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