bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/provider/exec/posix.rb

@@ -1,48 +0,0 @@
-require 'puppet/provider/exec'
-
-Puppet::Type.type(:exec).provide :posix, :parent => Puppet::Provider::Exec do
-  has_feature :umask
-  confine :feature => :posix
-  defaultfor :feature => :posix
-
-  desc <<-EOT
-    Executes external binaries directly, without passing through a shell or
-    performing any interpolation. This is a safer and more predictable way
-    to execute most commands, but prevents the use of globbing and shell
-    built-ins (including control logic like "for" and "if" statements).
-  EOT
-
-  # Verify that we have the executable
-  def checkexe(command)
-    exe = extractexe(command)
-
-    if File.expand_path(exe) == exe
-      if !Puppet::FileSystem.exist?(exe)
-        raise ArgumentError, _("Could not find command '%{exe}'") % { exe: exe }
-      elsif !File.file?(exe)
-        raise ArgumentError, _("'%{exe}' is a %{klass}, not a file") % { exe: exe, klass: File.ftype(exe) }
-      elsif !File.executable?(exe)
-        raise ArgumentError, _("'%{exe}' is not executable") % { exe: exe }
-      end
-      return
-    end
-
-    if resource[:path]
-      Puppet::Util.withenv :PATH => resource[:path].join(File::PATH_SEPARATOR) do
-        return if which(exe)
-      end
-    end
-
-    # 'which' will only return the command if it's executable, so we can't
-    # distinguish not found from not executable
-    raise ArgumentError, _("Could not find command '%{exe}'") % { exe: exe }
-  end
-
-  def run(command, check = false)
-    if resource[:umask]
-      Puppet::Util::withumask(resource[:umask]) { super(command, check) }
-    else
-      super(command, check)
-    end
-  end
-end

data/vendored/puppet/lib/puppet/provider/exec/shell.rb

@@ -1,25 +0,0 @@
-Puppet::Type.type(:exec).provide :shell, :parent => :posix do
-  include Puppet::Util::Execution
-
-  confine :feature => :posix
-
-  desc <<-EOT
-    Passes the provided command through `/bin/sh`; only available on
-    POSIX systems. This allows the use of shell globbing and built-ins, and
-    does not require that the path to a command be fully-qualified. Although
-    this can be more convenient than the `posix` provider, it also means that
-    you need to be more careful with escaping; as ever, with great power comes
-    etc. etc.
-
-    This provider closely resembles the behavior of the `exec` type
-    in Puppet 0.25.x.
-  EOT
-
-  def run(command, check = false)
-    super(['/bin/sh', '-c', command], check)
-  end
-
-  def validatecmd(command)
-    true
-  end
-end

data/vendored/puppet/lib/puppet/provider/exec/windows.rb

@@ -1,55 +0,0 @@
-require 'puppet/provider/exec'
-
-Puppet::Type.type(:exec).provide :windows, :parent => Puppet::Provider::Exec do
-
-  confine    :operatingsystem => :windows
-  defaultfor :operatingsystem => :windows
-
-  desc <<-'EOT'
-    Execute external binaries on Windows systems. As with the `posix`
-    provider, this provider directly calls the command with the arguments
-    given, without passing it through a shell or performing any interpolation.
-    To use shell built-ins --- that is, to emulate the `shell` provider on
-    Windows --- a command must explicitly invoke the shell:
-
-        exec {'echo foo':
-          command => 'cmd.exe /c echo "foo"',
-        }
-
-    If no extension is specified for a command, Windows will use the `PATHEXT`
-    environment variable to locate the executable.
-
-    **Note on PowerShell scripts:** PowerShell's default `restricted`
-    execution policy doesn't allow it to run saved scripts. To run PowerShell
-    scripts, specify the `remotesigned` execution policy as part of the
-    command:
-
-        exec { 'test':
-          path    => 'C:/Windows/System32/WindowsPowerShell/v1.0',
-          command => 'powershell -executionpolicy remotesigned -file C:/test.ps1',
-        }
-
-  EOT
-
-  # Verify that we have the executable
-  def checkexe(command)
-    exe = extractexe(command)
-
-    if absolute_path?(exe)
-      if !Puppet::FileSystem.exist?(exe)
-        raise ArgumentError, _("Could not find command '%{exe}'") % { exe: exe }
-      elsif !File.file?(exe)
-        raise ArgumentError, _("'%{exe}' is a %{klass}, not a file") % { exe: exe, klass: File.ftype(exe) }
-      end
-      return
-    end
-
-    if resource[:path]
-      Puppet::Util.withenv( {'PATH' => resource[:path].join(File::PATH_SEPARATOR)}, :windows) do
-        return if which(exe)
-      end
-    end
-
-    raise ArgumentError, _("Could not find command '%{exe}'") % { exe: exe }
-  end
-end

data/vendored/puppet/lib/puppet/provider/file/posix.rb

@@ -1,136 +0,0 @@
-Puppet::Type.type(:file).provide :posix do
-  desc "Uses POSIX functionality to manage file ownership and permissions."
-
-  confine :feature => :posix
-  has_features :manages_symlinks
-
-  include Puppet::Util::POSIX
-  include Puppet::Util::Warnings
-
-  require 'etc'
-
-  def uid2name(id)
-    return id.to_s if id.is_a?(Symbol) or id.is_a?(String)
-    return nil if id > Puppet[:maximum_uid].to_i
-
-    begin
-      user = Etc.getpwuid(id)
-    rescue TypeError, ArgumentError
-      return nil
-    end
-
-    if user.uid == ""
-      return nil
-    else
-      return user.name
-    end
-  end
-
-  # Determine if the user is valid, and if so, return the UID
-  def name2uid(value)
-    Integer(value) rescue uid(value) || false
-  end
-
-  def gid2name(id)
-    return id.to_s if id.is_a?(Symbol) or id.is_a?(String)
-    return nil if id > Puppet[:maximum_uid].to_i
-
-    begin
-      group = Etc.getgrgid(id)
-    rescue TypeError, ArgumentError
-      return nil
-    end
-
-    if group.gid == ""
-      return nil
-    else
-      return group.name
-    end
-  end
-
-  def name2gid(value)
-    Integer(value) rescue gid(value) || false
-  end
-
-  def owner
-    unless stat = resource.stat
-      return :absent
-    end
-
-    currentvalue = stat.uid
-
-    # On OS X, files that are owned by -2 get returned as really
-    # large UIDs instead of negative ones.  This isn't a Ruby bug,
-    # it's an OS X bug, since it shows up in perl, too.
-    if currentvalue > Puppet[:maximum_uid].to_i
-      self.warning _("Apparently using negative UID (%{currentvalue}) on a platform that does not consistently handle them") % { currentvalue: currentvalue }
-      currentvalue = :silly
-    end
-
-    currentvalue
-  end
-
-  def owner=(should)
-    # Set our method appropriately, depending on links.
-    if resource[:links] == :manage
-      method = :lchown
-    else
-      method = :chown
-    end
-
-    begin
-      File.send(method, should, nil, resource[:path])
-    rescue => detail
-      raise Puppet::Error, _("Failed to set owner to '%{should}': %{detail}") % { should: should, detail: detail }, detail.backtrace
-    end
-  end
-
-  def group
-    return :absent unless stat = resource.stat
-
-    currentvalue = stat.gid
-
-    # On OS X, files that are owned by -2 get returned as really
-    # large GIDs instead of negative ones.  This isn't a Ruby bug,
-    # it's an OS X bug, since it shows up in perl, too.
-    if currentvalue > Puppet[:maximum_uid].to_i
-      self.warning _("Apparently using negative GID (%{currentvalue}) on a platform that does not consistently handle them") % { currentvalue: currentvalue }
-      currentvalue = :silly
-    end
-
-    currentvalue
-  end
-
-  def group=(should)
-    # Set our method appropriately, depending on links.
-    if resource[:links] == :manage
-      method = :lchown
-    else
-      method = :chown
-    end
-
-    begin
-      File.send(method, nil, should, resource[:path])
-    rescue => detail
-      raise Puppet::Error, _("Failed to set group to '%{should}': %{detail}") % { should: should, detail: detail }, detail.backtrace
-    end
-  end
-
-  def mode
-    if stat = resource.stat
-      return (stat.mode & 007777).to_s(8).rjust(4, '0')
-    else
-      return :absent
-    end
-  end
-
-  def mode=(value)
-    begin
-      File.chmod(value.to_i(8), resource[:path])
-    rescue => detail
-      error = Puppet::Error.new(_("failed to set mode %{mode} on %{path}: %{message}") % { mode: mode, path: resource[:path], message: detail.message })
-      error.set_backtrace detail.backtrace
-      raise error
-    end
-  end
-end

data/vendored/puppet/lib/puppet/provider/file/windows.rb

@@ -1,104 +0,0 @@
-Puppet::Type.type(:file).provide :windows do
-  desc "Uses Microsoft Windows functionality to manage file ownership and permissions."
-
-  confine :operatingsystem => :windows
-  has_feature :manages_symlinks if Puppet.features.manages_symlinks?
-
-  include Puppet::Util::Warnings
-
-  if Puppet.features.microsoft_windows?
-    require 'puppet/util/windows'
-    include Puppet::Util::Windows::Security
-  end
-
-  # Determine if the account is valid, and if so, return the UID
-  def name2id(value)
-    Puppet::Util::Windows::SID.name_to_sid(value)
-  end
-
-  # If it's a valid SID, get the name. Otherwise, it's already a name,
-  # so just return it.
-  def id2name(id)
-    if Puppet::Util::Windows::SID.valid_sid?(id)
-      Puppet::Util::Windows::SID.sid_to_name(id)
-    else
-      id
-    end
-  end
-
-  # We use users and groups interchangeably, so use the same methods for both
-  # (the type expects different methods, so we have to oblige).
-  alias :uid2name :id2name
-  alias :gid2name :id2name
-
-  alias :name2gid :name2id
-  alias :name2uid :name2id
-
-  def owner
-    return :absent unless resource.stat
-    get_owner(resource[:path])
-  end
-
-  def owner=(should)
-    begin
-      set_owner(should, resolved_path)
-    rescue => detail
-      raise Puppet::Error, _("Failed to set owner to '%{should}': %{detail}") % { should: should, detail: detail }, detail.backtrace
-    end
-  end
-
-  def group
-    return :absent unless resource.stat
-    get_group(resource[:path])
-  end
-
-  def group=(should)
-    begin
-      set_group(should, resolved_path)
-    rescue => detail
-      raise Puppet::Error, _("Failed to set group to '%{should}': %{detail}") % { should: should, detail: detail }, detail.backtrace
-    end
-  end
-
-  def mode
-    if resource.stat
-      mode = get_mode(resource[:path])
-      mode ? mode.to_s(8).rjust(4, '0') : :absent
-    else
-      :absent
-    end
-  end
-
-  def mode=(value)
-    begin
-      set_mode(value.to_i(8), resource[:path])
-    rescue => detail
-      error = Puppet::Error.new(_("failed to set mode %{mode} on %{path}: %{message}") % { mode: mode, path: resource[:path], message: detail.message })
-      error.set_backtrace detail.backtrace
-      raise error
-    end
-    :file_changed
-  end
-
-  def validate
-    if [:owner, :group, :mode].any?{|p| resource[p]} and !supports_acl?(resource[:path])
-      resource.fail(_("Can only manage owner, group, and mode on filesystems that support Windows ACLs, such as NTFS"))
-    end
-  end
-
-  attr_reader :file
-  private
-  def file
-    @file ||= Puppet::FileSystem.pathname(resource[:path])
-  end
-
-  def resolved_path
-    path = file()
-    # under POSIX, :manage means use lchown - i.e. operate on the link
-    return path.to_s if resource[:links] == :manage
-
-    # otherwise, use chown -- that will resolve the link IFF it is a link
-    # otherwise it will operate on the path
-    Puppet::FileSystem.symlink?(path) ? Puppet::FileSystem.readlink(path) : path.to_s
-  end
-end

data/vendored/puppet/lib/puppet/provider/group/aix.rb

@@ -1,143 +0,0 @@
-#
-# Group Puppet provider for AIX. It uses standard commands to manage groups:
-#  mkgroup, rmgroup, lsgroup, chgroup
-#
-# Author::    Hector Rivas Gandara <keymon@gmail.com>
-#
-require 'puppet/provider/aixobject'
-
-Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject do
-  desc "Group management for AIX."
-
-  # This will the default provider for this platform
-  defaultfor :operatingsystem => :aix
-  confine :operatingsystem => :aix
-
-  # Provider features
-  has_features :manages_aix_lam
-  has_features :manages_members
-
-  # Commands that manage the element
-  commands :list      => "/usr/sbin/lsgroup"
-  commands :add       => "/usr/bin/mkgroup"
-  commands :delete    => "/usr/sbin/rmgroup"
-  commands :modify    => "/usr/bin/chgroup"
-
-  # Group attributes to ignore
-  def self.attribute_ignore
-    []
-  end
-
-  # AIX attributes to properties mapping.
-  #
-  # Valid attributes to be managed by this provider.
-  # It is a list with of hash
-  #  :aix_attr      AIX command attribute name
-  #  :puppet_prop   Puppet property name
-  #  :to            Method to adapt puppet property to aix command value. Optional.
-  #  :from          Method to adapt aix command value to puppet property. Optional
-  self.attribute_mapping = [
-    #:name => :name,
-    {:aix_attr => :id,       :puppet_prop => :gid },
-    {:aix_attr => :users,    :puppet_prop => :members,
-      :from => :users_from_attr},
-    {:aix_attr => :attributes, :puppet_prop => :attributes},
-  ]
-
-  #--------------
-  # Command definition
-
-  # Return the IA module arguments based on the resource param ia_load_module
-  def get_ia_module_args
-    if @resource[:ia_load_module]
-      ["-R", @resource[:ia_load_module].to_s]
-    else
-      []
-    end
-  end
-
-  def lscmd(value=@resource[:name])
-    [self.class.command(:list)] +
-      self.get_ia_module_args +
-      [ value]
-  end
-
-  def lsallcmd()
-    lscmd("ALL")
-  end
-
-  def addcmd(extra_attrs = [])
-    # Here we use the @resource.to_hash to get the list of provided parameters
-    # Puppet does not call to self.<parameter>= method if it does not exists.
-    #
-    # It gets an extra list of arguments to add to the user.
-    [self.class.command(:add) ] +
-      self.get_ia_module_args +
-      self.hash2args(@resource.to_hash) +
-      extra_attrs + [@resource[:name]]
-  end
-
-  def modifycmd(hash = property_hash)
-    args = self.hash2args(hash)
-    return nil if args.empty?
-
-    [self.class.command(:modify)] +
-      self.get_ia_module_args +
-      args + [@resource[:name]]
-  end
-
-  def deletecmd
-    [self.class.command(:delete)] +
-      self.get_ia_module_args +
-      [@resource[:name]]
-  end
-
-
-  #--------------
-  # Overwrite get_arguments to add the attributes' arguments
-  def get_arguments(key, value, mapping, objectinfo)
-    # In the case of attributes, return a list of key=value
-    if key == :attributes
-      unless value and value.is_a? Hash
-        raise Puppet::Error, _("Attributes must be a list of pairs key=value on %{resource}[%{name}]") %
-            { resource: @resource.class.name, name: @resource.name }
-      end
-      return value.select { |k,v| true }.map { |pair| pair.join("=") }
-    end
-    super(key, value, mapping, objectinfo)
-  end
-
-  def filter_attributes(hash)
-    # Return only not managed attributes.
-    hash.select {
-        |k,v| !self.class.attribute_mapping_from.include?(k) and
-                !self.class.attribute_ignore.include?(k)
-      }.inject({}) {
-        |h, array| h[array[0]] = array[1]; h
-      }
-  end
-
-  def attributes
-    filter_attributes(getosinfo(false))
-  end
-
-  def attributes=(attr_hash)
-    #self.class.validate(param, value)
-    param = :attributes
-    cmd = modifycmd({param => filter_attributes(attr_hash)})
-    if cmd
-      begin
-        execute(cmd)
-      rescue Puppet::ExecutionFailure  => detail
-        raise Puppet::Error, _("Could not set %{param} on %{resource}[%{name}]: %{detail}") % { param: param, resource: @resource.class.name, name: @resource.name, detail: detail }, detail.backtrace
-      end
-    end
-  end
-
-  # Force convert users it a list.
-  def users_from_attr(value)
-    (value.is_a? String) ? value.split(',') : value
-  end
-
-
-end