kubernetes-deploy 0.7.8 → 0.7.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c72be87cc8ea1503ae698d2a789ceba24015691e
-  data.tar.gz: 42985326dfd947a6bb549f595bf5aae4f6296889
+  metadata.gz: 13dbeb21aaaa5ab8c43c1f7fb6737ad1a9c2f735
+  data.tar.gz: 817ac9680c47685d2ecc9257952830baab8ee4ef
 SHA512:
-  metadata.gz: 6a9d5f8e191e7de823812350ba7931dc504b74a8268cbae3f80a39da4dab2aea47265e6a9aaf65d2e400d9477302490d0198450df25460360c1983a484f21e29
-  data.tar.gz: 89e0078eb5300a7b791a1205154a4c322b3ce2c0370ac20bd70b2fc9efe710c856c2fa0fd463fcbc1cc48e19561cb5f69d646926b60c1f18b385264741f4343f
+  metadata.gz: a613afd9f8697c843223f20e70b7c22ec174af2d1f0394e6978d3644900b9713f6d6480c7897074c9cf77d594cdd37ee8dfa5ef55f05d240c69e0e226b61a709
+  data.tar.gz: 8247c8ca0ac3fdc7ef2a867e0bb2207741fc86894ad5b7ae80e12f71c29bbecc898be64a94175ca4e57a5f3344ad03976eb36d34f5ee284b52598a8caef81b54

data/lib/kubernetes-deploy/kubernetes_resource.rb

@@ -22,27 +22,15 @@ module KubernetesDeploy
       If you have reason to believe it will succeed, retry the deploy to continue to monitor the rollout.
       MSG
 
-    def self.for_type(type:, name:, namespace:, context:, file:, logger:)
-      subclass = case type
-      when 'cloudsql' then Cloudsql
-      when 'configmap' then ConfigMap
-      when 'deployment' then Deployment
-      when 'pod' then Pod
-      when 'redis' then Redis
-      when 'bugsnag' then Bugsnag
-      when 'ingress' then Ingress
-      when 'persistentvolumeclaim' then PersistentVolumeClaim
-      when 'service' then Service
-      when 'podtemplate' then PodTemplate
-      when 'poddisruptionbudget' then PodDisruptionBudget
-      end
-
-      opts = { name: name, namespace: namespace, context: context, file: file, logger: logger }
-      if subclass
-        subclass.new(**opts)
+    def self.build(namespace:, context:, definition:, logger:)
+      opts = { namespace: namespace, context: context, definition: definition, logger: logger }
+      if KubernetesDeploy.const_defined?(definition["kind"])
+        klass = KubernetesDeploy.const_get(definition["kind"])
+        klass.new(**opts)
       else
         inst = new(**opts)
-        inst.tap { |r| r.type = type }
+        inst.type = definition["kind"]
+        inst
       end
     end
 
@@ -54,19 +42,28 @@ module KubernetesDeploy
       self.class.timeout
     end
 
-    def initialize(name:, namespace:, context:, file:, logger:)
+    def initialize(namespace:, context:, definition:, logger:)
       # subclasses must also set these if they define their own initializer
-      @name = name
+      @name = definition.fetch("metadata", {})["name"]
+      unless @name.present?
+        logger.summary.add_paragraph("Rendered template content:\n#{definition.to_yaml}")
+        raise FatalDeploymentError, "Template is missing required field metadata.name"
+      end
+
       @namespace = namespace
       @context = context
-      @file = file
       @logger = logger
+      @definition = definition
     end
 
     def id
       "#{type}/#{name}"
     end
 
+    def file_path
+      file.path
+    end
+
     def sync
     end
 
@@ -139,10 +136,11 @@ module KubernetesDeploy
         if container_logs.blank? || container_logs.values.all?(&:blank?)
           helpful_info << "  - Logs: #{DEBUG_RESOURCE_NOT_FOUND_MESSAGE}"
         else
-          helpful_info << "  - Logs (last #{LOG_LINE_COUNT} lines shown):"
-          container_logs.each do |identifier, logs|
-            logs.split("\n").each do |line|
-              helpful_info << "      [#{identifier}]\t#{line}"
+          sorted_logs = container_logs.sort_by { |_, log_lines| log_lines.length }
+          sorted_logs.each do |identifier, log_lines|
+            helpful_info << "  - Logs from container '#{identifier}' (last #{LOG_LINE_COUNT} lines shown):"
+            log_lines.each do |line|
+              helpful_info << "      #{line}"
             end
           end
         end
@@ -241,5 +239,19 @@ module KubernetesDeploy
         "#{@reason}: #{@message} (#{@count} events)"
       end
     end
+
+    private
+
+    def file
+      @file ||= create_definition_tempfile
+    end
+
+    def create_definition_tempfile
+      file = Tempfile.new(["#{type}-#{name}", ".yml"])
+      file.write(YAML.dump(@definition))
+      file
+    ensure
+      file.close if file
+    end
   end
 end

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

@@ -4,80 +4,84 @@ module KubernetesDeploy
     TIMEOUT = 5.minutes
 
     def sync
-      json_data, _err, st = kubectl.run("get", type, @name, "--output=json")
+      raw_json, _err, st = kubectl.run("get", type, @name, "--output=json")
       @found = st.success?
-      @rollout_data = {}
-      @status = nil
-      @representative_pod = nil
-      @pods = []
 
       if @found
-        @rollout_data = JSON.parse(json_data)["status"]
-          .slice("updatedReplicas", "replicas", "availableReplicas", "unavailableReplicas")
-        @status = @rollout_data.map { |replica_state, num| "#{num} #{replica_state}" }.join(", ")
-
-        pod_list, _err, st = kubectl.run("get", "pods", "-a", "-l", "name=#{name}", "--output=json")
-        if st.success?
-          pods_json = JSON.parse(pod_list)["items"]
-          pods_json.each do |pod_json|
-            pod_name = pod_json["metadata"]["name"]
-            pod = Pod.new(
-              name: pod_name,
-              namespace: namespace,
-              context: context,
-              file: nil,
-              parent: "#{@name.capitalize} deployment",
-              logger: @logger
-            )
-            pod.deploy_started = @deploy_started
-            pod.interpret_json_data(pod_json)
-
-            if !@representative_pod && pod_probably_new?(pod_json)
-              @representative_pod = pod
-            end
-            @pods << pod
-          end
-        end
+        deployment_data = JSON.parse(raw_json)
+        @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(", ")
+      else # reset
+        @latest_rs = nil
+        @rollout_data = { "replicas" => 0 }
+        @status = nil
       end
     end
 
-    def fetch_logs
-      @representative_pod ? @representative_pod.fetch_logs : {}
-    end
-
     def fetch_events
       own_events = super
-      return own_events unless @representative_pod
-      own_events.merge(@representative_pod.fetch_events)
+      return own_events unless @latest_rs.present?
+      own_events.merge(@latest_rs.fetch_events)
+    end
+
+    def fetch_logs
+      return {} unless @latest_rs.present?
+      @latest_rs.fetch_logs
     end
 
     def deploy_succeeded?
-      return false unless @rollout_data.key?("availableReplicas")
-      # TODO: this should look at the current replica set's pods too
+      return false unless @latest_rs
+
+      @latest_rs.deploy_succeeded? &&
+      @latest_rs.desired_replicas == desired_replicas && # latest RS fully scaled up
       @rollout_data["updatedReplicas"].to_i == @rollout_data["replicas"].to_i &&
       @rollout_data["updatedReplicas"].to_i == @rollout_data["availableReplicas"].to_i
     end
 
     def deploy_failed?
-      # TODO: this should look at the current replica set's pods only or it'll never be true for rolling updates
-      @pods.present? && @pods.all?(&:deploy_failed?)
+      @latest_rs && @latest_rs.deploy_failed?
     end
 
     def deploy_timed_out?
-      # TODO: this should look at the current replica set's pods only or it'll never be true for rolling updates
-      super || @pods.present? && @pods.all?(&:deploy_timed_out?)
+      super || @latest_rs && @latest_rs.deploy_timed_out?
     end
 
     def exists?
       @found
     end
 
+    def desired_replicas
+      @definition["spec"]["replicas"].to_i
+    end
+
     private
 
-    def pod_probably_new?(pod_json)
-      return false unless @deploy_started
-      # Shitty, brittle workaround to identify a pod from the new ReplicaSet before implementing ReplicaSet awareness
-      Time.parse(pod_json["metadata"]["creationTimestamp"]) >= (@deploy_started - 30.seconds)
+    def find_latest_rs(deployment_data)
+      label_string = deployment_data["spec"]["selector"]["matchLabels"].map { |k, v| "#{k}=#{v}" }.join(",")
+      raw_json, _err, st = kubectl.run("get", "replicasets", "--output=json", "--selector=#{label_string}")
+      return unless st.success?
+
+      all_rs_data = JSON.parse(raw_json)["items"]
+      current_revision = deployment_data["metadata"]["annotations"]["deployment.kubernetes.io/revision"]
+
+      latest_rs_data = all_rs_data.find do |rs|
+        rs["metadata"]["ownerReferences"].any? { |ref| ref["uid"] == deployment_data["metadata"]["uid"] } &&
+        rs["metadata"]["annotations"]["deployment.kubernetes.io/revision"] == current_revision
+      end
+      return unless latest_rs_data.present?
+
+      rs = ReplicaSet.new(
+        namespace: namespace,
+        context: context,
+        definition: latest_rs_data,
+        logger: @logger,
+        parent: "#{@name.capitalize} deployment",
+        deploy_started: @deploy_started
+      )
+      rs.sync(latest_rs_data)
+      rs
     end
   end
 end

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

@@ -2,52 +2,37 @@
 module KubernetesDeploy
   class Pod < KubernetesResource
     TIMEOUT = 10.minutes
-    SUSPICIOUS_CONTAINER_STATES = %w(ImagePullBackOff RunContainerError ErrImagePull).freeze
+    SUSPICIOUS_CONTAINER_STATES = %w(ImagePullBackOff RunContainerError ErrImagePull CrashLoopBackOff).freeze
 
-    def initialize(name:, namespace:, context:, file:, parent: nil, logger:)
-      @name = name
-      @namespace = namespace
-      @context = context
-      @file = file
+    def initialize(namespace:, context:, definition:, logger:, parent: nil, deploy_started: nil)
       @parent = parent
-      @logger = logger
-    end
-
-    def sync
-      out, _err, st = kubectl.run("get", type, @name, "-a", "--output=json")
-      if @found = st.success?
-        pod_data = JSON.parse(out)
-        interpret_json_data(pod_data)
-      else # reset
-        @status = @phase = nil
-        @ready = false
-        @containers = []
+      @deploy_started = deploy_started
+      @containers = definition.fetch("spec", {}).fetch("containers", {}).map { |c| c["name"] }
+      unless @containers.present?
+        logger.summary.add_paragraph("Rendered template content:\n#{definition.to_yaml}")
+        raise FatalDeploymentError, "Template is missing required field spec.containers"
       end
-      display_logs if unmanaged? && deploy_succeeded?
+      super(namespace: namespace, context: context, definition: definition, logger: logger)
     end
 
-    def interpret_json_data(pod_data)
-      @phase = (pod_data["metadata"]["deletionTimestamp"] ? "Terminating" : pod_data["status"]["phase"])
-      @containers = pod_data["spec"]["containers"].map { |c| c["name"] }
-
-      if @deploy_started && pod_data["status"]["containerStatuses"]
-        pod_data["status"]["containerStatuses"].each do |status|
-          waiting_state = status["state"]["waiting"] if status["state"]
-          reason = waiting_state["reason"] if waiting_state
-          next unless SUSPICIOUS_CONTAINER_STATES.include?(reason)
-          @logger.warn("#{id} has container in state #{reason} (#{waiting_state['message']})")
-        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?
       end
 
-      if @phase == "Failed"
-        @status = "#{@phase} (Reason: #{pod_data['status']['reason']})"
-      elsif @phase == "Terminating"
-        @status = @phase
-      else
-        ready_condition = pod_data["status"].fetch("conditions", []).find { |condition| condition["type"] == "Ready" }
-        @ready = ready_condition.present? && (ready_condition["status"] == "True")
-        @status = "#{@phase} (Ready: #{@ready})"
+      if pod_data.present?
+        @found = true
+        interpret_pod_status_data(pod_data["status"], pod_data["metadata"]) # sets @phase, @status and @ready
+        if @deploy_started
+          log_suspicious_states(pod_data["status"].fetch("containerStatuses", []))
+        end
+      else # reset
+        @found = false
+        @phase = @status = nil
+        @ready = false
       end
+      display_logs if unmanaged? && deploy_succeeded?
     end
 
     def deploy_succeeded?
@@ -63,17 +48,16 @@ module KubernetesDeploy
     end
 
     def exists?
-      unmanaged? ? @found : true
+      @found
     end
 
     # Returns a hash in the following format:
     # {
-    #   "pod/web-1/app-container" => "giant blob of logs\nas a single string"
-    #   "pod/web-1/nginx-container" => "another giant blob of logs\nas a single string"
+    #   "app" => ["array of log lines", "received from app container"],
+    #   "nginx" => ["array of log lines", "received from nginx container"]
     # }
     def fetch_logs
       return {} unless exists? && @containers.present?
-
       @containers.each_with_object({}) do |container_name, container_logs|
         cmd = [
           "logs",
@@ -83,12 +67,33 @@ module KubernetesDeploy
         ]
         cmd << "--tail=#{LOG_LINE_COUNT}" unless unmanaged?
         out, _err, _st = kubectl.run(*cmd)
-        container_logs["#{id}/#{container_name}"] = out
+        container_logs[container_name] = out.split("\n")
       end
     end
 
     private
 
+    def interpret_pod_status_data(status_data, metadata)
+      @status = @phase = (metadata["deletionTimestamp"] ? "Terminating" : status_data["phase"])
+
+      if @phase == "Failed" && status_data['reason'].present?
+        @status += " (Reason: #{status_data['reason']})"
+      elsif @phase != "Terminating"
+        ready_condition = status_data.fetch("conditions", []).find { |condition| condition["type"] == "Ready" }
+        @ready = ready_condition.present? && (ready_condition["status"] == "True")
+        @status += " (Ready: #{@ready})"
+      end
+    end
+
+    def log_suspicious_states(container_statuses)
+      container_statuses.each do |status|
+        waiting_state = status["state"]["waiting"] if status["state"]
+        reason = waiting_state["reason"] if waiting_state
+        next unless SUSPICIOUS_CONTAINER_STATES.include?(reason)
+        @logger.warn("#{id} has container in state #{reason} (#{waiting_state['message']})")
+      end
+    end
+
     def unmanaged?
       @parent.blank?
     end
@@ -104,13 +109,11 @@ module KubernetesDeploy
 
       container_logs.each do |container_identifier, logs|
         if logs.blank?
-          @logger.warn("No logs found for #{container_identifier}")
+          @logger.warn("No logs found for container '#{container_identifier}'")
         else
           @logger.blank_line
-          @logger.info("Logs from #{container_identifier}:")
-          logs.split("\n").each do |line|
-            @logger.info("[#{container_identifier}]\t#{line}")
-          end
+          @logger.info("Logs from #{id} container '#{container_identifier}':")
+          logs.each { |line| @logger.info("\t#{line}") }
           @logger.blank_line
         end
       end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+module KubernetesDeploy
+  class ReplicaSet < KubernetesResource
+    TIMEOUT = 5.minutes
+
+    def initialize(namespace:, context:, definition:, logger:, parent: nil, deploy_started: nil)
+      @parent = parent
+      @deploy_started = deploy_started
+      @rollout_data = { "replicas" => 0 }
+      @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
+
+      if rs_data.present?
+        @found = true
+        @rollout_data = { "replicas" => 0 }.merge(rs_data["status"]
+          .slice("replicas", "availableReplicas", "readyReplicas"))
+        @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 = []
+      end
+    end
+
+    def deploy_succeeded?
+      @rollout_data["replicas"].to_i == @rollout_data["availableReplicas"].to_i &&
+      @rollout_data["replicas"].to_i == @rollout_data["readyReplicas"].to_i
+    end
+
+    def deploy_failed?
+      @pods.present? && @pods.all?(&:deploy_failed?)
+    end
+
+    def deploy_timed_out?
+      super || @pods.present? && @pods.all?(&:deploy_timed_out?)
+    end
+
+    def exists?
+      @found
+    end
+
+    def desired_replicas
+      @definition["spec"]["replicas"].to_i
+    end
+
+    def fetch_events
+      own_events = super
+      return own_events unless @pods.present?
+      own_events.merge(@pods.first.fetch_events)
+    end
+
+    def fetch_logs
+      container_names.each_with_object({}) do |container_name, container_logs|
+        out, _err, _st = kubectl.run(
+          "logs",
+          id,
+          "--container=#{container_name}",
+          "--since-time=#{@deploy_started.to_datetime.rfc3339}",
+          "--tail=#{LOG_LINE_COUNT}"
+        )
+        container_logs[container_name] = out.split("\n")
+      end
+    end
+
+    private
+
+    def unmanaged?
+      @parent.blank?
+    end
+
+    def container_names
+      @definition["spec"]["template"]["spec"]["containers"].map { |c| c["name"] }
+    end
+
+    def find_pods(rs_data)
+      label_string = rs_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?
+
+      all_pods = JSON.parse(raw_json)["items"]
+      all_pods.each_with_object([]) do |pod_data, relevant_pods|
+        next unless pod_data["metadata"]["ownerReferences"].any? { |ref| ref["uid"] == rs_data["metadata"]["uid"] }
+        pod = Pod.new(
+          namespace: namespace,
+          context: context,
+          definition: pod_data,
+          logger: @logger,
+          parent: "#{@name.capitalize} replica set",
+          deploy_started: @deploy_started
+        )
+        pod.sync(pod_data)
+        relevant_pods << pod
+      end
+    end
+  end
+end

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

@@ -16,7 +16,11 @@ module KubernetesDeploy
     end
 
     def deploy_succeeded?
-      @num_endpoints > 0
+      if exposes_zero_replica_deployment?
+        @num_endpoints == 0
+      else
+        @num_endpoints > 0
+      end
     end
 
     def deploy_failed?
@@ -33,5 +37,23 @@ module KubernetesDeploy
     def exists?
       @found
     end
+
+    private
+
+    def exposes_zero_replica_deployment?
+      related_deployment_replicas && related_deployment_replicas == 0
+    end
+
+    def related_deployment_replicas
+      @related_deployment_replicas ||= begin
+        selector = @definition["spec"]["selector"].map { |k, v| "#{k}=#{v}" }.join(",")
+        raw_json, _err, st = kubectl.run("get", "deployments", "--selector=#{selector}", "--output=json")
+        return unless st.success?
+
+        deployments = JSON.parse(raw_json)["items"]
+        return unless deployments.length == 1
+        deployments.first["spec"]["replicas"].to_i
+      end
+    end
   end
 end

data/lib/kubernetes-deploy/restart_task.rb

@@ -70,7 +70,8 @@ module KubernetesDeploy
 
     def wait_for_rollout(kubeclient_resources)
       resources = kubeclient_resources.map do |d|
-        Deployment.new(name: d.metadata.name, namespace: @namespace, context: @context, file: nil, logger: @logger)
+        definition = d.to_h.deep_stringify_keys
+        Deployment.new(namespace: @namespace, context: @context, definition: definition, logger: @logger)
       end
       watcher = ResourceWatcher.new(resources, logger: @logger)
       watcher.run

data/lib/kubernetes-deploy/runner.rb

@@ -18,6 +18,7 @@ require 'kubernetes-deploy/kubernetes_resource'
   pod_template
   bugsnag
   pod_disruption_budget
+  replica_set
 ).each do |subresource|
   require "kubernetes-deploy/kubernetes_resource/#{subresource}"
 end
@@ -181,14 +182,13 @@ module KubernetesDeploy
     def find_bad_file_from_kubectl_output(stderr)
       # Output example:
       # Error from server (BadRequest): error when creating "/path/to/configmap-gqq5oh.yml20170411-33615-t0t3m":
-      match = stderr.match(%r{BadRequest.*"(?<path>\/\S+\.ya?ml\S+)"})
+      match = stderr.match(%r{BadRequest.*"(?<path>\/\S+\.ya?ml\S*)"})
       return unless match
 
       path = match[:path]
       if path.present? && File.file?(path)
-        suspicious_file = File.read(path)
+        File.read(path)
       end
-      [File.basename(path, ".*"), suspicious_file]
     end
 
     def deploy_has_priority_resources?(resources)
@@ -217,48 +217,38 @@ module KubernetesDeploy
       Dir.foreach(@template_dir) do |filename|
         next unless filename.end_with?(".yml.erb", ".yml", ".yaml", ".yaml.erb")
 
-        split_templates(filename) do |tempfile|
-          resource_id = discover_resource_via_dry_run(tempfile)
-          type, name = resource_id.split("/", 2) # e.g. "pod/web-198612918-dzvfb"
-          resources << KubernetesResource.for_type(type: type, name: name, namespace: @namespace, context: @context,
-            file: tempfile, logger: @logger)
-          @logger.info "  - #{resource_id}"
+        split_templates(filename) do |r_def|
+          r = KubernetesResource.build(namespace: @namespace, context: @context, logger: @logger, definition: r_def)
+          validate_template_via_dry_run(r.file_path, filename)
+          resources << r
+          @logger.info "  - #{r.id}"
         end
       end
       resources
     end
 
-    def discover_resource_via_dry_run(tempfile)
-      command = ["create", "-f", tempfile.path, "--dry-run", "--output=name"]
-      resource_id, err, st = kubectl.run(*command, log_failure: false)
+    def validate_template_via_dry_run(file_path, original_filename)
+      command = ["create", "-f", file_path, "--dry-run", "--output=name"]
+      _, err, st = kubectl.run(*command, log_failure: false)
+      return if st.success?
 
-      unless st.success?
-        debug_msg = <<-DEBUG_MSG.strip_heredoc
-          This usually means template '#{File.basename(tempfile.path, '.*')}' is not a valid Kubernetes template.
-
-          Error from kubectl:
-            #{err}
-
-          Rendered template content:
-        DEBUG_MSG
-        debug_msg += File.read(tempfile.path)
-        @logger.summary.add_paragraph(debug_msg)
+      debug_msg = <<-DEBUG_MSG.strip_heredoc
+        This usually means template '#{original_filename}' is not a valid Kubernetes template.
+        Error from kubectl:
+          #{err}
+        Rendered template content:
+      DEBUG_MSG
+      debug_msg += File.read(file_path)
+      @logger.summary.add_paragraph(debug_msg)
 
-        raise FatalDeploymentError, "Kubectl dry run failed (command: #{Shellwords.join(command)})"
-      end
-      resource_id
+      raise FatalDeploymentError, "Kubectl dry run failed (command: #{Shellwords.join(command)})"
     end
 
     def split_templates(filename)
       file_content = File.read(File.join(@template_dir, filename))
       rendered_content = render_template(filename, file_content)
       YAML.load_stream(rendered_content) do |doc|
-        next if doc.blank?
-
-        f = Tempfile.new(filename)
-        f.write(YAML.dump(doc))
-        f.close
-        yield f
+        yield doc unless doc.blank?
       end
     rescue Psych::SyntaxError => e
       debug_msg = <<-INFO.strip_heredoc
@@ -273,23 +263,14 @@ module KubernetesDeploy
     end
 
     def record_apply_failure(err)
-      file_name, file_content = find_bad_file_from_kubectl_output(err)
-      if file_name
-        debug_msg = <<-HELPFUL_MESSAGE.strip_heredoc
-          This usually means your template named '#{file_name}' is invalid.
-
-          Error from kubectl:
-            #{err}
-
-          Rendered template content:
-        HELPFUL_MESSAGE
-        debug_msg += file_content || "Failed to read file"
-      else
-        debug_msg = <<-FALLBACK_MSG
-          This usually means one of your templates is invalid, but we were unable to automatically identify which one.
-          Please inspect the error message from kubectl:
-            #{err}
-        FALLBACK_MSG
+      file_content = find_bad_file_from_kubectl_output(err)
+      debug_msg = <<-HELPFUL_MESSAGE.strip_heredoc
+        This usually means one of your templates is invalid.
+        Error from kubectl:
+          #{err}
+      HELPFUL_MESSAGE
+      if file_content
+        debug_msg += "Rendered template content:\n#{file_content}"
       end
 
       @logger.summary.add_paragraph(debug_msg)
@@ -376,9 +357,9 @@ module KubernetesDeploy
         r.deploy_started = Time.now.utc
         case r.deploy_method
         when :replace
-          _, _, replace_st = kubectl.run("replace", "-f", r.file.path, log_failure: false)
+          _, _, replace_st = kubectl.run("replace", "-f", r.file_path, log_failure: false)
         when :replace_force
-          _, _, replace_st = kubectl.run("replace", "--force", "-f", r.file.path, log_failure: false)
+          _, _, replace_st = kubectl.run("replace", "--force", "-f", r.file_path, log_failure: false)
         else
           # Fail Fast! This is a programmer mistake.
           raise ArgumentError, "Unexpected deploy method! (#{r.deploy_method.inspect})"
@@ -386,7 +367,7 @@ module KubernetesDeploy
 
         next if replace_st.success?
         # it doesn't exist so we can't replace it
-        _, err, create_st = kubectl.run("create", "-f", r.file.path, log_failure: false)
+        _, err, create_st = kubectl.run("create", "-f", r.file_path, log_failure: false)
 
         next if create_st.success?
         raise FatalDeploymentError, <<-MSG.strip_heredoc
@@ -405,7 +386,7 @@ module KubernetesDeploy
       command = ["apply"]
       resources.each do |r|
         @logger.info("- #{r.id} (timeout: #{r.timeout}s)") if resources.length > 1
-        command.push("-f", r.file.path)
+        command.push("-f", r.file_path)
         r.deploy_started = Time.now.utc
       end
 

data/lib/kubernetes-deploy/version.rb

@@ -1,3 +1,3 @@
 module KubernetesDeploy
-  VERSION = "0.7.8"
+  VERSION = "0.7.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kubernetes-deploy
 version: !ruby/object:Gem::Version
-  version: 0.7.8
+  version: 0.7.9
 platform: ruby
 authors:
 - Katrina Verey
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-27 00:00:00.000000000 Z
+date: 2017-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -206,6 +206,7 @@ files:
 - lib/kubernetes-deploy/kubernetes_resource/pod_disruption_budget.rb
 - lib/kubernetes-deploy/kubernetes_resource/pod_template.rb
 - lib/kubernetes-deploy/kubernetes_resource/redis.rb
+- lib/kubernetes-deploy/kubernetes_resource/replica_set.rb
 - lib/kubernetes-deploy/kubernetes_resource/service.rb
 - lib/kubernetes-deploy/resource_watcher.rb
 - lib/kubernetes-deploy/restart_task.rb