2 # Copyright (c) 2016 Cable Television Laboratories, Inc. ("CableLabs")
3 # and others. All rights reserved.
5 # Licensed under the Apache License, Version 2.0 (the "License");
6 # you may not use this file except in compliance with the License.
7 # You may obtain a copy of the License at:
9 # http://www.apache.org/licenses/LICENSE-2.0
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
17 # This utility makes it easy to create OpenStack objects
25 from keystoneauth1.exceptions import Unauthorized
27 from snaps import file_utils
28 from snaps.config.flavor import FlavorConfig
29 from snaps.config.image import ImageConfig
30 from snaps.config.keypair import KeypairConfig
31 from snaps.config.network import PortConfig, NetworkConfig
32 from snaps.config.project import ProjectConfig
33 from snaps.config.qos import QoSConfig
34 from snaps.config.router import RouterConfig
35 from snaps.config.security_group import SecurityGroupConfig
36 from snaps.config.user import UserConfig
37 from snaps.config.vm_inst import VmInstanceConfig
38 from snaps.config.volume import VolumeConfig
39 from snaps.config.volume_type import VolumeTypeConfig
40 from snaps.openstack.create_flavor import OpenStackFlavor
41 from snaps.openstack.create_image import OpenStackImage
42 from snaps.openstack.create_keypairs import OpenStackKeypair
43 from snaps.openstack.create_network import OpenStackNetwork
44 from snaps.openstack.create_project import OpenStackProject
45 from snaps.openstack.create_qos import OpenStackQoS
46 from snaps.openstack.create_router import OpenStackRouter
47 from snaps.openstack.create_security_group import OpenStackSecurityGroup
48 from snaps.openstack.create_user import OpenStackUser
49 from snaps.openstack.create_volume import OpenStackVolume
50 from snaps.openstack.create_volume_type import OpenStackVolumeType
51 from snaps.openstack.os_credentials import OSCreds, ProxySettings
52 from snaps.openstack.utils import deploy_utils, neutron_utils, keystone_utils
53 from snaps.openstack.utils.nova_utils import RebootType
54 from snaps.provisioning import ansible_utils
56 from warnings import warn
57 warn('This utility will be removed in a subsequent release',
60 logger = logging.getLogger('lanuch_utils')
61 DEFAULT_CREDS_KEY = 'admin'
64 def launch_config(config, tmplt_file, deploy, clean, clean_image):
66 Launches all objects and applies any configured ansible playbooks
67 :param config: the environment configuration dict object
68 :param tmplt_file: the path to the SNAPS-OO template file
69 :param deploy: when True deploy
70 :param clean: when True clean
71 :param clean_image: when True clean the image when clean is True
73 os_config = config.get('openstack')
79 networks_dict = dict()
81 os_creds_dict = dict()
84 os_creds_dict = __get_creds_dict(os_config)
87 projects_dict = __create_instances(
88 os_creds_dict, OpenStackProject, ProjectConfig,
89 os_config.get('projects'), 'project', clean)
90 creators.append(projects_dict)
93 users_dict = __create_instances(
94 os_creds_dict, OpenStackUser, UserConfig,
95 os_config.get('users'), 'user', clean)
96 creators.append(users_dict)
98 # Associate new users to projects
100 for project_creator in projects_dict.values():
101 users = project_creator.project_settings.users
102 for user_name in users:
103 user_creator = users_dict.get(user_name)
105 project_creator.assoc_user(
106 user_creator.get_user())
109 flavors_dict = __create_instances(
110 os_creds_dict, OpenStackFlavor, FlavorConfig,
111 os_config.get('flavors'), 'flavor', clean, users_dict)
112 creators.append(flavors_dict)
115 qos_dict = __create_instances(
116 os_creds_dict, OpenStackQoS, QoSConfig,
117 os_config.get('qos_specs'), 'qos_spec', clean, users_dict)
118 creators.append(qos_dict)
120 # Create volume types
121 vol_type_dict = __create_instances(
122 os_creds_dict, OpenStackVolumeType, VolumeTypeConfig,
123 os_config.get('volume_types'), 'volume_type', clean,
125 creators.append(vol_type_dict)
128 vol_dict = __create_instances(
129 os_creds_dict, OpenStackVolume, VolumeConfig,
130 os_config.get('volumes'), 'volume', clean, users_dict)
131 creators.append(vol_dict)
134 images_dict = __create_instances(
135 os_creds_dict, OpenStackImage, ImageConfig,
136 os_config.get('images'), 'image', clean, users_dict)
137 creators.append(images_dict)
140 networks_dict = __create_instances(
141 os_creds_dict, OpenStackNetwork, NetworkConfig,
142 os_config.get('networks'), 'network', clean, users_dict)
143 creators.append(networks_dict)
146 routers_dict = __create_instances(
147 os_creds_dict, OpenStackRouter, RouterConfig,
148 os_config.get('routers'), 'router', clean, users_dict)
149 creators.append(routers_dict)
152 keypairs_dict = __create_instances(
153 os_creds_dict, OpenStackKeypair, KeypairConfig,
154 os_config.get('keypairs'), 'keypair', clean, users_dict)
155 creators.append(keypairs_dict)
157 # Create security groups
158 creators.append(__create_instances(
159 os_creds_dict, OpenStackSecurityGroup,
161 os_config.get('security_groups'), 'security_group', clean,
165 vm_dict = __create_vm_instances(
166 os_creds_dict, users_dict, os_config.get('instances'),
167 images_dict, keypairs_dict, clean)
168 creators.append(vm_dict)
170 'Completed creating/retrieving all configured instances')
172 # Must enter either block
174 # Cleanup Environment
175 __cleanup(creators, clean_image)
178 ansible_config = config.get('ansible')
179 if ansible_config and vm_dict:
180 if not __apply_ansible_playbooks(
181 ansible_config, os_creds_dict, vm_dict, images_dict,
182 flavors_dict, networks_dict, routers_dict, tmplt_file):
183 logger.error("Problem applying ansible playbooks")
186 def __get_creds_dict(os_conn_config):
188 Returns a dict of OSCreds where the key is the creds name.
189 For backwards compatibility, credentials not contained in a list (only
190 one) will be returned with the key of None
191 :param os_conn_config: the credential configuration
192 :return: a dict of OSCreds objects
194 if 'connection' in os_conn_config:
195 return {DEFAULT_CREDS_KEY: __get_os_credentials(os_conn_config)}
196 elif 'connections' in os_conn_config:
198 for os_conn_dict in os_conn_config['connections']:
199 config = os_conn_dict.get('connection')
201 raise Exception('Invalid connection format')
203 name = config.get('name')
205 raise Exception('Connection config requires a name field')
207 out[name] = __get_os_credentials(os_conn_dict)
211 def __get_creds(os_creds_dict, os_user_dict, inst_config):
213 Returns the appropriate credentials
214 :param os_creds_dict: a dictionary of OSCreds objects where the name is the
216 :param os_user_dict: a dictionary of OpenStackUser objects where the name
219 :return: an OSCreds instance or None
221 os_creds = os_creds_dict.get(DEFAULT_CREDS_KEY)
222 if 'os_user' in inst_config:
223 os_user_conf = inst_config['os_user']
224 if 'name' in os_user_conf:
225 user_creator = os_user_dict.get(os_user_conf['name'])
227 return user_creator.get_os_creds(
228 project_name=os_user_conf.get('project_name'))
229 elif 'os_creds_name' in inst_config:
230 if 'os_creds_name' in inst_config:
231 os_creds = os_creds_dict[inst_config['os_creds_name']]
235 def __get_os_credentials(os_conn_config):
237 Returns an object containing all of the information required to access
239 :param os_conn_config: The configuration holding the credentials
240 :return: an OSCreds instance
242 config = os_conn_config.get('connection')
244 raise Exception('Invalid connection configuration')
246 proxy_settings = None
247 http_proxy = config.get('http_proxy')
249 tokens = re.split(':', http_proxy)
250 ssh_proxy_cmd = config.get('ssh_proxy_cmd')
251 proxy_settings = ProxySettings(host=tokens[0], port=tokens[1],
252 ssh_proxy_cmd=ssh_proxy_cmd)
254 if 'proxy_settings' in config:
255 host = config['proxy_settings'].get('host')
256 port = config['proxy_settings'].get('port')
257 if host and host != 'None' and port and port != 'None':
258 proxy_settings = ProxySettings(**config['proxy_settings'])
261 config['proxy_settings'] = proxy_settings
263 if config.get('proxy_settings'):
264 del config['proxy_settings']
266 return OSCreds(**config)
269 def __parse_ports_config(config):
271 Parses the "ports" configuration
272 :param config: The dictionary to parse
273 :return: a list of PortConfig objects
276 for port_config in config:
277 out.append(PortConfig(**port_config.get('port')))
281 def __create_instances(os_creds_dict, creator_class, config_class, config,
282 config_key, cleanup=False, os_users_dict=None):
284 Returns a dictionary of SNAPS creator objects where the key is the name
285 :param os_creds_dict: Dictionary of OSCreds objects where the key is the
287 :param config: The list of configurations for the same type
288 :param config_key: The list of configurations for the same type
289 :param cleanup: Denotes whether or not this is being called for cleanup
295 for config_dict in config:
296 inst_config = config_dict.get(config_key)
298 creds = __get_creds(os_creds_dict, os_users_dict, inst_config)
300 creator = creator_class(
302 config_class(**inst_config))
308 except Unauthorized as e:
310 'Unable to initialize creator [%s] - %s',
315 out[inst_config['name']] = creator
317 raise Exception('Unable to instantiate creator')
319 logger.info('Initialized configured %ss', config_key)
324 def __create_vm_instances(os_creds_dict, os_users_dict, instances_config,
325 image_dict, keypairs_dict, cleanup=False):
327 Returns a dictionary of OpenStackVmInstance objects where the key is the
329 :param os_creds_dict: Dictionary of OSCreds objects where the key is the
331 :param os_users_dict: Dictionary of OpenStackUser objects where the key is
333 :param instances_config: The list of VM instance configurations
334 :param image_dict: A dictionary of images that will probably be used to
335 instantiate the VM instance
336 :param keypairs_dict: A dictionary of keypairs that will probably be used
337 to instantiate the VM instance
338 :param cleanup: Denotes whether or not this is being called for cleanup
344 for instance_config in instances_config:
345 conf = instance_config.get('instance')
348 image_creator = image_dict.get(conf.get('imageName'))
350 instance_settings = VmInstanceConfig(
351 **instance_config['instance'])
352 kp_creator = keypairs_dict.get(
353 conf.get('keypair_name'))
357 'name']] = deploy_utils.create_vm_instance(
359 os_creds_dict, os_users_dict, conf),
361 image_creator.image_settings,
362 keypair_creator=kp_creator,
364 except Unauthorized as e:
366 logger.warn('Unable to initialize VM - %s', e)
369 raise Exception('Image creator instance not found.'
370 ' Cannot instantiate')
373 raise Exception('Image dictionary is None. Cannot '
376 raise Exception('Instance configuration is None. Cannot '
378 logger.info('Created configured instances')
383 def __apply_ansible_playbooks(ansible_configs, os_creds_dict, vm_dict,
384 image_dict, flavor_dict, networks_dict,
385 routers_dict, tmplt_file):
387 Applies ansible playbooks to running VMs with floating IPs
388 :param ansible_configs: a list of Ansible configurations
389 :param os_creds_dict: Dictionary of OSCreds objects where the key is the
391 :param vm_dict: the dictionary of newly instantiated VMs where the name is
393 :param image_dict: the dictionary of newly instantiated images where the
395 :param flavor_dict: the dictionary of newly instantiated flavors where the
397 :param networks_dict: the dictionary of newly instantiated networks where
399 :param routers_dict: the dictionary of newly instantiated routers where
401 :param tmplt_file: the path of the SNAPS-OO template file for setting the
402 CWD so playbook location is relative to the deployment
404 :return: t/f - true if successful
406 logger.info("Applying Ansible Playbooks")
408 # Set CWD so the deployment file's playbook location can leverage
410 orig_cwd = os.getcwd()
411 env_dir = os.path.dirname(tmplt_file)
415 for ansible_config in ansible_configs:
416 # Ensure all hosts are accepting SSH session requests
417 for vm_name in ansible_config['hosts']:
418 vm_inst = vm_dict.get(vm_name)
420 if not vm_inst.vm_ssh_active(block=True):
422 'Timeout waiting for instance to respond to '
426 __apply_ansible_playbook(
427 ansible_config, os_creds_dict, vm_dict, image_dict,
428 flavor_dict, networks_dict, routers_dict)
430 # Return to original directory
436 def __apply_ansible_playbook(ansible_config, os_creds_dict, vm_dict,
437 image_dict, flavor_dict, networks_dict,
440 Applies an Ansible configuration setting
441 :param ansible_config: the configuration settings
442 :param os_creds_dict: dict where the key is the name and value is OSCreds
443 :param vm_dict: the dictionary of newly instantiated VMs where the name is
445 :param image_dict: the dictionary of newly instantiated images where the
447 :param flavor_dict: the dictionary of newly instantiated flavors where the
449 :param networks_dict: the dictionary of newly instantiated networks where
451 :param routers_dict: the dictionary of newly instantiated routers where
455 (remote_user, floating_ips, private_key_filepath,
456 proxy_settings) = __get_connection_info(
457 ansible_config, vm_dict)
459 for key, vm_creator in vm_dict.items():
460 fip = vm_creator.get_floating_ip()
461 if fip and fip.ip in floating_ips:
462 if not vm_creator.cloud_init_complete(block=True):
464 'Cannot apply playbooks as cloud-init has not '
467 variables = __get_variables(
468 ansible_config.get('variables'), os_creds_dict, vm_dict,
469 image_dict, flavor_dict, networks_dict, routers_dict)
471 ansible_utils.apply_playbook(
472 ansible_config['playbook_location'], floating_ips, remote_user,
473 ssh_priv_key_file_path=private_key_filepath,
475 proxy_setting=proxy_settings)
477 if 'post_processing' in ansible_config:
478 post_proc_config = ansible_config['post_processing']
479 if 'sleep' in post_proc_config:
480 time.sleep(post_proc_config['sleep'])
481 if 'reboot' in post_proc_config:
482 for vm_name in post_proc_config['reboot']:
483 if vm_name in vm_dict:
484 logger.info('Rebooting VM - %s', vm_name)
485 vm_dict[vm_name].reboot(RebootType.hard)
488 def __get_connection_info(ansible_config, vm_dict):
490 Returns a tuple of data required for connecting to the running VMs
491 (remote_user, [floating_ips], private_key_filepath, proxy_settings)
492 :param ansible_config: the configuration settings
493 :param vm_dict: the dictionary of VMs where the VM name is the key
494 :return: tuple where the first element is the user and the second is a list
495 of floating IPs and the third is the
496 private key file location and the fourth is an instance of the
497 snaps.ProxySettings class
498 (note: in order to work, each of the hosts need to have the same sudo_user
499 and private key file location values)
501 if ansible_config.get('hosts'):
502 hosts = ansible_config['hosts']
504 floating_ips = list()
507 proxy_settings = None
509 vm = vm_dict.get(host)
511 fip = vm.get_floating_ip()
513 remote_user = vm.get_image_user()
516 floating_ips.append(fip.ip)
519 'Could not find floating IP for VM - ' +
522 pk_file = vm.keypair_settings.private_filepath
523 proxy_settings = vm.get_os_creds().proxy_settings
525 logger.error('Could not locate VM with name - ' + host)
527 return remote_user, floating_ips, pk_file, proxy_settings
531 def __get_variables(var_config, os_creds_dict, vm_dict, image_dict,
532 flavor_dict, networks_dict, routers_dict):
534 Returns a dictionary of substitution variables to be used for Ansible
536 :param var_config: the variable configuration settings
537 :param os_creds_dict: dict where the key is the name and value is OSCreds
538 :param vm_dict: the dictionary of newly instantiated VMs where the name is
540 :param image_dict: the dictionary of newly instantiated images where the
542 :param flavor_dict: the dictionary of newly instantiated flavors where the
544 :param networks_dict: the dictionary of newly instantiated networks where
546 :param routers_dict: the dictionary of newly instantiated routers where
548 :return: dictionary or None
550 if var_config and vm_dict and len(vm_dict) > 0:
552 for key, value in var_config.items():
553 value = __get_variable_value(
554 value, os_creds_dict, vm_dict, image_dict, flavor_dict,
555 networks_dict, routers_dict)
557 variables[key] = value
559 "Set Jinga2 variable with key [%s] the value [%s]",
563 'Key - [' + str(key) + '] or Value [' + str(value)
564 + '] must not be None')
569 def __get_variable_value(var_config_values, os_creds_dict, vm_dict, image_dict,
570 flavor_dict, networks_dict, routers_dict):
572 Returns the associated variable value for use by Ansible for substitution
574 :param var_config_values: the configuration dictionary
575 :param os_creds_dict: dict where the key is the name and value is OSCreds
576 :param vm_dict: the dictionary of newly instantiated VMs where the name is
578 :param image_dict: the dictionary of newly instantiated images where the
580 :param flavor_dict: the dictionary of newly instantiated flavors where the
582 :param networks_dict: the dictionary of newly instantiated networks where
584 :param routers_dict: the dictionary of newly instantiated routers where
588 if var_config_values['type'] == 'string':
589 return __get_string_variable_value(var_config_values)
590 if var_config_values['type'] == 'vm-attr':
591 return __get_vm_attr_variable_value(var_config_values, vm_dict)
592 if var_config_values['type'] == 'os_creds':
593 return __get_os_creds_variable_value(var_config_values, os_creds_dict)
594 if var_config_values['type'] == 'os_creds_dict':
595 return str(__get_os_creds_dict(var_config_values, os_creds_dict))
596 if var_config_values['type'] == 'network':
597 return __get_network_variable_value(var_config_values, networks_dict)
598 if var_config_values['type'] == 'router':
599 return __get_router_variable_value(var_config_values, routers_dict,
601 if var_config_values['type'] == 'port':
602 return __get_vm_port_variable_value(var_config_values, vm_dict)
603 if var_config_values['type'] == 'floating_ip':
604 return __get_vm_fip_variable_value(var_config_values, vm_dict)
605 if var_config_values['type'] == 'image':
606 return __get_image_variable_value(var_config_values, image_dict)
607 if var_config_values['type'] == 'flavor':
608 return __get_flavor_variable_value(var_config_values, flavor_dict)
609 if var_config_values['type'] == 'vm-yaml':
610 return __create_yaml(var_config_values, vm_dict)
614 def __get_string_variable_value(var_config_values):
616 Returns the associated string value
617 :param var_config_values: the configuration dictionary
618 :return: the value contained in the dictionary with the key 'value'
620 return var_config_values['value']
623 def __get_vm_attr_variable_value(var_config_values, vm_dict):
625 Returns the associated value contained on a VM instance
626 :param var_config_values: the configuration dictionary
627 :param vm_dict: the dictionary containing all VMs where the key is the VM's
631 vm = vm_dict.get(var_config_values['vm_name'])
633 if var_config_values['value'] == 'floating_ip':
634 return vm.get_floating_ip().ip
635 if var_config_values['value'] == 'image_user':
636 return vm.get_image_user()
639 def __get_os_creds_variable_value(var_config_values, os_creds_dict):
641 Returns the associated OS credentials value
642 :param var_config_values: the configuration dictionary
643 :param os_creds_dict: dict of OpenStack credentials where the key is the
647 if 'creds_name' in var_config_values:
648 os_creds = os_creds_dict.get[var_config_values['creds_name']]
650 os_creds = os_creds_dict.get('admin-creds')
653 if var_config_values['value'] == 'username':
654 logger.info("Returning OS username")
655 return os_creds.username
656 elif var_config_values['value'] == 'password':
657 logger.info("Returning OS password")
658 return os_creds.password
659 elif var_config_values['value'] == 'auth_url':
660 logger.info("Returning OS auth_url")
661 return os_creds.auth_url
662 elif var_config_values['value'] == 'project_name':
663 logger.info("Returning OS project_name")
664 return os_creds.project_name
667 def __get_os_creds_dict(var_config_values, os_creds_dict):
669 Returns the associated OS credentials as a dict
670 :param var_config_values: the configuration dictionary
671 :param os_creds_dict: dict of creds where the key is the username
672 :return: the value dict
674 if 'creds_name' in var_config_values:
675 os_creds = os_creds_dict.get[var_config_values['creds_name']]
677 os_creds = os_creds_dict.get('admin-creds')
679 return os_creds.to_dict()
682 def __get_network_variable_value(var_config_values, networks_dict):
684 Returns the associated network value
685 :param var_config_values: the configuration dictionary
686 :param networks_dict: the dictionary containing all networks where the key
690 net_name = var_config_values.get('network_name')
692 if net_name and networks_dict.get(net_name):
693 network_creator = networks_dict[net_name]
695 if 'subnet_name' in var_config_values:
696 subnet_name = var_config_values.get('subnet_name')
698 for subnet in network_creator.get_network().subnets:
699 if subnet_name == subnet.name:
700 if 'value' in var_config_values:
701 if 'gateway_ip' == var_config_values['value']:
702 return subnet.gateway_ip
703 if 'ip_range' == var_config_values['value']:
704 return subnet.start + ' ' + subnet.end
705 if 'ip_range_start' == var_config_values['value']:
707 if 'ip_range_end' == var_config_values['value']:
709 if 'cidr' == var_config_values['value']:
711 if 'cidr_ip' == var_config_values['value']:
712 cidr_split = subnet.cidr.split('/')
714 if 'netmask' == var_config_values['value']:
715 cidr_split = subnet.cidr.split('/')
716 cidr_bits = 32 - int(cidr_split[1])
717 netmask = socket.inet_ntoa(
719 '!I', (1 << 32) - (1 << cidr_bits)))
721 if 'broadcast_ip' == var_config_values['value']:
722 end_split = subnet.end.split('.')
724 end_split[0] + '.' + end_split[1] + '.'
725 + end_split[2] + '.255')
729 def __get_router_variable_value(var_config_values, routers_dict,
732 Returns the associated network value
733 :param var_config_values: the configuration dictionary
734 :param routers_dict: the dictionary containing all networks where the key
736 :param os_creds_dict: dict of OpenStack credentials where the key is the
740 if 'creds_name' in var_config_values:
741 os_creds = os_creds_dict.get[var_config_values['creds_name']]
743 os_creds = os_creds_dict.get('admin-creds')
745 router_name = var_config_values.get('router_name')
746 router_creator = routers_dict[router_name]
749 if 'external_fixed_ip' == var_config_values.get('attr'):
750 session = keystone_utils.keystone_session(os_creds)
751 neutron = neutron_utils.neutron_client(os_creds, session)
753 ext_nets = neutron_utils.get_external_networks(neutron)
755 subnet_name = var_config_values.get('subnet_name')
757 for ext_net in ext_nets:
758 for subnet in ext_net.subnets:
759 if subnet_name == subnet.name:
760 router = router_creator.get_router()
761 for fixed_ips in router.external_fixed_ips:
762 if subnet.id == fixed_ips['subnet_id']:
763 return fixed_ips['ip_address']
765 keystone_utils.close_session(session)
768 def __get_vm_port_variable_value(var_config_values, vm_dict):
770 Returns the associated OS credentials value
771 :param var_config_values: the configuration dictionary
772 :param vm_dict: the dictionary containing all VMs where the key is the VM's
776 port_name = var_config_values.get('port_name')
777 vm_name = var_config_values.get('vm_name')
779 if port_name and vm_name:
780 vm = vm_dict.get(vm_name)
782 for vm_port in vm.get_vm_inst().ports:
783 if vm_port.name == port_name:
784 port_value_id = var_config_values.get('port_value')
786 if port_value_id == 'mac_address':
787 return vm_port.mac_address
788 if port_value_id == 'ip_address':
789 return vm_port.ips[0]['ip_address']
792 def __get_vm_fip_variable_value(var_config_values, vm_dict):
794 Returns the floating IP value if found
795 :param var_config_values: the configuration dictionary
796 :param vm_dict: the dictionary containing all VMs where the key is the VM's
798 :return: the floating IP string value or None
800 fip_name = var_config_values.get('fip_name')
801 vm_name = var_config_values.get('vm_name')
804 vm = vm_dict.get(vm_name)
806 fip = vm.get_floating_ip(fip_name)
811 def __get_image_variable_value(var_config_values, image_dict):
813 Returns the associated image value
814 :param var_config_values: the configuration dictionary
815 :param image_dict: the dictionary containing all images where the key is
820 if var_config_values.get('image_name'):
821 image_creator = image_dict.get(var_config_values['image_name'])
823 if (var_config_values.get('value')
824 and var_config_values['value'] == 'id'):
825 return image_creator.get_image().id
826 if (var_config_values.get('value')
827 and var_config_values['value'] == 'user'):
828 return image_creator.image_settings.image_user
831 def __get_flavor_variable_value(var_config_values, flavor_dict):
833 Returns the associated flavor value
834 :param var_config_values: the configuration dictionary
835 :param flavor_dict: the dictionary containing all flavor creators where the
837 :return: the value or None
840 if var_config_values.get('flavor_name'):
841 flavor_creator = flavor_dict.get(var_config_values['flavor_name'])
843 if (var_config_values.get('value')
844 and var_config_values['value'] == 'id'):
845 return flavor_creator.get_flavor().id
848 def __create_yaml(var_config_values, vm_dict):
850 Creates a yaml file containing an OpenStack pod's credentials with a list
851 of server IDs that can be used for obtaining SNAPS-OO instances for
852 manipulation such as rebooting
853 :param var_config_values: the configuration dictionary
854 :param vm_dict: the dictionary containing all vm creators where the
856 :return: the name of the generated file
859 out_dict['vms'] = list()
860 req_vm_names = var_config_values.get('vms')
862 for name, vm_creator in vm_dict.items():
863 vm_inst = vm_creator.get_vm_inst()
864 if vm_inst and vm_inst.name in req_vm_names:
865 out_dict['vms'].append({
866 'name': str(vm_inst.name),
867 'id': str(vm_inst.id),
868 'os_creds': vm_creator.get_os_creds().to_dict()
871 out_file = file_utils.persist_dict_to_yaml(
872 out_dict, var_config_values.get('file_name'))
878 def __cleanup(creators, clean_image=False):
880 Cleans up environment
881 :param creators: the list of creators by type
882 :param clean_image: when true
885 for creator_dict in reversed(creators):
886 for key, creator in creator_dict.items():
887 if ((isinstance(creator, OpenStackImage) and clean_image)
888 or not isinstance(creator, OpenStackImage)):