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