dapp 0.6.1 → 0.6.2

data/lib/dapp/project/lock.rb

@@ -7,20 +7,27 @@ module Dapp
         build_path.join('locks')
       end
 
-      def lock(name, *args, default_timeout: 300, **kwargs, &blk)
-        timeout = cli_options[:lock_timeout] || default_timeout
+      def _lock(name)
+        @_locks ||= {}
+        @_locks[name] ||= ::Dapp::Lock::File.new(lock_path, name)
+      end
 
-        ::Dapp::Lock::File.new(
-          lock_path, name,
-          timeout: timeout,
-          on_wait: lambda do |&blk|
-            log_secondary_process(
-              t(code: 'process.waiting_resouce_lock', data: { name: name }),
-              short: true,
-              &blk
-            )
-          end
-        ).synchronize(*args, **kwargs, &blk)
+      def lock(name, *_args, default_timeout: 300, **kwargs, &blk)
+        if dry_run?
+          yield if block_given?
+        else
+          timeout = cli_options[:lock_timeout] || default_timeout
+          _lock(name).synchronize(
+            timeout: timeout,
+            on_wait: proc do |&do_wait|
+              log_secondary_process(
+                t(code: 'process.waiting_resouce_lock', data: { name: name }),
+                short: true,
+                &do_wait
+              )
+            end, **kwargs, &blk
+          )
+        end
       end
     end # Lock
   end # Project

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

@@ -17,6 +17,14 @@ module Dapp
           cli_options[:log_verbose]
         end
 
+        def introspect_error?
+          cli_options[:introspect_error]
+        end
+
+        def introspect_before_error?
+          cli_options[:introspect_before_error]
+        end
+
         def dry_run?
           cli_options[:dry_run]
         end
@@ -26,6 +34,13 @@ module Dapp
           log(*args, **kwargs)
         end
 
+        def log_step_with_indent(step)
+          log_step(step)
+          with_log_indent do
+            yield
+          end
+        end
+
         def log_step(*args, **kwargs)
           kwargs[:style] = :step
           log(*args, **kwargs)
@@ -51,7 +66,7 @@ module Dapp
         end
 
         def log_time
-          self.class.log_time
+          "#{DateTime.now.strftime('%Y-%m-%dT%T%z')} "
         end
 
         def log_format_string(str, time: true, indent: true, style: nil)
@@ -90,8 +105,10 @@ module Dapp
           end
         end
 
-        def self.log_time
-          "#{DateTime.now.strftime('%Y-%m-%dT%T%z')} "
+        class << self
+          def included(base)
+            base.extend(self)
+          end
         end
 
         protected

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

@@ -0,0 +1,25 @@
+module Dapp
+  class Project
+    module Logging
+      # I18n
+      module I18n
+        def self.initialize
+          ::I18n.load_path << Dir[File.join(Dapp.root, 'config', '**', '*')].select { |path| File.file?(path) }
+          ::I18n.reload!
+          ::I18n.locale = :en
+        end
+
+        def t(context: nil, **desc)
+          code = desc[:code]
+          data = desc[:data] || {}
+          paths = []
+          paths << [:common, context, code].join('.') if context
+          paths << [:common, code].join('.')
+          ::I18n.t(*paths, **data, raise: true)
+        rescue ::I18n::MissingTranslationData => _e
+          raise ::NetStatus::Exception, code: :missing_translation, data: { code: code }
+        end
+      end
+    end # Helper
+  end
+end # Dapp

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

@@ -0,0 +1,47 @@
+module Dapp
+  # Project
+  class Project
+    module Logging
+      # Paint
+      module Paint
+        FORMAT = {
+          step: [:yellow, :bold],
+          info: [:blue],
+          success: [:green, :bold],
+          warning: [:red, :bold],
+          secondary: [:white, :bold],
+          default: [:white]
+        }.freeze
+
+        def self.initialize(mode)
+          ::Paint.mode = case mode
+                         when 'auto' then STDOUT.tty? ? 8 : 0
+                         when 'on'   then 8
+                         when 'off'  then 0
+                         else raise
+                         end
+        end
+
+        def paint_style(name)
+          FORMAT[name].tap do |format|
+            raise if format.nil?
+          end
+        end
+
+        def paint_string(object, style_name)
+          ::Paint[unpaint(object.to_s), *paint_style(style_name)]
+        end
+
+        def unpaint(str)
+          ::Paint.unpaint(str)
+        end
+
+        class << self
+          def included(base)
+            base.extend(self)
+          end
+        end
+      end # Paint
+    end
+  end # Project
+end # Dapp

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

@@ -26,19 +26,26 @@ module Dapp
           log "#{formatted_message}#{formatted_status}"
         end
 
-        def log_process(message, process: nil, short: false, style: {}, &blk)
+        # rubocop:disable Metrics/ParameterLists
+        def log_process(message, process: nil, short: false, quiet: false, style: {}, status: {}, &blk)
+          return yield if quiet
+
           style[:message] ||= DEFAULT_STYLE[:message]
           style[:process] ||= DEFAULT_STYLE[:process]
           style[:failed] ||= DEFAULT_STYLE[:failed]
           style[:success] ||= DEFAULT_STYLE[:success]
 
+          status[:success] ||= t(code: 'status.success.default')
+          status[:failed] ||= t(code: 'status.failed.default')
+
           if log_verbose? && !short
             process ||= t(code: 'status.process.default')
-            log_process_verbose(message, process: process, style: style, &blk)
+            log_process_verbose(message, process: process, style: style, status: status, &blk)
           else
-            log_process_short(message, style: style, &blk)
+            log_process_short(message, style: style, status: status, &blk)
           end
         end
+        # rubocop:enable Metrics/ParameterLists
 
         def log_secondary_process(message, **kwargs, &blk)
           log_process(message, **kwargs.merge(style: { message: :secondary, success: :secondary }), &blk)
@@ -46,19 +53,19 @@ module Dapp
 
         protected
 
-        def log_process_verbose(message, process:, style: {}, &blk)
+        def log_process_verbose(message, process:, style: {}, status: {}, &blk)
           process         = paint_string(rjust(process, message), style[:process])
           info            = paint_string(message, style[:message]) + process
           success_message = paint_string(slice(message), style[:message]) +
-                            paint_string(rjust(t(code: 'status.success.default'), message), style[:success])
-          failed_message  = paint_string(slice(message) + rjust(t(code: 'status.failed.default'), message), style[:failed])
+                            paint_string(rjust(status[:success], message), style[:success])
+          failed_message  = paint_string(slice(message) + rjust(status[:failed], message), style[:failed])
           log_process_default(info, success_message, failed_message, &blk)
         end
 
-        def log_process_short(message, style: {}, &blk)
+        def log_process_short(message, style: {}, status: {}, &blk)
           info            = "#{paint_string(slice(message), style[:message])} ... "
-          success_message = paint_string(rjust(t(code: 'status.success.default'), info), style[:success])
-          failed_message  = paint_string(rjust(t(code: 'status.failed.default'), info), style[:failed])
+          success_message = paint_string(rjust(status[:success], info), style[:success])
+          failed_message  = paint_string(rjust(status[:failed], info), style[:failed])
           log_process_default(info, success_message, failed_message, inline: true, &blk)
         end
 
@@ -90,7 +97,7 @@ module Dapp
         def free_space(str)
           base_time = log_time? ? log_time.length : 0
           indent = log_indent.length
-          str = ::Paint.unpaint(str.to_s).length
+          str = unpaint(str.to_s).length
           time = 15
           terminal_width - base_time - str - indent - time
         end

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

@@ -0,0 +1,74 @@
+module Dapp
+  class Project
+    # Shellout
+    module Shellout
+      # Base
+      module Base
+        include Streaming
+
+        def shellout(*args, **kwargs)
+          env = nil
+
+          Base.default_env_keys.each do |env_key|
+            env_key = env_key.to_s.upcase
+            env ||= {}
+            env[env_key] = ENV[env_key]
+          end
+
+          param_env = (kwargs.delete(:env) || kwargs.delete(:environment))
+          param_env = param_env.map { |key, value| [key.to_s.upcase, value.to_s] }.to_h if param_env
+
+          env = (env || {}).merge(param_env) if param_env
+          kwargs[:env] = env if env
+
+          do_shellout = -> { ::Mixlib::ShellOut.new(*args, timeout: 3600, **kwargs).run_command }
+          if defined? ::Bundler
+            ::Bundler.with_clean_env { do_shellout.call }
+          else
+            do_shellout.call
+          end
+        end
+
+        def shellout!(*args, **kwargs)
+          shellout_with_logging(**kwargs) do |options|
+            shellout(*args, **options).tap(&:error!)
+          end
+        end
+
+        def shellout_pack(command)
+          "eval $(#{echo_path} #{Base64.strict_encode64(command)} | base64 --decode)"
+        end
+
+        class << self
+          def included(base)
+            base.extend(self)
+          end
+
+          def default_env_keys
+            @default_env_keys ||= []
+          end
+        end # << self
+
+        protected
+
+        def shellout_with_logging(log_verbose: false, **kwargs)
+          return yield(**kwargs) unless instance_of? Project
+
+          begin
+            stream = Stream.new
+            if log_verbose && log_verbose?
+              kwargs[:live_stream] = Proxy::Base.new(stream, STDOUT, with_time: log_time?)
+            else
+              kwargs[:live_stdout] = Proxy::Base.new(stream, with_time: log_time?)
+            end
+            kwargs[:live_stderr] = Proxy::Error.new(stream, with_time: log_time?)
+
+            yield(**kwargs)
+          rescue ::Mixlib::ShellOut::ShellCommandFailed => e
+            raise Error::Shellout, code: class_to_lowercase(e.class), data: { stream: stream.show }
+          end
+        end
+      end
+    end
+  end # Helper
+end # Dapp

data/lib/dapp/project/shellout/streaming.rb

@@ -0,0 +1,49 @@
+module Dapp
+  class Project
+    module Shellout
+      # Streaming
+      module Streaming
+        # Stream
+        class Stream
+          def buffer
+            @buffer ||= []
+          end
+
+          def <<(string)
+            buffer << string
+          end
+
+          def show
+            buffer.join.strip
+          end
+        end
+
+        # Proxy
+        module Proxy
+          # Base
+          class Base
+            def initialize(*streams, with_time: false)
+              @streams = streams
+              @with_time = with_time
+            end
+
+            def <<(str)
+              @streams.each { |s| s << format_string(str) }
+            end
+
+            def format_string(str)
+              str.lines.map { |l| "#{Project.log_time if @with_time}#{l.strip}\n" }.join
+            end
+          end
+
+          # Error
+          class Error < Base
+            def format_string(str)
+              "#{Project.paint_string(super.strip, :warning)}\n"
+            end
+          end
+        end
+      end
+    end
+  end # Helper
+end # Dapp

data/lib/dapp/project/shellout/system.rb

@@ -0,0 +1,72 @@
+module Dapp
+  # Project
+  class Project
+    module Shellout
+      # System
+      module System
+        SYSTEM_SHELLOUT_IMAGE = 'ubuntu:14.04'.freeze
+        SYSTEM_SHELLOUT_VERSION = 2
+
+        def system_shellout_container_name
+          "dapp_system_shellout_#{hashsum [SYSTEM_SHELLOUT_VERSION,
+                                           SYSTEM_SHELLOUT_IMAGE,
+                                           Deps::Base::BASE_VERSION,
+                                           Deps::Gitartifact::GITARTIFACT_VERSION]}"
+        end
+
+        def system_shellout_container
+          @system_shellout_container ||= begin
+            lock(system_shellout_container_name) do
+              if shellout("docker inspect #{system_shellout_container_name}").exitstatus.nonzero?
+                volumes_from = [base_container, gitartifact_container]
+                log_secondary_process(t(code: 'process.system_shellout_container_loading'), short: true) do
+                  shellout! ['docker run --detach --privileged', '--restart always',
+                             "--name #{system_shellout_container_name}",
+                             *volumes_from.map { |container| "--volumes-from #{container}" },
+                             '--volume /:/.system_shellout_root',
+                             "#{SYSTEM_SHELLOUT_IMAGE} #{bash_path} -ec 'while true ; do sleep 1 ; done'"].join(' ')
+
+                  shellout! ["docker exec #{system_shellout_container_name}",
+                             "bash -ec '#{[
+                               'mkdir -p /.system_shellout_root/.dapp',
+                               'mount --rbind /.dapp /.system_shellout_root/.dapp'
+                             ].join(' && ')}'"].join(' ')
+                end
+              end
+            end
+
+            system_shellout_container_name
+          end
+        end
+
+        def system_shellout(command, **kwargs)
+          shellout _to_system_shellout_command(command), **kwargs
+        end
+
+        def system_shellout!(command, **kwargs)
+          shellout! _to_system_shellout_command(command), **kwargs
+        end
+
+        private
+
+        def _to_system_shellout_command(command)
+          cmd = shellout_pack ["cd #{Dir.pwd}", command].join(' && ')
+          "docker exec #{system_shellout_container} chroot /.system_shellout_root bash -ec '#{[
+            *System.default_env_keys.map do |env_key|
+              env_key = env_key.to_s.upcase
+              "export #{env_key}=#{ENV[env_key]}"
+            end, cmd
+          ].join(' && ')}'"
+        end
+
+        public
+
+        class << self
+          def default_env_keys
+            @default_env_keys ||= []
+          end
+        end # << self
+      end # System
+    end
+  end # Project
+end # Dapp

data/lib/dapp/project/ssh_agent.rb

@@ -5,12 +5,13 @@ module Dapp
     module SshAgent
       class << self
         def included(_base)
-          ::Dapp::Helper::Shellout.default_env_keys << 'SSH_AUTH_SOCK'
+          ::Dapp::Project::Shellout::Base.default_env_keys << 'SSH_AUTH_SOCK'
+          ::Dapp::Project::Shellout::System.default_env_keys << 'SSH_AUTH_SOCK'
         end
       end # << self
 
       def run_ssh_agent
-        raise "Cannot fork dapp process: there are active file locks" unless ::Dapp::Lock::File.counter == 0
+        raise 'Cannot fork dapp process: there are active file locks' unless ::Dapp::Lock::File.counter.zero?
 
         sock_name = "dapp-ssh-#{SecureRandom.uuid}"
 
@@ -22,10 +23,10 @@ module Dapp
 
             @ssh_agent_pid = nil
 
-            Signal.trap('INT') {  }
+            Signal.trap('INT') {}
             Signal.trap('TERM') { Process.kill('TERM', @ssh_agent_pid) if @ssh_agent_pid }
 
-            @ssh_agent_pid =  Process.fork do
+            @ssh_agent_pid = Process.fork do
               STDOUT.reopen '/dev/null', 'a'
               STDERR.reopen '/dev/null', 'a'
               exec 'ssh-agent', '-d', '-a', sock_path
@@ -36,9 +37,7 @@ module Dapp
 
           begin
             ::Timeout.timeout(10) do
-              until File.exist? sock_path
-                sleep 0.001
-              end
+              sleep 0.001 until File.exist? sock_path
             end
           rescue ::Timeout::Error
             raise ::Dapp::Error::Project, code: :cannot_run_ssh_agent
@@ -47,7 +46,7 @@ module Dapp
       end
 
       def add_ssh_key(ssh_key_path)
-        shellout! "ssh-add #{ssh_key_path}", env: {SSH_AUTH_SOCK: ssh_auth_sock(force_run_agent: true)}
+        shellout! "ssh-add #{ssh_key_path}", env: { SSH_AUTH_SOCK: ssh_auth_sock(force_run_agent: true) }
       end
 
       def ssh_auth_sock(force_run_agent: false)
@@ -70,7 +69,7 @@ module Dapp
           raise ::Dapp::Error::Project, code: :ssh_key_not_found,
                                         data: { path: ssh_key } unless File.exist? ssh_key
 
-          File.chmod 0600, ssh_key
+          File.chmod 0o600, ssh_key
           add_ssh_key ssh_key
         end
       end