def _finalize_manager(process, address, authkey, state, _Client): ''' Shutdown the manager process; will be registered as a finalizer ''' if process.is_alive(): util.info('sending shutdown message to manager') try: conn = _Client(address, authkey=authkey) try: managers.dispatch(conn, None, 'shutdown') finally: conn.close() except Exception: pass process.join(timeout=0.2) if process.is_alive(): util.info('manager still alive') if hasattr(process, 'terminate'): util.info('trying to `terminate()` manager process') try: process.terminate() process.join(timeout=0.1) # XXX: catch the OS error ... something weird is going on here.. except OSError: pass if process.is_alive(): util.info('manager still alive after terminate') state.value = managers.State.SHUTDOWN try: del managers.BaseProxy._address_to_local[address] except KeyError: pass
def from_address(cls, address, authkey): """ Return manager given an address. address: (ip_addr, port) or string referring to pipe. Address to connect to. authkey: string Authorization key. """ manager = cls(address, authkey) conn = connection.Client(address, authkey=authkey) try: managers.dispatch(conn, None, 'dummy') finally: conn.close() manager._state.value = managers.State.STARTED manager._name = 'Host-%s:%s' % manager.address manager.shutdown = util.Finalize(manager, HostManager._finalize_host, args=(manager._address, manager._authkey, manager._name), exitpriority=-10) return manager
def _finalize_manager(process, address, authkey, state, conns, _Client): """ Shutdown the manager process; will be registered as a finalizer.""" if process.is_alive(): util.info("Sending shutdown message to manager.") try: conn = _Client(fqaddr(address), authkey=authkey) try: dispatch(conn, None, "shutdown") finally: conn.close() except Exception: pass for conn in conns: conn.close() process.join(timeout=0.2) if process.is_alive(): util.info("Manager still alive.") if hasattr(process, "terminate"): util.info("Trying to `terminate()` manager process.") process.terminate() process.join(timeout=0.1) if process.is_alive(): util.info("Manager still alive after terminate.") state.value = State.SHUTDOWN try: del BaseProxy._address_to_local[fqaddr(address)] except KeyError: pass
def connect(self): ''' Connect manager object to the server process ''' Listener, Client = listener_client[self._serializer] self._conn = Client(self._address, authkey=self._authkey) dispatch(self._conn, None, 'dummy') self._state.value = State.STARTED
def SharedMemory(self, size): """Returns a new SharedMemory instance with the specified size in bytes, to be tracked by the manager.""" with self._Client(self._address, authkey=self._authkey) as conn: sms = shared_memory.SharedMemory(None, create=True, size=size) try: dispatch(conn, None, 'track_segment', (sms.name,)) except BaseException as e: sms.unlink() raise e return sms
def ShareableList(self, sequence): """Returns a new ShareableList instance populated with the values from the input sequence, to be tracked by the manager.""" with self._Client(self._address, authkey=self._authkey) as conn: sl = shared_memory.ShareableList(sequence) try: dispatch(conn, None, 'track_segment', (sl.shm.name,)) except BaseException as e: sl.shm.unlink() raise e return sl
def temp(self, *args, **kwds): logger.debug("calling self._create(%s,%s)", args, kwds) token, exp = self._create(typeid, *args, **kwds) proxy = proxytype(token, self._serializer, manager=self, authkey=self._authkey, exposed=exp) conn = self._Client(token.address, authkey=self._authkey) dispatch(conn, None, 'decref', (token.id, )) return proxy
def SharedMemory(self, name: str = None, size: int = None): assert name is not None or size is not None with self._Client(self._address, authkey=self._authkey) as conn: if name is not None: shm = SharedMemory(name=name) self.client_shms[name] = shm else: shm = SharedMemory(None, create=True, size=size) try: dispatch(conn, None, 'track_segment', (shm.name, )) except BaseException as e: shm.unlink() raise e return shm
def _finalize_host(address, authkey, fcleanup, rcleanup): """ Sends a shutdown message and cleans up tunnels. """ mgr_ok = OpenMDAO_Proxy.manager_is_alive(address) if mgr_ok: conn = connection.Client(address, authkey=authkey) try: managers.dispatch(conn, None, 'shutdown') except EOFError: pass finally: conn.close() if fcleanup is not None: fcleanup[0](*fcleanup[1:], **dict(keep_log=not mgr_ok)) if rcleanup is not None: rcleanup[0](*rcleanup[1:], **dict(keep_log=not mgr_ok))
def _finalize_host(address, authkey, name): """ Sends a shutdown message. """ conn = connection.Client(address, authkey=authkey) try: return managers.dispatch(conn, None, 'shutdown') finally: conn.close()
def AsyncAutoProxy(token, serializer, manager=None, authkey=None, exposed=None, incref=True): """Return an auto-proxy for `token`.""" _Client = listener_client[serializer][1] if exposed is None: conn = _Client(token.address, authkey=authkey) try: exposed = dispatch(conn, None, 'get_methods', (token, )) finally: conn.close() if authkey is None and manager is not None: authkey = manager._authkey if authkey is None: authkey = process.current_process().authkey ProxyType = MakeAsyncProxyType('AutoProxy[%s]' % token.typeid, exposed) proxy = ProxyType(token, serializer, manager=manager, authkey=authkey, incref=incref) proxy._isauto = True return proxy
def mpm_AutoProxy(token, serializer, manager=None, authkey=None, exposed=None, incref=True, manager_owned=False): ''' Return an auto-proxy for `token` ''' _Client = mpm.listener_client[serializer][1] if exposed is None: conn = _Client(token.address, authkey=authkey) try: exposed = mpm.dispatch(conn, None, 'get_methods', (token, )) finally: conn.close() if authkey is None and manager is not None: authkey = manager._authkey if authkey is None: authkey = mpm.process.current_process().authkey ProxyType = mpm.MakeProxyType('AutoProxy[%s]' % token.typeid, exposed) proxy = ProxyType(token, serializer, manager=manager, authkey=authkey, incref=incref, manager_owned=manager_owned) proxy._isauto = True return proxy
def from_address(cls, address, authkey, host): """ Return manager given an address. address: (ip_addr, port) or string referring to pipe. Address to connect to. authkey: string Authorization key. host: :class:`Host` Host we're managing. """ if host.tunnel_outgoing: _LOGGER.debug('Client setting up tunnel for %s:%s', host.hostname, address[1]) address, cleanup = setup_tunnel(host.hostname, address[1], identity=host.identity_filename) else: cleanup = None manager = cls(address, authkey) _LOGGER.debug('Client connecting to server at %s' % (address, )) conn = connection.Client(address, authkey=authkey) try: managers.dispatch(conn, None, 'dummy') finally: conn.close() manager._state.value = managers.State.STARTED manager._name = 'Host-%s:%s' % manager.address manager.shutdown = util.Finalize(manager, HostManager._finalize_host, args=(manager._address, manager._authkey, cleanup, host.reverse_cleanup), exitpriority=-10) return manager
def from_address(cls, address, authkey): """ Return manager given an address. address: (ip_addr, port) or string referring to pipe. Address to connect to. authkey: string Authorization key. """ manager = cls(address, authkey) conn = connection.Client(address, authkey=authkey) try: managers.dispatch(conn, None, 'dummy') finally: conn.close() manager._state.value = managers.State.STARTED manager._name = 'Host-%s:%s' % manager.address manager.shutdown = util.Finalize( manager, HostManager._finalize_host, args=(manager._address, manager._authkey, manager._name), exitpriority=-10 ) return manager
def from_address(cls, address, authkey, host): """ Return manager given an address. address: (ip_addr, port) or string referring to pipe. Address to connect to. authkey: string Authorization key. host: :class:`Host` Host we're managing. """ if host.tunnel_outgoing: _LOGGER.debug('Client setting up tunnel for %s:%s', host.hostname, address[1]) address, cleanup = setup_tunnel(host.hostname, address[1], identity=host.identity_filename) else: cleanup = None manager = cls(address, authkey) _LOGGER.debug('Client connecting to server at %s' % (address,)) conn = connection.Client(address, authkey=authkey) try: managers.dispatch(conn, None, 'dummy') finally: conn.close() manager._state.value = managers.State.STARTED manager._name = 'Host-%s:%s' % manager.address manager.shutdown = util.Finalize( manager, HostManager._finalize_host, args=(manager._address, manager._authkey, cleanup, host.reverse_cleanup), exitpriority=-10) return manager