bolt 0.21.7 → 0.21.8

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

@@ -1,167 +0,0 @@
-Puppet::Type.newtype(:macauthorization) do
-
-  @doc = "Manage the Mac OS X authorization database. See the
-    [Apple developer site](https://developer.apple.com/library/content/documentation/Security/Conceptual/Security_Overview/AuthenticationAndAuthorization/AuthenticationAndAuthorization.html)
-    for more information.
-
-    Note that authorization store directives with hyphens in their names have
-    been renamed to use underscores, as Puppet does not react well to hyphens
-    in identifiers.
-
-    **Autorequires:** If Puppet is managing the `/etc/authorization` file, each
-    macauthorization resource will autorequire it."
-
-  ensurable
-
-  autorequire(:file) do
-    ["/etc/authorization"]
-  end
-
-  def munge_boolean(value)
-    case value
-    when true, "true", :true
-      :true
-    when false, "false", :false
-      :false
-    else
-      fail("munge_boolean only takes booleans")
-    end
-  end
-
-  def munge_integer(value)
-      Integer(value)
-  rescue ArgumentError
-      fail _("munge_integer only takes integers")
-  end
-
-  newparam(:name) do
-    desc "The name of the right or rule to be managed.
-    Corresponds to `key` in Authorization Services. The key is the name
-    of a rule. A key uses the same naming conventions as a right. The
-    Security Server uses a rule's key to match the rule with a right.
-    Wildcard keys end with a '.'. The generic rule has an empty key value.
-    Any rights that do not match a specific rule use the generic rule."
-
-    isnamevar
-  end
-
-  newproperty(:auth_type) do
-    desc "Type --- this can be a `right` or a `rule`. The `comment` type has
-    not yet been implemented."
-
-    newvalue(:right)
-    newvalue(:rule)
-    # newvalue(:comment)  # not yet implemented.
-  end
-
-  newproperty(:allow_root, :boolean => true) do
-    desc "Corresponds to `allow-root` in the authorization store. Specifies
-    whether a right should be allowed automatically if the requesting process
-    is running with `uid == 0`.  AuthorizationServices defaults this attribute
-    to false if not specified."
-
-    newvalue(:true)
-    newvalue(:false)
-
-    munge do |value|
-      @resource.munge_boolean(value)
-    end
-  end
-
-  newproperty(:authenticate_user, :boolean => true) do
-    desc "Corresponds to `authenticate-user` in the authorization store."
-
-    newvalue(:true)
-    newvalue(:false)
-
-    munge do |value|
-      @resource.munge_boolean(value)
-    end
-  end
-
-  newproperty(:auth_class) do
-    desc "Corresponds to `class` in the authorization store; renamed due
-    to 'class' being a reserved word in Puppet."
-
-    newvalue(:user)
-    newvalue(:'evaluate-mechanisms')
-    newvalue(:allow)
-    newvalue(:deny)
-    newvalue(:rule)
-  end
-
-  newproperty(:comment) do
-    desc "The `comment` attribute for authorization resources."
-  end
-
-  newproperty(:group) do
-    desc "A group which the user must authenticate as a member of. This
-    must be a single group."
-  end
-
-  newproperty(:k_of_n) do
-    desc "How large a subset of rule mechanisms must succeed for successful
-    authentication. If there are 'n' mechanisms, then 'k' (the integer value
-    of this parameter) mechanisms must succeed. The most common setting for
-    this parameter is `1`. If `k-of-n` is not set, then every mechanism ---
-    that is, 'n-of-n' --- must succeed."
-
-    munge do |value|
-      @resource.munge_integer(value)
-    end
-  end
-
-  newproperty(:mechanisms, :array_matching => :all) do
-    desc "An array of suitable mechanisms."
-  end
-
-  newproperty(:rule, :array_matching => :all) do
-    desc "The rule(s) that this right refers to."
-  end
-
-  newproperty(:session_owner, :boolean => true) do
-    desc "Whether the session owner automatically matches this rule or right.
-    Corresponds to `session-owner` in the authorization store."
-
-    newvalue(:true)
-    newvalue(:false)
-
-    munge do |value|
-      @resource.munge_boolean(value)
-    end
-  end
-
-  newproperty(:shared, :boolean => true) do
-    desc "Whether the Security Server should mark the credentials used to gain
-    this right as shared. The Security Server may use any shared credentials
-    to authorize this right. For maximum security, set sharing to false so
-    credentials stored by the Security Server for one application may not be
-    used by another application."
-
-    newvalue(:true)
-    newvalue(:false)
-
-    munge do |value|
-      @resource.munge_boolean(value)
-    end
-  end
-
-  newproperty(:timeout) do
-    desc "The number of seconds in which the credential used by this rule will
-    expire. For maximum security where the user must authenticate every time,
-    set the timeout to 0. For minimum security, remove the timeout attribute
-    so the user authenticates only once per session."
-
-    munge do |value|
-      @resource.munge_integer(value)
-    end
-  end
-
-  newproperty(:tries) do
-    desc "The number of tries allowed."
-    munge do |value|
-      @resource.munge_integer(value)
-    end
-  end
-
-end

data/vendored/puppet/lib/puppet/type/mcx.rb

@@ -1,98 +0,0 @@
-Puppet::Type.newtype(:mcx) do
-
-  @doc = "MCX object management using DirectoryService on OS X.
-
-The default provider of this type merely manages the XML plist as
-reported by the `dscl -mcxexport` command.  This is similar to the
-content property of the file type in Puppet.
-
-The recommended method of using this type is to use Work Group Manager
-to manage users and groups on the local computer, record the resulting
-puppet manifest using the command `puppet resource mcx`, then deploy it
-to other machines.
-
-**Autorequires:** If Puppet is managing the user, group, or computer that these
-MCX settings refer to, the MCX resource will autorequire that user, group, or computer.
-"
-  feature :manages_content, \
-    "The provider can manage MCXSettings as a string.",
-    :methods => [:content, :content=]
-
-  ensurable do
-    desc "Create or remove the MCX setting."
-
-    newvalue(:present) do
-      provider.create
-    end
-
-    newvalue(:absent) do
-      provider.destroy
-    end
-
-  end
-
-  newparam(:name) do
-    desc "The name of the resource being managed.
-    The default naming convention follows Directory Service paths:
-
-        /Computers/localhost
-        /Groups/admin
-        /Users/localadmin
-
-    The `ds_type` and `ds_name` type parameters are not necessary if the
-    default naming convention is followed."
-    isnamevar
-  end
-
-  newparam(:ds_type) do
-
-    desc "The DirectoryService type this MCX setting attaches to."
-
-    newvalues(:user, :group, :computer, :computerlist)
-
-  end
-
-  newparam(:ds_name) do
-    desc "The name to attach the MCX Setting to. (For example, `localhost`
-    when `ds_type => computer`.) This setting is not required, as it can be
-    automatically discovered when the resource name is parseable.  (For
-    example, in `/Groups/admin`, `group` will be used as the dstype.)"
-  end
-
-  newproperty(:content, :required_features => :manages_content) do
-    desc "The XML Plist used as the value of MCXSettings in DirectoryService.
-    This is the standard output from the system command:
-
-        dscl localhost -mcxexport /Local/Default/<ds_type>/ds_name
-
-    Note that `ds_type` is capitalized and plural in the dscl command."
-  end
-
-  # JJM Yes, this is not DRY at all.  Because of the code blocks
-  # autorequire must be done this way.  I think.
-
-  def setup_autorequire(type)
-    # value returns a Symbol
-    ds_type = value(:ds_type)
-    ds_name = value(:ds_name)
-    if ds_type == type
-      rval = [ ds_name.to_s ]
-    else
-      rval = [ ]
-    end
-    rval
-  end
-
-  autorequire(:user) do
-    setup_autorequire(:user)
-  end
-
-  autorequire(:group) do
-    setup_autorequire(:group)
-  end
-
-  autorequire(:computer) do
-    setup_autorequire(:computer)
-  end
-
-end

data/vendored/puppet/lib/puppet/type/mount.rb

@@ -1,314 +0,0 @@
-require 'puppet/property/boolean'
-
-module Puppet
-  # We want the mount to refresh when it changes.
-  Type.newtype(:mount, :self_refresh => true) do
-    @doc = "Manages mounted filesystems, including putting mount
-      information into the mount table. The actual behavior depends
-      on the value of the 'ensure' parameter.
-
-      **Refresh:** `mount` resources can respond to refresh events (via
-      `notify`, `subscribe`, or the `~>` arrow). If a `mount` receives an event
-      from another resource **and** its `ensure` attribute is set to `mounted`,
-      Puppet will try to unmount then remount that filesystem.
-
-      **Autorequires:** If Puppet is managing any parents of a mount resource ---
-      that is, other mount points higher up in the filesystem --- the child
-      mount will autorequire them.
-
-      **Autobefores:**  If Puppet is managing any child file paths of a mount
-      point, the mount resource will autobefore them."
-
-    feature :refreshable, "The provider can remount the filesystem.",
-      :methods => [:remount]
-
-    # Use the normal parent class, because we actually want to
-    # call code when sync is called.
-    newproperty(:ensure) do
-      desc "Control what to do with this mount. Set this attribute to
-        `unmounted` to make sure the filesystem is in the filesystem table
-        but not mounted (if the filesystem is currently mounted, it will be
-        unmounted).  Set it to `absent` to unmount (if necessary) and remove
-        the filesystem from the fstab.  Set to `mounted` to add it to the
-        fstab and mount it. Set to `present` to add to fstab but not change
-        mount/unmount status."
-
-      #  IS        -> SHOULD     In Sync  Action
-      #  ghost     -> present    NO       create
-      #  absent    -> present    NO       create
-      # (mounted   -> present    YES)
-      # (unmounted -> present    YES)
-      newvalue(:defined) do
-        provider.create
-        return :mount_created
-      end
-
-      aliasvalue :present, :defined
-
-      #  IS        -> SHOULD     In Sync  Action
-      #  ghost     -> unmounted  NO       create, unmount
-      #  absent    -> unmounted  NO       create
-      #  mounted   -> unmounted  NO       unmount
-      newvalue(:unmounted) do
-        case self.retrieve
-        when :ghost   # (not in fstab but mounted)
-          provider.create
-          @resource.flush
-          provider.unmount
-          return :mount_unmounted
-        when nil, :absent  # (not in fstab and not mounted)
-          provider.create
-          return :mount_created
-        when :mounted # (in fstab and mounted)
-          provider.unmount
-          syncothers # I guess it's more likely that the mount was originally mounted with
-                     # the wrong attributes so I sync AFTER the umount
-          return :mount_unmounted
-        else
-          raise Puppet::Error, _("Unexpected change from %{current} to unmounted") % { current: current_value }
-        end
-      end
-
-      #  IS        -> SHOULD     In Sync  Action
-      #  ghost     -> absent     NO       unmount
-      #  mounted   -> absent     NO       provider.destroy AND unmount
-      #  unmounted -> absent     NO       provider.destroy
-      newvalue(:absent, :event => :mount_deleted) do
-        current_value = self.retrieve
-        provider.unmount if provider.mounted?
-        provider.destroy unless current_value == :ghost
-      end
-
-      #  IS        -> SHOULD     In Sync  Action
-      #  ghost     -> mounted    NO       provider.create
-      #  absent    -> mounted    NO       provider.create AND mount
-      #  unmounted -> mounted    NO       mount
-      newvalue(:mounted, :event => :mount_mounted) do
-        # Create the mount point if it does not already exist.
-        current_value = self.retrieve
-        currently_mounted = provider.mounted?
-        provider.create if [nil, :absent, :ghost].include?(current_value)
-
-        syncothers
-
-        # The fs can be already mounted if it was absent but mounted
-        provider.property_hash[:needs_mount] = true unless currently_mounted
-      end
-
-      # insync: mounted   -> present
-      #         unmounted -> present
-      def insync?(is)
-        if should == :defined and [:mounted,:unmounted].include?(is)
-          true
-        else
-          super
-        end
-      end
-
-      def syncothers
-        # We have to flush any changes to disk.
-        currentvalues = @resource.retrieve_resource
-
-        # Determine if there are any out-of-sync properties.
-        oos = @resource.send(:properties).find_all do |prop|
-          unless currentvalues.include?(prop)
-            raise Puppet::DevError, _("Parent has property %{name} but it doesn't appear in the current values") % { name: prop.name }
-          end
-          if prop.name == :ensure
-            false
-          else
-            ! prop.safe_insync?(currentvalues[prop])
-          end
-        end.each { |prop| prop.sync }.length
-        @resource.flush if oos > 0
-      end
-    end
-
-    newproperty(:device) do
-      desc "The device providing the mount.  This can be whatever
-        device is supporting by the mount, including network
-        devices or devices specified by UUID rather than device
-        path, depending on the operating system."
-
-      validate do |value|
-        raise Puppet::Error, _("device must not contain whitespace: %{value}") % { value: value } if value =~ /\s/
-      end
-    end
-
-    # Solaris specifies two devices, not just one.
-    newproperty(:blockdevice) do
-      desc "The device to fsck.  This is property is only valid
-        on Solaris, and in most cases will default to the correct
-        value."
-
-      # Default to the device but with "dsk" replaced with "rdsk".
-      defaultto do
-        if Facter.value(:osfamily) == "Solaris"
-          if device = resource[:device] and device =~ %r{/dsk/}
-            device.sub(%r{/dsk/}, "/rdsk/")
-          elsif fstype = resource[:fstype] and fstype == 'nfs'
-            '-'
-          else
-            nil
-          end
-        else
-          nil
-        end
-      end
-
-      validate do |value|
-        raise Puppet::Error, _("blockdevice must not contain whitespace: %{value}") % { value: value } if value =~ /\s/
-      end
-    end
-
-    newproperty(:fstype) do
-      desc "The mount type.  Valid values depend on the
-        operating system.  This is a required option."
-
-      validate do |value|
-        raise Puppet::Error, _("fstype must not contain whitespace: %{value}") % { value: value } if value =~ /\s/
-        raise Puppet::Error, _("fstype must not be an empty string") if value.empty?
-      end
-    end
-
-    newproperty(:options) do
-      desc "A single string containing options for the mount, as they would
-        appear in fstab on Linux. For many platforms this is a comma-delimited
-        string. Consult the fstab(5) man page for system-specific details.
-        AIX options other than dev, nodename, or vfs can be defined here. If
-        specified, AIX options of account, boot, check, free, mount, size,
-        type, vol, log, and quota must be ordered alphabetically at the end of
-        the list."
-
-      validate do |value|
-        raise Puppet::Error, _("options must not contain whitespace: %{value}") % { value: value } if value =~ /\s/
-        raise Puppet::Error, _("options must not be an empty string") if value.empty?
-      end
-    end
-
-    newproperty(:pass) do
-      desc "The pass in which the mount is checked."
-
-      defaultto {
-        if @resource.managed?
-          if Facter.value(:osfamily) == 'Solaris'
-            '-'
-          else
-            0
-          end
-        end
-      }
-    end
-
-    newproperty(:atboot, :parent => Puppet::Property::Boolean) do
-      desc "Whether to mount the mount at boot.  Not all platforms
-        support this."
-
-      def munge(value)
-        munged = super
-        if munged
-          :yes
-        else
-          :no
-        end
-      end
-    end
-
-    newproperty(:dump) do
-      desc "Whether to dump the mount.  Not all platform support this.
-        Valid values are `1` or `0` (or `2` on FreeBSD). Default is `0`."
-
-      if Facter.value(:operatingsystem) == "FreeBSD"
-        newvalue(%r{(0|1|2)})
-      else
-        newvalue(%r{(0|1)})
-      end
-
-      defaultto {
-        0 if @resource.managed?
-      }
-    end
-
-    newproperty(:target) do
-      desc "The file in which to store the mount table.  Only used by
-        those providers that write to disk."
-
-      defaultto { if @resource.class.defaultprovider.ancestors.include?(Puppet::Provider::ParsedFile)
-          @resource.class.defaultprovider.default_target
-        else
-          nil
-        end
-      }
-    end
-
-    newparam(:name) do
-      desc "The mount path for the mount."
-
-      isnamevar
-
-      validate do |value|
-        raise Puppet::Error, _("name must not contain whitespace: %{value}") % { value: value } if value =~ /\s/
-      end
-
-      munge do |value|
-        value.gsub(/^(.+?)\/*$/, '\1')
-      end
-    end
-
-    newparam(:remounts) do
-      desc "Whether the mount can be remounted  `mount -o remount`.  If
-        this is false, then the filesystem will be unmounted and remounted
-        manually, which is prone to failure."
-
-      newvalues(:true, :false)
-      defaultto do
-        case Facter.value(:operatingsystem)
-        when "FreeBSD", "Darwin", "DragonFly", "OpenBSD"
-          false
-        when "AIX"
-          if Facter.value(:kernelmajversion) == "5300"
-            false
-          elsif resource[:device] and resource[:device].match(%r{^[^/]+:/})
-            false
-          else
-            true
-          end
-        else
-          true
-        end
-      end
-    end
-
-    def refresh
-      # Only remount if we're supposed to be mounted.
-      provider.remount if self.should(:fstype) != "swap" and provider.mounted?
-    end
-
-    def value(name)
-      name = name.intern
-      if property = @parameters[name]
-        return property.value
-      end
-    end
-
-    # Ensure that mounts higher up in the filesystem are mounted first
-    autorequire(:mount) do
-      dependencies = []
-      Pathname.new(@parameters[:name].value).ascend do |parent|
-        dependencies.unshift parent.to_s
-      end
-      dependencies[0..-2]
-    end
-
-    # Autobefore the mount point's child file paths
-    autobefore(:file) do
-      dependencies = []
-      file_resources = catalog.resources.select { |resource| resource.type == :file }
-      children_file_resources = file_resources.select { |resource| File.expand_path(resource[:path]) =~ %r(^#{self[:name]}/.) }
-      children_file_resources.each do |child|
-        dependencies.push Pathname.new(child[:path])
-      end
-      dependencies
-    end
-  end
-end

data/vendored/puppet/lib/puppet/type/router.rb

@@ -1,17 +0,0 @@
-#
-# Manage a router abstraction
-
-
-module Puppet
-  Type.newtype(:router) do
-    @doc = "Manages connected router."
-
-    newparam(:url) do
-      desc <<-EOT
-        An SSH or telnet URL at which to access the router, in the form
-        `ssh://user:pass:enable@host/` or `telnet://user:pass:enable@host/`.
-      EOT
-      isnamevar
-    end
-  end
-end