Lines Matching refs:self
68 def __init__(self, typeid, address, id):
69 (self.typeid, self.address, self.id) = (typeid, address, id)
71 def __getstate__(self):
72 return (self.typeid, self.address, self.id)
74 def __setstate__(self, state):
75 (self.typeid, self.address, self.id) = state
77 def __repr__(self):
79 (self.__class__.__name__, self.typeid, self.address, self.id)
111 def __str__(self):
112 return ('\n' + '-'*75 + '\n' + str(self.args[0]) + '-'*75)
146 def __init__(self, registry, address, authkey, serializer):
151 self.registry = registry
152 self.authkey = process.AuthenticationString(authkey)
156 self.listener = Listener(address=address, backlog=16)
157 self.address = self.listener.address
159 self.id_to_obj = {'0': (None, ())}
160 self.id_to_refcount = {}
161 self.id_to_local_proxy_obj = {}
162 self.mutex = threading.Lock()
164 def serve_forever(self):
168 self.stop_event = threading.Event()
169 process.current_process()._manager_server = self
171 accepter = threading.Thread(target=self.accepter)
175 while not self.stop_event.is_set():
176 self.stop_event.wait(1)
186 def accepter(self):
189 c = self.listener.accept()
192 t = threading.Thread(target=self.handle_request, args=(c,))
196 def _handle_request(self, c):
199 connection.deliver_challenge(c, self.authkey)
200 connection.answer_challenge(c, self.authkey)
203 assert funcname in self.public, '%r unrecognized' % funcname
204 func = getattr(self, funcname)
226 def handle_request(self, conn):
231 self._handle_request(conn)
238 def serve_client(self, conn):
247 id_to_obj = self.id_to_obj
249 while not self.stop_event.is_set():
260 self.id_to_local_proxy_obj[ident]
279 rident, rexposed = self.create(conn, typeid, res)
280 token = Token(typeid, self.address, rident)
290 fallback_func = self.fallback_mapping[methodname]
292 self, conn, ident, obj, *args, **kwds
319 def fallback_getvalue(self, conn, ident, obj):
322 def fallback_str(self, conn, ident, obj):
325 def fallback_repr(self, conn, ident, obj):
334 def dummy(self, c):
337 def debug_info(self, c):
342 with self.mutex:
344 keys = list(self.id_to_refcount.keys())
349 (ident, self.id_to_refcount[ident],
350 str(self.id_to_obj[ident][0])[:75]))
353 def number_of_objects(self, c):
357 # Doesn't use (len(self.id_to_obj) - 1) as we shouldn't count ident='0'
358 return len(self.id_to_refcount)
360 def shutdown(self, c):
371 self.stop_event.set()
373 def create(self, c, typeid, /, *args, **kwds):
377 with self.mutex:
379 self.registry[typeid]
402 self.id_to_obj[ident] = (obj, set(exposed), method_to_typeid)
403 if ident not in self.id_to_refcount:
404 self.id_to_refcount[ident] = 0
406 self.incref(c, ident)
409 def get_methods(self, c, token):
413 return tuple(self.id_to_obj[token.id][1])
415 def accept_connection(self, c, name):
421 self.serve_client(c)
423 def incref(self, c, ident):
424 with self.mutex:
426 self.id_to_refcount[ident] += 1
432 if ident in self.id_to_local_proxy_obj:
433 self.id_to_refcount[ident] = 1
434 self.id_to_obj[ident] = \
435 self.id_to_local_proxy_obj[ident]
436 obj, exposed, gettypeid = self.id_to_obj[ident]
441 def decref(self, c, ident):
442 if ident not in self.id_to_refcount and \
443 ident in self.id_to_local_proxy_obj:
447 with self.mutex:
448 if self.id_to_refcount[ident] <= 0:
451 ident, self.id_to_obj[ident],
452 self.id_to_refcount[ident]))
453 self.id_to_refcount[ident] -= 1
454 if self.id_to_refcount[ident] == 0:
455 del self.id_to_refcount[ident]
457 if ident not in self.id_to_refcount:
460 # Otherwise, deleting self.id_to_obj[ident] would trigger the
463 self.id_to_obj[ident] = (None, (), None) # thread-safe
465 with self.mutex:
466 del self.id_to_obj[ident]
499 def __init__(self, address=None, authkey=None, serializer='pickle',
503 self._address = address # XXX not final address if eg ('', 0)
504 self._authkey = process.AuthenticationString(authkey)
505 self._state = State()
506 self._state.value = State.INITIAL
507 self._serializer = serializer
508 self._Listener, self._Client = listener_client[serializer]
509 self._ctx = ctx or get_context()
510 self._shutdown_timeout = shutdown_timeout
512 def get_server(self):
516 if self._state.value != State.INITIAL:
517 if self._state.value == State.STARTED:
519 elif self._state.value == State.SHUTDOWN:
523 "Unknown state {!r}".format(self._state.value))
524 return Server(self._registry, self._address,
525 self._authkey, self._serializer)
527 def connect(self):
531 Listener, Client = listener_client[self._serializer]
532 conn = Client(self._address, authkey=self._authkey)
534 self._state.value = State.STARTED
536 def start(self, initializer=None, initargs=()):
540 if self._state.value != State.INITIAL:
541 if self._state.value == State.STARTED:
543 elif self._state.value == State.SHUTDOWN:
547 "Unknown state {!r}".format(self._state.value))
556 self._process = self._ctx.Process(
557 target=type(self)._run_server,
558 args=(self._registry, self._address, self._authkey,
559 self._serializer, writer, initializer, initargs),
561 ident = ':'.join(str(i) for i in self._process._identity)
562 self._process.name = type(self).__name__ + '-' + ident
563 self._process.start()
567 self._address = reader.recv()
571 self._state.value = State.STARTED
572 self.shutdown = util.Finalize(
573 self, type(self)._finalize_manager,
574 args=(self._process, self._address, self._authkey, self._state,
575 self._Client, self._shutdown_timeout),
602 def _create(self, typeid, /, *args, **kwds):
606 assert self._state.value == State.STARTED, 'server not yet started'
607 conn = self._Client(self._address, authkey=self._authkey)
612 return Token(typeid, self._address, id), exposed
614 def join(self, timeout=None):
618 if self._process is not None:
619 self._process.join(timeout)
620 if not self._process.is_alive():
621 self._process = None
623 def _debug_info(self):
627 conn = self._Client(self._address, authkey=self._authkey)
633 def _number_of_objects(self):
637 conn = self._Client(self._address, authkey=self._authkey)
643 def __enter__(self):
644 if self._state.value == State.INITIAL:
645 self.start()
646 if self._state.value != State.STARTED:
647 if self._state.value == State.INITIAL:
649 elif self._state.value == State.SHUTDOWN:
653 "Unknown state {!r}".format(self._state.value))
654 return self
656 def __exit__(self, exc_type, exc_val, exc_tb):
657 self.shutdown()
695 def address(self):
696 return self._address
725 def temp(self, /, *args, **kwds):
727 token, exp = self._create(typeid, *args, **kwds)
729 token, self._serializer, manager=self,
730 authkey=self._authkey, exposed=exp
732 conn = self._Client(token.address, authkey=self._authkey)
743 def __init__(self):
744 util.register_after_fork(self, lambda obj: obj.clear())
745 def __reduce__(self):
746 return type(self), ()
759 def __init__(self, token, serializer, manager=None,
767 # self._tls is used to record the connection used by this
769 self._tls = tls_idset[0]
771 # self._idset is used to record the identities of all shared
774 self._idset = tls_idset[1]
776 self._token = token
777 self._id = self._token.id
778 self._manager = manager
779 self._serializer = serializer
780 self._Client = listener_client[serializer][1]
786 self._owned_by_manager = manager_owned
789 self._authkey = process.AuthenticationString(authkey)
790 elif self._manager is not None:
791 self._authkey = self._manager._authkey
793 self._authkey = process.current_process().authkey
796 self._incref()
798 util.register_after_fork(self, BaseProxy._after_fork)
800 def _connect(self):
805 conn = self._Client(self._token.address, authkey=self._authkey)
807 self._tls.connection = conn
809 def _callmethod(self, methodname, args=(), kwds={}):
814 conn = self._tls.connection
818 self._connect()
819 conn = self._tls.connection
821 conn.send((self._id, methodname, args, kwds))
828 proxytype = self._manager._registry[token.typeid][-1]
829 token.address = self._token.address
831 token, self._serializer, manager=self._manager,
832 authkey=self._authkey, exposed=exposed
834 conn = self._Client(token.address, authkey=self._authkey)
839 def _getvalue(self):
843 return self._callmethod('#GETVALUE')
845 def _incref(self):
846 if self._owned_by_manager:
847 util.debug('owned_by_manager skipped INCREF of %r', self._token.id)
850 conn = self._Client(self._token.address, authkey=self._authkey)
851 dispatch(conn, None, 'incref', (self._id,))
852 util.debug('INCREF %r', self._token.id)
854 self._idset.add(self._id)
856 state = self._manager and self._manager._state
858 self._close = util.Finalize(
859 self, BaseProxy._decref,
860 args=(self._token, self._authkey, state,
861 self._tls, self._idset, self._Client),
890 def _after_fork(self):
891 self._manager = None
893 self._incref()
898 def __reduce__(self):
901 kwds['authkey'] = self._authkey
903 if getattr(self, '_isauto', False):
904 kwds['exposed'] = self._exposed_
906 (AutoProxy, self._token, self._serializer, kwds))
909 (type(self), self._token, self._serializer, kwds))
911 def __deepcopy__(self, memo):
912 return self._getvalue()
914 def __repr__(self):
916 (type(self).__name__, self._token.typeid, id(self))
918 def __str__(self):
923 return self._callmethod('__repr__')
925 return repr(self)[:-1] + "; '__str__()' failed>"
965 exec('''def %s(self, /, *args, **kwds):
966 return self._callmethod(%r, args, kwds)''' % (meth, meth), dic)
1004 def __init__(self, /, **kwds):
1005 self.__dict__.update(kwds)
1006 def __repr__(self):
1007 items = list(self.__dict__.items())
1013 return '%s(%s)' % (self.__class__.__name__, ', '.join(temp))
1016 def __init__(self, typecode, value, lock=True):
1017 self._typecode = typecode
1018 self._value = value
1019 def get(self):
1020 return self._value
1021 def set(self, value):
1022 self._value = value
1023 def __repr__(self):
1024 return '%s(%r, %r)'%(type(self).__name__, self._typecode, self._value)
1036 def __iter__(self):
1037 return self
1038 def __next__(self, *args):
1039 return self._callmethod('__next__', args)
1040 def send(self, *args):
1041 return self._callmethod('send', args)
1042 def throw(self, *args):
1043 return self._callmethod('throw', args)
1044 def close(self, *args):
1045 return self._callmethod('close', args)
1050 def acquire(self, blocking=True, timeout=None):
1052 return self._callmethod('acquire', args)
1053 def release(self):
1054 return self._callmethod('release')
1055 def __enter__(self):
1056 return self._callmethod('acquire')
1057 def __exit__(self, exc_type, exc_val, exc_tb):
1058 return self._callmethod('release')
1063 def wait(self, timeout=None):
1064 return self._callmethod('wait', (timeout,))
1065 def notify(self, n=1):
1066 return self._callmethod('notify', (n,))
1067 def notify_all(self):
1068 return self._callmethod('notify_all')
1069 def wait_for(self, predicate, timeout=None):
1083 self.wait(waittime)
1090 def is_set(self):
1091 return self._callmethod('is_set')
1092 def set(self):
1093 return self._callmethod('set')
1094 def clear(self):
1095 return self._callmethod('clear')
1096 def wait(self, timeout=None):
1097 return self._callmethod('wait', (timeout,))
1102 def wait(self, timeout=None):
1103 return self._callmethod('wait', (timeout,))
1104 def abort(self):
1105 return self._callmethod('abort')
1106 def reset(self):
1107 return self._callmethod('reset')
1109 def parties(self):
1110 return self._callmethod('__getattribute__', ('parties',))
1112 def n_waiting(self):
1113 return self._callmethod('__getattribute__', ('n_waiting',))
1115 def broken(self):
1116 return self._callmethod('__getattribute__', ('broken',))
1121 def __getattr__(self, key):
1123 return object.__getattribute__(self, key)
1124 callmethod = object.__getattribute__(self, '_callmethod')
1126 def __setattr__(self, key, value):
1128 return object.__setattr__(self, key, value)
1129 callmethod = object.__getattribute__(self, '_callmethod')
1131 def __delattr__(self, key):
1133 return object.__delattr__(self, key)
1134 callmethod = object.__getattribute__(self, '_callmethod')
1140 def get(self):
1141 return self._callmethod('get')
1142 def set(self, value):
1143 return self._callmethod('set', (value,))
1156 def __iadd__(self, value):
1157 self._callmethod('extend', (value,))
1158 return self
1159 def __imul__(self, value):
1160 self._callmethod('__imul__', (value,))
1161 return self
1191 def __enter__(self):
1192 return self
1193 def __exit__(self, exc_type, exc_val, exc_tb):
1194 self.terminate()
1240 def __init__(self, name, segment_names=[]):
1241 self.shared_memory_context_name = name
1242 self.segment_names = segment_names
1244 def register_segment(self, segment_name):
1247 self.segment_names.append(segment_name)
1249 def destroy_segment(self, segment_name):
1253 self.segment_names.remove(segment_name)
1258 def unlink(self):
1260 for segment_name in self.segment_names[:]:
1261 self.destroy_segment(segment_name)
1263 def __del__(self):
1264 util.debug(f"Call {self.__class__.__name__}.__del__ in {getpid()}")
1265 self.unlink()
1267 def __getstate__(self):
1268 return (self.shared_memory_context_name, self.segment_names)
1270 def __setstate__(self, state):
1271 self.__init__(*state)
1279 def __init__(self, *args, **kwargs):
1280 Server.__init__(self, *args, **kwargs)
1281 address = self.address
1285 self.shared_memory_context = \
1289 def create(self, c, typeid, /, *args, **kwargs):
1295 if hasattr(self.registry[typeid][-1], "_shared_memory_proxy"):
1296 kwargs['shared_memory_context'] = self.shared_memory_context
1297 return Server.create(self, c, typeid, *args, **kwargs)
1299 def shutdown(self, c):
1301 self.shared_memory_context.unlink()
1302 return Server.shutdown(self, c)
1304 def track_segment(self, c, segment_name):
1306 self.shared_memory_context.register_segment(segment_name)
1308 def release_segment(self, c, segment_name):
1311 self.shared_memory_context.destroy_segment(segment_name)
1313 def list_segments(self, c):
1316 return self.shared_memory_context.segment_names
1331 def __init__(self, *args, **kwargs):
1340 BaseManager.__init__(self, *args, **kwargs)
1341 util.debug(f"{self.__class__.__name__} created by pid {getpid()}")
1343 def __del__(self):
1344 util.debug(f"{self.__class__.__name__}.__del__ by pid {getpid()}")
1346 def get_server(self):
1348 if self._state.value != State.INITIAL:
1349 if self._state.value == State.STARTED:
1351 elif self._state.value == State.SHUTDOWN:
1355 "Unknown state {!r}".format(self._state.value))
1356 return self._Server(self._registry, self._address,
1357 self._authkey, self._serializer)
1359 def SharedMemory(self, size):
1362 with self._Client(self._address, authkey=self._authkey) as conn:
1371 def ShareableList(self, sequence):
1374 with self._Client(self._address, authkey=self._authkey) as conn: