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()