bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/provider/service/freebsd.rb

@@ -1,143 +0,0 @@
-Puppet::Type.type(:service).provide :freebsd, :parent => :init do
-
-  desc "Provider for FreeBSD and DragonFly BSD. Uses the `rcvar` argument of init scripts and parses/edits rc files."
-
-  confine :operatingsystem => [:freebsd, :dragonfly]
-  defaultfor :operatingsystem => [:freebsd, :dragonfly]
-
-  def rcconf()        '/etc/rc.conf' end
-  def rcconf_local()  '/etc/rc.conf.local' end
-  def rcconf_dir()    '/etc/rc.conf.d' end
-
-  def self.defpath
-    superclass.defpath
-  end
-
-  def error(msg)
-    raise Puppet::Error, msg
-  end
-
-  # Executing an init script with the 'rcvar' argument returns
-  # the service name, rcvar name and whether it's enabled/disabled
-  def rcvar
-    rcvar = execute([self.initscript, :rcvar], :failonfail => true, :combine => false, :squelch => false)
-    rcvar = rcvar.split("\n")
-    rcvar.delete_if {|str| str =~ /^#\s*$/}
-    rcvar[1] = rcvar[1].gsub(/^\$/, '')
-    rcvar
-  end
-
-  # Extract value name from service or rcvar
-  def extract_value_name(name, rc_index, regex, regex_index)
-    value_name = self.rcvar[rc_index]
-    self.error("No #{name} name found in rcvar") if value_name.nil?
-    value_name = value_name.gsub!(regex, regex_index)
-    self.error("#{name} name is empty") if value_name.nil?
-    self.debug("#{name} name is #{value_name}")
-    value_name
-  end
-
-  # Extract service name
-  def service_name
-    extract_value_name('service', 0, /# (\S+).*/, '\1')
-  end
-
-  # Extract rcvar name
-  def rcvar_name
-    extract_value_name('rcvar', 1, /(.*?)(_enable)?=(.*)/, '\1')
-  end
-
-  # Extract rcvar value
-  def rcvar_value
-    value = self.rcvar[1]
-    self.error("No rcvar value found in rcvar") if value.nil?
-    value = value.gsub!(/(.*)(_enable)?="?(\w+)"?/, '\3')
-    self.error("rcvar value is empty") if value.nil?
-    self.debug("rcvar value is #{value}")
-    value
-  end
-
-  # Edit rc files and set the service to yes/no
-  def rc_edit(yesno)
-    service = self.service_name
-    rcvar = self.rcvar_name
-    self.debug("Editing rc files: setting #{rcvar} to #{yesno} for #{service}")
-    self.rc_add(service, rcvar, yesno) if not self.rc_replace(service, rcvar, yesno)
-  end
-
-  # Try to find an existing setting in the rc files
-  # and replace the value
-  def rc_replace(service, rcvar, yesno)
-    success = false
-    # Replace in all files, not just in the first found with a match
-    [rcconf, rcconf_local, rcconf_dir + "/#{service}"].each do |filename|
-      if Puppet::FileSystem.exist?(filename)
-        s = File.read(filename)
-        if s.gsub!(/^(#{rcvar}(_enable)?)=\"?(YES|NO)\"?/, "\\1=\"#{yesno}\"")
-          File.open(filename, File::WRONLY) { |f| f << s }
-          self.debug("Replaced in #{filename}")
-          success = true
-        end
-      end
-    end
-    success
-  end
-
-  # Add a new setting to the rc files
-  def rc_add(service, rcvar, yesno)
-    append = "\# Added by Puppet\n#{rcvar}_enable=\"#{yesno}\"\n"
-    # First, try the one-file-per-service style
-    if Puppet::FileSystem.exist?(rcconf_dir)
-      File.open(rcconf_dir + "/#{service}", File::WRONLY | File::APPEND | File::CREAT, 0644) {
-        |f| f << append
-        self.debug("Appended to #{f.path}")
-      }
-    else
-      # Else, check the local rc file first, but don't create it
-      if Puppet::FileSystem.exist?(rcconf_local)
-        File.open(rcconf_local, File::WRONLY | File::APPEND) {
-          |f| f << append
-          self.debug("Appended to #{f.path}")
-        }
-      else
-        # At last use the standard rc.conf file
-        File.open(rcconf, File::WRONLY | File::APPEND | File::CREAT, 0644) {
-          |f| f << append
-          self.debug("Appended to #{f.path}")
-        }
-      end
-    end
-  end
-
-  def enabled?
-    if /YES$/ =~ self.rcvar_value
-      self.debug("Is enabled")
-      return :true
-    end
-    self.debug("Is disabled")
-    :false
-  end
-
-  def enable
-    self.debug("Enabling")
-    self.rc_edit("YES")
-  end
-
-  def disable
-    self.debug("Disabling")
-    self.rc_edit("NO")
-  end
-
-  def startcmd
-    [self.initscript, :onestart]
-  end
-
-  def stopcmd
-    [self.initscript, :onestop]
-  end
-
-  def statuscmd
-    [self.initscript, :onestatus]
-  end
-
-end

data/vendored/puppet/lib/puppet/provider/service/gentoo.rb

@@ -1,45 +0,0 @@
-# Manage gentoo services.  Start/stop is the same as InitSvc, but enable/disable
-# is special.
-Puppet::Type.type(:service).provide :gentoo, :parent => :init do
-  desc <<-EOT
-    Gentoo's form of `init`-style service management.
-
-    Uses `rc-update` for service enabling and disabling.
-
-  EOT
-
-  commands :update => "/sbin/rc-update"
-
-  confine :operatingsystem => :gentoo
-
-  def disable
-      output = update :del, @resource[:name], :default
-  rescue Puppet::ExecutionFailure
-      raise Puppet::Error, "Could not disable #{self.name}: #{output}", $!.backtrace
-  end
-
-  def enabled?
-    begin
-      output = update :show
-    rescue Puppet::ExecutionFailure
-      return :false
-    end
-
-    line = output.split(/\n/).find { |l| l.include?(@resource[:name]) }
-
-    return :false unless line
-
-    # If it's enabled then it will print output showing service | runlevel
-    if output =~ /^\s*#{@resource[:name]}\s*\|\s*(boot|default)/
-      return :true
-    else
-      return :false
-    end
-  end
-
-  def enable
-      output = update :add, @resource[:name], :default
-  rescue Puppet::ExecutionFailure
-      raise Puppet::Error, "Could not enable #{self.name}: #{output}", $!.backtrace
-  end
-end

data/vendored/puppet/lib/puppet/provider/service/init.rb

@@ -1,194 +0,0 @@
-# The standard init-based service type.  Many other service types are
-# customizations of this module.
-Puppet::Type.type(:service).provide :init, :parent => :base do
-  desc "Standard `init`-style service management."
-
-  def self.defpath
-    case Facter.value(:operatingsystem)
-    when "FreeBSD", "DragonFly"
-      ["/etc/rc.d", "/usr/local/etc/rc.d"]
-    when "HP-UX"
-      "/sbin/init.d"
-    when "Archlinux"
-      "/etc/rc.d"
-    when "AIX"
-      "/etc/rc.d/init.d"
-    else
-      "/etc/init.d"
-    end
-  end
-
-  # Debian and Ubuntu should use the Debian provider.
-  # RedHat systems should use the RedHat provider.
-  confine :true => begin
-      os = Facter.value(:operatingsystem).downcase
-      family = Facter.value(:osfamily).downcase
-      !(os == 'debian' || os == 'ubuntu' || family == 'redhat')
-  end
-
-  # We can't confine this here, because the init path can be overridden.
-  #confine :exists => defpath
-
-  # some init scripts are not safe to execute, e.g. we do not want
-  # to suddenly run /etc/init.d/reboot.sh status and reboot our system. The
-  # exclude list could be platform agnostic but I assume an invalid init script
-  # on system A will never be a valid init script on system B
-  def self.excludes
-    excludes = []
-    # these exclude list was found with grep -L '\/sbin\/runscript' /etc/init.d/* on gentoo
-    excludes += %w{functions.sh reboot.sh shutdown.sh}
-    # this exclude list is all from /sbin/service (5.x), but I did not exclude kudzu
-    excludes += %w{functions halt killall single linuxconf reboot boot}
-    # 'wait-for-state' and 'portmap-wait' are excluded from instances here
-    # because they take parameters that have unclear meaning. It looks like
-    # 'wait-for-state' is a generic waiter mainly used internally for other
-    # upstart services as a 'sleep until something happens'
-    # (http://lists.debian.org/debian-devel/2012/02/msg01139.html), while
-    # 'portmap-wait' is a specific instance of a waiter. There is an open
-    # launchpad bug
-    # (https://bugs.launchpad.net/ubuntu/+source/upstart/+bug/962047) that may
-    # eventually explain how to use the wait-for-state service or perhaps why
-    # it should remain excluded. When that bug is addressed this should be
-    # reexamined.
-    excludes += %w{wait-for-state portmap-wait}
-    # these excludes were found with grep -r -L start /etc/init.d
-    excludes += %w{rcS module-init-tools}
-    # Prevent puppet failing on unsafe scripts from Yocto Linux
-    if Facter.value(:osfamily) == "cisco-wrlinux"
-      excludes += %w{banner.sh bootmisc.sh checkroot.sh devpts.sh dmesg.sh
-                   hostname.sh mountall.sh mountnfs.sh populate-volatile.sh
-                   rmnologin.sh save-rtc.sh sendsigs sysfs.sh umountfs
-                   umountnfs.sh}
-    end
-    # Prevent puppet failing to get status of the new service introduced
-    # by the fix for this (bug https://bugs.launchpad.net/ubuntu/+source/lightdm/+bug/982889)
-    # due to puppet's inability to deal with upstart services with instances.
-    excludes += %w{plymouth-ready}
-    # Prevent puppet failing to get status of these services, which need parameters
-    # passed in (see https://bugs.launchpad.net/ubuntu/+source/puppet/+bug/1276766).
-    excludes += %w{idmapd-mounting startpar-bridge}
-    # Prevent puppet failing to get status of these services, additional upstart
-    # service with instances
-    excludes += %w{cryptdisks-udev}
-    excludes += %w{statd-mounting}
-    excludes += %w{gssd-mounting}
-    excludes
-  end
-
-  # List all services of this type.
-  def self.instances
-    get_services(self.defpath)
-  end
-
-  def self.get_services(defpath, exclude = self.excludes)
-    defpath = [defpath] unless defpath.is_a? Array
-    instances = []
-    defpath.each do |path|
-      unless FileTest.directory?(path)
-        Puppet.debug "Service path #{path} does not exist"
-        next
-      end
-
-      check = [:ensure]
-
-      check << :enable if public_method_defined? :enabled?
-
-      Dir.entries(path).each do |name|
-        fullpath = File.join(path, name)
-        next if name =~ /^\./
-        next if exclude.include? name
-        next if not FileTest.executable?(fullpath)
-        next if not is_init?(fullpath)
-        instances << new(:name => name, :path => path, :hasstatus => true)
-      end
-    end
-    instances
-  end
-
-  # Mark that our init script supports 'status' commands.
-  def hasstatus=(value)
-    case value
-    when true, "true"; @parameters[:hasstatus] = true
-    when false, "false"; @parameters[:hasstatus] = false
-    else
-      raise Puppet::Error, "Invalid 'hasstatus' value #{value.inspect}"
-    end
-  end
-
-  # Where is our init script?
-  def initscript
-    @initscript ||= self.search(@resource[:name])
-  end
-
-  def paths
-    @paths ||= @resource[:path].find_all do |path|
-      if File.directory?(path)
-        true
-      else
-        if Puppet::FileSystem.exist?(path)
-          self.debug "Search path #{path} is not a directory"
-        else
-          self.debug "Search path #{path} does not exist"
-        end
-        false
-      end
-    end
-  end
-
-  def search(name)
-    paths.each do |path|
-      fqname = File.join(path,name)
-      if Puppet::FileSystem.exist? fqname
-        return fqname
-      else
-        self.debug("Could not find #{name} in #{path}")
-      end
-    end
-
-    paths.each do |path|
-      fqname_sh = File.join(path,"#{name}.sh")
-      if Puppet::FileSystem.exist? fqname_sh
-        return fqname_sh
-      else
-        self.debug("Could not find #{name}.sh in #{path}")
-      end
-    end
-    raise Puppet::Error, "Could not find init script for '#{name}'"
-  end
-
-  # The start command is just the init script with 'start'.
-  def startcmd
-    [initscript, :start]
-  end
-
-  # The stop command is just the init script with 'stop'.
-  def stopcmd
-    [initscript, :stop]
-  end
-
-  def restartcmd
-    (@resource[:hasrestart] == :true) && [initscript, :restart]
-  end
-
-  def texecute(type, command, fof = true, squelch = false, combine = true)
-    if type == :start && Facter.value(:osfamily) == "Solaris"
-        command =  ["/usr/bin/ctrun -l child", command].flatten.join(" ")
-    end
-    super(type, command, fof, squelch, combine)
-  end
-
-  # If it was specified that the init script has a 'status' command, then
-  # we just return that; otherwise, we return false, which causes it to
-  # fallback to other mechanisms.
-  def statuscmd
-    (@resource[:hasstatus] == :true) && [initscript, :status]
-  end
-
-private
-
-  def self.is_init?(script = initscript)
-    file = Puppet::FileSystem.pathname(script)
-    !Puppet::FileSystem.symlink?(file) || Puppet::FileSystem.readlink(file) != "/lib/init/upstart-job"
-  end
-end
-

data/vendored/puppet/lib/puppet/provider/service/launchd.rb

@@ -1,345 +0,0 @@
-require 'puppet/util/plist'
-Puppet::Type.type(:service).provide :launchd, :parent => :base do
-  desc <<-'EOT'
-    This provider manages jobs with `launchd`, which is the default service
-    framework for Mac OS X (and may be available for use on other platforms).
-
-    For more information, see the `launchd` man page:
-
-    * <https://developer.apple.com/legacy/library/documentation/Darwin/Reference/ManPages/man8/launchd.8.html>
-
-    This provider reads plists out of the following directories:
-
-    * `/System/Library/LaunchDaemons`
-    * `/System/Library/LaunchAgents`
-    * `/Library/LaunchDaemons`
-    * `/Library/LaunchAgents`
-
-    ...and builds up a list of services based upon each plist's "Label" entry.
-
-    This provider supports:
-
-    * ensure => running/stopped,
-    * enable => true/false
-    * status
-    * restart
-
-    Here is how the Puppet states correspond to `launchd` states:
-
-    * stopped --- job unloaded
-    * started --- job loaded
-    * enabled --- 'Disable' removed from job plist file
-    * disabled --- 'Disable' added to job plist file
-
-    Note that this allows you to do something `launchctl` can't do, which is to
-    be in a state of "stopped/enabled" or "running/disabled".
-
-    Note that this provider does not support overriding 'restart'
-
-  EOT
-
-  include Puppet::Util::Warnings
-
-  commands :launchctl => "/bin/launchctl"
-
-  defaultfor :operatingsystem => :darwin
-  confine :operatingsystem    => :darwin
-  confine :feature            => :cfpropertylist
-
-  has_feature :enableable
-  has_feature :refreshable
-  mk_resource_methods
-
-  # These are the paths in OS X where a launchd service plist could
-  # exist. This is a helper method, versus a constant, for easy testing
-  # and mocking
-  #
-  # @api private
-  def self.launchd_paths
-    [
-      "/Library/LaunchAgents",
-      "/Library/LaunchDaemons",
-      "/System/Library/LaunchAgents",
-      "/System/Library/LaunchDaemons"
-    ]
-  end
-
-  # Gets the current Darwin version, example 10.6 returns 9 and 10.10 returns 14
-  # See https://en.wikipedia.org/wiki/Darwin_(operating_system)#Release_history
-  # for more information.
-  #
-  # @api private
-  def self.get_os_version
-    @os_version ||= Facter.value(:operatingsystemmajrelease).to_i
-  end
-
-  # Defines the path to the overrides plist file where service enabling
-  # behavior is defined in 10.6 and greater.
-  #
-  # With the rewrite of launchd in 10.10+, this moves and slightly changes format.
-  #
-  # @api private
-  def self.launchd_overrides
-    if self.get_os_version < 14
-      "/var/db/launchd.db/com.apple.launchd/overrides.plist"
-    else
-      "/var/db/com.apple.xpc.launchd/disabled.plist"
-    end
-  end
-
-  # Caching is enabled through the following three methods. Self.prefetch will
-  # call self.instances to create an instance for each service. Self.flush will
-  # clear out our cache when we're done.
-  def self.prefetch(resources)
-    instances.each do |prov|
-      if resource = resources[prov.name]
-        resource.provider = prov
-      end
-    end
-  end
-
-  # Self.instances will return an array with each element being a hash
-  # containing the name, provider, path, and status of each service on the
-  # system.
-  def self.instances
-    jobs = self.jobsearch
-    @job_list ||= self.job_list
-    jobs.keys.collect do |job|
-      job_status = @job_list.has_key?(job) ? :running : :stopped
-      new(:name => job, :provider => :launchd, :path => jobs[job], :status => job_status)
-    end
-  end
-
-  # This method will return a list of files in the passed directory. This method
-  # does not go recursively down the tree and does not return directories
-  #
-  # @param path [String] The directory to glob
-  #
-  # @api private
-  #
-  # @return [Array] of String instances modeling file paths
-  def self.return_globbed_list_of_file_paths(path)
-    array_of_files = Dir.glob(File.join(path, '*')).collect do |filepath|
-      File.file?(filepath) ? filepath : nil
-    end
-    array_of_files.compact
-  end
-
-  # Get a hash of all launchd plists, keyed by label.  This value is cached, but
-  # the cache will be refreshed if refresh is true.
-  #
-  # @api private
-  def self.make_label_to_path_map(refresh=false)
-    return @label_to_path_map if @label_to_path_map and not refresh
-    @label_to_path_map = {}
-    launchd_paths.each do |path|
-      return_globbed_list_of_file_paths(path).each do |filepath|
-        Puppet.debug("Reading launchd plist #{filepath}")
-        job = read_plist(filepath)
-        next if job.nil?
-        if job.has_key?("Label")
-          @label_to_path_map[job["Label"]] = filepath
-        else
-          #TRANSLATORS 'plist' and label' should not be translated
-          Puppet.debug(_("The %{file} plist does not contain a 'label' key; Puppet is skipping it") % { file: filepath })
-          next
-        end
-      end
-    end
-    @label_to_path_map
-  end
-
-  # Sets a class instance variable with a hash of all launchd plist files that
-  # are found on the system. The key of the hash is the job id and the value
-  # is the path to the file. If a label is passed, we return the job id and
-  # path for that specific job.
-  def self.jobsearch(label=nil)
-    by_label = make_label_to_path_map
-
-    if label
-      if by_label.has_key? label
-        return { label => by_label[label] }
-      else
-        # try refreshing the map, in case a plist has been added in the interim
-        by_label = make_label_to_path_map(true)
-        if by_label.has_key? label
-          return { label => by_label[label] }
-        else
-          raise Puppet::Error, "Unable to find launchd plist for job: #{label}"
-        end
-      end
-    else
-      # caller wants the whole map
-      by_label
-    end
-  end
-
-  # This status method lists out all currently running services.
-  # This hash is returned at the end of the method.
-  def self.job_list
-    @job_list = Hash.new
-    begin
-      output = launchctl :list
-      raise Puppet::Error.new("launchctl list failed to return any data.") if output.nil?
-      output.split("\n").each do |line|
-        @job_list[line.split(/\s/).last] = :running
-      end
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error.new("Unable to determine status of #{resource[:name]}", $!)
-    end
-    @job_list
-  end
-
-  # Read a plist, whether its format is XML or in Apple's "binary1"
-  # format.
-  def self.read_plist(path)
-    Puppet::Util::Plist.read_plist_file(path)
-  end
-
-  # Clean out the @property_hash variable containing the cached list of services
-  def flush
-    @property_hash.clear
-  end
-
-  def exists?
-    Puppet.debug("Puppet::Provider::Launchd:Ensure for #{@property_hash[:name]}: #{@property_hash[:ensure]}")
-    @property_hash[:ensure] != :absent
-  end
-
-  # finds the path for a given label and returns the path and parsed plist
-  # as an array of [path, plist]. Note plist is really a Hash here.
-  def plist_from_label(label)
-    job = self.class.jobsearch(label)
-    job_path = job[label]
-    if FileTest.file?(job_path)
-      job_plist = self.class.read_plist(job_path)
-    else
-      raise Puppet::Error.new("Unable to parse launchd plist at path: #{job_path}")
-    end
-    [job_path, job_plist]
-  end
-
-  # when a service includes hasstatus=>false, we override the launchctl
-  # status mechanism and fall back to the base provider status method.
-  def status
-    if @resource && ((@resource[:hasstatus] == :false) || (@resource[:status]))
-      return super
-    else
-      if @property_hash[:status].nil?
-        :absent
-      else
-        @property_hash[:status]
-      end
-    end
-  end
-
-  # start the service. To get to a state of running/enabled, we need to
-  # conditionally enable at load, then disable by modifying the plist file
-  # directly.
-  def start
-    return ucommand(:start) if resource[:start]
-    job_path, _ = plist_from_label(resource[:name])
-    did_enable_job = false
-    cmds = []
-    cmds << :launchctl << :load
-    # always add -w so it always starts the job, it is a noop if it is not needed, this means we do
-    # not have to rescan all launchd plists.
-    cmds << "-w"
-    if self.enabled? == :false  || self.status == :stopped # launchctl won't load disabled jobs
-      did_enable_job = true
-    end
-    cmds << job_path
-    begin
-      execute(cmds)
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error.new("Unable to start service: #{resource[:name]} at path: #{job_path}", $!)
-    end
-    # As load -w clears the Disabled flag, we need to add it in after
-    self.disable if did_enable_job and resource[:enable] == :false
-  end
-
-
-  def stop
-    return ucommand(:stop) if resource[:stop]
-    job_path, _ = plist_from_label(resource[:name])
-    did_disable_job = false
-    cmds = []
-    cmds << :launchctl << :unload
-    if self.enabled? == :true # keepalive jobs can't be stopped without disabling
-      cmds << "-w"
-      did_disable_job = true
-    end
-    cmds << job_path
-    begin
-      execute(cmds)
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error.new("Unable to stop service: #{resource[:name]} at path: #{job_path}", $!)
-    end
-    # As unload -w sets the Disabled flag, we need to add it in after
-    self.enable if did_disable_job and resource[:enable] == :true
-  end
-
-  def restart
-    Puppet.debug("A restart has been triggered for the #{resource[:name]} service")
-    Puppet.debug("Stopping the #{resource[:name]} service")
-    self.stop
-    Puppet.debug("Starting the #{resource[:name]} service")
-    self.start
-  end
-
-  # launchd jobs are enabled by default. They are only disabled if the key
-  # "Disabled" is set to true, but it can also be set to false to enable it.
-  # Starting in 10.6, the Disabled key in the job plist is consulted, but only
-  # if there is no entry in the global overrides plist.  We need to draw a
-  # distinction between undefined, true and false for both locations where the
-  # Disabled flag can be defined.
-  def enabled?
-    job_plist_disabled = nil
-    overrides_disabled = nil
-
-    _, job_plist = plist_from_label(resource[:name])
-    job_plist_disabled = job_plist["Disabled"] if job_plist.has_key?("Disabled")
-
-    if FileTest.file?(self.class.launchd_overrides) and overrides = self.class.read_plist(self.class.launchd_overrides)
-      if overrides.has_key?(resource[:name])
-        if self.class.get_os_version < 14
-          overrides_disabled = overrides[resource[:name]]["Disabled"] if overrides[resource[:name]].has_key?("Disabled")
-        else
-          overrides_disabled = overrides[resource[:name]]
-        end
-      end
-    end
-
-    if overrides_disabled.nil?
-      if job_plist_disabled.nil? or job_plist_disabled == false
-        return :true
-      end
-    elsif overrides_disabled == false
-      return :true
-    end
-    :false
-  end
-
-  # enable and disable are a bit hacky. We write out the plist with the appropriate value
-  # rather than dealing with launchctl as it is unable to change the Disabled flag
-  # without actually loading/unloading the job.
-  def enable
-    overrides = self.class.read_plist(self.class.launchd_overrides)
-    if self.class.get_os_version < 14
-      overrides[resource[:name]] = { "Disabled" => false }
-    else
-      overrides[resource[:name]] = false
-    end
-    Puppet::Util::Plist.write_plist_file(overrides, self.class.launchd_overrides)
-  end
-
-  def disable
-    overrides = self.class.read_plist(self.class.launchd_overrides)
-    if self.class.get_os_version < 14
-      overrides[resource[:name]] = { "Disabled" => true }
-    else
-      overrides[resource[:name]] = true
-    end
-    Puppet::Util::Plist.write_plist_file(overrides, self.class.launchd_overrides)
-  end
-end