dapp 0.10.2 → 0.36.24

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

@@ -0,0 +1,189 @@
+module Dapp
+  module Kube
+    class Helm::Release
+      include Helper::YAML
+
+      attr_reader :dapp
+
+      attr_reader :name
+      attr_reader :repo
+      attr_reader :docker_tag
+      attr_reader :namespace
+      attr_reader :chart_path
+      attr_reader :set
+      attr_reader :values
+      attr_reader :deploy_timeout
+      attr_reader :without_registry
+      attr_reader :kube_context
+
+      def initialize(dapp,
+        name:, repo:, docker_tag:, namespace:, chart_path:,
+        set: [], values: [], deploy_timeout: nil, without_registry: nil, kube_context: nil)
+        @dapp = dapp
+
+        @name = name
+        @repo = repo
+        @docker_tag = docker_tag
+        @namespace = namespace
+        @chart_path = chart_path
+        @set = set
+        @values = values
+        @deploy_timeout = deploy_timeout
+        @without_registry = (without_registry.nil? ? false : without_registry)
+        @kube_context = kube_context
+      end
+
+      def jobs
+        (resources_specs['Job'] || {}).map do |name, spec|
+          [name, Kubernetes::Client::Resource::Job.new(spec)]
+        end.to_h
+      end
+
+      def hooks
+        jobs.select do |_, spec|
+          spec.annotations.key? "helm.sh/hook"
+        end
+      end
+
+      def deployments
+        (resources_specs['Deployment'] || {}).map do |name, spec|
+          [name, Kubernetes::Client::Resource::Deployment.new(spec)]
+        end.to_h
+      end
+
+      def install_helm_release
+        unless dapp.dry_run?
+          dapp.kubernetes.create_namespace!(namespace) unless dapp.kubernetes.namespace?(namespace)
+        end
+
+        cmd = dapp.shellout([
+          "helm install #{chart_path}",
+          "--name #{name}",
+          *helm_additional_values_options,
+          *helm_set_options,
+          *helm_install_options,
+          ("--kube-context #{kube_context}" if kube_context),
+        ].join(" "))
+
+        return cmd
+      end
+
+      def upgrade_helm_release
+        cmd = dapp.shellout([
+          "helm upgrade #{name} #{chart_path}",
+          *helm_additional_values_options,
+          *helm_set_options,
+          *helm_install_options,
+          ("--kube-context #{kube_context}" if kube_context),
+        ].join(" "))
+
+        return cmd
+      end
+
+      def templates
+        @templates ||= {}.tap do |t|
+          current_template = nil
+          spec = 0
+          evaluation_output.lines.each do |l|
+            if (match = l[/# Source: (.*)/, 1])
+              spec = 0
+              t[current_template = match] ||= []
+            end
+
+            if l[/^---$/]
+              spec += 1
+            elsif current_template
+              (t[current_template][spec] ||= []) << l
+            end
+          end
+
+          t.each do |template, specs|
+            t[template] = "---\n#{specs.reject(&:nil?).map(&:join).join("---\n").strip}"
+          end
+        end
+      end
+
+      def lint!
+        dapp.shellout! [
+          'helm',
+          'lint',
+          '--strict',
+          *helm_additional_values_options,
+          *helm_set_options(fake: true),
+          *helm_common_options,
+          ("--kube-context #{kube_context}" if kube_context),
+          chart_path
+        ].compact.join(' ')
+      end
+
+      protected
+
+      def evaluation_output
+        @evaluation_output ||= begin
+          cmd = dapp.shellout! [
+            "helm",
+            "template",
+            chart_path,
+            helm_additional_values_options,
+            helm_set_options(without_registry: true),
+            ("--namespace #{namespace}" if namespace),
+            "--name #{name}",
+            ("--kube-context #{kube_context}" if kube_context),
+          ].compact.join(" ")
+
+          cmd.stdout
+        end
+      end
+
+      def resources_specs
+        @resources_specs ||= {}.tap do |specs|
+          evaluation_output.split(/^---$/)
+              .reject {|chunk| chunk.lines.all? {|line| line.strip.empty? or line.strip.start_with? "#"}}
+              .map {|chunk| yaml_load(chunk)}.each do |spec|
+            specs[spec['kind']] ||= {}
+            specs[spec['kind']][(spec['metadata'] || {})['name']] = spec
+          end
+        end
+      end
+
+      def helm_additional_values_options
+        [].tap do |options|
+          options.concat(values.map { |p| "--values #{p}" })
+        end
+      end
+
+      def dimg_registry
+        @dimg_registry ||= dapp.dimg_registry(repo)
+      end
+
+      def helm_set_options(without_registry: false, fake: false)
+        [].tap do |options|
+          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,
+                                                       fake: fake)
+          options.concat service_values.to_set_options
+        end
+      end
+
+      def helm_install_options(dry_run: nil)
+        dry_run = dapp.dry_run? if dry_run.nil?
+
+        helm_common_options(dry_run: dry_run).tap do |options|
+          options << '--dry-run' if dry_run
+          options << "--timeout #{deploy_timeout}" if deploy_timeout
+        end
+      end
+
+      def helm_common_options(dry_run: nil)
+        dry_run = dapp.dry_run? if dry_run.nil?
+
+        [].tap do |options|
+          options << "--namespace #{namespace}" if namespace
+          options << '--debug'                  if dry_run
+        end
+      end
+    end # Helm::Release
+  end # Kube
+end # Dapp

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

@@ -0,0 +1,148 @@
+module Dapp
+  module Kube
+    class Helm::Values
+      TEMPLATE_EMPTY_VALUE = '"-"'.freeze
+
+      class << self
+        def service_values(*a, &b)
+          self.new(service_values_hash(*a, &b))
+        end
+
+        def service_values_hash(dapp, repo, namespace, docker_tag, fake: false, without_registry: false, disable_warnings: false)
+          res = {
+            "global" => {
+              "namespace" => namespace,
+              "dapp" => {
+                "name" => dapp.name,
+                "repo" => repo,
+                "docker_tag" => docker_tag,
+              },
+              # TODO: enable again with chars escape
+              # "ci" => ENV.select { |k, _| k.start_with?('CI_') && k != "CI_ENVIRONMENT_URL" },
+            }
+          }
+
+          ci_info = {
+            "is_tag" => false,
+            "is_branch" => false,
+            "branch" => TEMPLATE_EMPTY_VALUE,
+            "tag" => TEMPLATE_EMPTY_VALUE,
+            "ref" => TEMPLATE_EMPTY_VALUE
+          }
+          res["global"]["dapp"]["ci"] = ci_info
+
+          if fake
+          elsif commit_tag = (ENV["CI_BUILD_TAG"] || ENV["CI_COMMIT_TAG"])
+            ci_info["tag"] = ci_info["ref"] = commit_tag
+            ci_info["is_tag"] = true
+          elsif commit_ref_name = (ENV["CI_BUILD_REF_NAME"] || ENV["CI_COMMIT_REF_NAME"])
+            ci_info["branch"] = ci_info["ref"] = commit_ref_name
+            ci_info["is_branch"] = true
+          elsif dapp.git_own_repo_exist? and dapp.git_own_repo.head_branch_name != "HEAD"
+            ci_info["branch"] = ci_info["ref"] = dapp.git_own_repo.head_branch_name
+            ci_info["is_branch"] = true
+          elsif dapp.git_own_repo_exist?
+            git = dapp.git_own_repo.send(:git)
+
+            tagref = git.references.find do |r|
+              if r.name.start_with?("refs/tags/")
+                if r.target.is_a? Rugged::Tag::Annotation
+                  r.target.target_id == git.head.target_id
+                else
+                  r.target_id == git.head.target_id
+                end
+              end
+            end
+
+            if tagref
+              tag = tagref.name.partition("refs/tags/").last
+            else
+              tag = git.head.target_id
+            end
+
+            ci_info["tag"] = ci_info["ref"] = tag
+            ci_info["is_tag"] = true
+          end
+
+          dimgs = dapp.build_configs.map do |config|
+            dapp.dimg(config: config, ignore_signature_auto_calculation: true)
+          end.uniq do |dimg|
+            dimg.name
+          end
+
+          dimgs.each do |dimg|
+            dimg_data = {}
+            if dimg.name
+              res["global"]["dapp"]["is_nameless_dimg"] = false
+              res["global"]["dapp"]["dimg"] ||= {}
+              res["global"]["dapp"]["dimg"][dimg.name] = dimg_data
+            else
+              res["global"]["dapp"]["is_nameless_dimg"] = true
+              res["global"]["dapp"]["dimg"] = dimg_data
+            end
+
+            dimg_labels = {}
+            docker_image_id = TEMPLATE_EMPTY_VALUE
+            unless fake || without_registry
+              begin
+                dimg_labels = dapp.dimg_registry(repo).image_config(docker_tag, dimg.name)["config"]["Labels"]
+                docker_image_id = dapp.dimg_registry(repo).image_id(docker_tag, dimg.name)
+              rescue ::Dapp::Dimg::Error::Registry => e
+                unless disable_warnings
+                  dapp.log_warning "Cannot determine <dimg>.docker_image_id and <dimg>.git.<ga>.commit_id helm values of dimg#{dimg.name ? " `#{dimg.name}`" : nil}: #{e.net_status[:data][:message]}"
+                end
+              end
+            end
+
+            dimg_data["docker_image"] = [[repo, dimg.name].compact.join("/"), docker_tag].join(":")
+            dimg_data["docker_image_id"] = docker_image_id
+
+            dimg.git_artifacts(omit_empty: false).each do |ga|
+              if ga.as
+                commit_id = dimg_labels[dapp.dimgstage_g_a_commit_label(ga.paramshash)] || TEMPLATE_EMPTY_VALUE
+
+                dimg_data["git"] ||= {}
+                dimg_data["git"][ga.as] ||= {}
+                dimg_data["git"][ga.as]["commit_id"] = commit_id
+              end
+            end
+          end
+
+          res
+        end
+      end
+
+      attr_reader :data
+
+      def initialize(data={})
+        @data = data
+      end
+
+      def as_set_options
+        options = {}
+
+        queue = [[nil, data]]
+
+        loop do
+          option_key, hash = queue.shift
+          break unless hash
+
+          hash.each do |k, v|
+            new_option_key = [option_key, k].compact.join(".")
+            if v.is_a? Hash
+              queue << [new_option_key, v]
+            else
+              options[new_option_key] = v
+            end
+          end
+        end
+
+        options
+      end
+
+      def to_set_options
+        as_set_options.map {|k, v| "--set '#{k}=#{v}'"}
+      end
+    end # Helm::ServiceValues
+  end # Kube
+end # Dapp

data/lib/dapp/kube/helm.rb

@@ -0,0 +1,5 @@
+module Dapp
+  module Kube
+    module Helm ; end
+  end # Kube
+end # Dapp

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

@@ -0,0 +1,43 @@
+module Dapp
+  module Kube
+    module Kubernetes::Client::Error
+      class Base < Kubernetes::Error::Base
+      end
+
+      class Default < Base
+        include ::Dapp::Error::Mod::User
+      end
+
+      class Timeout < Default
+      end
+
+      class ConnectionRefused < Default
+      end
+
+      class BadConfig < Default
+      end
+
+      class NotFound < Base
+        def initialize(**net_status)
+          super({code: :not_found}.merge(net_status))
+        end
+      end
+
+      module Pod
+        class NotFound < Kubernetes::Client::Error::NotFound ; end
+
+        class ContainerCreating < Kubernetes::Client::Error::Base
+          def initialize(**net_status)
+            super({code: :container_creating}.merge(net_status))
+          end
+        end
+
+        class PodInitializing < Kubernetes::Client::Error::Base
+          def initialize(**net_status)
+            super({code: :pod_initializing}.merge(net_status))
+          end
+        end
+      end # Pod
+    end # Kubernetes::Client::Error
+  end # Kube
+end # Dapp

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

@@ -0,0 +1,33 @@
+module Dapp
+  module Kube
+    module Kubernetes::Client::Resource
+      class Base
+        attr_reader :spec
+
+        def initialize(spec)
+          @spec = spec
+        end
+
+        def metadata
+          spec.fetch('metadata', {})
+        end
+
+        def name
+          metadata['name']
+        end
+
+        def uid
+          metadata['uid']
+        end
+
+        def annotations
+          metadata.fetch('annotations', {})
+        end
+
+        def status
+          spec.fetch('status', {})
+        end
+      end # Base
+    end # Kubernetes::Client::Resource
+  end # Kube
+end # Dapp

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

@@ -0,0 +1,11 @@
+module Dapp
+  module Kube
+    module Kubernetes::Client::Resource
+      class Deployment < Base
+        def replicas
+          spec.fetch('spec', {}).fetch('replicas', nil)
+        end
+      end # Deployment
+    end # Kubernetes::Client::Resource
+  end # Kube
+end # Dapp

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

@@ -0,0 +1,8 @@
+module Dapp
+  module Kube
+    module Kubernetes::Client::Resource
+      class Event < Base
+      end # Event
+    end # Kubernetes::Client::Resource
+  end # Kube
+end # Dapp

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

@@ -0,0 +1,27 @@
+module Dapp
+  module Kube
+    module Kubernetes::Client::Resource
+      class Job < Base
+        def uid
+          spec.fetch('metadata', {})['uid']
+        end
+
+        def terminated?
+          failed? || succeeded?
+        end
+
+        def failed?
+          !!spec.fetch('status', {}).fetch('conditions', []).find do |cond|
+            cond['type'] == 'Failed'
+          end
+        end
+
+        def succeeded?
+          !!spec.fetch('status', {}).fetch('conditions', []).find do |cond|
+            cond['type'] == 'Complete'
+          end
+        end
+      end # Job
+    end # Kubernetes::Client::Resource
+  end # Kube
+end # Dapp

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

@@ -0,0 +1,62 @@
+module Dapp
+  module Kube
+    module Kubernetes::Client::Resource
+      class Pod < Base
+        # Returns:
+        #   nil: no such condition yet
+        #   "True" string: ready
+        #   "False" string: not ready
+        def ready_condition_status
+          rd = self.ready_condition
+          return nil unless rd
+          return rd['status']
+        end
+
+        def ready_condition
+          status.fetch('conditions', {}).find {|condition| condition['type'] == 'Ready'}
+        end
+
+        def container_id(container_name)
+          container_status = spec.fetch('status', {})
+            .fetch('containerStatuses')
+            .find {|cs| cs['name'] == container_name}
+
+          if container_status
+            container_status['containerID']
+          else
+            nil
+          end
+        end
+
+        def container_state(container_name)
+          container_status = status
+            .fetch('containerStatuses', [])
+            .find {|cs| cs['name'] == container_name}
+
+          if container_status
+            container_state, container_state_data = container_status.fetch('state', {}).first
+            [container_state, container_state_data]
+          else
+            [nil, {}]
+          end
+        end
+
+        def phase
+          status.fetch('phase', nil)
+        end
+
+        def containers_names
+          spec.fetch('spec', {})
+            .fetch('containers', [])
+            .map {|container_spec| container_spec['name']}
+        end
+
+        def restart_policy
+          spec
+            .fetch('spec', {})
+            .fetch('restartPolicy', nil)
+        end
+      end # Pod
+    end # Kubernetes::Client::Resource
+  end # Kube
+end # Dapp

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

@@ -0,0 +1,8 @@
+module Dapp
+  module Kube
+    module Kubernetes::Client::Resource
+      class Replicaset < Base
+      end # Replicaset
+    end # Kubernetes::Client::Resource
+  end # Kube
+end # Dapp