kubernetes-deploy 0.6.6 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 845bf8bd854e94df070d5637d37a8678f9a92411
-  data.tar.gz: 32a57ce86b607e98133ec04875d88f4ffa37495c
+  metadata.gz: 60da18d26c2e8a36c8761924b17e1b263eacaf70
+  data.tar.gz: 6f05ac075997226ed8c526f6d02cbb4406617b55
 SHA512:
-  metadata.gz: 8a6b635d9554e3737a5330fe4df509ec6ca5f5b1a0a3abac8016a199b084620d36ac47116e7863c9b8ebbda3e5a6a264b4b24da6262e772ee0250e2d98e48ea4
-  data.tar.gz: c479251f382257c6be386422f13d87ab4252f4adaa91b5d1600aa9df30b0d8687b9bb0612642275d2dc4860fc15871bb3afdad8f59e6311e1e120b3d9da11c7a
+  metadata.gz: da4f1f609882fb90af50e1505a9ca841eb8e6a95de220b3471686425964c953b025858bb86835b9d50f5f6053a77188affaf363d690b2211914a1c3bad4d17e3
+  data.tar.gz: 7fe5caa73866be72e7aa2351a4e0d562d4891eda7fc8261d4d9ceb5b5abc972bc09ca26a67459eec72d2b516bbb77fde10e4d63d78bbe791a93e2b810f5211d1

data/exe/kubernetes-deploy

@@ -10,6 +10,7 @@ template_dir = nil
 allow_protected_ns = false
 prune = true
 bindings = {}
+verbose_log_prefix = false
 
 ARGV.options do |opts|
   opts.on("--bindings=BINDINGS", Array, "k1=v1,k2=v2") do |binds|
@@ -25,6 +26,7 @@ ARGV.options do |opts|
   opts.on("--allow-protected-ns") { allow_protected_ns = true }
   opts.on("--no-prune") { prune = false }
   opts.on("--template-dir=DIR") { |v| template_dir = v }
+  opts.on("--verbose-log-prefix") { verbose_log_prefix = true }
   opts.parse!
 end
 
@@ -43,16 +45,22 @@ revision = ENV.fetch('REVISION') do
   exit 1
 end
 
-KubernetesDeploy::Runner.with_friendly_errors do
-  runner = KubernetesDeploy::Runner.new(
-    namespace: ARGV[0],
-    context: ARGV[1],
-    current_sha: revision,
-    template_dir: template_dir,
-    wait_for_completion: !skip_wait,
-    allow_protected_ns: allow_protected_ns,
-    prune: prune,
-    bindings: bindings
-  )
-  runner.run
-end
+namespace = ARGV[0]
+context = ARGV[1]
+logger = KubernetesDeploy::FormattedLogger.build(namespace, context, verbose_prefix: verbose_log_prefix)
+
+runner = KubernetesDeploy::Runner.new(
+  namespace: namespace,
+  context: context,
+  current_sha: revision,
+  template_dir: template_dir,
+  bindings: bindings,
+  logger: logger
+)
+
+success = runner.run(
+  verify_result: !skip_wait,
+  allow_protected_ns: allow_protected_ns,
+  prune: prune
+)
+exit 1 unless success

data/exe/kubernetes-restart

@@ -12,7 +12,10 @@ ARGV.options do |opts|
   opts.parse!
 end
 
-KubernetesDeploy::Runner.with_friendly_errors do
-  restart = KubernetesDeploy::RestartTask.new(namespace: ARGV[0], context: ARGV[1])
-  restart.perform(raw_deployments)
-end
+namespace = ARGV[0]
+context = ARGV[1]
+logger = KubernetesDeploy::FormattedLogger.build(namespace, context)
+
+restart = KubernetesDeploy::RestartTask.new(namespace: namespace, context: context, logger: logger)
+success = restart.perform(raw_deployments)
+exit 1 unless success

data/exe/kubernetes-run

@@ -16,16 +16,20 @@ ARGV.options do |opts|
   opts.parse!
 end
 
+namespace = ARGV[0]
+context = ARGV[1]
+logger = KubernetesDeploy::FormattedLogger.build(namespace, context)
+
 runner = KubernetesDeploy::RunnerTask.new(
-  namespace: ARGV[0],
-  context: ARGV[1],
+  namespace: namespace,
+  context: context,
+  logger: logger
 )
 
- KubernetesDeploy::Runner.with_friendly_errors do
-  runner.run(
-    task_template: template,
-    entrypoint: entrypoint,
-    args: ARGV[2..-1],
-    env_vars: env_vars
-  )
-end
+success = runner.run(
+  task_template: template,
+  entrypoint: entrypoint,
+  args: ARGV[2..-1],
+  env_vars: env_vars
+)
+exit 1 unless success

data/kubernetes-deploy.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "kubeclient", "~> 2.3"
   spec.add_dependency "googleauth", ">= 0.5"
   spec.add_dependency "ejson", "1.0.1"
+  spec.add_dependency "colorize", "~> 0.8"
 
   spec.add_development_dependency "bundler", "~> 1.13"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/kubernetes-deploy.rb

@@ -5,11 +5,12 @@ require 'active_support/core_ext/numeric/time'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/string/strip'
 require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/array/conversions'
+require 'colorized_string'
 
 require 'kubernetes-deploy/errors'
-require 'kubernetes-deploy/logger'
+require 'kubernetes-deploy/formatted_logger'
 require 'kubernetes-deploy/runner'
 
 module KubernetesDeploy
-  include Logger
 end

data/lib/kubernetes-deploy/deferred_summary_logging.rb

@@ -0,0 +1,87 @@
+module KubernetesDeploy
+  # Adds the methods kubernetes-deploy requires to your logger class.
+  # These methods include helpers for logging consistent headings, as well as facilities for
+  # displaying key information later, in a summary section, rather than when it occurred.
+  module DeferredSummaryLogging
+    attr_reader :summary
+    def initialize(*args)
+      reset
+      super
+    end
+
+    def reset
+      @summary = DeferredSummary.new
+      @current_phase = 0
+    end
+
+    def blank_line(level = :info)
+      public_send(level, "")
+    end
+
+    def phase_heading(phase_name)
+      @current_phase += 1
+      heading("Phase #{@current_phase}: #{phase_name}")
+    end
+
+    def heading(text, secondary_msg = '', secondary_msg_color = :blue)
+      padding = (100.0 - (text.length + secondary_msg.length)) / 2
+      blank_line
+      part1 = ColorizedString.new("#{'-' * padding.floor}#{text}").blue
+      part2 = ColorizedString.new(secondary_msg).colorize(secondary_msg_color)
+      part3 = ColorizedString.new('-' * padding.ceil).blue
+      info(part1 + part2 + part3)
+    end
+
+    # Outputs the deferred summary information saved via @logger.summary.add_action and @logger.summary.add_paragraph
+    def print_summary(success)
+      if success
+        heading("Result: ", "SUCCESS", :green)
+        level = :info
+      else
+        heading("Result: ", "FAILURE", :red)
+        level = :fatal
+      end
+
+      public_send(level, summary.actions_sentence)
+      summary.paragraphs.each do |para|
+        blank_line(level)
+        msg_lines = para.split("\n")
+        msg_lines.each { |line| public_send(level, line) }
+      end
+    end
+
+    class DeferredSummary
+      attr_reader :paragraphs
+
+      def initialize
+        @actions_taken = []
+        @paragraphs = []
+      end
+
+      def actions_sentence
+        case @actions_taken.length
+        when 0 then "No actions taken"
+        else
+          @actions_taken.to_sentence.capitalize
+        end
+      end
+
+      # Saves a sentence fragment to be displayed in the first sentence of the summary section
+      #
+      # Example:
+      # # The resulting summary will begin with "Created 3 secrets and failed to deploy 2 resources"
+      # @logger.summary.add_action("created 3 secrets")
+      # @logger.summary.add_cation("failed to deploy 2 resources")
+      def add_action(sentence_fragment)
+        @actions_taken << sentence_fragment
+      end
+
+      # Adds a paragraph to be displayed in the summary section
+      # Paragraphs will be printed in the order they were added, separated by a blank line
+      # This can be used to log a block of data on a particular topic, e.g. debug info for a particular failed resource
+      def add_paragraph(paragraph)
+        paragraphs << paragraph
+      end
+    end
+  end
+end

data/lib/kubernetes-deploy/ejson_secret_provisioner.rb

@@ -2,7 +2,6 @@
 require 'json'
 require 'base64'
 require 'open3'
-require 'kubernetes-deploy/logger'
 require 'kubernetes-deploy/kubectl'
 
 module KubernetesDeploy
@@ -18,13 +17,12 @@ module KubernetesDeploy
     EJSON_SECRETS_FILE = "secrets.ejson"
     EJSON_KEYS_SECRET = "ejson-keys"
 
-    def initialize(namespace:, context:, template_dir:)
+    def initialize(namespace:, context:, template_dir:, logger:)
       @namespace = namespace
       @context = context
       @ejson_file = "#{template_dir}/#{EJSON_SECRETS_FILE}"
-
-      raise FatalDeploymentError, "Cannot create secrets without a namespace" if @namespace.blank?
-      raise FatalDeploymentError, "Cannot create secrets without a context" if @context.blank?
+      @logger = logger
+      @kubectl = Kubectl.new(namespace: @namespace, context: @context, logger: @logger, log_failure_by_default: false)
     end
 
     def secret_changes_required?
@@ -42,7 +40,7 @@ module KubernetesDeploy
       with_decrypted_ejson do |decrypted|
         secrets = decrypted[MANAGED_SECRET_EJSON_KEY]
         unless secrets.present?
-          KubernetesDeploy.logger.warn("#{EJSON_SECRETS_FILE} does not have key #{MANAGED_SECRET_EJSON_KEY}."\
+          @logger.warn("#{EJSON_SECRETS_FILE} does not have key #{MANAGED_SECRET_EJSON_KEY}."\
             "No secrets will be created.")
           return
         end
@@ -51,6 +49,7 @@ module KubernetesDeploy
           validate_secret_spec(secret_name, secret_spec)
           create_or_update_secret(secret_name, secret_spec["_type"], secret_spec["data"])
         end
+        @logger.summary.add_action("created/updated #{secrets.length} #{'secret'.pluralize(secrets.length)}")
       end
     end
 
@@ -58,16 +57,19 @@ module KubernetesDeploy
       ejson_secret_names = encrypted_ejson.fetch(MANAGED_SECRET_EJSON_KEY, {}).keys
       live_secrets = run_kubectl_json("get", "secrets")
 
+      prune_count = 0
       live_secrets.each do |secret|
         secret_name = secret["metadata"]["name"]
         next unless secret_managed?(secret)
         next if ejson_secret_names.include?(secret_name)
 
-        KubernetesDeploy.logger.info("Pruning secret #{secret_name}")
-        out, err, st = run_kubectl("delete", "secret", secret_name)
-        KubernetesDeploy.logger.debug(out)
+        @logger.info("Pruning secret #{secret_name}")
+        prune_count += 1
+        out, err, st = @kubectl.run("delete", "secret", secret_name)
+        @logger.debug(out)
         raise EjsonSecretError, err unless st.success?
       end
+      @logger.summary.add_action("pruned #{prune_count} #{'secret'.pluralize(prune_count)}") if prune_count > 0
     end
 
     def managed_secrets_exist?
@@ -103,15 +105,15 @@ module KubernetesDeploy
 
     def create_or_update_secret(secret_name, secret_type, data)
       msg = secret_exists?(secret_name) ? "Updating secret #{secret_name}" : "Creating secret #{secret_name}"
-      KubernetesDeploy.logger.info(msg)
+      @logger.info(msg)
 
       secret_yaml = generate_secret_yaml(secret_name, secret_type, data)
       file = Tempfile.new(secret_name)
       file.write(secret_yaml)
       file.close
 
-      out, err, st = run_kubectl("apply", "--filename=#{file.path}")
-      KubernetesDeploy.logger.debug(out)
+      out, err, st = @kubectl.run("apply", "--filename=#{file.path}")
+      @logger.debug(out)
       raise EjsonSecretError, err unless st.success?
     ensure
       file.unlink if file
@@ -144,7 +146,7 @@ module KubernetesDeploy
     end
 
     def secret_exists?(secret_name)
-      _out, _err, st = run_kubectl("get", "secret", secret_name)
+      _out, _err, st = @kubectl.run("get", "secret", secret_name)
       st.success?
     end
 
@@ -166,7 +168,7 @@ module KubernetesDeploy
     end
 
     def decrypt_ejson(key_dir)
-      KubernetesDeploy.logger.info("Decrypting #{EJSON_SECRETS_FILE}")
+      @logger.info("Decrypting #{EJSON_SECRETS_FILE}")
       # ejson seems to dump both errors and output to STDOUT
       out_err, st = Open3.capture2e("EJSON_KEYDIR=#{key_dir} ejson decrypt #{@ejson_file}")
       raise EjsonSecretError, out_err unless st.success?
@@ -176,7 +178,7 @@ module KubernetesDeploy
     end
 
     def fetch_private_key_from_secret
-      KubernetesDeploy.logger.info("Fetching ejson private key from secret #{EJSON_KEYS_SECRET}")
+      @logger.info("Fetching ejson private key from secret #{EJSON_KEYS_SECRET}")
 
       secret = run_kubectl_json("get", "secret", EJSON_KEYS_SECRET)
       encoded_private_key = secret["data"][public_key]
@@ -189,14 +191,10 @@ module KubernetesDeploy
 
     def run_kubectl_json(*args)
       args += ["--output=json"]
-      out, err, st = run_kubectl(*args)
+      out, err, st = @kubectl.run(*args)
       raise EjsonSecretError, err unless st.success?
       result = JSON.parse(out)
       result.fetch('items', result)
     end
-
-    def run_kubectl(*args)
-      Kubectl.run_kubectl(*args, namespace: @namespace, context: @context, log_failure: false)
-    end
   end
 end

data/lib/kubernetes-deploy/formatted_logger.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require 'logger'
+require 'kubernetes-deploy/deferred_summary_logging'
+
+module KubernetesDeploy
+  class FormattedLogger < Logger
+    include DeferredSummaryLogging
+
+    def self.build(namespace, context, stream = $stderr, verbose_prefix: false)
+      l = new(stream)
+      l.level = level_from_env
+
+      l.formatter = proc do |severity, datetime, _progname, msg|
+        middle = verbose_prefix ? "[#{context}][#{namespace}]" : ""
+        colorized_line = ColorizedString.new("[#{severity}][#{datetime}]#{middle}\t#{msg}\n")
+
+        case severity
+        when "FATAL"
+          ColorizedString.new("[#{severity}][#{datetime}]#{middle}\t").red + "#{msg}\n"
+        when "ERROR"
+          colorized_line.red
+        when "WARN"
+          colorized_line.yellow
+        else
+          colorized_line
+        end
+      end
+      l
+    end
+
+    def self.level_from_env
+      return ::Logger::DEBUG if ENV["DEBUG"]
+
+      if ENV["LEVEL"]
+        ::Logger.const_get(ENV["LEVEL"].upcase)
+      else
+        ::Logger::INFO
+      end
+    end
+    private_class_method :level_from_env
+  end
+end

data/lib/kubernetes-deploy/kubectl.rb

@@ -1,18 +1,31 @@
 # frozen_string_literal: true
 
 module KubernetesDeploy
-  module Kubectl
-    def self.run_kubectl(*args, namespace:, context:, log_failure: true)
+  class Kubectl
+    def initialize(namespace:, context:, logger:, log_failure_by_default:)
+      @namespace = namespace
+      @context = context
+      @logger = logger
+      @log_failure_by_default = log_failure_by_default
+
+      raise ArgumentError, "namespace is required" if namespace.blank?
+      raise ArgumentError, "context is required" if context.blank?
+    end
+
+    def run(*args, log_failure: nil, use_context: true, use_namespace: true)
+      log_failure = @log_failure_by_default if log_failure.nil?
+
       args = args.unshift("kubectl")
-      args.push("--namespace=#{namespace}") if namespace.present?
-      args.push("--context=#{context}")     if context.present?
+      args.push("--namespace=#{@namespace}") if use_namespace
+      args.push("--context=#{@context}")     if use_context
 
-      KubernetesDeploy.logger.debug Shellwords.join(args)
+      @logger.debug Shellwords.join(args)
       out, err, st = Open3.capture3(*args)
-      KubernetesDeploy.logger.debug(out.shellescape)
+      @logger.debug(out.shellescape)
+
       if !st.success? && log_failure
-        KubernetesDeploy.logger.warn("The following command failed: #{Shellwords.join(args)}")
-        KubernetesDeploy.logger.warn(err)
+        @logger.warn("The following command failed: #{Shellwords.join(args)}")
+        @logger.warn(err)
       end
       [out.chomp, err.chomp, st]
     end

data/lib/kubernetes-deploy/kubernetes_resource.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'json'
 require 'open3'
 require 'shellwords'
@@ -5,39 +6,42 @@ require 'kubernetes-deploy/kubectl'
 
 module KubernetesDeploy
   class KubernetesResource
-    def self.logger=(value)
-      @logger = value
-    end
-
-    def self.logger
-      @logger ||= begin
-        l = ::Logger.new($stderr)
-        l.formatter = proc do |_severity, datetime, _progname, msg|
-          "[KUBESTATUS][#{datetime}]\t#{msg}\n"
-        end
-        l
-      end
-    end
-
     attr_reader :name, :namespace, :file, :context
     attr_writer :type, :deploy_started
 
     TIMEOUT = 5.minutes
 
-    def self.for_type(type, name, namespace, context, file)
-      case type
-      when 'cloudsql' then Cloudsql.new(name, namespace, context, file)
-      when 'configmap' then ConfigMap.new(name, namespace, context, file)
-      when 'deployment' then Deployment.new(name, namespace, context, file)
-      when 'pod' then Pod.new(name, namespace, context, file)
-      when 'redis' then Redis.new(name, namespace, context, file)
-      when 'bugsnag' then Bugsnag.new(name, namespace, context, file)
-      when 'ingress' then Ingress.new(name, namespace, context, file)
-      when 'persistentvolumeclaim' then PersistentVolumeClaim.new(name, namespace, context, file)
-      when 'service' then Service.new(name, namespace, context, file)
-      when 'podtemplate' then PodTemplate.new(name, namespace, context, file)
-      when 'poddisruptionbudget' then PodDisruptionBudget.new(name, namespace, context, file)
-      else self.new(name, namespace, context, file).tap { |r| r.type = type }
+    DEBUG_RESOURCE_NOT_FOUND_MESSAGE = "None found. Please check your usual logging service (e.g. Splunk)."
+    UNUSUAL_FAILURE_MESSAGE = <<-MSG.strip_heredoc
+      It is very unusual for this resource type to fail to deploy. Please try the deploy again.
+      If that new deploy also fails, contact your cluster administrator.
+      MSG
+    STANDARD_TIMEOUT_MESSAGE = <<-MSG.strip_heredoc
+      Kubernetes will continue to attempt to deploy this resource in the cluster, but at this point it is considered unlikely that it will succeed.
+      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)
+      else
+        inst = new(**opts)
+        inst.tap { |r| r.type = type }
       end
     end
 
@@ -49,9 +53,13 @@ module KubernetesDeploy
       self.class.timeout
     end
 
-    def initialize(name, namespace, context, file)
-      # subclasses must also set these
-      @name, @namespace, @context, @file = name, namespace, context, file
+    def initialize(name:, namespace:, context:, file:, logger:)
+      # subclasses must also set these if they define their own initializer
+      @name = name
+      @namespace = namespace
+      @context = context
+      @file = file
+      @logger = logger
     end
 
     def id
@@ -59,7 +67,6 @@ module KubernetesDeploy
     end
 
     def sync
-      log_status
     end
 
     def deploy_failed?
@@ -68,7 +75,7 @@ module KubernetesDeploy
 
     def deploy_succeeded?
       if @deploy_started && !@success_assumption_warning_shown
-        KubernetesDeploy.logger.warn("Don't know how to monitor resources of type #{type}. Assuming #{id} deployed successfully.")
+        @logger.warn("Don't know how to monitor resources of type #{type}. Assuming #{id} deployed successfully.")
         @success_assumption_warning_shown = true
       end
       true
@@ -80,7 +87,6 @@ module KubernetesDeploy
 
     def status
       @status ||= "Unknown"
-      deploy_timed_out? ? "Timed out with status #{@status}" : @status
     end
 
     def type
@@ -106,31 +112,84 @@ module KubernetesDeploy
       tpr? ? :replace : :apply
     end
 
-    def status_data
-      {
-        group: group_name,
-        name: name,
-        status_string: status,
-        exists: exists?,
-        succeeded: deploy_succeeded?,
-        failed: deploy_failed?,
-        timed_out: deploy_timed_out?
-      }
+    def debug_message
+      helpful_info = []
+      if deploy_failed?
+        helpful_info << ColorizedString.new("#{id}: FAILED").red
+        helpful_info << failure_message if failure_message.present?
+      else
+        helpful_info << ColorizedString.new("#{id}: TIMED OUT").yellow + " (limit: #{timeout}s)"
+        helpful_info << timeout_message if timeout_message.present?
+      end
+      helpful_info << "  - Final status: #{status}"
+
+      events = fetch_events
+      if events.present?
+        helpful_info << "  - Events:"
+        events.each do |identifier, event_hashes|
+          event_hashes.each { |event| helpful_info << "      [#{identifier}]\t#{event}" }
+        end
+      else
+        helpful_info << "  - Events: #{DEBUG_RESOURCE_NOT_FOUND_MESSAGE}"
+      end
+
+      if respond_to?(:fetch_logs)
+        container_logs = fetch_logs
+        if container_logs.blank? || container_logs.values.all?(&:blank?)
+          helpful_info << "  - Logs: #{DEBUG_RESOURCE_NOT_FOUND_MESSAGE}"
+        else
+          helpful_info << "  - Logs:"
+          container_logs.each do |identifier, logs|
+            logs.split("\n").each do |line|
+              helpful_info << "      [#{identifier}]\t#{line}"
+            end
+          end
+        end
+      end
+
+      helpful_info.join("\n")
+    end
+
+    # Returns a hash in the following format:
+    # {
+    #   "pod/web-1" => [
+    #     {"subject_kind" => "Pod", "some" => "stuff"}, # event 1
+    #     {"subject_kind" => "Pod", "other" => "stuff"}, # event 2
+    #   ]
+    # }
+    def fetch_events
+      return {} unless exists?
+      fields = "{.involvedObject.kind}\t{.count}\t{.message}\t{.reason}"
+      out, _err, st = kubectl.run("get", "events",
+        %(--output=jsonpath={range .items[?(@.involvedObject.name=="#{name}")]}#{fields}\n{end}))
+      return {} unless st.success?
+
+      event_collector = Hash.new { |hash, key| hash[key] = [] }
+      out.split("\n").each_with_object(event_collector) do |event_blob, events|
+        pieces = event_blob.split("\t")
+        subject_kind = pieces[0]
+        # jsonpath can only filter by one thing at a time, and we chose involvedObject.name
+        # This means we still need to filter by involvedObject.kind here to make sure we only retain relevant events
+        next unless subject_kind.downcase == type.downcase
+        events[id] << "#{pieces[3] || 'Unknown'}: #{pieces[2]} (#{pieces[1]} events)" # Reason: Message (X events)
+      end
     end
 
-    def group_name
-      type.downcase.pluralize
+    def timeout_message
+      STANDARD_TIMEOUT_MESSAGE
     end
 
-    def log_status
-      KubernetesResource.logger.info("[#{@context}][#{@namespace}] #{JSON.dump(status_data)}")
+    def failure_message
     end
 
-    def run_kubectl(*args)
-      raise FatalDeploymentError, "Namespace missing for namespaced command" if @namespace.blank?
-      raise KubectlError, "Explicit context is required to run this command" if @context.blank?
+    def pretty_status
+      padding = " " * (50 - id.length)
+      msg = exists? ? status : "not found"
+      "#{id}#{padding}#{msg}"
+    end
 
-      Kubectl.run_kubectl(*args, namespace: @namespace, context: @context, log_failure: false)
+    def kubectl
+      @kubectl ||= Kubectl.new(namespace: @namespace, context: @context, logger: @logger, log_failure_by_default: false)
     end
   end
 end