knife-essentials 0.9.4 → 0.9.5

data/lib/chef_fs/file_system/acls_dir.rb

@@ -0,0 +1,66 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, 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.
+#
+
+require 'chef_fs/file_system/base_fs_dir'
+require 'chef_fs/file_system/acl_dir'
+require 'chef_fs/file_system/cookbooks_acl_dir'
+require 'chef_fs/file_system/acl_entry'
+require 'chef_fs/data_handler/acl_data_handler'
+
+module ChefFS
+  module FileSystem
+    class AclsDir < BaseFSDir
+      ENTITY_TYPES = %w(clients containers cookbooks data_bags environments groups nodes roles) # we don't read sandboxes, so we don't read their acls
+
+      def initialize(parent)
+        super('acls', parent)
+      end
+
+      def data_handler
+        @data_handler ||= ChefFS::DataHandler::AclDataHandler.new
+      end
+
+      def api_path
+        parent.api_path
+      end
+
+      def can_have_child?(name, is_dir)
+        is_dir ? ENTITY_TYPES.include(name) : name == 'organization.json'
+      end
+
+      def children
+        if @children.nil?
+          @children = ENTITY_TYPES.map do |entity_type|
+            case entity_type
+            when 'cookbooks'
+              CookbooksAclDir.new(entity_type, self)
+            else
+              AclDir.new(entity_type, self)
+            end
+          end
+          @children << AclEntry.new('organization.json', self, true) # the org acl is retrieved as GET /organizations/ORGNAME/ANYTHINGATALL/_acl
+        end
+        @children
+      end
+
+      def rest
+        parent.rest
+      end
+    end
+  end
+end

data/lib/chef_fs/file_system/base_fs_object.rb

@@ -103,11 +103,6 @@ module ChefFS
         []
       end
 
-      def chef_hash
-        raise NotFoundError.new(self) if !exists?
-        nil
-      end
-
       # Expand this entry into a chef object (Chef::Role, ::Node, etc.)
       def chef_object
         raise NotFoundError.new(self) if !exists?
@@ -176,75 +171,6 @@ module ChefFS
       # Important directory attributes: name, parent, path, root
       # Overridable attributes: dir?, child(name), path_for_printing
       # Abstract: read, write, delete, children, can_have_child?, create_child, compare_to
-
-      # Consider putting this into a concern module and including it instead
-      def raw_request(_api_path)
-        self.class.api_request(rest, :GET, rest.create_url(_api_path), {}, false)
-      end
-
-
-      class << self
-        # Copied so that it does not automatically inflate an object
-        # This is also used by knife raw_essentials
-
-        ACCEPT_ENCODING = "Accept-Encoding".freeze
-        ENCODING_GZIP_DEFLATE = "gzip;q=1.0,deflate;q=0.6,identity;q=0.3".freeze
-
-        def redirected_to(response)
-          return nil  unless response.kind_of?(Net::HTTPRedirection)
-          # Net::HTTPNotModified is undesired subclass of Net::HTTPRedirection so test for this
-          return nil  if response.kind_of?(Net::HTTPNotModified)
-          response['location']
-        end
-
-
-        def build_headers(chef_rest, method, url, headers={}, json_body=false, raw=false)
-          #        headers                 = @default_headers.merge(headers)
-          #headers['Accept']       = "application/json" unless raw
-          headers['Accept']       = "application/json" unless raw
-          headers["Content-Type"] = 'application/json' if json_body
-          headers['Content-Length'] = json_body.bytesize.to_s if json_body
-          headers[Chef::REST::RESTRequest::ACCEPT_ENCODING] = Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE
-          headers.merge!(chef_rest.authentication_headers(method, url, json_body)) if chef_rest.sign_requests?
-          headers.merge!(Chef::Config[:custom_http_headers]) if Chef::Config[:custom_http_headers]
-          headers
-        end
-
-        def api_request(chef_rest, method, url, headers={}, data=false)
-          json_body = data
-          #        json_body = data ? Chef::JSONCompat.to_json(data) : nil
-          # Force encoding to binary to fix SSL related EOFErrors
-          # cf. http://tickets.opscode.com/browse/CHEF-2363
-          # http://redmine.ruby-lang.org/issues/5233
-          #        json_body.force_encoding(Encoding::BINARY) if json_body.respond_to?(:force_encoding)
-          headers = build_headers(chef_rest, method, url, headers, json_body)
-
-          chef_rest.retriable_rest_request(method, url, json_body, headers) do |rest_request|
-            response = rest_request.call {|r| r.read_body}
-
-            response_body = chef_rest.decompress_body(response)
-
-            if response.kind_of?(Net::HTTPSuccess)
-                response_body
-            elsif redirect_location = redirected_to(response)
-              raise "Redirected to #{create_url(redirect_location)}"
-              follow_redirect {api_request(:GET, create_url(redirect_location))}
-            else
-              # have to decompress the body before making an exception for it. But the body could be nil.
-              response.body.replace(chef_rest.decompress_body(response)) if response.body.respond_to?(:replace)
-
-              if response['content-type'] =~ /json/
-                exception = response_body
-                msg = "HTTP Request Returned #{response.code} #{response.message}: "
-                msg << (exception["error"].respond_to?(:join) ? exception["error"].join(", ") : exception["error"].to_s)
-                Chef::Log.info(msg)
-              end
-              response.error!
-            end
-          end
-        end
-      end
-
     end # class BaseFsObject
   end
 end

data/lib/chef_fs/file_system/chef_repository_file_system_root_dir.rb

@@ -26,6 +26,9 @@ require 'chef_fs/data_handler/environment_data_handler'
 require 'chef_fs/data_handler/node_data_handler'
 require 'chef_fs/data_handler/role_data_handler'
 require 'chef_fs/data_handler/user_data_handler'
+require 'chef_fs/data_handler/group_data_handler'
+require 'chef_fs/data_handler/container_data_handler'
+require 'chef_fs/data_handler/acl_data_handler'
 
 module ChefFS
   module FileSystem
@@ -89,6 +92,12 @@ module ChefFS
               ChefFS::DataHandler::RoleDataHandler.new
             when 'users'
               ChefFS::DataHandler::UserDataHandler.new
+            when 'groups'
+              ChefFS::DataHandler::GroupDataHandler.new
+            when 'containers'
+              ChefFS::DataHandler::ContainerDataHandler.new
+            when 'acls'
+              ChefFS::DataHandler::AclDataHandler.new
             else
               raise "Unknown top level path #{name}"
             end

data/lib/chef_fs/file_system/chef_server_root_dir.rb

@@ -16,6 +16,7 @@
 # limitations under the License.
 #
 
+require 'chef_fs/file_system/acls_dir'
 require 'chef_fs/file_system/base_fs_dir'
 require 'chef_fs/file_system/rest_list_dir'
 require 'chef_fs/file_system/cookbooks_dir'
@@ -26,17 +27,19 @@ require 'chef/rest'
 require 'chef_fs/data_handler/client_data_handler'
 require 'chef_fs/data_handler/role_data_handler'
 require 'chef_fs/data_handler/user_data_handler'
+require 'chef_fs/data_handler/group_data_handler'
+require 'chef_fs/data_handler/container_data_handler'
 
 module ChefFS
   module FileSystem
     class ChefServerRootDir < BaseFSDir
-      def initialize(root_name, chef_config, repo_mode)
+      def initialize(root_name, chef_config)
         super("", nil)
         @chef_server_url = chef_config[:chef_server_url]
         @chef_username = chef_config[:node_name]
         @chef_private_key = chef_config[:client_key]
         @environment = chef_config[:environment]
-        @repo_mode = repo_mode
+        @repo_mode = chef_config[:repo_mode]
         @root_name = root_name
       end
 
@@ -62,6 +65,14 @@ module ChefFS
         is_dir && children.any? { |child| child.name == name }
       end
 
+      def org
+        @org ||= if URI.parse(chef_server_url).path =~ /^\/+organizations\/+([^\/]+)$/
+          $1
+        else
+          nil
+        end
+      end
+
       def children
         @children ||= begin
           result = [
@@ -76,6 +87,14 @@ module ChefFS
               NodesDir.new(self),
               RestListDir.new("users", self, nil, ChefFS::DataHandler::UserDataHandler.new)
             ]
+          elsif repo_mode == 'hosted_everything'
+            result += [
+              AclsDir.new(self),
+              RestListDir.new("clients", self, nil, ChefFS::DataHandler::ClientDataHandler.new),
+              RestListDir.new("containers", self, nil, ChefFS::DataHandler::ContainerDataHandler.new),
+              RestListDir.new("groups", self, nil, ChefFS::DataHandler::GroupDataHandler.new),
+              NodesDir.new(self)
+            ]
           end
           result.sort_by { |child| child.name }
         end

data/lib/chef_fs/file_system/cookbook_dir.rb

@@ -185,7 +185,7 @@ module ChefFS
           old_retry_count = Chef::Config[:http_retry_count]
           begin
             Chef::Config[:http_retry_count] = 0
-            @chef_object ||= rest.get_rest(api_path)
+            @chef_object ||= Chef::CookbookVersion.json_create(ChefFS::RawRequest.raw_json(rest, api_path))
           ensure
             Chef::Config[:http_retry_count] = old_retry_count
           end

data/lib/chef_fs/file_system/cookbooks_acl_dir.rb

@@ -0,0 +1,39 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, 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.
+#
+
+require 'chef_fs/file_system/acl_dir'
+require 'chef_fs/file_system/acl_entry'
+
+module ChefFS
+  module FileSystem
+    class CookbooksAclDir < AclDir
+      # If versioned_cookbooks is on, the list of cookbooks will have versions
+      # in them.  But all versions of a cookbook have the same acl, so even if
+      # we have cookbooks/apache2-1.0.0 and cookbooks/apache2-1.1.2, we will
+      # only have one acl: acls/cookbooks/apache2.json.  Thus, the list of
+      # children of acls/cookbooks is a unique list of cookbook *names*.
+      def children
+        if @children.nil?
+          names = parent.parent.child(name).children.map { |child| "#{child.cookbook_name}.json" }
+          @children = names.uniq.map { |name| AclEntry.new(name, self, true) }
+        end
+        @children
+      end
+    end
+  end
+end

data/lib/chef_fs/file_system/cookbooks_dir.rb

@@ -18,6 +18,7 @@
 
 require 'chef_fs/file_system/rest_list_dir'
 require 'chef_fs/file_system/cookbook_dir'
+require 'chef_fs/raw_request'
 
 require 'tmpdir'
 
@@ -45,13 +46,13 @@ module ChefFS
         @children ||= begin
           if Chef::Config[:versioned_cookbooks]
             result = []
-            rest.get_rest("#{api_path}/?num_versions=all").each_pair do |cookbook_name, cookbooks|
+            ChefFS::RawRequest.raw_json(rest, "#{api_path}/?num_versions=all").each_pair do |cookbook_name, cookbooks|
               cookbooks['versions'].each do |cookbook_version|
                 result << CookbookDir.new("#{cookbook_name}-#{cookbook_version['version']}", self, :exists => true)
               end
             end
           else
-            result = rest.get_rest(api_path).keys.map { |cookbook_name| CookbookDir.new(cookbook_name, self, :exists => true) }
+            result = ChefFS::RawRequest.raw_json(rest, api_path).keys.map { |cookbook_name| CookbookDir.new(cookbook_name, self, :exists => true) }
           end
           result.sort_by(&:name)
         end

data/lib/chef_fs/file_system/data_bags_dir.rb

@@ -33,7 +33,7 @@ module ChefFS
 
       def children
         begin
-          @children ||= chef_collection.keys.sort.map do |entry|
+          @children ||= ChefFS::RawRequest.raw_json(rest, api_path).keys.sort.map do |entry|
             DataBagDir.new(entry, self, true)
           end
         rescue Net::HTTPServerException
@@ -45,10 +45,6 @@ module ChefFS
         end
       end
 
-      def chef_collection
-        rest.get_rest(api_path)
-      end
-
       def can_have_child?(name, is_dir)
         is_dir
       end

data/lib/chef_fs/file_system/nodes_dir.rb

@@ -28,9 +28,19 @@ module ChefFS
         super("nodes", parent, nil, ChefFS::DataHandler::NodeDataHandler.new)
       end
 
-      # Override to respond to environment
-      def chef_collection
-        rest.get_rest(env_api_path)
+      # Identical to RestListDir.children, except supports environments
+      def children
+        begin
+          @children ||= ChefFS::RawRequest.raw_json(rest, env_api_path).keys.sort.map do |key|
+            _make_child_entry("#{key}.json", true)
+          end
+        rescue Net::HTTPServerException => e
+          if $!.response.code == "404"
+            raise ChefFS::FileSystem::NotFoundError.new(self, $!)
+          else
+            raise ChefFS::FileSystem::OperationFailedError.new(:children, self, e), "HTTP error retrieving children: #{e}"
+          end
+        end
       end
 
       def env_api_path

data/lib/chef_fs/file_system/rest_list_dir.rb

@@ -44,7 +44,7 @@ module ChefFS
 
       def children
         begin
-          @children ||= chef_collection.keys.sort.map do |key|
+          @children ||= ChefFS::RawRequest.raw_json(rest, api_path).keys.sort.map do |key|
             _make_child_entry("#{key}.json", true)
           end
         rescue Net::HTTPServerException => e
@@ -56,16 +56,10 @@ module ChefFS
         end
       end
 
-      def chef_collection
-        rest.get_rest(api_path)
-      end
-
       def identity_key
         'name'
       end
 
-      # NOTE if you change this significantly, you will likely need to change
-      # DataBagDir.create_child as well.
       def create_child(name, file_contents)
         begin
           object = JSON.parse(file_contents, :create_additions => false)
@@ -97,6 +91,10 @@ module ChefFS
         result
       end
 
+      def org
+        parent.org
+      end
+
       def environment
         parent.environment
       end

data/lib/chef_fs/file_system/rest_list_entry.rb

@@ -19,6 +19,7 @@
 require 'chef_fs/file_system/base_fs_object'
 require 'chef_fs/file_system/not_found_error'
 require 'chef_fs/file_system/operation_failed_error'
+require 'chef_fs/raw_request'
 require 'chef/role'
 require 'chef/node'
 
@@ -45,6 +46,10 @@ module ChefFS
         "#{parent.api_path}/#{api_child_name}"
       end
 
+      def org
+        parent.org
+      end
+
       def environment
         parent.environment
       end
@@ -73,31 +78,26 @@ module ChefFS
       end
 
       def read
-        # Minimize the value so the results don't look terrible
-        Chef::JSONCompat.to_json_pretty(minimize_value(chef_hash))
-      end
-
-      def chef_hash
-        JSON.parse(raw_request(api_path), :create_additions => false)
-      rescue Net::HTTPServerException => e
-        if $!.response.code == "404"
-          raise ChefFS::FileSystem::NotFoundError.new(self, $!)
-        else
-          raise ChefFS::FileSystem::OperationFailedError.new(:read, self, e)
-        end
+        Chef::JSONCompat.to_json_pretty(_read_hash)
       end
 
-      def chef_object
+      def _read_hash
         begin
-          # REST will inflate the Chef object using json_class
-          rest.get_rest(api_path)
+          json = ChefFS::RawRequest.raw_request(rest, api_path)
         rescue Net::HTTPServerException => e
           if $!.response.code == "404"
             raise ChefFS::FileSystem::NotFoundError.new(self, $!)
           else
-            raise ChefFS::FileSystem::OperationFailedError.new(:read, self, e)
+            raise ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "HTTP error reading: #{e}"
           end
         end
+        # Minimize the value (get rid of defaults) so the results don't look terrible
+        minimize_value(JSON.parse(json, :create_additions => false))
+      end
+
+      def chef_object
+        # REST will inflate the Chef object using json_class
+        data_handler.json_class.json_create(read)
       end
 
       def minimize_value(value)
@@ -114,7 +114,7 @@ module ChefFS
 
         # Grab this value
         begin
-          value = chef_object.to_hash
+          value = _read_hash
         rescue ChefFS::FileSystem::NotFoundError
           return [ false, :none, other_value_json ]
         end
@@ -162,7 +162,7 @@ module ChefFS
           if e.response.code == "404"
             raise ChefFS::FileSystem::NotFoundError.new(self, e)
           else
-            raise ChefFS::FileSystem::OperationFailedError.new(:write, self, e)
+            raise ChefFS::FileSystem::OperationFailedError.new(:write, self, e), "HTTP error writing: #{e}"
           end
         end
       end