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