kubernetes-deploy 0.29.0 → 1.0.0.pre.2

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

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

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

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

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-module KubernetesDeploy
+module Krane
   class Pod < KubernetesResource
     TIMEOUT = 10.minutes
 
@@ -101,6 +101,10 @@ module KubernetesDeploy
       exists? && !@stream_logs # don't print them a second time
     end
 
+    def node_name
+      @instance_data.dig('spec', 'nodeName')
+    end
+
     private
 
     def failed_schedule_reason
@@ -137,7 +141,7 @@ module KubernetesDeploy
     end
 
     def logs
-      @logs ||= KubernetesDeploy::RemoteLogs.new(
+      @logs ||= Krane::RemoteLogs.new(
         logger: @logger,
         parent_id: id,
         container_names: @containers.map(&:name),

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-module KubernetesDeploy
+module Krane
   class PodDisruptionBudget < KubernetesResource
     TIMEOUT = 10.seconds
 
@@ -13,7 +13,7 @@ module KubernetesDeploy
 
     def deploy_method
       # Required until https://github.com/kubernetes/kubernetes/issues/45398 changes
-      :replace_force
+      uses_generate_name? ? :create : :replace_force
     end
 
     def timeout_message

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
-require 'kubernetes-deploy/kubernetes_resource/pod'
+require 'krane/kubernetes_resource/pod'
 
-module KubernetesDeploy
+module Krane
   class PodSetBase < KubernetesResource
     def failure_message
       pods.map(&:failure_message).compact.uniq.join("\n")
@@ -19,7 +19,7 @@ module KubernetesDeploy
     end
 
     def fetch_debug_logs
-      logs = KubernetesDeploy::RemoteLogs.new(
+      logs = Krane::RemoteLogs.new(
         logger: @logger,
         parent_id: id,
         container_names: container_names,

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-module KubernetesDeploy
+module Krane
   class PodTemplate < KubernetesResource
     def status
       exists? ? "Available" : "Not Found"

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
-require 'kubernetes-deploy/kubernetes_resource/pod_set_base'
+require 'krane/kubernetes_resource/pod_set_base'
 
-module KubernetesDeploy
+module Krane
   class ReplicaSet < PodSetBase
     TIMEOUT = 5.minutes
     attr_reader :pods

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

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

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

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

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

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

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

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

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
-require 'kubernetes-deploy/kubernetes_resource/pod'
+require 'krane/kubernetes_resource/pod'
 
-module KubernetesDeploy
+module Krane
   class Service < KubernetesResource
     TIMEOUT = 7.minutes
 

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

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

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
-require 'kubernetes-deploy/kubernetes_resource/pod_set_base'
-module KubernetesDeploy
+require 'krane/kubernetes_resource/pod_set_base'
+module Krane
   class StatefulSet < PodSetBase
     TIMEOUT = 10.minutes
     ONDELETE = 'OnDelete'

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module KubernetesDeploy
+module Krane
   class LabelSelector
     def self.parse(string)
       selector = {}

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module KubernetesDeploy
+module Krane
   module OptionsHelper
     class OptionsError < StandardError; end
 
@@ -19,7 +19,7 @@ module KubernetesDeploy
         end
 
         if template_paths.include?("-")
-          Dir.mktmpdir("kubernetes-deploy") do |dir|
+          Dir.mktmpdir("krane") do |dir|
             template_dir_from_stdin(temp_dir: dir)
             validated_paths << dir
             yield validated_paths

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
-require 'kubernetes-deploy/container_logs'
+require 'krane/container_logs'
 
-module KubernetesDeploy
+module Krane
   class RemoteLogs
     attr_reader :container_logs
 

data/lib/krane/render_task.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+require 'tempfile'
+
+require 'krane/common'
+require 'krane/renderer'
+require 'krane/template_sets'
+
+module Krane
+  # Render templates
+  class RenderTask
+    # Initializes the render task
+    #
+    # @param logger [Object] Logger object (defaults to an instance of Krane::FormattedLogger)
+    # @param current_sha [String] The SHA of the commit
+    # @param template_dir [String] Path to a directory with templates to render (deprecated)
+    # @param template_paths [Array<String>] An array of template paths to render
+    # @param bindings [Hash] Bindings parsed by Krane::BindingsParser
+    def initialize(logger: nil, current_sha:, template_dir: nil, template_paths: [], bindings:)
+      @logger = logger || Krane::FormattedLogger.build
+      @template_dir = template_dir
+      @template_paths = template_paths.map { |path| File.expand_path(path) }
+      @bindings = bindings
+      @current_sha = current_sha
+    end
+
+    # Runs the task, returning a boolean representing success or failure
+    #
+    # @return [Boolean]
+    def run(*args)
+      run!(*args)
+      true
+    rescue Krane::FatalDeploymentError
+      false
+    end
+
+    # Runs the task, raising exceptions in case of issues
+    #
+    # @param stream [IO] Place to stream the output to
+    # @param only_filenames [Array<String>] List of filenames to render
+    #
+    # @return [nil]
+    def run!(stream, only_filenames = [])
+      @logger.reset
+      @logger.phase_heading("Initializing render task")
+
+      ts = TemplateSets.from_dirs_and_files(paths: template_sets_paths(only_filenames), logger: @logger)
+
+      validate_configuration(ts, only_filenames)
+      count = render_templates(stream, ts)
+
+      @logger.summary.add_action("Successfully rendered #{count} template(s)")
+      @logger.print_summary(:success)
+    rescue Krane::FatalDeploymentError
+      @logger.print_summary(:failure)
+      raise
+    end
+
+    private
+
+    def template_sets_paths(only_filenames)
+      if @template_paths.present?
+        # Validation will catch @template_paths & @template_dir being present
+        @template_paths
+      elsif only_filenames.blank?
+        [File.expand_path(@template_dir || '')]
+      else
+        absolute_template_dir = File.expand_path(@template_dir || '')
+        only_filenames.map do |name|
+          File.join(absolute_template_dir, name)
+        end
+      end
+    end
+
+    def render_templates(stream, template_sets)
+      @logger.phase_heading("Rendering template(s)")
+      count = 0
+      template_sets.with_resource_definitions_and_filename(render_erb: true,
+          current_sha: @current_sha, bindings: @bindings, raw: true) do |rendered_content, filename|
+        write_to_stream(rendered_content, filename, stream)
+        count += 1
+      end
+
+      count
+    rescue Krane::InvalidTemplateError => exception
+      log_invalid_template(exception)
+      raise
+    end
+
+    def write_to_stream(rendered_content, filename, stream)
+      file_basename = File.basename(filename)
+      @logger.info("Rendering #{file_basename}...")
+      implicit = []
+      YAML.parse_stream(rendered_content, "<rendered> #{filename}") { |d| implicit << d.implicit }
+      if rendered_content.present?
+        stream.puts "---\n" if implicit.first
+        stream.puts rendered_content
+        @logger.info("Rendered #{file_basename}")
+      else
+        @logger.warn("Rendered #{file_basename} successfully, but the result was blank")
+      end
+    rescue Psych::SyntaxError => exception
+      raise InvalidTemplateError.new("Template is not valid YAML. #{exception.message}", filename: filename)
+    end
+
+    def validate_configuration(template_sets, filenames)
+      @logger.info("Validating configuration")
+      errors = []
+      if @template_dir.present? && @template_paths.present?
+        errors << "template_dir and template_paths can not be combined"
+      elsif @template_dir.blank? && @template_paths.blank?
+        errors << "template_dir or template_paths must be set"
+      end
+
+      if filenames.present?
+        if @template_dir.nil?
+          errors << "template_dir must be set to use filenames"
+        else
+          absolute_template_dir = File.expand_path(@template_dir)
+          filenames.each do |filename|
+            absolute_file = File.expand_path(File.join(@template_dir, filename))
+            unless absolute_file.start_with?(absolute_template_dir)
+              errors << "Filename \"#{absolute_file}\" is outside the template directory," \
+              " which was resolved as #{absolute_template_dir}"
+            end
+          end
+        end
+      end
+
+      errors += template_sets.validate
+
+      unless errors.empty?
+        @logger.summary.add_action("Configuration invalid")
+        @logger.summary.add_paragraph(errors.map { |err| "- #{err}" }.join("\n"))
+        raise Krane::TaskConfigurationError, "Configuration invalid: #{errors.join(', ')}"
+      end
+    end
+
+    def log_invalid_template(exception)
+      @logger.error("Failed to render #{exception.filename}")
+
+      debug_msg = ColorizedString.new("Invalid template: #{exception.filename}\n").red
+      debug_msg += "> Error message:\n#{FormattedLogger.indent_four(exception.to_s)}"
+      if exception.content
+        debug_msg += "\n> Template content:\n#{FormattedLogger.indent_four(exception.content)}"
+      end
+      @logger.summary.add_paragraph(debug_msg)
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ require 'securerandom'
 require 'yaml'
 require 'json'
 
-module KubernetesDeploy
+module Krane
   class Renderer
     class InvalidPartialError < InvalidTemplateError
       attr_accessor :parents, :content, :filename

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

@@ -2,22 +2,22 @@
 
 require 'concurrent/hash'
 
-module KubernetesDeploy
+module Krane
   class ResourceCache
-    def initialize(namespace, context, logger)
-      @namespace = namespace
-      @context = context
-      @logger = logger
+    delegate :namespace, :context, :logger, to: :@task_config
+
+    def initialize(task_config)
+      @task_config = task_config
 
       @kind_fetcher_locks = Concurrent::Hash.new { |hash, key| hash[key] = Mutex.new }
       @data = Concurrent::Hash.new
-      @kubectl = Kubectl.new(namespace: @namespace, context: @context, logger: @logger, log_failure_by_default: false)
+      @kubectl = Kubectl.new(task_config: @task_config, log_failure_by_default: false)
     end
 
     def get_instance(kind, resource_name, raise_if_not_found: false)
       instance = use_or_populate_cache(kind).fetch(resource_name, {})
       if instance.blank? && raise_if_not_found
-        raise KubernetesDeploy::Kubectl::ResourceNotFoundError, "Resource does not exist (used cache for kind #{kind})"
+        raise Krane::Kubectl::ResourceNotFoundError, "Resource does not exist (used cache for kind #{kind})"
       end
       instance
     rescue KubectlError
@@ -39,7 +39,7 @@ module KubernetesDeploy
     private
 
     def statsd_tags
-      { namespace: @namespace, context: @context }
+      { namespace: namespace, context: context }
     end
 
     def use_or_populate_cache(kind)
@@ -51,9 +51,10 @@ module KubernetesDeploy
 
     def fetch_by_kind(kind)
       resource_class = KubernetesResource.class_for_kind(kind)
+      global_kind = @task_config.global_kinds.map(&:downcase).include?(kind.downcase)
       output_is_sensitive = resource_class.nil? ? false : resource_class::SENSITIVE_TEMPLATE_CONTENT
       raw_json, _, st = @kubectl.run("get", kind, "--chunk-size=0", attempts: 5, output: "json",
-         output_is_sensitive: output_is_sensitive)
+         output_is_sensitive: output_is_sensitive, use_namespace: !global_kind)
       raise KubectlError unless st.success?
 
       instances = {}

data/lib/krane/resource_deployer.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require 'krane/resource_watcher'
+require 'krane/concerns/template_reporting'
+
+module Krane
+  class ResourceDeployer
+    extend Krane::StatsD::MeasureMethods
+    include Krane::TemplateReporting
+
+    delegate :logger, to: :@task_config
+    attr_reader :statsd_tags
+
+    def initialize(task_config:, prune_whitelist:, max_watch_seconds:, current_sha: nil, selector:, statsd_tags:)
+      @task_config = task_config
+      @prune_whitelist = prune_whitelist
+      @max_watch_seconds = max_watch_seconds
+      @current_sha = current_sha
+      @selector = selector
+      @statsd_tags = statsd_tags
+    end
+
+    def deploy!(resources, verify_result, prune)
+      if verify_result
+        deploy_all_resources(resources, prune: prune, verify: true)
+        failed_resources = resources.reject(&:deploy_succeeded?)
+        success = failed_resources.empty?
+        if !success && failed_resources.all?(&:deploy_timed_out?)
+          raise DeploymentTimeoutError
+        end
+        raise FatalDeploymentError unless success
+      else
+        deploy_all_resources(resources, prune: prune, verify: false)
+        logger.summary.add_action("deployed #{resources.length} #{'resource'.pluralize(resources.length)}")
+        warning = <<~MSG
+          Deploy result verification is disabled for this deploy.
+          This means the desired changes were communicated to Kubernetes, but the deploy did not make sure they actually succeeded.
+        MSG
+        logger.summary.add_paragraph(ColorizedString.new(warning).yellow)
+      end
+    end
+
+    def predeploy_priority_resources(resource_list, predeploy_sequence)
+      bare_pods = resource_list.select { |resource| resource.is_a?(Pod) }
+      if bare_pods.count == 1
+        bare_pods.first.stream_logs = true
+      end
+
+      predeploy_sequence.each do |resource_type|
+        matching_resources = resource_list.select { |r| r.type == resource_type }
+        next if matching_resources.empty?
+        deploy_resources(matching_resources, verify: true, record_summary: false)
+
+        failed_resources = matching_resources.reject(&:deploy_succeeded?)
+        fail_count = failed_resources.length
+        if fail_count > 0
+          Krane::Concurrency.split_across_threads(failed_resources) do |r|
+            r.sync_debug_info(kubectl)
+          end
+          failed_resources.each { |r| logger.summary.add_paragraph(r.debug_message) }
+          raise FatalDeploymentError, "Failed to deploy #{fail_count} priority #{'resource'.pluralize(fail_count)}"
+        end
+        logger.blank_line
+      end
+    end
+    measure_method(:predeploy_priority_resources, 'priority_resources.duration')
+
+    private
+
+    def deploy_all_resources(resources, prune: false, verify:, record_summary: true)
+      deploy_resources(resources, prune: prune, verify: verify, record_summary: record_summary)
+    end
+    measure_method(:deploy_all_resources, 'normal_resources.duration')
+
+    def deploy_resources(resources, prune: false, verify:, record_summary: true)
+      return if resources.empty?
+      deploy_started_at = Time.now.utc
+
+      if resources.length > 1
+        logger.info("Deploying resources:")
+        resources.each do |r|
+          logger.info("- #{r.id} (#{r.pretty_timeout_type})")
+        end
+      else
+        resource = resources.first
+        logger.info("Deploying #{resource.id} (#{resource.pretty_timeout_type})")
+      end
+
+      # Apply can be done in one large batch, the rest have to be done individually
+      applyables, individuals = resources.partition { |r| r.deploy_method == :apply }
+      # Prunable resources should also applied so that they can  be pruned
+      pruneable_types = @prune_whitelist.map { |t| t.split("/").last }
+      applyables += individuals.select { |r| pruneable_types.include?(r.type) }
+
+      individuals.each do |individual_resource|
+        individual_resource.deploy_started_at = Time.now.utc
+
+        case individual_resource.deploy_method
+        when :create
+          err, status = create_resource(individual_resource)
+        when :replace
+          err, status = replace_or_create_resource(individual_resource)
+        when :replace_force
+          err, status = replace_or_create_resource(individual_resource, force: true)
+        else
+          # Fail Fast! This is a programmer mistake.
+          raise ArgumentError, "Unexpected deploy method! (#{individual_resource.deploy_method.inspect})"
+        end
+
+        next if status.success?
+
+        raise FatalDeploymentError, <<~MSG
+          Failed to replace or create resource: #{individual_resource.id}
+          #{individual_resource.sensitive_template_content? ? '<suppressed sensitive output>' : err}
+        MSG
+      end
+
+      apply_all(applyables, prune)
+
+      if verify
+        watcher = Krane::ResourceWatcher.new(resources: resources, deploy_started_at: deploy_started_at,
+          timeout: @max_watch_seconds, task_config: @task_config, sha: @current_sha)
+        watcher.run(record_summary: record_summary)
+      end
+    end
+
+    def apply_all(resources, prune)
+      return unless resources.present?
+      command = %w(apply)
+
+      Dir.mktmpdir do |tmp_dir|
+        resources.each do |r|
+          FileUtils.symlink(r.file_path, tmp_dir)
+          r.deploy_started_at = Time.now.utc
+        end
+        command.push("-f", tmp_dir)
+
+        if prune && @prune_whitelist.present?
+          command.push("--prune")
+          if @selector
+            command.push("--selector", @selector.to_s)
+          else
+            command.push("--all")
+          end
+          @prune_whitelist.each { |type| command.push("--prune-whitelist=#{type}") }
+        end
+
+        output_is_sensitive = resources.any?(&:sensitive_template_content?)
+        global_mode = resources.all?(&:global?)
+        out, err, st = kubectl.run(*command, log_failure: false, output_is_sensitive: output_is_sensitive,
+          use_namespace: !global_mode)
+
+        if st.success?
+          log_pruning(out) if prune
+        else
+          record_apply_failure(err, resources: resources)
+          raise FatalDeploymentError, "Command failed: #{Shellwords.join(command)}"
+        end
+      end
+    end
+    measure_method(:apply_all)
+
+    def log_pruning(kubectl_output)
+      pruned = kubectl_output.scan(/^(.*) pruned$/)
+      return unless pruned.present?
+
+      logger.info("The following resources were pruned: #{pruned.join(', ')}")
+      logger.summary.add_action("pruned #{pruned.length} #{'resource'.pluralize(pruned.length)}")
+    end
+
+    def record_apply_failure(err, resources: [])
+      warn_msg = "WARNING: Any resources not mentioned in the error(s) below were likely created/updated. " \
+        "You may wish to roll back this deploy."
+      logger.summary.add_paragraph(ColorizedString.new(warn_msg).yellow)
+
+      unidentified_errors = []
+      filenames_with_sensitive_content = resources
+        .select(&:sensitive_template_content?)
+        .map { |r| File.basename(r.file_path) }
+
+      server_dry_run_validated_resource = resources
+        .select(&:server_dry_run_validated?)
+        .map { |r| File.basename(r.file_path) }
+
+      err.each_line do |line|
+        bad_files = find_bad_files_from_kubectl_output(line)
+        unless bad_files.present?
+          unidentified_errors << line
+          next
+        end
+
+        bad_files.each do |f|
+          err_msg = f[:err]
+          if filenames_with_sensitive_content.include?(f[:filename])
+            # Hide the error and template contents in case it has sensitive information
+            # we display full error messages as we assume there's no sensitive info leak after server-dry-run
+            err_msg = "SUPPRESSED FOR SECURITY" unless server_dry_run_validated_resource.include?(f[:filename])
+            record_invalid_template(logger: logger, err: err_msg, filename: f[:filename], content: nil)
+          else
+            record_invalid_template(logger: logger, err: err_msg, filename: f[:filename], content: f[:content])
+          end
+        end
+      end
+      return unless unidentified_errors.any?
+
+      if (filenames_with_sensitive_content - server_dry_run_validated_resource).present?
+        warn_msg = "WARNING: There was an error applying some or all resources. The raw output may be sensitive and " \
+          "so cannot be displayed."
+        logger.summary.add_paragraph(ColorizedString.new(warn_msg).yellow)
+      else
+        heading = ColorizedString.new('Unidentified error(s):').red
+        msg = FormattedLogger.indent_four(unidentified_errors.join)
+        logger.summary.add_paragraph("#{heading}\n#{msg}")
+      end
+    end
+
+    def replace_or_create_resource(resource, force: false)
+      args = if force
+        ["replace", "--force", "--cascade", "-f", resource.file_path]
+      else
+        ["replace", "-f", resource.file_path]
+      end
+
+      _, err, status = kubectl.run(*args, log_failure: false, output_is_sensitive: resource.sensitive_template_content?,
+        raise_if_not_found: true, use_namespace: !resource.global?)
+
+      [err, status]
+    rescue Krane::Kubectl::ResourceNotFoundError
+      # it doesn't exist so we can't replace it, we try to create it
+      create_resource(resource)
+    end
+
+    def create_resource(resource)
+      out, err, status = kubectl.run("create", "-f", resource.file_path, log_failure: false,
+        output: 'json', output_is_sensitive: resource.sensitive_template_content?,
+        use_namespace: !resource.global?)
+
+      # For resources that rely on a generateName attribute, we get the `name` from the result of the call to `create`
+      # We must explicitly set this name value so that the `apply` step for pruning can run successfully
+      if status.success? && resource.uses_generate_name?
+        resource.use_generated_name(JSON.parse(out))
+      end
+
+      [err, status]
+    end
+
+    # Inspect the file referenced in the kubectl stderr
+    # to make it easier for developer to understand what's going on
+    def find_bad_files_from_kubectl_output(line)
+      # stderr often contains one or more lines like the following, from which we can extract the file path(s):
+      # Error from server (TypeOfError): error when creating "/path/to/service-gqq5oh.yml": Service "web" is invalid:
+
+      line.scan(%r{"(/\S+\.ya?ml\S*)"}).each_with_object([]) do |matches, bad_files|
+        matches.each do |path|
+          content = File.read(path) if File.file?(path)
+          bad_files << { filename: File.basename(path), err: line, content: content }
+        end
+      end
+    end
+
+    def kubectl
+      @kubectl ||= Kubectl.new(task_config: @task_config, log_failure_by_default: true)
+    end
+  end
+end