def create_one_image(self, user, **kwargs):
"""Create one image for the user."""
clients = osclients.Clients(user["endpoint"])
image_id = types.ImageResourceType.transform(
clients=clients, resource_config=self.config["image"])
flavor_id = types.FlavorResourceType.transform(
clients=clients, resource_config=self.config["flavor"])
vm_scenario = vmtasks.VMTasks(self.context, clients=clients)
server, fip = vm_scenario._boot_server_with_fip(
name=vm_scenario._generate_random_name("rally_ctx_custom_image_"),
image=image_id,
flavor=flavor_id,
floating_network=self.config.get("floating_network"),
userdata=self.config.get("userdata"),
key_name=user["keypair"]["name"],
security_groups=[user["secgroup"]["name"]],
**kwargs)
LOG.debug("Installing benchmark on %r %s", server, fip["ip"])
self.customize_image(server, fip, user)
LOG.debug("Stopping server %r", server)
vm_scenario._stop_server(server)
LOG.debug("Creating snapshot for %r", server)
custom_image = vm_scenario._create_image(server).to_dict()
vm_scenario._delete_server_with_fip(server, fip)
return custom_image
def test_boot_runcommand_delete(self, mock_json_loads):
# Setup mocks
scenario = vmtasks.VMTasks()
fake_server = fakes.FakeServer()
fake_server.addresses = dict(private=[dict(version=4, addr="1.2.3.4")])
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._generate_random_name = mock.MagicMock(return_value="name")
fake_floating_ip = fakes.FakeFloatingIP()
fake_floating_ip.ip = "4.3.2.1"
scenario._create_floating_ip = mock.MagicMock(
return_value=fake_floating_ip)
scenario._associate_floating_ip = mock.MagicMock()
scenario._release_server_floating_ip = mock.MagicMock()
fake_floating_ip_pool = fakes.FakeFloatingIPPool()
fake_floating_ip_pool.name = "public"
scenario._list_floating_ip_pools = mock.MagicMock(
return_value=[fake_floating_ip_pool])
scenario.run_command = mock.MagicMock()
scenario.run_command.return_value = (0, 'stdout', 'stderr')
scenario._delete_server = mock.MagicMock()
# Run scenario
scenario.boot_runcommand_delete("image_id",
"flavour_id",
"script_path",
"interpreter",
fixed_network='private',
floating_network='public',
username="******",
ip_version=4,
port=22,
use_floatingip=True,
fakearg="f")
# Assertions
scenario._boot_server.assert_called_once_with('name',
'image_id',
"flavour_id",
key_name="rally_ssh_key",
fakearg="f")
scenario._create_floating_ip.assert_called_once_with(
fake_floating_ip_pool.name)
scenario._associate_floating_ip.assert_called_once_with(
fake_server, fake_floating_ip)
scenario.run_command.assert_called_once_with(fake_floating_ip.ip, 22,
'username', "interpreter",
"script_path")
mock_json_loads.assert_called_once_with('stdout')
scenario._release_server_floating_ip.assert_called_once_with(
fake_server, fake_floating_ip)
scenario._delete_server.assert_called_once_with(fake_server)
def test__release_server_floating_ip(self):
scenario = vmtasks.VMTasks()
fake_server = fakes.FakeServer()
fake_floating_ip = fakes.FakeFloatingIP()
scenario._dissociate_floating_ip = mock.MagicMock()
scenario._delete_floating_ip = mock.MagicMock()
scenario.check_ip_address = mock.MagicMock(
return_value=mock.MagicMock(return_value=True))
scenario._release_server_floating_ip(fake_server, fake_floating_ip)
scenario._dissociate_floating_ip.assert_called_once_with(
fake_server, fake_floating_ip)
scenario._delete_floating_ip.assert_called_once_with(fake_floating_ip)
def setUp(self):
super(VMTasksTestCase, self).setUp()
self.scenario = vmtasks.VMTasks(
context={"user": {
"keypair": {
"name": "keypair_name"
}
}})
self.ip = {"id": "foo_id", "ip": "foo_ip", "is_floating": True}
self.scenario._boot_server_with_fip = mock.Mock(
return_value=("foo_server", self.ip))
self.scenario._delete_server_with_fip = mock.Mock()
self.scenario._create_volume = mock.Mock(return_value=mock.Mock(
id="foo_volume"))
self.scenario._run_command = mock.MagicMock(
return_value=(0, "\"foo_out\"", "foo_err"))
def test_boot_runcommand_delete_no_floating_ip(self, mock_json_loads):
# Setup mocks
scenario = vmtasks.VMTasks()
fake_server = fakes.FakeServer()
fake_server.addresses = dict(private=[dict(version=4, addr="1.2.3.4")])
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._generate_random_name = mock.MagicMock(return_value="name")
scenario.run_command = mock.MagicMock()
scenario.run_command.return_value = (0, 'stdout', 'stderr')
scenario._delete_server = mock.MagicMock()
# Run scenario
scenario.boot_runcommand_delete("image_id",
"flavour_id",
"script_path",
"interpreter",
fixed_network='private',
floating_network='public',
username="******",
ip_version=4,
port=22,
use_floatingip=False,
fakearg="f")
# Assertions
scenario._boot_server.assert_called_once_with('name',
'image_id',
"flavour_id",
key_name="rally_ssh_key",
fakearg="f")
scenario.run_command.assert_called_once_with(
fake_server.addresses['private'][0]['addr'], 22, 'username',
"interpreter", "script_path")
mock_json_loads.assert_called_once_with('stdout')
scenario._delete_server.assert_called_once_with(fake_server)
def setUp(self):
super(VMTasksTestCase, self).setUp()
self.scenario = vmtasks.VMTasks(
context={"user": {
"keypair": {
"name": "keypair_name"
}
}})
self.clients = mock.Mock()
self.fip = {"id": "fip_id", "ip": "fip_ip"}
self.server = mock.Mock(networks={"foo_net": "foo_net_data"},
addresses={"foo_net": [{
"addr": "foo_addr"
}]},
tenant_id="foo_tenant")
self.scenario._create_volume = mock.Mock(return_value=mock.Mock(
id="foo_volume"))
self.scenario._boot_server_with_fip = mock.MagicMock(
return_value=(self.server, self.fip))
self.scenario._delete_server_with_fip = mock.MagicMock()
self.scenario._run_command = mock.MagicMock(
return_value=(0, "\"foo_out\"", "foo_err"))
def test_boot_runcommand_delete(self, mock_json_loads):
# Setup mocks
scenario = vmtasks.VMTasks()
scenario._boot_server = mock.MagicMock(return_value="fake_server")
scenario._generate_random_name = mock.MagicMock(return_value="name")
scenario.run_command = mock.MagicMock()
scenario.run_command.return_value = ('code', 'stdout', 'stderr')
scenario._delete_server = mock.MagicMock()
# Run scenario
scenario.boot_runcommand_delete("image_id",
"flavour_id",
"script_path",
"interpreter",
network="network",
username="******",
ip_version="ip_version",
port="port",
fakearg="f")
# Assertions
scenario._boot_server.assert_called_once_with('name',
'image_id',
"flavour_id",
key_name="rally_ssh_key",
fakearg="f")
scenario.run_command.assert_called_once_with("fake_server", 'username',
"network", "port",
"ip_version",
"interpreter",
"script_path")
mock_json_loads.assert_called_once_with('stdout')
scenario._delete_server.assert_called_once_with("fake_server")