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