Puppet

    "rspec"

    "puppet"

    at.clear_mappings

    # watch out: Ruby bug (1.8.6):

    # %r(/) != /\//

    at.add_mapping(%r%^spec/.*\.rb$%) { |filename, _|

        filename

    }

    at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m|

        ["spec/#{m[1]}_spec.rb"]

    }

    at.add_mapping(%r%^spec/(spec_helper|shared/.*)\.rb$%) {

        at.files_matching %r{^spec/.*_spec\.rb$}

    }

    def initialize

        super

        self.failed_results_re = /^\d+\)\n(?:\e\[\d*m)?(?:.*?Error in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n(.*?)\n\n/m

        self.completed_re = /\Z/ # FIX: some sort of summary line at the end?

    end

    def consolidate_failures(failed)

        filters = Hash.new { |h,k| h[k] = [] }

        failed.each do |spec, failed_trace|

            if f = test_files_for(failed).find { |f| failed_trace =~ Regexp.new(f) } then

                filters[f] << spec

                break

            end

        end

        return filters

    def make_test_cmd(files_to_test)

        return "#{ruby} -S #{spec_command} #{add_options_if_present} #{files_to_test.keys.flatten.join(' ')}"

    end

    def add_options_if_present

        File.exist?("spec/spec.opts") ? "-O spec/spec.opts " : ""

    end

    # Finds the proper spec command to use.  Precendence is set in the

    # lazily-evaluated method spec_commands.  Alias + Override that in

    # ~/.autotest to provide a different spec command then the default

    # paths provided.

    def spec_command(separator=File::ALT_SEPARATOR)

        unless defined? @spec_command then

            @spec_command = spec_commands.find { |cmd| File.exists? cmd }

            raise RspecCommandError, "No spec command could be found!" unless @spec_command

            @spec_command.gsub! File::SEPARATOR, separator if separator

        end

        @spec_command

    # Autotest will look for spec commands in the following

    # locations, in this order:

    #

    #   * bin/spec

    #   * default spec bin/loader installed in Rubygems

    def spec_commands

        [

            File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec')),

            File.join(Config::CONFIG['bindir'], 'spec')

        ]

    end

    VERSION = '0.1'

    script_name = File.basename($0)

    # default options

    OPTIONS = {

        :statefile => "/var/puppet/state/state.yaml",

        :process   => "puppetd",

        :interval  => 30,

    }

    o = OptionParser.new do |o|

        o.set_summary_indent('  ')

        o.banner =    "Usage: #{script_name} [OPTIONS]"

        o.define_head "The check_puppet Nagios plug-in checks that specified " +

                  o.separator   ""

                  o.separator   "Mandatory arguments to long options are mandatory for " +

                  o.on("-s", "--statefile=statefile", String, "The state file",

         o.on("-p", "--process=processname", String, "The process to check",

         o.on("-i", "--interval=value", Integer,

         o.separator ""

         o.on_tail("-h", "--help", "Show this help message.") do

             puts o

             exit

         end

         o.parse!(ARGV)

    def check_proc

        unless ProcTable.ps.find { |p| p.name == OPTIONS[:process]}

            @proc = 2

        else

            @proc = 0

        end

    def check_state

        # Set variables

        curt = Time.now

        intv = OPTIONS[:interval] * 60

        # Check file time

        begin

            @modt = File.mtime("#{OPTIONS[:statefile]}")

        rescue

            @file = 3

        end

        diff = (curt - @modt).to_i

        if diff > intv

            @file = 2

        else

            @file = 0

        end

    def output_status

        case @file

        when 0

            state = "state file status okay updated on " + @modt.strftime("%m/%d/%Y at %H:%M:%S")

        when 2

            state = "state fille is not up to date and is older than #{OPTIONS[:interval]} minutes"

        when 3

            state = "state file status unknown"

        end

        case @proc

        when 0

            process = "process #{OPTIONS[:process]} is running"

        when 2

            process = "process #{OPTIONS[:process]} is not running"

        end

        case @proc or @file

        when 0

            status = "OK"

            exitcode = 0

        when 2

            status = "CRITICAL"

            exitcode = 2

        when 3

            status = "UNKNOWN"

            exitcide = 3

        end

        puts "PUPPET " + status + ": " + process + ", " + state

        exit(exitcode)

    end

    case line

    when /^\s*#/: next # skip comments

    when /^\s*$/: next # skip blank lines

    when /\[puppetrunner\]/: # puppetrunner section

        runner=true

    when /^\s*(\w+)\s+(.+)$/:

        var = $1

        value = $2

        case var

        when "allow":

            value.split(/\s*,\s*/).each { |val|

            allowed_servers << val

            puts "allowing %s access" % val

        } if runner==true

        end

    else

        runner=false

    begin

        ns = ssls.accept # start SSL session

        af, port, host, ip = ns.peeraddr

        print "connection from #{host+"("+ip+")"} "

        if allowed_servers.include?(host)

            #TODO add support for tags and other command line arguments

            puts "accepted"

            ns.puts "Executing #{cmd} on #{Facter.fqdn}.\n*******OUTPUT********\n\n"

            IO.popen(cmd) do |f|

                while line = f.gets do

                    ns.puts line

                end

            end

            ns.puts "\n*********DONE**********"

        else

            ns.puts "denied\n"

            puts "denied"

        ns.close

    rescue

        ns.close

        next

    warn "Usage: hostname to run against"

    exit 1

    host = ARGV[0]

    puts line

    when "sqlite3"

        args[:dbfile] = pm_conf[:dblocation]

    when "mysql", "postgresql"

        args[:host]     = pm_conf[:dbserver] unless pm_conf[:dbserver].to_s.empty?

        args[:username] = pm_conf[:dbuser] unless pm_conf[:dbuser].to_s.empty?

        args[:password] = pm_conf[:dbpassword] unless pm_conf[:dbpassword].to_s.empty?

        args[:database] = pm_conf[:dbname] unless pm_conf[:dbname].to_s.empty?

        socket          = pm_conf[:dbsocket]

        args[:socket]   = socket unless socket.to_s.empty?

    else

        raise ArgumentError, "Invalid db adapter %s" % adapter

    # These glogal vars are used to make nice graph source.

    $tab  = '    '

    $tab2 = $tab * 2

    # if we don't like 4 spaces, we can change it any time

    def change_tab (t)

        $tab  = t

        $tab2 = t * 2

    end

    # options for node declaration

    NODE_OPTS = [

        # attributes due to

        # http://www.graphviz.org/Documentation/dotguide.pdf

        # March, 26, 2005

        'bottomlabel', # auxiliary label for nodes of shape M*

        'color',       # default: black; node shape color

        'comment',     # any string (format-dependent)

        'distortion',  # default: 0.0; node distortion for shape=polygon

        'fillcolor',   # default: lightgrey/black; node fill color

        'fixedsize',   # default: false; label text has no affect on node size

        'fontcolor',   # default: black; type face color

        'fontname',    # default: Times-Roman; font family

        'fontsize',    # default: 14; point size of label

        'group',       # name of node?s group

        'height',      # default: .5; height in inches

        'label',       # default: node name; any string

        'layer',       # default: overlay range; all, id or id:id

        'orientation', # dafault: 0.0; node rotation angle

        'peripheries', # shape-dependent number of node boundaries

        'regular',     # default:  false; force polygon to be regular

        'shape',       # default: ellipse; node shape; see Section 2.1 and Appendix E

        'shapefile',   # external EPSF or SVG custom shape file

        'sides',       # default: 4; number of sides for shape=polygon

        'skew' ,       # default: 0.0; skewing of node for shape=polygon

        'style',       # graphics options, e.g. bold, dotted, filled; cf. Section 2.3

        'toplabel',    # auxiliary label for nodes of shape M*

        'URL',         # URL associated with node (format-dependent)

        'width',       # default: .75; width in inches

        'z',           # default: 0.0; z coordinate for VRML output

        # maintained for backward compatibility or rdot internal

        'bgcolor',

        'rank'

    ]

    # options for edge declaration

    EDGE_OPTS = [

        'arrowhead',      # default: normal; style of arrowhead at head end

        'arrowsize',      # default: 1.0; scaling factor for arrowheads

        'arrowtail',      # default: normal; style of arrowhead at tail end

        'color',          # default: black; edge stroke color

        'comment',        # any string (format-dependent)

        'constraint',     # default: true use edge to affect node ranking

        'decorate',       # if set, draws a line connecting labels with their edges

        'dir',            # default: forward; forward, back, both, or none

        'fontcolor',      # default: black type face color

        'fontname',       # default: Times-Roman; font family

        'fontsize',       # default: 14; point size of label

        'headlabel',      # label placed near head of edge

        'headport',       # n,ne,e,se,s,sw,w,nw

        'headURL',        # URL attached to head label if output format is ismap

        'label',          # edge label

        'labelangle',     # default: -25.0; angle in degrees which head or tail label is rotated off edge

        'labeldistance',  # default: 1.0; scaling factor for distance of head or tail label from node

        'labelfloat',     # default: false; lessen constraints on edge label placement

        'labelfontcolor', # default: black; type face color for head and tail labels

        'labelfontname',  # default: Times-Roman; font family for head and tail labels

        'labelfontsize',  # default: 14 point size for head and tail labels

        'layer',          # default: overlay range; all, id or id:id

        'lhead',          # name of cluster to use as head of edge

        'ltail',          # name of cluster to use as tail of edge

        'minlen',         # default: 1 minimum rank distance between head and tail

        'samehead',       # tag for head node; edge heads with the same tag are merged onto the same port

        'sametail',       # tag for tail node; edge tails with the same tag are merged onto the same port

        'style',          # graphics options, e.g. bold, dotted, filled; cf. Section 2.3

        'taillabel',      # label placed near tail of edge

        'tailport',       # n,ne,e,se,s,sw,w,nw

        'tailURL',        # URL attached to tail label if output format is ismap

        'weight',         # default: 1; integer cost of stretching an edge

        # maintained for backward compatibility or rdot internal

        'id'

    ]

    # options for graph declaration

    GRAPH_OPTS = [

        'bgcolor',

        'center', 'clusterrank', 'color', 'concentrate',

        'fontcolor', 'fontname', 'fontsize',

        'label', 'layerseq',

        'margin', 'mclimit',

        'nodesep', 'nslimit',

        'ordering', 'orientation',

        'page',

        'rank', 'rankdir', 'ranksep', 'ratio',

        'size'

    ]

    # a root class for any element in dot notation

    class DOTSimpleElement

        attr_accessor :name

        def initialize (params = {})

            @label = params['name'] ? params['name'] : ''

        end

        def to_s

            @name

        end

    # an element that has options ( node, edge, or graph )

    class DOTElement < DOTSimpleElement

        # attr_reader :parent

        attr_accessor :name, :options

        def initialize (params = {}, option_list = [])

            super(params)

            @name   = params['name']   ? params['name']   : nil

            @parent = params['parent'] ? params['parent'] : nil

            @options = {}

            option_list.each{ |i|

                @options[i] = params[i] if params[i]

            }

            @options['label'] ||= @name if @name != 'node'

        end

        def each_option

            @options.each{ |i| yield i }

        end

        def each_option_pair

            @options.each_pair{ |key, val| yield key, val }

        end

        #def parent=( thing )

        #    @parent.delete( self ) if defined?( @parent ) and @parent

        #    @parent = thing

        #end

    end

    # This is used when we build nodes that have shape=record

    # ports don't have options :)

    class DOTPort < DOTSimpleElement

        attr_accessor :label

        def initialize (params = {})

            super(params)

            @name = params['label'] ? params['label'] : ''

        end

        def to_s

            ( @name && @name != "" ? "<#{@name}>" : "" ) + "#{@label}"

        end

    # node element

    class DOTNode < DOTElement

        @ports

        def initialize (params = {}, option_list = NODE_OPTS)

            super(params, option_list)

            @ports = params['ports'] ? params['ports'] : []

        end

        def each_port

            @ports.each { |i| yield i }

        end

        def << (thing)

            @ports << thing

        end

        def push (thing)

            @ports.push(thing)

        end

        def pop

            @ports.pop

        end

        def to_s (t = '')

            # This code is totally incomprehensible; it needs to be replaced!

            label = @options['shape'] != 'record' && @ports.length == 0 ?

                    @options['label'] ?

                        t + $tab + "label = \"#{@options['label']}\"\n" :

                        '' :

                    t + $tab + 'label = "' + " \\\n" +

                    t + $tab2 + "#{@options['label']}| \\\n" +

                    @ports.collect{ |i|

                        t + $tab2 + i.to_s

                    }.join( "| \\\n" ) + " \\\n" +

                    t + $tab + '"' + "\n"

                t + "#{@name} [\n" +

                @options.to_a.collect{ |i|

                    i[1] && i[0] != 'label' ?

                        t + $tab + "#{i[0]} = #{i[1]}" : nil

                }.compact.join( ",\n" ) + ( label != '' ? ",\n" : "\n" ) +

                label +

                t + "]\n"

        end

    end # class DOTNode

    # A subgraph element is the same to graph, but has another header in dot

    # notation.

    class DOTSubgraph < DOTElement

        @nodes

        @dot_string

        def initialize (params = {}, option_list = GRAPH_OPTS)

            super(params, option_list)

            @nodes      = params['nodes'] ? params['nodes'] : []

            @dot_string = 'graph'

        end

        def each_node

            @nodes.each{ |i| yield i }

        end

        def << (thing)

            @nodes << thing

        end

        def push (thing)

            @nodes.push( thing )

        end

        def pop

            @nodes.pop

        end

        def to_s (t = '')

            hdr = t + "#{@dot_string} #{@name} {\n"

            options = @options.to_a.collect{ |name, val|

                val && name != 'label' ?

                    t + $tab + "#{name} = #{val}" :

                    name ? t + $tab + "#{name} = \"#{val}\"" : nil

            }.compact.join( "\n" ) + "\n"

            nodes = @nodes.collect{ |i|

                i.to_s( t + $tab )

            }.join( "\n" ) + "\n"

            hdr + options + nodes + t + "}\n"

        end

    end # class DOTSubgraph

    # This is a graph.

    class DOTDigraph < DOTSubgraph

        super(params, option_list)

        @dot_string = 'digraph'

    end # class DOTDigraph

    # This is an edge.

    class DOTEdge < DOTElement

        attr_accessor :from, :to

        def initialize (params = {}, option_list = EDGE_OPTS)

            super(params, option_list)

            @from = params['from'] ? params['from'] : nil

            @to   = params['to'] ? params['to'] : nil

        end

        def edge_link

            '--'

        end

        def to_s (t = '')

            t + "#{@from} #{edge_link} #{to} [\n" +

                @options.to_a.collect{ |i|

                    i[1] && i[0] != 'label' ?

                        t + $tab + "#{i[0]} = #{i[1]}" :

                        i[1] ? t + $tab + "#{i[0]} = \"#{i[1]}\"" : nil

                }.compact.join( "\n" ) + "\n" + t + "]\n"

        end

    end # class DOTEdge

    class DOTDirectedEdge < DOTEdge

        def edge_link

            '->'

        end

    end # class DOTDirectedEdge

end # module DOT

    def predicate?

        to_s.include? "?" end

    def imperative?

        to_s.include? "!" end

    def writer?

        to_s.include? "=" end

    def punctuated?

        predicate? or imperative? or writer? end

    def without_punctuation

        to_s.delete("?!=").to_sym end

    def predicate

        without_punctuation.to_s + "?" end

    def imperative

        without_punctuation.to_s + "!" end

    def writer

        without_punctuation.to_s + "=" end

    def collect! (&block)

        replace Hash[*collect(&block).flatten]

    end

    def flatten

        to_a.flatten

    end

    def returning (value)

        yield value ; value

    end

    def define_hard_aliases (name_pairs)

        for new_aliases, existing_name in name_pairs do

            new_aliases.kind_of? Array or new_aliases = [new_aliases]

            for new_alias in new_aliases do

                alias_method(new_alias, existing_name)

            end

        end

    def define_soft_aliases (name_pairs)

        for new_aliases, existing_name in name_pairs do

            new_aliases.kind_of? Array or new_aliases = [new_aliases]

            for new_alias in new_aliases do

                class_eval %{def #{new_alias}(*args, &block)

                            #{existing_name}(*args, &block) end}

            end

        end

    define_soft_aliases \

        :define_hard_alias => :define_hard_aliases,

        :define_soft_alias => :define_soft_aliases

    # This method lets you define predicates like :foo?,

    # which will be defined to return the value of @foo.

    def define_readers (*names)

        for name in names.map { |x| x.to_sym } do

            if name.punctuated?

                # There's no way to define an efficient reader whose

                # name is different from the instance variable.

                class_eval %{def #{name} ; @#{name.without_punctuation} end}

            else

                # Use `attr_reader' to define an efficient method.

                attr_reader(name)

            end

        end

    def writer_defined? (name)

        method_defined? name.to_sym.writer

    # If you pass a predicate symbol :foo? to this method, it'll first

    # define a regular writer method :foo, without a question mark.

    # Then it'll define an imperative writer method :foo! as a shorthand

    # for setting the property to true.

    def define_writers (*names, &body)

        for name in names.map { |x| x.to_sym } do

            if block_given?

                define_method(name.writer, &body)

            else

                attr_writer(name.without_punctuation)

            end

            if name.predicate?

                class_eval %{def #{name.imperative}

                           self.#{name.writer} true end}

            end

        end

    end

    define_soft_aliases \

        :define_reader => :define_readers,

        :define_writer => :define_writers

    # We don't need a singular alias for `define_accessors',

    # because it always defines at least two methods.

    def define_accessors (*names)

        define_readers(*names)

        define_writers(*names)

    def define_opposite_readers (name_pairs)

        name_pairs.collect! { |k, v| [k.to_sym, v.to_sym] }

        for opposite_name, name in name_pairs do

            define_reader(name) unless method_defined? name

            class_eval %{def #{opposite_name} ; not #{name} end}

        end

    def define_opposite_writers (name_pairs)

        name_pairs.collect! { |k, v| [k.to_sym, v.to_sym] }

        for opposite_name, name in name_pairs do

            define_writer(name) unless writer_defined? name

            class_eval %{def #{opposite_name.writer} x

                         self.#{name.writer} !x end}

            class_eval %{def #{opposite_name.imperative}

                         self.#{name.writer} false end}

        end

    end

    define_soft_aliases \

        :define_opposite_reader => :define_opposite_readers,

        :define_opposite_writer => :define_opposite_writers

    def define_opposite_accessors (name_pairs)

        define_opposite_readers name_pairs

        define_opposite_writers name_pairs

    end

    def define_reader_with_opposite (name_pair, &body)

        name, opposite_name = name_pair.flatten.collect { |x| x.to_sym }

        define_method(name, &body)

        define_opposite_reader(opposite_name => name)

    end

    def define_writer_with_opposite (name_pair, &body)

        name, opposite_name = name_pair.flatten.collect { |x| x.to_sym }

        define_writer(name, &body)

        define_opposite_writer(opposite_name => name)

    end

    def define_methods (*names, &body)

        names.each { |name| define_method(name, &body) }

    end

    def define_private_methods (*names, &body)

        define_methods(*names, &body)

        names.each { |name| private name }

    end

    def define_protected_methods (*names, &body)

        define_methods(*names, &body)

        names.each { |name| protected name }

    end

    def define_private_method (name, &body)

        define_method(name, &body)

        private name

    end

    def define_protected_method (name, &body)

        define_method(name, &body)

        protected name

    end

    def initialize (attribute=nil, message=nil)

        super message

        @attribute = attribute

    end

    define_accessors :attribute

    def to_s

        if @attribute and @message

            "cannot change the value of `#@attribute': #@message"

        elsif @attribute

            "cannot change the value of `#@attribute'"

        elsif @message

            "cannot change the value of attribute: #@message"

        else

            "cannot change the value of attribute"

        end