def setUp(self):
self.array_a = PortArray()
self.array_a.add_port('a_only')
self.array_a.add_port('in_both')
self.array_a.add_port('also_a_only')
self.array_b = PortArray()
self.array_b.add_port('b_only')
self.array_b.add_port('in_both')
def get_instance_metadata(self, service_map):
clone = self.__class__()
clone.ports = PortArray()
for port in self.get_provides():
provider_class = self.get_provider(port)
provider_instance = service_map[provider_class]
provider_flags = provider_instance.get_provider_flags(
port_name=port)
provider_func = provider_instance.get_provider_func(port_name=port)
clone.register_provider(port_name=port,
service=provider_instance,
flags=provider_flags)
# create and connect ports
clone.ports.add_port(port_name=port)
clone.ports.connect_port(port_name=port, func=provider_func)
return clone
def setUp(self):
self.ports = PortArray()
def __new__(mcs, name, bases, state):
if bases == (
INeed,
IProvide): # This is the Domain class itself, not its subclass
return type.__new__(mcs, name, bases, state)
mcs.validate_overridden_attributes(attrs=state, class_name=name)
if '__services__' not in state or not isinstance(
state['__services__'], (list, tuple)):
raise DomainDefinitionError(
'{}.__services__ must be defined with a list of component classes'
.format(name))
else:
service_classes = state['__services__']
for service_class in service_classes:
mcs._assert_is_compatible_class(name, service_class)
discovered = AutoDiscoverConnections(service_classes)
provides = state.get('__provides__', None)
if provides is None or not isinstance(provides,
(list, tuple, AutoProvide)):
raise DomainDefinitionError(
'{}.__provides__ must be defined with a list of port names'.
format(name))
else:
if isinstance(provides,
AutoProvide): # auto-discover provides ports
auto_provider = provides
provides_ports = auto_provider.filter(
discovered.get_provides())
else:
for port_name in provides:
if port_name not in discovered.get_provides():
msg = '"{}" listed in {}.__provides__ is not provided by any of the services'.format(
port_name,
name,
)
raise DomainDefinitionError(msg)
provides_ports = provides
# all unsatisfied deps are exposed as dependencies of the domain
state['deps'] = deps = PortArray()
for port_name in discovered.unsatisfied_needs():
deps.add_port(port_name)
# make a shadow copy of template_funcs. Used mainly for tracking intended interfaces for ports so we can
# use for validation during testing. At some point we might use this for wiring-time checks too to ensure
# compatibility between ports.
deps._needs_template_funcs = template_funcs = {}
for port in deps.get_ports():
template_func = mcs._assert_providers_compatible_and_extract_template_func(
providers=discovered._needs[port],
port_name=port,
)
template_funcs[port] = template_func
# declared 'provides' ports are registered and entry points created
state['meta'] = meta = DomainProviderMetadata()
for port in provides_ports:
provider = discovered.get_provider(port_name=port)
if not issubclass(provider, (Service, Domain)):
msg = 'Port of non-service class ({}.{}) cannot be published on the domain'.format(
provider.__name__, port)
raise DomainDefinitionError(msg)
inherited_flags = provider.get_provider_flags(port)
inherited_flags.pop('with_name',
None) # don't inherit name-change flags
meta.register_provider(port_name=port,
service=provider,
flags=inherited_flags)
state[port] = generate_domain_method(port_name=port,
provider=provider)
return type.__new__(mcs, name, bases, state)