dockerploy 0.0.2 → 0.0.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NTcwNmE2ZjEzM2Q3ZjBhZTEzZDA1NGVjODU3OWI1ODBhODZlMzc3Mw==
+    MmJiMDlmMDFkMmE1MzVjZWUwNTU0NWM2NDU5MDkxMWVkMjI5NzFiZg==
   data.tar.gz: !binary |-
-    YjY2ZWNmNzM2Y2Y2Y2Q2ZjZkNTM4OTMyZWY1MTRhNmFhMWExMzhmNw==
+    NzhlOGFiMDYwNzFmN2VjNmE3MDIyOWIzYzM5ZjAxOWI3ZTkyNWEyZg==
 SHA512:
   metadata.gz: !binary |-
-    ZDc0Zjk0MWFlYzM1N2YyOTZjZjk1MThmMmEzOTQxOGZkZmNjMTJmMzVhODhj
-    NjcxODk0ODZjYTE0ZjliOGNlOWFlNDAxYzE3ZGIxY2EyYWI0MzM4MjRlMDBl
-    YjYzMDc2OThmMjYzZjc3Mjc3Y2IzMjNiYjQ2NDg1NTBjNTk5NjE=
+    NDA0ODIwNGQwNTMzODg0NGYwOTRiNGI1NTBjZTExYzBhMGY4NTIyYjUxNmMz
+    YjVlNWVjNDczNmNiOTVmN2RjNzQzYTBlYmUzYTg4MDRjNmM0NTU3MzBkYmJk
+    ZDY2ZmNlN2UzOTI4MmM3OTEyNGJlNjljYzUyZjVhOTFkNmI1NjA=
   data.tar.gz: !binary |-
-    YTdjOGQ5YmUzYTk0MTM3OWE5MGFkNjAyOWE1NTBiNTAxMGVhYTI4NTYyZTli
-    NWE1ODMzMGU4MGE5Mjk5NDk4NGI4MTAxZjY5MzZhYTM5YWQyMTM1MGI3MmU2
-    YTQ4NTU1YTRlNTM1NGU0MDcwMzFiNWZjOGVkODBhYTdjMTQ5MDQ=
+    MGQyNGMzYzQwNmU2OWNkN2QwMmI3OWE1MDRkNjM0MDg3MGE4NjhkNGMxNzIw
+    M2QxYzAwYWM3MjI5NjIwZTJhODI2NTViMjFhY2FkOGE5Yzg0MWQyYzQyZjcz
+    OGU0MDU3N2MwN2IzMmYxYjVjY2JlNjM0Zjc2Yjc5MmRiMjgzNjc=

data/.gitignore

@@ -3,6 +3,7 @@
 .bundle
 .config
 .yardoc
+.ruby-version
 Gemfile.lock
 InstalledFiles
 _yardoc
@@ -16,4 +17,4 @@ test/tmp
 test/version_tmp
 tmp
 docker/config.yml
-.idea
+.idea

data/c

@@ -0,0 +1,2 @@
+#!/bin/bash
+irb -I ./lib -r ./lib/dockerploy.rb

data/dockerploy.gemspec

@@ -21,8 +21,10 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 1.9.3'
   spec.add_dependency 'thor', '~> 0.19'
   spec.add_dependency 'mono_logger', '~> 1.1.0'
+  spec.add_dependency 'net-ssh', '~> 2.6'
 
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'fakefs', '~> 0.6'
 end

data/lib/dockerploy/cli.rb

@@ -4,16 +4,25 @@ require 'yaml'
 require 'dockerploy/configuration'
 require 'dockerploy/deploy'
 require 'dockerploy/image'
+require 'dockerploy/template'
+require 'erb'
+require 'ostruct'
 
 module Dockerploy
   # The command-line interface for Dockerploy
   class CLI < Thor
-    class_option :config, aliases: ['-c'], type: :string
+    class_option :config, aliases: ['-c'], type: :string, required: false
+    class_option :tag, aliases: ['-t'], type: :string, required: false
 
     def initialize(args = [], opts = {}, config = {})
       super(args, opts, config)
     end
 
+    desc 'init', 'Generate a config.yml file'
+    def init
+      Template.write
+    end
+
     desc 'ps ENVIRONMENT', 'Show running containers'
     def ps(environment)
       config = configuration(environment.to_sym)
@@ -26,23 +35,27 @@ module Dockerploy
 
     desc 'build', 'build an image'
     def build
-      Image.new(configuration).build
+      build_options = { tag: options[:tag] }
+      Image.new(configuration, build_options).build
     end
 
     desc 'push', 'push an image'
     def push
-      Image.new(configuration).push
+      build_options = { tag: options[:tag] }
+      Image.new(configuration, build_options).push
     end
 
     desc 'pull', 'pull an image'
     def pull(environment)
-      Image.new(configuration(environment.to_sym)).pull
+      build_options = { tag: options[:tag] }
+      Image.new(configuration(environment.to_sym), build_options).pull
     end
 
     desc 'deploy', 'deploy an application'
     def deploy(environment)
+      deploy_options = { tag: options[:tag] }
       config = configuration(environment.to_sym)
-      Deploy.new(config).deploy
+      Deploy.new(config, deploy_options).deploy
     end
 
     private

data/lib/dockerploy/configuration.rb

@@ -42,6 +42,32 @@ module Dockerploy
       options[@env][:tagging]
     end
 
+    def before_all_hooks
+      return {} if options[:hooks].nil? || options[:hooks][:before_deploy].nil?
+      options[:hooks][:before_deploy]
+    end
+
+    def before_hooks
+      raise NoEnvError if @env.nil?
+      return {} if options[@env].nil?
+      hooks = options[@env][:hooks]
+      return {} if hooks.nil? || hooks[:before_deploy].nil?
+      hooks[:before_deploy]
+    end
+
+    def after_all_hooks
+      return {} if options[:hooks].nil? || options[:hooks][:after_deploy].nil?
+      options[:hooks][:after_deploy]
+    end
+
+    def after_hooks
+      raise NoEnvError if @env.nil?
+      return {} if options[@env].nil?
+      hooks = options[@env][:hooks]
+      return {} if hooks.nil? || hooks[:after_deploy].nil?
+      hooks[:after_deploy]
+    end
+
     private
 
     def options

data/lib/dockerploy/deploy.rb

@@ -3,8 +3,9 @@ module Dockerploy
     SSH_PORT = 22
     HTTP_PORT = 80
 
-    def initialize(config)
+    def initialize(config, options = {})
       @config = config
+      @options = options
     end
 
     def destroy(ssh_client, server)
@@ -19,25 +20,48 @@ module Dockerploy
       command << option_delimiter + port_option(server)
       command << option_delimiter + volume_option
       command << option_delimiter + environment_variables_option
-      command << option_delimiter + @config.image_name
+      command << option_delimiter + image_name
       ssh_client.command(command)
     end
 
     def deploy
       create_tag if @config.tagging?
       @config.servers.each do |server|
+        run_before_hooks(server)
         ssh_client = SSHClient.new(server[:host], server[:username], server[:password], server[:port])
         destroy(ssh_client, server)
         run(ssh_client, server)
+        run_after_hooks(server)
       end
     end
 
+    def run_before_hooks(server)
+      @config.before_all_hooks.each { |hook| run_hook(server, hook) }
+      @config.before_hooks.each { |hook| run_hook(server, hook) }
+    end
+
+    def run_after_hooks(server)
+      @config.after_all_hooks.each { |hook| run_hook(server, hook) }
+      @config.after_hooks.each { |hook| run_hook(server, hook) }
+    end
+
+    def run_hook(server, hook)
+      if hook[:local]
+        hook[:local].each do |command|
+          ShellClient.new(abort_on_failure: true).command(command)
+        end
+      elsif hook[:remote]
+        hook[:remote].each do |command|
+          SSHClient.new(server[:host], server[:username], server[:password], server[:port]).command(command)
+        end
+      end
+    end
     private
 
     def create_tag
       tag_name = sprintf('%s-%s', @config.env, Time.now.strftime('%Y%m%dT%H%M'))
-      command = sprintf('git tag %s %s && git push origin %s', tag_name, @config.branch, tag_name)
-      ShellClient.new.command(command)
+      ShellClient.new.command(sprintf('git tag %s %s', tag_name, @config.branch))
+      ShellClient.new.command(sprintf('git push origin %s', tag_name))
     end
 
     def volume_option
@@ -73,5 +97,9 @@ module Dockerploy
     def hostname_option
       sprintf('--hostname %s', @config.application_name)
     end
+
+    def image_name
+      @options[:tag] ? sprintf('%s:%s', @config.image_name, @options[:tag]) : @config.image_name
+    end
   end
 end

data/lib/dockerploy/image.rb

@@ -1,16 +1,17 @@
 module Dockerploy
   class Image
-    def initialize(config)
+    def initialize(config, options = {})
       @config = config
+      @options = options
     end
 
     def build
-      command = sprintf('env DOCKER_HOST=%s docker build -t %s .', @config.docker_host, @config.image_name)
+      command = sprintf('env DOCKER_HOST=%s docker build -t %s .', @config.docker_host, image_name)
       ShellClient.new.command(command)
     end
 
     def push
-      command = sprintf('env DOCKER_HOST=%s docker push %s', @config.docker_host, @config.image_name)
+      command = sprintf('env DOCKER_HOST=%s docker push %s', @config.docker_host, image_name)
       ShellClient.new.command(command)
     end
 
@@ -18,8 +19,13 @@ module Dockerploy
       return unless @config.servers
       @config.servers.each do |server|
         ssh_client = SSHClient.new(server[:host], server[:username], server[:password], server[:port])
-        ssh_client.command(sprintf('docker pull %s', @config.image_name))
+        ssh_client.command(sprintf('docker pull %s', image_name))
       end
     end
+
+    private
+    def image_name
+      @options[:tag] ? sprintf('%s:%s', @config.image_name, @options[:tag]) : @config.image_name
+    end
   end
 end

data/lib/dockerploy/shell_client.rb

@@ -1,16 +1,28 @@
 module Dockerploy
-  # Wrapper for local shell command
   class ShellClient
-    def initialize
+    attr_accessor :output
+
+    def initialize(options = {})
+      @options = options
     end
 
     def command(command)
-      system(command)
-      unless $?.success?
-        Dockerploy.logger.info sprintf('Exit Code: %d', $?.exitstatus)
-        return false
+      Dockerploy.logger.debug sprintf('Running: %s', command)
+      IO.popen('-') do |p|
+        if p.nil?
+          $stderr.close
+          exec *command.split(' ')
+        end
+        @output = p.read
+        Dockerploy.logger.debug p.read
+      end
+
+      return false if $?.nil?
+      result = $?.exitstatus == 0
+      if !result && @options[:abort_on_failure]
+        Dockerploy.logger.error sprintf('Failed to run: %s', command)
+        abort
       end
-      true
     end
   end
-end
+end

data/lib/dockerploy/template.rb

@@ -0,0 +1,27 @@
+module Dockerploy
+  class Template
+    TEMPLATE_PATH = 'templates/config.yml.erb'.freeze
+    CONFIG_PATH = 'docker/config.yml.sample'.freeze
+
+    def self.application_name
+      File.basename(Dir.getwd)
+    end
+
+    def self.project_name
+      shell_client = ShellClient.new
+      shell_client.command('git config --get remote.origin.url')
+      shell_client.output.match(/([\w-]+\/[\w-]+).git/)[1]
+    end
+
+    def self.generate
+      namespace = OpenStruct.new(user: ENV['USER'], application_name: self.application_name, project_name: self.project_name)
+      template = File.read(File.expand_path(TEMPLATE_PATH, File.dirname(__FILE__)))
+      ERB.new(template).result(namespace.instance_eval { binding })
+    end
+
+    def self.write
+      FileUtils.mkdir_p('docker')
+      File.open(CONFIG_PATH, 'w') { |f| f.write(self.generate) }
+    end
+  end
+end

data/lib/dockerploy/templates/config.yml.erb

@@ -0,0 +1,17 @@
+image_name: <%= project_name %>
+docker_username: <%= user %>
+docker_host: tcp://:2375
+application_name: <%= application_name %>
+development:
+  branch: master
+  tagging: true
+  volumes: []
+  servers:
+    - host: 0.0.0.0
+      username: <%= user %>
+      password:
+      port: 22
+      container:
+        host: 0.0.0.0
+        ssh_port: 22
+        http_port: 80

data/lib/dockerploy/version.rb

@@ -1,4 +1,4 @@
 module Dockerploy
   # Version of Dockerploy
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/spec/fixtures/config_with_hooks.yml

@@ -0,0 +1,27 @@
+image_name: docker/image
+docker_username: dockeruser
+docker_host: tcp://test.host:4243
+application_name: app
+hooks:
+  before_deploy:
+    - local:
+      - echo "Started deploying"
+    - remote:
+      - echo "Access to server"
+  after_deploy:
+    - local:
+      - echo "Finished deploying"
+    - remote:
+      - echo "Access to server again"
+test:
+  branch: master
+  servers:
+    - host: server.host
+      username: server_user
+      password: server_pass
+      port: 2000
+      role: server_role
+      container:
+        host: container.host
+        ssh_port: 1022
+        http_port: 8080

data/spec/fixtures/config_with_hooks_for_each_env.yml

@@ -0,0 +1,27 @@
+image_name: docker/image
+docker_username: dockeruser
+docker_host: tcp://test.host:4243
+application_name: app
+test:
+  branch: master
+  hooks:
+    before_deploy:
+      - local:
+        - echo "Started deploying on testing"
+      - remote:
+        - echo "Access to test server"
+    after_deploy:
+      - local:
+        - echo "Finished deploying on testing"
+      - remote:
+        - echo "Access to test server again"
+  servers:
+    - host: server.host
+      username: server_user
+      password: server_pass
+      port: 2000
+      role: server_role
+      container:
+        host: container.host
+        ssh_port: 1022
+        http_port: 8080

data/spec/lib/dockerploy/cli_spec.rb

@@ -7,6 +7,18 @@ module Dockerploy
       stub_const('Dockerploy::Configuration::DEFAULT_CONFIG_FILE', fixture_path)
     end
 
+    describe '#init' do
+      include FakeFS::SpecHelpers
+      it 'runs docker ps in servers' do
+        FakeFS do
+          expect(Template).to receive(:generate).and_return('template')
+          cli = described_class.new
+          cli.init
+          expect(File.read('docker/config.yml.sample')).to eq('template')
+        end
+      end
+    end
+
     describe '#ps' do
       it 'runs docker ps in servers' do
         expect_any_instance_of(SSHClient).to receive(:command).with('docker ps | grep app')
@@ -22,6 +34,15 @@ module Dockerploy
         cli = described_class.new
         cli.build
       end
+
+      context 'with tag' do
+        it 'runs docker build with tag name' do
+          expected_command = 'env DOCKER_HOST=tcp://test.host:4243 docker build -t docker/image:tag .'
+          expect_any_instance_of(ShellClient).to receive(:command).with(expected_command)
+          cli = described_class.new([], tag: 'tag')
+          cli.build
+        end
+      end
     end
 
     describe '#push' do
@@ -31,6 +52,15 @@ module Dockerploy
         cli = described_class.new
         cli.push
       end
+
+      context 'with tag' do
+        it 'pushes the image with tag name' do
+          expected_command = 'env DOCKER_HOST=tcp://test.host:4243 docker push docker/image:tag'
+          expect_any_instance_of(ShellClient).to receive(:command).with(expected_command)
+          cli = described_class.new([], tag: 'tag')
+          cli.push
+        end
+      end
     end
 
     describe '#pull' do
@@ -39,6 +69,15 @@ module Dockerploy
         cli = described_class.new
         cli.pull('test')
       end
+
+      context 'with tag' do
+        it 'pulls the image with tag name' do
+          expected_command = 'docker pull docker/image:tag'
+          expect_any_instance_of(SSHClient).to receive(:command).with(expected_command)
+          cli = described_class.new([], tag: 'tag')
+          cli.pull('test')
+        end
+      end
     end
 
     describe '#deploy' do
@@ -52,6 +91,19 @@ SHELL
         cli = described_class.new
         cli.deploy('test')
       end
+
+      context 'with tag' do
+        it 'creates a container on server' do
+          expect_any_instance_of(SSHClient).to receive(:command).with('docker rm -f app_8080')
+          expected_command = <<-SHELL
+docker run -d --name app_8080 --hostname app -p container.host:1022:22 -p container.host:8080:80   docker/image:tag
+          SHELL
+          expected_command.chomp!
+          expect_any_instance_of(SSHClient).to receive(:command).with(expected_command)
+          cli = described_class.new([], tag: 'tag')
+          cli.deploy('test')
+        end
+      end
     end
   end
 end

data/spec/lib/dockerploy/deploy_spec.rb

@@ -6,7 +6,8 @@ module Dockerploy
     let(:config) { Configuration.new(env: 'test') }
     let(:ssh_client) { double(command: double) }
     let(:shell_client) { double(command: double) }
-    subject { described_class.new(config) }
+    let(:options) { {} }
+    subject { described_class.new(config, options) }
 
     before do
       stub_const('Dockerploy::Configuration::DEFAULT_CONFIG_FILE', fixture_path)
@@ -30,6 +31,19 @@ docker run -d --name app_8080 --hostname app -p container.host:1022:22 -p contai
         subject.deploy
       end
 
+      context 'with tag' do
+        let(:options) { {tag: 'tag'} }
+
+        it 'creates a container on server with tag' do
+          expected_command = <<-SHELL
+docker run -d --name app_8080 --hostname app -p container.host:1022:22 -p container.host:8080:80   docker/image:tag
+          SHELL
+          expected_command.chomp!
+          expect(ssh_client).to receive(:command).with(expected_command)
+          subject.deploy
+        end
+      end
+
       context 'an environment file exists' do
         let(:fixture_path) { 'spec/fixtures/config_with_env_file.yml' }
 
@@ -66,8 +80,44 @@ docker/image
 
         it 'pushes a tags to the repository' do
           timestamp = Time.now.strftime('%Y%m%dT%H%M')
-         expect(shell_client).to receive(:command).with(
-              "git tag test-#{timestamp} test-branch && git push origin test-#{timestamp}").and_return(true)
+          expect(shell_client).to receive(:command).with("git tag test-#{timestamp} test-branch").and_return(true)
+          expect(shell_client).to receive(:command).with("git push origin test-#{timestamp}").and_return(true)
+          subject.deploy
+        end
+      end
+
+      context 'with hooks' do
+        let(:fixture_path) { 'spec/fixtures/config_with_hooks.yml' }
+
+        it 'runs hooks before/after deploying' do
+          expect(shell_client).to receive(:command).with('echo "Started deploying"').ordered
+          expect(ssh_client).to receive(:command).with('echo "Access to server"').ordered
+          expect(ssh_client).to receive(:command).with('docker rm -f app_8080').ordered
+          expected_command = <<-SHELL
+docker run -d --name app_8080 --hostname app -p container.host:1022:22 -p container.host:8080:80   docker/image
+          SHELL
+          expected_command.chomp!
+          expect(ssh_client).to receive(:command).with(expected_command).ordered
+          expect(shell_client).to receive(:command).with('echo "Finished deploying"').ordered
+          expect(ssh_client).to receive(:command).with('echo "Access to server again"').ordered
+          subject.deploy
+        end
+      end
+
+      context 'with hooks in each environment' do
+        let(:fixture_path) { 'spec/fixtures/config_with_hooks_for_each_env.yml' }
+
+        it 'runs hooks before/after deploying' do
+          expect(shell_client).to receive(:command).with('echo "Started deploying on testing"').ordered
+          expect(ssh_client).to receive(:command).with('echo "Access to test server"').ordered
+          expect(ssh_client).to receive(:command).with('docker rm -f app_8080').ordered
+          expected_command = <<-SHELL
+docker run -d --name app_8080 --hostname app -p container.host:1022:22 -p container.host:8080:80   docker/image
+          SHELL
+          expected_command.chomp!
+          expect(ssh_client).to receive(:command).with(expected_command).ordered
+          expect(shell_client).to receive(:command).with('echo "Finished deploying on testing"').ordered
+          expect(ssh_client).to receive(:command).with('echo "Access to test server again"').ordered
           subject.deploy
         end
       end

data/spec/lib/dockerploy/image_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module Dockerploy
+  describe Image do
+    let(:fixture_path) { 'spec/fixtures/config.yml' }
+    before do
+      stub_const('Dockerploy::Configuration::DEFAULT_CONFIG_FILE', fixture_path)
+    end
+
+    let(:config) { Configuration.new(env: 'test') }
+    let(:options) { {} }
+
+    describe '#build' do
+      subject { Image.new(config, options).build }
+
+      it 'runs docker build' do
+        expected_command = 'env DOCKER_HOST=tcp://test.host:4243 docker build -t docker/image .'
+        expect_any_instance_of(ShellClient).to receive(:command).with(expected_command)
+        subject
+      end
+
+      context 'with tag' do
+        let(:options) { { tag: 'tag' } }
+
+        it 'runs docker build with tag' do
+          expected_command = 'env DOCKER_HOST=tcp://test.host:4243 docker build -t docker/image:tag .'
+          expect_any_instance_of(ShellClient).to receive(:command).with(expected_command)
+          subject
+        end
+      end
+    end
+
+    describe '#push' do
+      subject { Image.new(config, options).push }
+
+      it 'runs docker push' do
+        expected_command = 'env DOCKER_HOST=tcp://test.host:4243 docker push docker/image'
+        expect_any_instance_of(ShellClient).to receive(:command).with(expected_command)
+        subject
+      end
+
+      context 'with tag' do
+        let(:options) { { tag: 'tag' } }
+
+        it 'runs docker push with tag name' do
+          expected_command = 'env DOCKER_HOST=tcp://test.host:4243 docker push docker/image:tag'
+          expect_any_instance_of(ShellClient).to receive(:command).with(expected_command)
+          subject
+        end
+      end
+    end
+
+    describe '#pull' do
+      subject { Image.new(config, options).pull }
+
+      it 'pulls the image' do
+        expected_command = 'docker pull docker/image'
+        expect_any_instance_of(SSHClient).to receive(:command).with(expected_command)
+        subject
+      end
+
+      context 'with tag' do
+        let(:options) { { tag: 'tag' } }
+
+        it 'runs docker pull with tag name' do
+          expected_command = 'docker pull docker/image:tag'
+          expect_any_instance_of(SSHClient).to receive(:command).with(expected_command)
+          subject
+        end
+      end
+    end
+  end
+end

data/spec/lib/dockerploy/template_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+module Dockerploy
+  describe Template do
+    describe '.application_name' do
+      subject { described_class.application_name }
+      it 'returns application name from current working directory' do
+        expect(Dir).to receive(:getwd).and_return('/home/sunjin')
+        expect(subject).to eq('sunjin')
+      end
+    end
+
+    describe '.project_name' do
+      subject { described_class.project_name }
+
+      it 'returns project name from git repository name' do
+        client = double(output: 'git@github.com:org/project-name.git')
+        expect(ShellClient).to receive(:new).and_return(client)
+        expect(client).to receive(:command).with('git config --get remote.origin.url')
+        expect(subject).to eq('org/project-name')
+      end
+    end
+
+    describe '.generate' do
+      subject { described_class.generate }
+
+      before do
+        allow(Dir).to receive(:getwd).and_return('/home/application-name')
+        client = double(output: 'git@github.com:org/project-name.git')
+        allow(ShellClient).to receive(:new).and_return(client)
+        allow(client).to receive(:command).with('git config --get remote.origin.url')
+        ENV['USER'] = 'sunjin'
+      end
+
+      it 'generates template file' do
+         result = <<-YML
+image_name: org/project-name
+docker_username: sunjin
+docker_host: tcp://:2375
+application_name: application-name
+development:
+  branch: master
+  tagging: true
+  volumes: []
+  servers:
+    - host: 0.0.0.0
+      username: sunjin
+      password:
+      port: 22
+      container:
+        host: 0.0.0.0
+        ssh_port: 22
+        http_port: 80
+YML
+
+        expect(subject).to eq(result.chop)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -2,6 +2,7 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'dockerploy'
 require 'rspec'
+require 'fakefs/spec_helpers'
 
 Dir['#{File.dirname(__FILE__)}/support/**/*.rb'].each { |f| require f }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dockerploy
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Sunjin Lee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-26 00:00:00.000000000 Z
+date: 2015-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -38,6 +38,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +94,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
 description: Deploy dockerized an application
 email:
 - styner32@gmail.com
@@ -97,6 +125,7 @@ files:
 - README.md
 - Rakefile
 - bin/dockerploy
+- c
 - d.sh
 - dockerploy.gemspec
 - lib/dockerploy.rb
@@ -107,14 +136,20 @@ files:
 - lib/dockerploy/image.rb
 - lib/dockerploy/shell_client.rb
 - lib/dockerploy/ssh_client.rb
+- lib/dockerploy/template.rb
+- lib/dockerploy/templates/config.yml.erb
 - lib/dockerploy/version.rb
 - spec/fixtures/config.yml
 - spec/fixtures/config_with_env_file.yml
+- spec/fixtures/config_with_hooks.yml
+- spec/fixtures/config_with_hooks_for_each_env.yml
 - spec/fixtures/config_with_tagging.yml
 - spec/fixtures/config_with_volumes.yml
 - spec/fixtures/test.yml
 - spec/lib/dockerploy/cli_spec.rb
 - spec/lib/dockerploy/deploy_spec.rb
+- spec/lib/dockerploy/image_spec.rb
+- spec/lib/dockerploy/template_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/viki-org/dockerploy
 licenses:
@@ -143,10 +178,14 @@ summary: Deploy dockerized an application
 test_files:
 - spec/fixtures/config.yml
 - spec/fixtures/config_with_env_file.yml
+- spec/fixtures/config_with_hooks.yml
+- spec/fixtures/config_with_hooks_for_each_env.yml
 - spec/fixtures/config_with_tagging.yml
 - spec/fixtures/config_with_volumes.yml
 - spec/fixtures/test.yml
 - spec/lib/dockerploy/cli_spec.rb
 - spec/lib/dockerploy/deploy_spec.rb
+- spec/lib/dockerploy/image_spec.rb
+- spec/lib/dockerploy/template_spec.rb
 - spec/spec_helper.rb
 has_rdoc: