##// END OF EJS Templates
schain
RSS
refresh
joabAM -
r1292:d21a875a7d98
parent child
Show More
Side by Side Unified
Context file:
r1292:d21a875a7d98 Loading diff...:

The requested changes are too big and content was truncated. Show full diff

Show file before | Show file after | Hide comments
1 NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
Show file before | Show file after | Hide comments
@@ -1,1008 +1,1011
1 1 '''
2 2 @author: Daniel Suarez
3 3 '''
4 4 import os
5 5 import glob
6 6 import ftplib
7 7
8 8 try:
9 9 import paramiko
10 10 import scp
11 11 except:
12 12 print("You should install paramiko and scp libraries \nif you want to use SSH protocol to upload files to the server")
13 13
14 14 import time
15 15
16 16 import threading
17 17 Thread = threading.Thread
18 18
19 19 # try:
20 20 # from gevent import sleep
21 21 # except:
22 22 from time import sleep
23 23
24 24 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
25 25 @MPDecorator
26 26 class Remote(Thread):
27 27 """
28 28 Remote is a parent class used to define the behaviour of FTP and SSH class. These clases are
29 29 used to upload or download files remotely.
30 30
31 31 Non-standard Python modules used:
32 32 None
33 33
34 34 Written by:
35 35 "Miguel Urco":mailto:miguel.urco@jro.igp.gob.pe Jun. 03, 2015
36 36 """
37 37
38 38 server = None
39 39 username = None
40 40 password = None
41 41 remotefolder = None
42 42
43 43 period = 60
44 44 fileList = []
45 45 bussy = False
46 46
47 47 def __init__(self, server, username, password, remotefolder, period=60):
48 48
49 49 Thread.__init__(self)
50 50
51 51 self.setDaemon(True)
52 52
53 53 self.status = 0
54 54
55 55 self.__server = server
56 56 self.__username = username
57 57 self.__password = password
58 58 self.__remotefolder = remotefolder
59 59
60 60 self.period = period
61 61
62 62 self.fileList = []
63 63 self.bussy = False
64 64
65 65 self.stopFlag = False
66 66
67 67 print("[Remote Server] Opening server: %s" %self.__server)
68 68 if self.open(self.__server, self.__username, self.__password, self.__remotefolder):
69 69 print("[Remote Server] %s server was opened successfully" %self.__server)
70 70
71 71 self.close()
72 72
73 73 self.mutex = threading.Lock()
74 74
75 75 def stop(self):
76 76
77 77 self.stopFlag = True
78 78 self.join(10)
79 79
80 80 def open(self):
81 81 """
82 82 Connect to server and create a connection class (FTP or SSH) to remote server.
83 83 """
84 84 raise NotImplementedError("Implement this method in child class")
85 85
86 86 def close(self):
87 87 """
88 88 Close connection to server
89 89 """
90 90 raise NotImplementedError("Implement this method in child class")
91 91
92 92 def mkdir(self, remotefolder):
93 93 """
94 94 Create a folder remotely
95 95 """
96 96 raise NotImplementedError("Implement this method in child class")
97 97
98 98 def cd(self, remotefolder):
99 99 """
100 100 Change working directory in remote server
101 101 """
102 102 raise NotImplementedError("Implement this method in child class")
103 103
104 104 def download(self, filename, localfolder=None):
105 105 """
106 106 Download a file from server to local host
107 107 """
108 108 raise NotImplementedError("Implement this method in child class")
109 109
110 110 def sendFile(self, fullfilename):
111 111 """
112 112 sendFile method is used to upload a local file to the current directory in remote server
113 113
114 114 Inputs:
115 115 fullfilename - full path name of local file to store in remote directory
116 116
117 117 Returns:
118 118 0 in error case else 1
119 119 """
120 120 raise NotImplementedError("Implement this method in child class")
121 121
122 122 def upload(self, fullfilename, remotefolder=None):
123 123 """
124 124 upload method is used to upload a local file to remote directory. This method changes
125 125 working directory before sending a file.
126 126
127 127 Inputs:
128 128 fullfilename - full path name of local file to store in remote directory
129 129
130 130 remotefolder - remote directory
131 131
132 132 Returns:
133 133 0 in error case else 1
134 134 """
135 135 print("[Remote Server] Uploading %s to %s:%s" %(fullfilename, self.server, self.remotefolder))
136 136
137 137 if not self.status:
138 138 return 0
139 139
140 140 if remotefolder == None:
141 141 remotefolder = self.remotefolder
142 142
143 143 if not self.cd(remotefolder):
144 144 return 0
145 145
146 146 if not self.sendFile(fullfilename):
147 147 print("[Remote Server] Error uploading file %s" %fullfilename)
148 148 return 0
149 149
150 150 print("[Remote Server] upload finished successfully")
151 151
152 152 return 1
153 153
154 154 def delete(self, filename):
155 155 """
156 156 Remove a file from remote server
157 157 """
158 158 pass
159 159
160 160 def updateFileList(self, fileList):
161 161 """
162 162 Remove a file from remote server
163 163 """
164 164
165 165 if fileList == self.fileList:
166 166 return 0
167 167
168 168 self.mutex.acquire()
169 169 # init = time.time()
170 170 #
171 171 # while(self.bussy):
172 172 # sleep(0.1)
173 173 # if time.time() - init > 2*self.period:
174 174 # return 0
175 175
176 176 self.fileList = fileList
177 177 self.mutex.release()
178 178 return 1
179 179
180 180 def run(self):
181 181
182 182 if not self.status:
183 183 print("Finishing FTP service")
184 184 return
185 185
186 186 if not self.cd(self.remotefolder):
187 187 raise ValueError("Could not access to the new remote directory: %s" %self.remotefolder)
188 188
189 189 while True:
190 190
191 191 for i in range(self.period):
192 192 if self.stopFlag:
193 193 break
194 194 sleep(1)
195 195
196 196 if self.stopFlag:
197 197 break
198 198
199 199 # self.bussy = True
200 200 self.mutex.acquire()
201 201
202 202 print("[Remote Server] Opening %s" %self.__server)
203 203 if not self.open(self.__server, self.__username, self.__password, self.__remotefolder):
204 204 self.mutex.release()
205 205 continue
206 206
207 207 for thisFile in self.fileList:
208 208 self.upload(thisFile, self.remotefolder)
209 209
210 210 print("[Remote Server] Closing %s" %self.__server)
211 211 self.close()
212 212
213 213 self.mutex.release()
214 214 # self.bussy = False
215 215
216 216 print("[Remote Server] Thread stopped successfully")
217 217
218 218 class FTPClient(Remote):
219 219
220 220 __ftpClientObj = None
221 221
222 222 def __init__(self, server, username, password, remotefolder, period=60):
223 223 """
224 224 """
225 225 Remote.__init__(self, server, username, password, remotefolder, period)
226 226
227 227 def open(self, server, username, password, remotefolder):
228 228
229 229 """
230 230 This method is used to set FTP parameters and establish a connection to remote server
231 231
232 232 Inputs:
233 233 server - remote server IP Address
234 234
235 235 username - remote server Username
236 236
237 237 password - remote server password
238 238
239 239 remotefolder - remote server current working directory
240 240
241 241 Return:
242 242 Boolean - Returns 1 if a connection has been established, 0 otherwise
243 243
244 244 Affects:
245 245 self.status - in case of error or fail connection this parameter is set to 0 else 1
246 246
247 247 """
248 248
249 249 if server == None:
250 250 raise ValueError("FTP server should be defined")
251 251
252 252 if username == None:
253 253 raise ValueError("FTP username should be defined")
254 254
255 255 if password == None:
256 256 raise ValueError("FTP password should be defined")
257 257
258 258 if remotefolder == None:
259 259 raise ValueError("FTP remote folder should be defined")
260 260
261 261 try:
262 262 ftpClientObj = ftplib.FTP(server)
263 263 except ftplib.all_errors as e:
264 264 print("[FTP Server]: FTP server connection fail: %s" %server)
265 265 print("[FTP Server]:", e)
266 266 self.status = 0
267 267 return 0
268 268
269 269 try:
270 270 ftpClientObj.login(username, password)
271 271 except ftplib.all_errors:
272 272 print("[FTP Server]: FTP username or password are incorrect")
273 273 self.status = 0
274 274 return 0
275 275
276 276 if remotefolder == None:
277 277 remotefolder = ftpClientObj.pwd()
278 278 else:
279 279 try:
280 280 ftpClientObj.cwd(remotefolder)
281 281 except ftplib.all_errors:
282 282 print("[FTP Server]: FTP remote folder is invalid: %s" %remotefolder)
283 283 remotefolder = ftpClientObj.pwd()
284 284
285 285 self.server = server
286 286 self.username = username
287 287 self.password = password
288 288 self.remotefolder = remotefolder
289 289 self.__ftpClientObj = ftpClientObj
290 290 self.status = 1
291 291
292 292 return 1
293 293
294 294 def close(self):
295 295 """
296 296 Close connection to remote server
297 297 """
298 298 if not self.status:
299 299 return 0
300 300
301 301 self.__ftpClientObj.close()
302 302
303 303 def mkdir(self, remotefolder):
304 304 """
305 305 mkdir is used to make a new directory in remote server
306 306
307 307 Input:
308 308 remotefolder - directory name
309 309
310 310 Return:
311 311 0 in error case else 1
312 312 """
313 313 if not self.status:
314 314 return 0
315 315
316 316 try:
317 317 self.__ftpClientObj.mkd(dirname)
318 318 except ftplib.all_errors:
319 319 print("[FTP Server]: Error creating remote folder: %s" %remotefolder)
320 320 return 0
321 321
322 322 return 1
323 323
324 324 def cd(self, remotefolder):
325 325 """
326 326 cd is used to change remote working directory on server
327 327
328 328 Input:
329 329 remotefolder - current working directory
330 330
331 331 Affects:
332 332 self.remotefolder
333 333
334 334 Return:
335 335 0 in case of error else 1
336 336 """
337 337 if not self.status:
338 338 return 0
339 339
340 340 if remotefolder == self.remotefolder:
341 341 return 1
342 342
343 343 try:
344 344 self.__ftpClientObj.cwd(remotefolder)
345 345 except ftplib.all_errors:
346 346 print('[FTP Server]: Error changing to %s' %remotefolder)
347 347 print('[FTP Server]: Trying to create remote folder')
348 348
349 349 if not self.mkdir(remotefolder):
350 350 print('[FTP Server]: Remote folder could not be created')
351 351 return 0
352 352
353 353 try:
354 354 self.__ftpClientObj.cwd(remotefolder)
355 355 except ftplib.all_errors:
356 356 return 0
357 357
358 358 self.remotefolder = remotefolder
359 359
360 360 return 1
361 361
362 362 def sendFile(self, fullfilename):
363 363
364 364 if not self.status:
365 365 return 0
366 366
367 367 fp = open(fullfilename, 'rb')
368 368
369 369 filename = os.path.basename(fullfilename)
370 370
371 371 command = "STOR %s" %filename
372 372
373 373 try:
374 374 self.__ftpClientObj.storbinary(command, fp)
375 375 except ftplib.all_errors as e:
376 376 print("[FTP Server]:", e)
377 377 return 0
378 378
379 379 try:
380 380 self.__ftpClientObj.sendcmd('SITE CHMOD 755 ' + filename)
381 381 except ftplib.all_errors as e:
382 382 print("[FTP Server]:", e)
383 383
384 384 fp.close()
385 385
386 386 return 1
387 387
388 388 class SSHClient(Remote):
389 389
390 390 __sshClientObj = None
391 391 __scpClientObj = None
392 392
393 393 def __init__(self, server, username, password, remotefolder, period=60):
394 394 """
395 395 """
396 396 Remote.__init__(self, server, username, password, remotefolder, period)
397 397
398 398 def open(self, server, username, password, remotefolder, port=22):
399 399
400 400 """
401 401 This method is used to set SSH parameters and establish a connection to a remote server
402 402
403 403 Inputs:
404 404 server - remote server IP Address
405 405
406 406 username - remote server Username
407 407
408 408 password - remote server password
409 409
410 410 remotefolder - remote server current working directory
411 411
412 412 Return: void
413 413
414 414 Affects:
415 415 self.status - in case of error or fail connection this parameter is set to 0 else 1
416 416
417 417 """
418 418 import socket
419 419
420 420 if server == None:
421 421 raise ValueError("SSH server should be defined")
422 422
423 423 if username == None:
424 424 raise ValueError("SSH username should be defined")
425 425
426 426 if password == None:
427 427 raise ValueError("SSH password should be defined")
428 428
429 429 if remotefolder == None:
430 430 raise ValueError("SSH remote folder should be defined")
431 431
432 432 sshClientObj = paramiko.SSHClient()
433 433
434 434 sshClientObj.load_system_host_keys()
435 435 sshClientObj.set_missing_host_key_policy(paramiko.WarningPolicy())
436 436
437 437 self.status = 0
438 438 try:
439 439 sshClientObj.connect(server, username=username, password=password, port=port)
440 440 except paramiko.AuthenticationException as e:
441 441 # print "SSH username or password are incorrect: %s"
442 442 print("[SSH Server]:", e)
443 443 return 0
444 444 except SSHException as e:
445 445 print("[SSH Server]:", e)
446 446 return 0
447 447 except socket.error:
448 448 self.status = 0
449 449 print("[SSH Server]:", e)
450 450 return 0
451 451
452 452 self.status = 1
453 453 scpClientObj = scp.SCPClient(sshClientObj.get_transport(), socket_timeout=30)
454 454
455 455 if remotefolder == None:
456 456 remotefolder = self.pwd()
457 457
458 458 self.server = server
459 459 self.username = username
460 460 self.password = password
461 461 self.__sshClientObj = sshClientObj
462 462 self.__scpClientObj = scpClientObj
463 463 self.status = 1
464 464
465 465 if not self.cd(remotefolder):
466 466 raise ValueError("[SSH Server]: Could not access to remote folder: %s" %remotefolder)
467 467 return 0
468 468
469 469 self.remotefolder = remotefolder
470 470
471 471 return 1
472 472
473 473 def close(self):
474 474 """
475 475 Close connection to remote server
476 476 """
477 477 if not self.status:
478 478 return 0
479 479
480 480 self.__scpClientObj.close()
481 481 self.__sshClientObj.close()
482 482
483 483 def __execute(self, command):
484 484 """
485 485 __execute a command on remote server
486 486
487 487 Input:
488 488 command - Exmaple 'ls -l'
489 489
490 490 Return:
491 491 0 in error case else 1
492 492 """
493 493 if not self.status:
494 494 return 0
495 495
496 496 stdin, stdout, stderr = self.__sshClientObj.exec_command(command)
497 497
498 498 result = stderr.readlines()
499 499 if len(result) > 1:
500 500 return 0
501 501
502 502 result = stdout.readlines()
503 503 if len(result) > 1:
504 504 return result[0][:-1]
505 505
506 506 return 1
507 507
508 508 def mkdir(self, remotefolder):
509 509 """
510 510 mkdir is used to make a new directory in remote server
511 511
512 512 Input:
513 513 remotefolder - directory name
514 514
515 515 Return:
516 516 0 in error case else 1
517 517 """
518 518
519 519 command = 'mkdir %s' %remotefolder
520 520
521 521 return self.__execute(command)
522 522
523 523 def pwd(self):
524 524
525 525 command = 'pwd'
526 526
527 527 return self.__execute(command)
528 528
529 529 def cd(self, remotefolder):
530 530 """
531 531 cd is used to change remote working directory on server
532 532
533 533 Input:
534 534 remotefolder - current working directory
535 535
536 536 Affects:
537 537 self.remotefolder
538 538
539 539 Return:
540 540 0 in case of error else 1
541 541 """
542 542 if not self.status:
543 543 return 0
544 544
545 545 if remotefolder == self.remotefolder:
546 546 return 1
547 547
548 548 chk_command = "cd %s; pwd" %remotefolder
549 549 mkdir_command = "mkdir %s" %remotefolder
550 550
551 551 if not self.__execute(chk_command):
552 552 if not self.__execute(mkdir_command):
553 553 self.remotefolder = None
554 554 return 0
555 555
556 556 self.remotefolder = remotefolder
557 557
558 558 return 1
559 559
560 560 def sendFile(self, fullfilename):
561 561
562 562 if not self.status:
563 563 return 0
564 564
565 565 try:
566 566 self.__scpClientObj.put(fullfilename, remote_path=self.remotefolder)
567 567 except scp.ScpError as e:
568 568 print("[SSH Server]", str(e))
569 569 return 0
570 570
571 571 remotefile = os.path.join(self.remotefolder, os.path.split(fullfilename)[-1])
572 572 command = 'chmod 775 %s' %remotefile
573 573
574 574 return self.__execute(command)
575 575 @MPDecorator
576 576 class SendToServer(ProcessingUnit):
577 577
578 578 def __init__(self, **kwargs):
579 579
580 580 ProcessingUnit.__init__(self, **kwargs)
581 581
582 582 self.isConfig = False
583 583 self.clientObj = None
584 584
585 585 def setup(self, server, username, password, remotefolder, localfolder, ext='.png', period=60, protocol='ftp', **kwargs):
586
586 self.server = server
587 self.username = username
588 self.password = password
589 self.remotefolder = remotefolder
587 590 self.clientObj = None
588 591 self.localfolder = localfolder
589 592 self.ext = ext
590 593 self.period = period
591 594
592 595 if str.lower(protocol) == 'ftp':
593 596 self.clientObj = FTPClient(server, username, password, remotefolder, period)
594 597
595 598 if str.lower(protocol) == 'ssh':
596 599 self.clientObj = SSHClient(server, username, password, remotefolder, period)
597 600
598 601 if not self.clientObj:
599 602 raise ValueError("%s has been chosen as remote access protocol but it is not valid" %protocol)
600 603
601 604 self.clientObj.start()
602 605 print("ftp setup complete")
603 606 def findFiles(self):
604 607
605 608 if not type(self.localfolder) == list:
606 609 folderList = [self.localfolder]
607 610 else:
608 611 folderList = self.localfolder
609 612
610 613 #Remove duplicate items
611 614 folderList = list(set(folderList))
612 615
613 616 fullfilenameList = []
614 617
615 618 for thisFolder in folderList:
616 619
617 620 print("[Remote Server]: Searching files on %s" %thisFolder)
618 621
619 622 filenameList = glob.glob1(thisFolder, '*%s' %self.ext)
620 623
621 624 if len(filenameList) < 1:
622 625
623 626 continue
624 627
625 628 for thisFile in filenameList:
626 629 fullfilename = os.path.join(thisFolder, thisFile)
627 630
628 631 if fullfilename in fullfilenameList:
629 632 continue
630 633
631 634 #Only files modified in the last 30 minutes are considered
632 635 if os.path.getmtime(fullfilename) < time.time() - 30*60:
633 636 continue
634 637
635 638 fullfilenameList.append(fullfilename)
636 639
637 640 return fullfilenameList
638 641
639 642 def run(self, **kwargs):
640 643 if not self.isConfig:
641 644 self.init = time.time()
642 645 self.setup(**kwargs)
643 646 self.isConfig = True
644 647
645 648 if not self.clientObj.is_alive():
646 649 print("[Remote Server]: Restarting connection ")
647 650 self.setup(**kwargs)
648 651
649 652 if time.time() - self.init >= self.period:
650 653 fullfilenameList = self.findFiles()
651 654
652 655 if self.clientObj.updateFileList(fullfilenameList):
653 656 print("[Remote Server]: Sending the next files ", str(fullfilenameList))
654 657 self.init = time.time()
655 658
656 659 def close(self):
657 660 print("[Remote Server] Stopping thread")
658 661 self.clientObj.stop()
659 662
660 663
661 664 class FTP(object):
662 665 """
663 666 Ftp is a public class used to define custom File Transfer Protocol from "ftplib" python module
664 667
665 668 Non-standard Python modules used: None
666 669
667 670 Written by "Daniel Suarez":mailto:daniel.suarez@jro.igp.gob.pe Oct. 26, 2010
668 671 """
669 672
670 673 def __init__(self,server = None, username=None, password=None, remotefolder=None):
671 674 """
672 675 This method is used to setting parameters for FTP and establishing connection to remote server
673 676
674 677 Inputs:
675 678 server - remote server IP Address
676 679
677 680 username - remote server Username
678 681
679 682 password - remote server password
680 683
681 684 remotefolder - remote server current working directory
682 685
683 686 Return: void
684 687
685 688 Affects:
686 689 self.status - in Error Case or Connection Failed this parameter is set to 1 else 0
687 690
688 691 self.folderList - sub-folder list of remote folder
689 692
690 693 self.fileList - file list of remote folder
691 694
692 695
693 696 """
694 697
695 698 if ((server == None) and (username==None) and (password==None) and (remotefolder==None)):
696 699 server, username, password, remotefolder = self.parmsByDefault()
697 700
698 701 self.server = server
699 702 self.username = username
700 703 self.password = password
701 704 self.remotefolder = remotefolder
702 705 self.file = None
703 706 self.ftp = None
704 707 self.status = 0
705 708
706 709 try:
707 710 self.ftp = ftplib.FTP(self.server)
708 711 self.ftp.login(self.username,self.password)
709 712 self.ftp.cwd(self.remotefolder)
710 713 # print 'Connect to FTP Server: Successfully'
711 714
712 715 except ftplib.all_errors:
713 716 print('Error FTP Service')
714 717 self.status = 1
715 718 return
716 719
717 720
718 721
719 722 self.dirList = []
720 723
721 724 try:
722 725 self.dirList = self.ftp.nlst()
723 726
724 727 except ftplib.error_perm as resp:
725 728 if str(resp) == "550 No files found":
726 729 print("no files in this directory")
727 730 self.status = 1
728 731 return
729 732
730 733 except ftplib.all_errors:
731 734 print('Error Displaying Dir-Files')
732 735 self.status = 1
733 736 return
734 737
735 738 self.fileList = []
736 739 self.folderList = []
737 740 #only for test
738 741 for f in self.dirList:
739 742 name, ext = os.path.splitext(f)
740 743 if ext != '':
741 744 self.fileList.append(f)
742 745 # print 'filename: %s - size: %d'%(f,self.ftp.size(f))
743 746
744 747 def parmsByDefault(self):
745 748 server = 'jro-app.igp.gob.pe'
746 749 username = 'wmaster'
747 750 password = 'mst2010vhf'
748 751 remotefolder = '/home/wmaster/graficos'
749 752
750 753 return server, username, password, remotefolder
751 754
752 755
753 756 def mkd(self,dirname):
754 757 """
755 758 mkd is used to make directory in remote server
756 759
757 760 Input:
758 761 dirname - directory name
759 762
760 763 Return:
761 764 1 in error case else 0
762 765 """
763 766 try:
764 767 self.ftp.mkd(dirname)
765 768 except:
766 769 print('Error creating remote folder:%s'%dirname)
767 770 return 1
768 771
769 772 return 0
770 773
771 774
772 775 def delete(self,filename):
773 776 """
774 777 delete is used to delete file in current working directory of remote server
775 778
776 779 Input:
777 780 filename - filename to delete in remote folder
778 781
779 782 Return:
780 783 1 in error case else 0
781 784 """
782 785
783 786 try:
784 787 self.ftp.delete(filename)
785 788 except:
786 789 print('Error deleting remote file:%s'%filename)
787 790 return 1
788 791
789 792 return 0
790 793
791 794 def download(self,filename,localfolder):
792 795 """
793 796 download is used to downloading file from remote folder into local folder
794 797
795 798 Inputs:
796 799 filename - filename to donwload
797 800
798 801 localfolder - directory local to store filename
799 802
800 803 Returns:
801 804 self.status - 1 in error case else 0
802 805 """
803 806
804 807 self.status = 0
805 808
806 809
807 810 if not(filename in self.fileList):
808 811 print('filename:%s not exists'%filename)
809 812 self.status = 1
810 813 return self.status
811 814
812 815 newfilename = os.path.join(localfolder,filename)
813 816
814 817 self.file = open(newfilename, 'wb')
815 818
816 819 try:
817 820 print('Download: ' + filename)
818 821 self.ftp.retrbinary('RETR ' + filename, self.__handleDownload)
819 822 print('Download Complete')
820 823 except ftplib.all_errors:
821 824 print('Error Downloading ' + filename)
822 825 self.status = 1
823 826 return self.status
824 827
825 828 self.file.close()
826 829
827 830 return self.status
828 831
829 832
830 833 def __handleDownload(self,block):
831 834 """
832 835 __handleDownload is used to handle writing file
833 836 """
834 837 self.file.write(block)
835 838
836 839
837 840 def upload(self,filename,remotefolder=None):
838 841 """
839 842 upload is used to uploading local file to remote directory
840 843
841 844 Inputs:
842 845 filename - full path name of local file to store in remote directory
843 846
844 847 remotefolder - remote directory
845 848
846 849 Returns:
847 850 self.status - 1 in error case else 0
848 851 """
849 852
850 853 if remotefolder == None:
851 854 remotefolder = self.remotefolder
852 855
853 856 self.status = 0
854 857
855 858 try:
856 859 self.ftp.cwd(remotefolder)
857 860
858 861 self.file = open(filename, 'rb')
859 862
860 863 (head, tail) = os.path.split(filename)
861 864
862 865 command = "STOR " + tail
863 866
864 867 print('Uploading: ' + tail)
865 868 self.ftp.storbinary(command, self.file)
866 869 print('Upload Completed')
867 870
868 871 except ftplib.all_errors:
869 872 print('Error Uploading ' + tail)
870 873 self.status = 1
871 874 return self.status
872 875
873 876 self.file.close()
874 877
875 878 #back to initial directory in __init__()
876 879 self.ftp.cwd(self.remotefolder)
877 880
878 881 return self.status
879 882
880 883
881 884 def dir(self,remotefolder):
882 885 """
883 886 dir is used to change working directory of remote server and get folder and file list
884 887
885 888 Input:
886 889 remotefolder - current working directory
887 890
888 891 Affects:
889 892 self.fileList - file list of working directory
890 893
891 894 Return:
892 895 infoList - list with filenames and size of file in bytes
893 896
894 897 self.folderList - folder list
895 898 """
896 899
897 900 self.remotefolder = remotefolder
898 901 print('Change to ' + self.remotefolder)
899 902 try:
900 903 self.ftp.cwd(remotefolder)
901 904 except ftplib.all_errors:
902 905 print('Error Change to ' + self.remotefolder)
903 906 infoList = None
904 907 self.folderList = None
905 908 return infoList,self.folderList
906 909
907 910 self.dirList = []
908 911
909 912 try:
910 913 self.dirList = self.ftp.nlst()
911 914
912 915 except ftplib.error_perm as resp:
913 916 if str(resp) == "550 No files found":
914 917 print("no files in this directory")
915 918 infoList = None
916 919 self.folderList = None
917 920 return infoList,self.folderList
918 921 except ftplib.all_errors:
919 922 print('Error Displaying Dir-Files')
920 923 infoList = None
921 924 self.folderList = None
922 925 return infoList,self.folderList
923 926
924 927 infoList = []
925 928 self.fileList = []
926 929 self.folderList = []
927 930 for f in self.dirList:
928 931 name,ext = os.path.splitext(f)
929 932 if ext != '':
930 933 self.fileList.append(f)
931 934 value = (f,self.ftp.size(f))
932 935 infoList.append(value)
933 936
934 937 if ext == '':
935 938 self.folderList.append(f)
936 939
937 940 return infoList,self.folderList
938 941
939 942
940 943 def close(self):
941 944 """
942 945 close is used to close and end FTP connection
943 946
944 947 Inputs: None
945 948
946 949 Return: void
947 950
948 951 """
949 952 self.ftp.close()
950
953 @MPDecorator
951 954 class SendByFTP(Operation):
952 955
953 956 def __init__(self, **kwargs):
954 957 Operation.__init__(self, **kwargs)
955 958 self.status = 1
956 959 self.counter = 0
957 960
958 961 def error_print(self, ValueError):
959 962
960 963 print(ValueError, 'Error FTP')
961 964 print("don't worry the program is running...")
962 965
963 966 def worker_ftp(self, server, username, password, remotefolder, filenameList):
964 967
965 968 self.ftpClientObj = FTP(server, username, password, remotefolder)
966 969 for filename in filenameList:
967 970 self.ftpClientObj.upload(filename)
968 971 self.ftpClientObj.close()
969 972
970 973 def ftp_thread(self, server, username, password, remotefolder):
971 974 if not(self.status):
972 975 return
973 976
974 977 import multiprocessing
975 978
976 979 p = multiprocessing.Process(target=self.worker_ftp, args=(server, username, password, remotefolder, self.filenameList,))
977 980 p.start()
978 981
979 982 p.join(3)
980 983
981 984 if p.is_alive():
982 985 p.terminate()
983 986 p.join()
984 987 print('killing ftp process...')
985 988 self.status = 0
986 989 return
987 990
988 991 self.status = 1
989 992 return
990 993
991 994 def filterByExt(self, ext, localfolder):
992 995 fnameList = glob.glob1(localfolder,ext)
993 996 self.filenameList = [os.path.join(localfolder,x) for x in fnameList]
994 997
995 998 if len(self.filenameList) == 0:
996 999 self.status = 0
997 1000
998 1001 def run(self, dataOut, ext, localfolder, remotefolder, server, username, password, period=1):
999 1002
1000 1003 self.counter += 1
1001 1004 if self.counter >= period:
1002 1005 self.filterByExt(ext, localfolder)
1003 1006
1004 1007 self.ftp_thread(server, username, password, remotefolder)
1005 1008
1006 1009 self.counter = 0
1007 1010
1008 1011 self.status = 1
General Comments 0
You need to be logged in to leave comments. Login now