chef 12.6.0-universal-mingw32 → 12.7.2-universal-mingw32

data/lib/chef/chef_fs/file_system/chef_repository_file_system_entry.rb

@@ -1,81 +0,0 @@
-#
-# 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
-#
-# 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/chef_fs/file_system/file_system_entry'
-require 'chef/chef_fs/file_system/not_found_error'
-
-class Chef
-  module ChefFS
-    module FileSystem
-      # ChefRepositoryFileSystemEntry works just like FileSystemEntry,
-      # except can inflate Chef objects
-      class ChefRepositoryFileSystemEntry < FileSystemEntry
-        def initialize(name, parent, file_path = nil, data_handler = nil)
-          super(name, parent, file_path)
-          @data_handler = data_handler
-        end
-
-        def write_pretty_json=(value)
-          @write_pretty_json = value
-        end
-
-        def write_pretty_json
-          @write_pretty_json.nil? ? root.write_pretty_json : @write_pretty_json
-        end
-
-        def data_handler
-          @data_handler || parent.data_handler
-        end
-
-        def chef_object
-          begin
-            return data_handler.chef_object(Chef::JSONCompat.parse(read))
-          rescue
-            Chef::Log.error("Could not read #{path_for_printing} into a Chef object: #{$!}")
-          end
-          nil
-        end
-
-        def can_have_child?(name, is_dir)
-          !is_dir && name[-5..-1] == '.json'
-        end
-
-        def write(file_contents)
-          if file_contents && write_pretty_json && name[-5..-1] == '.json'
-            file_contents = minimize(file_contents, self)
-          end
-          super(file_contents)
-        end
-
-        def minimize(file_contents, entry)
-          object = Chef::JSONCompat.parse(file_contents)
-          object = data_handler.normalize(object, entry)
-          object = data_handler.minimize(object, entry)
-          Chef::JSONCompat.to_json_pretty(object)
-        end
-
-        protected
-
-        def make_child_entry(child_name)
-          ChefRepositoryFileSystemEntry.new(child_name, self)
-        end
-      end
-    end
-  end
-end

data/lib/chef/chef_fs/file_system/chef_repository_file_system_root_dir.rb

@@ -1,196 +0,0 @@
-#
-# Author:: John Keiser (<jkeiser@opscode.com>)
-# Copyright:: Copyright (c) 2012 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/chef_fs/file_system/base_fs_dir'
-require 'chef/chef_fs/file_system/chef_repository_file_system_entry'
-require 'chef/chef_fs/file_system/chef_repository_file_system_acls_dir'
-require 'chef/chef_fs/file_system/chef_repository_file_system_cookbooks_dir'
-require 'chef/chef_fs/file_system/chef_repository_file_system_data_bags_dir'
-require 'chef/chef_fs/file_system/chef_repository_file_system_policies_dir'
-require 'chef/chef_fs/file_system/multiplexed_dir'
-require 'chef/chef_fs/data_handler/client_data_handler'
-require 'chef/chef_fs/data_handler/environment_data_handler'
-require 'chef/chef_fs/data_handler/node_data_handler'
-require 'chef/chef_fs/data_handler/role_data_handler'
-require 'chef/chef_fs/data_handler/user_data_handler'
-require 'chef/chef_fs/data_handler/group_data_handler'
-require 'chef/chef_fs/data_handler/container_data_handler'
-
-class Chef
-  module ChefFS
-    module FileSystem
-
-      #
-      # Represents the root of a local Chef repository, with directories for
-      # nodes, cookbooks, roles, etc. under it.
-      #
-      class ChefRepositoryFileSystemRootDir < BaseFSDir
-        #
-        # Create a new Chef Repository File System root.
-        #
-        # == Parameters
-        # [child_paths]
-        #   A hash of child paths, e.g.:
-        #     "nodes" => [ '/var/nodes', '/home/jkeiser/nodes' ],
-        #     "roles" => [ '/var/roles' ],
-        #     ...
-        # [root_paths]
-        #   An array of paths representing the top level, where
-        #   +org.json+, +members.json+, and +invites.json+ will be stored.
-        # [chef_config] - a hash of options that looks suspiciously like the ones
-        #   stored in Chef::Config, containing at least these keys:
-        #   :versioned_cookbooks:: whether to include versions in cookbook names
-        def initialize(child_paths, root_paths=[], chef_config=Chef::Config)
-          super("", nil)
-          @child_paths = child_paths
-          @root_paths = root_paths
-          @versioned_cookbooks = chef_config[:versioned_cookbooks]
-        end
-
-        attr_accessor :write_pretty_json
-
-        attr_reader :root_paths
-        attr_reader :child_paths
-        attr_reader :versioned_cookbooks
-
-        CHILDREN = %w(org.json invitations.json members.json)
-
-        def children
-          @children ||= begin
-            result = child_paths.keys.sort.map { |name| make_child_entry(name) }
-            result += CHILDREN.map { |name| make_child_entry(name) }
-            result.select { |c| c && c.exists? }.sort_by { |c| c.name }
-          end
-        end
-
-        def can_have_child?(name, is_dir)
-          if is_dir
-            child_paths.has_key?(name)
-          elsif root_dir
-            CHILDREN.include?(name)
-          else
-            false
-          end
-        end
-
-        def create_child(name, file_contents = nil)
-          if file_contents
-            child = root_dir.create_child(name, file_contents)
-          else
-            child_paths[name].each do |path|
-              begin
-                Dir.mkdir(path)
-              rescue Errno::EEXIST
-              end
-            end
-            child = make_child_entry(name)
-          end
-          @children = nil
-          child
-        end
-
-        def json_class
-          nil
-        end
-
-        # Used to print out a human-readable file system description
-        def fs_description
-          repo_paths = root_paths || [ File.dirname(child_paths['cookbooks'][0]) ]
-          result = "repository at #{repo_paths.join(', ')}\n"
-          if versioned_cookbooks
-            result << "  Multiple versions per cookbook\n"
-          else
-            result << "  One version per cookbook\n"
-          end
-          child_paths.each_pair do |name, paths|
-            if paths.any? { |path| !repo_paths.include?(File.dirname(path)) }
-              result << "  #{name} at #{paths.join(', ')}\n"
-            end
-          end
-          result
-        end
-
-        private
-
-        #
-        # A FileSystemEntry representing the root path where invites.json,
-        # members.json and org.json may be found.
-        #
-        def root_dir
-          existing_paths = root_paths.select { |path| File.exists?(path) }
-          if existing_paths.size > 0
-            MultiplexedDir.new(existing_paths.map do |path|
-              dir = ChefRepositoryFileSystemEntry.new(name, parent, path)
-              dir.write_pretty_json = !!write_pretty_json
-              dir
-            end)
-          end
-        end
-
-        #
-        # Create a child entry of the appropriate type:
-        # cookbooks, data_bags, acls, etc.  All will be multiplexed (i.e. if
-        # you have multiple paths for cookbooks, the multiplexed dir will grab
-        # cookbooks from all of them when you list or grab them).
-        #
-        def make_child_entry(name)
-          if CHILDREN.include?(name)
-            return nil if !root_dir
-            return root_dir.child(name)
-          end
-
-          paths = (child_paths[name] || []).select { |path| File.exists?(path) }
-          if paths.size == 0
-            return NonexistentFSObject.new(name, self)
-          end
-          case name
-          when 'cookbooks'
-            dirs = paths.map { |path| ChefRepositoryFileSystemCookbooksDir.new(name, self, path) }
-          when 'data_bags'
-            dirs = paths.map { |path| ChefRepositoryFileSystemDataBagsDir.new(name, self, path) }
-          when 'policies'
-            dirs = paths.map { |path| ChefRepositoryFileSystemPoliciesDir.new(name, self, path) }
-          when 'acls'
-            dirs = paths.map { |path| ChefRepositoryFileSystemAclsDir.new(name, self, path) }
-          else
-            data_handler = case name
-              when 'clients'
-                Chef::ChefFS::DataHandler::ClientDataHandler.new
-              when 'environments'
-                Chef::ChefFS::DataHandler::EnvironmentDataHandler.new
-              when 'nodes'
-                Chef::ChefFS::DataHandler::NodeDataHandler.new
-              when 'roles'
-                Chef::ChefFS::DataHandler::RoleDataHandler.new
-              when 'users'
-                Chef::ChefFS::DataHandler::UserDataHandler.new
-              when 'groups'
-                Chef::ChefFS::DataHandler::GroupDataHandler.new
-              when 'containers'
-                Chef::ChefFS::DataHandler::ContainerDataHandler.new
-              else
-                raise "Unknown top level path #{name}"
-              end
-            dirs = paths.map { |path| ChefRepositoryFileSystemEntry.new(name, self, path, data_handler) }
-          end
-          MultiplexedDir.new(dirs)
-        end
-      end
-    end
-  end
-end

data/lib/chef/chef_fs/file_system/chef_server_root_dir.rb

@@ -1,165 +0,0 @@
-#
-# Author:: John Keiser (<jkeiser@opscode.com>)
-# Copyright:: Copyright (c) 2012 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/server_api'
-require 'chef/chef_fs/file_system/acls_dir'
-require 'chef/chef_fs/file_system/base_fs_dir'
-require 'chef/chef_fs/file_system/rest_list_dir'
-require 'chef/chef_fs/file_system/cookbooks_dir'
-require 'chef/chef_fs/file_system/data_bags_dir'
-require 'chef/chef_fs/file_system/nodes_dir'
-require 'chef/chef_fs/file_system/org_entry'
-require 'chef/chef_fs/file_system/organization_invites_entry'
-require 'chef/chef_fs/file_system/organization_members_entry'
-require 'chef/chef_fs/file_system/environments_dir'
-require 'chef/chef_fs/data_handler/client_data_handler'
-require 'chef/chef_fs/data_handler/role_data_handler'
-require 'chef/chef_fs/data_handler/user_data_handler'
-require 'chef/chef_fs/data_handler/group_data_handler'
-require 'chef/chef_fs/data_handler/container_data_handler'
-
-class Chef
-  module ChefFS
-    module FileSystem
-      #
-      # Represents the root of a Chef server (or organization), under which
-      # nodes, roles, cookbooks, etc. can be found.
-      #
-      class ChefServerRootDir < BaseFSDir
-        #
-        # Create a new Chef server root.
-        #
-        # == Parameters
-        #
-        # [root_name]
-        #   A friendly name for the root, for printing--like "remote" or "chef_central".
-        # [chef_config]
-        #   A hash with options that look suspiciously like Chef::Config, including the
-        #   following keys:
-        #   :chef_server_url:: The URL to the Chef server or top of the organization
-        #   :node_name:: The username to authenticate to the Chef server with
-        #   :client_key:: The private key for the user for authentication
-        #   :environment:: The environment in which you are presently working
-        #   :repo_mode::
-        #     The repository mode, :hosted_everything, :everything or :static.
-        #     This determines the set of subdirectories the Chef server will
-        #     offer up.
-        #   :versioned_cookbooks:: whether or not to include versions in cookbook names
-        # [options]
-        #   Other options:
-        #   :cookbook_version:: when cookbooks are retrieved, grab this version for them.
-        #   :freeze:: freeze cookbooks on upload
-        #
-        def initialize(root_name, chef_config, options = {})
-          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 = chef_config[:repo_mode]
-          @versioned_cookbooks = chef_config[:versioned_cookbooks]
-          @root_name = root_name
-          @cookbook_version = options[:cookbook_version] # Used in knife diff and download for server cookbook version
-        end
-
-        attr_reader :chef_server_url
-        attr_reader :chef_username
-        attr_reader :chef_private_key
-        attr_reader :environment
-        attr_reader :repo_mode
-        attr_reader :cookbook_version
-        attr_reader :versioned_cookbooks
-
-        def fs_description
-          "Chef server at #{chef_server_url} (user #{chef_username}), repo_mode = #{repo_mode}"
-        end
-
-        def rest
-          Chef::ServerAPI.new(chef_server_url, :client_name => chef_username, :signing_key_filename => chef_private_key, :raw_output => true, :api_version => "0")
-        end
-
-        def get_json(path)
-          Chef::ServerAPI.new(chef_server_url, :client_name => chef_username, :signing_key_filename => chef_private_key, :api_version => "0").get(path)
-        end
-
-        def chef_rest
-          Chef::REST.new(chef_server_url, chef_username, chef_private_key)
-        end
-
-        def api_path
-          ""
-        end
-
-        def path_for_printing
-          "#{@root_name}/"
-        end
-
-        def can_have_child?(name, is_dir)
-          result = children.select { |child| child.name == name }.first
-          result && !!result.dir? == !!is_dir
-        end
-
-        def org
-          @org ||= begin
-            path = Pathname.new(URI.parse(chef_server_url).path).cleanpath
-            if File.dirname(path) == '/organizations'
-              File.basename(path)
-            else
-              # In Chef 12, everything is in an org.
-              'chef'
-            end
-          end
-        end
-
-        def make_child_entry(name)
-          children.select { |child| child.name == name }.first
-        end
-
-        def children
-          @children ||= begin
-            result = [
-              CookbooksDir.new(self),
-              DataBagsDir.new(self),
-              EnvironmentsDir.new(self),
-              RestListDir.new("roles", self, nil, Chef::ChefFS::DataHandler::RoleDataHandler.new)
-            ]
-            if repo_mode == 'hosted_everything'
-              result += [
-                AclsDir.new(self),
-                RestListDir.new("clients", self, nil, Chef::ChefFS::DataHandler::ClientDataHandler.new),
-                RestListDir.new("containers", self, nil, Chef::ChefFS::DataHandler::ContainerDataHandler.new),
-                RestListDir.new("groups", self, nil, Chef::ChefFS::DataHandler::GroupDataHandler.new),
-                NodesDir.new(self),
-                OrgEntry.new("org.json", self),
-                OrganizationMembersEntry.new("members.json", self),
-                OrganizationInvitesEntry.new("invitations.json", self)
-              ]
-            elsif repo_mode != 'static'
-              result += [
-                RestListDir.new("clients", self, nil, Chef::ChefFS::DataHandler::ClientDataHandler.new),
-                NodesDir.new(self),
-                RestListDir.new("users", self, nil, Chef::ChefFS::DataHandler::UserDataHandler.new)
-              ]
-            end
-            result.sort_by { |child| child.name }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/chef/chef_fs/file_system/cookbook_dir.rb

@@ -1,224 +0,0 @@
-#
-# Author:: John Keiser (<jkeiser@opscode.com>)
-# Copyright:: Copyright (c) 2012 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/chef_fs/command_line'
-require 'chef/chef_fs/file_system/rest_list_dir'
-require 'chef/chef_fs/file_system/cookbook_subdir'
-require 'chef/chef_fs/file_system/cookbook_file'
-require 'chef/chef_fs/file_system/not_found_error'
-require 'chef/cookbook_version'
-require 'chef/cookbook_uploader'
-
-class Chef
-  module ChefFS
-    module FileSystem
-      class CookbookDir < BaseFSDir
-        def initialize(name, parent, options = {})
-          super(name, parent)
-          @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 root.versioned_cookbooks
-            if name =~ VALID_VERSIONED_COOKBOOK_NAME
-              @cookbook_name = $1
-              @version = $2
-            else
-              @exists = false
-            end
-          else
-            @cookbook_name = name
-            @version = root.cookbook_version # nil unless --cookbook-version specified in download/diff
-          end
-        end
-
-        attr_reader :cookbook_name, :version
-
-        COOKBOOK_SEGMENT_INFO = {
-          :attributes => { :ruby_only => true },
-          :definitions => { :ruby_only => true },
-          :recipes => { :ruby_only => true },
-          :libraries => { :ruby_only => true },
-          :templates => { :recursive => true },
-          :files => { :recursive => true },
-          :resources => { :ruby_only => true, :recursive => true },
-          :providers => { :ruby_only => true, :recursive => true },
-          :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}/#{cookbook_name}/#{version || "_latest"}"
-        end
-
-        def make_child_entry(name)
-          # Since we're ignoring the rules and doing a network request here,
-          # we need to make sure we don't rethrow the exception.  (child(name)
-          # is not supposed to fail.)
-          begin
-            children.select { |child| child.name == name }.first
-          rescue Chef::ChefFS::FileSystem::NotFoundError
-            nil
-          end
-        end
-
-        def can_have_child?(name, is_dir)
-          # A cookbook's root may not have directories unless they are segment directories
-          return name != 'root_files' && COOKBOOK_SEGMENT_INFO.keys.include?(name.to_sym) if is_dir
-          return true
-        end
-
-        def children
-          if @children.nil?
-            @children = []
-            manifest = chef_object.manifest
-            COOKBOOK_SEGMENT_INFO.each do |segment, segment_info|
-              next unless manifest.has_key?(segment)
-
-              # Go through each file in the manifest for the segment, and
-              # add cookbook subdirs and files for it.
-              manifest[segment].each do |segment_file|
-                parts = segment_file[:path].split('/')
-                # Get or create the path to the file
-                container = self
-                parts[0,parts.length-1].each do |part|
-                  old_container = container
-                  container = old_container.children.select { |child| part == child.name }.first
-                  if !container
-                    container = CookbookSubdir.new(part, old_container, segment_info[:ruby_only], segment_info[:recursive])
-                    old_container.add_child(container)
-                  end
-                end
-                # Create the file itself
-                container.add_child(CookbookFile.new(parts[parts.length-1], container, segment_file))
-              end
-            end
-            @children = @children.sort_by { |c| c.name }
-          end
-          @children
-        end
-
-        def dir?
-          exists?
-        end
-
-        def delete(recurse)
-          if recurse
-            begin
-              rest.delete(api_path)
-            rescue Timeout::Error => e
-              raise Chef::ChefFS::FileSystem::OperationFailedError.new(:delete, self, e), "Timeout deleting: #{e}"
-            rescue Net::HTTPServerException
-              if $!.response.code == "404"
-                raise Chef::ChefFS::FileSystem::NotFoundError.new(self, $!)
-              else
-                raise Chef::ChefFS::FileSystem::OperationFailedError.new(:delete, self, e), "HTTP error deleting: #{e}"
-              end
-            end
-          else
-            raise NotFoundError.new(self) if !exists?
-            raise MustDeleteRecursivelyError.new(self), "#{path_for_printing} must be deleted recursively"
-          end
-        end
-
-        # In versioned cookbook mode, actually check if the version exists
-        # Probably want to cache this.
-        def exists?
-          if @exists.nil?
-            @exists = parent.children.any? { |child| child.name == name }
-          end
-          @exists
-        end
-
-        def compare_to(other)
-          if !other.dir?
-            return [ !exists?, nil, nil ]
-          end
-          are_same = true
-          Chef::ChefFS::CommandLine::diff_entries(self, other, nil, :name_only).each do |type, old_entry, new_entry|
-            if [ :directory_to_file, :file_to_directory, :deleted, :added, :modified ].include?(type)
-              are_same = false
-            end
-          end
-          [ are_same, nil, nil ]
-        end
-
-        def copy_from(other, options = {})
-          parent.upload_cookbook_from(other, options)
-        end
-
-        def rest
-          parent.rest
-        end
-
-        def chef_object
-          # We cheat and cache here, because it seems like a good idea to keep
-          # the cookbook view consistent with the directory structure.
-          return @chef_object if @chef_object
-
-          # The negative (not found) response is cached
-          if @could_not_get_chef_object
-            raise Chef::ChefFS::FileSystem::NotFoundError.new(self, @could_not_get_chef_object)
-          end
-
-          begin
-            # We want to fail fast, for now, because of the 500 issue :/
-            # This will make things worse for parallelism, a little, because
-            # Chef::Config is global and this could affect other requests while
-            # this request is going on.  (We're not parallel yet, but we will be.)
-            # Chef bug http://tickets.opscode.com/browse/CHEF-3066
-            old_retry_count = Chef::Config[:http_retry_count]
-            begin
-              Chef::Config[:http_retry_count] = 0
-              @chef_object ||= Chef::CookbookVersion.json_create(root.get_json(api_path))
-            ensure
-              Chef::Config[:http_retry_count] = old_retry_count
-            end
-
-          rescue Timeout::Error => e
-            raise Chef::ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "Timeout reading: #{e}"
-
-          rescue Net::HTTPServerException => e
-            if e.response.code == "404"
-              @could_not_get_chef_object = e
-              raise Chef::ChefFS::FileSystem::NotFoundError.new(self, @could_not_get_chef_object)
-            else
-              raise Chef::ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "HTTP error reading: #{e}"
-            end
-
-          # Chef bug http://tickets.opscode.com/browse/CHEF-3066 ... instead of 404 we get 500 right now.
-          # Remove this when that bug is fixed.
-          rescue Net::HTTPFatalError => e
-            if e.response.code == "500"
-              @could_not_get_chef_object = e
-              raise Chef::ChefFS::FileSystem::NotFoundError.new(self, @could_not_get_chef_object)
-            else
-              raise Chef::ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "HTTP error reading: #{e}"
-            end
-          end
-        end
-      end
-    end
-  end
-end