def execute(self): templates = self.args['<templates>'] try: if not login_lib.check_env(): print('you are not authorized.') else: login_lib.load_env_file() libs_dir = os.path.dirname(os.path.realpath(__file__)) # os.chdir("{}/templates/{}".format(libs_dir,templates)) template_file = "{}/templates/{}/index.yaml".format( libs_dir, templates) template_env = "{}/templates/{}/env.yaml".format( libs_dir, templates) heat_url = 'https://heat.wjv-1.neo.id:8004/v1/%s' % os.environ.get( "OS_PROJECT_ID") # template = open(templates_index) env = open(template_env) files, template = template_utils.process_template_path( template_file) heat = heat_client.Client('1', endpoint=heat_url, token=os.environ.get("OS_TOKEN")) heat.stacks.create(stack_name=templates, template=template, environment=env.read(), files=files) except Exception as e: print(e) else: pass finally: pass
def do_create(initialize, session=None): try: heat = get_heat_client(session) for deploy in initialize: deploy_init_file = "{}/init.yml".format(deploy["dir"]) deploy_file = utils.yaml_parser(deploy_init_file)["create"] """ template """ deploy_template = "{}/{}".format(deploy["dir"], deploy_file) deploy_name = deploy["project"] files, template = template_utils.process_template_path( deploy_template) """Create Stack""" utils.log_info("Create {} stack....".format(deploy["project"])) if not deploy["env_file"]: heat.stacks.create(stack_name=deploy_name, template=template, files=files) else: deploy_env_file = open(deploy["env_file"]) heat.stacks.create( stack_name=deploy_name, template=template, environment=deploy_env_file.read(), files=files, ) if len(initialize) > 0: time.sleep(8) except Exception as e: utils.log_err(e) else: pass finally: pass
def create_stack(heat_client, stack_name, template, parameters, environment=None): # process_template_path expects a path to a file object, create # a temporary named file and write the contents of template to it with tempfile.NamedTemporaryFile(mode='w+t') as fd: fd.write(template) fd.seek(0) files, processed_template = template_utils.process_template_path( fd.name) stack_params = { 'stack_name': stack_name, 'template': processed_template, 'parameters': parameters, 'environment': environment, 'files': files, } stack = heat_client.stacks.create(**stack_params)['stack'] LOG.info('New stack: %s', stack) wait_stack_completion(heat_client, stack['id']) return stack['id']
def _validate(heat_client, args): tpl_files, template = template_utils.process_template_path( args.template, object_request=http.authenticated_fetcher(heat_client)) env_files_list = [] env_files, env = template_utils.process_multiple_environments_and_files( env_paths=args.environment, env_list_tracker=env_files_list) fields = { 'template': template, 'parameters': heat_utils.format_parameters(args.parameter), 'files': dict(list(tpl_files.items()) + list(env_files.items())), 'environment': env, } if args.ignore_errors: fields['ignore_errors'] = args.ignore_errors # If one or more environments is found, pass the listing to the server if env_files_list: fields['environment_files'] = env_files_list if args.show_nested: fields['show_nested'] = args.show_nested validation = heat_client.stacks.validate(**fields) data = list(six.itervalues(validation)) columns = list(six.iterkeys(validation)) return columns, data
def deploy_app(new_sess, neutron, keystone, new_project): # Rebuilding app new_project_obj = [ prj for prj in keystone.projects.list() if prj.name == new_project ] neutron_resources = neutron.list_networks(project_id=new_project_obj[0].id) # Redeployng App #Assuming App management netwrk will have MGMT in the name and DataPlane for dp network mgmt = [ net for net in neutron_resources['networks'] if 'MGMT' in net['name'] ] dp = [ net for net in neutron_resources['networks'] if 'DataPlane' in net['name'] ] resources_dict = {} resources_dict['Management_net'] = mgmt[0]['id'] resources_dict['Mgmt_subnet'] = mgmt[0]['subnets'][0] resources_dict['DataPlane_net'] = dp[0]['id'] resources_dict['DP_subnet'] = dp[0]['subnets'][0] heat = heat_client('1', session=new_sess) files, template = template_utils.process_template_path( 'service-deployment.yaml') res = heat.stacks.create(stack_name='App', template=template, files=files, parameters=resources_dict) print "App redeployment was started"
def pre_expand_pnda(self, node_counts): ''' Use the Openstack heatclient API to expand a stack ''' # Generate template files self._update_template_file(self._flavor, node_counts['datanodes'], node_counts['kafka_nodes']) stack_name = self._cluster heat_session = self._get_heat_session() templates_path = os.getcwd() + '/cli/' + '_resources_{}-{}'.format( self._flavor, self._cluster) template_file = templates_path + "/pnda.yaml" env_file = templates_path + "/pnda_env.yaml" env_param = [env_file] tpl_files, tpl_template = template_utils.process_template_path( template_file) env_files, env_template = template_utils.process_multiple_environments_and_files( env_paths=env_param) files_all = dict(list(tpl_files.items()) + list(env_files.items())) try: heat_session.stacks.update(stack_id=stack_name, template=tpl_template, files=files_all, environment=env_template, timeout_mins=120) stack_status_body = heat_session.stacks.get(stack_id=stack_name) stack_status = 'UPDATING' stack_status_new = None stack_id = stack_status_body.stack_name except exc.HTTPBadRequest as exp: error_state = exp.error CONSOLE.error("Bad request update stack failed: %s", error_state) sys.exit(1) while stack_status in [ 'UPDATE_IN_PROGRESS', 'UPDATING', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS' ]: time.sleep(5) if stack_status != stack_status_new: if stack_status_new is not None: stack_status = stack_status_new CONSOLE.info('Stack is: %s', stack_status) else: CONSOLE.debug('Stack is: %s', stack_status) stack_status_body = heat_session.stacks.get(stack_id) stack_status_new = stack_status_body.stack_status if stack_status != 'UPDATE_COMPLETE': CONSOLE.error('Stack did not come up, status is: %s', stack_status) sys.exit(1) self.clear_instance_map_cache()
def get_heat_temp_files(self, template, env_file=None): try: env = None files = None temp = None files, temp = template_utils.process_template_path(template) if env_file: files, env = template_utils.process_environment_and_files( env_file, template) return files, temp, env except Exception as err: logger.debug(err) raise
def stack_create(self, hc, HOT_path, env_path, stack_name): hot_path = self._get_resource_path(HOT_path) env_path = self._get_resource_path(env_path) with open(env_path, "r") as envFile: environment = yaml.load(envFile) files, template = template_utils.process_template_path(hot_path) stack = hc.stacks.create(stack_name=stack_name, template=template, environment=environment, files=files) return stack
def do_create(initialize, session=None): try: heat = get_heat_client(session) for deploy in initialize: deploy_init_file = "{}/init.yml".format(deploy["dir"]) deploy_file = utils.yaml_parser(deploy_init_file)["create"] """ template """ deploy_template = "{}/{}".format(deploy["dir"], deploy_file) deploy_name = deploy["project"] files, template = template_utils.process_template_path( deploy_template) """Create Stack""" utils.log_info("Create {} stack....".format(deploy["project"])) if not deploy["env_file"]: heat.stacks.create( stack_name=deploy_name, template=template, files=files) else: deploy_env_file = open(deploy["env_file"]) heat.stacks.create( stack_name=deploy_name, template=template, environment=deploy_env_file.read(), files=files) if (len(initialize) > 0): time.sleep(8) # if deploy["stack"] == "clusters": # utils.log_info("Generate {} private key...".format( # deploy["project"])) # wait_key = True # private_key_file = None # while wait_key: # out = get_pkey_from_stack( # deploy["project"]) # if out: # private_key_file = "{}/private_key.pem".format( # deploy["dir"]) # with open(private_key_file, "w") as pkey: # pkey.write(out) # os.chmod(private_key_file, 0o600) # utils.log_info("Done...") # wait_key = False # else: # time.sleep(5) except Exception as e: utils.log_err(e) else: pass finally: pass
def start(stack_name): global stack_active global stackname stackname = stack_name template_name = 'Heat_template_start_instance.yml' files, template = template_utils.process_template_path(template_name) if stack_active: abort(400, 'A stack is already active') try: hc.stacks.create(stack_name=stack_name, template=template, files=files) time.sleep(10) stacks = hc.stacks.list(filters={'stack_name': stack_name}) stack = next(stacks) stack_status = stack.status while stack_status == 'IN_PROGRESS': stacks = hc.stacks.list(filters={'stack_name': stack_name}) stack = next(stacks) stack_output = hc.stacks.output_list(stack.id) print 'Build in progress, sleep for 5 seconds...' time.sleep(5) stack_status = stack.status stack_active = True result = {} for line in stack_output['outputs']: output_value = line['output_key'] result[output_value] = hc.stacks.output_show( stack.id, output_value) write_to_hosts_file(result) write_to_ansible_hosts_file(result) write_hosts_to_master_and_worker(result) token = subprocess.check_output( 'ssh -i group8key.pem -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -q ubuntu@' + result['ansible_ip']['output']['output_value'] + " 'sh ~/get_token.sh'") result['token'] = token return jsonify(result) # redirect('http://IP.TO.SPARK.MASTER:60060/', 302, jsonify(result)) except heatclient.exc.HTTPConflict as e: abort(400, 'Stack already exists : %s %s' % (e.error, stack_name)) except heatclient.exc.HTTPBadRequest as e: abort(400, 'Bad request : %s' % e.error)
def create_stacks(num_stacks, nested, template_file): tpl_files, template = template_utils.process_template_path( template_file, object_request=http.authenticated_fetcher(TempestClients.heat())) for i in range(num_stacks): stack_name = 'stack_%s' % i + ('_nested' if nested else '') TempestClients.heat().stacks.create(stack_name=stack_name, template=template, files=tpl_files, parameters={}) wait_for_status(45, _check_num_stacks, num_stacks=num_stacks, state='CREATE_COMPLETE') time.sleep(2)
def take_action(self, parsed_args): self.log.debug('take_action(%s)', parsed_args) client = self.app.client_manager.orchestration tpl_files, template = template_utils.process_template_path( parsed_args.template, object_request=_authenticated_fetcher(client)) env_files, env = ( template_utils.process_multiple_environments_and_files( env_paths=parsed_args.environment)) parameters = heat_utils.format_all_parameters( parsed_args.parameter, parsed_args.parameter_file, parsed_args.template) if parsed_args.pre_create: template_utils.hooks_to_env(env, parsed_args.pre_create, 'pre-create') fields = { 'stack_name': parsed_args.name, 'disable_rollback': not parsed_args.enable_rollback, 'parameters': parameters, 'template': template, 'files': dict(list(tpl_files.items()) + list(env_files.items())), 'environment': env } if parsed_args.tags: fields['tags'] = parsed_args.tags if parsed_args.timeout: fields['timeout_mins'] = parsed_args.timeout stack = client.stacks.create(**fields)['stack'] if parsed_args.wait: if not utils.wait_for_status(client.stacks.get, parsed_args.name, status_field='stack_status', success_status='create_complete', error_status='create_failed'): msg = _('Stack %s failed to create.') % parsed_args.name raise exc.CommandError(msg) return _show_stack(client, stack['id'], format='table', short=True)
def create_stack(self, stack_name, stack_file_path, heat_parameters): files, template = template_utils.process_template_path(stack_file_path) stack_created = self.heatclient.stacks.create( stack_name=stack_name, template=template, parameters=heat_parameters, files=files) stack = self.heatclient.stacks.get(stack_created['stack']['id'], resolve_outputs=True) # Poll at 5 second intervals, until the status is no longer 'BUILD' while stack.stack_status == 'CREATE_IN_PROGRESS': print('waiting..') time.sleep(5) stack = self.heatclient.stacks.get(stack_created['stack']['id'], resolve_outputs=True) if stack.stack_status == 'CREATE_COMPLETE': return stack else: RapidLog.exception('Error in stack deployment')
def take_action(self, parsed_args): self.log.debug('take_action(%s)', parsed_args) client = self.app.client_manager.orchestration tpl_files, template = template_utils.process_template_path( parsed_args.template, object_request=_authenticated_fetcher(client), existing=parsed_args.existing) env_files, env = ( template_utils.process_multiple_environments_and_files( env_paths=parsed_args.environment)) parameters = heat_utils.format_all_parameters( parsed_args.parameter, parsed_args.parameter_file, parsed_args.template) if parsed_args.pre_update: template_utils.hooks_to_env(env, parsed_args.pre_update, 'pre-update') fields = { 'stack_id': parsed_args.stack, 'parameters': parameters, 'existing': parsed_args.existing, 'template': template, 'files': dict(list(tpl_files.items()) + list(env_files.items())), 'environment': env } if parsed_args.tags: fields['tags'] = parsed_args.tags if parsed_args.timeout: fields['timeout_mins'] = parsed_args.timeout if parsed_args.clear_parameter: fields['clear_parameters'] = list(parsed_args.clear_parameter) if parsed_args.rollback: rollback = parsed_args.rollback.strip().lower() if rollback not in ('enabled', 'disabled', 'keep'): msg = _('--rollback invalid value: %s') % parsed_args.rollback raise exc.CommandError(msg) if rollback != 'keep': fields['disable_rollback'] = rollback == 'disabled' if parsed_args.dry_run: changes = client.stacks.preview_update(**fields) fields = ['state', 'resource_name', 'resource_type', 'resource_identity'] columns = sorted(changes.get("resource_changes", {}).keys()) data = [heat_utils.json_formatter(changes["resource_changes"][key]) for key in columns] return columns, data client.stacks.update(**fields) if parsed_args.wait: if not utils.wait_for_status(client.stacks.get, parsed_args.stack, status_field='stack_status', success_status='update_complete', error_status='update_failed'): msg = _('Stack %s failed to update.') % parsed_args.stack raise exc.CommandError(msg) return _show_stack(client, parsed_args.stack, format='table', short=True)
Created on 2018/6/25 10:31 @author: mengph reach """ import yaml from heatclient import client as htclient from heatclient.common import template_utils from keystoneauth1 import loading, session yaml_name = "nic_qos.yaml" keystone_url_200 = "http://172.16.90.2:5000/v2.0" keystone_url_180_11 = "http://10.121.137.50:5000/v2.0" keystone_url_180_12 = "http://10.121.137.80:5000/v2.0" keystone_url_136_132 = "http://10.121.136.132:5000/v2.0" loader = loading.get_plugin_loader('password') auth = loader.load_from_options(auth_url=keystone_url_180_11, username="******", password="******", project_name="admin") sess = session.Session(auth=auth, verify=False) heat = htclient.Client(version="1", session=sess) files, template = template_utils.process_template_path(yaml_name) heat_parameters = open(yaml_name) # temp_params = yaml.load(heat_parameters) # heat_parameters.close()ls # print files,template # print temp_params["parameters"] # heat.stacks.create(stack_name="cmcc", template=template, parameters=temp_params["parameters"], files=files) heat.stacks.create(stack_name=yaml_name, template=template, files=files) print heat.stacks.list()
def take_action(self, parsed_args): self.log.debug('take_action(%s)', parsed_args) client = self.app.client_manager.orchestration tpl_files, template = template_utils.process_template_path( parsed_args.template, object_request=http.authenticated_fetcher(client)) env_files, env = ( template_utils.process_multiple_environments_and_files( env_paths=parsed_args.environment)) parameters = heat_utils.format_all_parameters( parsed_args.parameter, parsed_args.parameter_file, parsed_args.template) if parsed_args.pre_create: template_utils.hooks_to_env(env, parsed_args.pre_create, 'pre-create') fields = { 'stack_name': parsed_args.name, 'disable_rollback': not parsed_args.enable_rollback, 'parameters': parameters, 'template': template, 'files': dict(list(tpl_files.items()) + list(env_files.items())), 'environment': env } if parsed_args.tags: fields['tags'] = parsed_args.tags if parsed_args.timeout: fields['timeout_mins'] = parsed_args.timeout if parsed_args.dry_run: stack = client.stacks.preview(**fields) formatters = { 'description': heat_utils.text_wrap_formatter, 'template_description': heat_utils.text_wrap_formatter, 'stack_status_reason': heat_utils.text_wrap_formatter, 'parameters': heat_utils.json_formatter, 'outputs': heat_utils.json_formatter, 'resources': heat_utils.json_formatter, 'links': heat_utils.link_formatter, } columns = [] for key in stack.to_dict(): columns.append(key) columns.sort() return ( columns, utils.get_item_properties(stack, columns, formatters=formatters) ) stack = client.stacks.create(**fields)['stack'] if parsed_args.wait: stack_status, msg = event_utils.poll_for_events( client, parsed_args.name, action='CREATE') if stack_status == 'CREATE_FAILED': raise exc.CommandError(msg) return _show_stack(client, stack['id'], format='table', short=True)
def pre_install_pnda(self, node_counts): ''' Use the Openstack heatclient API to launch a stack that PNDA can be installed on The stack is defined in template files in the flavor specific heat-template directory ''' # Generate template files self._generate_template_file(self._flavor, node_counts['datanodes'], node_counts['opentsdb_nodes'], node_counts['kafka_nodes'], node_counts['zk_nodes']) stack_name = self._cluster heat_session = self._get_heat_session() templates_path = os.getcwd() + '/cli/' + '_resources_{}-{}'.format( self._flavor, self._cluster) template_file = templates_path + "/pnda.yaml" env_file = templates_path + "/pnda_env.yaml" config, ind, bsi = load_yaml_guess_indent(open(env_file)) parameters = config['parameters'] parameters['keyName'] = node_counts['keyname'] # remove extra parmeters for heat template exclude_section = [ 'INFRASTRUCTURE_TYPE', 'SSH_KEY', 'OS_USER', 'networkCidr', 'KEYSTONE_AUTH_URL', 'KEYSTONE_USER', 'KEYSTONE_PASSWORD', 'KEYSTONE_TENANT', 'KEYSTONE_AUTH_URL', 'KEYSTONE_AUTH_VERSION', 'KEYSTONE_REGION_NAME' ] for param in exclude_section: if param in parameters: del parameters[param] ruamel.yaml.round_trip_dump(config, open(env_file, 'w'), indent=ind, block_seq_indent=bsi) env_param = [env_file] tpl_files, tpl_template = template_utils.process_template_path( template_file) env_files, env_template = template_utils.process_multiple_environments_and_files( env_paths=env_param) files_all = dict(list(tpl_files.items()) + list(env_files.items())) try: status = heat_session.stacks.create(stack_name=stack_name, template=tpl_template, files=files_all, environment=env_template, timeout_mins=120) stack_id = status['stack']['id'] stack_status = 'CREATING' stack_status_new = None except exc.HTTPConflict as exp: error_state = exp.error CONSOLE.error("Stack already exist : %s %s", error_state, stack_name) sys.exit(1) except exc.HTTPBadRequest as exp: error_state = exp.error CONSOLE.error("Bad request stack creation failed: %s", error_state) sys.exit(1) while stack_status in ['CREATE_IN_PROGRESS', 'CREATING']: time.sleep(5) if stack_status != stack_status_new: if stack_status_new is not None: stack_status = stack_status_new CONSOLE.info('Stack is: %s', stack_status) else: CONSOLE.debug('Stack is: %s', stack_status) stack_status_body = heat_session.stacks.get(stack_id) stack_status_new = stack_status_body.stack_status if stack_status != 'CREATE_COMPLETE': CONSOLE.error('Stack did not come up, status is: %s', stack_status) sys.exit(1) self.fill_instance_map()
def take_action(self, parsed_args): self.log.debug('take_action(%s)', parsed_args) client = self.app.client_manager.orchestration tpl_files, template = template_utils.process_template_path( parsed_args.template, object_request=http.authenticated_fetcher(client), existing=parsed_args.existing) env_files, env = ( template_utils.process_multiple_environments_and_files( env_paths=parsed_args.environment)) parameters = heat_utils.format_all_parameters( parsed_args.parameter, parsed_args.parameter_file, parsed_args.template) if parsed_args.pre_update: template_utils.hooks_to_env(env, parsed_args.pre_update, 'pre-update') fields = { 'stack_id': parsed_args.stack, 'parameters': parameters, 'existing': parsed_args.existing, 'template': template, 'files': dict(list(tpl_files.items()) + list(env_files.items())), 'environment': env } if parsed_args.tags: fields['tags'] = parsed_args.tags if parsed_args.timeout: fields['timeout_mins'] = parsed_args.timeout if parsed_args.clear_parameter: fields['clear_parameters'] = list(parsed_args.clear_parameter) if parsed_args.rollback: rollback = parsed_args.rollback.strip().lower() if rollback not in ('enabled', 'disabled', 'keep'): msg = _('--rollback invalid value: %s') % parsed_args.rollback raise exc.CommandError(msg) if rollback != 'keep': fields['disable_rollback'] = rollback == 'disabled' if parsed_args.dry_run: changes = client.stacks.preview_update(**fields) fields = ['state', 'resource_name', 'resource_type', 'resource_identity'] columns = sorted(changes.get("resource_changes", {}).keys()) data = [heat_utils.json_formatter(changes["resource_changes"][key]) for key in columns] return columns, data if parsed_args.wait: # find the last event to use as the marker events = event_utils.get_events(client, stack_id=parsed_args.stack, event_args={'sort_dir': 'desc', 'limit': 1}) marker = events[0].id if events else None client.stacks.update(**fields) if parsed_args.wait: stack = client.stacks.get(parsed_args.stack) stack_status, msg = event_utils.poll_for_events( client, stack.stack_name, action='UPDATE', marker=marker) if stack_status == 'UPDATE_FAILED': raise exc.CommandError(msg) return _show_stack(client, parsed_args.stack, format='table', short=True)
def take_action(self, parsed_args): self.log.debug('take_action(%s)', parsed_args) client = self.app.client_manager.orchestration tpl_files, template = template_utils.process_template_path( parsed_args.template, object_request=http.authenticated_fetcher(client), existing=parsed_args.existing, fetch_child=parsed_args.files_container is None) env_files_list = [] env_files, env = ( template_utils.process_multiple_environments_and_files( env_paths=parsed_args.environment, env_list_tracker=env_files_list, fetch_env_files=parsed_args.files_container is None)) parameters = heat_utils.format_all_parameters( parsed_args.parameter, parsed_args.parameter_file, parsed_args.template) if parsed_args.pre_update: template_utils.hooks_to_env(env, parsed_args.pre_update, 'pre-update') fields = { 'stack_id': parsed_args.stack, 'parameters': parameters, 'existing': parsed_args.existing, 'template': template, 'files': dict(list(tpl_files.items()) + list(env_files.items())), 'environment': env } # If one or more environments is found, pass the listing to the server if env_files_list: fields['environment_files'] = env_files_list if parsed_args.files_container: fields['files_container'] = parsed_args.files_container if parsed_args.tags: fields['tags'] = parsed_args.tags if parsed_args.timeout: fields['timeout_mins'] = parsed_args.timeout if parsed_args.clear_parameter: fields['clear_parameters'] = list(parsed_args.clear_parameter) if parsed_args.rollback: rollback = parsed_args.rollback.strip().lower() if rollback not in ('enabled', 'disabled', 'keep'): msg = _('--rollback invalid value: %s') % parsed_args.rollback raise exc.CommandError(msg) if rollback != 'keep': fields['disable_rollback'] = rollback == 'disabled' if parsed_args.dry_run: if parsed_args.show_nested: fields['show_nested'] = parsed_args.show_nested changes = client.stacks.preview_update(**fields) fields = [ 'state', 'resource_name', 'resource_type', 'resource_identity' ] columns = sorted(changes.get("resource_changes", {}).keys()) data = [ heat_utils.json_formatter(changes["resource_changes"][key]) for key in columns ] return columns, data if parsed_args.wait: # find the last event to use as the marker events = event_utils.get_events(client, stack_id=parsed_args.stack, event_args={'sort_dir': 'desc'}, limit=1) marker = events[0].id if events else None if parsed_args.converge: fields['converge'] = True client.stacks.update(**fields) if parsed_args.wait: stack = client.stacks.get(parsed_args.stack) stack_status, msg = event_utils.poll_for_events(client, stack.stack_name, action='UPDATE', marker=marker) if stack_status == 'UPDATE_FAILED': raise exc.CommandError(msg) return _show_stack(client, parsed_args.stack, format='table', short=True)
def take_action(self, parsed_args): self.log.debug('take_action(%s)', parsed_args) client = self.app.client_manager.orchestration tpl_files, template = template_utils.process_template_path( parsed_args.template, object_request=http.authenticated_fetcher(client), fetch_child=parsed_args.files_container is None) env_files_list = [] env_files, env = ( template_utils.process_multiple_environments_and_files( env_paths=parsed_args.environment, env_list_tracker=env_files_list, fetch_env_files=parsed_args.files_container is None)) parameters = heat_utils.format_all_parameters( parsed_args.parameter, parsed_args.parameter_file, parsed_args.template) if parsed_args.pre_create: template_utils.hooks_to_env(env, parsed_args.pre_create, 'pre-create') fields = { 'stack_name': parsed_args.name, 'disable_rollback': not parsed_args.enable_rollback, 'parameters': parameters, 'template': template, 'files': dict(list(tpl_files.items()) + list(env_files.items())), 'environment': env } # If one or more environments is found, pass the listing to the server if env_files_list: fields['environment_files'] = env_files_list if parsed_args.files_container: fields['files_container'] = parsed_args.files_container if parsed_args.tags: fields['tags'] = parsed_args.tags if parsed_args.timeout: fields['timeout_mins'] = parsed_args.timeout if parsed_args.dry_run: stack = client.stacks.preview(**fields) formatters = { 'description': heat_utils.text_wrap_formatter, 'template_description': heat_utils.text_wrap_formatter, 'stack_status_reason': heat_utils.text_wrap_formatter, 'parameters': heat_utils.json_formatter, 'outputs': heat_utils.json_formatter, 'resources': heat_utils.json_formatter, 'links': heat_utils.link_formatter, } columns = [] for key in stack.to_dict(): columns.append(key) columns.sort() return (columns, utils.get_item_properties(stack, columns, formatters=formatters)) stack = client.stacks.create(**fields)['stack'] if parsed_args.wait: stack_status, msg = event_utils.poll_for_events( client, parsed_args.name, action='CREATE', poll_period=parsed_args.poll) if stack_status == 'CREATE_FAILED': raise exc.CommandError(msg) return _show_stack(client, stack['id'], format='table', short=True)
def stack_up(conn, stack_name): for stack_dir in _stack_dir(): stack_file = os.path.join(stack_dir, "%s.yaml" % (stack_name)) if os.path.exists(stack_file): break else: raise Exception("Cannot find '%s' stack." % (stack_name)) dependencies = [] with open(stack_file) as fp: for l in fp: l = l.strip() if len(l) > 2 and l[0] == '#': if l[2:].startswith('Depends-On: '): dependencies.append(l[14:]) for dep in dependencies: stack_up(conn, dep) with open(stack_file) as fp: config = yaml.safe_load(fp) if 'heat_template_version' in config: d = config['heat_template_version'].strftime('%Y-%m-%d') config['heat_template_version'] = d has_image = config.get('parameters', {}).get('image', None) is not None has_key_pair_path = config.get('parameters', {}).get('key_pair_path', None) is not None has_key_pair = config.get('parameters', {}).get('key_pair', None) is not None files, template = template_utils.process_template_path(stack_file) args = { 'files': files, 'template': template, 'parameters': {}, 'name': stack_name, 'tags': 'stack', } if has_image: args['parameters']['image'] = 'cirros-0.4.0-x86_64-disk' if has_key_pair_path: key_filename = os.path.expanduser('~/.ssh/id_rsa.pub') args['parameters']['key_pair_path'] = 'keys/id_rsa.pub' with open(key_filename) as fp: files['keys/id_rsa.pub'] = fp.read() if has_key_pair: args['parameters']['key_pair'] = 'keypair0' cur_stack = conn.orchestration.find_stack(stack_name) if cur_stack is None: print("Creating stack %s" % (stack_name)) conn.orchestration.create_stack(**args) else: print("Updating stack %s" % (stack_name)) conn.orchestration.update_stack(cur_stack.id, **args) while True: stack = conn.orchestration.get_stack(stack_name) if stack.status not in ('CREATE_IN_PROGRESS', 'UPDATE_IN_PROGRESS'): break time.sleep(1) print("Stack %s %s (%s)" % (stack_name, stack.status, stack.status_reason)) print( yaml.safe_dump(stack.outputs, default_flow_style=False, explicit_start=True))