def setUp(self):
self.provisioner = FakeProvisionerClient()
self.state = ControllerCoreState(ControllerStore())
self.prov_vars = {"foo" : "bar"}
self.controller_name = "fakey"
self.control = ControllerCoreControl(self.provisioner, self.state,
self.prov_vars,
self.controller_name)
def __init__(self,
provisioner_client,
engineclass,
controller_name,
conf=None,
state=None,
store=None):
if state:
self.state = state
else:
self.state = ControllerCoreState(store or ControllerStore())
prov_vars = None
health_kwargs = None
if conf:
if conf.has_key(PROVISIONER_VARS_KEY):
prov_vars = conf[PROVISIONER_VARS_KEY]
if conf.get(MONITOR_HEALTH_KEY):
health_kwargs = {}
if HEALTH_BOOT_KEY in conf:
health_kwargs['boot_seconds'] = conf[HEALTH_BOOT_KEY]
if HEALTH_MISSING_KEY in conf:
health_kwargs['missing_seconds'] = conf[HEALTH_MISSING_KEY]
if HEALTH_ZOMBIE_KEY in conf:
health_kwargs['zombie_seconds'] = conf[HEALTH_ZOMBIE_KEY]
self.conf = conf
if health_kwargs is not None:
self.health_monitor = HealthMonitor(self.state, **health_kwargs)
else:
self.health_monitor = None
# There can only ever be one 'reconfigure' or 'decide' engine call run
# at ANY time. The 'decide' call is triggered via timed looping call
# and 'reconfigure' is triggered asynchronously at any moment.
self.busy = defer.DeferredSemaphore(1)
self.provisioner_client = provisioner_client
health_not_checked = self.health_monitor is None
self.control = ControllerCoreControl(
provisioner_client,
self.state,
prov_vars,
controller_name,
health_not_checked=health_not_checked)
self.engine = EngineLoader().load(engineclass)
self.control_loop = None
def test_reconfigure_recovery(self):
# test that engine config is correctly using reconfigured engine values
# in subsequent starts of the controller. Strategy is:
# 1. Start up a controller with some config
# 2. Call reconfigure with some more config
# 3. Kill controller and restart it, verify engine got the merged
# config.
store = ControllerStore()
spawnargs = {
'engine_class':
'epu.epucontroller.test.test_controller_core.FakeEngine',
'engine_conf': {
'a': 'a1',
'b': 'b1'
},
'servicename': 'TestEPUController',
'store': store
}
controller = EPUControllerService(spawnargs=spawnargs)
self.controller = controller
yield self._spawn_process(controller)
client = EPUControllerClient(targetname='TestEPUController')
yield client.attach()
yield procutils.asleep(1.01)
yield client.reconfigure_rpc({'a': 'a2', 'c': 'c1'})
yield procutils.asleep(1.01)
controller.terminate()
controller = EPUControllerService(spawnargs=spawnargs)
self.controller = controller
yield self._spawn_process(controller)
yield procutils.asleep(1.01)
self.assertEqual(controller.core.engine.initialize_conf, {
'a': 'a2',
'b': 'b1',
'c': 'c1'
})
def setUp(self):
self.store = ControllerStore()
self.state = ControllerCoreState(self.store)
def get_store(self):
return defer.succeed(ControllerStore())
def setUp(self):
self.state = FakeState(ControllerStore())
self.monitor = None
def setUp(self):
self.store = ControllerStore()
def slc_init(self):
scoped_name = self.get_scoped_name("system", self.svc_name)
self.scoped_name = scoped_name
queue_name_work = self.spawn_args.get("queue_name_work")
if queue_name_work:
self.queue_name_work = self.get_scoped_name(
"system", queue_name_work)
extradict = {"queue_name_work": self.queue_name_work}
cei_events.event(self.svc_name, "init_begin", extra=extradict)
yield self._make_queue(queue_name_work)
queuestat_client = QueueStatClient(self)
yield queuestat_client.watch_queue(self.queue_name_work,
self.scoped_name, 'sensor_info')
cei_events.event(self.svc_name, "queue_watched")
else:
self.worker_queue_receiver = None
self.queue_name_work = None
extradict = None
cei_events.event(self.svc_name, "init_begin", extra=extradict)
engineclass = "epu.decisionengine.impls.NpreservingEngine"
if self.spawn_args.has_key("engine_class"):
engineclass = self.spawn_args["engine_class"]
log.info("Using configured decision engine: %s" % engineclass)
else:
log.info("Using default decision engine: %s" % engineclass)
if self.spawn_args.has_key("engine_conf"):
engine_conf = self.spawn_args["engine_conf"]
if isinstance(engine_conf, str):
engine_conf = json.loads(engine_conf)
else:
engine_conf = None
if self.spawn_args.has_key("cassandra"):
cass = self.spawn_args["cassandra"]
host = cass['hostname']
username = cass['username']
password = cass['password']
port = cass['port']
keyspace = cass['keyspace']
store = CassandraControllerStore(self.svc_name, host, port,
username, password, keyspace,
CoreInstance, SensorItem)
store.initialize()
store.activate()
elif self.spawn_args.has_key('store'):
store = self.spawn_args['store']
else:
store = ControllerStore()
self.core = ControllerCore(ProvisionerClient(self),
engineclass,
scoped_name,
conf=engine_conf,
store=store)
# run state recovery and engine initialization
# this one needs to run before any messages start arriving. It pulls
# information from persistence and refreshes local caches.
yield self.core.run_recovery()
# temporarily doing this later due to a potential bug in ioncore where
# queues may not be bound before slc_init runs. This means if the
# provisioner is quck to reply to dump_state some messages may be
# missed.
reactor.callLater(1, self._delayed_init)
