stackup 1.5.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c15ca8477932ab203176cf7047ba309edae07fe35c36cdf797353d747bb74e5b
-  data.tar.gz: 195ebfa65f7fa5a3836abf59e855fe803f97e1dbc28965800f89c88f5b56a22d
+  metadata.gz: f74cb61004ec9220d92f5f1d1ff292607b216233bc5aed7668d31027e4e2d2b3
+  data.tar.gz: 18cce0dfddda4b0870affec164d0d0c9cdb30e2e25f1ea675e3b64bd3385323e
 SHA512:
-  metadata.gz: 8439adf18ef0d019ea73e2205b9c0d33848f2151c48ef45e5b6f8552492d860bf0ad9477d625d62163537da997fc18c763310731a4f8735860e6edc4cf121b91
-  data.tar.gz: 8022894472208a085f0224c71e2e2bbfb9d896673c6fbd5a5af259c970383c8edec14cba14cc5cc576e8d203a15e1121bb682321ab5c79a224b3a6ac52ceb996
+  metadata.gz: 38a0621de917ddd7bc2163756c854ad89bae2f79e5b8f1d784e04042b55f4a5a9ea5a84bed89f305c4604efc7c9ccb01ec46c32ec3635e3d03f3148b5b3db0ed
+  data.tar.gz: ac2b19120472ed87471053394d1383d860939a562aebdf5e17fa2a3fc1290b48397c1dae1d9b6c752d6a0a4fd041716b9c753be42f135661303863e2e471397d

data/CHANGES.md

@@ -1,5 +1,22 @@
 # CHANGES
 
+## 1.7.1 (2021-08-31)
+
+* Dependency upgrades. Uplift of release process.
+* M1/arm64 support for docker image releases.
+
+## 1.7.0 (2020-11-25)
+
+* Feature: --no-fail-on-empty-change-set
+
+## 1.6.0 (2020-11-19)
+
+* Feature: Support --service-role-arn on "change-set create"
+
+## 1.5.1 (2020-11-16)
+
+* Fix: Recognise that template is in S3 when URL is formatted like `s3.REGION.amazonaws.com`
+
 ## 1.5.0 (2020-04-21)
 
 * Feature: --preserve-template-formatting

data/README.md

@@ -1,7 +1,7 @@
 # stackup
 
 [![Gem Version](https://badge.fury.io/rb/stackup.png)](http://badge.fury.io/rb/stackup)
-[![Build Status](https://travis-ci.org/realestate-com-au/stackup.svg?branch=master)](https://travis-ci.org/realestate-com-au/stackup)
+[![Build Status](https://travis-ci.com/realestate-com-au/stackup.svg?branch=main)](https://travis-ci.com/realestate-com-au/stackup)
 
 Stackup provides a CLI and a simplified Ruby API for dealing with
 AWS CloudFormation stacks.
@@ -191,7 +191,7 @@ Where a template URL references an object in S3, `stackup` leverages [CloudForma
 Non-S3 URLs are also supported, though in that case `stackup` must fetch the content itself:
 
     $ stackup mystack up \
-      -t https://raw.githubusercontent.com/realestate-com-au/stackup/master/examples/template.yml
+      -t https://raw.githubusercontent.com/realestate-com-au/stackup/main/examples/template.yml
 
 ### Stack deletion
 
@@ -216,6 +216,10 @@ You can also create, list, inspect, apply and delete [change sets](http://docs.a
 
 The change-set name defaults to "pending", but can be overridden using `--name`.
 
+The `change-set create` subcommand, like the `up` command, supports `--service-role-arn` to specify a service role.
+
+It is impossible to create a change set with no changes. By default, stackup will only return successfully if a change set was actually created, and will otherwise fail. If the `--no-fail-on-empty-change-set` option is provided, stackup will return successfully if a change set was created _or_ if no change set was created because no changes were needed.
+
 ## Programmatic usage
 
 Get a handle to a `Stack` object as follows:
@@ -300,18 +304,23 @@ This policy grants the principal all actions required by `stackup up` for any cl
 }
 ```
 
-## Releasing
+## Development
 
-The release process will push tags to GitHub, push the gem to rubygems and push the docker image to DockerHub.
+### Running tests
 
-Prerequisites:
+`auto/test` will run the tests in a Docker container.
+`auto/lint` will run the linter in a Docker container.
 
-* logged into dockerhub via `docker login`. Your user must have permission to push to `realestate/stackup`
-* logged into rubygems via `gem push`. Your user must have permission to push to the `stackup` gem.
+### Releasing
 
-To release:
+Releasing is done mostly by CI. The automated process will push tags to GitHub, push the docker images to DockerHub. It won't yet push the gem to `rubygems.org`, but we're working ok it..
 
-```
-bundle install
-auto/release
-```
+Prerequisites:
+
+* You must have a rubygems account with permission to push to the `stackup` gem. (`auto/release-gem` will ask for your username and password)
+* You have bumped the version number in `lib/stackup/version.rb`.
+* You have checked the `CHANGES.md` file to make sure it is reasonable and has the changes for this new version.
+
+To release the rubygem.
+1. `auto/release-gem`
+2. On REA's internal CI tool of choice, find the build for `stackup-ci` and trigger a new build from `HEAD`. This will always grab the latest code from here and release the rest of the parts.

data/bin/stackup

@@ -1,553 +1,11 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 $LOAD_PATH << File.expand_path("../lib", __dir__)
 
-require "clamp"
-require "console_logger"
-require "multi_json"
-require "securerandom"
-require "stackup"
-require "stackup/differ"
-require "stackup/source"
-require "stackup/version"
-require "stackup/yaml"
+require "stackup/main_command"
 
 $stdout.sync = true
 $stderr.sync = true
 
-Clamp do
-
-  option ["-L", "--list"], :flag, "list stacks" do
-    list_stacks
-    exit 0
-  end
-
-  option ["-Y", "--yaml"], :flag, "output data in YAML format"
-
-  option ["--region"], "REGION", "set region" do |arg|
-    raise ArgumentError, "#{arg.inspect} doesn't look like a region" unless arg =~ /^[a-z]{2}-[a-z]+-\d$/
-
-    arg
-  end
-
-  option ["--with-role"], "ROLE_ARN", "assume this role",
-         :attribute_name => :role_arn
-
-  option ["--retry-limit"], "N", "maximum number of retries for API calls",
-         :environment_variable => "AWS_API_RETRY_LIMIT" do |arg|
-    Integer(arg)
-  end
-
-  option ["--[no-]wait"], :flag, "wait for stack updates to complete",
-         :default => true
-
-  option ["--wait-poll-interval"], "N", "polling interval (in seconds) while waiting for updates",
-         :default => 5, &method(:Integer)
-
-  option "--debug", :flag, "enable debugging"
-
-  option ["--version"], :flag, "display version" do
-    puts "stackup v#{Stackup::VERSION}"
-    exit 0
-  end
-
-  parameter "NAME", "Name of stack", :attribute_name => :stack_name
-
-  def run(arguments)
-    super(arguments)
-  rescue Stackup::Source::ReadError => e
-    signal_error e.message
-  rescue Stackup::ServiceError => e
-    signal_error e.message
-  rescue Aws::Errors::MissingCredentialsError
-    signal_error "no credentials provided"
-  rescue Aws::Errors::ServiceError => e
-    signal_error e.message
-  end
-
-  private
-
-  def logger
-    @logger ||= ConsoleLogger.new($stdout, debug?)
-  end
-
-  def format_data(data)
-    if yaml?
-      YAML.dump(data)
-    else
-      MultiJson.dump(data, :pretty => true)
-    end
-  end
-
-  def display_data(data)
-    puts format_data(data)
-  end
-
-  def role_arn=(arg)
-    raise ArgumentError, "#{arg.inspect} doesn't look like a role ARN" unless arg =~ %r{^arn:aws:iam::\d+:role/}
-
-    @role_arn = arg
-  end
-
-  def stackup
-    Stackup(aws_config)
-  end
-
-  def base_aws_config
-    {
-      :log_level => :debug,
-      :logger => logger,
-      :region => region,
-      :retry_limit => retry_limit
-    }.reject { |_k, v| v.nil? }
-  end
-
-  def aws_config
-    return base_aws_config unless role_arn
-
-    assumed_credentials = Aws::AssumeRoleCredentials.new(
-      :client => Aws::STS::Client.new(base_aws_config),
-      :role_arn => role_arn,
-      :role_session_name => "stackup-#{SecureRandom.hex(8)}"
-    )
-    base_aws_config.merge(:credentials => assumed_credentials)
-  end
-
-  def stack
-    stackup.stack(stack_name, :wait => wait?, :wait_poll_interval => wait_poll_interval)
-  end
-
-  def list_stacks
-    stackup.stack_names.each do |name|
-      puts name
-    end
-  end
-
-  def report_change
-    final_status = yield
-    puts final_status unless final_status.nil?
-  end
-
-  subcommand "status", "Print stack status." do
-
-    def execute
-      puts stack.status
-    end
-
-  end
-
-  module HasParameters
-
-    extend Clamp::Option::Declaration
-
-    option ["-p", "--parameters"], "FILE", "parameters file (last wins)",
-           :multivalued => true,
-           :attribute_name => :parameter_sources,
-           &Stackup::Source.method(:new)
-
-    option ["-o", "--override"], "PARAM=VALUE", "parameter overrides",
-           :multivalued => true,
-           :attribute_name => :override_list
-
-    private
-
-    def parameters
-      parameters_from_files.merge(parameter_overrides)
-    end
-
-    def parameters_from_files
-      parameter_sources.map do |src|
-        Stackup::Parameters.new(src.data).to_hash
-      end.inject({}, :merge)
-    end
-
-    def parameter_overrides
-      {}.tap do |result|
-        override_list.each do |override|
-          key, value = override.split("=", 2)
-          result[key] = value
-        end
-      end
-    end
-
-  end
-
-  subcommand "up", "Create/update the stack." do
-
-    option ["-t", "--template"], "FILE", "template source",
-           :attribute_name => :template_source,
-           &Stackup::Source.method(:new)
-
-    option ["-T", "--use-previous-template"], :flag,
-           "reuse the existing template"
-
-    option ["-P", "--preserve-template-formatting"], :flag,
-           "do not normalise the template when calling the Cloudformation APIs; useful for preserving YAML and comments"
-
-    include HasParameters
-
-    option "--tags", "FILE", "stack tags file",
-           :attribute_name => :tag_source,
-           &Stackup::Source.method(:new)
-
-    option "--policy", "FILE", "stack policy file",
-           :attribute_name => :policy_source,
-           &Stackup::Source.method(:new)
-
-    option "--service-role-arn", "SERVICE_ROLE_ARN", "cloudformation service role ARN" do |arg|
-      raise ArgumentError, "#{arg.inspect} doesn't look like a role ARN" unless arg =~ %r{^arn:aws:iam::\d+:role/}
-
-      arg
-    end
-
-    option "--on-failure", "ACTION",
-           "when stack creation fails: DO_NOTHING, ROLLBACK, or DELETE",
-           :default => "ROLLBACK"
-
-    option "--capability", "CAPABILITY", "cloudformation capability",
-           :multivalued => true, :default => ["CAPABILITY_NAMED_IAM"]
-
-    def execute
-      unless template_source || use_previous_template?
-        signal_usage_error "Specify either --template or --use-previous-template"
-      end
-      options = {}
-      if template_source
-        if template_source.s3?
-          options[:template_url] = template_source.location
-        else
-          options[:template] = template_source.data
-          options[:template_orig] = template_source.body
-        end
-      end
-      options[:on_failure] = on_failure
-      options[:parameters] = parameters
-      options[:tags] = tag_source.data if tag_source
-      if policy_source
-        if policy_source.s3?
-          options[:stack_policy_url] = policy_source.location
-        else
-          options[:stack_policy] = policy_source.data
-        end
-      end
-      options[:role_arn] = service_role_arn if service_role_arn
-      options[:use_previous_template] = use_previous_template?
-      options[:capabilities] = capability_list
-      options[:preserve] = preserve_template_formatting?
-      report_change do
-        stack.create_or_update(options)
-      end
-    end
-
-  end
-
-  subcommand ["change-sets"], "List change-sets." do
-
-    def execute
-      stack.change_set_summaries.each do |change_set|
-        puts [
-          pad(change_set.change_set_name, 36),
-          pad(change_set.status, 20),
-          pad(change_set.execution_status, 24)
-        ].join("  ")
-      end
-    end
-
-    private
-
-    def pad(s, width)
-      (s || "").ljust(width)
-    end
-
-  end
-
-  subcommand ["change-set"], "Change-set operations." do
-
-    option "--name", "NAME", "Name of change-set",
-           :attribute_name => :change_set_name,
-           :default => "pending"
-
-    subcommand "create", "Create a change-set." do
-
-      option ["-d", "--description"], "DESC",
-             "Change-set description"
-
-      option ["-t", "--template"], "FILE", "template source",
-             :attribute_name => :template_source,
-             &Stackup::Source.method(:new)
-
-      option ["-T", "--use-previous-template"], :flag,
-             "reuse the existing template"
-
-      option ["-P", "--preserve-template-formatting"], :flag,
-             "do not normalise the template when calling the Cloudformation APIs; useful for preserving YAML and comments"
-
-      option ["--force"], :flag,
-             "replace existing change-set of the same name"
-
-      include HasParameters
-
-      option "--tags", "FILE", "stack tags file",
-             :attribute_name => :tag_source,
-             &Stackup::Source.method(:new)
-
-      option "--capability", "CAPABILITY", "cloudformation capability",
-             :multivalued => true, :default => ["CAPABILITY_NAMED_IAM"]
-
-      def execute
-        unless template_source || use_previous_template?
-          signal_usage_error "Specify either --template or --use-previous-template"
-        end
-        options = {}
-        if template_source
-          if template_source.s3?
-            options[:template_url] = template_source.location
-          else
-            options[:template] = template_source.data
-            options[:template_orig] = template_source.body
-          end
-        end
-        options[:parameters] = parameters
-        options[:description] = description if description
-        options[:tags] = tag_source.data if tag_source
-        options[:use_previous_template] = use_previous_template?
-        options[:force] = force?
-        options[:capabilities] = capability_list
-        options[:preserve] = preserve_template_formatting?
-        report_change do
-          change_set.create(options)
-        end
-      end
-
-    end
-
-    subcommand "changes", "Describe the change-set." do
-
-      def execute
-        display_data(change_set.describe.changes.map(&:to_h))
-      end
-
-    end
-
-    subcommand "inspect", "Show full change-set details." do
-
-      def execute
-        display_data(change_set.describe.to_h)
-      end
-
-    end
-
-    subcommand ["apply", "execute"], "Apply the change-set." do
-
-      def execute
-        report_change do
-          change_set.execute
-        end
-      end
-
-    end
-
-    subcommand "delete", "Delete the change-set." do
-
-      def execute
-        report_change do
-          change_set.delete
-        end
-      end
-
-    end
-
-    private
-
-    def change_set
-      stack.change_set(change_set_name)
-    end
-
-  end
-
-  subcommand "diff", "Compare template/params to current stack." do
-
-    option "--diff-format", "FORMAT", "'text', 'color', or 'html'", :default => "color"
-
-    option ["-C", "--context-lines"], "LINES", "number of lines of context to show", :default => 10_000
-
-    option ["-t", "--template"], "FILE", "template source",
-           :attribute_name => :template_source,
-           &Stackup::Source.method(:new)
-
-    include HasParameters
-
-    option "--tags", "FILE", "stack tags file",
-           :attribute_name => :tag_source,
-           &Stackup::Source.method(:new)
-
-    def execute
-      current = {}
-      planned = {}
-      if template_source
-        current["Template"] = stack.template
-        planned["Template"] = template_source.data
-      end
-      unless parameter_sources.empty?
-        current["Parameters"] = existing_parameters.sort.to_h
-        planned["Parameters"] = new_parameters.sort.to_h
-      end
-      if tag_source
-        current["Tags"] = stack.tags.sort.to_h
-        planned["Tags"] = tag_source.data.sort.to_h
-      end
-      signal_usage_error "specify '--template' or '--parameters'" if planned.empty?
-      puts differ.diff(current, planned, context_lines)
-    end
-
-    private
-
-    def differ
-      Stackup::Differ.new(diff_format, &method(:format_data))
-    end
-
-    def existing_parameters
-      @existing_parameters ||= stack.parameters
-    end
-
-    def new_parameters
-      existing_parameters.merge(parameters)
-    end
-
-  end
-
-  subcommand ["down", "delete"], "Remove the stack." do
-
-    def execute
-      report_change do
-        stack.delete
-      end
-    end
-
-  end
-
-  subcommand "cancel-update", "Cancel the update in-progress." do
-
-    def execute
-      report_change do
-        stack.cancel_update
-      end
-    end
-
-  end
-
-  subcommand "wait", "Wait until stack is stable." do
-
-    def execute
-      puts stack.wait
-    end
-
-  end
-
-  subcommand "events", "List stack events." do
-
-    option ["-f", "--follow"], :flag, "follow new events"
-    option ["--data"], :flag, "display events as data"
-
-    def execute
-      stack.watch(false) do |watcher|
-        loop do
-          watcher.each_new_event do |event|
-            display_event(event)
-          end
-          break unless follow?
-
-          sleep 5
-        end
-      end
-    end
-
-    private
-
-    def display_event(e)
-      if data?
-        display_data(event_data(e))
-      else
-        puts event_summary(e)
-      end
-    end
-
-    def event_data(e)
-      {
-        "timestamp" => e.timestamp.localtime,
-        "logical_resource_id" => e.logical_resource_id,
-        "physical_resource_id" => e.physical_resource_id,
-        "resource_status" => e.resource_status,
-        "resource_status_reason" => e.resource_status_reason
-      }.reject { |_k, v| blank?(v) }
-    end
-
-    def blank?(v)
-      v.nil? || v.respond_to?(:empty?) && v.empty?
-    end
-
-    def event_summary(e)
-      summary = "[#{e.timestamp.localtime.iso8601}] #{e.logical_resource_id}"
-      summary += " - #{e.resource_status}"
-      summary += " - #{e.resource_status_reason}" if e.resource_status_reason
-      summary
-    end
-
-  end
-
-  subcommand "template", "Display stack template." do
-
-    def execute
-      display_data(stack.template)
-    end
-
-  end
-
-  subcommand ["parameters", "params"], "Display stack parameters." do
-
-    def execute
-      display_data(stack.parameters)
-    end
-
-  end
-
-  subcommand "tags", "Display stack tags." do
-
-    def execute
-      display_data(stack.tags)
-    end
-
-  end
-
-  subcommand "resources", "Display stack resources." do
-
-    def execute
-      display_data(stack.resources)
-    end
-
-  end
-
-  subcommand "outputs", "Display stack outputs." do
-
-    def execute
-      display_data(stack.outputs)
-    end
-
-  end
-
-  subcommand "inspect", "Display stack particulars." do
-
-    def execute
-      data = {
-        "Status" => stack.status,
-        "Parameters" => stack.parameters,
-        "Tags" => stack.tags,
-        "Resources" => stack.resources,
-        "Outputs" => stack.outputs
-      }
-      display_data(data)
-    end
-
-  end
-
-end
+Stackup::MainCommand.run