puppet 2.6.18 → 2.7.1

data/README.queueing

@@ -1,126 +0,0 @@
-*PUPPET QUEUEING
-
-Puppet Queueing is a feature which is designed to take some load
-off of the PuppetMaster by transferring the task of updating the
-database to a separate program which is named puppetqd (Puppet
-Queue Daemon).
-
-Currently this is only supported for "Storeconfigs" which is
-documented at:
-
-http://projects.puppetlabs.com/projects/1/wiki/Using_Stored_Configuration
-
-In the future this feature can be extended to any new puppet
-data which involves storage in a database.
-
-*OPERATION
-
-In a nutshell:
-
-  puppetmasterd -> stomp -> service -> stomp -> puppetqd -> database
-
-At the moment the only messaging protocol supported is "stomp". Although
-others could be implemented, stomp is considered by many as the
-default queueing mechanism for Ruby and Rails applications. It is
-distributed as a Ruby gem and is easily installed.
-
-(The queueing code inside Puppet has been written so that when other
-interfaces and protocols are implemented they will be easy to use by
-changing settings in puppet.conf).
-
-The "service" in the diagram above is any queueing service that supports
-the Stomp API. For details refer to:
-
-  http://xircles.codehaus.org/projects/stomp
-
-Both puppetmasterd and puppetqd subscribe to the same queueing service
-using the stomp interface. As puppetmasterd posts data to the queue,
-puppetqd receives it and stores it. The details of how to connect to
-the service and the name of the queue to use are set in puppet.conf:
-
-  [main]
-    queue_type = stomp
-    queue_source = stomp://localhost:61613
-  [puppetmasterd]
-    async_storeconfigs = true
-
-Note: since puppetmasterd needs to recover the data being stored at a
-later time, both puppetmasterd and puppetqd need to work with the same
-database as defined in the STORECONFIGS setup.
-
-*QUEUEING SERVICES
-
-As mentioned previously any queueing service that supports the Stomp
-protocol can be used. Which one you use depends on your needs. We have
-tested with two of the most popular services - StompServer and ActiveMQ.
-
-+ StompServer
-
-    http://rubyforge.org/projects/stompserver/
-
-StompServer is a lightweight queueing service written in Ruby which is
-suitable for testing or low volume puppet usage. Works well when both
-puppetmasterd and puppetd are running on the same machine that it's running
-on but we encountered some problems when using it from multiple machines.
-
-Just install the stompserver gem and run 'stompserver'.
-
-+ Apache ActiveMQ
-
-    http://activemq.apache.org
-
-Considered by many to be the most popular message service in use today,
-ActiveMQ has hundreds of features for scaling, persistence and so on.
-
-Although installation is fairly simple, the configuration can seem quite
-intimidating, but for our use a one line change to the  standard configuration
-is all that is required and is explained at:
-
-    http://activemq.apache.org/stomp.html
-
-Other customization of the internal workings of ActiveMQ, if any, will depend
-on your needs and deployment. A quick skimming of the ActiveMQ documentation
-will give you enough info to decide.
-
-Others
-
-We have looked at but not tried some other queuing services which are
-compatible with the Stomp API:
-
-+ POE Component Message Queue
-+ JBoss Messaging (with 3rd party support for Stomp)
-
-*SCALING
-
-For StoreConfigs you basically need to have the catalog for a node stored
-in the database before the next time the node connects and asks for a
-new catalog.
-
-If the puppetd on your nodes is set to check every 30 minutes,
-then it would seem that there is no problem. However if you have 3000
-nodes you have a LOT of catalogs to store and it is possible you will
-not get a catalog saved in time.
-
-Running puppetmaster, your queueing service and puppetqd on the same
-machine means that they are all competing for the same CPU cycles. Bumping
-up the power of the server they are running on may be enough to handle
-even fairly large deployments.
-
-However since most queueing services (even StompServer) are designed to
-deliver messages from a "queue" to whoever asks for the next message you
-can split things up between machines:
-
-  puppetmaster1 --\             /-- puppetqd1 -\
-  puppetmaster2 ----> ActiveMQ ---> puppetqd2 ---> database
-  puppetmaster3 --/             \-- puppetqd33 -/
-                                 \- puppetqd4-/
-
-This is, of course a totally contrived example, but it gets the point
-across. As long as the data gets to the database, it doesn't matter
-which machines or services it goes through.
-
-Although for StoreConfigs absolute reliability is not a requirement as
-a new catalog will be sent the next time a node connects, some amount
-of persistence should some process crash may be desirable. Both ActiveMQ
-and MySQL (and other databases) have these kind of features built in
-which can be activated as needed.

data/ext/upload_facts.rb

@@ -1,120 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'net/https'
-require 'openssl'
-require 'openssl/x509'
-require 'optparse'
-require 'pathname'
-require 'yaml'
-
-require 'puppet'
-require 'puppet/network/http_pool'
-
-class Puppet::Application::UploadFacts < Puppet::Application
-  should_parse_config
-  run_mode :master
-
-  option('--debug', '-d')
-  option('--verbose', '-v')
-
-  option('--logdest DEST', '-l DEST') do |arg|
-    Puppet::Util::Log.newdestination(arg)
-    options[:setdest] = true
-  end
-
-  option('--minutes MINUTES', '-m MINUTES') do |minutes|
-    options[:time_limit] = 60 * minutes.to_i
-  end
-
-  def help
-    print <<HELP
-== Synopsis
-
-Upload cached facts to the inventory service.
-
-= Usage
-
-  upload_facts [-d|--debug] [-v|--verbose] [-m|--minutes <minutes>]
-               [-l|--logdest syslog|<file>|console]
-
-= Description
-
-This command will read YAML facts from the puppet master's YAML directory, and
-save them to the configured facts_terminus. It is intended to be used with the
-facts_terminus set to inventory_service, in order to ensure facts which have
-been cached locally due to a temporary failure are still uploaded to the
-inventory service.
-
-= Usage Notes
-
-upload_facts is intended to be run from cron, with the facts_terminus set to
-inventory_service. The +--minutes+ argument should be set to the length of time
-between upload_facts runs. This will ensure that only new YAML files are
-uploaded.
-
-= Options
-
-Note that any configuration parameter that's valid in the configuration file
-is also a valid long argument.  For example, 'server' is a valid configuration
-parameter, so you can specify '--server <servername>' as an argument.
-
-See the configuration file documentation at
-http://docs.puppetlabs.com/references/stable/configuration.html for
-the full list of acceptable parameters. A commented list of all
-configuration options can also be generated by running puppet agent with
-'--genconfig'.
-
-minutes::
-  Limit the upload only to YAML files which have been added within the last n
-  minutes.
-HELP
-
-    exit
-  end
-
-  def setup
-    # Handle the logging settings.
-    if options[:debug] or options[:verbose]
-      if options[:debug]
-        Puppet::Util::Log.level = :debug
-      else
-        Puppet::Util::Log.level = :info
-      end
-
-      Puppet::Util::Log.newdestination(:console) unless options[:setdest]
-    end
-
-    exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
-  end
-
-  def main
-    dir = Pathname.new(Puppet[:yamldir]) + 'facts'
-
-    cutoff = options[:time_limit] ? Time.now - options[:time_limit] : Time.at(0)
-
-    files = dir.children.select do |file|
-      file.extname == '.yaml' && file.mtime > cutoff
-    end
-
-    failed = false
-
-    terminus = Puppet::Node::Facts.indirection.terminus
-
-    files.each do |file|
-      facts = YAML.load_file(file)
-
-      request = Puppet::Indirector::Request.new(:facts, :save, facts)
-
-      # The terminus warns for us if we fail.
-      if terminus.save(request)
-        Puppet.info "Uploaded facts for #{facts.name} to inventory service"
-      else
-        failed = true
-      end
-    end
-
-    exit !failed
-  end
-end
-
-Puppet::Application::UploadFacts.new.run

data/ext/vim/ftplugin/puppet.vim

@@ -1,94 +0,0 @@
-" Vim filetype plugin
-" Language:     Puppet
-" Maintainer:   Todd Zullinger <tmz@pobox.com>
-" Last Change:  2009 Aug 19
-" vim: set sw=4 sts=4:
-
-if exists("b:did_ftplugin")
-    finish
-endif
-let b:did_ftplugin = 1
-
-if !exists("no_plugin_maps") && !exists("no_puppet_maps")
-    if !hasmapto("<Plug>AlignRange")
-        map <buffer> <LocalLeader>= <Plug>AlignRange
-    endif
-endif
-
-noremap <buffer> <unique> <script> <Plug>AlignArrows :call <SID>AlignArrows()<CR>
-noremap <buffer> <unique> <script> <Plug>AlignRange :call <SID>AlignRange()<CR>
-
-iabbrev => =><C-R>=<SID>AlignArrows('=>')<CR>
-iabbrev +> +><C-R>=<SID>AlignArrows('+>')<CR>
-
-if exists('*s:AlignArrows')
-    finish
-endif
-
-let s:arrow_re = '[=+]>'
-let s:selector_re = '[=+]>\s*\$.*\s*?\s*{\s*$'
-
-function! s:AlignArrows(op)
-    let cursor_pos = getpos('.')
-    let lnum = line('.')
-    let line = getline(lnum)
-    if line !~ s:arrow_re
-        return
-    endif
-    let pos = stridx(line, a:op)
-    let start = lnum
-    let end = lnum
-    let pnum = lnum - 1
-    while 1
-        let pline = getline(pnum)
-        if pline !~ s:arrow_re || pline =~ s:selector_re
-            break
-        endif
-        let start = pnum
-        let pnum -= 1
-    endwhile
-    let cnum = end
-    while 1
-        let cline = getline(cnum)
-        if cline !~ s:arrow_re ||
-                \ (indent(cnum) != indent(cnum+1) && getline(cnum+1) !~ '\s*}')
-            break
-        endif
-        let end = cnum
-        let cnum += 1
-    endwhile
-    call s:AlignSection(start, end)
-    let cursor_pos[2] = stridx(getline('.'), a:op) + strlen(a:op) + 1
-    call setpos('.', cursor_pos)
-    return ''
-endfunction
-
-function! s:AlignRange() range
-    call s:AlignSection(a:firstline, a:lastline)
-endfunction
-
-" AlignSection and AlignLine are from the vim wiki:
-" http://vim.wikia.com/wiki/Regex-based_text_alignment
-function! s:AlignSection(start, end)
-    let extra = 1
-    let sep = s:arrow_re
-    let maxpos = 0
-    let section = getline(a:start, a:end)
-    for line in section
-        let pos = match(line, ' *'.sep)
-        if maxpos < pos
-            let maxpos = pos
-        endif
-    endfor
-    call map(section, 's:AlignLine(v:val, sep, maxpos, extra)')
-    call setline(a:start, section)
-endfunction
-
-function! s:AlignLine(line, sep, maxpos, extra)
-    let m = matchlist(a:line, '\(.\{-}\) \{-}\('.a:sep.'.*\)')
-    if empty(m)
-        return a:line
-    endif
-    let spaces = repeat(' ', a:maxpos - strlen(m[1]) + a:extra)
-    return m[1] . spaces . m[2]
-endfunction

data/ext/vim/indent/puppet.vim

@@ -1,76 +0,0 @@
-" Vim indent file
-" Language:	Puppet
-" Maintainer:	Todd Zullinger <tmz@pobox.com>
-" Last Change:	2009 Aug 19
-" vim: set sw=4 sts=4:
-
-if exists("b:did_indent")
-    finish
-endif
-let b:did_indent = 1
-
-setlocal autoindent smartindent
-setlocal indentexpr=GetPuppetIndent()
-setlocal indentkeys+=0],0)
-
-if exists("*GetPuppetIndent")
-    finish
-endif
-
-" Check if a line is part of an include 'block', e.g.:
-"   include foo,
-"       bar,
-"       baz
-function! s:PartOfInclude(lnum)
-    let lnum = a:lnum
-    while lnum
-        let lnum = lnum - 1
-        let line = getline(lnum)
-        if line !~ ',$'
-            break
-        endif
-        if line =~ '^\s*include\s\+[^,]\+,$'
-            return 1
-        endif
-    endwhile
-    return 0
-endfunction
-
-function! s:OpenBrace(lnum)
-    call cursor(a:lnum, 1)
-    return searchpair('{\|\[\|(', '', '}\|\]\|)', 'nbW')
-endfunction
-
-function! GetPuppetIndent()
-    let pnum = prevnonblank(v:lnum - 1)
-    if pnum == 0
-       return 0
-    endif
-
-    let line = getline(v:lnum)
-    let pline = getline(pnum)
-    let ind = indent(pnum)
-
-    if pline =~ '^\s*#'
-        return ind
-    endif
-
-    if pline =~ '\({\|\[\|(\|:\)$'
-        let ind += &sw
-    elseif pline =~ ';$' && pline !~ '[^:]\+:.*[=+]>.*'
-        let ind -= &sw
-    elseif pline =~ '^\s*include\s\+.*,$'
-        let ind += &sw
-    endif
-
-    if pline !~ ',$' && s:PartOfInclude(pnum)
-        let ind -= &sw
-    endif
-
-    " Match } }, }; ] ]: )
-    if line =~ '^\s*\(}\(,\|;\)\?$\|]:\?$\|)\)'
-        let ind = indent(s:OpenBrace(v:lnum))
-    endif
-
-    return ind
-endfunction

data/lib/puppet/indirector/errors.rb

@@ -1,5 +0,0 @@
-require 'puppet/error'
-
-module Puppet::Indirector
-  class ValidationError < Puppet::Error; end
-end

data/lib/puppet/indirector/facts/inventory_service.rb

@@ -1,20 +0,0 @@
-require 'puppet/node/facts'
-require 'puppet/indirector/rest'
-
-class Puppet::Node::Facts::InventoryService < Puppet::Indirector::REST
-  desc "Find and save facts about nodes using a remote inventory service."
-  use_server_setting(:inventory_server)
-  use_port_setting(:inventory_port)
-
-  # We don't want failing to upload to the inventory service to cause any
-  # failures, so we just suppress them and warn.
-  def save(request)
-    begin
-      super
-      true
-    rescue => e
-      Puppet.warning "Could not upload facts for #{request.key} to inventory service: #{e.to_s}"
-      false
-    end
-  end
-end

data/lib/puppet/indirector/file_bucket_file/selector.rb

@@ -1,53 +0,0 @@
-require 'puppet/indirector/code'
-
-module Puppet::FileBucketFile
-  class Selector < Puppet::Indirector::Code
-    desc "Select the terminus based on the request"
-
-    def select(request)
-      if request.protocol == 'https'
-        :rest
-      else
-        :file
-      end
-    end
-
-    def get_terminus(request)
-      indirection.terminus(select(request))
-    end
-
-    def head(request)
-      get_terminus(request).head(request)
-    end
-
-    def find(request)
-      get_terminus(request).find(request)
-    end
-
-    def save(request)
-      get_terminus(request).save(request)
-    end
-
-    def search(request)
-      get_terminus(request).search(request)
-    end
-
-    def destroy(request)
-      get_terminus(request).destroy(request)
-    end
-
-    def authorized?(request)
-      terminus = get_terminus(request)
-      if terminus.respond_to?(:authorized?)
-        terminus.authorized?(request)
-      else
-        true
-      end
-    end
-
-    def validate_key(request)
-      get_terminus(request).validate(request)
-    end
-  end
-end
-