dapp 0.2.8 → 0.3.0

data/lib/dapp/controller.rb

@@ -15,52 +15,51 @@ module Dapp
 
       paint_initialize
       Helper::I18n.initialize
-      build_confs
+    end
+
+    def run(docker_options, command)
+      raise Error::Controller, code: :run_command_unexpected_apps_number unless build_configs.one?
+      Application.new(config: build_configs.first, cli_options: cli_options, ignore_git_fetch: true).run(docker_options, command)
     end
 
     def build
-      build_confs.each do |build_conf|
-        log_step(build_conf._name)
-        with_log_indent { Application.new(config: build_conf, cli_options: cli_options).build! }
-      end
+      build_configs.each { |config| Application.new(config: config, cli_options: cli_options).build! }
     end
 
     def list
-      build_confs.each do |build_conf|
-        log(build_conf._name)
-      end
+      build_configs.each { |config| log(config._name) }
     end
 
     def push(repo)
-      raise Error::Controller, code: :push_command_unexpected_apps unless @build_confs.one?
-      Application.new(config: @build_confs.first, cli_options: cli_options, ignore_git_fetch: true).export!(repo)
+      raise Error::Controller, code: :push_command_unexpected_apps_number unless build_configs.one?
+      Application.new(config: build_configs.first, cli_options: cli_options, ignore_git_fetch: true).export!(repo)
     end
 
     def smartpush(repo_prefix)
-      build_confs.each do |build_conf|
-        log_step(build_conf._name)
-        repo = File.join(repo_prefix, build_conf._name)
-        with_log_indent { Application.new(config: build_conf, cli_options: cli_options, ignore_git_fetch: true).export!(repo) }
+      build_configs.each do |config|
+        log_step(config._name)
+        repo = File.join(repo_prefix, config._name)
+        with_log_indent { Application.new(config: config, cli_options: cli_options, ignore_git_fetch: true).export!(repo) }
       end
     end
 
-    def flush_build_cache
-      build_confs.each do |build_conf|
-        log(build_conf._name)
-        app = Application.new(config: build_conf, cli_options: cli_options, ignore_git_fetch: true)
-        FileUtils.rm_rf app.build_cache_path
+    def flush_metadata
+      build_configs.each do |config|
+        log(config._name)
+        app = Application.new(config: config, cli_options: cli_options, ignore_git_fetch: true)
+        FileUtils.rm_rf app.metadata_path
       end
     end
 
-    def self.flush_stage_cache
+    def self.flush_stages
       shellout('docker rmi $(docker images --format="{{.Repository}}:{{.Tag}}" dapp)')
       shellout('docker rmi $(docker images -f "dangling=true" -q)')
     end
 
     private
 
-    def build_confs
-      @build_confs ||= begin
+    def build_configs
+      @configs ||= begin
         if File.exist? dappfile_path
           dappfiles = dappfile_path
         elsif (dappfiles = dapps_dappfiles_pathes).empty? && (dappfiles = search_dappfile_up).nil?

data/lib/dapp/exception/base.rb

@@ -1,10 +1,6 @@
 module Dapp
   module Exception
     # Base
-    class Base < NetStatus::Exception
-      def initialize(net_status = {})
-        super(net_status.merge(context: self.class.to_s.split('::').last.downcase))
-      end
-    end
+    class Base < Error::Base; end
   end
 end

data/lib/dapp/filelock.rb

@@ -28,7 +28,7 @@ module Dapp
     protected
 
     def filelock_lockfile(filelock, error_message: 'Already in use!', timeout: 10)
-      File.open(build_path(filelock), File::RDWR | File::CREAT, 0o644) do |file|
+      File.open(home_path(filelock), File::RDWR | File::CREAT, 0o644) do |file|
         Timeout.timeout(timeout) do
           file.flock(File::LOCK_EX)
         end

data/lib/dapp/git_artifact.rb

@@ -26,7 +26,7 @@ module Dapp
       credentials = [:owner, :group].map { |attr| "--#{attr}=#{send(attr)}" unless send(attr).nil? }.compact
 
       ["install #{credentials.join(' ')} -d #{where_to_add}",
-       ["git --git-dir=#{repo.container_build_dir_path} archive #{stage.layer_commit(self)}:#{cwd} #{paths}",
+       ["git --git-dir=#{repo.container_path} archive #{stage.layer_commit(self)}:#{cwd} #{paths}",
         "#{sudo}tar -x -C #{where_to_add}"].join(' | ')]
     end
 
@@ -35,7 +35,7 @@ module Dapp
       prev_commit = stage.prev_source_stage.layer_commit(self)
 
       if prev_commit != current_commit || any_changes?(prev_commit, current_commit)
-        [["git --git-dir=#{repo.container_build_dir_path} #{diff_command(prev_commit, current_commit)}",
+        [["git --git-dir=#{repo.container_path} #{diff_command(prev_commit, current_commit)}",
           "#{sudo}git apply --whitespace=nowarn --directory=#{where_to_add} " \
           '$(if [[ "$(git --version)" != "git version 1."* ]]; then echo "--unsafe-paths"; fi)'].join(' | ')] # FIXME
       else

data/lib/dapp/git_repo/base.rb

@@ -10,16 +10,16 @@ module Dapp
         @name = name
       end
 
-      def container_build_dir_path
-        application.container_build_path "#{name}.git"
+      def container_path
+        application.container_tmp_path "#{name}.git"
       end
 
-      def dir_path
-        application.build_path "#{name}.git"
+      def path
+        application.tmp_path "#{name}.git"
       end
 
       def git_bare(command, **kwargs)
-        git "--git-dir=#{dir_path} #{command}", **kwargs
+        git "--git-dir=#{path} #{command}", **kwargs
       end
 
       def commit_at(commit)

data/lib/dapp/git_repo/own.rb

@@ -6,8 +6,12 @@ module Dapp
         super(application, 'own')
       end
 
-      def dir_path
-        @dir_path ||= Pathname(git("-C #{application.home_path} rev-parse --git-dir").stdout.strip).expand_path
+      def container_path
+        application.container_dapp_path('own', "#{name}.git")
+      end
+
+      def path
+        @path ||= Pathname(git("-C #{application.home_path} rev-parse --git-dir").stdout.strip).expand_path
       end
 
       def latest_commit(branch = nil)

data/lib/dapp/git_repo/remote.rb

@@ -12,8 +12,10 @@ module Dapp
         File.chmod(0o600, @ssh_key_path) if @ssh_key_path
 
         with_ssh_key do
-          git "clone --bare --depth 1 #{url} #{dir_path}"
-        end unless File.directory? dir_path
+          application.log_secondary_process(application.t(code: 'process.git_artifact_clone', data: { name: name }), short: true) do
+            git "clone --bare --depth 1 #{url} #{path}"
+          end
+        end unless File.directory?(path)
       end
 
       def fetch!(branch = 'master')
@@ -26,7 +28,7 @@ module Dapp
 
       def cleanup!
         super
-        FileUtils.rm_rf dir_path
+        FileUtils.rm_rf path
       end
 
       protected

data/lib/dapp/helper/cli.rb

@@ -3,7 +3,13 @@ module Dapp
     # Cli
     module Cli
       def parse_options(cli, argv)
-        cli.parse_options(argv)
+        cli_wrapper(cli) do
+          cli.parse_options(argv)
+        end
+      end
+
+      def cli_wrapper(cli)
+        yield
       rescue OptionParser::MissingArgument, OptionParser::InvalidOption, OptionParser::InvalidArgument => e
         STDERR.puts "Error: #{e.message}"
         puts cli.opt_parser

data/lib/dapp/helper/log.rb

@@ -34,9 +34,9 @@ module Dapp
         end.join
       end
 
-      def log_with_indent(message = '', **kvargs)
+      def log_with_indent(message = '', **kwargs)
         with_log_indent do
-          log(message, **kvargs)
+          log(message, **kwargs)
         end
       end
 

data/lib/dapp/helper/shellout.rb

@@ -34,7 +34,7 @@ module Dapp
       end
 
       def shellout_pack(command)
-        "bash -ec 'eval $(echo #{Base64.strict_encode64(command)} | base64 --decode)'"
+        "-ec 'eval $(echo #{Base64.strict_encode64(command)} | base64 --decode)'"
       end
 
       def self.included(base)

data/lib/dapp/helper/trivia.rb

@@ -15,10 +15,6 @@ module Dapp
         path.delete if path.exist?
       end
 
-      def to_mb(bytes)
-        (bytes / 1024.0 / 1024.0).round(2)
-      end
-
       def self.class_to_lowercase(class_name = self.class)
         class_name.to_s.split('::').last.split(/(?=[[:upper:]]|[0-9])/).join('_').downcase.to_s
       end

data/lib/dapp/image/arguments.rb

@@ -0,0 +1,115 @@
+module Dapp
+  module Image
+    # Arguments
+    module Arguments
+      def add_change_volume(value)
+        add_change_option(:volume, value)
+      end
+
+      def add_change_expose(value)
+        add_change_option(:expose, value)
+      end
+
+      def add_change_env(value)
+        add_change_option(:env, value)
+      end
+
+      def add_change_label(value)
+        add_change_option(:label, value)
+      end
+
+      def add_change_cmd(value)
+        add_change_option(:cmd, value)
+      end
+
+      def add_change_entrypoint(value)
+        add_change_option(:entrypoint, value)
+      end
+
+      def add_change_onbuild(value)
+        add_change_option(:onbuild, value)
+      end
+
+      def add_change_workdir(value)
+        add_change_option(:workdir, value)
+      end
+
+      def add_change_user(value)
+        add_change_option(:user, value)
+      end
+
+      def add_cmd(value)
+        add_option(:cmd, value)
+      end
+
+      def add_volume(value)
+        add_option(:volume, value)
+      end
+
+      def add_volumes_from(value)
+        add_option(:'volumes-from', value)
+      end
+
+      def add_entrypoint(value)
+        add_option(:entrypoint, value)
+      end
+
+      def add_commands(*commands)
+        @bash_commands.concat(commands.flatten)
+      end
+
+      protected
+
+      attr_reader :bash_commands
+      attr_reader :options, :change_options
+
+      def add_option(key, value)
+        add_option_default(options, key, value)
+      end
+
+      def add_change_option(key, value)
+        add_option_default(change_options, key, value)
+      end
+
+      def add_option_default(hash, key, value)
+        hash[key] = (hash[key].nil? ? value : (Array(hash[key]) << value).flatten)
+      end
+
+      def from_options
+        return {} if from.nil?
+        [:entrypoint, :cmd].each_with_object({}) do |option, options|
+          output = shellout!("docker inspect --format='{{json .Config.#{option.to_s.capitalize}}}' #{from.built_id}").stdout.strip
+          options[option] = output == 'null' ? [] : JSON.parse(output)
+          options
+        end
+      end
+
+      def prepared_options
+        prepared_options_default(options) { |k, vals| Array(vals).map { |v| "--#{k}=#{v}" }.join(' ') }
+      end
+
+      def prepared_change
+        prepared_options_default(from_options.merge(change_options)) do |k, vals|
+          if [:cmd, :entrypoint].include? k
+            %(-c '#{k.to_s.upcase} #{Array(vals)}')
+          else
+            Array(vals).map { |v| %(-c "#{k.to_s.upcase} #{v}") }.join(' ')
+          end
+        end
+      end
+
+      def prepared_options_default(hash)
+        hash.map { |k, vals| yield(k, vals) }.join(' ')
+      end
+
+      def prepared_bash_command
+        shellout_pack prepared_commands.join(' && ')
+      end
+
+      def prepared_commands
+        return ['true'] if bash_commands.empty?
+        bash_commands
+      end
+    end
+  end # Image
+end # Dapp

data/lib/dapp/image/docker.rb

@@ -0,0 +1,76 @@
+module Dapp
+  # Image
+  module Image
+    # Docker
+    class Docker
+      include Helper::Shellout
+
+      attr_reader :from
+      attr_reader :name
+
+      def initialize(name:, from: nil)
+        @from = from
+        @name = name
+      end
+
+      def id
+        @id || cache[:id]
+      end
+
+      def untag!
+        raise Error::Build, code: :image_already_untagged, data: { name: name } unless tagged?
+        shellout!("docker rmi #{name}")
+        cache_reset
+      end
+
+      def push!(log_verbose: false, log_time: false)
+        raise Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
+        shellout!("docker push #{name}", log_verbose: log_verbose, log_time: log_time)
+      end
+
+      def pull!(log_verbose: false, log_time: false)
+        return if tagged?
+        shellout!("docker pull #{name}", log_verbose: log_verbose, log_time: log_time)
+        @pulled = true
+        cache_reset
+      end
+
+      def tagged?
+        !!id
+      end
+
+      def pulled?
+        !!@pulled
+      end
+
+      def info
+        raise Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
+        [cache[:created_at], cache[:size]]
+      end
+
+      protected
+
+      def cache
+        self.class.cache[name.to_s] || {}
+      end
+
+      def cache_reset
+        self.class.cache.delete(name)
+        self.class.cache_reset(name)
+      end
+
+      class << self
+        def cache
+          @cache ||= (@cache = {}).tap { cache_reset }
+        end
+
+        def cache_reset(name = '')
+          shellout!("docker images --format='{{.Repository}}:{{.Tag}};{{.ID}};{{.CreatedAt}};{{.Size}}' #{name}").stdout.lines.each do |line|
+            name, id, created_at, size = line.split(';')
+            cache[name] = { id: id, created_at: created_at, size: size }
+          end
+        end
+      end
+    end # Docker
+  end # Image
+end # Dapp

data/lib/dapp/image/stage.rb

@@ -0,0 +1,74 @@
+module Dapp
+  # Image
+  module Image
+    # Stage
+    class Stage < Docker
+      include Arguments
+
+      def initialize(name:, built_id: nil, from: nil)
+        @bash_commands = []
+        @options = {}
+        @change_options = {}
+        @container_name = SecureRandom.hex
+        @built_id = built_id
+        super(name: name, from: from)
+      end
+
+      def built_id
+        @built_id ||= id
+      end
+
+      def build!(**kwargs)
+        @built_id = if should_be_built?
+                      begin
+                        run!(**kwargs)
+                        commit!
+                      ensure
+                        shellout("docker rm #{container_name}")
+                      end
+                    else
+                      from.built_id
+                    end
+      end
+
+      def export!(name, log_verbose: false, log_time: false, force: false)
+        image = self.class.new(built_id: built_id, name: name)
+        image.tag!(log_verbose: log_verbose, log_time: log_time, force: force)
+        image.push!(log_verbose: log_verbose, log_time: log_time)
+        image.untag!
+      end
+
+      def tag!(log_verbose: false, log_time: false, force: false)
+        if !(existed_id = id).nil? && !force
+          raise Error::Build, code: :another_image_already_tagged if built_id != existed_id
+          return
+        end
+        shellout!("docker tag #{built_id} #{name}", log_verbose: log_verbose, log_time: log_time)
+        cache_reset
+      end
+
+      protected
+
+      attr_reader :container_name
+
+      def run!(log_verbose: false, log_time: false, introspect_error: false, introspect_before_error: false)
+        raise Error::Build, code: :built_id_not_defined if from.built_id.nil?
+        shellout!("docker run #{prepared_options} --entrypoint /bin/sh --name=#{container_name} #{from.built_id} #{prepared_bash_command}",
+                  log_verbose: log_verbose, log_time: log_time)
+      rescue Error::Shellout => e
+        raise unless introspect_error || introspect_before_error
+        built_id = introspect_error ? commit! : from.built_id
+        raise Exception::IntrospectImage, message: Dapp::Helper::NetStatus.message(e),
+                                          data: { built_id: built_id, options: prepared_options, rmi: introspect_error }
+      end
+
+      def commit!
+        shellout!("docker commit #{prepared_change} #{container_name}").stdout.strip
+      end
+
+      def should_be_built?
+        !(bash_commands.empty? && change_options.empty?)
+      end
+    end # Stage
+  end # Image
+end # Dapp