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