dip 7.8.0 → 8.0.0.rc

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88f631de08ccd575c2e65930de249fbbba598e0948e8335fd9bbb4adf8a455c8
-  data.tar.gz: 0d906d4a243285684469524e85a8d494f12a13de58065e1ecf8eaccc6ef85903
+  metadata.gz: 62ac96c33784899b925107b213950d7304f29edcf5d3d5d7787c061a63fd8502
+  data.tar.gz: c2d7dff0d4d8bc168e8afa55ff76e20aabda37cde9308abedfcc8de0494579d8
 SHA512:
-  metadata.gz: 51aa9e654715ee7836b9d143760dc028e9f06f811e0804decffc48fffcef4816e78c1f302f2d9af3462faad53a53efa755112804e116278372f447192572a06b
-  data.tar.gz: 12521190b37c170b54abaa319c3ad877999c9471f3936a7d732b2bbaeb776b922c28a8ab7d2ccc13322f73294419156f1d6156ccc35c2e1ac5709ac55d0bc8f2
+  metadata.gz: 45b7eb4d3220ce5ce109c45a3a84e5248d7a8b9aead0542c6543f005298fa31eeb93a741c9beef19b9f098b9693257fd91c6c32c910cfe1a8317503124f251cc
+  data.tar.gz: 0160da43d5ed98e5cae351050926fc87941317dfb55854b8e7a9f97c6f79d50e06b5a9e1db72ae41a43f65cbdf0cc0272df14ef1b10adb27024cba4b8b2e076c

data/README.md

@@ -14,7 +14,7 @@ Development-environment CLI program providing the native-like interaction with a
 ## Presentations and examples
 
 - [Local development with Docker containers](https://slides.com/bibendi/dip)
-- Dockerized Ruby on Rails applications: [one](https://github.com/lewagon/rails-k8s-demo), [two](https://github.com/bibendi/dip-example-rails), [three](https://github.com/evilmartians/evil_chat)
+- [Dockerized Ruby on Rails application](https://SberMarket-Tech/outbox-example-apps)
 - Dockerized Node.js application: [one](https://github.com/bibendi/twinkle.js), [two](https://github.com/bibendi/yt-graphql-react-event-booking-api)
 - [Dockerized Ruby gem](https://github.com/bibendi/schked)
 - [Dockerizing Ruby and Rails development](https://evilmartians.com/chronicles/ruby-on-whales-docker-for-ruby-rails-development)
@@ -22,7 +22,13 @@ Development-environment CLI program providing the native-like interaction with a
 
 [![asciicast](https://asciinema.org/a/210236.svg)](https://asciinema.org/a/210236)
 
-## Integration with shell
+## Installation
+
+```sh
+gem install dip
+```
+
+### Integration with shell
 
 Dip can be injected into the current shell (ZSH or Bash).
 
@@ -53,14 +59,6 @@ VERSION=20180515103400 rails db:migrate:down
 You could add this `eval` at the end of your `~/.zshrc`, or `~/.bashrc`, or `~/.bash_profile`.
 After that, it will be automatically applied when you open your preferred terminal.
 
-## Installation
-
-```sh
-gem install dip
-```
-
-The compiled binary is no more provided since version 7, because of new version of [Ruby Packer](https://github.com/pmq20/ruby-packer) not released for a long time with recent Ruby version. Also there was a lot of work to prepare each release of Dip for MacOS version.
-
 ## Usage
 
 ```sh
@@ -242,19 +240,16 @@ services:
 
 The container will run using the same user ID as your host machine.
 
-
 ### dip run
 
 Run commands defined within the `interaction` section of dip.yml
 
 A command will be executed by specified runner. Dip has three types of them:
 
-- `docker-compose` runner — used when the `service` option is defined.
+- `docker compose` runner — used when the `service` option is defined.
 - `kubectl` runner — used when the `pod` option is defined.
 - `local` runner — used when the previous ones are not defined.
 
-If you are still using `docker-compose` binary (i.e., prior to Compose V2 changes), a command would be run through it. You can disable using of Compose V2 by passing an environment variable `DIP_COMPOSE_V2=false dip run`.
-
 ```sh
 dip run rails c
 dip run rake db:migrate
@@ -306,7 +301,7 @@ Run commands each by each from `provision` section of dip.yml
 
 ### dip compose
 
-Run docker-compose commands that are configured according to the application's dip.yml:
+Run Docker Compose commands that are configured according to the application's dip.yml:
 
 ```sh
 dip compose COMMAND [OPTIONS]
@@ -314,6 +309,35 @@ dip compose COMMAND [OPTIONS]
 dip compose up -d redis
 ```
 
+### dip infra
+
+Runs shared Docker Compose services that are used by the current application. Useful for microservices.
+
+There are several official infrastructure services available:
+- [dip-postgres](https://github.com/bibendi/dip-postgres)
+- [dip-kafka](https://github.com/bibendi/dip-kafka)
+- [dip-nginx](https://github.com/bibendi/dip-nginx)
+
+```yaml
+# dip.yml
+infra:
+  foo:
+    git: https://github.com/owner/foo.git
+    ref: latest # default, optional
+  bar:
+    path: ~/path/to/bar
+```
+
+Repositories will be pulled to a `~/.dip/infra` folder. For example, for the `foo` service it would be like this: `~/.dip/infra/foo/latest` and clonned with the following command: `git clone -b <ref> --single-branch <git> --depth 1`.
+
+Available CLI commands:
+
+- `dip infra update` pulls updates from sources
+- `dip infra up` starts all infra services
+- `dip infra up -n kafka` starts a specific infra service
+- `dip infra down` stops all infra services
+- `dip infra down -n kafka` stops a specific infra service
+
 ### dip ktl
 
 Run kubectl commands that are configured according to the application's dip.yml:
@@ -358,88 +382,10 @@ dip ssh up -u 1000
 
 This especially helpful if you have something like this in your docker-compose.yml:
 
-```
+```yml
 services:
   web:
     user: "1000:1000"
-
-```
-
-### dip nginx
-
-Runs Nginx server container based on [nginxproxy/nginx-proxy](https://github.com/nginx-proxy/nginx-proxy) image. An application's docker-compose.yml should contain environment variable `VIRTUAL_HOST` and `VIRTUAL_PATH` and connects to external network `frontend`.
-
-foo-project/docker-compose.yml
-
-```yml
-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
-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
-```
-
-#### Pass SSL certificates
-
-```sh
-dip nginx up -c $HOME/ssl_certificates
-```
-
-#### Publish more than one port to localhost
-
-Just pass a list, separated by a space:
-
-```sh
-dip nginx up -p 80:80 443:443
-```
-
-### dip dns
-
-Runs a DNS server container based on https://github.com/aacebedo/dnsdock. It is 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
 ```
 
 ## Changelog

data/lib/dip/cli/infra.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "base"
+require_relative "../commands/infra"
+require_relative "../commands/infra/service"
+
+module Dip
+  class CLI
+    class Infra < Base
+      desc "update", "Pull infra services updates"
+      method_option :help, aliases: "-h", type: :boolean,
+        desc: "Display usage information"
+      method_option :name, aliases: "-n", type: :array, default: [],
+        desc: "Update infra service, all if empty"
+      def update
+        if options[:help]
+          invoke :help, ["update"]
+        else
+          lookup_services(options[:name]).each do |service|
+            Commands::Infra::Update.new(service: service).execute
+          end
+        end
+      end
+
+      desc "up", "Run infra services"
+      method_option :help, aliases: "-h", type: :boolean,
+        desc: "Display usage information"
+      method_option :name, aliases: "-n", type: :array, default: [],
+        desc: "Start specific infra service, all if empty"
+      method_option :update, type: :boolean, default: true,
+        desc: "Pull infra services updates"
+      def up(*compose_argv)
+        if options[:help]
+          invoke :help, ["up"]
+        else
+          lookup_services(options[:name]).each do |service|
+            if options[:update]
+              Commands::Infra::Update.new(service: service).execute
+            end
+
+            Commands::Infra::Up.new(*compose_argv, service: service).execute
+          end
+        end
+      end
+
+      desc "down", "Stop infra services"
+      method_option :help, aliases: "-h", type: :boolean,
+        desc: "Display usage information"
+      method_option :name, aliases: "-n", type: :array, default: [],
+        desc: "Stop specific infra service, all if empty"
+      def down(*compose_argv)
+        if options[:help]
+          invoke :help, ["down"]
+        else
+          lookup_services(options[:name]).each do |service|
+            Commands::Infra::Down.new(*compose_argv, service: service).execute
+          end
+        end
+      end
+
+      private
+
+      def lookup_services(names)
+        names = Array(names).map(&:to_sym)
+
+        Dip.config.infra.each_with_object([]) do |(name, params), memo|
+          next if !names.empty? && !names.include?(name)
+          memo << Commands::Infra::Service.new(name, **params)
+        end
+      end
+    end
+  end
+end

data/lib/dip/cli.rb

@@ -5,7 +5,7 @@ require "dip/run_vars"
 
 module Dip
   class CLI < Thor
-    TOP_LEVEL_COMMANDS = %w[help version ls compose up stop down run provision ssh dns nginx console].freeze
+    TOP_LEVEL_COMMANDS = %w[help version ls compose up stop down run provision ssh infra console].freeze
 
     class << self
       # Hackery. Take the run method away from Thor so that we can redefine it.
@@ -47,30 +47,30 @@ module Dip
       Dip::Commands::List.new.execute
     end
 
-    desc "compose CMD [OPTIONS]", "Run docker-compose commands"
+    desc "compose CMD [OPTIONS]", "Run Docker Compose commands"
     def compose(*argv)
       require_relative "commands/compose"
       Dip::Commands::Compose.new(*argv).execute
     end
 
-    desc "build [OPTIONS] SERVICE", "Run `docker-compose build` command"
+    desc "build [OPTIONS] SERVICE", "Run `docker compose build` command"
     def build(*argv)
       compose("build", *argv)
     end
 
-    desc "up [OPTIONS] SERVICE", "Run `docker-compose up` command"
+    desc "up [OPTIONS] SERVICE", "Run `docker compose up` command"
     def up(*argv)
       compose("up", *argv)
     end
 
-    desc "stop [OPTIONS] SERVICE", "Run `docker-compose stop` command"
+    desc "stop [OPTIONS] SERVICE", "Run `docker compose stop` command"
     def stop(*argv)
       compose("stop", *argv)
     end
 
-    desc "down [OPTIONS]", "Run `docker-compose down` command"
+    desc "down [OPTIONS]", "Run `docker compose down` command"
     method_option :help, aliases: "-h", type: :boolean, desc: "Display usage information"
-    method_option :all, aliases: "-A", type: :boolean, desc: "Shutdown all running docker-compose projects"
+    method_option :all, aliases: "-A", type: :boolean, desc: "Shutdown all running Docker Compose projects"
     def down(*argv)
       if options[:help]
         invoke :help, ["down"]
@@ -121,13 +121,9 @@ module Dip
     desc "ssh", "ssh-agent container commands"
     subcommand :ssh, Dip::CLI::SSH
 
-    require_relative "cli/dns"
-    desc "dns", "DNS server for automatic docker container discovery"
-    subcommand :dns, Dip::CLI::DNS
-
-    require_relative "cli/nginx"
-    desc "nginx", "Nginx reverse proxy server"
-    subcommand :nginx, Dip::CLI::Nginx
+    require_relative "cli/infra"
+    desc "infra", "Infrastructure services"
+    subcommand :infra, Dip::CLI::Infra
 
     require_relative "cli/console"
     desc "console", "Integrate Dip commands into shell (only ZSH and Bash are supported)"

data/lib/dip/commands/compose.rb

@@ -21,15 +21,15 @@ module Dip
       def execute
         Dip.env["DIP_DNS"] ||= find_dns
 
+        set_infra_env
+
         compose_argv = Array(find_files) + Array(cli_options) + argv
 
         if (override_command = compose_command_override)
           override_command, *override_args = override_command.split(" ")
           exec_program(override_command, override_args.concat(compose_argv), shell: shell)
-        elsif compose_v2?
-          exec_program("docker", compose_argv.unshift("compose"), shell: shell)
         else
-          exec_program("docker-compose", compose_argv, shell: shell)
+          exec_program("docker", compose_argv.unshift("compose"), shell: shell)
         end
       end
 
@@ -76,17 +76,16 @@ module Dip
         end
       end
 
-      def compose_v2?
-        if %w[false no 0].include?(Dip.env["DIP_COMPOSE_V2"]) || Dip.test?
-          return false
-        end
-
-        !!exec_subprocess("docker", "compose version", panic: false, out: File::NULL, err: File::NULL)
-      end
-
       def compose_command_override
         Dip.env["DIP_COMPOSE_COMMAND"] || config[:command]
       end
+
+      def set_infra_env
+        Dip.config.infra.each do |name, params|
+          service = Commands::Infra::Service.new(name, **params)
+          Dip.env[service.network_env_var] = service.network_name
+        end
+      end
     end
   end
 end

data/lib/dip/commands/infra/service.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Dip
+  module Commands
+    module Infra
+      class Service
+        attr_reader :name, :git, :ref, :location, :project_name, :network_name, :network_env_var
+
+        def initialize(name, git: nil, ref: nil, path: nil)
+          if git.nil? && path.nil?
+            raise ArgumentError, "Infra service `#{name}` configuration error: git or path must be defined"
+          end
+
+          @name = name
+          @git = git
+          @ref = ref || "latest"
+          @location = if git
+            "#{Dip.home_path}/infra/#{@name}/#{@ref}"
+          else
+            File.expand_path(path)
+          end
+          @project_name = "dip-infra-#{name}-#{@ref}"
+          @network_name = "dip-net-#{name}-#{@ref}"
+          @network_env_var = "DIP_INFRA_NETWORK_#{@name.to_s.upcase.tr("-", "_")}"
+        end
+
+        def env
+          {
+            "COMPOSE_PROJECT_NAME" => project_name,
+            "DIP_INFRA_NETWORK_NAME" => network_name
+          }
+        end
+      end
+    end
+  end
+end

data/lib/dip/commands/infra.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "fileutils"
+require_relative "../command"
+
+module Dip
+  module Commands
+    module Infra
+      class Update < Dip::Command
+        def initialize(service:)
+          @service = service
+        end
+
+        def execute
+          return unless @service.git
+
+          if Dir.exist?(@service.location)
+            pull
+          else
+            clone
+          end
+        end
+
+        private
+
+        def pull
+          Dir.chdir(@service.location) do
+            exec_subprocess("git", "checkout .")
+            exec_subprocess("git", "pull --rebase")
+          end
+        end
+
+        def clone
+          FileUtils.mkdir_p(@service.location)
+
+          Dir.chdir(@service.location) do
+            args = [
+              "clone",
+              "--single-branch",
+              "--depth 1",
+              "--branch #{Shellwords.escape(@service.ref)}",
+              Shellwords.escape(@service.git),
+              Shellwords.escape(@service.location)
+            ]
+            exec_subprocess("git", args)
+          end
+        end
+      end
+
+      class Up < Dip::Command
+        def initialize(*compose_argv, service:)
+          @compose_argv = compose_argv.compact
+          @service = service
+        end
+
+        def execute
+          Dir.chdir(@service.location) do
+            exec_subprocess("docker", "network create #{@service.network_name}", panic: false, err: File::NULL)
+
+            argv = %w[compose up --detach] + @compose_argv
+            exec_subprocess("docker", argv, env: @service.env)
+          end
+        end
+      end
+
+      class Down < Dip::Command
+        def initialize(*compose_argv, service:)
+          @compose_argv = compose_argv.compact
+          @service = service
+        end
+
+        def execute
+          Dir.chdir(@service.location) do
+            argv = %w[compose down] + @compose_argv
+            exec_subprocess("docker", argv, env: @service.env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dip/commands/runners/docker_compose_runner.rb

@@ -71,7 +71,7 @@ module Dip
 
         def update_command_for_profiles
           # NOTE: When using profiles, the method is always `up`.
-          #       This is because `docker-compose` does not support profiles
+          #       This is because `docker compose` does not support profiles
           #       for other commands. Also, run options need to be removed
           #       because they are not supported by `up`.
           command[:compose][:method] = "up"

data/lib/dip/config.rb

@@ -17,10 +17,13 @@ module Dip
       environment: {},
       compose: {},
       kubectl: {},
+      infra: {},
       interaction: {},
       provision: []
     }.freeze
 
+    TOP_LEVEL_KEYS = %i[environment compose kubectl infra interaction provision].freeze
+
     ConfigKeyMissingError = Class.new(ArgumentError)
 
     class ConfigFinder
@@ -95,7 +98,7 @@ module Dip
       config
     end
 
-    %i[environment compose kubectl interaction provision].each do |key|
+    TOP_LEVEL_KEYS.each do |key|
       define_method(key) do
         config[key] || (raise config_missing_error(key))
       end

data/lib/dip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dip
-  VERSION = "7.8.0"
+  VERSION = "8.0.0.rc"
 end

data/lib/dip.rb

@@ -18,6 +18,10 @@ module Dip
       $PROGRAM_NAME.start_with?("./") ? File.expand_path($PROGRAM_NAME) : "dip"
     end
 
+    def home_path
+      @home_path ||= File.expand_path(ENV.fetch("DIP_HOME", "~/.dip"))
+    end
+
     %w[test debug].each do |key|
       define_method("#{key}?") do
         ENV["DIP_ENV"] == key

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dip
 version: !ruby/object:Gem::Version
-  version: 7.8.0
+  version: 8.0.0.rc
 platform: ruby
 authors:
 - bibendi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-28 00:00:00.000000000 Z
+date: 2024-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -156,8 +156,22 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: DIP - Docker Interaction Process.CLI tool for better development experience
-  when interacting with docker and docker-compose.
+  when interacting with docker and Docker Compose.
 email:
 - merkushin.m.s@gmail.com
 executables:
@@ -173,16 +187,17 @@ files:
 - lib/dip/cli/base.rb
 - lib/dip/cli/console.rb
 - lib/dip/cli/dns.rb
-- lib/dip/cli/nginx.rb
+- lib/dip/cli/infra.rb
 - lib/dip/cli/ssh.rb
 - lib/dip/command.rb
 - lib/dip/commands/compose.rb
 - lib/dip/commands/console.rb
 - lib/dip/commands/dns.rb
 - lib/dip/commands/down_all.rb
+- lib/dip/commands/infra.rb
+- lib/dip/commands/infra/service.rb
 - lib/dip/commands/kubectl.rb
 - lib/dip/commands/list.rb
-- lib/dip/commands/nginx.rb
 - lib/dip/commands/provision.rb
 - lib/dip/commands/run.rb
 - lib/dip/commands/runners/base.rb
@@ -213,12 +228,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
-summary: Ruby gem CLI tool for better interacting docker-compose files.
+summary: Ruby gem CLI tool for better interacting Docker Compose files.
 test_files: []

data/lib/dip/cli/nginx.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require "thor"
-require_relative "base"
-require_relative "../commands/nginx"
-
-module Dip
-  class CLI
-    # See more https://github.com/nginx-proxy/nginx-proxy
-    class Nginx < Base
-      desc "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: :array, default: ["80:80"],
-        desc: "Container port(s). For more than one port, separate them by a space"
-      method_option :image, aliases: "-i", type: :string, default: "nginxproxy/nginx-proxy:latest",
-        desc: "Docker image name"
-      method_option :domain, aliases: "-d", type: :string, default: "docker",
-        desc: "Top level domain"
-      method_option :certs, aliases: "-c", type: :string, desc: "Path to ssl certificates"
-      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),
-            certs: options[:certs]
-          ).execute
-        end
-      end
-
-      desc "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 "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/commands/nginx.rb

@@ -1,52 +0,0 @@
-# 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:, certs:)
-          @name = name
-          @socket = socket
-          @net = net
-          @publish = publish
-          @image = image
-          @domain = domain
-          @certs = certs
-        end
-
-        def execute
-          exec_subprocess("docker", "network create #{@net}", panic: false, err: File::NULL)
-          exec_subprocess("docker", "run #{container_args} #{@image}")
-        end
-
-        private
-
-        def container_args
-          result = %w[--detach]
-          result << "--volume #{@socket}:/tmp/docker.sock:ro"
-          result << "--volume #{@certs}:/etc/nginx/certs" unless @certs.to_s.empty?
-          result << "--restart always"
-          result << Array(@publish).map { |p| "--publish #{p}" }.join(" ")
-          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
-          exec_subprocess("docker", "stop #{@name}", panic: false, out: File::NULL, err: File::NULL)
-          exec_subprocess("docker", "rm -v #{@name}", panic: false, out: File::NULL, err: File::NULL)
-        end
-      end
-    end
-  end
-end