kumo_dockercloud 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa4d5ceb6b52b11070c8c24ff454f9b5b9394548
-  data.tar.gz: 5a0b1624adc85788d28a9ec56d958a6ecd743cbd
+  metadata.gz: f17aa8666415f9aca28a1bff56fd4f15008ac281
+  data.tar.gz: 69a0f07ebf17b9a59fdf426a7e567f620f862b88
 SHA512:
-  metadata.gz: 3a171ca8c7bcba09b966c5043c6ac8a2a63c97e5f03b08dca279b7e293aa688e9e78dcf7ead95c29c8943646c8eaef0b9691648d1cb5cda76268572aafe5a477
-  data.tar.gz: 1213275c4960c57efe4a7e301ff6d60324b3b6db9b15a18fb7a9a0dd09d474bd442bbddfde215f9f16455c320bba68e87218990ecf72fa9e5ee9408c1b3baecb
+  metadata.gz: c4c7cec1ea8cce00a0ac8cd85375ec7ab965c44f02fd9516f0be9e0cb4598e9fbab4bb1d4034f406c4e845f71b76f27ca20e0f371b5c39a7ef4a7b9daba90fed
+  data.tar.gz: a06f463691c216e733f47d83f16713ce85706f5befff163f97bc11d8d52689ecdd72a04271afb328446a7aa009a9870cf4186f3c632751f3641d4a597dbe986d

data/lib/kumo_dockercloud/service.rb

@@ -2,6 +2,8 @@ require 'timeout'
 
 module KumoDockerCloud
   class Service
+    attr_reader :name
+
     def initialize(stack_name, service_name)
       @stack_name = stack_name
       @name = service_name
@@ -35,11 +37,33 @@ module KumoDockerCloud
       raise KumoDockerCloud::ServiceDeployError.new("One or more checks failed to pass within the timeout")
     end
 
+    def links
+      get_service.linked_to_service.map { |service| KumoDockerCloud::Service.new(stack_name, service[:name]) }
+    end
+
+    def set_link(service_to_link)
+      linked_service = {
+        to_service: service_to_link.resource_uri,
+        name: service_to_link.name,
+        from_service: resource_uri
+      }
+
+      docker_cloud_api.services.update(uuid, linked_to_service: [linked_service])
+    end
+
+    def stop
+      docker_cloud_api.services.stop(uuid)
+    end
+
+    def resource_uri
+      get_service.resource_uri
+    end
+
     private
-    attr_reader :stack_name, :name
+    attr_reader :stack_name
 
     def containers
-      service_api.containers
+      get_service.containers
     end
 
     def update_image(version)
@@ -58,16 +82,16 @@ module KumoDockerCloud
       @docker_cloud_api ||= KumoDockerCloud::DockerCloudApi.new
     end
 
-    def service_api
+    def get_service
       docker_cloud_api.service_by_stack_and_service_name(stack_name, name)
     end
 
     def uuid
-      service_api.uuid
+      get_service.uuid
     end
 
     def image_name
-      service_api.image_name.split(':').first
+      get_service.image_name.split(':').first
     end
   end
 end

data/lib/kumo_dockercloud/stack.rb

@@ -2,6 +2,7 @@ module KumoDockerCloud
   class Stack
     attr_reader :stack_name, :app_name, :options
 
+    #TODO delete options
     def initialize(app_name, env_name, options = { contactable: true })
       @app_name = app_name
       @stack_name = "#{app_name}-#{env_name}"
@@ -17,6 +18,28 @@ module KumoDockerCloud
       service.check(checks, check_timeout) if checks
     end
 
+    def deploy_blue_green(options)
+      service_names = options[:service_names]
+      version = options[:version]
+      checks = options[:checks]
+      check_timeout = options[:check_timeout]
+      switching_service_name = options[:switching_service_name]
+
+      validate_params(version, "Version")
+      validate_params(service_names, "Service names")
+      validate_params(switching_service_name, "Switching service name")
+
+      services = service_names.map { |service_name| Service.new(stack_name, service_name) }
+
+      switching_service = Service.new(stack_name, switching_service_name)
+      green_service = switching_service.links.find { |linked_service| services.find { |service| service.name == linked_service.name } }
+      blue_service = services.find { |service| service.name != green_service.name }
+
+      deploy(blue_service.name, version, checks, check_timeout)
+      switching_service.set_link(blue_service)
+      green_service.stop
+    end
+
     private
 
     def validate_params(param_value, param_name)

data/lib/kumo_dockercloud/stack_file.rb

@@ -5,14 +5,11 @@ module KumoDockerCloud
     def self.create_from_template(stack_template, config, env_vars)
       parsed = YAML.load(ERB.new(stack_template).result(config.get_binding))
 
-      parsed[config.app_name]['environment'] ||= {}
-      parsed[config.app_name]['environment'].merge!(config.plain_text_secrets)
-      parsed[config.app_name]['environment'].merge!(env_vars.fetch(config.app_name, {}))
-
       converted_env_vars = make_all_root_level_keys_strings(env_vars)
 
       env_vars.each do |key, _|
         key_string = key.to_s
+        parsed[key_string]['environment'] ||= {}
         parsed[key_string]['environment'].merge!(converted_env_vars.fetch(key_string))
       end
 

data/lib/kumo_dockercloud/version.rb

@@ -1,3 +1,3 @@
 module KumoDockerCloud
-  VERSION = '1.2.0'
+  VERSION = '2.0.0'
 end

data/spec/kumo_dockercloud/service_spec.rb

@@ -4,32 +4,33 @@ require 'httpi'
 describe KumoDockerCloud::Service do
   let(:service_image) { "repository/docker_image_name:version" }
   let(:service_uuid) { "i_am_a_unique_snowflower" }
-  let(:docker_cloud_service_api) { double(:services_api, uuid: service_uuid, image_name: service_image, containers: []) }
-  let(:docker_cloud_api) { instance_double(KumoDockerCloud::DockerCloudApi, services: docker_cloud_service_api)}
+  let(:docker_cloud_service) { double(:service, uuid: service_uuid, image_name: service_image, containers: [], resource_uri: "api/v1/#{service_uuid}")}
+  let(:docker_cloud_services_api) { double(:services_api) }
+  let(:docker_cloud_api) { instance_double(KumoDockerCloud::DockerCloudApi, services: docker_cloud_services_api)}
 
   subject { described_class.new('stack_name', 'service_name') }
 
   before do
     allow(KumoDockerCloud::DockerCloudApi).to receive(:new).and_return(docker_cloud_api)
 
-    allow(docker_cloud_api).to receive(:service_by_stack_and_service_name).with('stack_name', 'service_name').and_return(docker_cloud_service_api)
+    allow(docker_cloud_api).to receive(:service_by_stack_and_service_name).with('stack_name', 'service_name').and_return(docker_cloud_service)
   end
 
   describe '#deploy' do
     it 'runs the actual update and redeploy methods' do
-      expect(docker_cloud_service_api).to receive(:update).with(service_uuid, { image: service_image })
-      expect(docker_cloud_service_api).to receive(:redeploy).with(service_uuid)
+      expect(docker_cloud_services_api).to receive(:update).with(service_uuid, { image: service_image })
+      expect(docker_cloud_services_api).to receive(:redeploy).with(service_uuid)
       subject.deploy('version')
     end
 
     it 'raises an appropriate exception when there is an error during image update' do
-      expect(docker_cloud_service_api).to receive(:update).and_raise(RestClient::InternalServerError)
+      expect(docker_cloud_services_api).to receive(:update).and_raise(RestClient::InternalServerError)
       expect { subject.deploy('version') }.to raise_error(KumoDockerCloud::ServiceDeployError, "Something went wrong during service update on Docker Cloud's end")
     end
 
     it 'raises an appropriate exception when there is an error during redployment' do
-      allow(docker_cloud_service_api).to receive(:update).with(service_uuid, { image: service_image })
-      expect(docker_cloud_service_api).to receive(:redeploy).and_raise(RestClient::InternalServerError)
+      allow(docker_cloud_services_api).to receive(:update).with(service_uuid, { image: service_image })
+      expect(docker_cloud_services_api).to receive(:redeploy).and_raise(RestClient::InternalServerError)
       expect { subject.deploy('version') }.to raise_error(KumoDockerCloud::ServiceDeployError, "Something went wrong during service update on Docker Cloud's end")
     end
   end
@@ -54,7 +55,7 @@ describe KumoDockerCloud::Service do
       allow(http_lib).to receive(:get).with("http://whale1.test/site_status").and_return(200)
       allow(http_lib).to receive(:get).with("http://whale2.test/site_status").and_return("timeout", "timeout", 200)
       allow(whale1).to receive(:state).and_return("Starting", "Running")
-      allow(docker_cloud_service_api).to receive(:containers).and_return(containers)
+      allow(docker_cloud_service).to receive(:containers).and_return(containers)
     end
 
     it 'resolves to true if all the checks eventually pass' do
@@ -68,5 +69,66 @@ describe KumoDockerCloud::Service do
       allow(whale1).to receive(:state).and_return("Starting")
       expect { subject.check(checks, short_timeout) }.to raise_error(KumoDockerCloud::ServiceDeployError, "One or more checks failed to pass within the timeout")
     end
+
+    describe "#links" do
+      let(:linked_service_uuid) { "i_am_the_db" }
+      let(:linked_service_name) { "db" }
+      let(:linked_to_service) do
+        {
+          from_service: service_uuid,
+          name: linked_service_name,
+          to_service: linked_service_uuid
+        }
+      end
+
+      before do
+        allow(docker_cloud_service).to receive(:linked_to_service).and_return([linked_to_service])
+      end
+
+      it "returns a list of KumoDockerCloud::Service object that are linked to from this service" do
+        links = subject.links
+        expect(links.first).to have_attributes(name: linked_service_name)
+        expect(links.size).to eq(1)
+      end
+
+      it "returns an empty array if there are no links" do
+        allow(docker_cloud_service).to receive(:linked_to_service).and_return([])
+        expect(subject.links).to eq([])
+      end
+    end
+
+    describe "#set_link" do
+      let(:linked_service_uuid) { "i_am_the_db" }
+      let(:linked_service_name) { "db" }
+      let(:linked_to_service) do
+        {
+          to_service: "api/v1/#{linked_service_uuid}",
+          name: linked_service_name,
+          from_service: "api/v1/#{service_uuid}"
+        }
+      end
+      let(:linked_service) { KumoDockerCloud::Service.new('stack_name', linked_service_name) }
+      let(:this_service) { double(:this_service, uuid: service_uuid, resource_uri: "api/v1/#{service_uuid}") }
+      let(:linked_service) { double(:linked_service, uuid: linked_service_uuid, resource_uri: "api/v1/#{linked_service_uuid}", name: linked_service_name) }
+
+      before do
+        allow(docker_cloud_api).to receive(:service_by_stack_and_service_name).with('stack_name', 'service_name').and_return(this_service)
+        allow(docker_cloud_api).to receive(:service_by_stack_and_service_name).with('stack_name', linked_service_name).and_return(linked_service)
+      end
+
+      it "updates the link attribute" do
+        expect(docker_cloud_services_api).to receive(:update).with(service_uuid, { linked_to_service: [linked_to_service] })
+
+        subject.set_link(linked_service)
+      end
+    end
+
+    describe "#stop" do
+      it "sends a request to stop the service" do
+        expect(docker_cloud_services_api).to receive(:stop).with(service_uuid)
+
+        subject.stop
+      end
+    end
   end
 end

data/spec/kumo_dockercloud/stack_file_spec.rb

@@ -32,8 +32,6 @@ describe KumoDockerCloud::StackFile do
       expect(subject).to eq(app_name => {
         'image' => 'a-thing',
         'environment' => {
-          'TEST_ENV' => 'FAKE',
-          'MORE' => 'ANOTHER',
           'KEY' => 'VALUE'
         }
       })
@@ -53,8 +51,6 @@ describe KumoDockerCloud::StackFile do
           'image' => 'a-thing',
           'environment' => {
             'TEST' => 'thing',
-            'TEST_ENV' => 'FAKE',
-            'MORE' => 'ANOTHER',
             'KEY' => 'VALUE'
           }
         })
@@ -72,37 +68,12 @@ describe KumoDockerCloud::StackFile do
         expect(subject).to eq(app_name => {
           'image' => 'a-thing',
           'environment' => {
-            'TEST_ENV' => 'FAKE',
-            'MORE' => 'ANOTHER',
             'KEY' => 'VALUE'
           }
         })
       end
     end
 
-    context 'no app name env var' do
-      let(:env_vars) do
-        { }
-      end
-
-      let(:stack_template) do
-        <<-eos
-          application-stack-name:
-            image: a-thing
-        eos
-      end
-
-      it 'should create the environment with secrets in it' do
-        expect(subject).to eq(app_name => {
-          'image' => 'a-thing',
-          'environment' => {
-            'TEST_ENV' => 'FAKE',
-            'MORE' => 'ANOTHER'
-          }
-        })
-      end
-    end
-
     context 'with other services' do
       let(:env_vars) do
         {
@@ -130,8 +101,6 @@ describe KumoDockerCloud::StackFile do
           app_name => {
             'image' => 'a-thing',
             'environment' => {
-              'TEST_ENV' => 'FAKE',
-              'MORE' => 'ANOTHER',
               'KEY' => 'VALUE'
             }},
           'another_service' => {

data/spec/kumo_dockercloud/stack_spec.rb

@@ -60,4 +60,83 @@ describe KumoDockerCloud::Stack do
     end
 
   end
+
+  describe '#deploy_blue_green' do
+    let(:service_a_uuid) { 'service_a_uuid' }
+    let(:service_a) { instance_double(KumoDockerCloud::Service, :service_a, uuid: uuid, name: "service-a") }
+    let(:service_b_uuid) { 'service_b_uuid' }
+    let(:service_b) { instance_double(KumoDockerCloud::Service, :service_b, uuid: uuid, name: "service-b") }
+    let(:nginx) { instance_double(KumoDockerCloud::Service, uuid: "nginx_uuid") }
+    let(:version) { "1" }
+    let(:deployment_checks) { [] }
+    let(:links) { [service_a] }
+    let(:check_timeout) { 120 }
+    let(:deploy_options) do
+      {
+        service_names: ["service-a", "service-b"],
+        version: version,
+        checks: deployment_checks,
+        check_timeout: check_timeout,
+        switching_service_name: "nginx"
+      }
+    end
+
+    subject { described_class.new(app_name, environment_name).deploy_blue_green(deploy_options) }
+
+    before do
+      allow(KumoDockerCloud::Service).to receive(:new)
+        .with(stack_name, "service-a")
+        .and_return(service_a)
+
+      allow(KumoDockerCloud::Service).to receive(:new)
+        .with(stack_name, "service-b")
+        .and_return(service_b)
+
+      allow(KumoDockerCloud::Service).to receive(:new)
+        .with(stack_name, "nginx")
+        .and_return(nginx)
+
+      allow(nginx).to receive(:links).and_return(links)
+      allow(nginx).to receive(:set_link).with(service_b)
+
+      allow(service_a).to receive(:stop)
+
+      allow(service_b).to receive(:deploy).with(version)
+      allow(service_b).to receive(:check).with(deployment_checks, check_timeout)
+    end
+
+    context 'when parameters are missing' do
+      it 'blow up when version is missing' do
+        deploy_options.delete(:version)
+        expect{ subject }.to raise_error(KumoDockerCloud::Error, "Version cannot be nil")
+      end
+
+      it 'blow up when service_names are missing' do
+        deploy_options.delete(:service_names)
+        expect{ subject }.to raise_error(KumoDockerCloud::Error, "Service names cannot be nil")
+      end
+
+      it 'blow up when switching_service_name is missing' do
+        deploy_options.delete(:switching_service_name)
+        expect{ subject }.to raise_error(KumoDockerCloud::Error, "Switching service name cannot be nil")
+      end
+    end
+
+    it 'deploys to the blue service only' do
+      expect(service_b).to receive(:deploy).with(version)
+      expect(service_b).to receive(:check).with(deployment_checks, check_timeout)
+      expect(service_a).to_not receive(:deploy)
+      subject
+    end
+
+    it 'switches over to the blue service on a successful deployment' do
+      expect(nginx).to receive(:set_link).with(service_b)
+      subject
+    end
+
+    it 'shuts down the previously green service' do
+      expect(service_a).to receive(:stop)
+      subject
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kumo_dockercloud
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Redbubble
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-19 00:00:00.000000000 Z
+date: 2016-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpi