puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/provider/service/upstart.rb

@@ -0,0 +1,347 @@
+require 'semver'
+
+Puppet::Type.type(:service).provide :upstart, :parent => :debian do
+  START_ON = /^\s*start\s+on/
+  COMMENTED_START_ON = /^\s*#+\s*start\s+on/
+  MANUAL   = /^\s*manual\s*$/
+
+  desc "Ubuntu service management with `upstart`.
+
+  This provider manages `upstart` jobs, which have replaced `initd` services
+  on Ubuntu. For `upstart` documentation, see <http://upstart.ubuntu.com/>.
+  "
+  # confine to :ubuntu for now because I haven't tested on other platforms
+  confine :operatingsystem => :ubuntu #[:ubuntu, :fedora, :debian]
+
+  defaultfor :operatingsystem => :ubuntu
+
+  commands :start   => "/sbin/start",
+           :stop    => "/sbin/stop",
+           :restart => "/sbin/restart",
+           :status_exec  => "/sbin/status",
+           :initctl => "/sbin/initctl"
+
+  # upstart developer haven't implemented initctl enable/disable yet:
+  # http://www.linuxplanet.com/linuxplanet/tutorials/7033/2/
+  has_feature :enableable
+
+  # 'wait-for-state' is excluded from instances here because it takes
+  # parameters that have unclear meaning. It looks like 'wait-for-state' is
+  # mainly used internally for other upstart services as a 'sleep until something happens'
+  # (http://lists.debian.org/debian-devel/2012/02/msg01139.html). There is an open launchpad bug
+  # (https://bugs.launchpad.net/ubuntu/+source/upstart/+bug/962047) that may
+  # eventually explain how to use this service or perhaps why it should remain
+  # excluded. When that bug is adddressed this should be reexamined.
+  def self.instances
+    self.get_services(['wait-for-state'])
+  end
+
+  def self.get_services(exclude=[])
+    instances = []
+    execpipe("#{command(:initctl)} list") { |process|
+      process.each_line { |line|
+        # needs special handling of services such as network-interface:
+        # initctl list:
+        # network-interface (lo) start/running
+        # network-interface (eth0) start/running
+        # network-interface-security start/running
+        name = \
+          if matcher = line.match(/^(network-interface)\s\(([^\)]+)\)/)
+            "#{matcher[1]} INTERFACE=#{matcher[2]}"
+          elsif matcher = line.match(/^(network-interface-security)\s\(([^\)]+)\)/)
+            "#{matcher[1]} JOB=#{matcher[2]}"
+          else
+            line.split.first
+          end
+        instances << new(:name => name)
+      }
+    }
+    instances.reject { |instance| exclude.include?(instance.name) }
+  end
+
+  def self.defpath
+    ["/etc/init", "/etc/init.d"]
+  end
+
+  def upstart_version
+    @@upstart_version ||= initctl("--version").match(/initctl \(upstart ([^\)]*)\)/)[1]
+  end
+
+  # Where is our override script?
+  def overscript
+    @overscript ||= initscript.gsub(/\.conf$/,".override")
+  end
+
+  def search(name)
+    # Search prefers .conf as that is what upstart uses
+    [".conf", "", ".sh"].each do |suffix|
+      paths.each do |path|
+        service_name = name.match(/^(\S+)/)[1]
+        fqname = File.join(path, service_name + suffix)
+        if File.exists?(fqname)
+          return fqname
+        end
+
+        self.debug("Could not find #{name}#{suffix} in #{path}")
+      end
+    end
+
+    raise Puppet::Error, "Could not find init script or upstart conf file for '#{name}'"
+  end
+
+  def enabled?
+    return super if not is_upstart?
+
+    script_contents = read_script_from(initscript)
+    if version_is_pre_0_6_7
+      enabled_pre_0_6_7?(script_contents)
+    elsif version_is_pre_0_9_0
+      enabled_pre_0_9_0?(script_contents)
+    elsif version_is_post_0_9_0
+      enabled_post_0_9_0?(script_contents, read_override_file)
+    end
+  end
+
+  def enable
+    return super if not is_upstart?
+
+    script_text = read_script_from(initscript)
+    if version_is_pre_0_9_0
+      enable_pre_0_9_0(script_text)
+    else
+      enable_post_0_9_0(script_text, read_override_file)
+    end
+  end
+
+  def disable
+    return super if not is_upstart?
+
+    script_text = read_script_from(initscript)
+    if version_is_pre_0_6_7
+      disable_pre_0_6_7(script_text)
+    elsif version_is_pre_0_9_0
+      disable_pre_0_9_0(script_text)
+    elsif version_is_post_0_9_0
+      disable_post_0_9_0(read_override_file)
+    end
+  end
+
+  def startcmd
+    is_upstart? ? [command(:start), @resource[:name]] : super
+  end
+
+  def stopcmd
+    is_upstart? ? [command(:stop),  @resource[:name]] : super
+  end
+
+  def restartcmd
+    is_upstart? ? (@resource[:hasrestart] == :true) && [command(:restart), @resource[:name]] : super
+  end
+
+  def statuscmd
+    is_upstart? ? nil : super #this is because upstart is broken with its return codes
+  end
+
+  def status
+    return super if not is_upstart?
+
+    output = status_exec(@resource[:name].split)
+    if output =~ /start\//
+      return :running
+    else
+      return :stopped
+    end
+  end
+
+private
+  def is_upstart?(script = initscript)
+    File.exists?(script) && script.match(/\/etc\/init\/\S+\.conf/)
+  end
+
+  def version_is_pre_0_6_7
+    Puppet::Util::Package.versioncmp(upstart_version, "0.6.7") == -1
+  end
+
+  def version_is_pre_0_9_0
+    Puppet::Util::Package.versioncmp(upstart_version, "0.9.0") == -1
+  end
+
+  def version_is_post_0_9_0
+    Puppet::Util::Package.versioncmp(upstart_version, "0.9.0") >= 0
+  end
+
+  def enabled_pre_0_6_7?(script_text)
+    # Upstart version < 0.6.7 means no manual stanza.
+    if script_text.match(START_ON)
+      return :true
+    else
+      return :false
+    end
+  end
+
+  def enabled_pre_0_9_0?(script_text)
+    # Upstart version < 0.9.0 means no override files
+    # So we check to see if an uncommented start on or manual stanza is the last one in the file
+    # The last one in the file wins.
+    enabled = :false
+    script_text.each do |line|
+      if line.match(START_ON)
+        enabled = :true
+      elsif line.match(MANUAL)
+        enabled = :false
+      end
+    end
+    enabled
+  end
+
+  def enabled_post_0_9_0?(script_text, over_text)
+    # This version has manual stanzas and override files
+    # So we check to see if an uncommented start on or manual stanza is the last one in the
+    # conf file and any override files. The last one in the file wins.
+    enabled = :false
+
+    script_text.each do |line|
+      if line.match(START_ON)
+        enabled = :true
+      elsif line.match(MANUAL)
+        enabled = :false
+      end
+    end
+    over_text.each do |line|
+      if line.match(START_ON)
+        enabled = :true
+      elsif line.match(MANUAL)
+        enabled = :false
+      end
+    end if over_text
+    enabled
+  end
+
+  def enable_pre_0_9_0(text)
+    # We also need to remove any manual stanzas to ensure that it is enabled
+    text = remove_manual_from(text)
+
+    if enabled_pre_0_9_0?(text) == :false
+      enabled_script =
+        if text.match(COMMENTED_START_ON)
+          uncomment_start_block_in(text)
+        else
+          add_default_start_to(text)
+        end
+    else
+      enabled_script = text
+    end
+
+    write_script_to(initscript, enabled_script)
+  end
+
+  def enable_post_0_9_0(script_text, over_text)
+    over_text = remove_manual_from(over_text)
+
+    if enabled_post_0_9_0?(script_text, over_text) == :false
+      if script_text.match(START_ON)
+        over_text << extract_start_on_block_from(script_text)
+      else
+        over_text << "\nstart on runlevel [2,3,4,5]"
+      end
+    end
+
+    write_script_to(overscript, over_text)
+  end
+
+  def disable_pre_0_6_7(script_text)
+    disabled_script = comment_start_block_in(script_text)
+    write_script_to(initscript, disabled_script)
+  end
+
+  def disable_pre_0_9_0(script_text)
+    write_script_to(initscript, ensure_disabled_with_manual(script_text))
+  end
+
+  def disable_post_0_9_0(over_text)
+    write_script_to(overscript, ensure_disabled_with_manual(over_text))
+  end
+
+  def read_override_file
+    if File.exists?(overscript)
+      read_script_from(overscript)
+    else
+      ""
+    end
+  end
+
+  def uncomment(line)
+    line.gsub(/^(\s*)#+/, '\1')
+  end
+
+  def remove_trailing_comments_from_commented_line_of(line)
+    line.gsub(/^(\s*#+\s*[^#]*).*/, '\1')
+  end
+
+  def remove_trailing_comments_from(line)
+    line.gsub(/^(\s*[^#]*).*/, '\1')
+  end
+
+  def unbalanced_parens_on(line)
+    line.count('(') - line.count(')')
+  end
+
+  def remove_manual_from(text)
+    text.gsub(MANUAL, "")
+  end
+
+  def comment_start_block_in(text)
+    parens = 0
+    text.map do |line|
+      if line.match(START_ON) || parens > 0
+        # If there are more opening parens than closing parens, we need to comment out a multiline 'start on' stanza
+        parens += unbalanced_parens_on(remove_trailing_comments_from(line))
+        "#" + line
+      else
+        line
+      end
+    end.join('')
+  end
+
+  def uncomment_start_block_in(text)
+    parens = 0
+    text.map do |line|
+      if line.match(COMMENTED_START_ON) || parens > 0
+        parens += unbalanced_parens_on(remove_trailing_comments_from_commented_line_of(line))
+        uncomment(line)
+      else
+        line
+      end
+    end.join('')
+  end
+
+  def extract_start_on_block_from(text)
+    parens = 0
+    text.map do |line|
+      if line.match(START_ON) || parens > 0
+        parens += unbalanced_parens_on(remove_trailing_comments_from(line))
+        line
+      end
+    end.join('')
+  end
+
+  def add_default_start_to(text)
+    text + "\nstart on runlevel [2,3,4,5]"
+  end
+
+  def ensure_disabled_with_manual(text)
+    remove_manual_from(text) + "\nmanual"
+  end
+
+  def read_script_from(filename)
+    File.open(filename) do |file|
+      file.read
+    end
+  end
+
+  def write_script_to(file, text)
+    Puppet::Util.replace_file(file, 0644) do |file|
+      file.write(text)
+    end
+  end
+end

data/lib/vendor/puppet/provider/service/windows.rb

@@ -0,0 +1,106 @@
+# Windows Service Control Manager (SCM) provider
+
+Puppet::Type.type(:service).provide :windows, :parent => :service do
+
+  desc <<-EOT
+    Support for Windows Service Control Manager (SCM). This provider can
+    start, stop, enable, and disable services, and the SCM provides working
+    status methods for all services.
+
+    Control of service groups (dependencies) is not yet supported, nor is running
+    services as a specific user.
+  EOT
+
+  defaultfor :operatingsystem => :windows
+  confine    :operatingsystem => :windows
+
+  has_feature :refreshable
+
+  commands :net => 'net.exe'
+
+  def enable
+    w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_AUTO_START )
+    raise Puppet::Error.new("Win32 service enable of #{@resource[:name]} failed" ) if( w32ss.nil? )
+  rescue Win32::Service::Error => detail
+    raise Puppet::Error.new("Cannot enable #{@resource[:name]}, error was: #{detail}" )
+  end
+
+  def disable
+    w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_DISABLED )
+    raise Puppet::Error.new("Win32 service disable of #{@resource[:name]} failed" ) if( w32ss.nil? )
+  rescue Win32::Service::Error => detail
+    raise Puppet::Error.new("Cannot disable #{@resource[:name]}, error was: #{detail}" )
+  end
+
+  def manual_start
+    w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_DEMAND_START )
+    raise Puppet::Error.new("Win32 service manual enable of #{@resource[:name]} failed" ) if( w32ss.nil? )
+  rescue Win32::Service::Error => detail
+    raise Puppet::Error.new("Cannot enable #{@resource[:name]} for manual start, error was: #{detail}" )
+  end
+
+  def enabled?
+    w32ss = Win32::Service.config_info( @resource[:name] )
+    raise Puppet::Error.new("Win32 service query of #{@resource[:name]} failed" ) unless( !w32ss.nil? && w32ss.instance_of?( Struct::ServiceConfigInfo ) )
+    debug("Service #{@resource[:name]} start type is #{w32ss.start_type}")
+    case w32ss.start_type
+      when Win32::Service.get_start_type(Win32::Service::SERVICE_AUTO_START),
+           Win32::Service.get_start_type(Win32::Service::SERVICE_BOOT_START),
+           Win32::Service.get_start_type(Win32::Service::SERVICE_SYSTEM_START)
+        :true
+      when Win32::Service.get_start_type(Win32::Service::SERVICE_DEMAND_START)
+        :manual
+      when Win32::Service.get_start_type(Win32::Service::SERVICE_DISABLED)
+        :false
+      else
+        raise Puppet::Error.new("Unknown start type: #{w32ss.start_type}")
+    end
+  rescue Win32::Service::Error => detail
+    raise Puppet::Error.new("Cannot get start type for #{@resource[:name]}, error was: #{detail}" )
+  end
+
+  def start
+    if enabled? == :false
+      # If disabled and not managing enable, respect disabled and fail.
+      if @resource[:enable].nil?
+        raise Puppet::Error, "Will not start disabled service #{@resource[:name]} without managing enable. Specify 'enable => false' to override."
+      # Otherwise start. If enable => false, we will later sync enable and
+      # disable the service again.
+      elsif @resource[:enable] == :true
+        enable
+      else
+        manual_start
+      end
+    end
+
+    net(:start, @resource[:name])
+  rescue Puppet::ExecutionFailure => detail
+    raise Puppet::Error.new("Cannot start #{@resource[:name]}, error was: #{detail}" )
+  end
+
+  def stop
+    net(:stop, @resource[:name])
+  rescue Puppet::ExecutionFailure => detail
+    raise Puppet::Error.new("Cannot stop #{@resource[:name]}, error was: #{detail}" )
+  end
+
+  def status
+    w32ss = Win32::Service.status( @resource[:name] )
+    raise Puppet::Error.new("Win32 service query of #{@resource[:name]} failed" ) unless( !w32ss.nil? && w32ss.instance_of?( Struct::ServiceStatus ) )
+    state = case w32ss.current_state
+      when "stopped", "pause pending", "stop pending", "paused" then :stopped
+      when "running", "continue pending", "start pending"       then :running
+      else
+        raise Puppet::Error.new("Unknown service state '#{w32ss.current_state}' for service '#{@resource[:name]}'")
+    end
+    debug("Service #{@resource[:name]} is #{w32ss.current_state}")
+    return state
+  rescue Win32::Service::Error => detail
+    raise Puppet::Error.new("Cannot get status of #{@resource[:name]}, error was: #{detail}" )
+  end
+
+  # returns all providers for all existing services and startup state
+  def self.instances
+    Win32::Service.services.collect { |s| new(:name => s.service_name) }
+  end
+end

data/lib/vendor/puppet/provider/ssh_authorized_key/parsed.rb

@@ -0,0 +1,88 @@
+require 'puppet/provider/parsedfile'
+Puppet::Type.type(:ssh_authorized_key).provide(
+  :parsed,
+  :parent         => Puppet::Provider::ParsedFile,
+  :filetype       => :flat,
+  :default_target => ''
+) do
+  desc "Parse and generate authorized_keys files for SSH."
+
+  text_line :comment, :match => /^\s*#/
+  text_line :blank, :match => /^\s*$/
+
+  record_line :parsed,
+    :fields   => %w{options type key name},
+    :optional => %w{options},
+    :rts => /^\s+/,
+    :match    => /^(?:(.+) )?(ssh-dss|ssh-rsa|ecdsa-sha2-nistp256|ecdsa-sha2-nistp384|ecdsa-sha2-nistp521) ([^ ]+) ?(.*)$/,
+    :post_parse => proc { |h|
+      h[:name] = "" if h[:name] == :absent
+      h[:options] ||= [:absent]
+      h[:options] = Puppet::Type::Ssh_authorized_key::ProviderParsed.parse_options(h[:options]) if h[:options].is_a? String
+    },
+    :pre_gen => proc { |h|
+      h[:options] = [] if h[:options].include?(:absent)
+      h[:options] = h[:options].join(',')
+    }
+
+  record_line :key_v1,
+    :fields   => %w{options bits exponent modulus name},
+    :optional => %w{options},
+    :rts      => /^\s+/,
+    :match    => /^(?:(.+) )?(\d+) (\d+) (\d+)(?: (.+))?$/
+
+  def dir_perm
+    0700
+  end
+
+  def file_perm
+    0600
+  end
+
+  def user
+    uid = File.stat(target).uid
+    Etc.getpwuid(uid).name
+  end
+
+  def flush
+    raise Puppet::Error, "Cannot write SSH authorized keys without user"    unless @resource.should(:user)
+    raise Puppet::Error, "User '#{@resource.should(:user)}' does not exist" unless uid = Puppet::Util.uid(@resource.should(:user))
+    # ParsedFile usually calls backup_target much later in the flush process,
+    # but our SUID makes that fail to open filebucket files for writing.
+    # Fortunately, there's already logic to make sure it only ever happens once,
+    # so calling it here supresses the later attempt by our superclass's flush method.
+    self.class.backup_target(target)
+
+    Puppet::Util::SUIDManager.asuser(@resource.should(:user)) do
+        unless File.exist?(dir = File.dirname(target))
+          Puppet.debug "Creating #{dir}"
+          Dir.mkdir(dir, dir_perm)
+        end
+
+        super
+
+        File.chmod(file_perm, target)
+    end
+  end
+
+  # parse sshv2 option strings, wich is a comma separated list of
+  # either key="values" elements or bare-word elements
+  def self.parse_options(options)
+    result = []
+    scanner = StringScanner.new(options)
+    while !scanner.eos?
+      scanner.skip(/[ \t]*/)
+      # scan a long option
+      if out = scanner.scan(/[-a-z0-9A-Z_]+=\".*?\"/) or out = scanner.scan(/[-a-z0-9A-Z_]+/)
+        result << out
+      else
+        # found an unscannable token, let's abort
+        break
+      end
+      # eat a comma
+      scanner.skip(/[ \t]*,[ \t]*/)
+    end
+    result
+  end
+end
+

data/lib/vendor/puppet/provider/sshkey/parsed.rb

@@ -0,0 +1,37 @@
+require 'puppet/provider/parsedfile'
+
+known = nil
+case Facter.value(:operatingsystem)
+when "Darwin"; known = "/etc/ssh_known_hosts"
+else
+  known = "/etc/ssh/ssh_known_hosts"
+end
+
+
+Puppet::Type.type(:sshkey).provide(
+  :parsed,
+  :parent => Puppet::Provider::ParsedFile,
+  :default_target => known,
+  :filetype => :flat
+) do
+  desc "Parse and generate host-wide known hosts files for SSH."
+
+  text_line :comment, :match => /^#/
+  text_line :blank, :match => /^\s+/
+
+  record_line :parsed, :fields => %w{name type key},
+    :post_parse => proc { |hash|
+      names = hash[:name].split(",", -1)
+      hash[:name]  = names.shift
+      hash[:host_aliases] = names
+    },
+    :pre_gen => proc { |hash|
+      if hash[:host_aliases]
+        names = [hash[:name], hash[:host_aliases]].flatten
+
+        hash[:name] = [hash[:name], hash[:host_aliases]].flatten.join(",")
+        hash.delete(:host_aliases)
+      end
+    }
+end
+