def run()

in servicecatalog_puppet/workflow/workspaces/provision_workspace_task.py [0:0]
79 lines of code
5 McCabe index (conditional complexity)

    def run(self):
        with self.hub_client("s3") as s3:
            options = (
                zipfile.ZipFile(
                    io.BytesIO(
                        s3.get_object(Bucket=self.bucket, Key=self.key)
                        .get("Body")
                        .read()
                    )
                )
                .open(f"options.json", "r")
                .read()
            )

        options = json.loads(options)

        zip_file_path = f"s3://{self.bucket}/{self.key}"
        state_file_path = f"s3://sc-puppet-state-{self.account_id}/workspace/{self.workspace_name}/{self.account_id}/{self.region}.zip"
        with self.spoke_client("codebuild") as codebuild:
            parameters_to_use = [
                dict(name="TARGET_ACCOUNT", value=self.account_id, type="PLAINTEXT",),
                dict(name="STATE_FILE", value=state_file_path, type="PLAINTEXT",),
                dict(name="ZIP", value=zip_file_path, type="PLAINTEXT",),
            ]

            for parameter_name, parameter_value in self.get_parameter_values().items():
                parameters_to_use.append(
                    dict(
                        name=f"TF_VAR_{parameter_name}",
                        value=f"{parameter_value}",
                        type="PLAINTEXT",
                    ),
                )

            parameters_to_use.append(
                dict(
                    name="TERRAFORM_VERSION",
                    value=options.get("Terraform", {}).get(
                        "Version", constants.DEFAULT_TERRAFORM_VERSION_VALUE
                    ),
                    type="PLAINTEXT",
                ),
            )

            build = codebuild.start_build_and_wait_for_completion(
                projectName=constants.EXECUTE_TERRAFORM_PROJECT_NAME,
                environmentVariablesOverride=parameters_to_use,
            )

        if len(self.ssm_param_outputs) > 0:
            with self.spoke_client("s3") as s3:
                output_bucket = f"sc-puppet-state-{self.account_id}"
                output_key = f"terraform-executions/{build.get('id').split(':')[1]}/artifacts-execute/outputs.json"
                outputs = json.loads(
                    s3.get_object(Bucket=output_bucket, Key=output_key)
                    .get("Body")
                    .read()
                )

                for ssm_param_output in self.ssm_param_outputs:
                    self.info(
                        f"writing SSM Param: {ssm_param_output.get('stack_output')}"
                    )
                    with self.hub_client("ssm") as ssm:
                        if outputs.get(ssm_param_output.get("stack_output")):
                            output_value = outputs.get(
                                ssm_param_output.get("stack_output")
                            ).get("value")

                            ssm_parameter_name = ssm_param_output.get("param_name")
                            ssm_parameter_name = ssm_parameter_name.replace(
                                "${AWS::Region}", self.region
                            )
                            ssm_parameter_name = ssm_parameter_name.replace(
                                "${AWS::AccountId}", self.account_id
                            )
                            ssm.put_parameter_and_wait(
                                Name=ssm_parameter_name,
                                Value=output_value,
                                Type=ssm_param_output.get("param_type", "String"),
                                Overwrite=True,
                            )
                        else:
                            raise Exception(
                                f"Could not find {ssm_param_output.get('stack_output')} in the outputs"
                            )

        self.write_output(self.params_for_results_display())