kubernetes-deploy 0.22.0 → 0.23.0

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

@@ -6,10 +6,9 @@ module KubernetesDeploy
     ONDELETE = 'OnDelete'
     attr_reader :pods
 
-    SYNC_DEPENDENCIES = %w(Pod)
-    def sync(mediator)
+    def sync(cache)
       super
-      @pods = exists? ? find_pods(mediator) : []
+      @pods = exists? ? find_pods(cache) : []
     end
 
     def status

data/lib/kubernetes-deploy/oj.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require 'oj'
+
+Oj.mimic_JSON

data/lib/kubernetes-deploy/options_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module KubernetesDeploy
+  module OptionsHelper
+    def self.default_and_check_template_dir(template_dir)
+      if !template_dir && ENV.key?("ENVIRONMENT")
+        template_dir = "config/deploy/#{ENV['ENVIRONMENT']}"
+      end
+
+      if !template_dir || template_dir.empty?
+        puts "Template directory is unknown. " \
+          "Either specify --template-dir argument or set $ENVIRONMENT to use config/deploy/$ENVIRONMENT " \
+        + "as a default path."
+        exit 1
+      end
+
+      template_dir
+    end
+
+    def self.revision_from_environment
+      ENV.fetch('REVISION') do
+        puts "ENV['REVISION'] is missing. Please specify the commit SHA"
+        exit 1
+      end
+    end
+  end
+end

data/lib/kubernetes-deploy/remote_logs.rb

@@ -5,11 +5,17 @@ module KubernetesDeploy
   class RemoteLogs
     attr_reader :container_logs
 
-    def initialize(logger:, parent_id:, container_names:)
+    def initialize(logger:, parent_id:, container_names:, namespace:, context:)
       @logger = logger
       @parent_id = parent_id
       @container_logs = container_names.map do |n|
-        ContainerLogs.new(logger: logger, container_name: n, parent_id: parent_id)
+        ContainerLogs.new(
+          logger: logger,
+          container_name: n,
+          parent_id: parent_id,
+          namespace: namespace,
+          context: context
+        )
       end
     end
 
@@ -17,8 +23,8 @@ module KubernetesDeploy
       @container_logs.all?(&:empty?)
     end
 
-    def sync(kubectl)
-      @container_logs.each { |cl| cl.sync(kubectl) }
+    def sync
+      @container_logs.each(&:sync)
     end
 
     def print_latest

data/lib/kubernetes-deploy/render_task.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+require 'tempfile'
+
+require 'kubernetes-deploy/renderer'
+require 'kubernetes-deploy/template_discovery'
+
+module KubernetesDeploy
+  class RenderTask
+    def initialize(logger:, current_sha:, template_dir:, bindings:)
+      @logger = logger
+      @template_dir = template_dir
+      @renderer = KubernetesDeploy::Renderer.new(
+        current_sha: current_sha,
+        bindings: bindings,
+        template_dir: @template_dir,
+        logger: @logger,
+      )
+    end
+
+    def run(*args)
+      run!(*args)
+      true
+    rescue KubernetesDeploy::FatalDeploymentError
+      false
+    end
+
+    def run!(stream, only_filenames = [])
+      @logger.reset
+      @logger.phase_heading("Initializing render task")
+
+      filenames = if only_filenames.empty?
+        TemplateDiscovery.new(@template_dir).templates
+      else
+        only_filenames
+      end
+
+      validate_configuration(filenames)
+      render_filenames(stream, filenames)
+
+      @logger.summary.add_action("Successfully rendered #{filenames.size} template(s)")
+      @logger.print_summary(:success)
+    rescue KubernetesDeploy::FatalDeploymentError
+      @logger.print_summary(:failure)
+      raise
+    end
+
+    private
+
+    def render_filenames(stream, filenames)
+      exceptions = []
+      @logger.phase_heading("Rendering template(s)")
+
+      filenames.each do |filename|
+        begin
+          render_filename(filename, stream)
+        rescue KubernetesDeploy::InvalidTemplateError => exception
+          exceptions << exception
+          log_invalid_template(exception)
+        end
+      end
+
+      unless exceptions.empty?
+        raise exceptions[0]
+      end
+    end
+
+    def render_filename(filename, stream)
+      @logger.info("Rendering #{File.basename(filename)} ...")
+      file_content = File.read(File.join(@template_dir, filename))
+      rendered_content = @renderer.render_template(filename, file_content)
+      YAML.load_stream(rendered_content, "<rendered> #{filename}") do |doc|
+        stream.puts YAML.dump(doc)
+      end
+      @logger.info("Rendered #{File.basename(filename)}")
+    rescue Psych::SyntaxError => exception
+      raise InvalidTemplateError.new("Template is not valid YAML. #{exception.message}", filename: filename)
+    end
+
+    def validate_configuration(filenames)
+      @logger.info("Validating configuration")
+      errors = []
+
+      if filenames.empty?
+        errors << "no templates found in template dir #{@template_dir}"
+      end
+
+      absolute_template_dir = File.expand_path(@template_dir)
+
+      filenames.each do |filename|
+        absolute_file = File.expand_path(File.join(@template_dir, filename))
+        if !File.exist?(absolute_file)
+          errors << "Filename \"#{absolute_file}\" could not be found"
+        elsif !File.file?(absolute_file)
+          errors << "Filename \"#{absolute_file}\" is not a file"
+        elsif !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
+
+      unless errors.empty?
+        @logger.summary.add_action("Configuration invalid")
+        @logger.summary.add_paragraph(errors.map { |err| "- #{err}" }.join("\n"))
+        raise KubernetesDeploy::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/renderer.rb

@@ -52,7 +52,7 @@ module KubernetesDeploy
       template = File.read(partial_path)
       expanded_template = ERB.new(template, nil, '-').result(erb_binding)
 
-      docs = Psych.parse_stream(expanded_template)
+      docs = Psych.parse_stream(expanded_template, partial_path)
       # If the partial contains multiple documents or has an explicit document header,
       # we know it cannot validly be indented in the parent, so return it immediately.
       return expanded_template unless docs.children.one? && docs.children.first.implicit

data/lib/kubernetes-deploy/resource_cache.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'concurrent/hash'
+
+module KubernetesDeploy
+  class ResourceCache
+    def initialize(namespace, context, logger)
+      @namespace = namespace
+      @context = context
+      @logger = logger
+
+      @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)
+    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})"
+      end
+      instance
+    rescue KubectlError
+      {}
+    end
+
+    def get_all(kind, selector = nil)
+      instances = use_or_populate_cache(kind).values
+      return instances unless selector
+
+      instances.select do |r|
+        labels = r.dig("metadata", "labels") || {}
+        labels >= selector
+      end
+    rescue KubectlError
+      []
+    end
+
+    private
+
+    def statsd_tags
+      { namespace: @namespace, context: @context }
+    end
+
+    def use_or_populate_cache(kind)
+      @kind_fetcher_locks[kind].synchronize do
+        return @data[kind] if @data.key?(kind)
+        @data[kind] = fetch_by_kind(kind)
+      end
+    end
+
+    def fetch_by_kind(kind)
+      raw_json, _, st = @kubectl.run("get", kind, "--chunk-size=0", "--output=json", attempts: 5)
+      raise KubectlError unless st.success?
+
+      instances = {}
+      JSON.parse(raw_json)["items"].each do |resource|
+        resource_name = resource.dig("metadata", "name")
+        instances[resource_name] = resource
+      end
+      instances
+    end
+  end
+end

data/lib/kubernetes-deploy/resource_watcher.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 module KubernetesDeploy
   class ResourceWatcher
-    def initialize(resources:, sync_mediator:, logger:, deploy_started_at: Time.now.utc,
-      operation_name: "deploy", timeout: nil)
+    extend KubernetesDeploy::StatsD::MeasureMethods
+
+    def initialize(resources:, logger:, context:, namespace:,
+      deploy_started_at: Time.now.utc, operation_name: "deploy", timeout: nil, sha: nil)
       unless resources.is_a?(Enumerable)
         raise ArgumentError, <<~MSG
           ResourceWatcher expects Enumerable collection, got `#{resources.class}` instead
@@ -10,10 +12,12 @@ module KubernetesDeploy
       end
       @resources = resources
       @logger = logger
-      @sync_mediator = sync_mediator
+      @namespace = namespace
+      @context = context
       @deploy_started_at = deploy_started_at
       @operation_name = operation_name
       @timeout = timeout
+      @sha = sha
     end
 
     def run(delay_sync: 3.seconds, reminder_interval: 30.seconds, record_summary: true)
@@ -24,8 +28,7 @@ module KubernetesDeploy
         report_and_give_up(remainder) if global_timeout?(monitoring_started)
         sleep_until_next_sync(delay_sync)
 
-        @sync_mediator.sync(remainder)
-        remainder.each(&:after_sync)
+        sync_resources(remainder)
 
         new_successes, remainder = remainder.partition(&:deploy_succeeded?)
         new_failures, remainder = remainder.partition(&:deploy_failed?)
@@ -45,6 +48,21 @@ module KubernetesDeploy
 
     private
 
+    def sync_resources(resources)
+      cache = ResourceCache.new(@namespace, @context, @logger)
+      KubernetesDeploy::Concurrency.split_across_threads(resources) { |r| r.sync(cache) }
+      resources.each(&:after_sync)
+    end
+    measure_method(:sync_resources, "sync.duration")
+
+    def statsd_tags
+      {
+        namespace: @namespace,
+        context: @context,
+        sha: @sha
+      }
+    end
+
     def global_timeout?(started_at)
       @timeout && (Time.now.utc - started_at > @timeout)
     end
@@ -118,9 +136,12 @@ module KubernetesDeploy
             "failed to #{@operation_name} #{failures.length} #{'resource'.pluralize(failures.length)}"
           )
         end
+
+        kubectl = Kubectl.new(namespace: @namespace, context: @context, logger: @logger, log_failure_by_default: false)
         KubernetesDeploy::Concurrency.split_across_threads(failed_resources + global_timeouts) do |r|
-          r.sync_debug_info(@sync_mediator.kubectl)
+          r.sync_debug_info(kubectl)
         end
+
         failed_resources.each { |r| @logger.summary.add_paragraph(r.debug_message) }
         global_timeouts.each { |r| @logger.summary.add_paragraph(r.debug_message(:gave_up, timeout: @timeout)) }
       end

data/lib/kubernetes-deploy/restart_task.rb

@@ -24,7 +24,6 @@ module KubernetesDeploy
       @context = context
       @namespace = namespace
       @logger = logger
-      @sync_mediator = SyncMediator.new(namespace: @namespace, context: @context, logger: @logger)
       @max_watch_seconds = max_watch_seconds
     end
 
@@ -50,22 +49,22 @@ module KubernetesDeploy
 
       @logger.phase_heading("Waiting for rollout")
       resources = build_watchables(deployments, start)
-      ResourceWatcher.new(resources: resources, sync_mediator: @sync_mediator,
-        logger: @logger, operation_name: "restart", timeout: @max_watch_seconds).run
+      ResourceWatcher.new(resources: resources, logger: @logger, operation_name: "restart",
+        timeout: @max_watch_seconds, namespace: @namespace, context: @context).run
       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
-      ::StatsD.distribution('restart.duration', StatsD.duration(start), tags: tags('success', deployments))
+      StatsD.distribution('restart.duration', StatsD.duration(start), tags: tags('success', deployments))
       @logger.print_summary(:success)
     rescue DeploymentTimeoutError
-      ::StatsD.distribution('restart.duration', StatsD.duration(start), tags: tags('timeout', deployments))
+      StatsD.distribution('restart.duration', StatsD.duration(start), tags: tags('timeout', deployments))
       @logger.print_summary(:timed_out)
       raise
     rescue FatalDeploymentError => error
-      ::StatsD.distribution('restart.duration', StatsD.duration(start), tags: tags('failure', deployments))
+      StatsD.distribution('restart.duration', StatsD.duration(start), tags: tags('failure', deployments))
       @logger.summary.add_action(error.message) if error.message != error.class.to_s
       @logger.print_summary(:failure)
       raise

data/lib/kubernetes-deploy/runner_task.rb

@@ -8,7 +8,6 @@ module KubernetesDeploy
   class RunnerTask
     include KubeclientBuilder
 
-    class TaskConfigurationError < FatalDeploymentError; end
     class TaskTemplateMissingError < TaskConfigurationError; end
 
     attr_reader :pod_name
@@ -45,14 +44,14 @@ module KubernetesDeploy
       else
         record_status_once(pod)
       end
-      ::StatsD.distribution('task_runner.duration', StatsD.duration(start), tags: statsd_tags('success'))
+      StatsD.distribution('task_runner.duration', StatsD.duration(start), tags: statsd_tags('success'))
       @logger.print_summary(:success)
     rescue DeploymentTimeoutError
-      ::StatsD.distribution('task_runner.duration', StatsD.duration(start), tags: statsd_tags('timeout'))
+      StatsD.distribution('task_runner.duration', StatsD.duration(start), tags: statsd_tags('timeout'))
       @logger.print_summary(:timed_out)
       raise
     rescue FatalDeploymentError
-      ::StatsD.distribution('task_runner.duration', StatsD.duration(start), tags: statsd_tags('failure'))
+      StatsD.distribution('task_runner.duration', StatsD.duration(start), tags: statsd_tags('failure'))
       @logger.print_summary(:failure)
       raise
     end
@@ -87,14 +86,15 @@ module KubernetesDeploy
 
     def watch_pod(pod)
       rw = ResourceWatcher.new(resources: [pod], logger: @logger, timeout: @max_watch_seconds,
-        sync_mediator: sync_mediator, operation_name: "run")
+        operation_name: "run", namespace: @namespace, context: @context)
       rw.run(delay_sync: 1, reminder_interval: 30.seconds)
       raise DeploymentTimeoutError if pod.deploy_timed_out?
       raise FatalDeploymentError if pod.deploy_failed?
     end
 
     def record_status_once(pod)
-      pod.sync(sync_mediator)
+      cache = ResourceCache.new(@namespace, @context, @logger)
+      pod.sync(cache)
       warning = <<~STRING
         #{ColorizedString.new('Result verification is disabled for this task.').yellow}
         The following status was observed immediately after pod creation:
@@ -197,10 +197,6 @@ module KubernetesDeploy
       @kubectl ||= Kubectl.new(namespace: @namespace, context: @context, logger: @logger, log_failure_by_default: true)
     end
 
-    def sync_mediator
-      @sync_mediator ||= SyncMediator.new(namespace: @namespace, context: @context, logger: @logger)
-    end
-
     def kubeclient
       @kubeclient ||= build_v1_kubeclient(@context)
     end

data/lib/kubernetes-deploy/statsd.rb

@@ -4,23 +4,76 @@ require 'logger'
 
 module KubernetesDeploy
   class StatsD
+    extend ::StatsD
+
+    PREFIX = "KubernetesDeploy"
+
     def self.duration(start_time)
       (Time.now.utc - start_time).round(1)
     end
 
     def self.build
-      ::StatsD.default_sample_rate = 1.0
-      ::StatsD.prefix = "KubernetesDeploy"
-
       if ENV['STATSD_DEV'].present?
-        ::StatsD.backend = ::StatsD::Instrument::Backends::LoggerBackend.new(Logger.new($stderr))
+        self.backend = ::StatsD::Instrument::Backends::LoggerBackend.new(Logger.new($stderr))
       elsif ENV['STATSD_ADDR'].present?
         statsd_impl = ENV['STATSD_IMPLEMENTATION'].present? ? ENV['STATSD_IMPLEMENTATION'] : "datadog"
-        ::StatsD.backend = ::StatsD::Instrument::Backends::UDPBackend.new(ENV['STATSD_ADDR'], statsd_impl)
+        self.backend = ::StatsD::Instrument::Backends::UDPBackend.new(ENV['STATSD_ADDR'], statsd_impl)
       else
-        ::StatsD.backend = ::StatsD::Instrument::Backends::NullBackend.new
+        self.backend = ::StatsD::Instrument::Backends::NullBackend.new
+      end
+    end
+
+    # It is not sufficient to set the prefix field on the KubernetesDeploy::StatsD singleton itself, since its value
+    # is overridden in the underlying calls to the ::StatsD library, hence the need to pass it in as a custom prefix
+    # via the metric_options hash. This is done since KubernetesDeploy may be included as a library and should not
+    # change the global StatsD configuration of the importing application.
+    def self.increment(key, value = 1, **metric_options)
+      metric_options[:prefix] = PREFIX
+      super
+    end
+
+    def self.distribution(key, value = nil, **metric_options, &block)
+      metric_options[:prefix] = PREFIX
+      super
+    end
+
+    module MeasureMethods
+      def measure_method(method_name, metric = nil)
+        unless method_defined?(method_name) || private_method_defined?(method_name)
+          raise NotImplementedError, "Cannot instrument undefined method #{method_name}"
+        end
+
+        unless const_defined?("InstrumentationProxy")
+          const_set("InstrumentationProxy", Module.new)
+          should_prepend = true
+        end
+
+        metric ||= "#{method_name}.duration"
+        self::InstrumentationProxy.send(:define_method, method_name) do |*args, &block|
+          begin
+            start_time = Time.now.utc
+            super(*args, &block)
+          rescue
+            error = true
+            raise
+          ensure
+            dynamic_tags = send(:statsd_tags) if respond_to?(:statsd_tags, true)
+            dynamic_tags ||= {}
+            if error
+              dynamic_tags[:error] = error if dynamic_tags.is_a?(Hash)
+              dynamic_tags << "error:#{error}" if dynamic_tags.is_a?(Array)
+            end
+
+            StatsD.distribution(
+              metric,
+              KubernetesDeploy::StatsD.duration(start_time),
+              tags: dynamic_tags
+            )
+          end
+        end
+
+        prepend(self::InstrumentationProxy) if should_prepend
       end
-      ::StatsD.backend
     end
   end
 end