knife-ec-backup 1.2.0 → 2.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f715c068eec09039f7fb77be236223d14bd5bbb
-  data.tar.gz: 5d00a6295eda4e69bd2a1631ff0c651f737a870b
+  metadata.gz: 24f0f5bf6187090c18829999dd6ae339b8f97f44
+  data.tar.gz: c90dc04b94f007fb059a03021e2d951411e60d92
 SHA512:
-  metadata.gz: bb98c58235cb8bc54b5ddbe810afea0c11a55fe9db47eced86203bb3aea403f545ee438917af54706dc873b1a73b32bf3866bdc52128702f015ca3e7fd9c6b65
-  data.tar.gz: 7e27ada33d2a6424880d54e6e924b1336e677cc8125403c064edb2708fed90c91e1d0cd27914391f5d02354e31fe09ad48ac2aec8f4093dd3980e2449215ff87
+  metadata.gz: d8f804e4a2a9bcc0486c86f618af446f3d8cea3a8ce002a39705db49652d6301ac5d68d65b1224c0f5b2db60a8eca620b50c0012a3fabff08ce40762555f1389
+  data.tar.gz: 0c5f596befa740f26deb0b7bc4bc50065333904d039ce22ded2e9bf02768e5c0475660c4a2d7723d1359901372a58b50463408b2683b6f6e9cfc56f65e469f69

data/README.md

@@ -6,9 +6,12 @@ This is an UNOFFICIAL and EXPERIMENTAL knife plugin intended to back up and rest
 
 # Requirements
 
-This knife plugin currently requires the Knife-Essentials gem to be installed in the same gemset. This requirement is currently hosted here:
+This knife plugin requires Chef 11.8+.
 
-    https://github.com/jkeiser/knife-essentials
+## Chef 10
+
+Users who are still using Chef 10 can use the most recent 1.x version
+of this gem.  Version 1.x additionally depends on knife-essentials.
 
 # Installation
 
@@ -16,7 +19,6 @@ This knife plugin currently requires the Knife-Essentials gem to be installed in
 This will install the plugin directly on the Chef Server:
 
     /opt/opscode/embedded/bin/gem install knife-ec-backup
-    /opt/opscode/embedded/bin/gem install knife-ec-backup
 
 ## Build from source
 Clone the git repository and run the following from inside:
@@ -118,4 +120,4 @@ Restores all data from a repository to an Enterprise Chef / Private Chef server.
 * Single org backups.
 * This plugin does **NOT** currently backup user passwords.  **They will have to be reset after a restore.**
 * This plugin does **NOT** currently restore user public keys.  **Private keys will have to be reset after a restore.**
-* This plugin does **NOT** currently restore custom user ACLs.  **It will revert back to default ACLs on a restore.**
+* This plugin does **NOT** currently restore custom user ACLs.  **It will revert back to default ACLs on a restore.**

data/lib/chef/knife/ec_backup.rb

@@ -25,21 +25,25 @@ class Chef
         :default => false,
         :description => "Whether to skip checking the Chef Server version.  This will also skip any auto-configured options"
 
+      option :with_user_sql,
+        :long => '--with-user-sql',
+        :description => 'Whether to try direct data base access for user export.  Required to properly handle passwords, keys, and USAGs'
+
       option :org,
         :long => '--only-org ORGNAME',
         :description => "Only back up objects in the named organization (default: all orgs)"
 
       deps do
-        require 'chef_fs/config'
-        require 'chef_fs/file_system'
-        require 'chef_fs/file_pattern'
-        require 'chef_fs/parallelizer'
+        require 'chef/chef_fs/config'
+        require 'chef/chef_fs/file_system'
+        require 'chef/chef_fs/file_pattern'
+        require 'chef/chef_fs/parallelizer'
       end
 
       def configure_chef
         super
         Chef::Config[:concurrency] = config[:concurrency].to_i if config[:concurrency]
-        ::ChefFS::Parallelizer.threads = (Chef::Config[:concurrency] || 10) - 1
+        Chef::ChefFS::Parallelizer.threads = (Chef::Config[:concurrency] || 10) - 1
       end
 
       def run
@@ -122,7 +126,6 @@ class Chef
 
         # Grab users
         puts "Grabbing users ..."
-
         ensure_dir("#{dest_dir}/users")
         ensure_dir("#{dest_dir}/user_acls")
 
@@ -141,6 +144,16 @@ class Chef
           end
         end
 
+        if config[:with_user_sql]
+          require 'chef/knife/ec_key_export'
+          Chef::Knife::EcKeyExport.deps
+          k = Chef::Knife::EcKeyExport.new
+          k.name_args = ["#{dest_dir}/key_dump.json"]
+          k.config[:sql_host] = "localhost"
+          k.config[:sql_port] = 5432
+          k.run
+        end
+
         # Download organizations
         ensure_dir("#{dest_dir}/organizations")
         rest.get_rest('/organizations').each_pair do |name, url|
@@ -174,16 +187,13 @@ class Chef
       end
 
       PATHS = %w(chef_repo_path cookbook_path environment_path data_bag_path role_path node_path client_path acl_path group_path container_path)
-      CONFIG_VARS = %w(chef_server_url chef_server_root custom_http_headers node_name client_key versioned_cookbooks) + PATHS
       def download_org(dest_dir, webui_key, name)
-        old_config = {}
-        CONFIG_VARS.each do |key|
-          old_config[key] = Chef::Config[key.to_sym]
-        end
+        old_config = Chef::Config.save
+
         begin
           # Clear out paths
-          PATHS.each do |path_var|
-            Chef::Config[path_var.to_sym] = nil
+          PATHS.each do |path|
+            Chef::Config.delete(path.to_sym)
           end
           Chef::Config.chef_repo_path = "#{dest_dir}/organizations/#{name}"
           Chef::Config.versioned_cookbooks = true
@@ -193,17 +203,17 @@ class Chef
           ensure_dir(Chef::Config.chef_repo_path)
 
           # Download the billing-admins ACL and group as pivotal
-          chef_fs_config = ::ChefFS::Config.new
-          pattern = ::ChefFS::FilePattern.new('/acls/groups/billing-admins.json') 
-          if ::ChefFS::FileSystem.copy_to(pattern, chef_fs_config.chef_fs, chef_fs_config.local_fs, nil, config, ui, proc { |entry| chef_fs_config.format_path(entry) })
+          chef_fs_config = Chef::ChefFS::Config.new
+          pattern = Chef::ChefFS::FilePattern.new('/acls/groups/billing-admins.json') 
+          if Chef::ChefFS::FileSystem.copy_to(pattern, chef_fs_config.chef_fs, chef_fs_config.local_fs, nil, config, ui, proc { |entry| chef_fs_config.format_path(entry) })
             @error = true
           end
-          pattern = ::ChefFS::FilePattern.new('/groups/billing-admins.json') 
-          if ::ChefFS::FileSystem.copy_to(pattern, chef_fs_config.chef_fs, chef_fs_config.local_fs, nil, config, ui, proc { |entry| chef_fs_config.format_path(entry) })
+          pattern = Chef::ChefFS::FilePattern.new('/groups/billing-admins.json') 
+          if Chef::ChefFS::FileSystem.copy_to(pattern, chef_fs_config.chef_fs, chef_fs_config.local_fs, nil, config, ui, proc { |entry| chef_fs_config.format_path(entry) })
             @error = true
           end
-          pattern = ::ChefFS::FilePattern.new('/groups/admins.json') 
-          if ::ChefFS::FileSystem.copy_to(pattern, chef_fs_config.chef_fs, chef_fs_config.local_fs, nil, config, ui, proc { |entry| chef_fs_config.format_path(entry) })
+          pattern = Chef::ChefFS::FilePattern.new('/groups/admins.json') 
+          if Chef::ChefFS::FileSystem.copy_to(pattern, chef_fs_config.chef_fs, chef_fs_config.local_fs, nil, config, ui, proc { |entry| chef_fs_config.format_path(entry) })
             @error = true
           end
 
@@ -217,19 +227,17 @@ class Chef
           Chef::Config.custom_http_headers = (Chef::Config.custom_http_headers || {}).merge({'x-ops-request-source' => 'web'})
 
           # Download the entire org skipping the billing admins group ACL and the group itself
-          chef_fs_config = ::ChefFS::Config.new
+          chef_fs_config = Chef::ChefFS::Config.new
           top_level_paths = chef_fs_config.chef_fs.children.select { |entry| entry.name != 'acls' && entry.name != 'groups' }.map { |entry| entry.path }
-          acl_paths = ::ChefFS::FileSystem.list(chef_fs_config.chef_fs, ::ChefFS::FilePattern.new('/acls/*')).select { |entry| entry.name != 'groups' }.map { |entry| entry.path }
-          group_acl_paths = ::ChefFS::FileSystem.list(chef_fs_config.chef_fs, ::ChefFS::FilePattern.new('/acls/groups/*')).select { |entry| entry.name != 'billing-admins.json' }.map { |entry| entry.path }
-          group_paths = ::ChefFS::FileSystem.list(chef_fs_config.chef_fs, ::ChefFS::FilePattern.new('/groups/*')).select { |entry| entry.name != 'billing-admins.json' }.map { |entry| entry.path }
+          acl_paths = Chef::ChefFS::FileSystem.list(chef_fs_config.chef_fs, Chef::ChefFS::FilePattern.new('/acls/*')).select { |entry| entry.name != 'groups' }.map { |entry| entry.path }
+          group_acl_paths = Chef::ChefFS::FileSystem.list(chef_fs_config.chef_fs, Chef::ChefFS::FilePattern.new('/acls/groups/*')).select { |entry| entry.name != 'billing-admins.json' }.map { |entry| entry.path }
+          group_paths = Chef::ChefFS::FileSystem.list(chef_fs_config.chef_fs, Chef::ChefFS::FilePattern.new('/groups/*')).select { |entry| entry.name != 'billing-admins.json' }.map { |entry| entry.path }
           (top_level_paths + group_acl_paths + acl_paths + group_paths).each do |path|
-            ::ChefFS::FileSystem.copy_to(::ChefFS::FilePattern.new(path), chef_fs_config.chef_fs, chef_fs_config.local_fs, nil, config, ui, proc { |entry| chef_fs_config.format_path(entry) })
+            Chef::ChefFS::FileSystem.copy_to(Chef::ChefFS::FilePattern.new(path), chef_fs_config.chef_fs, chef_fs_config.local_fs, nil, config, ui, proc { |entry| chef_fs_config.format_path(entry) })
           end
 
         ensure
-          CONFIG_VARS.each do |key|
-            Chef::Config[key.to_sym] = old_config[key]
-          end
+          Chef::Config.restore(old_config)
         end
       end
     end

data/lib/chef/knife/ec_key_base.rb

@@ -52,8 +52,9 @@ class Chef
 
       def db
         @db ||= begin
+                  require 'sequel'
                   server_string = "#{config[:sql_user]}:#{config[:sql_password]}@#{config[:sql_host]}:#{config[:sql_port]}/opscode_chef"
-                  Sequel.connect("postgres://#{server_string}")
+                  ::Sequel.connect("postgres://#{server_string}")
                 end
       end
 

data/lib/chef/knife/ec_key_export.rb

@@ -37,7 +37,7 @@ class Chef
       end
 
       def export(path)
-        users = db.select(:username, :public_key, :pubkey_version, :hashed_password, :salt, :hash_type).from(:users)
+        users = db.select(:username, :id, :public_key, :pubkey_version, :hashed_password, :salt, :hash_type).from(:users)
         File.open(path, 'w') { |file| file.write(users.all.to_json) }
       end
     end

data/lib/chef/knife/ec_key_import.rb

@@ -33,6 +33,12 @@ class Chef
         :boolean => true,
         :description => "Upload pivotal key.  By default the pivotal key is not uploaded."
 
+      option :skip_ids,
+        :long => "--[no-]skip-user-ids",
+        :default => true,
+        :boolean => true,
+        :description => "Upload user ids."
+
       def run
         if config[:sql_user].nil? || config[:sql_password].nil?
           load_config_from_file!
@@ -46,6 +52,7 @@ class Chef
       def import(path)
         key_data = JSON.parse(File.read(path))
         key_data.each do |d|
+          id = d['id']
           username = d['username']
           key = d['public_key']
           version = d['pubkey_version']
@@ -63,11 +70,14 @@ class Chef
           if users_to_update.count != 1
             ui.warn "Wrong number of users to update for #{username}. Skipping"
           else
-            users_to_update.update(:public_key => key,
-                                   :pubkey_version => version,
-                                   :salt => salt,
-                                   :hashed_password => hashed_password,
-                                   :hash_type => hash_type)
+            data = { :public_key => key,
+              :pubkey_version => version,
+              :salt => salt,
+              :hashed_password => hashed_password,
+              :hash_type => hash_type
+            }
+            data[:id] = id unless config[:skip_ids]
+            users_to_update.update(data)
           end
         end
       end

data/lib/chef/knife/ec_restore.rb

@@ -31,22 +31,36 @@ class Chef
         :default => false,
         :description => "Whether to skip checking the Chef Server version.  This will also skip any auto-configured options"
 
+      option :org,
+        :long => "--only-org ORG",
+        :description => "Only restore objects in the named organization (default: all orgs)"
+
+      option :skip_users,
+        :long => "--skip-users",
+        :description => "Skip restoring users"
+
+      option :with_user_sql,
+        :long => "--with-user-sql",
+        :description => "Restore user id's, passwords, and keys from sql export"
+
       deps do
         require 'chef/json_compat'
-        require 'chef_fs/config'
-        require 'chef_fs/file_system'
-        require 'chef_fs/file_pattern'
-        require 'chef_fs/file_system/acl_entry'
-        require 'chef_fs/data_handler/acl_data_handler'
+        require 'chef/chef_fs/config'
+        require 'chef/chef_fs/file_system'
+        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/data_handler/acl_data_handler'
         require 'securerandom'
-        require 'chef_fs/parallelizer'
+        require 'chef/chef_fs/parallelizer'
         require 'chef/tsorter'
       end
 
       def configure_chef
         super
         Chef::Config[:concurrency] = config[:concurrency].to_i if config[:concurrency]
-        ::ChefFS::Parallelizer.threads = (Chef::Config[:concurrency] || 10) - 1
+        Chef::ChefFS::Parallelizer.threads = (Chef::Config[:concurrency] || 10) - 1
       end
 
       def run
@@ -109,46 +123,22 @@ class Chef
               config[:skip_useracl] = true
               user_acl_rest = nil
             else
-              user_acl_rest = rest 
-            end             
+              user_acl_rest = rest
+            end
           else
             ui.warn("Unable to detect Chef Server version.")
           end
         end
 
-        # Restore users
-        puts "Restoring users ..."
-
         rest = Chef::REST.new(Chef::Config.chef_server_root)
-
-        Dir.foreach("#{dest_dir}/users") do |filename|
-          next if filename !~ /(.+)\.json/
-          name = $1
-          if name == 'pivotal' && !config[:overwrite_pivotal]
-            ui.warn("Skipping pivotal update.  To overwrite pivotal, pass --overwrite-pivotal.")
-            next
-          end
-
-          # Update user object
-          user = JSONCompat.from_json(IO.read("#{dest_dir}/users/#{name}.json"))
-          begin
-            # Supply password for new user
-            user_with_password = user.dup
-            user_with_password['password'] = SecureRandom.hex
-            rest.post_rest('users', user_with_password)
-          rescue Net::HTTPServerException => e
-            if e.response.code == "409"
-              rest.put_rest("users/#{name}", user)
-            else
-              raise
-            end
-          end
-
-        end
+        # Restore users
+        restore_users(dest_dir, rest) unless config[:skip_users]
+        restore_user_sql(dest_dir) if config[:with_user_sql]
 
         # Restore organizations
         Dir.foreach("#{dest_dir}/organizations") do |name|
           next if name == '..' || name == '.' || !File.directory?("#{dest_dir}/organizations/#{name}")
+          next unless (config[:org].nil? || config[:org] == name)
           puts "Restoring org #{name} ..."
 
           # Create organization
@@ -170,7 +160,7 @@ class Chef
               rest.post_rest("organizations/#{name}/association_requests", { 'user' => invitation['username'] })
             rescue Net::HTTPServerException => e
               if e.response.code != "409"
-                raise
+                ui.error("Cannot create invitation #{invitation['id']}")
               end
             end
           end
@@ -210,7 +200,7 @@ class Chef
 
           # Update user acl
           user_acl = JSONCompat.from_json(IO.read("#{dest_dir}/user_acls/#{name}.json"))
-          put_acl(rest, "users/#{name}/_acl", user_acl)          
+          put_acl(rest, "users/#{name}/_acl", user_acl)
         end
 
 
@@ -219,18 +209,54 @@ class Chef
         end
       end
 
+      def restore_users(dest_dir, rest)
+        puts "Restoring users ..."
+        Dir.foreach("#{dest_dir}/users") do |filename|
+          next if filename !~ /(.+)\.json/
+          name = $1
+          if name == 'pivotal' && !config[:overwrite_pivotal]
+            ui.warn("Skipping pivotal update.  To overwrite pivotal, pass --overwrite-pivotal.")
+            next
+          end
+          
+          # Update user object
+          user = JSONCompat.from_json(IO.read("#{dest_dir}/users/#{name}.json"))
+          begin
+            # Supply password for new user
+            user_with_password = user.dup
+            user_with_password['password'] = SecureRandom.hex
+            rest.post_rest('users', user_with_password)
+          rescue Net::HTTPServerException => e
+            if e.response.code == "409"
+              rest.put_rest("users/#{name}", user)
+            else
+              raise
+            end
+          end
+        end
+      end
+
+      def restore_user_sql(dest_dir)
+        require 'chef/knife/ec_key_import'
+        k = Chef::Knife::EcKeyImport.new
+        k.name_args = ["#{dest_dir}/key_dump.json"]
+        k.config[:skip_pivotal] = true
+        k.config[:skip_ids] = false
+        k.config[:sql_host] = "localhost"
+        k.config[:sql_port] = 5432
+        k.run
+      end
+
       PATHS = %w(chef_repo_path cookbook_path environment_path data_bag_path role_path node_path client_path acl_path group_path container_path)
-      CONFIG_VARS = %w(chef_server_url chef_server_root custom_http_headers node_name client_key versioned_cookbooks) + PATHS
       def upload_org(dest_dir, webui_key, name)
-        old_config = {}
-        CONFIG_VARS.each do |key|
-          old_config[key] = Chef::Config[key.to_sym]
-        end
+        old_config = Chef::Config.save
+
         begin
           # Clear out paths
-          PATHS.each do |path_var|
-            Chef::Config[path_var.to_sym] = nil
+          PATHS.each do |path|
+            Chef::Config.delete(path.to_sym)
           end
+
           Chef::Config.chef_repo_path = "#{dest_dir}/organizations/#{name}"
           Chef::Config.versioned_cookbooks = true
 
@@ -238,15 +264,15 @@ class Chef
 
           # Upload the admins group and billing-admins acls
           puts "Restoring the org admin data"
-          chef_fs_config = ::ChefFS::Config.new
+          chef_fs_config = Chef::ChefFS::Config.new
 
           # Restore users w/o clients (which don't exist yet)
           ['admins', 'billing-admins'].each do |group|
             restore_group(chef_fs_config, group, :clients => false)
           end
 
-          pattern = ::ChefFS::FilePattern.new('/acls/groups/billing-admins.json')
-          if ::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) })
+          pattern = Chef::ChefFS::FilePattern.new('/acls/groups/billing-admins.json')
+          if 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) })
             @error = true
           end
 
@@ -267,30 +293,28 @@ class Chef
 
           # Restore the entire org skipping the admin data and restoring groups and acls last
           puts "Restoring the rest of the org"
-          chef_fs_config = ::ChefFS::Config.new
+          chef_fs_config = Chef::ChefFS::Config.new
           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 = ::ChefFS::FileSystem.list(chef_fs_config.local_fs, ::ChefFS::FilePattern.new('/groups/*')).select { |entry| entry.name != 'billing-admins.json' }.map { |entry| JSON.parse(entry.read) }
+          unsorted_groups = Chef::ChefFS::FileSystem.list(chef_fs_config.local_fs, Chef::ChefFS::FilePattern.new('/groups/*')).select { |entry| entry.name != 'billing-admins.json' }.map { |entry| JSON.parse(entry.read) }
           group_paths = sort_groups_for_upload(unsorted_groups).map { |group_name| "/groups/#{group_name}.json" }
 
-          group_acl_paths = ::ChefFS::FileSystem.list(chef_fs_config.local_fs, ::ChefFS::FilePattern.new('/acls/groups/*')).select { |entry| entry.name != 'billing-admins.json' }.map { |entry| entry.path }
-          acl_paths = ::ChefFS::FileSystem.list(chef_fs_config.local_fs, ::ChefFS::FilePattern.new('/acls/*')).select { |entry| entry.name != 'groups' }.map { |entry| entry.path }
+          group_acl_paths = Chef::ChefFS::FileSystem.list(chef_fs_config.local_fs, Chef::ChefFS::FilePattern.new('/acls/groups/*')).select { |entry| entry.name != 'billing-admins.json' }.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 }
 
           (top_level_paths + group_paths + group_acl_paths + acl_paths).each do |path|
-            ::ChefFS::FileSystem.copy_to(::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::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) })
           end
           # restore clients to groups, using the pivotal key again
           Chef::Config[:node_name] = old_config['node_name']
-          Chef::Config[:client_key] = old_config['client_key'] 
+          Chef::Config[:client_key] = old_config['client_key']
           Chef::Config.custom_http_headers = {}
           ['admins', 'billing-admins'].each do |group|
-            restore_group(::ChefFS::Config.new, group)
+            restore_group(Chef::ChefFS::Config.new, group)
           end
          ensure
-          CONFIG_VARS.each do |key|
-            Chef::Config[key.to_sym] = old_config[key]
-          end
+          Chef::Config.restore(old_config)
         end
       end
 
@@ -316,13 +340,13 @@ class Chef
       def restore_group(chef_fs_config, group_name, includes = {:users => true, :clients => true})
         includes[:users] = true unless includes.key? :users
         includes[:clients] = true unless includes.key? :clients
-      
-        group = ::ChefFS::FileSystem.resolve_path(
+
+        group = Chef::ChefFS::FileSystem.resolve_path(
           chef_fs_config.chef_fs,
           "/groups/#{group_name}.json"
         )
 
-        members_json = ::ChefFS::FileSystem.resolve_path(
+        members_json = Chef::ChefFS::FileSystem.resolve_path(
           chef_fs_config.local_fs,
           "/groups/#{group_name}.json"
         ).read
@@ -336,20 +360,20 @@ class Chef
             member == 'clients'
           end
         end
-        
+
         group.write(members.to_json)
       end
 
       def parallelize(entries, options = {}, &block)
-        ::ChefFS::Parallelizer.parallelize(entries, options, &block)
+        Chef::ChefFS::Parallelizer.parallelize(entries, options, &block)
       end
 
       def put_acl(rest, url, acls)
         old_acls = rest.get_rest(url)
-        old_acls = ::ChefFS::DataHandler::AclDataHandler.new.normalize(old_acls, nil)
-        acls = ::ChefFS::DataHandler::AclDataHandler.new.normalize(acls, nil)
+        old_acls = Chef::ChefFS::DataHandler::AclDataHandler.new.normalize(old_acls, nil)
+        acls = Chef::ChefFS::DataHandler::AclDataHandler.new.normalize(acls, nil)
         if acls != old_acls
-          ::ChefFS::FileSystem::AclEntry::PERMISSIONS.each do |permission|
+          Chef::ChefFS::FileSystem::AclEntry::PERMISSIONS.each do |permission|
             rest.put_rest("#{url}/#{permission}", { permission => acls[permission] })
           end
         end

data/lib/knife_ec_backup/version.rb

@@ -1,3 +1,3 @@
 module KnifeECBackup
-  VERSION = '1.2.0'
+  VERSION = '2.0.0.beta.1'
 end

metadata

@@ -1,31 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: knife-ec-backup
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0.beta.1
 platform: ruby
 authors:
 - John Keiser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-19 00:00:00.000000000 Z
+date: 2014-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: knife-essentials
+  name: sequel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.6
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.6
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: sequel
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,19 +39,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pg
+  name: chef
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '11.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '11.8'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -113,12 +113,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Backup and Restore of Enterprise Chef