def test_remove_unit(self): unit1 = storage.Unit(dns_name="instance1.cloud.tsuru.io", id="i-0800") unit2 = storage.Unit(dns_name="instance2.cloud.tsuru.io", id="i-0801") instance = storage.Instance() instance.add_unit(unit1) instance.add_unit(unit2) self.assertEqual([unit1, unit2], instance.units) instance.remove_unit(unit1) self.assertEqual([unit2], instance.units)
def test_info_multiple_units(self): units = [api_storage.Unit(dns_name="secret.cloud.tsuru.io", id="i-0800"), api_storage.Unit(dns_name="not-secret.cloud.tsuru.io", id="i-0800")] instance = api_storage.Instance(name="secret", units=units) storage = mock.Mock() storage.retrieve_instance.return_value = instance manager = managers.BaseManager(storage) expected = [{"label": "Address", "value": "secret.cloud.tsuru.io"}] self.assertEqual(expected, manager.info("secret")) storage.retrieve_instance.assert_called_with(name="secret")
def test_remove_instance_with_units(self): units = [ storage.Unit(dns_name="instance1.cloud.tsuru.io", id="i-0800"), storage.Unit(dns_name="instance2.cloud.tsuru.io", id="i-0801"), storage.Unit(dns_name="instance3.cloud.tsuru.io", id="i-0802") ] instance = storage.Instance(name="secret", units=units) self.storage.store_instance(instance) self.storage.remove_instance(instance.name) self.assertIsNone( self.client.feaas_test.units.find_one( {"instance_name": instance.name}))
def test_terminate_instance(self): self.set_api_envs() self.addCleanup(self.del_api_envs) instance = storage.Instance(name="some_instance", units=[storage.Unit(id="vm-123"), storage.Unit(id="vm-456")]) strg_mock = mock.Mock() strg_mock.retrieve_instance.return_value = instance manager = cloudstack.CloudStackManager(storage=strg_mock) manager.client = client_mock = mock.Mock() got_instance = manager.terminate_instance("some_instance") self.assertEqual(instance, got_instance) expected_calls = [mock.call({"id": "vm-123"}), mock.call({"id": "vm-456"})] self.assertEqual(expected_calls, client_mock.destroyVirtualMachine.call_args_list)
def test_retrieve_units_limited(self): units = [ storage.Unit(dns_name="instance1.cloud.tsuru.io", id="i-0800"), storage.Unit(dns_name="instance2.cloud.tsuru.io", id="i-0801"), storage.Unit(dns_name="instance3.cloud.tsuru.io", id="i-0802", state="started") ] instance = storage.Instance(name="great", units=units) self.storage.store_instance(instance) self.addCleanup(self.storage.remove_instance, instance.name) got_units = self.storage.retrieve_units(state="creating", limit=1) self.assertEqual([u.to_dict() for u in units[:1]], [u.to_dict() for u in got_units])
def test_scale_instance_no_change(self): instance = api_storage.Instance(name="secret", units=[api_storage.Unit(dns_name="secret.cloud.tsuru.io", id="i-0800"), api_storage.Unit(dns_name="secreti.cloud.tsuru.io", id="i-0801")]) storage = mock.Mock() storage.retrieve_instance.return_value = instance manager = managers.BaseManager(storage) with self.assertRaises(ValueError) as cm: manager.scale_instance("secret", 2) exc = cm.exception self.assertEqual(("instance already have 2 units",), exc.args) storage.retrieve_instance.assert_called_with(name="secret")
def test_physical_scale_down(self): self.set_api_envs() self.addCleanup(self.del_api_envs) units = [storage.Unit(id="vm-123"), storage.Unit(id="vm-456"), storage.Unit(id="vm-789")] instance = storage.Instance(name="some_instance", units=copy.deepcopy(units)) strg_mock = mock.Mock() manager = cloudstack.CloudStackManager(storage=strg_mock) manager.client = client_mock = mock.Mock() got_units = manager.physical_scale(instance, 1) self.assertEqual(1, len(instance.units)) self.assertEqual(2, len(got_units)) self.assertEqual("vm-789", instance.units[0].id) expected_calls = [mock.call({"id": "vm-123"}), mock.call({"id": "vm-456"})] self.assertEqual(expected_calls, client_mock.destroyVirtualMachine.call_args_list)
def test_terminate_instance_ignores_exceptions(self, stderr): self.set_api_envs() self.addCleanup(self.del_api_envs) instance = storage.Instance(name="some_instance", units=[storage.Unit(id="vm-123"), storage.Unit(id="vm-456")]) strg_mock = mock.Mock() strg_mock.retrieve_instance.return_value = instance client_mock = mock.Mock() client_mock.destroyVirtualMachine.side_effect = Exception("wat", "wot") manager = cloudstack.CloudStackManager(storage=strg_mock) manager.client = client_mock got_instance = manager.terminate_instance("some_instance") self.assertEqual(instance, got_instance) stderr.write.assert_called_with("[ERROR] Failed to terminate CloudStack VM: wat wot")
def _deploy_vm(self, instance): secret = unicode(uuid.uuid4()) group = os.environ.get("CLOUDSTACK_GROUP", "feaas") data = { "group": group, "templateid": self.get_env("CLOUDSTACK_TEMPLATE_ID"), "zoneid": self.get_env("CLOUDSTACK_ZONE_ID"), "serviceofferingid": self.get_env("CLOUDSTACK_SERVICE_OFFERING_ID"), "userdata": self.client.encode_user_data(self.get_user_data(secret)), } project_id = os.environ.get("CLOUDSTACK_PROJECT_ID") if project_id: data["projectid"] = project_id network_ids = os.environ.get("CLOUDSTACK_NETWORK_IDS") if network_ids: data["networkids"] = network_ids vm_job = self.client.deployVirtualMachine(data) max_tries = int(os.environ.get("CLOUDSTACK_MAX_TRIES", 100)) vm = self._wait_for_unit(vm_job, max_tries, project_id) return storage.Unit(id=vm["id"], dns_name=self._get_dns_name(vm), state="creating", secret=secret)
def test_physical_scale_up(self, uuid): self.set_api_envs() self.addCleanup(self.del_api_envs) self.set_vm_envs(project_id="project-123", network_ids="net-123") self.addCleanup(self.del_vm_envs) uuid.return_value = "uuid_val" instance = storage.Instance(name="some_instance", units=[storage.Unit(id="123")]) strg_mock = mock.Mock() client_mock = mock.Mock() client_mock.deployVirtualMachine.return_value = {"id": "abc123", "jobid": "qwe321"} client_mock.queryAsyncJobResult.return_value = {"jobstatus": 1} vm = {"id": "qwe123", "nic": [{"ipaddress": "10.0.0.5"}]} client_mock.listVirtualMachines.return_value = {"virtualmachine": [vm]} client_mock.encode_user_data.return_value = user_data = mock.Mock() manager = cloudstack.CloudStackManager(storage=strg_mock) manager.client = client_mock units = manager.physical_scale(instance, 2) self.assertEqual(2, len(instance.units)) self.assertEqual(1, len(units)) unit = instance.units[1] self.assertEqual("qwe123", unit.id) self.assertEqual("uuid_val", unit.secret) self.assertEqual(instance, unit.instance) self.assertEqual("10.0.0.5", unit.dns_name) self.assertEqual("creating", unit.state) create_data = {"group": "feaas", "templateid": self.template_id, "zoneid": self.zone_id, "serviceofferingid": self.service_offering_id, "userdata": user_data, "networkids": self.network_ids, "projectid": self.project_id} client_mock.deployVirtualMachine.assert_called_with(create_data) actual_user_data = manager.get_user_data("uuid_val") client_mock.encode_user_data.assert_called_with(actual_user_data)
def test_is_unit_up_down(self, Telnet): Telnet.side_effect = ValueError() unit = storage.Unit(dns_name="instance1.cloud.tsuru.io") manager = mock.Mock(storage=storage.MongoDBStorage()) writer = vcl_writer.VCLWriter(manager, max_items=3) self.assertFalse(writer._is_unit_up(unit)) Telnet.assert_called_with(unit.dns_name, "6082", timeout=3)
def test_retrieve_instance(self): units = [ storage.Unit(dns_name="instance1.cloud.tsuru.io", id="i-0800"), storage.Unit(dns_name="instance2.cloud.tsuru.io", id="i-0801"), storage.Unit(dns_name="instance3.cloud.tsuru.io", id="i-0802") ] instance = storage.Instance(name="what", units=units) self.storage.store_instance(instance) self.addCleanup(self.client.feaas_test.instances.remove, {"name": instance.name}) self.addCleanup(self.client.feaas_test.units.remove, {"instance_name": instance.name}) got_instance = self.storage.retrieve_instance(name="what") self.assertEqual([u.to_dict() for u in units], [u.to_dict() for u in got_instance.units]) self.assertEqual(instance.to_dict(), got_instance.to_dict())
def fake_run_unit(): calls = fake_data["calls"] = fake_data["calls"] + 1 name = "i-080%d" % calls unit = api_storage.Unit(id=name, dns_name="%s.domain.com" % name, secret="%s-secret" % name) fake_data["units"].append(unit) return unit
def test_update_units(self): units = [ storage.Unit(dns_name="instance1.cloud.tsuru.io", id="i-0800"), storage.Unit(dns_name="instance2.cloud.tsuru.io", id="i-0801"), storage.Unit(dns_name="instance3.cloud.tsuru.io", id="i-0802", state="started") ] instance = storage.Instance(name="great", units=units) self.storage.store_instance(instance) self.addCleanup(self.storage.remove_instance, instance.name) units[0].state = "started" units[1].state = "started" self.storage.update_units(units, state="started") got_units = self.storage.retrieve_units(state="started") self.assertEqual([u.to_dict() for u in units], [u.to_dict() for u in got_units])
def test_store_instance_update_with_units(self): units = [ storage.Unit(dns_name="instance1.cloud.tsuru.io", id="i-0800"), storage.Unit(dns_name="instance2.cloud.tsuru.io", id="i-0801"), storage.Unit(dns_name="instance3.cloud.tsuru.io", id="i-0802") ] instance = storage.Instance(name="secret", units=units) self.storage.store_instance(instance) self.addCleanup(self.client.feaas_test.instances.remove, {"name": "secret"}) self.addCleanup(self.client.feaas_test.units.remove, {"instance_name": "secret"}) self.assert_units(units, "secret") new_units = units[1:] instance.units = new_units self.storage.store_instance(instance) self.assert_units(new_units, "secret")
def test_status(self): instance = api_storage.Instance(name="secret", state="started", units=[api_storage.Unit(dns_name="secret.cloud.tsuru.io", id="i-0800")]) storage = mock.Mock() storage.retrieve_instance.return_value = instance manager = managers.BaseManager(storage) status = manager.status("secret") self.assertEqual("started", status)
def test_physical_scale_remove_units(self): unit1 = api_storage.Unit(dns_name="secret1.cloud.tsuru.io", id="i-0800") unit2 = api_storage.Unit(dns_name="secret2.cloud.tsuru.io", id="i-0801") unit3 = api_storage.Unit(dns_name="secret3.cloud.tsuru.io", id="i-0802") units = [unit1, unit2, unit3] instance = api_storage.Instance(name="secret", units=units) storage = mock.Mock() manager = ec2.EC2Manager(storage) manager._terminate_unit = mock.Mock() units = manager.physical_scale(instance, 1) expected = [mock.call(unit1), mock.call(unit2)] self.assertEqual(expected, manager._terminate_unit.call_args_list) self.assertEqual([unit3], instance.units) storage.store_instance.assert_called_with(instance) self.assertEqual([unit1, unit2], units)
def test_is_unit_up_up(self, Telnet): telnet_client = mock.Mock() Telnet.return_value = telnet_client unit = storage.Unit(dns_name="instance1.cloud.tsuru.io") manager = mock.Mock(storage=mock.Mock()) writer = vcl_writer.VCLWriter(manager, max_items=3) self.assertTrue(writer._is_unit_up(unit)) Telnet.assert_called_with(unit.dns_name, "6082", timeout=3) telnet_client.close.assert_called_once()
def test_store_instance_update_without_units(self): units = [ storage.Unit(dns_name="instance1.cloud.tsuru.io", id="i-0800"), storage.Unit(dns_name="instance2.cloud.tsuru.io", id="i-0801"), storage.Unit(dns_name="instance3.cloud.tsuru.io", id="i-0802") ] instance = storage.Instance(name="secret", units=units) self.storage.store_instance(instance) self.addCleanup(self.client.feaas_test.instances.remove, {"name": "secret"}) self.addCleanup(self.client.feaas_test.units.remove, {"instance_name": "secret"}) instance.units = [] instance.state = "started" self.storage.store_instance(instance, save_units=False) self.assert_units(units, instance.name) got_instance = self.storage.retrieve_instance(name=instance.name) self.assertEqual("started", got_instance.state)
def test_run_binds(self): units = [ storage.Unit(id="i-0800", dns_name="unit1.cloud.tsuru.io", secret="abc123", state="started"), storage.Unit(id="i-8001", dns_name="unit2.cloud.tsuru.io", secret="abc321", state="started") ] instance1 = storage.Instance(name="wat", units=units) instance2 = storage.Instance(name="wet", units=units) binds = [ storage.Bind(instance=instance1, app_host="cool", state="creating"), storage.Bind(instance=instance2, app_host="bool", state="creating") ] strg = mock.Mock() strg.retrieve_units.return_value = units strg.retrieve_binds.return_value = binds manager = mock.Mock(storage=strg) writer = vcl_writer.VCLWriter(manager, max_items=3) writer.locker = mock.Mock() writer.run_binds() writer.locker.lock.assert_called_with(vcl_writer.BINDS_LOCKER) writer.locker.unlock.assert_called_with(vcl_writer.BINDS_LOCKER) strg.retrieve_units.assert_called_once_with( state="started", instance_name={"$in": ["wat", "wet"]}) strg.retrieve_binds.assert_called_once_with(state="creating", limit=3) expected_write_vcl_calls = [ mock.call("unit1.cloud.tsuru.io", "abc123", "cool"), mock.call("unit2.cloud.tsuru.io", "abc321", "cool"), mock.call("unit1.cloud.tsuru.io", "abc123", "bool"), mock.call("unit2.cloud.tsuru.io", "abc321", "bool") ] self.assertEqual(expected_write_vcl_calls, manager.write_vcl.call_args_list) expected_update_bind_calls = [ mock.call(binds[0], state="created"), mock.call(binds[1], state="created") ] self.assertEqual(expected_update_bind_calls, strg.update_bind.call_args_list)
def _run_unit(self): ami_id = os.environ.get("AMI_ID") subnet_id = os.environ.get("SUBNET_ID") secret = unicode(uuid.uuid4()) reservation = self.connection.run_instances(image_id=ami_id, subnet_id=subnet_id, user_data=self._user_data(secret)) ec2_instance = reservation.instances[0] return storage.Unit(id=ec2_instance.id, dns_name=ec2_instance.dns_name, secret=secret, state="creating")
def test_run_units(self): units = [ storage.Unit(dns_name="instance1.cloud.tsuru.io", id="i-0800"), storage.Unit(dns_name="instance2.cloud.tsuru.io", id="i-0801"), storage.Unit(dns_name="instance3.cloud.tsuru.io", id="i-0802") ] strg = mock.Mock() strg.retrieve_units.return_value = units manager = mock.Mock(storage=strg) writer = vcl_writer.VCLWriter(manager, max_items=3) writer._is_unit_up = lambda unit: unit == units[1] writer.bind_units = mock.Mock() writer.locker = mock.Mock() writer.run_units() writer.locker.lock.assert_called_with(vcl_writer.UNITS_LOCKER) strg.retrieve_units.assert_called_with(state="creating", limit=3) writer.locker.unlock.assert_called_with(vcl_writer.UNITS_LOCKER) writer.bind_units.assert_called_with([units[1]]) strg.update_units.assert_called_with([units[1]], state="started")
def test_terminate_instance(self): conn = mock.Mock() storage = mock.Mock() unit = api_storage.Unit(id="i-0800") instance = api_storage.Instance(name="secret", units=[unit]) storage.retrieve_instance.return_value = instance manager = ec2.EC2Manager(storage) manager._connection = conn got_instance = manager.terminate_instance("secret") conn.terminate_instances.assert_called_with(instance_ids=["i-0800"]) storage.retrieve_instance.assert_called_with(name="secret") self.assertEqual(instance, got_instance)
def test_terminate_instance_ec2_failure(self, stderr_mock): conn = mock.Mock() conn.terminate_instances.side_effect = ValueError( "Something went wrong") unit = api_storage.Unit(id="i-0800") storage = mock.Mock() storage.retrieve_instance.return_value = api_storage.Instance( name="secret", units=[unit]) manager = ec2.EC2Manager(storage) manager._connection = conn manager.terminate_instance("someapp") msg = "[ERROR] Failed to terminate EC2 instance: Something went wrong" stderr_mock.write.assert_called_with(msg)
def test_bind_instance(self, Bind): Bind.return_value = "abacaxi" instance = api_storage.Instance(name="myinstance", units=[api_storage.Unit(secret="abc-123", dns_name="10.1.1.2", id="i-0800")]) storage = mock.Mock() storage.retrieve_instance.return_value = instance manager = managers.BaseManager(storage) manager.bind("someapp", "myapp.cloud.tsuru.io") storage.retrieve_instance.assert_called_with(name="someapp") storage.store_bind.assert_called_with("abacaxi") Bind.assert_called_with("myapp.cloud.tsuru.io", instance)
def test_bind_units(self): instance1 = storage.Instance(name="myinstance") instance2 = storage.Instance(name="yourinstance") units = [ storage.Unit(dns_name="instance1-1.cloud.tsuru.io", id="i-0800", instance=instance1, secret="abc123"), storage.Unit(dns_name="instance1-2.cloud.tsuru.io", id="i-0801", instance=instance1, secret="abc321"), storage.Unit(dns_name="instance2-1.cloud.tsuru.io", id="i-0802", instance=instance2, secret="abc456") ] strg = mock.Mock() strg.retrieve_units.return_value = units strg.retrieve_binds.return_value = [ storage.Bind("myapp.cloud.tsuru.io", instance1) ] manager = mock.Mock(storage=strg) writer = vcl_writer.VCLWriter(manager, max_items=3) writer.bind_units(units) expected_calls = [ mock.call(instance_name="myinstance", state="created"), mock.call(instance_name="yourinstance", state="created") ] self.assertEqual(expected_calls, strg.retrieve_binds.call_args_list) expected_calls = [ mock.call("instance1-1.cloud.tsuru.io", "abc123", "myapp.cloud.tsuru.io"), mock.call("instance1-2.cloud.tsuru.io", "abc321", "myapp.cloud.tsuru.io"), mock.call("instance2-1.cloud.tsuru.io", "abc456", "myapp.cloud.tsuru.io") ] self.assertEqual(expected_calls, manager.write_vcl.call_args_list)
def test_to_dict(self): instance = storage.Instance(name="myinstance") unit = storage.Unit(id="i-0800", dns_name="instance.cloud.tsuru.io", secret="abc123", state="started", instance=instance) expected = { "id": "i-0800", "dns_name": "instance.cloud.tsuru.io", "secret": "abc123", "state": "started", "instance_name": "myinstance" } self.assertEqual(expected, unit.to_dict())
def test_physical_scale_add_units(self): instance = api_storage.Instance( name="secret", units=[ api_storage.Unit(dns_name="secret.cloud.tsuru.io", id="i-0800") ]) fake_run_unit, fake_data = self.get_fake_run_unit() storage = mock.Mock() manager = ec2.EC2Manager(storage) manager._run_unit = fake_run_unit units = manager.physical_scale(instance, 4) self.assertEqual(fake_data["calls"], 3) instance.units.extend(fake_data["units"]) storage.store_instance.assert_called_with(instance) self.assertEqual(fake_data["units"], units)
def test_store_instance_with_units(self): units = [storage.Unit(dns_name="instance.cloud.tsuru.io", id="i-0800")] instance = storage.Instance(name="secret", units=units) self.storage.store_instance(instance) self.addCleanup(self.client.feaas_test.instances.remove, {"name": "secret"}) self.addCleanup(self.client.feaas_test.units.remove, {"instance_name": "secret"}) instance = self.client.feaas_test.instances.find_one( {"name": "secret"}) expected = { "name": "secret", "_id": instance["_id"], "state": "creating" } self.assertEqual(expected, instance) unit = self.client.feaas_test.units.find_one({ "id": "i-0800", "instance_name": "secret" }) expected = units[0].to_dict() expected["_id"] = unit["_id"] self.assertEqual(expected, unit)
def test_init_with_units(self): units = [storage.Unit(id="i-0800"), storage.Unit(id="i-0801")] instance = storage.Instance(name="something", units=units) for unit in units: self.assertEqual(instance, unit.instance)