stackit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 426eae8667b341e8834521f00605632edd98b19d
+  data.tar.gz: dc9890de3f68a1ee7198ea22597f46bbd7266a39
+SHA512:
+  metadata.gz: 8cc56791184964fbf5752e5cf493b3c4cb5845c43beae200d33845dbc0bce23b5e34ffe3a4903a1c223943817fe942d3f7cc9198150b2279a0053d98039fb52f
+  data.tar.gz: 196c75963e0d8fe4c4ebde6645a2d4eab0103028c18622856b87ae3c198dfe3ca287b74a6fc878e70fb3944e94f86ad406cb7be84b4f82c2135724ad86fae9fa

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.6
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in stackit.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,16 @@
+stackit :: Simple, elegant CloudFormation dependency management.
+Copyright (C) 2016  Jeremy Hahn
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+

data/README.md

@@ -0,0 +1,38 @@
+# stackit
+
+Simple, elegant CloudFormation dependency management.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'stackit'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install stackit
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jeremyhahn/stackit.
+
+
+## License
+
+The gem is available as open source under the terms of the [GNU GENERAL PUBLIC LICENSE](http://www.gnu.org/licenses/gpl-3.0.en.html).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "stackit"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/stackit

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$:.push File.expand_path('../../lib', __FILE__)
+require 'stackit/cli'
+Stackit::Cli.start

data/lib/stackit/aws.rb

@@ -0,0 +1,3 @@
+module Stackit
+  class Aws < Awsclient::Connection; end
+end

data/lib/stackit/cli.rb

@@ -0,0 +1,168 @@
+require 'stackit'
+require 'thor'
+
+module Stackit
+  class Cli < Thor
+
+    class_option :environment, :aliases => '-e', :desc => "Your stack environment (dev, staging, prod, etc)", :default => 'default'
+    class_option :profile, desc: 'AWS profile'
+    class_option :region, desc: 'AWS region', default: 'us-east-1'
+    class_option :debug, type: :boolean, default: false
+    class_option :verbose, type: :boolean, default: false
+    class_option :assume_role, type: :hash, :desc => 'IAM role name and optional duration to keep the STS token valid'
+
+    def initialize(*args)
+      super(*args)
+      init_cli
+    end
+
+    def self.banner(task, namespace = true, subcommand = false)
+      #"#{basename} #{subcommand_prefix} #{task.usage}"
+      "#{basename} #{task.usage}"
+    end
+
+    def self.subcommand_prefix
+      self.name.gsub(%r{.*::}, '').gsub(%r{^[A-Z]}) { |match| match[0].downcase }.gsub(%r{[A-Z]}) { |match| "-#{match[0].downcase}" }
+    end
+
+    desc 'create', 'Creates a new CloudFormation stack'
+    method_option :template, aliases: '-t', desc: 'The cloudformation template', :required => true
+    method_option :stack_name, aliases: '-n', desc: 'The stack name. Defaults to the camelized template file name', :required => true
+    method_option :stack_policy, :aliases => '-p', :desc => 'A local file system or S3 (HTTPS) path to the stack policy'
+    method_option :depends, :aliases => '-d', :type => :array, :default => [], :desc => 'Space delimited list of stack names to automatically map parameter values from'
+    method_option :parameters, aliases: '-p', type: :hash, desc: 'Parameters supplied to the cloudformation template', default: {}
+    method_option :parameters_file, desc: 'Parameters supplied to the cloudformation template'
+    method_option :parameter_map, :aliases => '-pm', type: :hash, default: {}, desc: 'Parameter map used to direct dependent parameter values to stack template parameters'
+    method_option :wait, :aliases => '-w', type: :boolean, default: false, desc: 'Wait for the stack to enter STATUS_COMPLETE before returning or raise an exception if it times out'
+    method_option :force, :desc => 'Force a stack update on unchanged templates'
+    method_option :dry_run, :type => :boolean, :default => false, :desc => 'Run all code except AWS API calls'
+    def create
+      ManagedStack.new({
+        template: options[:template],
+        stack_name: options[:stack_name],
+        stack_policy: options[:stack_policy],
+        depends: options[:depends],
+        user_defined_parameters: options[:parameters],
+        parameters_file: options[:parameters_file],
+        parameter_map: options[:parameter_map],
+        wait: options[:wait],
+        force: options[:force],
+        dry_run: options[:dry_run],
+        debug: !!options[:debug]
+      }).create!
+    end
+
+    desc 'update', 'Updates an existing CloudFormation stack'
+    method_option :template, aliases: '-t', desc: 'The cloudformation template', :required => true
+    method_option :stack_name, aliases: '-n', desc: 'The stack name. Defaults to the camelized template file name', :required => true
+    method_option :stack_policy, :aliases => '-p', :desc => 'A local file system or S3 (HTTPS) path to the stack policy'
+    method_option :stack_policy_during_update, :aliases => '-pu', :desc => 'A local file system or S3 (HTTPS) path to the stack policy to use during update'
+    method_option :depends, :aliases => '-d', :type => :array, :default => [], :desc => 'Space delimited list of stack names to automatically map parameter values from'
+    method_option :parameters, aliases: '-p', type: :hash, desc: 'Parameters supplied to the cloudformation template', default: {}
+    method_option :parameters_file, desc: 'Parameters supplied to the cloudformation template'
+    method_option :parameter_map, :aliases => '-pm', type: :hash, default: {}, desc: 'Parameter map used to direct dependent parameter values to stack template parameters'
+    method_option :wait, :aliases => '-w', type: :boolean, default: false, desc: 'Wait for the stack to enter STATUS_COMPLETE before returning or raise an exception if it times out'
+    method_option :force, :desc => 'Force a stack update on unchanged templates'
+    method_option :dry_run, :type => :boolean, :default => false, :desc => 'Run all code except AWS API calls'
+    def update
+      ManagedStack.new({
+        template: options[:template],
+        stack_name: options[:stack_name],
+        stack_policy: options[:stack_policy],
+        stack_policy_during_update: options[:stack_policy_during_update],
+        depends: options[:depends],
+        user_defined_parameters: options[:parameters],
+        parameters_file: options[:parameters_file],
+        parameter_map: options[:parameter_map],
+        wait: options[:wait],
+        force: options[:force],
+        dry_run: options[:dry_run],
+        debug: !!options[:debug]
+      }).update!
+    end
+
+    desc 'delete', 'Deletes a CloudFormation stack'
+    method_option :stack_name, aliases: '-n', desc: 'The stack name. Defaults to the camelized template file name', :required => true
+    method_option :retain_resources, :aliases => '-r', :type => :array, :desc => 'Space delimited list of logical resource ids to retain after the stack is deleted'
+    method_option :wait, :aliases => '-w', type: :boolean, default: false, desc: 'Wait for the stack to enter STATUS_COMPLETE before returning or raise an exception if it times out'
+    method_option :dry_run, :type => :boolean, :default => false, :desc => 'Run all code except AWS API calls'
+    def delete
+      ManagedStack.new({
+        stack_name: options[:stack_name],
+        wait: options[:wait],
+        dry_run: options[:dry_run],
+        debug: !!options[:debug]
+      }).delete!
+    end
+
+    desc 'create-keypair', 'Creates a new EC2 keypair'
+    method_option :name, desc: 'The name of the keypair', :required => true
+    def create_keypair
+      puts Stackit.aws.ec2.create_key_pair({
+        key_name: options['name']
+      })['key_material']
+    end
+
+    desc 'delete-keypair', 'Deletes an existing EC2 keypair'
+    method_option :name, desc: 'The name of the keypair', :required => true
+    def delete_keypair
+      Stackit.aws.ec2.delete_key_pair({
+        key_name: options['name']
+      })
+    end
+
+    desc 'version', 'Displays StackIT version'
+    def version
+      puts <<-LOGO
+  _____   _                 _      _______  _______ 
+ (_____) (_)_              (_) _  (_______)(__ _ __)
+(_)___   (___) ____    ___ (_)(_)    (_)      (_)   
+  (___)_ (_)  (____) _(___)(___)     (_)      (_)   
+  ____(_)(_)_( )_( )(_)___ (_)(_)  __(_)__    (_)   
+ (_____)  (__)(__)_) (____)(_) (_)(_______)   (_)  v#{Stackit::VERSION}
+
+Simple, elegant CloudFormation dependency management.
+
+LOGO
+    end
+
+    def self.exit_on_failure?
+      true
+    end
+
+    no_commands do
+
+      def init_cli
+
+        Stackit.aws.region = options[:region] if options[:region]
+        Stackit.environment = options[:environment].to_sym if options[:environment]
+        Stackit.debug = !!options[:debug]
+        if Stackit.debug
+          Stackit.logger.level = Logger::DEBUG
+          Stackit.logger.debug "Initializing CLI in debug mode."
+          begin
+            require 'pry-byebug'
+          rescue LoadError; end
+        elsif options[:verbose]
+          Stackit.logger.level = Logger::INFO
+        else
+          Stackit.logger.level = Logger::ERROR
+        end
+        if options[:profile]
+          Stackit.aws.profile = options[:profile]
+        elsif options[:environment]
+          Stackit.aws.credentials = Stackit.aws.load_credentials(
+            options[:environment]
+          )
+        end
+        if options[:assume_role] && options[:assume_role].has_key?('name')
+          name = options[:assume_role]['name']
+          duration = options[:assume_role].has_key?('duration') ? options[:assume_role]['duration'] : 3600
+          Stackit.aws.assume_role!(name, duration)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/stackit/stack/default_notifier.rb

@@ -0,0 +1,45 @@
+require 'thor'
+
+module Stackit
+
+  class ThorNotifier < Thor
+
+    include Thor::Actions
+
+    def initialize(*args)
+      super(*args)
+    end
+
+    no_commands do
+
+      def backtrace(e)
+        puts
+        puts e.backtrace
+      end
+
+      def error(message)
+        say_status 'ERROR', message, :red
+      end
+  
+      def success(message)
+        say_status 'OK', message
+      end
+  
+      def response(response, message = 'Success', respond_to_key = 'stack_id')
+        if response.is_a?(::Seahorse::Client::Response)
+          if response.respond_to?(respond_to_key)
+            success(response.send(respond_to_key))
+          else
+            success(message)
+          end
+        else
+          error(response)
+        end
+      end
+
+    end
+  end
+
+  class DefaultNotifier < ThorNotifier; end
+
+end

data/lib/stackit/stack/managed_stack.rb

@@ -0,0 +1,268 @@
+module Stackit
+  class ManagedStack < Stack
+
+    attr_accessor :template
+    attr_accessor :file_parameters
+    attr_accessor :user_defined_parameters
+    attr_accessor :parameter_map
+    attr_accessor :dry_run
+    attr_accessor :depends
+    attr_accessor :debug
+    attr_accessor :force
+    attr_accessor :wait
+    attr_accessor :notifier
+
+    def initialize(options={})
+      super(options)
+      options = options.to_h.symbolize_keys!
+      @template = create_template(options[:template])
+      @user_defined_parameters = symbolized_user_defined_parameters(options[:user_defined_parameters])
+      @parameter_map = symbolized_parameter_map(options[:parameter_map])
+      @stack_name = options[:stack_name] || default_stack_name
+      @depends = options[:depends] || []
+      @debug = !!options[:debug] || Stackit.debug
+      @force = options[:force]
+      @wait = options[:wait]
+      @dry_run = options[:dry_run]
+      @notifier = options[:notifier] || Stackit::ThorNotifier.new
+      parse_file_parameters(options[:parameters_file]) if options[:parameters_file]
+    end
+
+    def symbolized_user_defined_parameters(params)
+      if params
+        params.symbolize_keys!
+      else
+        {}
+      end
+    end
+
+    def symbolized_parameter_map(param_map)
+      if param_map
+        param_map.symbolize_keys!
+      else
+        []
+      end
+    end
+
+    def default_stack_name
+      self.class.name.demodulize
+    end
+
+    def create_template(t)
+      template_path = t ? t : File.join(Dir.pwd, 'cloudformation', "#{stack_name.underscore.dasherize}.json")
+      return unless File.exist?(template_path)
+      template = Template.new(:template_path => template_path)
+      template.parse!
+    end
+
+    def parse_file_parameters(parameters_file)
+      if File.exist?(parameters_file)
+        @file_parameters = {}
+        file_params = JSON.parse(File.read(parameters_file))
+        file_params.inject(@file_parameters) do |hash, param|
+          hash.merge!(param['ParameterKey'].to_sym => param['ParameterValue'])
+        end
+      end
+    end
+
+    def create!
+      begin
+        response = cloudformation_request(:create_stack)
+        notifier.response(response)
+      rescue ::Aws::CloudFormation::Errors::AlreadyExistsException => e
+        notifier.backtrace(e) if Stackit.debug
+        notifier.error(e.message)
+      rescue ::Aws::CloudFormation::Errors::ValidationError => e
+        notifier.backtrace(e) if Stackit.debug
+        notifier.error(e.message)
+      end
+      response
+    end
+
+    def update!
+      begin
+        response = cloudformation_request(:update_stack)
+        notifier.response(response)
+      rescue ::Aws::CloudFormation::Errors::AlreadyExistsException => e
+        notifier.backtrace(e) if Stackit.debug
+        notifier.error(e.message)
+      rescue ::Aws::CloudFormation::Errors::ValidationError => e
+        if e.message =~ /No updates are to be performed./
+          notifier.success(e.message)
+        else
+          notifier.backtrace(e) if Stackit.debug
+          notifier.error(e.message)
+        end
+      end
+      response
+    end
+
+    def delete!
+      begin
+        response = cloudformation_request(:delete_stack)
+        notifier.response(response)
+      rescue ::Aws::CloudFormation::Errors::AlreadyExistsException => e
+        notifier.backtrace(e) if Stackit.debug
+        notifier.error(e.message)
+      rescue ::Aws::CloudFormation::Errors::ValidationError => e
+        notifier.backtrace(e) if Stackit.debug
+        notifier.error(e.message)
+      end
+      response
+    end
+
+    def deploy!
+      if !File.exist?(template)
+        delete!
+        wait_for_stack_to_delete
+        notifier.success('Delete successful')
+      elsif exists?
+        begin
+          update!
+          wait_for_stack
+          notifier.success('Update successful')
+        rescue ::Aws::CloudFormation::Errors::ValidationError => e 
+          if e.message.include? "No updates are to be performed"
+            Stackit.logger.info "No updates are to be performed"
+          elsif e.message.include? "_FAILED state and can not be updated"
+            Stackit.logger.info 'Stack is in a failed state and can\'t be updated. Deleting/creating a new stack.'
+            delete!
+            wait_for_stack_to_delete
+            create!
+            wait_for_stack
+            notifier.success('Stack deleted and re-created')
+          else
+            raise e
+          end
+        end
+      else
+        begin
+          create!
+          wait_for_stack
+          notifier.success('Created successfully')
+        rescue ::Aws::CloudFormation::Errors::ValidationError => e 
+          if e.message.include? "_FAILED state and can not be updated"
+            Stackit.logger.info 'Stack already exists, is in a failed state, and can\'t be updated. Deleting and creating a new stack.'
+            delete!
+            wait_for_stack_to_delete
+            create!
+            wait_for_stack
+            notifier.success('Stack deleted and re-created')
+          else
+            raise e
+          end
+        end
+      end
+    end
+
+    def exist?
+      describe != nil
+    end
+
+    def describe
+      response = cloudformation_request(:describe_stacks)
+      if response && response[:stacks]
+        response[:stacks].first
+      else
+        nil
+      end
+    rescue ::Aws::CloudFormation::Errors::ValidationError
+      nil
+    end
+
+  private
+
+    DRY_RUN_RESPONSE = Struct.new(:stack_id)
+    REDACTED_TEXT = '****redacted****'
+
+    def capabilities
+      template.needs_iam_capability? ? ['CAPABILITY_IAM'] : []
+    end
+
+    def cloudformation_request(action)
+      Stackit.logger.debug "ManagedStack CloudFormation API request: #{action}"
+      cloudformation_options = create_cloudformation_options(action)
+      if debug
+        Stackit.logger.debug "#{action} request parameters: "
+        opts = cloudformation_options.clone
+        if opts[:parameters]
+          opts[:parameters].each do |param|
+            key = param['parameter_key']
+            param['parameter_value'] = REDACTED_TEXT if key =~ /username|password/i && !debug
+          end
+        end
+        opts[:template_body] = REDACTED_TEXT if opts[:template_body]
+        opts[:stack_policy_body] = JSON.parse(opts[:stack_policy_body]) if opts[:stack_policy_body]
+        opts[:stack_policy_during_update_body] = 
+          JSON.parse(opts[:stack_policy_during_update_body]) if opts[:stack_policy_during_update_body]
+          pp opts
+      end
+      response = dry_run ? dry_run_response : cloudformation.send(action, cloudformation_options)
+      wait_for_stack if wait
+      response
+    end
+
+    def create_cloudformation_options(action)
+      case action
+      when :create_stack
+        {
+          parameters: to_request_parameters(merged_parameters),
+          capabilities: capabilities
+        }.reverse_merge(template.options).reverse_merge(create_stack_request_params)
+      when :update_stack
+        {
+          parameters: to_request_parameters(merged_parameters),
+          capabilities: capabilities
+        }.merge(template.options).merge(update_stack_request_params)
+      else
+        delete_stack_request_params
+      end
+    end
+
+    def dependent_parameters
+      depends.inject([]) do |arr, dep|
+        arr.push(Stackit::Stack.new(stack_name))
+      end
+    end
+
+    def merged_parameters
+
+      parsed_parameters = template.parsed_parameters
+      return parsed_parameters unless depends.length
+
+      validated_parameters = parsed_parameters.clone
+
+      # merge file parameters
+      validated_parameters.merge!(file_parameters) if file_parameters
+
+      # merge --depends
+      depends.each do |dependent_stack_name|
+        this_stack = Stack.new({
+          cloudformation: cloudformation,
+          stack_name: dependent_stack_name
+        })
+        validated_parameters.select { |param|
+          !this_stack[mapped_key(param.to_s)].nil?
+        }.each do | param_name, param_value |
+          validated_parameters.merge!(param_name => this_stack[mapped_key(param_name)])
+        end
+      end
+
+      # merge user defined parameters
+      validated_parameters.merge!(user_defined_parameters)
+    end
+
+    def mapped_key(param)
+      if parameter_map.has_key?(param.to_sym)
+        parameter_map[param.to_sym]
+      else
+        param.to_sym
+      end
+    end
+
+    def dry_run_response
+      DRY_RUN_RESPONSE.new('arn:stackit:dry-run:complete')
+    end
+
+  end
+end

data/lib/stackit/stack.rb

@@ -0,0 +1,177 @@
+module Stackit
+  class Stack
+
+    attr_accessor :cloudformation
+    attr_accessor :stack_id
+    attr_accessor :stack_name
+    attr_accessor :description
+    attr_accessor :parameters
+    attr_accessor :creation_time
+    attr_accessor :last_updated_time
+    attr_accessor :stack_status
+    attr_accessor :stack_status_reason
+    attr_accessor :disable_rollback
+    attr_accessor :timeout_in_minutes
+    attr_accessor :stack_policy_body
+    attr_accessor :stack_policy_url
+    attr_accessor :stack_policy_during_update_body
+    attr_accessor :stack_policy_during_update_url
+    attr_accessor :on_failure
+    attr_accessor :use_previous_template
+    attr_accessor :retain_resources
+
+    def initialize(options = {})
+      options = options.to_h.symbolize_keys!
+      @cloudformation = options[:cloudformation] || Stackit.cloudformation
+      @stack_name = options[:stack_name]
+      @description = options[:description]
+      @parameters = options[:parameters]
+      @disable_rollback = options[:disable_rollback]
+      @notification_arns = options[:notification_arns]
+      @timeout_in_minutes = options[:timeout_in_minutes]
+      @capabilities = options[:capabilities]
+      @tags = options[:tags]
+      @on_failure = options[:on_failure]
+      @use_previous_template = options[:use_previous_template] || true
+      @retain_resources = options[:retain_resources]
+    end
+
+    def [](key)
+      parameters[key] || outputs[key] || resources[key]
+    end
+
+    def parameters
+      @parameters ||= begin
+        stack.parameters.inject({}) do |hash, param|
+          hash.merge(param[:parameter_key] => param[:parameter_value])
+        end
+      rescue ::Aws::CloudFormation::Errors::ValidationError => e
+        [] if e.message =~ /Stack with id #{stack_name} does not exist/
+      end
+    end
+
+    def outputs
+      @outputs ||= begin
+        stack.outputs.inject({}) do |hash, output|
+          hash.merge(output[:output_key] => output[:output_value])
+        end
+      rescue ::Aws::CloudFormation::Errors::ValidationError => e
+        [] if e.message =~ /Stack with id #{stack_name} does not exist/
+      end
+    end
+
+    def resources
+      @resources ||= list_stack_resources.inject({}) do |hash, resource|
+        hash.merge(resource[:logical_resource_id] => resource[:physical_resource_id])
+      end
+    end
+
+    def notification_arns
+      @notification_arns ||= begin
+        stack.notification_arns.inject([]) do |arr, arn|
+          arr.push(arn)
+        end
+      rescue ::Aws::CloudFormation::Errors::ValidationError => e
+        [] if e.message =~ /Stack with id #{stack_name} does not exist/
+      end
+    end
+
+    def capabilities
+      @capabilities ||= stack.capabilities.inject([]) do |arr, capability|
+        arr.push(capability)
+      end
+    end
+
+    def tags
+      @tags ||= begin
+        stack.tags.inject([]) do |arr, tag|
+          arr.push(tag)
+        end
+      rescue ::Aws::CloudFormation::Errors::ValidationError => e
+        [] if e.message =~ /Stack with id #{stack_name} does not exist/
+      end
+    end
+
+    def hydrate!
+      @stack_id = stack.stack_id
+      @description = stack.description
+      @creation_time = stack.creation_time
+      @last_updated_time = stack.last_updated_time
+      @stack_status = stack.stack_status
+      @stack_status_reason = stack.stack_status_reason
+      @disable_rollback = stack.disable_rollback
+      @timeout_in_minutes = stack.timeout_in_minutes
+      @stack_policy_body = stack.stack_policy_body if stack.respond_to?(:stack_policy_body)
+      @stack_policy_url = stack.stack_policy_url if stack.respond_to?(:stack_policy_url)
+      self
+    end
+
+    def create_stack_request_params
+      {
+        stack_name: stack_name,
+        parameters: to_request_parameters,
+        disable_rollback: disable_rollback,
+        timeout_in_minutes: timeout_in_minutes,
+        notification_arns: notification_arns,
+        on_failure: on_failure,
+        stack_policy_body: stack_policy_body,
+        stack_policy_url: stack_policy_url,
+        tags: to_request_tags
+      }
+    end
+
+    def update_stack_request_params
+      {
+        stack_name: stack_name,
+        use_previous_template: use_previous_template,
+        stack_policy_during_update_body: stack_policy_during_update_body,
+        stack_policy_during_update_url: stack_policy_during_update_url,
+        parameters: to_request_parameters,
+        stack_policy_body: stack_policy_body,
+        stack_policy_url: stack_policy_url,
+        tags: to_request_tags
+      }
+    end
+
+    def delete_stack_request_params
+    {
+      stack_name: stack_name,
+      retain_resources: retain_resources
+    }
+    end
+
+  private
+
+    def stack
+      @stack ||= cloudformation.describe_stacks(
+        stack_name: stack_name
+      )[:stacks].first
+    end
+
+    def list_stack_resources(next_token = nil)
+      result = []
+      response = cloudformation.list_stack_resources(
+        stack_name: stack.stack_id
+      ).inject([]) do |arr, page|
+        arr.concat(page[:stack_resource_summaries])
+      end
+    end
+
+    def to_request_parameters(params = parameters)
+      params.map do |k, v|
+        if v == :use_previous_value
+          { 'parameter_key' => k, 'use_previous_value' => true }
+        else
+          { 'parameter_key' => k, 'parameter_value' => v || '' }
+        end
+      end
+    end
+
+    def to_request_tags(tagz = tags)
+      tagz.map do |k, v|
+        { 'key' => k, 'value' => v || '' }
+      end
+    end
+
+  end
+end

data/lib/stackit/template.rb

@@ -0,0 +1,51 @@
+module Stackit
+  class Template
+
+    attr_accessor :cloudformation
+    attr_accessor :template_path
+    attr_accessor :options
+    attr_accessor :parsed_parameters
+
+    def initialize(options = {})
+      @cloudformation = options[:cloudformation] || Stackit.cloudformation
+      @template_path = options[:template_path]
+      @options = {}
+    end
+
+    def parse!
+      Stackit.logger.info "Parsing cloudformation template: #{template_path}"
+      if @template_path =~ /^https:\/\/s3\.amazonaws\.com/
+        @options[:template_url] = @template_path
+      else
+        @options[:template_body] = body
+      end
+      @options[:parameters] = validate
+      self
+    end
+
+    def parsed_parameters
+      @parsed_parameters ||= @options[:parameters].inject({}) do |hash, param|
+        hash.merge(param['parameter_key'].to_sym => param['default_value'])
+      end
+    end
+
+    def needs_iam_capability?
+      body =~ /AWS::IAM::AccessKey|AWS::IAM::Group|AWS::IAM::InstanceProfile|AWS::IAM::Policy|AWS::IAM::Role|AWS::IAM::User|AWS::IAM::UserToGroupAddition/ ? true : false
+    end
+
+  private
+
+    def body
+      path = File.exist?(template_path) ? template_path : File.join(Dir.pwd, template_path)
+      raise "Unable to stat filesystem template #{template_path}" if !File.exist?(path)
+      File.read(path)
+    end
+
+    def validate
+      cloudformation.validate_template(
+        options.slice(:template_body, :template_url)
+      )[:parameters]
+    end
+
+  end
+end

data/lib/stackit/version.rb

@@ -0,0 +1,3 @@
+module Stackit
+  VERSION = "0.1.0"
+end

data/lib/stackit/wait.rb

@@ -0,0 +1,71 @@
+module Stackit
+
+  class WaitError < StandardError; end
+
+  module Wait
+
+    def wait_until_stack_info_has_key(key)
+      Stackit.logger.debug "Waiting until stack #{stack_name} has key #{key}..."
+      wait_for(timeout: 15.minutes) do
+        stack = Stack.new(stack_name: stack_name).hydrate!
+        raise "Stack failure: #{stack.stack_status}" if stack.stack_status =~ /FAILED/
+        if stack[key]
+          yield stack if block_given?
+          true
+        end
+      end
+    end
+
+    def wait_for_stack(status_pattern = /COMPLETE/)
+      Stackit.logger.debug "Waiting for stack #{stack_name} to complete..."
+      wait_for(timeout: 15.minutes) do
+        stack = Stack.new(stack_name: stack_name).hydrate!
+        case stack.stack_status
+        when /FAILED/
+          raise WaitError, "Stack failed during wait: #{stack_name}"
+        when status_pattern
+          yield stack if block_given?
+          true
+        else
+          false
+        end
+      end
+    end
+
+    def wait_for_stack_to_delete
+      Stackit.logger.debug "Waiting for stack #{stack_name} to delete..."
+      wait_for(timeout: 15.minutes) do
+        begin
+          stack = Stack.new(stack_name: stack_name).hydrate!
+          if stack.nil?
+            yield stack if block_given?
+            true
+          else
+            false
+          end
+        rescue Aws::CloudFormation::Errors::ValidationError => e
+          if e.message.include?("does not exist")
+            true
+          end
+        end
+      end
+    end
+
+  private
+
+    def wait_for(opts={})
+      raise ArgumentError, 'block expected' unless block_given?
+      timeout = opts[:timeout] || 600
+      interval = opts[:interval] || 10
+      attempts = timeout / interval
+      Stackit.logger.debug "Timeout: #{timeout}"
+      Stackit.logger.debug "Attempts: #{attempts}"
+      actual_attempts = attempts.times do
+        break if yield
+        sleep interval
+      end
+      actual_attempts != attempts
+    end
+
+  end
+end

data/lib/stackit.rb

@@ -0,0 +1,43 @@
+require "logger"
+require "pp"
+require "stackit/version"
+require 'json'
+require "active_support"
+require "active_support/all"
+require "awsclient"
+require "stackit/aws"
+require "stackit/template"
+require "stackit/stack/default_notifier"
+require "stackit/stack"
+require "stackit/stack/managed_stack"
+
+module Stackit
+  class << self
+
+    attr_accessor :aws
+    attr_accessor :cloudformation
+    attr_accessor :environment
+    attr_accessor :debug
+
+    def aws
+      @aws ||= Stackit::Aws.new
+    end
+
+    def cloudformation
+      @cloudformation ||= Stackit::Aws.new.cloudformation
+    end
+
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    def environment
+      @environment ||= :default
+    end
+
+    def debug
+      @debug ||= false
+    end
+
+  end
+end

data/stackit.gemspec

@@ -0,0 +1,40 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'stackit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "stackit"
+  spec.version       = Stackit::VERSION
+  spec.authors       = ["Jeremy Hahn"]
+  spec.email         = ["mail@jeremyhahn.com"]
+
+  spec.summary       = %q{Simple, elegant CloudFormation dependency management.}
+  spec.description   = %q{Use existing stack values (output, resource, or parameters) as input parmeters to templates.}
+  spec.homepage      = "https://github.com/jeremyhahn/stackit"
+  spec.license       = "GPLv3"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'pry-byebug', '~> 2.0'
+
+  spec.add_runtime_dependency 'awsclient'
+  spec.add_runtime_dependency 'aws-sdk', '~> 2'
+  spec.add_runtime_dependency 'thor', '~> 0.19'
+  spec.add_runtime_dependency 'activesupport', '~> 4.2'
+
+end
+

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: stackit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jeremy Hahn
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: awsclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+description: Use existing stack values (output, resource, or parameters) as input
+  parmeters to templates.
+email:
+- mail@jeremyhahn.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- bin/stackit
+- lib/stackit.rb
+- lib/stackit/aws.rb
+- lib/stackit/cli.rb
+- lib/stackit/stack.rb
+- lib/stackit/stack/default_notifier.rb
+- lib/stackit/stack/managed_stack.rb
+- lib/stackit/template.rb
+- lib/stackit/version.rb
+- lib/stackit/wait.rb
+- stackit.gemspec
+homepage: https://github.com/jeremyhahn/stackit
+licenses:
+- GPLv3
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Simple, elegant CloudFormation dependency management.
+test_files: []