Exemple #1
0
def step_impl(context, stack_name):
    config_reader = ConfigReader(context.sceptre_dir)
    stack = config_reader.construct_stack(stack_name + ".yaml")
    try:
        context.output = stack.template.body
    except Exception as e:
        context.error = e
Exemple #2
0
def get_stack_or_stack_group(ctx, path):
    """
    Parses the path to generate relevant Stack Group and Stack object.

    :param ctx: Cli context.
    :type ctx: click.Context
    :param path: Path to either stack config or stack_group folder.
    :type path: str
    """
    stack = None
    stack_group = None

    config_reader = ConfigReader(ctx.obj["sceptre_dir"],
                                 ctx.obj["user_variables"])
    if os.path.splitext(path)[1]:
        stack = config_reader.construct_stack(path)
    else:
        # <<<<<<< HEAD
        #
        #         env = config_reader.construct_environment(path)
        # =======
        #         stack_group = config_reader.construct_stack_group(path)
        # >>>>>>> cfb45a0c7c9e4567f765d4ee4c7dbfe05ebfa0b9

        stack_group = config_reader.construct_stack_group(path)

    return (stack, stack_group)
 def test_read_with_empty_config_file(self):
     config_reader = ConfigReader(self.test_sceptre_directory)
     config = config_reader.read("account/stack-group/region/subnets.yaml")
     assert config == {
         "sceptre_dir": self.test_sceptre_directory,
         "stack_group_path": "account/stack-group/region"
     }
Exemple #4
0
def step_impl(context, stack_name):
    config_reader = ConfigReader(context.sceptre_dir)
    stack = config_reader.construct_stack(stack_name + ".yaml")
    try:
        stack.launch()
    except Exception as e:
        context.error = e
Exemple #5
0
 def test_read_with_templated_config_file(self):
     config_reader = ConfigReader(
         self.test_sceptre_directory,
         {"user_variable": "user_variable_value"}
     )
     config_reader.templating_vars["environment_config"] = {
         "region": "environment_region"
     }
     os.environ["TEST_ENV_VAR"] = "environment_variable_value"
     config = config_reader.read(
         "account/environment/region/security_groups.yaml"
     )
     # self.config.read({"user_variable": "user_variable_value"})
     assert config == {
         'sceptre_dir': config_reader.sceptre_dir,
         "environment_path": "account/environment/region",
         "parameters": {
             "param1": "user_variable_value",
             "param2": "environment_variable_value",
             "param3": "account",
             "param4": "environment",
             "param5": "region",
             "param6": "environment_region"
         }
     }
Exemple #6
0
 def test_construct_stack_with_valid_config(
     self, mock_Stack, mock_collect_s3_details
 ):
     mock_Stack.return_value = sentinel.stack
     mock_collect_s3_details.return_value = sentinel.s3_details
     config_reader = ConfigReader(self.test_sceptre_directory)
     stack = config_reader.construct_stack(
         "account/environment/region/vpc.yaml"
     )
     mock_Stack.assert_called_with(
             name="account/environment/region/vpc",
             project_code="account_project_code",
             template_path=os.path.join(
                 self.test_sceptre_directory, "path/to/template"
             ),
             region="region_region",
             iam_role="account_iam_role",
             parameters={"param1": "val1"},
             sceptre_user_data={},
             hooks={},
             s3_details=sentinel.s3_details,
             dependencies=[],
             role_arn=None,
             protected=False,
             tags={},
             external_name=None,
             notifications=None,
             on_failure=None,
             stack_timeout=0
     )
     assert stack == sentinel.stack
Exemple #7
0
 def test_read_with_empty_config_file(self):
     config_reader = ConfigReader(self.test_sceptre_directory)
     config = config_reader.read("account/environment/region/subnets.yaml")
     assert config == {
         "sceptre_dir": self.test_sceptre_directory,
         "environment_path": "account/environment/region"
     }
def step_impl(context, stack_name):
    config_reader = ConfigReader(context.sceptre_dir)
    stack = config_reader.construct_stack(stack_name + ".yaml")
    try:
        stack.lock()
    except ClientError as e:
        context.error = e
Exemple #9
0
    def test_construct_nodes(self):
        def add(value):
            return 1 + value

        attr = {
            "parameters": {
                "param1": partial(add),
                "param2": {
                    "param3": partial(add),
                    "param4": partial(add)
                },
                "param5": [partial(add), partial(add)]
            },
            "sceptre_user_data": [partial(add), [partial(add),
                                                 partial(add)]]
        }
        ConfigReader._construct_nodes(attr, 1)
        assert attr == {
            "parameters": {
                "param1": 2,
                "param2": {
                    "param3": 2,
                    "param4": 2
                },
                "param5": [2, 2]
            },
            "sceptre_user_data": [2, [2, 2]]
        }
Exemple #10
0
def step_impl(context, stack_name):
    config_reader = ConfigReader(context.sceptre_dir)
    stack = config_reader.construct_stack(stack_name + ".yaml")
    try:
        context.response = stack.template.validate()
    except ClientError as e:
        context.error = e
Exemple #11
0
def step_impl(context, stack_name):
    config_reader = ConfigReader(context.sceptre_dir)
    stack = config_reader.construct_stack(stack_name + ".yaml")
    try:
        stack.delete()
    except ClientError as e:
        if e.response['Error']['Code'] == 'ValidationError' \
          and e.response['Error']['Message'].endswith("does not exist"):
            return
        else:
            raise e
Exemple #12
0
def step_impl(context, stack_name):
    config_reader = ConfigReader(context.sceptre_dir)
    stack = config_reader.construct_stack(stack_name + ".yaml")
    try:
        stack.create()
    except ClientError as e:
        if e.response['Error']['Code'] == 'AlreadyExistsException' \
          and e.response['Error']['Message'].endswith("already exists"):
            return
        else:
            raise e
Exemple #13
0
def step_impl(context, change_set_name, stack_name):
    config_reader = ConfigReader(context.sceptre_dir)
    stack = config_reader.construct_stack(stack_name + ".yaml")
    allowed_errors = {'ValidationError', 'ChangeSetNotFound'}
    try:
        stack.execute_change_set(change_set_name)
    except ClientError as e:
        if e.response['Error']['Code'] in allowed_errors:
            context.error = e
            return
        else:
            raise e
Exemple #14
0
def step_impl(context, stack_name):
    config_reader = ConfigReader(context.sceptre_dir)
    stack = config_reader.construct_stack(stack_name + ".yaml")
    try:
        stack.update()
    except ClientError as e:
        message = e.response['Error']['Message']
        if e.response['Error']['Code'] == 'ValidationError' \
            and (message.endswith("does not exist")
                 or message.endswith("No updates are to be performed.")):
            return
        else:
            raise e
Exemple #15
0
    def test_read_reads_config_file_with_base_config(self):
        with self.runner.isolated_filesystem():
            sceptre_dir = os.path.abspath('./example')
            config_dir = os.path.join(sceptre_dir, "config")
            env_dir = os.path.join(config_dir, "A")

            os.makedirs(env_dir)

            config = {"config": "config"}
            with open(os.path.join(env_dir, "stack.yaml"), 'w') as config_file:
                yaml.safe_dump(
                    config, stream=config_file, default_flow_style=False
                )

            base_config = {
                "base_config": "base_config"
            }

            config = ConfigReader(sceptre_dir).read(
                "A/stack.yaml", base_config
            )

            assert config == {
                "sceptre_dir": sceptre_dir,
                "environment_path": "A",
                "config": "config",
                "base_config": "base_config"
            }
Exemple #16
0
    def test_read_reads_config_file(self, filepaths, target):
        with self.runner.isolated_filesystem():
            sceptre_dir = os.path.abspath('./example')
            config_dir = os.path.join(sceptre_dir, "config")
            os.makedirs(config_dir)

            for rel_path in filepaths:
                abs_path = os.path.join(config_dir, rel_path)
                if not os.path.exists(os.path.dirname(abs_path)):
                    try:
                        os.makedirs(os.path.dirname(abs_path))
                    except OSError as exc:
                        if exc.errno != errno.EEXIST:
                            raise

                config = {"filepath": rel_path}
                with open(abs_path, 'w') as config_file:
                    yaml.safe_dump(
                        config, stream=config_file, default_flow_style=False
                    )

            config = ConfigReader(sceptre_dir).read(target)

            assert config == {
                "sceptre_dir": sceptre_dir,
                "environment_path": os.path.split(target)[0],
                "filepath": target
            }
Exemple #17
0
    def test_read_with_nonexistant_filepath(self):
        with self.runner.isolated_filesystem():
            sceptre_dir = os.path.abspath('./example')
            config_dir = os.path.join(sceptre_dir, "config")
            os.makedirs(config_dir)

            with pytest.raises(ConfigFileNotFoundError):
                ConfigReader(sceptre_dir).read("stack.yaml")
Exemple #18
0
    def test_construct_environment_with_valid_config(
        self, filepaths, targets, results
    ):
        with self.runner.isolated_filesystem():
            sceptre_dir = os.path.abspath('./example')
            config_dir = os.path.join(sceptre_dir, "config")
            os.makedirs(config_dir)

            for rel_path in filepaths:
                abs_path = os.path.join(config_dir, rel_path)
                dir_path = abs_path
                if abs_path.endswith(".yaml"):
                    dir_path = os.path.split(abs_path)[0]
                if not os.path.exists(dir_path):
                    try:
                        os.makedirs(dir_path)
                    except OSError as exc:
                        if exc.errno != errno.EEXIST:
                            raise

                config = {
                    "region": "region",
                    "project_code": "project_code",
                    "template_path": rel_path
                }
                with open(abs_path, 'w') as config_file:
                    yaml.safe_dump(
                        config, stream=config_file, default_flow_style=False
                    )

            config_reader = ConfigReader(sceptre_dir)

            def check_environment(environment, details):
                assert sorted(details["stacks"]) == sorted([
                    stack.name for stack in environment.stacks
                ])
                for sub_env in environment.sub_environments:
                    sub_env_details = details["environments"][sub_env.path]
                    check_environment(sub_env, sub_env_details)

            for i, target in enumerate(targets):
                environment = config_reader.construct_environment(target)
                expected = results[i]
                check_environment(environment, expected[environment.path])
Exemple #19
0
def get_stack(ctx, path):
    """
    Parses the path to generate relevant StackGroup and Stack object.

    :param ctx: Cli context.
    :type ctx: click.Context
    :param path: Path to either stack config or stack_group folder.
    :type path: str
    """
    return ConfigReader(ctx.obj["sceptre_dir"],
                        ctx.obj["options"]).construct_stack(path)
Exemple #20
0
def get_stack_or_env(ctx, path):
    """
    Parses the path to generate relevant Envrionment and Stack object.

    :param ctx: Cli context.
    :type ctx: click.Context
    :param path: Path to either stack config or environment folder.
    :type path: str
    """
    stack = None
    env = None

    config_reader = ConfigReader(ctx.obj["sceptre_dir"], ctx.obj["options"])

    if os.path.splitext(path)[1]:
        stack = config_reader.construct_stack(path)
    else:
        env = config_reader.construct_environment(path)

    return (stack, env)
Exemple #21
0
def get_stack_or_stack_group(ctx, path):
    """
    Parses the path to generate relevant Stack Group and Stack object.

    :param ctx: Cli context.
    :type ctx: click.Context
    :param path: Path to either stack config or stack_group folder.
    :type path: str
    """
    stack = None
    stack_group = None

    config_reader = ConfigReader(ctx.obj["sceptre_dir"],
                                 ctx.obj["user_variables"])

    if os.path.splitext(path)[1]:
        stack = config_reader.construct_stack(path)
    else:
        stack_group = config_reader.construct_stack_group(path)

    return (stack, stack_group)
Exemple #22
0
def step_impl(context, environment_name):
    env = ConfigReader(context.sceptre_dir).construct_environment(environment_name)
    context.response = env.describe_resources()
Exemple #23
0
def step_impl(context, environment_name):
    env = ConfigReader(context.sceptre_dir).construct_environment(environment_name)
    env.delete()
Exemple #24
0
def step_impl(context, stack_group_name):
    stack_group = ConfigReader(context.sceptre_dir).construct_stack_group(stack_group_name)
    context.response = stack_group.describe_resources()
Exemple #25
0
def step_impl(context, stack_group_name):
    stack_group = ConfigReader(context.sceptre_dir).construct_stack_group(stack_group_name)
    stack_group.delete()
Exemple #26
0
 def test_aborts_on_incompatible_version_requirement(self):
     config = {
         'require_version': '<0'
     }
     with pytest.raises(VersionIncompatibleError):
         ConfigReader(self.test_sceptre_directory)._check_version(config)
Exemple #27
0
 def test_collect_s3_details(self, stack_name, config, expected):
     details = ConfigReader._collect_s3_details(stack_name, config)
     assert details == expected
Exemple #28
0
def step_impl(context, stack_name):
    config_reader = ConfigReader(context.sceptre_dir)
    stack = config_reader.construct_stack(stack_name + ".yaml")

    context.output = stack.describe_resources()
Exemple #29
0
 def test_config_reader_correctly_initialised(self):
     config_reader = ConfigReader(self.test_sceptre_directory)
     assert config_reader.sceptre_dir == self.test_sceptre_directory
Exemple #30
0
 def test_config_reader_with_invalid_path(self):
     with pytest.raises(InvalidSceptreDirectoryError):
         ConfigReader("/path/does/not/exist")