knife-ec-backup 2.2.1 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee7a5b7811f83c09644f6f5d9e04f2a6844ce857
-  data.tar.gz: 76a0134c09193ac0be43a5c9fcfcc8858a259c65
+  metadata.gz: d8f28320438d24209115a64e91cec7e5d2646b0f
+  data.tar.gz: 7fb944b92530e55b91674ee719622e59805fb561
 SHA512:
-  metadata.gz: 60bf796884f29c0aa5bd769a52280e2d660b99d78902dfef230db9659efea11dbd928b2ca389b67f47f5097b87d87629e0f672b7c6c1fba77c471f4bf8974dc8
-  data.tar.gz: 8fd94183cc56cdfb7456b0fefe7b2e3827f6f23ee39f6e28c356e70f77b9f3b9158ba7f745c0d5e6aae129614fb87c4d80aaaa9758f326cd0191d5d12dbee1ff
+  metadata.gz: 2f992491a7740086eb463b27ea99dcfb7f772d8e6809d10ee1dc286976b4041c112d9f8f2078f049d2e3a0557196731d237bef544295978b20021bc89fd60b2c
+  data.tar.gz: 70d19c19168130fa803d38db9df39c70c49feab8a052746977b2c6dda8da2c7d3da0f5fb6b620fc91bbc006e712affc3ff1141eb1d26b76c093c59ca809d7da9

data/lib/chef/knife/ec_backup.rb

@@ -186,11 +186,13 @@ class Chef
 
           # Download the billing-admins, public_key_read_access ACL and group as pivotal
           chef_fs_config = Chef::ChefFS::Config.new
-          chef_fs_copy_pattern('/acls/groups/billing-admins.json', chef_fs_config)
-          chef_fs_copy_pattern('/groups/billing-admins.json', chef_fs_config)
-          chef_fs_copy_pattern('/acls/groups/public_key_read_access.json', chef_fs_config)
-          chef_fs_copy_pattern('/groups/public_key_read_access.json', chef_fs_config)
-          chef_fs_copy_pattern('/groups/admins.json', chef_fs_config)
+
+          paths = ['/acls/groups/billing-admins.json', '/groups/billing-admins.json', '/groups/admins.json']
+          paths.push('/acls/groups/public_key_read_access.json', '/groups/public_key_read_access.json') if server.supports_public_key_read_access?
+
+          paths.each do |path|
+            chef_fs_copy_pattern(path, chef_fs_config)
+          end
 
           Chef::Config.node_name = if config[:skip_version]
                                      org_admin
@@ -210,7 +212,7 @@ class Chef
           # for example: /acls/environments/_default
 
            # Skip the billing-admins, public_key_read_access group ACLs and the groups since they've already been copied
-          exclude_list = ['billing-admins','public_key_read_access']
+          exclude_list = ['billing-admins', 'public_key_read_access']
 
           top_level_acls  = chef_fs_paths('/acls/*.json', chef_fs_config, [])
           acl_paths       = chef_fs_paths('/acls/*/*', chef_fs_config, exclude_list)
@@ -241,7 +243,9 @@ class Chef
                                          chef_fs_config.local_fs, nil,
                                          config, ui,
                                          proc { |entry| chef_fs_config.format_path(entry) })
-      rescue Net::HTTPServerException => ex
+      rescue Net::HTTPServerException,
+             Chef::ChefFS::FileSystem::NotFoundError,
+             Chef::ChefFS::FileSystem::OperationFailedError => ex
         knife_ec_error_handler.add(ex)
       end
     end

data/lib/chef/knife/ec_error_handler.rb

@@ -69,10 +69,21 @@ class Chef
         }
 
         if ex.respond_to?(:chef_rest_request=) && ex.chef_rest_request
-          msg.merge!( {
+          msg.merge!(
             req_path: ex.chef_rest_request.path,
             req_method: ex.chef_rest_request.method
-          })
+          )
+        elsif ex.instance_of?(Chef::ChefFS::FileSystem::NotFoundError)
+          msg.merge!(
+            entry: ex.entry,
+            cause: ex.cause,
+            reason: ex.reason
+          )
+        elsif ex.instance_of?(Chef::ChefFS::FileSystem::OperationFailedError)
+          msg.merge!(
+            entry: ex.entry,
+            operation: ex.operation
+          )
         end
 
         lock_file(@err_file, 'a') do |f|

data/lib/chef/knife/ec_restore.rb

@@ -238,11 +238,19 @@ class Chef
           # pivotal and members of the admins group. Use the same strategy
           # above here.
           #
-          ['admins', 'billing-admins', 'public_key_read_access'].each do |group|
+          groups = ['admins', 'billing-admins']
+          groups.push('public_key_read_access') if
+            ::File.exist?(::File.join(chef_fs_config.local_fs.child_paths['groups'], 'public_key_read_access.json'))
+
+          groups.each do |group|
             restore_group(chef_fs_config, group, :clients => false)
           end
 
-          ['/acls/groups/billing-admins.json', '/acls/groups/public_key_read_access.json'].each do |acl|
+          acls_groups_paths = ['/acls/groups/billing-admins.json']
+          acls_groups_paths.push('/acls/groups/public_key_read_access.json') if
+            ::File.exist?(::File.join(chef_fs_config.local_fs.child_paths['acls'], 'groups', 'public_key_read_access.json'))
+
+          acls_groups_paths.each do |acl|
             chef_fs_copy_pattern(acl, chef_fs_config)
           end
 
@@ -258,13 +266,13 @@ class Chef
           top_level_paths = chef_fs_config.local_fs.children.select { |entry| entry.name != 'acls' && entry.name != 'groups' }.map { |entry| entry.path }
 
           # Topologically sort groups for upload
-          unsorted_groups = Chef::ChefFS::FileSystem.list(chef_fs_config.local_fs, Chef::ChefFS::FilePattern.new('/groups/*')).select { |entry| ! ['billing-admins.json', 'public_key_read_access.json'].include?(entry.name) }.map { |entry| JSON.parse(entry.read) }
+          filenames = ['billing-admins.json', 'public_key_read_access.json']
+          unsorted_groups = Chef::ChefFS::FileSystem.list(chef_fs_config.local_fs, Chef::ChefFS::FilePattern.new('/groups/*')).select { |entry| ! filenames.include?(entry.name) }.map { |entry| JSON.parse(entry.read) }
           group_paths = sort_groups_for_upload(unsorted_groups).map { |group_name| "/groups/#{group_name}.json" }
 
-          group_acl_paths = Chef::ChefFS::FileSystem.list(chef_fs_config.local_fs, Chef::ChefFS::FilePattern.new('/acls/groups/*')).select { |entry| ! ['billing-admins.json', 'public_key_read_access.json'].include?(entry.name) }.map { |entry| entry.path }
+          group_acl_paths = Chef::ChefFS::FileSystem.list(chef_fs_config.local_fs, Chef::ChefFS::FilePattern.new('/acls/groups/*')).select { |entry| ! filenames.include?(entry.name) }.map { |entry| entry.path }
           acl_paths = Chef::ChefFS::FileSystem.list(chef_fs_config.local_fs, Chef::ChefFS::FilePattern.new('/acls/*')).select { |entry| entry.name != 'groups' }.map { |entry| entry.path }
 
-
           # Store organization data in a particular order:
           # - clients must be uploaded before groups (in top_level_paths)
           # - groups must be uploaded before any acl's
@@ -276,7 +284,7 @@ class Chef
 
           # restore clients to groups, using the pivotal user again
           Chef::Config[:node_name] = 'pivotal'
-          ['admins', 'billing-admins', 'public_key_read_access'].each do |group|
+          groups.each do |group|
             restore_group(Chef::ChefFS::Config.new, group)
           end
          ensure
@@ -297,7 +305,9 @@ class Chef
                                          chef_fs_config.chef_fs, nil,
                                          config, ui,
                                          proc { |entry| chef_fs_config.format_path(entry) })
-      rescue Net::HTTPServerException => ex
+      rescue Net::HTTPServerException,
+             Chef::ChefFS::FileSystem::NotFoundError,
+             Chef::ChefFS::FileSystem::OperationFailedError => ex
         knife_ec_error_handler.add(ex)
       end
 
@@ -324,6 +334,7 @@ class Chef
         includes[:users] = true unless includes.key? :users
         includes[:clients] = true unless includes.key? :clients
 
+        ui.msg "Copying /groups/#{group_name}.json"
         group = Chef::ChefFS::FileSystem.resolve_path(
           chef_fs_config.chef_fs,
           "/groups/#{group_name}.json"

data/lib/chef/server.rb

@@ -39,5 +39,9 @@ class Chef
     def supports_defaulting_to_pivotal?
       version >= Gem::Version.new('12.1.0')
     end
+
+    def supports_public_key_read_access?
+      version >= Gem::Version.new('12.5.0')
+    end
   end
 end

data/lib/knife_ec_backup/version.rb

@@ -1,3 +1,3 @@
 module KnifeECBackup
-  VERSION = '2.2.1'
+  VERSION = '2.2.2'
 end

data/spec/chef/knife/ec_backup_spec.rb

@@ -1,6 +1,9 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
 require 'chef/knife/ec_backup'
 require 'fakefs/spec_helpers'
+require_relative './ec_error_handler_spec'
+require "chef/chef_fs/file_system/repository/chef_repository_file_system_root_dir"
+
 
 describe Chef::Knife::EcBackup do
   let(:dest_dir) { Dir.mktmpdir }
@@ -162,6 +165,28 @@ describe Chef::Knife::EcBackup do
     end
   end
 
+  describe "#chef_fs_copy_pattern" do
+    context "when there are Filesystem errors" do
+      let(:ec_error_handler) { double("Chef::Knife::EcErrorHandler") }
+      let(:cheffs_config) { double("Chef::ChefFS::Config") }
+      let(:cheffs_files) { double("Chef::ChefFS::FileSystem") }
+      let(:cheffs_local_fs) { double('Chef::ChefFS::FileSystem::Repository::ChefRepositoryFileSystemRootDir') }
+      let(:chef_fs) { double('applefs') }
+
+      it "adds exceptions to error handler" do
+        exception = cheffs_filesystem_exception('NotFoundError')
+        allow(Chef::Knife::EcErrorHandler).to receive(:new).and_return(ec_error_handler)
+        allow(Chef::ChefFS::Config).to receive(:new).and_return(cheffs_config)
+        allow(Chef::ChefFS::FileSystem::Repository::ChefRepositoryFileSystemRootDir).to receive(:new).and_return(cheffs_local_fs)
+        allow(Chef::ChefFS::FileSystem).to receive(:copy_to).with(any_args).and_raise(exception)
+        allow(cheffs_config).to receive(:chef_fs).and_return(chef_fs)
+        allow(cheffs_config).to receive(:local_fs).and_return(cheffs_local_fs)
+        expect(ec_error_handler).to receive(:add).at_least(1).with(exception)
+        @knife.chef_fs_copy_pattern('bob', cheffs_config)
+      end
+    end
+  end
+
   describe "#write_org_object_to_disk" do
     include FakeFS::SpecHelpers
     it "writes the given object to disk" do
@@ -205,7 +230,6 @@ describe Chef::Knife::EcBackup do
         @knife.download_org_members("bob")
       end
     end
-
   end
 
   describe "#download_org_inivitations" do

data/spec/chef/knife/ec_error_handler_spec.rb

@@ -2,6 +2,8 @@ require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_hel
 require 'chef/knife/ec_error_handler'
 require 'chef/knife/ec_backup'
 require 'chef/knife/ec_restore'
+require 'chef/chef_fs/config'
+require 'chef/chef_fs/file_system'
 require 'fakefs/spec_helpers'
 
 def net_exception(code)
@@ -9,6 +11,17 @@ def net_exception(code)
   Net::HTTPServerException.new("I'm not real!", s)
 end
 
+def cheffs_filesystem_exception(type)
+  case type
+  when 'NotFoundError'
+    Chef::ChefFS::FileSystem::NotFoundError.new('/boop', 'The exception', 'The reason')
+  when 'OperationFailedError'
+    Chef::ChefFS::FileSystem::OperationFailedError.new(:read, '/boop', 'The exception', 'The reason')
+  else
+    raise RuntimeError, 'invalid type passed'
+  end
+end
+
 describe Chef::Knife::EcErrorHandler do
   let(:dest_dir) { Dir.mktmpdir }
   let(:err_dir)  { File.join(dest_dir, "errors") }
@@ -69,6 +82,21 @@ Error Summary Report
   "message": "I'm not real!",
   "backtrace": null,
   "exception": "Net::HTTPServerException"
+}{
+  "timestamp": "1988-04-17 00:00:00 +0000",
+  "message": "The reason",
+  "backtrace": null,
+  "exception": "Chef::ChefFS::FileSystem::NotFoundError",
+  "entry": "/boop",
+  "cause": "The exception",
+  "reason": "The reason"
+}{
+  "timestamp": "1988-04-17 00:00:00 +0000",
+  "message": "The reason",
+  "backtrace": null,
+  "exception": "Chef::ChefFS::FileSystem::OperationFailedError",
+  "entry": "/boop",
+  "operation": "read"
 }
 EOF
     err_file = @knife_ec_error_handler.err_file
@@ -83,6 +111,8 @@ EOF
     @knife_ec_error_handler.add(net_exception(409))
     @knife_ec_error_handler.add(net_exception(404))
     @knife_ec_error_handler.add(net_exception(123))
+    @knife_ec_error_handler.add(cheffs_filesystem_exception('NotFoundError'))
+    @knife_ec_error_handler.add(cheffs_filesystem_exception('OperationFailedError'))
     expect(File.read(err_file)).to match mock_content.strip
   end
 end

data/spec/chef/knife/ec_restore_spec.rb

@@ -1,6 +1,8 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
 require 'chef/knife/ec_restore'
 require 'fakefs/spec_helpers'
+require_relative './ec_error_handler_spec'
+require "chef/chef_fs/file_system/repository/chef_repository_file_system_root_dir"
 
 def make_user(username)
   FileUtils.mkdir_p("/users")
@@ -159,4 +161,26 @@ describe Chef::Knife::EcRestore do
       end
     end
   end
+
+  describe "#chef_fs_copy_pattern" do
+    context "when there are Filesystem errors" do
+      let(:ec_error_handler) { double("Chef::Knife::EcErrorHandler") }
+      let(:cheffs_config) { double("Chef::ChefFS::Config") }
+      let(:cheffs_files) { double("Chef::ChefFS::FileSystem") }
+      let(:cheffs_local_fs) { double('Chef::ChefFS::FileSystem::Repository::ChefRepositoryFileSystemRootDir') }
+      let(:chef_fs) { double('applefs') }
+
+      it "adds exceptions to error handler" do
+        exception = cheffs_filesystem_exception('NotFoundError')
+        allow(Chef::Knife::EcErrorHandler).to receive(:new).and_return(ec_error_handler)
+        allow(Chef::ChefFS::Config).to receive(:new).and_return(cheffs_config)
+        allow(Chef::ChefFS::FileSystem::Repository::ChefRepositoryFileSystemRootDir).to receive(:new).and_return(cheffs_local_fs)
+        allow(Chef::ChefFS::FileSystem).to receive(:copy_to).with(any_args).and_raise(exception)
+        allow(cheffs_config).to receive(:chef_fs).and_return(chef_fs)
+        allow(cheffs_config).to receive(:local_fs).and_return(cheffs_local_fs)
+        expect(ec_error_handler).to receive(:add).at_least(1).with(exception)
+        @knife.chef_fs_copy_pattern('bob', cheffs_config)
+      end
+    end
+  end
 end

data/spec/chef/server_spec.rb

@@ -47,4 +47,13 @@ describe Chef::Server do
     allow(rest).to receive(:get).and_raise(Errno::ECONNREFUSED)
     expect(s.direct_account_access?).to eq(false)
   end
+
+  it "knows that public_key_read_access was implemented in 12.5.0" do
+    before = Chef::Server.new("http://api.example.com")
+    allow(before).to receive(:open).and_return(StringIO.new("Chef Server 12.4.1\nother stuff\nother stuff"))
+    expect(before.supports_public_key_read_access?).to eq(false)
+    after = Chef::Server.new("http://api.example.com")
+    allow(after).to receive(:open).and_return(StringIO.new("Chef Server 12.6.0\nother stuff\nother stuff"))
+    expect(after.supports_public_key_read_access?).to eq(true)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knife-ec-backup
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 2.2.2
 platform: ruby
 authors:
 - John Keiser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-11 00:00:00.000000000 Z
+date: 2017-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Backup and Restore of Enterprise Chef
-email: jkeiser@opscode.com
+email: jkeiser@chef.io
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -98,7 +98,7 @@ files:
 - spec/chef/server_spec.rb
 - spec/chef/tsorter_spec.rb
 - spec/spec_helper.rb
-homepage: http://www.opscode.com
+homepage: https://www.chef.io
 licenses:
 - Apache 2.0
 metadata: {}