def test_all_url(self): properties = {'hw_video_model': 'vga'} kernel_settings = ImageSettings(name='kernel', url='http://kernel.com', image_user='******', img_format='qcow2') ramdisk_settings = ImageSettings(name='ramdisk', url='http://ramdisk.com', image_user='******', img_format='qcow2') settings = ImageSettings(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)
def test_config_all_url(self): settings = ImageSettings( **{'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)
def prepare(self): super(CloudifyVrouter, self).prepare() self.__logger.info("Additional pre-configuration steps") self.snaps_creds = OSCreds(username=self.creds['username'], password=self.creds['password'], auth_url=self.creds['auth_url'], project_name=self.creds['tenant'], identity_api_version=int( os_utils.get_keystone_client_version())) self.util.set_credentials(self.creds["username"], self.creds["password"], self.creds["auth_url"], self.creds["tenant"]) # 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, ImageSettings(name=image_name, image_user='******', img_format='qcow2', image_file=image_file)) image_creator.create() self.created_object.append(image_creator)
def prepare(self): """Prepare testscase (Additional pre-configuration steps).""" super(CloudifyIms, self).prepare() self.__logger.info("Additional pre-configuration steps") self.snaps_creds = OSCreds( username=self.creds['username'], password=self.creds['password'], auth_url=self.creds['auth_url'], project_name=self.creds['tenant'], identity_api_version=int(os_utils.get_keystone_client_version())) # needs some images self.__logger.info("Upload some OS images if it doesn't exist") for image_name, image_url in self.images.iteritems(): self.__logger.info("image: %s, url: %s", image_name, image_url) if image_url and image_name: image_creator = OpenStackImage( self.snaps_creds, ImageSettings(name=image_name, image_user='******', img_format='qcow2', url=image_url)) image_creator.create()
def prepare(self): """Prepare testcase (Additional pre-configuration steps).""" self.__logger.debug("OS Credentials: %s", os_utils.get_credentials()) super(JujuEpc, self).prepare() self.__logger.info("Additional pre-configuration steps") self.public_auth_url = keystone_utils.get_endpoint( self.snaps_creds, 'identity') # it enforces a versioned public identity endpoint as juju simply # adds /auth/tokens wich fails vs an unversioned endpoint. if not self.public_auth_url.endswith(('v3', 'v3/', 'v2.0', 'v2.0/')): self.public_auth_url = urljoin(self.public_auth_url, 'v3') self.creds = { "tenant": self.tenant_name, "username": self.tenant_name, "password": self.tenant_name, "auth_url": os_utils.get_credentials()['auth_url'] } self.snaps_creds = OSCreds( username=self.creds['username'], password=self.creds['password'], auth_url=self.creds['auth_url'], project_name=self.creds['tenant'], identity_api_version=int(os_utils.get_keystone_client_version())) cloud_data = { 'url': self.public_auth_url, 'pass': self.tenant_name, 'tenant_n': self.tenant_name, 'user_n': self.tenant_name, 'region': os.environ.get( "OS_REGION_NAME", self.default_region_name) } self.__logger.info("Cloud DATA: %s", cloud_data) self.filename = os.path.join(self.case_dir, 'abot-epc.yaml') self.__logger.info("Create %s to add cloud info", self.filename) write_config(self.filename, CLOUD_TEMPLATE, **cloud_data) if self.snaps_creds.identity_api_version == 3: append_config(self.filename, '{}'.format( os_utils.get_credentials()['project_domain_name']), '{}'.format(os_utils.get_credentials()['user_domain_name'])) 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, ImageSettings(name=image_name, image_user='******', img_format='qcow2', image_file=image_file)) image_creator.create() self.created_object.append(image_creator)
def test_name_user_format_url_only(self): settings = ImageSettings(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)
def test_config_with_name_user_format_file_only(self): settings = ImageSettings( **{'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)
def test_config_with_name_user_format_url_only(self): settings = ImageSettings( **{'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)
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, ImageSettings(name=image_name, image_user='******', img_format='qcow2', image_file=image_file, public=True)) image.create()
def test_name_user_format_url_only_properties(self): properties = {'hw_video_model': 'vga'} settings = ImageSettings(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)
def prepare(self): """Prepare testcase (Additional pre-configuration steps).""" self.__logger.debug("OS Credentials: %s", os_utils.get_credentials()) super(JujuEpc, self).prepare() self.__logger.info("Additional pre-configuration steps") self.creds = { "tenant": self.tenant_name, "username": self.tenant_name, "password": self.tenant_name, "auth_url": os_utils.get_credentials()['auth_url'] } self.snaps_creds = OSCreds( username=self.creds['username'], password=self.creds['password'], auth_url=self.creds['auth_url'], project_name=self.creds['tenant'], identity_api_version=int(os_utils.get_keystone_client_version())) cmd = "sed -i 's#endpoint:.*#endpoint: {}#g' {}/abot_epc_\ cloud.yaml".format(self.creds['auth_url'], self.case_dir) os.system(cmd) if self.snaps_creds.identity_api_version == 3: cmd = "sed -i '/username/a\ user-domain-name: {}' {}/abot_" \ "epc_credential.yaml".format(os_utils.get_credentials() ['user_domain_name'], self.case_dir) os.system(cmd) cmd = "sed -i '/username/a\ project-domain-name: {}' {}" \ "/abot_epc_credential.yaml".format(os_utils.get_credentials() ['project_domain_name'], self.case_dir) os.system(cmd) 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, ImageSettings(name=image_name, image_user='******', img_format='qcow2', image_file=image_file)) image_creator.create() self.created_object.append(image_creator)
def test_config_all_file(self): settings = ImageSettings( **{'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)
def test_all_file(self): properties = {'hw_video_model': 'vga'} settings = ImageSettings(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)
def test_config_with_name_only(self): with self.assertRaises(ImageConfigError): ImageSettings(**{'name': 'foo'})
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 = ImageSettings(name=self.mano['requirements']['image'], image_user='******', exists=True) # setting up port port_settings = PortSettings( name='%s_port' % self.case_name, network_name=self.mano['details']['network']['name']) # build configuration of vm orchestra_settings = VmInstanceSettings( name=self.case_name, flavor=self.mano['details']['flavor']['name'], port_settings=[port_settings], security_group_names=[self.mano['details']['sec_group']], userdata=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 < 200: if servertest(self.mano['details']['fip'].ip, "8080"): break else: self.logger.info("Open Baton NFVO is not started yet (%ss)", (timeout * 5)) time.sleep(5) timeout += 1 if timeout >= 200: 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
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_vrouter.pem") keypair_settings = KeypairSettings(name='cloudify_vrouter_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 = SubnetSettings(name='cloudify_vrouter_subnet', cidr='10.67.79.0/24') network_settings = NetworkSettings(name='cloudify_vrouter_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, RouterSettings(name='cloudify_vrouter_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( SecurityGroupRuleSettings(sec_grp_name="sg-cloudify-manager", direction=Direction.ingress, protocol=Protocol.tcp, port_range_min=1, port_range_max=65535)) sg_rules.append( SecurityGroupRuleSettings(sec_grp_name="sg-cloudify-manager", direction=Direction.ingress, protocol=Protocol.udp, port_range_min=1, port_range_max=65535)) security_group_creator = OpenStackSecurityGroup( self.snaps_creds, SecurityGroupSettings(name="sg-cloudify-manager", rule_settings=sg_rules)) security_group_creator.create() self.created_object.append(security_group_creator) # orchestrator VM flavor self.__logger.info("Get or create flavor for cloudify manager vm ...") flavor_settings = FlavorSettings( 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 = ImageSettings( name=self.orchestrator['requirements']['os_image'], image_user='******', exists=True) port_settings = PortSettings(name='cloudify_manager_port', network_name=network_settings.name) manager_settings = VmInstanceSettings( name='cloudify_manager', flavor=flavor_settings.name, port_settings=[port_settings], security_group_names=[ security_group_creator.sec_grp_settings.name ], floating_ip_settings=[ FloatingIpSettings( 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 = os_utils.get_endpoint('identity') self.__logger.info("Set creds for cloudify manager") cfy_creds = dict(keystone_username=self.tenant_name, keystone_password=self.tenant_name, keystone_tenant_name=self.tenant_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.cfy_manager_ip = manager_creator.get_floating_ip().ip 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_vrouter.pem /etc/cloudify/" run_blocking_ssh_command(ssh, cmd) cmd = "sudo chmod 444 /etc/cloudify/cloudify_vrouter.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)) return True
def test_config_with_name_user_format_only(self): with self.assertRaises(ImageConfigError): ImageSettings( **{'name': 'foo', 'image_user': '******', 'format': 'qcow2'})
def test_name_user_format_only(self): with self.assertRaises(ImageConfigError): ImageSettings(name='foo', image_user='******', img_format='qcow2')
def test_name_only(self): with self.assertRaises(ImageConfigError): ImageSettings(name='foo')
def test_empty_config(self): with self.assertRaises(ImageConfigError): ImageSettings(**dict())
def test_no_params(self): with self.assertRaises(ImageConfigError): ImageSettings()