docker_compose_deploy 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d0c48329c119fc90532529e8a141a52b3cf45b17
+  data.tar.gz: 7489ff60f598b4fe35f69ddf371dc177e1655fed
+SHA512:
+  metadata.gz: c584fece997fe67ba5826b8df74f41c48455d5a6b6feb247f557c32858f5a1ab8072f3974898be0b8d8b9bb249618237b3ff9dea044dcd52f583735a315c69d4
+  data.tar.gz: 8ac15de15749951c7a48b01ae6c3f828df6c20cc564a71d5ca50dad59823da647e895b307a67ced72038e4f17971addab037023df435820b670fa8a77fd68f76

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem
+tags

data/Gemfile

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

data/README.md

@@ -0,0 +1,15 @@
+### Easily deploy a docker-compose.yml
+
+This gem is a collection of scripts that I use to deploy my personal websites using docker-compose. This gem will help you:
+
+- Generate a skeleton for you project
+- Provision a server with Docker and Docker Compose
+- Test your deployment on a vagrant machine
+- Deploy your docker-compose project
+- Backup the data that your applications Generate
+
+While these scripts are great for your personal projects, they will not help you with zero-downtime deploys, rotating your logs, or any of that other fancy stuff.
+
+This doesn't provide much over using docker-machine, but it will simplify working with volumes and allow you to test your deployment in a realistic environment.
+
+### The Skeleton

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/docker_compose_deploy.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'docker_compose_deploy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "docker_compose_deploy"
+  spec.version       = DockerComposeDeploy::VERSION
+  spec.authors       = ["Pete Kinnecom"]
+  spec.email         = ["rubygems@k7u7.com"]
+  spec.licenses    = ['MIT']
+
+  spec.summary       = %q{This helps you deploy a website using docker-compose}
+  spec.homepage      = "http://www.petekinnecom.net"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "thor", "~> 0.19"
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/exe/dcd

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/docker_compose_deploy/cli"
+
+
+DockerComposeDeploy::CLI.start(ARGV)

data/lib/docker_compose_deploy/actions/backup.rb

@@ -0,0 +1,43 @@
+module DockerComposeDeploy
+  module Actions
+    class Backup < Struct.new(:shell)
+
+      def save
+        shell.notify("Backing up remote ./sites/data directory")
+        shell.notify("This may take a while...")
+        shell.run!("mkdir -p ./backups")
+
+        shell.ssh!("mkdir -p ./sites/backups")
+        shell.ssh!("tar -zcvf ./sites/backups/#{filename} ./sites/data")
+        shell.scp!("#{connection}:./sites/backups/#{filename}", "./backups/#{filename}")
+        shell.ssh!("rm ./sites/backups/#{filename}")
+
+        shell.notify "success"
+      end
+
+      private
+
+      def tmp_dir
+        @tmp_dir ||= "./tmp".tap do |dir|
+          FileUtils.mkdir_p(dir)
+        end
+      end
+
+      def filename
+        @filename ||= begin
+          time_str = Time.now.strftime("%Y-%m-%d_%H.%M.%S")
+
+          "backup__#{connection}__#{time_str}.tar.gz"
+        end
+      end
+
+      def tmp_file_path
+        File.join(tmp_dir, filename)
+      end
+
+      def connection
+        DockerComposeDeploy.config.connection
+      end
+    end
+  end
+end

data/lib/docker_compose_deploy/actions/deployment.rb

@@ -0,0 +1,42 @@
+require "docker_compose_deploy/actions/docker_compose/file"
+
+module DockerComposeDeploy
+  module Actions
+    class Deployment < Struct.new(:ignore_pull_failures, :shell)
+
+      def create
+        shell.ssh!("mkdir -p ./sites")
+        shell.ssh!("rm -rf ./sites/config") # bin/deploy is irreversible :)
+        shell.scp!("./sites/config/", "#{connection}:./sites/config", "-r")
+
+        docker_compose.services.each do |service_name|
+          shell.ssh!("mkdir -p ./sites/data/#{service_name}")
+          shell.ssh!("mkdir -p ./sites/log/#{service_name}")
+        end
+
+        shell.scp!(docker_compose.path, "#{connection}:./docker-compose.yml")
+        shell.ssh!("docker-compose down")
+        shell.ssh!("docker-compose pull #{ignore_pull_failures_option}")
+        shell.ssh!("docker-compose up -d")
+
+        shell.notify "success"
+      end
+
+      private
+
+      def ignore_pull_failures_option
+        if ignore_pull_failures
+          "--ignore-pull-failures"
+        end
+      end
+
+      def docker_compose
+        @docker_compose ||= DockerCompose::File.new
+      end
+
+      def connection
+        DockerComposeDeploy.config.connection
+      end
+    end
+  end
+end

data/lib/docker_compose_deploy/actions/docker_compose/file.rb

@@ -0,0 +1,32 @@
+require 'yaml'
+
+module DockerComposeDeploy
+  module Actions
+    module DockerCompose
+      class File
+        attr_reader :path
+        def initialize(path="./docker-compose.yml")
+          @path = path
+        end
+
+        def services
+          if !hash["services"]
+            raise "This is build to work with version 2 or 3 of docker-compose. It requires the 'services' top level key."
+          end
+
+          hash["services"].keys
+        end
+
+        private
+
+        def hash
+          @hash ||= YAML.load(string)
+        end
+
+        def string
+          @string ||= ::File.read(@path)
+        end
+      end
+    end
+  end
+end

data/lib/docker_compose_deploy/actions/hosts.rb

@@ -0,0 +1,30 @@
+module DockerComposeDeploy
+  module Actions
+    class Hosts < Struct.new(:shell)
+
+      def hijack
+        return unless DockerComposeDeploy.config.domains.any?
+
+        shell.notify("Creating hosts entries for test_domains")
+
+        host_entries = ["localhost", "vagrant"] + DockerComposeDeploy.config.domains
+        Tempfile.open do |f|
+          host_entries.each do |host|
+            f.puts("127.0.0.1 #{host}")
+          end
+          f.close
+          shell.scp!(f.path, "#{connection}:/tmp/hosts")
+          shell.ssh!("sudo mv /tmp/hosts /etc/hosts")
+          shell.notify("Wrote to /etc/hosts on test server:")
+          shell.puts(`cat #{f.path}`)
+        end
+      end
+
+      private
+
+      def connection
+        DockerComposeDeploy.config.connection
+      end
+    end
+  end
+end

data/lib/docker_compose_deploy/actions/image.rb

@@ -0,0 +1,41 @@
+require "securerandom"
+require "fileutils"
+
+module DockerComposeDeploy
+  module Actions
+    class Image < Struct.new(:name, :shell)
+
+      def push
+        shell.notify "Pushing #{name} to remote"
+
+        shell.run!("docker save #{name} > #{tmp_file_path}")
+        shell.run!("bzip2 #{tmp_file_path}")
+        shell.scp!("#{tmp_file_path}.bz2", "#{connection}:/tmp/")
+        shell.run!("rm #{tmp_file_path}.bz2")
+        shell.ssh!("docker load -i /tmp/#{filename}.bz2")
+
+        shell.notify "success"
+      end
+
+      private
+
+      def tmp_dir
+        @tmp_dir ||= "./tmp".tap do |dir|
+          FileUtils.mkdir_p(dir)
+        end
+      end
+
+      def filename
+        @filename ||= "#{name.gsub('/', '__')}_#{SecureRandom.hex}.tar"
+      end
+
+      def tmp_file_path
+        File.join(tmp_dir, filename)
+      end
+
+      def connection
+        DockerComposeDeploy.config.connection
+      end
+    end
+  end
+end

data/lib/docker_compose_deploy/actions/server.rb

@@ -0,0 +1,27 @@
+module DockerComposeDeploy
+  module Actions
+    class Server < Struct.new(:shell)
+
+      def provision
+        shell.notify("Provisioning: #{connection}")
+        shell.ssh!("sudo groupadd docker")
+        shell.ssh!("sudo usermod -aG docker $USER")
+        shell.ssh!("true", "-O exit") # resets the connection, so that our group changes take effect
+
+        shell.ssh!("wget -qO- https://get.docker.com/ | bash")
+        shell.ssh!("curl -L https://github.com/docker/compose/releases/download/1.11.1/run.sh > ./docker-compose")
+        shell.ssh!("chmod +x docker-compose")
+        shell.ssh!("sudo mv ./docker-compose /usr/local/bin/docker-compose")
+        shell.ssh!("docker-compose -v")
+
+        shell.notify "success"
+      end
+
+      private
+
+      def connection
+        DockerComposeDeploy.config.connection
+      end
+    end
+  end
+end

data/lib/docker_compose_deploy/actions/skeleton.rb

@@ -0,0 +1,43 @@
+module DockerComposeDeploy
+  module Actions
+    class Skeleton < Struct.new(:name, :shell)
+
+      def create
+        shell.notify("Creating new skeleton")
+        if File.exist?(name)
+          shell.warn("Directory or file: '#{name}' already exists. Exiting.")
+          exit(1)
+        end
+
+        begin
+          Dir.mkdir(name)
+          Dir.rmdir(name)
+        rescue
+          shell.warn("Unable to make directory '#{name}'. Is it a valid directory name? Exiting.")
+        end
+
+        template_path = File.expand_path(File.join(__dir__, "../../../template"))
+        FileUtils.cp_r(template_path, name)
+        shell.notify("Created skeleton app in '#{name}'.")
+        shell.puts <<-MESSAGE
+To see the skeleton app in action, run the following commands
+
+# Move into the directory
+1. cd #{name}
+
+# Use vagrant to create the virtual machine for testing (it will open a window and will display Ubuntu's desktop)
+2. vagrant up
+
+# Install docker and docker-compose on the vagrant machine
+3. dcd provision
+
+# Deploy the skeleton app to the vagrant machine
+4. dcd deploy
+
+# See the server in action:
+5. Open firefox on the vagrant machine and visit http://www.test
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/docker_compose_deploy/actions.rb

@@ -0,0 +1,6 @@
+require "docker_compose_deploy/actions/deployment"
+require "docker_compose_deploy/actions/server"
+require "docker_compose_deploy/actions/backup"
+require "docker_compose_deploy/actions/image"
+require "docker_compose_deploy/actions/hosts"
+require "docker_compose_deploy/actions/skeleton"

data/lib/docker_compose_deploy/cli.rb

@@ -0,0 +1,49 @@
+require "thor"
+$LOAD_PATH.unshift(File.expand_path("..", __dir__))
+require "docker_compose_deploy"
+require "docker_compose_deploy/util/shell"
+require "docker_compose_deploy/actions"
+
+module DockerComposeDeploy
+  class CLI < Thor
+    desc "push IMAGE_NAME", "push IMAGE_NAME to configured host"
+    option :e, required: true, default: "test"
+    def push(*image_names)
+      DockerComposeDeploy.configure!(options[:e])
+      shell = Util::Shell.new
+      image_names.each do |image_name|
+        Actions::Image.new(image_name, shell).push
+      end
+    end
+
+    desc "deploy", "deploy your docker-compose.yml to configured host"
+    option :e, required: true, default: "test"
+    def deploy
+      DockerComposeDeploy.configure!(options[:e])
+      ignore_pull_failures = DockerComposeDeploy.config.ignore_pull_failures
+      shell = Util::Shell.new
+
+      Actions::Deployment.new(ignore_pull_failures, shell).create
+      Actions::Hosts.new(shell).hijack
+    end
+
+    desc "backup", "backup the data directory of the configured host"
+    option :e, required: true, default: "test"
+    def backup
+      DockerComposeDeploy.configure!(options[:e])
+      Actions::Backup.new(Util::Shell.new).save
+    end
+
+    desc "provision", "provision the host to work with docker"
+    option :e, required: true, default: "test"
+    def provision
+      DockerComposeDeploy.configure!(options[:e])
+      Actions::Server.new(Util::Shell.new).provision
+    end
+
+    desc "new", "create a new docker-compose server skeleton"
+    def new(name)
+      Actions::Skeleton.new(name, Util::Shell.new).create
+    end
+  end
+end

data/lib/docker_compose_deploy/util/color.rb

@@ -0,0 +1,26 @@
+module DockerComposeDeploy
+  module Util
+    module Color
+      CODES = {
+        red: 31,
+        green: 32,
+        yellow: 33,
+        blue: 34,
+        pink: 35,
+      }.freeze
+
+      CODES.each do |color, code|
+        self.send(:define_method, color) do |string|
+          colorize(string, code)
+        end
+      end
+
+      private
+
+      # colorization
+      def colorize(string, color_code)
+        "\e[#{color_code}m#{string}\e[0m"
+      end
+    end
+  end
+end

data/lib/docker_compose_deploy/util/shell.rb

@@ -0,0 +1,74 @@
+require 'docker_compose_deploy/util/color'
+
+module DockerComposeDeploy
+  module Util
+    class Shell
+      include Color
+
+      def initialize
+        $stderr.sync = true
+        $stdout.sync = true
+      end
+
+      def run(cmd)
+        puts blue(cmd)
+        IO.popen(cmd) do |io|
+          while (line = io.gets) do
+            puts line
+          end
+        end
+        $?
+      end
+
+      def run!(cmd)
+        if run(cmd) != 0
+          exit("\nCommand failed:\n#{cmd}")
+        end
+      end
+
+      def warn(msg)
+        puts red(msg)
+      end
+
+      def notify(msg)
+        puts yellow(msg)
+      end
+
+      def puts(msg)
+        Kernel.puts(msg)
+      end
+
+      def exit(msg)
+        warn(msg)
+        Kernel.exit(1)
+      end
+
+      def ssh(cmd)
+        run(ssh_cmd(cmd))
+      end
+
+      def ssh!(cmd, opts="")
+        run!(ssh_cmd(cmd, opts))
+      end
+
+      def scp!(src, dest, opts="")
+        run!("scp -F ~/.ssh/config -F ssh_config_overrides #{opts} #{src} #{dest} > /dev/tty")
+      end
+
+      def confirm?(question)
+        warn "#{question} [Yn]"
+        STDIN.gets.strip.downcase != 'n'
+      end
+
+      def ssh_cmd(cmd, opts)
+        "ssh -F ~/.ssh/config -F ssh_config_overrides #{opts} #{connection} '#{cmd}'"
+      end
+
+      private
+
+      def connection
+        DockerComposeDeploy.config.connection
+      end
+    end
+  end
+end

data/lib/docker_compose_deploy/version.rb

@@ -0,0 +1,3 @@
+module DockerComposeDeploy
+  VERSION = "1.0.0"
+end

data/lib/docker_compose_deploy.rb

@@ -0,0 +1,40 @@
+require "docker_compose_deploy/version"
+require "yaml"
+
+module DockerComposeDeploy
+  class << self
+    def config
+      @config || raise("Not configured")
+    end
+
+    def configure!(environment)
+      yaml = YAML.load(File.read("./config.yml"))
+      @config = Configuration.new(environment, yaml)
+    end
+  end
+
+  class Configuration
+    def initialize(environment, yaml)
+      @environment = environment
+      @yaml = yaml
+    end
+
+    def ignore_pull_failures
+      config_block.fetch("ignore_pull_failures", false)
+    end
+
+    def connection
+      config_block["connection"] || raise("INVALID CONFIG: Environment '#{@environment}' does not specify a connection string in config.yml")
+    end
+
+    def domains
+      config_block.fetch("domains", [])
+    end
+
+    private
+
+    def config_block
+      @yaml[@environment] || raise("INVALID ENVIRONMENT: Environment '#{@environment}' is not configured in config.yml")
+    end
+  end
+end

data/template/Vagrantfile

@@ -0,0 +1,8 @@
+Vagrant.configure("2") do |config|
+  config.vm.box = "boxcutter/ubuntu1604-desktop"
+  config.vm.network "forwarded_port", guest: 80, host: 8080
+
+  config.vm.provider "virtualbox" do |v|
+    v.gui = true
+  end
+end

data/template/config.yml

@@ -0,0 +1,80 @@
+# Environment configuration
+#
+# You can define as many "environments" as you like. I've found
+# that I only need two. The "test" environment is the vagrant
+# box, the "production" environment uses my virtual machine on
+# DigitalOcean.
+#
+# When using the `dcd` command, you can specify the environment
+# using the `-e` flag. Here is an example:
+#
+#  dcd deploy -e production
+#
+# If the `-e` is not set, it will default to "test".
+#
+################################################################
+#
+# "connection": How we connect to the host machine
+#
+# For each, we must configure the connection string that we use
+# to connect to the host using ssh. The "test" environment is
+# already setup for the vagrant host. You need to configure the
+# production environment.
+#
+################################################################
+#
+# "ignore_pull_failures": Pull Failures configuration
+#
+# For each environment we can also set the "ignore_pull_failures"
+# flag. This flag is used when deploying your docker-compose.yml.
+#
+# We run `docker-compose pull` to pull down the latest
+# images from hub.docker.com. If you have decided instead
+# to push your images directly to your host (using
+# `dcd push image_name`) then these images will fail to be pulled
+# from hub.docker.com (since they were never put there).
+#
+# If images cannot be pulled, then `docker-compose pull` will
+# consider this an error. Setting `ignore_pull_failures` to `true`
+# will tell docker-compose to ignore any errors generated while
+# pulling down the latest image.
+#
+# If you are using hub.docker.com, leave this as false.
+#
+# If you are using `dcd push image_name` then set this to true
+#
+################################################################
+#
+# "domains" => Urls to hijack on the host machine
+#
+# It can be tricky to ensure that the nginx configuration that
+# your proxy is using is routing things to the correct docker
+# container.
+#
+# In order to help test things on the vagrant machine, we add
+# the listed domains to the /etc/hosts file of the machine.
+# We can then use firefox on the vagrant machine to visit one
+# of the domains and the request will be routed back to our
+# nginx proxy.
+#
+# Add an entry here for each subdomain that you have on your
+# production server. Notice how the three domains specified
+# here are present in the sites/config/proxy/nginx.conf file.
+#
+# Note that you can specify any domain, but using the ".test"
+# domain will keep things clear while testing.
+#
+# You should have no reason to add domains for your production
+# server.
+#
+
+test:
+  connection: "vagrant@default"
+  ignore_pull_failures: false
+  domains:
+    - www.test
+    - site1.test
+    - site2.test
+production:
+  connection: "user@yourserver"
+  ignore_pull_failures: false

data/template/docker-compose.yml

@@ -0,0 +1,26 @@
+version: '3'
+services:
+  proxy:
+    image: nginx:1.11.10
+    command: ["nginx", "-c", "/mnt/config/nginx.conf", "-g", "daemon off;"]
+    volumes:
+      - ./sites/config/proxy:/mnt/config
+      - ./sites/data/proxy:/mnt/data
+      - ./sites/log/proxy:/mnt/log
+    ports:
+      - 80:80
+    depends_on:
+      - site1
+      - site2
+  site1:
+    image: petekinnecom/compose_deploy_site:1.0
+    volumes:
+      - ./sites/config/site1:/mnt/config
+      - ./sites/data/site1:/mnt/data
+      - ./sites/log/site1:/mnt/log
+  site2:
+    image: petekinnecom/compose_deploy_site:2.0
+    volumes:
+      - ./sites/config/site2:/mnt/config
+      - ./sites/data/site2:/mnt/data
+      - ./sites/log/site2:/mnt/log

data/template/sites/config/proxy/nginx.conf

@@ -0,0 +1,36 @@
+events {
+  worker_connections  1024;
+}
+
+http {
+  access_log  /mnt/log/access.log;
+  error_log   /mnt/log/error.log;
+
+  server {
+    listen 80;
+    server_name www.*;
+
+    location / {
+      add_header Content-Type text/html;
+      return 200 "<a href='http://site1.test'>site1</a> or <a href='http://site2.test'>site2</a>";
+    }
+  }
+
+  server {
+    listen 80;
+    server_name site1.*;
+
+    location / {
+      proxy_pass http://site1/;
+    }
+  }
+
+  server {
+    listen 80;
+    server_name site2.*;
+
+    location / {
+      proxy_pass http://site2/;
+    }
+  }
+}

data/template/ssh_config_overrides

@@ -0,0 +1,27 @@
+# This keeps the connection alive for two seconds
+# after each usage. This improves performance.
+
+Host *
+  ControlPath ~/.ssh/sock-%r@%h:%p
+  ControlMaster auto
+  ControlPersist 2
+
+# The following configuration for the "default" host works
+# with the default Vagrant file and vagrant 1.9.1. If you
+# cannot connect using:
+#
+#   ssh -F ssh_config_overrides vagrant@default
+#
+# Then replace this Host definition with the output from
+# the command: `vagrant ssh-config`
+
+Host default
+  HostName 127.0.0.1
+  User vagrant
+  Port 2222
+  UserKnownHostsFile /dev/null
+  StrictHostKeyChecking no
+  PasswordAuthentication no
+  IdentityFile .vagrant/machines/default/virtualbox/private_key
+  IdentitiesOnly yes
+  LogLevel FATAL

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: docker_compose_deploy
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Pete Kinnecom
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- rubygems@k7u7.com
+executables:
+- dcd
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- docker_compose_deploy.gemspec
+- exe/dcd
+- lib/docker_compose_deploy.rb
+- lib/docker_compose_deploy/actions.rb
+- lib/docker_compose_deploy/actions/backup.rb
+- lib/docker_compose_deploy/actions/deployment.rb
+- lib/docker_compose_deploy/actions/docker_compose/file.rb
+- lib/docker_compose_deploy/actions/hosts.rb
+- lib/docker_compose_deploy/actions/image.rb
+- lib/docker_compose_deploy/actions/server.rb
+- lib/docker_compose_deploy/actions/skeleton.rb
+- lib/docker_compose_deploy/cli.rb
+- lib/docker_compose_deploy/util/color.rb
+- lib/docker_compose_deploy/util/shell.rb
+- lib/docker_compose_deploy/version.rb
+- template/Vagrantfile
+- template/config.yml
+- template/docker-compose.yml
+- template/sites/config/proxy/nginx.conf
+- template/ssh_config_overrides
+homepage: http://www.petekinnecom.net
+licenses:
+- MIT
+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.5.2
+signing_key: 
+specification_version: 4
+summary: This helps you deploy a website using docker-compose
+test_files: []
+has_rdoc: