kubernetes-deploy 0.18.0 → 0.18.1

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

@@ -17,33 +17,29 @@ module KubernetesDeploy
       super(namespace: namespace, context: context, definition: definition, logger: logger)
     end
 
-    def sync(pod_data = nil)
-      if pod_data.blank?
-        raw_json, _err, st = kubectl.run("get", type, @name, "-a", "--output=json")
-        pod_data = JSON.parse(raw_json) if st.success?
-        raise_predates_deploy_error if pod_data.present? && unmanaged? && !deploy_started?
-      end
-
-      if pod_data.present?
-        @found = true
-        @phase = @status = pod_data["status"]["phase"]
-        @status += " (Reason: #{pod_data['status']['reason']})" if pod_data['status']['reason'].present?
-        @ready = ready?(pod_data["status"])
-        update_container_statuses(pod_data["status"])
+    def sync(mediator)
+      super
+      raise_predates_deploy_error if exists? && unmanaged? && !deploy_started?
+
+      if exists?
+        update_container_statuses(@instance_data["status"])
       else # reset
-        @found = @ready = false
-        @status = @phase = 'Unknown'
         @containers.each(&:reset_status)
       end
 
-      display_logs if unmanaged? && deploy_succeeded?
+      display_logs(mediator) if unmanaged? && deploy_succeeded?
+    end
+
+    def status
+      return phase if @instance_data.dig('status', 'reason').blank?
+      "#{phase} (Reason: #{@instance_data['status']['reason']})"
     end
 
     def deploy_succeeded?
       if unmanaged?
-        @phase == "Succeeded"
+        phase == "Succeeded"
       else
-        @phase == "Running" && @ready
+        phase == "Running" && ready?
       end
     end
 
@@ -51,10 +47,6 @@ module KubernetesDeploy
       failure_message.present?
     end
 
-    def exists?
-      @found
-    end
-
     def timeout_message
       return STANDARD_TIMEOUT_MESSAGE unless readiness_probe_failure?
       probe_failure_msgs = @containers.map(&:readiness_fail_reason).compact
@@ -63,8 +55,8 @@ module KubernetesDeploy
     end
 
     def failure_message
-      if @phase == FAILED_PHASE_NAME
-        phase_problem = "Pod status: #{@status}. "
+      if phase == FAILED_PHASE_NAME
+        phase_problem = "Pod status: #{status}. "
       end
 
       doomed_containers = @containers.select(&:doomed?)
@@ -87,7 +79,7 @@ module KubernetesDeploy
     #   "app" => ["array of log lines", "received from app container"],
     #   "nginx" => ["array of log lines", "received from nginx container"]
     # }
-    def fetch_logs
+    def fetch_logs(kubectl)
       return {} unless exists? && @containers.present?
       @containers.each_with_object({}) do |container, container_logs|
         cmd = [
@@ -97,20 +89,25 @@ module KubernetesDeploy
           "--since-time=#{@deploy_started_at.to_datetime.rfc3339}",
         ]
         cmd << "--tail=#{LOG_LINE_COUNT}" unless unmanaged?
-        out, _err, _st = kubectl.run(*cmd)
+        out, _err, _st = kubectl.run(*cmd, log_failure: false)
         container_logs[container.name] = out.split("\n")
       end
     end
 
     private
 
+    def phase
+      @instance_data.dig("status", "phase") || "Unknown"
+    end
+
     def readiness_probe_failure?
-      return false if @ready || unmanaged?
-      return false if @phase != "Running"
+      return false if ready? || unmanaged?
+      return false if phase != "Running"
       @containers.any?(&:readiness_fail_reason)
     end
 
-    def ready?(status_data)
+    def ready?
+      return false unless status_data = @instance_data["status"]
       ready_condition = status_data.fetch("conditions", []).find { |condition| condition["type"] == "Ready" }
       ready_condition.present? && (ready_condition["status"] == "True")
     end
@@ -131,9 +128,9 @@ module KubernetesDeploy
       @parent.blank?
     end
 
-    def display_logs
+    def display_logs(mediator)
       return if @already_displayed
-      container_logs = fetch_logs
+      container_logs = fetch_logs(mediator.kubectl)
 
       if container_logs.empty?
         @logger.warn("No logs found for pod #{id}")

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

@@ -3,10 +3,8 @@ module KubernetesDeploy
   class PodDisruptionBudget < KubernetesResource
     TIMEOUT = 10.seconds
 
-    def sync
-      _, _err, st = kubectl.run("get", type, @name)
-      @found = st.success?
-      @status = @found ? "Available" : "Unknown"
+    def status
+      exists? ? "Available" : "Unknown"
     end
 
     def deploy_succeeded?
@@ -21,9 +19,5 @@ module KubernetesDeploy
     def timeout_message
       UNUSUAL_FAILURE_MESSAGE
     end
-
-    def exists?
-      @found
-    end
   end
 end

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

@@ -9,14 +9,14 @@ module KubernetesDeploy
       pods.map(&:timeout_message).compact.uniq.join("\n")
     end
 
-    def fetch_events
+    def fetch_events(kubectl)
       own_events = super
       return own_events unless pods.present?
       most_useful_pod = pods.find(&:deploy_failed?) || pods.find(&:deploy_timed_out?) || pods.first
-      own_events.merge(most_useful_pod.fetch_events)
+      own_events.merge(most_useful_pod.fetch_events(kubectl))
     end
 
-    def fetch_logs
+    def fetch_logs(kubectl)
       return {} unless pods.present? # the kubectl command times out if no pods exist
       container_names.each_with_object({}) do |container_name, container_logs|
         out, _err, _st = kubectl.run(
@@ -24,7 +24,8 @@ module KubernetesDeploy
           id,
           "--container=#{container_name}",
           "--since-time=#{@deploy_started_at.to_datetime.rfc3339}",
-          "--tail=#{LOG_LINE_COUNT}"
+          "--tail=#{LOG_LINE_COUNT}",
+          log_failure: false
         )
         container_logs[container_name] = out.split("\n")
       end
@@ -36,7 +37,7 @@ module KubernetesDeploy
       raise NotImplementedError, "Subclasses must define a `pods` accessor"
     end
 
-    def parent_of_pod?(_, _)
+    def parent_of_pod?(_)
       raise NotImplementedError, "Subclasses must define a `parent_of_pod?` method"
     end
 
@@ -46,14 +47,11 @@ module KubernetesDeploy
       regular_containers + init_containers
     end
 
-    def find_pods(pod_controller_data)
-      label_string = pod_controller_data["spec"]["selector"]["matchLabels"].map { |k, v| "#{k}=#{v}" }.join(",")
-      raw_json, _err, st = kubectl.run("get", "pods", "-a", "--output=json", "--selector=#{label_string}")
-      return [] unless st.success?
+    def find_pods(mediator)
+      all_pods = mediator.get_all(Pod.kind, @instance_data["spec"]["selector"]["matchLabels"])
 
-      all_pods = JSON.parse(raw_json)["items"]
       all_pods.each_with_object([]) do |pod_data, relevant_pods|
-        next unless parent_of_pod?(pod_controller_data, pod_data)
+        next unless parent_of_pod?(pod_data)
         pod = Pod.new(
           namespace: namespace,
           context: context,
@@ -62,7 +60,7 @@ module KubernetesDeploy
           parent: "#{name.capitalize} #{type}",
           deploy_started_at: @deploy_started_at
         )
-        pod.sync(pod_data)
+        pod.sync(mediator)
         relevant_pods << pod
       end
     end

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

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 module KubernetesDeploy
   class PodTemplate < KubernetesResource
-    def sync
-      _, _err, st = kubectl.run("get", type, @name)
-      @status = st.success? ? "Available" : "Unknown"
-      @found = st.success?
+    def status
+      exists? ? "Available" : "Unknown"
     end
 
     def deploy_succeeded?
@@ -18,9 +16,5 @@ module KubernetesDeploy
     def timeout_message
       UNUSUAL_FAILURE_MESSAGE
     end
-
-    def exists?
-      @found
-    end
   end
 end

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

@@ -4,75 +4,46 @@ module KubernetesDeploy
     TIMEOUT = 5.minutes
     UUID_ANNOTATION = "redis.stable.shopify.io/owner_uid"
 
-    def sync
-      _, _err, st = kubectl.run("get", type, @name)
-      @found = st.success?
-      @deployment_exists = redis_deployment_exists?
-      @service_exists = redis_service_exists?
+    SYNC_DEPENDENCIES = %w(Deployment Service)
+    def sync(mediator)
+      super
+      @deployment = mediator.get_instance(Deployment.kind, "redis-#{redis_resource_uuid}")
+      @service = mediator.get_instance(Service.kind, "redis-#{redis_resource_uuid}")
+    end
 
-      @status = if @deployment_exists && @service_exists
-        "Provisioned"
-      else
-        "Unknown"
-      end
+    def status
+      deploy_succeeded? ? "Provisioned" : "Unknown"
     end
 
     def deploy_succeeded?
-      @deployment_exists && @service_exists
+      deployment_ready? && service_ready?
     end
 
     def deploy_failed?
       false
     end
 
-    def exists?
-      @found
-    end
-
     def deploy_method
       :replace
     end
 
     private
 
-    def redis_deployment_exists?
-      deployment, _err, st = kubectl.run("get", "deployments", "redis-#{redis_resource_uuid}", "-o=json")
-
-      if st.success?
-        parsed = JSON.parse(deployment)
-
-        if parsed.fetch("status", {}).fetch("availableReplicas", -1) == parsed.fetch("status", {}).fetch("replicas", 0)
-          # all redis pods are running
-          return true
-        end
-      end
-
-      false
+    def deployment_ready?
+      return false unless status = @deployment["status"]
+      # all redis pods are running
+      status.fetch("availableReplicas", -1) == status.fetch("replicas", 0)
     end
 
-    def redis_service_exists?
-      service, _err, st = kubectl.run("get", "services", "redis-#{redis_resource_uuid}", "-o=json")
-
-      if st.success?
-        parsed = JSON.parse(service)
-
-        if parsed.dig("spec", "clusterIP").present?
-          return true
-        end
-      end
-
-      false
+    def service_ready?
+      return false unless @service.present?
+      # the service has an assigned cluster IP and is therefore functioning
+      @service.dig("spec", "clusterIP").present?
     end
 
     def redis_resource_uuid
-      return @redis_resource_uuid if defined?(@redis_resource_uuid) && @redis_resource_uuid
-
-      redis, _err, st = kubectl.run("get", "redises", @name, "-o=json")
-      if st.success?
-        parsed = JSON.parse(redis)
-
-        @redis_resource_uuid = parsed.dig("metadata", "uid")
-      end
+      return unless @instance_data.present?
+      @instance_data.dig("metadata", "uid")
     end
   end
 end

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

@@ -3,64 +3,62 @@ require 'kubernetes-deploy/kubernetes_resource/pod_set_base'
 module KubernetesDeploy
   class ReplicaSet < PodSetBase
     TIMEOUT = 5.minutes
-    attr_reader :desired_replicas, :ready_replicas, :available_replicas, :pods
+    attr_reader :pods
 
     def initialize(namespace:, context:, definition:, logger:, parent: nil, deploy_started_at: nil)
       @parent = parent
       @deploy_started_at = deploy_started_at
-      @rollout_data = { "replicas" => 0 }
-      @desired_replicas = -1
-      @ready_replicas = -1
-      @available_replicas = -1
       @pods = []
       super(namespace: namespace, context: context, definition: definition, logger: logger)
     end
 
-    def sync(rs_data = nil)
-      if rs_data.blank?
-        raw_json, _err, st = kubectl.run("get", type, @name, "--output=json")
-        rs_data = JSON.parse(raw_json) if st.success?
-      end
+    SYNC_DEPENDENCIES = %w(Pod)
+    def sync(mediator)
+      super
+      @pods = exists? ? find_pods(mediator) : []
+    end
 
-      if rs_data.present?
-        @found = true
-        @desired_replicas = rs_data["spec"]["replicas"].to_i
-        @rollout_data = { "replicas" => 0 }.merge(
-          rs_data["status"].slice("replicas", "availableReplicas", "readyReplicas")
-        )
-        @ready_replicas = @rollout_data['readyReplicas'].to_i
-        @available_replicas = @rollout_data["availableReplicas"].to_i
-        @status = @rollout_data.map { |state_replicas, num| "#{num} #{state_replicas.chop.pluralize(num)}" }.join(", ")
-        @pods = find_pods(rs_data)
-      else # reset
-        @found = false
-        @rollout_data = { "replicas" => 0 }
-        @status = nil
-        @pods = []
-        @desired_replicas = -1
-        @ready_replicas = -1
-        @available_replicas = -1
-      end
+    def status
+      return super unless rollout_data.present?
+      rollout_data.map { |state_replicas, num| "#{num} #{state_replicas.chop.pluralize(num)}" }.join(", ")
     end
 
     def deploy_succeeded?
-      @desired_replicas == @rollout_data["availableReplicas"].to_i &&
-      @desired_replicas == @rollout_data["readyReplicas"].to_i
+      desired_replicas == rollout_data["availableReplicas"].to_i &&
+      desired_replicas == rollout_data["readyReplicas"].to_i
     end
 
     def deploy_failed?
       pods.present? && pods.all?(&:deploy_failed?)
     end
 
-    def exists?
-      @found
+    def desired_replicas
+      return -1 unless exists?
+      @instance_data["spec"]["replicas"].to_i
+    end
+
+    def ready_replicas
+      return -1 unless exists?
+      rollout_data['readyReplicas'].to_i
+    end
+
+    def available_replicas
+      return -1 unless exists?
+      rollout_data["availableReplicas"].to_i
     end
 
     private
 
-    def parent_of_pod?(set_data, pod_data)
+    def rollout_data
+      return { "replicas" => 0 } unless exists?
+      { "replicas" => 0 }.merge(
+        @instance_data["status"].slice("replicas", "availableReplicas", "readyReplicas")
+      )
+    end
+
+    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"]["ownerReferences"].any? { |ref| ref["uid"] == @instance_data["metadata"]["uid"] }
     end
 
     def unmanaged?

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

@@ -3,19 +3,12 @@ module KubernetesDeploy
   class ResourceQuota < KubernetesResource
     TIMEOUT = 30.seconds
 
-    def sync
-      raw_json, _err, st = kubectl.run("get", type, @name, "--output=json")
-      @status = st.success? ? "Available" : "Unknown"
-      @found = st.success?
-      @rollout_data = if @found
-        JSON.parse(raw_json)
-      else
-        {}
-      end
+    def status
+      exists? ? "In effect" : "Unknown"
     end
 
     def deploy_succeeded?
-      @rollout_data.dig("spec", "hard") == @rollout_data.dig("status", "hard")
+      @instance_data.dig("spec", "hard") == @instance_data.dig("status", "hard")
     end
 
     def deploy_failed?
@@ -25,9 +18,5 @@ module KubernetesDeploy
     def timeout_message
       UNUSUAL_FAILURE_MESSAGE
     end
-
-    def exists?
-      @found
-    end
   end
 end