knife-ec-backup 2.0.6 → 2.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8a281b55227d745f186c3c9a9a471d274e078585
-  data.tar.gz: cc3f0d8ed0a83f0e4b00eab7713c51f670fec1a7
+  metadata.gz: b97714005f59fe60b36667b628c58f9de216f1e2
+  data.tar.gz: 8ba4fc5291580630844c140dea952c78d4a69db2
 SHA512:
-  metadata.gz: 0b58a4651be0b287f89ac2e2ec362db20f0193f17ce15dd6749591e26e71683b311933cf2a8ece1c1ba65be30398db844094dc6659344a570b0c60437b888133
-  data.tar.gz: 046df1b5018e9ff98cd44b47d7768df28de07562f166ab0d7c2962a6847f21b579c35189b1de777b9bb2277aa696673d1918cb466e59c26e201132f1d860e42f
+  metadata.gz: 49ea3afa7fa7ed54a318c828b235703fda5b38d28a171124ee4837efc43867ffecb4ff46b157c82aee9c7d93da65d39041f6aeb2f50f5792903e22d536e82f2c
+  data.tar.gz: 3443451e72baa28454cf805cfc8c20a241cc21bcf14ff286beb3d80e5caab8bc33d6c658f3191562d2ee0a59c5b8f482835be1b3028d15b272d7e2d433048af7

data/lib/chef/knife/ec_backup.rb

@@ -144,21 +144,23 @@ class Chef
 
           ensure_dir(Chef::Config.chef_repo_path)
 
-          # Download the billing-admins ACL and group as pivotal
+          # 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)
 
           # Set Chef::Config to use an organization administrator
           Chef::Config.node_name = org_admin
 
-          # Download the entire org skipping the billing admins group ACL and the group itself
+          # Download the entire org skipping the billing-admins, public_key_read_access group ACLs and the groups themselves
           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       = chef_fs_paths('/acls/*', chef_fs_config, 'groups')
-          group_acl_paths = chef_fs_paths('/acls/groups/*', chef_fs_config, 'billing-admins.json')
-          group_paths     = chef_fs_paths('/groups/*', chef_fs_config, 'billing-admins.json')
+          acl_paths       = chef_fs_paths('/acls/*', chef_fs_config, ['groups'])
+          group_acl_paths = chef_fs_paths('/acls/groups/*', chef_fs_config, ['billing-admins','public_key_read_access'])
+          group_paths     = chef_fs_paths('/groups/*', chef_fs_config, ['billing-admins','public_key_read_access'])
           (top_level_paths + group_acl_paths + acl_paths + group_paths).each do |path|
             chef_fs_copy_pattern(path, chef_fs_config)
           end
@@ -167,14 +169,19 @@ class Chef
         end
       end
 
-      def chef_fs_paths(pattern_str, chef_fs_config, exclude=nil)
+      def normalize_path_name(path)
+        path=~/\.json\z/ ? path : path<<'.json'
+      end
+
+      def chef_fs_paths(pattern_str, chef_fs_config, exclude=[])
         pattern = Chef::ChefFS::FilePattern.new(pattern_str)
         list = Chef::ChefFS::FileSystem.list(chef_fs_config.chef_fs, pattern)
-        list = list.select { |entry| entry.name != exclude } if ! exclude.nil?
-        list.map {|entry| entry.path }
+        list = list.select { |entry| ! exclude.include?(entry.name) } if ! exclude.empty?
+        list.map { |entry| normalize_path_name(entry.path) }
       end
 
       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.chef_fs,
                                          chef_fs_config.local_fs, nil,

data/lib/chef/knife/ec_restore.rb

@@ -193,11 +193,11 @@ class Chef
           Chef::Config.versioned_cookbooks = true
           Chef::Config.chef_server_url = "#{server.root_url}/organizations/#{name}"
 
-          # Upload the admins group and billing-admins acls
+          # Upload the admins, public_key_read_access and billing-admins groups and acls
           ui.msg "Restoring org admin data"
           chef_fs_config = Chef::ChefFS::Config.new
 
-          # Handle Admins and Billing Admins seperately
+          # Handle Admins, Billing Admins and Public Key Read Access seperately
           #
           # admins: We need to upload admins first so that we
           # can upload all of the other objects as a user in the org
@@ -213,14 +213,21 @@ class Chef
           # and then update it again once all of the clients and
           # groups are uploaded.
           #
-          ['admins', 'billing-admins'].each do |group|
+          # public_key_read_access: Similarly for public_key_read_access,
+          # the default permissions only give read/update to
+          # pivotal and members of the admins group. Use the same strategy
+          # above here.
+          #
+          ['admins', 'billing-admins', 'public_key_read_access'].each do |group|
             restore_group(chef_fs_config, group, :clients => false)
           end
 
-          pattern = Chef::ChefFS::FilePattern.new('/acls/groups/billing-admins.json')
-          Chef::ChefFS::FileSystem.copy_to(pattern, chef_fs_config.local_fs,
+          ['/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)})
+          end
 
           Chef::Config.node_name = org_admin
 
@@ -231,10 +238,10 @@ 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| 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| ! ['billing-admins.json', 'public_key_read_access.json'].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| entry.name != 'billing-admins.json' }.map { |entry| entry.path }
+          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 }
           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 }
 
 
@@ -249,7 +256,7 @@ class Chef
 
           # restore clients to groups, using the pivotal user again
           Chef::Config[:node_name] = 'pivotal'
-          ['admins', 'billing-admins'].each do |group|
+          ['admins', 'billing-admins', 'public_key_read_access'].each do |group|
             restore_group(Chef::ChefFS::Config.new, group)
           end
          ensure
@@ -285,6 +292,7 @@ class Chef
           "/groups/#{group_name}.json"
         )
 
+        # Will throw NotFoundError if JSON file does not exist on disk. See below.
         members_json = Chef::ChefFS::FileSystem.resolve_path(
           chef_fs_config.local_fs,
           "/groups/#{group_name}.json"
@@ -301,6 +309,8 @@ class Chef
         end
 
         group.write(members.to_json)
+      rescue Chef::ChefFS::FileSystem::NotFoundError
+        Chef::Log.warn "Could not find #{group.display_path} on disk. Will not restore."
       end
 
       def put_acl(rest, url, acls)

data/lib/knife_ec_backup/version.rb

@@ -1,3 +1,3 @@
 module KnifeECBackup
-  VERSION = '2.0.6'
+  VERSION = '2.0.7'
 end

data/spec/chef/knife/ec_restore_spec.rb

@@ -135,4 +135,15 @@ describe Chef::Knife::EcRestore do
       @knife.restore_users
     end
   end
+
+  describe "#restore_group" do
+    context "when group is not present in backup" do
+      let(:chef_fs_config) { Chef::ChefFS::Config.new }
+      let(:group_name) { "bad_group" }
+
+      it "does not raise error" do
+        expect { @knife.restore_group(chef_fs_config, group_name) }.not_to raise_error
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knife-ec-backup
 version: !ruby/object:Gem::Version
-  version: 2.0.6
+  version: 2.0.7
 platform: ruby
 authors:
 - John Keiser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-23 00:00:00.000000000 Z
+date: 2017-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -102,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Backup and Restore of Enterprise Chef