capistrano-docker-cloud 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 80e86ce3e62045cd06a1c371fc22e6d4f7b20333
+  data.tar.gz: 42d178fda17226ffe9d369db7879e5398a23aee7
+SHA512:
+  metadata.gz: 6f003869c4196581f4809d9a12b51f355bd133466793e6adcb6ab8b39043fbbeecf4ce672e8a2a3be5010152f85c4af18f9a2fc0f6c38f3206331e076a15bdbc
+  data.tar.gz: a7b64a9d31cb3591cd179721b9b5078166b2ca0279c6afe9378c0d596ecc3cff6c9a0b2abb825509e3f16ce4d06e5a852311b39fcd30155f7a9d3d788c5bbf25

data/.gitignore

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

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+# master
+
+* Your contribution here!
+
+# 0.2.2 (Jul 1 2016)
+
+ - Ignore endpoint URI update when not configured
+
+# 0.2.1 (Jul 1 2016)
+
+ - Remove the load balancer redeploy
+
+The HAProxy image is reload automatically when updating the links.
+
+# 0.2.0 (Jun 25 2016)
+
+ - Service creation for your image
+ - Service start
+ - Load balancer update and redeploy using the new service
+
+This release is not yet ready as there is a downtime in case the application is
+taking some times to boot (as of now, the gem is only waiting on the Docker
+ Cloud status, which is not the application status).
+
+# 0.1.0 (Jun 23 2016)
+
+Initial release

data/Dockerfile

@@ -0,0 +1,37 @@
+# How to use it
+# =============
+#
+# Visit http://blog.zedroot.org/using-docker-to-maintain-a-ruby-gem/
+
+# ~~~~ Image base ~~~~
+# Base image with the latest Ruby only
+FROM ruby:2.3.0-slim
+MAINTAINER Guillaume Hain zedtux@zedroot.org
+
+
+# ~~~~ Set up the environment ~~~~
+ENV DEBIAN_FRONTEND noninteractive
+
+RUN mkdir -p /gem/
+WORKDIR /gem/
+ADD . /gem/
+
+# ~~~~ OS Maintenance & Rails Preparation ~~~~
+# Rubygems and Bundler
+RUN apt-get update && \
+  apt-get install -y git build-essential && \
+  touch ~/.gemrc && \
+  echo "gem: --no-ri --no-rdoc" >> ~/.gemrc && \
+  gem install rubygems-update && \
+  update_rubygems && \
+  gem install bundler && \
+  bundle install && \
+  apt-get remove --purge -y build-essential && \
+  apt-get autoclean -y && \
+  apt-get clean
+
+# Import the gem source code
+VOLUME .:/gem/
+
+ENTRYPOINT ["bundle", "exec"]
+CMD ["rake", "-T"]

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Guillaume Hain
+
+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,88 @@
+# Capistrano::DockerCloud
+
+[Docker cloud](https://cloud.docker.com/) specific tasks for Capistrano v3:
+
+  - `cap docker_cloud:deploy`
+
+## TODO
+
+ - [ ] Add a `docker_cloud:rollback` task [#1](https://github.com/YourCursus/capistrano-docker-cloud/issues/1)
+ - [ ] Add a task for A/B testing [#2](https://github.com/YourCursus/capistrano-docker-cloud/issues/2)
+ - [ ] Add a task to delete old Docker image tags [#3](https://github.com/YourCursus/capistrano-docker-cloud/issues/3)
+ - [ ] Add more options to be configured on the Capistrano `deploy.rb` file
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+group :development do
+  gem 'capistrano', '~> 3.1'
+  gem 'capistrano-docker-cloud'
+end
+```
+
+Run the following command to install the gems:
+
+```
+bundle install
+```
+
+Then run the generator to create a basic set of configuration files:
+
+```
+bundle exec cap install
+```
+
+## Usage
+
+```ruby
+# Capfile
+require 'capistrano/docker-cloud'
+```
+
+Please note that any `require`s should be placed in `Capfile`, not in `config/deploy.rb`.
+
+You can tweak some Docker Cloud's specific options in `config/deploy.rb`:
+
+```ruby
+# Docker image name to deploy
+set :docker_image, 'me/my-image'
+
+# Docker Cloud credentials
+set :docker_cloud_credentials, {
+    username: 'username',
+    api_key: 'my-api-key'
+  }
+```
+
+## Debugging
+
+#### RestClient
+
+Under the hood, this Capistrano gem is using
+[Docker cloud](https://cloud.docker.com/) which is using the [RestClient](https://github.com/rest-client/rest-client) gem.
+
+You can see all the RestClient requests setting the `RESTCLIENT_LOG` environment
+variable like the following:
+
+```
+$ cap staging docker_cloud:deploy RESTCLIENT_LOG=stdout
+```
+
+#### Capistrano tasks
+
+Of course you can also pass `--trace` in order to reveal the backtrace in case
+of an error:
+
+```
+$ cap staging docker_cloud:deploy --trace
+```
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/capistrano-rails.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'capistrano/docker-cloud/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'capistrano-docker-cloud'
+  gem.version       = Capistrano::DockerCloud::VERSION
+  gem.authors       = ['Guillaume Hain']
+  gem.email         = ['zedtux@zedroot.org']
+  gem.description   = %q{Docker cloud specific Capistrano tasks}
+  gem.summary       = %q{Docker cloud specific Capistrano tasks}
+  gem.homepage      = 'https://github.com/YourCursus/capistrano-docker-cloud'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'capistrano', '~> 3.1'
+  gem.add_dependency 'capistrano-bundler', '~> 1.1'
+  gem.add_dependency 'docker_cloud', '~> 0.3.0'
+end

data/lib/capistrano/docker-cloud.rb

@@ -0,0 +1,2 @@
+require 'capistrano/bundler'
+load File.expand_path('../tasks/docker-cloud.rake', __FILE__)

data/lib/capistrano/docker-cloud/base.rb

@@ -0,0 +1,82 @@
+require 'docker_cloud'
+require 'capistrano/docker-cloud/helpers/collection_helper'
+
+module Capistrano
+  module DockerCloud
+    class RecordNotFound < Exception; end
+
+    class Base
+      include Capistrano::DockerCloud::Helpers::CollectionHelper
+
+      # ~~~~ Class Methods ~~~~
+      def self.subclass_name
+        # FIXME : Find a better way to archive this.
+        ancestors.first.to_s.split('::').last.downcase + 's'
+      end
+
+      def self.find(uuid)
+        object = resource.get(uuid)
+        return object if object
+        raise Capistrano::DockerCloud::RecordNotFound
+      rescue RestClient::ResourceNotFound => error
+        puts "ERROR: #{error.response}"
+      end
+
+      def self.find_by(options = {})
+        case
+        when options.key?(:name)
+          new(find_by_name(options[:name]))
+        else
+          raise "You can only search #{subclass_name} by `:name`."
+        end
+      end
+
+      def self.find_by_name(name)
+        resource.all.detect do |stack|
+          stack.name.downcase == name
+        end
+      end
+
+      def self.resource
+        connection.send("#{subclass_name}")
+      end
+
+      def self.configure(username, api_key)
+        @@dockercloud_username = username
+        @@dockercloud_api_key = api_key
+      end
+
+      def self.connection
+        @@connection ||= ::DockerCloud::Client.new(@@dockercloud_username,
+                                                   @@dockercloud_api_key)
+      end
+
+      #
+      # Rails like belongs_to association
+      #
+      def self.belongs_to(name)
+        define_method("#{name.to_s}=") do |object|
+          instance_variable_set("@#{name.to_s}", object)
+        end
+        define_method("#{name.to_s}") { instance_variable_get("@#{name.to_s}") }
+      end
+
+      def self.redeploy(uuid)
+        resource.redeploy(uuid)
+      end
+
+      # ~~~~ Instance Methods ~~~~
+      def connection
+        self.class.connection
+      end
+
+      def reload!
+        initialize(self.class.find(uuid))
+      end
+
+      def redeploy
+        self.class.redeploy(uuid)
+      end
+    end
+  end
+end

data/lib/capistrano/docker-cloud/client.rb

@@ -0,0 +1,138 @@
+require 'capistrano/docker-cloud/base'
+require 'capistrano/docker-cloud/service'
+require 'capistrano/docker-cloud/stack'
+require 'capistrano/docker-cloud/helpers/collection_helper'
+
+module Capistrano
+  module DockerCloud
+    class Client
+      include Capistrano::DockerCloud::Helpers::CollectionHelper
+
+      def initialize(capistrano_instance)
+        @capistrano = capistrano_instance
+      end
+
+      def deploy
+        # Ensure all is fine before to deploy
+        ensure_credential_exists!
+        ensure_docker_image_tag_to_deploy_is_defined!
+        prepare_dockercloud_connection
+        ensure_stack_exists_with_name!(stage_name)
+        ensure_no_container_with_image_to_deploy_already_exists!
+        ensure_stack_has_a_load_balancer!
+
+        # Deploy the image
+        create_new_service!
+        start_created_service!
+        wait_service_to_boot!
+        switch_load_balancer_linked_service!
+      end
+
+      private
+
+      def fetch(key)
+        @capistrano.fetch(key)
+      end
+
+      def stage_name
+        fetch(:stage).to_s.downcase
+      end
+
+      def ensure_credential_exists!
+        @credentials = fetch(:docker_cloud_credentials)
+        return if @credentials
+        raise 'You have not defined the :docker_cloud_credentials option in ' \
+              'capistrano deploy.rb file.'
+      end
+
+      def ensure_docker_image_tag_to_deploy_is_defined!
+        return if fetch(:docker_image_tag)
+        raise 'No tag defined to be used to deploy the Docker image ' \
+              "#{fetch(:docker_image)}."
+      end
+
+      def prepare_dockercloud_connection
+        Capistrano::DockerCloud::Base.configure(@credentials[:username],
+                                                @credentials[:api_key])
+      end
+
+      def ensure_stack_exists_with_name!(name)
+        @capistrano.info "Looking for the Stack named #{name} ..."
+        @stack = Capistrano::DockerCloud::Stack.find_by(name: name)
+        return if @stack
+        raise "Unable to find the Stack with name #{name}."
+      end
+
+      def image_name_to_deploy
+        @image_name_to_deploy ||= "#{fetch(:docker_image)}:" \
+                                  "#{fetch(:docker_image_tag)}"
+      end
+
+      def ensure_no_container_with_image_to_deploy_already_exists!
+        @capistrano.info "Ensuring no service is running the image " \
+                         "#{image_name_to_deploy} ..."
+        service = @stack.find_service_by_image_name(image_name_to_deploy).first
+        if service.nil? || %w(Terminating Terminated).include?(service.state)
+          return
+        end
+        raise "The service #{service.name} is already running the image " \
+              "#{image_name_to_deploy}."
+      end
+
+      def ensure_stack_has_a_load_balancer!
+        @capistrano.info "Checking the presence of a Load Balancer ..."
+        if @stack.has_a_load_balancer?
+          @load_balancer = @stack.load_balancer_service
+          return
+        end
+        raise "The stack #{stage_name} is missing a Load Balancer. Please " \
+              'add one using the dockercloud:haproxy Docker image.'
+      end
+
+      #
+      # Extract image name from the capistrano `docker_image` option.
+      #
+      # Example:
+      #
+      #   - yourcursus/cursus => cursus
+      #   - ruby => ruby
+      #
+      def docker_image_name
+        fetch(:docker_image).match(/^(?:.*\/)?(.*)$/)[1]
+      end
+
+      def docker_image_tag
+        fetch(:docker_image_tag).gsub(/[\.\_]/, '-')
+      end
+
+      def service_name
+        @service_name ||= "#{docker_image_name}-#{docker_image_tag}"
+      end
+
+      def create_new_service!
+        @capistrano.info "Creating a new service #{service_name} with image " \
+                         "#{image_name_to_deploy} ..."
+        @stack.build_service(image: image_name_to_deploy, name: service_name)
+        @stack.save
+      end
+
+      def start_created_service!
+        @capistrano.info "Starting newly created service #{service_name} ..."
+        @stack.start_service(name: service_name)
+      end
+
+      def wait_service_to_boot!
+        @capistrano.info "Waiting #{service_name} container booting ..."
+        @stack.waiting_service_boot(name: service_name)
+        @capistrano.info "Waiting #{service_name} application booting ..."
+        @stack.waiting_service_application_boot(name: service_name)
+      end
+
+      def switch_load_balancer_linked_service!
+        @capistrano.info 'Switching the Load Balancer linked services to ' \
+                         "#{service_name} ..."
+        @load_balancer.switch!(service_name: service_name)
+      end
+    end
+  end
+end

data/lib/capistrano/docker-cloud/helpers/collection_helper.rb

@@ -0,0 +1,15 @@
+module Capistrano
+  module DockerCloud
+    module Helpers
+      module CollectionHelper
+        def first_or_raise_error!(objects, name)
+          unless objects.size == 1
+            raise "1 object expected with #{name}, #{objects.size} objects " \
+                  'found'
+          end
+          objects.first
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/docker-cloud/service.rb

@@ -0,0 +1,145 @@
+module Capistrano
+  module DockerCloud
+    class Service < Capistrano::DockerCloud::Base
+
+      # https://docs.docker.com/apidocs/docker-cloud/#update-an-existing-service
+      ATTRIBUTES = [
+        :autorestart, :autodestroy, :container_envvars, :container_ports,
+        :cpu_shares, :entrypoint, :image, :linked_to_service, :memory, :net,
+        :privileged, :roles, :run_command, :sequential_deployment, :tags,
+        :target_num_containers, :deployment_strategy, :autoredeploy, :pid,
+        :working_dir, :nickname,
+        # Special keys
+        :name, :image_name
+      ]
+
+      attr_accessor *ATTRIBUTES, :uuid
+
+      belongs_to :stack
+
+      def initialize(service)
+        ATTRIBUTES.each do |attribute|
+          value = default_value_for(attribute)
+          value = service.info[attribute] if service
+          self.send("#{attribute.to_s}=", value)
+        end
+        if service
+          # The Service API update is expecting an `image` attribute instead of
+          # `image_name`
+          self.image = service.info[:image_name]
+          self.uuid = service.uuid
+        end
+      end
+
+      def load_balancer?
+        image_name =~ /^dockercloud\/haproxy\:/
+      end
+
+      def linked_to_service_for_update
+        links = linked_to_service.dup
+        links.each { |link| link.delete(:from_service) }
+      end
+
+      def container_ports_for_update
+        ports = container_ports.dup
+        ports.each do |port|
+          port.delete(:endpoint_uri)
+          port.delete(:port_name)
+        end
+      end
+
+      def update(options)
+        options.each do |key, value|
+          self.send("#{key.to_s}=", value)
+        end
+      end
+
+      def save
+        connection.services.update(uuid, build_update_hash)
+        reload!
+      rescue RestClient::BadRequest => error
+        puts "ERROR: #{error.response}"
+      end
+
+      def default_value_for(attribute)
+        case attribute
+        when :privileged, :autoredeploy, :sequential_deployment
+          false
+        when :autorestart, :autodestroy
+          'OFF'
+        when :net
+          'bridge'
+        when :deployment_strategy
+          'EMPTIEST_NODE'
+        when :pid
+          'none'
+        when :target_num_containers
+          1
+        when :tags
+          []
+        when :nickname
+          ''
+        when :image, :name, :image_name
+          nil
+        end
+      end
+
+      def build_update_hash
+        attributes = {}
+        ignored_attributes = [:nickname, :image_name]
+        calling = caller.first.match(/^.*\/([a-z\_\-]+)\.rb\:.*$/)[1]
+        ignored_attributes << :name unless calling == 'stack'
+        ATTRIBUTES.each do |attribute|
+          next if ignored_attributes.include?(attribute)
+
+          value = self.send("#{attribute.to_s}")
+          next if value.nil? || value == []
+          next if default_value_for(attribute) == value
+
+          case attribute
+          when :linked_to_service
+            attributes[attribute] = linked_to_service_for_update
+          when :container_ports
+            attributes[attribute] = container_ports_for_update
+          else
+            attributes[attribute] = value
+          end
+        end
+        attributes
+      end
+
+      def switch!(options)
+        unless load_balancer?
+          raise 'This service is not a Load Balancer, therefor you cannot ' \
+                'call switch.'
+        end
+
+        update_links_with_service!(name: options[:service_name])
+        save
+      end
+
+      def update_links_with_service!(options)
+        links = linked_to_service.dup
+
+        services = stack.find_service_by_name(options[:name])
+        switch_to = first_or_raise_error!(services, options[:name])
+
+        to_be_replaced = remove_service_with_same_image_than(switch_to)
+
+        links.delete_if { |link| link[:name] == to_be_replaced.name }
+        links << { name: options[:name], to_service: "/api/app/v1/yourcursus/service/#{switch_to.uuid}/" }
+
+        self.linked_to_service = links
+      end
+
+      private
+
+      def remove_service_with_same_image_than(switch_to)
+        services = stack.find_service_by_image_name(switch_to.image_name,
+                                                    tag: false)
+        services.delete_if { |service| service.name == switch_to.name }
+        first_or_raise_error!(services, switch_to.name)
+      end
+    end
+  end
+end

data/lib/capistrano/docker-cloud/stack.rb

@@ -0,0 +1,141 @@
+module Capistrano
+  module DockerCloud
+    class Stack < Capistrano::DockerCloud::Base
+
+      def initialize(stack)
+        @original_stack = stack
+        sync_services_from_stack
+      end
+
+      # ~~~~ Class Methods ~~~~
+
+      # ~~~~ Instance Methods ~~~~
+        # TODO : Refactor this code in order to move it in the Service class
+      def find_service_by_name(name)
+        @original_stack.services.select do |service|
+          compare(service.name, name)
+        end
+      end
+
+      def find_service_by_image_name(name, options = {})
+        options[:tag] = true unless options.key?(:tag)
+
+        @original_stack.services.select do |service|
+          compare(service.image_name, name, tag: options[:tag])
+        end
+      end
+
+      def build_service(options = {})
+        services = find_service_by_image_name(options[:image], tag: false)
+        service = first_or_raise_error!(services, options[:image])
+        service = Capistrano::DockerCloud::Service.new(service)
+        service.update(image: options[:image], name: options[:name])
+        @services << service
+      end
+
+      def save
+        connection.stacks.update(@original_stack.uuid, build_update_body)
+        reload!
+      rescue RestClient::BadRequest => error
+        puts "ERROR: #{error.response}"
+      end
+
+      def has_a_load_balancer?
+        # TODO : Refactor this code in order to move it in the Service class
+        @load_balancer_service = @original_stack.services.detect do |service|
+          service.image_name =~ /^dockercloud\/haproxy\:/
+        end
+      end
+
+      def load_balancer_service
+        service = Capistrano::DockerCloud::Service.new(@load_balancer_service)
+        service.stack = self
+        service
+      end
+
+      def start_service(options)
+        services = find_service_by_name(options[:name])
+        service = first_or_raise_error!(services, options[:name])
+        service.start
+      end
+
+      def uuid
+        @original_stack.uuid
+      end
+
+      def waiting_service_boot(options)
+        options[:timeout] ||= 60
+        services = find_service_by_name(options[:name])
+        service = first_or_raise_error!(services, options[:name])
+
+        Timeout.timeout(options[:timeout]) do
+          begin
+            sleep 0.5
+            service.reload
+          end until service.state == 'Running'
+        end
+      rescue Timeout::Error
+        raise "The service #{options[:name]} was not able to boot in less " \
+              "than #{options[:timeout]} seconds. (Service state was " \
+              "#{service.state.inspect})"
+      end
+
+      def waiting_service_application_boot(options)
+        options[:timeout] ||= 60
+        services = find_service_by_name(options[:name])
+        service = first_or_raise_error!(services, options[:name])
+
+        uri = service.containers.flat_map do |container|
+          container.info[:container_ports].map do |container_port|
+            next unless container_port[:endpoint_uri]
+            container_port[:endpoint_uri].gsub(/^tcp\:\/\//, 'http://')
+          end
+        end
+
+        result = 0
+
+        Timeout.timeout(options[:timeout]) do
+          while result != 200 do
+            sleep 0.5
+            result = uri.map do |url|
+              begin
+                response = RestClient.get(url)
+                response.code
+              rescue Errno::ECONNREFUSED
+                500
+              end
+            end.reduce(0, :+) / uri.size
+          end
+        end
+      rescue Timeout::Error
+        raise "The service #{options[:name]} application was not able to boot" \
+              " in less than #{options[:timeout]} seconds."
+      end
+
+      private
+
+      def sync_services_from_stack(from_stack = nil)
+        @services = []
+        @services = (from_stack || @original_stack).services.map do |service|
+          Capistrano::DockerCloud::Service.new(service)
+        end
+      end
+
+      def compare(source, from, options = {})
+        compare_source = source.dup
+        compare_from = from.dup
+
+        if options[:tag] == false
+          compare_source = compare_source.gsub(/\:.*$/, '')
+          compare_from = compare_from.gsub(/\:.*$/, '')
+        end
+
+        compare_source == compare_from
+      end
+
+      def build_update_body
+        { services: @services.map(&:build_update_hash) }
+      end
+    end
+  end
+end

data/lib/capistrano/docker-cloud/version.rb

@@ -0,0 +1,5 @@
+module Capistrano
+  module DockerCloud
+    VERSION = '0.2.2'
+  end
+end

data/lib/capistrano/tasks/docker-cloud.rake

@@ -0,0 +1,11 @@
+require 'capistrano/docker-cloud/client'
+
+namespace :docker_cloud do
+  desc 'Deploy with zero-downtime on Docker cloud'
+  task :deploy do
+    run_locally do
+      set :docker_image_tag, ask('What tag do you want to deploy?', 'latest')
+      Capistrano::DockerCloud::Client.new(self).deploy
+    end
+  end
+end

data/make_new_release.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+DOCKER_IMAGE_NAME="$USER/capistrano-docker-cloud"
+LIBRARY_NEW_VERSION=`cat lib/**/*.rb | grep VERSION | awk '{ print $3 }' | tr -d "'"`
+
+LIBRARY_UPDATED=`git status --porcelain | grep -v "lib/capistrano/docker-cloud/version.rb"`
+if [[ -n "$LIBRARY_UPDATED" ]]; then
+  echo "Your repository is not clean !"
+  exit 1
+fi
+
+echo "Ensuring Docker image $DOCKER_IMAGE_NAME exists ..."
+EXISTING_DOCKER_IMAGE=`docker images | grep "$DOCKER_IMAGE_NAME"`
+if [[ -z "$EXISTING_DOCKER_IMAGE" ]]; then
+  echo "Building the Docker image ..."
+  docker build -t "$DOCKER_IMAGE_NAME" .
+fi
+
+echo "Releasing gem ..."
+docker run --rm -v ~/.gitconfig:/root/.gitconfig \
+  -v ~/.ssh/:/root/.ssh/ \
+  -v ~/.gem/:/root/.gem/ \
+  -v `pwd`:/gem/ "$DOCKER_IMAGE_NAME" rake release

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: capistrano-docker-cloud
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Guillaume Hain
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: capistrano-bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: docker_cloud
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+description: Docker cloud specific Capistrano tasks
+email:
+- zedtux@zedroot.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Dockerfile
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- capistrano-rails.gemspec
+- lib/capistrano/docker-cloud.rb
+- lib/capistrano/docker-cloud/base.rb
+- lib/capistrano/docker-cloud/client.rb
+- lib/capistrano/docker-cloud/helpers/collection_helper.rb
+- lib/capistrano/docker-cloud/service.rb
+- lib/capistrano/docker-cloud/stack.rb
+- lib/capistrano/docker-cloud/version.rb
+- lib/capistrano/tasks/docker-cloud.rake
+- make_new_release.sh
+homepage: https://github.com/YourCursus/capistrano-docker-cloud
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: Docker cloud specific Capistrano tasks
+test_files: []