chef 18.5.0 → 18.6.2

data/lib/chef/target_io/train/http.rb

@@ -1,117 +0,0 @@
-# require_relative "../mixin/which"
-
-module TargetIO
-  module TrainCompat
-    class HTTP
-      attr_reader :last_response
-
-      def initialize(url, options = {})
-        @url = url.is_a?(URI) ? url.to_s : url
-        @options = options
-        @last_response = ""
-      end
-
-      # Send an HTTP HEAD request to the path
-      #
-      # === Parameters
-      # path:: path part of the request URL
-      def head(path, headers = {})
-        request(:HEAD, path, headers)
-      end
-
-      # Send an HTTP GET request to the path
-      #
-      # === Parameters
-      # path:: The path to GET
-      def get(path, headers = {})
-        request(:GET, path, headers)
-      end
-
-      # Send an HTTP PUT request to the path
-      #
-      # === Parameters
-      # path:: path part of the request URL
-      def put(path, json, headers = {})
-        request(:PUT, path, headers, json)
-      end
-
-      # Send an HTTP POST request to the path
-      #
-      # === Parameters
-      # path:: path part of the request URL
-      def post(path, json, headers = {})
-        request(:POST, path, headers, json)
-      end
-
-      # Send an HTTP DELETE request to the path
-      #
-      # === Parameters
-      # path:: path part of the request URL
-      def delete(path, headers = {})
-        request(:DELETE, path, headers)
-      end
-
-      # Used inside Chef::Provider::RemoteFile::HTTPS
-      def streaming_request(path, headers = {}, tempfile = nil)
-        content = get(path, headers)
-        @last_response = content
-
-        tempfile.write(content)
-        tempfile.close
-
-        tempfile
-      end
-
-      def request(method, path, headers = {}, data = false)
-        cmd = nil
-        path = path.is_a?(URI) ? path.to_s : path
-        headers.merge!(@options[:headers] || {})
-
-        SUPPORTED_COMMANDS.each do |command_name|
-          executable = which(command_name).chop
-          next if !executable || executable.empty?
-
-          # There are different ways to call (constructor, argument, combination of both)
-          full_url = if path.start_with?("http")
-                       path
-                     elsif path.empty? || @url.end_with?(path)
-                       @url
-                     else
-                       File.join(@url, path)
-                     end
-
-          cmd = send(command_name.to_sym, executable, method.to_s.upcase, full_url, headers, data)
-          break
-        end
-
-        raise "Target needs one of #{SUPPORTED_COMMANDS.join("/")} for HTTP requests to work" unless cmd
-
-        connection = Chef.run_context&.transport_connection
-        connection.run_command(cmd).stdout
-      end
-
-      SUPPORTED_COMMANDS = %w{curl wget}.freeze
-
-      # Sending data is not yet supported
-      def curl(cmd, method, url, headers, _data)
-        cmd += headers.map { |name, value| " --header '#{name}: #{value}'" }.join
-        cmd += " --request #{method} "
-        cmd += url
-      end
-
-      # Sending data is not yet supported
-      def wget(cmd, method, url, headers, _data)
-        cmd += headers.map { |name, value| " --header '#{name}: #{value}'" }.join
-        cmd += " --method #{method}"
-        cmd += " --output-document=- "
-        cmd += url
-      end
-
-      # extend Chef::Mixin::Which
-      def which(cmd)
-        connection = Chef.run_context&.transport_connection
-        connection.run_command("which #{cmd}").stdout
-      end
-    end
-  end
-end

data/lib/chef/target_io/train/io.rb

@@ -1,13 +0,0 @@
-require_relative "file"
-
-module TargetIO
-  module TrainCompat
-    class IO
-      class << self
-        def read(path)
-          TargetIO::File.read(path)
-        end
-      end
-    end
-  end
-end

data/lib/chef/target_io/train/shadow.rb

@@ -1,52 +0,0 @@
-module TargetIO
-  module TrainCompat
-    module Shadow
-      # @see https://www.rubydoc.info/gems/ruby-shadow/2.5.0
-      class Passwd
-        class << self
-          def getspnam(name)
-            content = ::TargetIO::File.read("/etc/shadow")
-            entries = __parse_shadow(content)
-            data    = entries.detect { |entry| entry["name"] == name }
-            return ::TargetIO::Shadow::Entry.new unless data
-
-            ::TargetIO::Shadow::Entry.new(
-              data["sp_namp"],
-              data["sp_pwdp"],
-              data["sp_lstchg"],
-              data["sp_min"],
-              data["sp_max"],
-              data["sp_warn"],
-              data["sp_inact"],
-              data["sp_expire"],
-              data["sp_loginclass"]
-            )
-          end
-
-          def __parse_shadow(content)
-            content.to_s.split("\n").map do |line|
-              next if line[0] == "#"
-
-              __parse_shadow_line(line)
-            end.compact
-          end
-
-          def __parse_shadow_line(line)
-            x = line.split(":")
-            {
-              # rubocop:disable Layout/AlignHash
-              "sp_namp"   => x.at(0),
-              "sp_pwdp"   => x.at(1),
-              "sp_lstchg" => x.at(2),
-              "sp_min"    => x.at(3),
-              "sp_max"    => x.at(4),
-              "sp_warn"   => x.at(5),
-              "sp_inact"  => x.at(6),
-              "sp_expire" => x.at(7),
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/chef/target_io/train_compat.rb

@@ -1,7 +0,0 @@
-require_relative "train/dir"
-require_relative "train/etc"
-require_relative "train/file"
-require_relative "train/fileutils"
-require_relative "train/http"
-require_relative "train/io"
-require_relative "train/shadow"

data/lib/chef/target_io.rb

@@ -1,9 +0,0 @@
-require_relative "target_io/dir"
-require_relative "target_io/etc"
-require_relative "target_io/file"
-require_relative "target_io/fileutils"
-require_relative "target_io/http"
-require_relative "target_io/io"
-require_relative "target_io/shadow"
-
-require_relative "target_io/train_compat"

data/spec/unit/mixin/homebrew_user_spec.rb

@@ -1,119 +0,0 @@
-#
-# Author:: Joshua Timberman (<joshua@chef.io>)
-#
-# Copyright:: Copyright (c) Chef Software Inc.
-#
-# 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 "spec_helper"
-require "chef/mixin/homebrew_user"
-
-class ExampleHomebrewUser
-  include Chef::Mixin::HomebrewUser
-end
-
-describe Chef::Mixin::HomebrewUser do
-  let(:homebrew_user) { ExampleHomebrewUser.new }
-  let(:node) { Chef::Node.new }
-
-  describe "when the homebrew user is provided" do
-    let(:uid) { 1001 }
-    let(:user) { "foo" }
-
-    it "returns the homebrew user without looking at the file when uid is provided" do
-      expect(File).to receive(:exist?).exactly(0).times
-      expect(homebrew_user.find_homebrew_uid(uid)).to eq(uid)
-    end
-
-    it "returns the homebrew user without looking at the file when name is provided" do
-      expect(File).to receive(:exist?).exactly(0).times
-      allow(Etc).to receive_message_chain(:getpwnam, :uid).and_return(uid)
-      expect(homebrew_user.find_homebrew_uid(user)).to eq(uid)
-    end
-
-  end
-
-  shared_examples "successfully find executable" do
-    let(:user) { nil }
-    let(:brew_owner) { 2001 }
-    let(:default_brew_path) { "/usr/local/bin/brew" }
-    let(:default_brew_path_arm) { "/opt/homebrew/bin/brew" }
-    let(:default_brew_path_linux) { "/home/linuxbrew/.linuxbrew/bin/brew" }
-    let(:stat_double) do
-      d = double
-      expect(d).to receive(:uid).and_return(brew_owner)
-      d
-    end
-
-    context "debug statement prints owner name" do
-
-      before do
-        expect(Etc).to receive(:getpwuid).with(brew_owner).and_return(OpenStruct.new(name: "name"))
-      end
-
-      def false_unless_specific_value(object, method, value)
-        allow(object).to receive(method).and_return(false)
-        allow(object).to receive(method).with(value).and_return(true)
-      end
-
-      it "returns the owner of the brew executable when it is at a default location for x86_64 machines" do
-        false_unless_specific_value(File, :exist?, default_brew_path)
-        false_unless_specific_value(File, :executable?, default_brew_path)
-        allow(File).to receive(:stat).with(default_brew_path).and_return(stat_double)
-        expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
-      end
-
-      it "returns the owner of the brew executable when it is at a default location for arm machines" do
-        false_unless_specific_value(File, :exist?, default_brew_path_arm)
-        false_unless_specific_value(File, :executable?, default_brew_path_arm)
-        allow(File).to receive(:stat).with(default_brew_path_arm).and_return(stat_double)
-        expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
-      end
-
-      it "returns the owner of the brew executable when it is at a default location for linux machines" do
-        false_unless_specific_value(File, :exist?, default_brew_path_linux)
-        false_unless_specific_value(File, :executable?, default_brew_path_linux)
-        allow(File).to receive(:stat).with(default_brew_path_linux).and_return(stat_double)
-        expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
-      end
-
-      it "returns the owner of the brew executable when it is not at a default location" do
-        allow_any_instance_of(ExampleHomebrewUser).to receive(:which).and_return("/foo")
-        false_unless_specific_value(File, :exist?, "/foo")
-        false_unless_specific_value(File, :executable?, "/foo")
-        allow(homebrew_user).to receive_message_chain(:shell_out, :stdout, :strip).and_return("/foo")
-        allow(File).to receive(:stat).with("/foo").and_return(stat_double)
-        expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
-      end
-
-    end
-  end
-
-  describe "when the homebrew user is not provided" do
-
-    it "raises an error if no executable is found" do
-      expect(File).to receive(:exist?).and_return(nil).at_least(:once)
-      expect { homebrew_user.find_homebrew_uid(user) }.to raise_error(Chef::Exceptions::CannotDetermineHomebrewOwner)
-    end
-
-    include_examples "successfully find executable"
-
-    context "the executable is owned by root" do
-      include_examples "successfully find executable" do
-        let(:brew_owner) { 0 }
-      end
-    end
-
-  end
-
-end