dapp 0.8.0 → 0.9.0

data/lib/dapp/dimg/git_repo/own.rb

@@ -0,0 +1,39 @@
+module Dapp
+  module Dimg
+    module GitRepo
+      class Own < Base
+        def initialize(dimg)
+          super(dimg, 'own')
+        end
+
+        def exclude_paths
+          dimg.dapp.local_git_artifact_exclude_paths
+        end
+
+        def path
+          @path ||= Rugged::Repository.discover(dimg.home_path.to_s).path
+        rescue Rugged::RepositoryError => _e
+          raise Error::Rugged, code: :local_git_repository_does_not_exist
+        end
+
+        def diff(from, to, **kwargs)
+          if to.nil?
+            git.lookup(from).diff_workdir
+          else
+            super
+          end
+        end
+
+        def latest_commit(_branch = nil)
+          git.head.target_id
+        end
+
+        def lookup_commit(commit)
+          super
+        rescue Rugged::OdbError => _e
+          raise Error::Rugged, code: :commit_not_found_in_local_git_repository, data: { commit: commit }
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dimg/git_repo/remote.rb

@@ -0,0 +1,50 @@
+module Dapp
+  module Dimg
+    module GitRepo
+      class Remote < Base
+        def initialize(dimg, name, url:)
+          super(dimg, name)
+
+          @url = url
+
+          dimg.dapp.log_secondary_process(dimg.dapp.t(code: 'process.git_artifact_clone', data: { name: name }), short: true) do
+            begin
+              Rugged::Repository.clone_at(url, path, bare: true)
+            rescue Rugged::NetworkError, Rugged::SslError => e
+              raise Error::Rugged, code: :rugged_remote_error, data: { message: e.message, url: url }
+            end
+          end unless File.directory?(path)
+        end
+
+        def path
+          dimg.build_path("#{name}.git").to_s
+        end
+
+        def fetch!(branch = nil)
+          branch ||= self.branch
+          dimg.dapp.log_secondary_process(dimg.dapp.t(code: 'process.git_artifact_fetch', data: { name: name }), short: true) do
+            git.fetch('origin', [branch])
+          end unless dimg.ignore_git_fetch || dimg.dapp.dry_run?
+        end
+
+        def latest_commit(branch)
+          git.ref("refs/remotes/origin/#{branch}").target_id
+        end
+
+        def lookup_commit(commit)
+          super
+        rescue Rugged::OdbError => _e
+          raise Error::Rugged, code: :commit_not_found_in_remote_git_repository, data: { commit: commit, url: url }
+        end
+
+        protected
+
+        attr_reader :url
+
+        def git
+          super(bare: true)
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dimg/image/argument.rb

@@ -0,0 +1,143 @@
+module Dapp
+  module Dimg
+    module Image
+      module Argument
+        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(**options)
+          add_change_option(:env, options)
+        end
+
+        def add_change_label(**options)
+          add_change_option(:label, options)
+        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_service_change_label(**options)
+          add_service_change_option(:label, options)
+        end
+
+        def add_env(var, value)
+          add_option(:env, "#{var}=#{value}")
+        end
+
+        def add_volume(value)
+          add_option(:volume, value)
+        end
+
+        def add_volumes_from(value)
+          add_option(:'volumes-from', value)
+        end
+
+        def add_command(*commands)
+          @bash_commands.concat(commands.flatten)
+        end
+
+        def add_service_command(*commands)
+          @service_bash_commands.concat(commands.flatten)
+        end
+
+        def prepare_instructions(options)
+          options.map do |key, vals|
+            case key
+            when :cmd, :entrypoint then [vals]
+            when :env, :label then vals.map(&method(:options_to_args)).flatten
+            else vals
+            end.map { |val| %(#{key.to_s.upcase} #{val}) }
+          end.flatten
+        end
+
+        protected
+
+        attr_reader :bash_commands, :service_bash_commands
+        attr_reader :change_options, :service_change_options
+        attr_reader :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_service_change_option(key, value)
+          add_option_default(service_change_options, key, value)
+        end
+
+        def add_option_default(hash, key, value)
+          hash[key] = (hash[key].nil? ? [value] : (hash[key] << value)).flatten
+        end
+
+        def from_change_options
+          return {} if from.nil?
+          [:entrypoint, :cmd].each_with_object({}) do |option, options|
+            options[option] = self.class.image_config_option(image_id: from.built_id, option: option)
+          end
+        end
+
+        def options_to_args(options)
+          options.map { |key, value| "#{key}=#{value}" }
+        end
+
+        def prepared_options
+          all_options.map { |key, vals| Array(vals).map { |val| "--#{key}=#{val}" } }.flatten.join(' ')
+        end
+
+        def all_options
+          service_options.merge(options)
+        end
+
+        def all_bash_commands
+          Array(bash_commands) + Array(service_bash_commands)
+        end
+
+        def service_options
+          { entrypoint: dapp.bash_bin, name: container_name }
+        end
+
+        def prepared_change
+          prepare_instructions(all_change_options).map { |instruction| %(-c '#{instruction}') }.join(' ')
+        end
+
+        def all_change_options
+          from_change_options.merge(change_options.merge(service_change_options) { |_, v1, v2| [v1, v2].flatten })
+        end
+
+        def prepared_bash_command
+          dapp.shellout_pack prepared_commands.join(' && ')
+        end
+
+        def prepared_commands
+          return [dapp.true_bin] if all_bash_commands.empty?
+          all_bash_commands
+        end
+      end
+    end # Image
+  end # Dimg
+end # Dapp

data/lib/dapp/dimg/image/docker.rb

@@ -0,0 +1,127 @@
+module Dapp
+  module Dimg
+    module Image
+      class Docker
+        attr_reader :from
+        attr_reader :name
+        attr_reader :dapp
+
+        def self.image_by_name(name:, **kwargs)
+          (@images ||= {})[name] ||= new(name: name, **kwargs)
+        end
+
+        def initialize(name:, dapp:, from: nil)
+          @from = from
+          @name = name
+          @dapp = dapp
+        end
+
+        def id
+          cache[:id]
+        end
+
+        def untag!
+          raise Error::Build, code: :image_already_untagged, data: { name: name } unless tagged?
+          dapp.shellout!("docker rmi #{name}")
+          cache_reset
+        end
+
+        def push!
+          raise Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
+          dapp.log_secondary_process(dapp.t(code: 'process.image_push', data: { name: name })) do
+            dapp.shellout!("docker push #{name}", log_verbose: true)
+          end
+        end
+
+        def pull!
+          return if tagged?
+          dapp.log_secondary_process(dapp.t(code: 'process.image_pull', data: { name: name })) do
+            dapp.shellout!("docker pull #{name}", log_verbose: true)
+          end
+          cache_reset
+        end
+
+        def tagged?
+          !!id
+        end
+
+        def created_at
+          raise Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
+          cache[:created_at]
+        end
+
+        def size
+          raise Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
+          cache[:size]
+        end
+
+        def self.image_config_option(image_id:, option:)
+          output = ::Dapp::Dapp.shellout!("docker inspect --format='{{json .Config.#{option.to_s.capitalize}}}' #{image_id}").stdout.strip
+          output == 'null' ? [] : JSON.parse(output)
+        end
+
+        def cache_reset
+          self.class.cache_reset(name)
+        end
+
+        protected
+
+        def cache
+          self.class.cache[name.to_s] || {}
+        end
+
+        class << self
+          def image_name_format
+            separator = '[_.]|__|[-]*'
+            tag = "[[:alnum:]][[[:alnum:]]#{separator}]{0,127}"
+            "#{DockerRegistry.repo_name_format}(:(?<tag>#{tag}))?"
+          end
+
+          def image_name?(name)
+            !(/^#{image_name_format}$/ =~ name).nil?
+          end
+
+          def tag!(id:, tag:)
+            ::Dapp::Dapp.shellout!("docker tag #{id} #{tag}")
+            cache_reset
+          end
+
+          def save!(image_or_images, file_path)
+            images = Array(image_or_images).join(' ')
+            ::Dapp::Dapp.shellout!("docker save -o #{file_path} #{images}", log_verbose: true)
+          end
+
+          def load!(file_path)
+            ::Dapp::Dapp.shellout!("docker load -i #{file_path}", log_verbose: true)
+          end
+
+          def cache
+            @cache ||= (@cache = {}).tap { cache_reset }
+          end
+
+          def cache_reset(name = '')
+            cache.delete(name)
+            ::Dapp::Dapp.shellout!("docker images --format='{{.Repository}}:{{.Tag}};{{.ID}};{{.CreatedAt}};{{.Size}}' --no-trunc #{name}")
+                        .stdout
+                        .lines
+                        .each do |l|
+              name, id, created_at, size_field = l.split(';')
+              size = begin
+                number, unit = size_field.split
+                coef = case unit.to_s.downcase
+                       when 'b'  then return number.to_f
+                       when 'kb' then 1
+                       when 'mb' then 2
+                       when 'gb' then 3
+                       when 'tb' then 4
+                       end
+                number.to_f * (1000**coef)
+              end
+              cache[name] = { id: id, created_at: created_at, size: size }
+            end
+          end
+        end
+      end # Docker
+    end # Image
+  end # Dimg
+end # Dapp

data/lib/dapp/dimg/image/scratch.rb

@@ -0,0 +1,32 @@
+module Dapp
+  module Dimg
+    module Image
+      class Scratch < Stage
+        def initialize(**_kwargs)
+          super
+          @from_archives = []
+        end
+
+        def add_archive(*archives)
+          @from_archives.concat(archives.flatten)
+        end
+
+        def build!(**_kwargs)
+          raise
+
+          # FIXME: system-shellout rejected
+          # build_from_command = if from_archives.empty?
+          #                        "#{dapp.tar_bin} c --files-from /dev/null"
+          #                      else
+          #                        "#{dapp.cat_bin} #{from_archives.join(' ')}"
+          #                      end
+          # @built_id = dapp.system_shellout!("#{build_from_command} | docker import #{prepared_change} - ").stdout.strip
+        end
+
+        protected
+
+        attr_accessor :from_archives
+      end # Stage
+    end # Image
+  end # Dimg
+end # Dapp

data/lib/dapp/dimg/image/stage.rb

@@ -0,0 +1,95 @@
+module Dapp
+  module Dimg
+    module Image
+      class Stage < Docker
+        include Argument
+
+        def initialize(name:, dapp:, built_id: nil, from: nil)
+          @container_name = "#{name[/[[^:].]*/]}.#{SecureRandom.hex(4)}"
+          @built_id = built_id
+
+          @bash_commands          = []
+          @service_bash_commands  = []
+          @options                = {}
+          @change_options         = {}
+          @service_change_options = {}
+
+          super(name: name, dapp: dapp, from: from)
+        end
+
+        def built_id
+          @built_id ||= id
+        end
+
+        def build!
+          run!
+          @built_id = commit!
+        ensure
+          dapp.shellout("docker rm #{container_name}")
+        end
+
+        def built?
+          !built_id.nil?
+        end
+
+        def export!(name)
+          tag!(name).tap do |image|
+            image.push!
+            image.untag!
+          end
+        end
+
+        def tag!(name)
+          clone!(name).tap do |image|
+            self.class.tag!(id: image.built_id, tag: image.name)
+          end
+        end
+
+        def import!(name)
+          clone!(name).tap do |image|
+            image.pull!
+            @built_id = image.built_id
+            save_in_cache!
+            image.untag!
+          end
+        end
+
+        def save_in_cache!
+          dapp.log_warning(desc: { code: :another_image_already_tagged }) if !(existed_id = id).nil? && built_id != existed_id
+          self.class.tag!(id: built_id, tag: name)
+        end
+
+        def labels
+          raise Error::Build, code: :image_not_exist, data: { name: name } if built_id.nil?
+          self.class.image_config_option(image_id: built_id, option: 'labels')
+        end
+
+        protected
+
+        attr_reader :container_name
+
+        def run!
+          raise Error::Build, code: :built_id_not_defined if from.built_id.nil?
+          dapp.shellout!("docker run #{prepared_options} #{from.built_id} -ec '#{prepared_bash_command}'", log_verbose: true)
+        rescue Error::Shellout => error
+          dapp.log_warning(desc: { code: :launched_command, data: { command: prepared_commands.join(' && ') }, context: :container })
+
+          raise unless dapp.introspect_error? || dapp.introspect_before_error?
+          built_id = dapp.introspect_error? ? commit! : from.built_id
+          raise Exception::IntrospectImage, data: { built_id: built_id,
+                                                    options: prepared_options,
+                                                    rmi: dapp.introspect_error?,
+                                                    error: error }
+        end
+
+        def commit!
+          dapp.shellout!("docker commit #{prepared_change} #{container_name}").stdout.strip
+        end
+
+        def clone!(name)
+          self.class.new(name: name, dapp: dapp, built_id: built_id)
+        end
+      end # Stage
+    end # Image
+  end # Dimg
+end # Dapp