indocker 0.0.6 → 0.1.4

data/example/indocker/bin/utils/configurations.rb

@@ -0,0 +1,3 @@
+def list_configurations(configurations_dir)
+  Dir[File.join(configurations_dir, '**/*.rb')].map {|c| c.split('/').last.gsub('.rb', '')}
+end

data/example/indocker/bounded_contexts/shared/ruby/Dockerfile

@@ -0,0 +1,10 @@
+FROM ruby:2.5.0
+
+RUN dpkg --add-architecture i386 \
+  && apt-get update \
+  && apt-get install vim curl -y \
+  && apt-get clean \
+  && rm -rf /var/lib/apt/lists/*
+
+RUN mkdir /app
+WORKDIR /app

data/example/indocker/bounded_contexts/shared/ruby/container.rb

@@ -0,0 +1,5 @@
+Indocker
+  .define_container(:ruby)
+  .tags('ruby', 'console=true')
+  .image(:ruby)
+  .networks(:app_net)

data/example/indocker/bounded_contexts/shared/ruby/image.rb

@@ -0,0 +1,3 @@
+Indocker
+  .define_image(:ruby)
+  .registry(:default)

data/example/indocker/configurations/dev.rb

@@ -0,0 +1,9 @@
+Indocker
+  .build_configuration(:dev)
+  .use_registry(:dev, as: :default)
+  .use_build_server(:local_bs)
+  .enabled_containers(
+    ruby: {
+      servers: [:localhost],
+    }
+  )

data/example/indocker/infrastructure/build_servers.rb

@@ -0,0 +1,8 @@
+Indocker.add_build_server(
+  Indocker::BuildServer.new(
+    name: :local_bs,
+    host: 'localhost',
+    user: `whoami`.strip,
+    port: 22
+  )
+)

data/example/indocker/infrastructure/networks.rb

@@ -0,0 +1 @@
+Indocker.define_network(:app_net)

data/example/indocker/infrastructure/registries.rb

@@ -0,0 +1,3 @@
+Indocker.add_registry(
+  Indocker::Registries::Local.new(:dev)
+)

data/example/indocker/infrastructure/servers.rb

@@ -0,0 +1,8 @@
+Indocker.add_server(
+  Indocker::Server.new(
+    name: :localhost,
+    host: 'localhost',
+    user: `whoami`.strip,
+    port: 22
+  )
+)

data/example/indocker/setup.rb

@@ -0,0 +1,24 @@
+require 'indocker'
+
+root_dir = File.join(__dir__, '..', '..')
+
+Indocker.set_root_dir(__dir__)
+Indocker.set_deploy_dir(File.join(root_dir, 'tmp', 'deployment'))
+
+Indocker.set_dockerignore [
+  'Dockerfile',
+  '.DS_Store',
+  '**/.DS_Store',
+  '**/*.log',
+  '.vscode',
+  'tmp',
+]
+
+require_relative 'infrastructure/registries'
+require_relative 'infrastructure/servers'
+require_relative 'infrastructure/build_servers'
+require_relative 'infrastructure/networks'
+
+Indocker.set_bounded_contexts_dir(File.join(__dir__, 'bounded_contexts'))
+
+require_relative "configurations/#{Indocker.configuration_name}"

data/indocker.gemspec

@@ -1,28 +1,30 @@
-require_relative 'lib/indocker/version'
 
-Gem::Specification.new do |s|
-  s.name        = 'indocker'
-  s.version     = Indocker::VERSION
-  s.summary     = "Indocker"
-  s.description = "DSL for build, run and deploy docker containers"
-  s.authors     = ["Droid Labs"]
-  s.email       = 'hello@droidlabs.pro'
-  
-  s.files       = `git ls-files`.split($/)
-  s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  s.test_files  = s.files.grep(%r{^(spec)/})
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "indocker/version"
 
-  s.add_development_dependency "byebug"
-  s.add_development_dependency "rspec"
-  
-  s.add_dependency "smart_ioc"
-  s.add_dependency "docker-api"
-  s.add_dependency "docker_registry2"
-  s.add_dependency "thor"
-  s.add_dependency "colorize"
-  s.add_dependency "git"
-  s.add_dependency "byebug" # TODO: remove after release
+Gem::Specification.new do |spec|
+  spec.name          = "indocker"
+  spec.version       = Indocker::VERSION
+  spec.authors       = ["Ruslan Gatiyatov", "Iskander Khaziev"]
+  spec.email         = ["gvalmon@gmail.com"]
 
-  s.homepage    = 'https://github.com/droidlabs/indocker'
-  s.license     = 'MIT'
-end
+  spec.summary       = %q{Docker Containers Deployment}
+  spec.description   = %q{Docker Containers Deployment}
+  spec.homepage      = "https://github.com/ArtStation/indocker"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |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 "net-ssh"
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/indocker.rb

@@ -1,155 +1,462 @@
-require 'smart_ioc'
+require "indocker/version"
+require 'logger'
+$LOAD_PATH << File.join(__dir__, 'indocker')
 
-require 'byebug' # TODO: remove after release
+require_relative 'indocker/colored_string'
 
-SmartIoC.find_package_beans(:indocker, __dir__)
-SmartIoC.set_load_proc do |location|
-  require(location)
-end
+module Indocker
+  module Repositories
+    autoload :Abstract, 'repositories/abstract'
+    autoload :Git, 'repositories/git'
+    autoload :Local, 'repositories/local'
+    autoload :NoSync, 'repositories/no_sync'
+    autoload :Clonner, 'repositories/clonner'
+  end
 
-require 'indocker/version'
-
-require 'indocker/image/image_helper'
-
-require 'indocker/errors'
-require 'indocker/cli'
-require 'indocker/dsl_context'
-
-require 'indocker/docker_api/docker_api'
-require 'indocker/docker_api/container_config'
-
-require 'indocker/configs/config'
-require 'indocker/configs/config_factory'
-require 'indocker/configs/locator'
-require 'indocker/configs/config_initializer'
-
-require 'indocker/utils/logger'
-require 'indocker/utils/logger_factory'
-require 'indocker/utils/test_logger_factory'
-require 'indocker/utils/tar_helper'
-require 'indocker/utils/string_utils'
-require 'indocker/utils/registry_authenticator'
-require 'indocker/utils/render_util'
-require 'indocker/utils/render_namespace'
-
-require 'indocker/handlers/performable'
-require 'indocker/handlers/container_run'
-require 'indocker/handlers/container_stop'
-
-require 'indocker/utils/ioc_container'
-
-require 'indocker/envs/env_metadata'
-require 'indocker/envs/loader'
-
-require 'indocker/registry/registry_helper'
-require 'indocker/registry/registry_service'
-require 'indocker/registry/registry_api'
-
-require 'indocker/image/image_metadata'
-require 'indocker/image/image_metadata_factory'
-require 'indocker/image/image_dsl'
-require 'indocker/image/image_metadata_repository'
-require 'indocker/image/image_builder'
-require 'indocker/image/image_dependencies_manager'
-require 'indocker/image/image_evaluator'
-require 'indocker/image/image_dockerfile_builder'
-require 'indocker/image/image_directives_runner'
-
-require 'indocker/container/container_metadata'
-require 'indocker/container/container_metadata_repository'
-require 'indocker/container/container_metadata_factory'
-require 'indocker/container/container_manager'
-require 'indocker/container/container_evaluator'
-require 'indocker/container/container_dsl'
-require 'indocker/container/container_builder'
-require 'indocker/container/container_directives_runner'
-
-require 'indocker/partial/partial_metadata'
-require 'indocker/partial/partial_metadata_repository'
-
-require 'indocker/directives/base'
-require 'indocker/directives/partial'
-
-require 'indocker/networks/network_metadata'
-require 'indocker/networks/network_metadata_factory'
-require 'indocker/networks/network_metadata_repository'
-
-require 'indocker/volumes/volume_metadata'
-require 'indocker/volumes/volume_metadata_factory'
-require 'indocker/volumes/volume_metadata_repository'
-
-require 'indocker/directives/image_directives/base'
-require 'indocker/directives/image_directives/cmd'
-require 'indocker/directives/image_directives/entrypoint'
-require 'indocker/directives/image_directives/env'
-require 'indocker/directives/image_directives/copy'
-require 'indocker/directives/image_directives/from'
-require 'indocker/directives/image_directives/run'
-require 'indocker/directives/image_directives/workdir'
-require 'indocker/directives/image_directives/expose'
-require 'indocker/directives/image_directives/env_file'
-require 'indocker/directives/image_directives/docker_cp'
-require 'indocker/directives/image_directives/registry'
-
-require 'indocker/directives/container_directives/base'
-require 'indocker/directives/container_directives/from'
-require 'indocker/directives/container_directives/network'
-require 'indocker/directives/container_directives/ports'
-require 'indocker/directives/container_directives/expose'
-require 'indocker/directives/container_directives/depends_on'
-require 'indocker/directives/container_directives/ready'
-require 'indocker/directives/container_directives/cmd'
-require 'indocker/directives/container_directives/volume'
-require 'indocker/directives/container_directives/env_file'
-require 'indocker/directives/container_directives/env'
-
-
-require 'indocker/git/git_helper'
+  module Configurations
+    autoload :Configuration, 'configurations/configuration'
+    autoload :ConfigurationBuilder, 'configurations/configuration_builder'
 
-module Indocker
-  DOCKERFILE_NAME = 'Dockerfile'
+    module Formatters
+      autoload :Stdout, 'configurations/formatters/stdout'
+    end
+  end
+
+  module Registries
+    autoload :Abstract, 'registries/abstract'
+    autoload :Local, 'registries/local'
+    autoload :Remote, 'registries/remote'
+  end
+
+  module Concerns
+    autoload :Inspectable, 'concerns/inspectable'
+  end
+
+  module Images
+    autoload :Image, 'images/image'
+    autoload :ImageBuilder, 'images/image_builder'
+    autoload :ImageCompiler, 'images/image_compiler'
+    autoload :TemplateCompiler, 'images/template_compiler'
+    autoload :TemplatesCompiler, 'images/templates_compiler'
+  end
+
+  module Containers
+    autoload :Container, 'containers/container'
+    autoload :ContainerBuilder, 'containers/container_builder'
+    autoload :RestartPolicy, 'containers/restart_policy'
+  end
+
+  module Volumes
+    autoload :Local, 'volumes/local'
+    autoload :External, 'volumes/external'
+    autoload :Repository, 'volumes/repository'
+  end
+
+  module EnvFiles
+    autoload :Local, 'env_files/local'
+    autoload :Remote, 'env_files/remote'
+  end
+
+  module Artifacts
+    autoload :Git, 'artifacts/git'
+  end
+
+  autoload :HashMerger, 'hash_merger'
+  autoload :BuildServer, 'build_server'
+  autoload :Server, 'server'
+  autoload :ConfigurationDeployer, 'configuration_deployer'
+  autoload :SshSession, 'ssh_session'
+  autoload :BuildContextPool, 'build_context_pool'
+  autoload :BuildContext, 'build_context'
+  autoload :BuildContextHelper, 'build_context_helper'
+  autoload :Shell, 'shell'
+  autoload :Docker, 'docker'
+  autoload :ContextArgs, 'context_args'
+  autoload :Network, 'network'
+  autoload :ContainerDeployer, 'container_deployer'
+  autoload :ServerPool, 'server_pool'
+  autoload :DeployContext, 'deploy_context'
+  autoload :ContainerHelper, 'container_helper'
+  autoload :DockerRunArgs, 'docker_run_args'
+  autoload :VolumeHelper, 'volume_helper'
+  autoload :NetworkHelper, 'network_helper'
+  autoload :Rsync, 'rsync'
+  autoload :EnvFileHelper, 'env_file_helper'
+  autoload :IndockerHelper, 'indocker_helper'
+  autoload :ImagesCompiler, 'images_compiler'
+  autoload :ContainerRunner, 'container_runner'
+  autoload :SshResultLogger, 'ssh_result_logger'
+  autoload :DeploymentProgress, 'deployment_progress'
+  autoload :DeploymentChecker, 'deployment_checker'
+  autoload :CrontabRedeployRulesBuilder, 'crontab_redeploy_rules_builder'
 
   class << self
-    def define_image(name, &definition)
-      ioc.image_metadata_repository.put(
-        ioc.image_metadata_factory.create(name, &definition)
-      )
+    def set_export_command(command)
+      @export_command = command
     end
 
-    def define_container(name, attach: false, &definition)
-      ioc.container_metadata_repository.put(
-        ioc.container_metadata_factory.create(name, attach: attach, &definition)
-      )
+    def export_command
+      @export_command
     end
 
-    def define_partial(name, &definition)
-      ioc.partial_metadata_repository.put(
-        Indocker::PartialMetadata.new(name, &definition)
-      )
+    def set_deploy_dir(val)
+      @deploy_dir = val
+    end
+
+    def set_root_dir(val)
+      @root_dir = val
+    end
+
+    def set_redeploy_crontab_path(val)
+      @redeploy_crontab_path = val
+    end
+
+    def redeploy_crontab_path
+      @redeploy_crontab_path
+    end
+
+    def deploy_dir
+      if @deploy_dir
+        @deploy_dir
+      else
+        raise ArgumentError.new("deploy dir was not specified")
+      end
+    end
+
+    def root_dir
+      if @root_dir
+        File.expand_path(@root_dir)
+      else
+        raise ArgumentError.new("root dir was not specified")
+      end
+    end
+
+    def add_artifact(artifact)
+      artifacts.push(artifact)
+    end
+
+    def add_repository(repository)
+      if !repository.is_a?(Indocker::Repositories::Abstract)
+        raise ArgumentError.new("should be an instance of Indocker::Repositories::Abstract, got: #{repository.inspect}")
+      end
+
+      repositories.push(repository)
+    end
+
+    def add_registry(registry)
+      if !registry.is_a?(Indocker::Registries::Abstract)
+        raise ArgumentError.new("should be an instance of Indocker::Registries::Abstract, got: #{registry.inspect}")
+      end
+
+      registries.push(registry)
+    end
+
+    def add_server(server)
+      if !server.is_a?(Indocker::Server)
+        raise ArgumentError.new("should be an instance of Indocker::Server, got: #{server.inspect}")
+      end
+
+      existing = servers.detect {|s| s == server}
+
+      if existing
+        raise ArgumentError.new("server with name #{server.name} was already defined")
+      end
+
+      servers.push(server)
     end
 
     def define_network(name)
-      ioc.network_metadata_repository.put(
-        ioc.network_metadata_factory.create(name)
+      if networks.detect {|n| n.name == name}
+        raise ArgumentError.new("network :#{name} was already defined")
+      end
+
+      networks.push(Indocker::Network.new(name))
+    end
+
+    def container_files
+      @container_files || (raise ArgumentError.new("container files were not found. Set bounded contexts dir"))
+    end
+
+    def image_files
+      @image_files || (raise ArgumentError.new("image files were not found. Set bounded contexts dir"))
+    end
+
+    def set_bounded_contexts_dir(path)
+      @container_files = {}
+
+      Dir[File.join(path, '**/container.rb')].map do |path|
+        name = path.gsub('/container.rb', '').split('/').last.to_sym
+        @container_files[name] = path
+      end
+
+      @image_files = {}
+
+      Dir[File.join(path, '**/image.rb')].map do |path|
+        name = path.gsub('/image.rb', '').split('/').last.to_sym
+        @image_files[name] = path
+      end
+    end
+
+    def define_env_file(env_file)
+      if env_files.detect {|ef| ef.name == env_file.name}
+        Indocker.logger.error("env file :#{env_file.name} was already defined")
+        exit 1
+      end
+
+      env_files.push(env_file)
+    end
+
+    def define_volume(volume)
+      if volumes.detect { |v| v.name == volume.name}
+        raise ArgumentError.new("volume :#{volume.name} was already defined")
+      end
+
+      volumes.push(volume)
+    end
+
+    def add_build_server(build_server)
+      if !build_server.is_a?(Indocker::BuildServer)
+        raise ArgumentError.new("should be an instance of Indocker::BuildServer, got: #{build_server.inspect}")
+      end
+
+      existing = build_servers.detect {|s| s == build_server}
+
+      if existing
+        raise ArgumentError.new("build server with name #{build_server.name} was already defined")
+      end
+
+      build_servers.push(build_server)
+    end
+
+    def repositories
+      @repositories ||= []
+    end
+
+    def registries
+      @registries ||= []
+    end
+
+    def networks
+      @networks ||= []
+    end
+
+    def volumes
+      @volumes ||= []
+    end
+
+    def servers
+      @servers ||= []
+    end
+
+    def artifacts
+      @artifacts ||= []
+    end
+
+    def build_servers
+      @build_servers ||= []
+    end
+
+    def env_files
+      @env_files ||= []
+    end
+
+    def configuration
+      @configuration || (raise ArgumentError.new("no configuration provided"))
+    end
+
+    def images
+      @images ||= []
+    end
+
+    def containers
+      @containers ||= []
+    end
+
+    def build_configuration(name)
+      builder = Indocker::Configurations::ConfigurationBuilder.new(
+        name: name,
+        repositories: repositories,
+        registries: registries,
+        servers: servers,
+        build_servers: build_servers,
+        volumes: volumes,
+        networks: networks,
+        env_files: env_files,
+        containers: containers,
       )
+
+      @configuration = builder.configuration
+      builder
     end
 
-    def define_volume(name)
-      ioc.volume_metadata_repository.put(
-        ioc.volume_metadata_factory.create(name)
+    def define_image(name)
+      path = caller[0].split(':').first
+
+      if !(path =~ /\/image.rb$/)
+        Indocker.logger.error("image :#{name} should be defined in image.rb file")
+        exit 1
+      end
+
+      builder = Indocker::Images::ImageBuilder.new(
+        name: name,
+        configuration: configuration,
+        dir: path.split('image.rb').first
       )
+
+      images.push(builder.image)
+
+      builder
     end
 
-    def setup(&block)
-      ioc.config.set(&block)
+    def define_container(name)
+      builder = Indocker::Containers::ContainerBuilder.new(
+        name: name,
+        configuration: configuration,
+      )
+
+      containers.push(builder.container)
+      builder
+    end
+
+    def deploy(containers: [], skip_tags: [], tags: [], skip_dependent: false, skip_containers: [], servers: [], skip_build: false, force_restart: false, skip_force_restart: [], auto_confirm: false, require_confirmation: false)
+      Indocker::ConfigurationDeployer
+        .new(Indocker.logger)
+        .run(
+          configuration: configuration,
+          deploy_containers: containers,
+          deploy_tags: tags,
+          skip_dependent: skip_dependent,
+          skip_containers: skip_containers,
+          servers: servers,
+          skip_build: skip_build,
+          force_restart: force_restart,
+          skip_tags: skip_tags,
+          skip_force_restart: skip_force_restart,
+          auto_confirm: auto_confirm,
+          require_confirmation: require_confirmation,
+        )
+    end
+
+    def check(servers: [])
+      Indocker::DeploymentChecker
+        .new(Indocker.logger)
+        .run(
+          configuration: configuration,
+          servers: servers,
+        )
+    end
+
+    def launched?(contaner_name, servers: [])
+      silent_logger = Logger.new(File.open(File::NULL, "w"))
+      Indocker::DeploymentChecker
+        .new(silent_logger, silent_logger)
+        .launched?(
+          contaner_name,
+          configuration: configuration,
+          servers: servers,
+        )
+    end
+
+    def compile(images:, skip_dependent:)
+      Indocker::ImagesCompiler
+        .new(Indocker.logger)
+        .compile(
+          configuration: configuration,
+          image_list: images,
+          skip_dependent: skip_dependent,
+        )
+    end
+
+    def run(container_name, force_restart)
+      Indocker::ContainerRunner
+        .new(Indocker.logger)
+        .run(
+          configuration: configuration,
+          container_name: container_name,
+          force_restart: force_restart
+        )
+    end
+
+    def global_build_args
+      Indocker::ContextArgs.new(nil, configuration.global_build_args, nil)
+    end
+
+    def helper
+      Indocker::BuildContextHelper.new(Indocker.configuration, nil)
+    end
+
+    def logger
+      @logger ||= begin
+        logger = if @log_level == Logger::DEBUG
+          Logger.new(STDOUT)
+        else
+          Logger.new(File.open(File::NULL, "w"))
+        end
+
+        logger.level = @log_level || Logger::INFO
+
+        logger.formatter = proc do |severity, datetime, progname, msg|
+          level = Logger::SEV_LABEL.index(severity)
+
+          severity = case level
+          when Logger::INFO
+            severity.green
+          when Logger::WARN
+            severity.purple
+          when Logger::DEBUG
+            severity.yellow
+          when Logger::ERROR
+            severity.red
+          when Logger::FATAL
+            severity.red
+          else
+            severity
+          end
+
+          severity = severity.downcase
+
+          if logger.debug?
+            if msg == "{timestamp}"
+              ""
+            else
+              "#{datetime.strftime("%Y/%m/%d %H:%M:%S")} #{severity}: #{msg}\n"
+            end
+          else
+            # Use a nicer logging for not debug
+            if msg == "{timestamp}"
+              datetime.strftime("%Y/%m/%d %H:%M:%S\n").grey
+            else
+              "  #{severity}: #{msg}\n"
+            end
+          end
+        end
+
+        logger
+      end
+    end
+
+    def set_log_level(level)
+      @log_level = level
+    end
+
+    def set_dockerignore(ignore_list)
+      @dockerignore = ignore_list
+    end
+
+    def dockerignore
+      @dockerignore || []
+    end
+
+    def build_helper(&proc)
+      Indocker::BuildContextHelper.class_exec(&proc)
     end
 
-    def cache_dir(dir = nil)
-      ioc.config.git.cache_dir(Pathname.new(dir))
+    def set_configuration_name(name)
+      @configuration_name = name
     end
 
-    def build_dir(dir = nil)
-      ioc.config.build_dir(Pathname.new(dir))
+    def configuration_name
+      @configuration_name || (raise ArgumentError.new("configuration was not specified"))
     end
   end
-end
+end