cloudfoundry_blue_green_deploy 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 54397c469bcc873ba16da8358aaf7659e5e0a7cd
+  data.tar.gz: 9f27071ae08a3dda2347f6371dddb242a6d8405e
+SHA512:
+  metadata.gz: 924f6dfc9bf0c9e813629c0c5adccd0e6671be57c9d9c7c068c1074b8ecb4751b6348227c064e3b1b344f1fc1c97a9f1c3be38082dfbab9182210a9fa68d9c6d
+  data.tar.gz: e90a718e563b61cc450bc0c486c561812e26f09f5a84082a00e417bc4b145e29dc282072fac517d393dfbf1ccd31d5e4b6d3a3b79b3aa18b563926ed1a5d28bd

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 John Ryan and Mariana Lenetis
+
+MIT License
+
+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,184 @@
+# Overview
+
+Using a simple deployment process, one can introduce significant (even if planned) downtime of your application.
+
+If you want to minimize this impact to your site's availability, you might opt to use the Blue/Green deployment approach: http://docs.gopivotal.com/pivotalcf/devguide/deploy-apps/blue-green.html
+
+This gem provides a Rake task to automate Blue/Green deployment to a Cloud Foundry installation.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cloudfoundry_blue_green_deploy'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cloudfoundry_blue_green_deploy
+
+## For first deployment - where app to deploy needs to be specified
+
+## Usage
+
+1. define the blue and green instances of your application(s) in your Cloud Foundry Manifest.  (see rules in the next section)
+2. run
+
+    $ bundle exec rake cf:blue_green_deploy[web-app-name]
+
+   Where "web-app-name" is the "name" attribute in your manifest.yml.
+   The default color for first deployment is blue.
+   You may optionally specify the color that you would like to be the "live" instance on the first deployment.
+
+### manifest.yml
+
+Your Cloud Foundry manifest file must comply with the following requirements:
+
+1. name: two application instances are required. One name ending with "-green" and another ending with "-blue"
+2. host: the url. One ending with "-green" and the other ending with "-blue"
+3. domain: required
+4. command: bundle exec rake cf:on_first_instance db:migrate && bundle exec rails s -p $PORT -e $RAILS_ENV
+5. services: Optional, only required if there are services that need to be bound
+
+#### Bare Minimum Example:
+
+In this example:
+- Our web application is known to Cloud Foundry as "carrot-soup".
+- "carrot-soup" has a database service known as "oyster-cracker".
+
+    ---
+    applications:
+
+    - name: carrot-soup-green
+      host: la-pong-green
+      domain: cfapps.io
+      command: bundle exec rake cf:on_first_instance db:migrate && bundle exec rails s -p $PORT -e $RAILS_ENV
+      services:
+      - oyster-cracker
+
+    - name: carrot-soup-blue
+      host: la-pong-blue
+      domain: cfapps.io
+      command: bundle exec rake cf:on_first_instance db:migrate && bundle exec rails s -p $PORT -e $RAILS_ENV
+      services:
+      - oyster-cracker
+
+And perform a blue/green deploy like this:
+
+    $ bundle exec rake cf:blue_green_deploy[carrot-soup]
+
+## Workers
+
+Non-trivial applications often require background processes to perform asynchronous jobs (e.g. sending email, importing data from external systems, etc.).
+If these applications' code are to stay in sync with the web application, they need blue/green treatment as well.
+
+This Rake task natively supports worker application instances.
+
+### Usage (with Workers)
+
+1. define the blue and green instances of your application(s) and workers in your Cloud Foundry Manifest. (see rules in the next section)
+2. run:
+
+    $ bundle exec rake cf:blue_green_deploy[web-app-name,worker-name,another-worker-name]
+
+   Note:
+     The "web-app-name" is the "name" attribute (without a color) detailed in your manifest.yml
+     The "worker-name" and "another-worker-name" are "name" attributes for 2 separate worker apps as detailed in your manifest.yml
+     Multiple worker apps can be specified as long as they comply with the blue/green deployment requirements in the manifest.yml
+
+### manifest.yml
+
+For web application deployment (see requirements above)
+
+For worker applications
+1. name: two application instances are required. One name ending with "-green" and another ending with "-blue"
+2. command:
+3. path: Relative to the current working directory
+4. services: Optional, only required if there are services that need to be bound
+
+#### Example with Workers
+
+In this example:
+- Our web application is known to Cloud Foundry as "carrot-soup".
+- The app "carrot-soup" has a database service known as "oyster-cracker".
+- We have a worker application named "relish", whose database is known as "creme-fraiche".
+
+    ---
+    applications:
+
+    - name: relish-green
+      command: bundle exec rails s -p $PORT -e $RAILS_ENV
+      path: ../relish
+      services:
+      - creme-fraiche
+
+    - name: carrot-soup-green
+      host: la-pong-green
+      domain: cfapps.io
+      size: 1GB
+      path: .
+      command: bundle exec rails s -p $PORT -e $RAILS_ENV
+      services:
+      - oyster-cracker
+
+    - name: carrot-soup-blue
+      host: la-pong-blue
+      domain: cfapps.io
+      size: 1GB
+      path: .
+      command: bundle exec rails s -p $PORT -e $RAILS_ENV
+      services:
+      - oyster-cracker
+
+    - name: relish-blue
+      command: bundle exec rails s -p $PORT -e $RAILS_ENV
+      path: ../relish
+      services:
+      - creme-fraiche
+
+ And perform the blue/green deploy like this:
+     $ bundle exec rake cf:blue_green_deploy[carrot-soup,relish]
+
+
+# Blue/Green with Shutter
+
+For blue/green deployments that require a database migration this tool provides the ability to automatically shutter the app during the required downtime. To use this feature, create a shutter app and configure your manifest.yml.
+
+## Creating a Minimal Shutter App
+
+1. Add the following to your manifest.yml. Note that the name must match the name of your production application and end in -shutter.
+
+    - name: carrot-soup-shutter
+      command: bundle exec rackup config.ru -p $PORT -E $RACK_ENV
+      path: shutter-app
+
+2. Create a directory named "shutter-app".  In that directory:
+   1. create a Rack config (config.ru):
+
+    class Message
+      def call(env)
+        [200, {"Content-Type" => "text/plain"}, ["Temporarily down for maintenance. Please check back shortly."]]
+      end
+    end
+
+    run Message.new
+
+   2. create a minimal Gemfile:
+
+    source 'https://rubygems.org'
+    ruby '2.0.0'
+
+    gem 'rack'
+
+   3. create the Gemfile.lock by running Bundler in the "shutter-app" directory:
+
+    $ bundle install
+
+
+ - Note: as of 05/09/14 deployment using Cloud Foundry's buildpack does not appear to be compatible with ruby version 2.1.0.
+ - Our fail-fast philosophy. We recommend understanding deployment on Cloud Foundry before using this tool.
+

data/Rakefile

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

data/cloudfoundry_blue_green_deploy.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cloudfoundry_blue_green_deploy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cloudfoundry_blue_green_deploy'
+  spec.version       = CloudfoundryBlueGreenDeploy::VERSION
+  spec.authors       = ['John Ryan and Mariana Lenetis']
+  spec.email         = ['jryan@pivotallabs.com', 'mlenetis@pivotallabs.com']
+  spec.summary       = %q{Blue-green deployment tool for Cloud Foundry.}
+  spec.description   = %q{Blue-green deployment tool for Cloud Foundry. Please see readme.}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'awesome_print'
+end

data/lib/cloudfoundry_blue_green_deploy.rb

@@ -0,0 +1,8 @@
+require_relative 'cloudfoundry_blue_green_deploy/app'
+require_relative 'cloudfoundry_blue_green_deploy/route'
+require_relative 'cloudfoundry_blue_green_deploy/command_line'
+require_relative 'cloudfoundry_blue_green_deploy/cloudfoundry'
+require_relative 'cloudfoundry_blue_green_deploy/blue_green_deploy_error'
+require_relative 'cloudfoundry_blue_green_deploy/blue_green_deploy_config'
+require_relative 'cloudfoundry_blue_green_deploy/blue_green_deploy'
+require_relative 'cloudfoundry_blue_green_deploy/railtie' if defined?(Rails)

data/lib/cloudfoundry_blue_green_deploy/app.rb

@@ -0,0 +1,10 @@
+module CloudfoundryBlueGreenDeploy
+  class App
+    attr_accessor :name, :state
+
+    def initialize(name: , state: 'stopped')
+      @name = name
+      @state = state
+    end
+  end
+end

data/lib/cloudfoundry_blue_green_deploy/blue_green_deploy.rb

@@ -0,0 +1,144 @@
+require_relative 'route'
+require_relative 'cloudfoundry'
+require_relative 'blue_green_deploy_error'
+require_relative 'blue_green_deploy_config'
+
+module CloudfoundryBlueGreenDeploy
+  class InvalidRouteStateError < BlueGreenDeployError; end
+  class InvalidWorkerStateError < BlueGreenDeployError; end
+
+  class BlueGreenDeploy
+    def self.cf
+      Cloudfoundry
+    end
+
+    def self.make_it_so(app_name, worker_apps, deploy_config)
+      hot_app_name = get_hot_web_app(deploy_config.hot_url)
+      both_invalid_and_valid_hot_worker_names = get_hot_worker_names
+
+      is_first_deploy = first_deploy?(hot_app_name, both_invalid_and_valid_hot_worker_names)
+
+      deploy_config.target_color = set_target_color(is_first_deploy, hot_app_name)
+
+      ready_for_takeoff(hot_app_name, both_invalid_and_valid_hot_worker_names, deploy_config)
+
+      with_shutter = deploy_config.with_shutter
+      hot_url = deploy_config.hot_url
+      cold_app = deploy_config.target_web_app_name
+      domain = deploy_config.domain
+      shutter_app_name = deploy_config.shutter_app_name
+
+      if with_shutter
+        cf.push(shutter_app_name)
+        cf.map_route(shutter_app_name, domain, hot_url)
+        cf.unmap_route(hot_app_name, domain, hot_url) if hot_app_name
+      end
+
+      cf.push(cold_app)
+
+      deploy_config.target_worker_app_names.each do |worker_app_name|
+        cf.push(worker_app_name)
+        unless is_first_deploy
+          to_be_cold_worker = BlueGreenDeployConfig.toggle_app_color(worker_app_name)
+          cf.stop(to_be_cold_worker)
+        end
+      end
+
+      if with_shutter
+        cf.map_route(cold_app, domain, hot_url)
+        cf.unmap_route(shutter_app_name, domain, hot_url)
+      else
+        make_hot(app_name, deploy_config)
+      end
+    end
+
+    def self.set_target_color(is_first_deploy, hot_app_name)
+      if is_first_deploy
+        'blue'
+      else
+        determine_target_color(hot_app_name) unless hot_app_name.nil?
+      end
+    end
+
+
+    def self.ready_for_takeoff(hot_app_name, both_invalid_and_valid_hot_worker_names, deploy_config)
+      unless first_deploy?(hot_app_name, both_invalid_and_valid_hot_worker_names)
+        ensure_there_is_a_hot_instance(deploy_config, hot_app_name)
+        ensure_hot_instance_is_not_target(deploy_config, hot_app_name)
+        ensure_hot_workers_are_not_target(deploy_config)
+      end
+    end
+
+    def self.first_deploy?(hot_app_name, both_invalid_and_valid_hot_worker_names)
+      hot_app_name.nil? && both_invalid_and_valid_hot_worker_names.empty?
+    end
+
+    def self.ensure_there_is_a_hot_instance(deploy_config, hot_app_name)
+      if hot_app_name.nil?
+        raise InvalidRouteStateError.new(
+          "There is no route mapped from #{deploy_config.hot_url} to an app.")
+      end
+    end
+
+    def self.ensure_hot_instance_is_not_target(deploy_config, hot_app_name)
+      if deploy_config.is_in_target?(hot_app_name)
+        raise InvalidRouteStateError.new(
+          "The app \"#{hot_app_name}\" is already hot (target color is #{deploy_config.target_color}).")
+      end
+    end
+
+    def self.ensure_hot_workers_are_not_target(deploy_config)
+      apps = cf.apps
+
+      deploy_config.target_worker_app_names.each do |hot_worker|
+        if deploy_config.is_in_target?(hot_worker) && invalid_worker?(hot_worker, apps)
+          raise InvalidWorkerStateError.new(
+            "Worker #{hot_worker} is already hot (target color is #{deploy_config.target_color}).")
+        end
+      end
+    end
+
+    def self.invalid_worker?(hot_worker, apps)
+      apps.each do |app|
+        if app.name == hot_worker && app.state == 'started'
+          return true
+        end
+      end
+      return false
+    end
+
+    def self.get_color_stem(hot_app_name)
+      hot_app_name.slice((hot_app_name.rindex('-') + 1)..(hot_app_name.length))
+    end
+
+    def self.determine_target_color(hot_app_name)
+      target_color = get_color_stem(hot_app_name)
+      BlueGreenDeployConfig.toggle_color(target_color)
+    end
+
+    def self.make_hot(app_name, deploy_config)
+      hot_url = deploy_config.hot_url
+      hot_app = get_hot_web_app(hot_url)
+      cold_app = deploy_config.target_web_app_name
+      domain = deploy_config.domain
+
+      cf.map_route(cold_app, domain, hot_url)
+      cf.unmap_route(hot_app, domain, hot_url) if hot_app
+    end
+
+    def self.get_hot_web_app(hot_url)
+      cf_routes = cf.routes
+      hot_route = cf_routes.find { |route| route.host == hot_url }
+      hot_route.nil? ? nil : hot_route.app
+    end
+
+    def self.get_hot_worker_names
+      cf_apps = cf.apps
+      hot_names = []
+      cf_apps.each do |app|
+        hot_names << app.name if app.state == 'started'
+      end
+      hot_names
+    end
+  end
+end

data/lib/cloudfoundry_blue_green_deploy/blue_green_deploy_config.rb

@@ -0,0 +1,108 @@
+require_relative 'blue_green_deploy_error'
+
+module CloudfoundryBlueGreenDeploy
+  class InvalidManifestError < BlueGreenDeployError; end
+
+  class BlueGreenDeployConfig
+    attr_reader :hot_url, :worker_app_names, :domain, :with_shutter
+    attr_accessor :target_color
+
+    def initialize(cf_manifest, web_app_name, worker_app_names, with_shutter = nil)
+      manifest = cf_manifest['applications']
+
+      self.class.valid_name_check(web_app_name, worker_app_names, manifest)
+
+      item = manifest.find { |item| self.class.strip_color(item['name']) == web_app_name }
+      if item.nil?
+        raise InvalidManifestError.new("Could not find \"#{web_app_name}-green\" nor \"#{web_app_name}-blue\" in the Cloud Foundry manifest:\n" +
+                                       "#{cf_manifest.inspect}")
+      end
+
+      host = item['host']
+      if host.nil?
+        raise InvalidManifestError.new(
+          "Could not find the \"host\" property associated with the \"#{item['name']}\" application in the Cloud Foundry manifest:\n" +
+          "#{cf_manifest.inspect}")
+      end
+
+      @domain = item['domain']
+
+      if @domain.nil?
+        raise InvalidManifestError.new(
+          "Could not find the \"domain\" property associated with the \"#{item['name']}\" application in the Cloud Foundry manifest:\n" +
+          "#{cf_manifest.inspect}")
+      end
+
+      @web_app_name = web_app_name
+      @hot_url = host.slice(0, host.rindex('-'))
+      @worker_app_names = worker_app_names
+      @with_shutter = with_shutter
+      @target_color = nil
+    end
+
+    def shutter_app_name
+      "#{@web_app_name}-shutter"
+    end
+
+    def target_web_app_name
+      "#{@web_app_name}-#{@target_color}"
+    end
+
+    def is_in_target?(app)
+      self.class.get_color_stem(app) == @target_color
+    end
+
+    def target_worker_app_names
+      @worker_app_names.map do |app|
+        "#{app}-#{@target_color}"
+      end
+    end
+
+
+    def self.valid_name_check(web_app_name, worker_app_names, manifest)
+      all_apps = all_app_names(web_app_name, worker_app_names)
+      all_apps.each do |app_name|
+        if manifest.none? { |record| record['name'] == app_name }
+          raise InvalidManifestError.new("Could not find \"#{app_name}\" in the Cloud Foundry manifest:\n" +
+                                         "#{manifest}")
+
+        end
+      end
+    end
+
+    def self.strip_color(app_name_with_color)
+      app_name_with_color.slice((0..app_name_with_color.rindex('-') - 1))
+    end
+
+    def self.toggle_app_color(target_app_name)
+      new_color = toggle_color(get_color_stem(target_app_name))
+      new_app = target_app_name.slice(0..(target_app_name.rindex('-') - 1))
+      new_app = "#{new_app}-#{new_color}"
+    end
+
+    def self.get_color_stem(app_name)
+      app_name.slice((app_name.rindex('-') + 1)..(app_name.length))
+    end
+
+    def self.toggle_color(target_color)
+      target_color == 'green' ? 'blue' : 'green'
+    end
+
+    def self.colorize_name(app_name, color)
+      "#{app_name}-#{color}"
+    end
+
+    def self.all_app_names(web_app_name, worker_app_names)
+      all_app_names = []
+      all_app_names <<  colorize_name(web_app_name, 'blue')
+      all_app_names <<  colorize_name(web_app_name, 'green')
+
+      worker_app_names.each do |app|
+        all_app_names << colorize_name(app, 'green')
+        all_app_names << colorize_name(app, 'blue')
+      end
+
+      all_app_names
+    end
+  end
+end