def create_gem( self, gem_name, initial_content = 'empty', enable = False, asset_only = False, version = '1.0.0', relative_directory_path = None, lmbr_exe_path_override = None, no_sln_change = False): # Validate arguments try: util.validate_stack_name(gem_name) except HandledError as e: raise HandledError('The gem name is not valid for use as a Cloud Gem. {}.'.format(e)) if initial_content not in self.initial_content_list: raise HandledError('Invalid initial content: {}. Valid initial content values are {}.'.format(initial_content, ', '.join(self.initial_content_list))) # Validate files are writable writable_file_list = [] if enable: writable_file_list.append(self.get_gems_file_path()) if writable_file_list: if not util.validate_writable_list(self.__context, writable_file_list): return # Create the gem... root_directory_path = self.__do_lmbr_gems_create(lmbr_exe_path_override, gem_name, relative_directory_path, asset_only, version) # Add the framework dependency self.__add_framework_gem_dependency(root_directory_path) # Copy initial gem content... self.__copy_initial_gem_content(gem_name, root_directory_path, initial_content, no_sln_change) # Set the c++ build configuration for the gem. if not asset_only: self.__setup_cloud_gem_cpp_build(root_directory_path, gem_name, initial_content) # Add gem to collections... gem = self.__add_gem(root_directory_path, enable) # Tell them about it, then go on to enable if requested... self.__context.view.gem_created(gem_name, root_directory_path) if enable: self.enable_gem(gem_name, lmbr_exe_path_override)
def add_resource_group(self, resource_group): if resource_group.name in self.__dict__.keys(): raise HandledError( 'Multiple resource groups named {} are enabled for the project.' .format(resource_group.name)) try: util.validate_stack_name(resource_group.name) except HandledError as e: raise HandledError( 'The resource group name \'{}\' is not a valid name. '.format( e)) self.__dict__[resource_group.name] = resource_group
def gem_enabled(self, gem): if gem.has_aws_file(constant.RESOURCE_GROUP_TEMPLATE_FILENAME): if gem.name in self.__resource_groups.keys(): if self.__resource_groups[gem.name].gem is not gem: raise HandledError( 'Multiple cloud gems named {} are enabled for the project. Cloud gems must have unique names within a project.' .format(gem.name)) try: util.validate_stack_name(gem.name) except HandledError as e: raise HandledError( 'The gem name is not valid for use as a Cloud Gem. {}. You need to rename or disable the gem, or remove the gem\s AWS\resource-group-template.json file.' .format(e)) self.__resource_groups[gem.name] = ResourceGroup( self.__context, gem.name, gem.aws_directory_path, gem.cpp_base_directory_path, gem.cpp_aws_directory_path, gem)
def create_stack(context, args): '''Implements the lmbr_aws initialze-project command.''' # Supported region? supported_regions = __get_region_list() if args.region not in supported_regions: raise HandledError('Region {} is not supported.'.format(args.region)) # Initialize AWS directory if needed. context.config.initialize_aws_directory() if (args.files_only): return # Already initialized? if context.config.project_stack_id is not None: raise HandledError( 'The project has already been initialized and is using the {} AWS Cloud Formation stack.' .format(context.config.project_stack_id)) # Project settings writable? context.config.validate_writable( context.config.local_project_settings.path) # Is it ok to do this? pending_resource_status = __get_pending_resource_status(context) capabilities = context.stack.confirm_stack_operation( context.config.get_pending_project_stack_id( ), # may be None, which is ok 'project', args, pending_resource_status) # Skip creating the stack if we have already done so. if not context.config.get_pending_project_stack_id(): # Use game directory name as stack name by default. if args.stack_name is None: args.stack_name = context.config.game_directory_name # Does a stack with the name already exist? if context.stack.name_exists(args.stack_name, args.region): raise HandledError( 'An AWS Cloud Formation stack with the name {} already exists in region {}. Use the --stack-name option to provide a different name.' .format(args.stack_name, args.region)) # Is the stack name valid? util.validate_stack_name(args.stack_name) # Create stack using the boostrapping template. context.stack.create_using_template( args.stack_name, bootstrap_template, args.region, created_callback=lambda id: context.config. set_pending_project_stack_id(id), capabilities=capabilities) # Create initial project settings. context.config.init_project_settings() # Temporarily set the config's project_stack_id property to the pending stack # id so the project uploader can find it later. context.config.project_stack_id = context.config.get_pending_project_stack_id( ) # Do the initial update... __update_project_stack(context, pending_resource_status, capabilities)
def create_stack(context, args): # Has the project been initialized? if not context.config.project_initialized: raise HandledError('The project has not been initialized.') # Does a deployment with that name already exist? if context.config.deployment_stack_exists(args.deployment): raise HandledError('The project already has a {} deployment.'.format(args.deployment)) # Does deployment-template.json include resource group from a gem which isn't enabled for the project? for resource_group_name in context.resource_groups.keys(): __check_resource_group_gem_status(context, resource_group_name) # Is the project settings file writable? context.config.validate_writable(context.config.local_project_settings_path) # Is the deployment name valid? util.validate_stack_name(args.deployment) # If there is no project default deployment, make this the project default deployment if context.config.project_default_deployment is None: args.make_project_default = True # If there is no release deployment, make this the release deployment if context.config.release_deployment is None: args.make_release_deployment = True # Need to handle situations where the deployment and/or access stack were # not successfully created on previous attempts. pending_deployment_stack_id = context.config.get_pending_deployment_stack_id(args.deployment) pending_deployment_access_stack_id = context.config.get_pending_deployment_access_stack_id(args.deployment) pending_deployment_stack_status = context.stack.get_stack_status(pending_deployment_stack_id) pending_deployment_access_stack_status = context.stack.get_stack_status(pending_deployment_access_stack_id) # Does a stack with the name already exist? It's ok if a previous attempt # at creation left a stack with this name behind, we'll deal with that later. deployment_stack_name = args.stack_name or context.config.get_default_deployment_stack_name(args.deployment) deployment_region = util.get_region_from_arn(context.config.project_stack_id) if pending_deployment_stack_id is None or deployment_stack_name != util.get_stack_name_from_arn(pending_deployment_stack_id): if context.stack.name_exists(deployment_stack_name, deployment_region): raise HandledError('An AWS Cloud Formation stack with the name {} already exists in region {}. Use the --stack-name option to provide a different name.'.format(deployment_stack_name, deployment_region)) # Resource group (and other) file write checks create_and_validate_writable_list(context) # Is it ok to use AWS? pending_resource_status = __get_pending_combined_resource_status(context, args.deployment) capabilities = context.stack.confirm_stack_operation( None, # stack id 'deployment {}'.format(args.deployment), args, pending_resource_status, ignore_resource_types = [ 'Custom::EmptyDeployment' ] ) # We have the following scenerios to deal with: # # 1) This is the first attempt to create the deployment, or previous attempts didn't # get as far as creating any stacks. # # 2) The previous attempt failed to create or update the deployment stack, which was # left in a ROLLBACK_COMPLETED, UPDATE_ROLLBACK_FAILED, or ROLLBACK_FAILED state. This # stack must be deleted and a new one created. # # 3) The previous attempt created the deployment stack but failed to create the access # stack, leaving it in the ROLLBACK_COMPLETED state. In this case we update the deployment # stack (to make sure it reflects any changes that may have been made), delete the access # stack and attempt to create a new one. # # 4) Both the deployment and access stacks were created successfully, but the pending # stack id properites in the config were not replaced with the non-pending properties # (this could happen if someone kills the client during the access stack creation # process, which then runs to a successful completion). In this case we update both # stacks to make sure they reflect any changes, then replace the "pending" stack id # properties. project_uploader = ProjectUploader(context) deployment_uploader = project_uploader.get_deployment_uploader(args.deployment) template_url = before_update(context, deployment_uploader) deployment_stack_parameters = __get_deployment_stack_parameters(context, args.deployment, uploader = deployment_uploader) # wait a bit for S3 to help insure that templates can be read by cloud formation time.sleep(constant.STACK_UPDATE_DELAY_TIME) try: if pending_deployment_stack_status not in [None, context.stack.STATUS_ROLLBACK_COMPLETE, context.stack.STATUS_DELETE_COMPLETE, context.stack.STATUS_UPDATE_ROLLBACK_FAILED, context.stack.STATUS_ROLLBACK_FAILED]: # case 3 or 4 - deployment stack was previously created successfully, update it context.stack.update( pending_deployment_stack_id, template_url, deployment_stack_parameters, capabilities = capabilities ) deployment_stack_id = pending_deployment_stack_id else: if pending_deployment_stack_status in [context.stack.STATUS_ROLLBACK_COMPLETE, context.stack.STATUS_ROLLBACK_FAILED, context.stack.STATUS_UPDATE_ROLLBACK_FAILED]: # case 2 - deployment stack failed to create previously, delete it context.stack.delete(pending_deployment_stack_id) # case 1 and 2 - deployment stack wasn't creatred previously or was just # deleted, attempt to create it deployment_stack_id = context.stack.create_using_url( deployment_stack_name, template_url, deployment_region, deployment_stack_parameters, created_callback=lambda id: context.config.set_pending_deployment_stack_id(args.deployment, id), capabilities = capabilities) # Now create or update the access stack... context.view.processing_template('{} deployment'.format(args.deployment)) access_template_url = deployment_uploader.upload_content( constant.DEPLOYMENT_ACCESS_TEMPLATE_FILENAME, json.dumps(context.config.deployment_access_template_aggregator.effective_template, indent=4, sort_keys=True), 'processed deployment access temmplate') access_stack_parameters = __get_access_stack_parameters( context, args.deployment, deployment_stack_id = deployment_stack_id, uploader = deployment_uploader ) if pending_deployment_access_stack_status not in [None, context.stack.STATUS_ROLLBACK_COMPLETE, context.stack.STATUS_DELETE_COMPLETE]: # case 4 - access stack was previously created successfully but the pending # stack id properties were not replaced. Update the stack. context.stack.update( pending_deployment_access_stack_id, access_template_url, deployment_stack_parameters, capabilities = capabilities ) deployment_access_stack_id = pending_deployment_access_stack_id else: if pending_deployment_access_stack_status == context.stack.STATUS_ROLLBACK_COMPLETE: # case 3 - access stack failed to create previously, delete it context.stack.delete(pending_deployment_access_stack_id) # case 1 or 3 - access stack wasn't created before, or was just deleted. Attempt # to create. deployment_access_stack_name = deployment_stack_name + '-Access' deployment_access_stack_id = context.stack.create_using_url( deployment_access_stack_name, access_template_url, deployment_region, parameters = access_stack_parameters, created_callback=lambda id: context.config.set_pending_deployment_access_stack_id(args.deployment, id), capabilities = capabilities) except: context.config.force_gui_refresh() raise context.config.force_gui_refresh() context.config.finalize_deployment_stack_ids(args.deployment) context.view.deployment_stack_created(args.deployment, deployment_stack_id, deployment_access_stack_id) # Should the new deployment become the project default deployment or the release deployment? if args.make_project_default: context.config.set_project_default_deployment(args.deployment) mappings.update(context, util.Args()) context.view.default_deployment(context.config.user_default_deployment, context.config.project_default_deployment) if args.make_release_deployment: context.config.set_release_deployment(args.deployment) temp_args = util.Args() temp_args.release = True mappings.update(context, temp_args) context.view.release_deployment(context.config.release_deployment) after_update(context, deployment_uploader)