def __create_remote_Conc__(Mgr, RemoteEnvId, CallingModule, ConcClass, *args,
**kwargs):
''' low-level support for Conc creation in another Env '''
ConcId = _ConcIdMgr.new()
NewConcAddr = ConcAddr(my_EnvId(), ConcId, RemoteEnvId)
ConcClassProxy = proxy(ConcClass, ConcClass.__name__ + 'Name',
CallingModule)
NewProxy = ConcClassProxy(NewConcAddr)
NewName = Name(NewProxy, ConcClass.__name__, CallingModule.__name__)
# create proxy for remote Env
EnvConcAddr = ConcAddr(CORPSMGR_ENVID, ENVMGR_CONCID, RemoteEnvId)
RemoteEnv = EnvName(EnvConcAddr)
# request object creation in remote Env
kwargs['ConcAddr'] = NewConcAddr
kwargs['Mgr'] = Mgr
FutRes = RemoteEnv.rem2loc_create_Conc(NewConcAddr, CallingModule.__name__,
ConcClass.__name__, *args, **kwargs)
try:
Ret = FutRes.Ret
except:
ei = exc_info()
ftb = format_exception(ei[0], ei[1], ei[2])
raise AsyncExecutionError(ei[0].__name__, ei[1], ''.join(ftb))
return NewName
def my_Name(self):
frm = stack()[1]
CallingModule = getmodule(frm[0])
SelfClassName = self.__class__.__name__
ConcClassProxy = proxy(self.__class__, SelfClassName + 'Name', CallingModule)
NewProxy = ConcClassProxy(self.ConcAddr)
NewName = Name(NewProxy, SelfClassName, CallingModule.__name__)
return NewName
def __init__(cls, name, bases, dct):
super(ConcMeta, cls).__init__(name, bases, dct)
#print(f'\nmetaclass init: {name} inherits from mro: {cls.mro()}\n')
# generate a Name (i.e. a proxy) for the Conc subclass (except Name itself) in the calling module
mro = cls.mro()
if mro[0].__module__ != 'Name':
frm = stack()[1]
CallingModule = getmodule(frm[0])
ClassProxy = proxy(cls, mro[0].__name__ + 'Name', CallingModule)
def my_Name(self):
''' Returns a new Name for the Conc instance '''
SelfClassName = self.__class__.__name__
CallingModuleName = self.__class__.__module__
CallingModule = import_module(CallingModuleName)
ConcClassProxy = proxy(self.__class__, SelfClassName + 'Name', CallingModule)
NewProxy = ConcClassProxy(self.ConcAddr)
NewName = Name(NewProxy, SelfClassName, CallingModuleName)
return NewName
def my_ExtName(self):
''' Returns a new ExtName for the Corps instance '''
# todo: after we implement to_ExtName(), maybe rewrite using Conc's verion and converting
SelfClassName = self.__class__.__name__
CallingModuleName = self.__class__.__module__
CallingModule = import_module(CallingModuleName)
CorpsClassProxy = proxy(self.__class__, SelfClassName + 'Name', CallingModule)
NewProxy = CorpsClassProxy(ConcAddr_to_ExtAddr(self.ConcAddr, my_Ip(), my_Port()))
NewName = Name(NewProxy, SelfClassName, CallingModuleName)
return NewName
def __create_local_Conc(Mgr, CallingModule, ConcClass, *args, **kwargs):
''' low-level support for Conc creation in this Env '''
ConcId = _ConcIdMgr.new()
NewConcAddr = ConcAddr(my_EnvId(), ConcId, my_EnvId())
ConcClassProxy = proxy(ConcClass, ConcClass.__name__ + 'Name',
CallingModule)
NewProxy = ConcClassProxy(NewConcAddr)
NewName = Name(NewProxy, ConcClass.__name__, CallingModule.__name__)
ConcClassInModule = getattr(CallingModule, ConcClass.__name__)
kwargs['ConcAddr'] = NewConcAddr
NewConc = ConcClassInModule(*args, **kwargs)
_Addr2Conc.register(NewConc, NewConcAddr)
return NewName
def __create_remote_Conc(Mgr, RemoteEnvId, CallingModule, ConcClass, *args,
**kwargs):
''' low-level support for Conc creation in another Env '''
ConcId = _ConcIdMgr.new()
NewConcAddr = ConcAddr(my_EnvId(), ConcId, RemoteEnvId)
ConcClassProxy = proxy(ConcClass, ConcClass.__name__ + 'Name',
CallingModule)
NewProxy = ConcClassProxy(NewConcAddr)
NewName = Name(NewProxy, ConcClass.__name__, CallingModule.__name__)
# create proxy for remote Env
EnvConcAddr = ConcAddr(CORPSMGR_ENVID, ENVMGR_CONCID, RemoteEnvId)
RemoteEnv = EnvName(EnvConcAddr)
# call rem2loc_create_Conc
kwargs['ConcAddr'] = NewConcAddr
FutRes = RemoteEnv.rem2loc_create_Conc(NewConcAddr, CallingModule.__name__,
ConcClass.__name__, *args, **kwargs)
Ret = FutRes.Ret
return NewName
def load_Corps(ConcClass, *args, **kwargs):
''' script-level support for loading top-level Corps '''
assert issubclass(ConcClass,
Corps) == True, f'{ConcClass.__name__} is not a Corps'
frm = stack()[1]
CallingModule = getmodule(frm[0])
ConcClassInModule = getattr(CallingModule, ConcClass.__name__)
ConfigFiles = 'ConfigFiles'
if ConfigFiles not in kwargs:
kwargs[ConfigFiles] = []
NewConc = ConcClassInModule(*args, **kwargs)
NewConcAddr = NewConc.ConcAddr
ConcClassProxy = proxy(ConcClass, ConcClass.__name__ + 'Name',
CallingModule)
NewProxy = ConcClassProxy(NewConcAddr)
NewName = Name(NewProxy, ConcClass.__name__, CallingModule.__name__)
return NewName
def create_Corps(CorpsClass, *args, Tag="No Name", Ext=True, Managed=True, ConfigFiles=[], ConfigDicts=[], \
LocType=LocType.Auto, LocVal=None, **kwargs):
''' create an ExtCorps from a script or an ExtCorps or ContCorps from calling Corps '''
assert issubclass(
CorpsClass,
Corps.Corps) == True, f'{CorpsClass.__name__} is not a type of Corps'
# todo: make sure inputs are clean/consistent
# get who called us
frm = stack()[1]
CallingModule = getmodule(frm[0])
# add our info to Config info
CreateDicts = ConfigDicts.copy()
CreateDict = {
'Tag': Tag,
'Ext': Ext,
'Managed': Managed,
'LocType': LocType,
'LocVal': LocVal
}
CreateDicts.append(CreateDict)
# Store kwargs for new Corps (will be processed by ConcMeta and stored as attributes)
kwargs['ConfigFiles'] = ConfigFiles
kwargs['ConfigDicts'] = CreateDicts
EnvStatus = my_EnvStatus()
if EnvStatus == MajorStatus.Running:
# Called from an existing Corps...the CorpsMgr will do the work
CorpsMgrConcAddr = ConcAddr(CORPSMGR_ENVID, CORPSMGR_CONCID,
CORPSMGR_ENVID)
TheCorpsMgr = Corps.CorpsMgrName(CorpsMgrConcAddr)
FutRet = TheCorpsMgr.create_Corps(CallingModule.__name__, CorpsClass.__name__, Tag, Ext, Managed, LocType, \
LocVal, *args, **kwargs)
# todo: Test for Exception
NewXferCorpsEnvRecord = FutRet.Ret
NewCorps_EnvId = NewXferCorpsEnvRecord.LocEnvId
NewCorps_Ip = NewXferCorpsEnvRecord.IpAddr
NewCorps_Port = NewXferCorpsEnvRecord.Port
elif EnvStatus == MajorStatus.Nonexistent:
# Called from a script...create the new Corps in another process
CreateDict['Ext'] = True
CreateDict['Managed'] = False
WorkerQueue = Queue()
NewCorpsProcess = Process(target=__other_process_create_Corps__, \
args=(CallingModule.__name__, CorpsClass.__name__, WorkerQueue, *args), kwargs=kwargs)
NewCorpsProcess.start()
NewCorpsData = WorkerQueue.get()
NewCorps_Ip = NewCorpsData[0]
NewCorps_Port = NewCorpsData[1]
if Managed == True and EnvStatus == MajorStatus.Running:
NewConcAddr = ConcAddr(CORPSMGR_ENVID, CORPS_CONCID, NewCorps_EnvId)
else:
NewConcAddr = ExtAddr(CORPSMGR_ENVID, CORPS_CONCID, CORPSMGR_ENVID,
NewCorps_Ip, NewCorps_Port)
ConcClassProxy = proxy(CorpsClass, CorpsClass.__name__ + 'Name',
CallingModule)
NewProxy = ConcClassProxy(NewConcAddr)
NewName = Name(NewProxy, CorpsClass.__name__, CallingModule.__name__)
return NewName
