dapp 0.8.0 → 0.9.0

data/lib/dapp/git_repo/own.rb

@@ -1,38 +0,0 @@
-module Dapp
-  module GitRepo
-    # Own Git repo
-    class Own < Base
-      def initialize(dimg)
-        super(dimg, 'own')
-      end
-
-      def exclude_paths
-        dimg.project.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

data/lib/dapp/git_repo/remote.rb

@@ -1,49 +0,0 @@
-module Dapp
-  module GitRepo
-    # Normal Git repo
-    class Remote < Base
-      def initialize(dimg, name, url:)
-        super(dimg, name)
-
-        @url = url
-
-        dimg.project.log_secondary_process(dimg.project.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.project.log_secondary_process(dimg.project.t(code: 'process.git_artifact_fetch', data: { name: name }), short: true) do
-          git.fetch('origin', [branch])
-        end unless dimg.ignore_git_fetch || dimg.project.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

data/lib/dapp/image/argument.rb

@@ -1,134 +0,0 @@
-module Dapp
-  module Image
-    # Argument
-    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 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
-      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 service_options
-        { entrypoint: project.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
-        project.shellout_pack prepared_commands.join(' && ')
-      end
-
-      def prepared_commands
-        return [project.true_bin] if bash_commands.empty?
-        bash_commands
-      end
-    end
-  end # Image
-end # Dapp

data/lib/dapp/image/docker.rb

@@ -1,115 +0,0 @@
-module Dapp
-  # Image
-  module Image
-    # Docker
-    class Docker
-      attr_reader :from
-      attr_reader :name
-      attr_reader :project
-
-      def self.image_by_name(name:, **kwargs)
-        (@images ||= {})[name] ||= new(name: name, **kwargs)
-      end
-
-      def initialize(name:, project:, from: nil)
-        @from = from
-        @name = name
-        @project = project
-      end
-
-      def id
-        cache[:id]
-      end
-
-      def untag!
-        raise Error::Build, code: :image_already_untagged, data: { name: name } unless tagged?
-        project.shellout!("docker rmi #{name}")
-        cache_reset
-      end
-
-      def push!
-        raise Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
-        project.log_secondary_process(project.t(code: 'process.image_push', data: { name: name })) do
-          project.shellout!("docker push #{name}", log_verbose: true)
-        end
-      end
-
-      def pull!
-        return if tagged?
-        project.log_secondary_process(project.t(code: 'process.image_pull', data: { name: name })) do
-          project.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 = Project.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:)
-          Project.shellout!("docker tag #{id} #{tag}")
-          cache_reset
-        end
-
-        def cache
-          @cache ||= (@cache = {}).tap { cache_reset }
-        end
-
-        def cache_reset(name = '')
-          cache.delete(name)
-          Project.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 # Dapp

data/lib/dapp/image/scratch.rb

@@ -1,32 +0,0 @@
-module Dapp
-  # Image
-  module Image
-    # Stage
-    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?
-        #                        "#{project.tar_bin} c --files-from /dev/null"
-        #                      else
-        #                        "#{project.cat_bin} #{from_archives.join(' ')}"
-        #                      end
-        # @built_id = project.system_shellout!("#{build_from_command} | docker import #{prepared_change} - ").stdout.strip
-      end
-
-      protected
-
-      attr_accessor :from_archives
-    end # Stage
-  end # Image
-end # Dapp

data/lib/dapp/image/stage.rb

@@ -1,94 +0,0 @@
-module Dapp
-  # Image
-  module Image
-    # Stage
-    class Stage < Docker
-      include Argument
-
-      def initialize(name:, project:, built_id: nil, from: nil)
-        @container_name = "#{name[/[[^:].]*/]}.#{SecureRandom.hex(4)}"
-        @built_id = built_id
-
-        @bash_commands          = []
-        @options                = {}
-        @change_options         = {}
-        @service_change_options = {}
-
-        super(name: name, project: project, from: from)
-      end
-
-      def built_id
-        @built_id ||= id
-      end
-
-      def build!
-        run!
-        @built_id = commit!
-      ensure
-        project.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!
-        project.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?
-        project.shellout!("docker run #{prepared_options} #{from.built_id} -ec '#{prepared_bash_command}'", log_verbose: true)
-      rescue Error::Shellout => error
-        project.log_warning(desc: { code: :launched_command, data: { command: prepared_commands.join(' && ') }, context: :container })
-
-        raise unless project.introspect_error? || project.introspect_before_error?
-        built_id = project.introspect_error? ? commit! : from.built_id
-        raise Exception::IntrospectImage, data: { built_id: built_id,
-                                                  options: prepared_options,
-                                                  rmi: project.introspect_error?,
-                                                  error: error }
-      end
-
-      def commit!
-        project.shellout!("docker commit #{prepared_change} #{container_name}").stdout.strip
-      end
-
-      def clone!(name)
-        self.class.new(name: name, project: project, built_id: built_id)
-      end
-    end # Stage
-  end # Image
-end # Dapp