def test_validate_container_state(self):
container = Container(self.context, **db_utils.get_test_container())
container.status = 'Stopped'
with self.assertRaisesRegex(exception.InvalidStateException,
"%s" % container.uuid):
utils.validate_container_state(container, 'stop')
with self.assertRaisesRegex(exception.InvalidStateException,
"%s" % container.uuid):
utils.validate_container_state(container, 'pause')
container.status = 'Running'
with self.assertRaisesRegex(exception.InvalidStateException,
"%s" % container.uuid):
utils.validate_container_state(container, 'start')
with self.assertRaisesRegex(exception.InvalidStateException,
"%s" % container.uuid):
utils.validate_container_state(container, 'unpause')
with self.assertRaisesRegex(exception.InvalidStateException,
"%s" % container.uuid):
utils.validate_container_state(container, 'delete')
self.assertIsNone(utils.validate_container_state(
container, 'reboot'))
container.status = 'Stopped'
self.assertIsNone(utils.validate_container_state(
container, 'reboot'))
container.status = 'Running'
self.assertIsNone(utils.validate_container_state(
container, 'execute'))
def test_container_commit_failed(self, mock_commit, mock_delete):
container = Container(self.context, **utils.get_test_container())
mock_commit.side_effect = exception.DockerError
self.assertRaises(exception.DockerError,
self.compute_manager._do_container_commit,
self.context, container, 'repo', 'tag')
self.assertTrue(mock_delete.called)
def test_fail_container(self, mock_save):
container = Container(self.context, **utils.get_test_container())
self.compute_manager._fail_container(self.context, container,
"Creation Failed")
self.assertEqual(consts.ERROR, container.status)
self.assertEqual("Creation Failed", container.status_reason)
self.assertIsNone(container.task_state)
def test_connect_container_to_network(self):
container = Container(self.context, **utils.get_test_container())
network_name = 'c02afe4e-8350-4263-8078'
requested_net = {
'ipv4_address': '10.5.0.22',
'port': 'fake-port-id',
'preserve_on_delete': True
}
expected_address = [{
'version': 4,
'addr': '10.5.0.22',
'port': 'fake-port-id',
'subnet_id': 'fake-subnet-id',
'preserve_on_delete': True
}]
old_port = self.network_driver.neutron_api.list_ports(
id='fake-port-id')['ports'][0]
self.assertEqual('', old_port['device_id'])
with mock.patch.object(self.network_driver.docker,
'connect_container_to_network') as mock_connect:
address = self.network_driver.connect_container_to_network(
container, network_name, requested_net)
self.assertEqual(expected_address, address)
mock_connect.assert_called_once_with(container.container_id,
network_name,
ipv4_address='10.5.0.22')
new_port = self.network_driver.neutron_api.list_ports(
id='fake-port-id')['ports'][0]
self.assertEqual(container.uuid, new_port['device_id'])
def test_init_container_retries_reboot(self, mock_save,
mock_container_reboot):
container = Container(self.context, **utils.get_test_container())
container.task_state = consts.CONTAINER_REBOOTING
self.compute_manager._init_container(self.context, container)
mock_container_reboot.assert_called_once_with(self.context,
container, 60)
def test_init_container_retries_stop_already(self, mock_save):
container = Container(self.context, **utils.get_test_container())
container.task_state = consts.CONTAINER_STOPPING
container.status = consts.STOPPED
self.compute_manager._init_container(self.context, container)
self.assertEqual(container.status, consts.STOPPED)
self.assertIsNone(container.task_state)
def test_container_logs_failed(self, mock_logs):
container = Container(self.context, **utils.get_test_container())
mock_logs.side_effect = exception.DockerError
self.assertRaises(exception.DockerError,
self.compute_manager.container_logs,
self.context, container, True, True,
False, 'all', None)
def test_container_attach_successful(self, mock_save,
mock_get_websocket_url):
container = Container(self.context, **utils.get_test_container())
mock_get_websocket_url.return_value = "ws://test"
self.compute_manager.container_attach(self.context, container)
mock_get_websocket_url.assert_called_once_with(self.context, container)
mock_save.assert_called_once_with(self.context)
def test_container_run_create_raises_docker_error(
self, mock_create, mock_pull, mock_attach_volume,
mock_detach_volume, mock_list_by_container, mock_save,
mock_spawn_n):
container = Container(self.context, **utils.get_test_container())
image = {'image': 'repo', 'path': 'out_path', 'driver': 'glance',
'repo': 'test', 'tag': 'testtag'}
mock_pull.return_value = image, True
mock_create.side_effect = exception.DockerError(
message="Docker Error occurred")
mock_spawn_n.side_effect = lambda f, *x, **y: f(*x, **y)
self.compute_manager._resource_tracker = FakeResourceTracker()
networks = []
volumes = [FakeVolumeMapping()]
self.compute_manager.container_create(
self.context,
requested_networks=networks,
requested_volumes=volumes,
container=container,
limits=None, run=True)
mock_save.assert_called_with(self.context)
self.assertEqual('Error', container.status)
self.assertEqual('Docker Error occurred', container.status_reason)
mock_pull.assert_any_call(self.context, container.image, 'latest',
'always', 'glance')
mock_create.assert_called_once_with(
self.context, container, image, networks, volumes)
mock_attach_volume.assert_called_once()
mock_detach_volume.assert_called_once()
self.assertEqual(0, len(FakeVolumeMapping.volumes))
def test_init_container_sets_creating_error(self, mock_save):
container = Container(self.context, **utils.get_test_container())
container.status = consts.CREATING
self.compute_manager._init_container(context=self.context,
container=container)
self.assertEqual(consts.ERROR, container.status)
self.assertIsNone(container.task_state)
def test_container_run_driver_attach_failed(
self, mock_start, mock_create, mock_attach_volume,
mock_detach_volume, mock_pull, mock_list_by_container, mock_save,
mock_spawn_n):
mock_attach_volume.side_effect = [None, base.TestingException("fake")]
container = Container(self.context, **utils.get_test_container())
vol = FakeVolumeMapping()
vol2 = FakeVolumeMapping()
image = {'image': 'repo', 'path': 'out_path', 'driver': 'glance'}
mock_create.return_value = container
mock_pull.return_value = image, False
mock_spawn_n.side_effect = lambda f, *x, **y: f(*x, **y)
container.status = 'Stopped'
self.compute_manager._resource_tracker = FakeResourceTracker()
networks = []
volumes = [vol, vol2]
self.compute_manager.container_create(
self.context,
requested_networks=networks,
requested_volumes=volumes,
container=container,
limits=None, run=True)
mock_save.assert_called_with(self.context)
mock_pull.assert_not_called()
mock_create.assert_not_called()
mock_start.assert_not_called()
mock_attach_volume.assert_has_calls([
mock.call(mock.ANY, vol), mock.call(mock.ANY, vol2)])
mock_detach_volume.assert_has_calls([
mock.call(mock.ANY, vol)])
self.assertEqual(0, len(FakeVolumeMapping.volumes))
def test_container_run_image_pull_docker_error(
self, mock_pull, mock_attach_volume, mock_detach_volume,
mock_list_by_container, mock_save, mock_spawn_n):
container_dict = utils.get_test_container(
image='test:latest', image_driver='docker',
image_pull_policy='ifnotpresent')
container = Container(self.context, **container_dict)
mock_pull.side_effect = exception.DockerError(
message="Docker Error occurred")
mock_spawn_n.side_effect = lambda f, *x, **y: f(*x, **y)
networks = []
volumes = [FakeVolumeMapping()]
self.compute_manager.container_create(
self.context,
requested_networks=networks,
requested_volumes=volumes,
container=container,
limits=None, run=True)
mock_save.assert_called_with(self.context)
self.assertEqual('Error', container.status)
self.assertEqual('Docker Error occurred', container.status_reason)
mock_pull.assert_called_once_with(self.context, 'test', 'latest',
'ifnotpresent', 'docker')
mock_attach_volume.assert_called_once()
mock_detach_volume.assert_called_once()
self.assertEqual(0, len(FakeVolumeMapping.volumes))
def test_container_run(
self, mock_start, mock_create, mock_attach_volume,
mock_detach_volume, mock_pull, mock_list_by_container, mock_save,
mock_spawn_n):
container = Container(self.context, **utils.get_test_container())
image = {'image': 'repo', 'path': 'out_path', 'driver': 'glance'}
mock_create.return_value = container
mock_pull.return_value = image, False
mock_spawn_n.side_effect = lambda f, *x, **y: f(*x, **y)
container.status = 'Stopped'
self.compute_manager._resource_tracker = FakeResourceTracker()
networks = []
volumes = [FakeVolumeMapping()]
self.compute_manager.container_create(
self.context,
requested_networks=networks,
requested_volumes=volumes,
container=container,
limits=None, run=True)
mock_save.assert_called_with(self.context)
mock_pull.assert_any_call(self.context, container.image, 'latest',
'always', 'glance')
mock_create.assert_called_once_with(self.context, container, image,
networks, volumes)
mock_start.assert_called_once_with(self.context, container)
mock_attach_volume.assert_called_once()
mock_detach_volume.assert_not_called()
self.assertEqual(1, len(FakeVolumeMapping.volumes))
def test_init_container_retries_container_delete_task(
self, mock_save, mock_container_delete):
container = Container(self.context, **utils.get_test_container())
container.task_state = consts.CONTAINER_DELETING
self.compute_manager._init_container(self.context, container)
mock_container_delete.assert_called_once_with(self.context, container,
force=True)
def test_connect_container_to_network(self):
container = Container(self.context, **utils.get_test_container())
network_name = 'c02afe4e-8350-4263-8078'
expected = [{'version': 4, 'addr': '192.168.2.22', 'port': '1234567'}]
address = self.network_api.connect_container_to_network(
container, network_name)
self.assertEqual(expected, address)
def test_container_unpause_failed(self, mock_unpause):
container = Container(self.context, **utils.get_test_container())
mock_unpause.side_effect = exception.DockerError
self.assertRaises(exception.DockerError,
self.compute_manager._do_container_unpause,
self.context,
container,
reraise=True)
def test_init_container_retries_deleting(self, mock_save,
mock_container_delete):
kw = {'status': consts.DELETING,
'task_state': None}
container = Container(self.context, **utils.get_test_container(**kw))
self.compute_manager._init_container(self.context, container)
mock_container_delete.assert_called_once_with(self.context, container,
force=True)
def test_container_create_pull_image_failed_image_not_found(
self, mock_fail, mock_pull, mock_create_sandbox, mock_save):
container = Container(self.context, **utils.get_test_container())
mock_pull.side_effect = exception.ImageNotFound("Image Not Found")
mock_create_sandbox.return_value = mock.MagicMock()
self.compute_manager._do_container_create(self.context, container)
mock_fail.assert_called_once_with(self.context, container,
"Image Not Found")
def test_init_container_retries_start(self, mock_save,
mock_container_start):
container = Container(self.context, **utils.get_test_container())
container.task_state = consts.CONTAINER_STARTING
container.status = consts.STOPPED
self.compute_manager._init_container(self.context, container)
mock_container_start.assert_called_once_with(self.context,
container)
def test_container_execute(self, mock_execute_create, mock_execute_run):
mock_execute_create.return_value = 'fake_exec_id'
container = Container(self.context, **utils.get_test_container())
self.compute_manager.container_exec(
self.context, container, 'fake_cmd', True, False)
mock_execute_create.assert_called_once_with(
self.context, container, 'fake_cmd', False)
mock_execute_run.assert_called_once_with('fake_exec_id', 'fake_cmd')
def test_container_logs(self, mock_logs):
container = Container(self.context, **utils.get_test_container())
self.compute_manager.container_logs(self.context,
container, True, True,
False, 'all', None)
mock_logs.assert_called_once_with(
self.context, container, stderr=True, stdout=True,
timestamps=False, tail='all', since=None)
def test_container_create_pull_image_failed_image_not_found(
self, mock_fail, mock_pull, mock_save):
container = Container(self.context, **utils.get_test_container())
mock_pull.side_effect = exception.ImageNotFound("Image Not Found")
networks = []
self.compute_manager._do_container_create(self.context, container,
networks)
mock_fail.assert_called_once_with(self.context,
container, "Image Not Found")
def test_container_kill_failed(self, mock_kill, mock_fail):
container = Container(self.context, **utils.get_test_container())
mock_kill.side_effect = exception.DockerError(
message="Docker Error occurred")
self.assertRaises(exception.DockerError,
self.compute_manager._do_container_kill,
self.context, container, None, reraise=True)
mock_fail.assert_called_with(self.context,
container, 'Docker Error occurred')
def test_init_container_sets_creating_tasks_error(self, mock_save):
tasks = [consts.CONTAINER_CREATING, consts.IMAGE_PULLING]
container = Container(self.context, **utils.get_test_container())
for task in tasks:
container.task_state = task
self.compute_manager._init_container(context=self.context,
container=container)
self.assertEqual(consts.ERROR, container.status)
self.assertIsNone(container.task_state)
def test_container_delete(self, mock_delete, mock_save, mock_cnt_destroy,
mock_remove_usage):
container = Container(self.context, **utils.get_test_container())
self.compute_manager.container_delete(self. context, container, False)
mock_save.assert_called_with(self.context)
mock_delete.assert_called_once_with(self.context, container, False)
mock_cnt_destroy.assert_called_once_with(self.context)
mock_remove_usage.assert_called_once_with(self.context, container,
True)
def test_container_create_pull_image_failed_docker_error(
self, mock_fail, mock_pull, mock_save):
container = Container(self.context, **utils.get_test_container())
mock_pull.side_effect = exception.DockerError("Pull Failed")
networks = []
self.compute_manager._do_container_create(self.context, container,
networks)
mock_fail.assert_called_once_with(self.context,
container, "Pull Failed")
def test_container_start_failed(self, mock_start, mock_fail):
container = Container(self.context, **utils.get_test_container())
mock_start.side_effect = exception.DockerError
self.assertRaises(exception.DockerError,
self.compute_manager._do_container_start,
self.context,
container,
reraise=True)
mock_fail.assert_called_once()
def test_container_create_docker_create_failed(self, mock_fail,
mock_create_sandbox,
mock_create, mock_pull,
mock_save):
container = Container(self.context, **utils.get_test_container())
mock_create.side_effect = exception.DockerError("Creation Failed")
mock_create_sandbox.return_value = mock.MagicMock()
self.compute_manager._do_container_create(self.context, container)
mock_fail.assert_called_once_with(self.context, container,
"Creation Failed")
def test_container_delete_failed(self, mock_delete, mock_save, mock_fail):
container = Container(self.context, **utils.get_test_container())
mock_delete.side_effect = exception.DockerError(
message="Docker Error occurred")
self.assertRaises(exception.DockerError,
self.compute_manager.container_delete, self.context,
container, False)
mock_save.assert_called_with(self.context)
mock_fail.assert_called_with(self.context, container,
'Docker Error occurred')
def test_wart_container_event(self, mock_finish, mock_start):
container = Container(self.context, **db_utils.get_test_container())
@utils.wrap_container_event(prefix='compute')
def fake_event(self, context, container):
pass
fake_event(self, self.context, container=container)
self.assertTrue(mock_start.called)
self.assertTrue(mock_finish.called)
