def comm_count(self):
r"""int: The number of comms."""
out = 0
for k in self.cleanup_comm_classes:
cls = get_comm_class(k)
out += cls.comm_count()
return out
def _init_comms(self, name, icomm_kws=None, ocomm_kws=None, **kwargs):
r"""Parse keyword arguments for input/output comms."""
if icomm_kws is None:
icomm_kws = dict()
if ocomm_kws is None:
ocomm_kws = dict()
# Input communicator
self.debug("Creating input comm")
icomm_kws['direction'] = 'recv'
icomm_kws['dont_open'] = True
icomm_kws['reverse_names'] = True
icomm_kws['close_on_eof_recv'] = False
icomm_kws.setdefault('comm', self._icomm_type)
icomm_kws.setdefault('name', name)
if self._is_input:
ikws = get_comm_class(icomm_kws['comm'])._schema
for k in ikws:
if (k not in icomm_kws) and (k in kwargs):
icomm_kws[k] = kwargs[k]
self.icomm = new_comm(icomm_kws.pop('name'), **icomm_kws)
self.icomm_kws = icomm_kws
self.env.update(**self.icomm.opp_comms)
# Output communicator
self.debug("Creating output comm")
ocomm_kws['direction'] = 'send'
ocomm_kws['dont_open'] = True
ocomm_kws['reverse_names'] = True
ocomm_kws.setdefault('comm', self._ocomm_type)
ocomm_kws.setdefault('name', name)
if self._is_output:
okws = get_comm_class(ocomm_kws['comm'])._schema
for k in okws:
if (k not in ocomm_kws) and (k in kwargs):
ocomm_kws[k] = kwargs[k]
try:
self.ocomm = new_comm(ocomm_kws.pop('name'), **ocomm_kws)
except BaseException:
self.icomm.close()
raise
self.ocomm_kws = ocomm_kws
self.env.update(**self.ocomm.opp_comms)
def opp_comm_kwargs(self):
r"""Get keyword arguments to initialize communication with opposite
comm object.
Returns:
dict: Keyword arguments for opposite comm object.
"""
kwargs = super(ServerComm, self).opp_comm_kwargs()
kwargs['comm'] = get_comm_class("ClientComm")
kwargs['request_comm'] = self.icomm.comm_class
kwargs['response_kwargs'] = self.response_kwargs
return kwargs
def is_installed(cls, language=None):
r"""Determine if the necessary libraries are installed for this
communication class.
Args:
language (str, optional): Specific language that should be checked
for compatibility. Defaults to None and all languages supported
on the current platform will be checked.
Returns:
bool: Is the comm installed.
"""
return get_comm_class().is_installed(language=language)
def new_comm_kwargs(cls, name, request_comm=None, **kwargs):
r"""Initialize communication with new comms.
Args:
name (str): Name for new comm.
request_comm (str, optional): Name of class for new input comm.
Defaults to None.
"""
args = [name]
icomm_class = get_comm_class(request_comm)
kwargs['direction'] = 'recv'
if 'address' not in kwargs:
iargs, kwargs = icomm_class.new_comm_kwargs(name, **kwargs)
kwargs['request_comm'] = request_comm
return args, kwargs
def is_comm_installed(comm, language=None):
r"""Check to see if cis_interface can use a communication mechanism on the
current machine.
Args:
comm (str): Communication mechanism to check.
language (str, optional): Specific programming language that
communication mechanism should be check for. Defaults to None and
all supported languages will be checked.
Returns:
bool: True if the communication mechanism can be used on the current
machine, False otherwise.
"""
from cis_interface import communication
cmm = communication.get_comm_class(comm)
return cmm.is_installed(language=language)
def ErrorComm(name, base_comm='CommBase', **kwargs):
r"""Wrapper to return errored version of a comm class.
Args:
name (str): The environment variable where communication address is
stored.
base_comm (str, optional): Name of the base comm that should be used.
Defaults to 'CommBase'.
**kwargs: Additional keyword arguments are passed to the class
constructor.
Returns:
ErrorClass: Instance of a comm class that will raise an error at the
requested locaiton.
"""
base_class = get_comm_class(base_comm)
out = ErrorClass(base_class, name, **kwargs)
if base_comm is None:
base_comm = str(base_class).split("'")[1].split(".")[-1]
out._comm_class = base_comm
return out
def new_comm_kwargs(cls, name, *args, **kwargs):
r"""Get keyword arguments for new comm."""
if 'address' not in kwargs:
addresses = []
comm = kwargs.get('comm', None)
ncomm = kwargs.pop('ncomm', 0)
if comm is None:
comm = [None for i in range(ncomm)]
assert (isinstance(comm, list))
ncomm = len(comm)
for i in range(ncomm):
x = comm[i]
if x is None:
x = {}
iname = x.pop('name', get_comm_name(name, i))
icls = get_comm_class(x.get('comm', None))
_, ickw = icls.new_comm_kwargs(iname, **x)
ickw['name'] = iname
comm[i] = ickw
addresses.append(ickw['address'])
kwargs['comm'] = comm
kwargs['address'] = addresses
args = tuple([name] + list(args))
return args, kwargs
def comm_count(cls):
r"""int: Number of communication connections."""
return get_comm_class().comm_count()
def underlying_comm_class(self):
r"""str: Name of underlying communication class."""
return get_comm_class().underlying_comm_class()
def new_comm_kwargs(cls,
name,
address=None,
icomm_name=None,
ocomm_name=None,
icomm_comm=None,
ocomm_comm=None,
icomm_kwargs=None,
ocomm_kwargs=None,
**kwargs):
r"""Initialize communication with new comms.
Args:
name (str): Name for new comm.
address (str, optional): Communication info. Default to None and
address is taken from combination of input/output comm addresses
that are provided or generated.
icomm_name (str, optional): Name for new input comm. Defaults to
name + '_IN'. This will be overriden if 'name' is in
icomm_kwargs.
ocomm_name (str, optional): Name for new output comm. Defaults to
name + '_OUT'. This will be overriden if 'name' is in
ocomm_kwargs.
icomm_comm (str, optional): Name of class for new input comm.
Defaults to None. This will be overrriden if 'comm' is in
icomm_kwargs.
ocomm_comm (str, optional): Name of class for new output comm.
Defaults to None. This will be overrriden if 'comm' is in
ocomm_kwargs.
icomm_kwargs (dict, optional): Keyword arguments for the icomm_comm
new_comm_kwargs class method.
ocomm_kwargs (dict, optional): Keyword arguments for the ocomm_comm
new_comm_kwargs class method.
"""
args = [name]
if icomm_kwargs is None:
icomm_kwargs = dict()
if ocomm_kwargs is None:
ocomm_kwargs = dict()
if icomm_name is None:
icomm_name = name
if ocomm_name is None:
ocomm_name = name
icomm_name = icomm_kwargs.pop('name', icomm_name)
ocomm_name = ocomm_kwargs.pop('name', ocomm_name)
icomm_comm = icomm_kwargs.pop('comm', icomm_comm)
ocomm_comm = ocomm_kwargs.pop('comm', ocomm_comm)
icomm_class = get_comm_class(icomm_comm)
ocomm_class = get_comm_class(ocomm_comm)
icomm_kwargs['direction'] = 'recv'
ocomm_kwargs['direction'] = 'send'
ikwargs = copy.deepcopy(kwargs)
okwargs = copy.deepcopy(kwargs)
ikwargs.update(**icomm_kwargs)
okwargs.update(**ocomm_kwargs)
if address is None:
if 'address' not in icomm_kwargs:
iargs, ikwargs = icomm_class.new_comm_kwargs(
icomm_name, **icomm_kwargs)
if 'address' not in ocomm_kwargs:
oargs, okwargs = ocomm_class.new_comm_kwargs(
ocomm_name, **ocomm_kwargs)
else:
kwargs['address'] = address
ikwargs['address'], okwargs['address'] = address.split(
_rpc_address_split)
ikwargs['name'] = icomm_name
okwargs['name'] = ocomm_name
ikwargs['comm'] = icomm_comm
okwargs['comm'] = ocomm_comm
kwargs['icomm_kwargs'] = ikwargs
kwargs['ocomm_kwargs'] = okwargs
return args, kwargs
def is_installed(cls):
r"""bool: Is the comm installed."""
return get_comm_class().is_installed()
