dapp 0.6.1 → 0.6.2

data/lib/dapp/image/scratch.rb

@@ -0,0 +1,29 @@
+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)
+        build_from_command = if from_archives.empty?
+                               "#{project.tar_path} c --files-from /dev/null"
+                             else
+                               "#{project.cat_path} #{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

@@ -6,59 +6,69 @@ module Dapp
       include Argument
 
       def initialize(name:, project:, built_id: nil, from: nil)
-        @bash_commands = []
-        @options = {}
-        @change_options = {}
-        @service_change_options = {}
         @container_name = "#{name[/[[^:].]*/]}.#{SecureRandom.hex(4)}"
         @built_id = built_id
-        super(name: name, project: project, from: from)
-      end
 
-      def labels
-        self.class.image_config_option(image_id: built_id, option: 'labels')
+        @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!(**kwargs)
-        run!(**kwargs)
+      def build!
+        run!
         @built_id = commit!
       ensure
-        shellout("docker rm #{container_name}")
+        project.shellout("docker rm #{container_name}")
       end
 
-      def export!(name, log_verbose: false, log_time: false)
+      def export!(name)
         image = self.class.new(name: name, project: project, built_id: built_id)
-        image.tag!(log_verbose: log_verbose, log_time: log_time)
-        image.push!(log_verbose: log_verbose, log_time: log_time)
+        image.tag!
+        image.push!
         image.untag!
       end
 
-      def tag!(log_verbose: false, log_time: false)
+      def import!(name)
+        image = self.class.new(name: name, project: project)
+        image.pull!
+        @built_id = image.built_id
+        tag!
+        image.untag!
+      end
+
+      def tag!
         project.log_warning(desc: { code: :another_image_already_tagged, context: 'warning' }) if !(existed_id = id).nil? && built_id != existed_id
-        shellout!("docker tag #{built_id} #{name}", log_verbose: log_verbose, log_time: log_time)
+        project.shellout!("docker tag #{built_id} #{name}")
         cache_reset
       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!(log_verbose: false, log_time: false, introspect_error: false, introspect_before_error: false)
+      def run!
         raise Error::Build, code: :built_id_not_defined if from.built_id.nil?
-        shellout!("docker run #{prepared_options} #{from.built_id} -ec '#{prepared_bash_command}'",
-                  log_verbose: log_verbose, log_time: log_time)
+        project.shellout!("docker run #{prepared_options} #{from.built_id} -ec '#{prepared_bash_command}'", log_verbose: true)
       rescue Error::Shellout => _e
-        raise unless introspect_error || introspect_before_error
-        built_id = introspect_error ? commit! : from.built_id
-        raise Exception::IntrospectImage, data: { built_id: built_id, options: prepared_options, rmi: introspect_error }
+        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? }
       end
 
       def commit!
-        shellout!("docker commit #{prepared_change} #{container_name}").stdout.strip
+        project.shellout!("docker commit #{prepared_change} #{container_name}").stdout.strip
       end
     end # Stage
   end # Image

data/lib/dapp/lock/base.rb

@@ -4,21 +4,20 @@ module Dapp
     # Base
     class Base
       attr_reader :name
-      attr_reader :on_wait
-      attr_reader :timeout
 
-      def initialize(name, timeout: 60, on_wait: nil)
+      def initialize(name)
         @name = name
-        @on_wait = on_wait
-        @timeout = timeout
+        @active_locks = 0
       end
 
-      def lock(shared: false)
-        raise
+      def lock(timeout: 60, on_wait: nil, readonly: false)
+        _do_lock(timeout, on_wait, readonly) unless @active_locks > 0
+        @active_locks += 1
       end
 
       def unlock
-        raise
+        @active_locks -= 1
+        _do_unlock if @active_locks.zero?
       end
 
       def synchronize(*args)
@@ -32,9 +31,17 @@ module Dapp
 
       protected
 
-      def _waiting(&blk)
-        if @on_wait
-          @on_wait.call { ::Timeout.timeout(timeout, &blk) }
+      def _do_lock(_timeout, _on_wait, _readonly)
+        raise
+      end
+
+      def _do_unlock
+        raise
+      end
+
+      def _waiting(timeout, on_wait, &blk)
+        if on_wait
+          on_wait.call { ::Timeout.timeout(timeout, &blk) }
         else
           ::Timeout.timeout(timeout, &blk)
         end

data/lib/dapp/lock/file.rb

@@ -3,20 +3,30 @@ module Dapp
   module Lock
     # File
     class File < Base
+      class << self
+        attr_writer :counter
+
+        def counter
+          @counter ||= 0
+        end
+      end # << self
+
       attr_reader :lock_path
 
-      def initialize(lock_path, name, **kwargs)
-        super(name, **kwargs)
+      def initialize(lock_path, name)
+        super(name)
+
         @lock_path = Pathname.new(lock_path).tap(&:mkpath)
       end
 
-      def lock(shared: false)
-        return if @file
-        @file = ::File.open(lock_path.join(name), ::File::RDWR | ::File::CREAT, 0644)
+      protected
+
+      def _do_lock(timeout, on_wait, readonly)
+        @file = ::File.open(lock_path.join(name), ::File::RDWR | ::File::CREAT, 0o644)
 
         begin
-          mode = (shared ? ::File::LOCK_SH : ::File::LOCK_EX)
-          _waiting { @file.flock(mode) } unless @file.flock(mode | ::File::LOCK_NB)
+          mode = (readonly ? ::File::LOCK_SH : ::File::LOCK_EX)
+          _waiting(timeout, on_wait) { @file.flock(mode) } unless @file.flock(mode | ::File::LOCK_NB)
         rescue ::Timeout::Error
           raise Dapp::Lock::Error::Timeout, code: :timeout,
                                             data: { name: name, timeout: timeout }
@@ -25,19 +35,11 @@ module Dapp
         self.class.counter += 1
       end
 
-      def unlock
+      def _do_unlock
         @file.close
         @file = nil
         self.class.counter -= 1
       end
-
-      class << self
-        attr_writer :counter
-
-        def counter
-          @counter ||= 0
-        end
-      end # << self
     end # File
   end # Lock
 end # Dapp

data/lib/dapp/prctl.rb

@@ -1,3 +1,4 @@
+# Prctl
 module Prctl
   PR_SET_PDEATHSIG = 1
 

data/lib/dapp/project.rb

@@ -3,7 +3,7 @@ module Dapp
   class Project
     include Lock
     include Dappfile
-    include Paint
+
     include Command::Common
     include Command::Run
     include Command::Build
@@ -11,17 +11,30 @@ module Dapp
     include Command::Push
     include Command::Spush
     include Command::List
-    include Command::StagesFlush
-    include Command::StagesCleanup
+    include Command::Stages::CleanupLocal
+    include Command::Stages::CleanupRepo
+    include Command::Stages::FlushLocal
+    include Command::Stages::FlushRepo
+    include Command::Stages::Push
+    include Command::Stages::Pull
+    include Command::Stages::Common
     include Command::Cleanup
+    include Command::Mrproper
+    include Command::StageImage
     include Logging::Base
     include Logging::Process
+    include Logging::I18n
+    include Logging::Paint
 
     include SshAgent
-    include Helper::I18n
-    include Helper::Shellout
-    include Helper::Paint
     include Helper::Sha256
+    include Helper::Trivia
+
+    include Deps::Gitartifact
+    include Deps::Base
+
+    include Shellout::Base
+    include Shellout::System
 
     attr_reader :cli_options
     attr_reader :apps_patterns
@@ -31,13 +44,13 @@ module Dapp
       @apps_patterns = apps_patterns || []
       @apps_patterns << '*' unless @apps_patterns.any?
 
-      paint_initialize
-      Helper::I18n.initialize
+      Logging::Paint.initialize(cli_options[:log_color])
+      Logging::I18n.initialize
     end
 
     def name
       @name ||= begin
-        shellout!("git -C #{path} config --get remote.origin.url").stdout.strip.split('/').last[/.*(?=.git)/]
+        system_shellout!("#{git_path} -C #{path} config --get remote.origin.url").stdout.strip.split('/').last[/.*(?=.git)/]
       rescue Error::Shellout
         File.basename(path)
       end

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

@@ -8,15 +8,12 @@ module Dapp
         def bp(repo)
           bp_step(:build)
           bp_step(:push, repo)
-          bp_step(:stages_cleanup, repo)
+          bp_step(:stages_cleanup_local, repo)
           bp_step(:cleanup)
         end
 
         def bp_step(step, *args)
-          log_step(step)
-          with_log_indent do
-            public_send(step, *args)
-          end
+          log_step_with_indent(step) { public_send(step, *args) }
         end
       end
     end

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

@@ -9,8 +9,7 @@ module Dapp
           setup_ssh_agent
 
           build_configs.each do |config|
-            log_step(config._name)
-            with_log_indent do
+            log_step_with_indent(config._name) do
               Application.new(config: config, project: self).build!
             end
           end

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

@@ -8,13 +8,15 @@ module Dapp
         def cleanup
           build_configs.map(&:_basename).uniq.each do |basename|
             lock("#{basename}.images") do
-              log(basename)
-              containers_flush(basename)
-              remove_images([
-                'docker images',
-                %(--format '{{if ne "#{stage_cache(basename)}" .Repository }}{{.ID}}{{ end }}'),
-                %(-f "label=dapp=#{stage_dapp_label(basename)}")
-              ].join(' ')) # FIXME: negative filter is not currently supported by the Docker CLI
+              log_step_with_indent(basename) do
+                project_containers_flush(basename)
+                project_dangling_images_flush(basename)
+                remove_images_by_query([
+                  'docker images',
+                  %(--format '{{if ne "#{stage_cache(basename)}" .Repository }}{{.ID}}{{ end }}'),
+                  %(-f "label=dapp=#{stage_dapp_label(basename)}")
+                ].join(' ')) # FIXME: negative filter is not currently supported by the Docker CLI
+              end
             end
           end
         end

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

@@ -7,18 +7,38 @@ module Dapp
       module Common
         protected
 
-        def containers_flush(basename)
-          remove_containers(%(docker ps -a -f "label=dapp" -f "name=#{container_name(basename)}" -q), force: true)
+        def project_images(basename)
+          shellout!(%(docker images --format="{{.Repository}}:{{.Tag}}" #{stage_cache(basename)})).stdout.strip
         end
 
-        def remove_images(images_query, force: false)
-          force_option = force ? ' -f' : ''
-          with_subquery(images_query) { |ids| run_command(%(docker rmi#{force_option} #{ids.join(' ')})) }
+        def project_containers_flush(basename)
+          remove_containers_by_query(%(docker ps -a -f "label=dapp" -f "name=#{container_name(basename)}" -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)
+        end
+
+        def remove_images_by_query(images_query, force: false)
+          with_subquery(images_query) { |ids| remove_images(ids, force: force) }
+        end
+
+        def remove_images(ids, force: false)
+          remove_base('docker rmi%{force_option} %{ids}', ids, force: force)
         end
 
-        def remove_containers(containers_query, force: false)
+        def remove_containers_by_query(containers_query, force: false)
+          with_subquery(containers_query) { |ids| remove_containers(ids, force: force) }
+        end
+
+        def remove_containers(ids, force: false)
+          remove_base('docker rm%{force_option} %{ids}', ids, force: force)
+        end
+
+        def remove_base(query_format, ids, force: false)
+          return if ids.empty?
           force_option = force ? ' -f' : ''
-          with_subquery(containers_query) { |ids| run_command(%(docker rm#{force_option} #{ids.join(' ')})) }
+          ids.each_slice(50) { |chunk| run_command(query_format % ({ force_option: force_option, ids: chunk.join(' ') })) }
         end
 
         def with_subquery(query)
@@ -27,11 +47,8 @@ module Dapp
         end
 
         def run_command(cmd)
-          if @cli_options[:dry_run] # FIXME
-            puts cmd
-          else
-            shellout!(cmd)
-          end
+          log(cmd) if log_verbose? || dry_run?
+          shellout!(cmd) unless dry_run?
         end
 
         def stage_cache(basename)
@@ -45,6 +62,14 @@ module Dapp
         def container_name(basename)
           basename
         end
+
+        def proper_cache_version?
+          !!cli_options[:proper_cache_version]
+        end
+
+        def log_proper_cache(&blk)
+          log_step_with_indent(:'proper cache', &blk)
+        end
       end
     end
   end # Project

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

@@ -0,0 +1,57 @@
+module Dapp
+  # Project
+  class Project
+    # Command
+    module Command
+      # Mrproper
+      module Mrproper
+        def mrproper
+          log_step_with_indent(:mrproper) do
+            if proper_all?
+              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.lines.select { |id| !proper_cache_images.lines.include?(id) }.map(&:strip))
+              end
+            else
+              raise Error::Project, code: :mrproper_required_option
+            end
+          end
+        end
+
+        protected
+
+        def proper_all?
+          !!cli_options[:proper_all]
+        end
+
+        def dapp_containers_flush
+          remove_containers_by_query('docker ps -a -f "label=dapp" -q', force: true)
+        end
+
+        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
+          dapp_dangling_images_flush
+          remove_images(dapp_images.lines.map(&:strip), force: true)
+        end
+
+        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
+          shellout!([
+            'docker images',
+            '--format="{{.Repository}}:{{.Tag}}"',
+            %(-f "label=dapp-cache-version=#{Dapp::BUILD_CACHE_VERSION}" -f "dangling=false")
+          ].join(' ')).stdout.strip
+        end
+      end
+    end
+  end # Project
+end # Dapp