puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/util/network_device/transport/ssh.rb

@@ -0,0 +1,121 @@
+
+require 'puppet/util/network_device'
+require 'puppet/util/network_device/transport'
+require 'puppet/util/network_device/transport/base'
+
+# This is an adaptation/simplification of gem net-ssh-telnet, which aims to have
+# a sane interface to Net::SSH. Credits goes to net-ssh-telnet authors
+class Puppet::Util::NetworkDevice::Transport::Ssh < Puppet::Util::NetworkDevice::Transport::Base
+
+  attr_accessor :buf, :ssh, :channel, :verbose
+
+  def initialize
+    super
+    unless Puppet.features.ssh?
+      raise 'Connecting with ssh to a network device requires the \'net/ssh\' ruby library'
+    end
+  end
+
+  def handles_login?
+    true
+  end
+
+  def eof?
+    !! @eof
+  end
+
+  def connect(&block)
+    @output = []
+    @channel_data = ""
+
+    begin
+      Puppet.debug("connecting to #{host} as #{user}")
+      @ssh = Net::SSH.start(host, user, :port => port, :password => password, :timeout => timeout)
+    rescue TimeoutError
+      raise TimeoutError, "timed out while opening an ssh connection to the host"
+    rescue Net::SSH::AuthenticationFailed
+      raise Puppet::Error, "SSH authentication failure connecting to #{host} as #{user}"
+    rescue Net::SSH::Exception => detail
+      raise Puppet::Error, "SSH connection failure to #{host}"
+    end
+
+    @buf = ""
+    @eof = false
+    @channel = nil
+    @ssh.open_channel do |channel|
+      channel.request_pty { |ch,success| raise "failed to open pty" unless success }
+
+      channel.send_channel_request("shell") do |ch, success|
+        raise "failed to open ssh shell channel" unless success
+
+        ch.on_data { |ch,data| @buf << data }
+        ch.on_extended_data { |ch,type,data|  @buf << data if type == 1 }
+        ch.on_close { @eof = true }
+
+        @channel = ch
+        expect(default_prompt, &block)
+        # this is a little bit unorthodox, we're trying to escape
+        # the ssh loop there while still having the ssh connection up
+        # otherwise we wouldn't be able to return ssh stdout/stderr
+        # for a given call of command.
+        return
+      end
+
+    end
+    @ssh.loop
+
+  end
+
+  def close
+    @channel.close if @channel
+    @channel = nil
+    @ssh.close if @ssh
+  end
+
+  def expect(prompt)
+    line = ''
+    sock = @ssh.transport.socket
+
+    while not @eof
+      break if line =~ prompt and @buf == ''
+      break if sock.closed?
+
+      IO::select([sock], [sock], nil, nil)
+
+      process_ssh
+
+      # at this point we have accumulated some data in @buf
+      # or the channel has been closed
+      if @buf != ""
+        line += @buf.gsub(/\r\n/no, "\n")
+        @buf = ''
+        yield line if block_given?
+      elsif @eof
+        # channel has been closed
+        break if line =~ prompt
+        if line == ''
+          line = nil
+          yield nil if block_given?
+        end
+        break
+      end
+    end
+    Puppet.debug("ssh: expected #{line}") if @verbose
+    line
+  end
+
+  def send(line)
+    Puppet.debug("ssh: send #{line}") if @verbose
+    @channel.send_data(line + "\n")
+  end
+
+  def process_ssh
+    while @buf == "" and not eof?
+      begin
+        @channel.connection.process(0.1)
+      rescue IOError
+        @eof = true
+      end
+    end
+  end
+end

data/lib/vendor/puppet/util/network_device/transport/telnet.rb

@@ -0,0 +1,42 @@
+require 'puppet/util/network_device'
+require 'puppet/util/network_device/transport'
+require 'puppet/util/network_device/transport/base'
+require 'net/telnet'
+
+class Puppet::Util::NetworkDevice::Transport::Telnet < Puppet::Util::NetworkDevice::Transport::Base
+    def initialize
+      super
+    end
+
+    def handles_login?
+      false
+    end
+
+    def connect
+      @telnet = Net::Telnet::new("Host" => host, "Port" => port || 23,
+                                 "Timeout" => 10,
+                                 "Prompt" => default_prompt)
+    end
+
+    def close
+      @telnet.close if @telnet
+      @telnet = nil
+    end
+
+    def expect(prompt)
+      @telnet.waitfor(prompt) do |out|
+        yield out if block_given?
+      end
+    end
+
+    def command(cmd, options = {})
+      send(cmd)
+      expect(options[:prompt] || default_prompt) do |output|
+        yield output if block_given?
+      end
+    end
+
+    def send(line)
+      @telnet.puts(line)
+    end
+end

data/lib/vendor/puppet/util/network_device/transport.rb

@@ -0,0 +1,3 @@
+# stub
+module Puppet::Util::NetworkDevice::Transport
+end

data/lib/vendor/puppet/util/network_device.rb

@@ -0,0 +1,17 @@
+class Puppet::Util::NetworkDevice
+  class << self
+    attr_reader :current
+  end
+
+  def self.init(device)
+    require "puppet/util/network_device/#{device.provider}/device"
+    @current = Puppet::Util::NetworkDevice.const_get(device.provider.capitalize).const_get(:Device).new(device.url)
+  rescue => detail
+    raise "Can't load #{device.provider} for #{device.name}: #{detail}"
+  end
+
+  # Should only be used in tests
+  def self.teardown
+    @current = nil
+  end
+end

data/lib/vendor/puppet/util/package.rb

@@ -0,0 +1,31 @@
+module Puppet::Util::Package
+  def versioncmp(version_a, version_b)
+    vre = /[-.]|\d+|[^-.\d]+/
+    ax = version_a.scan(vre)
+    bx = version_b.scan(vre)
+
+    while (ax.length>0 && bx.length>0)
+      a = ax.shift
+      b = bx.shift
+
+      if( a == b )                 then next
+      elsif (a == '-' && b == '-') then next
+      elsif (a == '-')             then return -1
+      elsif (b == '-')             then return 1
+      elsif (a == '.' && b == '.') then next
+      elsif (a == '.' )            then return -1
+      elsif (b == '.' )            then return 1
+      elsif (a =~ /^\d+$/ && b =~ /^\d+$/) then
+        if( a =~ /^0/ or b =~ /^0/ ) then
+          return a.to_s.upcase <=> b.to_s.upcase
+        end
+        return a.to_i <=> b.to_i
+      else
+        return a.upcase <=> b.upcase
+      end
+    end
+    version_a <=> version_b;
+  end
+
+  module_function :versioncmp
+end

data/lib/vendor/puppet/util/pidlock.rb

@@ -0,0 +1,117 @@
+require 'fileutils'
+
+class Puppet::Util::Pidlock
+  attr_reader :lockfile
+
+  def initialize(lockfile)
+    @lockfile = lockfile
+  end
+
+  def locked?
+    clear_if_stale
+    return true if File.exists? @lockfile
+
+    # HACK!  There was a temporary change to the lockfile behavior introduced in 2.7.10 and 2.7.11, and reverted
+    # in 2.7.12.  We need to pull some chicanery to be backwards-compatible with those versions.  For more info,
+    # see the comments on the method... and this hack should be removed for the 3.x series.
+    handle_2_7_10_disabled_lockfile
+    File.exists? @lockfile
+  end
+
+  def mine?
+    Process.pid == lock_pid
+  end
+
+  def anonymous?
+    return false unless File.exists?(@lockfile)
+    File.read(@lockfile) == ""
+  end
+
+  def lock(opts = {})
+    opts = {:anonymous => false}.merge(opts)
+
+    if locked?
+      mine?
+    else
+      if opts[:anonymous]
+        File.open(@lockfile, 'w') { |fd| true }
+      else
+        File.open(@lockfile, "w") { |fd| fd.write(Process.pid) }
+      end
+      true
+    end
+  end
+
+  def unlock(opts = {})
+    return false unless locked?
+
+    opts = {:anonymous => false}.merge(opts)
+
+    if mine? or (opts[:anonymous] and anonymous?)
+      File.unlink(@lockfile)
+      true
+    else
+      false
+    end
+  end
+
+  private
+  def lock_pid
+    if File.exists? @lockfile
+      File.read(@lockfile).to_i
+    else
+      nil
+    end
+  end
+
+  def clear_if_stale
+    return if lock_pid.nil?
+
+    errors = [Errno::ESRCH]
+    # Process::Error can only happen, and is only defined, on Windows
+    errors << Process::Error if defined? Process::Error
+
+    begin
+      Process.kill(0, lock_pid)
+    rescue *errors
+      File.unlink(@lockfile)
+    end
+  end
+
+
+  ######################################################################################
+  # Backwards compatibility hack
+  ######################################################################################
+  # A change to lockfile behavior was introduced in 2.7.10 and 2.7.11; basically,
+  # instead of using a single lockfile to indicate both administrative disabling of
+  # the agent *and* the case where an agent run is already in progress, we started using
+  # two separate lockfiles: the 'normal' one for the "run in progress" case, and a
+  # separate one with a ".disabled" extension to indicate administrative disabling.
+  #
+  # This was determined to cause incompatibilities with mcollective, so the behavior
+  # was reverted for 2.7.12.  Unfortunately this leaves the possibility that someone
+  # may have run "agent --disable" to administratively disable a 2.7.10 or 2.7.11
+  # agent, and then upgraded to a newer version.  This method exists only to
+  # provide backwards compatibility.  Basically, it just recognizes the 2.7.10/2.7.11
+  # ".disabled" lock file, warns, and cleans it up.
+  #
+  # This should be removed for the 3.x series.
+  #
+  # For more information, please see tickets #12844, #3757, #4836, and #11057
+  #
+  # -- cprice 2012-03-01
+  #
+  def handle_2_7_10_disabled_lockfile
+    disabled_lockfile_path = @lockfile + ".disabled"
+    if (File.exists?(disabled_lockfile_path))
+      Puppet.warning("Found special lockfile '#{disabled_lockfile_path}'; this file was " +
+          "generated by a call to 'puppet agent --disable' in puppet 2.7.10 or 2.7.11. " +
+          "The expected lockfile path is '#{@lockfile}'; renaming the lock file.")
+      File.rename(disabled_lockfile_path, @lockfile)
+    end
+  end
+  private :handle_2_7_10_disabled_lockfile
+  ######################################################################################
+  # End backwards compatibility hack
+  ######################################################################################
+end

data/lib/vendor/puppet/util/platform.rb

@@ -0,0 +1,22 @@
+module Puppet
+  module Util
+    module Platform
+      def windows?
+        # Ruby only sets File::ALT_SEPARATOR on Windows and the Ruby standard
+        # library uses that to test what platform it's on. In some places we
+        # would use Puppet.features.microsoft_windows?, but this method can be
+        # used to determine the behavior of the underlying system without
+        # requiring features to be initialized and without side effect.
+        !!File::ALT_SEPARATOR
+      end
+      module_function :windows?
+
+      def default_paths
+        return [] if windows?
+
+        %w{/usr/sbin /sbin}
+      end
+      module_function :default_paths
+    end
+  end
+end

data/lib/vendor/puppet/util/plugins.rb

@@ -0,0 +1,82 @@
+#
+# This system manages an extensible set of metadata about plugins which it
+#   collects by searching for files named "plugin_init.rb" in a series of
+#   directories.  Initially, these are simply the $LOAD_PATH.
+#
+# The contents of each file found is executed in the context of a Puppet::Plugins
+#    object (and thus scoped).  An example file might contain:
+#
+# -------------------------------------------------------
+#      @name = "Greet the CA"
+#
+#      @description = %q{
+#        This plugin causes a friendly greeting to print out on a master
+#        that is operating as the CA, after it has been set up but before
+#        it does anything.
+#      }
+#
+#      def after_application_setup(options)
+#        if options[:application_object].is_a?(Puppet::Application::Master) && Puppet::SSL::CertificateAuthority.ca?
+#          puts "Hey, this is the CA!"
+#        end
+#      end
+# -------------------------------------------------------
+#
+# Note that the instance variables are local to this Puppet::Plugin (and so may be used
+#   for maintaining state, etc.) but the plugin system does not provide any thread safety
+#   assurances, so they may not be adequate for some complex use cases.
+#
+#
+module Puppet
+  class Plugins
+    Paths  = [] # Where we might find plugin initialization code
+    Loaded = [] # Code we have found (one-to-one with paths once searched)
+    #
+    # Return all the Puppet::Plugins we know about, searching any new paths
+    #
+    def self.known
+      Paths[Loaded.length...Paths.length].each { |path|
+        file = File.join(path,'plugin_init.rb')
+        Loaded << (File.exist?(file) && new(file))
+      }
+      Loaded.compact
+    end
+    #
+    # Add more places to look for plugins without adding duplicates or changing the
+    #   order of ones we've already found.
+    #   
+    def self.look_in(*paths)
+      Paths.replace Paths | paths.flatten.collect { |path| File.expand_path(path) }
+    end
+    #
+    # Initially just look in $LOAD_PATH
+    #
+    look_in $LOAD_PATH
+    #
+    # Calling methods (hooks) on the class calls the method of the same name on 
+    #   all plugins that use that hook, passing in the same arguments to each
+    #   and returning an array containing the results returned by each plugin as
+    #   an array of [plugin_name,result] pairs.
+    # 
+    def self.method_missing(hook,*args,&block)
+      known.
+        select  { |p| p.respond_to? hook }.
+        collect { |p| [p.name,p.send(hook,*args,&block)] }
+    end
+    #
+    # 
+    #
+    attr_reader :path,:name
+    def initialize(path)
+      @name = @path = path
+      class << self
+        private
+        def define_hooks
+          eval File.read(path),nil,path,1
+        end
+      end
+      define_hooks
+    end
+  end
+end
+

data/lib/vendor/puppet/util/posix.rb

@@ -0,0 +1,137 @@
+# Utility methods for interacting with POSIX objects; mostly user and group
+module Puppet::Util::POSIX
+
+  # Retrieve a field from a POSIX Etc object.  The id can be either an integer
+  # or a name.  This only works for users and groups.  It's also broken on
+  # some platforms, unfortunately, which is why we fall back to the other
+  # method search_posix_field in the gid and uid methods if a sanity check
+  # fails
+  def get_posix_field(space, field, id)
+    raise Puppet::DevError, "Did not get id from caller" unless id
+
+    if id.is_a?(Integer)
+      if id > Puppet[:maximum_uid].to_i
+        Puppet.err "Tried to get #{field} field for silly id #{id}"
+        return nil
+      end
+      method = methodbyid(space)
+    else
+      method = methodbyname(space)
+    end
+
+    begin
+      return Etc.send(method, id).send(field)
+    rescue ArgumentError => detail
+      # ignore it; we couldn't find the object
+      return nil
+    end
+  end
+
+  # A degenerate method of retrieving name/id mappings.  The job of this method is
+  # to retrieve all objects of a certain type, search for a specific entry
+  # and then return a given field from that entry.
+  def search_posix_field(type, field, id)
+    idmethod = idfield(type)
+    integer = false
+    if id.is_a?(Integer)
+      integer = true
+      if id > Puppet[:maximum_uid].to_i
+        Puppet.err "Tried to get #{field} field for silly id #{id}"
+        return nil
+      end
+    end
+
+    Etc.send(type) do |object|
+      if integer and object.send(idmethod) == id
+        return object.send(field)
+      elsif object.name == id
+        return object.send(field)
+      end
+    end
+
+    # Apparently the group/passwd methods need to get reset; if we skip
+    # this call, then new users aren't found.
+    case type
+    when :passwd; Etc.send(:endpwent)
+    when :group; Etc.send(:endgrent)
+    end
+    nil
+  end
+
+  # Determine what the field name is for users and groups.
+  def idfield(space)
+    case space.intern
+    when :gr, :group; return :gid
+    when :pw, :user, :passwd; return :uid
+    else
+      raise ArgumentError.new("Can only handle users and groups")
+    end
+  end
+
+  # Determine what the method is to get users and groups by id
+  def methodbyid(space)
+    case space.intern
+    when :gr, :group; return :getgrgid
+    when :pw, :user, :passwd; return :getpwuid
+    else
+      raise ArgumentError.new("Can only handle users and groups")
+    end
+  end
+
+  # Determine what the method is to get users and groups by name
+  def methodbyname(space)
+    case space.intern
+    when :gr, :group; return :getgrnam
+    when :pw, :user, :passwd; return :getpwnam
+    else
+      raise ArgumentError.new("Can only handle users and groups")
+    end
+  end
+
+  # Get the GID of a given group, provided either a GID or a name
+  def gid(group)
+    begin
+      group = Integer(group)
+    rescue ArgumentError
+      # pass
+    end
+    if group.is_a?(Integer)
+      return nil unless name = get_posix_field(:group, :name, group)
+      gid = get_posix_field(:group, :gid, name)
+      check_value = gid
+    else
+      return nil unless gid = get_posix_field(:group, :gid, group)
+      name = get_posix_field(:group, :name, gid)
+      check_value = name
+    end
+    if check_value != group
+      return search_posix_field(:group, :gid, group)
+    else
+      return gid
+    end
+  end
+
+  # Get the UID of a given user, whether a UID or name is provided
+  def uid(user)
+    begin
+      user = Integer(user)
+    rescue ArgumentError
+      # pass
+    end
+    if user.is_a?(Integer)
+      return nil unless name = get_posix_field(:passwd, :name, user)
+      uid = get_posix_field(:passwd, :uid, name)
+      check_value = uid
+    else
+      return nil unless uid = get_posix_field(:passwd, :uid, user)
+      name = get_posix_field(:passwd, :name, uid)
+      check_value = name
+    end
+    if check_value != user
+      return search_posix_field(:passwd, :uid, user)
+    else
+      return uid
+    end
+  end
+end
+