def __init__(self, router=None):
BaseNode.__init__(self)
self._own_router = True
if router is not None:
self._local_router = router
self._own_router = False
else:
self._local_router = LocalRouter(get_sys_name())
self._channel_id_pool = IDPool()
def setUp(self):
self.lr = LocalRouter(get_sys_name())
self.lr.start()
self.addCleanup(self.lr.stop)
# make a hook so we can tell when a message gets routed
self.ev = Event()
def new_route(*args, **kwargs):
self.ev.set()
self.lr._oldroute(*args, **kwargs)
self.lr._oldroute = self.lr._route
self.lr._route = new_route
def start(self):
# internal router for local transports
self.container.local_router = LocalRouter(bootstrap.get_sys_name())
self.container.local_router.start()
self.container.local_router.ready.wait(timeout=2)
def start(self):
log.debug("Container starting...")
if self._is_started:
raise ContainerError("Container already started")
# Check if this UNIX process already runs a Container.
self.pidfile = "cc-pid-%d" % os.getpid()
if os.path.exists(self.pidfile):
raise ContainerError(
"Container.on_start(): Container is a singleton per UNIX process. Existing pid file found: %s"
% self.pidfile)
# write out a PID file containing our agent messaging name
with open(self.pidfile, 'w') as f:
pid_contents = {
'messaging': dict(CFG.server.amqp),
'container-agent': self.name,
'container-xp': bootstrap.get_sys_name()
}
f.write(msgpack.dumps(pid_contents))
atexit.register(self._cleanup_pid)
self._capabilities.append("PID_FILE")
# set up abnormal termination handler for this container
def handl(signum, frame):
try:
self._cleanup_pid() # cleanup the pidfile first
self.quit(
) # now try to quit - will not error on second cleanup pidfile call
finally:
signal.signal(signal.SIGTERM, self._normal_signal)
os.kill(os.getpid(), signal.SIGTERM)
self._normal_signal = signal.signal(signal.SIGTERM, handl)
# set up greenlet debugging signal handler
gevent.signal(signal.SIGUSR2, self._handle_sigusr2)
self.datastore_manager.start()
self._capabilities.append("DATASTORE_MANAGER")
self._capabilities.append("DIRECTORY")
# Event repository
self.event_repository = EventRepository()
self.event_pub = EventPublisher()
self._capabilities.append("EVENT_REPOSITORY")
# Local resource registry
self.resource_registry = ResourceRegistry()
self._capabilities.append("RESOURCE_REGISTRY")
# Persistent objects
self.datastore_manager.get_datastore("objects",
DataStore.DS_PROFILE.OBJECTS)
# State repository
self.state_repository = StateRepository()
self._capabilities.append("STATE_REPOSITORY")
# internal router for local transports
self.local_router = LocalRouter(bootstrap.get_sys_name())
self.local_router.start()
self.local_router.ready.wait(timeout=2)
self._capabilities.append("LOCAL_ROUTER")
# Start ExchangeManager, which starts the node (broker connection)
self.ex_manager.start()
self._capabilities.append("EXCHANGE_MANAGER")
self.proc_manager.start()
self._capabilities.append("PROC_MANAGER")
self.app_manager.start()
self._capabilities.append("APP_MANAGER")
self.governance_controller.start()
self._capabilities.append("GOVERNANCE_CONTROLLER")
if CFG.get_safe('container.sflow.enabled', False):
self.sflow_manager.start()
self._capabilities.append("SFLOW_MANAGER")
# Start the CC-Agent API
rsvc = ProcessRPCServer(node=self.node,
from_name=self.name,
service=self,
process=self)
cleanup = lambda _: self.proc_manager._cleanup_method(self.name, rsvc)
# Start an ION process with the right kind of endpoint factory
proc = self.proc_manager.proc_sup.spawn(name=self.name,
listeners=[rsvc],
service=self,
cleanup_method=cleanup)
self.proc_manager.proc_sup.ensure_ready(proc)
proc.start_listeners()
self._capabilities.append("CONTAINER_AGENT")
self.event_pub.publish_event(event_type="ContainerLifecycleEvent",
origin=self.id,
origin_type="CapabilityContainer",
sub_type="START",
state=ContainerStateEnum.START)
self._is_started = True
self._status = "RUNNING"
log.info("Container (%s) started, OK.", self.id)
