dapp 0.29.2 → 0.30.0

data/lib/dapp/dimg/git_repo/remote.rb

@@ -2,15 +2,14 @@ module Dapp
   module Dimg
     module GitRepo
       class Remote < Base
-        CACHE_VERSION = 1
+        CACHE_VERSION = 2
 
         attr_reader :url
-        attr_reader :path
 
         class << self
-          def get_or_create(dapp, name, url:, branch:, ignore_git_fetch: false)
-            key         = [url, branch, ignore_git_fetch]
-            inverse_key = [url, branch, !ignore_git_fetch]
+          def get_or_create(dapp, name, url:, ignore_git_fetch: false)
+            key         = [url, ignore_git_fetch]
+            inverse_key = [url, !ignore_git_fetch]
 
             repositories[key] ||= begin
               if repositories.key?(inverse_key)
@@ -18,7 +17,7 @@ module Dapp
               else
                 new(dapp, name, url: url)
               end.tap do |repo|
-                repo.fetch!(branch, ignore_git_fetch: ignore_git_fetch) unless ignore_git_fetch
+                repo.fetch! unless ignore_git_fetch
               end
             end
           end
@@ -63,13 +62,11 @@ module Dapp
         end
 
         def path
-          Pathname(dapp.build_path("remote_git_repo", CACHE_VERSION.to_s, name).to_s)
+          Pathname(dapp.build_path("remote_git_repo", CACHE_VERSION.to_s, dapp.consistent_uniq_slugify(name)).to_s)
         end
 
-        def fetch!(branch = nil, ignore_git_fetch: false)
+        def fetch!
           _with_lock do
-            branch ||= self.branch
-
             cfg_path = path.join("config")
             cfg = IniFile.load(cfg_path)
             remote_origin_cfg = cfg['remote "origin"']
@@ -82,21 +79,19 @@ module Dapp
 
             dapp.log_secondary_process(dapp.t(code: 'process.git_artifact_fetch', data: { url: url }), short: true) do
               begin
-                git.fetch('origin', [branch], credentials: _rugged_credentials)
+                git.remotes.each { |remote| remote.fetch(credentials: _rugged_credentials) }
               rescue Rugged::SshError => e
                 raise Error::Rugged, code: :rugged_remote_error, data: { url: url, message: e.message.strip }
               end
-              raise Error::Rugged, code: :branch_not_exist_in_remote_git_repository, data: { branch: branch, url: url } unless branch_exist?(branch)
             end
-          end unless ignore_git_fetch || dapp.dry_run?
-        end
-
-        def branch_exist?(name)
-          git.branches.exist?(branch_format(name))
+          end unless dapp.dry_run?
         end
 
-        def latest_commit(name)
-          git.ref("refs/remotes/#{branch_format(name)}").target_id
+        def latest_commit(branch)
+          git.ref("refs/remotes/#{branch_format(branch)}").tap do |ref|
+            raise Error::Rugged, code: :branch_not_exist_in_remote_git_repository, data: { branch: branch, url: url } if ref.nil?
+            break ref.target_id
+          end
         end
 
         def lookup_commit(commit)
@@ -105,6 +100,24 @@ module Dapp
           raise Error::Rugged, code: :commit_not_found_in_remote_git_repository, data: { commit: commit, url: url }
         end
 
+        def submodules_git(commit)
+          submodules_git_path(commit).tap do |git_path|
+            break begin
+              if git_path.directory?
+                Rugged::Repository.new(git_path.to_s)
+              else
+                Rugged::Repository.clone_at(path.to_s, git_path.to_s).tap do |submodules_git|
+                  submodules_git.checkout(commit)
+                end
+              end
+            end
+          end
+        end
+
+        def submodules_git_path(commit)
+          Pathname(File.join(dapp.host_docker_tmp_config_dir, "submodule", dapp.consistent_uniq_slugify(name), commit).to_s)
+        end
+
         protected
 
         def git

data/lib/dapp/kube/cli/command/kube/deploy.rb

@@ -15,6 +15,10 @@ BANNER
              long: '--namespace NAME',
              default: nil
 
+      option :context,
+             long: '--context NAME',
+             default: nil
+
       option :image_version,
              long: '--image-version TAG',
              description: "Custom tag (alias for --tag)",

data/lib/dapp/kube/cli/command/kube/dismiss.rb

@@ -13,6 +13,10 @@ BANNER
              long: '--namespace NAME',
              default: nil
 
+      option :context,
+             long: '--context NAME',
+             default: nil
+
       option :with_namespace,
              long: '--with-namespace',
              default: false

data/lib/dapp/kube/cli/command/kube/lint.rb

@@ -14,6 +14,10 @@ BANNER
              long: '--namespace NAME',
              default: nil
 
+      option :context,
+             long: '--context NAME',
+             default: nil
+
       option :helm_set_options,
              long: '--set STRING_ARRAY',
              default: [],

data/lib/dapp/kube/cli/command/kube/render.rb

@@ -14,6 +14,10 @@ BANNER
              long: '--namespace NAME',
              default: nil
 
+      option :context,
+             long: '--context NAME',
+             default: nil
+
       option :tmp_dir_prefix,
              long: '--tmp-dir-prefix PREFIX',
              description: 'Tmp directory prefix (/tmp by default). Used for build process service directories.'

data/lib/dapp/kube/cli/command/kube/value_get.rb

@@ -14,6 +14,10 @@ BANNER
         long: '--namespace NAME',
         default: nil
 
+      option :context,
+        long: '--context NAME',
+        default: nil
+
       option :registry_username,
         long: '--registry-username USERNAME'
 

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

@@ -341,29 +341,32 @@ image: {{ tuple $name $context | include "_dimg2" }}
             options[:namespace].nil? ? nil : consistent_uniq_slugify(options[:namespace])
           end
 
+          def context_option
+            options[:context]
+          end
+
+          def kube_context
+            ENV["KUBECONTEXT"] ||
+              context_option ||
+                kubernetes_config.current_context_name
+          end
+
           def kube_namespace
-            namespace_option || begin
-              namespace = "default"
-
-              Kubernetes::Client.tap do |kube|
-                kube_config = kube.kube_config(kube.kube_config_path)
-                if kube_config
-                  kube_context_name = kube.kube_context_name(kube_config)
-                  kube_context_config = kube.kube_context_config(kube_config, kube_context_name)
-
-                  if kube_context_config
-                    context_namespace = kube.kube_context_namespace(kube_context_config)
-                    namespace = context_namespace if context_namespace
-                  end
-                end
-              end
+            namespace_option ||
+              kubernetes_config.namespace(kube_context) ||
+                "default"
+          end
 
-              namespace
-            end
+          def kubernetes_config
+            @kubernetes_config ||= Kubernetes::Config.new_auto
           end
 
           def kubernetes
-            @kubernetes ||= Kubernetes::Client.new(namespace: kube_namespace)
+            @kubernetes ||= Kubernetes::Client.new(
+              kubernetes_config,
+              kube_context,
+              kube_namespace,
+            )
           end
         end
       end

data/lib/dapp/kube/dapp/command/minikube_setup.rb

@@ -34,7 +34,7 @@ module Dapp
                 _minikube_set_original_sudo_caller_process_user!
 
                 begin
-                  if shellout!('minikube status', verbose: true).stdout.split("\n").map(&:strip).first == 'minikubeVM: Running'
+                  if shellout('minikube status').stdout.split("\n").map(&:strip).first =~ /minikube(VM)?: Running/
                     shellout! 'minikube stop', verbose: true
                   end
                   shellout! 'minikube start --insecure-registry localhost:5000', verbose: true
@@ -251,7 +251,11 @@ module Dapp
           end
 
           def _minikube_kubernetes
-            @_minikube_kubernetes ||= Kubernetes::Client.new(namespace: 'kube-system')
+            @_minikube_kubernetes ||= Kubernetes::Client.new(
+              kubernetes_config,
+              kubernetes_config.current_context_name,
+              'kube-system'
+            )
           end
 
           def _minikube_registry_replicationcontroller_spec

data/lib/dapp/kube/helm/release.rb

@@ -151,7 +151,7 @@ module Dapp
 
       def helm_set_options(without_registry: false, fake: false)
         [].tap do |options|
-          options.concat set.map {|opt| "--set #{opt}"}
+          options.concat set.map {|opt| "--set '#{opt}'"}
 
           service_values = Helm::Values.service_values(dapp, repo, namespace, docker_tag,
                                                        without_registry: self.without_registry || without_registry,

data/lib/dapp/kube/helm/values.rb

@@ -1,7 +1,7 @@
 module Dapp
   module Kube
     class Helm::Values
-      TEMPLATE_EMPTY_VALUE = "\\\"-\\\""
+      TEMPLATE_EMPTY_VALUE = '"-"'.freeze
 
       class << self
         def service_values(*a, &b)
@@ -17,7 +17,7 @@ module Dapp
                 "repo" => repo,
                 "docker_tag" => docker_tag,
               },
-              "ci" => ENV.select { |k, _| k.start_with?("CI_") } ,
+              "ci" => ENV.select { |k, _| k.start_with?('CI_') },
             }
           }
 
@@ -140,7 +140,7 @@ module Dapp
       end
 
       def to_set_options
-        as_set_options.map {|k, v| "--set #{k}=#{v}"}
+        as_set_options.map {|k, v| "--set '#{k}=#{v}'"}
       end
     end # Helm::ServiceValues
   end # Kube

data/lib/dapp/kube/kubernetes/client.rb

@@ -35,12 +35,6 @@ module Dapp
           '/apis/batch/v1' => [:job, ],
           '/apis/batch/v1beta1' => [:cronjob, ],
         },
-        '1.11' => {
-          '/api/v1' => [:service, :replicationcontroller, :pod, :podtemplate, ],
-          '/apis/apps/v1' => [:daemonset, :deployment, :replicaset, :statefulset, ],
-          '/apis/batch/v1' => [:job, ],
-          '/apis/batch/v1beta1' => [:cronjob, ],
-        },
         'stable' => {
           '/api/v1' => [:service, :replicationcontroller, :pod, :podtemplate, ],
           '/apis/batch/v1' => [:job, ],
@@ -53,17 +47,18 @@ module Dapp
 
         ::Dapp::Dapp::Shellout::Base.default_env_keys << 'KUBECONFIG'
 
-        #
-        def initialize(namespace: nil)
+        attr_reader :config
+        attr_reader :context
+        attr_reader :namespace
+
+        def initialize(config, context, namespace)
+          @config = config
+          @context = context
           @namespace = namespace
           @query_parameters = {}
           @cluster_version
         end
 
-        def namespace
-          @namespace || self.class.kube_context_namespace(kube_context_config) || "default"
-        end
-
         # Чтобы не перегружать методы явной передачей namespace.
         # Данный метод может пригодиться только в ситуации, когда надо указать другой namespace,
         # в большинстве случаев используется namespace из конструктора.
@@ -250,11 +245,13 @@ module Dapp
 
         def with_connection(excon_parameters: {}, &blk)
           connection = begin
-            Excon.new(kube_cluster_config['cluster']['server'], **kube_server_options(excon_parameters)).tap(&:get)
+            context_config = config.context_config(context)
+            cluster_config = config.cluster_config(context_config['cluster'])
+            Excon.new(cluster_config['server'], **kube_server_options(excon_parameters)).tap(&:get)
           rescue Excon::Error::Socket => err
             raise Error::ConnectionRefused,
                   code: :server_connection_refused,
-                  data: { kube_cluster_config: kube_cluster_config, kube_user_config: kube_user_config, error: err.message }
+                  data: { url: cluster_config['server'], error: err.message }
           end
 
           return yield connection
@@ -262,22 +259,26 @@ module Dapp
 
         def kube_server_options(excon_parameters = {})
           {}.tap do |opts|
-            client_cert = kube_config.fetch('users', [{}]).first.fetch('user', {}).fetch('client-certificate', nil)
+            context_config = config.context_config(context)
+            user_config = config.user_config(context_config['user'])
+            cluster_config = config.cluster_config(context_config['cluster'])
+
+            client_cert = user_config['client-certificate']
             opts[:client_cert] = client_cert if client_cert
 
-            client_cert_data = kube_config.fetch('users', [{}]).first.fetch('user', {}).fetch('client-certificate-data', nil)
+            client_cert_data= user_config['client-certificate-data']
             opts[:client_cert_data] = Base64.decode64(client_cert_data) if client_cert_data
 
-            client_key = kube_config.fetch('users', [{}]).first.fetch('user', {}).fetch('client-key', nil)
+            client_key = user_config['client-key']
             opts[:client_key] = client_key if client_key
 
-            client_key_data = kube_config.fetch('users', [{}]).first.fetch('user', {}).fetch('client-key-data', nil)
+            client_key_data = user_config['client-key-data']
             opts[:client_key_data] = Base64.decode64(client_key_data) if client_key_data
 
             ssl_cert_store = OpenSSL::X509::Store.new
-            if ssl_ca_file = kube_config.fetch('clusters', [{}]).first.fetch('cluster', {}).fetch('certificate-authority', nil)
+            if ssl_ca_file = cluster_config['certificate-authority']
               ssl_cert_store.add_file ssl_ca_file
-            elsif ssl_ca_data = kube_config.fetch('clusters', [{}]).first.fetch('cluster', {}).fetch('certificate-authority-data', nil)
+            elsif ssl_ca_data = cluster_config['certificate-authority-data']
               ssl_cert_store.add_cert OpenSSL::X509::Certificate.new(Base64.decode64(ssl_ca_data))
             end
             opts[:ssl_cert_store] = ssl_cert_store
@@ -289,76 +290,6 @@ module Dapp
             opts.merge!(excon_parameters)
           end
         end
-
-        def kube_user_config
-          @kube_user_config ||= begin
-            kube_user_config = self.class.kube_user_config(kube_config, kube_context_config['context']['user'])
-            raise Error::BadConfig, code: :user_config_not_found, data: {config_path: self.class.kube_config_path, context: kube_context_config, user: kube_context_config['context']['user']} if kube_user_config.nil?
-            kube_user_config
-          end
-        end
-
-        def kube_cluster_config
-          @kube_cluster_config ||= begin
-            kube_cluster_config = self.class.kube_cluster_config(kube_config, kube_context_config['context']['cluster'])
-            raise Error::BadConfig, code: :cluster_config_not_found, data: {config_path: self.class.kube_config_path, context: kube_context_config, cluster: kube_context_config['context']['cluster']} if kube_cluster_config.nil?
-            kube_cluster_config
-          end
-        end
-
-        def kube_context_config
-          @kube_context_config ||= begin
-            context_name = self.class.kube_context_name(kube_config)
-            kube_context_config = self.class.kube_context_config(kube_config, context_name)
-            raise Error::BadConfig, code: :config_context_not_found, data: {config_path: self.class.kube_config_path, config: kube_config, context_name: context_name} if kube_context_config.nil?
-            kube_context_config
-          end
-        end
-
-        def kube_config
-          @kube_config ||= begin
-            kube_config = self.class.kube_config(self.class.kube_config_path)
-            raise Error::BadConfig, code: :config_not_found, data: { config_path: self.class.kube_config_path } if kube_config.nil?
-            kube_config
-          end
-        end
-
-        class << self
-          def kube_config_path
-            kube_config_path = ENV['KUBECONFIG']
-            kube_config_path = File.join(ENV['HOME'], '.kube/config') unless kube_config_path
-            kube_config_path
-          end
-
-          def kube_config(kube_config_path)
-            yaml_load_file(kube_config_path) if File.exist?(kube_config_path)
-          end
-
-          def kube_context_name(kube_config)
-            kube_config['current-context'] || begin
-              if (context = kube_config.fetch('contexts', []).first)
-                warn "[WARN] .kube/config current-context is not set, using context '#{context['name']}'"
-                context['name']
-              end
-            end
-          end
-
-          def kube_context_config(kube_config, kube_context_name)
-            kube_config.fetch('contexts', []).find {|context| context['name'] == kube_context_name}
-          end
-
-          def kube_user_config(kube_config, user_name)
-            kube_config.fetch('users', []).find {|user| user['name'] == user_name}
-          end
-
-          def kube_cluster_config(kube_config, cluster_name)
-            kube_config.fetch('clusters', []).find {|cluster| cluster['name'] == cluster_name}
-          end
-
-          def kube_context_namespace(kube_context_config)
-            kube_context_config['context']['namespace']
-          end
-        end
       end # Client
     end # Kubernetes
   end # Kube

data/lib/dapp/kube/kubernetes/config.rb

@@ -0,0 +1,129 @@
+module Dapp
+  module Kube
+    module Kubernetes
+      class Config
+        extend Helper::YAML
+        extend Dapp::Shellout::Base
+
+        class << self
+          def new_auto_if_available
+            if ENV['KUBECONFIG']
+              Kubernetes::Config.new_from_kubeconfig(ENV['KUBECONFIG'])
+            elsif Kubernetes::Config.kubectl_available?
+              Kubernetes::Config.new_from_kubectl
+            else
+              default_path = File.join(ENV['HOME'], '.kube/config')
+              if File.exists? default_path
+                Kubernetes::Config.new_from_kubeconfig(default_path)
+              end
+            end
+          end
+
+          def new_auto
+            new_auto_if_available.tap do |cfg|
+              raise(Kubernetes::Error::Default,
+                code: :config_not_found,
+                data: { },
+              ) if cfg.nil?
+            end
+          end
+
+          def new_from_kubeconfig(path)
+            unless File.exists?(path)
+              raise(Kubernetes::Error::Default,
+                code: :config_file_not_found,
+                data: { config_path: path }
+              )
+            end
+            self.new yaml_load_file(path), path
+          end
+
+          def kubectl_available?
+            shellout("kubectl").exitstatus.zero?
+          end
+
+          def new_from_kubectl
+            cmd_res = shellout("kubectl config view")
+
+            shellout_cmd_should_succeed! cmd_res
+
+            self.new YAML.load(cmd_res.stdout), "kubectl config view"
+          end
+        end # << self
+
+        attr_reader :config_hash, :config_path
+
+        def initialize(config_hash, config_path)
+          @config_hash = config_hash
+          @config_path = config_path
+        end
+
+        def context_names
+          config_hash.fetch('contexts', []).map {|context| context['name']}
+        end
+
+        def current_context_name
+          @current_context_name ||= begin
+            config_hash['current-context'] || begin
+              if (context = config_hash.fetch('contexts', []).first)
+                warn "[WARN] .kube/config current-context is not set, using first context '#{context['name']}'"
+                context['name']
+              end
+            end
+          end
+        end
+
+        def context_config(context_name)
+          res = config_hash.fetch('contexts', [])
+            .find {|context| context['name'] == context_name}
+
+          raise(Kubernetes::Error::Default,
+            code: :context_config_not_found,
+            data: {config_path: config_path,
+                    config: config_hash,
+                    context_name: context_name}
+          ) if res.nil?
+
+          res['context']
+        end
+
+        def user_config(user_name)
+          res = config_hash.fetch('users', [])
+            .find {|user| user['name'] == user_name}
+
+          raise(Kubernetes::Error::Default,
+            code: :user_config_not_found,
+            data: {config_path: config_path,
+                    user: user_name}
+          ) if res.nil?
+
+          res['user']
+        end
+
+        def cluster_config(cluster_name)
+          res = config_hash.fetch('clusters', [])
+            .find {|cluster| cluster['name'] == cluster_name}
+
+          raise(Kubernetes::Error::Default,
+            code: :cluster_config_not_found,
+            data: {config_path: config_path,
+                  cluster: cluster_name}
+          ) if res.nil?
+
+          res['cluster']
+        end
+
+        def cluster_name(context_name)
+          cfg = context_config(context_name)
+          cfg['cluster'] if cfg
+        end
+
+        def namespace(context_name)
+          cfg = context_config(context_name)
+          cfg['namespace'] if cfg
+        end
+
+      end # Kubeconfig
+    end # Kubernetes
+  end # Kube
+end # Dapp