chef 13.12.14 → 14.0.190

data/lib/chef/resource/ksh.rb

@@ -20,13 +20,14 @@ require "chef/resource/script"
 
 class Chef
   class Resource
-    # Use the ksh resource to execute scripts using the Korn shell (ksh) interpreter. This resource may also use any
-    # f the actions and properties that are available to the execute resource. Commands that are executed with this
-    # resource are (by their nature) not idempotent, as they are typically unique to the environment in which they are
-    # run. Use not_if and only_if to guard this resource for idempotence.
-    #
-    # @since 12.6
     class Ksh < Chef::Resource::Script
+      description "Use the ksh resource to execute scripts using the Korn shell (ksh)"\
+                  " interpreter. This resource may also use any of the actions and properties"\
+                  " that are available to the execute resource. Commands that are executed"\
+                  " with this resource are (by their nature) not idempotent, as they are"\
+                  " typically unique to the environment in which they are run. Use not_if"\
+                  " and only_if to guard this resource for idempotence."
+      introduced "12.6"
 
       def initialize(name, run_context = nil)
         super

data/lib/chef/resource/launchd.rb

@@ -20,12 +20,12 @@ require "chef/resource"
 
 class Chef
   class Resource
-    # Use the launchd resource to manage system-wide services (daemons) and per-user services (agents) on the macOS platform.
-    #
-    # @since 12.8
     class Launchd < Chef::Resource
       resource_name :launchd
-      provides :launchd, os: "darwin"
+      provides :launchd
+
+      description "Use the launchd resource to manage system-wide services (daemons) and per-user services (agents) on the macOS platform."
+      introduced "12.8"
 
       default_action :create
       allowed_actions :create, :create_if_missing, :delete, :enable, :disable, :restart

data/lib/chef/resource/link.rb

@@ -1,7 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Tyler Cloke (<tyler@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -22,22 +22,22 @@ require "chef/mixin/securable"
 
 class Chef
   class Resource
-    # Use the link resource to create symbolic or hard links.
-    #
-    # A symbolic link—sometimes referred to as a soft link—is a directory entry that associates a file name with a string
-    # that contains an absolute or relative path to a file on any file system. In other words, “a file that contains a path
-    # that points to another file.” A symbolic link creates a new file with a new inode that points to the inode location
-    # of the original file.
-    #
-    # A hard link is a directory entry that associates a file with another file in the same file system. In other words,
-    # “multiple directory entries to the same file.” A hard link creates a new file that points to the same inode as the
-    # original file.
     class Link < Chef::Resource
       include Chef::Mixin::Securable
+      resource_name :link
+      provides :link
 
-      identity_attr :target_file
+      description "Use the link resource to create symbolic or hard links.\n\n"\
+                  "A symbolic link—sometimes referred to as a soft link—is a directory entry"\
+                  " that associates a file name with a string that contains an absolute or"\
+                  " relative path to a file on any file system. In other words, “a file that"\
+                  " contains a path that points to another file.” A symbolic link creates a new"\
+                  " file with a new inode that points to the inode location of the original file.\n\n"\
+                  "A hard link is a directory entry that associates a file with another file in the"\
+                  " same file system. In other words, “multiple directory entries to the same file.”"\
+                  " A hard link creates a new file that points to the same inode as the original file."
 
-      state_attrs :to, :owner, :group
+      state_attrs :owner # required since it's not a property below
 
       default_action :create
       allowed_actions :create, :delete
@@ -45,51 +45,13 @@ class Chef
       def initialize(name, run_context = nil)
         verify_links_supported!
         super
-        @to = nil
-        @link_type = :symbolic
-        @target_file = name
       end
 
-      def to(arg = nil)
-        set_or_return(
-          :to,
-          arg,
-          :kind_of => String
-        )
-      end
-
-      def target_file(arg = nil)
-        set_or_return(
-          :target_file,
-          arg,
-          :kind_of => String
-        )
-      end
-
-      def link_type(arg = nil)
-        real_arg = arg.kind_of?(String) ? arg.to_sym : arg
-        set_or_return(
-          :link_type,
-          real_arg,
-          :equal_to => [ :symbolic, :hard ]
-        )
-      end
-
-      def group(arg = nil)
-        set_or_return(
-          :group,
-          arg,
-          :regex => Chef::Config[:group_valid_regex]
-        )
-      end
-
-      def owner(arg = nil)
-        set_or_return(
-          :owner,
-          arg,
-          :regex => Chef::Config[:user_valid_regex]
-        )
-      end
+      property :target_file, String, name_property: true, identity: true
+      property :to, String
+      property :link_type, [String, Symbol], coerce: proc { |arg| arg.kind_of?(String) ? arg.to_sym : arg }, equal_to: [ :symbolic, :hard ], default: :symbolic
+      property :group, [String, Integer], regex: [Chef::Config[:group_valid_regex]]
+      property :user, [String, Integer], regex: [Chef::Config[:user_valid_regex]]
 
       # make link quack like a file (XXX: not for public consumption)
       def path

data/lib/chef/resource/log.rb

@@ -21,13 +21,6 @@ require "chef/resource"
 
 class Chef
   class Resource
-    # Use the log resource to create log entries. The log resource behaves like any other resource: built into the resource
-    # collection during the compile phase, and then run during the execution phase. (To create a log entry that is not built
-    # into the resource collection, use Chef::Log instead of the log resource.)
-    #
-    # Allows logging a :debug, :info, :warn, and :error levels
-    # Defaults to :info level
-    #
     # @example logging at default info level
     #   log "your string to log"
     #
@@ -35,10 +28,15 @@ class Chef
     #   log "a debug string" do
     #     level :debug
     #   end
-    #
     class Log < Chef::Resource
       resource_name :log
 
+      description "Use the log resource to create log entries. The log resource behaves"\
+                  " like any other resource: built into the resource collection during the"\
+                  " compile phase, and then run during the execution phase. (To create a log"\
+                  " entry that is not built into the resource collection, use Chef::Log instead"\
+                  " of the log resource.)"
+
       property :message, String, name_property: true, identity: true
       property :level, Symbol, equal_to: [ :debug, :info, :warn, :error, :fatal ], default: :info
 

data/lib/chef/resource/lwrp_base.rb

@@ -2,7 +2,7 @@
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Christopher Walters (<cw@chef.io>)
 # Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software, Inc.
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -41,11 +41,9 @@ class Chef
         include Chef::Mixin::ConvertToClassName
         include Chef::Mixin::FromFile
 
-        attr_accessor :loaded_lwrps
-
         def build_from_file(cookbook_name, filename, run_context)
           if LWRPBase.loaded_lwrps[filename]
-            Chef::Log.debug("Custom resource #{filename} from cookbook #{cookbook_name} has already been loaded!  Skipping the reload.")
+            Chef::Log.trace("Custom resource #{filename} from cookbook #{cookbook_name} has already been loaded!  Skipping the reload.")
             return loaded_lwrps[filename]
           end
 
@@ -65,7 +63,7 @@ class Chef
             define_singleton_method(:inspect) { to_s }
           end
 
-          Chef::Log.debug("Loaded contents of #{filename} into resource #{resource_name} (#{resource_class})")
+          Chef::Log.trace("Loaded contents of #{filename} into resource #{resource_name} (#{resource_class})")
 
           LWRPBase.loaded_lwrps[filename] = true
 
@@ -102,6 +100,7 @@ class Chef
 
         protected
 
+        attr_writer :loaded_lwrps
         def loaded_lwrps
           @loaded_lwrps ||= {}
         end

data/lib/chef/resource/macos_userdefaults.rb

@@ -0,0 +1,133 @@
+#
+# Copyright:: 2011-2018, Joshua Timberman
+# Copyright:: 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 MacosUserDefaults < Chef::Resource
+      # align with apple's marketing department
+      resource_name :macos_userdefaults
+      provides :mac_os_x_userdefaults
+      provides :macos_userdefaults
+
+      description "Use the macos_userdefaults resource to manage the macOS user defaults system. The properties"\
+                  " of this resource are passed to the defaults command, and the parameters follow the convention"\
+                  " of that command. See the defaults(1) man page for details on how the tool works."
+      introduced "14.0"
+
+      property :domain, String,
+               description: "The domain the defaults belong to.",
+               required: true
+
+      property :global, [TrueClass, FalseClass],
+               description: "Whether the domain is global.",
+               default: false
+
+      property :key, String,
+               description: "The preference key."
+
+      property :value, [Integer, Float, String, TrueClass, FalseClass, Hash, Array],
+               description: "The value of the key.",
+               coerce: proc { |v| coerce_booleans(v) },
+               required: true
+
+      property :type, String,
+               description: "Value type of the preference key.",
+               default: ""
+
+      property :user, String,
+               description: "User for which to set the default."
+
+      property :sudo, [TrueClass, FalseClass],
+               description: "Set to true if the setting requires privileged access to modify.",
+               default: false,
+               desired_state: false
+
+      property :is_set, [TrueClass, FalseClass],
+               description: "",
+               default: false,
+               desired_state: false
+
+       # coerce various ways of representing a boolean into either 0 (false) or 1 (true)
+       # which is what the defaults CLI expects. Why? Well defaults itself accepts a few
+       # different formats, but when you do a read command it all comes back as 1 or 0.
+      def coerce_booleans(val)
+        return 1 if [true, "TRUE", "1", "true", "YES", "yes"].include?(val)
+        return 0 if [false, "FALSE", "0", "false", "NO", "no"].include?(val)
+        val
+      end
+
+      load_current_value do |desired|
+        drcmd = "defaults read '#{desired.domain}' "
+        drcmd << "'#{desired.key}' " if desired.key
+        shell_out_opts = {}
+        shell_out_opts[:user] = desired.user unless desired.user.nil?
+        vc = shell_out("#{drcmd} | grep -qx '#{desired.value}'", shell_out_opts)
+        is_set vc.exitstatus == 0 ? true : false
+      end
+
+      action :write do
+        description "Write the setting to the specified domain"
+
+        unless current_resource.is_set
+          cmd = ["defaults write"]
+          cmd.unshift("sudo") if new_resource.sudo
+
+          cmd << if new_resource.global
+                   "NSGlobalDomain"
+                 else
+                   "'#{new_resource.domain}'"
+                 end
+
+          cmd << "'#{new_resource.key}'" if new_resource.key
+          value = new_resource.value
+          type = new_resource.type.empty? ? value_type(value) : new_resource.type
+          # creates a string of Key1 Value1 Key2 Value2...
+          value = value.map { |k, v| "\"#{k}\" \"#{v}\"" }.join(" ") if type == "dict"
+          if type == "array"
+            value = value.join("' '")
+            value = "'#{value}'"
+          end
+          cmd << "-#{type}" if type
+          cmd << value
+
+          declare_resource(:execute, cmd.join(" ")) do
+            user new_resource.user unless new_resource.user.nil?
+          end
+        end
+      end
+
+      action_class do
+        def value_type(value)
+          case value
+          when true, false
+            "bool"
+          when Integer
+            "int"
+          when Float
+            "float"
+          when Hash
+            "dict"
+          when Array
+            "array"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/resource/macosx_service.rb

@@ -21,37 +21,21 @@ require "chef/resource/service"
 class Chef
   class Resource
     class MacosxService < Chef::Resource::Service
-
-      provides :macosx_service, os: "darwin"
+      resource_name :macosx_service
+      provides :macosx_service
       provides :service, os: "darwin"
 
+      description "Use the macosx_service resource to manage services on the macOS platform."
+
       identity_attr :service_name
 
       state_attrs :enabled, :running
 
-      def initialize(name, run_context = nil)
-        super
-        @plist = nil
-        @session_type = nil
-      end
-
       # This will enable user to pass a plist in the case
       # that the filename and label for the service dont match
-      def plist(arg = nil)
-        set_or_return(
-          :plist,
-          arg,
-          :kind_of => String
-        )
-      end
-
-      def session_type(arg = nil)
-        set_or_return(
-          :session_type,
-          arg,
-          :kind_of => String
-        )
-      end
+      property :plist, String
+
+      property :session_type, String
 
     end
   end

data/lib/chef/resource/macports_package.rb

@@ -20,9 +20,10 @@ require "chef/resource/package"
 
 class Chef
   class Resource
-    # Use the macports_package resource to manage packages for the macOS platform.
     class MacportsPackage < Chef::Resource::Package
       resource_name :macports_package
+
+      description "Use the macports_package resource to manage packages for the macOS platform."
     end
   end
 end

data/lib/chef/resource/mdadm.rb

@@ -21,96 +21,25 @@ require "chef/resource"
 
 class Chef
   class Resource
-    # Use the mdadm resource to manage RAID devices in a Linux environment using the mdadm utility. The mdadm resource
-    # will create and assemble an array, but it will not create the config file that is used to persist the array upon
-    # reboot. If the config file is required, it must be done by specifying a template with the correct array layout,
-    # and then by using the mount provider to create a file systems table (fstab) entry.
     class Mdadm < Chef::Resource
+      resource_name :mdadm
 
-      identity_attr :raid_device
-
-      state_attrs :devices, :level, :chunk
+      description "Use the mdadm resource to manage RAID devices in a Linux environment using the mdadm utility. The mdadm resource"\
+                  " will create and assemble an array, but it will not create the config file that is used to persist the array upon"\
+                  " reboot. If the config file is required, it must be done by specifying a template with the correct array layout,"\
+                  " and then by using the mount provider to create a file systems table (fstab) entry."
 
       default_action :create
       allowed_actions :create, :assemble, :stop
 
-      def initialize(name, run_context = nil)
-        super
-
-        @chunk = 16
-        @devices = []
-        @exists = false
-        @level = 1
-        @metadata = "0.90"
-        @bitmap = nil
-        @raid_device = name
-        @layout = nil
-      end
-
-      def chunk(arg = nil)
-        set_or_return(
-          :chunk,
-          arg,
-          :kind_of => [ Integer ]
-        )
-      end
-
-      def devices(arg = nil)
-        set_or_return(
-          :devices,
-          arg,
-          :kind_of => [ Array ]
-        )
-      end
-
-      def exists(arg = nil)
-        set_or_return(
-          :exists,
-          arg,
-          :kind_of => [ TrueClass, FalseClass ]
-        )
-      end
-
-      def level(arg = nil)
-        set_or_return(
-          :level,
-          arg,
-          :kind_of => [ Integer ]
-        )
-      end
-
-      def metadata(arg = nil)
-        set_or_return(
-          :metadata,
-          arg,
-          :kind_of => [ String ]
-        )
-      end
-
-      def bitmap(arg = nil)
-        set_or_return(
-          :bitmap,
-          arg,
-          :kind_of => [ String ]
-        )
-      end
-
-      def raid_device(arg = nil)
-        set_or_return(
-          :raid_device,
-          arg,
-          :kind_of => [ String ]
-        )
-      end
-
-      def layout(arg = nil)
-        set_or_return(
-          :layout,
-          arg,
-          :kind_of => [ String ]
-        )
-      end
-
+      property :chunk, Integer, default: 16
+      property :devices, Array, default: lazy { [] }
+      property :exists, [ TrueClass, FalseClass ], default: false
+      property :level, Integer, default: 1
+      property :metadata, String, default: "0.90"
+      property :bitmap, String
+      property :raid_device, String, identity: true, name_property: true
+      property :layout, String
     end
   end
 end