krane 2.1.8 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f0acd44dff6399afd220b377ae825e964d07da8a0574525ff7b3f966857bf80
-  data.tar.gz: 31c0f004b0f4f5db39e73b5fbde06b54bfce2bfbf393676f44b036397e303515
+  metadata.gz: 676fdc875449178de6e0f4ff1f649271bd691637e4e56d540c5e5ea71dc8ded4
+  data.tar.gz: 6a16a1e9e32947b0bd6aff7f679ca7f4958a4ef4d3c27e8855fc2a7a6e39abfa
 SHA512:
-  metadata.gz: 240a8713adc34a340ff3d127828c3a1a740d3543656b6b0c730a26db295b7b6f9c306d9fa53cf10ad425a00116d99895b2feec207aae94a1f3b3b5b571bef006
-  data.tar.gz: dd13e23ab5b37b152665ce4bd29a10cb77a30115938df6a50ef394b3bccf84ea51fcf12ba7590bd899c071fb083df70eeb94095b1a72086932a9e0122db1cdb3
+  metadata.gz: 20aad308cbb7c96ad518d0bb57026d6b95e6e8ced1f9eb968c2d144906920a45da272fdf20c94fd8d455a6265b266b6d10912573839e48b08c8162c382905774
+  data.tar.gz: 31711f6a966d5364d6e084eb67b8bdcff4e511e40967cc9fb0528a9e8dd1739ed3f59363ab1dd2ba122d40331019eaf2a9ef850830d6c92ddcdfc5a291bd5e89

data/.rubocop.yml

@@ -1,5 +1,8 @@
-inherit_from:
-  - http://shopify.github.io/ruby-style-guide/rubocop.yml
+inherit_gem:
+  rubocop-shopify: rubocop.yml
+
+Style/DateTime:
+  Enabled: false
 
 AllCops:
   TargetRubyVersion: 2.4

data/.shopify-build/krane.yml

@@ -8,6 +8,14 @@ steps:
     run:
       - bundle: ~
       - bundle exec rubocop
+  - label: 'Run Test Suite (:kubernetes: 1.21-latest :ruby: 3.0)'
+    command: bin/ci
+    agents:
+      queue: k8s-ci
+    env:
+      LOGGING_LEVEL: "4"
+      KUBERNETES_VERSION: v1.21-latest
+      RUBY_VERSION: "3.0"
   - label: 'Run Test Suite (:kubernetes: 1.20-latest :ruby: 3.0)'
     command: bin/ci
     agents:
@@ -38,17 +46,3 @@ steps:
     env:
       LOGGING_LEVEL: "4"
       KUBERNETES_VERSION: v1.17-latest
-  - label: 'Run Test Suite (:kubernetes: 1.16-latest)'
-    command: bin/ci
-    agents:
-      queue: k8s-ci
-    env:
-      LOGGING_LEVEL: "4"
-      KUBERNETES_VERSION: v1.16-latest
-  - label: 'Run Test Suite (:kubernetes: 1.15-latest)'
-    command: bin/ci
-    agents:
-      queue: k8s-ci
-    env:
-      LOGGING_LEVEL: "4"
-      KUBERNETES_VERSION: v1.15-latest

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 ## next
 
+## 2.3.0
+
+- Restart tasks now support restarting StatefulSets and DaemonSets, in addition to Deployments [#836](https://github.com/Shopify/krane/pull/836)
+
+## 2.2.0
+
+*Enhancements*
+
+- Add a new option `--selector-as-filter` to command `krane deploy` and `krane global-deploy` [#831](https://github.com/Shopify/krane/pull/831)
+
+## 2.1.10
+
+*Bug Fixes*
+
+- Don't gather prunable resources by calling uniq only on `kind`: use `group` as well. Otherwise certain resources may not be added to the prune whitelist if the same kind exists across multiple groups [#825](https://github.com/Shopify/krane/pull/825)
+- Fix resource discovery failures when API paths are not located at the root of the API server (this occurs, for example, when using Rancher proxy) [#827](https://github.com/Shopify/krane/pull/827)
+
+*Other*
+
+- Fix ERB deprecation of positional arguments [#828](https://github.com/Shopify/krane/pull/828)
+
+## 2.1.9
+
+*Other*
+
+- Don't package screenshots in the built gem to reduce size [#817](https://github.com/Shopify/krane/pull/817)
+
 ## 2.1.8
 
 *Other*

data/README.md

@@ -117,6 +117,7 @@ Refer to `krane help` for the authoritative set of options.
 - `--global-timeout=duration`: Raise a timeout error if it takes longer than _duration_ for any
 resource to deploy.
 - `--selector`: Instructs krane to only prune resources which match the specified label selector, such as `environment=staging`. If you use this option, all resource templates must specify matching labels. See [Sharing a namespace](#sharing-a-namespace) below.
+- `--selector-as-filter`: Instructs krane to only deploy resources that are filtered by the specified labels in `--selector`. The deploy will not fail if not all resources match the labels. This is useful if you only want to deploy a subset of resources within a given YAML file. See [Sharing a namespace](#sharing-a-namespace) below.
 - `--no-verify-result`: Skip verification that workloads correctly deployed.
 - `--protected-namespaces=default kube-system kube-public`: Fail validation if a deploy is targeted at a protected namespace.
 - `--verbose-log-prefix`: Add [context][namespace] to the log prefix
@@ -132,6 +133,8 @@ If you need to, you may specify `--no-prune` to disable all pruning behaviour, b
 
 If you need to share a namespace with resources which are managed by other tools or indeed other krane deployments, you can supply the `--selector` option, such that only resources with labels matching the selector are considered for pruning.
 
+If you need to share a namespace with different set of resources using the same YAML file, you can supply the `--selector` and `--selector-as-filter` options, such that only the resources that match with the labels will be deployed. In each run of deploy, you can use different labels in `--selector` to deploy a different set of resources. Only the deployed resources in each run are considered for pruning.
+
 ### Using templates
 
 All templates must be YAML formatted.
@@ -441,13 +444,14 @@ Refer to `krane global-deploy help` for the authoritative set of options.
 - `--filenames / -f [PATHS]`: Accepts a list of directories and/or filenames to specify the set of directories/files that will be deployed. Use `-` to specify STDIN.
 - `--no-prune`: Skips pruning of resources that are no longer in your Kubernetes template set. Not recommended, as it allows your namespace to accumulate cruft that is not reflected in your deploy directory.
 - `--selector`: Instructs krane to only prune resources which match the specified label selector, such as `environment=staging`. By using this option, all resource templates must specify matching labels. See [Sharing a namespace](#sharing-a-namespace) below.
+- `--selector-as-filter`: Instructs krane to only deploy resources that are filtered by the specified labels in `--selector`. The deploy will not fail if not all resources match the labels. This is useful if you only want to deploy a subset of resources within a given YAML file. See [Sharing a namespace](#sharing-a-namespace) below.
 - `--global-timeout=duration`: Raise a timeout error if it takes longer than _duration_ for any
 resource to deploy.
 - `--no-verify-result`: Skip verification that resources correctly deployed.
 
 # krane restart
 
-`krane restart` is a tool for restarting all of the pods in one or more deployments. It triggers the restart by touching the `RESTARTED_AT` environment variable in the deployment's podSpec. The rollout strategy defined for each deployment will be respected by the restart.
+`krane restart` is a tool for restarting all of the pods in one or more deployments, statefuls sets, and/or daemon sets. It triggers the restart by patching template metadata with the `kubectl.kubernetes.io/restartedAt` annotation (with the value being an RFC 3339 representation of the current time). Note this is the manner in which `kubectl rollout restart` itself triggers restarts.
 
 ## Usage
 

data/dev.yml

@@ -4,7 +4,7 @@ up:
   - ruby: 2.6.6 # Matches gemspec
   - bundler
   - homebrew:
-    - homebrew/cask/minikube
+    - minikube
     - hyperkit
   - custom:
       name: Install the minikube fork of driver-hyperkit
@@ -13,7 +13,7 @@ up:
   - custom:
       name: Minikube Cluster
       met?: test $(minikube status | grep Running | wc -l) -ge 2 && $(minikube status | grep -q 'Configured')
-      meet: minikube start --kubernetes-version=v1.15.12 --vm-driver=hyperkit
+      meet: minikube start --kubernetes-version=v1.18.18 --vm-driver=hyperkit
       down: minikube stop
 commands:
   reset-minikube: minikube delete && rm -rf ~/.minikube

data/krane.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.license       = "MIT"
 
   spec.files         = %x(git ls-files -z).split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
+    f.match(%r{^(test|spec|features|screenshots)/})
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
@@ -57,5 +57,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency("ruby-prof")
   spec.add_development_dependency("ruby-prof-flamegraph")
   spec.add_development_dependency("rubocop", "~> 0.89.1")
+  spec.add_development_dependency("rubocop-shopify", "~> 1.0.5")
   spec.add_development_dependency("simplecov")
 end

data/lib/krane/cli/deploy_command.rb

@@ -25,6 +25,10 @@ module Krane
                      default: true },
         "selector" => { type: :string, banner: "'label=value'",
                         desc: "Select workloads by selector(s)" },
+        "selector-as-filter" => { type: :boolean,
+                                  desc: "Use --selector as a label filter to deploy only a subset "\
+                                    "of the provided resources",
+                                  default: false },
         "verbose-log-prefix" => { type: :boolean, desc: "Add [context][namespace] to the log prefix",
                                   default: false },
         "verify-result" => { type: :boolean, default: true,
@@ -37,6 +41,11 @@ module Krane
         require 'krane/label_selector'
 
         selector = ::Krane::LabelSelector.parse(options[:selector]) if options[:selector]
+        selector_as_filter = options['selector-as-filter']
+
+        if selector_as_filter && !selector
+          raise(Thor::RequiredArgumentMissingError, '--selector must be set when --selector-as-filter is set')
+        end
 
         logger = ::Krane::FormattedLogger.build(namespace, context,
           verbose_prefix: options['verbose-log-prefix'])
@@ -60,6 +69,7 @@ module Krane
             logger: logger,
             global_timeout: ::Krane::DurationParser.new(options["global-timeout"]).parse!.to_i,
             selector: selector,
+            selector_as_filter: selector_as_filter,
             protected_namespaces: protected_namespaces,
           )
 

data/lib/krane/cli/global_deploy_command.rb

@@ -16,6 +16,10 @@ module Krane
                              desc: "Verify workloads correctly deployed" },
         "selector" => { type: :string, banner: "'label=value'", required: true,
                         desc: "Select workloads owned by selector(s)" },
+        "selector-as-filter" => { type: :boolean,
+                                  desc: "Use --selector as a label filter to deploy only a subset "\
+                                    "of the provided resources",
+                                  default: false },
         "prune" => { type: :boolean, desc: "Enable deletion of resources that match"\
                      " the provided selector and do not appear in the provided templates",
                      default: true },
@@ -28,6 +32,11 @@ module Krane
         require 'krane/duration_parser'
 
         selector = ::Krane::LabelSelector.parse(options[:selector])
+        selector_as_filter = options['selector-as-filter']
+
+        if selector_as_filter && !selector
+          raise(Thor::RequiredArgumentMissingError, '--selector must be set when --selector-as-filter is set')
+        end
 
         filenames = options[:filenames].dup
         filenames << "-" if options[:stdin]
@@ -41,6 +50,7 @@ module Krane
             filenames: paths,
             global_timeout: ::Krane::DurationParser.new(options["global-timeout"]).parse!.to_i,
             selector: selector,
+            selector_as_filter: selector_as_filter,
           )
 
           deploy.run!(

data/lib/krane/cli/restart_command.rb

@@ -6,7 +6,11 @@ module Krane
       DEFAULT_RESTART_TIMEOUT = '300s'
       OPTIONS = {
         "deployments" => { type: :array, banner: "list of deployments",
-                           desc: "List of workload names to restart" },
+                           desc: "List of deployment names to restart", default: [] },
+        "statefulsets" => { type: :array, banner: "list of statefulsets",
+                            desc: "List of statefulset names to restart", default: [] },
+        "daemonsets" => { type: :array, banner: "list of daemonsets",
+                          desc: "List of daemonset names to restart", default: [] },
         "global-timeout" => { type: :string, banner: "duration", default: DEFAULT_RESTART_TIMEOUT,
                               desc: "Max duration to monitor workloads correctly restarted" },
         "selector" => { type: :string, banner: "'label=value'",
@@ -25,6 +29,8 @@ module Krane
         )
         restart.run!(
           deployments: options[:deployments],
+          statefulsets: options[:statefulsets],
+          daemonsets: options[:daemonsets],
           selector: selector,
           verify_result: options["verify-result"]
         )

data/lib/krane/cluster_resource_discovery.rb

@@ -34,7 +34,7 @@ module Krane
       end
       responses.flat_map do |path, resources|
         resources.map { |r| resource_hash(path, namespaced, r) }
-      end.compact.uniq { |r| r["kind"] }
+      end.compact.uniq { |r| "#{r['apigroup']}/#{r['kind']}" }
     end
 
     def fetch_mutating_webhook_configurations
@@ -52,9 +52,20 @@ module Krane
 
     private
 
+    # During discovery, the api paths may not actually be at the root, so we must programatically find it.
+    def base_api_path
+      @base_api_path ||= begin
+        raw_response, err, st = kubectl.run("config", "view", "--minify", "--output",
+          "jsonpath={.clusters[*].cluster.server}", attempts: 5, use_namespace: false)
+        raise FatalKubeAPIError, "Error retrieving cluster url: #{err}" unless st.success?
+
+        URI(raw_response).path.blank? ? "/" : URI(raw_response).path
+      end
+    end
+
     def api_paths
       @api_path_cache["/"] ||= begin
-        raw_json, err, st = kubectl.run("get", "--raw", "/", attempts: 5, use_namespace: false)
+        raw_json, err, st = kubectl.run("get", "--raw", base_api_path, attempts: 5, use_namespace: false)
         paths = if st.success?
           JSON.parse(raw_json)["paths"]
         else

data/lib/krane/deploy_task.rb

@@ -100,12 +100,13 @@ module Krane
     # @param bindings [Hash] Bindings parsed by Krane::BindingsParser
     # @param global_timeout [Integer] Timeout in seconds
     # @param selector [Hash] Selector(s) parsed by Krane::LabelSelector
+    # @param selector_as_filter [Boolean] Allow selecting a subset of Kubernetes resource templates to deploy
     # @param filenames [Array<String>] An array of filenames and/or directories containing templates (*required*)
     # @param protected_namespaces [Array<String>] Array of protected Kubernetes namespaces (defaults
     #   to Krane::DeployTask::PROTECTED_NAMESPACES)
     # @param render_erb [Boolean] Enable ERB rendering
     def initialize(namespace:, context:, current_sha: nil, logger: nil, kubectl_instance: nil, bindings: {},
-      global_timeout: nil, selector: nil, filenames: [], protected_namespaces: nil,
+      global_timeout: nil, selector: nil, selector_as_filter: false, filenames: [], protected_namespaces: nil,
       render_erb: false, kubeconfig: nil)
       @logger = logger || Krane::FormattedLogger.build(namespace, context)
       @template_sets = TemplateSets.from_dirs_and_files(paths: filenames, logger: @logger, render_erb: render_erb)
@@ -118,6 +119,7 @@ module Krane
       @kubectl = kubectl_instance
       @global_timeout = global_timeout
       @selector = selector
+      @selector_as_filter = selector_as_filter
       @protected_namespaces = protected_namespaces || PROTECTED_NAMESPACES
       @render_erb = render_erb
     end
@@ -273,6 +275,7 @@ module Krane
 
       confirm_ejson_keys_not_prunable if prune
       @logger.info("Using resource selector #{@selector}") if @selector
+      @logger.info("Only deploying resources filtered by labels in selector") if @selector && @selector_as_filter
       @namespace_tags |= tags_from_namespace_labels
       @logger.info("All required parameters and files are present")
     end
@@ -295,6 +298,7 @@ module Krane
       batchable_resources, individuals = partition_dry_run_resources(resources.dup)
       batch_dry_run_success = kubectl.server_dry_run_enabled? && validate_dry_run(batchable_resources)
       individuals += batchable_resources unless batch_dry_run_success
+      resources.select! { |r| r.selected?(@selector) } if @selector_as_filter
       Krane::Concurrency.split_across_threads(resources) do |r|
         r.validate_definition(kubectl: kubectl, selector: @selector, dry_run: individuals.include?(r))
       end

data/lib/krane/global_deploy_task.rb

@@ -33,8 +33,10 @@ module Krane
     # @param context [String] Kubernetes context (*required*)
     # @param global_timeout [Integer] Timeout in seconds
     # @param selector [Hash] Selector(s) parsed by Krane::LabelSelector (*required*)
+    # @param selector_as_filter [Boolean] Allow selecting a subset of Kubernetes resource templates to deploy
     # @param filenames [Array<String>] An array of filenames and/or directories containing templates (*required*)
-    def initialize(context:, global_timeout: nil, selector: nil, filenames: [], logger: nil, kubeconfig: nil)
+    def initialize(context:, global_timeout: nil, selector: nil, selector_as_filter: false,
+      filenames: [], logger: nil, kubeconfig: nil)
       template_paths = filenames.map { |path| File.expand_path(path) }
 
       @task_config = TaskConfig.new(context, nil, logger, kubeconfig)
@@ -42,6 +44,7 @@ module Krane
         logger: @task_config.logger, render_erb: false)
       @global_timeout = global_timeout
       @selector = selector
+      @selector_as_filter = selector_as_filter
     end
 
     # Runs the task, returning a boolean representing success or failure
@@ -130,6 +133,7 @@ module Krane
     def validate_resources(resources)
       validate_globals(resources)
 
+      resources.select! { |r| r.selected?(@selector) } if @selector_as_filter
       Concurrency.split_across_threads(resources) do |r|
         r.validate_definition(kubectl: @kubectl, selector: @selector)
       end

data/lib/krane/kubernetes_resource.rb

@@ -499,6 +499,10 @@ module Krane
       @global || self.class::GLOBAL
     end
 
+    def selected?(selector)
+      selector.nil? || selector.to_h <= labels
+    end
+
     private
 
     def validate_timeout_annotation

data/lib/krane/renderer.rb

@@ -39,7 +39,7 @@ module Krane
       erb_binding = TemplateContext.new(self).template_binding
       bind_template_variables(erb_binding, template_variables)
 
-      ERB.new(raw_template, nil, '-').result(erb_binding)
+      ERB.new(raw_template, trim_mode: '-').result(erb_binding)
     rescue InvalidPartialError => err
       err.parents = err.parents.dup.unshift(filename)
       err.filename = "#{err.filename} (partial included from: #{err.parents.join(' -> ')})"
@@ -56,7 +56,7 @@ module Krane
 
       partial_path = find_partial(partial)
       template = File.read(partial_path)
-      expanded_template = ERB.new(template, nil, '-').result(erb_binding)
+      expanded_template = ERB.new(template, trim_mode: '-').result(erb_binding)
 
       docs = Psych.parse_stream(expanded_template, partial_path)
       # If the partial contains multiple documents or has an explicit document header,

data/lib/krane/restart_task.rb

@@ -22,6 +22,8 @@ module Krane
     HTTP_OK_RANGE = 200..299
     ANNOTATION = "shipit.shopify.io/restart"
 
+    RESTART_TRIGGER_ANNOTATION = "kubectl.kubernetes.io/restartedAt"
+
     attr_reader :task_config
 
     delegate :kubeclient_builder, to: :task_config
@@ -58,33 +60,41 @@ module Krane
     # @param verify_result [Boolean] Wait for completion and verify success
     #
     # @return [nil]
-    def run!(deployments: nil, selector: nil, verify_result: true)
+    def run!(deployments: [], statefulsets: [], daemonsets: [], selector: nil, verify_result: true)
       start = Time.now.utc
       @logger.reset
 
       @logger.phase_heading("Initializing restart")
       verify_config!
-      deployments = identify_target_deployments(deployments, selector: selector)
+      deployments, statefulsets, daemonsets = identify_target_workloads(deployments, statefulsets,
+                                                daemonsets, selector: selector)
 
-      @logger.phase_heading("Triggering restart by touching ENV[RESTARTED_AT]")
+      @logger.phase_heading("Triggering restart by annotating pod template #{RESTART_TRIGGER_ANNOTATION} annotation")
       patch_kubeclient_deployments(deployments)
+      patch_kubeclient_statefulsets(statefulsets)
+      patch_kubeclient_daemonsets(daemonsets)
 
       if verify_result
         @logger.phase_heading("Waiting for rollout")
-        resources = build_watchables(deployments, start)
+        resources = build_watchables(deployments, start, Deployment)
+        resources += build_watchables(statefulsets, start, StatefulSet)
+        resources += build_watchables(daemonsets, start, DaemonSet)
         verify_restart(resources)
       else
         warning = "Result verification is disabled for this task"
         @logger.summary.add_paragraph(ColorizedString.new(warning).yellow)
       end
-      StatsD.client.distribution('restart.duration', StatsD.duration(start), tags: tags('success', deployments))
+      StatsD.client.distribution('restart.duration', StatsD.duration(start),
+        tags: tags('success', deployments, statefulsets, daemonsets))
       @logger.print_summary(:success)
     rescue DeploymentTimeoutError
-      StatsD.client.distribution('restart.duration', StatsD.duration(start), tags: tags('timeout', deployments))
+      StatsD.client.distribution('restart.duration', StatsD.duration(start),
+        tags: tags('timeout', deployments, statefulsets, daemonsets))
       @logger.print_summary(:timed_out)
       raise
     rescue FatalDeploymentError => error
-      StatsD.client.distribution('restart.duration', StatsD.duration(start), tags: tags('failure', deployments))
+      StatsD.client.distribution('restart.duration', StatsD.duration(start),
+        tags: tags('failure', deployments, statefulsets, daemonsets))
       @logger.summary.add_action(error.message) if error.message != error.class.to_s
       @logger.print_summary(:failure)
       raise
@@ -93,66 +103,140 @@ module Krane
 
     private
 
-    def tags(status, deployments)
-      %W(namespace:#{@namespace} context:#{@context} status:#{status} deployments:#{deployments.to_a.length}})
+    def tags(status, deployments, statefulsets, daemonsets)
+      %W(namespace:#{@namespace} context:#{@context} status:#{status} deployments:#{deployments.to_a.length}
+         statefulsets:#{statefulsets.to_a.length} daemonsets:#{daemonsets.to_a.length}})
     end
 
-    def identify_target_deployments(deployment_names, selector: nil)
-      if deployment_names.nil?
-        deployments = if selector.nil?
-          @logger.info("Configured to restart all deployments with the `#{ANNOTATION}` annotation")
-          apps_v1_kubeclient.get_deployments(namespace: @namespace)
+    def identify_target_workloads(deployment_names, statefulset_names, daemonset_names, selector: nil)
+      if deployment_names.blank? && statefulset_names.blank? && daemonset_names.blank?
+        if selector.nil?
+          @logger.info("Configured to restart all workloads with the `#{ANNOTATION}` annotation")
         else
-          selector_string = selector.to_s
           @logger.info(
-            "Configured to restart all deployments with the `#{ANNOTATION}` annotation and #{selector_string} selector"
+            "Configured to restart all workloads with the `#{ANNOTATION}` annotation and #{selector} selector"
           )
-          apps_v1_kubeclient.get_deployments(namespace: @namespace, label_selector: selector_string)
         end
-        deployments.select! { |d| d.metadata.annotations[ANNOTATION] }
+        deployments = identify_target_deployments(selector: selector)
+        statefulsets = identify_target_statefulsets(selector: selector)
+        daemonsets = identify_target_daemonsets(selector: selector)
 
-        if deployments.none?
-          raise FatalRestartError, "no deployments with the `#{ANNOTATION}` annotation found in namespace #{@namespace}"
+        if deployments.none? && statefulsets.none? && daemonsets.none?
+          raise FatalRestartError, "no deployments, statefulsets, or daemonsets, 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"
       elsif !selector.nil?
-        raise FatalRestartError, "Can't specify deployment names and selector at the same time"
+        raise FatalRestartError, "Can't specify workload names and selector at the same time"
       else
-        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 FatalRestartError, "no deployments with names #{list} found in namespace #{@namespace}"
+        deployments, statefulsets, daemonsets = identify_target_workloads_by_name(deployment_names,
+            statefulset_names, daemonset_names)
+        if deployments.none? && statefulsets.none? && daemonsets.none?
+          error_msgs = []
+          error_msgs << "no deployments with names #{list} found in namespace #{@namespace}" if deployment_names
+          error_msgs << "no statefulsets with names #{list} found in namespace #{@namespace}" if statefulset_names
+          error_msgs << "no daemonsets with names #{list} found in namespace #{@namespace}" if daemonset_names
+          raise FatalRestartError, error_msgs.join(', ')
         end
       end
-      deployments
+      [deployments, statefulsets, daemonsets]
     end
 
-    def build_watchables(kubeclient_resources, started)
+    def identify_target_workloads_by_name(deployment_names, statefulset_names, daemonset_names)
+      deployment_names = deployment_names.uniq
+      statefulset_names = statefulset_names.uniq
+      daemonset_names = daemonset_names.uniq
+
+      if deployment_names.present?
+        @logger.info("Configured to restart deployments by name: #{deployment_names.join(', ')}")
+      end
+      if statefulset_names.present?
+        @logger.info("Configured to restart statefulsets by name: #{statefulset_names.join(', ')}")
+      end
+      if daemonset_names.present?
+        @logger.info("Configured to restart daemonsets by name: #{daemonset_names.join(', ')}")
+      end
+
+      [fetch_deployments(deployment_names), fetch_statefulsets(statefulset_names), fetch_daemonsets(daemonset_names)]
+    end
+
+    def identify_target_deployments(selector: nil)
+      deployments = if selector.nil?
+        apps_v1_kubeclient.get_deployments(namespace: @namespace)
+      else
+        selector_string = selector.to_s
+        apps_v1_kubeclient.get_deployments(namespace: @namespace, label_selector: selector_string)
+      end
+      deployments.select { |d| d.metadata.annotations[ANNOTATION] }
+    end
+
+    def identify_target_statefulsets(selector: nil)
+      statefulsets = if selector.nil?
+        apps_v1_kubeclient.get_stateful_sets(namespace: @namespace)
+      else
+        selector_string = selector.to_s
+        apps_v1_kubeclient.get_stateful_sets(namespace: @namespace, label_selector: selector_string)
+      end
+      statefulsets.select { |d| d.metadata.annotations[ANNOTATION] }
+    end
+
+    def identify_target_daemonsets(selector: nil)
+      daemonsets = if selector.nil?
+        apps_v1_kubeclient.get_daemon_sets(namespace: @namespace)
+      else
+        selector_string = selector.to_s
+        apps_v1_kubeclient.get_daemon_sets(namespace: @namespace, label_selector: selector_string)
+      end
+      daemonsets.select { |d| d.metadata.annotations[ANNOTATION] }
+    end
+
+    def build_watchables(kubeclient_resources, started, klass)
       kubeclient_resources.map do |d|
         definition = d.to_h.deep_stringify_keys
-        r = Deployment.new(namespace: @namespace, context: @context, definition: definition, logger: @logger)
+        r = klass.new(namespace: @namespace, context: @context, definition: definition, logger: @logger)
         r.deploy_started_at = started # we don't care what happened to the resource before the restart cmd ran
         r
       end
     end
 
     def patch_deployment_with_restart(record)
-      apps_v1_kubeclient.patch_deployment(
-        record.metadata.name,
-        build_patch_payload(record),
-        @namespace
-      )
+      apps_v1_kubeclient.patch_deployment(record.metadata.name, build_patch_payload(record), @namespace)
+    end
+
+    def patch_statefulset_with_restart(record)
+      apps_v1_kubeclient.patch_stateful_set(record.metadata.name, build_patch_payload(record), @namespace)
+    end
+
+    def patch_daemonset_with_restart(record)
+      apps_v1_kubeclient.patch_daemon_set(record.metadata.name, build_patch_payload(record), @namespace)
     end
 
     def patch_kubeclient_deployments(deployments)
       deployments.each do |record|
         begin
           patch_deployment_with_restart(record)
-          @logger.info("Triggered `#{record.metadata.name}` restart")
+          @logger.info("Triggered `Deployment/#{record.metadata.name}` restart")
+        rescue Kubeclient::HttpError => e
+          raise RestartAPIError.new(record.metadata.name, e.message)
+        end
+      end
+    end
+
+    def patch_kubeclient_statefulsets(statefulsets)
+      statefulsets.each do |record|
+        begin
+          patch_statefulset_with_restart(record)
+          @logger.info("Triggered `StatefulSet/#{record.metadata.name}` restart")
+        rescue Kubeclient::HttpError => e
+          raise RestartAPIError.new(record.metadata.name, e.message)
+        end
+      end
+    end
+
+    def patch_kubeclient_daemonsets(daemonsets)
+      daemonsets.each do |record|
+        begin
+          patch_daemonset_with_restart(record)
+          @logger.info("Triggered `DaemonSet/#{record.metadata.name}` restart")
         rescue Kubeclient::HttpError => e
           raise RestartAPIError.new(record.metadata.name, e.message)
         end
@@ -171,18 +255,38 @@ module Krane
       end
     end
 
-    def build_patch_payload(deployment)
-      containers = deployment.spec.template.spec.containers
+    def fetch_statefulsets(list)
+      list.map do |name|
+        record = nil
+        begin
+          record = apps_v1_kubeclient.get_stateful_set(name, @namespace)
+        rescue Kubeclient::ResourceNotFoundError
+          raise FatalRestartError, "StatefulSet `#{name}` not found in namespace `#{@namespace}`"
+        end
+        record
+      end
+    end
+
+    def fetch_daemonsets(list)
+      list.map do |name|
+        record = nil
+        begin
+          record = apps_v1_kubeclient.get_daemon_set(name, @namespace)
+        rescue Kubeclient::ResourceNotFoundError
+          raise FatalRestartError, "DaemonSet `#{name}` not found in namespace `#{@namespace}`"
+        end
+        record
+      end
+    end
+
+    def build_patch_payload(_deployment)
       {
         spec: {
           template: {
-            spec: {
-              containers: containers.map do |container|
-                {
-                  name: container.name,
-                  env: [{ name: "RESTARTED_AT", value: Time.now.to_i.to_s }],
-                }
-              end,
+            metadata: {
+              annotations: {
+                RESTART_TRIGGER_ANNOTATION => Time.now.utc.to_datetime.rfc3339,
+              },
             },
           },
         },

data/lib/krane/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Krane
-  VERSION = "2.1.8"
+  VERSION = "2.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: krane
 version: !ruby/object:Gem::Version
-  version: 2.1.8
+  version: 2.3.0
 platform: ruby
 authors:
 - Katrina Verey
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-04-13 00:00:00.000000000 Z
+date: 2021-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -374,6 +374,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.89.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-shopify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.5
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -494,11 +508,6 @@ files:
 - lib/krane/task_config_validator.rb
 - lib/krane/template_sets.rb
 - lib/krane/version.rb
-- screenshots/deploy-demo.gif
-- screenshots/migrate-logs.png
-- screenshots/missing-secret-fail.png
-- screenshots/success.png
-- screenshots/test-output.png
 homepage: https://github.com/Shopify/krane
 licenses:
 - MIT
@@ -519,7 +528,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.20
 signing_key: 
 specification_version: 4
 summary: A command line tool that helps you ship changes to a Kubernetes namespace