dapp 0.10.2 → 0.36.24

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

@@ -18,7 +18,7 @@ module Dapp
             sub_directive_eval { @_group = group }
           end
 
-          def export(absolute_dir_path = '/', &blk)
+          def export(absolute_dir_path = nil, &blk)
             self.class.const_get('Export').new(absolute_dir_path, dapp: dapp, &blk).tap do |export|
               @_export << export
             end
@@ -36,9 +36,8 @@ module Dapp
           class Export < Directive::Base
             attr_accessor :_cwd, :_to, :_include_paths, :_exclude_paths, :_owner, :_group
 
-            def initialize(cwd = '/', **kwargs, &blk)
-              raise Error::Config, code: :export_cwd_absolute_path_required unless Pathname(cwd).absolute?
-              @_cwd = path_format(cwd)
+            def initialize(cwd, **kwargs, &blk)
+              self._cwd = cwd
               @_include_paths ||= []
               @_exclude_paths ||= []
 
@@ -56,9 +55,15 @@ module Dapp
               }
             end
 
+            def _cwd=(value)
+              return if value.nil?
+              raise ::Dapp::Error::Config, code: :export_cwd_absolute_path_required unless Pathname(value).absolute?
+              @_cwd = path_format(value)
+            end
+
             def to(absolute_path)
               sub_directive_eval do
-                raise Error::Config, code: :export_to_absolute_path_required unless Pathname(absolute_path).absolute?
+                raise ::Dapp::Error::Config, code: :export_to_absolute_path_required unless Pathname(absolute_path).absolute?
                 @_to = path_format(absolute_path)
               end
             end
@@ -66,7 +71,7 @@ module Dapp
             def include_paths(*relative_paths)
               sub_directive_eval do
                 unless relative_paths.all? { |path| Pathname(path).relative? }
-                  raise Error::Config, code: :export_include_paths_relative_path_required
+                  raise ::Dapp::Error::Config, code: :export_include_paths_relative_path_required
                 end
                 _include_paths.concat(relative_paths.map(&method(:path_format)))
               end
@@ -75,7 +80,7 @@ module Dapp
             def exclude_paths(*relative_paths)
               sub_directive_eval do
                 unless relative_paths.all? { |path| Pathname(path).relative? }
-                  raise Error::Config, code: :export_exclude_paths_relative_path_required
+                  raise ::Dapp::Error::Config, code: :export_exclude_paths_relative_path_required
                 end
                 _exclude_paths.concat(relative_paths.map(&method(:path_format)))
               end
@@ -90,7 +95,7 @@ module Dapp
             end
 
             def validate!
-              raise Error::Config, code: :export_to_required if _to.nil?
+              raise ::Dapp::Error::Config, code: :export_to_required if _to.nil?
             end
           end
         end

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

@@ -0,0 +1,12 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        class ArtifactDimg < Dimg
+          def validate_scratch!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        class ArtifactGroup < DimgGroup
+          attr_reader :_name
+
+          def initialize(name = nil, dapp:)
+            super(dapp: dapp)
+            @_name = name
+          end
+
+          def export(*args, &blk)
+            _artifact_export(_artifact_config, *args, &blk)
+          end
+
+          def _artifact_config
+            artifact_config_name = "artifact-#{[_name, SecureRandom.hex(2)].compact.join('-')}"
+            pass_to(ArtifactDimg.new(artifact_config_name, dapp: dapp))
+          end
+
+          def _artifact_export(artifact_config, *args, &blk)
+            artifact = Artifact.new(dapp: dapp, config: artifact_config)
+            artifact.export(*args, &blk).tap do
+              _export.concat artifact._export
+            end
+          end
+
+          def _shell(&blk)
+            @_shell ||= Shell::Artifact.new(dapp: dapp, &blk)
+          end
+
+          def _docker(&blk)
+            @_docker ||= Docker::Artifact.new(dapp: dapp, &blk)
+          end
+
+          def _export
+            @_export ||= []
+          end
+
+          def validate!
+            _export.each(&:validate!)
+          end
+
+          undef :artifact
+          undef :dimg
+          undef :dimg_group
+
+          protected
+
+          def check_dimg_directive_order(_directive)
+          end
+
+          def check_dimg_group_directive_order(_directive)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,203 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        class Dimg < Base
+          module InstanceMethods
+            attr_reader :_builder
+            attr_reader :_chef, :_shell, :_docker, :_git_artifact, :_mount, :_artifact, :_ansible
+            attr_reader :_artifact_groups
+            attr_reader :_from_dimg, :_from_dimg_artifact
+
+            def chef(&blk)
+              builder(:chef)
+              directive_eval(_chef, &blk)
+            end
+
+            def shell(&blk)
+              builder(:shell)
+              directive_eval(_shell, &blk)
+            end
+
+            def docker(&blk)
+              directive_eval(_docker, &blk)
+            end
+
+            def artifact(name = nil, &blk)
+              pass_to(ArtifactGroup.new(name, dapp: dapp), :clone_to_artifact).tap do |artifact_group|
+                _context_artifact_groups << directive_eval(artifact_group, &blk)
+                dapp.artifact_config(name, artifact_group._artifact_config) unless name.nil?
+              end
+            end
+
+            def import(name, from = nil, &blk)
+              ArtifactGroup.new(dapp: dapp).tap do |artifact_group|
+                artifact_group._artifact_export(dapp.artifact_config_by_name(name), from, &blk)
+                _context_artifact_groups << artifact_group
+              end
+            end
+
+            def git(url = nil, &blk)
+              type = url.nil? ? :local : :remote
+              _git_artifact.public_send(type, url.to_s, &blk)
+            end
+
+            def mount(to, &blk)
+              Mount.new(to, dapp: dapp, &blk).tap do |mount|
+                _mount << mount
+              end
+            end
+
+            def _builder
+              @_builder || :none
+            end
+
+            def _chef
+              @_chef ||= Chef.new(dapp: dapp)
+            end
+
+            def _shell
+              @_shell ||= Shell::Dimg.new(dapp: dapp)
+            end
+
+            def _docker
+              @_docker ||= Docker::Dimg.new(dapp: dapp)
+            end
+
+            def _mount
+              @_mount ||= []
+            end
+
+            def _git_artifact
+              @_git_artifact ||= GitArtifact.new(dapp: dapp)
+            end
+
+            [:build_dir, :tmp_dir, :custom_dir].each do |mount_type|
+              define_method "_#{mount_type}_mount" do
+                _mount.select { |m| m._type == mount_type }
+              end
+            end
+
+            def _artifact_groups
+              @_artifact_groups ||= []
+            end
+
+            def _context_artifact_groups
+              @_context_artifact_groups ||= []
+            end
+
+            def _artifact
+              [_artifact_groups, _context_artifact_groups].flatten.map(&:_export).flatten
+            end
+
+            [:before, :after].each do |order|
+              [:setup, :install].each do |stage|
+                define_method "_#{order}_#{stage}_artifact" do
+                  _artifact.select do |art|
+                    art.public_send("_#{order}") == stage
+                  end
+                end
+              end
+            end
+
+            def _import_artifact
+              _artifact.select(&:not_associated?)
+            end
+
+            class GitArtifact < Base
+              attr_reader :_local, :_remote
+
+              def initialize(**kwargs, &blk)
+                @_local = []
+                @_remote = []
+
+                super(**kwargs, &blk)
+              end
+
+              def local(_, &blk)
+                GitArtifactLocal.new(dapp: dapp, &blk).tap do |git|
+                  @_local << git
+                end
+              end
+
+              def remote(repo_url, &blk)
+                GitArtifactRemote.new(repo_url, dapp: dapp, &blk).tap do |git|
+                  @_remote << git
+                end
+              end
+
+              def _local
+                @_local.map(&:_export).flatten
+              end
+
+              def _remote
+                @_remote.map(&:_export).flatten
+              end
+
+              def empty?
+                (_local + _remote).empty?
+              end
+
+              def validate!
+                (_local + _remote).each(&:validate!)
+              end
+            end
+
+            def artifacts_after_parsing!
+              _artifacts_auto_excluding!
+              _artifact.map(&:_config).each(&:artifacts_after_parsing!)
+            end
+
+            protected
+
+            def builder(type)
+              @_builder = type if _builder == :none
+              raise ::Dapp::Error::Config, code: :builder_type_conflict unless @_builder == type
+            end
+
+            def passed_directives
+              [:@_chef, :@_shell, :@_docker, :@_git_artifact, :@_mount, :@_artifact_groups, :@_builder]
+            end
+
+            def _artifacts_auto_excluding!
+              path_to_relative = proc { |path| path.reverse.chomp('/').reverse }
+
+              all_artifacts.reduce({}) do |hash, artifact|
+                unless artifact._to.nil?
+                  to_common = artifact._to[/^\/[^\/]*/]
+                  hash[to_common] ||= []
+                  hash[to_common] << artifact
+                end
+                hash
+              end.each do |to_common, artifacts|
+                include_paths_common = artifacts.reduce([]) do |arr, artifact|
+                  arr << artifact._to.sub(to_common, '')
+                  arr.concat(artifact._include_paths.map { |path| File.join(artifact._to.sub(to_common, ''), path) } )
+                  arr
+                end.map(&path_to_relative).uniq
+
+                artifacts.each do |artifact|
+                  artifact_include_shift = path_to_relative.call(artifact._to.sub(to_common, ''))
+
+                  include_paths_common.each do |path|
+                    next if artifact_include_shift.start_with? path
+
+                    path = path_to_relative.call(path.sub(artifact_include_shift, ''))
+                    unless artifact._include_paths.any? { |ipath| ipath.start_with? path } || artifact._exclude_paths.any? { |epath| path.start_with? epath }
+                      artifact._exclude_paths << path
+                    end
+                  end
+                end
+              end
+            end
+
+            def all_artifacts
+              _artifact + _git_artifact._local + _git_artifact._remote
+            end
+          end # InstanceMethods
+          # rubocop:enable Metrics/ModuleLength
+        end # Dimg
+      end # Directive
+    end # Config
+  end # Dimg
+end # Dapp

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

@@ -0,0 +1,217 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        class Dimg < Base
+          module Validation
+            include Helper::Trivia
+
+            def validate!
+              directives_validate!
+              validate_scratch!
+              validate_artifacts!
+              validate_artifacts_artifacts!
+            end
+
+            protected
+
+            def validate_scratch!
+              if _docker._from.nil? && _from_dimg.nil? && _from_dimg_artifact.nil?
+                validate_scratch_directives!
+                validate_scratch_artifacts!
+              else
+                raise ::Dapp::Error::Config, code: :stage_artifact_not_associated unless _import_artifact.empty?
+              end
+            end
+
+            def directives_validate!
+              passed_directives.each do |v|
+                next if (value = instance_variable_get(v)).nil?
+                Array(value).each do |elm|
+                  elm.validate! if elm.respond_to?(:validate!)
+                end
+              end
+              _context_artifact_groups.each(&:validate!)
+              _mount.map(&:_to).tap do |mounts_points|
+                mounts_points.each do |path|
+                  raise ::Dapp::Error::Config, code: :mount_duplicate_to, data: { path: path } if mounts_points.count(path) > 1
+                end
+              end
+            end
+
+            def validate_scratch_directives!
+              directives = [[:_shell, :shell], [:_chef, :chef], [:_git_artifact, :git],
+                            [:_tmp_dir_mount, :mount], [:_build_dir_mount, :mount], [:_custom_dir_mount, :mount]]
+              directives.each do |name, user_name|
+                raise ::Dapp::Error::Config, code: :scratch_unsupported_directive,
+                                             data: { directive: user_name } unless public_send(name).empty?
+              end
+
+              docker_directives = [:_expose, :_env, :_cmd, :_onbuild, :_workdir, :_user, :_entrypoint]
+              docker_directives.each do |directive|
+                value = _docker.public_send(directive)
+                raise ::Dapp::Error::Config, code: :scratch_unsupported_directive,
+                                             data: { directive: "docker.#{directive}" } unless value.nil? || value.empty?
+              end
+            end
+
+            def validate_scratch_artifacts!
+              raise ::Dapp::Error::Config, code: :scratch_artifact_associated unless _associated_artifacts.empty?
+              raise ::Dapp::Error::Config, code: :scratch_artifact_required if _import_artifact.empty?
+              _import_artifact.each do |artifact|
+                raise ::Dapp::Error::Config, code: :scratch_artifact_docker_from if artifact._config._docker._from.nil?
+              end
+            end
+
+            def validate_artifacts_artifacts!
+              _artifact.each { |artifact_dimg| artifact_dimg._config.validate! }
+            end
+
+            def validate_artifacts!
+              artifacts = validate_artifact_format(all_artifacts)
+              loop do
+                break if artifacts.empty?
+                verifiable_artifact = artifacts.shift
+                artifacts.each do |artifact|
+                  next if verifiable_artifact[:index] == artifact[:index]
+                  begin
+                    validate_artifact!(verifiable_artifact, artifact)
+                    validate_artifact!(artifact, verifiable_artifact)
+                  rescue ::Dapp::Error::Config => e
+                    conflict_between_artifacts!(artifact, verifiable_artifact) if e.net_status[:code] == :artifact_conflict
+                    raise
+                  end
+                end
+              end
+            end
+
+            def conflict_between_artifacts!(*formatted_artifacts)
+              artifacts = formatted_artifacts.flatten.map { |formatted_artifact| formatted_artifact[:related_artifact] }
+              artifact_imports = []
+              git_artifacts    = []
+              artifacts.map do |artifact|
+                (artifact.is_a?(Artifact::Export) ? artifact_imports : git_artifacts) << artifact
+              end
+
+              common_artifact_dsl = proc do |a|
+                [].tap do |context|
+                  context << "  to '#{a._to}'"
+                  [:include_paths, :exclude_paths].each do |directive|
+                    next if (paths = a.send("_#{directive}")).empty?
+                    context << "  #{directive} '#{paths.join("', '")}'"
+                  end
+                end
+              end
+
+              import_dsl = proc do |ga|
+                [].tap do |context|
+                  context << "artifact.export('#{ga._cwd}') do"
+                  context.concat(common_artifact_dsl.call(ga))
+                  context << 'end'
+                end
+              end
+
+              git_artifact_dsl = proc do |ga|
+                [].tap do |context|
+                  context << "git#{"('#{ga._url}')" if ga.respond_to?(:_url)}.add('#{ga._cwd}') do"
+                  context.concat(common_artifact_dsl.call(ga))
+                  context << 'end'
+                end
+              end
+
+              common_artifact_yaml = proc do |a|
+                [].tap do |context|
+                  context << "  to: #{a._to}"
+                  {
+                    include_paths: 'includePaths',
+                    exclude_paths: 'excludePaths',
+                  }.each do |directive, yamlDirective|
+                    next if (paths = a.send("_#{directive}")).empty?
+                    context << "  #{yamlDirective}: [#{paths.join(", ")}]"
+                  end
+                end
+              end
+
+              import_yaml = proc do |a|
+                [].tap do |context|
+                  context << "- artifact: #{a._config._name}"
+                  context << "  add: #{a._cwd}"
+                  context.concat(common_artifact_yaml.call(a))
+                end
+              end
+
+              git_artifact_yaml = proc do |ga|
+                [].tap do |context|
+                  if ga.respond_to?(:_url)
+                    context << "- url: #{ga._url}"
+                    context << "  add: #{ga._cwd}"
+                  else
+                    context << "- add: #{ga._cwd}"
+                  end
+                  context.concat(common_artifact_yaml.call(ga))
+                end
+              end
+
+              dappfile_context = [].tap do |msg|
+                if artifact_imports.count != 0
+                  if dapp
+                    artifact_imports.each { |a| msg.concat(import_dsl.call(a)) }
+                  else
+                    msg << 'import:'
+                    artifact_imports.each { |a| msg.concat(import_yaml.call(a)) }
+                  end
+                end
+
+                if git_artifacts.count != 0
+                  if dapp
+                    git_artifacts.each { |a| msg.concat(git_artifact_dsl.call(a)) }
+                  else
+                    msg << 'git:'
+                    git_artifacts.each { |a| msg.concat(git_artifact_yaml.call(a)) }
+                  end
+                end
+              end.join("\n")
+              raise ::Dapp::Error::Config, code: :artifact_conflict, data: { dappfile_context: dappfile_context }
+            end
+
+            def validate_artifact_format(artifacts)
+              artifacts.map do |a|
+                include_paths = begin
+                  if a._include_paths.empty?
+                    [a._to]
+                  else
+                    a._include_paths.dup.map { |p| File.join(a._to, p) }
+                  end
+                end
+
+                {
+                  index: artifacts.index(a),
+                  include_paths: include_paths,
+                  exclude_paths: a._exclude_paths.dup.map { |p| File.join(a._to, p) },
+                  related_artifact: a
+                }
+              end
+            end
+
+            def validate_artifact!(verifiable_artifact, artifact)
+              cases = []
+              cases << verifiable_artifact[:include_paths].any? do |verifiable_path|
+                !ignore_path?(verifiable_path, paths: artifact[:include_paths], exclude_paths: artifact[:exclude_paths])
+              end
+              cases << (verifiable_artifact[:include_paths].empty? && artifact[:include_paths].empty?)
+
+              raise ::Dapp::Error::Config, code: :artifact_conflict if cases.any?
+            end
+
+            def _associated_artifacts
+              _artifact.select do |art|
+                !(art._before.nil? && art._after.nil?)
+              end
+            end
+          end # Validation
+          # rubocop:enable Metrics/ModuleLength
+        end # Dimg
+      end # Directive
+    end # Config
+  end # Dimg
+end # Dapp

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

@@ -0,0 +1,36 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        class Dimg < Base
+          include Validation
+          include InstanceMethods
+
+          attr_reader :_name
+
+          def initialize(name, dapp:)
+            self._name = name
+            super(dapp: dapp)
+          end
+
+          def _name=(name)
+            sub_directive_eval do
+              return self if name.nil?
+              name = name.to_s
+              validate_compliance!(dimg_name_pattern, name, :dimg_name_incorrect)
+              @_name = name
+            end
+          end
+
+          protected
+
+          def dimg_name_pattern
+            separator = '[_\.]|(__)|(-*)'
+            alpha_numeric = '[a-z0-9]'
+            "^#{alpha_numeric}(#{separator}#{alpha_numeric})*$"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        class DimgGroup < Base
+          include DimgGroupBase
+          include Dimg::InstanceMethods
+
+          def chef(&blk)
+            check_dimg_directive_order(:chef)
+            super
+          end
+
+          def shell(&blk)
+            check_dimg_directive_order(:shell)
+            super
+          end
+
+          def docker(&blk)
+            check_dimg_directive_order(:docker)
+            super
+          end
+
+          def artifact(name = nil, &blk)
+            check_dimg_group_directive_order(:artifact)
+            super
+          end
+
+          def git(url = nil, &blk)
+            check_dimg_directive_order(:git)
+            super
+          end
+
+          def mount(to, &blk)
+            check_dimg_directive_order(:mount)
+            super
+          end
+
+          protected
+
+          def before_dimg_eval(dimg)
+            before_eval_base(dimg)
+          end
+
+          def before_dimg_group_eval(dimg_group)
+            before_eval_base(dimg_group)
+          end
+
+          def before_eval_base(obj)
+            pass_to(obj)
+            pass_context_artifact_groups_to(obj)
+          end
+
+          def pass_context_artifact_groups_to(obj)
+            obj.instance_variable_set(:@_artifact_groups, [obj._artifact_groups, clone_variable(_context_artifact_groups)].flatten)
+          end
+
+          def check_dimg_directive_order(directive)
+            dapp.log_config_warning(desc: { code: 'wrong_using_base_directive',
+                                            data: { directive: directive },
+                                            context: 'warning' }) if _dimg.any? || _dimg_group.any? || _artifact.any?
+          end
+
+          def check_dimg_group_directive_order(directive)
+            dapp.log_config_warning(desc: { code: 'wrong_using_directive',
+                                            data: { directive: directive },
+                                            context: 'warning' }) if _dimg.any? || _dimg_group.any?
+          end
+        end
+      end
+    end
+  end
+end