cloudfoundry_blue_green_deploy 0.0.1

data/lib/cloudfoundry_blue_green_deploy/blue_green_deploy_error.rb

@@ -0,0 +1,3 @@
+module CloudfoundryBlueGreenDeploy
+  class BlueGreenDeployError < StandardError; end
+end

data/lib/cloudfoundry_blue_green_deploy/cloudfoundry.rb

@@ -0,0 +1,90 @@
+require_relative './command_line'
+require_relative './route'
+require_relative './app'
+
+module CloudfoundryBlueGreenDeploy
+
+  class CloudfoundryCliError < StandardError; end
+
+  class Cloudfoundry
+
+    def self.apps
+      apps = []
+      cmd = "cf apps"
+      output = CommandLine.backtick(cmd)
+      found_header = false
+
+      lines = output.lines
+
+      lines.each do |line|
+        line = line.split
+        if line[0] == 'name' && found_header == false
+          found_header = true
+          next
+        end
+
+        if found_header
+          apps << App.new(name: line[0], state: line[1])
+        end
+      end
+
+      apps
+    end
+
+    def self.push(app)
+      execute("cf push #{app}")
+    end
+
+    def self.stop(app)
+      execute("cf stop #{app}")
+    end
+
+    def self.routes
+      routes = []
+      cmd = "cf routes"
+      output = CommandLine.backtick(cmd)
+      success = !output.include?('FAILED')
+      if success
+        lines = output.lines
+        found_header = false
+        lines.each do |line|
+          line = line.split
+          if line[0] == 'host' && found_header == false
+            found_header = true
+            next
+          end
+
+          if found_header
+            routes << Route.new(line[0], line[1], line[2])
+          end
+        end
+        routes
+      else
+        raise CloudfoundryCliError.new("\"#{cmd}\" returned \"#{success}\".  The output of the command was \n\"#{output}\".")
+      end
+    end
+
+    def self.unmap_route(app, domain, host)
+      execute("cf unmap-route #{app} #{domain} -n #{host}")
+    end
+
+    def self.map_route(app, domain, host)
+      execute("cf map-route #{app} #{domain} -n #{host}")
+    end
+
+    private
+
+    def self.execute(cmd)
+      success = CommandLine.system(cmd)
+      handle_success_or_failure(cmd, success)
+    end
+
+    def self.handle_success_or_failure(cmd, success)
+      if success
+        return success
+      else
+        raise CloudfoundryCliError.new("\"#{cmd}\" returned \"#{success}\".  Look for details in \"FAILED\" above.")
+      end
+    end
+  end
+end

data/lib/cloudfoundry_blue_green_deploy/command_line.rb

@@ -0,0 +1,15 @@
+module CloudfoundryBlueGreenDeploy
+  class CommandLine
+    DEBUG = false
+    def self.backtick(command)
+
+      output = `export CF_COLOR=false; #{command}`
+      puts "CommandLine.backtick(): \"#{output}\"" if DEBUG
+      output
+    end
+
+    def self.system(command)
+      Kernel.system(command)
+    end
+  end
+end

data/lib/cloudfoundry_blue_green_deploy/railtie.rb

@@ -0,0 +1,11 @@
+require 'rails'
+
+module CloudfoundryBlueGreenDeploy
+  class Railtie < Rails::Railtie
+    railtie_name :cloudfoundry_blue_green_deploy
+
+    rake_tasks do
+      load 'cloudfoundry_blue_green_deploy/tasks/cf.rake'
+    end
+  end
+end

data/lib/cloudfoundry_blue_green_deploy/route.rb

@@ -0,0 +1,10 @@
+module CloudfoundryBlueGreenDeploy
+  class Route
+    attr_reader :host, :domain, :app
+    def initialize(host, domain, app)
+      @host = host
+      @domain = domain
+      @app = app == '' ? nil : app
+    end
+  end
+end

data/lib/cloudfoundry_blue_green_deploy/tasks/cf.rake

@@ -0,0 +1,28 @@
+require 'cloudfoundry_blue_green_deploy'
+
+namespace :cf do
+  desc 'Only run on the first application instance'
+  task :on_first_instance do
+    instance_index = JSON.parse(ENV['VCAP_APPLICATION'])['instance_index'] rescue nil
+    exit(0) unless instance_index == 0
+  end
+
+  desc 'Reroutes "live" traffic to specified app through provided URL'
+  task :blue_green_deploy, :web_app_name do |t, args|
+    web_app_name = args[:web_app_name]
+    worker_app_names = args.extras.to_a
+    if worker_app_names.last == 'with_shutter'
+      worker_app_names.pop
+      with_shutter = true
+    else
+      with_shutter = false
+    end
+
+    deploy_config = CloudfoundryBlueGreenDeploy::BlueGreenDeployConfig.new(load_manifest, web_app_name, worker_app_names, with_shutter)
+    CloudfoundryBlueGreenDeploy::BlueGreenDeploy.make_it_so(web_app_name, worker_app_names, deploy_config)
+  end
+
+  def load_manifest
+    YAML.load_file('manifest.yml')
+  end
+end

data/lib/cloudfoundry_blue_green_deploy/version.rb

@@ -0,0 +1,3 @@
+module CloudfoundryBlueGreenDeploy
+  VERSION = "0.0.1"
+end

data/spec/blue_green_deploy_config_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+module CloudfoundryBlueGreenDeploy
+  describe BlueGreenDeployConfig do
+    let(:cf_manifest) { YAML.load_file('spec/manifest.yml') }
+    let(:web_app_name) { 'the-web-app' }
+    let(:web_url_name) { 'the-web-url' }
+    let(:worker_app_names) { ['the-web-app-worker', 'hard-worker'] }
+    let(:with_shutter) { false }
+    let(:target_color) { nil }
+    let(:deploy_config) do
+      config = BlueGreenDeployConfig.new(cf_manifest, web_app_name, worker_app_names, with_shutter)
+      config.target_color = target_color
+      config
+    end
+
+    describe '#initialize' do
+      subject { deploy_config }
+      context 'given a parsed conforming manifest.yml' do
+        it 'calculates the "Hot URL"' do
+          expect(subject.hot_url).to eq "#{web_url_name}"
+        end
+
+        it 'determines the "domain" (i.e the Cloud Foundry domain)' do
+          expect(subject.domain).to eq 'cfapps.io'
+        end
+
+        context 'user requested "shutter treatment"' do
+          let(:with_shutter) { true }
+          it 'indicates "use shutter"' do
+            expect(subject.with_shutter).to eq true
+          end
+        end
+      end
+
+      describe '(vetting parameters against the contents of the manifest)' do
+        context 'given the "web_app_name" parameter does not match any of the applications defined in the manifest.yml' do
+          let(:web_app_name) { 'the-web-pap' }
+          it 'raises an InvalidManifestError' do
+            expect{subject}.to raise_error InvalidManifestError
+          end
+        end
+
+        context 'given one of the instances of a worker application is not defined in the manifest' do
+          let(:worker_app_names) { ['the-web-app-wroker', 'hard-worker'] }
+          it 'raises an InvalidManifestError' do
+            expect{subject}.to raise_error InvalidManifestError
+          end
+        end
+      end
+
+      context 'given the "web_app_name" matches, but the host name is not defined' do
+        let(:cf_manifest) { {"applications"=>[{"name"=>"the-web-app-blue"}]} }
+        let(:worker_app_names) { [] }
+        it 'raises an InvalidManifestError' do
+          expect{subject}.to raise_error InvalidManifestError
+        end
+      end
+
+      context 'given the "web_app_name" matches, but the domain is not defined' do
+        let(:cf_manifest) { {"applications"=>[{"name"=>"the-web-app-blue", "host"=> "#{web_url_name}"}]} }
+        let(:worker_app_names) { [] }
+        it 'raises an InvalidManifestError' do
+          expect{subject}.to raise_error InvalidManifestError
+        end
+      end
+
+    end
+
+    context 'the target color was calculated by Blue Green deploy' do
+      let(:target_color) { 'green' }
+
+      describe '.target_web_app_name' do
+        subject { deploy_config.target_web_app_name }
+        it 'calculates the "target" web app name' do
+          expect(subject).to eq "the-web-app-#{target_color}"
+        end
+      end
+
+      describe '.target_worker_app_names' do
+        subject { deploy_config.target_worker_app_names }
+
+        it 'calculates the "target" worker app names' do
+          expect(subject[0]).to eq 'the-web-app-worker-green'
+          expect(subject[1]).to eq 'hard-worker-green'
+        end
+      end
+    end
+
+    describe '.shutter_app_name' do
+      subject { deploy_config.shutter_app_name }
+      it 'provides the CF app name for the Shutter app.' do
+        expect(subject).to eq "#{web_app_name}-shutter"
+      end
+    end
+
+
+    describe '#strip_color' do
+      let(:app_name_with_color) { 'some-app-name-here-yay-blue' }
+      subject { BlueGreenDeployConfig.strip_color(app_name_with_color) }
+
+      it 'returns just the name of the app' do
+        expect(subject).to eq 'some-app-name-here-yay'
+      end
+
+    end
+
+    describe '#toggle_app_color' do
+      let(:app_name) { 'app_name' }
+      let(:target_app_name) { "#{app_name}-#{starting_color}" }
+      subject { BlueGreenDeployConfig.toggle_app_color(target_app_name) }
+
+      context 'where named app is the green instance' do
+        let(:starting_color) { 'green' }
+        it 'provides the blue app name' do
+          expect(subject).to eq "#{app_name}-blue"
+        end
+      end
+    end
+
+    describe '.is_in_target?' do
+      let(:target_color) { 'green' }
+      let(:app_name) { "app_name-#{app_color}" }
+      subject { deploy_config.is_in_target?(app_name) }
+
+      context 'when the specified app IS the name of the target app' do
+        let(:app_color) { target_color }
+        it 'returns true' do
+          expect(subject).to be true
+        end
+      end
+      context 'when the specified app is NOT the name of the target app' do
+        let(:app_color) { BlueGreenDeployConfig.toggle_color(target_color) }
+        it 'returns false' do
+          expect(subject).to be false
+        end
+      end
+    end
+  end
+end

data/spec/blue_green_deploy_spec.rb

@@ -0,0 +1,287 @@
+require 'spec_helper'
+require_relative 'cloudfoundry_fake'
+
+module CloudfoundryBlueGreenDeploy
+  describe BlueGreenDeploy do
+    let(:cf_manifest) { YAML.load_file('spec/manifest.yml') }
+    let(:worker_app_names) { ['the-web-app-worker'] }
+    let(:deploy_config) { BlueGreenDeployConfig.new(cf_manifest, app_name, worker_app_names, with_shutter) }
+    let(:domain) { 'cfapps.io' }
+    let(:hot_url) { 'the-web-url' }
+    let(:app_name) { 'the-web-app' }
+    let(:with_shutter) { nil }
+
+    describe '#make_it_so' do
+      context 'steady-state deploy (not first deploy, already a hot app)' do
+        let(:worker_apps) { worker_app_names }
+        let(:target_color) { 'green' }
+        let(:current_hot_app) { 'blue' }
+
+        subject { BlueGreenDeploy.make_it_so(app_name, worker_apps, deploy_config) }
+
+        before do
+          allow(BlueGreenDeploy).to receive(:cf).and_return(CloudfoundryFake)
+          CloudfoundryFake.init_route_table(domain, app_name, hot_url, current_hot_app)
+          CloudfoundryFake.init_app_list_with_workers_for(app_name)
+        end
+
+        context 'AND deploy does not require shutter' do
+          let(:with_shutter) { false }
+          it 'instructs Cloud Foundry to deploy the specified web app; ' +
+            'THEN, deploys each of the specified worker apps, stopping their counterparts; ' +
+            'and THEN, makes the specified web app "hot" ' +
+            '(mapping the "hot" route to it and unmapping that "hot" route from it`s counterpart)' do
+              green_or_blue = BlueGreenDeployConfig.toggle_color(target_color)
+              old_worker_app_full_name = "#{worker_apps.first}-#{green_or_blue}"
+              new_worker_app_full_name = "#{worker_apps.first}-#{target_color}"
+              new_web_app_full_name = "#{app_name}-#{target_color}"
+              old_web_app_full_name = "#{app_name}-#{green_or_blue}"
+
+              expect(CloudfoundryFake).to receive(:push).with(new_web_app_full_name).ordered.and_call_original
+              expect(CloudfoundryFake).to receive(:push).with(new_worker_app_full_name).ordered.and_call_original
+              expect(CloudfoundryFake).to receive(:stop).with(old_worker_app_full_name).ordered.and_call_original
+              expect(CloudfoundryFake).to receive(:map_route).with(new_web_app_full_name, domain, hot_url).ordered.and_call_original
+              expect(CloudfoundryFake).to receive(:unmap_route).with(old_web_app_full_name, domain, hot_url).ordered.and_call_original
+
+              subject
+            end
+        end
+
+        context 'AND deploy requires shutter' do
+          let(:with_shutter) { true }
+          it 'instructs Cloud Foundry to deploy the specified web app; ' +
+            'THEN, deploys each of the specified worker apps, stopping their counterparts; ' +
+            'and THEN, makes the specified web app "hot" ' +
+            '(mapping the "hot" route to it and unmapping that "hot" route from it`s counterpart)' do
+              green_or_blue = BlueGreenDeployConfig.toggle_color(target_color)
+              shutter_app_name = deploy_config.shutter_app_name
+              old_worker_app_full_name = "#{worker_apps.first}-#{green_or_blue}"
+              new_worker_app_full_name = "#{worker_apps.first}-#{target_color}"
+              new_web_app_full_name = "#{app_name}-#{target_color}"
+              old_web_app_full_name = "#{app_name}-#{green_or_blue}"
+
+              expect(CloudfoundryFake).to receive(:push).with(shutter_app_name).ordered.and_call_original
+              expect(CloudfoundryFake).to receive(:map_route).with(shutter_app_name, domain, hot_url).ordered.and_call_original
+              expect(CloudfoundryFake).to receive(:unmap_route).with(old_web_app_full_name, domain, hot_url).ordered.and_call_original
+              expect(CloudfoundryFake).to receive(:push).with(new_web_app_full_name).ordered.and_call_original
+              expect(CloudfoundryFake).to receive(:push).with(new_worker_app_full_name).ordered.and_call_original
+              expect(CloudfoundryFake).to receive(:stop).with(old_worker_app_full_name).ordered.and_call_original
+              expect(CloudfoundryFake).to receive(:map_route).with(new_web_app_full_name, domain, hot_url).ordered.and_call_original
+              expect(CloudfoundryFake).to receive(:unmap_route).with(shutter_app_name, domain, hot_url).ordered.and_call_original
+
+              subject
+            end
+
+        end
+      end
+
+      context 'it is a first deploy' do
+        let(:target_color) { nil }
+        let(:worker_apps) { worker_app_names }
+        subject { BlueGreenDeploy.make_it_so(app_name, worker_apps, deploy_config) }
+        before do
+          allow(BlueGreenDeploy).to receive(:cf).and_return(CloudfoundryFake)
+        end
+
+        context 'there is no hot app' do
+          let(:current_hot_app) { nil }
+          before { CloudfoundryFake.clear_route_table }
+
+          context 'there are no hot worker apps' do
+            let(:worker_app_names) { [] }
+            before { CloudfoundryFake.clear_app_list }
+            it 'deploys "blue" instances' do
+              subject
+              hot_web_app = CloudfoundryFake.find_route(hot_url).app
+              expect(BlueGreenDeploy.get_color_stem(hot_web_app)).to eq 'blue'
+              CloudfoundryFake.started_apps.each do |worker_app|
+                expect(BlueGreenDeploy.get_color_stem(worker_app.name)).to eq 'blue'
+              end
+            end
+          end
+
+          context 'there ARE hot worker apps' do
+            before do
+              CloudfoundryFake.init_app_list_from_names(worker_app_names)
+              CloudfoundryFake.mark_app_as_started("#{worker_app_names.first}-blue")
+            end
+            it 'raises an InvalidRouteStateError' do
+              expect{ subject }.to raise_error(InvalidRouteStateError)
+            end
+          end
+        end
+      end
+    end
+
+    describe '#get_hot_worker_names' do
+      subject { BlueGreenDeploy.get_hot_worker_names }
+      let(:target_color) { 'green' }
+
+      context 'there are no started worker apps' do
+        before do
+          allow(BlueGreenDeploy).to receive(:cf).and_return(CloudfoundryFake)
+          CloudfoundryFake.init_app_list_from_names(worker_app_names)
+        end
+
+        it 'returns an empty array' do
+          expect(subject).to eq []
+        end
+      end
+
+      context 'a worker app is started (and another is stopped)' do
+        before do
+          allow(BlueGreenDeploy).to receive(:cf).and_return(CloudfoundryFake)
+          CloudfoundryFake.init_app_list_from_names(worker_app_names)
+          CloudfoundryFake.mark_workers_as_started(worker_app_names, target_color)
+        end
+
+        it 'returns just the started worker app' do
+          expect(subject).to eq(worker_app_names.map { |app_name| "#{app_name}-#{target_color}" })
+        end
+      end
+    end
+
+    describe '#ready_for_takeoff' do
+      let(:target_color) { 'green' }
+      subject { BlueGreenDeploy.ready_for_takeoff(hot_app_name, both_invalid_and_valid_hot_worker_names, deploy_config) }
+      before { allow(BlueGreenDeploy).to receive(:cf).and_return(CloudfoundryFake) }
+
+      context 'first deploy: there are no apps deployed' do
+        let(:hot_app_name) { nil }
+        let(:worker_app_names) { [] }
+        let(:both_invalid_and_valid_hot_worker_names) { worker_app_names }
+        before { CloudfoundryFake.init_app_list(worker_app_names) }
+
+        it 'allows the deploy to proceed' do
+          expect{ subject }.not_to raise_error
+        end
+      end
+
+      context 'in subsequent deploys' do
+        let(:hot_app_name) { "#{app_name}-#{current_hot_app}" }
+        let(:worker_apps) { CloudfoundryFake.apps }
+        let(:both_invalid_and_valid_hot_worker_names) { worker_apps.select { |app| app.state == 'started' }.map(&:name) }
+        before do
+          CloudfoundryFake.init_route_table(domain, app_name, hot_url, current_hot_app)
+          CloudfoundryFake.init_app_list_with_workers_for(app_name)
+        end
+        context 'the target color is the cold app color.' do
+          let(:current_hot_app) { 'blue' }
+          let(:target_color) { 'green' }
+          let(:deploy_config) do
+            config = BlueGreenDeployConfig.new(cf_manifest, app_name, worker_app_names, with_shutter)
+            config.target_color = target_color
+            config
+          end
+
+          it 'does not raise an error: "It`s kosh!"' do
+            expect{ subject }.to_not raise_error
+          end
+
+          context 'but, one or more of the target worker apps is already hot' do
+            before do
+              CloudfoundryFake.replace_app(App.new(name: "#{app_name}-worker-#{target_color}", state: 'started'))
+              both_invalid_and_valid_hot_worker_names = ["#{app_name}-worker-#{target_color}"]
+            end
+
+            it 'raises an InvalidWorkerStateError' do
+              expect{ subject }.to raise_error(InvalidWorkerStateError)
+            end
+          end
+        end
+
+
+        context 'and there is no current hot app and there are started worker apps' do
+          let(:target_color) { nil }
+          let(:current_hot_app) { '' }
+          let(:hot_app_name) { nil }
+          before do
+            CloudfoundryFake.remove_route(hot_url)
+            CloudfoundryFake.mark_app_as_started(CloudfoundryFake.apps.sample.name)
+          end
+
+          it 'raises an InvalidRouteStateError' do
+            expect{ subject }.to raise_error(InvalidRouteStateError)
+          end
+        end
+      end
+    end
+
+    describe '#get_hot_web_app' do
+      subject { BlueGreenDeploy.get_hot_web_app(hot_url) }
+      let(:current_hot_color) { 'green' }
+      let(:hot_app) { "#{app_name}-#{current_hot_color}" }
+
+      before do
+        allow(BlueGreenDeploy).to receive(:cf).and_return(CloudfoundryFake)
+        CloudfoundryFake.init_route_table(domain, app_name, hot_url, current_hot_color)
+      end
+
+      it 'returns the app mapped to that Host URL' do
+        expect(subject).to eq hot_app
+      end
+
+      context 'when there is no app mapped to the hot url' do
+        before { CloudfoundryFake.remove_route(hot_url) }
+
+        it 'returns nil' do
+          expect(subject).to be_nil
+        end
+      end
+    end
+
+
+    describe '#make_hot' do
+      let(:target_color) { 'blue' }
+      let(:current_hot_app) { 'green' }
+      let(:deploy_config) do
+        config = BlueGreenDeployConfig.new(cf_manifest, app_name, worker_app_names, with_shutter)
+        config.target_color = target_color
+        config
+      end
+      subject { BlueGreenDeploy.make_hot(app_name, deploy_config) }
+
+      before do
+        allow(BlueGreenDeploy).to receive(:cf).and_return(CloudfoundryFake)
+        CloudfoundryFake.init_route_table(domain, app_name, hot_url, current_hot_app)
+
+      end
+
+      context 'when there is no current hot app' do
+        before do
+          CloudfoundryFake.remove_route(hot_url)
+        end
+
+        it 'the target_color is mapped to the hot_url' do
+          subject
+          expect(BlueGreenDeploy.get_hot_web_app(hot_url)).to eq "#{app_name}-#{target_color}"
+        end
+      end
+
+      context 'when there IS a hot URL route, but it is not mapped to any app' do
+        before do
+          CloudfoundryFake.remove_route(hot_url)
+          CloudfoundryFake.add_route(Route.new(hot_url, domain, nil))
+
+        end
+
+        it 'the target_color is mapped to the hot_url' do
+          subject
+          expect(BlueGreenDeploy.get_hot_web_app(hot_url)).to eq "#{app_name}-#{target_color}"
+        end
+      end
+
+      context 'when the hot url IS mapped to an app, already' do
+        it 'the app that was mapped to the hot_url is no longer mapped to hot_url' do
+          subject
+          expect(BlueGreenDeploy.get_hot_web_app(hot_url)).to_not eq "#{app_name}-#{current_hot_app}"
+        end
+
+        it 'the target_color is mapped to the hot_url' do
+          subject
+          expect(BlueGreenDeploy.get_hot_web_app(hot_url)).to eq "#{app_name}-#{target_color}"
+        end
+      end
+    end
+  end
+end