def test_config_with_name_only(self): settings = KeypairSettings(**{'name': 'foo'}) self.assertEqual('foo', settings.name) self.assertEqual(1024, settings.key_size) self.assertIsNone(settings.public_filepath) self.assertIsNone(settings.private_filepath) self.assertIsNone(settings.delete_on_clean)
def test_name_priv_only(self): settings = KeypairSettings(name='foo', private_filepath='/foo/bar') self.assertEqual('foo', settings.name) self.assertEqual(1024, settings.key_size) self.assertIsNone(settings.public_filepath) self.assertEqual('/foo/bar', settings.private_filepath) self.assertIsNone(settings.delete_on_clean)
def test_all_delete_str_false_cap(self): settings = KeypairSettings(name='foo', public_filepath='/foo/bar.pub', private_filepath='/foo/bar', delete_on_clean='False') self.assertEqual('foo', settings.name) self.assertEqual(1024, settings.key_size) self.assertEqual('/foo/bar.pub', settings.public_filepath) self.assertEqual('/foo/bar', settings.private_filepath) self.assertFalse(settings.delete_on_clean)
def test_all_delete_bool(self): settings = KeypairSettings(name='foo', public_filepath='/foo/bar.pub', private_filepath='/foo/bar', delete_on_clean=True, key_size=999) self.assertEqual('foo', settings.name) self.assertEqual(999, settings.key_size) self.assertEqual('/foo/bar.pub', settings.public_filepath) self.assertEqual('/foo/bar', settings.private_filepath) self.assertTrue(settings.delete_on_clean)
def test_config_all_delete_false_str_lc(self): settings = KeypairSettings( **{ 'name': 'foo', 'public_filepath': '/foo/bar.pub', 'private_filepath': '/foo/bar', 'delete_on_clean': 'false' }) self.assertEqual('foo', settings.name) self.assertEqual(1024, settings.key_size) self.assertEqual('/foo/bar.pub', settings.public_filepath) self.assertEqual('/foo/bar', settings.private_filepath) self.assertFalse(settings.delete_on_clean)
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 run(self): """ Excecute VPingSSH testcase. Sets up the OpenStack keypair, router, security group, and VM instance objects then validates the ping. :return: the exit code from the super.execute() method """ try: super(VPingSSH, self).run() log = "Creating keypair with name: '%s'" % self.kp_name self.logger.info(log) kp_creator = deploy_utils.create_keypair( self.os_creds, KeypairSettings(name=self.kp_name, private_filepath=self.kp_priv_file, public_filepath=self.kp_pub_file)) self.creators.append(kp_creator) # Creating router to external network log = "Creating router with name: '%s'" % self.router_name self.logger.info(log) net_set = self.network_creator.network_settings sub_set = [net_set.subnet_settings[0].name] ext_net_name = snaps_utils.get_ext_net_name(self.os_creds) router_creator = deploy_utils.create_router( self.os_creds, RouterSettings( name=self.router_name, external_gateway=ext_net_name, internal_subnets=sub_set)) self.creators.append(router_creator) # Creating Instance 1 port1_settings = PortSettings( name=self.vm1_name + '-vPingPort', network_name=self.network_creator.network_settings.name) instance1_settings = VmInstanceSettings( name=self.vm1_name, flavor=self.flavor_name, vm_boot_timeout=self.vm_boot_timeout, vm_delete_timeout=self.vm_delete_timeout, ssh_connect_timeout=self.vm_ssh_connect_timeout, port_settings=[port1_settings]) log = ("Creating VM 1 instance with name: '%s'" % instance1_settings.name) self.logger.info(log) self.vm1_creator = deploy_utils.create_vm_instance( self.os_creds, instance1_settings, self.image_creator.image_settings, keypair_creator=kp_creator) self.creators.append(self.vm1_creator) # Creating Instance 2 sg_creator = self.__create_security_group() self.creators.append(sg_creator) port2_settings = PortSettings( name=self.vm2_name + '-vPingPort', network_name=self.network_creator.network_settings.name) instance2_settings = VmInstanceSettings( name=self.vm2_name, flavor=self.flavor_name, vm_boot_timeout=self.vm_boot_timeout, vm_delete_timeout=self.vm_delete_timeout, ssh_connect_timeout=self.vm_ssh_connect_timeout, port_settings=[port2_settings], security_group_names=[sg_creator.sec_grp_settings.name], floating_ip_settings=[FloatingIpSettings( name=self.vm2_name + '-FIPName', port_name=port2_settings.name, router_name=router_creator.router_settings.name)]) log = ("Creating VM 2 instance with name: '%s'" % instance2_settings.name) self.logger.info(log) self.vm2_creator = deploy_utils.create_vm_instance( self.os_creds, instance2_settings, self.image_creator.image_settings, keypair_creator=kp_creator) self.creators.append(self.vm2_creator) return self._execute() except Exception as exc: # pylint: disable=broad-except self.logger.error('Unexpected error running test - ' + exc.message) return TestCase.EX_RUN_ERROR finally: self._cleanup()
def test_small_key_size(self): with self.assertRaises(KeypairConfigError): KeypairSettings(name='foo', key_size=511)
def test_empty_config(self): with self.assertRaises(KeypairConfigError): KeypairSettings(**dict())
def test_no_params(self): with self.assertRaises(KeypairConfigError): KeypairSettings()