stax 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee309ab8e6e330d1d4a048112e92ef4baa447a476d424aa603ef6ab8ba5d8373
-  data.tar.gz: b961c4bd5be7fc88e23b07a36fd69ab9f3d308c490e32ddac51d4ff1aace36f0
+  metadata.gz: 1637c27b601383577e3b2f002e93de68a1d030d13a083fafaf0ae29d325d4cc3
+  data.tar.gz: 9d3d833071c1ef2c0ce92491e64aecbc39858dd44ffe225dc61d0e0adf487219
 SHA512:
-  metadata.gz: e6190e8b3ebbac9249c4e4a506f940250dac24c9601453d7d956ef177ac71c62c885a7f784f971bdf611378719bd98c0b074f2470172c77963e9f7227941a2f0
-  data.tar.gz: 1cf0747c5ed623d09612a3e19a55e6324afd7dc7bce69eb7f976464ec027cfa80d029baaa330dad80abe0d1ff8c2f4b900efed9b1b7034fe7b1ef6c9eb1206f0
+  metadata.gz: e560c98cafefb0228b31e0613372f722ed2b129e804a1010eaa6557e35de3ed070f93eba1e3e15b8fe8b76d78fbf5e2d9ca6b1492925caed3721198030af3c5a
+  data.tar.gz: c173d44f14e732458c6f677a24972b0eb88c8d8dc2f6189a397b598c8c46c3d09c0cd9bb68627bbab25c4f9888ef9c3587961a3c6cb1ee9bc9563c4d56a508d5

data/README.md

@@ -176,7 +176,7 @@ Commands:
 ## Cloudformation templates
 
 Stax will load template files from the path relative to its `Staxfile`
-as `cf/$stack.rb`, e.g. `cf/vpc.rb`. Modify this using the method `Stax::Stack::cfer_template`.
+as `cf/$stack.rb`, e.g. `cf/vpc.rb`. Modify this using the method `Stax::Stack::cfn_template_dir`.
 See `examples` for a typical setup.
 
 Simply control stacks using the relevant subcommands:

data/lib/stax.rb

@@ -38,4 +38,5 @@ require 'stax/mixin/logs'
 require 'stax/mixin/apigw'
 require 'stax/mixin/firehose'
 require 'stax/mixin/codebuild'
-require 'stax/mixin/codepipeline'
+require 'stax/mixin/codepipeline'
+require 'stax/mixin/rds'

data/lib/stax/aws/cfn.rb

@@ -99,11 +99,13 @@ module Stax
 
         ## list of stacks that import from this one
         def imports(name)
-          paginate(:imports) do |next_token|
-            client.list_imports(export_name: name, next_token: next_token)
-          end
+          client.list_imports(export_name: name).map(&:imports)
         rescue ::Aws::CloudFormation::Errors::ValidationError
           []
+        rescue ::Aws::CloudFormation::Errors::Throttling => e # this call rate-limits aggressively
+          warn(e.message)
+          sleep 1
+          retry
         end
 
         def validate(opt)

data/lib/stax/aws/dms.rb

@@ -0,0 +1,39 @@
+module Stax
+  module Aws
+    class Dms < Sdk
+
+      class << self
+
+        def client
+          @_client ||= ::Aws::DatabaseMigrationService::Client.new
+        end
+
+        def endpoints(opt)
+          client.describe_endpoints(opt).map(&:endpoints).flatten
+        end
+
+        def instances(opt)
+          client.describe_replication_instances(opt).map(&:replication_instances).flatten
+        end
+
+        def tasks(opt)
+          client.describe_replication_tasks(opt).map(&:replication_tasks).flatten
+        end
+
+        def test(opt)
+          client.test_connection(opt).connection
+        end
+
+        def connections(opt)
+          client.describe_connections(opt).map(&:connections).flatten
+        end
+
+        def start(opt)
+          client.start_replication_task(opt).replication_task
+        end
+
+      end
+
+    end
+  end
+end

data/lib/stax/aws/rds.rb

@@ -0,0 +1,27 @@
+module Stax
+  module Aws
+    class Rds < Sdk
+
+      class << self
+
+        def client
+          @_client ||= ::Aws::RDS::Client.new
+        end
+
+        def clusters(opt)
+          client.describe_db_clusters(opt)&.db_clusters
+        end
+
+        def instances(opt)
+          client.describe_db_instances(opt).map(&:db_instances).flatten
+        end
+
+        def subnet_groups(opt)
+          client.describe_db_subnet_groups(opt).map(&:db_subnet_groups).flatten
+        end
+
+      end
+
+    end
+  end
+end

data/lib/stax/aws/s3.rb

@@ -14,6 +14,10 @@ module Stax
 
         def bucket_tags(bucket)
           client.get_bucket_tagging(bucket: bucket).tag_set
+        rescue ::Aws::Errors::NoSuchEndpointError
+          warn("socket error for #{bucket}, retrying")
+          sleep 1
+          retry
         rescue ::Aws::S3::Errors::NoSuchTagSet
           []
         end

data/lib/stax/aws/secrets_manager.rb

@@ -0,0 +1,22 @@
+module Stax
+  module Aws
+    class SecretsManager < Sdk
+
+      class << self
+
+        def client
+          @_client ||= ::Aws::SecretsManager::Client.new
+        end
+
+        def list
+          client.list_secrets.map(&:secret_list).flatten
+        end
+
+        def get(id, version = :AWSCURRENT)
+          client.get_secret_value(secret_id: id, version_stage: version)
+        end
+
+      end
+    end
+  end
+end

data/lib/stax/aws/sg.rb

@@ -24,6 +24,22 @@ module Stax
           warn(e.message)
         end
 
+        def authorize_sg(id, sg, port)
+          client.authorize_security_group_ingress(
+            group_id: id,
+            ip_permissions: [
+              {
+                ip_protocol: :tcp,
+                from_port: port,
+                to_port: port,
+                user_id_group_pairs: [ { group_id: sg } ],
+              }
+            ]
+          )
+        rescue ::Aws::EC2::Errors::InvalidPermissionDuplicate => e
+          warn(e.message)
+        end
+
         def revoke(id, cidr, port = 22)
           client.revoke_security_group_ingress(
             group_id:    id,
@@ -36,6 +52,21 @@ module Stax
           warn(e.message)
         end
 
+        def revoke_sg(id, sg, port)
+          client.revoke_security_group_ingress(
+            group_id: id,
+            ip_permissions: [
+              {
+                ip_protocol: :tcp,
+                from_port: port,
+                to_port: port,
+                user_id_group_pairs: [ { group_id: sg } ],
+              }
+            ]
+          )
+        rescue ::Aws::EC2::Errors::InvalidPermissionNotFound => e
+          warn(e.message)
+        end
       end
     end
   end

data/lib/stax/cfer.rb

@@ -33,7 +33,7 @@ end
 
 module Stax
   class Stack < Base
-    class_option :use_previous_value, aliases: '-u', type: :array, default: [], desc: 'params to use previous value'
+    class_option :use_previous_value, aliases: '-u', type: :array, default: nil, desc: 'params to use previous value'
 
     no_commands do
 

data/lib/stax/mixin/dms.rb

@@ -0,0 +1,129 @@
+require 'stax/aws/dms'
+
+module Stax
+  module Dms
+    def self.included(thor)
+      thor.desc('dms COMMAND', 'DMS subcommands')
+      thor.subcommand(:dms, Cmd::Dms)
+    end
+
+    def stack_dms_endpoints
+      @_stack_dms_endpoints ||= Aws::Cfn.resources_by_type(stack_name, 'AWS::DMS::Endpoint')
+    end
+
+    def stack_dms_replication_instances
+      @_stack_dms_replication_instances ||= Aws::Cfn.resources_by_type(stack_name, 'AWS::DMS::ReplicationInstance')
+    end
+
+    def stack_dms_replication_tasks
+      @_stack_dms_replication_tasks ||= Aws::Cfn.resources_by_type(stack_name, 'AWS::DMS::ReplicationTask')
+    end
+  end
+
+  module Cmd
+    class Dms < SubCommand
+      stax_info :endpoints, :instances, :tasks
+
+      COLORS = {
+        active:     :green,
+        available:  :green,
+        successful: :green,
+        failed:     :red,
+        stopped:    :red,
+        ready:      :green,
+      }
+
+      no_commands do
+        def dms_endpoint_arns
+          my.stack_dms_endpoints.map(&:physical_resource_id)
+        end
+
+        def dms_instance_arns
+          my.stack_dms_replication_instances.map(&:physical_resource_id)
+        end
+
+        def dms_task_arns
+          my.stack_dms_replication_tasks.map(&:physical_resource_id)
+        end
+      end
+
+      desc 'endpoints', 'list endpoints'
+      def endpoints
+        debug("DMS endpoints for #{my.stack_name}")
+        print_table Aws::Dms.endpoints(filters: [{name: 'endpoint-arn', values: dms_endpoint_arns}]).map { |e|
+          [e.endpoint_identifier, e.endpoint_type, color(e.status, COLORS), e.engine_name, e.server_name]
+        }
+      end
+
+      desc 'instances', 'list replication instances'
+      def instances
+        debug("DMS replication instances for #{my.stack_name}")
+        print_table Aws::Dms.instances(filters: [{name: 'replication-instance-arn', values: dms_instance_arns}]).map { |i|
+          [
+            i.replication_instance_identifier, color(i.replication_instance_status, COLORS),
+            i.replication_subnet_group&.vpc_id, i.replication_instance_class, i.engine_version,
+            i.availability_zone, i.replication_instance_private_ip_address,
+          ]
+        }
+      end
+
+      desc 'tasks', 'list replication tasks'
+      def tasks
+        debug("DMS replication tasks for #{my.stack_name}")
+        print_table Aws::Dms.tasks(filters: [{name: 'replication-task-arn', values: dms_task_arns}]).map { |t|
+          [
+            t.replication_task_identifier, color(t.status, COLORS), t.migration_type,
+            "#{t.replication_task_stats&.full_load_progress_percent}%", "#{(t.replication_task_stats&.elapsed_time_millis/1000).to_i}s",
+            "#{t.replication_task_stats&.tables_loaded} loaded", "#{t.replication_task_stats&.tables_errored} errors",
+          ]
+        }
+      end
+
+      desc 'test', 'test endpoint connections'
+      def test
+        instance = dms_instance_arns.first # FIXME: handle multiple instances
+        dms_endpoint_arns.each do |endpoint|
+          debug("Testing connection for #{endpoint}")
+          conn = Aws::Dms.test(replication_instance_arn: instance, endpoint_arn: endpoint)
+          loop do
+            sleep 3
+            c = Aws::Dms.connections(
+              filters: [
+                { name: 'endpoint-arn',             values: [conn.endpoint_arn] },
+                { name: 'replication-instance-arn', values: [conn.replication_instance_arn] },
+              ]
+            ).first
+            puts [c.endpoint_identifier, c.replication_instance_identifier, color(c.status, COLORS), c.last_failure_message].join('  ')
+            break unless c.status == 'testing'
+          end
+        end
+      end
+
+      desc 'connections', 'list endpoint test connections'
+      def connections
+        debug("Test connection results for #{my.stack_name}")
+        print_table Aws::Dms.connections(filters: [{name: 'endpoint-arn', values: dms_endpoint_arns}]).map { |c|
+          [c.endpoint_identifier, c.replication_instance_identifier, color(c.status, COLORS), c.last_failure_message]
+        }
+      end
+
+      desc 'start', 'start replication task'
+      method_option :tasks,  type: :array,   default: nil,   description: 'task arns to start'
+      method_option :resume, type: :boolean, default: false, description: 'resume processing'
+      method_option :reload, type: :boolean, default: false, description: 'reload target'
+      def start(*tasks)
+        type = (options[:resume] && 'resume-processing') || (options[:reload] && 'reload-target') || 'start-replication'
+        options.fetch(:tasks, dms_task_arns).each do |task|
+          Aws::Dms.start(replication_task_arn: task, start_replication_task_type: type).tap do |r|
+            puts [r.replication_task_identifier, r.status, r.replication_task_start_date].join('  ')
+          end
+        end
+      rescue ::Aws::DatabaseMigrationService::Errors::InvalidParameterCombinationException => e
+        fail_task(e.message)
+      rescue ::Aws::DatabaseMigrationService::Errors::InvalidResourceStateFault => e
+        fail_task(e.message)
+      end
+
+    end
+  end
+end

data/lib/stax/mixin/dynamodb/local.rb

@@ -1,14 +1,25 @@
 require 'json'
 
 module Stax
+  module DynamoDB
+
+    ## monkey-patch this method to apply any app-specific changes to payload
+    ## args: logical_id, payload hash
+    ## returns: new payload
+    def dynamo_local_payload_hacks(id, payload)
+      payload
+    end
+
+  end
+
   module Cmd
     class DynamoDB < SubCommand
 
       no_commands do
 
-        ## client for dynamodb-local endpoint
-        def client
-          @_client ||= ::Aws::DynamoDB::Client.new(endpoint: 'http://localhost:8000')
+        ## client for dynamodb-local endpoint on given port
+        def client(port)
+          @_client ||= ::Aws::DynamoDB::Client.new(endpoint: "http://localhost:#{port}")
         end
 
         ## get CFN template and return hash of table configs
@@ -37,8 +48,8 @@ module Stax
         end
 
         ## create table
-        def dynamo_local_create(payload)
-          client.create_table(dynamo_ruby_payload(payload))
+        def dynamo_local_create(payload, port)
+          client(port).create_table(dynamo_ruby_payload(payload))
         rescue ::Aws::DynamoDB::Errors::ResourceInUseException => e
           warn(e.message)       # table exists
         rescue Seahorse::Client::NetworkingError => e
@@ -46,24 +57,38 @@ module Stax
         end
       end
 
-      desc 'local', 'create local tables from template'
+      desc 'local-create', 'create local tables from template'
       method_option :tables,  aliases: '-t', type: :array,   default: nil,   desc: 'filter table ids'
       method_option :payload, aliases: '-p', type: :boolean, default: false, desc: 'just output payload'
-      def local
+      method_option :port, aliases: '-P', type: :numeric, default: 8000, desc: 'local dynamo port'
+      def local_create
         tables = dynamo_local_tables
         tables.slice!(*options[:tables]) if options[:tables]
 
         tables.each do |id, value|
           payload = dynamo_payload_from_template(id, value)
+          payload = my.dynamo_local_payload_hacks(id, payload) # apply user-supplied hacks
           if options[:payload]
             puts JSON.pretty_generate(payload)
           else
             puts "create table #{id}"
-            dynamo_local_create(payload)
+            dynamo_local_create(payload, options[:port])
           end
         end
       end
 
+      desc 'local-delete', 'delete local tables from template'
+      method_option :tables,  aliases: '-t', type: :array, default: nil, desc: 'filter table ids'
+      method_option :port, aliases: '-P', type: :numeric, default: 8000, desc: 'local dynamo port'
+      def local_delete
+        tables = dynamo_local_tables
+        tables.slice!(*options[:tables]) if options[:tables]
+
+        tables.each do |id,_value|
+          puts "deleting table #{id}"
+          client(options[:port]).delete_table(table_name: id)
+        end
+      end
     end
   end
-end
+end

data/lib/stax/mixin/ec2.rb

@@ -10,6 +10,8 @@ module Stax
 
   module Cmd
     class Ec2 < SubCommand
+      stax_info :ls
+
       COLORS = {
         ## instances
         running:    :green,
@@ -23,6 +25,7 @@ module Stax
 
       desc 'ls', 'list instances for stack'
       def ls
+        debug("EC2 instances for #{my.stack_name}")
         print_table Aws::Ec2.instances(my.stack_name).map { |i|
           name = i.tags.find { |t| t.key == 'Name' }&.value
           [

data/lib/stax/mixin/rds.rb

@@ -0,0 +1,102 @@
+require 'stax/aws/rds'
+
+module Stax
+  module Rds
+    def self.included(thor)
+      thor.desc('rds COMMAND', 'RDS subcommands')
+      thor.subcommand(:rds, Cmd::Rds)
+    end
+  end
+
+  module Cmd
+    class Rds < SubCommand
+      stax_info :clusters, :instances, :endpoints
+
+      COLORS = {
+        available: :green,
+        Complete:  :green,
+        Active:    :green,
+      }
+
+      no_commands do
+        def stack_db_clusters
+          Aws::Cfn.resources_by_type(my.stack_name, 'AWS::RDS::DBCluster')
+        end
+
+        def stack_db_instances
+          Aws::Cfn.resources_by_type(my.stack_name, 'AWS::RDS::DBInstance')
+        end
+
+        def stack_rds_clusters
+          filter = { name: 'db-cluster-id', values: stack_db_clusters.map(&:physical_resource_id) }
+          Aws::Rds.clusters(filters: [filter])
+        end
+
+        def stack_rds_instances
+          filter = { name: 'db-instance-id', values: stack_db_instances.map(&:physical_resource_id) }
+          Aws::Rds.instances(filters: [filter])
+        end
+
+        def stack_db_subnet_groups
+          Aws::Cfn.resources_by_type(my.stack_name, 'AWS::RDS::DBSubnetGroup')
+        end
+      end
+
+      desc 'clusters', 'list db clusters for stack'
+      def clusters
+        debug("RDS DB clusters for #{my.stack_name}")
+        print_table stack_rds_clusters.map { |c|
+          [c.db_cluster_identifier, c.engine, c.engine_version, color(c.status, COLORS), c.cluster_create_time]
+        }
+      end
+
+      desc 'members', 'list db cluster members for stack'
+      def members
+        stack_rds_clusters.each do |c|
+          debug("RDS DB members for cluster #{c.db_cluster_identifier}")
+          print_table c.db_cluster_members.map { |m|
+            role = m.is_cluster_writer ? 'writer' : 'reader'
+            [m.db_instance_identifier, role, m.db_cluster_parameter_group_status]
+          }
+        end
+      end
+
+      desc 'instances', 'list db instances for stack'
+      def instances
+        debug("RDS DB instances for #{my.stack_name}")
+        print_table stack_rds_instances.map { |i|
+          [i.db_instance_identifier, i.engine, i.engine_version, color(i.db_instance_status, COLORS), i.db_instance_class, i.db_subnet_group&.vpc_id, i.availability_zone]
+        }
+      end
+
+      desc 'endpoints', 'list db instance endpoints'
+      def endpoints
+        stack_rds_clusters.each do |c|
+          debug("RDS DB endpoints for cluster #{c.db_cluster_identifier}")
+          print_table [
+            ['writer', c.endpoint,        c.port, c.hosted_zone_id],
+            ['reader', c.reader_endpoint, c.port, c.hosted_zone_id],
+          ]
+        end
+
+        debug("RDS DB instance endpoints for #{my.stack_name}")
+        print_table stack_rds_instances.map { |i|
+          [i.db_instance_identifier, i.endpoint&.address, i.endpoint&.port, i.endpoint&.hosted_zone_id]
+        }
+      end
+
+      desc 'subnets', 'list db subnet groups'
+      def subnets
+        stack_db_subnet_groups.map do |r|
+          Aws::Rds.subnet_groups(db_subnet_group_name: r.physical_resource_id)
+        end.flatten.each do |g|
+          debug("Subnets for group #{g.db_subnet_group_name}")
+          print_table g.subnets.map { |s|
+            [s&.subnet_availability_zone&.name, s&.subnet_identifier, color(s&.subnet_status, COLORS)]
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/stax/mixin/s3.rb

@@ -15,6 +15,10 @@ module Stax
           Aws::Cfn.resources_by_type(my.stack_name, 'AWS::S3::Bucket')
         end
 
+        def stack_s3_bucket_names
+          stack_s3_buckets.map(&:physical_resource_id).compact
+        end
+
         def stack_tagged_buckets
           Aws::S3.list_buckets.select do |bucket|
             region = Aws::S3.bucket_region(bucket.name)
@@ -27,16 +31,27 @@ module Stax
 
       desc 'buckets', 'S3 buckets for this stack'
       def buckets
-        puts stack_s3_buckets.map(&:physical_resource_id)
+        puts stack_s3_bucket_names
       end
 
       desc 'tagged', 'S3 buckets that were tagged by this stack'
       def tagged
+        debug("Buckets tagged by stack #{my.stack_name}")
         print_table stack_tagged_buckets.map { |b|
           [b.name, b.creation_date]
         }
       end
 
+      desc 'reap', 'delete buckets tagged by this stack'
+      def reap
+        debug("Deleting buckets tagged by #{my.stack_name}")
+        stack_tagged_buckets.each do |b|
+          if yes?("Delete bucket and contents #{b.name}?", :yellow)
+            ::Aws::S3::Bucket.new(b.name).delete!
+          end
+        end
+      end
+
       desc 'lifecycle', 'show/set lifecycle for tagged buckets'
       def lifecycle
         debug("Lifecycle for buckets tagged by #{my.stack_name}")
@@ -71,6 +86,28 @@ module Stax
         end
       end
 
+      desc 'clear', 'clear objects from buckets'
+      method_option :names, aliases: '-n', type: :array, default: nil, desc: 'names of buckets to clear'
+      def clear
+        debug("Clearing buckets for #{my.stack_name}")
+        (options[:names] || stack_s3_bucket_names).each do |b|
+          if yes?("Clear contents of bucket #{b}?", :yellow)
+            ::Aws::S3::Bucket.new(b).clear!
+          end
+        end
+      end
+
+      desc 'delete', 'delete buckets and objects'
+      method_option :names, aliases: '-n', type: :array, default: nil, desc: 'names of buckets to delete'
+      def delete
+        debug("Deleting buckets for #{my.stack_name}")
+        (options[:names] || stack_s3_bucket_names).each do |b|
+          if yes?("Delete bucket and contents #{b}?", :yellow)
+            ::Aws::S3::Bucket.new(b).delete!
+          end
+        end
+      end
+
     end
   end
 end

data/lib/stax/mixin/secrets_manager.rb

@@ -0,0 +1,37 @@
+require 'stax/aws/secrets_manager'
+
+module Stax
+  module SecretsManager
+    def self.included(thor)
+      thor.desc('sm COMMAND', 'SecretsManager subcommands')
+      thor.subcommand(:sm, Cmd::SecretsManager)
+    end
+
+    ## monkey-patch in your application as needed
+    def secrets_manager_prefix
+      @_secrets_manager_prefix ||= "#{app_name}/#{branch_name}/"
+    end
+  end
+
+  module Cmd
+    class SecretsManager < SubCommand
+
+      desc 'ls', 'list secrets'
+      def ls
+        debug("Secrets for #{my.stack_name}")
+        print_table Aws::SecretsManager.list.select { |s|
+          s.name.start_with?(my.secrets_manager_prefix)
+        }.map { |s|
+          [s.name, s.description, s.last_accessed_date]
+        }.sort
+      end
+
+      desc 'get ID', 'get secret'
+      def get(id)
+        id = my.secrets_manager_prefix + id unless id.include?('/') # allow absolute or relative path
+        puts Aws::SecretsManager.get(id).secret_string
+      end
+
+    end
+  end
+end

data/lib/stax/mixin/ssh.rb

@@ -16,7 +16,7 @@ module Stax
 
       ## IP address to ssh
       def ssh_instances
-        Aws::Ec2.instances(stack_name).map(&:public_ip_address)
+        Aws::Ec2.instances(stack_name).map(&:public_ip_address).reject(&:nil?)
       end
 
       def ssh_options_format(opt)

data/lib/stax/stack/changeset.rb

@@ -57,6 +57,11 @@ module Stax
         }
       end
 
+      ## get status reason, used for a failure message
+      def change_set_reason(id)
+        Aws::Cfn.client.describe_change_set(stack_name: stack_name, change_set_name: id).status_reason
+      end
+
       ## confirm and execute the change set
       def change_set_execute(id)
         if yes?("Apply these changes to stack #{stack_name}?", :yellow)
@@ -76,7 +81,7 @@ module Stax
     desc 'change', 'create and execute a changeset'
     def change
       id = change_set_update
-      change_set_complete?(id) || fail_task('No changes')
+      change_set_complete?(id) || fail_task(change_set_reason(id))
       change_set_changes(id)
       change_set_unlock
       change_set_execute(id) && tail && update_warn_imports

data/lib/stax/stack/crud.rb

@@ -45,20 +45,32 @@ module Stax
         end
       end
 
+      ## stack should monkey-patch with list of params to keep on update
+      def use_previous_value
+        []
+      end
+
+      ## return option or method
+      def _use_previous_value
+        @_use_previous_value ||= (options[:use_previous_value] || use_previous_value.map(&:to_s))
+      end
+
+      ## get array of params for stack create
       def cfn_parameters_create
-        cfn_parameters.map do |k,v|
+        @_cfn_parameters_create ||= cfn_parameters.map { |k,v|
           { parameter_key: k, parameter_value: v }
-        end
+        }
       end
 
+      ## get array of params for stack update, use previous where requested
       def cfn_parameters_update
-        cfn_parameters.map do |k,v|
-          if options[:use_previous_value].include?(k.to_s)
+        @_cfn_parameters_update ||= cfn_parameters.map { |k,v|
+          if _use_previous_value.include?(k.to_s)
             { parameter_key: k, use_previous_value: true }
           else
             { parameter_key: k, parameter_value: v }
           end
-        end
+        }
       end
 
       ## location of templates relative to Staxfile

data/lib/stax/stack/imports.rb

@@ -25,9 +25,9 @@ module Stax
     def imports
       debug("Stacks that import from #{stack_name}")
       print_table Aws::Cfn.exports(stack_name).map { |e|
-        imports = (i = Aws::Cfn.imports(e.export_name)).empty? ? '-' : i.join(',')
+        imports = (i = Aws::Cfn.imports(e.export_name)).empty? ? '-' : i.join('  ')
         [e.output_key, imports]
-      }
+      }.sort
     end
 
   end

data/lib/stax/version.rb

@@ -1,3 +1,3 @@
 module Stax
-  VERSION = '0.0.8'
+  VERSION = '0.0.9'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stax
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Richard Lister
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-09 00:00:00.000000000 Z
+date: 2018-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -163,6 +163,7 @@ files:
 - lib/stax/aws/cfn.rb
 - lib/stax/aws/codebuild.rb
 - lib/stax/aws/codepipeline.rb
+- lib/stax/aws/dms.rb
 - lib/stax/aws/dynamodb.rb
 - lib/stax/aws/ec2.rb
 - lib/stax/aws/ecr.rb
@@ -175,9 +176,11 @@ files:
 - lib/stax/aws/kms.rb
 - lib/stax/aws/lambda.rb
 - lib/stax/aws/logs.rb
+- lib/stax/aws/rds.rb
 - lib/stax/aws/route53.rb
 - lib/stax/aws/s3.rb
 - lib/stax/aws/sdk.rb
+- lib/stax/aws/secrets_manager.rb
 - lib/stax/aws/sg.rb
 - lib/stax/aws/sqs.rb
 - lib/stax/aws/ssm.rb
@@ -211,6 +214,7 @@ files:
 - lib/stax/mixin/asg.rb
 - lib/stax/mixin/codebuild.rb
 - lib/stax/mixin/codepipeline.rb
+- lib/stax/mixin/dms.rb
 - lib/stax/mixin/dynamodb.rb
 - lib/stax/mixin/dynamodb/backup.rb
 - lib/stax/mixin/dynamodb/local.rb
@@ -226,7 +230,9 @@ files:
 - lib/stax/mixin/kms.rb
 - lib/stax/mixin/lambda.rb
 - lib/stax/mixin/logs.rb
+- lib/stax/mixin/rds.rb
 - lib/stax/mixin/s3.rb
+- lib/stax/mixin/secrets_manager.rb
 - lib/stax/mixin/sg.rb
 - lib/stax/mixin/sqs.rb
 - lib/stax/mixin/ssh.rb
@@ -263,7 +269,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Control Cloudformation stack and other stuff.