stacker 0.0.2 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bc3ba2bbeac3d470e4d355cf4605df35e6640720
+  data.tar.gz: c6e53ace12414864ae41bbfe9a3ed32135daab50
+SHA512:
+  metadata.gz: 669c65102b76e13165b7668e56631f6b97d02ee5643f703ed2f0cdffa41c8d8844ae320e6ccfc218582a41f2e27f1f5079ecbe1ca10dd736bc42b768caae6662
+  data.tar.gz: 25f33fa2551709a54a55cd5a3633374c183078f8dbb7508f4ff986d180e9470d0ce1910bedf3cc13a507ad7a936ab3b7c99aa20832b4ddd5e163d9ab89e01096

data/bin/stacker

@@ -1,6 +1,9 @@
 #!/usr/bin/env ruby
 
+require 'rubygems'
 require 'stacker'
 require 'stacker/cli'
 
-Stacker::CLI.start
+trap('INT') { puts ''; exit }
+
+Stacker::Cli.start ARGV

data/lib/stacker.rb

@@ -1,5 +1,4 @@
-require "stacker/version"
-require "stacker/aws"
-require "stacker/repo"
-require "stacker/stack"
-require "stacker/template"
+require 'stacker/region'
+require 'stacker/stack'
+require 'stacker/logging'
+require 'stacker/version'

data/lib/stacker/cli.rb

@@ -1,119 +1,216 @@
-require 'trollop'
+require 'benchmark'
+require 'stacker'
+require 'thor'
 require 'yaml'
 
 module Stacker
-  module CLI
-    def self.start
-      read_variables
+  class Cli < Thor
+    include Thor::Actions
 
-      @stack = Stack.new(:name => @opts[:name])
+    default_path = ENV['STACKER_PATH'] || '.'
+    default_region = ENV['STACKER_REGION'] || 'us-east-1'
 
-      explain if verbose?
+    method_option :path,   default: default_path,   banner: 'project path'
+    method_option :region, default: default_region, banner: 'AWS region name'
+    def initialize(*args); super(*args) end
 
-      self.send @cmd
+    desc "init [PATH]", "Create stacker project directories"
+    def init path = nil
+      init_project path || options['path']
     end
 
-    def self.create
-      build_template
-      @stack.create(:template => @opts[:output])
-      describe
+    desc "list", "List stacks"
+    def list
+      Stacker.logger.inspect region.stacks.map(&:name)
     end
 
-    def self.delete
-      @stack.delete
-      describe
+    desc "show STACK_NAME", "Show details of a stack"
+    def show stack_name
+      with_one_or_all stack_name do |stack|
+        Stacker.logger.inspect(
+          'Description'  => stack.description,
+          'Status'       => stack.status,
+          'Updated'      => stack.last_updated_time || stack.creation_time,
+          'Capabilities' => stack.capabilities.remote,
+          'Parameters'   => stack.parameters.remote,
+          'Outputs'      => stack.outputs
+        )
+      end
     end
 
-    def self.describe
-      status @stack.describe.to_yaml
+    desc "status [STACK_NAME]", "Show stack status"
+    def status stack_name = nil
+      with_one_or_all(stack_name) do |stack|
+        Stacker.logger.debug stack.status.indent
+      end
     end
 
-    def self.events
-      status @stack.events.to_yaml
+    desc "diff [STACK_NAME]", "Show outstanding stack differences"
+    def diff stack_name = nil
+      with_one_or_all(stack_name) do |stack|
+        resolve stack
+        next unless full_diff stack
+      end
     end
 
-    def self.resources
-      status @stack.resources.to_yaml
+    desc "update [STACK_NAME]", "Create or update stack"
+    def update stack_name = nil
+      with_one_or_all(stack_name) do |stack|
+        resolve stack
+
+        if stack.exists?
+          next unless full_diff stack
+
+          if yes? "Update remote template with these changes (y/n)?"
+            time = Benchmark.realtime do
+              stack.update
+            end
+            Stacker.logger.info time stack_name, 'updated', time
+          else
+            Stacker.logger.warn 'Update skipped'
+          end
+        else
+          if yes? "#{stack.name} does not exist. Create it (y/n)?"
+            time = Benchmark.realtime do
+              stack.create
+            end
+            Stacker.logger.info time stack_name, 'created', time
+          else
+            Stacker.logger.warn 'Create skipped'
+          end
+        end
+      end
     end
 
-    def self.list
-      Stack.list.each do |stack|
-        status stack.to_yaml
+    desc "dump [STACK_NAME]", "Download stack template"
+    def dump stack_name = nil
+      with_one_or_all(stack_name) do |stack|
+        if stack.exists?
+          diff = stack.template.diff :down, :color
+          next Stacker.logger.warn 'Stack up-to-date' if diff.length == 0
+
+          Stacker.logger.debug "\n" + diff.indent
+          if yes? "Update local template with these changes (y/n)?"
+            stack.template.dump
+          else
+            Stacker.logger.warn 'Pull skipped'
+          end
+        else
+          Stacker.logger.warn "#{stack.name} does not exist"
+        end
       end
     end
 
-    def self.build_template
-      template = Template.new(:git_repo => @opts[:git_repo],
-                              :attributes => @opts[:attributes],
-                              :output => @opts[:output], 
-                              :path => @opts[:path], 
-                              :resources => @opts[:resources])
-      template.build
-    end
-
-    def self.read_variables
-      @cmd = ARGV.shift
-
-      @opts = case @cmd
-      when "create"
-        Trollop::options do
-          opt :attributes, "Attributes definition file", :default => 'attributes.json.erb'
-          opt :git_repo, "Git repository to export.", :type => String #:default => 'git@github.com:brettweavnet/stacker-repo.git'
-          opt :path, "Path to configuraiton repo.  If a -g or --git_repo is specified, it will override this setting.", :type => String 
-          opt :name, "Name of stack to create.", :type => String
-          opt :output, "Template output file.", :default => 'stack.json'
-          opt :resources, "Resource definition file", :default => 'resources.json.erb'
-          opt :silent, "Silent mode.", :default => false
-          opt :temp_dir, "Directory to export configuration git repo.", :default => File.join(Dir.home, "stack-repo")
-          opt :verbose, "Verbose mode.", :default => false
-        end
-      when "delete"
-        Trollop::options do
-          opt :name, "Name of stack to delete.", :type => String
-          opt :silent, "Silent mode.", :default => false
-          opt :verbose, "Verbose mode.", :default => false
-        end
-      when "describe"
-        Trollop::options do
-          opt :name, "Name of stack to describe.", :type => String
-          opt :verbose, "Verbose mode.", :default => false
-        end
-      when "events"
-        Trollop::options do
-          opt :name, "Name of stack who's events to display.", :type => String
-          opt :verbose, "Verbose mode.", :default => false
+    desc "fmt [STACK_NAME]", "Re-format template JSON"
+    def fmt stack_name = nil
+      with_one_or_all(stack_name) do |stack|
+        if stack.template.exists?
+          Stacker.logger.warn 'Formatting...'
+          stack.template.write
+        else
+          Stacker.logger.warn "#{stack.name} does not exist"
         end
-      when "list"
-        Trollop::options do
-          opt :verbose, "Verbose mode.", :default => false
+      end
+    end
+
+    private
+
+    def init_project path
+      project_path = File.expand_path path
+
+      %w[ regions templates ].each do |dir|
+        directory_path = File.join project_path, dir
+        unless Dir.exists? directory_path
+          Stacker.logger.debug "Creating directory at #{directory_path}"
+          FileUtils.mkdir_p directory_path
         end
-      when "resources"
-        Trollop::options do
-          opt :name, "Name of stack who's resources to display.", :type => String
-          opt :verbose, "Verbose mode.", :default => false
+      end
+
+      region_path = File.join project_path, 'regions', 'us-east-1.yml'
+      unless File.exists? region_path
+        Stacker.logger.debug "Creating region file at #{region_path}"
+        File.open(region_path, 'w+') { |f| f.print <<-YAML }
+defaults:
+  parameters:
+    CidrBlock: '10.0'
+stacks:
+  - name: VPC
+YAML
+      end
+    end
+
+    def full_diff stack
+      templ_diff = stack.template.diff :color
+      param_diff = stack.parameters.diff :color
+
+      if (templ_diff + param_diff).length == 0
+        Stacker.logger.warn 'Stack up-to-date'
+        return false
+      end
+
+      Stacker.logger.info "\n#{templ_diff.indent}\n" if templ_diff.length > 0
+      Stacker.logger.info "\n#{param_diff.indent}\n" if param_diff.length > 0
+
+      true
+    end
+
+    def region
+      @region ||= begin
+        config_path =  File.join working_path, 'regions', "#{options['region']}.yml"
+        if File.exists? config_path
+          begin
+            config = YAML.load_file(config_path)
+          rescue Psych::SyntaxError => err
+            Stacker.logger.fatal err.message
+            exit 1
+          end
+
+          defaults = config.fetch 'defaults', {}
+          stacks = config.fetch 'stacks', {}
+
+          Region.new options['region'], defaults, stacks, templates_path
+        else
+          Stacker.logger.fatal "#{options['region']}.yml does not exist. Please configure or use stacker init"
+          exit 1
         end
-      else
-        status "\nUnknown command: '#{@cmd}'.\n"
-        status "\nstacker [create|describe|delete|list] --help\n"
-        exit 1
       end
     end
 
-    def self.explain
-      status "\nExecuting #{@cmd} with following options:\n\n"
-      status @opts.to_yaml
+    def resolve stack
+      return {} if stack.parameters.resolver.dependencies.none?
+      Stacker.logger.debug 'Resolving dependencies...'
+      stack.parameters.resolved
     end
 
-    def self.verbose?
-      @opts[:verbose] && !silent?
+    def time (stack, action, benchmark)
+      return "Stack #{stack} #{action} in: #{(benchmark / 60).floor} min and #{(benchmark % 60).round} seconds."
     end
 
-    def self.silent?
-      @opts[:silent] if @opts
+    def with_one_or_all stack_name = nil, &block
+      yield_with_stack = proc do |stack|
+        Stacker.logger.info "#{stack.name}:"
+        yield stack
+        Stacker.logger.info ''
+      end
+
+      if stack_name
+        yield_with_stack.call region.stack(stack_name)
+      else
+        region.stacks.each(&yield_with_stack)
+      end
+
+    rescue Stacker::Stack::Error => err
+      Stacker.logger.fatal err.message
+      exit 1
+    end
+
+    def templates_path
+      File.join working_path, 'templates'
     end
 
-    def self.status(msg)
-      printf("#{msg}") unless silent? 
+    def working_path
+      File.expand_path options['path']
     end
+
   end
 end

data/lib/stacker/differ.rb

@@ -0,0 +1,31 @@
+require 'diffy'
+require 'json'
+
+module Stacker
+  module Differ
+
+    module_function
+
+    def diff one, two, *args
+      down = args.include? :down
+
+      diff = Diffy::Diff.new(
+        (down ? one : two) + "\n",
+        (down ? two : one) + "\n",
+        context: 3,
+        include_diff_info: true
+      ).to_s(*args.select { |arg| arg == :color })
+
+      diff.gsub(/^(\x1B.+)?(\-{3}|\+{3}).+\n/, '').strip
+    end
+
+    def json_diff one, two, *args
+      diff JSON.pretty_generate(one), JSON.pretty_generate(two), *args
+    end
+
+    def yaml_diff one, two, *args
+      diff YAML.dump(one), YAML.dump(two), *args
+    end
+
+  end
+end

data/lib/stacker/logging.rb

@@ -0,0 +1,61 @@
+require 'coderay'
+require 'delegate'
+require 'indentation'
+require 'rainbow'
+
+module Stacker
+  module_function
+
+  class << self
+
+    class PrettyLogger < SimpleDelegator
+      def initialize logger
+        super
+
+        old_formatter = logger.formatter
+
+        logger.formatter =  proc do |level, time, prog, msg|
+          unless msg.start_with?("\e")
+            color = case level
+                    when 'FATAL' then :red
+                    when 'WARN'  then :yellow
+                    when 'INFO'  then :blue
+                    when 'DEBUG' then '333333'
+                    else              :default
+                    end
+            msg = msg.color(color)
+          end
+
+          old_formatter.call level, time, prog, msg
+        end
+      end
+
+      %w[ debug info warn fatal ].each do |level|
+        define_method level do |msg, opts = {}|
+          if opts.include? :highlight
+            msg = CodeRay.scan(msg, opts[:highlight]).terminal
+          end
+          __getobj__.__send__ level, msg
+        end
+      end
+
+      def inspect object
+        info object.to_yaml[4..-1].strip.indent, highlight: :yaml
+      end
+    end
+
+    def logger= logger
+      @logger = PrettyLogger.new logger
+    end
+
+    def logger
+      @logger ||= begin
+        logger = Logger.new STDOUT
+        logger.level = Logger::DEBUG
+        logger.formatter = proc { |_, _, _, msg| "#{msg}\n" }
+        PrettyLogger.new logger
+      end
+    end
+
+  end
+end

data/lib/stacker/region.rb

@@ -0,0 +1,32 @@
+require 'aws-sdk'
+require 'stacker/stack'
+
+module Stacker
+  class Region
+
+    attr_reader :name, :defaults, :stacks, :templates_path
+
+    def initialize(name, defaults, stacks, templates_path)
+      @name = name
+      @defaults = defaults
+      @stacks = stacks.map do |options|
+        begin
+          Stack.new self, options.fetch('name'), options
+        rescue KeyError => err
+         Stacker.logger.fatal "Malformed YAML: #{err.message}"
+         exit 1
+        end
+      end
+      @templates_path = templates_path
+    end
+
+    def client
+      @client ||= AWS::CloudFormation.new region: name
+    end
+
+    def stack name
+      stacks.find { |s| s.name == name } || Stack.new(self, name)
+    end
+
+  end
+end

data/lib/stacker/resolver.rb

@@ -0,0 +1,29 @@
+module Stacker
+  class Resolver
+
+    attr_reader :region, :parameters
+
+    def initialize region, parameters
+      @region, @parameters = region, parameters
+    end
+
+    def dependencies
+      @dependencies ||= parameters.select { |_, value|
+        value.is_a?(Hash)
+      }.map { |_, value|
+        "#{value.fetch('Stack')}.#{value.fetch('Output')}"
+      }
+    end
+
+    def resolved
+      @resolved ||= Hash[parameters.map do |name, value|
+        if value.is_a? Hash
+          stack = region.stack value.fetch('Stack')
+          value = stack.outputs.fetch value.fetch('Output')
+        end
+        [ name, value ]
+      end]
+    end
+
+  end
+end

data/lib/stacker/stack.rb

@@ -1,45 +1,129 @@
-module Stacker
+require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/module/delegation'
+require 'aws-sdk'
+require 'memoist'
+require 'stacker/stack/capabilities'
+require 'stacker/stack/parameters'
+require 'stacker/stack/template'
 
+module Stacker
   class Stack
-    attr_accessor :name
 
-    def self.list
-      list = []
+    class Error < StandardError;     end
+    class DoesNotExistError < Error; end
+    class MissingParameters < Error; end
+    class UpToDateError < Error;     end
 
-      stacks = AWS::CloudFormation::Stack.list
-      stacks.body["Stacks"].each do |stack|
-        list << stack['StackName']
-      end
+    extend Memoist
+
+    CLIENT_METHODS = %w[
+      creation_time
+      description
+      exists?
+      last_updated_time
+      status
+      status_reason
+    ]
 
-      list
+    attr_reader :region, :name, :options
+
+    def initialize region, name, options = {}
+      @region, @name, @options = region, name, options
     end
 
-    def initialize(args={})
-      self.name = args[:name] if args[:name]
-      @stack = AWS::CloudFormation::Stack.new
+    def client
+      @client ||= region.client.stacks[name]
     end
 
-    def create(args)
-      file = File.open(args[:template], "rb")
-      contents = file.read
-      @stack.create(:name => name, :body => contents)
+    delegate *CLIENT_METHODS, to: :client
+    memoize *CLIENT_METHODS
+
+    %w[complete failed in_progress].each do |stage|
+      define_method(:"#{stage}?") { status =~ /#{stage.upcase}/ }
     end
 
-    def delete
-      @stack.delete(:name => name)
+    def template
+      @template ||= Template.new self
     end
 
-    def describe
-      @stack.describe(:name => name).body["Stacks"].first
+    def parameters
+      @parameters ||= Parameters.new self
     end
 
-    def events
-      @stack.events(:name => name).body["StackEvents"]
+    def capabilities
+      @capabilities ||= Capabilities.new self
     end
 
-    def resources
-      @stack.resources(:name => name).body["StackResources"]
+    def outputs
+      @outputs ||= begin
+        return {} unless complete?
+        Hash[client.outputs.map { |output| [ output.key, output.value ] }]
+      end
     end
-  end
 
+    def create blocking = true
+      if exists?
+        Stacker.logger.warn 'Stack already exists'
+        return
+      end
+
+      if parameters.missing.any?
+        raise MissingParameters.new(
+          "Required parameters missing: #{parameters.missing.join ', '}"
+        )
+      end
+
+      Stacker.logger.info 'Creating stack'
+
+      region.client.stacks.create(
+        name,
+        template.local,
+        parameters: parameters.resolved,
+        capabilities: capabilities.local
+      )
+
+      wait_while_status 'CREATE_IN_PROGRESS' if blocking
+    rescue AWS::CloudFormation::Errors::ValidationError => err
+      raise Error.new err.message
+    end
+
+    def update blocking = true
+      if parameters.missing.any?
+        raise MissingParameters.new(
+          "Required parameters missing: #{parameters.missing.join ', '}"
+        )
+      end
+
+      Stacker.logger.info 'Updating stack'
+
+      client.update(
+        template: template.local,
+        parameters: parameters.resolved,
+        capabilities: capabilities.local
+      )
+
+      wait_while_status 'UPDATE_IN_PROGRESS' if blocking
+    rescue AWS::CloudFormation::Errors::ValidationError => err
+      case err.message
+      when /does not exist/
+        raise DoesNotExistError.new err.message
+      when /No updates/
+        raise UpToDateError.new err.message
+      else
+        raise Error.new err.message
+      end
+    end
+
+    private
+
+    def wait_while_status wait_status
+      while flush_cache(:status) && status == wait_status
+        Stacker.logger.debug "#{name} Status => #{status}"
+        sleep 5
+      end
+      Stacker.logger.info "#{name} Status => #{status}"
+    end
+
+  end
 end
+

data/lib/stacker/stack/capabilities.rb

@@ -0,0 +1,17 @@
+require 'stacker/stack/component'
+
+module Stacker
+  class Stack
+    class Capabilities < Component
+
+      def local
+        @local ||= Array(stack.options.fetch 'capabilities', [])
+      end
+
+      def remote
+        @remote ||= client.capabilities
+      end
+
+    end
+  end
+end

data/lib/stacker/stack/component.rb

@@ -0,0 +1,22 @@
+require 'stacker/stack'
+
+module Stacker
+  class Stack
+    # an abstract base class for stack components (template, parameters)
+    class Component
+
+      attr_reader :stack
+
+      def initialize stack
+        @stack = stack
+      end
+
+      private
+
+      def client
+        stack.client
+      end
+
+    end
+  end
+end

data/lib/stacker/stack/parameters.rb

@@ -0,0 +1,68 @@
+require 'memoist'
+require 'stacker/differ'
+require 'stacker/resolver'
+require 'stacker/stack/component'
+
+module Stacker
+  class Stack
+    class Parameters < Component
+
+      extend Memoist
+
+      # everything required by the template
+      def template_definitions
+        stack.template.local.fetch 'Parameters', {}
+      end
+
+      def region_defaults
+        stack.region.defaults.fetch 'parameters', {}
+      end
+
+      # template defaults merged with region and stack-specific overrides
+      def local
+        region_defaults = stack.region.defaults.fetch 'parameters', {}
+
+        template_defaults = Hash[
+          template_definitions.select { |_, opts|
+            opts.key?('Default')
+          }.map { |name, opts|
+            [name, opts['Default']]
+          }
+        ]
+
+        available = template_defaults.merge(
+          region_defaults.merge(
+            stack.options.fetch 'parameters', {}
+          )
+        )
+
+        available.slice(*template_definitions.keys)
+      end
+
+      def missing
+        template_definitions.keys - local.keys
+      end
+
+      def remote
+        client.parameters
+      end
+      memoize :remote
+
+      def resolved
+        resolver.resolved
+      end
+      memoize :resolved
+
+      def resolver
+        Resolver.new stack.region, local
+      end
+      memoize :resolver
+
+      def diff *args
+        Differ.yaml_diff Hash[resolved.sort], Hash[remote.sort], *args
+      end
+      memoize :diff
+
+    end
+  end
+end

data/lib/stacker/stack/template.rb

@@ -0,0 +1,86 @@
+require 'active_support/core_ext/string/inflections'
+require 'json'
+require 'memoist'
+require 'stacker/differ'
+require 'stacker/stack/component'
+
+module Stacker
+  class Stack
+    class Template < Component
+
+      FORMAT_VERSION = '2010-09-09'
+
+      extend Memoist
+
+      def exists?
+        File.exists? path
+      end
+
+      def local
+        @local ||= begin
+          if exists?
+            template = JSON.parse File.read path
+            template['AWSTemplateFormatVersion'] ||= FORMAT_VERSION
+            template
+          else
+            {}
+          end
+        end
+      end
+
+      def remote
+        @remote ||= JSON.parse client.template
+      rescue AWS::CloudFormation::Errors::ValidationError => err
+        if err.message =~ /does not exist/
+          raise DoesNotExistError.new err.message
+        else
+          raise Error.new err.message
+        end
+      end
+
+      def diff *args
+        Differ.json_diff local, remote, *args
+      end
+      memoize :diff
+
+      def write value = local
+        File.write path, JSONFormatter.format(value)
+      end
+
+      def dump
+        write remote
+      end
+
+      private
+
+      def path
+        @path ||= File.join(
+          stack.region.templates_path,
+          "#{stack.options.fetch('template_name', stack.name)}.json"
+        )
+      end
+
+      class JSONFormatter
+        STR = '\"[^\"]+\"'
+
+        def self.format object
+          formatted = JSON.pretty_generate object
+
+          # put empty arrays on a single line
+          formatted.gsub! /: \[\s*\]/m, ': []'
+
+          # put { "Ref": ... } on a single line
+          formatted.gsub! /\{\s+\"Ref\"\:\s+(?<ref>#{STR})\s+\}/m,
+            '{ "Ref": \\k<ref> }'
+
+          # put { "Fn::GetAtt": ... } on a single line
+          formatted.gsub! /\{\s+\"Fn::GetAtt\"\: \[\s+(?<key>#{STR}),\s+(?<val>#{STR})\s+\]\s+\}/m,
+            '{ "Fn::GetAtt": [ \\k<key>, \\k<val> ] }'
+
+          formatted + "\n"
+        end
+      end
+
+    end
+  end
+end

data/lib/stacker/version.rb

@@ -1,3 +1,3 @@
 module Stacker
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,118 +1,199 @@
 --- !ruby/object:Gem::Specification
 name: stacker
 version: !ruby/object:Gem::Version
-  version: 0.0.2
-  prerelease: 
+  version: 0.1.0
 platform: ruby
 authors:
-- Brett Weaver
+- Cotap, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-10 00:00:00.000000000 -08:00
-default_executable: 
+date: 2014-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: &84986040 !ruby/object:Gem::Requirement
-    none: false
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '4.0'
+  type: :runtime
   prerelease: false
-  version_requirements: *84986040
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: coderay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: diffy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: fog
-  requirement: &84985830 !ruby/object:Gem::Requirement
-    none: false
+  name: indentation
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.0'
   type: :runtime
   prerelease: false
-  version_requirements: *84985830
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
 - !ruby/object:Gem::Dependency
-  name: git
-  requirement: &84985620 !ruby/object:Gem::Requirement
-    none: false
+  name: memoist
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
   type: :runtime
   prerelease: false
-  version_requirements: *84985620
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
 - !ruby/object:Gem::Dependency
-  name: json
-  requirement: &84985410 !ruby/object:Gem::Requirement
-    none: false
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.1'
   type: :runtime
   prerelease: false
-  version_requirements: *84985410
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: trollop
-  requirement: &84985200 !ruby/object:Gem::Requirement
-    none: false
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.18'
   type: :runtime
   prerelease: false
-  version_requirements: *84985200
-description: stacker integrates with git and AWS cloud formation to rapidley build
-  full application stacks from dynamic templates
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+description: Stacker helps you assemple and manage CloudFormation stacks and dependencies.
 email:
-- brett@weaver.io
+- martin@cotap.com
+- evan@cotap.com
 executables:
 - stacker
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rvmrc
-- Gemfile
-- README.md
-- Rakefile
 - bin/stacker
 - lib/stacker.rb
-- lib/stacker/aws.rb
 - lib/stacker/cli.rb
-- lib/stacker/repo.rb
+- lib/stacker/differ.rb
+- lib/stacker/logging.rb
+- lib/stacker/region.rb
+- lib/stacker/resolver.rb
 - lib/stacker/stack.rb
-- lib/stacker/template.rb
+- lib/stacker/stack/capabilities.rb
+- lib/stacker/stack/component.rb
+- lib/stacker/stack/parameters.rb
+- lib/stacker/stack/template.rb
 - lib/stacker/version.rb
-- stacker.gemspec
-has_rdoc: true
-homepage: http://brettweavnet.github.com/stacker
-licenses: []
+homepage: https://github.com/cotap/stacker
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: stacker
-rubygems_version: 1.6.2
+rubyforge_project: 
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
-summary: stacker helps build cloud stacks
+specification_version: 4
+summary: Easily assemble CloudFormation stacks.
 test_files: []

data/.gitignore

@@ -1,5 +0,0 @@
-*.gem
-.bundle
-Gemfile.lock
-pkg/*
-*.json

data/.rvmrc

@@ -1 +0,0 @@
-rvm use ruby-1.9.2-p180@stacker --create

data/Gemfile

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

data/README.md

@@ -1,21 +0,0 @@
-Stacker like to build full application stacks.  Creates cloud formation templates from a set of attributes, resource templates and data files.
-
-Getting started, first get the gem
-
-gem install stacker
-
-Then set the following environment variables to your AWS credentials:
-
-export AWS_SECRET_ACCESS_KEY='my aws secret key'
-
-export AWS_ACCESS_KEY_ID='my aws access key'
-
-export STACKER_DEFAULT_KEY='the name of my ssh key in AWS'
-
-Create your first stack from our repository
-
-stacker create -g git@github.com:brettweavnet/stacker-repo.git -n my-new-app
-
-You can then see the status on the stack build
-
-stacker describe -n my_new_app

data/Rakefile

@@ -1 +0,0 @@
-require "bundler/gem_tasks"

data/lib/stacker/aws.rb

@@ -1,47 +0,0 @@
-require 'fog'
-
-module Stacker
-  module AWS
-    module CloudFormation
-      class Stack
-        def initialize
-          @connect = Stack.connect
-        end
-
-        def self.list
-          Stack.connect.describe_stacks
-        end
-
-        def create(args)
-          @connect.create_stack(args[:name], 'TemplateBody' => args[:body] )
-        end
-
-        def delete(args)
-          @connect.delete_stack(args[:name])
-        end
-
-        def describe(args)
-          @connect.describe_stacks('StackName' => args[:name])
-        end
-
-        def events(args)
-          @connect.describe_stack_events(args[:name])
-        end
-
-        def resources(args)
-          @connect.describe_stack_resources('StackName' => args[:name])
-        end
-
-        private 
-
-        def self.connect
-          Fog::AWS::CloudFormation.new(
-            :aws_access_key_id      => ENV['AWS_ACCESS_KEY_ID'],
-            :aws_secret_access_key  => ENV['AWS_SECRET_ACCESS_KEY']
-          )
-        end
-
-      end
-    end
-  end
-end

data/lib/stacker/repo.rb

@@ -1,22 +0,0 @@
-require "git"
-
-module Stacker
-  class Repo
-
-    attr_accessor :git_repo, :temp_repo_export_dir
-
-    def initialize(args)
-      self.git_repo = args[:git_repo]
-      self.temp_repo_export_dir = "/tmp/repo-#{(0...8).map{65.+(rand(25)).chr}.join}"
-    end
-
-    def export
-      Dir.mkdir(temp_repo_export_dir, 0700)
-      Git.export(git_repo, temp_repo_export_dir)
-    end
-
-    def remove
-      FileUtils.remove_dir(temp_repo_export_dir)
-    end
-  end
-end

data/lib/stacker/template.rb

@@ -1,77 +0,0 @@
-require "erb"
-require "json"
-
-module Stacker
-
-  class Template
-
-    attr_accessor :attributes_file, :git_repo, :output_file, 
-                  :repo_path, :resources_file
-
-    def initialize(args)
-      self.attributes_file = args[:attributes]
-      self.git_repo = args[:git_repo]
-      self.output_file = args[:output]
-      self.repo_path = args[:path]
-      self.resources_file = args[:resources]
-
-      @repo = Repo.new(:git_repo => git_repo)
-    end
-
-    def build
-      begin
-        export_git_repo if git_repo
-        load_attributes
-        load_data
-        load_resources
-        create_template
-      ensure
-        remove_git_repo if git_repo
-      end
-    end
-
-    private
-
-    def load_attributes
-      template = IO.read("#{repo_path}/attributes/#{attributes_file}")
-      attributes_json = ERB.new(template).result(binding).to_s 
-      parsed_attributes = JSON.parse(attributes_json)
-      @data = parsed_attributes['data']
-      @resources = parsed_attributes['resources']
-    end
-
-    def load_data
-      data_dir = "#{repo_path}/data"
-
-      Dir.entries(data_dir).each do |data_file|
-        if data_file =~ /.erb$/
-          template = IO.read("#{data_dir}/#{data_file}")
-          data = ERB.new(template).result(binding).to_s 
-          instance_variable_set("@#{data_file.gsub(/.erb$/, '')}", data)
-        end
-      end
-    end
-
-    def load_resources
-      resource_template = IO.read("#{repo_path}/resources/#{resources_file}")
-      ERB.new(resource_template).result(binding)
-    end
-
-    def create_template
-      output_file_handle = File.new(output_file,'w')
-      output_file_handle.puts load_resources
-      output_file_handle.close
-    end
-
-    def export_git_repo
-      @repo.export
-      self.repo_path = @repo.temp_repo_export_dir
-    end
-
-    def remove_git_repo
-      @repo.remove
-    end
-
-  end
-
-end

data/stacker.gemspec

@@ -1,26 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "stacker/version"
-
-Gem::Specification.new do |s|
-  s.name        = "stacker"
-  s.version     = Stacker::VERSION
-  s.authors     = ["Brett Weaver"]
-  s.email       = ["brett@weaver.io"]
-  s.homepage    = "http://brettweavnet.github.com/stacker"
-  s.summary     = %q{stacker helps build cloud stacks}
-  s.description = %q{stacker integrates with git and AWS cloud formation to rapidley build full application stacks from dynamic templates}
-
-  s.rubyforge_project = "stacker"
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  s.add_development_dependency "rspec"
-  s.add_runtime_dependency "fog"
-  s.add_runtime_dependency "git"
-  s.add_runtime_dependency "json"
-  s.add_runtime_dependency "trollop"
-end