dapp 0.8.0 → 0.9.0

data/lib/dapp/dimg/config/directive/docker/artifact.rb

@@ -0,0 +1,15 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        module Docker
+          class Artifact < Base
+            def _change_options
+              {}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dimg/config/directive/docker/base.rb

@@ -0,0 +1,22 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        module Docker
+          class Base < Directive::Base
+            attr_reader :_from, :_from_cache_version
+
+            def from(image, cache_version: nil)
+              image = image.to_s
+              raise(Error::Config, code: :docker_from_incorrect,
+                                   data: { name: image }) unless ::Dapp::Dimg::Image::Docker.image_name?(image)
+              raise(Error::Config, code: :docker_from_without_tag, data: { name: image }) unless image.include?(':')
+              @_from = image
+              @_from_cache_version = cache_version
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dimg/config/directive/docker/dimg.rb

@@ -0,0 +1,82 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        module Docker
+          class Dimg < Base
+            attr_reader :_volume, :_expose, :_env, :_label, :_cmd, :_onbuild, :_workdir, :_user, :_entrypoint
+
+            def initialize(**kwargs, &blk)
+              @_volume = []
+              @_expose = []
+              @_env = {}
+              @_label = {}
+              @_cmd = []
+              @_onbuild = []
+
+              super(**kwargs, &blk)
+            end
+
+            def volume(*args)
+              @_volume.concat(args)
+            end
+
+            def expose(*args)
+              @_expose.concat(args)
+            end
+
+            def env(**options)
+              @_env.merge!(options)
+            end
+
+            def label(**options)
+              @_label.merge!(options)
+            end
+
+            def cmd(*args)
+              @_cmd.concat(args)
+            end
+
+            def onbuild(*args)
+              @_onbuild.concat(args)
+            end
+
+            def workdir(path)
+              @_workdir = path_format(path)
+            end
+
+            def user(val)
+              @_user = val
+            end
+
+            def entrypoint(*cmd_with_args)
+              @_entrypoint = cmd_with_args.flatten
+            end
+
+            def _change_options
+              {
+                volume: _volume,
+                expose: _expose,
+                env: _env,
+                label: _label,
+                cmd: _cmd,
+                onbuild: _onbuild,
+                workdir: _workdir,
+                user: _user,
+                entrypoint: _entrypoint
+              }
+            end
+
+            protected
+
+            def clone_to_artifact
+              Artifact.new(dapp: dapp).tap do |docker|
+                docker.instance_variable_set('@_from', @_from)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dimg/config/directive/git_artifact_local.rb

@@ -0,0 +1,47 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        class GitArtifactLocal < ArtifactBase
+          alias add export
+          undef_method :export
+
+          class Export < ArtifactBase::Export
+            def stage_dependencies(&blk)
+              @stage_dependencies ||= StageDependencies.new(&blk)
+            end
+
+            def _artifact_options
+              super.merge(stages_dependencies: stage_dependencies.to_h)
+            end
+
+            class StageDependencies < Base
+              STAGES = [:install, :setup, :before_setup, :build_artifact].freeze
+
+              STAGES.each do |stage|
+                define_method(stage) do |*glob|
+                  if (globs = glob.map { |g| path_format(g) }).any? { |g| Pathname(g).absolute? }
+                    raise Error::Config, code: :stages_dependencies_paths_relative_path_required, data: { stage: stage }
+                  end
+                  instance_variable_set(:"@#{stage}", globs)
+                end
+
+                define_method("_#{stage}") do
+                  instance_variable_get(:"@#{stage}") || []
+                end
+              end
+
+              def initialize(&blk)
+                instance_eval(&blk) if block_given?
+              end
+
+              def to_h
+                STAGES.map { |stage| [stage, send("_#{stage}")] }.to_h
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dimg/config/directive/git_artifact_remote.rb

@@ -0,0 +1,58 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        class GitArtifactRemote < GitArtifactLocal
+          attr_reader :_url, :_name, :_branch, :_commit
+
+          def initialize(url, **kwargs, &blk)
+            raise Error::Config, code: :git_artifact_remote_unsupported_protocol,
+                                 data: { url: url } unless %w(http https).include? URI(url.to_s).scheme
+
+            @_url  = url
+            @_name = url.gsub(%r{.*?([^\/ ]+)\.git}, '\\1')
+
+            super(**kwargs, &blk)
+          end
+
+          def _export
+            super do |export|
+              export._url    = @_url
+              export._name   = @_name
+              export._branch ||= @_branch
+              export._commit ||= @_commit
+            end
+          end
+
+          class Export < GitArtifactLocal::Export
+            attr_accessor :_url, :_name, :_branch, :_commit
+
+            def _artifact_options
+              super.merge(name: _name, branch: _branch)
+            end
+
+            protected
+
+            def branch(value)
+              @_branch = value
+            end
+
+            def commit(value)
+              @_commit = value
+            end
+          end
+
+          protected
+
+          def branch(value)
+            @_branch = value
+          end
+
+          def commit(value)
+            @_commit = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dimg/config/directive/mount.rb

@@ -0,0 +1,27 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        class Mount < Base
+          attr_reader :_from, :_to
+          attr_reader :_type
+
+          def initialize(to, **kwargs, &blk)
+            raise Error::Config, code: :mount_to_absolute_path_required unless Pathname((to = to.to_s)).absolute?
+            @_to = path_format(to)
+
+            super(**kwargs, &blk)
+          end
+
+          protected
+
+          def from(type)
+            type = type.to_sym
+            raise Error::Config, code: :mount_from_type_required unless [:tmp_dir, :build_dir].include? type
+            @_type = type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dimg/config/directive/shell/artifact.rb

@@ -0,0 +1,18 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        module Shell
+          class Artifact < Dimg
+            attr_reader :_build_artifact
+            stage_command_generator(:build_artifact)
+
+            def empty?
+              super && _build_artifact_command.empty?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dimg/config/directive/shell/dimg.rb

@@ -0,0 +1,65 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        module Shell
+          class Dimg < Directive::Base
+            attr_reader :_version
+            attr_reader :_before_install, :_before_setup, :_install, :_setup
+
+            def version(value)
+              @_version = value
+            end
+
+            def self.stage_command_generator(stage)
+              define_method stage do |&blk|
+                (variable = instance_variable_get("@_#{stage}") || StageCommand.new(dapp: dapp)).instance_eval(&blk)
+                instance_variable_set("@_#{stage}", variable)
+              end
+
+              define_method "_#{stage}_command" do
+                return [] if (variable = instance_variable_get("@_#{stage}")).nil?
+                variable._run
+              end
+
+              define_method "_#{stage}_version" do
+                return [] if (variable = instance_variable_get("@_#{stage}")).nil?
+                variable._version || _version
+              end
+            end
+            [:before_install, :before_setup, :install, :setup].each(&method(:stage_command_generator))
+
+            class StageCommand < Directive::Base
+              attr_reader :_version
+              attr_reader :_run
+
+              def initialize(**kwargs, &blk)
+                @_run = []
+
+                super(**kwargs, &blk)
+              end
+
+              def run(*args)
+                @_run.concat(args)
+              end
+
+              def version(value)
+                @_version = value
+              end
+            end
+
+            protected
+
+            def empty?
+              (_before_install_command + _before_setup_command + _install_command + _setup_command).empty?
+            end
+
+            def clone_to_artifact
+              _clone_to Artifact.new(dapp: dapp)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dimg/dapp/command.rb

@@ -0,0 +1,21 @@
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Common)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Run)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Build)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Bp)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Push)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Spush)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Tag)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::List)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Stages::CleanupLocal)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Stages::CleanupRepo)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Stages::FlushLocal)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Stages::FlushRepo)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Stages::Push)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Stages::Pull)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Stages::Common)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Cleanup)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Mrproper)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::StageImage)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::BuildContext::Import)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::BuildContext::Export)
+::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::BuildContext::Common)

data/lib/dapp/dimg/dapp/command/bp.rb

@@ -0,0 +1,20 @@
+module Dapp
+  module Dimg
+    class Dapp
+      module Command
+        module Bp
+          def bp(repo)
+            bp_step(:build)
+            bp_step(:push, repo)
+            bp_step(:stages_cleanup_by_repo, repo)
+            bp_step(:cleanup)
+          end
+
+          def bp_step(step, *args)
+            log_step_with_indent(step) { send(step, *args) }
+          end
+        end
+      end
+    end
+  end # Dimg
+end # Dapp

data/lib/dapp/dimg/dapp/command/build.rb

@@ -0,0 +1,22 @@
+module Dapp
+  module Dimg
+    class Dapp
+      module Command
+        module Build
+          def build
+            setup_ssh_agent
+
+            build_configs.each do |config|
+              log_dimg_name_with_indent(config) do
+                Dimg.new(config: config, dapp: self).build!
+              end
+            end
+          rescue ::Dapp::Error::Shellout, Error::Base
+            build_context_export unless cli_options[:build_context_directory].nil?
+            raise
+          end
+        end
+      end
+    end
+  end # Dimg
+end # Dapp

data/lib/dapp/dimg/dapp/command/build_context/common.rb

@@ -0,0 +1,27 @@
+module Dapp
+  module Dimg
+    class Dapp
+      module Command
+        module BuildContext
+          module Common
+            def build_context_images_tar
+              build_context_path('images.tar')
+            end
+
+            def build_context_build_tar
+              build_context_path('build.tar')
+            end
+
+            def build_context_path(*path)
+              path.compact.map(&:to_s).inject(Pathname.new(build_context_directory), &:+).tap { |p| p.parent.mkpath }
+            end
+
+            def build_context_directory
+              File.expand_path(cli_options[:build_context_directory].to_s)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dimg/dapp/command/build_context/export.rb

@@ -0,0 +1,55 @@
+module Dapp
+  module Dimg
+    class Dapp
+      module Command
+        module BuildContext
+          module Export
+            def build_context_export
+              log_process(:'export context') do
+                with_log_indent do
+                  export_build_context_image_tar
+                  export_build_context_build_tar
+                end
+              end
+            end
+
+            def export_build_context_image_tar
+              lock("#{name}.images", readonly: true) do
+                context_images_names = build_configs.map do |config|
+                  Dimg.new(config: config, dapp: self).tagged_images.map(&:name)
+                end.flatten
+
+                log_secondary_process(:images, short: true) do
+                  Image::Docker.save!(context_images_names, build_context_images_tar)
+                end unless context_images_names.empty?
+              end
+            end
+
+            def export_build_context_build_tar
+              log_secondary_process(:build_dir, short: true) do
+                File.open(build_context_build_tar, File::RDWR | File::CREAT) do |f|
+                  Gem::Package::TarWriter.new(f) do |tar|
+                    Dir.glob(File.join(build_path, '**/*'), File::FNM_DOTMATCH).each do |path|
+                      archive_file_path = path
+                                            .reverse
+                                            .chomp(build_path.to_s.reverse)
+                                            .chomp('/')
+                                            .reverse
+                      if File.directory?(path)
+                        tar.mkdir archive_file_path, File.stat(path).mode
+                      else
+                        tar.add_file archive_file_path, File.stat(path).mode do |tf|
+                          tf.write File.read(path)
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end