puppet-retrospec 1.5.0 → 1.6.0

data/vendor/gems/puppet-4.5.2/lib/puppet/provider/aixobject.rb

@@ -1,392 +0,0 @@
-#
-# Common code for AIX providers. This class implements basic structure for
-# AIX resources.
-# Author::    Hector Rivas Gandara <keymon@gmail.com>
-#
-class Puppet::Provider::AixObject < Puppet::Provider
-  desc "Generic AIX resource provider"
-
-  # The real provider must implement these functions.
-  def lscmd( _value = @resource[:name] )
-    raise Puppet::Error, "Method not defined #{@resource.class.name} #{@resource.name}: Base AixObject provider doesn't implement lscmd"
-  end
-
-  def addcmd( _extra_attrs = [] )
-    raise Puppet::Error, "Method not defined #{@resource.class.name} #{@resource.name}: Base AixObject provider doesn't implement addcmd"
-  end
-
-  def modifycmd( _attributes_hash = {} )
-    raise Puppet::Error, "Method not defined #{@resource.class.name} #{@resource.name}: Base AixObject provider doesn't implement modifycmd"
-  end
-
-  def deletecmd
-    raise Puppet::Error, "Method not defined #{@resource.class.name} #{@resource.name}: Base AixObject provider doesn't implement deletecmd"
-  end
-
-  # Valid attributes to be managed by this provider.
-  # It is a list of hashes
-  #  :aix_attr      AIX command attribute name
-  #  :puppet_prop   Puppet propertie name
-  #  :to            Optional. Method name that adapts puppet property to aix command value.
-  #  :from          Optional. Method to adapt aix command line value to puppet property. Optional
-  class << self
-    attr_accessor :attribute_mapping
-  end
-
-  # Mapping from Puppet property to AIX attribute.
-  def self.attribute_mapping_to
-    if ! @attribute_mapping_to
-      @attribute_mapping_to = {}
-      attribute_mapping.each { |elem|
-        attribute_mapping_to[elem[:puppet_prop]] = {
-          :key => elem[:aix_attr],
-          :method => elem[:to]
-        }
-      }
-    end
-    @attribute_mapping_to
-  end
-
-  # Mapping from AIX attribute to Puppet property.
-  def self.attribute_mapping_from
-    if ! @attribute_mapping_from
-      @attribute_mapping_from = {}
-      attribute_mapping.each { |elem|
-        attribute_mapping_from[elem[:aix_attr]] = {
-          :key => elem[:puppet_prop],
-          :method => elem[:from]
-        }
-      }
-    end
-    @attribute_mapping_from
-  end
-
-  # This functions translates a key and value using the given mapping.
-  # Mapping can be nil (no translation) or a hash with this format
-  # {:key => new_key, :method => translate_method}
-  # It returns a list with the pair [key, value]
-  def translate_attr(key, value, mapping)
-    return [key, value] unless mapping
-    return nil unless mapping[key]
-
-    if mapping[key][:method]
-      new_value = method(mapping[key][:method]).call(value)
-    else
-      new_value = value
-    end
-    [mapping[key][:key], new_value]
-  end
-
-  # Loads an AIX attribute (key=value) and stores it in the given hash with
-  # puppet semantics. It translates the pair using the given mapping.
-  #
-  # This operation works with each property one by one,
-  # subclasses must reimplement this if more complex operations are needed
-  def load_attribute(key, value, mapping, objectinfo)
-    if mapping.nil?
-      objectinfo[key] = value
-    elsif mapping[key].nil?
-      # is not present in mapping, ignore it.
-      true
-    elsif mapping[key][:method].nil?
-      objectinfo[mapping[key][:key]] = value
-    else
-      objectinfo[mapping[key][:key]] = method(mapping[key][:method]).call(value)
-    end
-
-    return objectinfo
-  end
-
-  # Gets the given command line argument for the given key and value,
-  # using the given mapping to translate key and value.
-  # All the objectinfo hash (@resource or @property_hash) is passed.
-  #
-  # This operation works with each property one by one,
-  # and default behaviour is return the arguments as key=value pairs.
-  # Subclasses must reimplement this if more complex operations/arguments
-  # are needed
-  #
-  def get_arguments(key, value, mapping, objectinfo)
-    if mapping.nil?
-      new_key = key
-      new_value = value
-    elsif mapping[key].nil?
-      # is not present in mapping, ignore it.
-      new_key = nil
-      new_value = nil
-    elsif mapping[key][:method].nil?
-      new_key = mapping[key][:key]
-      new_value = value
-    else
-      new_key = mapping[key][:key]
-      new_value = method(mapping[key][:method]).call(value)
-    end
-
-    # convert it to string
-    new_value = Array(new_value).join(',')
-
-    if new_key
-      return [ "#{new_key}=#{new_value}" ]
-    else
-      return []
-    end
-  end
-
-  # Convert the provider properties (hash) to AIX command arguments
-  # (list of strings)
-  # This function will translate each value/key and generate the argument using
-  # the get_arguments function.
-  def hash2args(hash, mapping=self.class.attribute_mapping_to)
-    return "" unless hash
-    arg_list = []
-    hash.each {|key, val|
-      arg_list += self.get_arguments(key, val, mapping, hash)
-    }
-    arg_list
-  end
-
-  # Parse AIX command attributes from the output of an AIX command, that
-  # which format is a list of space separated of key=value pairs:
-  # "uid=100 groups=a,b,c".
-  # It returns a hash.
-  #
-  # If a mapping is provided, the keys are translated as defined in the
-  # mapping hash. And only values included in mapping will be added
-  #
-  # NOTE: it will ignore the items not including '='
-  def parse_attr_list(str, mapping=self.class.attribute_mapping_from)
-    properties = {}
-    attrs = []
-    if str.nil? or (attrs = str.split()).empty?
-      return nil
-    end
-
-    attrs.each { |i|
-      if i.include? "=" # Ignore if it does not include '='
-        (key_str, val) = i.split('=')
-        # Check the key
-        if key_str.nil? or key_str.empty?
-          info "Empty key in string 'i'?"
-          continue
-        end
-        key_str.strip!
-        key = key_str.to_sym
-        val.strip! if val
-
-        properties = self.load_attribute(key, val, mapping, properties)
-      end
-    }
-    properties.empty? ? nil : properties
-  end
-
-  # Parse AIX command output in a colon separated list of attributes,
-  # This function is useful to parse the output of commands like lsfs -c:
-  #   #MountPoint:Device:Vfs:Nodename:Type:Size:Options:AutoMount:Acct
-  #   /:/dev/hd4:jfs2::bootfs:557056:rw:yes:no
-  #   /home:/dev/hd1:jfs2:::2129920:rw:yes:no
-  #   /usr:/dev/hd2:jfs2::bootfs:9797632:rw:yes:no
-  #
-  # If a mapping is provided, the keys are translated as defined in the
-  # mapping hash. And only values included in mapping will be added
-  def parse_colon_list(str, key_list, mapping=self.class.attribute_mapping_from)
-    properties = {}
-    attrs = []
-    if str.nil? or (attrs = str.split(':')).empty?
-      return nil
-    end
-
-    attrs.each { |val|
-      key = key_list.shift.to_sym
-      properties = self.load_attribute(key, val, mapping, properties)
-    }
-    properties.empty? ? nil : properties
-  end
-
-  # Default parsing function for AIX commands.
-  # It will choose the method depending of the first line.
-  # For the colon separated list it will:
-  #  1. Get keys from first line.
-  #  2. Parse next line.
-  def parse_command_output(output, mapping=self.class.attribute_mapping_from)
-    lines = output.split("\n")
-    # if it begins with #something:... is a colon separated list.
-    if lines[0] =~ /^#.*:/
-      self.parse_colon_list(lines[1], lines[0][1..-1].split(':'), mapping)
-    else
-      self.parse_attr_list(lines[0], mapping)
-    end
-  end
-
-  # Retrieve all the information of an existing resource.
-  # It will execute 'lscmd' command and parse the output, using the mapping
-  # 'attribute_mapping_from' to translate the keys and values.
-  def getinfo(refresh = false)
-    if @objectinfo.nil? or refresh == true
-      # Execute lsuser, split all attributes and add them to a dict.
-      begin
-        output = execute(self.lscmd)
-        @objectinfo = self.parse_command_output(output)
-        # All attributtes without translation
-        @objectosinfo = self.parse_command_output(output, nil)
-      rescue Puppet::ExecutionFailure => detail
-        # Print error if needed. FIXME: Do not check the user here.
-        Puppet.debug "aix.getinfo(): Could not find #{@resource.class.name} #{@resource.name}: #{detail}"
-      end
-    end
-    @objectinfo
-  end
-
-  # Like getinfo, but it will not use the mapping to translate the keys and values.
-  # It might be usefult to retrieve some raw information.
-  def getosinfo(refresh = false)
-    if @objectosinfo.nil? or refresh == true
-      getinfo(refresh)
-    end
-    @objectosinfo || Hash.new
-  end
-
-
-  # List all elements of given type. It works for colon separated commands and
-  # list commands.
-  # It returns a list of names.
-  def self.list_all
-    names = []
-    begin
-      output = execute([self.command(:list), 'ALL'])
-
-      output = output.split("\n").select{ |line| line != /^#/ }
-
-      output.each do |line|
-        name = line.split(/[ :]/)[0]
-        names << name if not name.empty?
-      end
-    rescue Puppet::ExecutionFailure => detail
-      # Print error if needed
-      Puppet.debug "aix.list_all(): Could not get all resources of type #{@resource.class.name}: #{detail}"
-    end
-    names
-  end
-
-
-  #-------------
-  # Provider API
-  # ------------
-
-  # Clear out the cached values.
-  def flush
-    @property_hash.clear if @property_hash
-    @objectinfo.clear if @objectinfo
-  end
-
-  # Check that the user exists
-  def exists?
-    !!getinfo(true) # !! => converts to bool
-  end
-
-  # Return all existing instances
-  # The method for returning a list of provider instances.  Note that it returns
-  # providers, preferably with values already filled in, not resources.
-  def self.instances
-    objects=[]
-    list_all.each { |entry|
-      objects << new(:name => entry, :ensure => :present)
-    }
-    objects
-  end
-
-  #- **ensure**
-  #    The basic state that the object should be in.  Valid values are
-  #    `present`, `absent`, `role`.
-  # From ensurable: exists?, create, delete
-  def ensure
-    if exists?
-      :present
-    else
-      :absent
-    end
-  end
-
-  # Create a new instance of the resource
-  def create
-    if exists?
-      info "already exists"
-      # The object already exists
-      return nil
-    end
-
-    begin
-      execute(self.addcmd)
-    rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, "Could not create #{@resource.class.name} #{@resource.name}: #{detail}", detail.backtrace
-    end
-  end
-
-  # Delete this instance of the resource
-  def delete
-    unless exists?
-      info "already absent"
-      # the object already doesn't exist
-      return nil
-    end
-
-    begin
-      execute(self.deletecmd)
-    rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, "Could not delete #{@resource.class.name} #{@resource.name}: #{detail}", detail.backtrace
-    end
-  end
-
-  #--------------------------------
-  # Call this method when the object is initialized.
-  # It creates getter/setter methods for each property our resource type supports.
-  # If setter or getter already defined it will not be overwritten
-  def self.mk_resource_methods
-    [resource_type.validproperties, resource_type.parameters].flatten.each do |prop|
-      next if prop == :ensure
-      define_method(prop) { get(prop) || :absent} unless public_method_defined?(prop)
-      define_method(prop.to_s + "=") { |*vals| set(prop, *vals) } unless public_method_defined?(prop.to_s + "=")
-    end
-  end
-
-  # Define the needed getters and setters as soon as we know the resource type
-  def self.resource_type=(resource_type)
-    super
-    mk_resource_methods
-  end
-
-  # Retrieve a specific value by name.
-  def get(param)
-    (hash = getinfo(false)) ? hash[param] : nil
-  end
-
-  # Set a property.
-  def set(param, value)
-    @property_hash[param.intern] = value
-
-    if getinfo().nil?
-      # This is weird...
-      raise Puppet::Error, "Trying to update parameter '#{param}' to '#{value}' for a resource that does not exists #{@resource.class.name} #{@resource.name}: #{detail}"
-    end
-    if value == getinfo()[param.to_sym]
-      return
-    end
-
-    #self.class.validate(param, value)
-    if cmd = modifycmd({param =>value})
-      begin
-        execute(cmd)
-      rescue Puppet::ExecutionFailure  => detail
-        raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}", detail.backtrace
-      end
-    end
-
-    # Refresh de info.
-    getinfo(true)
-  end
-
-  def initialize(resource)
-    super
-    @objectinfo = nil
-    @objectosinfo = nil
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/provider/exec.rb

@@ -1,96 +0,0 @@
-require 'puppet/provider'
-require 'puppet/util/execution'
-
-class Puppet::Provider::Exec < Puppet::Provider
-  include Puppet::Util::Execution
-
-  def run(command, check = false)
-    output = nil
-    status = nil
-    dir = nil
-
-    checkexe(command)
-
-    if dir = resource[:cwd]
-      unless File.directory?(dir)
-        if check
-          dir = nil
-        else
-          self.fail "Working directory '#{dir}' does not exist"
-        end
-      end
-    end
-
-    dir ||= Dir.pwd
-
-    debug "Executing#{check ? " check": ""} '#{command}'"
-    begin
-      # Do our chdir
-      Dir.chdir(dir) do
-        environment = {}
-
-        environment[:PATH] = resource[:path].join(File::PATH_SEPARATOR) if resource[:path]
-
-        if envlist = resource[:environment]
-          envlist = [envlist] unless envlist.is_a? Array
-          envlist.each do |setting|
-            if setting =~ /^(\w+)=((.|\n)+)$/
-              env_name = $1
-              value = $2
-              if environment.include?(env_name) || environment.include?(env_name.to_sym)
-                warning "Overriding environment setting '#{env_name}' with '#{value}'"
-              end
-              environment[env_name] = value
-            else
-              warning "Cannot understand environment setting #{setting.inspect}"
-            end
-          end
-        end
-
-        # Ruby 2.1 and later interrupt execution in a way that bypasses error
-        # handling by default. Passing Timeout::Error causes an exception to be
-        # raised that can be rescued inside of the block by cleanup routines.
-        #
-        # This is backwards compatible all the way to Ruby 1.8.7.
-        Timeout::timeout(resource[:timeout], Timeout::Error) do
-          # note that we are passing "false" for the "override_locale" parameter, which ensures that the user's
-          # default/system locale will be respected.  Callers may override this behavior by setting locale-related
-          # environment variables (LANG, LC_ALL, etc.) in their 'environment' configuration.
-          output = Puppet::Util::Execution.execute(command, :failonfail => false, :combine => true,
-                                  :uid => resource[:user], :gid => resource[:group],
-                                  :override_locale => false,
-                                  :custom_environment => environment)
-        end
-        # The shell returns 127 if the command is missing.
-        if output.exitstatus == 127
-          raise ArgumentError, output
-        end
-
-      end
-    rescue Errno::ENOENT => detail
-      self.fail Puppet::Error, detail.to_s, detail
-    end
-
-    # Return output twice as processstatus was returned before, but only exitstatus was ever called.
-    # Output has the exitstatus on it so it is returned instead. This is here twice as changing this
-    #  would result in a change to the underlying API.
-    return output, output
-  end
-
-  def extractexe(command)
-    if command.is_a? Array
-      command.first
-    elsif match = /^"([^"]+)"|^'([^']+)'/.match(command)
-      # extract whichever of the two sides matched the content.
-      match[1] or match[2]
-    else
-      command.split(/ /)[0]
-    end
-  end
-
-  def validatecmd(command)
-    exe = extractexe(command)
-    # if we're not fully qualified, require a path
-    self.fail "'#{command}' is not qualified and no path was specified. Please qualify the command or specify a path." if !absolute_path?(exe) and resource[:path].nil?
-  end
-end