bolt 0.21.7 → 0.21.8

data/vendored/puppet/lib/puppet/provider/macauthorization/macauthorization.rb

@@ -1,298 +0,0 @@
-require 'facter'
-require 'puppet/util/plist' if Puppet.features.cfpropertylist?
-require 'puppet'
-require 'tempfile'
-
-Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppet::Provider do
-
-  desc "Manage Mac OS X authorization database rules and rights.
-
-  "
-
-  commands :security => "/usr/bin/security"
-
-  confine :operatingsystem => :darwin
-  confine :feature         => :cfpropertylist
-
-  defaultfor :operatingsystem => :darwin
-
-  AuthDB = "/etc/authorization"
-
-  @rights = {}
-  @rules = {}
-  @parsed_auth_db = {}
-  @comment = ""  # Not implemented yet. Is there any real need to?
-
-  # This map exists due to the use of hyphens and reserved words in
-  # the authorization schema.
-  PuppetToNativeAttributeMap = {  :allow_root => "allow-root",
-    :authenticate_user => "authenticate-user",
-    :auth_class => "class",
-    :k_of_n => "k-of-n",
-    :session_owner => "session-owner", }
-
-  class << self
-    attr_accessor :parsed_auth_db
-    attr_accessor :rights
-    attr_accessor :rules
-    attr_accessor :comments  # Not implemented yet.
-
-    def prefetch(resources)
-      self.populate_rules_rights
-    end
-
-    def instances
-      if self.parsed_auth_db == {}
-        self.prefetch(nil)
-      end
-      self.parsed_auth_db.collect do |k,v|
-        new(:name => k)
-      end
-    end
-
-    def populate_rules_rights
-      auth_plist = Puppet::Util::Plist.parse_plist(AuthDB)
-      raise Puppet::Error.new(_("Cannot parse: %{auth}") % { auth: AuthDB }) if not auth_plist
-      self.rights = auth_plist["rights"].dup
-      self.rules = auth_plist["rules"].dup
-      self.parsed_auth_db = self.rights.dup
-      self.parsed_auth_db.merge!(self.rules.dup)
-    end
-
-  end
-
-  # standard required provider instance methods
-
-  def initialize(resource)
-    if self.class.parsed_auth_db == {}
-      self.class.prefetch(resource)
-    end
-    super
-  end
-
-
-  def create
-    # we just fill the @property_hash in here and let the flush method
-    # deal with it rather than repeating code.
-    new_values = {}
-    validprops = Puppet::Type.type(resource.class.name).validproperties
-    validprops.each do |prop|
-      next if prop == :ensure
-      if value = resource.should(prop) and value != ""
-        new_values[prop] = value
-      end
-    end
-    @property_hash = new_values.dup
-  end
-
-  def destroy
-    # We explicitly delete here rather than in the flush method.
-    case resource[:auth_type]
-    when :right
-      destroy_right
-    when :rule
-      destroy_rule
-    else
-      raise Puppet::Error.new(_("Must specify auth_type when destroying."))
-    end
-  end
-
-  def exists?
-    !!self.class.parsed_auth_db.has_key?(resource[:name])
-  end
-
-
-  def flush
-    # deletion happens in the destroy methods
-    if resource[:ensure] != :absent
-      case resource[:auth_type]
-      when :right
-        flush_right
-      when :rule
-        flush_rule
-      else
-        raise Puppet::Error.new(_("flush requested for unknown type."))
-      end
-      @property_hash.clear
-    end
-  end
-
-
-  # utility methods below
-
-  def destroy_right
-    security "authorizationdb", :remove, resource[:name]
-  end
-
-  def destroy_rule
-    authdb = Puppet::Util::Plist.parse_plist(AuthDB)
-    authdb_rules = authdb["rules"].dup
-    if authdb_rules[resource[:name]]
-      begin
-        authdb["rules"].delete(resource[:name])
-        Puppet::Util::Plist.write_plist_file(authdb, AuthDB)
-      rescue Errno::EACCES => e
-        raise Puppet::Error.new(_("Error saving %{auth}: %{error}") % { auth: AuthDB, error: e }, e)
-      end
-    end
-  end
-
-  def flush_right
-    # first we re-read the right just to make sure we're in sync for
-    # values that weren't specified in the manifest. As we're supplying
-    # the whole plist when specifying the right it seems safest to be
-    # paranoid given the low cost of querying the db once more.
-    cmds = []
-    cmds << :security << "authorizationdb" << "read" << resource[:name]
-    output = execute(cmds, :failonfail => false, :combine => false)
-    current_values = Puppet::Util::Plist.parse_plist(output)
-    current_values ||= {}
-    specified_values = convert_plist_to_native_attributes(@property_hash)
-
-    # take the current values, merge the specified values to obtain a
-    # complete description of the new values.
-    new_values = current_values.merge(specified_values)
-    set_right(resource[:name], new_values)
-  end
-
-  def flush_rule
-    authdb = Puppet::Util::Plist.parse_plist(AuthDB)
-    authdb_rules = authdb["rules"].dup
-    current_values = {}
-    current_values = authdb_rules[resource[:name]] if authdb_rules[resource[:name]]
-    specified_values = convert_plist_to_native_attributes(@property_hash)
-    new_values = current_values.merge(specified_values)
-    set_rule(resource[:name], new_values)
-  end
-
-  def set_right(name, values)
-    # Both creates and modifies rights as it simply overwrites them.
-    # The security binary only allows for writes using stdin, so we
-    # dump the values to a tempfile.
-    values = convert_plist_to_native_attributes(values)
-    tmp = Tempfile.new('puppet_macauthorization')
-    begin
-      Puppet::Util::Plist.write_plist_file(values, tmp.path)
-      cmds = []
-      cmds << :security << "authorizationdb" << "write" << name
-      execute(cmds, :failonfail => false, :combine => false, :stdinfile => tmp.path.to_s)
-    rescue Errno::EACCES => e
-      raise Puppet::Error.new(_("Cannot save right to %{path}: %{error}") % { path: tmp.path, error: e }, e)
-    ensure
-      tmp.close
-      tmp.unlink
-    end
-  end
-
-  def set_rule(name, values)
-    # Both creates and modifies rules as it overwrites the entry in the
-    # rules dictionary.  Unfortunately the security binary doesn't
-    # support modifying rules at all so we have to twiddle the whole
-    # plist... :( See Apple Bug #6386000
-    values = convert_plist_to_native_attributes(values)
-    authdb = Puppet::Util::Plist.parse_plist(AuthDB)
-    authdb["rules"][name] = values
-
-    begin
-      Puppet::Util::Plist.write_plist_file(authdb, AuthDB)
-    rescue
-      raise Puppet::Error.new(_("Error writing to: %{auth_db}") % { auth_db: AuthDB })
-    end
-  end
-
-  def convert_plist_to_native_attributes(propertylist)
-    # This mainly converts the keys from the puppet attributes to the
-    # 'native' ones, but also enforces that the keys are all Strings
-    # rather than Symbols so that any merges of the resultant Hash are
-    # sane. The exception is booleans, where we coerce to a proper bool
-    # if they come in as a symbol.
-    newplist = {}
-    propertylist.each_pair do |key, value|
-      next if key == :ensure     # not part of the auth db schema.
-      next if key == :auth_type  # not part of the auth db schema.
-      case value
-      when true, :true
-        value = true
-      when false, :false
-        value = false
-      end
-      new_key = key
-      if PuppetToNativeAttributeMap.has_key?(key)
-        new_key = PuppetToNativeAttributeMap[key].to_s
-      elsif not key.is_a?(String)
-        new_key = key.to_s
-      end
-      newplist[new_key] = value
-    end
-    newplist
-  end
-
-  def retrieve_value(resource_name, attribute)
-    # We set boolean values to symbols when retrieving values
-    raise Puppet::Error.new(_("Cannot find %{resource_name} in auth db") % { resource_name: resource_name }) if not self.class.parsed_auth_db.has_key?(resource_name)
-
-    if PuppetToNativeAttributeMap.has_key?(attribute)
-      native_attribute = PuppetToNativeAttributeMap[attribute]
-    else
-      native_attribute = attribute.to_s
-    end
-
-    if self.class.parsed_auth_db[resource_name].has_key?(native_attribute)
-      value = self.class.parsed_auth_db[resource_name][native_attribute]
-      case value
-      when true, :true
-        value = :true
-      when false, :false
-        value = :false
-      end
-
-      @property_hash[attribute] = value
-      return value
-    else
-      @property_hash.delete(attribute)
-      return ""  # so ralsh doesn't display it.
-    end
-  end
-
-
-  # property methods below
-  #
-  # We define them all dynamically apart from auth_type which is a special
-  # case due to not being in the actual authorization db schema.
-
-  properties = [  :allow_root, :authenticate_user, :auth_class, :comment,
-    :group, :k_of_n, :mechanisms, :rule, :session_owner,
-    :shared, :timeout, :tries ]
-
-  properties.each do |field|
-    define_method(field.to_s) do
-      retrieve_value(resource[:name], field)
-    end
-
-    define_method(field.to_s + "=") do |value|
-      @property_hash[field] = value
-    end
-  end
-
-  def auth_type
-    if resource.should(:auth_type) != nil
-      return resource.should(:auth_type)
-    elsif self.exists?
-      # this is here just for ralsh, so it can work out what type it is.
-      if self.class.rights.has_key?(resource[:name])
-        return :right
-      elsif self.class.rules.has_key?(resource[:name])
-        return :rule
-      else
-        raise Puppet::Error.new(_("%{resource} is unknown type.") % { resource: resource[:name] })
-      end
-    else
-      raise Puppet::Error.new(_("auth_type required for new resources."))
-    end
-  end
-
-  def auth_type=(value)
-    @property_hash[:auth_type] = value
-  end
-
-end

data/vendored/puppet/lib/puppet/provider/mcx/mcxcontent.rb

@@ -1,173 +0,0 @@
-require 'tempfile'
-
-Puppet::Type.type(:mcx).provide :mcxcontent, :parent => Puppet::Provider do
-
-  desc "MCX Settings management using DirectoryService on OS X.
-
-  This provider manages the entire MCXSettings attribute available
-  to some directory services nodes.  This management is 'all or nothing'
-  in that discrete application domain key value pairs are not managed
-  by this provider.
-
-  It is recommended to use WorkGroup Manager to configure Users, Groups,
-  Computers, or ComputerLists, then use 'ralsh mcx' to generate a puppet
-  manifest from the resulting configuration.
-
-  Original Author: Jeff McCune (mccune.jeff@gmail.com)
-
-"
-
-  # This provides a mapping of puppet types to DirectoryService
-  # type strings.
-  TypeMap = {
-    :user => "Users",
-    :group => "Groups",
-    :computer => "Computers",
-    :computerlist => "ComputerLists",
-  }
-
-  class MCXContentProviderException < Exception
-
-  end
-
-  commands :dscl => "/usr/bin/dscl"
-  confine :operatingsystem => :darwin
-  defaultfor :operatingsystem => :darwin
-
-  def self.instances
-    mcx_list = []
-    TypeMap.each_key do |ds_type|
-      ds_path = "/Local/Default/#{TypeMap[ds_type]}"
-      output = dscl 'localhost', '-list', ds_path
-      member_list = output.split
-      member_list.each do |ds_name|
-        content = mcxexport(ds_type, ds_name)
-        if content.empty?
-          Puppet.debug "/#{TypeMap[ds_type]}/#{ds_name} has no MCX data."
-        else
-          # This node has MCX data.
-
-          mcx_list << self.new(
-            :name => "/#{TypeMap[ds_type]}/#{ds_name}",
-            :ds_type => ds_type,
-            :ds_name => ds_name,
-            :content => content
-          )
-        end
-      end
-    end
-    mcx_list
-  end
-
-  def self.mcxexport(ds_type, ds_name)
-    ds_t = TypeMap[ds_type]
-    ds_n = ds_name.to_s
-    ds_path = "/Local/Default/#{ds_t}/#{ds_n}"
-    dscl 'localhost', '-mcxexport', ds_path
-  end
-
-
-  def create
-    self.content=(resource[:content])
-  end
-
-  def destroy
-    ds_parms = get_dsparams
-    ds_t = TypeMap[ds_parms[:ds_type]]
-    ds_n = ds_parms[:ds_name].to_s
-    ds_path = "/Local/Default/#{ds_t}/#{ds_n}"
-
-    dscl 'localhost', '-mcxdelete', ds_path
-  end
-
-  def exists?
-    begin
-      has_mcx?
-    rescue Puppet::ExecutionFailure
-      return false
-    end
-  end
-
-  def content
-    ds_parms = get_dsparams
-
-    self.class.mcxexport(ds_parms[:ds_type], ds_parms[:ds_name])
-  end
-
-  def content=(value)
-    # dscl localhost -mcximport
-    ds_parms = get_dsparams
-
-    mcximport(ds_parms[:ds_type], ds_parms[:ds_name], resource[:content])
-  end
-
-  private
-
-  def has_mcx?
-    !content.empty?
-  end
-
-  def mcximport(ds_type, ds_name, val)
-    ds_t = TypeMap[ds_type]
-    ds_path = "/Local/Default/#{ds_t}/#{ds_name}"
-
-    if has_mcx?
-      Puppet.debug "Removing MCX from #{ds_path}"
-      dscl 'localhost', '-mcxdelete', ds_path
-    end
-
-    # val being passed in is resource[:content] which should be UTF-8
-    tmp = Tempfile.new('puppet_mcx', :encoding => Encoding::UTF_8)
-    begin
-      tmp << val
-      tmp.flush
-      Puppet.debug "Importing MCX into #{ds_path}"
-      dscl 'localhost', '-mcximport', ds_path, tmp.path
-    ensure
-      tmp.close
-      tmp.unlink
-    end
-  end
-
-  # Given the resource name string, parse ds_type out.
-  def parse_type(name)
-    ds_type = name.split('/')[1]
-    unless ds_type
-      raise MCXContentProviderException,
-      _("Could not parse ds_type from resource name '%{name}'.  Specify with ds_type parameter.") % { name: name }
-    end
-    # De-pluralize and downcase.
-    ds_type = ds_type.chop.downcase.to_sym
-    unless TypeMap.key? ds_type
-      raise MCXContentProviderException,
-      _("Could not parse ds_type from resource name '%{name}'.  Specify with ds_type parameter.") % { name: name }
-    end
-    ds_type
-  end
-
-  # Given the resource name string, parse ds_name out.
-  def parse_name(name)
-    ds_name = name.split('/')[2]
-    unless ds_name
-      raise MCXContentProviderException,
-      _("Could not parse ds_name from resource name '%{name}'.  Specify with ds_name parameter.") % { name: name }
-    end
-    ds_name
-  end
-
-  # Gather ds_type and ds_name from resource or parse it out of the name.
-  def get_dsparams
-    ds_type = resource[:ds_type]
-    ds_type ||= parse_type(resource[:name])
-    raise MCXContentProviderException unless TypeMap.keys.include? ds_type.to_sym
-
-    ds_name = resource[:ds_name]
-    ds_name ||= parse_name(resource[:name])
-
-    {
-      :ds_type => ds_type.to_sym,
-      :ds_name => ds_name,
-    }
-  end
-
-end