chef 18.0.169-x64-mingw-ucrt

data/lib/chef/user_v1.rb

@@ -0,0 +1,326 @@
+#
+# Author:: Steven Danna (steve@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 "config"
+require_relative "mixin/params_validate"
+require_relative "mixin/from_file"
+require_relative "mash"
+require_relative "json_compat"
+require_relative "search/query"
+require_relative "mixin/api_version_request_handling"
+require_relative "exceptions"
+require_relative "server_api"
+
+# OSC 11 BACKWARDS COMPATIBILITY NOTE (remove after OSC 11 support ends)
+#
+# In general, Chef::UserV1 is no longer expected to support Open Source Chef 11 Server requests.
+# The object that handles those requests remain in the Chef::User namespace.
+# This code will be moved to the Chef::User namespace as of Chef 13.
+#
+# Exception: self.list is backwards compatible with OSC 11
+class Chef
+  class UserV1
+
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::ParamsValidate
+    include Chef::Mixin::ApiVersionRequestHandling
+
+    SUPPORTED_API_VERSIONS = [0, 1].freeze
+
+    def initialize
+      @username = nil
+      @display_name = nil
+      @first_name = nil
+      @middle_name = nil
+      @last_name = nil
+      @email = nil
+      @password = nil
+      @public_key = nil
+      @private_key = nil
+      @create_key = nil
+    end
+
+    def chef_root_rest_v0
+      @chef_root_rest_v0 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_root], { api_version: "0" })
+    end
+
+    def chef_root_rest_v1
+      @chef_root_rest_v1 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_root], { api_version: "1" })
+    end
+
+    def username(arg = nil)
+      set_or_return(:username, arg,
+        regex: /^[a-z0-9\-_]+$/)
+    end
+
+    def display_name(arg = nil)
+      set_or_return(:display_name,
+        arg, kind_of: String)
+    end
+
+    def first_name(arg = nil)
+      set_or_return(:first_name,
+        arg, kind_of: String)
+    end
+
+    def middle_name(arg = nil)
+      set_or_return(:middle_name,
+        arg, kind_of: String)
+    end
+
+    def last_name(arg = nil)
+      set_or_return(:last_name,
+        arg, kind_of: String)
+    end
+
+    def email(arg = nil)
+      set_or_return(:email,
+        arg, kind_of: String)
+    end
+
+    def create_key(arg = nil)
+      set_or_return(:create_key, arg,
+        kind_of: [TrueClass, FalseClass])
+    end
+
+    def public_key(arg = nil)
+      set_or_return(:public_key,
+        arg, kind_of: String)
+    end
+
+    def private_key(arg = nil)
+      set_or_return(:private_key,
+        arg, kind_of: String)
+    end
+
+    def password(arg = nil)
+      set_or_return(:password,
+        arg, kind_of: String)
+    end
+
+    def to_h
+      result = {
+        "username" => @username,
+      }
+      result["display_name"] = @display_name unless @display_name.nil?
+      result["first_name"] = @first_name unless @first_name.nil?
+      result["middle_name"] = @middle_name unless @middle_name.nil?
+      result["last_name"] = @last_name unless @last_name.nil?
+      result["email"] = @email unless @email.nil?
+      result["password"] = @password unless @password.nil?
+      result["public_key"] = @public_key unless @public_key.nil?
+      result["private_key"] = @private_key unless @private_key.nil?
+      result["create_key"] = @create_key unless @create_key.nil?
+      result
+    end
+
+    alias_method :to_hash, :to_h
+
+    def to_json(*a)
+      Chef::JSONCompat.to_json(to_h, *a)
+    end
+
+    def destroy
+      # will default to the current API version (Chef::Authenticator::DEFAULT_SERVER_API_VERSION)
+      Chef::ServerAPI.new(Chef::Config[:chef_server_url]).delete("users/#{@username}")
+    end
+
+    def create
+      # try v1, fail back to v0 if v1 not supported
+      begin
+        payload = {
+          username: @username,
+          display_name: @display_name,
+          email: @email,
+        }
+        payload[:first_name] = @first_name unless @first_name.nil?
+        payload[:last_name] = @last_name unless @last_name.nil?
+        payload[:password] = @password unless @password.nil?
+        payload[:public_key] = @public_key unless @public_key.nil?
+        payload[:create_key] = @create_key unless @create_key.nil?
+        payload[:middle_name] = @middle_name unless @middle_name.nil?
+        raise Chef::Exceptions::InvalidUserAttribute, "You cannot set both public_key and create_key for create." if !@create_key.nil? && !@public_key.nil?
+
+        new_user = chef_root_rest_v1.post("users", payload)
+
+        # get the private_key out of the chef_key hash if it exists
+        if new_user["chef_key"]
+          if new_user["chef_key"]["private_key"]
+            new_user["private_key"] = new_user["chef_key"]["private_key"]
+          end
+          new_user["public_key"] = new_user["chef_key"]["public_key"]
+          new_user.delete("chef_key")
+        end
+      rescue Net::HTTPClientException => e
+        # rescue API V0 if 406 and the server supports V0
+        supported_versions = server_client_api_version_intersection(e, SUPPORTED_API_VERSIONS)
+        raise e unless supported_versions && supported_versions.include?(0)
+
+        payload = {
+          username: @username,
+          display_name: @display_name,
+          first_name: @first_name,
+          last_name: @last_name,
+          email: @email,
+          password: @password,
+        }
+        payload[:middle_name] = @middle_name unless @middle_name.nil?
+        payload[:public_key] = @public_key unless @public_key.nil?
+        # under API V0, the server will create a key pair if public_key isn't passed
+        new_user = chef_root_rest_v0.post("users", payload)
+      end
+
+      Chef::UserV1.from_hash(to_h.merge(new_user))
+    end
+
+    def update(new_key = false)
+      begin
+        payload = { username: username }
+        payload[:display_name] = display_name unless display_name.nil?
+        payload[:first_name] = first_name unless first_name.nil?
+        payload[:middle_name] = middle_name unless middle_name.nil?
+        payload[:last_name] = last_name unless last_name.nil?
+        payload[:email] = email unless email.nil?
+        payload[:password] = password unless password.nil?
+
+        # API V1 will fail if these key fields are defined, and try V0 below if relevant 400 is returned
+        payload[:public_key] = public_key unless public_key.nil?
+        payload[:private_key] = new_key if new_key
+
+        updated_user = chef_root_rest_v1.put("users/#{username}", payload)
+      rescue Net::HTTPClientException => e
+        if e.response.code == "400"
+          # if a 400 is returned but the error message matches the error related to private / public key fields, try V0
+          # else, raise the 400
+          error = Chef::JSONCompat.from_json(e.response.body)["error"].first
+          error_match = /Since Server API v1, all keys must be updated via the keys endpoint/.match(error)
+          if error_match.nil?
+            raise e
+          end
+        else # for other types of errors, test for API versioning errors right away
+          supported_versions = server_client_api_version_intersection(e, SUPPORTED_API_VERSIONS)
+          raise e unless supported_versions && supported_versions.include?(0)
+        end
+        updated_user = chef_root_rest_v0.put("users/#{username}", payload)
+      end
+      Chef::UserV1.from_hash(to_h.merge(updated_user))
+    end
+
+    def save(new_key = false)
+      create
+    rescue Net::HTTPClientException => e
+      if e.response.code == "409"
+        update(new_key)
+      else
+        raise e
+      end
+    end
+
+    # Note: remove after API v0 no longer supported by client (and knife command).
+    def reregister
+      begin
+        payload = to_h.merge({ "private_key" => true })
+        reregistered_self = chef_root_rest_v0.put("users/#{username}", payload)
+        private_key(reregistered_self["private_key"])
+      # only V0 supported for reregister
+      rescue Net::HTTPClientException => e
+        # if there was a 406 related to versioning, give error explaining that
+        # only API version 0 is supported for reregister command
+        if e.response.code == "406" && e.response["x-ops-server-api-version"]
+          version_header = Chef::JSONCompat.from_json(e.response["x-ops-server-api-version"])
+          min_version = version_header["min_version"]
+          max_version = version_header["max_version"]
+          error_msg = reregister_only_v0_supported_error_msg(max_version, min_version)
+          raise Chef::Exceptions::OnlyApiVersion0SupportedForAction.new(error_msg)
+        else
+          raise e
+        end
+      end
+      self
+    end
+
+    def to_s
+      "user[#{@username}]"
+    end
+
+    # Class Methods
+    def self.from_hash(user_hash)
+      user = Chef::UserV1.new
+      user.username user_hash["username"]
+      user.display_name user_hash["display_name"] if user_hash.key?("display_name")
+      user.first_name user_hash["first_name"] if user_hash.key?("first_name")
+      user.middle_name user_hash["middle_name"] if user_hash.key?("middle_name")
+      user.last_name user_hash["last_name"] if user_hash.key?("last_name")
+      user.email user_hash["email"] if user_hash.key?("email")
+      user.password user_hash["password"] if user_hash.key?("password")
+      user.public_key user_hash["public_key"] if user_hash.key?("public_key")
+      user.private_key user_hash["private_key"] if user_hash.key?("private_key")
+      user.create_key user_hash["create_key"] if user_hash.key?("create_key")
+      user
+    end
+
+    def self.from_json(json)
+      Chef::UserV1.from_hash(Chef::JSONCompat.from_json(json))
+    end
+
+    def self.list(inflate = false)
+      response = Chef::ServerAPI.new(Chef::Config[:chef_server_url]).get("users")
+      users = if response.is_a?(Array)
+                # EC 11 / CS 12 V0, V1
+                #   GET /organizations/<org>/users
+                transform_list_response(response)
+              else
+                # OSC 11
+                #  GET /users
+                # EC 11 / CS 12 V0, V1
+                #  GET /users
+                response # OSC
+              end
+
+      if inflate
+        users.inject({}) do |user_map, (name, _url)|
+          user_map[name] = Chef::UserV1.load(name)
+          user_map
+        end
+      else
+        users
+      end
+    end
+
+    def self.load(username)
+      # will default to the current API version (Chef::Authenticator::DEFAULT_SERVER_API_VERSION)
+      response = Chef::ServerAPI.new(Chef::Config[:chef_server_url]).get("users/#{username}")
+      Chef::UserV1.from_hash(response)
+    end
+
+    # Gross.  Transforms an API response in the form of:
+    # [ { "user" => { "username" => USERNAME }}, ...]
+    # into the form
+    # { "USERNAME" => "URI" }
+    def self.transform_list_response(response)
+      new_response = {}
+      response.each do |u|
+        name = u["user"]["username"]
+        new_response[name] = Chef::Config[:chef_server_url] + "/users/#{name}"
+      end
+      new_response
+    end
+
+    private_class_method :transform_list_response
+
+  end
+end

data/lib/chef/util/backup.rb

@@ -0,0 +1,94 @@
+#
+# Author:: Lamont Granquist (<lamont@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 "path_helper"
+
+class Chef
+  class Util
+    class Backup
+      attr_reader :new_resource
+      attr_accessor :path
+
+      def initialize(new_resource, path = nil)
+        @new_resource = new_resource
+        @path = path.nil? ? new_resource.path : path
+      end
+
+      def backup!
+        if @new_resource.backup != false && @new_resource.backup > 0 && ::File.exist?(path)
+          do_backup
+          # Clean up after the number of backups
+          slice_number = @new_resource.backup
+          backup_files = sorted_backup_files
+          if backup_files.length >= @new_resource.backup
+            remainder = backup_files.slice(slice_number..)
+            remainder.each do |backup_to_delete|
+              delete_backup(backup_to_delete)
+            end
+          end
+        end
+      end
+
+      private
+
+      def backup_filename
+        @backup_filename ||= begin
+          time = Time.now
+          nanoseconds = sprintf("%6f", time.to_f).split(".")[1]
+          savetime = time.strftime("%Y%m%d%H%M%S.#{nanoseconds}")
+          backup_filename = "#{path}.chef-#{savetime}"
+          backup_filename = backup_filename.sub(/^([A-Za-z]:)/, "") # strip drive letter on Windows
+        end
+      end
+
+      def prefix
+        # if :file_backup_path is nil, we fallback to the old behavior of
+        # keeping the backup in the same directory. We also need to to_s it
+        # so we don't get a type error around implicit to_str conversions.
+        @prefix ||= Chef::Config[:file_backup_path].to_s
+      end
+
+      def backup_path
+        @backup_path ||= ::File.join(prefix, backup_filename)
+      end
+
+      def do_backup
+        FileUtils.mkdir_p(::File.dirname(backup_path)) if Chef::Config[:file_backup_path]
+        FileUtils.cp(path, backup_path, preserve: true)
+        Chef::Log.info("#{@new_resource} backed up to #{backup_path}")
+      end
+
+      def delete_backup(backup_file)
+        FileUtils.rm(backup_file)
+        Chef::Log.info("#{@new_resource} removed backup at #{backup_file}")
+      end
+
+      def unsorted_backup_files
+        # If you replace this with Dir[], you will probably break Windows.
+        fn = Regexp.escape(::File.basename(path))
+        Dir.entries(::File.dirname(backup_path)).select do |f|
+          !!(f =~ /\A#{fn}.chef-[0-9.]*\B/)
+        end.map { |f| ::File.join(::File.dirname(backup_path), f) }
+      end
+
+      def sorted_backup_files
+        unsorted_backup_files.sort.reverse # faster than sort { |a, b| b <=> a }
+      end
+    end
+  end
+end

data/lib/chef/util/diff.rb

@@ -0,0 +1,186 @@
+# Author:: Lamont Granquist (<lamont@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.
+#
+# Some portions of this file are derived from material in the diff-lcs
+# project licensed under the terms of the MIT license, provided below.
+#
+# Copyright:: Copyright 2004-2016, Austin Ziegler
+# License:: MIT
+#
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation files
+# (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of this Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OF OTHER DEALINGS IN THE
+# SOFTWARE.
+
+class Chef
+  class Util
+    class Diff
+      # @todo: to_a, to_s, to_json, inspect defs, accessors for @diff and @error
+      # @todo: move coercion to UTF-8 into to_json
+
+      def for_output
+        # formatted output to a terminal uses arrays of strings and returns error strings
+        @diff.nil? ? [ @error ] : @diff
+      end
+
+      def for_reporting
+        # caller needs to ensure that new files aren't posted to resource reporting
+        return nil if @diff.nil?
+
+        @diff.join("\\n")
+      end
+
+      def use_tempfile_if_missing(file)
+        tempfile = nil
+        unless File.exist?(file)
+          Chef::Log.trace("File #{file} does not exist to diff against, using empty tempfile")
+          tempfile = Tempfile.new("chef-diff")
+          file = tempfile.path
+        end
+        yield file
+        unless tempfile.nil?
+          tempfile.close
+          tempfile.unlink
+        end
+      end
+
+      def diff(old_file, new_file)
+        use_tempfile_if_missing(old_file) do |old_file|
+          use_tempfile_if_missing(new_file) do |new_file|
+            @error = do_diff(old_file, new_file)
+          end
+        end
+      end
+
+      # produces a unified-output-format diff with 3 lines of context
+      # ChefFS uses udiff() directly
+      def udiff(old_file, new_file)
+        require "diff/lcs"
+        require "diff/lcs/hunk"
+
+        diff_str = ""
+        file_length_difference = 0
+
+        old_data = IO.readlines(old_file).map(&:chomp)
+        new_data = IO.readlines(new_file).map(&:chomp)
+        diff_data = ::Diff::LCS.diff(old_data, new_data)
+
+        return diff_str if old_data.empty? && new_data.empty?
+        return "No differences encountered\n" if diff_data.empty?
+
+        # write diff header (standard unified format)
+        ft = File.stat(old_file).mtime.localtime.strftime("%Y-%m-%d %H:%M:%S.%N %z")
+        diff_str << "--- #{old_file}\t#{ft}\n"
+        ft = File.stat(new_file).mtime.localtime.strftime("%Y-%m-%d %H:%M:%S.%N %z")
+        diff_str << "+++ #{new_file}\t#{ft}\n"
+
+        # loop over diff hunks. if a hunk overlaps with the last hunk,
+        # join them. otherwise, print out the old one.
+        old_hunk = hunk = nil
+        diff_data.each do |piece|
+
+          hunk = ::Diff::LCS::Hunk.new(old_data, new_data, piece, 3, file_length_difference)
+          file_length_difference = hunk.file_length_difference
+          next unless old_hunk
+          next if hunk.merge(old_hunk)
+
+          diff_str << old_hunk.diff(:unified) << "\n"
+        ensure
+          old_hunk = hunk
+
+        end
+        diff_str << old_hunk.diff(:unified) << "\n"
+        diff_str
+      end
+
+      private
+
+      def do_diff(old_file, new_file)
+        if Chef::Config[:diff_disabled]
+          return "(diff output suppressed by config)"
+        end
+
+        diff_filesize_threshold = Chef::Config[:diff_filesize_threshold]
+        diff_output_threshold = Chef::Config[:diff_output_threshold]
+
+        if ::File.size(old_file) > diff_filesize_threshold || ::File.size(new_file) > diff_filesize_threshold
+          return "(file sizes exceed #{diff_filesize_threshold} bytes, diff output suppressed)"
+        end
+
+        # macOS(BSD?) diff will *sometimes* happily spit out nasty binary diffs
+        return "(current file is binary, diff output suppressed)" if is_binary?(old_file)
+        return "(new content is binary, diff output suppressed)" if is_binary?(new_file)
+
+        begin
+          Chef::Log.trace("Running: diff -u #{old_file} #{new_file}")
+          diff_str = udiff(old_file, new_file)
+
+        rescue Exception => e
+          # Should *not* receive this, but in some circumstances it seems that
+          # an exception can be thrown even using shell_out instead of shell_out!
+          return "Could not determine diff. Error: #{e.message}"
+        end
+
+        if !diff_str.empty? && diff_str != "No differences encountered\n"
+          if diff_str.length > diff_output_threshold
+            "(long diff of over #{diff_output_threshold} characters, diff output suppressed)"
+          else
+            diff_str = encode_diff_for_json(diff_str)
+            @diff = diff_str.split("\n")
+            "(diff available)"
+          end
+        else
+          "(no diff)"
+        end
+      end
+
+      def is_binary?(path)
+        File.open(path) do |file|
+          # XXX: this slurps into RAM, but we should have already checked our diff has a reasonable size
+          buff = file.read
+          buff = "" if buff.nil?
+          begin
+            return buff !~ /\A[\s[:print:]]*\z/m
+          rescue ArgumentError => e
+            return true if /invalid byte sequence/.match?(e.message)
+
+            raise
+          end
+        end
+      end
+
+      def encode_diff_for_json(diff_str)
+        diff_str.encode!("UTF-8", invalid: :replace, undef: :replace, replace: "?")
+      end
+
+    end
+  end
+end