knife-bulk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b21db83b5357f2dc64be44ec418fd3139c57a768771218fac890817023a083e4
+  data.tar.gz: 0cd26dc6e2e61d1714ed46cd7a0a5a35f0e1f1586c9bf9d255875235adcd4994
+SHA512:
+  metadata.gz: ac90dac8fdb710cffd35952a443256814f3e941b1c1718fc80244655d10969818046f28cc7c94e46a4991b6aceec43afe0f78393aded40b89fc268d5bae9bdb6
+  data.tar.gz: b2be7b3e5276655f0601a6e6d01b95413f12b92e58738cb537f0a26112eae01b7d8abbecf34686901ac031da2036fc6e6709ac7f6f1e424f297f098a2396dd22

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2022 joshuariojas
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/chef/knife/bulk_node_check.rb

@@ -0,0 +1,95 @@
+require 'chef/knife'
+require_relative 'helpers/bulk_node_base.rb'
+
+class Chef
+  class Knife
+    class BulkNodeCheck < Chef::Knife
+
+      include Chef::Knife::BulkNodeBase
+
+      deps do
+        require 'chef/json_compat' unless defined?(Chef::JSONCompat)
+        require 'chef/server_api' unless defined?(Chef::ServerAPI)
+      end
+
+      banner 'knife bulk node check [NODE_NAME [NODE_NAME]] (options)'
+      category 'bulk'
+
+      def run
+        STDOUT.sync = STDERR.sync = true
+
+        config[:format] = 'json'
+
+        api   = Chef::ServerAPI.new
+        nodes = bulk_args
+        resp  = {
+          :errors => false,
+          :items  => {
+            :nodes   => [],
+            :clients => []
+          }
+        }
+
+        nodes.each do |node_name|
+          begin
+            api.head("nodes/#{node_name}")
+
+            resp[:items][:nodes] << {
+              :node_name  => node_name,
+              :method     => 'head',
+              :successful => true
+            }
+          rescue StandardError => e
+            resp[:errors] ||= true
+            message, code   = parse_exception(e)
+
+            ui.error("Encountered #{e.class} when checking node '#{node_name}'\n#{e}")
+
+            resp[:items][:nodes] << {
+              :node_name  => node_name,
+              :method     => 'head',
+              :successful => false,
+              :error      => {
+                :code    => code,
+                :message => message
+              }
+            }
+          end
+
+          unless config[:include_clients]
+            ui.output(resp)
+            return
+          end
+
+          begin
+            _ = api.get("clients/#{node_name}")
+
+            resp[:items][:clients] << {
+              :client_name  => node_name,
+              :method      => 'head',
+              :successful  => true
+            }
+          rescue StandardError => e
+            resp[:errors] ||= true
+            message, code   = parse_exception(e)
+
+            ui.error("Encountered #{e.class} when checking client '#{node_name}'\n#{e}")
+
+            resp[:items][:clients] << {
+              :client_name => node_name,
+              :method      => 'head',
+              :successful  => false,
+              :error       => {
+                :code    => code,
+                :message => message
+              }
+            }
+          end
+        end
+
+        ui.output(resp)
+      end
+
+    end
+  end
+end

data/lib/chef/knife/bulk_node_delete.rb

@@ -0,0 +1,106 @@
+require 'chef/knife'
+require_relative 'helpers/bulk_node_base'
+
+class Chef
+  class Knife
+    class BulkNodeDelete < Chef::Knife
+
+      include Chef::Knife::BulkNodeBase
+
+      banner 'knife bulk node delete [NODE_NAME [NODE_NAME]] (options)'
+      category 'bulk'
+
+      def run
+        STDOUT.sync = STDERR.sync = true
+
+        config[:format] = 'json'
+
+        api   = Chef::ServerAPI.new
+        nodes = bulk_args
+        resp  = {
+          :errors => false,
+          :items  => {
+            :nodes   => [],
+            :clients => []
+          }
+        }
+
+        nodes.each do |node_name|
+          begin
+            api.delete("nodes/#{node_name}")
+
+            resp[:items][:nodes] << {
+              :node_name  => node_name,
+              :method     => 'delete',
+              :successful => true
+            }
+          rescue StandardError => e
+            message, code = parse_exception(e)
+
+            if code == 404
+              resp[:items][:nodes] << {
+                :node_name  => node_name,
+                :method     => 'delete',
+                :successful => true
+              }
+            else
+              resp[:items][:nodes] << {
+                :node_name  => node_name,
+                :method     => 'delete',
+                :successful => false,
+                :error      => {
+                  :code    => code,
+                  :message => message
+                }
+              }
+
+              resp[:errors] ||= true
+              ui.error("Encountered #{e.class} when checking node '#{node_name}'\n#{e}")
+            end
+          end
+
+          unless config[:include_clients]
+            ui.output(resp)
+            return
+          end
+
+          begin
+            api.delete("clients/#{node_name}")
+
+            resp[:items][:clients] << {
+              :client_name => node_name,
+              :method      => 'delete',
+              :successful  => true
+            }
+          rescue StandardError => e
+            message, code = parse_exception(e)
+
+            if code == 404
+              resp[:items][:clients] << {
+                :client_name => node_name,
+                :method      => 'delete',
+                :successful  => true
+              }
+            else
+              resp[:errors] ||= true
+              ui.error("Encountered #{e.class} when checking node '#{node_name}'\n#{e}")
+
+              resp[:items][:clients] << {
+                :client_name => node_name,
+                :method      => 'delete',
+                :successful  => false,
+                :error       => {
+                  :code    => code,
+                  :message => message
+                }
+              }
+            end
+          end
+        end
+
+        ui.output(resp)
+      end
+
+    end
+  end
+end

data/lib/chef/knife/helpers/bulk_node_base.rb

@@ -0,0 +1,89 @@
+require 'chef/knife'
+require_relative 'bulk_shared_options'
+
+class Chef
+  class Knife
+    module BulkNodeBase
+
+      def self.included(includer)
+        includer.class_eval do
+
+          include Chef::Knife::BulkSharedOptions
+
+          deps do
+            require 'chef/json_compat' unless defined?(Chef::JSONCompat)
+            require 'chef/server_api' unless defined?(Chef::ServerAPI)
+          end
+
+          option :append_domain,
+            long: '--append-domain DOMAIN',
+            description: 'Domain that will be appended to each node during HTTP request'
+
+          option :include_clients,
+            long: '--[no-]include-clients',
+            description: 'Include operations against client objects',
+            boolean: true,
+            default: true
+
+          def append_domain(nodes)
+            if config.has_key?(:append_domain)
+              return nodes.map { |line| "#{line}.#{config[:append_domain]}" }
+            else
+              return nodes
+            end
+          end
+
+          def file_exists_and_readable?(path)
+            File.exist?(path) && File.readable?(path)
+          end
+
+          def bulk_args
+            unless config.has_key?(:from_file)
+              if @name_args.size == 0
+                ui.fatal('You must provide at least one node name')
+                exit 1
+              end
+
+              return append_domain(@name_args)
+            end
+
+            if file_exists_and_readable?(config[:from_file])
+              nodes = File.readlines(config[:from_file], chomp: true).map(&:strip).reject(&:empty?)
+
+              if nodes.size == 0
+                ui.fatal("Invalid value provided to option '--from-file'. File '#{config[:from_file]} was empty'")
+                exit 1
+              end
+
+              return append_domain(nodes)
+            else
+              show_usage
+              ui.fatal("Invalid value provided to option '--from-file'. Could not find or open file '#{config[:from_file]}'")
+              exit 1
+            end
+          end
+
+          def parse_exception(exception)
+            # TODO
+            # Extend this to handling different exception categories.
+            # exception.class.name.include? 'HTTP' is for handing the family of errors under net/http, but it is barely best effort
+            # Undecided on how to handle returns. Currently, the else case intends that code will be set to nil, and a caller may need to
+            # check for an exception category that is not yet support below.
+            #
+            # message, code = parse_exception(exception)
+            # if code.nil? then do the things
+
+            if exception.class.name.include?('HTTP')
+              code, message = exception.message.split(' ', 2)
+              return message.delete_suffix('"').delete_prefix('"'), code
+            else
+              return exception.message, nil
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/chef/knife/helpers/bulk_shared_options.rb

@@ -0,0 +1,19 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    module BulkSharedOptions
+
+      def self.included(includer)
+        includer.class_eval do
+
+          option :from_file,
+            long: '--from-file FILE',
+            description: 'File containing list of objects to pass to subcommand in place of expected argument(s)'
+
+        end
+      end
+
+    end
+  end
+end

data/lib/knife-bulk/version.rb

@@ -0,0 +1,5 @@
+module Knife
+  module Bulk
+    VERSION = '0.1.0'.freeze
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: knife-bulk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joshua Riojas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-06-29 00:00:00.000000000 Z
+dependencies: []
+description: Plugin that adds functionality of running bulk requests against Chef
+  Infra Server.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/chef/knife/bulk_node_check.rb
+- lib/chef/knife/bulk_node_delete.rb
+- lib/chef/knife/helpers/bulk_node_base.rb
+- lib/chef/knife/helpers/bulk_shared_options.rb
+- lib/knife-bulk/version.rb
+homepage: https://github.com/joshuariojas/knife-bulk
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6.2
+signing_key: 
+specification_version: 4
+summary: Plugin that adds functionality of running bulk requests against Chef Infra
+  Server.
+test_files: []