kubernetes-deploy 0.29.0 → 1.0.0.pre.2

data/lib/{kubernetes-deploy → krane}/kubernetes_resource.rb

@@ -2,15 +2,15 @@
 require 'json'
 require 'shellwords'
 
-require 'kubernetes-deploy/remote_logs'
-require 'kubernetes-deploy/duration_parser'
-require 'kubernetes-deploy/label_selector'
-require 'kubernetes-deploy/rollout_conditions'
+require 'krane/remote_logs'
+require 'krane/duration_parser'
+require 'krane/label_selector'
+require 'krane/rollout_conditions'
 
-module KubernetesDeploy
+module Krane
   class KubernetesResource
     attr_reader :name, :namespace, :context
-    attr_writer :type, :deploy_started_at
+    attr_writer :type, :deploy_started_at, :global
 
     GLOBAL = false
     TIMEOUT = 5.minutes
@@ -40,7 +40,7 @@ module KubernetesDeploy
     SERVER_DRY_RUNNABLE = false
 
     class << self
-      def build(namespace:, context:, definition:, logger:, statsd_tags:, crd: nil)
+      def build(namespace: nil, context:, definition:, logger:, statsd_tags:, crd: nil, global_names: [])
         validate_definition_essentials(definition)
         opts = { namespace: namespace, context: context, definition: definition, logger: logger,
                  statsd_tags: statsd_tags }
@@ -50,15 +50,17 @@ module KubernetesDeploy
         if crd
           CustomResource.new(crd: crd, **opts)
         else
+          type = definition["kind"]
           inst = new(**opts)
-          inst.type = definition["kind"]
+          inst.type = type
+          inst.global = global_names.map(&:downcase).include?(type.downcase)
           inst
         end
       end
 
       def class_for_kind(kind)
-        if KubernetesDeploy.const_defined?(kind)
-          KubernetesDeploy.const_get(kind)
+        if Krane.const_defined?(kind)
+          Krane.const_get(kind)
         end
       rescue NameError
         nil
@@ -85,8 +87,9 @@ module KubernetesDeploy
           raise InvalidTemplateError.new("Template is missing required field 'kind'", content: debug_content)
         end
 
-        if definition.dig('metadata', 'name').blank?
-          raise InvalidTemplateError.new("Template is missing required field 'metadata.name'", content: debug_content)
+        if definition.dig('metadata', 'name').blank? && definition.dig('metadata', 'generateName').blank?
+          raise InvalidTemplateError.new("Template must specify one of 'metadata.name' or 'metadata.generateName'",
+            content: debug_content)
         end
       end
     end
@@ -110,7 +113,7 @@ module KubernetesDeploy
 
     def initialize(namespace:, context:, definition:, logger:, statsd_tags: [])
       # subclasses must also set these if they define their own initializer
-      @name = definition.dig("metadata", "name").to_s
+      @name = (definition.dig("metadata", "name") || definition.dig("metadata", "generateName")).to_s
       @optional_statsd_tags = statsd_tags
       @namespace = namespace
       @context = context
@@ -168,7 +171,7 @@ module KubernetesDeploy
 
     def sync(cache)
       @instance_data = cache.get_instance(kubectl_resource_type, name, raise_if_not_found: true)
-    rescue KubernetesDeploy::Kubectl::ResourceNotFoundError
+    rescue Krane::Kubectl::ResourceNotFoundError
       @disappeared = true if deploy_started?
       @instance_data = {}
     end
@@ -233,9 +236,13 @@ module KubernetesDeploy
       !deploy_succeeded? && !deploy_failed? && (Time.now.utc - @deploy_started_at > timeout)
     end
 
-    # Expected values: :apply, :replace, :replace_force
+    # Expected values: :apply, :create, :replace, :replace_force
     def deploy_method
-      :apply
+      if @definition.dig("metadata", "name").blank? && uses_generate_name?
+        :create
+      else
+        :apply
+      end
     end
 
     def sync_debug_info(kubectl)
@@ -315,7 +322,7 @@ module KubernetesDeploy
     def fetch_events(kubectl)
       return {} unless exists?
       out, _err, st = kubectl.run("get", "events", "--output=go-template=#{Event.go_template_for(type, name)}",
-        log_failure: false)
+        log_failure: false, use_namespace: !global?)
       return {} unless st.success?
 
       event_collector = Hash.new { |hash, key| hash[key] = [] }
@@ -338,7 +345,7 @@ module KubernetesDeploy
 
     def report_status_to_statsd(watch_time)
       unless @statsd_report_done
-        StatsD.distribution('resource.duration', watch_time, tags: statsd_tags)
+        StatsD.client.distribution('resource.duration', watch_time, tags: statsd_tags)
         @statsd_report_done = true
       end
     end
@@ -348,13 +355,29 @@ module KubernetesDeploy
     end
 
     def server_dry_runnable_resource?
-      self.class::SERVER_DRY_RUNNABLE
+      # generateName and server-side dry run are incompatible because the former only works with `create`
+      # and the latter only works with `apply`
+      self.class::SERVER_DRY_RUNNABLE && !uses_generate_name?
+    end
+
+    def uses_generate_name?
+      @definition.dig('metadata', 'generateName').present?
     end
 
     def server_dry_run_validated?
       @server_dry_run_validated
     end
 
+    # If a resource uses generateName, we don't know the full name of the resource until it's deployed to the cluster.
+    # In this case, we need to update our local definition with the realized name in order to accurately track the
+    # resource during deploy
+    def use_generated_name(instance_data)
+      @name = instance_data.dig('metadata', 'name')
+      @definition['metadata']['name'] = @name
+      @definition['metadata'].delete('generateName')
+      @file = create_definition_tempfile
+    end
+
     class Event
       EVENT_SEPARATOR = "ENDEVENT--BEGINEVENT"
       FIELD_SEPARATOR = "ENDFIELD--BEGINFIELD"
@@ -365,7 +388,12 @@ module KubernetesDeploy
         .lastTimestamp
         .reason
         .message
+        .eventTime
+        .deprecatedCount
+        .deprecatedLastTimestamp
+        .series
       )
+      FIELD_EMPTY_VALUE = '<no value>'
 
       def self.go_template_for(kind, name)
         and_conditions = [
@@ -386,17 +414,61 @@ module KubernetesDeploy
       def self.extract_all_from_go_template_blob(blob)
         blob.split(EVENT_SEPARATOR).map do |event_blob|
           pieces = event_blob.split(FIELD_SEPARATOR, FIELDS.length)
+          count = extract_event_count(pieces)
+          timestamp = extract_event_timestamp(pieces)
+
           new(
             subject_kind: pieces[FIELDS.index(".involvedObject.kind")],
             subject_name: pieces[FIELDS.index(".involvedObject.name")],
-            count: pieces[FIELDS.index(".count")],
-            last_timestamp: pieces[FIELDS.index(".lastTimestamp")],
+            count: count,
+            last_timestamp: timestamp,
             reason: pieces[FIELDS.index(".reason")],
             message: pieces[FIELDS.index(".message")]
           )
         end
       end
 
+      def self.extract_event_count(pieces)
+        series = pieces[FIELDS.index(".series")]
+        count = pieces[FIELDS.index(".count")]
+        deprecated_count = pieces[FIELDS.index(".deprecatedCount")]
+
+        # Find the right event count according to Kubernetes API and kubectl version
+        if count.present? && count != FIELD_EMPTY_VALUE
+          count # This is the default field, so let's try to use it first
+        elsif series.present? && series != FIELD_EMPTY_VALUE
+          # kubectl 1.16 uses Events/v1, which has the .series/.count field
+          count_regex = /count:(?<value>\S+?(?=\s))/
+          count_regex.match(series)['value']
+        elsif deprecated_count.present? && deprecated_count != FIELD_EMPTY_VALUE
+          # kubectl < 1.16 uses events.k8s.io/v1beta1, which has .deprecatedCount
+          deprecated_count
+        else
+          "1" # Fallback to 1 when all count fields are null
+        end
+      end
+
+      def self.extract_event_timestamp(pieces)
+        series = pieces[FIELDS.index(".series")]
+        last_timestamp = pieces[FIELDS.index(".lastTimestamp")]
+        deprecated_timestamp = pieces[FIELDS.index(".deprecatedLastTimestamp")]
+
+        # Find the right event timestamp according to Kubernetes API and kubectl version
+        if last_timestamp.present? && last_timestamp != FIELD_EMPTY_VALUE
+          last_timestamp # kubernetes 1.16 also exposes .last_timestamp field, so let's support it
+        elsif series.present? && series != FIELD_EMPTY_VALUE
+          # kubectl 1.16 uses Events/v1, which has the .series/.lastObservedTime field
+          timestamp_regex = /lastObservedTime:(?<value>\S+?(?=\]))/
+          timestamp_regex.match(series)['value']
+        elsif deprecated_timestamp.present? && deprecated_timestamp != FIELD_EMPTY_VALUE
+          # kubectl < 1.16 uses events.k8s.io/v1beta1, which has .deprecatedLastTimestamp
+          deprecated_timestamp
+        else
+          pieces[FIELDS.index(".eventTime")] # Fallback to eventTime when other timestamp fields are null
+        end
+      end
+      private_class_method :extract_event_timestamp, :extract_event_count
+
       def initialize(subject_kind:, last_timestamp:, reason:, message:, count:, subject_name:)
         @subject_kind = subject_kind
         @subject_name = subject_name
@@ -416,7 +488,7 @@ module KubernetesDeploy
     end
 
     def global?
-      self.class::GLOBAL
+      @global || self.class::GLOBAL
     end
 
     private
@@ -478,13 +550,13 @@ module KubernetesDeploy
     def validate_spec_with_kubectl(kubectl)
       err = ""
       if kubectl.server_dry_run_enabled? && server_dry_runnable_resource?
-        _, err, st = validate_with_dry_run_option(kubectl, "--server-dry-run")
+        _, err, st = validate_with_server_side_dry_run(kubectl)
         @server_dry_run_validated = st.success?
         return true if st.success?
       end
 
       if err.empty? || err.match(SERVER_DRY_RUN_DISABLED_ERROR)
-        _, err, st = validate_with_dry_run_option(kubectl, "--dry-run")
+        _, err, st = validate_with_local_dry_run(kubectl)
       end
 
       return true if st.success?
@@ -495,10 +567,21 @@ module KubernetesDeploy
       end
     end
 
-    def validate_with_dry_run_option(kubectl, dry_run_option)
-      command = ["apply", "-f", file_path, dry_run_option, "--output=name"]
+    # Server side dry run is only supported on apply
+    def validate_with_server_side_dry_run(kubectl)
+      command = ["apply", "-f", file_path, "--server-dry-run", "--output=name"]
+      kubectl.run(*command, log_failure: false, output_is_sensitive: sensitive_template_content?,
+        retry_whitelist: [:client_timeout], attempts: 3)
+    end
+
+    # Local dry run is supported on only create and apply
+    # If the deploy method is create, validating with apply will fail
+    # If the resource template uses generateName, validating with apply will fail
+    def validate_with_local_dry_run(kubectl)
+      verb = deploy_method == :apply ? "apply" : "create"
+      command = [verb, "-f", file_path, "--dry-run", "--output=name"]
       kubectl.run(*command, log_failure: false, output_is_sensitive: sensitive_template_content?,
-                               retry_whitelist: [:client_timeout], attempts: 3)
+        retry_whitelist: [:client_timeout], attempts: 3, use_namespace: !global?)
     end
 
     def labels

data/lib/{kubernetes-deploy → krane}/kubernetes_resource/cloudsql.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-module KubernetesDeploy
+module Krane
   class Cloudsql < KubernetesResource
     TIMEOUT = 10.minutes
 

data/lib/{kubernetes-deploy → krane}/kubernetes_resource/config_map.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-module KubernetesDeploy
+module Krane
   class ConfigMap < KubernetesResource
     TIMEOUT = 30.seconds
 

data/lib/{kubernetes-deploy → krane}/kubernetes_resource/cron_job.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-module KubernetesDeploy
+module Krane
   class CronJob < KubernetesResource
     TIMEOUT = 30.seconds
 

data/lib/{kubernetes-deploy → krane}/kubernetes_resource/custom_resource.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 require 'jsonpath'
 
-module KubernetesDeploy
+module Krane
   class CustomResource < KubernetesResource
     TIMEOUT_MESSAGE_DIFFERENT_GENERATIONS = <<~MSG
       This resource's status could not be used to determine rollout success because it is not up-to-date
@@ -68,7 +68,7 @@ module KubernetesDeploy
       @crd.validate_rollout_conditions
     rescue RolloutConditionsError => e
       @validation_errors << "The CRD that specifies this resource is using invalid rollout conditions. " \
-      "Kubernetes-deploy will not be able to continue until those rollout conditions are fixed.\n" \
+      "Krane will not be able to continue until those rollout conditions are fixed.\n" \
       "Rollout conditions can be found on the CRD that defines this resource (#{@crd.name}), " \
       "under the annotation #{CustomResourceDefinition::ROLLOUT_CONDITIONS_ANNOTATION}.\n" \
       "Validation failed with: #{e}"

data/lib/{kubernetes-deploy → krane}/kubernetes_resource/custom_resource_definition.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-module KubernetesDeploy
+module Krane
   class CustomResourceDefinition < KubernetesResource
     TIMEOUT = 2.minutes
     ROLLOUT_CONDITIONS_ANNOTATION_SUFFIX = "instance-rollout-conditions"
@@ -46,10 +46,6 @@ module KubernetesDeploy
       @definition.dig("spec", "names", "kind")
     end
 
-    def name
-      @definition.dig("metadata", "name")
-    end
-
     def prunable?
       prunable = krane_annotation_value("prunable")
       prunable == "true"

data/lib/krane/kubernetes_resource/daemon_set.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+require "krane/kubernetes_resource/pod_set_base"
+module Krane
+  class DaemonSet < PodSetBase
+    TIMEOUT = 5.minutes
+    attr_reader :pods
+
+    def sync(cache)
+      super
+      @pods = exists? ? find_pods(cache) : []
+      @nodes = find_nodes(cache) if @nodes.blank?
+    end
+
+    def status
+      return super unless exists?
+      rollout_data.map { |state_replicas, num| "#{num} #{state_replicas}" }.join(", ")
+    end
+
+    def deploy_succeeded?
+      return false unless exists?
+      current_generation == observed_generation &&
+        rollout_data["desiredNumberScheduled"].to_i == rollout_data["updatedNumberScheduled"].to_i &&
+        relevant_pods_ready?
+    end
+
+    def deploy_failed?
+      pods.present? && pods.any?(&:deploy_failed?) &&
+      observed_generation == current_generation
+    end
+
+    def fetch_debug_logs
+      most_useful_pod = pods.find(&:deploy_failed?) || pods.find(&:deploy_timed_out?) || pods.first
+      most_useful_pod.fetch_debug_logs
+    end
+
+    def print_debug_logs?
+      pods.present? # the kubectl command times out if no pods exist
+    end
+
+    private
+
+    class Node
+      attr_reader :name
+
+      class << self
+        def kind
+          name.demodulize
+        end
+      end
+
+      def initialize(definition:)
+        @name = definition.dig("metadata", "name").to_s
+        @definition = definition
+      end
+    end
+
+    def relevant_pods_ready?
+      return true if rollout_data["desiredNumberScheduled"].to_i == rollout_data["numberReady"].to_i # all pods ready
+      relevant_node_names = @nodes.map(&:name)
+      considered_pods = @pods.select { |p| relevant_node_names.include?(p.node_name) }
+      @logger.debug("DaemonSet is reporting #{rollout_data['numberReady']} pods ready." \
+        " Considered #{considered_pods.size} pods out of #{@pods.size} for #{@nodes.size} nodes.")
+      considered_pods.present? &&
+        considered_pods.all?(&:deploy_succeeded?) &&
+        rollout_data["numberReady"].to_i >= considered_pods.length
+    end
+
+    def find_nodes(cache)
+      all_nodes = cache.get_all(Node.kind)
+      all_nodes.map { |node_data| Node.new(definition: node_data) }
+    end
+
+    def rollout_data
+      return { "currentNumberScheduled" => 0 } unless exists?
+      @instance_data["status"]
+        .slice("updatedNumberScheduled", "desiredNumberScheduled", "numberReady")
+    end
+
+    def parent_of_pod?(pod_data)
+      return false unless pod_data.dig("metadata", "ownerReferences")
+
+      template_generation = @instance_data.dig("spec", "templateGeneration") ||
+        @instance_data.dig("metadata", "annotations", "deprecated.daemonset.template.generation")
+      return false unless template_generation.present?
+
+      pod_data["metadata"]["ownerReferences"].any? { |ref| ref["uid"] == @instance_data["metadata"]["uid"] } &&
+      pod_data["metadata"]["labels"]["pod-template-generation"].to_i == template_generation.to_i
+    end
+  end
+end

data/lib/{kubernetes-deploy → krane}/kubernetes_resource/deployment.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
-require 'kubernetes-deploy/kubernetes_resource/replica_set'
+require 'krane/kubernetes_resource/replica_set'
 
-module KubernetesDeploy
+module Krane
   class Deployment < KubernetesResource
     TIMEOUT = 7.minutes
     REQUIRED_ROLLOUT_ANNOTATION_SUFFIX = "required-rollout"

data/lib/{kubernetes-deploy → krane}/kubernetes_resource/horizontal_pod_autoscaler.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-module KubernetesDeploy
+module Krane
   class HorizontalPodAutoscaler < KubernetesResource
     TIMEOUT = 3.minutes
     RECOVERABLE_CONDITION_PREFIX = "FailedGet"

data/lib/{kubernetes-deploy → krane}/kubernetes_resource/ingress.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-module KubernetesDeploy
+module Krane
   class Ingress < KubernetesResource
     TIMEOUT = 30.seconds
 

data/lib/{kubernetes-deploy → krane}/kubernetes_resource/job.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-module KubernetesDeploy
+module Krane
   class Job < KubernetesResource
     TIMEOUT = 10.minutes