chef 16.18.30 → 17.0.242

data/lib/chef/chef_fs/parallelizer.rb

@@ -1,102 +0,0 @@
-require_relative "parallelizer/parallel_enumerable"
-
-class Chef
-  module ChefFS
-    # Tries to balance several guarantees, in order of priority:
-    # - don't get deadlocked
-    # - provide results in desired order
-    # - provide results as soon as they are available
-    # - process input as soon as possible
-    class Parallelizer
-      @@parallelizer = nil
-      @@threads = 0
-
-      def self.threads=(value)
-        @@threads = value
-        @@parallelizer.resize(value) if @@parallelizer
-      end
-
-      def self.parallelizer
-        @@parallelizer ||= Parallelizer.new(@@threads)
-      end
-
-      def self.parallelize(enumerable, options = {}, &block)
-        parallelizer.parallelize(enumerable, options, &block)
-      end
-
-      def self.parallel_do(enumerable, options = {}, &block)
-        parallelizer.parallel_do(enumerable, options, &block)
-      end
-
-      def initialize(num_threads)
-        @tasks = Queue.new
-        @threads = []
-        @stop_thread = {}
-        resize(num_threads)
-      end
-
-      def num_threads
-        @threads.size
-      end
-
-      def parallelize(enumerable, options = {}, &block)
-        ParallelEnumerable.new(@tasks, enumerable, options, &block)
-      end
-
-      def parallel_do(enumerable, options = {}, &block)
-        ParallelEnumerable.new(@tasks, enumerable, options.merge(ordered: false), &block).wait
-      end
-
-      def stop(wait = true, timeout = nil)
-        resize(0, wait, timeout)
-      end
-
-      def resize(to_threads, wait = true, timeout = nil)
-        if to_threads < num_threads
-          threads_to_stop = @threads[to_threads..num_threads - 1]
-          @threads = @threads.slice(0, to_threads)
-          threads_to_stop.each do |thread|
-            @stop_thread[thread] = true
-          end
-
-          if wait
-            start_time = Time.now
-            threads_to_stop.each do |thread|
-              thread_timeout = timeout ? timeout - (Time.now - start_time) : nil
-              thread.join(thread_timeout)
-            end
-          end
-
-        else
-          num_threads.upto(to_threads - 1) do |i|
-            @threads[i] = Thread.new(&method(:worker_loop))
-          end
-        end
-      end
-
-      def kill
-        @threads.each do |thread|
-          Thread.kill(thread)
-          @stop_thread.delete(thread)
-        end
-        @threads = []
-      end
-
-      private
-
-      def worker_loop
-        until @stop_thread[Thread.current]
-          begin
-            task = @tasks.pop
-            task.call
-          rescue
-            puts "ERROR #{$!}"
-            puts $!.backtrace
-          end
-        end
-      ensure
-        @stop_thread.delete(Thread.current)
-      end
-    end
-  end
-end

data/lib/chef/cookbook_site_streaming_uploader.rb

@@ -1,244 +0,0 @@
-#
-# Author:: Stanislav Vitvitskiy
-# Author:: Nuo Yan (nuo@chef.io)
-# Author:: Christopher Walters (<cw@chef.io>)
-# Copyright:: Copyright (c) Chef Software 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.
-#
-
-autoload :URI, "uri"
-module Net
-  autoload :HTTP, "net/http"
-end
-autoload :OpenSSL, "openssl"
-module Mixlib
-  module Authentication
-    autoload :SignedHeaderAuth, "mixlib/authentication/signedheaderauth"
-  end
-end
-require "chef-utils/dist" unless defined?(ChefUtils::Dist)
-
-class Chef
-  # == Chef::CookbookSiteStreamingUploader
-  # A streaming multipart HTTP upload implementation. Used to upload cookbooks
-  # (in tarball form) to https://supermarket.chef.io
-  #
-  # inspired by http://stanislavvitvitskiy.blogspot.com/2008/12/multipart-post-in-ruby.html
-  class CookbookSiteStreamingUploader
-
-    DefaultHeaders = { "accept" => "application/json", "x-chef-version" => ::Chef::VERSION }.freeze # rubocop:disable Naming/ConstantName
-
-    class << self
-
-      def create_build_dir(cookbook)
-        tmp_cookbook_path = Tempfile.new("#{ChefUtils::Dist::Infra::SHORT}-#{cookbook.name}-build")
-        tmp_cookbook_path.close
-        tmp_cookbook_dir = tmp_cookbook_path.path
-        File.unlink(tmp_cookbook_dir)
-        FileUtils.mkdir_p(tmp_cookbook_dir)
-        Chef::Log.trace("Staging at #{tmp_cookbook_dir}")
-        checksums_to_on_disk_paths = cookbook.checksums
-        cookbook.each_file do |manifest_record|
-          path_in_cookbook = manifest_record[:path]
-          on_disk_path = checksums_to_on_disk_paths[manifest_record[:checksum]]
-          dest = File.join(tmp_cookbook_dir, cookbook.name.to_s, path_in_cookbook)
-          FileUtils.mkdir_p(File.dirname(dest))
-          Chef::Log.trace("Staging #{on_disk_path} to #{dest}")
-          FileUtils.cp(on_disk_path, dest)
-        end
-
-        # First, generate metadata
-        Chef::Log.trace("Generating metadata")
-        kcm = Chef::Knife::CookbookMetadata.new
-        kcm.config[:cookbook_path] = [ tmp_cookbook_dir ]
-        kcm.name_args = [ cookbook.name.to_s ]
-        kcm.run
-
-        tmp_cookbook_dir
-      end
-
-      def post(to_url, user_id, secret_key_filename, params = {}, headers = {})
-        make_request(:post, to_url, user_id, secret_key_filename, params, headers)
-      end
-
-      def put(to_url, user_id, secret_key_filename, params = {}, headers = {})
-        make_request(:put, to_url, user_id, secret_key_filename, params, headers)
-      end
-
-      def make_request(http_verb, to_url, user_id, secret_key_filename, params = {}, headers = {})
-        boundary = "----RubyMultipartClient" + rand(1000000).to_s + "ZZZZZ"
-        parts = []
-        content_file = nil
-
-        secret_key = OpenSSL::PKey::RSA.new(File.read(secret_key_filename))
-
-        unless params.nil? || params.empty?
-          params.each do |key, value|
-            if value.is_a?(File)
-              content_file = value
-              filepath = value.path
-              filename = File.basename(filepath)
-              parts << StringPart.new( "--" + boundary + "\r\n" +
-                                      "Content-Disposition: form-data; name=\"" + key.to_s + "\"; filename=\"" + filename + "\"\r\n" +
-                                      "Content-Type: application/octet-stream\r\n\r\n")
-              parts << StreamPart.new(value, File.size(filepath))
-              parts << StringPart.new("\r\n")
-            else
-              parts << StringPart.new( "--" + boundary + "\r\n" +
-                                      "Content-Disposition: form-data; name=\"" + key.to_s + "\"\r\n\r\n")
-              parts << StringPart.new(value.to_s + "\r\n")
-            end
-          end
-          parts << StringPart.new("--" + boundary + "--\r\n")
-        end
-
-        body_stream = MultipartStream.new(parts)
-
-        timestamp = Time.now.utc.iso8601
-
-        url = URI.parse(to_url)
-
-        Chef::Log.logger.debug("Signing: method: #{http_verb}, url: #{url}, file: #{content_file}, User-id: #{user_id}, Timestamp: #{timestamp}")
-
-        # We use the body for signing the request if the file parameter
-        # wasn't a valid file or wasn't included. Extract the body (with
-        # multi-part delimiters intact) to sign the request.
-        # TODO: tim: 2009-12-28: It'd be nice to remove this special case, and
-        # always hash the entire request body. In the file case it would just be
-        # expanded multipart text - the entire body of the POST.
-        content_body = parts.inject("") { |result, part| result + part.read(0, part.size) }
-        content_file.rewind if content_file # we consumed the file for the above operation, so rewind it.
-
-        signing_options = {
-          http_method: http_verb,
-          path: url.path,
-          user_id: user_id,
-          timestamp: timestamp }
-        (content_file && signing_options[:file] = content_file) || (signing_options[:body] = (content_body || ""))
-
-        headers.merge!(Mixlib::Authentication::SignedHeaderAuth.signing_object(signing_options).sign(secret_key))
-
-        content_file.rewind if content_file
-
-        # net/http doesn't like symbols for header keys, so we'll to_s each one just in case
-        headers = DefaultHeaders.merge(Hash[*headers.map { |k, v| [k.to_s, v] }.flatten])
-
-        req = case http_verb
-              when :put
-                Net::HTTP::Put.new(url.path, headers)
-              when :post
-                Net::HTTP::Post.new(url.path, headers)
-              end
-        req.content_length = body_stream.size
-        req.content_type = "multipart/form-data; boundary=" + boundary unless parts.empty?
-        req.body_stream = body_stream
-
-        http = Chef::HTTP::BasicClient.new(url).http_client
-        res = http.request(req)
-
-        # alias status to code and to_s to body for test purposes
-        # TODO: stop the following madness!
-        class << res
-          alias :to_s :body
-
-          # BUG this makes the response compatible with what response_steps expects to test headers (response.headers[] -> response[])
-          def headers # rubocop:disable Lint/NestedMethodDefinition
-            self
-          end
-
-          def status  # rubocop:disable Lint/NestedMethodDefinition
-            code.to_i
-          end
-        end
-        res
-      end
-
-    end
-
-    class StreamPart
-      def initialize(stream, size)
-        @stream, @size = stream, size
-      end
-
-      def size
-        @size
-      end
-
-      # read the specified amount from the stream
-      def read(offset, how_much)
-        @stream.read(how_much)
-      end
-    end
-
-    class StringPart
-      def initialize(str)
-        @str = str
-      end
-
-      def size
-        @str.length
-      end
-
-      # read the specified amount from the string starting at the offset
-      def read(offset, how_much)
-        @str[offset, how_much]
-      end
-    end
-
-    class MultipartStream
-      def initialize(parts)
-        @parts = parts
-        @part_no = 0
-        @part_offset = 0
-      end
-
-      def size
-        @parts.inject(0) { |size, part| size + part.size }
-      end
-
-      def read(how_much, dst_buf = nil)
-        if @part_no >= @parts.size
-          dst_buf.replace("") if dst_buf
-          return dst_buf
-        end
-
-        how_much_current_part = @parts[@part_no].size - @part_offset
-
-        how_much_current_part = if how_much_current_part > how_much
-                                  how_much
-                                else
-                                  how_much_current_part
-                                end
-
-        how_much_next_part = how_much - how_much_current_part
-
-        current_part = @parts[@part_no].read(@part_offset, how_much_current_part)
-
-        # recurse into the next part if the current one was not large enough
-        if how_much_next_part > 0
-          @part_no += 1
-          @part_offset = 0
-          next_part = read(how_much_next_part)
-          result = current_part + (next_part || "")
-        else
-          @part_offset += how_much_current_part
-          result = current_part
-        end
-        dst_buf ? dst_buf.replace(result || "") : result
-      end
-    end
-
-  end
-end

data/lib/chef/knife/acl_add.rb

@@ -1,57 +0,0 @@
-#
-# Author:: Steven Danna (steve@chef.io)
-# Author:: Jeremiah Snapp (jeremiah@chef.io)
-# Copyright:: Copyright (c) Chef Software 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_relative "../knife"
-
-class Chef
-  class Knife
-    class AclAdd < Chef::Knife
-      category "acl"
-      banner "knife acl add MEMBER_TYPE MEMBER_NAME OBJECT_TYPE OBJECT_NAME PERMS"
-
-      deps do
-        require_relative "acl_base"
-        include Chef::Knife::AclBase
-      end
-
-      def run
-        member_type, member_name, object_type, object_name, perms = name_args
-
-        if name_args.length != 5
-          show_usage
-          ui.fatal "You must specify the member type [client|group], member name, object type, object name and perms"
-          exit 1
-        end
-
-        unless %w{client group}.include?(member_type)
-          ui.fatal "ERROR: To enforce best practice, knife-acl can only add a client or a group to an ACL."
-          ui.fatal "       See the knife-acl README for more information."
-          exit 1
-        end
-        validate_perm_type!(perms)
-        validate_member_name!(member_name)
-        validate_object_name!(object_name)
-        validate_object_type!(object_type)
-        validate_member_exists!(member_type, member_name)
-
-        add_to_acl!(member_type, member_name, object_type, object_name, perms)
-      end
-    end
-  end
-end

data/lib/chef/knife/acl_base.rb

@@ -1,183 +0,0 @@
-#
-# Author:: Steven Danna (steve@chef.io)
-# Author:: Jeremiah Snapp (<jeremiah@chef.io>)
-# Copyright:: Copyright (c) Chef Software 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_relative "../knife"
-
-class Chef
-  class Knife
-    module AclBase
-
-      PERM_TYPES = %w{create read update delete grant}.freeze unless defined? PERM_TYPES
-      MEMBER_TYPES = %w{client group user}.freeze unless defined? MEMBER_TYPES
-      OBJECT_TYPES = %w{clients containers cookbooks data environments groups nodes roles policies policy_groups}.freeze unless defined? OBJECT_TYPES
-      OBJECT_NAME_SPEC = /^[\-[:alnum:]_\.]+$/.freeze unless defined? OBJECT_NAME_SPEC
-
-      def validate_object_type!(type)
-        unless OBJECT_TYPES.include?(type)
-          ui.fatal "Unknown object type \"#{type}\".  The following types are permitted: #{OBJECT_TYPES.join(", ")}"
-          exit 1
-        end
-      end
-
-      def validate_object_name!(name)
-        unless OBJECT_NAME_SPEC.match(name)
-          ui.fatal "Invalid name: #{name}"
-          exit 1
-        end
-      end
-
-      def validate_member_type!(type)
-        unless MEMBER_TYPES.include?(type)
-          ui.fatal "Unknown member type \"#{type}\". The following types are permitted: #{MEMBER_TYPES.join(", ")}"
-          exit 1
-        end
-      end
-
-      def validate_member_name!(name)
-        # Same rules apply to objects and members
-        validate_object_name!(name)
-      end
-
-      def validate_perm_type!(perms)
-        perms.split(",").each do |perm|
-          unless PERM_TYPES.include?(perm)
-            ui.fatal "Invalid permission \"#{perm}\". The following permissions are permitted: #{PERM_TYPES.join(",")}"
-            exit 1
-          end
-        end
-      end
-
-      def validate_member_exists!(member_type, member_name)
-        true if rest.get_rest("#{member_type}s/#{member_name}")
-      rescue NameError
-        # ignore "NameError: uninitialized constant Chef::ApiClient" when finding a client
-        true
-      rescue
-        ui.fatal "#{member_type} '#{member_name}' does not exist"
-        exit 1
-      end
-
-      def is_usag?(gname)
-        gname.length == 32 && gname =~ /^[0-9a-f]+$/
-      end
-
-      def get_acl(object_type, object_name)
-        rest.get_rest("#{object_type}/#{object_name}/_acl?detail=granular")
-      end
-
-      def get_ace(object_type, object_name, perm)
-        get_acl(object_type, object_name)[perm]
-      end
-
-      def add_to_acl!(member_type, member_name, object_type, object_name, perms)
-        acl = get_acl(object_type, object_name)
-        perms.split(",").each do |perm|
-          ui.msg "Adding '#{member_name}' to '#{perm}' ACE of '#{object_name}'"
-          ace = acl[perm]
-
-          case member_type
-          when "client", "user"
-            # Our PUT body depends on the type of reply we get from _acl?detail=granular
-            # When the server replies with json attributes  'users' and 'clients',
-            # we'll want to modify entries under the same keys they arrived.- their presence
-            # in the body tells us that CS will accept them in a PUT.
-            # Older version of chef-server will continue to use 'actors' for a combined list
-            # and expect the same in the body.
-            key = "#{member_type}s"
-            key = "actors" unless ace.key? key
-            next if ace[key].include?(member_name)
-
-            ace[key] << member_name
-          when "group"
-            next if ace["groups"].include?(member_name)
-
-            ace["groups"] << member_name
-          end
-
-          update_ace!(object_type, object_name, perm, ace)
-        end
-      end
-
-      def remove_from_acl!(member_type, member_name, object_type, object_name, perms)
-        acl = get_acl(object_type, object_name)
-        perms.split(",").each do |perm|
-          ui.msg "Removing '#{member_name}' from '#{perm}' ACE of '#{object_name}'"
-          ace = acl[perm]
-
-          case member_type
-          when "client", "user"
-            key = "#{member_type}s"
-            key = "actors" unless ace.key? key
-            next unless ace[key].include?(member_name)
-
-            ace[key].delete(member_name)
-          when "group"
-            next unless ace["groups"].include?(member_name)
-
-            ace["groups"].delete(member_name)
-          end
-
-          update_ace!(object_type, object_name, perm, ace)
-        end
-      end
-
-      def update_ace!(object_type, object_name, ace_type, ace)
-        rest.put_rest("#{object_type}/#{object_name}/_acl/#{ace_type}", ace_type => ace)
-      end
-
-      def add_to_group!(member_type, member_name, group_name)
-        validate_member_exists!(member_type, member_name)
-        existing_group = rest.get_rest("groups/#{group_name}")
-        ui.msg "Adding '#{member_name}' to '#{group_name}' group"
-        unless existing_group["#{member_type}s"].include?(member_name)
-          existing_group["#{member_type}s"] << member_name
-          new_group = {
-            "groupname" => existing_group["groupname"],
-            "orgname" => existing_group["orgname"],
-            "actors" => {
-              "users" => existing_group["users"],
-              "clients" => existing_group["clients"],
-              "groups" => existing_group["groups"],
-            },
-          }
-          rest.put_rest("groups/#{group_name}", new_group)
-        end
-      end
-
-      def remove_from_group!(member_type, member_name, group_name)
-        validate_member_exists!(member_type, member_name)
-        existing_group = rest.get_rest("groups/#{group_name}")
-        ui.msg "Removing '#{member_name}' from '#{group_name}' group"
-        if existing_group["#{member_type}s"].include?(member_name)
-          existing_group["#{member_type}s"].delete(member_name)
-          new_group = {
-            "groupname" => existing_group["groupname"],
-            "orgname" => existing_group["orgname"],
-            "actors" => {
-              "users" => existing_group["users"],
-              "clients" => existing_group["clients"],
-              "groups" => existing_group["groups"],
-            },
-          }
-          rest.put_rest("groups/#{group_name}", new_group)
-        end
-      end
-    end
-  end
-end

data/lib/chef/knife/acl_bulk_add.rb

@@ -1,78 +0,0 @@
-#
-# Author:: Jeremiah Snapp (jeremiah@chef.io)
-# Copyright:: Copyright (c) Chef Software 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_relative "../knife"
-
-class Chef
-  class Knife
-    class AclBulkAdd < Chef::Knife
-      category "acl"
-      banner "knife acl bulk add MEMBER_TYPE MEMBER_NAME OBJECT_TYPE REGEX PERMS"
-
-      deps do
-        require_relative "acl_base"
-        include Chef::Knife::AclBase
-      end
-
-      def run
-        member_type, member_name, object_type, regex, perms = name_args
-        object_name_matcher = /#{regex}/
-
-        if name_args.length != 5
-          show_usage
-          ui.fatal "You must specify the member type [client|group], member name, object type, object name REGEX and perms"
-          exit 1
-        end
-
-        unless %w{client group}.include?(member_type)
-          ui.fatal "ERROR: To enforce best practice, knife-acl can only add a client or a group to an ACL."
-          ui.fatal "       See the knife-acl README for more information."
-          exit 1
-        end
-        validate_perm_type!(perms)
-        validate_member_name!(member_name)
-        validate_object_type!(object_type)
-        validate_member_exists!(member_type, member_name)
-
-        if %w{containers groups}.include?(object_type)
-          ui.fatal "bulk modifying the ACL of #{object_type} is not permitted"
-          exit 1
-        end
-
-        objects_to_modify = []
-        all_objects = rest.get_rest(object_type)
-        objects_to_modify = all_objects.keys.select { |object_name| object_name =~ object_name_matcher }
-
-        if objects_to_modify.empty?
-          ui.info "No #{object_type} match the expression /#{regex}/"
-          exit 0
-        end
-
-        ui.msg("The ACL of the following #{object_type} will be modified:")
-        ui.msg("")
-        ui.msg(ui.list(objects_to_modify.sort, :columns_down))
-        ui.msg("")
-        ui.confirm("Are you sure you want to modify the ACL of these #{object_type}?")
-
-        objects_to_modify.each do |object_name|
-          add_to_acl!(member_type, member_name, object_type, object_name, perms)
-        end
-      end
-    end
-  end
-end