kumo_dockercloud 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 30cba0c29df6e2bd9db7bae50838fc0bf317c2fa
+  data.tar.gz: e5b9bf55b8ff0cf329e6537099db2ea54840d383
+SHA512:
+  metadata.gz: 926d693084ea08c039a9fcd643fc388399d771e73b9d221d0f4ac6a82734382dbf1090c025b1b7809e4056c514fa9810c0e4d2ad240ceabf53de7ee29dc78a41
+  data.tar.gz: db132f216e112a0a15cf6cec3563bc340f63f2cd065b0177d1a2a19bf5d127556270c93f81981cbb4e96ecca1e82c4170611357e460b634197a371299460d40f

data/.buildkite/pipeline.yml

@@ -0,0 +1,9 @@
+steps:
+  - name: ':gem: build'
+    command: script/build.sh
+    agents:
+      location: aws
+  - name: ':rspec: unit-test'
+    command: script/unit_test.sh
+    agents:
+      location: aws

data/.gitignore

@@ -0,0 +1,18 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+.idea
+*.gem
+.#*

data/.rspec

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

data/.ruby-version

@@ -0,0 +1 @@
+2.2.3

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.2

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Redbubble
+
+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,49 @@
+# KumoDockerCloud [![Build status](https://badge.buildkite.com/e9ebd06f4732bbb2a914228ac8816a2bbbeaf8bf0444ea00b4.svg)](https://buildkite.com/redbubble/kumo-docker-cloud)
+
+This is the Redbubble wrapper around creating environments in docker cloud.  It is built into our rbdevltools container and can then be used during `apply-env` and `deploy` tasks. 
+
+## Installation
+
+This is installed into the rbdevtools container.
+
+## Usage
+
+Apply env example
+```ruby
+  KumoDockerCloud::Environment.new(
+    name: environment_name,
+    env_vars: env_vars,
+    app_name: 'your-app-here',
+    config_path: File.join('/app', 'config'),
+    stack_template_path: File.join('/app', 'docker-cloud, 'stack.yml.erb')
+  ).apply
+```
+
+Deploy example
+```ruby
+begin
+  KumoDockerCloud::Stack.new(app_name, env_name).deploy(version)
+rescue KumoDockerCloud::Deployment::DeploymentError, TimeoutError
+  exit 1
+end
+```
+
+## Testing changes
+
+Changes to the gem can be manually tested end to end in a project that uses the gem (i.e. http-wala).
+
+- First start the dev-tools container: `baxter kumo tools debug non-production`
+- Re-install the gem: `gem specific_install https://github.com/redbubble/kumo_dockercloud_gem.git -b <your_branch>`
+- Fire up a console: `irb`
+- Require the gem: `require "kumo_dockercloud"`
+- Interact with the gem's classes. `KumoDockerCloud::Stack.new('http-wala', 'test').deploy('1518')`
+- If your container doesn't have a version check endpoint, add the `contactable: false` option: `KumoDockerCloud::Stack.new('http-wala', 'test', contactable: false).deploy('1518')`
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/kumo_dockercloud_gem/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

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

data/kumo_dockercloud.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kumo_dockercloud/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'kumo_dockercloud'
+  spec.version       = KumoDockerCloud::VERSION
+  spec.authors       = %w(Redbubble Delivery Engineering)
+  spec.email         = %w(delivery-engineering@redbubble.com)
+  spec.summary       = %q{Use to create Redbubble environments on the DockerCloud platform}
+  spec.description   = %q{Use to create Redbubble environments on the DockerCloud platform}
+  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_runtime_dependency 'httpi', '~> 2.4'
+  spec.add_runtime_dependency 'docker_cloud', '~> 0.1'
+  spec.add_runtime_dependency 'kumo_ki', '~>1.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.4'
+  spec.add_development_dependency 'webmock', '~> 1.22'
+end

data/lib/kumo_dockercloud.rb

@@ -0,0 +1,3 @@
+require 'kumo_dockercloud/environment'
+require 'kumo_dockercloud/deployment'
+require 'kumo_dockercloud/stack'

data/lib/kumo_dockercloud/deployment.rb

@@ -0,0 +1,126 @@
+require 'time'
+require 'httpi'
+
+require_relative 'docker_cloud_api'
+require_relative 'state_validator'
+
+module KumoDockerCloud
+  class Deployment
+
+    class DeploymentError < StandardError; end
+
+    attr_accessor :app_name, :contactable
+    attr_reader :stack_name, :version, :health_check_path, :version_check_path
+
+    def initialize(stack_name, version, _ = nil)
+      @stack_name = stack_name
+      @version = version
+      @contactable = true
+
+      @health_check_path = 'site_status'
+      @version_check_path = "#{health_check_path}/version"
+    end
+
+    def validate
+      wait_for_running_state
+      validate_containers
+    end
+
+    def wait_for_running_state
+      service_state_provider = lambda {
+        service = docker_cloud_api.services.get(service_uuid)
+        { name: service.name, state: service.state }
+      }
+
+      StateValidator.new(service_state_provider).wait_for_state('Running', 240)
+    end
+
+    private
+
+    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
+
+    def current_state
+      return 'an unknown state' if @parsed_service_info.nil?
+      @parsed_service_info.fetch('state', 'an unknown state')
+    end
+
+    def validate_containers
+      puts "Getting containers"
+
+      containers = docker_cloud_api.containers_by_stack_name(stack_name)
+
+      HTTPI.log = false
+
+      containers.each do |container|
+        validate_container_data(container)
+      end
+    end
+
+    def validate_container_data(container)
+      unless container.name.start_with?(app_name)
+        puts "Skipping #{container.name}"
+        return
+      end
+      print "Checking '#{container.name}' (#{container.uuid}): "
+
+      raise "Unexpected number of open container ports" if container.container_ports.size != 1
+
+      if contactable
+        endpoint_uri = container.container_ports.first.endpoint_uri.gsub(/^tcp:/, 'http:')
+        validate_container_version(endpoint_uri)
+        validate_container_health(endpoint_uri)
+      end
+      print "\n"
+    end
+
+    def validate_container_version(endpoint_uri)
+      version_check_uri = "#{endpoint_uri}#{version_check_path}"
+      print "Version "
+      response = safe_http_get(version_check_uri)
+      actual_version = response.body.strip
+
+      if actual_version == version
+        print "OK, "
+      else
+        puts "Incorrect: Should be '#{version}'; reported '#{actual_version}'"
+        raise DeploymentError.new
+      end
+    end
+
+    def validate_container_health(endpoint_uri)
+      health_check_uri = "#{endpoint_uri}#{health_check_path}"
+      print "Health "
+      response = safe_http_get(health_check_uri)
+      if response.code == 200
+        print "OK"
+      else
+        puts "Unhealthy (HTTP #{response.code}): #{response.body}"
+        raise DeploymentError.new
+      end
+    end
+
+    def safe_http_get(url)
+      tries ||= 3
+      request = HTTPI::Request.new(url: url, open_timeout: 5, read_timeout: 5)
+      HTTPI.get(request)
+    rescue Timeout::Error, Errno::ECONNREFUSED, Errno::EINVAL, Errno::ECONNRESET, Errno::ETIMEDOUT, EOFError,
+        Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+      sleep 5
+
+      if (tries -= 1).zero?
+        raise e
+      else
+        retry
+      end 
+    end
+  end
+end

data/lib/kumo_dockercloud/docker_cloud_api.rb

@@ -0,0 +1,31 @@
+require 'docker_cloud'
+require 'base64' # left out of DockerCloud gem
+
+module KumoDockerCloud
+  class DockerCloudApi
+    extend Forwardable
+    def_delegator :@client, :services
+
+    def initialize(options = {})
+      options[:username] ||= ENV['DOCKERCLOUD_USER']
+      options[:api_key] ||= ENV['DOCKERCLOUD_APIKEY']
+      @client = options[:client] || ::DockerCloud::Client.new(options[:username], options[:api_key])
+    end
+
+    def stack_by_name(name)
+      @client.stacks.all.find { |s| s.name == name }
+    end
+
+    def services_by_stack_name(stack_name)
+      stack = stack_by_name(stack_name)
+      return [] unless stack
+      stack.services
+    end
+
+    def containers_by_stack_name(stack_name)
+      services_by_stack_name(stack_name).collect do |service|
+        service.containers
+      end.flatten
+    end
+  end
+end

data/lib/kumo_dockercloud/environment.rb

@@ -0,0 +1,110 @@
+require 'yaml'
+require 'erb'
+require 'tempfile'
+require 'forwardable'
+
+require_relative 'docker_cloud_api'
+require_relative 'state_validator'
+require_relative 'environment_config'
+require_relative 'stack_file'
+
+module KumoDockerCloud
+  class Environment
+    extend ::Forwardable
+    def_delegators :@config, :stack_name, :env_name
+
+    def initialize(params = {})
+      @env_name = params.fetch(:name)
+      @env_vars = params.fetch(:env_vars, {})
+      @stack_template_path = params.fetch(:stack_template_path)
+      @timeout = params.fetch(:timeout, 120)
+
+      app_name = params.fetch(:app_name)
+      @config = EnvironmentConfig.new(app_name: app_name, env_name: @env_name, config_path: params.fetch(:config_path))
+    end
+
+    def apply
+      if @config.image_tag == 'latest'
+        puts 'WARNING: Deploying latest. The deployed container version may arbitrarily change'
+      end
+
+      stack_file = write_stack_config_file(configure_stack(stack_template))
+      run_command(stack_command(stack_file))
+      stack_file.unlink
+
+      run_command("docker-cloud stack redeploy #{stack_name}")
+
+      wait_for_running(@timeout)
+    end
+
+    def destroy
+      run_command("docker-cloud stack terminate --sync #{stack_name}")
+    end
+
+    private
+
+    def configure_stack(stack_template)
+      StackFile.create_from_template(stack_template, @config, @env_vars)
+    end
+
+    def wait_for_running(timeout)
+      StateValidator.new(stack_state_provider).wait_for_state('Redeploying', timeout)
+      StateValidator.new(stack_state_provider).wait_for_state(expected_state, timeout)
+      StateValidator.new(service_state_provider).wait_for_state('Running', timeout)
+    end
+
+    def expected_state
+      env_name == 'production' ? 'Partly running' : 'Running'
+    end
+
+    def stack_state_provider
+      docker_cloud_api = DockerCloudApi.new
+      lambda {
+        stack = docker_cloud_api.stack_by_name(stack_name)
+        { name: stack.name, state: stack.state }
+      }
+    end
+
+    def service_state_provider
+      docker_cloud_api = DockerCloudApi.new
+      lambda {
+        services = docker_cloud_api.services_by_stack_name(stack_name)
+        services.select! { |service| service.name != 'geckoboardwidget' }
+        { name: 'services', state: services.map { |s| s.state }.uniq.join }
+      }
+    end
+
+    def run_command(cmd)
+      puts "Executing -> #{cmd}"
+      puts `#{cmd}`
+    end
+
+    def evaluate_command(cmd)
+      `#{cmd}`
+    end
+
+    def stack_command(stack_file)
+      if exists?
+        "docker-cloud stack update -f #{stack_file.path} #{stack_name}"
+      else
+        "docker-cloud stack create -f #{stack_file.path} -n #{stack_name}"
+      end
+    end
+
+    def exists?
+      result = evaluate_command('docker-cloud stack ls')
+      result.include?(stack_name)
+    end
+
+    def write_stack_config_file(stack_file_data)
+      output_file = Tempfile.new('docker-cloud_stack_config')
+      output_file.write(stack_file_data.to_yaml)
+      output_file.close
+      output_file
+    end
+
+    def stack_template
+      File.read(@stack_template_path)
+    end
+  end
+end