chef 12.19.36 → 14.14.25

data/lib/chef/resource/windows_firewall_rule.rb

@@ -0,0 +1,205 @@
+# Author:: Matt Clifton (spartacus003@hotmail.com)
+# Author:: Matt Stratton (matt.stratton@gmail.com)
+# Author:: Tor Magnus Rakvåg (tor.magnus@outlook.com)
+# Author:: Tim Smith (tsmith@chef.io)
+# Copyright:: 2013-2015 Matt Clifton
+# Copyright:: 2018, Chef Software, Inc.
+# Copyright:: 2018, Intility AS
+#
+# 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/json_compat"
+
+class Chef
+  class Resource
+    class WindowsFirewallRule < Chef::Resource
+      preview_resource true
+      resource_name :windows_firewall_rule
+
+      description "Use the windows_firewall_rule resource to create, change or remove windows firewall rules."
+      introduced "14.7"
+
+      property :rule_name, String,
+               name_property: true,
+               description: "An optional property to set the name of the firewall rule to assign if it differs from the resource block's name."
+
+      property :description, String,
+               default: "Firewall rule",
+               description: "The description to assign to the firewall rule."
+
+      property :local_address, String,
+               description: "The local address the firewall rule applies to."
+
+      property :local_port, [String, Integer, Array],
+               # split various formats of comma separated lists and provide a sorted array of strings to match PS output
+               coerce: proc { |d| d.is_a?(String) ? d.split(/\s*,\s*/).sort : Array(d).sort.map { |x| x.to_s } },
+               description: "The local port the firewall rule applies to."
+
+      property :remote_address, String,
+               description: "The remote address the firewall rule applies to."
+
+      property :remote_port, [String, Integer, Array],
+               # split various formats of comma separated lists and provide a sorted array of strings to match PS output
+               coerce: proc { |d| d.is_a?(String) ? d.split(/\s*,\s*/).sort : Array(d).sort.map { |x| x.to_s } },
+               description: "The remote port the firewall rule applies to."
+
+      property :direction, [Symbol, String],
+               default: :inbound, equal_to: [:inbound, :outbound],
+               description: "The direction of the firewall rule. Direction means either inbound or outbound traffic.",
+               coerce: proc { |d| d.is_a?(String) ? d.downcase.to_sym : d }
+
+      property :protocol, String,
+               default: "TCP",
+               description: "The protocol the firewall rule applies to."
+
+      property :firewall_action, [Symbol, String],
+               default: :allow, equal_to: [:allow, :block, :notconfigured],
+               description: "The action of the firewall rule.",
+               coerce: proc { |f| f.is_a?(String) ? f.downcase.to_sym : f }
+
+      property :profile, [Symbol, String],
+               default: :any, equal_to: [:public, :private, :domain, :any, :notapplicable],
+               description: "The profile the firewall rule applies to.",
+               coerce: proc { |p| p.is_a?(String) ? p.downcase.to_sym : p }
+
+      property :program, String,
+               description: "The program the firewall rule applies to."
+
+      property :service, String,
+               description: "The service the firewall rule applies to."
+
+      property :interface_type, [Symbol, String],
+               default: :any, equal_to: [:any, :wireless, :wired, :remoteaccess],
+               description: "The interface type the firewall rule applies to.",
+               coerce: proc { |i| i.is_a?(String) ? i.downcase.to_sym : i }
+
+      property :enabled, [TrueClass, FalseClass],
+               default: true,
+               description: "Whether or not to enable the firewall rule."
+
+      alias_method :localip, :local_address
+      alias_method :remoteip, :remote_address
+      alias_method :localport, :local_port
+      alias_method :remoteport, :remote_port
+      alias_method :interfacetype, :interface_type
+
+      load_current_value do
+        load_state_cmd = load_firewall_state(rule_name)
+        output = powershell_out(load_state_cmd)
+        if output.stdout.empty?
+          current_value_does_not_exist!
+        else
+          state = Chef::JSONCompat.from_json(output.stdout)
+        end
+        local_address state["local_address"]
+        local_port Array(state["local_port"]).sort
+        remote_address state["remote_address"]
+        remote_port Array(state["remote_port"]).sort
+        direction state["direction"]
+        protocol state["protocol"]
+        firewall_action state["firewall_action"]
+        profile state["profile"]
+        program state["program"]
+        service state["service"]
+        interface_type state["interface_type"]
+        enabled state["enabled"]
+      end
+
+      action :create do
+        description "Create a Windows firewall entry."
+
+        if current_resource
+          converge_if_changed :rule_name, :local_address, :local_port, :remote_address, :remote_port, :direction,
+                              :protocol, :firewall_action, :profile, :program, :service, :interface_type, :enabled do
+            cmd = firewall_command("Set")
+            powershell_out!(cmd)
+          end
+        else
+          converge_by("create firewall rule #{new_resource.rule_name}") do
+            cmd = firewall_command("New")
+            powershell_out!(cmd)
+          end
+        end
+      end
+
+      action :delete do
+        description "Delete an existing Windows firewall entry."
+
+        if current_resource
+          converge_by("delete firewall rule #{new_resource.rule_name}") do
+            powershell_out!("Remove-NetFirewallRule -Name '#{new_resource.rule_name}'")
+          end
+        else
+          Chef::Log.info("Firewall rule \"#{new_resource.rule_name}\" doesn't exist. Skipping.")
+        end
+      end
+
+      action_class do
+        # build the command to create a firewall rule based on new_resource values
+        # @return [String] firewall create command
+        def firewall_command(cmdlet_type)
+          cmd = "#{cmdlet_type}-NetFirewallRule -Name '#{new_resource.rule_name}'"
+          cmd << " -DisplayName '#{new_resource.rule_name}'" if cmdlet_type == "New"
+          cmd << " -Description '#{new_resource.description}'" if new_resource.description
+          cmd << " -LocalAddress '#{new_resource.local_address}'" if new_resource.local_address
+          cmd << " -LocalPort #{new_resource.local_port.join(',')}" if new_resource.local_port
+          cmd << " -RemoteAddress '#{new_resource.remote_address}'" if new_resource.remote_address
+          cmd << " -RemotePort #{new_resource.remote_port.join(',')}" if new_resource.remote_port
+          cmd << " -Direction '#{new_resource.direction}'" if new_resource.direction
+          cmd << " -Protocol '#{new_resource.protocol}'" if new_resource.protocol
+          cmd << " -Action '#{new_resource.firewall_action}'" if new_resource.firewall_action
+          cmd << " -Profile '#{new_resource.profile}'" if new_resource.profile
+          cmd << " -Program '#{new_resource.program}'" if new_resource.program
+          cmd << " -Service '#{new_resource.service}'" if new_resource.service
+          cmd << " -InterfaceType '#{new_resource.interface_type}'" if new_resource.interface_type
+          cmd << " -Enabled '#{new_resource.enabled}'"
+
+          cmd
+        end
+      end
+
+      private
+
+      # build the command to load the current resource
+      # # @return [String] current firewall state
+      def load_firewall_state(rule_name)
+        <<-EOH
+          Remove-TypeData System.Array # workaround for PS bug here: https://bit.ly/2SRMQ8M
+          $rule = Get-NetFirewallRule -Name '#{rule_name}'
+          $addressFilter = $rule | Get-NetFirewallAddressFilter
+          $portFilter = $rule | Get-NetFirewallPortFilter
+          $applicationFilter = $rule | Get-NetFirewallApplicationFilter
+          $serviceFilter = $rule | Get-NetFirewallServiceFilter
+          $interfaceTypeFilter = $rule | Get-NetFirewallInterfaceTypeFilter
+          ([PSCustomObject]@{
+            rule_name = $rule.Name
+            description = $rule.Description
+            local_address = $addressFilter.LocalAddress
+            local_port = $portFilter.LocalPort
+            remote_address = $addressFilter.RemoteAddress
+            remote_port = $portFilter.RemotePort
+            direction = $rule.Direction.ToString()
+            protocol = $portFilter.Protocol
+            firewall_action = $rule.Action.ToString()
+            profile = $rule.Profile.ToString()
+            program = $applicationFilter.Program
+            service = $serviceFilter.Service
+            interface_type = $interfaceTypeFilter.InterfaceType.ToString()
+            enabled = [bool]::Parse($rule.Enabled.ToString())
+          }) | ConvertTo-Json
+        EOH
+      end
+    end
+  end
+end

data/lib/chef/resource/windows_font.rb

@@ -0,0 +1,125 @@
+#
+# Copyright:: 2014-2018, Schuberg Philis BV.
+# Copyright:: 2017-2018, 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 "chef/resource"
+
+class Chef
+  class Resource
+    class WindowsFont < Chef::Resource
+      require "chef/util/path_helper"
+
+      resource_name :windows_font
+      provides(:windows_font) { true }
+
+      description "Use the windows_font resource to install font files on Windows. By default, the font is sourced from the cookbook using the resource, but a URI source can be specified as well."
+      introduced "14.0"
+
+      property :font_name, String,
+               description: "An optional property to set the name of the font to install if it differs from the resource block's name.",
+               name_property: true
+
+      property :source, String,
+               description: "A local filesystem path or URI that is used to source the font file.",
+               coerce: proc { |x| x =~ /^.:.*/ ? x.tr('\\', "/").gsub("//", "/") : x }
+
+      action :install do
+        description "Install a font to the system fonts directory."
+
+        if font_exists?
+          logger.trace("Not installing font: #{new_resource.font_name} as font already installed.")
+        else
+          retrieve_cookbook_font
+          install_font
+          del_cookbook_font
+        end
+      end
+
+      action_class do
+        # if a source is specified fetch using remote_file. If not use cookbook_file
+        def retrieve_cookbook_font
+          font_file = new_resource.font_name
+          if new_resource.source
+            declare_resource(:remote_file, font_file) do
+              action :nothing
+              source source_uri
+              path Chef::Util::PathHelper.join(ENV["TEMP"], font_file)
+            end.run_action(:create)
+          else
+            declare_resource(:cookbook_file, font_file) do
+              action    :nothing
+              cookbook  cookbook_name.to_s unless cookbook_name.nil?
+              path      Chef::Util::PathHelper.join(ENV["TEMP"], font_file)
+            end.run_action(:create)
+          end
+        end
+
+        # delete the temp cookbook file
+        def del_cookbook_font
+          file Chef::Util::PathHelper.join(ENV["TEMP"], new_resource.font_name) do
+            action :delete
+          end
+        end
+
+        # install the font into the appropriate fonts directory
+        def install_font
+          require "win32ole" if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+          fonts_dir = Chef::Util::PathHelper.join(ENV["windir"], "fonts")
+          folder = WIN32OLE.new("Shell.Application").Namespace(fonts_dir)
+          converge_by("install font #{new_resource.font_name} to #{fonts_dir}") do
+            folder.CopyHere(Chef::Util::PathHelper.join(ENV["TEMP"], new_resource.font_name))
+          end
+        end
+
+        # Check to see if the font is installed in the fonts dir
+        #
+        # @return [Boolean] Is the font is installed?
+        def font_exists?
+          require "win32ole" if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+          fonts_dir = WIN32OLE.new("WScript.Shell").SpecialFolders("Fonts")
+          logger.trace("Seeing if the font at #{Chef::Util::PathHelper.join(fonts_dir, new_resource.font_name)} exists")
+          ::File.exist?(Chef::Util::PathHelper.join(fonts_dir, new_resource.font_name))
+        end
+
+        # Parse out the schema provided to us to see if it's one we support via remote_file.
+        # We do this because URI will parse C:/foo as schema 'c', which won't work with remote_file
+        #
+        # @return [Boolean]
+        def remote_file_schema?(schema)
+          return true if %w{http https ftp}.include?(schema)
+        end
+
+        # return new_resource.source if we have a proper URI specified
+        # if it's a local file listed as a source return it in file:// format
+        #
+        # @return [String] path to the font
+        def source_uri
+          begin
+            require "uri"
+            if remote_file_schema?(URI.parse(new_resource.source).scheme)
+              logger.trace("source property starts with ftp/http. Using source property unmodified")
+              return new_resource.source
+            end
+          rescue URI::InvalidURIError
+            Chef::Log.warn("source property of #{new_resource.source} could not be processed as a URI. Check the format you provided.")
+          end
+          logger.trace("source property does not start with ftp/http. Prepending with file:// as it appears to be a local file.")
+          "file://#{new_resource.source}"
+        end
+      end
+    end
+  end
+end

data/lib/chef/resource/windows_package.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Bryan McLellan <btm@loftninjas.org>
-# Copyright:: Copyright 2014-2016, Chef Software, Inc.
+# Copyright:: Copyright 2014-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -27,9 +27,12 @@ class Chef
       include Chef::Mixin::Uris
 
       resource_name :windows_package
-      provides :windows_package, os: "windows"
+      provides(:windows_package) { true }
       provides :package, os: "windows"
 
+      description "Use the windows_package resource to manage Microsoft Installer Package (MSI) packages for the Microsoft Windows platform."
+      introduced "11.12"
+
       allowed_actions :install, :remove
 
       def initialize(name, run_context = nil)
@@ -37,6 +40,9 @@ class Chef
         @source ||= source(@package_name) if @package_name.downcase.end_with?(".msi")
       end
 
+      # windows can't take array options yet
+      property :options, String
+
       # Unique to this resource
       property :installer_type, Symbol
       property :timeout, [ String, Integer ], default: 600

data/lib/chef/resource/windows_pagefile.rb

@@ -0,0 +1,206 @@
+#
+# Copyright:: 2012-2018, Nordstrom, Inc.
+# Copyright:: 2017-2018, 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 "chef/resource"
+
+class Chef
+  class Resource
+    class WindowsPagefile < Chef::Resource
+      resource_name :windows_pagefile
+      provides(:windows_pagefile) { true }
+
+      description "Use the windows_pagefile resource to configure pagefile settings on Windows."
+      introduced "14.0"
+
+      property :path, String,
+               coerce: proc { |x| x.tr("/", '\\') },
+               description: "An optional property to set the pagefile name if it differs from the resource block's name.",
+               name_property: true
+
+      property :system_managed, [TrueClass, FalseClass],
+               description: "Configures whether the system manages the pagefile size."
+
+      property :automatic_managed, [TrueClass, FalseClass],
+               description: "Enable automatic management of pagefile initial and maximum size. Setting this to true ignores 'initial_size' and 'maximum_size' properties.",
+               default: false
+
+      property :initial_size, Integer,
+               description: "Initial size of the pagefile in megabytes."
+
+      property :maximum_size, Integer,
+               description: "Maximum size of the pagefile in megabytes."
+
+      action :set do
+        description "Configures the default pagefile, creating if it doesn't exist."
+
+        pagefile = new_resource.path
+        initial_size = new_resource.initial_size
+        maximum_size = new_resource.maximum_size
+        system_managed = new_resource.system_managed
+        automatic_managed = new_resource.automatic_managed
+
+        if automatic_managed
+          set_automatic_managed unless automatic_managed?
+        else
+          unset_automatic_managed if automatic_managed?
+
+          # Check that the resource is not just trying to unset automatic managed, if it is do nothing more
+          if (initial_size && maximum_size) || system_managed
+            validate_name
+            create(pagefile) unless exists?(pagefile)
+
+            if system_managed
+              set_system_managed(pagefile) unless max_and_min_set?(pagefile, 0, 0)
+            else
+              unless max_and_min_set?(pagefile, initial_size, maximum_size)
+                set_custom_size(pagefile, initial_size, maximum_size)
+              end
+            end
+          end
+        end
+      end
+
+      action :delete do
+        description "Deletes the specified pagefile."
+
+        validate_name
+        delete(new_resource.path) if exists?(new_resource.path)
+      end
+
+      action_class do
+        # make sure the provided name property matches the appropriate format
+        # we do this here and not in the property itself because if automatic_managed
+        # is set then this validation is not necessary / doesn't make sense at all
+        def validate_name
+          return if /^.:.*.sys/ =~ new_resource.path
+          raise "#{new_resource.path} does not match the format DRIVE:\\path\\file.sys for pagefiles. Example: C:\\pagefile.sys"
+        end
+
+        # See if the pagefile exists
+        #
+        # @param [String] pagefile path to the pagefile
+        # @return [Boolean]
+        def exists?(pagefile)
+          @exists ||= begin
+            logger.trace("Checking if #{pagefile} exists by runing: wmic.exe pagefileset where SettingID=\"#{get_setting_id(pagefile)}\" list /format:list")
+            cmd = shell_out("wmic.exe pagefileset where SettingID=\"#{get_setting_id(pagefile)}\" list /format:list", returns: [0])
+            cmd.stderr.empty? && (cmd.stdout =~ /SettingID=#{get_setting_id(pagefile)}/i)
+          end
+        end
+
+        # is the max/min pagefile size set?
+        #
+        # @param [String] pagefile path to the pagefile
+        # @param [String] min the minimum size of the pagefile
+        # @param [String] max the minimum size of the pagefile
+        # @return [Boolean]
+        def max_and_min_set?(pagefile, min, max)
+          @max_and_min_set ||= begin
+            logger.trace("Checking if #{pagefile} min: #{min} and max #{max} are set")
+            cmd = shell_out("wmic.exe pagefileset where SettingID=\"#{get_setting_id(pagefile)}\" list /format:list", returns: [0])
+            cmd.stderr.empty? && (cmd.stdout =~ /InitialSize=#{min}/i) && (cmd.stdout =~ /MaximumSize=#{max}/i)
+          end
+        end
+
+        # create a pagefile
+        #
+        # @param [String] pagefile path to the pagefile
+        def create(pagefile)
+          converge_by("create pagefile #{pagefile}") do
+            logger.trace("Running wmic.exe pagefileset create name=\"#{pagefile}\"")
+            cmd = shell_out("wmic.exe pagefileset create name=\"#{pagefile}\"")
+            check_for_errors(cmd.stderr)
+          end
+        end
+
+        # delete a pagefile
+        #
+        # @param [String] pagefile path to the pagefile
+        def delete(pagefile)
+          converge_by("remove pagefile #{pagefile}") do
+            logger.trace("Running wmic.exe pagefileset where SettingID=\"#{get_setting_id(pagefile)}\" delete")
+            cmd = shell_out("wmic.exe pagefileset where SettingID=\"#{get_setting_id(pagefile)}\" delete")
+            check_for_errors(cmd.stderr)
+          end
+        end
+
+        # see if the pagefile is automatically managed by Windows
+        #
+        # @return [Boolean]
+        def automatic_managed?
+          @automatic_managed ||= begin
+            logger.trace("Checking if pagefiles are automatically managed")
+            cmd = shell_out("wmic.exe computersystem where name=\"%computername%\" get AutomaticManagedPagefile /format:list")
+            cmd.stderr.empty? && (cmd.stdout =~ /AutomaticManagedPagefile=TRUE/i)
+          end
+        end
+
+        # turn on automatic management of all pagefiles by Windows
+        def set_automatic_managed
+          converge_by("set pagefile to Automatic Managed") do
+            logger.trace("Running wmic.exe computersystem where name=\"%computername%\" set AutomaticManagedPagefile=True")
+            cmd = shell_out("wmic.exe computersystem where name=\"%computername%\" set AutomaticManagedPagefile=True")
+            check_for_errors(cmd.stderr)
+          end
+        end
+
+        # turn off automatic management of all pagefiles by Windows
+        def unset_automatic_managed
+          converge_by("set pagefile to User Managed") do
+            logger.trace("Running wmic.exe computersystem where name=\"%computername%\" set AutomaticManagedPagefile=False")
+            cmd = shell_out("wmic.exe computersystem where name=\"%computername%\" set AutomaticManagedPagefile=False")
+            check_for_errors(cmd.stderr)
+          end
+        end
+
+        # set a custom size for the pagefile (vs the defaults)
+        #
+        # @param [String] pagefile path to the pagefile
+        # @param [String] min the minimum size of the pagefile
+        # @param [String] max the minimum size of the pagefile
+        def set_custom_size(pagefile, min, max)
+          converge_by("set #{pagefile} to InitialSize=#{min} & MaximumSize=#{max}") do
+            logger.trace("Running wmic.exe pagefileset where SettingID=\"#{get_setting_id(pagefile)}\" set InitialSize=#{min},MaximumSize=#{max}")
+            cmd = shell_out("wmic.exe pagefileset where SettingID=\"#{get_setting_id(pagefile)}\" set InitialSize=#{min},MaximumSize=#{max}", returns: [0])
+            check_for_errors(cmd.stderr)
+          end
+        end
+
+        # set a pagefile size to be system managed
+        #
+        # @param [String] pagefile path to the pagefile
+        def set_system_managed(pagefile)
+          converge_by("set #{pagefile} to System Managed") do
+            logger.trace("Running wmic.exe pagefileset where SettingID=\"#{get_setting_id(pagefile)}\" set InitialSize=0,MaximumSize=0")
+            cmd = shell_out("wmic.exe pagefileset where SettingID=\"#{get_setting_id(pagefile)}\" set InitialSize=0,MaximumSize=0", returns: [0])
+            check_for_errors(cmd.stderr)
+          end
+        end
+
+        def get_setting_id(pagefile)
+          split_path = pagefile.split('\\')
+          "#{split_path[1]} @ #{split_path[0]}"
+        end
+
+        # raise if there's an error on stderr on a shellout
+        def check_for_errors(stderr)
+          raise stderr.chomp unless stderr.empty?
+        end
+      end
+    end
+  end
+end