knife-essentials 0.9.2 → 0.9.3

data/lib/chef/knife/raw_essentials.rb

@@ -1,4 +1,5 @@
 require 'json'
+require 'chef_fs/data_handler/data_handler_base'
 
 class Chef
   class Knife
@@ -41,7 +42,7 @@ class Chef
         end
         chef_rest = Chef::REST.new(Chef::Config[:chef_server_url])
         begin
-          output api_request(chef_rest, config[:method].to_sym, chef_rest.create_url(name_args[0]), {}, data)
+          output ChefFS::FileSystem::BaseFSObject.api_request(chef_rest, config[:method].to_sym, chef_rest.create_url(name_args[0]), {}, data)
         rescue Net::HTTPServerException => e
           ui.error "Server responded with error #{e.response.code} \"#{e.response.message}\""
           ui.error "Error Body: #{e.response.body}" if e.response.body && e.response.body != ''
@@ -49,66 +50,7 @@ class Chef
         end
       end
 
-      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 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)
-            if config[:pretty] && response['content-type'] =~ /json/
-              JSON.pretty_generate(JSON.parse(response_body, :create_additions => false))
-            else
-              response_body
-            end
-          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
-
-      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
-    end
+    end # class Raw
   end
 end
 

data/lib/chef_fs/data_handler/data_handler_base.rb

@@ -105,6 +105,7 @@ module ChefFS
         end
         result
       end
-    end
+
+    end # class DataHandlerBase
   end
 end

data/lib/chef_fs/file_system/base_fs_object.rb

@@ -103,6 +103,11 @@ 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?
@@ -171,7 +176,76 @@ 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
-    end
+
+      # 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_entry.rb

@@ -1,5 +1,6 @@
 #
 # Author:: John Keiser (<jkeiser@opscode.com>)
+# Author:: Ho-Sheng Hsiao (<hosh@opscode.com>)
 # Copyright:: Copyright (c) 2012 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -45,6 +46,17 @@ module ChefFS
         begin
           if parent.path == '/cookbooks'
             loader = Chef::Cookbook::CookbookVersionLoader.new(file_path, parent.chefignore)
+            # We need the canonical cookbook name if we are using versioned cookbooks, but we don't
+            # want to spend a lot of time adding code to the main Chef libraries
+            if Chef::Config[:versioned_cookbooks]
+
+              _canonical_name = canonical_cookbook_name(File.basename(file_path))
+              fail "When versioned_cookbooks mode is on, cookbook #{file_path} must match format <cookbook_name>-x.y.z"  unless _canonical_name
+
+              # KLUDGE: We shouldn't have to use instance_variable_set
+              loader.instance_variable_set(:@cookbook_name, _canonical_name)
+            end
+
             loader.load_cookbooks
             return loader.cookbook_version
           end
@@ -57,6 +69,17 @@ module ChefFS
         nil
       end
 
+      # Exposed as a class method so that it can be used elsewhere
+      def self.canonical_cookbook_name(entry_name)
+        name_match = ChefFS::FileSystem::CookbookDir::VALID_VERSIONED_COOKBOOK_NAME.match(entry_name)
+        return nil if name_match.nil?
+        return name_match[1]
+      end
+
+      def canonical_cookbook_name(entry_name)
+        self.class.canonical_cookbook_name(entry_name)
+      end
+
       def children
         @children ||=
           Dir.entries(file_path).

data/lib/chef_fs/file_system/cookbook_dir.rb

@@ -26,12 +26,24 @@ require 'chef/cookbook_uploader'
 module ChefFS
   module FileSystem
     class CookbookDir < BaseFSDir
-      def initialize(name, parent, versions = nil)
+      def initialize(name, parent, options = {})
         super(name, parent)
-        @versions = versions
+        @exists = options[:exists]
+        # If the name is apache2-1.0.0 and versioned_cookbooks is on, we know
+        # the actual cookbook_name and version.
+        if Chef::Config[:versioned_cookbooks]
+          if name =~ VALID_VERSIONED_COOKBOOK_NAME
+            @cookbook_name = $1
+            @version = $2
+          else
+            @exists = false
+          end
+        else
+          @cookbook_name = name
+        end
       end
 
-      attr_reader :versions
+      attr_reader :cookbook_name, :version
 
       COOKBOOK_SEGMENT_INFO = {
         :attributes => { :ruby_only => true },
@@ -45,12 +57,16 @@ module ChefFS
         :root_files => { }
       }
 
+      # See Erchef code
+      # https://github.com/opscode/chef_objects/blob/968a63344d38fd507f6ace05f73d53e9cd7fb043/src/chef_regex.erl#L94
+      VALID_VERSIONED_COOKBOOK_NAME = /^([.a-zA-Z0-9_-]+)-(\d+\.\d+\.\d+)$/
+
       def add_child(child)
         @children << child
       end
 
       def api_path
-        "#{parent.api_path}/#{name}/_latest"
+        "#{parent.api_path}/#{cookbook_name}/#{version || "_latest"}"
       end
 
       def child(name)
@@ -67,11 +83,8 @@ module ChefFS
 
       def can_have_child?(name, is_dir)
         # A cookbook's root may not have directories unless they are segment directories
-        if is_dir
-          return name != 'root_files' &&
-                 COOKBOOK_SEGMENT_INFO.keys.any? { |segment| segment.to_s == name }
-        end
-        true
+        return name != 'root_files' && COOKBOOK_SEGMENT_INFO.keys.include?(name.to_sym) if is_dir
+        return true
       end
 
       def children
@@ -123,12 +136,13 @@ module ChefFS
         end
       end
 
+      # In versioned cookbook mode, actually check if the version exists
+      # Probably want to cache this.
       def exists?
-        if !@versions
-          child = parent.children.select { |child| child.name == name }.first
-          @versions = child.versions if child
+        if @exists.nil?
+          @exists = parent.children.any? { |child| child.name == name }
         end
-        !!@versions
+        @exists
       end
 
       def compare_to(other)

data/lib/chef_fs/file_system/cookbooks_dir.rb

@@ -19,6 +19,8 @@
 require 'chef_fs/file_system/rest_list_dir'
 require 'chef_fs/file_system/cookbook_dir'
 
+require 'tmpdir'
+
 module ChefFS
   module FileSystem
     class CookbooksDir < RestListDir
@@ -27,12 +29,32 @@ module ChefFS
       end
 
       def child(name)
-        result = @children.select { |child| child.name == name }.first if @children
-        result || CookbookDir.new(name, self)
+        if @children
+          result = self.children.select { |child| child.name == name }.first
+          if result
+            result
+          else
+            NonexistentFSObject.new(name, self)
+          end
+        else
+          CookbookDir.new(name, self)
+        end
       end
 
       def children
-        @children ||= rest.get_rest(api_path).map { |key, value| CookbookDir.new(key, self, value) }.sort_by { |c| c.name }
+        @children ||= begin
+          if Chef::Config[:versioned_cookbooks]
+            result = []
+            rest.get_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) }
+          end
+          result.sort_by(&:name)
+        end
       end
 
       def create_child_from(other)
@@ -40,38 +62,75 @@ module ChefFS
       end
 
       def upload_cookbook_from(other)
-        other_cookbook_version = other.chef_object
-        # TODO this only works on the file system.  And it can't be broken into
-        # pieces.
-        begin
-          uploader = Chef::CookbookUploader.new(other_cookbook_version, other.parent.file_path, :rest => rest)
-          # Work around the fact that CookbookUploader doesn't understand chef_repo_path (yet)
-          old_cookbook_path = Chef::Config.cookbook_path
-          Chef::Config.cookbook_path = other.parent.file_path if !Chef::Config.cookbook_path
-          begin
-            # Chef 11 changes this API
-            if uploader.respond_to?(:upload_cookbook)
-              uploader.upload_cookbook
-            else
-              uploader.upload_cookbooks
-            end
-          ensure
-            Chef::Config.cookbook_path = old_cookbook_path
-          end
-        rescue Net::HTTPServerException => e
-          case e.response.code
-          when "409"
-            ui.error "Version #{other_cookbook_version.version} of cookbook #{other_cookbook_version.name} is frozen. Use --force to override."
-            Chef::Log.debug(e)
-            raise Exceptions::CookbookFrozen
-          else
-            raise
+        Chef::Config[:versioned_cookbooks] ? upload_versioned_cookbook(other) : upload_unversioned_cookbook(other)
+      rescue Net::HTTPServerException => e
+        case e.response.code
+        when "409"
+          ui.error "Version #{other_cookbook_version.version} of cookbook #{other_cookbook_version.name} is frozen. Use --force to override."
+          Chef::Log.debug(e)
+          raise Exceptions::CookbookFrozen
+        else
+          raise
+        end
+      end
+
+      # Knife currently does not understand versioned cookbooks
+      # Cookbook Version uploader also requires a lot of refactoring
+      # to make this work. So instead, we make a temporary cookbook
+      # symlinking back to real cookbook, and upload the proxy.
+      def upload_versioned_cookbook(other)
+        cookbook_name = ChefFS::FileSystem::ChefRepositoryFileSystemEntry.canonical_cookbook_name(other.name)
+
+        Dir.mktmpdir do |temp_cookbooks_path|
+          proxy_cookbook_path = "#{temp_cookbooks_path}/#{cookbook_name}"
+
+          # Make a symlink
+          File.symlink other.file_path, proxy_cookbook_path
+
+          # Instantiate a proxy loader using the temporary symlink
+          proxy_loader = Chef::Cookbook::CookbookVersionLoader.new(proxy_cookbook_path, other.parent.chefignore)
+          proxy_loader.load_cookbooks
+
+          # Instantiate a new uploader based on the proxy loader
+          uploader = Chef::CookbookUploader.new(proxy_loader.cookbook_version, proxy_cookbook_path, :rest => rest)
+
+          with_actual_cookbooks_dir(temp_cookbooks_path) do
+            upload_cookbook!(uploader)
           end
         end
       end
 
+      def upload_unversioned_cookbook(other)
+        uploader = Chef::CookbookUploader.new(other.chef_object, other.parent.file_path, :rest => rest)
+
+        with_actual_cookbooks_dir(other.parent.file_path) do
+          upload_cookbook!(uploader)
+        end
+      end
+
+      # Work around the fact that CookbookUploader doesn't understand chef_repo_path (yet)
+      def with_actual_cookbooks_dir(actual_cookbook_path)
+        old_cookbook_path = Chef::Config.cookbook_path
+        Chef::Config.cookbook_path = actual_cookbook_path if !Chef::Config.cookbook_path
+
+        yield
+      ensure
+        Chef::Config.cookbook_path = old_cookbook_path
+      end
+
+      # Chef 11 changes this API
+      def upload_cookbook!(uploader)
+        if uploader.respond_to?(:upload_cookbook)
+          uploader.upload_cookbook
+        else
+          uploader.upload_cookbooks
+        end
+      end
+
       def can_have_child?(name, is_dir)
-        is_dir
+        return false if !is_dir
+        return false if Chef::Config[:versioned_cookbooks] && name !~ ChefFS::FileSystem::CookbookDir::VALID_VERSIONED_COOKBOOK_NAME
+        return true
       end
     end
   end

data/lib/chef_fs/file_system/data_bags_dir.rb

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