Писане на софтуер с функционалността на Windows клиент-сървър помощни програми, част 02

Продължавайки продължаващата поредица от статии, посветени на потребителски реализации на конзолни помощни програми на Windows, не можем да не се докоснем до TFTP (Trivial File Transfer Protocol) - прост протокол за прехвърляне на файлове.

Както миналия път, нека прегледаме накратко теорията, вижте кода, който изпълнява функционалност, подобна на необходимата, и го анализирайте. Повече детайли - под кройката

Няма да копирам и поставям референтна информация, връзки към която традиционно могат да бъдат намерени в края на статията, ще кажа само, че в основата си TFTP е опростен вариант на FTP протокола, в който настройката за контрол на достъпа има е премахнат и всъщност тук няма нищо освен команди за получаване и прехвърляне на файл. Въпреки това, за да направим нашата реализация малко по-елегантна и адаптирана към настоящите принципи на писане на код, синтаксисът е леко променен - ​​това не променя принципите на работа, но интерфейсът, IMHO, става малко по-логичен и съчетава положителните аспекти на FTP и TFTP.

По-специално, когато се стартира, клиентът изисква IP адреса на сървъра и порта, на който е отворен персонализираният TFTP (поради несъвместимост със стандартния протокол, сметнах за подходящо да оставя на потребителя възможността да избира порт), след което възниква връзка, в резултат на което клиентът може да изпрати една от командите - get или put, за получаване или изпращане на файл към сървъра. Всички файлове се изпращат в двоичен режим, за да се опрости логиката.

За да реализирам протокола, традиционно използвах 4 класа:

• TFTPClient
• TFTPSървър
• TFTPClientTester
• TFTPServerTester

Поради факта, че класовете за тестване съществуват само за отстраняване на грешки в основните, няма да ги анализирам, но кодът ще бъде в хранилището; връзката към него може да бъде намерена в края на статията. Сега ще разгледам основните класове.

TFTPClient

Задачата на този клас е да се свърже с отдалечен сървър чрез неговия ip и номер на порт, да прочете команда от входния поток (в този случай клавиатурата), да я анализира, да я прехвърли на сървъра и в зависимост от това дали трябва да изпратите или получите файл, да го прехвърлите или получите.

Кодът за стартиране на клиента за свързване към сървъра и изчакване на команда от входния поток изглежда така. Редица глобални променливи, които се използват тук, са описани извън статията, в пълния текст на програмата. Поради тяхната тривиалност не ги цитирам, за да не натоварвам статията.

 public void run(String ip, int port)
    {
        this.ip = ip;
        this.port = port;
        try {
            inicialization();
            Scanner keyboard = new Scanner(System.in);
            while (isRunning) {
                getAndParseInput(keyboard);
                sendCommand();
                selector();
                }
            }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

Нека да разгледаме методите, извикани в този блок код:

Тук се изпраща файлът - с помощта на скенер представяме съдържанието на файла като масив от байтове, които записваме един по един в сокета, след което го затваряме и отваряме отново (не е най-очевидното решение, но гарантира освобождаването на ресурси), след което показваме съобщение за успешно прехвърляне.

private  void put(String sourcePath, String destPath)
    {

        File src = new File(sourcePath);
        try {

            InputStream scanner = new FileInputStream(src);
            byte[] bytes = scanner.readAllBytes();
            for (byte b : bytes)
                sout.write(b);
            sout.close();
            inicialization();
            System.out.println("nDonen");
            }

        catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

Този кодов фрагмент описва извличането на данни от сървъра. Всичко отново е тривиално, само първият блок от код представлява интерес. За да разберете точно колко байта трябва да бъдат прочетени от сокета, трябва да знаете колко тежи прехвърленият файл. Размерът на файла на сървъра е представен като дълго цяло число, така че тук се приемат 4 байта, които впоследствие се преобразуват в едно число. Това не е много подход на Java, той е доста подобен за SI, но решава проблема му.

Тогава всичко е тривиално - получаваме известен брой байтове от сокета и ги записваме във файл, след което показваме съобщение за успех.

   private void get(String sourcePath, String destPath){
        long sizeOfFile = 0;
        try {


            byte[] sizeBytes = new byte[Long.SIZE];
           for (int i =0; i< Long.SIZE/Byte.SIZE; i++)
           {
               sizeBytes[i] = (byte)sin.read();
               sizeOfFile*=256;
               sizeOfFile+=sizeBytes[i];
           }

           FileOutputStream writer = new FileOutputStream(new File(destPath));
           for (int i =0; i < sizeOfFile; i++)
           {
               writer.write(sin.read());
           }
           writer.close();
           System.out.println("nDONEn");
       }
       catch (Exception e){
            System.out.println(e.getMessage());
       }
    }

Ако в прозореца на клиента е въведена команда, различна от get или put, ще бъде извикана функцията showErrorMessage, което показва, че въвеждането е неправилно. Поради тривиалност няма да го цитирам. Малко по-интересна е функцията за получаване и разделяне на входния низ. Прекарваме скенера в него, от който очакваме да получим ред, разделен с два интервала и съдържащ командата, адреса на източника и адреса на дестинацията.

    private void getAndParseInput(Scanner scanner)
    {
        try {

            input = scanner.nextLine().split(" ");
            typeOfCommand = input[0];
            sourcePath = input[1];
            destPath = input[2];
        }
        catch (Exception e) {
            System.out.println("Bad input");
        }
    }

Изпращане на команда—предава въведената от скенера команда към сокета и принуждава да бъде изпратена

    private void sendCommand()
    {
        try {

            for (String str : input) {
                for (char ch : str.toCharArray()) {
                    sout.write(ch);
                }
                sout.write(' ');
            }
            sout.write('n');
        }
        catch (Exception e) {
            System.out.print(e.getMessage());
        }
    }

Селекторът е функция, която определя действията на програмата в зависимост от въведения низ. Всичко тук не е много красиво и използваният трик не е най-добрият с принудително излизане извън кодовия блок, но основната причина за това е липсата в Java на някои неща, като делегати в C#, указатели на функции от C++ или в най-малко ужасното и ужасно goto, което ви позволява да приложите това красиво. Ако знаете как да направите кода малко по-елегантен, приветствам критиките в коментарите. Струва ми се, че тук е необходим речник String-delegate, но няма делегат...

    private void selector()
    {
        do{
            if (typeOfCommand.equals("get")){
                get(sourcePath, destPath);
                break;
            }
            if (typeOfCommand.equals("put")){
                put(sourcePath, destPath);
                break;
            }
            showErrorMessage();
        }
        while (false);
    }
}

TFTPSървър

Функционалността на сървъра се различава от функционалността на клиента като цяло само по това, че командите идват към него не от клавиатурата, а от сокета. Някои от методите като цяло са еднакви, така че няма да ги цитирам, а само ще засегна разликите.

За начало се използва методът run, който получава порт като вход и обработва входните данни от сокета във вечен цикъл.

    public void run(int port) {
            this.port = port;
            incialization();
            while (true) {
                getAndParseInput();
                selector();
            }
    }

Методът put, който обвива метода writeToFileFromSocket, който отваря поток за запис във файл и записва всички входни байтове от сокета, показва съобщение, указващо успешното завършване на прехвърлянето, когато записът приключи.

    private  void put(String source, String dest){
            writeToFileFromSocket();
            System.out.print("nDonen");
    };
    private void writeToFileFromSocket()
    {
        try {
            FileOutputStream writer = new FileOutputStream(new File(destPath));
            byte[] bytes = sin.readAllBytes();
            for (byte b : bytes) {
                writer.write(b);
            }
            writer.close();
        }
        catch (Exception e){
            System.out.println(e.getMessage());
        }
    }

Методът get извлича сървърния файл. Както вече беше споменато в раздела от клиентската страна на програмата, за да прехвърлите успешно файл, трябва да знаете размера му, съхранен в дълго цяло число, така че го разделям на масив от 4 байта, прехвърлям ги байт по байт към сокета и след това, след като ги получих и сглобих на клиента в номер обратно, прехвърлям всички байтове, които съставят файла, прочетени от входния поток от файла.

 private  void get(String source, String dest){
        File sending = new File(source);
        try {
            FileInputStream readFromFile = new FileInputStream(sending);
            byte[] arr = readFromFile.readAllBytes();
            byte[] bytes = ByteBuffer.allocate(Long.SIZE / Byte.SIZE).putLong(sending.length()).array();
            for (int i = 0; i<Long.SIZE / Byte.SIZE; i++)
                sout.write(bytes[i]);
            sout.flush();
            for (byte b : arr)
                sout.write(b);
        }
        catch (Exception e){
            System.out.println(e.getMessage());
        }
    };

Методът getAndParseInput е същият като в клиента, като единствената разлика е, че чете данни от сокета, а не от клавиатурата. Кодът е в хранилището, точно като селектор.
В този случай инициализацията се поставя в отделен блок код, т.к в рамките на тази реализация, след като прехвърлянето приключи, ресурсите се освобождават и заемат отново - отново, за да се осигури защита срещу изтичане на памет.

    private void  incialization()
    {
        try {
            serverSocket = new ServerSocket(port);
            socket = serverSocket.accept();
            sin = socket.getInputStream();
            sout = socket.getOutputStream();
        }
        catch (Exception e) {
            System.out.print(e.getMessage());
        }
    }

Да обобщим:

Току-що написахме нашия собствен вариант на прост протокол за пренос на данни и разбрахме как трябва да работи. По принцип не открих Америка тук и не написах много нови неща, но нямаше подобни статии на Habré и ​​като част от писането на поредица от статии за cmd помощни програми беше невъзможно да не се докосна до него.

за справка:

Хранилище на изходния код
Накратко за TFTP
Същото нещо, но на руски

Източник: www.habr.com