ఈ ప్రోగ్రామ్‌ను అమలు చేయడానికి ఇక్కడ ప్రాథమిక సెటప్ రేఖాచిత్రం ఉంది.
సరళత కోసం మేము వ్యాసం అంతటా సిస్టమ్ A ని A_client మరియు సిస్టమ్ B ని B_ సర్వర్ అని పిలుస్తాము.
ఫైల్ అవసరాలు:
మాకు అవసరము server.py మరియు ఈ ఫైల్ సర్వర్ సిస్టమ్‌లో ఉండాలి. మా విషయంలో server.py B_server సిస్టమ్‌లో ఉండాలి.
మరో రెండు ఫైళ్లు client.py మరియు నమూనా. టెక్స్ట్ క్లయింట్ సిస్టమ్‌లో ఉండాలి. మా విషయంలో ఆ రెండు ఫైళ్లు A_client సిస్టమ్‌లో ఉండాలి.
అంచనాలు:
ఇక్కడ అంచనాలు ఉన్నాయి:
- మేము టెర్మినల్ యాక్సెస్‌తో రెండు లైనక్స్ సిస్టమ్‌లను కలిగి ఉండాలి.
- ఇష్టపడే లైనక్స్ రుచి ఉబుంటు .
- పైథాన్ 3 ఇన్‌స్టాల్ చేయాలి.
- రెండు లైనక్స్ సిస్టమ్‌లు ఒకదానికొకటి పింగ్ చేయగలవు. వా డు పింగ్ పింగ్ తనిఖీ చేయడానికి ఆదేశం.
- ఒక సిస్టమ్ సర్వర్‌గా మరియు ఇతర సిస్టమ్ ఒక నిర్దిష్ట సమయంలో క్లయింట్‌గా వ్యవహరించాలి.
పరిమితులు:
మేము మరింత ముందుకు వెళ్లే ముందు ఈ ప్రోగ్రామ్‌కు కొన్ని పరిమితులు ఉన్నాయని తెలుసుకోవాలి.
- ఈ ప్రోగ్రామ్‌ను అమలు చేయడానికి పైథాన్ 3+ ఇన్‌స్టాల్ చేయాలి. పైథాన్ పాత వెర్షన్‌లలో అమలు చేస్తే మీరు లోపం లేదా విభిన్న ప్రవర్తనను గమనించవచ్చు.
- ఇప్పటి వరకు ఈ ప్రోగ్రామ్ ద్వారా టెక్స్ట్ ఫైల్ మాత్రమే బదిలీ చేయబడుతుంది. టెక్స్ట్ లేని ఏదైనా ఇతర ఫార్మాట్ ఫైల్ విఫలం కావచ్చు.
- ప్రాథమిక ప్రోగ్రామింగ్ మినహాయింపులు ప్రోగ్రామ్‌లో నిర్వహించబడ్డాయి.
- ఉబుంటు కాకుండా ఇతర OS లో ప్రోగ్రామ్ రన్ కావచ్చు లేదా రన్ కాకపోవచ్చు.
- 1024 బైట్ల బఫర్ సైజ్ ఉపయోగించబడినందున క్లయింట్ వైపు టెక్స్ట్ ఫైల్ చిన్నదిగా ఉండాలి.
అవసరాలను సెటప్ చేయండి:
- ఈ ప్రోగ్రామ్‌ను ప్రయత్నించడానికి మాకు కనీసం ఒక లైనక్స్ సిస్టమ్ అవసరం. కానీ నెట్‌వర్క్ ద్వారా అనుసంధానించబడిన రెండు వేర్వేరు లైనక్స్ సిస్టమ్‌లను ఉపయోగించడం సిఫార్సు.
- ఈథర్నెట్ లేదా వై-ఫై లేదా ఏదైనా ఇతర కనెక్షన్‌ల ద్వారా రెండు సిస్టమ్‌లను కనెక్ట్ చేయాలి.
సర్వర్ సోర్స్ కోడ్:
https://github.com/linuxhintcode/websamples/blob/master/python_send_file/server.py
క్లయింట్ సోర్స్ కోడ్:
https://github.com/linuxhintcode/websamples/blob/master/python_send_file/client.py
ప్రోగ్రామ్‌లను మరియు ఊహించిన అవుట్‌పుట్‌ను ఎలా అమలు చేయాలి:
ప్రోగ్రామ్‌ను అమలు చేయడానికి ఇక్కడ దశలు ఉన్నాయి.
దశ 1: B_server సిస్టమ్‌కి వెళ్లి టెర్మినల్‌ని తెరవండి. టెర్మినల్ తెరవడానికి షార్ట్ కట్ Alt+Ctrl+t.
దశ 2: ఇప్పుడు server.py ఉన్న మార్గంలోకి వెళ్లండి.
స్టెప్ 3: ఇప్పుడు సర్వర్పై అమలు చేయండి
పైథాన్ 3 సర్వర్.పైఏ లోపాలు ఉండకూడదు మరియు మీరు దిగువ ప్రింట్‌లను చూడాలి
సర్వర్ పోర్ట్‌లో జాబితా చేయబడుతోంది: 9898కాపీ చేయబడిన ఫైల్ పేరు సర్వర్ వైపు recv.txt అవుతుంది
దశ 4: ఇప్పుడు A_client సిస్టమ్‌లో టెర్మినల్‌ని తెరవండి.
దశ 5: client.py మరియు నమూనా.టెక్స్ట్ ఉన్న మార్గానికి వెళ్లండి.
స్టెప్ 6: ఇప్పుడు client.py ని క్రింది విధంగా అమలు చేయండి
పైథాన్ 3 క్లయింట్.పై <B_ సర్వర్ సిస్టమ్ IP>మేము సర్వర్ యొక్క IP చిరునామాను తెలుసుకోవాలని మేము గమనించాము. B_server సిస్టమ్ యొక్క IP చిరునామాను తెలుసుకోవడానికి మేము దిగువ ఆదేశాన్ని అమలు చేయవచ్చు.
ifconfig
ఇప్పుడు A_client సిస్టమ్ యొక్క అవుట్‌పుట్ ఇలా ఉండాలి
###################################################| --------------------------------- |
హాయ్ క్లయింట్[IP చిరునామా: 192.168.1.102],
** సర్వర్‌కు స్వాగతం **
-సర్వర్
| --------------------------------- |
దశ 7: ఇప్పుడు B_server కి వెళ్లి దిగువ అవుట్‌పుట్ కోసం చూడండి
ఫైల్ విజయవంతంగా కాపీ చేయబడిందిసర్వర్ కనెక్షన్‌ను మూసివేసింది
దశ 8: సర్వర్ ఫోల్డర్ వద్ద ఒక ఫైల్ పేరు recv.txt ఉండాలి. ఈ recv.txt లోని కంటెంట్ ఒకే మాదిరిగా ఉండాలి. Txt.
కాబట్టి పైథాన్ ప్రోగ్రామ్ ద్వారా నెట్‌వర్క్ ద్వారా క్లయింట్ నుండి సర్వర్‌కు ఫైల్‌ను విజయవంతంగా కాపీ చేసాము.
కోడ్ వివరణలు:
రెండు పైథాన్ ఫైల్స్ ఉన్నాయి server.py మరియు client.py .
ఏదైనా కోడ్ server.py మరియు client.py లోపల ఒకేలా ఉంటే మేము ఒకసారి వివరిస్తామని గమనించండి.
- server.py:
ఇది షెబాంగ్ లైన్, అంటే డిఫాల్ట్‌గా ఈ server.py పైథాన్ 3 ని ఉపయోగించాలి. ఈ లైన్ యొక్క ఒక ప్రయోజనాన్ని చూద్దాం.
మేము server.py లేదా client.py వంటి వాటిని అమలు చేసాము పైథాన్ 3. ఇప్పుడు పైథాన్ 3 ని ఉపయోగించకుండా మనం పైథాన్ ఫైల్‌ను అమలు చేయవచ్చు. దిగువ ఆదేశాలను అనుసరించండి
సూపర్ యూజర్ మోడ్‌కు వెళ్లండి:
దాని.Py ఫైల్‌కు అన్ని అనుమతులు ఇవ్వండి:
chmod777సర్వర్పైServer.py రన్ చేయండి:
./ సర్వర్.పై దిగుమతి సాకెట్దిగుమతి చేస్తోందిసాకెట్పైథాన్ ప్రోగ్రామ్‌లోకి లైబ్రరీగామనము వెళ్తున్నాము
ఉపయోగించడానికిసాకెట్ కోసంకనెక్షన్
లు = సాకెట్.సాకెట్()
మేము ఒక వస్తువును సృష్టిస్తున్నాము లు సాకెట్ యొక్క అన్ని పద్ధతులను యాక్సెస్ చేయడానికి. ఇది OOP ల భావన.
పోర్ట్= 9898ఇప్పుడు మేము సర్వర్ వింటున్న ఒక పోర్టును ఎంచుకున్నాము. మేము దీనికి బదులుగా రిజర్వ్ చేయని పోర్టును ఉపయోగించవచ్చు.
లు.కట్టు(('',పోర్ట్))ఆ పోర్ట్ [9898] కు సర్వర్ ip చిరునామాను బంధించడానికి మేము బైండ్ పద్ధతిని ఉపయోగిస్తాము. ఒక పరిశీలన ఏమిటంటే, బైండ్ పద్ధతి యొక్క మొదటి ఆర్గ్యుమెంట్ స్థానంలో మేము సర్వర్ యొక్క ఖచ్చితమైన IP చిరునామాను ఉపయోగించుకోవచ్చు కానీ ఈ పని చక్కగా ఉన్నందున మేము ఖాళీగా ఉండాలని ఎంచుకున్నాము.
లు.కట్టు((IP చిరునామా,పోర్ట్))ఫైల్ = తెరవండి('recv.txt', 'wb')
మేము రైట్ మోడ్ కోసం సర్వర్‌లో ఒక ఫైల్ పేరు recv.txt ని తెరిచాము మరియు ఫైల్ పాయింటర్ పొందాము. మేము క్లయింట్ నుండి ఒక టెక్స్ట్ ఫైల్‌ని కాపీ చేయాల్సి ఉన్నందున ఇది అవసరం.
అయితే నిజమే:ఒక అనంతమైన పనిని ప్రారంభిద్దాం, సర్వర్ ఉద్యోగం 9888 పోర్ట్‌లో క్లయింట్ సర్వర్‌తో కమ్యూనికేట్ చేసే వరకు వేచి ఉండటం. కాబట్టి ఈ లూప్ అవసరం.
కనెక్ట్,addr=లు.అంగీకరించు()ఈ కోడ్ క్లయింట్ నుండి ఏదైనా ఇన్‌కమింగ్ కనెక్షన్ అభ్యర్థనను ఆమోదించడానికి. కాన్ ఉపయోగిస్తుంది కనెక్ట్ క్లయింట్‌తో కమ్యూనికేట్ చేయడానికి మరియు addr పోర్ట్ 9898 లో ఈ సర్వర్‌కు గందరగోళ అభ్యర్థనను పంపిన క్లయింట్ యొక్క IP చిరునామా.
సందేశం= ' n n| --------------------------------- | nహాయ్ క్లయింట్ [IP చిరునామా:'+ addr[0]+'], n** సర్వర్‌కు స్వాగతం ** n-సర్వర్ n
| --------------------------------- | n n n'
ఈ కోడ్ క్లయింట్‌కు పంపడానికి సందేశాన్ని సృష్టించడం. ఈ సందేశాన్ని క్లయింట్ టెర్మినల్‌లో ముద్రించాలి. క్లయింట్ సర్వర్‌తో కమ్యూనికేట్ చేయగలరని ఇది నిర్ధారిస్తుంది.
కనెక్ట్.పంపండి(సందేశం.ఎన్కోడ్())ఇప్పుడు మా వద్ద సందేశం సిద్ధంగా ఉంది, ఆపై దాన్ని ఉపయోగించి క్లయింట్‌కు పంపండి కనెక్ట్. ఈ కోడ్ వాస్తవానికి క్లయింట్‌కు సందేశాన్ని పంపుతుంది.
RecvData=కనెక్ట్.recv(1024)క్లయింట్ వైపు నుండి పంపబడిన ఏదైనా డేటాను ఈ కోడ్ అందుకుంటుంది. మా విషయంలో, నమూనా.టెక్స్ట్ లోని కంటెంట్ కోసం మేము ఎదురుచూస్తున్నాము RecvData .
అయితేRecvData:RecvData కండిషన్‌తో ఉన్న మరో లూప్ ఖాళీగా లేదు. మా విషయంలో అది ఖాళీగా లేదు.
ఫైల్.వ్రాయడానికి(RecvData)ఒకసారి మన లోపల కంటెంట్ ఉంది RecvData అప్పుడు మేము ఆ ఫైల్‌కు వ్రాస్తున్నాము recv.txt ఫైల్ పాయింటర్ ఉపయోగించి ఫైల్.
RecvData=కనెక్ట్.recv(1024)మళ్లీ క్లయింట్ నుండి ఏదైనా డేటా ఉంటే స్వీకరించడానికి ప్రయత్నిస్తోంది. ఒకసారి RecvData డేటా లేదు కోడ్ అయితే లూప్‌ను విచ్ఛిన్నం చేస్తుంది.
ఫైల్.దగ్గరగా()మేము ఫైల్ రైటర్ పూర్తి చేసినందున ఇది ఫైల్ పాయింటర్‌ను మూసివేస్తుంది.
కనెక్ట్.దగ్గరగా()ఇది క్లయింట్‌తో కనెక్షన్‌ను మూసివేస్తుంది.
విరామంఇది B_server వద్ద అనంతమైన సమయంలో లూప్ నుండి బయటకు రావాలి.
- client.py:
పైథాన్‌లో ఆర్గ్యుమెంట్ సదుపాయాన్ని ఉపయోగించాలనుకుంటున్నందున sys లైబ్రరీని దిగుమతి చేస్తోంది.
ఉంటే (లెన్(sys.argv) > 1):సర్వర్ఐపి= sys.argv[1]
లేకపోతే:
ముద్రణ(' n nఇలా పరిగెత్తండి npython3 client.py n n')
బయటకి దారి(1)
మేము నడుస్తున్నప్పుడు ఫైల్ పేరు client.py తర్వాత B_server యొక్క IP చిరునామాను పాస్ చేస్తున్నప్పుడు, మేము క్లయింట్ లోపల ఆ సర్వర్ IP చిరునామాను పట్టుకోవాలి.
.... సర్వర్ఐపి.
యూజర్ కనీసం ఒక ఆర్గ్యుమెంట్ కోడ్ పాస్ చేయకపోతే సహాయం చూపిస్తుంది మరియు కోడ్ నుండి బయటకు వస్తుంది.
పోర్ట్= 9898ఇది B_server వైపు పేర్కొన్న విధంగానే ఉండాలి.
లు.కనెక్ట్((సర్వర్ఐపి,పోర్ట్))ఈ కోడ్ ఆ పోర్ట్‌తో సర్వర్ IP కి TCP కనెక్షన్ చేస్తుంది. ఈ పోనింట్‌లో ఏదైనా తప్పు జరిగితే కనెక్షన్‌లో వైఫల్యాలు ఏర్పడతాయి.
ఫైల్ = తెరవండి('నమూనా. టెక్స్ట్', 'rb')కంటెంట్‌ను మాత్రమే చదవడానికి మేము నమూనా.టిఎక్స్‌టిని రీడ్ మోడ్‌లో తెరుస్తున్నాము.
SendData= ఫైల్.చదవండి(1024)ఫైల్ కంటెంట్‌ను చదవడం మరియు లోపల పెట్టడం SendData వేరియబుల్.
అయితేపంపు డేటా:ఒకవేళ లూప్ అయితే ఒకటి ప్రారంభిస్తున్నాము SendData డేటా ఉంది. మా విషయంలో నమూనా.టెక్స్ట్ ఖాళీగా లేకుంటే దానికి డేటా ఉండాలి.
లు.పంపండి(SendData)ఇప్పుడు మేము కంటెంట్‌ను పంపవచ్చు నమూనా. టెక్స్ట్ సాకెట్ వస్తువును ఉపయోగించి సర్వర్‌కు లు.
SendData= ఫైల్.చదవండి(1024)ఏదైనా మిగిలి ఉంటే మళ్లీ చదవండి. కాబట్టి ఫైల్ నుండి చదవడానికి ఏమీ ఉండదు SendData ఖాళీగా ఉంటుంది మరియు అది లూప్ నుండి బయటకు వస్తుంది.
లు.దగ్గరగా()ఇది క్లయింట్ వైపు నుండి కనెక్షన్‌ను మూసివేయదు.
ఉబుంటు స్క్రీన్ షాట్స్ సర్వర్ వైపు
ఉబుంటు స్క్రీన్ షాట్స్ క్లయింట్ వైపు
పరీక్షించిన కలయికలు:
- Linux సర్వర్‌గా మరియు Linux క్లయింట్‌గా: PASS
- Linux క్లయింట్‌గా మరియు Linux సర్వర్‌గా: PASS
- Linux సర్వర్‌గా మరియు Windows10 క్లయింట్‌గా: PASS
- Linux క్లయింట్‌గా మరియు Windows10 సర్వర్‌గా: PASS
సర్వర్ మరియు క్లయింట్ కోసం రెండు లైనక్స్ సిస్టమ్‌లను ఉపయోగించడం సిఫార్సు.
ఆశించిన లోపాలు:
- 9898 పోర్టులో సర్వర్ రన్ కాకపోతే మీరు ఈ క్రింది లోపాన్ని చూడవచ్చు
ట్రేస్‌బ్యాక్ (ఇటీవలి కాల్ చివరిది):
ఫైల్'client.py',లైన్22, లో <మాడ్యూల్>లు.కనెక్ట్((సర్వర్ఐపి,పోర్ట్))
కనెక్షన్ తిరస్కరణ లోపం:[ఎర్నో111]కనెక్షన్ తిరస్కరించబడింది
- IP చిరునామా క్లయింట్ వైపు పాస్ చేయకపోతే దిగువ లోపం కనిపిస్తుంది
ఇలా పరిగెత్తండి
పైథాన్ 3 క్లయింట్.పై <సర్వీప్ చిరునామా>- 1 ఉంటే కింది లోపం కనిపిస్తుందిసెయింట్క్లయింట్ వైపు వాదన IP చిరునామా కాదు
ట్రేస్‌బ్యాక్ (ఇటీవలి కాల్ చివరిది):
ఫైల్'client.py',లైన్22, లో <మాడ్యూల్>లు.కనెక్ట్((సర్వర్ఐపి,పోర్ట్))
సాకెట్.గైరర్:[ఎర్నో -2]పేరులేదాసేవకాదుతెలిసిన
- పోర్ట్ 98980 లాగా ఉపయోగించినట్లయితే దిగువ లోపం కనిపిస్తుంది
ట్రేస్‌బ్యాక్ (ఇటీవలి కాల్ చివరిది):
ఫైల్'client.py',లైన్22, లో <మాడ్యూల్>లు.కనెక్ట్((సర్వర్ఐపి,పోర్ట్))
ఓవర్‌ఫ్లో ఎర్రర్: getsockaddrarg: పోర్ట్ ఉండాలి0-65535.
- నమూనా.టెక్స్ట్ క్లయింట్ వైపు లేనట్లయితే దిగువ లోపం కనిపిస్తుంది.
ట్రేస్‌బ్యాక్ (ఇటీవలి కాల్ చివరిది):
ఫైల్'client.py',లైన్25, లో <మాడ్యూల్>ఫైల్ = తెరవండి('నమూనా. టెక్స్ట్', 'rb')
FileNotFoundError:[ఎర్నో2]అలాంటిది లేదుఫైల్ లేదాడైరెక్టరీ:'నమూనా. టెక్స్ట్'
ముగింపు:
ఈ ప్రోగ్రామ్‌ని ఉపయోగించి మనం పైథాన్ ప్రోగ్రామ్‌ని ఉపయోగించి నెట్‌వర్క్ ద్వారా ఒక సిస్టమ్ నుండి మరొక సిస్టమ్‌కు ఒక సాధారణ టెక్స్ట్ ఫైల్‌ను పంపవచ్చు. ఇది నెట్‌వర్క్ ద్వారా డేటాను పంపడానికి కూడా పైథాన్ మరియు సాకెట్ ప్రోగ్రామింగ్ గురించి ప్రాథమికంగా నేర్చుకుంటుంది.