Ejemplo n.º 1
0
 def test_config_with_name_user_format_only(self):
     with self.assertRaises(ImageConfigError):
         ImageConfig(**{
             'name': 'foo',
             'image_user': '******',
             'format': 'qcow2'
         })
Ejemplo n.º 2
0
    def test_create_same_image_new_settings(self):
        """
        Tests the creation of an OpenStack image when the image already exists
        and the configuration only contains the name.
        """
        # Create Image
        self.image_creator = create_image.OpenStackImage(self.os_creds,
                                                         self.image_settings)
        image1 = self.image_creator.create()

        retrieved_image = glance_utils.get_image(
            self.glance, image_settings=self.image_settings)
        self.assertIsNotNone(retrieved_image)
        self.assertEqual(self.image_creator.get_image().size,
                         retrieved_image.size)
        self.assertEqual(get_image_size(self.image_settings),
                         retrieved_image.size)
        self.assertEqual(image1.name, retrieved_image.name)
        self.assertEqual(image1.id, retrieved_image.id)
        self.assertEqual(image1.properties, retrieved_image.properties)

        # Should be retrieving the instance data
        image_2_settings = ImageConfig(name=self.image_settings.name,
                                       image_user='******', exists=True)
        os_image_2 = create_image.OpenStackImage(self.os_creds,
                                                 image_2_settings)
        image2 = os_image_2.create()
        self.assertEqual(image1.id, image2.id)
Ejemplo n.º 3
0
    def prepare(self):
        """Prepare testscase (Additional pre-configuration steps)."""
        super(CloudifyIms, self).prepare()

        self.__logger.info("Additional pre-configuration steps")

        compute_quotas = self.os_project.get_compute_quotas()
        network_quotas = self.os_project.get_network_quotas()

        for key, value in (self.vnf['requirements']['compute_quotas'].items()):
            setattr(compute_quotas, key, value)

        for key, value in (self.vnf['requirements']['network_quotas'].items()):
            setattr(network_quotas, key, value)

        compute_quotas = self.os_project.update_compute_quotas(compute_quotas)
        network_quotas = self.os_project.update_network_quotas(network_quotas)

        # needs some images
        self.__logger.info("Upload some OS images if it doesn't exist")
        for image_name, image_file in self.images.iteritems():
            self.__logger.info("image: %s, file: %s", image_name, image_file)
            if image_file and image_name:
                image_creator = OpenStackImage(
                    self.snaps_creds,
                    ImageConfig(name=image_name,
                                image_user='******',
                                img_format='qcow2',
                                image_file=image_file))
                image_creator.create()
Ejemplo n.º 4
0
 def test_name_user_format_url_only(self):
     settings = ImageConfig(name='foo',
                            image_user='******',
                            img_format='qcow2',
                            url='http://foo.com')
     self.assertEqual('foo', settings.name)
     self.assertEqual('bar', settings.image_user)
     self.assertEqual('qcow2', settings.format)
     self.assertEqual('http://foo.com', settings.url)
     self.assertIsNone(settings.image_file)
     self.assertFalse(settings.exists)
     self.assertFalse(settings.public)
     self.assertIsNone(settings.nic_config_pb_loc)
Ejemplo n.º 5
0
 def test_all_url(self):
     properties = {'hw_video_model': 'vga'}
     kernel_settings = ImageConfig(name='kernel',
                                   url='http://kernel.com',
                                   image_user='******',
                                   img_format='qcow2')
     ramdisk_settings = ImageConfig(name='ramdisk',
                                    url='http://ramdisk.com',
                                    image_user='******',
                                    img_format='qcow2')
     settings = ImageConfig(name='foo',
                            image_user='******',
                            img_format='qcow2',
                            url='http://foo.com',
                            extra_properties=properties,
                            nic_config_pb_loc='/foo/bar',
                            kernel_image_settings=kernel_settings,
                            ramdisk_image_settings=ramdisk_settings,
                            exists=True,
                            public=True)
     self.assertEqual('foo', settings.name)
     self.assertEqual('bar', settings.image_user)
     self.assertEqual('qcow2', settings.format)
     self.assertEqual('http://foo.com', settings.url)
     self.assertEqual(properties, settings.extra_properties)
     self.assertIsNone(settings.image_file)
     self.assertEqual('/foo/bar', settings.nic_config_pb_loc)
     self.assertEqual('kernel', settings.kernel_image_settings.name)
     self.assertEqual('http://kernel.com',
                      settings.kernel_image_settings.url)
     self.assertEqual('bar', settings.kernel_image_settings.image_user)
     self.assertEqual('qcow2', settings.kernel_image_settings.format)
     self.assertEqual('ramdisk', settings.ramdisk_image_settings.name)
     self.assertEqual('http://ramdisk.com',
                      settings.ramdisk_image_settings.url)
     self.assertEqual('bar', settings.ramdisk_image_settings.image_user)
     self.assertEqual('qcow2', settings.ramdisk_image_settings.format)
     self.assertTrue(settings.exists)
     self.assertTrue(settings.public)
Ejemplo n.º 6
0
 def prepare_images(self):
     """Upload images if they doen't exist yet"""
     self.logger.info("Upload images if they doen't exist yet")
     for image_name, image_file in self.images.iteritems():
         self.logger.info("image: %s, file: %s", image_name, image_file)
         if image_file and image_name:
             image = OpenStackImage(
                 self.snaps_creds,
                 ImageConfig(name=image_name,
                             image_user='******',
                             img_format='qcow2',
                             image_file=image_file,
                             public=True))
             image.create()
Ejemplo n.º 7
0
 def test_bad_image_file(self):
     """
     Expect an ImageCreationError when the image file does not exist
     """
     os_image_settings = openstack_tests.cirros_image_settings(
         name=self.image_name)
     self.image_creator = create_image.OpenStackImage(
         self.os_creds,
         ImageConfig(
             name=os_image_settings.name,
             image_user=os_image_settings.image_user,
             img_format=os_image_settings.format, image_file="/foo/bar.qcow"))
     with self.assertRaises(IOError):
         self.image_creator.create()
Ejemplo n.º 8
0
    def test_bad_image_image_type(self):
        """
        Expect an ImageCreationError when the image type bad
        """
        os_image_settings = openstack_tests.cirros_image_settings(
            name=self.image_name)
        self.image_creator = create_image.OpenStackImage(
            self.os_creds,
            ImageConfig(
                name=os_image_settings.name,
                image_user=os_image_settings.image_user,
                img_format='foo', url=os_image_settings.url))

        with self.assertRaises(Exception):
            self.image_creator.create()
Ejemplo n.º 9
0
    def test_bad_image_name(self):
        """
        Expect an ImageCreationError when the image name does not exist when a
        file or URL has not been configured
        """
        os_image_settings = ImageConfig(name='foo', image_user='******',
                                        exists=True)
        self.image_creator = create_image.OpenStackImage(self.os_creds,
                                                         os_image_settings)

        with self.assertRaises(ImageCreationError):
            self.image_creator.create()

            self.fail('ImageCreationError should have been raised prior to'
                      'this line')
Ejemplo n.º 10
0
    def register_glance_image(self, name, url, img_format, public):
        logger.info("Registering the image...")
        # Check whether the image is local or not
        if 'http' in url:
            image_settings = ImageConfig(name=name,
                                         img_format=img_format,
                                         url=url,
                                         public=public,
                                         image_user='******')
        else:
            image_settings = ImageConfig(name=name,
                                         img_format=img_format,
                                         image_file=url,
                                         public=public,
                                         image_user='******')

        # TODO Remove this when tacker is part of SNAPS
        self.image_settings = image_settings

        image_creator = OpenStackImage(self.os_creds, image_settings)
        image_creator.create()

        self.creators.append(image_creator)
        return image_creator
Ejemplo n.º 11
0
 def prepare(self):
     super(CloudifyVrouter, self).prepare()
     self.__logger.info("Additional pre-configuration steps")
     self.util.set_credentials(self.snaps_creds)
     self.__logger.info("Upload some OS images if it doesn't exist")
     for image_name, image_file in self.images.iteritems():
         self.__logger.info("image: %s, file: %s", image_name, image_file)
         if image_file and image_name:
             image_creator = OpenStackImage(
                 self.snaps_creds,
                 ImageConfig(name=image_name,
                             image_user='******',
                             img_format='qcow2',
                             image_file=image_file))
             image_creator.create()
             self.created_object.append(image_creator)
Ejemplo n.º 12
0
 def test_config_with_name_user_format_file_only(self):
     settings = ImageConfig(
         **{
             'name': 'foo',
             'image_user': '******',
             'format': 'qcow2',
             'image_file': '/foo/bar.qcow'
         })
     self.assertEqual('foo', settings.name)
     self.assertEqual('bar', settings.image_user)
     self.assertEqual('qcow2', settings.format)
     self.assertIsNone(settings.url)
     self.assertEqual('/foo/bar.qcow', settings.image_file)
     self.assertFalse(settings.exists)
     self.assertFalse(settings.public)
     self.assertIsNone(settings.nic_config_pb_loc)
Ejemplo n.º 13
0
 def test_config_with_name_user_format_url_only(self):
     settings = ImageConfig(
         **{
             'name': 'foo',
             'image_user': '******',
             'format': 'qcow2',
             'download_url': 'http://foo.com'
         })
     self.assertEqual('foo', settings.name)
     self.assertEqual('bar', settings.image_user)
     self.assertEqual('qcow2', settings.format)
     self.assertEqual('http://foo.com', settings.url)
     self.assertIsNone(settings.image_file)
     self.assertFalse(settings.exists)
     self.assertFalse(settings.public)
     self.assertIsNone(settings.nic_config_pb_loc)
Ejemplo n.º 14
0
 def test_name_user_format_url_only_properties(self):
     properties = {'hw_video_model': 'vga'}
     settings = ImageConfig(name='foo',
                            image_user='******',
                            img_format='qcow2',
                            url='http://foo.com',
                            extra_properties=properties)
     self.assertEqual('foo', settings.name)
     self.assertEqual('bar', settings.image_user)
     self.assertEqual('qcow2', settings.format)
     self.assertEqual('http://foo.com', settings.url)
     self.assertEqual(properties, settings.extra_properties)
     self.assertIsNone(settings.image_file)
     self.assertFalse(settings.exists)
     self.assertFalse(settings.public)
     self.assertIsNone(settings.nic_config_pb_loc)
Ejemplo n.º 15
0
 def test_all_file(self):
     properties = {'hw_video_model': 'vga'}
     settings = ImageConfig(name='foo',
                            image_user='******',
                            img_format='qcow2',
                            image_file='/foo/bar.qcow',
                            extra_properties=properties,
                            nic_config_pb_loc='/foo/bar',
                            exists=True,
                            public=True)
     self.assertEqual('foo', settings.name)
     self.assertEqual('bar', settings.image_user)
     self.assertEqual('qcow2', settings.format)
     self.assertIsNone(settings.url)
     self.assertEqual('/foo/bar.qcow', settings.image_file)
     self.assertEqual(properties, settings.extra_properties)
     self.assertEqual('/foo/bar', settings.nic_config_pb_loc)
     self.assertTrue(settings.exists)
     self.assertTrue(settings.public)
Ejemplo n.º 16
0
 def test_config_all_url(self):
     settings = ImageConfig(
         **{
             'name': 'foo',
             'image_user': '******',
             'format': 'qcow2',
             'download_url': 'http://foo.com',
             'extra_properties': '{\'hw_video_model\': \'vga\'}',
             'nic_config_pb_loc': '/foo/bar',
             'kernel_image_settings': {
                 'name': 'kernel',
                 'download_url': 'http://kernel.com',
                 'image_user': '******',
                 'format': 'qcow2'
             },
             'ramdisk_image_settings': {
                 'name': 'ramdisk',
                 'download_url': 'http://ramdisk.com',
                 'image_user': '******',
                 'format': 'qcow2'
             },
             'exists': True,
             'public': True
         })
     self.assertEqual('foo', settings.name)
     self.assertEqual('bar', settings.image_user)
     self.assertEqual('qcow2', settings.format)
     self.assertEqual('http://foo.com', settings.url)
     self.assertEqual('{\'hw_video_model\': \'vga\'}',
                      settings.extra_properties)
     self.assertIsNone(settings.image_file)
     self.assertEqual('/foo/bar', settings.nic_config_pb_loc)
     self.assertEqual('kernel', settings.kernel_image_settings.name)
     self.assertEqual('http://kernel.com',
                      settings.kernel_image_settings.url)
     self.assertEqual('ramdisk', settings.ramdisk_image_settings.name)
     self.assertEqual('http://ramdisk.com',
                      settings.ramdisk_image_settings.url)
     self.assertTrue(settings.exists)
     self.assertTrue(settings.public)
Ejemplo n.º 17
0
 def test_config_all_file(self):
     settings = ImageConfig(
         **{
             'name': 'foo',
             'image_user': '******',
             'format': 'qcow2',
             'image_file': '/foo/bar.qcow',
             'extra_properties': '{\'hw_video_model\' : \'vga\'}',
             'nic_config_pb_loc': '/foo/bar',
             'exists': True,
             'public': True
         })
     self.assertEqual('foo', settings.name)
     self.assertEqual('bar', settings.image_user)
     self.assertEqual('qcow2', settings.format)
     self.assertIsNone(settings.url)
     self.assertEqual('/foo/bar.qcow', settings.image_file)
     self.assertEqual('{\'hw_video_model\' : \'vga\'}',
                      settings.extra_properties)
     self.assertEqual('/foo/bar', settings.nic_config_pb_loc)
     self.assertTrue(settings.exists)
     self.assertTrue(settings.public)
Ejemplo n.º 18
0
    def test_bad_image_url(self):
        """
        Expect an ImageCreationError when the image download url is bad
        """
        os_image_settings = openstack_tests.cirros_image_settings(
            name=self.image_name)
        self.image_creator = create_image.OpenStackImage(
            self.os_creds,
            ImageConfig(
                name=os_image_settings.name,
                image_user=os_image_settings.image_user,
                img_format=os_image_settings.format,
                url="http://foo.bar"))

        try:
            self.image_creator.create()
        except HTTPBadRequest:
            pass
        except URLError:
            pass
        except Exception as e:
            self.fail('Invalid Exception ' + str(e))
Ejemplo n.º 19
0
 def test_empty_config(self):
     with self.assertRaises(ImageConfigError):
         ImageConfig(**dict())
Ejemplo n.º 20
0
 def test_name_user_format_only(self):
     with self.assertRaises(ImageConfigError):
         ImageConfig(name='foo', image_user='******', img_format='qcow2')
Ejemplo n.º 21
0
    def deploy_orchestrator(self):  # pylint: disable=too-many-locals
        """
        Create network, subnet, router

        Bootstrap juju
        """
        self.__logger.info("Deployed Orchestrator")
        private_net_name = getattr(
            config.CONF, 'vnf_{}_private_net_name'.format(self.case_name))
        private_subnet_name = '{}-{}'.format(
            getattr(config.CONF,
                    'vnf_{}_private_subnet_name'.format(self.case_name)),
            self.uuid)
        private_subnet_cidr = getattr(
            config.CONF, 'vnf_{}_private_subnet_cidr'.format(self.case_name))
        abot_router = '{}-{}'.format(
            getattr(config.CONF,
                    'vnf_{}_external_router'.format(self.case_name)),
            self.uuid)
        self.__logger.info("Creating full network ...")
        subnet_settings = SubnetConfig(name=private_subnet_name,
                                       cidr=private_subnet_cidr,
                                       dns_nameservers=[env.get('NAMESERVER')])
        network_settings = NetworkConfig(name=private_net_name,
                                         subnet_settings=[subnet_settings])
        network_creator = OpenStackNetwork(self.snaps_creds, network_settings)
        net_id = network_creator.create().id
        self.created_object.append(network_creator)

        ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds)
        self.__logger.info("Creating network Router ....")
        router_creator = OpenStackRouter(
            self.snaps_creds,
            RouterConfig(name=abot_router,
                         external_gateway=ext_net_name,
                         internal_subnets=[subnet_settings.name]))
        router_creator.create()
        self.created_object.append(router_creator)
        self.__logger.info("Creating Flavor ....")
        flavor_settings = FlavorConfig(
            name=self.orchestrator['requirements']['flavor']['name'],
            ram=self.orchestrator['requirements']['flavor']['ram_min'],
            disk=10,
            vcpus=1)
        flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
        flavor_creator.create()
        self.created_object.append(flavor_creator)
        self.__logger.info("Upload some OS images if it doesn't exist")
        images = get_config("tenant_images", self.config_file)
        self.__logger.info("Images needed for vEPC: %s", images)
        for image_name, image_file in images.iteritems():
            self.__logger.info("image: %s, file: %s", image_name, image_file)
            if image_file and image_name:
                image_creator = OpenStackImage(
                    self.snaps_creds,
                    ImageConfig(name=image_name,
                                image_user='******',
                                img_format='qcow2',
                                image_file=image_file))
                image_id = image_creator.create().id
                cmd = [
                    'timeout', '-t', JujuEpc.juju_timeout, 'juju', 'metadata',
                    'generate-image', '-d', '/root', '-i', image_id, '-s',
                    image_name, '-r', self.snaps_creds.region_name, '-u',
                    self.public_auth_url
                ]
                output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
                self.__logger.info("%s\n%s", " ".join(cmd), output)
                self.created_object.append(image_creator)
        self.__logger.info("Network ID  : %s", net_id)
        cmd = [
            'timeout', '-t', JujuEpc.juju_timeout, 'juju', 'bootstrap',
            'abot-epc', 'abot-controller', '--metadata-source', '/root',
            '--constraints', 'mem=2G', '--bootstrap-series', 'xenial',
            '--config', 'network={}'.format(net_id), '--config',
            'ssl-hostname-verification=false', '--config',
            'use-floating-ip=true', '--config', 'use-default-secgroup=true',
            '--debug'
        ]
        output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
        self.__logger.info("%s\n%s", " ".join(cmd), output)
        return True
Ejemplo n.º 22
0
 def test_config_with_name_only(self):
     with self.assertRaises(ImageConfigError):
         ImageConfig(**{'name': 'foo'})
Ejemplo n.º 23
0
 def test_name_user_only(self):
     with self.assertRaises(ImageConfigError):
         ImageConfig(name='foo', image_user='******')
Ejemplo n.º 24
0
 def test_name_only(self):
     with self.assertRaises(ImageConfigError):
         ImageConfig(name='foo')
Ejemplo n.º 25
0
    def deploy_orchestrator(self):  # pylint: disable=too-many-locals
        """
        Create network, subnet, router

        Bootstrap juju
        """
        self.__logger.info("Deployed Orchestrator")
        private_net_name = getattr(
            CONST, 'vnf_{}_private_net_name'.format(self.case_name))
        private_subnet_name = getattr(
            CONST, 'vnf_{}_private_subnet_name'.format(self.case_name))
        private_subnet_cidr = getattr(
            CONST, 'vnf_{}_private_subnet_cidr'.format(self.case_name))
        abot_router = getattr(
            CONST, 'vnf_{}_external_router'.format(self.case_name))

        self.__logger.info("Creating full network ...")
        subnet_settings = SubnetConfig(
            name=private_subnet_name, cidr=private_subnet_cidr)
        network_settings = NetworkConfig(
            name=private_net_name, subnet_settings=[subnet_settings])
        network_creator = OpenStackNetwork(self.snaps_creds, network_settings)
        net_id = network_creator.create().id
        self.created_object.append(network_creator)

        ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds)
        self.__logger.info("Creating network Router ....")
        router_creator = OpenStackRouter(
            self.snaps_creds, RouterConfig(
                name=abot_router,
                external_gateway=ext_net_name,
                internal_subnets=[subnet_settings.name]))
        router_creator.create()
        self.created_object.append(router_creator)
        self.__logger.info("Creating Flavor ....")
        flavor_settings = FlavorConfig(
            name=self.orchestrator['requirements']['flavor']['name'],
            ram=self.orchestrator['requirements']['flavor']['ram_min'],
            disk=10, vcpus=1)
        flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
        flavor_creator.create()
        self.created_object.append(flavor_creator)
        self.__logger.info("Upload some OS images if it doesn't exist")
        images = get_config("tenant_images", self.config_file)
        self.__logger.info("Images needed for vEPC: %s", images)
        for image_name, image_file in images.iteritems():
            self.__logger.info("image: %s, file: %s", image_name, image_file)
            if image_file and image_name:
                image_creator = OpenStackImage(self.snaps_creds, ImageConfig(
                    name=image_name, image_user='******', img_format='qcow2',
                    image_file=image_file))
                image_id = image_creator.create().id
                os.system(
                    'juju metadata generate-image -d ~ -i {} -s {} -r '
                    '{} -u {}'.format(
                        image_id, image_name,
                        os.environ.get(
                            "OS_REGION_NAME", self.default_region_name),
                        self.public_auth_url))
                self.created_object.append(image_creator)
        self.__logger.info("Credential information  : %s", net_id)
        juju_bootstrap_command = (
            'juju bootstrap abot-epc abot-controller --config network={} '
            '--metadata-source ~  --config ssl-hostname-verification=false '
            '--constraints mem=2G --bootstrap-series xenial '
            '--config use-floating-ip=true --debug '
            '--config use-default-secgroup=true'.format(net_id))
        os.system(juju_bootstrap_command)
        return True
Ejemplo n.º 26
0
    def _prepare_env(self):
        """Create resources needed by test scenarios."""
        LOGGER.debug('Validating the test name...')
        if self.test_name not in self.TESTS:
            raise Exception("Test name '%s' is invalid" % self.test_name)

        network_name = self.RALLY_PRIVATE_NET_NAME + self.guid
        subnet_name = self.RALLY_PRIVATE_SUBNET_NAME + self.guid
        router_name = self.RALLY_ROUTER_NAME + self.guid
        self.image_name = self.GLANCE_IMAGE_NAME + self.guid
        self.flavor_name = self.FLAVOR_NAME + self.guid
        self.flavor_alt_name = self.FLAVOR_ALT_NAME + self.guid
        self.ext_net_name = snaps_utils.get_ext_net_name(self.os_creds)
        self.compute_cnt = snaps_utils.get_active_compute_cnt(self.os_creds)

        LOGGER.debug("Creating image '%s'...", self.image_name)
        image_creator = deploy_utils.create_image(
            self.os_creds, ImageConfig(
                name=self.image_name,
                image_file=self.GLANCE_IMAGE_PATH,
                img_format=self.GLANCE_IMAGE_FORMAT,
                image_user=self.GLANCE_IMAGE_USERNAME,
                public=True,
                extra_properties=self.GLANCE_IMAGE_EXTRA_PROPERTIES))
        if image_creator is None:
            raise Exception("Failed to create image")
        self.creators.append(image_creator)

        LOGGER.debug("Creating network '%s'...", network_name)

        rally_network_type = None
        rally_physical_network = None
        rally_segmentation_id = None

        if hasattr(CONST, 'rally_network_type'):
            rally_network_type = CONST.__getattribute__(
                'rally_network_type')
        if hasattr(CONST, 'rally_physical_network'):
            rally_physical_network = CONST.__getattribute__(
                'rally_physical_network')
        if hasattr(CONST, 'rally_segmentation_id'):
            rally_segmentation_id = CONST.__getattribute__(
                'rally_segmentation_id')

        network_creator = deploy_utils.create_network(
            self.os_creds, NetworkConfig(
                name=network_name,
                shared=True,
                network_type=rally_network_type,
                physical_network=rally_physical_network,
                segmentation_id=rally_segmentation_id,
                subnet_settings=[SubnetConfig(
                    name=subnet_name,
                    cidr=self.RALLY_PRIVATE_SUBNET_CIDR)]))
        if network_creator is None:
            raise Exception("Failed to create private network")
        self.priv_net_id = network_creator.get_network().id
        self.creators.append(network_creator)

        LOGGER.debug("Creating router '%s'...", router_name)
        router_creator = deploy_utils.create_router(
            self.os_creds, RouterConfig(
                name=router_name,
                external_gateway=self.ext_net_name,
                internal_subnets=[subnet_name]))
        if router_creator is None:
            raise Exception("Failed to create router")
        self.creators.append(router_creator)

        LOGGER.debug("Creating flavor '%s'...", self.flavor_name)
        flavor_creator = OpenStackFlavor(
            self.os_creds, FlavorConfig(
                name=self.flavor_name, ram=self.FLAVOR_RAM, disk=1, vcpus=1,
                metadata=self.FLAVOR_EXTRA_SPECS))
        if flavor_creator is None or flavor_creator.create() is None:
            raise Exception("Failed to create flavor")
        self.creators.append(flavor_creator)

        LOGGER.debug("Creating flavor '%s'...", self.flavor_alt_name)
        flavor_alt_creator = OpenStackFlavor(
            self.os_creds, FlavorConfig(
                name=self.flavor_alt_name, ram=self.FLAVOR_RAM_ALT, disk=1,
                vcpus=1, metadata=self.FLAVOR_EXTRA_SPECS))
        if flavor_alt_creator is None or flavor_alt_creator.create() is None:
            raise Exception("Failed to create flavor")
        self.creators.append(flavor_alt_creator)
Ejemplo n.º 27
0
 def test_no_params(self):
     with self.assertRaises(ImageConfigError):
         ImageConfig()
Ejemplo n.º 28
0
    def deploy_orchestrator(self):
        self.logger.info("Deploying Open Baton...")
        self.logger.info("Details: %s", self.mano['details'])
        start_time = time.time()

        self.logger.info("Creating orchestra instance...")
        userdata = get_userdata(self.mano)
        self.logger.info("flavor: %s\n"
                         "image: %s\n"
                         "network_id: %s\n",
                         self.mano['details']['flavor']['name'],
                         self.mano['requirements']['image'],
                         self.mano['details']['network']['id'])
        self.logger.debug("userdata: %s\n", userdata)
        # setting up image
        image_settings = ImageConfig(name=self.mano['requirements']['image'],
                                     image_user='******',
                                     exists=True)
        # setting up port
        port_settings = PortConfig(
            name='%s_port' % self.case_name,
            network_name=self.mano['details']['network']['name'])
        # build configuration of vm
        orchestra_settings = VmInstanceConfig(
            name=self.case_name,
            flavor=self.mano['details']['flavor']['name'],
            port_settings=[port_settings],
            security_group_names=[self.mano['details']['sec_group']],
            userdata=str(userdata))
        orchestra_vm = OpenStackVmInstance(self.snaps_creds,
                                           orchestra_settings, image_settings)

        orchestra_vm.create()
        self.created_resources.append(orchestra_vm)
        self.mano['details']['id'] = orchestra_vm.get_vm_info()['id']
        self.logger.info("Created orchestra instance: %s",
                         self.mano['details']['id'])

        self.logger.info("Associating floating ip: '%s' to VM '%s' ",
                         self.mano['details']['fip'].ip, self.case_name)
        nova_client = os_utils.get_nova_client()
        if not os_utils.add_floating_ip(nova_client,
                                        self.mano['details']['id'],
                                        self.mano['details']['fip'].ip):
            duration = time.time() - start_time
            self.details["orchestrator"].update(status='FAIL',
                                                duration=duration)
            self.logger.error("Cannot associate floating IP to VM.")
            return False

        self.logger.info("Waiting for Open Baton NFVO to be up and running...")
        timeout = 0
        while timeout < 20:
            if servertest(self.mano['details']['fip'].ip, "8080"):
                break
            else:
                self.logger.info("Open Baton NFVO is not started yet (%ss)",
                                 (timeout * 60))
                time.sleep(60)
                timeout += 1

        if timeout >= 20:
            duration = time.time() - start_time
            self.details["orchestrator"].update(status='FAIL',
                                                duration=duration)
            self.logger.error("Open Baton is not started correctly")
            return False

        self.logger.info("Waiting for all components to be up and running...")
        time.sleep(60)
        duration = time.time() - start_time
        self.details["orchestrator"].update(status='PASS', duration=duration)
        self.logger.info("Deploy Open Baton NFVO: OK")
        return True
Ejemplo n.º 29
0
    def test_vnf(self):
        """Run IXIA Stress test on clearwater ims instance."""
        start_time = time.time()

        cfy_client = self.orchestrator['object']

        outputs = cfy_client.deployments.outputs.get(
            self.vnf['descriptor'].get('name'))['outputs']
        dns_ip = outputs['dns_ip']
        ellis_ip = outputs['ellis_ip']

        self.__logger.info("Creating full IXIA network ...")
        subnet_settings = SubnetConfig(name='ixia_management_subnet',
                                       cidr='10.10.10.0/24',
                                       dns_nameservers=[env.get('NAMESERVER')])
        network_settings = NetworkConfig(name='ixia_management_network',
                                         subnet_settings=[subnet_settings])
        network_creator = OpenStackNetwork(self.snaps_creds, network_settings)
        network_creator.create()
        self.created_object.append(network_creator)
        ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds)
        router_creator = OpenStackRouter(
            self.snaps_creds,
            RouterConfig(name='ixia_management_router',
                         external_gateway=ext_net_name,
                         internal_subnets=[subnet_settings.name]))
        router_creator.create()
        self.created_object.append(router_creator)

        # security group creation
        self.__logger.info("Creating security groups for IXIA VMs")
        sg_rules = list()
        sg_rules.append(
            SecurityGroupRuleConfig(sec_grp_name="ixia_management",
                                    direction=Direction.ingress,
                                    protocol=Protocol.tcp,
                                    port_range_min=1,
                                    port_range_max=65535))
        sg_rules.append(
            SecurityGroupRuleConfig(sec_grp_name="ixia_management",
                                    direction=Direction.ingress,
                                    protocol=Protocol.udp,
                                    port_range_min=1,
                                    port_range_max=65535))
        sg_rules.append(
            SecurityGroupRuleConfig(sec_grp_name="ixia_management",
                                    direction=Direction.ingress,
                                    protocol=Protocol.icmp))

        ixia_managment_sg_settings = SecurityGroupConfig(
            name="ixia_management", rule_settings=sg_rules)
        securit_group_creator = OpenStackSecurityGroup(
            self.snaps_creds, ixia_managment_sg_settings)

        securit_group_creator.create()
        self.created_object.append(securit_group_creator)

        sg_rules = list()
        sg_rules.append(
            SecurityGroupRuleConfig(sec_grp_name="ixia_ssh_http",
                                    direction=Direction.ingress,
                                    protocol=Protocol.tcp,
                                    port_range_min=1,
                                    port_range_max=65535))

        ixia_ssh_http_sg_settings = SecurityGroupConfig(name="ixia_ssh_http",
                                                        rule_settings=sg_rules)
        securit_group_creator = OpenStackSecurityGroup(
            self.snaps_creds, ixia_ssh_http_sg_settings)

        securit_group_creator.create()
        self.created_object.append(securit_group_creator)

        chassis_flavor_settings = FlavorConfig(name="ixia_vChassis",
                                               ram=4096,
                                               disk=40,
                                               vcpus=2)
        flavor_creator = OpenStackFlavor(self.snaps_creds,
                                         chassis_flavor_settings)
        flavor_creator.create()
        self.created_object.append(flavor_creator)

        card_flavor_settings = FlavorConfig(name="ixia_vCard",
                                            ram=4096,
                                            disk=4,
                                            vcpus=2)
        flavor_creator = OpenStackFlavor(self.snaps_creds,
                                         card_flavor_settings)
        flavor_creator.create()
        self.created_object.append(flavor_creator)

        load_flavor_settings = FlavorConfig(name="ixia_vLoad",
                                            ram=8192,
                                            disk=100,
                                            vcpus=4)
        flavor_creator = OpenStackFlavor(self.snaps_creds,
                                         load_flavor_settings)
        flavor_creator.create()
        self.created_object.append(flavor_creator)

        chassis_image_settings = ImageConfig(
            name=self.test['requirements']['chassis']['image'],
            image_user='******',
            exists=True)

        card_image_settings = ImageConfig(
            name=self.test['requirements']['card']['image'],
            image_user='******',
            exists=True)

        load_image_settings = ImageConfig(
            name=self.test['requirements']['load']['image'],
            image_user='******',
            exists=True)

        chassis_port_settings = PortConfig(name='ixia_chassis_port',
                                           network_name=network_settings.name)

        card1_port1_settings = PortConfig(name='ixia_card1_port1',
                                          network_name=network_settings.name)

        card2_port1_settings = PortConfig(name='ixia_card2_port1',
                                          network_name=network_settings.name)

        card1_port2_settings = PortConfig(name='ixia_card1_port2',
                                          network_name="cloudify_ims_network")

        card2_port2_settings = PortConfig(name='ixia_card2_port2',
                                          network_name="cloudify_ims_network")

        load_port_settings = PortConfig(name='ixia_load_port',
                                        network_name=network_settings.name)

        chassis_settings = VmInstanceConfig(
            name='ixia_vChassis',
            flavor=chassis_flavor_settings.name,
            port_settings=[chassis_port_settings],
            security_group_names=[
                ixia_ssh_http_sg_settings.name, ixia_managment_sg_settings.name
            ],
            floating_ip_settings=[
                FloatingIpConfig(
                    name='ixia_vChassis_fip',
                    port_name=chassis_port_settings.name,
                    router_name=router_creator.router_settings.name)
            ])

        vm_creator = OpenStackVmInstance(self.snaps_creds, chassis_settings,
                                         chassis_image_settings)

        self.__logger.info("Creating Ixia vChassis VM")
        vm_creator.create()
        fip_chassis = vm_creator.get_floating_ip().ip
        self.created_object.append(vm_creator)

        card1_settings = VmInstanceConfig(
            name='ixia_vCard1',
            flavor=card_flavor_settings.name,
            port_settings=[card1_port1_settings, card1_port2_settings],
            security_group_names=[ixia_managment_sg_settings.name])

        vm_creator = OpenStackVmInstance(self.snaps_creds, card1_settings,
                                         card_image_settings)

        self.__logger.info("Creating Ixia vCard1 VM")
        vm_creator.create()
        vcard_ips = list()
        vcard_ips_p2 = list()
        vcard_ips.append(vm_creator.get_port_ip('ixia_card1_port1'))
        vcard_ips_p2.append(vm_creator.get_port_ip('ixia_card1_port2'))
        self.created_object.append(vm_creator)

        card2_settings = VmInstanceConfig(
            name='ixia_vCard2',
            flavor=card_flavor_settings.name,
            port_settings=[card2_port1_settings, card2_port2_settings],
            security_group_names=[ixia_managment_sg_settings.name])

        vm_creator = OpenStackVmInstance(self.snaps_creds, card2_settings,
                                         card_image_settings)

        self.__logger.info("Creating Ixia vCard2 VM")
        vm_creator.create()
        vcard_ips.append(vm_creator.get_port_ip('ixia_card2_port1'))
        vcard_ips_p2.append(vm_creator.get_port_ip('ixia_card2_port2'))
        self.created_object.append(vm_creator)

        load_settings = VmInstanceConfig(
            name='ixia_vLoad',
            flavor=load_flavor_settings.name,
            port_settings=[load_port_settings],
            security_group_names=[
                ixia_ssh_http_sg_settings.name, ixia_managment_sg_settings.name
            ],
            floating_ip_settings=[
                FloatingIpConfig(
                    name='ixia_vLoad_fip',
                    port_name=load_port_settings.name,
                    router_name=router_creator.router_settings.name)
            ])

        vm_creator = OpenStackVmInstance(self.snaps_creds, load_settings,
                                         load_image_settings)

        self.__logger.info("Creating Ixia vLoad VM")
        vm_creator.create()
        fip_load = vm_creator.get_floating_ip().ip
        self.created_object.append(vm_creator)

        self.__logger.info("Chassis IP is: %s", fip_chassis)
        login_url = "https://" + str(fip_chassis) + "/api/v1/auth/session"
        cards_url = "https://" + str(fip_chassis) + "/api/v2/ixos/cards/"

        payload = json.dumps({
            "username": "******",
            "password": "******",
            "rememberMe": "false"
        })
        api_key = json.loads(
            (IxChassisUtils.ChassisRestAPI.postWithPayload(login_url,
                                                           payload)))["apiKey"]

        self.__logger.info("Adding 2 card back inside the ixia chassis...")

        for ip in vcard_ips:
            payload = {"ipAddress": str(ip)}
            response = json.loads(
                IxChassisUtils.ChassisRestAPI.postOperation(
                    cards_url, api_key, payload))
            count = 0
            while (int(
                    IxChassisUtils.ChassisRestAPI.getWithHeaders(
                        response['url'], api_key)['progress']) != 100):
                self.__logger.debug("Operation did not finish yet. \
                                    Waiting for 1 more second..")
                time.sleep(1)
                if count > 60:
                    raise Exception("Adding card take more than 60 seconds")
                count += 1

        ssh = paramiko.SSHClient()
        ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy())
        ssh.connect(fip_chassis, username="******", password="******")
        cmd = "set license-check disable"
        run_blocking_ssh_command(ssh, cmd)
        cmd = "restart-service ixServer"
        run_blocking_ssh_command(ssh, cmd)

        self.config_ellis(ellis_ip)

        # Get IPs of P-CSCF
        resolver = dns.resolver.Resolver()
        resolver.nameservers = [dns_ip]
        result = resolver.query("bono.clearwater.local")

        iplistims = ''
        i = 0
        for rdata in result:
            i = i + 1
            print rdata.address
            iplistims += str(rdata.address)
            if i != len(result):
                iplistims += ';'

        kResourcesUrl = 'http://%s:%s/api/v0/resources' % (fip_load, 8080)

        kRxfPath = r"REG_CALL_OPNFV_v13.rxf"
        test_filname = self.test['inputs']['test_filname']
        kGatewaySharedFolder = '/mnt/ixload-share/'
        kRxfRelativeUploadPath = 'uploads/%s' % os.path.split(kRxfPath)[1]
        kRxfAbsoluteUploadPath = os.path.join(kGatewaySharedFolder,
                                              kRxfRelativeUploadPath)
        kChassisList = [str(fip_chassis)]
        dataFileNameList = [
            test_filname, 'Registration_only_LPS.tst', 'SIPCall.tst'
        ]

        kPortListPerCommunityCommunity = {
            "VoIP1@VM1": [(1, 1, 1)],
            "VoIP2@VM2": [(1, 2, 1)]
        }

        kStatsToDisplayDict = self.test['inputs']['stats']
        connection = IxRestUtils.getConnection(fip_load, 8080)

        self.__logger.info("Creating a new session...")
        sessionUrl = IxLoadUtils.createSession(connection,
                                               self.test['version'])

        license_server = self.test['inputs']['licenseServer']
        IxLoadUtils.configureLicenseServer(connection, sessionUrl,
                                           license_server)

        files_dir = os.path.join(self.case_dir, 'ixia/files')
        target_file = open(os.path.join(files_dir, test_filname), 'w')
        j2_env = Environment(loader=FileSystemLoader(files_dir),
                             trim_blocks=True)
        self.test['inputs'].update(
            dict(ipchassis=fip_chassis,
                 ipcard1=vcard_ips_p2[0],
                 ipcard2=vcard_ips_p2[1],
                 iplistims=iplistims))

        target_file.write(
            j2_env.get_template(test_filname + '.template').render(
                self.test['inputs']))
        target_file.close()

        self.__logger.info('Uploading files %s...' % kRxfPath)
        for dataFile in dataFileNameList:
            localFilePath = os.path.join(files_dir, dataFile)
            remoteFilePath = os.path.join(kGatewaySharedFolder,
                                          'uploads/%s' % dataFile)
            IxLoadUtils.uploadFile(connection, kResourcesUrl, localFilePath,
                                   remoteFilePath)
        self.__logger.info('Upload file finished.')

        self.__logger.info("Loading repository %s..." % kRxfAbsoluteUploadPath)
        IxLoadUtils.loadRepository(connection, sessionUrl,
                                   kRxfAbsoluteUploadPath)

        self.__logger.info("Clearing chassis list...")
        IxLoadUtils.clearChassisList(connection, sessionUrl)

        self.__logger.info("Adding chassis %s..." % (kChassisList))
        IxLoadUtils.addChassisList(connection, sessionUrl, kChassisList)

        self.__logger.info("Assigning new ports...")
        IxLoadUtils.assignPorts(connection, sessionUrl,
                                kPortListPerCommunityCommunity)

        self.__logger.info("Starting the test...")
        IxLoadUtils.runTest(connection, sessionUrl)

        self.__logger.info("Polling values for stats %s..." %
                           (kStatsToDisplayDict))
        result = IxLoadUtils.pollStats(connection, sessionUrl,
                                       kStatsToDisplayDict)
        self.__logger.info("Test finished.")
        self.__logger.info("Checking test status...")
        testRunError = IxLoadUtils.getTestRunError(connection, sessionUrl)

        self.__logger.info(result)
        duration = time.time() - start_time
        self.details['test_vnf'].update(status='PASS',
                                        result=result,
                                        duration=duration)
        if testRunError:
            self.__logger.info("The test exited with following error: %s" %
                               (testRunError))
            self.details['test_vnf'].update(status='FAIL', duration=duration)
            return False
        else:
            self.__logger.info("The test completed successfully.")
            self.details['test_vnf'].update(status='PASS', duration=duration)
            self.result += 1 / 3 * 100
            return True
Ejemplo n.º 30
0
    def deploy_orchestrator(self):
        """
        Deploy Cloudify Manager.

        network, security group, fip, VM creation
        """
        # network creation

        start_time = time.time()
        self.__logger.info("Creating keypair ...")
        kp_file = os.path.join(self.data_dir, "cloudify_ims.pem")
        keypair_settings = KeypairConfig(name='cloudify_ims_kp',
                                         private_filepath=kp_file)
        keypair_creator = OpenStackKeypair(self.snaps_creds, keypair_settings)
        keypair_creator.create()
        self.created_object.append(keypair_creator)

        self.__logger.info("Creating full network ...")
        subnet_settings = SubnetConfig(name='cloudify_ims_subnet',
                                       cidr='10.67.79.0/24')
        network_settings = NetworkConfig(name='cloudify_ims_network',
                                         subnet_settings=[subnet_settings])
        network_creator = OpenStackNetwork(self.snaps_creds, network_settings)
        network_creator.create()
        self.created_object.append(network_creator)
        ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds)
        router_creator = OpenStackRouter(
            self.snaps_creds,
            RouterConfig(name='cloudify_ims_router',
                         external_gateway=ext_net_name,
                         internal_subnets=[subnet_settings.name]))
        router_creator.create()
        self.created_object.append(router_creator)

        # security group creation
        self.__logger.info("Creating security group for cloudify manager vm")
        sg_rules = list()
        sg_rules.append(
            SecurityGroupRuleConfig(sec_grp_name="sg-cloudify-manager",
                                    direction=Direction.ingress,
                                    protocol=Protocol.tcp,
                                    port_range_min=1,
                                    port_range_max=65535))
        sg_rules.append(
            SecurityGroupRuleConfig(sec_grp_name="sg-cloudify-manager",
                                    direction=Direction.ingress,
                                    protocol=Protocol.udp,
                                    port_range_min=1,
                                    port_range_max=65535))

        securit_group_creator = OpenStackSecurityGroup(
            self.snaps_creds,
            SecurityGroupConfig(name="sg-cloudify-manager",
                                rule_settings=sg_rules))

        securit_group_creator.create()
        self.created_object.append(securit_group_creator)

        # orchestrator VM flavor
        self.__logger.info("Get or create flavor for cloudify manager vm ...")

        flavor_settings = FlavorConfig(
            name=self.orchestrator['requirements']['flavor']['name'],
            ram=self.orchestrator['requirements']['flavor']['ram_min'],
            disk=50,
            vcpus=2)
        flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
        flavor_creator.create()
        self.created_object.append(flavor_creator)
        image_settings = ImageConfig(
            name=self.orchestrator['requirements']['os_image'],
            image_user='******',
            exists=True)

        port_settings = PortConfig(name='cloudify_manager_port',
                                   network_name=network_settings.name)

        manager_settings = VmInstanceConfig(
            name='cloudify_manager',
            flavor=flavor_settings.name,
            port_settings=[port_settings],
            security_group_names=[securit_group_creator.sec_grp_settings.name],
            floating_ip_settings=[
                FloatingIpConfig(
                    name='cloudify_manager_fip',
                    port_name=port_settings.name,
                    router_name=router_creator.router_settings.name)
            ])

        manager_creator = OpenStackVmInstance(self.snaps_creds,
                                              manager_settings, image_settings,
                                              keypair_settings)

        self.__logger.info("Creating cloudify manager VM")
        manager_creator.create()
        self.created_object.append(manager_creator)

        public_auth_url = keystone_utils.get_endpoint(self.snaps_creds,
                                                      'identity')

        self.__logger.info("Set creds for cloudify manager")
        cfy_creds = dict(keystone_username=self.snaps_creds.username,
                         keystone_password=self.snaps_creds.password,
                         keystone_tenant_name=self.snaps_creds.project_name,
                         keystone_url=public_auth_url)

        cfy_client = CloudifyClient(host=manager_creator.get_floating_ip().ip,
                                    username='******',
                                    password='******',
                                    tenant='default_tenant')

        self.orchestrator['object'] = cfy_client

        self.__logger.info("Attemps running status of the Manager")
        cfy_status = None
        retry = 10
        while str(cfy_status) != 'running' and retry:
            try:
                cfy_status = cfy_client.manager.get_status()['status']
                self.__logger.debug("The current manager status is %s",
                                    cfy_status)
            except Exception:  # pylint: disable=broad-except
                self.__logger.warning("Cloudify Manager isn't " +
                                      "up and running. Retrying ...")
            retry = retry - 1
            time.sleep(30)

        if str(cfy_status) == 'running':
            self.__logger.info("Cloudify Manager is up and running")
        else:
            raise Exception("Cloudify Manager isn't up and running")

        self.__logger.info("Put OpenStack creds in manager")
        secrets_list = cfy_client.secrets.list()
        for k, val in cfy_creds.iteritems():
            if not any(d.get('key', None) == k for d in secrets_list):
                cfy_client.secrets.create(k, val)
            else:
                cfy_client.secrets.update(k, val)

        duration = time.time() - start_time

        self.__logger.info("Put private keypair in manager")
        if manager_creator.vm_ssh_active(block=True):
            ssh = manager_creator.ssh_client()
            scp = SCPClient(ssh.get_transport(), socket_timeout=15.0)
            scp.put(kp_file, '~/')
            cmd = "sudo cp ~/cloudify_ims.pem /etc/cloudify/"
            run_blocking_ssh_command(ssh, cmd)
            cmd = "sudo chmod 444 /etc/cloudify/cloudify_ims.pem"
            run_blocking_ssh_command(ssh, cmd)
            cmd = "sudo yum install -y gcc python-devel"
            run_blocking_ssh_command(
                ssh, cmd, "Unable to install packages \
                                                on manager")

        self.details['orchestrator'].update(status='PASS', duration=duration)

        self.vnf['inputs'].update(
            dict(external_network_name=ext_net_name,
                 network_name=network_settings.name))
        self.result = 1 / 3 * 100
        return True