def start(self, provider_type=None):
"""Starts the unit deployer."""
# Find out what provided the machine, and how to deploy units.
if provider_type is None:
settings = GlobalSettingsStateManager(self.client)
provider_type = yield settings.get_provider_type()
self.deploy_factory = get_deploy_factory(provider_type)
if not os.path.exists(self.charms_directory):
os.makedirs(self.charms_directory)
def get_unit_address(client):
settings = GlobalSettingsStateManager(client)
provider_type = yield settings.get_provider_type()
if provider_type == "ec2":
returnValue(EC2UnitAddress())
elif provider_type == "local":
returnValue(LocalUnitAddress())
elif provider_type == "orchestra":
returnValue(OrchestraUnitAddress())
elif provider_type == "dummy":
returnValue(DummyUnitAddress())
raise JujuError("Unknown provider type: %r, unit addresses unknown." %
provider_type)
def get_unit_address(client):
settings = GlobalSettingsStateManager(client)
provider_type = yield settings.get_provider_type()
if provider_type == "ec2":
returnValue(EC2UnitAddress())
elif provider_type == "local":
returnValue(LocalUnitAddress())
elif provider_type == "orchestra":
returnValue(OrchestraUnitAddress())
elif provider_type == "dummy":
returnValue(DummyUnitAddress())
raise JujuError(
"Unknown provider type: %r, unit addresses unknown." % provider_type)
def test_initialize(self):
yield self.layout.initialize()
yield self.assert_existence_and_acl("/charms")
yield self.assert_existence_and_acl("/services")
yield self.assert_existence_and_acl("/units")
yield self.assert_existence_and_acl("/machines")
yield self.assert_existence_and_acl("/relations")
yield self.assert_existence_and_acl("/initialized")
# To check that the constraints landed correctly, we need the
# environment config to have been sent, or we won't be able to
# get a provider to help us construct the appropriate objects.
yield self.push_default_config(with_constraints=False)
esm = EnvironmentStateManager(self.client)
env_constraints = yield esm.get_constraints()
self.assertEquals(env_constraints, {
"provider-type": "dummy",
"ubuntu-series": None,
"arch": "arm",
"cpu": None,
"mem": 512})
machine_state_manager = MachineStateManager(self.client)
machine_state = yield machine_state_manager.get_machine_state(0)
machine_constraints = yield machine_state.get_constraints()
self.assertTrue(machine_constraints.complete)
self.assertEquals(machine_constraints, {
"provider-type": "dummy",
"ubuntu-series": "cranky",
"arch": "arm",
"cpu": None,
"mem": 512})
instance_id = yield machine_state.get_instance_id()
self.assertEqual(instance_id, "i-abcdef")
settings_manager = GlobalSettingsStateManager(self.client)
self.assertEqual((yield settings_manager.get_provider_type()), "dummy")
self.assertEqual(
self.log.getvalue().strip(),
"Initializing zookeeper hierarchy")
def test_initialize(self):
yield self.layout.initialize()
yield self.assert_existence_and_acl("/charms")
yield self.assert_existence_and_acl("/services")
yield self.assert_existence_and_acl("/units")
yield self.assert_existence_and_acl("/machines")
yield self.assert_existence_and_acl("/relations")
yield self.assert_existence_and_acl("/initialized")
machine_state_manager = MachineStateManager(self.client)
machine_state = yield machine_state_manager.get_machine_state(0)
self.assertTrue(machine_state)
instance_id = yield machine_state.get_instance_id()
self.assertEqual(instance_id, "i-abcdef")
settings_manager = GlobalSettingsStateManager(self.client)
self.assertEqual((yield settings_manager.get_provider_type()), "dummy")
self.assertEqual(self.log.getvalue().strip(),
"Initializing zookeeper hierarchy")
def test_initialize(self):
yield self.layout.initialize()
yield self.assert_existence_and_acl("/charms")
yield self.assert_existence_and_acl("/services")
yield self.assert_existence_and_acl("/units")
yield self.assert_existence_and_acl("/machines")
yield self.assert_existence_and_acl("/relations")
yield self.assert_existence_and_acl("/initialized")
machine_state_manager = MachineStateManager(self.client)
machine_state = yield machine_state_manager.get_machine_state(0)
self.assertTrue(machine_state)
instance_id = yield machine_state.get_instance_id()
self.assertEqual(instance_id, "i-abcdef")
settings_manager = GlobalSettingsStateManager(self.client)
self.assertEqual((yield settings_manager.get_provider_type()), "dummy")
self.assertEqual(
self.log.getvalue().strip(),
"Initializing zookeeper hierarchy")
def start(self):
"""Start the machine agent.
Creates state directories on the machine, retrieves the machine state,
and enables watch on assigned units.
"""
# Initialize directory paths.
if not os.path.exists(self.charms_directory):
os.makedirs(self.charms_directory)
if not os.path.exists(self.units_directory):
os.makedirs(self.units_directory)
if not os.path.exists(self.unit_state_directory):
os.makedirs(self.unit_state_directory)
# Get state managers we'll be utilizing.
self.service_state_manager = ServiceStateManager(self.client)
self.charm_state_manager = CharmStateManager(self.client)
# Retrieve the machine state for the machine we represent.
machine_manager = MachineStateManager(self.client)
self.machine_state = yield machine_manager.get_machine_state(
self.get_machine_id())
# Watch assigned units for the machine.
if self.get_watch_enabled():
self.machine_state.watch_assigned_units(
self.watch_service_units)
# Find out what provided the machine, and how to deploy units.
settings = GlobalSettingsStateManager(self.client)
self.provider_type = yield settings.get_provider_type()
self.deploy_factory = get_deploy_factory(self.provider_type)
# Connect the machine agent, broadcasting presence to the world.
yield self.machine_state.connect_agent()
log.info("Machine agent started id:%s deploy:%r provider:%r" % (
self.get_machine_id(), self.deploy_factory, self.provider_type))
def start(self):
"""Start the machine agent.
Creates state directories on the machine, retrieves the machine state,
and enables watch on assigned units.
"""
# Initialize directory paths.
if not os.path.exists(self.charms_directory):
os.makedirs(self.charms_directory)
if not os.path.exists(self.units_directory):
os.makedirs(self.units_directory)
if not os.path.exists(self.unit_state_directory):
os.makedirs(self.unit_state_directory)
# Get state managers we'll be utilizing.
self.service_state_manager = ServiceStateManager(self.client)
self.charm_state_manager = CharmStateManager(self.client)
# Retrieve the machine state for the machine we represent.
machine_manager = MachineStateManager(self.client)
self.machine_state = yield machine_manager.get_machine_state(
self.get_machine_id())
# Watch assigned units for the machine.
if self.get_watch_enabled():
self.machine_state.watch_assigned_units(self.watch_service_units)
# Find out what provided the machine, and how to deploy units.
settings = GlobalSettingsStateManager(self.client)
self.provider_type = yield settings.get_provider_type()
self.deploy_factory = get_deploy_factory(self.provider_type)
# Connect the machine agent, broadcasting presence to the world.
yield self.machine_state.connect_agent()
log.info(
"Machine agent started id:%s deploy:%r provider:%r" %
(self.get_machine_id(), self.deploy_factory, self.provider_type))
class GlobalSettingsTest(StateTestBase):
@inlineCallbacks
def setUp(self):
yield super(GlobalSettingsTest, self).setUp()
self.manager = GlobalSettingsStateManager(self.client)
@inlineCallbacks
def test_get_set_provider_type(self):
"""Debug logging is off by default."""
self.assertEqual((yield self.manager.get_provider_type()), None)
yield self.manager.set_provider_type("ec2")
self.assertEqual((yield self.manager.get_provider_type()), "ec2")
content, stat = yield self.client.get("/settings")
self.assertEqual(yaml.load(content),
{"provider-type": "ec2"})
@inlineCallbacks
def test_get_debug_log_enabled_no_settings_default(self):
"""Debug logging is off by default."""
value = yield self.manager.is_debug_log_enabled()
self.assertFalse(value)
@inlineCallbacks
def test_set_debug_log(self):
"""Debug logging can be (dis)enabled via the runtime manager."""
yield self.manager.set_debug_log(True)
value = yield self.manager.is_debug_log_enabled()
self.assertTrue(value)
yield self.manager.set_debug_log(False)
value = yield self.manager.is_debug_log_enabled()
self.assertFalse(value)
@inlineCallbacks
def test_watcher(self):
"""Use the watch facility of the settings manager to observer changes.
"""
results = []
callbacks = [Deferred() for i in range(5)]
def watch(content):
results.append(content)
callbacks[len(results) - 1].callback(content)
yield self.manager.set_debug_log(True)
yield self.manager.watch_settings_changes(watch)
self.assertTrue(results)
yield self.manager.set_debug_log(False)
yield self.manager.set_debug_log(True)
yield callbacks[2]
self.assertEqual(len(results), 3)
self.assertEqual(
map(lambda x: isinstance(x, bool) and x or x.type_name, results),
[True, "changed", "changed"])
data, stat = yield self.client.get(SETTINGS_PATH)
self.assertEqual(
(yield self.manager.is_debug_log_enabled()),
True)
@inlineCallbacks
def test_watcher_start_stop(self):
"""Setings watcher observes changes till stopped.
Additionally watching can be enabled on a setting node that doesn't
exist yet.
XXX For reasons unknown this fails under coverage outside of the test,
at least for me (k.), but not for others.
"""
results = []
callbacks = [Deferred() for i in range(5)]
def watch(content):
results.append(content)
callbacks[len(results) - 1].callback(content)
watcher = yield self.manager.watch_settings_changes(watch)
yield self.client.create(SETTINGS_PATH, "x")
value = yield callbacks[0]
self.assertEqual(value.type_name, "created")
data = dict(x=1, y=2, z=3, moose=u"moon")
yield self.client.set(
SETTINGS_PATH, yaml.safe_dump(data))
value = yield callbacks[1]
self.assertEqual(value.type_name, "changed")
watcher.stop()
yield self.client.set(SETTINGS_PATH, "z")
# Give a chance for things to go bad.
yield self.sleep(0.1)
self.assertFalse(callbacks[2].called)
@inlineCallbacks
def test_watcher_stops_on_callback_exception(self):
"""If a callback has an exception the watcher is stopped."""
results = []
callbacks = [Deferred(), Deferred()]
def watch(content):
results.append(content)
callbacks[len(results) - 1].callback(content)
raise AttributeError("foobar")
def on_error(error):
results.append(True)
yield self.client.create(SETTINGS_PATH, "z")
watcher = yield self.manager.watch_settings_changes(
watch, on_error)
yield callbacks[0]
# The callback error should have disconnected the system.
yield self.client.set(SETTINGS_PATH, "x")
# Give a chance for things to go bad.
yield self.sleep(0.1)
# Verify nothing did go bad.
self.assertFalse(watcher.is_running)
self.assertFalse(callbacks[1].called)
self.assertIdentical(results[1], True)
class GlobalSettingsTest(StateTestBase):
@inlineCallbacks
def setUp(self):
yield super(GlobalSettingsTest, self).setUp()
self.manager = GlobalSettingsStateManager(self.client)
@inlineCallbacks
def test_get_set_provider_type(self):
"""Debug logging is off by default."""
self.assertEqual((yield self.manager.get_provider_type()), None)
yield self.manager.set_provider_type("ec2")
self.assertEqual((yield self.manager.get_provider_type()), "ec2")
content, stat = yield self.client.get("/settings")
self.assertEqual(yaml.load(content), {"provider-type": "ec2"})
@inlineCallbacks
def test_get_debug_log_enabled_no_settings_default(self):
"""Debug logging is off by default."""
value = yield self.manager.is_debug_log_enabled()
self.assertFalse(value)
@inlineCallbacks
def test_set_debug_log(self):
"""Debug logging can be (dis)enabled via the runtime manager."""
yield self.manager.set_debug_log(True)
value = yield self.manager.is_debug_log_enabled()
self.assertTrue(value)
yield self.manager.set_debug_log(False)
value = yield self.manager.is_debug_log_enabled()
self.assertFalse(value)
@inlineCallbacks
def test_watcher(self):
"""Use the watch facility of the settings manager to observer changes.
"""
results = []
callbacks = [Deferred() for i in range(5)]
def watch(content):
results.append(content)
callbacks[len(results) - 1].callback(content)
yield self.manager.set_debug_log(True)
yield self.manager.watch_settings_changes(watch)
self.assertTrue(results)
yield self.manager.set_debug_log(False)
yield self.manager.set_debug_log(True)
yield callbacks[2]
self.assertEqual(len(results), 3)
self.assertEqual(
map(lambda x: isinstance(x, bool) and x or x.type_name, results),
[True, "changed", "changed"])
data, stat = yield self.client.get(SETTINGS_PATH)
self.assertEqual((yield self.manager.is_debug_log_enabled()), True)
@inlineCallbacks
def test_watcher_start_stop(self):
"""Setings watcher observes changes till stopped.
Additionally watching can be enabled on a setting node that doesn't
exist yet.
XXX For reasons unknown this fails under coverage outside of the test,
at least for me (k.), but not for others.
"""
results = []
callbacks = [Deferred() for i in range(5)]
def watch(content):
results.append(content)
callbacks[len(results) - 1].callback(content)
watcher = yield self.manager.watch_settings_changes(watch)
yield self.client.create(SETTINGS_PATH, "x")
value = yield callbacks[0]
self.assertEqual(value.type_name, "created")
data = dict(x=1, y=2, z=3, moose=u"moon")
yield self.client.set(SETTINGS_PATH, yaml.safe_dump(data))
value = yield callbacks[1]
self.assertEqual(value.type_name, "changed")
watcher.stop()
yield self.client.set(SETTINGS_PATH, "z")
# Give a chance for things to go bad.
yield self.sleep(0.1)
self.assertFalse(callbacks[2].called)
@inlineCallbacks
def test_watcher_stops_on_callback_exception(self):
"""If a callback has an exception the watcher is stopped."""
results = []
callbacks = [Deferred(), Deferred()]
def watch(content):
results.append(content)
callbacks[len(results) - 1].callback(content)
raise AttributeError("foobar")
def on_error(error):
results.append(True)
yield self.client.create(SETTINGS_PATH, "z")
watcher = yield self.manager.watch_settings_changes(watch, on_error)
yield callbacks[0]
# The callback error should have disconnected the system.
yield self.client.set(SETTINGS_PATH, "x")
# Give a chance for things to go bad.
yield self.sleep(0.1)
# Verify nothing did go bad.
self.assertFalse(watcher.is_running)
self.assertFalse(callbacks[1].called)
self.assertIdentical(results[1], True)
