dapp 0.32.10 → 0.33.0

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

@@ -13,6 +13,17 @@ module Dapp
           @name = name
         end
 
+        def get_ruby2go_state_hash
+          {
+            "Dapp" => dapp.get_ruby2go_state_hash,
+            "Name" => @name.to_s,
+          }
+        end
+
+        def set_ruby2go_state_hash(state)
+          @name = state["Name"]
+        end
+
         def exclude_paths
           []
         end

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

@@ -9,6 +9,20 @@ module Dapp
           self.path = path
         end
 
+        def get_ruby2go_state_hash
+          super.tap {|res|
+            p = @path.to_s
+            p = File.dirname(@path) if File.basename(@path) == ".git"
+            res["Path"] = p
+            res["OrigPath"] = @path.to_s
+          }
+        end
+
+        def set_ruby2go_state_hash(state)
+          super(state)
+          @path = state["OrigPath"]
+        end
+
         def path=(path)
           @path ||= Pathname(Rugged::Repository.new(path).path)
         rescue Rugged::RepositoryError, Rugged::OSError => _e

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

@@ -8,7 +8,7 @@ module Dapp
 
         class << self
           def get_or_create(dapp, name, url:)
-            repositories[url] ||= new(dapp, name, url: url).tap(&:fetch!)
+            repositories[url] ||= new(dapp, name, url: url).tap(&:clone_and_fetch)
           end
 
           def repositories
@@ -20,20 +20,29 @@ module Dapp
           super(dapp, name)
 
           @url = url
+        end
 
-          _with_lock do
-            dapp.log_secondary_process(dapp.t(code: 'process.git_artifact_clone', data: { url: url }), short: true) do
-              begin
-                if [:https, :ssh].include?(remote_origin_url_protocol) && !Rugged.features.include?(remote_origin_url_protocol)
-                  raise Error::Rugged, code: :rugged_protocol_not_supported, data: { url: url, protocol: remote_origin_url_protocol }
-                end
-
-                Rugged::Repository.clone_at(url, path.to_s, bare: true, credentials: _rugged_credentials)
-              rescue Rugged::NetworkError, Rugged::SslError, Rugged::OSError, Rugged::SshError => e
-                raise Error::Rugged, code: :rugged_remote_error, data: { message: e.message, url: url }
-              end
-            end
-          end unless path.directory?
+        def ruby2go_method(method, args_hash={})
+          res = dapp.ruby2go_git_repo(args_hash.merge("RemoteGitRepo" => JSON.dump(get_ruby2go_state_hash), "method" => method))
+
+          raise res["error"] if res["error"]
+
+          self.set_ruby2go_state_hash(JSON.load(res["data"]["RemoteGitRepo"]))
+
+          res["data"]["result"]
+        end
+
+        def get_ruby2go_state_hash
+          super.tap {|res|
+            res["Url"] = @url.to_s
+            res["ClonePath"] = dapp.build_path("remote_git_repo", CACHE_VERSION.to_s, dapp.consistent_uniq_slugify(name), remote_origin_url_protocol).to_s # FIXME
+            res["IsDryRun"] = dapp.dry_run?
+          }
+        end
+
+        def set_ruby2go_state_hash(state)
+          super(state)
+          @url = state["Url"]
         end
 
         def _with_lock(&blk)
@@ -54,26 +63,8 @@ module Dapp
           Pathname(dapp.build_path("remote_git_repo", CACHE_VERSION.to_s, dapp.consistent_uniq_slugify(name), remote_origin_url_protocol).to_s)
         end
 
-        def fetch!
-          _with_lock do
-            cfg_path = path.join("config")
-            cfg = IniFile.load(cfg_path)
-            remote_origin_cfg = cfg['remote "origin"']
-
-            old_url = remote_origin_cfg["url"]
-            if old_url and old_url != url
-              remote_origin_cfg["url"] = url
-              cfg.write(filename: cfg_path)
-            end
-
-            dapp.log_secondary_process(dapp.t(code: 'process.git_artifact_fetch', data: { url: url }), short: true) do
-              begin
-                git.remotes.each { |remote| remote.fetch(credentials: _rugged_credentials) }
-              rescue Rugged::SshError, Rugged::NetworkError => e
-                raise Error::Rugged, code: :rugged_remote_error, data: { url: url, message: e.message.strip }
-              end
-            end
-          end unless dapp.dry_run?
+        def clone_and_fetch
+          return ruby2go_method("CloneAndFetch")
         end
 
         def latest_branch_commit(branch)

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

@@ -11,11 +11,11 @@ module Dapp
         end
 
         def add_change_env(**options)
-          add_change_option(:env, options)
+          (change_options[:env] ||= {}).merge!(options)
         end
 
         def add_change_label(**options)
-          add_change_option(:label, options)
+          (change_options[:label] ||= {}).merge!(options)
         end
 
         def add_change_cmd(value)
@@ -31,19 +31,19 @@ module Dapp
         end
 
         def add_change_workdir(value)
-          add_change_option(:workdir, value)
+          change_options[:workdir] = value
         end
 
         def add_change_user(value)
-          add_change_option(:user, value)
+          change_options[:user] = value
         end
 
         def add_service_change_label(**options)
-          add_service_change_option(:label, options)
+          (service_change_options[:label] ||= {}).merge!(options)
         end
 
-        def add_env(var, value)
-          add_option(:env, "#{var}=#{value}")
+        def add_env(**options)
+          (self.options[:env] ||= {}).merge!(options)
         end
 
         def add_volume(value)
@@ -65,10 +65,12 @@ module Dapp
         def prepare_instructions(options)
           options.map do |key, vals|
             case key
+            when :workdir, :user
+              [vals]
             when :cmd, :entrypoint
               vals = [''] if vals == [] && ::Dapp::Dapp.host_docker_minor_version >= Gem::Version.new('17.10')
               [vals]
-            when :env, :label then vals.map(&method(:options_to_args)).flatten
+            when :env, :label then options_to_args(vals)
             else vals
             end.map { |val| %(#{key.to_s.upcase} #{val}) }
           end.flatten
@@ -77,7 +79,8 @@ module Dapp
         protected
 
         attr_reader :bash_commands, :service_bash_commands
-        attr_reader :change_options, :service_change_options
+        attr_reader :change_options
+        attr_reader :service_change_options
         attr_reader :options
 
         def add_option(key, value)
@@ -96,58 +99,9 @@ module Dapp
           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] = from.config_option(option.to_s.capitalize) || []
-          end.tap do |options|
-            workdir = from.config_option('WorkingDir')
-            options[:workdir] = Array((workdir || '').empty? ? '/' : workdir)
-          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.in_depth_merge(options)
-        end
-
-        def all_bash_commands
-          Array(bash_commands) + Array(service_bash_commands)
-        end
-
-        def service_options
-          {
-            workdir: '/',
-            entrypoint: dapp.bash_bin,
-            name: container_name,
-            user: '0:0',
-            :'volumes-from' => [dapp.base_container, dapp.toolchain_container]
-          }
-        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

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

@@ -1,11 +1,59 @@
 module Dapp
   module Dimg
     module Image
-      class Stage < Docker
+      class Stage
         include Argument
 
+        attr_reader :from
+        attr_reader :name
+        attr_reader :dapp
+
+        class << self
+          def image_by_name(name:, **kwargs)
+            images[name] ||= new(name: name, **kwargs)
+          end
+
+          def image_reset(name)
+            images.delete(name)
+          end
+
+          def images
+            @images ||= {}
+          end
+
+          def image_name_format
+            "#{DockerRegistry.repo_name_format}(:(?<tag>#{tag_format}))?"
+          end
+
+          def tag_format
+            '(?![-.])[a-zA-Z0-9_.-]{1,127}'
+          end
+
+          def image_name?(name)
+            !(/^#{image_name_format}$/ =~ name).nil?
+          end
+
+          def tag?(name)
+            !(/^#{tag_format}$/ =~ name).nil?
+          end
+
+          def save!(dapp, image_or_images, file_path, verbose: false, quiet: false)
+            ruby2go_command(dapp, command: :save, options: { images: Array(image_or_images), file_path: file_path })
+          end
+
+          def load!(dapp, file_path, verbose: false, quiet: false)
+            ruby2go_command(dapp, command: :load, options: { file_path: file_path })
+          end
+
+          def ruby2go_command(dapp, command:, **options)
+            dapp.ruby2go_image({ command: command }.merge(options)).tap do |res|
+              raise Error::Build, code: :ruby2go_image_command_failed_unexpected_error, data: { command: command, message: res["error"] } unless res["error"].nil?
+              break res['data']
+            end
+          end
+        end
+
         def initialize(name:, dapp:, built_id: nil, from: nil)
-          @container_name = "dapp.build.#{SecureRandom.hex(4)}"
           @built_id = built_id
 
           @bash_commands          = []
@@ -14,79 +62,190 @@ module Dapp
           @change_options         = {}
           @service_change_options = {}
 
-          super(name: name, dapp: dapp, from: from)
+          @from = from
+          @name = name
+          @dapp = dapp
+        end
+
+        def tagged?
+          not image_inspect.empty?
+        end
+
+        def built?
+          !built_id.nil?
         end
 
         def built_id
           @built_id ||= id
         end
 
+        def id
+          image_inspect["Id"]
+        end
+
+        def labels
+          built_image_inspect!.fetch('Config', {}).fetch('Labels', {})
+        end
+
+        def created_at
+          built_image_inspect!["Created"]
+        end
+
+        def size
+          Float(built_image_inspect!["Size"])
+        end
+
+        def built_image_inspect!
+          built_image_inspect
+        end
+
+        def built_image_inspect
+          @built_image_inspect || image_inspect
+        end
+
+        def reset_image_inspect
+          @image_inspect = nil
+        end
+
+        def image_inspect
+          ruby2go_command(:inspect, extended_image_option: false) if @image_inspect.nil?
+          @image_inspect
+        end
+
+        def pull!
+          dapp.log_secondary_process(dapp.t(code: 'process.image_pull', data: { name: name })) do
+            ruby2go_command(:pull)
+          end
+        end
+
+        def push!
+          dapp.log_secondary_process(dapp.t(code: 'process.image_push', data: { name: name })) do
+            ruby2go_command(:push)
+          end
+        end
+
         def build!
-          run!
-          @built_id = commit!
-        ensure
-          dapp.shellout("#{dapp.host_docker} rm #{container_name}")
+          res = self.dapp.ruby2go_image(**ruby2go_image_build_options)
+          if res["error"].nil?
+            set_ruby2go_state_hash(JSON.load(res['data']['image']))
+          elsif res["error"].start_with? "container run failed"
+            raise Error::Build, code: :ruby2go_image_command_failed, data: { command: "build" }
+          else
+            raise Error::Build, code: :ruby2go_image_command_failed_unexpected_error, data: { command: "build", message: res["error"] }
+          end
         end
 
-        def built?
-          !built_id.nil?
+        def ruby2go_image_build_options
+          {
+            image: ruby2go_image_option,
+            command: :build,
+            options: {
+              introspection: {
+                before: dapp.introspect_before_error?,
+                after: dapp.introspect_error?
+              }
+            }
+          }
+        end
+
+        def introspect!
+          ruby2go_command(:introspect)
         end
 
         def export!(name)
-          tag!(name).tap do |image|
-            image.push!
-            image.untag!
-          end
+          ruby2go_command(:export, options: { name: name })
         end
 
         def tag!(name)
-          clone!(name).tap do |image|
-            self.class.tag!(id: image.built_id, tag: image.name)
-          end
+          ruby2go_command(:tag, options: { name: name })
         end
 
         def import!(name)
-          clone!(name).tap do |image|
-            image.pull!
-            @built_id = image.built_id
-            save_in_cache!
-            image.untag!
-          end
+          ruby2go_command(:import, options: { name: name })
         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)
+          ruby2go_command(:save_in_cache)
         end
 
-        def labels
-          config_option('Labels')
+        def untag!
+          ruby2go_command(:untag)
         end
 
-        protected
+        def ruby2go_command(command, extended_image_option: true, options: {})
+          command_options = ruby2go_command_options(command, extended_image_option: extended_image_option).in_depth_merge(options: options)
+          self.class.ruby2go_command(dapp, **command_options).tap do |data|
+            set_ruby2go_state_hash(JSON.load(data['image']))
+          end
+        end
 
-        attr_reader :container_name
+        def ruby2go_command_options(command, extended_image_option: true)
+          image = begin
+            if extended_image_option
+              ruby2go_image_option
+            else
+              JSON.dump({name: name})
+            end
+          end
 
-        def run!
-          raise Error::Build, code: :built_id_not_defined if from.built_id.nil?
-          dapp.shellout!("#{dapp.host_docker} run #{prepared_options} #{from.built_id} -ec '#{prepared_bash_command}'", verbose: true)
-        rescue ::Dapp::Error::Shellout => error
-          dapp.log_warning(desc: { code: :launched_command, data: { command: prepared_commands.join(' && ') }, context: :container })
+          {
+            image: image,
+            command: command,
+          }
+        end
 
-          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 }
+        def ruby2go_image_option
+          JSON.dump(get_ruby2go_state_hash)
         end
 
-        def commit!
-          dapp.shellout!("#{dapp.host_docker} commit #{prepared_change} #{container_name}").stdout.strip
+        def get_ruby2go_state_hash
+          [
+            :name,
+            :from,
+            :built_id,
+            :built_image_inspect,
+            :image_inspect,
+            :bash_commands,
+            :service_bash_commands,
+            :options,
+            :change_options,
+            :service_change_options,
+          ].map do |name|
+            if name == :from
+              [name, from.get_ruby2go_state_hash] unless from.nil?
+            elsif name == :built_image_inspect && built_image_inspect.empty?
+            elsif name == :image_inspect && image_inspect.empty?
+            else
+              [name, send(name)]
+            end
+          end
+            .compact
+            .to_h
         end
 
-        def clone!(name)
-          self.class.new(name: name, dapp: dapp, built_id: built_id)
+        def set_ruby2go_state_hash(state_hash)
+          state_hash.each do |name, value|
+            variable = "@#{name}".to_sym
+
+            case name
+            when "from"
+              from.set_ruby2go_state_hash(value) unless from.nil? || value.nil?
+            when "built_id"
+              if value.to_s.empty?
+                @built_id = nil
+              else
+                @built_id = value
+              end
+            when "image_inspect"
+              instance_variable_set(variable, (value || {}))
+            when "options", "change_options", "service_change_options"
+              instance_variable_set(variable, (value || {}).reject { |_, v| v.nil? || v.empty? }.symbolize_keys)
+            when "bash_commands", "service_bash_commands"
+              instance_variable_set(variable, value || [])
+            else
+              instance_variable_set(variable, value)
+            end
+          end
         end
       end # Stage
     end # Image