def __init__(self, uri, control_uri, attributes=None):
super(Node, self).__init__()
self.uri = uri
self.control_uri = control_uri
try:
self.attributes = AttributeResolver(attributes)
except:
_log.exception("Attributes not correct, uses empty attribute!")
self.attributes = AttributeResolver(None)
self.id = calvinuuid.uuid("NODE")
self.monitor = Event_Monitor()
self.am = actormanager.ActorManager(self)
self.control = calvincontrol.get_calvincontrol()
_scheduler = scheduler.DebugScheduler if _log.getEffectiveLevel() <= logging.DEBUG else scheduler.Scheduler
self.sched = _scheduler(self, self.am, self.monitor)
self.control.start(node=self, uri=control_uri)
self.async_msg_ids = {}
self._calvinsys = CalvinSys(self)
# Default will multicast and listen on all interfaces
# TODO: be able to specify the interfaces
# @TODO: Store capabilities
self.storage = storage.Storage(self)
self.network = CalvinNetwork(self)
self.proto = CalvinProto(self, self.network)
self.pm = PortManager(self, self.proto)
self.app_manager = appmanager.AppManager(self)
# The initialization that requires the main loop operating is deferred to start function
async.DelayedCall(0, self.start)
def __init__(self, uri, control_uri, attributes=None):
super(Node, self).__init__()
self.uri = uri
self.control_uri = control_uri
self.attributes = attributes
self.id = calvinuuid.uuid("NODE")
_log.debug("Calvin init 1")
self.monitor = Event_Monitor()
_log.debug("Calvin init 2")
self.am = actormanager.ActorManager(self)
_log.debug("Calvin init 3")
self.control = calvincontrol.get_calvincontrol()
_log.debug("Calvin init 4")
self.sched = scheduler.Scheduler(self, self.am, self.monitor)
_log.debug("Calvin init 5")
self.control.start(node=self, uri=control_uri)
self.async_msg_ids = {}
_log.debug("Calvin init 6")
self.storage = storage.Storage()
self.storage.start()
_log.debug("Calvin init 7")
self.network = CalvinNetwork(self)
_log.debug("Calvin init 8")
self.proto = CalvinProto(self, self.network)
self.pm = PortManager(self, self.proto)
_log.debug("Calvin init 9")
self.app_manager = appmanager.AppManager(self)
_log.debug("Calvin init 10")
# The initialization that requires the main loop operating is deferred to start function
async.DelayedCall(0, self.start)
_log.debug("Calvin init 11")
def __init__(self, actor_type, name='', allow_invalid_transitions=True, disable_transition_checks=False,
disable_state_checks=False, actor_id=None, app_id=""):
"""Should _not_ be overridden in subclasses."""
super(Actor, self).__init__()
self._type = actor_type
self.name = name # optional: human_readable_name
self.id = actor_id or calvinuuid.uuid("ACTOR")
self.master_nodes = []
_log.debug("New actor id: %s, supplied actor id %s" % (self.id, actor_id))
self.app_id = app_id
self._deployment_requirements = []
self._signature = None
self._component_members = set([self.id]) # We are only part of component if this is extended
self._managed = set(('id', 'name', '_deployment_requirements', '_signature', 'master_nodes'))
self._calvinsys = None
self._using = {}
self.control = calvincontrol.get_calvincontrol()
self.metering = metering.get_metering()
self._migrating_to = None # During migration while on the previous node set to the next node id
self._last_time_warning = 0.0
self.inports = {p: actorport.InPort(p, self) for p in self.inport_names}
self.outports = {p: actorport.OutPort(p, self) for p in self.outport_names}
hooks = {
(Actor.STATUS.PENDING, Actor.STATUS.ENABLED): self.will_start,
(Actor.STATUS.ENABLED, Actor.STATUS.PENDING): self.will_stop,
}
self.fsm = Actor.FSM(Actor.STATUS, Actor.STATUS.LOADED, Actor.VALID_TRANSITIONS, hooks,
allow_invalid_transitions=allow_invalid_transitions,
disable_transition_checks=disable_transition_checks,
disable_state_checks=disable_state_checks)
self.metering.add_actor_info(self)
def __init__(self, actor_type, name='', allow_invalid_transitions=True, disable_transition_checks=False,
disable_state_checks=False, actor_id=None):
"""Should _not_ be overridden in subclasses."""
super(Actor, self).__init__()
self._type = actor_type
self.name = name # optional: human_readable_name
self.id = actor_id or calvinuuid.uuid("ACTOR")
self._deployment_requirements = []
self._managed = set(('id', 'name', '_deployment_requirements'))
self._calvinsys = None
self._using = {}
self.control = calvincontrol.get_calvincontrol()
self._migrating_to = None # During migration while on the previous node set to the next node id
self.inports = {p: actorport.InPort(p, self) for p in self.inport_names}
self.outports = {p: actorport.OutPort(p, self) for p in self.outport_names}
hooks = {
(Actor.STATUS.PENDING, Actor.STATUS.ENABLED): self.will_start,
(Actor.STATUS.ENABLED, Actor.STATUS.PENDING): self.will_stop,
}
self.fsm = Actor.FSM(Actor.STATUS, Actor.STATUS.LOADED, Actor.VALID_TRANSITIONS, hooks,
allow_invalid_transitions=allow_invalid_transitions,
disable_transition_checks=disable_transition_checks,
disable_state_checks=disable_state_checks)
def __init__(self,
actor_type,
name='',
allow_invalid_transitions=True,
disable_transition_checks=False,
disable_state_checks=False,
actor_id=None,
security=None):
"""Should _not_ be overridden in subclasses."""
super(Actor, self).__init__()
self._type = actor_type
self.name = name # optional: human_readable_name
self.id = actor_id or calvinuuid.uuid("ACTOR")
_log.debug("New actor id: %s, supplied actor id %s" %
(self.id, actor_id))
self._deployment_requirements = []
self._signature = None
self._component_members = set(
[self.id]) # We are only part of component if this is extended
self._managed = set(
('id', 'name', '_deployment_requirements', '_signature',
'subject_attributes', 'migration_info'))
self._calvinsys = None
self._using = {}
self.control = calvincontrol.get_calvincontrol()
self.metering = metering.get_metering()
self.migration_info = None
self._migrating_to = None # During migration while on the previous node set to the next node id
self._last_time_warning = 0.0
self.sec = security
self.subject_attributes = self.sec.get_subject_attributes(
) if self.sec is not None else None
self.authorization_checks = None
self.inports = {
p: actorport.InPort(p, self)
for p in self.inport_names
}
self.outports = {
p: actorport.OutPort(p, self)
for p in self.outport_names
}
hooks = {
(Actor.STATUS.PENDING, Actor.STATUS.ENABLED): self.will_start,
(Actor.STATUS.ENABLED, Actor.STATUS.PENDING): self.will_stop,
}
self.fsm = Actor.FSM(
Actor.STATUS,
Actor.STATUS.LOADED,
Actor.VALID_TRANSITIONS,
hooks,
allow_invalid_transitions=allow_invalid_transitions,
disable_transition_checks=disable_transition_checks,
disable_state_checks=disable_state_checks)
self.metering.add_actor_info(self)
def __init__(self, control_uri):
super(StorageNode, self).__init__()
self.id = calvinuuid.uuid("NODE")
self.control_uri = control_uri
self.control = calvincontrol.get_calvincontrol()
_scheduler = scheduler.DebugScheduler if _log.getEffectiveLevel() <= logging.DEBUG else scheduler.Scheduler
self.sched = _scheduler(self, FakeAM(), FakeMonitor())
self.control.start(node=self, uri=control_uri)
self.storage = storage.Storage(self)
async.DelayedCall(0, self.start)
def __init__(self, control_uri):
super(StorageNode, self).__init__()
self.id = calvinuuid.uuid("NODE")
self.control_uri = control_uri
self.control = calvincontrol.get_calvincontrol()
_scheduler = scheduler.DebugScheduler if _log.getEffectiveLevel(
) <= logging.DEBUG else scheduler.Scheduler
self.sched = _scheduler(self, FakeAM(), FakeMonitor())
self.control.start(node=self, uri=control_uri)
self.storage = storage.Storage(self)
async .DelayedCall(0, self.start)
def __init__(self, uri, control_uri, attributes=None, self_start=True):
super(Node, self).__init__()
self.uri = uri
self.control_uri = control_uri
try:
self.attributes = AttributeResolver(attributes)
except:
_log.exception("Attributes not correct, uses empty attribute!")
self.attributes = AttributeResolver(None)
self.id = calvinuuid.uuid("NODE")
self.metering = metering.set_metering(metering.Metering(self))
self.monitor = Event_Monitor()
self.am = actormanager.ActorManager(self)
self.control = calvincontrol.get_calvincontrol()
_scheduler = scheduler.DebugScheduler if _log.getEffectiveLevel() <= logging.DEBUG else scheduler.Scheduler
self.sched = _scheduler(self, self.am, self.monitor)
self.async_msg_ids = {}
self._calvinsys = CalvinSys(self)
hb_timeout = _conf.get('global', 'heartbeat_timeout') or DEFAULT_HEARTBEAT_TIMEOUT
self.heartbeat_timeout = float(hb_timeout)
hb_delay = _conf.get('global', 'heartbeat_delay') or DEFAULT_HEARTBEAT_DELAY
self.heartbeat_delay = float(hb_delay)
self.heartbeat_addr = self._clean_addr()
self.heartbeat_port = _conf.get('global', 'heartbeat_port') or int(self._clean_uri().split(":")[1]) + DEFAULT_HEARTBEAT_PORT_DIFF
rr_delay = _conf.get('global', 'resource_reporter_delay') or 0.25
self.resource_reporter_delay = float(rr_delay)
# Default will multicast and listen on all interfaces
# TODO: be able to specify the interfaces
# @TODO: Store capabilities
self.storage = storage.Storage(self)
self.network = CalvinNetwork(self)
self.proto = CalvinProto(self, self.network)
self.pm = PortManager(self, self.proto)
self.app_manager = appmanager.AppManager(self)
self.resource_manager = ResourceManager()
self.app_monitor = AppMonitor(self, self.app_manager, self.storage)
self.lost_node_handler = LostNodeHandler(self, self.resource_manager, self.pm, self.am, self.storage)
self.heartbeat_actor = None
self.outgoing_heartbeats = defaultdict(list)
# The initialization that requires the main loop operating is deferred to start function
if self_start:
async.DelayedCall(0, self.start)
def __init__(self, uri, control_uri, attributes=None):
super(Node, self).__init__()
self.uri = uri
self.control_uri = control_uri
self.external_uri = attributes.pop('external_uri', self.uri) \
if attributes else self.uri
self.external_control_uri = attributes.pop('external_control_uri', self.control_uri) \
if attributes else self.control_uri
try:
self.attributes = AttributeResolver(attributes)
except:
_log.exception("Attributes not correct, uses empty attribute!")
self.attributes = AttributeResolver(None)
self.node_name = self.attributes.get_node_name_as_str()
# Obtain node id, when using security also handle runtime certificate
self.id = certificate.obtain_cert_node_info(self.node_name)['id']
self.authentication = authentication.Authentication(self)
self.authorization = authorization.Authorization(self)
try:
self.domain = _conf.get("security", "security_domain_name")
# cert_name is the node's certificate filename (without file extension)
self.cert_name = certificate.get_own_cert_name(self.node_name)
except:
self.domain = None
self.cert_name = None
self.metering = metering.set_metering(metering.Metering(self))
self.monitor = Event_Monitor()
self.am = actormanager.ActorManager(self)
self.control = calvincontrol.get_calvincontrol()
_scheduler = scheduler.DebugScheduler if _log.getEffectiveLevel() <= logging.DEBUG else scheduler.Scheduler
self.sched = _scheduler(self, self.am, self.monitor)
self.async_msg_ids = {}
self._calvinsys = CalvinSys(self)
# Default will multicast and listen on all interfaces
# TODO: be able to specify the interfaces
# @TODO: Store capabilities
self.storage = storage.Storage(self)
self.network = CalvinNetwork(self)
self.proto = CalvinProto(self, self.network)
self.pm = PortManager(self, self.proto)
self.app_manager = appmanager.AppManager(self)
# The initialization that requires the main loop operating is deferred to start function
async.DelayedCall(0, self.start)
def __init__(self,
actor_type,
name='',
allow_invalid_transitions=True,
disable_transition_checks=False,
disable_state_checks=False,
actor_id=None):
"""Should _not_ be overridden in subclasses."""
super(Actor, self).__init__()
self._type = actor_type
self.name = name # optional: human_readable_name
self.id = actor_id or calvinuuid.uuid("ACTOR")
self._deployment_requirements = []
self._managed = set(('id', 'name', '_deployment_requirements'))
self._calvinsys = None
self._using = {}
self.control = calvincontrol.get_calvincontrol()
self._migrating_to = None # During migration while on the previous node set to the next node id
self.inports = {
p: actorport.InPort(p, self)
for p in self.inport_names
}
self.outports = {
p: actorport.OutPort(p, self)
for p in self.outport_names
}
hooks = {
(Actor.STATUS.PENDING, Actor.STATUS.ENABLED): self.will_start,
(Actor.STATUS.ENABLED, Actor.STATUS.PENDING): self.will_stop,
}
self.fsm = Actor.FSM(
Actor.STATUS,
Actor.STATUS.LOADED,
Actor.VALID_TRANSITIONS,
hooks,
allow_invalid_transitions=allow_invalid_transitions,
disable_transition_checks=disable_transition_checks,
disable_state_checks=disable_state_checks)
def __init__(self, actor_type, name='', allow_invalid_transitions=True, disable_transition_checks=False,
disable_state_checks=False, actor_id=None):
"""Should normally _not_ be overridden in subclasses."""
super(Actor, self).__init__()
self._type = actor_type
self.name = name # optional: human_readable_name
self.id = actor_id or calvinuuid.uuid("ACTOR")
self._managed = set(('id', 'name'))
self.calvinsys = None # CalvinSys(node)
self.control = calvincontrol.get_calvincontrol()
self.inports = {p: actorport.InPort(p, self) for p in self.inport_names}
self.outports = {p: actorport.OutPort(p, self) for p in self.outport_names}
hooks = {
(Actor.STATUS.PENDING, Actor.STATUS.ENABLED): self.will_start,
(Actor.STATUS.ENABLED, Actor.STATUS.PENDING): self.will_stop,
}
self.fsm = Actor.FSM(Actor.STATUS, Actor.STATUS.LOADED, Actor.VALID_TRANSITIONS, hooks,
allow_invalid_transitions=allow_invalid_transitions,
disable_transition_checks=disable_transition_checks,
disable_state_checks=disable_state_checks)
def __init__(self, uri, control_uri, attributes=None):
super(Node, self).__init__()
self.uri = uri
self.control_uri = control_uri
self.attributes = attributes
self.id = calvinuuid.uuid("NODE")
self.monitor = Event_Monitor()
self.am = actormanager.ActorManager(self)
self.control = calvincontrol.get_calvincontrol()
_scheduler = scheduler.DebugScheduler if _log.getEffectiveLevel() <= logging.DEBUG else scheduler.Scheduler
self.sched = _scheduler(self, self.am, self.monitor)
self.control.start(node=self, uri=control_uri)
self.async_msg_ids = {}
self.storage = storage.Storage()
self.storage.start()
self.network = CalvinNetwork(self)
self.proto = CalvinProto(self, self.network)
self.pm = PortManager(self, self.proto)
self.app_manager = appmanager.AppManager(self)
# The initialization that requires the main loop operating is deferred to start function
# FIXME: Don't use delayed call in calvin-tiny
async.DelayedCall(0, self.start)
def __init__(self,
actor_type,
name='',
allow_invalid_transitions=True,
disable_transition_checks=False,
disable_state_checks=False,
actor_id=None):
"""Should normally _not_ be overridden in subclasses."""
super(Actor, self).__init__()
self._type = actor_type
self.name = name # optional: human_readable_name
self.id = actor_id or calvinuuid.uuid("ACTOR")
self._managed = set(('id', 'name'))
self.calvinsys = None # CalvinSys(node)
self.control = calvincontrol.get_calvincontrol()
self.inports = {
p: actorport.InPort(p, self)
for p in self.inport_names
}
self.outports = {
p: actorport.OutPort(p, self)
for p in self.outport_names
}
hooks = {
(Actor.STATUS.PENDING, Actor.STATUS.ENABLED): self.will_start,
(Actor.STATUS.ENABLED, Actor.STATUS.PENDING): self.will_stop,
}
self.fsm = Actor.FSM(
Actor.STATUS,
Actor.STATUS.LOADED,
Actor.VALID_TRANSITIONS,
hooks,
allow_invalid_transitions=allow_invalid_transitions,
disable_transition_checks=disable_transition_checks,
disable_state_checks=disable_state_checks)
def __init__(self, uris, control_uri, attributes=None):
super(Node, self).__init__()
self.quitting = False
# Warn if its not a uri
if not isinstance(uris, list):
_log.error("Calvin uris must be a list %s" % uris)
raise TypeError("Calvin uris must be a list!")
# Uris
self.uris = uris
if attributes:
ext_uris = attributes.pop('external_uri', None)
if ext_uris is not None:
self.uris += ext_uris
# Control uri
self.control_uri = control_uri
self.external_control_uri = attributes.pop('external_control_uri', self.control_uri) \
if attributes else self.control_uri
try:
self.attributes = AttributeResolver(attributes)
except:
_log.exception("Attributes not correct, uses empty attribute!")
self.attributes = AttributeResolver(None)
self.node_name = self.attributes.get_node_name_as_str()
# Obtain node id, when using security also handle runtime certificate
try:
security_dir = _conf.get("security", "security_dir")
self.runtime_credentials = RuntimeCredentials(self.node_name, node=self, security_dir=security_dir)
self.id = self.runtime_credentials.get_node_id()
except Exception as err:
_log.debug("No runtime credentials, err={}".format(err))
self.runtime_credentials = None
self.id = calvinuuid.uuid("Node")
self.certificate_authority = certificate_authority.CertificateAuthority(self)
self.authentication = authentication.Authentication(self)
self.authorization = authorization.Authorization(self)
self.metering = metering.set_metering(metering.Metering(self))
self.monitor = Event_Monitor()
self.am = actormanager.ActorManager(self)
self.rm = replicationmanager.ReplicationManager(self)
self.control = calvincontrol.get_calvincontrol()
_scheduler = scheduler.DebugScheduler if _log.getEffectiveLevel() <= logging.DEBUG else scheduler.Scheduler
self.sched = _scheduler(self, self.am, self.monitor)
self.async_msg_ids = {}
self._calvinsys = CalvinSys(self)
calvinsys = get_calvinsys()
calvinsys.init(self)
calvinlib = get_calvinlib()
calvinlib.init(self)
# Default will multicast and listen on all interfaces
# TODO: be able to specify the interfaces
# @TODO: Store capabilities
self.storage = storage.Storage(self)
self.network = CalvinNetwork(self)
self.proto = CalvinProto(self, self.network)
self.pm = PortManager(self, self.proto)
self.app_manager = appmanager.AppManager(self)
# The initialization that requires the main loop operating is deferred to start function
async.DelayedCall(0, self.start)
def test_get_calvincontrol_returns_xxx():
control = get_calvincontrol()
assert control == get_calvincontrol()
def __init__(self, uris, control_uri, attributes=None):
super(Node, self).__init__()
self.quitting = False
self.super_node_class = None
# Warn if its not a uri
if not isinstance(uris, list):
_log.error("Calvin uris must be a list %s" % uris)
raise TypeError("Calvin uris must be a list!")
# Uris
self.uris = uris
if attributes:
ext_uris = attributes.pop('external_uri', None)
if ext_uris is not None:
self.uris += ext_uris
# Control uri
self.control_uri = control_uri
self.external_control_uri = attributes.pop('external_control_uri', self.control_uri) \
if attributes else self.control_uri
try:
self.attributes = AttributeResolver(attributes)
except:
_log.exception("Attributes not correct, uses empty attribute!")
self.attributes = AttributeResolver(None)
self.node_name = self.attributes.get_node_name_as_str()
# Obtain node id, when using security also handle runtime certificate
try:
security_dir = _conf.get("security", "security_dir")
self.runtime_credentials = RuntimeCredentials(self.node_name, node=self, security_dir=security_dir)
self.id = self.runtime_credentials.get_node_id()
except Exception as err:
_log.debug("No runtime credentials, err={}".format(err))
self.runtime_credentials = None
self.id = calvinuuid.uuid("Node")
self.certificate_authority = certificate_authority.CertificateAuthority(self)
self.authentication = authentication.Authentication(self)
self.authorization = authorization.Authorization(self)
self.am = actormanager.ActorManager(self)
self.rm = replicationmanager.ReplicationManager(self)
self.control = calvincontrol.get_calvincontrol()
# _scheduler = scheduler.DebugScheduler if _log.getEffectiveLevel() <= logging.DEBUG else scheduler.Scheduler
# _scheduler = scheduler.NonPreemptiveScheduler
# _scheduler = scheduler.RoundRobinScheduler
_scheduler = scheduler.SimpleScheduler
# _scheduler = scheduler.BaselineScheduler
self.sched = _scheduler(self, self.am)
self.async_msg_ids = {}
calvinsys = get_calvinsys()
calvinsys.init(self)
calvinlib = get_calvinlib()
calvinlib.init()
# Default will multicast and listen on all interfaces
# TODO: be able to specify the interfaces
# @TODO: Store capabilities
self.storage = storage.Storage(self)
self.network = CalvinNetwork(self)
self.proto = CalvinProto(self, self.network)
self.pm = PortManager(self, self.proto)
self.app_manager = appmanager.AppManager(self)
self.cpu_monitor = CpuMonitor(self.id, self.storage)
self.mem_monitor = MemMonitor(self.id, self.storage)
self.proxy_handler = ProxyHandler(self)
# The initialization that requires the main loop operating is deferred to start function
async.DelayedCall(0, self.start)
def test_get_calvincontrol_returns_xxx():
control = get_calvincontrol()
assert control == get_calvincontrol()