openvox 7.37.1

data/ext/redhat/client.init

@@ -0,0 +1,169 @@
+#!/bin/bash
+# puppet        Init script for running the puppet client daemon
+#
+# Author:       Duane Griffin <d.griffin@psenterprise.com>
+#               David Lutterkort <dlutter@redhat.com>
+#
+# chkconfig: - 98 02
+#
+# description: Enables periodic system configuration checks through puppet.
+# processname: puppet
+# config: /etc/sysconfig/puppet
+
+# Source function library.
+. /etc/rc.d/init.d/functions
+
+[ -f /etc/sysconfig/puppet ] && . /etc/sysconfig/puppet
+lockfile=/var/lock/subsys/puppet
+piddir=/var/run/puppetlabs
+pidfile="${piddir}/agent.pid"
+puppetd=/opt/puppetlabs/puppet/bin/puppet
+pid=$(cat "$pidfile" 2> /dev/null)
+RETVAL=0
+
+PUPPET_OPTS="agent "
+
+# Determine if we can use the -p option to daemon, killproc, and status.
+# RHEL < 5 can't.
+if status | grep -q -- '-p' 2>/dev/null; then
+    daemonopts="--pidfile $pidfile"
+    pidopts="-p $pidfile"
+    USEINITFUNCTIONS=true
+fi
+
+# Figure out if the system just booted. Let's assume
+# boot doesn't take longer than 5 minutes
+## Not used for now
+##[ -n "$INIT_VERSION" ] && PUPPET_OPTS="${PUPPET_OPTS} --fullrun"
+
+start() {
+    echo -n $"Starting puppet agent: "
+    mkdir -p $piddir
+    daemon $daemonopts $puppetd ${PUPPET_OPTS} ${PUPPET_EXTRA_OPTS}
+    RETVAL=$?
+    echo
+        [ $RETVAL = 0 ] && touch ${lockfile}
+        return $RETVAL
+}
+
+stop() {
+    echo -n $"Stopping puppet agent: "
+    if [ "$USEINITFUNCTIONS" = "true" ]; then
+      killproc $pidopts $puppetd
+      RETVAL=$?
+    else
+      if [ -n "${pid}" ]; then
+        kill -TERM $pid >/dev/null 2>&1
+        RETVAL=$?
+      fi
+    fi
+    echo
+    [ $RETVAL = 0 ] && rm -f ${lockfile} ${pidfile}
+    return $RETVAL
+}
+
+reload() {
+    echo -n $"Reloading puppet agent: "
+    if [ "$USEINITFUNCTIONS" = "true" ]; then
+      killproc $pidopts $puppetd -HUP
+      RETVAL=$?
+    else
+      if [ -n "${pid}" ]; then
+        kill -HUP $pid >/dev/null 2>&1
+        RETVAL=$?
+      else
+        RETVAL=0
+      fi
+    fi
+    echo
+    return $RETVAL
+}
+
+rotate() {
+    echo -n $"Reopening log files for puppet agent: "
+    killproc $pidopts $puppetd -USR2
+    RETVAL=$?
+    echo
+    return $RETVAL
+}
+
+restart() {
+    stop
+    start
+}
+
+rh_status() {
+    base=puppet
+    if [ "$USEINITFUNCTIONS" = "true" ]; then
+      status $pidopts $puppetd
+      RETVAL=$?
+      return $RETVAL
+    else
+      if [ -n "${pid}" ]; then
+        if `ps -p $pid | grep $pid > /dev/null 2>&1`; then
+          echo "${base} (pid ${pid}) is running..."
+          RETVAL=0
+          return $RETVAL
+        fi
+      fi
+      if [ -f "${pidfile}" ] ; then
+        echo "${base} dead but pid file exists"
+        RETVAL=1
+        return $RETVAL
+      fi
+      if [ -f "${lockfile}" ]; then
+        echo "${base} dead but subsys locked"
+        RETVAL=2
+        return $RETVAL
+      fi
+      echo "${base} is stopped"
+      RETVAL=3
+      return $RETVAL
+    fi
+}
+
+rh_status_q() {
+    rh_status >/dev/null 2>&1
+}
+
+genconfig() {
+    echo -n $"Generate puppet agent configuration: "
+    $puppetd ${PUPPET_OPTS} ${PUPPET_EXTRA_OPTS} --genconfig
+}
+
+case "$1" in
+    start)
+        start
+    ;;
+    stop)
+        stop
+    ;;
+    restart)
+        restart
+    ;;
+    rotate)
+        rotate
+    ;;
+    reload|force-reload)
+        reload
+    ;;
+    condrestart|try-restart)
+        rh_status_q || exit 0
+        restart
+    ;;
+    status)
+        rh_status
+    ;;
+    once)
+        shift
+        $puppetd ${PUPPET_OPTS} --onetime ${PUPPET_EXTRA_OPTS} $@
+        ;;
+    genconfig)
+        genconfig
+    ;;
+    *)
+        echo $"Usage: $0 {start|stop|status|restart|reload|force-reload|condrestart|rotate|once|genconfig}"
+        exit 1
+esac
+
+exit $RETVAL

data/ext/redhat/client.sysconfig

@@ -0,0 +1,2 @@
+# You may specify parameters to the puppet client here
+#PUPPET_EXTRA_OPTS=--waitforcert=500

data/ext/solaris/smf/puppet

@@ -0,0 +1,44 @@
+#!/sbin/sh
+
+. /lib/svc/share/smf_include.sh
+
+[ -z "${SMF_FMRI}" ] && exit "$SMF_EXIT_ERR"
+
+CONF_FILE=/etc/puppetlabs/puppet/puppet.conf
+[ ! -f "${CONF_FILE}" ] && exit "$SMF_EXIT_ERR_CONFIG"
+
+PUPPET=/opt/puppetlabs/bin/puppet
+
+case "$1" in
+start)
+  exec "$PUPPET" agent
+  ;;
+
+stop)
+  # stop sends sigterm first followed by sigkill
+  # smf_kill_contract <CTID> TERM 1 30
+  # sends sigterm to all process in ctid and will continue
+  # to do so for 30 seconds with interval of 5 seconds
+  # smf_kill_contract <CTID> KILL 1
+  # continues until all processes are killed.
+  # svcs -p <fmri> lists all processes in the contract.
+  # http://bnsmb.de/solaris/My_Little_SMF_FAQ.html
+  ctid=`svcprop -p restarter/contract "$SMF_FMRI"`
+  if [ -n "$ctid" ]; then
+    smf_kill_contract "$ctid" TERM 1 30
+    ret=$?
+    [ "$ret" -eq 1 ] && exit "$SMF_EXIT_ERR_FATAL"
+
+    if [ "$ret" -eq 2 ] ; then
+      smf_kill_contract "$ctid" KILL 1
+      [ $? -ne 0 ] && exit "$SMF_EXIT_ERR_FATAL"
+    fi
+  fi
+  ;;
+*)
+  echo "Usage: $0 {start|stop}";
+  exit "$SMF_EXIT_ERR_FATAL"
+  ;;
+esac
+exit "$SMF_EXIT_OK"
+

data/ext/solaris/smf/puppet.xml

@@ -0,0 +1,46 @@
+<?xml version="1.0"?>
+<!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">
+<!-- Original puppet manifest: Luke Kanies - puppetlabs.com -->
+<service_bundle type="manifest" name="puppet">
+
+  <service name="network/puppet" type="service" version="1">
+
+    <create_default_instance enabled="false"/>
+    <single_instance/>
+
+    <dependency name="config-file" grouping="require_all" restart_on="none" type="path">
+      <service_fmri value="file:///etc/puppetlabs/puppet/puppet.conf"/>
+    </dependency>
+
+    <dependency name="loopback" grouping="require_all" restart_on="error" type="service">
+      <service_fmri value="svc:/network/loopback:default"/>
+    </dependency>
+
+    <dependency name="physical" grouping="require_all" restart_on="error" type="service">
+      <service_fmri value="svc:/network/physical:default"/>
+    </dependency>
+
+    <dependency name="fs-local" grouping="require_all" restart_on="none" type="service">
+      <service_fmri value="svc:/system/filesystem/local"/>
+    </dependency>
+
+    <exec_method type="method" name="start" exec="/lib/svc/method/puppet start" timeout_seconds="60"/>
+
+    <exec_method type="method" name="stop" exec="/lib/svc/method/puppet stop" timeout_seconds="60"/>
+
+    <exec_method type="method" name="refresh" exec=":kill" timeout_seconds="60"/>
+
+  <stability value="Evolving"/>
+
+    <template>
+      <common_name>
+        <loctext xml:lang="C">Puppet Agent Daemon</loctext>
+      </common_name>
+      <documentation>
+        <manpage title="puppet" section="1"/>
+        <doc_link name="puppetlabs.com" uri="https://puppetlabs.com/puppet/introduction"/>
+      </documentation>
+    </template>
+  </service>
+
+</service_bundle>

data/ext/suse/client.init

@@ -0,0 +1,141 @@
+#!/bin/bash
+# puppet        Init script for running the puppet client daemon
+#
+# Author:       Duane Griffin <d.griffin@psenterprise.com>
+#               David Lutterkort <dlutter@redhat.com>
+#               Martin Vuk <martin.vuk@fri.uni-lj.si> (SuSE support)
+#
+# chkconfig: - 98 02
+#
+# description: Enables periodic system configuration checks through puppet.
+# processname: puppet
+# config: /etc/sysconfig/puppet
+
+### BEGIN INIT INFO
+# Provides: puppet
+# Required-Start: $local_fs $remote_fs $network $syslog
+# Should-Start: puppet
+# Required-Stop: $local_fs $remote_fs $network $syslog
+# Should-Stop: puppet
+# Default-Start: 3 5
+# Default-Stop: 0 1 2 6
+# Short-Description: puppet
+# Description: Enables periodic system configuration checks through puppet.
+### END INIT INFO
+
+# Shell functions sourced from /etc/rc.status:
+#      rc_check         check and set local and overall rc status
+#      rc_status        check and set local and overall rc status
+#      rc_status -v     ditto but be verbose in local rc status
+#      rc_status -v -r  ditto and clear the local rc status
+#      rc_failed        set local and overall rc status to failed
+#      rc_reset         clear local rc status (overall remains)
+#      rc_exit          exit appropriate to overall rc status
+[ -f /etc/rc.status ] && . /etc/rc.status
+[ -f /etc/sysconfig/puppet ] && . /etc/sysconfig/puppet
+lockfile=/var/lock/subsys/puppet
+pidfile=/var/run/puppetlabs/agent.pid
+puppetd=/opt/puppetlabs/puppet/bin/puppet
+
+PUPPET_OPTS="agent"
+
+# First reset status of this service
+rc_reset
+
+# Return values acc. to LSB for all commands but status:
+# 0 - success
+# 1 - misc error
+# 2 - invalid or excess args
+# 3 - unimplemented feature (e.g. reload)
+# 4 - insufficient privilege
+# 5 - program not installed
+# 6 - program not configured
+#
+# Note that starting an already running service, stopping
+# or restarting a not-running service as well as the restart
+# with force-reload (in case signalling is not supported) are
+# considered a success.
+
+case "$1" in
+    start)
+        echo -n "Starting puppet services."
+        ## Start daemon with startproc(8). If this fails
+        ## the echo return value is set appropriate.
+
+        ## This accounts for the behavior of startproc on sles 10.
+        ## Check to see if a running process matches the contents
+        ## of the pidfile, and do nothing if true. Otherwise
+        ## force a process start
+        if [ -f "${pidfile}" ]; then
+            PID=$(cat "$pidfile")
+            if [ "$PID" -eq $(pgrep -f "$puppetd") ] ; then
+                rc_status -v
+                rc_exit
+            fi
+        fi
+        startproc -f -w -p "${pidfile}" "${puppetd}" "${PUPPET_OPTS}" ${PUPPET_EXTRA_OPTS} && touch "${lockfile}"
+        # Remember status and be verbose
+        rc_status -v
+        ;;
+    stop)
+        echo -n "Shutting down puppet:"
+        ## Stop daemon with killproc(8) and if this fails
+        ## set echo the echo return value.
+
+        killproc -QUIT -p "${pidfile}" "${puppetd}" && rm -f "${lockfile}" "${pidfile}"
+
+        # Remember status and be verbose
+        rc_status -v
+        ;;
+    try-restart|condrestart)
+        ## Stop the service and if this succeeds (i.e. the
+        ## service was running before), start it again.
+        $0 status >/dev/null &&  $0 restart
+
+        # Remember status and be quiet
+        rc_status
+        ;;
+    restart)
+        ## Stop the service and regardless of whether it was
+        ## running or not, start it again.
+        $0 stop
+        $0 start
+
+        # Remember status and be quiet
+        rc_status
+        ;;
+    reload|force-reload)
+        # Reload the service by sending the HUP signal
+        echo -n "Reloading puppet service: "
+        killproc -HUP -p "${pidfile}" "${puppetd}"
+        rc_status -v
+        ;;
+    status)
+        echo -n "Checking for service puppetd: "
+        ## Check status with checkproc(8), if process is running
+        ## checkproc will return with exit status 0.
+
+        # Status has a slightly different for the status command:
+        # 0 - service running
+        # 1 - service dead, but /var/run/  pid  file exists
+        # 2 - service dead, but /var/lock/ lock file exists
+        # 3 - service not running
+
+        # NOTE: checkproc returns LSB compliant status values.
+        if [ -f "${pidfile}" ]; then
+            checkproc -p "${pidfile}" "${puppetd}"
+            rc_status -v
+        else
+            rc_failed 3
+            rc_status -v
+        fi
+        ;;
+    once)
+        shift
+        $puppetd "${PUPPET_OPTS}" --onetime ${PUPPET_EXTRA_OPTS} $@
+        ;;
+    *)
+        echo "Usage: $0 {start|stop|status|try-restart|condrestart|restart|force-reload|reload|once}"
+        exit 1
+esac
+rc_exit

data/ext/systemd/puppet.service

@@ -0,0 +1,26 @@
+#
+# Local settings can be configured without being overwritten by package upgrades, for example
+# if you want to increase puppet open-files-limit to 10000,
+# you need to increase systemd's LimitNOFILE setting, so create a file named
+# "/etc/systemd/system/puppet.service.d/limits.conf" containing:
+# [Service]
+# LimitNOFILE=10000
+# You can confirm it worked by running systemctl daemon-reload
+# then running systemctl show puppet | grep LimitNOFILE
+#
+[Unit]
+Description=Puppet agent
+Documentation=man:puppet-agent(8)
+Wants=basic.target
+After=basic.target network.target network-online.target
+
+[Service]
+EnvironmentFile=-/etc/sysconfig/puppetagent
+EnvironmentFile=-/etc/sysconfig/puppet
+EnvironmentFile=-/etc/default/puppet
+ExecStart=/opt/puppetlabs/puppet/bin/puppet agent $PUPPET_EXTRA_OPTS --no-daemonize
+ExecReload=/bin/kill -HUP $MAINPID
+KillMode=process
+
+[Install]
+WantedBy=multi-user.target

data/ext/windows/puppet_interactive.bat

@@ -0,0 +1,6 @@
+@echo off
+SETLOCAL
+echo Running Puppet agent on demand ...
+cd "%~dp0"
+call puppet.bat agent --test %*
+PAUSE

data/ext/windows/puppet_shell.bat

@@ -0,0 +1,9 @@
+@echo off
+SETLOCAL
+if exist "%~dp0environment.bat" (
+  call "%~dp0environment.bat" %0 %*
+) else (
+  SET "PATH=%~dp0;%PATH%"
+)
+REM Display Ruby version
+ruby.exe -v

data/ext/windows/run_puppet_interactive.bat

@@ -0,0 +1,9 @@
+@echo Running puppet on demand ...
+@echo off
+SETLOCAL
+if exist "%~dp0environment.bat" (
+  call "%~dp0environment.bat" %0 %*
+) else (
+  SET "PATH=%~dp0;%PATH%"
+)
+elevate.exe "%~dp0puppet_interactive.bat"

data/ext/windows/service/daemon.bat

@@ -0,0 +1,6 @@
+@echo off
+SETLOCAL
+
+call "%~dp0..\bin\environment.bat" %0 %*
+
+ruby -rubygems "%~dp0daemon.rb" %*

data/ext/windows/service/daemon.rb

@@ -0,0 +1,225 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'puppet/util/windows/daemon'
+
+# This file defines utilities for logging to eventlog. While it lives inside
+# Puppet, it is completely independent and loads no other parts of Puppet, so we
+# can safely require *just* it.
+require 'puppet/util/windows/eventlog'
+
+# monkey patches ruby Process to add .create method
+require 'puppet/util/windows/monkey_patches/process'
+
+class WindowsDaemon < Puppet::Util::Windows::Daemon
+  CREATE_NEW_CONSOLE          = 0x00000010
+
+  @run_thread = nil
+  @LOG_TO_FILE = false
+  @loglevel = 0
+  LOG_FILE =  File.expand_path(File.join(ENV['ALLUSERSPROFILE'], 'PuppetLabs', 'puppet', 'var', 'log', 'windows.log'))
+  LEVELS = [:debug, :info, :notice, :warning, :err, :alert, :emerg, :crit]
+  LEVELS.each do |level|
+    define_method("log_#{level}") do |msg|
+      log(msg, level)
+    end
+  end
+
+  def service_init
+  end
+
+  def service_main(*argsv)
+    argsv = (argsv << ARGV).flatten.compact
+    args = argsv.join(' ')
+    @loglevel = LEVELS.index(argsv.index('--debug') ? :debug : :notice)
+
+    @LOG_TO_FILE = (argsv.index('--logtofile') ? true : false)
+
+    if (@LOG_TO_FILE)
+      FileUtils.mkdir_p(File.dirname(LOG_FILE))
+      args = args.gsub("--logtofile","")
+    end
+
+    base_dir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+    load_env(base_dir)
+
+    # The puppet installer registers a 'Puppet' event source.  For the moment events will be logged with this key, but
+    # it may be a good idea to split the Service and Puppet events later so it's easier to read in the windows Event Log.
+    #
+    # Example code to register an event source;
+    # eventlogdll =  File.expand_path(File.join(basedir, 'puppet', 'ext', 'windows', 'eventlog', 'puppetres.dll'))
+    # if (File.exist?(eventlogdll))
+    #   Win32::EventLog.add_event_source(
+    #      'source' => "Application",
+    #      'key_name' => "Puppet Agent",
+    #      'category_count' => 3,
+    #      'event_message_file' => eventlogdll,
+    #      'category_message_file' => eventlogdll
+    #   )
+    # end
+
+    puppet = File.join(base_dir, 'puppet', 'bin', 'puppet')
+    ruby = File.join(base_dir, 'puppet', 'bin', 'ruby.exe')
+    ruby_puppet_cmd = "\"#{ruby}\" \"#{puppet}\""
+
+    unless File.exist?(puppet)
+      log_err("File not found: '#{puppet}'")
+      return
+    end
+    log_debug("Using '#{puppet}'")
+
+    cmdline_debug = argsv.index('--debug') ? :debug : nil
+    @loglevel = parse_log_level(ruby_puppet_cmd, cmdline_debug)
+    log_notice('Service started')
+
+    service = self
+    @run_thread = Thread.new do
+      begin
+        while service.running? do
+          runinterval = service.parse_runinterval(ruby_puppet_cmd)
+
+          if service.state == RUNNING or service.state == IDLE
+            service.log_notice("Executing agent with arguments: #{args}")
+            pid = Process.create(:command_line => "#{ruby_puppet_cmd} agent --onetime #{args}", :creation_flags => CREATE_NEW_CONSOLE).process_id
+            service.log_debug("Process created: #{pid}")
+          else
+            service.log_debug("Service is paused.  Not invoking Puppet agent")
+          end
+
+          service.log_debug("Service worker thread waiting for #{runinterval} seconds")
+          sleep(runinterval)
+          service.log_debug('Service worker thread woken up')
+        end
+      rescue Exception => e
+        service.log_exception(e)
+      end
+    end
+    @run_thread.join
+
+  rescue Exception => e
+    log_exception(e)
+  ensure
+    log_notice('Service stopped')
+  end
+
+  def service_stop
+    log_notice('Service stopping / killing worker thread')
+    @run_thread.kill if @run_thread
+  end
+
+  def service_pause
+    log_notice('Service pausing')
+  end
+
+  def service_resume
+    log_notice('Service resuming')
+  end
+
+  def service_shutdown
+    log_notice('Host shutting down')
+  end
+
+  # Interrogation handler is just for debug.  Can be commented out or removed entirely.
+  # def service_interrogate
+  #   log_debug('Service is being interrogated')
+  # end
+
+  def log_exception(e)
+    log_err(e.message)
+    log_err(e.backtrace.join("\n"))
+  end
+
+  def log(msg, level)
+    if LEVELS.index(level) >= @loglevel
+      if (@LOG_TO_FILE)
+        # without this change its possible that we get Encoding errors trying to write UTF-8 messages in current codepage
+        File.open(LOG_FILE, 'a:UTF-8') { |f| f.puts("#{Time.now} Puppet (#{level}): #{msg}") }
+      end
+
+      native_type, native_id = Puppet::Util::Windows::EventLog.to_native(level)
+      report_windows_event(native_type, native_id, msg.to_s)
+    end
+  end
+
+  def report_windows_event(type,id,message)
+    begin
+      eventlog = nil
+      eventlog = Puppet::Util::Windows::EventLog.open("Puppet")
+      eventlog.report_event(
+        :event_type  => type,   # EVENTLOG_ERROR_TYPE, etc
+        :event_id    => id,     # 0x01 or 0x02, 0x03 etc.
+        :data        => message # "the message"
+      )
+    rescue Exception
+      # Ignore all errors
+    ensure
+      if (!eventlog.nil?)
+        eventlog.close
+      end
+    end
+  end
+
+  # Parses runinterval.
+  #
+  # @param puppet_path [String] The file path for the Puppet executable.
+  # @return runinterval [Integer] How often to do a Puppet run, in seconds.
+  def parse_runinterval(puppet_path)
+    begin
+      runinterval = %x(#{puppet_path} config --section agent --log_level notice print runinterval).chomp
+      if runinterval == ''
+        runinterval = 1800
+        log_err("Failed to determine runinterval, defaulting to #{runinterval} seconds")
+      else
+        # Use Kernel#Integer because to_i will return 0 with non-numeric strings.
+        runinterval = Integer(runinterval)
+      end
+    rescue Exception => e
+      log_exception(e)
+      runinterval = 1800
+    end
+
+    runinterval
+  end
+
+  def parse_log_level(puppet_path,cmdline_debug)
+    begin
+      loglevel = %x{ #{puppet_path} config --section agent --log_level notice print log_level }.chomp
+      unless loglevel && respond_to?("log_#{loglevel}")
+        loglevel = :notice
+        log_err("Failed to determine loglevel, defaulting to #{loglevel}")
+      end
+    rescue Exception => e
+      log_exception(e)
+      loglevel = :notice
+    end
+
+    LEVELS.index(cmdline_debug ? cmdline_debug : loglevel.to_sym)
+  end
+
+  private
+
+  def load_env(base_dir)
+    begin
+      # ENV that uses backward slashes
+      ENV['FACTER_env_windows_installdir'] = base_dir.tr('/', '\\')
+      ENV['PL_BASEDIR'] = base_dir.tr('/', '\\')
+      ENV['PUPPET_DIR'] = File.join(base_dir, 'puppet').tr('/', '\\')
+      ENV['OPENSSL_CONF'] = File.join(base_dir, 'puppet', 'ssl', 'openssl.cnf').tr('/', '\\')
+      ENV['SSL_CERT_DIR'] = File.join(base_dir, 'puppet', 'ssl', 'certs').tr('/', '\\')
+      ENV['SSL_CERT_FILE'] = File.join(base_dir, 'puppet', 'ssl', 'cert.pem').tr('/', '\\')
+      ENV['Path'] = [
+        File.join(base_dir, 'puppet', 'bin'),
+        File.join(base_dir, 'bin'),
+      ].join(';').tr('/', '\\') + ';' + ENV['Path']
+
+      # ENV that uses forward slashes
+      ENV['RUBYLIB'] = "#{File.join(base_dir, 'puppet','lib')};#{ENV['RUBYLIB']}"
+    rescue => e
+      log_exception(e)
+    end
+  end
+end
+
+if __FILE__ == $0
+  WindowsDaemon.mainloop
+end