kubernetes-deploy 0.12.2 → 0.12.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 191575b8707a76646afc97a5857e41aeedfe841a
-  data.tar.gz: 0fc63d6a819b3aa446e5c9c000837c6207fe3ec8
+  metadata.gz: d72e1288dc4248dfcb5a1843a63946c8b9e89c1d
+  data.tar.gz: cd7f50c0d7fc5524ce8c9b83113af0e1d8abb01b
 SHA512:
-  metadata.gz: 9c6d55d9154882ca8299ad288bea2f28913901b334ca22313e24a133d3d3900ecb2fa3a1690cc053f30608e5118b400099d610245a3791c20ba1c98331f7e644
-  data.tar.gz: de1465e7bedd7aba0fadcb80e019bd5a2e6d0547e1d9cc452fe4f02815d886931fb3f19fc349a8b56a25040341c22401b1ed6f107d0d34b7e793e0c0e24a2365
+  metadata.gz: 8d399ff5fd70beddf51c041ba7f39ba586501c7e9a0728e7fb820523d70b1ebb957cf5df14d3abeba78b197ed1fdcdbf3dfbbf7b489b6164be5725a32237c0ba
+  data.tar.gz: 381a1e2bc1828589974638e1facfb3090f31fc6d3e4be024fb3c85072e3ba6cf2108f72cc26071e6668f6b0952407d64eaf41bddeb2e1e668ffc9a83687ce09f

data/kubernetes-deploy.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.3.0'
   spec.add_dependency "activesupport", ">= 4.2"
-  spec.add_dependency "kubeclient", "~> 2.3"
+  spec.add_dependency "kubeclient", "~> 2.4"
   spec.add_dependency "googleauth", ">= 0.5"
   spec.add_dependency "ejson", "1.0.1"
   spec.add_dependency "colorize", "~> 0.8"

data/lib/kubernetes-deploy/errors.rb

@@ -5,7 +5,7 @@ module KubernetesDeploy
 
   class NamespaceNotFoundError < FatalDeploymentError
     def initialize(name, context)
-      super("Namespace `#{name}` not found in context `#{context}`. Aborting the task.")
+      super("Namespace `#{name}` not found in context `#{context}`")
     end
   end
 end

data/lib/kubernetes-deploy/kubeclient_builder.rb

@@ -6,8 +6,7 @@ module KubernetesDeploy
   module KubeclientBuilder
     class ContextMissingError < FatalDeploymentError
       def initialize(context_name)
-        super("`#{context_name}` context must be configured in your KUBECONFIG (#{ENV['KUBECONFIG']}). " \
-          "Please see the README.")
+        super("`#{context_name}` context must be configured in your KUBECONFIG (#{ENV['KUBECONFIG']}).")
       end
     end
 

data/lib/kubernetes-deploy/resource_watcher.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module KubernetesDeploy
   class ResourceWatcher
-    def initialize(resources, logger:, deploy_started_at: Time.now.utc)
+    def initialize(resources, logger:, deploy_started_at: Time.now.utc, operation_name: "deploy")
       unless resources.is_a?(Enumerable)
         raise ArgumentError, <<~MSG
           ResourceWatcher expects Enumerable collection, got `#{resources.class}` instead
@@ -10,30 +10,33 @@ module KubernetesDeploy
       @resources = resources
       @logger = logger
       @deploy_started_at = deploy_started_at
+      @operation_name = operation_name
     end
 
-    def run(delay_sync: 3.seconds, reminder_interval: 30.seconds)
+    def run(delay_sync: 3.seconds, reminder_interval: 30.seconds, record_summary: true)
       delay_sync_until = last_message_logged_at = Time.now.utc
+      remainder = @resources.dup
 
-      while @resources.present?
+      while remainder.present?
         if Time.now.utc < delay_sync_until
           sleep(delay_sync_until - Time.now.utc)
         end
         delay_sync_until = Time.now.utc + delay_sync # don't pummel the API if the sync is fast
 
-        KubernetesDeploy::Concurrency.split_across_threads(@resources, &:sync)
-        newly_finished_resources, @resources = @resources.partition(&:deploy_finished?)
+        KubernetesDeploy::Concurrency.split_across_threads(remainder, &:sync)
+        newly_finished_resources, remainder = remainder.partition(&:deploy_finished?)
 
         if newly_finished_resources.present?
           watch_time = (Time.now.utc - @deploy_started_at).round(1)
           report_what_just_happened(newly_finished_resources, watch_time)
-          report_what_is_left(reminder: false)
+          report_what_is_left(remainder, reminder: false)
           last_message_logged_at = Time.now.utc
         elsif due_for_reminder?(last_message_logged_at, reminder_interval)
-          report_what_is_left(reminder: true)
+          report_what_is_left(remainder, reminder: true)
           last_message_logged_at = Time.now.utc
         end
       end
+      record_statuses_for_summary(@resources) if record_summary
     end
 
     private
@@ -44,25 +47,43 @@ module KubernetesDeploy
       new_successes, new_failures = resources.partition(&:deploy_succeeded?)
       new_failures.each do |resource|
         if resource.deploy_failed?
-          @logger.error("#{resource.id} failed to deploy after #{watch_time}s")
+          @logger.error("#{resource.id} failed to #{@operation_name} after #{watch_time}s")
         else
-          @logger.error("#{resource.id} deployment timed out")
+          @logger.error("#{resource.id} rollout timed out")
         end
       end
 
       if new_successes.present?
-        success_string = ColorizedString.new("Successfully deployed in #{watch_time}s:").green
+        success_string = ColorizedString.new("Successfully #{@operation_name}ed in #{watch_time}s:").green
         @logger.info("#{success_string} #{new_successes.map(&:id).join(', ')}")
       end
     end
 
-    def report_what_is_left(reminder:)
-      return unless @resources.present?
-      resource_list = @resources.map(&:id).join(', ')
+    def report_what_is_left(resources, reminder:)
+      return unless resources.present?
+      resource_list = resources.map(&:id).join(', ')
       msg = reminder ? "Still waiting for: #{resource_list}" : "Continuing to wait for: #{resource_list}"
       @logger.info(msg)
     end
 
+    def record_statuses_for_summary(resources)
+      successful_resources, failed_resources = resources.partition(&:deploy_succeeded?)
+      fail_count = failed_resources.length
+      success_count = successful_resources.length
+
+      if success_count > 0
+        @logger.summary.add_action("successfully #{@operation_name}ed #{success_count} "\
+          "#{'resource'.pluralize(success_count)}")
+        final_statuses = successful_resources.map(&:pretty_status).join("\n")
+        @logger.summary.add_paragraph("#{ColorizedString.new('Successful resources').green}\n#{final_statuses}")
+      end
+
+      if fail_count > 0
+        @logger.summary.add_action("failed to #{@operation_name} #{fail_count} #{'resource'.pluralize(fail_count)}")
+        failed_resources.each { |r| @logger.summary.add_paragraph(r.debug_message) }
+      end
+    end
+
     def due_for_reminder?(last_message_logged_at, reminder_interval)
       (last_message_logged_at.to_f + reminder_interval.to_f) <= Time.now.utc.to_f
     end

data/lib/kubernetes-deploy/restart_task.rb

@@ -6,13 +6,9 @@ module KubernetesDeploy
   class RestartTask
     include KubernetesDeploy::KubeclientBuilder
 
-    class DeploymentNotFoundError < FatalDeploymentError
-      def initialize(name, namespace)
-        super("Deployment `#{name}` not found in namespace `#{namespace}`. Aborting the task.")
-      end
-    end
+    class FatalRestartError < FatalDeploymentError; end
 
-    class RestartError < FatalDeploymentError
+    class RestartAPIError < FatalRestartError
       def initialize(deployment_name, response)
         super("Failed to restart #{deployment_name}. " \
             "API returned non-200 response code (#{response.code})\n" \
@@ -27,58 +23,71 @@ module KubernetesDeploy
       @context = context
       @namespace = namespace
       @logger = logger
-      @kubeclient = build_v1_kubeclient(context)
-      @v1beta1_kubeclient = build_v1beta1_kubeclient(context)
-      @policy_v1beta1_kubeclient = build_policy_v1beta1_kubeclient(context)
     end
 
     def perform(deployments_names = nil)
+      start = Time.now.utc
       @logger.reset
+
+      @logger.phase_heading("Initializing restart")
       verify_namespace
+      deployments = identify_target_deployments(deployments_names)
+
+      @logger.phase_heading("Triggering restart by touching ENV[RESTARTED_AT]")
+      patch_kubeclient_deployments(deployments)
+
+      @logger.phase_heading("Waiting for rollout")
+      resources = build_watchables(deployments, start)
+      ResourceWatcher.new(resources, logger: @logger, operation_name: "restart").run
+      success = resources.all?(&:deploy_succeeded?)
+    rescue FatalDeploymentError => error
+      @logger.summary.add_action(error.message)
+      success = false
+    ensure
+      @logger.print_summary(success)
+      status = success ? "success" : "failed"
+      tags = %W(namespace:#{@namespace} context:#{@context} status:#{status} deployments:#{deployments.to_a.length}})
+      ::StatsD.measure('restart.duration', StatsD.duration(start), tags: tags)
+    end
 
-      if deployments_names
-        deployments = fetch_deployments(deployments_names.uniq)
+    private
+
+    def identify_target_deployments(deployment_names)
+      if deployment_names.nil?
+        @logger.info("Configured to restart all deployments with the `#{ANNOTATION}` annotation")
+        deployments = v1beta1_kubeclient.get_deployments(namespace: @namespace)
+          .select { |d| d.metadata.annotations[ANNOTATION] }
 
         if deployments.none?
-          raise ArgumentError, "no deployments with names #{deployments_names} found in namespace #{@namespace}"
+          raise FatalRestartError, "no deployments with the `#{ANNOTATION}` annotation found in namespace #{@namespace}"
         end
+      elsif deployment_names.empty?
+        raise FatalRestartError, "Configured to restart deployments by name, but list of names was blank"
       else
-        deployments = @v1beta1_kubeclient
-          .get_deployments(namespace: @namespace)
-          .select { |d| d.metadata.annotations[ANNOTATION] }
+        deployment_names = deployment_names.uniq
+        list = deployment_names.join(', ')
+        @logger.info("Configured to restart deployments by name: #{list}")
 
+        deployments = fetch_deployments(deployment_names)
         if deployments.none?
-          raise ArgumentError, "no deployments found in namespace #{@namespace} with #{ANNOTATION} annotation available"
+          raise FatalRestartError, "no deployments with names #{list} found in namespace #{@namespace}"
         end
       end
-
-      @logger.phase_heading("Triggering restart by touching ENV[RESTARTED_AT]")
-      patch_kubeclient_deployments(deployments)
-
-      @logger.phase_heading("Waiting for rollout")
-      wait_for_rollout(deployments)
-
-      names = deployments.map { |d| "`#{d.metadata.name}`" }
-      @logger.info "Restart of #{names.sort.join(', ')} deployments succeeded"
-      true
-    rescue FatalDeploymentError => error
-      @logger.fatal "#{error.class}: #{error.message}"
-      false
+      deployments
     end
 
-    private
-
-    def wait_for_rollout(kubeclient_resources)
-      resources = kubeclient_resources.map do |d|
+    def build_watchables(kubeclient_resources, started)
+      kubeclient_resources.map do |d|
         definition = d.to_h.deep_stringify_keys
-        Deployment.new(namespace: @namespace, context: @context, definition: definition, logger: @logger)
+        r = Deployment.new(namespace: @namespace, context: @context, definition: definition, logger: @logger)
+        r.deploy_started = started # we don't care what happened to the resource before the restart cmd ran
+        r
       end
-      watcher = ResourceWatcher.new(resources, logger: @logger)
-      watcher.run
     end
 
     def verify_namespace
-      @kubeclient.get_namespace(@namespace)
+      kubeclient.get_namespace(@namespace)
+      @logger.info("Namespace #{@namespace} found in context #{@context}")
     rescue KubeException => error
       if error.error_code == 404
         raise NamespaceNotFoundError.new(@namespace, @context)
@@ -88,7 +97,7 @@ module KubernetesDeploy
     end
 
     def patch_deployment_with_restart(record)
-      @v1beta1_kubeclient.patch_deployment(
+      v1beta1_kubeclient.patch_deployment(
         record.metadata.name,
         build_patch_payload(record),
         @namespace
@@ -101,7 +110,7 @@ module KubernetesDeploy
         if HTTP_OK_RANGE.cover?(response.code)
           @logger.info "Triggered `#{record.metadata.name}` restart"
         else
-          raise RestartError.new(record.metadata.name, response)
+          raise RestartAPIError.new(record.metadata.name, response)
         end
       end
     end
@@ -110,10 +119,10 @@ module KubernetesDeploy
       list.map do |name|
         record = nil
         begin
-          record = @v1beta1_kubeclient.get_deployment(name, @namespace)
+          record = v1beta1_kubeclient.get_deployment(name, @namespace)
         rescue KubeException => error
           if error.error_code == 404
-            raise DeploymentNotFoundError.new(name, @namespace)
+            raise FatalRestartError, "Deployment `#{name}` not found in namespace `#{@namespace}`"
           else
             raise
           end
@@ -139,5 +148,13 @@ module KubernetesDeploy
         }
       }
     end
+
+    def kubeclient
+      @kubeclient ||= build_v1_kubeclient(@context)
+    end
+
+    def v1beta1_kubeclient
+      @v1beta1_kubeclient ||= build_v1beta1_kubeclient(@context)
+    end
   end
 end

data/lib/kubernetes-deploy/runner.rb

@@ -109,7 +109,7 @@ module KubernetesDeploy
         @logger.phase_heading("Predeploying priority resources")
         start_priority_resource = Time.now.utc
         predeploy_priority_resources(resources)
-        ::StatsD.measure('priority_resources.duration', statsd_duration(start_priority_resource), tags: statsd_tags)
+        ::StatsD.measure('priority_resources.duration', StatsD.duration(start_priority_resource), tags: statsd_tags)
       end
 
       @logger.phase_heading("Deploying all resources")
@@ -120,8 +120,7 @@ module KubernetesDeploy
       if verify_result
         start_normal_resource = Time.now.utc
         deploy_resources(resources, prune: prune, verify: true)
-        ::StatsD.measure('normal_resources.duration', statsd_duration(start_normal_resource), tags: statsd_tags)
-        record_statuses(resources)
+        ::StatsD.measure('normal_resources.duration', StatsD.duration(start_normal_resource), tags: statsd_tags)
         success = resources.all?(&:deploy_succeeded?)
       else
         deploy_resources(resources, prune: prune, verify: false)
@@ -139,7 +138,7 @@ module KubernetesDeploy
     ensure
       @logger.print_summary(success)
       status = success ? "success" : "failed"
-      ::StatsD.measure('all_resources.duration', statsd_duration(start), tags: statsd_tags << "status:#{status}")
+      ::StatsD.measure('all_resources.duration', StatsD.duration(start), tags: statsd_tags << "status:#{status}")
       success
     end
 
@@ -152,23 +151,6 @@ module KubernetesDeploy
 
     private
 
-    def record_statuses(resources)
-      successful_resources, failed_resources = resources.partition(&:deploy_succeeded?)
-      fail_count = failed_resources.length
-      success_count = successful_resources.length
-
-      if success_count > 0
-        @logger.summary.add_action("successfully deployed #{success_count} #{'resource'.pluralize(success_count)}")
-        final_statuses = successful_resources.map(&:pretty_status).join("\n")
-        @logger.summary.add_paragraph("#{ColorizedString.new('Successful resources').green}\n#{final_statuses}")
-      end
-
-      if fail_count > 0
-        @logger.summary.add_action("failed to deploy #{fail_count} #{'resource'.pluralize(fail_count)}")
-        failed_resources.each { |r| @logger.summary.add_paragraph(r.debug_message) }
-      end
-    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(stderr)
@@ -186,7 +168,7 @@ module KubernetesDeploy
       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)
+        deploy_resources(matching_resources, verify: true, record_summary: false)
 
         failed_resources = matching_resources.reject(&:deploy_succeeded?)
         fail_count = failed_resources.length
@@ -264,11 +246,6 @@ module KubernetesDeploy
       "    " + str.gsub("\n", "\n    ")
     end
 
-    def wait_for_completion(watched_resources, started_at)
-      watcher = ResourceWatcher.new(watched_resources, logger: @logger, deploy_started_at: started_at)
-      watcher.run
-    end
-
     def render_template(filename, raw_template)
       return raw_template unless File.extname(filename) == ".erb"
 
@@ -326,7 +303,7 @@ module KubernetesDeploy
       @logger.info("All required parameters and files are present")
     end
 
-    def deploy_resources(resources, prune: false, verify:)
+    def deploy_resources(resources, prune: false, verify:, record_summary: true)
       return if resources.empty?
       deploy_started_at = Time.now.utc
 
@@ -365,7 +342,11 @@ module KubernetesDeploy
       end
 
       apply_all(applyables, prune)
-      wait_for_completion(resources, deploy_started_at) if verify
+
+      if verify
+        watcher = ResourceWatcher.new(resources, logger: @logger, deploy_started_at: deploy_started_at)
+        watcher.run(record_summary: record_summary)
+      end
     end
 
     def apply_all(resources, prune)
@@ -429,9 +410,5 @@ module KubernetesDeploy
     def statsd_tags
       %W(namespace:#{@namespace} sha:#{@current_sha} context:#{@context})
     end
-
-    def statsd_duration(start_time)
-      (Time.now.utc - start_time).round(1)
-    end
   end
 end

data/lib/kubernetes-deploy/statsd.rb

@@ -4,6 +4,10 @@ require 'logger'
 
 module KubernetesDeploy
   class StatsD
+    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"

data/lib/kubernetes-deploy/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module KubernetesDeploy
-  VERSION = "0.12.2"
+  VERSION = "0.12.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kubernetes-deploy
 version: !ruby/object:Gem::Version
-  version: 0.12.2
+  version: 0.12.3
 platform: ruby
 authors:
 - Katrina Verey
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-14 00:00:00.000000000 Z
+date: 2017-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -31,14 +31,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.4'
 - !ruby/object:Gem::Dependency
   name: googleauth
   requirement: !ruby/object:Gem::Requirement