def generate_command(ctx, no_placeholders, path): """ Prints the template used for stack in PATH. \f :param path: Path to execute the command on. :type path: str """ context = SceptreContext( command_path=path, project_path=ctx.obj.get("project_path"), user_variables=ctx.obj.get("user_variables"), options=ctx.obj.get("options"), output_format=ctx.obj.get("output_format"), ignore_dependencies=ctx.obj.get("ignore_dependencies")) plan = SceptrePlan(context) execution_context = null_context( ) if no_placeholders else use_resolver_placeholders_on_error() with execution_context: responses = plan.generate() output = [template for template in responses.values()] write(output, context.output_format)
def validate_command(ctx, no_placeholders, path): """ Validates the template used for stack in PATH. \f :param path: Path to execute the command on. :type path: str """ context = SceptreContext( command_path=path, project_path=ctx.obj.get("project_path"), user_variables=ctx.obj.get("user_variables"), options=ctx.obj.get("options"), output_format=ctx.obj.get("output_format"), ignore_dependencies=ctx.obj.get("ignore_dependencies")) plan = SceptrePlan(context) execution_context = null_context( ) if no_placeholders else use_resolver_placeholders_on_error() with execution_context: responses = plan.validate() for stack, response in responses.items(): if response['ResponseMetadata']['HTTPStatusCode'] == 200: del response['ResponseMetadata'] click.echo("Template {} is valid. Template details:\n".format( stack.name)) write(response, context.output_format)
def test_get__resolver_raises_recursive_resolve__placeholders_allowed__raises_error( self): class RecursiveResolver(Resolver): def resolve(self): raise RecursiveResolve() resolver = RecursiveResolver() self.mock_object.resolvable_value_property = resolver with use_resolver_placeholders_on_error(), pytest.raises( RecursiveResolve): self.mock_object.resolvable_value_property
def test_create_placeholder_value(self, placeholder_type, argument, expected): class MyResolver(Resolver): def resolve(self): pass resolver = MyResolver(argument) with use_resolver_placeholders_on_error(): result = create_placeholder_value(resolver, placeholder_type) assert result == expected
def test_get__resolver_raises_error__placeholders_allowed__alternate_placeholder_type__uses_alternate_type( self): class ErroringResolver(Resolver): def resolve(self): raise ValueError() resolver = ErroringResolver() self.mock_object.value_with_none_placeholder = resolver with use_resolver_placeholders_on_error(): result = self.mock_object.value_with_none_placeholder assert result == create_placeholder_value(resolver, PlaceholderType.none)
def test_get__resolver_raises_error__placeholders_allowed__returns_placeholder( self): class ErroringResolver(Resolver): def resolve(self): raise ValueError() resolver = ErroringResolver() self.mock_object.resolvable_value_property = resolver with use_resolver_placeholders_on_error(): result = self.mock_object.resolvable_value_property assert result == create_placeholder_value(resolver, PlaceholderType.explicit)
def test_get__resolver_raises_error__placeholders_allowed__alternate_placeholder_type__uses_alternate( self): class ErroringResolver(Resolver): def resolve(self): raise ValueError() resolver = ErroringResolver() self.mock_object.container_with_alphanum_placeholder = { 'resolver': resolver } with use_resolver_placeholders_on_error(): result = self.mock_object.container_with_alphanum_placeholder assert result == { 'resolver': create_placeholder_value(resolver, PlaceholderType.alphanum) }
def test_are_placeholders_enabled__error_in_placeholder_context__returns_false( self): with pytest.raises(ValueError), use_resolver_placeholders_on_error(): raise ValueError() assert are_placeholders_enabled() is False
def test_are_placeholders_enabled__out_of_placeholder_context__returns_false( self): with use_resolver_placeholders_on_error(): pass assert are_placeholders_enabled() is False
def test_are_placeholders_enabled__in_placeholder_context__returns_true( self): with use_resolver_placeholders_on_error(): assert are_placeholders_enabled() is True
def step_impl(context: Context): placeholder_context = use_resolver_placeholders_on_error() placeholder_context.__enter__() context.add_cleanup(exit_placeholder_context, placeholder_context)
def diff_command(ctx: Context, differ: str, show_no_echo: bool, no_placeholders: bool, path: str): """Indicates the difference between the currently DEPLOYED stacks in the command path and the stacks configured in Sceptre right now. This command will compare both the templates as well as the subset of stack configurations that can be compared. Some settings (such as sceptre_user_data) are not available in a CloudFormation stack description, so the diff will not be indicated. Currently compared stack configurations are: \b * parameters * notifications * role_arn * stack_tags Important: There are resolvers (notably !stack_output, among others) that rely on other stacks to be already deployed when they are resolved. When producing a diff on Stack Configs that have such resolvers that point to non-deployed stacks, this presents a challenge, since this means those resolvers cannot be resolved. This particularly applies to stack parameters and when a stack's template uses sceptre_user_data with resolvers in it. In order to continue to be useful when producing a diff in these conditions, this command will do the following: 1. If the resolver CAN be resolved, it will be resolved and the resolved value will be in the diff results. 2. If the resolver CANNOT be resolved, it will be replaced with a string that represents the resolver and its arguments. For example: !stack_output my_stack.yaml::MyOutput will resolve in the parameters to "{ !StackOutput(my_stack.yaml::MyOutput) }". Particularly in cases where the replaced value doesn't work in the template as the template logic requires and causes an error, there is nothing further Sceptre can do and diffing will fail. """ context = SceptreContext( command_path=path, project_path=ctx.obj.get("project_path"), user_variables=ctx.obj.get("user_variables"), options=ctx.obj.get("options"), ignore_dependencies=ctx.obj.get("ignore_dependencies"), output_format=ctx.obj.get('output_format'), no_colour=ctx.obj.get('no_colour') ) output_format = context.output_format plan = SceptrePlan(context) if differ == "deepdiff": stack_differ = DeepDiffStackDiffer(show_no_echo) writer_class = DeepDiffWriter elif differ == 'difflib': stack_differ = DifflibStackDiffer(show_no_echo) writer_class = DiffLibWriter else: raise ValueError(f"Unexpected differ type: {differ}") execution_context = null_context() if no_placeholders else use_resolver_placeholders_on_error() with execution_context: diffs: Dict[Stack, StackDiff] = plan.diff(stack_differ) num_stacks_with_diff = output_diffs(diffs.values(), writer_class, sys.stdout, output_format) if num_stacks_with_diff: logger.warning( f"{num_stacks_with_diff} stacks with differences detected." )