dip 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6a9ad2527f29216fd1a230c2c8acc9032f08cd1eea686f89df433f8c59be50fb
+  data.tar.gz: d84a3f71b392136dd0d275391ec0c58424b91a00e3ae0a1ea93233ec3a718026
+SHA512:
+  metadata.gz: 99e059244669e8aa9a7ab9393aaad1461231667ef66ce0073ad417462bae8996c9819794e8fba8006ea4fabf6296426b006ae5ff485afb0b92aefaafd5719bf2
+  data.tar.gz: 5497a34f27a83e88f91eadca30dbaf3732f38da9b70c5d7bbfbe994ab3b0293156966bb187c3394120ab35a992995d3ea8b7d1e6e4b7d4384b55e141badfd28e

data/LICENSE.txt

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 bibendi
+
+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,206 @@
+# DIP [![Build Status](https://travis-ci.org/bibendi/dip.svg?branch=master)](https://travis-ci.org/bibendi/dip)
+
+Docker Interaction Process
+
+CLI utility for straightforward provisioning and interacting with an application configured by docker-compose.
+
+DIP also contains commands for running support containers such as ssh-agent and DNS server.
+
+## Installation
+
+```sh
+gem install dip
+```
+
+## Changelog
+
+https://github.com/bibendi/dip/releases
+
+
+## Docker installation
+
+- [Ubuntu](docs/docker-ubuntu-install.md)
+- [Mac OS](docs/docker-for-mac-install.md)
+
+## Usage
+
+```sh
+dip --help
+dip SUBCOMMAND --help
+```
+
+### dip.yml
+
+```yml
+version: '2'
+
+environment:
+  COMPOSE_EXT: development
+  RAILS_ENV: development
+
+compose:
+  files:
+    - docker/docker-compose.yml
+    - docker/docker-compose.$COMPOSE_EXT.yml
+    - docker/docker-compose.$DIP_OS.yml
+  project_name: bear-$RAILS_ENV
+
+interaction:
+  sh:
+    service: foo-app
+    compose_run_options: [no-deps]
+
+  bundle:
+    service: foo-app
+    command: bundle
+
+  rake:
+    service: foo-app
+    command: bundle exec rake
+
+  rspec:
+    service: foo-app
+    environment:
+      RAILS_ENV: test
+    command: bundle exec rspec
+
+  rails:
+    service: foo-app
+    command: bundle exec rails
+    subcommands:
+      s:
+        service: foo-web
+        compose_method: up
+
+  psql:
+    service: foo-app
+    command: psql -h pg -U postgres
+
+provision:
+  - dip compose up -d foo-pg foo-redis
+  - dip bundle install
+  - dip rake db:migrate
+```
+
+### dip run
+
+Run commands defined within `interaction` section of dip.yml
+
+```sh
+dip run rails c
+dip run rake db:migrate
+```
+
+`run` argument can be ommited
+
+```sh
+dip rake db:migrate
+dip VERSION=12352452 rake db:rollback
+```
+
+### dip provision
+
+Run commands each by each from `provision` section of dip.yml
+
+### dip compose
+
+Run docker-compose commands that are configured according with application dip.yml
+
+```sh
+dip compose COMMAND [OPTIONS]
+
+dip compose up -d redis
+```
+
+### dip ssh
+
+Runs ssh-agent container based on https://github.com/whilp/ssh-agent with your ~/.ssh/id_rsa.
+It creates a named volume `ssh_data` with ssh socket.
+An application's docker-compose.yml should contains environment variable `SSH_AUTH_SOCK=/ssh/auth/sock` and connects to external volume `ssh_data`.
+
+```sh
+dip ssh up
+```
+
+docker-compose.yml
+
+```yml
+services:
+  web:
+    environment:
+      - SSH_AUTH_SOCK=/ssh/auth/sock
+    volumes:
+      - ssh-data:/ssh:ro
+
+volumes:
+  ssh-data:
+    external:
+      name: ssh_data
+```
+
+### dip nginx
+
+Runs Nginx server container based on [bibendi/nginx-proxy](https://github.com/bibendi/nginx-proxy) image. An application's docker-compose.yml should contains environment variable `VIRTUAL_HOST` and `VIRTUAL_PATH` and connects to external network `frontend`.
+
+foo-project/docker-compose.yml
+
+```yml
+version: '2'
+
+services:
+  foo-web:
+    image: company/foo_image
+    environment:
+      - VIRTUAL_HOST=*.bar-app.docker
+      - VIRTUAL_PATH=/
+    networks:
+      - default
+      - frontend
+    dns: $DIP_DNS
+
+networks:
+  frontend:
+    external:
+      name: frontend
+```
+
+baz-project/docker-compose.yml
+
+```yml
+version: '2'
+
+services:
+  baz-web:
+    image: company/baz_image
+    environment:
+      - VIRTUAL_HOST=*.bar-app.docker
+      - VIRTUAL_PATH=/api/v1/baz_service,/api/v2/baz_service
+    networks:
+      - default
+      - frontend
+    dns: $DIP_DNS
+
+networks:
+  frontend:
+    external:
+      name: frontend
+```
+
+```sh
+dip nginx up
+cd foo-project && dip compose up
+cd baz-project && dip compose up
+curl www.bar-app.docker/api/v1/quz
+curl www.bar-app.docker/api/v1/baz_service/qzz
+```
+
+### dip dns
+
+Runs DNS server container based on https://github.com/aacebedo/dnsdock It used for container to container requests through nginx. An application's docker-compose.yml should define `dns` configuration with environment variable `$DIP_DNS` and connect to external network `frontend`. `$DIP_DNS` will be automatically assigned by dip.
+
+```sh
+dip dns up
+
+cd foo-project
+dip compose exec foo-web curl http://www.bar-app.docker/api/v1/baz_service
+```

data/exe/dip

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+lib_path = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+
+require 'dip'
+require 'dip/cli'
+require 'pry-byebug' if Dip.debug?
+
+Signal.trap('INT') do
+  warn("\n#{caller.join("\n")}: interrupted")
+  exit(1)
+end
+
+begin
+  run_vars = []
+
+  ARGV.each do |arg|
+    if !run_vars.frozen? && arg.include?("=")
+      key, val = arg.split("=", 2)
+      run_vars << "#{'--x-dip-run-vars=' if run_vars.empty?}#{key}:#{val}"
+    else
+      run_vars.freeze
+    end
+  end
+
+  unless run_vars.empty?
+    ARGV.shift(run_vars.size)
+    ARGV.push(*run_vars)
+  end
+
+  Dip::CLI.start
+rescue Dip::Error => err
+  puts "ERROR: #{err.message}"
+  exit 1
+end

data/lib/dip.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "dip/version"
+require "dip/config"
+require "dip/environment"
+
+module Dip
+  Error = Class.new(StandardError)
+
+  class << self
+    def config_path
+      ENV["DIP_FILE"] || "./dip.yml"
+    end
+
+    def config
+      @config ||= Dip::Config.new(config_path)
+    end
+
+    def env
+      @env ||= Dip::Environment.new(config.environment)
+    end
+
+    def test?
+      ENV["DIP_ENV"] == "test"
+    end
+
+    def debug?
+      ENV["DIP_ENV"] == "debug"
+    end
+
+    def reset!
+      @config = nil
+      @env = nil
+    end
+  end
+end

data/lib/dip/cli.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Dip
+  class CLI < Thor
+    class << self
+      def retrieve_command_name(args)
+        meth = args.first.to_sym unless args.empty?
+        args.unshift("run") if meth && ::Dip.config.interaction.key?(meth.to_sym)
+
+        super(args)
+      end
+
+      # Hackery. Take the run method away from Thor so that we can redefine it.
+      def is_thor_reserved_word?(word, type)
+        return false if word == "run"
+
+        super
+      end
+    end
+
+    desc 'version', 'dip version'
+    def version
+      require_relative 'version'
+      puts Dip::VERSION
+    end
+    map %w(--version -v) => :version
+
+    desc 'compose CMD [OPTIONS]', 'Run docker-compose commands'
+    method_option :help, aliases: '-h', type: :boolean,
+                         desc: 'Display usage information'
+    def compose(cmd, *argv)
+      if options[:help]
+        invoke :help, ['compose']
+      else
+        require_relative 'commands/compose'
+        Dip::Commands::Compose.new(cmd, argv).execute
+      end
+    end
+
+    desc 'CMD or dip run CMD [OPTIONS]', 'Run configured command in a docker-compose service'
+    method_option :help, aliases: '-h', type: :boolean,
+                         desc: 'Display usage information'
+    method_option :x_dip_run_vars,
+                  type: :hash,
+                  desc: "Enforce environment variables into container, recommended run like 'dip FOO=bar cmd'"
+    def run(cmd, subcmd = nil, *argv)
+      if options[:help]
+        invoke :help, ['run']
+      else
+        require_relative 'commands/run'
+        Dip::Commands::Run.
+          new(cmd, subcmd, argv,
+              run_vars: options[:x_dip_run_vars]).
+          execute
+      end
+    end
+
+    desc "provision", "Execute commands within provision section"
+    method_option :help, aliases: '-h', type: :boolean,
+                         desc: 'Display usage information'
+    def provision
+      if options[:help]
+        invoke :help, ['provision']
+      else
+        require_relative 'commands/provision'
+        Dip::Commands::Provision.new.execute
+      end
+    end
+
+    desc "ssh", "ssh-agent container commands"
+    def ssh(*args)
+      require_relative 'cli/ssh'
+      Dip::CLI::SSH.start(args)
+    end
+
+    desc "dns", "DNS server for automatic docker container discovery"
+    def dns(*args)
+      require_relative 'cli/dns'
+      Dip::CLI::DNS.start(args)
+    end
+
+    desc "nginx", "Nginx reverse proxy server"
+    def nginx(*args)
+      require_relative 'cli/nginx'
+      Dip::CLI::Nginx.start(args)
+    end
+  end
+end

data/lib/dip/cli/dns.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative "../commands/dns"
+
+module Dip
+  class CLI
+    # See more https://github.com/aacebedo/dnsdock
+    class DNS < Thor
+      desc "dns up", "Run dnsdock container"
+      method_option :help, aliases: '-h', type: :boolean,
+                           desc: 'Display usage information'
+      method_option :name, aliases: '-n', type: :string, default: "dnsdock",
+                           desc: 'Container name'
+      method_option :socket, aliases: '-s', type: :string, default: "/var/run/docker.sock",
+                             desc: 'Path to docker socket'
+      method_option :net, aliases: '-t', type: :string, default: "frontend",
+                          desc: 'Container network name'
+      method_option :publish, aliases: '-p', type: :string, default: "53/udp",
+                              desc: 'Container port'
+      method_option :image, aliases: '-i', type: :string, default: "aacebedo/dnsdock:latest-amd64",
+                            desc: 'Docker image name'
+      method_option :domain, aliases: '-d', type: :string, default: "docker",
+                             desc: 'Top level domain'
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def up
+        if options[:help]
+          invoke :help, ['up']
+        else
+          Dip::Commands::DNS::Up.new(
+            name: options.fetch(:name),
+            socket: options.fetch(:socket),
+            net: options.fetch(:net),
+            publish: options.fetch(:publish),
+            image: options.fetch(:image),
+            domain: options.fetch(:domain)
+          ).execute
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      desc "dns down", "Stop dnsdock container"
+      method_option :help, aliases: '-h', type: :boolean,
+                           desc: 'Display usage information'
+      method_option :name, aliases: '-n', type: :string, default: "dnsdock",
+                           desc: 'Container name'
+      def down
+        if options[:help]
+          invoke :help, ['down']
+        else
+          Dip::Commands::DNS::Down.new(
+            name: options.fetch(:name)
+          ).execute
+        end
+      end
+
+      desc "dns restart", "Stop and start dnsdock container"
+      method_option :help, aliases: '-h', type: :boolean,
+                           desc: 'Display usage information'
+      def restart(*args)
+        if options[:help]
+          invoke :help, ['restart']
+        else
+          Dip::CLI::DNS.start(["down"] + args)
+          sleep 1
+          Dip::CLI::DNS.start(["up"] + args)
+        end
+      end
+
+      desc "dns ip", "Get ip address of dnsdock container"
+      method_option :help, aliases: '-h', type: :boolean,
+                           desc: 'Display usage information'
+      method_option :name, aliases: '-n', type: :string, default: "dnsdock",
+                           desc: 'Container name'
+      method_option :net, aliases: '-t', type: :string, default: "frontend",
+                          desc: 'Container network name'
+      def ip
+        if options[:help]
+          invoke :help, ['status']
+        else
+          Dip::Commands::DNS::IP.new(
+            name: options.fetch(:name),
+            net: options.fetch(:net)
+          ).execute
+        end
+      end
+    end
+  end
+end

data/lib/dip/cli/nginx.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative "../commands/nginx"
+
+module Dip
+  class CLI
+    # See more https://github.com/bibendi/nginx-proxy
+    class Nginx < Thor
+      desc "nginx up", "Run nginx container"
+      method_option :help, aliases: '-h', type: :boolean,
+                           desc: 'Display usage information'
+      method_option :name, aliases: '-n', type: :string, default: "nginx",
+                           desc: 'Container name'
+      method_option :socket, aliases: '-s', type: :string, default: "/var/run/docker.sock",
+                             desc: 'Path to docker socket'
+      method_option :net, aliases: '-t', type: :string, default: "frontend",
+                          desc: 'Container network name'
+      method_option :publish, aliases: '-p', type: :string, default: "80:80",
+                              desc: 'Container port'
+      method_option :image, aliases: '-i', type: :string, default: "bibendi/nginx-proxy:latest",
+                            desc: 'Docker image name'
+      method_option :domain, aliases: '-d', type: :string, default: "docker",
+                             desc: 'Top level domain'
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def up
+        if options[:help]
+          invoke :help, ['up']
+        else
+          Dip::Commands::Nginx::Up.new(
+            name: options.fetch(:name),
+            socket: options.fetch(:socket),
+            net: options.fetch(:net),
+            publish: options.fetch(:publish),
+            image: options.fetch(:image),
+            domain: options.fetch(:domain)
+          ).execute
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      desc "nginx down", "Stop nginx container"
+      method_option :help, aliases: '-h', type: :boolean,
+                           desc: 'Display usage information'
+      method_option :name, aliases: '-n', type: :string, default: "nginx",
+                           desc: 'Container name'
+      def down
+        if options[:help]
+          invoke :help, ['down']
+        else
+          Dip::Commands::Nginx::Down.new(
+            name: options.fetch(:name)
+          ).execute
+        end
+      end
+
+      desc "nginx restart", "Stop and start nginx container"
+      method_option :help, aliases: '-h', type: :boolean,
+                           desc: 'Display usage information'
+      def restart(*args)
+        if options[:help]
+          invoke :help, ['restart']
+        else
+          Dip::CLI::Nginx.start(["down"] + args)
+          sleep 1
+          Dip::CLI::Nginx.start(["up"] + args)
+        end
+      end
+    end
+  end
+end

data/lib/dip/cli/ssh.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative "../commands/ssh"
+
+module Dip
+  class CLI
+    class SSH < Thor
+      desc "ssh up", "Run ssh-agent container"
+      method_option :help, aliases: '-h', type: :boolean,
+                           desc: 'Display usage information'
+      method_option :key, aliases: '-k', type: :string, default: "$HOME/.ssh/id_rsa",
+                          desc: 'Path to ssh key'
+      method_option :volume, aliases: '-v', type: :string, default: "$HOME",
+                             desc: 'Mounted docker volume'
+      method_option :interactive, aliases: '-t', type: :boolean, default: true,
+                                  desc: 'Run in interactive mode'
+      # Backward compatibility
+      method_option :nonteractive, aliases: '-T', type: :boolean,
+                                   desc: 'Run in noninteractive mode'
+      def up
+        if options[:help]
+          invoke :help, ['up']
+        else
+          Dip::Commands::SSH::Up.new(
+            key: options.fetch(:key),
+            volume: options.fetch(:volume),
+            interactive: options.nonteractive? ? false : options.interactive?
+          ).execute
+        end
+      end
+
+      map add: :up
+
+      desc "ssh down", "Stop ssh-agent container"
+      method_option :help, aliases: '-h', type: :boolean,
+                           desc: 'Display usage information'
+      def down
+        if options[:help]
+          invoke :help, ['down']
+        else
+          Dip::Commands::SSH::Down.new.execute
+        end
+      end
+
+      desc "ssh restart", "Stop and start ssh-agent container"
+      method_option :help, aliases: '-h', type: :boolean,
+                           desc: 'Display usage information'
+      def restart(*args)
+        if options[:help]
+          invoke :help, ['restart']
+        else
+          Dip::CLI::SSH.start(["down"] + args)
+          sleep 1
+          Dip::CLI::SSH.start(["up"] + args)
+        end
+      end
+
+      desc "ssh status", "Show status of ssh-agent container"
+      method_option :help, aliases: '-h', type: :boolean,
+                           desc: 'Display usage information'
+      def status
+        if options[:help]
+          invoke :help, ['status']
+        else
+          Dip::Commands::SSH::Status.new.execute
+        end
+      end
+    end
+  end
+end

data/lib/dip/command.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Dip
+  class Command
+    extend Forwardable
+
+    def_delegators self, :shell, :subshell
+
+    class ExecRunner
+      def self.call(cmd, argv, env: {}, **options)
+        ::Process.exec(env, cmd, *argv, options)
+      end
+    end
+
+    class SubshellRunner
+      def self.call(cmd, argv, env: {}, panic: true, **options)
+        return if ::Kernel.system(env, cmd, *argv, options)
+        raise Dip::Error, "Command '#{([cmd] + argv).join(' ')}' executed with error." if panic
+      end
+    end
+
+    class << self
+      def shell(cmd, argv = [], subshell: false, **options)
+        cmd = Dip.env.interpolate(cmd)
+        argv = argv.map { |arg| Dip.env.interpolate(arg) }
+
+        puts [Dip.env.vars, cmd, argv].inspect if Dip.debug?
+
+        runner = subshell ? SubshellRunner : ExecRunner
+        runner.call(cmd, argv, env: Dip.env.vars, **options)
+      end
+
+      def subshell(*args, **kwargs)
+        kwargs[:subshell] = true
+        shell(*args, **kwargs)
+      end
+    end
+  end
+end

data/lib/dip/commands/compose.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative '../command'
+require_relative 'dns'
+
+module Dip
+  module Commands
+    class Compose < Dip::Command
+      DOCKER_EMBEDDED_DNS = "127.0.0.11"
+
+      def initialize(cmd, argv = [])
+        @cmd = cmd
+        @argv = argv
+        @config = ::Dip.config.compose
+      end
+
+      def execute
+        compose_argv = Array(find_files) + Array(find_project_name)
+        compose_argv << @cmd
+        compose_argv += @argv
+
+        Dip.env["DIP_DNS"] ||= find_dns
+
+        shell("docker-compose", compose_argv)
+      end
+
+      private
+
+      def find_files
+        return unless (files = @config[:files])
+
+        if files.is_a?(Array)
+          files.each_with_object([]) do |file_name, memo|
+            file_name = ::Dip.env.interpolate(file_name)
+            next unless File.exist?(file_name)
+
+            memo << "--file"
+            memo << file_name
+          end
+        end
+      end
+
+      def find_project_name
+        return unless (project_name = @config[:project_name])
+
+        if project_name.is_a?(String)
+          project_name = ::Dip.env.interpolate(project_name)
+          ["--project-name", project_name]
+        end
+      end
+
+      def find_dns
+        name = Dip.env["DNSDOCK_CONTAINER"] || "dnsdock"
+        net = Dip.env["FRONTEND_NETWORK"] || "frontend"
+
+        IO.pipe do |r, w|
+          Dip::Commands::DNS::IP.
+            new(name: name, net: net).
+            execute(out: w, err: File::NULL, panic: false)
+
+          w.close_write
+          ip = r.readlines[0].to_s.strip
+          ip.empty? ? DOCKER_EMBEDDED_DNS : ip
+        end
+      end
+    end
+  end
+end

data/lib/dip/commands/dns.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require_relative '../command'
+
+module Dip
+  module Commands
+    module DNS
+      class Up < Dip::Command
+        def initialize(name:, socket:, net:, publish:, image:, domain:)
+          @name = name
+          @socket = socket
+          @net = net
+          @publish = publish
+          @image = image
+          @domain = domain
+        end
+
+        def execute
+          subshell("docker", "network create #{@net}".shellsplit, panic: false, err: File::NULL)
+          subshell("docker", "run #{container_args} #{@image} --domain=#{@domain}".shellsplit)
+        end
+
+        private
+
+        def container_args
+          result = %w(--detach)
+          result << "--volume #{@socket}:/var/run/docker.sock:ro"
+          result << "--restart always"
+          result << "--publish #{@publish}"
+          result << "--net #{@net}"
+          result << "--name #{@name}"
+          result.join(' ')
+        end
+      end
+
+      class Down < Dip::Command
+        def initialize(name:)
+          @name = name
+        end
+
+        def execute
+          subshell("docker", "stop #{@name}".shellsplit, panic: false, out: File::NULL, err: File::NULL)
+          subshell("docker", "rm -v #{@name}".shellsplit, panic: false, out: File::NULL, err: File::NULL)
+        end
+      end
+
+      class IP < Dip::Command
+        def initialize(name:, net:)
+          @name = name
+          @net = net
+        end
+
+        def execute(**options)
+          subshell("docker",
+                   "inspect " \
+                   "--format '{{ .NetworkSettings.Networks.#{@net}.IPAddress }}' " \
+                   "#{@name}".shellsplit,
+                   **options)
+        end
+      end
+    end
+  end
+end

data/lib/dip/commands/nginx.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require_relative '../command'
+
+module Dip
+  module Commands
+    module Nginx
+      class Up < Dip::Command
+        def initialize(name:, socket:, net:, publish:, image:, domain:)
+          @name = name
+          @socket = socket
+          @net = net
+          @publish = publish
+          @image = image
+          @domain = domain
+        end
+
+        def execute
+          subshell("docker", "network create #{@net}".shellsplit, panic: false, err: File::NULL)
+          subshell("docker", "run #{container_args} #{@image}".shellsplit)
+        end
+
+        private
+
+        def container_args
+          result = %w(--detach)
+          result << "--volume #{@socket}:/tmp/docker.sock:ro"
+          result << "--restart always"
+          result << "--publish #{@publish}"
+          result << "--net #{@net}"
+          result << "--name #{@name}"
+          result << "--label com.dnsdock.alias=#{@domain}"
+          result.join(' ')
+        end
+      end
+
+      class Down < Dip::Command
+        def initialize(name:)
+          @name = name
+        end
+
+        def execute
+          subshell("docker", "stop #{@name}".shellsplit, panic: false, out: File::NULL, err: File::NULL)
+          subshell("docker", "rm -v #{@name}".shellsplit, panic: false, out: File::NULL, err: File::NULL)
+        end
+      end
+    end
+  end
+end

data/lib/dip/commands/provision.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative '../command'
+
+module Dip
+  module Commands
+    class Provision < Dip::Command
+      def execute
+        Dip.config.provision.each do |command|
+          subshell(command)
+        end
+      end
+    end
+  end
+end

data/lib/dip/commands/run.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+require_relative '../command'
+require_relative 'compose'
+
+module Dip
+  module Commands
+    class Run < Dip::Command
+      def initialize(cmd, subcmd = nil, argv = [], run_vars: nil)
+        @cmd = cmd.to_sym
+        @subcmd = subcmd.to_sym if subcmd
+        @argv = argv
+        @run_vars = run_vars
+        @config = ::Dip.config.interaction
+      end
+
+      # TODO: Refactor
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def execute
+        command = @config.fetch(@cmd)
+        command[:subcommands] ||= {}
+
+        if (subcommand = command[:subcommands].fetch(@subcmd, {})).any?
+          subcommand[:command] ||= nil
+          command.merge!(subcommand)
+        elsif @subcmd
+          @argv.unshift(@subcmd.to_s)
+        end
+
+        Dip.env.merge(command[:environment]) if command[:environment]
+
+        compose_method = command.fetch(:compose_method, "run").to_s
+
+        compose_argv = []
+        compose_argv.concat(prepare_compose_run_options(command[:compose_run_options]))
+        compose_argv.concat(run_vars)
+        compose_argv << "--rm" if compose_method == "run"
+        compose_argv << command.fetch(:service).to_s
+        compose_argv += command[:command].to_s.shellsplit
+        compose_argv.concat(@argv)
+
+        Dip::Commands::Compose.new(compose_method, compose_argv).execute
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def prepare_compose_run_options(value)
+        return [] unless value
+
+        value.map do |o|
+          o = o.start_with?("-") ? o : "--#{o}"
+          o.shellsplit
+        end.flatten
+      end
+
+      def run_vars
+        return [] unless @run_vars
+
+        @run_vars.map { |k, v| ["-e", "#{k}=#{v}"] }.flatten
+      end
+    end
+  end
+end

data/lib/dip/commands/ssh.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require_relative '../command'
+
+module Dip
+  module Commands
+    module SSH
+      class Up < Dip::Command
+        def initialize(key:, volume:, interactive:)
+          @key = key
+          @volume = volume
+          @interactive = interactive
+        end
+
+        def execute
+          subshell("docker", "volume create --name ssh_data".shellsplit, out: File::NULL, err: File::NULL)
+
+          subshell("docker", "run --detach --volume ssh_data:/ssh --name=ssh-agent whilp/ssh-agent".shellsplit)
+
+          key = Dip.env.interpolate(@key)
+          subshell("docker", "run #{container_args} whilp/ssh-agent ssh-add #{key}".shellsplit)
+        end
+
+        private
+
+        def container_args
+          result = %w(--rm)
+          volume = Dip.env.interpolate(@volume)
+          result << "--volume ssh_data:/ssh"
+          result << "--volume #{volume}:#{volume}"
+          result << "--interactive --tty" if @interactive
+          result.join(' ')
+        end
+      end
+
+      class Down < Dip::Command
+        def execute
+          subshell("docker", "stop ssh-agent".shellsplit, panic: false, out: File::NULL, err: File::NULL)
+          subshell("docker", "rm -v ssh-agent".shellsplit, panic: false, out: File::NULL, err: File::NULL)
+          subshell("docker", "volume rm ssh_data".shellsplit, panic: false, out: File::NULL, err: File::NULL)
+        end
+      end
+
+      class Status < Dip::Command
+        def execute
+          subshell("docker", "inspect --format '{{.State.Status}}' ssh-agent".shellsplit)
+        end
+      end
+    end
+  end
+end

data/lib/dip/config.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "erb"
+
+module Dip
+  class Config
+    def initialize(config_path)
+      load_or_default(config_path)
+    end
+
+    def merge(config)
+      @config.merge!(config)
+    end
+
+    def environment
+      @config.fetch(:environment, {})
+    end
+
+    def compose
+      @config.fetch(:compose, {})
+    end
+
+    def interaction
+      @config.fetch(:interaction, {})
+    end
+
+    def provision
+      @config.fetch(:provision, [])
+    end
+
+    private
+
+    def load_or_default(config_path)
+      @config ||= if File.exist?(config_path) && !Dip.test?
+                    YAML.safe_load(
+                      ERB.new(File.read(config_path)).result,
+                      [], [], true,
+                      symbolize_names: true
+                    )
+                  else
+                    {}
+                  end
+    end
+  end
+end

data/lib/dip/environment.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Dip
+  class Environment
+    VAR_REGEX = /\$[\{]?(?<var_name>[a-zA-Z_][a-zA-Z0-9_]*)[\}]?/
+    SPECIAL_VARS = {"DIP_OS" => :find_dip_os}.freeze
+
+    attr_reader :vars
+
+    def initialize(default_vars)
+      @vars = {}
+
+      merge(default_vars)
+    end
+
+    def merge(new_vars)
+      new_vars.each do |key, value|
+        key = key.to_s
+        @vars[key] = ENV.fetch(key) { interpolate(value.to_s) }
+      end
+    end
+
+    def [](name)
+      vars.fetch(name) { ENV[name] }
+    end
+
+    def []=(key, value)
+      @vars[key] = value
+    end
+
+    def interpolate(value)
+      value.gsub(VAR_REGEX) do
+        var_name = Regexp.last_match[:var_name]
+
+        if SPECIAL_VARS.key?(var_name)
+          self[var_name] || send(SPECIAL_VARS[var_name])
+        else
+          self[var_name]
+        end
+      end
+    end
+
+    alias replace interpolate
+
+    private
+
+    def find_dip_os
+      @dip_os ||= Gem::Platform.local.os
+    end
+  end
+end

data/lib/dip/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Dip
+  VERSION = "3.0.0"
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: dip
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: ruby
+authors:
+- bibendi
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-09-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.20.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.20.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.59'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.59'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: DIP - Docker Interaction Process.CLI tool for better development experience
+  when interacting with docker and docker-compose.
+email:
+- merkushin.m.s@gmail.com
+executables:
+- dip
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- exe/dip
+- lib/dip.rb
+- lib/dip/cli.rb
+- lib/dip/cli/dns.rb
+- lib/dip/cli/nginx.rb
+- lib/dip/cli/ssh.rb
+- lib/dip/command.rb
+- lib/dip/commands/compose.rb
+- lib/dip/commands/dns.rb
+- lib/dip/commands/nginx.rb
+- lib/dip/commands/provision.rb
+- lib/dip/commands/run.rb
+- lib/dip/commands/ssh.rb
+- lib/dip/config.rb
+- lib/dip/environment.rb
+- lib/dip/version.rb
+homepage: https://github.com/bibendi/dip
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org/
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Ruby gem CLI tool for better interacting docker-compose files.
+test_files: []