def test_environment_constraint(self):
yield self.client.delete("/environment")
finished = self.setup_cli_reactor()
self.setup_exit(0)
self.mocker.replay()
main(["set-constraints", "arch=arm", "cpu=any"])
yield finished
esm = EnvironmentStateManager(self.client)
yield esm.get_config()
constraints = yield esm.get_constraints()
self.assertEquals(constraints, {
"ubuntu-series": None,
"provider-type": "dummy",
"arch": "arm",
"cpu": None,
"mem": 512.0})
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 constraints_get(env_config, environment, entity_names, log):
"""
Show the complete set of applicable constraints for each specified entity.
This will show the final computed values of all constraints (including
internal constraints which cannot be set directly via set-constraints).
"""
provider = environment.get_machine_provider()
client = yield provider.connect()
result = {}
try:
yield sync_environment_state(client, env_config, environment.name)
if entity_names:
msm = MachineStateManager(client)
ssm = ServiceStateManager(client)
for name in entity_names:
if name.isdigit():
kind = "machine"
entity = yield msm.get_machine_state(name)
elif "/" in name:
kind = "service unit"
entity = yield ssm.get_unit_state(name)
else:
kind = "service"
entity = yield ssm.get_service_state(name)
log.info("Fetching constraints for %s %s", kind, name)
constraints = yield entity.get_constraints()
result[name] = dict(constraints)
else:
esm = EnvironmentStateManager(client)
log.info("Fetching constraints for environment")
constraints = yield esm.get_constraints()
result = dict(constraints)
yaml.safe_dump(result, sys.stdout)
finally:
yield client.close()
class EnvironmentStateManagerTest(StateTestBase, EnvironmentsConfigTestBase):
@inlineCallbacks
def setUp(self):
yield super(EnvironmentStateManagerTest, self).setUp()
self.environment_state_manager = EnvironmentStateManager(self.client)
self.write_config(SAMPLE_ENV)
self.config.load()
@inlineCallbacks
def tearDown(self):
yield super(EnvironmentStateManagerTest, self).tearDown()
@inlineCallbacks
def test_set_config_state(self):
"""
The simplest thing the manager can do is serialize a given
environment and save it in zookeeper.
"""
manager = self.environment_state_manager
yield manager.set_config_state(self.config, "myfirstenv")
serialized = self.config.serialize("myfirstenv")
content, stat = yield self.client.get("/environment")
self.assertEquals(yaml.load(content), yaml.load(serialized))
@inlineCallbacks
def test_set_config_state_replaces_environment(self):
"""
Setting the environment should also work with an existing
environment.
"""
yield self.client.create("/environment", "Replace me!")
manager = self.environment_state_manager
yield manager.set_config_state(self.config, "myfirstenv")
serialized = self.config.serialize("myfirstenv")
content, stat = yield self.client.get("/environment")
self.assertEquals(yaml.load(content), yaml.load(serialized))
@inlineCallbacks
def test_get_config(self):
"""
We can also retrieve a loaded config from the environment.
"""
manager = self.environment_state_manager
yield manager.set_config_state(self.config, "myfirstenv")
config = yield manager.get_config()
serialized1 = self.config.serialize("myfirstenv")
serialized2 = config.serialize("myfirstenv")
self.assertEquals(yaml.load(serialized1), yaml.load(serialized2))
def test_get_config_when_missing(self):
"""
get_config should blow up politely if the environment config
is missing.
"""
d = self.environment_state_manager.get_config()
return self.assertFailure(d, EnvironmentStateNotFound)
@inlineCallbacks
def test_get_in_legacy_environment_no(self):
yield self.push_default_config()
esm = self.environment_state_manager
legacy = yield esm.get_in_legacy_environment()
self.assertEquals(legacy, False)
@inlineCallbacks
def test_get_in_legacy_environment_yes(self):
yield self.push_default_config()
self.client.delete("/constraints")
esm = self.environment_state_manager
legacy = yield esm.get_in_legacy_environment()
self.assertEquals(legacy, True)
def test_get_constraint_set_no_env(self):
d = self.environment_state_manager.get_constraint_set()
return self.assertFailure(d, EnvironmentStateNotFound)
@inlineCallbacks
def test_get_constraint_set(self):
yield self.push_default_config()
cs = yield self.environment_state_manager.get_constraint_set()
constraints = cs.parse(["arch=any", "cpu=10"])
self.assertEquals(constraints, {
"ubuntu-series": None,
"provider-type": "dummy",
"arch": None,
"cpu": 10.0,
"mem": 512.0})
def test_get_constraints_no_env(self):
d = self.environment_state_manager.get_constraints()
return self.assertFailure(d, EnvironmentStateNotFound)
@inlineCallbacks
def test_get_constraints_env_with_no_node(self):
yield self.push_default_config()
self.client.delete("/constraints")
constraints = yield self.environment_state_manager.get_constraints()
self.assertEquals(constraints.data, {})
@inlineCallbacks
def test_set_constraints(self):
yield self.push_default_config()
constraints = dummy_cs.parse(["cpu=any", "mem=32T"])
yield self.environment_state_manager.set_constraints(constraints)
roundtrip = yield self.environment_state_manager.get_constraints()
self.assertEquals(roundtrip, constraints)
