autostacker24 1.0.pre1420195669

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5504eb5540d79a296099f4b7e3e20e8956ffa7f6
+  data.tar.gz: 34aa0de0b82ea78c919503c70b44c19a242c97f9
+SHA512:
+  metadata.gz: 3339d2f678fd379179aebc52882802061522c57cae23685490e7b70132e500c6a50f025fd284325a38eeb71121b4241525028aefcf971bc19078cc545b3df108
+  data.tar.gz: ea14bf541ef75c9e7b8459a3d8c6332d581f5c74578951e412e847a1d4004efa3fdc4496c42ab369c3fea889295eedd090c3fa3cb922b66f0caa47e3a0fdfbb4

data/lib/autostacker24.rb

@@ -0,0 +1,3 @@
+
+require_relative 'autostacker24/service_stack.rb'
+require_relative 'autostacker24/stacker.rb'

data/lib/autostacker24/service_stack.rb

@@ -0,0 +1,43 @@
+require 'json'
+require_relative 'stacker.rb'
+
+class ServiceStack
+
+  def initialize(name, version, sandbox = nil, global_stack_name = nil)
+    @name = name || fail('mandatory name is not specified')
+    @version = version || ENV['VERSION'] || fail('mandatory version is not specified')
+    @sandbox = sandbox || ENV['SANDBOX']
+    @stack_name = (sandbox ? "#{sandbox}-" : '') + name
+    @global_stack_name  = global_stack_name || ENV['GLOBAL_STACK_NAME'] || 'global'
+  end
+
+  attr_reader :name, :sandbox, :version, :stack_name, :global_stack_name
+
+  def create_or_update(template, parameters)
+    inputs = JSON(template)['Parameters']
+    global_outputs.each{|k, v| parameters[k.to_sym] = v if inputs.has_key?(k.to_s)}
+    parameters[:Version] = version
+    Stacker.create_or_update_stack(stack_name, template, parameters)
+  end
+
+  def delete
+    Stacker.delete_stack(stack_name)
+  end
+
+  def outputs
+    @lazy_outputs ||= Stacker.get_stack_outputs(stack_name)
+  end
+
+  def global_outputs
+    @lazy_global_outputs ||= Stacker.get_stack_outputs(global_stack_name)
+  end
+
+  def estimate(template, parameters)
+    Stacker.estimate_template_cost(template, parameters)
+  end
+
+end
+
+if $0 ==__FILE__ # placeholder for interactive testing
+
+end

data/lib/autostacker24/stacker.rb

@@ -0,0 +1,98 @@
+require 'aws-sdk'
+
+module Stacker
+
+  def self.create_or_update_stack(stack_name, template_body, parameters)
+    if find_stack(stack_name).nil?
+      create_stack(stack_name, template_body, parameters)
+    else
+      update_stack(stack_name, template_body, parameters)
+    end
+  end
+
+  def self.create_stack(stack_name, template_body, parameters)
+    cloud_formation.create_stack(stack_name:    stack_name,
+                                 template_body: template_body,
+                                 on_failure:    'DELETE',
+                                 parameters:    transform_parameters(parameters),
+                                 capabilities:  ['CAPABILITY_IAM'])
+    wait_for_stack(stack_name, :create)
+  end
+
+  def self.update_stack(stack_name, template_body, parameters)
+    begin
+      cloud_formation.update_stack(stack_name:    stack_name,
+                                   template_body: template_body,
+                                   parameters:    transform_parameters(parameters),
+                                   capabilities:  ['CAPABILITY_IAM'])
+    rescue Aws::CloudFormation::Errors::ValidationError => error
+      raise error unless error.message =~ /No updates are to be performed/i # may be flaky, do more research in API
+      find_stack(stack_name)
+    else
+      wait_for_stack(stack_name, :update)
+    end
+  end
+
+  def self.delete_stack(stack_name)
+    cloud_formation.delete_stack(stack_name: stack_name)
+    wait_for_stack(stack_name, :delete)
+  end
+
+  def self.wait_for_stack(stack_name, operation, timeout_in_minutes = 15)
+    stop_time = Time.now + timeout_in_minutes * 60
+    finished = /(CREATE_COMPLETE|UPDATE_COMPLETE|DELETE_COMPLETE|ROLLBACK_COMPLETE|ROLLBACK_FAILED|CREATE_FAILED|DELETE_FAILED)$/
+    while Time.now < stop_time
+      stack = find_stack(stack_name)
+      status = stack ? stack.stack_status : 'DELETE_COMPLETE'
+      expected_status = case operation
+                          when :create then /CREATE_COMPLETE$/
+                          when :update then /UPDATE_COMPLETE$/
+                          when :delete then /DELETE_COMPLETE$/
+                        end
+      return true if status =~ expected_status
+      fail "#{stack_name} failed, current status #{status}" if status =~ finished
+      puts "waiting for #{stack_name}, current status #{status}"
+      sleep(7)
+    end
+    fail "waiting for stack timeout after #{timeout_in_minutes} minutes"
+  end
+
+  def self.find_stack(stack_name)
+    cloud_formation.describe_stacks(stack_name: stack_name).stacks.first
+  rescue Aws::CloudFormation::Errors::ValidationError => error
+    raise error unless error.message =~ /does not exist/i # may be flaky, do more research in API
+    nil
+  end
+
+  def self.estimate_template_cost(template_body, parameters)
+    cloud_formation.estimate_template_cost(:template_body => template_body, :parameters => transform_parameters(parameters))
+  end
+
+  def self.get_stack_outputs(stack_name, hash = {})
+    stack = find_stack(stack_name)
+    fail "stack #{stack_name} not found" unless stack
+    transform_outputs(stack.outputs, hash).freeze
+  end
+
+  def self.transform_outputs(outputs, existing_outputs = {})
+    outputs.inject(existing_outputs) { |m, o| m.merge(o.output_key.to_sym => o.output_value) }
+  end
+
+  def self.transform_parameters(parameters)
+    parameters.inject([]) { |m, kv| m << {parameter_key: kv[0].to_s, parameter_value: kv[1].to_s} }
+  end
+
+  def self.get_stack_resources(stack_name)
+    resources = cloud_formation.describe_stack_resources(stack_name: stack_name).data.stack_resources
+    resources.inject({}){|map, resource| map.merge(resource.logical_resource_id => resource)}.freeze
+  end
+
+  def self.cloud_formation # lazy CloudFormation client
+    @lazy_cloud_formation ||= Aws::CloudFormation::Client.new(region: ENV['AWS_DEFAULT_REGION'] || 'eu-west-1')
+  end
+
+end
+
+if $0 ==__FILE__ # placeholder for interactive testing
+
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: autostacker24
+version: !ruby/object:Gem::Version
+  version: 1.0.pre1420195669
+platform: ruby
+authors:
+- Johannes Mueller
+- Christian Rodemeyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.pre
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.pre
+description: n/a
+email:
+- jmueller@autoscout24.com
+- crodemeyer@autoscout24.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/autostacker24.rb
+- lib/autostacker24/service_stack.rb
+- lib/autostacker24/stacker.rb
+homepage: https://github.com/AutoScout24/autostacker24
+licenses:
+- MIT
+metadata: {}
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Library for managing AWS CloudFormation stacks
+test_files: []