kumo_dockercloud 1.0.0

data/lib/kumo_dockercloud/environment_config.rb

@@ -0,0 +1,116 @@
+require 'kumo_ki'
+require 'logger'
+
+module KumoDockerCloud
+  class EnvironmentConfig
+    LOGGER = Logger.new(STDOUT)
+
+    attr_reader :env_name, :app_name
+
+    def initialize(options, logger = LOGGER)
+      @env_name    = options.fetch(:env_name)
+      @config_path = options.fetch(:config_path)
+      @log         = logger
+      @app_name    = options.fetch(:app_name)
+    end
+
+    def get_binding
+      binding
+    end
+
+    def stack_name
+      "#{app_name}-#{env_name}"
+    end
+
+    def deploy_tag
+      production? ? 'production' : 'non-production'
+    end
+
+    def production?
+      env_name == 'production'
+    end
+
+    def development?
+      !(%w(production staging).include?(env_name))
+    end
+
+    def ruby_env
+      return 'development' if development?
+      env_name
+    end
+
+    def image_name
+      if existing_image_name?
+        existing_image_name
+      else
+        "redbubble/#{app_name}:master"
+      end
+    end
+
+    def image_tag
+      image_name.split(':').last
+    end
+
+    def plain_text_secrets
+      @plain_text_secrets ||= Hash[
+        encrypted_secrets.map do |name, cipher_text|
+          @log.info "Decrypting '#{name}'"
+          if cipher_text.start_with? '[ENC,'
+            begin
+              [name, "#{kms.decrypt cipher_text[5, cipher_text.size]}"]
+            rescue
+              @log.error "Error decrypting secret '#{name}' from '#{encrypted_secrets_filename}'"
+              raise
+            end
+          else
+            [name, cipher_text]
+          end
+        end
+      ]
+    end
+
+    def tags
+      [deploy_tag]
+    end
+
+    def error_queue_url
+      @error_queue_url ||= AssetWala::SqsQueue.get_error_queue_url
+    end
+
+    private
+
+    def existing_image_name?
+      !!existing_image_name
+    end
+
+    def existing_image_name
+      @service ||= docker_cloud_api.services_by_stack_name(stack_name).first
+      @service ? @service.image_name : nil
+    end
+
+    def docker_cloud_api
+      @docker_cloud_api ||= KumoDockerCloud::DockerCloudApi.new
+    end
+
+    def kms
+      @kms ||= KumoKi::KMS.new
+    end
+
+    def encrypted_secrets_path
+      config_path      = File.expand_path(File.join(@config_path), __FILE__)
+      secrets_filepath = File.join(config_path, "#{env_name}_secrets.yml")
+      secrets_filepath = File.join(config_path, 'development_secrets.yml') unless File.exist?(secrets_filepath)
+      secrets_filepath
+    end
+
+    def encrypted_secrets_filename
+      File.basename encrypted_secrets_path
+    end
+
+    def encrypted_secrets
+      file = File.read(encrypted_secrets_path)
+      erb_result = ERB.new(file).result(get_binding)
+      @encrypted_secrets ||= YAML.load(erb_result)
+    end
+  end
+end

data/lib/kumo_dockercloud/stack.rb

@@ -0,0 +1,46 @@
+module KumoDockerCloud
+  class Stack
+    attr_reader :stack_name, :app_name, :options
+
+    def initialize(app_name, env_name, options = { contactable: true })
+      @app_name = app_name
+      @stack_name = "#{app_name}-#{env_name}"
+      @options = options
+    end
+
+    def deploy(version)
+      update_image(version)
+      redeploy
+      validate_deployment(version)
+    end
+
+    private
+
+    def update_image(version)
+      docker_cloud_api.services.update(service_uuid, image: "redbubble/#{app_name}:#{version}")
+    end
+
+    def redeploy
+      docker_cloud_api.services.redeploy(service_uuid)
+    end
+
+    def validate_deployment(version)
+      deployment = Deployment.new(stack_name, version)
+      deployment.app_name = app_name
+      deployment.contactable = options[:contactable]
+      deployment.validate
+    end
+
+    def service_uuid
+      @service_uuid ||= begin
+        services = docker_cloud_api.services_by_stack_name(stack_name)
+        services.first.uuid
+      end
+    end
+
+    def docker_cloud_api
+      @docker_cloud_api ||= KumoDockerCloud::DockerCloudApi.new
+    end
+
+  end
+end

data/lib/kumo_dockercloud/stack_file.rb

@@ -0,0 +1,28 @@
+require 'yaml'
+
+module KumoDockerCloud
+  module StackFile
+    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'].merge!(converted_env_vars.fetch(key_string))
+      end
+
+      parsed
+    end
+
+    def self.make_all_root_level_keys_strings(env_vars)
+      env_vars.keys.reduce({}) { |acc, key| acc[key.to_s] = env_vars[key]; acc }
+    end
+
+    private_class_method :make_all_root_level_keys_strings
+  end
+end

data/lib/kumo_dockercloud/state_validator.rb

@@ -0,0 +1,49 @@
+require 'time'
+
+module KumoDockerCloud
+  class StateValidator
+    attr_reader :state_provider
+
+    def initialize(state_provider)
+      @state_provider = state_provider
+      @stateful = nil
+    end
+
+    def wait_for_state(expected_state, time_limit)
+      start_time = Time.now
+      last_state = nil
+
+      while Time.now.to_i - start_time.to_i < time_limit
+        @stateful = state_provider.call
+
+        if last_state != current_state
+          print "\n#{@stateful[:name]} is currently #{current_state}"
+        else
+          print "."
+        end
+        last_state = current_state
+
+        if current_state == expected_state
+          break
+        end
+
+        sleep(1)
+      end
+
+      print "\n"
+      if current_state != expected_state
+        puts "Timed out after #{time_limit} seconds"
+        raise TimeoutError.new
+      end
+    end
+
+    private
+
+    def current_state
+      return 'an unknown state' if @stateful.nil?
+      @stateful.fetch(:state, 'an unknown state')
+    end
+
+  end
+
+end

data/lib/kumo_dockercloud/version.rb

@@ -0,0 +1,3 @@
+module KumoDockerCloud
+  VERSION = '1.0.0'
+end

data/script/build.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+set -e
+
+if [[ -z "$KUMO_DOCKERCLOUD_VERSION" && -n "$BUILDKITE_BUILD_NUMBER" ]]; then
+  export KUMO_DOCKERCLOUD_VERSION="$BUILDKITE_BUILD_NUMBER"
+fi
+
+echo "--- :wind_chime: Building gem :wind_chime:"
+
+gem build kumo_dockercloud.gemspec

data/script/release-gem

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/kumo_docker_cloud'
+
+def run_command(cmd)
+  puts cmd
+  puts `#{cmd}`
+  raise "non zero exit code" if $?.exitstatus != 0
+end
+
+tag = KumoDockerCloud::VERSION
+
+run_command "git tag #{tag}"
+run_command "git push origin #{tag}"

data/script/unit_test.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+set -e
+
+echo "--- :clock1: :clock2: running specs :clock3: :clock4:"
+bundle install
+bundle exec rspec
+
+function inline_image {
+  printf '\033]1338;url='"$1"';alt='"$2"'\a\n'
+}
+
+echo "+++ Done! :thumbsup: :shipit:"
+inline_image "https://giftoppr.desktopprassets.com/uploads/f828c372186b5fa80a1c553adbcd4bc4d331396b/tumblr_m2cg550aq21ql201ao1_500.gif" "Yuss"

data/spec/fixtures/config/test_encrypted_secrets.yml

@@ -0,0 +1,2 @@
+testkey: someval
+enctest: '[ENC,ZW5jcnlwdGVkIGJpbmFyeSBkYXRh'

data/spec/fixtures/config/test_secrets.yml

@@ -0,0 +1,2 @@
+testkey: someval
+moretest: otherval

data/spec/fixtures/stack.yml.erb

@@ -0,0 +1,2 @@
+application-stack-name:
+  image: a-thing

data/spec/kumo_docker_cloud_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe KumoDockerCloud do
+  it 'has a version number' do
+    expect(KumoDockerCloud::VERSION).not_to be nil
+  end
+end

data/spec/kumo_dockercloud/docker_cloud_api_spec.rb

@@ -0,0 +1,174 @@
+require 'kumo_dockercloud/docker_cloud_api'
+require 'webmock/rspec'
+
+describe KumoDockerCloud::DockerCloudApi do
+  let(:username) { 'pebbles' }
+  let(:api_key) { 'bam bam' }
+  let(:api) { KumoDockerCloud::DockerCloudApi.new(username: username, api_key: api_key) }
+  let(:stack) { double(DockerCloud::Stack, name: stack_name, services: services) }
+  let(:stack_name) { "foo" }
+  let(:services) { [] }
+
+  describe '#initialize' do
+    subject { api }
+
+    it "passes through username and api_key from hash" do
+      expect(::DockerCloud::Client).to receive(:new).with(username, api_key)
+      subject
+    end
+
+    context "without params" do
+      subject { KumoDockerCloud::DockerCloudApi.new }
+
+      after do
+        ENV.delete('DOCKERCLOUD_USER')
+        ENV.delete('DOCKERCLOUD_APIKEY')
+      end
+
+      it "uses user name from env variable DOCKERCLOUD_USER" do
+        ENV['DOCKERCLOUD_USER'] = username
+        expect(::DockerCloud::Client).to receive(:new).with(username, anything)
+        subject
+      end
+
+      it "uses api key from env variable DOCKERCLOUD_APIKEY" do
+        ENV['DOCKERCLOUD_APIKEY'] = api_key
+        expect(::DockerCloud::Client).to receive(:new).with(anything, api_key)
+        subject
+      end
+
+    end
+  end
+
+
+  describe '#stack_by_name' do
+    subject { api.stack_by_name(stack_name_in) }
+    let(:stacks_mock) { double(DockerCloud::StackAPI, all: [stack] ) }
+
+    before do
+      allow_any_instance_of(::DockerCloud::Client).to receive(:stacks).and_return(stacks_mock)
+    end
+
+    context 'when you have 1 stack, with matching name' do
+      let(:stack_name_in) { stack_name }
+
+      it { should == stack }
+    end
+
+    context 'when you have 1 stack, with non-matching name' do
+      let(:stack_name_in) { 'bar' }
+
+      it { should be_nil }
+    end
+
+    context 'when your stacks have partially matching names' do
+      let(:stack_name_in) { 'fo' }
+
+      it { should be_nil }
+    end
+
+    context 'when you have no stacks' do
+      let(:stack_name_in) { stack_name }
+      let(:stacks_mock) { double(DockerCloud::StackAPI, all: [] ) }
+
+      it { should be_nil }
+    end
+  end
+
+  describe '#services_by_stack_name' do
+    subject { api.services_by_stack_name(stack_name) }
+
+    context 'when the stack exists' do
+      before do
+        allow(api).to receive(:stack_by_name).and_return(stack)
+      end
+
+      context 'without any services' do
+        let(:services) { [] }
+        it do
+          expect(api).to receive(:stack_by_name).with(stack_name)
+          subject
+        end
+
+        it 'returns a blank list' do
+          expect(subject).to eq []
+        end
+      end
+
+      context 'with services' do
+        let(:service) { double(DockerCloud::Service) }
+        let(:services) { [ service ] }
+        let(:stack_name) { 'bar' }
+
+        it 'returns list of service data' do
+          expect(subject).to eq services
+        end
+
+        it 'appropriately passes through the correct stack name' do
+          expect(api).to receive(:stack_by_name).with(stack_name)
+          subject
+        end
+      end
+    end
+
+    context "when the stack doesn't exist" do
+      before do
+        allow(api).to receive(:stack_by_name).and_return(nil)
+      end
+
+      it 'returns a blank list' do
+        expect(subject).to eq []
+      end
+    end
+  end
+
+  describe '#containers_by_stack_name' do
+    subject { api.containers_by_stack_name(stack_name) }
+
+    before do
+      allow(api).to receive(:services_by_stack_name).and_return(services)
+    end
+
+    context 'with only 1 service' do
+      let(:service) { double(DockerCloud::Service, containers: containers) }
+      let(:services) { [service] }
+
+      context 'without any containers' do
+        let(:containers) { [] }
+
+        it { should == [] }
+      end
+
+      context 'with multiple containers' do
+        let(:container) { double(DockerCloud::Container) }
+        let(:containers) { [container, container] }
+
+        it { should == containers }
+      end
+    end
+
+    context 'with multiple services' do
+      let(:service1) { double(DockerCloud::Service, containers: containers1) }
+      let(:service2) { double(DockerCloud::Service, containers: containers2) }
+      let(:services) { [service1, service2] }
+
+      let(:container) { double(DockerCloud::Container) }
+      let(:containers1) { [container] }
+      let(:containers2) { [container, container] }
+
+      it { should == [container, container, container] }
+    end
+  end
+
+  context 'forwarded methods' do
+    describe '#services' do
+      let(:client) { instance_double(DockerCloud::Client) }
+      let(:api) { KumoDockerCloud::DockerCloudApi.new(username: username, api_key: api_key, client: client) }
+
+      it 'forwards to the docker cloud client' do
+        expect(client).to receive(:services)
+        api.services
+      end
+    end
+  end
+end