knife-ec-backup 3.0.9 → 3.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f2a9570f14dc2fb44eb99732fd69f1f9da32c48ceab68bd6e94511f1e2c464d
-  data.tar.gz: de9b0f5cd3bc62c6402bd364151c1237d6e1107b89ce9b80753240091e0b3303
+  metadata.gz: d288abb4c07544382487a1ea61612a485fa0651e5ebb20a39db277278b900237
+  data.tar.gz: 21cb4ac04036f42faff0a5e93ddc3af4bed52efd8905ddf58840103d415747d6
 SHA512:
-  metadata.gz: 5c68fe7a9f2af77f36bff226a63d131cd7dc1a9bb0dd0086b0d65125913310080b4b2acc52f1284438116aae4d14baa248624078d08b3abf37484cebacda3c5f
-  data.tar.gz: d2d04dfab678b7d4629e88369208807be1af0f92a930dc6c2bf4d6ead3ba813836f4542ba93322c390f8e120a59c7ab9a9d07d142cb5aa3137af2578864d6e0a
+  metadata.gz: 022deb1b7431715bfdb5b21cf30da21bded07ae68c1cd4bbeaefeaa8b01a68cdd07bfdc335839b46f69fce64d926063e5cbfeb98fba27330319c20bc6cc591ea
+  data.tar.gz: c87aef9ad1f2e606d1b119ebdaa8f9ff0838a202deacf42c19f09c1849cb3657fb6650630d380cc98a70e706e7083a628ad049bd8c965dad445fdfd3938ee5c9

data/lib/chef/knife/ec_error_handler.rb

@@ -28,6 +28,8 @@ class Chef
       def initialize(working_dir, process)
         @err_dir = "#{working_dir}/errors"
         FileUtils.mkdir_p(@err_dir)
+        @error_count = 0
+        @process = process
 
         # Create an specific error file name depending
         # of where the process comes from.
@@ -40,7 +42,51 @@ class Chef
                     end
 
         # exit handler
-        at_exit { display(@err_file) }
+        at_exit do
+          display(@err_file)
+          override_exit_status
+        end
+      end
+
+      # Forces a consistent, non-zero exit status when errors were recorded so
+      # that a run with a high-verbosity flag (e.g. -VVV) and one without it
+      # report the same status. Only applies to `knife ec import`; other
+      # commands keep their original exit status. Skipped under RSpec so the
+      # test suite's own exit status is not altered.
+      def override_exit_status
+        return if defined?(RSpec)
+        return unless defined?(Chef::Knife::EcImport) && @process == Chef::Knife::EcImport
+
+        status = maybe_exit_status($!)
+        exit(status) unless status.nil?
+      end
+
+      # Decides the process exit status so it is identical regardless of
+      # verbosity. Under -VVV knife re-raises and Ruby exits 1; without it knife
+      # rescues and exits with a different code (e.g. 100). Both are error cases
+      # and must agree.
+      #
+      # +error+ is the exception propagating at exit (Ruby's $!). Returns the
+      # status to force, or nil to leave the current status untouched.
+      def maybe_exit_status(error = $!)
+        case error
+        when SystemExit
+          # Normalize any non-zero exit (e.g. knife's exit 100) to 1.
+          return 1 unless error.success?
+          has_errors? ? 1 : nil
+        when nil
+          # Normal termination: exit 1 only if errors were logged.
+          has_errors? ? 1 : nil
+        else
+          # A raw exception is propagating (typically under -VVV); Ruby already
+          # exits 1 and prints the backtrace, so leave it untouched.
+          nil
+        end
+      end
+
+      # Returns true when any error has been recorded.
+      def has_errors?
+        @error_count > 0
       end
 
       # Add an exception to the error file.
@@ -61,6 +107,7 @@ class Chef
       # The advantages of this schema is the ability to retry the backup or
       # restore and pick up where we left.
       def add(ex)
+        @error_count += 1
         msg = {
           timestamp:  Time.now,
           message:    ex.message,

data/lib/chef/knife/ec_import.rb

@@ -31,6 +31,22 @@ class Chef
       ADMIN_GROUP_FILES = ['billing-admins.json', 'public_key_read_access.json'].freeze
       NOT_FOUND_STATUS = '404'
 
+      # Network/server errors that should be logged and skipped so the rest of
+      # the import can proceed instead of aborting. Covers 5xx "Internal Server
+      # Error" responses and dropped connections such as "Connection reset by
+      # peer".
+      RECOVERABLE_NETWORK_ERRORS = [
+        Net::HTTPClientException, # 4xx
+        Net::HTTPFatalError,      # 5xx, e.g. Internal Server Error
+        Errno::ECONNRESET,        # Connection reset by peer
+        Errno::ECONNREFUSED,
+        Errno::ETIMEDOUT,
+      ].freeze
+
+      # Substring of the RuntimeError some Ruby builds raise while computing
+      # cookbook checksums. It must be logged and skipped, not abort the import.
+      DIGEST_INHERITANCE_ERROR = 'Digest::Base cannot be directly inherited'.freeze
+
       option :tenant_id_header,
         :long => '--tenant-id TENANT_ID',
         :description => 'Tenant identifier added as X-Tenant-Id header for import requests'
@@ -146,13 +162,11 @@ class Chef
       def organization_exists?(orgname)
         rest.get(org_url(orgname))
         true
-      rescue Net::HTTPClientException => ex
-        if ex.response.code == NOT_FOUND_STATUS
-          false
-        else
-          knife_ec_error_handler.add(ex)
-          false
-        end
+      rescue *RECOVERABLE_NETWORK_ERRORS => ex
+        return false if ex.is_a?(Net::HTTPClientException) && ex.response.code == NOT_FOUND_STATUS
+        ui.error "Failed to verify organization #{orgname}: #{ex.message}"
+        knife_ec_error_handler.add(ex)
+        false
       end
 
       def restore_user_acls
@@ -285,13 +299,19 @@ class Chef
                                          chef_fs_config.chef_fs, nil,
                                          config, ui,
                                          proc { |entry| chef_fs_config.format_path(entry) })
-      rescue Net::HTTPClientException,
+      rescue *RECOVERABLE_NETWORK_ERRORS,
              Chef::ChefFS::FileSystem::NotFoundError,
              Chef::ChefFS::FileSystem::OperationFailedError,
              Chef::Exceptions::JSON::ParseError,
              JSON::ParserError => ex
         ui.error "#{pattern_str} failed to copy: #{ex.message}"
         knife_ec_error_handler.add(ex)
+      rescue RuntimeError => ex
+        # Only swallow the known Digest::Base inheritance error so the import
+        # continues; re-raise anything else.
+        raise unless ex.message.to_s.include?(DIGEST_INHERITANCE_ERROR)
+        ui.error "#{pattern_str} failed to copy: #{ex.message}"
+        knife_ec_error_handler.add(ex)
       end
 
       def sort_groups_for_upload(groups)
@@ -399,8 +419,8 @@ class Chef
 
         rest.put(cookbook_url(org_name, cookbook_name, version, 'freeze=true'), 
                  manifest.tap { |h| h[FROZEN_STATUS_KEY] = true })
-      rescue Net::HTTPClientException => ex
-        ui.warn "Failed to freeze cookbook #{cookbook_name} #{version}: #{ex.message}"
+      rescue *RECOVERABLE_NETWORK_ERRORS => ex
+        ui.error "Failed to freeze cookbook #{cookbook_name} #{version}: #{ex.message}"
         knife_ec_error_handler.add(ex)
       end
 
@@ -414,7 +434,8 @@ class Chef
             rest.put("#{url}/#{permission}", { permission => acls[permission] })
           end
         end
-      rescue Net::HTTPClientException => ex
+      rescue *RECOVERABLE_NETWORK_ERRORS => ex
+        ui.error "Failed to update ACL #{url}: #{ex.message}"
         knife_ec_error_handler.add(ex)
       end
     end

data/lib/knife_ec_backup/version.rb

@@ -1,4 +1,4 @@
 # when you change this to double quotes, also update .expeditor/update_version.sh
 module KnifeECBackup
-  VERSION = '3.0.9'
+  VERSION = '3.0.11'
 end

data/spec/chef/knife/ec_error_handler_spec.rb

@@ -115,4 +115,47 @@ EOF
     @knife_ec_error_handler.add(cheffs_filesystem_exception('OperationFailedError'))
     expect(File.read(err_file)).to match mock_content.strip
   end
+
+  describe "#has_errors?" do
+    it "is false before any error is added" do
+      expect(@knife_ec_error_handler.has_errors?).to be false
+    end
+
+    it "is true after an error is added" do
+      @knife_ec_error_handler.add(net_exception(500))
+      expect(@knife_ec_error_handler.has_errors?).to be true
+    end
+  end
+
+  describe "#maybe_exit_status" do
+    context "when no error was recorded" do
+      it "leaves a clean exit untouched" do
+        expect(@knife_ec_error_handler.maybe_exit_status(nil)).to be_nil
+      end
+
+      it "normalizes knife's non-zero exit (e.g. 100) to 1" do
+        expect(@knife_ec_error_handler.maybe_exit_status(SystemExit.new(100))).to eq 1
+      end
+
+      it "leaves a clean SystemExit untouched" do
+        expect(@knife_ec_error_handler.maybe_exit_status(SystemExit.new(0))).to be_nil
+      end
+
+      it "leaves a raw exception (e.g. under -VVV) untouched" do
+        expect(@knife_ec_error_handler.maybe_exit_status(RuntimeError.new('boom'))).to be_nil
+      end
+    end
+
+    context "when an error was recorded" do
+      before(:each) { @knife_ec_error_handler.add(net_exception(500)) }
+
+      it "forces exit 1 on an otherwise clean exit" do
+        expect(@knife_ec_error_handler.maybe_exit_status(nil)).to eq 1
+      end
+
+      it "normalizes knife's exit 100 to 1" do
+        expect(@knife_ec_error_handler.maybe_exit_status(SystemExit.new(100))).to eq 1
+      end
+    end
+  end
 end

data/spec/chef/knife/ec_import_spec.rb

@@ -463,6 +463,7 @@ describe Chef::Knife::EcImport do
     it HANDLES_ERRORS do
       allow(@rest).to receive(:get).and_raise(import_net_exception(500))
       expect(@error_handler).to receive(:add)
+      expect(@knife.ui).to receive(:error).with(/Failed to update ACL/)
       @knife.put_acl(@rest, "url", {})
     end
   end
@@ -562,7 +563,7 @@ describe Chef::Knife::EcImport do
     it HANDLES_ERRORS do
       allow(@rest).to receive(:get).and_raise(import_net_exception(500))
       expect(@error_handler).to receive(:add)
-      expect(@knife.ui).to receive(:warn).with(/Failed to freeze cookbook/)
+      expect(@knife.ui).to receive(:error).with(/Failed to freeze cookbook/)
       @knife.freeze_cookbook("mycb", "1.0.0", "foo")
     end
   end
@@ -598,6 +599,16 @@ describe Chef::Knife::EcImport do
       expect(@error_handler).to receive(:add)
       @knife.chef_fs_copy_pattern("/foo", chef_fs_config)
     end
+
+    [Errno::ECONNRESET, Errno::ECONNREFUSED, Errno::ETIMEDOUT].each do |socket_error|
+      it "recovers from #{socket_error} socket failures" do
+        chef_fs_config = double("config", :local_fs => double, :chef_fs => double)
+        allow(Chef::ChefFS::FileSystem).to receive(:copy_to).and_raise(socket_error)
+        expect(@knife.ui).to receive(:error).with(/\/foo failed to copy:/)
+        expect(@error_handler).to receive(:add)
+        @knife.chef_fs_copy_pattern("/foo", chef_fs_config)
+      end
+    end
   end
 
   describe "#sort_groups_for_upload" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knife-ec-backup
 version: !ruby/object:Gem::Version
-  version: 3.0.9
+  version: 3.0.11
 platform: ruby
 authors:
 - John Keiser
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-30 00:00:00.000000000 Z
+date: 2026-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -119,7 +119,7 @@ homepage: https://www.chef.io
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -135,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.3.27
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Backup and Restore of Enterprise Chef
 test_files: []