kubernetes-deploy 0.18.0 → 0.18.1

data/lib/kubernetes-deploy/kubernetes_resource/daemon_set.rb

@@ -5,53 +5,57 @@ module KubernetesDeploy
     TIMEOUT = 5.minutes
     attr_reader :pods
 
-    def sync
-      raw_json, _err, st = kubectl.run("get", type, @name, "--output=json")
-      @found = st.success?
-
-      if @found
-        daemonset_data = JSON.parse(raw_json)
-        @current_generation = daemonset_data["metadata"]["generation"]
-        @observed_generation = daemonset_data["status"]["observedGeneration"]
-        @rollout_data = daemonset_data["status"]
-          .slice("currentNumberScheduled", "desiredNumberScheduled", "numberReady")
-        @status = @rollout_data.map { |state_replicas, num| "#{num} #{state_replicas}" }.join(", ")
-        @pods = find_pods(daemonset_data)
-      else # reset
-        @rollout_data = { "currentNumberScheduled" => 0 }
-        @current_generation = 1 # to make sure the current and observed generations are different
-        @observed_generation = 0
-        @status = nil
-        @pods = []
-      end
+    SYNC_DEPENDENCIES = %w(Pod)
+    def sync(mediator)
+      super
+      @pods = exists? ? find_pods(mediator) : []
+    end
+
+    def status
+      return super unless exists?
+      rollout_data.map { |state_replicas, num| "#{num} #{state_replicas}" }.join(", ")
     end
 
     def deploy_succeeded?
-      @rollout_data["desiredNumberScheduled"].to_i == @rollout_data["currentNumberScheduled"].to_i &&
-      @rollout_data["desiredNumberScheduled"].to_i == @rollout_data["numberReady"].to_i &&
-      @current_generation == @observed_generation
+      return false unless exists?
+      rollout_data["desiredNumberScheduled"].to_i == rollout_data["currentNumberScheduled"].to_i &&
+      rollout_data["desiredNumberScheduled"].to_i == rollout_data["numberReady"].to_i &&
+      current_generation == observed_generation
     end
 
     def deploy_failed?
       pods.present? && pods.any?(&:deploy_failed?)
     end
 
-    def fetch_logs
-      return {} unless @pods.present?
-      most_useful_pod = @pods.find(&:deploy_failed?) || @pods.find(&:deploy_timed_out?) || @pods.first
-      most_useful_pod.fetch_logs
+    def fetch_logs(kubectl)
+      return {} unless pods.present?
+      most_useful_pod = pods.find(&:deploy_failed?) || pods.find(&:deploy_timed_out?) || pods.first
+      most_useful_pod.fetch_logs(kubectl)
+    end
+
+    private
+
+    def current_generation
+      return -1 unless exists? # must be different default than observed_generation
+      @instance_data["metadata"]["generation"]
     end
 
-    def exists?
-      @found
+    def observed_generation
+      return -2 unless exists?
+      @instance_data["status"]["observedGeneration"]
     end
 
-    private
+    def rollout_data
+      return { "currentNumberScheduled" => 0 } unless exists?
+      @instance_data["status"]
+        .slice("currentNumberScheduled", "desiredNumberScheduled", "numberReady")
+    end
 
-    def parent_of_pod?(set_data, pod_data)
+    def parent_of_pod?(pod_data)
       return false unless pod_data.dig("metadata", "ownerReferences")
-      pod_data["metadata"]["ownerReferences"].any? { |ref| ref["uid"] == set_data["metadata"]["uid"] } &&
-      pod_data["metadata"]["labels"]["pod-template-generation"].to_i == set_data["spec"]["templateGeneration"].to_i
+      pod_data["metadata"]["ownerReferences"].any? { |ref| ref["uid"] == @instance_data["metadata"]["uid"] } &&
+      pod_data["metadata"]["labels"]["pod-template-generation"].to_i ==
+        @instance_data["spec"]["templateGeneration"].to_i
     end
   end
 end

data/lib/kubernetes-deploy/kubernetes_resource/deployment.rb

@@ -6,53 +6,37 @@ module KubernetesDeploy
     REQUIRED_ROLLOUT_TYPES = %w(maxUnavailable full none).freeze
     DEFAULT_REQUIRED_ROLLOUT = 'full'
 
-    def sync
-      raw_json, _err, st = kubectl.run("get", type, @name, "--output=json")
-      @found = st.success?
-
-      if @found
-        deployment_data = JSON.parse(raw_json)
-        @desired_replicas = deployment_data["spec"]["replicas"].to_i
-        @latest_rs = find_latest_rs(deployment_data)
-
-        @rollout_data = { "replicas" => 0 }.merge(deployment_data["status"]
-          .slice("replicas", "updatedReplicas", "availableReplicas", "unavailableReplicas"))
-        @status = @rollout_data.map { |state_replicas, num| "#{num} #{state_replicas.chop.pluralize(num)}" }.join(", ")
-
-        conditions = deployment_data.fetch("status", {}).fetch("conditions", [])
-        @progress_condition = conditions.find { |condition| condition['type'] == 'Progressing' }
-        @progress_deadline = deployment_data['spec']['progressDeadlineSeconds']
-        @max_unavailable = deployment_data.dig('spec', 'strategy', 'rollingUpdate', 'maxUnavailable')
-      else # reset
-        @latest_rs = nil
-        @rollout_data = { "replicas" => 0 }
-        @status = nil
-        @progress_condition = nil
-        @progress_deadline = @definition['spec']['progressDeadlineSeconds']
-        @desired_replicas = -1
-        @max_unavailable = @definition.dig('spec', 'strategy', 'rollingUpdate', 'maxUnavailable')
-      end
+    SYNC_DEPENDENCIES = %w(Pod ReplicaSet)
+    def sync(mediator)
+      super
+      @latest_rs = exists? ? find_latest_rs(mediator) : nil
+      @server_version ||= mediator.kubectl.server_version
+    end
+
+    def status
+      return super unless exists?
+      rollout_data.map { |state_replicas, num| "#{num} #{state_replicas.chop.pluralize(num)}" }.join(", ")
     end
 
-    def fetch_events
+    def fetch_events(kubectl)
       own_events = super
       return own_events unless @latest_rs.present?
-      own_events.merge(@latest_rs.fetch_events)
+      own_events.merge(@latest_rs.fetch_events(kubectl))
     end
 
-    def fetch_logs
+    def fetch_logs(kubectl)
       return {} unless @latest_rs.present?
-      @latest_rs.fetch_logs
+      @latest_rs.fetch_logs(kubectl)
     end
 
     def deploy_succeeded?
-      return false unless @latest_rs.present?
+      return false unless exists? && @latest_rs.present?
 
       if required_rollout == 'full'
         @latest_rs.deploy_succeeded? &&
-        @latest_rs.desired_replicas == @desired_replicas && # latest RS fully scaled up
-        @rollout_data["updatedReplicas"].to_i == @desired_replicas &&
-        @rollout_data["updatedReplicas"].to_i == @rollout_data["availableReplicas"].to_i
+        @latest_rs.desired_replicas == desired_replicas && # latest RS fully scaled up
+        rollout_data["updatedReplicas"].to_i == desired_replicas &&
+        rollout_data["updatedReplicas"].to_i == rollout_data["availableReplicas"].to_i
       elsif required_rollout == 'none'
         true
       elsif required_rollout == 'maxUnavailable' || percent?(required_rollout)
@@ -76,8 +60,8 @@ module KubernetesDeploy
     end
 
     def timeout_message
-      reason_msg = if @progress_condition.present?
-        "Timeout reason: #{@progress_condition['reason']}"
+      reason_msg = if progress_condition.present?
+        "Timeout reason: #{progress_condition['reason']}"
       else
         "Timeout reason: hard deadline for #{type}"
       end
@@ -86,19 +70,15 @@ module KubernetesDeploy
     end
 
     def pretty_timeout_type
-      @progress_deadline.present? ? "progress deadline: #{@progress_deadline}s" : super
+      progress_deadline.present? ? "progress deadline: #{progress_deadline}s" : super
     end
 
     def deploy_timed_out?
       # Do not use the hard timeout if progress deadline is set
-      @progress_condition.present? ? deploy_failing_to_progress? : super
-    end
-
-    def exists?
-      @found
+      progress_condition.present? ? deploy_failing_to_progress? : super
     end
 
-    def validate_definition
+    def validate_definition(_)
       super
 
       unless REQUIRED_ROLLOUT_TYPES.include?(required_rollout) || percent?(required_rollout)
@@ -116,39 +96,57 @@ module KubernetesDeploy
 
     private
 
+    def desired_replicas
+      return -1 unless exists?
+      @instance_data["spec"]["replicas"].to_i
+    end
+
+    def rollout_data
+      return { "replicas" => 0 } unless exists?
+      { "replicas" => 0 }.merge(@instance_data["status"]
+        .slice("replicas", "updatedReplicas", "availableReplicas", "unavailableReplicas"))
+    end
+
+    def progress_condition
+      return unless exists?
+      conditions = @instance_data.fetch("status", {}).fetch("conditions", [])
+      conditions.find { |condition| condition['type'] == 'Progressing' }
+    end
+
+    def progress_deadline
+      if exists?
+        @instance_data['spec']['progressDeadlineSeconds']
+      else
+        @definition['spec']['progressDeadlineSeconds']
+      end
+    end
+
     def rollout_annotation_err_msg
       "'#{REQUIRED_ROLLOUT_ANNOTATION}: #{required_rollout}' is invalid. "\
         "Acceptable values: #{REQUIRED_ROLLOUT_TYPES.join(', ')}"
     end
 
     def deploy_failing_to_progress?
-      return false unless @progress_condition.present?
+      return false unless progress_condition.present?
 
-      if kubectl.server_version < Gem::Version.new("1.7.7")
+      if @server_version < Gem::Version.new("1.7.7")
         # Deployments were being updated prematurely with incorrect progress information
         # https://github.com/kubernetes/kubernetes/issues/49637
-        return false unless Time.now.utc - @deploy_started_at >= @progress_deadline.to_i
+        return false unless Time.now.utc - @deploy_started_at >= progress_deadline.to_i
       else
         return false unless deploy_started?
       end
 
-      @progress_condition["status"] == 'False' &&
-      Time.parse(@progress_condition["lastUpdateTime"]).to_i >= (@deploy_started_at - 5.seconds).to_i
+      progress_condition["status"] == 'False' &&
+      Time.parse(progress_condition["lastUpdateTime"]).to_i >= (@deploy_started_at - 5.seconds).to_i
     end
 
-    def all_rs_data(match_labels)
-      label_string = match_labels.map { |k, v| "#{k}=#{v}" }.join(",")
-      raw_json, _err, st = kubectl.run("get", "replicasets", "--output=json", "--selector=#{label_string}")
-      return {} unless st.success?
+    def find_latest_rs(mediator)
+      all_rs_data = mediator.get_all(ReplicaSet.kind, @instance_data["spec"]["selector"]["matchLabels"])
+      current_revision = @instance_data["metadata"]["annotations"]["deployment.kubernetes.io/revision"]
 
-      JSON.parse(raw_json)["items"]
-    end
-
-    def find_latest_rs(deployment_data)
-      current_revision = deployment_data["metadata"]["annotations"]["deployment.kubernetes.io/revision"]
-
-      latest_rs_data = all_rs_data(deployment_data["spec"]["selector"]["matchLabels"]).find do |rs|
-        rs["metadata"]["ownerReferences"].any? { |ref| ref["uid"] == deployment_data["metadata"]["uid"] } &&
+      latest_rs_data = all_rs_data.find do |rs|
+        rs["metadata"]["ownerReferences"].any? { |ref| ref["uid"] == @instance_data["metadata"]["uid"] } &&
         rs["metadata"]["annotations"]["deployment.kubernetes.io/revision"] == current_revision
       end
 
@@ -162,20 +160,25 @@ module KubernetesDeploy
         parent: "#{@name.capitalize} deployment",
         deploy_started_at: @deploy_started_at
       )
-      rs.sync(latest_rs_data)
+      rs.sync(mediator)
       rs
     end
 
     def min_available_replicas
-      max_unavailable = percent?(required_rollout) ? "#{100 - required_rollout.to_i}%" : @max_unavailable
-
-      if max_unavailable =~ /%/
-        (@desired_replicas * (100 - max_unavailable.to_i) / 100.0).ceil
+      if percent?(required_rollout)
+        (desired_replicas * required_rollout.to_i / 100.0).ceil
+      elsif max_unavailable =~ /%/
+        (desired_replicas * (100 - max_unavailable.to_i) / 100.0).ceil
       else
-        @desired_replicas - max_unavailable.to_i
+        desired_replicas - max_unavailable.to_i
       end
     end
 
+    def max_unavailable
+      source = exists? ? @instance_data : @definition
+      source.dig('spec', 'strategy', 'rollingUpdate', 'maxUnavailable')
+    end
+
     def required_rollout
       @definition.dig('metadata', 'annotations', REQUIRED_ROLLOUT_ANNOTATION).presence || DEFAULT_REQUIRED_ROLLOUT
     end

data/lib/kubernetes-deploy/kubernetes_resource/elasticsearch.rb

@@ -1,23 +1,8 @@
 # frozen_string_literal: true
 module KubernetesDeploy
   class Elasticsearch < KubernetesResource
-    def sync
-      _, _err, st = kubectl.run("get", type, @name)
-      @found = st.success?
-    end
-
     def deploy_succeeded?
-      return false unless deploy_started?
-
-      unless @success_assumption_warning_shown
-        @logger.warn("Don't know how to monitor resources of type #{type}. Assuming #{id} deployed successfully.")
-        @success_assumption_warning_shown = true
-      end
-      true
-    end
-
-    def exists?
-      @found
+      super # success assumption, with warning
     end
 
     def deploy_failed?

data/lib/kubernetes-deploy/kubernetes_resource/ingress.rb

@@ -3,10 +3,8 @@ module KubernetesDeploy
   class Ingress < KubernetesResource
     TIMEOUT = 30.seconds
 
-    def sync
-      _, _err, st = kubectl.run("get", type, @name)
-      @status = st.success? ? "Created" : "Unknown"
-      @found = st.success?
+    def status
+      exists? ? "Created" : "Unknown"
     end
 
     def deploy_succeeded?
@@ -16,9 +14,5 @@ module KubernetesDeploy
     def deploy_failed?
       false
     end
-
-    def exists?
-      @found
-    end
   end
 end

data/lib/kubernetes-deploy/kubernetes_resource/memcached.rb

@@ -4,58 +4,45 @@ module KubernetesDeploy
     TIMEOUT = 5.minutes
     CONFIGMAP_NAME = "memcached-url"
 
-    def sync
-      _, _err, st = kubectl.run("get", type, @name)
-      @found = st.success?
-      @deployment_exists = memcached_deployment_exists?
-      @service_exists = memcached_service_exists?
-      @configmap_exists = memcached_configmap_exists?
+    SYNC_DEPENDENCIES = %w(Deployment Service ConfigMap)
+    def sync(mediator)
+      super
+      @deployment = mediator.get_instance(Deployment.kind, "memcached-#{@name}")
+      @service = mediator.get_instance(Service.kind, "memcached-#{@name}")
+      @configmap = mediator.get_instance(ConfigMap.kind, CONFIGMAP_NAME)
+    end
 
-      @status = if @deployment_exists && @service_exists && @configmap_exists
-        "Provisioned"
-      else
-        "Unknown"
-      end
+    def status
+      deploy_succeeded? ? "Provisioned" : "Unknown"
     end
 
     def deploy_succeeded?
-      @deployment_exists && @service_exists && @configmap_exists
+      deployment_ready? && service_ready? && configmap_ready?
     end
 
     def deploy_failed?
       false
     end
 
-    def exists?
-      @found
-    end
-
     def deploy_method
       :replace
     end
 
     private
 
-    def memcached_deployment_exists?
-      deployment, _err, st = kubectl.run("get", "deployments", "memcached-#{@name}", "-o=json")
-      return false unless st.success?
-      parsed = JSON.parse(deployment)
-      status = parsed.fetch("status", {})
+    def deployment_ready?
+      return false unless status = @deployment["status"]
       status.fetch("availableReplicas", -1) == status.fetch("replicas", 0)
     end
 
-    def memcached_service_exists?
-      service, _err, st = kubectl.run("get", "services", "memcached-#{@name}", "-o=json")
-      return false unless st.success?
-      parsed = JSON.parse(service)
-      parsed.dig("spec", "clusterIP").present?
+    def service_ready?
+      return false unless @service.present?
+      @service.dig("spec", "clusterIP").present?
     end
 
-    def memcached_configmap_exists?
-      secret, _err, st = kubectl.run("get", "configmaps", CONFIGMAP_NAME, "-o=json")
-      return false unless st.success?
-      parsed = JSON.parse(secret)
-      parsed.dig("data", @name).present?
+    def configmap_ready?
+      return false unless @configmap.present?
+      @configmap.dig("data", @name).present?
     end
   end
 end

data/lib/kubernetes-deploy/kubernetes_resource/persistent_volume_claim.rb

@@ -3,22 +3,16 @@ module KubernetesDeploy
   class PersistentVolumeClaim < KubernetesResource
     TIMEOUT = 5.minutes
 
-    def sync
-      out, _err, st = kubectl.run("get", type, @name, "--output=jsonpath={.status.phase}")
-      @found = st.success?
-      @status = out if @found
+    def status
+      exists? ? @instance_data["status"]["phase"] : "Unknown"
     end
 
     def deploy_succeeded?
-      @status == "Bound"
+      status == "Bound"
     end
 
     def deploy_failed?
-      @status == "Lost"
-    end
-
-    def exists?
-      @found
+      status == "Lost"
     end
   end
 end