##// END OF EJS Templates
schain
RSS
minor changes and comments added
Miguel Valdez -
r641:ef17427bf2f3
parent child
Show More

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