bolt 0.21.1 → 0.21.2

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

@@ -1,125 +0,0 @@
-Puppet::Type.type(:zpool).provide(:zpool) do
-  desc "Provider for zpool."
-
-  commands :zpool => 'zpool'
-
-  #NAME    SIZE  ALLOC   FREE    CAP  HEALTH  ALTROOT
-  def self.instances
-    zpool(:list, '-H').split("\n").collect do |line|
-      name, _size, _alloc, _free, _cap, _health, _altroot = line.split(/\s+/)
-      new({:name => name, :ensure => :present})
-    end
-  end
-
-  def process_zpool_data(pool_array)
-    if pool_array == []
-      return Hash.new(:absent)
-    end
-    #get the name and get rid of it
-    pool = Hash.new
-    pool[:pool] = pool_array[0]
-    pool_array.shift
-
-    tmp = []
-
-    #order matters here :(
-    pool_array.reverse_each do |value|
-      sym = nil
-      case value
-      when "spares";
-        sym = :spare
-      when "logs";
-        sym = :log
-      when /^mirror|^raidz1|^raidz2/;
-        sym = value =~ /^mirror/ ? :mirror : :raidz
-        pool[:raid_parity] = "raidz2" if value =~ /^raidz2/
-      else
-        tmp << value
-        sym = :disk if value == pool_array.first
-      end
-
-      if sym
-        pool[sym] = pool[sym] ? pool[sym].unshift(tmp.reverse.join(' ')) : [tmp.reverse.join(' ')]
-        tmp.clear
-      end
-    end
-
-    pool
-  end
-
-  def get_pool_data
-    # https://docs.oracle.com/cd/E19082-01/817-2271/gbcve/index.html
-    # we could also use zpool iostat -v mypool for a (little bit) cleaner output
-    out = execute("zpool status #{@resource[:pool]}", :failonfail => false, :combine => false)
-    zpool_data = out.lines.select { |line| line.index("\t") == 0 }.collect { |l| l.strip.split("\s")[0] }
-    zpool_data.shift
-    zpool_data
-  end
-
-  def current_pool
-    @current_pool = process_zpool_data(get_pool_data) unless (defined?(@current_pool) and @current_pool)
-    @current_pool
-  end
-
-  def flush
-    @current_pool= nil
-  end
-
-  #Adds log and spare
-  def build_named(name)
-    if prop = @resource[name.intern]
-      [name] + prop.collect { |p| p.split(' ') }.flatten
-    else
-      []
-    end
-  end
-
-  #query for parity and set the right string
-  def raidzarity
-    @resource[:raid_parity] ? @resource[:raid_parity] : "raidz1"
-  end
-
-  #handle mirror or raid
-  def handle_multi_arrays(prefix, array)
-    array.collect{ |a| [prefix] +  a.split(' ') }.flatten
-  end
-
-  #builds up the vdevs for create command
-  def build_vdevs
-    if disk = @resource[:disk]
-      disk.collect { |d| d.split(' ') }.flatten
-    elsif mirror = @resource[:mirror]
-      handle_multi_arrays("mirror", mirror)
-    elsif raidz = @resource[:raidz]
-      handle_multi_arrays(raidzarity, raidz)
-    end
-  end
-
-  def create
-    zpool(*([:create, @resource[:pool]] + build_vdevs + build_named("spare") + build_named("log")))
-  end
-
-  def destroy
-    zpool :destroy, @resource[:pool]
-  end
-
-  def exists?
-    if current_pool[:pool] == :absent
-      false
-    else
-      true
-    end
-  end
-
-  [:disk, :mirror, :raidz, :log, :spare].each do |field|
-    define_method(field) do
-      current_pool[field]
-    end
-
-    define_method(field.to_s + "=") do |should|
-      self.fail "zpool #{field} can't be changed. should be #{should}, currently is #{current_pool[field]}"
-    end
-  end
-
-end
-

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

@@ -1,46 +0,0 @@
-module Puppet
-  Type.newtype(:mailalias) do
-    @doc = "Creates an email alias in the local alias database."
-
-    ensurable
-
-    newparam(:name, :namevar => true) do
-      desc "The alias name."
-    end
-
-    newproperty(:recipient, :array_matching => :all) do
-      desc "Where email should be sent.  Multiple values
-        should be specified as an array.  The file and the
-        recipient entries are mutually exclusive."
-    end
-
-    newproperty(:file) do
-      desc "A file containing the alias's contents.  The file and the
-        recipient entries are mutually exclusive."
-
-      validate do |value|
-	unless Puppet::Util.absolute_path?(value)
-	  fail Puppet::Error, _("File paths must be fully qualified, not '%{value}'") % { value: value }
-	end
-      end
-    end
-
-    newproperty(:target) do
-      desc "The file in which to store the aliases.  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
-
-    validate do
-      if self[:recipient] && self[:file]
-	self.fail _("You cannot specify both a recipient and a file")
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-module Puppet
-  Type.newtype(:maillist) do
-    @doc = "Manage email lists.  This resource type can only create
-      and remove lists; it cannot currently reconfigure them."
-
-    ensurable do
-      defaultvalues
-
-      newvalue(:purged) do
-        provider.purge
-      end
-
-      def change_to_s(current_value, newvalue)
-        return _("Purged %{resource}") % { resource: resource } if newvalue == :purged
-        super
-      end
-
-      def insync?(is)
-        return true if is == :absent && should == :purged
-        super
-      end
-    end
-
-    newparam(:name, :namevar => true) do
-      desc "The name of the email list."
-    end
-
-    newparam(:description) do
-      desc "The description of the mailing list."
-    end
-
-    newparam(:password) do
-      desc "The admin password."
-    end
-
-    newparam(:webserver) do
-      desc "The name of the host providing web archives and the administrative interface."
-    end
-
-    newparam(:mailserver) do
-      desc "The name of the host handling email for the list."
-    end
-
-    newparam(:admin) do
-      desc "The email address of the administrator."
-    end
-
-    def generate
-      if provider.respond_to?(:aliases)
-        should = self.should(:ensure) || :present
-        if should == :purged
-          should = :absent
-        end
-        atype = Puppet::Type.type(:mailalias)
-
-        provider.aliases.
-          reject  { |name,recipient| catalog.resource(:mailalias, name) }.
-          collect { |name,recipient| atype.new(:name => name, :recipient => recipient, :ensure => should) }
-      end
-    end
-  end
-end

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

@@ -1,154 +0,0 @@
-module Puppet
-  Type.newtype(:zfs) do
-    @doc = "Manage zfs. Create destroy and set properties on zfs instances.
-
-**Autorequires:** If Puppet is managing the zpool at the root of this zfs
-instance, the zfs resource will autorequire it. If Puppet is managing any
-parent zfs instances, the zfs resource will autorequire them."
-
-    ensurable
-
-    newparam(:name) do
-      desc "The full name for this filesystem (including the zpool)."
-    end
-
-    newproperty(:aclinherit) do
-      desc "The aclinherit property. Valid values are `discard`, `noallow`, `restricted`, `passthrough`, `passthrough-x`."
-    end
-
-    newproperty(:aclmode) do
-      desc "The aclmode property. Valid values are `discard`, `groupmask`, `passthrough`."
-    end
-
-    newproperty(:acltype) do
-      desc "The acltype propery. Valid values are 'noacl' and 'posixacl'. Only supported on Linux."
-    end
-
-    newproperty(:atime) do
-      desc "The atime property. Valid values are `on`, `off`."
-    end
-
-    newproperty(:canmount) do
-      desc "The canmount property. Valid values are `on`, `off`, `noauto`."
-    end
-
-    newproperty(:checksum) do
-      desc "The checksum property. Valid values are `on`, `off`, `fletcher2`, `fletcher4`, `sha256`."
-    end
-
-    newproperty(:compression) do
-      desc "The compression property. Valid values are `on`, `off`, `lzjb`, `gzip`, `gzip-[1-9]`, `zle`."
-    end
-
-    newproperty(:copies) do
-      desc "The copies property. Valid values are `1`, `2`, `3`."
-    end
-
-    newproperty(:dedup) do
-      desc "The dedup property. Valid values are `on`, `off`."
-    end
-
-    newproperty(:devices) do
-      desc "The devices property. Valid values are `on`, `off`."
-    end
-
-    newproperty(:exec) do
-      desc "The exec property. Valid values are `on`, `off`."
-    end
-
-    newproperty(:logbias) do
-      desc "The logbias property. Valid values are `latency`, `throughput`."
-    end
-
-    newproperty(:mountpoint) do
-      desc "The mountpoint property. Valid values are `<path>`, `legacy`, `none`."
-    end
-
-    newproperty(:nbmand) do
-      desc "The nbmand property. Valid values are `on`, `off`."
-    end
-
-    newproperty(:primarycache) do
-      desc "The primarycache property. Valid values are `all`, `none`, `metadata`."
-    end
-
-    newproperty(:quota) do
-      desc "The quota property. Valid values are `<size>`, `none`."
-    end
-
-    newproperty(:readonly) do
-      desc "The readonly property. Valid values are `on`, `off`."
-    end
-
-    newproperty(:recordsize) do
-      desc "The recordsize property. Valid values are powers of two between 512 and 128k."
-    end
-
-    newproperty(:refquota) do
-      desc "The refquota property. Valid values are `<size>`, `none`."
-    end
-
-    newproperty(:refreservation) do
-      desc "The refreservation property. Valid values are `<size>`, `none`."
-    end
-
-    newproperty(:reservation) do
-      desc "The reservation property. Valid values are `<size>`, `none`."
-    end
-
-    newproperty(:secondarycache) do
-      desc "The secondarycache property. Valid values are `all`, `none`, `metadata`."
-    end
-
-    newproperty(:setuid) do
-      desc "The setuid property. Valid values are `on`, `off`."
-    end
-
-    newproperty(:shareiscsi) do
-      desc "The shareiscsi property. Valid values are `on`, `off`, `type=<type>`."
-    end
-
-    newproperty(:sharenfs) do
-      desc "The sharenfs property. Valid values are `on`, `off`, share(1M) options"
-    end
-
-    newproperty(:sharesmb) do
-      desc "The sharesmb property. Valid values are `on`, `off`, sharemgr(1M) options"
-    end
-
-    newproperty(:snapdir) do
-      desc "The snapdir property. Valid values are `hidden`, `visible`."
-    end
-
-    newproperty(:version) do
-      desc "The version property. Valid values are `1`, `2`, `3`, `4`, `current`."
-    end
-
-    newproperty(:volsize) do
-      desc "The volsize property. Valid values are `<size>`"
-    end
-
-    newproperty(:vscan) do
-      desc "The vscan property. Valid values are `on`, `off`."
-    end
-
-    newproperty(:xattr) do
-      desc "The xattr property. Valid values are `on`, `off`."
-    end
-
-    newproperty(:zoned) do
-      desc "The zoned property. Valid values are `on`, `off`."
-    end
-
-    autorequire(:zpool) do
-      #strip the zpool off the zfs name and autorequire it
-      [@parameters[:name].value.split('/')[0]]
-    end
-
-    autorequire(:zfs) do
-      #slice and dice, we want all the zfs before this one
-      names = @parameters[:name].value.split('/')
-      names.slice(1..-2).inject([]) { |a,v| a << "#{a.last}/#{v}" }.collect { |fs| names[0] + fs }
-    end
-  end
-end

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

@@ -1,382 +0,0 @@
-require 'puppet/property/list'
-Puppet::Type.newtype(:zone) do
-  @doc = "Manages Solaris zones.
-
-**Autorequires:** If Puppet is managing the directory specified as the root of
-the zone's filesystem (with the `path` attribute), the zone resource will
-autorequire that directory."
-
-module Puppet::Zone
-  class StateMachine
-    # A silly little state machine.
-    def initialize
-      @state = {}
-      @sequence = []
-      @state_aliases = {}
-      @default = nil
-    end
-
-    # The order of calling insert_state is important
-    def insert_state(name, transitions)
-      @sequence << name
-      @state[name] = transitions
-    end
-
-    def alias_state(state, salias)
-      @state_aliases[state] = salias
-    end
-
-    def name(n)
-      @state_aliases[n.to_sym] || n.to_sym
-    end
-
-    def index(state)
-      @sequence.index(name(state))
-    end
-
-    # return all states between fs and ss excluding fs
-    def sequence(fs, ss)
-      fi = index(fs)
-      si= index(ss)
-      (if fi > si
-        then @sequence[si .. fi].map{|i| @state[i]}.reverse
-        else @sequence[fi .. si].map{|i| @state[i]}
-      end)[1..-1]
-    end
-
-    def cmp?(a,b)
-      index(a) < index(b)
-    end
-  end
-end
-
-  ensurable do
-    desc "The running state of the zone.  The valid states directly reflect
-      the states that `zoneadm` provides.  The states are linear,
-      in that a zone must be `configured`, then `installed`, and
-      only then can be `running`.  Note also that `halt` is currently
-      used to stop zones."
-
-    def self.fsm
-      return @fsm if @fsm
-      @fsm = Puppet::Zone::StateMachine.new
-    end
-
-    def self.alias_state(values)
-      values.each do |k,v|
-        fsm.alias_state(k,v)
-      end
-    end
-
-    def self.seqvalue(name, hash)
-      fsm.insert_state(name, hash)
-      self.newvalue name
-    end
-
-    # This is seq value because the order of declaration is important.
-    # i.e we go linearly from :absent -> :configured -> :installed -> :running
-    seqvalue :absent, :down => :destroy
-    seqvalue :configured, :up => :configure, :down => :uninstall
-    seqvalue :installed, :up => :install, :down => :stop
-    seqvalue :running, :up => :start
-
-    alias_state :incomplete => :installed, :ready => :installed, :shutting_down => :running
-
-    defaultto :running
-
-    def self.state_sequence(first, second)
-      fsm.sequence(first, second)
-    end
-
-    # Why override it? because property/ensure.rb has a default retrieve method
-    # that knows only about :present and :absent. That method just calls
-    # provider.exists? and returns :present if a result was returned.
-    def retrieve
-      provider.properties[:ensure]
-    end
-
-    def provider_sync_send(method)
-      warned = false
-      while provider.processing?
-        next if warned
-        info _("Waiting for zone to finish processing")
-        warned = true
-        sleep 1
-      end
-      provider.send(method)
-      provider.flush()
-    end
-
-    def sync
-      method = nil
-      direction = up? ? :up : :down
-
-      # We need to get the state we're currently in and just call
-      # everything between it and us.
-      self.class.state_sequence(self.retrieve, self.should).each do |state|
-        method = state[direction]
-        raise Puppet::DevError, _("Cannot move %{direction} from %{name}") % { direction: direction, name: st[:name] } unless method
-        provider_sync_send(method)
-      end
-
-      ("zone_#{self.should}").intern
-    end
-
-    # Are we moving up the property tree?
-    def up?
-      self.class.fsm.cmp?(self.retrieve, self.should)
-    end
-
-  end
-
-  newparam(:name) do
-    desc "The name of the zone."
-
-    isnamevar
-  end
-
-  newparam(:id) do
-    desc "The numerical ID of the zone.  This number is autogenerated
-      and cannot be changed."
-  end
-
-  newparam(:clone) do
-    desc "Instead of installing the zone, clone it from another zone.
-      If the zone root resides on a zfs file system, a snapshot will be
-      used to create the clone; if it resides on a ufs filesystem, a copy of the
-      zone will be used. The zone from which you clone must not be running."
-  end
-
-  newproperty(:ip, :parent => Puppet::Property::List) do
-    require 'ipaddr'
-
-    desc "The IP address of the zone.  IP addresses **must** be specified
-      with an interface, and may optionally be specified with a default router
-      (sometimes called a defrouter). The interface, IP address, and default
-      router should be separated by colons to form a complete IP address string.
-      For example: `bge0:192.168.178.200` would be a valid IP address string
-      without a default router, and `bge0:192.168.178.200:192.168.178.1` adds a
-      default router to it.
-
-      For zones with multiple interfaces, the value of this attribute should be
-      an array of IP address strings (each of which must include an interface
-      and may include a default router)."
-
-    # The default action of list should is to lst.join(' '). By specifying
-    # @should, we ensure the should remains an array. If we override should, we
-    # should also override insync?() -- property/list.rb
-    def should
-      @should
-    end
-
-    # overridden so that we match with self.should
-    def insync?(is)
-      is = [] if !is || is == :absent
-      is.sort == self.should.sort
-    end
-  end
-
-  newproperty(:iptype) do
-    desc "The IP stack type of the zone."
-    defaultto :shared
-    newvalue :shared
-    newvalue :exclusive
-  end
-
-  newproperty(:autoboot, :boolean => true) do
-    desc "Whether the zone should automatically boot."
-    defaultto true
-    newvalues(:true, :false)
-  end
-
-  newproperty(:path) do
-    desc "The root of the zone's filesystem.  Must be a fully qualified
-      file name.  If you include `%s` in the path, then it will be
-      replaced with the zone's name.  Currently, you cannot use
-      Puppet to move a zone. Consequently this is a readonly property."
-
-    validate do |value|
-      raise ArgumentError, _("The zone base must be fully qualified") unless value =~ /^\//
-    end
-
-    munge do |value|
-      if value =~ /%s/
-        value % @resource[:name]
-      else
-        value
-      end
-    end
-  end
-
-  newproperty(:pool) do
-    desc "The resource pool for this zone."
-  end
-
-  newproperty(:shares) do
-    desc "Number of FSS CPU shares allocated to the zone."
-  end
-
-  newproperty(:dataset, :parent => Puppet::Property::List ) do
-    desc "The list of datasets delegated to the non-global zone from the
-      global zone.  All datasets must be zfs filesystem names which are
-      different from the mountpoint."
-
-    def should
-      @should
-    end
-
-    # overridden so that we match with self.should
-    def insync?(is)
-      is = [] if !is || is == :absent
-      is.sort == self.should.sort
-    end
-
-    validate do |value|
-      unless value !~ /^\//
-        raise ArgumentError, _("Datasets must be the name of a zfs filesystem")
-      end
-    end
-  end
-
-  newproperty(:inherit, :parent => Puppet::Property::List) do
-    desc "The list of directories that the zone inherits from the global
-      zone.  All directories must be fully qualified."
-
-    def should
-      @should
-    end
-
-    # overridden so that we match with self.should
-    def insync?(is)
-      is = [] if !is || is == :absent
-      is.sort == self.should.sort
-    end
-
-    validate do |value|
-      unless value =~ /^\//
-        raise ArgumentError, _("Inherited filesystems must be fully qualified")
-      end
-    end
-  end
-
-  # Specify the sysidcfg file.  This is pretty hackish, because it's
-  # only used to boot the zone the very first time.
-  newparam(:sysidcfg) do
-    desc %{The text to go into the `sysidcfg` file when the zone is first
-      booted.  The best way is to use a template:
-
-          # $confdir/modules/site/templates/sysidcfg.erb
-          system_locale=en_US
-          timezone=GMT
-          terminal=xterms
-          security_policy=NONE
-          root_password=<%= password %>
-          timeserver=localhost
-          name_service=DNS {domain_name=<%= domain %> name_server=<%= nameserver %>}
-          network_interface=primary {hostname=<%= realhostname %>
-            ip_address=<%= ip %>
-            netmask=<%= netmask %>
-            protocol_ipv6=no
-            default_route=<%= defaultroute %>}
-          nfs4_domain=dynamic
-
-      And then call that:
-
-          zone { 'myzone':
-            ip           => 'bge0:192.168.0.23',
-            sysidcfg     => template('site/sysidcfg.erb'),
-            path         => '/opt/zones/myzone',
-            realhostname => 'fully.qualified.domain.name',
-          }
-
-      The `sysidcfg` only matters on the first booting of the zone,
-      so Puppet only checks for it at that time.}
-  end
-
-  newparam(:create_args) do
-    desc "Arguments to the `zonecfg` create command.  This can be used to create branded zones."
-  end
-
-  newparam(:install_args) do
-    desc "Arguments to the `zoneadm` install command.  This can be used to create branded zones."
-  end
-
-  newparam(:realhostname) do
-    desc "The actual hostname of the zone."
-  end
-
-  # If Puppet is also managing the base dir or its parent dir, list them
-  # both as prerequisites.
-  autorequire(:file) do
-    if @parameters.include? :path
-      [@parameters[:path].value, ::File.dirname(@parameters[:path].value)]
-    else
-      nil
-    end
-  end
-
-  # If Puppet is also managing the zfs filesystem which is the zone dataset
-  # then list it as a prerequisite.  Zpool's get autorequired by the zfs
-  # type.  We just need to autorequire the dataset zfs itself as the zfs type
-  # will autorequire all of the zfs parents and zpool.
-  autorequire(:zfs) do
-    # Check if we have datasets in our zone configuration and autorequire each dataset
-    self[:dataset] if @parameters.include? :dataset
-  end
-
-  def validate_ip(ip, name)
-    IPAddr.new(ip) if ip
-  rescue ArgumentError
-    self.fail Puppet::Error, _("'%{ip}' is an invalid %{name}") % { ip: ip, name: name }, $!
-  end
-
-  def validate_exclusive(interface, address, router)
-    return if !interface.nil? and address.nil?
-    self.fail _("only interface may be specified when using exclusive IP stack: %{interface}:%{address}") % { interface: interface, address: address }
-  end
-  def validate_shared(interface, address, router)
-    self.fail _("ip must contain interface name and ip address separated by a \":\"") if interface.nil? or address.nil?
-    [address, router].each do |ip|
-      validate_ip(address, "IP address") unless ip.nil?
-    end
-  end
-
-  validate do
-    return unless self[:ip]
-    # self[:ip] reflects the type passed from property:ip.should. If we
-    # override it and pass @should, then we get an array here back.
-    self[:ip].each do |ip|
-      interface, address, router = ip.split(':')
-      if self[:iptype] == :shared
-        validate_shared(interface, address, router)
-      else
-        validate_exclusive(interface, address, router)
-      end
-    end
-  end
-
-  def retrieve
-    provider.flush
-    hash = provider.properties
-    return setstatus(hash) unless hash.nil? or hash[:ensure] == :absent
-    # Return all properties as absent.
-    return Hash[properties.map{|p| [p, :absent]} ]
-  end
-
-  # Take the results of a listing and set everything appropriately.
-  def setstatus(hash)
-    prophash = {}
-    hash.each do |param, value|
-      next if param == :name
-      case self.class.attrtype(param)
-      when :property
-        # Only try to provide values for the properties we're managing
-        prop = self.property(param)
-        prophash[prop] = value if prop
-      else
-        self[param] = value
-      end
-    end
-    prophash
-  end
-end