def _createInstance(self): aClass = self._actorClass try: aClass = actualActorClass(aClass, partial(loadModuleFromHashSource, self._sourceHash, self._sources) if self._sourceHash else None) # Now instantiate the identified Actor class object actorInst = aClass() self._sCBStats.inc('Actor.Instance Created') except Exception as ex: import traceback logging.getLogger(str(self._actorClass)) \ .error('Actor %s @ %s instantiation exception', self._actorClass, self.transport.myAddress, exc_info = True) thesplog('Actor %s @ %s instantiation exception: %s', self._actorClass, self.transport.myAddress, traceback.format_exc(), level=logging.ERROR, primary=True) self._sCBStats.inc('Actor.Instance Create Failed') self._sayGoodbye() return self.actorInst = actorInst self.actorInst._myRef = self
def _not_compatible(self, createActorEnvelope): # Called when the current Actor System is not compatible with # the Actor's actorSystemCapabilityCheck. Forward this # createActor request to another system that it's compatible # with. sourceHash = createActorEnvelope.message.sourceHash childRequirements = createActorEnvelope.message.targetActorReq childCName = createActorEnvelope.message.actorClassName childClass = actualActorClass( childCName, partial(loadModuleFromHashSource, sourceHash, self._sources) if sourceHash else None) acceptsCaps = lambda caps: checkActorCapabilities( childClass, caps, childRequirements) if createActorEnvelope.message.forActor is None: # Request from external; use sender address createActorEnvelope.message.forActor = createActorEnvelope.sender iolist = self._cstate.forward_pending_to_remote_system( childClass, createActorEnvelope, sourceHash, acceptsCaps) if iolist: for each in iolist: # Expected to be only one; if the transmit fails, # route it back here so that the next possible # remote can be tried. each.addCallback(onFailure=self._pending_send_failed) each.orig_create_envelope = createActorEnvelope return self._performIO(iolist) self._sendPendingActorResponse( createActorEnvelope, None, errorCode=PendingActorResponse.ERROR_No_Compatible_ActorSystem, errorStr="") # self._retryPendingChildOperations(childInstance, None) return True
def _createInstance(self): aClass = self._actorClass try: aClass = actualActorClass( aClass, partial(loadModuleFromHashSource, self._sourceHash, self._sources) if self._sourceHash else None) # Now instantiate the identified Actor class object actorInst = aClass() self._sCBStats.inc('Actor.Instance Created') except Exception as ex: import traceback logging.getLogger(str(self._actorClass)) \ .error('Actor %s @ %s instantiation exception', self._actorClass, self.transport.myAddress, exc_info = True) thesplog('Actor %s @ %s instantiation exception: %s', self._actorClass, self.transport.myAddress, traceback.format_exc(), level=logging.ERROR, primary=True) self._sCBStats.inc('Actor.Instance Create Failed') self._sayGoodbye() return self.actorInst = actorInst self.actorInst._myRef = self
def _createInstance(self): aClass = self._actorClass try: aClass = actualActorClass( aClass, partial(loadModuleFromHashSource, self._sourceHash, self._sources) if self._sourceHash else None) # Now instantiate the identified Actor class object actorInst = withPossibleInitArgs(capabilities=self.capabilities, requirements=self._childReqs, globalName=self.globalName) \ .create(aClass) self._sCBStats.inc('Actor.Instance Created') except Exception as ex: import traceback logging.getLogger(str(self._actorClass)) \ .error('Actor %s @ %s instantiation exception', self._actorClass, self.transport.myAddress, exc_info = True) thesplog('Actor %s @ %s instantiation exception: %s', self._actorClass, self.transport.myAddress, traceback.format_exc(), level=logging.WARNING, primary=True) self._sCBStats.inc('Actor.Instance Create Failed') self._sayGoodbye() return self.actorInst = actorInst self.actorInst._myRef = self
def _newRefAndActor(self, actorSystem, parentAddr, actorAddr, actorClass, sourceHash=None, isTopLevel=False): try: actorClass = actualActorClass(actorClass, functools.partial( loadModuleFromHashSource, sourceHash, self._sources) if sourceHash else None) try: actor = actorClass(childActors=None) except TypeError as te: if "unexpected keyword argument 'childActors'" in str(te): actor = actorClass() else: actor = None except ActorSystemException: logging.getLogger('Thespian').warning('Actor total creation failure', exc_info=True) actor = None if isTopLevel: raise except ImportError: logging.getLogger('Thespian').warning('Actor create import error for %s', actorClass, exc_info=True) raise except Exception: logging.getLogger('Thespian').warning('Actor total creation error', exc_info=True) actor = None nar = ActorRef(actorSystem, parentAddr, actorAddr, actor, mySourceHash=sourceHash) if actor: nar.instance._myRef = nar nar.instance._receive = types.MethodType(actor_base_receive, nar.instance) return nar
def _newRefAndActor(self, actorSystem, parentAddr, actorAddr, actorClass, sourceHash = None, isTopLevel = False): try: actorClass = actualActorClass(actorClass, functools.partial( loadModuleFromHashSource, sourceHash, self._sources) if sourceHash else None) try: actor = actorClass(childActors=None) except TypeError as te: if "unexpected keyword argument 'childActors'" in str(te): actor = actorClass() else: actor = None except ActorSystemException: logging.getLogger('Thespian').warning('Actor total creation failure', exc_info=True) actor = None if isTopLevel: raise except ImportError: logging.getLogger('Thespian').warning('Actor create import error for %s (hash %s)', actorClass, sourceHash, exc_info=True) raise except Exception: logging.getLogger('Thespian').warning('Actor total creation error', exc_info=True) actor = None nar = ActorRef(actorSystem, parentAddr, actorAddr, actor, mySourceHash=sourceHash) if actor: nar.instance._myRef = nar nar.instance._receive = types.MethodType(actor_base_receive, nar.instance) return nar
def _newRefAndActor(self, actorSystem, parentAddr, actorAddr, actorClass, sourceHash=None, targetActorRequirements=None, isTopLevel=False): try: actorClass = actualActorClass( actorClass, functools.partial(loadModuleFromHashSource, sourceHash, self._sources) if sourceHash else None) if hasattr(actorClass, 'actorSystemCapabilityCheck') and \ not actorClass.actorSystemCapabilityCheck( self.system.capabilities, targetActorRequirements or {}): actor = None else: actor = withPossibleInitArgs( capabilities=self.system.capabilities, requirements=targetActorRequirements) \ .create(actorClass) except ActorSystemException: logging.getLogger('Thespian').warning( 'Actor total creation failure', exc_info=True) actor = None if isTopLevel: raise except ImportError: logging.getLogger('Thespian').warning( 'Actor create import error for %s (hash %s)', actorClass, sourceHash, exc_info=True) raise except Exception: logging.getLogger('Thespian').warning('Actor total creation error', exc_info=True) actor = None if isTopLevel: raise nar = ActorRef(actorSystem, parentAddr, actorAddr, actor, mySourceHash=sourceHash) if actor: nar.instance._myRef = nar nar.instance._receive = types.MethodType(actor_base_receive, nar.instance) return nar
def h_PendingActor(self, envelope): sourceHash = envelope.message.sourceHash childRequirements = envelope.message.targetActorReq thesplog('Pending Actor request received for %s%s reqs %s from %s', envelope.message.actorClassName, ' (%s)'%sourceHash if sourceHash else '', childRequirements, envelope.sender) if sourceHash: if sourceHash not in self._sources: # If this request was forwarded by a remote Admin and the # sourceHash is not known locally, request it from the sending # remote Admin if self._cstate.sentByRemoteAdmin(envelope) and \ self._acceptsRemoteLoadedSourcesFrom(envelope): self._sources[sourceHash] = PendingSource(sourceHash, None) self._sources[sourceHash].pending_actors.append(envelope) self._hysteresisSender.sendWithHysteresis( TransmitIntent( envelope.sender, SourceHashTransferRequest(sourceHash, bool(self._sourceAuthority)))) # sent with hysteresis, so break out to local _run return False if sourceHash in self._sources and \ not self._sources[sourceHash].source_valid: # Still pending, add this create request to the waiting list self._sources[sourceHash].pending_actors.append(envelope) return True # If the requested ActorClass is compatible with this # ActorSystem, attempt to start it, otherwise forward the # request to any known compatible ActorSystem. childClass = envelope.message.actorClassName try: childClass = actualActorClass(envelope.message.actorClassName, partial(loadModuleFromHashSource, sourceHash, self._sources) if sourceHash else None) acceptsCaps = lambda caps: checkActorCapabilities(childClass, caps, childRequirements) if not acceptsCaps(self.capabilities): if envelope.message.forActor is None: # Request from external; use sender address envelope.message.forActor = envelope.sender iolist = self._cstate.forward_pending_to_remote_system( childClass, envelope, sourceHash, acceptsCaps) for each in iolist: # Expected to be only one; if the transmit fails, # route it back here so that the next possible # remote can be tried. each.addCallback(onFailure=self._pending_send_failed) self._performIO(iolist) return True except NoCompatibleSystemForActor as ex: thesplog(str(ex), level=logging.WARNING, primary=True) self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_No_Compatible_ActorSystem) return True except InvalidActorSourceHash: self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Invalid_SourceHash) return True except InvalidActorSpecification as ex: thesplog('Error: InvalidActorSpecification: %s', str(ex), exc_info=True) self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Invalid_ActorClass, errorStr=str(ex)) return True except ImportError as ex: self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Import, errorStr=str(ex)) return True except AttributeError as ex: # Usually when the module has no attribute FooActor thesplog('Error: AttributeError: %s', str(ex), exc_info=True) self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Invalid_ActorClass, errorStr=str(ex)) return True except Exception as ex: import traceback thesplog('Exception "%s" handling PendingActor: %s', ex, traceback.format_exc(), level=logging.ERROR) self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Invalid_ActorClass, errorStr=str(ex)) return True return super(ConventioneerAdmin, self).h_PendingActor(envelope)
def h_PendingActor(self, envelope): sourceHash = envelope.message.sourceHash childRequirements = envelope.message.targetActorReq thesplog('Pending Actor request for %s%s reqs %s from %s', envelope.message.actorClassName, ' (%s)' % sourceHash if sourceHash else '', childRequirements, envelope.sender) # If this request was forwarded by a remote Admin and the # sourceHash is not known locally, request it from the sending # remote Admin if sourceHash and \ sourceHash not in self._sources and \ self._sentByRemoteAdmin(envelope) and \ self._acceptsRemoteLoadedSourcesFrom(envelope): requestedAlready = self._pendingSources.get(sourceHash, False) self._pendingSources.setdefault(sourceHash, []).append(envelope) if not requestedAlready: self._hysteresisSender.sendWithHysteresis( TransmitIntent(envelope.sender, SourceHashTransferRequest(sourceHash))) return False # sent with hysteresis, so break out to local _run return True # If the requested ActorClass is compatible with this # ActorSystem, attempt to start it, otherwise forward the # request to any known compatible ActorSystem. try: childClass = actualActorClass( envelope.message.actorClassName, partial(loadModuleFromHashSource, sourceHash, self._sources) if sourceHash else None) acceptsCaps = lambda caps: checkActorCapabilities( childClass, caps, childRequirements) if not acceptsCaps(self.capabilities): if envelope.message.forActor is None: # Request from external; use sender address envelope.message.forActor = envelope.sender remoteCandidates = [ K for K in self._conventionMembers if not self._conventionMembers[K].registryValid.expired() and self._conventionMembers[K].remoteAddress != envelope.sender # source Admin and self._conventionMembers[K].remoteAddress not in getattr(envelope.message, 'alreadyTried', []) and acceptsCaps(self._conventionMembers[K].remoteCapabilities) ] if not remoteCandidates: if self.isConventionLeader(): thesplog( 'No known ActorSystems can handle a %s for %s', childClass, envelope.message.forActor, level=logging.WARNING, primary=True) self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse. ERROR_No_Compatible_ActorSystem) return True # Let the Convention Leader try to find an appropriate ActorSystem bestC = self._conventionAddress else: # distribute equally amongst candidates C = [(self._conventionMembers[K].remoteAddress, len(self._conventionMembers[K].hasRemoteActors)) for K in remoteCandidates] bestC = foldl( lambda best, possible: best if best[1] <= possible[1] else possible, C)[0] thesplog('Requesting creation of %s%s on remote admin %s', envelope.message.actorClassName, ' (%s)' % sourceHash if sourceHash else '', bestC) envelope.message.alreadyTried.append(self.myAddress) self._send_intent(TransmitIntent(bestC, envelope.message)) return True except InvalidActorSourceHash: self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Invalid_SourceHash) return True except InvalidActorSpecification: self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Invalid_ActorClass) return True except ImportError as ex: self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Import, errorStr=str(ex)) return True except AttributeError as ex: # Usually when the module has no attribute FooActor self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Invalid_ActorClass, errorStr=str(ex)) return True except Exception as ex: import traceback thesplog('Exception "%s" handling PendingActor: %s', ex, traceback.format_exc()) self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Invalid_ActorClass, errorStr=str(ex)) return True return super(ConventioneerAdmin, self).h_PendingActor(envelope)
def h_PendingActor(self, envelope): sourceHash = envelope.message.sourceHash childRequirements = envelope.message.targetActorReq thesplog('Pending Actor request received for %s%s reqs %s from %s', envelope.message.actorClassName, ' (%s)' % sourceHash if sourceHash else '', childRequirements, envelope.sender) # If this request was forwarded by a remote Admin and the # sourceHash is not known locally, request it from the sending # remote Admin if sourceHash and \ sourceHash not in self._sources and \ self._cstate.sentByRemoteAdmin(envelope) and \ self._acceptsRemoteLoadedSourcesFrom(envelope): requestedAlready = self._pendingSources.get(sourceHash, False) self._pendingSources.setdefault(sourceHash, []).append(envelope) if not requestedAlready: self._hysteresisSender.sendWithHysteresis( TransmitIntent(envelope.sender, SourceHashTransferRequest(sourceHash))) return False # sent with hysteresis, so break out to local _run return True # If the requested ActorClass is compatible with this # ActorSystem, attempt to start it, otherwise forward the # request to any known compatible ActorSystem. childClass = envelope.message.actorClassName try: childClass = actualActorClass( envelope.message.actorClassName, partial(loadModuleFromHashSource, sourceHash, self._sources) if sourceHash else None) acceptsCaps = lambda caps: checkActorCapabilities( childClass, caps, childRequirements) if not acceptsCaps(self.capabilities): if envelope.message.forActor is None: # Request from external; use sender address envelope.message.forActor = envelope.sender iolist = self._cstate.forward_pending_to_remote_system( childClass, envelope, sourceHash, acceptsCaps) for each in iolist: # Expected to be only one; if the transmit fails, # route it back here so that the next possible # remote can be tried. each.addCallback(onFailure=self._pending_send_failed) self._performIO(iolist) return True except NoCompatibleSystemForActor as ex: thesplog(str(ex), level=logging.WARNING, primary=True) self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_No_Compatible_ActorSystem) return True except InvalidActorSourceHash: self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Invalid_SourceHash) return True except InvalidActorSpecification: self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Invalid_ActorClass) return True except ImportError as ex: self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Import, errorStr=str(ex)) return True except AttributeError as ex: # Usually when the module has no attribute FooActor self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Invalid_ActorClass, errorStr=str(ex)) return True except Exception as ex: import traceback thesplog('Exception "%s" handling PendingActor: %s', ex, traceback.format_exc(), level=logging.ERROR) self._sendPendingActorResponse( envelope, None, errorCode=PendingActorResponse.ERROR_Invalid_ActorClass, errorStr=str(ex)) return True return super(ConventioneerAdmin, self).h_PendingActor(envelope)
def h_PendingActor(self, envelope): sourceHash = envelope.message.sourceHash childRequirements = envelope.message.targetActorReq # If this request was forwarded by a remote Admin and the # sourceHash is not known locally, request it from the sending # remote Admin if sourceHash and \ sourceHash not in self._sources and \ self._sentByRemoteAdmin(envelope) and \ self._acceptsRemoteLoadedSourcesFrom(envelope): requestedAlready = self._pendingSources.get(sourceHash, False) self._pendingSources.setdefault(sourceHash, []).append(envelope) if not requestedAlready: self._hysteresisSender.sendWithHysteresis( TransmitIntent(envelope.sender, SourceHashTransferRequest(sourceHash))) return False # sent with hysteresis, so break out to local _run return True # If the requested ActorClass is compatible with this # ActorSystem, attempt to start it, otherwise forward the # request to any known compatible ActorSystem. try: childClass = actualActorClass(envelope.message.actorClassName, partial(loadModuleFromHashSource, sourceHash, self._sources) if sourceHash else None) acceptsCaps = lambda caps: checkActorCapabilities(childClass, caps, childRequirements) if not acceptsCaps(self.capabilities): if envelope.message.forActor is None: # Request from external; use sender address envelope.message.forActor = envelope.sender remoteCandidates = [ K for K in self._conventionMembers if not self._conventionMembers[K].registryValid.expired() and self._conventionMembers[K].remoteAddress != envelope.sender # source Admin and acceptsCaps(self._conventionMembers[K].remoteCapabilities)] if not remoteCandidates: if self.isConventionLeader(): thesplog('No known ActorSystems can handle a %s for %s', childClass, envelope.message.forActor, level=logging.WARNING, primary=True) self._sendPendingActorResponse(envelope, None, errorCode = PendingActorResponse.ERROR_No_Compatible_ActorSystem) return True # Let the Convention Leader try to find an appropriate ActorSystem bestC = self._conventionAddress else: # distribute equally amongst candidates C = [(self._conventionMembers[K].remoteAddress, len(self._conventionMembers[K].hasRemoteActors)) for K in remoteCandidates] bestC = foldl(lambda best,possible: best if best[1] <= possible[1] else possible, C)[0] self._send_intent(TransmitIntent(bestC, envelope.message)) return True except InvalidActorSourceHash: self._sendPendingActorResponse(envelope, None, errorCode = PendingActorResponse.ERROR_Invalid_SourceHash) return True except InvalidActorSpecification: self._sendPendingActorResponse(envelope, None, errorCode = PendingActorResponse.ERROR_Invalid_ActorClass) return True except ImportError: self._sendPendingActorResponse(envelope, None, errorCode = PendingActorResponse.ERROR_Import) return True return super(ConventioneerAdmin, self).h_PendingActor(envelope)