Avsikten med denna artikel är att lära sig hur man överför en textfil över nätverket via python-programmet. Denna filöverföring baseras på serverklientmodellen för att använda sockelprogrammering i python3+.

Grundläggande inställningsdiagram:

Här är det grundläggande inställningsdiagrammet för att köra detta program.

För enkelhetens skull kommer vi att kalla System A som A_client och System B som B_server genom hela artikeln.

Filkrav:

Vi behöver server.py och den här filen ska finnas på serversystemet. I vårt fall server.py ska vara på B_server-systemet.

Ytterligare två filer klient.py och prov.Text bör vara närvarande i klientsystemet. I vårt fall bör dessa två filer finnas på A_client-systemet.

Antaganden:

Här är antagandena:

Vi borde ha två Linux-system med terminalåtkomst.
Föredragen Linux-smak är Ubuntu.
Python3 bör installeras.
Båda Linux-systemen borde kunna pinga varandra. Använda sig av ping kommando för att kontrollera ping.
Ett system ska fungera som server och det andra systemet ska fungera som klient vid en viss tidpunkt.

Begränsningar:

Innan vi går vidare bör vi veta att det finns vissa begränsningar i detta program.

Python3 + bör installeras för att köra programmet. Du kan observera fel eller annat beteende om du kör på äldre versioner av Python.
Endast textfiler kan överföras via detta program från och med nu. Alla andra formatfiler som inte innehåller text kan misslyckas.
Grundläggande programmeringsundantag har hanterats i programmet.
Programmet kan eller kanske inte köras på annat operativsystem än Ubuntu.
Textfilen ska vara kort på klientsidan eftersom buffertstorlek på 1024 byte har använts.

Ställ in krav:

Vi behöver minst ett Linux-system för att testa det här programmet. Men rekommendationen är att använda två olika Linux-system som är anslutna via nätverk.
Två system ska anslutas via Ethernet eller Wi-Fi eller andra anslutningar.

Serverkällkod:

https: // github.com / linuxhintcode / webbprover / blob / master / python_send_file / server.py

Kundens källkod:

https: // github.com / linuxhintcode / webbprover / blob / master / python_send_file / client.py

Hur man kör program och förväntad produktion:

Här är stegen för att köra programmet.

Steg 1: Gå till B_server-systemet och öppna en terminal. Genväg för att öppna en terminal är Alt + Ctrl + t.

Steg 2: Gå nu vägen där servern.py är närvarande.

Steg 3: Kör nu servern.py som nedan

python3-server.py

Det borde inte finnas några fel och du bör se utskrifterna nedan

Servern noterar på port: 9898

Kopierat filnamn kommer att recv.txt på serversidan

Steg 4: Öppna nu terminalen vid A_client-systemet.

Steg 5: Gå till sökvägen där klienten.py och prov.txt är närvarande.

Steg 6: Kör nu klienten.py som nedan

python3-klient.py

Vi har observerat att vi behöver känna till serverns IP-adress. Vi kan utföra kommandot nedan för att känna till IP-adressen till B_server-systemet.

ifconfig

Nu ska utdata från A_client-systemet vara så här

#################### Nedanstående meddelande tas emot från servern ######################
| --------------------------------- |
Hej klient [IP-adress: 192.168.1.102],
** Välkommen till Server **
-Server
| ---------------------------------

Steg 7: Gå nu till B_server och leta efter utdata nedan

Filen har kopierats
Servern stängde förbindelsen

Steg 8: Det bör finnas ett filnamn recv.txt i servermappen. Innehållet i denna recv.txt ska vara samma exempel.Text.

Så vi har framgångsrikt kopierat en fil från klient till server via nätverk via python-program.

Kodförklaringar:

Det finns två pythonfiler server.py och klient.py.

Observera att vi kommer att förklara en gång om någon kod är densamma i servern.py och klient.py.

server.py:

#!/ usr / bin / env python3

Det här är shebang-linjen vilket betyder som standard denna server.py ska använda python3. Låt oss se en fördel med denna linje.

Vi har kört servern.py eller klient.py som python3 <.py file name>. Nu utan att använda python3 kan vi köra python-filen. Följ kommandona nedan

Gå till superanvändarläge:

Ge all tillåtelse till .py-fil:

chmod 777-server.py

Kör server.py:

./ server.py importuttag
Importerar sockelbiblioteket till pythonprogrammet när vi ska
att använda uttaget för anslutning.
s = uttag.uttag()

Vi skapar ett objekt “S” för att komma åt alla metoder för uttaget. Detta är ett OOP-koncept.

PORT = 9898

Nu väljer vi en port där servern ska lyssna. Vi kan använda icke-reserverad port istället för detta.

s.bind ((", PORT))

Vi använder bindningsmetoden för att binda server-ip-adressen till den porten [9898]. En observation är att vi kunde ha använt serverns exakta IP-adress istället för första argumentet för bindningsmetoden men vi väljer att lämna tomt eftersom det här fungerar bra.

s.bind ((IP-adress, PORT))
fil = öppen ("recv.txt "," wb ")

Vi har öppnat ett filnamn “recv.txt ”i servern för skrivläge och fick filpekare. Detta krävs eftersom vi måste kopiera en textfil från klienten.

medan det är sant:

Låt oss starta ett oändligt under loop eftersom serverns jobb är att vänta tills en klient kommunicerar med servern på den 9898-porten. Så detta medan loop krävs.

anslut, addr = s.acceptera()

Denna kod är för att acceptera alla inkommande anslutningsförfrågningar från klienten. Conn kommer att använda “ansluta ” att kommunicera med klienten och “Addr” är IP-adressen till klienten som har skickat uppståndelseförfrågan till denna server på port 9898.

msg = "\ n \ n | --------------------------------- | \ n Hej klient [IP-adress:
"+ addr [0] +"], \ n ** Välkommen till Server ** \ n -Server \ n
| --------------------------------- | \ n \ n \ n "

Den här koden är för att skapa ett meddelande som ska skickas till klienten. Detta meddelande ska skrivas ut på klientterminalen. Detta bekräftar att klienten kan kommunicera med servern.

anslutning.skicka (msg.koda())

Nu har vi meddelandet klart och skickar det sedan till klienten med det "Ansluta". Den här koden skickar faktiskt meddelande till klienten.

RecvData = anslut.recv (1024)

Den här koden tar emot all data som skickas från klientsidan. I vårt fall förväntar vi oss innehållet i provet.txt in “RecvData”.

medan RecvData:

Ytterligare en loop medan villkoret RecvData inte är tomt. I vårt fall är det inte tomt.

fil.skriv (RecvData)

När vi väl har innehåll inuti “RecvData” då skriver vi till den filen “Recv.Text" med filpekaren "fil".

RecvData = anslut.recv (1024)

Återigen försöker ta emot om det finns data från klienten. En gång “RecvData” har inga data koden kommer att bryta medan loop.

fil.stänga()

Detta stänger bara filpekaren när vi är klara med att skriva.

anslutning.stänga()

Detta stänger anslutningen till klienten.

ha sönder

Detta är att komma ut från oändligt medan loop på B_server.

klient.py:

importera sys

Importera sys-biblioteket som vi vill använda argumentfaciliteten i python.

if (len (sys.argv)> 1):
ServerIp = sys.argv [1]
annan:
print ("\ n \ n Kör som \ n python3-klient.py < serverip address > \ n \ n ")
utgång (1)

När vi skickar IP-adressen till B_server efter filnamnsklienten.när vi kör måste vi fånga serverns IP-adress inuti klienten.

... if (len (sys.argv)> 1): => För att säkerställa att användaren skickar minst ett argument som IP-adress och fångar den IP-adressen insdie “ServerIP”.

Om användaren inte skickar åtminstone en argumentkod visar hjälp och kommer ut från koden.

PORT = 9898

Detta måste vara samma port som nämnts på B_serversidan.

s.anslut ((ServerIp, PORT))

Denna kod kommer att göra TCP-anslutning till serverns IP med den porten. Något fel på denna ponint resulterar i fel i anslutningen.

file = open ("exempel.txt "," rb ")

Vi öppnar ”prov.txt ”i läsläge för att bara läsa innehåll.

SendData = fil.läs (1024)

Läser innehållet i filen och lägger in "Skicka data" variabel.

medan SendData:

Vi börjar en stund-loop om “Skicka data" har data. I vårt fall om “prov.txt ”är inte tom den borde ha data.

s.skicka (SendData)

Nu kan vi skicka innehåll av "prov.Text" till server med sockelobjekt “S”.

SendData = fil.läs (1024)

Läs igen om det finns något kvar. Så det kommer inte att finnas något att läsa från filen "Skicka data" kommer att vara tom och den kommer ut från en loop.

s.stänga()

Detta stänger inte anslutningen från klientsidan.

Ubuntu Screenshots Serversida

Ubuntu Screenshots Client-sida

Testade kombinationer:

Linux som server och Linux som klient: PASS
Linux som klient och Linux som server: PASS
Linux som server och Windows10 som klient: PASS
Linux som klient och Windows10 som server: PASS

Rekommendationen är att använda två Linux-system för server och klient.

Förväntade fel:

Du kan se nedan fel om servern inte körs på 9898-porten

Spårning (senaste samtalet senast):

Fil "klient.py ", rad 22, in
s.anslut ((ServerIp, PORT))
ConnectionRefusedError: [Errno 111] Anslutning nekad

Nedanstående fel visas om IP-adressen inte skickas på klientsidan

Kör som

python3-klient.py < serverip address >

Nedanstående fel visas om 1^st argument på klientsidan är inte en IP-adress

Spårning (senaste samtalet senast):

Fil "klient.py ", rad 22, in
s.anslut ((ServerIp, PORT))
uttag.gaierror: [Errno -2] Namn eller tjänst känd inte

Nedan visas fel om port används som 98980

Spårning (senaste samtalet senast):

Fil "klient.py ", rad 22, in
s.anslut ((ServerIp, PORT))
OverflowError: getsockaddrarg: port måste vara 0-65535.

Nedanstående fel visas om “exempel.txt ”finns inte på klientsidan.

Spårning (senaste samtalet senast):

Fil "klient.py ", rad 25, in
file = open ("exempel.txt "," rb ")
FileNotFoundError: [Errno 2] Ingen sådan fil eller katalog: 'exempel.Text'

Slutsats:

Med hjälp av detta program kan vi skicka en enkel textfil från ett system till ett annat system via nätverk med hjälp av python-program. Detta ger oss grundläggande inlärning av python- och sockelprogrammering också för att skicka data via nätverk.

Python Socket File Transfer Skicka

Grundläggande inställningsdiagram:

Filkrav:

Antaganden:

Begränsningar:

Ställ in krav:

Serverkällkod:

Kundens källkod:

Hur man kör program och förväntad produktion:

Ubuntu Screenshots Serversida

Ubuntu Screenshots Client-sida

Testade kombinationer:

Förväntade fel:

Slutsats: