puppet 5.5.22 → 6.0.0

data/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/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