Exemple #1
0
    def test_deploy_fail(self):

        def refresh():
            pass

        self.node.refresh = refresh

        self.mox.StubOutWithMock(pxe, '_create_pxe_config')
        self.mox.StubOutWithMock(pxe, '_cache_images')
        self.mox.StubOutWithMock(pxe, '_get_tftp_image_info')
        pxe._get_tftp_image_info(self.node).AndReturn(None)
        pxe._create_pxe_config(mox.IgnoreArg(), self.node, None).\
            AndReturn(None)
        pxe._cache_images(self.node, None).AndReturn(None)
        self.mox.ReplayAll()

        class handler_deploying(threading.Thread):
            def __init__(self, node):
                threading.Thread.__init__(self)
                self.node = node

            def run(self):
                self.node['provision_state'] = states.DEPLOYING
                time.sleep(2)
                self.node['provision_state'] = states.DEPLOYFAIL

        handler = handler_deploying(self.node)
        handler.start()
        with task_manager.acquire([self.node['uuid']], shared=False) as task:
            self.assertRaises(exception.InstanceDeployFailure,
                              task.resources[0].driver.deploy.deploy,
                              task,
                              self.node)
        self.mox.VerifyAll()
    def test_start_deploy(self):
        self.mox.StubOutWithMock(pxe, '_create_pxe_config')
        self.mox.StubOutWithMock(pxe, '_cache_images')
        self.mox.StubOutWithMock(pxe, '_get_tftp_image_info')
        pxe._get_tftp_image_info(self.node).AndReturn(None)
        pxe._create_pxe_config(mox.IgnoreArg(), self.node, None).\
            AndReturn(None)
        pxe._cache_images(self.node, None).AndReturn(None)
        self.mox.ReplayAll()

        with task_manager.acquire([self.node['uuid']], shared=False) as task:
            state = task.resources[0].driver.deploy.deploy(task, self.node)
        self.assertEqual(state, states.DEPLOYING)
        self.mox.VerifyAll()
Exemple #3
0
    def test__get_tftp_image_info(self):
        properties = {
            'properties': {
                u'kernel_id': u'instance_kernel_uuid',
                u'ramdisk_id': u'instance_ramdisk_uuid'
            }
        }

        expected_info = {
            'ramdisk': [
                'instance_ramdisk_uuid',
                os.path.join(CONF.pxe.tftp_root, self.node.uuid, 'ramdisk')
            ],
            'kernel': [
                'instance_kernel_uuid',
                os.path.join(CONF.pxe.tftp_root, self.node.uuid, 'kernel')
            ],
            'deploy_ramdisk': [
                'deploy_ramdisk_uuid',
                os.path.join(CONF.pxe.tftp_root, self.node.uuid,
                             'deploy_ramdisk')
            ],
            'deploy_kernel': [
                'deploy_kernel_uuid',
                os.path.join(CONF.pxe.tftp_root, self.node.uuid,
                             'deploy_kernel')
            ]
        }
        with mock.patch.object(base_image_service.BaseImageService, '_show') \
                as show_mock:
            show_mock.return_value = properties
            image_info = pxe._get_tftp_image_info(self.node, self.context)
            show_mock.assert_called_once_with('glance://image_uuid',
                                              method='get')
            self.assertEqual(image_info, expected_info)
Exemple #4
0
    def test__get_tftp_image_info(self):
        properties = {'properties': {u'kernel_id': u'instance_kernel_uuid',
                     u'ramdisk_id': u'instance_ramdisk_uuid'}}

        expected_info = {'ramdisk':
                         ['instance_ramdisk_uuid',
                          os.path.join(CONF.pxe.tftp_root,
                                       self.node.uuid,
                                       'ramdisk')],
                         'kernel':
                         ['instance_kernel_uuid',
                          os.path.join(CONF.pxe.tftp_root,
                                       self.node.uuid,
                                       'kernel')],
                         'deploy_ramdisk':
                         ['deploy_ramdisk_uuid',
                           os.path.join(CONF.pxe.tftp_root,
                                        self.node.uuid,
                                        'deploy_ramdisk')],
                         'deploy_kernel':
                         ['deploy_kernel_uuid',
                          os.path.join(CONF.pxe.tftp_root,
                                       self.node.uuid,
                                       'deploy_kernel')]}
        with mock.patch.object(base_image_service.BaseImageService, '_show') \
                as show_mock:
            show_mock.return_value = properties
            image_info = pxe._get_tftp_image_info(self.node, self.context)
            show_mock.assert_called_once_with('glance://image_uuid',
                                               method='get')
            self.assertEqual(expected_info, image_info)
Exemple #5
0
    def test__get_tftp_image_info(self, show_mock):
        properties = {'properties': {u'kernel_id': u'instance_kernel_uuid',
                     u'ramdisk_id': u'instance_ramdisk_uuid'}}

        expected_info = {'ramdisk':
                         ('instance_ramdisk_uuid',
                          os.path.join(CONF.pxe.tftp_root,
                                       self.node.uuid,
                                       'ramdisk')),
                         'kernel':
                         ('instance_kernel_uuid',
                          os.path.join(CONF.pxe.tftp_root,
                                       self.node.uuid,
                                       'kernel')),
                         'deploy_ramdisk':
                         ('deploy_ramdisk_uuid',
                           os.path.join(CONF.pxe.tftp_root,
                                        self.node.uuid,
                                        'deploy_ramdisk')),
                         'deploy_kernel':
                         ('deploy_kernel_uuid',
                          os.path.join(CONF.pxe.tftp_root,
                                       self.node.uuid,
                                       'deploy_kernel'))}
        show_mock.return_value = properties
        image_info = pxe._get_tftp_image_info(self.node, self.context)
        show_mock.assert_called_once_with('glance://image_uuid',
                                           method='get')
        self.assertEqual(expected_info, image_info)

        # test with saved info
        show_mock.reset_mock()
        image_info = pxe._get_tftp_image_info(self.node, self.context)
        self.assertEqual(expected_info, image_info)
        self.assertFalse(show_mock.called)
        self.assertEqual('instance_kernel_uuid',
                         self.node.instance_info.get('kernel'))
        self.assertEqual('instance_ramdisk_uuid',
                         self.node.instance_info.get('ramdisk'))
Exemple #6
0
    def test__get_tftp_image_info(self, show_mock):
        properties = {'properties': {u'kernel_id': u'instance_kernel_uuid',
                     u'ramdisk_id': u'instance_ramdisk_uuid'}}

        expected_info = {'ramdisk':
                         ('instance_ramdisk_uuid',
                          os.path.join(CONF.pxe.tftp_root,
                                       self.node.uuid,
                                       'ramdisk')),
                         'kernel':
                         ('instance_kernel_uuid',
                          os.path.join(CONF.pxe.tftp_root,
                                       self.node.uuid,
                                       'kernel')),
                         'deploy_ramdisk':
                         ('deploy_ramdisk_uuid',
                           os.path.join(CONF.pxe.tftp_root,
                                        self.node.uuid,
                                        'deploy_ramdisk')),
                         'deploy_kernel':
                         ('deploy_kernel_uuid',
                          os.path.join(CONF.pxe.tftp_root,
                                       self.node.uuid,
                                       'deploy_kernel'))}
        show_mock.return_value = properties
        image_info = pxe._get_tftp_image_info(self.node, self.context)
        show_mock.assert_called_once_with('glance://image_uuid',
                                           method='get')
        self.assertEqual(expected_info, image_info)

        # test with saved info
        show_mock.reset_mock()
        image_info = pxe._get_tftp_image_info(self.node, self.context)
        self.assertEqual(expected_info, image_info)
        self.assertFalse(show_mock.called)
        self.assertEqual('instance_kernel_uuid',
                         self.node.instance_info.get('kernel'))
        self.assertEqual('instance_ramdisk_uuid',
                         self.node.instance_info.get('ramdisk'))
Exemple #7
0
    def test_deploy_timeout_fail(self):

        def refresh():
            pass

        self.node.refresh = refresh

        self.mox.StubOutWithMock(pxe, '_create_pxe_config')
        self.mox.StubOutWithMock(pxe, '_cache_images')
        self.mox.StubOutWithMock(pxe, '_get_tftp_image_info')
        pxe._get_tftp_image_info(self.node).AndReturn(None)
        pxe._create_pxe_config(mox.IgnoreArg(), self.node, None).\
            AndReturn(None)
        pxe._cache_images(self.node, None).AndReturn(None)
        self.mox.ReplayAll()

        CONF.set_default('pxe_deploy_timeout', 2, group='pxe')

        with task_manager.acquire([self.node['uuid']], shared=False) as task:
            self.assertRaises(exception.InstanceDeployFailure,
                              task.resources[0].driver.deploy.deploy,
                              task,
                              self.node)
        self.mox.VerifyAll()
Exemple #8
0
    def test__get_tftp_image_info(self, show_mock):
        properties = {"properties": {u"kernel_id": u"instance_kernel_uuid", u"ramdisk_id": u"instance_ramdisk_uuid"}}

        expected_info = {
            "ramdisk": ("instance_ramdisk_uuid", os.path.join(CONF.pxe.tftp_root, self.node.uuid, "ramdisk")),
            "kernel": ("instance_kernel_uuid", os.path.join(CONF.pxe.tftp_root, self.node.uuid, "kernel")),
            "deploy_ramdisk": (
                "deploy_ramdisk_uuid",
                os.path.join(CONF.pxe.tftp_root, self.node.uuid, "deploy_ramdisk"),
            ),
            "deploy_kernel": ("deploy_kernel_uuid", os.path.join(CONF.pxe.tftp_root, self.node.uuid, "deploy_kernel")),
        }
        show_mock.return_value = properties
        image_info = pxe._get_tftp_image_info(self.node, self.context)
        show_mock.assert_called_once_with("glance://image_uuid", method="get")
        self.assertEqual(expected_info, image_info)

        # test with saved info
        show_mock.reset_mock()
        image_info = pxe._get_tftp_image_info(self.node, self.context)
        self.assertEqual(expected_info, image_info)
        self.assertFalse(show_mock.called)
        self.assertEqual("instance_kernel_uuid", self.node.driver_info.get("pxe_kernel"))
        self.assertEqual("instance_ramdisk_uuid", self.node.driver_info.get("pxe_ramdisk"))
Exemple #9
0
    def test__get_tftp_image_info(self):
        properties = {'properties': {u'kernel_id': u'instance_kernel_uuid',
                     u'ramdisk_id': u'instance_ramdisk_uuid'}}

        expected_info = {'ramdisk':
                         ['instance_ramdisk_uuid',
                          '/tftpboot/instance_uuid_123/ramdisk'],
                         'kernel':
                         ['instance_kernel_uuid',
                          '/tftpboot/instance_uuid_123/kernel'],
                         'deploy_ramdisk':
                         ['deploy_ramdisk_uuid',
                           '/tftpboot/instance_uuid_123/deploy_ramdisk'],
                         'deploy_kernel':
                         ['deploy_kernel_uuid',
                          '/tftpboot/instance_uuid_123/deploy_kernel']}
        with mock.patch.object(base_image_service.BaseImageService, '_show') \
                as show_mock:
            show_mock.return_value = properties
            image_info = pxe._get_tftp_image_info(self.node)
            show_mock.assert_called_once_with('glance://image_uuid',
                                               method='get')
            self.assertEqual(image_info, expected_info)
Exemple #10
0
    def test__get_tftp_image_info(self):
        properties = {'properties': {u'kernel_id': u'instance_kernel_uuid',
                     u'ramdisk_id': u'instance_ramdisk_uuid'}}

        expected_info = {'ramdisk':
                         ['instance_ramdisk_uuid',
                          '/tftpboot/instance_uuid_123/ramdisk'],
                         'kernel':
                         ['instance_kernel_uuid',
                          '/tftpboot/instance_uuid_123/kernel'],
                         'deploy_ramdisk':
                         ['deploy_ramdisk_uuid',
                           '/tftpboot/instance_uuid_123/deploy_ramdisk'],
                         'deploy_kernel':
                         ['deploy_kernel_uuid',
                          '/tftpboot/instance_uuid_123/deploy_kernel']}
        self.mox.StubOutWithMock(base_image_service.BaseImageService, '_show')
        base_image_service.BaseImageService._show(
            'glance://image_uuid',
            method='get').AndReturn(properties)
        self.mox.ReplayAll()
        image_info = pxe._get_tftp_image_info(self.node)

        self.assertEqual(image_info, expected_info)
Exemple #11
0
    def tear_down_config(self, master=None):
        temp_dir = tempfile.mkdtemp()
        CONF.set_default('tftp_root', temp_dir, group='pxe')
        CONF.set_default('images_path', temp_dir, group='pxe')

        ports = []
        ports.append(
            self.dbapi.create_port(
                db_utils.get_test_port(
                    id=6,
                    address='aa:bb:cc',
                    uuid='bb43dc0b-03f2-4d2e-ae87-c02d7f33cc53',
                    node_id='123')))

        d_kernel_path = os.path.join(temp_dir,
                                     'instance_uuid_123/deploy_kernel')
        image_info = {'deploy_kernel': ['deploy_kernel_uuid', d_kernel_path]}

        self.mox.StubOutWithMock(pxe, '_get_tftp_image_info')
        pxe._get_tftp_image_info(self.node).AndReturn(image_info)
        self.mox.ReplayAll()

        pxecfg_dir = os.path.join(temp_dir, 'pxelinux.cfg')
        os.makedirs(pxecfg_dir)

        instance_dir = os.path.join(temp_dir, 'instance_uuid_123')
        image_dir = os.path.join(temp_dir, 'fake_instance_name')
        os.makedirs(instance_dir)
        os.makedirs(image_dir)
        config_path = os.path.join(instance_dir, 'config')
        deploy_kernel_path = os.path.join(instance_dir, 'deploy_kernel')
        pxe_mac_path = os.path.join(pxecfg_dir, '01-aa-bb-cc')
        image_path = os.path.join(image_dir, 'disk')
        open(config_path, 'w').close()
        os.link(config_path, pxe_mac_path)
        if master:
            tftp_master_dir = os.path.join(temp_dir, 'tftp_master')
            instance_master_dir = os.path.join(temp_dir, 'instance_master')
            CONF.set_default('tftp_master_path', tftp_master_dir, group='pxe')
            CONF.set_default('instance_master_path', instance_master_dir,
                             group='pxe')
            os.makedirs(tftp_master_dir)
            os.makedirs(instance_master_dir)
            master_deploy_kernel_path = os.path.join(tftp_master_dir,
                                                     'deploy_kernel_uuid')
            master_instance_path = os.path.join(instance_master_dir,
                                                'image_uuid')
            open(master_deploy_kernel_path, 'w').close()
            open(master_instance_path, 'w').close()

            os.link(master_deploy_kernel_path, deploy_kernel_path)
            os.link(master_instance_path, image_path)
            if master == 'in_use':
                deploy_kernel_link = os.path.join(temp_dir,
                                                  'deploy_kernel_link')
                image_link = os.path.join(temp_dir, 'image_link')
                os.link(master_deploy_kernel_path, deploy_kernel_link)
                os.link(master_instance_path, image_link)

        else:
            CONF.set_default('tftp_master_path', '', group='pxe')
            CONF.set_default('instance_master_path', '', group='pxe')
            open(deploy_kernel_path, 'w').close()
            open(image_path, 'w').close()

        with task_manager.acquire([self.node['uuid']], shared=False) as task:
            task.resources[0].driver.deploy.tear_down(task, self.node)
        self.mox.VerifyAll()
        assert_false_path = [config_path, deploy_kernel_path, image_path,
                                 pxe_mac_path, image_dir, instance_dir]
        for path in assert_false_path:
            self.assertFalse(os.path.exists(path))

        return temp_dir