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)
