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)