autocanary24 0.1.0.pre.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 26fa649c88fc42c4c4e77d4a732695f298e9276d
+  data.tar.gz: 24d0de4d0b38ef6ce5f033db668da64cee47405e
+SHA512:
+  metadata.gz: 50666494d784f0252d165b4476c6ba7f84fc1f8ed83f919322992f4e43385009f227e178b5f90b2a7a8f5a358e02a6778a3dae0b498c03919e48731b9a3e29ff
+  data.tar.gz: 127c59c643c6077142f821fb9c918916d2dc5a593fc82fe154ed760804ebaf563a382837964232e76636495d71f73818b5a08911f9136ed27d072e998ef01d71

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+vendor
+.idea

data/.rspec

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

data/.travis.yml

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

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in autocanary24.gemspec
+gemspec
+
+gem 'aws-sdk', '~>2'
+gem 'autostacker24'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 AutoScout24 GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,74 @@
+# AutoCanary24
+
+AutoCanary24 is a ruby utility to do [blue/green](http://martinfowler.com/bliki/BlueGreenDeployment.html) and [canary](http://martinfowler.com/bliki/CanaryRelease.html) deployments with AWS CloudFormation stacks.
+
+This library use the [Swap AutoScaling Groups](http://www.slideshare.net/AmazonWebServices/dvo401-deep-dive-into-bluegreen-deployments-on-aws/32) approach and expects two stacks. A "base" stack which includes at least the `ELB` and another which includes the `AutoScaling Group`.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'autocanary24'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install autocanary24
+
+
+## Usage
+
+Initialize the client, e.g. in your `Rakefile` and deploy your stack:
+
+```ruby
+# Deploy the base stack before
+
+ac = AutoCanary24::Client.new({
+  keep_inactive_stack: false,
+  scaling_instance_percent: 50,
+  keep_instances_balanced: false})
+
+ac.deploy_stack(parent_stack_name, template, parameters, tags, deployment_check)
+```
+
+- `parent_stack_name`: the name of the 'base' stack. In addition `AutoStacker24` will read the output parameters of an existing stack and merge them to the given parameters.
+- `template`: is either the template json data itself or the name of a file containing the template body
+- `parameters`: specify the input parameter as a simple ruby hash. It gets converted to the
+  cumbersome AWS format automatically.
+  The template body will be validated and optionally preprocessed.
+- `tags`: Optional. Key-value pairs to associate with this stack.
+- 'deployment_check': Optional. A `lambda` which is executed whenever new instances are added to the ELB. If `true` AutoCanary continues, if `false` it will rollback to the current stack.
+
+> For more information about stacked CloudFormation stacks visit [AutoStacker24](https://github.com/autoscout24/autostacker24).
+
+The available configuration:
+- `keep_inactive_stack`: If `true` the inactive stack gets not deleted. Default is `false`
+- `keep_instances_balanced`: If `true` a instance from current stack gets removed whenever a new instance from the new stack is added. If `false` first all new instances are created and afterwards the old instances gets removed.
+- `scaling_instance_percent`: Percent of instances which are added at once (depends on the actual number of instances, read from desired)
+
+
+
+### Examples
+Have a look into the [examples subfolder](https://github.com/autoscout24/autocanary24/blob/master/examples/)
+
+## 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/autoscout24/autocanary24.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

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

data/autocanary24.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'autocanary24/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "autocanary24"
+  spec.version       = AutoCanary24::VERSION
+  spec.authors       = ["Philipp Garbe"]
+  spec.email         = ["pgarbe@autoscout24.com"]
+
+  spec.summary       = %q{A very narrow interface to AWS ECR}
+  spec.description   = %q{autocanary24 provides a small convenient module for blue/green and canary deployments with CloudFormation.}
+  spec.homepage      = "https://github.com/autoscout24/autocanary24"
+  spec.license       = "MIT"
+
+  # 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'] = "TODO: Set to 'http://mygemserver.com'"
+  # 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"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "autocanary24"
+
+# 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/examples/.bundle/config

@@ -0,0 +1,3 @@
+---
+BUNDLE_PATH: vendor/bundle
+BUNDLE_DISABLE_SHARED_GEMS: '1'

data/examples/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'aws-sdk', '~>2'
+gem 'autostacker24'

data/examples/Gemfile.lock

@@ -0,0 +1,26 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    autostacker24 (1.0.71)
+      aws-sdk-core (~> 2)
+      json (~> 1.8)
+      json_pure (~> 1.8)
+    aws-sdk (2.2.30)
+      aws-sdk-resources (= 2.2.30)
+    aws-sdk-core (2.2.30)
+      jmespath (~> 1.0)
+    aws-sdk-resources (2.2.30)
+      aws-sdk-core (= 2.2.30)
+    jmespath (1.1.3)
+    json (1.8.3)
+    json_pure (1.8.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  autostacker24
+  aws-sdk (~> 2)
+
+BUNDLED WITH
+   1.11.2

data/examples/Rakefile

@@ -0,0 +1,25 @@
+require "aws-sdk-core"
+require "autostacker24"
+require_relative "../lib/autocanary24/client"
+
+task :default do
+
+  # 1) Create the base stack which includes at least the ELB
+  parameters = {}
+  Stacker.create_or_update_stack('autocanary24-example', 'base-stack.json', parameters)
+
+  # 2) Create the stack which includes the ASG
+  client = AutoCanary24::Client.new({
+    :keep_inactive_stack => true
+  })
+
+  parameters = {}
+  client.deploy_stack('autocanary24-example', 'asg-stack.json', parameters)
+
+end
+
+task :cleanup do
+  Stacker.delete_stack('autocanary24-example-B')
+  Stacker.delete_stack('autocanary24-example-G')
+  Stacker.delete_stack('autocanary24-example')
+end

data/examples/asg-stack.json

@@ -0,0 +1,326 @@
+//AutoStacker24
+{
+  "AWSTemplateFormatVersion" : "2010-09-09",
+
+  "Description" : "AWS CloudFormation Sample Template AutoScalingMultiAZWithNotifications: Create a multi-az, load balanced and Auto Scaled sample web site running on an Apache Web Serever. The application is configured to span all Availability Zones in the region and is Auto-Scaled based on the CPU utilization of the web servers. Notifications will be sent to the operator email address on scaling events. The instances are load balanced with a simple health check against the default web page. **WARNING** This template creates one or more Amazon EC2 instances and an Elastic Load Balancer. You will be billed for the AWS resources used if you create a stack from this template.",
+
+  "Parameters" : {
+    "InstanceSecurityGroup": {
+      "Type": "String"
+    },
+    "InstanceType" : {
+      "Description" : "WebServer EC2 instance type",
+      "Type" : "String",
+      "Default" : "t2.nano",
+      "AllowedValues" : [ "t1.micro", "t2.nano", "t2.micro", "t2.small", "t2.medium", "t2.large", "m1.small", "m1.medium", "m1.large", "m1.xlarge", "m2.xlarge", "m2.2xlarge", "m2.4xlarge", "m3.medium", "m3.large", "m3.xlarge", "m3.2xlarge", "m4.large", "m4.xlarge", "m4.2xlarge", "m4.4xlarge", "m4.10xlarge", "c1.medium", "c1.xlarge", "c3.large", "c3.xlarge", "c3.2xlarge", "c3.4xlarge", "c3.8xlarge", "c4.large", "c4.xlarge", "c4.2xlarge", "c4.4xlarge", "c4.8xlarge", "g2.2xlarge", "g2.8xlarge", "r3.large", "r3.xlarge", "r3.2xlarge", "r3.4xlarge", "r3.8xlarge", "i2.xlarge", "i2.2xlarge", "i2.4xlarge", "i2.8xlarge", "d2.xlarge", "d2.2xlarge", "d2.4xlarge", "d2.8xlarge", "hi1.4xlarge", "hs1.8xlarge", "cr1.8xlarge", "cc2.8xlarge", "cg1.4xlarge"],
+      "ConstraintDescription" : "must be a valid EC2 instance type."
+    }
+  },
+
+  "Mappings" : {
+    "Region2Examples" : {
+      "us-east-1"      : { "Examples" : "https://s3.amazonaws.com/cloudformation-examples-us-east-1" },
+      "us-west-2"      : { "Examples" : "https://s3-us-west-2.amazonaws.com/cloudformation-examples-us-west-2" },
+      "us-west-1"      : { "Examples" : "https://s3-us-west-1.amazonaws.com/cloudformation-examples-us-west-1" },
+      "eu-west-1"      : { "Examples" : "https://s3-eu-west-1.amazonaws.com/cloudformation-examples-eu-west-1" },
+      "eu-central-1"   : { "Examples" : "https://s3-eu-central-1.amazonaws.com/cloudformation-examples-eu-central-1" },
+      "ap-southeast-1" : { "Examples" : "https://s3-ap-southeast-1.amazonaws.com/cloudformation-examples-ap-southeast-1" },
+      "ap-northeast-1" : { "Examples" : "https://s3-ap-northeast-1.amazonaws.com/cloudformation-examples-ap-northeast-1" },
+      "ap-northeast-2" : { "Examples" : "https://s3-ap-northeast-2.amazonaws.com/cloudformation-examples-ap-northeast-2" },
+      "ap-southeast-2" : { "Examples" : "https://s3-ap-southeast-2.amazonaws.com/cloudformation-examples-ap-southeast-2" },
+      "sa-east-1"      : { "Examples" : "https://s3-sa-east-1.amazonaws.com/cloudformation-examples-sa-east-1" },
+      "cn-north-1"     : { "Examples" : "https://s3.cn-north-1.amazonaws.com.cn/cloudformation-examples-cn-north-1" }
+    },
+    "AWSInstanceType2Arch" : {
+      "t1.micro"    : { "Arch" : "PV64"   },
+      "t2.nano"     : { "Arch" : "HVM64"  },
+      "t2.micro"    : { "Arch" : "HVM64"  },
+      "t2.small"    : { "Arch" : "HVM64"  },
+      "t2.medium"   : { "Arch" : "HVM64"  },
+      "t2.large"    : { "Arch" : "HVM64"  },
+      "m1.small"    : { "Arch" : "PV64"   },
+      "m1.medium"   : { "Arch" : "PV64"   },
+      "m1.large"    : { "Arch" : "PV64"   },
+      "m1.xlarge"   : { "Arch" : "PV64"   },
+      "m2.xlarge"   : { "Arch" : "PV64"   },
+      "m2.2xlarge"  : { "Arch" : "PV64"   },
+      "m2.4xlarge"  : { "Arch" : "PV64"   },
+      "m3.medium"   : { "Arch" : "HVM64"  },
+      "m3.large"    : { "Arch" : "HVM64"  },
+      "m3.xlarge"   : { "Arch" : "HVM64"  },
+      "m3.2xlarge"  : { "Arch" : "HVM64"  },
+      "m4.large"    : { "Arch" : "HVM64"  },
+      "m4.xlarge"   : { "Arch" : "HVM64"  },
+      "m4.2xlarge"  : { "Arch" : "HVM64"  },
+      "m4.4xlarge"  : { "Arch" : "HVM64"  },
+      "m4.10xlarge" : { "Arch" : "HVM64"  },
+      "c1.medium"   : { "Arch" : "PV64"   },
+      "c1.xlarge"   : { "Arch" : "PV64"   },
+      "c3.large"    : { "Arch" : "HVM64"  },
+      "c3.xlarge"   : { "Arch" : "HVM64"  },
+      "c3.2xlarge"  : { "Arch" : "HVM64"  },
+      "c3.4xlarge"  : { "Arch" : "HVM64"  },
+      "c3.8xlarge"  : { "Arch" : "HVM64"  },
+      "c4.large"    : { "Arch" : "HVM64"  },
+      "c4.xlarge"   : { "Arch" : "HVM64"  },
+      "c4.2xlarge"  : { "Arch" : "HVM64"  },
+      "c4.4xlarge"  : { "Arch" : "HVM64"  },
+      "c4.8xlarge"  : { "Arch" : "HVM64"  },
+      "g2.2xlarge"  : { "Arch" : "HVMG2"  },
+      "g2.8xlarge"  : { "Arch" : "HVMG2"  },
+      "r3.large"    : { "Arch" : "HVM64"  },
+      "r3.xlarge"   : { "Arch" : "HVM64"  },
+      "r3.2xlarge"  : { "Arch" : "HVM64"  },
+      "r3.4xlarge"  : { "Arch" : "HVM64"  },
+      "r3.8xlarge"  : { "Arch" : "HVM64"  },
+      "i2.xlarge"   : { "Arch" : "HVM64"  },
+      "i2.2xlarge"  : { "Arch" : "HVM64"  },
+      "i2.4xlarge"  : { "Arch" : "HVM64"  },
+      "i2.8xlarge"  : { "Arch" : "HVM64"  },
+      "d2.xlarge"   : { "Arch" : "HVM64"  },
+      "d2.2xlarge"  : { "Arch" : "HVM64"  },
+      "d2.4xlarge"  : { "Arch" : "HVM64"  },
+      "d2.8xlarge"  : { "Arch" : "HVM64"  },
+      "hi1.4xlarge" : { "Arch" : "HVM64"  },
+      "hs1.8xlarge" : { "Arch" : "HVM64"  },
+      "cr1.8xlarge" : { "Arch" : "HVM64"  },
+      "cc2.8xlarge" : { "Arch" : "HVM64"  }
+    },
+    "AWSInstanceType2NATArch" : {
+      "t1.micro"    : { "Arch" : "NATPV64"   },
+      "t2.nano"     : { "Arch" : "NATHVM64"  },
+      "t2.micro"    : { "Arch" : "NATHVM64"  },
+      "t2.small"    : { "Arch" : "NATHVM64"  },
+      "t2.medium"   : { "Arch" : "NATHVM64"  },
+      "t2.large"    : { "Arch" : "NATHVM64"  },
+      "m1.small"    : { "Arch" : "NATPV64"   },
+      "m1.medium"   : { "Arch" : "NATPV64"   },
+      "m1.large"    : { "Arch" : "NATPV64"   },
+      "m1.xlarge"   : { "Arch" : "NATPV64"   },
+      "m2.xlarge"   : { "Arch" : "NATPV64"   },
+      "m2.2xlarge"  : { "Arch" : "NATPV64"   },
+      "m2.4xlarge"  : { "Arch" : "NATPV64"   },
+      "m3.medium"   : { "Arch" : "NATHVM64"  },
+      "m3.large"    : { "Arch" : "NATHVM64"  },
+      "m3.xlarge"   : { "Arch" : "NATHVM64"  },
+      "m3.2xlarge"  : { "Arch" : "NATHVM64"  },
+      "m4.large"    : { "Arch" : "NATHVM64"  },
+      "m4.xlarge"   : { "Arch" : "NATHVM64"  },
+      "m4.2xlarge"  : { "Arch" : "NATHVM64"  },
+      "m4.4xlarge"  : { "Arch" : "NATHVM64"  },
+      "m4.10xlarge" : { "Arch" : "NATHVM64"  },
+      "c1.medium"   : { "Arch" : "NATPV64"   },
+      "c1.xlarge"   : { "Arch" : "NATPV64"   },
+      "c3.large"    : { "Arch" : "NATHVM64"  },
+      "c3.xlarge"   : { "Arch" : "NATHVM64"  },
+      "c3.2xlarge"  : { "Arch" : "NATHVM64"  },
+      "c3.4xlarge"  : { "Arch" : "NATHVM64"  },
+      "c3.8xlarge"  : { "Arch" : "NATHVM64"  },
+      "c4.large"    : { "Arch" : "NATHVM64"  },
+      "c4.xlarge"   : { "Arch" : "NATHVM64"  },
+      "c4.2xlarge"  : { "Arch" : "NATHVM64"  },
+      "c4.4xlarge"  : { "Arch" : "NATHVM64"  },
+      "c4.8xlarge"  : { "Arch" : "NATHVM64"  },
+      "g2.2xlarge"  : { "Arch" : "NATHVMG2"  },
+      "g2.8xlarge"  : { "Arch" : "NATHVMG2"  },
+      "r3.large"    : { "Arch" : "NATHVM64"  },
+      "r3.xlarge"   : { "Arch" : "NATHVM64"  },
+      "r3.2xlarge"  : { "Arch" : "NATHVM64"  },
+      "r3.4xlarge"  : { "Arch" : "NATHVM64"  },
+      "r3.8xlarge"  : { "Arch" : "NATHVM64"  },
+      "i2.xlarge"   : { "Arch" : "NATHVM64"  },
+      "i2.2xlarge"  : { "Arch" : "NATHVM64"  },
+      "i2.4xlarge"  : { "Arch" : "NATHVM64"  },
+      "i2.8xlarge"  : { "Arch" : "NATHVM64"  },
+      "d2.xlarge"   : { "Arch" : "NATHVM64"  },
+      "d2.2xlarge"  : { "Arch" : "NATHVM64"  },
+      "d2.4xlarge"  : { "Arch" : "NATHVM64"  },
+      "d2.8xlarge"  : { "Arch" : "NATHVM64"  },
+      "hi1.4xlarge" : { "Arch" : "NATHVM64"  },
+      "hs1.8xlarge" : { "Arch" : "NATHVM64"  },
+      "cr1.8xlarge" : { "Arch" : "NATHVM64"  },
+      "cc2.8xlarge" : { "Arch" : "NATHVM64"  }
+    },
+    "AWSRegionArch2AMI" : {
+      "us-east-1"        : {"PV64" : "ami-5fb8c835", "HVM64" : "ami-60b6c60a", "HVMG2" : "ami-e998ea83"},
+      "us-west-2"        : {"PV64" : "ami-d93622b8", "HVM64" : "ami-f0091d91", "HVMG2" : "ami-315f4850"},
+      "us-west-1"        : {"PV64" : "ami-56ea8636", "HVM64" : "ami-d5ea86b5", "HVMG2" : "ami-943956f4"},
+      "eu-west-1"        : {"PV64" : "ami-95e33ce6", "HVM64" : "ami-bff32ccc", "HVMG2" : "ami-83fd23f0"},
+      "eu-central-1"     : {"PV64" : "ami-794a5915", "HVM64" : "ami-bc5b48d0", "HVMG2" : "ami-ba1a09d6"},
+      "ap-northeast-1"   : {"PV64" : "ami-393c1957", "HVM64" : "ami-383c1956", "HVMG2" : "ami-08e5c166"},
+      "ap-northeast-2"   : {"PV64" : "NOT_SUPPORTED", "HVM64" : "ami-249b554a", "HVMG2" : "NOT_SUPPORTED"},
+      "ap-southeast-1"   : {"PV64" : "ami-34bd7a57", "HVM64" : "ami-c9b572aa", "HVMG2" : "ami-5a15d239"},
+      "ap-southeast-2"   : {"PV64" : "ami-ced887ad", "HVM64" : "ami-48d38c2b", "HVMG2" : "ami-0c1a446f"},
+      "sa-east-1"        : {"PV64" : "ami-7d15ad11", "HVM64" : "ami-6817af04", "HVMG2" : "NOT_SUPPORTED"},
+      "cn-north-1"       : {"PV64" : "ami-18ac6575", "HVM64" : "ami-43a36a2e", "HVMG2" : "NOT_SUPPORTED"}
+    }
+  },
+
+  "Resources" : {
+    "WebServerGroup" : {
+      "Type" : "AWS::AutoScaling::AutoScalingGroup",
+      "Properties" : {
+        "AvailabilityZones" : { "Fn::GetAZs" : ""},
+        "LaunchConfigurationName" : { "Ref" : "LaunchConfig" },
+        "MinSize" : "1",
+        "MaxSize" : "3",
+        "HealthCheckGracePeriod" : "600",
+        "HealthCheckType" : "ELB"
+      },
+      "CreationPolicy" : {
+        "ResourceSignal" : {
+          "Timeout" : "PT15M",
+          "Count"   : "1"
+        }
+      },
+      "UpdatePolicy": {
+        "AutoScalingRollingUpdate": {
+          "MinInstancesInService": "1",
+          "MaxBatchSize": "1",
+          "PauseTime" : "PT15M",
+          "WaitOnResourceSignals": "true"
+        }
+      }
+    },
+
+    "LaunchConfig" : {
+      "Type" : "AWS::AutoScaling::LaunchConfiguration",
+      "Metadata" : {
+        "Comment" : "Install a simple application",
+        "AWS::CloudFormation::Init" : {
+          "config" : {
+            "packages" : {
+              "yum" : {
+                "httpd" : []
+              }
+            },
+
+            "files" : {
+              "/var/www/html/index.html" : {
+                "content" : { "Fn::Join" : ["\n", [
+                  "<img src=\"", {"Fn::FindInMap" : ["Region2Examples", {"Ref" : "AWS::Region"}, "Examples"]}, "/cloudformation_graphic.png\" alt=\"AWS CloudFormation Logo\"/>",
+                  "<h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>"
+                ]]},
+                "mode"    : "000644",
+                "owner"   : "root",
+                "group"   : "root"
+              },
+
+              "/etc/cfn/cfn-hup.conf" : {
+                "content" : { "Fn::Join" : ["", [
+                  "[main]\n",
+                  "stack=", { "Ref" : "AWS::StackId" }, "\n",
+                  "region=", { "Ref" : "AWS::Region" }, "\n"
+                ]]},
+                "mode"    : "000400",
+                "owner"   : "root",
+                "group"   : "root"
+              },
+
+              "/etc/cfn/hooks.d/cfn-auto-reloader.conf" : {
+                "content": { "Fn::Join" : ["", [
+                  "[cfn-auto-reloader-hook]\n",
+                  "triggers=post.update\n",
+                  "path=Resources.LaunchConfig.Metadata.AWS::CloudFormation::Init\n",
+                  "action=/opt/aws/bin/cfn-init -v ",
+                  "         --stack ", { "Ref" : "AWS::StackName" },
+                  "         --resource LaunchConfig ",
+                  "         --region ", { "Ref" : "AWS::Region" }, "\n",
+                  "runas=root\n"
+                ]]}
+              }
+            },
+
+            "services" : {
+              "sysvinit" : {
+                "httpd"    : { "enabled" : "true", "ensureRunning" : "true" },
+                "cfn-hup" : { "enabled" : "true", "ensureRunning" : "true",
+                              "files" : ["/etc/cfn/cfn-hup.conf", "/etc/cfn/hooks.d/cfn-auto-reloader.conf"]}
+              }
+            }
+          }
+        }
+      },
+      "Properties" : {
+        "ImageId" : { "Fn::FindInMap" : [ "AWSRegionArch2AMI", { "Ref" : "AWS::Region" },
+                                          { "Fn::FindInMap" : [ "AWSInstanceType2Arch", { "Ref" : "InstanceType" }, "Arch" ] } ] },
+        "SecurityGroups" : [ { "Ref" : "InstanceSecurityGroup" } ],
+        "InstanceType" : { "Ref" : "InstanceType" },
+        "UserData"       : { "Fn::Base64" : { "Fn::Join" : ["", [
+             "#!/bin/bash -xe\n",
+             "yum update -y aws-cfn-bootstrap\n",
+
+             "/opt/aws/bin/cfn-init -v ",
+             "         --stack ", { "Ref" : "AWS::StackName" },
+             "         --resource LaunchConfig ",
+             "         --region ", { "Ref" : "AWS::Region" }, "\n",
+
+             "/opt/aws/bin/cfn-signal -e $? ",
+             "         --stack ", { "Ref" : "AWS::StackName" },
+             "         --resource WebServerGroup ",
+             "         --region ", { "Ref" : "AWS::Region" }, "\n"
+        ]]}}
+      }
+    },
+
+    "CPUAlarmHigh": {
+     "Type": "AWS::CloudWatch::Alarm",
+     "Properties": {
+        "AlarmDescription": "Scale-up if CPU > 90% for 10 minutes",
+        "MetricName": "CPUUtilization",
+        "Namespace": "AWS/EC2",
+        "Statistic": "Average",
+        "Period": "300",
+        "EvaluationPeriods": "2",
+        "Threshold": "90",
+        "AlarmActions": [ { "Ref": "WebServerScaleUpPolicy" } ],
+        "Dimensions": [
+          {
+            "Name": "AutoScalingGroupName",
+            "Value": { "Ref": "WebServerGroup" }
+          }
+        ],
+        "ComparisonOperator": "GreaterThanThreshold"
+      }
+    },
+    "CPUAlarmLow": {
+     "Type": "AWS::CloudWatch::Alarm",
+     "Properties": {
+        "AlarmDescription": "Scale-down if CPU < 70% for 10 minutes",
+        "MetricName": "CPUUtilization",
+        "Namespace": "AWS/EC2",
+        "Statistic": "Average",
+        "Period": "300",
+        "EvaluationPeriods": "2",
+        "Threshold": "70",
+        "AlarmActions": [ { "Ref": "WebServerScaleDownPolicy" } ],
+        "Dimensions": [
+          {
+            "Name": "AutoScalingGroupName",
+            "Value": { "Ref": "WebServerGroup" }
+          }
+        ],
+        "ComparisonOperator": "LessThanThreshold"
+      }
+    },
+
+    "WebServerScaleUpPolicy" : {
+      "Type" : "AWS::AutoScaling::ScalingPolicy",
+      "Properties" : {
+        "AdjustmentType" : "ChangeInCapacity",
+        "AutoScalingGroupName" : { "Ref" : "WebServerGroup" },
+        "Cooldown" : "60",
+        "ScalingAdjustment" : "1"
+      }
+    },
+    "WebServerScaleDownPolicy" : {
+      "Type" : "AWS::AutoScaling::ScalingPolicy",
+      "Properties" : {
+        "AdjustmentType" : "ChangeInCapacity",
+        "AutoScalingGroupName" : { "Ref" : "WebServerGroup" },
+        "Cooldown" : "60",
+        "ScalingAdjustment" : "-1"
+      }
+    }
+  }
+}

data/examples/base-stack.json

@@ -0,0 +1,59 @@
+//AutoStacker24
+{
+  "AWSTemplateFormatVersion" : "2010-09-09",
+
+  "Description" : "AWS CloudFormation Sample Template AutoScalingMultiAZWithNotifications: Create a multi-az, load balanced and Auto Scaled sample web site running on an Apache Web Serever. The application is configured to span all Availability Zones in the region and is Auto-Scaled based on the CPU utilization of the web servers. Notifications will be sent to the operator email address on scaling events. The instances are load balanced with a simple health check against the default web page. **WARNING** This template creates one or more Amazon EC2 instances and an Elastic Load Balancer. You will be billed for the AWS resources used if you create a stack from this template.",
+
+  "Parameters" : {
+  },
+
+  "Resources" : {
+
+    "ElasticLoadBalancer" : {
+      "Type" : "AWS::ElasticLoadBalancing::LoadBalancer",
+      "Properties" : {
+        "AvailabilityZones" : { "Fn::GetAZs" : "" },
+        "CrossZone" : "true",
+        "Listeners" : [ {
+          "LoadBalancerPort" : "80",
+          "InstancePort" : "80",
+          "Protocol" : "HTTP"
+        } ],
+        "HealthCheck" : {
+          "Target" : "HTTP:80/",
+          "HealthyThreshold" : "3",
+          "UnhealthyThreshold" : "5",
+          "Interval" : "30",
+          "Timeout" : "5"
+        }
+      }
+    },
+
+    "InstanceSecurityGroup" : {
+      "Type" : "AWS::EC2::SecurityGroup",
+      "Properties" : {
+        "GroupDescription" : "Enable SSH access and HTTP from the load balancer only",
+        "SecurityGroupIngress" : [
+          {
+            "IpProtocol" : "tcp",
+            "FromPort" : "80",
+            "ToPort" : "80",
+            "SourceSecurityGroupOwnerId" : {"Fn::GetAtt" : ["ElasticLoadBalancer", "SourceSecurityGroup.OwnerAlias"]},
+            "SourceSecurityGroupName" : {"Fn::GetAtt" : ["ElasticLoadBalancer", "SourceSecurityGroup.GroupName"]}
+          }
+        ]
+      }
+    }
+  },
+
+  "Outputs" : {
+    "InstanceSecurityGroup" : {
+      "Description" : "The security group id of the instance",
+      "Value" : { "Fn::GetAtt" : [ "InstanceSecurityGroup", "GroupId" ]}
+    },
+    "URL" : {
+      "Description" : "The URL of the website",
+      "Value" :  { "Fn::Join" : [ "", [ "http://", { "Fn::GetAtt" : [ "ElasticLoadBalancer", "DNSName" ]}]]}
+    }
+  }
+}

data/lib/autocanary24.rb

@@ -0,0 +1,9 @@
+require "autocanary24/version"
+require "autocanary24/client"
+require "autocanary24/configuration"
+require "autocanary24/canarystack"
+require 'aws-sdk-core'
+require 'base64'
+
+module AutoCanary24
+end

data/lib/autocanary24/canarystack.rb

@@ -0,0 +1,178 @@
+require 'aws-sdk-core'
+
+module AutoCanary24
+  class CanaryStack
+    attr_reader :stack_name
+
+    def initialize(stack_name, wait_timeout, sleep_during_wait = 5)
+      raise "ERR: stack_name is missing" if stack_name.nil?
+      raise "ERR: wait_timeout is missing" if wait_timeout.nil?
+      @stack_name = stack_name
+      @wait_timeout = wait_timeout
+      @sleep_during_wait = sleep_during_wait
+    end
+
+    def get_desired_capacity
+      asg = get_autoscaling_group
+      asg_client = Aws::AutoScaling::Client.new
+      describe_asg(asg).desired_capacity
+    end
+
+    def set_desired_capacity_and_wait(desired_capacity)
+      asg = get_autoscaling_group
+      asg_client = Aws::AutoScaling::Client.new
+      resp = asg_client.set_desired_capacity({
+        auto_scaling_group_name: asg,
+        desired_capacity: desired_capacity,
+        honor_cooldown: false,
+      })
+      wait_for_instances_in_asg(asg, desired_capacity)
+    end
+
+    def is_attached_to(elb)
+      asg = get_autoscaling_group
+      elbs = get_attached_loadbalancers(asg) unless asg.nil?
+      (!elbs.nil? && elbs.any? { |e| e.load_balancer_name == elb })
+    end
+
+    def attach_instances_to_elb_and_wait(elb, instances)
+      elb_client = Aws::ElasticLoadBalancing::Client.new
+      elb_client.register_instances_with_load_balancer({ load_balancer_name: elb, instances: instances })
+      wait_for_instances_attached_to_elb(instances, elb)
+    end
+
+    def detach_instances_from_elb(elb, instances)
+      elb_client = Aws::ElasticLoadBalancing::Client.new
+      elb_client.deregister_instances_from_load_balancer({ load_balancer_name: elb, instances: instances })
+    end
+
+    def detach_asg_from_elb_and_wait(elb)
+      asg = get_autoscaling_group
+      asg_client = Aws::AutoScaling::Client.new
+      asg_client.detach_load_balancers({auto_scaling_group_name: asg, load_balancer_names: [elb]})
+      wait_for_asg_detached_from_elb(asg, elb)
+    end
+
+    def attach_asg_to_elb_and_wait(elb)
+      asg = get_autoscaling_group
+      asg_client = Aws::AutoScaling::Client.new
+      asg_client.attach_load_balancers({auto_scaling_group_name: asg, load_balancer_names: [elb]})
+      wait_for_asg_on_elb(asg, elb)
+    end
+
+    def suspend_asg_processes
+      processes = ['Launch', 'Terminate', 'AddToLoadBalancer', 'AlarmNotification']
+      asg = get_autoscaling_group
+      asg_client = Aws::AutoScaling::Client.new
+      asg_client.suspend_processes({auto_scaling_group_name: asg, scaling_processes: processes})
+    end
+
+    def resume_asg_processes
+      processes = ['Launch', 'Terminate', 'AddToLoadBalancer', 'AlarmNotification']
+      asg = get_autoscaling_group
+      asg_client = Aws::AutoScaling::Client.new
+      asg_client.resume_processes({auto_scaling_group_name: asg, scaling_processes: processes})
+    end
+
+    def get_instance_ids
+      asg = get_autoscaling_group
+      asg_client = Aws::AutoScaling::Client.new
+      describe_asg(asg)[:instances].map{ |i| { instance_id: i[:instance_id] } }
+    end
+
+
+    private
+    def describe_asg(asg)
+      asg_client = Aws::AutoScaling::Client.new
+      asg_client.describe_auto_scaling_groups({auto_scaling_group_names: [asg], max_records: 1})[:auto_scaling_groups][0]
+    end
+
+    def wait_for_asg_detached_from_elb(asg, elb)
+      auto_scaling_group = describe_asg(asg)
+
+      if auto_scaling_group[:load_balancer_names].select{|l| l == elb}.length == 1
+        puts "WARNING: ASG still on the ELB!"
+      end
+
+      instances = auto_scaling_group[:instances].map{ |i| { instance_id: i[:instance_id] } }
+      wait_for_instances_detached_from_elb(instances, elb)
+    end
+
+    def wait_for_instances_detached_from_elb(instances, elb)
+      elb_client = Aws::ElasticLoadBalancing::Client.new
+      retries = (@wait_timeout / @sleep_during_wait).round
+      while retries > 0
+        begin
+          elb_instances = elb_client.describe_instance_health({load_balancer_name: elb, instances: instances})
+          break if elb_instances[:instance_states].select{ |s| s.state == 'InService' }.length == 0
+        rescue Aws::ElasticLoadBalancing::Errors::InvalidInstance
+        end
+        sleep @sleep_during_wait
+        retries -= 1
+      end
+
+      raise "Timeout. Couldn't wait for instances '#{instances}' to get detached from ELB '#{elb}'." if retries == 0
+    end
+
+    def wait_for_asg_on_elb(asg, elb)
+      auto_scaling_group = describe_asg(asg)
+
+      if auto_scaling_group[:load_balancer_names].select{|l| l == elb}.length == 0
+        puts "WARNING: ASG not on the ELB yet!"
+      end
+
+      instances = auto_scaling_group[:instances].map{ |i| { instance_id: i[:instance_id] } }
+      wait_for_instances_attached_to_elb(instances, elb)
+    end
+
+    def wait_for_instances_attached_to_elb(instances, elb)
+      elb_client = Aws::ElasticLoadBalancing::Client.new
+      retries = (@wait_timeout / @sleep_during_wait).round
+      while retries > 0
+        begin
+          elb_instances = elb_client.describe_instance_health({load_balancer_name: elb, instances: instances})
+          break if elb_instances[:instance_states].select{ |s| s.state != 'InService' }.length == 0
+        rescue Aws::ElasticLoadBalancing::Errors::InvalidInstance
+        end
+        sleep @sleep_during_wait
+        retries -= 1
+      end
+
+      raise "Timeout. Couldn't wait for instances '#{instances}' to get attached to ELB '#{elb}'." if retries == 0
+    end
+
+    def wait_for_instances_in_asg(asg, expected_number_of_instances)
+      asg_client = Aws::AutoScaling::Client.new
+      retries = (@wait_timeout / @sleep_during_wait).round
+      while retries > 0
+        instances = asg_client.describe_auto_scaling_groups({auto_scaling_group_names: [asg]})[:auto_scaling_groups][0].instances
+        healthy_instances = instances.select{ |i| i[:health_status] == "Healthy" && i[:lifecycle_state]=="InService"}.length
+        break if healthy_instances == expected_number_of_instances
+        sleep @sleep_during_wait
+        retries -= 1
+      end
+
+      raise "Timeout. Only #{healthy_instances} of #{expected_number_of_instances} instances got healthy in ASG '#{asg}'." if retries == 0
+    end
+
+    def get_attached_loadbalancers(asg)
+      asg_client = Aws::AutoScaling::Client.new
+      asg_client.describe_load_balancers({ auto_scaling_group_name: asg }).load_balancers
+    end
+
+    def get_autoscaling_group
+      get_first_resource_id('AWS::AutoScaling::AutoScalingGroup')
+    end
+
+    def get_first_resource_id(resource_type)
+      client = Aws::CloudFormation::Client.new
+      begin
+        response = client.list_stack_resources({ stack_name: @stack_name })
+      rescue Exception
+        return nil
+      end
+      resources = response.data.stack_resource_summaries.select{|x| x[:resource_type] == resource_type }
+      resources.map{ |e| e.physical_resource_id }[0]
+    end
+  end
+end

data/lib/autocanary24/client.rb

@@ -0,0 +1,183 @@
+require 'aws-sdk-core'
+require 'autostacker24'
+require 'base64'
+
+require_relative 'configuration'
+require_relative 'canarystack'
+
+module AutoCanary24
+
+  class Client
+    def initialize(**params)
+      @configuration = Configuration.new(params) #params.fetch(:configuration, Configuration::new(params))
+    end
+
+    def deploy_stack(parent_stack_name, template, parameters, tags = nil, deployment_check = lambda { |stacks, elb, instances_to_create| true })
+      begin
+        write_log(parent_stack_name, "Starting the deployment")
+        write_log(parent_stack_name, "Using the following configuration #{@configuration.inspect}")
+
+        elb = get_elb(parent_stack_name)
+        raise "No ELB found in stack #{parent_stack_name}" if elb.nil?
+
+        blue_cs = get_canary_stack("#{parent_stack_name}-B")
+        green_cs = get_canary_stack("#{parent_stack_name}-G")
+
+        stacks = get_stacks_to_create_and_to_delete_for(blue_cs, green_cs, elb)
+
+        before_switch(stacks, template, parameters, parent_stack_name, tags)
+
+        failed = switch(stacks, elb, deployment_check)
+
+        after_switch(stacks, failed || @configuration.keep_inactive_stack)
+
+      rescue Exception => e
+        write_log(parent_stack_name, "Unexpected exception #{e}")
+      end
+      write_log(parent_stack_name, "Deployment finished")
+    end
+
+    private
+    def get_stacks_to_create_and_to_delete_for(blue_cs, green_cs, elb)
+
+      green_is_attached = green_cs.is_attached_to(elb)
+      blue_is_attached = blue_cs.is_attached_to(elb)
+
+      if green_is_attached
+        stack_to_delete = green_cs
+        stack_to_create = blue_cs
+      elsif blue_is_attached
+        stack_to_delete = blue_cs
+        stack_to_create = green_cs
+      else
+        stack_to_delete = nil
+        stack_to_create = blue_cs
+      end
+
+      write_log(blue_cs.stack_name, blue_is_attached ? "Stack is attached to ELB #{elb}" : "Stack is not attached")
+      write_log(green_cs.stack_name, green_is_attached ? "Stack is attached to ELB #{elb}" : "Stack is not attached")
+
+      write_log(stack_to_create.stack_name, "will be created")
+      write_log(stack_to_delete.stack_name, "will be deleted")
+
+      {stack_to_create: stack_to_create, stack_to_delete: stack_to_delete}
+    end
+
+    def before_switch(stacks, template, parameters, parent_stack_name, tags)
+
+      create_stack(stacks[:stack_to_create].stack_name, template, parameters, parent_stack_name, tags)
+
+      unless stacks[:stack_to_delete].nil?
+        desired = stacks[:stack_to_delete].get_desired_capacity
+        write_log(stacks[:stack_to_delete].stack_name, "Found #{desired} instances")
+
+        stacks[:stack_to_create].set_desired_capacity_and_wait(desired)
+        stacks[:stack_to_delete].suspend_asg_processes
+      end
+
+      stacks[:stack_to_create].suspend_asg_processes
+
+    end
+
+    def switch(stacks, elb, deployment_check)
+
+      desired = stacks[:stack_to_create].get_desired_capacity
+
+      instances_to_toggle = (desired / 100.0 * @configuration.scaling_instance_percent).round
+      instances_to_toggle = 1 if (instances_to_toggle < 1)
+
+      instances_to_create = stacks[:stack_to_create].get_instance_ids
+      instances_to_delete = stacks[:stack_to_delete].nil? ? [] : stacks[:stack_to_delete].get_instance_ids
+
+      missing = desired
+      while missing > 0
+
+        write_log(stacks[:stack_to_create].stack_name, "Adding #{instances_to_toggle} instances (#{desired-missing+instances_to_toggle}/#{desired})")
+
+        begin
+          stacks[:stack_to_create].attach_instances_to_elb_and_wait(elb, instances_to_create[desired-missing, instances_to_toggle])
+        rescue
+          rollback(stacks, elb, instances_to_create, instances_to_delete)
+          return true
+        end
+
+        unless deployment_check.call(stacks, elb, instances_to_create)
+          rollback(stacks, elb, instances_to_create, instances_to_delete)
+          return true
+        end
+
+        if @configuration.keep_instances_balanced && !stacks[:stack_to_delete].nil?
+          begin
+            write_log(stacks[:stack_to_delete].stack_name, "Removing #{instances_to_toggle} instances (#{instances_to_delete[desired-missing, instances_to_toggle]})")
+            stacks[:stack_to_delete].detach_instances_from_elb(elb, instances_to_delete[desired-missing, instances_to_toggle])
+          rescue Exception => e
+            write_log(stacks[:stack_to_delete].stack_name, "WARNING: #{e}")
+          end
+        end
+
+        missing -= instances_to_toggle
+        if missing < instances_to_toggle
+          instances_to_toggle = missing
+        end
+      end
+
+      write_log(stacks[:stack_to_create].stack_name, "Attach to ELB #{elb}")
+      stacks[:stack_to_create].attach_asg_to_elb_and_wait(elb)
+
+      unless stacks[:stack_to_delete].nil?
+        write_log(stacks[:stack_to_delete].stack_name, "Detach from ELB #{elb}")
+        stacks[:stack_to_delete].detach_asg_from_elb_and_wait(elb)
+      end
+    end
+
+    def rollback(stacks, elb, instances_to_create, instances_to_delete)
+      begin
+        stacks[:stack_to_create].detach_instances_from_elb(elb, instances_to_create)
+        stacks[:stack_to_delete].attach_instances_to_elb_and_wait(elb, instances_to_delete)
+      rescue Exception => e
+        write_log("", "ROLLBACK FAILED: #{e}")
+      end
+    end
+
+    def after_switch(stacks, keep_inactive_stack)
+      stacks[:stack_to_create].resume_asg_processes
+      stacks[:stack_to_delete].resume_asg_processes unless stacks[:stack_to_delete].nil?
+
+      if keep_inactive_stack == false
+        delete_stack(stacks[:stack_to_delete])
+      end
+    end
+
+    def get_elb(stack_name)
+      get_first_resource_id(stack_name, 'AWS::ElasticLoadBalancing::LoadBalancer')
+    end
+
+    def get_first_resource_id(stack_name, resource_type)
+      return nil if stack_name.nil?
+
+      client = Aws::CloudFormation::Client.new
+      resp = client.list_stack_resources({ stack_name: stack_name }).data.stack_resource_summaries
+
+      resource_ids = resp.select{|x| x[:resource_type] == resource_type }.map { |e| e.physical_resource_id }
+      resource_ids[0]
+    end
+
+    def create_stack(stack_name, template, parameters, parent_stack_name, tags)
+      write_log(stack_name, "Create/Update stack")
+      Stacker.create_or_update_stack(stack_name, template, parameters, parent_stack_name, tags)
+    end
+
+    def delete_stack(stack_name)
+      Stacker.delete_stack(stack_name) unless stack_name.nil?
+    end
+
+    def get_canary_stack(stack_name)
+      CanaryStack.new(stack_name, @configuration.wait_timeout)
+    end
+
+    def write_log(stack_name, message)
+      puts "#{Time.now.utc}\t#{stack_name.ljust(20)}\t#{message.ljust(40)}"
+    end
+  end
+
+end

data/lib/autocanary24/configuration.rb

@@ -0,0 +1,40 @@
+module AutoCanary24
+  class Configuration
+    # Defines what should happen with the inactive stack
+    attr_accessor :keep_inactive_stack
+    # If true a instance from current stack gets removed whenever a new instance from the new stack is added.
+    attr_accessor :keep_instances_balanced
+    # Percent of instances which are added at once (depends on the actual number of instances, read from desired)
+    attr_accessor :scaling_instance_percent
+    # Timeout to wait for checking AWS operations are done before do a rollback
+    attr_accessor :wait_timeout
+
+    def initialize(**params)
+
+      @keep_inactive_stack = false
+      unless params[:keep_inactive_stack].nil?
+        raise "ERR: inactive_stack_state should be a boolean" unless [true, false].include? params[:keep_inactive_stack]
+        @keep_inactive_stack = params[:keep_inactive_stack]
+      end
+
+      @keep_instances_balanced = false
+      unless params[:keep_instances_balanced].nil?
+        raise 'ERR: keep_instances_balanced needs to a boolean' unless [true, false].include? params[:keep_instances_balanced]
+        @keep_instances_balanced = params[:keep_instances_balanced]
+      end
+
+      @scaling_instance_percent = 100
+      unless params[:scaling_instance_percent].nil?
+        raise 'ERR: scaling_instance_percent needs to be a number between 1 and 100' unless params[:scaling_instance_percent].is_a?(Integer) && (1..100).include?(params[:scaling_instance_percent])
+        @scaling_instance_percent = params[:scaling_instance_percent]
+      end
+
+      @wait_timeout = 300
+      unless params[:wait_timeout].nil?
+        raise 'ERR: wait_timeout needs to be a number' unless params[:wait_timeout].is_a?(Integer)
+        @wait_timeout = params[:wait_timeout]
+      end
+
+    end
+  end
+end

data/lib/autocanary24/version.rb

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

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: autocanary24
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre.alpha
+platform: ruby
+authors:
+- Philipp Garbe
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-29 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'
+description: autocanary24 provides a small convenient module for blue/green and canary
+  deployments with CloudFormation.
+email:
+- pgarbe@autoscout24.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- autocanary24.gemspec
+- bin/console
+- bin/setup
+- examples/.bundle/config
+- examples/Gemfile
+- examples/Gemfile.lock
+- examples/README.md
+- examples/Rakefile
+- examples/asg-stack.json
+- examples/base-stack.json
+- lib/autocanary24.rb
+- lib/autocanary24/canarystack.rb
+- lib/autocanary24/client.rb
+- lib/autocanary24/configuration.rb
+- lib/autocanary24/version.rb
+homepage: https://github.com/autoscout24/autocanary24
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: A very narrow interface to AWS ECR
+test_files: []