ક્લાયંટ-સર્વર ઉપયોગિતા કાર્યક્ષમતા સાથે લેખન સોફ્ટવેર Windows, ભાગ ૦૧

કન્સોલ ઉપયોગિતાઓના કસ્ટમ અમલીકરણોને સમર્પિત લેખોની શ્રેણી ચાલુ રાખીએ છીએ Windows TFTP (ટ્રિવિયલ ફાઇલ ટ્રાન્સફર પ્રોટોકોલ) નો ઉલ્લેખ ન કરવો અશક્ય છે - એક સરળ ફાઇલ ટ્રાન્સફર પ્રોટોકોલ.

ગયા વખતની જેમ, આપણે સિદ્ધાંતની ટૂંકમાં સમીક્ષા કરીશું, જરૂરી કોડ જેવી જ કાર્યક્ષમતા લાગુ કરતો કોડ જોઈશું અને તેનું વિશ્લેષણ કરીશું. વધુ વિગતો નીચે.

હું સંદર્ભ માહિતી કોપી-પેસ્ટ નહીં કરું, જેની લિંક્સ પરંપરાગત રીતે લેખના અંતે મળી શકે છે. હું ફક્ત એટલું જ કહીશ કે TFTP એ મૂળભૂત રીતે FTP પ્રોટોકોલનું એક સરળ સંસ્કરણ છે, જે ઍક્સેસ નિયંત્રણ સેટિંગ્સને દૂર કરે છે અને તેમાં ફાઇલ ટ્રાન્સફર અને પુનઃપ્રાપ્તિ આદેશો સિવાય બીજું કંઈ નથી. જો કે, અમારા અમલીકરણને થોડું વધુ ભવ્ય અને આધુનિક કોડિંગ સિદ્ધાંતો અનુસાર અનુકૂલનક્ષમ બનાવવા માટે, વાક્યરચનામાં થોડો ફેરફાર કરવામાં આવ્યો છે. આ ઓપરેટિંગ સિદ્ધાંતોને બદલતું નથી, પરંતુ મારા મતે, ઇન્ટરફેસ થોડું વધુ તાર્કિક બને છે અને FTP અને TFTP ના સકારાત્મક પાસાઓને જોડે છે.

ખાસ કરીને, લોન્ચ થયા પછી, ક્લાયંટ સર્વરના IP સરનામાં અને કસ્ટમ TFTP ખુલ્લું હોય તેવા પોર્ટની વિનંતી કરે છે (માનક પ્રોટોકોલ સાથે અસંગતતાને કારણે, મેં પોર્ટ પસંદગી વપરાશકર્તા પર છોડી દેવાનું યોગ્ય માન્યું). ત્યારબાદ એક કનેક્શન સ્થાપિત થાય છે, જે ક્લાયંટને સર્વર પર ફાઇલ પુનઃપ્રાપ્ત કરવા અથવા મોકલવા માટે - મેળવો અથવા પુટ - આદેશોમાંથી એક મોકલવાની મંજૂરી આપે છે. લોજિકને સરળ બનાવવા માટે બધી ફાઇલો બાઈનરી મોડમાં મોકલવામાં આવે છે.

પ્રોટોકોલ અમલમાં મૂકવા માટે, મેં પરંપરાગત રીતે 4 વર્ગોનો ઉપયોગ કર્યો:

• TFTPClientName
• TFTPServerName
• TFTPClientTesterName
• TFTPServerTesterName

ટેસ્ટ ક્લાસ ફક્ત મુખ્ય ક્લાસને ડીબગ કરવા માટે જ અસ્તિત્વમાં હોવાથી, હું તેમાં જઈશ નહીં. કોડ રિપોઝીટરીમાં હશે; તેની લિંક લેખના અંતે મળી શકે છે. હું હવે મુખ્ય ક્લાસને આવરી લઈશ.

TFTPClientName

આ વર્ગનું કાર્ય રિમોટ સર્વર સાથે તેના 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());
        }
    }

આ કોડ ફ્રેગમેન્ટ સર્વરમાંથી ડેટા પ્રાપ્ત કરવાનું વર્ણન કરે છે. ફરીથી, બધું જ નજીવું છે; ફક્ત કોડનો પહેલો બ્લોક રસપ્રદ છે. સોકેટમાંથી કેટલા બાઇટ વાંચવાની જરૂર છે તે બરાબર સમજવા માટે, આપણે ટ્રાન્સફર થઈ રહેલી ફાઇલનું કદ જાણવાની જરૂર છે. સર્વર પર ફાઇલનું કદ લાંબા પૂર્ણાંક તરીકે દર્શાવવામાં આવે છે, તેથી અહીં ચાર બાઇટ પ્રાપ્ત થાય છે, જે પછીથી એક જ સંખ્યામાં રૂપાંતરિત થાય છે. આ ખૂબ જાવા જેવો અભિગમ નથી; તે વધુ C-જેવો અભિગમ છે, પરંતુ તે કામ પૂર્ણ કરે છે.

પછી બધું જ નજીવું છે - આપણે સોકેટમાંથી જાણીતી સંખ્યામાં બાઇટ મેળવીએ છીએ અને તેને ફાઇલમાં લખીએ છીએ, ત્યારબાદ આપણે સફળતાનો સંદેશ પ્રદર્શિત કરીએ છીએ.

   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());
        }
    }

સિલેક્ટર એ એક ફંક્શન છે જે ઇનપુટ સ્ટ્રિંગના આધારે પ્રોગ્રામની ક્રિયાઓ નક્કી કરે છે. તે ખૂબ જ ભવ્ય નથી અને કોડને બ્લોકમાંથી બહાર નીકળવા માટે દબાણ કરવાની એક અસંસ્કારી તકનીકનો ઉપયોગ કરે છે, પરંતુ તેનું મુખ્ય કારણ એ છે કે જાવામાં ચોક્કસ સુવિધાઓનો અભાવ છે, જેમ કે C# માં ડેલિગેટ્સ, C++ માં ફંક્શન પોઇન્ટર્સ, અથવા તો ભયાનક ગોટો, જે વધુ ભવ્ય અમલીકરણ માટે પરવાનગી આપશે. જો તમે કોડને થોડો વધુ ભવ્ય કેવી રીતે બનાવવો તે જાણો છો, તો કૃપા કરીને ટિપ્પણીઓમાં તમારા વિચારો શેર કરો. મને લાગે છે કે અહીં સ્ટ્રિંગ-ડેલિગેટ શબ્દકોશની જરૂર છે, પરંતુ કોઈ ડેલિગેટ નથી...

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

TFTPServerName

સર્વરની કાર્યક્ષમતા ક્લાયંટની કાર્યક્ષમતાથી અલગ છે, મૂળભૂત રીતે ફક્ત તેમાં આદેશો કીબોર્ડ કરતાં સોકેટ દ્વારા પ્રાપ્ત થાય છે. કેટલીક પદ્ધતિઓ વાસ્તવમાં સમાન છે, તેથી હું તેમને અહીં આવરી લઈશ નહીં; હું ફક્ત તફાવતો પર સ્પર્શ કરીશ.

પ્રોગ્રામ શરૂ કરવા માટે, રન પદ્ધતિનો ઉપયોગ થાય છે, જે ઇનપુટ તરીકે પોર્ટ મેળવે છે અને સોકેટમાંથી ઇનપુટ ડેટાને અનંત લૂપમાં પ્રક્રિયા કરે છે.

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

પુટ પદ્ધતિ, જે 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());
        }
    }

ગેટ પદ્ધતિ સર્વર ફાઇલને પુનઃપ્રાપ્ત કરે છે. ક્લાયંટ-સાઇડ વિભાગમાં જણાવ્યા મુજબ, ફાઇલને સફળતાપૂર્વક સ્થાનાંતરિત કરવા માટે, મારે તેનું કદ જાણવાની જરૂર છે, જે લાંબા પૂર્ણાંક તરીકે સંગ્રહિત છે. તેથી, હું તેને 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