knife-ec-backup 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c0eaeaca5c1a8707e66a26cafe08186a77ea6fa
-  data.tar.gz: 2b4675644bc5a526f3a26ad436dfd73a30ed1307
+  metadata.gz: 090c5b339d237877732a3d620eb92a4466addb75
+  data.tar.gz: 76cbbc8bb669fd36a722515b618838d3a100603b
 SHA512:
-  metadata.gz: ba31ebcf31a0aca8b4df975c9687436822c5fabdc81095b23e30c4e60e35f7ff88516334949ad53fa86c4d8fe4c6787c1ed5764fa9ddd0057e132ee73f78eab1
-  data.tar.gz: e751b01f0094618a3fb5a6249ef083a42d20e911135d69d07b9bba77a4438b4118fb1f7f80201ec86ec7cd392865f1d8241775c8b4f9e83305ad9fbf3d6871e8
+  metadata.gz: d074dfc01e8be51da10c38831d02aeff7b3aa8cd672c93540f9e53cbc161bc4c8ba5b97be95ef5a978d131aa0f5b02883a77243f7ef34bc5e77df440eab2b7ba
+  data.tar.gz: b092806e811fa6b550b145d42c2ac55ab543281eafaf46c53f68118d1f8e498e2fd4196af48252d7a40105f7947e13638cca334a29dd56457d27501094aaa1fa

data/lib/chef/knife/ec_backup.rb

@@ -77,13 +77,21 @@ class Chef
         remote_users.each_pair do |name, url|
           yield name, url
         end
+      rescue Net::HTTPServerException => ex
+        knife_ec_error_handler.add(ex)
       end
 
       def for_each_organization
         rest.get('/organizations').each_pair do |name, url|
           next unless (config[:org].nil? || config[:org] == name)
           ui.msg "Downloading organization object for #{name} from #{url}"
-          org = rest.get(url)
+          begin
+            org = rest.get(url)
+          rescue Net::HTTPServerException => ex
+            ui.error "Failed to find organization '#{name}'."
+            knife_ec_error_handler.add(ex)
+            next
+          end
           # Enterprise Chef 11 and below uses a pool of precreated
           # organizations to account for slow organization creation
           # using CouchDB. Thus, on server versions < 12 we want to
@@ -102,12 +110,16 @@ class Chef
         File.open("#{dest_dir}/users/#{username}.json", 'w') do |file|
           file.write(Chef::JSONCompat.to_json_pretty(rest.get(url)))
         end
+      rescue Net::HTTPServerException => ex
+        knife_ec_error_handler.add(ex)
       end
 
       def download_user_acl(username)
         File.open("#{dest_dir}/user_acls/#{username}.json", 'w') do |file|
           file.write(Chef::JSONCompat.to_json_pretty(user_acl_rest.get("users/#{username}/_acl")))
         end
+      rescue Net::HTTPServerException => ex
+        knife_ec_error_handler.add(ex)
       end
 
       def export_from_sql
@@ -137,6 +149,8 @@ class Chef
         File.open("#{dest_dir}/organizations/#{name}/members.json", 'w') do |file|
           file.write(Chef::JSONCompat.to_json_pretty(rest.get("/organizations/#{name}/users")))
         end
+      rescue Net::HTTPServerException => ex
+        knife_ec_error_handler.add(ex)
       end
 
       def download_org_invitations(name)
@@ -144,6 +158,8 @@ class Chef
         File.open("#{dest_dir}/organizations/#{name}/invitations.json", 'w') do |file|
           file.write(Chef::JSONCompat.to_json_pretty(rest.get("/organizations/#{name}/association_requests")))
         end
+      rescue Net::HTTPServerException => ex
+        knife_ec_error_handler.add(ex)
       end
 
       def ensure_dir(dir)
@@ -225,6 +241,8 @@ class Chef
                                          chef_fs_config.local_fs, nil,
                                          config, ui,
                                          proc { |entry| chef_fs_config.format_path(entry) })
+      rescue Net::HTTPServerException => ex
+        knife_ec_error_handler.add(ex)
       end
     end
   end

data/lib/chef/knife/ec_base.rb

@@ -19,6 +19,7 @@
 require 'chef/knife'
 require 'chef/server_api'
 require 'veil'
+require 'chef/knife/ec_error_handler'
 
 class Chef
   class Knife
@@ -115,6 +116,8 @@ class Chef
           else
             admin_users[0]
           end
+        rescue Net::HTTPServerException => ex
+          knife_ec_error_handler.add(ex)
         end
       end
 
@@ -150,6 +153,10 @@ class Chef
         raise Chef::Knife::EcBase::UnImplemented
       end
 
+      def knife_ec_error_handler
+        @knife_ec_error_handler ||= Chef::Knife::EcErrorHandler.new(dest_dir, self.class)
+      end
+
       def user_acl_rest
         @user_acl_rest ||= if config[:skip_version]
                              rest

data/lib/chef/knife/ec_error_handler.rb

@@ -0,0 +1,114 @@
+# Author:: Jeremy Miller (<jmiller@chef.io>)
+# Copyright:: Copyright (c) 2017 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Chef
+  class Knife
+    # This class handles the errors that we might encounter on a
+    # backup or restore, it stors the errors inside a specific file
+    # inside the working directory.
+    class EcErrorHandler
+
+      attr_reader :err_file
+
+      # Creates a new instance of the EcErrorHandler to start
+      # adding errors during a backup or restore.
+      def initialize(working_dir, process)
+        @err_dir = "#{working_dir}/errors"
+        FileUtils.mkdir_p(@err_dir)
+
+        # Create an specific error file name depending
+        # of where the process comes from.
+        @err_file = if process == Chef::Knife::EcRestore
+                      File.join(@err_dir, "restore-#{Time.now.iso8601}.json")
+                    elsif process == Chef::Knife::EcBackup
+                      File.join(@err_dir, "backup-#{Time.now.iso8601}.json")
+                    else
+                      File.join(@err_dir, "other-#{Time.now.iso8601}.json")
+                    end
+
+        # exit handler
+        at_exit { display(@err_file) }
+      end
+
+      # Add an exception to the error file.
+      #
+      # For now we are writing all the errors to a single file, but
+      # in the future we would like to be able to generate a full path
+      # just as we do when we are backing up the Server, just that putting
+      # the file inside `{work_dir}/errors/{path}`
+      #
+      # Example:
+      # A failed user
+      # => {work_dir}/errors/users/afiune.json
+      # A failed cookbook
+      # => {work_dir}/errors/cookbooks/burger.json
+      # A failed environment
+      # => {work_dir}/errors/environment/dev.json
+      #
+      # The advantages of this schema is the ability to retry the backup or
+      # restore and pick up where we left.
+      def add(ex)
+        msg = {
+          timestamp:  Time.now,
+          message:    ex.message,
+          backtrace:  ex.backtrace,
+          exception:  ex.class
+        }
+
+        if ex.respond_to?(:chef_rest_request=) && ex.chef_rest_request
+          msg.merge!( {
+            req_path: ex.chef_rest_request.path,
+            req_method: ex.chef_rest_request.method
+          })
+        end
+
+        lock_file(@err_file, 'a') do |f|
+          f.write(Chef::JSONCompat.to_json_pretty(msg))
+        end
+      end
+
+      # Why lock the error file?
+      #
+      # Well because ec-backup has a concurrency options that
+      # will allow you to backup and restore things in parallel,
+      # therefor we need to ensure that only one process is
+      # writing to the error file.
+      def lock_file(file_name, mode)
+        File.open(file_name, mode) do |f|
+          begin
+            f.flock ::File::LOCK_EX
+            yield f
+          ensure
+            f.flock ::File::LOCK_UN
+          end
+        end
+      end
+
+      def display(file_name = @err_file)
+        # Print summary report only if error file exist
+        return unless File.exist?(file_name)
+
+        puts "\nError Summary Report"
+        lock_file(file_name, 'r') do |f|
+          f.each_line do |line|
+            puts line
+          end
+        end
+        puts "\nError(s) Summary file located at: '#{file_name}'"
+      end
+    end
+  end
+end

data/lib/chef/knife/ec_restore.rb

@@ -26,7 +26,7 @@ class Chef
         require 'chef/chef_fs/file_pattern'
         # Work around bug in chef_fs
         require 'chef/chef_fs/command_line'
-        require 'chef/chef_fs/file_system/acl_entry'
+        require 'chef/chef_fs/file_system/chef_server/acl_entry'
         require 'chef/chef_fs/data_handler/acl_data_handler'
         require 'securerandom'
         require 'chef/chef_fs/parallelizer'
@@ -63,11 +63,11 @@ class Chef
       def create_organization(orgname)
         org = JSONCompat.from_json(File.read("#{dest_dir}/organizations/#{orgname}/org.json"))
         rest.post('organizations', org)
-      rescue Net::HTTPServerException => e
-        if e.response.code == "409"
+      rescue Net::HTTPServerException => ex
+        if ex.response.code == "409"
           rest.put("organizations/#{orgname}", org)
         else
-          raise
+          knife_ec_error_handler.add(ex)
         end
       end
 
@@ -76,9 +76,10 @@ class Chef
         invitations.each do |invitation|
           begin
             rest.post("organizations/#{orgname}/association_requests", { 'user' => invitation['username'] })
-          rescue Net::HTTPServerException => e
-            if e.response.code != "409"
+          rescue Net::HTTPServerException => ex
+            if ex.response.code != "409"
               ui.error("Cannot create invitation #{invitation['id']}")
+              knife_ec_error_handler.add(ex)
             end
           end
         end
@@ -92,10 +93,8 @@ class Chef
             response = rest.post("organizations/#{orgname}/association_requests", { 'user' => username })
             association_id = response["uri"].split("/").last
             rest.put("users/#{username}/association_requests/#{association_id}", { 'response' => 'accept' })
-          rescue Net::HTTPServerException => e
-            if e.response.code != "409"
-              raise
-            end
+          rescue Net::HTTPServerException => ex
+            knife_ec_error_handler.add(ex) if ex.response.code != "409"
           end
         end
       end
@@ -137,12 +136,12 @@ class Chef
             user_with_password = user.dup
             user_with_password['password'] = SecureRandom.hex
             rest.post('users', user_with_password)
-          rescue Net::HTTPServerException => e
-            if e.response.code == "409"
+          rescue Net::HTTPServerException => ex
+            if ex.response.code == "409"
               rest.put("users/#{name}", user)
-            else
-              raise
+              next
             end
+            knife_ec_error_handler.add(ex)
           end
         end
         purge_users_on_restore
@@ -245,10 +244,7 @@ class Chef
           end
 
           ['/acls/groups/billing-admins.json', '/acls/groups/public_key_read_access.json'].each do |acl|
-            pattern = Chef::ChefFS::FilePattern.new(acl)
-            Chef::ChefFS::FileSystem.copy_to(pattern, chef_fs_config.local_fs,
-                                           chef_fs_config.chef_fs, nil, config, ui,
-                                           proc { |entry| chef_fs_config.format_path(entry)})
+            chef_fs_copy_pattern(acl, chef_fs_config)
           end
 
           Chef::Config.node_name = if config[:skip_version]
@@ -276,7 +272,7 @@ class Chef
           # - groups must be uploaded twice to account for Chef Server versions that don't
           #   accept group members on POST
           (top_level_paths + group_paths*2 + group_acl_paths + acl_paths).each do |path|
-            Chef::ChefFS::FileSystem.copy_to(Chef::ChefFS::FilePattern.new(path), chef_fs_config.local_fs, chef_fs_config.chef_fs, nil, config, ui, proc { |entry| chef_fs_config.format_path(entry) })
+            chef_fs_copy_pattern(path, chef_fs_config)
           end
 
           # restore clients to groups, using the pivotal user again
@@ -289,6 +285,23 @@ class Chef
         end
       end
 
+      # ChefFS copy pattern inside the EcRestore class will
+      # copy from the local_fs to the Chef Server.
+      #
+      # NOTE: Do not get confused, this is the other way around
+      # from how we implemented in EcBackup. Therefor we can't
+      # abstract it inside EcBase.
+      def chef_fs_copy_pattern(pattern_str, chef_fs_config)
+        ui.msg "Copying #{pattern_str}"
+        pattern = Chef::ChefFS::FilePattern.new(pattern_str)
+        Chef::ChefFS::FileSystem.copy_to(pattern, chef_fs_config.local_fs,
+                                         chef_fs_config.chef_fs, nil,
+                                         config, ui,
+                                         proc { |entry| chef_fs_config.format_path(entry) })
+      rescue Net::HTTPServerException => ex
+        knife_ec_error_handler.add(ex)
+      end
+
       # Takes an array of group objects
       # and topologically sorts them
       def sort_groups_for_upload(groups)
@@ -347,6 +360,8 @@ class Chef
             rest.put("#{url}/#{permission}", { permission => acls[permission] })
           end
         end
+      rescue Net::HTTPServerException => ex
+        knife_ec_error_handler.add(ex)
       end
     end
   end

data/lib/chef/server.rb

@@ -1,5 +1,6 @@
 require 'uri'
 require 'openssl'
+require 'chef/server_api'
 
 class Chef
   class Server
@@ -29,7 +30,7 @@ class Chef
     end
 
     def direct_account_access?
-      Chef::REST.new("http://127.0.0.1:9465").get("users")
+      Chef::ServerAPI.new("http://127.0.0.1:9465").get("users")
       true
     rescue
       false

data/lib/knife_ec_backup/version.rb

@@ -1,3 +1,3 @@
 module KnifeECBackup
-  VERSION = '2.1.0'
+  VERSION = '2.2.0'
 end

data/spec/chef/knife/ec_backup_spec.rb

@@ -3,6 +3,7 @@ require 'chef/knife/ec_backup'
 require 'fakefs/spec_helpers'
 
 describe Chef::Knife::EcBackup do
+  let(:dest_dir) { Dir.mktmpdir }
   USER_RESPONSE = {
     "foo" => "organizations/bar/users/foo",
     "bar" => "organizations/bar/users/bar"
@@ -30,9 +31,10 @@ describe Chef::Knife::EcBackup do
   before(:each) do
     Chef::Knife::EcBackup.load_deps
     @knife = Chef::Knife::EcBackup.new
-    @rest = double('Chef::Rest')
+    @rest = double('Chef::ServerAPI')
     allow(@knife).to receive(:rest).and_return(@rest)
     allow(@knife).to receive(:user_acl_rest).and_return(@rest)
+    allow_any_instance_of(Chef::Knife::EcBase).to receive(:dest_dir).and_return(dest_dir)
   end
 
   describe "#for_each_user" do
@@ -40,6 +42,18 @@ describe Chef::Knife::EcBackup do
       allow(@rest).to receive(:get).with("/users").and_return(USER_RESPONSE)
       expect{ |b| @knife.for_each_user(&b) }.to yield_successive_args(["foo", USER_RESPONSE["foo"]], ["bar", USER_RESPONSE["bar"]])
     end
+
+    context "when there are HTTP failures" do
+      let(:ec_error_handler) { double("Chef::Knife::EcErrorHandler") }
+
+      it "adds exceptions to error handler" do
+        exception = net_exception(500)
+        allow(Chef::Knife::EcErrorHandler).to receive(:new).and_return(ec_error_handler)
+        allow(@rest).to receive(:get).with("/users").and_raise(exception)
+        expect(ec_error_handler).to receive(:add).at_least(1).with(exception)
+        @knife.for_each_user
+      end
+    end
   end
 
   describe "#for_each_organization" do
@@ -71,12 +85,39 @@ describe Chef::Knife::EcBackup do
       expect{ |b| @knife.for_each_organization(&b) }.to yield_successive_args(org_response("bar"),
                                                                               org_response("foo", true))
     end
+
+    context "when there are HTTP failures" do
+      let(:ec_error_handler) { double("Chef::Knife::EcErrorHandler") }
+
+      before(:each) do
+        server = double('Chef::Server')
+        allow(Chef::Server).to receive(:new).and_return(server)
+        allow(Chef::Knife::EcErrorHandler).to receive(:new).and_return(ec_error_handler)
+        allow(server).to receive(:version).and_return(Gem::Version.new("12.0.0"))
+      end
+
+      it "adds exception and continues with the rest of the orgs" do
+        exception = net_exception(404)
+        allow(@rest).to receive(:get).with("organizations/foo").and_return(org_response("foo"))
+        allow(@rest).to receive(:get).with("organizations/bar").and_raise(exception)
+        expect(ec_error_handler).to receive(:add).at_least(1).with(exception)
+        expect{ |b| @knife.for_each_organization(&b) }.to yield_successive_args(org_response("foo"))
+      end
+
+      it "adds exceptions to error handler" do
+        allow(@rest).to receive(:get).with("organizations/foo").and_raise(net_exception(500))
+        allow(@rest).to receive(:get).with("organizations/bar").and_raise(net_exception(404))
+        expect(ec_error_handler).to receive(:add).at_least(2)
+        @knife.for_each_organization
+      end
+    end
   end
 
   describe "#download_user" do
     include FakeFS::SpecHelpers
     let (:username) { "foo" }
     let (:url) { "users/foo" }
+    before(:each) { FileUtils.mkdir_p(File.join(dest_dir, "users")) }
 
     it "downloads a named user from the api" do
       expect(@rest).to receive(:get).with(url)
@@ -87,13 +128,14 @@ describe Chef::Knife::EcBackup do
       user_response = {"username" => "foo"}
       allow(@rest).to receive(:get).with(url).and_return(user_response)
       @knife.download_user(username, url)
-      expect(JSON.parse(File.read("/users/foo.json"))).to eq(user_response)
+      expect(JSON.parse(File.read("#{dest_dir}/users/foo.json"))).to eq(user_response)
     end
   end
 
   describe "#download_user_acl" do
     include FakeFS::SpecHelpers
     let (:username) {"foo"}
+    before(:each) { FileUtils.mkdir_p(File.join(dest_dir, "user_acls")) }
 
     it "downloads a user acl from the API" do
       expect(@rest).to receive(:get).with("users/#{username}/_acl")
@@ -104,7 +146,19 @@ describe Chef::Knife::EcBackup do
       user_acl_response = {"create" => {}}
       allow(@rest).to receive(:get).with("users/#{username}/_acl").and_return(user_acl_response)
       @knife.download_user_acl(username)
-      expect(JSON.parse(File.read("/user_acls/foo.json"))).to eq(user_acl_response)
+      expect(JSON.parse(File.read("#{dest_dir}/user_acls/foo.json"))).to eq(user_acl_response)
+    end
+
+    context "when there are HTTP failures" do
+      let(:ec_error_handler) { double("Chef::Knife::EcErrorHandler") }
+
+      it "adds exceptions to error handler" do
+        exception = net_exception(500)
+        allow(Chef::Knife::EcErrorHandler).to receive(:new).and_return(ec_error_handler)
+        allow(@rest).to receive(:get).with("users/#{username}/_acl").and_raise(exception)
+        expect(ec_error_handler).to receive(:add).at_least(1).with(exception)
+        @knife.download_user_acl(username)
+      end
     end
   end
 
@@ -113,7 +167,7 @@ describe Chef::Knife::EcBackup do
     it "writes the given object to disk" do
       org_object = { "name" => "bob" }
       @knife.write_org_object_to_disk(org_object)
-      expect(JSON.parse(File.read("/organizations/bob/org.json"))).to eq(org_object)
+      expect(JSON.parse(File.read("#{dest_dir}/organizations/bob/org.json"))).to eq(org_object)
     end
   end
 
@@ -137,8 +191,21 @@ describe Chef::Knife::EcBackup do
     it "writes the org members to a JSON file" do
       expect(@rest).to receive(:get).with("/organizations/bob/users").and_return(users)
       @knife.download_org_members("bob")
-      expect(JSON.parse(File.read("/organizations/bob/members.json"))).to eq(users)
+      expect(JSON.parse(File.read("#{dest_dir}/organizations/bob/members.json"))).to eq(users)
     end
+
+    context "when there are HTTP failures" do
+      let(:ec_error_handler) { double("Chef::Knife::EcErrorHandler") }
+
+      it "adds exceptions to error handler" do
+        exception = net_exception(500)
+        allow(Chef::Knife::EcErrorHandler).to receive(:new).and_return(ec_error_handler)
+        allow(@rest).to receive(:get).with("/organizations/bob/users").and_raise(exception)
+        expect(ec_error_handler).to receive(:add).at_least(1).with(exception)
+        @knife.download_org_members("bob")
+      end
+    end
+
   end
 
   describe "#download_org_inivitations" do
@@ -152,7 +219,19 @@ describe Chef::Knife::EcBackup do
     it "writes the invitations to a JSON file" do
       expect(@rest).to receive(:get).with("/organizations/bob/association_requests").and_return(invites)
       @knife.download_org_invitations("bob")
-      expect(JSON.parse(File.read("/organizations/bob/invitations.json"))).to eq(invites)
+      expect(JSON.parse(File.read("#{dest_dir}/organizations/bob/invitations.json"))).to eq(invites)
+    end
+
+    context "when there are HTTP failures" do
+      let(:ec_error_handler) { double("Chef::Knife::EcErrorHandler") }
+
+      it "adds exceptions to error handler" do
+        exception = net_exception(500)
+        allow(Chef::Knife::EcErrorHandler).to receive(:new).and_return(ec_error_handler)
+        allow(@rest).to receive(:get).with("/organizations/bob/association_requests").and_raise(exception)
+        expect(ec_error_handler).to receive(:add).at_least(1).with(exception)
+        @knife.download_org_invitations("bob")
+      end
     end
   end
 end

data/spec/chef/knife/ec_error_handler_spec.rb

@@ -0,0 +1,88 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
+require 'chef/knife/ec_error_handler'
+require 'chef/knife/ec_backup'
+require 'chef/knife/ec_restore'
+require 'fakefs/spec_helpers'
+
+def net_exception(code)
+  s = double("status", :code => code.to_s)
+  Net::HTTPServerException.new("I'm not real!", s)
+end
+
+describe Chef::Knife::EcErrorHandler do
+  let(:dest_dir) { Dir.mktmpdir }
+  let(:err_dir)  { File.join(dest_dir, "errors") }
+
+  before(:each) do
+    allow(Time).to receive(:now).and_return(Time.new(1988, 04, 17, 0, 0, 0, "+00:00")) #=> 1988-04-17 00:00:00 +0000
+    @knife_ec_error_handler = described_class.new(dest_dir, Class)
+  end
+
+  describe "#initialize" do
+    it "creates an error directory" do
+      expect(FileUtils).to receive(:mkdir_p).with("#{dest_dir}/errors")
+      described_class.new(dest_dir, Class)
+    end
+
+    it "sets up an err_file depending of the class that comes from" do
+      ec_backup = described_class.new(dest_dir, Chef::Knife::EcBackup)
+      expect(ec_backup.err_file).to match File.join(err_dir, "backup-1988-04-17T00:00:00+00:00.json")
+      ec_restore = described_class.new(dest_dir, Chef::Knife::EcRestore)
+      expect(ec_restore.err_file).to match File.join(err_dir, "restore-1988-04-17T00:00:00+00:00.json")
+      ec_other = described_class.new(dest_dir, Class)
+      expect(ec_other.err_file).to match File.join(err_dir, "other-1988-04-17T00:00:00+00:00.json")
+    end
+  end
+
+  it "#display" do
+    @knife_ec_error_handler.add(net_exception(123))
+    expect { @knife_ec_error_handler.display }.to output(/
+Error Summary Report
+{
+  "timestamp": "1988-04-17 00:00:00 \+0000",
+  "message": "I'm not real!",
+  "backtrace": null,
+  "exception": "Net::HTTPServerException"
+}
+/).to_stdout
+  end
+
+  it "#add" do
+    mock_content = <<-EOF
+{
+  "timestamp": "1988-04-17 00:00:00 +0000",
+  "message": "I'm not real!",
+  "backtrace": null,
+  "exception": "Net::HTTPServerException"
+}{
+  "timestamp": "1988-04-17 00:00:00 +0000",
+  "message": "I'm not real!",
+  "backtrace": null,
+  "exception": "Net::HTTPServerException"
+}{
+  "timestamp": "1988-04-17 00:00:00 +0000",
+  "message": "I'm not real!",
+  "backtrace": null,
+  "exception": "Net::HTTPServerException"
+}{
+  "timestamp": "1988-04-17 00:00:00 +0000",
+  "message": "I'm not real!",
+  "backtrace": null,
+  "exception": "Net::HTTPServerException"
+}
+EOF
+    err_file = @knife_ec_error_handler.err_file
+    expect(Chef::JSONCompat).to receive(:to_json_pretty)
+      .at_least(4)
+      .and_call_original
+    expect(File).to receive(:open)
+      .at_least(4)
+      .with(err_file, "a")
+      .and_call_original
+    @knife_ec_error_handler.add(net_exception(500))
+    @knife_ec_error_handler.add(net_exception(409))
+    @knife_ec_error_handler.add(net_exception(404))
+    @knife_ec_error_handler.add(net_exception(123))
+    expect(File.read(err_file)).to match mock_content.strip
+  end
+end

data/spec/chef/knife/ec_key_base_spec.rb

@@ -9,25 +9,26 @@ describe Chef::Knife::EcKeyBase do
   let (:knife) { Chef::Knife::KeyBaseTester.new }
 
   let(:running_server_postgresql_sql_config_json) {
-    '{"private_chef": { "opscode-erchef":{}, "postgresql": { "sql_user": "jiminy", "sql_password": "secret"} }}'
+    '{"private_chef": { "opscode-erchef":{}, "postgresql": { "sql_user": "jiminy", "sql_password": "secret"} }, "postgresql": { "sql_user": "jiminy", "sql_password": "secret"} }'
   }
 
 
   let(:running_server_erchef_config_json) {
-    '{"private_chef": { "opscode-erchef": { "sql_user": "cricket", "sql_password": "secrete"}, "postgresql" : {} }}'
+    '{"private_chef": { "opscode-erchef": { "sql_user": "cricket", "sql_password": "secrete"}}, "opscode_erchef": { "sql_user": "cricket", "sql_password": "secrete"}}'
   }
   describe "#load_config_from_file!" do
     before(:each) do
       allow(File).to receive(:exists?).and_return(true)
+      allow(File).to receive(:size).and_return(1)
     end
     it "correctly sets sql options when they live under postgresql settings" do
-      allow(File).to receive(:read).and_return(running_server_postgresql_sql_config_json)
+      allow(IO).to receive(:read).and_return(running_server_postgresql_sql_config_json)
       knife.load_config_from_file!
       expect(knife.config[:sql_user]).to eq("jiminy")
       expect(knife.config[:sql_password]).to eq("secret")
     end
     it "correctly sets sql options when they live under opscode-erchef settings" do
-      allow(File).to receive(:read).and_return(running_server_erchef_config_json)
+      allow(IO).to receive(:read).and_return(running_server_erchef_config_json)
       knife.load_config_from_file!
       expect(knife.config[:sql_user]).to eq("cricket")
       expect(knife.config[:sql_password]).to eq("secrete")

data/spec/chef/knife/ec_restore_spec.rb

@@ -23,7 +23,7 @@ describe Chef::Knife::EcRestore do
   before(:each) do
     Chef::Knife::EcRestore.load_deps
     @knife = Chef::Knife::EcRestore.new
-    @rest = double('Chef::Rest')
+    @rest = double('Chef::ServerAPI')
     allow(@knife).to receive(:rest).and_return(@rest)
     allow(@knife).to receive(:user_acl_rest).and_return(@rest)
   end
@@ -134,6 +134,19 @@ describe Chef::Knife::EcRestore do
       expect(@rest).to receive(:put).with("users/jane", {"username" => "jane"})
       @knife.restore_users
     end
+
+    context "when there are HTTP failures with different code than 409" do
+      let(:ec_error_handler) { double("Chef::Knife::EcErrorHandler") }
+
+      it "adds exceptions to error handler" do
+        make_user "jane"
+        exception = net_exception(500)
+        allow(Chef::Knife::EcErrorHandler).to receive(:new).and_return(ec_error_handler)
+        allow(@rest).to receive(:post).with("users", anything).and_raise(exception)
+        expect(ec_error_handler).to receive(:add).at_least(1).with(exception)
+        @knife.restore_users
+      end
+    end
   end
 
   describe "#restore_group" do

data/spec/chef/server_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
 require 'chef/server'
-require 'chef/rest'
+require 'chef/server_api'
 require 'stringio'
 
 describe Chef::Server do
@@ -35,7 +35,7 @@ describe Chef::Server do
   it "knows when account is directly accessible" do
     s = Chef::Server.new("http://api.example.com")
     rest = double('rest')
-    allow(Chef::REST).to receive(:new).and_return(rest)
+    allow(Chef::ServerAPI).to receive(:new).and_return(rest)
     allow(rest).to receive(:get).and_return("")
     expect(s.direct_account_access?).to eq(true)
   end
@@ -43,7 +43,7 @@ describe Chef::Server do
   it "knows when account is not directly accessible" do
     s = Chef::Server.new("http://api.example.com")
     rest = double('rest')
-    allow(Chef::REST).to receive(:new).and_return(rest)
+    allow(Chef::ServerAPI).to receive(:new).and_return(rest)
     allow(rest).to receive(:get).and_raise(Errno::ECONNREFUSED)
     expect(s.direct_account_access?).to eq(false)
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knife-ec-backup
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - John Keiser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-25 00:00:00.000000000 Z
+date: 2017-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -79,6 +79,7 @@ files:
 - Rakefile
 - lib/chef/knife/ec_backup.rb
 - lib/chef/knife/ec_base.rb
+- lib/chef/knife/ec_error_handler.rb
 - lib/chef/knife/ec_key_base.rb
 - lib/chef/knife/ec_key_export.rb
 - lib/chef/knife/ec_key_import.rb
@@ -89,6 +90,7 @@ files:
 - lib/knife_ec_backup/version.rb
 - spec/chef/knife/ec_backup_spec.rb
 - spec/chef/knife/ec_base_spec.rb
+- spec/chef/knife/ec_error_handler_spec.rb
 - spec/chef/knife/ec_key_base_spec.rb
 - spec/chef/knife/ec_key_export_spec.rb
 - spec/chef/knife/ec_key_import_spec.rb
@@ -116,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Backup and Restore of Enterprise Chef