dapp 0.6.17 → 0.7.1

data/lib/dapp/project/command/common.rb

@@ -7,16 +7,16 @@ module Dapp
       module Common
         protected
 
-        def project_images(basename)
-          shellout!(%(docker images --format="{{.Repository}}:{{.Tag}}" #{stage_cache(basename)})).stdout.strip
+        def project_images
+          shellout!(%(docker images --format="{{.Repository}}:{{.Tag}}" #{stage_cache})).stdout.strip
         end
 
-        def project_containers_flush(basename)
-          remove_containers_by_query(%(docker ps -a -f "label=dapp" -f "name=#{container_name(basename)}" -q), force: true)
+        def project_containers_flush
+          remove_containers_by_query(%(docker ps -a -f "label=dapp" -f "name=#{container_name_prefix}" -q), force: true)
         end
 
-        def project_dangling_images_flush(basename)
-          remove_images_by_query(%(docker images -f "dangling=true" -f "label=dapp=#{stage_dapp_label(basename)}" -q), force: true)
+        def project_dangling_images_flush
+          remove_images_by_query(%(docker images -f "dangling=true" -f "label=dapp=#{stage_dapp_label}" -q), force: true)
         end
 
         def remove_images_by_query(images_query, force: false)
@@ -51,20 +51,8 @@ module Dapp
           shellout!(cmd) unless dry_run?
         end
 
-        def stage_cache(basename)
-          cache_format % { application_name: basename }
-        end
-
-        def stage_dapp_label(basename)
-          stage_dapp_label_format % { application_name: basename }
-        end
-
-        def container_name(basename)
-          basename
-        end
-
-        def validate_repo_name(repo)
-          raise(Error::Project, code: :repo_name_incorrect, data: { name: repo }) unless DockerRegistry.repo_name?(repo)
+        def container_name_prefix
+          name
         end
 
         def proper_cache_version?

data/lib/dapp/project/command/list.rb

@@ -6,7 +6,13 @@ module Dapp
       # List
       module List
         def list
-          build_configs.each { |config| puts config._name }
+          build_configs.each do |config|
+            if config._name.nil?
+              log_warning("Project '#{name}' with nameless dimg!")
+            else
+              puts config._name
+            end
+          end
         end
       end
     end

data/lib/dapp/project/command/mrproper.rb

@@ -8,13 +8,12 @@ module Dapp
         def mrproper
           log_step_with_indent(:mrproper) do
             if proper_all?
-              flush_by_label('dapp')
-            elsif proper_dev_mode_cache?
-              flush_by_label('dapp-dev-mode')
+              log_step_with_indent(:containers) { dapp_containers_flush }
+              log_step_with_indent(:images) { dapp_images_flush }
             elsif proper_cache_version?
               log_proper_cache do
                 proper_cache_images = proper_cache_all_images
-                remove_images(dapp_images_by_label('dapp').lines.select { |id| !proper_cache_images.lines.include?(id) }.map(&:strip))
+                remove_images(dapp_images.lines.select { |id| !proper_cache_images.lines.include?(id) }.map(&:strip))
               end
             else
               raise Error::Project, code: :mrproper_required_option
@@ -24,34 +23,25 @@ module Dapp
 
         protected
 
-        def flush_by_label(label)
-          log_step_with_indent(:containers) { dapp_containers_flush_by_label(label) }
-          log_step_with_indent(:images) { dapp_images_flush_be_label(label) }
-        end
-
         def proper_all?
           !!cli_options[:proper_all]
         end
 
-        def proper_dev_mode_cache?
-          !!cli_options[:proper_dev_mode_cache]
-        end
-
-        def dapp_containers_flush_by_label(label)
-          remove_containers_by_query(%(docker ps -a -f "label=#{label}" -q), force: true)
+        def dapp_containers_flush
+          remove_containers_by_query('docker ps -a -f "label=dapp" -q', force: true)
         end
 
-        def dapp_dangling_images_flush_by_label(label)
-          remove_images_by_query(%(docker images -f "dangling=true" -f "label=#{label}" -q), force: true)
+        def dapp_dangling_images_flush
+          remove_images_by_query('docker images -f "dangling=true" -f "label=dapp" -q', force: true)
         end
 
-        def dapp_images_flush_be_label(label)
-          dapp_dangling_images_flush_by_label(label)
-          remove_images(dapp_images_by_label(label).lines.map(&:strip), force: true)
+        def dapp_images_flush
+          dapp_dangling_images_flush
+          remove_images(dapp_images.lines.map(&:strip), force: true)
         end
 
-        def dapp_images_by_label(label)
-          @dapp_images ||= shellout!(%(docker images -f "dangling=false" --format="{{.Repository}}:{{.Tag}}" -f "label=#{label}")).stdout.strip
+        def dapp_images
+          @dapp_images ||= shellout!('docker images -f "dangling=false" --format="{{.Repository}}:{{.Tag}}" -f "label=dapp"').stdout.strip
         end
 
         def proper_cache_all_images

data/lib/dapp/project/command/push.rb

@@ -6,12 +6,11 @@ module Dapp
       # Push
       module Push
         def push(repo)
-          validate_repo_name(repo)
           log_step_with_indent(:stages) { stages_push(repo) } if with_stages?
           build_configs.each do |config|
-            log_step_with_indent(config._name) do
-              Application.new(config: config, project: self, ignore_git_fetch: true, should_be_built: true).tap do |app|
-                app.export!(repo, format: '%{repo}:%{application_name}-%{tag}')
+            log_dimg_name_with_indent(config) do
+              Dimg.new(config: config, project: self, ignore_git_fetch: true, should_be_built: true).tap do |dimg|
+                dimg.export!(repo, format: '%{repo}:%{dimg_name}-%{tag}')
               end
             end
           end

data/lib/dapp/project/command/run.rb

@@ -6,8 +6,8 @@ module Dapp
       # Run
       module Run
         def run(docker_options, command)
-          raise Error::Project, code: :command_unexpected_apps_number unless build_configs.one?
-          Application.new(config: build_configs.first, project: self, ignore_git_fetch: true, should_be_built: true).run(docker_options, command)
+          raise Error::Project, code: :command_unexpected_dimgs_number unless build_configs.one?
+          Dimg.new(config: build_configs.first, project: self, ignore_git_fetch: true, should_be_built: true).run(docker_options, command)
         end
       end
     end

data/lib/dapp/project/command/spush.rb

@@ -6,10 +6,9 @@ module Dapp
       # Spush
       module Spush
         def spush(repo)
-          validate_repo_name(repo)
-          raise Error::Project, code: :spush_command_unexpected_apps_number unless build_configs.one?
-          Application.new(config: build_configs.first, project: self, ignore_git_fetch: true, should_be_built: true).tap do |app|
-            app.export!(repo, format: '%{repo}:%{tag}')
+          raise Error::Project, code: :spush_command_unexpected_dimgs_number unless build_configs.one?
+          Dimg.new(config: build_configs.first, project: self, ignore_git_fetch: true, should_be_built: true).tap do |dimg|
+            dimg.export!(repo, format: '%{repo}:%{tag}')
           end
         end
       end

data/lib/dapp/project/command/stage_image.rb

@@ -6,8 +6,8 @@ module Dapp
       # StageImage
       module StageImage
         def stage_image
-          raise Error::Project, code: :command_unexpected_apps_number unless build_configs.one?
-          puts Application.new(config: build_configs.first, project: self, ignore_git_fetch: true).stage_image_name(cli_options[:stage])
+          raise Error::Project, code: :command_unexpected_dimgs_number unless build_configs.one?
+          puts Dimg.new(config: build_configs.first, project: self, ignore_git_fetch: true).stage_image_name(cli_options[:stage])
         end
       end
     end

data/lib/dapp/project/command/stages/cleanup_local.rb

@@ -9,59 +9,55 @@ module Dapp
           def stages_cleanup_local(repo)
             lock_repo(repo, readonly: true) do
               registry = registry(repo)
-              repo_applications = repo_applications_images(registry)
+              repo_dimgs = repo_dimgs_images(registry)
               proper_cache if proper_cache_version?
-              build_configs.map(&:_basename).uniq.each do |basename|
-                cleanup_project(basename, repo_applications)
-              end
+              cleanup_project(repo_dimgs)
             end
           end
 
           protected
 
-          def cleanup_project(basename, repo_applications)
-            lock("#{basename}.images") do
-              log_step_with_indent(basename) do
-                project_containers_flush(basename)
-                project_dangling_images_flush(basename)
-                apps, stages = project_images_hash(basename).partition { |_, image_id| repo_applications.values.include?(image_id) }
-                apps = apps.to_h
+          def cleanup_project(repo_dimgs)
+            lock("#{name}.images") do
+              log_step_with_indent(name) do
+                project_containers_flush
+                project_dangling_images_flush
+                dimgs, stages = project_images_hash.partition { |_, image_id| repo_dimgs.values.include?(image_id) }
+                dimgs = dimgs.to_h
                 stages = stages.to_h
-                apps.each { |_, aiid| clear_stages(aiid, stages) }
+                dimgs.each { |_, aiid| clear_stages(aiid, stages) }
                 remove_images(stages.keys)
               end
             end
           end
 
-          def repo_applications_images(registry)
+          def repo_dimgs_images(registry)
             repo_images(registry).first
           end
 
           def proper_cache
             log_proper_cache do
-              build_configs.map(&:_basename).uniq.each do |basename|
-                lock("#{basename}.images") do
-                  log_step_with_indent(basename) do
-                    project_containers_flush(basename)
-                    actual_cache_images = actual_cache_images(basename)
-                    remove_images(project_images(basename).lines.select { |id| !actual_cache_images.lines.include?(id) }.map(&:strip))
-                  end
+              lock("#{name}.images") do
+                log_step_with_indent(name) do
+                  project_containers_flush
+                  actual_cache_images = actual_cache_images
+                  remove_images(project_images.lines.select { |id| !actual_cache_images.lines.include?(id) }.map(&:strip))
                 end
               end
             end
           end
 
-          def actual_cache_images(basename)
+          def actual_cache_images
             shellout!([
               'docker images',
               '--format="{{.Repository}}:{{.Tag}}"',
               %(-f "label=dapp-cache-version=#{Dapp::BUILD_CACHE_VERSION}"),
-              stage_cache(basename)
+              stage_cache
             ].join(' ')).stdout.strip
           end
 
-          def project_images_hash(basename)
-            shellout!(%(docker images --format "{{.Repository}}:{{.Tag}};{{.ID}}" --no-trunc #{stage_cache(basename)})).stdout.lines.map do |line|
+          def project_images_hash
+            shellout!(%(docker images --format "{{.Repository}}:{{.Tag}};{{.ID}}" --no-trunc #{stage_cache})).stdout.lines.map do |line|
               line.strip.split(';')
             end.to_h
           end

data/lib/dapp/project/command/stages/cleanup_repo.rb

@@ -9,11 +9,11 @@ module Dapp
           def stages_cleanup_repo(repo)
             lock_repo(repo) do
               registry = registry(repo)
-              repo_applications, repo_stages = repo_images(registry)
-              repo_stages.delete_if { |_, siid| repo_applications.values.include?(siid) } # ignoring stages with apps ids (v2)
+              repo_dimgs, repo_stages = repo_images(registry)
+              repo_stages.delete_if { |_, siid| repo_dimgs.values.include?(siid) } # ignoring stages with dimgs ids (v2)
               proper_repo_cache(registry, repo_stages) if proper_cache_version?
               log_step_with_indent(repo) do
-                repo_applications.each { |image_tag, image_id| clear_repo_stages(registry, repo_stages, image_tag, image_id) }
+                repo_dimgs.each { |image_tag, image_id| clear_repo_stages(registry, repo_stages, image_tag, image_id) }
                 repo_stages.keys.each { |image_tag| delete_repo_image(registry, image_tag) }
               end
             end

data/lib/dapp/project/command/stages/common.rb

@@ -9,7 +9,6 @@ module Dapp
           protected
 
           def registry(repo)
-            validate_repo_name(repo)
             DockerRegistry.new(repo)
           end
 
@@ -23,8 +22,8 @@ module Dapp
                 end
               end.compact.to_h
             end
-            applications, stages = registry_tags(registry).partition { |tag| !tag.start_with?('dappstage') }
-            [format.call(applications), format.call(stages)]
+            dimgs, stages = registry.tags.partition { |tag| !tag.start_with?('dimgstage') }
+            [format.call(dimgs), format.call(stages)]
           end
 
           def registry_tags(registry)

data/lib/dapp/project/command/stages/flush_local.rb

@@ -7,13 +7,11 @@ module Dapp
         # FlushLocal
         module FlushLocal
           def stages_flush_local
-            build_configs.map(&:_basename).uniq.each do |basename|
-              lock("#{basename}.images") do
-                log_step_with_indent(basename) do
-                  project_containers_flush(basename)
-                  project_dangling_images_flush(basename)
-                  remove_images(project_images(basename).lines.map(&:strip))
-                end
+            lock("#{name}.images") do
+              log_step_with_indent(name) do
+                project_containers_flush
+                project_dangling_images_flush
+                remove_images(project_images.lines.map(&:strip))
               end
             end
           end

data/lib/dapp/project/command/stages/flush_repo.rb

@@ -10,8 +10,8 @@ module Dapp
             lock_repo(repo) do
               log_step_with_indent(repo) do
                 registry = registry(repo)
-                repo_applications, repo_stages = repo_images(registry)
-                repo_applications.merge(repo_stages).keys.each { |image_tag| delete_repo_image(registry, image_tag) }
+                repo_dimgs, repo_stages = repo_images(registry)
+                repo_dimgs.merge(repo_stages).keys.each { |image_tag| delete_repo_image(registry, image_tag) }
               end
             end
           end

data/lib/dapp/project/command/stages/pull.rb

@@ -7,11 +7,10 @@ module Dapp
         # Pull
         module Pull
           def stages_pull(repo)
-            validate_repo_name(repo)
             build_configs.each do |config|
-              log_step_with_indent(config._name) do
-                Application.new(config: config, project: self, ignore_git_fetch: true).tap do |app|
-                  app.import_stages!(repo, format: '%{repo}:dappstage-%{signature}')
+              log_dimg_name_with_indent(config) do
+                Dimg.new(config: config, project: self, ignore_git_fetch: true).tap do |dimg|
+                  dimg.import_stages!(repo, format: '%{repo}:dimgstage-%{signature}')
                 end
               end
             end

data/lib/dapp/project/command/stages/push.rb

@@ -7,11 +7,10 @@ module Dapp
         # Push
         module Push
           def stages_push(repo)
-            validate_repo_name(repo)
             build_configs.each do |config|
-              log_step_with_indent(config._name) do
-                Application.new(config: config, project: self, ignore_git_fetch: true, should_be_built: true).tap do |app|
-                  app.export_stages!(repo, format: '%{repo}:dappstage-%{signature}')
+              log_dimg_name_with_indent(config) do
+                Dimg.new(config: config, project: self, ignore_git_fetch: true, should_be_built: true).tap do |dimg|
+                  dimg.export_stages!(repo, format: '%{repo}:dimgstage-%{signature}')
                 end
               end
             end

data/lib/dapp/project/dappfile.rb

@@ -5,31 +5,15 @@ module Dapp
     module Dappfile
       def build_configs
         @configs ||= begin
-          dappfiles.map { |dappfile| apps(dappfile, app_filters: apps_patterns) }.flatten.tap do |apps|
-            raise Error::Project, code: :no_such_app, data: { apps_patterns: apps_patterns.join(', ') } if apps.empty?
+          dimgs(dappfile_path).flatten.tap do |dimgs|
+            raise Error::Project, code: :no_such_dimg, data: { dimgs_patterns: dimgs_patterns.join(', ') } if dimgs.empty?
           end
         end
       end
 
-      def dappfiles
-        if File.exist?(dappfile_path)                 then [dappfile_path]
-        elsif !dapps_dappfiles_pathes.empty?          then dapps_dappfiles_pathes
-        elsif (dappfile_path = search_up('Dappfile')) then [dappfile_path]
-        else raise Error::Project, code: :dappfile_not_found
-        end
-      end
-
       def dappfile_path
-        File.join [cli_options[:dir], 'Dappfile'].compact
-      end
-
-      def dapps_dappfiles_pathes
-        path = []
-        path << cli_options[:dir]
-        path << '.dapps' unless File.basename(work_dir) == '.dapps'
-        path << '*'
-        path << 'Dappfile'
-        Dir.glob(File.join(path.compact))
+        raise Error::Project, code: :dappfile_not_found unless (dappfile_path = search_up('Dappfile'))
+        dappfile_path
       end
 
       def search_up(file)
@@ -52,19 +36,18 @@ module Dapp
         path
       end
 
-      def apps(dappfile_path, app_filters:)
-        config = Config::Main.new(dappfile_path: dappfile_path, project: self) do |conf|
+      def dimgs(dappfile_path)
+        Config::DimgGroupMain.new(project: self) do |conf|
           begin
             conf.instance_eval File.read(dappfile_path), dappfile_path
           rescue SyntaxError, StandardError => e
             backtrace = e.backtrace.find { |line| line.start_with?(dappfile_path) }
-            message = e.is_a?(NoMethodError) ? e.message[/.*(?= for)/] : e.message
+            message = [NoMethodError, NameError].any? { |err| e.is_a?(err) } ? e.message[/.*(?= for)/] : e.message
             message = "#{backtrace[/.*(?=:in)/]}: #{message}" if backtrace
             raise Error::Dappfile, code: :incorrect, data: { error: e.class.name, message: message }
           end
-        end
-        config._apps.select { |app| app_filters.any? { |pattern| File.fnmatch(pattern, app._name) } }.tap do |apps|
-          apps.each { |app| app.send(:validate!) }
+        end._dimg.select { |dimg| dimgs_patterns.any? { |pattern| dimg._name.nil? || File.fnmatch(pattern, dimg._name) } }.tap do |dimgs|
+          dimgs.each { |dimg| dimg.send(:validate!) }
         end
       end
     end # Dappfile

data/lib/dapp/project/logging/base.rb

@@ -17,6 +17,10 @@ module Dapp
           cli_options[:log_verbose]
         end
 
+        def ignore_config_warning?
+          cli_options[:ignore_config_warning]
+        end
+
         def introspect_error?
           cli_options[:introspect_error]
         end
@@ -34,6 +38,11 @@ module Dapp
           log(*args, **kwargs)
         end
 
+        def log_dimg_name_with_indent(dimg, &blk)
+          return yield if dimg._name.nil?
+          log_step_with_indent(dimg._name, &blk)
+        end
+
         def log_step_with_indent(step)
           log_step(step)
           with_log_indent do
@@ -58,6 +67,11 @@ module Dapp
           log(*args, **kwargs)
         end
 
+        def log_config_warning(*args, **kwargs)
+          return if ignore_config_warning?
+          log_warning(*args, **kwargs)
+        end
+
         def log(message = '', desc: nil, inline: false, **kwargs)
           return if log_quiet?
           unless desc.nil?