3 # jose.lausuch@ericsson.com
4 # valentin.boucher@orange.com
5 # All rights reserved. This program and the accompanying materials
6 # are made available under the terms of the Apache License, Version 2.0
7 # which accompanies this distribution, and is available at
8 # http://www.apache.org/licenses/LICENSE-2.0
17 from keystoneauth1 import loading
18 from keystoneauth1 import session
19 from cinderclient import client as cinderclient
20 from glanceclient import client as glanceclient
21 from novaclient import client as novaclient
22 from keystoneclient import client as keystoneclient
23 from neutronclient.neutron import client as neutronclient
25 import functest.utils.functest_logger as ft_logger
26 import functest.utils.functest_utils as ft_utils
28 logger = ft_logger.Logger("openstack_utils").getLogger()
30 DEFAULT_API_VERSION = '2'
33 # *********************************************
35 # *********************************************
36 class MissingEnvVar(Exception):
38 def __init__(self, var):
42 return str.format("Please set the mandatory env var: {}", self.var)
46 keystone_api_version = os.getenv('OS_IDENTITY_API_VERSION')
47 if (keystone_api_version is None or
48 keystone_api_version == '2'):
54 def get_rc_env_vars():
55 env_vars = ['OS_AUTH_URL', 'OS_USERNAME', 'OS_PASSWORD']
57 env_vars.extend(['OS_PROJECT_NAME',
58 'OS_USER_DOMAIN_NAME',
59 'OS_PROJECT_DOMAIN_NAME'])
61 env_vars.extend(['OS_TENANT_NAME'])
65 def check_credentials():
67 Check if the OpenStack credentials (openrc) are sourced
69 env_vars = get_rc_env_vars()
70 return all(map(lambda v: v in os.environ and os.environ[v], env_vars))
73 def get_env_cred_dict():
75 'OS_USERNAME': 'username',
76 'OS_PASSWORD': 'password',
77 'OS_AUTH_URL': 'auth_url',
78 'OS_TENANT_NAME': 'tenant_name',
79 'OS_USER_DOMAIN_NAME': 'user_domain_name',
80 'OS_PROJECT_DOMAIN_NAME': 'project_domain_name',
81 'OS_PROJECT_NAME': 'project_name',
82 'OS_ENDPOINT_TYPE': 'endpoint_type',
83 'OS_REGION_NAME': 'region_name'
88 def get_credentials(other_creds={}):
89 """Returns a creds dictionary filled with parsed from env
92 env_vars = get_rc_env_vars()
93 env_cred_dict = get_env_cred_dict()
95 for envvar in env_vars:
96 if os.getenv(envvar) is None:
97 raise MissingEnvVar(envvar)
99 creds_key = env_cred_dict.get(envvar)
100 creds.update({creds_key: os.getenv(envvar)})
102 if 'tenant' in other_creds.keys():
104 tenant = 'project_name'
106 tenant = 'tenant_name'
107 other_creds[tenant] = other_creds.pop('tenant')
109 creds.update(other_creds)
114 def source_credentials(rc_file):
115 with open(rc_file, "r") as f:
117 var = line.rstrip('"\n').replace('export ', '').split("=")
118 key = re.sub(r'^ *| *$', '', var[0])
119 value = re.sub(r'^[" ]*|[ "]*$', '', "".join(var[1:]))
120 os.environ[key] = value
123 def get_credentials_for_rally():
124 creds = get_credentials()
125 env_cred_dict = get_env_cred_dict()
126 rally_conf = {"type": "ExistingCloud", "admin": {}}
128 if key == 'auth_url':
129 rally_conf[key] = creds[key]
131 rally_conf['admin'][key] = creds[key]
133 endpoint_types = [('internalURL', 'internal'),
134 ('publicURL', 'public'), ('adminURL', 'admin')]
136 endpoint_type = os.getenv('OS_ENDPOINT_TYPE')
137 if endpoint_type is not None:
138 cred_key = env_cred_dict.get('OS_ENDPOINT_TYPE')
139 for k, v in endpoint_types:
140 if endpoint_type == k:
141 rally_conf[cred_key] = v
143 region_name = os.getenv('OS_REGION_NAME')
144 if region_name is not None:
145 cred_key = env_cred_dict.get('OS_REGION_NAME')
146 rally_conf[cred_key] = region_name
150 def get_session_auth(other_creds={}):
151 loader = loading.get_plugin_loader('password')
152 creds = get_credentials(other_creds)
153 auth = loader.load_from_options(**creds)
157 def get_endpoint(service_type, endpoint_type='publicURL'):
158 auth = get_session_auth()
159 return get_session().get_endpoint(auth=auth,
160 service_type=service_type,
161 endpoint_type=endpoint_type)
164 def get_session(other_creds={}):
165 auth = get_session_auth(other_creds)
166 return session.Session(auth=auth)
169 # *********************************************
171 # *********************************************
172 def get_keystone_client_version():
173 api_version = os.getenv('OS_IDENTITY_API_VERSION')
174 if api_version is not None:
175 logger.info("OS_IDENTITY_API_VERSION is set in env as '%s'",
178 return DEFAULT_API_VERSION
181 def get_keystone_client(other_creds={}):
182 sess = get_session(other_creds)
183 return keystoneclient.Client(get_keystone_client_version(), session=sess)
186 def get_nova_client_version():
187 api_version = os.getenv('OS_COMPUTE_API_VERSION')
188 if api_version is not None:
189 logger.info("OS_COMPUTE_API_VERSION is set in env as '%s'",
192 return DEFAULT_API_VERSION
195 def get_nova_client(other_creds={}):
196 sess = get_session(other_creds)
197 return novaclient.Client(get_nova_client_version(), session=sess)
200 def get_cinder_client_version():
201 api_version = os.getenv('OS_VOLUME_API_VERSION')
202 if api_version is not None:
203 logger.info("OS_VOLUME_API_VERSION is set in env as '%s'",
206 return DEFAULT_API_VERSION
209 def get_cinder_client(other_creds={}):
210 sess = get_session(other_creds)
211 return cinderclient.Client(get_cinder_client_version(), session=sess)
214 def get_neutron_client_version():
215 api_version = os.getenv('OS_NETWORK_API_VERSION')
216 if api_version is not None:
217 logger.info("OS_NETWORK_API_VERSION is set in env as '%s'",
220 return DEFAULT_API_VERSION
223 def get_neutron_client(other_creds={}):
224 sess = get_session(other_creds)
225 return neutronclient.Client(get_neutron_client_version(), session=sess)
228 def get_glance_client_version():
229 api_version = os.getenv('OS_IMAGE_API_VERSION')
230 if api_version is not None:
231 logger.info("OS_IMAGE_API_VERSION is set in env as '%s'", api_version)
233 return DEFAULT_API_VERSION
236 def get_glance_client(other_creds={}):
237 sess = get_session(other_creds)
238 return glanceclient.Client(get_glance_client_version(), session=sess)
241 # *********************************************
243 # *********************************************
244 def get_instances(nova_client):
246 instances = nova_client.servers.list(search_opts={'all_tenants': 1})
249 logger.error("Error [get_instances(nova_client)]: %s" % e)
253 def get_instance_status(nova_client, instance):
255 instance = nova_client.servers.get(instance.id)
256 return instance.status
258 logger.error("Error [get_instance_status(nova_client)]: %s" % e)
262 def get_instance_by_name(nova_client, instance_name):
264 instance = nova_client.servers.find(name=instance_name)
267 logger.error("Error [get_instance_by_name(nova_client, '%s')]: %s"
268 % (instance_name, e))
272 def get_flavor_id(nova_client, flavor_name):
273 flavors = nova_client.flavors.list(detailed=True)
276 if f.name == flavor_name:
282 def get_flavor_id_by_ram_range(nova_client, min_ram, max_ram):
283 flavors = nova_client.flavors.list(detailed=True)
286 if min_ram <= f.ram and f.ram <= max_ram:
292 def get_aggregates(nova_client):
294 aggregates = nova_client.aggregates.list()
297 logger.error("Error [get_aggregates(nova_client)]: %s" % e)
301 def get_aggregate_id(nova_client, aggregate_name):
303 aggregates = get_aggregates(nova_client)
304 _id = [ag.id for ag in aggregates if ag.name == aggregate_name][0]
307 logger.error("Error [get_aggregate_id(nova_client, %s)]:"
308 " %s" % (aggregate_name, e))
312 def get_availability_zones(nova_client):
314 availability_zones = nova_client.availability_zones.list()
315 return availability_zones
317 logger.error("Error [get_availability_zones(nova_client)]: %s" % e)
321 def get_availability_zone_names(nova_client):
323 az_names = [az.zoneName for az in get_availability_zones(nova_client)]
326 logger.error("Error [get_availability_zone_names(nova_client)]:"
331 def create_flavor(nova_client, flavor_name, ram, disk, vcpus, public=True):
333 flavor = nova_client.flavors.create(
334 flavor_name, ram, vcpus, disk, is_public=public)
336 extra_specs = ft_utils.get_functest_config(
337 'general.flavor_extra_specs')
338 flavor.set_keys(extra_specs)
340 # flavor extra specs are not configured, therefore skip the update
344 logger.error("Error [create_flavor(nova_client, '%s', '%s', '%s', "
345 "'%s')]: %s" % (flavor_name, ram, disk, vcpus, e))
350 def get_or_create_flavor(flavor_name, ram, disk, vcpus, public=True):
351 flavor_exists = False
352 nova_client = get_nova_client()
354 flavor_id = get_flavor_id(nova_client, flavor_name)
356 logger.info("Using existing flavor '%s'..." % flavor_name)
359 logger.info("Creating flavor '%s' with '%s' RAM, '%s' disk size, "
360 "'%s' vcpus..." % (flavor_name, ram, disk, vcpus))
361 flavor_id = create_flavor(
362 nova_client, flavor_name, ram, disk, vcpus, public=public)
364 logger.error("Failed to create flavor '%s'..." % (flavor_name))
366 logger.debug("Flavor '%s' with ID=%s created successfully."
367 % (flavor_name, flavor_id))
369 return flavor_exists, flavor_id
372 def get_floating_ips(nova_client):
374 floating_ips = nova_client.floating_ips.list()
377 logger.error("Error [get_floating_ips(nova_client)]: %s" % e)
381 def get_hypervisors(nova_client):
384 hypervisors = nova_client.hypervisors.list()
385 for hypervisor in hypervisors:
386 if hypervisor.state == "up":
387 nodes.append(hypervisor.hypervisor_hostname)
390 logger.error("Error [get_hypervisors(nova_client)]: %s" % e)
394 def create_aggregate(nova_client, aggregate_name, av_zone):
396 nova_client.aggregates.create(aggregate_name, av_zone)
399 logger.error("Error [create_aggregate(nova_client, %s, %s)]: %s"
400 % (aggregate_name, av_zone, e))
404 def add_host_to_aggregate(nova_client, aggregate_name, compute_host):
406 aggregate_id = get_aggregate_id(nova_client, aggregate_name)
407 nova_client.aggregates.add_host(aggregate_id, compute_host)
410 logger.error("Error [add_host_to_aggregate(nova_client, %s, %s)]: %s"
411 % (aggregate_name, compute_host, e))
415 def create_aggregate_with_host(
416 nova_client, aggregate_name, av_zone, compute_host):
418 create_aggregate(nova_client, aggregate_name, av_zone)
419 add_host_to_aggregate(nova_client, aggregate_name, compute_host)
422 logger.error("Error [create_aggregate_with_host("
423 "nova_client, %s, %s, %s)]: %s"
424 % (aggregate_name, av_zone, compute_host, e))
428 def create_instance(flavor_name,
431 instance_name="functest-vm",
437 nova_client = get_nova_client()
439 flavor = nova_client.flavors.find(name=flavor_name)
441 flavors = nova_client.flavors.list()
442 logger.error("Error: Flavor '%s' not found. Available flavors are: "
443 "\n%s" % (flavor_name, flavors))
445 if fixed_ip is not None:
446 nics = {"net-id": network_id, "v4-fixed-ip": fixed_ip}
448 nics = {"net-id": network_id}
450 instance = nova_client.servers.create(
455 availability_zone=av_zone,
459 instance = nova_client.servers.create(
464 config_drive=confdrive,
466 availability_zone=av_zone,
472 def create_instance_and_wait_for_active(flavor_name,
482 VM_BOOT_TIMEOUT = 180
483 nova_client = get_nova_client()
484 instance = create_instance(flavor_name,
493 count = VM_BOOT_TIMEOUT / SLEEP
494 for n in range(count, -1, -1):
495 status = get_instance_status(nova_client, instance)
496 if status.lower() == "active":
498 elif status.lower() == "error":
499 logger.error("The instance %s went to ERROR status."
503 logger.error("Timeout booting the instance %s." % instance_name)
507 def create_floating_ip(neutron_client):
508 extnet_id = get_external_net_id(neutron_client)
509 props = {'floating_network_id': extnet_id}
511 ip_json = neutron_client.create_floatingip({'floatingip': props})
512 fip_addr = ip_json['floatingip']['floating_ip_address']
513 fip_id = ip_json['floatingip']['id']
515 logger.error("Error [create_floating_ip(neutron_client)]: %s" % e)
517 return {'fip_addr': fip_addr, 'fip_id': fip_id}
520 def add_floating_ip(nova_client, server_id, floatingip_addr):
522 nova_client.servers.add_floating_ip(server_id, floatingip_addr)
525 logger.error("Error [add_floating_ip(nova_client, '%s', '%s')]: %s"
526 % (server_id, floatingip_addr, e))
530 def delete_instance(nova_client, instance_id):
532 nova_client.servers.force_delete(instance_id)
535 logger.error("Error [delete_instance(nova_client, '%s')]: %s"
540 def delete_floating_ip(nova_client, floatingip_id):
542 nova_client.floating_ips.delete(floatingip_id)
545 logger.error("Error [delete_floating_ip(nova_client, '%s')]: %s"
546 % (floatingip_id, e))
550 def remove_host_from_aggregate(nova_client, aggregate_name, compute_host):
552 aggregate_id = get_aggregate_id(nova_client, aggregate_name)
553 nova_client.aggregates.remove_host(aggregate_id, compute_host)
556 logger.error("Error [remove_host_from_aggregate(nova_client, %s, %s)]:"
557 " %s" % (aggregate_name, compute_host, e))
561 def remove_hosts_from_aggregate(nova_client, aggregate_name):
562 aggregate_id = get_aggregate_id(nova_client, aggregate_name)
563 hosts = nova_client.aggregates.get(aggregate_id).hosts
565 all(remove_host_from_aggregate(nova_client, aggregate_name, host)
569 def delete_aggregate(nova_client, aggregate_name):
571 remove_hosts_from_aggregate(nova_client, aggregate_name)
572 nova_client.aggregates.delete(aggregate_name)
575 logger.error("Error [delete_aggregate(nova_client, %s)]: %s"
576 % (aggregate_name, e))
580 # *********************************************
582 # *********************************************
583 def get_network_list(neutron_client):
584 network_list = neutron_client.list_networks()['networks']
585 if len(network_list) == 0:
591 def get_router_list(neutron_client):
592 router_list = neutron_client.list_routers()['routers']
593 if len(router_list) == 0:
599 def get_port_list(neutron_client):
600 port_list = neutron_client.list_ports()['ports']
601 if len(port_list) == 0:
607 def get_network_id(neutron_client, network_name):
608 networks = neutron_client.list_networks()['networks']
611 if n['name'] == network_name:
617 def get_subnet_id(neutron_client, subnet_name):
618 subnets = neutron_client.list_subnets()['subnets']
621 if s['name'] == subnet_name:
627 def get_router_id(neutron_client, router_name):
628 routers = neutron_client.list_routers()['routers']
631 if r['name'] == router_name:
637 def get_private_net(neutron_client):
638 # Checks if there is an existing shared private network
639 networks = neutron_client.list_networks()['networks']
640 if len(networks) == 0:
643 if (net['router:external'] is False) and (net['shared'] is True):
648 def get_external_net(neutron_client):
649 for network in neutron_client.list_networks()['networks']:
650 if network['router:external']:
651 return network['name']
655 def get_external_net_id(neutron_client):
656 for network in neutron_client.list_networks()['networks']:
657 if network['router:external']:
662 def check_neutron_net(neutron_client, net_name):
663 for network in neutron_client.list_networks()['networks']:
664 if network['name'] == net_name:
665 for subnet in network['subnets']:
670 def create_neutron_net(neutron_client, name):
671 json_body = {'network': {'name': name,
672 'admin_state_up': True}}
674 network = neutron_client.create_network(body=json_body)
675 network_dict = network['network']
676 return network_dict['id']
678 logger.error("Error [create_neutron_net(neutron_client, '%s')]: %s"
683 def create_neutron_subnet(neutron_client, name, cidr, net_id):
684 json_body = {'subnets': [{'name': name, 'cidr': cidr,
685 'ip_version': 4, 'network_id': net_id}]}
687 subnet = neutron_client.create_subnet(body=json_body)
688 return subnet['subnets'][0]['id']
690 logger.error("Error [create_neutron_subnet(neutron_client, '%s', "
691 "'%s', '%s')]: %s" % (name, cidr, net_id, e))
695 def create_neutron_router(neutron_client, name):
696 json_body = {'router': {'name': name, 'admin_state_up': True}}
698 router = neutron_client.create_router(json_body)
699 return router['router']['id']
701 logger.error("Error [create_neutron_router(neutron_client, '%s')]: %s"
706 def create_neutron_port(neutron_client, name, network_id, ip):
707 json_body = {'port': {
708 'admin_state_up': True,
710 'network_id': network_id,
711 'fixed_ips': [{"ip_address": ip}]
714 port = neutron_client.create_port(body=json_body)
715 return port['port']['id']
717 logger.error("Error [create_neutron_port(neutron_client, '%s', '%s', "
718 "'%s')]: %s" % (name, network_id, ip, e))
722 def update_neutron_net(neutron_client, network_id, shared=False):
723 json_body = {'network': {'shared': shared}}
725 neutron_client.update_network(network_id, body=json_body)
728 logger.error("Error [update_neutron_net(neutron_client, '%s', '%s')]: "
729 "%s" % (network_id, str(shared), e))
733 def update_neutron_port(neutron_client, port_id, device_owner):
734 json_body = {'port': {
735 'device_owner': device_owner,
738 port = neutron_client.update_port(port=port_id,
740 return port['port']['id']
742 logger.error("Error [update_neutron_port(neutron_client, '%s', '%s')]:"
743 " %s" % (port_id, device_owner, e))
747 def add_interface_router(neutron_client, router_id, subnet_id):
748 json_body = {"subnet_id": subnet_id}
750 neutron_client.add_interface_router(router=router_id, body=json_body)
753 logger.error("Error [add_interface_router(neutron_client, '%s', "
754 "'%s')]: %s" % (router_id, subnet_id, e))
758 def add_gateway_router(neutron_client, router_id):
759 ext_net_id = get_external_net_id(neutron_client)
760 router_dict = {'network_id': ext_net_id}
762 neutron_client.add_gateway_router(router_id, router_dict)
765 logger.error("Error [add_gateway_router(neutron_client, '%s')]: %s"
770 def delete_neutron_net(neutron_client, network_id):
772 neutron_client.delete_network(network_id)
775 logger.error("Error [delete_neutron_net(neutron_client, '%s')]: %s"
780 def delete_neutron_subnet(neutron_client, subnet_id):
782 neutron_client.delete_subnet(subnet_id)
785 logger.error("Error [delete_neutron_subnet(neutron_client, '%s')]: %s"
790 def delete_neutron_router(neutron_client, router_id):
792 neutron_client.delete_router(router=router_id)
795 logger.error("Error [delete_neutron_router(neutron_client, '%s')]: %s"
800 def delete_neutron_port(neutron_client, port_id):
802 neutron_client.delete_port(port_id)
805 logger.error("Error [delete_neutron_port(neutron_client, '%s')]: %s"
810 def remove_interface_router(neutron_client, router_id, subnet_id):
811 json_body = {"subnet_id": subnet_id}
813 neutron_client.remove_interface_router(router=router_id,
817 logger.error("Error [remove_interface_router(neutron_client, '%s', "
818 "'%s')]: %s" % (router_id, subnet_id, e))
822 def remove_gateway_router(neutron_client, router_id):
824 neutron_client.remove_gateway_router(router_id)
827 logger.error("Error [remove_gateway_router(neutron_client, '%s')]: %s"
832 def create_network_full(neutron_client,
838 # Check if the network already exists
839 network_id = get_network_id(neutron_client, net_name)
840 subnet_id = get_subnet_id(neutron_client, subnet_name)
841 router_id = get_router_id(neutron_client, router_name)
843 if network_id != '' and subnet_id != '' and router_id != '':
844 logger.info("A network with name '%s' already exists..." % net_name)
846 neutron_client.format = 'json'
847 logger.info('Creating neutron network %s...' % net_name)
848 network_id = create_neutron_net(neutron_client, net_name)
853 logger.debug("Network '%s' created successfully" % network_id)
854 logger.debug('Creating Subnet....')
855 subnet_id = create_neutron_subnet(neutron_client, subnet_name,
860 logger.debug("Subnet '%s' created successfully" % subnet_id)
861 logger.debug('Creating Router...')
862 router_id = create_neutron_router(neutron_client, router_name)
867 logger.debug("Router '%s' created successfully" % router_id)
868 logger.debug('Adding router to subnet...')
870 if not add_interface_router(neutron_client, router_id, subnet_id):
873 logger.debug("Interface added successfully.")
875 logger.debug('Adding gateway to router...')
876 if not add_gateway_router(neutron_client, router_id):
879 logger.debug("Gateway added successfully.")
881 network_dic = {'net_id': network_id,
882 'subnet_id': subnet_id,
883 'router_id': router_id}
887 def create_shared_network_full(net_name, subnt_name, router_name, subnet_cidr):
888 neutron_client = get_neutron_client()
890 network_dic = create_network_full(neutron_client,
896 if not update_neutron_net(neutron_client,
897 network_dic['net_id'],
899 logger.error("Failed to update network %s..." % net_name)
902 logger.debug("Network '%s' is available..." % net_name)
904 logger.error("Network %s creation failed" % net_name)
909 def create_bgpvpn(neutron_client, **kwargs):
910 # route_distinguishers
912 json_body = {"bgpvpn": kwargs}
913 return neutron_client.create_bgpvpn(json_body)
916 def create_network_association(neutron_client, bgpvpn_id, neutron_network_id):
917 json_body = {"network_association": {"network_id": neutron_network_id}}
918 return neutron_client.create_network_association(bgpvpn_id, json_body)
921 def create_router_association(neutron_client, bgpvpn_id, router_id):
922 json_body = {"router_association": {"router_id": router_id}}
923 return neutron_client.create_router_association(bgpvpn_id, json_body)
926 def update_bgpvpn(neutron_client, bgpvpn_id, **kwargs):
927 json_body = {"bgpvpn": kwargs}
928 return neutron_client.update_bgpvpn(bgpvpn_id, json_body)
931 def delete_bgpvpn(neutron_client, bgpvpn_id):
932 return neutron_client.delete_bgpvpn(bgpvpn_id)
935 def get_bgpvpn(neutron_client, bgpvpn_id):
936 return neutron_client.show_bgpvpn(bgpvpn_id)
939 def get_bgpvpn_routers(neutron_client, bgpvpn_id):
940 return get_bgpvpn(neutron_client, bgpvpn_id)['bgpvpn']['routers']
943 def get_bgpvpn_networks(neutron_client, bgpvpn_id):
944 return get_bgpvpn(neutron_client, bgpvpn_id)['bgpvpn']['networks']
946 # *********************************************
948 # *********************************************
951 def get_security_groups(neutron_client):
953 security_groups = neutron_client.list_security_groups()[
955 return security_groups
957 logger.error("Error [get_security_groups(neutron_client)]: %s" % e)
961 def get_security_group_id(neutron_client, sg_name):
962 security_groups = get_security_groups(neutron_client)
964 for sg in security_groups:
965 if sg['name'] == sg_name:
971 def create_security_group(neutron_client, sg_name, sg_description):
972 json_body = {'security_group': {'name': sg_name,
973 'description': sg_description}}
975 secgroup = neutron_client.create_security_group(json_body)
976 return secgroup['security_group']
978 logger.error("Error [create_security_group(neutron_client, '%s', "
979 "'%s')]: %s" % (sg_name, sg_description, e))
983 def create_secgroup_rule(neutron_client, sg_id, direction, protocol,
984 port_range_min=None, port_range_max=None):
985 if port_range_min is None and port_range_max is None:
986 json_body = {'security_group_rule': {'direction': direction,
987 'security_group_id': sg_id,
988 'protocol': protocol}}
989 elif port_range_min is not None and port_range_max is not None:
990 json_body = {'security_group_rule': {'direction': direction,
991 'security_group_id': sg_id,
992 'port_range_min': port_range_min,
993 'port_range_max': port_range_max,
994 'protocol': protocol}}
996 logger.error("Error [create_secgroup_rule(neutron_client, '%s', '%s', "
997 "'%s', '%s', '%s', '%s')]:" % (neutron_client,
1002 " Invalid values for port_range_min, port_range_max")
1005 neutron_client.create_security_group_rule(json_body)
1007 except Exception, e:
1008 logger.error("Error [create_secgroup_rule(neutron_client, '%s', '%s', "
1009 "'%s', '%s', '%s', '%s')]: %s" % (neutron_client,
1018 def create_security_group_full(neutron_client,
1019 sg_name, sg_description):
1020 sg_id = get_security_group_id(neutron_client, sg_name)
1022 logger.info("Using existing security group '%s'..." % sg_name)
1024 logger.info("Creating security group '%s'..." % sg_name)
1025 SECGROUP = create_security_group(neutron_client,
1029 logger.error("Failed to create the security group...")
1032 sg_id = SECGROUP['id']
1034 logger.debug("Security group '%s' with ID=%s created successfully."
1035 % (SECGROUP['name'], sg_id))
1037 logger.debug("Adding ICMP rules in security group '%s'..."
1039 if not create_secgroup_rule(neutron_client, sg_id,
1041 logger.error("Failed to create the security group rule...")
1044 logger.debug("Adding SSH rules in security group '%s'..."
1046 if not create_secgroup_rule(
1047 neutron_client, sg_id, 'ingress', 'tcp', '22', '22'):
1048 logger.error("Failed to create the security group rule...")
1051 if not create_secgroup_rule(
1052 neutron_client, sg_id, 'egress', 'tcp', '22', '22'):
1053 logger.error("Failed to create the security group rule...")
1058 def add_secgroup_to_instance(nova_client, instance_id, secgroup_id):
1060 nova_client.servers.add_security_group(instance_id, secgroup_id)
1062 except Exception, e:
1063 logger.error("Error [add_secgroup_to_instance(nova_client, '%s', "
1064 "'%s')]: %s" % (instance_id, secgroup_id, e))
1068 def update_sg_quota(neutron_client, tenant_id, sg_quota, sg_rule_quota):
1069 json_body = {"quota": {
1070 "security_group": sg_quota,
1071 "security_group_rule": sg_rule_quota
1075 neutron_client.update_quota(tenant_id=tenant_id,
1078 except Exception, e:
1079 logger.error("Error [update_sg_quota(neutron_client, '%s', '%s', "
1080 "'%s')]: %s" % (tenant_id, sg_quota, sg_rule_quota, e))
1084 def delete_security_group(neutron_client, secgroup_id):
1086 neutron_client.delete_security_group(secgroup_id)
1088 except Exception, e:
1089 logger.error("Error [delete_security_group(neutron_client, '%s')]: %s"
1094 # *********************************************
1096 # *********************************************
1097 def get_images(nova_client):
1099 images = nova_client.images.list()
1101 except Exception, e:
1102 logger.error("Error [get_images]: %s" % e)
1106 def get_image_id(glance_client, image_name):
1107 images = glance_client.images.list()
1110 if i.name == image_name:
1116 def create_glance_image(glance_client, image_name, file_path, disk="qcow2",
1117 container="bare", public="public"):
1118 if not os.path.isfile(file_path):
1119 logger.error("Error: file %s does not exist." % file_path)
1122 image_id = get_image_id(glance_client, image_name)
1124 logger.info("Image %s already exists." % image_name)
1126 logger.info("Creating image '%s' from '%s'..." % (image_name,
1129 image = glance_client.images.create(name=image_name,
1132 container_format=container)
1134 with open(file_path) as image_data:
1135 glance_client.images.upload(image_id, image_data)
1137 except Exception, e:
1138 logger.error("Error [create_glance_image(glance_client, '%s', '%s', "
1139 "'%s')]: %s" % (image_name, file_path, public, e))
1143 def get_or_create_image(name, path, format):
1144 image_exists = False
1145 glance_client = get_glance_client()
1147 image_id = get_image_id(glance_client, name)
1149 logger.info("Using existing image '%s'..." % name)
1152 logger.info("Creating image '%s' from '%s'..." % (name, path))
1153 image_id = create_glance_image(glance_client, name, path, format)
1155 logger.error("Failed to create a Glance image...")
1157 logger.debug("Image '%s' with ID=%s created successfully."
1160 return image_exists, image_id
1163 def delete_glance_image(nova_client, image_id):
1165 nova_client.images.delete(image_id)
1167 except Exception, e:
1168 logger.error("Error [delete_glance_image(nova_client, '%s')]: %s"
1173 # *********************************************
1175 # *********************************************
1176 def get_volumes(cinder_client):
1178 volumes = cinder_client.volumes.list(search_opts={'all_tenants': 1})
1180 except Exception, e:
1181 logger.error("Error [get_volumes(cinder_client)]: %s" % e)
1185 def list_volume_types(cinder_client, public=True, private=True):
1187 volume_types = cinder_client.volume_types.list()
1189 volume_types = [vt for vt in volume_types if not vt.is_public]
1191 volume_types = [vt for vt in volume_types if vt.is_public]
1193 except Exception, e:
1194 logger.error("Error [list_volume_types(cinder_client)]: %s" % e)
1198 def create_volume_type(cinder_client, name):
1200 volume_type = cinder_client.volume_types.create(name)
1202 except Exception, e:
1203 logger.error("Error [create_volume_type(cinder_client, '%s')]: %s"
1208 def update_cinder_quota(cinder_client, tenant_id, vols_quota,
1209 snapshots_quota, gigabytes_quota):
1210 quotas_values = {"volumes": vols_quota,
1211 "snapshots": snapshots_quota,
1212 "gigabytes": gigabytes_quota}
1215 cinder_client.quotas.update(tenant_id, **quotas_values)
1217 except Exception, e:
1218 logger.error("Error [update_cinder_quota(cinder_client, '%s', '%s', "
1219 "'%s' '%s')]: %s" % (tenant_id, vols_quota,
1220 snapshots_quota, gigabytes_quota, e))
1224 def delete_volume(cinder_client, volume_id, forced=False):
1228 cinder_client.volumes.detach(volume_id)
1230 logger.error(sys.exc_info()[0])
1231 cinder_client.volumes.force_delete(volume_id)
1233 cinder_client.volumes.delete(volume_id)
1235 except Exception, e:
1236 logger.error("Error [delete_volume(cinder_client, '%s', '%s')]: %s"
1237 % (volume_id, str(forced), e))
1241 def delete_volume_type(cinder_client, volume_type):
1243 cinder_client.volume_types.delete(volume_type)
1245 except Exception, e:
1246 logger.error("Error [delete_volume_type(cinder_client, '%s')]: %s"
1251 # *********************************************
1253 # *********************************************
1254 def get_tenants(keystone_client):
1256 if is_keystone_v3():
1257 tenants = keystone_client.projects.list()
1259 tenants = keystone_client.tenants.list()
1261 except Exception, e:
1262 logger.error("Error [get_tenants(keystone_client)]: %s" % e)
1266 def get_users(keystone_client):
1268 users = keystone_client.users.list()
1270 except Exception, e:
1271 logger.error("Error [get_users(keystone_client)]: %s" % e)
1275 def get_tenant_id(keystone_client, tenant_name):
1276 tenants = get_tenants(keystone_client)
1279 if t.name == tenant_name:
1285 def get_user_id(keystone_client, user_name):
1286 users = get_users(keystone_client)
1289 if u.name == user_name:
1295 def get_role_id(keystone_client, role_name):
1296 roles = keystone_client.roles.list()
1299 if r.name == role_name:
1305 def create_tenant(keystone_client, tenant_name, tenant_description):
1307 if is_keystone_v3():
1308 tenant = keystone_client.projects.create(
1310 description=tenant_description,
1314 tenant = keystone_client.tenants.create(tenant_name,
1318 except Exception, e:
1319 logger.error("Error [create_tenant(keystone_client, '%s', '%s')]: %s"
1320 % (tenant_name, tenant_description, e))
1324 def create_user(keystone_client, user_name, user_password,
1325 user_email, tenant_id):
1327 if is_keystone_v3():
1328 user = keystone_client.users.create(name=user_name,
1329 password=user_password,
1331 project_id=tenant_id,
1334 user = keystone_client.users.create(user_name,
1340 except Exception, e:
1341 logger.error("Error [create_user(keystone_client, '%s', '%s', '%s'"
1342 "'%s')]: %s" % (user_name, user_password,
1343 user_email, tenant_id, e))
1347 def add_role_user(keystone_client, user_id, role_id, tenant_id):
1349 if is_keystone_v3():
1350 keystone_client.roles.grant(role=role_id,
1354 keystone_client.roles.add_user_role(user_id, role_id, tenant_id)
1356 except Exception, e:
1357 logger.error("Error [add_role_user(keystone_client, '%s', '%s'"
1358 "'%s')]: %s " % (user_id, role_id, tenant_id, e))
1362 def delete_tenant(keystone_client, tenant_id):
1364 if is_keystone_v3():
1365 keystone_client.projects.delete(tenant_id)
1367 keystone_client.tenants.delete(tenant_id)
1369 except Exception, e:
1370 logger.error("Error [delete_tenant(keystone_client, '%s')]: %s"
1375 def delete_user(keystone_client, user_id):
1377 keystone_client.users.delete(user_id)
1379 except Exception, e:
1380 logger.error("Error [delete_user(keystone_client, '%s')]: %s"