dapp 0.5.13 → 0.6.0

data/lib/dapp/helper/shellout.rb

@@ -5,12 +5,24 @@ module Dapp
       include Streaming
 
       def shellout(*args, log_verbose: false, **kwargs)
-        do_shellout = proc do
-          log_verbose = (log_verbose && cli_options[:log_verbose]) if defined? cli_options
-          kwargs[:live_stream] ||= STDOUT if log_verbose
-          ::Mixlib::ShellOut.new(*args, timeout: 3600, **kwargs).run_command
+        log_verbose = (log_verbose && cli_options[:log_verbose]) if defined? cli_options
+        kwargs[:live_stream] ||= STDOUT if log_verbose
+
+        env = nil
+
+        Shellout.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
@@ -37,9 +49,15 @@ module Dapp
         "eval $(echo #{Base64.strict_encode64(command)} | base64 --decode)"
       end
 
-      def self.included(base)
-        base.extend(self)
-      end
+      class << self
+        def included(base)
+          base.extend(self)
+        end
+
+        def default_env_keys
+          @default_env_keys ||= []
+        end
+      end # << self
     end
   end # Helper
 end # Dapp

data/lib/dapp/helper/streaming.rb

@@ -21,8 +21,6 @@ module Dapp
       module Proxy
         # Base
         class Base
-          include Helper::Log
-
           def initialize(*streams, with_time: false)
             @streams = streams
             @with_time = with_time
@@ -33,7 +31,7 @@ module Dapp
           end
 
           def format_string(str)
-            str.lines.map { |l| "#{log_time if @with_time}#{l.strip}\n" }.join
+            str.lines.map { |l| "#{Project::Logging.log_time if @with_time}#{l.strip}\n" }.join
           end
         end
 

data/lib/dapp/image/argument.rb

@@ -38,8 +38,8 @@ module Dapp
         add_change_option(:user, value)
       end
 
-      def add_cmd(value)
-        add_option(:cmd, value)
+      def add_service_change_label(**options)
+        add_service_change_option(:label, options)
       end
 
       def add_volume(value)
@@ -50,18 +50,25 @@ module Dapp
         add_option(:'volumes-from', value)
       end
 
-      def add_entrypoint(value)
-        add_option(:entrypoint, value)
-      end
-
       def add_command(*commands)
         @bash_commands.concat(commands.flatten)
       end
 
+      def prepare_instructions(options)
+        options.map do |key, vals|
+          case key
+          when :cmd, :entrypoint then [vals]
+          when :env, :label then vals.map(&method(:options_to_args)).flatten
+          else vals
+          end.map { |val| %(#{key.to_s.upcase} #{val}) }
+        end.flatten
+      end
+
       protected
 
       attr_reader :bash_commands
-      attr_reader :options, :change_options
+      attr_reader :change_options, :service_change_options
+      attr_reader :options
 
       def add_option(key, value)
         add_option_default(options, key, value)
@@ -71,11 +78,15 @@ module Dapp
         add_option_default(change_options, key, value)
       end
 
+      def add_service_change_option(key, value)
+        add_option_default(service_change_options, key, value)
+      end
+
       def add_option_default(hash, key, value)
         hash[key] = (hash[key].nil? ? [value] : (hash[key] << value)).flatten
       end
 
-      def from_options
+      def from_change_options
         return {} if from.nil?
         [:entrypoint, :cmd].each_with_object({}) do |option, options|
           options[option] = self.class.image_config_option(image_id: from.built_id, option: option)
@@ -87,21 +98,23 @@ module Dapp
       end
 
       def prepared_options
-        prepared_options_default(options) { |key, vals| Array(vals).map { |val| "--#{key}=#{val}" }.join(' ') }
+        all_options.map { |key, vals| Array(vals).map { |val| "--#{key}=#{val}" } }.flatten.join(' ')
+      end
+
+      def all_options
+        service_options.merge(options)
+      end
+
+      def service_options
+        { entrypoint: '/bin/bash', name: container_name }
       end
 
       def prepared_change
-        prepared_options_default(from_options.merge(change_options)) do |key, vals|
-          case key
-          when :cmd, :entrypoint then [vals]
-          when :env, :label then vals.map(&method(:options_to_args)).flatten
-          else vals
-          end.map { |val| %(-c '#{key.to_s.upcase} #{val}') }.join(' ')
-        end
+        prepare_instructions(all_change_options).map { |instruction| %(-c '#{instruction}') }.join(' ')
       end
 
-      def prepared_options_default(hash)
-        hash.map { |key, vals| yield(key, vals) }.join(' ')
+      def all_change_options
+        from_change_options.merge(change_options.merge(service_change_options) { |_, v1, v2| [v1, v2].flatten })
       end
 
       def prepared_bash_command

data/lib/dapp/image/docker.rb

@@ -7,10 +7,12 @@ module Dapp
 
       attr_reader :from
       attr_reader :name
+      attr_reader :project
 
-      def initialize(name:, from: nil)
+      def initialize(name:, project:, from: nil)
         @from = from
         @name = name
+        @project = project
       end
 
       def id
@@ -43,9 +45,14 @@ module Dapp
         !!@pulled
       end
 
-      def info
+      def created_at
         raise Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
-        [cache[:created_at], cache[:size]]
+        cache[:created_at]
+      end
+
+      def size
+        raise Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
+        cache[:size]
       end
 
       def self.image_config_option(image_id:, option:)
@@ -53,23 +60,23 @@ module Dapp
         output == 'null' ? [] : JSON.parse(output)
       end
 
+      def cache_reset
+        self.class.cache_reset(name)
+      end
+
       protected
 
       def cache
         self.class.cache[name.to_s] || {}
       end
 
-      def cache_reset
-        self.class.cache.delete(name)
-        self.class.cache_reset(name)
-      end
-
       class << self
         def cache
           @cache ||= (@cache = {}).tap { cache_reset }
         end
 
         def cache_reset(name = '')
+          cache.delete(name)
           shellout!("docker images --format='{{.Repository}}:{{.Tag}};{{.ID}};{{.CreatedAt}};{{.Size}}' #{name}").stdout.lines.each do |line|
             name, id, created_at, size = line.split(';')
             cache[name] = { id: id, created_at: created_at, size: size }

data/lib/dapp/image/stage.rb

@@ -5,13 +5,14 @@ module Dapp
     class Stage < Docker
       include Argument
 
-      def initialize(name:, built_id: nil, from: nil)
+      def initialize(name:, project:, built_id: nil, from: nil)
         @bash_commands = []
         @options = {}
         @change_options = {}
-        @container_name = SecureRandom.hex
+        @service_change_options = {}
+        @container_name = "#{name[/[[^:].]*/]}.#{SecureRandom.hex(4)}"
         @built_id = built_id
-        super(name: name, from: from)
+        super(name: name, project: project, from: from)
       end
 
       def labels
@@ -29,18 +30,15 @@ module Dapp
         shellout("docker rm #{container_name}")
       end
 
-      def export!(name, log_verbose: false, log_time: false, force: false)
-        image = self.class.new(built_id: built_id, name: name)
-        image.tag!(log_verbose: log_verbose, log_time: log_time, force: force)
+      def export!(name, log_verbose: false, log_time: false)
+        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.untag!
       end
 
-      def tag!(log_verbose: false, log_time: false, force: false)
-        if !(existed_id = id).nil? && !force
-          raise Error::Build, code: :another_image_already_tagged if built_id != existed_id
-          return
-        end
+      def tag!(log_verbose: false, log_time: false)
+        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)
         cache_reset
       end
@@ -51,7 +49,7 @@ module Dapp
 
       def run!(log_verbose: false, log_time: false, introspect_error: false, introspect_before_error: false)
         raise Error::Build, code: :built_id_not_defined if from.built_id.nil?
-        shellout!("docker run #{prepared_options} --entrypoint /bin/bash --name=#{container_name} #{from.built_id} -ec '#{prepared_bash_command}'",
+        shellout!("docker run #{prepared_options} #{from.built_id} -ec '#{prepared_bash_command}'",
                   log_verbose: log_verbose, log_time: log_time)
       rescue Error::Shellout => _e
         raise unless introspect_error || introspect_before_error

data/lib/dapp/lock/base.rb

@@ -0,0 +1,44 @@
+module Dapp
+  # Lock
+  module Lock
+    # Base
+    class Base
+      attr_reader :name
+      attr_reader :on_wait
+      attr_reader :timeout
+
+      def initialize(name, timeout: 60, on_wait: nil)
+        @name = name
+        @on_wait = on_wait
+        @timeout = timeout
+      end
+
+      def lock(shared: false)
+        raise
+      end
+
+      def unlock
+        raise
+      end
+
+      def synchronize(*args)
+        lock(*args)
+        begin
+          yield if block_given?
+        ensure
+          unlock
+        end
+      end
+
+      protected
+
+      def _waiting(&blk)
+        if @on_wait
+          @on_wait.call { ::Timeout.timeout(timeout, &blk) }
+        else
+          ::Timeout.timeout(timeout, &blk)
+        end
+      end
+    end # Base
+  end # Lock
+end # Dapp

data/lib/dapp/lock/error.rb

@@ -0,0 +1,14 @@
+module Dapp
+  # Lock
+  module Lock
+    # Error
+    module Error
+      # Timeout
+      class Timeout < ::Dapp::Error::Base
+        def initialize(**net_status)
+          super(context: :lock, **net_status)
+        end
+      end # Timeout
+    end # Error
+  end # Lock
+end # Dapp

data/lib/dapp/lock/file.rb

@@ -0,0 +1,33 @@
+module Dapp
+  # Lock
+  module Lock
+    # File
+    class File < Base
+      attr_reader :lock_path
+
+      def initialize(lock_path, name, **kwargs)
+        super(name, **kwargs)
+        @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)
+
+        begin
+          mode = (shared ? ::File::LOCK_SH : ::File::LOCK_EX)
+          _waiting { @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 }
+        end
+      end
+
+      def unlock
+        @file.flock(::File::LOCK_UN)
+        @file.close
+        @file = nil
+      end
+    end # File
+  end # Lock
+end # Dapp

data/lib/dapp/prctl.rb

@@ -0,0 +1,22 @@
+module Prctl
+  PR_SET_PDEATHSIG = 1
+
+  class << self
+    def _fiddle_func
+      require 'fiddle'
+      @_fiddle_func ||= Fiddle::Function.new(
+        Fiddle::Handle['prctl'.freeze], [
+          Fiddle::TYPE_INT,
+          Fiddle::TYPE_LONG,
+          Fiddle::TYPE_LONG,
+          Fiddle::TYPE_LONG,
+          Fiddle::TYPE_LONG
+        ], Fiddle::TYPE_INT
+      )
+    end
+
+    def call(*a)
+      _fiddle_func.call(*a)
+    end
+  end
+end

data/lib/dapp/project.rb

@@ -0,0 +1,75 @@
+module Dapp
+  # Project
+  class Project
+    include Lock
+    include Dappfile
+    include Paint
+    include Command::Common
+    include Command::Run
+    include Command::Build
+    include Command::Bp
+    include Command::Push
+    include Command::Spush
+    include Command::List
+    include Command::StagesFlush
+    include Command::StagesCleanup
+    include Command::Cleanup
+    include Logging::Base
+    include Logging::Process
+
+    include SshAgent
+    include Helper::I18n
+    include Helper::Shellout
+    include Helper::Paint
+    include Helper::Sha256
+
+    attr_reader :cli_options
+    attr_reader :apps_patterns
+
+    def initialize(cli_options: {}, apps_patterns: nil)
+      @cli_options = cli_options
+      @apps_patterns = apps_patterns || []
+      @apps_patterns << '*' unless @apps_patterns.any?
+
+      paint_initialize
+      Helper::I18n.initialize
+    end
+
+    def name
+      @name ||= begin
+        shellout!("git -C #{path} config --get remote.origin.url").stdout.strip.split('/').last[/.*(?=.git)/]
+      rescue Error::Shellout
+        File.basename(path)
+      end
+    end
+
+    def path
+      @path ||= begin
+        dappfile_path = dappfiles.first
+        if File.basename(expand_path(dappfile_path, 2)) == '.dapps'
+          expand_path(dappfile_path, 3)
+        else
+          expand_path(dappfile_path)
+        end
+      end
+    end
+
+    def build_path
+      @build_path ||= begin
+        if cli_options[:build_dir]
+          Pathname.new(cli_options[:build_dir])
+        else
+          Pathname.new(path).join('.dapps_build')
+        end.expand_path.tap(&:mkpath)
+      end
+    end
+
+    def cache_format
+      "dappstage-#{name}-%{application_name}"
+    end
+
+    def stage_dapp_label_format
+      '%{application_name}'
+    end
+  end # Project
+end # Dapp