dapp 0.10.2 → 0.36.24

data/lib/dapp/cli/command/update.rb

@@ -0,0 +1,65 @@
+module Dapp
+  class CLI
+    module Command
+      class Update < ::Dapp::CLI
+        banner <<BANNER.freeze
+Usage:
+
+  dapp update
+
+Options:
+BANNER
+
+        def run(argv = ARGV)
+          self.class.parse_options(self, argv)
+
+          spec = Gem::Specification.find do |s|
+            File.fnmatch?(File.join(s.full_gem_path, '**', '*'), __FILE__, File::FNM_PATHNAME)
+          end
+          unless (latest_version = latest_beta_version(spec)).nil?
+            try_lock do
+              Gem.install(spec.name, latest_version)
+            end
+          end
+        rescue Gem::FilePermissionError => e
+          raise Errno::EACCES, e.message
+        end
+
+        def latest_beta_version(current_spec)
+          minor_version = current_spec.version.approximate_recommendation
+          url = "https://rubygems.org/api/v1/versions/#{current_spec.name}.json"
+          response = Excon.get(url)
+          if response.status == 200
+            JSON.parse(response.body)
+              .reduce([]) { |versions, spec| versions << Gem::Version.new(spec['number']) }
+              .reject { |spec_version| minor_version != spec_version.approximate_recommendation || current_spec.version >= spec_version }
+              .first
+          else
+            warn "Cannot get `#{url}`: got bad http status `#{response.status}`"
+          end
+        end
+
+        def try_lock
+          old_umask = File.umask(0)
+          file = nil
+
+          begin
+            begin
+              file = ::File.open('/tmp/dapp-update-running.lock', ::File::RDWR | ::File::CREAT, 0777)
+            ensure
+              File.umask(old_umask)
+            end
+
+            if file.flock(::File::LOCK_EX | ::File::LOCK_NB)
+              yield
+            else
+              puts 'There are other active dapp update process, exiting without update'
+            end
+          ensure
+            file.close unless file.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dapp/cli/options/ssh.rb

@@ -0,0 +1,18 @@
+module Dapp
+  class CLI
+    module Options
+      module Ssh
+        def self.extended(klass)
+          klass.class_eval do
+            option :ssh_key,
+                  long: '--ssh-key SSH_KEY',
+                  description: ['Enable only specified ssh keys ',
+                                '(use system ssh-agent by default)'].join,
+                  default: nil,
+                  proc: ->(v) { composite_options(:ssh_key) << v }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dapp/cli/options/tag.rb

@@ -0,0 +1,51 @@
+module Dapp
+  class CLI
+    module Options
+      module Tag
+        def self.extended(klass)
+          klass.class_eval do
+            "Add tag (can be used one or more times), specified text will be slugified".tap do |desc|
+              option :tag,
+                      long: '--tag TAG',
+                      description: desc,
+                      default: [],
+                      proc: proc { |v| composite_options(:tags) << v }
+
+              option :tag_slug,
+                      long: '--tag-slug TAG',
+                      description: desc,
+                      default: [],
+                      proc: proc { |v| composite_options(:slug_tags) << v }
+            end
+
+            option :tag_plain,
+                   long: '--tag-plain TAG',
+                   description: "Add tag (can be used one or more times)",
+                   default: [],
+                   proc: proc { |v| composite_options(:plain_tags) << v }
+
+            option :tag_branch,
+                   long: '--tag-branch',
+                   description: 'Tag by git branch',
+                   boolean: true
+
+            option :tag_build_id,
+                   long: '--tag-build-id',
+                   description: 'Tag by CI build id',
+                   boolean: true
+
+            option :tag_ci,
+                   long: '--tag-ci',
+                   description: 'Tag by CI branch and tag',
+                   boolean: true
+
+            option :tag_commit,
+                   long: '--tag-commit',
+                   description: 'Tag by git commit',
+                   boolean: true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dapp/cli.rb

@@ -5,14 +5,18 @@ module Dapp
     extend Helper::Cli
     include Helper::Trivia
 
-    SUBCOMMANDS = ['dimg'].freeze
+    SUBCOMMANDS = %w(dimg kube update sample slug).freeze
 
     banner <<BANNER.freeze
-Usage: dapp [options] sub-command [sub-command options]
+Usage: dapp subcommand [subcommand options]
 
 Available subcommands: (for details, dapp SUB-COMMAND --help)
 
-dapp dimg
+  dapp dimg
+  dapp kube
+  dapp update
+  dapp sample
+  dapp slug STRING
 
 Options:
 BANNER
@@ -34,6 +38,10 @@ BANNER
            show_options: true,
            exit: 0
 
+    class << self
+      attr_accessor :dapp_object
+    end
+
     def initialize(*args)
       super(*args)
 

data/lib/dapp/config/config.rb

@@ -0,0 +1,21 @@
+module Dapp
+  module Config
+    class Config < Directive::Base
+      def dev_mode
+        @_dev_mode = true
+      end
+
+      def _dev_mode
+        !!@_dev_mode
+      end
+
+      def after_parsing!
+        do_all!('_after_parsing!')
+      end
+
+      def validate!
+        do_all!('_validate!')
+      end
+    end
+  end
+end

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

@@ -1,20 +1,117 @@
 module Dapp
   module Config
     module Directive
-      class Base < Config::Base
+      class Base
+        def initialize(dapp:, &blk)
+          @dapp = dapp
+          initialize_variables
+          instance_eval(&blk) if block_given?
+        end
+
         def clone
           _clone
         end
 
+        def encode_with(coder)
+          (instance_variables - [:@dapp]).each do |var|
+            var = var.to_s
+            coder[var.gsub('@', '')] = instance_variable_get(var)
+          end
+        end
+
         protected
 
+        attr_reader :dapp
+
+        def path_format(path)
+          path = path.to_s
+          path = path.chomp('/') unless path == '/'
+          path
+        end
+
+        def validate_compliance!(pattern, value, error_code)
+          return if /^#{pattern}$/ =~ value
+          raise ::Dapp::Error::Config, code: error_code, data: { value: value, pattern: pattern }
+        end
+
+        def initialize_variables
+          do_all!('_init_variables!')
+        end
+
+        def do_all!(postfix)
+          methods
+            .select { |m| m.to_s.end_with? postfix }
+            .each(&method(:send))
+        end
+
+        def directive_eval(directive, &blk)
+          directive.instance_eval(&blk) if block_given?
+          directive
+        end
+
         def sub_directive_eval
           yield if block_given?
           self
         end
 
-        def path_format(path)
-          path.to_s.chomp('/')
+        def pass_to(obj, clone_method = :clone)
+          passed_directives.each do |directive|
+            obj.instance_variable_set(directive, clone_variable(instance_variable_get(directive), clone_method))
+          end
+          obj
+        end
+
+        def clone_variable(var, clone_method = :clone)
+          case var
+          when Base then var.public_send(clone_method)
+          when String, Symbol, Integer, TrueClass, FalseClass then var
+          when Array, Hash then marshal_clone(var)
+          when NilClass then nil
+          else
+            raise
+          end
+        end
+
+        def passed_directives
+          []
+        end
+
+        def ref_variables
+          [:@dapp]
+        end
+
+        def marshal_dump
+          instance_variables
+            .reject {|variable| ref_variables.include? variable}
+            .map {|variable| [variable, instance_variable_get(variable)]}
+        end
+
+        def marshal_load(variable_values)
+          variable_values.each { |variable, value| instance_variable_set(variable, clone_variable(value)) }
+          self
+        end
+
+        def _clone
+          marshal_clone(self).tap do |obj|
+            _set_ref_variables_to(obj)
+          end
+        end
+
+        def _clone_to(obj)
+          obj.tap do
+            obj.marshal_load(marshal_dump)
+            _set_ref_variables_to(obj)
+          end
+        end
+
+        def _set_ref_variables_to(obj)
+          ref_variables.each do |ref_variable|
+            obj.instance_variable_set(ref_variable, instance_variable_get(ref_variable))
+          end
+        end
+
+        def marshal_clone(obj)
+          Marshal.load(Marshal.dump(obj))
         end
       end
     end

data/lib/dapp/core_ext/hash.rb

@@ -12,6 +12,20 @@ module Dapp
           end
         end
       end
+
+      def symbolize_keys
+        transform_keys { |key| key.to_sym rescue key }
+      end
+
+      private
+
+      def transform_keys
+        result = {}
+        each_key do |key|
+          result[yield(key)] = self[key]
+        end
+        result
+      end
     end
   end
 end

data/lib/dapp/core_ext/pathname.rb

@@ -8,13 +8,15 @@ module Dapp
         path_descends = []
         cleanpath.descend {|d| path_descends << d}
 
-        (path_descends & another_path_descends) == another_path_descends &&
-          (path_descends - another_path_descends).any?
+        (path_descends & another_path_descends) == another_path_descends
       end
 
       def subpath_of(another_path)
-        return unless subpath_of? another_path
-        cleanpath.to_s.partition(::Pathname.new(another_path).cleanpath.to_s + '/').last
+        another_cleanpath = ::Pathname.new(another_path).cleanpath
+
+        return     unless subpath_of? another_path
+        return '.' if cleanpath.to_s == another_cleanpath.to_s
+        cleanpath.to_s.partition(another_cleanpath.to_s + '/').last
       end
     end # Pathname
   end # CoreExt

data/lib/dapp/dapp/chef.rb

@@ -1,16 +1,8 @@
 module Dapp
   class Dapp
     module Chef
-      def local_git_artifact_exclude_paths(&blk)
-        super do |exclude_paths|
-          exclude_paths << '.dapp_chef'
-
-          yield exclude_paths if block_given?
-        end
-      end
-
       def builder_cookbook_path
-        Pathname.new(path).join('.dapp_chef')
+        path('.dapp_chef')
       end
     end # Chef
   end # Dapp

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

@@ -0,0 +1,24 @@
+module Dapp
+  class Dapp
+    module Command
+      module Common
+        def option_repo
+          shortcut_or_key(options[:repo])
+        end
+
+        def shortcut_or_key(key)
+          shortcuts[key] || key
+        end
+
+        def shortcuts
+          { ':minikube' => "localhost:5000/#{name}" }
+        end
+
+        def dimg_registry(repo = option_repo)
+          validate_repo_name!(repo)
+          ::Dapp::Dimg::DockerRegistry.new(self, repo)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Dapp
+  class Dapp
+    module Command
+      module Sample
+        module Common
+          def _sample_list
+            @sample_list ||= [].tap do |list|
+              tree = begin
+                latest_commit = _sample_git_repo.latest_branch_commit(_samples_git_repo_branch)
+                latest_commit_tree = _sample_git_repo.lookup_commit(latest_commit).tree
+
+                if _samples_dir == '.'
+                  latest_commit_tree
+                else
+                  begin
+                    oid = latest_commit_tree.path(_samples_dir)[:oid]
+                  rescue Rugged::TreeError
+                    raise Error::Command, code: :samples_directory_not_exist, data: { url: _samples_git_repo_url, path: _samples_dir }
+                  end
+
+                  _sample_git_repo.lookup_object(oid)
+                end
+              end
+
+              tree.each_tree { |entry| list << entry[:name] }
+            end
+          end
+
+          def _sample_git_repo
+            @sample_repo ||= begin
+              Dimg::GitRepo::Remote.get_or_create(
+                self,
+                git_url_to_name(_samples_git_repo_url),
+                url: _samples_git_repo_url
+              )
+            end
+          end
+
+          def _samples_git_repo_url
+            options[:samples_repo]
+          end
+
+          def _samples_git_repo_branch
+            options[:samples_branch]
+          end
+
+          def _samples_dir
+            options[:samples_dir]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dapp/command/sample/create.rb

@@ -0,0 +1,57 @@
+module Dapp
+  class Dapp
+    module Command
+      module Sample
+        module Create
+          def sample_create(sample_name)
+            sample_exist!(sample_name)
+
+            _sample_repo_blobs_entries(sample_name).each do |root, entry|
+              file_path = _sample_slice_cwd(sample_name, File.join(root, entry[:name]))
+              content = _sample_git_repo.lookup_object(entry[:oid]).content
+
+              begin
+                FileUtils.mkdir_p(File.dirname(file_path))
+                if entry[:filemode] == 0o120000 # symlink
+                  FileUtils.symlink(content, file_path)
+                else
+                  IO.write(file_path, content)
+                  FileUtils.chmod(entry[:filemode], file_path)
+                end
+              rescue Errno::EEXIST => e
+                log_warning("File `#{file_path}` skipped: `#{e.message}`")
+              end
+            end
+          end
+
+          def sample_exist!(sample_name)
+            return if sample_exist?(sample_name)
+            raise Error::Command, code: :sample_not_exist, data: { name: sample_name, url: _samples_git_repo_url, path: _samples_dir }
+          end
+
+          def sample_exist?(sample_name)
+            _sample_list.include?(sample_name)
+          end
+
+          def _sample_repo_blobs_entries(sample_name)
+            _sample_git_repo
+              .blobs_entries(_sample_git_repo.latest_branch_commit(_samples_git_repo_branch), paths: [_sample_directory(sample_name)])
+              .reject { |_, entry| entry[:filemode] == 0o160000 }
+          end
+
+          def _sample_directory(sample_name)
+            File.expand_path(File.join('/', _samples_dir, sample_name))[1..-1]
+          end
+
+          def _sample_slice_cwd(sample_name, path)
+            path
+              .reverse
+              .chomp(_sample_directory(sample_name).reverse)
+              .chomp('/')
+              .reverse
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Dapp
+  class Dapp
+    module Command
+      module Sample
+        module List
+          def sample_list
+            _sample_list.each(&method(:puts))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dapp/command/slug.rb

@@ -0,0 +1,11 @@
+module Dapp
+  class Dapp
+    module Command
+      module Slug
+        def slug(str)
+          puts consistent_uniq_slugify(str)
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dapp/dapp_config.rb

@@ -0,0 +1,85 @@
+module Dapp
+  class Dapp
+    module DappConfig
+      SUPPORTED_CONFIG_OPTIONS = {
+        verbose:   [FalseClass, TrueClass],
+        quiet:     [FalseClass, TrueClass],
+        dev:       [FalseClass, TrueClass],
+        time:      [FalseClass, TrueClass],
+        dry_run:   [FalseClass, TrueClass],
+        build_dir: [String],
+        color:     [String]
+      }
+
+      SUPPORTED_CONFIG_OPTIONS.keys.each do |opt|
+        define_method "option_#{opt}" do
+          options[opt] || config_options[opt]
+        end
+      end
+
+      def option_color
+        if options[:color] == 'auto'
+          config_options[:color] || 'auto'
+        else
+          options[:color]
+        end
+      end
+
+      def option_dev
+        if options[:dev].nil?
+          config._dev_mode || config_options[:dev]
+        else
+          options[:dev]
+        end
+      end
+
+      def config_options
+        @config_options ||= begin
+          config_search_paths = []
+          config_search_paths << File.join(Dir.home)
+          config_search_paths << path if dappfile_exists?
+
+          config_search_paths.reduce({}) do |options, dir|
+            if (config_options_path = make_path(dir, '.dapp_config')).file?
+              config_options = begin
+                yaml_load_file(config_options_path).tap do |c_options|
+                  c_options.merge!(c_options.in_depth_merge(c_options['ci'] || {})) if ENV['GITLAB_CI'] || ENV['TRAVIS']
+                  c_options.delete('ci')
+                end
+              rescue Psych::SyntaxError => e
+                raise Error::Dapp, code: :dapp_config_file_incorrect, data: { message: e.message }
+              end
+              options.in_depth_merge(config_options)
+            else
+              options
+            end
+          end.symbolize_keys
+        end
+      end
+
+      def validate_config_options!
+        data_list_format = proc { |list| list.map { |e| "'#{e}'" }.join(', ') }
+
+        unless (unsupported_keys = config_options.select { |k, _| !SUPPORTED_CONFIG_OPTIONS.keys.include?(k) }.keys).empty?
+          log_warning(desc: { code: :unsupported_dapp_config_options,
+                              data: { options: data_list_format.call(unsupported_keys),
+                                      supported_options: data_list_format.call(SUPPORTED_CONFIG_OPTIONS.keys) } })
+        end
+
+        config_options.each do |k, v|
+          next unless SUPPORTED_CONFIG_OPTIONS.keys.include?(k)
+
+          if k == :color
+            raise Error::Dapp,
+                  code: :incorrect_dapp_config_option_color,
+                  data: { value: v, expected: data_list_format.call(%w(auto on off)) } unless %w(auto on off).member?(v)
+          elsif !SUPPORTED_CONFIG_OPTIONS[k].member? v.class
+            raise Error::Dapp,
+                  code: :incorrect_dapp_config_option,
+                  data: { option: k, value: v, expected: data_list_format.call(SUPPORTED_CONFIG_OPTIONS[k]) }
+          end
+        end
+      end
+    end # DappConfig
+  end # Dapp
+end # Dapp