IF:seccomment
ENDIF:seccomment
ENDIF:sectitle
END:sections
}
METHOD_LIST = %{
IF:sectitle
IF:seccomment
ENDIF:seccomment
ENDIF:sectitle
IF:facts
Custom Facts
START:facts
HREF:aref:name:
END:facts
ENDIF:facts
IF:plugins
Plugins
START:plugins
HREF:aref:name:
END:plugins
ENDIF:plugins
IF:nodelist
Nodes
%nodelist%
ENDIF:nodelist
IF:classlist
Classes and Modules
%classlist%
ENDIF:classlist
IF:constants
Global Variables
START:constants
%name%
=
%value%
IF:desc
%desc%
ENDIF:desc
END:constants
ENDIF:constants
IF:aliases
External Aliases
START:aliases
%old_name%
->
%new_name%
IF:desc
%desc%
ENDIF:desc
END:aliases
ENDIF:aliases
IF:attributes
Attributes
START:attributes
%name%
IF:rw
[%rw%]
ENDIF:rw
IFNOT:rw
ENDIF:rw
%a_desc%
END:attributes
ENDIF:attributes
IF:method_list
START:method_list
IF:methods
Defines
START:methods
IF:m_desc
%m_desc%
ENDIF:m_desc
IF:sourcecode
[Source]
ENDIF:sourcecode
END:methods
ENDIF:methods
END:method_list
ENDIF:method_list
IF:resource_list
Resources
START:resource_list
%name% %name% => %value%
IF:m_desc
%m_desc%
ENDIF:m_desc
END:resource_list
ENDIF:resource_list
END:sections
}
#####################################################################
### B O D Y T E M P L A T E
#####################################################################
BODY = HEADER + %{
!INCLUDE!
} + METHOD_LIST + %{
} + FOOTER
BODYINC = HEADER + %{
!INCLUDE!
!INCLUDE!
} + FOOTER
#####################################################################
### S O U R C E C O D E T E M P L A T E
#####################################################################
SRC_PAGE = XHTML_PREAMBLE + %{
%title%
%code%
}
#####################################################################
### I N D E X F I L E T E M P L A T E S
#####################################################################
FR_INDEX_BODY = %{
!INCLUDE!
}
FILE_INDEX = XHTML_PREAMBLE + %{
%list_title%
%list_title%
START:entries
%name%
END:entries
}
TOP_INDEX = XHTML_PREAMBLE + %{
%list_title%
%list_title%
START:entries
%name%
END:entries
}
CLASS_INDEX = FILE_INDEX
METHOD_INDEX = FILE_INDEX
COMBO_INDEX = XHTML_PREAMBLE + %{
%classes_title% & %defines_title%
IF:nodes
%nodes_title%
ENDIF:nodes
IF:classes
%classes_title%
START:classes
%name%
END:classes
ENDIF:classes
IF:defines
%defines_title%
START:defines
%name%
END:defines
ENDIF:defines
IF:facts
%facts_title%
ENDIF:facts
IF:plugins
%plugins_title%
START:plugins
%name%
END:plugins
ENDIF:plugins
}
INDEX = %{
%title%
}
end # module Page
end # class RDoc
require 'rdoc/generators/template/html/one_page_html'
puppet-3.4.3/lib/puppet/util/rdoc.rb 0000644 0052762 0001160 00000005123 12300765631 017246 0 ustar jenkins jenkins require 'puppet/util'
module Puppet::Util::RDoc
module_function
# launch a rdoc documenation process
# with the files/dir passed in +files+
def rdoc(outputdir, files, charset = nil)
Puppet[:ignoreimport] = true
# then rdoc
require 'rdoc/rdoc'
require 'rdoc/options'
# load our parser
require 'puppet/util/rdoc/parser'
r = RDoc::RDoc.new
if Puppet.features.rdoc1?
RDoc::RDoc::GENERATORS["puppet"] = RDoc::RDoc::Generator.new(
"puppet/util/rdoc/generators/puppet_generator.rb",
:PuppetGenerator,
"puppet"
)
end
# specify our own format & where to output
options = [ "--fmt", "puppet",
"--quiet",
"--exclude", "/modules/[^/]*/spec/.*$",
"--exclude", "/modules/[^/]*/files/.*$",
"--exclude", "/modules/[^/]*/tests/.*$",
"--exclude", "/modules/[^/]*/templates/.*$",
"--op", outputdir ]
if !Puppet.features.rdoc1? || ::Options::OptionList.options.any? { |o| o[0] == "--force-update" } # Options is a root object in the rdoc1 namespace...
options << "--force-update"
end
options += [ "--charset", charset] if charset
options += files
# launch the documentation process
r.document(options)
end
# launch an output to console manifest doc
def manifestdoc(files)
Puppet[:ignoreimport] = true
files.select { |f| FileTest.file?(f) }.each do |f|
parser = Puppet::Parser::Parser.new(Puppet::Node::Environment.new(Puppet[:environment]))
parser.file = f
ast = parser.parse
output(f, ast)
end
end
# Ouputs to the console the documentation
# of a manifest
def output(file, ast)
astobj = []
ast.instantiate('').each do |resource_type|
astobj << resource_type if resource_type.file == file
end
astobj.sort! {|a,b| a.line <=> b.line }.each do |k|
output_astnode_doc(k)
end
end
def output_astnode_doc(ast)
puts ast.doc if !ast.doc.nil? and !ast.doc.empty?
if Puppet.settings[:document_all]
# scan each underlying resources to produce documentation
code = ast.code.children if ast.code.is_a?(Puppet::Parser::AST::ASTArray)
code ||= ast.code
output_resource_doc(code) unless code.nil?
end
end
def output_resource_doc(code)
code.sort { |a,b| a.line <=> b.line }.each do |stmt|
output_resource_doc(stmt.children) if stmt.is_a?(Puppet::Parser::AST::ASTArray)
if stmt.is_a?(Puppet::Parser::AST::Resource)
puts stmt.doc if !stmt.doc.nil? and !stmt.doc.empty?
end
end
end
end
puppet-3.4.3/lib/puppet/util/adsi.rb 0000644 0052762 0001160 00000022561 12300765631 017244 0 ustar jenkins jenkins module Puppet::Util::ADSI
class << self
def connectable?(uri)
begin
!! connect(uri)
rescue
false
end
end
def connect(uri)
begin
WIN32OLE.connect(uri)
rescue Exception => e
raise Puppet::Error.new( "ADSI connection error: #{e}" )
end
end
def create(name, resource_type)
Puppet::Util::ADSI.connect(computer_uri).Create(resource_type, name)
end
def delete(name, resource_type)
Puppet::Util::ADSI.connect(computer_uri).Delete(resource_type, name)
end
def computer_name
unless @computer_name
buf = " " * 128
Win32API.new('kernel32', 'GetComputerName', ['P','P'], 'I').call(buf, buf.length.to_s)
@computer_name = buf.unpack("A*")[0]
end
@computer_name
end
def computer_uri(host = '.')
"WinNT://#{host}"
end
def wmi_resource_uri( host = '.' )
"winmgmts:{impersonationLevel=impersonate}!//#{host}/root/cimv2"
end
def sid_uri(sid)
raise Puppet::Error.new( "Must use a valid SID object" ) if !sid.kind_of?(Win32::Security::SID)
"WinNT://#{sid.to_s}"
end
def uri(resource_name, resource_type, host = '.')
"#{computer_uri(host)}/#{resource_name},#{resource_type}"
end
def wmi_connection
connect(wmi_resource_uri)
end
def execquery(query)
wmi_connection.execquery(query)
end
def sid_for_account(name)
Puppet.deprecation_warning "Puppet::Util::ADSI.sid_for_account is deprecated and will be removed in 3.0, use Puppet::Util::Windows::SID.name_to_sid instead."
Puppet::Util::Windows::Security.name_to_sid(name)
end
end
class User
extend Enumerable
attr_accessor :native_user
attr_reader :name, :sid
def initialize(name, native_user = nil)
@name = name
@native_user = native_user
end
def self.parse_name(name)
if name =~ /\//
raise Puppet::Error.new( "Value must be in DOMAIN\\user style syntax" )
end
matches = name.scan(/((.*)\\)?(.*)/)
domain = matches[0][1] || '.'
account = matches[0][2]
return account, domain
end
def native_user
@native_user ||= Puppet::Util::ADSI.connect(self.class.uri(*self.class.parse_name(@name)))
end
def sid
@sid ||= Puppet::Util::Windows::Security.octet_string_to_sid_object(native_user.objectSID)
end
def self.uri(name, host = '.')
host = '.' if ['NT AUTHORITY', 'BUILTIN', Socket.gethostname].include?(host)
Puppet::Util::ADSI.uri(name, 'user', host)
end
def uri
self.class.uri(sid.account, sid.domain)
end
def self.logon(name, password)
Puppet::Util::Windows::User.password_is?(name, password)
end
def [](attribute)
native_user.Get(attribute)
end
def []=(attribute, value)
native_user.Put(attribute, value)
end
def commit
begin
native_user.SetInfo unless native_user.nil?
rescue Exception => e
raise Puppet::Error.new( "User update failed: #{e}" )
end
self
end
def password_is?(password)
self.class.logon(name, password)
end
def add_flag(flag_name, value)
flag = native_user.Get(flag_name) rescue 0
native_user.Put(flag_name, flag | value)
commit
end
def password=(password)
native_user.SetPassword(password)
commit
fADS_UF_DONT_EXPIRE_PASSWD = 0x10000
add_flag("UserFlags", fADS_UF_DONT_EXPIRE_PASSWD)
end
def groups
# WIN32OLE objects aren't enumerable, so no map
groups = []
native_user.Groups.each {|g| groups << g.Name} rescue nil
groups
end
def add_to_groups(*group_names)
group_names.each do |group_name|
Puppet::Util::ADSI::Group.new(group_name).add_member_sids(sid)
end
end
alias add_to_group add_to_groups
def remove_from_groups(*group_names)
group_names.each do |group_name|
Puppet::Util::ADSI::Group.new(group_name).remove_member_sids(sid)
end
end
alias remove_from_group remove_from_groups
def set_groups(desired_groups, minimum = true)
return if desired_groups.nil? or desired_groups.empty?
desired_groups = desired_groups.split(',').map(&:strip)
current_groups = self.groups
# First we add the user to all the groups it should be in but isn't
groups_to_add = desired_groups - current_groups
add_to_groups(*groups_to_add)
# Then we remove the user from all groups it is in but shouldn't be, if
# that's been requested
groups_to_remove = current_groups - desired_groups
remove_from_groups(*groups_to_remove) unless minimum
end
def self.create(name)
# Windows error 1379: The specified local group already exists.
raise Puppet::Error.new( "Cannot create user if group '#{name}' exists." ) if Puppet::Util::ADSI::Group.exists? name
new(name, Puppet::Util::ADSI.create(name, 'user'))
end
def self.exists?(name)
Puppet::Util::ADSI::connectable?(User.uri(*User.parse_name(name)))
end
def self.delete(name)
Puppet::Util::ADSI.delete(name, 'user')
end
def self.each(&block)
wql = Puppet::Util::ADSI.execquery('select name from win32_useraccount where localaccount = "TRUE"')
users = []
wql.each do |u|
users << new(u.name)
end
users.each(&block)
end
end
class UserProfile
def self.delete(sid)
begin
Puppet::Util::ADSI.wmi_connection.Delete("Win32_UserProfile.SID='#{sid}'")
rescue => e
# http://social.technet.microsoft.com/Forums/en/ITCG/thread/0f190051-ac96-4bf1-a47f-6b864bfacee5
# Prior to Vista SP1, there's no builtin way to programmatically
# delete user profiles (except for delprof.exe). So try to delete
# but warn if we fail
raise e unless e.message.include?('80041010')
Puppet.warning "Cannot delete user profile for '#{sid}' prior to Vista SP1"
end
end
end
class Group
extend Enumerable
attr_accessor :native_group
attr_reader :name
def initialize(name, native_group = nil)
@name = name
@native_group = native_group
end
def uri
self.class.uri(name)
end
def self.uri(name, host = '.')
Puppet::Util::ADSI.uri(name, 'group', host)
end
def native_group
@native_group ||= Puppet::Util::ADSI.connect(uri)
end
def commit
begin
native_group.SetInfo unless native_group.nil?
rescue Exception => e
raise Puppet::Error.new( "Group update failed: #{e}" )
end
self
end
def self.name_sid_hash(names)
return [] if names.nil? or names.empty?
sids = names.map do |name|
sid = Puppet::Util::Windows::Security.name_to_sid_object(name)
raise Puppet::Error.new( "Could not resolve username: #{name}" ) if !sid
[sid.to_s, sid]
end
Hash[ sids ]
end
def add_members(*names)
Puppet.deprecation_warning('Puppet::Util::ADSI::Group#add_members is deprecated; please use Puppet::Util::ADSI::Group#add_member_sids')
sids = self.class.name_sid_hash(names)
add_member_sids(*sids.values)
end
alias add_member add_members
def remove_members(*names)
Puppet.deprecation_warning('Puppet::Util::ADSI::Group#remove_members is deprecated; please use Puppet::Util::ADSI::Group#remove_member_sids')
sids = self.class.name_sid_hash(names)
remove_member_sids(*sids.values)
end
alias remove_member remove_members
def add_member_sids(*sids)
sids.each do |sid|
native_group.Add(Puppet::Util::ADSI.sid_uri(sid))
end
end
def remove_member_sids(*sids)
sids.each do |sid|
native_group.Remove(Puppet::Util::ADSI.sid_uri(sid))
end
end
def members
# WIN32OLE objects aren't enumerable, so no map
members = []
native_group.Members.each {|m| members << m.Name}
members
end
def member_sids
sids = []
native_group.Members.each do |m|
sids << Puppet::Util::Windows::Security.octet_string_to_sid_object(m.objectSID)
end
sids
end
def set_members(desired_members)
return if desired_members.nil? or desired_members.empty?
current_hash = Hash[ self.member_sids.map { |sid| [sid.to_s, sid] } ]
desired_hash = self.class.name_sid_hash(desired_members)
# First we add all missing members
members_to_add = (desired_hash.keys - current_hash.keys).map { |sid| desired_hash[sid] }
add_member_sids(*members_to_add)
# Then we remove all extra members
members_to_remove = (current_hash.keys - desired_hash.keys).map { |sid| current_hash[sid] }
remove_member_sids(*members_to_remove)
end
def self.create(name)
# Windows error 2224: The account already exists.
raise Puppet::Error.new( "Cannot create group if user '#{name}' exists." ) if Puppet::Util::ADSI::User.exists? name
new(name, Puppet::Util::ADSI.create(name, 'group'))
end
def self.exists?(name)
Puppet::Util::ADSI.connectable?(Group.uri(name))
end
def self.delete(name)
Puppet::Util::ADSI.delete(name, 'group')
end
def self.each(&block)
wql = Puppet::Util::ADSI.execquery( 'select name from win32_group where localaccount = "TRUE"' )
groups = []
wql.each do |g|
groups << new(g.name)
end
groups.each(&block)
end
end
end
puppet-3.4.3/lib/puppet/util/tag_set.rb 0000644 0052762 0001160 00000000652 12300765631 017747 0 ustar jenkins jenkins require 'set'
class Puppet::Util::TagSet < Set
def self.from_yaml(yaml)
self.new(YAML.load(yaml))
end
def to_yaml
@hash.keys.to_yaml
end
def self.from_pson(data)
self.new(data)
end
def to_pson(*args)
to_a.to_pson
end
# this makes puppet serialize it as an array for backwards
# compatibility
def to_zaml(z)
to_a.to_zaml(z)
end
def join(*args)
to_a.join(*args)
end
end
puppet-3.4.3/lib/puppet/util/json_lockfile.rb 0000644 0052762 0001160 00000003253 12300765631 021142 0 ustar jenkins jenkins require 'puppet/util/lockfile'
# This class provides a simple API for managing a lock file
# whose contents are a serialized JSON object. In addition
# to querying the basic state (#locked?) of the lock, managing
# the lock (#lock, #unlock), the contents can be retrieved at
# any time while the lock is held (#lock_data). This can be
# used to store structured data (state messages, etc.) about
# the lock.
#
# @see Puppet::Util::Lockfile
class Puppet::Util::JsonLockfile < Puppet::Util::Lockfile
# Lock the lockfile. You may optionally pass a data object, which will be
# retrievable for the duration of time during which the file is locked.
#
# @param [Hash] lock_data an optional Hash of data to associate with the lock.
# This may be used to store pids, descriptive messages, etc. The
# data may be retrieved at any time while the lock is held by
# calling the #lock_data method.
NOTE that the JSON serialization
# does NOT support Symbol objects--if you pass them in, they will be
# serialized as Strings, so you should plan accordingly.
# @return [boolean] true if lock is successfully acquired, false otherwise.
def lock(lock_data = nil)
return false if locked?
super(lock_data.to_pson)
end
# Retrieve the (optional) lock data that was specified at the time the file
# was locked.
# @return [Object] the data object. Remember that the serialization does not
# support Symbol objects, so if your data Object originally contained symbols,
# they will be converted to Strings.
def lock_data
return nil unless file_locked?
file_contents = super
return nil if file_contents.nil?
PSON.parse(file_contents)
end
end
puppet-3.4.3/lib/puppet/util/pson.rb 0000644 0052762 0001160 00000001203 12300765631 017271 0 ustar jenkins jenkins # A simple module to provide consistency between how we use PSON and how
# ruby expects it to be used. Basically, we don't want to require
# that the sender specify a class.
# Ruby wants everyone to provide a 'type' field, and the PSON support
# requires such a field to track the class down. Because we use our URL to
# figure out what class we're working on, we don't need that, and we don't want
# our consumers and producers to need to know anything about our internals.
module Puppet::Util::Pson
def pson_create(pson)
raise ArgumentError, "No data provided in pson data" unless pson['data']
from_pson(pson['data'])
end
end
puppet-3.4.3/lib/puppet/util/network_device.rb 0000644 0052762 0001160 00000000745 12300765631 021334 0 ustar jenkins jenkins 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, device.options)
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
puppet-3.4.3/lib/puppet/util/ldap/ 0000755 0052762 0001160 00000000000 12300765640 016711 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/util/ldap/generator.rb 0000644 0052762 0001160 00000001252 12300765631 021224 0 ustar jenkins jenkins require 'puppet/util/ldap'
class Puppet::Util::Ldap::Generator
# Declare the attribute we'll use to generate the value.
def from(source)
@source = source
self
end
# Actually do the generation.
def generate(value = nil)
if value.nil?
@generator.call
else
@generator.call(value)
end
end
# Initialize our generator with the name of the parameter
# being generated.
def initialize(name)
@name = name
end
def name
@name.to_s
end
def source
if @source
@source.to_s
else
nil
end
end
# Provide the code that does the generation.
def with(&block)
@generator = block
self
end
end
puppet-3.4.3/lib/puppet/util/ldap/connection.rb 0000644 0052762 0001160 00000003356 12300765631 021404 0 ustar jenkins jenkins require 'puppet/util/ldap'
require 'puppet/util/methodhelper'
class Puppet::Util::Ldap::Connection
include Puppet::Util::MethodHelper
attr_accessor :host, :port, :user, :password, :reset, :ssl
attr_reader :connection
# Return a default connection, using our default settings.
def self.instance
ssl = if Puppet[:ldaptls]
:tls
elsif Puppet[:ldapssl]
true
else
false
end
options = {}
options[:ssl] = ssl
if user = Puppet.settings[:ldapuser] and user != ""
options[:user] = user
if pass = Puppet.settings[:ldappassword] and pass != ""
options[:password] = pass
end
end
new(Puppet[:ldapserver], Puppet[:ldapport], options)
end
def close
connection.unbind if connection.bound?
end
def initialize(host, port, options = {})
raise Puppet::Error, "Could not set up LDAP Connection: Missing ruby/ldap libraries" unless Puppet.features.ldap?
@host, @port = host, port
set_options(options)
end
# Create a per-connection unique name.
def name
[host, port, user, password, ssl].collect { |p| p.to_s }.join("/")
end
# Should we reset the connection?
def reset?
reset
end
# Start our ldap connection.
def start
case ssl
when :tls
@connection = LDAP::SSLConn.new(host, port, true)
when true
@connection = LDAP::SSLConn.new(host, port)
else
@connection = LDAP::Conn.new(host, port)
end
@connection.set_option(LDAP::LDAP_OPT_PROTOCOL_VERSION, 3)
@connection.set_option(LDAP::LDAP_OPT_REFERRALS, LDAP::LDAP_OPT_ON)
@connection.simple_bind(user, password)
rescue => detail
raise Puppet::Error, "Could not connect to LDAP: #{detail}"
end
end
puppet-3.4.3/lib/puppet/util/ldap/manager.rb 0000644 0052762 0001160 00000016661 12300765631 020662 0 ustar jenkins jenkins require 'puppet/util/ldap'
require 'puppet/util/ldap/connection'
require 'puppet/util/ldap/generator'
# The configuration class for LDAP providers, plus
# connection handling for actually interacting with ldap.
class Puppet::Util::Ldap::Manager
attr_reader :objectclasses, :puppet2ldap, :location, :rdn
# A null-op that just returns the config.
def and
self
end
# Set the offset from the search base and return the config.
def at(location)
@location = location
self
end
# The basic search base.
def base
[location, Puppet[:ldapbase]].join(",")
end
# Convert the name to a dn, then pass the args along to
# our connection.
def create(name, attributes)
attributes = attributes.dup
# Add the objectclasses
attributes["objectClass"] = objectclasses.collect { |o| o.to_s }
attributes["objectClass"] << "top" unless attributes["objectClass"].include?("top")
attributes[rdn.to_s] = [name]
# Generate any new values we might need.
generate(attributes)
# And create our resource.
connect { |conn| conn.add dn(name), attributes }
end
# Open, yield, and close the connection. Cannot be left
# open, at this point.
def connect
raise ArgumentError, "You must pass a block to #connect" unless block_given?
unless @connection
if Puppet[:ldaptls]
ssl = :tls
elsif Puppet[:ldapssl]
ssl = true
else
ssl = false
end
options = {:ssl => ssl}
if user = Puppet[:ldapuser] and user != ""
options[:user] = user
end
if password = Puppet[:ldappassword] and password != ""
options[:password] = password
end
@connection = Puppet::Util::Ldap::Connection.new(Puppet[:ldapserver], Puppet[:ldapport], options)
end
@connection.start
begin
yield @connection.connection
ensure
@connection.close
end
nil
end
# Convert the name to a dn, then pass the args along to
# our connection.
def delete(name)
connect { |connection| connection.delete dn(name) }
end
# Calculate the dn for a given resource.
def dn(name)
["#{rdn}=#{name}", base].join(",")
end
# Convert an ldap-style entry hash to a provider-style hash.
def entry2provider(entry)
raise ArgumentError, "Could not get dn from ldap entry" unless entry["dn"]
# DN is always a single-entry array. Strip off the bits before the
# first comma, then the bits after the remaining equal sign. This is the
# name.
name = entry["dn"].dup.pop.split(",").shift.split("=").pop
result = {:name => name}
@ldap2puppet.each do |ldap, puppet|
result[puppet] = entry[ldap.to_s] || :absent
end
result
end
# Create our normal search filter.
def filter
return(objectclasses.length == 1 ? "objectclass=#{objectclasses[0]}" : "(&(objectclass=" + objectclasses.join(")(objectclass=") + "))")
end
# Find the associated entry for a resource. Returns a hash, minus
# 'dn', or nil if the entry cannot be found.
def find(name)
connect do |conn|
begin
conn.search2(dn(name), 0, "objectclass=*") do |result|
# Convert to puppet-appropriate attributes
return entry2provider(result)
end
rescue
return nil
end
end
end
# Declare a new attribute generator.
def generates(parameter)
@generators << Puppet::Util::Ldap::Generator.new(parameter)
@generators[-1]
end
# Generate any extra values we need to make the ldap entry work.
def generate(values)
return unless @generators.length > 0
@generators.each do |generator|
# Don't override any values that might exist.
next if values[generator.name]
if generator.source
unless value = values[generator.source]
raise ArgumentError, "#{generator.source} must be defined to generate #{generator.name}"
end
result = generator.generate(value)
else
result = generator.generate
end
result = [result] unless result.is_a?(Array)
result = result.collect { |r| r.to_s }
values[generator.name] = result
end
end
def initialize
@rdn = :cn
@generators = []
end
# Specify what classes this provider models.
def manages(*classes)
@objectclasses = classes
self
end
# Specify the attribute map. Assumes the keys are the puppet
# attributes, and the values are the ldap attributes, and creates a map
# for each direction.
def maps(attributes)
# The map with the puppet attributes as the keys
@puppet2ldap = attributes
# and the ldap attributes as the keys.
@ldap2puppet = attributes.inject({}) { |map, ary| map[ary[1]] = ary[0]; map }
self
end
# Return the ldap name for a puppet attribute.
def ldap_name(attribute)
@puppet2ldap[attribute].to_s
end
# Convert the name to a dn, then pass the args along to
# our connection.
def modify(name, mods)
connect { |connection| connection.modify dn(name), mods }
end
# Specify the rdn that we use to build up our dn.
def named_by(attribute)
@rdn = attribute
self
end
# Return the puppet name for an ldap attribute.
def puppet_name(attribute)
@ldap2puppet[attribute]
end
# Search for all entries at our base. A potentially expensive search.
def search(sfilter = nil)
sfilter ||= filter
result = []
connect do |conn|
conn.search2(base, 1, sfilter) do |entry|
result << entry2provider(entry)
end
end
return(result.empty? ? nil : result)
end
# Update the ldap entry with the desired state.
def update(name, is, should)
if should[:ensure] == :absent
Puppet.info "Removing #{dn(name)} from ldap"
delete(name)
return
end
# We're creating a new entry
if is.empty? or is[:ensure] == :absent
Puppet.info "Creating #{dn(name)} in ldap"
# Remove any :absent params and :ensure, then convert the names to ldap names.
attrs = ldap_convert(should)
create(name, attrs)
return
end
# We're modifying an existing entry. Yuck.
mods = []
# For each attribute we're deleting that is present, create a
# modify instance for deletion.
[is.keys, should.keys].flatten.uniq.each do |property|
# They're equal, so do nothing.
next if is[property] == should[property]
attributes = ldap_convert(should)
prop_name = ldap_name(property).to_s
# We're creating it.
if is[property] == :absent or is[property].nil?
mods << LDAP::Mod.new(LDAP::LDAP_MOD_ADD, prop_name, attributes[prop_name])
next
end
# We're deleting it
if should[property] == :absent or should[property].nil?
mods << LDAP::Mod.new(LDAP::LDAP_MOD_DELETE, prop_name, [])
next
end
# We're replacing an existing value
mods << LDAP::Mod.new(LDAP::LDAP_MOD_REPLACE, prop_name, attributes[prop_name])
end
modify(name, mods)
end
# Is this a complete ldap configuration?
def valid?
location and objectclasses and ! objectclasses.empty? and puppet2ldap
end
private
# Convert a hash of attributes to ldap-like forms. This mostly means
# getting rid of :ensure and making sure everything's an array of strings.
def ldap_convert(attributes)
attributes.reject { |param, value| value == :absent or param == :ensure }.inject({}) do |result, ary|
value = (ary[1].is_a?(Array) ? ary[1] : [ary[1]]).collect { |v| v.to_s }
result[ldap_name(ary[0])] = value
result
end
end
end
puppet-3.4.3/lib/puppet/util/http_proxy.rb 0000644 0052762 0001160 00000001321 12300765631 020533 0 ustar jenkins jenkins module Puppet::Util::HttpProxy
def self.http_proxy_env
# Returns a URI object if proxy is set, or nil
proxy_env = ENV["http_proxy"] || ENV["HTTP_PROXY"]
begin
return URI.parse(proxy_env) if proxy_env
rescue URI::InvalidURIError
return nil
end
return nil
end
def self.http_proxy_host
env = self.http_proxy_env
if env and env.host then
return env.host
end
if Puppet.settings[:http_proxy_host] == 'none'
return nil
end
return Puppet.settings[:http_proxy_host]
end
def self.http_proxy_port
env = self.http_proxy_env
if env and env.port then
return env.port
end
return Puppet.settings[:http_proxy_port]
end
end
puppet-3.4.3/lib/puppet/util/instrumentation/ 0000755 0052762 0001160 00000000000 12300765640 021234 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/util/instrumentation/data.rb 0000644 0052762 0001160 00000001710 12300765631 022471 0 ustar jenkins jenkins require 'puppet/indirector'
require 'puppet/util/instrumentation'
# This is just a transport class to be used through the instrumentation_data
# indirection. All the data resides in the real underlying listeners which this
# class delegates to.
class Puppet::Util::Instrumentation::Data
extend Puppet::Indirector
indirects :instrumentation_data, :terminus_class => :local
attr_reader :listener
def initialize(listener_name)
@listener = Puppet::Util::Instrumentation[listener_name]
raise "Listener #{listener_name} wasn't registered" unless @listener
end
def name
@listener.name
end
def to_data_hash
{ :name => name }.merge(@listener.respond_to?(:data) ? @listener.data : {})
end
def to_pson_data_hash
{
'document_type' => "Puppet::Util::Instrumentation::Data",
'data' => to_data_hash,
}
end
def to_pson(*args)
to_pson_data_hash.to_pson(*args)
end
def self.from_pson(data)
data
end
end
puppet-3.4.3/lib/puppet/util/instrumentation/listener.rb 0000644 0052762 0001160 00000002751 12300765631 023413 0 ustar jenkins jenkins require 'puppet/indirector'
require 'puppet/util/instrumentation'
require 'puppet/util/instrumentation/data'
class Puppet::Util::Instrumentation::Listener
include Puppet::Util
include Puppet::Util::Warnings
extend Puppet::Indirector
indirects :instrumentation_listener, :terminus_class => :local
attr_reader :pattern, :listener
attr_accessor :enabled
def initialize(listener, pattern = nil, enabled = false)
@pattern = pattern.is_a?(Symbol) ? pattern.to_s : pattern
raise "Listener isn't a correct listener (it doesn't provide the notify method)" unless listener.respond_to?(:notify)
@listener = listener
@enabled = enabled
end
def notify(label, event, data)
listener.notify(label, event, data)
rescue => e
warnonce("Error during instrumentation notification: #{e}")
end
def listen_to?(label)
enabled? and (!@pattern || @pattern === label.to_s)
end
def enabled?
!!@enabled
end
def name
@listener.name.to_s
end
def data
{ :data => @listener.data }
end
def to_data_hash
{
:name => name,
:pattern => pattern,
:enabled => enabled?
}
end
def to_pson_data_hash
{
:document_type => "Puppet::Util::Instrumentation::Listener",
:data => to_data_hash,
}
end
def to_pson(*args)
to_pson_data_hash.to_pson(*args)
end
def self.from_pson(data)
result = Puppet::Util::Instrumentation[data["name"]]
self.new(result.listener, result.pattern, data["enabled"])
end
end
puppet-3.4.3/lib/puppet/util/instrumentation/indirection_probe.rb 0000644 0052762 0001160 00000001454 12300765631 025263 0 ustar jenkins jenkins require 'puppet/indirector'
require 'puppet/util/instrumentation'
# We need to use a class other than Probe for the indirector because
# the Indirection class might declare some probes, and this would be a huge unbreakable
# dependency cycle.
class Puppet::Util::Instrumentation::IndirectionProbe
extend Puppet::Indirector
indirects :instrumentation_probe, :terminus_class => :local
attr_reader :probe_name
def initialize(probe_name)
@probe_name = probe_name
end
def to_data_hash
{ :name => probe_name }
end
def to_pson_data_hash
{
:document_type => "Puppet::Util::Instrumentation::IndirectionProbe",
:data => to_data_hash,
}
end
def to_pson(*args)
to_pson_data_hash.to_pson(*args)
end
def self.from_pson(data)
self.new(data["name"])
end
end
puppet-3.4.3/lib/puppet/util/instrumentation/instrumentable.rb 0000644 0052762 0001160 00000007374 12300765631 024630 0 ustar jenkins jenkins require 'puppet/util/instrumentation'
# This is the central point of all declared probes.
# Every class needed to declare probes should include this module
# and declare the methods that are subject to instrumentation:
#
# class MyClass
# extend Puppet::Util::Instrumentation::Instrumentable
#
# probe :mymethod
#
# def mymethod
# ... this is code to be instrumented ...
# end
# end
module Puppet::Util::Instrumentation::Instrumentable
INSTRUMENTED_CLASSES = {}
attr_reader :probes
class Probe
attr_reader :klass, :method, :label, :data
def initialize(method, klass, options = {})
@method = method
@klass = klass
@label = options[:label] || method
@data = options[:data] || {}
end
def enable
raise "Probe already enabled" if enabled?
# We're forced to perform this copy because in the class_eval'uated
# block below @method would be evaluated in the class context. It's better
# to close on locally-scoped variables than to resort to complex namespacing
# to get access to the probe instance variables.
method = @method; label = @label; data = @data
klass.class_eval {
alias_method("instrumented_#{method}", method)
define_method(method) do |*args|
id = nil
instrumentation_data = nil
begin
instrumentation_label = label.respond_to?(:call) ? label.call(self, args) : label
instrumentation_data = data.respond_to?(:call) ? data.call(self, args) : data
id = Puppet::Util::Instrumentation.start(instrumentation_label, instrumentation_data)
send("instrumented_#{method}".to_sym, *args)
ensure
Puppet::Util::Instrumentation.stop(instrumentation_label, id, instrumentation_data || {})
end
end
}
@enabled = true
end
def disable
raise "Probe is not enabled" unless enabled?
# For the same reason as in #enable, we're forced to do a local
# copy
method = @method
klass.class_eval do
alias_method(method, "instrumented_#{method}")
remove_method("instrumented_#{method}".to_sym)
end
@enabled = false
end
def enabled?
!!@enabled
end
end
# Declares a new probe
#
# It is possible to pass several options that will be later on evaluated
# and sent to the instrumentation layer.
#
# label::
# this can either be a static symbol/string or a block. If it's a block
# this one will be evaluated on every call of the instrumented method and
# should return a string or a symbol
#
# data::
# this can be a hash or a block. If it's a block this one will be evaluated
# on every call of the instrumented method and should return a hash.
#
#Example:
#
# class MyClass
# extend Instrumentable
#
# probe :mymethod, :data => Proc.new { |args| { :data => args[1] } }, :label => Proc.new { |args| args[0] }
#
# def mymethod(name, options)
# end
#
# end
#
def probe(method, options = {})
(@probes ||= []) << Probe.new(method, self, options)
INSTRUMENTED_CLASSES[self] = @probes
end
def self.probes
@probes
end
def self.probe_names
probe_names = []
each_probe { |probe| probe_names << "#{probe.klass}.#{probe.method}" }
probe_names
end
def self.enable_probes
each_probe { |probe| probe.enable }
end
def self.disable_probes
each_probe { |probe| probe.disable }
end
def self.clear_probes
INSTRUMENTED_CLASSES.clear
nil # do not leak our probes to the exterior world
end
def self.each_probe
INSTRUMENTED_CLASSES.each_key do |klass|
klass.probes.each { |probe| yield probe }
end
nil # do not leak our probes to the exterior world
end
end
puppet-3.4.3/lib/puppet/util/instrumentation/listeners/ 0000755 0052762 0001160 00000000000 12300765640 023244 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/util/instrumentation/listeners/performance.rb 0000644 0052762 0001160 00000001257 12300765631 026077 0 ustar jenkins jenkins Puppet::Util::Instrumentation.new_listener(:performance) do
attr_reader :samples
def initialize
@samples = {}
end
def notify(label, event, data)
return if event == :start
duration = data[:finished] - data[:started]
@samples[label] ||= { :count => 0, :max => 0, :min => nil, :sum => 0, :average => 0 }
@samples[label][:count] += 1
@samples[label][:sum] += duration
@samples[label][:max] = [ @samples[label][:max], duration ].max
@samples[label][:min] = [ @samples[label][:min], duration ].reject { |val| val.nil? }.min
@samples[label][:average] = @samples[label][:sum] / @samples[label][:count]
end
def data
@samples.dup
end
end
puppet-3.4.3/lib/puppet/util/instrumentation/listeners/log.rb 0000644 0052762 0001160 00000001012 12300765631 024344 0 ustar jenkins jenkins # This is an example instrumentation listener that stores the last
# 20 instrumented probe run time.
Puppet::Util::Instrumentation.new_listener(:log) do
SIZE = 20
attr_accessor :last_logs
def initialize
@last_logs = {}
end
def notify(label, event, data)
return if event == :start
log_line = "#{label} took #{data[:finished] - data[:started]}"
(@last_logs[label] ||= []) << log_line
@last_logs[label].shift if @last_logs[label].length > SIZE
end
def data
@last_logs.dup
end
end
puppet-3.4.3/lib/puppet/util/storage.rb 0000644 0052762 0001160 00000004070 12300765631 017763 0 ustar jenkins jenkins require 'yaml'
require 'sync'
require 'singleton'
require 'puppet/util/yaml'
# a class for storing state
class Puppet::Util::Storage
include Singleton
include Puppet::Util
def self.state
@@state
end
def initialize
self.class.load
end
# Return a hash that will be stored to disk. It's worth noting
# here that we use the object's full path, not just the name/type
# combination. At the least, this is useful for those non-isomorphic
# types like exec, but it also means that if an object changes locations
# in the configuration it will lose its cache.
def self.cache(object)
if object.is_a?(Symbol)
name = object
else
name = object.to_s
end
@@state[name] ||= {}
end
def self.clear
@@state.clear
end
def self.init
@@state = {}
end
self.init
def self.load
Puppet.settings.use(:main) unless FileTest.directory?(Puppet[:statedir])
filename = Puppet[:statefile]
unless Puppet::FileSystem::File.exist?(filename)
self.init if @@state.nil?
return
end
unless File.file?(filename)
Puppet.warning("Checksumfile #{filename} is not a file, ignoring")
return
end
Puppet::Util.benchmark(:debug, "Loaded state") do
begin
@@state = Puppet::Util::Yaml.load_file(filename)
rescue Puppet::Util::Yaml::YamlLoadError => detail
Puppet.err "Checksumfile #{filename} is corrupt (#{detail}); replacing"
begin
File.rename(filename, filename + ".bad")
rescue
raise Puppet::Error, "Could not rename corrupt #{filename}; remove manually"
end
end
end
unless @@state.is_a?(Hash)
Puppet.err "State got corrupted"
self.init
end
end
def self.stateinspect
@@state.inspect
end
def self.store
Puppet.debug "Storing state"
Puppet.info "Creating state file #{Puppet[:statefile]}" unless Puppet::FileSystem::File.exist?(Puppet[:statefile])
Puppet::Util.benchmark(:debug, "Stored state") do
Puppet::Util::Yaml.dump(@@state, Puppet[:statefile])
end
end
end
puppet-3.4.3/lib/puppet/util/zaml.rb 0000644 0052762 0001160 00000026725 12300765631 017275 0 ustar jenkins jenkins # encoding: UTF-8
#
# The above encoding line is a magic comment to set the default source encoding
# of this file for the Ruby interpreter. It must be on the first or second
# line of the file if an interpreter is in use. In Ruby 1.9 and later, the
# source encoding determines the encoding of String and Regexp objects created
# from this source file. This explicit encoding is important becuase otherwise
# Ruby will pick an encoding based on LANG or LC_CTYPE environment variables.
# These may be different from site to site so it's important for us to
# establish a consistent behavior. For more information on M17n please see:
# http://links.puppetlabs.com/understanding_m17n
# ZAML -- A partial replacement for YAML, writen with speed and code clarity
# in mind. ZAML fixes one YAML bug (loading Exceptions) and provides
# a replacement for YAML.dump unimaginatively called ZAML.dump,
# which is faster on all known cases and an order of magnitude faster
# with complex structures.
#
# http://github.com/hallettj/zaml
#
# ## License (from upstream)
#
# Copyright (c) 2008-2009 ZAML contributers
#
# This program is dual-licensed under the GNU General Public License
# version 3 or later and under the Apache License, version 2.0.
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version; or under the terms of the Apache License,
# Version 2.0.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License and the Apache License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see
#
.
#
# You may obtain a copy of the Apache License at
#
.
require 'yaml'
class ZAML
VERSION = "0.1.3"
#
# Class Methods
#
def self.dump(stuff, where='')
z = new
stuff.to_zaml(z)
where << z.to_s
end
#
# Instance Methods
#
def initialize
@result = []
@indent = nil
@structured_key_prefix = nil
@previously_emitted_object = {}
@next_free_label_number = 0
emit('--- ')
end
def nested(tail=' ')
old_indent = @indent
@indent = "#{@indent || "\n"}#{tail}"
yield
@indent = old_indent
end
class Label
#
# YAML only wants objects in the datastream once; if the same object
# occurs more than once, we need to emit a label ("&idxxx") on the
# first occurrence and then emit a back reference (*idxxx") on any
# subsequent occurrence(s).
#
# To accomplish this we keeps a hash (by object id) of the labels of
# the things we serialize as we begin to serialize them. The labels
# initially serialize as an empty string (since most objects are only
# going to be be encountered once), but can be changed to a valid
# (by assigning it a number) the first time it is subsequently used,
# if it ever is. Note that we need to do the label setup BEFORE we
# start to serialize the object so that circular structures (in
# which we will encounter a reference to the object as we serialize
# it can be handled).
#
attr_accessor :this_label_number
def initialize(obj,indent)
@indent = indent
@this_label_number = nil
@obj = obj # prevent garbage collection so that object id isn't reused
end
def to_s
@this_label_number ? ('&id%03d%s' % [@this_label_number, @indent]) : ''
end
def reference
@reference ||= '*id%03d' % @this_label_number
end
end
def label_for(obj)
@previously_emitted_object[obj.object_id]
end
def new_label_for(obj)
label = Label.new(obj,(Hash === obj || Array === obj) ? "#{@indent || "\n"} " : ' ')
@previously_emitted_object[obj.object_id] = label
label
end
def first_time_only(obj)
if label = label_for(obj)
label.this_label_number ||= (@next_free_label_number += 1)
emit(label.reference)
else
with_structured_prefix(obj) do
emit(new_label_for(obj))
yield
end
end
end
def with_structured_prefix(obj)
if @structured_key_prefix
unless obj.is_a?(String) and obj !~ /\n/
emit(@structured_key_prefix)
@structured_key_prefix = nil
end
end
yield
end
def emit(s)
@result << s
@recent_nl = false unless s.kind_of?(Label)
end
def nl(s = nil)
emit(@indent || "\n") unless @recent_nl
emit(s) if s
@recent_nl = true
end
def to_s
@result.join
end
def prefix_structured_keys(x)
@structured_key_prefix = x
yield
nl unless @structured_key_prefix
@structured_key_prefix = nil
end
end
################################################################
#
# Behavior for custom classes
#
################################################################
class Object
# Users of this method need to do set math consistently with the
# result. Since #instance_variables returns strings in 1.8 and symbols
# on 1.9, standardize on symbols
if RUBY_VERSION[0,3] == '1.8'
def to_yaml_properties
instance_variables.map(&:to_sym)
end
else
def to_yaml_properties
instance_variables
end
end
def yaml_property_munge(x)
x
end
def zamlized_class_name(root)
cls = self.class
"!ruby/#{root.name.downcase}#{cls == root ? '' : ":#{cls.respond_to?(:name) ? cls.name : cls}"}"
end
def to_zaml(z)
z.first_time_only(self) {
z.emit(zamlized_class_name(Object))
z.nested {
instance_variables = to_yaml_properties
if instance_variables.empty?
z.emit(" {}")
else
instance_variables.each { |v|
z.nl
v.to_s[1..-1].to_zaml(z) # Remove leading '@'
z.emit(': ')
yaml_property_munge(instance_variable_get(v)).to_zaml(z)
}
end
}
}
end
end
################################################################
#
# Behavior for built-in classes
#
################################################################
class NilClass
def to_zaml(z)
z.emit('') # NOTE: blank turns into nil in YAML.load
end
end
class Symbol
def to_zaml(z)
z.emit("!ruby/sym ")
to_s.to_zaml(z)
end
end
class TrueClass
def to_zaml(z)
z.emit('true')
end
end
class FalseClass
def to_zaml(z)
z.emit('false')
end
end
class Numeric
def to_zaml(z)
z.emit(self)
end
end
class Regexp
def to_zaml(z)
z.first_time_only(self) { z.emit("#{zamlized_class_name(Regexp)} #{inspect}") }
end
end
class Exception
def to_zaml(z)
z.emit(zamlized_class_name(Exception))
z.nested {
z.nl("message: ")
message.to_zaml(z)
}
end
#
# Monkey patch for buggy Exception restore in YAML
#
# This makes it work for now but is not very future-proof; if things
# change we'll most likely want to remove this. To mitigate the risks
# as much as possible, we test for the bug before appling the patch.
#
if respond_to? :yaml_new and yaml_new(self, :tag, "message" => "blurp").message != "blurp"
def self.yaml_new( klass, tag, val )
o = YAML.object_maker( klass, {} ).exception(val.delete( 'message'))
val.each_pair do |k,v|
o.instance_variable_set("@#{k}", v)
end
o
end
end
end
class String
ZAML_ESCAPES = {
"\a" => "\\a", "\e" => "\\e", "\f" => "\\f", "\n" => "\\n",
"\r" => "\\r", "\t" => "\\t", "\v" => "\\v"
}
def to_zaml(z)
z.with_structured_prefix(self) do
case
when self == ''
z.emit('""')
when self.to_ascii8bit !~ /\A(?: # ?: non-capturing group (grouping with no back references)
[\x09\x0A\x0D\x20-\x7E] # ASCII
| [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
| \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
| [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
| \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
| \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
| [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
| \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
)*\z/mnx
# Emit the binary tag, then recurse. Ruby splits BASE64 output at the 60
# character mark when packing strings, and we can wind up a multi-line
# string here. We could reimplement the multi-line string logic,
# but why would we - this does just as well for producing solid output.
z.emit("!binary ")
[self].pack("m*").to_zaml(z)
# Only legal UTF-8 characters can make it this far, so we are safe
# against emitting something dubious. That means we don't need to mess
# about, just emit them directly. --daniel 2012-07-14
when ((self =~ /\A[a-zA-Z\/][-\[\]_\/.a-zA-Z0-9]*\z/) and
(self !~ /^(?:true|false|yes|no|on|null|off)$/i))
# simple string literal, safe to emit unquoted.
z.emit(self)
when (self =~ /\n/ and self !~ /\A\s/ and self !~ /\s\z/)
# embedded newline, split line-wise in quoted string block form.
if self[-1..-1] == "\n" then z.emit('|+') else z.emit('|-') end
z.nested { split("\n",-1).each { |line| z.nl; z.emit(line) } }
else
# ...though we still have to escape unsafe characters.
escaped = gsub(/[\\"\x00-\x1F]/) do |c|
ZAML_ESCAPES[c] || "\\x#{c[0].ord.to_s(16)}"
end
z.emit("\"#{escaped}\"")
end
end
end
# Return a guranteed ASCII-8BIT encoding for Ruby 1.9 This is a helper
# method for other methods that perform regular expressions against byte
# sequences deliberately rather than dealing with characters.
# The method may or may not return a new instance.
if String.method_defined?(:encoding)
ASCII_ENCODING = Encoding.find("ASCII-8BIT")
def to_ascii8bit
if self.encoding == ASCII_ENCODING
self
else
self.dup.force_encoding(ASCII_ENCODING)
end
end
else
def to_ascii8bit
self
end
end
end
class Hash
def to_zaml(z)
z.first_time_only(self) {
z.nested {
if empty?
z.emit('{}')
else
each_pair { |k, v|
z.nl
z.prefix_structured_keys('? ') { k.to_zaml(z) }
z.emit(': ')
v.to_zaml(z)
}
end
}
}
end
end
class Array
def to_zaml(z)
z.first_time_only(self) {
z.nested {
if empty?
z.emit('[]')
else
each { |v| z.nl('- '); v.to_zaml(z) }
end
}
}
end
end
class Time
def to_zaml(z)
# 2008-12-06 10:06:51.373758 -07:00
ms = ("%0.6f" % (usec * 1e-6))[2..-1]
offset = "%+0.2i:%0.2i" % [utc_offset / 3600.0, (utc_offset / 60) % 60]
z.emit(self.strftime("%Y-%m-%d %H:%M:%S.#{ms} #{offset}"))
end
end
class Date
def to_zaml(z)
z.emit(strftime('%Y-%m-%d'))
end
end
class Range
def to_zaml(z)
z.first_time_only(self) {
z.emit(zamlized_class_name(Range))
z.nested {
z.nl
z.emit('begin: ')
z.emit(first)
z.nl
z.emit('end: ')
z.emit(last)
z.nl
z.emit('excl: ')
z.emit(exclude_end?)
}
}
end
end
puppet-3.4.3/lib/puppet/util/execution_stub.rb 0000644 0052762 0001160 00000001367 12300765631 021365 0 ustar jenkins jenkins module Puppet::Util
class ExecutionStub
class << self
# Set a stub block that Puppet::Util::Execution.execute() should invoke instead
# of actually executing commands on the target machine. Intended
# for spec testing.
#
# The arguments passed to the block are |command, options|, where
# command is an array of strings and options is an options hash.
def set(&block)
@value = block
end
# Uninstall any execution stub, so that calls to
# Puppet::Util::Execution.execute() behave normally again.
def reset
@value = nil
end
# Retrieve the current execution stub, or nil if there is no stub.
def current_value
@value
end
end
end
end
puppet-3.4.3/lib/puppet/util/provider_features.rb 0000644 0052762 0001160 00000013476 12300765631 022061 0 ustar jenkins jenkins # Provides feature definitions.
require 'puppet/util/methodhelper'
require 'puppet/util/docs'
require 'puppet/util'
# This module models provider features and handles checking whether the features
# are present.
# @todo Unclear what is api and what is private in this module.
#
module Puppet::Util::ProviderFeatures
include Puppet::Util::Docs
# This class models provider features and handles checking whether the features
# are present.
# @todo Unclear what is api and what is private in this class
class ProviderFeature
include Puppet::Util
include Puppet::Util::MethodHelper
include Puppet::Util::Docs
attr_accessor :name, :docs, :methods
# Are all of the requirements met?
# Requirements are checked by checking if feature predicate methods have been generated - see {#methods_available?}.
# @param obj [Object, Class] the object or class to check if requirements are met
# @return [Boolean] whether all requirements for this feature are met or not.
def available?(obj)
if self.methods
return !!methods_available?(obj)
else
# In this case, the provider has to declare support for this
# feature, and that's been checked before we ever get to the
# method checks.
return false
end
end
def initialize(name, docs, hash)
self.name = name.intern
self.docs = docs
hash = symbolize_options(hash)
set_options(hash)
end
private
# Checks whether all feature predicate methods are available.
# @param obj [Object, Class] the object or class to check if feature predicates are available or not.
# @return [Boolean] Returns whether all of the required methods are available or not in the given object.
def methods_available?(obj)
methods.each do |m|
if obj.is_a?(Class)
return false unless obj.public_method_defined?(m)
else
return false unless obj.respond_to?(m)
end
end
true
end
end
# Defines one feature.
# At a minimum, a feature requires a name
# and docs, and at this point they should also specify a list of methods
# required to determine if the feature is present.
# @todo How methods that determine if the feature is present are specified.
def feature(name, docs, hash = {})
@features ||= {}
raise(Puppet::DevError, "Feature #{name} is already defined") if @features.include?(name)
begin
obj = ProviderFeature.new(name, docs, hash)
@features[obj.name] = obj
rescue ArgumentError => detail
error = ArgumentError.new(
"Could not create feature #{name}: #{detail}"
)
error.set_backtrace(detail.backtrace)
raise error
end
end
# @return [String] Returns a string with documentation covering all features.
def featuredocs
str = ""
@features ||= {}
return nil if @features.empty?
names = @features.keys.sort { |a,b| a.to_s <=> b.to_s }
names.each do |name|
doc = @features[name].docs.gsub(/\n\s+/, " ")
str << "- *#{name}*: #{doc}\n"
end
if providers.length > 0
headers = ["Provider", names].flatten
data = {}
providers.each do |provname|
data[provname] = []
prov = provider(provname)
names.each do |name|
if prov.feature?(name)
data[provname] << "*X*"
else
data[provname] << ""
end
end
end
str << doctable(headers, data)
end
str
end
# @return [Array] Returns a list of features.
def features
@features ||= {}
@features.keys
end
# Generates a module that sets up the boolean predicate methods to test for given features.
#
def feature_module
unless defined?(@feature_module)
@features ||= {}
@feature_module = ::Module.new
const_set("FeatureModule", @feature_module)
features = @features
# Create a feature? method that can be passed a feature name and
# determine if the feature is present.
@feature_module.send(:define_method, :feature?) do |name|
method = name.to_s + "?"
return !!(respond_to?(method) and send(method))
end
# Create a method that will list all functional features.
@feature_module.send(:define_method, :features) do
return false unless defined?(features)
features.keys.find_all { |n| feature?(n) }.sort { |a,b|
a.to_s <=> b.to_s
}
end
# Create a method that will determine if a provided list of
# features are satisfied by the curred provider.
@feature_module.send(:define_method, :satisfies?) do |*needed|
ret = true
needed.flatten.each do |feature|
unless feature?(feature)
ret = false
break
end
end
ret
end
# Create a boolean method for each feature so you can test them
# individually as you might need.
@features.each do |name, feature|
method = name.to_s + "?"
@feature_module.send(:define_method, method) do
(is_a?(Class) ? declared_feature?(name) : self.class.declared_feature?(name)) or feature.available?(self)
end
end
# Allow the provider to declare that it has a given feature.
@feature_module.send(:define_method, :has_features) do |*names|
@declared_features ||= []
names.each do |name|
@declared_features << name.intern
end
end
# Aaah, grammatical correctness
@feature_module.send(:alias_method, :has_feature, :has_features)
end
@feature_module
end
# @return [ProviderFeature] Returns a provider feature instance by name.
# @param name [String] the name of the feature to return
# @note Should only be used for testing.
# @api private
#
def provider_feature(name)
return nil unless defined?(@features)
@features[name]
end
end
puppet-3.4.3/lib/puppet/util/ldap.rb 0000644 0052762 0001160 00000000036 12300765631 017235 0 ustar jenkins jenkins module Puppet::Util::Ldap
end
puppet-3.4.3/lib/puppet/util/filetype.rb 0000644 0052762 0001160 00000020130 12300765631 020133 0 ustar jenkins jenkins # Basic classes for reading, writing, and emptying files. Not much
# to see here.
require 'puppet/util/selinux'
require 'tempfile'
require 'fileutils'
class Puppet::Util::FileType
attr_accessor :loaded, :path, :synced
class FileReadError < Puppet::Error; end
include Puppet::Util::SELinux
class << self
attr_accessor :name
include Puppet::Util::ClassGen
end
# Create a new filetype.
def self.newfiletype(name, &block)
@filetypes ||= {}
klass = genclass(
name,
:block => block,
:prefix => "FileType",
:hash => @filetypes
)
# Rename the read and write methods, so that we're sure they
# maintain the stats.
klass.class_eval do
# Rename the read method
define_method(:real_read, instance_method(:read))
define_method(:read) do
begin
val = real_read
@loaded = Time.now
if val
return val.gsub(/# HEADER.*\n/,'')
else
return ""
end
rescue Puppet::Error => detail
raise
rescue => detail
message = "#{self.class} could not read #{@path}: #{detail}"
Puppet.log_exception(detail, message)
raise Puppet::Error, message
end
end
# And then the write method
define_method(:real_write, instance_method(:write))
define_method(:write) do |text|
begin
val = real_write(text)
@synced = Time.now
return val
rescue Puppet::Error => detail
raise
rescue => detail
message = "#{self.class} could not write #{@path}: #{detail}"
Puppet.log_exception(detail, message)
raise Puppet::Error, message
end
end
end
end
def self.filetype(type)
@filetypes[type]
end
# Pick or create a filebucket to use.
def bucket
@bucket ||= Puppet::Type.type(:filebucket).mkdefaultbucket.bucket
end
def initialize(path)
raise ArgumentError.new("Path is nil") if path.nil?
@path = path
end
# Arguments that will be passed to the execute method. Will set the uid
# to the target user if the target user and the current user are not
# the same
def cronargs
if uid = Puppet::Util.uid(@path) and uid == Puppet::Util::SUIDManager.uid
{:failonfail => true, :combine => true}
else
{:failonfail => true, :combine => true, :uid => @path}
end
end
# Operate on plain files.
newfiletype(:flat) do
# Back the file up before replacing it.
def backup
bucket.backup(@path) if Puppet::FileSystem::File.exist?(@path)
end
# Read the file.
def read
if Puppet::FileSystem::File.exist?(@path)
File.read(@path)
else
return nil
end
end
# Remove the file.
def remove
Puppet::FileSystem::File.unlink(@path) if Puppet::FileSystem::File.exist?(@path)
end
# Overwrite the file.
def write(text)
tf = Tempfile.new("puppet")
tf.print text; tf.flush
FileUtils.cp(tf.path, @path)
tf.close
# If SELinux is present, we need to ensure the file has its expected context
set_selinux_default_context(@path)
end
end
# Operate on plain files.
newfiletype(:ram) do
@@tabs = {}
def self.clear
@@tabs.clear
end
def initialize(path)
super
@@tabs[@path] ||= ""
end
# Read the file.
def read
Puppet.info "Reading #{@path} from RAM"
@@tabs[@path]
end
# Remove the file.
def remove
Puppet.info "Removing #{@path} from RAM"
@@tabs[@path] = ""
end
# Overwrite the file.
def write(text)
Puppet.info "Writing #{@path} to RAM"
@@tabs[@path] = text
end
end
# Handle Linux-style cron tabs.
newfiletype(:crontab) do
def initialize(user)
self.path = user
end
def path=(user)
begin
@uid = Puppet::Util.uid(user)
rescue Puppet::Error => detail
raise FileReadError, "Could not retrieve user #{user}: #{detail}", detail.backtrace
end
# XXX We have to have the user name, not the uid, because some
# systems *cough*linux*cough* require it that way
@path = user
end
# Read a specific @path's cron tab.
def read
%x{#{cmdbase} -l 2>/dev/null}
end
# Remove a specific @path's cron tab.
def remove
if %w{Darwin FreeBSD DragonFly}.include?(Facter.value("operatingsystem"))
%x{/bin/echo yes | #{cmdbase} -r 2>/dev/null}
else
%x{#{cmdbase} -r 2>/dev/null}
end
end
# Overwrite a specific @path's cron tab; must be passed the @path name
# and the text with which to create the cron tab.
def write(text)
IO.popen("#{cmdbase()} -", "w") { |p|
p.print text
}
end
private
# Only add the -u flag when the @path is different. Fedora apparently
# does not think I should be allowed to set the @path to my own user name
def cmdbase
if @uid == Puppet::Util::SUIDManager.uid || Facter.value(:operatingsystem) == "HP-UX"
return "crontab"
else
return "crontab -u #{@path}"
end
end
end
# SunOS has completely different cron commands; this class implements
# its versions.
newfiletype(:suntab) do
# Read a specific @path's cron tab.
def read
Puppet::Util::Execution.execute(%w{crontab -l}, cronargs)
rescue => detail
case detail.to_s
when /can't open your crontab/
return ""
when /you are not authorized to use cron/
raise FileReadError, "User #{@path} not authorized to use cron", detail.backtrace
else
raise FileReadError, "Could not read crontab for #{@path}: #{detail}", detail.backtrace
end
end
# Remove a specific @path's cron tab.
def remove
Puppet::Util::Execution.execute(%w{crontab -r}, cronargs)
rescue => detail
raise FileReadError, "Could not remove crontab for #{@path}: #{detail}", detail.backtrace
end
# Overwrite a specific @path's cron tab; must be passed the @path name
# and the text with which to create the cron tab.
def write(text)
output_file = Tempfile.new("puppet_suntab")
begin
output_file.print text
output_file.close
# We have to chown the stupid file to the user.
File.chown(Puppet::Util.uid(@path), nil, output_file.path)
Puppet::Util::Execution.execute(["crontab", output_file.path], cronargs)
rescue => detail
raise FileReadError, "Could not write crontab for #{@path}: #{detail}", detail.backtrace
ensure
output_file.close
output_file.unlink
end
end
end
# Support for AIX crontab with output different than suntab's crontab command.
newfiletype(:aixtab) do
# Read a specific @path's cron tab.
def read
Puppet::Util::Execution.execute(%w{crontab -l}, cronargs)
rescue => detail
case detail.to_s
when /Cannot open a file in the .* directory/
return ""
when /You are not authorized to use the cron command/
raise FileReadError, "User #{@path} not authorized to use cron", detail.backtrace
else
raise FileReadError, "Could not read crontab for #{@path}: #{detail}", detail.backtrace
end
end
# Remove a specific @path's cron tab.
def remove
Puppet::Util::Execution.execute(%w{crontab -r}, cronargs)
rescue => detail
raise FileReadError, "Could not remove crontab for #{@path}: #{detail}", detail.backtrace
end
# Overwrite a specific @path's cron tab; must be passed the @path name
# and the text with which to create the cron tab.
def write(text)
output_file = Tempfile.new("puppet_aixtab")
begin
output_file.print text
output_file.close
# We have to chown the stupid file to the user.
File.chown(Puppet::Util.uid(@path), nil, output_file.path)
Puppet::Util::Execution.execute(["crontab", output_file.path], cronargs)
rescue => detail
raise FileReadError, "Could not write crontab for #{@path}: #{detail}", detail.backtrace
ensure
output_file.close
output_file.unlink
end
end
end
end
puppet-3.4.3/lib/puppet/util/queue/ 0000755 0052762 0001160 00000000000 12300765640 017115 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/util/queue/stomp.rb 0000644 0052762 0001160 00000004026 12300765631 020606 0 ustar jenkins jenkins require 'puppet/util/queue'
require 'stomp'
require 'uri'
# Implements the Ruby Stomp client as a queue type within the
# Puppet::Indirector::Queue::Client registry, for use with the :queue
# indirection terminus type.
#
# Looks to Puppet[:queue_source] for the sole argument to the
# underlying Stomp::Client constructor; consequently, for this client to work,
# Puppet[:queue_source] must use the Stomp::Client URL-like syntax
# for identifying the Stomp message broker: login:pass@host.port
class Puppet::Util::Queue::Stomp
attr_accessor :stomp_client
def initialize
begin
uri = URI.parse(Puppet[:queue_source])
rescue => detail
raise ArgumentError, "Could not create Stomp client instance - queue source #{Puppet[:queue_source]} is invalid: #{detail}"
end
unless uri.scheme == "stomp"
raise ArgumentError, "Could not create Stomp client instance - queue source #{Puppet[:queue_source]} is not a Stomp URL: #{detail}"
end
begin
self.stomp_client = Stomp::Client.new(uri.user, uri.password, uri.host, uri.port, true)
rescue => detail
raise ArgumentError, "Could not create Stomp client instance with queue source #{Puppet[:queue_source]}: got internal Stomp client error #{detail}"
end
# Identify the supported method for sending messages.
@method =
case
when stomp_client.respond_to?(:publish)
:publish
when stomp_client.respond_to?(:send)
:send
else
raise ArgumentError, "STOMP client does not respond to either publish or send"
end
end
def publish_message(target, msg)
stomp_client.__send__(@method, stompify_target(target), msg, :persistent => true)
end
def subscribe(target)
stomp_client.subscribe(stompify_target(target), :ack => :client) do |stomp_message|
yield(stomp_message.body)
stomp_client.acknowledge(stomp_message)
end
end
def stompify_target(target)
'/queue/' + target.to_s
end
Puppet::Util::Queue.register_queue_type(self, :stomp)
end
puppet-3.4.3/lib/puppet/util/command_line.rb 0000644 0052762 0001160 00000013456 12300765631 020754 0 ustar jenkins jenkins # Bundler and rubygems maintain a set of directories from which to
# load gems. If Bundler is loaded, let it determine what can be
# loaded. If it's not loaded, then use rubygems. But do this before
# loading any puppet code, so that our gem loading system is sane.
if not defined? ::Bundler
begin
require 'rubygems'
rescue LoadError
end
end
require 'puppet'
require 'puppet/util'
require "puppet/util/plugins"
require "puppet/util/rubygems"
require "puppet/util/limits"
module Puppet
module Util
# This is the main entry point for all puppet applications / faces; it
# is basically where the bootstrapping process / lifecycle of an app
# begins.
class CommandLine
include Puppet::Util::Limits
OPTION_OR_MANIFEST_FILE = /^-|\.pp$|\.rb$/
# @param zero [String] the name of the executable
# @param argv [Array] the arguments passed on the command line
# @param stdin [IO] (unused)
def initialize(zero = $0, argv = ARGV, stdin = STDIN)
@command = File.basename(zero, '.rb')
@argv = argv
Puppet::Plugins.on_commandline_initialization(:command_line_object => self)
end
# @return [String] name of the subcommand is being executed
# @api public
def subcommand_name
return @command if @command != 'puppet'
if @argv.first =~ OPTION_OR_MANIFEST_FILE
nil
else
@argv.first
end
end
# @return [Array] the command line arguments being passed to the subcommand
# @api public
def args
return @argv if @command != 'puppet'
if subcommand_name.nil?
@argv
else
@argv[1..-1]
end
end
# @api private
# @deprecated
def self.available_subcommands
Puppet.deprecation_warning('Puppet::Util::CommandLine.available_subcommands is deprecated; please use Puppet::Application.available_application_names instead.')
Puppet::Application.available_application_names
end
# available_subcommands was previously an instance method, not a class
# method, and we have an unknown number of user-implemented applications
# that depend on that behaviour. Forwarding allows us to preserve a
# backward compatible API. --daniel 2011-04-11
# @api private
# @deprecated
def available_subcommands
Puppet.deprecation_warning('Puppet::Util::CommandLine#available_subcommands is deprecated; please use Puppet::Application.available_application_names instead.')
Puppet::Application.available_application_names
end
# Run the puppet subcommand. If the subcommand is determined to be an
# external executable, this method will never return and the current
# process will be replaced via {Kernel#exec}.
#
# @return [void]
def execute
Puppet::Util.exit_on_fail("intialize global default settings") do
Puppet.initialize_settings(args)
end
setpriority(Puppet[:priority])
find_subcommand.run
end
# @api private
def external_subcommand
Puppet::Util.which("puppet-#{subcommand_name}")
end
private
def find_subcommand
if subcommand_name.nil?
NilSubcommand.new(self)
elsif Puppet::Application.available_application_names.include?(subcommand_name)
ApplicationSubcommand.new(subcommand_name, self)
elsif path_to_subcommand = external_subcommand
ExternalSubcommand.new(path_to_subcommand, self)
else
UnknownSubcommand.new(subcommand_name, self)
end
end
# @api private
class ApplicationSubcommand
def initialize(subcommand_name, command_line)
@subcommand_name = subcommand_name
@command_line = command_line
end
def run
# For most applications, we want to be able to load code from the modulepath,
# such as apply, describe, resource, and faces.
# For agent, we only want to load pluginsync'ed code from libdir.
# For master, we shouldn't ever be loading per-enviroment code into the master's
# ruby process, but that requires fixing (#17210, #12173, #8750). So for now
# we try to restrict to only code that can be autoloaded from the node's
# environment.
if @subcommand_name != 'master' and @subcommand_name != 'agent'
Puppet::Node::Environment.new.each_plugin_directory do |dir|
$LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
end
end
app = Puppet::Application.find(@subcommand_name).new(@command_line)
Puppet::Plugins.on_application_initialization(:application_object => @command_line)
app.run
end
end
# @api private
class ExternalSubcommand
def initialize(path_to_subcommand, command_line)
@path_to_subcommand = path_to_subcommand
@command_line = command_line
end
def run
Kernel.exec(@path_to_subcommand, *@command_line.args)
end
end
# @api private
class NilSubcommand
def initialize(command_line)
@command_line = command_line
end
def run
if @command_line.args.include? "--version" or @command_line.args.include? "-V"
puts Puppet.version
else
puts "See 'puppet help' for help on available puppet subcommands"
end
end
end
# @api private
class UnknownSubcommand < NilSubcommand
def initialize(subcommand_name, command_line)
@subcommand_name = subcommand_name
super(command_line)
end
def run
puts "Error: Unknown Puppet subcommand '#{@subcommand_name}'"
super
end
end
end
end
end
puppet-3.4.3/lib/puppet/util/windows/ 0000755 0052762 0001160 00000000000 12300765640 017463 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/util/windows/user.rb 0000644 0052762 0001160 00000006317 12300765631 020775 0 ustar jenkins jenkins require 'puppet/util/windows'
require 'win32/security'
require 'facter'
module Puppet::Util::Windows::User
include ::Windows::Security
extend ::Windows::Security
def admin?
majversion = Facter.value(:kernelmajversion)
return false unless majversion
# if Vista or later, check for unrestricted process token
return Win32::Security.elevated_security? unless majversion.to_f < 6.0
# otherwise 2003 or less
check_token_membership
end
module_function :admin?
def check_token_membership
sid = 0.chr * 80
size = [80].pack('L')
member = 0.chr * 4
unless CreateWellKnownSid(WinBuiltinAdministratorsSid, nil, sid, size)
raise Puppet::Util::Windows::Error.new("Failed to create administrators SID")
end
unless IsValidSid(sid)
raise Puppet::Util::Windows::Error.new("Invalid SID")
end
unless CheckTokenMembership(nil, sid, member)
raise Puppet::Util::Windows::Error.new("Failed to check membership")
end
# Is administrators SID enabled in calling thread's access token?
member.unpack('L')[0] == 1
end
module_function :check_token_membership
def password_is?(name, password)
logon_user(name, password)
true
rescue Puppet::Util::Windows::Error
false
end
module_function :password_is?
def logon_user(name, password, &block)
fLOGON32_LOGON_NETWORK = 3
fLOGON32_PROVIDER_DEFAULT = 0
logon_user = Win32API.new("advapi32", "LogonUser", ['P', 'P', 'P', 'L', 'L', 'P'], 'L')
close_handle = Win32API.new("kernel32", "CloseHandle", ['L'], 'B')
token = 0.chr * 4
if logon_user.call(name, ".", password, fLOGON32_LOGON_NETWORK, fLOGON32_PROVIDER_DEFAULT, token) == 0
raise Puppet::Util::Windows::Error.new("Failed to logon user #{name.inspect}")
end
token = token.unpack('L')[0]
begin
yield token if block_given?
ensure
close_handle.call(token)
end
end
module_function :logon_user
def load_profile(user, password)
logon_user(user, password) do |token|
# Set up the PROFILEINFO structure that will be used to load the
# new user's profile
# typedef struct _PROFILEINFO {
# DWORD dwSize;
# DWORD dwFlags;
# LPTSTR lpUserName;
# LPTSTR lpProfilePath;
# LPTSTR lpDefaultPath;
# LPTSTR lpServerName;
# LPTSTR lpPolicyPath;
# HANDLE hProfile;
# } PROFILEINFO, *LPPROFILEINFO;
fPI_NOUI = 1
profile = 0.chr * 4
pi = [4 * 8, fPI_NOUI, user, nil, nil, nil, nil, profile].pack('LLPPPPPP')
load_user_profile = Win32API.new('userenv', 'LoadUserProfile', ['L', 'P'], 'L')
unload_user_profile = Win32API.new('userenv', 'UnloadUserProfile', ['L', 'L'], 'L')
# Load the profile. Since it doesn't exist, it will be created
if load_user_profile.call(token, pi) == 0
raise Puppet::Util::Windows::Error.new("Failed to load user profile #{user.inspect}")
end
Puppet.debug("Loaded profile for #{user}")
profile = pi.unpack('LLLLLLLL').last
if unload_user_profile.call(token, profile) == 0
raise Puppet::Util::Windows::Error.new("Failed to unload user profile #{user.inspect}")
end
end
end
module_function :load_profile
end
puppet-3.4.3/lib/puppet/util/windows/security.rb 0000644 0052762 0001160 00000055540 12300765631 021670 0 ustar jenkins jenkins # This class maps POSIX owner, group, and modes to the Windows
# security model, and back.
#
# The primary goal of this mapping is to ensure that owner, group, and
# modes can be round-tripped in a consistent and deterministic
# way. Otherwise, Puppet might think file resources are out-of-sync
# every time it runs. A secondary goal is to provide equivalent
# permissions for common use-cases. For example, setting the owner to
# "Administrators", group to "Users", and mode to 750 (which also
# denies access to everyone else.
#
# There are some well-known problems mapping windows and POSIX
# permissions due to differences between the two security
# models. Search for "POSIX permission mapping leak". In POSIX, access
# to a file is determined solely based on the most specific class
# (user, group, other). So a mode of 460 would deny write access to
# the owner even if they are a member of the group. But in Windows,
# the entire access control list is walked until the user is
# explicitly denied or allowed (denied take precedence, and if neither
# occurs they are denied). As a result, a user could be allowed access
# based on their group membership. To solve this problem, other people
# have used deny access control entries to more closely model POSIX,
# but this introduces a lot of complexity.
#
# In general, this implementation only supports "typical" permissions,
# where group permissions are a subset of user, and other permissions
# are a subset of group, e.g. 754, but not 467. However, there are
# some Windows quirks to be aware of.
#
# * The owner can be either a user or group SID, and most system files
# are owned by the Administrators group.
# * The group can be either a user or group SID.
# * Unexpected results can occur if the owner and group are the
# same, but the user and group classes are different, e.g. 750. In
# this case, it is not possible to allow write access to the owner,
# but not the group. As a result, the actual permissions set on the
# file would be 770.
# * In general, only privileged users can set the owner, group, or
# change the mode for files they do not own. In 2003, the user must
# be a member of the Administrators group. In Vista/2008, the user
# must be running with elevated privileges.
# * A file/dir can be deleted by anyone with the DELETE access right
# OR by anyone that has the FILE_DELETE_CHILD access right for the
# parent. See http://support.microsoft.com/kb/238018. But on Unix,
# the user must have write access to the file/dir AND execute access
# to all of the parent path components.
# * Many access control entries are inherited from parent directories,
# and it is common for file/dirs to have more than 3 entries,
# e.g. Users, Power Users, Administrators, SYSTEM, etc, which cannot
# be mapped into the 3 class POSIX model. The get_mode method will
# set the S_IEXTRA bit flag indicating that an access control entry
# was found whose SID is neither the owner, group, or other. This
# enables Puppet to detect when file/dirs are out-of-sync,
# especially those that Puppet did not create, but is attempting
# to manage.
# * A special case of this is S_ISYSTEM_MISSING, which is set when the
# SYSTEM permissions are *not* present on the DACL.
# * On Unix, the owner and group can be modified without changing the
# mode. But on Windows, an access control entry specifies which SID
# it applies to. As a result, the set_owner and set_group methods
# automatically rebuild the access control list based on the new
# (and different) owner or group.
require 'puppet/util/windows'
require 'pathname'
require 'ffi'
require 'win32/security'
require 'windows/file'
require 'windows/handle'
require 'windows/security'
require 'windows/process'
require 'windows/memory'
require 'windows/msvcrt/buffer'
require 'windows/volume'
module Puppet::Util::Windows::Security
include ::Windows::File
include ::Windows::Handle
include ::Windows::Security
include ::Windows::Process
include ::Windows::Memory
include ::Windows::MSVCRT::Buffer
include ::Windows::Volume
include Puppet::Util::Windows::SID
extend Puppet::Util::Windows::Security
# file modes
S_IRUSR = 0000400
S_IRGRP = 0000040
S_IROTH = 0000004
S_IWUSR = 0000200
S_IWGRP = 0000020
S_IWOTH = 0000002
S_IXUSR = 0000100
S_IXGRP = 0000010
S_IXOTH = 0000001
S_IRWXU = 0000700
S_IRWXG = 0000070
S_IRWXO = 0000007
S_ISVTX = 0001000
S_IEXTRA = 02000000 # represents an extra ace
S_ISYSTEM_MISSING = 04000000
# constants that are missing from Windows::Security
PROTECTED_DACL_SECURITY_INFORMATION = 0x80000000
UNPROTECTED_DACL_SECURITY_INFORMATION = 0x20000000
NO_INHERITANCE = 0x0
SE_DACL_PROTECTED = 0x1000
# Set the owner of the object referenced by +path+ to the specified
# +owner_sid+. The owner sid should be of the form "S-1-5-32-544"
# and can either be a user or group. Only a user with the
# SE_RESTORE_NAME privilege in their process token can overwrite the
# object's owner to something other than the current user.
def set_owner(owner_sid, path)
sd = get_security_descriptor(path)
if owner_sid != sd.owner
sd.owner = owner_sid
set_security_descriptor(path, sd)
end
end
# Get the owner of the object referenced by +path+. The returned
# value is a SID string, e.g. "S-1-5-32-544". Any user with read
# access to an object can get the owner. Only a user with the
# SE_BACKUP_NAME privilege in their process token can get the owner
# for objects they do not have read access to.
def get_owner(path)
return unless supports_acl?(path)
get_security_descriptor(path).owner
end
# Set the owner of the object referenced by +path+ to the specified
# +group_sid+. The group sid should be of the form "S-1-5-32-544"
# and can either be a user or group. Any user with WRITE_OWNER
# access to the object can change the group (regardless of whether
# the current user belongs to that group or not).
def set_group(group_sid, path)
sd = get_security_descriptor(path)
if group_sid != sd.group
sd.group = group_sid
set_security_descriptor(path, sd)
end
end
# Get the group of the object referenced by +path+. The returned
# value is a SID string, e.g. "S-1-5-32-544". Any user with read
# access to an object can get the group. Only a user with the
# SE_BACKUP_NAME privilege in their process token can get the group
# for objects they do not have read access to.
def get_group(path)
return unless supports_acl?(path)
get_security_descriptor(path).group
end
def supports_acl?(path)
flags = 0.chr * 4
root = Pathname.new(path).enum_for(:ascend).to_a.last.to_s
# 'A trailing backslash is required'
root = "#{root}\\" unless root =~ /[\/\\]$/
unless GetVolumeInformation(root, nil, 0, nil, nil, flags, nil, 0)
raise Puppet::Util::Windows::Error.new("Failed to get volume information")
end
(flags.unpack('L')[0] & Windows::File::FILE_PERSISTENT_ACLS) != 0
end
def get_attributes(path)
attributes = GetFileAttributes(path)
raise Puppet::Util::Windows::Error.new("Failed to get file attributes") if attributes == INVALID_FILE_ATTRIBUTES
attributes
end
def add_attributes(path, flags)
oldattrs = get_attributes(path)
if (oldattrs | flags) != oldattrs
set_attributes(path, oldattrs | flags)
end
end
def remove_attributes(path, flags)
oldattrs = get_attributes(path)
if (oldattrs & ~flags) != oldattrs
set_attributes(path, oldattrs & ~flags)
end
end
def set_attributes(path, flags)
raise Puppet::Util::Windows::Error.new("Failed to set file attributes") unless SetFileAttributes(path, flags)
end
MASK_TO_MODE = {
FILE_GENERIC_READ => S_IROTH,
FILE_GENERIC_WRITE => S_IWOTH,
(FILE_GENERIC_EXECUTE & ~FILE_READ_ATTRIBUTES) => S_IXOTH
}
def get_aces_for_path_by_sid(path, sid)
get_security_descriptor(path).dacl.select { |ace| ace.sid == sid }
end
# Get the mode of the object referenced by +path+. The returned
# integer value represents the POSIX-style read, write, and execute
# modes for the user, group, and other classes, e.g. 0640. Any user
# with read access to an object can get the mode. Only a user with
# the SE_BACKUP_NAME privilege in their process token can get the
# mode for objects they do not have read access to.
def get_mode(path)
return unless supports_acl?(path)
well_known_world_sid = Win32::Security::SID::Everyone
well_known_nobody_sid = Win32::Security::SID::Nobody
well_known_system_sid = Win32::Security::SID::LocalSystem
mode = S_ISYSTEM_MISSING
sd = get_security_descriptor(path)
sd.dacl.each do |ace|
next if ace.inherit_only?
case ace.sid
when sd.owner
MASK_TO_MODE.each_pair do |k,v|
if (ace.mask & k) == k
mode |= (v << 6)
end
end
when sd.group
MASK_TO_MODE.each_pair do |k,v|
if (ace.mask & k) == k
mode |= (v << 3)
end
end
when well_known_world_sid
MASK_TO_MODE.each_pair do |k,v|
if (ace.mask & k) == k
mode |= (v << 6) | (v << 3) | v
end
end
if File.directory?(path) && (ace.mask & (FILE_WRITE_DATA | FILE_EXECUTE | FILE_DELETE_CHILD)) == (FILE_WRITE_DATA | FILE_EXECUTE)
mode |= S_ISVTX;
end
when well_known_nobody_sid
if (ace.mask & FILE_APPEND_DATA).nonzero?
mode |= S_ISVTX
end
when well_known_system_sid
else
#puts "Warning, unable to map SID into POSIX mode: #{ace.sid}"
mode |= S_IEXTRA
end
if ace.sid == well_known_system_sid
mode &= ~S_ISYSTEM_MISSING
end
# if owner and group the same, then user and group modes are the OR of both
if sd.owner == sd.group
mode |= ((mode & S_IRWXG) << 3) | ((mode & S_IRWXU) >> 3)
#puts "owner: #{sd.group}, 0x#{ace.mask.to_s(16)}, #{mode.to_s(8)}"
end
end
#puts "get_mode: #{mode.to_s(8)}"
mode
end
MODE_TO_MASK = {
S_IROTH => FILE_GENERIC_READ,
S_IWOTH => FILE_GENERIC_WRITE,
S_IXOTH => (FILE_GENERIC_EXECUTE & ~FILE_READ_ATTRIBUTES),
}
# Set the mode of the object referenced by +path+ to the specified
# +mode+. The mode should be specified as POSIX-stye read, write,
# and execute modes for the user, group, and other classes,
# e.g. 0640. The sticky bit, S_ISVTX, is supported, but is only
# meaningful for directories. If set, group and others are not
# allowed to delete child objects for which they are not the owner.
# By default, the DACL is set to protected, meaning it does not
# inherit access control entries from parent objects. This can be
# changed by setting +protected+ to false. The owner of the object
# (with READ_CONTROL and WRITE_DACL access) can always change the
# mode. Only a user with the SE_BACKUP_NAME and SE_RESTORE_NAME
# privileges in their process token can change the mode for objects
# that they do not have read and write access to.
def set_mode(mode, path, protected = true)
sd = get_security_descriptor(path)
well_known_world_sid = Win32::Security::SID::Everyone
well_known_nobody_sid = Win32::Security::SID::Nobody
well_known_system_sid = Win32::Security::SID::LocalSystem
owner_allow = STANDARD_RIGHTS_ALL | FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES
group_allow = STANDARD_RIGHTS_READ | FILE_READ_ATTRIBUTES | SYNCHRONIZE
other_allow = STANDARD_RIGHTS_READ | FILE_READ_ATTRIBUTES | SYNCHRONIZE
nobody_allow = 0
system_allow = 0
MODE_TO_MASK.each do |k,v|
if ((mode >> 6) & k) == k
owner_allow |= v
end
if ((mode >> 3) & k) == k
group_allow |= v
end
if (mode & k) == k
other_allow |= v
end
end
if (mode & S_ISVTX).nonzero?
nobody_allow |= FILE_APPEND_DATA;
end
# caller is NOT managing SYSTEM by using group or owner, so set to FULL
if ! [sd.owner, sd.group].include? well_known_system_sid
# we don't check S_ISYSTEM_MISSING bit, but automatically carry over existing SYSTEM perms
# by default set SYSTEM perms to full
system_allow = FILE_ALL_ACCESS
end
isdir = File.directory?(path)
if isdir
if (mode & (S_IWUSR | S_IXUSR)) == (S_IWUSR | S_IXUSR)
owner_allow |= FILE_DELETE_CHILD
end
if (mode & (S_IWGRP | S_IXGRP)) == (S_IWGRP | S_IXGRP) && (mode & S_ISVTX) == 0
group_allow |= FILE_DELETE_CHILD
end
if (mode & (S_IWOTH | S_IXOTH)) == (S_IWOTH | S_IXOTH) && (mode & S_ISVTX) == 0
other_allow |= FILE_DELETE_CHILD
end
end
# if owner and group the same, then map group permissions to the one owner ACE
isownergroup = sd.owner == sd.group
if isownergroup
owner_allow |= group_allow
end
# if any ACE allows write, then clear readonly bit, but do this before we overwrite
# the DACl and lose our ability to set the attribute
if ((owner_allow | group_allow | other_allow ) & FILE_WRITE_DATA) == FILE_WRITE_DATA
remove_attributes(path, FILE_ATTRIBUTE_READONLY)
end
dacl = Puppet::Util::Windows::AccessControlList.new
dacl.allow(sd.owner, owner_allow)
unless isownergroup
dacl.allow(sd.group, group_allow)
end
dacl.allow(well_known_world_sid, other_allow)
dacl.allow(well_known_nobody_sid, nobody_allow)
# TODO: system should be first?
dacl.allow(well_known_system_sid, system_allow)
# add inherit-only aces for child dirs and files that are created within the dir
if isdir
inherit = INHERIT_ONLY_ACE | CONTAINER_INHERIT_ACE
dacl.allow(Win32::Security::SID::CreatorOwner, owner_allow, inherit)
dacl.allow(Win32::Security::SID::CreatorGroup, group_allow, inherit)
inherit = INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE
dacl.allow(Win32::Security::SID::CreatorOwner, owner_allow & ~FILE_EXECUTE, inherit)
dacl.allow(Win32::Security::SID::CreatorGroup, group_allow & ~FILE_EXECUTE, inherit)
end
new_sd = Puppet::Util::Windows::SecurityDescriptor.new(sd.owner, sd.group, dacl, protected)
set_security_descriptor(path, new_sd)
nil
end
def add_access_allowed_ace(acl, mask, sid, inherit = nil)
inherit ||= NO_INHERITANCE
string_to_sid_ptr(sid) do |sid_ptr|
raise Puppet::Util::Windows::Error.new("Invalid SID") unless IsValidSid(sid_ptr)
unless AddAccessAllowedAceEx(acl, ACL_REVISION, inherit, mask, sid_ptr)
raise Puppet::Util::Windows::Error.new("Failed to add access control entry")
end
end
end
def add_access_denied_ace(acl, mask, sid)
string_to_sid_ptr(sid) do |sid_ptr|
raise Puppet::Util::Windows::Error.new("Invalid SID") unless IsValidSid(sid_ptr)
unless AddAccessDeniedAce(acl, ACL_REVISION, mask, sid_ptr)
raise Puppet::Util::Windows::Error.new("Failed to add access control entry")
end
end
end
def parse_dacl(dacl_ptr)
# REMIND: need to handle NULL DACL
raise Puppet::Util::Windows::Error.new("Invalid DACL") unless IsValidAcl(dacl_ptr)
# ACL structure, size and count are the important parts. The
# size includes both the ACL structure and all the ACEs.
#
# BYTE AclRevision
# BYTE Padding1
# WORD AclSize
# WORD AceCount
# WORD Padding2
acl_buf = 0.chr * 8
memcpy(acl_buf, dacl_ptr, acl_buf.size)
ace_count = acl_buf.unpack('CCSSS')[3]
dacl = Puppet::Util::Windows::AccessControlList.new
# deny all
return dacl if ace_count == 0
0.upto(ace_count - 1) do |i|
ace_ptr = [0].pack('L')
next unless GetAce(dacl_ptr, i, ace_ptr)
# ACE structures vary depending on the type. All structures
# begin with an ACE header, which specifies the type, flags
# and size of what follows. We are only concerned with
# ACCESS_ALLOWED_ACE and ACCESS_DENIED_ACEs, which have the
# same structure:
#
# BYTE C AceType
# BYTE C AceFlags
# WORD S AceSize
# DWORD L ACCESS_MASK
# DWORD L Sid
# .. ...
# DWORD L Sid
ace_buf = 0.chr * 8
memcpy(ace_buf, ace_ptr.unpack('L')[0], ace_buf.size)
ace_type, ace_flags, size, mask = ace_buf.unpack('CCSL')
case ace_type
when ACCESS_ALLOWED_ACE_TYPE
sid_ptr = ace_ptr.unpack('L')[0] + 8 # address of ace_ptr->SidStart
raise Puppet::Util::Windows::Error.new("Failed to read DACL, invalid SID") unless IsValidSid(sid_ptr)
sid = sid_ptr_to_string(sid_ptr)
dacl.allow(sid, mask, ace_flags)
when ACCESS_DENIED_ACE_TYPE
sid_ptr = ace_ptr.unpack('L')[0] + 8 # address of ace_ptr->SidStart
raise Puppet::Util::Windows::Error.new("Failed to read DACL, invalid SID") unless IsValidSid(sid_ptr)
sid = sid_ptr_to_string(sid_ptr)
dacl.deny(sid, mask, ace_flags)
else
Puppet.warning "Unsupported access control entry type: 0x#{ace_type.to_s(16)}"
end
end
dacl
end
# Open an existing file with the specified access mode, and execute a
# block with the opened file HANDLE.
def open_file(path, access)
handle = CreateFile(
path,
access,
FILE_SHARE_READ | FILE_SHARE_WRITE,
0, # security_attributes
OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
0) # template
raise Puppet::Util::Windows::Error.new("Failed to open '#{path}'") if handle == INVALID_HANDLE_VALUE
begin
yield handle
ensure
CloseHandle(handle)
end
end
# Execute a block with the specified privilege enabled
def with_privilege(privilege)
set_privilege(privilege, true)
yield
ensure
set_privilege(privilege, false)
end
# Enable or disable a privilege. Note this doesn't add any privileges the
# user doesn't already has, it just enables privileges that are disabled.
def set_privilege(privilege, enable)
return unless Puppet.features.root?
with_process_token(TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY) do |token|
tmpLuid = 0.chr * 8
# Get the LUID for specified privilege.
unless LookupPrivilegeValue("", privilege, tmpLuid)
raise Puppet::Util::Windows::Error.new("Failed to lookup privilege")
end
# DWORD + [LUID + DWORD]
tkp = [1].pack('L') + tmpLuid + [enable ? SE_PRIVILEGE_ENABLED : 0].pack('L')
unless AdjustTokenPrivileges(token, 0, tkp, tkp.length , nil, nil)
raise Puppet::Util::Windows::Error.new("Failed to adjust process privileges")
end
end
end
# Execute a block with the current process token
def with_process_token(access)
token = 0.chr * 4
unless OpenProcessToken(GetCurrentProcess(), access, token)
raise Puppet::Util::Windows::Error.new("Failed to open process token")
end
begin
token = token.unpack('L')[0]
yield token
ensure
CloseHandle(token)
end
end
def get_security_descriptor(path)
sd = nil
with_privilege(SE_BACKUP_NAME) do
open_file(path, READ_CONTROL) do |handle|
owner_sid = [0].pack('L')
group_sid = [0].pack('L')
dacl = [0].pack('L')
ppsd = [0].pack('L')
rv = GetSecurityInfo(
handle,
SE_FILE_OBJECT,
OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
owner_sid,
group_sid,
dacl,
nil, #sacl
ppsd) #sec desc
raise Puppet::Util::Windows::Error.new("Failed to get security information") unless rv == ERROR_SUCCESS
begin
owner = sid_ptr_to_string(owner_sid.unpack('L')[0])
group = sid_ptr_to_string(group_sid.unpack('L')[0])
control = FFI::MemoryPointer.new(:uint16, 1)
revision = FFI::MemoryPointer.new(:uint32, 1)
ffsd = FFI::Pointer.new(ppsd.unpack('L')[0])
if ! API.get_security_descriptor_control(ffsd, control, revision)
raise Puppet::Util::Windows::Error.new("Failed to get security descriptor control")
end
protect = (control.read_uint16 & SE_DACL_PROTECTED) == SE_DACL_PROTECTED
dacl = parse_dacl(dacl.unpack('L')[0])
sd = Puppet::Util::Windows::SecurityDescriptor.new(owner, group, dacl, protect)
ensure
LocalFree(ppsd.unpack('L')[0])
end
end
end
sd
end
# setting DACL requires both READ_CONTROL and WRITE_DACL access rights,
# and their respective privileges, SE_BACKUP_NAME and SE_RESTORE_NAME.
def set_security_descriptor(path, sd)
# REMIND: FFI
acl = 0.chr * 1024 # This can be increased later as neede
unless InitializeAcl(acl, acl.size, ACL_REVISION)
raise Puppet::Util::Windows::Error.new("Failed to initialize ACL")
end
raise Puppet::Util::Windows::Error.new("Invalid DACL") unless IsValidAcl(acl)
with_privilege(SE_BACKUP_NAME) do
with_privilege(SE_RESTORE_NAME) do
open_file(path, READ_CONTROL | WRITE_DAC | WRITE_OWNER) do |handle|
string_to_sid_ptr(sd.owner) do |ownersid|
string_to_sid_ptr(sd.group) do |groupsid|
sd.dacl.each do |ace|
case ace.type
when ACCESS_ALLOWED_ACE_TYPE
#puts "ace: allow, sid #{sid_to_name(ace.sid)}, mask 0x#{ace.mask.to_s(16)}"
add_access_allowed_ace(acl, ace.mask, ace.sid, ace.flags)
when ACCESS_DENIED_ACE_TYPE
#puts "ace: deny, sid #{sid_to_name(ace.sid)}, mask 0x#{ace.mask.to_s(16)}"
add_access_denied_ace(acl, ace.mask, ace.sid)
else
raise "We should never get here"
# TODO: this should have been a warning in an earlier commit
end
end
# protected means the object does not inherit aces from its parent
flags = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION
flags |= sd.protect ? PROTECTED_DACL_SECURITY_INFORMATION : UNPROTECTED_DACL_SECURITY_INFORMATION
rv = SetSecurityInfo(handle,
SE_FILE_OBJECT,
flags,
ownersid,
groupsid,
acl,
nil)
raise Puppet::Util::Windows::Error.new("Failed to set security information") unless rv == ERROR_SUCCESS
end
end
end
end
end
end
module API
extend FFI::Library
ffi_lib 'kernel32'
ffi_convention :stdcall
# typedef WORD SECURITY_DESCRIPTOR_CONTROL, *PSECURITY_DESCRIPTOR_CONTROL;
# BOOL WINAPI GetSecurityDescriptorControl(
# _In_ PSECURITY_DESCRIPTOR pSecurityDescriptor,
# _Out_ PSECURITY_DESCRIPTOR_CONTROL pControl,
# _Out_ LPDWORD lpdwRevision
# );
ffi_lib :advapi32
attach_function :get_security_descriptor_control, :GetSecurityDescriptorControl, [:pointer, :pointer, :pointer], :bool
end
end
puppet-3.4.3/lib/puppet/util/windows/registry.rb 0000644 0052762 0001160 00000003731 12300765631 021664 0 ustar jenkins jenkins require 'puppet/util/windows'
module Puppet::Util::Windows
module Registry
# http://msdn.microsoft.com/en-us/library/windows/desktop/aa384129(v=vs.85).aspx
KEY64 = 0x100
KEY32 = 0x200
KEY_READ = 0x20019
KEY_WRITE = 0x20006
KEY_ALL_ACCESS = 0x2003f
def root(name)
Win32::Registry.const_get(name)
rescue NameError
raise Puppet::Error, "Invalid registry key '#{name}'"
end
def open(name, path, mode = KEY_READ | KEY64, &block)
hkey = root(name)
begin
hkey.open(path, mode) do |subkey|
return yield subkey
end
rescue Win32::Registry::Error => error
raise Puppet::Util::Windows::Error.new("Failed to open registry key '#{hkey.keyname}\\#{path}'", error.code)
end
end
def values(subkey)
values = {}
subkey.each_value do |name, type, data|
case type
when Win32::Registry::REG_MULTI_SZ
data.each { |str| force_encoding(str) }
when Win32::Registry::REG_SZ, Win32::Registry::REG_EXPAND_SZ
force_encoding(data)
end
values[name] = data
end
values
end
if defined?(Encoding)
def force_encoding(str)
if @encoding.nil?
# See https://bugs.ruby-lang.org/issues/8943
# Ruby uses ANSI versions of Win32 APIs to read values from the
# registry. The encoding of these strings depends on the active
# code page. However, ruby incorrectly sets the string
# encoding to US-ASCII. So we must force the encoding to the
# correct value.
require 'windows/national'
begin
cp = Windows::National::GetACP.call
@encoding = Encoding.const_get("CP#{cp}")
rescue
@encoding = Encoding.default_external
end
end
str.force_encoding(@encoding)
end
else
def force_encoding(str, enc)
end
end
private :force_encoding
end
end
puppet-3.4.3/lib/puppet/util/windows/process.rb 0000644 0052762 0001160 00000017470 12300765631 021477 0 ustar jenkins jenkins require 'puppet/util/windows'
require 'windows/process'
require 'windows/handle'
require 'windows/synchronize'
module Puppet::Util::Windows::Process
extend ::Windows::Process
extend ::Windows::Handle
extend ::Windows::Synchronize
module API
require 'ffi'
extend FFI::Library
ffi_convention :stdcall
ffi_lib 'kernel32'
# http://msdn.microsoft.com/en-us/library/windows/desktop/ms683179(v=vs.85).aspx
# HANDLE WINAPI GetCurrentProcess(void);
attach_function :get_current_process, :GetCurrentProcess, [], :uint
# BOOL WINAPI CloseHandle(
# _In_ HANDLE hObject
# );
attach_function :close_handle, :CloseHandle, [:uint], :bool
ffi_lib 'advapi32'
# http://msdn.microsoft.com/en-us/library/windows/desktop/aa379295(v=vs.85).aspx
# BOOL WINAPI OpenProcessToken(
# _In_ HANDLE ProcessHandle,
# _In_ DWORD DesiredAccess,
# _Out_ PHANDLE TokenHandle
# );
attach_function :open_process_token, :OpenProcessToken,
[:uint, :uint, :pointer], :bool
# http://msdn.microsoft.com/en-us/library/windows/desktop/aa379261(v=vs.85).aspx
# typedef struct _LUID {
# DWORD LowPart;
# LONG HighPart;
# } LUID, *PLUID;
class LUID < FFI::Struct
layout :low_part, :uint,
:high_part, :int
end
# http://msdn.microsoft.com/en-us/library/Windows/desktop/aa379180(v=vs.85).aspx
# BOOL WINAPI LookupPrivilegeValue(
# _In_opt_ LPCTSTR lpSystemName,
# _In_ LPCTSTR lpName,
# _Out_ PLUID lpLuid
# );
attach_function :lookup_privilege_value, :LookupPrivilegeValueA,
[:string, :string, :pointer], :bool
Token_Information = enum(
:token_user, 1,
:token_groups,
:token_privileges,
:token_owner,
:token_primary_group,
:token_default_dacl,
:token_source,
:token_type,
:token_impersonation_level,
:token_statistics,
:token_restricted_sids,
:token_session_id,
:token_groups_and_privileges,
:token_session_reference,
:token_sandbox_inert,
:token_audit_policy,
:token_origin,
:token_elevation_type,
:token_linked_token,
:token_elevation,
:token_has_restrictions,
:token_access_information,
:token_virtualization_allowed,
:token_virtualization_enabled,
:token_integrity_level,
:token_ui_access,
:token_mandatory_policy,
:token_logon_sid,
:max_token_info_class
)
# http://msdn.microsoft.com/en-us/library/windows/desktop/aa379263(v=vs.85).aspx
# typedef struct _LUID_AND_ATTRIBUTES {
# LUID Luid;
# DWORD Attributes;
# } LUID_AND_ATTRIBUTES, *PLUID_AND_ATTRIBUTES;
class LUID_And_Attributes < FFI::Struct
layout :luid, LUID,
:attributes, :uint
end
# http://msdn.microsoft.com/en-us/library/windows/desktop/aa379630(v=vs.85).aspx
# typedef struct _TOKEN_PRIVILEGES {
# DWORD PrivilegeCount;
# LUID_AND_ATTRIBUTES Privileges[ANYSIZE_ARRAY];
# } TOKEN_PRIVILEGES, *PTOKEN_PRIVILEGES;
class Token_Privileges < FFI::Struct
layout :privilege_count, :uint,
:privileges, [LUID_And_Attributes, 1] # placeholder for offset
end
# http://msdn.microsoft.com/en-us/library/windows/desktop/aa446671(v=vs.85).aspx
# BOOL WINAPI GetTokenInformation(
# _In_ HANDLE TokenHandle,
# _In_ TOKEN_INFORMATION_CLASS TokenInformationClass,
# _Out_opt_ LPVOID TokenInformation,
# _In_ DWORD TokenInformationLength,
# _Out_ PDWORD ReturnLength
# );
attach_function :get_token_information, :GetTokenInformation,
[:uint, Token_Information, :pointer, :uint, :pointer ], :bool
end
def execute(command, arguments, stdin, stdout, stderr)
Process.create( :command_line => command, :startup_info => {:stdin => stdin, :stdout => stdout, :stderr => stderr}, :close_handles => false )
end
module_function :execute
def wait_process(handle)
while WaitForSingleObject(handle, 0) == Windows::Synchronize::WAIT_TIMEOUT
sleep(1)
end
exit_status = [0].pack('L')
unless GetExitCodeProcess(handle, exit_status)
raise Puppet::Util::Windows::Error.new("Failed to get child process exit code")
end
exit_status = exit_status.unpack('L').first
# $CHILD_STATUS is not set when calling win32/process Process.create
# and since it's read-only, we can't set it. But we can execute a
# a shell that simply returns the desired exit status, which has the
# desired effect.
%x{#{ENV['COMSPEC']} /c exit #{exit_status}}
exit_status
end
module_function :wait_process
def get_current_process
# this pseudo-handle does not require closing per MSDN docs
API.get_current_process
end
module_function :get_current_process
def open_process_token(handle, desired_access)
token_handle_ptr = FFI::MemoryPointer.new(:uint, 1)
result = API.open_process_token(handle, desired_access, token_handle_ptr)
if !result
raise Puppet::Util::Windows::Error.new(
"OpenProcessToken(#{handle}, #{desired_access.to_s(8)}, #{token_handle_ptr})")
end
begin
yield token_handle = token_handle_ptr.read_uint
ensure
API.close_handle(token_handle)
end
end
module_function :open_process_token
def lookup_privilege_value(name, system_name = '')
luid = FFI::MemoryPointer.new(API::LUID.size)
result = API.lookup_privilege_value(
system_name,
name.to_s,
luid
)
return API::LUID.new(luid) if result
raise Puppet::Util::Windows::Error.new(
"LookupPrivilegeValue(#{system_name}, #{name}, #{luid})")
end
module_function :lookup_privilege_value
def get_token_information(token_handle, token_information)
# to determine buffer size
return_length_ptr = FFI::MemoryPointer.new(:uint, 1)
result = API.get_token_information(token_handle, token_information, nil, 0, return_length_ptr)
return_length = return_length_ptr.read_uint
if return_length <= 0
raise Puppet::Util::Windows::Error.new(
"GetTokenInformation(#{token_handle}, #{token_information}, nil, 0, #{return_length_ptr})")
end
# re-call API with properly sized buffer for all results
token_information_buf = FFI::MemoryPointer.new(return_length)
result = API.get_token_information(token_handle, token_information,
token_information_buf, return_length, return_length_ptr)
if !result
raise Puppet::Util::Windows::Error.new(
"GetTokenInformation(#{token_handle}, #{token_information}, #{token_information_buf}, " +
"#{return_length}, #{return_length_ptr})")
end
raw_privileges = API::Token_Privileges.new(token_information_buf)
privileges = { :count => raw_privileges[:privilege_count], :privileges => [] }
offset = token_information_buf + API::Token_Privileges.offset_of(:privileges)
privilege_ptr = FFI::Pointer.new(API::LUID_And_Attributes, offset)
# extract each instance of LUID_And_Attributes
0.upto(privileges[:count] - 1) do |i|
privileges[:privileges] << API::LUID_And_Attributes.new(privilege_ptr[i])
end
privileges
end
module_function :get_token_information
TOKEN_ALL_ACCESS = 0xF01FF
ERROR_NO_SUCH_PRIVILEGE = 1313
def process_privilege_symlink?
handle = get_current_process
open_process_token(handle, TOKEN_ALL_ACCESS) do |token_handle|
luid = lookup_privilege_value('SeCreateSymbolicLinkPrivilege')
token_info = get_token_information(token_handle, :token_privileges)
token_info[:privileges].any? { |p| p[:luid].values == luid.values }
end
rescue Puppet::Util::Windows::Error => e
if e.code == ERROR_NO_SUCH_PRIVILEGE
false # pre-Vista
else
raise e
end
end
module_function :process_privilege_symlink?
end
puppet-3.4.3/lib/puppet/util/windows/security_descriptor.rb 0000644 0052762 0001160 00000003673 12300765631 024126 0 ustar jenkins jenkins # Windows Security Descriptor
#
# Represents a security descriptor that can be applied to any Windows securable
# object, e.g. file, registry key, service, etc. It consists of an owner, group,
# flags, DACL, and SACL. The SACL is not currently supported, though it has the
# same layout as a DACL.
#
# @see http://msdn.microsoft.com/en-us/library/windows/desktop/aa379563(v=vs.85).aspx
# @api private
class Puppet::Util::Windows::SecurityDescriptor
require 'puppet/util/windows/security'
include Puppet::Util::Windows::SID
attr_reader :owner, :group, :dacl
attr_accessor :protect
# Construct a security descriptor
#
# @param owner [String] The SID of the owner, e.g. 'S-1-5-18'
# @param group [String] The SID of the group
# @param dacl [AccessControlList] The ACL specifying the rights granted to
# each user for accessing the object that the security descriptor refers to.
# @param protect [Boolean] If true, then inheritable access control
# entries will be blocked, and not applied to the object.
def initialize(owner, group, dacl, protect = false)
@owner = owner
@group = group
@dacl = dacl
@protect = protect
end
# Set the owner. Non-inherited access control entries assigned to the
# current owner will be assigned to the new owner.
#
# @param new_owner [String] The SID of the new owner, e.g. 'S-1-5-18'
def owner=(new_owner)
if @owner != new_owner
@dacl.reassign!(@owner, new_owner)
@owner = new_owner
end
end
# Set the group. Non-inherited access control entries assigned to the
# current group will be assigned to the new group.
#
# @param new_group [String] The SID of the new group, e.g. 'S-1-0-0'
def group=(new_group)
if @group != new_group
@dacl.reassign!(@group, new_group)
@group = new_group
end
end
def inspect
str = sid_to_name(owner)
str << "\n"
str << sid_to_name(group)
str << "\n"
str << @dacl.inspect
str
end
end
puppet-3.4.3/lib/puppet/util/windows/string.rb 0000644 0052762 0001160 00000000744 12300765631 021323 0 ustar jenkins jenkins require 'puppet/util/windows'
module Puppet::Util::Windows::String
def wide_string(str)
# ruby (< 2.1) does not respect multibyte terminators, so it is possible
# for a string to contain a single trailing null byte, followed by garbage
# causing buffer overruns.
#
# See http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?revision=41920&view=revision
newstr = str + "\0".encode(str.encoding)
newstr.encode!('UTF-16LE')
end
module_function :wide_string
end
puppet-3.4.3/lib/puppet/util/windows/sid.rb 0000644 0052762 0001160 00000007431 12300765631 020574 0 ustar jenkins jenkins require 'puppet/util/windows'
module Puppet::Util::Windows
module SID
require 'windows/security'
include ::Windows::Security
require 'windows/memory'
include ::Windows::Memory
require 'windows/msvcrt/string'
include ::Windows::MSVCRT::String
# missing from Windows::Error
ERROR_NONE_MAPPED = 1332
ERROR_INVALID_SID_STRUCTURE = 1337
# Convert an account name, e.g. 'Administrators' into a SID string,
# e.g. 'S-1-5-32-544'. The name can be specified as 'Administrators',
# 'BUILTIN\Administrators', or 'S-1-5-32-544', and will return the
# SID. Returns nil if the account doesn't exist.
def name_to_sid(name)
sid = name_to_sid_object(name)
sid ? sid.to_s : nil
end
# Convert an account name, e.g. 'Administrators' into a SID object,
# e.g. 'S-1-5-32-544'. The name can be specified as 'Administrators',
# 'BUILTIN\Administrators', or 'S-1-5-32-544', and will return the
# SID object. Returns nil if the account doesn't exist.
def name_to_sid_object(name)
# Apparently, we accept a symbol..
name = name.to_s.strip if name
# if it's in SID string form, convert to user
parsed_sid = Win32::Security::SID.string_to_sid(name) rescue nil
parsed_sid ? Win32::Security::SID.new(parsed_sid) : Win32::Security::SID.new(name)
rescue
nil
end
# Converts an octet string array of bytes to a SID object,
# e.g. [1, 1, 0, 0, 0, 0, 0, 5, 18, 0, 0, 0] is the representation for
# S-1-5-18, the local 'SYSTEM' account.
# Raises an Error for nil or non-array input.
def octet_string_to_sid_object(bytes)
if !bytes || !bytes.respond_to?('pack') || bytes.empty?
raise Puppet::Util::Windows::Error.new("Octet string must be an array of bytes")
end
Win32::Security::SID.new(bytes.pack('C*'))
end
# Convert a SID string, e.g. "S-1-5-32-544" to a name,
# e.g. 'BUILTIN\Administrators'. Returns nil if an account
# for that SID does not exist.
def sid_to_name(value)
sid = Win32::Security::SID.new(Win32::Security::SID.string_to_sid(value))
if sid.domain and sid.domain.length > 0
"#{sid.domain}\\#{sid.account}"
else
sid.account
end
rescue
nil
end
# Convert a SID pointer to a SID string, e.g. "S-1-5-32-544".
def sid_ptr_to_string(psid)
sid_buf = 0.chr * 256
str_ptr = 0.chr * 4
raise Puppet::Util::Windows::Error.new("Invalid SID") unless IsValidSid(psid)
raise Puppet::Util::Windows::Error.new("Failed to convert binary SID") unless ConvertSidToStringSid(psid, str_ptr)
begin
strncpy(sid_buf, str_ptr.unpack('L')[0], sid_buf.size - 1)
sid_buf[sid_buf.size - 1] = 0.chr
return sid_buf.strip
ensure
LocalFree(str_ptr.unpack('L')[0])
end
end
# Convert a SID string, e.g. "S-1-5-32-544" to a pointer (containing the
# address of the binary SID structure). The returned value can be used in
# Win32 APIs that expect a PSID, e.g. IsValidSid. The account for this
# SID may or may not exist.
def string_to_sid_ptr(string, &block)
sid_buf = 0.chr * 80
string_addr = [string].pack('p*').unpack('L')[0]
raise Puppet::Util::Windows::Error.new("Failed to convert string SID: #{string}") unless ConvertStringSidToSid(string_addr, sid_buf)
sid_ptr = sid_buf.unpack('L')[0]
begin
yield sid_ptr
ensure
LocalFree(sid_ptr)
end
end
# Return true if the string is a valid SID, e.g. "S-1-5-32-544", false otherwise.
def valid_sid?(string)
string_to_sid_ptr(string) { |ptr| true }
rescue Puppet::Util::Windows::Error => e
if e.code == ERROR_INVALID_SID_STRUCTURE
false
else
raise
end
end
end
end
puppet-3.4.3/lib/puppet/util/windows/file.rb 0000644 0052762 0001160 00000022010 12300765631 020722 0 ustar jenkins jenkins require 'puppet/util/windows'
module Puppet::Util::Windows::File
require 'ffi'
require 'windows/api'
def replace_file(target, source)
target_encoded = Puppet::Util::Windows::String.wide_string(target.to_s)
source_encoded = Puppet::Util::Windows::String.wide_string(source.to_s)
flags = 0x1
backup_file = nil
result = API.replace_file(
target_encoded,
source_encoded,
backup_file,
flags,
0,
0
)
return true if result
raise Puppet::Util::Windows::Error.new("ReplaceFile(#{target}, #{source})")
end
module_function :replace_file
MoveFileEx = Windows::API.new('MoveFileExW', 'PPL', 'B')
def move_file_ex(source, target, flags = 0)
result = MoveFileEx.call(Puppet::Util::Windows::String.wide_string(source.to_s),
Puppet::Util::Windows::String.wide_string(target.to_s),
flags)
return true unless result == 0
raise Puppet::Util::Windows::Error.
new("MoveFileEx(#{source}, #{target}, #{flags.to_s(8)})")
end
module_function :move_file_ex
module API
extend FFI::Library
ffi_lib 'kernel32'
ffi_convention :stdcall
# http://msdn.microsoft.com/en-us/library/windows/desktop/aa365512(v=vs.85).aspx
# BOOL WINAPI ReplaceFile(
# _In_ LPCTSTR lpReplacedFileName,
# _In_ LPCTSTR lpReplacementFileName,
# _In_opt_ LPCTSTR lpBackupFileName,
# _In_ DWORD dwReplaceFlags - 0x1 REPLACEFILE_WRITE_THROUGH,
# 0x2 REPLACEFILE_IGNORE_MERGE_ERRORS,
# 0x4 REPLACEFILE_IGNORE_ACL_ERRORS
# _Reserved_ LPVOID lpExclude,
# _Reserved_ LPVOID lpReserved
# );
attach_function :replace_file, :ReplaceFileW,
[:buffer_in, :buffer_in, :buffer_in, :uint, :uint, :uint], :bool
# BOOLEAN WINAPI CreateSymbolicLink(
# _In_ LPTSTR lpSymlinkFileName, - symbolic link to be created
# _In_ LPTSTR lpTargetFileName, - name of target for symbolic link
# _In_ DWORD dwFlags - 0x0 target is a file, 0x1 target is a directory
# );
# rescue on Windows < 6.0 so that code doesn't explode
begin
attach_function :create_symbolic_link, :CreateSymbolicLinkW,
[:buffer_in, :buffer_in, :uint], :bool
rescue LoadError
end
# DWORD WINAPI GetFileAttributes(
# _In_ LPCTSTR lpFileName
# );
attach_function :get_file_attributes, :GetFileAttributesW,
[:buffer_in], :uint
# HANDLE WINAPI CreateFile(
# _In_ LPCTSTR lpFileName,
# _In_ DWORD dwDesiredAccess,
# _In_ DWORD dwShareMode,
# _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes,
# _In_ DWORD dwCreationDisposition,
# _In_ DWORD dwFlagsAndAttributes,
# _In_opt_ HANDLE hTemplateFile
# );
attach_function :create_file, :CreateFileW,
[:buffer_in, :uint, :uint, :pointer, :uint, :uint, :uint], :uint
# http://msdn.microsoft.com/en-us/library/windows/desktop/aa363216(v=vs.85).aspx
# BOOL WINAPI DeviceIoControl(
# _In_ HANDLE hDevice,
# _In_ DWORD dwIoControlCode,
# _In_opt_ LPVOID lpInBuffer,
# _In_ DWORD nInBufferSize,
# _Out_opt_ LPVOID lpOutBuffer,
# _In_ DWORD nOutBufferSize,
# _Out_opt_ LPDWORD lpBytesReturned,
# _Inout_opt_ LPOVERLAPPED lpOverlapped
# );
attach_function :device_io_control, :DeviceIoControl,
[:uint, :uint, :pointer, :uint, :pointer, :uint, :pointer, :pointer], :bool
MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 16384
# REPARSE_DATA_BUFFER
# http://msdn.microsoft.com/en-us/library/cc232006.aspx
# http://msdn.microsoft.com/en-us/library/windows/hardware/ff552012(v=vs.85).aspx
# struct is always MAXIMUM_REPARSE_DATA_BUFFER_SIZE bytes
class ReparseDataBuffer < FFI::Struct
layout :reparse_tag, :uint,
:reparse_data_length, :ushort,
:reserved, :ushort,
:substitute_name_offset, :ushort,
:substitute_name_length, :ushort,
:print_name_offset, :ushort,
:print_name_length, :ushort,
:flags, :uint,
# max less above fields dword / uint 4 bytes, ushort 2 bytes
:path_buffer, [:uchar, MAXIMUM_REPARSE_DATA_BUFFER_SIZE - 20]
end
# BOOL WINAPI CloseHandle(
# _In_ HANDLE hObject
# );
attach_function :close_handle, :CloseHandle, [:uint], :bool
end
def symlink(target, symlink)
flags = File.directory?(target) ? 0x1 : 0x0
result = API.create_symbolic_link(Puppet::Util::Windows::String.wide_string(symlink.to_s),
Puppet::Util::Windows::String.wide_string(target.to_s), flags)
return true if result
raise Puppet::Util::Windows::Error.new(
"CreateSymbolicLink(#{symlink}, #{target}, #{flags.to_s(8)})")
end
module_function :symlink
INVALID_FILE_ATTRIBUTES = 0xFFFFFFFF #define INVALID_FILE_ATTRIBUTES (DWORD (-1))
def self.get_file_attributes(file_name)
result = API.get_file_attributes(Puppet::Util::Windows::String.wide_string(file_name.to_s))
return result unless result == INVALID_FILE_ATTRIBUTES
raise Puppet::Util::Windows::Error.new("GetFileAttributes(#{file_name})")
end
INVALID_HANDLE_VALUE = -1 #define INVALID_HANDLE_VALUE ((HANDLE)(LONG_PTR)-1)
def self.create_file(file_name, desired_access, share_mode, security_attributes,
creation_disposition, flags_and_attributes, template_file_handle)
result = API.create_file(Puppet::Util::Windows::String.wide_string(file_name.to_s),
desired_access, share_mode, security_attributes, creation_disposition,
flags_and_attributes, template_file_handle)
return result unless result == INVALID_HANDLE_VALUE
raise Puppet::Util::Windows::Error.new(
"CreateFile(#{file_name}, #{desired_access.to_s(8)}, #{share_mode.to_s(8)}, " +
"#{security_attributes}, #{creation_disposition.to_s(8)}, " +
"#{flags_and_attributes.to_s(8)}, #{template_file_handle})")
end
def self.device_io_control(handle, io_control_code, in_buffer = nil, out_buffer = nil)
if out_buffer.nil?
raise Puppet::Util::Windows::Error.new("out_buffer is required")
end
result = API.device_io_control(
handle,
io_control_code,
in_buffer, in_buffer.nil? ? 0 : in_buffer.size,
out_buffer, out_buffer.size,
FFI::MemoryPointer.new(:uint, 1),
nil
)
return out_buffer if result
raise Puppet::Util::Windows::Error.new(
"DeviceIoControl(#{handle}, #{io_control_code}, #{in_buffer}, #{in_buffer.size}, " +
"#{out_buffer}, #{out_buffer.size}")
end
FILE_ATTRIBUTE_REPARSE_POINT = 0x400
def symlink?(file_name)
begin
attributes = get_file_attributes(file_name)
(attributes & FILE_ATTRIBUTE_REPARSE_POINT) == FILE_ATTRIBUTE_REPARSE_POINT
rescue
# raised INVALID_FILE_ATTRIBUTES is equivalent to file not found
false
end
end
module_function :symlink?
GENERIC_READ = 0x80000000
FILE_SHARE_READ = 1
OPEN_EXISTING = 3
FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000
FILE_FLAG_BACKUP_SEMANTICS = 0x02000000
def self.open_symlink(link_name)
begin
yield handle = create_file(
Puppet::Util::Windows::String.wide_string(link_name.to_s),
GENERIC_READ,
FILE_SHARE_READ,
nil, # security_attributes
OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
0) # template_file
ensure
API.close_handle(handle) if handle
end
end
def readlink(link_name)
open_symlink(link_name) do |handle|
resolve_symlink(handle)
end
end
module_function :readlink
def stat(file_name)
file_name = file_name.to_s # accomodate PathName or String
stat = File.stat(file_name)
if symlink?(file_name)
link_ftype = File.stat(readlink(file_name)).ftype
# sigh, monkey patch instance method for instance, and close over link_ftype
singleton_class = class << stat; self; end
singleton_class.send(:define_method, :ftype) do
link_ftype
end
end
stat
end
module_function :stat
def lstat(file_name)
file_name = file_name.to_s # accomodate PathName or String
# monkey'ing around!
stat = File.lstat(file_name)
if symlink?(file_name)
def stat.ftype
"link"
end
end
stat
end
module_function :lstat
private
# http://msdn.microsoft.com/en-us/library/windows/desktop/aa364571(v=vs.85).aspx
FSCTL_GET_REPARSE_POINT = 0x900a8
def self.resolve_symlink(handle)
# must be multiple of 1024, min 10240
out_buffer = FFI::MemoryPointer.new(API::ReparseDataBuffer.size)
device_io_control(handle, FSCTL_GET_REPARSE_POINT, nil, out_buffer)
reparse_data = API::ReparseDataBuffer.new(out_buffer)
offset = reparse_data[:print_name_offset]
length = reparse_data[:print_name_length]
result = reparse_data[:path_buffer].to_a[offset, length].pack('C*')
result.force_encoding('UTF-16LE').encode(Encoding.default_external)
end
end
puppet-3.4.3/lib/puppet/util/windows/access_control_entry.rb 0000644 0052762 0001160 00000004635 12300765631 024242 0 ustar jenkins jenkins # Windows Access Control Entry
#
# Represents an access control entry, which grants or denies a subject,
# identified by a SID, rights to a securable object.
#
# @see http://msdn.microsoft.com/en-us/library/windows/desktop/aa374868(v=vs.85).aspx
# @api private
class Puppet::Util::Windows::AccessControlEntry
require 'puppet/util/windows/security'
include Puppet::Util::Windows::SID
attr_accessor :sid
attr_reader :mask, :flags, :type
OBJECT_INHERIT_ACE = 0x1
CONTAINER_INHERIT_ACE = 0x2
NO_PROPAGATE_INHERIT_ACE = 0x4
INHERIT_ONLY_ACE = 0x8
INHERITED_ACE = 0x10
ACCESS_ALLOWED_ACE_TYPE = 0x0
ACCESS_DENIED_ACE_TYPE = 0x1
def initialize(sid, mask, flags = 0, type = ACCESS_ALLOWED_ACE_TYPE)
@sid = sid
@mask = mask
@flags = flags
@type = type
end
# Returns true if this ACE is inherited from a parent. If false,
# then the ACE is set directly on the object to which it refers.
#
# @return [Boolean] true if the ACE is inherited
def inherited?
(@flags & INHERITED_ACE) == INHERITED_ACE
end
# Returns true if this ACE only applies to children of the object.
# If false, it applies to the object.
#
# @return [Boolean] true if the ACE only applies to children and
# not the object itself.
def inherit_only?
(@flags & INHERIT_ONLY_ACE) == INHERIT_ONLY_ACE
end
# Returns true if this ACE applies to child directories.
#
# @return [Boolean] true if the ACE applies to child direcories
def container_inherit?
(@flags & CONTAINER_INHERIT_ACE) == CONTAINER_INHERIT_ACE
end
# Returns true if this ACE applies to child files.
#
# @return [Boolean] true if the ACE applies to child files.
def object_inherit?
(@flags & OBJECT_INHERIT_ACE) == OBJECT_INHERIT_ACE
end
def inspect
inheritance = ""
inheritance << '(I)' if inherited?
inheritance << '(OI)' if object_inherit?
inheritance << '(CI)' if container_inherit?
inheritance << '(IO)' if inherit_only?
left = "#{sid_to_name(sid)}:#{inheritance}"
left = left.ljust(45)
"#{left} 0x#{mask.to_s(16)}"
end
# Returns true if this ACE is equal to +other+
def ==(other)
self.class == other.class &&
sid == other.sid &&
mask == other.mask &&
flags == other.flags &&
type == other.type
end
alias eql? ==
end
puppet-3.4.3/lib/puppet/util/windows/access_control_list.rb 0000644 0052762 0001160 00000006557 12300765631 024061 0 ustar jenkins jenkins # Windows Access Control List
#
# Represents a list of access control entries (ACEs).
#
# @see http://msdn.microsoft.com/en-us/library/windows/desktop/aa374872(v=vs.85).aspx
# @api private
class Puppet::Util::Windows::AccessControlList
include Enumerable
ACCESS_ALLOWED_ACE_TYPE = 0x0
ACCESS_DENIED_ACE_TYPE = 0x1
# Construct an ACL.
#
# @param acl [Enumerable] A list of aces to copy from.
def initialize(acl = nil)
if acl
@aces = acl.map(&:dup)
else
@aces = []
end
end
# Enumerate each ACE in the list.
#
# @yieldparam ace [Hash] the ace
def each
@aces.each {|ace| yield ace}
end
# Allow the +sid+ to access a resource with the specified access +mask+.
#
# @param sid [String] The SID that the ACE is granting access to
# @param mask [int] The access mask granted to the SID
# @param flags [int] The flags assigned to the ACE, e.g. +INHERIT_ONLY_ACE+
def allow(sid, mask, flags = 0)
@aces << Puppet::Util::Windows::AccessControlEntry.new(sid, mask, flags, ACCESS_ALLOWED_ACE_TYPE)
end
# Deny the +sid+ access to a resource with the specified access +mask+.
#
# @param sid [String] The SID that the ACE is denying access to
# @param mask [int] The access mask denied to the SID
# @param flags [int] The flags assigned to the ACE, e.g. +INHERIT_ONLY_ACE+
def deny(sid, mask, flags = 0)
@aces << Puppet::Util::Windows::AccessControlEntry.new(sid, mask, flags, ACCESS_DENIED_ACE_TYPE)
end
# Reassign all ACEs currently assigned to +old_sid+ to +new_sid+ instead.
# If an ACE is inherited or is not assigned to +old_sid+, then it will
# be copied as-is to the new ACL, preserving its order within the ACL.
#
# @param old_sid [String] The old SID, e.g. 'S-1-5-18'
# @param new_sid [String] The new SID
# @return [AccessControlList] The copied ACL.
def reassign!(old_sid, new_sid)
new_aces = []
prepend_needed = false
aces_to_prepend = []
@aces.each do |ace|
new_ace = ace.dup
if ace.sid == old_sid
if ace.inherited?
# create an explicit ACE granting or denying the
# new_sid the rights that the inherited ACE
# granted or denied the old_sid. We mask off all
# flags except those affecting inheritance of the
# ACE we're creating.
inherit_mask = Windows::Security::CONTAINER_INHERIT_ACE |
Windows::Security::OBJECT_INHERIT_ACE |
Windows::Security::INHERIT_ONLY_ACE
explicit_ace = Puppet::Util::Windows::AccessControlEntry.new(new_sid, ace.mask, ace.flags & inherit_mask, ace.type)
aces_to_prepend << explicit_ace
else
new_ace.sid = new_sid
prepend_needed = old_sid == Win32::Security::SID::LocalSystem
end
end
new_aces << new_ace
end
@aces = []
if prepend_needed
mask = Windows::Security::STANDARD_RIGHTS_ALL | Windows::Security::SPECIFIC_RIGHTS_ALL
ace = Puppet::Util::Windows::AccessControlEntry.new(
Win32::Security::SID::LocalSystem,
mask)
@aces << ace
end
@aces.concat(aces_to_prepend)
@aces.concat(new_aces)
end
def inspect
str = ""
@aces.each do |ace|
str << " #{ace.inspect}\n"
end
str
end
def ==(other)
self.class == other.class &&
self.to_a == other.to_a
end
alias eql? ==
end
puppet-3.4.3/lib/puppet/util/windows/error.rb 0000644 0052762 0001160 00000000530 12300765631 021137 0 ustar jenkins jenkins require 'puppet/util/windows'
# represents an error resulting from a Win32 error code
class Puppet::Util::Windows::Error < Puppet::Error
require 'windows/error'
include ::Windows::Error
attr_reader :code
def initialize(message, code = GetLastError.call)
super(message + ": #{get_last_error(code)}")
@code = code
end
end
puppet-3.4.3/lib/puppet/util/windows/root_certs.rb 0000644 0052762 0001160 00000004751 12300765631 022202 0 ustar jenkins jenkins require 'puppet/util/windows'
require 'openssl'
require 'ffi'
# Represents a collection of trusted root certificates.
#
# @api public
class Puppet::Util::Windows::RootCerts
include Enumerable
extend FFI::Library
typedef :ulong, :dword
typedef :uintptr_t, :handle
def initialize(roots)
@roots = roots
end
# Enumerates each root certificate.
# @yieldparam cert [OpenSSL::X509::Certificate] each root certificate
# @api public
def each
@roots.each {|cert| yield cert}
end
# Returns a new instance.
# @return [Puppet::Util::Windows::RootCerts] object constructed from current root certificates
def self.instance
new(self.load_certs)
end
# Returns an array of root certificates.
#
# @return [Array<[OpenSSL::X509::Certificate]>] an array of root certificates
# @api private
def self.load_certs
certs = []
# This is based on a patch submitted to openssl:
# http://www.mail-archive.com/openssl-dev@openssl.org/msg26958.html
ptr = FFI::Pointer::NULL
store = CertOpenSystemStoreA(nil, "ROOT")
begin
while (ptr = CertEnumCertificatesInStore(store, ptr)) and not ptr.null?
context = CERT_CONTEXT.new(ptr)
cert_buf = context[:pbCertEncoded].read_bytes(context[:cbCertEncoded])
begin
certs << OpenSSL::X509::Certificate.new(cert_buf)
rescue => detail
Puppet.warning("Failed to import root certificate: #{detail.inspect}")
end
end
ensure
CertCloseStore(store, 0)
end
certs
end
private
# typedef ULONG_PTR HCRYPTPROV_LEGACY;
# typedef void *HCERTSTORE;
class CERT_CONTEXT < FFI::Struct
layout(
:dwCertEncodingType, :dword,
:pbCertEncoded, :pointer,
:cbCertEncoded, :dword,
:pCertInfo, :pointer,
:hCertStore, :handle
)
end
# HCERTSTORE
# WINAPI
# CertOpenSystemStoreA(
# __in_opt HCRYPTPROV_LEGACY hProv,
# __in LPCSTR szSubsystemProtocol
# );
ffi_lib :crypt32
attach_function :CertOpenSystemStoreA, [:pointer, :string], :handle
# PCCERT_CONTEXT
# WINAPI
# CertEnumCertificatesInStore(
# __in HCERTSTORE hCertStore,
# __in_opt PCCERT_CONTEXT pPrevCertContext
# );
ffi_lib :crypt32
attach_function :CertEnumCertificatesInStore, [:handle, :pointer], :pointer
# BOOL
# WINAPI
# CertCloseStore(
# __in_opt HCERTSTORE hCertStore,
# __in DWORD dwFlags
# );
ffi_lib :crypt32
attach_function :CertCloseStore, [:handle, :dword], :bool
end
puppet-3.4.3/lib/puppet/util/reference.rb 0000644 0052762 0001160 00000005637 12300765631 020267 0 ustar jenkins jenkins require 'puppet/util/instance_loader'
require 'puppet/util/methodhelper'
require 'fileutils'
# Manage Reference Documentation.
class Puppet::Util::Reference
include Puppet::Util
include Puppet::Util::MethodHelper
include Puppet::Util::Docs
extend Puppet::Util::InstanceLoader
instance_load(:reference, 'puppet/reference')
def self.footer
"\n\n----------------\n\n*This page autogenerated on #{Time.now}*\n"
end
def self.modes
%w{pdf text}
end
def self.newreference(name, options = {}, &block)
ref = self.new(name, options, &block)
instance_hash(:reference)[name.intern] = ref
ref
end
def self.page(*sections)
depth = 4
# Use the minimum depth
sections.each do |name|
section = reference(name) or raise "Could not find section #{name}"
depth = section.depth if section.depth < depth
end
end
def self.pdf(text)
puts "creating pdf"
rst2latex = which('rst2latex') || which('rst2latex.py') ||
raise("Could not find rst2latex")
cmd = %{#{rst2latex} /tmp/puppetdoc.txt > /tmp/puppetdoc.tex}
Puppet::Util.replace_file("/tmp/puppetdoc.txt") {|f| f.puts text }
# There used to be an attempt to use secure_open / replace_file to secure
# the target, too, but that did nothing: the race was still here. We can
# get exactly the same benefit from running this effort:
Puppet::FileSystem::File.unlink('/tmp/puppetdoc.tex') rescue nil
output = %x{#{cmd}}
unless $CHILD_STATUS == 0
$stderr.puts "rst2latex failed"
$stderr.puts output
exit(1)
end
$stderr.puts output
# Now convert to pdf
Dir.chdir("/tmp") do
%x{texi2pdf puppetdoc.tex >/dev/null 2>/dev/null}
end
end
def self.references
instance_loader(:reference).loadall
loaded_instances(:reference).sort { |a,b| a.to_s <=> b.to_s }
end
attr_accessor :page, :depth, :header, :title, :dynamic
attr_writer :doc
def doc
if defined?(@doc)
return "#{@name} - #{@doc}"
else
return @title
end
end
def dynamic?
self.dynamic
end
def initialize(name, options = {}, &block)
@name = name
set_options(options)
meta_def(:generate, &block)
# Now handle the defaults
@title ||= "#{@name.to_s.capitalize} Reference"
@page ||= @title.gsub(/\s+/, '')
@depth ||= 2
@header ||= ""
end
# Indent every line in the chunk except those which begin with '..'.
def indent(text, tab)
text.gsub(/(^|\A)/, tab).gsub(/^ +\.\./, "..")
end
def option(name, value)
":#{name.to_s.capitalize}: #{value}\n"
end
def text
puts output
end
def to_markdown(withcontents = true)
# First the header
text = markdown_header(@title, 1)
text << "\n\n**This page is autogenerated; any changes will get overwritten** *(last generated on #{Time.now.to_s})*\n\n"
text << @header
text << generate
text << self.class.footer if withcontents
text
end
end
puppet-3.4.3/lib/puppet/util/profiler.rb 0000644 0052762 0001160 00000001440 12300765631 020137 0 ustar jenkins jenkins require 'benchmark'
# A simple profiling callback system.
#
# @api private
module Puppet::Util::Profiler
require 'puppet/util/profiler/wall_clock'
require 'puppet/util/profiler/object_counts'
require 'puppet/util/profiler/none'
NONE = Puppet::Util::Profiler::None.new
# Reset the profiling system to the original state
def self.clear
@profiler = nil
end
# @return This thread's configured profiler
def self.current
@profiler || NONE
end
# @param profiler [#profile] A profiler for the current thread
def self.current=(profiler)
@profiler = profiler
end
# @param message [String] A description of the profiled event
# @param block [Block] The segment of code to profile
def self.profile(message, &block)
current.profile(message, &block)
end
end
puppet-3.4.3/lib/puppet/util/user_attr.rb 0000644 0052762 0001160 00000000720 12300765631 020325 0 ustar jenkins jenkins class UserAttr
def self.get_attributes_by_name(name)
attributes = nil
File.readlines('/etc/user_attr').each do |line|
next if line =~ /^#/
token = line.split(':')
if token[0] == name
attributes = {:name => name}
token[4].split(';').each do |attr|
key_value = attr.split('=')
attributes[key_value[0].intern] = key_value[1].strip
end
break
end
end
attributes
end
end
puppet-3.4.3/lib/puppet/util/windows.rb 0000644 0052762 0001160 00000001214 12300765631 020006 0 ustar jenkins jenkins module Puppet::Util::Windows
if Puppet::Util::Platform.windows?
# these reference platform specific gems
require 'puppet/util/windows/error'
require 'puppet/util/windows/sid'
require 'puppet/util/windows/security'
require 'puppet/util/windows/user'
require 'puppet/util/windows/process'
require 'puppet/util/windows/string'
require 'puppet/util/windows/file'
require 'puppet/util/windows/root_certs'
require 'puppet/util/windows/access_control_entry'
require 'puppet/util/windows/access_control_list'
require 'puppet/util/windows/security_descriptor'
end
require 'puppet/util/windows/registry'
end
puppet-3.4.3/lib/puppet/util/docs.rb 0000644 0052762 0001160 00000007702 12300765631 017254 0 ustar jenkins jenkins # Some simple methods for helping manage automatic documentation generation.
module Puppet::Util::Docs
# Specify the actual doc string.
def desc(str)
@doc = str
end
# Add a new autodoc block. We have to define these as class methods,
# rather than just sticking them in a hash, because otherwise they're
# too difficult to do inheritance with.
def dochook(name, &block)
method = "dochook_#{name}"
meta_def method, &block
end
attr_writer :doc
# Generate the full doc string.
def doc
extra = methods.find_all { |m| m.to_s =~ /^dochook_.+/ }.sort.collect { |m|
self.send(m)
}.delete_if {|r| r.nil? }.collect {|r| "* #{r}"}.join("\n")
if @doc
scrub(@doc) + (extra.empty? ? '' : "\n\n#{extra}")
else
extra
end
end
# Build a table
def doctable(headers, data)
str = "\n\n"
lengths = []
# Figure out the longest field for all columns
data.each do |name, values|
[name, values].flatten.each_with_index do |value, i|
lengths[i] ||= 0
lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
end
end
# The headers could also be longest
headers.each_with_index do |value, i|
lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
end
# Add the header names
str += headers.zip(lengths).collect { |value, num| pad(value, num) }.join(" | ") + " |" + "\n"
# And the header row
str += lengths.collect { |num| "-" * num }.join(" | ") + " |" + "\n"
# Now each data row
data.sort { |a, b| a[0].to_s <=> b[0].to_s }.each do |name, rows|
str += [name, rows].flatten.zip(lengths).collect do |value, length|
pad(value, length)
end.join(" | ") + " |" + "\n"
end
str + "\n"
end
# There is nothing that would ever set this. It gets read in reference/type.rb, but will never have any value but nil.
attr_reader :nodoc
def nodoc?
nodoc
end
# Pad a field with spaces
def pad(value, length)
value.to_s + (" " * (length - value.to_s.length))
end
HEADER_LEVELS = [nil, "#", "##", "###", "####", "#####"]
def markdown_header(name, level)
"#{HEADER_LEVELS[level]} #{name}\n\n"
end
def markdown_definitionlist(term, definition)
lines = scrub(definition).split("\n")
str = "#{term}\n: #{lines.shift}\n"
lines.each do |line|
str << " " if line =~ /\S/
str << "#{line}\n"
end
str << "\n"
end
# Strip indentation and trailing whitespace from embedded doc fragments.
#
# Multi-line doc fragments are sometimes indented in order to preserve the
# formatting of the code they're embedded in. Since indents are syntactic
# elements in Markdown, we need to make sure we remove any indent that was
# added solely to preserve surrounding code formatting, but LEAVE any indent
# that delineates a Markdown element (code blocks, multi-line bulleted list
# items). We can do this by removing the *least common indent* from each line.
#
# Least common indent is defined as follows:
#
# * Find the smallest amount of leading space on any line...
# * ...excluding the first line (which may have zero indent without affecting
# the common indent)...
# * ...and excluding lines that consist solely of whitespace.
# * The least common indent may be a zero-length string, if the fragment is
# not indented to match code.
# * If there are hard tabs for some dumb reason, we assume they're at least
# consistent within this doc fragment.
#
# See tests in spec/unit/util/docs_spec.rb for examples.
def scrub(text)
# One-liners are easy!
return text.strip if text !~ /\n/
excluding_first_line = text.partition("\n").last
indent = excluding_first_line.scan(/^[ \t]*(?=\S)/).min || '' # prevent nil
# Clean hanging indent, if any
if indent.length > 0
text = text.gsub(/^#{indent}/, '')
end
# Clean trailing space
text.lines.map{|line|line.rstrip}.join("\n").rstrip
end
module_function :scrub
end
puppet-3.4.3/lib/puppet/util/log/ 0000755 0052762 0001160 00000000000 12300765640 016552 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/util/log/destinations.rb 0000644 0052762 0001160 00000012332 12300765631 021604 0 ustar jenkins jenkins Puppet::Util::Log.newdesttype :syslog do
def self.suitable?(obj)
Puppet.features.syslog?
end
def close
Syslog.close
end
def initialize
Syslog.close if Syslog.opened?
name = "puppet-#{Puppet.run_mode.name}"
options = Syslog::LOG_PID | Syslog::LOG_NDELAY
# XXX This should really be configurable.
str = Puppet[:syslogfacility]
begin
facility = Syslog.const_get("LOG_#{str.upcase}")
rescue NameError
raise Puppet::Error, "Invalid syslog facility #{str}"
end
@syslog = Syslog.open(name, options, facility)
end
def handle(msg)
# XXX Syslog currently has a bug that makes it so you
# cannot log a message with a '%' in it. So, we get rid
# of them.
if msg.source == "Puppet"
msg.to_s.split("\n").each do |line|
@syslog.send(msg.level, line.gsub("%", '%%'))
end
else
msg.to_s.split("\n").each do |line|
@syslog.send(msg.level, "(%s) %s" % [msg.source.to_s.gsub("%", ""),
line.gsub("%", '%%')
]
)
end
end
end
end
Puppet::Util::Log.newdesttype :file do
require 'fileutils'
def self.match?(obj)
Puppet::Util.absolute_path?(obj)
end
def close
if defined?(@file)
@file.close
@file = nil
end
end
def flush
@file.flush if defined?(@file)
end
attr_accessor :autoflush
def initialize(path)
@name = path
# first make sure the directory exists
# We can't just use 'Config.use' here, because they've
# specified a "special" destination.
unless Puppet::FileSystem::File.exist?(File.dirname(path))
FileUtils.mkdir_p(File.dirname(path), :mode => 0755)
Puppet.info "Creating log directory #{File.dirname(path)}"
end
# create the log file, if it doesn't already exist
file = File.open(path, File::WRONLY|File::CREAT|File::APPEND)
# Give ownership to the user and group puppet will run as
begin
FileUtils.chown(Puppet[:user], Puppet[:group], path) unless Puppet::Util::Platform.windows?
rescue ArgumentError, Errno::EPERM
Puppet.err "Unable to set ownership of log file"
end
@file = file
@autoflush = Puppet[:autoflush]
end
def handle(msg)
@file.puts("#{msg.time} #{msg.source} (#{msg.level}): #{msg}")
@file.flush if @autoflush
end
end
Puppet::Util::Log.newdesttype :logstash_event do
require 'time'
def format(msg)
# logstash_event format is documented at
# https://logstash.jira.com/browse/LOGSTASH-675
data = {}
data = msg.to_hash
data['version'] = 1
data['@timestamp'] = data['time']
data.delete('time')
data
end
def handle(msg)
message = format(msg)
$stdout.puts message.to_pson
end
end
Puppet::Util::Log.newdesttype :console do
require 'puppet/util/colors'
include Puppet::Util::Colors
def initialize
# Flush output immediately.
$stderr.sync = true
$stdout.sync = true
end
def handle(msg)
levels = {
:emerg => { :name => 'Emergency', :color => :hred, :stream => $stderr },
:alert => { :name => 'Alert', :color => :hred, :stream => $stderr },
:crit => { :name => 'Critical', :color => :hred, :stream => $stderr },
:err => { :name => 'Error', :color => :hred, :stream => $stderr },
:warning => { :name => 'Warning', :color => :hred, :stream => $stderr },
:notice => { :name => 'Notice', :color => :reset, :stream => $stdout },
:info => { :name => 'Info', :color => :green, :stream => $stdout },
:debug => { :name => 'Debug', :color => :cyan, :stream => $stdout },
}
str = msg.respond_to?(:multiline) ? msg.multiline : msg.to_s
str = msg.source == "Puppet" ? str : "#{msg.source}: #{str}"
level = levels[msg.level]
level[:stream].puts colorize(level[:color], "#{level[:name]}: #{str}")
end
end
# Log to a transaction report.
Puppet::Util::Log.newdesttype :report do
attr_reader :report
match "Puppet::Transaction::Report"
def initialize(report)
@report = report
end
def handle(msg)
@report << msg
end
end
# Log to an array, just for testing.
module Puppet::Test
class LogCollector
def initialize(logs)
@logs = logs
end
def <<(value)
@logs << value
end
end
end
Puppet::Util::Log.newdesttype :array do
match "Puppet::Test::LogCollector"
def initialize(messages)
@messages = messages
end
def handle(msg)
@messages << msg
end
end
Puppet::Util::Log.newdesttype :eventlog do
def self.suitable?(obj)
Puppet.features.eventlog?
end
def initialize
@eventlog = Win32::EventLog.open("Application")
end
def to_native(level)
case level
when :debug,:info,:notice
[Win32::EventLog::INFO, 0x01]
when :warning
[Win32::EventLog::WARN, 0x02]
when :err,:alert,:emerg,:crit
[Win32::EventLog::ERROR, 0x03]
end
end
def handle(msg)
native_type, native_id = to_native(msg.level)
@eventlog.report_event(
:source => "Puppet",
:event_type => native_type,
:event_id => native_id,
:data => (msg.source and msg.source != 'Puppet' ? "#{msg.source}: " : '') + msg.to_s
)
end
def close
if @eventlog
@eventlog.close
@eventlog = nil
end
end
end
puppet-3.4.3/lib/puppet/util/log/rate_limited_logger.rb 0000644 0052762 0001160 00000002324 12300765631 023101 0 ustar jenkins jenkins require 'puppet/util/logging'
# Logging utility class that limits the frequency of identical log messages
class Puppet::Util::Log::RateLimitedLogger
include Puppet::Util::Logging
def initialize(interval)
raise ArgumentError, "Logging rate-limit interval must be an integer" unless interval.is_a?(Integer)
@interval = interval
@log_record = {}
end
# Override the logging entry point to rate-limit it
def send_log(level, message)
Puppet::Util::Log.create({:level => level, :message => message}) if should_log?(level, message)
end
private
def should_log?(level, message)
# Initialize separate records for different levels, and only when needed
record = (@log_record[level] ||= {})
last_log = record[message]
# Skip logging if the time interval since the last logging hasn't elapsed yet
return false if last_log and within_interval?(last_log)
# Purge stale entries; do this after the interval check to reduce passes through the cache
record.delete_if { |key, time| !within_interval?(time) }
# Reset the beginning of the interval to the current time
record[message] = Time.now
true
end
def within_interval?(time)
time + @interval > Time.now
end
end
puppet-3.4.3/lib/puppet/util/log/destination.rb 0000644 0052762 0001160 00000001732 12300765631 021423 0 ustar jenkins jenkins # A type of log destination.
class Puppet::Util::Log::Destination
class << self
attr_accessor :name
end
def self.initvars
@matches = []
end
# Mark the things we're supposed to match.
def self.match(obj)
@matches ||= []
@matches << obj
end
# See whether we match a given thing.
def self.match?(obj)
# Convert single-word strings into symbols like :console and :syslog
if obj.is_a? String and obj =~ /^\w+$/
obj = obj.downcase.intern
end
@matches.each do |thing|
# Search for direct matches or class matches
return true if thing === obj or thing == obj.class.to_s
end
false
end
def name
if defined?(@name)
return @name
else
return self.class.name
end
end
# Set how to handle a message.
def self.sethandler(&block)
define_method(:handle, &block)
end
# Mark how to initialize our object.
def self.setinit(&block)
define_method(:initialize, &block)
end
end
puppet-3.4.3/lib/puppet/util/symbolic_file_mode.rb 0000644 0052762 0001160 00000010752 12300765631 022147 0 ustar jenkins jenkins require 'puppet/util'
module Puppet
module Util
module SymbolicFileMode
SetUIDBit = ReadBit = 4
SetGIDBit = WriteBit = 2
StickyBit = ExecBit = 1
SymbolicMode = { 'x' => ExecBit, 'w' => WriteBit, 'r' => ReadBit }
SymbolicSpecialToBit = {
't' => { 'u' => StickyBit, 'g' => StickyBit, 'o' => StickyBit },
's' => { 'u' => SetUIDBit, 'g' => SetGIDBit, 'o' => StickyBit }
}
def valid_symbolic_mode?(value)
value = normalize_symbolic_mode(value)
return true if value =~ /^0?[0-7]{1,4}$/
return true if value =~ /^([ugoa]*[-=+][-=+rstwxXugo]*)(,[ugoa]*[-=+][-=+rstwxXugo]*)*$/
return false
end
def normalize_symbolic_mode(value)
return nil if value.nil?
# We need to treat integers as octal numbers.
if value.is_a? Numeric then
return value.to_s(8)
elsif value =~ /^0?[0-7]{1,4}$/ then
return value.to_i(8).to_s(8)
else
return value
end
end
def symbolic_mode_to_int(modification, to_mode = 0, is_a_directory = false)
if modification.nil? or modification == '' then
raise Puppet::Error, "An empty mode string is illegal"
end
if modification =~ /^[0-7]+$/ then return modification.to_i(8) end
if modification =~ /^\d+$/ then
raise Puppet::Error, "Numeric modes must be in octal, not decimal!"
end
fail "non-numeric current mode (#{to_mode.inspect})" unless to_mode.is_a?(Numeric)
original_mode = {
's' => (to_mode & 07000) >> 9,
'u' => (to_mode & 00700) >> 6,
'g' => (to_mode & 00070) >> 3,
'o' => (to_mode & 00007) >> 0,
# Are there any execute bits set in the original mode?
'any x?' => (to_mode & 00111) != 0
}
final_mode = {
's' => original_mode['s'],
'u' => original_mode['u'],
'g' => original_mode['g'],
'o' => original_mode['o'],
}
modification.split(/\s*,\s*/).each do |part|
begin
_, to, dsl = /^([ugoa]*)([-+=].*)$/.match(part).to_a
if dsl.nil? then raise Puppet::Error, 'Missing action' end
to = "a" unless to and to.length > 0
# We want a snapshot of the mode before we start messing with it to
# make actions like 'a-g' atomic. Various parts of the DSL refer to
# the original mode, the final mode, or the current snapshot of the
# mode, for added fun.
snapshot_mode = {}
final_mode.each {|k,v| snapshot_mode[k] = v }
to.gsub('a', 'ugo').split('').uniq.each do |who|
value = snapshot_mode[who]
action = '!'
actions = {
'!' => lambda {|_,_| raise Puppet::Error, 'Missing operation (-, =, or +)' },
'=' => lambda {|m,v| m | v },
'+' => lambda {|m,v| m | v },
'-' => lambda {|m,v| m & ~v },
}
dsl.split('').each do |op|
case op
when /[-+=]/ then
action = op
# Clear all bits, if this is assignment
value = 0 if op == '='
when /[ugo]/ then
value = actions[action].call(value, snapshot_mode[op])
when /[rwx]/ then
value = actions[action].call(value, SymbolicMode[op])
when 'X' then
# Only meaningful in combination with "set" actions.
if action != '+' then
raise Puppet::Error, "X only works with the '+' operator"
end
# As per the BSD manual page, set if this is a directory, or if
# any execute bit is set on the original (unmodified) mode.
# Ignored otherwise; it is "add if", not "add or clear".
if is_a_directory or original_mode['any x?'] then
value = actions[action].call(value, ExecBit)
end
when /[st]/ then
bit = SymbolicSpecialToBit[op][who] or fail "internal error"
final_mode['s'] = actions[action].call(final_mode['s'], bit)
else
raise Puppet::Error, 'Unknown operation'
end
end
# Now, assign back the value.
final_mode[who] = value
end
rescue Puppet::Error => e
if part.inspect != modification.inspect then
rest = " at #{part.inspect}"
else
rest = ''
end
raise Puppet::Error, "#{e}#{rest} in symbolic mode #{modification.inspect}"
end
end
result =
final_mode['s'] << 9 |
final_mode['u'] << 6 |
final_mode['g'] << 3 |
final_mode['o'] << 0
return result
end
end
end
end
puppet-3.4.3/lib/puppet/util/command_line/ 0000755 0052762 0001160 00000000000 12300765640 020416 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/util/command_line/trollop.rb 0000644 0052762 0001160 00000070260 12300765631 022443 0 ustar jenkins jenkins ## lib/trollop.rb -- trollop command-line processing library
## Author:: William Morgan (mailto: wmorgan-trollop@masanjin.net)
## Copyright:: Copyright 2007 William Morgan
## License:: the same terms as ruby itself
##
## 2012-03: small changes made by cprice (chris@puppetlabs.com);
## patch submitted for upstream consideration:
## https://gitorious.org/trollop/mainline/merge_requests/9
## 2012-08: namespace changes made by Jeff McCune (jeff@puppetlabs.com)
## moved Trollop into Puppet::Util::CommandLine to prevent monkey
## patching the upstream trollop library if also loaded.
require 'date'
module Puppet
module Util
class CommandLine
module Trollop
VERSION = "1.16.2"
## Thrown by Parser in the event of a commandline error. Not needed if
## you're using the Trollop::options entry.
class CommandlineError < StandardError; end
## Thrown by Parser if the user passes in '-h' or '--help'. Handled
## automatically by Trollop#options.
class HelpNeeded < StandardError; end
## Thrown by Parser if the user passes in '-h' or '--version'. Handled
## automatically by Trollop#options.
class VersionNeeded < StandardError; end
## Regex for floating point numbers
FLOAT_RE = /^-?((\d+(\.\d+)?)|(\.\d+))([eE][-+]?[\d]+)?$/
## Regex for parameters
PARAM_RE = /^-(-|\.$|[^\d\.])/
## The commandline parser. In typical usage, the methods in this class
## will be handled internally by Trollop::options. In this case, only the
## #opt, #banner and #version, #depends, and #conflicts methods will
## typically be called.
##
## If you want to instantiate this class yourself (for more complicated
## argument-parsing logic), call #parse to actually produce the output hash,
## and consider calling it from within
## Trollop::with_standard_exception_handling.
class Parser
## The set of values that indicate a flag option when passed as the
## +:type+ parameter of #opt.
FLAG_TYPES = [:flag, :bool, :boolean]
## The set of values that indicate a single-parameter (normal) option when
## passed as the +:type+ parameter of #opt.
##
## A value of +io+ corresponds to a readable IO resource, including
## a filename, URI, or the strings 'stdin' or '-'.
SINGLE_ARG_TYPES = [:int, :integer, :string, :double, :float, :io, :date]
## The set of values that indicate a multiple-parameter option (i.e., that
## takes multiple space-separated values on the commandline) when passed as
## the +:type+ parameter of #opt.
MULTI_ARG_TYPES = [:ints, :integers, :strings, :doubles, :floats, :ios, :dates]
## The complete set of legal values for the +:type+ parameter of #opt.
TYPES = FLAG_TYPES + SINGLE_ARG_TYPES + MULTI_ARG_TYPES
INVALID_SHORT_ARG_REGEX = /[\d-]/ #:nodoc:
## The values from the commandline that were not interpreted by #parse.
attr_reader :leftovers
## The complete configuration hashes for each option. (Mainly useful
## for testing.)
attr_reader :specs
## A flag that determines whether or not to attempt to automatically generate "short" options if they are not
## explicitly specified.
attr_accessor :create_default_short_options
## A flag that determines whether or not to raise an error if the parser is passed one or more
## options that were not registered ahead of time. If 'true', then the parser will simply
## ignore options that it does not recognize.
attr_accessor :ignore_invalid_options
## A flag indicating whether or not the parser should attempt to handle "--help" and
## "--version" specially. If 'false', it will treat them just like any other option.
attr_accessor :handle_help_and_version
## Initializes the parser, and instance-evaluates any block given.
def initialize *a, &b
@version = nil
@leftovers = []
@specs = {}
@long = {}
@short = {}
@order = []
@constraints = []
@stop_words = []
@stop_on_unknown = false
#instance_eval(&b) if b # can't take arguments
cloaker(&b).bind(self).call(*a) if b
end
## Define an option. +name+ is the option name, a unique identifier
## for the option that you will use internally, which should be a
## symbol or a string. +desc+ is a string description which will be
## displayed in help messages.
##
## Takes the following optional arguments:
##
## [+:long+] Specify the long form of the argument, i.e. the form with two dashes. If unspecified, will be automatically derived based on the argument name by turning the +name+ option into a string, and replacing any _'s by -'s.
## [+:short+] Specify the short form of the argument, i.e. the form with one dash. If unspecified, will be automatically derived from +name+.
## [+:type+] Require that the argument take a parameter or parameters of type +type+. For a single parameter, the value can be a member of +SINGLE_ARG_TYPES+, or a corresponding Ruby class (e.g. +Integer+ for +:int+). For multiple-argument parameters, the value can be any member of +MULTI_ARG_TYPES+ constant. If unset, the default argument type is +:flag+, meaning that the argument does not take a parameter. The specification of +:type+ is not necessary if a +:default+ is given.
## [+:default+] Set the default value for an argument. Without a default value, the hash returned by #parse (and thus Trollop::options) will have a +nil+ value for this key unless the argument is given on the commandline. The argument type is derived automatically from the class of the default value given, so specifying a +:type+ is not necessary if a +:default+ is given. (But see below for an important caveat when +:multi+: is specified too.) If the argument is a flag, and the default is set to +true+, then if it is specified on the the commandline the value will be +false+.
## [+:required+] If set to +true+, the argument must be provided on the commandline.
## [+:multi+] If set to +true+, allows multiple occurrences of the option on the commandline. Otherwise, only a single instance of the option is allowed. (Note that this is different from taking multiple parameters. See below.)
##
## Note that there are two types of argument multiplicity: an argument
## can take multiple values, e.g. "--arg 1 2 3". An argument can also
## be allowed to occur multiple times, e.g. "--arg 1 --arg 2".
##
## Arguments that take multiple values should have a +:type+ parameter
## drawn from +MULTI_ARG_TYPES+ (e.g. +:strings+), or a +:default:+
## value of an array of the correct type (e.g. [String]). The
## value of this argument will be an array of the parameters on the
## commandline.
##
## Arguments that can occur multiple times should be marked with
## +:multi+ => +true+. The value of this argument will also be an array.
## In contrast with regular non-multi options, if not specified on
## the commandline, the default value will be [], not nil.
##
## These two attributes can be combined (e.g. +:type+ => +:strings+,
## +:multi+ => +true+), in which case the value of the argument will be
## an array of arrays.
##
## There's one ambiguous case to be aware of: when +:multi+: is true and a
## +:default+ is set to an array (of something), it's ambiguous whether this
## is a multi-value argument as well as a multi-occurrence argument.
## In thise case, Trollop assumes that it's not a multi-value argument.
## If you want a multi-value, multi-occurrence argument with a default
## value, you must specify +:type+ as well.
def opt name, desc="", opts={}
raise ArgumentError, "you already have an argument named '#{name}'" if @specs.member? name
## fill in :type
opts[:type] = # normalize
case opts[:type]
when :boolean, :bool; :flag
when :integer; :int
when :integers; :ints
when :double; :float
when :doubles; :floats
when Class
case opts[:type].name
when 'TrueClass', 'FalseClass'; :flag
when 'String'; :string
when 'Integer'; :int
when 'Float'; :float
when 'IO'; :io
when 'Date'; :date
else
raise ArgumentError, "unsupported argument type '#{opts[:type].class.name}'"
end
when nil; nil
else
raise ArgumentError, "unsupported argument type '#{opts[:type]}'" unless TYPES.include?(opts[:type])
opts[:type]
end
## for options with :multi => true, an array default doesn't imply
## a multi-valued argument. for that you have to specify a :type
## as well. (this is how we disambiguate an ambiguous situation;
## see the docs for Parser#opt for details.)
disambiguated_default =
if opts[:multi] && opts[:default].is_a?(Array) && !opts[:type]
opts[:default].first
else
opts[:default]
end
type_from_default =
case disambiguated_default
when Integer; :int
when Numeric; :float
when TrueClass, FalseClass; :flag
when String; :string
when IO; :io
when Date; :date
when Array
if opts[:default].empty?
raise ArgumentError, "multiple argument type cannot be deduced from an empty array for '#{opts[:default][0].class.name}'"
end
case opts[:default][0] # the first element determines the types
when Integer; :ints
when Numeric; :floats
when String; :strings
when IO; :ios
when Date; :dates
else
raise ArgumentError, "unsupported multiple argument type '#{opts[:default][0].class.name}'"
end
when nil; nil
else
raise ArgumentError, "unsupported argument type '#{opts[:default].class.name}'"
end
raise ArgumentError, ":type specification and default type don't match (default type is #{type_from_default})" if opts[:type] && type_from_default && opts[:type] != type_from_default
opts[:type] = opts[:type] || type_from_default || :flag
## fill in :long
opts[:long] = opts[:long] ? opts[:long].to_s : name.to_s.gsub("_", "-")
opts[:long] =
case opts[:long]
when /^--([^-].*)$/
$1
when /^[^-]/
opts[:long]
else
raise ArgumentError, "invalid long option name #{opts[:long].inspect}"
end
raise ArgumentError, "long option name #{opts[:long].inspect} is already taken; please specify a (different) :long" if @long[opts[:long]]
## fill in :short
opts[:short] = opts[:short].to_s if opts[:short] unless opts[:short] == :none
opts[:short] = case opts[:short]
when /^-(.)$/; $1
when nil, :none, /^.$/; opts[:short]
else raise ArgumentError, "invalid short option name '#{opts[:short].inspect}'"
end
if opts[:short]
raise ArgumentError, "short option name #{opts[:short].inspect} is already taken; please specify a (different) :short" if @short[opts[:short]]
raise ArgumentError, "a short option name can't be a number or a dash" if opts[:short] =~ INVALID_SHORT_ARG_REGEX
end
## fill in :default for flags
opts[:default] = false if opts[:type] == :flag && opts[:default].nil?
## autobox :default for :multi (multi-occurrence) arguments
opts[:default] = [opts[:default]] if opts[:default] && opts[:multi] && !opts[:default].is_a?(Array)
## fill in :multi
opts[:multi] ||= false
opts[:desc] ||= desc
@long[opts[:long]] = name
@short[opts[:short]] = name if opts[:short] && opts[:short] != :none
@specs[name] = opts
@order << [:opt, name]
end
## Sets the version string. If set, the user can request the version
## on the commandline. Should probably be of the form "
## ".
def version s=nil; @version = s if s; @version end
## Adds text to the help display. Can be interspersed with calls to
## #opt to build a multi-section help page.
def banner s; @order << [:text, s] end
alias :text :banner
## Marks two (or more!) options as requiring each other. Only handles
## undirected (i.e., mutual) dependencies. Directed dependencies are
## better modeled with Trollop::die.
def depends *syms
syms.each { |sym| raise ArgumentError, "unknown option '#{sym}'" unless @specs[sym] }
@constraints << [:depends, syms]
end
## Marks two (or more!) options as conflicting.
def conflicts *syms
syms.each { |sym| raise ArgumentError, "unknown option '#{sym}'" unless @specs[sym] }
@constraints << [:conflicts, syms]
end
## Defines a set of words which cause parsing to terminate when
## encountered, such that any options to the left of the word are
## parsed as usual, and options to the right of the word are left
## intact.
##
## A typical use case would be for subcommand support, where these
## would be set to the list of subcommands. A subsequent Trollop
## invocation would then be used to parse subcommand options, after
## shifting the subcommand off of ARGV.
def stop_on *words
@stop_words = [*words].flatten
end
## Similar to #stop_on, but stops on any unknown word when encountered
## (unless it is a parameter for an argument). This is useful for
## cases where you don't know the set of subcommands ahead of time,
## i.e., without first parsing the global options.
def stop_on_unknown
@stop_on_unknown = true
end
## Parses the commandline. Typically called by Trollop::options,
## but you can call it directly if you need more control.
##
## throws CommandlineError, HelpNeeded, and VersionNeeded exceptions.
def parse cmdline=ARGV
vals = {}
required = {}
if handle_help_and_version
opt :version, "Print version and exit" if @version unless @specs[:version] || @long["version"]
opt :help, "Show this message" unless @specs[:help] || @long["help"]
end
@specs.each do |sym, opts|
required[sym] = true if opts[:required]
vals[sym] = opts[:default]
vals[sym] = [] if opts[:multi] && !opts[:default] # multi arguments default to [], not nil
end
resolve_default_short_options if create_default_short_options
## resolve symbols
given_args = {}
@leftovers = each_arg cmdline do |arg, params|
sym = case arg
when /^-([^-])$/
@short[$1]
when /^--no-([^-]\S*)$/
@long["[no-]#{$1}"]
when /^--([^-]\S*)$/
@long[$1] ? @long[$1] : @long["[no-]#{$1}"]
else
raise CommandlineError, "invalid argument syntax: '#{arg}'"
end
unless sym
next 0 if ignore_invalid_options
raise CommandlineError, "unknown argument '#{arg}'" unless sym
end
if given_args.include?(sym) && !@specs[sym][:multi]
raise CommandlineError, "option '#{arg}' specified multiple times"
end
given_args[sym] ||= {}
given_args[sym][:arg] = arg
given_args[sym][:params] ||= []
# The block returns the number of parameters taken.
num_params_taken = 0
unless params.nil?
if SINGLE_ARG_TYPES.include?(@specs[sym][:type])
given_args[sym][:params] << params[0, 1] # take the first parameter
num_params_taken = 1
elsif MULTI_ARG_TYPES.include?(@specs[sym][:type])
given_args[sym][:params] << params # take all the parameters
num_params_taken = params.size
end
end
num_params_taken
end
if handle_help_and_version
## check for version and help args
raise VersionNeeded if given_args.include? :version
raise HelpNeeded if given_args.include? :help
end
## check constraint satisfaction
@constraints.each do |type, syms|
constraint_sym = syms.find { |sym| given_args[sym] }
next unless constraint_sym
case type
when :depends
syms.each { |sym| raise CommandlineError, "--#{@specs[constraint_sym][:long]} requires --#{@specs[sym][:long]}" unless given_args.include? sym }
when :conflicts
syms.each { |sym| raise CommandlineError, "--#{@specs[constraint_sym][:long]} conflicts with --#{@specs[sym][:long]}" if given_args.include?(sym) && (sym != constraint_sym) }
end
end
required.each do |sym, val|
raise CommandlineError, "option --#{@specs[sym][:long]} must be specified" unless given_args.include? sym
end
## parse parameters
given_args.each do |sym, given_data|
arg = given_data[:arg]
params = given_data[:params]
opts = @specs[sym]
raise CommandlineError, "option '#{arg}' needs a parameter" if params.empty? && opts[:type] != :flag
vals["#{sym}_given".intern] = true # mark argument as specified on the commandline
case opts[:type]
when :flag
if arg =~ /^--no-/ and sym.to_s =~ /^--\[no-\]/
vals[sym] = opts[:default]
else
vals[sym] = !opts[:default]
end
when :int, :ints
vals[sym] = params.map { |pg| pg.map { |p| parse_integer_parameter p, arg } }
when :float, :floats
vals[sym] = params.map { |pg| pg.map { |p| parse_float_parameter p, arg } }
when :string, :strings
vals[sym] = params.map { |pg| pg.map { |p| p.to_s } }
when :io, :ios
vals[sym] = params.map { |pg| pg.map { |p| parse_io_parameter p, arg } }
when :date, :dates
vals[sym] = params.map { |pg| pg.map { |p| parse_date_parameter p, arg } }
end
if SINGLE_ARG_TYPES.include?(opts[:type])
unless opts[:multi] # single parameter
vals[sym] = vals[sym][0][0]
else # multiple options, each with a single parameter
vals[sym] = vals[sym].map { |p| p[0] }
end
elsif MULTI_ARG_TYPES.include?(opts[:type]) && !opts[:multi]
vals[sym] = vals[sym][0] # single option, with multiple parameters
end
# else: multiple options, with multiple parameters
opts[:callback].call(vals[sym]) if opts.has_key?(:callback)
end
## modify input in place with only those
## arguments we didn't process
cmdline.clear
@leftovers.each { |l| cmdline << l }
## allow openstruct-style accessors
class << vals
def method_missing(m, *args)
self[m] || self[m.to_s]
end
end
vals
end
def parse_date_parameter param, arg #:nodoc:
begin
begin
time = Chronic.parse(param)
rescue NameError
# chronic is not available
end
time ? Date.new(time.year, time.month, time.day) : Date.parse(param)
rescue ArgumentError
raise CommandlineError, "option '#{arg}' needs a date"
end
end
## Print the help message to +stream+.
def educate stream=$stdout
width # just calculate it now; otherwise we have to be careful not to
# call this unless the cursor's at the beginning of a line.
left = {}
@specs.each do |name, spec|
left[name] = "--#{spec[:long]}" +
(spec[:short] && spec[:short] != :none ? ", -#{spec[:short]}" : "") +
case spec[:type]
when :flag; ""
when :int; " "
when :ints; " "
when :string; " "
when :strings; " "
when :float; " "
when :floats; " "
when :io; " "
when :ios; " "
when :date; " "
when :dates; " "
end
end
leftcol_width = left.values.map { |s| s.length }.max || 0
rightcol_start = leftcol_width + 6 # spaces
unless @order.size > 0 && @order.first.first == :text
stream.puts "#@version\n" if @version
stream.puts "Options:"
end
@order.each do |what, opt|
if what == :text
stream.puts wrap(opt)
next
end
spec = @specs[opt]
stream.printf " %#{leftcol_width}s: ", left[opt]
desc = spec[:desc] + begin
default_s = case spec[:default]
when $stdout; ""
when $stdin; ""
when $stderr; ""
when Array
spec[:default].join(", ")
else
spec[:default].to_s
end
if spec[:default]
if spec[:desc] =~ /\.$/
" (Default: #{default_s})"
else
" (default: #{default_s})"
end
else
""
end
end
stream.puts wrap(desc, :width => width - rightcol_start - 1, :prefix => rightcol_start)
end
end
def width #:nodoc:
@width ||= if $stdout.tty?
begin
require 'curses'
Curses::init_screen
x = Curses::cols
Curses::close_screen
x
rescue Exception
80
end
else
80
end
end
def wrap str, opts={} # :nodoc:
if str == ""
[""]
else
str.split("\n").map { |s| wrap_line s, opts }.flatten
end
end
## The per-parser version of Trollop::die (see that for documentation).
def die arg, msg
if msg
$stderr.puts "Error: argument --#{@specs[arg][:long]} #{msg}."
else
$stderr.puts "Error: #{arg}."
end
$stderr.puts "Try --help for help."
exit(-1)
end
private
## yield successive arg, parameter pairs
def each_arg args
remains = []
i = 0
until i >= args.length
if @stop_words.member? args[i]
remains += args[i .. -1]
return remains
end
case args[i]
when /^--$/ # arg terminator
remains += args[(i + 1) .. -1]
return remains
when /^--(\S+?)=(.*)$/ # long argument with equals
yield "--#{$1}", [$2]
i += 1
when /^--(\S+)$/ # long argument
params = collect_argument_parameters(args, i + 1)
unless params.empty?
num_params_taken = yield args[i], params
unless num_params_taken
if @stop_on_unknown
remains += args[i + 1 .. -1]
return remains
else
remains += params
end
end
i += 1 + num_params_taken
else # long argument no parameter
yield args[i], nil
i += 1
end
when /^-(\S+)$/ # one or more short arguments
shortargs = $1.split(//)
shortargs.each_with_index do |a, j|
if j == (shortargs.length - 1)
params = collect_argument_parameters(args, i + 1)
unless params.empty?
num_params_taken = yield "-#{a}", params
unless num_params_taken
if @stop_on_unknown
remains += args[i + 1 .. -1]
return remains
else
remains += params
end
end
i += 1 + num_params_taken
else # argument no parameter
yield "-#{a}", nil
i += 1
end
else
yield "-#{a}", nil
end
end
else
if @stop_on_unknown
remains += args[i .. -1]
return remains
else
remains << args[i]
i += 1
end
end
end
remains
end
def parse_integer_parameter param, arg
raise CommandlineError, "option '#{arg}' needs an integer" unless param =~ /^\d+$/
param.to_i
end
def parse_float_parameter param, arg
raise CommandlineError, "option '#{arg}' needs a floating-point number" unless param =~ FLOAT_RE
param.to_f
end
def parse_io_parameter param, arg
case param
when /^(stdin|-)$/i; $stdin
else
require 'open-uri'
begin
open param
rescue SystemCallError => e
raise CommandlineError, "file or url for option '#{arg}' cannot be opened: #{e.message}"
end
end
end
def collect_argument_parameters args, start_at
params = []
pos = start_at
while args[pos] && args[pos] !~ PARAM_RE && !@stop_words.member?(args[pos]) do
params << args[pos]
pos += 1
end
params
end
def resolve_default_short_options
@order.each do |type, name|
next unless type == :opt
opts = @specs[name]
next if opts[:short]
c = opts[:long].split(//).find { |d| d !~ INVALID_SHORT_ARG_REGEX && !@short.member?(d) }
if c # found a character to use
opts[:short] = c
@short[c] = name
end
end
end
def wrap_line str, opts={}
prefix = opts[:prefix] || 0
width = opts[:width] || (self.width - 1)
start = 0
ret = []
until start > str.length
nextt =
if start + width >= str.length
str.length
else
x = str.rindex(/\s/, start + width)
x = str.index(/\s/, start) if x && x < start
x || str.length
end
ret << (ret.empty? ? "" : " " * prefix) + str[start ... nextt]
start = nextt + 1
end
ret
end
## instance_eval but with ability to handle block arguments
## thanks to why: http://redhanded.hobix.com/inspect/aBlockCostume.html
def cloaker &b
(class << self; self; end).class_eval do
define_method :cloaker_, &b
meth = instance_method :cloaker_
remove_method :cloaker_
meth
end
end
end
## The easy, syntactic-sugary entry method into Trollop. Creates a Parser,
## passes the block to it, then parses +args+ with it, handling any errors or
## requests for help or version information appropriately (and then exiting).
## Modifies +args+ in place. Returns a hash of option values.
##
## The block passed in should contain zero or more calls to +opt+
## (Parser#opt), zero or more calls to +text+ (Parser#text), and
## probably a call to +version+ (Parser#version).
##
## The returned block contains a value for every option specified with
## +opt+. The value will be the value given on the commandline, or the
## default value if the option was not specified on the commandline. For
## every option specified on the commandline, a key "_given" will also be set in the hash.
##
## Example:
##
## require 'trollop'
## opts = Trollop::options do
## opt :monkey, "Use monkey mode" # a flag --monkey, defaulting to false
## opt :goat, "Use goat mode", :default => true # a flag --goat, defaulting to true
## opt :num_limbs, "Number of limbs", :default => 4 # an integer --num-limbs , defaulting to 4
## opt :num_thumbs, "Number of thumbs", :type => :int # an integer --num-thumbs , defaulting to nil
## end
##
## ## if called with no arguments
## p opts # => { :monkey => false, :goat => true, :num_limbs => 4, :num_thumbs => nil }
##
## ## if called with --monkey
## p opts # => {:monkey_given=>true, :monkey=>true, :goat=>true, :num_limbs=>4, :help=>false, :num_thumbs=>nil}
##
## See more examples at http://trollop.rubyforge.org.
def options args=ARGV, *a, &b
@last_parser = Parser.new(*a, &b)
with_standard_exception_handling(@last_parser) { @last_parser.parse args }
end
## If Trollop::options doesn't do quite what you want, you can create a Parser
## object and call Parser#parse on it. That method will throw CommandlineError,
## HelpNeeded and VersionNeeded exceptions when necessary; if you want to
## have these handled for you in the standard manner (e.g. show the help
## and then exit upon an HelpNeeded exception), call your code from within
## a block passed to this method.
##
## Note that this method will call System#exit after handling an exception!
##
## Usage example:
##
## require 'trollop'
## p = Trollop::Parser.new do
## opt :monkey, "Use monkey mode" # a flag --monkey, defaulting to false
## opt :goat, "Use goat mode", :default => true # a flag --goat, defaulting to true
## end
##
## opts = Trollop::with_standard_exception_handling p do
## o = p.parse ARGV
## raise Trollop::HelpNeeded if ARGV.empty? # show help screen
## o
## end
##
## Requires passing in the parser object.
def with_standard_exception_handling parser
begin
yield
rescue CommandlineError => e
$stderr.puts "Error: #{e.message}."
$stderr.puts "Try --help for help."
exit(-1)
rescue HelpNeeded
parser.educate
exit
rescue VersionNeeded
puts parser.version
exit
end
end
## Informs the user that their usage of 'arg' was wrong, as detailed by
## 'msg', and dies. Example:
##
## options do
## opt :volume, :default => 0.0
## end
##
## die :volume, "too loud" if opts[:volume] > 10.0
## die :volume, "too soft" if opts[:volume] < 0.1
##
## In the one-argument case, simply print that message, a notice
## about -h, and die. Example:
##
## options do
## opt :whatever # ...
## end
##
## Trollop::die "need at least one filename" if ARGV.empty?
def die arg, msg=nil
if @last_parser
@last_parser.die arg, msg
else
raise ArgumentError, "Trollop::die can only be called after Trollop::options"
end
end
module_function :options, :die, :with_standard_exception_handling
end # module
end
end
end
puppet-3.4.3/lib/puppet/util/command_line/puppet_option_parser.rb 0000644 0052762 0001160 00000006043 12300765631 025227 0 ustar jenkins jenkins require 'puppet/util/command_line/trollop'
module Puppet
module Util
class CommandLine
class PuppetOptionError < Puppet::Error
end
class TrollopCommandlineError < Puppet::Util::CommandLine::Trollop::CommandlineError; end
# This is a command line option parser. It is intended to have an API that is very similar to
# the ruby stdlib 'OptionParser' API, for ease of integration into our existing code... however,
# However, we've removed the OptionParser-based implementation and are only maintaining the
# it's implemented based on the third-party "trollop" library. This was done because there
# are places where the stdlib OptionParser is not flexible enough to meet our needs.
class PuppetOptionParser
def initialize(usage_msg = nil)
require "puppet/util/command_line/trollop"
@create_default_short_options = false
@parser = Trollop::Parser.new do
banner usage_msg
end
end
# This parameter, if set, will tell the underlying option parser not to throw an
# exception if we pass it options that weren't explicitly registered. We need this
# capability because we need to be able to pass all of the command-line options before
# we know which application/face they are going to be running, but the app/face
# may specify additional command-line arguments that are valid for that app/face.
attr_reader :ignore_invalid_options
def ignore_invalid_options=(value)
@parser.ignore_invalid_options = value
end
def on(*args, &block)
# The 2nd element is an optional "short" representation.
if args.length == 3
long, desc, type = args
elsif args.length == 4
long, short, desc, type = args
else
raise ArgumentError, "this method only takes 3 or 4 arguments. Given: #{args.inspect}"
end
options = {
:long => long,
:short => short,
:required => false,
:callback => pass_only_last_value_on_to(block),
:multi => true,
}
case type
when :REQUIRED
options[:type] = :string
when :NONE
options[:type] = :flag
else
raise PuppetOptionError.new("Unsupported type: '#{type}'")
end
@parser.opt long.sub("^--", "").intern, desc, options
end
def parse(*args)
args = args[0] if args.size == 1 and Array === args[0]
args_copy = args.dup
begin
@parser.parse args_copy
rescue Puppet::Util::CommandLine::Trollop::CommandlineError => err
raise PuppetOptionError.new("Error parsing arguments", err)
end
end
def pass_only_last_value_on_to(block)
lambda { |values| block.call(values.is_a?(Array) ? values.last : values) }
end
private :pass_only_last_value_on_to
end
end
end
end
puppet-3.4.3/lib/puppet/util/log.rb 0000644 0052762 0001160 00000020577 12300765631 017112 0 ustar jenkins jenkins require 'puppet/util/tagging'
require 'puppet/util/classgen'
require 'puppet/network/format_support'
# Pass feedback to the user. Log levels are modeled after syslog's, and it is
# expected that that will be the most common log destination. Supports
# multiple destinations, one of which is a remote server.
class Puppet::Util::Log
include Puppet::Util
extend Puppet::Util::ClassGen
include Puppet::Util::Tagging
include Puppet::Network::FormatSupport
@levels = [:debug,:info,:notice,:warning,:err,:alert,:emerg,:crit]
@loglevel = 2
@desttypes = {}
# Create a new destination type.
def self.newdesttype(name, options = {}, &block)
dest = genclass(
name,
:parent => Puppet::Util::Log::Destination,
:prefix => "Dest",
:block => block,
:hash => @desttypes,
:attributes => options
)
dest.match(dest.name)
dest
end
require 'puppet/util/log/destination'
require 'puppet/util/log/destinations'
@destinations = {}
@queued = []
class << self
include Puppet::Util
include Puppet::Util::ClassGen
attr_reader :desttypes
end
# Reset log to basics. Basically just flushes and closes files and
# undefs other objects.
def Log.close(destination)
if @destinations.include?(destination)
@destinations[destination].flush if @destinations[destination].respond_to?(:flush)
@destinations[destination].close if @destinations[destination].respond_to?(:close)
@destinations.delete(destination)
end
end
def self.close_all
destinations.keys.each { |dest|
close(dest)
}
raise Puppet::DevError.new("Log.close_all failed to close #{@destinations.keys.inspect}") if !@destinations.empty?
end
# Flush any log destinations that support such operations.
def Log.flush
@destinations.each { |type, dest|
dest.flush if dest.respond_to?(:flush)
}
end
def Log.autoflush=(v)
@destinations.each do |type, dest|
dest.autoflush = v if dest.respond_to?(:autoflush=)
end
end
# Create a new log message. The primary role of this method is to
# avoid creating log messages below the loglevel.
def Log.create(hash)
raise Puppet::DevError, "Logs require a level" unless hash.include?(:level)
raise Puppet::DevError, "Invalid log level #{hash[:level]}" unless @levels.index(hash[:level])
@levels.index(hash[:level]) >= @loglevel ? Puppet::Util::Log.new(hash) : nil
end
def Log.destinations
@destinations
end
# Yield each valid level in turn
def Log.eachlevel
@levels.each { |level| yield level }
end
# Return the current log level.
def Log.level
@levels[@loglevel]
end
# Set the current log level.
def Log.level=(level)
level = level.intern unless level.is_a?(Symbol)
raise Puppet::DevError, "Invalid loglevel #{level}" unless @levels.include?(level)
@loglevel = @levels.index(level)
end
def Log.levels
@levels.dup
end
# Create a new log destination.
def Log.newdestination(dest)
# Each destination can only occur once.
if @destinations.find { |name, obj| obj.name == dest }
return
end
name, type = @desttypes.find do |name, klass|
klass.match?(dest)
end
if type.respond_to?(:suitable?) and not type.suitable?(dest)
return
end
raise Puppet::DevError, "Unknown destination type #{dest}" unless type
begin
if type.instance_method(:initialize).arity == 1
@destinations[dest] = type.new(dest)
else
@destinations[dest] = type.new
end
flushqueue
@destinations[dest]
rescue => detail
Puppet.log_exception(detail)
# If this was our only destination, then add the console back in.
newdestination(:console) if @destinations.empty? and (dest != :console and dest != "console")
end
end
def Log.with_destination(destination, &block)
if @destinations.include?(destination)
yield
else
newdestination(destination)
begin
yield
ensure
close(destination)
end
end
end
# Route the actual message. FIXME There are lots of things this method
# should do, like caching and a bit more. It's worth noting that there's
# a potential for a loop here, if the machine somehow gets the destination set as
# itself.
def Log.newmessage(msg)
return if @levels.index(msg.level) < @loglevel
queuemessage(msg) if @destinations.length == 0
@destinations.each do |name, dest|
dest.handle(msg)
end
end
def Log.queuemessage(msg)
@queued.push(msg)
end
def Log.flushqueue
return unless @destinations.size >= 1
@queued.each do |msg|
Log.newmessage(msg)
end
@queued.clear
end
# Flush the logging queue. If there are no destinations available,
# adds in a console logger before flushing the queue.
# This is mainly intended to be used as a last-resort attempt
# to ensure that logging messages are not thrown away before
# the program is about to exit--most likely in a horrific
# error scenario.
# @return nil
def Log.force_flushqueue()
if (@destinations.empty? and !(@queued.empty?))
newdestination(:console)
end
flushqueue
end
def Log.sendlevel?(level)
@levels.index(level) >= @loglevel
end
# Reopen all of our logs.
def Log.reopen
Puppet.notice "Reopening log files"
types = @destinations.keys
@destinations.each { |type, dest|
dest.close if dest.respond_to?(:close)
}
@destinations.clear
# We need to make sure we always end up with some kind of destination
begin
types.each { |type|
Log.newdestination(type)
}
rescue => detail
if @destinations.empty?
Log.setup_default
Puppet.err detail.to_s
end
end
end
def self.setup_default
Log.newdestination(
(Puppet.features.syslog? ? :syslog :
(Puppet.features.eventlog? ? :eventlog : Puppet[:puppetdlog])))
end
# Is the passed level a valid log level?
def self.validlevel?(level)
@levels.include?(level)
end
def self.from_pson(data)
obj = allocate
obj.initialize_from_hash(data)
obj
end
attr_accessor :time, :remote, :file, :line, :source
attr_reader :level, :message
def initialize(args)
self.level = args[:level]
self.message = args[:message]
self.source = args[:source] || "Puppet"
@time = Time.now
if tags = args[:tags]
tags.each { |t| self.tag(t) }
end
[:file, :line].each do |attr|
next unless value = args[attr]
send(attr.to_s + "=", value)
end
Log.newmessage(self)
end
def initialize_from_hash(data)
@level = data['level'].intern
@message = data['message']
@source = data['source']
@tags = Puppet::Util::TagSet.new(data['tags'])
@time = data['time']
if @time.is_a? String
@time = Time.parse(@time)
end
@file = data['file'] if data['file']
@line = data['line'] if data['line']
end
def to_hash
self.to_data_hash
end
def to_data_hash
{
'level' => @level,
'message' => @message,
'source' => @source,
'tags' => @tags,
'time' => @time.iso8601(9),
'file' => @file,
'line' => @line,
}
end
def to_pson(*args)
to_data_hash.to_pson(*args)
end
def message=(msg)
raise ArgumentError, "Puppet::Util::Log requires a message" unless msg
@message = msg.to_s
end
def level=(level)
raise ArgumentError, "Puppet::Util::Log requires a log level" unless level
raise ArgumentError, "Puppet::Util::Log requires a symbol or string" unless level.respond_to? "to_sym"
@level = level.to_sym
raise ArgumentError, "Invalid log level #{@level}" unless self.class.validlevel?(@level)
# Tag myself with my log level
tag(level)
end
# If they pass a source in to us, we make sure it is a string, and
# we retrieve any tags we can.
def source=(source)
if source.respond_to?(:path)
@source = source.path
source.tags.each { |t| tag(t) }
self.file = source.file
self.line = source.line
else
@source = source.to_s
end
end
def to_report
"#{time} #{source} (#{level}): #{to_s}"
end
def to_s
message
end
end
# This is for backward compatibility from when we changed the constant to Puppet::Util::Log
# because the reports include the constant name. Apparently the alias was created in
# March 2007, should could probably be removed soon.
Puppet::Log = Puppet::Util::Log
puppet-3.4.3/lib/puppet/util/ssl.rb 0000644 0052762 0001160 00000002446 12300765631 017125 0 ustar jenkins jenkins ##
# SSL is a private module with class methods that help work with x.509
# subjects.
#
# @api private
module Puppet::Util::SSL
NO_NAME = OpenSSL::X509::Name.new
DN_PARSERS = [
OpenSSL::X509::Name.method(:parse_rfc2253),
OpenSSL::X509::Name.method(:parse_openssl),
lambda { |dn| NO_NAME }
]
# Given a DN string, parse it into an OpenSSL certificate subject. This
# method will flexibly handle both OpenSSl and RFC2253 formats, as given by
# nginx and Apache, respectively.
#
# @param [String] dn the x.509 Distinguished Name (DN) string.
#
# @return [OpenSSL::X509::Name] the certificate subject
def self.subject_from_dn(dn)
if is_possibly_valid_dn?(dn)
DN_PARSERS.each do |parser|
begin
return parser.call(dn)
rescue OpenSSL::X509::NameError
end
end
else
NO_NAME
end
end
##
# cn_from_subject extracts the CN from the given OpenSSL certtificate
# subject.
#
# @api private
#
# @param [OpenSSL::X509::Name] subject the subject to extract the CN field from
#
# @return [String, nil] the CN, or nil if not found
def self.cn_from_subject(subject)
if subject.respond_to? :to_a
(subject.to_a.assoc('CN') || [])[1]
end
end
def self.is_possibly_valid_dn?(dn)
dn =~ /=/
end
end
puppet-3.4.3/lib/puppet/util/diff.rb 0000644 0052762 0001160 00000003741 12300765631 017233 0 ustar jenkins jenkins require 'tempfile'
# Provide a diff between two strings.
module Puppet::Util::Diff
include Puppet::Util::Execution
require 'tempfile'
def diff(old, new)
return '' unless diff_cmd = Puppet[:diff] and diff_cmd != ""
command = [diff_cmd]
if args = Puppet[:diff_args] and args != ""
command << args
end
command << old << new
Puppet::Util::Execution.execute(command, :failonfail => false, :combine => false)
end
module_function :diff
# return diff string of two input strings
# format defaults to unified
# context defaults to 3 lines
def lcs_diff(data_old, data_new, format=:unified, context_lines=3)
unless Puppet.features.diff?
Puppet.warning "Cannot provide diff without the diff/lcs Ruby library"
return ""
end
data_old = data_old.split(/\n/).map! { |e| e.chomp }
data_new = data_new.split(/\n/).map! { |e| e.chomp }
output = ""
diffs = ::Diff::LCS.diff(data_old, data_new)
return output if diffs.empty?
oldhunk = hunk = nil
file_length_difference = 0
diffs.each do |piece|
begin
hunk = ::Diff::LCS::Hunk.new(
data_old, data_new, piece,
context_lines,
file_length_difference)
file_length_difference = hunk.file_length_difference
next unless oldhunk
# Hunks may overlap, which is why we need to be careful when our
# diff includes lines of context. Otherwise, we might print
# redundant lines.
if (context_lines > 0) and hunk.overlaps?(oldhunk)
hunk.unshift(oldhunk)
else
output << oldhunk.diff(format)
end
ensure
oldhunk = hunk
output << "\n"
end
end
# Handle the last remaining hunk
output << oldhunk.diff(format) << "\n"
end
def string_file_diff(path, string)
tempfile = Tempfile.new("puppet-diffing")
tempfile.open
tempfile.print string
tempfile.close
notice "\n" + diff(path, tempfile.path)
tempfile.delete
end
end
puppet-3.4.3/lib/puppet/util/terminal.rb 0000644 0052762 0001160 00000001036 12300765631 020131 0 ustar jenkins jenkins module Puppet::Util::Terminal
# Attempts to determine the width of the terminal. This is currently only
# supported on POSIX systems, and relies on the claims of `stty` (or `tput`).
#
# Inspired by code from Thor; thanks wycats!
# @return [Number] The column width of the terminal. Defaults to 80 columns.
def self.width
if Puppet.features.posix?
result = %x{stty size 2>/dev/null}.split[1] ||
%x{tput cols 2>/dev/null}.split[0]
end
return (result || '80').to_i
rescue
return 80
end
end
puppet-3.4.3/lib/puppet/util/instance_loader.rb 0000644 0052762 0001160 00000004017 12300765631 021452 0 ustar jenkins jenkins require 'puppet/util/autoload'
require 'puppet/util'
# A module that can easily autoload things for us. Uses an instance
# of Puppet::Util::Autoload
module Puppet::Util::InstanceLoader
include Puppet::Util
# Are we instance-loading this type?
def instance_loading?(type)
defined?(@autoloaders) and @autoloaders.include?(type.intern)
end
# Define a new type of autoloading.
def instance_load(type, path, options = {})
@autoloaders ||= {}
@instances ||= {}
type = type.intern
@instances[type] = {}
@autoloaders[type] = Puppet::Util::Autoload.new(self, path, options)
# Now define our new simple methods
unless respond_to?(type)
meta_def(type) do |name|
loaded_instance(type, name)
end
end
end
# Return a list of the names of all instances
def loaded_instances(type)
@instances[type].keys
end
# Collect the docs for all of our instances.
def instance_docs(type)
docs = ""
# Load all instances.
instance_loader(type).loadall
# Use this method so they all get loaded
loaded_instances(type).sort { |a,b| a.to_s <=> b.to_s }.each do |name|
mod = self.loaded_instance(name)
docs << "#{name}\n#{"-" * name.to_s.length}\n"
docs << Puppet::Util::Docs.scrub(mod.doc) << "\n\n"
end
docs
end
# Return the instance hash for our type.
def instance_hash(type)
@instances[type.intern]
end
# Return the Autoload object for a given type.
def instance_loader(type)
@autoloaders[type.intern]
end
# Retrieve an alread-loaded instance, or attempt to load our instance.
def loaded_instance(type, name)
name = name.intern
return nil unless instances = instance_hash(type)
unless instances.include? name
if instance_loader(type).load(name)
unless instances.include? name
Puppet.warning(
"Loaded #{type} file for #{name} but #{type} was not defined"
)
return nil
end
else
return nil
end
end
instances[name]
end
end
puppet-3.4.3/lib/puppet/util/retryaction.rb 0000644 0052762 0001160 00000003044 12300765631 020662 0 ustar jenkins jenkins module Puppet::Util::RetryAction
class RetryException < Exception; end
class RetryException::NoBlockGiven < RetryException; end
class RetryException::NoRetriesGiven < RetryException;end
class RetryException::RetriesExceeded < RetryException; end
def self.retry_action( parameters = { :retry_exceptions => nil, :retries => nil } )
# Retry actions for a specified amount of time. This method will allow the final
# retry to complete even if that extends beyond the timeout period.
unless block_given?
raise RetryException::NoBlockGiven
end
raise RetryException::NoRetriesGiven if parameters[:retries].nil?
parameters[:retry_exceptions] ||= Hash.new
failures = 0
begin
yield
rescue Exception => e
# If we were giving exceptions to catch,
# catch the excptions we care about and retry.
# All others fail hard
raise RetryException::RetriesExceeded if parameters[:retries] == 0
if (not parameters[:retry_exceptions].keys.empty?) and parameters[:retry_exceptions].keys.include?(e.class)
Puppet.info("Caught exception #{e.class}:#{e}")
Puppet.info(parameters[:retry_exceptions][e.class])
elsif (not parameters[:retry_exceptions].keys.empty?)
# If the exceptions is not in the list of retry_exceptions re-raise.
raise e
end
failures += 1
parameters[:retries] -= 1
# Increase the amount of time that we sleep after every
# failed retry attempt.
sleep (((2 ** failures) -1) * 0.1)
retry
end
end
end
puppet-3.4.3/lib/puppet/util/libuser.conf 0000644 0052762 0001160 00000000366 12300765631 020312 0 ustar jenkins jenkins [import]
login_defs = /etc/login.defs
default_useradd = /etc/default/useradd
[defaults]
crypt_style = md5
modules = files shadow
create_modules = files shadow
[userdefaults]
LU_USERNAME = %n
LU_GIDNUMBER = %u
[groupdefaults]
LU_GROUPNAME = %n
puppet-3.4.3/lib/puppet/util/cacher.rb 0000644 0052762 0001160 00000003513 12300765631 017545 0 ustar jenkins jenkins module Puppet::Util::Cacher
# Our module has been extended in a class; we can only add the Instance methods,
# which become *class* methods in the class.
def self.extended(other)
class << other
extend ClassMethods
include InstanceMethods
end
end
# Our module has been included in a class, which means the class gets the class methods
# and all of its instances get the instance methods.
def self.included(other)
other.extend(ClassMethods)
other.send(:include, InstanceMethods)
end
# Methods that can get added to a class.
module ClassMethods
# Provide a means of defining an attribute whose value will be cached.
# Must provide a block capable of defining the value if it's flushed..
def cached_attr(name, ttl, &block)
init_method = "init_#{name}"
define_method(init_method, &block)
set_attr_ttl(name, ttl)
define_method(name) do
cached_value(name)
end
define_method(name.to_s + "=") do |value|
# Make sure the cache timestamp is set
value_cache[name] = value
set_expiration(name)
end
end
def attr_ttl(name)
@attr_ttls[name]
end
def set_attr_ttl(name, value)
@attr_ttls ||= {}
@attr_ttls[name] = Integer(value)
end
end
# Methods that get added to instances.
module InstanceMethods
private
def cached_value(name)
if value_cache[name].nil? or expired_by_ttl?(name)
value_cache[name] = send("init_#{name}")
set_expiration(name)
end
value_cache[name]
end
def expired_by_ttl?(name)
@attr_expirations[name] < Time.now
end
def set_expiration(name)
@attr_expirations ||= {}
@attr_expirations[name] = Time.now + self.class.attr_ttl(name)
end
def value_cache
@value_cache ||= {}
end
end
end
puppet-3.4.3/lib/puppet/util/libuser.rb 0000644 0052762 0001160 00000000316 12300765631 017763 0 ustar jenkins jenkins module Puppet::Util::Libuser
def self.getconf
File.expand_path("../libuser.conf", __FILE__)
end
def self.getenv
newenv = {}
newenv['LIBUSER_CONF'] = getconf
newenv
end
end
puppet-3.4.3/lib/puppet/util/execution.rb 0000644 0052762 0001160 00000030113 12300765631 020317 0 ustar jenkins jenkins module Puppet
require 'rbconfig'
require 'puppet/error'
# A command failed to execute.
# @api public
class ExecutionFailure < Puppet::Error
end
end
# This module defines methods for execution of system commands. It is intented for inclusion
# in classes that needs to execute system commands.
# @api public
module Puppet::Util::Execution
# This is the full output from a process. The object itself (a String) is the
# stdout of the process.
#
# @api public
class ProcessOutput < String
# @return [Integer] The exit status of the process
# @api public
attr_reader :exitstatus
# @api private
def initialize(value,exitstatus)
super(value)
@exitstatus = exitstatus
end
end
# Executes the provided command with STDIN connected to a pipe, yielding the
# pipe object.
# This allows data to be fed to the subprocess.
#
# The command can be a simple string, which is executed as-is, or an Array,
# which is treated as a set of command arguments to pass through.
#
# In all cases this is passed directly to the shell, and STDOUT and STDERR
# are connected together during execution.
# @param command [String, Array] the command to execute as one string, or as parts in an array.
# the parts of the array are joined with one separating space between each entry when converting to
# the command line string to execute.
# @param failonfail [Boolean] (true) if the execution should fail with Exception on failure or not.
# @yield [pipe] to a block executing a subprocess
# @yieldparam pipe [IO] the opened pipe
# @yieldreturn [String] the output to return
# @raise [Puppet::ExecutionFailure] if the executed chiled process did not exit with status == 0 and `failonfail` is
# `true`.
# @return [String] a string with the output from the subprocess executed by the given block
# @api public
#
def self.execpipe(command, failonfail = true)
# Paste together an array with spaces. We used to paste directly
# together, no spaces, which made for odd invocations; the user had to
# include whitespace between arguments.
#
# Having two spaces is really not a big drama, since this passes to the
# shell anyhow, while no spaces makes for a small developer cost every
# time this is invoked. --daniel 2012-02-13
command_str = command.respond_to?(:join) ? command.join(' ') : command
if respond_to? :debug
debug "Executing '#{command_str}'"
else
Puppet.debug "Executing '#{command_str}'"
end
output = open("| #{command_str} 2>&1") do |pipe|
yield pipe
end
if failonfail
unless $CHILD_STATUS == 0
raise Puppet::ExecutionFailure, output
end
end
output
end
# Wraps execution of {execute} with mapping of exception to given exception (and output as argument).
# @raise [exception] under same conditions as {execute}, but raises the given `exception` with the output as argument
# @return (see execute)
# @api public
def self.execfail(command, exception)
output = execute(command)
return output
rescue Puppet::ExecutionFailure
raise exception, output
end
# Default empty options for {execute}
NoOptionsSpecified = {}
# Executes the desired command, and return the status and output.
# def execute(command, options)
# @param command [Array, String] the command to execute. If it is
# an Array the first element should be the executable and the rest of the
# elements should be the individual arguments to that executable.
# @param options [Hash] a Hash of options
# @option options [Boolean] :failonfail if this value is set to true, then this method will raise an error if the
# command is not executed successfully.
# @option options [Integer, String] :uid (nil) the user id of the user that the process should be run as
# @option options [Integer, String] :gid (nil) the group id of the group that the process should be run as
# @option options [Boolean] :combine sets whether or not to combine stdout/stderr in the output
# @option options [String] :stdinfile (nil) sets a file that can be used for stdin. Passing a string for stdin is not currently
# supported.
# @option options [Boolean] :squelch (true) if true, ignore stdout / stderr completely.
# @option options [Boolean] :override_locale (true) by default (and if this option is set to true), we will temporarily override
# the user/system locale to "C" (via environment variables LANG and LC_*) while we are executing the command.
# This ensures that the output of the command will be formatted consistently, making it predictable for parsing.
# Passing in a value of false for this option will allow the command to be executed using the user/system locale.
# @option options [Hash<{String => String}>] :custom_environment ({}) a hash of key/value pairs to set as environment variables for the duration
# of the command.
# @return [Puppet::Util::Execution::ProcessOutput] output as specified by options
# @raise [Puppet::ExecutionFailure] if the executed chiled process did not exit with status == 0 and `failonfail` is
# `true`.
# @note Unfortunately, the default behavior for failonfail and combine (since
# 0.22.4 and 0.24.7, respectively) depend on whether options are specified
# or not. If specified, then failonfail and combine default to false (even
# when the options specified are neither failonfail nor combine). If no
# options are specified, then failonfail and combine default to true.
# @comment See commits efe9a833c and d32d7f30
# @api public
#
def self.execute(command, options = NoOptionsSpecified)
# specifying these here rather than in the method signature to allow callers to pass in a partial
# set of overrides without affecting the default values for options that they don't pass in
default_options = {
:failonfail => NoOptionsSpecified.equal?(options),
:uid => nil,
:gid => nil,
:combine => NoOptionsSpecified.equal?(options),
:stdinfile => nil,
:squelch => false,
:override_locale => true,
:custom_environment => {},
}
options = default_options.merge(options)
if command.is_a?(Array)
command = command.flatten.map(&:to_s)
str = command.join(" ")
elsif command.is_a?(String)
str = command
end
if respond_to? :debug
debug "Executing '#{str}'"
else
Puppet.debug "Executing '#{str}'"
end
null_file = Puppet.features.microsoft_windows? ? 'NUL' : '/dev/null'
stdin = File.open(options[:stdinfile] || null_file, 'r')
stdout = options[:squelch] ? File.open(null_file, 'w') : Tempfile.new('puppet')
stderr = options[:combine] ? stdout : File.open(null_file, 'w')
exec_args = [command, options, stdin, stdout, stderr]
if execution_stub = Puppet::Util::ExecutionStub.current_value
return execution_stub.call(*exec_args)
elsif Puppet.features.posix?
child_pid = execute_posix(*exec_args)
exit_status = Process.waitpid2(child_pid).last.exitstatus
elsif Puppet.features.microsoft_windows?
process_info = execute_windows(*exec_args)
begin
exit_status = Puppet::Util::Windows::Process.wait_process(process_info.process_handle)
ensure
Puppet::Util::Windows::Process.CloseHandle(process_info.process_handle)
Puppet::Util::Windows::Process.CloseHandle(process_info.thread_handle)
end
end
[stdin, stdout, stderr].each {|io| io.close rescue nil}
# read output in if required
unless options[:squelch]
output = wait_for_output(stdout)
Puppet.warning "Could not get output" unless output
end
if options[:failonfail] and exit_status != 0
raise Puppet::ExecutionFailure, "Execution of '#{str}' returned #{exit_status}: #{output}"
end
Puppet::Util::Execution::ProcessOutput.new(output || '', exit_status)
end
# Returns the path to the ruby executable (available via Config object, even if
# it's not in the PATH... so this is slightly safer than just using Puppet::Util.which)
# @return [String] the path to the Ruby executable
# @api private
#
def self.ruby_path()
File.join(RbConfig::CONFIG['bindir'],
RbConfig::CONFIG['ruby_install_name'] + RbConfig::CONFIG['EXEEXT']).
sub(/.*\s.*/m, '"\&"')
end
# Because some modules provide their own version of this method.
class << self
alias util_execute execute
end
# This is private method.
# @comment see call to private_class_method after method definition
# @api private
#
def self.execute_posix(command, options, stdin, stdout, stderr)
child_pid = Puppet::Util.safe_posix_fork(stdin, stdout, stderr) do
# We can't just call Array(command), and rely on it returning
# things like ['foo'], when passed ['foo'], because
# Array(command) will call command.to_a internally, which when
# given a string can end up doing Very Bad Things(TM), such as
# turning "/tmp/foo;\r\n /bin/echo" into ["/tmp/foo;\r\n", " /bin/echo"]
command = [command].flatten
Process.setsid
begin
Puppet::Util::SUIDManager.change_privileges(options[:uid], options[:gid], true)
# if the caller has requested that we override locale environment variables,
if (options[:override_locale]) then
# loop over them and clear them
Puppet::Util::POSIX::LOCALE_ENV_VARS.each { |name| ENV.delete(name) }
# set LANG and LC_ALL to 'C' so that the command will have consistent, predictable output
# it's OK to manipulate these directly rather than, e.g., via "withenv", because we are in
# a forked process.
ENV['LANG'] = 'C'
ENV['LC_ALL'] = 'C'
end
# unset all of the user-related environment variables so that different methods of starting puppet
# (automatic start during boot, via 'service', via /etc/init.d, etc.) won't have unexpected side
# effects relating to user / home dir environment vars.
# it's OK to manipulate these directly rather than, e.g., via "withenv", because we are in
# a forked process.
Puppet::Util::POSIX::USER_ENV_VARS.each { |name| ENV.delete(name) }
options[:custom_environment] ||= {}
Puppet::Util.withenv(options[:custom_environment]) do
Kernel.exec(*command)
end
rescue => detail
Puppet.log_exception(detail, "Could not execute posix command: #{detail}")
exit!(1)
end
end
child_pid
end
private_class_method :execute_posix
# This is private method.
# @comment see call to private_class_method after method definition
# @api private
#
def self.execute_windows(command, options, stdin, stdout, stderr)
command = command.map do |part|
part.include?(' ') ? %Q["#{part.gsub(/"/, '\"')}"] : part
end.join(" ") if command.is_a?(Array)
options[:custom_environment] ||= {}
Puppet::Util.withenv(options[:custom_environment]) do
Puppet::Util::Windows::Process.execute(command, options, stdin, stdout, stderr)
end
end
private_class_method :execute_windows
# This is private method.
# @comment see call to private_class_method after method definition
# @api private
#
def self.wait_for_output(stdout)
# Make sure the file's actually been written. This is basically a race
# condition, and is probably a horrible way to handle it, but, well, oh
# well.
# (If this method were treated as private / inaccessible from outside of this file, we shouldn't have to worry
# about a race condition because all of the places that we call this from are preceded by a call to "waitpid2",
# meaning that the processes responsible for writing the file have completed before we get here.)
2.times do |try|
if Puppet::FileSystem::File.exist?(stdout.path)
stdout.open
begin
return stdout.read
ensure
stdout.close
stdout.unlink
end
else
time_to_sleep = try / 2.0
Puppet.warning "Waiting for output; will sleep #{time_to_sleep} seconds"
sleep(time_to_sleep)
end
end
nil
end
private_class_method :wait_for_output
end
puppet-3.4.3/lib/puppet/util/plugins.rb 0000644 0052762 0001160 00000005302 12300765631 017777 0 ustar jenkins jenkins #
# 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 << (Puppet::FileSystem::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
puppet-3.4.3/lib/puppet/util/inline_docs.rb 0000644 0052762 0001160 00000000673 12300765631 020612 0 ustar jenkins jenkins module Puppet::Util::InlineDocs
def self.included(klass)
klass.send(:include, InstanceMethods)
klass.extend ClassMethods
end
module ClassMethods
attr_accessor :use_docs
def associates_doc
self.use_docs = true
end
end
module InstanceMethods
attr_writer :doc
def doc
@doc ||= ""
end
# don't fetch lexer comment by default
def use_docs
self.class.use_docs
end
end
end
puppet-3.4.3/lib/puppet/util/suidmanager.rb 0000644 0052762 0001160 00000016311 12300765631 020617 0 ustar jenkins jenkins require 'facter'
require 'puppet/util/warnings'
require 'forwardable'
require 'etc'
module Puppet::Util::SUIDManager
include Puppet::Util::Warnings
extend Forwardable
# Note groups= is handled specially due to a bug in OS X 10.6, 10.7,
# and probably upcoming releases...
to_delegate_to_process = [ :euid=, :euid, :egid=, :egid, :uid=, :uid, :gid=, :gid, :groups ]
to_delegate_to_process.each do |method|
def_delegator Process, method
module_function method
end
def osx_maj_ver
return @osx_maj_ver unless @osx_maj_ver.nil?
# 'kernel' is available without explicitly loading all facts
if Facter.value('kernel') != 'Darwin'
@osx_maj_ver = false
return @osx_maj_ver
end
# But 'macosx_productversion_major' requires it.
Facter.loadfacts
@osx_maj_ver = Facter.value('macosx_productversion_major')
end
module_function :osx_maj_ver
def groups=(grouplist)
begin
return Process.groups = grouplist
rescue Errno::EINVAL => e
#We catch Errno::EINVAL as some operating systems (OS X in particular) can
# cause troubles when using Process#groups= to change *this* user / process
# list of supplementary groups membership. This is done via Ruby's function
# "static VALUE proc_setgroups(VALUE obj, VALUE ary)" which is effectively
# a wrapper for "int setgroups(size_t size, const gid_t *list)" (part of SVr4
# and 4.3BSD but not in POSIX.1-2001) that fails and sets errno to EINVAL.
#
# This does not appear to be a problem with Ruby but rather an issue on the
# operating system side. Therefore we catch the exception and look whether
# we run under OS X or not -- if so, then we acknowledge the problem and
# re-throw the exception otherwise.
if osx_maj_ver and not osx_maj_ver.empty?
return true
else
raise e
end
end
end
module_function :groups=
def self.root?
return Process.uid == 0 unless Puppet.features.microsoft_windows?
require 'puppet/util/windows/user'
Puppet::Util::Windows::User.admin?
end
# Methods to handle changing uid/gid of the running process. In general,
# these will noop or fail on Windows, and require root to change to anything
# but the current uid/gid (which is a noop).
# Runs block setting euid and egid if provided then restoring original ids.
# If running on Windows or without root, the block will be run with the
# current euid/egid.
def asuser(new_uid=nil, new_gid=nil)
return yield if Puppet.features.microsoft_windows?
return yield unless root?
return yield unless new_uid or new_gid
old_euid, old_egid = self.euid, self.egid
begin
change_privileges(new_uid, new_gid, false)
yield
ensure
change_privileges(new_uid ? old_euid : nil, old_egid, false)
end
end
module_function :asuser
# If `permanently` is set, will permanently change the uid/gid of the
# process. If not, it will only set the euid/egid. If only uid is supplied,
# the primary group of the supplied gid will be used. If only gid is
# supplied, only gid will be changed. This method will fail if used on
# Windows.
def change_privileges(uid=nil, gid=nil, permanently=false)
return unless uid or gid
unless gid
uid = convert_xid(:uid, uid)
gid = Etc.getpwuid(uid).gid
end
change_group(gid, permanently)
change_user(uid, permanently) if uid
end
module_function :change_privileges
# Changes the egid of the process if `permanently` is not set, otherwise
# changes gid. This method will fail if used on Windows, or attempting to
# change to a different gid without root.
def change_group(group, permanently=false)
gid = convert_xid(:gid, group)
raise Puppet::Error, "No such group #{group}" unless gid
if permanently
Process::GID.change_privilege(gid)
else
Process.egid = gid
end
end
module_function :change_group
# As change_group, but operates on uids. If changing user permanently,
# supplementary groups will be set the to default groups for the new uid.
def change_user(user, permanently=false)
uid = convert_xid(:uid, user)
raise Puppet::Error, "No such user #{user}" unless uid
if permanently
# If changing uid, we must be root. So initgroups first here.
initgroups(uid)
Process::UID.change_privilege(uid)
else
# We must be root to initgroups, so initgroups before dropping euid if
# we're root, otherwise elevate euid before initgroups.
# change euid (to root) first.
if Process.euid == 0
initgroups(uid)
Process.euid = uid
else
Process.euid = uid
initgroups(uid)
end
end
end
module_function :change_user
# Make sure the passed argument is a number.
def convert_xid(type, id)
map = {:gid => :group, :uid => :user}
raise ArgumentError, "Invalid id type #{type}" unless map.include?(type)
ret = Puppet::Util.send(type, id)
if ret == nil
raise Puppet::Error, "Invalid #{map[type]}: #{id}"
end
ret
end
module_function :convert_xid
# Initialize primary and supplemental groups to those of the target user. We
# take the UID and manually look up their details in the system database,
# including username and primary group. This method will fail on Windows, or
# if used without root to initgroups of another user.
def initgroups(uid)
pwent = Etc.getpwuid(uid)
Process.initgroups(pwent.name, pwent.gid)
end
module_function :initgroups
# Run a command and capture the output
# Parameters:
# [command] the command to execute
# [new_uid] (optional) a userid to run the command as
# [new_gid] (optional) a groupid to run the command as
# [options] (optional, defaults to {}) a hash of option key/value pairs; currently supported:
# :override_locale (defaults to true) a flag indicating whether or puppet should temporarily override the
# system locale for the duration of the command. If true, the locale will be set to 'C' to ensure consistent
# output / formatting from the command, which makes it much easier to parse the output. If false, the system
# locale will be respected.
# :custom_environment (default {}) -- a hash of key/value pairs to set as environment variables for the duration
# of the command
def run_and_capture(command, new_uid=nil, new_gid=nil, options = {})
Puppet.deprecation_warning("Puppet::Util::SUIDManager.run_and_capture is deprecated; please use Puppet::Util::Execution.execute instead.")
# specifying these here rather than in the method signature to allow callers to pass in a partial
# set of overrides without affecting the default values for options that they don't pass in
default_options = {
:override_locale => true,
:custom_environment => {},
}
options = default_options.merge(options)
output = Puppet::Util::Execution.execute(command, :failonfail => false, :combine => true,
:uid => new_uid, :gid => new_gid,
:override_locale => options[:override_locale],
:custom_environment => options[:custom_environment])
[output, $CHILD_STATUS.dup]
end
module_function :run_and_capture
end
puppet-3.4.3/lib/puppet/util/warnings.rb 0000644 0052762 0001160 00000001270 12300765631 020146 0 ustar jenkins jenkins # Methods to help with handling warnings.
module Puppet::Util::Warnings
module_function
def notice_once(msg)
Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.notice msg }
end
def debug_once(msg)
Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.debug msg }
end
def warnonce(msg)
Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.warning msg }
end
def clear_warnings
@stampwarnings = {}
nil
end
protected
def self.maybe_log(message, klass)
@stampwarnings ||= {}
@stampwarnings[klass] ||= []
return nil if @stampwarnings[klass].include? message
yield
@stampwarnings[klass] << message
nil
end
end
puppet-3.4.3/lib/puppet/util/monkey_patches/ 0000755 0052762 0001160 00000000000 12300765640 021002 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/util/monkey_patches/lines.rb 0000644 0052762 0001160 00000000444 12300765631 022443 0 ustar jenkins jenkins require 'puppet/util/monkey_patches'
require 'enumerator'
module Puppet::Util::MonkeyPatches::Lines
def lines(separator = $/)
if block_given?
self.each_line(separator) {|line| yield line }
return self
else
return enum_for(:each_line, separator)
end
end
end
puppet-3.4.3/lib/puppet/util/backups.rb 0000644 0052762 0001160 00000004500 12300765631 017745 0 ustar jenkins jenkins require 'find'
require 'fileutils'
module Puppet::Util::Backups
# Deal with backups.
def perform_backup(file = nil)
# if they specifically don't want a backup, then just say
# we're good
return true unless self[:backup]
# let the path be specified
file ||= self[:path]
return true unless Puppet::FileSystem::File.exist?(file)
return(self.bucket ? perform_backup_with_bucket(file) : perform_backup_with_backuplocal(file, self[:backup]))
end
private
def perform_backup_with_bucket(fileobj)
file = (fileobj.class == String) ? fileobj : fileobj.name
case Puppet::FileSystem::File.new(file).lstat.ftype
when "directory"
# we don't need to backup directories when recurse is on
return true if self[:recurse]
info "Recursively backing up to filebucket"
Find.find(self[:path]) { |f| backup_file_with_filebucket(f) if File.file?(f) }
when "file"; backup_file_with_filebucket(file)
when "link";
end
true
end
def perform_backup_with_backuplocal(fileobj, backup)
file = (fileobj.class == String) ? fileobj : fileobj.name
newfile = file + backup
remove_backup(newfile)
begin
bfile = file + backup
# N.B. cp_r works on both files and directories
FileUtils.cp_r(file, bfile, :preserve => true)
return true
rescue => detail
# since they said they want a backup, let's error out
# if we couldn't make one
self.fail "Could not back #{file} up: #{detail.message}"
end
end
def remove_backup(newfile)
if self.class.name == :file and self[:links] != :follow
method = :lstat
else
method = :stat
end
begin
stat = Puppet::FileSystem::File.new(newfile).send(method)
rescue Errno::ENOENT
return
end
if stat.ftype == "directory"
raise Puppet::Error, "Will not remove directory backup #{newfile}; use a filebucket"
end
info "Removing old backup of type #{stat.ftype}"
begin
Puppet::FileSystem::File.unlink(newfile)
rescue => detail
message = "Could not remove old backup: #{detail}"
self.log_exception(detail, message)
self.fail message
end
end
def backup_file_with_filebucket(f)
sum = self.bucket.backup(f)
self.info "Filebucketed #{f} to #{self.bucket.name} with sum #{sum}"
return sum
end
end
puppet-3.4.3/lib/puppet/util/logging.rb 0000644 0052762 0001160 00000012410 12300765631 017742 0 ustar jenkins jenkins # A module to make logging a bit easier.
require 'puppet/util/log'
require 'puppet/error'
module Puppet::Util::Logging
def send_log(level, message)
Puppet::Util::Log.create({:level => level, :source => log_source, :message => message}.merge(log_metadata))
end
# Create a method for each log level.
Puppet::Util::Log.eachlevel do |level|
define_method(level) do |args|
args = args.join(" ") if args.is_a?(Array)
send_log(level, args)
end
end
# Log an exception via Puppet.err. Will also log the backtrace if Puppet[:trace] is set.
# Parameters:
# [exception] an Exception to log
# [message] an optional String overriding the message to be logged; by default, we log Exception.message.
# If you pass a String here, your string will be logged instead. You may also pass nil if you don't
# wish to log a message at all; in this case it is likely that you are only calling this method in order
# to take advantage of the backtrace logging.
def log_exception(exception, message = :default, options = {})
err(format_exception(exception, message, Puppet[:trace] || options[:trace]))
end
def format_exception(exception, message = :default, trace = true)
arr = []
case message
when :default
arr << exception.message
when nil
# don't log anything if they passed a nil; they are just calling for the optional backtrace logging
else
arr << message
end
if trace and exception.backtrace
arr << Puppet::Util.pretty_backtrace(exception.backtrace)
end
if exception.respond_to?(:original) and exception.original
arr << "Wrapped exception:"
arr << format_exception(exception.original, :default, trace)
end
arr.flatten.join("\n")
end
def log_and_raise(exception, message)
log_exception(exception, message)
raise exception, message + "\n" + exception.to_s, exception.backtrace
end
class DeprecationWarning < Exception; end
# Log a warning indicating that the code path is deprecated. Note that this method keeps track of the
# offending lines of code that triggered the deprecation warning, and will only log a warning once per
# offending line of code. It will also stop logging deprecation warnings altogether after 100 unique
# deprecation warnings have been logged.
# Parameters:
# [message] The message to log (logs via )
def deprecation_warning(message)
$deprecation_warnings ||= {}
if $deprecation_warnings.length < 100 then
offender = get_deprecation_offender()
if (! $deprecation_warnings.has_key?(offender)) then
$deprecation_warnings[offender] = message
warning("#{message}\n (at #{offender})")
end
end
end
def get_deprecation_offender()
# we have to put this in its own method to simplify testing; we need to be able to mock the offender results in
# order to test this class, and our framework does not appear to enjoy it if you try to mock Kernel.caller
#
# let's find the offending line; we need to jump back up the stack a few steps to find the method that called
# the deprecated method
caller()[2]
end
def clear_deprecation_warnings
$deprecation_warnings.clear if $deprecation_warnings
end
# TODO: determine whether there might be a potential use for adding a puppet configuration option that would
# enable this deprecation logging.
# utility method that can be called, e.g., from spec_helper config.after, when tracking down calls to deprecated
# code.
# Parameters:
# [deprecations_file] relative or absolute path of a file to log the deprecations to
# [pattern] (default nil) if specified, will only log deprecations whose message matches the provided pattern
def log_deprecations_to_file(deprecations_file, pattern = nil)
# this method may get called lots and lots of times (e.g., from spec_helper config.after) without the global
# list of deprecation warnings being cleared out. We don't want to keep logging the same offenders over and over,
# so, we need to keep track of what we've logged.
#
# It'd be nice if we could just clear out the list of deprecation warnings, but then the very next spec might
# find the same offender, and we'd end up logging it again.
$logged_deprecation_warnings ||= {}
File.open(deprecations_file, "a") do |f|
if ($deprecation_warnings) then
$deprecation_warnings.each do |offender, message|
if (! $logged_deprecation_warnings.has_key?(offender)) then
$logged_deprecation_warnings[offender] = true
if ((pattern.nil?) || (message =~ pattern)) then
f.puts(message)
f.puts(offender)
f.puts()
end
end
end
end
end
end
private
def is_resource?
defined?(Puppet::Type) && is_a?(Puppet::Type)
end
def is_resource_parameter?
defined?(Puppet::Parameter) && is_a?(Puppet::Parameter)
end
def log_metadata
[:file, :line, :tags].inject({}) do |result, attr|
result[attr] = send(attr) if respond_to?(attr)
result
end
end
def log_source
# We need to guard the existence of the constants, since this module is used by the base Puppet module.
(is_resource? or is_resource_parameter?) and respond_to?(:path) and return path.to_s
to_s
end
end
puppet-3.4.3/lib/puppet/util/watched_file.rb 0000644 0052762 0001160 00000002342 12300765631 020735 0 ustar jenkins jenkins require 'puppet/util/watcher'
# Monitor a given file for changes on a periodic interval. Changes are detected
# by looking for a change in the file ctime.
class Puppet::Util::WatchedFile
# @!attribute [r] filename
# @return [String] The fully qualified path to the file.
attr_reader :filename
# @param filename [String] The fully qualified path to the file.
# @param file_timeout [Integer] The polling interval for checking for file
# changes. Setting the timeout to a negative value will treat the file as
# always changed. Defaults to `Puppet[:filetimeout]`
def initialize(filename, timer = Puppet::Util::Watcher::Timer.new(Puppet[:filetimeout]))
@filename = filename
@timer = timer
@info = Puppet::Util::Watcher::PeriodicWatcher.new(
Puppet::Util::Watcher::Common.file_ctime_change_watcher(@filename),
timer)
end
# @return [true, false] If the file has changed since it was last checked.
def changed?
@info.changed?
end
# Allow this to be used as the name of the file being watched in various
# other methods (such as Puppet::FileSystem::File.exist?)
def to_str
@filename
end
def to_s
""
end
end
puppet-3.4.3/lib/puppet/util/metaid.rb 0000644 0052762 0001160 00000001023 12300765631 017555 0 ustar jenkins jenkins class Object
# The hidden singleton lurks behind everyone
def singleton_class; class << self; self; end; end
def meta_eval(&blk); singleton_class.instance_eval(&blk); end
# Adds methods to a singleton_class
def meta_def(name, &blk)
meta_eval { define_method name, &blk }
end
# Remove singleton_class methods.
def meta_undef(name, &blk)
meta_eval { remove_method name }
end
# Defines an instance method within a class
def class_def(name, &blk)
class_eval { define_method name, &blk }
end
end
puppet-3.4.3/lib/puppet/util/platform.rb 0000644 0052762 0001160 00000001234 12300765631 020142 0 ustar jenkins jenkins 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
puppet-3.4.3/lib/puppet/util/limits.rb 0000644 0052762 0001160 00000000452 12300765631 017620 0 ustar jenkins jenkins require 'puppet/util'
module Puppet::Util::Limits
# @api private
def setpriority(priority)
return unless priority
Process.setpriority(0, Process.pid, priority)
rescue Errno::EACCES, NotImplementedError
Puppet.warning("Failed to set process priority to '#{priority}'")
end
end
puppet-3.4.3/lib/puppet/util/profiler/ 0000755 0052762 0001160 00000000000 12300765640 017613 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/util/profiler/wall_clock.rb 0000644 0052762 0001160 00000001222 12300765631 022247 0 ustar jenkins jenkins require 'puppet/util/profiler/logging'
# A profiler implementation that measures the number of seconds a segment of
# code takes to execute and provides a callback with a string representation of
# the profiling information.
#
# @api private
class Puppet::Util::Profiler::WallClock < Puppet::Util::Profiler::Logging
def start
Timer.new
end
def finish(context)
context.stop
"took #{context} seconds"
end
class Timer
FOUR_DECIMAL_DIGITS = '%0.4f'
def initialize
@start = Time.now
end
def stop
@finish = Time.now
end
def to_s
format(FOUR_DECIMAL_DIGITS, @finish - @start)
end
end
end
puppet-3.4.3/lib/puppet/util/profiler/none.rb 0000644 0052762 0001160 00000000247 12300765631 021102 0 ustar jenkins jenkins # A no-op profiler. Used when there is no profiling wanted.
#
# @api private
class Puppet::Util::Profiler::None
def profile(description, &block)
yield
end
end
puppet-3.4.3/lib/puppet/util/profiler/object_counts.rb 0000644 0052762 0001160 00000000576 12300765631 023011 0 ustar jenkins jenkins require 'puppet/util/profiler/logging'
class Puppet::Util::Profiler::ObjectCounts < Puppet::Util::Profiler::Logging
def start
ObjectSpace.count_objects
end
def finish(before)
after = ObjectSpace.count_objects
diff = before.collect do |type, count|
[type, after[type] - count]
end
diff.sort.collect { |pair| pair.join(': ') }.join(', ')
end
end
puppet-3.4.3/lib/puppet/util/profiler/logging.rb 0000644 0052762 0001160 00000001452 12300765631 021570 0 ustar jenkins jenkins class Puppet::Util::Profiler::Logging
def initialize(logger, identifier)
@logger = logger
@identifier = identifier
@sequence = Sequence.new
end
def profile(description, &block)
retval = nil
@sequence.next
@sequence.down
context = start
begin
retval = yield
ensure
profile_explanation = finish(context)
@sequence.up
@logger.call("PROFILE [#{@identifier}] #{@sequence} #{description}: #{profile_explanation}")
end
retval
end
class Sequence
INITIAL = 0
SEPARATOR = '.'
def initialize
@elements = [INITIAL]
end
def next
@elements[-1] += 1
end
def down
@elements << INITIAL
end
def up
@elements.pop
end
def to_s
@elements.join(SEPARATOR)
end
end
end
puppet-3.4.3/lib/puppet/util/pidlock.rb 0000644 0052762 0001160 00000001562 12300765631 017747 0 ustar jenkins jenkins require 'fileutils'
require 'puppet/util/lockfile'
class Puppet::Util::Pidlock
def initialize(lockfile)
@lockfile = Puppet::Util::Lockfile.new(lockfile)
end
def locked?
clear_if_stale
@lockfile.locked?
end
def mine?
Process.pid == lock_pid
end
def lock
return mine? if locked?
@lockfile.lock(Process.pid)
end
def unlock()
if mine?
return @lockfile.unlock
else
false
end
end
def lock_pid
@lockfile.lock_data.to_i
end
def file_path
@lockfile.file_path
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
@lockfile.unlock
end
end
private :clear_if_stale
end
puppet-3.4.3/lib/puppet/util/resource_template.rb 0000644 0052762 0001160 00000004100 12300765631 022033 0 ustar jenkins jenkins require 'puppet/util'
require 'puppet/util/logging'
require 'erb'
# A template wrapper that evaluates a template in the
# context of a resource, allowing the resource attributes
# to be looked up from within the template.
# This provides functionality essentially equivalent to
# the language's template() function. You pass your file
# path and the resource you want to use into the initialization
# method, then call result on the instance, and you get back
# a chunk of text.
# The resource's parameters are available as instance variables
# (as opposed to the language, where we use a method_missing trick).
# For example, say you have a resource that generates a file. You would
# need to implement the following style of `generate` method:
#
# def generate
# template = Puppet::Util::ResourceTemplate.new("/path/to/template", self)
#
# return Puppet::Type.type(:file).new :path => "/my/file",
# :content => template.evaluate
# end
#
# This generated file gets added to the catalog (which is what `generate` does),
# and its content is the result of the template. You need to use instance
# variables in your template, so if your template just needs to have the name
# of the generating resource, it would just have:
#
# <%= @name %>
#
# Since the ResourceTemplate class sets as instance variables all of the resource's
# parameters.
#
# Note that this example uses the generating resource as its source of
# parameters, which is generally most useful, since it allows you to configure
# the generated resource via the generating resource.
class Puppet::Util::ResourceTemplate
include Puppet::Util::Logging
def evaluate
set_resource_variables
ERB.new(File.read(@file), 0, "-").result(binding)
end
def initialize(file, resource)
raise ArgumentError, "Template #{file} does not exist" unless Puppet::FileSystem::File.exist?(file)
@file = file
@resource = resource
end
private
def set_resource_variables
@resource.to_hash.each do |param, value|
var = "@#{param.to_s}"
instance_variable_set(var, value)
end
end
end
puppet-3.4.3/lib/puppet/util/checksums.rb 0000644 0052762 0001160 00000005761 12300765631 020314 0 ustar jenkins jenkins require 'digest/md5'
require 'digest/sha1'
# A stand-alone module for calculating checksums
# in a generic way.
module Puppet::Util::Checksums
class FakeChecksum
def <<(*args)
self
end
end
# Is the provided string a checksum?
def checksum?(string)
string =~ /^\{(\w{3,5})\}\S+/
end
# Strip the checksum type from an existing checksum
def sumdata(checksum)
checksum =~ /^\{(\w+)\}(.+)/ ? $2 : nil
end
# Strip the checksum type from an existing checksum
def sumtype(checksum)
checksum =~ /^\{(\w+)\}/ ? $1 : nil
end
# Calculate a checksum using Digest::MD5.
def md5(content)
Digest::MD5.hexdigest(content)
end
# Calculate a checksum of the first 500 chars of the content using Digest::MD5.
def md5lite(content)
md5(content[0..511])
end
# Calculate a checksum of a file's content using Digest::MD5.
def md5_file(filename, lite = false)
digest = Digest::MD5.new
checksum_file(digest, filename, lite)
end
# Calculate a checksum of the first 500 chars of a file's content using Digest::MD5.
def md5lite_file(filename)
md5_file(filename, true)
end
def md5_stream(&block)
digest = Digest::MD5.new
yield digest
digest.hexdigest
end
alias :md5lite_stream :md5_stream
# Return the :mtime timestamp of a file.
def mtime_file(filename)
Puppet::FileSystem::File.new(filename).stat.send(:mtime)
end
# by definition this doesn't exist
# but we still need to execute the block given
def mtime_stream
noop_digest = FakeChecksum.new
yield noop_digest
nil
end
def mtime(content)
""
end
# Calculate a checksum using Digest::SHA1.
def sha1(content)
Digest::SHA1.hexdigest(content)
end
# Calculate a checksum of the first 500 chars of the content using Digest::SHA1.
def sha1lite(content)
sha1(content[0..511])
end
# Calculate a checksum of a file's content using Digest::SHA1.
def sha1_file(filename, lite = false)
digest = Digest::SHA1.new
checksum_file(digest, filename, lite)
end
# Calculate a checksum of the first 500 chars of a file's content using Digest::SHA1.
def sha1lite_file(filename)
sha1_file(filename, true)
end
def sha1_stream
digest = Digest::SHA1.new
yield digest
digest.hexdigest
end
alias :sha1lite_stream :sha1_stream
# Return the :ctime of a file.
def ctime_file(filename)
Puppet::FileSystem::File.new(filename).stat.send(:ctime)
end
alias :ctime_stream :mtime_stream
def ctime(content)
""
end
# Return a "no checksum"
def none_file(filename)
""
end
def none_stream
noop_digest = FakeChecksum.new
yield noop_digest
""
end
def none(content)
""
end
private
# Perform an incremental checksum on a file.
def checksum_file(digest, filename, lite = false)
buffer = lite ? 512 : 4096
File.open(filename, 'rb') do |file|
while content = file.read(buffer)
digest << content
break if lite
end
end
digest.hexdigest
end
end
puppet-3.4.3/lib/puppet/util/watcher/ 0000755 0052762 0001160 00000000000 12300765640 017426 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/util/watcher/change_watcher.rb 0000644 0052762 0001160 00000001410 12300765631 022711 0 ustar jenkins jenkins # Watches for changes over time. It only re-examines the values when it is requested to update readings.
# @api private
class Puppet::Util::Watcher::ChangeWatcher
def self.watch(reader)
Puppet::Util::Watcher::ChangeWatcher.new(nil, nil, reader).next_reading
end
def initialize(previous, current, value_reader)
@previous = previous
@current = current
@value_reader = value_reader
end
def changed?
if uncertain?
false
else
@previous != @current
end
end
def uncertain?
@previous.nil? || @current.nil?
end
def change_current_reading_to(new_value)
Puppet::Util::Watcher::ChangeWatcher.new(@current, new_value, @value_reader)
end
def next_reading
change_current_reading_to(@value_reader.call)
end
end
puppet-3.4.3/lib/puppet/util/watcher/timer.rb 0000644 0052762 0001160 00000000374 12300765631 021077 0 ustar jenkins jenkins class Puppet::Util::Watcher::Timer
attr_reader :timeout
def initialize(timeout)
@timeout = timeout
end
def start
@start_time = now
end
def expired?
(now - @start_time) >= @timeout
end
def now
Time.now.to_i
end
end
puppet-3.4.3/lib/puppet/util/watcher/periodic_watcher.rb 0000644 0052762 0001160 00000001642 12300765631 023271 0 ustar jenkins jenkins # Monitor a given watcher for changes on a periodic interval.
class Puppet::Util::Watcher::PeriodicWatcher
# @param watcher [Puppet::Util::Watcher::ChangeWatcher] a watcher for the value to watch
# @param timer [Puppet::Util::Watcher::Timer] A timer to determin when to
# recheck the watcher. If the timout of the timer is negative, then the
# watched value is always considered to be changed
def initialize(watcher, timer)
@watcher = watcher
@timer = timer
@timer.start
end
# @return [true, false] If the file has changed since it was last checked.
def changed?
return true if always_consider_changed?
@watcher = examine_watched_info(@watcher)
@watcher.changed?
end
private
def always_consider_changed?
@timer.timeout < 0
end
def examine_watched_info(known)
if @timer.expired?
@timer.start
known.next_reading
else
known
end
end
end
puppet-3.4.3/lib/puppet/util/feature.rb 0000644 0052762 0001160 00000004164 12300765631 017756 0 ustar jenkins jenkins class Puppet::Util::Feature
attr_reader :path
# Create a new feature test. You have to pass the feature name,
# and it must be unique. You can either provide a block that
# will get executed immediately to determine if the feature
# is present, or you can pass an option to determine it.
# Currently, the only supported option is 'libs' (must be
# passed as a symbol), which will make sure that each lib loads
# successfully.
def add(name, options = {})
method = name.to_s + "?"
@results.delete(name)
if block_given?
begin
result = yield
rescue Exception => detail
warn "Failed to load feature test for #{name}: #{detail}"
result = false
end
@results[name] = result
end
meta_def(method) do
# Positive cache only, except blocks which are executed just once above
final = @results[name] || block_given?
@results[name] = test(name, options) unless final
@results[name]
end
end
# Create a new feature collection.
def initialize(path)
@path = path
@results = {}
@loader = Puppet::Util::Autoload.new(self, @path)
end
def load
@loader.loadall
end
def method_missing(method, *args)
return super unless method.to_s =~ /\?$/
feature = method.to_s.sub(/\?$/, '')
@loader.load(feature)
respond_to?(method) && self.send(method)
end
# Actually test whether the feature is present. We only want to test when
# someone asks for the feature, so we don't unnecessarily load
# files.
def test(name, options)
return true unless ary = options[:libs]
ary = [ary] unless ary.is_a?(Array)
ary.each do |lib|
return false unless load_library(lib, name)
end
# We loaded all of the required libraries
true
end
private
def load_library(lib, name)
raise ArgumentError, "Libraries must be passed as strings not #{lib.class}" unless lib.is_a?(String)
begin
require lib
rescue SystemExit,NoMemoryError
raise
rescue Exception
Puppet.debug "Failed to load library '#{lib}' for feature '#{name}'"
return false
end
true
end
end
puppet-3.4.3/lib/puppet/util/constant_inflector.rb 0000644 0052762 0001160 00000001216 12300765631 022214 0 ustar jenkins jenkins # Created on 2008-02-12
# Copyright Luke Kanies
# NOTE: I think it might be worth considering moving these methods directly into Puppet::Util.
# A common module for converting between constants and
# file names.
module Puppet
module Util
module ConstantInflector
def file2constant(file)
file.split("/").collect { |name| name.capitalize }.join("::").gsub(/_+(.)/) { |term| $1.capitalize }
end
module_function :file2constant
def constant2file(constant)
constant.to_s.gsub(/([a-z])([A-Z])/) { |term| $1 + "_#{$2}" }.gsub("::", "/").downcase
end
module_function :constant2file
end
end
end
puppet-3.4.3/lib/puppet/util/network_device/ 0000755 0052762 0001160 00000000000 12300765640 021001 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/util/network_device/transport/ 0000755 0052762 0001160 00000000000 12300765640 023035 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/util/network_device/transport/telnet.rb 0000644 0052762 0001160 00000002045 12300765631 024656 0 ustar jenkins jenkins 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(verbose = false)
super()
@verbose = verbose
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)
Puppet.debug("telnet: send #{line}") if @verbose
@telnet.puts(line)
end
end
puppet-3.4.3/lib/puppet/util/network_device/transport/base.rb 0000644 0052762 0001160 00000000740 12300765631 024275 0 ustar jenkins jenkins
require 'puppet/util/network_device'
require 'puppet/util/network_device/transport'
class Puppet::Util::NetworkDevice::Transport::Base
attr_accessor :user, :password, :host, :port
attr_accessor :default_prompt, :timeout
def initialize
@timeout = 10
end
def send(cmd)
end
def expect(prompt)
end
def command(cmd, options = {})
send(cmd)
expect(options[:prompt] || default_prompt) do |output|
yield output if block_given?
end
end
end
puppet-3.4.3/lib/puppet/util/network_device/transport/ssh.rb 0000644 0052762 0001160 00000006145 12300765631 024165 0 ustar jenkins jenkins
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
def initialize(verbose = false)
super()
@verbose = verbose
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
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
puppet-3.4.3/lib/puppet/util/network_device/config.rb 0000644 0052762 0001160 00000004324 12300765631 022576 0 ustar jenkins jenkins require 'ostruct'
require 'puppet/util/watched_file'
require 'puppet/util/network_device'
class Puppet::Util::NetworkDevice::Config
def self.main
@main ||= self.new
end
def self.devices
main.devices || []
end
attr_reader :devices
def exists?
Puppet::FileSystem::File.exist?(@file)
end
def initialize
@file = Puppet::Util::WatchedFile.new(Puppet[:deviceconfig])
@devices = {}
read(true) # force reading at start
end
# Read the configuration file.
def read(force = false)
return unless exists?
parse if force or @file.changed?
end
private
def parse
begin
devices = {}
device = nil
File.open(@file) { |f|
count = 1
f.each { |line|
case line
when /^\s*#/ # skip comments
count += 1
next
when /^\s*$/ # skip blank lines
count += 1
next
when /^\[([\w.-]+)\]\s*$/ # [device.fqdn]
name = $1
name.chomp!
raise Puppet::Error, "Duplicate device found at line #{count}, already found at #{device.line}" if devices.include?(name)
device = OpenStruct.new
device.name = name
device.line = count
device.options = { :debug => false }
Puppet.debug "found device: #{device.name} at #{device.line}"
devices[name] = device
when /^\s*(type|url|debug)(\s+(.+))*$/
parse_directive(device, $1, $3, count)
else
raise Puppet::Error, "Invalid line #{count}: #{line}"
end
count += 1
}
}
rescue Errno::EACCES => detail
Puppet.err "Configuration error: Cannot read #{@file}; cannot serve"
#raise Puppet::Error, "Cannot read #{@config}"
rescue Errno::ENOENT => detail
Puppet.err "Configuration error: '#{@file}' does not exit; cannot serve"
end
@devices = devices
end
def parse_directive(device, var, value, count)
case var
when "type"
device.provider = value
when "url"
device.url = value
when "debug"
device.options[:debug] = true
else
raise Puppet::Error, "Invalid argument '#{var}' at line #{count}"
end
end
end
puppet-3.4.3/lib/puppet/util/network_device/cisco.rb 0000644 0052762 0001160 00000000060 12300765631 022422 0 ustar jenkins jenkins
module Puppet::Util::NetworkDevice::Cisco
end
puppet-3.4.3/lib/puppet/util/network_device/cisco/ 0000755 0052762 0001160 00000000000 12300765640 022101 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/util/network_device/cisco/interface.rb 0000644 0052762 0001160 00000005103 12300765631 024365 0 ustar jenkins jenkins require 'puppet/util/network_device/cisco'
require 'puppet/util/network_device/ipcalc'
# this manages setting properties to an interface in a cisco switch or router
class Puppet::Util::NetworkDevice::Cisco::Interface
include Puppet::Util::NetworkDevice::IPCalc
extend Puppet::Util::NetworkDevice::IPCalc
attr_reader :transport, :name
def initialize(name, transport)
@name = name
@transport = transport
end
COMMANDS = {
# property => order, ios command/block/array
:description => [1, "description %s"],
:speed => [2, "speed %s"],
:duplex => [3, "duplex %s"],
:native_vlan => [4, "switchport access vlan %s"],
:encapsulation => [5, "switchport trunk encapsulation %s"],
:mode => [6, "switchport mode %s"],
:allowed_trunk_vlans => [7, "switchport trunk allowed vlan %s"],
:etherchannel => [8, ["channel-group %s", "port group %s"]],
:ipaddress => [9,
lambda do |prefix,ip,option|
ip.ipv6? ? "ipv6 address #{ip.to_s}/#{prefix} #{option}" :
"ip address #{ip.to_s} #{netmask(Socket::AF_INET,prefix)}"
end],
:ensure => [10, lambda { |value| value == :present ? "no shutdown" : "shutdown" } ]
}
def update(is={}, should={})
Puppet.debug("Updating interface #{name}")
command("conf t")
command("interface #{name}")
# apply changes in a defined orders for cisco IOS devices
[is.keys, should.keys].flatten.uniq.sort {|a,b| COMMANDS[a][0] <=> COMMANDS[b][0] }.each do |property|
# They're equal, so do nothing.
next if is[property] == should[property]
# We're deleting it
if should[property] == :absent or should[property].nil?
execute(property, is[property], "no ")
next
end
# We're replacing an existing value or creating a new one
execute(property, should[property])
end
command("exit")
command("exit")
end
def execute(property, value, prefix='')
case COMMANDS[property][1]
when Array
COMMANDS[property][1].each do |command|
transport.command(prefix + command % value) do |out|
break unless out =~ /^%/
end
end
when String
command(prefix + COMMANDS[property][1] % value)
when Proc
value = [value] unless value.is_a?(Array)
value.each do |value|
command(prefix + COMMANDS[property][1].call(*value))
end
end
end
def command(command)
transport.command(command) do |out|
Puppet.err "Error while executing #{command}, device returned #{out}" if out =~ /^%/mo
end
end
end
puppet-3.4.3/lib/puppet/util/network_device/cisco/facts.rb 0000644 0052762 0001160 00000007366 12300765631 023542 0 ustar jenkins jenkins
require 'puppet/util/network_device/cisco'
require 'puppet/util/network_device/ipcalc'
# this retrieves facts from a cisco device
class Puppet::Util::NetworkDevice::Cisco::Facts
attr_reader :transport
def initialize(transport)
@transport = transport
end
def retrieve
facts = {}
facts.merge(parse_show_ver)
end
def parse_show_ver
facts = {}
out = @transport.command("sh ver")
lines = out.split("\n")
lines.shift; lines.pop
lines.each do |l|
case l
# cisco WS-C2924C-XL (PowerPC403GA) processor (revision 0x11) with 8192K/1024K bytes of memory.
# Cisco 1841 (revision 5.0) with 355328K/37888K bytes of memory.
# Cisco 877 (MPC8272) processor (revision 0x200) with 118784K/12288K bytes of memory.
# cisco WS-C2960G-48TC-L (PowerPC405) processor (revision C0) with 61440K/4088K bytes of memory.
# cisco WS-C2950T-24 (RC32300) processor (revision R0) with 19959K bytes of memory.
when /[cC]isco ([\w-]+) (?:\(([\w-]+)\) processor )?\(revision (.+)\) with (\d+[KMG])(?:\/(\d+[KMG]))? bytes of memory\./
facts[:hardwaremodel] = $1
facts[:processor] = $2 if $2
facts[:hardwarerevision] = $3
facts[:memorysize] = $4
# uptime
# Switch uptime is 1 year, 12 weeks, 6 days, 22 hours, 32 minutes
# c2950 uptime is 3 weeks, 1 day, 23 hours, 36 minutes
# c2960 uptime is 2 years, 27 weeks, 5 days, 21 hours, 30 minutes
# router uptime is 5 weeks, 1 day, 3 hours, 30 minutes
when /^\s*([\w-]+)\s+uptime is (.*?)$/
facts[:hostname] = $1
facts[:uptime] = $2
facts[:uptime_seconds] = uptime_to_seconds($2)
facts[:uptime_days] = facts[:uptime_seconds] / 86400
# "IOS (tm) C2900XL Software (C2900XL-C3H2S-M), Version 12.0(5)WC10, RELEASE SOFTWARE (fc1)"=> { :operatingsystem => "IOS", :operatingsystemrelease => "12.0(5)WC10", :operatingsystemmajrelease => "12.0", :operatingsystemfeature => "C3H2S"},
# "IOS (tm) C2950 Software (C2950-I6K2L2Q4-M), Version 12.1(22)EA8a, RELEASE SOFTWARE (fc1)"=> { :operatingsystem => "IOS", :operatingsystemrelease => "12.1(22)EA8a", :operatingsystemmajrelease => "12.1", :operatingsystemfeature => "I6K2L2Q4"},
# "Cisco IOS Software, C2960 Software (C2960-LANBASEK9-M), Version 12.2(44)SE, RELEASE SOFTWARE (fc1)"=>{ :operatingsystem => "IOS", :operatingsystemrelease => "12.2(44)SE", :operatingsystemmajrelease => "12.2", :operatingsystemfeature => "LANBASEK9"},
# "Cisco IOS Software, C870 Software (C870-ADVIPSERVICESK9-M), Version 12.4(11)XJ4, RELEASE SOFTWARE (fc2)"=>{ :operatingsystem => "IOS", :operatingsystemrelease => "12.4(11)XJ40", :operatingsystemmajrelease => "12.4XJ", :operatingsystemfeature => "ADVIPSERVICESK9"},
# "Cisco IOS Software, 1841 Software (C1841-ADVSECURITYK9-M), Version 12.4(24)T4, RELEASE SOFTWARE (fc2)" =>{ :operatingsystem => "IOS", :operatingsystemrelease => "12.4(24)T4", :operatingsystemmajrelease => "12.4T", :operatingsystemfeature => "ADVSECURITYK9"},
when /(?:Cisco )?(IOS)\s*(?:\(tm\) |Software, )?(?:\w+)\s+Software\s+\(\w+-(\w+)-\w+\), Version ([0-9.()A-Za-z]+),/
facts[:operatingsystem] = $1
facts[:operatingsystemrelease] = $3
facts[:operatingsystemmajrelease] = ios_major_version(facts[:operatingsystemrelease])
facts[:operatingsystemfeature] = $2
end
end
facts
end
def ios_major_version(version)
version.gsub(/^(\d+)\.(\d+)\(.+\)([A-Z]+)([\da-z]+)?/, '\1.\2\3')
end
def uptime_to_seconds(uptime)
captures = (uptime.match /^(?:(\d+) years?,)?\s*(?:(\d+) weeks?,)?\s*(?:(\d+) days?,)?\s*(?:(\d+) hours?,)?\s*(\d+) minutes?$/).captures
captures.zip([31536000, 604800, 86400, 3600, 60]).inject(0) do |total, (x,y)|
total + (x.nil? ? 0 : x.to_i * y)
end
end
end
puppet-3.4.3/lib/puppet/util/network_device/cisco/device.rb 0000644 0052762 0001160 00000016524 12300765631 023675 0 ustar jenkins jenkins require 'puppet'
require 'puppet/util'
require 'puppet/util/network_device/base'
require 'puppet/util/network_device/ipcalc'
require 'puppet/util/network_device/cisco/interface'
require 'puppet/util/network_device/cisco/facts'
require 'ipaddr'
class Puppet::Util::NetworkDevice::Cisco::Device < Puppet::Util::NetworkDevice::Base
include Puppet::Util::NetworkDevice::IPCalc
attr_accessor :enable_password
def initialize(url, options = {})
super(url, options)
@enable_password = options[:enable_password] || parse_enable(@url.query)
transport.default_prompt = /[#>]\s?\z/n
end
def parse_enable(query)
if query
params = CGI.parse(query)
params['enable'].first unless params['enable'].empty?
end
end
def connect
transport.connect
login
transport.command("terminal length 0") do |out|
enable if out =~ />\s?\z/n
end
find_capabilities
end
def disconnect
transport.close
end
def command(cmd = nil)
connect
out = execute(cmd) if cmd
yield self if block_given?
disconnect
out
end
def execute(cmd)
transport.command(cmd)
end
def login
return if transport.handles_login?
if @url.user != ''
transport.command(@url.user, :prompt => /^Password:/)
else
transport.expect(/^Password:/)
end
transport.command(@url.password)
end
def enable
raise "Can't issue \"enable\" to enter privileged, no enable password set" unless enable_password
transport.command("enable", :prompt => /^Password:/)
transport.command(enable_password)
end
def support_vlan_brief?
!! @support_vlan_brief
end
def find_capabilities
out = execute("sh vlan brief")
lines = out.split("\n")
lines.shift; lines.pop
@support_vlan_brief = ! (lines.first =~ /^%/)
end
IF = {
:FastEthernet => %w{FastEthernet FastEth Fast FE Fa F},
:GigabitEthernet => %w{GigabitEthernet GigEthernet GigEth GE Gi G},
:TenGigabitEthernet => %w{TenGigabitEthernet TE Te},
:Ethernet => %w{Ethernet Eth E},
:Serial => %w{Serial Se S},
:PortChannel => %w{PortChannel Port-Channel Po},
:POS => %w{POS P},
:VLAN => %w{VLAN VL V},
:Loopback => %w{Loopback Loop Lo},
:ATM => %w{ATM AT A},
:Dialer => %w{Dialer Dial Di D},
:VirtualAccess => %w{Virtual-Access Virtual-A Virtual Virt}
}
def canonalize_ifname(interface)
IF.each do |k,ifnames|
if found = ifnames.find { |ifname| interface =~ /^#{ifname}\s*\d/i }
found = /^#{found}(.+)\Z/i.match(interface)
return "#{k.to_s}#{found[1]}".gsub(/\s+/,'')
end
end
interface
end
def facts
@facts ||= Puppet::Util::NetworkDevice::Cisco::Facts.new(transport)
facts = {}
command do |ng|
facts = @facts.retrieve
end
facts
end
def interface(name)
ifname = canonalize_ifname(name)
interface = parse_interface(ifname)
return { :ensure => :absent } if interface.empty?
interface.merge!(parse_trunking(ifname))
interface.merge!(parse_interface_config(ifname))
end
def new_interface(name)
Puppet::Util::NetworkDevice::Cisco::Interface.new(canonalize_ifname(name), transport)
end
def parse_interface(name)
resource = {}
out = execute("sh interface #{name}")
lines = out.split("\n")
lines.shift; lines.pop
lines.each do |l|
if l =~ /#{name} is (.+), line protocol is /
resource[:ensure] = ($1 == 'up' ? :present : :absent);
end
if l =~ /Auto Speed \(.+\),/ or l =~ /Auto Speed ,/ or l =~ /Auto-speed/
resource[:speed] = :auto
end
if l =~ /, (.+)Mb\/s/
resource[:speed] = $1
end
if l =~ /\s+Auto-duplex \((.{4})\),/
resource[:duplex] = :auto
end
if l =~ /\s+(.+)-duplex/
resource[:duplex] = $1 == "Auto" ? :auto : $1.downcase.to_sym
end
if l =~ /Description: (.+)/
resource[:description] = $1
end
end
resource
end
def parse_interface_config(name)
resource = Hash.new { |hash, key| hash[key] = Array.new ; }
out = execute("sh running-config interface #{name} | begin interface")
lines = out.split("\n")
lines.shift; lines.pop
lines.each do |l|
if l =~ /ip address (#{IP}) (#{IP})\s+secondary\s*$/
resource[:ipaddress] << [prefix_length(IPAddr.new($2)), IPAddr.new($1), 'secondary']
end
if l =~ /ip address (#{IP}) (#{IP})\s*$/
resource[:ipaddress] << [prefix_length(IPAddr.new($2)), IPAddr.new($1), nil]
end
if l =~ /ipv6 address (#{IP})\/(\d+) (eui-64|link-local)/
resource[:ipaddress] << [$2.to_i, IPAddr.new($1), $3]
end
if l =~ /channel-group\s+(\d+)/
resource[:etherchannel] = $1
end
end
resource
end
def parse_vlans
vlans = {}
out = execute(support_vlan_brief? ? "sh vlan brief" : "sh vlan-switch brief")
lines = out.split("\n")
lines.shift; lines.shift; lines.shift; lines.pop
vlan = nil
lines.each do |l|
case l
# vlan name status
when /^(\d+)\s+(\w+)\s+(\w+)\s+([a-zA-Z0-9,\/. ]+)\s*$/
vlan = { :name => $1, :description => $2, :status => $3, :interfaces => [] }
if $4.strip.length > 0
vlan[:interfaces] = $4.strip.split(/\s*,\s*/).map{ |ifn| canonalize_ifname(ifn) }
end
vlans[vlan[:name]] = vlan
when /^\s+([a-zA-Z0-9,\/. ]+)\s*$/
raise "invalid sh vlan summary output" unless vlan
if $1.strip.length > 0
vlan[:interfaces] += $1.strip.split(/\s*,\s*/).map{ |ifn| canonalize_ifname(ifn) }
end
else
end
end
vlans
end
def update_vlan(id, is = {}, should = {})
if should[:ensure] == :absent
Puppet.info "Removing #{id} from device vlan"
execute("conf t")
execute("no vlan #{id}")
execute("exit")
return
end
# We're creating or updating an entry
execute("conf t")
execute("vlan #{id}")
[is.keys, should.keys].flatten.uniq.each do |property|
Puppet.debug("trying property: #{property}: #{should[property]}")
next if property != :description
execute("name #{should[property]}")
end
execute("exit")
execute("exit")
end
def parse_trunking(interface)
trunking = {}
out = execute("sh interface #{interface} switchport")
lines = out.split("\n")
lines.shift; lines.pop
lines.each do |l|
case l
when /^Administrative mode:\s+(.*)$/i
case $1
when "trunk"
trunking[:mode] = :trunk
when "static access"
trunking[:mode] = :access
else
raise "Unknown switchport mode: #{$1} for #{interface}"
end
when /^Administrative Trunking Encapsulation:\s+(.*)$/
case $1
when "dot1q","isl"
trunking[:encapsulation] = $1.to_sym if trunking[:mode] == :trunk
else
raise "Unknown switchport encapsulation: #{$1} for #{interface}"
end
when /^Access Mode VLAN:\s+(.*) \(\(Inactive\)\)$/
# nothing
when /^Access Mode VLAN:\s+(.*) \(.*\)$/
trunking[:native_vlan] = $1 if trunking[:mode] == :access
when /^Trunking VLANs Enabled:\s+(.*)$/
next if trunking[:mode] == :access
vlans = $1
trunking[:allowed_trunk_vlans] = case vlans
when /all/i
:all
when /none/i
:none
else
vlans
end
end
end
trunking
end
end
puppet-3.4.3/lib/puppet/util/network_device/transport.rb 0000644 0052762 0001160 00000000137 12300765631 023363 0 ustar jenkins jenkins require 'puppet/util/network_device'
# stub
module Puppet::Util::NetworkDevice::Transport
end
puppet-3.4.3/lib/puppet/util/network_device/ipcalc.rb 0000644 0052762 0001160 00000003316 12300765631 022564 0 ustar jenkins jenkins require 'puppet/util/network_device'
module Puppet::Util::NetworkDevice::IPCalc
# This is a rip-off of authstore
Octet = '(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])'
IPv4 = "#{Octet}\.#{Octet}\.#{Octet}\.#{Octet}"
IPv6_full = "_:_:_:_:_:_:_:_|_:_:_:_:_:_::_?|_:_:_:_:_::((_:)?_)?|_:_:_:_::((_:){0,2}_)?|_:_:_::((_:){0,3}_)?|_:_::((_:){0,4}_)?|_::((_:){0,5}_)?|::((_:){0,6}_)?"
IPv6_partial = "_:_:_:_:_:_:|_:_:_:_::(_:)?|_:_::(_:){0,2}|_::(_:){0,3}"
IP = "#{IPv4}|#{IPv6_full}".gsub(/_/,'([0-9a-fA-F]{1,4})').gsub(/\(/,'(?:')
def parse(value)
case value
when /^(#{IP})\/(\d+)$/ # 12.34.56.78/24, a001:b002::efff/120, c444:1000:2000::9:192.168.0.1/112
[$2.to_i,IPAddr.new($1)]
when /^(#{IP})$/ # 10.20.30.40,
value = IPAddr.new(value)
[bits(value.family),value]
end
end
def bits(family)
family == Socket::AF_INET6 ? 128 : 32
end
def fullmask(family)
(1 << bits(family)) - 1
end
def mask(family, length)
(1 << (bits(family) - length)) - 1
end
# returns ip address netmask from prefix length
def netmask(family, length)
IPAddr.new(fullmask(family) & ~mask(family, length) , family)
end
# returns an IOS wildmask
def wildmask(family, length)
IPAddr.new(mask(family, length) , family)
end
# returns ip address prefix length from netmask
def prefix_length(netmask)
mask_addr = netmask.to_i
return 0 if mask_addr == 0
length=32
if (netmask.ipv6?)
length=128
end
mask = mask_addr < 2**length ? length : 128
mask.times do
if ((mask_addr & 1) == 1)
break
end
mask_addr = mask_addr >> 1
mask = mask - 1
end
mask
end
def linklocal?(ip)
end
end
puppet-3.4.3/lib/puppet/util/network_device/base.rb 0000644 0052762 0001160 00000001430 12300765631 022236 0 ustar jenkins jenkins require 'puppet/util/autoload'
require 'uri'
require 'puppet/util/network_device/transport'
require 'puppet/util/network_device/transport/base'
class Puppet::Util::NetworkDevice::Base
attr_accessor :url, :transport
def initialize(url, options = {})
@url = URI.parse(url)
@autoloader = Puppet::Util::Autoload.new(
self,
"puppet/util/network_device/transport",
:wrap => false
)
if @autoloader.load(@url.scheme)
@transport = Puppet::Util::NetworkDevice::Transport.const_get(@url.scheme.capitalize).new(options[:debug])
@transport.host = @url.host
@transport.port = @url.port || case @url.scheme ; when "ssh" ; 22 ; when "telnet" ; 23 ; end
@transport.user = @url.user
@transport.password = @url.password
end
end
end
puppet-3.4.3/lib/puppet/util/metric.rb 0000644 0052762 0001160 00000012615 12300765631 017606 0 ustar jenkins jenkins # included so we can test object types
require 'puppet'
require 'puppet/network/format_support'
# A class for handling metrics. This is currently ridiculously hackish.
class Puppet::Util::Metric
include Puppet::Network::FormatSupport
attr_accessor :type, :name, :value, :label
attr_writer :values
attr_writer :basedir
def self.from_pson(data)
metric = new(data['name'], data['label'])
metric.values = data['values']
metric
end
def to_data_hash
{
'name' => @name,
'label' => @label,
'values' => @values
}
end
def to_pson(*args)
to_data_hash.to_pson(*args)
end
# Return a specific value
def [](name)
if value = @values.find { |v| v[0] == name }
return value[2]
else
return 0
end
end
def basedir
if defined?(@basedir)
@basedir
else
Puppet[:rrddir]
end
end
def create(start = nil)
Puppet.settings.use(:main, :metrics)
start ||= Time.now.to_i - 5
args = []
if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
@rrd = RRDtool.new(self.path)
end
values.each { |value|
# the 7200 is the heartbeat -- this means that any data that isn't
# more frequently than every two hours gets thrown away
args.push "DS:#{value[0]}:GAUGE:7200:U:U"
}
args.push "RRA:AVERAGE:0.5:1:300"
begin
if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
@rrd.create( Puppet[:rrdinterval], start, args)
else
RRD.create( self.path, '-s', Puppet[:rrdinterval].to_s, '-b', start.to_i.to_s, *args)
end
rescue => detail
raise "Could not create RRD file #{path}: #{detail}"
end
end
def dump
if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
puts @rrd.info
else
puts RRD.info(self.path)
end
end
def graph(range = nil)
unless Puppet.features.rrd? || Puppet.features.rrd_legacy?
Puppet.warning "RRD library is missing; cannot graph metrics"
return
end
unit = 60 * 60 * 24
colorstack = %w{#00ff00 #ff0000 #0000ff #ffff00 #ff99ff #ff9966 #66ffff #990000 #099000 #000990 #f00990 #0f0f0f #555555 #333333 #ffffff}
{:daily => unit, :weekly => unit * 7, :monthly => unit * 30, :yearly => unit * 365}.each do |name, time|
file = self.path.sub(/\.rrd$/, "-#{name}.png")
args = [file]
args.push("--title",self.label)
args.push("--imgformat","PNG")
args.push("--interlace")
defs = []
lines = []
#p @values.collect { |s,l| s }
values.zip(colorstack).each { |value,color|
next if value.nil?
# this actually uses the data label
defs.push("DEF:#{value[0]}=#{self.path}:#{value[0]}:AVERAGE")
lines.push("LINE2:#{value[0]}#{color}:#{value[1]}")
}
args << defs
args << lines
args.flatten!
if range
if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
args.push("--start",range[0],"--end",range[1])
else
args.push("--start",range[0].to_i.to_s,"--end",range[1].to_i.to_s)
end
else
if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
args.push("--start", Time.now.to_i - time, "--end", Time.now.to_i)
else
args.push("--start", (Time.now.to_i - time).to_s, "--end", Time.now.to_i.to_s)
end
end
begin
#Puppet.warning "args = #{args}"
if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
RRDtool.graph( args )
else
RRD.graph( *args )
end
rescue => detail
Puppet.err "Failed to graph #{self.name}: #{detail}"
end
end
end
def initialize(name,label = nil)
@name = name.to_s
@label = label || self.class.labelize(name)
@values = []
end
def path
File.join(self.basedir, @name + ".rrd")
end
def newvalue(name,value,label = nil)
raise ArgumentError.new("metric name #{name.inspect} is not a string") unless name.is_a? String
label ||= self.class.labelize(name)
@values.push [name,label,value]
end
def store(time)
unless Puppet.features.rrd? || Puppet.features.rrd_legacy?
Puppet.warning "RRD library is missing; cannot store metrics"
return
end
self.create(time - 5) unless Puppet::FileSystem::File.exist?(self.path)
if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
@rrd ||= RRDtool.new(self.path)
end
# XXX this is not terribly error-resistant
args = [time]
temps = []
values.each { |value|
#Puppet.warning "value[0]: #{value[0]}; value[1]: #{value[1]}; value[2]: #{value[2]}; "
args.push value[2]
temps.push value[0]
}
arg = args.join(":")
template = temps.join(":")
begin
if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
@rrd.update( template, [ arg ] )
else
RRD.update( self.path, '-t', template, arg )
end
#system("rrdtool updatev #{self.path} '#{arg}'")
rescue => detail
raise Puppet::Error, "Failed to update #{self.name}: #{detail}"
end
end
def values
@values.sort { |a, b| a[1] <=> b[1] }
end
# Convert a name into a label.
def self.labelize(name)
name.to_s.capitalize.gsub("_", " ")
end
end
# This is necessary because we changed the class path in early 2007,
# and reports directly yaml-dump these metrics, so both client and server
# have to agree on the class name.
Puppet::Metric = Puppet::Util::Metric
puppet-3.4.3/lib/puppet/transaction/ 0000755 0052762 0001160 00000000000 12300765640 017341 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/transaction/resource_harness.rb 0000644 0052762 0001160 00000017243 12300765631 023247 0 ustar jenkins jenkins require 'puppet/resource/status'
class Puppet::Transaction::ResourceHarness
NO_ACTION = Object.new
extend Forwardable
def_delegators :@transaction, :relationship_graph
attr_reader :transaction
def initialize(transaction)
@transaction = transaction
end
def evaluate(resource)
status = Puppet::Resource::Status.new(resource)
begin
context = ResourceApplicationContext.from_resource(resource, status)
perform_changes(resource, context)
if status.changed? && ! resource.noop?
cache(resource, :synced, Time.now)
resource.flush if resource.respond_to?(:flush)
end
rescue => detail
status.failed_because(detail)
ensure
status.evaluation_time = Time.now - status.time
end
status
end
def scheduled?(resource)
return true if Puppet[:ignoreschedules]
return true unless schedule = schedule(resource)
# We use 'checked' here instead of 'synced' because otherwise we'll
# end up checking most resources most times, because they will generally
# have been synced a long time ago (e.g., a file only gets updated
# once a month on the server and its schedule is daily; the last sync time
# will have been a month ago, so we'd end up checking every run).
schedule.match?(cached(resource, :checked).to_i)
end
def schedule(resource)
unless resource.catalog
resource.warning "Cannot schedule without a schedule-containing catalog"
return nil
end
return nil unless name = resource[:schedule]
resource.catalog.resource(:schedule, name) || resource.fail("Could not find schedule #{name}")
end
# Used mostly for scheduling and auditing at this point.
def cached(resource, name)
Puppet::Util::Storage.cache(resource)[name]
end
# Used mostly for scheduling and auditing at this point.
def cache(resource, name, value)
Puppet::Util::Storage.cache(resource)[name] = value
end
private
def perform_changes(resource, context)
cache(resource, :checked, Time.now)
return [] if ! allow_changes?(resource)
# Record the current state in state.yml.
context.audited_params.each do |param|
cache(resource, param, context.current_values[param])
end
ensure_param = resource.parameter(:ensure)
if ensure_param && ensure_param.should
ensure_event = sync_if_needed(ensure_param, context)
else
ensure_event = NO_ACTION
end
if ensure_event == NO_ACTION
if context.resource_present?
resource.properties.each do |param|
sync_if_needed(param, context)
end
else
resource.debug("Nothing to manage: no ensure and the resource doesn't exist")
end
end
capture_audit_events(resource, context)
end
def allow_changes?(resource)
if resource.purging? and resource.deleting? and deps = relationship_graph.dependents(resource) \
and ! deps.empty? and deps.detect { |d| ! d.deleting? }
deplabel = deps.collect { |r| r.ref }.join(",")
plurality = deps.length > 1 ? "":"s"
resource.warning "#{deplabel} still depend#{plurality} on me -- not purging"
false
else
true
end
end
def sync_if_needed(param, context)
historical_value = context.historical_values[param.name]
current_value = context.current_values[param.name]
do_audit = context.audited_params.include?(param.name)
begin
if param.should && !param.safe_insync?(current_value)
event = create_change_event(param, current_value, historical_value)
if do_audit
event = audit_event(event, param)
end
brief_audit_message = audit_message(param, do_audit, historical_value, current_value)
if param.noop
noop(event, param, current_value, brief_audit_message)
else
sync(event, param, current_value, brief_audit_message)
end
event
else
NO_ACTION
end
rescue => detail
# Execution will continue on StandardErrors, just store the event
Puppet.log_exception(detail)
event = create_change_event(param, current_value, historical_value)
event.status = "failure"
event.message = "change from #{param.is_to_s(current_value)} to #{param.should_to_s(param.should)} failed: #{detail}"
event
rescue Exception => detail
# Execution will halt on Exceptions, they get raised to the application
event = create_change_event(param, current_value, historical_value)
event.status = "failure"
event.message = "change from #{param.is_to_s(current_value)} to #{param.should_to_s(param.should)} failed: #{detail}"
raise
ensure
if event
context.record(event)
event.send_log
context.synced_params << param.name
end
end
end
def create_change_event(property, current_value, historical_value)
event = property.event
event.previous_value = current_value
event.desired_value = property.should
event.historical_value = historical_value
event
end
def audit_event(event, property)
event.audited = true
event.status = "audit"
if event.historical_value != event.previous_value
event.message = "audit change: previously recorded value #{property.is_to_s(event.historical_value)} has been changed to #{property.is_to_s(event.previous_value)}"
end
event
end
def audit_message(param, do_audit, historical_value, current_value)
if do_audit && historical_value && historical_value != current_value
" (previously recorded value was #{param.is_to_s(historical_value)})"
else
""
end
end
def noop(event, param, current_value, audit_message)
event.message = "current_value #{param.is_to_s(current_value)}, should be #{param.should_to_s(param.should)} (noop)#{audit_message}"
event.status = "noop"
end
def sync(event, param, current_value, audit_message)
param.sync
event.message = "#{param.change_to_s(current_value, param.should)}#{audit_message}"
event.status = "success"
end
def capture_audit_events(resource, context)
context.audited_params.each do |param_name|
if context.historical_values.include?(param_name)
if context.historical_values[param_name] != context.current_values[param_name] && !context.synced_params.include?(param_name)
parameter = resource.parameter(param_name)
event = audit_event(create_change_event(parameter,
context.current_values[param_name],
context.historical_values[param_name]),
parameter)
event.send_log
context.record(event)
end
else
resource.property(param_name).notice "audit change: newly-recorded value #{context.current_values[param_name]}"
end
end
end
# @api private
ResourceApplicationContext = Struct.new(:resource,
:current_values,
:historical_values,
:audited_params,
:synced_params,
:status) do
def self.from_resource(resource, status)
ResourceApplicationContext.new(resource,
resource.retrieve_resource.to_hash,
Puppet::Util::Storage.cache(resource).dup,
(resource[:audit] || []).map { |p| p.to_sym },
[],
status)
end
def resource_present?
resource.present?(current_values)
end
def record(event)
status << event
end
end
end
puppet-3.4.3/lib/puppet/transaction/additional_resource_generator.rb 0000644 0052762 0001160 00000010746 12300765631 025763 0 ustar jenkins jenkins # Adds additional resources to the catalog and relationship graph that are
# generated by existing resources. There are two ways that a resource can
# generate additional resources, either through the #generate method or the
# #eval_generate method.
#
# @api private
class Puppet::Transaction::AdditionalResourceGenerator
def initialize(catalog, relationship_graph, prioritizer)
@catalog = catalog
@relationship_graph = relationship_graph
@prioritizer = prioritizer
end
def generate_additional_resources(resource)
return unless resource.respond_to?(:generate)
begin
generated = resource.generate
rescue => detail
resource.log_exception(detail, "Failed to generate additional resources using 'generate': #{detail}")
end
return unless generated
generated = [generated] unless generated.is_a?(Array)
generated.collect do |res|
@catalog.resource(res.ref) || res
end.each do |res|
priority = @prioritizer.generate_priority_contained_in(resource, res)
add_resource(res, resource, priority)
add_conditional_directed_dependency(resource, res)
generate_additional_resources(res)
end
end
def eval_generate(resource)
return false unless resource.respond_to?(:eval_generate)
raise Puppet::DevError,"Depthfirst resources are not supported by eval_generate" if resource.depthfirst?
begin
generated = replace_duplicates_with_catalog_resources(resource.eval_generate)
return false if generated.empty?
rescue => detail
resource.log_exception(detail, "Failed to generate additional resources using 'eval_generate': #{detail}")
return false
end
add_resources(generated, resource)
made = Hash[generated.map(&:name).zip(generated)]
contain_generated_resources_in(resource, made)
connect_resources_to_ancestors(resource, made)
true
end
private
def replace_duplicates_with_catalog_resources(generated)
generated.collect do |generated_resource|
@catalog.resource(generated_resource.ref) || generated_resource
end
end
def contain_generated_resources_in(resource, made)
sentinel = Puppet::Type.type(:whit).new(:name => "completed_#{resource.title}", :catalog => resource.catalog)
priority = @prioritizer.generate_priority_contained_in(resource, sentinel)
@relationship_graph.add_vertex(sentinel, priority)
redirect_edges_to_sentinel(resource, sentinel, made)
made.values.each do |res|
# This resource isn't 'completed' until each child has run
add_conditional_directed_dependency(res, sentinel, Puppet::Graph::RelationshipGraph::Default_label)
end
# This edge allows the resource's events to propagate, though it isn't
# strictly necessary for ordering purposes
add_conditional_directed_dependency(resource, sentinel, Puppet::Graph::RelationshipGraph::Default_label)
end
def redirect_edges_to_sentinel(resource, sentinel, made)
@relationship_graph.adjacent(resource, :direction => :out, :type => :edges).each do |e|
next if made[e.target.name]
@relationship_graph.add_relationship(sentinel, e.target, e.label)
@relationship_graph.remove_edge! e
end
end
def connect_resources_to_ancestors(resource, made)
made.values.each do |res|
# Depend on the nearest ancestor we generated, falling back to the
# resource if we have none
parent_name = res.ancestors.find { |a| made[a] and made[a] != res }
parent = made[parent_name] || resource
add_conditional_directed_dependency(parent, res)
end
end
def add_resources(generated, resource)
generated.each do |res|
priority = @prioritizer.generate_priority_contained_in(resource, res)
add_resource(res, resource, priority)
end
end
def add_resource(res, parent_resource, priority)
if @catalog.resource(res.ref).nil?
res.tag(*parent_resource.tags)
@catalog.add_resource(res)
@relationship_graph.add_vertex(res, priority)
@catalog.add_edge(@catalog.container_of(parent_resource), res)
res.finish
end
end
# Copy an important relationships from the parent to the newly-generated
# child resource.
def add_conditional_directed_dependency(parent, child, label=nil)
@relationship_graph.add_vertex(child)
edge = parent.depthfirst? ? [child, parent] : [parent, child]
if @relationship_graph.edge?(*edge.reverse)
parent.debug "Skipping automatic relationship to #{child}"
else
@relationship_graph.add_relationship(edge[0],edge[1],label)
end
end
end
puppet-3.4.3/lib/puppet/transaction/event.rb 0000644 0052762 0001160 00000005230 12300765631 021007 0 ustar jenkins jenkins require 'puppet/transaction'
require 'puppet/util/tagging'
require 'puppet/util/logging'
require 'puppet/util/methodhelper'
require 'puppet/network/format_support'
# A simple struct for storing what happens on the system.
class Puppet::Transaction::Event
include Puppet::Util::MethodHelper
include Puppet::Util::Tagging
include Puppet::Util::Logging
include Puppet::Network::FormatSupport
ATTRIBUTES = [:name, :resource, :property, :previous_value, :desired_value, :historical_value, :status, :message, :file, :line, :source_description, :audited, :invalidate_refreshes]
YAML_ATTRIBUTES = %w{@audited @property @previous_value @desired_value @historical_value @message @name @status @time}.map(&:to_sym)
attr_accessor *ATTRIBUTES
attr_accessor :time
attr_reader :default_log_level
EVENT_STATUSES = %w{noop success failure audit}
def self.from_pson(data)
obj = self.allocate
obj.initialize_from_hash(data)
obj
end
def initialize(options = {})
@audited = false
set_options(options)
@time = Time.now
end
def initialize_from_hash(data)
@audited = data['audited']
@property = data['property']
@previous_value = data['previous_value']
@desired_value = data['desired_value']
@historical_value = data['historical_value']
@message = data['message']
@name = data['name'].intern if data['name']
@status = data['status']
@time = data['time']
@time = Time.parse(@time) if @time.is_a? String
end
def to_data_hash
{
'audited' => @audited,
'property' => @property,
'previous_value' => @previous_value,
'desired_value' => @desired_value,
'historical_value' => @historical_value,
'message' => @message,
'name' => @name,
'status' => @status,
'time' => @time.iso8601(9),
}
end
def to_pson(*args)
to_data_hash.to_pson(*args)
end
def property=(prop)
@property = prop.to_s
end
def resource=(res)
if res.respond_to?(:[]) and level = res[:loglevel]
@default_log_level = level
end
@resource = res.to_s
end
def send_log
super(log_level, message)
end
def status=(value)
raise ArgumentError, "Event status can only be #{EVENT_STATUSES.join(', ')}" unless EVENT_STATUSES.include?(value)
@status = value
end
def to_s
message
end
def to_yaml_properties
YAML_ATTRIBUTES & super
end
private
# If it's a failure, use 'err', else use either the resource's log level (if available)
# or 'notice'.
def log_level
status == "failure" ? :err : (@default_log_level || :notice)
end
# Used by the Logging module
def log_source
source_description || property || resource
end
end
puppet-3.4.3/lib/puppet/transaction/report.rb 0000644 0052762 0001160 00000025220 12300765631 021202 0 ustar jenkins jenkins require 'puppet'
require 'puppet/indirector'
# This class is used to report what happens on a client.
# There are two types of data in a report; _Logs_ and _Metrics_.
#
# * **Logs** - are the output that each change produces.
# * **Metrics** - are all of the numerical data involved in the transaction.
#
# Use {Puppet::Reports} class to create a new custom report type. This class is indirectly used
# as a source of data to report in such a registered report.
#
# ##Metrics
# There are three types of metrics in each report, and each type of metric has one or more values.
#
# * Time: Keeps track of how long things took.
# * Total: Total time for the configuration run
# * File:
# * Exec:
# * User:
# * Group:
# * Config Retrieval: How long the configuration took to retrieve
# * Service:
# * Package:
# * Resources: Keeps track of the following stats:
# * Total: The total number of resources being managed
# * Skipped: How many resources were skipped, because of either tagging or scheduling restrictions
# * Scheduled: How many resources met any scheduling restrictions
# * Out of Sync: How many resources were out of sync
# * Applied: How many resources were attempted to be fixed
# * Failed: How many resources were not successfully fixed
# * Restarted: How many resources were restarted because their dependencies changed
# * Failed Restarts: How many resources could not be restarted
# * Changes: The total number of changes in the transaction.
#
# @api public
class Puppet::Transaction::Report
extend Puppet::Indirector
indirects :report, :terminus_class => :processor
# The version of the configuration
# @todo Uncertain what this is?
# @return [???] the configuration version
attr_accessor :configuration_version
# An agent generated transaction uuid, useful for connecting catalog and report
# @return [String] uuid
attr_accessor :transaction_uuid
# The host name for which the report is generated
# @return [String] the host name
attr_accessor :host
# The name of the environment the host is in
# @return [String] the environment name
attr_accessor :environment
# A hash with a map from resource to status
# @return [Hash<{String => String}>] Resource name to status string.
# @todo Uncertain if the types in the hash are correct...
attr_reader :resource_statuses
# A list of log messages.
# @return [Array] logged messages
attr_reader :logs
# A hash of metric name to metric value.
# @return [Hash<{String => Object}>] A map of metric name to value.
# @todo Uncertain if all values are numbers - now marked as Object.
#
attr_reader :metrics
# The time when the report data was generated.
# @return [Time] A time object indicating when the report data was generated
#
attr_reader :time
# The 'kind' of report is the name of operation that triggered the report to be produced.
# Typically "apply".
# @return [String] the kind of operation that triggered the generation of the report.
#
attr_reader :kind
# The status of the client run is an enumeration: 'failed', 'changed' or 'unchanged'
# @return [String] the status of the run - one of the values 'failed', 'changed', or 'unchanged'
#
attr_reader :status
# @return [String] The Puppet version in String form.
# @see Puppet::version()
#
attr_reader :puppet_version
# @return [Integer] report format version number. This value is constant for
# a given version of Puppet; it is incremented when a new release of Puppet
# changes the API for the various objects that make up a report.
#
attr_reader :report_format
def self.from_pson(data)
obj = self.allocate
obj.initialize_from_hash(data)
obj
end
def as_logging_destination(&block)
Puppet::Util::Log.with_destination(self, &block)
end
# @api private
def <<(msg)
@logs << msg
self
end
# @api private
def add_times(name, value)
@external_times[name] = value
end
# @api private
def add_metric(name, hash)
metric = Puppet::Util::Metric.new(name)
hash.each do |name, value|
metric.newvalue(name, value)
end
@metrics[metric.name] = metric
metric
end
# @api private
def add_resource_status(status)
@resource_statuses[status.resource] = status
end
# @api private
def compute_status(resource_metrics, change_metric)
if (resource_metrics["failed"] || 0) > 0
'failed'
elsif change_metric > 0
'changed'
else
'unchanged'
end
end
# @api private
def prune_internal_data
resource_statuses.delete_if {|name,res| res.resource_type == 'Whit'}
end
# @api private
def finalize_report
prune_internal_data
resource_metrics = add_metric(:resources, calculate_resource_metrics)
add_metric(:time, calculate_time_metrics)
change_metric = calculate_change_metric
add_metric(:changes, {"total" => change_metric})
add_metric(:events, calculate_event_metrics)
@status = compute_status(resource_metrics, change_metric)
end
# @api private
def initialize(kind, configuration_version=nil, environment=nil, transaction_uuid=nil)
@metrics = {}
@logs = []
@resource_statuses = {}
@external_times ||= {}
@host = Puppet[:node_name_value]
@time = Time.now
@kind = kind
@report_format = 4
@puppet_version = Puppet.version
@configuration_version = configuration_version
@transaction_uuid = transaction_uuid
@environment = environment
@status = 'failed' # assume failed until the report is finalized
end
# @api private
def initialize_from_hash(data)
@puppet_version = data['puppet_version']
@report_format = data['report_format']
@configuration_version = data['configuration_version']
@transaction_uuid = data['transaction_uuid']
@environment = data['environment']
@status = data['status']
@host = data['host']
@time = data['time']
if @time.is_a? String
@time = Time.parse(@time)
end
@kind = data['kind']
@metrics = {}
data['metrics'].each do |name, hash|
@metrics[name] = Puppet::Util::Metric.from_pson(hash)
end
@logs = data['logs'].map do |record|
Puppet::Util::Log.from_pson(record)
end
@resource_statuses = {}
data['resource_statuses'].map do |record|
if record[1] == {}
status = nil
else
status = Puppet::Resource::Status.from_pson(record[1])
end
@resource_statuses[record[0]] = status
end
end
def to_data_hash
{
'host' => @host,
'time' => @time.iso8601(9),
'configuration_version' => @configuration_version,
'transaction_uuid' => @transaction_uuid,
'report_format' => @report_format,
'puppet_version' => @puppet_version,
'kind' => @kind,
'status' => @status,
'environment' => @environment,
'logs' => @logs,
'metrics' => @metrics,
'resource_statuses' => @resource_statuses,
}
end
def to_pson
to_data_hash.to_pson
end
# @return [String] the host name
# @api public
#
def name
host
end
# Provide a human readable textual summary of this report.
# @note This is intended for debugging purposes
# @return [String] A string with a textual summary of this report.
# @api public
#
def summary
report = raw_summary
ret = ""
report.keys.sort { |a,b| a.to_s <=> b.to_s }.each do |key|
ret += "#{Puppet::Util::Metric.labelize(key)}:\n"
report[key].keys.sort { |a,b|
# sort by label
if a == :total
1
elsif b == :total
-1
else
report[key][a].to_s <=> report[key][b].to_s
end
}.each do |label|
value = report[key][label]
next if value == 0
value = "%0.2f" % value if value.is_a?(Float)
ret += " %15s %s\n" % [Puppet::Util::Metric.labelize(label) + ":", value]
end
end
ret
end
# Provides a raw hash summary of this report.
# @return [Hash<{String => Object}>] A hash with metrics key to value map
# @api public
#
def raw_summary
report = { "version" => { "config" => configuration_version, "puppet" => Puppet.version } }
@metrics.each do |name, metric|
key = metric.name.to_s
report[key] = {}
metric.values.each do |name, label, value|
report[key][name.to_s] = value
end
report[key]["total"] = 0 unless key == "time" or report[key].include?("total")
end
(report["time"] ||= {})["last_run"] = Time.now.tv_sec
report
end
# Computes a single number that represents the report's status.
# The computation is based on the contents of this report's metrics.
# The resulting number is a bitmask where
# individual bits represent the presence of different metrics.
#
# * 0x2 set if there are changes
# * 0x4 set if there are resource failures or resources that failed to restart
# @return [Integer] A bitmask where 0x2 is set if there are changes, and 0x4 is set of there are failures.
# @api public
#
def exit_status
status = 0
status |= 2 if @metrics["changes"]["total"] > 0
status |= 4 if @metrics["resources"]["failed"] > 0
status |= 4 if @metrics["resources"]["failed_to_restart"] > 0
status
end
# @api private
#
def to_yaml_properties
super - [:@external_times]
end
def self.supported_formats
[:pson, :yaml]
end
def self.default_format
Puppet[:report_serialization_format].intern
end
private
def calculate_change_metric
resource_statuses.map { |name, status| status.change_count || 0 }.inject(0) { |a,b| a+b }
end
def calculate_event_metrics
metrics = Hash.new(0)
%w{total failure success}.each { |m| metrics[m] = 0 }
resource_statuses.each do |name, status|
metrics["total"] += status.events.length
status.events.each do |event|
metrics[event.status] += 1
end
end
metrics
end
def calculate_resource_metrics
metrics = {}
metrics["total"] = resource_statuses.length
# force every resource key in the report to be present
# even if no resources is in this given state
Puppet::Resource::Status::STATES.each do |state|
metrics[state.to_s] = 0
end
resource_statuses.each do |name, status|
Puppet::Resource::Status::STATES.each do |state|
metrics[state.to_s] += 1 if status.send(state)
end
end
metrics
end
def calculate_time_metrics
metrics = Hash.new(0)
resource_statuses.each do |name, status|
type = Puppet::Resource.new(name).type
metrics[type.to_s.downcase] += status.evaluation_time if status.evaluation_time
end
@external_times.each do |name, value|
metrics[name.to_s.downcase] = value
end
metrics["total"] = metrics.values.inject(0) { |a,b| a+b }
metrics
end
end
puppet-3.4.3/lib/puppet/transaction/event_manager.rb 0000644 0052762 0001160 00000010026 12300765631 022500 0 ustar jenkins jenkins require 'puppet/transaction'
class Puppet::Transaction::EventManager
attr_reader :transaction, :events
def initialize(transaction)
@transaction = transaction
@event_queues = {}
@events = []
end
def relationship_graph
transaction.relationship_graph
end
# Respond to any queued events for this resource.
def process_events(resource)
restarted = false
queued_events(resource) do |callback, events|
r = process_callback(resource, callback, events)
restarted ||= r
end
if restarted
queue_events(resource, [resource.event(:name => :restarted, :status => "success")])
transaction.resource_status(resource).restarted = true
end
end
# Queue events for other resources to respond to. All of these events have
# to be from the same resource.
def queue_events(resource, events)
#@events += events
# Do some basic normalization so we're not doing so many
# graph queries for large sets of events.
events.inject({}) do |collection, event|
collection[event.name] ||= []
collection[event.name] << event
collection
end.collect do |name, list|
# It doesn't matter which event we use - they all have the same source
# and name here.
event = list[0]
# Collect the targets of any subscriptions to those events. We pass
# the parent resource in so it will override the source in the events,
# since eval_generated children can't have direct relationships.
received = (event.name != :restarted)
relationship_graph.matching_edges(event, resource).each do |edge|
received ||= true unless edge.target.is_a?(Puppet::Type.type(:whit))
next unless method = edge.callback
next unless edge.target.respond_to?(method)
queue_events_for_resource(resource, edge.target, method, list)
end
@events << event if received
queue_events_for_resource(resource, resource, :refresh, [event]) if resource.self_refresh? and ! resource.deleting?
end
dequeue_events_for_resource(resource, :refresh) if events.detect { |e| e.invalidate_refreshes }
end
def dequeue_events_for_resource(target, callback)
target.info "Unscheduling #{callback} on #{target}"
@event_queues[target][callback] = {} if @event_queues[target]
end
def queue_events_for_resource(source, target, callback, events)
whit = Puppet::Type.type(:whit)
# The message that a resource is refreshing the completed-whit for its own class
# is extremely counter-intuitive. Basically everything else is easy to understand,
# if you suppress the whit-lookingness of the whit resources
refreshing_c_whit = target.is_a?(whit) && target.name =~ /^completed_/
if refreshing_c_whit
source.debug "The container #{target} will propagate my #{callback} event"
else
source.info "Scheduling #{callback} of #{target}"
end
@event_queues[target] ||= {}
@event_queues[target][callback] ||= []
@event_queues[target][callback].concat(events)
end
def queued_events(resource)
return unless callbacks = @event_queues[resource]
callbacks.each do |callback, events|
yield callback, events unless events.empty?
end
end
private
def process_callback(resource, callback, events)
process_noop_events(resource, callback, events) and return false unless events.detect { |e| e.status != "noop" }
resource.send(callback)
if not resource.is_a?(Puppet::Type.type(:whit))
resource.notice "Triggered '#{callback}' from #{events.length} events"
end
return true
rescue => detail
resource.err "Failed to call #{callback}: #{detail}"
transaction.resource_status(resource).failed_to_restart = true
resource.log_exception(detail)
return false
end
def process_noop_events(resource, callback, events)
resource.notice "Would have triggered '#{callback}' from #{events.length} events"
# And then add an event for it.
queue_events(resource, [resource.event(:status => "noop", :name => :noop_restart)])
true # so the 'and if' works
end
end
puppet-3.4.3/lib/puppet/transaction.rb 0000644 0052762 0001160 00000026500 12300765631 017671 0 ustar jenkins jenkins require 'puppet'
require 'puppet/util/tagging'
require 'puppet/application'
require 'digest/sha1'
require 'set'
# the class that actually walks our resource/property tree, collects the changes,
# and performs them
#
# @api private
class Puppet::Transaction
require 'puppet/transaction/additional_resource_generator'
require 'puppet/transaction/event'
require 'puppet/transaction/event_manager'
require 'puppet/transaction/resource_harness'
require 'puppet/resource/status'
attr_accessor :catalog, :ignoreschedules, :for_network_device
# The report, once generated.
attr_reader :report
# Routes and stores any events and subscriptions.
attr_reader :event_manager
# Handles most of the actual interacting with resources
attr_reader :resource_harness
attr_reader :prefetched_providers
include Puppet::Util
include Puppet::Util::Tagging
def initialize(catalog, report, prioritizer)
@catalog = catalog
@report = report || Puppet::Transaction::Report.new("apply", catalog.version, catalog.environment)
@prioritizer = prioritizer
@report.add_times(:config_retrieval, @catalog.retrieval_duration || 0)
@event_manager = Puppet::Transaction::EventManager.new(self)
@resource_harness = Puppet::Transaction::ResourceHarness.new(self)
@prefetched_providers = Hash.new { |h,k| h[k] = {} }
end
# This method does all the actual work of running a transaction. It
# collects all of the changes, executes them, and responds to any
# necessary events.
def evaluate(&block)
block ||= method(:eval_resource)
generator = AdditionalResourceGenerator.new(@catalog, relationship_graph, @prioritizer)
@catalog.vertices.each { |resource| generator.generate_additional_resources(resource) }
Puppet.info "Applying configuration version '#{catalog.version}'" if catalog.version
continue_while = lambda { !stop_processing? }
post_evalable_providers = Set.new
pre_process = lambda do |resource|
prov_class = resource.provider.class
post_evalable_providers << prov_class if prov_class.respond_to?(:post_resource_eval)
prefetch_if_necessary(resource)
# If we generated resources, we don't know what they are now
# blocking, so we opt to recompute it, rather than try to track every
# change that would affect the number.
relationship_graph.clear_blockers if generator.eval_generate(resource)
end
providerless_types = []
overly_deferred_resource_handler = lambda do |resource|
# We don't automatically assign unsuitable providers, so if there
# is one, it must have been selected by the user.
if resource.provider
resource.err "Provider #{resource.provider.class.name} is not functional on this host"
else
providerless_types << resource.type
end
resource_status(resource).failed = true
end
canceled_resource_handler = lambda do |resource|
resource_status(resource).skipped = true
resource.debug "Transaction canceled, skipping"
end
teardown = lambda do
# Just once per type. No need to punish the user.
providerless_types.uniq.each do |type|
Puppet.err "Could not find a suitable provider for #{type}"
end
post_evalable_providers.each do |provider|
begin
provider.post_resource_eval
rescue => detail
Puppet.log_exception(detail, "post_resource_eval failed for provider #{provider}")
end
end
end
relationship_graph.traverse(:while => continue_while,
:pre_process => pre_process,
:overly_deferred_resource_handler => overly_deferred_resource_handler,
:canceled_resource_handler => canceled_resource_handler,
:teardown => teardown) do |resource|
if resource.is_a?(Puppet::Type::Component)
Puppet.warning "Somehow left a component in the relationship graph"
else
resource.info "Starting to evaluate the resource" if Puppet[:evaltrace] and @catalog.host_config?
seconds = thinmark { block.call(resource) }
resource.info "Evaluated in %0.2f seconds" % seconds if Puppet[:evaltrace] and @catalog.host_config?
end
end
Puppet.debug "Finishing transaction #{object_id}"
end
# Wraps application run state check to flag need to interrupt processing
def stop_processing?
Puppet::Application.stop_requested? && catalog.host_config?
end
# Are there any failed resources in this transaction?
def any_failed?
report.resource_statuses.values.detect { |status| status.failed? }
end
# Find all of the changed resources.
def changed?
report.resource_statuses.values.find_all { |status| status.changed }.collect { |status| catalog.resource(status.resource) }
end
def relationship_graph
catalog.relationship_graph
end
def resource_status(resource)
report.resource_statuses[resource.to_s] || add_resource_status(Puppet::Resource::Status.new(resource))
end
# The tags we should be checking.
def tags
self.tags = Puppet[:tags] unless defined?(@tags)
super
end
def prefetch_if_necessary(resource)
provider_class = resource.provider.class
return unless provider_class.respond_to?(:prefetch) and !prefetched_providers[resource.type][provider_class.name]
resources = resources_by_provider(resource.type, provider_class.name)
if provider_class == resource.class.defaultprovider
providerless_resources = resources_by_provider(resource.type, nil)
providerless_resources.values.each {|res| res.provider = provider_class.name}
resources.merge! providerless_resources
end
prefetch(provider_class, resources)
end
private
# Apply all changes for a resource
def apply(resource, ancestor = nil)
status = resource_harness.evaluate(resource)
add_resource_status(status)
event_manager.queue_events(ancestor || resource, status.events) unless status.failed?
rescue => detail
resource.err "Could not evaluate: #{detail}"
end
# Evaluate a single resource.
def eval_resource(resource, ancestor = nil)
if skip?(resource)
resource_status(resource).skipped = true
else
resource_status(resource).scheduled = true
apply(resource, ancestor)
end
# Check to see if there are any events queued for this resource
event_manager.process_events(resource)
end
def failed?(resource)
s = resource_status(resource) and s.failed?
end
# Does this resource have any failed dependencies?
def failed_dependencies?(resource)
# First make sure there are no failed dependencies. To do this,
# we check for failures in any of the vertexes above us. It's not
# enough to check the immediate dependencies, which is why we use
# a tree from the reversed graph.
found_failed = false
# When we introduced the :whit into the graph, to reduce the combinatorial
# explosion of edges, we also ended up reporting failures for containers
# like class and stage. This is undesirable; while just skipping the
# output isn't perfect, it is RC-safe. --daniel 2011-06-07
suppress_report = (resource.class == Puppet::Type.type(:whit))
relationship_graph.dependencies(resource).each do |dep|
next unless failed?(dep)
found_failed = true
# See above. --daniel 2011-06-06
unless suppress_report then
resource.notice "Dependency #{dep} has failures: #{resource_status(dep).failed}"
end
end
found_failed
end
# A general method for recursively generating new resources from a
# resource.
def generate_additional_resources(resource)
return unless resource.respond_to?(:generate)
begin
made = resource.generate
rescue => detail
resource.log_exception(detail, "Failed to generate additional resources using 'generate': #{detail}")
end
return unless made
made = [made] unless made.is_a?(Array)
made.uniq.each do |res|
begin
res.tag(*resource.tags)
@catalog.add_resource(res)
res.finish
add_conditional_directed_dependency(resource, res)
generate_additional_resources(res)
rescue Puppet::Resource::Catalog::DuplicateResourceError
res.info "Duplicate generated resource; skipping"
end
end
end
# Should we ignore tags?
def ignore_tags?
! @catalog.host_config?
end
def resources_by_provider(type_name, provider_name)
unless @resources_by_provider
@resources_by_provider = Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } }
@catalog.vertices.each do |resource|
if resource.class.attrclass(:provider)
prov = resource.provider && resource.provider.class.name
@resources_by_provider[resource.type][prov][resource.name] = resource
end
end
end
@resources_by_provider[type_name][provider_name] || {}
end
# Prefetch any providers that support it, yo. We don't support prefetching
# types, just providers.
def prefetch(provider_class, resources)
type_name = provider_class.resource_type.name
return if @prefetched_providers[type_name][provider_class.name]
Puppet.debug "Prefetching #{provider_class.name} resources for #{type_name}"
begin
provider_class.prefetch(resources)
rescue => detail
Puppet.log_exception(detail, "Could not prefetch #{type_name} provider '#{provider_class.name}': #{detail}")
end
@prefetched_providers[type_name][provider_class.name] = true
end
def add_resource_status(status)
report.add_resource_status(status)
end
# Is the resource currently scheduled?
def scheduled?(resource)
self.ignoreschedules or resource_harness.scheduled?(resource)
end
# Should this resource be skipped?
def skip?(resource)
if missing_tags?(resource)
resource.debug "Not tagged with #{tags.join(", ")}"
elsif ! scheduled?(resource)
resource.debug "Not scheduled"
elsif failed_dependencies?(resource)
# When we introduced the :whit into the graph, to reduce the combinatorial
# explosion of edges, we also ended up reporting failures for containers
# like class and stage. This is undesirable; while just skipping the
# output isn't perfect, it is RC-safe. --daniel 2011-06-07
unless resource.class == Puppet::Type.type(:whit) then
resource.warning "Skipping because of failed dependencies"
end
elsif resource.virtual?
resource.debug "Skipping because virtual"
elsif !host_and_device_resource?(resource) && resource.appliable_to_host? && for_network_device
resource.debug "Skipping host resources because running on a device"
elsif !host_and_device_resource?(resource) && resource.appliable_to_device? && !for_network_device
resource.debug "Skipping device resources because running on a posix host"
else
return false
end
true
end
def host_and_device_resource?(resource)
resource.appliable_to_host? && resource.appliable_to_device?
end
def handle_qualified_tags( qualified )
# The default behavior of Puppet::Util::Tagging is
# to split qualified tags into parts. That would cause
# qualified tags to match too broadly here.
return
end
# Is this resource tagged appropriately?
def missing_tags?(resource)
return false if ignore_tags?
return false if tags.empty?
not resource.tagged?(*tags)
end
end
require 'puppet/transaction/report'
puppet-3.4.3/lib/puppet/file_system/ 0000755 0052762 0001160 00000000000 12300765640 017337 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/file_system/path_pattern.rb 0000644 0052762 0001160 00000004353 12300765631 022362 0 ustar jenkins jenkins require 'pathname'
module Puppet::FileSystem
class PathPattern
class InvalidPattern < Puppet::Error; end
TRAVERSAL = /^\.\.$/
ABSOLUTE_UNIX = /^\//
ABSOLUTE_WINDOWS = /^[a-z]:/i
#ABSOLUT_VODKA #notappearinginthisclass
CURRENT_DRIVE_RELATIVE_WINDOWS = /^\\/
def self.relative(pattern)
RelativePathPattern.new(pattern)
end
def self.absolute(pattern)
AbsolutePathPattern.new(pattern)
end
class << self
protected :new
end
# @param prefix [AbsolutePathPattern] An absolute path pattern instance
# @return [AbsolutePathPattern] A new AbsolutePathPattern prepended with
# the passed prefix's pattern.
def prefix_with(prefix)
new_pathname = prefix.pathname + pathname
self.class.absolute(new_pathname.to_s)
end
def glob
Dir.glob(pathname.to_s)
end
def to_s
pathname.to_s
end
protected
attr_reader :pathname
private
def validate
@pathname.each_filename do |e|
if e =~ TRAVERSAL
raise(InvalidPattern, "PathPatterns cannot be created with directory traversals.")
end
end
case @pathname.to_s
when CURRENT_DRIVE_RELATIVE_WINDOWS
raise(InvalidPattern, "A PathPattern cannot be a Windows current drive relative path.")
end
end
def initialize(pattern)
begin
@pathname = Pathname.new(pattern.strip)
rescue ArgumentError => error
raise InvalidPattern.new("PathPatterns cannot be created with a zero byte.", error)
end
validate
end
end
class RelativePathPattern < PathPattern
def absolute?
false
end
def validate
super
case @pathname.to_s
when ABSOLUTE_WINDOWS
raise(InvalidPattern, "A relative PathPattern cannot be prefixed with a drive.")
when ABSOLUTE_UNIX
raise(InvalidPattern, "A relative PathPattern cannot be an absolute path.")
end
end
end
class AbsolutePathPattern < PathPattern
def absolute?
true
end
def validate
super
if @pathname.to_s !~ ABSOLUTE_UNIX and @pathname.to_s !~ ABSOLUTE_WINDOWS
raise(InvalidPattern, "An absolute PathPattern cannot be a relative path.")
end
end
end
end
puppet-3.4.3/lib/puppet/file_system/file18.rb 0000644 0052762 0001160 00000000200 12300765631 020744 0 ustar jenkins jenkins class Puppet::FileSystem::File18 < Puppet::FileSystem::File
def binread
::File.open(@path, 'rb') { |f| f.read }
end
end
puppet-3.4.3/lib/puppet/file_system/file19.rb 0000644 0052762 0001160 00000000146 12300765631 020756 0 ustar jenkins jenkins class Puppet::FileSystem::File19 < Puppet::FileSystem::File
def binread
@path.binread
end
end
puppet-3.4.3/lib/puppet/file_system/memory_file.rb 0000644 0052762 0001160 00000001430 12300765631 022171 0 ustar jenkins jenkins # An in-memory file abstraction. Commonly used with Puppet::FileSystem::File#overlay
# @api private
class Puppet::FileSystem::MemoryFile
attr_reader :path
def self.a_missing_file(path)
new(path, :exist? => false, :executable? => false)
end
def self.a_regular_file_containing(path, content)
new(path, :exist? => true, :executable? => false, :content => content)
end
def self.an_executable(path)
new(path, :exist? => true, :executable? => true)
end
def initialize(path, options)
@path = Pathname.new(path)
@exist = options[:exist?]
@executable = options[:executable?]
@content = options[:content]
end
def exist?; @exist; end
def executable?; @executable; end
def each_line(&block)
StringIO.new(@content).each_line(&block)
end
end
puppet-3.4.3/lib/puppet/file_system/file.rb 0000644 0052762 0001160 00000017066 12300765631 020615 0 ustar jenkins jenkins # An abstraction over the ruby file system operations for a single file.
#
# For the time being this is being kept private so that we can evolve it for a
# while.
#
# @api private
class Puppet::FileSystem::File
attr_reader :path
IMPL = if RUBY_VERSION =~ /^1\.8/
require 'puppet/file_system/file18'
Puppet::FileSystem::File18
elsif Puppet::Util::Platform.windows?
require 'puppet/file_system/file19windows'
Puppet::FileSystem::File19Windows
else
require 'puppet/file_system/file19'
Puppet::FileSystem::File19
end
@remembered = {}
def self.new(path)
if @remembered.include?(path.to_s)
@remembered[path.to_s]
else
file = IMPL.allocate
file.send(:initialize, path)
file
end
end
# Run a block of code with a file accessible in the filesystem.
# @note This API should only be used for testing
#
# @param file [Object] an object that conforms to the Puppet::FileSystem::File interface
# @api private
def self.overlay(file, &block)
remember(file)
yield
ensure
forget(file)
end
# Create a binding between a filename and a particular instance of a file object.
# @note This API should only be used for testing
#
# @param file [Object] an object that conforms to the Puppet::FileSystem::File interface
# @api private
def self.remember(file)
@remembered[file.path.to_s] = file
end
# Forget a remembered file
# @note This API should only be used for testing
#
# @param file [Object] an object that conforms to the Puppet::FileSystem::File interface
# @api private
def self.forget(file)
@remembered.delete(file.path.to_s)
end
def initialize(path)
if path.is_a?(Pathname)
@path = path
else
@path = Pathname.new(path)
end
end
def open(mode, options, &block)
::File.open(@path, options, mode, &block)
end
# @return [Puppet::FileSystem::File] The directory of this file
# @api public
def dir
Puppet::FileSystem::File.new(@path.dirname)
end
# @return [String] the name of the file
# @api public
def basename
@path.basename.to_s
end
# @return [Num] The size of this file
# @api public
def size
@path.size
end
# Allows exclusive updates to a file to be made by excluding concurrent
# access using flock. This means that if the file is on a filesystem that
# does not support flock, this method will provide no protection.
#
# While polling to aquire the lock the process will wait ever increasing
# amounts of time in order to prevent multiple processes from wasting
# resources.
#
# @param mode [Integer] The mode to apply to the file if it is created
# @param options [Integer] Extra file operation mode information to use
# (defaults to read-only mode)
# @param timeout [Integer] Number of seconds to wait for the lock (defaults to 300)
# @yield The file handle, in read-write mode
# @return [Void]
# @raise [Timeout::Error] If the timeout is exceeded while waiting to aquire the lock
# @api public
def exclusive_open(mode, options = 'r', timeout = 300, &block)
wait = 0.001 + (Kernel.rand / 1000)
written = false
while !written
::File.open(@path, options, mode) do |rf|
if rf.flock(::File::LOCK_EX|::File::LOCK_NB)
yield rf
written = true
else
sleep wait
timeout -= wait
wait *= 2
if timeout < 0
raise Timeout::Error, "Timeout waiting for exclusive lock on #{@path}"
end
end
end
end
end
def each_line(&block)
::File.open(@path) do |f|
f.each_line do |line|
yield line
end
end
end
# @return [String] The contents of the file
def read
@path.read
end
# @return [String] The binary contents of the file
def binread
raise NotImplementedError
end
# Determine if a file exists by verifying that the file can be stat'd.
# Will follow symlinks and verify that the actual target path exists.
#
# @return [Boolean] true if the named file exists.
def self.exist?(path)
return IMPL.exist?(path) if IMPL.method(:exist?) != self.method(:exist?)
File.exist?(path)
end
# Determine if a file exists by verifying that the file can be stat'd.
# Will follow symlinks and verify that the actual target path exists.
#
# @return [Boolean] true if the path of this file is present
def exist?
self.class.exist?(@path)
end
# Determine if a file is executable.
#
# @todo Should this take into account extensions on the windows platform?
#
# @return [Boolean] true if this file can be executed
def executable?
::File.executable?(@path)
end
# @return [Boolean] Whether the file is writable by the current
# process
def writable?
@path.writable?
end
# Touches the file. On most systems this updates the mtime of the file.
def touch
::FileUtils.touch(@path)
end
# Create the entire path as directories
def mkpath
@path.mkpath
end
# Creates a symbolic link dest which points to the current file.
# If dest already exists:
#
# * and is a file, will raise Errno::EEXIST
# * and is a directory, will return 0 but perform no action
# * and is a symlink referencing a file, will raise Errno::EEXIST
# * and is a symlink referencing a directory, will return 0 but perform no action
#
# With the :force option set to true, when dest already exists:
#
# * and is a file, will replace the existing file with a symlink (DANGEROUS)
# * and is a directory, will return 0 but perform no action
# * and is a symlink referencing a file, will modify the existing symlink
# * and is a symlink referencing a directory, will return 0 but perform no action
#
# @param dest [String] The path to create the new symlink at
# @param [Hash] options the options to create the symlink with
# @option options [Boolean] :force overwrite dest
# @option options [Boolean] :noop do not perform the operation
# @option options [Boolean] :verbose verbose output
#
# @raise [Errno::EEXIST] dest already exists as a file and, :force is not set
#
# @return [Integer] 0
def symlink(dest, options = {})
FileUtils.symlink(@path, dest, options)
end
# @return [Boolean] true if the file is a symbolic link.
def symlink?
File.symlink?(@path)
end
# @return [String] the name of the file referenced by the given link.
def readlink
File.readlink(@path)
end
# Deletes the named files, returning the number of names passed as arguments.
# See also Dir::rmdir.
#
# @raise an exception on any error.
#
# @return [Integer] the number of names passed as arguments
def self.unlink(*file_names)
return IMPL.unlink(*file_names) if IMPL.method(:unlink) != self.method(:unlink)
File.unlink(*file_names)
end
# Deletes the file.
# See also Dir::rmdir.
#
# @raise an exception on any error.
#
# @return [Integer] the number of names passed as arguments, in this case 1
def unlink
self.class.unlink(@path)
end
# @return [File::Stat] object for the named file.
def stat
File.stat(@path)
end
# @return [File::Stat] Same as stat, but does not follow the last symbolic
# link. Instead, reports on the link itself.
def lstat
File.lstat(@path)
end
# Compare the contents of this file against the contents of a stream.
# @param stream [IO] The stream to compare the contents against
# @return [Boolean] Whether the contents were the same
def compare_stream(stream)
open(0, 'rb') do |this|
FileUtils.compare_stream(this, stream)
end
end
def to_s
@path.to_s
end
end
puppet-3.4.3/lib/puppet/file_system/file19windows.rb 0000644 0052762 0001160 00000006005 12300765631 022371 0 ustar jenkins jenkins require 'puppet/file_system/file19'
require 'puppet/util/windows'
class Puppet::FileSystem::File19Windows < Puppet::FileSystem::File19
def self.exist?(path)
if ! Puppet.features.manages_symlinks?
return ::File.exist?(path)
end
path = path.to_str if path.respond_to?(:to_str) # support WatchedFile
path = path.to_s # support String and Pathname
begin
if Puppet::Util::Windows::File.symlink?(path)
path = Puppet::Util::Windows::File.readlink(path)
end
! Puppet::Util::Windows::File.stat(path).nil?
rescue # generally INVALID_HANDLE_VALUE which means 'file not found'
false
end
end
def exist?
self.class.exist?(@path)
end
def symlink(dest, options = {})
raise_if_symlinks_unsupported
dest_exists = self.class.exist?(dest) # returns false on dangling symlink
dest_stat = Puppet::Util::Windows::File.stat(dest) if dest_exists
dest_symlink = Puppet::Util::Windows::File.symlink?(dest)
# silent fail to preserve semantics of original FileUtils
return 0 if dest_exists && dest_stat.ftype == 'directory'
if dest_exists && dest_stat.ftype == 'file' && options[:force] != true
raise(Errno::EEXIST, "#{dest} already exists and the :force option was not specified")
end
if options[:noop] != true
::File.delete(dest) if dest_exists # can only be file
Puppet::Util::Windows::File.symlink(@path, dest)
end
0
end
def symlink?
return false if ! Puppet.features.manages_symlinks?
Puppet::Util::Windows::File.symlink?(@path)
end
def readlink
raise_if_symlinks_unsupported
Puppet::Util::Windows::File.readlink(@path)
end
def self.unlink(*file_names)
if ! Puppet.features.manages_symlinks?
return ::File.unlink(*file_names)
end
file_names.each do |file_name|
file_name = file_name.to_s # handle PathName
stat = Puppet::Util::Windows::File.stat(file_name) rescue nil
# sigh, Ruby + Windows :(
if stat && stat.ftype == 'directory'
if Puppet::Util::Windows::File.symlink?(file_name)
Dir.rmdir(file_name)
else
raise Errno::EPERM.new(file_name)
end
else
::File.unlink(file_name)
end
end
file_names.length
end
def unlink
self.class.unlink(@path)
end
def stat
if ! Puppet.features.manages_symlinks?
return super
end
Puppet::Util::Windows::File.stat(@path)
end
def lstat
if ! Puppet.features.manages_symlinks?
return Puppet::Util::Windows::File.stat(@path)
end
Puppet::Util::Windows::File.lstat(@path)
end
private
def raise_if_symlinks_unsupported
if ! Puppet.features.manages_symlinks?
msg = "This version of Windows does not support symlinks. Windows Vista / 2008 or higher is required."
raise Puppet::Util::Windows::Error.new(msg)
end
if ! Puppet::Util::Windows::Process.process_privilege_symlink?
Puppet.warning "The current user does not have the necessary permission to manage symlinks."
end
end
end
puppet-3.4.3/lib/puppet/file_system/tempfile.rb 0000644 0052762 0001160 00000000720 12300765631 021470 0 ustar jenkins jenkins require 'tempfile'
class Puppet::FileSystem::Tempfile
# Variation of Tempfile.open which ensures that the tempfile is closed and
# unlinked before returning
#
# @param identifier [String] additional part of generated pathname
# @yieldparam file [File] the temporary file object
# @return result of the passed block
# @api private
def self.open(identifier)
file = ::Tempfile.new(identifier)
yield file
ensure
file.close!
end
end
puppet-3.4.3/lib/puppet/version.rb 0000644 0052762 0001160 00000007040 12300765631 017027 0 ustar jenkins jenkins # The version method and constant are isolated in puppet/version.rb so that a
# simple `require 'puppet/version'` allows a rubygems gemspec or bundler
# Gemfile to get the Puppet version of the gem install.
#
# The version is programatically settable because we want to allow the
# Raketasks and such to set the version based on the output of `git describe`
module Puppet
PUPPETVERSION = '3.4.3'
##
# version is a public API method intended to always provide a fast and
# lightweight way to determine the version of Puppet.
#
# The intent is that software external to Puppet be able to determine the
# Puppet version with no side-effects. The expected use is:
#
# require 'puppet/version'
# version = Puppet.version
#
# This function has the following ordering precedence. This precedence list
# is designed to facilitate automated packaging tasks by simply writing to
# the VERSION file in the same directory as this source file.
#
# 1. If a version has been explicitly assigned using the Puppet.version=
# method, return that version.
# 2. If there is a VERSION file, read the contents, trim any
# trailing whitespace, and return that version string.
# 3. Return the value of the Puppet::PUPPETVERSION constant hard-coded into
# the source code.
#
# If there is no VERSION file, the method must return the version string of
# the nearest parent version that is an officially released version. That is
# to say, if a branch named 3.1.x contains 25 patches on top of the most
# recent official release of 3.1.1, then the version method must return the
# string "3.1.1" if no "VERSION" file is present.
#
# By design the version identifier is _not_ intended to vary during the life
# a process. There is no guarantee provided that writing to the VERSION file
# while a Puppet process is running will cause the version string to be
# updated. On the contrary, the contents of the VERSION are cached to reduce
# filesystem accesses.
#
# The VERSION file is intended to be used by package maintainers who may be
# applying patches or otherwise changing the software version in a manner
# that warrants a different software version identifier. The VERSION file is
# intended to be managed and owned by the release process and packaging
# related tasks, and as such should not reside in version control. The
# PUPPETVERSION constant is intended to be version controlled in history.
#
# Ideally, this behavior will allow package maintainers to precisely specify
# the version of the software they're packaging as in the following example:
#
# $ git describe --match "3.0.*" > lib/puppet/VERSION
# $ ruby -r puppet -e 'puts Puppet.version'
# 3.0.1-260-g9ca4e54
#
# @api public
#
# @return [String] containing the puppet version, e.g. "3.0.1"
def self.version
version_file = File.join(File.dirname(__FILE__), 'VERSION')
return @puppet_version if @puppet_version
if version = read_version_file(version_file)
@puppet_version = version
end
@puppet_version ||= PUPPETVERSION
end
def self.version=(version)
@puppet_version = version
end
##
# read_version_file reads the content of the "VERSION" file that lives in the
# same directory as this source code file.
#
# @api private
#
# @return [String] for example: "1.6.14-6-gea42046" or nil if the VERSION
# file does not exist.
def self.read_version_file(path)
if File.exist?(path)
File.read(path).chomp
end
end
private_class_method :read_version_file
end
puppet-3.4.3/lib/puppet/confine.rb 0000644 0052762 0001160 00000003034 12300765631 016762 0 ustar jenkins jenkins # The class that handles testing whether our providers
# actually work or not.
require 'puppet/util'
class Puppet::Confine
include Puppet::Util
@tests = {}
class << self
attr_accessor :name
end
def self.inherited(klass)
name = klass.to_s.split("::").pop.downcase.to_sym
raise "Test #{name} is already defined" if @tests.include?(name)
klass.name = name
@tests[name] = klass
end
def self.test(name)
unless @tests[name]
begin
require "puppet/confine/#{name}"
rescue LoadError => detail
unless detail.to_s =~ /No such file|cannot load such file/i
warn "Could not load confine test '#{name}': #{detail}"
end
# Could not find file
end
end
@tests[name]
end
attr_reader :values
# Mark that this confine is used for testing binary existence.
attr_accessor :for_binary
def for_binary?
for_binary
end
# Used for logging.
attr_accessor :label
def initialize(values)
values = [values] unless values.is_a?(Array)
@values = values
end
# Provide a hook for the message when there's a failure.
def message(value)
""
end
# Collect the results of all of them.
def result
values.collect { |value| pass?(value) }
end
# Test whether our confine matches.
def valid?
values.each do |value|
unless pass?(value)
Puppet.debug(label + ": " + message(value))
return false
end
end
return true
ensure
reset
end
# Provide a hook for subclasses.
def reset
end
end
puppet-3.4.3/lib/puppet/vendor/ 0000755 0052762 0001160 00000000000 12300765640 016311 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/vendor/load_safe_yaml.rb 0000644 0052762 0001160 00000000073 12300765631 021575 0 ustar jenkins jenkins $: << File.join([File.dirname(__FILE__), "safe_yaml/lib"])
puppet-3.4.3/lib/puppet/vendor/safe_yaml_patches.rb 0000644 0052762 0001160 00000000177 12300765631 022312 0 ustar jenkins jenkins module SafeYAML
class Parse
class Date
def self.value(value)
Time.parse(value)
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/ 0000755 0052762 0001160 00000000000 12300765640 020251 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/ 0000755 0052762 0001160 00000000000 12300765640 021017 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml.rb 0000644 0052762 0001160 00000017040 12300765631 023306 0 ustar jenkins jenkins require "yaml"
# This needs to be defined up front in case any internal classes need to base
# their behavior off of this.
module SafeYAML
YAML_ENGINE = defined?(YAML::ENGINE) ? YAML::ENGINE.yamler : "syck"
end
require "set"
require "safe_yaml/deep"
require "safe_yaml/parse/hexadecimal"
require "safe_yaml/parse/sexagesimal"
require "safe_yaml/parse/date"
require "safe_yaml/transform/transformation_map"
require "safe_yaml/transform/to_boolean"
require "safe_yaml/transform/to_date"
require "safe_yaml/transform/to_float"
require "safe_yaml/transform/to_integer"
require "safe_yaml/transform/to_nil"
require "safe_yaml/transform/to_symbol"
require "safe_yaml/transform"
require "safe_yaml/resolver"
require "safe_yaml/syck_hack" if defined?(JRUBY_VERSION)
module SafeYAML
MULTI_ARGUMENT_YAML_LOAD = YAML.method(:load).arity != 1
DEFAULT_OPTIONS = Deep.freeze({
:default_mode => nil,
:suppress_warnings => false,
:deserialize_symbols => false,
:whitelisted_tags => [],
:custom_initializers => {},
:raise_on_unknown_tag => false
})
OPTIONS = Deep.copy(DEFAULT_OPTIONS)
module_function
def restore_defaults!
OPTIONS.clear.merge!(Deep.copy(DEFAULT_OPTIONS))
end
def tag_safety_check!(tag, options)
return if tag.nil? || tag == "!"
if options[:raise_on_unknown_tag] && !options[:whitelisted_tags].include?(tag) && !tag_is_explicitly_trusted?(tag)
raise "Unknown YAML tag '#{tag}'"
end
end
def whitelist!(*classes)
classes.each do |klass|
whitelist_class!(klass)
end
end
def whitelist_class!(klass)
raise "#{klass} not a Class" unless klass.is_a?(::Class)
klass_name = klass.name
raise "#{klass} cannot be anonymous" if klass_name.nil? || klass_name.empty?
# Whitelist any built-in YAML tags supplied by Syck or Psych.
predefined_tag = predefined_tags[klass]
if predefined_tag
OPTIONS[:whitelisted_tags] << predefined_tag
return
end
# Exception is exceptional (har har).
tag_class = klass < Exception ? "exception" : "object"
tag_prefix = case YAML_ENGINE
when "psych" then "!ruby/#{tag_class}"
when "syck" then "tag:ruby.yaml.org,2002:#{tag_class}"
else raise "unknown YAML_ENGINE #{YAML_ENGINE}"
end
OPTIONS[:whitelisted_tags] << "#{tag_prefix}:#{klass_name}"
end
def predefined_tags
if @predefined_tags.nil?
@predefined_tags = {}
if YAML_ENGINE == "syck"
YAML.tagged_classes.each do |tag, klass|
@predefined_tags[klass] = tag
end
else
# Special tags appear to be hard-coded in Psych:
# https://github.com/tenderlove/psych/blob/v1.3.4/lib/psych/visitors/to_ruby.rb
# Fortunately, there aren't many that SafeYAML doesn't already support.
@predefined_tags.merge!({
Exception => "!ruby/exception",
Range => "!ruby/range",
Regexp => "!ruby/regexp",
})
end
end
@predefined_tags
end
if YAML_ENGINE == "psych"
def tag_is_explicitly_trusted?(tag)
false
end
else
TRUSTED_TAGS = Set.new([
"tag:yaml.org,2002:binary",
"tag:yaml.org,2002:bool#no",
"tag:yaml.org,2002:bool#yes",
"tag:yaml.org,2002:float",
"tag:yaml.org,2002:float#fix",
"tag:yaml.org,2002:int",
"tag:yaml.org,2002:map",
"tag:yaml.org,2002:null",
"tag:yaml.org,2002:seq",
"tag:yaml.org,2002:str",
"tag:yaml.org,2002:timestamp",
"tag:yaml.org,2002:timestamp#ymd"
]).freeze
def tag_is_explicitly_trusted?(tag)
TRUSTED_TAGS.include?(tag)
end
end
end
module YAML
def self.load_with_options(yaml, *original_arguments)
filename, options = filename_and_options_from_arguments(original_arguments)
safe_mode = safe_mode_from_options("load", options)
arguments = [yaml]
if safe_mode == :safe
arguments << filename if SafeYAML::YAML_ENGINE == "psych"
arguments << options_for_safe_load(options)
safe_load(*arguments)
else
arguments << filename if SafeYAML::MULTI_ARGUMENT_YAML_LOAD
unsafe_load(*arguments)
end
end
def self.load_file_with_options(file, options={})
safe_mode = safe_mode_from_options("load_file", options)
if safe_mode == :safe
safe_load_file(file, options_for_safe_load(options))
else
unsafe_load_file(file)
end
end
if SafeYAML::YAML_ENGINE == "psych"
require "safe_yaml/psych_handler"
require "safe_yaml/psych_resolver"
require "safe_yaml/safe_to_ruby_visitor"
def self.safe_load(yaml, filename=nil, options={})
# If the user hasn't whitelisted any tags, we can go with this implementation which is
# significantly faster.
if (options && options[:whitelisted_tags] || SafeYAML::OPTIONS[:whitelisted_tags]).empty?
safe_handler = SafeYAML::PsychHandler.new(options)
arguments_for_parse = [yaml]
arguments_for_parse << filename if SafeYAML::MULTI_ARGUMENT_YAML_LOAD
Psych::Parser.new(safe_handler).parse(*arguments_for_parse)
return safe_handler.result || false
else
safe_resolver = SafeYAML::PsychResolver.new(options)
tree = SafeYAML::MULTI_ARGUMENT_YAML_LOAD ?
Psych.parse(yaml, filename) :
Psych.parse(yaml)
return safe_resolver.resolve_node(tree)
end
end
def self.safe_load_file(filename, options={})
File.open(filename, 'r:bom|utf-8') { |f| self.safe_load(f, filename, options) }
end
def self.unsafe_load_file(filename)
if SafeYAML::MULTI_ARGUMENT_YAML_LOAD
# https://github.com/tenderlove/psych/blob/v1.3.2/lib/psych.rb#L296-298
File.open(filename, 'r:bom|utf-8') { |f| self.unsafe_load(f, filename) }
else
# https://github.com/tenderlove/psych/blob/v1.2.2/lib/psych.rb#L231-233
self.unsafe_load File.open(filename)
end
end
else
require "safe_yaml/syck_resolver"
require "safe_yaml/syck_node_monkeypatch"
def self.safe_load(yaml, options={})
resolver = SafeYAML::SyckResolver.new(SafeYAML::OPTIONS.merge(options || {}))
tree = YAML.parse(yaml)
return resolver.resolve_node(tree)
end
def self.safe_load_file(filename, options={})
File.open(filename) { |f| self.safe_load(f, options) }
end
def self.unsafe_load_file(filename)
# https://github.com/indeyets/syck/blob/master/ext/ruby/lib/yaml.rb#L133-135
File.open(filename) { |f| self.unsafe_load(f) }
end
end
class << self
alias_method :unsafe_load, :load
alias_method :load, :load_with_options
alias_method :load_file, :load_file_with_options
private
def filename_and_options_from_arguments(arguments)
if arguments.count == 1
if arguments.first.is_a?(String)
return arguments.first, {}
else
return nil, arguments.first || {}
end
else
return arguments.first, arguments.last || {}
end
end
def safe_mode_from_options(method, options={})
if options[:safe].nil?
safe_mode = SafeYAML::OPTIONS[:default_mode] || :safe
if SafeYAML::OPTIONS[:default_mode].nil? && !SafeYAML::OPTIONS[:suppress_warnings]
Kernel.warn "Called '#{method}' without the :safe option -- defaulting to #{safe_mode} mode."
SafeYAML::OPTIONS[:suppress_warnings] = true
end
return safe_mode
end
options[:safe] ? :safe : :unsafe
end
def options_for_safe_load(base_options)
options = base_options.dup
options.delete(:safe)
options
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/ 0000755 0052762 0001160 00000000000 12300765640 022757 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/transform.rb 0000644 0052762 0001160 00000002111 12300765631 025312 0 ustar jenkins jenkins require 'base64'
module SafeYAML
class Transform
TRANSFORMERS = [
Transform::ToSymbol.new,
Transform::ToInteger.new,
Transform::ToFloat.new,
Transform::ToNil.new,
Transform::ToBoolean.new,
Transform::ToDate.new
]
def self.to_guessed_type(value, quoted=false, options=nil)
return value if quoted
if value.is_a?(String)
TRANSFORMERS.each do |transformer|
success, transformed_value = transformer.method(:transform?).arity == 1 ?
transformer.transform?(value) :
transformer.transform?(value, options)
return transformed_value if success
end
end
value
end
def self.to_proper_type(value, quoted=false, tag=nil, options=nil)
case tag
when "tag:yaml.org,2002:binary", "x-private:binary", "!binary"
decoded = Base64.decode64(value)
decoded = decoded.force_encoding(value.encoding) if decoded.respond_to?(:force_encoding)
decoded
else
self.to_guessed_type(value, quoted, options)
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/psych_resolver.rb 0000644 0052762 0001160 00000002053 12300765631 026353 0 ustar jenkins jenkins module SafeYAML
class PsychResolver < Resolver
NODE_TYPES = {
Psych::Nodes::Document => :root,
Psych::Nodes::Mapping => :map,
Psych::Nodes::Sequence => :seq,
Psych::Nodes::Scalar => :scalar,
Psych::Nodes::Alias => :alias
}.freeze
def initialize(options={})
super
@aliased_nodes = {}
end
def resolve_root(root)
resolve_seq(root).first
end
def resolve_alias(node)
resolve_node(@aliased_nodes[node.anchor])
end
def native_resolve(node)
@visitor ||= SafeYAML::SafeToRubyVisitor.new(self)
@visitor.accept(node)
end
def get_node_type(node)
NODE_TYPES[node.class]
end
def get_node_tag(node)
node.tag
end
def get_node_value(node)
@aliased_nodes[node.anchor] = node if node.respond_to?(:anchor) && node.anchor
case get_node_type(node)
when :root, :map, :seq
node.children
when :scalar
node.value
end
end
def value_is_quoted?(node)
node.quoted
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/syck_hack.rb 0000644 0052762 0001160 00000002157 12300765631 025250 0 ustar jenkins jenkins # Hack to JRuby 1.8's YAML Parser Yecht
#
# This file is always loaded AFTER either syck or psych are already
# loaded. It then looks at what constants are available and creates
# a consistent view on all rubys.
#
# Taken from rubygems and modified.
# See https://github.com/rubygems/rubygems/blob/master/lib/rubygems/syck_hack.rb
module YAML
# In newer 1.9.2, there is a Syck toplevel constant instead of it
# being underneith YAML. If so, reference it back under YAML as
# well.
if defined? ::Syck
# for tests that change YAML::ENGINE
# 1.8 does not support the second argument to const_defined?
remove_const :Syck rescue nil
Syck = ::Syck
# JRuby's "Syck" is called "Yecht"
elsif defined? YAML::Yecht
Syck = YAML::Yecht
end
end
# Sometime in the 1.9 dev cycle, the Syck constant was moved from under YAML
# to be a toplevel constant. So gemspecs created under these versions of Syck
# will have references to Syck::DefaultKey.
#
# So we need to be sure that we reference Syck at the toplevel too so that
# we can always load these kind of gemspecs.
#
if !defined?(Syck)
Syck = YAML::Syck
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/safe_to_ruby_visitor.rb 0000644 0052762 0001160 00000000517 12300765631 027547 0 ustar jenkins jenkins module SafeYAML
class SafeToRubyVisitor < Psych::Visitors::ToRuby
def initialize(resolver)
super()
@resolver = resolver
end
def accept(node)
if node.tag
SafeYAML.tag_safety_check!(node.tag, @resolver.options)
return super
end
@resolver.resolve_node(node)
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/version.rb 0000644 0052762 0001160 00000000050 12300765631 024764 0 ustar jenkins jenkins module SafeYAML
VERSION = "0.9.2"
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/syck_node_monkeypatch.rb 0000644 0052762 0001160 00000003026 12300765631 027665 0 ustar jenkins jenkins # This is, admittedly, pretty insane. Fundamentally the challenge here is this: if we want to allow
# whitelisting of tags (while still leveraging Syck's internal functionality), then we have to
# change how Syck::Node#transform works. But since we (SafeYAML) do not control instantiation of
# Syck::Node objects, we cannot, for example, subclass Syck::Node and override #tranform the "easy"
# way. So the only choice is to monkeypatch, like this. And the only way to make this work
# recursively with potentially call-specific options (that my feeble brain can think of) is to set
# pseudo-global options on the first call and unset them once the recursive stack has fully unwound.
monkeypatch = <<-EORUBY
class Node
@@safe_transform_depth = 0
@@safe_transform_whitelist = nil
def safe_transform(options={})
begin
@@safe_transform_depth += 1
@@safe_transform_whitelist ||= options[:whitelisted_tags]
if self.type_id
SafeYAML.tag_safety_check!(self.type_id, options)
return unsafe_transform if @@safe_transform_whitelist.include?(self.type_id)
end
SafeYAML::SyckResolver.new.resolve_node(self)
ensure
@@safe_transform_depth -= 1
if @@safe_transform_depth == 0
@@safe_transform_whitelist = nil
end
end
end
alias_method :unsafe_transform, :transform
alias_method :transform, :safe_transform
end
EORUBY
if defined?(YAML::Syck::Node)
YAML::Syck.module_eval monkeypatch
else
Syck.module_eval monkeypatch
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/psych_handler.rb 0000644 0052762 0001160 00000004160 12300765631 026130 0 ustar jenkins jenkins require "psych"
require "base64"
module SafeYAML
class PsychHandler < Psych::Handler
def initialize(options)
@options = SafeYAML::OPTIONS.merge(options || {})
@initializers = @options[:custom_initializers] || {}
@anchors = {}
@stack = []
@current_key = nil
@result = nil
end
def result
@result
end
def add_to_current_structure(value, anchor=nil, quoted=nil, tag=nil)
value = Transform.to_proper_type(value, quoted, tag, @options)
@anchors[anchor] = value if anchor
if @result.nil?
@result = value
@current_structure = @result
return
end
if @current_structure.respond_to?(:<<)
@current_structure << value
elsif @current_structure.respond_to?(:[]=)
if @current_key.nil?
@current_key = value
else
if @current_key == "<<"
@current_structure.merge!(value)
else
@current_structure[@current_key] = value
end
@current_key = nil
end
else
raise "Don't know how to add to a #{@current_structure.class}!"
end
end
def end_current_structure
@stack.pop
@current_structure = @stack.last
end
def streaming?
false
end
# event handlers
def alias(anchor)
add_to_current_structure(@anchors[anchor])
end
def scalar(value, anchor, tag, plain, quoted, style)
add_to_current_structure(value, anchor, quoted, tag)
end
def start_mapping(anchor, tag, implicit, style)
map = @initializers.include?(tag) ? @initializers[tag].call : {}
self.add_to_current_structure(map, anchor)
@current_structure = map
@stack.push(map)
end
def end_mapping
self.end_current_structure()
end
def start_sequence(anchor, tag, implicit, style)
seq = @initializers.include?(tag) ? @initializers[tag].call : []
self.add_to_current_structure(seq, anchor)
@current_structure = seq
@stack.push(seq)
end
def end_sequence
self.end_current_structure()
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/deep.rb 0000644 0052762 0001160 00000001233 12300765631 024220 0 ustar jenkins jenkins module SafeYAML
class Deep
def self.freeze(object)
object.each do |*entry|
value = entry.last
case value
when String, Regexp
value.freeze
when Enumerable
Deep.freeze(value)
end
end
return object.freeze
end
def self.copy(object)
duplicate = object.dup rescue object
case object
when Array
(0...duplicate.count).each do |i|
duplicate[i] = Deep.copy(duplicate[i])
end
when Hash
duplicate.keys.each do |key|
duplicate[key] = Deep.copy(duplicate[key])
end
end
duplicate
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/resolver.rb 0000644 0052762 0001160 00000005162 12300765631 025151 0 ustar jenkins jenkins module SafeYAML
class Resolver
def initialize(options)
@options = SafeYAML::OPTIONS.merge(options || {})
@whitelist = @options[:whitelisted_tags] || []
@initializers = @options[:custom_initializers] || {}
@raise_on_unknown_tag = @options[:raise_on_unknown_tag]
end
def resolve_node(node)
return node if !node
return self.native_resolve(node) if tag_is_whitelisted?(self.get_node_tag(node))
case self.get_node_type(node)
when :root
resolve_root(node)
when :map
resolve_map(node)
when :seq
resolve_seq(node)
when :scalar
resolve_scalar(node)
when :alias
resolve_alias(node)
else
raise "Don't know how to resolve this node: #{node.inspect}"
end
end
def resolve_map(node)
tag = get_and_check_node_tag(node)
hash = @initializers.include?(tag) ? @initializers[tag].call : {}
map = normalize_map(self.get_node_value(node))
# Take the "<<" key nodes first, as these are meant to approximate a form of inheritance.
inheritors = map.select { |key_node, value_node| resolve_node(key_node) == "<<" }
inheritors.each do |key_node, value_node|
merge_into_hash(hash, resolve_node(value_node))
end
# All that's left should be normal (non-"<<") nodes.
(map - inheritors).each do |key_node, value_node|
hash[resolve_node(key_node)] = resolve_node(value_node)
end
return hash
end
def resolve_seq(node)
seq = self.get_node_value(node)
tag = get_and_check_node_tag(node)
arr = @initializers.include?(tag) ? @initializers[tag].call : []
seq.inject(arr) { |array, node| array << resolve_node(node) }
end
def resolve_scalar(node)
Transform.to_proper_type(self.get_node_value(node), self.value_is_quoted?(node), get_and_check_node_tag(node), @options)
end
def get_and_check_node_tag(node)
tag = self.get_node_tag(node)
SafeYAML.tag_safety_check!(tag, @options)
tag
end
def tag_is_whitelisted?(tag)
@whitelist.include?(tag)
end
def options
@options
end
private
def normalize_map(map)
# Syck creates Hashes from maps.
if map.is_a?(Hash)
map.inject([]) { |arr, key_and_value| arr << key_and_value }
# Psych is really weird; it flattens out a Hash completely into: [key, value, key, value, ...]
else
map.each_slice(2).to_a
end
end
def merge_into_hash(hash, array)
array.each do |key, value|
hash[key] = value
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/parse/ 0000755 0052762 0001160 00000000000 12300765640 024071 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/parse/sexagesimal.rb 0000644 0052762 0001160 00000001303 12300765631 026715 0 ustar jenkins jenkins module SafeYAML
class Parse
class Sexagesimal
INTEGER_MATCHER = /\A[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+\Z/.freeze
FLOAT_MATCHER = /\A[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+\.[0-9_]*\Z/.freeze
def self.value(value)
before_decimal, after_decimal = value.split(".")
whole_part = 0
multiplier = 1
before_decimal = before_decimal.split(":")
until before_decimal.empty?
whole_part += (Float(before_decimal.pop) * multiplier)
multiplier *= 60
end
result = whole_part
result += Float("." + after_decimal) unless after_decimal.nil?
result *= -1 if value[0] == "-"
result
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/parse/date.rb 0000644 0052762 0001160 00000002175 12300765631 025340 0 ustar jenkins jenkins module SafeYAML
class Parse
class Date
# This one's easy enough :)
DATE_MATCHER = /\A(\d{4})-(\d{2})-(\d{2})\Z/.freeze
# This unbelievable little gem is taken basically straight from the YAML spec, but made
# slightly more readable (to my poor eyes at least) to me:
# http://yaml.org/type/timestamp.html
TIME_MATCHER = /\A\d{4}-\d{1,2}-\d{1,2}(?:[Tt]|\s+)\d{1,2}:\d{2}:\d{2}(?:\.\d*)?\s*(?:Z|[-+]\d{1,2}(?::?\d{2})?)?\Z/.freeze
SECONDS_PER_DAY = 60 * 60 * 24
MICROSECONDS_PER_SECOND = 1000000
# So this is weird. In Ruby 1.8.7, the DateTime#sec_fraction method returned fractional
# seconds in units of DAYS for some reason. In 1.9.2, they changed the units -- much more
# reasonably -- to seconds.
SEC_FRACTION_MULTIPLIER = RUBY_VERSION == "1.8.7" ? (SECONDS_PER_DAY * MICROSECONDS_PER_SECOND) : MICROSECONDS_PER_SECOND
def self.value(value)
d = DateTime.parse(value)
usec = d.sec_fraction * SEC_FRACTION_MULTIPLIER
Time.utc(d.year, d.month, d.day, d.hour, d.min, d.sec, usec) - (d.offset * SECONDS_PER_DAY)
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/parse/hexadecimal.rb 0000644 0052762 0001160 00000000416 12300765631 026663 0 ustar jenkins jenkins module SafeYAML
class Parse
class Hexadecimal
MATCHER = /\A[-+]?0x[0-9a-fA-F_]+\Z/.freeze
def self.value(value)
# This is safe to do since we already validated the value.
return Integer(value.gsub(/_/, ""))
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/transform/ 0000755 0052762 0001160 00000000000 12300765640 024772 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/transform/to_nil.rb 0000644 0052762 0001160 00000000557 12300765631 026612 0 ustar jenkins jenkins module SafeYAML
class Transform
class ToNil
include TransformationMap
set_predefined_values({
"" => nil,
"~" => nil,
"null" => nil,
})
def transform?(value)
return false if value.length > 4
return PREDEFINED_VALUES.include?(value), PREDEFINED_VALUES[value]
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/transform/to_date.rb 0000644 0052762 0001160 00000000442 12300765631 026736 0 ustar jenkins jenkins module SafeYAML
class Transform
class ToDate
def transform?(value)
return true, Date.parse(value) if Parse::Date::DATE_MATCHER.match(value)
return true, Parse::Date.value(value) if Parse::Date::TIME_MATCHER.match(value)
false
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/transform/transformation_map.rb 0000644 0052762 0001160 00000002120 12300765631 031215 0 ustar jenkins jenkins module SafeYAML
class Transform
module TransformationMap
def self.included(base)
base.extend(ClassMethods)
end
class CaseAgnosticMap < Hash
def initialize(*args)
super
end
def include?(key)
super(key.downcase)
end
def [](key)
super(key.downcase)
end
# OK, I actually don't think it's all that important that this map be
# frozen.
def freeze
self
end
end
module ClassMethods
def set_predefined_values(predefined_values)
if SafeYAML::YAML_ENGINE == "syck"
expanded_map = predefined_values.inject({}) do |hash, (key, value)|
hash[key] = value
hash[key.capitalize] = value
hash[key.upcase] = value
hash
end
else
expanded_map = CaseAgnosticMap.new
expanded_map.merge!(predefined_values)
end
self.const_set(:PREDEFINED_VALUES, expanded_map.freeze)
end
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/transform/to_boolean.rb 0000644 0052762 0001160 00000000703 12300765631 027440 0 ustar jenkins jenkins module SafeYAML
class Transform
class ToBoolean
include TransformationMap
set_predefined_values({
"yes" => true,
"on" => true,
"true" => true,
"no" => false,
"off" => false,
"false" => false
})
def transform?(value)
return false if value.length > 5
return PREDEFINED_VALUES.include?(value), PREDEFINED_VALUES[value]
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/transform/to_integer.rb 0000644 0052762 0001160 00000001405 12300765631 027456 0 ustar jenkins jenkins module SafeYAML
class Transform
class ToInteger
MATCHERS = Deep.freeze([
/\A[-+]?(0|([1-9][0-9_,]*))\Z/, # decimal
/\A0[0-7]+\Z/, # octal
/\A0x[0-9a-f]+\Z/i, # hexadecimal
/\A0b[01_]+\Z/ # binary
])
def transform?(value)
MATCHERS.each do |matcher|
return true, Integer(value.gsub(",", "")) if matcher.match(value)
end
try_edge_cases?(value)
end
def try_edge_cases?(value)
return true, Parse::Hexadecimal.value(value) if Parse::Hexadecimal::MATCHER.match(value)
return true, Parse::Sexagesimal.value(value) if Parse::Sexagesimal::INTEGER_MATCHER.match(value)
return false
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/transform/to_symbol.rb 0000644 0052762 0001160 00000000472 12300765631 027331 0 ustar jenkins jenkins module SafeYAML
class Transform
class ToSymbol
MATCHER = /\A:"?(\w+)"?\Z/.freeze
def transform?(value, options=nil)
options ||= SafeYAML::OPTIONS
return false unless options[:deserialize_symbols] && MATCHER.match(value)
return true, $1.to_sym
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/transform/to_float.rb 0000644 0052762 0001160 00000001542 12300765631 027130 0 ustar jenkins jenkins module SafeYAML
class Transform
class ToFloat
Infinity = 1.0 / 0.0
NaN = 0.0 / 0.0
PREDEFINED_VALUES = {
".inf" => Infinity,
".Inf" => Infinity,
".INF" => Infinity,
"-.inf" => -Infinity,
"-.Inf" => -Infinity,
"-.INF" => -Infinity,
".nan" => NaN,
".NaN" => NaN,
".NAN" => NaN,
}.freeze
MATCHER = /\A[-+]?(?:\d[\d_]*)?\.[\d_]+(?:[eE][-+][\d]+)?\Z/.freeze
def transform?(value)
return true, Float(value) if MATCHER.match(value)
try_edge_cases?(value)
end
def try_edge_cases?(value)
return true, PREDEFINED_VALUES[value] if PREDEFINED_VALUES.include?(value)
return true, Parse::Sexagesimal.value(value) if Parse::Sexagesimal::FLOAT_MATCHER.match(value)
return false
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/lib/safe_yaml/syck_resolver.rb 0000644 0052762 0001160 00000001172 12300765631 026177 0 ustar jenkins jenkins module SafeYAML
class SyckResolver < Resolver
QUOTE_STYLES = [
:quote1,
:quote2
].freeze
NODE_TYPES = {
Hash => :map,
Array => :seq,
String => :scalar
}.freeze
def initialize(options={})
super
end
def native_resolve(node)
node.transform(self.options)
end
def get_node_type(node)
NODE_TYPES[node.value.class]
end
def get_node_tag(node)
node.type_id
end
def get_node_value(node)
node.value
end
def value_is_quoted?(node)
QUOTE_STYLES.include?(node.instance_variable_get(:@style))
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/Rakefile 0000644 0052762 0001160 00000000172 12300765631 021716 0 ustar jenkins jenkins require "rspec/core/rake_task"
desc "Run specs"
RSpec::Core::RakeTask.new(:spec) do |t|
t.rspec_opts = %w(--color)
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/run_specs_all_ruby_versions.sh 0000755 0052762 0001160 00000000536 12300765631 026436 0 ustar jenkins jenkins #!/bin/bash
[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm"
rvm use 1.8.7@safe_yaml
rake spec
rvm use 1.9.2@safe_yaml
YAMLER=syck rake spec
rvm use 1.9.3@safe_yaml
YAMLER=syck rake spec
rvm use 1.9.2@safe_yaml
YAMLER=psych rake spec
rvm use 1.9.3@safe_yaml
YAMLER=psych rake spec
rvm use 2.0.0@safe_yaml
YAMLER=psych rake spec
puppet-3.4.3/lib/puppet/vendor/safe_yaml/safe_yaml.gemspec 0000644 0052762 0001160 00000001433 12300765631 023557 0 ustar jenkins jenkins # -*- encoding: utf-8 -*-
require File.join(File.dirname(__FILE__), "lib", "safe_yaml", "version")
Gem::Specification.new do |gem|
gem.name = "safe_yaml"
gem.version = SafeYAML::VERSION
gem.authors = "Dan Tao"
gem.email = "daniel.tao@gmail.com"
gem.description = %q{Parse YAML safely, without that pesky arbitrary object deserialization vulnerability}
gem.summary = %q{SameYAML provides an alternative implementation of YAML.load suitable for accepting user input in Ruby applications.}
gem.homepage = "http://dtao.github.com/safe_yaml/"
gem.license = "MIT"
gem.files = `git ls-files`.split($\)
gem.test_files = gem.files.grep(%r{^spec/})
gem.require_paths = ["lib"]
gem.required_ruby_version = ">= 1.8.7"
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/README.md 0000644 0052762 0001160 00000023075 12300765631 021537 0 ustar jenkins jenkins SafeYAML
========
[](http://travis-ci.org/dtao/safe_yaml)
The **SafeYAML** gem provides an alternative implementation of `YAML.load` suitable for accepting user input in Ruby applications. Unlike Ruby's built-in implementation of `YAML.load`, SafeYAML's version will not expose apps to arbitrary code execution exploits (such as [the ones discovered](http://www.reddit.com/r/netsec/comments/167c11/serious_vulnerability_in_ruby_on_rails_allowing/) [in Rails in early 2013](http://www.h-online.com/open/news/item/Rails-developers-close-another-extremely-critical-flaw-1793511.html)).
**If you encounter any issues with SafeYAML, check out the 'Common Issues' section below.** If you don't see anything that addresses the problem you're experiencing, by all means, [create an issue](https://github.com/dtao/safe_yaml/issues/new)!
Installation
------------
Add this line to your application's Gemfile:
gem "safe_yaml"
And then execute:
$ bundle
Or install it yourself as:
$ gem install safe_yaml
Configuration
-------------
Configuring SafeYAML should be quick. In most cases, you will probably only have to think about two things:
1. What do you want the `YAML` module's *default* behavior to be? Set the `SafeYAML::OPTIONS[:default_mode]` option to either `:safe` or `:unsafe` to control this. If you do neither, SafeYAML will default to `:safe` mode but will issue a warning the first time you call `YAML.load`.
2. Do you want to allow symbols by default? Set the `SafeYAML::OPTIONS[:deserialize_symbols]` option to `true` or `false` to control this. The default is `false`, which means that SafeYAML will deserialize symbols in YAML documents as strings.
For more information on these and other options, see the "Usage" section down below.
Explanation
-----------
Suppose your application were to use a popular open source library which contained code like this:
```ruby
class ClassBuilder
def []=(key, value)
@class ||= Class.new
@class.class_eval <<-EOS
def #{key}
#{value}
end
EOS
end
def create
@class.new
end
end
```
Now, if you were to use `YAML.load` on user input anywhere in your application without the SafeYAML gem installed, an attacker who suspected you were using this library could send a request with a carefully-crafted YAML string to execute arbitrary code (yes, including `system("unix command")`) on your servers.
This simple example demonstrates the vulnerability:
```ruby
yaml = <<-EOYAML
--- !ruby/hash:ClassBuilder
"foo; end; puts %(I'm in yr system!); def bar": "baz"
EOYAML
```
> YAML.load(yaml)
I'm in yr system!
=> #>
With SafeYAML, the same attacker would be thwarted:
> require "safe_yaml"
=> true
> YAML.load(yaml, :safe => true)
=> {"foo; end; puts %(I'm in yr system!); def bar"=>"baz"}
Usage
-----
When you require the safe_yaml gem in your project, `YAML.load` is patched to accept one additional (optional) `options` parameter. This changes the method signature as follows:
- for Syck and Psych prior to Ruby 1.9.3: `YAML.load(yaml, options={})`
- for Psych in 1.9.3 and later: `YAML.load(yaml, filename=nil, options={})`
The most important option is the `:safe` option (default: `true`), which controls whether or not to deserialize arbitrary objects when parsing a YAML document. The other options, along with explanations, are as follows.
- `:deserialize_symbols` (default: `false`): Controls whether or not YAML will deserialize symbols. It is probably best to only enable this option where necessary, e.g. to make trusted libraries work. Symbols receive special treatment in Ruby and are not garbage collected, which means deserializing them indiscriminately may render your site vulnerable to a DOS attack (hence `false` as a default value).
- `:whitelisted_tags`: Accepts an array of YAML tags that designate trusted types, e.g., ones that can be deserialized without worrying about any resulting security vulnerabilities. When any of the given tags are encountered in a YAML document, the associated data will be parsed by the underlying YAML engine (Syck or Psych) for the version of Ruby you are using. See the "Whitelisting Trusted Types" section below for more information.
- `:custom_initializers`: Similar to the `:whitelisted_tags` option, but allows you to provide your own initializers for specified tags rather than using Syck or Psyck. Accepts a hash with string tags for keys and lambdas for values.
- `:raise_on_unknown_tag` (default: `false`): Represents the highest possible level of paranoia (not necessarily a bad thing); if the YAML engine encounters any tag other than ones that are automatically trusted by SafeYAML or that you've explicitly whitelisted, it will raise an exception. This may be a good choice if you expect to always be dealing with perfectly safe YAML and want your application to fail loudly upon encountering questionable data.
All of the above options can be set at the global level via `SafeYAML::OPTIONS`. You can also set each one individually per call to `YAML.load`; an option explicitly passed to `load` will take precedence over an option specified globally.
Supported Types
---------------
The way that SafeYAML works is by restricting the kinds of objects that can be deserialized via `YAML.load`. More specifically, only the following types of objects can be deserialized by default:
- Hashes
- Arrays
- Strings
- Numbers
- Dates
- Times
- Booleans
- Nils
Again, deserialization of symbols can be enabled globally by setting `SafeYAML::OPTIONS[:deserialize_symbols] = true`, or in a specific call to `YAML.load([some yaml], :deserialize_symbols => true)`.
Whitelisting Trusted Types
--------------------------
SafeYAML supports whitelisting certain YAML tags for trusted types. This is handy when your application uses YAML to serialize and deserialize certain types not listed above, which you know to be free of any deserialization-related vulnerabilities.
The easiest way to whitelist types is by calling `SafeYAML.whitelist!`, which can accept a variable number of safe types, e.g.:
```ruby
SafeYAML.whitelist!(FrobDispenser, GobbleFactory)
```
You can also whitelist YAML *tags* via the `:whitelisted_tags` option:
```ruby
# Using Syck
SafeYAML::OPTIONS[:whitelisted_tags] = ["tag:ruby.yaml.org,2002:object:OpenStruct"]
# Using Psych
SafeYAML::OPTIONS[:whitelisted_tags] = ["!ruby/object:OpenStruct"]
```
And in case you were wondering: no, this feature will *not* allow would-be attackers to embed untrusted types within trusted types:
```ruby
yaml = <<-EOYAML
--- !ruby/object:OpenStruct
table:
:backdoor: !ruby/hash:ClassBuilder
"foo; end; puts %(I'm in yr system!); def bar": "baz"
EOYAML
```
> YAML.safe_load(yaml)
=> #"baz"}>
Known Issues
------------
If you add SafeYAML to your project and start seeing any errors about missing keys, or you notice mysterious strings that look like `":foo"` (i.e., start with a colon), it's likely you're seeing errors from symbols being saved in YAML format. If you are able to modify the offending code, you might want to consider changing your YAML content to use plain vanilla strings instead of symbols. If not, you may need to set the `:deserialize_symbols` option to `true`, either in calls to `YAML.load` or--as a last resort--globally, with `SafeYAML::OPTIONS[:deserialize_symbols]`.
Also be aware that some Ruby libraries, particularly those requiring inter-process communication, leverage YAML's object deserialization functionality and therefore may break or otherwise be impacted by SafeYAML. The following list includes known instances of SafeYAML's interaction with other Ruby gems:
- [**ActiveRecord**](https://github.com/rails/rails/tree/master/activerecord): uses YAML to control serialization of model objects using the `serialize` class method. If you find that accessing serialized properties on your ActiveRecord models is causing errors, chances are you may need to:
1. set the `:deserialize_symbols` option to `true`,
2. whitelist some of the types in your serialized data via `SafeYAML.whitelist!` or the `:whitelisted_tags` option, or
3. both
- [**Guard**](https://github.com/guard/guard): Uses YAML as a serialization format for notifications. The data serialized uses symbolic keys, so setting `SafeYAML::OPTIONS[:deserialize_symbols] = true` is necessary to allow Guard to work.
- [**sidekiq**](https://github.com/mperham/sidekiq): Uses a YAML configiuration file with symbolic keys, so setting `SafeYAML::OPTIONS[:deserialize_symbols] = true` should allow it to work.
The above list will grow over time, as more issues are discovered.
Caveat
------
My intention is to eventually adopt [semantic versioning](http://semver.org/) with this gem, if it ever gets to version 1.0 (i.e., doesn't become obsolete by then). Since it isn't there yet, that means that API may well change from one version to the next. Please keep that in mind if you are using it in your application.
To be clear: my *goal* is for SafeYAML to make it as easy as possible to protect existing applications from object deserialization exploits. Any and all feedback is more than welcome!
Requirements
------------
SafeYAML requires Ruby 1.8.7 or newer and works with both [Syck](http://www.ruby-doc.org/stdlib-1.8.7/libdoc/yaml/rdoc/YAML.html) and [Psych](http://github.com/tenderlove/psych).
If you are using a version of Ruby where Psych is the default YAML engine (e.g., 1.9.3) but you want to use Syck, be sure to set `YAML::ENGINE.yamler = "syck"` **before** requiring the safe_yaml gem.
puppet-3.4.3/lib/puppet/vendor/safe_yaml/LICENSE.txt 0000644 0052762 0001160 00000002050 12300765631 022071 0 ustar jenkins jenkins Copyright (c) 2013 Dan Tao
MIT License
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
puppet-3.4.3/lib/puppet/vendor/safe_yaml/Gemfile 0000644 0052762 0001160 00000000231 12300765631 021540 0 ustar jenkins jenkins source "https://rubygems.org"
gemspec
group :development do
gem "hashie"
gem "heredoc_unindent"
gem "rake"
gem "rspec"
gem "travis-lint"
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/CHANGES.md 0000644 0052762 0001160 00000002505 12300765631 021645 0 ustar jenkins jenkins 0.9.2
-----
- fixed error w/ parsing "!" when whitelisting tags
- fixed parsing of the number 0 (d'oh!)
0.9.1
-----
- added Yecht support (JRuby)
- more bug fixes
0.9.0
-----
- added `whitelist!` method for easily whitelisting tags
- added support for call-specific options
- removed deprecated methods
0.8.6
-----
- fixed bug in float matcher
0.8.5
-----
- performance improvements
- made less verbose by default
- bug fixes
0.8.4
-----
- enhancements to parsing of integers, floats, and dates
- updated built-in whitelist
- more bug fixes
0.8.3
-----
- fixed exception on parsing empty document
- fixed handling of octal & hexadecimal numbers
0.8.2
-----
- bug fixes
0.8.1
-----
- added `:raise_on_unknown_tag` option
- renamed `reset_defaults!` to `restore_defaults!`
0.8
---
- added tag whitelisting
- more API changes
0.7
---
- separated YAML engine support from Ruby version
- added support for binary scalars
- numerous bug fixes and enhancements
0.6
---
- several API changes
- added `SafeYAML::OPTIONS` for specifying default behavior
0.5
---
Added support for dates
0.4
---
- efficiency improvements
- made `YAML.load` use `YAML.safe_load` by default
- made symbol deserialization optional
0.3
---
Added Syck support
0.2
---
Added support for:
- anchors & aliases
- booleans
- nils
0.1
---
Initial release puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/ 0000755 0052762 0001160 00000000000 12300765640 021203 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/resolver_specs.rb 0000644 0052762 0001160 00000014752 12300765631 024577 0 ustar jenkins jenkins module ResolverSpecs
def self.included(base)
base.module_eval do
let(:resolver) { nil }
let(:result) { @result }
def parse(yaml)
tree = YAML.parse(yaml.unindent)
@result = resolver.resolve_node(tree)
end
# Isn't this how I should've been doing it all along?
def parse_and_test(yaml)
parse(yaml)
@result.should == YAML.unsafe_load(yaml)
end
context "by default" do
it "translates maps to hashes" do
parse <<-YAML
potayto: potahto
tomayto: tomahto
YAML
result.should == {
"potayto" => "potahto",
"tomayto" => "tomahto"
}
end
it "translates sequences to arrays" do
parse <<-YAML
- foo
- bar
- baz
YAML
result.should == ["foo", "bar", "baz"]
end
it "translates most values to strings" do
parse "string: value"
result.should == { "string" => "value" }
end
it "does not deserialize symbols" do
parse ":symbol: value"
result.should == { ":symbol" => "value" }
end
it "translates valid integral numbers to integers" do
parse "integer: 1"
result.should == { "integer" => 1 }
end
it "translates valid decimal numbers to floats" do
parse "float: 3.14"
result.should == { "float" => 3.14 }
end
it "translates valid dates" do
parse "date: 2013-01-24"
result.should == { "date" => Date.parse("2013-01-24") }
end
it "translates valid true/false values to booleans" do
parse <<-YAML
- yes
- true
- no
- false
YAML
result.should == [true, true, false, false]
end
it "translates valid nulls to nil" do
parse <<-YAML
-
- ~
- null
YAML
result.should == [nil] * 3
end
it "matches the behavior of the underlying YAML engine w/ respect to capitalization of boolean values" do
parse_and_test <<-YAML
- true
- True
- TRUE
- tRue
- TRue
- False
- FALSE
- fAlse
- FALse
YAML
# using Syck: [true, true, true, "tRue", "TRue", false, false, "fAlse", "FALse"]
# using Psych: all booleans
end
it "matches the behavior of the underlying YAML engine w/ respect to capitalization of nil values" do
parse_and_test <<-YAML
- Null
- NULL
- nUll
- NUll
YAML
# using Syck: [nil, nil, "nUll", "NUll"]
# using Psych: all nils
end
it "translates quoted empty strings to strings (not nil)" do
parse "foo: ''"
result.should == { "foo" => "" }
end
it "correctly reverse-translates strings encoded via #to_yaml" do
parse "5.10".to_yaml
result.should == "5.10"
end
it "does not specially parse any double-quoted strings" do
parse <<-YAML
- "1"
- "3.14"
- "true"
- "false"
- "2013-02-03"
- "2013-02-03 16:27:00 -0600"
YAML
result.should == ["1", "3.14", "true", "false", "2013-02-03", "2013-02-03 16:27:00 -0600"]
end
it "does not specially parse any single-quoted strings" do
parse <<-YAML
- '1'
- '3.14'
- 'true'
- 'false'
- '2013-02-03'
- '2013-02-03 16:27:00 -0600'
YAML
result.should == ["1", "3.14", "true", "false", "2013-02-03", "2013-02-03 16:27:00 -0600"]
end
it "deals just fine with nested maps" do
parse <<-YAML
foo:
bar:
marco: polo
YAML
result.should == { "foo" => { "bar" => { "marco" => "polo" } } }
end
it "deals just fine with nested sequences" do
parse <<-YAML
- foo
-
- bar1
- bar2
-
- baz1
- baz2
YAML
result.should == ["foo", ["bar1", "bar2", ["baz1", "baz2"]]]
end
it "applies the same transformations to keys as to values" do
parse <<-YAML
foo: string
:bar: symbol
1: integer
3.14: float
2013-01-24: date
YAML
result.should == {
"foo" => "string",
":bar" => "symbol",
1 => "integer",
3.14 => "float",
Date.parse("2013-01-24") => "date",
}
end
it "applies the same transformations to elements in sequences as to all values" do
parse <<-YAML
- foo
- :bar
- 1
- 3.14
- 2013-01-24
YAML
result.should == ["foo", ":bar", 1, 3.14, Date.parse("2013-01-24")]
end
end
context "for Ruby version #{RUBY_VERSION}" do
it "translates valid time values" do
parse "time: 2013-01-29 05:58:00 -0800"
result.should == { "time" => Time.utc(2013, 1, 29, 13, 58, 0) }
end
it "applies the same transformation to elements in sequences" do
parse "- 2013-01-29 05:58:00 -0800"
result.should == [Time.utc(2013, 1, 29, 13, 58, 0)]
end
it "applies the same transformation to keys" do
parse "2013-01-29 05:58:00 -0800: time"
result.should == { Time.utc(2013, 1, 29, 13, 58, 0) => "time" }
end
end
context "with symbol deserialization enabled" do
before :each do
SafeYAML::OPTIONS[:deserialize_symbols] = true
end
after :each do
SafeYAML.restore_defaults!
end
it "translates values starting with ':' to symbols" do
parse "symbol: :value"
result.should == { "symbol" => :value }
end
it "applies the same transformation to keys" do
parse ":bar: symbol"
result.should == { :bar => "symbol" }
end
it "applies the same transformation to elements in sequences" do
parse "- :bar"
result.should == [:bar]
end
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/support/ 0000755 0052762 0001160 00000000000 12300765640 022717 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/support/exploitable_back_door.rb 0000644 0052762 0001160 00000001221 12300765631 027553 0 ustar jenkins jenkins class ExploitableBackDoor
def exploited?
@exploited_through_setter || @exploited_through_init_with || @exploited_through_ivars
end
def exploited_through_setter?
@exploited_through_setter
end
def exploited_through_init_with?
@exploited_through_init_with
end
def exploited_through_ivars?
self.instance_variables.any?
end
def init_with(command)
# Note: this is how bad this COULD be.
# system("#{command}")
@exploited_through_init_with = true
end
def []=(command, arguments)
# Note: this is how bad this COULD be.
# system("#{command} #{arguments}")
@exploited_through_setter = true
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/exploit.1.9.3.yaml 0000644 0052762 0001160 00000000054 12300765631 024221 0 ustar jenkins jenkins --- !ruby/hash:ExploitableBackDoor
foo: bar
puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/safe_yaml_spec.rb 0000644 0052762 0001160 00000052244 12300765631 024511 0 ustar jenkins jenkins require File.join(File.dirname(__FILE__), "spec_helper")
require "exploitable_back_door"
describe YAML do
# Essentially stolen from:
# https://github.com/rails/rails/blob/3-2-stable/activesupport/lib/active_support/core_ext/kernel/reporting.rb#L10-25
def silence_warnings
$VERBOSE = nil; yield
ensure
$VERBOSE = true
end
def safe_load_round_trip(object, options={})
yaml = object.to_yaml
if SafeYAML::YAML_ENGINE == "psych"
YAML.safe_load(yaml, nil, options)
else
YAML.safe_load(yaml, options)
end
end
before :each do
SafeYAML.restore_defaults!
end
after :each do
SafeYAML.restore_defaults!
end
describe "unsafe_load" do
if SafeYAML::YAML_ENGINE == "psych" && RUBY_VERSION >= "1.9.3"
it "allows exploits through objects defined in YAML w/ !ruby/hash via custom :[]= methods" do
backdoor = YAML.unsafe_load("--- !ruby/hash:ExploitableBackDoor\nfoo: bar\n")
backdoor.should be_exploited_through_setter
end
it "allows exploits through objects defined in YAML w/ !ruby/object via the :init_with method" do
backdoor = YAML.unsafe_load("--- !ruby/object:ExploitableBackDoor\nfoo: bar\n")
backdoor.should be_exploited_through_init_with
end
end
it "allows exploits through objects w/ sensitive instance variables defined in YAML w/ !ruby/object" do
backdoor = YAML.unsafe_load("--- !ruby/object:ExploitableBackDoor\nfoo: bar\n")
backdoor.should be_exploited_through_ivars
end
context "with special whitelisted tags defined" do
before :each do
SafeYAML::whitelist!(OpenStruct)
end
it "effectively ignores the whitelist (since everything is whitelisted)" do
result = YAML.unsafe_load <<-YAML.unindent
--- !ruby/object:OpenStruct
table:
:backdoor: !ruby/object:ExploitableBackDoor
foo: bar
YAML
result.should be_a(OpenStruct)
result.backdoor.should be_exploited_through_ivars
end
end
end
describe "safe_load" do
it "does NOT allow exploits through objects defined in YAML w/ !ruby/hash" do
object = YAML.safe_load("--- !ruby/hash:ExploitableBackDoor\nfoo: bar\n")
object.should_not be_a(ExploitableBackDoor)
end
it "does NOT allow exploits through objects defined in YAML w/ !ruby/object" do
object = YAML.safe_load("--- !ruby/object:ExploitableBackDoor\nfoo: bar\n")
object.should_not be_a(ExploitableBackDoor)
end
context "for YAML engine #{SafeYAML::YAML_ENGINE}" do
if SafeYAML::YAML_ENGINE == "psych"
let(:options) { nil }
let(:arguments) { ["foo: bar", nil, options] }
context "when no tags are whitelisted" do
it "constructs a SafeYAML::PsychHandler to resolve nodes as they're parsed, for optimal performance" do
Psych::Parser.should_receive(:new).with an_instance_of(SafeYAML::PsychHandler)
# This won't work now; we just want to ensure Psych::Parser#parse was in fact called.
YAML.safe_load(*arguments) rescue nil
end
end
context "when whitelisted tags are specified" do
let(:options) {
{ :whitelisted_tags => ["foo"] }
}
it "instead uses Psych to construct a full tree before examining the nodes" do
Psych.should_receive(:parse)
# This won't work now; we just want to ensure Psych::Parser#parse was in fact called.
YAML.safe_load(*arguments) rescue nil
end
end
end
if SafeYAML::YAML_ENGINE == "syck"
it "uses Syck internally to parse YAML" do
YAML.should_receive(:parse).with("foo: bar")
# This won't work now; we just want to ensure YAML::parse was in fact called.
YAML.safe_load("foo: bar") rescue nil
end
end
end
it "loads a plain ol' YAML document just fine" do
result = YAML.safe_load <<-YAML.unindent
foo:
number: 1
string: Hello, there!
symbol: :blah
sequence:
- hi
- bye
YAML
result.should == {
"foo" => {
"number" => 1,
"string" => "Hello, there!",
"symbol" => ":blah",
"sequence" => ["hi", "bye"]
}
}
end
it "works for YAML documents with anchors and aliases" do
result = YAML.safe_load <<-YAML
- &id001 {}
- *id001
- *id001
YAML
result.should == [{}, {}, {}]
end
it "works for YAML documents with binary tagged keys" do
result = YAML.safe_load <<-YAML
? !!binary >
Zm9v
: "bar"
? !!binary >
YmFy
: "baz"
YAML
result.should == {"foo" => "bar", "bar" => "baz"}
end
it "works for YAML documents with binary tagged values" do
result = YAML.safe_load <<-YAML
"foo": !!binary >
YmFy
"bar": !!binary >
YmF6
YAML
result.should == {"foo" => "bar", "bar" => "baz"}
end
it "works for YAML documents with binary tagged array values" do
result = YAML.safe_load <<-YAML
- !binary |-
Zm9v
- !binary |-
YmFy
YAML
result.should == ["foo", "bar"]
end
it "works for YAML documents with sections" do
result = YAML.safe_load <<-YAML
mysql: &mysql
adapter: mysql
pool: 30
login: &login
username: user
password: password123
development: &development
<<: *mysql
<<: *login
host: localhost
YAML
result.should == {
"mysql" => {
"adapter" => "mysql",
"pool" => 30
},
"login" => {
"username" => "user",
"password" => "password123"
},
"development" => {
"adapter" => "mysql",
"pool" => 30,
"username" => "user",
"password" => "password123",
"host" => "localhost"
}
}
end
it "correctly prefers explicitly defined values over default values from included sections" do
# Repeating this test 100 times to increase the likelihood of running into an issue caused by
# non-deterministic hash key enumeration.
100.times do
result = YAML.safe_load <<-YAML
defaults: &defaults
foo: foo
bar: bar
baz: baz
custom:
<<: *defaults
bar: custom_bar
baz: custom_baz
YAML
result["custom"].should == {
"foo" => "foo",
"bar" => "custom_bar",
"baz" => "custom_baz"
}
end
end
it "works with multi-level inheritance" do
result = YAML.safe_load <<-YAML
defaults: &defaults
foo: foo
bar: bar
baz: baz
custom: &custom
<<: *defaults
bar: custom_bar
baz: custom_baz
grandcustom: &grandcustom
<<: *custom
YAML
result.should == {
"defaults" => { "foo" => "foo", "bar" => "bar", "baz" => "baz" },
"custom" => { "foo" => "foo", "bar" => "custom_bar", "baz" => "custom_baz" },
"grandcustom" => { "foo" => "foo", "bar" => "custom_bar", "baz" => "custom_baz" }
}
end
it "returns false when parsing an empty document" do
result = YAML.safe_load ""
result.should == false
end
context "with custom initializers defined" do
before :each do
if SafeYAML::YAML_ENGINE == "psych"
SafeYAML::OPTIONS[:custom_initializers] = {
"!set" => lambda { Set.new },
"!hashiemash" => lambda { Hashie::Mash.new }
}
else
SafeYAML::OPTIONS[:custom_initializers] = {
"tag:yaml.org,2002:set" => lambda { Set.new },
"tag:yaml.org,2002:hashiemash" => lambda { Hashie::Mash.new }
}
end
end
it "will use a custom initializer to instantiate an array-like class upon deserialization" do
result = YAML.safe_load <<-YAML.unindent
--- !set
- 1
- 2
- 3
YAML
result.should be_a(Set)
result.to_a.should =~ [1, 2, 3]
end
it "will use a custom initializer to instantiate a hash-like class upon deserialization" do
result = YAML.safe_load <<-YAML.unindent
--- !hashiemash
foo: bar
YAML
result.should be_a(Hashie::Mash)
result.to_hash.should == { "foo" => "bar" }
end
end
context "with special whitelisted tags defined" do
before :each do
SafeYAML::whitelist!(OpenStruct)
# Necessary for deserializing OpenStructs properly.
SafeYAML::OPTIONS[:deserialize_symbols] = true
end
it "will allow objects to be deserialized for whitelisted tags" do
result = YAML.safe_load("--- !ruby/object:OpenStruct\ntable:\n foo: bar\n")
result.should be_a(OpenStruct)
result.instance_variable_get(:@table).should == { "foo" => "bar" }
end
it "will not deserialize objects without whitelisted tags" do
result = YAML.safe_load("--- !ruby/hash:ExploitableBackDoor\nfoo: bar\n")
result.should_not be_a(ExploitableBackDoor)
result.should == { "foo" => "bar" }
end
it "will not allow non-whitelisted objects to be embedded within objects with whitelisted tags" do
result = YAML.safe_load <<-YAML.unindent
--- !ruby/object:OpenStruct
table:
:backdoor: !ruby/object:ExploitableBackDoor
foo: bar
YAML
result.should be_a(OpenStruct)
result.backdoor.should_not be_a(ExploitableBackDoor)
result.backdoor.should == { "foo" => "bar" }
end
context "with the :raise_on_unknown_tag option enabled" do
before :each do
SafeYAML::OPTIONS[:raise_on_unknown_tag] = true
end
after :each do
SafeYAML.restore_defaults!
end
it "raises an exception if a non-nil, non-whitelisted tag is encountered" do
lambda {
YAML.safe_load <<-YAML.unindent
--- !ruby/object:Unknown
foo: bar
YAML
}.should raise_error
end
it "checks all tags, even those within objects with trusted tags" do
lambda {
YAML.safe_load <<-YAML.unindent
--- !ruby/object:OpenStruct
table:
:backdoor: !ruby/object:Unknown
foo: bar
YAML
}.should raise_error
end
it "does not raise an exception as long as all tags are whitelisted" do
result = YAML.safe_load <<-YAML.unindent
--- !ruby/object:OpenStruct
table:
:backdoor:
string: foo
integer: 1
float: 3.14
symbol: :bar
date: 2013-02-20
array: []
hash: {}
YAML
result.should be_a(OpenStruct)
result.backdoor.should == {
"string" => "foo",
"integer" => 1,
"float" => 3.14,
"symbol" => :bar,
"date" => Date.parse("2013-02-20"),
"array" => [],
"hash" => {}
}
end
it "does not raise an exception on the non-specific '!' tag" do
result = nil
expect { result = YAML.safe_load "--- ! 'foo'" }.to_not raise_error
result.should == "foo"
end
context "with whitelisted custom class" do
class SomeClass
attr_accessor :foo
end
let(:instance) { SomeClass.new }
before do
SafeYAML::whitelist!(SomeClass)
instance.foo = 'with trailing whitespace: '
end
it "does not raise an exception on the non-specific '!' tag" do
result = nil
expect { result = YAML.safe_load(instance.to_yaml) }.to_not raise_error
result.foo.should == 'with trailing whitespace: '
end
end
end
end
context "when options are passed direclty to #load which differ from the defaults" do
let(:default_options) { {} }
before :each do
SafeYAML::OPTIONS.merge!(default_options)
end
context "(for example, when symbol deserialization is enabled by default)" do
let(:default_options) { { :deserialize_symbols => true } }
it "goes with the default option when it is not overridden" do
silence_warnings do
YAML.load(":foo: bar").should == { :foo => "bar" }
end
end
it "allows the default option to be overridden on a per-call basis" do
silence_warnings do
YAML.load(":foo: bar", :deserialize_symbols => false).should == { ":foo" => "bar" }
YAML.load(":foo: bar", :deserialize_symbols => true).should == { :foo => "bar" }
end
end
end
context "(or, for example, when certain tags are whitelisted)" do
let(:default_options) {
{
:deserialize_symbols => true,
:whitelisted_tags => SafeYAML::YAML_ENGINE == "psych" ?
["!ruby/object:OpenStruct"] :
["tag:ruby.yaml.org,2002:object:OpenStruct"]
}
}
it "goes with the default option when it is not overridden" do
result = safe_load_round_trip(OpenStruct.new(:foo => "bar"))
result.should be_a(OpenStruct)
result.foo.should == "bar"
end
it "allows the default option to be overridden on a per-call basis" do
result = safe_load_round_trip(OpenStruct.new(:foo => "bar"), :whitelisted_tags => [])
result.should == { "table" => { :foo => "bar" } }
result = safe_load_round_trip(OpenStruct.new(:foo => "bar"), :deserialize_symbols => false, :whitelisted_tags => [])
result.should == { "table" => { ":foo" => "bar" } }
end
end
end
end
describe "unsafe_load_file" do
if SafeYAML::YAML_ENGINE == "psych" && RUBY_VERSION >= "1.9.3"
it "allows exploits through objects defined in YAML w/ !ruby/hash via custom :[]= methods" do
backdoor = YAML.unsafe_load_file "spec/exploit.1.9.3.yaml"
backdoor.should be_exploited_through_setter
end
end
if SafeYAML::YAML_ENGINE == "psych" && RUBY_VERSION >= "1.9.2"
it "allows exploits through objects defined in YAML w/ !ruby/object via the :init_with method" do
backdoor = YAML.unsafe_load_file "spec/exploit.1.9.2.yaml"
backdoor.should be_exploited_through_init_with
end
end
it "allows exploits through objects w/ sensitive instance variables defined in YAML w/ !ruby/object" do
backdoor = YAML.unsafe_load_file "spec/exploit.1.9.2.yaml"
backdoor.should be_exploited_through_ivars
end
end
describe "safe_load_file" do
it "does NOT allow exploits through objects defined in YAML w/ !ruby/hash" do
object = YAML.safe_load_file "spec/exploit.1.9.3.yaml"
object.should_not be_a(ExploitableBackDoor)
end
it "does NOT allow exploits through objects defined in YAML w/ !ruby/object" do
object = YAML.safe_load_file "spec/exploit.1.9.2.yaml"
object.should_not be_a(ExploitableBackDoor)
end
end
describe "load" do
let(:options) { {} }
let (:arguments) {
if SafeYAML::MULTI_ARGUMENT_YAML_LOAD
["foo: bar", nil, options]
else
["foo: bar", options]
end
}
context "as long as a :default_mode has been specified" do
it "doesn't issue a warning for safe mode, since an explicit mode has been set" do
SafeYAML::OPTIONS[:default_mode] = :safe
Kernel.should_not_receive(:warn)
YAML.load(*arguments)
end
it "doesn't issue a warning for unsafe mode, since an explicit mode has been set" do
SafeYAML::OPTIONS[:default_mode] = :unsafe
Kernel.should_not_receive(:warn)
YAML.load(*arguments)
end
end
context "when the :safe options is specified" do
let(:safe_mode) { true }
let(:options) { { :safe => safe_mode } }
it "doesn't issue a warning" do
Kernel.should_not_receive(:warn)
YAML.load(*arguments)
end
it "calls #safe_load if the :safe option is set to true" do
YAML.should_receive(:safe_load)
YAML.load(*arguments)
end
context "when the :safe option is set to false" do
let(:safe_mode) { false }
it "calls #unsafe_load if the :safe option is set to false" do
YAML.should_receive(:unsafe_load)
YAML.load(*arguments)
end
end
end
it "issues a warning when the :safe option is omitted" do
silence_warnings do
Kernel.should_receive(:warn)
YAML.load(*arguments)
end
end
it "only issues a warning once (to avoid spamming an app's output)" do
silence_warnings do
Kernel.should_receive(:warn).once
2.times { YAML.load(*arguments) }
end
end
it "defaults to safe mode if the :safe option is omitted" do
silence_warnings do
YAML.should_receive(:safe_load)
YAML.load(*arguments)
end
end
context "with the default mode set to :unsafe" do
before :each do
SafeYAML::OPTIONS[:default_mode] = :unsafe
end
it "defaults to unsafe mode if the :safe option is omitted" do
silence_warnings do
YAML.should_receive(:unsafe_load)
YAML.load(*arguments)
end
end
it "calls #safe_load if the :safe option is set to true" do
YAML.should_receive(:safe_load)
YAML.load(*(arguments + [{ :safe => true }]))
end
end
end
describe "load_file" do
let(:filename) { "spec/exploit.1.9.2.yaml" } # doesn't really matter
it "issues a warning if the :safe option is omitted" do
silence_warnings do
Kernel.should_receive(:warn)
YAML.load_file(filename)
end
end
it "doesn't issue a warning as long as the :safe option is specified" do
Kernel.should_not_receive(:warn)
YAML.load_file(filename, :safe => true)
end
it "defaults to safe mode if the :safe option is omitted" do
silence_warnings do
YAML.should_receive(:safe_load_file)
YAML.load_file(filename)
end
end
it "calls #safe_load_file if the :safe option is set to true" do
YAML.should_receive(:safe_load_file)
YAML.load_file(filename, :safe => true)
end
it "calls #unsafe_load_file if the :safe option is set to false" do
YAML.should_receive(:unsafe_load_file)
YAML.load_file(filename, :safe => false)
end
context "with arbitrary object deserialization enabled by default" do
before :each do
SafeYAML::OPTIONS[:default_mode] = :unsafe
end
it "defaults to unsafe mode if the :safe option is omitted" do
silence_warnings do
YAML.should_receive(:unsafe_load_file)
YAML.load_file(filename)
end
end
it "calls #safe_load if the :safe option is set to true" do
YAML.should_receive(:safe_load_file)
YAML.load_file(filename, :safe => true)
end
end
end
describe "whitelist!" do
context "not a class" do
it "should raise" do
expect { SafeYAML::whitelist! :foo }.to raise_error(/not a Class/)
SafeYAML::OPTIONS[:whitelisted_tags].should be_empty
end
end
context "anonymous class" do
it "should raise" do
expect { SafeYAML::whitelist! Class.new }.to raise_error(/cannot be anonymous/)
SafeYAML::OPTIONS[:whitelisted_tags].should be_empty
end
end
context "with a Class as its argument" do
it "should configure correctly" do
expect { SafeYAML::whitelist! OpenStruct }.to_not raise_error
SafeYAML::OPTIONS[:whitelisted_tags].grep(/OpenStruct\Z/).should_not be_empty
end
it "successfully deserializes the specified class" do
SafeYAML.whitelist!(OpenStruct)
# necessary for properly assigning OpenStruct attributes
SafeYAML::OPTIONS[:deserialize_symbols] = true
result = safe_load_round_trip(OpenStruct.new(:foo => "bar"))
result.should be_a(OpenStruct)
result.foo.should == "bar"
end
it "works for ranges" do
SafeYAML.whitelist!(Range)
safe_load_round_trip(1..10).should == (1..10)
end
it "works for regular expressions" do
SafeYAML.whitelist!(Regexp)
safe_load_round_trip(/foo/).should == /foo/
end
it "works for multiple classes" do
SafeYAML.whitelist!(Range, Regexp)
safe_load_round_trip([(1..10), /bar/]).should == [(1..10), /bar/]
end
it "works for arbitrary Exception subclasses" do
class CustomException < Exception
attr_reader :custom_message
def initialize(custom_message)
@custom_message = custom_message
end
end
SafeYAML.whitelist!(CustomException)
ex = safe_load_round_trip(CustomException.new("blah"))
ex.should be_a(CustomException)
ex.custom_message.should == "blah"
end
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/psych_resolver_spec.rb 0000644 0052762 0001160 00000000401 12300765631 025604 0 ustar jenkins jenkins require File.join(File.dirname(__FILE__), "spec_helper")
if SafeYAML::YAML_ENGINE == "psych"
require "safe_yaml/psych_resolver"
describe SafeYAML::PsychResolver do
include ResolverSpecs
let(:resolver) { SafeYAML::PsychResolver.new }
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/exploit.1.9.2.yaml 0000644 0052762 0001160 00000000056 12300765631 024222 0 ustar jenkins jenkins --- !ruby/object:ExploitableBackDoor
foo: bar
puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/transform/ 0000755 0052762 0001160 00000000000 12300765640 023216 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/transform/to_float_spec.rb 0000644 0052762 0001160 00000002320 12300765631 026361 0 ustar jenkins jenkins require File.join(File.dirname(__FILE__), "..", "spec_helper")
describe SafeYAML::Transform::ToFloat do
it "returns true when the value matches a valid Float" do
subject.transform?("20.00").should == [true, 20.0]
end
it "returns false when the value does not match a valid Float" do
subject.transform?("foobar").should be_false
end
it "returns false when the value spans multiple lines" do
subject.transform?("20.00\nNOT A FLOAT").should be_false
end
it "correctly parses all formats in the YAML spec" do
# canonical
subject.transform?("6.8523015e+5").should == [true, 685230.15]
# exponentioal
subject.transform?("685.230_15e+03").should == [true, 685230.15]
# fixed
subject.transform?("685_230.15").should == [true, 685230.15]
# sexagesimal
subject.transform?("190:20:30.15").should == [true, 685230.15]
# infinity
subject.transform?("-.inf").should == [true, (-1.0 / 0.0)]
# not a number
# NOTE: can't use == here since NaN != NaN
success, result = subject.transform?(".NaN")
success.should be_true; result.should be_nan
end
# issue 29
it "returns false for the string '.'" do
subject.transform?(".").should be_false
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/transform/to_symbol_spec.rb 0000644 0052762 0001160 00000003024 12300765631 026563 0 ustar jenkins jenkins require File.join(File.dirname(__FILE__), "..", "spec_helper")
describe SafeYAML::Transform::ToSymbol do
def with_symbol_deserialization_value(value)
symbol_deserialization_flag = SafeYAML::OPTIONS[:deserialize_symbols]
SafeYAML::OPTIONS[:deserialize_symbols] = value
yield
ensure
SafeYAML::OPTIONS[:deserialize_symbols] = symbol_deserialization_flag
end
def with_symbol_deserialization(&block)
with_symbol_deserialization_value(true, &block)
end
def without_symbol_deserialization(&block)
with_symbol_deserialization_value(false, &block)
end
it "returns true when the value matches a valid Symbol" do
with_symbol_deserialization { subject.transform?(":foo")[0].should be_true }
end
it "returns true when the value matches a valid String+Symbol" do
with_symbol_deserialization { subject.transform?(':"foo"')[0].should be_true }
end
it "returns false when symbol deserialization is disabled" do
without_symbol_deserialization { subject.transform?(":foo").should be_false }
end
it "returns false when the value does not match a valid Symbol" do
with_symbol_deserialization { subject.transform?("foo").should be_false }
end
it "returns false when the symbol does not begin the line" do
with_symbol_deserialization do
subject.transform?("NOT A SYMBOL\n:foo").should be_false
end
end
it "returns false when the symbol does not end the line" do
with_symbol_deserialization do
subject.transform?(":foo\nNOT A SYMBOL").should be_false
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/transform/to_integer_spec.rb 0000644 0052762 0001160 00000003272 12300765631 026720 0 ustar jenkins jenkins require File.join(File.dirname(__FILE__), "..", "spec_helper")
describe SafeYAML::Transform::ToInteger do
it "returns true when the value matches a valid Integer" do
subject.transform?("10").should == [true, 10]
end
it "returns false when the value does not match a valid Integer" do
subject.transform?("foobar").should be_false
end
it "returns false when the value spans multiple lines" do
subject.transform?("10\nNOT AN INTEGER").should be_false
end
it "allows commas in the number" do
subject.transform?("1,000").should == [true, 1000]
end
it "correctly parses numbers in octal format" do
subject.transform?("010").should == [true, 8]
end
it "correctly parses numbers in hexadecimal format" do
subject.transform?("0x1FF").should == [true, 511]
end
it "defaults to a string for a number that resembles octal format but is not" do
subject.transform?("09").should be_false
end
it "correctly parses 0 in decimal" do
subject.transform?("0").should == [true, 0]
end
it "defaults to a string for a number that resembles hexadecimal format but is not" do
subject.transform?("0x1G").should be_false
end
it "correctly parses all formats in the YAML spec" do
# canonical
subject.transform?("685230").should == [true, 685230]
# decimal
subject.transform?("+685_230").should == [true, 685230]
# octal
subject.transform?("02472256").should == [true, 685230]
# hexadecimal:
subject.transform?("0x_0A_74_AE").should == [true, 685230]
# binary
subject.transform?("0b1010_0111_0100_1010_1110").should == [true, 685230]
# sexagesimal
subject.transform?("190:20:30").should == [true, 685230]
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/transform/base64_spec.rb 0000644 0052762 0001160 00000000571 12300765631 025644 0 ustar jenkins jenkins require File.join(File.dirname(__FILE__), "..", "spec_helper")
describe SafeYAML::Transform do
it "should return the same encoding when decoding Base64" do
value = "c3VyZS4="
decoded = SafeYAML::Transform.to_proper_type(value, false, "!binary")
decoded.should == "sure."
decoded.encoding.should == value.encoding if decoded.respond_to?(:encoding)
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/transform/to_date_spec.rb 0000644 0052762 0001160 00000002164 12300765631 026177 0 ustar jenkins jenkins require File.join(File.dirname(__FILE__), "..", "spec_helper")
describe SafeYAML::Transform::ToDate do
it "returns true when the value matches a valid Date" do
subject.transform?("2013-01-01").should == [true, Date.parse("2013-01-01")]
end
it "returns false when the value does not match a valid Date" do
subject.transform?("foobar").should be_false
end
it "returns false when the value does not end with a Date" do
subject.transform?("2013-01-01\nNOT A DATE").should be_false
end
it "returns false when the value does not begin with a Date" do
subject.transform?("NOT A DATE\n2013-01-01").should be_false
end
it "correctly parses the remaining formats of the YAML spec" do
equivalent_values = [
"2001-12-15T02:59:43.1Z", # canonical
"2001-12-14t21:59:43.10-05:00", # iso8601
"2001-12-14 21:59:43.10 -5", # space separated
"2001-12-15 2:59:43.10" # no time zone (Z)
]
equivalent_values.each do |value|
success, result = subject.transform?(value)
success.should be_true
result.should == Time.utc(2001, 12, 15, 2, 59, 43, 100000)
end
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/syck_resolver_spec.rb 0000644 0052762 0001160 00000000375 12300765631 025441 0 ustar jenkins jenkins require File.join(File.dirname(__FILE__), "spec_helper")
if SafeYAML::YAML_ENGINE == "syck"
require "safe_yaml/syck_resolver"
describe SafeYAML::SyckResolver do
include ResolverSpecs
let(:resolver) { SafeYAML::SyckResolver.new }
end
end
puppet-3.4.3/lib/puppet/vendor/safe_yaml/spec/spec_helper.rb 0000644 0052762 0001160 00000000763 12300765631 024027 0 ustar jenkins jenkins HERE = File.dirname(__FILE__) unless defined?(HERE)
ROOT = File.join(HERE, "..") unless defined?(ROOT)
$LOAD_PATH << File.join(ROOT, "lib")
$LOAD_PATH << File.join(HERE, "support")
require "yaml"
if ENV["YAMLER"] && defined?(YAML::ENGINE)
YAML::ENGINE.yamler = ENV["YAMLER"]
puts "Running specs in Ruby #{RUBY_VERSION} with '#{YAML::ENGINE.yamler}' YAML engine."
end
require "safe_yaml"
require "ostruct"
require "hashie"
require "heredoc_unindent"
require File.join(HERE, "resolver_specs")
puppet-3.4.3/lib/puppet/vendor/require_vendored.rb 0000644 0052762 0001160 00000000337 12300765631 022203 0 ustar jenkins jenkins # This adds upfront requirements on vendored code found under lib/vendor/x
# Add one requirement per vendored package (or a comment if it is loaded on demand).
require 'safe_yaml'
require 'puppet/vendor/safe_yaml_patches'
puppet-3.4.3/lib/puppet/rails.rb 0000644 0052762 0001160 00000010566 12300765631 016463 0 ustar jenkins jenkins # Load the appropriate libraries, or set a class indicating they aren't available
require 'facter'
require 'puppet'
require 'logger'
module Puppet::Rails
TIME_DEBUG = true
def self.connect
# This global init does not work for testing, because we remove
# the state dir on every test.
return if ActiveRecord::Base.connected?
Puppet.settings.use(:main, :rails, :master)
ActiveRecord::Base.logger = Logger.new(Puppet[:railslog])
begin
loglevel = Logger.const_get(Puppet[:rails_loglevel].upcase)
ActiveRecord::Base.logger.level = loglevel
rescue => detail
Puppet.warning "'#{Puppet[:rails_loglevel]}' is not a valid Rails log level; using debug"
ActiveRecord::Base.logger.level = Logger::DEBUG
end
# As of ActiveRecord 2.2 allow_concurrency has been deprecated and no longer has any effect.
ActiveRecord::Base.allow_concurrency = true if Puppet::Util.activerecord_version < 2.2
ActiveRecord::Base.verify_active_connections!
begin
args = database_arguments
Puppet.info "Connecting to #{args[:adapter]} database: #{args[:database]}"
ActiveRecord::Base.establish_connection(args)
rescue => detail
message = "Could not connect to database: #{detail}"
Puppet.log_exception(detail, message)
raise Puppet::Error, message
end
end
# The arguments for initializing the database connection.
def self.database_arguments
adapter = Puppet[:dbadapter]
args = {:adapter => adapter, :log_level => Puppet[:rails_loglevel]}
case adapter
when "sqlite3"
args[:database] = Puppet[:dblocation]
when "mysql", "mysql2", "postgresql"
args[:host] = Puppet[:dbserver] unless Puppet[:dbserver].to_s.empty?
args[:port] = Puppet[:dbport] unless Puppet[:dbport].to_s.empty?
args[:username] = Puppet[:dbuser] unless Puppet[:dbuser].to_s.empty?
args[:password] = Puppet[:dbpassword] unless Puppet[:dbpassword].to_s.empty?
args[:pool] = Puppet[:dbconnections].to_i unless Puppet[:dbconnections].to_i <= 0
args[:database] = Puppet[:dbname]
args[:reconnect]= true
socket = Puppet[:dbsocket]
args[:socket] = socket unless socket.to_s.empty?
when "oracle_enhanced"
args[:database] = Puppet[:dbname] unless Puppet[:dbname].to_s.empty?
args[:username] = Puppet[:dbuser] unless Puppet[:dbuser].to_s.empty?
args[:password] = Puppet[:dbpassword] unless Puppet[:dbpassword].to_s.empty?
args[:pool] = Puppet[:dbconnections].to_i unless Puppet[:dbconnections].to_i <= 0
else
raise ArgumentError, "Invalid db adapter #{adapter}"
end
args
end
# Set up our database connection. It'd be nice to have a "use" system
# that could make callbacks.
def self.init
raise Puppet::DevError, "No activerecord, cannot init Puppet::Rails" unless Puppet.features.rails?
connect
unless ActiveRecord::Base.connection.tables.include?("resources")
require 'puppet/rails/database/schema'
Puppet::Rails::Schema.init
end
migrate if Puppet[:dbmigrate]
end
# Migrate to the latest db schema.
def self.migrate
dbdir = nil
$LOAD_PATH.each { |d|
tmp = File.join(d, "puppet/rails/database")
if FileTest.directory?(tmp)
dbdir = tmp
break
end
}
raise Puppet::Error, "Could not find Puppet::Rails database dir" unless dbdir
raise Puppet::Error, "Database has problems, can't migrate." unless ActiveRecord::Base.connection.tables.include?("resources")
Puppet.notice "Migrating"
begin
ActiveRecord::Migrator.migrate(dbdir)
rescue => detail
message = "Could not migrate database: #{detail}"
Puppet.log_exception(detail, message)
raise Puppet::Error, "Could not migrate database: #{detail}"
end
end
# Tear down the database. Mostly only used during testing.
def self.teardown
raise Puppet::DevError, "No activerecord, cannot init Puppet::Rails" unless Puppet.features.rails?
Puppet.settings.use(:master, :rails)
begin
ActiveRecord::Base.establish_connection(database_arguments)
rescue => detail
Puppet.log_exception(detail)
raise Puppet::Error, "Could not connect to database: #{detail}"
end
ActiveRecord::Base.connection.tables.each do |t|
ActiveRecord::Base.connection.drop_table t
end
end
end
require 'puppet/rails/host' if Puppet.features.rails?
puppet-3.4.3/lib/puppet/application/ 0000755 0052762 0001160 00000000000 12300765640 017317 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/application/help.rb 0000644 0052762 0001160 00000000154 12300765631 020574 0 ustar jenkins jenkins require 'puppet/application/face_base'
class Puppet::Application::Help < Puppet::Application::FaceBase
end
puppet-3.4.3/lib/puppet/application/config.rb 0000644 0052762 0001160 00000000156 12300765631 021113 0 ustar jenkins jenkins require 'puppet/application/face_base'
class Puppet::Application::Config < Puppet::Application::FaceBase
end
puppet-3.4.3/lib/puppet/application/doc.rb 0000644 0052762 0001160 00000016552 12300765631 020422 0 ustar jenkins jenkins require 'puppet/application'
class Puppet::Application::Doc < Puppet::Application
run_mode :master
attr_accessor :unknown_args, :manifest
def preinit
{:references => [], :mode => :text, :format => :to_markdown }.each do |name,value|
options[name] = value
end
@unknown_args = []
@manifest = false
end
option("--all","-a")
option("--outputdir OUTPUTDIR","-o")
option("--verbose","-v")
option("--debug","-d")
option("--charset CHARSET")
option("--format FORMAT", "-f") do |arg|
method = "to_#{arg}"
require 'puppet/util/reference'
if Puppet::Util::Reference.method_defined?(method)
options[:format] = method
else
raise "Invalid output format #{arg}"
end
end
option("--mode MODE", "-m") do |arg|
require 'puppet/util/reference'
if Puppet::Util::Reference.modes.include?(arg) or arg.intern==:rdoc
options[:mode] = arg.intern
else
raise "Invalid output mode #{arg}"
end
end
option("--list", "-l") do |arg|
require 'puppet/util/reference'
puts Puppet::Util::Reference.references.collect { |r| Puppet::Util::Reference.reference(r).doc }.join("\n")
exit(0)
end
option("--reference REFERENCE", "-r") do |arg|
options[:references] << arg.intern
end
def help
<<-'HELP'
puppet-doc(8) -- Generate Puppet documentation and references
========
SYNOPSIS
--------
Generates a reference for all Puppet types. Largely meant for internal
Puppet Labs use.
WARNING: RDoc support is only available under Ruby 1.8.7 and earlier.
USAGE
-----
puppet doc [-a|--all] [-h|--help] [-o|--outputdir ]
[-m|--mode text|pdf|rdoc] [-r|--reference ]
[--charset ] []
DESCRIPTION
-----------
If mode is not 'rdoc', then this command generates a Markdown document
describing all installed Puppet types or all allowable arguments to
puppet executables. It is largely meant for internal use and is used to
generate the reference document available on the Puppet Labs web site.
In 'rdoc' mode, this command generates an html RDoc hierarchy describing
the manifests that are in 'manifestdir' and 'modulepath' configuration
directives. The generated documentation directory is doc by default but
can be changed with the 'outputdir' option.
If the command is run with the name of a manifest file as an argument,
puppet doc will output a single manifest's documentation on stdout.
WARNING: RDoc support is only available under Ruby 1.8.7 and earlier.
The internal API used to support manifest documentation has changed
radically in newer versions, and support is not yet available for
using those versions of RDoc.
OPTIONS
-------
* --all:
Output the docs for all of the reference types. In 'rdoc' mode, this also
outputs documentation for all resources.
* --help:
Print this help message
* --outputdir:
Used only in 'rdoc' mode. The directory to which the rdoc output should
be written.
* --mode:
Determine the output mode. Valid modes are 'text', 'pdf' and 'rdoc'. The 'pdf'
mode creates PDF formatted files in the /tmp directory. The default mode is
'text'.
* --reference:
Build a particular reference. Get a list of references by running
'puppet doc --list'.
* --charset:
Used only in 'rdoc' mode. It sets the charset used in the html files produced.
* --manifestdir:
Used only in 'rdoc' mode. The directory to scan for stand-alone manifests.
If not supplied, puppet doc will use the manifestdir from puppet.conf.
* --modulepath:
Used only in 'rdoc' mode. The directory or directories to scan for modules.
If not supplied, puppet doc will use the modulepath from puppet.conf.
* --environment:
Used only in 'rdoc' mode. The configuration environment from which
to read the modulepath and manifestdir settings, when reading said settings
from puppet.conf.
EXAMPLE
-------
$ puppet doc -r type > /tmp/type_reference.markdown
or
$ puppet doc --outputdir /tmp/rdoc --mode rdoc /path/to/manifests
or
$ puppet doc /etc/puppet/manifests/site.pp
or
$ puppet doc -m pdf -r configuration
AUTHOR
------
Luke Kanies
COPYRIGHT
---------
Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
HELP
end
def handle_unknown( opt, arg )
@unknown_args << {:opt => opt, :arg => arg }
true
end
def run_command
return[:rdoc].include?(options[:mode]) ? send(options[:mode]) : other
end
def rdoc
exit_code = 0
files = []
unless @manifest
env = Puppet::Node::Environment.new
files += env.modulepath
files << ::File.dirname(env[:manifest])
end
files += command_line.args
Puppet.info "scanning: #{files.inspect}"
Puppet.settings[:document_all] = options[:all] || false
begin
require 'puppet/util/rdoc'
if @manifest
Puppet::Util::RDoc.manifestdoc(files)
else
options[:outputdir] = "doc" unless options[:outputdir]
Puppet::Util::RDoc.rdoc(options[:outputdir], files, options[:charset])
end
rescue => detail
Puppet.log_exception(detail, "Could not generate documentation: #{detail}")
exit_code = 1
end
exit exit_code
end
def other
text = ""
with_contents = options[:references].length <= 1
exit_code = 0
require 'puppet/util/reference'
options[:references].sort { |a,b| a.to_s <=> b.to_s }.each do |name|
raise "Could not find reference #{name}" unless section = Puppet::Util::Reference.reference(name)
begin
# Add the per-section text, but with no ToC
text += section.send(options[:format], with_contents)
rescue => detail
Puppet.log_exception(detail, "Could not generate reference #{name}: #{detail}")
exit_code = 1
next
end
end
text += Puppet::Util::Reference.footer unless with_contents # We've only got one reference
if options[:mode] == :pdf
Puppet::Util::Reference.pdf(text)
else
puts text
end
exit exit_code
end
def setup
# sole manifest documentation
if command_line.args.size > 0
options[:mode] = :rdoc
@manifest = true
end
if options[:mode] == :rdoc
setup_rdoc
else
setup_reference
end
setup_logging
end
def setup_reference
if options[:all]
# Don't add dynamic references to the "all" list.
require 'puppet/util/reference'
options[:references] = Puppet::Util::Reference.references.reject do |ref|
Puppet::Util::Reference.reference(ref).dynamic?
end
end
options[:references] << :type if options[:references].empty?
end
def setup_rdoc(dummy_argument=:work_arround_for_ruby_GC_bug)
# consume the unknown options
# and feed them as settings
if @unknown_args.size > 0
@unknown_args.each do |option|
# force absolute path for modulepath when passed on commandline
if option[:opt]=="--modulepath" or option[:opt] == "--manifestdir"
option[:arg] = option[:arg].split(::File::PATH_SEPARATOR).collect { |p| ::File.expand_path(p) }.join(::File::PATH_SEPARATOR)
end
Puppet.settings.handlearg(option[:opt], option[:arg])
end
end
end
def setup_logging
# Handle the logging settings.
if options[:debug]
Puppet::Util::Log.level = :debug
elsif options[:verbose]
Puppet::Util::Log.level = :info
else
Puppet::Util::Log.level = :warning
end
Puppet::Util::Log.newdestination(:console)
end
end
puppet-3.4.3/lib/puppet/application/queue.rb 0000644 0052762 0001160 00000010177 12300765631 020776 0 ustar jenkins jenkins require 'puppet/application'
require 'puppet/util'
require 'puppet/daemon'
require 'puppet/util/pidlock'
class Puppet::Application::Queue < Puppet::Application
attr_accessor :daemon
def app_defaults()
super.merge( :pidfile => "$rundir/queue.pid" )
end
def preinit
@argv = ARGV.dup
# Do an initial trap, so that cancels don't get a stack trace.
# This exits with exit code 1
Signal.trap(:INT) do
$stderr.puts "Caught SIGINT; shutting down"
exit(1)
end
# This is a normal shutdown, so code 0
Signal.trap(:TERM) do
$stderr.puts "Caught SIGTERM; shutting down"
exit(0)
end
{
:verbose => false,
:debug => false
}.each do |opt,val|
options[opt] = val
end
end
option("--debug","-d")
option("--verbose","-v")
def help
<<-HELP
puppet-queue(8) -- Queuing daemon for asynchronous storeconfigs
========
SYNOPSIS
--------
Retrieves serialized storeconfigs records from a queue and processes
them in order.
USAGE
-----
puppet queue [-d|--debug] [-v|--verbose]
DESCRIPTION
-----------
This application runs as a daemon and processes storeconfigs data,
retrieving the data from a stomp server message queue and writing it to
a database.
For more information, including instructions for properly setting up
your puppet master and message queue, see the documentation on setting
up asynchronous storeconfigs at:
http://projects.puppetlabs.com/projects/1/wiki/Using_Stored_Configuration
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 ' 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 queue with
'--genconfig'.
* --debug:
Enable full debugging.
* --help:
Print this help message
* --verbose:
Turn on verbose reporting.
* --version:
Print the puppet version number and exit.
EXAMPLE
-------
$ puppet queue
AUTHOR
------
Luke Kanies
COPYRIGHT
---------
Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
HELP
end
option("--logdest DEST", "-l DEST") do |arg|
handle_logdest_arg(arg)
end
def main
require 'puppet/indirector/catalog/queue' # provides Puppet::Indirector::Queue.subscribe
Puppet.notice "Starting puppet queue #{Puppet.version}"
Puppet::Resource::Catalog::Queue.subscribe do |catalog|
# Once you have a Puppet::Resource::Catalog instance, passing it to save should suffice
# to put it through to the database via its active_record indirector (which is determined
# by the terminus_class = :active_record setting above)
Puppet::Util.benchmark(:notice, "Processing queued catalog for #{catalog.name}") do
begin
Puppet::Resource::Catalog.indirection.save(catalog)
rescue => detail
Puppet.log_exception(detail, "Could not save queued catalog for #{catalog.name}: #{detail}")
end
end
end
Thread.list.each { |thread| thread.join }
end
def setup
Puppet.warning "Puppet queue is deprecated. See http://links.puppetlabs.com/puppet-queue-deprecation"
unless Puppet.features.stomp?
raise ArgumentError, "Could not load the 'stomp' library, which must be present for queueing to work. You must install the required library."
end
setup_logs
exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
require 'puppet/resource/catalog'
Puppet::Resource::Catalog.indirection.terminus_class = :store_configs
daemon = Puppet::Daemon.new(Puppet::Util::Pidlock.new(Puppet[:pidfile]))
daemon.argv = @argv
daemon.daemonize if Puppet[:daemonize]
# We want to make sure that we don't have a cache
# class set up, because if storeconfigs is enabled,
# we'll get a loop of continually caching the catalog
# for storage again.
Puppet::Resource::Catalog.indirection.cache_class = nil
end
end
puppet-3.4.3/lib/puppet/application/apply.rb 0000644 0052762 0001160 00000016256 12300765631 021003 0 ustar jenkins jenkins require 'puppet/application'
require 'puppet/configurer'
class Puppet::Application::Apply < Puppet::Application
option("--debug","-d")
option("--execute EXECUTE","-e") do |arg|
options[:code] = arg
end
option("--loadclasses","-L")
option("--verbose","-v")
option("--use-nodes")
option("--detailed-exitcodes")
option("--write-catalog-summary")
option("--catalog catalog", "-c catalog") do |arg|
options[:catalog] = arg
end
option("--logdest LOGDEST", "-l") do |arg|
handle_logdest_arg(arg)
end
option("--parseonly") do |args|
puts "--parseonly has been removed. Please use 'puppet parser validate '"
exit 1
end
def help
<<-'HELP'
puppet-apply(8) -- Apply Puppet manifests locally
========
SYNOPSIS
--------
Applies a standalone Puppet manifest to the local system.
USAGE
-----
puppet apply [-h|--help] [-V|--version] [-d|--debug] [-v|--verbose]
[-e|--execute] [--detailed-exitcodes] [-l|--logdest ] [--noop]
[--catalog ] [--write-catalog-summary]
DESCRIPTION
-----------
This is the standalone puppet execution tool; use it to apply
individual manifests.
When provided with a modulepath, via command line or config file, puppet
apply can effectively mimic the catalog that would be served by puppet
master with access to the same modules, although there are some subtle
differences. When combined with scheduling and an automated system for
pushing manifests, this can be used to implement a serverless Puppet
site.
Most users should use 'puppet agent' and 'puppet master' for site-wide
manifests.
OPTIONS
-------
Note that any configuration parameter that's valid in the configuration
file is also a valid long argument. For example, 'tags' is a
valid configuration parameter, so you can specify '--tags ,'
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 with
'--genconfig'.
* --debug:
Enable full debugging.
* --detailed-exitcodes:
Provide transaction information via exit codes. If this is enabled, an exit
code of '2' means there were changes, an exit code of '4' means there were
failures during the transaction, and an exit code of '6' means there were both
changes and failures.
* --help:
Print this help message
* --loadclasses:
Load any stored classes. 'puppet agent' caches configured classes
(usually at /etc/puppet/classes.txt), and setting this option causes
all of those classes to be set in your puppet manifest.
* --logdest:
Where to send messages. Choose between syslog, the console, and a log
file. Defaults to sending messages to the console.
* --noop:
Use 'noop' mode where Puppet runs in a no-op or dry-run mode. This
is useful for seeing what changes Puppet will make without actually
executing the changes.
* --execute:
Execute a specific piece of Puppet code
* --verbose:
Print extra information.
* --catalog:
Apply a JSON catalog (such as one generated with 'puppet master --compile'). You can
either specify a JSON file or pipe in JSON from standard input.
* --write-catalog-summary
After compiling the catalog saves the resource list and classes list to the node
in the state directory named classes.txt and resources.txt
EXAMPLE
-------
$ puppet apply -l /tmp/manifest.log manifest.pp
$ puppet apply --modulepath=/root/dev/modules -e "include ntpd::server"
$ puppet apply --catalog catalog.json
AUTHOR
------
Luke Kanies
COPYRIGHT
---------
Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
HELP
end
def app_defaults
super.merge({
:default_file_terminus => :file_server,
})
end
def run_command
if options[:catalog]
apply
else
main
end
end
def apply
if options[:catalog] == "-"
text = $stdin.read
else
text = ::File.read(options[:catalog])
end
catalog = read_catalog(text)
apply_catalog(catalog)
end
def main
# Set our code or file to use.
if options[:code] or command_line.args.length == 0
Puppet[:code] = options[:code] || STDIN.read
else
manifest = command_line.args.shift
raise "Could not find file #{manifest}" unless Puppet::FileSystem::File.exist?(manifest)
Puppet.warning("Only one file can be applied per run. Skipping #{command_line.args.join(', ')}") if command_line.args.size > 0
Puppet[:manifest] = manifest
end
unless Puppet[:node_name_fact].empty?
# Collect our facts.
unless facts = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value])
raise "Could not find facts for #{Puppet[:node_name_value]}"
end
Puppet[:node_name_value] = facts.values[Puppet[:node_name_fact]]
facts.name = Puppet[:node_name_value]
end
# Find our Node
unless node = Puppet::Node.indirection.find(Puppet[:node_name_value])
raise "Could not find node #{Puppet[:node_name_value]}"
end
# Merge in the facts.
node.merge(facts.values) if facts
# Allow users to load the classes that puppet agent creates.
if options[:loadclasses]
file = Puppet[:classfile]
if Puppet::FileSystem::File.exist?(file)
unless FileTest.readable?(file)
$stderr.puts "#{file} is not readable"
exit(63)
end
node.classes = ::File.read(file).split(/[\s\n]+/)
end
end
begin
# Compile our catalog
starttime = Time.now
catalog = Puppet::Resource::Catalog.indirection.find(node.name, :use_node => node)
# Translate it to a RAL catalog
catalog = catalog.to_ral
catalog.finalize
catalog.retrieval_duration = Time.now - starttime
if options[:write_catalog_summary]
catalog.write_class_file
catalog.write_resource_file
end
exit_status = apply_catalog(catalog)
if not exit_status
exit(1)
elsif options[:detailed_exitcodes] then
exit(exit_status)
else
exit(0)
end
rescue => detail
Puppet.log_exception(detail)
exit(1)
end
end
def setup
exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
Puppet::Util::Log.newdestination(:console) unless options[:setdest]
Signal.trap(:INT) do
$stderr.puts "Exiting"
exit(1)
end
# we want the last report to be persisted locally
Puppet::Transaction::Report.indirection.cache_class = :yaml
set_log_level
if Puppet[:profile]
Puppet::Util::Profiler.current = Puppet::Util::Profiler::WallClock.new(Puppet.method(:debug), "apply")
end
end
private
def read_catalog(text)
begin
catalog = Puppet::Resource::Catalog.convert_from(Puppet::Resource::Catalog.default_format,text)
catalog = Puppet::Resource::Catalog.pson_create(catalog) unless catalog.is_a?(Puppet::Resource::Catalog)
rescue => detail
raise Puppet::Error, "Could not deserialize catalog from pson: #{detail}"
end
catalog.to_ral
end
def apply_catalog(catalog)
configurer = Puppet::Configurer.new
configurer.run(:catalog => catalog, :pluginsync => false)
end
end
puppet-3.4.3/lib/puppet/application/certificate.rb 0000644 0052762 0001160 00000001101 12300765631 022117 0 ustar jenkins jenkins require 'puppet/application/indirection_base'
class Puppet::Application::Certificate < Puppet::Application::IndirectionBase
def setup
location = Puppet::SSL::Host.ca_location
if location == :local && !Puppet::SSL::CertificateAuthority.ca?
# I'd prefer if this could be dealt with differently; ideally, run_mode should be set as
# part of a class definition, and should not be modifiable beyond that. This is one of
# the cases where that isn't currently possible.
Puppet.settings.preferred_run_mode = "master"
end
super
end
end
puppet-3.4.3/lib/puppet/application/certificate_request.rb 0000644 0052762 0001160 00000000572 12300765631 023702 0 ustar jenkins jenkins require 'puppet/application/indirection_base'
# NOTE: this is using an "old" naming convention (underscores instead of camel-case), for backwards
# compatibility with 2.7.x. When the old naming convention is officially and publicly deprecated,
# this should be changed to camel-case.
class Puppet::Application::Certificate_request < Puppet::Application::IndirectionBase
end
puppet-3.4.3/lib/puppet/application/indirection_base.rb 0000644 0052762 0001160 00000000167 12300765631 023151 0 ustar jenkins jenkins require 'puppet/application/face_base'
class Puppet::Application::IndirectionBase < Puppet::Application::FaceBase
end
puppet-3.4.3/lib/puppet/application/man.rb 0000644 0052762 0001160 00000000153 12300765631 020416 0 ustar jenkins jenkins require 'puppet/application/face_base'
class Puppet::Application::Man < Puppet::Application::FaceBase
end
puppet-3.4.3/lib/puppet/application/catalog.rb 0000644 0052762 0001160 00000000175 12300765631 021261 0 ustar jenkins jenkins require 'puppet/application/indirection_base'
class Puppet::Application::Catalog < Puppet::Application::IndirectionBase
end
puppet-3.4.3/lib/puppet/application/secret_agent.rb 0000644 0052762 0001160 00000000615 12300765631 022311 0 ustar jenkins jenkins require 'puppet/application/face_base'
require 'puppet/face'
# NOTE: this is using an "old" naming convention (underscores instead of camel-case), for backwards
# compatibility with 2.7.x. When the old naming convention is officially and publicly deprecated,
# this should be changed to camel-case.
class Puppet::Application::Secret_agent < Puppet::Application::FaceBase
run_mode :agent
end
puppet-3.4.3/lib/puppet/application/parser.rb 0000644 0052762 0001160 00000000204 12300765631 021134 0 ustar jenkins jenkins require 'puppet/application/face_base'
require 'puppet/face'
class Puppet::Application::Parser < Puppet::Application::FaceBase
end
puppet-3.4.3/lib/puppet/application/node.rb 0000644 0052762 0001160 00000000172 12300765631 020571 0 ustar jenkins jenkins require 'puppet/application/indirection_base'
class Puppet::Application::Node < Puppet::Application::IndirectionBase
end
puppet-3.4.3/lib/puppet/application/cert.rb 0000644 0052762 0001160 00000016155 12300765631 020611 0 ustar jenkins jenkins require 'puppet/application'
require 'puppet/ssl/certificate_authority/interface'
class Puppet::Application::Cert < Puppet::Application
run_mode :master
attr_accessor :all, :ca, :digest, :signed
def subcommand
@subcommand
end
def subcommand=(name)
# Handle the nasty, legacy mapping of "clean" to "destroy".
sub = name.to_sym
@subcommand = (sub == :clean ? :destroy : sub)
end
option("--clean", "-c") do |arg|
self.subcommand = "destroy"
end
option("--all", "-a") do |arg|
@all = true
end
option("--digest DIGEST") do |arg|
@digest = arg
end
option("--signed", "-s") do |arg|
@signed = true
end
option("--debug", "-d") do |arg|
Puppet::Util::Log.level = :debug
end
option("--list", "-l") do |arg|
self.subcommand = :list
end
option("--revoke", "-r") do |arg|
self.subcommand = :revoke
end
option("--generate", "-g") do |arg|
self.subcommand = :generate
end
option("--sign", "-s") do |arg|
self.subcommand = :sign
end
option("--print", "-p") do |arg|
self.subcommand = :print
end
option("--verify", "-v") do |arg|
self.subcommand = :verify
end
option("--fingerprint", "-f") do |arg|
self.subcommand = :fingerprint
end
option("--reinventory") do |arg|
self.subcommand = :reinventory
end
option("--[no-]allow-dns-alt-names") do |value|
options[:allow_dns_alt_names] = value
end
option("--verbose", "-v") do |arg|
Puppet::Util::Log.level = :info
end
def help
<<-'HELP'
puppet-cert(8) -- Manage certificates and requests
========
SYNOPSIS
--------
Standalone certificate authority. Capable of generating certificates,
but mostly used for signing certificate requests from puppet clients.
USAGE
-----
puppet cert [-h|--help] [-V|--version] [-d|--debug] [-v|--verbose]
[--digest ] []
DESCRIPTION
-----------
Because the puppet master service defaults to not signing client
certificate requests, this script is available for signing outstanding
requests. It can be used to list outstanding requests and then either
sign them individually or sign all of them.
ACTIONS
-------
Every action except 'list' and 'generate' requires a hostname to act on,
unless the '--all' option is set.
* clean:
Revoke a host's certificate (if applicable) and remove all files
related to that host from puppet cert's storage. This is useful when
rebuilding hosts, since new certificate signing requests will only be
honored if puppet cert does not have a copy of a signed certificate
for that host. If '--all' is specified then all host certificates,
both signed and unsigned, will be removed.
* fingerprint:
Print the DIGEST (defaults to the signing algorithm) fingerprint of a
host's certificate.
* generate:
Generate a certificate for a named client. A certificate/keypair will
be generated for each client named on the command line.
* list:
List outstanding certificate requests. If '--all' is specified, signed
certificates are also listed, prefixed by '+', and revoked or invalid
certificates are prefixed by '-' (the verification outcome is printed
in parenthesis).
* print:
Print the full-text version of a host's certificate.
* revoke:
Revoke the certificate of a client. The certificate can be specified either
by its serial number (given as a hexadecimal number prefixed by '0x') or by its
hostname. The certificate is revoked by adding it to the Certificate Revocation
List given by the 'cacrl' configuration option. Note that the puppet master
needs to be restarted after revoking certificates.
* sign:
Sign an outstanding certificate request.
* verify:
Verify the named certificate against the local CA certificate.
* reinventory:
Build an inventory of the issued certificates. This will destroy the current
inventory file specified by 'cert_inventory' and recreate it from the
certificates found in the 'certdir'. Ensure the puppet master is stopped
before running this action.
OPTIONS
-------
Note that any configuration parameter that's valid in the configuration
file is also a valid long argument. For example, 'ssldir' is a valid
configuration parameter, so you can specify '--ssldir ' 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 cert with
'--genconfig'.
* --all:
Operate on all items. Currently only makes sense with the 'sign',
'clean', 'list', and 'fingerprint' actions.
* --digest:
Set the digest for fingerprinting (defaults to the the digest used when
signing the cert). Valid values depends on your openssl and openssl ruby
extension version.
* --debug:
Enable full debugging.
* --help:
Print this help message
* --verbose:
Enable verbosity.
* --version:
Print the puppet version number and exit.
EXAMPLE
-------
$ puppet cert list
culain.madstop.com
$ puppet cert sign culain.madstop.com
AUTHOR
------
Luke Kanies
COPYRIGHT
---------
Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
HELP
end
def main
if @all
hosts = :all
elsif @signed
hosts = :signed
else
hosts = command_line.args.collect { |h| h.downcase }
end
begin
apply(@ca, :revoke, options.merge(:to => hosts)) if subcommand == :destroy
apply(@ca, subcommand, options.merge(:to => hosts, :digest => @digest))
rescue => detail
Puppet.log_exception(detail)
exit(24)
end
end
def setup
require 'puppet/ssl/certificate_authority'
exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
Puppet::Util::Log.newdestination :console
if [:generate, :destroy].include? subcommand
Puppet::SSL::Host.ca_location = :local
else
Puppet::SSL::Host.ca_location = :only
end
# If we are generating, and the option came from the CLI, it gets added to
# the data. This will do the right thing for non-local certificates, in
# that the command line but *NOT* the config file option will apply.
if subcommand == :generate
if Puppet.settings.set_by_cli?(:dns_alt_names)
options[:dns_alt_names] = Puppet[:dns_alt_names]
end
end
begin
@ca = Puppet::SSL::CertificateAuthority.new
rescue => detail
Puppet.log_exception(detail)
exit(23)
end
end
def parse_options
# handle the bareword subcommand pattern.
result = super
unless self.subcommand then
if sub = self.command_line.args.shift then
self.subcommand = sub
else
puts help
exit
end
end
result
end
# Create and run an applicator. I wanted to build an interface where you could do
# something like 'ca.apply(:generate).to(:all) but I don't think it's really possible.
def apply(ca, method, options)
raise ArgumentError, "You must specify the hosts to apply to; valid values are an array or the symbol :all" unless options[:to]
applier = Puppet::SSL::CertificateAuthority::Interface.new(method, options)
applier.apply(ca)
end
end
puppet-3.4.3/lib/puppet/application/certificate_revocation_list.rb 0000644 0052762 0001160 00000000602 12300765631 025410 0 ustar jenkins jenkins require 'puppet/application/indirection_base'
# NOTE: this is using an "old" naming convention (underscores instead of camel-case), for backwards
# compatibility with 2.7.x. When the old naming convention is officially and publicly deprecated,
# this should be changed to camel-case.
class Puppet::Application::Certificate_revocation_list < Puppet::Application::IndirectionBase
end
puppet-3.4.3/lib/puppet/application/resource_type.rb 0000644 0052762 0001160 00000000564 12300765631 022541 0 ustar jenkins jenkins require 'puppet/application/indirection_base'
# NOTE: this is using an "old" naming convention (underscores instead of camel-case), for backwards
# compatibility with 2.7.x. When the old naming convention is officially and publicly deprecated,
# this should be changed to camel-case.
class Puppet::Application::Resource_type < Puppet::Application::IndirectionBase
end
puppet-3.4.3/lib/puppet/application/describe.rb 0000644 0052762 0001160 00000012314 12300765631 021425 0 ustar jenkins jenkins require 'puppet/application'
class Formatter
def initialize(width)
@width = width
end
def wrap(txt, opts)
return "" unless txt && !txt.empty?
work = (opts[:scrub] ? scrub(txt) : txt)
indent = (opts[:indent] ? opts[:indent] : 0)
textLen = @width - indent
patt = Regexp.new("^(.{0,#{textLen}})[ \n]")
prefix = " " * indent
res = []
while work.length > textLen
if work =~ patt
res << $1
work.slice!(0, $MATCH.length)
else
res << work.slice!(0, textLen)
end
end
res << work if work.length.nonzero?
prefix + res.join("\n#{prefix}")
end
def header(txt, sep = "-")
"\n#{txt}\n" + sep * txt.size
end
private
def scrub(text)
# For text with no carriage returns, there's nothing to do.
return text if text !~ /\n/
indent = nil
# If we can match an indentation, then just remove that same level of
# indent from every line.
if text =~ /^(\s+)/
indent = $1
return text.gsub(/^#{indent}/,'')
else
return text
end
end
end
class TypeDoc
def initialize
@format = Formatter.new(76)
@types = {}
Puppet::Type.loadall
Puppet::Type.eachtype { |type|
next if type.name == :component
@types[type.name] = type
}
end
def list_types
puts "These are the types known to puppet:\n"
@types.keys.sort { |a, b|
a.to_s <=> b.to_s
}.each do |name|
type = @types[name]
s = type.doc.gsub(/\s+/, " ")
n = s.index(". ")
if n.nil?
s = ".. no documentation .."
elsif n > 45
s = s[0, 45] + " ..."
else
s = s[0, n]
end
printf "%-15s - %s\n", name, s
end
end
def format_type(name, opts)
name = name.to_sym
unless @types.has_key?(name)
puts "Unknown type #{name}"
return
end
type = @types[name]
puts @format.header(name.to_s, "=")
puts @format.wrap(type.doc, :indent => 0, :scrub => true) + "\n\n"
puts @format.header("Parameters")
if opts[:parameters]
format_attrs(type, [:property, :param])
else
list_attrs(type, [:property, :param])
end
if opts[:meta]
puts @format.header("Meta Parameters")
if opts[:parameters]
format_attrs(type, [:meta])
else
list_attrs(type, [:meta])
end
end
if type.providers.size > 0
puts @format.header("Providers")
if opts[:providers]
format_providers(type)
else
list_providers(type)
end
end
end
# List details about attributes
def format_attrs(type, attrs)
docs = {}
type.allattrs.each do |name|
kind = type.attrtype(name)
docs[name] = type.attrclass(name).doc if attrs.include?(kind) && name != :provider
end
docs.sort { |a,b|
a[0].to_s <=> b[0].to_s
}.each { |name, doc|
print "\n- **#{name}**"
if type.key_attributes.include?(name) and name != :name
puts " (*namevar*)"
else
puts ""
end
puts @format.wrap(doc, :indent => 4, :scrub => true)
}
end
# List the names of attributes
def list_attrs(type, attrs)
params = []
type.allattrs.each do |name|
kind = type.attrtype(name)
params << name.to_s if attrs.include?(kind) && name != :provider
end
puts @format.wrap(params.sort.join(", "), :indent => 4)
end
def format_providers(type)
type.providers.sort { |a,b|
a.to_s <=> b.to_s
}.each { |prov|
puts "\n- **#{prov}**"
puts @format.wrap(type.provider(prov).doc, :indent => 4, :scrub => true)
}
end
def list_providers(type)
list = type.providers.sort { |a,b|
a.to_s <=> b.to_s
}.join(", ")
puts @format.wrap(list, :indent => 4)
end
end
class Puppet::Application::Describe < Puppet::Application
banner "puppet describe [options] [type]"
option("--short", "-s", "Only list parameters without detail") do |arg|
options[:parameters] = false
end
option("--providers","-p")
option("--list", "-l")
option("--meta","-m")
def help
<<-'HELP'
puppet-describe(8) -- Display help about resource types
========
SYNOPSIS
--------
Prints help about Puppet resource types, providers, and metaparameters.
USAGE
-----
puppet describe [-h|--help] [-s|--short] [-p|--providers] [-l|--list] [-m|--meta]
OPTIONS
-------
* --help:
Print this help text
* --providers:
Describe providers in detail for each type
* --list:
List all types
* --meta:
List all metaparameters
* --short:
List only parameters without detail
EXAMPLE
-------
$ puppet describe --list
$ puppet describe file --providers
$ puppet describe user -s -m
AUTHOR
------
David Lutterkort
COPYRIGHT
---------
Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
HELP
end
def preinit
options[:parameters] = true
end
def main
doc = TypeDoc.new
if options[:list]
doc.list_types
else
options[:types].each { |name| doc.format_type(name, options) }
end
end
def setup
options[:types] = command_line.args.dup
handle_help(nil) unless options[:list] || options[:types].size > 0
$stderr.puts "Warning: ignoring types when listing all types" if options[:list] && options[:types].size > 0
end
end
puppet-3.4.3/lib/puppet/application/module.rb 0000644 0052762 0001160 00000000156 12300765631 021133 0 ustar jenkins jenkins require 'puppet/application/face_base'
class Puppet::Application::Module < Puppet::Application::FaceBase
end
puppet-3.4.3/lib/puppet/application/agent.rb 0000644 0052762 0001160 00000035115 12300765631 020747 0 ustar jenkins jenkins require 'puppet/application'
require 'puppet/run'
require 'puppet/daemon'
require 'puppet/util/pidlock'
class Puppet::Application::Agent < Puppet::Application
run_mode :agent
def app_defaults
super.merge({
:catalog_terminus => :rest,
:catalog_cache_terminus => :json,
:node_terminus => :rest,
:facts_terminus => :facter,
})
end
def preinit
# Do an initial trap, so that cancels don't get a stack trace.
Signal.trap(:INT) do
$stderr.puts "Cancelling startup"
exit(0)
end
{
:waitforcert => nil,
:detailed_exitcodes => false,
:verbose => false,
:debug => false,
:setdest => false,
:enable => false,
:disable => false,
:client => true,
:fqdn => nil,
:serve => [],
:digest => 'SHA256',
:graph => true,
:fingerprint => false,
}.each do |opt,val|
options[opt] = val
end
@argv = ARGV.dup
end
option("--disable [MESSAGE]") do |message|
options[:disable] = true
options[:disable_message] = message
end
option("--enable")
option("--debug","-d")
option("--fqdn FQDN","-f")
option("--test","-t")
option("--verbose","-v")
option("--fingerprint")
option("--digest DIGEST")
option("--no-client") do |arg|
options[:client] = false
end
option("--detailed-exitcodes") do |arg|
options[:detailed_exitcodes] = true
end
option("--logdest DEST", "-l DEST") do |arg|
handle_logdest_arg(arg)
end
option("--waitforcert WAITFORCERT", "-w") do |arg|
options[:waitforcert] = arg.to_i
end
def help
<<-'HELP'
puppet-agent(8) -- The puppet agent daemon
========
SYNOPSIS
--------
Retrieves the client configuration from the puppet master and applies it to
the local host.
This service may be run as a daemon, run periodically using cron (or something
similar), or run interactively for testing purposes.
USAGE
-----
puppet agent [--certname ] [-D|--daemonize|--no-daemonize]
[-d|--debug] [--detailed-exitcodes] [--digest ] [--disable [message]] [--enable]
[--fingerprint] [-h|--help] [-l|--logdest syslog||console]
[--no-client] [--noop] [-o|--onetime] [-t|--test]
[-v|--verbose] [-V|--version] [-w|--waitforcert ]
DESCRIPTION
-----------
This is the main puppet client. Its job is to retrieve the local
machine's configuration from a remote server and apply it. In order to
successfully communicate with the remote server, the client must have a
certificate signed by a certificate authority that the server trusts;
the recommended method for this, at the moment, is to run a certificate
authority as part of the puppet server (which is the default). The
client will connect and request a signed certificate, and will continue
connecting until it receives one.
Once the client has a signed certificate, it will retrieve its
configuration and apply it.
USAGE NOTES
-----------
'puppet agent' does its best to find a compromise between interactive
use and daemon use. Run with no arguments and no configuration, it will
go into the background, attempt to get a signed certificate, and retrieve
and apply its configuration every 30 minutes.
Some flags are meant specifically for interactive use -- in particular,
'test', 'tags' or 'fingerprint' are useful. 'test' enables verbose
logging, causes the daemon to stay in the foreground, exits if the
server's configuration is invalid (this happens if, for instance, you've
left a syntax error on the server), and exits after running the
configuration once (rather than hanging around as a long-running
process).
'tags' allows you to specify what portions of a configuration you want
to apply. Puppet elements are tagged with all of the class or definition
names that contain them, and you can use the 'tags' flag to specify one
of these names, causing only configuration elements contained within
that class or definition to be applied. This is very useful when you are
testing new configurations -- for instance, if you are just starting to
manage 'ntpd', you would put all of the new elements into an 'ntpd'
class, and call puppet with '--tags ntpd', which would only apply that
small portion of the configuration during your testing, rather than
applying the whole thing.
'fingerprint' is a one-time flag. In this mode 'puppet agent' will run
once and display on the console (and in the log) the current certificate
(or certificate request) fingerprint. Providing the '--digest' option
allows to use a different digest algorithm to generate the fingerprint.
The main use is to verify that before signing a certificate request on
the master, the certificate request the master received is the same as
the one the client sent (to prevent against man-in-the-middle attacks
when signing certificates).
OPTIONS
-------
Note that any Puppet setting that's valid in the configuration file is also a
valid long argument. For example, 'server' is a valid setting, so you can
specify '--server ' as an argument. Boolean settings translate into
'--setting' and '--no-setting' pairs.
See the configuration file documentation at
http://docs.puppetlabs.com/references/stable/configuration.html for the
full list of acceptable settings. A commented list of all settings can also be
generated by running puppet agent with '--genconfig'.
* --certname:
Set the certname (unique ID) of the client. The master reads this
unique identifying string, which is usually set to the node's
fully-qualified domain name, to determine which configurations the
node will receive. Use this option to debug setup problems or
implement unusual node identification schemes.
(This is a Puppet setting, and can go in puppet.conf.)
* --daemonize:
Send the process into the background. This is the default.
(This is a Puppet setting, and can go in puppet.conf. Note the special 'no-'
prefix for boolean settings on the command line.)
* --no-daemonize:
Do not send the process into the background.
(This is a Puppet setting, and can go in puppet.conf. Note the special 'no-'
prefix for boolean settings on the command line.)
* --debug:
Enable full debugging.
* --detailed-exitcodes:
Provide transaction information via exit codes. If this is enabled, an exit
code of '2' means there were changes, an exit code of '4' means there were
failures during the transaction, and an exit code of '6' means there were both
changes and failures.
* --digest:
Change the certificate fingerprinting digest algorithm. The default is
SHA256. Valid values depends on the version of OpenSSL installed, but
will likely contain MD5, MD2, SHA1 and SHA256.
* --disable:
Disable working on the local system. This puts a lock file in place,
causing 'puppet agent' not to work on the system until the lock file
is removed. This is useful if you are testing a configuration and do
not want the central configuration to override the local state until
everything is tested and committed.
Disable can also take an optional message that will be reported by the
'puppet agent' at the next disabled run.
'puppet agent' uses the same lock file while it is running, so no more
than one 'puppet agent' process is working at a time.
'puppet agent' exits after executing this.
* --enable:
Enable working on the local system. This removes any lock file,
causing 'puppet agent' to start managing the local system again
(although it will continue to use its normal scheduling, so it might
not start for another half hour).
'puppet agent' exits after executing this.
* --fingerprint:
Display the current certificate or certificate signing request
fingerprint and then exit. Use the '--digest' option to change the
digest algorithm used.
* --help:
Print this help message
* --logdest:
Where to send messages. Choose between syslog, the console, and a log
file. Defaults to sending messages to syslog, or the console if
debugging or verbosity is enabled.
* --masterport:
The port on which to contact the puppet master.
(This is a Puppet setting, and can go in puppet.conf.)
* --no-client:
Do not create a config client. This will cause the daemon to start
but not check configuration unless it is triggered with `puppet
kick`. This only makes sense when puppet agent is being run with
listen = true in puppet.conf or was started with the `--listen` option.
* --noop:
Use 'noop' mode where the daemon runs in a no-op or dry-run mode. This
is useful for seeing what changes Puppet will make without actually
executing the changes.
(This is a Puppet setting, and can go in puppet.conf. Note the special 'no-'
prefix for boolean settings on the command line.)
* --onetime:
Run the configuration once. Runs a single (normally daemonized) Puppet
run. Useful for interactively running puppet agent when used in
conjunction with the --no-daemonize option.
(This is a Puppet setting, and can go in puppet.conf. Note the special 'no-'
prefix for boolean settings on the command line.)
* --test:
Enable the most common options used for testing. These are 'onetime',
'verbose', 'ignorecache', 'no-daemonize', 'no-usecacheonfailure',
'detailed-exitcodes', 'no-splay', and 'show_diff'.
* --verbose:
Turn on verbose reporting.
* --version:
Print the puppet version number and exit.
* --waitforcert:
This option only matters for daemons that do not yet have certificates
and it is enabled by default, with a value of 120 (seconds). This
causes 'puppet agent' to connect to the server every 2 minutes and ask
it to sign a certificate request. This is useful for the initial setup
of a puppet client. You can turn off waiting for certificates by
specifying a time of 0.
(This is a Puppet setting, and can go in puppet.conf. Note the special 'no-'
prefix for boolean settings on the command line.)
EXAMPLE
-------
$ puppet agent --server puppet.domain.com
DIAGNOSTICS
-----------
Puppet agent accepts the following signals:
* SIGHUP:
Restart the puppet agent daemon.
* SIGINT and SIGTERM:
Shut down the puppet agent daemon.
* SIGUSR1:
Immediately retrieve and apply configurations from the puppet master.
* SIGUSR2:
Close file descriptors for log files and reopen them. Used with logrotate.
AUTHOR
------
Luke Kanies
COPYRIGHT
---------
Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
HELP
end
def run_command
if options[:fingerprint]
fingerprint
else
# It'd be nice to daemonize later, but we have to daemonize before
# waiting for certificates so that we don't block
daemon = daemonize_process_when(Puppet[:daemonize])
wait_for_certificates
if Puppet[:onetime]
onetime(daemon)
else
main(daemon)
end
end
end
def fingerprint
host = Puppet::SSL::Host.new
unless cert = host.certificate || host.certificate_request
$stderr.puts "Fingerprint asked but no certificate nor certificate request have yet been issued"
exit(1)
return
end
unless digest = cert.digest(options[:digest].to_s)
raise ArgumentError, "Could not get fingerprint for digest '#{options[:digest]}'"
end
puts digest.to_s
end
def onetime(daemon)
if Puppet[:listen]
Puppet.notice "Ignoring --listen on onetime run"
end
unless options[:client]
Puppet.err "onetime is specified but there is no client"
exit(43)
return
end
daemon.set_signal_traps
begin
exitstatus = daemon.agent.run
rescue => detail
Puppet.log_exception(detail)
end
daemon.stop(:exit => false)
if not exitstatus
exit(1)
elsif options[:detailed_exitcodes] then
exit(exitstatus)
else
exit(0)
end
end
def main(daemon)
if Puppet[:listen]
setup_listen(daemon)
end
Puppet.notice "Starting Puppet client version #{Puppet.version}"
daemon.start
end
# Enable all of the most common test options.
def setup_test
Puppet.settings.handlearg("--ignorecache")
Puppet.settings.handlearg("--no-usecacheonfailure")
Puppet.settings.handlearg("--no-splay")
Puppet.settings.handlearg("--show_diff")
Puppet.settings.handlearg("--no-daemonize")
options[:verbose] = true
Puppet[:onetime] = true
options[:detailed_exitcodes] = true
end
def setup
setup_test if options[:test]
setup_logs
exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
if options[:fqdn]
Puppet[:certname] = options[:fqdn]
end
Puppet.settings.use :main, :agent, :ssl
# Always ignoreimport for agent. It really shouldn't even try to import,
# but this is just a temporary band-aid.
Puppet[:ignoreimport] = true
Puppet::Transaction::Report.indirection.terminus_class = :rest
# we want the last report to be persisted locally
Puppet::Transaction::Report.indirection.cache_class = :yaml
if Puppet[:catalog_cache_terminus]
Puppet::Resource::Catalog.indirection.cache_class = Puppet[:catalog_cache_terminus]
end
if options[:fingerprint]
# in fingerprint mode we just need
# access to the local files and we don't need a ca
Puppet::SSL::Host.ca_location = :none
else
Puppet::SSL::Host.ca_location = :remote
setup_agent
end
end
private
def enable_disable_client(agent)
if options[:enable]
agent.enable
elsif options[:disable]
agent.disable(options[:disable_message] || 'reason not specified')
end
exit(0)
end
def setup_listen(daemon)
Puppet.warning "Puppet --listen / kick is deprecated. See http://links.puppetlabs.com/puppet-kick-deprecation"
unless Puppet::FileSystem::File.exist?(Puppet[:rest_authconfig])
Puppet.err "Will not start without authorization file #{Puppet[:rest_authconfig]}"
exit(14)
end
require 'puppet/network/server'
# No REST handlers yet.
server = Puppet::Network::Server.new(Puppet[:bindaddress], Puppet[:puppetport])
daemon.server = server
end
def setup_agent
# We need to make the client either way, we just don't start it
# if --no-client is set.
require 'puppet/agent'
require 'puppet/configurer'
agent = Puppet::Agent.new(Puppet::Configurer, (not(Puppet[:onetime])))
enable_disable_client(agent) if options[:enable] or options[:disable]
@agent = agent if options[:client]
end
def daemonize_process_when(should_daemonize)
daemon = Puppet::Daemon.new(Puppet::Util::Pidlock.new(Puppet[:pidfile]))
daemon.argv = @argv
daemon.agent = @agent
daemon.daemonize if should_daemonize
daemon
end
def wait_for_certificates
host = Puppet::SSL::Host.new
waitforcert = options[:waitforcert] || (Puppet[:onetime] ? 0 : Puppet[:waitforcert])
host.wait_for_cert(waitforcert)
end
end
puppet-3.4.3/lib/puppet/application/status.rb 0000644 0052762 0001160 00000000174 12300765631 021171 0 ustar jenkins jenkins require 'puppet/application/indirection_base'
class Puppet::Application::Status < Puppet::Application::IndirectionBase
end
puppet-3.4.3/lib/puppet/application/inspect.rb 0000644 0052762 0001160 00000012563 12300765631 021320 0 ustar jenkins jenkins require 'puppet/application'
class Puppet::Application::Inspect < Puppet::Application
run_mode :agent
option("--debug","-d")
option("--verbose","-v")
option("--logdest LOGDEST", "-l") do |arg|
handle_logdest_arg(arg)
end
def help
<<-'HELP'
puppet-inspect(8) -- Send an inspection report
========
SYNOPSIS
--------
Prepares and submits an inspection report to the puppet master.
USAGE
-----
puppet inspect [--archive_files] [--archive_file_server]
DESCRIPTION
-----------
This command uses the cached catalog from the previous run of 'puppet
agent' to determine which attributes of which resources have been
marked as auditable with the 'audit' metaparameter. It then examines
the current state of the system, writes the state of the specified
resource attributes to a report, and submits the report to the puppet
master.
Puppet inspect does not run as a daemon, and must be run manually or
from cron.
OPTIONS
-------
Any configuration setting which is valid in the configuration file is
also a valid long argument, e.g. '--server=master.domain.com'. See the
configuration file documentation at
http://docs.puppetlabs.com/references/latest/configuration.html for
the full list of acceptable settings.
* --archive_files:
During an inspect run, whether to archive files whose contents are audited to
a file bucket.
* --archive_file_server:
During an inspect run, the file bucket server to archive files to if
archive_files is set. The default value is '$server'.
AUTHOR
------
Puppet Labs
COPYRIGHT
---------
Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
HELP
end
def setup
exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
raise "Inspect requires reporting to be enabled. Set report=true in puppet.conf to enable reporting." unless Puppet[:report]
@report = Puppet::Transaction::Report.new("inspect")
Puppet::Util::Log.newdestination(@report)
Puppet::Util::Log.newdestination(:console) unless options[:setdest]
Signal.trap(:INT) do
$stderr.puts "Exiting"
exit(1)
end
set_log_level
Puppet::Transaction::Report.indirection.terminus_class = :rest
Puppet::Resource::Catalog.indirection.terminus_class = :yaml
end
def preinit
require 'puppet'
require 'puppet/file_bucket/dipper'
end
def run_command
benchmark(:notice, "Finished inspection") do
retrieval_starttime = Time.now
unless catalog = Puppet::Resource::Catalog.indirection.find(Puppet[:certname])
raise "Could not find catalog for #{Puppet[:certname]}"
end
@report.configuration_version = catalog.version
@report.environment = Puppet[:environment]
inspect_starttime = Time.now
@report.add_times("config_retrieval", inspect_starttime - retrieval_starttime)
if Puppet[:archive_files]
dipper = Puppet::FileBucket::Dipper.new(:Server => Puppet[:archive_file_server])
end
catalog.to_ral.resources.each do |ral_resource|
audited_attributes = ral_resource[:audit]
next unless audited_attributes
status = Puppet::Resource::Status.new(ral_resource)
begin
audited_resource = ral_resource.to_resource
rescue StandardError => detail
ral_resource.log_exception(detail, "Could not inspect #{ral_resource}; skipping: #{detail}")
audited_attributes.each do |name|
event = ral_resource.event(
:property => name,
:status => "failure",
:audited => true,
:message => "failed to inspect #{name}"
)
status.add_event(event)
end
else
audited_attributes.each do |name|
next if audited_resource[name].nil?
# Skip :absent properties of :absent resources. Really, it would be nicer if the RAL returned nil for those, but it doesn't. ~JW
if name == :ensure or audited_resource[:ensure] != :absent or audited_resource[name] != :absent
event = ral_resource.event(
:previous_value => audited_resource[name],
:property => name,
:status => "audit",
:audited => true,
:message => "inspected value is #{audited_resource[name].inspect}"
)
status.add_event(event)
end
end
end
if Puppet[:archive_files] and ral_resource.type == :file and audited_attributes.include?(:content)
path = ral_resource[:path]
if ::File.readable?(path)
begin
dipper.backup(path)
rescue StandardError => detail
Puppet.warning detail
end
end
end
@report.add_resource_status(status)
end
finishtime = Time.now
@report.add_times("inspect", finishtime - inspect_starttime)
@report.finalize_report
begin
Puppet::Transaction::Report.indirection.save(@report)
rescue => detail
Puppet.log_exception(detail, "Could not send report: #{detail}")
end
end
end
end
puppet-3.4.3/lib/puppet/application/instrumentation_listener.rb 0000644 0052762 0001160 00000000577 12300765631 025025 0 ustar jenkins jenkins require 'puppet/application/indirection_base'
# NOTE: this is using an "old" naming convention (underscores instead of camel-case), for backwards
# compatibility with 2.7.x. When the old naming convention is officially and publicly deprecated,
# this should be changed to camel-case.
class Puppet::Application::Instrumentation_listener < Puppet::Application::IndirectionBase
end
puppet-3.4.3/lib/puppet/application/filebucket.rb 0000644 0052762 0001160 00000010354 12300765631 021764 0 ustar jenkins jenkins require 'puppet/application'
class Puppet::Application::Filebucket < Puppet::Application
option("--bucket BUCKET","-b")
option("--debug","-d")
option("--local","-l")
option("--remote","-r")
option("--verbose","-v")
attr :args
def help
<<-'HELP'
puppet-filebucket(8) -- Store and retrieve files in a filebucket
========
SYNOPSIS
--------
A stand-alone Puppet filebucket client.
USAGE
-----
puppet filebucket [-h|--help] [-V|--version] [-d|--debug]
[-v|--verbose] [-l|--local] [-r|--remote] [-s|--server ]
[-b|--bucket ] ...
Puppet filebucket can operate in three modes, with only one mode per call:
backup:
Send one or more files to the specified file bucket. Each sent file is
printed with its resulting md5 sum.
get:
Return the text associated with an md5 sum. The text is printed to
stdout, and only one file can be retrieved at a time.
restore:
Given a file path and an md5 sum, store the content associated with
the sum into the specified file path. You can specify an entirely new
path to this argument; you are not restricted to restoring the content
to its original location.
DESCRIPTION
-----------
This is a stand-alone filebucket client for sending files to a local or
central filebucket.
Note that 'filebucket' defaults to using a network-based filebucket
available on the server named 'puppet'. To use this, you'll have to be
running as a user with valid Puppet certificates. Alternatively, you can
use your local file bucket by specifying '--local'.
OPTIONS
-------
Note that any configuration parameter that's valid in the configuration
file is also a valid long argument. For example, 'ssldir' is a valid
configuration parameter, so you can specify '--ssldir ' 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 with
'--genconfig'.
* --debug:
Enable full debugging.
* --help:
Print this help message
* --local:
Use the local filebucket. This will use the default configuration
information.
* --remote:
Use a remote filebucket. This will use the default configuration
information.
* --server:
The server to send the file to, instead of locally.
* --verbose:
Print extra information.
* --version:
Print version information.
EXAMPLE
-------
$ puppet filebucket backup /etc/passwd
/etc/passwd: 429b225650b912a2ee067b0a4cf1e949
$ puppet filebucket restore /tmp/passwd 429b225650b912a2ee067b0a4cf1e949
AUTHOR
------
Luke Kanies
COPYRIGHT
---------
Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
HELP
end
def run_command
@args = command_line.args
command = args.shift
return send(command) if %w{get backup restore}.include? command
help
end
def get
md5 = args.shift
out = @client.getfile(md5)
print out
end
def backup
raise "You must specify a file to back up" unless args.length > 0
args.each do |file|
unless Puppet::FileSystem::File.exist?(file)
$stderr.puts "#{file}: no such file"
next
end
unless FileTest.readable?(file)
$stderr.puts "#{file}: cannot read file"
next
end
md5 = @client.backup(file)
puts "#{file}: #{md5}"
end
end
def restore
file = args.shift
md5 = args.shift
@client.restore(file, md5)
end
def setup
Puppet::Log.newdestination(:console)
@client = nil
@server = nil
Signal.trap(:INT) do
$stderr.puts "Cancelling"
exit(1)
end
if options[:debug]
Puppet::Log.level = :debug
elsif options[:verbose]
Puppet::Log.level = :info
end
exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
require 'puppet/file_bucket/dipper'
begin
if options[:local] or options[:bucket]
path = options[:bucket] || Puppet[:bucketdir]
@client = Puppet::FileBucket::Dipper.new(:Path => path)
else
@client = Puppet::FileBucket::Dipper.new(:Server => Puppet[:server])
end
rescue => detail
Puppet.log_exception(detail)
exit(1)
end
end
end
puppet-3.4.3/lib/puppet/application/instrumentation_probe.rb 0000644 0052762 0001160 00000000574 12300765631 024304 0 ustar jenkins jenkins require 'puppet/application/indirection_base'
# NOTE: this is using an "old" naming convention (underscores instead of camel-case), for backwards
# compatibility with 2.7.x. When the old naming convention is officially and publicly deprecated,
# this should be changed to camel-case.
class Puppet::Application::Instrumentation_probe < Puppet::Application::IndirectionBase
end
puppet-3.4.3/lib/puppet/application/plugin.rb 0000644 0052762 0001160 00000000155 12300765631 021143 0 ustar jenkins jenkins require 'puppet/application/face_base'
class Puppet::Application::Plugin < Puppet::Application::FaceBase
end
puppet-3.4.3/lib/puppet/application/facts.rb 0000644 0052762 0001160 00000000173 12300765631 020745 0 ustar jenkins jenkins require 'puppet/application/indirection_base'
class Puppet::Application::Facts < Puppet::Application::IndirectionBase
end
puppet-3.4.3/lib/puppet/application/device.rb 0000644 0052762 0001160 00000015135 12300765631 021110 0 ustar jenkins jenkins require 'puppet/application'
require 'puppet/util/network_device'
class Puppet::Application::Device < Puppet::Application
run_mode :agent
attr_accessor :args, :agent, :host
def app_defaults
super.merge({
:catalog_terminus => :rest,
:catalog_cache_terminus => :json,
:node_terminus => :rest,
:facts_terminus => :network_device,
})
end
def preinit
# Do an initial trap, so that cancels don't get a stack trace.
Signal.trap(:INT) do
$stderr.puts "Cancelling startup"
exit(0)
end
{
:waitforcert => nil,
:detailed_exitcodes => false,
:verbose => false,
:debug => false,
:centrallogs => false,
:setdest => false,
}.each do |opt,val|
options[opt] = val
end
@args = {}
end
option("--centrallogging")
option("--debug","-d")
option("--verbose","-v")
option("--detailed-exitcodes") do |arg|
options[:detailed_exitcodes] = true
end
option("--logdest DEST", "-l DEST") do |arg|
handle_logdest_arg(arg)
end
option("--waitforcert WAITFORCERT", "-w") do |arg|
options[:waitforcert] = arg.to_i
end
option("--port PORT","-p") do |arg|
@args[:Port] = arg
end
def help
<<-'HELP'
puppet-device(8) -- Manage remote network devices
========
SYNOPSIS
--------
Retrieves all configurations from the puppet master and apply
them to the remote devices configured in /etc/puppet/device.conf.
Currently must be run out periodically, using cron or something similar.
USAGE
-----
puppet device [-d|--debug] [--detailed-exitcodes] [-V|--version]
[-h|--help] [-l|--logdest syslog||console]
[-v|--verbose] [-w|--waitforcert ]
DESCRIPTION
-----------
Once the client has a signed certificate for a given remote device, it will
retrieve its configuration and apply it.
USAGE NOTES
-----------
One need a /etc/puppet/device.conf file with the following content:
[remote.device.fqdn]
type
url
where:
* type: the current device type (the only value at this time is cisco)
* url: an url allowing to connect to the device
Supported url must conforms to:
scheme://user:password@hostname/?query
with:
* scheme: either ssh or telnet
* user: username, can be omitted depending on the switch/router configuration
* password: the connection password
* query: this is device specific. Cisco devices supports an enable parameter whose
value would be the enable password.
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 ' as an argument.
* --debug:
Enable full debugging.
* --detailed-exitcodes:
Provide transaction information via exit codes. If this is enabled, an exit
code of '2' means there were changes, an exit code of '4' means there were
failures during the transaction, and an exit code of '6' means there were both
changes and failures.
* --help:
Print this help message
* --logdest:
Where to send messages. Choose between syslog, the console, and a log file.
Defaults to sending messages to syslog, or the console if debugging or
verbosity is enabled.
* --verbose:
Turn on verbose reporting.
* --waitforcert:
This option only matters for daemons that do not yet have certificates
and it is enabled by default, with a value of 120 (seconds). This causes
+puppet agent+ to connect to the server every 2 minutes and ask it to sign a
certificate request. This is useful for the initial setup of a puppet
client. You can turn off waiting for certificates by specifying a time
of 0.
EXAMPLE
-------
$ puppet device --server puppet.domain.com
AUTHOR
------
Brice Figureau
COPYRIGHT
---------
Copyright (c) 2011 Puppet Labs, LLC
Licensed under the Apache 2.0 License
HELP
end
def main
vardir = Puppet[:vardir]
confdir = Puppet[:confdir]
certname = Puppet[:certname]
# find device list
require 'puppet/util/network_device/config'
devices = Puppet::Util::NetworkDevice::Config.devices
if devices.empty?
Puppet.err "No device found in #{Puppet[:deviceconfig]}"
exit(1)
end
devices.each_value do |device|
begin
Puppet.info "starting applying configuration to #{device.name} at #{device.url}"
# override local $vardir and $certname
Puppet.settings.set_value(:confdir, ::File.join(Puppet[:devicedir], device.name), :cli)
Puppet.settings.set_value(:vardir, ::File.join(Puppet[:devicedir], device.name), :cli)
Puppet.settings.set_value(:certname, device.name, :cli)
# this will reload and recompute default settings and create the devices sub vardir, or we hope so :-)
Puppet.settings.use :main, :agent, :ssl
# this init the device singleton, so that the facts terminus
# and the various network_device provider can use it
Puppet::Util::NetworkDevice.init(device)
# ask for a ssl cert if needed, but at least
# setup the ssl system for this device.
setup_host
require 'puppet/configurer'
configurer = Puppet::Configurer.new
configurer.run(:network_device => true, :pluginsync => Puppet[:pluginsync])
rescue => detail
Puppet.log_exception(detail)
ensure
Puppet.settings.set_value(:vardir, vardir, :cli)
Puppet.settings.set_value(:confdir, confdir, :cli)
Puppet.settings.set_value(:certname, certname, :cli)
Puppet::SSL::Host.reset
end
end
end
def setup_host
@host = Puppet::SSL::Host.new
waitforcert = options[:waitforcert] || (Puppet[:onetime] ? 0 : Puppet[:waitforcert])
@host.wait_for_cert(waitforcert)
end
def setup
setup_logs
args[:Server] = Puppet[:server]
if options[:centrallogs]
logdest = args[:Server]
logdest += ":" + args[:Port] if args.include?(:Port)
Puppet::Util::Log.newdestination(logdest)
end
Puppet.settings.use :main, :agent, :device, :ssl
# Always ignoreimport for agent. It really shouldn't even try to import,
# but this is just a temporary band-aid.
Puppet[:ignoreimport] = true
# We need to specify a ca location for all of the SSL-related
# indirected classes to work; in fingerprint mode we just need
# access to the local files and we don't need a ca.
Puppet::SSL::Host.ca_location = :remote
Puppet::Transaction::Report.indirection.terminus_class = :rest
if Puppet[:catalog_cache_terminus]
Puppet::Resource::Catalog.indirection.cache_class = Puppet[:catalog_cache_terminus].intern
end
end
end
puppet-3.4.3/lib/puppet/application/instrumentation_data.rb 0000644 0052762 0001160 00000000573 12300765631 024105 0 ustar jenkins jenkins require 'puppet/application/indirection_base'
# NOTE: this is using an "old" naming convention (underscores instead of camel-case), for backwards
# compatibility with 2.7.x. When the old naming convention is officially and publicly deprecated,
# this should be changed to camel-case.
class Puppet::Application::Instrumentation_data < Puppet::Application::IndirectionBase
end
puppet-3.4.3/lib/puppet/application/file.rb 0000644 0052762 0001160 00000000172 12300765631 020563 0 ustar jenkins jenkins require 'puppet/application/indirection_base'
class Puppet::Application::File < Puppet::Application::IndirectionBase
end
puppet-3.4.3/lib/puppet/application/master.rb 0000644 0052762 0001160 00000017131 12300765631 021142 0 ustar jenkins jenkins require 'puppet/application'
require 'puppet/daemon'
require 'puppet/util/pidlock'
class Puppet::Application::Master < Puppet::Application
run_mode :master
option("--debug", "-d")
option("--verbose", "-v")
# internal option, only to be used by ext/rack/config.ru
option("--rack")
option("--compile host", "-c host") do |arg|
options[:node] = arg
end
option("--logdest DEST", "-l DEST") do |arg|
handle_logdest_arg(arg)
end
option("--parseonly") do |args|
puts "--parseonly has been removed. Please use 'puppet parser validate '"
exit 1
end
def help
<<-'HELP'
puppet-master(8) -- The puppet master daemon
========
SYNOPSIS
--------
The central puppet server. Functions as a certificate authority by
default.
USAGE
-----
puppet master [-D|--daemonize|--no-daemonize] [-d|--debug] [-h|--help]
[-l|--logdest |console|syslog] [-v|--verbose] [-V|--version]
[--compile ]
DESCRIPTION
-----------
This command starts an instance of puppet master, running as a daemon
and using Ruby's built-in Webrick webserver. Puppet master can also be
managed by other application servers; when this is the case, this
executable is not used.
OPTIONS
-------
Note that any Puppet setting that's valid in the configuration file is also a
valid long argument. For example, 'server' is a valid setting, so you can
specify '--server ' as an argument. Boolean settings translate into
'--setting' and '--no-setting' pairs.
See the configuration file documentation at
http://docs.puppetlabs.com/references/stable/configuration.html for the
full list of acceptable settings. A commented list of all settings can also be
generated by running puppet master with '--genconfig'.
* --daemonize:
Send the process into the background. This is the default.
(This is a Puppet setting, and can go in puppet.conf. Note the special 'no-'
prefix for boolean settings on the command line.)
* --no-daemonize:
Do not send the process into the background.
(This is a Puppet setting, and can go in puppet.conf. Note the special 'no-'
prefix for boolean settings on the command line.)
* --debug:
Enable full debugging.
* --help:
Print this help message.
* --logdest:
Where to send messages. Choose between syslog, the console, and a log
file. Defaults to sending messages to syslog, or the console if
debugging or verbosity is enabled.
* --masterport:
The port on which to listen for traffic.
(This is a Puppet setting, and can go in puppet.conf.)
* --verbose:
Enable verbosity.
* --version:
Print the puppet version number and exit.
* --compile:
Compile a catalogue and output it in JSON from the puppet master. Uses
facts contained in the $vardir/yaml/ directory to compile the catalog.
EXAMPLE
-------
puppet master
DIAGNOSTICS
-----------
When running as a standalone daemon, puppet master accepts the
following signals:
* SIGHUP:
Restart the puppet master server.
* SIGINT and SIGTERM:
Shut down the puppet master server.
* SIGUSR2:
Close file descriptors for log files and reopen them. Used with logrotate.
AUTHOR
------
Luke Kanies
COPYRIGHT
---------
Copyright (c) 2012 Puppet Labs, LLC Licensed under the Apache 2.0 License
HELP
end
# Sets up the 'node_cache_terminus' default to use the Write Only Yaml terminus :write_only_yaml.
# If this is not wanted, the setting ´node_cache_terminus´ should be set to nil.
# @see Puppet::Node::WriteOnlyYaml
# @see #setup_node_cache
# @see puppet issue 16753
#
def app_defaults
super.merge({
:node_cache_terminus => :write_only_yaml,
:facts_terminus => 'yaml'
})
end
def preinit
Signal.trap(:INT) do
$stderr.puts "Canceling startup"
exit(0)
end
# save ARGV to protect us from it being smashed later by something
@argv = ARGV.dup
end
def run_command
if options[:node]
compile
else
main
end
end
def compile
Puppet::Util::Log.newdestination :console
begin
unless catalog = Puppet::Resource::Catalog.indirection.find(options[:node])
raise "Could not compile catalog for #{options[:node]}"
end
puts PSON::pretty_generate(catalog.to_resource, :allow_nan => true, :max_nesting => false)
rescue => detail
$stderr.puts detail
exit(30)
end
exit(0)
end
def main
require 'etc'
# Make sure we've got a localhost ssl cert
Puppet::SSL::Host.localhost
# And now configure our server to *only* hit the CA for data, because that's
# all it will have write access to.
Puppet::SSL::Host.ca_location = :only if Puppet::SSL::CertificateAuthority.ca?
if Puppet.features.root?
begin
Puppet::Util.chuser
rescue => detail
Puppet.log_exception(detail, "Could not change user to #{Puppet[:user]}: #{detail}")
exit(39)
end
end
if options[:rack]
start_rack_master
else
start_webrick_master
end
end
def setup_logs
# 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
unless Puppet[:daemonize] or options[:rack]
Puppet::Util::Log.newdestination(:console)
options[:setdest] = true
end
end
Puppet::Util::Log.newdestination(:syslog) unless options[:setdest]
end
def setup_terminuses
require 'puppet/file_serving/content'
require 'puppet/file_serving/metadata'
Puppet::FileServing::Content.indirection.terminus_class = :file_server
Puppet::FileServing::Metadata.indirection.terminus_class = :file_server
Puppet::FileBucket::File.indirection.terminus_class = :file
end
def setup_ssl
# Configure all of the SSL stuff.
if Puppet::SSL::CertificateAuthority.ca?
Puppet::SSL::Host.ca_location = :local
Puppet.settings.use :ca
Puppet::SSL::CertificateAuthority.instance
else
Puppet::SSL::Host.ca_location = :none
end
end
# Sets up a special node cache "write only yaml" that collects and stores node data in yaml
# but never finds or reads anything (this since a real cache causes stale data to be served
# in circumstances when the cache can not be cleared).
# @see puppet issue 16753
# @see Puppet::Node::WriteOnlyYaml
# @return [void]
def setup_node_cache
Puppet::Node.indirection.cache_class = Puppet[:node_cache_terminus]
end
def setup
raise Puppet::Error.new("Puppet master is not supported on Microsoft Windows") if Puppet.features.microsoft_windows?
setup_logs
exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
Puppet.settings.use :main, :master, :ssl, :metrics
setup_terminuses
setup_node_cache
setup_ssl
end
private
# Start a master that will be using WeBrick.
#
# This method will block until the master exits.
def start_webrick_master
require 'puppet/network/server'
daemon = Puppet::Daemon.new(Puppet::Util::Pidlock.new(Puppet[:pidfile]))
daemon.argv = @argv
daemon.server = Puppet::Network::Server.new(Puppet[:bindaddress], Puppet[:masterport])
daemon.daemonize if Puppet[:daemonize]
announce_start_of_master
daemon.start
end
# Start a master that will be used for a Rack container.
#
# This method immediately returns the Rack handler that must be returned to
# the calling Rack container
def start_rack_master
require 'puppet/network/http/rack'
announce_start_of_master
return Puppet::Network::HTTP::Rack.new()
end
def announce_start_of_master
Puppet.notice "Starting Puppet master version #{Puppet.version}"
end
end
puppet-3.4.3/lib/puppet/application/ca.rb 0000644 0052762 0001160 00000000175 12300765631 020232 0 ustar jenkins jenkins require 'puppet/application/face_base'
class Puppet::Application::Ca < Puppet::Application::FaceBase
run_mode :master
end
puppet-3.4.3/lib/puppet/application/key.rb 0000644 0052762 0001160 00000000171 12300765631 020433 0 ustar jenkins jenkins require 'puppet/application/indirection_base'
class Puppet::Application::Key < Puppet::Application::IndirectionBase
end
puppet-3.4.3/lib/puppet/application/report.rb 0000644 0052762 0001160 00000000174 12300765631 021161 0 ustar jenkins jenkins require 'puppet/application/indirection_base'
class Puppet::Application::Report < Puppet::Application::IndirectionBase
end
puppet-3.4.3/lib/puppet/application/resource.rb 0000644 0052762 0001160 00000013744 12300765631 021504 0 ustar jenkins jenkins require 'puppet/application'
class Puppet::Application::Resource < Puppet::Application
attr_accessor :host, :extra_params
def preinit
@extra_params = []
Facter.loadfacts
end
option("--debug","-d")
option("--verbose","-v")
option("--edit","-e")
option("--host HOST","-H") do |arg|
Puppet.warning("Accessing resources on the network is deprecated. See http://links.puppetlabs.com/deprecate-networked-resource")
@host = arg
end
option("--types", "-t") do |arg|
types = []
Puppet::Type.loadall
Puppet::Type.eachtype do |t|
next if t.name == :component
types << t.name.to_s
end
puts types.sort
exit
end
option("--param PARAM", "-p") do |arg|
@extra_params << arg.to_sym
end
def help
<<-'HELP'
puppet-resource(8) -- The resource abstraction layer shell
========
SYNOPSIS
--------
Uses the Puppet RAL to directly interact with the system.
USAGE
-----
puppet resource [-h|--help] [-d|--debug] [-v|--verbose] [-e|--edit]
[-H|--host ] [-p|--param ] [-t|--types]
[] [= ...]
DESCRIPTION
-----------
This command provides simple facilities for converting current system
state into Puppet code, along with some ability to modify the current
state using Puppet's RAL.
By default, you must at least provide a type to list, in which case
puppet resource will tell you everything it knows about all resources of
that type. You can optionally specify an instance name, and puppet
resource will only describe that single instance.
If given a type, a name, and a series of = pairs,
puppet resource will modify the state of the specified resource.
Alternately, if given a type, a name, and the '--edit' flag, puppet
resource will write its output to a file, open that file in an editor,
and then apply the saved file as a Puppet transaction.
OPTIONS
-------
Note that any configuration parameter that's valid in the configuration
file is also a valid long argument. For example, 'ssldir' is a valid
configuration parameter, so you can specify '--ssldir ' 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 with
'--genconfig'.
* --debug:
Enable full debugging.
* --edit:
Write the results of the query to a file, open the file in an editor,
and read the file back in as an executable Puppet manifest.
* --host:
When specified, connect to the resource server on the named host
and retrieve the list of resouces of the type specified.
* --help:
Print this help message.
* --param:
Add more parameters to be outputted from queries.
* --types:
List all available types.
* --verbose:
Print extra information.
EXAMPLE
-------
This example uses `puppet resource` to return a Puppet configuration for
the user `luke`:
$ puppet resource user luke
user { 'luke':
home => '/home/luke',
uid => '100',
ensure => 'present',
comment => 'Luke Kanies,,,',
gid => '1000',
shell => '/bin/bash',
groups => ['sysadmin','audio','video','puppet']
}
AUTHOR
------
Luke Kanies
COPYRIGHT
---------
Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
HELP
end
def main
type, name, params = parse_args(command_line.args)
raise "You cannot edit a remote host" if options[:edit] and @host
resources = find_or_save_resources(type, name, params)
text = resources.
map { |resource| resource.prune_parameters(:parameters_to_include => @extra_params).to_manifest }.
join("\n")
options[:edit] ?
handle_editing(text) :
(puts text)
end
def setup
Puppet::Util::Log.newdestination(:console)
set_log_level
end
private
def remote_key(type, name)
Puppet::Resource.indirection.terminus_class = :rest
port = Puppet[:puppetport]
["https://#{@host}:#{port}", "production", "resources", type, name].join('/')
end
def local_key(type, name)
[type, name].join('/')
end
def handle_editing(text)
require 'tempfile'
# Prefer the current directory, which is more likely to be secure
# and, in the case of interactive use, accessible to the user.
tmpfile = Tempfile.new('x2puppet', Dir.pwd)
begin
# sync write, so nothing buffers before we invoke the editor.
tmpfile.sync = true
tmpfile.puts text
# edit the content
system(ENV["EDITOR"] || 'vi', tmpfile.path)
# ...and, now, pass that file to puppet to apply. Because
# many editors rename or replace the original file we need to
# feed the pathname, not the file content itself, to puppet.
system('puppet apply -v ' + tmpfile.path)
ensure
# The temporary file will be safely removed.
tmpfile.close(true)
end
end
def parse_args(args)
type = args.shift or raise "You must specify the type to display"
Puppet::Type.type(type) or raise "Could not find type #{type}"
name = args.shift
params = {}
args.each do |setting|
if setting =~ /^(\w+)=(.+)$/
params[$1] = $2
else
raise "Invalid parameter setting #{setting}"
end
end
[type, name, params]
end
def find_or_save_resources(type, name, params)
key = @host ? remote_key(type, name) : local_key(type, name)
if name
if params.empty?
[ Puppet::Resource.indirection.find( key ) ]
else
resource = Puppet::Resource.new( type, name, :parameters => params )
# save returns [resource that was saved, transaction log from applying the resource]
save_result = Puppet::Resource.indirection.save(resource, key)
[ save_result.first ]
end
else
if type == "file"
raise "Listing all file instances is not supported. Please specify a file or directory, e.g. puppet resource file /etc"
end
Puppet::Resource.indirection.search( key, {} )
end
end
end
puppet-3.4.3/lib/puppet/application/kick.rb 0000644 0052762 0001160 00000022443 12300765631 020572 0 ustar jenkins jenkins require 'puppet/application'
class Puppet::Application::Kick < Puppet::Application
attr_accessor :hosts, :tags, :classes
option("--all","-a")
option("--foreground","-f")
option("--debug","-d")
option("--ping","-P")
option("--test")
option("--ignoreschedules")
option("--host HOST") do |arg|
@hosts << arg
end
option("--tag TAG", "-t") do |arg|
@tags << arg
end
option("--class CLASS", "-c") do |arg|
@classes << arg
end
option("--no-fqdn", "-n") do |arg|
options[:fqdn] = false
end
option("--parallel PARALLEL", "-p") do |arg|
begin
options[:parallel] = Integer(arg)
rescue
$stderr.puts "Could not convert #{arg.inspect} to an integer"
exit(23)
end
end
def help
<<-'HELP'
puppet-kick(8) -- Remotely control puppet agent
========
SYNOPSIS
--------
Trigger a puppet agent run on a set of hosts.
USAGE
-----
puppet kick [-a|--all] [-c|--class ] [-d|--debug] [-f|--foreground]
[-h|--help] [--host ] [--no-fqdn] [--ignoreschedules]
[-t|--tag ] [--test] [-p|--ping] [ [...]]
DESCRIPTION
-----------
This script can be used to connect to a set of machines running 'puppet
agent' and trigger them to run their configurations. The most common
usage would be to specify a class of hosts and a set of tags, and
'puppet kick' would look up in LDAP all of the hosts matching that
class, then connect to each host and trigger a run of all of the objects
with the specified tags.
If you are not storing your host configurations in LDAP, you can specify
hosts manually.
You will most likely have to run 'puppet kick' as root to get access to
the SSL certificates.
'puppet kick' reads 'puppet master''s configuration file, so that it can
copy things like LDAP settings.
USAGE NOTES
-----------
Puppet kick needs the puppet agent on the target machine to be running as a
daemon, be configured to listen for incoming network connections, and have an
appropriate security configuration.
The specific changes required are:
* Set `listen = true` in the agent's `puppet.conf` file (or `--listen` on the
command line)
* Configure the node's firewall to allow incoming connections on port 8139
* Insert the following stanza at the top of the node's `auth.conf` file:
# Allow puppet kick access
path /run
method save
auth any
allow workstation.example.com
This example would allow the machine `workstation.example.com` to trigger a
Puppet run; adjust the "allow" directive to suit your site. You may also use
`allow *` to allow anyone to trigger a Puppet run, but that makes it possible
to interfere with your site by triggering excessive Puppet runs.
See `http://docs.puppetlabs.com/guides/rest_auth_conf.html` for more details
about security settings.
OPTIONS
-------
Note that any configuration parameter that's valid in the configuration
file is also a valid long argument. For example, 'ssldir' is a valid
configuration parameter, so you can specify '--ssldir ' as an
argument.
See the configuration file documentation at
http://docs.puppetlabs.com/references/latest/configuration.html for
the full list of acceptable parameters. A commented list of all
configuration options can also be generated by running puppet master
with '--genconfig'.
* --all:
Connect to all available hosts. Requires LDAP support at this point.
* --class:
Specify a class of machines to which to connect. This only works if
you have LDAP configured, at the moment.
* --debug:
Enable full debugging.
* --foreground:
Run each configuration in the foreground; that is, when connecting to
a host, do not return until the host has finished its run. The default
is false.
* --help:
Print this help message
* --host:
A specific host to which to connect. This flag can be specified more
than once.
* --ignoreschedules:
Whether the client should ignore schedules when running its
configuration. This can be used to force the client to perform work it
would not normally perform so soon. The default is false.
* --parallel:
How parallel to make the connections. Parallelization is provided by
forking for each client to which to connect. The default is 1, meaning
serial execution.
* --puppetport:
Use the specified TCP port to connect to agents. Defaults to 8139.
* --tag:
Specify a tag for selecting the objects to apply. Does not work with
the --test option.
* --test:
Print the hosts you would connect to but do not actually connect. This
option requires LDAP support at this point.
* --ping:
Do an ICMP echo against the target host. Skip hosts that don't respond
to ping.
EXAMPLE
-------
$ sudo puppet kick -p 10 -t remotefile -t webserver host1 host2
AUTHOR
------
Luke Kanies
COPYRIGHT
---------
Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
HELP
end
def run_command
@hosts += command_line.args
options[:test] ? test : main
end
def test
puts "Skipping execution in test mode"
exit(0)
end
def main
Puppet.warning "Failed to load ruby LDAP library. LDAP functionality will not be available" unless Puppet.features.ldap?
require 'puppet/util/ldap/connection'
todo = @hosts.dup
failures = []
# Now do the actual work
go = true
while go
# If we don't have enough children in process and we still have hosts left to
# do, then do the next host.
if @children.length < options[:parallel] and ! todo.empty?
host = todo.shift
pid = safe_posix_fork do
run_for_host(host)
end
@children[pid] = host
else
# Else, see if we can reap a process.
begin
pid = Process.wait
if host = @children[pid]
# Remove our host from the list of children, so the parallelization
# continues working.
@children.delete(pid)
failures << host if $CHILD_STATUS.exitstatus != 0
print "#{host} finished with exit code #{$CHILD_STATUS.exitstatus}\n"
else
$stderr.puts "Could not find host for PID #{pid} with status #{$CHILD_STATUS.exitstatus}"
end
rescue Errno::ECHILD
# There are no children left, so just exit unless there are still
# children left to do.
next unless todo.empty?
if failures.empty?
puts "Finished"
exit(0)
else
puts "Failed: #{failures.join(", ")}"
exit(3)
end
end
end
end
end
def run_for_host(host)
if options[:ping]
%x{ping -c 1 #{host}}
unless $CHILD_STATUS == 0
$stderr.print "Could not contact #{host}\n"
exit($CHILD_STATUS)
end
end
require 'puppet/run'
Puppet::Run.indirection.terminus_class = :rest
port = Puppet[:puppetport]
url = ["https://#{host}:#{port}", "production", "run", host].join('/')
print "Triggering #{host}\n"
begin
run_options = {
:tags => @tags,
:background => ! options[:foreground],
:ignoreschedules => options[:ignoreschedules]
}
run = Puppet::Run.indirection.save(Puppet::Run.new( run_options ), url)
puts "Getting status"
result = run.status
puts "status is #{result}"
rescue => detail
Puppet.log_exception(detail, "Host #{host} failed: #{detail}\n")
exit(2)
end
case result
when "success";
exit(0)
when "running"
$stderr.puts "Host #{host} is already running"
exit(3)
else
$stderr.puts "Host #{host} returned unknown answer '#{result}'"
exit(12)
end
end
def initialize(*args)
super
@hosts = []
@classes = []
@tags = []
end
def preinit
[:INT, :TERM].each do |signal|
Signal.trap(signal) do
$stderr.puts "Cancelling"
exit(1)
end
end
options[:parallel] = 1
options[:verbose] = true
options[:fqdn] = true
options[:ignoreschedules] = false
options[:foreground] = false
end
def setup
super()
raise Puppet::Error.new("Puppet kick is not supported on Microsoft Windows") if Puppet.features.microsoft_windows?
Puppet.warning "Puppet kick is deprecated. See http://links.puppetlabs.com/puppet-kick-deprecation"
if options[:debug]
Puppet::Util::Log.level = :debug
else
Puppet::Util::Log.level = :info
end
if Puppet[:node_terminus] == :ldap and (options[:all] or @classes)
if options[:all]
@hosts = Puppet::Node.indirection.search("whatever", :fqdn => options[:fqdn]).collect { |node| node.name }
puts "all: #{@hosts.join(", ")}"
else
@hosts = []
@classes.each do |klass|
list = Puppet::Node.indirection.search("whatever", :fqdn => options[:fqdn], :class => klass).collect { |node| node.name }
puts "#{klass}: #{list.join(", ")}"
@hosts += list
end
end
elsif ! @classes.empty?
$stderr.puts "You must be using LDAP to specify host classes"
exit(24)
end
@children = {}
# If we get a signal, then kill all of our children and get out.
[:INT, :TERM].each do |signal|
Signal.trap(signal) do
Puppet.notice "Caught #{signal}; shutting down"
@children.each do |pid, host|
Process.kill("INT", pid)
end
waitall
exit(1)
end
end
end
end
puppet-3.4.3/lib/puppet/application/face_base.rb 0000644 0052762 0001160 00000021323 12300765631 021535 0 ustar jenkins jenkins require 'puppet/application'
require 'puppet/face'
require 'optparse'
require 'pp'
class Puppet::Application::FaceBase < Puppet::Application
option("--debug", "-d") do |arg|
Puppet::Util::Log.level = :debug
end
option("--verbose", "-v") do |_|
Puppet::Util::Log.level = :info
end
option("--render-as FORMAT") do |format|
self.render_as = format.to_sym
end
attr_accessor :face, :action, :type, :arguments, :render_as
def render_as=(format)
if format == :json then
@render_as = Puppet::Network::FormatHandler.format(:pson)
else
@render_as = Puppet::Network::FormatHandler.format(format)
end
@render_as or raise ArgumentError, "I don't know how to render '#{format}'"
end
def render(result, args_and_options)
hook = action.when_rendering(render_as.name)
if hook
# when defining when_rendering on your action you can optionally
# include arguments and options
if hook.arity > 1
result = hook.call(result, *args_and_options)
else
result = hook.call(result)
end
end
render_as.render(result)
end
def preinit
super
Signal.trap(:INT) do
$stderr.puts "Cancelling Face"
exit(0)
end
end
def parse_options
# We need to parse enough of the command line out early, to identify what
# the action is, so that we can obtain the full set of options to parse.
# REVISIT: These should be configurable versions, through a global
# '--version' option, but we don't implement that yet... --daniel 2011-03-29
@type = Puppet::Util::ConstantInflector.constant2file(self.class.name.to_s.sub(/.+:/, '')).to_sym
@face = Puppet::Face[@type, :current]
# Now, walk the command line and identify the action. We skip over
# arguments based on introspecting the action and all, and find the first
# non-option word to use as the action.
action_name = nil
index = -1
until action_name or (index += 1) >= command_line.args.length do
item = command_line.args[index]
if item =~ /^-/ then
option = @face.options.find do |name|
item =~ /^-+#{name.to_s.gsub(/[-_]/, '[-_]')}(?:[ =].*)?$/
end
if option then
option = @face.get_option(option)
# If we have an inline argument, just carry on. We don't need to
# care about optional vs mandatory in that case because we do a real
# parse later, and that will totally take care of raising the error
# when we get there. --daniel 2011-04-04
if option.takes_argument? and !item.index('=') then
index += 1 unless
(option.optional_argument? and command_line.args[index + 1] =~ /^-/)
end
elsif option = find_global_settings_argument(item) then
unless Puppet.settings.boolean? option.name then
# As far as I can tell, we treat non-bool options as always having
# a mandatory argument. --daniel 2011-04-05
# ... But, the mandatory argument will not be the next item if an = is
# employed in the long form of the option. --jeffmccune 2012-09-18
index += 1 unless item =~ /^--#{option.name}=/
end
elsif option = find_application_argument(item) then
index += 1 if (option[:argument] and not option[:optional])
else
raise OptionParser::InvalidOption.new(item.sub(/=.*$/, ''))
end
else
# Stash away the requested action name for later, and try to fetch the
# action object it represents; if this is an invalid action name that
# will be nil, and handled later.
action_name = item.to_sym
@action = Puppet::Face.find_action(@face.name, action_name)
@face = @action.face if @action
end
end
if @action.nil?
if @action = @face.get_default_action() then
@is_default_action = true
else
face = @face.name
action = action_name.nil? ? 'default' : "'#{action_name}'"
msg = "'#{face}' has no #{action} action. See `puppet help #{face}`."
Puppet.err(msg)
Puppet::Util::Log.force_flushqueue()
exit false
end
end
# Now we can interact with the default option code to build behaviour
# around the full set of options we now know we support.
@action.options.each do |option|
option = @action.get_option(option) # make it the object.
self.class.option(*option.optparse) # ...and make the CLI parse it.
end
# ...and invoke our parent to parse all the command line options.
super
end
def find_global_settings_argument(item)
Puppet.settings.each do |name, object|
object.optparse_args.each do |arg|
next unless arg =~ /^-/
# sadly, we have to emulate some of optparse here...
pattern = /^#{arg.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
pattern.match item and return object
end
end
return nil # nothing found.
end
def find_application_argument(item)
self.class.option_parser_commands.each do |options, function|
options.each do |option|
next unless option =~ /^-/
pattern = /^#{option.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
next unless pattern.match(item)
return {
:argument => option =~ /[ =]/,
:optional => option =~ /[ =]\[/
}
end
end
return nil # not found
end
def setup
Puppet::Util::Log.newdestination :console
@arguments = command_line.args
# Note: because of our definition of where the action is set, we end up
# with it *always* being the first word of the remaining set of command
# line arguments. So, strip that off when we construct the arguments to
# pass down to the face action. --daniel 2011-04-04
# Of course, now that we have default actions, we should leave the
# "action" name on if we didn't actually consume it when we found our
# action.
@arguments.delete_at(0) unless @is_default_action
# We copy all of the app options to the end of the call; This allows each
# action to read in the options. This replaces the older model where we
# would invoke the action with options set as global state in the
# interface object. --daniel 2011-03-28
@arguments << options
# If we don't have a rendering format, set one early.
self.render_as ||= (@action.render_as || :console)
end
def main
status = false
# Call the method associated with the provided action (e.g., 'find').
unless @action
puts Puppet::Face[:help, :current].help(@face.name)
raise "#{face} does not respond to action #{arguments.first}"
end
# We need to do arity checking here because this is generic code
# calling generic methods – that have argument defaulting. We need to
# make sure we don't accidentally pass the options as the first
# argument to a method that takes one argument. eg:
#
# puppet facts find
# => options => {}
# @arguments => [{}]
# => @face.send :bar, {}
#
# def face.bar(argument, options = {})
# => bar({}, {}) # oops! we thought the options were the
# # positional argument!!
#
# We could also fix this by making it mandatory to pass the options on
# every call, but that would make the Ruby API much more annoying to
# work with; having the defaulting is a much nicer convention to have.
#
# We could also pass the arguments implicitly, by having a magic
# 'options' method that was visible in the scope of the action, which
# returned the right stuff.
#
# That sounds attractive, but adds complications to all sorts of
# things, especially when you think about how to pass options when you
# are writing Ruby code that calls multiple faces. Especially if
# faces are involved in that. ;)
#
# --daniel 2011-04-27
if (arity = @action.positional_arg_count) > 0
unless (count = arguments.length) == arity then
s = arity == 2 ? '' : 's'
raise ArgumentError, "puppet #{@face.name} #{@action.name} takes #{arity-1} argument#{s}, but you gave #{count-1}"
end
end
result = @face.send(@action.name, *arguments)
puts render(result, arguments) unless result.nil?
status = true
# We need an easy way for the action to set a specific exit code, so we
# rescue SystemExit here; This allows each action to set the desired exit
# code by simply calling Kernel::exit. eg:
#
# exit(2)
#
# --kelsey 2012-02-14
rescue SystemExit => detail
status = detail.status
rescue => detail
Puppet.log_exception(detail)
Puppet.err "Try 'puppet help #{@face.name} #{@action.name}' for usage"
ensure
exit status
end
end
puppet-3.4.3/lib/puppet/pops.rb 0000644 0052762 0001160 00000005156 12300765631 016331 0 ustar jenkins jenkins module Puppet
module Pops
require 'puppet/pops/patterns'
require 'puppet/pops/utils'
require 'puppet/pops/adaptable'
require 'puppet/pops/adapters'
require 'puppet/pops/visitable'
require 'puppet/pops/visitor'
require 'puppet/pops/containment'
require 'puppet/pops/issues'
require 'puppet/pops/label_provider'
require 'puppet/pops/validation'
require 'puppet/pops/issue_reporter'
require 'puppet/pops/model/model'
module Types
require 'puppet/pops/types/types'
require 'puppet/pops/types/type_calculator'
require 'puppet/pops/types/type_factory'
require 'puppet/pops/types/type_parser'
require 'puppet/pops/types/class_loader'
end
module Model
require 'puppet/pops/model/tree_dumper'
require 'puppet/pops/model/ast_transformer'
require 'puppet/pops/model/ast_tree_dumper'
require 'puppet/pops/model/factory'
require 'puppet/pops/model/model_tree_dumper'
require 'puppet/pops/model/model_label_provider'
end
module Binder
module SchemeHandler
# the handlers are auto loaded via bindings
end
module Producers
require 'puppet/pops/binder/producers'
end
require 'puppet/pops/binder/binder'
require 'puppet/pops/binder/bindings_model'
require 'puppet/pops/binder/binder_issues'
require 'puppet/pops/binder/bindings_checker'
require 'puppet/pops/binder/bindings_factory'
require 'puppet/pops/binder/bindings_label_provider'
require 'puppet/pops/binder/bindings_validator_factory'
require 'puppet/pops/binder/injector_entry'
require 'puppet/pops/binder/key_factory'
require 'puppet/pops/binder/injector'
require 'puppet/pops/binder/hiera2'
require 'puppet/pops/binder/bindings_composer'
require 'puppet/pops/binder/bindings_model_dumper'
require 'puppet/pops/binder/system_bindings'
require 'puppet/pops/binder/bindings_loader'
module Config
require 'puppet/pops/binder/config/binder_config'
require 'puppet/pops/binder/config/binder_config_checker'
require 'puppet/pops/binder/config/issues'
require 'puppet/pops/binder/config/diagnostic_producer'
end
end
module Parser
require 'puppet/pops/parser/eparser'
require 'puppet/pops/parser/parser_support'
require 'puppet/pops/parser/lexer'
require 'puppet/pops/parser/evaluating_parser'
end
module Validation
require 'puppet/pops/validation/checker3_1'
require 'puppet/pops/validation/validator_factory_3_1'
end
end
require 'puppet/bindings'
end
puppet-3.4.3/lib/puppet/util.rb 0000644 0052762 0001160 00000041174 12300765631 016325 0 ustar jenkins jenkins # A module to collect utility functions.
require 'English'
require 'puppet/error'
require 'puppet/util/execution_stub'
require 'uri'
require 'tempfile'
require 'pathname'
require 'ostruct'
require 'puppet/util/platform'
require 'puppet/util/symbolic_file_mode'
require 'securerandom'
module Puppet
module Util
require 'puppet/util/monkey_patches'
require 'benchmark'
# These are all for backward compatibility -- these are methods that used
# to be in Puppet::Util but have been moved into external modules.
require 'puppet/util/posix'
extend Puppet::Util::POSIX
extend Puppet::Util::SymbolicFileMode
def self.activerecord_version
if (defined?(::ActiveRecord) and defined?(::ActiveRecord::VERSION) and defined?(::ActiveRecord::VERSION::MAJOR) and defined?(::ActiveRecord::VERSION::MINOR))
([::ActiveRecord::VERSION::MAJOR, ::ActiveRecord::VERSION::MINOR].join('.').to_f)
else
0
end
end
# Run some code with a specific environment. Resets the environment back to
# what it was at the end of the code.
def self.withenv(hash)
saved = ENV.to_hash
hash.each do |name, val|
ENV[name.to_s] = val
end
yield
ensure
ENV.clear
saved.each do |name, val|
ENV[name] = val
end
end
# Execute a given chunk of code with a new umask.
def self.withumask(mask)
cur = File.umask(mask)
begin
yield
ensure
File.umask(cur)
end
end
# Change the process to a different user
def self.chuser
if group = Puppet[:group]
begin
Puppet::Util::SUIDManager.change_group(group, true)
rescue => detail
Puppet.warning "could not change to group #{group.inspect}: #{detail}"
$stderr.puts "could not change to group #{group.inspect}"
# Don't exit on failed group changes, since it's
# not fatal
#exit(74)
end
end
if user = Puppet[:user]
begin
Puppet::Util::SUIDManager.change_user(user, true)
rescue => detail
$stderr.puts "Could not change to user #{user}: #{detail}"
exit(74)
end
end
end
# Create instance methods for each of the log levels. This allows
# the messages to be a little richer. Most classes will be calling this
# method.
def self.logmethods(klass, useself = true)
Puppet::Util::Log.eachlevel { |level|
klass.send(:define_method, level, proc { |args|
args = args.join(" ") if args.is_a?(Array)
if useself
Puppet::Util::Log.create(
:level => level,
:source => self,
:message => args
)
else
Puppet::Util::Log.create(
:level => level,
:message => args
)
end
})
}
end
# Proxy a bunch of methods to another object.
def self.classproxy(klass, objmethod, *methods)
classobj = class << klass; self; end
methods.each do |method|
classobj.send(:define_method, method) do |*args|
obj = self.send(objmethod)
obj.send(method, *args)
end
end
end
# Proxy a bunch of methods to another object.
def self.proxy(klass, objmethod, *methods)
methods.each do |method|
klass.send(:define_method, method) do |*args|
obj = self.send(objmethod)
obj.send(method, *args)
end
end
end
def benchmark(*args)
msg = args.pop
level = args.pop
object = nil
if args.empty?
if respond_to?(level)
object = self
else
object = Puppet
end
else
object = args.pop
end
raise Puppet::DevError, "Failed to provide level to :benchmark" unless level
unless level == :none or object.respond_to? level
raise Puppet::DevError, "Benchmarked object does not respond to #{level}"
end
# Only benchmark if our log level is high enough
if level != :none and Puppet::Util::Log.sendlevel?(level)
seconds = Benchmark.realtime {
yield
}
object.send(level, msg + (" in %0.2f seconds" % seconds))
return seconds
else
yield
end
end
module_function :benchmark
# Resolve a path for an executable to the absolute path. This tries to behave
# in the same manner as the unix `which` command and uses the `PATH`
# environment variable.
#
# @api public
# @param bin [String] the name of the executable to find.
# @return [String] the absolute path to the found executable.
def which(bin)
if absolute_path?(bin)
return bin if FileTest.file? bin and FileTest.executable? bin
else
ENV['PATH'].split(File::PATH_SEPARATOR).each do |dir|
begin
dest = File.expand_path(File.join(dir, bin))
rescue ArgumentError => e
# if the user's PATH contains a literal tilde (~) character and HOME is not set, we may get
# an ArgumentError here. Let's check to see if that is the case; if not, re-raise whatever error
# was thrown.
if e.to_s =~ /HOME/ and (ENV['HOME'].nil? || ENV['HOME'] == "")
# if we get here they have a tilde in their PATH. We'll issue a single warning about this and then
# ignore this path element and carry on with our lives.
Puppet::Util::Warnings.warnonce("PATH contains a ~ character, and HOME is not set; ignoring PATH element '#{dir}'.")
elsif e.to_s =~ /doesn't exist|can't find user/
# ...otherwise, we just skip the non-existent entry, and do nothing.
Puppet::Util::Warnings.warnonce("Couldn't expand PATH containing a ~ character; ignoring PATH element '#{dir}'.")
else
raise
end
else
if Puppet.features.microsoft_windows? && File.extname(dest).empty?
exts = ENV['PATHEXT']
exts = exts ? exts.split(File::PATH_SEPARATOR) : %w[.COM .EXE .BAT .CMD]
exts.each do |ext|
destext = File.expand_path(dest + ext)
return destext if FileTest.file? destext and FileTest.executable? destext
end
end
return dest if FileTest.file? dest and FileTest.executable? dest
end
end
end
nil
end
module_function :which
# Determine in a platform-specific way whether a path is absolute. This
# defaults to the local platform if none is specified.
#
# Escape once for the string literal, and once for the regex.
slash = '[\\\\/]'
label = '[^\\\\/]+'
AbsolutePathWindows = %r!^(?:(?:[A-Z]:#{slash})|(?:#{slash}#{slash}#{label}#{slash}#{label})|(?:#{slash}#{slash}\?#{slash}#{label}))!io
AbsolutePathPosix = %r!^/!
def absolute_path?(path, platform=nil)
# Ruby only sets File::ALT_SEPARATOR on Windows and the Ruby standard
# library uses that to test what platform it's on. Normally in Puppet we
# would use Puppet.features.microsoft_windows?, but this method needs to
# be called during the initialization of features so it can't depend on
# that.
platform ||= Puppet::Util::Platform.windows? ? :windows : :posix
regex = case platform
when :windows
AbsolutePathWindows
when :posix
AbsolutePathPosix
else
raise Puppet::DevError, "unknown platform #{platform} in absolute_path"
end
!! (path =~ regex)
end
module_function :absolute_path?
# Convert a path to a file URI
def path_to_uri(path)
return unless path
params = { :scheme => 'file' }
if Puppet.features.microsoft_windows?
path = path.gsub(/\\/, '/')
if unc = /^\/\/([^\/]+)(\/.+)/.match(path)
params[:host] = unc[1]
path = unc[2]
elsif path =~ /^[a-z]:\//i
path = '/' + path
end
end
params[:path] = URI.escape(path)
begin
URI::Generic.build(params)
rescue => detail
raise Puppet::Error, "Failed to convert '#{path}' to URI: #{detail}"
end
end
module_function :path_to_uri
# Get the path component of a URI
def uri_to_path(uri)
return unless uri.is_a?(URI)
path = URI.unescape(uri.path)
if Puppet.features.microsoft_windows? and uri.scheme == 'file'
if uri.host
path = "//#{uri.host}" + path # UNC
else
path.sub!(/^\//, '')
end
end
path
end
module_function :uri_to_path
def safe_posix_fork(stdin=$stdin, stdout=$stdout, stderr=$stderr, &block)
child_pid = Kernel.fork do
$stdin.reopen(stdin)
$stdout.reopen(stdout)
$stderr.reopen(stderr)
3.upto(256){|fd| IO::new(fd).close rescue nil}
block.call if block
end
child_pid
end
module_function :safe_posix_fork
def memory
unless defined?(@pmap)
@pmap = which('pmap')
end
if @pmap
%x{#{@pmap} #{Process.pid}| grep total}.chomp.sub(/^\s*total\s+/, '').sub(/K$/, '').to_i
else
0
end
end
def symbolizehash(hash)
newhash = {}
hash.each do |name, val|
name = name.intern if name.respond_to? :intern
newhash[name] = val
end
newhash
end
module_function :symbolizehash
# Just benchmark, with no logging.
def thinmark
seconds = Benchmark.realtime {
yield
}
seconds
end
module_function :memory, :thinmark
# Because IO#binread is only available in 1.9
def binread(file)
Puppet.deprecation_warning("Puppet::Util.binread is deprecated. Read the file without this method as it will be removed in a future version.")
File.open(file, 'rb') { |f| f.read }
end
module_function :binread
# utility method to get the current call stack and format it to a human-readable string (which some IDEs/editors
# will recognize as links to the line numbers in the trace)
def self.pretty_backtrace(backtrace = caller(1))
backtrace.collect do |line|
_, path, rest = /^(.*):(\d+.*)$/.match(line).to_a
# If the path doesn't exist - like in one test, and like could happen in
# the world - we should just tolerate it and carry on. --daniel 2012-09-05
# Also, if we don't match, just include the whole line.
if path
path = Pathname(path).realpath rescue path
"#{path}:#{rest}"
else
line
end
end.join("\n")
end
# Replace a file, securely. This takes a block, and passes it the file
# handle of a file open for writing. Write the replacement content inside
# the block and it will safely replace the target file.
#
# This method will make no changes to the target file until the content is
# successfully written and the block returns without raising an error.
#
# As far as possible the state of the existing file, such as mode, is
# preserved. This works hard to avoid loss of any metadata, but will result
# in an inode change for the file.
#
# Arguments: `filename`, `default_mode`
#
# The filename is the file we are going to replace.
#
# The default_mode is the mode to use when the target file doesn't already
# exist; if the file is present we copy the existing mode/owner/group values
# across. The default_mode can be expressed as an octal integer, a numeric string (ie '0664')
# or a symbolic file mode.
DEFAULT_POSIX_MODE = 0644
DEFAULT_WINDOWS_MODE = nil
def replace_file(file, default_mode, &block)
raise Puppet::DevError, "replace_file requires a block" unless block_given?
if default_mode
unless valid_symbolic_mode?(default_mode)
raise Puppet::DevError, "replace_file default_mode: #{default_mode} is invalid"
end
mode = symbolic_mode_to_int(normalize_symbolic_mode(default_mode))
else
if Puppet.features.microsoft_windows?
mode = DEFAULT_WINDOWS_MODE
else
mode = DEFAULT_POSIX_MODE
end
end
file = Puppet::FileSystem::File.new(file)
tempfile = Tempfile.new(file.basename, file.dir.to_s)
# Set properties of the temporary file before we write the content, because
# Tempfile doesn't promise to be safe from reading by other people, just
# that it avoids races around creating the file.
#
# Our Windows emulation is pretty limited, and so we have to carefully
# and specifically handle the platform, which has all sorts of magic.
# So, unlike Unix, we don't pre-prep security; we use the default "quite
# secure" tempfile permissions instead. Magic happens later.
if !Puppet.features.microsoft_windows?
# Grab the current file mode, and fall back to the defaults.
if file.exist?
stat = file.path.lstat
tempfile.chown(stat.uid, stat.gid)
effective_mode = stat.mode
else
effective_mode = mode
end
if effective_mode
# We only care about the bottom four slots, which make the real mode,
# and not the rest of the platform stat call fluff and stuff.
tempfile.chmod(effective_mode & 07777)
end
end
# OK, now allow the caller to write the content of the file.
yield tempfile
# Now, make sure the data (which includes the mode) is safe on disk.
tempfile.flush
begin
tempfile.fsync
rescue NotImplementedError
# fsync may not be implemented by Ruby on all platforms, but
# there is absolutely no recovery path if we detect that. So, we just
# ignore the return code.
#
# However, don't be fooled: that is accepting that we are running in
# an unsafe fashion. If you are porting to a new platform don't stub
# that out.
end
tempfile.close
if Puppet.features.microsoft_windows?
# Windows ReplaceFile needs a file to exist, so touch handles this
if !file.exist?
file.touch
if mode
Puppet::Util::Windows::Security.set_mode(mode, file.path.to_s)
end
end
# Yes, the arguments are reversed compared to the rename in the rest
# of the world.
Puppet::Util::Windows::File.replace_file(file.path, tempfile.path)
else
File.rename(tempfile.path, file.path.to_s)
end
# Ideally, we would now fsync the directory as well, but Ruby doesn't
# have support for that, and it doesn't matter /that/ much...
# Return something true, and possibly useful.
file.path
end
module_function :replace_file
# Executes a block of code, wrapped with some special exception handling. Causes the ruby interpreter to
# exit if the block throws an exception.
#
# @api public
# @param [String] message a message to log if the block fails
# @param [Integer] code the exit code that the ruby interpreter should return if the block fails
# @yield
def exit_on_fail(message, code = 1)
yield
# First, we need to check and see if we are catching a SystemExit error. These will be raised
# when we daemonize/fork, and they do not necessarily indicate a failure case.
rescue SystemExit => err
raise err
# Now we need to catch *any* other kind of exception, because we may be calling third-party
# code (e.g. webrick), and we have no idea what they might throw.
rescue Exception => err
## NOTE: when debugging spec failures, these two lines can be very useful
#puts err.inspect
#puts Puppet::Util.pretty_backtrace(err.backtrace)
Puppet.log_exception(err, "Could not #{message}: #{err}")
Puppet::Util::Log.force_flushqueue()
exit(code)
end
module_function :exit_on_fail
def deterministic_rand(seed,max)
if defined?(Random) == 'constant' && Random.class == Class
Random.new(seed).rand(max).to_s
else
srand(seed)
result = rand(max).to_s
srand()
result
end
end
module_function :deterministic_rand
#######################################################################################################
# Deprecated methods relating to process execution; these have been moved to Puppet::Util::Execution
#######################################################################################################
def execpipe(command, failonfail = true, &block)
Puppet.deprecation_warning("Puppet::Util.execpipe is deprecated; please use Puppet::Util::Execution.execpipe")
Puppet::Util::Execution.execpipe(command, failonfail, &block)
end
module_function :execpipe
def execfail(command, exception)
Puppet.deprecation_warning("Puppet::Util.execfail is deprecated; please use Puppet::Util::Execution.execfail")
Puppet::Util::Execution.execfail(command, exception)
end
module_function :execfail
def execute(*args)
Puppet.deprecation_warning("Puppet::Util.execute is deprecated; please use Puppet::Util::Execution.execute")
Puppet::Util::Execution.execute(*args)
end
module_function :execute
end
end
require 'puppet/util/errors'
require 'puppet/util/methodhelper'
require 'puppet/util/metaid'
require 'puppet/util/classgen'
require 'puppet/util/docs'
require 'puppet/util/execution'
require 'puppet/util/logging'
require 'puppet/util/package'
require 'puppet/util/warnings'
puppet-3.4.3/lib/puppet/scheduler.rb 0000644 0052762 0001160 00000000636 12300765631 017324 0 ustar jenkins jenkins module Puppet::Scheduler
require 'puppet/scheduler/job'
require 'puppet/scheduler/splay_job'
require 'puppet/scheduler/scheduler'
require 'puppet/scheduler/timer'
module_function
def create_job(interval, splay=false, splay_limit=0, &block)
if splay
Puppet::Scheduler::SplayJob.new(interval, splay_limit, &block)
else
Puppet::Scheduler::Job.new(interval, &block)
end
end
end
puppet-3.4.3/lib/puppet/parser.rb 0000644 0052762 0001160 00000000225 12300765631 016634 0 ustar jenkins jenkins # @api public
module Puppet::Parser; end
require 'puppet/parser/parser'
require 'puppet/parser/compiler'
require 'puppet/resource/type_collection'
puppet-3.4.3/lib/puppet/node.rb 0000644 0052762 0001160 00000010207 12300765631 016266 0 ustar jenkins jenkins require 'puppet/indirector'
# A class for managing nodes, including their facts and environment.
class Puppet::Node
require 'puppet/node/facts'
require 'puppet/node/environment'
# Set up indirection, so that nodes can be looked for in
# the node sources.
extend Puppet::Indirector
# Adds the environment getter and setter, with some instance/string conversion
include Puppet::Node::Environment::Helper
# Use the node source as the indirection terminus.
indirects :node, :terminus_setting => :node_terminus, :doc => "Where to find node information.
A node is composed of its name, its facts, and its environment."
attr_accessor :name, :classes, :source, :ipaddress, :parameters, :trusted_data
attr_reader :time, :facts
::PSON.register_document_type('Node',self)
def self.from_pson(pson)
raise ArgumentError, "No name provided in serialized data" unless name = pson['name']
node = new(name)
node.classes = pson['classes']
node.parameters = pson['parameters']
node.environment = pson['environment']
node
end
def to_data_hash
result = {
'name' => name,
'environment' => environment.name,
}
result['classes'] = classes unless classes.empty?
result['parameters'] = parameters unless parameters.empty?
result
end
def to_pson_data_hash(*args)
{
'document_type' => "Node",
'data' => to_data_hash,
}
end
def to_pson(*args)
to_pson_data_hash.to_pson(*args)
end
def environment
return super if @environment
if env = parameters["environment"]
self.environment = env
return super
end
# Else, return the default
Puppet::Node::Environment.new
end
def initialize(name, options = {})
raise ArgumentError, "Node names cannot be nil" unless name
@name = name
if classes = options[:classes]
if classes.is_a?(String)
@classes = [classes]
else
@classes = classes
end
else
@classes = []
end
@parameters = options[:parameters] || {}
@facts = options[:facts]
if env = options[:environment]
self.environment = env
end
@time = Time.now
end
# Merge the node facts with parameters from the node source.
def fact_merge
if @facts = Puppet::Node::Facts.indirection.find(name, :environment => environment)
@facts.sanitize
merge(@facts.values)
end
rescue => detail
error = Puppet::Error.new("Could not retrieve facts for #{name}: #{detail}")
error.set_backtrace(detail.backtrace)
raise error
end
# Merge any random parameters into our parameter list.
def merge(params)
params.each do |name, value|
@parameters[name] = value unless @parameters.include?(name)
end
@parameters["environment"] ||= self.environment.name.to_s
end
# Calculate the list of names we might use for looking
# up our node. This is only used for AST nodes.
def names
return [name] if Puppet.settings[:strict_hostname_checking]
names = []
names += split_name(name) if name.include?(".")
# First, get the fqdn
unless fqdn = parameters["fqdn"]
if parameters["hostname"] and parameters["domain"]
fqdn = parameters["hostname"] + "." + parameters["domain"]
else
Puppet.warning "Host is missing hostname and/or domain: #{name}"
end
end
# Now that we (might) have the fqdn, add each piece to the name
# list to search, in order of longest to shortest.
names += split_name(fqdn) if fqdn
# And make sure the node name is first, since that's the most
# likely usage.
# The name is usually the Certificate CN, but it can be
# set to the 'facter' hostname instead.
if Puppet[:node_name] == 'cert'
names.unshift name
else
names.unshift parameters["hostname"]
end
names.uniq
end
def split_name(name)
list = name.split(".")
tmp = []
list.each_with_index do |short, i|
tmp << list[0..i].join(".")
end
tmp.reverse
end
# Ensures the data is frozen
#
def trusted_data=(data)
Puppet.warning("Trusted node data modified for node #{name}") unless @trusted_data.nil?
@trusted_data = data.freeze
end
end
puppet-3.4.3/lib/puppet/file_collection/ 0000755 0052762 0001160 00000000000 12300765640 020146 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/file_collection/lookup.rb 0000644 0052762 0001160 00000000603 12300765631 022003 0 ustar jenkins jenkins require 'puppet/file_collection'
module Puppet::FileCollection::Lookup
# Yeah, this is all the external interface that was added to the folks who
# included this really was. Thankfully.
#
# See the comments in `puppet/file_collection.rb` for the annotated version,
# or just port your code away from this by adding the accessors on your own.
attr_accessor :line, :file
end
puppet-3.4.3/lib/puppet/dsl/ 0000755 0052762 0001160 00000000000 12300765640 015576 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/dsl/resource_api.rb 0000644 0052762 0001160 00000005512 12300765631 020606 0 ustar jenkins jenkins # This module adds functionality to a resource to make it
# capable of evaluating the DSL resource type block and also
# hooking into the scope system.
require 'puppet/resource/type_collection_helper'
class Puppet::DSL::ResourceAPI
include Puppet::Resource::TypeCollectionHelper
FUNCTION_MAP = {:acquire => :include}
attr_reader :scope, :resource, :block
def environment
scope.environment
end
def evaluate
set_instance_variables
instance_eval(&block)
end
def initialize(resource, scope, block)
@scope = scope
@resource = resource
@block = block
end
# Try to convert a missing method into a resource type or a function.
def method_missing(name, *args)
raise "MethodMissing loop when searching for #{name} with #{args.inspect}" if searching_for_method?
@searching_for_method = true
return create_resource(name, args[0], args[1]) if valid_type?(name)
name = map_function(name)
return call_function(name, args) if Puppet::Parser::Functions.function(name)
super
ensure
@searching_for_method = false
end
def set_instance_variables
resource.eachparam do |param|
instance_variable_set("@#{param.name}", param.value)
end
@title = resource.title
@name ||= resource.title
end
def create_resource(type, names, arguments = nil)
names = [names] unless names.is_a?(Array)
arguments ||= {}
raise ArgumentError, "Resource arguments must be provided as a hash" unless arguments.is_a?(Hash)
names.collect do |name|
resource = Puppet::Parser::Resource.new(type, name, :scope => scope)
arguments.each do |param, value|
resource[param] = value
end
resource.exported = true if exporting?
resource.virtual = true if virtualizing?
scope.compiler.add_resource(scope, resource)
resource
end
end
def call_function(name, args)
return false unless method = Puppet::Parser::Functions.function(name)
scope.send(method, *args)
end
def export(resources = nil, &block)
if resources
resources.each { |resource| resource.exported = true }
return resources
end
@exporting = true
instance_eval(&block)
ensure
@exporting = false
end
def virtual(resources = nil, &block)
if resources
resources.each { |resource| resource.virtual = true }
return resources
end
@virtualizing = true
instance_eval(&block)
ensure
@virtualizing = false
end
def valid_type?(name)
return true if [:class, :node].include?(name)
return true if Puppet::Type.type(name)
return(known_resource_types.definition(name) ? true : false)
end
private
def exporting?
@exporting
end
def map_function(name)
FUNCTION_MAP[name] || name
end
def searching_for_method?
@searching_for_method
end
def virtualizing?
@virtualizing
end
end
puppet-3.4.3/lib/puppet/dsl/resource_type_api.rb 0000644 0052762 0001160 00000001661 12300765631 021650 0 ustar jenkins jenkins require 'puppet/resource/type'
# Type of the objects inside of which pure ruby manifest files are
# executed. Provides methods for creating defines, hostclasses, and
# nodes.
class Puppet::DSL::ResourceTypeAPI
def initialize
@__created_ast_objects__ = []
end
def define(name, *args, &block)
args = args.inject([]) do |result, item|
if item.is_a?(Hash)
item.each { |p, v| result << [p, v] }
else
result << item
end
result
end
@__created_ast_objects__.push Puppet::Parser::AST::Definition.new(name, {:arguments => args}, &block)
nil
end
def hostclass(name, options = {}, &block)
@__created_ast_objects__.push Puppet::Parser::AST::Hostclass.new(name, options, &block)
nil
end
def node(name, options = {}, &block)
name = [name] unless name.is_a?(Array)
@__created_ast_objects__.push Puppet::Parser::AST::Node.new(name, options, &block)
nil
end
end
puppet-3.4.3/lib/puppet/file_serving/ 0000755 0052762 0001160 00000000000 12300765640 017470 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/file_serving/terminus_helper.rb 0000644 0052762 0001160 00000001414 12300765631 023222 0 ustar jenkins jenkins require 'puppet/file_serving'
require 'puppet/file_serving/fileset'
# Define some common methods for FileServing termini.
module Puppet::FileServing::TerminusHelper
# Create model instances for all files in a fileset.
def path2instances(request, *paths)
filesets = paths.collect do |path|
# Filesets support indirector requests as an options collection
Puppet::FileServing::Fileset.new(path, request)
end
Puppet::FileServing::Fileset.merge(*filesets).collect do |file, base_path|
inst = model.new(base_path, :relative_path => file)
inst.checksum_type = request.options[:checksum_type] if request.options[:checksum_type]
inst.links = request.options[:links] if request.options[:links]
inst.collect
inst
end
end
end
puppet-3.4.3/lib/puppet/file_serving/mount/ 0000755 0052762 0001160 00000000000 12300765640 020632 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/file_serving/mount/modules.rb 0000644 0052762 0001160 00000001145 12300765631 022630 0 ustar jenkins jenkins require 'puppet/file_serving/mount'
# This is the modules-specific mount: it knows how to search through
# modules for files. Yay.
class Puppet::FileServing::Mount::Modules < Puppet::FileServing::Mount
# Return an instance of the appropriate class.
def find(path, request)
raise "No module specified" if path.to_s.empty?
module_name, relative_path = path.split("/", 2)
return nil unless mod = request.environment.module(module_name)
mod.file(relative_path)
end
def search(path, request)
if result = find(path, request)
[result]
end
end
def valid?
true
end
end
puppet-3.4.3/lib/puppet/file_serving/mount/pluginfacts.rb 0000644 0052762 0001160 00000002306 12300765631 023477 0 ustar jenkins jenkins require 'puppet/file_serving/mount'
# Find files in the modules' pluginfacts directories.
# This is a very strange mount because it merges
# many directories into one.
class Puppet::FileServing::Mount::PluginFacts < Puppet::FileServing::Mount
# Return an instance of the appropriate class.
def find(relative_path, request)
return nil unless mod = request.environment.modules.find { |mod| mod.pluginfact(relative_path) }
path = mod.pluginfact(relative_path)
path
end
def search(relative_path, request)
# We currently only support one kind of search on plugins - return
# them all.
Puppet.debug("Warning: calling Plugins.search with empty module path.") if request.environment.modules.empty?
paths = request.environment.modules.find_all { |mod| mod.pluginfacts? }.collect { |mod| mod.plugin_fact_directory }
if paths.empty?
# If the modulepath is valid then we still need to return a valid root
# directory for the search, but make sure nothing inside it is
# returned.
request.options[:recurse] = false
request.environment.modulepath.empty? ? nil : request.environment.modulepath
else
paths
end
end
def valid?
true
end
end
puppet-3.4.3/lib/puppet/file_serving/mount/file.rb 0000644 0052762 0001160 00000005571 12300765631 022106 0 ustar jenkins jenkins require 'puppet/file_serving/mount'
class Puppet::FileServing::Mount::File < Puppet::FileServing::Mount
def self.localmap
@localmap ||= {
"h" => Facter.value("hostname"),
"H" => [
Facter.value("hostname"),
Facter.value("domain")
].join("."),
"d" => Facter.value("domain")
}
end
def complete_path(relative_path, node)
full_path = path(node)
raise ArgumentError.new("Mounts without paths are not usable") unless full_path
# If there's no relative path name, then we're serving the mount itself.
return full_path unless relative_path
file = ::File.join(full_path, relative_path)
if !(Puppet::FileSystem::File.exist?(file) or Puppet::FileSystem::File.new(file).symlink?)
Puppet.info("File does not exist or is not accessible: #{file}")
return nil
end
file
end
# Return an instance of the appropriate class.
def find(short_file, request)
complete_path(short_file, request.node)
end
# Return the path as appropriate, expanding as necessary.
def path(node = nil)
if expandable?
return expand(@path, node)
else
return @path
end
end
# Set the path.
def path=(path)
# FIXME: For now, just don't validate paths with replacement
# patterns in them.
if path =~ /%./
# Mark that we're expandable.
@expandable = true
else
raise ArgumentError, "#{path} does not exist or is not a directory" unless FileTest.directory?(path)
raise ArgumentError, "#{path} is not readable" unless FileTest.readable?(path)
@expandable = false
end
@path = path
end
def search(path, request)
return nil unless path = complete_path(path, request.node)
[path]
end
# Verify our configuration is valid. This should really check to
# make sure at least someone will be allowed, but, eh.
def validate
raise ArgumentError.new("Mounts without paths are not usable") if @path.nil?
end
private
# Create a map for a specific node.
def clientmap(node)
{
"h" => node.sub(/\..*$/, ""),
"H" => node,
"d" => node.sub(/[^.]+\./, "") # domain name
}
end
# Replace % patterns as appropriate.
def expand(path, node = nil)
# This map should probably be moved into a method.
map = nil
if node
map = clientmap(node)
else
Puppet.notice "No client; expanding '#{path}' with local host"
# Else, use the local information
map = localmap
end
path.gsub(/%(.)/) do |v|
key = $1
if key == "%"
"%"
else
map[key] || v
end
end
end
# Do we have any patterns in our path, yo?
def expandable?
if defined?(@expandable)
@expandable
else
false
end
end
# Cache this manufactured map, since if it's used it's likely
# to get used a lot.
def localmap
self.class.localmap
end
end
puppet-3.4.3/lib/puppet/file_serving/mount/plugins.rb 0000644 0052762 0001160 00000002255 12300765631 022644 0 ustar jenkins jenkins require 'puppet/file_serving/mount'
# Find files in the modules' plugins directories.
# This is a very strange mount because it merges
# many directories into one.
class Puppet::FileServing::Mount::Plugins < Puppet::FileServing::Mount
# Return an instance of the appropriate class.
def find(relative_path, request)
return nil unless mod = request.environment.modules.find { |mod| mod.plugin(relative_path) }
path = mod.plugin(relative_path)
path
end
def search(relative_path, request)
# We currently only support one kind of search on plugins - return
# them all.
Puppet.debug("Warning: calling Plugins.search with empty module path.") if request.environment.modules.empty?
paths = request.environment.modules.find_all { |mod| mod.plugins? }.collect { |mod| mod.plugin_directory }
if paths.empty?
# If the modulepath is valid then we still need to return a valid root
# directory for the search, but make sure nothing inside it is
# returned.
request.options[:recurse] = false
request.environment.modulepath.empty? ? nil : request.environment.modulepath
else
paths
end
end
def valid?
true
end
end
puppet-3.4.3/lib/puppet/file_serving/configuration.rb 0000644 0052762 0001160 00000005755 12300765631 022700 0 ustar jenkins jenkins require 'puppet'
require 'puppet/file_serving'
require 'puppet/file_serving/mount'
require 'puppet/file_serving/mount/file'
require 'puppet/file_serving/mount/modules'
require 'puppet/file_serving/mount/plugins'
require 'puppet/file_serving/mount/pluginfacts'
class Puppet::FileServing::Configuration
require 'puppet/file_serving/configuration/parser'
def self.configuration
@configuration ||= new
end
Mount = Puppet::FileServing::Mount
private_class_method :new
attr_reader :mounts
#private :mounts
# Find the right mount. Does some shenanigans to support old-style module
# mounts.
def find_mount(mount_name, environment)
# Reparse the configuration if necessary.
readconfig
# This can be nil.
mounts[mount_name]
end
def initialize
@mounts = {}
@config_file = nil
# We don't check to see if the file is modified the first time,
# because we always want to parse at first.
readconfig(false)
end
# Is a given mount available?
def mounted?(name)
@mounts.include?(name)
end
# Split the path into the separate mount point and path.
def split_path(request)
# Reparse the configuration if necessary.
readconfig
mount_name, path = request.key.split(File::Separator, 2)
raise(ArgumentError, "Cannot find file: Invalid mount '#{mount_name}'") unless mount_name =~ %r{^[-\w]+$}
raise(ArgumentError, "Cannot find file: Invalid relative path '#{path}'") if path and path.split('/').include?('..')
return nil unless mount = find_mount(mount_name, request.environment)
if mount.name == "modules" and mount_name != "modules"
# yay backward-compatibility
path = "#{mount_name}/#{path}"
end
if path == ""
path = nil
elsif path
# Remove any double slashes that might have occurred
path = path.gsub(/\/+/, "/")
end
return mount, path
end
def umount(name)
@mounts.delete(name) if @mounts.include? name
end
private
def mk_default_mounts
@mounts["modules"] ||= Mount::Modules.new("modules")
@mounts["modules"].allow('*') if @mounts["modules"].empty?
@mounts["plugins"] ||= Mount::Plugins.new("plugins")
@mounts["plugins"].allow('*') if @mounts["plugins"].empty?
@mounts["pluginfacts"] ||= Mount::PluginFacts.new("pluginfacts")
@mounts["pluginfacts"].allow('*') if @mounts["pluginfacts"].empty?
end
# Read the configuration file.
def readconfig(check = true)
config = Puppet[:fileserverconfig]
return unless Puppet::FileSystem::File.exist?(config)
@parser ||= Puppet::FileServing::Configuration::Parser.new(config)
return if check and ! @parser.changed?
# Don't assign the mounts hash until we're sure the parsing succeeded.
begin
newmounts = @parser.parse
@mounts = newmounts
rescue => detail
Puppet.log_exception(detail, "Error parsing fileserver configuration: #{detail}; using old configuration")
end
ensure
# Make sure we've got our plugins and modules.
mk_default_mounts
end
end
puppet-3.4.3/lib/puppet/file_serving/fileset.rb 0000644 0052762 0001160 00000011637 12300765631 021460 0 ustar jenkins jenkins require 'find'
require 'puppet/file_serving'
require 'puppet/file_serving/metadata'
# Operate recursively on a path, returning a set of file paths.
class Puppet::FileServing::Fileset
attr_reader :path, :ignore, :links
attr_accessor :recurse, :recurselimit, :checksum_type
# Produce a hash of files, with merged so that earlier files
# with the same postfix win. E.g., /dir1/subfile beats /dir2/subfile.
# It's a hash because we need to know the relative path of each file,
# and the base directory.
# This will probably only ever be used for searching for plugins.
def self.merge(*filesets)
result = {}
filesets.each do |fileset|
fileset.files.each do |file|
result[file] ||= fileset.path
end
end
result
end
def initialize(path, options = {})
if Puppet.features.microsoft_windows?
# REMIND: UNC path
path = path.chomp(File::SEPARATOR) unless path =~ /^[A-Za-z]:\/$/
else
path = path.chomp(File::SEPARATOR) unless path == File::SEPARATOR
end
raise ArgumentError.new("Fileset paths must be fully qualified: #{path}") unless Puppet::Util.absolute_path?(path)
@path = path
# Set our defaults.
self.ignore = []
self.links = :manage
@recurse = false
@recurselimit = :infinite
if options.is_a?(Puppet::Indirector::Request)
initialize_from_request(options)
else
initialize_from_hash(options)
end
raise ArgumentError.new("Fileset paths must exist") unless valid?(path)
raise ArgumentError.new("Fileset recurse parameter must not be a number anymore, please use recurselimit") if @recurse.is_a?(Integer)
end
# Return a list of all files in our fileset. This is different from the
# normal definition of find in that we support specific levels
# of recursion, which means we need to know when we're going another
# level deep, which Find doesn't do.
def files
files = perform_recursion
# Now strip off the leading path, so each file becomes relative, and remove
# any slashes that might end up at the beginning of the path.
result = files.collect { |file| file.sub(%r{^#{Regexp.escape(@path)}/*}, '') }
# And add the path itself.
result.unshift(".")
result
end
def ignore=(values)
values = [values] unless values.is_a?(Array)
@ignore = values
end
def links=(links)
links = links.to_sym
raise(ArgumentError, "Invalid :links value '#{links}'") unless [:manage, :follow].include?(links)
@links = links
@stat_method = @links == :manage ? :lstat : :stat
end
private
def initialize_from_hash(options)
options.each do |option, value|
method = option.to_s + "="
begin
send(method, value)
rescue NoMethodError
raise ArgumentError, "Invalid option '#{option}'"
end
end
end
def initialize_from_request(request)
[:links, :ignore, :recurse, :recurselimit, :checksum_type].each do |param|
if request.options.include?(param) # use 'include?' so the values can be false
value = request.options[param]
elsif request.options.include?(param.to_s)
value = request.options[param.to_s]
end
next if value.nil?
value = true if value == "true"
value = false if value == "false"
value = Integer(value) if value.is_a?(String) and value =~ /^\d+$/
send(param.to_s + "=", value)
end
end
FileSetEntry = Struct.new(:depth, :path, :ignored, :stat_method) do
def down_level(to)
FileSetEntry.new(depth + 1, File.join(path, to), ignored, stat_method)
end
def basename
File.basename(path)
end
def children
return [] unless directory?
Dir.entries(path).
reject { |child| ignore?(child) }.
collect { |child| down_level(child) }
end
def ignore?(child)
return true if child == "." || child == ".."
return false if ignored == [nil]
ignored.any? { |pattern| File.fnmatch?(pattern, child) }
end
def directory?
Puppet::FileSystem::File.new(path).send(stat_method).directory?
rescue Errno::ENOENT, Errno::EACCES
false
end
end
# Pull the recursion logic into one place. It's moderately hairy, and this
# allows us to keep the hairiness apart from what we do with the files.
def perform_recursion
current_dirs = [FileSetEntry.new(0, @path, @ignore, @stat_method)]
result = []
while entry = current_dirs.shift
if continue_recursion_at?(entry.depth + 1)
entry.children.each do |child|
result << child.path
current_dirs << child
end
end
end
result
end
def valid?(path)
Puppet::FileSystem::File.new(path).send(@stat_method)
true
rescue Errno::ENOENT, Errno::EACCES
false
end
def continue_recursion_at?(depth)
# recurse if told to, and infinite recursion or current depth not at the limit
self.recurse && (self.recurselimit == :infinite || depth <= self.recurselimit)
end
end
puppet-3.4.3/lib/puppet/file_serving/content.rb 0000644 0052762 0001160 00000002213 12300765631 021465 0 ustar jenkins jenkins require 'puppet/indirector'
require 'puppet/file_serving'
require 'puppet/file_serving/base'
# A class that handles retrieving file contents.
# It only reads the file when its content is specifically
# asked for.
class Puppet::FileServing::Content < Puppet::FileServing::Base
extend Puppet::Indirector
indirects :file_content, :terminus_class => :selector
attr_writer :content
def self.supported_formats
[:raw]
end
def self.from_raw(content)
instance = new("/this/is/a/fake/path")
instance.content = content
instance
end
# BF: we used to fetch the file content here, but this is counter-productive
# for puppetmaster streaming of file content. So collect just returns itself
def collect
return if stat.ftype == "directory"
self
end
# Read the content of our file in.
def content
unless @content
# This stat can raise an exception, too.
raise(ArgumentError, "Cannot read the contents of links unless following links") if stat.ftype == "symlink"
@content = Puppet::FileSystem::File.new(full_path).binread
end
@content
end
def to_raw
File.new(full_path, "rb")
end
end
puppet-3.4.3/lib/puppet/file_serving/mount.rb 0000644 0052762 0001160 00000001435 12300765631 021162 0 ustar jenkins jenkins require 'puppet/network/authstore'
require 'puppet/util/logging'
require 'puppet/file_serving'
require 'puppet/file_serving/metadata'
require 'puppet/file_serving/content'
# Broker access to the filesystem, converting local URIs into metadata
# or content objects.
class Puppet::FileServing::Mount < Puppet::Network::AuthStore
include Puppet::Util::Logging
attr_reader :name
def find(path, options)
raise NotImplementedError
end
# Create our object. It must have a name.
def initialize(name)
unless name =~ %r{^[-\w]+$}
raise ArgumentError, "Invalid mount name format '#{name}'"
end
@name = name
super()
end
def search(path, options)
raise NotImplementedError
end
def to_s
"mount[#{@name}]"
end
# A noop.
def validate
end
end
puppet-3.4.3/lib/puppet/file_serving/terminus_selector.rb 0000644 0052762 0001160 00000001463 12300765631 023567 0 ustar jenkins jenkins require 'puppet/file_serving'
# This module is used to pick the appropriate terminus
# in file-serving indirections. This is necessary because
# the terminus varies based on the URI asked for.
module Puppet::FileServing::TerminusSelector
def select(request)
# We rely on the request's parsing of the URI.
# Short-circuit to :file if it's a fully-qualified path or specifies a 'file' protocol.
if Puppet::Util.absolute_path?(request.key)
return :file
end
case request.protocol
when "file"
:file
when "puppet"
if request.server
:rest
else
Puppet[:default_file_terminus]
end
when nil
:file_server
else
raise ArgumentError, "URI protocol '#{request.protocol}' is not currently supported for file serving"
end
end
end
puppet-3.4.3/lib/puppet/file_serving/metadata.rb 0000644 0052762 0001160 00000007162 12300765631 021603 0 ustar jenkins jenkins require 'puppet'
require 'puppet/indirector'
require 'puppet/file_serving'
require 'puppet/file_serving/base'
require 'puppet/util/checksums'
# A class that handles retrieving file metadata.
class Puppet::FileServing::Metadata < Puppet::FileServing::Base
include Puppet::Util::Checksums
extend Puppet::Indirector
indirects :file_metadata, :terminus_class => :selector
attr_reader :path, :owner, :group, :mode, :checksum_type, :checksum, :ftype, :destination
PARAM_ORDER = [:mode, :ftype, :owner, :group]
def checksum_type=(type)
raise(ArgumentError, "Unsupported checksum type #{type}") unless respond_to?("#{type}_file")
@checksum_type = type
end
class MetaStat
extend Forwardable
def initialize(stat)
@stat = stat
end
def_delegator :@stat, :uid, :owner
def_delegator :@stat, :gid, :group
def_delegators :@stat, :mode, :ftype
end
class WindowsStat < MetaStat
if Puppet.features.microsoft_windows?
require 'puppet/util/windows/security'
end
def initialize(stat, path)
super(stat)
@path = path
end
{ :owner => 'S-1-5-32-544',
:group => 'S-1-0-0',
:mode => 0644
}.each do |method, default_value|
define_method method do
Puppet::Util::Windows::Security.send("get_#{method}", @path) || default_value
end
end
end
def collect_stat(path)
stat = stat()
if Puppet.features.microsoft_windows?
WindowsStat.new(stat, path)
else
MetaStat.new(stat)
end
end
# Retrieve the attributes for this file, relative to a base directory.
# Note that Puppet::FileSystem::File.new(path).stat raises Errno::ENOENT
# if the file is absent and this method does not catch that exception.
def collect
real_path = full_path
stat = collect_stat(real_path)
@owner = stat.owner
@group = stat.group
@ftype = stat.ftype
# We have to mask the mode, yay.
@mode = stat.mode & 007777
case stat.ftype
when "file"
@checksum = ("{#{@checksum_type}}") + send("#{@checksum_type}_file", real_path).to_s
when "directory" # Always just timestamp the directory.
@checksum_type = "ctime"
@checksum = ("{#{@checksum_type}}") + send("#{@checksum_type}_file", path).to_s
when "link"
@destination = Puppet::FileSystem::File.new(real_path).readlink
@checksum = ("{#{@checksum_type}}") + send("#{@checksum_type}_file", real_path).to_s rescue nil
else
raise ArgumentError, "Cannot manage files of type #{stat.ftype}"
end
end
def initialize(path,data={})
@owner = data.delete('owner')
@group = data.delete('group')
@mode = data.delete('mode')
if checksum = data.delete('checksum')
@checksum_type = checksum['type']
@checksum = checksum['value']
end
@checksum_type ||= "md5"
@ftype = data.delete('type')
@destination = data.delete('destination')
super(path,data)
end
def to_data_hash
super.update(
{
'owner' => owner,
'group' => group,
'mode' => mode,
'checksum' => {
'type' => checksum_type,
'value' => checksum
},
'type' => ftype,
'destination' => destination,
}
)
end
PSON.register_document_type('FileMetadata',self)
def to_pson_data_hash
{
'document_type' => 'FileMetadata',
'data' => to_data_hash,
'metadata' => {
'api_version' => 1
}
}
end
def to_pson(*args)
to_pson_data_hash.to_pson(*args)
end
def self.from_pson(data)
new(data.delete('path'), data)
end
end
puppet-3.4.3/lib/puppet/file_serving/base.rb 0000644 0052762 0001160 00000005144 12300765631 020733 0 ustar jenkins jenkins require 'puppet/file_serving'
require 'puppet/util'
require 'puppet/util/methodhelper'
# The base class for Content and Metadata; provides common
# functionality like the behaviour around links.
class Puppet::FileServing::Base
include Puppet::Util::MethodHelper
# This is for external consumers to store the source that was used
# to retrieve the metadata.
attr_accessor :source
# Does our file exist?
def exist?
stat
return true
rescue
return false
end
# Return the full path to our file. Fails if there's no path set.
def full_path(dummy_argument=:work_arround_for_ruby_GC_bug)
if relative_path.nil? or relative_path == "" or relative_path == "."
full_path = path
else
full_path = File.join(path, relative_path)
end
if Puppet.features.microsoft_windows?
# Replace multiple slashes as long as they aren't at the beginning of a filename
full_path.gsub(%r{(./)/+}, '\1')
else
full_path.gsub(%r{//+}, '/')
end
end
def initialize(path, options = {})
self.path = path
@links = :manage
set_options(options)
end
# Determine how we deal with links.
attr_reader :links
def links=(value)
value = value.to_sym
value = :manage if value == :ignore
raise(ArgumentError, ":links can only be set to :manage or :follow") unless [:manage, :follow].include?(value)
@links = value
end
# Set our base path.
attr_reader :path
def path=(path)
raise ArgumentError.new("Paths must be fully qualified") unless Puppet::FileServing::Base.absolute?(path)
@path = path
end
# Set a relative path; this is used for recursion, and sets
# the file's path relative to the initial recursion point.
attr_reader :relative_path
def relative_path=(path)
raise ArgumentError.new("Relative paths must not be fully qualified") if Puppet::FileServing::Base.absolute?(path)
@relative_path = path
end
# Stat our file, using the appropriate link-sensitive method.
def stat
@stat_method ||= self.links == :manage ? :lstat : :stat
Puppet::FileSystem::File.new(full_path).send(@stat_method)
end
def to_data_hash
{
'path' => @path,
'relative_path' => @relative_path,
'links' => @links
}
end
def to_pson_data_hash
{
# No 'document_type' since we don't send these bare
'data' => to_data_hash,
'metadata' => {
'api_version' => 1
}
}
end
def self.absolute?(path)
Puppet::Util.absolute_path?(path, :posix) or (Puppet.features.microsoft_windows? and Puppet::Util.absolute_path?(path, :windows))
end
end
puppet-3.4.3/lib/puppet/file_serving/configuration/ 0000755 0052762 0001160 00000000000 12300765640 022337 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/file_serving/configuration/parser.rb 0000644 0052762 0001160 00000006275 12300765631 024172 0 ustar jenkins jenkins require 'puppet/file_serving/configuration'
require 'puppet/util/watched_file'
class Puppet::FileServing::Configuration::Parser
Mount = Puppet::FileServing::Mount
MODULES = 'modules'
# Parse our configuration file.
def parse
raise("File server configuration #{@file} does not exist") unless Puppet::FileSystem::File.exist?(@file)
raise("Cannot read file server configuration #{@file}") unless FileTest.readable?(@file)
@mounts = {}
@count = 0
File.open(@file) { |f|
mount = nil
f.each_line { |line|
# Have the count increment at the top, in case we throw exceptions.
@count += 1
case line
when /^\s*#/; next # skip comments
when /^\s*$/; next # skip blank lines
when /\[([-\w]+)\]/
mount = newmount($1)
when /^\s*(\w+)\s+(.+?)(\s*#.*)?$/
var = $1
value = $2
value.strip!
raise(ArgumentError, "Fileserver configuration file does not use '=' as a separator") if value =~ /^=/
case var
when "path"
path(mount, value)
when "allow"
allow(mount, value)
when "deny"
deny(mount, value)
else
raise ArgumentError.new("Invalid argument '#{var}'", @count, @file)
end
else
raise ArgumentError.new("Invalid line '#{line.chomp}'", @count, @file)
end
}
}
validate
@mounts
end
def initialize(filename)
@file = Puppet::Util::WatchedFile.new(filename)
end
def changed?
@file.changed?
end
private
# Allow a given pattern access to a mount.
def allow(mount, value)
value.split(/\s*,\s*/).each { |val|
begin
mount.info "allowing #{val} access"
mount.allow(val)
rescue Puppet::AuthStoreError => detail
raise ArgumentError.new(detail.to_s, @count, @file)
end
}
end
# Deny a given pattern access to a mount.
def deny(mount, value)
value.split(/\s*,\s*/).each { |val|
begin
mount.info "denying #{val} access"
mount.deny(val)
rescue Puppet::AuthStoreError => detail
raise ArgumentError.new(detail.to_s, @count, @file)
end
}
end
# Create a new mount.
def newmount(name)
raise ArgumentError, "#{@mounts[name]} is already mounted at #{name}", @count, @file if @mounts.include?(name)
case name
when "modules"
mount = Mount::Modules.new(name)
when "plugins"
mount = Mount::Plugins.new(name)
else
mount = Mount::File.new(name)
end
@mounts[name] = mount
mount
end
# Set the path for a mount.
def path(mount, value)
if mount.respond_to?(:path=)
begin
mount.path = value
rescue ArgumentError => detail
Puppet.log_exception(detail, "Removing mount \"#{mount.name}\": #{detail}")
@mounts.delete(mount.name)
end
else
Puppet.warning "The '#{mount.name}' module can not have a path. Ignoring attempt to set it"
end
end
# Make sure all of our mounts are valid. We have to do this after the fact
# because details are added over time as the file is parsed.
def validate
@mounts.each { |name, mount| mount.validate }
end
end
puppet-3.4.3/lib/puppet/defaults.rb 0000644 0052762 0001160 00000215247 12300765631 017163 0 ustar jenkins jenkins module Puppet
def self.default_diffargs
if (Facter.value(:kernel) == "AIX" && Facter.value(:kernelmajversion) == "5300")
""
else
"-u"
end
end
############################################################################################
# NOTE: For information about the available values for the ":type" property of settings,
# see the docs for Settings.define_settings
############################################################################################
AS_DURATION = %q{This setting can be a time interval in seconds (30 or 30s), minutes (30m), hours (6h), days (2d), or years (5y).}
STORECONFIGS_ONLY = %q{This setting is only used by the ActiveRecord storeconfigs and inventory backends, which are deprecated.}
define_settings(:main,
:confdir => {
:default => nil,
:type => :directory,
:desc => "The main Puppet configuration directory. The default for this setting
is calculated based on the user. If the process is running as root or
the user that Puppet is supposed to run as, it defaults to a system
directory, but if it's running as any other user, it defaults to being
in the user's home directory.",
},
:vardir => {
:default => nil,
:type => :directory,
:owner => "service",
:group => "service",
:desc => "Where Puppet stores dynamic and growing data. The default for this
setting is calculated specially, like `confdir`_.",
},
### NOTE: this setting is usually being set to a symbol value. We don't officially have a
### setting type for that yet, but we might want to consider creating one.
:name => {
:default => nil,
:desc => "The name of the application, if we are running as one. The
default is essentially $0 without the path or `.rb`.",
}
)
define_settings(:main,
:logdir => {
:default => nil,
:type => :directory,
:mode => 0750,
:owner => "service",
:group => "service",
:desc => "The directory in which to store log files",
}
)
define_settings(:main,
:priority => {
:default => nil,
:type => :priority,
:desc => "The scheduling priority of the process. Valid values are 'high',
'normal', 'low', or 'idle', which are mapped to platform-specific
values. The priority can also be specified as an integer value and
will be passed as is, e.g. -5. Puppet must be running as a privileged
user in order to increase scheduling priority.",
},
:trace => {
:default => false,
:type => :boolean,
:desc => "Whether to print stack traces on some errors",
},
:profile => {
:default => false,
:type => :boolean,
:desc => "Whether to enable experimental performance profiling",
},
:autoflush => {
:default => true,
:type => :boolean,
:desc => "Whether log files should always flush to disk.",
:hook => proc { |value| Log.autoflush = value }
},
:syslogfacility => {
:default => "daemon",
:desc => "What syslog facility to use when logging to syslog.
Syslog has a fixed list of valid facilities, and you must
choose one of those; you cannot just make one up."
},
:statedir => {
:default => "$vardir/state",
:type => :directory,
:mode => 01755,
:desc => "The directory where Puppet state is stored. Generally,
this directory can be removed without causing harm (although it
might result in spurious service restarts)."
},
:rundir => {
:default => nil,
:type => :directory,
:mode => 0755,
:owner => "service",
:group => "service",
:desc => "Where Puppet PID files are kept."
},
:genconfig => {
:default => false,
:type => :boolean,
:desc => "When true, causes Puppet applications to print an example config file
to stdout and exit. The example will include descriptions of each
setting, and the current (or default) value of each setting,
incorporating any settings overridden on the CLI (with the exception
of `genconfig` itself). This setting only makes sense when specified
on the command line as `--genconfig`.",
},
:genmanifest => {
:default => false,
:type => :boolean,
:desc => "Whether to just print a manifest to stdout and exit. Only makes
sense when specified on the command line as `--genmanifest`. Takes into account arguments specified
on the CLI.",
},
:configprint => {
:default => "",
:desc => "Print the value of a specific configuration setting. If the name of a
setting is provided for this, then the value is printed and puppet
exits. Comma-separate multiple values. For a list of all values,
specify 'all'.",
},
:color => {
:default => "ansi",
:type => :string,
:desc => "Whether to use colors when logging to the console. Valid values are
`ansi` (equivalent to `true`), `html`, and `false`, which produces no color.
Defaults to false on Windows, as its console does not support ansi colors.",
},
:mkusers => {
:default => false,
:type => :boolean,
:desc => "Whether to create the necessary user and group that puppet agent will run as.",
},
:manage_internal_file_permissions => {
:default => true,
:type => :boolean,
:desc => "Whether Puppet should manage the owner, group, and mode of files it uses internally",
},
:onetime => {
:default => false,
:type => :boolean,
:desc => "Perform one configuration run and exit, rather than spawning a long-running
daemon. This is useful for interactively running puppet agent, or
running puppet agent from cron.",
:short => 'o',
},
:path => {
:default => "none",
:desc => "The shell search path. Defaults to whatever is inherited
from the parent process.",
:call_hook => :on_define_and_write,
:hook => proc do |value|
ENV["PATH"] = "" if ENV["PATH"].nil?
ENV["PATH"] = value unless value == "none"
paths = ENV["PATH"].split(File::PATH_SEPARATOR)
Puppet::Util::Platform.default_paths.each do |path|
ENV["PATH"] += File::PATH_SEPARATOR + path unless paths.include?(path)
end
value
end
},
:libdir => {
:type => :directory,
:default => "$vardir/lib",
:desc => "An extra search path for Puppet. This is only useful
for those files that Puppet will load on demand, and is only
guaranteed to work for those cases. In fact, the autoload
mechanism is responsible for making sure this directory
is in Ruby's search path\n",
:call_hook => :on_initialize_and_write,
:hook => proc do |value|
$LOAD_PATH.delete(@oldlibdir) if defined?(@oldlibdir) and $LOAD_PATH.include?(@oldlibdir)
@oldlibdir = value
$LOAD_PATH << value
end
},
:ignoreimport => {
:default => false,
:type => :boolean,
:desc => "If true, allows the parser to continue without requiring
all files referenced with `import` statements to exist. This setting was primarily
designed for use with commit hooks for parse-checking.",
},
:environment => {
:default => "production",
:desc => "The environment Puppet is running in. For clients
(e.g., `puppet agent`) this determines the environment itself, which
is used to find modules and much more. For servers (i.e., `puppet master`)
this provides the default environment for nodes we know nothing about."
},
:diff_args => {
:default => default_diffargs,
:desc => "Which arguments to pass to the diff command when printing differences between
files. The command to use can be chosen with the `diff` setting.",
},
:diff => {
:default => (Puppet.features.microsoft_windows? ? "" : "diff"),
:desc => "Which diff command to use when printing differences between files. This setting
has no default value on Windows, as standard `diff` is not available, but Puppet can use many
third-party diff tools.",
},
:show_diff => {
:type => :boolean,
:default => false,
:desc => "Whether to log and report a contextual diff when files are being replaced.
This causes partial file contents to pass through Puppet's normal
logging and reporting system, so this setting should be used with
caution if you are sending Puppet's reports to an insecure
destination. This feature currently requires the `diff/lcs` Ruby
library.",
},
:daemonize => {
:type => :boolean,
:default => (Puppet.features.microsoft_windows? ? false : true),
:desc => "Whether to send the process into the background. This defaults
to true on POSIX systems, and to false on Windows (where Puppet
currently cannot daemonize).",
:short => "D",
:hook => proc do |value|
if value and Puppet.features.microsoft_windows?
raise "Cannot daemonize on Windows"
end
end
},
:maximum_uid => {
:default => 4294967290,
:desc => "The maximum allowed UID. Some platforms use negative UIDs
but then ship with tools that do not know how to handle signed ints,
so the UIDs show up as huge numbers that can then not be fed back into
the system. This is a hackish way to fail in a slightly more useful
way when that happens.",
},
:route_file => {
:default => "$confdir/routes.yaml",
:desc => "The YAML file containing indirector route configuration.",
},
:node_terminus => {
:type => :terminus,
:default => "plain",
:desc => "Where to find information about nodes.",
},
:node_cache_terminus => {
:type => :terminus,
:default => nil,
:desc => "How to store cached nodes.
Valid values are (none), 'json', 'yaml' or write only yaml ('write_only_yaml').
The master application defaults to 'write_only_yaml', all others to none.",
},
:data_binding_terminus => {
:type => :terminus,
:default => "hiera",
:desc => "Where to retrive information about data.",
},
:hiera_config => {
:default => "$confdir/hiera.yaml",
:desc => "The hiera configuration file. Puppet only reads this file on startup, so you must restart the puppet master every time you edit it.",
:type => :file,
},
:binder => {
:default => false,
:desc => "Turns the binding system on or off. This includes hiera-2 and data in modules. The binding system aggregates data from
modules and other locations and makes them available for lookup. The binding system is experimental and any or all of it may change.",
:type => :boolean,
},
:binder_config => {
:default => nil,
:desc => "The binder configuration file. Puppet reads this file on each request to configure the bindings system.
If set to nil (the default), a $confdir/binder_config.yaml is optionally loaded. If it does not exists, a default configuration
is used. If the setting :binding_config is specified, it must reference a valid and existing yaml file.",
:type => :file,
},
:catalog_terminus => {
:type => :terminus,
:default => "compiler",
:desc => "Where to get node catalogs. This is useful to change if, for instance,
you'd like to pre-compile catalogs and store them in memcached or some other easily-accessed store.",
},
:catalog_cache_terminus => {
:type => :terminus,
:default => nil,
:desc => "How to store cached catalogs. Valid values are 'json' and 'yaml'. The agent application defaults to 'json'."
},
:facts_terminus => {
:default => 'facter',
:desc => "The node facts terminus.",
:call_hook => :on_initialize_and_write,
:hook => proc do |value|
require 'puppet/node/facts'
# Cache to YAML if we're uploading facts away
if %w[rest inventory_service].include? value.to_s
Puppet.info "configuring the YAML fact cache because a remote terminus is active"
Puppet::Node::Facts.indirection.cache_class = :yaml
end
end
},
:inventory_terminus => {
:type => :terminus,
:default => "$facts_terminus",
:desc => "Should usually be the same as the facts terminus",
},
:default_file_terminus => {
:type => :terminus,
:default => "rest",
:desc => "The default source for files if no server is given in a
uri, e.g. puppet:///file. The default of `rest` causes the file to be
retrieved using the `server` setting. When running `apply` the default
is `file_server`, causing requests to be filled locally."
},
:httplog => {
:default => "$logdir/http.log",
:type => :file,
:owner => "root",
:mode => 0640,
:desc => "Where the puppet agent web server logs.",
},
:http_proxy_host => {
:default => "none",
:desc => "The HTTP proxy host to use for outgoing connections. Note: You
may need to use a FQDN for the server hostname when using a proxy.",
},
:http_proxy_port => {
:default => 3128,
:desc => "The HTTP proxy port to use for outgoing connections",
},
:filetimeout => {
:default => "15s",
:type => :duration,
:desc => "The minimum time to wait between checking for updates in
configuration files. This timeout determines how quickly Puppet checks whether
a file (such as manifests or templates) has changed on disk. #{AS_DURATION}",
},
:queue_type => {
:default => "stomp",
:desc => "Which type of queue to use for asynchronous processing.",
},
:queue_type => {
:default => "stomp",
:desc => "Which type of queue to use for asynchronous processing.",
},
:queue_source => {
:default => "stomp://localhost:61613/",
:desc => "Which type of queue to use for asynchronous processing. If your stomp server requires
authentication, you can include it in the URI as long as your stomp client library is at least 1.1.1",
},
:async_storeconfigs => {
:default => false,
:type => :boolean,
:desc => "Whether to use a queueing system to provide asynchronous database integration.
Requires that `puppet queue` be running.",
:hook => proc do |value|
if value
# This reconfigures the termini for Node, Facts, and Catalog
Puppet.settings[:storeconfigs] = true
# But then we modify the configuration
Puppet::Resource::Catalog.indirection.cache_class = :queue
Puppet.settings[:catalog_cache_terminus] = :queue
else
raise "Cannot disable asynchronous storeconfigs in a running process"
end
end
},
:thin_storeconfigs => {
:default => false,
:type => :boolean,
:desc =>
"Boolean; whether Puppet should store only facts and exported resources in the storeconfigs
database. This will improve the performance of exported resources with the older
`active_record` backend, but will disable external tools that search the storeconfigs database.
Thinning catalogs is generally unnecessary when using PuppetDB to store catalogs.",
:hook => proc do |value|
Puppet.settings[:storeconfigs] = true if value
end
},
:config_version => {
:default => "",
:desc => "How to determine the configuration version. By default, it will be the
time that the configuration is parsed, but you can provide a shell script to override how the
version is determined. The output of this script will be added to every log message in the
reports, allowing you to correlate changes on your hosts to the source version on the server.",
},
:zlib => {
:default => true,
:type => :boolean,
:desc => "Boolean; whether to use the zlib library",
},
:prerun_command => {
:default => "",
:desc => "A command to run before every agent run. If this command returns a non-zero
return code, the entire Puppet run will fail.",
},
:postrun_command => {
:default => "",
:desc => "A command to run after every agent run. If this command returns a non-zero
return code, the entire Puppet run will be considered to have failed, even though it might have
performed work during the normal run.",
},
:freeze_main => {
:default => false,
:type => :boolean,
:desc => "Freezes the 'main' class, disallowing any code to be added to it. This
essentially means that you can't have any code outside of a node,
class, or definition other than in the site manifest.",
},
:stringify_facts => {
:default => true,
:type => :boolean,
:desc => "Flatten fact values to strings using #to_s. Means you can't have arrays or
hashes as fact values.",
},
:trusted_node_data => {
:default => false,
:type => :boolean,
:desc => "Stores trusted node data in a hash called $trusted.
When true also prevents $trusted from being overridden in any scope.",
}
)
Puppet.define_settings(:module_tool,
:module_repository => {
:default => 'https://forge.puppetlabs.com',
:desc => "The module repository",
},
:module_working_dir => {
:default => '$vardir/puppet-module',
:desc => "The directory into which module tool data is stored",
},
:module_skeleton_dir => {
:default => '$module_working_dir/skeleton',
:desc => "The directory which the skeleton for module tool generate is stored.",
}
)
Puppet.define_settings(
:main,
# We have to downcase the fqdn, because the current ssl stuff (as oppsed to in master) doesn't have good facilities for
# manipulating naming.
:certname => {
:default => Puppet::Settings.default_certname.downcase, :desc => "The name to use when handling certificates. Defaults
to the fully qualified domain name.",
:call_hook => :on_define_and_write, # Call our hook with the default value, so we're always downcased
:hook => proc { |value| raise(ArgumentError, "Certificate names must be lower case; see #1168") unless value == value.downcase }},
:certdnsnames => {
:default => '',
:hook => proc do |value|
unless value.nil? or value == '' then
Puppet.warning < < {
:default => '',
:desc => < {
:default => "$confdir/csr_attributes.yaml",
:type => :file,
:desc => < {
:default => "$ssldir/certs",
:type => :directory,
:owner => "service",
:desc => "The certificate directory."
},
:ssldir => {
:default => "$confdir/ssl",
:type => :directory,
:mode => 0771,
:owner => "service",
:desc => "Where SSL certificates are kept."
},
:publickeydir => {
:default => "$ssldir/public_keys",
:type => :directory,
:owner => "service",
:desc => "The public key directory."
},
:requestdir => {
:default => "$ssldir/certificate_requests",
:type => :directory,
:owner => "service",
:desc => "Where host certificate requests are stored."
},
:privatekeydir => {
:default => "$ssldir/private_keys",
:type => :directory,
:mode => 0750,
:owner => "service",
:desc => "The private key directory."
},
:privatedir => {
:default => "$ssldir/private",
:type => :directory,
:mode => 0750,
:owner => "service",
:desc => "Where the client stores private certificate information."
},
:passfile => {
:default => "$privatedir/password",
:type => :file,
:mode => 0640,
:owner => "service",
:desc => "Where puppet agent stores the password for its private key.
Generally unused."
},
:hostcsr => {
:default => "$ssldir/csr_$certname.pem",
:type => :file,
:mode => 0644,
:owner => "service",
:desc => "Where individual hosts store and look for their certificate requests."
},
:hostcert => {
:default => "$certdir/$certname.pem",
:type => :file,
:mode => 0644,
:owner => "service",
:desc => "Where individual hosts store and look for their certificates."
},
:hostprivkey => {
:default => "$privatekeydir/$certname.pem",
:type => :file,
:mode => 0600,
:owner => "service",
:desc => "Where individual hosts store and look for their private key."
},
:hostpubkey => {
:default => "$publickeydir/$certname.pem",
:type => :file,
:mode => 0644,
:owner => "service",
:desc => "Where individual hosts store and look for their public key."
},
:localcacert => {
:default => "$certdir/ca.pem",
:type => :file,
:mode => 0644,
:owner => "service",
:desc => "Where each client stores the CA certificate."
},
:ssl_client_ca_auth => {
:type => :file,
:mode => 0644,
:owner => "service",
:desc => "Certificate authorities who issue server certificates. SSL servers will not be
considered authentic unless they posses a certificate issued by an authority
listed in this file. If this setting has no value then the Puppet master's CA
certificate (localcacert) will be used."
},
:ssl_server_ca_auth => {
:type => :file,
:mode => 0644,
:owner => "service",
:desc => "Certificate authorities who issue client certificates. SSL clients will not be
considered authentic unless they posses a certificate issued by an authority
listed in this file. If this setting has no value then the Puppet master's CA
certificate (localcacert) will be used."
},
:hostcrl => {
:default => "$ssldir/crl.pem",
:type => :file,
:mode => 0644,
:owner => "service",
:desc => "Where the host's certificate revocation list can be found.
This is distinct from the certificate authority's CRL."
},
:certificate_revocation => {
:default => true,
:type => :boolean,
:desc => "Whether certificate revocation should be supported by downloading a
Certificate Revocation List (CRL)
to all clients. If enabled, CA chaining will almost definitely not work.",
},
:certificate_expire_warning => {
:default => "60d",
:type => :duration,
:desc => "The window of time leading up to a certificate's expiration that a notification
will be logged. This applies to CA, master, and agent certificates. #{AS_DURATION}"
}
)
define_settings(
:ca,
:ca_name => {
:default => "Puppet CA: $certname",
:desc => "The name to use the Certificate Authority certificate.",
},
:cadir => {
:default => "$ssldir/ca",
:type => :directory,
:owner => "service",
:group => "service",
:mode => 0770,
:desc => "The root directory for the certificate authority."
},
:cacert => {
:default => "$cadir/ca_crt.pem",
:type => :file,
:owner => "service",
:group => "service",
:mode => 0660,
:desc => "The CA certificate."
},
:cakey => {
:default => "$cadir/ca_key.pem",
:type => :file,
:owner => "service",
:group => "service",
:mode => 0660,
:desc => "The CA private key."
},
:capub => {
:default => "$cadir/ca_pub.pem",
:type => :file,
:owner => "service",
:group => "service",
:desc => "The CA public key."
},
:cacrl => {
:default => "$cadir/ca_crl.pem",
:type => :file,
:owner => "service",
:group => "service",
:mode => 0664,
:desc => "The certificate revocation list (CRL) for the CA. Will be used if present but otherwise ignored.",
},
:caprivatedir => {
:default => "$cadir/private",
:type => :directory,
:owner => "service",
:group => "service",
:mode => 0770,
:desc => "Where the CA stores private certificate information."
},
:csrdir => {
:default => "$cadir/requests",
:type => :directory,
:owner => "service",
:group => "service",
:desc => "Where the CA stores certificate requests"
},
:signeddir => {
:default => "$cadir/signed",
:type => :directory,
:owner => "service",
:group => "service",
:mode => 0770,
:desc => "Where the CA stores signed certificates."
},
:capass => {
:default => "$caprivatedir/ca.pass",
:type => :file,
:owner => "service",
:group => "service",
:mode => 0660,
:desc => "Where the CA stores the password for the private key."
},
:serial => {
:default => "$cadir/serial",
:type => :file,
:owner => "service",
:group => "service",
:mode => 0644,
:desc => "Where the serial number for certificates is stored."
},
:autosign => {
:default => "$confdir/autosign.conf",
:type => :autosign,
:desc => "Whether (and how) to autosign certificate requests. This setting
is only relevant on a puppet master acting as a certificate authority (CA).
Valid values are true (autosigns all certificate requests; not recommended),
false (disables autosigning certificates), or the absolute path to a file.
The file specified in this setting may be either a **configuration file**
or a **custom policy executable.** Puppet will automatically determine
what it is: If the Puppet user (see the `user` setting) can execute the
file, it will be treated as a policy executable; otherwise, it will be
treated as a config file.
If a custom policy executable is configured, the CA puppet master will run it
every time it receives a CSR. The executable will be passed the subject CN of the
request _as a command line argument,_ and the contents of the CSR in PEM format
_on stdin._ It should exit with a status of 0 if the cert should be autosigned
and non-zero if the cert should not be autosigned.
If a certificate request is not autosigned, it will persist for review. An admin
user can use the `puppet cert sign` command to manually sign it, or can delete
the request.
For info on autosign configuration files, see
[the guide to Puppet's config files](http://docs.puppetlabs.com/guides/configuring.html).",
},
:allow_duplicate_certs => {
:default => false,
:type => :boolean,
:desc => "Whether to allow a new certificate
request to overwrite an existing certificate.",
},
:ca_ttl => {
:default => "5y",
:type => :duration,
:desc => "The default TTL for new certificates. If this setting is set, ca_days is ignored.
#{AS_DURATION}"
},
:req_bits => {
:default => 4096,
:desc => "The bit length of the certificates.",
},
:keylength => {
:default => 4096,
:desc => "The bit length of keys.",
},
:cert_inventory => {
:default => "$cadir/inventory.txt",
:type => :file,
:mode => 0644,
:owner => "service",
:group => "service",
:desc => "The inventory file. This is a text file to which the CA writes a
complete listing of all certificates."
}
)
# Define the config default.
define_settings(:application,
:config_file_name => {
:type => :string,
:default => Puppet::Settings.default_config_file_name,
:desc => "The name of the puppet config file.",
},
:config => {
:type => :file,
:default => "$confdir/${config_file_name}",
:desc => "The configuration file for the current puppet application.",
},
:pidfile => {
:type => :file,
:default => "$rundir/${run_mode}.pid",
:desc => "The file containing the PID of a running process.
This file is intended to be used by service management frameworks
and monitoring systems to determine if a puppet process is still in
the process table.",
},
:bindaddress => {
:default => "0.0.0.0",
:desc => "The address a listening server should bind to.",
}
)
define_settings(:master,
:user => {
:default => "puppet",
:desc => "The user puppet master should run as.",
},
:group => {
:default => "puppet",
:desc => "The group puppet master should run as.",
},
:manifestdir => {
:default => "$confdir/manifests",
:type => :directory,
:desc => "Where puppet master looks for its manifests.",
},
:manifest => {
:default => "$manifestdir/site.pp",
:type => :file,
:desc => "The entry-point manifest for puppet master.",
},
:code => {
:default => "",
:desc => "Code to parse directly. This is essentially only used
by `puppet`, and should only be set if you're writing your own Puppet
executable.",
},
:masterlog => {
:default => "$logdir/puppetmaster.log",
:type => :file,
:owner => "service",
:group => "service",
:mode => 0660,
:desc => "Where puppet master logs. This is generally not used,
since syslog is the default log destination."
},
:masterhttplog => {
:default => "$logdir/masterhttp.log",
:type => :file,
:owner => "service",
:group => "service",
:mode => 0660,
:create => true,
:desc => "Where the puppet master web server logs."
},
:masterport => {
:default => 8140,
:desc => "The port for puppet master traffic. For puppet master,
this is the port to listen on; for puppet agent, this is the port
to make requests on. Both applications use this setting to get the port.",
},
:node_name => {
:default => "cert",
:desc => "How the puppet master determines the client's identity
and sets the 'hostname', 'fqdn' and 'domain' facts for use in the manifest,
in particular for determining which 'node' statement applies to the client.
Possible values are 'cert' (use the subject's CN in the client's
certificate) and 'facter' (use the hostname that the client
reported in its facts)",
},
:bucketdir => {
:default => "$vardir/bucket",
:type => :directory,
:mode => 0750,
:owner => "service",
:group => "service",
:desc => "Where FileBucket files are stored."
},
:rest_authconfig => {
:default => "$confdir/auth.conf",
:type => :file,
:desc => "The configuration file that defines the rights to the different
rest indirections. This can be used as a fine-grained
authorization system for `puppet master`.",
},
:ca => {
:default => true,
:type => :boolean,
:desc => "Whether the master should function as a certificate authority.",
},
:modulepath => {
:default => "$confdir/modules#{File::PATH_SEPARATOR}/usr/share/puppet/modules",
:type => :path,
:desc => "The search path for modules, as a list of directories separated by the system
path separator character. (The POSIX path separator is ':', and the
Windows path separator is ';'.)",
},
:ssl_client_header => {
:default => "HTTP_X_CLIENT_DN",
:desc => "The header containing an authenticated client's SSL DN.
This header must be set by the proxy to the authenticated client's SSL
DN (e.g., `/CN=puppet.puppetlabs.com`). Puppet will parse out the Common
Name (CN) from the Distinguished Name (DN) and use the value of the CN
field for authorization.
Note that the name of the HTTP header gets munged by the web server
common gateway inteface: an `HTTP_` prefix is added, dashes are converted
to underscores, and all letters are uppercased. Thus, to use the
`X-Client-DN` header, this setting should be `HTTP_X_CLIENT_DN`.",
},
:ssl_client_verify_header => {
:default => "HTTP_X_CLIENT_VERIFY",
:desc => "The header containing the status message of the client
verification. This header must be set by the proxy to 'SUCCESS' if the
client successfully authenticated, and anything else otherwise.
Note that the name of the HTTP header gets munged by the web server
common gateway inteface: an `HTTP_` prefix is added, dashes are converted
to underscores, and all letters are uppercased. Thus, to use the
`X-Client-Verify` header, this setting should be
`HTTP_X_CLIENT_VERIFY`.",
},
# To make sure this directory is created before we try to use it on the server, we need
# it to be in the server section (#1138).
:yamldir => {
:default => "$vardir/yaml",
:type => :directory,
:owner => "service",
:group => "service",
:mode => "750",
:desc => "The directory in which YAML data is stored, usually in a subdirectory."},
:server_datadir => {
:default => "$vardir/server_data",
:type => :directory,
:owner => "service",
:group => "service",
:mode => "750",
:desc => "The directory in which serialized data is stored, usually in a subdirectory."},
:reports => {
:default => "store",
:desc => "The list of report handlers to use. When using multiple report handlers,
their names should be comma-separated, with whitespace allowed. (For example,
`reports = http, tagmail`.)
This setting is relevant to puppet master and puppet apply. The puppet
master will call these report handlers with the reports it receives from
agent nodes, and puppet apply will call them with its own report. (In
all cases, the node applying the catalog must have `report = true`.)
See the report reference for information on the built-in report
handlers; custom report handlers can also be loaded from modules.
(Report handlers are loaded from the lib directory, at
`puppet/reports/NAME.rb`.)",
},
:reportdir => {
:default => "$vardir/reports",
:type => :directory,
:mode => 0750,
:owner => "service",
:group => "service",
:desc => "The directory in which to store reports. Each node gets
a separate subdirectory in this directory. This setting is only
used when the `store` report processor is enabled (see the
`reports` setting)."},
:reporturl => {
:default => "http://localhost:3000/reports/upload",
:desc => "The URL that reports should be forwarded to. This setting
is only used when the `http` report processor is enabled (see the
`reports` setting).",
},
:fileserverconfig => {
:default => "$confdir/fileserver.conf",
:type => :file,
:desc => "Where the fileserver configuration is stored.",
},
:strict_hostname_checking => {
:default => false,
:desc => "Whether to only search for the complete
hostname as it is in the certificate when searching for node information
in the catalogs.",
}
)
define_settings(:metrics,
:rrddir => {
:type => :directory,
:default => "$vardir/rrd",
:mode => 0750,
:owner => "service",
:group => "service",
:desc => "The directory where RRD database files are stored.
Directories for each reporting host will be created under
this directory."
},
:rrdinterval => {
:default => "$runinterval",
:type => :duration,
:desc => "How often RRD should expect data.
This should match how often the hosts report back to the server. #{AS_DURATION}",
}
)
define_settings(:device,
:devicedir => {
:default => "$vardir/devices",
:type => :directory,
:mode => "750",
:desc => "The root directory of devices' $vardir.",
},
:deviceconfig => {
:default => "$confdir/device.conf",
:desc => "Path to the device config file for puppet device.",
}
)
define_settings(:agent,
:node_name_value => {
:default => "$certname",
:desc => "The explicit value used for the node name for all requests the agent
makes to the master. WARNING: This setting is mutually exclusive with
node_name_fact. Changing this setting also requires changes to the default
auth.conf configuration on the Puppet Master. Please see
http://links.puppetlabs.com/node_name_value for more information."
},
:node_name_fact => {
:default => "",
:desc => "The fact name used to determine the node name used for all requests the agent
makes to the master. WARNING: This setting is mutually exclusive with
node_name_value. Changing this setting also requires changes to the default
auth.conf configuration on the Puppet Master. Please see
http://links.puppetlabs.com/node_name_fact for more information.",
:hook => proc do |value|
if !value.empty? and Puppet[:node_name_value] != Puppet[:certname]
raise "Cannot specify both the node_name_value and node_name_fact settings"
end
end
},
:localconfig => {
:default => "$statedir/localconfig",
:type => :file,
:owner => "root",
:mode => 0660,
:desc => "Where puppet agent caches the local configuration. An
extension indicating the cache format is added automatically."},
:statefile => {
:default => "$statedir/state.yaml",
:type => :file,
:mode => 0660,
:desc => "Where puppet agent and puppet master store state associated
with the running configuration. In the case of puppet master,
this file reflects the state discovered through interacting
with clients."
},
:clientyamldir => {
:default => "$vardir/client_yaml",
:type => :directory,
:mode => "750",
:desc => "The directory in which client-side YAML data is stored."
},
:client_datadir => {
:default => "$vardir/client_data",
:type => :directory,
:mode => "750",
:desc => "The directory in which serialized data is stored on the client."
},
:classfile => {
:default => "$statedir/classes.txt",
:type => :file,
:owner => "root",
:mode => 0640,
:desc => "The file in which puppet agent stores a list of the classes
associated with the retrieved configuration. Can be loaded in
the separate `puppet` executable using the `--loadclasses`
option."},
:resourcefile => {
:default => "$statedir/resources.txt",
:type => :file,
:owner => "root",
:mode => 0640,
:desc => "The file in which puppet agent stores a list of the resources
associated with the retrieved configuration." },
:puppetdlog => {
:default => "$logdir/puppetd.log",
:type => :file,
:owner => "root",
:mode => 0640,
:desc => "The log file for puppet agent. This is generally not used."
},
:server => {
:default => "puppet",
:desc => "The puppet master server to which the puppet agent should connect."
},
:use_srv_records => {
:default => false,
:type => :boolean,
:desc => "Whether the server will search for SRV records in DNS for the current domain.",
},
:srv_domain => {
:default => "#{Puppet::Settings.domain_fact}",
:desc => "The domain which will be queried to find the SRV records of servers to use.",
},
:ignoreschedules => {
:default => false,
:type => :boolean,
:desc => "Boolean; whether puppet agent should ignore schedules. This is useful
for initial puppet agent runs.",
},
:default_schedules => {
:default => true,
:type => :boolean,
:desc => "Boolean; whether to generate the default schedule resources. Setting this to
false is useful for keeping external report processors clean of skipped schedule resources.",
},
:puppetport => {
:default => 8139,
:desc => "Which port puppet agent listens on.",
},
:noop => {
:default => false,
:type => :boolean,
:desc => "Whether to apply catalogs in noop mode, which allows Puppet to
partially simulate a normal run. This setting affects puppet agent and
puppet apply.
When running in noop mode, Puppet will check whether each resource is in sync,
like it does when running normally. However, if a resource attribute is not in
the desired state (as declared in the catalog), Puppet will take no
action, and will instead report the changes it _would_ have made. These
simulated changes will appear in the report sent to the puppet master, or
be shown on the console if running puppet agent or puppet apply in the
foreground. The simulated changes will not send refresh events to any
subscribing or notified resources, although Puppet will log that a refresh
event _would_ have been sent.
**Important note:**
[The `noop` metaparameter](http://docs.puppetlabs.com/references/latest/metaparameter.html#noop)
allows you to apply individual resources in noop mode, and will override
the global value of the `noop` setting. This means a resource with
`noop => false` _will_ be changed if necessary, even when running puppet
agent with `noop = true` or `--noop`. (Conversely, a resource with
`noop => true` will only be simulated, even when noop mode is globally disabled.)",
},
:runinterval => {
:default => "30m",
:type => :duration,
:desc => "How often puppet agent applies the catalog.
Note that a runinterval of 0 means \"run continuously\" rather than
\"never run.\" If you want puppet agent to never run, you should start
it with the `--no-client` option. #{AS_DURATION}",
},
:listen => {
:default => false,
:type => :boolean,
:desc => "Whether puppet agent should listen for
connections. If this is true, then puppet agent will accept incoming
REST API requests, subject to the default ACLs and the ACLs set in
the `rest_authconfig` file. Puppet agent can respond usefully to
requests on the `run`, `facts`, `certificate`, and `resource` endpoints.",
},
:ca_server => {
:default => "$server",
:desc => "The server to use for certificate
authority requests. It's a separate server because it cannot
and does not need to horizontally scale.",
},
:ca_port => {
:default => "$masterport",
:desc => "The port to use for the certificate authority.",
},
:catalog_format => {
:default => "",
:desc => "(Deprecated for 'preferred_serialization_format') What format to
use to dump the catalog. Only supports 'marshal' and 'yaml'. Only
matters on the client, since it asks the server for a specific format.",
:hook => proc { |value|
if value
Puppet.deprecation_warning "Setting 'catalog_format' is deprecated; use 'preferred_serialization_format' instead."
Puppet.settings[:preferred_serialization_format] = value
end
}
},
:preferred_serialization_format => {
:default => "pson",
:desc => "The preferred means of serializing
ruby instances for passing over the wire. This won't guarantee that all
instances will be serialized using this method, since not all classes
can be guaranteed to support this format, but it will be used for all
classes that support it.",
},
:report_serialization_format => {
:default => "pson",
:type => :enum,
:values => ["pson", "yaml"],
:desc => "The serialization format to use when sending reports to the
`report_server`. Possible values are `pson` and `yaml`. This setting
affects puppet agent, but not puppet apply (which processes its own
reports).
This should almost always be set to `pson`. It can be temporarily set to
`yaml` to let agents using this Puppet version connect to a puppet master
running Puppet 3.0.0 through 3.2.x.
Note that this is set to 'yaml' automatically if the agent detects an
older master, so should never need to be set explicitly."
},
:legacy_query_parameter_serialization => {
:default => false,
:type => :boolean,
:desc => "The serialization format to use when sending file_metadata
query parameters. Older versions of puppet master expect certain query
parameters to be serialized as yaml, which is deprecated.
This should almost always be false. It can be temporarily set to true
to let agents using this Puppet version connect to a puppet master
running Puppet 3.0.0 through 3.2.x.
Note that this is set to true automatically if the agent detects an
older master, so should never need to be set explicitly."
},
:agent_catalog_run_lockfile => {
:default => "$statedir/agent_catalog_run.lock",
:type => :string, # (#2888) Ensure this file is not added to the settings catalog.
:desc => "A lock file to indicate that a puppet agent catalog run is currently in progress.
The file contains the pid of the process that holds the lock on the catalog run.",
},
:agent_disabled_lockfile => {
:default => "$statedir/agent_disabled.lock",
:type => :file,
:desc => "A lock file to indicate that puppet agent runs have been administratively
disabled. File contains a JSON object with state information.",
},
:usecacheonfailure => {
:default => true,
:type => :boolean,
:desc => "Whether to use the cached configuration when the remote
configuration will not compile. This option is useful for testing
new configurations, where you want to fix the broken configuration
rather than reverting to a known-good one.",
},
:use_cached_catalog => {
:default => false,
:type => :boolean,
:desc => "Whether to only use the cached catalog rather than compiling a new catalog
on every run. Puppet can be run with this enabled by default and then selectively
disabled when a recompile is desired.",
},
:ignoremissingtypes => {
:default => false,
:type => :boolean,
:desc => "Skip searching for classes and definitions that were missing during a
prior compilation. The list of missing objects is maintained per-environment and
persists until the environment is cleared or the master is restarted.",
},
:ignorecache => {
:default => false,
:type => :boolean,
:desc => "Ignore cache and always recompile the configuration. This is
useful for testing new configurations, where the local cache may in
fact be stale even if the timestamps are up to date - if the facts
change or if the server changes.",
},
:dynamicfacts => {
:default => "memorysize,memoryfree,swapsize,swapfree",
:desc => "(Deprecated) Facts that are dynamic; these facts will be ignored when deciding whether
changed facts should result in a recompile. Multiple facts should be
comma-separated.",
:hook => proc { |value|
if value
Puppet.deprecation_warning "The dynamicfacts setting is deprecated and will be ignored."
end
}
},
:splaylimit => {
:default => "$runinterval",
:type => :duration,
:desc => "The maximum time to delay before runs. Defaults to being the same as the
run interval. #{AS_DURATION}",
},
:splay => {
:default => false,
:type => :boolean,
:desc => "Whether to sleep for a pseudo-random (but consistent) amount of time before
a run.",
},
:clientbucketdir => {
:default => "$vardir/clientbucket",
:type => :directory,
:mode => 0750,
:desc => "Where FileBucket files are stored locally."
},
:configtimeout => {
:default => "2m",
:type => :duration,
:desc => "How long the client should wait for the configuration to be retrieved
before considering it a failure. This can help reduce flapping if too
many clients contact the server at one time. #{AS_DURATION}",
},
:report_server => {
:default => "$server",
:desc => "The server to send transaction reports to.",
},
:report_port => {
:default => "$masterport",
:desc => "The port to communicate with the report_server.",
},
:inventory_server => {
:default => "$server",
:desc => "The server to send facts to.",
},
:inventory_port => {
:default => "$masterport",
:desc => "The port to communicate with the inventory_server.",
},
:report => {
:default => true,
:type => :boolean,
:desc => "Whether to send reports after every transaction.",
},
:lastrunfile => {
:default => "$statedir/last_run_summary.yaml",
:type => :file,
:mode => 0644,
:desc => "Where puppet agent stores the last run report summary in yaml format."
},
:lastrunreport => {
:default => "$statedir/last_run_report.yaml",
:type => :file,
:mode => 0640,
:desc => "Where puppet agent stores the last run report in yaml format."
},
:graph => {
:default => false,
:type => :boolean,
:desc => "Whether to create dot graph files for the different
configuration graphs. These dot files can be interpreted by tools
like OmniGraffle or dot (which is part of ImageMagick).",
},
:graphdir => {
:default => "$statedir/graphs",
:type => :directory,
:desc => "Where to store dot-outputted graphs.",
},
:http_compression => {
:default => false,
:type => :boolean,
:desc => "Allow http compression in REST communication with the master.
This setting might improve performance for agent -> master
communications over slow WANs. Your puppet master needs to support
compression (usually by activating some settings in a reverse-proxy in
front of the puppet master, which rules out webrick). It is harmless to
activate this settings if your master doesn't support compression, but
if it supports it, this setting might reduce performance on high-speed LANs.",
},
:waitforcert => {
:default => "2m",
:type => :duration,
:desc => "How frequently puppet agent should ask for a signed certificate.
When starting for the first time, puppet agent will submit a certificate
signing request (CSR) to the server named in the `ca_server` setting
(usually the puppet master); this may be autosigned, or may need to be
approved by a human, depending on the CA server's configuration.
Puppet agent cannot apply configurations until its approved certificate is
available. Since the certificate may or may not be available immediately,
puppet agent will repeatedly try to fetch it at this interval. You can
turn off waiting for certificates by specifying a time of 0, in which case
puppet agent will exit if it cannot get a cert.
#{AS_DURATION}",
},
:ordering => {
:type => :enum,
:values => ["manifest", "title-hash", "random"],
:default => "title-hash",
:desc => "How unrelated resources should be ordered when applying a catalog.
Allowed values are `title-hash`, `manifest`, and `random`. This
setting affects puppet agent and puppet apply, but not puppet master.
* `title-hash` (the default) will order resources randomly, but will use
the same order across runs and across nodes.
* `manifest` will use the order in which the resources were declared in
their manifest files.
* `random` will order resources randomly and change their order with each
run. This can work like a fuzzer for shaking out undeclared dependencies.
Regardless of this setting's value, Puppet will always obey explicit
dependencies set with the before/require/notify/subscribe metaparameters
and the `->`/`~>` chaining arrows; this setting only affects the relative
ordering of _unrelated_ resources."
}
)
define_settings(:inspect,
:archive_files => {
:type => :boolean,
:default => false,
:desc => "During an inspect run, whether to archive files whose contents are audited to a file bucket.",
},
:archive_file_server => {
:default => "$server",
:desc => "During an inspect run, the file bucket server to archive files to if archive_files is set.",
}
)
# Plugin information.
define_settings(
:main,
:plugindest => {
:type => :directory,
:default => "$libdir",
:desc => "Where Puppet should store plugins that it pulls down from the central
server.",
},
:pluginsource => {
:default => "puppet://$server/plugins",
:desc => "From where to retrieve plugins. The standard Puppet `file` type
is used for retrieval, so anything that is a valid file source can
be used here.",
},
:pluginfactdest => {
:type => :directory,
:default => "$vardir/facts.d",
:desc => "Where Puppet should store external facts that are being handled by pluginsync",
},
:pluginfactsource => {
:default => "puppet://$server/pluginfacts",
:desc => "Where to retrieve external facts for pluginsync",
},
:pluginsync => {
:default => true,
:type => :boolean,
:desc => "Whether plugins should be synced with the central server.",
},
:pluginsignore => {
:default => ".svn CVS .git",
:desc => "What files to ignore when pulling down plugins.",
}
)
# Central fact information.
define_settings(
:main,
:factpath => {
:type => :path,
:default => "$vardir/lib/facter#{File::PATH_SEPARATOR}$vardir/facts",
:desc => "Where Puppet should look for facts. Multiple directories should
be separated by the system path separator character. (The POSIX path
separator is ':', and the Windows path separator is ';'.)",
:call_hook => :on_initialize_and_write, # Call our hook with the default value, so we always get the value added to facter.
:hook => proc do |value|
paths = value.split(File::PATH_SEPARATOR)
Facter.search(*paths)
end
}
)
define_settings(
:tagmail,
:tagmap => {
:default => "$confdir/tagmail.conf",
:desc => "The mapping between reporting tags and email addresses.",
},
:sendmail => {
:default => which('sendmail') || '',
:desc => "Where to find the sendmail binary with which to send email.",
},
:reportfrom => {
:default => "report@" + [Facter["hostname"].value,Facter["domain"].value].join("."),
:desc => "The 'from' email address for the reports.",
},
:smtpserver => {
:default => "none",
:desc => "The server through which to send email reports.",
},
:smtpport => {
:default => 25,
:desc => "The TCP port through which to send email reports.",
},
:smtphelo => {
:default => Facter["fqdn"].value,
:desc => "The name by which we identify ourselves in SMTP HELO for reports.
If you send to a smtpserver which does strict HELO checking (as with Postfix's
`smtpd_helo_restrictions` access controls), you may need to ensure this resolves.",
}
)
define_settings(
:rails,
:dblocation => {
:default => "$statedir/clientconfigs.sqlite3",
:type => :file,
:mode => 0660,
:owner => "service",
:group => "service",
:desc => "The sqlite database file. #{STORECONFIGS_ONLY}"
},
:dbadapter => {
:default => "sqlite3",
:desc => "The type of database to use. #{STORECONFIGS_ONLY}",
},
:dbmigrate => {
:default => false,
:type => :boolean,
:desc => "Whether to automatically migrate the database. #{STORECONFIGS_ONLY}",
},
:dbname => {
:default => "puppet",
:desc => "The name of the database to use. #{STORECONFIGS_ONLY}",
},
:dbserver => {
:default => "localhost",
:desc => "The database server for caching. Only
used when networked databases are used.",
},
:dbport => {
:default => "",
:desc => "The database password for caching. Only
used when networked databases are used. #{STORECONFIGS_ONLY}",
},
:dbuser => {
:default => "puppet",
:desc => "The database user for caching. Only
used when networked databases are used. #{STORECONFIGS_ONLY}",
},
:dbpassword => {
:default => "puppet",
:desc => "The database password for caching. Only
used when networked databases are used. #{STORECONFIGS_ONLY}",
},
:dbconnections => {
:default => '',
:desc => "The number of database connections for networked
databases. Will be ignored unless the value is a positive integer. #{STORECONFIGS_ONLY}",
},
:dbsocket => {
:default => "",
:desc => "The database socket location. Only used when networked
databases are used. Will be ignored if the value is an empty string. #{STORECONFIGS_ONLY}",
},
:railslog => {
:default => "$logdir/rails.log",
:type => :file,
:mode => 0600,
:owner => "service",
:group => "service",
:desc => "Where Rails-specific logs are sent. #{STORECONFIGS_ONLY}"
},
:rails_loglevel => {
:default => "info",
:desc => "The log level for Rails connections. The value must be
a valid log level within Rails. Production environments normally use `info`
and other environments normally use `debug`. #{STORECONFIGS_ONLY}",
}
)
define_settings(
:couchdb,
:couchdb_url => {
:default => "http://127.0.0.1:5984/puppet",
:desc => "The url where the puppet couchdb database will be created.
Only used when `facts_terminus` is set to `couch`.",
}
)
define_settings(
:transaction,
:tags => {
:default => "",
:desc => "Tags to use to find resources. If this is set, then
only resources tagged with the specified tags will be applied.
Values must be comma-separated.",
},
:evaltrace => {
:default => false,
:type => :boolean,
:desc => "Whether each resource should log when it is
being evaluated. This allows you to interactively see exactly
what is being done.",
},
:summarize => {
:default => false,
:type => :boolean,
:desc => "Whether to print a transaction summary.",
}
)
define_settings(
:main,
:external_nodes => {
:default => "none",
:desc => "An external command that can produce node information. The command's output
must be a YAML dump of a hash, and that hash must have a `classes` key and/or
a `parameters` key, where `classes` is an array or hash and
`parameters` is a hash. For unknown nodes, the command should
exit with a non-zero exit code.
This command makes it straightforward to store your node mapping
information in other data sources like databases.",
}
)
define_settings(
:ldap,
:ldapssl => {
:default => false,
:type => :boolean,
:desc => "Whether SSL should be used when searching for nodes.
Defaults to false because SSL usually requires certificates
to be set up on the client side.",
},
:ldaptls => {
:default => false,
:type => :boolean,
:desc => "Whether TLS should be used when searching for nodes.
Defaults to false because TLS usually requires certificates
to be set up on the client side.",
},
:ldapserver => {
:default => "ldap",
:desc => "The LDAP server. Only used if `node_terminus` is set to `ldap`.",
},
:ldapport => {
:default => 389,
:desc => "The LDAP port. Only used if `node_terminus` is set to `ldap`.",
},
:ldapstring => {
:default => "(&(objectclass=puppetClient)(cn=%s))",
:desc => "The search string used to find an LDAP node.",
},
:ldapclassattrs => {
:default => "puppetclass",
:desc => "The LDAP attributes to use to define Puppet classes. Values
should be comma-separated.",
},
:ldapstackedattrs => {
:default => "puppetvar",
:desc => "The LDAP attributes that should be stacked to arrays by adding
the values in all hierarchy elements of the tree. Values
should be comma-separated.",
},
:ldapattrs => {
:default => "all",
:desc => "The LDAP attributes to include when querying LDAP for nodes. All
returned attributes are set as variables in the top-level scope.
Multiple values should be comma-separated. The value 'all' returns
all attributes.",
},
:ldapparentattr => {
:default => "parentnode",
:desc => "The attribute to use to define the parent node.",
},
:ldapuser => {
:default => "",
:desc => "The user to use to connect to LDAP. Must be specified as a
full DN.",
},
:ldappassword => {
:default => "",
:desc => "The password to use to connect to LDAP.",
},
:ldapbase => {
:default => "",
:desc => "The search base for LDAP searches. It's impossible to provide
a meaningful default here, although the LDAP libraries might
have one already set. Generally, it should be the 'ou=Hosts'
branch under your main directory.",
}
)
define_settings(:master,
:storeconfigs => {
:default => false,
:type => :boolean,
:desc => "Whether to store each client's configuration, including catalogs, facts,
and related data. This also enables the import and export of resources in
the Puppet language - a mechanism for exchange resources between nodes.
By default this uses ActiveRecord and an SQL database to store and query
the data; this, in turn, will depend on Rails being available.
You can adjust the backend using the storeconfigs_backend setting.",
# Call our hook with the default value, so we always get the libdir set.
:call_hook => :on_initialize_and_write,
:hook => proc do |value|
require 'puppet/node'
require 'puppet/node/facts'
if value
if not Puppet.settings[:async_storeconfigs]
Puppet::Resource::Catalog.indirection.cache_class = :store_configs
Puppet.settings[:catalog_cache_terminus] = :store_configs
end
Puppet::Node::Facts.indirection.cache_class = :store_configs
Puppet::Resource.indirection.terminus_class = :store_configs
end
end
},
:storeconfigs_backend => {
:type => :terminus,
:default => "active_record",
:desc => "Configure the backend terminus used for StoreConfigs.
By default, this uses the ActiveRecord store, which directly talks to the
database from within the Puppet Master process."
}
)
define_settings(:parser,
:templatedir => {
:default => "$vardir/templates",
:type => :directory,
:desc => "Where Puppet looks for template files. Can be a list of colon-separated
directories.",
},
:allow_variables_with_dashes => {
:default => false,
:desc => <<-'EOT'
Permit hyphens (`-`) in variable names and issue deprecation warnings about
them. This setting **should always be `false`;** setting it to `true`
will cause subtle and wide-ranging bugs. It will be removed in a future version.
Hyphenated variables caused major problems in the language, but were allowed
between Puppet 2.7.3 and 2.7.14. If you used them during this window, we
apologize for the inconvenience --- you can temporarily set this to `true`
in order to upgrade, and can rename your variables at your leisure. Please
revert it to `false` after you have renamed all affected variables.
EOT
},
:parser => {
:default => "current",
:desc => <<-'EOT'
Selects the parser to use for parsing puppet manifests (in puppet DSL
language/'.pp' files). Available choices are `current` (the default),
and `future`.
The `curent` parser means that the released version of the parser should
be used.
The `future` parser is a "time travel to the future" allowing early
exposure to new language features. What these fatures are will vary from
release to release and they may be invididually configurable.
Available Since Puppet 3.2.
EOT
},
:max_errors => {
:default => 10,
:desc => <<-'EOT'
Sets the max number of logged/displayed parser validation errors in case
multiple errors have been detected. A value of 0 is the same as value 1.
The count is per manifest.
EOT
},
:max_warnings => {
:default => 10,
:desc => <<-'EOT'
Sets the max number of logged/displayed parser validation warnings in
case multiple errors have been detected. A value of 0 is the same as
value 1. The count is per manifest.
EOT
},
:max_deprecations => {
:default => 10,
:desc => <<-'EOT'
Sets the max number of logged/displayed parser validation deprecation
warnings in case multiple errors have been detected. A value of 0 is the
same as value 1. The count is per manifest.
EOT
}
)
define_settings(:puppetdoc,
:document_all => {
:default => false,
:type => :boolean,
:desc => "Whether to document all resources when using `puppet doc` to
generate manifest documentation.",
}
)
end
puppet-3.4.3/lib/puppet/data_binding.rb 0000644 0052762 0001160 00000000552 12300765631 017746 0 ustar jenkins jenkins require 'puppet/indirector'
# A class for managing data lookups
class Puppet::DataBinding
class LookupError < Puppet::Error; end
# Set up indirection, so that data can be looked for in the compiler
extend Puppet::Indirector
indirects(:data_binding, :terminus_setting => :data_binding_terminus,
:doc => "Where to find external data bindings.")
end
puppet-3.4.3/lib/puppet/pops/ 0000755 0052762 0001160 00000000000 12300765640 015775 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/pops/adaptable.rb 0000644 0052762 0001160 00000016750 12300765631 020250 0 ustar jenkins jenkins # Adaptable is a mix-in module that adds adaptability to a class.
# This means that an adapter can
# associate itself with an instance of the class and store additional data/have behavior.
#
# This mechanism should be used when there is a desire to keep implementation concerns separate.
# In Ruby it is always possible to open and modify a class or instance to teach it new tricks, but it
# is however not possible to do this for two different versions of some service at the same time.
# The Adaptable pattern is also good when only a few of the objects of some class needs to have extra
# information (again possible in Ruby by adding instance variables dynamically). In fact, the implementation
# of Adaptable does just that; it adds an instance variable named after the adapter class and keeps an
# instance of this class in this slot.
#
# @note the implementation details; the fact that an instance variable is used to keep the adapter
# instance data should not
# be exploited as the implementation of _being adaptable_ may change in the future.
# @api private
#
module Puppet::Pops::Adaptable
# Base class for an Adapter.
#
# A typical adapter just defines some accessors.
#
# A more advanced adapter may need to setup the adapter based on the object it is adapting.
# @example Making Duck adaptable
# class Duck
# include Puppet::Pops::Adaptable
# end
# @example Giving a Duck a nick name
# class NickNameAdapter < Puppet::Pops::Adaptable::Adapter
# attr_accessor :nick_name
# end
# d = Duck.new
# NickNameAdapter.adapt(d).nick_name = "Daffy"
# NickNameAdapter.get(d).nick_name # => "Daffy"
#
# @example Giving a Duck a more elaborate nick name
# class NickNameAdapter < Puppet::Pops::Adaptable::Adapter
# attr_accessor :nick_name, :object
# def initialize o
# @object = o
# @nick_name = "Yo"
# end
# def nick_name
# "#{@nick_name}, the #{o.class.name}"
# end
# def NickNameAdapter.create_adapter(o)
# x = new o
# x
# end
# end
# d = Duck.new
# n = NickNameAdapter.adapt(d)
# n.nick_name # => "Yo, the Duck"
# n.nick_name = "Daffy"
# n.nick_name # => "Daffy, the Duck"
# @example Using a block to set values
# NickNameAdapter.adapt(o) { |a| a.nick_name = "Buddy!" }
# NickNameAdapter.adapt(o) { |a, o| a.nick_name = "You're the best #{o.class.name} I met."}
#
class Adapter
# Returns an existing adapter for the given object, or nil, if the object is not
# adapted.
#
# @param o [Adaptable] object to get adapter from
# @return [Adapter] an adapter of the same class as the receiver of #get
# @return [nil] if the given object o has not been adapted by the receiving adapter
# @raise [ArgumentError] if the object is not adaptable
#
def self.get(o)
attr_name = :"@#{instance_var_name(self.name)}"
if o.instance_variable_defined?(attr_name)
o.instance_variable_get(attr_name)
else
nil
end
end
# Returns an existing adapter for the given object, or creates a new adapter if the
# object has not been adapted, or the adapter has been cleared.
#
# @example Using a block to set values
# NickNameAdapter.adapt(o) { |a| a.nick_name = "Buddy!" }
# NickNameAdapter.adapt(o) { |a, o| a.nick_name = "Your the best #{o.class.name} I met."}
# @overload adapt(o)
# @overload adapt(o, {|adapter| block})
# @overload adapt(o, {|adapter, o| block})
# @param o [Adaptable] object to add adapter to
# @yieldparam adapter [Adapter] the created adapter
# @yieldparam o [Adaptable] optional, the given adaptable
# @param block [Proc] optional, evaluated in the context of the adapter (existing or new)
# @return [Adapter] an adapter of the same class as the receiver of the call
# @raise [ArgumentError] if the given object o is not adaptable
#
def self.adapt(o, &block)
attr_name = :"@#{instance_var_name(self.name)}"
adapter = if o.instance_variable_defined?(attr_name) && value = o.instance_variable_get(attr_name)
value
else
associate_adapter(create_adapter(o), o)
end
if block_given?
case block.arity
when 1
block.call(adapter)
else
block.call(adapter, o)
end
end
adapter
end
# Creates a new adapter, associates it with the given object and returns the adapter.
#
# @example Using a block to set values
# NickNameAdapter.adapt_new(o) { |a| a.nick_name = "Buddy!" }
# NickNameAdapter.adapt_new(o) { |a, o| a.nick_name = "Your the best #{o.class.name} I met."}
# This is used when a fresh adapter is wanted instead of possible returning an
# existing adapter as in the case of {Adapter.adapt}.
# @overload adapt_new(o)
# @overload adapt_new(o, {|adapter| block})
# @overload adapt_new(o, {|adapter, o| block})
# @yieldparam adapter [Adapter] the created adapter
# @yieldparam o [Adaptable] optional, the given adaptable
# @param o [Adaptable] object to add adapter to
# @param block [Proc] optional, evaluated in the context of the new adapter
# @return [Adapter] an adapter of the same class as the receiver of the call
# @raise [ArgumentError] if the given object o is not adaptable
#
def self.adapt_new(o, &block)
adapter = associate_adapter(create_adapter(o), o)
if block_given?
case block.arity
when 1
block.call(adapter)
else
block.call(adapter, o)
end
end
adapter
end
# Clears the adapter set in the given object o. Returns any set adapter or nil.
# @param o [Adaptable] the object where the adapter should be cleared
# @return [Adapter] if an adapter was set
# @return [nil] if the adapter has not been set
#
def self.clear(o)
attr_name = :"@#{instance_var_name(self.name)}"
if o.instance_variable_defined?(attr_name)
o.send(:remove_instance_variable, attr_name)
else
nil
end
end
# This base version creates an instance of the class (i.e. an instance of the concrete subclass
# of Adapter). A Specialization may want to create an adapter instance specialized for the given target
# object.
# @param o [Adaptable] The object to adapt. This implementation ignores this variable, but a
# specialization may want to initialize itself differently depending on the object it is adapting.
# @return [Adapter] instance of the subclass of Adapter receiving the call
#
def self.create_adapter(o)
new
end
# Associates the given adapter with the given target object
# @param adapter [Adapter] the adapter to associate with the given object _o_
# @param o [Adaptable] the object to adapt
# @return [adapter] the given adapter
#
def self.associate_adapter(adapter, o)
attr_name = :"@#{instance_var_name(adapter.class.name)}"
o.instance_variable_set(attr_name, adapter)
adapter
end
# Returns a suitable instance variable name given a class name.
# The returned string is the fully qualified name of a class with '::' replaced by '_' since
# '::' is not allowed in an instance variable name.
# @param name [String] the fully qualified name of a class
# @return [String] the name with all '::' replaced by '_'
# @api private
# @private
#
def self.instance_var_name(name)
name.split("::").join('_')
end
end
end
puppet-3.4.3/lib/puppet/pops/visitable.rb 0000644 0052762 0001160 00000000270 12300765631 020303 0 ustar jenkins jenkins # Visitable is a mix-in module that makes a class visitable by a Visitor
module Puppet::Pops::Visitable
def accept(visitor, *arguments)
visitor.visit(self, *arguments)
end
end
puppet-3.4.3/lib/puppet/pops/utils.rb 0000644 0052762 0001160 00000005607 12300765631 017472 0 ustar jenkins jenkins # Provides utility methods
module Puppet::Pops::Utils
# Can the given o be converted to numeric? (or is numeric already)
# Accepts a leading '::'
# Returns a boolean if the value is numeric
# If testing if value can be converted it is more efficient to call {#to_n} or {#to_n_with_radix} directly
# and check if value is nil.
def self.is_numeric?(o)
case o
when Numeric, Integer, Fixnum, Float
!!o
else
!!Puppet::Pops::Patterns::NUMERIC.match(relativize_name(o.to_s))
end
end
# To LiteralNumber with radix, or nil if not a number.
# If the value is already a number it is returned verbatim with a radix of 10.
# @param o [String, Number] a string containing a number in octal, hex, integer (decimal) or floating point form
# @return [Array, nil] array with converted number and radix, or nil if not possible to convert
# @api public
#
def self.to_n_with_radix o
begin
case o
when String
match = Puppet::Pops::Patterns::NUMERIC.match(relativize_name(o))
if !match
nil
elsif match[3].to_s.length > 0
# Use default radix (default is decimal == 10) for floats
[Float(match[0]), 10]
else
# Set radix (default is decimal == 10)
radix = 10
if match[1].to_s.length > 0
radix = 16
elsif match[2].to_s.length > 1 && match[2][0] == '0'
radix = 8
end
[Integer(match[0], radix), radix]
end
when Numeric, Fixnum, Integer, Float
# Impossible to calculate radix, assume decimal
[o, 10]
else
nil
end
rescue ArgumentError
nil
end
end
# To Numeric (or already numeric)
# Returns nil if value is not numeric, else an Integer or Float
# A leading '::' is accepted (and ignored)
#
def self.to_n o
begin
case o
when String
match = Puppet::Pops::Patterns::NUMERIC.match(relativize_name(o))
if !match
nil
elsif match[3].to_s.length > 0
Float(match[0])
else
Integer(match[0])
end
when Numeric, Fixnum, Integer, Float
o
else
nil
end
rescue ArgumentError
nil
end
end
# is the name absolute (i.e. starts with ::)
def self.is_absolute? name
name.start_with? "::"
end
def self.name_to_segments name
name.split("::")
end
def self.relativize_name name
is_absolute?(name) ? name[2..-1] : name
end
# Finds an adapter for o or for one of its containers, or nil, if none of the containers
# was adapted with the given adapter.
# This method can only be used with objects that respond to `:eContainer`.
# with true, and Adaptable#adapters.
#
def self.find_adapter(o, adapter)
return nil unless o
a = adapter.get(o)
return a if a
return find_adapter(o.eContainer, adapter)
end
end
puppet-3.4.3/lib/puppet/pops/model/ 0000755 0052762 0001160 00000000000 12300765640 017075 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/pops/model/ast_transformer.rb 0000644 0052762 0001160 00000051476 12300765631 022650 0 ustar jenkins jenkins require 'puppet/parser/ast'
# The receiver of `import(file)` calls; once per imported file, or nil if imports are ignored
#
# Transforms a Pops::Model to classic Puppet AST.
# TODO: Documentation is currently skipped completely (it is only used for Rdoc)
#
class Puppet::Pops::Model::AstTransformer
AST = Puppet::Parser::AST
Model = Puppet::Pops::Model
attr_reader :importer
def initialize(source_file = "unknown-file", importer=nil)
@@transform_visitor ||= Puppet::Pops::Visitor.new(nil,"transform",0,0)
@@query_transform_visitor ||= Puppet::Pops::Visitor.new(nil,"query",0,0)
@@hostname_transform_visitor ||= Puppet::Pops::Visitor.new(nil,"hostname",0,0)
@importer = importer
@source_file = source_file
end
# Initialize klass from o (location) and hash (options to created instance).
# The object o is used to compute a source location. It may be nil. Source position is merged into
# the given options (non surgically). If o is non-nil, the first found source position going up
# the containment hierarchy is set. I.e. callers should pass nil if a source position is not wanted
# or known to be unobtainable for the object.
#
# @param o [Object, nil] object from which source position / location is obtained, may be nil
# @param klass [Class] the ast class to create an instance of
# @param hash [Hash] hash with options for the class to create
#
def ast(o, klass, hash={})
# create and pass hash with file and line information
klass.new(merge_location(hash, o))
end
def merge_location(hash, o)
if o
pos = {}
source_pos = Puppet::Pops::Utils.find_adapter(o, Puppet::Pops::Adapters::SourcePosAdapter)
if source_pos
pos[:line] = source_pos.line
pos[:pos] = source_pos.pos
end
pos[:file] = @source_file if @source_file
hash = hash.merge(pos)
end
hash
end
# Transforms pops expressions into AST 3.1 statements/expressions
def transform(o)
@@transform_visitor.visit_this(self,o)
end
# Transforms pops expressions into AST 3.1 query expressions
def query(o)
@@query_transform_visitor.visit_this(self, o)
end
# Transforms pops expressions into AST 3.1 hostnames
def hostname(o)
@@hostname_transform_visitor.visit_this(self, o)
end
def transform_LiteralNumber(o)
s = case o.radix
when 10
o.value.to_s
when 8
"0%o" % o.value
when 16
"0x%X" % o.value
else
"bad radix:" + o.value.to_s
end
# Numbers are Names in the AST !! (Name a.k.a BareWord)
ast o, AST::Name, :value => s
end
# Transforms all literal values to string (override for those that should not be AST::String)
#
def transform_LiteralValue(o)
ast o, AST::String, :value => o.value.to_s
end
def transform_LiteralBoolean(o)
ast o, AST::Boolean, :value => o.value
end
def transform_Factory(o)
transform(o.current)
end
def transform_ArithmeticExpression(o)
ast o, AST::ArithmeticOperator2, :lval => transform(o.left_expr), :rval=>transform(o.right_expr),
:operator => o.operator.to_s
end
def transform_Array(o)
ast nil, AST::ASTArray, :children => o.collect {|x| transform(x) }
end
# Puppet AST only allows:
# * variable[expression] => Hasharray Access
# * NAME [expressions] => Resource Reference(s)
# * type [epxressions] => Resource Reference(s)
# * HashArrayAccesses[expression] => HasharrayAccesses
#
# i.e. it is not possible to do `func()[3]`, `[1,2,3][$x]`, `{foo=>10, bar=>20}[$x]` etc. since
# LHS is not an expression
#
# Validation for 3.x semantics should validate the illegal cases. This transformation may fail,
# or ignore excess information if the expressions are not correct.
# This means that the transformation does not have to evaluate the lhs to detect the target expression.
#
# Hm, this seems to have changed, the LHS (variable) is evaluated if evaluateable, else it is used as is.
#
def transform_AccessExpression(o)
case o.left_expr
when Model::QualifiedName
ast o, AST::ResourceReference, :type => o.left_expr.value, :title => transform(o.keys)
when Model::QualifiedReference
ast o, AST::ResourceReference, :type => o.left_expr.value, :title => transform(o.keys)
when Model::VariableExpression
ast o, AST::HashOrArrayAccess, :variable => transform(o.left_expr), :key => transform(o.keys()[0])
else
ast o, AST::HashOrArrayAccess, :variable => transform(o.left_expr), :key => transform(o.keys()[0])
end
end
# Puppet AST has a complicated structure
# LHS can not be an expression, it must be a type (which is downcased).
# type = a downcased QualifiedName
#
def transform_CollectExpression(o)
raise "LHS is not a type" unless o.type_expr.is_a? Model::QualifiedReference
type = o.type_expr.value().downcase()
args = { :type => type }
# This somewhat peculiar encoding is used by the 3.1 AST.
query = transform(o.query)
if query.is_a? Symbol
args[:form] = query
else
args[:form] = query.form
args[:query] = query
query.type = type
end
if o.operations.size > 0
args[:override] = transform(o.operations)
end
ast o, AST::Collection, args
end
def transform_ExportedQuery(o)
if is_nop?(o.expr)
result = :exported
else
result = query(o.expr)
result.form = :exported
end
result
end
def transform_VirtualQuery(o)
if is_nop?(o.expr)
result = :virtual
else
result = query(o.expr)
result.form = :virtual
end
result
end
# Ensures transformation fails if a 3.1 non supported object is encountered in a query expression
#
def query_Object(o)
raise "Not a valid expression in a collection query: "+o.class.name
end
# Puppet AST only allows == and !=, and left expr is restricted, but right value is an expression
#
def query_ComparisonExpression(o)
if [:'==', :'!='].include? o.operator
ast o, AST::CollExpr, :test1 => query(o.left_expr), :oper => o.operator.to_s, :test2 => transform(o.right_expr)
else
raise "Not a valid comparison operator in a collection query: " + o.operator.to_s
end
end
def query_AndExpression(o)
ast o, AST::CollExpr, :test1 => query(o.left_expr), :oper => 'and', :test2 => query(o.right_expr)
end
def query_OrExpression(o)
ast o, AST::CollExpr, :test1 => query(o.left_expr), :oper => 'or', :test2 => query(o.right_expr)
end
def query_ParenthesizedExpression(o)
result = query(o.expr) # produces CollExpr
result.parens = true
result
end
def query_VariableExpression(o)
transform(o)
end
def query_QualifiedName(o)
transform(o)
end
def query_LiteralNumber(o)
transform(o) # number to string in correct radix
end
def query_LiteralString(o)
transform(o)
end
def query_LiteralBoolean(o)
transform(o)
end
def transform_QualifiedName(o)
ast o, AST::Name, :value => o.value
end
def transform_QualifiedReference(o)
ast o, AST::Type, :value => o.value
end
def transform_ComparisonExpression(o)
ast o, AST::ComparisonOperator, :operator => o.operator.to_s, :lval => transform(o.left_expr), :rval => transform(o.right_expr)
end
def transform_AndExpression(o)
ast o, AST::BooleanOperator, :operator => 'and', :lval => transform(o.left_expr), :rval => transform(o.right_expr)
end
def transform_OrExpression(o)
ast o, AST::BooleanOperator, :operator => 'or', :lval => transform(o.left_expr), :rval => transform(o.right_expr)
end
def transform_InExpression(o)
ast o, AST::InOperator, :lval => transform(o.left_expr), :rval => transform(o.right_expr)
end
# This is a complex transformation from a modeled import to a Nop result (where the import took place),
# and calls to perform import/parsing etc. during the transformation.
# When testing syntax, the @importer does not have to be set, but it is not possible to check
# the actual import without inventing a new AST::ImportExpression with nop effect when evaluating.
def transform_ImportExpression(o)
if importer
o.files.each {|f|
unless f.is_a? Model::LiteralString
raise "Illegal import file expression. Must be a single quoted string"
end
importer.import(f.value)
}
end
# Crazy stuff
# Transformation of "import" needs to parse the other files at the time of transformation.
# Then produce a :nop, since nothing should be evaluated.
ast o, AST::Nop, {}
end
def transform_InstanceReferences(o)
ast o, AST::ResourceReference, :type => o.type_name.value, :title => transform(o.names)
end
# Assignment in AST 3.1 is to variable or hasharray accesses !!! See Bug #16116
def transform_AssignmentExpression(o)
args = {:value => transform(o.right_expr) }
args[:append] = true if o.operator == :'+='
args[:name] = case o.left_expr
when Model::VariableExpression
ast o, AST::Name, {:value => o.left_expr.expr.value }
when Model::AccessExpression
transform(o.left_expr)
else
raise "LHS is not an expression that can be assigned to"
end
ast o, AST::VarDef, args
end
# Produces (name => expr) or (name +> expr)
def transform_AttributeOperation(o)
args = { :value => transform(o.value_expr) }
args[:add] = true if o.operator == :'+>'
args[:param] = o.attribute_name
ast o, AST::ResourceParam, args
end
def transform_LiteralList(o)
# Uses default transform of Ruby Array to ASTArray
transform(o.values)
end
# Literal hash has strange behavior in Puppet 3.1. See Bug #19426, and this implementation is bug
# compatible
def transform_LiteralHash(o)
if o.entries.size == 0
ast o, AST::ASTHash, {:value=> {}}
else
value = {}
o.entries.each {|x| value.merge! transform(x) }
ast o, AST::ASTHash, {:value=> value}
end
end
# Transforms entry into a hash (they are later merged with strange effects: Bug #19426).
# Puppet 3.x only allows:
# * NAME
# * quotedtext
# As keys (quoted text can be an interpolated string which is compared as a key in a less than satisfactory way).
#
def transform_KeyedEntry(o)
value = transform(o.value)
key = case o.key
when Model::QualifiedName
o.key.value
when Model::LiteralString
transform o.key
when Model::LiteralNumber
transform o.key
when Model::ConcatenatedString
transform o.key
else
raise "Illegal hash key expression of type (#{o.key.class})"
end
{key => value}
end
def transform_MatchExpression(o)
ast o, AST::MatchOperator, :operator => o.operator.to_s, :lval => transform(o.left_expr), :rval => transform(o.right_expr)
end
def transform_LiteralString(o)
ast o, AST::String, :value => o.value
end
# Literal text in a concatenated string
def transform_LiteralText(o)
ast o, AST::String, :value => o.value
end
def transform_LambdaExpression(o)
astargs = { :parameters => o.parameters.collect {|p| transform(p) } }
astargs.merge!({ :children => transform(o.body) }) if o.body # do not want children if it is nil/nop
ast o, AST::Lambda, astargs
end
def transform_LiteralDefault(o)
ast o, AST::Default, :value => :default
end
def transform_LiteralUndef(o)
ast o, AST::Undef, :value => :undef
end
def transform_LiteralRegularExpression(o)
ast o, AST::Regex, :value => o.value
end
def transform_Nop(o)
ast o, AST::Nop
end
# In the 3.1. grammar this is a hash that is merged with other elements to form a method call
# Also in 3.1. grammar there are restrictions on the LHS (that are only there for grammar issues).
#
def transform_NamedAccessExpression(o)
receiver = transform(o.left_expr)
name = o.right_expr
raise "Unacceptable function/method name" unless name.is_a? Model::QualifiedName
{:receiver => receiver, :name => name.value}
end
def transform_NilClass(o)
ast o, AST::Nop, {}
end
def transform_NotExpression(o)
ast o, AST::Not, :value => transform(o.expr)
end
def transform_VariableExpression(o)
# assumes the expression is a QualifiedName
ast o, AST::Variable, :value => o.expr.value
end
# In Puppet 3.1, the ConcatenatedString is responsible for the evaluation and stringification of
# expression segments. Expressions and Strings are kept in an array.
def transform_TextExpression(o)
transform(o.expr)
end
def transform_UnaryMinusExpression(o)
ast o, AST::Minus, :value => transform(o.expr)
end
# Puppet 3.1 representation of a BlockExpression is an AST::Array - this makes it impossible to differentiate
# between a LiteralArray and a Sequence. (Should it return the collected array, or the last expression?)
# (A BlockExpression has now been introduced in the AST to solve this).
#
def transform_BlockExpression(o)
children = []
# remove nops resulting from import
o.statements.each {|s| r = transform(s); children << r unless is_nop?(r) }
ast o, AST::BlockExpression, :children => children # o.statements.collect {|s| transform(s) }
end
# Interpolated strings are kept in an array of AST (string or other expression).
def transform_ConcatenatedString(o)
ast o, AST::Concat, :value => o.segments.collect {|x| transform(x)}
end
def transform_HostClassDefinition(o)
parameters = o.parameters.collect {|p| transform(p) }
args = {
:arguments => parameters,
:parent => o.parent_class,
}
args[:code] = transform(o.body) unless is_nop?(o.body)
Puppet::Parser::AST::Hostclass.new(o.name, merge_location(args, o))
end
def transform_NodeDefinition(o)
# o.host_matches are expressions, and 3.1 AST requires special object AST::HostName
# where a HostName is one of NAME, STRING, DEFAULT or Regexp - all of these are strings except regexp
#
args = {
:code => transform(o.body)
}
args[:parent] = hostname(o.parent) unless is_nop?(o.parent)
if(args[:parent].is_a?(Array))
raise "Illegal expression - unacceptable as a node parent"
end
Puppet::Parser::AST::Node.new(hostname(o.host_matches), merge_location(args, o))
end
# Transforms Array of host matching expressions into a (Ruby) array of AST::HostName
def hostname_Array(o)
o.collect {|x| ast x, AST::HostName, :value => hostname(x) }
end
def hostname_LiteralValue(o)
return o.value
end
def hostname_QualifiedName(o)
return o.value
end
def hostname_LiteralNumber(o)
transform(o) # Number to string with correct radix
end
def hostname_LiteralDefault(o)
return 'default'
end
def hostname_LiteralRegularExpression(o)
ast o, AST::Regex, :value => o.value
end
def hostname_Object(o)
raise "Illegal expression - unacceptable as a node name"
end
def transform_RelationshipExpression(o)
Puppet::Parser::AST::Relationship.new(transform(o.left_expr), transform(o.right_expr), o.operator.to_s, merge_location({}, o))
end
def transform_ResourceTypeDefinition(o)
parameters = o.parameters.collect {|p| transform(p) }
args = { :arguments => parameters }
args[:code] = transform(o.body) unless is_nop?(o.body)
Puppet::Parser::AST::Definition.new(o.name, merge_location(args, o))
end
# Transformation of ResourceOverrideExpression is slightly more involved than a straight forward
# transformation.
# A ResourceOverrideExppression has "resources" which should be an AccessExpression
# on the form QualifiedName[expressions], or QualifiedReference[expressions] to be valid.
# It also has a set of attribute operations.
#
# The AST equivalence is an AST::ResourceOverride with a ResourceReference as its LHS, and
# a set of Parameters.
# ResourceReference has type as a string, and the expressions representing
# the "titles" to be an ASTArray.
#
def transform_ResourceOverrideExpression(o)
resource_ref = o.resources
raise "Unacceptable expression for resource override" unless resource_ref.is_a? Model::AccessExpression
type = case resource_ref.left_expr
when Model::QualifiedName
# This is deprecated "Resource references should now be capitalized" - this is caught elsewhere
resource_ref.left_expr.value
when Model::QualifiedReference
resource_ref.left_expr.value
else
raise "Unacceptable expression for resource override; need NAME or CLASSREF"
end
result_ref = ast o, AST::ResourceReference, :type => type, :title => transform(resource_ref.keys)
# title is one or more expressions, if more than one it should be an ASTArray
ast o, AST::ResourceOverride, :object => result_ref, :parameters => transform(o.operations)
end
# Parameter is a parameter in a definition of some kind.
# It is transformed to an array on the form `[name]´, or `[name, value]´.
def transform_Parameter(o)
if o.value
[o.name, transform(o.value)]
else
[o.name]
end
end
# For non query expressions, parentheses can be dropped in the resulting AST.
def transform_ParenthesizedExpression(o)
transform(o.expr)
end
def transform_IfExpression(o)
args = { :test => transform(o.test), :statements => transform(o.then_expr) }
args[:else] = transform(o.else_expr) # Tests say Nop should be there (unless is_nop? o.else_expr), probably not needed
ast o, AST::IfStatement, args
end
# Unless is not an AST object, instead an AST::IfStatement is used with an AST::Not around the test
#
def transform_UnlessExpression(o)
args = { :test => ast(o, AST::Not, :value => transform(o.test)),
:statements => transform(o.then_expr) }
# AST 3.1 does not allow else on unless in the grammar, but it is ok since unless is encoded as an if !x
args.merge!({:else => transform(o.else_expr)}) unless is_nop?(o.else_expr)
ast o, AST::IfStatement, args
end
# Puppet 3.1 AST only supports calling a function by name (it is not possible to produce a function
# that is then called).
# rval_required (for an expression)
# functor_expr (lhs - the "name" expression)
# arguments - list of arguments
#
def transform_CallNamedFunctionExpression(o)
name = o.functor_expr
raise "Unacceptable expression for name of function" unless name.is_a? Model::QualifiedName
args = {
:name => name.value,
:arguments => transform(o.arguments),
:ftype => o.rval_required ? :rvalue : :statement
}
args[:pblock] = transform(o.lambda) if o.lambda
ast o, AST::Function, args
end
# Transformation of CallMethodExpression handles a NamedAccessExpression functor and
# turns this into a 3.1 AST::MethodCall.
#
def transform_CallMethodExpression(o)
name = o.functor_expr
raise "Unacceptable expression for name of function" unless name.is_a? Model::NamedAccessExpression
# transform of NamedAccess produces a hash, add arguments to it
astargs = transform(name).merge(:arguments => transform(o.arguments))
astargs.merge!(:lambda => transform(o.lambda)) if o.lambda # do not want a Nop as the lambda
ast o, AST::MethodCall, astargs
end
def transform_CaseExpression(o)
# Expects expression, AST::ASTArray of AST
ast o, AST::CaseStatement, :test => transform(o.test), :options => transform(o.options)
end
def transform_CaseOption(o)
ast o, AST::CaseOpt, :value => transform(o.values), :statements => transform(o.then_expr)
end
def transform_ResourceBody(o)
# expects AST, AST::ASTArray of AST
ast o, AST::ResourceInstance, :title => transform(o.title), :parameters => transform(o.operations)
end
def transform_ResourceDefaultsExpression(o)
ast o, AST::ResourceDefaults, :type => o.type_ref.value, :parameters => transform(o.operations)
end
# Transformation of ResourceExpression requires calling a method on the resulting
# AST::Resource if it is virtual or exported
#
def transform_ResourceExpression(o)
raise "Unacceptable type name expression" unless o.type_name.is_a? Model::QualifiedName
resource = ast o, AST::Resource, :type => o.type_name.value, :instances => transform(o.bodies)
resource.send("#{o.form}=", true) unless o.form == :regular
resource
end
# Transformation of SelectorExpression is limited to certain types of expressions.
# This is probably due to constraints in the old grammar rather than any real concerns.
def transform_SelectorExpression(o)
case o.left_expr
when Model::CallNamedFunctionExpression
when Model::AccessExpression
when Model::VariableExpression
when Model::ConcatenatedString
else
raise "Unacceptable select expression" unless o.left_expr.kind_of? Model::Literal
end
ast o, AST::Selector, :param => transform(o.left_expr), :values => transform(o.selectors)
end
def transform_SelectorEntry(o)
ast o, AST::ResourceParam, :param => transform(o.matching_expr), :value => transform(o.value_expr)
end
def transform_Object(o)
raise "Unacceptable transform - found an Object without a rule: #{o.class}"
end
# Nil, nop
# Bee bopp a luh-lah, a bop bop boom.
#
def is_nop?(o)
o.nil? || o.is_a?(Model::Nop)
end
end
puppet-3.4.3/lib/puppet/pops/model/tree_dumper.rb 0000644 0052762 0001160 00000002356 12300765631 021743 0 ustar jenkins jenkins # Base class for formatted textual dump of a "model"
#
class Puppet::Pops::Model::TreeDumper
attr_accessor :indent_count
def initialize initial_indentation = 0
@@dump_visitor ||= Puppet::Pops::Visitor.new(nil,"dump",0,0)
@indent_count = initial_indentation
end
def dump(o)
format(do_dump(o))
end
def do_dump(o)
@@dump_visitor.visit_this(self, o)
end
def indent
" " * indent_count
end
def format(x)
result = ""
parts = format_r(x)
parts.each_index do |i|
if i > 0
# separate with space unless previous ends with whitepsace or (
result << ' ' if parts[i] != ")" && parts[i-1] !~ /.*(?:\s+|\()$/ && parts[i] !~ /^\s+/
end
result << parts[i].to_s
end
result
end
def format_r(x)
result = []
case x
when :break
result << "\n" + indent
when :indent
@indent_count += 1
when :dedent
@indent_count -= 1
when Array
result << '('
result += x.collect {|a| format_r(a) }.flatten
result << ')'
when Symbol
result << x.to_s # Allows Symbols in arrays e.g. ["text", =>, "text"]
else
result << x
end
result
end
def is_nop? o
o.nil? || o.is_a?(Puppet::Pops::Model::Nop)
end
end
puppet-3.4.3/lib/puppet/pops/model/model_label_provider.rb 0000644 0052762 0001160 00000012626 12300765631 023602 0 ustar jenkins jenkins # A provider of labels for model object, producing a human name for the model object.
# As an example, if object is an ArithmeticExpression with operator +, `#a_an(o)` produces "a '+' Expression",
# #the(o) produces "the + Expression", and #label produces "+ Expression".
#
class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
def initialize
@@label_visitor ||= Puppet::Pops::Visitor.new(self,"label",0,0)
end
# Produces a label for the given objects type/operator without article.
def label o
@@label_visitor.visit(o)
end
def label_Factory o ; label(o.current) end
def label_Array o ; "Array Object" end
def label_LiteralNumber o ; "Literal Number" end
def label_ArithmeticExpression o ; "'#{o.operator}' expression" end
def label_AccessExpression o ; "'[]' expression" end
def label_MatchExpression o ; "'#{o.operator}' expression" end
def label_CollectExpression o ; label(o.query) end
def label_ExportedQuery o ; "Exported Query" end
def label_VirtualQuery o ; "Virtual Query" end
def label_QueryExpression o ; "Collect Query" end
def label_ComparisonExpression o ; "'#{o.operator}' expression" end
def label_AndExpression o ; "'and' expression" end
def label_OrExpression o ; "'or' expression" end
def label_InExpression o ; "'in' expression" end
def label_ImportExpression o ; "'import' expression" end
def label_InstanceReferences o ; "Resource Reference" end
def label_AssignmentExpression o ; "'#{o.operator}' expression" end
def label_AttributeOperation o ; "'#{o.operator}' expression" end
def label_LiteralList o ; "Array Expression" end
def label_LiteralHash o ; "Hash Expression" end
def label_KeyedEntry o ; "Hash Entry" end
def label_LiteralBoolean o ; "Boolean" end
def label_LiteralString o ; "String" end
def label_LiteralText o ; "Text in Interpolated String" end
def label_LambdaExpression o ; "Lambda" end
def label_LiteralDefault o ; "'default' expression" end
def label_LiteralUndef o ; "'undef' expression" end
def label_LiteralRegularExpression o ; "Regular Expression" end
def label_Nop o ; "Nop Expression" end
def label_NamedAccessExpression o ; "'.' expression" end
def label_NilClass o ; "Nil Object" end
def label_NotExpression o ; "'not' expression" end
def label_VariableExpression o ; "Variable" end
def label_TextExpression o ; "Expression in Interpolated String" end
def label_UnaryMinusExpression o ; "Unary Minus" end
def label_BlockExpression o ; "Block Expression" end
def label_ConcatenatedString o ; "Double Quoted String" end
def label_HostClassDefinition o ; "Host Class Definition" end
def label_NodeDefinition o ; "Node Definition" end
def label_ResourceTypeDefinition o ; "'define' expression" end
def label_ResourceOverrideExpression o ; "Resource Override" end
def label_Parameter o ; "Parameter Definition" end
def label_ParenthesizedExpression o ; "Parenthesized Expression" end
def label_IfExpression o ; "'if' statement" end
def label_UnlessExpression o ; "'unless' Statement" end
def label_CallNamedFunctionExpression o ; "Function Call" end
def label_CallMethodExpression o ; "Method call" end
def label_CaseExpression o ; "'case' statement" end
def label_CaseOption o ; "Case Option" end
def label_RelationshipExpression o ; "'#{o.operator}' expression" end
def label_ResourceBody o ; "Resource Instance Definition" end
def label_ResourceDefaultsExpression o ; "Resource Defaults Expression" end
def label_ResourceExpression o ; "Resource Statement" end
def label_SelectorExpression o ; "Selector Expression" end
def label_SelectorEntry o ; "Selector Option" end
def label_String o ; "Ruby String" end
def label_Object o ; "Ruby Object" end
def label_QualifiedName o ; "Name" end
def label_QualifiedReference o ; "Type Name" end
end
puppet-3.4.3/lib/puppet/pops/model/model_tree_dumper.rb 0000644 0052762 0001160 00000017571 12300765631 023130 0 ustar jenkins jenkins # Dumps a Pops::Model in reverse polish notation; i.e. LISP style
# The intention is to use this for debugging output
# TODO: BAD NAME - A DUMP is a Ruby Serialization
#
class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
def dump_Array o
o.collect {|e| do_dump(e) }
end
def dump_LiteralNumber o
case o.radix
when 10
o.value.to_s
when 8
"0%o" % o.value
when 16
"0x%X" % o.value
else
"bad radix:" + o.value.to_s
end
end
def dump_LiteralValue o
o.value.to_s
end
def dump_Factory o
do_dump(o.current)
end
def dump_ArithmeticExpression o
[o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
end
# x[y] prints as (slice x y)
def dump_AccessExpression o
if o.keys.size <= 1
["slice", do_dump(o.left_expr), do_dump(o.keys[0])]
else
["slice", do_dump(o.left_expr), do_dump(o.keys)]
end
end
def dump_MatchesExpression o
[o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
end
def dump_CollectExpression o
result = ["collect", do_dump(o.type_expr), :indent, :break, do_dump(o.query), :indent]
o.operations do |ao|
result << :break << do_dump(ao)
end
result += [:dedent, :dedent ]
result
end
def dump_ExportedQuery o
result = ["<<| |>>"]
result += dump_QueryExpression(o) unless is_nop?(o.expr)
result
end
def dump_VirtualQuery o
result = ["<| |>"]
result += dump_QueryExpression(o) unless is_nop?(o.expr)
result
end
def dump_QueryExpression o
[do_dump(o.expr)]
end
def dump_ComparisonExpression o
[o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
end
def dump_AndExpression o
["&&", do_dump(o.left_expr), do_dump(o.right_expr)]
end
def dump_OrExpression o
["||", do_dump(o.left_expr), do_dump(o.right_expr)]
end
def dump_InExpression o
["in", do_dump(o.left_expr), do_dump(o.right_expr)]
end
def dump_ImportExpression o
["import"] + o.files.collect {|f| do_dump(f) }
end
def dump_InstanceReferences o
["instances", do_dump(o.type_name)] + o.names.collect {|n| do_dump(n) }
end
def dump_AssignmentExpression o
[o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
end
# Produces (name => expr) or (name +> expr)
def dump_AttributeOperation o
[o.attribute_name, o.operator, do_dump(o.value_expr)]
end
def dump_LiteralList o
["[]"] + o.values.collect {|x| do_dump(x)}
end
def dump_LiteralHash o
["{}"] + o.entries.collect {|x| do_dump(x)}
end
def dump_KeyedEntry o
[do_dump(o.key), do_dump(o.value)]
end
def dump_MatchExpression o
[o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
end
def dump_LiteralString o
"'#{o.value}'"
end
def dump_LiteralText o
o.value
end
def dump_LambdaExpression o
result = ["lambda"]
result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
if o.body
result << do_dump(o.body)
else
result << []
end
result
end
def dump_LiteralDefault o
":default"
end
def dump_LiteralUndef o
":undef"
end
def dump_LiteralRegularExpression o
"/#{o.value.source}/"
end
def dump_Nop o
":nop"
end
def dump_NamedAccessExpression o
[".", do_dump(o.left_expr), do_dump(o.right_expr)]
end
def dump_NilClass o
"()"
end
def dump_NotExpression o
['!', dump(o.expr)]
end
def dump_VariableExpression o
"$#{dump(o.expr)}"
end
# Interpolation (to string) shown as (str expr)
def dump_TextExpression o
["str", do_dump(o.expr)]
end
def dump_UnaryMinusExpression o
['-', do_dump(o.expr)]
end
def dump_BlockExpression o
["block"] + o.statements.collect {|x| do_dump(x) }
end
# Interpolated strings are shown as (cat seg0 seg1 ... segN)
def dump_ConcatenatedString o
["cat"] + o.segments.collect {|x| do_dump(x)}
end
def dump_HostClassDefinition o
result = ["class", o.name]
result << ["inherits", o.parent_class] if o.parent_class
result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
if o.body
result << do_dump(o.body)
else
result << []
end
result
end
def dump_NodeDefinition o
result = ["node"]
result << ["matches"] + o.host_matches.collect {|m| do_dump(m) }
result << ["parent", do_dump(o.parent)] if o.parent
if o.body
result << do_dump(o.body)
else
result << []
end
result
end
def dump_ResourceTypeDefinition o
result = ["define", o.name]
result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
if o.body
result << do_dump(o.body)
else
result << []
end
result
end
def dump_ResourceOverrideExpression o
result = ["override", do_dump(o.resources), :indent]
o.operations.each do |p|
result << :break << do_dump(p)
end
result << :dedent
result
end
# Produces parameters as name, or (= name value)
def dump_Parameter o
if o.value
["=", o.name, do_dump(o.value)]
else
o.name
end
end
def dump_ParenthesizedExpression o
do_dump(o.expr)
end
def dump_IfExpression o
result = ["if", do_dump(o.test), :indent, :break,
["then", :indent, do_dump(o.then_expr), :dedent]]
result +=
[:break,
["else", :indent, do_dump(o.else_expr), :dedent],
:dedent] unless is_nop? o.else_expr
result
end
def dump_UnlessExpression o
result = ["unless", do_dump(o.test), :indent, :break,
["then", :indent, do_dump(o.then_expr), :dedent]]
result +=
[:break,
["else", :indent, do_dump(o.else_expr), :dedent],
:dedent] unless is_nop? o.else_expr
result
end
# Produces (invoke name args...) when not required to produce an rvalue, and
# (call name args ... ) otherwise.
#
def dump_CallNamedFunctionExpression o
result = [o.rval_required ? "call" : "invoke", do_dump(o.functor_expr)]
o.arguments.collect {|a| result << do_dump(a) }
result
end
# def dump_CallNamedFunctionExpression o
# result = [o.rval_required ? "call" : "invoke", do_dump(o.functor_expr)]
# o.arguments.collect {|a| result << do_dump(a) }
# result
# end
def dump_CallMethodExpression o
result = [o.rval_required ? "call-method" : "invoke-method", do_dump(o.functor_expr)]
o.arguments.collect {|a| result << do_dump(a) }
result << do_dump(o.lambda) if o.lambda
result
end
def dump_CaseExpression o
result = ["case", do_dump(o.test), :indent]
o.options.each do |s|
result << :break << do_dump(s)
end
result << :dedent
end
def dump_CaseOption o
result = ["when"]
result << o.values.collect {|x| do_dump(x) }
result << ["then", do_dump(o.then_expr) ]
result
end
def dump_RelationshipExpression o
[o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
end
def dump_ResourceBody o
result = [do_dump(o.title), :indent]
o.operations.each do |p|
result << :break << do_dump(p)
end
result << :dedent
result
end
def dump_ResourceDefaultsExpression o
result = ["resource-defaults", do_dump(o.type_ref), :indent]
o.operations.each do |p|
result << :break << do_dump(p)
end
result << :dedent
result
end
def dump_ResourceExpression o
form = o.form == :regular ? '' : o.form.to_s + "-"
result = [form+"resource", do_dump(o.type_name), :indent]
o.bodies.each do |b|
result << :break << do_dump(b)
end
result << :dedent
result
end
def dump_SelectorExpression o
["?", do_dump(o.left_expr)] + o.selectors.collect {|x| do_dump(x) }
end
def dump_SelectorEntry o
[do_dump(o.matching_expr), "=>", do_dump(o.value_expr)]
end
def dump_Object o
[o.class.to_s, o.to_s]
end
def is_nop? o
o.nil? || o.is_a?(Puppet::Pops::Model::Nop)
end
end
puppet-3.4.3/lib/puppet/pops/model/factory.rb 0000644 0052762 0001160 00000056736 12300765631 021112 0 ustar jenkins jenkins # Factory is a helper class that makes construction of a Pops Model
# much more convenient. It can be viewed as a small internal DSL for model
# constructions.
# For usage see tests using the factory.
#
# @todo All those uppercase methods ... they look bad in one way, but stand out nicely in the grammar...
# decide if they should change into lower case names (some of the are lower case)...
#
class Puppet::Pops::Model::Factory
Model = Puppet::Pops::Model
attr_accessor :current
alias_method :model, :current
# Shared build_visitor, since there are many instances of Factory being used
@@build_visitor = Puppet::Pops::Visitor.new(self, "build")
# Initialize a factory with a single object, or a class with arguments applied to build of
# created instance
#
def initialize popsobj, *args
@current = to_ops(popsobj, *args)
end
# Polymorphic build
def build(o, *args)
begin
@@build_visitor.visit_this(self, o, *args)
rescue =>e
# require 'debugger'; debugger # enable this when in trouble...
raise e
end
end
# Building of Model classes
def build_ArithmeticExpression(o, op, a, b)
o.operator = op
build_BinaryExpression(o, a, b)
end
def build_AssignmentExpression(o, op, a, b)
o.operator = op
build_BinaryExpression(o, a, b)
end
def build_AttributeOperation(o, name, op, value)
o.operator = op
o.attribute_name = name.to_s # BOOLEAN is allowed in the grammar
o.value_expr = build(value)
o
end
def build_AccessExpression(o, left, *keys)
o.left_expr = to_ops(left)
keys.each {|expr| o.addKeys(to_ops(expr)) }
o
end
def build_BinaryExpression(o, left, right)
o.left_expr = to_ops(left)
o.right_expr = to_ops(right)
o
end
def build_BlockExpression(o, *args)
args.each {|expr| o.addStatements(to_ops(expr)) }
o
end
def build_CollectExpression(o, type_expr, query_expr, attribute_operations)
o.type_expr = to_ops(type_expr)
o.query = build(query_expr)
attribute_operations.each {|op| o.addOperations(build(op)) }
o
end
def build_ComparisonExpression(o, op, a, b)
o.operator = op
build_BinaryExpression(o, a, b)
end
def build_ConcatenatedString(o, *args)
args.each {|expr| o.addSegments(build(expr)) }
o
end
def build_CreateTypeExpression(o, name, super_name = nil)
o.name = name
o.super_name = super_name
o
end
def build_CreateEnumExpression(o, *args)
o.name = args.slice(0) if args.size == 2
o.values = build(args.last)
o
end
def build_CreateAttributeExpression(o, name, datatype_expr)
o.name = name
o.type = to_ops(datatype_expr)
o
end
# @param name [String] a valid classname
# @param parameters [Array] may be empty
# @param parent_class_name [String, nil] a valid classname referencing a parent class, optional.
# @param body [Array, Expression, nil] expression that constitute the body
# @return [Model::HostClassDefinition] configured from the parameters
#
def build_HostClassDefinition(o, name, parameters, parent_class_name, body)
build_NamedDefinition(o, name, parameters, body)
o.parent_class = parent_class_name if parent_class_name
o
end
# # @param name [String] a valid classname
# # @param parameters [Array] may be empty
# # @param body [Array, Expression, nil] expression that constitute the body
# # @return [Model::HostClassDefinition] configured from the parameters
# #
# def build_ResourceTypeDefinition(o, name, parameters, body)
# build_NamedDefinition(o, name, parameters, body)
# o.name = name
# parameters.each {|p| o.addParameters(build(p)) }
# b = f_build_body(body)
# o.body = b.current if b
# o
# end
def build_ResourceOverrideExpression(o, resources, attribute_operations)
o.resources = build(resources)
attribute_operations.each {|ao| o.addOperations(build(ao)) }
o
end
def build_KeyedEntry(o, k, v)
o.key = build(k)
o.value = build(v)
o
end
def build_LiteralHash(o, *keyed_entries)
keyed_entries.each {|entry| o.addEntries build(entry) }
o
end
def build_LiteralList(o, *values)
values.each {|v| o.addValues build(v) }
o
end
def build_LiteralNumber(o, val, radix)
o.value = val
o.radix = radix
o
end
def build_InstanceReferences(o, type_name, name_expressions)
o.type_name = build(type_name)
name_expressions.each {|n| o.addNames(build(n)) }
o
end
def build_ImportExpression(o, files)
# The argument files has already been built
files.each {|f| o.addFiles(to_ops(f)) }
o
end
def build_IfExpression(o, t, ift, els)
o.test = build(t)
o.then_expr = build(ift)
o.else_expr= build(els)
o
end
def build_MatchExpression(o, op, a, b)
o.operator = op
build_BinaryExpression(o, a, b)
end
# Builds body :) from different kinds of input
# @overload f_build_body(nothing)
# @param nothing [nil] unchanged, produces nil
# @overload f_build_body(array)
# @param array [Array] turns into a BlockExpression
# @overload f_build_body(expr)
# @param expr [Expression] produces the given expression
# @overload f_build_body(obj)
# @param obj [Object] produces the result of calling #build with body as argument
def f_build_body(body)
case body
when NilClass
nil
when Array
Puppet::Pops::Model::Factory.new(Model::BlockExpression, *body)
else
build(body)
end
end
def build_Definition(o, parameters, body)
parameters.each {|p| o.addParameters(build(p)) }
b = f_build_body(body)
o.body = b.current if b
o
end
def build_NamedDefinition(o, name, parameters, body)
build_Definition(o, parameters, body)
o.name = name
o
end
# @param o [Model::NodeDefinition]
# @param hosts [Array] host matches
# @param parent [Expression] parent node matcher
# @param body [Object] see {#f_build_body}
def build_NodeDefinition(o, hosts, parent, body)
hosts.each {|h| o.addHost_matches(build(h)) }
o.parent = build(parent) if parent # no nop here
b = f_build_body(body)
o.body = b.current if b
o
end
def build_Parameter(o, name, expr)
o.name = name
o.value = build(expr) if expr # don't build a nil/nop
o
end
def build_QualifiedReference(o, name)
o.value = name.to_s.downcase
o
end
def build_RelationshipExpression(o, op, a, b)
o.operator = op
build_BinaryExpression(o, a, b)
end
def build_ResourceExpression(o, type_name, bodies)
o.type_name = build(type_name)
bodies.each {|b| o.addBodies(build(b)) }
o
end
def build_ResourceBody(o, title_expression, attribute_operations)
o.title = build(title_expression)
attribute_operations.each {|ao| o.addOperations(build(ao)) }
o
end
def build_ResourceDefaultsExpression(o, type_ref, attribute_operations)
o.type_ref = build(type_ref)
attribute_operations.each {|ao| o.addOperations(build(ao)) }
o
end
def build_SelectorExpression(o, left, *selectors)
o.left_expr = to_ops(left)
selectors.each {|s| o.addSelectors(build(s)) }
o
end
def build_SelectorEntry(o, matching, value)
o.matching_expr = build(matching)
o.value_expr = build(value)
o
end
def build_QueryExpression(o, expr)
ops = to_ops(expr)
o.expr = ops unless Puppet::Pops::Model::Factory.nop? ops
o
end
def build_UnaryExpression(o, expr)
ops = to_ops(expr)
o.expr = ops unless Puppet::Pops::Model::Factory.nop? ops
o
end
def build_QualifiedName(o, name)
o.value = name.to_s
o
end
# Puppet::Pops::Model::Factory helpers
def f_build_unary(klazz, expr)
Puppet::Pops::Model::Factory.new(build(klazz.new, expr))
end
def f_build_binary_op(klazz, op, left, right)
Puppet::Pops::Model::Factory.new(build(klazz.new, op, left, right))
end
def f_build_binary(klazz, left, right)
Puppet::Pops::Model::Factory.new(build(klazz.new, left, right))
end
def f_build_vararg(klazz, left, *arg)
Puppet::Pops::Model::Factory.new(build(klazz.new, left, *arg))
end
def f_arithmetic(op, r)
f_build_binary_op(Model::ArithmeticExpression, op, current, r)
end
def f_comparison(op, r)
f_build_binary_op(Model::ComparisonExpression, op, current, r)
end
def f_match(op, r)
f_build_binary_op(Model::MatchExpression, op, current, r)
end
# Operator helpers
def in(r) f_build_binary(Model::InExpression, current, r); end
def or(r) f_build_binary(Model::OrExpression, current, r); end
def and(r) f_build_binary(Model::AndExpression, current, r); end
def not(); f_build_unary(Model::NotExpression, self); end
def minus(); f_build_unary(Model::UnaryMinusExpression, self); end
def text(); f_build_unary(Model::TextExpression, self); end
def var(); f_build_unary(Model::VariableExpression, self); end
def [](*r); f_build_vararg(Model::AccessExpression, current, *r); end
def dot r; f_build_binary(Model::NamedAccessExpression, current, r); end
def + r; f_arithmetic(:+, r); end
def - r; f_arithmetic(:-, r); end
def / r; f_arithmetic(:/, r); end
def * r; f_arithmetic(:*, r); end
def % r; f_arithmetic(:%, r); end
def << r; f_arithmetic(:<<, r); end
def >> r; f_arithmetic(:>>, r); end
def < r; f_comparison(:<, r); end
def <= r; f_comparison(:<=, r); end
def > r; f_comparison(:>, r); end
def >= r; f_comparison(:>=, r); end
def == r; f_comparison(:==, r); end
def ne r; f_comparison(:'!=', r); end
def =~ r; f_match(:'=~', r); end
def mne r; f_match(:'!~', r); end
def paren(); f_build_unary(Model::ParenthesizedExpression, current); end
def relop op, r
f_build_binary_op(Model::RelationshipExpression, op.to_sym, current, r)
end
def select *args
Puppet::Pops::Model::Factory.new(build(Model::SelectorExpression, current, *args))
end
# For CaseExpression, setting the default for an already build CaseExpression
def default r
current.addOptions(Puppet::Pops::Model::Factory.WHEN(:default, r).current)
self
end
def lambda=(lambda)
current.lambda = lambda.current
self
end
# Assignment =
def set(r)
f_build_binary_op(Model::AssignmentExpression, :'=', current, r)
end
# Assignment +=
def plus_set(r)
f_build_binary_op(Model::AssignmentExpression, :'+=', current, r)
end
def attributes(*args)
args.each {|a| current.addAttributes(build(a)) }
self
end
# Catch all delegation to current
def method_missing(meth, *args, &block)
if current.respond_to?(meth)
current.send(meth, *args, &block)
else
super
end
end
def respond_to?(meth)
current.respond_to?(meth) || super
end
# Records the position (start -> end) and computes the resulting length.
#
def record_position(start_pos, end_pos)
Puppet::Pops::Adapters::SourcePosAdapter.adapt(current) do |a|
a.line = start_pos.line
a.offset = start_pos.offset
a.pos = start_pos.pos
a.length = start_pos.length
if(end_pos.offset && end_pos.length)
a.length = end_pos.offset + end_pos.length - start_pos.offset
end
end
self
end
# Records the origin file of an element
# Does nothing if file is nil.
#
# @param file [String,nil] the file/path to the origin, may contain URI scheme of file: or some other URI scheme
# @return [Factory] returns self
#
def record_origin(file)
return self unless file
Puppet::Pops::Adapters::OriginAdapter.adapt(current) do |a|
a.origin = file
end
self
end
# @return [Puppet::Pops::Adapters::SourcePosAdapter] with location information
def loc()
Puppet::Pops::Adapters::SourcePosAdapter.adapt(current)
end
# Returns documentation string, or nil if not available
# @return [String, nil] associated documentation if available
def doc()
a = Puppet::Pops::Adapters::SourcePosAdapter.adapt(current)
return a.documentation if a
nil
end
def doc=(doc_string)
a = Puppet::Pops::Adapters::SourcePosAdapter.adapt(current)
a.documentation = doc_string
end
# Returns symbolic information about an expected share of a resource expression given the LHS of a resource expr.
#
# * `name { }` => `:resource`, create a resource of the given type
# * `Name { }` => ':defaults`, set defaults for the referenced type
# * `Name[] { }` => `:override`, overrides instances referenced by LHS
# * _any other_ => ':error', all other are considered illegal
#
def self.resource_shape(expr)
expr = expr.current if expr.is_a?(Puppet::Pops::Model::Factory)
case expr
when Model::QualifiedName
:resource
when Model::QualifiedReference
:defaults
when Model::AccessExpression
:override
when 'class'
:class
else
:error
end
end
# Factory starting points
def self.literal(o); new(o); end
def self.minus(o); new(o).minus; end
def self.var(o); new(o).var; end
def self.block(*args); new(Model::BlockExpression, *args); end
def self.string(*args); new(Model::ConcatenatedString, *args); end
def self.text(o); new(o).text; end
def self.IF(test_e,then_e,else_e); new(Model::IfExpression, test_e, then_e, else_e); end
def self.UNLESS(test_e,then_e,else_e); new(Model::UnlessExpression, test_e, then_e, else_e); end
def self.CASE(test_e,*options); new(Model::CaseExpression, test_e, *options); end
def self.WHEN(values_list, block); new(Model::CaseOption, values_list, block); end
def self.MAP(match, value); new(Model::SelectorEntry, match, value); end
def self.TYPE(name, super_name=nil); new(Model::CreateTypeExpression, name, super_name); end
def self.ATTR(name, type_expr=nil); new(Model::CreateAttributeExpression, name, type_expr); end
def self.ENUM(*args); new(Model::CreateEnumExpression, *args); end
def self.KEY_ENTRY(key, val); new(Model::KeyedEntry, key, val); end
def self.HASH(entries); new(Model::LiteralHash, *entries); end
def self.LIST(entries); new(Model::LiteralList, *entries); end
def self.PARAM(name, expr=nil); new(Model::Parameter, name, expr); end
def self.NODE(hosts, parent, body); new(Model::NodeDefinition, hosts, parent, body); end
# Creates a QualifiedName representation of o, unless o already represents a QualifiedName in which
# case it is returned.
#
def self.fqn(o)
o = o.current if o.is_a?(Puppet::Pops::Model::Factory)
o = new(Model::QualifiedName, o) unless o.is_a? Model::QualifiedName
o
end
# Creates a QualifiedName representation of o, unless o already represents a QualifiedName in which
# case it is returned.
#
def self.fqr(o)
o = o.current if o.is_a?(Puppet::Pops::Model::Factory)
o = new(Model::QualifiedReference, o) unless o.is_a? Model::QualifiedReference
o
end
def self.TEXT(expr)
new(Model::TextExpression, expr)
end
# TODO: This is the same a fqn factory method, don't know if callers to fqn and QNAME can live with the
# same result or not yet - refactor into one method when decided.
#
def self.QNAME(name)
new(Model::QualifiedName, name)
end
# Convert input string to either a qualified name, or a LiteralNumber with radix
#
def self.QNAME_OR_NUMBER(name)
if n_radix = Puppet::Pops::Utils.to_n_with_radix(name)
new(Model::LiteralNumber, *n_radix)
else
new(Model::QualifiedName, name)
end
end
def self.QREF(name)
new(Model::QualifiedReference, name)
end
def self.VIRTUAL_QUERY(query_expr)
new(Model::VirtualQuery, query_expr)
end
def self.EXPORTED_QUERY(query_expr)
new(Model::ExportedQuery, query_expr)
end
# Used by regular grammar, egrammar creates an AccessExpression instead, and evaluation determines
# if access is to instances or something else.
#
def self.INSTANCE(type_name, name_expressions)
new(Model::InstanceReferences, type_name, name_expressions)
end
def self.ATTRIBUTE_OP(name, op, expr)
new(Model::AttributeOperation, name, op, expr)
end
def self.CALL_NAMED(name, rval_required, argument_list)
unless name.kind_of?(Model::PopsObject)
name = Puppet::Pops::Model::Factory.fqn(name) unless name.is_a?(Puppet::Pops::Model::Factory)
end
new(Model::CallNamedFunctionExpression, name, rval_required, *argument_list)
end
def self.CALL_METHOD(functor, argument_list)
new(Model::CallMethodExpression, functor, true, nil, *argument_list)
end
def self.COLLECT(type_expr, query_expr, attribute_operations)
new(Model::CollectExpression, Puppet::Pops::Model::Factory.fqr(type_expr), query_expr, attribute_operations)
end
def self.IMPORT(files)
new(Model::ImportExpression, files)
end
def self.NAMED_ACCESS(type_name, bodies)
new(Model::NamedAccessExpression, type_name, bodies)
end
def self.RESOURCE(type_name, bodies)
new(Model::ResourceExpression, type_name, bodies)
end
def self.RESOURCE_DEFAULTS(type_name, attribute_operations)
new(Model::ResourceDefaultsExpression, type_name, attribute_operations)
end
def self.RESOURCE_OVERRIDE(resource_ref, attribute_operations)
new(Model::ResourceOverrideExpression, resource_ref, attribute_operations)
end
def self.RESOURCE_BODY(resource_title, attribute_operations)
new(Model::ResourceBody, resource_title, attribute_operations)
end
# Builds a BlockExpression if args size > 1, else the single expression/value in args
def self.block_or_expression(*args)
if args.size > 1
new(Model::BlockExpression, *args)
else
new(args[0])
end
end
def self.HOSTCLASS(name, parameters, parent, body)
new(Model::HostClassDefinition, name, parameters, parent, body)
end
def self.DEFINITION(name, parameters, body)
new(Model::ResourceTypeDefinition, name, parameters, body)
end
def self.LAMBDA(parameters, body)
new(Model::LambdaExpression, parameters, body)
end
def self.nop? o
o.nil? || o.is_a?(Puppet::Pops::Model::Nop)
end
# Transforms an array of expressions containing literal name expressions to calls if followed by an
# expression, or expression list. Also transforms a "call" to `import` into an ImportExpression.
#
def self.transform_calls(expressions)
expressions.reduce([]) do |memo, expr|
expr = expr.current if expr.is_a?(Puppet::Pops::Model::Factory)
name = memo[-1]
if name.is_a? Model::QualifiedName
if name.value() == 'import'
memo[-1] = Puppet::Pops::Model::Factory.IMPORT(expr.is_a?(Array) ? expr : [expr])
else
memo[-1] = Puppet::Pops::Model::Factory.CALL_NAMED(name, false, expr.is_a?(Array) ? expr : [expr])
if expr.is_a?(Model::CallNamedFunctionExpression)
# Patch statement function call to expression style
# This is needed because it is first parsed as a "statement" and the requirement changes as it becomes
# an argument to the name to call transform above.
expr.rval_required = true
end
end
else
memo << expr
if expr.is_a?(Model::CallNamedFunctionExpression)
# Patch rvalue expression function call to statement style.
# This is not really required but done to be AST model compliant
expr.rval_required = false
end
end
memo
end
end
# Building model equivalences of Ruby objects
# Allows passing regular ruby objects to the factory to produce instructions
# that when evaluated produce the same thing.
def build_String(o)
x = Model::LiteralString.new
x.value = o;
x
end
def build_NilClass(o)
x = Model::Nop.new
x
end
def build_TrueClass(o)
x = Model::LiteralBoolean.new
x.value = o
x
end
def build_FalseClass(o)
x = Model::LiteralBoolean.new
x.value = o
x
end
def build_Fixnum(o)
x = Model::LiteralNumber.new
x.value = o;
x
end
def build_Float(o)
x = Model::LiteralNumber.new
x.value = o;
x
end
def build_Regexp(o)
x = Model::LiteralRegularExpression.new
x.value = o;
x
end
# If building a factory, simply unwrap the model oject contained in the factory.
def build_Factory(o)
o.current
end
# Creates a String literal, unless the symbol is one of the special :undef, or :default
# which instead creates a LiterlUndef, or a LiteralDefault.
def build_Symbol(o)
case o
when :undef
Model::LiteralUndef.new
when :default
Model::LiteralDefault.new
else
build_String(o.to_s)
end
end
# Creates a LiteralList instruction from an Array, where the entries are built.
def build_Array(o)
x = Model::LiteralList.new
o.each { |v| x.addValues(build(v)) }
x
end
# Create a LiteralHash instruction from a hash, where keys and values are built
# The hash entries are added in sorted order based on key.to_s
#
def build_Hash(o)
x = Model::LiteralHash.new
(o.sort_by {|k,v| k.to_s}).each {|k,v| x.addEntries(build(Model::KeyedEntry.new, k, v)) }
x
end
# @param rval_required [Boolean] if the call must produce a value
def build_CallExpression(o, functor, rval_required, *args)
o.functor_expr = to_ops(functor)
o.rval_required = rval_required
args.each {|x| o.addArguments(to_ops(x)) }
o
end
# # @param rval_required [Boolean] if the call must produce a value
# def build_CallNamedFunctionExpression(o, name, rval_required, *args)
# build_CallExpression(o, name, rval_required, *args)
## o.functor_expr = build(name)
## o.rval_required = rval_required
## args.each {|x| o.addArguments(build(x)) }
# o
# end
def build_CallMethodExpression(o, functor, rval_required, lambda, *args)
build_CallExpression(o, functor, rval_required, *args)
o.lambda = lambda
o
end
def build_CaseExpression(o, test, *args)
o.test = build(test)
args.each {|opt| o.addOptions(build(opt)) }
o
end
def build_CaseOption(o, value_list, then_expr)
value_list = [value_list] unless value_list.is_a? Array
value_list.each { |v| o.addValues(build(v)) }
b = f_build_body(then_expr)
o.then_expr = to_ops(b) if b
o
end
# Build a Class by creating an instance of it, and then calling build on the created instance
# with the given arguments
def build_Class(o, *args)
build(o.new(), *args)
end
# Checks if the object is already a model object, or build it
def to_ops(o, *args)
if o.kind_of?(Model::PopsObject)
o
else
build(o, *args)
end
end
end
puppet-3.4.3/lib/puppet/pops/model/model.rb 0000644 0052762 0001160 00000046275 12300765631 020540 0 ustar jenkins jenkins #
# The Puppet Pops Metamodel
#
# This module contains a formal description of the Puppet Pops (*P*uppet *OP*eration instruction*S*).
# It describes a Metamodel containing DSL instructions, a description of PuppetType and related
# classes needed to evaluate puppet logic.
# The metamodel resembles the existing AST model, but it is a semantic model of instructions and
# the types that they operate on rather than an Abstract Syntax Tree, although closely related.
#
# The metamodel is anemic (has no behavior) except basic datatype and type
# assertions and reference/containment assertions.
# The metamodel is also a generalized description of the Puppet DSL to enable the
# same metamodel to be used to express Puppet DSL models (instances) with different semantics as
# the language evolves.
#
# The metamodel is concretized by a validator for a particular version of
# the Puppet DSL language.
#
# This metamodel is expressed using RGen.
#
# TODO: Anonymous Enums - probably ok, but they can be named (don't know if that is meaningsful)
require 'rgen/metamodel_builder'
module Puppet::Pops::Model
# A base class for modeled objects that makes them Visitable, and Adaptable.
# @todo currently includes Containment which will not be needed when the corresponding methods
# are added to RGen (in some version after 0.6.2).
#
class PopsObject < RGen::MetamodelBuilder::MMBase
include Puppet::Pops::Visitable
include Puppet::Pops::Adaptable
include Puppet::Pops::Containment
abstract
end
# @abstract base class for expressions
class Expression < PopsObject
abstract
end
# A Nop - the "no op" expression.
# @note not really needed since the evaluator can evaluate nil with the meaning of NoOp
# @todo deprecate? May be useful if there is the need to differentiate between nil and Nop when transforming model.
#
class Nop < Expression
end
# A binary expression is abstract and has a left and a right expression. The order of evaluation
# and semantics are determined by the concrete subclass.
#
class BinaryExpression < Expression
abstract
#
# @!attribute [rw] left_expr
# @return [Expression]
contains_one_uni 'left_expr', Expression, :lowerBound => 1
contains_one_uni 'right_expr', Expression, :lowerBound => 1
end
# An unary expression is abstract and contains one expression. The semantics are determined by
# a concrete subclass.
#
class UnaryExpression < Expression
abstract
contains_one_uni 'expr', Expression, :lowerBound => 1
end
# A class that simply evaluates to the contained expression.
# It is of value in order to preserve user entered parentheses in transformations, and
# transformations from model to source.
#
class ParenthesizedExpression < UnaryExpression; end
# An import of one or several files.
#
class ImportExpression < Expression
contains_many_uni 'files', Expression, :lowerBound => 1
end
# A boolean not expression, reversing the truth of the unary expr.
#
class NotExpression < UnaryExpression; end
# An arithmetic expression reversing the polarity of the numeric unary expr.
#
class UnaryMinusExpression < UnaryExpression; end
# An assignment expression assigns a value to the lval() of the left_expr.
#
class AssignmentExpression < BinaryExpression
has_attr 'operator', RGen::MetamodelBuilder::DataTypes::Enum.new([:'=', :'+=']), :lowerBound => 1
end
# An arithmetic expression applies an arithmetic operator on left and right expressions.
#
class ArithmeticExpression < BinaryExpression
has_attr 'operator', RGen::MetamodelBuilder::DataTypes::Enum.new([:'+', :'-', :'*', :'%', :'/', :'<<', :'>>' ]), :lowerBound => 1
end
# A relationship expression associates the left and right expressions
#
class RelationshipExpression < BinaryExpression
has_attr 'operator', RGen::MetamodelBuilder::DataTypes::Enum.new([:'->', :'<-', :'~>', :'<~']), :lowerBound => 1
end
# A binary expression, that accesses the value denoted by right in left. i.e. typically
# expressed concretely in a language as left[right].
#
class AccessExpression < Expression
contains_one_uni 'left_expr', Expression, :lowerBound => 1
contains_many_uni 'keys', Expression, :lowerBound => 1
end
# A comparison expression compares left and right using a comparison operator.
#
class ComparisonExpression < BinaryExpression
has_attr 'operator', RGen::MetamodelBuilder::DataTypes::Enum.new([:'==', :'!=', :'<', :'>', :'<=', :'>=' ]), :lowerBound => 1
end
# A match expression matches left and right using a matching operator.
#
class MatchExpression < BinaryExpression
has_attr 'operator', RGen::MetamodelBuilder::DataTypes::Enum.new([:'!~', :'=~']), :lowerBound => 1
end
# An 'in' expression checks if left is 'in' right
#
class InExpression < BinaryExpression; end
# A boolean expression applies a logical connective operator (and, or) to left and right expressions.
#
class BooleanExpression < BinaryExpression
abstract
end
# An and expression applies the logical connective operator and to left and right expression
# and does not evaluate the right expression if the left expression is false.
#
class AndExpression < BooleanExpression; end
# An or expression applies the logical connective operator or to the left and right expression
# and does not evaluate the right expression if the left expression is true
#
class OrExpression < BooleanExpression; end
# A literal list / array containing 0:M expressions.
#
class LiteralList < Expression
contains_many_uni 'values', Expression
end
# A Keyed entry has a key and a value expression. It it typically used as an entry in a Hash.
#
class KeyedEntry < PopsObject
contains_one_uni 'key', Expression, :lowerBound => 1
contains_one_uni 'value', Expression, :lowerBound => 1
end
# A literal hash is a collection of KeyedEntry objects
#
class LiteralHash < Expression
contains_many_uni 'entries', KeyedEntry
end
# A block contains a list of expressions
#
class BlockExpression < Expression
contains_many_uni 'statements', Expression
end
# A case option entry in a CaseStatement
#
class CaseOption < Expression
contains_many_uni 'values', Expression, :lowerBound => 1
contains_one_uni 'then_expr', Expression, :lowerBound => 1
end
# A case expression has a test, a list of options (multi values => block map).
# One CaseOption may contain a LiteralDefault as value. This option will be picked if nothing
# else matched.
#
class CaseExpression < Expression
contains_one_uni 'test', Expression, :lowerBound => 1
contains_many_uni 'options', CaseOption
end
# A query expression is an expression that is applied to some collection.
# The contained optional expression may contain different types of relational expressions depending
# on what the query is applied to.
#
class QueryExpression < Expression
abstract
contains_one_uni 'expr', Expression, :lowerBound => 0
end
# An exported query is a special form of query that searches for exported objects.
#
class ExportedQuery < QueryExpression
end
# A virtual query is a special form of query that searches for virtual objects.
#
class VirtualQuery < QueryExpression
end
# An attribute operation sets or appends a value to a named attribute.
#
class AttributeOperation < PopsObject
has_attr 'attribute_name', String, :lowerBound => 1
has_attr 'operator', RGen::MetamodelBuilder::DataTypes::Enum.new([:'=>', :'+>', ]), :lowerBound => 1
contains_one_uni 'value_expr', Expression, :lowerBound => 1
end
# An optional attribute operation sets or appends a value to a named attribute unless
# the value is undef/nil in which case the opereration is a Nop.
#
# This is a new feature proposed to solve the undef as antimatter problem
# @note Currently Unused
#
class OptionalAttributeOperation < AttributeOperation
end
# An object that collects stored objects from the central cache and returns
# them to the current host. Operations may optionally be applied.
#
class CollectExpression < Expression
contains_one_uni 'type_expr', Expression, :lowerBound => 1
contains_one_uni 'query', QueryExpression, :lowerBound => 1
contains_many_uni 'operations', AttributeOperation
end
class Parameter < PopsObject
has_attr 'name', String, :lowerBound => 1
contains_one_uni 'value', Expression
end
# Abstract base class for definitions.
#
class Definition < Expression
abstract
contains_many_uni 'parameters', Parameter
contains_one_uni 'body', Expression
end
# Abstract base class for named definitions.
class NamedDefinition < Definition
abstract
has_attr 'name', String, :lowerBound => 1
end
# A resource type definition (a 'define' in the DSL).
#
class ResourceTypeDefinition < NamedDefinition
# FUTURE
# contains_one_uni 'producer', Producer
end
# A node definition matches hosts using Strings, or Regular expressions. It may inherit from
# a parent node (also using a String or Regular expression).
#
class NodeDefinition < Expression
contains_one_uni 'parent', Expression
contains_many_uni 'host_matches', Expression, :lowerBound => 1
contains_one_uni 'body', Expression
end
# A class definition
#
class HostClassDefinition < NamedDefinition
has_attr 'parent_class', String
end
# i.e {|parameters| body }
class LambdaExpression < Definition; end
# If expression. If test is true, the then_expr part should be evaluated, else the (optional)
# else_expr. An 'elsif' is simply an else_expr = IfExpression, and 'else' is simply else == Block.
# a 'then' is typically a Block.
#
class IfExpression < Expression
contains_one_uni 'test', Expression, :lowerBound => 1
contains_one_uni 'then_expr', Expression, :lowerBound => 1
contains_one_uni 'else_expr', Expression
end
# An if expression with boolean reversed test.
#
class UnlessExpression < IfExpression
end
# An abstract call.
#
class CallExpression < Expression
abstract
# A bit of a crutch; functions are either procedures (void return) or has an rvalue
# this flag tells the evaluator that it is a failure to call a function that is void/procedure
# where a value is expected.
#
has_attr 'rval_required', Boolean, :defaultValueLiteral => "false"
contains_one_uni 'functor_expr', Expression, :lowerBound => 1
contains_many_uni 'arguments', Expression
contains_one_uni 'lambda', Expression
end
# A function call where the functor_expr should evaluate to something callable.
#
class CallFunctionExpression < CallExpression; end
# A function call where the given functor_expr should evaluate to the name
# of a function.
#
class CallNamedFunctionExpression < CallExpression; end
# A method/function call where the function expr is a NamedAccess and with support for
# an optional lambda block
#
class CallMethodExpression < CallExpression
end
# Abstract base class for literals.
#
class Literal < Expression
abstract
end
# A literal value is an abstract value holder. The type of the contained value is
# determined by the concrete subclass.
#
class LiteralValue < Literal
abstract
has_attr 'value', Object, :lowerBound => 1
end
# A Regular Expression Literal.
#
class LiteralRegularExpression < LiteralValue; end
# A Literal String
#
class LiteralString < LiteralValue; end
# A literal text is like a literal string, but has other rules for escaped characters. It
# is used as part of a ConcatenatedString
#
class LiteralText < LiteralValue; end
# A literal number has a radix of decimal (10), octal (8), or hex (16) to enable string conversion with the input radix.
# By default, a radix of 10 is used.
#
class LiteralNumber < LiteralValue
has_attr 'radix', Integer, :lowerBound => 1, :defaultValueLiteral => "10"
end
# The DSL `undef`.
#
class LiteralUndef < Literal; end
# The DSL `default`
class LiteralDefault < Literal; end
# DSL `true` or `false`
class LiteralBoolean < LiteralValue; end
# A text expression is an interpolation of an expression. If the embedded expression is
# a QualifiedName, it it taken as a variable name and resolved. All other expressions are evaluated.
# The result is transformed to a string.
#
class TextExpression < UnaryExpression; end
# An interpolated/concatenated string. The contained segments are expressions. Verbatim sections
# should be LiteralString instances, and interpolated expressions should either be
# TextExpression instances (if QualifiedNames should be turned into variables), or any other expression
# if such treatment is not needed.
#
class ConcatenatedString < Expression
contains_many_uni 'segments', Expression
end
# A DSL NAME (one or multiple parts separated by '::').
#
class QualifiedName < LiteralValue; end
# A DSL CLASSREF (one or multiple parts separated by '::' where (at least) the first part starts with an upper case letter).
#
class QualifiedReference < LiteralValue; end
# A Variable expression looks up value of expr (some kind of name) in scope.
# The expression is typically a QualifiedName, or QualifiedReference.
#
class VariableExpression < UnaryExpression; end
# A type reference is a reference to a type.
#
class TypeReference < Expression
contains_one_uni 'type_name', QualifiedReference, :lowerBound => 1
end
# An instance reference is a reference to one or many named instances of a particular type
#
class InstanceReferences < TypeReference
contains_many_uni 'names', Expression, :lowerBound => 1
end
# A resource body describes one resource instance
#
class ResourceBody < PopsObject
contains_one_uni 'title', Expression
contains_many_uni 'operations', AttributeOperation
end
# An abstract resource describes the form of the resource (regular, virtual or exported)
# and adds convenience methods to ask if it is virtual or exported.
# All derived classes may not support all forms, and these needs to be validated
#
class AbstractResource < Expression
has_attr 'form', RGen::MetamodelBuilder::DataTypes::Enum.new([:regular, :virtual, :exported ]), :lowerBound => 1, :defaultValueLiteral => "regular"
has_attr 'virtual', Boolean, :derived => true
has_attr 'exported', Boolean, :derived => true
module ClassModule
def virtual_derived
form == :virtual || form == :exported
end
def exported_derived
form == :exported
end
end
end
# A resource expression is used to instantiate one or many resource. Resources may optionally
# be virtual or exported, an exported resource is always virtual.
#
class ResourceExpression < AbstractResource
contains_one_uni 'type_name', Expression, :lowerBound => 1
contains_many_uni 'bodies', ResourceBody
end
# A resource defaults sets defaults for a resource type. This class inherits from AbstractResource
# but does only support the :regular form (this is intentional to be able to produce better error messages
# when illegal forms are applied to a model.
#
class ResourceDefaultsExpression < AbstractResource
contains_one_uni 'type_ref', QualifiedReference
contains_many_uni 'operations', AttributeOperation
end
# A resource override overrides already set values.
#
class ResourceOverrideExpression < Expression
contains_one_uni 'resources', Expression, :lowerBound => 1
contains_many_uni 'operations', AttributeOperation
end
# A selector entry describes a map from matching_expr to value_expr.
#
class SelectorEntry < PopsObject
contains_one_uni 'matching_expr', Expression, :lowerBound => 1
contains_one_uni 'value_expr', Expression, :lowerBound => 1
end
# A selector expression represents a mapping from a left_expr to a matching SelectorEntry.
#
class SelectorExpression < Expression
contains_one_uni 'left_expr', Expression, :lowerBound => 1
contains_many_uni 'selectors', SelectorEntry
end
# Create Invariant. Future suggested enhancement Puppet Types.
#
class CreateInvariantExpression < Expression
has_attr 'name', String
contains_one_uni 'message_expr', Expression, :lowerBound => 1
contains_one_uni 'constraint_expr', Expression, :lowerBound => 1
end
# Create Attribute. Future suggested enhancement Puppet Types.
#
class CreateAttributeExpression < Expression
has_attr 'name', String, :lowerBound => 1
# Should evaluate to name of datatype (String, Integer, Float, Boolean) or an EEnum metadata
# (created by CreateEnumExpression). If omitted, the type is a String.
#
contains_one_uni 'type', Expression
contains_one_uni 'min_expr', Expression
contains_one_uni 'max_expr', Expression
contains_one_uni 'default_value', Expression
contains_one_uni 'input_transformer', Expression
contains_one_uni 'derived_expr', Expression
end
# Create Attribute. Future suggested enhancement Puppet Types.
#
class CreateEnumExpression < Expression
has_attr 'name', String
contains_one_uni 'values', Expression
end
# Create Type. Future suggested enhancement Puppet Types.
#
class CreateTypeExpression < Expression
has_attr 'name', String, :lowerBound => 1
has_attr 'super_name', String
contains_many_uni 'attributes', CreateAttributeExpression
contains_many_uni 'invariants', CreateInvariantExpression
end
# Create ResourceType. Future suggested enhancement Puppet Types.
# @todo UNFINISHED
#
class CreateResourceType < CreateTypeExpression
# TODO CreateResourceType
# - has features required by the provider - provider invariant?
# - super type must be a ResourceType
end
# A named access expression looks up a named part. (e.g. $a.b)
#
class NamedAccessExpression < BinaryExpression; end
# A named function definition declares and defines a new function
# Future enhancement.
#
class NamedFunctionDefinition < NamedDefinition; end
# Future enhancements - Injection - Unfinished
#
module Injection
# A producer expression produces an instance of a type. The instance is initialized
# from an expression (or from the current scope if this expression is missing).
#--
# new. to handle production of injections
#
class Producer < Expression
contains_one_uni 'type_name', TypeReference, :lowerBound => 1
contains_one_uni 'instantiation_expr', Expression
end
# A binding entry binds one capability generically or named, specifies default bindings or
# composition of other bindings.
#
class BindingEntry < PopsObject
contains_one_uni 'key', Expression
contains_one_uni 'value', Expression
end
# Defines an optionally named binding.
#
class Binding < Expression
contains_one_uni 'title_expr', Expression
contains_many_uni 'bindings', BindingEntry
end
# An injection provides a value bound in the effective binding scope. The injection
# is based on a type (a capability) and an optional list of instance names (i.e. an InstanceReference).
# Invariants: optional and instantiation are mutually exclusive
#
class InjectExpression < Expression
has_attr 'optional', Boolean
contains_one_uni 'binding', Expression, :lowerBound => 1
contains_one_uni 'instantiation', Expression
end
end
end
puppet-3.4.3/lib/puppet/pops/model/ast_tree_dumper.rb 0000644 0052762 0001160 00000022061 12300765631 022605 0 ustar jenkins jenkins require 'puppet/parser/ast'
# Dumps a Pops::Model in reverse polish notation; i.e. LISP style
# The intention is to use this for debugging output
# TODO: BAD NAME - A DUMP is a Ruby Serialization
#
class Puppet::Pops::Model::AstTreeDumper < Puppet::Pops::Model::TreeDumper
AST = Puppet::Parser::AST
Model = Puppet::Pops::Model
def dump_LiteralNumber o
case o.radix
when 10
o.value.to_s
when 8
"0%o" % o.value
when 16
"0x%X" % o.value
else
"bad radix:" + o.value.to_s
end
end
def dump_Factory o
do_dump(o.current)
end
def dump_ArithmeticOperator o
[o.operator.to_s, do_dump(o.lval), do_dump(o.rval)]
end
def dump_Relationship o
[o.arrow.to_s, do_dump(o.left), do_dump(o.right)]
end
# Hostname is tricky, it is either a bare word, a string, or default, or regular expression
# Least evil, all strings except default are quoted
def dump_HostName o
result = do_dump o.value
unless o.value.is_a? AST::Regex
result = result == "default" ? ":default" : "'#{result}'"
end
result
end
# x[y] prints as (slice x y)
def dump_HashOrArrayAccess o
var = o.variable.is_a?(String) ? "$#{o.variable}" : do_dump(o.variable)
["slice", var, do_dump(o.key)]
end
# The AST Collection knows about exported or virtual query, not the query.
def dump_Collection o
result = ["collect", do_dump(o.type), :indent, :break]
if o.form == :virtual
q = ["<| |>"]
else
q = ["<<| |>>"]
end
q << do_dump(o.query) unless is_nop?(o.query)
q << :indent
result << q
o.override do |ao|
result << :break << do_dump(ao)
end
result += [:dedent, :dedent ]
result
end
def dump_CollExpr o
operator = case o.oper
when 'and'
'&&'
when 'or'
'||'
else
o.oper
end
[operator, do_dump(o.test1), do_dump(o.test2)]
end
def dump_ComparisonOperator o
[o.operator.to_s, do_dump(o.lval), do_dump(o.rval)]
end
def dump_Boolean o
o.to_s
end
def dump_BooleanOperator o
operator = o.operator == 'and' ? '&&' : '||'
[operator, do_dump(o.lval), do_dump(o.rval)]
end
def dump_InOperator o
["in", do_dump(o.lval), do_dump(o.rval)]
end
# $x = ...
# $x += ...
#
def dump_VarDef o
operator = o.append ? "+=" : "="
[operator, '$' + do_dump(o.name), do_dump(o.value)]
end
# Produces (name => expr) or (name +> expr)
def dump_ResourceParam o
operator = o.add ? "+>" : "=>"
[do_dump(o.param), operator, do_dump(o.value)]
end
def dump_Array o
o.collect {|e| do_dump(e) }
end
def dump_ASTArray o
["[]"] + o.children.collect {|x| do_dump(x)}
end
def dump_ASTHash o
["{}"] + o.value.sort_by{|k,v| k.to_s}.collect {|x| [do_dump(x[0]), do_dump(x[1])]}
# ["{}"] + o.value.collect {|x| [do_dump(x[0]), do_dump(x[1])]}
end
def dump_MatchOperator o
[o.operator.to_s, do_dump(o.lval), do_dump(o.rval)]
end
# Dump a Ruby String in single quotes unless it is a number.
def dump_String o
if o.is_a? String
o # A Ruby String, not quoted
elsif Puppet::Pops::Utils.to_n(o.value)
o.value # AST::String that is a number without quotes
else
"'#{o.value}'" # AST::String that is not a number
end
end
def dump_Lambda o
result = ["lambda"]
result << ["parameters"] + o.parameters.collect {|p| _dump_ParameterArray(p) } if o.parameters.size() > 0
if o.children == []
result << [] # does not have a lambda body
else
result << do_dump(o.children)
end
result
end
def dump_Default o
":default"
end
def dump_Undef o
":undef"
end
# Note this is Regex (the AST kind), not Ruby Regexp
def dump_Regex o
"/#{o.value.source}/"
end
def dump_Nop o
":nop"
end
def dump_NilClass o
"()"
end
def dump_Not o
['!', dump(o.value)]
end
def dump_Variable o
"$#{dump(o.value)}"
end
def dump_Minus o
['-', do_dump(o.value)]
end
def dump_BlockExpression o
["block"] + o.children.collect {|x| do_dump(x) }
end
# Interpolated strings are shown as (cat seg0 seg1 ... segN)
def dump_Concat o
["cat"] + o.value.collect {|x| x.is_a?(AST::String) ? " "+do_dump(x) : ["str", do_dump(x)]}
end
def dump_Hostclass o
# ok, this is kind of crazy stuff in the AST, information in a context instead of in AST, and
# parameters are in a Ruby Array with each parameter being an Array...
#
context = o.context
args = context[:arguments]
parent = context[:parent]
result = ["class", o.name]
result << ["inherits", parent] if parent
result << ["parameters"] + args.collect {|p| _dump_ParameterArray(p) } if args && args.size() > 0
if is_nop?(o.code)
result << []
else
result << do_dump(o.code)
end
result
end
def dump_Name o
o.value
end
def dump_Node o
context = o.context
parent = context[:parent]
code = context[:code]
result = ["node"]
result << ["matches"] + o.names.collect {|m| do_dump(m) }
result << ["parent", do_dump(parent)] if !is_nop?(parent)
if is_nop?(code)
result << []
else
result << do_dump(code)
end
result
end
def dump_Definition o
# ok, this is even crazier that Hostclass. The name of the define does not have an accessor
# and some things are in the context (but not the name). Parameters are called arguments and they
# are in a Ruby Array where each parameter is an array of 1 or 2 elements.
#
context = o.context
name = o.instance_variable_get("@name")
args = context[:arguments]
code = context[:code]
result = ["define", name]
result << ["parameters"] + args.collect {|p| _dump_ParameterArray(p) } if args && args.size() > 0
if is_nop?(code)
result << []
else
result << do_dump(code)
end
result
end
def dump_ResourceReference o
result = ["slice", do_dump(o.type)]
if o.title.children.size == 1
result << do_dump(o.title[0])
else
result << do_dump(o.title.children)
end
result
end
def dump_ResourceOverride o
result = ["override", do_dump(o.object), :indent]
o.parameters.each do |p|
result << :break << do_dump(p)
end
result << :dedent
result
end
# Puppet AST encodes a parameter as a one or two slot Array.
# This is not a polymorph dump method.
#
def _dump_ParameterArray o
if o.size == 2
["=", o[0], do_dump(o[1])]
else
o[0]
end
end
def dump_IfStatement o
result = ["if", do_dump(o.test), :indent, :break,
["then", :indent, do_dump(o.statements), :dedent]]
result +=
[:break,
["else", :indent, do_dump(o.else), :dedent],
:dedent] unless is_nop? o.else
result
end
# Produces (invoke name args...) when not required to produce an rvalue, and
# (call name args ... ) otherwise.
#
def dump_Function o
# somewhat ugly as Function hides its "ftype" instance variable
result = [o.instance_variable_get("@ftype") == :rvalue ? "call" : "invoke", do_dump(o.name)]
o.arguments.collect {|a| result << do_dump(a) }
result << do_dump(o.pblock) if o.pblock
result
end
def dump_MethodCall o
# somewhat ugly as Method call (does the same as function) and hides its "ftype" instance variable
result = [o.instance_variable_get("@ftype") == :rvalue ? "call-method" : "invoke-method",
[".", do_dump(o.receiver), do_dump(o.name)]]
o.arguments.collect {|a| result << do_dump(a) }
result << do_dump(o.lambda) if o.lambda
result
end
def dump_CaseStatement o
result = ["case", do_dump(o.test), :indent]
o.options.each do |s|
result << :break << do_dump(s)
end
result << :dedent
end
def dump_CaseOpt o
result = ["when"]
result << o.value.collect {|x| do_dump(x) }
# A bit of trickery to get it into the same shape as Pops output
if is_nop?(o.statements)
result << ["then", []] # Puppet AST has a nop if there is no body
else
result << ["then", do_dump(o.statements) ]
end
result
end
def dump_ResourceInstance o
result = [do_dump(o.title), :indent]
o.parameters.each do |p|
result << :break << do_dump(p)
end
result << :dedent
result
end
def dump_ResourceDefaults o
result = ["resource-defaults", do_dump(o.type), :indent]
o.parameters.each do |p|
result << :break << do_dump(p)
end
result << :dedent
result
end
def dump_Resource o
if o.exported
form = 'exported-'
elsif o.virtual
form = 'virtual-'
else
form = ''
end
result = [form+"resource", do_dump(o.type), :indent]
o.instances.each do |b|
result << :break << do_dump(b)
end
result << :dedent
result
end
def dump_Selector o
values = o.values
values = [values] unless values.instance_of? AST::ASTArray or values.instance_of? Array
["?", do_dump(o.param)] + values.collect {|x| do_dump(x) }
end
def dump_Object o
['dev-error-no-polymorph-dump-for:', o.class.to_s, o.to_s]
end
def is_nop? o
o.nil? || o.is_a?(Model::Nop) || o.is_a?(AST::Nop)
end
end
puppet-3.4.3/lib/puppet/pops/patterns.rb 0000644 0052762 0001160 00000003120 12300765631 020156 0 ustar jenkins jenkins # The Patterns module contains common regular expression patters for the Puppet DSL language
module Puppet::Pops::Patterns
# NUMERIC matches hex, octal, decimal, and floating point and captures three parts
# 0 = entire matched number, leading and trailing whitespace included
# 1 = hexadecimal number
# 2 = non hex integer portion, possibly with leading 0 (octal)
# 3 = floating point part, starts with ".", decimals and optional exponent
#
# Thus, a hex number has group 1 value, an octal value has group 2 (if it starts with 0), and no group 3
# and a floating point value has group 2 and group 3.
#
NUMERIC = %r{^\s*(?:(0[xX][0-9A-Fa-f]+)|(0?\d+)((?:\.\d+)?(?:[eE]-?\d+)?))\s*$}
# ILLEGAL_P3_1_HOSTNAME matches if a hostname contains illegal characters.
# This check does not prevent pathological names like 'a....b', '.....', "---". etc.
ILLEGAL_HOSTNAME_CHARS = %r{[^-\w.]}
# NAME matches a name the same way as the lexer.
# This name includes hyphen, which may be illegal in variables, and names in general.
NAME = %r{\A((::)?[a-z0-9]\w*)(::[a-z0-9]\w*)*\z}
# CLASSREF_EXT matches a class reference the same way as the lexer - i.e. the external source form
# where each part must start with a capital letter A-Z.
# This name includes hyphen, which may be illegal in some cases.
#
CLASSREF_EXT = %r{\A((::){0,1}[A-Z][-\w]*)+\z}
# CLASSREF matches a class reference the way it is represented internally in the
# model (i.e. in lower case).
# This name includes hyphen, which may be illegal in some cases.
#
CLASSREF = %r{\A((::){0,1}[a-z][-\w]*)+\z}
end
puppet-3.4.3/lib/puppet/pops/adapters.rb 0000644 0052762 0001160 00000005600 12300765631 020126 0 ustar jenkins jenkins # The Adapters module contains adapters for Documentation, Origin, SourcePosition, and Loader.
#
module Puppet::Pops::Adapters
# A documentation adapter adapts an object with a documentation string.
# (The intended use is for a source text parser to extract documentation and store this
# in DocumentationAdapter instances).
#
class DocumentationAdapter < Puppet::Pops::Adaptable::Adapter
# @return [String] The documentation associated with an object
attr_accessor :documentation
end
# An origin adapter adapts an object with where it came from. This origin
# describes the resource (a file, etc.) where source text originates.
# Instances of SourcePosAdapter is then used on other objects in a model to
# describe their relative position versus the origin.
#
# @see Puppet::Pops::Utils#find_adapter
#
class OriginAdapter < Puppet::Pops::Adaptable::Adapter
# @return [String] the origin of the adapted (usually a filename)
attr_accessor :origin
end
# A SourcePosAdapter describes a position relative to an origin. (Typically an {OriginAdapter} is
# associated with the root of a model. This origin has a URI to the resource, and a line number.
# The offset in the SourcePosAdapter is then relative to this origin.
# (This somewhat complex structure makes it possible to correctly refer to a source position
# in source that is embedded in some resource; a parser only sees the embedded snippet of source text
# and does not know where it was embedded).
#
# @see Puppet::Pops::Utils#find_adapter
#
class SourcePosAdapter < Puppet::Pops::Adaptable::Adapter
# @return [Fixnum] The start line in source starting from 1
attr_accessor :line
# @return [Fixnum] The position on the start_line (in characters) starting from 0
attr_accessor :pos
# @return [Fixnum] The (start) offset of source text characters
# (starting from 0) representing the adapted object.
# Value may be nil
attr_accessor :offset
# @return [Fixnum] The length (count) of characters of source text
# representing the adapted object from the origin. Not including any
# trailing whitespace.
attr_accessor :length
def extract_text_from_string(string)
string.slice(offset, length)
end
end
# A LoaderAdapter adapts an object with a {Puppet::Pops::Loader}. This is used to make further loading from the
# perspective of the adapted object take place in the perspective of this Loader.
#
# It is typically enough to adapt the root of a model as a search is made towards the root of the model
# until a loader is found, but there is no harm in duplicating this information provided a contained
# object is adapted with the correct loader.
#
# @see Puppet::Pops::Utils#find_adapter
#
class LoaderAdapter < Puppet::Pops::Adaptable::Adapter
# @return [Puppet::Pops::Loader] the loader
attr_accessor :loader
end
end
puppet-3.4.3/lib/puppet/pops/issue_reporter.rb 0000644 0052762 0001160 00000005676 12300765631 021412 0 ustar jenkins jenkins class Puppet::Pops::IssueReporter
# @param acceptor [Puppet::Pops::Validation::Acceptor] the acceptor containing reported issues
# @option options [String] :message (nil) A message text to use as prefix in a single Error message
# @option options [Boolean] :emit_warnings (false) A message text to use as prefix in a single Error message
# @option options [Boolean] :emit_errors (true) whether errors should be emitted or only given message
# @option options [Exception] :exception_class (Puppet::ParseError) The exception to raise
#
def self.assert_and_report(acceptor, options)
return unless acceptor
max_errors = Puppet[:max_errors]
max_warnings = Puppet[:max_warnings] + 1
max_deprecations = Puppet[:max_deprecations] + 1
emit_warnings = options[:emit_warnings] || false
emit_errors = options[:emit_errors] || true
emit_message = options[:message]
emit_exception = options[:exception_class] || Puppet::ParseError
# If there are warnings output them
warnings = acceptor.warnings
if emit_warnings && warnings.size > 0
formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
emitted_w = 0
emitted_dw = 0
acceptor.warnings.each do |w|
if w.severity == :deprecation
# Do *not* call Puppet.deprecation_warning it is for internal deprecation, not
# deprecation of constructs in manifests! (It is not designed for that purpose even if
# used throughout the code base).
#
Puppet.warning(formatter.format(w)) if emitted_dw < max_deprecations
emitted_dw += 1
else
Puppet.warning(formatter.format(w)) if emitted_w < max_warnings
emitted_w += 1
end
break if emitted_w > max_warnings && emitted_dw > max_deprecations # but only then
end
end
# If there were errors, report the first found. Use a puppet style formatter.
errors = acceptor.errors
if errors.size > 0
unless emit_errors
raise emit_exception.new(emit_message)
end
formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
if errors.size == 1 || max_errors <= 1
# raise immediately
raise emit_exception.new(format_with_prefix(emit_message, formatter.format(errors[0])))
end
emitted = 0
if emit_message
Puppet.err(emit_message)
end
errors.each do |e|
Puppet.err(formatter.format(e))
emitted += 1
break if emitted >= max_errors
end
warnings_message = (emit_warnings && warnings.size > 0) ? ", and #{warnings.size} warnings" : ""
giving_up_message = "Found #{errors.size} errors#{warnings_message}. Giving up"
exception = emit_exception.new(giving_up_message)
exception.file = errors[0].file
raise exception
end
parse_result
end
def self.format_with_prefix(prefix, message)
return message unless prefix
[prefix, message].join(' ')
end
end puppet-3.4.3/lib/puppet/pops/issues.rb 0000644 0052762 0001160 00000025556 12300765631 017652 0 ustar jenkins jenkins # Defines classes to deal with issues, and message formatting and defines constants with Issues.
# @api public
#
module Puppet::Pops::Issues
# Describes an issue, and can produce a message for an occurrence of the issue.
#
class Issue
# The issue code
# @return [Symbol]
attr_reader :issue_code
# A block producing the message
# @return [Proc]
attr_reader :message_block
# Names that must be bound in an occurrence of the issue to be able to produce a message.
# These are the names in addition to requirements stipulated by the Issue formatter contract; i.e. :label`,
# and `:semantic`.
#
attr_reader :arg_names
# If this issue can have its severity lowered to :warning, :deprecation, or :ignored
attr_writer :demotable
# Configures the Issue with required arguments (bound by occurrence), and a block producing a message.
def initialize issue_code, *args, &block
@issue_code = issue_code
@message_block = block
@arg_names = args
@demotable = true
end
# Returns true if it is allowed to demote this issue
def demotable?
@demotable
end
# Formats a message for an occurrence of the issue with argument bindings passed in a hash.
# The hash must contain a LabelProvider bound to the key `label` and the semantic model element
# bound to the key `semantic`. All required arguments as specified by `arg_names` must be bound
# in the given `hash`.
# @api public
#
def format(hash ={})
# Create a Message Data where all hash keys become methods for convenient interpolation
# in issue text.
msgdata = MessageData.new(*arg_names)
begin
# Evaluate the message block in the msg data's binding
msgdata.format(hash, &message_block)
rescue StandardError => e
raise RuntimeError, "Error while reporting issue: #{issue_code}. #{e.message}", caller
end
end
end
# Provides a binding of arguments passed to Issue.format to method names available
# in the issue's message producing block.
# @api private
#
class MessageData
def initialize *argnames
singleton = class << self; self end
argnames.each do |name|
singleton.send(:define_method, name) do
@data[name]
end
end
end
def format(hash, &block)
@data = hash
instance_eval &block
end
# Returns the label provider given as a key in the hash passed to #format.
#
def label
raise "Label provider key :label must be set to produce the text of the message!" unless @data[:label]
@data[:label]
end
# Returns the label provider given as a key in the hash passed to #format.
#
def semantic
raise "Label provider key :semantic must be set to produce the text of the message!" unless @data[:semantic]
@data[:semantic]
end
end
# Defines an issue with the given `issue_code`, additional required parameters, and a block producing a message.
# The block is evaluated in the context of a MessageData which provides convenient access to all required arguments
# via accessor methods. In addition to accessors for specified arguments, these are also available:
# * `label` - a `LabelProvider` that provides human understandable names for model elements and production of article (a/an/the).
# * `semantic` - the model element for which the issue is reported
#
# @param issue_code [Symbol] the issue code for the issue used as an identifier, should be the same as the constant
# the issue is bound to.
# @param args [Symbol] required arguments that must be passed when formatting the message, may be empty
# @param block [Proc] a block producing the message string, evaluated in a MessageData scope. The produced string
# should not end with a period as additional information may be appended.
#
# @see MessageData
# @api public
#
def self.issue (issue_code, *args, &block)
Issue.new(issue_code, *args, &block)
end
# Creates a non demotable issue.
# @see Issue.issue
#
def self.hard_issue(issue_code, *args, &block)
result = Issue.new(issue_code, *args, &block)
result.demotable = false
result
end
# @comment Here follows definitions of issues. The intent is to provide a list from which yardoc can be generated
# containing more detailed information / explanation of the issue.
# These issues are set as constants, but it is unfortunately not possible for the created object to easily know which
# name it is bound to. Instead the constant has to be repeated. (Alternatively, it could be done by instead calling
# #const_set on the module, but the extra work required to get yardoc output vs. the extra effort to repeat the name
# twice makes it not worth it (if doable at all, since there is no tag to artificially construct a constant, and
# the parse tag does not produce any result for a constant assignment).
# This is allowed (3.1) and has not yet been deprecated.
# @todo configuration
#
NAME_WITH_HYPHEN = issue :NAME_WITH_HYPHEN, :name do
"#{label.a_an_uc(semantic)} may not have a name containing a hyphen. The name '#{name}' is not legal"
end
# When a variable name contains a hyphen and these are illegal.
# It is possible to control if a hyphen is legal in a name or not using the setting TODO
# @todo describe the setting
# @api public
# @todo configuration if this is error or warning
#
VAR_WITH_HYPHEN = issue :VAR_WITH_HYPHEN, :name do
"A variable name may not contain a hyphen. The name '#{name}' is not legal"
end
# A class, definition, or node may only appear at top level or inside other classes
# @todo Is this really true for nodes? Can they be inside classes? Isn't that too late?
# @api public
#
NOT_TOP_LEVEL = hard_issue :NOT_TOP_LEVEL do
"Classes, definitions, and nodes may only appear at toplevel or inside other classes"
end
CROSS_SCOPE_ASSIGNMENT = hard_issue :CROSS_SCOPE_ASSIGNMENT, :name do
"Illegal attempt to assign to '#{name}'. Cannot assign to variables in other namespaces"
end
# Assignment can only be made to certain types of left hand expressions such as variables.
ILLEGAL_ASSIGNMENT = hard_issue :ILLEGAL_ASSIGNMENT do
"Illegal attempt to assign to '#{label.a_an(semantic)}'. Not an assignable reference"
end
# Assignment cannot be made to numeric match result variables
ILLEGAL_NUMERIC_ASSIGNMENT = issue :ILLEGAL_NUMERIC_ASSIGNMENT, :varname do
"Illegal attempt to assign to the numeric match result variable '$#{varname}'. Numeric variables are not assignable"
end
# parameters cannot have numeric names, clashes with match result variables
ILLEGAL_NUMERIC_PARAMETER = issue :ILLEGAL_NUMERIC_PARAMETER, :name do
"The numeric parameter name '$#{varname}' cannot be used (clashes with numeric match result variables)"
end
# In certain versions of Puppet it may be allowed to assign to a not already assigned key
# in an array or a hash. This is an optional validation that may be turned on to prevent accidental
# mutation.
#
ILLEGAL_INDEXED_ASSIGNMENT = issue :ILLEGAL_INDEXED_ASSIGNMENT do
"Illegal attempt to assign via [index/key]. Not an assignable reference"
end
# When indexed assignment ($x[]=) is allowed, the leftmost expression must be
# a variable expression.
#
ILLEGAL_ASSIGNMENT_VIA_INDEX = hard_issue :ILLEGAL_ASSIGNMENT_VIA_INDEX do
"Illegal attempt to assign to #{label.a_an(semantic)} via [index/key]. Not an assignable reference"
end
# Some expressions/statements may not produce a value (known as right-value, or rvalue).
# This may vary between puppet versions.
#
NOT_RVALUE = issue :NOT_RVALUE do
"Invalid use of expression. #{label.a_an_uc(semantic)} does not produce a value"
end
# Appending to attributes is only allowed in certain types of resource expressions.
#
ILLEGAL_ATTRIBUTE_APPEND = hard_issue :ILLEGAL_ATTRIBUTE_APPEND, :name, :parent do
"Illegal +> operation on attribute #{name}. This operator can not be used in #{label.a_an(parent)}"
end
ILLEGAL_NAME = hard_issue :ILLEGAL_NAME, :name do
"Illegal name. The given name #{name} does not conform to the naming rule \\A((::)?[a-z0-9]\w*)(::[a-z0-9]\w*)*\\z"
end
# In case a model is constructed programmatically, it must create valid type references.
#
ILLEGAL_CLASSREF = hard_issue :ILLEGAL_CLASSREF, :name do
"Illegal type reference. The given name '#{name}' does not conform to the naming rule"
end
# This is a runtime issue - storeconfigs must be on in order to collect exported. This issue should be
# set to :ignore when just checking syntax.
# @todo should be a :warning by default
#
RT_NO_STORECONFIGS = issue :RT_NO_STORECONFIGS do
"You cannot collect exported resources without storeconfigs being set; the collection will be ignored"
end
# This is a runtime issue - storeconfigs must be on in order to export a resource. This issue should be
# set to :ignore when just checking syntax.
# @todo should be a :warning by default
#
RT_NO_STORECONFIGS_EXPORT = issue :RT_NO_STORECONFIGS_EXPORT do
"You cannot collect exported resources without storeconfigs being set; the export is ignored"
end
# A hostname may only contain letters, digits, '_', '-', and '.'.
#
ILLEGAL_HOSTNAME_CHARS = hard_issue :ILLEGAL_HOSTNAME_CHARS, :hostname do
"The hostname '#{hostname}' contains illegal characters (only letters, digits, '_', '-', and '.' are allowed)"
end
# A hostname may only contain letters, digits, '_', '-', and '.'.
#
ILLEGAL_HOSTNAME_INTERPOLATION = hard_issue :ILLEGAL_HOSTNAME_INTERPOLATION do
"An interpolated expression is not allowed in a hostname of a node"
end
# Issues when an expression is used where it is not legal.
# E.g. an arithmetic expression where a hostname is expected.
#
ILLEGAL_EXPRESSION = hard_issue :ILLEGAL_EXPRESSION, :feature, :container do
"Illegal expression. #{label.a_an_uc(semantic)} is unacceptable as #{feature} in #{label.a_an(container)}"
end
# Issues when an expression is used illegaly in a query.
# query only supports == and !=, and not <, > etc.
#
ILLEGAL_QUERY_EXPRESSION = hard_issue :ILLEGAL_QUERY_EXPRESSION do
"Illegal query expression. #{label.a_an_uc(semantic)} cannot be used in a query"
end
# If an attempt is made to make a resource default virtual or exported.
#
NOT_VIRTUALIZEABLE = hard_issue :NOT_VIRTUALIZEABLE do
"Resource Defaults are not virtualizable"
end
# When an attempt is made to use multiple keys (to produce a range in Ruby - e.g. $arr[2,-1]).
# This is currently not supported, but may be in future versions
#
UNSUPPORTED_RANGE = issue :UNSUPPORTED_RANGE, :count do
"Attempt to use unsupported range in #{label.a_an(semantic)}, #{count} values given for max 1"
end
DEPRECATED_NAME_AS_TYPE = issue :DEPRECATED_NAME_AS_TYPE, :name do
"Resource references should now be capitalized. The given '#{name}' does not have the correct form"
end
end
puppet-3.4.3/lib/puppet/pops/label_provider.rb 0000644 0052762 0001160 00000003360 12300765631 021315 0 ustar jenkins jenkins # Provides a label for an object.
# This simple implementation calls #to_s on the given object, and handles articles 'a/an/the'.
#
class Puppet::Pops::LabelProvider
VOWELS = %w{a e i o u y}
SKIPPED_CHARACTERS = %w{" '}
A = "a"
AN = "an"
# Provides a label for the given object by calling `to_s` on the object.
# The intent is for this method to be overridden in concrete label providers.
def label o
o.to_s
end
# Produces a label for the given text with indefinite article (a/an)
def a_an o
text = label(o)
"#{article(text)} #{text}"
end
# Produces a label for the given text with indefinite article (A/An)
def a_an_uc o
text = label(o)
"#{article(text).capitalize} #{text}"
end
# Produces a label for the given text with *definitie article* (the).
def the o
"the #{label(o)}"
end
# Produces a label for the given text with *definitie article* (The).
def the_uc o
"The #{label(o)}"
end
private
# Produces an *indefinite article* (a/an) for the given text ('a' if
# it starts with a vowel) This is obviously flawed in the general
# sense as may labels have punctuation at the start and this method
# does not translate punctuation to English words. Also, if a vowel is
# pronounced as a consonant, the article should not be "an".
#
def article s
article_for_letter(first_letter_of(s))
end
def first_letter_of(string)
char = string[0,1]
if SKIPPED_CHARACTERS.include? char
char = string[1,1]
end
if char == ""
raise Puppet::DevError, "<#{string}> does not appear to contain a word"
end
char
end
def article_for_letter(letter)
downcased = letter.downcase
if VOWELS.include? downcased
AN
else
A
end
end
end
puppet-3.4.3/lib/puppet/pops/parser/ 0000755 0052762 0001160 00000000000 12300765640 017271 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/pops/parser/evaluating_parser.rb 0000644 0052762 0001160 00000012106 12300765631 023331 0 ustar jenkins jenkins
# Does not support "import" and parsing ruby files
#
class Puppet::Pops::Parser::EvaluatingParser
def initialize()
@parser = Puppet::Pops::Parser::Parser.new()
end
def parse_string(s, file_source = 'unknown')
@file_source = file_source
clear()
# Handling of syntax error can be much improved (in general), now it bails out of the parser
# and does not have as rich information (when parsing a string), need to update it with the file source
# (ideally, a syntax error should be entered as an issue, and not just thrown - but that is a general problem
# and an improvement that can be made in the eparser (rather than here).
# Also a possible improvement (if the YAML parser returns positions) is to provide correct output of position.
#
begin
assert_and_report(@parser.parse_string(s))
rescue Puppet::ParseError => e
e.file = @file_source unless e.file
raise e
end
end
def parse_file(file)
@file_source = file
clear()
assert_and_report(@parser.parse_file(file))
end
def evaluate_string(scope, s, file_source='unknown')
evaluate(scope, parse_string(s, file_source))
end
def evaluate_file(file)
evaluate(parse_file(file))
end
def clear()
@acceptor = nil
end
def evaluate(scope, model)
return nil unless model
ast = Puppet::Pops::Model::AstTransformer.new(@file_source, nil).transform(model)
return nil unless ast
ast.safeevaluate(scope)
end
def acceptor()
@acceptor ||= Puppet::Pops::Validation::Acceptor.new
@acceptor
end
def validator()
@validator ||= Puppet::Pops::Validation::ValidatorFactory_3_1.new().validator(acceptor)
end
def assert_and_report(parse_result)
return nil unless parse_result
# make sure the result has an origin (if parsed from a string)
unless Puppet::Pops::Adapters::OriginAdapter.get(parse_result.model)
Puppet::Pops::Adapters::OriginAdapter.adapt(parse_result.model).origin = @file_source
end
validator.validate(parse_result)
max_errors = Puppet[:max_errors]
max_warnings = Puppet[:max_warnings] + 1
max_deprecations = Puppet[:max_deprecations] + 1
# If there are warnings output them
warnings = acceptor.warnings
if warnings.size > 0
formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
emitted_w = 0
emitted_dw = 0
acceptor.warnings.each {|w|
if w.severity == :deprecation
# Do *not* call Puppet.deprecation_warning it is for internal deprecation, not
# deprecation of constructs in manifests! (It is not designed for that purpose even if
# used throughout the code base).
#
Puppet.warning(formatter.format(w)) if emitted_dw < max_deprecations
emitted_dw += 1
else
Puppet.warning(formatter.format(w)) if emitted_w < max_warnings
emitted_w += 1
end
break if emitted_w > max_warnings && emitted_dw > max_deprecations # but only then
}
end
# If there were errors, report the first found. Use a puppet style formatter.
errors = acceptor.errors
if errors.size > 0
formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
if errors.size == 1 || max_errors <= 1
# raise immediately
require 'debugger'; debugger
raise Puppet::ParseError.new(formatter.format(errors[0]))
end
emitted = 0
errors.each do |e|
Puppet.err(formatter.format(e))
emitted += 1
break if emitted >= max_errors
end
warnings_message = warnings.size > 0 ? ", and #{warnings.size} warnings" : ""
giving_up_message = "Found #{errors.size} errors#{warnings_message}. Giving up"
exception = Puppet::ParseError.new(giving_up_message)
exception.file = errors[0].file
raise exception
end
parse_result
end
def quote(x)
self.class.quote(x)
end
# Translates an already parsed string that contains control characters, quotes
# and backslashes into a quoted string where all such constructs have been escaped.
# Parsing the return value of this method using the puppet parser should yield
# exactly the same string as the argument passed to this method
#
# The method makes an exception for the two character sequences \$ and \s. They
# will not be escaped since they have a special meaning in puppet syntax.
#
# @param x [String] The string to quote and "unparse"
# @return [String] The quoted string
#
def self.quote(x)
escaped = '"'
p = nil
x.each_char do |c|
case p
when nil
# do nothing
when "\t"
escaped << '\\t'
when "\n"
escaped << '\\n'
when "\f"
escaped << '\\f'
# TODO: \cx is a range of characters - skip for now
# when "\c"
# escaped << '\\c'
when '"'
escaped << '\\"'
when '\\'
escaped << if c == '$' || c == 's'; p; else '\\\\'; end # don't escape \ when followed by s or $
else
escaped << p
end
p = c
end
escaped << p unless p.nil?
escaped << '"'
end
end
puppet-3.4.3/lib/puppet/pops/parser/egrammar.ra 0000644 0052762 0001160 00000060351 12300765631 021415 0 ustar jenkins jenkins # vim: syntax=ruby
# Parser using the Pops model, expression based
class Puppet::Pops::Parser::Parser
token STRING DQPRE DQMID DQPOST
token LBRACK RBRACK LBRACE RBRACE SYMBOL FARROW COMMA TRUE
token FALSE EQUALS APPENDS LESSEQUAL NOTEQUAL DOT COLON LLCOLLECT RRCOLLECT
token QMARK LPAREN RPAREN ISEQUAL GREATEREQUAL GREATERTHAN LESSTHAN
token IF ELSE
token DEFINE ELSIF VARIABLE CLASS INHERITS NODE BOOLEAN
token NAME SEMIC CASE DEFAULT AT LCOLLECT RCOLLECT CLASSREF
token NOT OR AND UNDEF PARROW PLUS MINUS TIMES DIV LSHIFT RSHIFT UMINUS
token MATCH NOMATCH REGEX IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
token IN UNLESS PIPE
token SELBRACE
token LOW
prechigh
left HIGH
left SEMIC
left PIPE
left LPAREN
left RPAREN
left AT
left DOT
left CALL
left LBRACK
left QMARK
left LCOLLECT LLCOLLECT
right NOT
nonassoc UMINUS
left IN
left MATCH NOMATCH
left TIMES DIV MODULO
left MINUS PLUS
left LSHIFT RSHIFT
left NOTEQUAL ISEQUAL
left GREATEREQUAL GREATERTHAN LESSTHAN LESSEQUAL
left AND
left OR
right APPENDS EQUALS
left LBRACE
left SELBRACE
left RBRACE
left IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
left TITLE_COLON
left CASE_COLON
left FARROW
left COMMA
left LOW
preclow
rule
# Produces [Model::BlockExpression, Model::Expression, nil] depending on multiple statements, single statement or empty
program
: statements { result = Factory.block_or_expression(*val[0]) }
| nil
# Produces a semantic model (non validated, but semantically adjusted).
statements
: syntactic_statements { result = transform_calls(val[0]) }
# Change may have issues with nil; i.e. program is a sequence of nils/nops
# Simplified from original which had validation for top level constructs - see statement rule
# Produces Array
syntactic_statements
: syntactic_statement { result = [val[0]]}
| syntactic_statements SEMIC syntactic_statement { result = val[0].push val[2] }
| syntactic_statements syntactic_statement { result = val[0].push val[1] }
# Produce a single expression or Array of expression
syntactic_statement
: any_expression { result = val[0] }
| syntactic_statement COMMA any_expression { result = aryfy(val[0]).push val[2] }
any_expression
: relationship_expression
relationship_expression
: resource_expression =LOW { result = val[0] }
| relationship_expression IN_EDGE relationship_expression { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
| relationship_expression IN_EDGE_SUB relationship_expression { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
| relationship_expression OUT_EDGE relationship_expression { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
| relationship_expression OUT_EDGE_SUB relationship_expression { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
#---EXPRESSION
#
# Produces Model::Expression
expression
: higher_precedence
| expression LBRACK expressions RBRACK =LBRACK { result = val[0][*val[2]] ; loc result, val[0], val[3] }
| expression IN expression { result = val[0].in val[2] ; loc result, val[1] }
| expression MATCH match_rvalue { result = val[0] =~ val[2] ; loc result, val[1] }
| expression NOMATCH match_rvalue { result = val[0].mne val[2] ; loc result, val[1] }
| expression PLUS expression { result = val[0] + val[2] ; loc result, val[1] }
| expression MINUS expression { result = val[0] - val[2] ; loc result, val[1] }
| expression DIV expression { result = val[0] / val[2] ; loc result, val[1] }
| expression TIMES expression { result = val[0] * val[2] ; loc result, val[1] }
| expression MODULO expression { result = val[0] % val[2] ; loc result, val[1] }
| expression LSHIFT expression { result = val[0] << val[2] ; loc result, val[1] }
| expression RSHIFT expression { result = val[0] >> val[2] ; loc result, val[1] }
| MINUS expression =UMINUS { result = val[1].minus() ; loc result, val[0] }
| expression NOTEQUAL expression { result = val[0].ne val[2] ; loc result, val[1] }
| expression ISEQUAL expression { result = val[0] == val[2] ; loc result, val[1] }
| expression GREATERTHAN expression { result = val[0] > val[2] ; loc result, val[1] }
| expression GREATEREQUAL expression { result = val[0] >= val[2] ; loc result, val[1] }
| expression LESSTHAN expression { result = val[0] < val[2] ; loc result, val[1] }
| expression LESSEQUAL expression { result = val[0] <= val[2] ; loc result, val[1] }
| NOT expression { result = val[1].not ; loc result, val[0] }
| expression AND expression { result = val[0].and val[2] ; loc result, val[1] }
| expression OR expression { result = val[0].or val[2] ; loc result, val[1] }
| expression EQUALS expression { result = val[0].set(val[2]) ; loc result, val[1] }
| expression APPENDS expression { result = val[0].plus_set(val[2]) ; loc result, val[1] }
| expression QMARK selector_entries { result = val[0].select(*val[2]) ; loc result, val[0] }
| LPAREN expression RPAREN { result = val[1].paren() ; loc result, val[0] }
#---EXPRESSIONS
# (e.g. argument list)
#
# This expression list can not contain function calls without parentheses around arguments
# Produces Array
expressions
: expression { result = [val[0]] }
| expressions COMMA expression { result = val[0].push(val[2]) }
# These go through a chain of left recursion, ending with primary_expression
higher_precedence
: call_function_expression
primary_expression
: literal_expression
| variable
| call_method_with_lambda_expression
| collection_expression
| case_expression
| if_expression
| unless_expression
| definition_expression
| hostclass_expression
| node_definition_expression
# Aleways have the same value
literal_expression
: array
| boolean
| default
| hash
| regex
| text_or_name =LOW # resolves hash key ambiguity (racc W U require this?)
| type
| undef
text_or_name
: name { result = val[0] }
| quotedtext { result = val[0] }
#---CALL FUNCTION
#
# Produces Model::CallNamedFunction
call_function_expression
: primary_expression LPAREN expressions endcomma RPAREN {
result = Factory.CALL_NAMED(val[0], true, val[2])
loc result, val[0], val[4]
}
| primary_expression LPAREN RPAREN {
result = Factory.CALL_NAMED(val[0], true, [])
loc result, val[0], val[2]
}
| primary_expression LPAREN expressions endcomma RPAREN lambda {
result = Factory.CALL_NAMED(val[0], true, val[2])
loc result, val[0], val[4]
result.lambda = val[5]
}
| primary_expression LPAREN RPAREN lambda {
result = Factory.CALL_NAMED(val[0], true, [])
loc result, val[0], val[2]
result.lambda = val[3]
}
| primary_expression = LOW { result = val[0] }
#---CALL METHOD
#
call_method_with_lambda_expression
: call_method_expression =LOW { result = val[0] }
| call_method_expression lambda { result = val[0]; val[0].lambda = val[1] }
call_method_expression
: named_access LPAREN expressions RPAREN { result = Factory.CALL_METHOD(val[0], val[2]); loc result, val[1], val[3] }
| named_access LPAREN RPAREN { result = Factory.CALL_METHOD(val[0], []); loc result, val[1], val[3] }
| named_access =LOW { result = Factory.CALL_METHOD(val[0], []); loc result, val[0] }
# TODO: It may be of value to access named elements of types too
named_access
: expression DOT NAME {
result = val[0].dot(Factory.fqn(val[2][:value]))
loc result, val[1], val[2]
}
#---LAMBDA
#
# This is a temporary switch while experimenting with concrete syntax
# One should be picked for inclusion in puppet.
# Lambda with parameters to the left of the body
lambda
: lambda_parameter_list lambda_rest {
result = Factory.LAMBDA(val[0], val[1])
# loc result, val[1] # TODO
}
lambda_rest
: LBRACE statements RBRACE { result = val[1] }
| LBRACE RBRACE { result = nil }
# Produces Array
lambda_parameter_list
: PIPE PIPE { result = [] }
| PIPE parameters endcomma PIPE { result = val[1] }
#---CONDITIONALS
#
#--IF
#
# Produces Model::IfExpression
if_expression
: IF if_part {
result = val[1]
loc(result, val[0], val[1])
}
# Produces Model::IfExpression
if_part
: expression LBRACE statements RBRACE else {
result = Factory.IF(val[0], Factory.block_or_expression(*val[2]), val[4])
loc(result, val[0], (val[4] ? val[4] : val[3]))
}
| expression LBRACE RBRACE else {
result = Factory.IF(val[0], nil, val[3])
loc(result, val[0], (val[3] ? val[3] : val[2]))
}
# Produces [Model::Expression, nil] - nil if there is no else or elsif part
else
: # nothing
| ELSIF if_part {
result = val[1]
loc(result, val[0], val[1])
}
| ELSE LBRACE statements RBRACE {
result = Factory.block_or_expression(*val[2])
loc result, val[0], val[3]
}
| ELSE LBRACE RBRACE {
result = nil # don't think a nop is needed here either
}
#--UNLESS
#
# Changed from Puppet 3x where there is no else part on unless
#
unless_expression
: UNLESS expression LBRACE statements RBRACE unless_else {
result = Factory.UNLESS(val[1], Factory.block_or_expression(*val[3]), val[5])
loc result, val[0], val[4]
}
| UNLESS expression LBRACE RBRACE unless_else {
result = Factory.UNLESS(val[1], nil, nil)
loc result, val[0], val[4]
}
# Different from else part of if, since "elsif" is not supported, but 'else' is
#
# Produces [Model::Expression, nil] - nil if there is no else or elsif part
unless_else
: # nothing
| ELSE LBRACE statements RBRACE {
result = Factory.block_or_expression(*val[2])
loc result, val[0], val[3]
}
| ELSE LBRACE RBRACE {
result = nil # don't think a nop is needed here either
}
#--- CASE EXPRESSION
#
# Produces Model::CaseExpression
case_expression
: CASE expression LBRACE case_options RBRACE {
result = Factory.CASE(val[1], *val[3])
loc result, val[0], val[4]
}
# Produces Array
case_options
: case_option { result = [val[0]] }
| case_options case_option { result = val[0].push val[1] }
# Produced Model::CaseOption (aka When)
case_option
: expressions case_colon LBRACE statements RBRACE {
result = Factory.WHEN(val[0], val[3])
loc result, val[1], val[4]
}
| expressions case_colon LBRACE RBRACE = LOW {
result = Factory.WHEN(val[0], nil)
loc result, val[1], val[3]
}
case_colon: COLON =CASE_COLON { result = val[0] }
# This special construct is required or racc will produce the wrong result when the selector entry
# LHS is generalized to any expression (LBRACE looks like a hash). Thus it is not possible to write
# a selector with a single entry where the entry LHS is a hash.
# The SELBRACE token is a LBRACE that follows a QMARK, and this is produced by the lexer with a lookback
# Produces Array
#
selector_entries
: selector_entry
| SELBRACE selector_entry_list endcomma RBRACE {
result = val[1]
}
# Produces Array
selector_entry_list
: selector_entry { result = [val[0]] }
| selector_entry_list COMMA selector_entry { result = val[0].push val[2] }
# Produces a Model::SelectorEntry
# This FARROW wins over FARROW in Hash
selector_entry
: expression FARROW expression { result = Factory.MAP(val[0], val[2]) ; loc result, val[1] }
# --- IMPORT
# IMPORT is handled as a non parenthesized call and is transformed to an ImportExpression.
# i.e. there is no special grammar for it - it is just a "call statement".
#---RESOURCE
#
# Produces [Model::ResourceExpression, Model::ResourceDefaultsExpression]
# The resource expression parses a generalized syntax and then selects the correct
# resulting model based on the combinatoin of the LHS and what follows.
# It also handled exported and virtual resources, and the class case
#
resource_expression
: expression =LOW {
result = val[0]
}
| at expression LBRACE resourceinstances endsemi RBRACE {
result = case Factory.resource_shape(val[1])
when :resource, :class
tmp = Factory.RESOURCE(Factory.fqn(token_text(val[1])), val[3])
tmp.form = val[0]
tmp
when :defaults
error "A resource default can not be virtual or exported"
when :override
error "A resource override can not be virtual or exported"
else
error "Expression is not valid as a resource, resource-default, or resource-override"
end
loc result, val[1], val[4]
}
| at expression LBRACE attribute_operations endcomma RBRACE {
result = case Factory.resource_shape(val[1])
when :resource, :class
error "Defaults are not virtualizable"
when :defaults
error "Defaults are not virtualizable"
when :override
error "Defaults are not virtualizable"
else
error "Expression is not valid as a resource, resource-default, or resource-override"
end
}
| expression LBRACE resourceinstances endsemi RBRACE {
result = case Factory.resource_shape(val[0])
when :resource, :class
Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
when :defaults
error "A resource default can not specify a resource name"
when :override
error "A resource override does not allow override of name of resource"
else
error "Expression is not valid as a resource, resource-default, or resource-override"
end
loc result, val[0], val[4]
}
| expression LBRACE attribute_operations endcomma RBRACE {
result = case Factory.resource_shape(val[0])
when :resource, :class
# This catches deprecated syntax.
error "All resource specifications require names"
when :defaults
Factory.RESOURCE_DEFAULTS(val[0], val[2])
when :override
# This was only done for override in original - TODO shuld it be here at all
Factory.RESOURCE_OVERRIDE(val[0], val[2])
else
error "Expression is not valid as a resource, resource-default, or resource-override"
end
loc result, val[0], val[4]
}
| CLASS LBRACE resourceinstances endsemi RBRACE {
result = Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
loc result, val[0], val[4]
}
resourceinst
: expression title_colon attribute_operations endcomma { result = Factory.RESOURCE_BODY(val[0], val[2]) }
title_colon : COLON =TITLE_COLON { result = val[0] }
resourceinstances
: resourceinst { result = [val[0]] }
| resourceinstances SEMIC resourceinst { result = val[0].push val[2] }
# Produces Symbol corresponding to resource form
#
at
: AT { result = :virtual }
| AT AT { result = :exported }
#---COLLECTION
#
# A Collection is a predicate applied to a set of objects with an implied context (used variables are
# attributes of the object.
# i.e. this is equivalent for source.select(QUERY).apply(ATTRIBUTE_OPERATIONS)
#
# Produces Model::CollectExpression
#
collection_expression
: expression collect_query LBRACE attribute_operations endcomma RBRACE {
result = Factory.COLLECT(val[0], val[1], val[3])
loc result, val[0], val[5]
}
| expression collect_query =LOW {
result = Factory.COLLECT(val[0], val[1], [])
loc result, val[0], val[1]
}
collect_query
: LCOLLECT optional_query RCOLLECT { result = Factory.VIRTUAL_QUERY(val[1]) ; loc result, val[0], val[2] }
| LLCOLLECT optional_query RRCOLLECT { result = Factory.EXPORTED_QUERY(val[1]) ; loc result, val[0], val[2] }
optional_query
: nil
| expression
#---ATTRIBUTE OPERATIONS
#
# (Not an expression)
#
# Produces Array
#
attribute_operations
: { result = [] }
| attribute_operation { result = [val[0]] }
| attribute_operations COMMA attribute_operation { result = val[0].push(val[2]) }
# Produces String
# QUESTION: Why is BOOLEAN valid as an attribute name?
#
attribute_name
: NAME
| keyword
| BOOLEAN
# In this version, illegal combinations are validated instead of producing syntax errors
# (Can give nicer error message "+> is not applicable to...")
# Produces Model::AttributeOperation
#
attribute_operation
: attribute_name FARROW expression {
result = Factory.ATTRIBUTE_OP(val[0][:value], :'=>', val[2])
loc result, val[0], val[2]
}
| attribute_name PARROW expression {
result = Factory.ATTRIBUTE_OP(val[0][:value], :'+>', val[2])
loc result, val[0], val[2]
}
#---DEFINE
#
# Produces Model::Definition
#
definition_expression
: DEFINE classname parameter_list LBRACE statements RBRACE {
result = Factory.DEFINITION(classname(val[1][:value]), val[2], val[4])
loc result, val[0], val[5]
@lexer.indefine = false
}
| DEFINE classname parameter_list LBRACE RBRACE {
result = Factory.DEFINITION(classname(val[1][:value]), val[2], nil)
loc result, val[0], val[4]
@lexer.indefine = false
}
#---HOSTCLASS
# ORIGINAL COMMENT: Our class gets defined in the parent namespace, not our own.
# WAT ??! This is way odd; should get its complete name, classnames do not nest
# Seems like the call to classname makes use of the name scope
# (This is uneccesary, since the parent name is known when evaluating)
#
# Produces Model::HostClassDefinition
#
hostclass_expression
: CLASS classname parameter_list classparent LBRACE statements RBRACE {
@lexer.namepop
result = Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), val[5])
loc result, val[0], val[6]
}
| CLASS classname parameter_list classparent LBRACE RBRACE {
@lexer.namepop
result = Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), nil)
loc result, val[0], val[5]
}
# Produces String, name or nil result
classparent
: nil
| INHERITS classnameordefault { result = val[1] }
# Produces String (this construct allows a class to be named "default" and to be referenced as
# the parent class.
# TODO: Investigate the validity
# Produces a String (classname), or a token (DEFAULT).
#
classnameordefault
: classname
| DEFAULT
#---NODE
#
# Produces Model::NodeDefinition
#
node_definition_expression
: NODE hostnames nodeparent LBRACE statements RBRACE {
result = Factory.NODE(val[1], val[2], val[4])
loc result, val[0], val[5]
}
| NODE hostnames nodeparent LBRACE RBRACE {
result = Factory.NODE(val[1], val[2], nil)
loc result, val[0], val[4]
}
# Hostnames is not a list of names, it is a list of name matchers (including a Regexp).
# (The old implementation had a special "Hostname" object with some minimal validation)
#
# Produces Array
#
hostnames
: hostname { result = [result] }
| hostnames COMMA hostname { result = val[0].push(val[2]) }
# Produces a LiteralExpression (string, :default, or regexp)
# String with interpolation is validated for better error message
hostname
: NAME { result = Factory.fqn(val[0][:value]); loc result, val[0] }
| quotedtext { result = val[0] }
| DEFAULT { result = Factory.literal(:default); loc result, val[0] }
| regex
# Produces Expression, since hostname is an Expression
nodeparent
: nil
| INHERITS hostname { result = val[1] }
#---NAMES AND PARAMTERS COMMON TO SEVERAL RULES
# String result
classname
: NAME { result = val[0] }
| CLASS { result = val[0] }
# Produces Array
parameter_list
: nil { result = [] }
| LPAREN RPAREN { result = [] }
| LPAREN parameters endcomma RPAREN { result = val[1] }
# Produces Array
parameters
: parameter { result = [val[0]] }
| parameters COMMA parameter { result = val[0].push(val[2]) }
# Produces Model::Parameter
parameter
: VARIABLE EQUALS expression { result = Factory.PARAM(val[0][:value], val[2]) ; loc result, val[0] }
| VARIABLE { result = Factory.PARAM(val[0][:value]); loc result, val[0] }
#--RESTRICTED EXPRESSIONS
# i.e. where one could have expected an expression, but the set is limited
# What is allowed RHS of match operators (see expression)
match_rvalue
: regex
| text_or_name
#--VARIABLE
#
variable
: VARIABLE { result = Factory.fqn(val[0][:value]).var ; loc result, val[0] }
#---LITERALS (dynamic and static)
#
array
: LBRACK expressions RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[2] }
| LBRACK expressions COMMA RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
| LBRACK RBRACK { result = Factory.literal([]) ; loc result, val[0] }
hash
: LBRACE hashpairs RBRACE { result = Factory.HASH(val[1]); loc result, val[0], val[2] }
| LBRACE hashpairs COMMA RBRACE { result = Factory.HASH(val[1]); loc result, val[0], val[3] }
| LBRACE RBRACE { result = Factory.literal({}) ; loc result, val[0], val[3] }
hashpairs
: hashpair { result = [val[0]] }
| hashpairs COMMA hashpair { result = val[0].push val[2] }
hashpair
: text_or_name FARROW expression { result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1] }
quotedtext
: string
| dq_string
string : STRING { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
dq_string : dqpre dqrval { result = Factory.string(val[0], *val[1]) ; loc result, val[0], val[1][-1] }
dqpre : DQPRE { result = Factory.literal(val[0][:value]); loc result, val[0] }
dqpost : DQPOST { result = Factory.literal(val[0][:value]); loc result, val[0] }
dqmid : DQMID { result = Factory.literal(val[0][:value]); loc result, val[0] }
dqrval : text_expression dqtail { result = [val[0]] + val[1] }
text_expression : expression { result = Factory.TEXT(val[0]) }
dqtail
: dqpost { result = [val[0]] }
| dqmid dqrval { result = [val[0]] + val[1] }
name : NAME { result = Factory.QNAME_OR_NUMBER(val[0][:value]) ; loc result, val[0] }
type : CLASSREF { result = Factory.QREF(val[0][:value]) ; loc result, val[0] }
undef : UNDEF { result = Factory.literal(:undef); loc result, val[0] }
default : DEFAULT { result = Factory.literal(:default); loc result, val[0] }
# Assumes lexer produces a Boolean value for booleans, or this will go wrong and produce a literal string
# with the text 'true'.
#TODO: could be changed to a specific boolean literal factory method to prevent this possible glitch.
boolean : BOOLEAN { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
regex
: REGEX { result = Factory.literal(val[0][:value]); loc result, val[0] }
#---MARKERS, SPECIAL TOKENS, SYNTACTIC SUGAR, etc.
endcomma
: #
| COMMA { result = nil }
endsemi
: #
| SEMIC
keyword
: AND
| CASE
| CLASS
| DEFAULT
| DEFINE
| ELSE
| ELSIF
| IF
| IN
| INHERITS
| NODE
| OR
| UNDEF
| UNLESS
nil
: { result = nil}
end
---- header ----
require 'puppet'
require 'puppet/pops'
module Puppet
class ParseError < Puppet::Error; end
class ImportError < Racc::ParseError; end
class AlreadyImportedError < ImportError; end
end
---- inner ----
# Make emacs happy
# Local Variables:
# mode: ruby
# End:
puppet-3.4.3/lib/puppet/pops/parser/makefile 0000644 0052762 0001160 00000000320 12300765631 020764 0 ustar jenkins jenkins
#parser.rb: grammar.ra
# racc -o$@ grammar.ra
#
#grammar.output: grammar.ra
# racc -v -o$@ grammar.ra
#
eparser.rb: egrammar.ra
racc -o$@ egrammar.ra
egrammar.output: egrammar.ra
racc -v -o$@ egrammar.ra puppet-3.4.3/lib/puppet/pops/parser/eparser.rb 0000644 0052762 0001160 00000210647 12300765631 021271 0 ustar jenkins jenkins #
# DO NOT MODIFY!!!!
# This file is automatically generated by Racc 1.4.9
# from Racc grammer file "".
#
require 'racc/parser.rb'
require 'puppet'
require 'puppet/pops'
module Puppet
class ParseError < Puppet::Error; end
class ImportError < Racc::ParseError; end
class AlreadyImportedError < ImportError; end
end
module Puppet
module Pops
module Parser
class Parser < Racc::Parser
module_eval(<<'...end egrammar.ra/module_eval...', 'egrammar.ra', 699)
# Make emacs happy
# Local Variables:
# mode: ruby
# End:
...end egrammar.ra/module_eval...
##### State transition tables begin ###
clist = [
'68,215,228,229,-126,230,202,229,238,87,88,84,79,90,290,94,262,89,-124',
'68,80,82,81,83,68,217,51,53,51,53,224,223,90,239,94,-192,89,90,93,94',
'199,89,86,85,-126,212,72,73,75,74,77,78,276,70,71,51,53,93,-124,68,69',
'202,93,117,-201,54,119,76,87,88,84,79,90,240,94,-192,89,70,71,80,82',
'81,83,68,69,59,229,59,51,53,292,212,117,109,312,119,90,93,94,112,89',
'86,85,111,-201,72,73,75,74,77,78,294,70,71,59,51,53,279,68,69,112,93',
'51,53,111,54,76,87,88,84,79,90,307,94,306,89,70,71,80,82,81,83,112,69',
'112,219,111,59,111,321,218,278,117,112,112,119,93,111,111,117,86,85',
'119,275,72,73,75,74,77,78,220,70,71,221,59,68,68,307,69,306,238,59,189',
'299,300,76,84,79,90,90,94,94,89,89,301,80,82,81,83,51,53,202,68,165',
'51,53,284,64,66,65,67,125,304,93,93,90,236,94,85,89,308,72,73,75,74',
'77,78,310,70,71,222,261,68,236,238,69,54,317,318,260,93,54,76,84,79',
'90,260,94,63,89,63,131,80,82,81,83,68,102,254,327,253,198,113,252,330',
'102,103,238,102,90,93,94,334,89,310,336,337,338,72,73,75,74,77,78,339',
'70,71,99,342,343,344,68,69,91,93,236,63,60,351,76,87,88,84,79,90,352',
'94,353,89,70,71,80,82,81,83,68,69,354,,,,,,,,,,79,90,93,94,,89,86,85',
'80,,72,73,75,74,77,78,,70,71,,,,,,69,,93,,,,,76,68,,72,73,75,74,77,78',
',70,71,,79,90,,94,69,89,,,80,,,76,68,,,,,,,,,,,,79,90,93,94,,89,,,80',
',72,73,75,74,77,78,,70,71,,,,,,69,,93,,,,,76,68,,72,73,75,74,77,78,',
'70,71,,79,90,,94,69,89,,,80,,,76,68,,,,,,,,,,,,,90,93,94,,89,,,,,72',
'73,75,74,77,78,,70,71,,,,,,69,,93,,,,,76,,,72,73,75,74,77,78,,70,71',
',,,,68,69,,,,,,,76,87,88,84,79,90,,94,,89,,,80,82,81,83,68,,,,,,,,,',
',,,90,93,94,,89,86,85,,,72,73,75,74,77,78,,70,71,,,,,,69,,93,,,,68,76',
',,72,73,75,74,77,78,,70,71,90,,94,,89,69,,,,,,68,76,,,,,,,,,,,,90,93',
'94,,89,,,,,72,73,75,74,,,,70,71,,,,,,69,,93,,,,,76,,,72,73,75,74,,,',
'70,71,,,,,68,69,,,,,,,76,87,88,84,79,90,234,94,,89,,,80,82,81,83,,,',
',,,,,,,,,,,93,,,,86,85,,,72,73,75,74,77,78,,70,71,,,,,68,69,,,,,,,76',
'87,88,84,79,90,,94,,89,,,80,82,81,83,,,,,,,,,,,,,,,93,,,,86,85,,,72',
'73,75,74,77,78,,70,71,,,,,68,69,,,,,,,76,87,88,84,79,90,,94,,89,,,80',
'82,81,83,68,,,,,,,,,,,,,90,93,94,,89,86,85,,,72,73,75,74,77,78,,70,71',
',,,,,69,,93,,,,,76,,,,,75,74,,,,70,71,,,,,68,69,,,,,,,76,87,88,84,79',
'90,,94,,89,,,80,82,81,83,68,,,,,,,,,,,,,90,93,94,,89,86,85,,,72,73,75',
'74,77,78,,70,71,,,,,,69,,93,,,,,76,,,,,75,74,,,,70,71,,,,,68,69,,,,',
',,76,87,88,84,79,90,,94,,89,,,80,82,81,83,,,,,,,,,,,,,,,93,,,,86,85',
',,72,73,75,74,77,78,,70,71,,,,,68,69,,,,,,,76,87,88,84,79,90,,94,,89',
',,80,82,81,83,,,,,,,,,,,,,,,93,,,,86,85,,,72,73,75,74,77,78,,70,71,',
',,,68,69,,,,,,,76,87,88,84,79,90,,94,,89,,,80,82,81,83,,,,,,,,,,,,,',
',93,,,,86,85,,,72,73,75,74,77,78,,70,71,,,,,68,69,,,,,,,76,87,88,84',
'79,90,,94,,89,,,80,82,81,83,,,,,,,,,,,,,,,93,,,,86,85,,,72,73,75,74',
'77,78,,70,71,,,,,68,69,,,,,,,76,87,88,84,79,90,,94,,89,,,80,82,81,83',
',,,,,,,,,,,,,,93,,,,86,85,,,72,73,75,74,77,78,,70,71,,,,,68,69,208,',
',,,,76,87,88,84,79,90,,94,,89,,,80,82,81,83,,,,,,,,,,,,,,,93,,,,86,85',
',,72,73,75,74,77,78,,70,71,,,,,68,69,207,,,,,,76,87,88,84,79,90,,94',
',89,,,80,82,81,83,,,,,,,,,,,,,,,93,,,,86,85,,,72,73,75,74,77,78,,70',
'71,,,,,68,69,206,,,,,,76,87,88,84,79,90,,94,,89,,,80,82,81,83,,,,,,',
',,,,,,,,93,,,,86,85,,,72,73,75,74,77,78,,70,71,,,,,68,69,205,,,,,,76',
'87,88,84,79,90,,94,,89,,,80,82,81,83,,,,,,,,,,,,,,,93,,,,86,85,,,72',
'73,75,74,77,78,,70,71,,,,,68,69,,,,,,,76,87,88,84,79,90,,94,,89,,194',
'80,82,81,83,,,,,,,,,,51,53,,,47,93,48,,,86,85,,,72,73,75,74,77,78,,70',
'71,13,,,,,69,38,,44,,46,96,76,45,58,54,,40,57,,,,55,12,51,53,56,,47',
'11,48,,,,,,,59,,,,,,39,,164,13,,,,,,167,184,178,185,46,179,187,180,176',
'174,,169,182,,,,55,12,188,183,181,51,53,11,,47,,48,324,,,59,,,,,186',
'168,,,,,,13,,,,,,38,,44,,46,42,,45,58,54,,40,57,43,,,55,12,51,53,56',
',47,11,48,313,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40',
'57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46',
'96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13',
',,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,',
',,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53',
'56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40',
'57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46',
'96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13',
',,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,',
',,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53',
'56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40',
'57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46',
'96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13',
',,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,',
',,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53',
'56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40',
'57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46',
'96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13',
',,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,',
',,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53',
'56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40',
'57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46',
'96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13',
',,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,',
',,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53',
'56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,167,184,178,185,46,179,187,180',
'176,174,,169,182,,,,55,12,188,183,181,51,53,11,,47,,48,,,,59,,,,,186',
'168,,,,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47',
'11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55',
'12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58',
'54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38',
',44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,',
',,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47',
'11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55',
'12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,42,,45,58',
'54,,40,57,43,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,196,,',
',,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,,,,59',
',,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,',
'47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,',
',,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,204,,,,,38,,44,,46',
'96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13',
',,,,,38,,44,,46,42,,45,58,54,,40,57,43,,,55,12,51,53,56,,47,11,48,,',
',,,,59,,,,,,39,,,13,,,,,,38,,44,,46,42,,45,58,54,,40,57,43,,,55,12,51',
'53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,42,,45,58,54,',
'40,57,43,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44',
',46,42,,45,58,54,,40,57,43,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,',
'39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11',
'48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12',
'51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54',
',40,57,,,,55,12,,,56,51,53,11,,47,283,48,,,,59,,,,,,39,,,,,,13,,,,,',
'38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,326,,,,,',
'59,,,,,,39,,,13,,,,,,38,,44,,46,42,,45,58,54,,40,57,43,,,55,12,51,53',
'56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40',
'57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46',
'96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,266,,,,,,59,,,,,,39',
',,13,,,,,,38,,44,,46,42,,45,58,54,,40,57,43,,,55,12,51,53,56,,47,11',
'48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,42,,45,58,54,,40,57,43,,,55',
'12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58',
'54,,40,57,,,,55,12,51,53,56,,47,11,48,258,,,,,,59,,,,,,39,,,13,,,,,',
'38,,44,,46,42,,45,58,54,,40,57,43,,,55,12,51,53,56,,47,11,48,,,,,,,59',
',,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,',
'47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,',
',,55,12,,,56,51,53,11,,47,123,48,,,,59,,,,,,39,,,,,,13,,,,,,38,,44,',
'46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39',
',,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48',
',,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51',
'53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,',
'40,57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44',
',46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39',
',,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48',
',,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55,12,51',
'53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,',
'40,57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44',
',46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,341,,,,,,59,,,,',
',39,,,13,,,,,,38,,44,,46,42,,45,58,54,,40,57,43,,,55,12,51,53,56,,47',
'11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58,54,,40,57,,,,55',
'12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,96,,45,58',
'54,,40,57,,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38',
',44,,46,96,,45,58,54,,40,57,,,,55,12,51,53,56,,47,11,48,346,,,,,,59',
',,,,,39,,,13,,,,,,38,,44,,46,42,,45,58,54,,40,57,43,,,55,12,51,53,56',
',47,11,48,348,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,42,,45,58,54,,40',
'57,43,,,55,12,51,53,56,,47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,',
'46,42,,45,58,54,61,40,57,43,,,55,12,51,53,56,,47,11,48,350,,,,,,59,',
',,,,39,,,13,,,,,,38,,44,,46,42,,45,58,54,,40,57,43,,,55,12,51,53,56',
',47,11,48,,,,,,,59,,,,,,39,,,13,,,,,,38,,44,,46,42,,45,58,54,,40,57',
'43,,,55,12,51,53,56,,47,11,48,264,,,,,,59,,,,,,39,,,13,,,,,,38,,44,',
'46,42,,45,58,54,,40,57,43,,,55,12,,,56,,,11,,,,248,184,247,185,59,245',
'187,249,243,242,39,244,246,,,,,,188,183,250,248,184,247,185,,245,187',
'249,243,242,,244,246,,,186,251,,188,183,250,248,184,247,185,,245,187',
'249,243,242,,244,246,,,186,251,,188,183,250,,,,,,,,,,,,,,,,186,251' ]
racc_action_table = arr = ::Array.new(4874, nil)
idx = 0
clist.each do |str|
str.split(',', -1).each do |i|
arr[idx] = i.to_i unless i.empty?
idx += 1
end
end
clist = [
'161,115,138,203,176,161,102,138,291,161,161,161,161,161,231,161,203',
'161,174,139,161,161,161,161,148,115,215,215,71,71,130,130,139,177,139',
'182,139,148,161,148,102,148,161,161,176,110,161,161,161,161,161,161',
'212,161,161,217,217,139,174,160,161,212,148,215,181,71,215,161,160,160',
'160,160,160,177,160,182,160,148,148,160,160,160,160,147,148,215,267',
'71,70,70,235,114,217,42,267,217,147,160,147,96,147,160,160,96,181,160',
'160,160,160,160,160,237,160,160,217,180,180,214,159,160,42,147,45,45',
'42,70,160,159,159,159,159,159,264,159,264,159,147,147,159,159,159,159',
'275,147,179,122,275,70,179,275,122,213,180,44,178,180,159,44,178,45',
'159,159,45,210,159,159,159,159,159,159,124,159,159,124,180,158,97,304',
'159,304,241,45,92,255,257,159,158,158,158,97,158,97,158,97,259,158,158',
'158,158,221,221,260,95,90,48,48,221,7,7,7,7,48,263,158,97,95,209,95',
'158,95,265,158,158,158,158,158,158,266,158,158,127,202,157,270,271,158',
'221,272,273,200,95,48,158,157,157,157,277,157,132,157,62,60,157,157',
'157,157,146,196,195,289,193,101,43,191,298,299,37,171,36,146,157,146',
'307,146,308,310,311,315,157,157,157,157,157,157,316,157,157,35,322,323',
'325,10,157,10,146,170,5,1,340,157,10,10,10,10,10,345,10,347,10,146,146',
'10,10,10,10,156,146,349,,,,,,,,,,156,156,10,156,,156,10,10,156,,10,10',
'10,10,10,10,,10,10,,,,,,10,,156,,,,,10,155,,156,156,156,156,156,156',
',156,156,,155,155,,155,156,155,,,155,,,156,154,,,,,,,,,,,,154,154,155',
'154,,154,,,154,,155,155,155,155,155,155,,155,155,,,,,,155,,154,,,,,155',
'153,,154,154,154,154,154,154,,154,154,,153,153,,153,154,153,,,153,,',
'154,152,,,,,,,,,,,,,152,153,152,,152,,,,,153,153,153,153,153,153,,153',
'153,,,,,,153,,152,,,,,153,,,152,152,152,152,152,152,,152,152,,,,,303',
'152,,,,,,,152,303,303,303,303,303,,303,,303,,,303,303,303,303,151,,',
',,,,,,,,,,151,303,151,,151,303,303,,,303,303,303,303,303,303,,303,303',
',,,,,303,,151,,,,150,303,,,151,151,151,151,151,151,,151,151,150,,150',
',150,151,,,,,,149,151,,,,,,,,,,,,149,150,149,,149,,,,,150,150,150,150',
',,,150,150,,,,,,150,,149,,,,,150,,,149,149,149,149,,,,149,149,,,,,166',
'149,,,,,,,149,166,166,166,166,166,166,166,,166,,,166,166,166,166,,,',
',,,,,,,,,,,166,,,,166,166,,,166,166,166,166,166,166,,166,166,,,,,297',
'166,,,,,,,166,297,297,297,297,297,,297,,297,,,297,297,297,297,,,,,,',
',,,,,,,,297,,,,297,297,,,297,297,297,297,297,297,,297,297,,,,,296,297',
',,,,,,297,296,296,296,296,296,,296,,296,,,296,296,296,296,145,,,,,,',
',,,,,,145,296,145,,145,296,296,,,296,296,296,296,296,296,,296,296,,',
',,,296,,145,,,,,296,,,,,145,145,,,,145,145,,,,,288,145,,,,,,,145,288',
'288,288,288,288,,288,,288,,,288,288,288,288,144,,,,,,,,,,,,,144,288',
'144,,144,288,288,,,288,288,288,288,288,288,,288,288,,,,,,288,,144,,',
',,288,,,,,144,144,,,,144,144,,,,,286,144,,,,,,,144,286,286,286,286,286',
',286,,286,,,286,286,286,286,,,,,,,,,,,,,,,286,,,,286,286,,,286,286,286',
'286,286,286,,286,286,,,,,190,286,,,,,,,286,190,190,190,190,190,,190',
',190,,,190,190,190,190,,,,,,,,,,,,,,,190,,,,190,190,,,190,190,190,190',
'190,190,,190,190,,,,,282,190,,,,,,,190,282,282,282,282,282,,282,,282',
',,282,282,282,282,,,,,,,,,,,,,,,282,,,,282,282,,,282,282,282,282,282',
'282,,282,282,,,,,128,282,,,,,,,282,128,128,128,128,128,,128,,128,,,128',
'128,128,128,,,,,,,,,,,,,,,128,,,,128,128,,,128,128,128,128,128,128,',
'128,128,,,,,121,128,,,,,,,128,121,121,121,121,121,,121,,121,,,121,121',
'121,121,,,,,,,,,,,,,,,121,,,,121,121,,,121,121,121,121,121,121,,121',
'121,,,,,108,121,108,,,,,,121,108,108,108,108,108,,108,,108,,,108,108',
'108,108,,,,,,,,,,,,,,,108,,,,108,108,,,108,108,108,108,108,108,,108',
'108,,,,,107,108,107,,,,,,108,107,107,107,107,107,,107,,107,,,107,107',
'107,107,,,,,,,,,,,,,,,107,,,,107,107,,,107,107,107,107,107,107,,107',
'107,,,,,106,107,106,,,,,,107,106,106,106,106,106,,106,,106,,,106,106',
'106,106,,,,,,,,,,,,,,,106,,,,106,106,,,106,106,106,106,106,106,,106',
'106,,,,,104,106,104,,,,,,106,104,104,104,104,104,,104,,104,,,104,104',
'104,104,,,,,,,,,,,,,,,104,,,,104,104,,,104,104,104,104,104,104,,104',
'104,,,,,98,104,,,,,,,104,98,98,98,98,98,,98,,98,,98,98,98,98,98,,,,',
',,,,,89,89,,,89,98,89,,,98,98,,,98,98,98,98,98,98,,98,98,89,,,,,98,89',
',89,,89,89,98,89,89,89,,89,89,,,,89,89,208,208,89,,208,89,208,,,,,,',
'89,,,,,,89,,89,208,,,,,,208,208,208,208,208,208,208,208,208,208,,208',
'208,,,,208,208,208,208,208,278,278,208,,278,,278,278,,,208,,,,,208,208',
',,,,,278,,,,,,278,,278,,278,278,,278,278,278,,278,278,278,,,278,278',
'268,268,278,,268,278,268,268,,,,,,278,,,,,,278,,,268,,,,,,268,,268,',
'268,268,,268,268,268,,268,268,,,,268,268,72,72,268,,72,268,72,,,,,,',
'268,,,,,,268,,,72,,,,,,72,,72,,72,72,,72,72,72,,72,72,,,,72,72,73,73',
'72,,73,72,73,,,,,,,72,,,,,,72,,,73,,,,,,73,,73,,73,73,,73,73,73,,73',
'73,,,,73,73,74,74,73,,74,73,74,,,,,,,73,,,,,,73,,,74,,,,,,74,,74,,74',
'74,,74,74,74,,74,74,,,,74,74,75,75,74,,75,74,75,,,,,,,74,,,,,,74,,,75',
',,,,,75,,75,,75,75,,75,75,75,,75,75,,,,75,75,76,76,75,,76,75,76,,,,',
',,75,,,,,,75,,,76,,,,,,76,,76,,76,76,,76,76,76,,76,76,,,,76,76,77,77',
'76,,77,76,77,,,,,,,76,,,,,,76,,,77,,,,,,77,,77,,77,77,,77,77,77,,77',
'77,,,,77,77,78,78,77,,78,77,78,,,,,,,77,,,,,,77,,,78,,,,,,78,,78,,78',
'78,,78,78,78,,78,78,,,,78,78,79,79,78,,79,78,79,,,,,,,78,,,,,,78,,,79',
',,,,,79,,79,,79,79,,79,79,79,,79,79,,,,79,79,80,80,79,,80,79,80,,,,',
',,79,,,,,,79,,,80,,,,,,80,,80,,80,80,,80,80,80,,80,80,,,,80,80,81,81',
'80,,81,80,81,,,,,,,80,,,,,,80,,,81,,,,,,81,,81,,81,81,,81,81,81,,81',
'81,,,,81,81,82,82,81,,82,81,82,,,,,,,81,,,,,,81,,,82,,,,,,82,,82,,82',
'82,,82,82,82,,82,82,,,,82,82,83,83,82,,83,82,83,,,,,,,82,,,,,,82,,,83',
',,,,,83,,83,,83,83,,83,83,83,,83,83,,,,83,83,84,84,83,,84,83,84,,,,',
',,83,,,,,,83,,,84,,,,,,84,,84,,84,84,,84,84,84,,84,84,,,,84,84,85,85',
'84,,85,84,85,,,,,,,84,,,,,,84,,,85,,,,,,85,,85,,85,85,,85,85,85,,85',
'85,,,,85,85,86,86,85,,86,85,86,,,,,,,85,,,,,,85,,,86,,,,,,86,,86,,86',
'86,,86,86,86,,86,86,,,,86,86,87,87,86,,87,86,87,,,,,,,86,,,,,,86,,,87',
',,,,,87,,87,,87,87,,87,87,87,,87,87,,,,87,87,88,88,87,,88,87,88,,,,',
',,87,,,,,,87,,,88,,,,,,88,,88,,88,88,,88,88,88,,88,88,,,,88,88,68,68',
'88,,68,88,68,,,,,,,88,,,,,,88,,,68,,,,,,68,,68,,68,68,,68,68,68,,68',
'68,,,,68,68,261,261,68,,261,68,261,,,,,,,68,,,,,,68,,,261,,,,,,261,',
'261,,261,261,,261,261,261,,261,261,,,,261,261,91,91,261,,91,261,91,',
',,,,,261,,,,,,261,,,91,,,,,,91,91,91,91,91,91,91,91,91,91,,91,91,,,',
'91,91,91,91,91,254,254,91,,254,,254,,,,91,,,,,91,91,,,,,,254,,,,,,254',
',254,,254,254,,254,254,254,,254,254,,,,254,254,93,93,254,,93,254,93',
',,,,,,254,,,,,,254,,,93,,,,,,93,,93,,93,93,,93,93,93,,93,93,,,,93,93',
'94,94,93,,94,93,94,,,,,,,93,,,,,,93,,,94,,,,,,94,,94,,94,94,,94,94,94',
',94,94,,,,94,94,240,240,94,,240,94,240,,,,,,,94,,,,,,94,,,240,,,,,,240',
',240,,240,240,,240,240,240,,240,240,,,,240,240,239,239,240,,239,240',
'239,,,,,,,240,,,,,,240,,,239,,,,,,239,,239,,239,239,,239,239,239,,239',
'239,,,,239,239,236,236,239,,236,239,236,,,,,,,239,,,,,,239,,,236,,,',
',,236,,236,,236,236,,236,236,236,,236,236,,,,236,236,67,67,236,,67,236',
'67,,,,,,,236,,,,,,236,,,67,,,,,,67,,67,,67,67,,67,67,67,,67,67,67,,',
'67,67,99,99,67,,99,67,99,,,,,,,67,,,,,,67,,,99,99,,,,,99,,99,,99,99',
',99,99,99,,99,99,,,,99,99,230,230,99,,230,99,230,,,,,,,99,,,,,,99,,',
'230,,,,,,230,,230,,230,230,,230,230,230,,230,230,,,,230,230,229,229',
'230,,229,230,229,,,,,,,230,,,,,,230,,,229,,,,,,229,,229,,229,229,,229',
'229,229,,229,229,,,,229,229,103,103,229,,103,229,103,,,,,,,229,,,,,',
'229,,,103,103,,,,,103,,103,,103,103,,103,103,103,,103,103,,,,103,103',
'66,66,103,,66,103,66,,,,,,,103,,,,,,103,,,66,,,,,,66,,66,,66,66,,66',
'66,66,,66,66,66,,,66,66,65,65,66,,65,66,65,,,,,,,66,,,,,,66,,,65,,,',
',,65,,65,,65,65,,65,65,65,,65,65,65,,,65,65,64,64,65,,64,65,64,,,,,',
',65,,,,,,65,,,64,,,,,,64,,64,,64,64,,64,64,64,,64,64,64,,,64,64,63,63',
'64,,63,64,63,,,,,,,64,,,,,,64,,,63,,,,,,63,,63,,63,63,,63,63,63,,63',
'63,63,,,63,63,109,109,63,,109,63,109,,,,,,,63,,,,,,63,,,109,,,,,,109',
',109,,109,109,,109,109,109,,109,109,,,,109,109,227,227,109,,227,109',
'227,,,,,,,109,,,,,,109,,,227,,,,,,227,,227,,227,227,,227,227,227,,227',
'227,,,,227,227,222,222,227,,222,227,222,,,,,,,227,,,,,,227,,,222,,,',
',,222,,222,,222,222,,222,222,222,,222,222,,,,222,222,,,222,218,218,222',
',218,218,218,,,,222,,,,,,222,,,,,,218,,,,,,218,,218,,218,218,,218,218',
'218,,218,218,,,,218,218,279,279,218,,279,218,279,279,,,,,,218,,,,,,218',
',,279,,,,,,279,,279,,279,279,,279,279,279,,279,279,279,,,279,279,69',
'69,279,,69,279,69,,,,,,,279,,,,,,279,,,69,,,,,,69,,69,,69,69,,69,69',
'69,,69,69,,,,69,69,207,207,69,,207,69,207,,,,,,,69,,,,,,69,,,207,,,',
',,207,,207,,207,207,,207,207,207,,207,207,,,,207,207,206,206,207,,206',
'207,206,206,,,,,,207,,,,,,207,,,206,,,,,,206,,206,,206,206,,206,206',
'206,,206,206,206,,,206,206,61,61,206,,61,206,61,,,,,,,206,,,,,,206,',
',61,,,,,,61,,61,,61,61,,61,61,61,,61,61,61,,,61,61,164,164,61,,164,61',
'164,,,,,,,61,,,,,,61,,,164,,,,,,164,,164,,164,164,,164,164,164,,164',
'164,,,,164,164,198,198,164,,198,164,198,198,,,,,,164,,,,,,164,,,198',
',,,,,198,,198,,198,198,,198,198,198,,198,198,198,,,198,198,52,52,198',
',52,198,52,,,,,,,198,,,,,,198,,,52,,,,,,52,,52,,52,52,,52,52,52,,52',
'52,,,,52,52,169,169,52,,169,52,169,,,,,,,52,,,,,,52,,,169,,,,,,169,',
'169,,169,169,,169,169,169,,169,169,,,,169,169,,,169,47,47,169,,47,47',
'47,,,,169,,,,,,169,,,,,,47,,,,,,47,,47,,47,47,,47,47,47,,47,47,,,,47',
'47,290,290,47,,290,47,290,,,,,,,47,,,,,,47,,,290,,,,,,290,,290,,290',
'290,,290,290,290,,290,290,,,,290,290,168,168,290,,168,290,168,,,,,,',
'290,,,,,,290,,,168,,,,,,168,,168,,168,168,,168,168,168,,168,168,,,,168',
'168,167,167,168,,167,168,167,,,,,,,168,,,,,,168,,,167,,,,,,167,,167',
',167,167,,167,167,167,,167,167,,,,167,167,41,41,167,,41,167,41,,,,,',
',167,,,,,,167,,,41,,,,,,41,,41,,41,41,,41,41,41,,41,41,,,,41,41,40,40',
'41,,40,41,40,,,,,,,41,,,,,,41,,,40,,,,,,40,,40,,40,40,,40,40,40,,40',
'40,,,,40,40,39,39,40,,39,40,39,,,,,,,40,,,,,,40,,,39,,,,,,39,,39,,39',
'39,,39,39,39,,39,39,,,,39,39,38,38,39,,38,39,38,,,,,,,39,,,,,,39,,,38',
',,,,,38,,38,,38,38,,38,38,38,,38,38,,,,38,38,306,306,38,,306,38,306',
',,,,,,38,,,,,,38,,,306,,,,,,306,,306,,306,306,,306,306,306,,306,306',
',,,306,306,318,318,306,,318,306,318,318,,,,,,306,,,,,,306,,,318,,,,',
',318,,318,,318,318,,318,318,318,,318,318,318,,,318,318,13,13,318,,13',
'318,13,,,,,,,318,,,,,,318,,,13,,,,,,13,,13,,13,13,,13,13,13,,13,13,',
',,13,13,12,12,13,,12,13,12,,,,,,,13,,,,,,13,,,12,,,,,,12,,12,,12,12',
',12,12,12,,12,12,,,,12,12,11,11,12,,11,12,11,,,,,,,12,,,,,,12,,,11,',
',,,,11,,11,,11,11,,11,11,11,,11,11,,,,11,11,334,334,11,,334,11,334,334',
',,,,,11,,,,,,11,,,334,,,,,,334,,334,,334,334,,334,334,334,,334,334,334',
',,334,334,336,336,334,,336,334,336,336,,,,,,334,,,,,,334,,,336,,,,,',
'336,,336,,336,336,,336,336,336,,336,336,336,,,336,336,4,4,336,,4,336',
'4,,,,,,,336,,,,,,336,,,4,,,,,,4,,4,,4,4,,4,4,4,4,4,4,4,,,4,4,337,337',
'4,,337,4,337,337,,,,,,4,,,,,,4,,,337,,,,,,337,,337,,337,337,,337,337',
'337,,337,337,337,,,337,337,0,0,337,,0,337,0,,,,,,,337,,,,,,337,,,0,',
',,,,0,,0,,0,0,,0,0,0,,0,0,0,,,0,0,205,205,0,,205,0,205,205,,,,,,0,,',
',,,0,,,205,,,,,,205,,205,,205,205,,205,205,205,,205,205,205,,,205,205',
',,205,,,205,,,,233,233,233,233,205,233,233,233,233,233,205,233,233,',
',,,,233,233,233,189,189,189,189,,189,189,189,189,189,,189,189,,,233',
'233,,189,189,189,238,238,238,238,,238,238,238,238,238,,238,238,,,189',
'189,,238,238,238,,,,,,,,,,,,,,,,238,238' ]
racc_action_check = arr = ::Array.new(4874, nil)
idx = 0
clist.each do |str|
str.split(',', -1).each do |i|
arr[idx] = i.to_i unless i.empty?
idx += 1
end
end
racc_action_pointer = [
4691, 297, nil, nil, 4599, 284, nil, 145, nil, nil,
285, 4461, 4415, 4369, nil, nil, nil, nil, nil, nil,
nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
nil, nil, nil, nil, nil, 263, 200, 242, 4231, 4185,
4139, 4093, 85, 219, 118, 120, nil, 3909, 202, nil,
nil, nil, 3814, nil, nil, nil, nil, nil, nil, nil,
251, 3676, 238, 3259, 3213, 3167, 3121, 2891, 2474, 3538,
86, 26, 1692, 1738, 1784, 1830, 1876, 1922, 1968, 2014,
2060, 2106, 2152, 2198, 2244, 2290, 2336, 2382, 2428, 1505,
164, 2566, 174, 2661, 2707, 196, 64, 170, 1468, 2937,
nil, 253, -28, 3075, 1409, nil, 1350, 1291, 1232, 3305,
21, nil, nil, nil, 67, -11, nil, nil, nil, nil,
nil, 1173, 138, nil, 161, nil, nil, 219, 1114, nil,
26, nil, 236, nil, nil, nil, nil, nil, -5, 13,
nil, nil, nil, nil, 878, 795, 250, 77, 18, 594,
570, 528, 445, 421, 377, 353, 309, 226, 169, 112,
53, -6, nil, nil, 3722, nil, 653, 4047, 4001, 3860,
255, 255, nil, nil, 7, nil, -7, 22, 119, 109,
113, 53, 24, nil, nil, nil, nil, nil, nil, 4785,
996, 218, nil, 238, nil, 246, 189, nil, 3768, nil,
227, nil, 216, -9, nil, 4737, 3630, 3584, 1551, 176,
127, nil, 27, 143, 109, 24, nil, 53, 3446, nil,
nil, 197, 3397, nil, nil, nil, nil, 3351, nil, 3029,
2983, 2, nil, 4764, nil, 81, 2845, 102, 4806, 2799,
2753, 168, nil, nil, nil, nil, nil, nil, nil, nil,
nil, nil, nil, nil, 2615, 158, nil, 175, nil, 126,
167, 2520, nil, 203, 101, 211, 196, 74, 1646, nil,
193, 222, 228, 230, nil, 107, nil, 234, 1600, 3492,
nil, nil, 1055, nil, nil, nil, 937, nil, 854, 250,
3955, -4, nil, nil, nil, nil, 771, 712, 255, 197,
nil, nil, nil, 504, 146, nil, 4277, 264, 243, nil,
267, 268, nil, nil, nil, 268, 275, nil, 4323, nil,
nil, nil, 263, 280, nil, 281, nil, nil, nil, nil,
nil, nil, nil, nil, 4507, nil, 4553, 4645, nil, nil,
289, nil, nil, nil, nil, 296, nil, 298, nil, 308,
nil, nil, nil, nil, nil ]
racc_action_default = [
-203, -204, -1, -2, -3, -4, -7, -9, -10, -15,
-103, -204, -204, -204, -43, -44, -45, -46, -47, -48,
-49, -50, -51, -52, -53, -54, -55, -56, -57, -58,
-59, -60, -61, -62, -63, -68, -69, -73, -204, -204,
-204, -204, -204, -113, -204, -204, -158, -204, -204, -168,
-169, -170, -204, -172, -179, -180, -181, -182, -183, -184,
-204, -204, -6, -204, -204, -204, -204, -204, -204, -204,
-204, -204, -204, -204, -204, -204, -204, -204, -204, -204,
-204, -204, -204, -204, -204, -204, -204, -204, -204, -204,
-204, -121, -116, -203, -203, -27, -204, -34, -204, -204,
-70, -204, -204, -204, -204, -80, -204, -204, -204, -204,
-203, -147, -148, -114, -203, -203, -139, -141, -142, -143,
-144, -41, -204, -161, -204, -164, -165, -204, -176, -171,
-204, 355, -5, -8, -11, -12, -13, -14, -204, -17,
-18, -156, -157, -19, -20, -21, -22, -23, -24, -25,
-26, -28, -29, -30, -31, -32, -33, -35, -36, -37,
-38, -204, -39, -98, -204, -74, -204, -196, -202, -190,
-187, -185, -111, -122, -179, -125, -183, -204, -193, -191,
-199, -181, -182, -189, -194, -195, -197, -198, -200, -121,
-120, -204, -119, -204, -40, -185, -65, -75, -204, -78,
-185, -152, -155, -204, -72, -204, -204, -204, -121, -187,
-203, -149, -204, -204, -204, -204, -145, -204, -204, -159,
-162, -204, -204, -173, -174, -175, -177, -204, -16, -204,
-204, -185, -100, -121, -110, -204, -188, -204, -186, -204,
-204, -185, -124, -126, -190, -191, -192, -193, -196, -199,
-201, -202, -117, -118, -186, -204, -67, -204, -77, -204,
-186, -204, -71, -204, -83, -204, -89, -204, -204, -93,
-187, -185, -204, -204, -133, -204, -150, -185, -204, -204,
-140, -146, -42, -160, -163, -166, -167, -178, -102, -204,
-186, -185, -106, -112, -107, -123, -127, -128, -204, -64,
-76, -79, -153, -154, -83, -82, -204, -204, -89, -88,
-204, -204, -97, -92, -94, -204, -204, -108, -204, -134,
-135, -136, -204, -204, -130, -204, -138, -99, -101, -109,
-115, -66, -81, -84, -204, -87, -204, -204, -104, -105,
-204, -132, -151, -129, -137, -204, -86, -204, -91, -204,
-96, -131, -85, -90, -95 ]
racc_goto_table = [
2, 3, 100, 95, 97, 98, 114, 163, 129, 126,
170, 171, 127, 200, 118, 305, 309, 120, 235, 210,
280, 311, 281, 213, 237, 231, 269, 293, 209, 233,
104, 106, 107, 108, 142, 142, 62, 140, 143, 121,
191, 193, 141, 141, 128, 268, 295, 333, 255, 134,
135, 136, 137, 259, 197, 332, 273, 272, 335, 319,
121, 139, 214, 162, 144, 145, 146, 147, 148, 149,
150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
160, 161, 232, 166, 289, 190, 190, 314, 302, 122,
124, 121, 133, 132, 298, 121, 1, 226, 227, 225,
nil, 166, nil, nil, nil, nil, nil, nil, nil, 241,
138, 211, nil, nil, nil, 211, 216, nil, 315, nil,
nil, nil, nil, 277, 316, nil, nil, 270, 271, nil,
322, nil, nil, nil, nil, nil, nil, nil, nil, nil,
114, 195, nil, nil, 329, 203, nil, nil, nil, 118,
nil, nil, 120, 291, nil, nil, 161, nil, nil, 104,
106, 107, 256, nil, nil, nil, nil, nil, nil, nil,
nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
nil, nil, 285, 287, 118, 127, 118, 120, nil, 120,
nil, nil, nil, nil, nil, nil, nil, nil, 257, 121,
166, nil, nil, nil, nil, 263, 265, nil, 328, nil,
282, 274, nil, nil, 286, nil, nil, nil, nil, 128,
nil, 282, 288, nil, nil, nil, nil, nil, 166, nil,
nil, 296, 297, nil, nil, nil, nil, 320, nil, nil,
nil, nil, nil, nil, nil, nil, 282, nil, nil, nil,
nil, nil, nil, 303, nil, nil, nil, nil, nil, nil,
121, nil, nil, nil, nil, 331, nil, nil, nil, nil,
nil, nil, nil, nil, nil, nil, nil, nil, 323, 325,
nil, nil, 161, nil, nil, nil, nil, nil, nil, nil,
nil, nil, nil, nil, nil, nil, nil, nil, 104, nil,
nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
nil, nil, nil, nil, nil, nil, nil, nil, 340, nil,
nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
nil, nil, nil, nil, 345, nil, 347, 349 ]
racc_goto_check = [
2, 3, 37, 9, 9, 9, 62, 49, 75, 71,
52, 54, 31, 42, 35, 44, 45, 30, 53, 63,
68, 48, 68, 63, 36, 50, 47, 55, 52, 56,
9, 9, 9, 9, 31, 31, 5, 12, 12, 9,
58, 58, 30, 30, 9, 46, 59, 43, 36, 7,
7, 7, 7, 36, 41, 44, 64, 53, 45, 65,
9, 9, 67, 13, 9, 9, 9, 9, 9, 9,
9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
9, 9, 49, 9, 36, 9, 9, 47, 69, 11,
70, 9, 6, 5, 36, 9, 1, 76, 77, 79,
nil, 9, nil, nil, nil, nil, nil, nil, nil, 54,
11, 3, nil, nil, nil, 3, 3, nil, 53, nil,
nil, nil, nil, 42, 36, nil, nil, 52, 54, nil,
36, nil, nil, nil, nil, nil, nil, nil, nil, nil,
62, 11, nil, nil, 36, 11, nil, nil, nil, 35,
nil, nil, 30, 54, nil, nil, 9, nil, nil, 9,
9, 9, 37, nil, nil, nil, nil, nil, nil, nil,
nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
nil, nil, 71, 75, 35, 31, 35, 30, nil, 30,
nil, nil, nil, nil, nil, nil, nil, nil, 2, 9,
9, nil, nil, nil, nil, 2, 2, nil, 49, nil,
9, 3, nil, nil, 9, nil, nil, nil, nil, 9,
nil, 9, 9, nil, nil, nil, nil, nil, 9, nil,
nil, 9, 9, nil, nil, nil, nil, 62, nil, nil,
nil, nil, nil, nil, nil, nil, 9, nil, nil, nil,
nil, nil, nil, 9, nil, nil, nil, nil, nil, nil,
9, nil, nil, nil, nil, 37, nil, nil, nil, nil,
nil, nil, nil, nil, nil, nil, nil, nil, 2, 2,
nil, nil, 9, nil, nil, nil, nil, nil, nil, nil,
nil, nil, nil, nil, nil, nil, nil, nil, 9, nil,
nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
nil, nil, nil, nil, nil, nil, nil, nil, 2, nil,
nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
nil, nil, nil, nil, 2, nil, 2, 2 ]
racc_goto_pointer = [
nil, 96, 0, 1, nil, 32, 29, -15, nil, -8,
nil, 42, -33, -26, nil, nil, nil, nil, nil, nil,
nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-28, -36, nil, nil, nil, -31, -147, -34, nil, nil,
nil, -47, -89, -259, -249, -250, -162, -181, -246, -82,
-139, nil, -81, -152, -80, -209, -137, nil, -53, -192,
nil, nil, -38, -91, -154, -216, nil, -53, -195, -172,
42, -39, nil, nil, nil, -44, -33, -32, nil, -31 ]
racc_goto_default = [
nil, nil, nil, 192, 4, 5, 6, 7, 8, 10,
9, 267, nil, nil, 14, 35, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
29, 30, 31, 32, 33, 34, nil, nil, 36, 37,
101, nil, nil, 105, nil, nil, nil, nil, nil, nil,
nil, 41, nil, nil, nil, 172, nil, 92, nil, 173,
177, 175, 110, nil, nil, nil, 115, nil, 116, 201,
nil, nil, 49, 50, 52, nil, nil, nil, 130, nil ]
racc_reduce_table = [
0, 0, :racc_error,
1, 77, :_reduce_1,
1, 77, :_reduce_none,
1, 78, :_reduce_3,
1, 80, :_reduce_4,
3, 80, :_reduce_5,
2, 80, :_reduce_6,
1, 81, :_reduce_7,
3, 81, :_reduce_8,
1, 82, :_reduce_none,
1, 83, :_reduce_10,
3, 83, :_reduce_11,
3, 83, :_reduce_12,
3, 83, :_reduce_13,
3, 83, :_reduce_14,
1, 85, :_reduce_none,
4, 85, :_reduce_16,
3, 85, :_reduce_17,
3, 85, :_reduce_18,
3, 85, :_reduce_19,
3, 85, :_reduce_20,
3, 85, :_reduce_21,
3, 85, :_reduce_22,
3, 85, :_reduce_23,
3, 85, :_reduce_24,
3, 85, :_reduce_25,
3, 85, :_reduce_26,
2, 85, :_reduce_27,
3, 85, :_reduce_28,
3, 85, :_reduce_29,
3, 85, :_reduce_30,
3, 85, :_reduce_31,
3, 85, :_reduce_32,
3, 85, :_reduce_33,
2, 85, :_reduce_34,
3, 85, :_reduce_35,
3, 85, :_reduce_36,
3, 85, :_reduce_37,
3, 85, :_reduce_38,
3, 85, :_reduce_39,
3, 85, :_reduce_40,
1, 87, :_reduce_41,
3, 87, :_reduce_42,
1, 86, :_reduce_none,
1, 91, :_reduce_none,
1, 91, :_reduce_none,
1, 91, :_reduce_none,
1, 91, :_reduce_none,
1, 91, :_reduce_none,
1, 91, :_reduce_none,
1, 91, :_reduce_none,
1, 91, :_reduce_none,
1, 91, :_reduce_none,
1, 91, :_reduce_none,
1, 92, :_reduce_none,
1, 92, :_reduce_none,
1, 92, :_reduce_none,
1, 92, :_reduce_none,
1, 92, :_reduce_none,
1, 92, :_reduce_none,
1, 92, :_reduce_none,
1, 92, :_reduce_none,
1, 107, :_reduce_62,
1, 107, :_reduce_63,
5, 90, :_reduce_64,
3, 90, :_reduce_65,
6, 90, :_reduce_66,
4, 90, :_reduce_67,
1, 90, :_reduce_68,
1, 94, :_reduce_69,
2, 94, :_reduce_70,
4, 114, :_reduce_71,
3, 114, :_reduce_72,
1, 114, :_reduce_73,
3, 115, :_reduce_74,
2, 113, :_reduce_75,
3, 117, :_reduce_76,
2, 117, :_reduce_77,
2, 116, :_reduce_78,
4, 116, :_reduce_79,
2, 97, :_reduce_80,
5, 119, :_reduce_81,
4, 119, :_reduce_82,
0, 120, :_reduce_none,
2, 120, :_reduce_84,
4, 120, :_reduce_85,
3, 120, :_reduce_86,
6, 98, :_reduce_87,
5, 98, :_reduce_88,
0, 121, :_reduce_none,
4, 121, :_reduce_90,
3, 121, :_reduce_91,
5, 96, :_reduce_92,
1, 122, :_reduce_93,
2, 122, :_reduce_94,
5, 123, :_reduce_95,
4, 123, :_reduce_96,
1, 124, :_reduce_97,
1, 89, :_reduce_none,
4, 89, :_reduce_99,
1, 126, :_reduce_100,
3, 126, :_reduce_101,
3, 125, :_reduce_102,
1, 84, :_reduce_103,
6, 84, :_reduce_104,
6, 84, :_reduce_105,
5, 84, :_reduce_106,
5, 84, :_reduce_107,
5, 84, :_reduce_108,
4, 131, :_reduce_109,
1, 132, :_reduce_110,
1, 128, :_reduce_111,
3, 128, :_reduce_112,
1, 127, :_reduce_113,
2, 127, :_reduce_114,
6, 95, :_reduce_115,
2, 95, :_reduce_116,
3, 133, :_reduce_117,
3, 133, :_reduce_118,
1, 134, :_reduce_none,
1, 134, :_reduce_none,
0, 130, :_reduce_121,
1, 130, :_reduce_122,
3, 130, :_reduce_123,
1, 136, :_reduce_none,
1, 136, :_reduce_none,
1, 136, :_reduce_none,
3, 135, :_reduce_127,
3, 135, :_reduce_128,
6, 99, :_reduce_129,
5, 99, :_reduce_130,
7, 100, :_reduce_131,
6, 100, :_reduce_132,
1, 140, :_reduce_none,
2, 140, :_reduce_134,
1, 141, :_reduce_none,
1, 141, :_reduce_none,
6, 101, :_reduce_137,
5, 101, :_reduce_138,
1, 142, :_reduce_139,
3, 142, :_reduce_140,
1, 144, :_reduce_141,
1, 144, :_reduce_142,
1, 144, :_reduce_143,
1, 144, :_reduce_none,
1, 143, :_reduce_none,
2, 143, :_reduce_146,
1, 138, :_reduce_147,
1, 138, :_reduce_148,
1, 139, :_reduce_149,
2, 139, :_reduce_150,
4, 139, :_reduce_151,
1, 118, :_reduce_152,
3, 118, :_reduce_153,
3, 145, :_reduce_154,
1, 145, :_reduce_155,
1, 88, :_reduce_none,
1, 88, :_reduce_none,
1, 93, :_reduce_158,
3, 102, :_reduce_159,
4, 102, :_reduce_160,
2, 102, :_reduce_161,
3, 105, :_reduce_162,
4, 105, :_reduce_163,
2, 105, :_reduce_164,
1, 146, :_reduce_165,
3, 146, :_reduce_166,
3, 147, :_reduce_167,
1, 111, :_reduce_none,
1, 111, :_reduce_none,
1, 148, :_reduce_170,
2, 149, :_reduce_171,
1, 150, :_reduce_172,
1, 152, :_reduce_173,
1, 153, :_reduce_174,
2, 151, :_reduce_175,
1, 154, :_reduce_176,
1, 155, :_reduce_177,
2, 155, :_reduce_178,
1, 110, :_reduce_179,
1, 108, :_reduce_180,
1, 109, :_reduce_181,
1, 104, :_reduce_182,
1, 103, :_reduce_183,
1, 106, :_reduce_184,
0, 112, :_reduce_none,
1, 112, :_reduce_186,
0, 129, :_reduce_none,
1, 129, :_reduce_none,
1, 137, :_reduce_none,
1, 137, :_reduce_none,
1, 137, :_reduce_none,
1, 137, :_reduce_none,
1, 137, :_reduce_none,
1, 137, :_reduce_none,
1, 137, :_reduce_none,
1, 137, :_reduce_none,
1, 137, :_reduce_none,
1, 137, :_reduce_none,
1, 137, :_reduce_none,
1, 137, :_reduce_none,
1, 137, :_reduce_none,
1, 137, :_reduce_none,
0, 79, :_reduce_203 ]
racc_reduce_n = 204
racc_shift_n = 355
racc_token_table = {
false => 0,
:error => 1,
:STRING => 2,
:DQPRE => 3,
:DQMID => 4,
:DQPOST => 5,
:LBRACK => 6,
:RBRACK => 7,
:LBRACE => 8,
:RBRACE => 9,
:SYMBOL => 10,
:FARROW => 11,
:COMMA => 12,
:TRUE => 13,
:FALSE => 14,
:EQUALS => 15,
:APPENDS => 16,
:LESSEQUAL => 17,
:NOTEQUAL => 18,
:DOT => 19,
:COLON => 20,
:LLCOLLECT => 21,
:RRCOLLECT => 22,
:QMARK => 23,
:LPAREN => 24,
:RPAREN => 25,
:ISEQUAL => 26,
:GREATEREQUAL => 27,
:GREATERTHAN => 28,
:LESSTHAN => 29,
:IF => 30,
:ELSE => 31,
:DEFINE => 32,
:ELSIF => 33,
:VARIABLE => 34,
:CLASS => 35,
:INHERITS => 36,
:NODE => 37,
:BOOLEAN => 38,
:NAME => 39,
:SEMIC => 40,
:CASE => 41,
:DEFAULT => 42,
:AT => 43,
:LCOLLECT => 44,
:RCOLLECT => 45,
:CLASSREF => 46,
:NOT => 47,
:OR => 48,
:AND => 49,
:UNDEF => 50,
:PARROW => 51,
:PLUS => 52,
:MINUS => 53,
:TIMES => 54,
:DIV => 55,
:LSHIFT => 56,
:RSHIFT => 57,
:UMINUS => 58,
:MATCH => 59,
:NOMATCH => 60,
:REGEX => 61,
:IN_EDGE => 62,
:OUT_EDGE => 63,
:IN_EDGE_SUB => 64,
:OUT_EDGE_SUB => 65,
:IN => 66,
:UNLESS => 67,
:PIPE => 68,
:SELBRACE => 69,
:LOW => 70,
:HIGH => 71,
:CALL => 72,
:MODULO => 73,
:TITLE_COLON => 74,
:CASE_COLON => 75 }
racc_nt_base = 76
racc_use_result_var = true
Racc_arg = [
racc_action_table,
racc_action_check,
racc_action_default,
racc_action_pointer,
racc_goto_table,
racc_goto_check,
racc_goto_default,
racc_goto_pointer,
racc_nt_base,
racc_reduce_table,
racc_token_table,
racc_shift_n,
racc_reduce_n,
racc_use_result_var ]
Racc_token_to_s_table = [
"$end",
"error",
"STRING",
"DQPRE",
"DQMID",
"DQPOST",
"LBRACK",
"RBRACK",
"LBRACE",
"RBRACE",
"SYMBOL",
"FARROW",
"COMMA",
"TRUE",
"FALSE",
"EQUALS",
"APPENDS",
"LESSEQUAL",
"NOTEQUAL",
"DOT",
"COLON",
"LLCOLLECT",
"RRCOLLECT",
"QMARK",
"LPAREN",
"RPAREN",
"ISEQUAL",
"GREATEREQUAL",
"GREATERTHAN",
"LESSTHAN",
"IF",
"ELSE",
"DEFINE",
"ELSIF",
"VARIABLE",
"CLASS",
"INHERITS",
"NODE",
"BOOLEAN",
"NAME",
"SEMIC",
"CASE",
"DEFAULT",
"AT",
"LCOLLECT",
"RCOLLECT",
"CLASSREF",
"NOT",
"OR",
"AND",
"UNDEF",
"PARROW",
"PLUS",
"MINUS",
"TIMES",
"DIV",
"LSHIFT",
"RSHIFT",
"UMINUS",
"MATCH",
"NOMATCH",
"REGEX",
"IN_EDGE",
"OUT_EDGE",
"IN_EDGE_SUB",
"OUT_EDGE_SUB",
"IN",
"UNLESS",
"PIPE",
"SELBRACE",
"LOW",
"HIGH",
"CALL",
"MODULO",
"TITLE_COLON",
"CASE_COLON",
"$start",
"program",
"statements",
"nil",
"syntactic_statements",
"syntactic_statement",
"any_expression",
"relationship_expression",
"resource_expression",
"expression",
"higher_precedence",
"expressions",
"match_rvalue",
"selector_entries",
"call_function_expression",
"primary_expression",
"literal_expression",
"variable",
"call_method_with_lambda_expression",
"collection_expression",
"case_expression",
"if_expression",
"unless_expression",
"definition_expression",
"hostclass_expression",
"node_definition_expression",
"array",
"boolean",
"default",
"hash",
"regex",
"text_or_name",
"type",
"undef",
"name",
"quotedtext",
"endcomma",
"lambda",
"call_method_expression",
"named_access",
"lambda_parameter_list",
"lambda_rest",
"parameters",
"if_part",
"else",
"unless_else",
"case_options",
"case_option",
"case_colon",
"selector_entry",
"selector_entry_list",
"at",
"resourceinstances",
"endsemi",
"attribute_operations",
"resourceinst",
"title_colon",
"collect_query",
"optional_query",
"attribute_operation",
"attribute_name",
"keyword",
"classname",
"parameter_list",
"classparent",
"classnameordefault",
"hostnames",
"nodeparent",
"hostname",
"parameter",
"hashpairs",
"hashpair",
"string",
"dq_string",
"dqpre",
"dqrval",
"dqpost",
"dqmid",
"text_expression",
"dqtail" ]
Racc_debug_parser = false
##### State transition tables end #####
# reduce 0 omitted
module_eval(<<'.,.,', 'egrammar.ra', 57)
def _reduce_1(val, _values, result)
result = Factory.block_or_expression(*val[0])
result
end
.,.,
# reduce 2 omitted
module_eval(<<'.,.,', 'egrammar.ra', 62)
def _reduce_3(val, _values, result)
result = transform_calls(val[0])
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 68)
def _reduce_4(val, _values, result)
result = [val[0]]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 69)
def _reduce_5(val, _values, result)
result = val[0].push val[2]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 70)
def _reduce_6(val, _values, result)
result = val[0].push val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 74)
def _reduce_7(val, _values, result)
result = val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 75)
def _reduce_8(val, _values, result)
result = aryfy(val[0]).push val[2]
result
end
.,.,
# reduce 9 omitted
module_eval(<<'.,.,', 'egrammar.ra', 81)
def _reduce_10(val, _values, result)
result = val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 82)
def _reduce_11(val, _values, result)
result = val[0].relop(val[1][:value], val[2]); loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 83)
def _reduce_12(val, _values, result)
result = val[0].relop(val[1][:value], val[2]); loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 84)
def _reduce_13(val, _values, result)
result = val[0].relop(val[1][:value], val[2]); loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 85)
def _reduce_14(val, _values, result)
result = val[0].relop(val[1][:value], val[2]); loc result, val[1]
result
end
.,.,
# reduce 15 omitted
module_eval(<<'.,.,', 'egrammar.ra', 92)
def _reduce_16(val, _values, result)
result = val[0][*val[2]] ; loc result, val[0], val[3]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 93)
def _reduce_17(val, _values, result)
result = val[0].in val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 94)
def _reduce_18(val, _values, result)
result = val[0] =~ val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 95)
def _reduce_19(val, _values, result)
result = val[0].mne val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 96)
def _reduce_20(val, _values, result)
result = val[0] + val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 97)
def _reduce_21(val, _values, result)
result = val[0] - val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 98)
def _reduce_22(val, _values, result)
result = val[0] / val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 99)
def _reduce_23(val, _values, result)
result = val[0] * val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 100)
def _reduce_24(val, _values, result)
result = val[0] % val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 101)
def _reduce_25(val, _values, result)
result = val[0] << val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 102)
def _reduce_26(val, _values, result)
result = val[0] >> val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 103)
def _reduce_27(val, _values, result)
result = val[1].minus() ; loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 104)
def _reduce_28(val, _values, result)
result = val[0].ne val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 105)
def _reduce_29(val, _values, result)
result = val[0] == val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 106)
def _reduce_30(val, _values, result)
result = val[0] > val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 107)
def _reduce_31(val, _values, result)
result = val[0] >= val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 108)
def _reduce_32(val, _values, result)
result = val[0] < val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 109)
def _reduce_33(val, _values, result)
result = val[0] <= val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 110)
def _reduce_34(val, _values, result)
result = val[1].not ; loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 111)
def _reduce_35(val, _values, result)
result = val[0].and val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 112)
def _reduce_36(val, _values, result)
result = val[0].or val[2] ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 113)
def _reduce_37(val, _values, result)
result = val[0].set(val[2]) ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 114)
def _reduce_38(val, _values, result)
result = val[0].plus_set(val[2]) ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 115)
def _reduce_39(val, _values, result)
result = val[0].select(*val[2]) ; loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 116)
def _reduce_40(val, _values, result)
result = val[1].paren() ; loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 124)
def _reduce_41(val, _values, result)
result = [val[0]]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 125)
def _reduce_42(val, _values, result)
result = val[0].push(val[2])
result
end
.,.,
# reduce 43 omitted
# reduce 44 omitted
# reduce 45 omitted
# reduce 46 omitted
# reduce 47 omitted
# reduce 48 omitted
# reduce 49 omitted
# reduce 50 omitted
# reduce 51 omitted
# reduce 52 omitted
# reduce 53 omitted
# reduce 54 omitted
# reduce 55 omitted
# reduce 56 omitted
# reduce 57 omitted
# reduce 58 omitted
# reduce 59 omitted
# reduce 60 omitted
# reduce 61 omitted
module_eval(<<'.,.,', 'egrammar.ra', 155)
def _reduce_62(val, _values, result)
result = val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 156)
def _reduce_63(val, _values, result)
result = val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 164)
def _reduce_64(val, _values, result)
result = Factory.CALL_NAMED(val[0], true, val[2])
loc result, val[0], val[4]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 168)
def _reduce_65(val, _values, result)
result = Factory.CALL_NAMED(val[0], true, [])
loc result, val[0], val[2]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 172)
def _reduce_66(val, _values, result)
result = Factory.CALL_NAMED(val[0], true, val[2])
loc result, val[0], val[4]
result.lambda = val[5]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 177)
def _reduce_67(val, _values, result)
result = Factory.CALL_NAMED(val[0], true, [])
loc result, val[0], val[2]
result.lambda = val[3]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 181)
def _reduce_68(val, _values, result)
result = val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 186)
def _reduce_69(val, _values, result)
result = val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 187)
def _reduce_70(val, _values, result)
result = val[0]; val[0].lambda = val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 190)
def _reduce_71(val, _values, result)
result = Factory.CALL_METHOD(val[0], val[2]); loc result, val[1], val[3]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 191)
def _reduce_72(val, _values, result)
result = Factory.CALL_METHOD(val[0], []); loc result, val[1], val[3]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 192)
def _reduce_73(val, _values, result)
result = Factory.CALL_METHOD(val[0], []); loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 197)
def _reduce_74(val, _values, result)
result = val[0].dot(Factory.fqn(val[2][:value]))
loc result, val[1], val[2]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 209)
def _reduce_75(val, _values, result)
result = Factory.LAMBDA(val[0], val[1])
# loc result, val[1] # TODO
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 214)
def _reduce_76(val, _values, result)
result = val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 215)
def _reduce_77(val, _values, result)
result = nil
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 219)
def _reduce_78(val, _values, result)
result = []
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 220)
def _reduce_79(val, _values, result)
result = val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 230)
def _reduce_80(val, _values, result)
result = val[1]
loc(result, val[0], val[1])
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 237)
def _reduce_81(val, _values, result)
result = Factory.IF(val[0], Factory.block_or_expression(*val[2]), val[4])
loc(result, val[0], (val[4] ? val[4] : val[3]))
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 241)
def _reduce_82(val, _values, result)
result = Factory.IF(val[0], nil, val[3])
loc(result, val[0], (val[3] ? val[3] : val[2]))
result
end
.,.,
# reduce 83 omitted
module_eval(<<'.,.,', 'egrammar.ra', 249)
def _reduce_84(val, _values, result)
result = val[1]
loc(result, val[0], val[1])
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 253)
def _reduce_85(val, _values, result)
result = Factory.block_or_expression(*val[2])
loc result, val[0], val[3]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 257)
def _reduce_86(val, _values, result)
result = nil # don't think a nop is needed here either
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 266)
def _reduce_87(val, _values, result)
result = Factory.UNLESS(val[1], Factory.block_or_expression(*val[3]), val[5])
loc result, val[0], val[4]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 270)
def _reduce_88(val, _values, result)
result = Factory.UNLESS(val[1], nil, nil)
loc result, val[0], val[4]
result
end
.,.,
# reduce 89 omitted
module_eval(<<'.,.,', 'egrammar.ra', 280)
def _reduce_90(val, _values, result)
result = Factory.block_or_expression(*val[2])
loc result, val[0], val[3]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 284)
def _reduce_91(val, _values, result)
result = nil # don't think a nop is needed here either
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 292)
def _reduce_92(val, _values, result)
result = Factory.CASE(val[1], *val[3])
loc result, val[0], val[4]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 298)
def _reduce_93(val, _values, result)
result = [val[0]]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 299)
def _reduce_94(val, _values, result)
result = val[0].push val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 304)
def _reduce_95(val, _values, result)
result = Factory.WHEN(val[0], val[3])
loc result, val[1], val[4]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 308)
def _reduce_96(val, _values, result)
result = Factory.WHEN(val[0], nil)
loc result, val[1], val[3]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 312)
def _reduce_97(val, _values, result)
result = val[0]
result
end
.,.,
# reduce 98 omitted
module_eval(<<'.,.,', 'egrammar.ra', 323)
def _reduce_99(val, _values, result)
result = val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 328)
def _reduce_100(val, _values, result)
result = [val[0]]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 329)
def _reduce_101(val, _values, result)
result = val[0].push val[2]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 334)
def _reduce_102(val, _values, result)
result = Factory.MAP(val[0], val[2]) ; loc result, val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 350)
def _reduce_103(val, _values, result)
result = val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 353)
def _reduce_104(val, _values, result)
result = case Factory.resource_shape(val[1])
when :resource, :class
tmp = Factory.RESOURCE(Factory.fqn(token_text(val[1])), val[3])
tmp.form = val[0]
tmp
when :defaults
error "A resource default can not be virtual or exported"
when :override
error "A resource override can not be virtual or exported"
else
error "Expression is not valid as a resource, resource-default, or resource-override"
end
loc result, val[1], val[4]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 368)
def _reduce_105(val, _values, result)
result = case Factory.resource_shape(val[1])
when :resource, :class
error "Defaults are not virtualizable"
when :defaults
error "Defaults are not virtualizable"
when :override
error "Defaults are not virtualizable"
else
error "Expression is not valid as a resource, resource-default, or resource-override"
end
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 380)
def _reduce_106(val, _values, result)
result = case Factory.resource_shape(val[0])
when :resource, :class
Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
when :defaults
error "A resource default can not specify a resource name"
when :override
error "A resource override does not allow override of name of resource"
else
error "Expression is not valid as a resource, resource-default, or resource-override"
end
loc result, val[0], val[4]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 393)
def _reduce_107(val, _values, result)
result = case Factory.resource_shape(val[0])
when :resource, :class
# This catches deprecated syntax.
error "All resource specifications require names"
when :defaults
Factory.RESOURCE_DEFAULTS(val[0], val[2])
when :override
# This was only done for override in original - TODO shuld it be here at all
Factory.RESOURCE_OVERRIDE(val[0], val[2])
else
error "Expression is not valid as a resource, resource-default, or resource-override"
end
loc result, val[0], val[4]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 408)
def _reduce_108(val, _values, result)
result = Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
loc result, val[0], val[4]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 413)
def _reduce_109(val, _values, result)
result = Factory.RESOURCE_BODY(val[0], val[2])
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 415)
def _reduce_110(val, _values, result)
result = val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 418)
def _reduce_111(val, _values, result)
result = [val[0]]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 419)
def _reduce_112(val, _values, result)
result = val[0].push val[2]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 424)
def _reduce_113(val, _values, result)
result = :virtual
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 425)
def _reduce_114(val, _values, result)
result = :exported
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 437)
def _reduce_115(val, _values, result)
result = Factory.COLLECT(val[0], val[1], val[3])
loc result, val[0], val[5]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 441)
def _reduce_116(val, _values, result)
result = Factory.COLLECT(val[0], val[1], [])
loc result, val[0], val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 446)
def _reduce_117(val, _values, result)
result = Factory.VIRTUAL_QUERY(val[1]) ; loc result, val[0], val[2]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 447)
def _reduce_118(val, _values, result)
result = Factory.EXPORTED_QUERY(val[1]) ; loc result, val[0], val[2]
result
end
.,.,
# reduce 119 omitted
# reduce 120 omitted
module_eval(<<'.,.,', 'egrammar.ra', 460)
def _reduce_121(val, _values, result)
result = []
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 461)
def _reduce_122(val, _values, result)
result = [val[0]]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 462)
def _reduce_123(val, _values, result)
result = val[0].push(val[2])
result
end
.,.,
# reduce 124 omitted
# reduce 125 omitted
# reduce 126 omitted
module_eval(<<'.,.,', 'egrammar.ra', 478)
def _reduce_127(val, _values, result)
result = Factory.ATTRIBUTE_OP(val[0][:value], :'=>', val[2])
loc result, val[0], val[2]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 482)
def _reduce_128(val, _values, result)
result = Factory.ATTRIBUTE_OP(val[0][:value], :'+>', val[2])
loc result, val[0], val[2]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 492)
def _reduce_129(val, _values, result)
result = Factory.DEFINITION(classname(val[1][:value]), val[2], val[4])
loc result, val[0], val[5]
@lexer.indefine = false
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 497)
def _reduce_130(val, _values, result)
result = Factory.DEFINITION(classname(val[1][:value]), val[2], nil)
loc result, val[0], val[4]
@lexer.indefine = false
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 512)
def _reduce_131(val, _values, result)
@lexer.namepop
result = Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), val[5])
loc result, val[0], val[6]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 517)
def _reduce_132(val, _values, result)
@lexer.namepop
result = Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), nil)
loc result, val[0], val[5]
result
end
.,.,
# reduce 133 omitted
module_eval(<<'.,.,', 'egrammar.ra', 525)
def _reduce_134(val, _values, result)
result = val[1]
result
end
.,.,
# reduce 135 omitted
# reduce 136 omitted
module_eval(<<'.,.,', 'egrammar.ra', 542)
def _reduce_137(val, _values, result)
result = Factory.NODE(val[1], val[2], val[4])
loc result, val[0], val[5]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 546)
def _reduce_138(val, _values, result)
result = Factory.NODE(val[1], val[2], nil)
loc result, val[0], val[4]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 556)
def _reduce_139(val, _values, result)
result = [result]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 557)
def _reduce_140(val, _values, result)
result = val[0].push(val[2])
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 562)
def _reduce_141(val, _values, result)
result = Factory.fqn(val[0][:value]); loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 563)
def _reduce_142(val, _values, result)
result = val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 564)
def _reduce_143(val, _values, result)
result = Factory.literal(:default); loc result, val[0]
result
end
.,.,
# reduce 144 omitted
# reduce 145 omitted
module_eval(<<'.,.,', 'egrammar.ra', 570)
def _reduce_146(val, _values, result)
result = val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 575)
def _reduce_147(val, _values, result)
result = val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 576)
def _reduce_148(val, _values, result)
result = val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 580)
def _reduce_149(val, _values, result)
result = []
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 581)
def _reduce_150(val, _values, result)
result = []
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 582)
def _reduce_151(val, _values, result)
result = val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 586)
def _reduce_152(val, _values, result)
result = [val[0]]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 587)
def _reduce_153(val, _values, result)
result = val[0].push(val[2])
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 591)
def _reduce_154(val, _values, result)
result = Factory.PARAM(val[0][:value], val[2]) ; loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 592)
def _reduce_155(val, _values, result)
result = Factory.PARAM(val[0][:value]); loc result, val[0]
result
end
.,.,
# reduce 156 omitted
# reduce 157 omitted
module_eval(<<'.,.,', 'egrammar.ra', 605)
def _reduce_158(val, _values, result)
result = Factory.fqn(val[0][:value]).var ; loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 611)
def _reduce_159(val, _values, result)
result = Factory.LIST(val[1]); loc result, val[0], val[2]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 612)
def _reduce_160(val, _values, result)
result = Factory.LIST(val[1]); loc result, val[0], val[3]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 613)
def _reduce_161(val, _values, result)
result = Factory.literal([]) ; loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 616)
def _reduce_162(val, _values, result)
result = Factory.HASH(val[1]); loc result, val[0], val[2]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 617)
def _reduce_163(val, _values, result)
result = Factory.HASH(val[1]); loc result, val[0], val[3]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 618)
def _reduce_164(val, _values, result)
result = Factory.literal({}) ; loc result, val[0], val[3]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 621)
def _reduce_165(val, _values, result)
result = [val[0]]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 622)
def _reduce_166(val, _values, result)
result = val[0].push val[2]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 625)
def _reduce_167(val, _values, result)
result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1]
result
end
.,.,
# reduce 168 omitted
# reduce 169 omitted
module_eval(<<'.,.,', 'egrammar.ra', 631)
def _reduce_170(val, _values, result)
result = Factory.literal(val[0][:value]) ; loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 632)
def _reduce_171(val, _values, result)
result = Factory.string(val[0], *val[1]) ; loc result, val[0], val[1][-1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 633)
def _reduce_172(val, _values, result)
result = Factory.literal(val[0][:value]); loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 634)
def _reduce_173(val, _values, result)
result = Factory.literal(val[0][:value]); loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 635)
def _reduce_174(val, _values, result)
result = Factory.literal(val[0][:value]); loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 636)
def _reduce_175(val, _values, result)
result = [val[0]] + val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 637)
def _reduce_176(val, _values, result)
result = Factory.TEXT(val[0])
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 640)
def _reduce_177(val, _values, result)
result = [val[0]]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 641)
def _reduce_178(val, _values, result)
result = [val[0]] + val[1]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 643)
def _reduce_179(val, _values, result)
result = Factory.QNAME_OR_NUMBER(val[0][:value]) ; loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 644)
def _reduce_180(val, _values, result)
result = Factory.QREF(val[0][:value]) ; loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 645)
def _reduce_181(val, _values, result)
result = Factory.literal(:undef); loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 646)
def _reduce_182(val, _values, result)
result = Factory.literal(:default); loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 651)
def _reduce_183(val, _values, result)
result = Factory.literal(val[0][:value]) ; loc result, val[0]
result
end
.,.,
module_eval(<<'.,.,', 'egrammar.ra', 654)
def _reduce_184(val, _values, result)
result = Factory.literal(val[0][:value]); loc result, val[0]
result
end
.,.,
# reduce 185 omitted
module_eval(<<'.,.,', 'egrammar.ra', 660)
def _reduce_186(val, _values, result)
result = nil
result
end
.,.,
# reduce 187 omitted
# reduce 188 omitted
# reduce 189 omitted
# reduce 190 omitted
# reduce 191 omitted
# reduce 192 omitted
# reduce 193 omitted
# reduce 194 omitted
# reduce 195 omitted
# reduce 196 omitted
# reduce 197 omitted
# reduce 198 omitted
# reduce 199 omitted
# reduce 200 omitted
# reduce 201 omitted
# reduce 202 omitted
module_eval(<<'.,.,', 'egrammar.ra', 683)
def _reduce_203(val, _values, result)
result = nil
result
end
.,.,
def _reduce_none(val, _values, result)
val[0]
end
end # class Parser
end # module Parser
end # module Pops
end # module Puppet
puppet-3.4.3/lib/puppet/pops/parser/parser_support.rb 0000644 0052762 0001160 00000015001 12300765631 022703 0 ustar jenkins jenkins require 'puppet/parser/functions'
require 'puppet/parser/files'
require 'puppet/resource/type_collection'
require 'puppet/resource/type_collection_helper'
require 'puppet/resource/type'
require 'monitor'
# Supporting logic for the parser.
# This supporting logic has slightly different responsibilities compared to the original Puppet::Parser::Parser.
# It is only concerned with parsing.
#
class Puppet::Pops::Parser::Parser
# Note that the name of the contained class and the file name (currently parser_support.rb)
# needs to be different as the class is generated by Racc, and this file (parser_support.rb) is included as a mix in
#
# Simplify access to the Model factory
# Note that the parser/parser support does not have direct knowledge about the Model.
# All model construction/manipulation is made by the Factory.
#
Factory = Puppet::Pops::Model::Factory
Model = Puppet::Pops::Model
include Puppet::Resource::TypeCollectionHelper
attr_accessor :lexer
# Returns the token text of the given lexer token, or nil, if token is nil
def token_text t
return t if t.nil?
t = t.current if t.respond_to?(:current)
return t.value if t.is_a? Model::QualifiedName
# else it is a lexer token
t[:value]
end
# Produces the fully qualified name, with the full (current) namespace for a given name.
#
# This is needed because class bodies are lazily evaluated and an inner class' container(s) may not
# have been evaluated before some external reference is made to the inner class; its must therefore know its complete name
# before evaluation-time.
#
def classname(name)
[@lexer.namespace, name].join("::").sub(/^::/, '')
end
# Reinitializes variables (i.e. creates a new lexer instance
#
def clear
initvars
end
# Raises a Parse error.
def error(message, options = {})
except = Puppet::ParseError.new(message)
except.line = options[:line] || @lexer.line
except.file = options[:file] || @lexer.file
except.pos = options[:pos] || @lexer.pos
raise except
end
# Parses a file expected to contain pp DSL logic.
def parse_file(file)
unless Puppet::FileSystem::File.exist?(file)
unless file =~ /\.pp$/
file = file + ".pp"
end
end
@lexer.file = file
_parse()
end
def initialize()
# Since the parser is not responsible for importing (removed), and does not perform linking,
# and there is no syntax that requires knowing if something referenced exists, it is safe
# to assume that no environment is needed when parsing. (All that comes later).
#
initvars
end
# Initializes the parser support by creating a new instance of {Puppet::Pops::Parser::Lexer}
# @return [void]
#
def initvars
@lexer = Puppet::Pops::Parser::Lexer.new
end
# This is a callback from the generated grammar (when an error occurs while parsing)
# TODO Picks up origin information from the lexer, probably needs this from the caller instead
# (for code strings, and when start line is not line 1 in a code string (or file), etc.)
#
def on_error(token,value,stack)
if token == 0 # denotes end of file
value = 'end of file'
else
value = "'#{value[:value]}'"
end
error = "Syntax error at #{value}"
# The 'expected' is only of value at end of input, otherwise any parse error involving a
# start of a pair will be reported as expecting the close of the pair - e.g. "$x.each |$x {", would
# report that "seeing the '{', the '}' is expected. That would be wrong.
# Real "expected" tokens are very difficult to compute (would require parsing of racc output data). Output of the stack
# could help, but can require extensive backtracking and produce many options.
#
if token == 0 && brace = @lexer.expected
error += "; expected '#{brace}'"
end
except = Puppet::ParseError.new(error)
except.line = @lexer.line
except.file = @lexer.file if @lexer.file
except.pos = @lexer.pos
raise except
end
# Parses a String of pp DSL code.
# @todo make it possible to pass a given origin
#
def parse_string(code)
@lexer.string = code
_parse()
end
# Mark the factory wrapped model object with location information
# @todo the lexer produces :line for token, but no offset or length
# @return [Puppet::Pops::Model::Factory] the given factory
# @api private
#
def loc(factory, start_token, end_token = nil)
factory.record_position(sourcepos(start_token), sourcepos(end_token))
end
# Associate documentation with the factory wrapped model object.
# @return [Puppet::Pops::Model::Factory] the given factory
# @api private
def doc factory, doc_string
factory.doc = doc_string
end
def sourcepos(o)
if !o
Puppet::Pops::Adapters::SourcePosAdapter.new
elsif o.is_a? Puppet::Pops::Model::Factory
# It is a built model element with loc set returns start at pos 0
o.loc
else
loc = Puppet::Pops::Adapters::SourcePosAdapter.new
# It must be a token
loc.line = o[:line]
loc.pos = o[:pos]
loc.offset = o[:offset]
loc.length = o[:length]
loc
end
end
def aryfy(o)
o = [o] unless o.is_a?(Array)
o
end
# Transforms an array of expressions containing literal name expressions to calls if followed by an
# expression, or expression list
#
def transform_calls(expressions)
Factory.transform_calls(expressions)
end
# Performs the parsing and returns the resulting model.
# The lexer holds state, and this is setup with {#parse_string}, or {#parse_file}.
#
# TODO: Drop support for parsing a ruby file this way (should be done where it is decided
# which file to load/run (i.e. loaders), and initial file to run
# TODO: deal with options containing origin (i.e. parsing a string from externally known location).
# TODO: should return the model, not a Hostclass
#
# @api private
#
def _parse()
begin
@yydebug = false
main = yyparse(@lexer,:scan)
# #Commented out now because this hides problems in the racc grammar while developing
# # TODO include this when test coverage is good enough.
# rescue Puppet::ParseError => except
# except.line ||= @lexer.line
# except.file ||= @lexer.file
# except.pos ||= @lexer.pos
# raise except
# rescue => except
# raise Puppet::ParseError.new(except.message, @lexer.file, @lexer.line, @lexer.pos, except)
end
main.record_origin(@lexer.file) if main
return main
ensure
@lexer.clear
end
end
puppet-3.4.3/lib/puppet/pops/parser/lexer.rb 0000644 0052762 0001160 00000062523 12300765631 020745 0 ustar jenkins jenkins # the scanner/lexer
require 'forwardable'
require 'strscan'
require 'puppet'
require 'puppet/util/methodhelper'
module Puppet
class LexError < RuntimeError; end
end
class Puppet::Pops::Parser::Lexer
extend Forwardable
attr_reader :file, :lexing_context, :token_queue
attr_reader :locator
attr_accessor :indefine
alias :indefine? :indefine
def lex_error msg
raise Puppet::LexError.new(msg)
end
class Token
ALWAYS_ACCEPTABLE = Proc.new { |context| true }
include Puppet::Util::MethodHelper
attr_accessor :regex, :name, :string, :skip, :skip_text
alias skip? skip
# @overload initialize(string)
# @param string [String] a literal string token matcher
# @param name [String] the token name (what it is known as in the grammar)
# @param options [Hash] see {#set_options}
# @overload initialize(regex)
# @param regex [Regexp] a regular expression token text matcher
# @param name [String] the token name (what it is known as in the grammar)
# @param options [Hash] see {#set_options}
#
def initialize(string_or_regex, name, options = {})
if string_or_regex.is_a?(String)
@name, @string = name, string_or_regex
@regex = Regexp.new(Regexp.escape(string_or_regex))
else
@name, @regex = name, string_or_regex
end
set_options(options)
@acceptable_when = ALWAYS_ACCEPTABLE
end
# @return [String] human readable token reference; the String if literal, else the token name
def to_s
string or @name.to_s
end
# @return [Boolean] if the token is acceptable in the given context or not.
# this implementation always returns true.
# @param context [Hash] ? ? ?
#
def acceptable?(context={})
@acceptable_when.call(context)
end
# Defines when the token is able to match.
# This provides context that cannot be expressed otherwise, such as feature flags.
#
# @param block [Proc] a proc that given a context returns a boolean
def acceptable_when(block)
@acceptable_when = block
end
end
# Maintains a list of tokens.
class TokenList
extend Forwardable
attr_reader :regex_tokens, :string_tokens
def_delegator :@tokens, :[]
# Adds a new token to the set of recognized tokens
# @param name [String] the token name
# @param regex [Regexp, String] source text token matcher, a litral string or regular expression
# @param options [Hash] see {Token::set_options}
# @param block [Proc] optional block set as the created tokens `convert` method
# @raise [ArgumentError] if the token with the given name is already defined
#
def add_token(name, regex, options = {}, &block)
raise(ArgumentError, "Token #{name} already exists") if @tokens.include?(name)
token = Token.new(regex, name, options)
@tokens[token.name] = token
if token.string
@string_tokens << token
@tokens_by_string[token.string] = token
else
@regex_tokens << token
end
token.meta_def(:convert, &block) if block_given?
token
end
# Creates an empty token list
#
def initialize
@tokens = {}
@regex_tokens = []
@string_tokens = []
@tokens_by_string = {}
end
# Look up a token by its literal (match) value, rather than name.
# @param string [String, nil] the literal match string to obtain a {Token} for, or nil if it does not exist.
def lookup(string)
@tokens_by_string[string]
end
# Adds tokens from a hash where key is a matcher (literal string or regexp) and the
# value is the token's name
# @param hash [Hash<{String => Symbol}, Hash<{Regexp => Symbol}] map token text matcher to token name
# @return [void]
#
def add_tokens(hash)
hash.each do |regex, name|
add_token(name, regex)
end
end
# Sort literal (string-) tokens by length, so we know once we match, we're done.
# This helps avoid the O(n^2) nature of token matching.
# The tokens are sorted in place.
# @return [void]
def sort_tokens
@string_tokens.sort! { |a, b| b.string.length <=> a.string.length }
end
# Yield each token name and value in turn.
def each
@tokens.each {|name, value| yield name, value }
end
end
TOKENS = TokenList.new
TOKENS.add_tokens(
'[' => :LBRACK,
']' => :RBRACK,
# '{' => :LBRACE, # Specialized to handle lambda and brace count
# '}' => :RBRACE, # Specialized to handle brace count
'(' => :LPAREN,
')' => :RPAREN,
'=' => :EQUALS,
'+=' => :APPENDS,
'==' => :ISEQUAL,
'>=' => :GREATEREQUAL,
'>' => :GREATERTHAN,
'<' => :LESSTHAN,
'<=' => :LESSEQUAL,
'!=' => :NOTEQUAL,
'!' => :NOT,
',' => :COMMA,
'.' => :DOT,
':' => :COLON,
'@' => :AT,
'|' => :PIPE,
'<<|' => :LLCOLLECT,
'|>>' => :RRCOLLECT,
'->' => :IN_EDGE,
'<-' => :OUT_EDGE,
'~>' => :IN_EDGE_SUB,
'<~' => :OUT_EDGE_SUB,
'<|' => :LCOLLECT,
'|>' => :RCOLLECT,
';' => :SEMIC,
'?' => :QMARK,
'\\' => :BACKSLASH,
'=>' => :FARROW,
'+>' => :PARROW,
'+' => :PLUS,
'-' => :MINUS,
'/' => :DIV,
'*' => :TIMES,
'%' => :MODULO,
'<<' => :LSHIFT,
'>>' => :RSHIFT,
'=~' => :MATCH,
'!~' => :NOMATCH,
%r{((::){0,1}[A-Z][-\w]*)+} => :CLASSREF,
"" => :STRING,
"" => :DQPRE,
"" => :DQMID,
"" => :DQPOST,
"" => :BOOLEAN,
"" => :SELBRACE # A QMARK followed by '{'
)
module Contextual
QUOTE_TOKENS = [:DQPRE,:DQMID]
REGEX_INTRODUCING_TOKENS = [:NODE,:LBRACE, :SELBRACE, :RBRACE,:MATCH,:NOMATCH,:COMMA]
NOT_INSIDE_QUOTES = Proc.new do |context|
!QUOTE_TOKENS.include? context[:after]
end
INSIDE_QUOTES = Proc.new do |context|
QUOTE_TOKENS.include? context[:after]
end
IN_REGEX_POSITION = Proc.new do |context|
REGEX_INTRODUCING_TOKENS.include? context[:after]
end
DASHED_VARIABLES_ALLOWED = Proc.new do |context|
Puppet[:allow_variables_with_dashes]
end
VARIABLE_AND_DASHES_ALLOWED = Proc.new do |context|
Contextual::DASHED_VARIABLES_ALLOWED.call(context) and TOKENS[:VARIABLE].acceptable?(context)
end
end
# Numbers are treated separately from names, so that they may contain dots.
TOKENS.add_token :NUMBER, %r{\b(?:0[xX][0-9A-Fa-f]+|0?\d+(?:\.\d+)?(?:[eE]-?\d+)?)\b} do |lexer, value|
lexer.assert_numeric(value)
[TOKENS[:NAME], value]
end
TOKENS[:NUMBER].acceptable_when Contextual::NOT_INSIDE_QUOTES
TOKENS.add_token :NAME, %r{((::)?[a-z0-9][-\w]*)(::[a-z0-9][-\w]*)*} do |lexer, value|
# A name starting with a number must be a valid numeric string (not that
# NUMBER token captures those names that do not comply with the name rule.
if value =~ /^[0-9].*$/
lexer.assert_numeric(value)
end
string_token = self
# we're looking for keywords here
if tmp = KEYWORDS.lookup(value)
string_token = tmp
if [:TRUE, :FALSE].include?(string_token.name)
value = eval(value)
string_token = TOKENS[:BOOLEAN]
end
end
[string_token, value]
end
[:NAME, :CLASSREF].each do |name_token|
TOKENS[name_token].acceptable_when Contextual::NOT_INSIDE_QUOTES
end
TOKENS.add_token :COMMENT, %r{#.*}, :skip => true do |lexer,value|
value.sub!(/# ?/,'')
[self, value]
end
TOKENS.add_token :MLCOMMENT, %r{/\*(.*?)\*/}m, :skip => true do |lexer, value|
value.sub!(/^\/\* ?/,'')
value.sub!(/ ?\*\/$/,'')
[self,value]
end
TOKENS.add_token :REGEX, %r{/[^/\n]*/} do |lexer, value|
# Make sure we haven't matched an escaped /
while value[-2..-2] == '\\'
other = lexer.scan_until(%r{/})
value += other
end
regex = value.sub(%r{\A/}, "").sub(%r{/\Z}, '').gsub("\\/", "/")
[self, Regexp.new(regex)]
end
TOKENS[:REGEX].acceptable_when Contextual::IN_REGEX_POSITION
TOKENS.add_token :RETURN, "\n", :skip => true, :skip_text => true
TOKENS.add_token :SQUOTE, "'" do |lexer, value|
[TOKENS[:STRING], lexer.slurpstring(value,["'"],:ignore_invalid_escapes).first ]
end
DQ_initial_token_types = {'$' => :DQPRE,'"' => :STRING}
DQ_continuation_token_types = {'$' => :DQMID,'"' => :DQPOST}
TOKENS.add_token :DQUOTE, /"/ do |lexer, value|
lexer.tokenize_interpolated_string(DQ_initial_token_types)
end
# LBRACE needs look ahead to differentiate between '{' and a '{'
# followed by a '|' (start of lambda) The racc grammar can only do one
# token lookahead.
#
TOKENS.add_token :LBRACE, "{" do |lexer, value|
lexer.lexing_context[:brace_count] += 1
if lexer.lexing_context[:after] == :QMARK
[TOKENS[:SELBRACE], value]
else
[TOKENS[:LBRACE], value]
end
end
# RBRACE needs to differentiate between a regular brace that is part of
# syntax and one that is the ending of a string interpolation.
TOKENS.add_token :RBRACE, "}" do |lexer, value|
context = lexer.lexing_context
if context[:interpolation_stack].empty? || context[:brace_count] != context[:interpolation_stack][-1]
context[:brace_count] -= 1
[TOKENS[:RBRACE], value]
else
lexer.tokenize_interpolated_string(DQ_continuation_token_types)
end
end
TOKENS.add_token :DOLLAR_VAR_WITH_DASH, %r{\$(?:::)?(?:[-\w]+::)*[-\w]+} do |lexer, value|
lexer.warn_if_variable_has_hyphen(value)
[TOKENS[:VARIABLE], value[1..-1]]
end
TOKENS[:DOLLAR_VAR_WITH_DASH].acceptable_when Contextual::DASHED_VARIABLES_ALLOWED
TOKENS.add_token :DOLLAR_VAR, %r{\$(::)?(\w+::)*\w+} do |lexer, value|
[TOKENS[:VARIABLE],value[1..-1]]
end
TOKENS.add_token :VARIABLE_WITH_DASH, %r{(?:::)?(?:[-\w]+::)*[-\w]+} do |lexer, value|
lexer.warn_if_variable_has_hyphen(value)
# If the varname (following $, or ${ is followed by (, it is a function call, and not a variable
# reference.
#
if lexer.match?(%r{[ \t\r]*\(})
[TOKENS[:NAME],value]
else
[TOKENS[:VARIABLE], value]
end
end
TOKENS[:VARIABLE_WITH_DASH].acceptable_when Contextual::VARIABLE_AND_DASHES_ALLOWED
TOKENS.add_token :VARIABLE, %r{(::)?(\w+::)*\w+} do |lexer, value|
# If the varname (following $, or ${ is followed by (, it is a function call, and not a variable
# reference.
#
if lexer.match?(%r{[ \t\r]*\(})
# followed by ( is a function call
[TOKENS[:NAME], value]
elsif kwd_token = KEYWORDS.lookup(value)
# true, false, if, unless, case, and undef are keywords that cannot be used as variables
# but node, and several others are variables
if [ :TRUE, :FALSE ].include?(kwd_token.name)
[ TOKENS[:BOOLEAN], eval(value) ]
elsif [ :IF, :UNLESS, :CASE, :UNDEF ].include?(kwd_token.name)
[kwd_token, value]
else
[TOKENS[:VARIABLE], value]
end
else
[TOKENS[:VARIABLE], value]
end
end
TOKENS[:VARIABLE].acceptable_when Contextual::INSIDE_QUOTES
TOKENS.sort_tokens
@@pairs = {
"{" => "}",
"(" => ")",
"[" => "]",
"<|" => "|>",
"<<|" => "|>>",
"|" => "|"
}
KEYWORDS = TokenList.new
KEYWORDS.add_tokens(
"case" => :CASE,
"class" => :CLASS,
"default" => :DEFAULT,
"define" => :DEFINE,
# "import" => :IMPORT,
"if" => :IF,
"elsif" => :ELSIF,
"else" => :ELSE,
"inherits" => :INHERITS,
"node" => :NODE,
"and" => :AND,
"or" => :OR,
"undef" => :UNDEF,
"false" => :FALSE,
"true" => :TRUE,
"in" => :IN,
"unless" => :UNLESS
)
def clear
initvars
end
def expected
return nil if @expected.empty?
name = @expected[-1]
TOKENS.lookup(name) or lex_error "Internal Lexer Error: Could not find expected token #{name}"
end
# scan the whole file
# basically just used for testing
def fullscan
array = []
self.scan { |token, str|
# Ignore any definition nesting problems
@indefine = false
array.push([token,str])
}
array
end
def file=(file)
@file = file
contents = Puppet::FileSystem::File.exist?(file) ? File.read(file) : ""
@scanner = StringScanner.new(contents)
@locator = Locator.new(contents, multibyte?)
end
def_delegator :@token_queue, :shift, :shift_token
def find_string_token
# We know our longest string token is three chars, so try each size in turn
# until we either match or run out of chars. This way our worst-case is three
# tries, where it is otherwise the number of string token we have. Also,
# the lookups are optimized hash lookups, instead of regex scans.
#
s = @scanner.peek(3)
token = TOKENS.lookup(s[0,3]) || TOKENS.lookup(s[0,2]) || TOKENS.lookup(s[0,1])
[ token, token && @scanner.scan(token.regex) ]
end
# Find the next token that matches a regex. We look for these first.
def find_regex_token
best_token = nil
best_length = 0
# I tried optimizing based on the first char, but it had
# a slightly negative affect and was a good bit more complicated.
TOKENS.regex_tokens.each do |token|
if length = @scanner.match?(token.regex) and token.acceptable?(lexing_context)
# We've found a longer match
if length > best_length
best_length = length
best_token = token
end
end
end
return best_token, @scanner.scan(best_token.regex) if best_token
end
# Find the next token, returning the string and the token.
def find_token
shift_token || find_regex_token || find_string_token
end
def initialize
@multibyte = init_multibyte
initvars
end
def assert_numeric(value)
if value =~ /^0[xX].*$/
lex_error (positioned_message("Not a valid hex number #{value}")) unless value =~ /^0[xX][0-9A-Fa-f]+$/
elsif value =~ /^0[^.].*$/
lex_error(positioned_message("Not a valid octal number #{value}")) unless value =~ /^0[0-7]+$/
else
lex_error(positioned_message("Not a valid decimal number #{value}")) unless value =~ /0?\d+(?:\.\d+)?(?:[eE]-?\d+)?/
end
end
# Returns true if ruby version >= 1.9.3 since regexp supports multi-byte matches and expanded
# character categories like [[:blank:]].
#
# This implementation will fail if there are more than 255 minor or micro versions of ruby
#
def init_multibyte
numver = RUBY_VERSION.split(".").collect {|s| s.to_i }
return true if (numver[0] << 16 | numver[1] << 8 | numver[2]) >= (1 << 16 | 9 << 8 | 3)
false
end
def multibyte?
@multibyte
end
def initvars
@previous_token = nil
@scanner = nil
@file = nil
# AAARRGGGG! okay, regexes in ruby are bloody annoying
# no one else has "\n" =~ /\s/
if multibyte?
# Skip all kinds of space, and CR, but not newlines
@skip = %r{[[:blank:]\r]+}
else
@skip = %r{[ \t\r]+}
end
@namestack = []
@token_queue = []
@indefine = false
@expected = []
@lexing_context = {
:after => nil,
:start_of_line => true,
:offset => 0, # byte offset before where token starts
:end_offset => 0, # byte offset after scanned token
:brace_count => 0, # nested depth of braces
:interpolation_stack => [] # matching interpolation brace level
}
end
# Make any necessary changes to the token and/or value.
def munge_token(token, value)
# A token may already have been munged (converted and positioned)
#
return token, value if value.is_a? Hash
skip if token.skip_text
return if token.skip
token, value = token.convert(self, value) if token.respond_to?(:convert)
return unless token
return if token.skip
# If the conversion performed the munging/positioning
return token, value if value.is_a? Hash
pos_hash = position_in_source
pos_hash[:value] = value
# Add one to pos, first char on line is 1
return token, pos_hash
end
# Returns a hash with the current position in source based on the current lexing context
#
def position_in_source
pos = @locator.pos_on_line(lexing_context[:offset])
offset = @locator.char_offset(lexing_context[:offset])
length = @locator.char_length(lexing_context[:offset], lexing_context[:end_offset])
start_line = @locator.line_for_offset(lexing_context[:offset])
return { :line => start_line, :pos => pos, :offset => offset, :length => length}
end
def pos
@locator.pos_on_line(lexing_context[:offset])
end
# Handling the namespace stack
def_delegator :@namestack, :pop, :namepop
# This value might have :: in it, but we don't care -- it'll be handled
# normally when joining, and when popping we want to pop this full value,
# however long the namespace is.
def_delegator :@namestack, :<<, :namestack
# Collect the current namespace.
def namespace
@namestack.join("::")
end
def_delegator :@scanner, :rest
# this is the heart of the lexer
def scan
#Puppet.debug("entering scan")
lex_error "Internal Error: No string or file given to lexer to process." unless @scanner
# Skip any initial whitespace.
skip
until token_queue.empty? and @scanner.eos? do
offset = @scanner.pos
matched_token, value = find_token
end_offset = @scanner.pos
# error out if we didn't match anything at all
lex_error "Could not match #{@scanner.rest[/^(\S+|\s+|.*)/]}" unless matched_token
newline = matched_token.name == :RETURN
lexing_context[:start_of_line] = newline
lexing_context[:offset] = offset
lexing_context[:end_offset] = end_offset
final_token, token_value = munge_token(matched_token, value)
# update end position since munging may have moved the end offset
lexing_context[:end_offset] = @scanner.pos
unless final_token
skip
next
end
lexing_context[:after] = final_token.name unless newline
if final_token.name == :DQPRE
lexing_context[:interpolation_stack] << lexing_context[:brace_count]
elsif final_token.name == :DQPOST
lexing_context[:interpolation_stack].pop
end
value = token_value[:value]
if match = @@pairs[value] and final_token.name != :DQUOTE and final_token.name != :SQUOTE
@expected << match
elsif exp = @expected[-1] and exp == value and final_token.name != :DQUOTE and final_token.name != :SQUOTE
@expected.pop
end
yield [final_token.name, token_value]
if @previous_token
namestack(value) if @previous_token.name == :CLASS and value != '{'
if @previous_token.name == :DEFINE
if indefine?
msg = "Cannot nest definition #{value} inside #{@indefine}"
self.indefine = false
raise Puppet::ParseError, msg
end
@indefine = value
end
end
@previous_token = final_token
skip
end
# Cannot reset @scanner to nil here - it is needed to answer questions about context after
# completed parsing.
# Seems meaningless to do this. Everything will be gc anyway.
#@scanner = nil
# This indicates that we're done parsing.
yield [false,false]
end
# Skip any skipchars in our remaining string.
def skip
@scanner.skip(@skip)
end
def match? r
@scanner.match?(r)
end
# Provide some limited access to the scanner, for those
# tokens that need it.
def_delegator :@scanner, :scan_until
# we've encountered the start of a string...
# slurp in the rest of the string and return it
def slurpstring(terminators,escapes=%w{ \\ $ ' " r n t s }+["\n"],ignore_invalid_escapes=false)
# we search for the next quote that isn't preceded by a
# backslash; the caret is there to match empty strings
last = @scanner.matched
str = @scanner.scan_until(/([^\\]|^|[^\\])([\\]{2})*[#{terminators}]/) || lex_error(positioned_message("Unclosed quote after #{format_quote(last)} followed by '#{followed_by}'"))
str.gsub!(/\\(.)/m) {
ch = $1
if escapes.include? ch
case ch
when 'r'; "\r"
when 'n'; "\n"
when 't'; "\t"
when 's'; " "
when "\n"; ''
else ch
end
else
Puppet.warning(positioned_message("Unrecognized escape sequence '\\#{ch}'")) unless ignore_invalid_escapes
"\\#{ch}"
end
}
[ str[0..-2],str[-1,1] ]
end
# Formats given message by appending file, line and position if available.
def positioned_message msg
result = [msg]
result << "in file #{file}" if file
result << "at line #{line}:#{pos}" if line
result.join(" ")
end
# Returns "" if at end of input, else the following 5 characters with \n \r \t escaped
def followed_by
return "" if @scanner.eos?
result = @scanner.rest[0,5] + "..."
result.gsub!("\t", '\t')
result.gsub!("\n", '\n')
result.gsub!("\r", '\r')
result
end
def format_quote q
if q == "'"
'"\'"'
else
"'#{q}'"
end
end
def tokenize_interpolated_string(token_type,preamble='')
# Expecting a (possibly empty) stretch of text terminated by end of string ", a variable $, or expression ${
# The length of this part includes the start and terminating characters.
value,terminator = slurpstring('"$')
# Advanced after '{' if this is in expression ${} interpolation
braced = terminator == '$' && @scanner.scan(/\{/)
# make offset to end_ofset be the length of the pre expression string including its start and terminating chars
lexing_context[:end_offset] = @scanner.pos
token_queue << [TOKENS[token_type[terminator]],position_in_source().merge!({:value => preamble+value})]
variable_regex = if Puppet[:allow_variables_with_dashes]
TOKENS[:VARIABLE_WITH_DASH].regex
else
TOKENS[:VARIABLE].regex
end
if terminator != '$' or braced
return token_queue.shift
end
tmp_offset = @scanner.pos
if var_name = @scanner.scan(variable_regex)
lexing_context[:offset] = tmp_offset
lexing_context[:end_offset] = @scanner.pos
warn_if_variable_has_hyphen(var_name)
# If the varname after ${ is followed by (, it is a function call, and not a variable
# reference.
#
if braced && @scanner.match?(%r{[ \t\r]*\(})
token_queue << [TOKENS[:NAME], position_in_source().merge!({:value=>var_name})]
else
token_queue << [TOKENS[:VARIABLE],position_in_source().merge!({:value=>var_name})]
end
lexing_context[:offset] = @scanner.pos
tokenize_interpolated_string(DQ_continuation_token_types)
else
tokenize_interpolated_string(token_type, replace_false_start_with_text(terminator))
end
end
def replace_false_start_with_text(appendix)
last_token = token_queue.pop
value = last_token.last
if value.is_a? Hash
value[:value] + appendix
else
value + appendix
end
end
# just parse a string, not a whole file
def string=(string)
@scanner = StringScanner.new(string)
@locator = Locator.new(string, multibyte?)
end
def warn_if_variable_has_hyphen(var_name)
if var_name.include?('-')
Puppet.deprecation_warning("Using `-` in variable names is deprecated at #{file || ''}:#{line}. See http://links.puppetlabs.com/puppet-hyphenated-variable-deprecation")
end
end
# Returns the line number (starting from 1) for the current position
# in the scanned text (at the end of the last produced, but not necessarily
# consumed.
#
def line
return 1 unless lexing_context && locator
locator.line_for_offset(lexing_context[:end_offset])
end
# Helper class that keeps track of where line breaks are located and can answer questions about positions.
#
class Locator
attr_reader :line_index
attr_reader :string
# Create a locator based on a content string, and a boolean indicating if ruby version support multi-byte strings
# or not.
#
def initialize(string, multibyte)
@string = string
@multibyte = multibyte
compute_line_index
end
# Returns whether this a ruby version that supports multi-byte strings or not
#
def multibyte?
@multibyte
end
# Computes the start offset for each line.
#
def compute_line_index
scanner = StringScanner.new(@string)
result = [0] # first line starts at 0
while scanner.scan_until(/\n/)
result << scanner.pos
end
@line_index = result
end
# Returns the line number (first line is 1) for the given offset
def line_for_offset(offset)
if line_nbr = line_index.index {|x| x > offset}
return line_nbr
end
# If not found it is after last
return line_index.size
end
# Returns the offset on line (first offset on a line is 0).
#
def offset_on_line(offset)
line_offset = line_index[line_for_offset(offset)-1]
if multibyte?
@string.byteslice(line_offset, offset-line_offset).length
else
offset - line_offset
end
end
# Returns the position on line (first position on a line is 1)
def pos_on_line(offset)
offset_on_line(offset) +1
end
# Returns the character offset for a given byte offset
def char_offset(byte_offset)
if multibyte?
@string.byteslice(0, byte_offset).length
else
byte_offset
end
end
# Returns the length measured in number of characters from the given start and end byte offseta
def char_length(offset, end_offset)
if multibyte?
@string.byteslice(offset, end_offset - offset).length
else
end_offset - offset
end
end
end
end
puppet-3.4.3/lib/puppet/pops/parser/grammar.ra 0000644 0052762 0001160 00000061125 12300765631 021250 0 ustar jenkins jenkins # vim: syntax=ruby
# Parser using the Pops model
# This grammar is a half step between the current 3.1. grammar and egrammar.
# FIXME! Keep as reference until egrammar is proven to work.
class Puppet::Pops::Impl::Parser::Parser
token STRING DQPRE DQMID DQPOST
token LBRACK RBRACK LBRACE RBRACE SYMBOL FARROW COMMA TRUE
token FALSE EQUALS APPENDS LESSEQUAL NOTEQUAL DOT COLON LLCOLLECT RRCOLLECT
token QMARK LPAREN RPAREN ISEQUAL GREATEREQUAL GREATERTHAN LESSTHAN
token IF ELSE IMPORT DEFINE ELSIF VARIABLE CLASS INHERITS NODE BOOLEAN
token NAME SEMIC CASE DEFAULT AT LCOLLECT RCOLLECT CLASSREF
token NOT OR AND UNDEF PARROW PLUS MINUS TIMES DIV LSHIFT RSHIFT UMINUS
token MATCH NOMATCH REGEX IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
token IN UNLESS PIPE
token LAMBDA
prechigh
left DOT
# left LBRACE
# left LCOLLECT LLCOLLECT
right NOT
nonassoc UMINUS
left IN MATCH NOMATCH
left TIMES DIV
left MINUS PLUS
left LSHIFT RSHIFT
left NOTEQUAL ISEQUAL
left GREATEREQUAL GREATERTHAN LESSTHAN LESSEQUAL
left AND
left OR
# left IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
preclow
rule
# Produces [Model::BlockExpression, Model::Expression, nil] depending on multiple statements, single statement or empty
program
: statements { result = Factory.block_or_expression(*val[0]) }
| nil
# Change may have issues with nil; i.e. program is a sequence of nils/nops
# Simplified from original which had validation for top level constructs - see statement rule
# Produces Array
statements
: statement { result = [val[0]]}
| statements statement { result = val[0].push val[1] }
# Removed validation construct regarding "top level statements" as it did not seem to catch all problems
# and relied on a "top-level-ness" encoded in the abstract syntax tree objects
#
# The main list of valid statements
# Produces Model::Expression
#
statement
: resource
| virtual_resource
| collection
| assignment
| casestatement
| if_expression
| unless_expression
| import
| call_named_function
| definition
| hostclass
| nodedef
| resource_override
| append
| relationship
| call_method_with_lambda
keyword
: AND
| CASE
| CLASS
| DEFAULT
| DEFINE
| ELSE
| ELSIF
| IF
| IN
| IMPORT
| INHERITS
| NODE
| OR
| UNDEF
| UNLESS
# Produces Model::RelationshipExpression
relationship
: relationship_side edge relationship_side { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
| relationship edge relationship_side { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
# Produces Model::Expression
relationship_side
: resource
| resourceref
| collection
| variable
| quotedtext
| selector
| casestatement
| hasharrayaccesses
# Produces String
edge
: IN_EDGE
| OUT_EDGE
| IN_EDGE_SUB
| OUT_EDGE_SUB
# Produces Model::CallNamedFunctionExpression
call_named_function
: NAME LPAREN expressions RPAREN { result = Factory.CALL_NAMED(val[0][:value], false, val[2]) ; loc result, val[0], val[3] }
| NAME LPAREN expressions COMMA RPAREN { result = Factory.CALL_NAMED(val[0][:value], false, val[2]) ; loc result, val[0], val[4] }
| NAME LPAREN RPAREN { result = Factory.CALL_NAMED(val[0][:value], false, []) ; loc result, val[0], val[2] }
| NAME func_call_args { result = Factory.CALL_NAMED(val[0][:value], false, val[1]) ; loc result, val[0] }
call_method_with_lambda
: call_method { result = val[0] }
| call_method lambda { result = val[0]; val[0].lambda = val[1] }
call_method
: named_access LPAREN expressions RPAREN { result = Factory.CALL_METHOD(val[0], val[2]); loc result, val[1], val[3] }
| named_access LPAREN RPAREN { result = Factory.CALL_METHOD(val[0], []); loc result, val[1], val[3] }
| named_access { result = Factory.CALL_METHOD(val[0], []); loc result, val[0] }
named_access
: named_access_lval DOT NAME {
result = val[0].dot(Factory.fqn(val[2][:value]))
loc result, val[1], val[2]
}
# Obviously not ideal, it is not possible to use literal array or hash as lhs
# These must be assigned to a variable - this is also an issue in other places
#
named_access_lval
: variable
| hasharrayaccesses
| selector
| quotedtext
| call_named_rval_function
lambda
: LAMBDA lambda_parameter_list statements RBRACE {
result = Factory.LAMBDA(val[1], val[2])
loc result, val[0], val[3]
}
| LAMBDA lambda_parameter_list RBRACE {
result = Factory.LAMBDA(val[1], nil)
loc result, val[0], val[2]
}
# Produces Array
lambda_parameter_list
: PIPE PIPE { result = [] }
| PIPE parameters endcomma PIPE { result = val[1] }
# Produces Array
func_call_args
: rvalue { result = [val[0]] }
| func_call_args COMMA rvalue { result = val[0].push(val[2]) }
# Produces Array
expressions
: expression { result = [val[0]] }
| expressions comma expression { result = val[0].push(val[2]) }
# Produces [Model::ResourceExpression, Model::ResourceDefaultsExpression]
resource
: classname LBRACE resourceinstances endsemi RBRACE {
result = Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
loc result, val[0], val[4]
}
| classname LBRACE attribute_operations endcomma RBRACE {
# This is a deprecated syntax.
# It also fails hard - TODO: create model and validate this case
error "All resource specifications require names"
}
| type LBRACE attribute_operations endcomma RBRACE {
# a defaults setting for a type
result = Factory.RESOURCE_DEFAULTS(val[0], val[2])
loc result, val[0], val[4]
}
# Override a value set elsewhere in the configuration.
# Produces Model::ResourceOverrideExpression
resource_override
: resourceref LBRACE attribute_operations endcomma RBRACE {
@lexer.commentpop
result = Factory.RESOURCE_OVERRIDE(val[0], val[2])
loc result, val[0], val[4]
}
# Exported and virtual resources; these don't get sent to the client
# unless they get collected elsewhere in the db.
# The original had validation here; checking if storeconfigs is on; this is moved to a validation step
# Also, validation was performed if an attempt was made to virtualize or export a resource defaults
# this is also now deferred to validation
# Produces [Model::ResourceExpression, Model::ResourceDefaultsExpression]
virtual_resource
: at resource {
val[1].form = val[0] # :virtual, :exported, (or :regular)
result = val[1]
}
# Produces Symbol corresponding to resource form
at
: AT { result = :virtual }
| AT AT { result = :exported }
# A collection statement. Currently supports no arguments at all, but eventually
# will, I assume.
#
# Produces Model::CollectExpression
#
collection
: type collect_query LBRACE attribute_operations endcomma RBRACE {
@lexer.commentpop
result = Factory.COLLECT(val[0].value.downcase, val[1], val[3])
loc result, val[0], val[5]
}
| type collect_query {
result = Factory.COLLECT(val[0].value.downcase, val[1], [])
loc result, val[0], val[1]
}
collect_query
: LCOLLECT optional_query RCOLLECT { result = Factory.VIRTUAL_QUERY(val[1]) ; loc result, val[0], val[2] }
| LLCOLLECT optional_query RRCOLLECT { result = Factory.EXPORTED_QUERY(val[1]) ; loc result, val[0], val[2] }
# ORIGINAL COMMENT: A mini-language for handling collection comparisons. This is organized
# to avoid the need for precedence indications.
# (New implementation is slightly different; and when finished, it may be possible to streamline the
# grammar - the difference is mostly in evaluation, not in grammar)
#
optional_query
: nil
| query
# ORIGINAL: Had a weird list structure where AND and OR where at the same level, and hence, there was the
# need to keep track of where parenthesis were (to get order correct).
#
# This is now not needed as AND has higher precedence than OR, and parenthesis are low in precedence
query
: predicate_lval ISEQUAL expression { result = (val[0] == val[2]) ; loc result, val[1] }
| predicate_lval NOTEQUAL expression { result = (val[0].ne(val[2])) ; loc result, val[1] }
| LPAREN query RPAREN { result = val[1] }
| query AND query { result = val[0].and(val[2]) ; loc result, val[1] }
| query OR query { result = val[0].or(val[2]) ; loc result, val[1] }
# Produces Model::VariableExpression, or Model::QualifiedName
predicate_lval
: variable
| name
resourceinst
: resourcename COLON attribute_operations endcomma { result = Factory.RESOURCE_BODY(val[0], val[2]) }
resourceinstances
: resourceinst { result = [val[0]] }
| resourceinstances SEMIC resourceinst { result = val[0].push val[2] }
resourcename
: quotedtext
| name
| type
| selector
| variable
| array
| hasharrayaccesses
# Assignment, only assignment to variable is legal, but parser builds expression for [] = anyway to
# enable a better error message
assignment
: VARIABLE EQUALS expression { result = Factory.var(Factory.fqn(val[0][:value])).set(val[2]) ; loc result, val[1] }
| hasharrayaccess EQUALS expression { result val[0].set(val[2]); loc result, val[1] }
append
: VARIABLE APPENDS expression { result = Factory.var(val[0][:value]).plus_set(val[1]) ; loc result, val[1] }
# Produces Array
attribute_operations
: { result = [] }
| attribute_operation { result = [val[0]] }
| attribute_operations COMMA attribute_operation { result = val[0].push(val[2]) }
# Produces String
attribute_name
: NAME
| keyword
| BOOLEAN
# Several grammar issues here: the addparam did not allow keyword and booleans as names.
# In this version, the wrong combinations are validated instead of producing syntax errors
# (Can give nicer error message +> is not applicable to...)
# WAT - Boolean as attribute name?
# Produces Model::AttributeOperation
#
attribute_operation
: attribute_name FARROW expression {
result = Factory.ATTRIBUTE_OP(val[0][:value], :'=>', val[2])
loc result, val[0], val[2]
}
| attribute_name PARROW expression {
result = Factory.ATTRIBUTE_OP(val[0][:value], :'+>', val[2])
loc result, val[0], val[2]
}
# Produces Model::CallNamedFunction
call_named_rval_function
: NAME LPAREN expressions RPAREN { result = Factory.CALL_NAMED(val[0][:value], true, val[2]) ; loc result, val[0], val[3] }
| NAME LPAREN RPAREN { result = Factory.CALL_NAMED(val[0][:value], true, []) ; loc result, val[0], val[2] }
quotedtext
: STRING { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
| dqpre dqrval { result = Factory.string(val[0], *val[1]) ; loc result, val[0], val[1][-1] }
dqpre : DQPRE { result = Factory.literal(val[0][:value]); loc result, val[0] }
dqpost : DQPOST { result = Factory.literal(val[0][:value]); loc result, val[0] }
dqmid : DQMID { result = Factory.literal(val[0][:value]); loc result, val[0] }
text_expression : expression { result = Factory.TEXT(val[0]) }
dqrval
: text_expression dqtail { result = [val[0]] + val[1] }
dqtail
: dqpost { result = [val[0]] }
| dqmid dqrval { result = [val[0]] + val[1] }
# Reference to Resource (future also reference to other instances of other types than Resources).
# First form (lower case name) is deprecated (deprecation message handled in validation). Note that
# this requires use of token NAME since a rule call to name causes shift reduce conflict with
# a function call NAME NAME (calling function with NAME as argument e.g. foo bar).
#
# Produces InstanceReference
resourceref
: NAME LBRACK expressions RBRACK {
# Would want to use rule name here, but can't (need a NAME with higher precedence), so must
# create a QualifiedName instance here for NAME
result = Factory.INSTANCE(Factory.QNAME_OR_NUMBER(val[0][:value]), val[2]);
loc result, val[0], val[2][-1]
}
| type LBRACK expressions RBRACK {
result = Factory.INSTANCE(val[0], val[2]);
loc result, val[0], val[2][-1]
}
# Changed from Puppet 3x where there is no else part on unless
#
unless_expression
: UNLESS expression LBRACE statements RBRACE unless_else {
@lexer.commentpop
result = Factory.UNLESS(val[1], Factory.block_or_expression(*val[3]), val[5])
loc result, val[0], val[4]
}
| UNLESS expression LBRACE RBRACE unless_else {
@lexer.commentpop
result = Factory.UNLESS(val[1], nil, nil)
loc result, val[0], val[4]
}
# Different from else part of if, since "elsif" is not supported, but else is
#
# Produces [Model::Expression, nil] - nil if there is no else or elsif part
unless_else
: # nothing
| ELSE LBRACE statements RBRACE {
@lexer.commentpop
result = Factory.block_or_expression(*val[2])
loc result, val[0], val[3]
}
| ELSE LBRACE RBRACE {
@lexer.commentpop
result = nil # don't think a nop is needed here either
}
# Produces Model::IfExpression
if_expression
: IF if_expression_part {
result = val[1]
}
# Produces Model::IfExpression
if_expression_part
: expression LBRACE statements RBRACE else {
@lexer.commentpop
result = Factory.IF(val[0], Factory.block_or_expression(*val[2]), val[4])
loc(result, val[0], (val[4] ? val[4] : val[3]))
}
| expression LBRACE RBRACE else {
result = Factory.IF(val[0], nil, val[3])
loc(result, val[0], (val[3] ? val[3] : val[2]))
}
# Produces [Model::Expression, nil] - nil if there is no else or elsif part
else
: # nothing
| ELSIF if_expression_part { result = val[1] }
| ELSE LBRACE statements RBRACE {
@lexer.commentpop
result = Factory.block_or_expression(*val[2])
loc result, val[0], val[3]
}
| ELSE LBRACE RBRACE {
@lexer.commentpop
result = nil # don't think a nop is needed here either
}
# Produces Model::Expression
expression
: rvalue
| hash
| expression IN expression { result = val[0].in val[2] ; loc result, val[1] }
| expression MATCH match_rvalue { result = val[0] =~ val[2] ; loc result, val[1] }
| expression NOMATCH match_rvalue { result = val[0].mne val[2] ; loc result, val[1] }
| expression PLUS expression { result = val[0] + val[2] ; loc result, val[1] }
| expression MINUS expression { result = val[0] - val[2] ; loc result, val[1] }
| expression DIV expression { result = val[0] / val[2] ; loc result, val[1] }
| expression TIMES expression { result = val[0] * val[2] ; loc result, val[1] }
| expression LSHIFT expression { result = val[0] << val[2] ; loc result, val[1] }
| expression RSHIFT expression { result = val[0] >> val[2] ; loc result, val[1] }
| MINUS expression =UMINUS { result = val[1].minus() ; loc result, val[0] }
| expression NOTEQUAL expression { result = val[0].ne val[2] ; loc result, val[1] }
| expression ISEQUAL expression { result = val[0] == val[2] ; loc result, val[1] }
| expression GREATERTHAN expression { result = val[0] > val[2] ; loc result, val[1] }
| expression GREATEREQUAL expression { result = val[0] >= val[2] ; loc result, val[1] }
| expression LESSTHAN expression { result = val[0] < val[2] ; loc result, val[1] }
| expression LESSEQUAL expression { result = val[0] <= val[2] ; loc result, val[1] }
| NOT expression { result = val[1].not ; loc result, val[0] }
| expression AND expression { result = val[0].and val[2] ; loc result, val[1] }
| expression OR expression { result = val[0].or val[2] ; loc result, val[1] }
| LPAREN expression RPAREN { result = val[1] ; }
| call_method_with_lambda
match_rvalue
: regex
| quotedtext
# Produces Model::CaseExpression
casestatement
: CASE expression LBRACE case_options RBRACE {
@lexer.commentpop
result = Factory.CASE(val[1], *val[3])
loc result, val[0], val[4]
}
# Produces Array
case_options
: case_option { result = [val[0]] }
| case_options case_option { result = val[0].push val[1] }
# Produced Model::CaseOption (aka When)
case_option
: case_values COLON LBRACE statements RBRACE {
@lexer.commentpop
result = Factory.WHEN(val[0], val[3])
loc result, val[1], val[4]
}
| case_values COLON LBRACE RBRACE {
@lexer.commentpop
result = Factory.WHEN(val[0], nil)
loc result, val[1], val[3]
}
# Produces Array mostly literals
case_values
: selectable { result = [val[0]] }
| case_values COMMA selectable { result = val[0].push val[2] }
# Produces Model::SelectorExpression
selector
: selectable QMARK selector_entries { result = val[0].select(*val[2]) ; loc result, val[1] }
# Produces Array
selector_entries
: selector_entry { result = [val[0]] }
| LBRACE selector_entry_list endcomma RBRACE {
@lexer.commentpop
result = val[1]
}
# Produces Array
selector_entry_list
: selector_entry { result = [val[0]] }
| selector_entry_list COMMA selector_entry { result = val[0].push val[2] }
# Produces a Model::SelectorEntry
selector_entry
: selectable FARROW rvalue { result = Factory.MAP(val[0], val[2]) ; loc result, val[1] }
# Produces Model::Expression (most of the literals)
selectable
: name
| type
| quotedtext
| variable
| call_named_rval_function
| boolean
| undef
| hasharrayaccess
| default
| regex
# Produces nil (noop)
import
: IMPORT strings {
error "Import not supported in this version of the parser", \
:line => stmt.context[:line], :file => stmt.context[:file]
result = nil
}
# IMPORT (T.B DEPRECATED IN PUPPET WHEN IT HAS BEEN FIGURED OUT HOW TO SUPPORT
# THE THINGS IMPORTS ARE USED FOR.
# BOLDLY DECIDED TO SKIP THIS COMPLETELY IN THIS IMPLEMENTATION - will trigger an error
#
# These are only used for importing, no interpolation
string
: STRING { result = [val[0][:value]] }
strings
: string
| strings COMMA string { result = val[0].push val[2] }
# Produces Model::Definition
definition
: DEFINE classname parameter_list LBRACE statements RBRACE {
@lexer.commentpop
result = Factory.DEFINITION(classname(val[1][:value]), val[2], val[4])
loc result, val[0], val[5]
@lexer.indefine = false
}
| DEFINE classname parameter_list LBRACE RBRACE {
@lexer.commentpop
result = Factory.DEFINITION(classname(val[1][:value]), val[2], nil)
loc result, val[0], val[4]
@lexer.indefine = false
}
# ORIGINAL COMMENT: Our class gets defined in the parent namespace, not our own.
# WAT ??! This is way odd; should get its complete name, classnames do not nest
# Seems like the call to classname makes use of the name scope
# (This is uneccesary, since the parent name is known when evaluating)
#
# Produces Model::HostClassDefinition
#
hostclass
: CLASS classname parameter_list classparent LBRACE statements RBRACE {
@lexer.commentpop
@lexer.namepop
result = Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), val[5])
loc result, val[0], val[6]
}
| CLASS classname parameter_list classparent LBRACE RBRACE {
@lexer.commentpop
@lexer.namepop
result = Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), nil)
loc result, val[0], val[5]
}
# Produces Model::NodeDefinition
nodedef
: NODE hostnames nodeparent LBRACE statements RBRACE {
@lexer.commentpop
result = Factory.NODE(val[1], val[2], val[4])
loc result, val[0], val[5]
}
| NODE hostnames nodeparent LBRACE RBRACE {
@lexer.commentpop
result = Factory.NODE(val[1], val[2], nil)
loc result, val[0], val[4]
}
# String result
classname
: NAME { result = val[0] }
| CLASS { result = val[0] }
# Hostnames is not a list of names, it is a list of name matchers (including a Regexp).
# (The old implementation had a special "Hostname" object with some minimal validation)
#
# Produces Array
#
hostnames
: nodename { result = [result] }
| hostnames COMMA nodename { result = val[0].push(val[2]) }
# Produces Model::LiteralExpression
#
nodename
: hostname
# Produces a LiteralExpression (string, :default, or regexp)
hostname
: NAME { result = Factory.fqn(val[0][:value]); loc result, val[0] }
| STRING { result = Factory.literal(val[0][:value]); loc result, val[0] }
| DEFAULT { result = Factory.literal(:default); loc result, val[0] }
| regex
# Produces Array
parameter_list
: nil { result = [] }
| LPAREN RPAREN { result = [] }
| LPAREN parameters endcomma RPAREN { result = val[1] }
# Produces Array
parameters
: parameter { result = [val[0]] }
| parameters COMMA parameter { result = val[0].push(val[2]) }
# Produces Model::Parameter
parameter
: VARIABLE EQUALS expression { result = Factory.PARAM(val[0][:value], val[2]) ; loc result, val[0] }
| VARIABLE { result = Factory.PARAM(val[0][:value]); loc result, val[0] }
# Produces Expression, since hostname is an Expression
nodeparent
: nil
| INHERITS hostname { result = val[1] }
# Produces String, name or nil result
classparent
: nil
| INHERITS classnameordefault { result = val[1] }
# Produces String (this construct allows a class to be named "default" and to be referenced as
# the parent class.
# TODO: Investigate the validity
# Produces a String (classname), or a token (DEFAULT).
#
classnameordefault
: classname
| DEFAULT
rvalue
: quotedtext
| name
| type
| boolean
| selector
| variable
| array
| hasharrayaccesses
| resourceref
| call_named_rval_function
| undef
array
: LBRACK expressions RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[2] }
| LBRACK expressions COMMA RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
| LBRACK RBRACK { result = Factory.literal([]) ; loc result, val[0] }
hash
: LBRACE hashpairs RBRACE { result = Factory.HASH(val[1]); loc result, val[0], val[2] }
| LBRACE hashpairs COMMA RBRACE { result = Factory.HASH(val[1]); loc result, val[0], val[3] }
| LBRACE RBRACE { result = Factory.literal({}) ; loc result, val[0], val[3] }
hashpairs
: hashpair { result = [val[0]] }
| hashpairs COMMA hashpair { result = val[0].push val[2] }
hashpair
: key FARROW expression { result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1] }
key
: NAME { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
| quotedtext { result = val[0] }
# NOTE: Limitation that LHS is a variable, means that it is not possible to do foo(10)[2] without
# using an intermediate variable
#
hasharrayaccess
: variable LBRACK expression RBRACK { result = val[0][val[2]]; loc result, val[0], val[3] }
hasharrayaccesses
: hasharrayaccess
| hasharrayaccesses LBRACK expression RBRACK { result = val[0][val[2]] ; loc result, val[1], val[3] }
# Produces Model::VariableExpression
variable : VARIABLE { result = Factory.fqn(val[0][:value]).var ; loc result, val[0] }
undef : UNDEF { result = Factory.literal(:undef); loc result, val[0] }
name : NAME { result = Factory.QNAME_OR_NUMBER(val[0][:value]) ; loc result, val[0] }
type : CLASSREF { result = Factory.QREF(val[0][:value]) ; loc result, val[0] }
default
: DEFAULT { result = Factory.literal(:default); loc result, val[0] }
boolean
# Assumes lexer produces a Boolean value for booleans, or this will go wrong (e.g. produce. LiteralString)
: BOOLEAN { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
regex
: REGEX { result = Factory.literal(val[0][:value]); loc result, val[0] }
# ---Special markers & syntactic sugar
# WAT !!!! this means array can be [1=>2=>3], func (1=>2=>3), and other retarded constructs
# TODO: Remove the FARROW (investigate if there is any validity)
comma
: FARROW
| COMMA
endcomma
: #
| COMMA { result = nil }
endsemi
: #
| SEMIC
nil
: { result = nil}
## Empty list - not really needed? TODO: Check if this can be removed
#empty_list
# : { result = [] }
end
---- header ----
require 'puppet'
require 'puppet/util/loadedfile'
require 'puppet/pops'
module Puppet
class ParseError < Puppet::Error; end
class ImportError < Racc::ParseError; end
class AlreadyImportedError < ImportError; end
end
---- inner ----
# Make emacs happy
# Local Variables:
# mode: ruby
# End:
puppet-3.4.3/lib/puppet/pops/binder/ 0000755 0052762 0001160 00000000000 12300765640 017240 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/pops/binder/binder_issues.rb 0000644 0052762 0001160 00000011502 12300765631 022422 0 ustar jenkins jenkins # @api public
module Puppet::Pops::Binder::BinderIssues
# NOTE: The methods #issue and #hard_issue are done in a somewhat funny way
# since the Puppet::Pops::Issues is a module with these methods defined on the module-class
# This makes it hard to inherit them in this module. (Likewise if Issues was a class, and they
# need to be defined for the class, and such methods are also not inherited, it becomes more
# difficult to reuse these. It did not seem as a good idea to refactor Issues at this point
# in time - they should both probably be refactored once bindings support is finished.
# Meanwhile, they delegate to Issues.
# (see Puppet::Pops::Issues#issue)
def self.issue (issue_code, *args, &block)
Puppet::Pops::Issues.issue(issue_code, *args, &block)
end
# (see Puppet::Pops::Issues#hard_issue)
def self.hard_issue(issue_code, *args, &block)
Puppet::Pops::Issues.hard_issue(issue_code, *args, &block)
end
# Producer issues (binding identified using :binding argument)
# @api public
MISSING_NAME = issue :MISSING_NAME, :binding do
"#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no name"
end
# @api public
MISSING_KEY = issue :MISSING_KEY, :binding do
"#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no key"
end
# @api public
MISSING_VALUE = issue :MISSING_VALUE, :binding do
"#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no value"
end
# @api public
MISSING_EXPRESSION = issue :MISSING_EXPRESSION, :binding do
"#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no expression"
end
# @api public
MISSING_CLASS_NAME = issue :MISSING_CLASS_NAME, :binding do
"#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no class name"
end
# @api public
CACHED_PRODUCER_MISSING_PRODUCER = issue :PRODUCER_MISSING_PRODUCER, :binding do
"#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no producer"
end
# @api public
INCOMPATIBLE_TYPE = issue :INCOMPATIBLE_TYPE, :binding, :expected_type, :actual_type do
"#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has an incompatible type: expected #{label.a_an(expected_type)}, but got #{label.a_an(actual_type)}."
end
# @api public
MULTIBIND_INCOMPATIBLE_TYPE = issue :MULTIBIND_INCOMPATIBLE_TYPE, :binding, :actual_type do
"#{label.a_an_uc(binding)} with #{label.a_an(semantic)} cannot bind #{label.a_an(actual_type)} value"
end
# @api public
MODEL_OBJECT_IS_UNBOUND = issue :MODEL_OBJECT_IS_UNBOUND do
"#{label.a_an_uc(semantic)} is not contained in a binding"
end
# Binding issues (binding identified using semantic)
# @api public
MISSING_PRODUCER = issue :MISSING_PRODUCER do
"#{label.a_an_uc(semantic)} has no producer"
end
# @api public
MISSING_TYPE = issue :MISSING_TYPE do
"#{label.a_an_uc(semantic)} has no type"
end
# @api public
MULTIBIND_NOT_COLLECTION_PRODUCER = issue :MULTIBIND_NOT_COLLECTION_PRODUCER, :actual_producer do
"#{label.a_an_uc(semantic)} must have a MultibindProducerDescriptor, but got: #{label.a_an(actual_producer)}"
end
# @api public
MULTIBIND_TYPE_ERROR = issue :MULTIBIND_TYPE_ERROR, :actual_type do
"#{label.a_an_uc(semantic)} is expected to bind a collection type, but got: #{label.a_an(actual_type)}."
end
# @api public
MISSING_BINDINGS = issue :MISSING_BINDINGS do
"#{label.a_an_uc(semantic)} has zero bindings"
end
# @api public
MISSING_BINDINGS_NAME = issue :MISSING_BINDINGS_NAME do
"#{label.a_an_uc(semantic)} has no name"
end
# @api public
MISSING_PREDICATES = issue :MISSING_PREDICATES do
"#{label.a_an_uc(semantic)} has zero predicates"
end
# @api public
MISSING_CATEGORIZATION = issue :MISSING_CATEGORIZATION do
"#{label.a_an_uc(semantic)} has a category without categorization"
end
# @api public
MISSING_CATEGORY_VALUE = issue :MISSING_CATEGORY_VALUE do
"#{label.a_an_uc(semantic)} has a category without value"
end
# @api public
MISSING_LAYERS = issue :MISSING_LAYERS do
"#{label.a_an_uc(semantic)} has zero layers"
end
# @api public
MISSING_LAYER_NAME = issue :MISSING_LAYER_NAME do
"#{label.a_an_uc(semantic)} has a layer without name"
end
# @api public
MISSING_BINDINGS_IN_LAYER = issue :MISSING_BINDINGS_IN_LAYER, :layer do
"#{label.a_an_uc(semantic)} has zero bindings in #{label.label(layer)}"
end
# @api public
PRECEDENCE_MISMATCH_IN_CONTRIBUTION = issue :PRECEDENCE_MISMATCH_IN_CONTRIBUTION, :categorization do
"Precedence mismatch: binding contribution '#{semantic.name}', category: '#{categorization}' is not in correct order"
end
# @api public
MISSING_CATEGORY_PRECEDENCE = issue :MISSING_CATEGORY_PRECEDENCE, :categorization do
"Missing category precedence: binding contribution '#{semantic.name}', category: '#{categorization}' not found in overall config"
end
end puppet-3.4.3/lib/puppet/pops/binder/bindings_model.rb 0000644 0052762 0001160 00000016073 12300765631 022551 0 ustar jenkins jenkins require 'rgen/metamodel_builder'
# The Bindings model is a model of Key to Producer mappings (bindings).
# The central concept is that a Bindings is a nested structure of bindings.
# A top level Bindings should be a NamedBindings (the name is used primarily
# in error messages). A Key is a Type/Name combination.
#
# TODO: In this version, references to "any object" uses the class Object,
# but this is only temporary. The intent is to use specific Puppet Objects
# that are typed using the Puppet Type System (to enable serialization).
#
# @see Puppet::Pops::Binder::BindingsFactory The BindingsFactory for more details on how to create model instances.
# @api public
module Puppet::Pops::Binder::Bindings
# @abstract
# @api public
#
class AbstractBinding < Puppet::Pops::Model::PopsObject
abstract
end
# An abstract producer
# @abstract
# @api public
#
class ProducerDescriptor < Puppet::Pops::Model::PopsObject
abstract
contains_one_uni 'transformer', Puppet::Pops::Model::LambdaExpression
end
# All producers are singleton producers unless wrapped in a non caching producer
# where each lookup produces a new instance. It is an error to have a nesting level > 1
# and to nest a NonCachingProducerDescriptor.
#
# @api public
#
class NonCachingProducerDescriptor < ProducerDescriptor
contains_one_uni 'producer', ProducerDescriptor
end
# Produces a constant value (i.e. something of {Puppet::Pops::Types::PDataType PDataType})
# @api public
#
class ConstantProducerDescriptor < ProducerDescriptor
# TODO: This should be a typed Puppet Object
has_attr 'value', Object
end
# Produces a value by evaluating a Puppet DSL expression
# @api public
#
class EvaluatingProducerDescriptor < ProducerDescriptor
contains_one_uni 'expression', Puppet::Pops::Model::Expression
end
# An InstanceProducer creates an instance of the given class
# Arguments are passed to the class' `new` operator in the order they are given.
# @api public
#
class InstanceProducerDescriptor < ProducerDescriptor
# TODO: This should be a typed Puppet Object ??
has_many_attr 'arguments', Object, :upperBound => -1
has_attr 'class_name', String
end
# A ProducerProducerDescriptor, describes that the produced instance is itself a Producer
# that should be used to produce the value.
# @api public
#
class ProducerProducerDescriptor < ProducerDescriptor
contains_one_uni 'producer', ProducerDescriptor, :lowerBound => 1
end
# Produces a value by looking up another key (type/name)
# @api public
#
class LookupProducerDescriptor < ProducerDescriptor
contains_one_uni 'type', Puppet::Pops::Types::PObjectType
has_attr 'name', String
end
# Produces a value by looking up another multibound key, and then looking up
# the detail using a detail_key.
# This is used to produce a specific service of a given type (such as a SyntaxChecker for the syntax "json").
# @api public
#
class HashLookupProducerDescriptor < LookupProducerDescriptor
has_attr 'key', String
end
# Produces a value by looking up each producer in turn. The first existing producer wins.
# @api public
#
class FirstFoundProducerDescriptor < ProducerDescriptor
contains_many_uni 'producers', LookupProducerDescriptor
end
# @api public
# @abstract
class MultibindProducerDescriptor < ProducerDescriptor
abstract
end
# Used in a Multibind of Array type unless it has a producer. May explicitly be used as well.
# @api public
#
class ArrayMultibindProducerDescriptor < MultibindProducerDescriptor
end
# Used in a Multibind of Hash type unless it has a producer. May explicitly be used as well.
# @api public
#
class HashMultibindProducerDescriptor < MultibindProducerDescriptor
end
# Plays the role of "Hash[String, Object] entry" but with keys in defined order.
#
# @api public
#
class NamedArgument < Puppet::Pops::Model::PopsObject
has_attr 'name', String, :lowerBound => 1
has_attr 'value', Object, :lowerBound => 1
end
# Binds a type/name combination to a producer. Optionally marking the bindidng as being abstract, or being an
# override of another binding. Optionally, the binding defines producer arguments passed to the producer when
# it is created.
#
# @api public
class Binding < AbstractBinding
contains_one_uni 'type', Puppet::Pops::Types::PObjectType
has_attr 'name', String
has_attr 'override', Boolean
has_attr 'abstract', Boolean
# If set is a contribution in a multibind
has_attr 'multibind_id', String, :lowerBound => 0
# Invariant: Only multibinds may have lowerBound 0, all regular Binding must have a producer.
contains_one_uni 'producer', ProducerDescriptor, :lowerBound => 0
contains_many_uni 'producer_args', NamedArgument, :lowerBound => 0
end
# A multibinding is a binding other bindings can contribute to.
#
# @api public
class Multibinding < Binding
has_attr 'id', String
end
# A container of Binding instances
# @api public
#
class Bindings < AbstractBinding
contains_many_uni 'bindings', AbstractBinding
end
# The top level container of bindings can have a name (for error messages, logging, tracing).
# May be nested.
# @api public
#
class NamedBindings < Bindings
has_attr 'name', String
end
# A category predicate (the request has to be in this category).
# @api public
#
class Category < Puppet::Pops::Model::PopsObject
has_attr 'categorization', String, :lowerBound => 1
has_attr 'value', String, :lowerBound => 1
end
# A container of Binding instances that are in effect when the
# predicates (min one) evaluates to true. Multiple predicates are handles as an 'and'.
# Note that 'or' semantics are handled by repeating the same rules.
# @api public
#
class CategorizedBindings < Bindings
contains_many_uni 'predicates', Category, :lowerBound => 1
end
# A named layer of bindings having the same priority.
# @api public
class NamedLayer < Puppet::Pops::Model::PopsObject
has_attr 'name', String, :lowerBound => 1
contains_many_uni 'bindings', NamedBindings
end
# A list of layers with bindings in descending priority order.
# @api public
#
class LayeredBindings < Puppet::Pops::Model::PopsObject
contains_many_uni 'layers', NamedLayer
end
# A list of categories consisting of categroization name and category value (i.e. the *state of the request*)
# @api public
#
class EffectiveCategories < Puppet::Pops::Model::PopsObject
# The order is from highest precedence to lowest
contains_many_uni 'categories', Category
end
# ContributedBindings is a named container of one or more NamedBindings.
# The intent is that a bindings producer returns a ContributedBindings which in addition to the bindings
# may optionally contain provider's opinion about the precedence of categories, and their category values.
# This enables merging of bindings, and validation of consistency.
#
# @api public
#
class ContributedBindings < NamedLayer
contains_one_uni 'effective_categories', EffectiveCategories
end
end
puppet-3.4.3/lib/puppet/pops/binder/key_factory.rb 0000644 0052762 0001160 00000002546 12300765631 022113 0 ustar jenkins jenkins # The KeyFactory is responsible for creating keys used for lookup of bindings.
# @api public
#
class Puppet::Pops::Binder::KeyFactory
attr_reader :type_calculator
# @api public
def initialize(type_calculator = Puppet::Pops::Types::TypeCalculator.new())
@type_calculator = type_calculator
end
# @api public
def binding_key(binding)
named_key(binding.type, binding.name)
end
# @api public
def named_key(type, name)
[(@type_calculator.assignable?(@type_calculator.data, type) ? @type_calculator.data : type), name]
end
# @api public
def data_key(name)
[@type_calculator.data, name]
end
# @api public
def is_contributions_key?(s)
return false unless s.is_a?(String)
s.start_with?('mc_')
end
# @api public
def multibind_contributions(multibind_id)
"mc_#{multibind_id}"
end
# @api public
def is_named?(key)
key.is_a?(Array) && key[1] && !key[1].empty?
end
# @api public
def is_data?(key)
return false unless key.is_a?(Array) && key[0].is_a?(Puppet::Pops::Types::PObjectType)
type_calculator.assignable?(type_calculator.data(), key[0])
end
# @api public
def is_ruby?(key)
return key.is_a?(Array) && key[0].is_a?(Puppet::Pops::Types::PRubyType)
end
# Returns the type of the key
# @api public
#
def get_type(key)
return nil unless key.is_a?(Array)
key[0]
end
end puppet-3.4.3/lib/puppet/pops/binder/bindings_factory.rb 0000644 0052762 0001160 00000102311 12300765631 023107 0 ustar jenkins jenkins # A helper class that makes it easier to construct a Bindings model.
#
# The Bindings Model
# ------------------
# The BindingsModel (defined in {Puppet::Pops::Binder::Bindings} is a model that is intended to be generally free from Ruby concerns.
# This means that it is possible for system integrators to create and serialize such models using other technologies than
# Ruby. This manifests itself in the model in that producers are described using instances of a `ProducerDescriptor` rather than
# describing Ruby classes directly. This is also true of the type system where type is expressed using the {Puppet::Pops::Types} model
# to describe all types.
#
# This class, the `BindingsFactory` is a concrete Ruby API for constructing instances of classes in the model.
#
# Named Bindings
# --------------
# The typical usage of the factory is to call {named_bindings} which creates a container of bindings wrapped in a *build object*
# equipped with convenience methods to define the details of the just created named bindings.
# The returned builder is an instance of {Puppet::Pops::Binder::BindingsFactory::BindingsContainerBuilder BindingsContainerBuilder}.
#
# Binding
# -------
# A Binding binds a type/name key to a producer of a value. A binding is conveniently created by calling `bind` on a
# `BindingsContainerBuilder`. The call to bind, produces a binding wrapped in a build object equipped with convenience methods
# to define the details of the just created binding. The returned builder is an instance of
# {Puppet::Pops::Binder::BindingsFactory::BindingsBuilder BindingsBuilder}.
#
# Multibinding
# ------------
# A multibinding works like a binding, but it requires an additional ID. It also places constraints on the type of the binding;
# it must be a collection type (Hash or Array).
#
# Constructing and Contributing Bindings from Ruby
# ------------------------------------------------
# The bindings system is used by referencing bindings symbolically; these are then specified in a Ruby file which is autoloaded
# by Puppet. The entry point for user code that creates bindings is described in {Puppet::Bindings Bindings}.
# That class makes use of a BindingsFactory, and the builder objects to make it easy to construct bindings.
#
# It is intended that a user defining bindings in Ruby should be able to use the builder object methods for the majority of tasks.
# If something advanced is wanted, use of one of the helper class methods on the BuildingsFactory, and/or the
# {Puppet::Pops::Types::TypeCalculator TypeCalculator} will be required to create and configure objects that are not handled by
# the methods in the builder objects.
#
# Chaining of calls
# ------------------
# Since all the build methods return the build object it is easy to stack on additional calls. The intention is to
# do this in an order that is readable from left to right: `bind.string.name('thename').to(42)`, but there is nothing preventing
# making the calls in some other order e.g. `bind.to(42).name('thename').string`, the second is quite unreadable but produces
# the same result.
#
# For sake of human readability, the method `name` is alsp available as `named`, with the intention that it is used after a type,
# e.g. `bind.integer.named('the meaning of life').to(42)`
#
# Methods taking blocks
# ----------------------
# Several methods take an optional block. The block evaluates with the builder object as `self`. This means that there is no
# need to chain the methods calls, they can instead be made in sequence - e.g.
#
# bind do
# integer
# named 'the meaning of life'
# to 42
# end
#
# or mix the two styles
#
# bind do
# integer.named 'the meaning of life'
# to 42
# end
#
# Unwrapping the result
# ---------------------
# The result from all methods is a builder object. Call the method `model` to unwrap the constructed bindings model object.
#
# bindings = BindingsFactory.named_bindings('my named bindings') do
# # bind things
# end.model
#
# @example Create a NamedBinding with content
# result = Puppet::Pops::Binder::BindingsFactory.named_bindings("mymodule::mybindings") do
# bind.name("foo").to(42)
# when_in_category("node", "kermit.example.com").bind.name("foo").to(43)
# bind.string.name("site url").to("http://www.example.com")
# end
# result.model()
#
# @api public
#
module Puppet::Pops::Binder::BindingsFactory
# Alias for the {Puppet::Pops::Types::TypeFactory TypeFactory}. This is also available as the method
# `type_factory`.
#
T = Puppet::Pops::Types::TypeFactory
# Abstract base class for bindings object builders.
# Supports delegation of method calls to the BindingsFactory class methods for all methods not implemented
# by a concrete builder.
#
# @abstract
#
class AbstractBuilder
# The built model object.
attr_reader :model
# @param binding [Puppet::Pops::Binder::Bindings::AbstractBinding] The binding to build.
# @api public
def initialize(binding)
@model = binding
end
# Provides convenient access to the Bindings Factory class methods. The intent is to provide access to the
# methods that return producers for the purpose of composing more elaborate things than the builder convenience
# methods support directly.
# @api private
#
def method_missing(meth, *args, &block)
factory = Puppet::Pops::Binder::BindingsFactory
if factory.respond_to?(meth)
factory.send(meth, *args, &block)
else
super
end
end
end
# A bindings builder for an AbstractBinding containing other AbstractBinding instances.
# @api public
class BindingsContainerBuilder < AbstractBuilder
# Adds an empty binding to the container, and returns a builder for it for further detailing.
# An optional block may be given which is evaluated using `instance_eval`.
# @return [BindingsBuilder] the builder for the created binding
# @api public
#
def bind(&block)
binding = Puppet::Pops::Binder::Bindings::Binding.new()
model.addBindings(binding)
builder = BindingsBuilder.new(binding)
builder.instance_eval(&block) if block_given?
builder
end
# Binds a multibind with the given identity where later, the looked up result contains all
# contributions to this key. An optional block may be given which is evaluated using `instance_eval`.
# @param id [String] the multibind's id used when adding contributions
# @return [MultibindingsBuilder] the builder for the created multibinding
# @api public
#
def multibind(id, &block)
binding = Puppet::Pops::Binder::Bindings::Multibinding.new()
binding.id = id
model.addBindings(binding)
builder = MultibindingsBuilder.new(binding)
builder.instance_eval(&block) if block_given?
builder
end
# Adds a categorized bindings to this container. Returns a BindingsContainerBuilder to allow adding
# bindings in the newly created container. An optional block may be given which is evaluated using `instance_eval`.
# @param categorization [String] the name of the categorization e.g. 'node'
# @param category_value [String] the value in that category e.g. 'kermit.example.com'
# @return [BindingsContainerBuilder] the builder for the created categorized bindings container
# @api public
#
def when_in_category(categorization, category_value, &block)
when_in_categories({categorization => category_value}, &block)
end
# Adds a categorized bindings to this container. Returns a BindingsContainerBuilder to allow adding
# bindings in the newly created container.
# The result is that a processed request must match all the given categorizations
# with the given values. An optional block may be given which is evaluated using `instance_eval`.
# @param categories_hash Hash[String, String] a hash with categorization and categorization value entries
# @return [BindingsContainerBuilder] the builder for the created categorized bindings container
# @api public
#
def when_in_categories(categories_hash, &block)
binding = Puppet::Pops::Binder::Bindings::CategorizedBindings.new()
categories_hash.each do |k,v|
pred = Puppet::Pops::Binder::Bindings::Category.new()
pred.categorization = k
pred.value = v
binding.addPredicates(pred)
end
model.addBindings(binding)
builder = BindingsContainerBuilder.new(binding)
builder.instance_eval(&block) if block_given?
builder
end
end
# Builds a Binding via convenience methods.
#
# @api public
#
class BindingsBuilder < AbstractBuilder
# @param binding [Puppet::Pops::Binder::Bindings::AbstractBinding] the binding to build.
# @api public
def initialize(binding)
super binding
data()
end
# Sets the name of the binding.
# @param name [String] the name to bind.
# @api public
def name(name)
model.name = name
self
end
# Same as {#name}, but reads better in certain combinations.
# @api public
alias_method :named, :name
# Sets the binding to be abstract (it must be overridden)
# @api public
def abstract
model.abstract = true
self
end
# Sets the binding to be override (it must override something)
# @api public
def override
model.override = true
self
end
# Makes the binding a multibind contribution to the given multibind id
# @param id [String] the multibind id to contribute this binding to
# @api public
def in_multibind(id)
model.multibind_id = id
self
end
# Sets the type of the binding to the given type.
# @note
# This is only needed if something other than the default type `Data` is wanted, or if the wanted type is
# not provided by one of the convenience methods {#array_of_data}, {#boolean}, {#float}, {#hash_of_data},
# {#integer}, {#literal}, {#pattern}, {#string}, or one of the collection methods {#array_of}, or {#hash_of}.
#
# To create a type, use the method {#type_factory}, to obtain the type.
# @example creating a Hash with Integer key and Array[Integer] element type
# tc = type_factory
# type(tc.hash(tc.array_of(tc.integer), tc.integer)
# @param type [Puppet::Pops::Types::PObjectType] the type to set for the binding
# @api public
#
def type(type)
model.type = type
self
end
# Sets the type of the binding to Integer.
# @return [Puppet::Pops::Types::PIntegerType] the type
# @api public
def integer()
type(T.integer())
end
# Sets the type of the binding to Float.
# @return [Puppet::Pops::Types::PFloatType] the type
# @api public
def float()
type(T.float())
end
# Sets the type of the binding to Boolean.
# @return [Puppet::Pops::Types::PBooleanType] the type
# @api public
def boolean()
type(T.boolean())
end
# Sets the type of the binding to String.
# @return [Puppet::Pops::Types::PStringType] the type
# @api public
def string()
type(T.string())
end
# Sets the type of the binding to Pattern.
# @return [Puppet::Pops::Types::PPatternType] the type
# @api public
def pattern()
type(T.pattern())
end
# Sets the type of the binding to the abstract type Literal.
# @return [Puppet::Pops::Types::PLiteralType] the type
# @api public
def literal()
type(T.literal())
end
# Sets the type of the binding to the abstract type Data.
# @return [Puppet::Pops::Types::PDataType] the type
# @api public
def data()
type(T.data())
end
# Sets the type of the binding to Array[Data].
# @return [Puppet::Pops::Types::PArrayType] the type
# @api public
def array_of_data()
type(T.array_of_data())
end
# Sets the type of the binding to Array[T], where T is given.
# @param t [Puppet::Pops::Types::PObjectType] the type of the elements of the array
# @return [Puppet::Pops::Types::PArrayType] the type
# @api public
def array_of(t)
type(T.array_of(t))
end
# Sets the type of the binding to Hash[Literal, Data].
# @return [Puppet::Pops::Types::PHashType] the type
# @api public
def hash_of_data()
type(T.hash_of_data())
end
# Sets type of the binding to `Hash[Literal, t]`.
# To also limit the key type, use {#type} and give it a fully specified
# hash using {#type_factory} and then `hash_of(value_type, key_type)`.
# @return [Puppet::Pops::Types::PHashType] the type
# @api public
def hash_of(t)
type(T.hash_of(t))
end
# Sets the type of the binding based on the given argument.
# @overload instance_of(t)
# The same as calling {#type} with `t`.
# @param t [Puppet::Pops::Types::PObjectType] the type
# @overload instance_of(o)
# Infers the type from the given Ruby object and sets that as the type - i.e. "set the type
# of the binding to be that of the given data object".
# @param o [Object] the object to infer the type from
# @overload instance_of(c)
# @param c [Class] the Class to base the type on.
# Sets the type based on the given ruby class. The result is one of the specific puppet types
# if the class can be represented by a specific type, or the open ended PRubyType otherwise.
# @overload instance_of(s)
# The same as using a class, but instead of giving a class instance, the class is expressed using its fully
# qualified name. This method of specifying the type allows late binding (the class does not have to be loaded
# before it can be used in a binding).
# @param s [String] the fully qualified classname to base the type on.
# @return the resulting type
# @api public
#
def instance_of(t)
type(T.type_of(t))
end
# Provides convenient access to the type factory.
# This is intended to be used when methods taking a type as argument i.e. {#type}, {#array_of}, {#hash_of}, and {#instance_of}.
# @note
# The type factory is also available via the constant {T}.
# @api public
def type_factory
Puppet::Pops::Types::TypeFactory
end
# Sets the binding's producer to a singleton producer, if given argument is a value, a literal producer is created for it.
# To create a producer producing an instance of a class with lazy loading of the class, use {#to_instance}.
#
# @overload to(a_literal)
# Sets a constant producer in the binding.
# @overload to(a_class, *args)
# Sets an Instantiating producer (producing an instance of the given class)
# @overload to(a_producer_descriptor)
# Sets the producer from the given producer descriptor
# @return [BindingsBuilder] self
# @api public
#
def to(producer, *args)
case producer
when Class
producer = Puppet::Pops::Binder::BindingsFactory.instance_producer(producer.name, *args)
when Puppet::Pops::Model::Expression
producer = Puppet::Pops::Binder::BindingsFactory.evaluating_producer(producer)
when Puppet::Pops::Binder::Bindings::ProducerDescriptor
else
# If given producer is not a producer, create a literal producer
producer = Puppet::Pops::Binder::BindingsFactory.literal_producer(producer)
end
model.producer = producer
self
end
# Sets the binding's producer to a producer of an instance of given class (a String class name, or a Class instance).
# Use a string class name when lazy loading of the class is wanted.
#
# @overload to_instance(class_name, *args)
# @param class_name [String] the name of the class to instantiate
# @param args [Object] optional arguments to the constructor
# @overload to_instance(a_class)
# @param a_class [Class] the class to instantiate
# @param args [Object] optional arguments to the constructor
#
def to_instance(type, *args)
class_name = case type
when Class
type.name
when String
type
else
raise ArgumentError, "to_instance accepts String (a class name), or a Class.*args got: #{type.class}."
end
model.producer = Puppet::Pops::Binder::BindingsFactory.instance_producer(class_name, *args)
end
# Sets the binding's producer to a singleton producer
# @overload to_producer(a_producer)
# Sets the producer to an instantiated producer. The resulting model can not be serialized as a consequence as there
# is no meta-model describing the specialized producer. Use this only in exceptional cases, or where there is never the
# need to serialize the model.
# @param a_producer [Puppet::Pops::Binder::Producers::Producer] an instantiated producer, not serializeable !
#
# @overload to_producer(a_class, *args)
# @param a_class [Class] the class to create an instance of
# @param args [Object] the arguments to the given class' new
#
# @overload to_producer(a_producer_descriptor)
# @param a_producer_descriptor [Puppet::Pops::Binder::Bindings::ProducerDescriptor] a descriptor
# producing Puppet::Pops::Binder::Producers::Producer
#
# @api public
#
def to_producer(producer, *args)
case producer
when Class
producer = Puppet::Pops::Binder::BindingsFactory.instance_producer(producer.name, *args)
when Puppet::Pops::Binder::Bindings::ProducerDescriptor
when Puppet::Pops::Binder::Producers::Producer
# a custom producer instance
producer = Puppet::Pops::Binder::BindingsFactory.literal_producer(producer)
else
raise ArgumentError, "Given producer argument is none of a producer descriptor, a class, or a producer"
end
metaproducer = Puppet::Pops::Binder::BindingsFactory.producer_producer(producer)
model.producer = metaproducer
self
end
# Sets the binding's producer to a series of producers.
# Use this when you want to produce a different producer on each request for a producer
#
# @overload to_producer(a_producer)
# Sets the producer to an instantiated producer. The resulting model can not be serialized as a consequence as there
# is no meta-model describing the specialized producer. Use this only in exceptional cases, or where there is never the
# need to serialize the model.
# @param a_producer [Puppet::Pops::Binder::Producers::Producer] an instantiated producer, not serializeable !
#
# @overload to_producer(a_class, *args)
# @param a_class [Class] the class to create an instance of
# @param args [Object] the arguments to the given class' new
#
# @overload to_producer(a_producer_descriptor)
# @param a_producer_descriptor [Puppet::Pops::Binder::Bindings::ProducerDescriptor] a descriptor
# producing Puppet::Pops::Binder::Producers::Producer
#
# @api public
#
def to_producer_series(producer, *args)
case producer
when Class
producer = Puppet::Pops::Binder::BindingsFactory.instance_producer(producer.name, *args)
when Puppet::Pops::Binder::Bindings::ProducerDescriptor
when Puppet::Pops::Binder::Producers::Producer
# a custom producer instance
producer = Puppet::Pops::Binder::BindingsFactory.literal_producer(producer)
else
raise ArgumentError, "Given producer argument is none of a producer descriptor, a class, or a producer"
end
non_caching = Puppet::Pops::Binder::Bindings::NonCachingProducerDescriptor.new()
non_caching.producer = producer
metaproducer = Puppet::Pops::Binder::BindingsFactory.producer_producer(non_caching)
non_caching = Puppet::Pops::Binder::Bindings::NonCachingProducerDescriptor.new()
non_caching.producer = metaproducer
model.producer = non_caching
self
end
# Sets the binding's producer to a "non singleton" producer (each call to produce produces a new instance/copy).
# @overload to_series_of(a_literal)
# a constant producer
# @overload to_series_of(a_class, *args)
# Instantiating producer
# @overload to_series_of(a_producer_descriptor)
# a given producer
#
# @api public
#
def to_series_of(producer, *args)
case producer
when Class
producer = Puppet::Pops::Binder::BindingsFactory.instance_producer(producer.name, *args)
when Puppet::Pops::Binder::Bindings::ProducerDescriptor
else
# If given producer is not a producer, create a literal producer
producer = Puppet::Pops::Binder::BindingsFactory.literal_producer(producer)
end
non_caching = Puppet::Pops::Binder::Bindings::NonCachingProducerDescriptor.new()
non_caching.producer = producer
model.producer = non_caching
self
end
# Sets the binding's producer to one that performs a lookup of another key
# @overload to_lookup_of(type, name)
# @overload to_lookup_of(name)
# @api public
#
def to_lookup_of(type, name=nil)
unless name
name = type
type = Puppet::Pops::Types::TypeFactory.data()
end
model.producer = Puppet::Pops::Binder::BindingsFactory.lookup_producer(type, name)
self
end
# Sets the binding's producer to a one that performs a lookup of another key and they applies hash lookup on
# the result.
#
# @overload to_lookup_of(type, name)
# @overload to_lookup_of(name)
# @api public
#
def to_hash_lookup_of(type, name, key)
model.producer = Puppet::Pops::Binder::BindingsFactory.hash_lookup_producer(type, name, key)
self
end
# Sets the binding's producer to one that produces the first found lookup of another key
# @param list_of_lookups [Array] array of arrays [type name], or just name (implies data)
# @example
# binder.bind().name('foo').to_first_found('fee', 'fum', 'extended-bar')
# binder.bind().name('foo').to_first_found(
# [T.ruby(ThisClass), 'fee'],
# [T.ruby(ThatClass), 'fum'],
# 'extended-bar')
# @api public
#
def to_first_found(*list_of_lookups)
producers = list_of_lookups.collect do |entry|
if entry.is_a?(Array)
case entry.size
when 2
Puppet::Pops::Binder::BindingsFactory.lookup_producer(entry[0], entry[1])
when 1
Puppet::Pops::Binder::BindingsFactory.lookup_producer(Puppet::Pops::Types::TypeFactory.data(), entry[0])
else
raise ArgumentError, "Not an array of [type, name], name, or [name]"
end
else
Puppet::Pops::Binder::BindingsFactory.lookup_producer(T.data(), entry)
end
end
model.producer = Puppet::Pops::Binder::BindingsFactory.first_found_producer(*producers)
self
end
# Sets options to the producer.
# See the respective producer for the options it supports. All producers supports the option `:transformer`, a
# puppet or ruby lambda that is evaluated with the produced result as an argument. The ruby lambda gets scope and
# value as arguments.
# @note
# A Ruby lambda is not cross platform safe. Use a puppet lambda if you want a bindings model that is.
#
# @api public
def producer_options(options)
options.each do |k, v|
arg = Puppet::Pops::Binder::Bindings::NamedArgument.new()
arg.name = k.to_s
arg.value = v
model.addProducer_args(arg)
end
self
end
end
# A builder specialized for multibind - checks that type is Array or Hash based. A new builder sets the
# multibinding to be of type Hash[Data].
#
# @api public
class MultibindingsBuilder < BindingsBuilder
# Constraints type to be one of {Puppet::Pops::Types::PArrayType PArrayType}, or {Puppet::Pops::Types::PHashType PHashType}.
# @raise [ArgumentError] if type constraint is not met.
# @api public
def type(type)
unless type.class == Puppet::Pops::Types::PArrayType || type.class == Puppet::Pops::Types::PHashType
raise ArgumentError, "Wrong type; only PArrayType, or PHashType allowed, got '#{type.to_s}'"
end
model.type = type
self
end
# Overrides the default implementation that will raise an exception as a multibind requires a hash type.
# Thus, if nothing else is requested, a multibind will be configured as Hash[Data].
#
def data()
hash_of_data()
end
end
# Produces a ContributedBindings.
# A ContributedBindings is used by bindings providers to return a set of named bindings.
#
# @param name [String] the name of the contributed bindings (for human use in messages/logs only)
# @param named_bindings [Puppet::Pops::Binder::Bindings::NamedBindings, Array] the
# named bindings to include
# @param effective_categories [Puppet::Pops::Binder::Bindings::EffectiveCategories] the contributors opinion about categorization
# this is used to ensure consistent use of categories.
#
def self.contributed_bindings(name, named_bindings, effective_categories)
cb = Puppet::Pops::Binder::Bindings::ContributedBindings.new()
cb.name = name
named_bindings = [named_bindings] unless named_bindings.is_a?(Array)
named_bindings.each {|b| cb.addBindings(b) }
cb.effective_categories = effective_categories
cb
end
# Creates a named binding container, the top bindings model object.
# A NamedBindings is typically produced by a bindings provider.
#
# The created container is wrapped in a BindingsContainerBuilder for further detailing.
# Unwrap the built result when done.
# @api public
#
def self.named_bindings(name, &block)
binding = Puppet::Pops::Binder::Bindings::NamedBindings.new()
binding.name = name
builder = BindingsContainerBuilder.new(binding)
builder.instance_eval(&block) if block_given?
builder
end
# This variant of {named_bindings} evaluates the given block as a method on an anonymous class,
# thus, if the block defines methods or do something with the class itself, this does not pollute
# the base class (BindingsContainerBuilder).
# @api private
#
def self.safe_named_bindings(name, scope, &block)
binding = Puppet::Pops::Binder::Bindings::NamedBindings.new()
binding.name = name
anon = Class.new(BindingsContainerBuilder) do
def initialize(b)
super b
end
end
anon.send(:define_method, :_produce, block)
builder = anon.new(binding)
case block.arity
when 0
builder._produce()
when 1
builder._produce(scope)
end
builder
end
# Creates a literal/constant producer
# @param value [Object] the value to produce
# @return [Puppet::Pops::Binder::Bindings::ProducerDescriptor] a producer description
# @api public
#
def self.literal_producer(value)
producer = Puppet::Pops::Binder::Bindings::ConstantProducerDescriptor.new()
producer.value = value
producer
end
# Creates a non caching producer
# @param producer [Puppet::Pops::Binder::Bindings::Producer] the producer to make non caching
# @return [Puppet::Pops::Binder::Bindings::ProducerDescriptor] a producer description
# @api public
#
def self.non_caching_producer(producer)
p = Puppet::Pops::Binder::Bindings::NonCachingProducerDescriptor.new()
p.producer = producer
p
end
# Creates a producer producer
# @param producer [Puppet::Pops::Binder::Bindings::Producer] a producer producing a Producer.
# @return [Puppet::Pops::Binder::Bindings::ProducerDescriptor] a producer description
# @api public
#
def self.producer_producer(producer)
p = Puppet::Pops::Binder::Bindings::ProducerProducerDescriptor.new()
p.producer = producer
p
end
# Creates an instance producer
# An instance producer creates a new instance of a class.
# If the class implements the class method `inject` this method is called instead of `new` to allow further lookups
# to take place. This is referred to as *assisted inject*. If the class method `inject` is missing, the regular `new` method
# is called.
#
# @param class_name [String] the name of the class
# @param args[Object] arguments to the class' `new` method.
# @return [Puppet::Pops::Binder::Bindings::ProducerDescriptor] a producer description
# @api public
#
def self.instance_producer(class_name, *args)
p = Puppet::Pops::Binder::Bindings::InstanceProducerDescriptor.new()
p.class_name = class_name
args.each {|a| p.addArguments(a) }
p
end
# Creates a Producer that looks up a value.
# @param type [Puppet::Pops::Types::PObjectType] the type to lookup
# @param name [String] the name to lookup
# @return [Puppet::Pops::Binder::Bindings::ProducerDescriptor] a producer description
# @api public
def self.lookup_producer(type, name)
p = Puppet::Pops::Binder::Bindings::LookupProducerDescriptor.new()
p.type = type
p.name = name
p
end
# Creates a Hash lookup producer that looks up a hash value, and then a key in the hash.
#
# @return [Puppet::Pops::Binder::Bindings::ProducerDescriptor] a producer description
# @param type [Puppet::Pops::Types::PObjectType] the type to lookup (i.e. a Hash of some key/value type).
# @param name [String] the name to lookup
# @param key [Object] the key to lookup in the looked up hash (type should comply with given key type).
# @api public
#
def self.hash_lookup_producer(type, name, key)
p = Puppet::Pops::Binder::Bindings::HashLookupProducerDescriptor.new()
p.type = type
p.name = name
p.key = key
p
end
# Creates a first-found producer that looks up from a given series of keys. The first found looked up
# value will be produced.
# @param producers [Array] the producers to consult in given order
# @return [Puppet::Pops::Binder::Bindings::ProducerDescriptor] a producer descriptor
# @api public
def self.first_found_producer(*producers)
p = Puppet::Pops::Binder::Bindings::FirstFoundProducerDescriptor.new()
producers.each {|p2| p.addProducers(p2) }
p
end
# Creates an evaluating producer that evaluates a puppet expression.
# A puppet expression is most conveniently created by using the {Puppet::Pops::Parser::EvaluatingParser EvaluatingParser} as it performs
# all set up and validation of the parsed source. Two convenience methods are used to parse an expression, or parse a ruby string
# as a puppet string. See methods {puppet_expression}, {puppet_string} and {parser} for more information.
#
# @example producing a puppet expression
# expr = puppet_string("Interpolated $fqdn", __FILE__)
#
# @param expression [Puppet::Pops::Model::Expression] a puppet DSL expression as producer by the eparser.
# @return [Puppet::Pops::Binder::Bindings::ProducerDescriptor] a producer descriptor
# @api public
#
def self.evaluating_producer(expression)
p = Puppet::Pops::Binder::Bindings::EvaluatingProducerDescriptor.new()
p.expression = expression
p
end
# Creates an EffectiveCategories from a list of tuples `[categorization category ...]`, or `[[categorization category] ...]`
# This method is used by backends to create a model of the effective categories.
# @api public
#
def self.categories(tuple_array)
result = Puppet::Pops::Binder::Bindings::EffectiveCategories.new()
tuple_array.flatten.each_slice(2) do |c|
cat = Puppet::Pops::Binder::Bindings::Category.new()
cat.categorization = c[0]
cat.value = c[1]
result.addCategories(cat)
end
result
end
# Creates a NamedLayer. This is used by the bindings system to create a model of the layers.
#
# @api public
#
def self.named_layer(name, *bindings)
result = Puppet::Pops::Binder::Bindings::NamedLayer.new()
result.name = name
bindings.each { |b| result.addBindings(b) }
result
end
# Create a LayeredBindings. This is used by the bindings system to create a model of all given layers.
# @param named_layers [Puppet::Pops::Binder::Bindings::NamedLayer] one or more named layers
# @return [Puppet::Pops::Binder::Bindings::LayeredBindings] the constructed layered bindings.
# @api public
#
def self.layered_bindings(*named_layers)
result = Puppet::Pops::Binder::Bindings::LayeredBindings.new()
named_layers.each {|b| result.addLayers(b) }
result
end
# @return [Puppet::Pops::Parser::EvaluatingParser] a parser for puppet expressions
def self.parser
@parser ||= Puppet::Pops::Parser::EvaluatingParser.new()
end
# Parses and produces a puppet expression from the given string.
# @param string [String] puppet source e.g. "1 + 2"
# @param source_file [String] the source location, typically `__File__`
# @return [Puppet::Pops::Model::Expression] an expression (that can be bound)
# @api public
#
def self.puppet_expression(string, source_file)
parser.parse_string(string, source_file).current
end
# Parses and produces a puppet string expression from the given string.
# The string will automatically be quoted and special characters escaped.
# As an example if given the (ruby) string "Hi\nMary" it is transformed to
# the puppet string (illustrated with a ruby string) "\"Hi\\nMary\”" before being
# parsed.
#
# @param string [String] puppet source e.g. "On node $!{fqdn}"
# @param source_file [String] the source location, typically `__File__`
# @return [Puppet::Pops::Model::Expression] an expression (that can be bound)
# @api public
#
def self.puppet_string(string, source_file)
parser.parse_string(parser.quote(string), source_file).current
end
end
puppet-3.4.3/lib/puppet/pops/binder/producers.rb 0000644 0052762 0001160 00000100370 12300765631 021574 0 ustar jenkins jenkins # This module contains the various producers used by Puppet Bindings.
# The main (abstract) class is {Puppet::Pops::Binder::Producers::Producer} which documents the
# Producer API and serves as a base class for all other producers.
# It is required that custom producers inherit from this producer (directly or indirectly).
#
# The selection of a Producer is typically performed by the Innjector when it configures itself
# from a Bindings model where a {Puppet::Pops::Binder::Bindings::ProducerDescriptor} describes
# which producer to use. The configuration uses this to create the concrete producer.
# It is possible to describe that a particular producer class is to be used, and also to describe that
# a custom producer (derived from Producer) should be used. This is available for both regular
# bindings as well as multi-bindings.
#
#
# @api public
#
module Puppet::Pops::Binder::Producers
# Producer is an abstract base class representing the base contract for a bound producer.
# Typically, when a lookup is performed it is the value that is returned (via a producer), but
# it is also possible to lookup the producer, and ask it to produce the value (the producer may
# return a series of values, which makes this especially useful).
#
# When looking up a producer, it is of importance to only use the API of the Producer class
# unless it is known that a particular custom producer class has been bound.
#
# Custom Producers
# ----------------
# The intent is that this class is derived for custom producers that require additional
# options/arguments when producing an instance. Such a custom producer may raise an error if called
# with too few arguments, or may implement specific `produce` methods and always raise an
# error on #produce indicating that this producer requires custom calls and that it can not
# be used as an implicit producer.
#
# Features of Producer
# --------------------
# The Producer class is abstract, but offers the ability to transform the produced result
# by passing the option `:transformer` which should be a Puppet Lambda Expression taking one argument
# and producing the transformed (wanted) result.
#
# @abstract
# @api public
#
class Producer
# A Puppet 3 AST Lambda Expression
# @api public
#
attr_reader :transformer
# Creates a Producer.
# Derived classes should call this constructor to get support for transformer lambda.
#
# @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
# @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
# @param scope [Puppet::Parser::Scope] The scope to use for evaluation
# @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
# @api public
#
def initialize(injector, binding, scope, options)
if transformer_lambda = options[:transformer]
if transformer_lambda.is_a?(Proc)
raise ArgumentError, "Transformer Proc must take two arguments; scope, value." unless transformer_lambda.arity == 2
@transformer = transformer_lambda
else
raise ArgumentError, "Transformer must be a LambdaExpression" unless transformer_lambda.is_a?(Puppet::Pops::Model::LambdaExpression)
raise ArgumentError, "Transformer lambda must take one argument; value." unless transformer_lambda.parameters.size() == 1
# NOTE: This depends on Puppet 3 AST Lambda
@transformer = Puppet::Pops::Model::AstTransformer.new().transform(transformer_lambda)
end
end
end
# Produces an instance.
# @param scope [Puppet::Parser:Scope] the scope to use for evaluation
# @param args [Object] arguments to custom producers, always empty for implicit productions
# @return [Object] the produced instance (should never be nil).
# @api public
#
def produce(scope, *args)
do_transformation(scope, internal_produce(scope))
end
# Returns the producer after possibly having recreated an internal/wrapped producer.
# This implementation returns `self`. A derived class may want to override this method
# to perform initialization/refresh of its internal state. This method is called when
# a producer is requested.
# @see Puppet::Pops::Binder::ProducerProducer for an example of implementation.
# @param scope [Puppet::Parser:Scope] the scope to use for evaluation
# @return [Puppet::Pops::Binder::Producer] the producer to use
# @api public
#
def producer(scope)
self
end
protected
# Derived classes should implement this method to do the production of a value
# @param scope [Puppet::Parser::Scope] the scope to use when performing lookup and evaluation
# @raise [NotImplementedError] this implementation always raises an error
# @abstract
# @api private
#
def internal_produce(scope)
raise NotImplementedError, "Producer-class '#{self.class.name}' should implement #internal_produce(scope)"
end
# Transforms the produced value if a transformer has been defined.
# @param scope [Puppet::Parser::Scope] the scope used for evaluation
# @param produced_value [Object, nil] the produced value (possibly nil)
# @return [Object] the transformed value if a transformer is defined, else the given `produced_value`
# @api private
#
def do_transformation(scope, produced_value)
return produced_value unless transformer
produced_value = :undef if produced_value.nil?
transformer.call(scope, produced_value)
end
end
# Abstract Producer holding a value
# @abstract
# @api public
#
class AbstractValueProducer < Producer
# @api public
attr_reader :value
# @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
# @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
# @param scope [Puppet::Parser::Scope] The scope to use for evaluation
# @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
# @option options [Puppet::Pops::Model::LambdaExpression, nil] :value (nil) the value to produce
# @api public
#
def initialize(injector, binding, scope, options)
super
# nil is ok here, as an abstract value producer may be used to signal "not found"
@value = options[:value]
end
end
# Produces the same/singleton value on each production
# @api public
#
class SingletonProducer < AbstractValueProducer
protected
# @api private
def internal_produce(scope)
value()
end
end
# Produces a deep clone of its value on each production.
# @api public
#
class DeepCloningProducer < AbstractValueProducer
protected
# @api private
def internal_produce(scope)
case value
when Integer, Float, TrueClass, FalseClass, Symbol
# These are immutable
return value
when String
# ok if frozen, else fall through to default
return value() if value.frozen?
end
# The default: serialize/deserialize to get a deep copy
Marshal.load(Marshal.dump(value()))
end
end
# This abstract producer class remembers the injector and binding.
# @abstract
# @api public
#
class AbstractArgumentedProducer < Producer
# @api public
attr_reader :injector
# @api public
attr_reader :binding
# @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
# @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
# @param scope [Puppet::Parser::Scope] The scope to use for evaluation
# @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
# @api public
#
def initialize(injector, binding, scope, options)
super
@injector = injector
@binding = binding
end
end
# @api public
class InstantiatingProducer < AbstractArgumentedProducer
# @api public
attr_reader :the_class
# @api public
attr_reader :init_args
# @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
# @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
# @param scope [Puppet::Parser::Scope] The scope to use for evaluation
# @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
# @option options [String] :class_name The name of the class to create instance of
# @option options [Array] :init_args ([]) Optional arguments to class constructor
# @api public
#
def initialize(injector, binding, scope, options)
# Better do this, even if a transformation of a created instance is kind of an odd thing to do, one can imagine
# sending it to a function for further detailing.
#
super
class_name = options[:class_name]
raise ArgumentError, "Option 'class_name' must be given for an InstantiatingProducer" unless class_name
# get class by name
@the_class = Puppet::Pops::Types::ClassLoader.provide(class_name)
@init_args = options[:init_args] || []
raise ArgumentError, "Can not load the class #{class_name} specified in binding named: '#{binding.name}'" unless @the_class
end
protected
# Performs initialization the same way as Assisted Inject does (but handle arguments to
# constructor)
# @api private
#
def internal_produce(scope)
result = nil
# A class :inject method wins over an instance :initialize if it is present, unless a more specific
# constructor exists. (i.e do not pick :inject from superclass if class has a constructor).
#
if the_class.respond_to?(:inject)
inject_method = the_class.method(:inject)
initialize_method = the_class.instance_method(:initialize)
if inject_method.owner <= initialize_method.owner
result = the_class.inject(injector, scope, binding, *init_args)
end
end
if result.nil?
result = the_class.new(*init_args)
end
result
end
end
# @api public
class FirstFoundProducer < Producer
# @api public
attr_reader :producers
# @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
# @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
# @param scope [Puppet::Parser::Scope] The scope to use for evaluation
# @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
# @option options [Array] :producers list of producers to consult. Required.
# @api public
#
def initialize(injector, binding, scope, options)
super
@producers = options[:producers]
raise ArgumentError, "Option :producers' must be set to a list of producers." if @producers.nil?
raise ArgumentError, "Given 'producers' option is not an Array" unless @producers.is_a?(Array)
end
protected
# @api private
def internal_produce(scope)
# return the first produced value that is non-nil (unfortunately there is no such enumerable method)
producers.reduce(nil) {|memo, p| break memo unless memo.nil?; p.produce(scope)}
end
end
# Evaluates a Puppet Expression and returns the result.
# This is typically used for strings with interpolated expressions.
# @api public
#
class EvaluatingProducer < Producer
# A Puppet 3 AST Expression
# @api public
#
attr_reader :expression
# @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
# @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
# @param scope [Puppet::Parser::Scope] The scope to use for evaluation
# @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
# @option options [Array] :expression The expression to evaluate
# @api public
#
def initialize(injector, binding, scope, options)
super
expr = options[:expression]
raise ArgumentError, "Option 'expression' must be given to an EvaluatingProducer." unless expr
@expression = Puppet::Pops::Model::AstTransformer.new().transform(expr)
end
# @api private
def internal_produce(scope)
expression.evaluate(scope)
end
end
# @api public
class LookupProducer < AbstractArgumentedProducer
# @api public
attr_reader :type
# @api public
attr_reader :name
# @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
# @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
# @param scope [Puppet::Parser::Scope] The scope to use for evaluation
# @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
# @option options [Puppet::Pops::Types::PObjectType] :type The type to lookup
# @option options [String] :name ('') The name to lookup
# @api public
#
def initialize(injector, binder, scope, options)
super
@type = options[:type]
@name = options[:name] || ''
raise ArgumentError, "Option 'type' must be given in a LookupProducer." unless @type
end
protected
# @api private
def internal_produce(scope)
injector.lookup_type(scope, type, name)
end
end
# @api public
class LookupKeyProducer < LookupProducer
# @api public
attr_reader :key
# @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
# @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
# @param scope [Puppet::Parser::Scope] The scope to use for evaluation
# @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
# @option options [Puppet::Pops::Types::PObjectType] :type The type to lookup
# @option options [String] :name ('') The name to lookup
# @option options [Puppet::Pops::Types::PObjectType] :key The key to lookup in the hash
# @api public
#
def initialize(injector, binder, scope, options)
super
@key = options[:key]
raise ArgumentError, "Option 'key' must be given in a LookupKeyProducer." if key.nil?
end
protected
# @api private
def internal_produce(scope)
result = super
result.is_a?(Hash) ? result[key] : nil
end
end
# Produces the given producer, then uses that producer.
# @see ProducerProducer for the non singleton version
# @api public
#
class SingletonProducerProducer < Producer
# @api public
attr_reader :value_producer
# @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
# @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
# @param scope [Puppet::Parser::Scope] The scope to use for evaluation
# @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
# @option options [Puppet::Pops::Model::LambdaExpression] :producer_producer a producer of a value producer (required)
# @api public
#
def initialize(injector, binding, scope, options)
super
p = options[:producer_producer]
raise ArgumentError, "Option :producer_producer must be given in a SingletonProducerProducer" unless p
@value_producer = p.produce(scope)
end
protected
# @api private
def internal_produce(scope)
value_producer.produce(scope)
end
end
# A ProducerProducer creates a producer via another producer, and then uses this created producer
# to produce values. This is useful for custom production of series of values.
# On each request for a producer, this producer will reset its internal producer (i.e. restarting
# the series).
#
# @param producer_producer [#produce(scope)] the producer of the producer
#
# @api public
#
class ProducerProducer < Producer
# @api public
attr_reader :producer_producer
# @api public
attr_reader :value_producer
# Creates new ProducerProducer given a producer.
#
# @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
# @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
# @param scope [Puppet::Parser::Scope] The scope to use for evaluation
# @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
# @option options [Puppet::Pops::Binder::Producer] :producer_producer a producer of a value producer (required)
#
# @api public
#
def initialize(injector, binding, scope, options)
super
unless producer_producer = options[:producer_producer]
raise ArgumentError, "The option :producer_producer must be set in a ProducerProducer"
end
raise ArgumentError, "Argument must be a Producer" unless producer_producer.is_a?(Producer)
@producer_producer = producer_producer
@value_producer = nil
end
# Updates the internal state to use a new instance of the wrapped producer.
# @api public
#
def producer(scope)
@value_producer = @producer_producer.produce(scope)
self
end
protected
# Produces a value after having created an instance of the wrapped producer (if not already created).
# @api private
#
def internal_produce(scope, *args)
producer() unless value_producer
value_producer.produce(scope)
end
end
# This type of producer should only be created by the Injector.
#
# @api private
#
class AssistedInjectProducer < Producer
# An Assisted Inject Producer is created when a lookup is made of a type that is
# not bound. It does not support a transformer lambda.
# @note This initializer has a different signature than all others. Do not use in regular logic.
# @api private
#
def initialize(injector, clazz)
raise ArgumentError, "class must be given" unless clazz.is_a?(Class)
@injector = injector
@clazz = clazz
@inst = nil
end
def produce(scope, *args)
producer(scope, *args) unless @inst
@inst
end
# @api private
def producer(scope, *args)
@inst = nil
# A class :inject method wins over an instance :initialize if it is present, unless a more specific zero args
# constructor exists. (i.e do not pick :inject from superclass if class has a zero args constructor).
#
if @clazz.respond_to?(:inject)
inject_method = @clazz.method(:inject)
initialize_method = @clazz.instance_method(:initialize)
if inject_method.owner <= initialize_method.owner || initialize_method.arity != 0
@inst = @clazz.inject(@injector, scope, nil, *args)
end
end
if @inst.nil?
unless args.empty?
raise ArgumentError, "Assisted Inject can not pass arguments to no-args constructor when there is no class inject method."
end
@inst = @clazz.new()
end
self
end
end
# Abstract base class for multibind producers.
# Is suitable as base class for custom implementations of multibind producers.
# @abstract
# @api public
#
class MultibindProducer < AbstractArgumentedProducer
attr_reader :contributions_key
# @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
# @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
# @param scope [Puppet::Parser::Scope] The scope to use for evaluation
# @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
#
# @api public
#
def initialize(injector, binding, scope, options)
super
@contributions_key = injector.key_factory.multibind_contributions(binding.id)
end
# @param expected [Array, Puppet::Pops::Types::PObjectType] expected type or types
# @param actual [Object, Puppet::Pops::Types::PObjectType> the actual value (or its type)
# @return [String] a formatted string for inclusion as detail in an error message
# @api private
#
def type_error_detail(expected, actual)
tc = injector.type_calculator
expected = [expected] unless expected.is_a?(Array)
actual_t = tc.is_ptype?(actual) ? actual : tc.infer(actual)
expstrs = expected.collect {|t| tc.string(t) }
"expected: #{expstrs.join(', or ')}, got: #{tc.string(actual_t)}"
end
end
# A configurable multibind producer for Array type multibindings.
#
# This implementation collects all contributions to the multibind and then combines them using the following rules:
#
# - all *unnamed* entries are added unless the option `:priority_on_unnamed` is set to true, in which case the unnamed
# contribution with the highest priority is added, and the rest are ignored (unless they have the same priority in which
# case an error is raised).
# - all *named* entries are handled the same way as *unnamed* but the option `:priority_on_named` controls their handling.
# - the option `:uniq` post processes the result to only contain unique entries
# - the option `:flatten` post processes the result by flattening all nested arrays.
# - If both `:flatten` and `:uniq` are true, flattening is done first.
#
# @note
# Collection accepts elements that comply with the array's element type, or the entire type (i.e. Array[element_type]).
# If the type is restrictive - e.g. Array[String] and an Array[String] is contributed, the result will not be type
# compliant without also using the `:flatten` option, and a type error will be raised. For an array with relaxed typing
# i.e. Array[Data], it it valid to produce a result such as `['a', ['b', 'c'], 'd']` and no flattening is required
# and no error is raised (but using the array needs to be aware of potential array, non-array entries.
# The use of the option `:flatten` controls how the result is flattened.
#
# @api public
#
class ArrayMultibindProducer < MultibindProducer
# @return [Boolean] whether the result should be made contain unique (non-equal) entries or not
# @api public
attr_reader :uniq
# @return [Boolean, Integer] If result should be flattened (true), or not (false), or flattened to given level (0 = none, -1 = all)
# @api public
attr_reader :flatten
# @return [Boolean] whether priority should be considered for named contributions
# @api public
attr_reader :priority_on_named
# @return [Boolean] whether priority should be considered for unnamed contributions
# @api public
attr_reader :priority_on_unnamed
# @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
# @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
# @param scope [Puppet::Parser::Scope] The scope to use for evaluation
# @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
# @option options [Boolean] :uniq (false) if collected result should be post-processed to contain only unique entries
# @option options [Boolean, Integer] :flatten (false) if collected result should be post-processed so all contained arrays
# are flattened. May be set to an Integer value to indicate the level of recursion (-1 is endless, 0 is none).
# @option options [Boolean] :priority_on_named (true) if highest precedented named element should win or if all should be included
# @option options [Boolean] :priority_on_unnamed (false) if highest precedented unnamed element should win or if all should be included
# @api public
#
def initialize(injector, binding, scope, options)
super
@uniq = !!options[:uniq]
@flatten = options[:flatten]
@priority_on_named = options[:priority_on_named].nil? ? true : options[:priority_on_name]
@priority_on_unnamed = !!options[:priority_on_unnamed]
case @flatten
when Integer
when true
@flatten = -1
when false
@flatten = nil
when NilClass
@flatten = nil
else
raise ArgumentError, "Option :flatten must be nil, Boolean, or an integer value" unless @flatten.is_a?(Integer)
end
end
protected
# @api private
def internal_produce(scope)
seen = {}
included_keys = []
injector.get_contributions(scope, contributions_key).each do |element|
key = element[0]
entry = element[1]
name = entry.binding.name
existing = seen[name]
empty_name = name.nil? || name.empty?
if existing
if empty_name && priority_on_unnamed
if (seen[name] <=> entry) >= 0
raise ArgumentError, "Duplicate key (same priority) contributed to Array Multibinding '#{binding.name}' with unnamed entry."
end
next
elsif !empty_name && priority_on_named
if (seen[name] <=> entry) >= 0
raise ArgumentError, "Duplicate key (same priority) contributed to Array Multibinding '#{binding.name}', key: '#{name}'."
end
next
end
else
seen[name] = entry
end
included_keys << key
end
result = included_keys.collect do |k|
x = injector.lookup_key(scope, k)
assert_type(binding(), injector.type_calculator(), x)
x
end
result.flatten!(flatten) if flatten
result.uniq! if uniq
result
end
# @api private
def assert_type(binding, tc, value)
infered = tc.infer(value)
unless tc.assignable?(binding.type.element_type, infered) || tc.assignable?(binding.type, infered)
raise ArgumentError, ["Type Error: contribution to '#{binding.name}' does not match type of multibind, ",
"#{type_error_detail([binding.type.element_type, binding.type], value)}"].join()
end
end
end
# @api public
class HashMultibindProducer < MultibindProducer
# @return [Symbol] One of `:error`, `:merge`, `:append`, `:priority`, `:ignore`
# @api public
attr_reader :conflict_resolution
# @return [Boolean]
# @api public
attr_reader :uniq
# @return [Boolean, Integer] Flatten all if true, or none if false, or to given level (0 = none, -1 = all)
# @api public
attr_reader :flatten
# The hash multibind producer provides options to control conflict resolution.
# By default, the hash is produced using `:priority` resolution - the highest entry is selected, the rest are
# ignored unless they have the same priority which is an error.
#
# @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
# @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
# @param scope [Puppet::Parser::Scope] The scope to use for evaluation
# @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
# @option options [Symbol, String] :conflict_resolution (:priority) One of `:error`, `:merge`, `:append`, `:priority`, `:ignore`
# `ignore` the first found highest priority contribution is used, the rest are ignored
# `error` any duplicate key is an error
# `append` element type must be compatible with Array, makes elements be arrays and appends all found
# `merge` element type must be compatible with hash, merges hashes with retention of highest priority hash content
# `priority` the first found highest priority contribution is used, duplicates with same priority raises and error, the rest are
# ignored. ] one or more String URI binding references
# @param config_file [String] reference to the loaded config file
#
def check_bindings_references(kind, value, config_file)
return check_reference(value, kind, config_file) if value.is_a?(String)
accept(Issues::BINDINGS_REF_NOT_STRING_OR_ARRAY, config_file, :kind => kind ) unless value.is_a?(Array)
value.each {|ref| check_reference(ref, kind, config_file) }
end
# A reference is a URI in string form having one of the schemes:
# - module-hiera
# - confdir-hiera
# - enc
#
# and with a path (at least '/')
#
def check_reference(value, kind, config_file)
begin
uri = URI.parse(value)
unless uri.scheme
accept(Issues::MISSING_SCHEME, config_file, :uri => uri)
end
unless uri.path
accept(Issues::REF_WITHOUT_PATH, config_file, :uri => uri, :kind => kind)
end
rescue InvalidURIError => e
accept(Issues::BINDINGS_REF_INVALID_URI, config_file, :msg => e.message)
end
end
def check_extensions(extensions, config_file)
unless extensions.is_a?(Hash)
accept(Issues::EXTENSIONS_NOT_HASH, config_file, :actual => extensions.class.name)
return
end
# check known extensions
extensions.each_key do |key|
unless ['scheme_handlers', 'hiera_backends'].include? key
accept(Issues::UNKNOWN_EXTENSION, config_file, :extension => key)
end
end
if binding_schemes = extensions['scheme_handlers']
unless binding_schemes.is_a?(Hash)
accept(Issues::EXTENSION_BINDING_NOT_HASH, config_file, :extension => 'scheme_handlers', :actual => binding_schemes.class.name)
end
end
if hiera_backends = extensions['hiera_backends']
unless hiera_backends.is_a?(Hash)
accept(Issues::EXTENSION_BINDING_NOT_HASH, config_file, :extension => 'hiera_backends', :actual => hiera_backends.class.name)
end
end
end
end
end
puppet-3.4.3/lib/puppet/pops/binder/config/diagnostic_producer.rb 0000644 0052762 0001160 00000001753 12300765631 025067 0 ustar jenkins jenkins module Puppet::Pops::Binder::Config
# Generates validation diagnostics
class Puppet::Pops::Binder::Config::DiagnosticProducer
def initialize(acceptor)
@acceptor = acceptor
@severity_producer = Puppet::Pops::Validation::SeverityProducer.new
end
def accept(issue, semantic, arguments={})
arguments[:semantic] ||= semantic
severity = severity_producer.severity(issue)
@acceptor.accept(Puppet::Pops::Validation::Diagnostic.new(severity, issue, nil, nil, arguments))
end
def errors?()
@acceptor.errors?
end
def severity_producer
p = @severity_producer
# All are errors, if there is need to mark some as warnings...
# p[Issues::XXX] = :warning
# ignored because there is a default
p[Puppet::Pops::Binder::Config::Issues::CONFIG_LAYERS_MISSING] = :ignore
# ignored because there is a default
p[Puppet::Pops::Binder::Config::Issues::CONFIG_CATEGORIES_MISSING] = :ignore
p
end
end
end
puppet-3.4.3/lib/puppet/pops/binder/config/binder_config.rb 0000644 0052762 0001160 00000011360 12300765631 023623 0 ustar jenkins jenkins module Puppet::Pops::Binder::Config
# Class holding the Binder Configuration
# The configuration is obtained from the file 'binder_config.yaml'
# that must reside in the root directory of the site
# @api public
#
class BinderConfig
# The bindings hierarchy is an array of categorizations where the
# array for each category has exactly three elements - the categorization name,
# category value, and the path that is later used by the backend to read
# the bindings for that category
#
# @return [Array, Hash>]
# @api public
#
attr_reader :layering_config
# @return [Array] Array of Category tuples where Strings are not evaluated.
# @api public
#
attr_reader :categorization
# @return ] ({}) optional mapping of bindings-scheme to handler class name
attr_reader :scheme_extensions
# @return ] ({}) optional mapping of hiera backend name to backend class name
attr_reader :hiera_backends
# @return [String] the loaded config file
attr_accessor :config_file
DEFAULT_LAYERS = [
{ 'name' => 'site', 'include' => ['confdir-hiera:/', 'confdir:/default?optional'] },
{ 'name' => 'modules', 'include' => ['module-hiera:/*/', 'module:/*::default'] },
]
DEFAULT_CATEGORIES = [
['node', "${fqdn}"],
['osfamily', "${osfamily}"],
['environment', "${environment}"],
['common', "true"]
]
DEFAULT_SCHEME_EXTENSIONS = {}
DEFAULT_HIERA_BACKENDS_EXTENSIONS = {}
def default_config()
# This is hardcoded now, but may be a user supplied default configuration later
{'version' => 1, 'layers' => default_layers, 'categories' => default_categories}
end
def confdir()
Puppet.settings[:confdir]
end
# Creates a new Config. The configuration is loaded from the file 'binder_config.yaml' which
# is expected to be found in confdir.
#
# @param diagnostics [DiagnosticProducer] collector of diagnostics
# @api public
#
def initialize(diagnostics)
@config_file = Puppet.settings[:binder_config]
# if file is stated, it must exist
# otherwise it is optional $confdir/binder_conf.yaml
# and if that fails, the default
case @config_file
when NilClass
# use the config file if it exists
rootdir = confdir
if rootdir.is_a?(String)
expanded_config_file = File.expand_path(File.join(rootdir, '/binder_config.yaml'))
if Puppet::FileSystem::File.exist?(expanded_config_file)
@config_file = expanded_config_file
end
else
raise ArgumentError, "No Puppet settings 'confdir', or it is not a String"
end
when String
unless Puppet::FileSystem::File.exist?(@config_file)
raise ArgumentError, "Cannot find the given binder configuration file '#{@config_file}'"
end
else
raise ArgumentError, "The setting binder_config is expected to be a String, got: #{@config_file.class.name}."
end
unless @config_file.is_a?(String) && Puppet::FileSystem::File.exist?(@config_file)
@config_file = nil # use defaults
end
validator = BinderConfigChecker.new(diagnostics)
begin
data = @config_file ? YAML.load_file(@config_file) : default_config()
validator.validate(data, @config_file)
rescue Errno::ENOENT
diagnostics.accept(Issues::CONFIG_FILE_NOT_FOUND, @config_file)
rescue Errno::ENOTDIR
diagnostics.accept(Issues::CONFIG_FILE_NOT_FOUND, @config_file)
rescue ::SyntaxError => e
diagnostics.accept(Issues::CONFIG_FILE_SYNTAX_ERROR, @config_file, :detail => e.message)
end
unless diagnostics.errors?
@layering_config = data['layers'] or default_layers
@categorization = data['categories'] or default_categories
@scheme_extensions = (data['extensions'] and data['extensions']['scheme_handlers'] or default_scheme_extensions)
@hiera_backends = (data['extensions'] and data['extensions']['hiera_backends'] or default_hiera_backends_extensions)
else
@layering_config = []
@categorization = {}
@scheme_extensions = {}
@hiera_backends = {}
end
end
# The default_xxx methods exists to make it easier to do mocking in tests.
# @api private
def default_layers
DEFAULT_LAYERS
end
# @api private
def default_categories
DEFAULT_CATEGORIES
end
# @api private
def default_scheme_extensions
DEFAULT_SCHEME_EXTENSIONS
end
# @api private
def default_hiera_backends_extensions
DEFAULT_HIERA_BACKENDS_EXTENSIONS
end
end
end
puppet-3.4.3/lib/puppet/pops/binder/config/issues.rb 0000644 0052762 0001160 00000010573 12300765631 022353 0 ustar jenkins jenkins module Puppet::Pops::Binder::Config::Issues
# (see Puppet::Pops::Issues#issue)
def self.issue (issue_code, *args, &block)
Puppet::Pops::Issues.issue(issue_code, *args, &block)
end
CONFIG_FILE_NOT_FOUND = issue :CONFIG_FILE_NOT_FOUND do
"The binder configuration file: #{semantic} can not be found."
end
CONFIG_FILE_SYNTAX_ERROR = issue :CONFIG_FILE_SYNTAX_ERROR, :detail do
"Syntax error in configuration file: #{detail}"
end
CONFIG_IS_NOT_HASH = issue :CONFIG_IS_NOT_HASH do
"The configuration file '#{semantic}' has no hash at the top level"
end
CONFIG_LAYERS_MISSING = issue :CONFIG_LAYERS_MISSING do
"The configuration file '#{semantic}' has no 'layers' entry in the top level hash"
end
CONFIG_VERSION_MISSING = issue :CONFIG_VERSION_MISSING do
"The configuration file '#{semantic}' has no 'version' entry in the top level hash"
end
CONFIG_CATEGORIES_MISSING = issue :CONFIG_CATEGORIES_MISSING do
"The configuration file '#{semantic}' has no 'categories' entry in the top level hash"
end
LAYERS_IS_NOT_ARRAY = issue :LAYERS_IS_NOT_ARRAY, :klass do
"The configuration file '#{semantic}' should contain a 'layers' key with an Array value, got: #{klass.name}"
end
CATEGORIES_IS_NOT_ARRAY = issue :CATEGORIES_IS_NOT_ARRAY, :klass do
"The configuration file '#{semantic}' should contain a 'categories' key with an Array value, got: #{klass.name}"
end
CATEGORY_IS_NOT_ARRAY = issue :CATEGORY_IS_NOT_ARRAY, :klass do
"The configuration file '#{semantic}' each entry in 'categories' should be an Array(String, String), got: #{klass.name}"
end
CATEGORY_NOT_TWO_STRINGS = issue :CATEGORY_NOT_TWO_STRINGS, :count do
"The configuration file '#{semantic}' each entry in 'categories' should be an array with 2 strings, got: #{count}"
end
INVALID_CATEGORY_NAME = issue :INVALID_CATEGORY_NAME, :name do
"The configuration file '#{semantic}' contains the invalid category: '#{name}', must match /[a-z][a-zA-Z0-9_]*/"
end
LAYER_IS_NOT_HASH = issue :LAYER_IS_NOT_HASH, :klass do
"The configuration file '#{semantic}' should contain one hash per layer, got #{klass.name} instead of Hash"
end
DUPLICATE_LAYER_NAME = issue :DUPLICATE_LAYER_NAME, :name do
"Duplicate layer '#{name}' in configuration file #{semantic}"
end
UNKNOWN_LAYER_ATTRIBUTE = issue :UNKNOWN_LAYER_ATTRIBUTE, :name do
"Unknown layer attribute '#{name}' in configuration file #{semantic}"
end
BINDINGS_REF_NOT_STRING_OR_ARRAY = issue :BINDINGS_REF_NOT_STRING_OR_ARRAY, :kind do
"Configuration file #{semantic} has bindings reference in '#{kind}' that is neither a String nor an Array."
end
MISSING_SCHEME = issue :MISSING_SCHEME, :uri do
"Configuration file #{semantic} contains a bindings reference: '#{uri}' without scheme."
end
UNKNOWN_REF_SCHEME = issue :UNKNOWN_REF_SCHEME, :uri, :kind do
"Configuration file #{semantic} contains a bindings reference: '#{kind}' => '#{uri}' with unknown scheme"
end
REF_WITHOUT_PATH = issue :REF_WITHOUT_PATH, :uri, :kind do
"Configuration file #{semantic} contains a bindings reference: '#{kind}' => '#{uri}' without path"
end
BINDINGS_REF_INVALID_URI = issue :BINDINGS_REF_INVALID_URI, :msg do
"Configuration file #{semantic} contains a bindings reference: '#{kind}' => invalid uri, msg: '#{msg}'"
end
LAYER_ATTRIBUTE_IS_SYMBOL = issue :LAYER_ATTRIBUTE_IS_SYMBOL, :name do
"Configuration file #{semantic} contains a layer attribute '#{name}' that is a Symbol (should be String)"
end
LAYER_NAME_NOT_STRING = issue :LAYER_NAME_NOT_STRING, :class_name do
"Configuration file #{semantic} contains a layer name that is not a String, got a: '#{class_name}'"
end
CONFIG_WRONG_VERSION = issue :CONFIG_WRONG_VERSION, :expected, :actual do
"The configuration file '#{semantic}' has unsupported 'version', expected: #{expected}, but got: #{actual}."
end
EXTENSIONS_NOT_HASH = issue :EXTENSIONS_NOT_HASH, :actual do
"The configuration file '#{semantic}' contains 'extensions', expected: Hash, but got: #{actual}."
end
EXTENSION_BINDING_NOT_HASH = issue :EXTENSION_BINDING_NOT_HASH, :extension, :actual do
"The configuration file '#{semantic}' contains '#{extension}', expected: Hash, but got: #{actual}."
end
UNKNOWN_EXTENSION = issue :UNKNOWN_EXTENSION, :actual do
"The configuration file '#{semantic}' contains the unknown extension: #{extension}."
end
end
puppet-3.4.3/lib/puppet/pops/binder/system_bindings.rb 0000644 0052762 0001160 00000005417 12300765631 022775 0 ustar jenkins jenkins class Puppet::Pops::Binder::SystemBindings
# Constant with name used for bindings used during initialization of injector
ENVIRONMENT_BOOT_BINDINGS_NAME = 'puppet::env::injector::boot'
Factory = Puppet::Pops::Binder::BindingsFactory
@extension_bindings = Factory.named_bindings("puppet::extensions")
@default_bindings = Factory.named_bindings("puppet::default")
# Bindings in effect when real injector is created
@injector_boot_bindings = Factory.named_bindings("puppet::injector_boot")
def self.extensions()
@extension_bindings
end
def self.default_bindings()
@default_bindings
end
def self.injector_boot_bindings()
@injector_boot_bindings
end
# def self.env_boot_bindings()
# Puppet::Bindings[Puppet::Pops::Binder::SystemBindings::ENVIRONMENT_BOOT_BINDINGS_NAME]
# end
def self.final_contribution
effective_categories = Factory.categories([['common', 'true']])
Factory.contributed_bindings("puppet-final", [deep_clone(@extension_bindings.model)], effective_categories)
end
def self.default_contribution
effective_categories = Factory.categories([['common', 'true']])
Factory.contributed_bindings("puppet-default", [deep_clone(@default_bindings.model)], effective_categories)
end
def self.injector_boot_contribution(env_boot_bindings)
# Compose the injector_boot_bindings contributed from the puppet runtime book (i.e. defaults for
# extensions that should be active in the boot injector - see Puppetx initialization.
#
bindings = [deep_clone(@injector_boot_bindings.model), deep_clone(@injector_default_bindings)]
# Add the bindings that come from the bindings_composer as it may define custom extensions added in the bindings
# configuration. (i.e. bindings required to be able to lookup using bindings schemes and backends when
# configuring the real injector).
#
bindings << env_boot_bindings unless env_boot_bindings.nil?
# Use an 'extension' category for extension bindings to allow them to override the default
# bindings since they are placed in the same layer (this is done to avoid having a separate layer).
# The purpose for allowing overrides is that someone may want to replace say 'yaml' with a different version,
# (say one that uses a YAML implementation that actually works ok in ruby 1.8.7 ;-)), an encrypted parser, etc.
effective_categories = Factory.categories([['extension', 'true'],['common', 'true']])
# return the composition and the cateogires.
Factory.contributed_bindings("puppet-injector-boot", bindings, effective_categories)
end
def self.factory()
Puppet::Pops::Binder::BindingsFactory
end
def self.type_factory()
Puppet::Pops::Types::TypeFactory
end
private
def self.deep_clone(o)
Marshal.load(Marshal.dump(o))
end
end
puppet-3.4.3/lib/puppet/pops/binder/bindings_loader.rb 0000644 0052762 0001160 00000005203 12300765631 022710 0 ustar jenkins jenkins require 'rgen/metamodel_builder'
# The ClassLoader provides a Class instance given a class name or a meta-type.
# If the class is not already loaded, it is loaded using the Puppet Autoloader.
# This means it can load a class from a gem, or from puppet modules.
#
class Puppet::Pops::Binder::BindingsLoader
@autoloader = Puppet::Util::Autoload.new("BindingsLoader", "puppet/bindings", :wrap => false)
# Returns a XXXXX given a fully qualified class name.
# Lookup of class is never relative to the calling namespace.
# @param name [String, Array, Array, Puppet::Pops::Types::PObjectType] A fully qualified
# class name String (e.g. '::Foo::Bar', 'Foo::Bar'), a PObjectType, or a fully qualified name in Array form where each part
# is either a String or a Symbol, e.g. `%w{Puppetx Puppetlabs SomeExtension}`.
# @return [Class, nil] the looked up class or nil if no such class is loaded
# @raise ArgumentError If the given argument has the wrong type
# @api public
#
def self.provide(scope, name)
case name
when String
provide_from_string(scope, name)
when Array
provide_from_name_path(scope, name.join('::'), name)
else
raise ArgumentError, "Cannot provide a bindings from a '#{name.class.name}'"
end
end
# If loadable name exists relative to a a basedir or not. Returns the loadable path as a side effect.
# @return [String, nil] a loadable path for the given name, or nil
#
def self.loadable?(basedir, name)
# note, "lib" is added by the autoloader
#
paths_for_name(name).find {|p| Puppet::FileSystem::File.exist?(File.join(basedir, "lib/puppet/bindings", p)+'.rb') }
end
private
def self.provide_from_string(scope, name)
name_path = name.split('::')
# always from the root, so remove an empty first segment
if name_path[0].empty?
name_path = name_path[1..-1]
end
provide_from_name_path(scope, name, name_path)
end
def self.provide_from_name_path(scope, name, name_path)
# If bindings is already loaded, try this first
result = Puppet::Bindings.resolve(scope, name)
unless result
# Attempt to load it using the auto loader
paths_for_name(name).find {|path| @autoloader.load(path) }
result = Puppet::Bindings.resolve(scope, name)
end
result
end
def self.paths_for_name(fq_name)
[de_camel(fq_name), downcased_path(fq_name)]
end
def self.downcased_path(fq_name)
fq_name.to_s.gsub(/::/, '/').downcase
end
def self.de_camel(fq_name)
fq_name.to_s.gsub(/::/, '/').
gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
gsub(/([a-z\d])([A-Z])/,'\1_\2').
tr("-", "_").
downcase
end
end puppet-3.4.3/lib/puppet/pops/binder/scheme_handler/ 0000755 0052762 0001160 00000000000 12300765640 022201 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/pops/binder/scheme_handler/module_scheme.rb 0000644 0052762 0001160 00000006106 12300765631 025342 0 ustar jenkins jenkins require 'puppet/pops/binder/scheme_handler/symbolic_scheme'
# The module scheme allows loading bindings using the Puppet autoloader.
# Optional uris are handled by checking if the symbolic name can be resolved to a loadable file
# from modules.
#
# URI
# ---
# The uri is on the format: `module:/[fqn][? | ?optional]` where `fqn` is a fully qualified bindings name
# starting with the module name or '*' to denote 'any module'. A URI query of `?` or `?optional` makes the
# request optional; if no loadable file is found, it is simply skipped.
#
#
# @todo
# Does currently only support checking of optionality against files under a module. If the result should be loaded
# from any other location it can not be marked as optional as it will be ignored.
#
class Puppet::Pops::Binder::SchemeHandler::ModuleScheme < Puppet::Pops::Binder::SchemeHandler::SymbolicScheme
# Expands URIs with wildcards and checks optionality.
# @param uri [URI] the uri to possibly expand
# @return [Array] the URIs to include
# @api public
#
def expand_included(uri, composer)
result = []
split_name, fqn = fqn_from_path(uri)
# supports wild card in the module name
case split_name[0]
when '*'
# create new URIs, one per module name that has a corresponding .rb file relative to its
# '/lib/puppet/bindings/'
#
composer.name_to_module.each_pair do | mod_name, mod |
expanded_name_parts = [mod_name] + split_name[1..-1]
expanded_name = expanded_name_parts.join('::')
if Puppet::Pops::Binder::BindingsLoader.loadable?(mod.path, expanded_name)
result << URI.parse('module:/' + expanded_name)
end
end
when nil
raise ArgumentError, "Bad bindings uri, the #{uri} has neither module name or wildcard '*' in its first path position"
else
joined_name = split_name.join('::')
# skip optional uri if it does not exist
if is_optional?(uri)
mod = composer.name_to_module[split_name[0]]
if mod && Puppet::Binder::BindingsLoader.loadable?(mod.path, joined_name)
result << URI.parse('module:/' + joined_name)
end
else
# assume it exists (do not give error if not, since it may be excluded later)
result << URI.parse('module:/' + joined_name)
end
end
result
end
# Expands URIs with wildcards
# @param uri [URI] the uri to possibly expand
# @return [Array] the URIs to exclude
# @api public
#
def expand_excluded(uri, composer)
result = []
split_name, fqn = fqn_from_path(uri)
case split_name[ 0 ]
when '*'
# create new URIs, one per module name
composer.name_to_module.each_pair do | name, mod |
result << URI.parse('module:/' + ([name] + split_name).join('::'))
end
when nil
raise ArgumentError, "Bad bindings uri, the #{uri} has neither module name or wildcard '*' in its first path position"
else
# create a clean copy (get rid of optional, fragments etc. and any trailing stuff
result << URI.parse('module:/' + split_name.join('::'))
end
result
end
end
puppet-3.4.3/lib/puppet/pops/binder/scheme_handler/symbolic_scheme.rb 0000644 0052762 0001160 00000004233 12300765631 025675 0 ustar jenkins jenkins # Abstract base class for schemes based on symbolic names of bindings.
# This class helps resolve symbolic names by computing a path from a fully qualified name (fqn).
# There are also helper methods do determine if the symbolic name contains a wild-card ('*') in the first
# portion of the fqn (with the convention that '*' means 'any module').
#
# @abstract
# @api public
#
class Puppet::Pops::Binder::SchemeHandler::SymbolicScheme < Puppetx::Puppet::BindingsSchemeHandler
# Shared implementation for module: and confdir: since the distinction is only in checks if a symbolic name
# exists as a loadable file or not. Once this method is called it is assumed that the name is relative
# and that it should exist relative to some loadable ruby location.
#
# TODO: this needs to be changed once ARM-8 Puppet DSL concrete syntax is also supported.
# @api public
#
def contributed_bindings(uri, scope, composer)
fqn = fqn_from_path(uri)[1]
bindings = Puppet::Pops::Binder::BindingsLoader.provide(scope, fqn)
raise ArgumentError, "Cannot load bindings '#{uri}' - no bindings found." unless bindings
# Must clone as the the rest mutates the model
cloned_bindings = Marshal.load(Marshal.dump(bindings))
# Give no effective categories (i.e. ok with whatever categories there is)
Puppet::Pops::Binder::BindingsFactory.contributed_bindings(fqn, cloned_bindings, nil)
end
# @api private
def fqn_from_path(uri)
split_path = uri.path.split('/')
if split_path.size > 1 && split_path[-1].empty?
split_path.delete_at(-1)
end
fqn = split_path[ 1 ]
raise ArgumentError, "Module scheme binding reference has no name." unless fqn
split_name = fqn.split('::')
# drop leading '::'
split_name.shift if split_name[0] && split_name[0].empty?
[split_name, split_name.join('::')]
end
# True if super thinks it is optional or if it contains a wildcard.
# @return [Boolean] true if the uri represents an optional set of bindings.
# @api public
def is_optional?(uri)
super(uri) || has_wildcard?(uri)
end
# @api private
def has_wildcard?(uri)
(path = uri.path) && path.split('/')[1].start_with?('*::')
end
end
puppet-3.4.3/lib/puppet/pops/binder/scheme_handler/confdir_scheme.rb 0000644 0052762 0001160 00000002300 12300765631 025471 0 ustar jenkins jenkins require 'puppet/pops/binder/scheme_handler/symbolic_scheme'
# Similar to {Puppet::Pops::Binder::SchemeHandler::ModuleScheme ModuleScheme}, but relative to the config root.
# Does not support wildcard expansion.
#
# URI
# ---
# The URI scheme is `confdir:/[]['?' | [?optional]` where FQN is the fully qualified name of the bindings to load.
# The referecence is made optional by using a URI query of `?` or `?optional`.
#
# @todo
# If the file to load is outside of the file system rooted at $confdir (in a gem, or just on the Ruby path), it can not
# be marked as optional as it will always be ignored.
#
class Puppet::Pops::Binder::SchemeHandler::ConfdirScheme < Puppet::Pops::Binder::SchemeHandler::SymbolicScheme
def expand_included(uri, composer)
fqn = fqn_from_path(uri)[1]
if is_optional?(uri)
if Puppet::Pops::Binder::BindingsLoader.loadable?(composer.confdir, fqn)
[URI.parse('confdir:/' + fqn)]
else
[]
end
else
# assume it exists (do not give error if not, since it may be excluded later)
[URI.parse('confdir:/' + fqn)]
end
end
def expand_excluded(uri, composer)
[URI.parse("confdir:/#{fqn_from_path(uri)[1]}")]
end
end
puppet-3.4.3/lib/puppet/pops/binder/scheme_handler/module_hiera_scheme.rb 0000644 0052762 0001160 00000006714 12300765631 026517 0 ustar jenkins jenkins # The `module-hiera:` scheme uses the path to denote a directory relative to a module root
# The path starts with the name of the module, or '*' to denote *any module*.
#
# @example All root hiera.yaml from all modules.
# module-hiera:/*
#
# @example The hiera.yaml from the module `foo`'s relative path `/bar`.
# module-hiera:/foo/bar
#
class Puppet::Pops::Binder::SchemeHandler::ModuleHieraScheme < Puppetx::Puppet::BindingsSchemeHandler
# (Puppetx::Puppet::BindingsSchemeHandler.contributed_bindings)
# @api public
def contributed_bindings(uri, scope, composer)
split_path = uri.path.split('/')
name = split_path[1]
mod = composer.name_to_module[name]
provider = Puppet::Pops::Binder::Hiera2::BindingsProvider.new(uri.to_s, File.join(mod.path, split_path[ 2..-1 ]), composer.acceptor)
provider.load_bindings(scope)
end
# Expands URIs with wildcards and checks optionality.
# @param uri [URI] the uri to possibly expand
# @return [Array] the URIs to include
# @api public
#
def expand_included(uri, composer)
result = []
split_path = uri.path.split('/')
if split_path.size > 1 && split_path[-1].empty?
split_path.delete_at(-1)
end
# 0 = "", since a URI with a path must start with '/'
# 1 = '*' or the module name
case split_path[ 1 ]
when '*'
# create new URIs, one per module name that has a hiera.yaml file relative to its root
composer.name_to_module.each_pair do | name, mod |
if Puppet::FileSystem::File.exist?(File.join(mod.path, split_path[ 2..-1 ], 'hiera.yaml' ))
path_parts =["", name] + split_path[2..-1]
result << URI.parse('module-hiera:'+File.join(path_parts))
end
end
when nil
raise ArgumentError, "Bad bindings uri, the #{uri} has neither module name or wildcard '*' in its first path position"
else
# If uri has query that is empty, or the text 'optional' skip this uri if it does not exist
if query = uri.query()
if query == '' || query == 'optional'
if Puppet::FileSystem::File.exist?(File.join(mod.path, split_path[ 2..-1 ], 'hiera.yaml' ))
result << URI.parse('module-hiera:' + uri.path)
end
end
else
# assume it exists (do not give error since it may be excluded later)
result << URI.parse('module-hiera:' + File.join(split_path))
end
end
result
end
# Expands URIs with wildcards and checks optionality.
# @param uri [URI] the uri to possibly expand
# @return [Array] the URIs to exclude
# @api public
#
def expand_excluded(uri, composer)
result = []
split_path = uri.path.split('/')
if split_path.size > 1 && split_path[-1].empty?
split_path.delete_at(-1)
end
# 0 = "", since a URI with a path must start with '/'
# 1 = '*' or the module name
case split_path[ 1 ]
when '*'
# create new URIs, one per module name that has a hiera.yaml file relative to its root
composer.name_to_module.each_pair do | name, mod |
path_parts =["", mod.name] + split_path[2..-1]
result << URI.parse('module-hiera:'+File.join(path_parts))
end
when nil
raise ArgumentError, "Bad bindings uri, the #{uri} has neither module name or wildcard '*' in its first path position"
else
# create a clean copy (get rid of optional, fragments etc. and a trailing "/")
result << URI.parse('module-hiera:' + File.join(split_path))
end
result
end
end
puppet-3.4.3/lib/puppet/pops/binder/scheme_handler/confdir_hiera_scheme.rb 0000644 0052762 0001160 00000004426 12300765631 026654 0 ustar jenkins jenkins # Similar to {Puppet::Pops::Binder::SchemeHandler::ModuleHieraScheme ModuleHieraScheme} but path is
# relative to the `$confdir` instead of relative to a module root.
#
# Does not handle wild-cards.
# @api public
class Puppet::Pops::Binder::SchemeHandler::ConfdirHieraScheme < Puppetx::Puppet::BindingsSchemeHandler
# (Puppetx::Puppet::BindingsSchemeHandler.contributed_bindings)
#
def contributed_bindings(uri, scope, composer)
split_path = uri.path.split('/')
name = split_path[1]
confdir = composer.confdir
provider = Puppet::Pops::Binder::Hiera2::BindingsProvider.new(uri.to_s, File.join(confdir, uri.path), composer.acceptor)
provider.load_bindings(scope)
end
# This handler does not support wildcards.
# The given uri is simply returned in an array.
# @param uri [URI] the uri to expand
# @return [Array] the uri wrapped in an array
# @todo Handle optional and possibly hiera-1 hiera.yaml config file in the expected location (the same as missing)
# @api public
#
def expand_included(uri, composer)
result = []
if config_exist?(uri, composer)
result << uri unless is_ignored_hiera_version?(uri, composer)
else
result << uri unless is_optional?(uri)
end
result
end
# This handler does not support wildcards.
# The given uri is simply returned in an array.
# @param uri [URI] the uri to expand
# @return [Array] the uri wrapped in an array
# @api public
#
def expand_excluded(uri, composer)
[uri]
end
def config_exist?(uri, composer)
Puppet::FileSystem::File.exist?(File.join(composer.confdir, uri.path, 'hiera.yaml'))
end
# A hiera.yaml that exists, is readable, can be loaded, and does not have version >= 2 set is ignored.
# All other conditions are reported as 'not ignored' even if there are errors; these will be handled later
# as if the hiera.yaml is a hiera-2 file.
# @api private
def is_ignored_hiera_version?(uri, composer)
config_file = File.join(composer.confdir, uri.path, 'hiera.yaml')
begin
data = YAML.load_file(config_file)
if data.is_a?(Hash)
ver = data[:version] || data['version']
return ver.nil? || ver < 2
end
rescue Errno::ENOENT
rescue Errno::ENOTDIR
rescue ::SyntaxError => e
end
return false
end
end
puppet-3.4.3/lib/puppet/pops/binder/bindings_validator_factory.rb 0000644 0052762 0001160 00000001316 12300765631 025157 0 ustar jenkins jenkins # Configures validation suitable for the bindings model
# @api public
#
class Puppet::Pops::Binder::BindingsValidatorFactory < Puppet::Pops::Validation::Factory
Issues = Puppet::Pops::Binder::BinderIssues
# Produces the checker to use
def checker diagnostic_producer
Puppet::Pops::Binder::BindingsChecker.new(diagnostic_producer)
end
# Produces the label provider to use
def label_provider
Puppet::Pops::Binder::BindingsLabelProvider.new()
end
# Produces the severity producer to use
def severity_producer
p = super
# Configure each issue that should **not** be an error
#
p[Issues::MISSING_BINDINGS] = :warning
p[Issues::MISSING_LAYERS] = :warning
p
end
end
puppet-3.4.3/lib/puppet/pops/binder/injector.rb 0000644 0052762 0001160 00000064545 12300765631 021420 0 ustar jenkins jenkins # The injector is the "lookup service" class
#
# Initialization
# --------------
# The injector is initialized with a configured {Puppet::Pops::Binder::Binder Binder}. The Binder instance contains a resolved set of
# `key => "binding information"` that is used to setup the injector.
#
# Lookup
# ------
# It is possible to lookup either the value, or a producer of the value. The {#lookup} method looks up a value, and the
# {#lookup_producer} looks up a producer.
# Both of these methods can be called with three different signatures; `lookup(key)`, `lookup(type, name)`, and `lookup(name)`,
# with the corresponding calls to obtain a producer; `lookup_producer(key)`, `lookup_producer(type, name)`, and `lookup_producer(name)`.
#
# It is possible to pass a block to {#lookup} and {#lookup_producer}, the block is passed the result of the lookup
# and the result of the block is returned as the value of the lookup. This is useful in order to provide a default value.
#
# @example Lookup with default value
# injector.lookup('favourite_food') {|x| x.nil? ? 'bacon' : x }
#
# Singleton or Not
# ----------------
# The lookup of a value is always based on the lookup of a producer. For *singleton producers* this means that the value is
# determined by the first value lookup. Subsequent lookups via `lookup` or `lookup_producer` will produce the same instance.
#
# *Non singleton producers* will produce a new instance on each request for a value. For constant value producers this
# means that a new deep-clone is produced for mutable objects (but not for immutable objects as this is not needed).
# Custom producers should have non singleton behavior, or if this is not possible ensure that the produced result is
# immutable. (The behavior if a custom producer hands out a mutable value and this is mutated is undefined).
#
# Custom bound producers capable of producing a series of objects when bound as a singleton means that the producer
# is a singleton, not the value it produces. If such a producer is bound as non singleton, each `lookup` will get a new
# producer (hence, typically, restarting the series). However, the producer returned from `lookup_producer` will not
# recreate the producer on each call to `produce`; i.e. each `lookup_producer` returns a producer capable of returning
# a series of objects.
#
# @see Puppet::Pops::Binder::Binder Binder, for details about how to bind keys to producers
# @see Puppet::Pops::Binder::BindingsFactory BindingsFactory, for a convenient way to create a Binder and bindings
#
# Assisted Inject
# ---------------
# The injector supports lookup of instances of classes *even if the requested class is not explicitly bound*.
# This is possible for classes that have a zero argument `initialize` method, or that has a class method called
# `inject` that takes two arguments; `injector`, and `scope`.
# This is useful in ruby logic as a class can then use the given injector to inject details.
# An `inject` class method wins over a zero argument `initialize` in all cases.
#
# @example Using assisted inject
# # Class with assisted inject support
# class Duck
# attr_reader :name, :year_of_birth
#
# def self.inject(injector, scope, binding, *args)
# # lookup default name and year of birth, and use defaults if not present
# name = injector.lookup(scope,'default-duck-name') {|x| x ? x : 'Donald Duck' }
# year_of_birth = injector.lookup(scope,'default-duck-year_of_birth') {|x| x ? x : 1934 }
# self.new(name, year_of_birth)
# end
#
# def initialize(name, year_of_birth)
# @name = name
# @year_of_birth = year_of_birth
# end
# end
#
# injector.lookup(scope, Duck)
# # Produces a Duck named 'Donald Duck' or named after the binding 'default-duck-name' (and with similar treatment of
# # year_of_birth).
# @see Puppet::Pops::Binder::Producers::AssistedInjectProducer AssistedInjectProducer, for more details on assisted injection
#
# Access to key factory and type calculator
# -----------------------------------------
# It is important to use the same key factory, and type calculator as the binder. It is therefor possible to obtaint
# these with the methods {#key_factory}, and {#type_calculator}.
#
# Special support for producers
# -----------------------------
# There is one method specially designed for producers. The {#get_contributions} method returns an array of all contributions
# to a given *contributions key*. This key is obtained from the {#key_factory} for a given multibinding. The returned set of
# contributed bindings is sorted in descending precedence order. Any conflicts, merges, etc. is performed by the multibinding
# producer configured for a multibinding.
#
# @api public
#
class Puppet::Pops::Binder::Injector
Producers = Puppet::Pops::Binder::Producers
# An Injector is initialized with a configured {Puppet::Pops::Binder::Binder Binder}.
#
# @param configured_binder [Puppet::Pops::Binder::Binder,nil] The configured binder containing effective bindings. A given value
# of nil creates an injector that returns or yields nil on all lookup requests.
# @raise ArgumentError if the given binder is not fully configured
#
# @api public
#
def initialize(configured_binder)
if configured_binder.nil?
@impl = Private::NullInjectorImpl.new()
else
@impl = Private::InjectorImpl.new(configured_binder)
end
end
# The KeyFactory used to produce keys in this injector.
# The factory is shared with the Binder to ensure consistent translation to keys.
# A compatible type calculator can also be obtained from the key factory.
# @return [Puppet::Pops::Binder::KeyFactory] the key factory in use
#
# @api public
#
def key_factory()
@impl.key_factory
end
# Returns the TypeCalculator in use for keys. The same calculator (as used for keys) should be used if there is a need
# to check type conformance, or infer the type of Ruby objects.
#
# @return [Puppet::Pops::Types::TypeCalculator] the type calculator that is in use for keys
# @api public
#
def type_calculator()
@impl.type_calculator()
end
# Lookup (a.k.a "inject") of a value given a key.
# The lookup may be called with different parameters. This method is a convenience method that
# dispatches to one of #lookup_key or #lookup_type depending on the arguments. It also provides
# the ability to use an optional block that is called with the looked up value, or scope and value if the
# block takes two parameters. This is useful to provide a default value or other transformations, calculations
# based on the result of the lookup.
#
# @overload lookup(scope, key)
# (see #lookup_key)
# @param scope [Puppet::Parser::Scope] the scope to use for evaluation
# @param key [Object] an opaque object being the full key
#
# @overload lookup(scope, type, name = '')
# (see #lookup_type)
# @param scope [Puppet::Parser::Scope] the scope to use for evaluation
# @param type [Puppet::Pops::Types::PObjectType] the type of what to lookup
# @param name [String] the name to use, defaults to empty string (for unnamed)
#
# @overload lookup(scope, name)
# Lookup of Data type with given name.
# @see #lookup_type
# @param scope [Puppet::Parser::Scope] the scope to use for evaluation
# @param name [String] the Data/name to lookup
#
# @yield [value] passes the looked up value to an optional block and returns what this block returns
# @yield [scope, value] passes scope and value to the block and returns what this block returns
# @yieldparam scope [Puppet::Parser::Scope] the scope given to lookup
# @yieldparam value [Object, nil] the looked up value or nil if nothing was found
#
# @raise [ArgumentError] if the block has an arity that is not 1 or 2
#
# @api public
#
def lookup(scope, *args, &block)
@impl.lookup(scope, *args, &block)
end
# Looks up a (typesafe) value based on a type/name combination.
# Creates a key for the type/name combination using a KeyFactory. Specialization of the Data type are transformed
# to a Data key, and the result is type checked to conform with the given key.
#
# @param type [Puppet::Pops::Types::PObjectType] the type to lookup as defined by Puppet::Pops::Types::TypeFactory
# @param name [String] the (optional for non `Data` types) name of the entry to lookup.
# The name may be an empty String (the default), but not nil. The name is required for lookup for subtypes of
# `Data`.
# @return [Object, nil] the looked up bound object, or nil if not found (type conformance with given type is guaranteed)
# @raise [ArgumentError] if the produced value does not conform with the given type
#
# @api public
#
def lookup_type(scope, type, name='')
@impl.lookup_type(scope, type, name)
end
# Looks up the key and returns the entry, or nil if no entry is found.
# Produced type is checked for type conformance with its binding, but not with the lookup key.
# (This since all subtypes of PDataType are looked up using a key based on PDataType).
# Use the Puppet::Pops::Types::TypeCalculator#instance? method to check for conformance of the result
# if this is wanted, or use #lookup_type.
#
# @param key [Object] lookup of key as produced by the key factory
# @return [Object, nil] produced value of type that conforms with bound type (type conformance with key not guaranteed).
# @raise [ArgumentError] if the produced value does not conform with the bound type
#
# @api public
#
def lookup_key(scope, key)
@impl.lookup_key(scope, key)
end
# Lookup (a.k.a "inject") producer of a value given a key.
# The producer lookup may be called with different parameters. This method is a convenience method that
# dispatches to one of #lookup_producer_key or #lookup_producer_type depending on the arguments. It also provides
# the ability to use an optional block that is called with the looked up producer, or scope and producer if the
# block takes two parameters. This is useful to provide a default value, call a custom producer method,
# or other transformations, calculations based on the result of the lookup.
#
# @overload lookup_producer(scope, key)
# (see #lookup_proudcer_key)
# @param scope [Puppet::Parser::Scope] the scope to use for evaluation
# @param key [Object] an opaque object being the full key
#
# @overload lookup_producer(scope, type, name = '')
# (see #lookup_type)
# @param scope [Puppet::Parser::Scope] the scope to use for evaluation
# @param type [Puppet::Pops::Types::PObjectType], the type of what to lookup
# @param name [String], the name to use, defaults to empty string (for unnamed)
#
# @overload lookup_producer(scope, name)
# Lookup of Data type with given name.
# @see #lookup_type
# @param scope [Puppet::Parser::Scope] the scope to use for evaluation
# @param name [String], the Data/name to lookup
#
# @return [Puppet::Pops::Binder::Producers::Producer, Object, nil] a producer, or what the optional block returns
#
# @yield [producer] passes the looked up producer to an optional block and returns what this block returns
# @yield [scope, producer] passes scope and producer to the block and returns what this block returns
# @yieldparam producer [Puppet::Pops::Binder::Producers::Producer, nil] the looked up producer or nil if nothing was bound
# @yieldparam scope [Puppet::Parser::Scope] the scope given to lookup
#
# @raise [ArgumentError] if the block has an arity that is not 1 or 2
#
# @api public
#
def lookup_producer(scope, *args, &block)
@impl.lookup_producer(scope, *args, &block)
end
# Looks up a Producer given an opaque binder key.
# @return [Puppet::Pops::Binder::Producers::Producer, nil] the bound producer, or nil if no such producer was found.
#
# @api public
#
def lookup_producer_key(scope, key)
@impl.lookup_producer_key(scope, key)
end
# Looks up a Producer given a type/name key.
# @note The result is not type checked (it cannot be until the producer has produced an instance).
# @return [Puppet::Pops::Binder::Producers::Producer, nil] the bound producer, or nil if no such producer was found
#
# @api public
#
def lookup_producer_type(scope, type, name='')
@impl.lookup_producer_type(scope, type, name)
end
# Returns the contributions to a multibind given its contribution key (as produced by the KeyFactory).
# This method is typically used by multibind value producers, but may be used for introspection of the injector's state.
#
# @param scope [Puppet::Parser::Scope] the scope to use
# @param contributions_key [Object] Opaque key as produced by KeyFactory as the contributions key for a multibinding
# @return [Array] the contributions sorted in deecending order of precedence
#
# @api public
#
def get_contributions(scope, contributions_key)
@impl.get_contributions(scope, contributions_key)
end
# Returns an Injector that returns (or yields) nil on all lookups, and produces an empty structure for contributions
# This method is intended for testing purposes.
#
def self.null_injector
self.new(nil)
end
# The implementation of the Injector is private.
# @see Puppet::Pops::Binder::Injector The public API this module implements.
# @api private
#
module Private
# This is a mocking "Null" implementation of Injector. It never finds anything
# @api private
class NullInjectorImpl
attr_reader :entries
attr_reader :key_factory
attr_reader :type_calculator
def initialize
@entries = []
@key_factory = Puppet::Pops::Binder::KeyFactory.new()
@type_calculator = @key_factory.type_calculator
end
def lookup(scope, *args, &block)
raise ArgumentError, "lookup should be called with two or three arguments, got: #{args.size()+1}" unless args.size.between?(1,2)
# call block with result if given
if block
case block.arity
when 1
block.call(:undef)
when 2
block.call(scope, :undef)
else
raise ArgumentError, "The block should have arity 1 or 2"
end
else
val
end
end
# @api private
def lookup_key(scope, key)
nil
end
# @api private
def lookup_producer(scope, *args, &block)
lookup(scope, *args, &block)
end
# @api private
def lookup_producer_key(scope, key)
nil
end
# @api private
def lookup_producer_type(scope, type, name='')
nil
end
def get_contributions()
[]
end
end
# @api private
#
class InjectorImpl
# Hash of key => InjectorEntry
# @api private
#
attr_reader :entries
attr_reader :key_factory
attr_reader :type_calculator
def initialize(configured_binder)
raise ArgumentError, "Given Binder is not configured" unless configured_binder && configured_binder.configured?()
@entries = configured_binder.injector_entries()
# It is essential that the injector uses the same key factory as the binder since keys must be
# represented the same (but still opaque) way.
#
@key_factory = configured_binder.key_factory()
@type_calculator = key_factory.type_calculator()
@@transform_visitor ||= Puppet::Pops::Visitor.new(nil,"transform", 2, 2)
@recursion_lock = [ ]
end
# @api private
def lookup(scope, *args, &block)
raise ArgumentError, "lookup should be called with two or three arguments, got: #{args.size()+1}" unless args.size.between?(1,2)
val = case args[ 0 ]
when Puppet::Pops::Types::PObjectType
lookup_type(scope, *args)
when String
raise ArgumentError, "lookup of name should only pass the name" unless args.size == 1
lookup_key(scope, key_factory.data_key(args[ 0 ]))
else
raise ArgumentError, 'lookup using a key should only pass a single key' unless args.size == 1
lookup_key(scope, args[ 0 ])
end
# call block with result if given
if block
case block.arity
when 1
block.call(val)
when 2
block.call(scope, val)
else
raise ArgumentError, "The block should have arity 1 or 2"
end
else
val
end
end
# Produces a key for a type/name combination.
# @api private
def named_key(type, name)
key_factory.named_key(type, name)
end
# Produces a key for a PDataType/name combination
# @api private
def data_key(name)
key_factory.data_key(name)
end
# @api private
def lookup_type(scope, type, name='')
val = lookup_key(scope, named_key(type, name))
unless key_factory.type_calculator.instance?(type, val)
raise ArgumentError, "Type error: incompatible type, #{type_error_detail(type, val)}"
end
val
end
# @api private
def type_error_detail(expected, actual)
actual_t = type_calculator.infer(actual)
"expected: #{type_calculator.string(expected)}, got: #{type_calculator.string(actual_t)}"
end
# @api private
def lookup_key(scope, key)
if @recursion_lock.include?(key)
raise ArgumentError, "Lookup loop detected for key: #{key}"
end
begin
@recursion_lock.push(key)
case entry = get_entry(key)
when NilClass
nil
when Puppet::Pops::Binder::InjectorEntry
val = produce(scope, entry)
return nil if val.nil?
unless key_factory.type_calculator.instance?(entry.binding.type, val)
raise "Type error: incompatible type returned by producer, #{type_error_detail(entry.binding.type, val)}"
end
val
when Producers::AssistedInjectProducer
entry.produce(scope)
else
# internal, direct entries
entry
end
ensure
@recursion_lock.pop()
end
end
# Should be used to get entries as it converts missing entries to NotFound entries or AssistedInject entries
#
# @api private
def get_entry(key)
case entry = entries[ key ]
when NilClass
# not found, is this an assisted inject?
if clazz = assistable_injected_class(key)
entry = Producers::AssistedInjectProducer.new(self, clazz)
entries[ key ] = entry
else
entries[ key ] = NotFound.new()
entry = nil
end
when NotFound
entry = nil
end
entry
end
# Returns contributions to a multibind in precedence order; highest first.
# Returns an Array on the form [ [key, entry], [key, entry]] where the key is intended to be used to lookup the value
# (or a producer) for that entry.
# @api private
def get_contributions(scope, contributions_key)
result = {}
return [] unless contributions = lookup_key(scope, contributions_key)
contributions.each { |k| result[k] = get_entry(k) }
result.sort {|a, b| a[0] <=> b[0] }
#result.sort_by {|key, entry| entry }
end
# Produces an injectable class given a key, or nil if key does not represent an injectable class
# @api private
#
def assistable_injected_class(key)
kt = key_factory.get_type(key)
return nil unless kt.is_a?(Puppet::Pops::Types::PRubyType) && !key_factory.is_named?(key)
type_calculator.injectable_class(kt)
end
def lookup_producer(scope, *args, &block)
raise ArgumentError, "lookup_producer should be called with two or three arguments, got: #{args.size()+1}" unless args.size <= 2
p = case args[ 0 ]
when Puppet::Pops::Types::PObjectType
lookup_producer_type(scope, *args)
when String
raise ArgumentError, "lookup_producer of name should only pass the name" unless args.size == 1
lookup_producer_key(scope, key_factory.data_key(args[ 0 ]))
else
raise ArgumentError, "lookup_producer using a key should only pass a single key" unless args.size == 1
lookup_producer_key(scope, args[ 0 ])
end
# call block with result if given
if block
case block.arity
when 1
block.call(p)
when 2
block.call(scope, p)
else
raise ArgumentError, "The block should have arity 1 or 2"
end
else
p
end
end
# @api private
def lookup_producer_key(scope, key)
if @recursion_lock.include?(key)
raise ArgumentError, "Lookup loop detected for key: #{key}"
end
begin
@recursion_lock.push(key)
producer(scope, get_entry(key), :multiple_use)
ensure
@recursion_lock.pop()
end
end
# @api private
def lookup_producer_type(scope, type, name='')
lookup_producer_key(scope, named_key(type, name))
end
# Returns the producer for the entry
# @return [Puppet::Pops::Binder::Producers::Producer] the entry's producer.
#
# @api private
#
def producer(scope, entry, use)
return nil unless entry # not found
return entry.producer(scope) if entry.is_a?(Producers::AssistedInjectProducer)
unless entry.cached_producer
entry.cached_producer = transform(entry.binding.producer, scope, entry)
end
unless entry.cached_producer
raise ArgumentError, "Injector entry without a producer #{format_binding(entry.binding)}"
end
entry.cached_producer.producer(scope)
end
# @api private
def transform(producer_descriptor, scope, entry)
@@transform_visitor.visit_this(self, producer_descriptor, scope, entry)
end
# Returns the produced instance
# @return [Object] the produced instance
# @api private
#
def produce(scope, entry)
return nil unless entry # not found
producer(scope, entry, :single_use).produce(scope)
end
# @api private
def named_arguments_to_hash(named_args)
nb = named_args.nil? ? [] : named_args
result = {}
nb.each {|arg| result[ :"#{arg.name}" ] = arg.value }
result
end
# @api private
def merge_producer_options(binding, options)
named_arguments_to_hash(binding.producer_args).merge(options)
end
# @api private
def format_binding(b)
Puppet::Pops::Binder::Binder.format_binding(b)
end
# Handles a missing producer (which is valid for a Multibinding where one is selected automatically)
# @api private
#
def transform_NilClass(descriptor, scope, entry)
unless entry.binding.is_a?(Puppet::Pops::Binder::Bindings::Multibinding)
raise ArgumentError, "Binding without producer detected, #{format_binding(entry.binding)}"
end
case entry.binding.type
when Puppet::Pops::Types::PArrayType
transform(Puppet::Pops::Binder::Bindings::ArrayMultibindProducerDescriptor.new(), scope, entry)
when Puppet::Pops::Types::PHashType
transform(Puppet::Pops::Binder::Bindings::HashMultibindProducerDescriptor.new(), scope, entry)
else
raise ArgumentError, "Unsupported multibind type, must be an array or hash type, #{format_binding(entry.binding)}"
end
end
# @api private
def transform_ArrayMultibindProducerDescriptor(descriptor, scope, entry)
make_producer(Producers::ArrayMultibindProducer, descriptor, scope, entry, named_arguments_to_hash(entry.binding.producer_args))
end
# @api private
def transform_HashMultibindProducerDescriptor(descriptor, scope, entry)
make_producer(Producers::HashMultibindProducer, descriptor, scope, entry, named_arguments_to_hash(entry.binding.producer_args))
end
# @api private
def transform_ConstantProducerDescriptor(descriptor, scope, entry)
producer_class = singleton?(descriptor) ? Producers::SingletonProducer : Producers::DeepCloningProducer
producer_class.new(self, entry.binding, scope, merge_producer_options(entry.binding, {:value => descriptor.value}))
end
# @api private
def transform_InstanceProducerDescriptor(descriptor, scope, entry)
make_producer(Producers::InstantiatingProducer, descriptor, scope, entry,
merge_producer_options(entry.binding, {:class_name => descriptor.class_name, :init_args => descriptor.arguments}))
end
# @api private
def transform_EvaluatingProducerDescriptor(descriptor, scope, entry)
make_producer(Producers::EvaluatingProducer, descriptor, scope, entry,
merge_producer_options(entry.binding, {:expression => descriptor.expression}))
end
# @api private
def make_producer(clazz, descriptor, scope, entry, options)
singleton_wrapped(descriptor, scope, entry, clazz.new(self, entry.binding, scope, options))
end
# @api private
def singleton_wrapped(descriptor, scope, entry, producer)
return producer unless singleton?(descriptor)
Producers::SingletonProducer.new(self, entry.binding, scope,
merge_producer_options(entry.binding, {:value => producer.produce(scope)}))
end
# @api private
def transform_ProducerProducerDescriptor(descriptor, scope, entry)
p = transform(descriptor.producer, scope, entry)
clazz = singleton?(descriptor) ? Producers::SingletonProducerProducer : Producers::ProducerProducer
clazz.new(self, entry.binding, scope, merge_producer_options(entry.binding,
merge_producer_options(entry.binding, { :producer_producer => p })))
end
# @api private
def transform_LookupProducerDescriptor(descriptor, scope, entry)
make_producer(Producers::LookupProducer, descriptor, scope, entry,
merge_producer_options(entry.binding, {:type => descriptor.type, :name => descriptor.name}))
end
# @api private
def transform_HashLookupProducerDescriptor(descriptor, scope, entry)
make_producer(Producers::LookupKeyProducer, descriptor, scope, entry,
merge_producer_options(entry.binding, {:type => descriptor.type, :name => descriptor.name, :key => descriptor.key}))
end
# @api private
def transform_NonCachingProducerDescriptor(descriptor, scope, entry)
# simply delegates to the wrapped producer
transform(descriptor.producer, scope, entry)
end
# @api private
def transform_FirstFoundProducerDescriptor(descriptor, scope, entry)
make_producer(Producers::FirstFoundProducer, descriptor, scope, entry,
merge_producer_options(entry.binding, {:producers => descriptor.producers.collect {|p| transform(p, scope, entry) }}))
end
# @api private
def singleton?(descriptor)
! descriptor.eContainer().is_a?(Puppet::Pops::Binder::Bindings::NonCachingProducerDescriptor)
end
# Special marker class used in entries
# @api private
class NotFound
end
end
end
end puppet-3.4.3/lib/puppet/pops/binder/binder.rb 0000644 0052762 0001160 00000034554 12300765631 021043 0 ustar jenkins jenkins # The Binder is responsible for processing layered bindings that can be used to setup an Injector.
#
# An instance should be created, and calls should then be made to {#define_categories} to define the available categories, and
# their precedence. This should be followed by a call to {#define_layers} which will match the layered bindings against the
# effective categories (filtering out everything that does not apply, handle overrides, abstract entries etc.).
# The constructed hash with `key => InjectorEntry` mappings is obtained as {#injector_entries}, and is used to initialize an
# {Puppet::Pops::Binder::Injector Injector}.
#
# @api public
#
class Puppet::Pops::Binder::Binder
# This limits the number of available categorizations, including "common".
# @api private
PRECEDENCE_MAX = 1000
# @api private
attr_reader :category_precedences
# @api private
attr_reader :category_values
# @api private
attr_reader :injector_entries
# @api private
attr_reader :key_factory
# Whether the binder is fully configured or not
# @api public
#
attr_reader :configured
# @api public
def initialize
@category_precedences = {}
@category_values = {}
@key_factory = Puppet::Pops::Binder::KeyFactory.new()
# Resulting hash of all key -> binding
@injector_entries = {}
# Not configured until the fat lady sings
@configured = false
@next_anonymous_key = 0
end
# Answers the question 'is this binder configured?' to the point it can be used to instantiate an Injector
# @api public
def configured?()
configured()
end
# Defines the effective categories in precedence order (highest precedence first).
# The 'common' (lowest precedence) category should not be included in the list.
# A sanity check is made that there are no more than 1000 categorizations (which is pretty wild).
#
# The term 'effective categories' refers to the evaluated list of tuples (categorization, category-value) represented with
# an instance of Puppet::Pops::Binder::Bindings::EffectiveCategories.
#
# @param effective_categories [Puppet::Pops::Binder::Bindings::EffectiveCategories] effective categories (i.e. with evaluated values)
# @raise ArgumentError if this binder is already configured
# @raise ArgumentError if the argument is not an EffectiveCategories
# @raise ArgumentError if there is an attempt to redefine a category (non unique, or 'common').
# @return [Puppet::Pops::Binder::Binder] self
# @api public
#
def define_categories(effective_categories)
raise ArgumentError, "This categories are already defined. Cannot redefine." unless @category_precedences.empty?
# Note: a model instance is used since a Hash does not have a defined order in all Rubies.
unless effective_categories.is_a?(Puppet::Pops::Binder::Bindings::EffectiveCategories)
raise ArgumentError, "Expected Puppet::Pops::Binder::Bindings::EffectiveCategories, but got a: #{effective_categories.class}"
end
categories = effective_categories.categories
raise ArgumentError, "Category limit (#{PRECEDENCE_MAX}) exceeded" unless categories.size <= PRECEDENCE_MAX
# Automatically add the 'common' category with lowest precedence
@category_precedences['common'] = 0
# if categories contains "common", it should be last - simply drop it if present
if last = categories[-1]
if last.categorization == 'common'
categories.delete_at(-1)
end
end
# Process the given categories (highest precedence is first in the list)
categories.each_with_index do |c, index|
cname = c.categorization
raise ArgumentError, "Attempt to redefine categorization: #{cname}" if @category_precedences[cname]
@category_precedences[cname] = PRECEDENCE_MAX - index
@category_values[cname] = c.value
end
self
end
# Binds layers from highest to lowest as defined by the given LayeredBindings.
# @note
# Categories must be set with #define_categories before calling this method. The model should have been
# validated to get better error messages if the model is invalid. This implementation expects the model
# to be valid, and any errors raised will be more technical runtime errors.
#
# @param layered_bindings [Puppet::Pops::Binder::Bindings::LayeredBindings] the named and ordered layers
# @raise ArgumentError if categories have not been defined
# @raise ArgumentError if this binder is already configured
# @raise ArgumentError if bindings with unresolved 'override' surfaces as an effective binding
# @raise ArgumentError if the given argument has the wrong type, or if model is invalid in some way
# @return [Puppet::Pops::Binder::Binder] self
# @api public
#
def define_layers(layered_bindings)
raise ArgumentError, "This binder is already configured. Cannot redefine its content." if configured?()
raise ArgumentError, "Categories must be defined first" if @category_precedences.empty?
LayerProcessor.new(self, key_factory).bind(layered_bindings)
injector_entries.each do |k,v|
unless key_factory.is_contributions_key?(k) || v.is_resolved?()
raise ArgumentError, "Binding with unresolved 'override' detected: #{self.class.format_binding(v.binding)}}"
end
end
# and the fat lady has sung
@configured = true
self
end
# @api private
def next_anonymous_key
tmp = @next_anonymous_key
@next_anonymous_key += 1
tmp
end
# @api private
def self.format_binding(b)
type_name = Puppet::Pops::Types::TypeCalculator.new().string(b.type)
layer_name, bindings_name = get_named_binding_layer_and_name(b)
"binding: '#{type_name}/#{b.name}' in: '#{bindings_name}' in layer: '#{layer_name}'"
end
# @api private
def self.format_contribution_source(b)
layer_name, bindings_name = get_named_binding_layer_and_name(b)
"(layer: #{layer_name}, bindings: #{bindings_name})"
end
# @api private
def self.get_named_binding_layer_and_name(b)
return ['', ''] if b.nil?
return [get_named_layer(b), b.name] if b.is_a?(Puppet::Pops::Binder::Bindings::NamedBindings)
get_named_binding_layer_and_name(b.eContainer)
end
# @api private
def self.get_named_layer(b)
return '' if b.nil?
return b.name if b.is_a?(Puppet::Pops::Binder::Bindings::NamedLayer)
get_named_layer(b.eContainer)
end
# Processes the information in a layer, aggregating it to the injector_entries hash in its parent binder.
# A LayerProcessor holds the intermediate state required while processing one layer.
#
# @api private
#
class LayerProcessor
attr :effective_prec
attr :prec_stack
attr :bindings
attr :binder
attr :key_factory
attr :contributions
def initialize(binder, key_factory)
@binder = binder
@key_factory = key_factory
@prec_stack = []
@effective_prec = nil
@bindings = []
@contributions = []
@@bind_visitor ||= Puppet::Pops::Visitor.new(nil,"bind",0,0)
end
# Add the binding to the list of potentially effective bindings from this layer
# @api private
#
def add(b)
bindings << Puppet::Pops::Binder::InjectorEntry.new(effective_prec, b)
end
# Add a multibind contribution
# @api private
#
def add_contribution(b)
contributions << Puppet::Pops::Binder::InjectorEntry.new(effective_prec, b)
end
# Bind given abstract binding
# @api private
#
def bind(binding)
@@bind_visitor.visit_this(self, binding)
end
# @return [Puppet::Pops::Binder::InjectorEntry] the entry with the highest (category) precedence
# @api private
def highest(b1, b2)
case b1.precedence <=> b2.precedence
when 1
b1
when -1
b2
when 0
raise_conflicting_binding(b1, b2)
end
end
# Raises a conflicting bindings error given two InjectorEntry's with same precedence in the same layer
# (if they are in different layers, something is seriously wrong)
def raise_conflicting_binding(b1, b2)
b1_layer_name, b1_bindings_name = Puppet::Pops::Binder::Binder.get_named_binding_layer_and_name(b1.binding)
b2_layer_name, b2_bindings_name = Puppet::Pops::Binder::Binder.get_named_binding_layer_and_name(b2.binding)
# The resolution is per layer, and if they differ something is serious wrong as a higher layer
# overrides a lower; so no such conflict should be possible:
unless b1_layer_name == b2_layer_name
raise ArgumentError, [
'Internal Error: Conflicting binding for',
"'#{b1.binding.name}'",
'being resolved across layers',
"'#{b1_layer_name}' and",
"'#{b2_layer_name}'"
].join(' ')
end
# Conflicting bindings made from the same source
if b1_bindings_name == b2_bindings_name
raise ArgumentError, [
'Conflicting binding for name:',
"'#{b1.binding.name}'",
'in layer:',
"'#{b1_layer_name}', ",
'both from:',
"'#{b1_bindings_name}'"
].join(' ')
end
# Conflicting bindings from different sources
raise ArgumentError, [
'Conflicting binding for name:',
"'#{b1.binding.name}'",
'in layer:',
"'#{b1_layer_name}',",
'from:',
"'#{b1_bindings_name}', and",
"'#{b2_bindings_name}'"
].join(' ')
end
# Produces the key for the given Binding.
# @param binding [Puppet::Pops::Binder::Bindings::Binding] the binding to get a key for
# @return [Object] an opaque key
# @api private
#
def key(binding)
k = if is_contribution?(binding)
# contributions get a unique (sequential) key
binder.next_anonymous_key()
else
key_factory.binding_key(binding)
end
end
# @api private
def is_contribution?(binding)
! binding.multibind_id.nil?
end
# @api private
def push_precedences(precedences)
prec_stack.push(precedences)
@effective_prec = nil # clear cache
end
# @api private
def pop_precedences()
prec_stack.pop()
@effective_prec = nil # clear cache
end
# Returns the effective precedence as an array with highest precedence first.
# Internally the precedence is an array with the highest precedence first.
#
# @api private
#
def effective_prec()
unless @effective_prec
@effective_prec = prec_stack.flatten.uniq.sort.reverse
if @effective_prec.size == 0
@effective_prec = [ 0 ] # i.e. "common"
end
end
@effective_prec
end
# @api private
def bind_Binding(o)
if is_contribution?(o)
add_contribution(o)
else
add(o)
end
end
# @api private
def bind_Bindings(o)
o.bindings.each {|b| bind(b) }
end
# @api private
def bind_NamedBindings(o)
# Name is ignored here, it should be introspected when needed (in case of errors)
o.bindings.each {|b| bind(b) }
end
# Process CategorizedBindings by calculating precedence, and then if satisfying the predicates, process the contained
# bindings.
# @api private
#
def bind_CategorizedBindings(o)
precedences = o.predicates.collect do |p|
prec = binder.category_precedences[p.categorization]
# Skip bindings if the categorization is not present, or
# if the category value is not the effective value for the categorization
# Ignore the value for the common category (it is not possible to state common 'false' etc.)
#
return unless prec
return unless binder.category_values[p.categorization] == p.value.downcase || p.categorization == 'common'
prec
end
push_precedences(precedences)
o.bindings.each {|b| bind(b) }
pop_precedences()
end
# Process layered bindings from highest to lowest layer
# @api private
#
def bind_LayeredBindings(o)
o.layers.each do |layer|
processor = LayerProcessor.new(binder, key_factory)
# All except abstract (==error) are transfered to injector_entries
processor.bind(layer).each do |k, v|
entry = binder.injector_entries[k]
unless key_factory.is_contributions_key?(k)
if v.is_abstract?()
layer_name, bindings_name = Puppet::Pops::Binder::Binder.get_named_binding_layer_and_name(v.binding)
type_name = key_factory.type_calculator.string(v.binding.type)
raise ArgumentError, "The abstract binding '#{type_name}/#{v.binding.name}' in '#{bindings_name}' in layer '#{layer_name}' was not overridden"
end
raise ArgumentError, "Internal Error - redefinition of key: #{k}, (should never happen)" if entry
binder.injector_entries[k] = v
else
entry ? entry << v : binder.injector_entries[k] = v
end
end
end
end
# Processes one named ("top level") layer consisting of a list of NamedBindings
# @api private
#
def bind_NamedLayer(o)
o.bindings.each {|b| bind(b) }
this_layer = {}
# process regular bindings
bindings.each do |b|
bkey = key(b.binding)
# ignore if a higher layer defined it, but ensure override gets resolved
if x = binder.injector_entries[bkey]
x.mark_override_resolved()
next
end
# if already found in this layer, one wins (and resolves override), or it is an error
existing = this_layer[bkey]
winner = existing ? highest(existing, b) : b
this_layer[bkey] = winner
if existing
winner.mark_override_resolved()
end
end
# Process contributions
# - organize map multibind_id to bindings with this id
# - for each id, create an array with the unique anonymous keys to the contributed bindings
# - bind the index to a special multibind contributions key (these are aggregated)
#
c_hash = Hash.new {|hash, key| hash[ key ] = [] }
contributions.each {|b| c_hash[ b.binding.multibind_id ] << b }
# - for each id
c_hash.each do |k, v|
index = v.collect do |b|
bkey = key(b.binding)
this_layer[bkey] = b
bkey
end
contributions_key = key_factory.multibind_contributions(k)
unless this_layer[contributions_key]
this_layer[contributions_key] = []
end
this_layer[contributions_key] += index
end
this_layer
end
end
end
puppet-3.4.3/lib/puppet/pops/binder/bindings_checker.rb 0000644 0052762 0001160 00000016704 12300765631 023056 0 ustar jenkins jenkins # A validator/checker of a bindings model
# @api public
#
class Puppet::Pops::Binder::BindingsChecker
Bindings = Puppet::Pops::Binder::Bindings
Issues = Puppet::Pops::Binder::BinderIssues
Types = Puppet::Pops::Types
attr_reader :type_calculator
attr_reader :acceptor
# @api public
def initialize(diagnostics_producer)
@@check_visitor ||= Puppet::Pops::Visitor.new(nil, "check", 0, 0)
@type_calculator = Puppet::Pops::Types::TypeCalculator.new()
@expression_validator = Puppet::Pops::Validation::ValidatorFactory_3_1.new().checker(diagnostics_producer)
@acceptor = diagnostics_producer
end
# Validates the entire model by visiting each model element and calling `check`.
# The result is collected (or acted on immediately) by the configured diagnostic provider/acceptor
# given when creating this Checker.
#
# @api public
#
def validate(b)
check(b)
b.eAllContents.each {|c| check(c) }
end
# Performs binding validity check
# @api private
def check(b)
@@check_visitor.visit_this(self, b)
end
# Checks that a binding has a producer and a type
# @api private
def check_Binding(b)
# Must have a type
acceptor.accept(Issues::MISSING_TYPE, b) unless b.type.is_a?(Types::PObjectType)
# Must have a producer
acceptor.accept(Issues::MISSING_PRODUCER, b) unless b.producer.is_a?(Bindings::ProducerDescriptor)
end
# Checks that the producer is a Multibind producer and that the type is a PCollectionType
# @api private
def check_Multibinding(b)
# id is optional (empty id blocks contributions)
# A multibinding must have PCollectionType
acceptor.accept(Issues::MULTIBIND_TYPE_ERROR, b, {:actual_type => b.type}) unless b.type.is_a?(Types::PCollectionType)
# if the producer is nil, a suitable producer will be picked automatically
unless b.producer.nil? || b.producer.is_a?(Bindings::MultibindProducerDescriptor)
acceptor.accept(Issues::MULTIBIND_NOT_COLLECTION_PRODUCER, b, {:actual_producer => b.producer})
end
end
# Checks that the bindings object contains at least one binding. Then checks each binding in turn
# @api private
def check_Bindings(b)
acceptor.accept(Issues::MISSING_BINDINGS, b) unless has_entries?(b.bindings)
end
# Checks that a name has been associated with the bindings
# @api private
def check_NamedBindings(b)
acceptor.accept(Issues::MISSING_BINDINGS_NAME, b) unless has_chars?(b.name)
check_Bindings(b)
end
# Check that the category has a categorization and a value
# @api private
def check_Category(c)
acceptor.accept(Issues::MISSING_CATEGORIZATION, binding_parent(c)) unless has_chars?(c.categorization)
acceptor.accept(Issues::MISSING_CATEGORY_VALUE, binding_parent(c)) unless has_chars?(c.value)
end
# Check that the binding contains at least one predicate and that all predicates are categorized and has a value
# @api private
def check_CategorizedBindings(b)
acceptor.accept(Issues::MISSING_PREDICATES, b) unless has_entries?(b.predicates)
check_Bindings(b)
end
# @api private
def check_EffectiveCategories(ec)
end
# Check layer has a name
# @api private
def check_NamedLayer(l)
acceptor.accept(Issues::MISSING_LAYER_NAME, binding_parent(l)) unless has_chars?(l.name)
# It is ok to have an empty layer
# acceptor.accept(Issues::MISSING_BINDINGS_IN_LAYER, binding_parent(l), { :layer => l.name }) unless has_entries?(l.bindings)
end
# Checks that the binding has layers and that each layer has a name and at least one binding
# @api private
def check_LayeredBindings(b)
acceptor.accept(Issues::MISSING_LAYERS, b) unless has_entries?(b.layers)
end
# Checks that the non caching producer has a producer to delegate to
# @api private
def check_NonCachingProducerDescriptor(p)
acceptor.accept(Issues::PRODUCER_MISSING_PRODUCER, p) unless p.producer.is_a?(Bindings::ProducerDescriptor)
end
# Checks that a constant value has been declared in the producer and that the type
# of the value is compatible with the type declared in the binding
# @api private
def check_ConstantProducerDescriptor(p)
# the product must be of compatible type
# TODO: Likely to change when value becomes a typed Puppet Object
b = binding_parent(p)
if p.value.nil?
acceptor.accept(Issues::MISSING_VALUE, p, {:binding => b})
else
infered = type_calculator.infer(p.value)
unless type_calculator.assignable?(b.type, infered)
acceptor.accept(Issues::INCOMPATIBLE_TYPE, p, {:binding => b, :expected_type => b.type, :actual_type => infered})
end
end
end
# Checks that an expression has been declared in the producer
# @api private
def check_EvaluatingProducerDescriptor(p)
unless p.expression.is_a?(Puppet::Pops::Model::Expression)
acceptor.accept(Issues::MISSING_EXPRESSION, p, {:binding => binding_parent(p)})
end
end
# Checks that a class name has been declared in the producer
# @api private
def check_InstanceProducerDescriptor(p)
acceptor.accept(Issues::MISSING_CLASS_NAME, p, {:binding => binding_parent(p)}) unless has_chars?(p.class_name)
end
# Checks that a type and a name has been declared. The type must be assignable to the type
# declared in the binding. The name can be an empty string to denote 'no name'
# @api private
def check_LookupProducerDescriptor(p)
b = binding_parent(p)
unless type_calculator.assignable(b.type, p.type)
acceptor.accept(Issues::INCOMPATIBLE_TYPE, p, {:binding => b, :expected_type => b.type, :actual_type => p.type })
end
acceptor.accept(Issues::MISSING_NAME, p, {:binding => b}) if p.name.nil? # empty string is OK
end
# Checks that a key has been declared, then calls producer_LookupProducerDescriptor to perform
# checks associated with the super class
# @api private
def check_HashLookupProducerDescriptor(p)
acceptor.accept(Issues::MISSING_KEY, p, {:binding => binding_parent(p)}) unless has_chars?(p.key)
check_LookupProducerDescriptor(p)
end
# Checks that the type declared in the binder is a PArrayType
# @api private
def check_ArrayMultibindProducerDescriptor(p)
b = binding_parent(p)
acceptor.accept(Issues::MULTIBIND_INCOMPATIBLE_TYPE, p, {:binding => b, :actual_type => b.type}) unless b.type.is_a?(Types::PArrayType)
end
# Checks that the type declared in the binder is a PHashType
# @api private
def check_HashMultibindProducerDescriptor(p)
b = binding_parent(p)
acceptor.accept(Issues::MULTIBIND_INCOMPATIBLE_TYPE, p, {:binding => b, :actual_type => b.type}) unless b.type.is_a?(Types::PHashType)
end
# Checks that the producer that this producer delegates to is declared
# @api private
def check_ProducerProducerDescriptor(p)
unless p.producer.is_a?(Bindings::ProducerDescriptor)
acceptor.accept(Issues::PRODUCER_MISSING_PRODUCER, p, {:binding => binding_parent(p)})
end
end
# @api private
def check_Expression(t)
@expression_validator.validate(t)
end
# @api private
def check_PObjectType(t)
# Do nothing
end
# Returns true if the argument is a non empty string
# @api private
def has_chars?(s)
s.is_a?(String) && !s.empty?
end
# @api private
def has_entries?(s)
!(s.nil? || s.empty?)
end
# @api private
def binding_parent(p)
begin
x = p.eContainer
if x.nil?
acceptor.accept(Issues::MODEL_OBJECT_IS_UNBOUND, p)
return nil
end
p = x
end while !p.is_a?(Bindings::AbstractBinding)
p
end
end
puppet-3.4.3/lib/puppet/pops/binder/hiera2.rb 0000644 0052762 0001160 00000000766 12300765631 020750 0 ustar jenkins jenkins # The Hiera2 Module contains the classes needed to configure a bindings producer
# to read module specific data. The configuration is expected to be found in
# a hiera.yaml file in the root of each module
module Puppet::Pops::Binder::Hiera2
require 'puppet/pops/binder/hiera2/config_checker'
require 'puppet/pops/binder/hiera2/config'
require 'puppet/pops/binder/hiera2/diagnostic_producer'
require 'puppet/pops/binder/hiera2/bindings_provider'
require 'puppet/pops/binder/hiera2/issues'
end
puppet-3.4.3/lib/puppet/pops/binder/bindings_composer.rb 0000644 0052762 0001160 00000023313 12300765631 023273 0 ustar jenkins jenkins # The BindingsComposer handles composition of multiple bindings sources
# It is directed by a {Puppet::Pops::Binder::Config::BinderConfig BinderConfig} that indicates how
# the final composition should be layered, and what should be included/excluded in each layer
#
# The bindings composer is intended to be used once per environment as the compiler starts its work.
#
# TODO: Possibly support envdir: scheme / relative to environment root (== same as confdir if there is only one environment).
# This is probably easier to do after ENC changes described in ARM-8 have been implemented.
# TODO: If same config is loaded in a higher layer, skip it in the lower (since it is meaningless to load it again with lower
# precedence. (Optimization, or possibly an error, should produce a warning).
#
class Puppet::Pops::Binder::BindingsComposer
# The BindingsConfig instance holding the read and parsed, but not evaluated configuration
# @api public
#
attr_reader :config
# map of scheme name to handler
# @api private
attr_reader :scheme_handlers
# @return Hash map of module name to module instance
# @api private
attr_reader :name_to_module
# @api private
attr_reader :confdir
# @api private
attr_reader :diagnostics
# Container of all warnings and errors produced while initializing and loading bindings
#
# @api public
attr_reader :acceptor
# @api public
def initialize()
@acceptor = Puppet::Pops::Validation::Acceptor.new()
@diagnostics = Puppet::Pops::Binder::Config::DiagnosticProducer.new(acceptor)
@config = Puppet::Pops::Binder::Config::BinderConfig.new(@diagnostics)
if acceptor.errors?
Puppet::Pops::IssueReporter.assert_and_report(acceptor, :message => 'Binding Composer: error while reading config.')
raise Puppet::DevError.new("Internal Error: IssueReporter did not raise exception for errors in bindings config.")
end
end
# Configures and creates the boot injector.
# The read config may optionally contain mapping of bindings scheme handler name to handler class, and
# mapping of biera2 backend symbolic name to backend class.
# If present, these are turned into bindings in the category 'extension' (which is only used in the boot injector) which
# has higher precedence than 'default'. This is done to allow users to override the default bindings for
# schemes and backends.
# @param scope [Puppet::Parser:Scope] the scope (used to find compiler and injector for the environment)
# @api private
#
def configure_and_create_injector(scope)
# create the injector (which will pick up the bindings registered above)
@scheme_handlers = SchemeHandlerHelper.new(scope)
# get extensions from the config
# ------------------------------
scheme_extensions = @config.scheme_extensions
hiera_backends = @config.hiera_backends
# Define a named bindings that are known by the SystemBindings
boot_bindings = Puppet::Pops::Binder::BindingsFactory.named_bindings(Puppet::Pops::Binder::SystemBindings::ENVIRONMENT_BOOT_BINDINGS_NAME) do
scheme_extensions.each_pair do |scheme, class_name|
# turn each scheme => class_name into a binding (contribute to the buildings-schemes multibind).
# do this in category 'extensions' to allow them to override the 'default'
when_in_category('extension', 'true').bind do
name(scheme)
instance_of(Puppetx::BINDINGS_SCHEMES_TYPE)
in_multibind(Puppetx::BINDINGS_SCHEMES)
to_instance(class_name)
end
end
hiera_backends.each_pair do |symbolic, class_name|
# turn each symbolic => class_name into a binding (contribute to the hiera backends multibind).
# do this in category 'extensions' to allow them to override the 'default'
when_in_category('extension', 'true').bind do
name(symbolic)
instance_of(Puppetx::HIERA2_BACKENDS_TYPE)
in_multibind(Puppetx::HIERA2_BACKENDS)
to_instance(class_name)
end
end
end
@injector = scope.compiler.create_boot_injector(boot_bindings.model)
end
# @return [Puppet::Pops::Binder::Bindings::LayeredBindings]
def compose(scope)
# The boot injector is used to lookup scheme-handlers
configure_and_create_injector(scope)
# get all existing modules and their root path
@name_to_module = {}
scope.environment.modules.each {|mod| name_to_module[mod.name] = mod }
# setup the confdir
@confdir = Puppet.settings[:confdir]
factory = Puppet::Pops::Binder::BindingsFactory
contributions = []
configured_layers = @config.layering_config.collect do | layer_config |
# get contributions with effective categories
contribs = configure_layer(layer_config, scope, diagnostics)
# collect the contributions separately for later checking of category precedence
contributions.concat(contribs)
# create a named layer with all the bindings for this layer
factory.named_layer(layer_config['name'], *contribs.collect {|c| c.bindings }.flatten)
end
# must check all contributions are based on compatible category precedence
# (Note that contributions no longer contains the bindings as a side effect of setting them in the collected
# layer. The effective categories and the name remains in the contributed model; this is enough for checking
# and error reporting).
check_contribution_precedence(contributions)
# Add the two system layers; the final - highest ("can not be overridden" layer), and the lowest
# Everything here can be overridden 'default' layer.
#
configured_layers.insert(0, Puppet::Pops::Binder::SystemBindings.final_contribution)
configured_layers.insert(-1, Puppet::Pops::Binder::SystemBindings.default_contribution)
# and finally... create the resulting structure
factory.layered_bindings(*configured_layers)
end
# Evaluates configured categorization and returns the result.
# The result is not cached.
# @api public
#
def effective_categories(scope)
unevaluated_categories = @config.categorization
parser = Puppet::Pops::Parser::EvaluatingParser.new()
file_source = @config.config_file or "defaults in: #{__FILE__}"
evaluated_categories = unevaluated_categories.collect do |category_tuple|
evaluated_categories = [ category_tuple[0], parser.evaluate_string( scope, parser.quote( category_tuple[1] ), file_source ) ]
if evaluated_categories[1].is_a?(String)
# category values are always in lower case
evaluated_categories[1] = evaluated_categories[1].downcase
else
raise ArgumentError, "Categorization value must be a string, category #{evaluated_categories[0]} evaluation resulted in a: '#{result[1].class}'"
end
evaluated_categories
end
Puppet::Pops::Binder::BindingsFactory::categories(evaluated_categories)
end
private
# Checks that contribution's effective categorization is in the same relative order as in the overall
# categorization precedence.
#
def check_contribution_precedence(contributions)
cat_prec = { }
@config.categorization.each_with_index {|c, i| cat_prec[ c[0] ] = i }
contributions.each() do |contrib|
# Contributions that do not specify their opinion about categorization silently accepts the precedence
# set in the root configuration - and may thus produce an unexpected result
#
next unless ec = contrib.effective_categories
next unless categories = ec.categories
prev_prec = -1
categories.each do |c|
prec = cat_prec[c.categorization]
issues = Puppet::Pops::Binder::BinderIssues
unless prec
diagnostics.accept(issues::MISSING_CATEGORY_PRECEDENCE, c, :categorization => c.categorization)
next
end
unless prec > prev_prec
diagnostics.accept(issues::PRECEDENCE_MISMATCH_IN_CONTRIBUTION, c, :categorization => c.categorization)
end
prev_prec = prec
end
end
end
def configure_layer(layer_description, scope, diagnostics)
name = layer_description['name']
# compute effective set of uris to load (and get rid of any duplicates in the process
included_uris = array_of_uris(layer_description['include'])
excluded_uris = array_of_uris(layer_description['exclude'])
effective_uris = Set.new(expand_included_uris(included_uris)).subtract(Set.new(expand_excluded_uris(excluded_uris)))
# Each URI should result in a ContributedBindings
effective_uris.collect { |uri| scheme_handlers[uri.scheme].contributed_bindings(uri, scope, self) }
end
def array_of_uris(descriptions)
return [] unless descriptions
descriptions = [descriptions] unless descriptions.is_a?(Array)
descriptions.collect {|d| URI.parse(d) }
end
def expand_included_uris(uris)
result = []
uris.each do |uri|
unless handler = scheme_handlers[uri.scheme]
raise ArgumentError, "Unknown bindings provider scheme: '#{uri.scheme}'"
end
result.concat(handler.expand_included(uri, self))
end
result
end
def expand_excluded_uris(uris)
result = []
uris.each do |uri|
unless handler = scheme_handlers[uri.scheme]
raise ArgumentError, "Unknown bindings provider scheme: '#{uri.scheme}'"
end
result.concat(handler.expand_excluded(uri, self))
end
result
end
class SchemeHandlerHelper
T = Puppet::Pops::Types::TypeFactory
HASH_OF_HANDLER = T.hash_of(T.type_of('Puppetx::Puppet::BindingsSchemeHandler'))
def initialize(scope)
@scope = scope
@cache = nil
end
def [] (scheme)
load_schemes unless @cache
@cache[scheme]
end
def load_schemes
@cache = @scope.compiler.boot_injector.lookup(@scope, HASH_OF_HANDLER, Puppetx::BINDINGS_SCHEMES) || {}
end
end
end
puppet-3.4.3/lib/puppet/pops/binder/bindings_label_provider.rb 0000644 0052762 0001160 00000005452 12300765631 024441 0 ustar jenkins jenkins # A provider of labels for bindings model object, producing a human name for the model object.
# @api private
#
class Puppet::Pops::Binder::BindingsLabelProvider < Puppet::Pops::LabelProvider
def initialize
@@label_visitor ||= Puppet::Pops::Visitor.new(self,"label",0,0)
end
# Produces a label for the given object without article.
# @return [String] a human readable label
#
def label o
@@label_visitor.visit(o)
end
def label_PObjectType o ; "#{Puppet::Pops::Types::TypeFactory.label(o)}" end
def label_ProducerDescriptor o ; "Producer" end
def label_NonCachingProducerDescriptor o ; "Non Caching Producer" end
def label_ConstantProducerDescriptor o ; "Producer['#{o.value}']" end
def label_EvaluatingProducerDescriptor o ; "Evaluating Producer" end
def label_InstanceProducerDescriptor o ; "Producer[#{o.class_name}]" end
def label_LookupProducerDescriptor o ; "Lookup Producer[#{o.name}]" end
def label_HashLookupProducerDescriptor o ; "Hash Lookup Producer[#{o.name}][#{o.key}]" end
def label_FirstFoundProducerDescriptor o ; "First Found Producer" end
def label_ProducerProducerDescriptor o ; "Producer[Producer]" end
def label_MultibindProducerDescriptor o ; "Multibind Producer" end
def label_ArrayMultibindProducerDescriptor o ; "Array Multibind Producer" end
def label_HashMultibindProducerDescriptor o ; "Hash Multibind Producer" end
def label_Bindings o ; "Bindings" end
def label_NamedBindings o ; "Named Bindings" end
def label_Category o ; "Category '#{o.categorization}/#{o.value}'" end
def label_CategorizedBindings o ; "Categorized Bindings" end
def label_LayeredBindings o ; "Layered Bindings" end
def label_NamedLayer o ; "Layer '#{o.name}'" end
def label_EffectiveCategories o ; "Effective Categories" end
def label_ContributedBindings o ; "Contributed Bindings" end
def label_NamedArgument o ; "Named Argument" end
def label_Binding(o)
'Binding' + (o.multibind_id.nil? ? '' : ' In Multibind')
end
def label_Multibinding(o)
'Multibinding' + (o.multibind_id.nil? ? '' : ' In Multibind')
end
end
puppet-3.4.3/lib/puppet/pops/binder/bindings_model_dumper.rb 0000644 0052762 0001160 00000011255 12300765631 024122 0 ustar jenkins jenkins
# Dumps a Pops::Binder::Bindings model in reverse polish notation; i.e. LISP style
# The intention is to use this for debugging output
# TODO: BAD NAME - A DUMP is a Ruby Serialization
# NOTE: use :break, :indent, :dedent in lists to do just that
#
class Puppet::Pops::Binder::BindingsModelDumper < Puppet::Pops::Model::TreeDumper
Bindings = Puppet::Pops::Binder::Bindings
attr_reader :type_calculator
attr_reader :expression_dumper
def initialize
super
@type_calculator = Puppet::Pops::Types::TypeCalculator.new()
@expression_dumper = Puppet::Pops::Model::ModelTreeDumper.new()
end
def dump_BindingsFactory o
do_dump(o.model)
end
def dump_BindingsBuilder o
do_dump(o.model)
end
def dump_BindingsContainerBuilder o
do_dump(o.model)
end
def dump_NamedLayer o
result = ['named-layer', (o.name.nil? ? '': o.name), :indent]
if o.bindings
o.bindings.each do |b|
result << :break
result << do_dump(b)
end
end
result << :dedent
result
end
def dump_Array o
o.collect {|e| do_dump(e) }
end
def dump_ASTArray o
["[]"] + o.children.collect {|x| do_dump(x)}
end
def dump_ASTHash o
["{}"] + o.value.sort_by{|k,v| k.to_s}.collect {|x| [do_dump(x[0]), do_dump(x[1])]}
end
def dump_Integer o
o.to_s
end
# Dump a Ruby String in single quotes unless it is a number.
def dump_String o
"'#{o}'"
end
def dump_NilClass o
"()"
end
def dump_Object o
['dev-error-no-polymorph-dump-for:', o.class.to_s, o.to_s]
end
def is_nop? o
o.nil? || o.is_a?(Model::Nop) || o.is_a?(AST::Nop)
end
def dump_ProducerDescriptor o
result = [o.class.name]
result << expression_dumper.dump(o.transformer) if o.transformer
result
end
def dump_NonCachingProducerDescriptor o
dump_ProducerDescriptor(o) + do_dump(o.producer)
end
def dump_ConstantProducerDescriptor o
['constant', do_dump(o.value)]
end
def dump_EvaluatingProducerDescriptor o
result = dump_ProducerDescriptor(o)
result << expression_dumper.dump(o.expression)
end
def dump_InstanceProducerDescriptor
# TODO: o.arguments, o. transformer
['instance', o.class_name]
end
def dump_ProducerProducerDescriptor o
# skip the transformer lambda...
result = ['producer-producer', do_dump(o.producer)]
result << expression_dumper.dump(o.transformer) if o.transformer
result
end
def dump_LookupProducerDescriptor o
['lookup', do_dump(o.type), o.name]
end
def dump_PObjectType o
type_calculator.string(o)
end
def dump_HashLookupProducerDescriptor o
# TODO: transformer lambda
result = ['hash-lookup', do_dump(o.type), o.name, "[#{do_dump(o.key)}]"]
result << expression_dumper.dump(o.transformer) if o.transformer
result
end
def dump_FirstFoundProducerDescriptor o
# TODO: transformer lambda
['first-found', do_dump(o.producers)]
end
def dump_ArrayMultibindProducerDescriptor o
['multibind-array']
end
def dump_HashMultibindProducerDescriptor o
['multibind-hash']
end
def dump_NamedArgument o
"#{o.name} => #{do_dump(o.value)}"
end
def dump_Binding o
result = ['bind']
result << 'override' if o.override
result << 'abstract' if o.abstract
result.concat([do_dump(o.type), o.name])
result << "(in #{o.multibind_id})" if o.multibind_id
result << ['to', do_dump(o.producer)] + do_dump(o.producer_args)
result
end
def dump_Multibinding o
result = ['multibind', o.id]
result << 'override' if o.override
result << 'abstract' if o.abstract
result.concat([do_dump(o.type), o.name])
result << "(in #{o.multibind_id})" if o.multibind_id
result << ['to', do_dump(o.producer)] + do_dump(o.producer_args)
result
end
def dump_Bindings o
do_dump(o.bindings)
end
def dump_NamedBindings o
result = ['named-bindings', o.name, :indent]
o.bindings.each do |b|
result << :break
result << do_dump(b)
end
result << :dedent
result
end
def dump_Category o
['category', o.categorization, do_dump(o.value)]
end
def dump_CategorizedBindings o
result = ['when', do_dump(o.predicates), :indent]
o.bindings.each do |b|
result << :break
result << do_dump(b)
end
result << :dedent
result
end
def dump_LayeredBindings o
result = ['layers', :indent]
o.layers.each do |layer|
result << :break
result << do_dump(layer)
end
result << :dedent
result
end
def dump_EffectiveCategories o
['categories', do_dump(o.categories)]
end
def dump_ContributedBindings o
['contributed', o.name, do_dump(o.effective_categories), do_dump(o.bindings)]
end
end
puppet-3.4.3/lib/puppet/pops/binder/hiera2/ 0000755 0052762 0001160 00000000000 12300765640 020412 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/pops/binder/hiera2/config.rb 0000644 0052762 0001160 00000004764 12300765631 022217 0 ustar jenkins jenkins module Puppet::Pops::Binder::Hiera2
# Class holding the Hiera2 Configuration
# The configuration is obtained from the file 'hiera.yaml'
# that must reside in the root directory of the module
# @api public
#
class Puppet::Pops::Binder::Hiera2::Config
DEFAULT_HIERARCHY = [ ['osfamily', '${osfamily}', 'data/osfamily/${osfamily}'], ['common', 'true', 'data/common']]
DEFAULT_BACKENDS = ['yaml', 'json']
if defined?(::Psych::SyntaxError)
YamlLoadExceptions = [::StandardError, ::ArgumentError, ::Psych::SyntaxError]
else
YamlLoadExceptions = [::StandardError, ::ArgumentError]
end
# Returns a list of configured backends.
#
# @return [Array] backend names
attr_reader :backends
# Root directory of the module holding the configuration
#
# @return [String] An absolute path
attr_reader :module_dir
# The bindings hierarchy is an array of categorizations where the
# array for each category has exactly three elements - the categorization name,
# category value, and the path that is later used by the backend to read
# the bindings for that category
#
# @return [Array]
# @api public
attr_reader :hierarchy
# Creates a new Config. The configuration is loaded from the file 'hiera.yaml' which
# is expected to be found in the given module_dir.
#
# @param module_dir [String] The module directory
# @param diagnostics [DiagnosticProducer] collector of diagnostics
# @api public
#
def initialize(module_dir, diagnostics)
@module_dir = module_dir
config_file = File.join(module_dir, 'hiera.yaml')
validator = ConfigChecker.new(diagnostics)
begin
data = YAML.load_file(config_file)
validator.validate(data, config_file)
unless diagnostics.errors?
# if these are missing the result is nil, and they get default values later
@hierarchy = data['hierarchy']
@backends = data['backends']
end
rescue Errno::ENOENT
diagnostics.accept(Issues::CONFIG_FILE_NOT_FOUND, config_file)
rescue Errno::ENOTDIR
diagnostics.accept(Issues::CONFIG_FILE_NOT_FOUND, config_file)
rescue ::SyntaxError => e
diagnostics.accept(Issues::CONFIG_FILE_SYNTAX_ERROR, e)
rescue *YamlLoadExceptions => e
diagnostics.accept(Issues::CONFIG_FILE_SYNTAX_ERROR, e)
end
@hierarchy ||= DEFAULT_HIERARCHY
@backends ||= DEFAULT_BACKENDS
end
end
end
puppet-3.4.3/lib/puppet/pops/binder/hiera2/yaml_backend.rb 0000644 0052762 0001160 00000001473 12300765631 023355 0 ustar jenkins jenkins # A Backend implementation capable of reading YAML syntax
class Puppet::Pops::Binder::Hiera2::YamlBackend < Puppetx::Puppet::Hiera2Backend
def read_data(module_dir, source)
begin
source_file = File.join(module_dir, "#{source}.yaml")
# if file is present but empty or has only "---", YAML.load_file returns false,
# in which case fall back to returning an empty hash
YAML.load_file(source_file) || {}
rescue TypeError => e
# SafeYaml chokes when trying to load using utf-8 and the file is empty
raise e if File.size?(source_file)
{}
rescue Errno::ENOTDIR
# This is OK, the file doesn't need to be present. Return an empty hash
{}
rescue Errno::ENOENT
# This is OK, the file doesn't need to be present. Return an empty hash
{}
end
end
end
puppet-3.4.3/lib/puppet/pops/binder/hiera2/json_backend.rb 0000644 0052762 0001160 00000001042 12300765631 023354 0 ustar jenkins jenkins require 'json'
# A Backend implementation capable of reading JSON syntax
class Puppet::Pops::Binder::Hiera2::JsonBackend < Puppetx::Puppet::Hiera2Backend
def read_data(module_dir, source)
begin
source_file = File.join(module_dir, "#{source}.json")
JSON.parse(File.read(source_file))
rescue Errno::ENOTDIR
# This is OK, the file doesn't need to be present. Return an empty hash
{}
rescue Errno::ENOENT
# This is OK, the file doesn't need to be present. Return an empty hash
{}
end
end
end
puppet-3.4.3/lib/puppet/pops/binder/hiera2/diagnostic_producer.rb 0000644 0052762 0001160 00000002275 12300765631 024774 0 ustar jenkins jenkins module Puppet::Pops::Binder::Hiera2
# Generates validation diagnostics
class Puppet::Pops::Binder::Hiera2::DiagnosticProducer
attr_reader :acceptor
def initialize(an_acceptor)
raise ArgumentError, "Not an acceptor" unless an_acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
@acceptor = an_acceptor
@severity_producer = Puppet::Pops::Validation::SeverityProducer.new
end
def accept(issue, semantic, arguments={})
arguments[:semantic] ||= semantic
severity = severity_producer.severity(issue)
acceptor.accept(Puppet::Pops::Validation::Diagnostic.new(severity, issue, nil, nil, arguments))
end
def errors?()
acceptor.errors?
end
def severity_producer
p = @severity_producer
p[Issues::UNRESOLVED_STRING_VARIABLE] = :warning
# Warning since if it does not blow up on anything else, a sane subset of later version was used
p[Issues::LATER_VERSION] = :warning
# Ignore MISSING_BACKENDS because a default will be provided
p[Issues::MISSING_BACKENDS] = :ignore
# Ignore MISSING_HIERARCHY because a default will be provided
p[Issues::MISSING_HIERARCHY] = :ignore
p
end
end
end
puppet-3.4.3/lib/puppet/pops/binder/hiera2/issues.rb 0000644 0052762 0001160 00000004614 12300765631 022257 0 ustar jenkins jenkins module Puppet::Pops::Binder::Hiera2::Issues
# (see Puppet::Pops::Issues#issue)
def self.issue (issue_code, *args, &block)
Puppet::Pops::Issues.issue(issue_code, *args, &block)
end
CONFIG_IS_NOT_HASH = issue :CONFIG_IS_NOT_HASH do
"The configuration file '#{semantic}' has no hash at the top level"
end
MISSING_HIERARCHY = issue :MISSING_HIERARCHY do
"The configuration file '#{semantic}' contains no hierarchy"
end
MISSING_BACKENDS = issue :MISSING_BACKENDS do
"The configuration file '#{semantic}' contains no backends"
end
CATEGORY_MUST_BE_THREE_ELEMENT_ARRAY = issue :CATEGORY_MUST_BE_THREE_ELEMENT_ARRAY do
"The configuration file '#{semantic}' has a malformed hierarchy (should consist of arrays with three string entries)"
end
CONFIG_FILE_NOT_FOUND = issue :CONFIG_FILE_NOT_FOUND do
"The configuration file '#{semantic}' does not exist"
end
CONFIG_FILE_SYNTAX_ERROR = issue :CONFIG_FILE_SYNTAX_ERROR do
"Unable to parse: #{semantic}"
end
CANNOT_LOAD_BACKEND = issue :CANNOT_LOAD_BACKEND, :key, :error do
"Backend '#{key}' in configuration file '#{semantic}' cannot be loaded: #{error}"
end
BACKEND_FILE_DOES_NOT_DEFINE_CLASS = issue :BACKEND_FILE_DOES_NOT_DEFINE_CLASS, :class_name do
"The file '#{semantic}' does not define class #{class_name}"
end
NOT_A_BACKEND_CLASS = issue :NOT_A_BACKEND_CLASS, :key, :class_name do
"Class #{class_name}, loaded using key #{key} in file '#{semantic}' is not a subclass of Backend"
end
METADATA_JSON_NOT_FOUND = issue :METADATA_JSON_NOT_FOUND do
"The metadata file '#{semantic}' does not exist"
end
UNSUPPORTED_STRING_EXPRESSION = issue :UNSUPPORTED_STRING_EXPRESSION, :expr do
"String '#{semantic}' contains an unsupported expression (type was #{expr.class.name})"
end
UNRESOLVED_STRING_VARIABLE = issue :UNRESOLVED_STRING_VARIABLE, :key do
"Variable '#{key}' found in string '#{semantic}' cannot be resolved"
end
MISSING_VERSION = issue :MISSING_VERSION do
"The configuration file '#{semantic}' does not have a version."
end
WRONG_VERSION = issue :WRONG_VERSION do
"The configuration file '#{semantic}' has the wrong version, expected: #{expected}, actual: #{actual}"
end
LATER_VERSION = issue :LATER_VERSION do
"The configuration file '#{semantic}' has a version that is newer (features may not work), expected: #{expected}, actual: #{actual}"
end
end
puppet-3.4.3/lib/puppet/pops/binder/hiera2/bindings_provider.rb 0000644 0052762 0001160 00000012256 12300765631 024454 0 ustar jenkins jenkins module Puppet::Pops::Binder::Hiera2
Model = Puppet::Pops::Model
# A BindingsProvider instance is used for creating a bindings model from a module directory
# @api public
#
class BindingsProvider
# The resulting name of loaded bindings (given when initializing)
attr_reader :name
# Creates a new BindingsProvider by reading the hiera_conf.yaml configuration file. Problems
# with the configuration are reported propagated to the acceptor
#
# @param name [String] the name to assign to the result (and in error messages if there is no result)
# @param hiera_config_dir [String] Path to the directory containing a hiera_config
# @param acceptor [Puppet::Pops::Validation::Acceptor] Acceptor that will receive diagnostics
def initialize(name, hiera_config_dir, acceptor)
@name = name
@parser = Puppet::Pops::Parser::EvaluatingParser.new()
@diagnostics = DiagnosticProducer.new(acceptor)
@type_calculator = Puppet::Pops::Types::TypeCalculator.new()
@config = Config.new(hiera_config_dir, @diagnostics)
end
# Loads a bindings model using the hierarchy and backends configured for this instance.
#
# @param scope [Puppet::Parser::Scope] The hash used when expanding
# @return [Puppet::Pops::Binder::Bindings::ContributedBindings] A bindings model with effective categories
def load_bindings(scope)
backends = BackendHelper.new(scope)
factory = Puppet::Pops::Binder::BindingsFactory
result = factory.named_bindings(name)
hierarchy = {}
precedence = []
@config.hierarchy.each do |key, value, path|
source_file = File.join(@config.module_dir, 'hiera.yaml')
category_value = @parser.evaluate_string(scope, @parser.quote(value), source_file)
hierarchy[key] = {
:bindings => result.when_in_category(key, category_value),
:path => @parser.evaluate_string(scope, @parser.quote(path)),
:unique_keys =>Set.new()}
precedence << [key, category_value]
end
@config.backends.each do |backend_key|
backend = backends[backend_key]
hierarchy.each_pair do |hier_key, hier_val|
bindings = hier_val[:bindings]
unique_keys = hier_val[:unique_keys]
hiera_data_file_path = hier_val[:path]
backend.read_data(@config.module_dir, hiera_data_file_path).each_pair do |key, value|
if unique_keys.add?(key)
b = bindings.bind().name(key)
# Transform value into a Model::Expression
expr = build_expr(value, hiera_data_file_path)
if is_constant?(expr)
# The value is constant so toss the expression
b.type(@type_calculator.infer(value)).to(value)
else
# Use an evaluating producer for the binding
b.to(expr)
end
end
end
end
end
factory.contributed_bindings(name, result.model, factory.categories(precedence))
end
private
# @return true unless the expression is a Model::ConcatenatedString or
# somehow contains one
def is_constant?(expr)
if expr.is_a?(Model::ConcatenatedString)
false
else
!expr.eAllContents.any? { |v| v.is_a?(Model::ConcatenatedString) }
end
end
# Transform the value into a Model::Expression. Strings are parsed using
# the Pops::Parser::Parser to produce either Model::LiteralString or Model::ConcatenatedString
#
# @param value [Object] May be an String, Number, TrueClass, FalseClass, or NilClass nested to any depth using Hash or Array.
# @param hiera_data_file_path [String] The source_file used when reporting errors
# @return [Model::Expression] The expression that corresponds to the value
def build_expr(value, hiera_data_file_path)
case value
when Symbol
value.to_s
when String
@parser.parse_string(@parser.quote(value)).current
when Hash
value.inject(Model::LiteralHash.new) do |h,(k,v)|
e = Model::KeyedEntry.new
e.key = build_expr(k, hiera_data_file_path)
e.value = build_expr(v, hiera_data_file_path)
h.addEntries(e)
h
end
when Enumerable
value.inject(Model::LiteralList.new) {|a,v| a.addValues(build_expr(v, hiera_data_file_path)); a }
when Numeric
expr = Model::LiteralNumber.new
expr.value = value;
expr
when TrueClass, FalseClass
expr = Model::LiteralBoolean.new
expr.value = value;
expr
when NilClass
Model::Nop.new
else
@diagnostics.accept(Issues::UNABLE_TO_PARSE_INSTANCE, value.class.name)
nil
end
end
end
# @api private
class BackendHelper
T = Puppet::Pops::Types::TypeFactory
HASH_OF_BACKENDS = T.hash_of(T.type_of('Puppetx::Puppet::Hiera2Backend'))
def initialize(scope)
@scope = scope
@cache = nil
end
def [] (backend_key)
load_backends unless @cache
@cache[backend_key]
end
def load_backends
@cache = @scope.compiler.boot_injector.lookup(@scope, HASH_OF_BACKENDS, Puppetx::HIERA2_BACKENDS) || {}
end
end
end
puppet-3.4.3/lib/puppet/pops/binder/hiera2/config_checker.rb 0000644 0052762 0001160 00000004711 12300765631 023673 0 ustar jenkins jenkins module Puppet::Pops::Binder::Hiera2
# Validates the consistency of a Hiera2::Config
class ConfigChecker
# Create an instance with a diagnostic producer that will receive the result during validation
# @param diangostics [DiagnosticProducer] The producer that will receive the diagnostic
def initialize(diagnostics)
@diagnostics = diagnostics
end
# Validate the consistency of the given data. Diagnostics will be emitted to the DiagnosticProducer
# that was set when this checker was created
#
# @param data [Object] The data read from the config file
# @param config_file [String] The full path of the file. Used in error messages
def validate(data, config_file)
if data.is_a?(Hash)
# If the version is missing, it is not meaningful to continue
return unless check_version(data['version'], config_file)
check_hierarchy(data['hierarchy'], config_file)
check_backends(data['backends'], config_file)
else
@diagnostics.accept(Issues::CONFIG_IS_NOT_HASH, config_file)
end
end
private
# Version is required and must be >= 2. A warning is issued if version > 2 as this checker is
# for version 2 only.
# @return [Boolean] false if it is meaningless to continue checking
def check_version(version, config_file)
if version.nil?
# This is not hiera2 compatible
@diagnostics.accept(Issues::MISSING_VERSION, config_file)
return false
end
unless version >= 2
@diagnostics.accept(Issues::WRONG_VERSION, config_file, :expected => 2, :actual => version)
return false
end
unless version == 2
# it may have a sane subset, hence a different error (configured as warning)
@diagnostics.accept(Issues::LATER_VERSION, config_file, :expected => 2, :actual => version)
end
return true
end
def check_hierarchy(hierarchy, config_file)
if !hierarchy.is_a?(Array) || hierarchy.empty?
@diagnostics.accept(Issues::MISSING_HIERARCHY, config_file)
else
hierarchy.each do |value|
unless value.is_a?(Array) && value.length() == 3
@diagnostics.accept(Issues::CATEGORY_MUST_BE_THREE_ELEMENT_ARRAY, config_file)
end
end
end
end
def check_backends(backends, config_file)
if !backends.is_a?(Array) || backends.empty?
@diagnostics.accept(Issues::MISSING_BACKENDS, config_file)
end
end
end
end
puppet-3.4.3/lib/puppet/pops/containment.rb 0000644 0052762 0001160 00000001776 12300765631 020654 0 ustar jenkins jenkins # FIXME: This module should be updated when a newer version of RGen (>0.6.2) adds required meta model "e-method" supports.
#
module Puppet::Pops::Containment
# Returns Enumerable, thus allowing
# some_element.eAllContents each {|contained| }
# This is a depth first enumeration where parent appears before children.
# @note the top-most object itself is not included in the enumeration, only what it contains.
def eAllContents
EAllContentsEnumerator.new(self)
end
class EAllContentsEnumerator
include Enumerable
def initialize o
@element = o
end
def each &block
if block_given?
eAllContents(@element, &block)
@element
else
self
end
end
def eAllContents(element, &block)
element.class.ecore.eAllReferences.select{|r| r.containment}.each do |r|
children = element.getGenericAsArray(r.name)
children.each do |c|
block.call(c)
eAllContents(c, &block)
end
end
end
end
end
puppet-3.4.3/lib/puppet/pops/visitor.rb 0000644 0052762 0001160 00000004132 12300765631 020021 0 ustar jenkins jenkins # A Visitor performs delegation to a given receiver based on the configuration of the Visitor.
# A new visitor is created with a given receiver, a method prefix, min, and max argument counts.
# e.g.
# vistor = Visitor.new(self, "visit_from", 1, 1)
# will make the visitor call "self.visit_from_CLASS(x)" where CLASS is resolved to the given
# objects class, or one of is ancestors, the first class for which there is an implementation of
# a method will be selected.
#
# Raises RuntimeError if there are too few or too many arguments, or if the receiver is not
# configured to handle a given visiting object.
#
class Puppet::Pops::Visitor
attr_reader :receiver, :message, :min_args, :max_args, :cache
def initialize(receiver, message, min_args=0, max_args=nil)
raise ArgumentError.new("min_args must be >= 0") if min_args < 0
raise ArgumentError.new("max_args must be >= min_args or nil") if max_args && max_args < min_args
@receiver = receiver
@message = message
@min_args = min_args
@max_args = max_args
@cache = Hash.new
end
# Visit the configured receiver
def visit(thing, *args)
visit_this(@receiver, thing, *args)
end
# Visit an explicit receiver
def visit_this(receiver, thing, *args)
raise "Visitor Error: Too few arguments passed. min = #{@min_args}" unless args.length >= @min_args
if @max_args
raise "Visitor Error: Too many arguments passed. max = #{@max_args}" unless args.length <= @max_args
end
if method_name = @cache[thing.class]
return receiver.send(method_name, thing, *args)
else
thing.class.ancestors().each do |ancestor|
method_name = :"#{@message}_#{ancestor.name.split("::").last}"
# DEBUG OUTPUT
# puts "Visitor checking: #{receiver.class}.#{method_name}, responds to: #{@receiver.respond_to? method_name}"
next unless receiver.respond_to? method_name
@cache[thing.class] = method_name
return receiver.send(method_name, thing, *args)
end
end
raise "Visitor Error: the configured receiver (#{receiver.class}) can't handle instance of: #{thing.class}"
end
end
puppet-3.4.3/lib/puppet/pops/validation.rb 0000644 0052762 0001160 00000034044 12300765631 020461 0 ustar jenkins jenkins # A module with base functionality for validation of a model.
#
# * **Factory** - an abstract factory implementation that makes it easier to create a new validation factory.
# * **SeverityProducer** - produces a severity (:error, :warning, :ignore) for a given Issue
# * **DiagnosticProducer** - produces a Diagnostic which binds an Issue to an occurrence of that issue
# * **Acceptor** - the receiver/sink/collector of computed diagnostics
# * **DiagnosticFormatter** - produces human readable output for a Diagnostic
#
module Puppet::Pops::Validation
# This class is an abstract base implementation of a _model validation factory_ that creates a validator instance
# and associates it with a fully configured DiagnosticProducer.
#
# A _validator_ is responsible for validating a model. There may be different versions of validation available
# for one and the same model; e.g. different semantics for different puppet versions, or different types of
# validation configuration depending on the context/type of validation that should be performed (static, vs. runtime, etc.).
#
# This class is abstract and must be subclassed. The subclass must implement the methods
# {#label_provider} and {#checker}. It is also expected that the sublcass will override
# the severity_producer and configure the issues that should be reported as errors (i.e. if they should be ignored, produce
# a warning, or a deprecation warning).
#
# @abstract Subclass must implement {#checker}, and {#label_provider}
# @api public
#
class Factory
# Produces a validator with the given acceptor as the recipient of produced diagnostics.
# The acceptor is where detected issues are received (and typically collected).
#
# @param acceptor [Acceptor] the acceptor is the receiver of all detected issues
# @return [#validate] a validator responding to `validate(model)`
#
# @api public
#
def validator(acceptor)
checker(diagnostic_producer(acceptor))
end
# Produces the diagnostics producer to use given an acceptor of issues.
#
# @param acceptor [Acceptor] the acceptor is the receiver of all detected issues
# @return [DiagnosticProducer] a detector of issues
#
# @api public
#
def diagnostic_producer(acceptor)
Puppet::Pops::Validation::DiagnosticProducer.new(acceptor, severity_producer(), label_provider())
end
# Produces the SeverityProducer to use
# Subclasses should implement and add specific overrides
#
# @return [SeverityProducer] a severity producer producing error, warning or ignore per issue
#
# @api public
#
def severity_producer
Puppet::Pops::Validation::SeverityProducer.new
end
# Produces the checker to use.
#
# @abstract
#
# @api public
#
def checker(diagnostic_producer)
raise NoMethodError, "checker"
end
# Produces the label provider to use.
#
# @abstract
#
# @api public
#
def label_provider
raise NoMethodError, "label_provider"
end
end
# Decides on the severity of a given issue.
# The produced severity is one of `:error`, `:warning`, or `:ignore`.
# By default, a severity of `:error` is produced for all issues. To configure the severity
# of an issue call `#severity=(issue, level)`.
#
# @return [Symbol] a symbol representing the severity `:error`, `:warning`, or `:ignore`
#
# @api public
#
class SeverityProducer
# Creates a new instance where all issues are diagnosed as :error unless overridden.
# @api public
#
def initialize
# If diagnose is not set, the default is returned by the block
@severities = Hash.new :error
end
# Returns the severity of the given issue.
# @return [Symbol] severity level :error, :warning, or :ignore
# @api public
#
def severity(issue)
assert_issue(issue)
@severities[issue]
end
# @see {#severity}
# @api public
#
def [] issue
severity issue
end
# Override a default severity with the given severity level.
#
# @param issue [Puppet::Pops::Issues::Issue] the issue for which to set severity
# @param level [Symbol] the severity level (:error, :warning, or :ignore).
# @api public
#
def []=(issue, level)
assert_issue(issue)
assert_severity(level)
raise Puppet::DevError.new("Attempt to demote the hard issue '#{issue.issue_code}' to #{level}") unless issue.demotable? || level == :error
@severities[issue] = level
end
# Returns `true` if the issue should be reported or not.
# @return [Boolean] this implementation returns true for errors and warnings
#
# @api public
#
def should_report? issue
diagnose = self[issue]
diagnose == :error || diagnose == :warning || diagnose == :deprecation
end
# Checks if the given issue is valid.
# @api private
#
def assert_issue issue
raise Puppet::DevError.new("Attempt to get validation severity for something that is not an Issue. (Got #{issue.class})") unless issue.is_a? Puppet::Pops::Issues::Issue
end
# Checks if the given severity level is valid.
# @api private
#
def assert_severity level
raise Puppet::DevError.new("Illegal severity level: #{option}") unless [:ignore, :warning, :error, :deprecation].include? level
end
end
# A producer of diagnostics.
# An producer of diagnostics is given each issue occurrence as they are found by a diagnostician/validator. It then produces
# a Diagnostic, which it passes on to a configured Acceptor.
#
# This class exists to aid a diagnostician/validator which will typically first check if a particular issue
# will be accepted at all (before checking for an occurrence of the issue; i.e. to perform check avoidance for expensive checks).
# A validator passes an instance of Issue, the semantic object (the "culprit"), a hash with arguments, and an optional
# exception. The semantic object is used to determine the location of the occurrence of the issue (file/line), and it
# sets keys in the given argument hash that may be used in the formatting of the issue message.
#
class DiagnosticProducer
# A producer of severity for a given issue
# @return [SeverityProducer]
#
attr_reader :severity_producer
# A producer of labels for objects involved in the issue
# @return [LabelProvider]
#
attr_reader :label_provider
# Initializes this producer.
#
# @param acceptor [Acceptor] a sink/collector of diagnostic results
# @param severity_producer [SeverityProducer] the severity producer to use to determine severity of a given issue
# @param label_provider [LabelProvider] a provider of model element type to human readable label
#
def initialize(acceptor, severity_producer, label_provider)
@acceptor = acceptor
@severity_producer = severity_producer
@label_provider = label_provider
end
def accept(issue, semantic, arguments={}, except=nil)
return unless will_accept? issue
# Set label provider unless caller provided a special label provider
arguments[:label] ||= @label_provider
arguments[:semantic] ||= semantic
# A detail message is always provided, but is blank by default.
arguments[:detail] ||= ''
origin_adapter = Puppet::Pops::Utils.find_adapter(semantic, Puppet::Pops::Adapters::OriginAdapter)
file = origin_adapter ? origin_adapter.origin : nil
source_pos = Puppet::Pops::Utils.find_adapter(semantic, Puppet::Pops::Adapters::SourcePosAdapter)
severity = @severity_producer.severity(issue)
@acceptor.accept(Diagnostic.new(severity, issue, file, source_pos, arguments))
end
def will_accept? issue
@severity_producer.should_report? issue
end
end
class Diagnostic
attr_reader :severity
attr_reader :issue
attr_reader :arguments
attr_reader :exception
attr_reader :file
attr_reader :source_pos
def initialize severity, issue, file, source_pos, arguments={}, exception=nil
@severity = severity
@issue = issue
@file = file
@source_pos = source_pos
@arguments = arguments
@exception = exception
end
end
# Formats a diagnostic for output.
# Produces a diagnostic output typical for a compiler (suitable for interpretation by tools)
# The format is:
# `file:line:pos: Message`, where pos, line and file are included if available.
#
class DiagnosticFormatter
def format diagnostic
"#{loc(diagnostic)} #{format_severity(diagnostic)}#{format_message(diagnostic)}"
end
def format_message diagnostic
diagnostic.issue.format(diagnostic.arguments)
end
# This produces "Deprecation notice: " prefix if the diagnostic has :deprecation severity, otherwise "".
# The idea is that all other diagnostics are emitted with the methods Puppet.err (or an exception), and
# Puppet.warning.
# @note Note that it is not a good idea to use Puppet.deprecation_warning as it is for internal deprecation.
#
def format_severity diagnostic
diagnostic.severity == :deprecation ? "Deprecation notice: " : ""
end
def format_location diagnostic
file = diagnostic.file
line = pos = nil
if diagnostic.source_pos
line = diagnostic.source_pos.line
pos = diagnostic.source_pos.pos
end
if file && line && pos
"#{file}:#{line}:#{pos}:"
elsif file && line
"#{file}:#{line}:"
elsif file
"#{file}:"
else
""
end
end
end
# Produces a diagnostic output in the "puppet style", where the location is appended with an "at ..." if the
# location is known.
#
class DiagnosticFormatterPuppetStyle < DiagnosticFormatter
def format diagnostic
if (location = format_location diagnostic) != ""
"#{format_severity(diagnostic)}#{format_message(diagnostic)}#{location}"
else
format_message(diagnostic)
end
end
# The somewhat (machine) unusable format in current use by puppet.
# have to be used here for backwards compatibility.
def format_location diagnostic
file = diagnostic.file
line = pos = nil
if diagnostic.source_pos
line = diagnostic.source_pos.line
pos = diagnostic.source_pos.pos
end
if file && line && pos
" at #{file}:#{line}:#{pos}"
elsif file and line
" at #{file}:#{line}"
elsif line && pos
" at line #{line}:#{pos}"
elsif line
" at line #{line}"
elsif file
" in #{file}"
else
""
end
end
end
# An acceptor of diagnostics.
# An acceptor of diagnostics is given each issue as they are found by a diagnostician/validator. An
# acceptor can collect all found issues, or decide to collect a few and then report, or give up as the first issue
# if found.
# This default implementation collects all diagnostics in the order they are produced, and can then
# answer questions about what was diagnosed.
#
class Acceptor
# All diagnostic in the order they were issued
attr_reader :diagnostics
# The number of :warning severity issues + number of :deprecation severity issues
attr_reader :warning_count
# The number of :error severity issues
attr_reader :error_count
# Initializes this diagnostics acceptor.
# By default, the acceptor is configured with a default severity producer.
# @param severity_producer [SeverityProducer] the severity producer to use to determine severity of an issue
#
# TODO add semantic_label_provider
#
def initialize()
@diagnostics = []
@error_count = 0
@warning_count = 0
end
# Returns true when errors have been diagnosed.
def errors?
@error_count > 0
end
# Returns true when warnings have been diagnosed.
def warnings?
@warning_count > 0
end
# Returns true when errors and/or warnings have been diagnosed.
def errors_or_warnings?
errors? || warnings?
end
# Returns the diagnosed errors in the order thwy were reported.
def errors
@diagnostics.select {|d| d.severity == :error }
end
# Returns the diagnosed warnings in the order thwy were reported.
# (This includes :warning and :deprecation severity)
def warnings
@diagnostics.select {|d| d.severity == :warning || d.severity == :deprecation }
end
def errors_and_warnings
@diagnostics.select {|d| d.severity != :ignore }
end
# Returns the ignored diagnostics in the order thwy were reported (if reported at all)
def ignored
@diagnostics.select {|d| d.severity == :ignore }
end
# Add a diagnostic, or all diagnostics from another acceptor to the set of diagnostics
# @param diagnostic [Puppet::Pops::Validation::Diagnostic, Puppet::Pops::Validation::Acceptor] diagnostic(s) that should be accepted
def accept(diagnostic)
if diagnostic.is_a?(Acceptor)
diagnostic.diagnostics.each {|d| self.send(d.severity, d)}
else
self.send(diagnostic.severity, diagnostic)
end
end
# Prunes the contain diagnostics by removing those for which the given block returns true.
# The internal statistics is updated as a consequence of removing.
# @return [Array false)
# Returns a Class given a fully qualified class name.
# Lookup of class is never relative to the calling namespace.
# @param name [String, Array, Array, Puppet::Pops::Types::PObjectType] A fully qualified
# class name String (e.g. '::Foo::Bar', 'Foo::Bar'), a PObjectType, or a fully qualified name in Array form where each part
# is either a String or a Symbol, e.g. `%w{Puppetx Puppetlabs SomeExtension}`.
# @return [Class, nil] the looked up class or nil if no such class is loaded
# @raise ArgumentError If the given argument has the wrong type
# @api public
#
def self.provide(name)
case name
when String
provide_from_string(name)
when Array
provide_from_name_path(name.join('::'), name)
when Puppet::Pops::Types::PObjectType, Puppet::Pops::Types::PType
provide_from_type(name)
else
raise ArgumentError, "Cannot provide a class from a '#{name.class.name}'"
end
end
private
def self.provide_from_type(type)
case type
when Puppet::Pops::Types::PRubyType
provide_from_string(type.ruby_class)
when Puppet::Pops::Types::PBooleanType
# There is no other thing to load except this Enum meta type
RGen::MetamodelBuilder::MMBase::Boolean
when Puppet::Pops::Types::PType
# TODO: PType should have a type argument (a PObjectType)
Class
# Although not expected to be the first choice for getting a concrete class for these
# types, these are of value if the calling logic just has a reference to type.
#
when Puppet::Pops::Types::PArrayType ; Array
when Puppet::Pops::Types::PHashType ; Hash
when Puppet::Pops::Types::PPatternType ; Regexp
when Puppet::Pops::Types::PIntegerType ; Integer
when Puppet::Pops::Types::PStringType ; String
when Puppet::Pops::Types::PFloatType ; Float
when Puppet::Pops::Types::PNilType ; NilClass
else
nil
end
end
def self.provide_from_string(name)
name_path = name.split('::')
# always from the root, so remove an empty first segment
if name_path[0].empty?
name_path = name_path[1..-1]
end
provide_from_name_path(name, name_path)
end
def self.provide_from_name_path(name, name_path)
# If class is already loaded, try this first
result = find_class(name_path)
unless result.is_a?(Class)
# Attempt to load it using the auto loader
loaded_path = nil
if paths_for_name(name).find {|path| loaded_path = path; @autoloader.load(path) }
result = find_class(name_path)
unless result.is_a?(Class)
raise RuntimeError, "Loading of #{name} using relative path: '#{loaded_path}' did not create expected class"
end
end
end
return nil unless result.is_a?(Class)
result
end
def self.find_class(name_path)
name_path.reduce(Object) do |ns, name|
begin
ns.const_get(name)
rescue NameError
return nil
end
end
end
def self.paths_for_name(fq_name)
[de_camel(fq_name), downcased_path(fq_name)]
end
def self.downcased_path(fq_name)
fq_name.to_s.gsub(/::/, '/').downcase
end
def self.de_camel(fq_name)
fq_name.to_s.gsub(/::/, '/').
gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
gsub(/([a-z\d])([A-Z])/,'\1_\2').
tr("-", "_").
downcase
end
end puppet-3.4.3/lib/puppet/pops/types/type_parser.rb 0000644 0052762 0001160 00000006302 12300765631 022024 0 ustar jenkins jenkins # This class provides parsing of Type Specification from a string into the Type
# Model that is produced by the Puppet::Pops::Types::TypeFactory.
#
# The Type Specifications that are parsed are the same as the stringified forms
# of types produced by the {Puppet::Pops::Types::TypeCalculator TypeCalculator}.
#
# @api public
class Puppet::Pops::Types::TypeParser
# @api private
TYPES = Puppet::Pops::Types::TypeFactory
# @api public
def initialize
@parser = Puppet::Pops::Parser::Parser.new()
@type_transformer = Puppet::Pops::Visitor.new(nil, "interpret", 0, 0)
end
# Produces a *puppet type* based on the given string.
#
# @example
# parser.parse('Integer')
# parser.parse('Array[String]')
# parser.parse('Hash[Integer, Array[String]]')
#
# @param string [String] a string with the type expressed in stringified form as produced by the
# {Puppet::Pops::Types::TypeCalculator#string TypeCalculator#string} method.
# @return [Puppet::Pops::Types::PObjectType] a specialization of the PObjectType representing the type.
#
# @api public
#
def parse(string)
@string = string
model = @parser.parse_string(@string)
if model
interpret(model.current)
else
raise_invalid_type_specification_error
end
end
# @api private
def interpret(ast)
@type_transformer.visit_this(self, ast)
end
# @api private
def interpret_Object(anything)
raise_invalid_type_specification_error
end
# @api private
def interpret_QualifiedReference(name_ast)
case name_ast.value
when "integer"
TYPES.integer
when "float"
TYPES.float
when "string"
TYPES.string
when "boolean"
TYPES.boolean
when "pattern"
TYPES.pattern
when "data"
TYPES.data
when "array"
TYPES.array_of_data
when "hash"
TYPES.hash_of_data
else
raise_unknown_type_error(name_ast)
end
end
# @api private
def interpret_AccessExpression(parameterized_ast)
parameters = parameterized_ast.keys.collect { |param| interpret(param) }
case parameterized_ast.left_expr.value
when "array"
if parameters.size != 1
raise_invalid_parameters_error("Array", 1, parameters.size)
end
TYPES.array_of(parameters[0])
when "hash"
if parameters.size == 1
TYPES.hash_of(parameters[0])
elsif parameters.size != 2
raise_invalid_parameters_error("Hash", "1 or 2", parameters.size)
else
TYPES.hash_of(parameters[1], parameters[0])
end
else
raise_unknown_type_error(parameterized_ast.left_expr)
end
end
private
def raise_invalid_type_specification_error
raise Puppet::ParseError,
"The expression <#{@string}> is not a valid type specification."
end
def raise_invalid_parameters_error(type, required, given)
raise Puppet::ParseError,
"Invalid number of type parameters specified: #{type} requires #{required}, #{given} provided"
end
def raise_unknown_type_error(ast)
raise Puppet::ParseError, "Unknown type <#{original_text_of(ast)}>"
end
def original_text_of(ast)
position = Puppet::Pops::Adapters::SourcePosAdapter.adapt(ast)
position.extract_text_from_string(@string)
end
end
puppet-3.4.3/lib/puppet/pops/types/types.rb 0000644 0052762 0001160 00000005543 12300765631 020641 0 ustar jenkins jenkins require 'rgen/metamodel_builder'
# The Types model is a model of Puppet Language types.
#
# The exact relationship between types is not visible in this model wrt. the PDataType which is an abstraction
# of Literal, Array[Data], and Hash[Literal, Data] nested to any depth. This means it is not possible to
# infer the type by simply looking at the inheritance hierarchy. The {Puppet::Pops::Types::TypeCalculator} should
# be used to answer questions about types. The {Puppet::Pops::Types::TypeFactory} should be used to create an instance
# of a type whenever one is needed.
#
# @api public
#
module Puppet::Pops::Types
# The type of types.
# @api public
class PType < Puppet::Pops::Model::PopsObject
end
# Base type for all types except {Puppet::Pops::Types::PType PType}, the type of types.
# @api public
class PObjectType < Puppet::Pops::Model::PopsObject
module ClassModule
def hash
self.class.hash
end
def ==(o)
self.class == o.class
end
alias eql? ==
end
end
# @api public
class PNilType < PObjectType
end
# A flexible data type, being assignable to its subtypes as well as PArrayType and PHashType with element type assignable to PDataType.
#
# @api public
class PDataType < PObjectType
end
# Type that is PDataType compatible, but is not a PCollectionType.
# @api public
class PLiteralType < PDataType
end
# @api public
class PStringType < PLiteralType
end
# @api public
class PNumericType < PLiteralType
end
# @api public
class PIntegerType < PNumericType
end
# @api public
class PFloatType < PNumericType
end
# @api public
class PPatternType < PLiteralType
end
# @api public
class PBooleanType < PLiteralType
end
# @api public
class PCollectionType < PObjectType
contains_one_uni 'element_type', PObjectType
module ClassModule
def hash
[self.class, element_type].hash
end
def ==(o)
self.class == o.class && element_type == o.element_type
end
end
end
# @api public
class PArrayType < PCollectionType
module ClassModule
def hash
[self.class, element_type].hash
end
def ==(o)
self.class == o.class && element_type == o.element_type
end
end
end
# @api public
class PHashType < PCollectionType
contains_one_uni 'key_type', PObjectType
module ClassModule
def hash
[self.class, key_type, element_type].hash
end
def ==(o)
self.class == o.class && key_type == o.key_type && element_type == o.element_type
end
end
end
# @api public
class PRubyType < PObjectType
has_attr 'ruby_class', String
module ClassModule
def hash
[self.class, ruby_class].hash
end
def ==(o)
self.class == o.class && ruby_class == o.ruby_class
end
end
end
end
puppet-3.4.3/lib/puppet/pops/types/type_factory.rb 0000644 0052762 0001160 00000006146 12300765631 022205 0 ustar jenkins jenkins # Helper module that makes creation of type objects simpler.
# @api public
#
module Puppet::Pops::Types::TypeFactory
@type_calculator = Puppet::Pops::Types::TypeCalculator.new()
Types = Puppet::Pops::Types
# Produces the Integer type
# @api public
#
def self.integer()
Types::PIntegerType.new()
end
# Produces the Float type
# @api public
#
def self.float()
Types::PFloatType.new()
end
# Produces a string representation of the type
# @api public
#
def self.label(t)
@type_calculator.string(t)
end
# Produces the String type
# @api public
#
def self.string()
Types::PStringType.new()
end
# Produces the Boolean type
# @api public
#
def self.boolean()
Types::PBooleanType.new()
end
# Produces the Pattern type
# @api public
#
def self.pattern()
Types::PPatternType.new()
end
# Produces the Literal type
# @api public
#
def self.literal()
Types::PLiteralType.new()
end
# Produces the abstract type Collection
# @api public
#
def self.collection()
Types::PCollectionType.new()
end
# Produces the Data type
# @api public
#
def self.data()
Types::PDataType.new()
end
# Produces a type for Array[o] where o is either a type, or an instance for which a type is inferred.
# @api public
#
def self.array_of(o)
type = Types::PArrayType.new()
type.element_type = type_of(o)
type
end
# Produces a type for Hash[Literal, o] where o is either a type, or an instance for which a type is inferred.
# @api public
#
def self.hash_of(value, key = literal())
type = Types::PHashType.new()
type.key_type = type_of(key)
type.element_type = type_of(value)
type
end
# Produces a type for Array[Data]
# @api public
#
def self.array_of_data()
type = Types::PArrayType.new()
type.element_type = data()
type
end
# Produces a type for Hash[Literal, Data]
# @api public
#
def self.hash_of_data()
type = Types::PHashType.new()
type.key_type = literal()
type.element_type = data()
type
end
# Produce a type corresponding to the class of given unless given is a String, Class or a PObjectType.
# When a String is given this is taken as a classname.
#
def self.type_of(o)
if o.is_a?(Class)
@type_calculator.type(o)
elsif o.is_a?(Types::PObjectType)
o
elsif o.is_a?(String)
type = Types::PRubyType.new()
type.ruby_class = o
type
else
@type_calculator.infer(o)
end
end
# Produces a type for a class or infers a type for something that is not a class
# @note
# To get the type for the class' class use `TypeCalculator.infer(c)`
#
# @overload ruby(o)
# @param o [Class] produces the type corresponding to the class (e.g. Integer becomes PIntegerType)
# @overload ruby(o)
# @param o [Object] produces the type corresponding to the instance class (e.g. 3 becomes PIntegerType)
#
# @api public
#
def self.ruby(o)
if o.is_a?(Class)
@type_calculator.type(o)
else
type = Types::PRubyType.new()
type.ruby_class = o.class.name
type
end
end
end
puppet-3.4.3/lib/puppet/pops/validation/ 0000755 0052762 0001160 00000000000 12300765640 020127 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/pops/validation/validator_factory_3_1.rb 0000644 0052762 0001160 00000001665 12300765631 024642 0 ustar jenkins jenkins # Configures validation suitable for 3.1 + iteration
#
class Puppet::Pops::Validation::ValidatorFactory_3_1 < Puppet::Pops::Validation::Factory
Issues = Puppet::Pops::Issues
# Produces the checker to use
def checker diagnostic_producer
Puppet::Pops::Validation::Checker3_1.new(diagnostic_producer)
end
# Produces the label provider to use
def label_provider
Puppet::Pops::Model::ModelLabelProvider.new()
end
# Produces the severity producer to use
def severity_producer
p = super
# Configure each issue that should **not** be an error
#
# Validate as per the current runtime configuration
p[Issues::RT_NO_STORECONFIGS_EXPORT] = Puppet[:storeconfigs] ? :ignore : :warning
p[Issues::RT_NO_STORECONFIGS] = Puppet[:storeconfigs] ? :ignore : :warning
p[Issues::NAME_WITH_HYPHEN] = :deprecation
p[Issues::DEPRECATED_NAME_AS_TYPE] = :deprecation
p
end
end
puppet-3.4.3/lib/puppet/pops/validation/checker3_1.rb 0000644 0052762 0001160 00000045355 12300765631 022377 0 ustar jenkins jenkins # A Validator validates a model.
#
# Validation is performed on each model element in isolation. Each method should validate the model element's state
# but not validate its referenced/contained elements except to check their validity in their respective role.
# The intent is to drive the validation with a tree iterator that visits all elements in a model.
#
#
# TODO: Add validation of multiplicities - this is a general validation that can be checked for all
# Model objects via their metamodel. (I.e an extra call to multiplicity check in polymorph check).
# This is however mostly valuable when validating model to model transformations, and is therefore T.B.D
#
class Puppet::Pops::Validation::Checker3_1
Issues = Puppet::Pops::Issues
Model = Puppet::Pops::Model
attr_reader :acceptor
# Initializes the validator with a diagnostics producer. This object must respond to
# `:will_accept?` and `:accept`.
#
def initialize(diagnostics_producer)
@@check_visitor ||= Puppet::Pops::Visitor.new(nil, "check", 0, 0)
@@rvalue_visitor ||= Puppet::Pops::Visitor.new(nil, "rvalue", 0, 0)
@@hostname_visitor ||= Puppet::Pops::Visitor.new(nil, "hostname", 1, 2)
@@assignment_visitor ||= Puppet::Pops::Visitor.new(nil, "assign", 0, 1)
@@query_visitor ||= Puppet::Pops::Visitor.new(nil, "query", 0, 0)
@@top_visitor ||= Puppet::Pops::Visitor.new(nil, "top", 1, 1)
@@relation_visitor ||= Puppet::Pops::Visitor.new(nil, "relation", 1, 1)
@acceptor = diagnostics_producer
end
# Validates the entire model by visiting each model element and calling `check`.
# The result is collected (or acted on immediately) by the configured diagnostic provider/acceptor
# given when creating this Checker.
#
def validate(model)
# tree iterate the model, and call check for each element
check(model)
model.eAllContents.each {|m| check(m) }
end
# Performs regular validity check
def check(o)
@@check_visitor.visit_this(self, o)
end
# Performs check if this is a vaid hostname expression
# @param single_feature_name [String, nil] the name of a single valued hostname feature of the value's container. e.g. 'parent'
def hostname(o, semantic, single_feature_name = nil)
@@hostname_visitor.visit_this(self, o, semantic, single_feature_name)
end
# Performs check if this is valid as a query
def query(o)
@@query_visitor.visit_this(self, o)
end
# Performs check if this is valid as a relationship side
def relation(o, container)
@@relation_visitor.visit_this(self, o, container)
end
# Performs check if this is valid as a rvalue
def rvalue(o)
@@rvalue_visitor.visit_this(self, o)
end
# Performs check if this is valid as a container of a definition (class, define, node)
def top(o, definition)
@@top_visitor.visit_this(self, o, definition)
end
# Checks the LHS of an assignment (is it assignable?).
# If args[0] is true, assignment via index is checked.
#
def assign(o, *args)
@@assignment_visitor.visit_this(self, o, *args)
end
#---ASSIGNMENT CHECKS
def assign_VariableExpression(o, *args)
varname_string = varname_to_s(o.expr)
if varname_string =~ /^[0-9]+$/
acceptor.accept(Issues::ILLEGAL_NUMERIC_ASSIGNMENT, o, :varname => varname_string)
end
# Can not assign to something in another namespace (i.e. a '::' in the name is not legal)
if acceptor.will_accept? Issues::CROSS_SCOPE_ASSIGNMENT
if varname_string =~ /::/
acceptor.accept(Issues::CROSS_SCOPE_ASSIGNMENT, o, :name => varname_string)
end
end
# TODO: Could scan for reassignment of the same variable if done earlier in the same container
# Or if assigning to a parameter (more work).
# TODO: Investigate if there are invalid cases for += assignment
end
def assign_AccessExpression(o, *args)
# Are indexed assignments allowed at all ? $x[x] = '...'
if acceptor.will_accept? Issues::ILLEGAL_INDEXED_ASSIGNMENT
acceptor.accept(Issues::ILLEGAL_INDEXED_ASSIGNMENT, o)
else
# Then the left expression must be assignable-via-index
assign(o.left_expr, true)
end
end
def assign_Object(o, *args)
# Can not assign to anything else (differentiate if this is via index or not)
# i.e. 10 = 'hello' vs. 10['x'] = 'hello' (the root is reported as being in error in both cases)
#
acceptor.accept(args[0] ? Issues::ILLEGAL_ASSIGNMENT_VIA_INDEX : Issues::ILLEGAL_ASSIGNMENT, o)
end
#---CHECKS
def check_Object(o)
end
def check_Factory(o)
check(o.current)
end
def check_AccessExpression(o)
# Check multiplicity of keys
case o.left_expr
when Model::QualifiedName
# allows many keys, but the name should really be a QualifiedReference
acceptor.accept(Issues::DEPRECATED_NAME_AS_TYPE, o, :name => o.left_expr.value)
when Model::QualifiedReference
# ok, allows many - this is a resource reference
else
# i.e. for any other expression that may produce an array or hash
if o.keys.size > 1
acceptor.accept(Issues::UNSUPPORTED_RANGE, o, :count => o.keys.size)
end
if o.keys.size < 1
acceptor.accept(Issues::MISSING_INDEX, o)
end
end
end
def check_AssignmentExpression(o)
assign(o.left_expr)
rvalue(o.right_expr)
end
# Checks that operation with :+> is contained in a ResourceOverride or Collector.
#
# Parent of an AttributeOperation can be one of:
# * CollectExpression
# * ResourceOverride
# * ResourceBody (ILLEGAL this is a regular resource expression)
# * ResourceDefaults (ILLEGAL)
#
def check_AttributeOperation(o)
if o.operator == :'+>'
# Append operator use is constrained
parent = o.eContainer
unless parent.is_a?(Model::CollectExpression) || parent.is_a?(Model::ResourceOverrideExpression)
acceptor.accept(Issues::ILLEGAL_ATTRIBUTE_APPEND, o, {:name=>o.attribute_name, :parent=>parent})
end
end
rvalue(o.value_expr)
end
def check_BinaryExpression(o)
rvalue(o.left_expr)
rvalue(o.right_expr)
end
def check_CallNamedFunctionExpression(o)
unless o.functor_expr.is_a? Model::QualifiedName
acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.functor_expr, :feature => 'function name', :container => o)
end
end
def check_MethodCallExpression(o)
unless o.functor_expr.is_a? Model::QualifiedName
acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.functor_expr, :feature => 'function name', :container => o)
end
end
def check_CaseExpression(o)
# There should only be one LiteralDefault case option value
# TODO: Implement this check
end
def check_CollectExpression(o)
unless o.type_expr.is_a? Model::QualifiedReference
acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.type_expr, :feature=> 'type name', :container => o)
end
# If a collect expression tries to collect exported resources and storeconfigs is not on
# then it will not work... This was checked in the parser previously. This is a runtime checking
# thing as opposed to a language thing.
if acceptor.will_accept?(Issues::RT_NO_STORECONFIGS) && o.query.is_a?(Model::ExportedQuery)
acceptor.accept(Issues::RT_NO_STORECONFIGS, o)
end
end
# Only used for function names, grammar should not be able to produce something faulty, but
# check anyway if model is created programatically (it will fail in transformation to AST for sure).
def check_NamedAccessExpression(o)
name = o.right_expr
unless name.is_a? Model::QualifiedName
acceptor.accept(Issues::ILLEGAL_EXPRESSION, name, :feature=> 'function name', :container => o.eContainer)
end
end
# for 'class' and 'define'
def check_NamedDefinition(o)
top(o.eContainer, o)
if (acceptor.will_accept? Issues::NAME_WITH_HYPHEN) && o.name.include?('-')
acceptor.accept(Issues::NAME_WITH_HYPHEN, o, {:name => o.name})
end
end
def check_ImportExpression(o)
o.files.each do |f|
unless f.is_a? Model::LiteralString
acceptor.accept(Issues::ILLEGAL_EXPRESSION, f, :feature => 'file name', :container => o)
end
end
end
def check_InstanceReference(o)
# TODO: Original warning is :
# Puppet.warning addcontext("Deprecation notice: Resource references should now be capitalized")
# This model element is not used in the egrammar.
# Either implement checks or deprecate the use of InstanceReference (the same is acheived by
# transformation of AccessExpression when used where an Instance/Resource reference is allowed.
#
end
# Restrictions on hash key are because of the strange key comparisons/and merge rules in the AST evaluation
# (Even the allowed ones are handled in a strange way).
#
def transform_KeyedEntry(o)
case o.key
when Model::QualifiedName
when Model::LiteralString
when Model::LiteralNumber
when Model::ConcatenatedString
else
acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.key, :feature => 'hash key', :container => o.eContainer)
end
end
# A Lambda is a Definition, but it may appear in other scopes that top scope (Which check_Definition asserts).
#
def check_LambdaExpression(o)
end
def check_NodeDefinition(o)
# Check that hostnames are valid hostnames (or regular expressons)
hostname(o.host_matches, o)
hostname(o.parent, o, 'parent') unless o.parent.nil?
top(o.eContainer, o)
end
# No checking takes place - all expressions using a QualifiedName need to check. This because the
# rules are slightly different depending on the container (A variable allows a numeric start, but not
# other names). This means that (if the lexer/parser so chooses) a QualifiedName
# can be anything when it represents a Bare Word and evaluates to a String.
#
def check_QualifiedName(o)
end
# Checks that the value is a valid UpperCaseWord (a CLASSREF), and optionally if it contains a hypen.
# DOH: QualifiedReferences are created with LOWER CASE NAMES at parse time
def check_QualifiedReference(o)
# Is this a valid qualified name?
if o.value !~ Puppet::Pops::Patterns::CLASSREF
acceptor.accept(Issues::ILLEGAL_CLASSREF, o, {:name=>o.value})
elsif (acceptor.will_accept? Issues::NAME_WITH_HYPHEN) && o.value.include?('-')
acceptor.accept(Issues::NAME_WITH_HYPHEN, o, {:name => o.value})
end
end
def check_QueryExpression(o)
query(o.expr) if o.expr # is optional
end
def relation_Object(o, rel_expr)
acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature => o.eContainingFeature, :container => rel_expr})
end
def relation_AccessExpression(o, rel_expr); end
def relation_CollectExpression(o, rel_expr); end
def relation_VariableExpression(o, rel_expr); end
def relation_LiteralString(o, rel_expr); end
def relation_ConcatenatedStringExpression(o, rel_expr); end
def relation_SelectorExpression(o, rel_expr); end
def relation_CaseExpression(o, rel_expr); end
def relation_ResourceExpression(o, rel_expr); end
def relation_RelationshipExpression(o, rel_expr); end
def check_Parameter(o)
if o.name =~ /^[0-9]+$/
acceptor.accept(Issues::ILLEGAL_NUMERIC_PARAMETER, o, :name => o.name)
end
end
#relationship_side: resource
# | resourceref
# | collection
# | variable
# | quotedtext
# | selector
# | casestatement
# | hasharrayaccesses
def check_RelationshipExpression(o)
relation(o.left_expr, o)
relation(o.right_expr, o)
end
def check_ResourceExpression(o)
# A resource expression must have a lower case NAME as its type e.g. 'file { ... }'
unless o.type_name.is_a? Model::QualifiedName
acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.type_name, :feature => 'resource type', :container => o)
end
# This is a runtime check - the model is valid, but will have runtime issues when evaluated
# and storeconfigs is not set.
if acceptor.will_accept?(Issues::RT_NO_STORECONFIGS) && o.exported
acceptor.accept(Issues::RT_NO_STORECONFIGS_EXPORT, o)
end
end
def check_ResourceDefaultsExpression(o)
if o.form && o.form != :regular
acceptor.accept(Issues::NOT_VIRTUALIZEABLE, o)
end
end
# Transformation of SelectorExpression is limited to certain types of expressions.
# This is probably due to constraints in the old grammar rather than any real concerns.
def select_SelectorExpression(o)
case o.left_expr
when Model::CallNamedFunctionExpression
when Model::AccessExpression
when Model::VariableExpression
when Model::ConcatenatedString
else
acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.left_expr, :feature => 'left operand', :container => o)
end
end
def check_UnaryExpression(o)
rvalue(o.expr)
end
def check_UnlessExpression(o)
# TODO: Unless may not have an elsif
# TODO: 3.x unless may not have an else
end
def check_VariableExpression(o)
# The expression must be a qualified name
if !o.expr.is_a? Model::QualifiedName
acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, :feature => 'name', :container => o)
else
# Note, that if it later becomes illegal with hyphen in any name, this special check
# can be skipped in favor of the check in QualifiedName, which is now not done if contained in
# a VariableExpression
name = o.expr.value
if (acceptor.will_accept? Issues::VAR_WITH_HYPHEN) && name.include?('-')
acceptor.accept(Issues::VAR_WITH_HYPHEN, o, {:name => name})
end
end
end
#--- HOSTNAME CHECKS
# Transforms Array of host matching expressions into a (Ruby) array of AST::HostName
def hostname_Array(o, semantic, single_feature_name)
if single_feature_name
acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature=>single_feature_name, :container=>semantic})
end
o.each {|x| hostname(x, semantic, false) }
end
def hostname_String(o, semantic, single_feature_name)
# The 3.x checker only checks for illegal characters - if matching /[^-\w.]/ the name is invalid,
# but this allows pathological names like "a..b......c", "----"
# TODO: Investigate if more illegal hostnames should be flagged.
#
if o =~ Puppet::Pops::Patterns::ILLEGAL_HOSTNAME_CHARS
acceptor.accept(Issues::ILLEGAL_HOSTNAME_CHARS, semantic, :hostname => o)
end
end
def hostname_LiteralValue(o, semantic, single_feature_name)
hostname_String(o.value.to_s, o, single_feature_name)
end
def hostname_ConcatenatedString(o, semantic, single_feature_name)
# Puppet 3.1. only accepts a concatenated string without interpolated expressions
if the_expr = o.segments.index {|s| s.is_a?(Model::TextExpression) }
acceptor.accept(Issues::ILLEGAL_HOSTNAME_INTERPOLATION, o.segments[the_expr].expr)
elsif o.segments.size() != 1
# corner case, bad model, concatenation of several plain strings
acceptor.accept(Issues::ILLEGAL_HOSTNAME_INTERPOLATION, o)
else
# corner case, may be ok, but lexer may have replaced with plain string, this is
# here if it does not
hostname_String(o.segments[0], o.segments[0], false)
end
end
def hostname_QualifiedName(o, semantic, single_feature_name)
hostname_String(o.value.to_s, o, single_feature_name)
end
def hostname_QualifiedReference(o, semantic, single_feature_name)
hostname_String(o.value.to_s, o, single_feature_name)
end
def hostname_LiteralNumber(o, semantic, single_feature_name)
# always ok
end
def hostname_LiteralDefault(o, semantic, single_feature_name)
# always ok
end
def hostname_LiteralRegularExpression(o, semantic, single_feature_name)
# always ok
end
def hostname_Object(o, semantic, single_feature_name)
acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature=> single_feature_name || 'hostname', :container=>semantic})
end
#---QUERY CHECKS
# Anything not explicitly allowed is flagged as error.
def query_Object(o)
acceptor.accept(Issues::ILLEGAL_QUERY_EXPRESSION, o)
end
# Puppet AST only allows == and !=
#
def query_ComparisonExpression(o)
acceptor.accept(Issues::ILLEGAL_QUERY_EXPRESSION, o) unless [:'==', :'!='].include? o.operator
end
# Allows AND, OR, and checks if left/right are allowed in query.
def query_BooleanExpression(o)
query o.left_expr
query o.right_expr
end
def query_ParenthesizedExpression(o)
query(o.expr)
end
def query_VariableExpression(o); end
def query_QualifiedName(o); end
def query_LiteralNumber(o); end
def query_LiteralString(o); end
def query_LiteralBoolean(o); end
#---RVALUE CHECKS
# By default, all expressions are reported as being rvalues
# Implement specific rvalue checks for those that are not.
#
def rvalue_Expression(o); end
def rvalue_ImportExpression(o) ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
def rvalue_BlockExpression(o) ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
def rvalue_CaseExpression(o) ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
def rvalue_IfExpression(o) ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
def rvalue_UnlessExpression(o) ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
def rvalue_ResourceExpression(o) ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
def rvalue_ResourceDefaultsExpression(o); acceptor.accept(Issues::NOT_RVALUE, o) ; end
def rvalue_ResourceOverrideExpression(o); acceptor.accept(Issues::NOT_RVALUE, o) ; end
def rvalue_CollectExpression(o) ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
def rvalue_Definition(o) ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
def rvalue_NodeDefinition(o) ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
def rvalue_UnaryExpression(o) ; rvalue o.expr ; end
#---TOP CHECK
def top_NilClass(o, definition)
# ok, reached the top, no more parents
end
def top_Object(o, definition)
# fail, reached a container that is not top level
acceptor.accept(Issues::NOT_TOP_LEVEL, definition)
end
def top_BlockExpression(o, definition)
# ok, if this is a block representing the body of a class, or is top level
top o.eContainer, definition
end
def top_HostClassDefinition(o, definition)
# ok, stop scanning parents
end
# A LambdaExpression is a BlockExpression, and this method is needed to prevent the polymorph method for BlockExpression
# to accept a lambda.
# A lambda can not iteratively create classes, nodes or defines as the lambda does not have a closure.
#
def top_LambdaExpression(o, definition)
# fail, stop scanning parents
acceptor.accept(Issues::NOT_TOP_LEVEL, definition)
end
#--- NON POLYMORPH, NON CHECKING CODE
# Produces string part of something named, or nil if not a QualifiedName or QualifiedReference
#
def varname_to_s(o)
case o
when Model::QualifiedName
o.value
when Model::QualifiedReference
o.value
else
nil
end
end
end
puppet-3.4.3/lib/puppet/file_serving.rb 0000644 0052762 0001160 00000000075 12300765631 020017 0 ustar jenkins jenkins # Just a stub class.
class Puppet::FileServing # :nodoc:
end
puppet-3.4.3/lib/puppet/resource/ 0000755 0052762 0001160 00000000000 12300765640 016643 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/resource/type_collection_helper.rb 0000644 0052762 0001160 00000000243 12300765631 023722 0 ustar jenkins jenkins require 'puppet/resource/type_collection'
module Puppet::Resource::TypeCollectionHelper
def known_resource_types
environment.known_resource_types
end
end
puppet-3.4.3/lib/puppet/resource/type_collection.rb 0000644 0052762 0001160 00000013560 12300765631 022371 0 ustar jenkins jenkins require 'puppet/parser/type_loader'
require 'puppet/util/file_watcher'
require 'puppet/util/warnings'
class Puppet::Resource::TypeCollection
attr_reader :environment
attr_accessor :parse_failed
include Puppet::Util::Warnings
def clear
@hostclasses.clear
@definitions.clear
@nodes.clear
@watched_files.clear
@notfound.clear
end
def initialize(env)
@environment = env.is_a?(String) ? Puppet::Node::Environment.new(env) : env
@hostclasses = {}
@definitions = {}
@nodes = {}
@notfound = {}
# So we can keep a list and match the first-defined regex
@node_list = []
@watched_files = Puppet::Util::FileWatcher.new
end
def import_ast(ast, modname)
ast.instantiate(modname).each do |instance|
add(instance)
end
end
def inspect
"TypeCollection" + { :hostclasses => @hostclasses.keys, :definitions => @definitions.keys, :nodes => @nodes.keys }.inspect
end
def <<(thing)
add(thing)
self
end
def add(instance)
if instance.type == :hostclass and other = @hostclasses[instance.name] and other.type == :hostclass
other.merge(instance)
return other
end
method = "add_#{instance.type}"
send(method, instance)
instance.resource_type_collection = self
instance
end
def add_hostclass(instance)
dupe_check(instance, @hostclasses) { |dupe| "Class '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined as a class" }
@hostclasses[instance.name] = instance
instance
end
def hostclass(name)
@hostclasses[munge_name(name)]
end
def add_node(instance)
dupe_check(instance, @nodes) { |dupe| "Node '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
@node_list << instance
@nodes[instance.name] = instance
instance
end
def loader
@loader ||= Puppet::Parser::TypeLoader.new(environment)
end
def node(name)
name = munge_name(name)
if node = @nodes[name]
return node
end
@node_list.each do |node|
next unless node.name_is_regex?
return node if node.match(name)
end
nil
end
def node_exists?(name)
@nodes[munge_name(name)]
end
def nodes?
@nodes.length > 0
end
def add_definition(instance)
dupe_check(instance, @hostclasses) { |dupe| "'#{instance.name}' is already defined#{dupe.error_context} as a class; cannot redefine as a definition" }
dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined" }
@definitions[instance.name] = instance
end
def definition(name)
@definitions[munge_name(name)]
end
def find_node(namespaces, name)
@nodes[munge_name(name)]
end
def find_hostclass(namespaces, name, options = {})
find_or_load(namespaces, name, :hostclass, options)
end
def find_definition(namespaces, name)
find_or_load(namespaces, name, :definition)
end
[:hostclasses, :nodes, :definitions].each do |m|
define_method(m) do
instance_variable_get("@#{m}").dup
end
end
def require_reparse?
@parse_failed || stale?
end
def stale?
@watched_files.changed?
end
def version
if !defined?(@version)
if environment[:config_version] == ""
@version = Time.now.to_i
else
@version = Puppet::Util::Execution.execute([environment[:config_version]]).strip
end
end
@version
rescue Puppet::ExecutionFailure => e
raise Puppet::ParseError, "Execution of config_version command `#{environment[:config_version]}` failed: #{e.message}"
end
def watch_file(filename)
@watched_files.watch(filename)
end
def watching_file?(filename)
@watched_files.watching?(filename)
end
private
# Return a list of all possible fully-qualified names that might be
# meant by the given name, in the context of namespaces.
def resolve_namespaces(namespaces, name)
name = name.downcase
if name =~ /^::/
# name is explicitly fully qualified, so just return it, sans
# initial "::".
return [name.sub(/^::/, '')]
end
if name == ""
# The name "" has special meaning--it always refers to a "main"
# hostclass which contains all toplevel resources.
return [""]
end
namespaces = [namespaces] unless namespaces.is_a?(Array)
namespaces = namespaces.collect { |ns| ns.downcase }
result = []
namespaces.each do |namespace|
ary = namespace.split("::")
# Search each namespace nesting in innermost-to-outermost order.
while ary.length > 0
result << "#{ary.join("::")}::#{name}"
ary.pop
end
# Finally, search the toplevel namespace.
result << name
end
return result.uniq
end
# Resolve namespaces and find the given object. Autoload it if
# necessary.
def find_or_load(namespaces, name, type, options = {})
searchspace = options[:assume_fqname] ? [name].flatten : resolve_namespaces(namespaces, name)
searchspace.each do |fqname|
result = send(type, fqname)
unless result
if @notfound[fqname] and Puppet[:ignoremissingtypes]
# do not try to autoload if we already tried and it wasn't conclusive
# as this is a time consuming operation. Warn the user.
debug_once "Not attempting to load #{type} #{fqname} as this object was missing during a prior compilation"
else
result = loader.try_load_fqname(type, fqname)
@notfound[fqname] = result.nil?
end
end
return result if result
end
return nil
end
def munge_name(name)
name.to_s.downcase
end
def dupe_check(instance, hash)
return unless dupe = hash[instance.name]
message = yield dupe
instance.fail Puppet::ParseError, message
end
end
puppet-3.4.3/lib/puppet/resource/catalog.rb 0000644 0052762 0001160 00000037511 12300765631 020611 0 ustar jenkins jenkins require 'puppet/node'
require 'puppet/indirector'
require 'puppet/transaction'
require 'puppet/util/pson'
require 'puppet/util/tagging'
require 'puppet/graph'
# This class models a node catalog. It is the thing meant to be passed
# from server to client, and it contains all of the information in the
# catalog, including the resources and the relationships between them.
#
# @api public
class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
class DuplicateResourceError < Puppet::Error
include Puppet::ExternalFileError
end
extend Puppet::Indirector
indirects :catalog, :terminus_setting => :catalog_terminus
include Puppet::Util::Tagging
extend Puppet::Util::Pson
# The host name this is a catalog for.
attr_accessor :name
# The catalog version. Used for testing whether a catalog
# is up to date.
attr_accessor :version
# How long this catalog took to retrieve. Used for reporting stats.
attr_accessor :retrieval_duration
# Whether this is a host catalog, which behaves very differently.
# In particular, reports are sent, graphs are made, and state is
# stored in the state database. If this is set incorrectly, then you often
# end up in infinite loops, because catalogs are used to make things
# that the host catalog needs.
attr_accessor :host_config
# Whether this catalog was retrieved from the cache, which affects
# whether it is written back out again.
attr_accessor :from_cache
# Some metadata to help us compile and generally respond to the current state.
attr_accessor :client_version, :server_version
# The environment for this catalog
attr_accessor :environment
# Add classes to our class list.
def add_class(*classes)
classes.each do |klass|
@classes << klass
end
# Add the class names as tags, too.
tag(*classes)
end
def title_key_for_ref( ref )
ref =~ /^([-\w:]+)\[(.*)\]$/m
[$1, $2]
end
def add_resource(*resources)
resources.each do |resource|
add_one_resource(resource)
end
end
# @param resource [A Resource] a resource in the catalog
# @return [A Resource, nil] the resource that contains the given resource
# @api public
def container_of(resource)
adjacent(resource, :direction => :in)[0]
end
def add_one_resource(resource)
fail_on_duplicate_type_and_title(resource)
add_resource_to_table(resource)
create_resource_aliases(resource)
resource.catalog = self if resource.respond_to?(:catalog=)
add_resource_to_graph(resource)
end
private :add_one_resource
def add_resource_to_table(resource)
title_key = title_key_for_ref(resource.ref)
@resource_table[title_key] = resource
@resources << title_key
end
private :add_resource_to_table
def add_resource_to_graph(resource)
add_vertex(resource)
@relationship_graph.add_vertex(resource) if @relationship_graph
end
private :add_resource_to_graph
def create_resource_aliases(resource)
if resource.respond_to?(:isomorphic?) and resource.isomorphic? and resource.name != resource.title
self.alias(resource, resource.uniqueness_key)
end
end
private :create_resource_aliases
# Create an alias for a resource.
def alias(resource, key)
resource.ref =~ /^(.+)\[/
class_name = $1 || resource.class.name
newref = [class_name, key].flatten
if key.is_a? String
ref_string = "#{class_name}[#{key}]"
return if ref_string == resource.ref
end
# LAK:NOTE It's important that we directly compare the references,
# because sometimes an alias is created before the resource is
# added to the catalog, so comparing inside the below if block
# isn't sufficient.
if existing = @resource_table[newref]
return if existing == resource
resource_declaration = " at #{resource.file}:#{resource.line}" if resource.file and resource.line
existing_declaration = " at #{existing.file}:#{existing.line}" if existing.file and existing.line
msg = "Cannot alias #{resource.ref} to #{key.inspect}#{resource_declaration}; resource #{newref.inspect} already declared#{existing_declaration}"
raise ArgumentError, msg
end
@resource_table[newref] = resource
@aliases[resource.ref] ||= []
@aliases[resource.ref] << newref
end
# Apply our catalog to the local host.
# @param options [Hash{Symbol => Object}] a hash of options
# @option options [Puppet::Transaction::Report] :report
# The report object to log this transaction to. This is optional,
# and the resulting transaction will create a report if not
# supplied.
# @option options [Array[String]] :tags
# Tags used to filter the transaction. If supplied then only
# resources tagged with any of these tags will be evaluated.
# @option options [Boolean] :ignoreschedules
# Ignore schedules when evaluating resources
# @option options [Boolean] :for_network_device
# Whether this catalog is for a network device
#
# @return [Puppet::Transaction] the transaction created for this
# application
#
# @api public
def apply(options = {})
Puppet::Util::Storage.load if host_config?
transaction = create_transaction(options)
begin
transaction.report.as_logging_destination do
transaction.evaluate
end
rescue Puppet::Error => detail
Puppet.log_exception(detail, "Could not apply complete catalog: #{detail}")
rescue => detail
Puppet.log_exception(detail, "Got an uncaught exception of type #{detail.class}: #{detail}")
ensure
# Don't try to store state unless we're a host config
# too recursive.
Puppet::Util::Storage.store if host_config?
end
yield transaction if block_given?
transaction
end
# The relationship_graph form of the catalog. This contains all of the
# dependency edges that are used for determining order.
#
# @return [Puppet::Graph::RelationshipGraph]
# @api public
def relationship_graph
if @relationship_graph.nil?
@relationship_graph = Puppet::Graph::RelationshipGraph.new(prioritizer)
@relationship_graph.populate_from(self)
end
@relationship_graph
end
def clear(remove_resources = true)
super()
# We have to do this so that the resources clean themselves up.
@resource_table.values.each { |resource| resource.remove } if remove_resources
@resource_table.clear
@resources = []
if @relationship_graph
@relationship_graph.clear
@relationship_graph = nil
end
end
def classes
@classes.dup
end
# Create a new resource and register it in the catalog.
def create_resource(type, options)
unless klass = Puppet::Type.type(type)
raise ArgumentError, "Unknown resource type #{type}"
end
return unless resource = klass.new(options)
add_resource(resource)
resource
end
# Make sure all of our resources are "finished".
def finalize
make_default_resources
@resource_table.values.each { |resource| resource.finish }
write_graph(:resources)
end
def host_config?
host_config
end
def initialize(name = nil)
super()
@name = name if name
@classes = []
@resource_table = {}
@resources = []
@relationship_graph = nil
@host_config = true
@aliases = {}
if block_given?
yield(self)
finalize
end
end
# Make the default objects necessary for function.
def make_default_resources
# We have to add the resources to the catalog, or else they won't get cleaned up after
# the transaction.
# First create the default scheduling objects
Puppet::Type.type(:schedule).mkdefaultschedules.each { |res| add_resource(res) unless resource(res.ref) }
# And filebuckets
if bucket = Puppet::Type.type(:filebucket).mkdefaultbucket
add_resource(bucket) unless resource(bucket.ref)
end
end
# Remove the resource from our catalog. Notice that we also call
# 'remove' on the resource, at least until resource classes no longer maintain
# references to the resource instances.
def remove_resource(*resources)
resources.each do |resource|
title_key = title_key_for_ref(resource.ref)
@resource_table.delete(title_key)
if aliases = @aliases[resource.ref]
aliases.each { |res_alias| @resource_table.delete(res_alias) }
@aliases.delete(resource.ref)
end
remove_vertex!(resource) if vertex?(resource)
@relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource)
@resources.delete(title_key)
resource.remove
end
end
# Look a resource up by its reference (e.g., File[/etc/passwd]).
def resource(type, title = nil)
# Always create a resource reference, so that it always
# canonicalizes how we are referring to them.
if title
res = Puppet::Resource.new(type, title)
else
# If they didn't provide a title, then we expect the first
# argument to be of the form 'Class[name]', which our
# Reference class canonicalizes for us.
res = Puppet::Resource.new(nil, type)
end
title_key = [res.type, res.title.to_s]
uniqueness_key = [res.type, res.uniqueness_key].flatten
@resource_table[title_key] || @resource_table[uniqueness_key]
end
def resource_refs
resource_keys.collect{ |type, name| name.is_a?( String ) ? "#{type}[#{name}]" : nil}.compact
end
def resource_keys
@resource_table.keys
end
def resources
@resources.collect do |key|
@resource_table[key]
end
end
def self.from_pson(data)
result = new(data['name'])
if tags = data['tags']
result.tag(*tags)
end
if version = data['version']
result.version = version
end
if environment = data['environment']
result.environment = environment
end
if resources = data['resources']
result.add_resource(*resources.collect do |res|
Puppet::Resource.from_pson(res)
end)
end
if edges = data['edges']
edges = PSON.parse(edges) if edges.is_a?(String)
edges.each do |edge|
edge_from_pson(result, edge)
end
end
if classes = data['classes']
result.add_class(*classes)
end
result
end
def self.edge_from_pson(result, edge)
# If no type information was presented, we manually find
# the class.
edge = Puppet::Relationship.from_pson(edge) if edge.is_a?(Hash)
unless source = result.resource(edge.source)
raise ArgumentError, "Could not convert from pson: Could not find relationship source #{edge.source.inspect}"
end
edge.source = source
unless target = result.resource(edge.target)
raise ArgumentError, "Could not convert from pson: Could not find relationship target #{edge.target.inspect}"
end
edge.target = target
result.add_edge(edge)
end
def to_data_hash
{
'tags' => tags,
'name' => name,
'version' => version,
'environment' => environment.to_s,
'resources' => @resources.collect { |v| @resource_table[v].to_pson_data_hash },
'edges' => edges. collect { |e| e.to_pson_data_hash },
'classes' => classes
}
end
PSON.register_document_type('Catalog',self)
def to_pson_data_hash
{
'document_type' => 'Catalog',
'data' => to_data_hash,
'metadata' => {
'api_version' => 1
}
}
end
def to_pson(*args)
to_pson_data_hash.to_pson(*args)
end
# Convert our catalog into a RAL catalog.
def to_ral
to_catalog :to_ral
end
# Convert our catalog into a catalog of Puppet::Resource instances.
def to_resource
to_catalog :to_resource
end
# filter out the catalog, applying +block+ to each resource.
# If the block result is false, the resource will
# be kept otherwise it will be skipped
def filter(&block)
to_catalog :to_resource, &block
end
# Store the classes in the classfile.
def write_class_file
::File.open(Puppet[:classfile], "w") do |f|
f.puts classes.join("\n")
end
rescue => detail
Puppet.err "Could not create class file #{Puppet[:classfile]}: #{detail}"
end
# Store the list of resources we manage
def write_resource_file
::File.open(Puppet[:resourcefile], "w") do |f|
to_print = resources.map do |resource|
next unless resource.managed?
if resource.name_var
"#{resource.type}[#{resource[resource.name_var]}]"
else
"#{resource.ref.downcase}"
end
end.compact
f.puts to_print.join("\n")
end
rescue => detail
Puppet.err "Could not create resource file #{Puppet[:resourcefile]}: #{detail}"
end
# Produce the graph files if requested.
def write_graph(name)
# We only want to graph the main host catalog.
return unless host_config?
super
end
private
def prioritizer
@prioritizer ||= case Puppet[:ordering]
when "title-hash"
Puppet::Graph::TitleHashPrioritizer.new
when "manifest"
Puppet::Graph::SequentialPrioritizer.new
when "random"
Puppet::Graph::RandomPrioritizer.new
else
raise Puppet::DevError, "Unknown ordering type #{Puppet[:ordering]}"
end
end
def create_transaction(options)
transaction = Puppet::Transaction.new(self, options[:report], prioritizer)
transaction.tags = options[:tags] if options[:tags]
transaction.ignoreschedules = true if options[:ignoreschedules]
transaction.for_network_device = options[:network_device]
transaction
end
# Verify that the given resource isn't declared elsewhere.
def fail_on_duplicate_type_and_title(resource)
# Short-circuit the common case,
return unless existing_resource = @resource_table[title_key_for_ref(resource.ref)]
# If we've gotten this far, it's a real conflict
msg = "Duplicate declaration: #{resource.ref} is already declared"
msg << " in file #{existing_resource.file}:#{existing_resource.line}" if existing_resource.file and existing_resource.line
msg << "; cannot redeclare"
raise DuplicateResourceError.new(msg, resource.file, resource.line)
end
# An abstracted method for converting one catalog into another type of catalog.
# This pretty much just converts all of the resources from one class to another, using
# a conversion method.
def to_catalog(convert)
result = self.class.new(self.name)
result.version = self.version
result.environment = self.environment
map = {}
resources.each do |resource|
next if virtual_not_exported?(resource)
next if block_given? and yield resource
newres = resource.copy_as_resource
newres.catalog = result
if convert != :to_resource
newres = newres.to_ral
end
# We can't guarantee that resources don't munge their names
# (like files do with trailing slashes), so we have to keep track
# of what a resource got converted to.
map[resource.ref] = newres
result.add_resource newres
end
message = convert.to_s.gsub "_", " "
edges.each do |edge|
# Skip edges between virtual resources.
next if virtual_not_exported?(edge.source)
next if block_given? and yield edge.source
next if virtual_not_exported?(edge.target)
next if block_given? and yield edge.target
unless source = map[edge.source.ref]
raise Puppet::DevError, "Could not find resource #{edge.source.ref} when converting #{message} resources"
end
unless target = map[edge.target.ref]
raise Puppet::DevError, "Could not find resource #{edge.target.ref} when converting #{message} resources"
end
result.add_edge(source, target, edge.label)
end
map.clear
result.add_class(*self.classes)
result.tag(*self.tags)
result
end
def virtual_not_exported?(resource)
resource.respond_to?(:virtual?) and resource.virtual? and (resource.respond_to?(:exported?) and not resource.exported?)
end
end
puppet-3.4.3/lib/puppet/resource/type.rb 0000644 0052762 0001160 00000031040 12300765631 020147 0 ustar jenkins jenkins require 'puppet/parser'
require 'puppet/util/warnings'
require 'puppet/util/errors'
require 'puppet/util/inline_docs'
require 'puppet/parser/ast/leaf'
require 'puppet/parser/ast/block_expression'
require 'puppet/dsl'
# Puppet::Resource::Type represents nodes, classes and defined types.
#
# It has a standard format for external consumption, usable from the
# resource_type indirection via rest and the resource_type face. See the
# {file:api_docs/http_resource_type.md#Schema resource type schema
# description}.
#
# @api public
class Puppet::Resource::Type
Puppet::ResourceType = self
include Puppet::Util::InlineDocs
include Puppet::Util::Warnings
include Puppet::Util::Errors
RESOURCE_KINDS = [:hostclass, :node, :definition]
# Map the names used in our documentation to the names used internally
RESOURCE_KINDS_TO_EXTERNAL_NAMES = {
:hostclass => "class",
:node => "node",
:definition => "defined_type",
}
RESOURCE_EXTERNAL_NAMES_TO_KINDS = RESOURCE_KINDS_TO_EXTERNAL_NAMES.invert
attr_accessor :file, :line, :doc, :code, :ruby_code, :parent, :resource_type_collection
attr_reader :namespace, :arguments, :behaves_like, :module_name
# This should probably be renamed to 'kind' eventually, in accordance with the changes
# made for serialization and API usability (#14137). At the moment that seems like
# it would touch a whole lot of places in the code, though. --cprice 2012-04-23
attr_reader :type
RESOURCE_KINDS.each do |t|
define_method("#{t}?") { self.type == t }
end
require 'puppet/indirector'
extend Puppet::Indirector
indirects :resource_type, :terminus_class => :parser
def self.from_pson(data)
name = data.delete('name') or raise ArgumentError, "Resource Type names must be specified"
kind = data.delete('kind') || "definition"
unless type = RESOURCE_EXTERNAL_NAMES_TO_KINDS[kind]
raise ArgumentError, "Unsupported resource kind '#{kind}'"
end
data = data.inject({}) { |result, ary| result[ary[0].intern] = ary[1]; result }
# External documentation uses "parameters" but the internal name
# is "arguments"
data[:arguments] = data.delete(:parameters)
new(type, name, data)
end
def to_pson(*args)
to_data_hash.to_pson(*args)
end
def to_data_hash
data = [:doc, :line, :file, :parent].inject({}) do |hash, param|
next hash unless (value = self.send(param)) and (value != "")
hash[param.to_s] = value
hash
end
# External documentation uses "parameters" but the internal name
# is "arguments"
data['parameters'] = arguments.dup unless arguments.empty?
data['name'] = name
unless RESOURCE_KINDS_TO_EXTERNAL_NAMES.has_key?(type)
raise ArgumentError, "Unsupported resource kind '#{type}'"
end
data['kind'] = RESOURCE_KINDS_TO_EXTERNAL_NAMES[type]
data
end
# Are we a child of the passed class? Do a recursive search up our
# parentage tree to figure it out.
def child_of?(klass)
return false unless parent
return(klass == parent_type ? true : parent_type.child_of?(klass))
end
# Now evaluate the code associated with this class or definition.
def evaluate_code(resource)
static_parent = evaluate_parent_type(resource)
scope = static_parent || resource.scope
scope = scope.newscope(:namespace => namespace, :source => self, :resource => resource) unless resource.title == :main
scope.compiler.add_class(name) unless definition?
set_resource_parameters(resource, scope)
resource.add_edge_to_stage
if code
if @match # Only bother setting up the ephemeral scope if there are match variables to add into it
begin
elevel = scope.ephemeral_level
scope.ephemeral_from(@match, file, line)
code.safeevaluate(scope)
ensure
scope.unset_ephemeral_var(elevel)
end
else
code.safeevaluate(scope)
end
end
evaluate_ruby_code(resource, scope) if ruby_code
end
def initialize(type, name, options = {})
@type = type.to_s.downcase.to_sym
raise ArgumentError, "Invalid resource supertype '#{type}'" unless RESOURCE_KINDS.include?(@type)
name = convert_from_ast(name) if name.is_a?(Puppet::Parser::AST::HostName)
set_name_and_namespace(name)
[:code, :doc, :line, :file, :parent].each do |param|
next unless value = options[param]
send(param.to_s + "=", value)
end
set_arguments(options[:arguments])
@match = nil
@module_name = options[:module_name]
end
# This is only used for node names, and really only when the node name
# is a regexp.
def match(string)
return string.to_s.downcase == name unless name_is_regex?
@match = @name.match(string)
end
# Add code from a new instance to our code.
def merge(other)
fail "#{name} is not a class; cannot add code to it" unless type == :hostclass
fail "#{other.name} is not a class; cannot add code from it" unless other.type == :hostclass
fail "Cannot have code outside of a class/node/define because 'freeze_main' is enabled" if name == "" and Puppet.settings[:freeze_main]
if parent and other.parent and parent != other.parent
fail "Cannot merge classes with different parent classes (#{name} => #{parent} vs. #{other.name} => #{other.parent})"
end
# We know they're either equal or only one is set, so keep whichever parent is specified.
self.parent ||= other.parent
if other.doc
self.doc ||= ""
self.doc += other.doc
end
# This might just be an empty, stub class.
return unless other.code
unless self.code
self.code = other.code
return
end
self.code = self.code.sequence_with(other.code)
end
# Make an instance of the resource type, and place it in the catalog
# if it isn't in the catalog already. This is only possible for
# classes and nodes. No parameters are be supplied--if this is a
# parameterized class, then all parameters take on their default
# values.
def ensure_in_catalog(scope, parameters=nil)
type == :definition and raise ArgumentError, "Cannot create resources for defined resource types"
resource_type = type == :hostclass ? :class : :node
# Do nothing if the resource already exists; this makes sure we don't
# get multiple copies of the class resource, which helps provide the
# singleton nature of classes.
# we should not do this for classes with parameters
# if parameters are passed, we should still try to create the resource
# even if it exists so that we can fail
# this prevents us from being able to combine param classes with include
if resource = scope.catalog.resource(resource_type, name) and !parameters
return resource
end
resource = Puppet::Parser::Resource.new(resource_type, name, :scope => scope, :source => self)
assign_parameter_values(parameters, resource)
instantiate_resource(scope, resource)
scope.compiler.add_resource(scope, resource)
resource
end
def instantiate_resource(scope, resource)
# Make sure our parent class has been evaluated, if we have one.
if parent && !scope.catalog.resource(resource.type, parent)
parent_type(scope).ensure_in_catalog(scope)
end
if ['Class', 'Node'].include? resource.type
scope.catalog.tag(*resource.tags)
end
end
def name
return @name unless @name.is_a?(Regexp)
@name.source.downcase.gsub(/[^-\w:.]/,'').sub(/^\.+/,'')
end
def name_is_regex?
@name.is_a?(Regexp)
end
def assign_parameter_values(parameters, resource)
return unless parameters
# It'd be nice to assign default parameter values here,
# but we can't because they often rely on local variables
# created during set_resource_parameters.
parameters.each do |name, value|
resource.set_parameter name, value
end
end
# MQR TODO:
#
# The change(s) introduced by the fix for #4270 are mostly silly & should be
# removed, though we didn't realize it at the time. If it can be established/
# ensured that nodes never call parent_type and that resource_types are always
# (as they should be) members of exactly one resource_type_collection the
# following method could / should be replaced with:
#
# def parent_type
# @parent_type ||= parent && (
# resource_type_collection.find_or_load([name],parent,type.to_sym) ||
# fail Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{resource_type_collection.environment}"
# )
# end
#
# ...and then the rest of the changes around passing in scope reverted.
#
def parent_type(scope = nil)
return nil unless parent
unless @parent_type
raise "Must pass scope to parent_type when called first time" unless scope
unless @parent_type = scope.environment.known_resource_types.send("find_#{type}", [name], parent)
fail Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{scope.environment}"
end
end
@parent_type
end
# Set any arguments passed by the resource as variables in the scope.
def set_resource_parameters(resource, scope)
set = {}
resource.to_hash.each do |param, value|
param = param.to_sym
fail Puppet::ParseError, "#{resource.ref} does not accept attribute #{param}" unless valid_parameter?(param)
exceptwrap { scope[param.to_s] = value }
set[param] = true
end
if @type == :hostclass
scope["title"] = resource.title.to_s.downcase unless set.include? :title
scope["name"] = resource.name.to_s.downcase unless set.include? :name
else
scope["title"] = resource.title unless set.include? :title
scope["name"] = resource.name unless set.include? :name
end
scope["module_name"] = module_name if module_name and ! set.include? :module_name
if caller_name = scope.parent_module_name and ! set.include?(:caller_module_name)
scope["caller_module_name"] = caller_name
end
scope.class_set(self.name,scope) if hostclass? or node?
# Evaluate the default parameters, now that all other variables are set
default_params = resource.set_default_parameters(scope)
default_params.each { |param| scope[param] = resource[param] }
# This has to come after the above parameters so that default values
# can use their values
resource.validate_complete
end
# Check whether a given argument is valid.
def valid_parameter?(param)
param = param.to_s
return true if param == "name"
return true if Puppet::Type.metaparam?(param)
return false unless defined?(@arguments)
return(arguments.include?(param) ? true : false)
end
def set_arguments(arguments)
@arguments = {}
return if arguments.nil?
arguments.each do |arg, default|
arg = arg.to_s
warn_if_metaparam(arg, default)
@arguments[arg] = default
end
end
private
def convert_from_ast(name)
value = name.value
if value.is_a?(Puppet::Parser::AST::Regex)
name = value.value
else
name = value
end
end
def evaluate_parent_type(resource)
return unless klass = parent_type(resource.scope) and parent_resource = resource.scope.compiler.catalog.resource(:class, klass.name) || resource.scope.compiler.catalog.resource(:node, klass.name)
parent_resource.evaluate unless parent_resource.evaluated?
parent_scope(resource.scope, klass)
end
def evaluate_ruby_code(resource, scope)
Puppet::DSL::ResourceAPI.new(resource, scope, ruby_code).evaluate
end
# Split an fq name into a namespace and name
def namesplit(fullname)
ary = fullname.split("::")
n = ary.pop || ""
ns = ary.join("::")
return ns, n
end
def parent_scope(scope, klass)
scope.class_scope(klass) || raise(Puppet::DevError, "Could not find scope for #{klass.name}")
end
def set_name_and_namespace(name)
if name.is_a?(Regexp)
@name = name
@namespace = ""
else
@name = name.to_s.downcase
# Note we're doing something somewhat weird here -- we're setting
# the class's namespace to its fully qualified name. This means
# anything inside that class starts looking in that namespace first.
@namespace, ignored_shortname = @type == :hostclass ? [@name, ''] : namesplit(@name)
end
end
def warn_if_metaparam(param, default)
return unless Puppet::Type.metaparamclass(param)
if default
warnonce "#{param} is a metaparam; this value will inherit to all contained resources in the #{self.name} definition"
else
raise Puppet::ParseError, "#{param} is a metaparameter; please choose another parameter name in the #{self.name} definition"
end
end
end
puppet-3.4.3/lib/puppet/resource/status.rb 0000644 0052762 0001160 00000010675 12300765631 020524 0 ustar jenkins jenkins require 'time'
require 'puppet/network/format_support'
module Puppet
class Resource
class Status
include Puppet::Util::Tagging
include Puppet::Util::Logging
include Puppet::Network::FormatSupport
attr_accessor :resource, :node, :file, :line, :current_values, :status, :evaluation_time
STATES = [:skipped, :failed, :failed_to_restart, :restarted, :changed, :out_of_sync, :scheduled]
attr_accessor *STATES
attr_reader :source_description, :containment_path,
:default_log_level, :time, :resource, :change_count,
:out_of_sync_count, :resource_type, :title
YAML_ATTRIBUTES = %w{@resource @file @line @evaluation_time @change_count
@out_of_sync_count @tags @time @events @out_of_sync
@changed @resource_type @title @skipped @failed
@containment_path}.
map(&:to_sym)
def self.from_pson(data)
obj = self.allocate
obj.initialize_from_hash(data)
obj
end
# Provide a boolean method for each of the states.
STATES.each do |attr|
define_method("#{attr}?") do
!! send(attr)
end
end
def <<(event)
add_event(event)
self
end
def add_event(event)
@events << event
if event.status == 'failure'
self.failed = true
elsif event.status == 'success'
@change_count += 1
@changed = true
end
if event.status != 'audit'
@out_of_sync_count += 1
@out_of_sync = true
end
end
def events
@events
end
def failed_because(detail)
@real_resource.log_exception(detail, "Could not evaluate: #{detail}")
failed = true
# There's a contract (implicit unfortunately) that a status of failed
# will always be accompanied by an event with some explanatory power. This
# is useful for reporting/diagnostics/etc. So synthesize an event here
# with the exception detail as the message.
add_event(@real_resource.event(:name => :resource_error, :status => "failure", :message => detail.to_s))
end
def initialize(resource)
@real_resource = resource
@source_description = resource.path
@containment_path = resource.pathbuilder
@resource = resource.to_s
@change_count = 0
@out_of_sync_count = 0
@changed = false
@out_of_sync = false
@skipped = false
@failed = false
@file = resource.file
@line = resource.line
tag(*resource.tags)
@time = Time.now
@events = []
@resource_type = resource.type.to_s.capitalize
@title = resource.title
end
def initialize_from_hash(data)
@resource_type = data['resource_type']
@title = data['title']
@resource = data['resource']
@containment_path = data['containment_path']
@file = data['file']
@line = data['line']
@evaluation_time = data['evaluation_time']
@change_count = data['change_count']
@out_of_sync_count = data['out_of_sync_count']
@tags = Puppet::Util::TagSet.new(data['tags'])
@time = data['time']
@time = Time.parse(@time) if @time.is_a? String
@out_of_sync = data['out_of_sync']
@changed = data['changed']
@skipped = data['skipped']
@failed = data['failed']
@events = data['events'].map do |event|
Puppet::Transaction::Event.from_pson(event)
end
end
def to_data_hash
{
'title' => @title,
'file' => @file,
'line' => @line,
'resource' => @resource,
'resource_type' => @resource_type,
'containment_path' => @containment_path,
'evaluation_time' => @evaluation_time,
'tags' => @tags,
'time' => @time.iso8601(9),
'failed' => @failed,
'changed' => @changed,
'out_of_sync' => @out_of_sync,
'skipped' => @skipped,
'change_count' => @change_count,
'out_of_sync_count' => @out_of_sync_count,
'events' => @events,
}
end
def to_pson(*args)
to_data_hash.to_pson(*args)
end
def to_yaml_properties
YAML_ATTRIBUTES & super
end
private
def log_source
source_description
end
end
end
end
puppet-3.4.3/lib/puppet/file_system.rb 0000644 0052762 0001160 00000000301 12300765631 017656 0 ustar jenkins jenkins module Puppet::FileSystem
require 'puppet/file_system/path_pattern'
require 'puppet/file_system/file'
require 'puppet/file_system/memory_file'
require 'puppet/file_system/tempfile'
end
puppet-3.4.3/lib/puppet/file_bucket.rb 0000644 0052762 0001160 00000000115 12300765631 017612 0 ustar jenkins jenkins # stub
module Puppet::FileBucket
class BucketError < RuntimeError; end
end
puppet-3.4.3/lib/puppet/application.rb 0000644 0052762 0001160 00000037151 12300765631 017653 0 ustar jenkins jenkins require 'optparse'
require 'puppet/util/command_line'
require 'puppet/util/plugins'
require 'puppet/util/constant_inflector'
require 'puppet/error'
module Puppet
# This class handles all the aspects of a Puppet application/executable
# * setting up options
# * setting up logs
# * choosing what to run
# * representing execution status
#
# === Usage
# An application is a subclass of Puppet::Application.
#
# For legacy compatibility,
# Puppet::Application[:example].run
# is equivalent to
# Puppet::Application::Example.new.run
#
#
# class Puppet::Application::Example << Puppet::Application
#
# def preinit
# # perform some pre initialization
# @all = false
# end
#
# # run_command is called to actually run the specified command
# def run_command
# send Puppet::Util::CommandLine.new.args.shift
# end
#
# # option uses metaprogramming to create a method
# # and also tells the option parser how to invoke that method
# option("--arg ARGUMENT") do |v|
# @args << v
# end
#
# option("--debug", "-d") do |v|
# @debug = v
# end
#
# option("--all", "-a:) do |v|
# @all = v
# end
#
# def handle_unknown(opt,arg)
# # last chance to manage an option
# ...
# # let's say to the framework we finally handle this option
# true
# end
#
# def read
# # read action
# end
#
# def write
# # writeaction
# end
#
# end
#
# === Preinit
# The preinit block is the first code to be called in your application, before option parsing,
# setup or command execution.
#
# === Options
# Puppet::Application uses +OptionParser+ to manage the application options.
# Options are defined with the +option+ method to which are passed various
# arguments, including the long option, the short option, a description...
# Refer to +OptionParser+ documentation for the exact format.
# * If the option method is given a block, this one will be called whenever
# the option is encountered in the command-line argument.
# * If the option method has no block, a default functionnality will be used, that
# stores the argument (or true/false if the option doesn't require an argument) in
# the global (to the application) options array.
# * If a given option was not defined by a the +option+ method, but it exists as a Puppet settings:
# * if +unknown+ was used with a block, it will be called with the option name and argument
# * if +unknown+ wasn't used, then the option/argument is handed to Puppet.settings.handlearg for
# a default behavior
#
# --help is managed directly by the Puppet::Application class, but can be overriden.
#
# === Setup
# Applications can use the setup block to perform any initialization.
# The default +setup+ behaviour is to: read Puppet configuration and manage log level and destination
#
# === What and how to run
# If the +dispatch+ block is defined it is called. This block should return the name of the registered command
# to be run.
# If it doesn't exist, it defaults to execute the +main+ command if defined.
#
# === Execution state
# The class attributes/methods of Puppet::Application serve as a global place to set and query the execution
# status of the application: stopping, restarting, etc. The setting of the application status does not directly
# affect its running status; it's assumed that the various components within the application will consult these
# settings appropriately and affect their own processing accordingly. Control operations (signal handlers and
# the like) should set the status appropriately to indicate to the overall system that it's the process of
# stopping or restarting (or just running as usual).
#
# So, if something in your application needs to stop the process, for some reason, you might consider:
#
# def stop_me!
# # indicate that we're stopping
# Puppet::Application.stop!
# # ...do stuff...
# end
#
# And, if you have some component that involves a long-running process, you might want to consider:
#
# def my_long_process(giant_list_to_munge)
# giant_list_to_munge.collect do |member|
# # bail if we're stopping
# return if Puppet::Application.stop_requested?
# process_member(member)
# end
# end
class Application
require 'puppet/util'
include Puppet::Util
DOCPATTERN = ::File.expand_path(::File.dirname(__FILE__) + "/util/command_line/*" )
CommandLineArgs = Struct.new(:subcommand_name, :args)
@loader = Puppet::Util::Autoload.new(self, 'puppet/application')
class << self
include Puppet::Util
attr_accessor :run_status
def clear!
self.run_status = nil
end
def stop!
self.run_status = :stop_requested
end
def restart!
self.run_status = :restart_requested
end
# Indicates that Puppet::Application.restart! has been invoked and components should
# do what is necessary to facilitate a restart.
def restart_requested?
:restart_requested == run_status
end
# Indicates that Puppet::Application.stop! has been invoked and components should do what is necessary
# for a clean stop.
def stop_requested?
:stop_requested == run_status
end
# Indicates that one of stop! or start! was invoked on Puppet::Application, and some kind of process
# shutdown/short-circuit may be necessary.
def interrupted?
[:restart_requested, :stop_requested].include? run_status
end
# Indicates that Puppet::Application believes that it's in usual running run_mode (no stop/restart request
# currently active).
def clear?
run_status.nil?
end
# Only executes the given block if the run status of Puppet::Application is clear (no restarts, stops,
# etc. requested).
# Upon block execution, checks the run status again; if a restart has been requested during the block's
# execution, then controlled_run will send a new HUP signal to the current process.
# Thus, long-running background processes can potentially finish their work before a restart.
def controlled_run(&block)
return unless clear?
result = block.call
Process.kill(:HUP, $PID) if restart_requested?
result
end
SHOULD_PARSE_CONFIG_DEPRECATION_MSG = "is no longer supported; config file parsing " +
"is now controlled by the puppet engine, rather than by individual applications. This " +
"method will be removed in a future version of puppet."
def should_parse_config
Puppet.deprecation_warning("should_parse_config " + SHOULD_PARSE_CONFIG_DEPRECATION_MSG)
end
def should_not_parse_config
Puppet.deprecation_warning("should_not_parse_config " + SHOULD_PARSE_CONFIG_DEPRECATION_MSG)
end
def should_parse_config?
Puppet.deprecation_warning("should_parse_config? " + SHOULD_PARSE_CONFIG_DEPRECATION_MSG)
true
end
# used to declare code that handle an option
def option(*options, &block)
long = options.find { |opt| opt =~ /^--/ }.gsub(/^--(?:\[no-\])?([^ =]+).*$/, '\1' ).gsub('-','_')
fname = "handle_#{long}".intern
if (block_given?)
define_method(fname, &block)
else
define_method(fname) do |value|
self.options["#{long}".to_sym] = value
end
end
self.option_parser_commands << [options, fname]
end
def banner(banner = nil)
@banner ||= banner
end
def option_parser_commands
@option_parser_commands ||= (
superclass.respond_to?(:option_parser_commands) ? superclass.option_parser_commands.dup : []
)
@option_parser_commands
end
# @return [Array] the names of available applications
# @api public
def available_application_names
@loader.files_to_load.map do |fn|
::File.basename(fn, '.rb')
end.uniq
end
# Finds the class for a given application and loads the class. This does
# not create an instance of the application, it only gets a handle to the
# class. The code for the application is expected to live in a ruby file
# `puppet/application/#{name}.rb` that is available on the `$LOAD_PATH`.
#
# @param application_name [String] the name of the application to find (eg. "apply").
# @return [Class] the Class instance of the application that was found.
# @raise [Puppet::Error] if the application class was not found.
# @raise [LoadError] if there was a problem loading the application file.
# @api public
def find(application_name)
begin
require @loader.expand(application_name.to_s.downcase)
rescue LoadError => e
Puppet.log_and_raise(e, "Unable to find application '#{application_name}'. #{e}")
end
class_name = Puppet::Util::ConstantInflector.file2constant(application_name.to_s)
clazz = try_load_class(class_name)
################################################################
#### Begin 2.7.x backward compatibility hack;
#### eventually we need to issue a deprecation warning here,
#### and then get rid of this stanza in a subsequent release.
################################################################
if (clazz.nil?)
class_name = application_name.capitalize
clazz = try_load_class(class_name)
end
################################################################
#### End 2.7.x backward compatibility hack
################################################################
if clazz.nil?
raise Puppet::Error.new("Unable to load application class '#{class_name}' from file 'puppet/application/#{application_name}.rb'")
end
return clazz
end
# Given the fully qualified name of a class, attempt to get the class instance.
# @param [String] class_name the fully qualified name of the class to try to load
# @return [Class] the Class instance, or nil? if it could not be loaded.
def try_load_class(class_name)
return self.const_defined?(class_name) ? const_get(class_name) : nil
end
private :try_load_class
def [](name)
find(name).new
end
# Sets or gets the run_mode name. Sets the run_mode name if a mode_name is
# passed. Otherwise, gets the run_mode or a default run_mode
#
def run_mode( mode_name = nil)
if mode_name
Puppet.settings.preferred_run_mode = mode_name
end
return @run_mode if @run_mode and not mode_name
require 'puppet/util/run_mode'
@run_mode = Puppet::Util::RunMode[ mode_name || Puppet.settings.preferred_run_mode ]
end
# This is for testing only
def clear_everything_for_tests
@run_mode = @banner = @run_status = @option_parser_commands = nil
end
end
attr_reader :options, :command_line
# Every app responds to --version
# See also `lib/puppet/util/command_line.rb` for some special case early
# handling of this.
option("--version", "-V") do |arg|
puts "#{Puppet.version}"
exit
end
# Every app responds to --help
option("--help", "-h") do |v|
puts help
exit
end
def app_defaults()
Puppet::Settings.app_defaults_for_run_mode(self.class.run_mode).merge(
:name => name
)
end
def initialize_app_defaults()
Puppet.settings.initialize_app_defaults(app_defaults)
end
# override to execute code before running anything else
def preinit
end
def initialize(command_line = Puppet::Util::CommandLine.new)
@command_line = CommandLineArgs.new(command_line.subcommand_name, command_line.args.dup)
@options = {}
end
# Execute the application.
# @api public
# @return [void]
def run
# I don't really like the names of these lifecycle phases. It would be nice to change them to some more meaningful
# names, and make deprecated aliases. Also, Daniel suggests that we can probably get rid of this "plugin_hook"
# pattern, but we need to check with PE and the community first. --cprice 2012-03-16
#
exit_on_fail("get application-specific default settings") do
plugin_hook('initialize_app_defaults') { initialize_app_defaults }
end
require 'puppet'
require 'puppet/util/instrumentation'
Puppet::Util::Instrumentation.init
exit_on_fail("initialize") { plugin_hook('preinit') { preinit } }
exit_on_fail("parse application options") { plugin_hook('parse_options') { parse_options } }
exit_on_fail("prepare for execution") { plugin_hook('setup') { setup } }
exit_on_fail("configure routes from #{Puppet[:route_file]}") { configure_indirector_routes }
exit_on_fail("run") { plugin_hook('run_command') { run_command } }
end
def main
raise NotImplementedError, "No valid command or main"
end
def run_command
main
end
def setup
setup_logs
end
def setup_logs
if options[:debug] || options[:verbose]
Puppet::Util::Log.newdestination(:console)
end
set_log_level
Puppet::Util::Log.setup_default unless options[:setdest]
end
def set_log_level
if options[:debug]
Puppet::Util::Log.level = :debug
elsif options[:verbose]
Puppet::Util::Log.level = :info
end
end
def handle_logdest_arg(arg)
begin
Puppet::Util::Log.newdestination(arg)
options[:setdest] = true
rescue => detail
Puppet.log_exception(detail)
end
end
def configure_indirector_routes
route_file = Puppet[:route_file]
if Puppet::FileSystem::File.exist?(route_file)
routes = YAML.load_file(route_file)
application_routes = routes[name.to_s]
Puppet::Indirector.configure_routes(application_routes) if application_routes
end
end
def parse_options
# Create an option parser
option_parser = OptionParser.new(self.class.banner)
# Here we're building up all of the options that the application may need to handle. The main
# puppet settings defined in "defaults.rb" have already been parsed once (in command_line.rb) by
# the time we get here; however, our app may wish to handle some of them specially, so we need to
# make the parser aware of them again. We might be able to make this a bit more efficient by
# re-using the parser object that gets built up in command_line.rb. --cprice 2012-03-16
# Add all global options to it.
Puppet.settings.optparse_addargs([]).each do |option|
option_parser.on(*option) do |arg|
handlearg(option[0], arg)
end
end
# Add options that are local to this application, which were
# created using the "option()" metaprogramming method. If there
# are any conflicts, this application's options will be favored.
self.class.option_parser_commands.each do |options, fname|
option_parser.on(*options) do |value|
# Call the method that "option()" created.
self.send(fname, value)
end
end
# Scan command line. We just hand any exceptions to our upper levels,
# rather than printing help and exiting, so that we can meaningfully
# respond with context-sensitive help if we want to. --daniel 2011-04-12
option_parser.parse!(self.command_line.args)
end
def handlearg(opt, val)
opt, val = Puppet::Settings.clean_opt(opt, val)
send(:handle_unknown, opt, val) if respond_to?(:handle_unknown)
end
# this is used for testing
def self.exit(code)
exit(code)
end
def name
self.class.to_s.sub(/.*::/,"").downcase.to_sym
end
def help
"No help available for puppet #{name}"
end
def plugin_hook(step,&block)
Puppet::Plugins.send("before_application_#{step}",:application_object => self)
x = yield
Puppet::Plugins.send("after_application_#{step}",:application_object => self, :return_value => x)
x
end
private :plugin_hook
end
end
puppet-3.4.3/lib/puppet/interface.rb 0000644 0052762 0001160 00000016211 12300765631 017302 0 ustar jenkins jenkins require 'puppet'
require 'puppet/util/autoload'
require 'prettyprint'
require 'semver'
# @api public
class Puppet::Interface
require 'puppet/interface/documentation'
require 'puppet/interface/face_collection'
require 'puppet/interface/action'
require 'puppet/interface/action_builder'
require 'puppet/interface/action_manager'
require 'puppet/interface/option'
require 'puppet/interface/option_builder'
require 'puppet/interface/option_manager'
include FullDocs
include Puppet::Interface::ActionManager
extend Puppet::Interface::ActionManager
include Puppet::Interface::OptionManager
extend Puppet::Interface::OptionManager
include Puppet::Util
class << self
# This is just so we can search for actions. We only use its
# list of directories to search.
# @api private
# @deprecated
def autoloader
Puppet.deprecation_warning("Puppet::Interface.autoloader is deprecated; please use Puppet::Interface#loader instead")
@autoloader ||= Puppet::Util::Autoload.new(:application, "puppet/face")
end
# Lists all loaded faces
# @return [Array] The names of the loaded faces
def faces
Puppet::Interface::FaceCollection.faces
end
# Register a face
# @param instance [Puppet::Interface] The face
# @return [void]
# @api private
def register(instance)
Puppet::Interface::FaceCollection.register(instance)
end
# Defines a new Face.
# @todo Talk about using Faces DSL inside the block
#
# @param name [Symbol] the name of the face
# @param version [String] the version of the face (this should
# conform to {http://semver.org/ Semantic Versioning})
# @overload define(name, version, {|| ... })
# @return [Puppet::Interface] The created face
# @api public
# @dsl Faces
def define(name, version, &block)
face = Puppet::Interface::FaceCollection[name, version]
if face.nil? then
face = self.new(name, version)
Puppet::Interface::FaceCollection.register(face)
# REVISIT: Shouldn't this be delayed until *after* we evaluate the
# current block, not done before? --daniel 2011-04-07
face.load_actions
end
face.instance_eval(&block) if block_given?
return face
end
# Retrieves a face by name and version. Use `:current` for the
# version to get the most recent available version.
#
# @param name [Symbol] the name of the face
# @param version [String, :current] the version of the face
#
# @return [Puppet::Interface] the face
#
# @api public
def face?(name, version)
Puppet::Interface::FaceCollection[name, version]
end
# Retrieves a face by name and version
#
# @param name [Symbol] the name of the face
# @param version [String] the version of the face
#
# @return [Puppet::Interface] the face
#
# @api public
def [](name, version)
unless face = Puppet::Interface::FaceCollection[name, version]
# REVISIT (#18042) no sense in rechecking if version == :current -- josh
if Puppet::Interface::FaceCollection[name, :current]
raise Puppet::Error, "Could not find version #{version} of #{name}"
else
raise Puppet::Error, "Could not find Puppet Face #{name.to_s}"
end
end
face
end
# Retrieves an action for a face
# @param name [Symbol] The face
# @param action [Symbol] The action name
# @param version [String, :current] The version of the face
# @return [Puppet::Interface::Action] The action
def find_action(name, action, version = :current)
Puppet::Interface::FaceCollection.get_action_for_face(name, action, version)
end
end
########################################################################
# Documentation. We currently have to rewrite both getters because we share
# the same instance between build-time and the runtime instance. When that
# splits out this should merge into a module that both the action and face
# include. --daniel 2011-04-17
# Returns the synopsis for the face. This shows basic usage and global
# options.
# @return [String] usage synopsis
# @api private
def synopsis
build_synopsis self.name, ''
end
########################################################################
# The name of the face
# @return [Symbol]
# @api private
attr_reader :name
# The version of the face
# @return [SemVer]
attr_reader :version
# The autoloader instance for the face
# @return [Puppet::Util::Autoload]
# @api private
attr_reader :loader
private :loader
# @api private
def initialize(name, version, &block)
unless SemVer.valid?(version)
raise ArgumentError, "Cannot create face #{name.inspect} with invalid version number '#{version}'!"
end
@name = Puppet::Interface::FaceCollection.underscorize(name)
@version = SemVer.new(version)
# The few bits of documentation we actually demand. The default license
# is a favour to our end users; if you happen to get that in a core face
# report it as a bug, please. --daniel 2011-04-26
@authors = []
@license = 'All Rights Reserved'
@loader = Puppet::Util::Autoload.new(@name, "puppet/face/#{@name}")
instance_eval(&block) if block_given?
end
# Loads all actions defined in other files.
#
# @return [void]
# @api private
def load_actions
loader.loadall
end
# Returns a string representation with the face's name and version
# @return [String]
def to_s
"Puppet::Face[#{name.inspect}, #{version.inspect}]"
end
########################################################################
# Action decoration, whee! You are not expected to care about this code,
# which exists to support face building and construction. I marked these
# private because the implementation is crude and ugly, and I don't yet know
# enough to work out how to make it clean.
#
# Once we have established that these methods will likely change radically,
# to be unrecognizable in the final outcome. At which point we will throw
# all this away, replace it with something nice, and work out if we should
# be making this visible to the outside world... --daniel 2011-04-14
private
# @return [void]
# @api private
def __invoke_decorations(type, action, passed_args = [], passed_options = {})
[:before, :after].member?(type) or fail "unknown decoration type #{type}"
# Collect the decoration methods matching our pass.
methods = action.options.select do |name|
passed_options.has_key? name
end.map do |name|
action.get_option(name).__decoration_name(type)
end
methods.reverse! if type == :after
# Exceptions here should propagate up; this implements a hook we can use
# reasonably for option validation.
methods.each do |hook|
respond_to? hook and self.__send__(hook, action, passed_args, passed_options)
end
end
# @return [void]
# @api private
def __add_method(name, proc)
meta_def(name, &proc)
method(name).unbind
end
# @return [void]
# @api private
def self.__add_method(name, proc)
define_method(name, proc)
instance_method(name)
end
end
puppet-3.4.3/lib/puppet/confine/ 0000755 0052762 0001160 00000000000 12300765640 016435 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/confine/true.rb 0000644 0052762 0001160 00000000624 12300765631 017743 0 ustar jenkins jenkins require 'puppet/confine'
class Puppet::Confine::True < Puppet::Confine
def self.summarize(confines)
confines.inject(0) { |count, confine| count + confine.summary }
end
def pass?(value)
# Double negate, so we only get true or false.
! ! value
end
def message(value)
"false value when expecting true"
end
def summary
result.find_all { |v| v == true }.length
end
end
puppet-3.4.3/lib/puppet/confine/exists.rb 0000644 0052762 0001160 00000000731 12300765631 020302 0 ustar jenkins jenkins require 'puppet/confine'
class Puppet::Confine::Exists < Puppet::Confine
def self.summarize(confines)
confines.inject([]) { |total, confine| total + confine.summary }
end
def pass?(value)
value && (for_binary? ? which(value) : Puppet::FileSystem::File.exist?(value))
end
def message(value)
"file #{value} does not exist"
end
def summary
result.zip(values).inject([]) { |array, args| val, f = args; array << f unless val; array }
end
end
puppet-3.4.3/lib/puppet/confine/false.rb 0000644 0052762 0001160 00000000541 12300765631 020054 0 ustar jenkins jenkins require 'puppet/confine'
class Puppet::Confine::False < Puppet::Confine
def self.summarize(confines)
confines.inject(0) { |count, confine| count + confine.summary }
end
def pass?(value)
! value
end
def message(value)
"true value when expecting false"
end
def summary
result.find_all { |v| v == false }.length
end
end
puppet-3.4.3/lib/puppet/confine/variable.rb 0000644 0052762 0001160 00000003156 12300765631 020554 0 ustar jenkins jenkins require 'puppet/confine'
# Require a specific value for a variable, either a Puppet setting
# or a Facter value. This class is a bit weird because the name
# is set explicitly by the ConfineCollection class -- from this class,
# it's not obvious how the name would ever get set.
class Puppet::Confine::Variable < Puppet::Confine
# Provide a hash summary of failing confines -- the key of the hash
# is the name of the confine, and the value is the missing yet required values.
# Only returns failed values, not all required values.
def self.summarize(confines)
result = Hash.new { |hash, key| hash[key] = [] }
confines.inject(result) { |total, confine| total[confine.name] += confine.values unless confine.valid?; total }
end
# This is set by ConfineCollection.
attr_accessor :name
# Retrieve the value from facter
def facter_value
@facter_value ||= ::Facter.value(name).to_s.downcase
end
def initialize(values)
super
@values = @values.collect { |v| v.to_s.downcase }
end
def message(value)
"facter value '#{test_value}' for '#{self.name}' not in required list '#{values.join(",")}'"
end
# Compare the passed-in value to the retrieved value.
def pass?(value)
test_value.downcase.to_s == value.to_s.downcase
end
def reset
# Reset the cache. We want to cache it during a given
# run, but not across runs.
@facter_value = nil
end
def valid?
@values.include?(test_value.to_s.downcase)
ensure
reset
end
private
def setting?
Puppet.settings.valid?(name)
end
def test_value
setting? ? Puppet.settings[name] : facter_value
end
end
puppet-3.4.3/lib/puppet/confine/feature.rb 0000644 0052762 0001160 00000000577 12300765631 020426 0 ustar jenkins jenkins require 'puppet/confine'
class Puppet::Confine::Feature < Puppet::Confine
def self.summarize(confines)
confines.collect { |c| c.values }.flatten.uniq.find_all { |value| ! confines[0].pass?(value) }
end
# Is the named feature available?
def pass?(value)
Puppet.features.send(value.to_s + "?")
end
def message(value)
"feature #{value} is missing"
end
end
puppet-3.4.3/lib/puppet/module.rb 0000644 0052762 0001160 00000022412 12300765631 016627 0 ustar jenkins jenkins require 'puppet/util/logging'
require 'semver'
require 'puppet/module_tool/applications'
# Support for modules
class Puppet::Module
class Error < Puppet::Error; end
class MissingModule < Error; end
class IncompatibleModule < Error; end
class UnsupportedPlatform < Error; end
class IncompatiblePlatform < Error; end
class MissingMetadata < Error; end
class InvalidName < Error; end
class InvalidFilePattern < Error; end
include Puppet::Util::Logging
FILETYPES = {
"manifests" => "manifests",
"files" => "files",
"templates" => "templates",
"plugins" => "lib",
"pluginfacts" => "facts.d",
}
# Find and return the +module+ that +path+ belongs to. If +path+ is
# absolute, or if there is no module whose name is the first component
# of +path+, return +nil+
def self.find(modname, environment = nil)
return nil unless modname
Puppet::Node::Environment.new(environment).module(modname)
end
attr_reader :name, :environment, :path
attr_writer :environment
attr_accessor :dependencies, :forge_name
attr_accessor :source, :author, :version, :license, :puppetversion, :summary, :description, :project_page
def initialize(name, path, environment)
@name = name
@path = path
@environment = environment
assert_validity
load_metadata if has_metadata?
validate_puppet_version
@absolute_path_to_manifests = Puppet::FileSystem::PathPattern.absolute(manifests)
end
def has_metadata?
return false unless metadata_file
return false unless Puppet::FileSystem::File.exist?(metadata_file)
begin
metadata = PSON.parse(File.read(metadata_file))
rescue PSON::PSONError => e
Puppet.debug("#{name} has an invalid and unparsable metadata.json file. The parse error: #{e.message}")
return false
end
return metadata.is_a?(Hash) && !metadata.keys.empty?
end
FILETYPES.each do |type, location|
# A boolean method to let external callers determine if
# we have files of a given type.
define_method(type +'?') do
type_subpath = subpath(location)
unless Puppet::FileSystem::File.exist?(type_subpath)
Puppet.debug("No #{type} found in subpath '#{type_subpath}' " +
"(file / directory does not exist)")
return false
end
return true
end
# A method for returning a given file of a given type.
# e.g., file = mod.manifest("my/manifest.pp")
#
# If the file name is nil, then the base directory for the
# file type is passed; this is used for fileserving.
define_method(type.sub(/s$/, '')) do |file|
# If 'file' is nil then they're asking for the base path.
# This is used for things like fileserving.
if file
full_path = File.join(subpath(location), file)
else
full_path = subpath(location)
end
return nil unless Puppet::FileSystem::File.exist?(full_path)
return full_path
end
# Return the base directory for the given type
define_method(type) do
subpath(location)
end
end
def license_file
return @license_file if defined?(@license_file)
return @license_file = nil unless path
@license_file = File.join(path, "License")
end
def load_metadata
data = PSON.parse File.read(metadata_file)
@forge_name = data['name'].gsub('-', '/') if data['name']
[:source, :author, :version, :license, :puppetversion, :dependencies].each do |attr|
unless value = data[attr.to_s]
unless attr == :puppetversion
raise MissingMetadata, "No #{attr} module metadata provided for #{self.name}"
end
end
# NOTICE: The fallback to `versionRequirement` is something we'd like to
# not have to support, but we have a reasonable number of releases that
# don't use `version_requirement`. When we can deprecate this, we should.
if attr == :dependencies
value.tap do |dependencies|
dependencies.each do |dep|
dep['version_requirement'] ||= dep['versionRequirement'] || '>= 0.0.0'
end
end
end
send(attr.to_s + "=", value)
end
end
# Return the list of manifests matching the given glob pattern,
# defaulting to 'init.{pp,rb}' for empty modules.
def match_manifests(rest)
if rest
wanted_manifests = wanted_manifests_from(rest)
searched_manifests = wanted_manifests.glob.reject { |f| FileTest.directory?(f) }
else
searched_manifests = []
end
# (#4220) Always ensure init.pp in case class is defined there.
init_manifests = [manifest("init.pp"), manifest("init.rb")].compact
init_manifests + searched_manifests
end
def all_manifests
return [] unless Puppet::FileSystem::File.exist?(manifests)
Dir.glob(File.join(manifests, '**', '*.{rb,pp}'))
end
def metadata_file
return @metadata_file if defined?(@metadata_file)
return @metadata_file = nil unless path
@metadata_file = File.join(path, "metadata.json")
end
def modulepath
File.dirname(path) if path
end
# Find all plugin directories. This is used by the Plugins fileserving mount.
def plugin_directory
subpath("lib")
end
def plugin_fact_directory
subpath("facts.d")
end
def has_external_facts?
File.directory?(plugin_fact_directory)
end
def supports(name, version = nil)
@supports ||= []
@supports << [name, version]
end
def to_s
result = "Module #{name}"
result += "(#{path})" if path
result
end
def dependencies_as_modules
dependent_modules = []
dependencies and dependencies.each do |dep|
author, dep_name = dep["name"].split('/')
found_module = environment.module(dep_name)
dependent_modules << found_module if found_module
end
dependent_modules
end
def required_by
environment.module_requirements[self.forge_name] || {}
end
def has_local_changes?
changes = Puppet::ModuleTool::Applications::Checksummer.run(path)
!changes.empty?
end
def local_changes
Puppet::ModuleTool::Applications::Checksummer.run(path)
end
# Identify and mark unmet dependencies. A dependency will be marked unmet
# for the following reasons:
#
# * not installed and is thus considered missing
# * installed and does not meet the version requirements for this module
# * installed and doesn't use semantic versioning
#
# Returns a list of hashes representing the details of an unmet dependency.
#
# Example:
#
# [
# {
# :reason => :missing,
# :name => 'puppetlabs-mysql',
# :version_constraint => 'v0.0.1',
# :mod_details => {
# :installed_version => '0.0.1'
# }
# :parent => {
# :name => 'puppetlabs-bacula',
# :version => 'v1.0.0'
# }
# }
# ]
#
def unmet_dependencies
unmet_dependencies = []
return unmet_dependencies unless dependencies
dependencies.each do |dependency|
forge_name = dependency['name']
version_string = dependency['version_requirement'] || '>= 0.0.0'
dep_mod = begin
environment.module_by_forge_name(forge_name)
rescue
nil
end
error_details = {
:name => forge_name,
:version_constraint => version_string.gsub(/^(?=\d)/, "v"),
:parent => {
:name => self.forge_name,
:version => self.version.gsub(/^(?=\d)/, "v")
},
:mod_details => {
:installed_version => dep_mod.nil? ? nil : dep_mod.version
}
}
unless dep_mod
error_details[:reason] = :missing
unmet_dependencies << error_details
next
end
if version_string
begin
required_version_semver_range = SemVer[version_string]
actual_version_semver = SemVer.new(dep_mod.version)
rescue ArgumentError
error_details[:reason] = :non_semantic_version
unmet_dependencies << error_details
next
end
unless required_version_semver_range.include? actual_version_semver
error_details[:reason] = :version_mismatch
unmet_dependencies << error_details
next
end
end
end
unmet_dependencies
end
def validate_puppet_version
return unless puppetversion and puppetversion != Puppet.version
raise IncompatibleModule, "Module #{self.name} is only compatible with Puppet version #{puppetversion}, not #{Puppet.version}"
end
private
def wanted_manifests_from(pattern)
begin
extended = File.extname(pattern).empty? ? "#{pattern}.{pp,rb}" : pattern
relative_pattern = Puppet::FileSystem::PathPattern.relative(extended)
rescue Puppet::FileSystem::PathPattern::InvalidPattern => error
raise Puppet::Module::InvalidFilePattern.new(
"The pattern \"#{pattern}\" to find manifests in the module \"#{name}\" " +
"is invalid and potentially unsafe.", error)
end
relative_pattern.prefix_with(@absolute_path_to_manifests)
end
def subpath(type)
File.join(path, type)
end
def assert_validity
raise InvalidName, "Invalid module name #{name}; module names must be alphanumeric (plus '-'), not '#{name}'" unless name =~ /^[-\w]+$/
end
def ==(other)
self.name == other.name &&
self.version == other.version &&
self.path == other.path &&
self.environment == other.environment
end
end
puppet-3.4.3/lib/puppet/scheduler/ 0000755 0052762 0001160 00000000000 12300765640 016772 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/scheduler/timer.rb 0000644 0052762 0001160 00000000255 12300765631 020441 0 ustar jenkins jenkins module Puppet::Scheduler
class Timer
def wait_for(seconds)
if seconds > 0
sleep(seconds)
end
end
def now
Time.now
end
end
end
puppet-3.4.3/lib/puppet/scheduler/job.rb 0000644 0052762 0001160 00000001560 12300765631 020073 0 ustar jenkins jenkins module Puppet::Scheduler
class Job
attr_reader :run_interval
attr_accessor :last_run
attr_accessor :start_time
def initialize(run_interval, &block)
self.run_interval = run_interval
@last_run = nil
@run_proc = block
@enabled = true
end
def run_interval=(interval)
@run_interval = [interval, 0].max
end
def ready?(time)
if @last_run
@last_run + @run_interval <= time
else
true
end
end
def enabled?
@enabled
end
def enable
@enabled = true
end
def disable
@enabled = false
end
def interval_to_next_from(time)
if ready?(time)
0
else
@run_interval - (time - @last_run)
end
end
def run(now)
@last_run = now
if @run_proc
@run_proc.call(self)
end
end
end
end
puppet-3.4.3/lib/puppet/scheduler/scheduler.rb 0000644 0052762 0001160 00000002023 12300765631 021272 0 ustar jenkins jenkins module Puppet::Scheduler
class Scheduler
def initialize(timer=Puppet::Scheduler::Timer.new)
@timer = timer
end
def run_loop(jobs)
mark_start_times(jobs, @timer.now)
while not enabled(jobs).empty?
@timer.wait_for(min_interval_to_next_run_from(jobs, @timer.now))
run_ready(jobs, @timer.now)
end
end
private
def enabled(jobs)
jobs.select(&:enabled?)
end
def mark_start_times(jobs, start_time)
jobs.each do |job|
job.start_time = start_time
end
end
def min_interval_to_next_run_from(jobs, from_time)
enabled(jobs).map do |j|
j.interval_to_next_from(from_time)
end.min
end
def run_ready(jobs, at_time)
enabled(jobs).each do |j|
# This check intentionally happens right before each run,
# instead of filtering on ready schedulers, since one may adjust
# the readiness of a later one
if j.ready?(at_time)
j.run(at_time)
end
end
end
end
end
puppet-3.4.3/lib/puppet/scheduler/splay_job.rb 0000644 0052762 0001160 00000001045 12300765631 021301 0 ustar jenkins jenkins module Puppet::Scheduler
class SplayJob < Job
attr_reader :splay
def initialize(run_interval, splay_limit, &block)
@splay = calculate_splay(splay_limit)
super(run_interval, &block)
end
def interval_to_next_from(time)
if last_run
super
else
(start_time + splay) - time
end
end
def ready?(time)
if last_run
super
else
start_time + splay <= time
end
end
private
def calculate_splay(limit)
rand(limit + 1)
end
end
end
puppet-3.4.3/lib/puppet/type.rb 0000644 0052762 0001160 00000267711 12300765631 016340 0 ustar jenkins jenkins require 'puppet'
require 'puppet/util/log'
require 'puppet/util/metric'
require 'puppet/property'
require 'puppet/parameter'
require 'puppet/util'
require 'puppet/util/autoload'
require 'puppet/metatype/manager'
require 'puppet/util/errors'
require 'puppet/util/logging'
require 'puppet/util/tagging'
# see the bottom of the file for the rest of the inclusions
module Puppet
# The base class for all Puppet types.
#
# A type describes:
#--
# * **Attributes** - properties, parameters, and meta-parameters are different types of attributes of a type.
# * **Properties** - these are the properties of the managed resource (attributes of the entity being managed; like
# a file's owner, group and mode). A property describes two states; the 'is' (current state) and the 'should' (wanted
# state).
# * **Ensurable** - a set of traits that control the lifecycle (create, remove, etc.) of a managed entity.
# There is a default set of operations associated with being _ensurable_, but this can be changed.
# * **Name/Identity** - one property is the name/identity of a resource, the _namevar_ that uniquely identifies
# one instance of a type from all others.
# * **Parameters** - additional attributes of the type (that does not directly related to an instance of the managed
# resource; if an operation is recursive or not, where to look for things, etc.). A Parameter (in contrast to Property)
# has one current value where a Property has two (current-state and wanted-state).
# * **Meta-Parameters** - parameters that are available across all types. A meta-parameter typically has
# additional semantics; like the `require` meta-parameter. A new type typically does not add new meta-parameters,
# but you need to be aware of their existence so you do not inadvertently shadow an existing meta-parameters.
# * **Parent** - a type can have a super type (that it inherits from).
# * **Validation** - If not just a basic data type, or an enumeration of symbolic values, it is possible to provide
# validation logic for a type, properties and parameters.
# * **Munging** - munging/unmunging is the process of turning a value in external representation (as used
# by a provider) into an internal representation and vice versa. A Type supports adding custom logic for these.
# * **Auto Requirements** - a type can specify automatic relationships to resources to ensure that if they are being
# managed, they will be processed before this type.
# * **Providers** - a provider is an implementation of a type's behavior - the management of a resource in the
# system being managed. A provider is often platform specific and is selected at runtime based on
# criteria/predicates specified in the configured providers. See {Puppet::Provider} for details.
# * **Device Support** - A type has some support for being applied to a device; i.e. something that is managed
# by running logic external to the device itself. There are several methods that deals with type
# applicability for these special cases such as {apply_to_device}.
#
# Additional Concepts:
# --
# * **Resource-type** - A _resource type_ is a term used to denote the type of a resource; internally a resource
# is really an instance of a Ruby class i.e. {Puppet::Resource} which defines its behavior as "resource data".
# Conceptually however, a resource is an instance of a subclass of Type (e.g. File), where such a class describes
# its interface (what can be said/what is known about a resource of this type),
# * **Managed Entity** - This is not a term in general use, but is used here when there is a need to make
# a distinction between a resource (a description of what/how something should be managed), and what it is
# managing (a file in the file system). The term _managed entity_ is a reference to the "file in the file system"
# * **Isomorphism** - the quality of being _isomorphic_ means that two resource instances with the same name
# refers to the same managed entity. Or put differently; _an isomorphic name is the identity of a resource_.
# As an example, `exec` resources (that executes some command) have the command (i.e. the command line string) as
# their name, and these resources are said to be non-isomorphic.
#
# @note The Type class deals with multiple concerns; some methods provide an internal DSL for convenient definition
# of types, other methods deal with various aspects while running; wiring up a resource (expressed in Puppet DSL
# or Ruby DSL) with its _resource type_ (i.e. an instance of Type) to enable validation, transformation of values
# (munge/unmunge), etc. Lastly, Type is also responsible for dealing with Providers; the concrete implementations
# of the behavior that constitutes how a particular Type behaves on a particular type of system (e.g. how
# commands are executed on a flavor of Linux, on Windows, etc.). This means that as you are reading through the
# documentation of this class, you will be switching between these concepts, as well as switching between
# the conceptual level "a resource is an instance of a resource-type" and the actual implementation classes
# (Type, Resource, Provider, and various utility and helper classes).
#
# @api public
#
#
class Type
include Puppet::Util
include Puppet::Util::Errors
include Puppet::Util::Logging
include Puppet::Util::Tagging
# Comparing type instances.
include Comparable
# Compares this type against the given _other_ (type) and returns -1, 0, or +1 depending on the order.
# @param other [Object] the object to compare against (produces nil, if not kind of Type}
# @return [-1, 0, +1, nil] produces -1 if this type is before the given _other_ type, 0 if equals, and 1 if after.
# Returns nil, if the given _other_ is not a kind of Type.
# @see Comparable
#
def <=>(other)
# We only order against other types, not arbitrary objects.
return nil unless other.is_a? Puppet::Type
# Our natural order is based on the reference name we use when comparing
# against other type instances.
self.ref <=> other.ref
end
# Code related to resource type attributes.
class << self
include Puppet::Util::ClassGen
include Puppet::Util::Warnings
# @return [Array] The list of declared properties for the resource type.
# The returned lists contains instances if Puppet::Property or its subclasses.
attr_reader :properties
end
# Returns all the attribute names of the type in the appropriate order.
# The {key_attributes} come first, then the {provider}, then the {properties}, and finally
# the {parameters} and {metaparams},
# all in the order they were specified in the respective files.
# @return [Array] all type attribute names in a defined order.
#
def self.allattrs
key_attributes | (parameters & [:provider]) | properties.collect { |property| property.name } | parameters | metaparams
end
# Returns the class associated with the given attribute name.
# @param name [String] the name of the attribute to obtain the class for
# @return [Class, nil] the class for the given attribute, or nil if the name does not refer to an existing attribute
#
def self.attrclass(name)
@attrclasses ||= {}
# We cache the value, since this method gets called such a huge number
# of times (as in, hundreds of thousands in a given run).
unless @attrclasses.include?(name)
@attrclasses[name] = case self.attrtype(name)
when :property; @validproperties[name]
when :meta; @@metaparamhash[name]
when :param; @paramhash[name]
end
end
@attrclasses[name]
end
# Returns the attribute type (`:property`, `;param`, `:meta`).
# @comment What type of parameter are we dealing with? Cache the results, because
# this method gets called so many times.
# @return [Symbol] a symbol describing the type of attribute (`:property`, `;param`, `:meta`)
#
def self.attrtype(attr)
@attrtypes ||= {}
unless @attrtypes.include?(attr)
@attrtypes[attr] = case
when @validproperties.include?(attr); :property
when @paramhash.include?(attr); :param
when @@metaparamhash.include?(attr); :meta
end
end
@attrtypes[attr]
end
# Provides iteration over meta-parameters.
# @yieldparam p [Puppet::Parameter] each meta parameter
# @return [void]
#
def self.eachmetaparam
@@metaparams.each { |p| yield p.name }
end
# Creates a new `ensure` property with configured default values or with configuration by an optional block.
# This method is a convenience method for creating a property `ensure` with default accepted values.
# If no block is specified, the new `ensure` property will accept the default symbolic
# values `:present`, and `:absent` - see {Puppet::Property::Ensure}.
# If something else is wanted, pass a block and make calls to {Puppet::Property.newvalue} from this block
# to define each possible value. If a block is passed, the defaults are not automatically added to the set of
# valid values.
#
# @note This method will be automatically called without a block if the type implements the methods
# specified by {ensurable?}. It is recommended to always call this method and not rely on this automatic
# specification to clearly state that the type is ensurable.
#
# @overload ensurable()
# @overload ensurable({|| ... })
# @yield [ ] A block evaluated in scope of the new Parameter
# @yieldreturn [void]
# @return [void]
# @dsl type
# @api public
#
def self.ensurable(&block)
if block_given?
self.newproperty(:ensure, :parent => Puppet::Property::Ensure, &block)
else
self.newproperty(:ensure, :parent => Puppet::Property::Ensure) do
self.defaultvalues
end
end
end
# Returns true if the type implements the default behavior expected by being _ensurable_ "by default".
# A type is _ensurable_ by default if it responds to `:exists`, `:create`, and `:destroy`.
# If a type implements these methods and have not already specified that it is _ensurable_, it will be
# made so with the defaults specified in {ensurable}.
# @return [Boolean] whether the type is _ensurable_ or not.
#
def self.ensurable?
# If the class has all three of these methods defined, then it's
# ensurable.
[:exists?, :create, :destroy].all? { |method|
self.public_method_defined?(method)
}
end
# @comment These `apply_to` methods are horrible. They should really be implemented
# as part of the usual system of constraints that apply to a type and
# provider pair, but were implemented as a separate shadow system.
#
# @comment We should rip them out in favour of a real constraint pattern around the
# target device - whatever that looks like - and not have this additional
# magic here. --daniel 2012-03-08
#
# Makes this type applicable to `:device`.
# @return [Symbol] Returns `:device`
# @api private
#
def self.apply_to_device
@apply_to = :device
end
# Makes this type applicable to `:host`.
# @return [Symbol] Returns `:host`
# @api private
#
def self.apply_to_host
@apply_to = :host
end
# Makes this type applicable to `:both` (i.e. `:host` and `:device`).
# @return [Symbol] Returns `:both`
# @api private
#
def self.apply_to_all
@apply_to = :both
end
# Makes this type apply to `:host` if not already applied to something else.
# @return [Symbol] a `:device`, `:host`, or `:both` enumeration
# @api private
def self.apply_to
@apply_to ||= :host
end
# Returns true if this type is applicable to the given target.
# @param target [Symbol] should be :device, :host or :target, if anything else, :host is enforced
# @return [Boolean] true
# @api private
#
def self.can_apply_to(target)
[ target == :device ? :device : :host, :both ].include?(apply_to)
end
# Processes the options for a named parameter.
# @param name [String] the name of a parameter
# @param options [Hash] a hash of options
# @option options [Boolean] :boolean if option set to true, an access method on the form _name_? is added for the param
# @return [void]
#
def self.handle_param_options(name, options)
# If it's a boolean parameter, create a method to test the value easily
if options[:boolean]
define_method(name.to_s + "?") do
val = self[name]
if val == :true or val == true
return true
end
end
end
end
# Is the given parameter a meta-parameter?
# @return [Boolean] true if the given parameter is a meta-parameter.
#
def self.metaparam?(param)
@@metaparamhash.include?(param.intern)
end
# Returns the meta-parameter class associated with the given meta-parameter name.
# Accepts a `nil` name, and return nil.
# @param name [String, nil] the name of a meta-parameter
# @return [Class,nil] the class for the given meta-parameter, or `nil` if no such meta-parameter exists, (or if
# the given meta-parameter name is `nil`.
#
def self.metaparamclass(name)
return nil if name.nil?
@@metaparamhash[name.intern]
end
# Returns all meta-parameter names.
# @return [Array] all meta-parameter names
#
def self.metaparams
@@metaparams.collect { |param| param.name }
end
# Returns the documentation for a given meta-parameter of this type.
# @todo the type for the param metaparam
# @param metaparam [??? Puppet::Parameter] the meta-parameter to get documentation for.
# @return [String] the documentation associated with the given meta-parameter, or nil of not such documentation
# exists.
# @raise if the given metaparam is not a meta-parameter in this type
#
def self.metaparamdoc(metaparam)
@@metaparamhash[metaparam].doc
end
# Creates a new meta-parameter.
# This creates a new meta-parameter that is added to all types.
# @param name [Symbol] the name of the parameter
# @param options [Hash] a hash with options.
# @option options [Class] :parent (Puppet::Parameter) the super class of this parameter
# @option options [Hash{String => Object}] :attributes a hash that is applied to the generated class
# by calling setter methods corresponding to this hash's keys/value pairs. This is done before the given
# block is evaluated.
# @option options [Boolean] :boolean (false) specifies if this is a boolean parameter
# @option options [Boolean] :namevar (false) specifies if this parameter is the namevar
# @option options [Symbol, Array] :required_features specifies required provider features by name
# @return [Class] the created parameter
# @yield [ ] a required block that is evaluated in the scope of the new meta-parameter
# @api public
# @dsl type
# @todo Verify that this description is ok
#
def self.newmetaparam(name, options = {}, &block)
@@metaparams ||= []
@@metaparamhash ||= {}
name = name.intern
param = genclass(
name,
:parent => options[:parent] || Puppet::Parameter,
:prefix => "MetaParam",
:hash => @@metaparamhash,
:array => @@metaparams,
:attributes => options[:attributes],
&block
)
# Grr.
param.required_features = options[:required_features] if options[:required_features]
handle_param_options(name, options)
param.metaparam = true
param
end
# Returns parameters that act as a key.
# All parameters that return true from #isnamevar? or is named `:name` are included in the returned result.
# @todo would like a better explanation
# @return [Array] WARNING: this return type is uncertain
def self.key_attribute_parameters
@key_attribute_parameters ||= (
@parameters.find_all { |param|
param.isnamevar? or param.name == :name
}
)
end
# Returns cached {key_attribute_parameters} names
# @todo what is a 'key_attribute' ?
# @return [Array] cached key_attribute names
#
def self.key_attributes
# This is a cache miss around 0.05 percent of the time. --daniel 2012-07-17
@key_attributes_cache ||= key_attribute_parameters.collect { |p| p.name }
end
# Returns a mapping from the title string to setting of attribute value(s).
# This default implementation provides a mapping of title to the one and only _namevar_ present
# in the type's definition.
# @note Advanced: some logic requires this mapping to be done differently, using a different
# validation/pattern, breaking up the title
# into several parts assigning each to an individual attribute, or even use a composite identity where
# all namevars are seen as part of the unique identity (such computation is done by the {#uniqueness} method.
# These advanced options are rarely used (only one of the built in puppet types use this, and then only
# a small part of the available functionality), and the support for these advanced mappings is not
# implemented in a straight forward way. For these reasons, this method has been marked as private).
#
# @raise [Puppet::DevError] if there is no title pattern and there are two or more key attributes
# @return [Array>>>, nil] a structure with a regexp and the first key_attribute ???
# @comment This wonderful piece of logic creates a structure used by Resource.parse_title which
# has the capability to assign parts of the title to one or more attributes; It looks like an implementation
# of a composite identity key (all parts of the key_attributes array are in the key). This can also
# be seen in the method uniqueness_key.
# The implementation in this method simply assigns the title to the one and only namevar (which is name
# or a variable marked as namevar).
# If there are multiple namevars (any in addition to :name?) then this method MUST be implemented
# as it raises an exception if there is more than 1. Note that in puppet, it is only File that uses this
# to create a different pattern for assigning to the :path attribute
# This requires further digging.
# The entire construct is somewhat strange, since resource checks if the method "title_patterns" is
# implemented (it seems it always is) - why take this more expensive regexp mathching route for all
# other types?
# @api private
#
def self.title_patterns
case key_attributes.length
when 0; []
when 1;
[ [ /(.*)/m, [ [key_attributes.first] ] ] ]
else
raise Puppet::DevError,"you must specify title patterns when there are two or more key attributes"
end
end
# Produces a _uniqueness_key_
# @todo Explain what a uniqueness_key is
# @return [Object] an object that is a _uniqueness_key_ for this object
#
def uniqueness_key
self.class.key_attributes.sort_by { |attribute_name| attribute_name.to_s }.map{ |attribute_name| self[attribute_name] }
end
# Creates a new parameter.
# @param name [Symbol] the name of the parameter
# @param options [Hash] a hash with options.
# @option options [Class] :parent (Puppet::Parameter) the super class of this parameter
# @option options [Hash{String => Object}] :attributes a hash that is applied to the generated class
# by calling setter methods corresponding to this hash's keys/value pairs. This is done before the given
# block is evaluated.
# @option options [Boolean] :boolean (false) specifies if this is a boolean parameter
# @option options [Boolean] :namevar (false) specifies if this parameter is the namevar
# @option options [Symbol, Array] :required_features specifies required provider features by name
# @return [Class] the created parameter
# @yield [ ] a required block that is evaluated in the scope of the new parameter
# @api public
# @dsl type
#
def self.newparam(name, options = {}, &block)
options[:attributes] ||= {}
param = genclass(
name,
:parent => options[:parent] || Puppet::Parameter,
:attributes => options[:attributes],
:block => block,
:prefix => "Parameter",
:array => @parameters,
:hash => @paramhash
)
handle_param_options(name, options)
# Grr.
param.required_features = options[:required_features] if options[:required_features]
param.isnamevar if options[:namevar]
param
end
# Creates a new property.
# @param name [Symbol] the name of the property
# @param options [Hash] a hash with options.
# @option options [Symbol] :array_matching (:first) specifies how the current state is matched against
# the wanted state. Use `:first` if the property is single valued, and (`:all`) otherwise.
# @option options [Class] :parent (Puppet::Property) the super class of this property
# @option options [Hash{String => Object}] :attributes a hash that is applied to the generated class
# by calling setter methods corresponding to this hash's keys/value pairs. This is done before the given
# block is evaluated.
# @option options [Boolean] :boolean (false) specifies if this is a boolean parameter
# @option options [Symbol] :retrieve the method to call on the provider (or `parent` if `provider` is not set)
# to retrieve the current value of this property.
# @option options [Symbol, Array] :required_features specifies required provider features by name
# @return [Class] the created property
# @yield [ ] a required block that is evaluated in the scope of the new property
# @api public
# @dsl type
#
def self.newproperty(name, options = {}, &block)
name = name.intern
# This is here for types that might still have the old method of defining
# a parent class.
unless options.is_a? Hash
raise Puppet::DevError,
"Options must be a hash, not #{options.inspect}"
end
raise Puppet::DevError, "Class #{self.name} already has a property named #{name}" if @validproperties.include?(name)
if parent = options[:parent]
options.delete(:parent)
else
parent = Puppet::Property
end
# We have to create our own, new block here because we want to define
# an initial :retrieve method, if told to, and then eval the passed
# block if available.
prop = genclass(name, :parent => parent, :hash => @validproperties, :attributes => options) do
# If they've passed a retrieve method, then override the retrieve
# method on the class.
if options[:retrieve]
define_method(:retrieve) do
provider.send(options[:retrieve])
end
end
class_eval(&block) if block
end
# If it's the 'ensure' property, always put it first.
if name == :ensure
@properties.unshift prop
else
@properties << prop
end
prop
end
def self.paramdoc(param)
@paramhash[param].doc
end
# @return [Array] Returns the parameter names
def self.parameters
return [] unless defined?(@parameters)
@parameters.collect { |klass| klass.name }
end
# @return [Puppet::Parameter] Returns the parameter class associated with the given parameter name.
def self.paramclass(name)
@paramhash[name]
end
# @return [Puppet::Property] Returns the property class ??? associated with the given property name
def self.propertybyname(name)
@validproperties[name]
end
# Returns whether or not the given name is the name of a property, parameter or meta-parameter
# @return [Boolean] true if the given attribute name is the name of an existing property, parameter or meta-parameter
#
def self.validattr?(name)
name = name.intern
return true if name == :name
@validattrs ||= {}
unless @validattrs.include?(name)
@validattrs[name] = !!(self.validproperty?(name) or self.validparameter?(name) or self.metaparam?(name))
end
@validattrs[name]
end
# @return [Boolean] Returns true if the given name is the name of an existing property
def self.validproperty?(name)
name = name.intern
@validproperties.include?(name) && @validproperties[name]
end
# @return [Array, {}] Returns a list of valid property names, or an empty hash if there are none.
# @todo An empty hash is returned if there are no defined parameters (not an empty array). This looks like
# a bug.
#
def self.validproperties
return {} unless defined?(@parameters)
@validproperties.keys
end
# @return [Boolean] Returns true if the given name is the name of an existing parameter
def self.validparameter?(name)
raise Puppet::DevError, "Class #{self} has not defined parameters" unless defined?(@parameters)
!!(@paramhash.include?(name) or @@metaparamhash.include?(name))
end
# (see validattr?)
# @note see comment in code - how should this be documented? Are some of the other query methods deprecated?
# (or should be).
# @comment This is a forward-compatibility method - it's the validity interface we'll use in Puppet::Resource.
def self.valid_parameter?(name)
validattr?(name)
end
# @return [Boolean] Returns true if the wanted state of the resoure is that it should be absent (i.e. to be deleted).
def deleting?
obj = @parameters[:ensure] and obj.should == :absent
end
# Creates a new property value holder for the resource if it is valid and does not already exist
# @return [Boolean] true if a new parameter was added, false otherwise
def add_property_parameter(prop_name)
if self.class.validproperty?(prop_name) && !@parameters[prop_name]
self.newattr(prop_name)
return true
end
false
end
# @return [Symbol, Boolean] Returns the name of the namevar if there is only one or false otherwise.
# @comment This is really convoluted and part of the support for multiple namevars (?).
# If there is only one namevar, the produced value is naturally this namevar, but if there are several?
# The logic caches the name of the namevar if it is a single name, but otherwise always
# calls key_attributes, and then caches the first if there was only one, otherwise it returns
# false and caches this (which is then subsequently returned as a cache hit).
#
def name_var
return @name_var_cache unless @name_var_cache.nil?
key_attributes = self.class.key_attributes
@name_var_cache = (key_attributes.length == 1) && key_attributes.first
end
# Gets the 'should' (wanted state) value of a parameter or property by name.
# To explicitly get the 'is' (current state) value use `o.is(:name)`, and to explicitly get the 'should' value
# use `o.should(:name)`
# @param name [String] the name of the attribute to obtain the 'should' value for.
# @return [Object] 'should'/wanted value of the given attribute
def [](name)
name = name.intern
fail("Invalid parameter #{name}(#{name.inspect})") unless self.class.validattr?(name)
if name == :name && nv = name_var
name = nv
end
if obj = @parameters[name]
# Note that if this is a property, then the value is the "should" value,
# not the current value.
obj.value
else
return nil
end
end
# Sets the 'should' (wanted state) value of a property, or the value of a parameter.
# @return
# @raise [Puppet::Error] if the setting of the value fails, or if the given name is nil.
# @raise [Puppet::ResourceError] when the parameter validation raises Puppet::Error or
# ArgumentError
def []=(name,value)
name = name.intern
fail("Invalid parameter #{name}") unless self.class.validattr?(name)
if name == :name && nv = name_var
name = nv
end
raise Puppet::Error.new("Got nil value for #{name}") if value.nil?
property = self.newattr(name)
if property
begin
# make sure the parameter doesn't have any errors
property.value = value
rescue Puppet::Error, ArgumentError => detail
error = Puppet::ResourceError.new("Parameter #{name} failed on #{ref}: #{detail}")
adderrorcontext(error, detail)
raise error
end
end
nil
end
# Removes a property from the object; useful in testing or in cleanup
# when an error has been encountered
# @todo Incomprehensible - the comment says "Remove a property", the code refers to @parameters, and
# the method parameter is called "attr" - What is it, property, parameter, both (i.e an attribute) or what?
# @todo Don't know what the attr is (name or Property/Parameter?). Guessing it is a String name...
# @todo Is it possible to delete a meta-parameter?
# @todo What does delete mean? Is it deleted from the type or is its value state 'is'/'should' deleted?
# @param attr [String] the attribute to delete from this object. WHAT IS THE TYPE?
# @raise [Puppet::DecError] when an attempt is made to delete an attribute that does not exists.
#
def delete(attr)
attr = attr.intern
if @parameters.has_key?(attr)
@parameters.delete(attr)
else
raise Puppet::DevError.new("Undefined attribute '#{attr}' in #{self}")
end
end
# Iterates over the existing properties.
# @todo what does this mean? As opposed to iterating over the "non existing properties" ??? Is it an
# iteration over those properties that have state? CONFUSING.
# @yieldparam property [Puppet::Property] each property
# @return [void]
def eachproperty
# properties is a private method
properties.each { |property|
yield property
}
end
# Return the parameters, metaparams, and properties that have a value or were set by a default. Properties are
# included since they are a subclass of parameter.
# @return [Array] Array of parameter objects ( or subclass thereof )
def parameters_with_value
self.class.allattrs.collect { |attr| parameter(attr) }.compact
end
# Iterates over all parameters with value currently set.
# @yieldparam parameter [Puppet::Parameter] or a subclass thereof
# @return [void]
def eachparameter
parameters_with_value.each { |parameter| yield parameter }
end
# Creates a transaction event.
# Called by Transaction or by a property.
# Merges the given options with the options `:resource`, `:file`, `:line`, and `:tags`, initialized from
# values in this object. For possible options to pass (if any ????) see {Puppet::Transaction::Event}.
# @todo Needs a better explanation "Why should I care who is calling this method?", What do I need to know
# about events and how they work? Where can I read about them?
# @param options [Hash] options merged with a fixed set of options defined by this method, passed on to {Puppet::Transaction::Event}.
# @return [Puppet::Transaction::Event] the created event
def event(options = {})
Puppet::Transaction::Event.new({:resource => self, :file => file, :line => line, :tags => tags}.merge(options))
end
# @return [Object, nil] Returns the 'should' (wanted state) value for a specified property, or nil if the
# given attribute name is not a property (i.e. if it is a parameter, meta-parameter, or does not exist).
def should(name)
name = name.intern
(prop = @parameters[name] and prop.is_a?(Puppet::Property)) ? prop.should : nil
end
# Creates an instance to represent/manage the given attribute.
# Requires either the attribute name or class as the first argument, then an optional hash of
# attributes to set during initialization.
# @todo The original comment is just wrong - the method does not accept a hash of options
# @todo Detective work required; this method interacts with provider to ask if it supports a parameter of
# the given class. it then returns the parameter if it exists, otherwise creates a parameter
# with its :resource => self.
# @overload newattr(name)
# @param name [String] Unclear what name is (probably a symbol) - Needs investigation.
# @overload newattr(klass)
# @param klass [Class] a class supported as an attribute class - Needs clarification what that means.
# @return [???] Probably returns a new instance of the class - Needs investigation.
#
def newattr(name)
if name.is_a?(Class)
klass = name
name = klass.name
end
unless klass = self.class.attrclass(name)
raise Puppet::Error, "Resource type #{self.class.name} does not support parameter #{name}"
end
if provider and ! provider.class.supports_parameter?(klass)
missing = klass.required_features.find_all { |f| ! provider.class.feature?(f) }
debug "Provider %s does not support features %s; not managing attribute %s" % [provider.class.name, missing.join(", "), name]
return nil
end
return @parameters[name] if @parameters.include?(name)
@parameters[name] = klass.new(:resource => self)
end
# Returns a string representation of the resource's containment path in
# the catalog.
# @return [String]
def path
@path ||= '/' + pathbuilder.join('/')
end
# Returns the value of this object's parameter given by name
# @param name [String] the name of the parameter
# @return [Object] the value
def parameter(name)
@parameters[name.to_sym]
end
# Returns a shallow copy of this object's hash of parameters.
# @todo Add that this is not only "parameters", but also "properties" and "meta-parameters" ?
# Changes to the contained parameters will have an effect on the parameters of this type, but changes to
# the returned hash does not.
# @return [Hash{String => Puppet:???Parameter}] a new hash being a shallow copy of the parameters map name to parameter
def parameters
@parameters.dup
end
# @return [Boolean] Returns whether the property given by name is defined or not.
# @todo what does it mean to be defined?
def propertydefined?(name)
name = name.intern unless name.is_a? Symbol
@parameters.include?(name)
end
# Returns a {Puppet::Property} instance by name.
# To return the value, use 'resource[param]'
# @todo LAK:NOTE(20081028) Since the 'parameter' method is now a superset of this method,
# this one should probably go away at some point. - Does this mean it should be deprecated ?
# @return [Puppet::Property] the property with the given name, or nil if not a property or does not exist.
def property(name)
(obj = @parameters[name.intern] and obj.is_a?(Puppet::Property)) ? obj : nil
end
# @todo comment says "For any parameters or properties that have defaults and have not yet been
# set, set them now. This method can be handed a list of attributes,
# and if so it will only set defaults for those attributes."
# @todo Needs a better explanation, and investigation about the claim an array can be passed (it is passed
# to self.class.attrclass to produce a class on which a check is made if it has a method class :default (does
# not seem to support an array...
# @return [void]
#
def set_default(attr)
return unless klass = self.class.attrclass(attr)
return unless klass.method_defined?(:default)
return if @parameters.include?(klass.name)
return unless parameter = newattr(klass.name)
if value = parameter.default and ! value.nil?
parameter.value = value
else
@parameters.delete(parameter.name)
end
end
# @todo the comment says: "Convert our object to a hash. This just includes properties."
# @todo this is confused, again it is the @parameters instance variable that is consulted, and
# each value is copied - does it contain "properties" and "parameters" or both? Does it contain
# meta-parameters?
#
# @return [Hash{ ??? => ??? }] a hash of WHAT?. The hash is a shallow copy, any changes to the
# objects returned in this hash will be reflected in the original resource having these attributes.
#
def to_hash
rethash = {}
@parameters.each do |name, obj|
rethash[name] = obj.value
end
rethash
end
# @return [String] the name of this object's class
# @todo Would that be "file" for the "File" resource type? of "File" or something else?
#
def type
self.class.name
end
# @todo Comment says "Return a specific value for an attribute.", as opposed to what "An upspecific value"???
# @todo is this the 'is' or the 'should' value?
# @todo why is the return restricted to things that respond to :value? (Only non structural basic data types
# supported?
#
# @return [Object, nil] the value of the attribute having the given name, or nil if the given name is not
# an attribute, or the referenced attribute does not respond to `:value`.
def value(name)
name = name.intern
(obj = @parameters[name] and obj.respond_to?(:value)) ? obj.value : nil
end
# @todo What is this used for? Needs a better explanation.
# @return [???] the version of the catalog or 0 if there is no catalog.
def version
return 0 unless catalog
catalog.version
end
# @return [Array] Returns all of the property objects, in the order specified in the
# class.
# @todo "what does the 'order specified in the class' mean? The order the properties where added in the
# ruby file adding a new type with new properties?
#
def properties
self.class.properties.collect { |prop| @parameters[prop.name] }.compact
end
# Returns true if the type's notion of name is the identity of a resource.
# See the overview of this class for a longer explanation of the concept _isomorphism_.
# Defaults to true.
#
# @return [Boolan] true, if this type's name is isomorphic with the object
def self.isomorphic?
if defined?(@isomorphic)
return @isomorphic
else
return true
end
end
# @todo check that this gets documentation (it is at the class level as well as instance).
# (see isomorphic?)
def isomorphic?
self.class.isomorphic?
end
# Returns true if the instance is a managed instance.
# A 'yes' here means that the instance was created from the language, vs. being created
# in order resolve other questions, such as finding a package in a list.
# @note An object that is managed always stays managed, but an object that is not managed
# may become managed later in its lifecycle.
# @return [Boolean] true if the object is managed
def managed?
# Once an object is managed, it always stays managed; but an object
# that is listed as unmanaged might become managed later in the process,
# so we have to check that every time
if @managed
return @managed
else
@managed = false
properties.each { |property|
s = property.should
if s and ! property.class.unmanaged
@managed = true
break
end
}
return @managed
end
end
###############################
# Code related to the container behaviour.
# Returns true if the search should be done in depth-first order.
# This implementation always returns false.
# @todo What is this used for?
#
# @return [Boolean] true if the search should be done in depth first order.
#
def depthfirst?
false
end
# Removes this object (FROM WHERE?)
# @todo removes if from where?
# @overload remove(rmdeps)
# @deprecated Use remove()
# @param rmdeps [Boolean] intended to indicate that all subscriptions should also be removed, ignored.
# @overload remove()
# @return [void]
#
def remove(rmdeps = true)
# This is hackish (mmm, cut and paste), but it works for now, and it's
# better than warnings.
@parameters.each do |name, obj|
obj.remove
end
@parameters.clear
@parent = nil
# Remove the reference to the provider.
if self.provider
@provider.clear
@provider = nil
end
end
###############################
# Code related to evaluating the resources.
# Returns the ancestors - WHAT?
# This implementation always returns an empty list.
# @todo WHAT IS THIS ?
# @return [Array] returns a list of ancestors.
def ancestors
[]
end
# Flushes the provider if supported by the provider, else no action.
# This is called by the transaction.
# @todo What does Flushing the provider mean? Why is it interesting to know that this is
# called by the transaction? (It is not explained anywhere what a transaction is).
#
# @return [???, nil] WHAT DOES IT RETURN? GUESS IS VOID
def flush
self.provider.flush if self.provider and self.provider.respond_to?(:flush)
end
# Returns true if all contained objects are in sync.
# @todo "contained in what?" in the given "in" parameter?
#
# @todo deal with the comment _"FIXME I don't think this is used on the type instances any more,
# it's really only used for testing"_
# @return [Boolean] true if in sync, false otherwise.
#
def insync?(is)
insync = true
if property = @parameters[:ensure]
unless is.include? property
raise Puppet::DevError,
"The is value is not in the is array for '#{property.name}'"
end
ensureis = is[property]
if property.safe_insync?(ensureis) and property.should == :absent
return true
end
end
properties.each { |property|
unless is.include? property
raise Puppet::DevError,
"The is value is not in the is array for '#{property.name}'"
end
propis = is[property]
unless property.safe_insync?(propis)
property.debug("Not in sync: #{propis.inspect} vs #{property.should.inspect}")
insync = false
#else
# property.debug("In sync")
end
}
#self.debug("#{self} sync status is #{insync}")
insync
end
# Retrieves the current value of all contained properties.
# Parameters and meta-parameters are not included in the result.
# @todo As oposed to all non contained properties? How is this different than any of the other
# methods that also "gets" properties/parameters/etc. ?
# @return [Puppet::Resource] array of all property values (mix of types)
# @raise [fail???] if there is a provider and it is not suitable for the host this is evaluated for.
def retrieve
fail "Provider #{provider.class.name} is not functional on this host" if self.provider.is_a?(Puppet::Provider) and ! provider.class.suitable?
result = Puppet::Resource.new(type, title)
# Provide the name, so we know we'll always refer to a real thing
result[:name] = self[:name] unless self[:name] == title
if ensure_prop = property(:ensure) or (self.class.validattr?(:ensure) and ensure_prop = newattr(:ensure))
result[:ensure] = ensure_state = ensure_prop.retrieve
else
ensure_state = nil
end
properties.each do |property|
next if property.name == :ensure
if ensure_state == :absent
result[property] = :absent
else
result[property] = property.retrieve
end
end
result
end
# Retrieve the current state of the system as a Puppet::Resource. For
# the base Puppet::Type this does the same thing as #retrieve, but
# specific types are free to implement #retrieve as returning a hash,
# and this will call #retrieve and convert the hash to a resource.
# This is used when determining when syncing a resource.
#
# @return [Puppet::Resource] A resource representing the current state
# of the system.
#
# @api private
def retrieve_resource
resource = retrieve
resource = Resource.new(type, title, :parameters => resource) if resource.is_a? Hash
resource
end
# Given the hash of current properties, should this resource be treated as if it
# currently exists on the system. May need to be overridden by types that offer up
# more than just :absent and :present.
def present?(current_values)
current_values[:ensure] != :absent
end
# Returns a hash of the current properties and their values.
# If a resource is absent, its value is the symbol `:absent`
# @return [Hash{Puppet::Property => Object}] mapping of property instance to its value
#
def currentpropvalues
# It's important to use the 'properties' method here, as it follows the order
# in which they're defined in the class. It also guarantees that 'ensure'
# is the first property, which is important for skipping 'retrieve' on
# all the properties if the resource is absent.
ensure_state = false
return properties.inject({}) do | prophash, property|
if property.name == :ensure
ensure_state = property.retrieve
prophash[property] = ensure_state
else
if ensure_state == :absent
prophash[property] = :absent
else
prophash[property] = property.retrieve
end
end
prophash
end
end
# Returns the `noop` run mode status of this.
# @return [Boolean] true if running in noop mode.
def noop?
# If we're not a host_config, we're almost certainly part of
# Settings, and we want to ignore 'noop'
return false if catalog and ! catalog.host_config?
if defined?(@noop)
@noop
else
Puppet[:noop]
end
end
# (see #noop?)
def noop
noop?
end
# Retrieves all known instances.
# @todo Retrieves them from where? Known to whom?
# Either requires providers or must be overridden.
# @raise [Puppet::DevError] when there are no providers and the implementation has not overridded this method.
def self.instances
raise Puppet::DevError, "#{self.name} has no providers and has not overridden 'instances'" if provider_hash.empty?
# Put the default provider first, then the rest of the suitable providers.
provider_instances = {}
providers_by_source.collect do |provider|
self.properties.find_all do |property|
provider.supports_parameter?(property)
end.collect do |property|
property.name
end
provider.instances.collect do |instance|
# We always want to use the "first" provider instance we find, unless the resource
# is already managed and has a different provider set
if other = provider_instances[instance.name]
Puppet.debug "%s %s found in both %s and %s; skipping the %s version" %
[self.name.to_s.capitalize, instance.name, other.class.name, instance.class.name, instance.class.name]
next
end
provider_instances[instance.name] = instance
result = new(:name => instance.name, :provider => instance)
properties.each { |name| result.newattr(name) }
result
end
end.flatten.compact
end
# Returns a list of one suitable provider per source, with the default provider first.
# @todo Needs better explanation; what does "source" mean in this context?
# @return [Array] list of providers
#
def self.providers_by_source
# Put the default provider first (can be nil), then the rest of the suitable providers.
sources = []
[defaultprovider, suitableprovider].flatten.uniq.collect do |provider|
next if provider.nil?
next if sources.include?(provider.source)
sources << provider.source
provider
end.compact
end
# Converts a simple hash into a Resource instance.
# @todo as opposed to a complex hash? Other raised exceptions?
# @param [Hash{Symbol, String => Object}] hash resource attribute to value map to initialize the created resource from
# @return [Puppet::Resource] the resource created from the hash
# @raise [Puppet::Error] if a title is missing in the given hash
def self.hash2resource(hash)
hash = hash.inject({}) { |result, ary| result[ary[0].to_sym] = ary[1]; result }
title = hash.delete(:title)
title ||= hash[:name]
title ||= hash[key_attributes.first] if key_attributes.length == 1
raise Puppet::Error, "Title or name must be provided" unless title
# Now create our resource.
resource = Puppet::Resource.new(self.name, title)
resource.catalog = hash.delete(:catalog)
hash.each do |param, value|
resource[param] = value
end
resource
end
# Returns an array of strings representing the containment heirarchy
# (types/classes) that make up the path to the resource from the root
# of the catalog. This is mostly used for logging purposes.
#
# @api private
def pathbuilder
if p = parent
[p.pathbuilder, self.ref].flatten
else
[self.ref]
end
end
###############################
# Add all of the meta-parameters.
newmetaparam(:noop) do
desc "Whether to apply this resource in noop mode.
When applying a resource in noop mode, Puppet will check whether it is in sync,
like it does when running normally. However, if a resource attribute is not in
the desired state (as declared in the catalog), Puppet will take no
action, and will instead report the changes it _would_ have made. These
simulated changes will appear in the report sent to the puppet master, or
be shown on the console if running puppet agent or puppet apply in the
foreground. The simulated changes will not send refresh events to any
subscribing or notified resources, although Puppet will log that a refresh
event _would_ have been sent.
**Important note:**
[The `noop` setting](http://docs.puppetlabs.com/references/latest/configuration.html#noop)
allows you to globally enable or disable noop mode, but it will _not_ override
the `noop` metaparameter on individual resources. That is, the value of the
global `noop` setting will _only_ affect resources that do not have an explicit
value set for their `noop` attribute."
newvalues(:true, :false)
munge do |value|
case value
when true, :true, "true"; @resource.noop = true
when false, :false, "false"; @resource.noop = false
end
end
end
newmetaparam(:schedule) do
desc "A schedule to govern when Puppet is allowed to manage this resource.
The value of this metaparameter must be the `name` of a `schedule`
resource. This means you must declare a schedule resource, then
refer to it by name; see
[the docs for the `schedule` type](http://docs.puppetlabs.com/references/latest/type.html#schedule)
for more info.
schedule { 'everyday':
period => daily,
range => \"2-4\"
}
exec { \"/usr/bin/apt-get update\":
schedule => 'everyday'
}
Note that you can declare the schedule resource anywhere in your
manifests, as long as it ends up in the final compiled catalog."
end
newmetaparam(:audit) do
desc "Marks a subset of this resource's unmanaged attributes for auditing. Accepts an
attribute name, an array of attribute names, or `all`.
Auditing a resource attribute has two effects: First, whenever a catalog
is applied with puppet apply or puppet agent, Puppet will check whether
that attribute of the resource has been modified, comparing its current
value to the previous run; any change will be logged alongside any actions
performed by Puppet while applying the catalog.
Secondly, marking a resource attribute for auditing will include that
attribute in inspection reports generated by puppet inspect; see the
puppet inspect documentation for more details.
Managed attributes for a resource can also be audited, but note that
changes made by Puppet will be logged as additional modifications. (I.e.
if a user manually edits a file whose contents are audited and managed,
puppet agent's next two runs will both log an audit notice: the first run
will log the user's edit and then revert the file to the desired state,
and the second run will log the edit made by Puppet.)"
validate do |list|
list = Array(list).collect {|p| p.to_sym}
unless list == [:all]
list.each do |param|
next if @resource.class.validattr?(param)
fail "Cannot audit #{param}: not a valid attribute for #{resource}"
end
end
end
munge do |args|
properties_to_audit(args).each do |param|
next unless resource.class.validproperty?(param)
resource.newattr(param)
end
end
def all_properties
resource.class.properties.find_all do |property|
resource.provider.nil? or resource.provider.class.supports_parameter?(property)
end.collect do |property|
property.name
end
end
def properties_to_audit(list)
if !list.kind_of?(Array) && list.to_sym == :all
list = all_properties
else
list = Array(list).collect { |p| p.to_sym }
end
end
end
newmetaparam(:loglevel) do
desc "Sets the level that information will be logged.
The log levels have the biggest impact when logs are sent to
syslog (which is currently the default)."
defaultto :notice
newvalues(*Puppet::Util::Log.levels)
newvalues(:verbose)
munge do |loglevel|
val = super(loglevel)
if val == :verbose
val = :info
end
val
end
end
newmetaparam(:alias) do
desc %q{Creates an alias for the resource. Puppet uses this internally when you
provide a symbolic title and an explicit namevar value:
file { 'sshdconfig':
path => $operatingsystem ? {
solaris => '/usr/local/etc/ssh/sshd_config',
default => '/etc/ssh/sshd_config',
},
source => '...'
}
service { 'sshd':
subscribe => File['sshdconfig'],
}
When you use this feature, the parser sets `sshdconfig` as the title,
and the library sets that as an alias for the file so the dependency
lookup in `Service['sshd']` works. You can use this metaparameter yourself,
but note that aliases generally only work for creating relationships; anything
else that refers to an existing resource (such as amending or overriding
resource attributes in an inherited class) must use the resource's exact
title. For example, the following code will not work:
file { '/etc/ssh/sshd_config':
owner => root,
group => root,
alias => 'sshdconfig',
}
File['sshdconfig'] {
mode => 644,
}
There's no way here for the Puppet parser to know that these two stanzas
should be affecting the same file.
}
munge do |aliases|
aliases = [aliases] unless aliases.is_a?(Array)
raise(ArgumentError, "Cannot add aliases without a catalog") unless @resource.catalog
aliases.each do |other|
if obj = @resource.catalog.resource(@resource.class.name, other)
unless obj.object_id == @resource.object_id
self.fail("#{@resource.title} can not create alias #{other}: object already exists")
end
next
end
# Newschool, add it to the catalog.
@resource.catalog.alias(@resource, other)
end
end
end
newmetaparam(:tag) do
desc "Add the specified tags to the associated resource. While all resources
are automatically tagged with as much information as possible
(e.g., each class and definition containing the resource), it can
be useful to add your own tags to a given resource.
Multiple tags can be specified as an array:
file {'/etc/hosts':
ensure => file,
source => 'puppet:///modules/site/hosts',
mode => 0644,
tag => ['bootstrap', 'minimumrun', 'mediumrun'],
}
Tags are useful for things like applying a subset of a host's configuration
with [the `tags` setting](/references/latest/configuration.html#tags)
(e.g. `puppet agent --test --tags bootstrap`) or filtering alerts with
[the `tagmail` report processor](http://docs.puppetlabs.com/references/latest/report.html#tagmail)."
munge do |tags|
tags = [tags] unless tags.is_a? Array
tags.each do |tag|
@resource.tag(tag)
end
end
end
# RelationshipMetaparam is an implementation supporting the meta-parameters `:require`, `:subscribe`,
# `:notify`, and `:before`.
#
#
class RelationshipMetaparam < Puppet::Parameter
class << self
attr_accessor :direction, :events, :callback, :subclasses
end
@subclasses = []
def self.inherited(sub)
@subclasses << sub
end
# @return [Array] turns attribute value(s) into list of resources
def munge(references)
references = [references] unless references.is_a?(Array)
references.collect do |ref|
if ref.is_a?(Puppet::Resource)
ref
else
Puppet::Resource.new(ref)
end
end
end
# Checks each reference to assert that what it references exists in the catalog.
#
# @raise [???fail] if the referenced resource can not be found
# @return [void]
def validate_relationship
@value.each do |ref|
unless @resource.catalog.resource(ref.to_s)
description = self.class.direction == :in ? "dependency" : "dependent"
fail ResourceError, "Could not find #{description} #{ref} for #{resource.ref}"
end
end
end
# Creates edges for all relationships.
# The `:in` relationships are specified by the event-receivers, and `:out`
# relationships are specified by the event generator.
# @todo references to "event-receivers" and "event generator" means in this context - are those just
# the resources at the two ends of the relationship?
# This way 'source' and 'target' are consistent terms in both edges
# and events, i.e. an event targets edges whose source matches
# the event's source. The direction of the relationship determines
# which resource is applied first and which resource is considered
# to be the event generator.
# @return [Array]
# @raise [???fail] when a reference can not be resolved
#
def to_edges
@value.collect do |reference|
reference.catalog = resource.catalog
# Either of the two retrieval attempts could have returned
# nil.
unless related_resource = reference.resolve
self.fail "Could not retrieve dependency '#{reference}' of #{@resource.ref}"
end
# Are we requiring them, or vice versa? See the method docs
# for futher info on this.
if self.class.direction == :in
source = related_resource
target = @resource
else
source = @resource
target = related_resource
end
if method = self.class.callback
subargs = {
:event => self.class.events,
:callback => method
}
self.debug("subscribes to #{related_resource.ref}")
else
# If there's no callback, there's no point in even adding
# a label.
subargs = nil
self.debug("requires #{related_resource.ref}")
end
Puppet::Relationship.new(source, target, subargs)
end
end
end
# @todo document this, have no clue what this does... it retuns "RelationshipMetaparam.subclasses"
#
def self.relationship_params
RelationshipMetaparam.subclasses
end
# Note that the order in which the relationships params is defined
# matters. The labelled params (notify and subcribe) must be later,
# so that if both params are used, those ones win. It's a hackish
# solution, but it works.
newmetaparam(:require, :parent => RelationshipMetaparam, :attributes => {:direction => :in, :events => :NONE}) do
desc "One or more resources that this resource depends on, expressed as
[resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_datatypes.html#resource-references).
Multiple resources can be specified as an array of references. When this
attribute is present:
* The required resource(s) will be applied **before** this resource.
This is one of the four relationship metaparameters, along with
`before`, `notify`, and `subscribe`. For more context, including the
alternate chaining arrow (`->` and `~>`) syntax, see
[the language page on relationships](http://docs.puppetlabs.com/puppet/latest/reference/lang_relationships.html)."
end
newmetaparam(:subscribe, :parent => RelationshipMetaparam, :attributes => {:direction => :in, :events => :ALL_EVENTS, :callback => :refresh}) do
desc "One or more resources that this resource depends on, expressed as
[resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_datatypes.html#resource-references).
Multiple resources can be specified as an array of references. When this
attribute is present:
* The subscribed resource(s) will be applied _before_ this resource.
* If Puppet makes changes to any of the subscribed resources, it will cause
this resource to _refresh._ (Refresh behavior varies by resource
type: services will restart, mounts will unmount and re-mount, etc. Not
all types can refresh.)
This is one of the four relationship metaparameters, along with
`before`, `require`, and `notify`. For more context, including the
alternate chaining arrow (`->` and `~>`) syntax, see
[the language page on relationships](http://docs.puppetlabs.com/puppet/latest/reference/lang_relationships.html)."
end
newmetaparam(:before, :parent => RelationshipMetaparam, :attributes => {:direction => :out, :events => :NONE}) do
desc "One or more resources that depend on this resource, expressed as
[resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_datatypes.html#resource-references).
Multiple resources can be specified as an array of references. When this
attribute is present:
* This resource will be applied _before_ the dependent resource(s).
This is one of the four relationship metaparameters, along with
`require`, `notify`, and `subscribe`. For more context, including the
alternate chaining arrow (`->` and `~>`) syntax, see
[the language page on relationships](http://docs.puppetlabs.com/puppet/latest/reference/lang_relationships.html)."
end
newmetaparam(:notify, :parent => RelationshipMetaparam, :attributes => {:direction => :out, :events => :ALL_EVENTS, :callback => :refresh}) do
desc "One or more resources that depend on this resource, expressed as
[resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_datatypes.html#resource-references).
Multiple resources can be specified as an array of references. When this
attribute is present:
* This resource will be applied _before_ the notified resource(s).
* If Puppet makes changes to this resource, it will cause all of the
notified resources to _refresh._ (Refresh behavior varies by resource
type: services will restart, mounts will unmount and re-mount, etc. Not
all types can refresh.)
This is one of the four relationship metaparameters, along with
`before`, `require`, and `subscribe`. For more context, including the
alternate chaining arrow (`->` and `~>`) syntax, see
[the language page on relationships](http://docs.puppetlabs.com/puppet/latest/reference/lang_relationships.html)."
end
newmetaparam(:stage) do
desc %{Which run stage this class should reside in.
**Note: This metaparameter can only be used on classes,** and only when
declaring them with the resource-like syntax. It cannot be used on normal
resources or on classes declared with `include`.
By default, all classes are declared in the `main` stage. To assign a class
to a different stage, you must:
* Declare the new stage as a [`stage` resource](http://docs.puppetlabs.com/references/latest/type.html#stage).
* Declare an order relationship between the new stage and the `main` stage.
* Use the resource-like syntax to declare the class, and set the `stage`
metaparameter to the name of the desired stage.
For example:
stage { 'pre':
before => Stage['main'],
}
class { 'apt-updates':
stage => 'pre',
}
}
end
###############################
# All of the provider plumbing for the resource types.
require 'puppet/provider'
require 'puppet/util/provider_features'
# Add the feature handling module.
extend Puppet::Util::ProviderFeatures
# The provider that has been selected for the instance of the resource type.
# @return [Puppet::Provider,nil] the selected provider or nil, if none has been selected
#
attr_reader :provider
# the Type class attribute accessors
class << self
# The loader of providers to use when loading providers from disk.
# Although it looks like this attribute provides a way to operate with different loaders of
# providers that is not the case; the attribute is written when a new type is created,
# and should not be changed thereafter.
# @api private
#
attr_accessor :providerloader
# @todo Don't know if this is a name, or a reference to a Provider instance (now marked up as an instance
# of Provider.
# @return [Puppet::Provider, nil] The default provider for this type, or nil if non is defines
#
attr_writer :defaultprovider
end
# The default provider, or the most suitable provider if no default provider was set.
# @note a warning will be issued if no default provider has been configured and a search for the most
# suitable provider returns more than one equally suitable provider.
# @return [Puppet::Provider, nil] the default or most suitable provider, or nil if no provider was found
#
def self.defaultprovider
return @defaultprovider if @defaultprovider
suitable = suitableprovider
# Find which providers are a default for this system.
defaults = suitable.find_all { |provider| provider.default? }
# If we don't have any default we use suitable providers
defaults = suitable if defaults.empty?
max = defaults.collect { |provider| provider.specificity }.max
defaults = defaults.find_all { |provider| provider.specificity == max }
if defaults.length > 1
Puppet.warning(
"Found multiple default providers for #{self.name}: #{defaults.collect { |i| i.name.to_s }.join(", ")}; using #{defaults[0].name}"
)
end
@defaultprovider = defaults.shift unless defaults.empty?
end
# @return [Hash{??? => Puppet::Provider}] Returns a hash of WHAT EXACTLY for the given type
# @todo what goes into this hash?
def self.provider_hash_by_type(type)
@provider_hashes ||= {}
@provider_hashes[type] ||= {}
end
# @return [Hash{ ??? => Puppet::Provider}] Returns a hash of WHAT EXACTLY for this type.
# @see provider_hash_by_type method to get the same for some other type
def self.provider_hash
Puppet::Type.provider_hash_by_type(self.name)
end
# Returns the provider having the given name.
# This will load a provider if it is not already loaded. The returned provider is the first found provider
# having the given name, where "first found" semantics is defined by the {providerloader} in use.
#
# @param name [String] the name of the provider to get
# @return [Puppet::Provider, nil] the found provider, or nil if no provider of the given name was found
#
def self.provider(name)
name = name.intern
# If we don't have it yet, try loading it.
@providerloader.load(name) unless provider_hash.has_key?(name)
provider_hash[name]
end
# Returns a list of loaded providers by name.
# This method will not load/search for available providers.
# @return [Array] list of loaded provider names
#
def self.providers
provider_hash.keys
end
# Returns true if the given name is a reference to a provider and if this is a suitable provider for
# this type.
# @todo How does the provider know if it is suitable for the type? Is it just suitable for the platform/
# environment where this method is executing?
# @param name [String] the name of the provider for which validity is checked
# @return [Boolean] true if the given name references a provider that is suitable
#
def self.validprovider?(name)
name = name.intern
(provider_hash.has_key?(name) && provider_hash[name].suitable?)
end
# Creates a new provider of a type.
# This method must be called directly on the type that it's implementing.
# @todo Fix Confusing Explanations!
# Is this a new provider of a Type (metatype), or a provider of an instance of Type (a resource), or
# a Provider (the implementation of a Type's behavior). CONFUSED. It calls magically named methods like
# "providify" ...
# @param name [String, Symbol] the name of the WHAT? provider? type?
# @param options [Hash{Symbol => Object}] a hash of options, used by this method, and passed on to {#genclass}, (see
# it for additional options to pass).
# @option options [Puppet::Provider] :parent the parent provider (what is this?)
# @option options [Puppet::Type] :resource_type the resource type, defaults to this type if unspecified
# @return [Puppet::Provider] a provider ???
# @raise [Puppet::DevError] when the parent provider could not be found.
#
def self.provide(name, options = {}, &block)
name = name.intern
if unprovide(name)
Puppet.debug "Reloading #{name} #{self.name} provider"
end
parent = if pname = options[:parent]
options.delete(:parent)
if pname.is_a? Class
pname
else
if provider = self.provider(pname)
provider
else
raise Puppet::DevError,
"Could not find parent provider #{pname} of #{name}"
end
end
else
Puppet::Provider
end
options[:resource_type] ||= self
self.providify
provider = genclass(
name,
:parent => parent,
:hash => provider_hash,
:prefix => "Provider",
:block => block,
:include => feature_module,
:extend => feature_module,
:attributes => options
)
provider
end
# Ensures there is a `:provider` parameter defined.
# Should only be called if there are providers.
# @return [void]
def self.providify
return if @paramhash.has_key? :provider
newparam(:provider) do
# We're using a hacky way to get the name of our type, since there doesn't
# seem to be a correct way to introspect this at the time this code is run.
# We expect that the class in which this code is executed will be something
# like Puppet::Type::Ssh_authorized_key::ParameterProvider.
desc <<-EOT
The specific backend to use for this `#{self.to_s.split('::')[2].downcase}`
resource. You will seldom need to specify this --- Puppet will usually
discover the appropriate provider for your platform.
EOT
# This is so we can refer back to the type to get a list of
# providers for documentation.
class << self
# The reference to a parent type for the parameter `:provider` used to get a list of
# providers for documentation purposes.
#
attr_accessor :parenttype
end
# Provides the ability to add documentation to a provider.
#
def self.doc
# Since we're mixing @doc with text from other sources, we must normalize
# its indentation with scrub. But we don't need to manually scrub the
# provider's doc string, since markdown_definitionlist sanitizes its inputs.
scrub(@doc) + "Available providers are:\n\n" + parenttype.providers.sort { |a,b|
a.to_s <=> b.to_s
}.collect { |i|
markdown_definitionlist( i, scrub(parenttype().provider(i).doc) )
}.join
end
# @todo this does what? where and how?
# @return [String] the name of the provider
defaultto {
prov = @resource.class.defaultprovider
prov.name if prov
}
validate do |provider_class|
provider_class = provider_class[0] if provider_class.is_a? Array
provider_class = provider_class.class.name if provider_class.is_a?(Puppet::Provider)
unless @resource.class.provider(provider_class)
raise ArgumentError, "Invalid #{@resource.class.name} provider '#{provider_class}'"
end
end
munge do |provider|
provider = provider[0] if provider.is_a? Array
provider = provider.intern if provider.is_a? String
@resource.provider = provider
if provider.is_a?(Puppet::Provider)
provider.class.name
else
provider
end
end
end.parenttype = self
end
# @todo this needs a better explanation
# Removes the implementation class of a given provider.
# @return [Object] returns what {Puppet::Util::ClassGen#rmclass} returns
def self.unprovide(name)
if @defaultprovider and @defaultprovider.name == name
@defaultprovider = nil
end
rmclass(name, :hash => provider_hash, :prefix => "Provider")
end
# Returns a list of suitable providers for the given type.
# A call to this method will load all providers if not already loaded and ask each if it is
# suitable - those that are are included in the result.
# @note This method also does some special processing which rejects a provider named `:fake` (for testing purposes).
# @return [Array] Returns an array of all suitable providers.
#
def self.suitableprovider
providerloader.loadall if provider_hash.empty?
provider_hash.find_all { |name, provider|
provider.suitable?
}.collect { |name, provider|
provider
}.reject { |p| p.name == :fake } # For testing
end
# @return [Boolean] Returns true if this is something else than a `:provider`, or if it
# is a provider and it is suitable, or if there is a default provider. Otherwise, false is returned.
#
def suitable?
# If we don't use providers, then we consider it suitable.
return true unless self.class.paramclass(:provider)
# We have a provider and it is suitable.
return true if provider && provider.class.suitable?
# We're using the default provider and there is one.
if !provider and self.class.defaultprovider
self.provider = self.class.defaultprovider.name
return true
end
# We specified an unsuitable provider, or there isn't any suitable
# provider.
false
end
# Sets the provider to the given provider/name.
# @overload provider=(name)
# Sets the provider to the result of resolving the name to an instance of Provider.
# @param name [String] the name of the provider
# @overload provider=(provider)
# Sets the provider to the given instances of Provider.
# @param provider [Puppet::Provider] the provider to set
# @return [Puppet::Provider] the provider set
# @raise [ArgumentError] if the provider could not be found/resolved.
#
def provider=(name)
if name.is_a?(Puppet::Provider)
@provider = name
@provider.resource = self
elsif klass = self.class.provider(name)
@provider = klass.new(self)
else
raise ArgumentError, "Could not find #{name} provider of #{self.class.name}"
end
end
###############################
# All of the relationship code.
# Adds a block producing a single name (or list of names) of the given resource type name to autorequire.
# @example Autorequire the files File['foo', 'bar']
# autorequire( 'file', {|| ['foo', 'bar'] })
#
# @todo original = _"Specify a block for generating a list of objects to autorequire.
# This makes it so that you don't have to manually specify things that you clearly require."_
# @param name [String] the name of a type of which one or several resources should be autorequired e.g. "file"
# @yield [ ] a block returning list of names of given type to auto require
# @yieldreturn [String, Array] one or several resource names for the named type
# @return [void]
# @dsl type
# @api public
#
def self.autorequire(name, &block)
@autorequires ||= {}
@autorequires[name] = block
end
# Provides iteration over added auto-requirements (see {autorequire}).
# @yieldparam type [String] the name of the type to autoriquire an instance of
# @yieldparam block [Proc] a block producing one or several dependencies to auto require (see {autorequire}).
# @yieldreturn [void]
# @return [void]
def self.eachautorequire
@autorequires ||= {}
@autorequires.each { |type, block|
yield(type, block)
}
end
# Adds dependencies to the catalog from added autorequirements.
# See {autorequire} for how to add an auto-requirement.
# @todo needs details - see the param rel_catalog, and type of this param
# @param rel_catalog [Puppet::Resource::Catalog, nil] the catalog to
# add dependencies to. Defaults to the current catalog (set when the
# type instance was added to a catalog)
# @raise [Puppet::DevError] if there is no catalog
#
def autorequire(rel_catalog = nil)
rel_catalog ||= catalog
raise(Puppet::DevError, "You cannot add relationships without a catalog") unless rel_catalog
reqs = []
self.class.eachautorequire { |type, block|
# Ignore any types we can't find, although that would be a bit odd.
next unless Puppet::Type.type(type)
# Retrieve the list of names from the block.
next unless list = self.instance_eval(&block)
list = [list] unless list.is_a?(Array)
# Collect the current prereqs
list.each { |dep|
# Support them passing objects directly, to save some effort.
unless dep.is_a? Puppet::Type
# Skip autorequires that we aren't managing
unless dep = rel_catalog.resource(type, dep)
next
end
end
reqs << Puppet::Relationship.new(dep, self)
}
}
reqs
end
# Builds the dependencies associated with an individual object.
# @todo Which object is the "individual object", as opposed to "object as a group?" or should it simply
# be "this object" as in "this resource" ?
# @todo Does this method "build dependencies" or "build what it depends on" ... CONFUSING
#
# @return [Array] list of WHAT? resources? edges?
def builddepends
# Handle the requires
self.class.relationship_params.collect do |klass|
if param = @parameters[klass.name]
param.to_edges
end
end.flatten.reject { |r| r.nil? }
end
# Sets the initial list of tags...
# @todo The initial list of tags, that ... that what?
# @return [void] ???
def tags=(list)
tag(self.class.name)
tag(*list)
end
# @comment - these two comments were floating around here, and turned up as documentation
# for the attribute "title", much to my surprise and amusement. Clearly these comments
# are orphaned ... I think they can just be removed as what they say should be covered
# by the now added yardoc. (Yo! to quote some of the other actual awsome specific comments applicable
# to objects called from elsewhere, or not. ;-)
#
# @comment Types (which map to resources in the languages) are entirely composed of
# attribute value pairs. Generally, Puppet calls any of these things an
# 'attribute', but these attributes always take one of three specific
# forms: parameters, metaparams, or properties.
# @comment In naming methods, I have tried to consistently name the method so
# that it is clear whether it operates on all attributes (thus has 'attr' in
# the method name, or whether it operates on a specific type of attributes.
# The title attribute of WHAT ???
# @todo Figure out what this is the title attribute of (it appears on line 1926 currently).
# @return [String] the title
attr_writer :title
# The noop attribute of WHAT ??? does WHAT???
# @todo Figure out what this is the noop attribute of (it appears on line 1931 currently).
# @return [???] the noop WHAT ??? (mode? if so of what, or noop for an instance of the type, or for all
# instances of a type, or for what???
#
attr_writer :noop
include Enumerable
# class methods dealing with Type management
public
# The Type class attribute accessors
class << self
# @return [String] the name of the resource type; e.g., "File"
#
attr_reader :name
# @return [Boolean] true if the type should send itself a refresh event on change.
#
attr_accessor :self_refresh
include Enumerable, Puppet::Util::ClassGen
include Puppet::MetaType::Manager
include Puppet::Util
include Puppet::Util::Logging
end
# Initializes all of the variables that must be initialized for each subclass.
# @todo Does the explanation make sense?
# @return [void]
def self.initvars
# all of the instances of this class
@objects = Hash.new
@aliases = Hash.new
@defaults = {}
@parameters ||= []
@validproperties = {}
@properties = []
@parameters = []
@paramhash = {}
@paramdoc = Hash.new { |hash,key|
key = key.intern if key.is_a?(String)
if hash.include?(key)
hash[key]
else
"Param Documentation for #{key} not found"
end
}
@doc ||= ""
end
# Returns the name of this type (if specified) or the parent type #to_s.
# The returned name is on the form "Puppet::Type::", where the first letter of name is
# capitalized.
# @return [String] the fully qualified name Puppet::Type:: where the first letter of name is captialized
#
def self.to_s
if defined?(@name)
"Puppet::Type::#{@name.to_s.capitalize}"
else
super
end
end
# Creates a `validate` method that is used to validate a resource before it is operated on.
# The validation should raise exceptions if the validation finds errors. (It is not recommended to
# issue warnings as this typically just ends up in a logfile - you should fail if a validation fails).
# The easiest way to raise an appropriate exception is to call the method {Puppet::Util::Errors.fail} with
# the message as an argument.
#
# @yield [ ] a required block called with self set to the instance of a Type class representing a resource.
# @return [void]
# @dsl type
# @api public
#
def self.validate(&block)
define_method(:validate, &block)
end
# @return [String] The file from which this type originates from
attr_accessor :file
# @return [Integer] The line in {#file} from which this type originates from
attr_accessor :line
# @todo what does this mean "this resource" (sounds like this if for an instance of the type, not the meta Type),
# but not sure if this is about the catalog where the meta Type is included)
# @return [??? TODO] The catalog that this resource is stored in.
attr_accessor :catalog
# @return [Boolean] Flag indicating if this type is exported
attr_accessor :exported
# @return [Boolean] Flag indicating if the type is virtual (it should not be).
attr_accessor :virtual
# Creates a log entry with the given message at the log level specified by the parameter `loglevel`
# @return [void]
#
def log(msg)
Puppet::Util::Log.create(
:level => @parameters[:loglevel].value,
:message => msg,
:source => self
)
end
# instance methods related to instance intrinsics
# e.g., initialize and name
public
# @return [Hash] hash of parameters originally defined
# @api private
attr_reader :original_parameters
# Creates an instance of Type from a hash or a {Puppet::Resource}.
# @todo Unclear if this is a new Type or a new instance of a given type (the initialization ends
# with calling validate - which seems like validation of an instance of a given type, not a new
# meta type.
#
# @todo Explain what the Hash and Resource are. There seems to be two different types of
# resources; one that causes the title to be set to resource.title, and one that
# causes the title to be resource.ref ("for components") - what is a component?
#
# @overload initialize(hash)
# @param [Hash] hash
# @raise [Puppet::ResourceError] when the type validation raises
# Puppet::Error or ArgumentError
# @overload initialize(resource)
# @param resource [Puppet:Resource]
# @raise [Puppet::ResourceError] when the type validation raises
# Puppet::Error or ArgumentError
#
def initialize(resource)
resource = self.class.hash2resource(resource) unless resource.is_a?(Puppet::Resource)
# The list of parameter/property instances.
@parameters = {}
# Set the title first, so any failures print correctly.
if resource.type.to_s.downcase.to_sym == self.class.name
self.title = resource.title
else
# This should only ever happen for components
self.title = resource.ref
end
[:file, :line, :catalog, :exported, :virtual].each do |getter|
setter = getter.to_s + "="
if val = resource.send(getter)
self.send(setter, val)
end
end
@tags = resource.tags
@original_parameters = resource.to_hash
set_name(@original_parameters)
set_default(:provider)
set_parameters(@original_parameters)
begin
self.validate if self.respond_to?(:validate)
rescue Puppet::Error, ArgumentError => detail
error = Puppet::ResourceError.new("Validation of #{ref} failed: #{detail}")
adderrorcontext(error, detail)
raise error
end
end
private
# Sets the name of the resource from a hash containing a mapping of `name_var` to value.
# Sets the value of the property/parameter appointed by the `name_var` (if it is defined). The value set is
# given by the corresponding entry in the given hash - e.g. if name_var appoints the name `:path` the value
# of `:path` is set to the value at the key `:path` in the given hash. As a side effect this key/value is then
# removed from the given hash.
#
# @note This method mutates the given hash by removing the entry with a key equal to the value
# returned from name_var!
# @param hash [Hash] a hash of what
# @return [void]
def set_name(hash)
self[name_var] = hash.delete(name_var) if name_var
end
# Sets parameters from the given hash.
# Values are set in _attribute order_ i.e. higher priority attributes before others, otherwise in
# the order they were specified (as opposed to just setting them in the order they happen to appear in
# when iterating over the given hash).
#
# Attributes that are not included in the given hash are set to their default value.
#
# @todo Is this description accurate? Is "ensure" an example of such a higher priority attribute?
# @return [void]
# @raise [Puppet::DevError] when impossible to set the value due to some problem
# @raise [ArgumentError, TypeError, Puppet::Error] when faulty arguments have been passed
#
def set_parameters(hash)
# Use the order provided by allattrs, but add in any
# extra attributes from the resource so we get failures
# on invalid attributes.
no_values = []
(self.class.allattrs + hash.keys).uniq.each do |attr|
begin
# Set any defaults immediately. This is mostly done so
# that the default provider is available for any other
# property validation.
if hash.has_key?(attr)
self[attr] = hash[attr]
else
no_values << attr
end
rescue ArgumentError, Puppet::Error, TypeError
raise
rescue => detail
error = Puppet::DevError.new( "Could not set #{attr} on #{self.class.name}: #{detail}")
error.set_backtrace(detail.backtrace)
raise error
end
end
no_values.each do |attr|
set_default(attr)
end
end
public
# Finishes any outstanding processing.
# This method should be called as a final step in setup,
# to allow the parameters that have associated auto-require needs to be processed.
#
# @todo what is the expected sequence here - who is responsible for calling this? When?
# Is the returned type correct?
# @return [Array] the validated list/set of attributes
#
def finish
# Call post_compile hook on every parameter that implements it. This includes all subclasses
# of parameter including, but not limited to, regular parameters, metaparameters, relationship
# parameters, and properties.
eachparameter do |parameter|
parameter.post_compile if parameter.respond_to? :post_compile
end
# Make sure all of our relationships are valid. Again, must be done
# when the entire catalog is instantiated.
self.class.relationship_params.collect do |klass|
if param = @parameters[klass.name]
param.validate_relationship
end
end.flatten.reject { |r| r.nil? }
end
# @comment For now, leave the 'name' method functioning like it used to. Once 'title'
# works everywhere, I'll switch it.
# Returns the resource's name
# @todo There is a comment in source that this is not quite the same as ':title' and that a switch should
# be made...
# @return [String] the name of a resource
def name
self[:name]
end
# Returns the parent of this in the catalog. In case of an erroneous catalog
# where multiple parents have been produced, the first found (non
# deterministic) parent is returned.
# @return [Puppet::Type, nil] the
# containing resource or nil if there is no catalog or no containing
# resource.
def parent
return nil unless catalog
@parent ||=
if parents = catalog.adjacent(self, :direction => :in)
parents.shift
else
nil
end
end
# Returns a reference to this as a string in "Type[name]" format.
# @return [String] a reference to this object on the form 'Type[name]'
#
def ref
# memoizing this is worthwhile ~ 3 percent of calls are the "first time
# around" in an average run of Puppet. --daniel 2012-07-17
@ref ||= "#{self.class.name.to_s.capitalize}[#{self.title}]"
end
# (see self_refresh)
# @todo check that meaningful yardoc is produced - this method delegates to "self.class.self_refresh"
# @return [Boolean] - ??? returns true when ... what?
#
def self_refresh?
self.class.self_refresh
end
# Marks the object as "being purged".
# This method is used by transactions to forbid deletion when there are dependencies.
# @todo what does this mean; "mark that we are purging" (purging what from where). How to use/when?
# Is this internal API in transactions?
# @see purging?
def purging
@purging = true
end
# Returns whether this resource is being purged or not.
# This method is used by transactions to forbid deletion when there are dependencies.
# @return [Boolean] the current "purging" state
#
def purging?
if defined?(@purging)
@purging
else
false
end
end
# Returns the title of this object, or its name if title was not explicetly set.
# If the title is not already set, it will be computed by looking up the {#name_var} and using
# that value as the title.
# @todo it is somewhat confusing that if the name_var is a valid parameter, it is assumed to
# be the name_var called :name, but if it is a property, it uses the name_var.
# It is further confusing as Type in some respects supports multiple namevars.
#
# @return [String] Returns the title of this object, or its name if title was not explicetly set.
# @raise [??? devfail] if title is not set, and name_var can not be found.
def title
unless @title
if self.class.validparameter?(name_var)
@title = self[:name]
elsif self.class.validproperty?(name_var)
@title = self.should(name_var)
else
self.devfail "Could not find namevar #{name_var} for #{self.class.name}"
end
end
@title
end
# Produces a reference to this in reference format.
# @see #ref
#
def to_s
self.ref
end
# @todo What to resource? Which one of the resource forms is prroduced? returned here?
# @return [??? Resource] a resource that WHAT???
#
def to_resource
resource = self.retrieve_resource
resource.tag(*self.tags)
@parameters.each do |name, param|
# Avoid adding each instance name twice
next if param.class.isnamevar? and param.value == self.title
# We've already got property values
next if param.is_a?(Puppet::Property)
resource[name] = param.value
end
resource
end
# @return [Boolean] Returns whether the resource is virtual or not
def virtual?; !!@virtual; end
# @return [Boolean] Returns whether the resource is exported or not
def exported?; !!@exported; end
# @return [Boolean] Returns whether the resource is applicable to `:device`
# Returns true if a resource of this type can be evaluated on a 'network device' kind
# of hosts.
# @api private
def appliable_to_device?
self.class.can_apply_to(:device)
end
# @return [Boolean] Returns whether the resource is applicable to `:host`
# Returns true if a resource of this type can be evaluated on a regular generalized computer (ie not an appliance like a network device)
# @api private
def appliable_to_host?
self.class.can_apply_to(:host)
end
end
end
require 'puppet/provider'
# Always load these types.
Puppet::Type.type(:component)
puppet-3.4.3/lib/puppet/agent.rb 0000644 0052762 0001160 00000005726 12300765631 016451 0 ustar jenkins jenkins require 'puppet/application'
# A general class for triggering a run of another
# class.
class Puppet::Agent
require 'puppet/agent/locker'
include Puppet::Agent::Locker
require 'puppet/agent/disabler'
include Puppet::Agent::Disabler
attr_reader :client_class, :client, :splayed, :should_fork
# Just so we can specify that we are "the" instance.
def initialize(client_class, should_fork=true)
@splayed = false
@should_fork = should_fork
@client_class = client_class
end
def needing_restart?
Puppet::Application.restart_requested?
end
# Perform a run with our client.
def run(client_options = {})
if running?
Puppet.notice "Run of #{client_class} already in progress; skipping (#{lockfile_path} exists)"
return
end
if disabled?
Puppet.notice "Skipping run of #{client_class}; administratively disabled (Reason: '#{disable_message}');\nUse 'puppet agent --enable' to re-enable."
return
end
result = nil
block_run = Puppet::Application.controlled_run do
splay client_options.fetch :splay, Puppet[:splay]
result = run_in_fork(should_fork) do
with_client do |client|
begin
client_args = client_options.merge(:pluginsync => Puppet[:pluginsync])
lock { client.run(client_args) }
rescue SystemExit,NoMemoryError
raise
rescue Exception => detail
Puppet.log_exception(detail, "Could not run #{client_class}: #{detail}")
end
end
end
true
end
Puppet.notice "Shutdown/restart in progress (#{Puppet::Application.run_status.inspect}); skipping run" unless block_run
result
end
def stopping?
Puppet::Application.stop_requested?
end
# Have we splayed already?
def splayed?
splayed
end
# Sleep when splay is enabled; else just return.
def splay(do_splay = Puppet[:splay])
return unless do_splay
return if splayed?
time = rand(Puppet[:splaylimit] + 1)
Puppet.info "Sleeping for #{time} seconds (splay is enabled)"
sleep(time)
@splayed = true
end
def run_in_fork(forking = true)
return yield unless forking or Puppet.features.windows?
child_pid = Kernel.fork do
$0 = "puppet agent: applying configuration"
begin
exit(yield)
rescue SystemExit
exit(-1)
rescue NoMemoryError
exit(-2)
end
end
exit_code = Process.waitpid2(child_pid)
case exit_code[1].exitstatus
when -1
raise SystemExit
when -2
raise NoMemoryError
end
exit_code[1].exitstatus
end
private
# Create and yield a client instance, keeping a reference
# to it during the yield.
def with_client
begin
@client = client_class.new
rescue SystemExit,NoMemoryError
raise
rescue Exception => detail
Puppet.log_exception(detail, "Could not create instance of #{client_class}: #{detail}")
return
end
yield @client
ensure
@client = nil
end
end
puppet-3.4.3/lib/puppet/provider/ 0000755 0052762 0001160 00000000000 12300765640 016646 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/package.rb 0000644 0052762 0001160 00000001120 12300765631 020560 0 ustar jenkins jenkins class Puppet::Provider::Package < Puppet::Provider
# Prefetch our package list, yo.
def self.prefetch(packages)
instances.each do |prov|
if pkg = packages[prov.name]
pkg.provider = prov
end
end
end
# Clear out the cached values.
def flush
@property_hash.clear
end
# Look up the current status.
def properties
if @property_hash.empty?
@property_hash = query || {:ensure => :absent}
@property_hash[:ensure] = :absent if @property_hash.empty?
end
@property_hash.dup
end
def validate_source(value)
true
end
end
puppet-3.4.3/lib/puppet/provider/scheduled_task/ 0000755 0052762 0001160 00000000000 12300765640 021630 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/scheduled_task/win32_taskscheduler.rb 0000644 0052762 0001160 00000043451 12300765631 026047 0 ustar jenkins jenkins require 'puppet/parameter'
if Puppet.features.microsoft_windows?
require 'win32/taskscheduler'
require 'puppet/util/adsi'
end
Puppet::Type.type(:scheduled_task).provide(:win32_taskscheduler) do
desc %q{This provider uses the win32-taskscheduler gem to manage scheduled
tasks on Windows.
Puppet requires version 0.2.1 or later of the win32-taskscheduler gem;
previous versions can cause "Could not evaluate: The operation completed
successfully" errors.}
defaultfor :operatingsystem => :windows
confine :operatingsystem => :windows
def self.instances
Win32::TaskScheduler.new.tasks.collect do |job_file|
job_title = File.basename(job_file, '.job')
new(
:provider => :win32_taskscheduler,
:name => job_title
)
end
end
def exists?
Win32::TaskScheduler.new.exists? resource[:name]
end
def task
return @task if @task
@task ||= Win32::TaskScheduler.new
@task.activate(resource[:name] + '.job') if exists?
@task
end
def clear_task
@task = nil
@triggers = nil
end
def enabled
task.flags & Win32::TaskScheduler::DISABLED == 0 ? :true : :false
end
def command
task.application_name
end
def arguments
task.parameters
end
def working_dir
task.working_directory
end
def user
account = task.account_information
return 'system' if account == ''
account
end
def trigger
return @triggers if @triggers
@triggers = []
task.trigger_count.times do |i|
trigger = begin
task.trigger(i)
rescue Win32::TaskScheduler::Error
# Win32::TaskScheduler can't handle all of the
# trigger types Windows uses, so we need to skip the
# unhandled types to prevent "puppet resource" from
# blowing up.
nil
end
next unless trigger and scheduler_trigger_types.include?(trigger['trigger_type'])
puppet_trigger = {}
case trigger['trigger_type']
when Win32::TaskScheduler::TASK_TIME_TRIGGER_DAILY
puppet_trigger['schedule'] = 'daily'
puppet_trigger['every'] = trigger['type']['days_interval'].to_s
when Win32::TaskScheduler::TASK_TIME_TRIGGER_WEEKLY
puppet_trigger['schedule'] = 'weekly'
puppet_trigger['every'] = trigger['type']['weeks_interval'].to_s
puppet_trigger['on'] = days_of_week_from_bitfield(trigger['type']['days_of_week'])
when Win32::TaskScheduler::TASK_TIME_TRIGGER_MONTHLYDATE
puppet_trigger['schedule'] = 'monthly'
puppet_trigger['months'] = months_from_bitfield(trigger['type']['months'])
puppet_trigger['on'] = days_from_bitfield(trigger['type']['days'])
when Win32::TaskScheduler::TASK_TIME_TRIGGER_MONTHLYDOW
puppet_trigger['schedule'] = 'monthly'
puppet_trigger['months'] = months_from_bitfield(trigger['type']['months'])
puppet_trigger['which_occurrence'] = occurrence_constant_to_name(trigger['type']['weeks'])
puppet_trigger['day_of_week'] = days_of_week_from_bitfield(trigger['type']['days_of_week'])
when Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE
puppet_trigger['schedule'] = 'once'
end
puppet_trigger['start_date'] = self.class.normalized_date("#{trigger['start_year']}-#{trigger['start_month']}-#{trigger['start_day']}")
puppet_trigger['start_time'] = self.class.normalized_time("#{trigger['start_hour']}:#{trigger['start_minute']}")
puppet_trigger['enabled'] = trigger['flags'] & Win32::TaskScheduler::TASK_TRIGGER_FLAG_DISABLED == 0
puppet_trigger['index'] = i
@triggers << puppet_trigger
end
@triggers = @triggers[0] if @triggers.length == 1
@triggers
end
def user_insync?(current, should)
return false unless current
# Win32::TaskScheduler can return the 'SYSTEM' account as the
# empty string.
current = 'system' if current == ''
# By comparing account SIDs we don't have to worry about case
# sensitivity, or canonicalization of the account name.
Puppet::Util::Windows::Security.name_to_sid(current) == Puppet::Util::Windows::Security.name_to_sid(should[0])
end
def trigger_insync?(current, should)
should = [should] unless should.is_a?(Array)
current = [current] unless current.is_a?(Array)
return false unless current.length == should.length
current_in_sync = current.all? do |c|
should.any? {|s| triggers_same?(c, s)}
end
should_in_sync = should.all? do |s|
current.any? {|c| triggers_same?(c,s)}
end
current_in_sync && should_in_sync
end
def command=(value)
task.application_name = value
end
def arguments=(value)
task.parameters = value
end
def working_dir=(value)
task.working_directory = value
end
def enabled=(value)
if value == :true
task.flags = task.flags & ~Win32::TaskScheduler::DISABLED
else
task.flags = task.flags | Win32::TaskScheduler::DISABLED
end
end
def trigger=(value)
desired_triggers = value.is_a?(Array) ? value : [value]
current_triggers = trigger.is_a?(Array) ? trigger : [trigger]
extra_triggers = []
desired_to_search = desired_triggers.dup
current_triggers.each do |current|
if found = desired_to_search.find {|desired| triggers_same?(current, desired)}
desired_to_search.delete(found)
else
extra_triggers << current['index']
end
end
needed_triggers = []
current_to_search = current_triggers.dup
desired_triggers.each do |desired|
if found = current_to_search.find {|current| triggers_same?(current, desired)}
current_to_search.delete(found)
else
needed_triggers << desired
end
end
extra_triggers.reverse_each do |index|
task.delete_trigger(index)
end
needed_triggers.each do |trigger_hash|
# Even though this is an assignment, the API for
# Win32::TaskScheduler ends up appending this trigger to the
# list of triggers for the task, while #add_trigger is only able
# to replace existing triggers. *shrug*
task.trigger = translate_hash_to_trigger(trigger_hash)
end
end
def user=(value)
self.fail("Invalid user: #{value}") unless Puppet::Util::Windows::Security.name_to_sid(value)
if value.to_s.downcase != 'system'
task.set_account_information(value, resource[:password])
else
# Win32::TaskScheduler treats a nil/empty username & password as
# requesting the SYSTEM account.
task.set_account_information(nil, nil)
end
end
def create
clear_task
@task = Win32::TaskScheduler.new(resource[:name], dummy_time_trigger)
self.command = resource[:command]
[:arguments, :working_dir, :enabled, :trigger, :user].each do |prop|
send("#{prop}=", resource[prop]) if resource[prop]
end
end
def destroy
Win32::TaskScheduler.new.delete(resource[:name] + '.job')
end
def flush
unless resource[:ensure] == :absent
self.fail('Parameter command is required.') unless resource[:command]
task.save
@task = nil
end
end
def triggers_same?(current_trigger, desired_trigger)
return false unless current_trigger['schedule'] == desired_trigger['schedule']
return false if current_trigger.has_key?('enabled') && !current_trigger['enabled']
desired = desired_trigger.dup
desired['every'] ||= current_trigger['every'] if current_trigger.has_key?('every')
desired['months'] ||= current_trigger['months'] if current_trigger.has_key?('months')
desired['on'] ||= current_trigger['on'] if current_trigger.has_key?('on')
desired['day_of_week'] ||= current_trigger['day_of_week'] if current_trigger.has_key?('day_of_week')
translate_hash_to_trigger(current_trigger) == translate_hash_to_trigger(desired)
end
def self.normalized_date(date_string)
date = Date.parse("#{date_string}")
"#{date.year}-#{date.month}-#{date.day}"
end
def self.normalized_time(time_string)
Time.parse("#{time_string}").strftime('%H:%M')
end
def dummy_time_trigger
now = Time.now
{
'flags' => 0,
'random_minutes_interval' => 0,
'end_day' => 0,
"end_year" => 0,
"trigger_type" => 0,
"minutes_interval" => 0,
"end_month" => 0,
"minutes_duration" => 0,
'start_year' => now.year,
'start_month' => now.month,
'start_day' => now.day,
'start_hour' => now.hour,
'start_minute' => now.min,
'trigger_type' => Win32::TaskScheduler::ONCE,
}
end
def translate_hash_to_trigger(puppet_trigger, user_provided_input=false)
trigger = dummy_time_trigger
if user_provided_input
self.fail "'enabled' is read-only on triggers" if puppet_trigger.has_key?('enabled')
self.fail "'index' is read-only on triggers" if puppet_trigger.has_key?('index')
end
puppet_trigger.delete('index')
if puppet_trigger.delete('enabled') == false
trigger['flags'] |= Win32::TaskScheduler::TASK_TRIGGER_FLAG_DISABLED
else
trigger['flags'] &= ~Win32::TaskScheduler::TASK_TRIGGER_FLAG_DISABLED
end
extra_keys = puppet_trigger.keys.sort - ['schedule', 'start_date', 'start_time', 'every', 'months', 'on', 'which_occurrence', 'day_of_week']
self.fail "Unknown trigger option(s): #{Puppet::Parameter.format_value_for_display(extra_keys)}" unless extra_keys.empty?
self.fail "Must specify 'start_time' when defining a trigger" unless puppet_trigger['start_time']
case puppet_trigger['schedule']
when 'daily'
trigger['trigger_type'] = Win32::TaskScheduler::DAILY
trigger['type'] = {
'days_interval' => Integer(puppet_trigger['every'] || 1)
}
when 'weekly'
trigger['trigger_type'] = Win32::TaskScheduler::WEEKLY
trigger['type'] = {
'weeks_interval' => Integer(puppet_trigger['every'] || 1)
}
trigger['type']['days_of_week'] = if puppet_trigger['day_of_week']
bitfield_from_days_of_week(puppet_trigger['day_of_week'])
else
scheduler_days_of_week.inject(0) {|day_flags,day| day_flags |= day}
end
when 'monthly'
trigger['type'] = {
'months' => bitfield_from_months(puppet_trigger['months'] || (1..12).to_a),
}
if puppet_trigger.keys.include?('on')
if puppet_trigger.has_key?('day_of_week') or puppet_trigger.has_key?('which_occurrence')
self.fail "Neither 'day_of_week' nor 'which_occurrence' can be specified when creating a monthly date-based trigger"
end
trigger['trigger_type'] = Win32::TaskScheduler::MONTHLYDATE
trigger['type']['days'] = bitfield_from_days(puppet_trigger['on'])
elsif puppet_trigger.keys.include?('which_occurrence') or puppet_trigger.keys.include?('day_of_week')
self.fail 'which_occurrence cannot be specified as an array' if puppet_trigger['which_occurrence'].is_a?(Array)
%w{day_of_week which_occurrence}.each do |field|
self.fail "#{field} must be specified when creating a monthly day-of-week based trigger" unless puppet_trigger.has_key?(field)
end
trigger['trigger_type'] = Win32::TaskScheduler::MONTHLYDOW
trigger['type']['weeks'] = occurrence_name_to_constant(puppet_trigger['which_occurrence'])
trigger['type']['days_of_week'] = bitfield_from_days_of_week(puppet_trigger['day_of_week'])
else
self.fail "Don't know how to create a 'monthly' schedule with the options: #{puppet_trigger.keys.sort.join(', ')}"
end
when 'once'
self.fail "Must specify 'start_date' when defining a one-time trigger" unless puppet_trigger['start_date']
trigger['trigger_type'] = Win32::TaskScheduler::ONCE
else
self.fail "Unknown schedule type: #{puppet_trigger["schedule"].inspect}"
end
if start_date = puppet_trigger['start_date']
start_date = Date.parse(start_date)
self.fail "start_date must be on or after 1753-01-01" unless start_date >= Date.new(1753, 1, 1)
trigger['start_year'] = start_date.year
trigger['start_month'] = start_date.month
trigger['start_day'] = start_date.day
end
start_time = Time.parse(puppet_trigger['start_time'])
trigger['start_hour'] = start_time.hour
trigger['start_minute'] = start_time.min
trigger
end
def validate_trigger(value)
value = [value] unless value.is_a?(Array)
# translate_hash_to_trigger handles the same validation that we
# would be doing here at the individual trigger level.
value.each {|t| translate_hash_to_trigger(t, true)}
true
end
private
def bitfield_from_months(months)
bitfield = 0
months = [months] unless months.is_a?(Array)
months.each do |month|
integer_month = Integer(month) rescue nil
self.fail 'Month must be specified as an integer in the range 1-12' unless integer_month == month.to_f and integer_month.between?(1,12)
bitfield |= scheduler_months[integer_month - 1]
end
bitfield
end
def bitfield_from_days(days)
bitfield = 0
days = [days] unless days.is_a?(Array)
days.each do |day|
# The special "day" of 'last' is represented by day "number"
# 32. 'last' has the special meaning of "the last day of the
# month", no matter how many days there are in the month.
day = 32 if day == 'last'
integer_day = Integer(day)
self.fail "Day must be specified as an integer in the range 1-31, or as 'last'" unless integer_day = day.to_f and integer_day.between?(1,32)
bitfield |= 1 << integer_day - 1
end
bitfield
end
def bitfield_from_days_of_week(days_of_week)
bitfield = 0
days_of_week = [days_of_week] unless days_of_week.is_a?(Array)
days_of_week.each do |day_of_week|
bitfield |= day_of_week_name_to_constant(day_of_week)
end
bitfield
end
def months_from_bitfield(bitfield)
months = []
scheduler_months.each do |month|
if bitfield & month != 0
months << month_constant_to_number(month)
end
end
months
end
def days_from_bitfield(bitfield)
days = []
i = 0
while bitfield > 0
if bitfield & 1 > 0
# Day 32 has the special meaning of "the last day of the
# month", no matter how many days there are in the month.
days << (i == 31 ? 'last' : i + 1)
end
bitfield = bitfield >> 1
i += 1
end
days
end
def days_of_week_from_bitfield(bitfield)
days_of_week = []
scheduler_days_of_week.each do |day_of_week|
if bitfield & day_of_week != 0
days_of_week << day_of_week_constant_to_name(day_of_week)
end
end
days_of_week
end
def scheduler_trigger_types
[
Win32::TaskScheduler::TASK_TIME_TRIGGER_DAILY,
Win32::TaskScheduler::TASK_TIME_TRIGGER_WEEKLY,
Win32::TaskScheduler::TASK_TIME_TRIGGER_MONTHLYDATE,
Win32::TaskScheduler::TASK_TIME_TRIGGER_MONTHLYDOW,
Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE
]
end
def scheduler_days_of_week
[
Win32::TaskScheduler::SUNDAY,
Win32::TaskScheduler::MONDAY,
Win32::TaskScheduler::TUESDAY,
Win32::TaskScheduler::WEDNESDAY,
Win32::TaskScheduler::THURSDAY,
Win32::TaskScheduler::FRIDAY,
Win32::TaskScheduler::SATURDAY
]
end
def scheduler_months
[
Win32::TaskScheduler::JANUARY,
Win32::TaskScheduler::FEBRUARY,
Win32::TaskScheduler::MARCH,
Win32::TaskScheduler::APRIL,
Win32::TaskScheduler::MAY,
Win32::TaskScheduler::JUNE,
Win32::TaskScheduler::JULY,
Win32::TaskScheduler::AUGUST,
Win32::TaskScheduler::SEPTEMBER,
Win32::TaskScheduler::OCTOBER,
Win32::TaskScheduler::NOVEMBER,
Win32::TaskScheduler::DECEMBER
]
end
def scheduler_occurrences
[
Win32::TaskScheduler::FIRST_WEEK,
Win32::TaskScheduler::SECOND_WEEK,
Win32::TaskScheduler::THIRD_WEEK,
Win32::TaskScheduler::FOURTH_WEEK,
Win32::TaskScheduler::LAST_WEEK
]
end
def day_of_week_constant_to_name(constant)
case constant
when Win32::TaskScheduler::SUNDAY; 'sun'
when Win32::TaskScheduler::MONDAY; 'mon'
when Win32::TaskScheduler::TUESDAY; 'tues'
when Win32::TaskScheduler::WEDNESDAY; 'wed'
when Win32::TaskScheduler::THURSDAY; 'thurs'
when Win32::TaskScheduler::FRIDAY; 'fri'
when Win32::TaskScheduler::SATURDAY; 'sat'
end
end
def day_of_week_name_to_constant(name)
case name
when 'sun'; Win32::TaskScheduler::SUNDAY
when 'mon'; Win32::TaskScheduler::MONDAY
when 'tues'; Win32::TaskScheduler::TUESDAY
when 'wed'; Win32::TaskScheduler::WEDNESDAY
when 'thurs'; Win32::TaskScheduler::THURSDAY
when 'fri'; Win32::TaskScheduler::FRIDAY
when 'sat'; Win32::TaskScheduler::SATURDAY
end
end
def month_constant_to_number(constant)
month_num = 1
while constant >> month_num - 1 > 1
month_num += 1
end
month_num
end
def occurrence_constant_to_name(constant)
case constant
when Win32::TaskScheduler::FIRST_WEEK; 'first'
when Win32::TaskScheduler::SECOND_WEEK; 'second'
when Win32::TaskScheduler::THIRD_WEEK; 'third'
when Win32::TaskScheduler::FOURTH_WEEK; 'fourth'
when Win32::TaskScheduler::LAST_WEEK; 'last'
end
end
def occurrence_name_to_constant(name)
case name
when 'first'; Win32::TaskScheduler::FIRST_WEEK
when 'second'; Win32::TaskScheduler::SECOND_WEEK
when 'third'; Win32::TaskScheduler::THIRD_WEEK
when 'fourth'; Win32::TaskScheduler::FOURTH_WEEK
when 'last'; Win32::TaskScheduler::LAST_WEEK
end
end
end
puppet-3.4.3/lib/puppet/provider/mount/ 0000755 0052762 0001160 00000000000 12300765640 020010 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/mount/parsed.rb 0000644 0052762 0001160 00000007353 12300765631 021623 0 ustar jenkins jenkins require 'puppet/provider/parsedfile'
require 'puppet/provider/mount'
fstab = nil
case Facter.value(:osfamily)
when "Solaris"; fstab = "/etc/vfstab"
else
fstab = "/etc/fstab"
end
Puppet::Type.type(:mount).provide(
:parsed,
:parent => Puppet::Provider::ParsedFile,
:default_target => fstab,
:filetype => :flat
) do
include Puppet::Provider::Mount
commands :mountcmd => "mount", :umount => "umount"
case Facter.value(:osfamily)
when "Solaris"
@fields = [:device, :blockdevice, :name, :fstype, :pass, :atboot, :options]
else
@fields = [:device, :name, :fstype, :options, :dump, :pass]
@fielddefaults = [ nil ] * 4 + [ "0", "2" ]
end
text_line :comment, :match => /^\s*#/
text_line :blank, :match => /^\s*$/
optional_fields = @fields - [:device, :name, :blockdevice]
mandatory_fields = @fields - optional_fields
# fstab will ignore lines that have fewer than the mandatory number of columns,
# so we should, too.
field_pattern = '(\s*(?>\S+))'
text_line :incomplete, :match => /^(?!#{field_pattern}{#{mandatory_fields.length}})/
record_line self.name, :fields => @fields, :separator => /\s+/, :joiner => "\t", :optional => optional_fields
# Every entry in fstab is :unmounted until we can prove different
def self.prefetch_hook(target_records)
target_records.collect do |record|
record[:ensure] = :unmounted if record[:record_type] == :parsed
record
end
end
def self.instances
providers = super
mounts = mountinstances.dup
# Update fstab entries that are mounted
providers.each do |prov|
if mounts.delete({:name => prov.get(:name), :mounted => :yes}) then
prov.set(:ensure => :mounted)
end
end
# Add mounts that are not in fstab but mounted
mounts.each do |mount|
providers << new(:ensure => :ghost, :name => mount[:name])
end
providers
end
def self.prefetch(resources = nil)
# Get providers for all resources the user defined and that match
# a record in /etc/fstab.
super
# We need to do two things now:
# - Update ensure from :unmounted to :mounted if the resource is mounted
# - Check for mounted devices that are not in fstab and
# set ensure to :ghost (if the user wants to add an entry
# to fstab we need to know if the device was mounted before)
mountinstances.each do |hash|
if mount = resources[hash[:name]]
case mount.provider.get(:ensure)
when :absent # Mount not in fstab
mount.provider.set(:ensure => :ghost)
when :unmounted # Mount in fstab
mount.provider.set(:ensure => :mounted)
end
end
end
end
def self.mountinstances
# XXX: Will not work for mount points that have spaces in path (does fstab support this anyways?)
regex = case Facter.value(:osfamily)
when "Darwin"
/ on (?:\/private\/var\/automount)?(\S*)/
when "Solaris", "HP-UX"
/^(\S*) on /
when "AIX"
/^(?:\S*\s+\S+\s+)(\S+)/
else
/ on (\S*)/
end
instances = []
mount_output = mountcmd.split("\n")
if mount_output.length >= 2 and mount_output[1] =~ /^[- \t]*$/
# On some OSes (e.g. AIX) mount output begins with a header line
# followed by a line consisting of dashes and whitespace.
# Discard these two lines.
mount_output[0..1] = []
end
mount_output.each do |line|
if match = regex.match(line) and name = match.captures.first
instances << {:name => name, :mounted => :yes} # Only :name is important here
else
raise Puppet::Error, "Could not understand line #{line} from mount output"
end
end
instances
end
def flush
needs_mount = @property_hash.delete(:needs_mount)
super
mount if needs_mount
end
end
puppet-3.4.3/lib/puppet/provider/port/ 0000755 0052762 0001160 00000000000 12300765640 017632 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/port/parsed.rb 0000644 0052762 0001160 00000012762 12300765631 021445 0 ustar jenkins jenkins require 'puppet/provider/parsedfile'
#services = nil
#case Facter.value(:operatingsystem)
#when "Solaris"; services = "/etc/inet/services"
#else
# services = "/etc/services"
#end
#
#Puppet::Type.type(:port).provide(:parsed,
# :parent => Puppet::Provider::ParsedFile,
# :default_target => services,
# :filetype => :flat
#) do
# text_line :comment, :match => /^\s*#/
# text_line :blank, :match => /^\s*$/
#
# # We're cheating horribly here -- we don't support ddp, because it assigns
# # the same number to already-used names, and the same name to different
# # numbers.
# text_line :ddp, :match => /^\S+\s+\d+\/ddp/
#
# # Also, just ignore the lines on OS X that don't have service names.
# text_line :funky_darwin, :match => /^\s+\d+\//
#
# # We have to manually parse the line, since it's so darn complicated.
# record_line :parsed, :fields => %w{name port protocols alias description},
# :optional => %w{alias description} do |line|
# if line =~ /\/ddp/
# raise "missed ddp in #{line}"
# end
# # The record might contain multiple port lines separated by \n.
# hashes = line.split("\n").collect { |l| parse_port(l) }
#
# # It's easy if there's just one hash.
# if hashes.length == 1
# return hashes.shift
# end
#
# # Else, merge the two records into one.
# return port_merge(*hashes)
# end
#
# # Override how we split into lines, so that we always treat both protocol
# # lines as a single line. This drastically simplifies merging the two lines
# # into one record.
# def self.lines(text)
# names = {}
# lines = []
#
# # We organize by number, because that's apparently how the ports work.
# # You'll never be able to use Puppet to manage multiple entries
# # with the same name but different numbers, though.
# text.split("\n").each do |line|
# if line =~ /^([-\w]+)\s+(\d+)\/[^d]/ # We want to skip ddp proto stuff
# names[$1] ||= []
# names[$1] << line
# lines << [:special, $1]
# else
# lines << line
# end
# end
#
# # Now, return each line in order, but join the ones with the same name
# lines.collect do |line|
# if line.is_a?(Array)
# name = line[1]
# if names[name]
# t = names[name].join("\n")
# names.delete(name)
# t
# end
# else
# line
# end
# end.reject { |l| l.nil? }
# end
#
# # Parse a single port line, returning a hash.
# def self.parse_port(line)
# hash = {}
# if line.sub!(/^(\S+)\s+(\d+)\/(\w+)\s*/, '')
# hash[:name] = $1
# hash[:number] = $2
# hash[:protocols] = [$3]
#
# unless line == ""
# line.sub!(/^([^#]+)\s*/) do |value|
# aliases = $1
#
# # Remove any trailing whitespace
# aliases.strip!
# unless aliases =~ /^\s*$/
# hash[:alias] = aliases.split(/\s+/)
# end
#
# ""
# end
#
# line.sub!(/^\s*#\s*(.+)$/) do |value|
# desc = $1
# unless desc =~ /^\s*$/
# hash[:description] = desc.sub(/\s*$/, '')
# end
#
# ""
# end
# end
# else
# if line =~ /^\s+\d+/ and
# Facter["operatingsystem"].value == "Darwin"
# #Puppet.notice "Skipping wonky OS X port entry %s" %
# # line.inspect
# next
# end
# Puppet.notice "Ignoring unparseable line '#{line}' in #{self.target}"
# end
#
# if hash.empty?
# return nil
# else
# return hash
# end
# end
#
# # Merge two records into one.
# def self.port_merge(one, two)
# keys = [one.keys, two.keys].flatten.uniq
#
# # We'll be returning the 'one' hash. so make any necessary modifications
# # to it.
# keys.each do |key|
# # The easy case
# if one[key] == two[key]
# next
# elsif one[key] and ! two[key]
# next
# elsif ! one[key] and two[key]
# one[key] = two[key]
# elsif one[key].is_a?(Array) and two[key].is_a?(Array)
# one[key] = [one[key], two[key]].flatten.uniq
# else
# # Keep the info from the first hash, so don't do anything
# #Puppet.notice "Cannot merge %s in %s with %s" %
# # [key, one.inspect, two.inspect]
# end
# end
#
# return one
# end
#
# # Convert the current object into one or more services entry.
# def self.to_line(hash)
# unless hash[:record_type] == :parsed
# return super
# end
#
# # Strangely, most sites seem to use tabs as separators.
# hash[:protocols].collect { |proto|
# str = "#{hash[:name]}\t\t#{hash[:number]}/#{proto}"
#
# if value = hash[:alias] and value != :absent
# str += "\t\t#{value.join(" ")}"
# end
#
# if value = hash[:description] and value != :absent
# str += "\t# #{value}"
# end
# str
# }.join("\n")
# end
#end
puppet-3.4.3/lib/puppet/provider/cisco.rb 0000644 0052762 0001160 00000000467 12300765631 020302 0 ustar jenkins jenkins require 'puppet/util/network_device/cisco/device'
require 'puppet/provider/network_device'
# This is the base class of all prefetched cisco device providers
class Puppet::Provider::Cisco < Puppet::Provider::NetworkDevice
def self.device(url)
Puppet::Util::NetworkDevice::Cisco::Device.new(url)
end
end
puppet-3.4.3/lib/puppet/provider/nameservice.rb 0000644 0052762 0001160 00000017331 12300765631 021501 0 ustar jenkins jenkins require 'puppet'
# This is the parent class of all NSS classes. They're very different in
# their backend, but they're pretty similar on the front-end. This class
# provides a way for them all to be as similar as possible.
class Puppet::Provider::NameService < Puppet::Provider
class << self
def autogen_default(param)
defined?(@autogen_defaults) ? @autogen_defaults[param.intern] : nil
end
def autogen_defaults(hash)
@autogen_defaults ||= {}
hash.each do |param, value|
@autogen_defaults[param.intern] = value
end
end
def initvars
@checks = {}
@options = {}
super
end
def instances
objects = []
listbyname do |name|
objects << new(:name => name, :ensure => :present)
end
objects
end
def option(name, option)
name = name.intern if name.is_a? String
(defined?(@options) and @options.include? name and @options[name].include? option) ? @options[name][option] : nil
end
def options(name, hash)
raise Puppet::DevError, "#{name} is not a valid attribute for #{resource_type.name}" unless resource_type.valid_parameter?(name)
@options ||= {}
@options[name] ||= {}
# Set options individually, so we can call the options method
# multiple times.
hash.each do |param, value|
@options[name][param] = value
end
end
# List everything out by name. Abstracted a bit so that it works
# for both users and groups.
def listbyname
names = []
Etc.send("set#{section()}ent")
begin
while ent = Etc.send("get#{section()}ent")
names << ent.name
yield ent.name if block_given?
end
ensure
Etc.send("end#{section()}ent")
end
names
end
def resource_type=(resource_type)
super
@resource_type.validproperties.each do |prop|
next if prop == :ensure
define_method(prop) { get(prop) || :absent} unless public_method_defined?(prop)
define_method(prop.to_s + "=") { |*vals| set(prop, *vals) } unless public_method_defined?(prop.to_s + "=")
end
end
# This is annoying, but there really aren't that many options,
# and this *is* built into Ruby.
def section
unless resource_type
raise Puppet::DevError,
"Cannot determine Etc section without a resource type"
end
if @resource_type.name == :group
"gr"
else
"pw"
end
end
def validate(name, value)
name = name.intern if name.is_a? String
if @checks.include? name
block = @checks[name][:block]
raise ArgumentError, "Invalid value #{value}: #{@checks[name][:error]}" unless block.call(value)
end
end
def verify(name, error, &block)
name = name.intern if name.is_a? String
@checks[name] = {:error => error, :block => block}
end
private
def op(property)
@ops[property.name] || ("-#{property.name}")
end
end
# Autogenerate a value. Mostly used for uid/gid, but also used heavily
# with DirectoryServices, because DirectoryServices is stupid.
def autogen(field)
field = field.intern
id_generators = {:user => :uid, :group => :gid}
if id_generators[@resource.class.name] == field
return self.class.autogen_id(field, @resource.class.name)
else
if value = self.class.autogen_default(field)
return value
elsif respond_to?("autogen_#{field}")
return send("autogen_#{field}")
else
return nil
end
end
end
# Autogenerate either a uid or a gid. This is not very flexible: we can
# only generate one field type per class, and get kind of confused if asked
# for both.
def self.autogen_id(field, resource_type)
# Figure out what sort of value we want to generate.
case resource_type
when :user; database = :passwd; method = :uid
when :group; database = :group; method = :gid
else
raise Puppet::DevError, "Invalid resource name #{resource}"
end
# Initialize from the data set, if needed.
unless @prevauto
# Sadly, Etc doesn't return an enumerator, it just invokes the block
# given, or returns the first record from the database. There is no
# other, more convenient enumerator for these, so we fake one with this
# loop. Thanks, Ruby, for your awesome abstractions. --daniel 2012-03-23
highest = []
Etc.send(database) {|entry| highest << entry.send(method) }
highest = highest.reject {|x| x > 65000 }.max
@prevauto = highest || 1000
end
# ...and finally increment and return the next value.
@prevauto += 1
end
def create
if exists?
info "already exists"
# The object already exists
return nil
end
begin
execute(self.addcmd, {:failonfail => true, :combine => true, :custom_environment => @custom_environment})
if feature?(:manages_password_age) && (cmd = passcmd)
execute(cmd)
end
rescue Puppet::ExecutionFailure => detail
raise Puppet::Error, "Could not create #{@resource.class.name} #{@resource.name}: #{detail}"
end
end
def delete
unless exists?
info "already absent"
# the object already doesn't exist
return nil
end
begin
execute(self.deletecmd)
rescue Puppet::ExecutionFailure => detail
raise Puppet::Error, "Could not delete #{@resource.class.name} #{@resource.name}: #{detail}"
end
end
def ensure
if exists?
:present
else
:absent
end
end
# Does our object exist?
def exists?
!!getinfo(true)
end
# Retrieve a specific value by name.
def get(param)
(hash = getinfo(false)) ? unmunge(param, hash[param]) : nil
end
def munge(name, value)
if block = self.class.option(name, :munge) and block.is_a? Proc
block.call(value)
else
value
end
end
def unmunge(name, value)
if block = self.class.option(name, :unmunge) and block.is_a? Proc
block.call(value)
else
value
end
end
# Retrieve what we can about our object
def getinfo(refresh)
if @objectinfo.nil? or refresh == true
@etcmethod ||= ("get" + self.class.section.to_s + "nam").intern
begin
@objectinfo = Etc.send(@etcmethod, @resource[:name])
rescue ArgumentError
@objectinfo = nil
end
end
# Now convert our Etc struct into a hash.
@objectinfo ? info2hash(@objectinfo) : nil
end
# The list of all groups the user is a member of. Different
# user mgmt systems will need to override this method.
def groups
groups = []
# Reset our group list
Etc.setgrent
user = @resource[:name]
# Now iterate across all of the groups, adding each one our
# user is a member of
while group = Etc.getgrent
members = group.mem
groups << group.name if members.include? user
end
# We have to close the file, so each listing is a separate
# reading of the file.
Etc.endgrent
groups.join(",")
end
# Convert the Etc struct into a hash.
def info2hash(info)
hash = {}
self.class.resource_type.validproperties.each do |param|
method = posixmethod(param)
hash[param] = info.send(posixmethod(param)) if info.respond_to? method
end
hash
end
def initialize(resource)
super
@custom_environment = {}
@objectinfo = nil
end
def set(param, value)
self.class.validate(param, value)
cmd = modifycmd(param, munge(param, value))
raise Puppet::DevError, "Nameservice command must be an array" unless cmd.is_a?(Array)
begin
execute(cmd)
rescue Puppet::ExecutionFailure => detail
raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}"
end
end
end
puppet-3.4.3/lib/puppet/provider/command.rb 0000644 0052762 0001160 00000002077 12300765631 020617 0 ustar jenkins jenkins # A command that can be executed on the system
class Puppet::Provider::Command
attr_reader :executable
attr_reader :name
# @param [String] name A way of referencing the name
# @param [String] executable The path to the executable file
# @param resolver An object for resolving the executable to an absolute path (usually Puppet::Util)
# @param executor An object for performing the actual execution of the command (usually Puppet::Util::Execution)
# @param [Hash] options Extra options to be used when executing (see Puppet::Util::Execution#execute)
def initialize(name, executable, resolver, executor, options = {})
@name = name
@executable = executable
@resolver = resolver
@executor = executor
@options = options
end
# @param args [Array] Any command line arguments to pass to the executable
# @return The output from the command
def execute(*args)
resolved_executable = @resolver.which(@executable) or raise Puppet::Error, "Command #{@name} is missing"
@executor.execute([resolved_executable] + args, @options)
end
end
puppet-3.4.3/lib/puppet/provider/user/ 0000755 0052762 0001160 00000000000 12300765640 017624 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/user/useradd.rb 0000644 0052762 0001160 00000013761 12300765631 021610 0 ustar jenkins jenkins require 'puppet/provider/nameservice/objectadd'
require 'date'
require 'puppet/util/libuser'
require 'time'
require 'puppet/error'
Puppet::Type.type(:user).provide :useradd, :parent => Puppet::Provider::NameService::ObjectAdd do
desc "User management via `useradd` and its ilk. Note that you will need to
install Ruby's shadow password library (often known as `ruby-libshadow`)
if you wish to manage user passwords."
commands :add => "useradd", :delete => "userdel", :modify => "usermod", :password => "chage"
options :home, :flag => "-d", :method => :dir
options :comment, :method => :gecos
options :groups, :flag => "-G"
options :password_min_age, :flag => "-m", :method => :sp_min
options :password_max_age, :flag => "-M", :method => :sp_max
options :password, :method => :sp_pwdp
options :expiry, :method => :sp_expire,
:munge => proc { |value|
if value == :absent
''
else
case Facter.value(:operatingsystem)
when 'Solaris'
# Solaris uses %m/%d/%Y for useradd/usermod
expiry_year, expiry_month, expiry_day = value.split('-')
[expiry_month, expiry_day, expiry_year].join('/')
else
value
end
end
},
:unmunge => proc { |value|
if value == -1
:absent
else
# Expiry is days after 1970-01-01
(Date.new(1970,1,1) + value).strftime('%Y-%m-%d')
end
}
optional_commands :localadd => "luseradd"
has_feature :libuser if Puppet.features.libuser?
def exists?
return !!localuid if @resource.forcelocal?
super
end
def uid
return localuid if @resource.forcelocal?
get(:uid)
end
def finduser(key, value)
passwd_file = "/etc/passwd"
passwd_keys = ['account', 'password', 'uid', 'gid', 'gecos', 'directory', 'shell']
index = passwd_keys.index(key)
File.open(passwd_file) do |f|
f.each_line do |line|
user = line.split(":")
if user[index] == value
f.close
return user
end
end
end
false
end
def local_username
finduser('uid', @resource.uid)
end
def localuid
user = finduser('account', resource[:name])
return user[2] if user
false
end
verify :gid, "GID must be an integer" do |value|
value.is_a? Integer
end
verify :groups, "Groups must be comma-separated" do |value|
value !~ /\s/
end
has_features :manages_homedir, :allows_duplicates, :manages_expiry
has_features :system_users unless %w{HP-UX Solaris}.include? Facter.value(:operatingsystem)
has_features :manages_passwords, :manages_password_age if Puppet.features.libshadow?
def check_allow_dup
# We have to manually check for duplicates when using libuser
# because by default duplicates are allowed. This check is
# to ensure consistent behaviour of the useradd provider when
# using both useradd and luseradd
if not @resource.allowdupe? and @resource.forcelocal?
if @resource.should(:uid) and finduser('uid', @resource.should(:uid).to_s)
raise(Puppet::Error, "UID #{@resource.should(:uid).to_s} already exists, use allowdupe to force user creation")
end
elsif @resource.allowdupe? and not @resource.forcelocal?
return ["-o"]
end
[]
end
def check_manage_home
cmd = []
if @resource.managehome? and not @resource.forcelocal?
cmd << "-m"
elsif not @resource.managehome? and Facter.value(:osfamily) == 'RedHat'
cmd << "-M"
end
cmd
end
def check_manage_expiry
cmd = []
if @resource[:expiry] and not @resource.forcelocal?
cmd << "-e #{@resource[:expiry]}"
end
cmd
end
def check_system_users
if self.class.system_users? and resource.system?
["-r"]
else
[]
end
end
def add_properties
cmd = []
# validproperties is a list of properties in undefined order
# sort them to have a predictable command line in tests
Puppet::Type.type(:user).validproperties.sort.each do |property|
next if property == :ensure
next if property.to_s =~ /password_.+_age/
next if property == :groups and @resource.forcelocal?
next if property == :expiry and @resource.forcelocal?
# the value needs to be quoted, mostly because -c might
# have spaces in it
if value = @resource.should(property) and value != ""
cmd << flag(property) << munge(property, value)
end
end
cmd
end
def addcmd
if @resource.forcelocal?
cmd = [command(:localadd)]
@custom_environment = Puppet::Util::Libuser.getenv
else
cmd = [command(:add)]
end
if not @resource.should(:gid) and Puppet::Util.gid(@resource[:name])
cmd += ["-g", @resource[:name]]
end
cmd += add_properties
cmd += check_allow_dup
cmd += check_manage_home
cmd += check_system_users
cmd << @resource[:name]
end
def deletecmd
if @resource.forcelocal?
cmd = [command(:localdelete)]
else
cmd = [command(:delete)]
end
cmd += @resource.managehome? ? ['-r'] : []
cmd << @resource[:name]
end
def passcmd
age_limits = [:password_min_age, :password_max_age].select { |property| @resource.should(property) }
if age_limits.empty?
nil
else
[command(:password),age_limits.collect { |property| [flag(property), @resource.should(property)]}, @resource[:name]].flatten
end
end
[:expiry, :password_min_age, :password_max_age, :password].each do |shadow_property|
define_method(shadow_property) do
if Puppet.features.libshadow?
if ent = Shadow::Passwd.getspnam(@resource.name)
method = self.class.option(shadow_property, :method)
return unmunge(shadow_property, ent.send(method))
end
end
:absent
end
end
def create
super
if @resource.forcelocal? and self.groups?
set(:groups, @resource[:groups])
end
if @resource.forcelocal? and @resource[:expiry]
set(:expiry, @resource[:expiry])
end
end
def groups?
!!@resource[:groups]
end
end
puppet-3.4.3/lib/puppet/provider/user/windows_adsi.rb 0000644 0052762 0001160 00000004055 12300765631 022647 0 ustar jenkins jenkins require 'puppet/util/adsi'
Puppet::Type.type(:user).provide :windows_adsi do
desc "Local user management for Windows."
defaultfor :operatingsystem => :windows
confine :operatingsystem => :windows
has_features :manages_homedir, :manages_passwords
def user
@user ||= Puppet::Util::ADSI::User.new(@resource[:name])
end
def groups
user.groups.join(',')
end
def groups=(groups)
user.set_groups(groups, @resource[:membership] == :minimum)
end
def create
@user = Puppet::Util::ADSI::User.create(@resource[:name])
@user.password = @resource[:password]
@user.commit
[:comment, :home, :groups].each do |prop|
send("#{prop}=", @resource[prop]) if @resource[prop]
end
if @resource.managehome?
Puppet::Util::Windows::User.load_profile(@resource[:name], @resource[:password])
end
end
def exists?
Puppet::Util::ADSI::User.exists?(@resource[:name])
end
def delete
# lookup sid before we delete account
sid = uid if @resource.managehome?
Puppet::Util::ADSI::User.delete(@resource[:name])
if sid
Puppet::Util::ADSI::UserProfile.delete(sid)
end
end
# Only flush if we created or modified a user, not deleted
def flush
@user.commit if @user
end
def comment
user['Description']
end
def comment=(value)
user['Description'] = value
end
def home
user['HomeDirectory']
end
def home=(value)
user['HomeDirectory'] = value
end
def password
user.password_is?( @resource[:password] ) ? @resource[:password] : :absent
end
def password=(value)
user.password = value
end
def uid
Puppet::Util::Windows::Security.name_to_sid(@resource[:name])
end
def uid=(value)
fail "uid is read-only"
end
[:gid, :shell].each do |prop|
define_method(prop) { nil }
define_method("#{prop}=") do |v|
fail "No support for managing property #{prop} of user #{@resource[:name]} on Windows"
end
end
def self.instances
Puppet::Util::ADSI::User.map { |u| new(:ensure => :present, :name => u.name) }
end
end
puppet-3.4.3/lib/puppet/provider/user/ldap.rb 0000644 0052762 0001160 00000007107 12300765631 021076 0 ustar jenkins jenkins require 'puppet/provider/ldap'
Puppet::Type.type(:user).provide :ldap, :parent => Puppet::Provider::Ldap do
desc "User management via LDAP.
This provider requires that you have valid values for all of the
LDAP-related settings in `puppet.conf`, including `ldapbase`. You will
almost definitely need settings for `ldapuser` and `ldappassword` in order
for your clients to write to LDAP.
Note that this provider will automatically generate a UID for you if
you do not specify one, but it is a potentially expensive operation,
as it iterates across all existing users to pick the appropriate next one."
confine :feature => :ldap, :false => (Puppet[:ldapuser] == "")
has_feature :manages_passwords
manages(:posixAccount, :person).at("ou=People").named_by(:uid).and.maps :name => :uid,
:password => :userPassword,
:comment => :cn,
:uid => :uidNumber,
:gid => :gidNumber,
:home => :homeDirectory,
:shell => :loginShell
# Use the last field of a space-separated array as
# the sn. LDAP requires a surname, for some stupid reason.
manager.generates(:sn).from(:cn).with do |cn|
cn[0].split(/\s+/)[-1]
end
# Find the next uid after the current largest uid.
provider = self
manager.generates(:uidNumber).with do
largest = 500
if existing = provider.manager.search
existing.each do |hash|
next unless value = hash[:uid]
num = value[0].to_i
largest = num if num > largest
end
end
largest + 1
end
# Convert our gid to a group name, if necessary.
def gid=(value)
value = group2id(value) unless [Fixnum, Bignum].include?(value.class)
@property_hash[:gid] = value
end
# Find all groups this user is a member of in ldap.
def groups
# We want to cache the current result, so we know if we
# have to remove old values.
unless @property_hash[:groups]
unless result = group_manager.search("memberUid=#{name}")
return @property_hash[:groups] = :absent
end
return @property_hash[:groups] = result.collect { |r| r[:name] }.sort.join(",")
end
@property_hash[:groups]
end
# Manage the list of groups this user is a member of.
def groups=(values)
should = values.split(",")
if groups == :absent
is = []
else
is = groups.split(",")
end
modes = {}
[is, should].flatten.uniq.each do |group|
# Skip it when they're in both
next if is.include?(group) and should.include?(group)
# We're adding a group.
modes[group] = :add and next unless is.include?(group)
# We're removing a group.
modes[group] = :remove and next unless should.include?(group)
end
modes.each do |group, form|
self.fail "Could not find ldap group #{group}" unless ldap_group = group_manager.find(group)
current = ldap_group[:members]
if form == :add
if current.is_a?(Array) and ! current.empty?
new = current + [name]
else
new = [name]
end
else
new = current - [name]
new = :absent if new.empty?
end
group_manager.update(group, {:ensure => :present, :members => current}, {:ensure => :present, :members => new})
end
end
# Convert a gropu name to an id.
def group2id(group)
Puppet::Type.type(:group).provider(:ldap).name2id(group)
end
private
def group_manager
Puppet::Type.type(:group).provider(:ldap).manager
end
def group_properties(values)
if values.empty? or values == :absent
{:ensure => :present}
else
{:ensure => :present, :members => values}
end
end
end
puppet-3.4.3/lib/puppet/provider/user/aix.rb 0000644 0052762 0001160 00000030060 12300765631 020731 0 ustar jenkins jenkins #
# User Puppet provider for AIX. It uses standard commands to manage users:
# mkuser, rmuser, lsuser, chuser
#
# Notes:
# - AIX users can have expiry date defined with minute granularity,
# but puppet does not allow it. There is a ticket open for that (#5431)
# - AIX maximum password age is in WEEKs, not days
#
# See http://projects.puppetlabs.com/projects/puppet/wiki/Development_Provider_Development
# for more information
#
# Author:: Hector Rivas Gandara
#
require 'puppet/provider/aixobject'
require 'tempfile'
require 'date'
Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
desc "User management for AIX."
# This will the the default provider for this platform
defaultfor :operatingsystem => :aix
confine :operatingsystem => :aix
# Commands that manage the element
commands :list => "/usr/sbin/lsuser"
commands :add => "/usr/bin/mkuser"
commands :delete => "/usr/sbin/rmuser"
commands :modify => "/usr/bin/chuser"
commands :lsgroup => "/usr/sbin/lsgroup"
commands :chpasswd => "/bin/chpasswd"
# Provider features
has_features :manages_aix_lam
has_features :manages_homedir, :manages_passwords
has_features :manages_expiry, :manages_password_age
# Attribute verification (TODO)
#verify :gid, "GID must be a string or int of a valid group" do |value|
# value.is_a? String || value.is_a? Integer
#end
#
#verify :groups, "Groups must be comma-separated" do |value|
# value !~ /\s/
#end
# User attributes to ignore from AIX output.
def self.attribute_ignore
["name"]
end
# AIX attributes to properties mapping.
#
# Valid attributes to be managed by this provider.
# It is a list with of hash
# :aix_attr AIX command attribute name
# :puppet_prop Puppet propertie name
# :to Method to adapt puppet property to aix command value. Optional.
# :from Method to adapt aix command value to puppet property. Optional
self.attribute_mapping = [
{:aix_attr => :pgrp, :puppet_prop => :gid,
:to => :gid_to_attr,
:from => :gid_from_attr },
{:aix_attr => :id, :puppet_prop => :uid},
{:aix_attr => :groups, :puppet_prop => :groups},
{:aix_attr => :home, :puppet_prop => :home},
{:aix_attr => :shell, :puppet_prop => :shell},
{:aix_attr => :expires, :puppet_prop => :expiry,
:to => :expiry_to_attr,
:from => :expiry_from_attr },
{:aix_attr => :maxage, :puppet_prop => :password_max_age},
{:aix_attr => :minage, :puppet_prop => :password_min_age},
{:aix_attr => :attributes, :puppet_prop => :attributes},
{ :aix_attr => :gecos, :puppet_prop => :comment },
]
#--------------
# Command definition
# Return the IA module arguments based on the resource param ia_load_module
def get_ia_module_args
if @resource[:ia_load_module]
["-R", @resource[:ia_load_module].to_s]
else
[]
end
end
# List groups and Ids
def lsgroupscmd(value=@resource[:name])
[command(:lsgroup)] +
self.get_ia_module_args +
["-a", "id", value]
end
def lscmd(value=@resource[:name])
[self.class.command(:list), "-c"] + self.get_ia_module_args + [ value]
end
def lsallcmd()
lscmd("ALL")
end
def addcmd(extra_attrs = [])
# Here we use the @resource.to_hash to get the list of provided parameters
# Puppet does not call to self.= method if it does not exists.
#
# It gets an extra list of arguments to add to the user.
[self.class.command(:add)] + self.get_ia_module_args +
self.hash2args(@resource.to_hash) +
extra_attrs + [@resource[:name]]
end
# Get modify command. Set translate=false if no mapping must be used.
# Needed for special properties like "attributes"
def modifycmd(hash = property_hash)
args = self.hash2args(hash)
return nil if args.empty?
[self.class.command(:modify)] + self.get_ia_module_args +
args + [@resource[:name]]
end
def deletecmd
[self.class.command(:delete)] + self.get_ia_module_args + [@resource[:name]]
end
#--------------
# We overwrite the create function to change the password after creation.
def create
super
# Reset the password if needed
self.password = @resource[:password] if @resource[:password]
end
def get_arguments(key, value, mapping, objectinfo)
# In the case of attributes, return a list of key=vlaue
if key == :attributes
raise Puppet::Error, "Attributes must be a list of pairs key=value on #{@resource.class.name}[#{@resource.name}]" \
unless value and value.is_a? Hash
return value.map { |k,v| k.to_s.strip + "=" + v.to_s.strip}
end
super(key, value, mapping, objectinfo)
end
# Get the groupname from its id
def groupname_by_id(gid)
groupname=nil
execute(lsgroupscmd("ALL")).each_line { |entry|
attrs = self.parse_attr_list(entry, nil)
if attrs and attrs.include? :id and gid == attrs[:id].to_i
groupname = entry.split(" ")[0]
end
}
groupname
end
# Get the groupname from its id
def groupid_by_name(groupname)
attrs = self.parse_attr_list(execute(lsgroupscmd(groupname)).split("\n")[0], nil)
attrs ? attrs[:id].to_i : nil
end
# Check that a group exists and is valid
def verify_group(value)
if value.is_a? Integer or value.is_a? Fixnum
groupname = groupname_by_id(value)
raise ArgumentError, "AIX group must be a valid existing group" unless groupname
else
raise ArgumentError, "AIX group must be a valid existing group" unless groupid_by_name(value)
groupname = value
end
groupname
end
# The user's primary group. Can be specified numerically or by name.
def gid_to_attr(value)
verify_group(value)
end
# Get the group gid from its name
def gid_from_attr(value)
groupid_by_name(value)
end
# The expiry date for this user. Must be provided in
# a zero padded YYYY-MM-DD HH:MM format
def expiry_to_attr(value)
# For chuser the expires parameter is a 10-character string in the MMDDhhmmyy format
# that is,"%m%d%H%M%y"
newdate = '0'
if value.is_a? String and value!="0000-00-00"
d = DateTime.parse(value, "%Y-%m-%d %H:%M")
newdate = d.strftime("%m%d%H%M%y")
end
newdate
end
def expiry_from_attr(value)
if value =~ /(..)(..)(..)(..)(..)/
#d= DateTime.parse("20#{$5}-#{$1}-#{$2} #{$3}:#{$4}")
#expiry_date = d.strftime("%Y-%m-%d %H:%M")
#expiry_date = d.strftime("%Y-%m-%d")
expiry_date = "20#{$5}-#{$1}-#{$2}"
else
Puppet.warn("Could not convert AIX expires date '#{value}' on #{@resource.class.name}[#{@resource.name}]") \
unless value == '0'
expiry_date = :absent
end
expiry_date
end
def open_security_passwd
# helper method for tests
File.open("/etc/security/passwd", 'r')
end
#--------------------------------
# Getter and Setter
# When the provider is initialized, create getter/setter methods for each
# property our resource type supports.
# If setter or getter already defined it will not be overwritten
#- **password**
# The user's password, in whatever encrypted format the local machine
# requires. Be sure to enclose any value that includes a dollar sign ($)
# in single quotes ('). Requires features manages_passwords.
#
# Retrieve the password parsing directly the /etc/security/passwd
def password
password = :absent
user = @resource[:name]
f = open_security_passwd
# Skip to the user
f.each_line { |l| break if l =~ /^#{user}:\s*$/ }
if ! f.eof?
f.each_line { |l|
# If there is a new user stanza, stop
break if l =~ /^\S*:\s*$/
# If the password= entry is found, return it, stripping trailing space
if l =~ /^\s*password\s*=\s*(\S*)\s*$/
password = $1; break;
end
}
end
f.close()
return password
end
def password=(value)
user = @resource[:name]
# Puppet execute does not support strings as input, only files.
tmpfile = Tempfile.new('puppet_#{user}_pw')
tmpfile << "#{user}:#{value}\n"
tmpfile.close()
# Options '-e', '-c', use encrypted password and clear flags
# Must receive "user:enc_password" as input
# command, arguments = {:failonfail => true, :combine => true}
# Fix for bugs #11200 and #10915
cmd = [self.class.command(:chpasswd), get_ia_module_args, '-e', '-c', user].flatten
begin
output = execute(cmd, {:failonfail => false, :combine => true, :stdinfile => tmpfile.path })
# chpasswd can return 1, even on success (at least on AIX 6.1); empty output indicates success
if output != ""
raise Puppet::ExecutionFailure, "chpasswd said #{output}"
end
rescue Puppet::ExecutionFailure => detail
raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}"
ensure
tmpfile.delete()
end
end
def managed_attribute_keys(hash)
managed_attributes ||= @resource.original_parameters[:attributes] || hash.keys.map{|k| k.to_s}
managed_attributes.map {|attr| key, value = attr.split("="); key.strip.to_sym}
end
def should_include?(key, managed_keys)
!self.class.attribute_mapping_from.include?(key) and
!self.class.attribute_ignore.include?(key) and
managed_keys.include?(key)
end
def filter_attributes(hash)
# Return only managed attributtes.
managed_keys = managed_attribute_keys(hash)
results = hash.select {
|k,v| should_include?(k, managed_keys)
}.inject({}) {
|hash, array| hash[array[0]] = array[1]; hash
}
results
end
def attributes
filter_attributes(getosinfo(false))
end
def attributes=(attr_hash)
#self.class.validate(param, value)
param = :attributes
cmd = modifycmd({param => filter_attributes(attr_hash)})
if cmd
begin
execute(cmd)
rescue Puppet::ExecutionFailure => detail
raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}"
end
end
end
# UNSUPPORTED
#- **profile_membership**
# Whether specified roles should be treated as the only roles
# of which the user is a member or whether they should merely
# be treated as the minimum membership list. Valid values are
# `inclusive`, `minimum`.
# UNSUPPORTED
#- **profiles**
# The profiles the user has. Multiple profiles should be
# specified as an array. Requires features manages_solaris_rbac.
# UNSUPPORTED
#- **project**
# The name of the project associated with a user Requires features
# manages_solaris_rbac.
# UNSUPPORTED
#- **role_membership**
# Whether specified roles should be treated as the only roles
# of which the user is a member or whether they should merely
# be treated as the minimum membership list. Valid values are
# `inclusive`, `minimum`.
# UNSUPPORTED
#- **roles**
# The roles the user has. Multiple roles should be
# specified as an array. Requires features manages_solaris_rbac.
# UNSUPPORTED
#- **key_membership**
# Whether specified key value pairs should be treated as the only
# attributes
# of the user or whether they should merely
# be treated as the minimum list. Valid values are `inclusive`,
# `minimum`.
# UNSUPPORTED
#- **keys**
# Specify user attributes in an array of keyvalue pairs Requires features
# manages_solaris_rbac.
# UNSUPPORTED
#- **allowdupe**
# Whether to allow duplicate UIDs. Valid values are `true`, `false`.
# UNSUPPORTED
#- **auths**
# The auths the user has. Multiple auths should be
# specified as an array. Requires features manages_solaris_rbac.
# UNSUPPORTED
#- **auth_membership**
# Whether specified auths should be treated as the only auths
# of which the user is a member or whether they should merely
# be treated as the minimum membership list. Valid values are
# `inclusive`, `minimum`.
# UNSUPPORTED
end
puppet-3.4.3/lib/puppet/provider/user/pw.rb 0000644 0052762 0001160 00000005366 12300765631 020611 0 ustar jenkins jenkins require 'puppet/provider/nameservice/pw'
require 'open3'
Puppet::Type.type(:user).provide :pw, :parent => Puppet::Provider::NameService::PW do
desc "User management via `pw` on FreeBSD and DragonFly BSD."
commands :pw => "pw"
has_features :manages_homedir, :allows_duplicates, :manages_passwords, :manages_expiry
defaultfor :operatingsystem => [:freebsd, :dragonfly]
options :home, :flag => "-d", :method => :dir
options :comment, :method => :gecos
options :groups, :flag => "-G"
options :expiry, :method => :expire, :munge => proc { |value|
value = '0000-00-00' if value == :absent
value.split("-").reverse.join("-")
}
verify :gid, "GID must be an integer" do |value|
value.is_a? Integer
end
verify :groups, "Groups must be comma-separated" do |value|
value !~ /\s/
end
def addcmd
cmd = [command(:pw), "useradd", @resource[:name]]
@resource.class.validproperties.each do |property|
next if property == :ensure or property == :password
if value = @resource.should(property) and value != ""
cmd << flag(property) << munge(property,value)
end
end
cmd << "-o" if @resource.allowdupe?
cmd << "-m" if @resource.managehome?
cmd
end
def modifycmd(param, value)
if param == :expiry
# FreeBSD uses DD-MM-YYYY rather than YYYY-MM-DD
value = value.split("-").reverse.join("-")
end
cmd = super(param, value)
cmd << "-m" if @resource.managehome?
cmd
end
def deletecmd
cmd = super
cmd << "-r" if @resource.managehome?
cmd
end
def create
super
# Set the password after create if given
self.password = @resource[:password] if @resource[:password]
end
# use pw to update password hash
def password=(cryptopw)
Puppet.debug "change password for user '#{@resource[:name]}' method called with hash '#{cryptopw}'"
stdin, stdout, stderr = Open3.popen3("pw user mod #{@resource[:name]} -H 0")
stdin.puts(cryptopw)
stdin.close
Puppet.debug "finished password for user '#{@resource[:name]}' method called with hash '#{cryptopw}'"
end
# get password from /etc/master.passwd
def password
Puppet.debug "checking password for user '#{@resource[:name]}' method called"
current_passline = `getent passwd #{@resource[:name]}`
current_password = current_passline.chomp.split(':')[1] if current_passline
Puppet.debug "finished password for user '#{@resource[:name]}' method called : '#{current_password}'"
current_password
end
# Get expiry from system and convert to Puppet-style date
def expiry
expiry = self.get(:expiry)
expiry = :absent if expiry == 0
if expiry != :absent
t = Time.at(expiry)
expiry = "%4d-%02d-%02d" % [t.year, t.month, t.mday]
end
expiry
end
end
puppet-3.4.3/lib/puppet/provider/user/user_role_add.rb 0000644 0052762 0001160 00000013453 12300765631 022766 0 ustar jenkins jenkins require 'puppet/util'
require 'puppet/util/user_attr'
require 'date'
Puppet::Type.type(:user).provide :user_role_add, :parent => :useradd, :source => :useradd do
desc "User and role management on Solaris, via `useradd` and `roleadd`."
defaultfor :osfamily => :solaris
commands :add => "useradd", :delete => "userdel", :modify => "usermod", :password => "passwd", :role_add => "roleadd", :role_delete => "roledel", :role_modify => "rolemod"
options :home, :flag => "-d", :method => :dir
options :comment, :method => :gecos
options :groups, :flag => "-G"
options :roles, :flag => "-R"
options :auths, :flag => "-A"
options :profiles, :flag => "-P"
options :password_min_age, :flag => "-n"
options :password_max_age, :flag => "-x"
verify :gid, "GID must be an integer" do |value|
value.is_a? Integer
end
verify :groups, "Groups must be comma-separated" do |value|
value !~ /\s/
end
has_features :manages_homedir, :allows_duplicates, :manages_solaris_rbac, :manages_passwords, :manages_password_age
#must override this to hand the keyvalue pairs
def add_properties
cmd = []
Puppet::Type.type(:user).validproperties.each do |property|
#skip the password because we can't create it with the solaris useradd
next if [:ensure, :password, :password_min_age, :password_max_age].include?(property)
# 1680 Now you can set the hashed passwords on solaris:lib/puppet/provider/user/user_role_add.rb
# the value needs to be quoted, mostly because -c might
# have spaces in it
if value = @resource.should(property) and value != ""
if property == :keys
cmd += build_keys_cmd(value)
else
cmd << flag(property) << value
end
end
end
cmd
end
def user_attributes
@user_attributes ||= UserAttr.get_attributes_by_name(@resource[:name])
end
def flush
@user_attributes = nil
end
def command(cmd)
cmd = ("role_#{cmd}").intern if is_role? or (!exists? and @resource[:ensure] == :role)
super(cmd)
end
def is_role?
user_attributes and user_attributes[:type] == "role"
end
def run(cmd, msg)
execute(cmd)
rescue Puppet::ExecutionFailure => detail
raise Puppet::Error, "Could not #{msg} #{@resource.class.name} #{@resource.name}: #{detail}"
end
def transition(type)
cmd = [command(:modify)]
cmd << "-K" << "type=#{type}"
cmd += add_properties
cmd << @resource[:name]
end
def create
if is_role?
run(transition("normal"), "transition role to")
else
run(addcmd, "create")
if cmd = passcmd
run(cmd, "change password policy for")
end
end
# added to handle case when password is specified
self.password = @resource[:password] if @resource[:password]
end
def destroy
run(deletecmd, "delete "+ (is_role? ? "role" : "user"))
end
def create_role
if exists? and !is_role?
run(transition("role"), "transition user to")
else
run(addcmd, "create role")
end
end
def roles
user_attributes[:roles] if user_attributes
end
def auths
user_attributes[:auths] if user_attributes
end
def profiles
user_attributes[:profiles] if user_attributes
end
def project
user_attributes[:project] if user_attributes
end
def managed_attributes
[:name, :type, :roles, :auths, :profiles, :project]
end
def remove_managed_attributes
managed = managed_attributes
user_attributes.select { |k,v| !managed.include?(k) }.inject({}) { |hash, array| hash[array[0]] = array[1]; hash }
end
def keys
if user_attributes
#we have to get rid of all the keys we are managing another way
remove_managed_attributes
end
end
def build_keys_cmd(keys_hash)
cmd = []
keys_hash.each do |k,v|
cmd << "-K" << "#{k}=#{v}"
end
cmd
end
def keys=(keys_hash)
run([command(:modify)] + build_keys_cmd(keys_hash) << @resource[:name], "modify attribute key pairs")
end
# This helper makes it possible to test this on stub data without having to
# do too many crazy things!
def target_file_path
"/etc/shadow"
end
private :target_file_path
#Read in /etc/shadow, find the line for this user (skipping comments, because who knows) and return it
#No abstraction, all esoteric knowledge of file formats, yay
def shadow_entry
return @shadow_entry if defined? @shadow_entry
@shadow_entry = File.readlines(target_file_path).
reject { |r| r =~ /^[^\w]/ }.
collect { |l| l.chomp.split(':') }.
find { |user, _| user == @resource[:name] }
end
def password
shadow_entry[1] if shadow_entry
end
def password_min_age
shadow_entry ? shadow_entry[3] : :absent
end
def password_max_age
return :absent unless shadow_entry
shadow_entry[4] || -1
end
# Read in /etc/shadow, find the line for our used and rewrite it with the
# new pw. Smooth like 80 grit sandpaper.
#
# Now uses the `replace_file` mechanism to minimize the chance that we lose
# data, but it is still terrible. We still skip platform locking, so a
# concurrent `vipw -s` session will have no idea we risk data loss.
def password=(cryptopw)
begin
shadow = File.read(target_file_path)
# Go Mifune loves the race here where we can lose data because
# /etc/shadow changed between reading it and writing it.
# --daniel 2012-02-05
Puppet::Util.replace_file(target_file_path, 0640) do |fh|
shadow.each_line do |line|
line_arr = line.split(':')
if line_arr[0] == @resource[:name]
line_arr[1] = cryptopw
line_arr[2] = (Date.today - Date.new(1970,1,1)).to_i.to_s
line = line_arr.join(':')
end
fh.print line
end
end
rescue => detail
fail "Could not write replace #{target_file_path}: #{detail}"
end
end
end
puppet-3.4.3/lib/puppet/provider/user/directoryservice.rb 0000644 0052762 0001160 00000066561 12300765631 023554 0 ustar jenkins jenkins require 'puppet'
require 'facter/util/plist'
require 'base64'
Puppet::Type.type(:user).provide :directoryservice do
desc "User management on OS X."
## ##
## Provider Settings ##
## ##
# Provider command declarations
commands :uuidgen => '/usr/bin/uuidgen'
commands :dsimport => '/usr/bin/dsimport'
commands :dscl => '/usr/bin/dscl'
commands :plutil => '/usr/bin/plutil'
commands :dscacheutil => '/usr/bin/dscacheutil'
# Provider confines and defaults
confine :operatingsystem => :darwin
defaultfor :operatingsystem => :darwin
# Need this to create getter/setter methods automagically
# This command creates methods that return @property_hash[:value]
mk_resource_methods
# JJM: OS X can manage passwords.
has_feature :manages_passwords
# 10.8 Passwords use a PBKDF2 salt value
has_features :manages_password_salt
## ##
## Class Methods ##
## ##
# This method exists to map the dscl values to the correct Puppet
# properties. This stays relatively consistent, but who knows what
# Apple will do next year...
def self.ds_to_ns_attribute_map
{
'RecordName' => :name,
'PrimaryGroupID' => :gid,
'NFSHomeDirectory' => :home,
'UserShell' => :shell,
'UniqueID' => :uid,
'RealName' => :comment,
'Password' => :password,
'GeneratedUID' => :guid,
'IPAddress' => :ip_address,
'ENetAddress' => :en_address,
'GroupMembership' => :members,
}
end
def self.ns_to_ds_attribute_map
@ns_to_ds_attribute_map ||= ds_to_ns_attribute_map.invert
end
# Prefetching is necessary to use @property_hash inside any setter methods.
# self.prefetch uses self.instances to gather an array of user instances
# on the system, and then populates the @property_hash instance variable
# with attribute data for the specific instance in question (i.e. it
# gathers the 'is' values of the resource into the @property_hash instance
# variable so you don't have to read from the system every time you need
# to gather the 'is' values for a resource. The downside here is that
# populating this instance variable for every resource on the system
# takes time and front-loads your Puppet run.
def self.prefetch(resources)
instances.each do |prov|
if resource = resources[prov.name]
resource.provider = prov
end
end
end
# This method assembles an array of provider instances containing
# information about every instance of the user type on the system (i.e.
# every user and its attributes). The `puppet resource` command relies
# on self.instances to gather an array of user instances in order to
# display its output.
def self.instances
get_all_users.collect do |user|
self.new(generate_attribute_hash(user))
end
end
# Return an array of hashes containing information about every user on
# the system.
def self.get_all_users
Plist.parse_xml(dscl '-plist', '.', 'readall', '/Users')
end
# This method accepts an individual user plist, passed as a hash, and
# strips the dsAttrTypeStandard: prefix that dscl adds for each key.
# An attribute hash is assembled and returned from the properties
# supported by the user type.
def self.generate_attribute_hash(input_hash)
attribute_hash = {}
input_hash.keys.each do |key|
ds_attribute = key.sub("dsAttrTypeStandard:", "")
next unless ds_to_ns_attribute_map.keys.include?(ds_attribute)
ds_value = input_hash[key]
case ds_to_ns_attribute_map[ds_attribute]
when :gid, :uid
# OS X stores objects like uid/gid as strings.
# Try casting to an integer for these cases to be
# consistent with the other providers and the group type
# validation
begin
ds_value = Integer(ds_value[0])
rescue ArgumentError
ds_value = ds_value[0]
end
else ds_value = ds_value[0]
end
attribute_hash[ds_to_ns_attribute_map[ds_attribute]] = ds_value
end
attribute_hash[:ensure] = :present
attribute_hash[:provider] = :directoryservice
attribute_hash[:shadowhashdata] = get_attribute_from_dscl('Users', attribute_hash[:name], 'ShadowHashData')
##############
# Get Groups #
##############
groups_array = []
get_list_of_groups.each do |group|
if group["dsAttrTypeStandard:GroupMembership"] and group["dsAttrTypeStandard:GroupMembership"].include?(attribute_hash[:name])
groups_array << group["dsAttrTypeStandard:RecordName"][0]
end
if group["dsAttrTypeStandard:GroupMembers"] and group["dsAttrTypeStandard:GroupMembers"].include?(attribute_hash[:guid])
groups_array << group["dsAttrTypeStandard:RecordName"][0]
end
end
attribute_hash[:groups] = groups_array.uniq.sort.join(',')
################################
# Get Password/Salt/Iterations #
################################
if (Puppet::Util::Package.versioncmp(get_os_version, '10.7') == -1)
attribute_hash[:password] = get_sha1(attribute_hash[:guid])
else
if attribute_hash[:shadowhashdata].empty?
attribute_hash[:password] = '*'
else
embedded_binary_plist = get_embedded_binary_plist(attribute_hash[:shadowhashdata])
if embedded_binary_plist['SALTED-SHA512']
attribute_hash[:password] = get_salted_sha512(embedded_binary_plist)
else
attribute_hash[:password] = get_salted_sha512_pbkdf2('entropy', embedded_binary_plist)
attribute_hash[:salt] = get_salted_sha512_pbkdf2('salt', embedded_binary_plist)
attribute_hash[:iterations] = get_salted_sha512_pbkdf2('iterations', embedded_binary_plist)
end
end
end
attribute_hash
end
def self.get_os_version
@os_version ||= Facter.value(:macosx_productversion_major)
end
# Use dscl to retrieve an array of hashes containing attributes about all
# of the local groups on the machine.
def self.get_list_of_groups
@groups ||= Plist.parse_xml(dscl '-plist', '.', 'readall', '/Groups')
end
# Perform a dscl lookup at the path specified for the specific keyname
# value. The value returned is the first item within the array returned
# from dscl
def self.get_attribute_from_dscl(path, username, keyname)
Plist.parse_xml(dscl '-plist', '.', 'read', "/#{path}/#{username}", keyname)
end
# The plist embedded in the ShadowHashData key is a binary plist. The
# facter/util/plist library doesn't read binary plists, so we need to
# extract the binary plist, convert it to XML, and return it.
def self.get_embedded_binary_plist(shadow_hash_data)
embedded_binary_plist = Array(shadow_hash_data['dsAttrTypeNative:ShadowHashData'][0].delete(' ')).pack('H*')
convert_binary_to_xml(embedded_binary_plist)
end
# This method will accept a hash that has been returned from Plist::parse_xml
# and convert it to a binary plist (string value).
def self.convert_xml_to_binary(plist_data)
Puppet.debug('Converting XML plist to binary')
Puppet.debug('Executing: \'plutil -convert binary1 -o - -\'')
IO.popen('plutil -convert binary1 -o - -', 'r+') do |io|
io.write Plist::Emit.dump(plist_data)
io.close_write
@converted_plist = io.read
end
@converted_plist
end
# This method will accept a binary plist (as a string) and convert it to a
# hash via Plist::parse_xml.
def self.convert_binary_to_xml(plist_data)
Puppet.debug('Converting binary plist to XML')
Puppet.debug('Executing: \'plutil -convert xml1 -o - -\'')
IO.popen('plutil -convert xml1 -o - -', 'r+') do |io|
io.write plist_data
io.close_write
@converted_plist = io.read
end
Puppet.debug('Converting XML values to a hash.')
Plist::parse_xml(@converted_plist)
end
# The salted-SHA512 password hash in 10.7 is stored in the 'SALTED-SHA512'
# key as binary data. That data is extracted and converted to a hex string.
def self.get_salted_sha512(embedded_binary_plist)
embedded_binary_plist['SALTED-SHA512'].string.unpack("H*")[0]
end
# This method reads the passed embedded_binary_plist hash and returns values
# according to which field is passed. Arguments passed are the hash
# containing the value read from the 'ShadowHashData' key in the User's
# plist, and the field to be read (one of 'entropy', 'salt', or 'iterations')
def self.get_salted_sha512_pbkdf2(field, embedded_binary_plist)
case field
when 'salt', 'entropy'
embedded_binary_plist['SALTED-SHA512-PBKDF2'][field].string.unpack('H*').first
when 'iterations'
Integer(embedded_binary_plist['SALTED-SHA512-PBKDF2'][field])
else
raise Puppet::Error, 'Puppet has tried to read an incorrect value from the ' +
"SALTED-SHA512-PBKDF2 hash. Acceptable fields are 'salt', " +
"'entropy', or 'iterations'."
end
end
# In versions 10.5 and 10.6 of OS X, the password hash is stored in a file
# in the /var/db/shadow/hash directory that matches the GUID of the user.
def self.get_sha1(guid)
password_hash = nil
password_hash_file = "#{password_hash_dir}/#{guid}"
if Puppet::FileSystem::File.exist?(password_hash_file) and File.file?(password_hash_file)
raise Puppet::Error, "Could not read password hash file at #{password_hash_file}" if not File.readable?(password_hash_file)
f = File.new(password_hash_file)
password_hash = f.read
f.close
end
password_hash
end
## ##
## Ensurable Methods ##
## ##
def exists?
begin
dscl '.', 'read', "/Users/#{@resource.name}"
rescue Puppet::ExecutionFailure => e
Puppet.debug("User was not found, dscl returned: #{e.inspect}")
return false
end
true
end
# This method is called if ensure => present is passed and the exists?
# method returns false. Dscl will directly set most values, but the
# setter methods will be used for any exceptions.
def create
create_new_user(@resource.name)
# Retrieve the user's GUID
@guid = self.class.get_attribute_from_dscl('Users', @resource.name, 'GeneratedUID')['dsAttrTypeStandard:GeneratedUID'][0]
# Get an array of valid User type properties
valid_properties = Puppet::Type.type('User').validproperties
# Iterate through valid User type properties
valid_properties.each do |attribute|
next if attribute == :ensure
value = @resource.should(attribute)
# Value defaults
if value.nil?
value = case attribute
when :gid
'20'
when :uid
next_system_id
when :comment
@resource.name
when :shell
'/bin/bash'
when :home
"/Users/#{@resource.name}"
else
nil
end
end
# Ensure group names are converted to integers.
value = Puppet::Util.gid(value) if attribute == :gid
## Set values ##
# For the :password and :groups properties, call the setter methods
# to enforce those values. For everything else, use dscl with the
# ns_to_ds_attribute_map to set the appropriate values.
if value != "" and not value.nil?
case attribute
when :password
self.password = value
when :iterations
self.iterations = value
when :salt
self.salt = value
when :groups
value.split(',').each do |group|
merge_attribute_with_dscl('Groups', group, 'GroupMembership', @resource.name)
merge_attribute_with_dscl('Groups', group, 'GroupMembers', @guid)
end
else
merge_attribute_with_dscl('Users', @resource.name, self.class.ns_to_ds_attribute_map[attribute], value)
end
end
end
end
# This method is called when ensure => absent has been set.
# Deleting a user is handled by dscl
def delete
dscl '.', '-delete', "/Users/#{@resource.name}"
end
## ##
## Getter/Setter Methods ##
## ##
# In the setter method we're only going to take action on groups for which
# the user is not currently a member.
def groups=(value)
guid = self.class.get_attribute_from_dscl('Users', @resource.name, 'GeneratedUID')['dsAttrTypeStandard:GeneratedUID'][0]
groups_to_add = value.split(',') - groups.split(',')
groups_to_add.each do |group|
merge_attribute_with_dscl('Groups', group, 'GroupMembership', @resource.name)
merge_attribute_with_dscl('Groups', group, 'GroupMembers', guid)
end
end
# If you thought GETTING a password was bad, try SETTING it. This method
# makes me want to cry. A thousand tears...
#
# I've been unsuccessful in tracking down a way to set the password for
# a user using dscl that DOESN'T require passing it as plaintext. We were
# also unable to get dsimport to work like this. Due to these downfalls,
# the sanest method requires opening the user's plist, dropping in the
# password hash, and serializing it back to disk. The problems with THIS
# method revolve around dscl. Any time you directly modify a user's plist,
# you need to flush the cache that dscl maintains.
def password=(value)
if (Puppet::Util::Package.versioncmp(self.class.get_os_version, '10.7') == -1)
write_sha1_hash(value)
else
if self.class.get_os_version == '10.7'
if value.length != 136
raise Puppet::Error, "OS X 10.7 requires a Salted SHA512 hash password of 136 characters. Please check your password and try again."
end
else
if value.length != 256
raise Puppet::Error, "OS X versions > 10.7 require a Salted SHA512 PBKDF2 password hash of 256 characters. Please check your password and try again."
end
end
# Methods around setting the password on OS X are the ONLY methods that
# cannot use dscl (because the only way to set it via dscl is by passing
# a plaintext password - which is bad). Because of this, we have to change
# the user's plist directly. DSCL has its own caching mechanism, which
# means that every time we call dscl in this provider we're not directly
# changing values on disk (instead, those calls are cached and written
# to disk according to Apple's prioritization algorithms). When Puppet
# needs to set the password property on OS X > 10.6, the provider has to
# tell dscl to write its cache to disk before modifying the user's
# plist. The 'dscacheutil -flushcache' command does this. Another issue
# is how fast Puppet makes calls to dscl and how long it takes dscl to
# enter those calls into its cache. We have to sleep for 2 seconds before
# flushing the dscl cache to allow all dscl calls to get INTO the cache
# first. This could be made faster (and avoid a sleep call) by finding
# a way to enter calls into the dscl cache faster. A sleep time of 1
# second would intermittantly require a second Puppet run to set
# properties, so 2 seconds seems to be the minimum working value.
sleep 2
flush_dscl_cache
write_password_to_users_plist(value)
# Since we just modified the user's plist, we need to flush the ds cache
# again so dscl can pick up on the changes we made.
flush_dscl_cache
end
end
# The iterations and salt properties, like the password property, can only
# be modified by directly changing the user's plist. Because of this fact,
# we have to treat the ds cache just like you would in the password=
# method.
def iterations=(value)
if (Puppet::Util::Package.versioncmp(self.class.get_os_version, '10.7') > 0)
sleep 2
flush_dscl_cache
users_plist = get_users_plist(@resource.name)
shadow_hash_data = get_shadow_hash_data(users_plist)
set_salted_pbkdf2(users_plist, shadow_hash_data, 'iterations', value)
flush_dscl_cache
end
end
# The iterations and salt properties, like the password property, can only
# be modified by directly changing the user's plist. Because of this fact,
# we have to treat the ds cache just like you would in the password=
# method.
def salt=(value)
if (Puppet::Util::Package.versioncmp(self.class.get_os_version, '10.7') > 0)
sleep 2
flush_dscl_cache
users_plist = get_users_plist(@resource.name)
shadow_hash_data = get_shadow_hash_data(users_plist)
set_salted_pbkdf2(users_plist, shadow_hash_data, 'salt', value)
flush_dscl_cache
end
end
#####
# Dynamically create setter methods for dscl properties
#####
#
# Setter methods are only called when a resource currently has a value for
# that property and it needs changed (true here since all of these values
# have a default that is set in the create method). We don't want to merge
# in additional values if an incorrect value is set, we want to CHANGE it.
# When using the -change argument in dscl, the old value needs to be passed
# first (followed by the new value). Because of this, we get the current
# value from the @property_hash variable and then use the value passed as
# the new value. Because we're prefetching instances of the provider, it's
# possible that the value determined at the start of the run may be stale
# (i.e. someone changed the value by hand during a Puppet run) - if that's
# the case we rescue the error from dscl and alert the user.
#
# In the event that the user doesn't HAVE a value for the attribute, the
# provider should use the -merge option with dscl to add the attribute value
# for the user record
['home', 'uid', 'gid', 'comment', 'shell'].each do |setter_method|
define_method("#{setter_method}=") do |value|
if @property_hash[setter_method.intern]
begin
dscl '.', '-change', "/Users/#{resource.name}", self.class.ns_to_ds_attribute_map[setter_method.intern], @property_hash[setter_method.intern], value
rescue Puppet::ExecutionFailure => e
raise Puppet::Error, "Cannot set the #{setter_method} value of '#{value}' for user " +
"#{@resource.name} due to the following error: #{e.inspect}"
end
else
begin
dscl '.', '-merge', "/Users/#{resource.name}", self.class.ns_to_ds_attribute_map[setter_method.intern], value
rescue Puppet::ExecutionFailure => e
raise Puppet::Error, "Cannot set the #{setter_method} value of '#{value}' for user " +
"#{@resource.name} due to the following error: #{e.inspect}"
end
end
end
end
## ##
## Helper Methods ##
## ##
def users_plist_dir
'/var/db/dslocal/nodes/Default/users'
end
def self.password_hash_dir
'/var/db/shadow/hash'
end
# This method will merge in a given value using dscl
def merge_attribute_with_dscl(path, username, keyname, value)
begin
dscl '.', '-merge', "/#{path}/#{username}", keyname, value
rescue Puppet::ExecutionFailure => detail
raise Puppet::Error, "Could not set the dscl #{keyname} key with value: #{value} - #{detail.inspect}"
end
end
# Create the new user with dscl
def create_new_user(username)
dscl '.', '-create', "/Users/#{username}"
end
# Get the next available uid on the system by getting a list of user ids,
# sorting them, grabbing the last one, and adding a 1. Scientific stuff here.
def next_system_id(min_id=20)
dscl_output = dscl '.', '-list', '/Users', 'uid'
# We're ok with throwing away negative uids here. Also, remove nil values.
user_ids = dscl_output.split.compact.collect { |l| l.to_i if l.match(/^\d+$/) }
ids = user_ids.compact!.sort! { |a,b| a.to_f <=> b.to_f }
# We're just looking for an unused id in our sorted array.
ids.each_index do |i|
next_id = ids[i] + 1
return next_id if ids[i+1] != next_id and next_id >= min_id
end
end
# This method is only called on version 10.7 or greater. On 10.7 machines,
# passwords are set using a salted-SHA512 hash, and on 10.8 machines,
# passwords are set using PBKDF2. It's possible to have users on 10.8
# who have upgraded from 10.7 and thus have a salted-SHA512 password hash.
# If we encounter this, do what 10.8 does - remove that key and give them
# a 10.8-style PBKDF2 password.
def write_password_to_users_plist(value)
users_plist = get_users_plist(@resource.name)
shadow_hash_data = get_shadow_hash_data(users_plist)
if self.class.get_os_version == '10.7'
set_salted_sha512(users_plist, shadow_hash_data, value)
else
# It's possible that a user could exist on the system and NOT have
# a ShadowHashData key (especially if the system was upgraded from 10.6).
# In this case, a conditional check is needed to determine if the
# shadow_hash_data variable is a Hash (it would be false if the key
# didn't exist for this user on the system). If the shadow_hash_data
# variable IS a Hash and contains the 'SALTED-SHA512' key (indicating an
# older 10.7-style password hash), it will be deleted and a newer
# 10.8-style (PBKDF2) password hash will be generated.
if (shadow_hash_data.class == Hash) && (shadow_hash_data.has_key?('SALTED-SHA512'))
shadow_hash_data.delete('SALTED-SHA512')
end
set_salted_pbkdf2(users_plist, shadow_hash_data, 'entropy', value)
end
end
def flush_dscl_cache
dscacheutil '-flushcache'
end
def get_users_plist(username)
# This method will retrieve the data stored in a user's plist and
# return it as a native Ruby hash.
Plist::parse_xml(plutil('-convert', 'xml1', '-o', '/dev/stdout', "#{users_plist_dir}/#{username}.plist"))
end
# This method will return the binary plist that's embedded in the
# ShadowHashData key of a user's plist, or false if it doesn't exist.
def get_shadow_hash_data(users_plist)
if users_plist['ShadowHashData']
password_hash_plist = users_plist['ShadowHashData'][0].string
self.class.convert_binary_to_xml(password_hash_plist)
else
false
end
end
# This method will embed the binary plist data comprising the user's
# password hash (and Salt/Iterations value if the OS is 10.8 or greater)
# into the ShadowHashData key of the user's plist.
def set_shadow_hash_data(users_plist, binary_plist)
if users_plist.has_key?('ShadowHashData')
users_plist['ShadowHashData'][0].string = binary_plist
else
users_plist['ShadowHashData'] = [new_stringio_object(binary_plist)]
end
write_users_plist_to_disk(users_plist)
end
# This method returns a new StringIO object. Why does it exist?
# Well, StringIO objects have their own 'serial number', so when
# writing rspec tests it's difficult to compare StringIO objects
# due to this serial number. If this action is wrapped in its own
# method, it can be mocked for easier testing.
def new_stringio_object(value = '')
StringIO.new(value)
end
# This method accepts an argument of a hex password hash, and base64
# decodes it into a format that OS X 10.7 and 10.8 will store
# in the user's plist.
def base64_decode_string(value)
Base64.decode64([[value].pack("H*")].pack("m").strip)
end
# Puppet requires a salted-sha512 password hash for 10.7 users to be passed
# in Hex, but the embedded plist stores that value as a Base64 encoded
# string. This method converts the string and calls the
# set_shadow_hash_data method to serialize and write the plist to disk.
def set_salted_sha512(users_plist, shadow_hash_data, value)
unless shadow_hash_data
shadow_hash_data = Hash.new
shadow_hash_data['SALTED-SHA512'] = new_stringio_object
end
shadow_hash_data['SALTED-SHA512'].string = base64_decode_string(value)
binary_plist = self.class.convert_xml_to_binary(shadow_hash_data)
set_shadow_hash_data(users_plist, binary_plist)
end
# This method accepts a passed value and one of three fields: 'salt',
# 'entropy', or 'iterations'. These fields correspond with the fields
# utilized in a PBKDF2 password hashing system
# (see http://en.wikipedia.org/wiki/PBKDF2 ) where 'entropy' is the
# password hash, 'salt' is the password hash salt value, and 'iterations'
# is an integer recommended to be > 10,000. The remaining arguments are
# the user's plist itself, and the shadow_hash_data hash containing the
# existing PBKDF2 values.
def set_salted_pbkdf2(users_plist, shadow_hash_data, field, value)
shadow_hash_data = Hash.new unless shadow_hash_data
shadow_hash_data['SALTED-SHA512-PBKDF2'] = Hash.new unless shadow_hash_data['SALTED-SHA512-PBKDF2']
case field
when 'salt', 'entropy'
shadow_hash_data['SALTED-SHA512-PBKDF2'][field] = new_stringio_object unless shadow_hash_data['SALTED-SHA512-PBKDF2'][field]
shadow_hash_data['SALTED-SHA512-PBKDF2'][field].string = base64_decode_string(value)
when 'iterations'
shadow_hash_data['SALTED-SHA512-PBKDF2'][field] = Integer(value)
else
raise Puppet::Error "Puppet has tried to set an incorrect field for the 'SALTED-SHA512-PBKDF2' hash. Acceptable fields are 'salt', 'entropy', or 'iterations'."
end
# on 10.8, this field *must* contain 8 stars, or authentication will
# fail.
users_plist['passwd'] = ('*' * 8)
# Convert shadow_hash_data to a binary plist, and call the
# set_shadow_hash_data method to serialize and write the data
# back to the user's plist.
binary_plist = self.class.convert_xml_to_binary(shadow_hash_data)
set_shadow_hash_data(users_plist, binary_plist)
end
# This method will accept a plist in XML format, save it to disk, convert
# the plist to a binary format, and flush the dscl cache.
def write_users_plist_to_disk(users_plist)
Plist::Emit.save_plist(users_plist, "#{users_plist_dir}/#{@resource.name}.plist")
plutil'-convert', 'binary1', "#{users_plist_dir}/#{@resource.name}.plist"
end
# This is a simple wrapper method for writing values to a file.
def write_to_file(filename, value)
begin
File.open(filename, 'w') { |f| f.write(value)}
rescue Errno::EACCES => detail
raise Puppet::Error, "Could not write to file #{filename}: #{detail}"
end
end
def write_sha1_hash(value)
users_guid = self.class.get_attribute_from_dscl('Users', @resource.name, 'GeneratedUID')['dsAttrTypeStandard:GeneratedUID'][0]
password_hash_file = "#{self.class.password_hash_dir}/#{users_guid}"
write_to_file(password_hash_file, value)
# NBK: For shadow hashes, the user AuthenticationAuthority must contain a value of
# ";ShadowHash;". The LKDC in 10.5 makes this more interesting though as it
# will dynamically generate ;Kerberosv5;;username@LKDC:SHA1 attributes if
# missing. Thus we make sure we only set ;ShadowHash; if it is missing, and
# we can do this with the merge command. This allows people to continue to
# use other custom AuthenticationAuthority attributes without stomping on them.
#
# There is a potential problem here in that we're only doing this when setting
# the password, and the attribute could get modified at other times while the
# hash doesn't change and so this doesn't get called at all... but
# without switching all the other attributes to merge instead of create I can't
# see a simple enough solution for this that doesn't modify the user record
# every single time. This should be a rather rare edge case. (famous last words)
merge_attribute_with_dscl('Users', @resource.name, 'AuthenticationAuthority', ';ShadowHash;')
end
end
puppet-3.4.3/lib/puppet/provider/user/hpux.rb 0000644 0052762 0001160 00000003606 12300765631 021142 0 ustar jenkins jenkins Puppet::Type.type(:user).provide :hpuxuseradd, :parent => :useradd do
desc "User management for HP-UX. This provider uses the undocumented `-F`
switch to HP-UX's special `usermod` binary to work around the fact that
its standard `usermod` cannot make changes while the user is logged in."
defaultfor :operatingsystem => "hp-ux"
confine :operatingsystem => "hp-ux"
commands :modify => "/usr/sam/lbin/usermod.sam", :delete => "/usr/sam/lbin/userdel.sam", :add => "/usr/sam/lbin/useradd.sam"
options :comment, :method => :gecos
options :groups, :flag => "-G"
options :home, :flag => "-d", :method => :dir
verify :gid, "GID must be an integer" do |value|
value.is_a? Integer
end
verify :groups, "Groups must be comma-separated" do |value|
value !~ /\s/
end
has_features :manages_homedir, :allows_duplicates, :manages_passwords
def deletecmd
super.insert(1,"-F")
end
def modifycmd(param,value)
super.insert(1,"-F")
end
def password
# Password management routine for trusted and non-trusted systems
#temp=""
while ent = Etc.getpwent() do
if ent.name == resource.name
temp=ent.name
break
end
end
Etc.endpwent()
if !temp
return nil
end
ent = Etc.getpwnam(resource.name)
if ent.passwd == "*"
# Either no password or trusted password, check trusted
file_name="/tcb/files/auth/#{resource.name.chars.first}/#{resource.name}"
if File.file?(file_name)
# Found the tcb user for the specific user, now get passwd
File.open(file_name).each do |line|
if ( line =~ /u_pwd/ )
temp_passwd=line.split(":")[1].split("=")[1]
ent.passwd = temp_passwd
return ent.passwd
end
end
else
debug "No trusted computing user file #{file_name} found."
end
else
return ent.passwd
end
end
end
puppet-3.4.3/lib/puppet/provider/service/ 0000755 0052762 0001160 00000000000 12300765640 020306 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/service/launchd.rb 0000644 0052762 0001160 00000027530 12300765631 022260 0 ustar jenkins jenkins require 'facter/util/plist'
Puppet::Type.type(:service).provide :launchd, :parent => :base do
desc <<-'EOT'
This provider manages jobs with `launchd`, which is the default service
framework for Mac OS X (and may be available for use on other platforms).
For `launchd` documentation, see:
*
*
Puppet::Type.type(:service).provide :daemontools, :parent => :base do
desc <<-'EOT'
Daemontools service management.
This provider manages daemons supervised by D.J. Bernstein daemontools.
When detecting the service directory it will check, in order of preference:
* `/service`
* `/etc/service`
* `/var/lib/svscan`
The daemon directory should be in one of the following locations:
* `/var/lib/service`
* `/etc`
...or this can be overriden in the resource's attributes:
service { "myservice":
provider => "daemontools",
path => "/path/to/daemons",
}
This provider supports out of the box:
* start/stop (mapped to enable/disable)
* enable/disable
* restart
* status
If a service has `ensure => "running"`, it will link /path/to/daemon to
/path/to/service, which will automatically enable the service.
If a service has `ensure => "stopped"`, it will only shut down the service, not
remove the `/path/to/service` link.
EOT
commands :svc => "/usr/bin/svc", :svstat => "/usr/bin/svstat"
class << self
attr_writer :defpath
# Determine the daemon path.
def defpath(dummy_argument=:work_arround_for_ruby_GC_bug)
unless @defpath
["/var/lib/service", "/etc"].each do |path|
if Puppet::FileSystem::File.exist?(path)
@defpath = path
break
end
end
raise "Could not find the daemon directory (tested [/var/lib/service,/etc])" unless @defpath
end
@defpath
end
end
attr_writer :servicedir
# returns all providers for all existing services in @defpath
# ie enabled or not
def self.instances
path = self.defpath
unless FileTest.directory?(path)
Puppet.notice "Service path #{path} does not exist"
return
end
# reject entries that aren't either a directory
# or don't contain a run file
Dir.entries(path).reject { |e|
fullpath = File.join(path, e)
e =~ /^\./ or ! FileTest.directory?(fullpath) or ! Puppet::FileSystem::File.exist?(File.join(fullpath,"run"))
}.collect do |name|
new(:name => name, :path => path)
end
end
# returns the daemon dir on this node
def self.daemondir
self.defpath
end
# find the service dir on this node
def servicedir
unless @servicedir
["/service", "/etc/service","/var/lib/svscan"].each do |path|
if Puppet::FileSystem::File.exist?(path)
@servicedir = path
break
end
end
raise "Could not find service directory" unless @servicedir
end
@servicedir
end
# returns the full path of this service when enabled
# (ie in the service directory)
def service
File.join(self.servicedir, resource[:name])
end
# returns the full path to the current daemon directory
# note that this path can be overriden in the resource
# definition
def daemon
File.join(resource[:path], resource[:name])
end
def status
begin
output = svstat self.service
if output =~ /:\s+up \(/
return :running
end
rescue Puppet::ExecutionFailure => detail
raise Puppet::Error.new( "Could not get status for service #{resource.ref}: #{detail}" )
end
:stopped
end
def setupservice
if resource[:manifest]
Puppet.notice "Configuring #{resource[:name]}"
command = [ resource[:manifest], resource[:name] ]
#texecute("setupservice", command)
system("#{command}")
end
rescue Puppet::ExecutionFailure => detail
raise Puppet::Error.new( "Cannot config #{self.service} to enable it: #{detail}" )
end
def enabled?
case self.status
when :running
# obviously if the daemon is running then it is enabled
return :true
else
# the service is enabled if it is linked
return Puppet::FileSystem::File.new(self.service).symlink? ? :true : :false
end
end
def enable
if ! FileTest.directory?(self.daemon)
Puppet.notice "No daemon dir, calling setupservice for #{resource[:name]}"
self.setupservice
end
if self.daemon
if ! Puppet::FileSystem::File.new(self.service).symlink?
Puppet.notice "Enabling #{self.service}: linking #{self.daemon} -> #{self.service}"
Puppet::FileSystem::File.new(self.daemon).symlink(self.service)
end
end
rescue Puppet::ExecutionFailure
raise Puppet::Error.new( "No daemon directory found for #{self.service}")
end
def disable
begin
if ! FileTest.directory?(self.daemon)
Puppet.notice "No daemon dir, calling setupservice for #{resource[:name]}"
self.setupservice
end
if self.daemon
if Puppet::FileSystem::File.new(self.service).symlink?
Puppet.notice "Disabling #{self.service}: removing link #{self.daemon} -> #{self.service}"
Puppet::FileSystem::File.unlink(self.service)
end
end
rescue Puppet::ExecutionFailure
raise Puppet::Error.new( "No daemon directory found for #{self.service}")
end
self.stop
end
def restart
svc "-t", self.service
end
def start
enable unless enabled? == :true
svc "-u", self.service
end
def stop
svc "-d", self.service
end
end
puppet-3.4.3/lib/puppet/provider/service/gentoo.rb 0000644 0052762 0001160 00000002212 12300765631 022123 0 ustar jenkins jenkins # Manage gentoo services. Start/stop is the same as InitSvc, but enable/disable
# is special.
Puppet::Type.type(:service).provide :gentoo, :parent => :init do
desc <<-EOT
Gentoo's form of `init`-style service management.
Uses `rc-update` for service enabling and disabling.
EOT
commands :update => "/sbin/rc-update"
confine :operatingsystem => :gentoo
def disable
output = update :del, @resource[:name], :default
rescue Puppet::ExecutionFailure
raise Puppet::Error, "Could not disable #{self.name}: #{output}"
end
def enabled?
begin
output = update :show
rescue Puppet::ExecutionFailure
return :false
end
line = output.split(/\n/).find { |l| l.include?(@resource[:name]) }
return :false unless line
# If it's enabled then it will print output showing service | runlevel
if output =~ /^\s*#{@resource[:name]}\s*\|\s*(boot|default)/
return :true
else
return :false
end
end
def enable
output = update :add, @resource[:name], :default
rescue Puppet::ExecutionFailure
raise Puppet::Error, "Could not enable #{self.name}: #{output}"
end
end
puppet-3.4.3/lib/puppet/provider/service/systemd.rb 0000644 0052762 0001160 00000003030 12300765631 022317 0 ustar jenkins jenkins # Manage systemd services using /bin/systemctl
Puppet::Type.type(:service).provide :systemd, :parent => :base do
desc "Manages `systemd` services using `systemctl`."
commands :systemctl => "systemctl"
#defaultfor :osfamily => [:redhat, :suse]
defaultfor :osfamily => [:archlinux]
def self.instances
i = []
output = systemctl('list-units', '--full', '--all', '--no-pager')
output.scan(/^(\S+)\s+(loaded|error)\s+(active|inactive)\s+(active|waiting|running|plugged|mounted|dead|exited|listening|elapsed)\s*?(\S.*?)?$/i).each do |m|
i << new(:name => m[0])
end
return i
rescue Puppet::ExecutionFailure
return []
end
def disable
output = systemctl(:disable, @resource[:name])
rescue Puppet::ExecutionFailure
raise Puppet::Error, "Could not disable #{self.name}: #{output}"
end
def enabled?
begin
systemctl("is-enabled", @resource[:name])
rescue Puppet::ExecutionFailure
return :false
end
:true
end
def status
begin
systemctl("is-active", @resource[:name])
rescue Puppet::ExecutionFailure
return :stopped
end
return :running
end
def enable
output = systemctl("enable", @resource[:name])
rescue Puppet::ExecutionFailure
raise Puppet::Error, "Could not enable #{self.name}: #{output}"
end
def restartcmd
[command(:systemctl), "restart", @resource[:name]]
end
def startcmd
[command(:systemctl), "start", @resource[:name]]
end
def stopcmd
[command(:systemctl), "stop", @resource[:name]]
end
end
puppet-3.4.3/lib/puppet/provider/service/base.rb 0000644 0052762 0001160 00000006112 12300765631 021545 0 ustar jenkins jenkins Puppet::Type.type(:service).provide :base, :parent => :service do
desc "The simplest form of Unix service support.
You have to specify enough about your service for this to work; the
minimum you can specify is a binary for starting the process, and this
same binary will be searched for in the process table to stop the
service. As with `init`-style services, it is preferable to specify start,
stop, and status commands.
"
commands :kill => "kill"
# Get the process ID for a running process. Requires the 'pattern'
# parameter.
def getpid
@resource.fail "Either stop/status commands or a pattern must be specified" unless @resource[:pattern]
ps = Facter["ps"].value
@resource.fail "You must upgrade Facter to a version that includes 'ps'" unless ps and ps != ""
regex = Regexp.new(@resource[:pattern])
self.debug "Executing '#{ps}'"
IO.popen(ps) { |table|
table.each_line { |line|
if regex.match(line)
self.debug "Process matched: #{line}"
ary = line.sub(/^\s+/, '').split(/\s+/)
return ary[1]
end
}
}
nil
end
# Check if the process is running. Prefer the 'status' parameter,
# then 'statuscmd' method, then look in the process table. We give
# the object the option to not return a status command, which might
# happen if, for instance, it has an init script (and thus responds to
# 'statuscmd') but does not have 'hasstatus' enabled.
def status
if @resource[:status] or statuscmd
# Don't fail when the exit status is not 0.
ucommand(:status, false)
# Expicitly calling exitstatus to facilitate testing
if $CHILD_STATUS.exitstatus == 0
return :running
else
return :stopped
end
elsif pid = self.getpid
self.debug "PID is #{pid}"
return :running
else
return :stopped
end
end
# There is no default command, which causes other methods to be used
def statuscmd
end
# Run the 'start' parameter command, or the specified 'startcmd'.
def start
ucommand(:start)
end
# The command used to start. Generated if the 'binary' argument
# is passed.
def startcmd
if @resource[:binary]
return @resource[:binary]
else
raise Puppet::Error,
"Services must specify a start command or a binary"
end
end
# Stop the service. If a 'stop' parameter is specified, it
# takes precedence; otherwise checks if the object responds to
# a 'stopcmd' method, and if so runs that; otherwise, looks
# for the process in the process table.
# This method will generally not be overridden by submodules.
def stop
if @resource[:stop] or stopcmd
ucommand(:stop)
else
pid = getpid
unless pid
self.info "#{self.name} is not running"
return false
end
begin
output = kill pid
rescue Puppet::ExecutionFailure
@resource.fail "Could not kill #{self.name}, PID #{pid}: #{output}"
end
return true
end
end
# There is no default command, which causes other methods to be used
def stopcmd
end
end
puppet-3.4.3/lib/puppet/provider/service/openbsd.rb 0000644 0052762 0001160 00000000723 12300765631 022267 0 ustar jenkins jenkins Puppet::Type.type(:service).provide :openbsd, :parent => :init do
desc "Provider for OpenBSD's rc.d daemon control scripts"
confine :operatingsystem => :openbsd
defaultfor :operatingsystem => :openbsd
def self.defpath
["/etc/rc.d"]
end
def startcmd
[self.initscript, "-f", :start]
end
def restartcmd
(@resource[:hasrestart] == :true) && [self.initscript, "-f", :restart]
end
def statuscmd
[self.initscript, :check]
end
end
puppet-3.4.3/lib/puppet/provider/service/init.rb 0000644 0052762 0001160 00000012123 12300765631 021575 0 ustar jenkins jenkins # The standard init-based service type. Many other service types are
# customizations of this module.
Puppet::Type.type(:service).provide :init, :parent => :base do
desc "Standard `init`-style service management."
def self.defpath
case Facter.value(:operatingsystem)
when "FreeBSD", "DragonFly"
["/etc/rc.d", "/usr/local/etc/rc.d"]
when "HP-UX"
"/sbin/init.d"
when "Archlinux"
"/etc/rc.d"
else
"/etc/init.d"
end
end
# We can't confine this here, because the init path can be overridden.
#confine :exists => defpath
# some init scripts are not safe to execute, e.g. we do not want
# to suddently run /etc/init.d/reboot.sh status and reboot our system. The
# exclude list could be platform agnostic but I assume an invalid init script
# on system A will never be a valid init script on system B
def self.excludes
excludes = []
# these exclude list was found with grep -L '\/sbin\/runscript' /etc/init.d/* on gentoo
excludes += %w{functions.sh reboot.sh shutdown.sh}
# this exclude list is all from /sbin/service (5.x), but I did not exclude kudzu
excludes += %w{functions halt killall single linuxconf reboot boot}
# 'wait-for-state' and 'portmap-wait' are excluded from instances here
# because they take parameters that have unclear meaning. It looks like
# 'wait-for-state' is a generic waiter mainly used internally for other
# upstart services as a 'sleep until something happens'
# (http://lists.debian.org/debian-devel/2012/02/msg01139.html), while
# 'portmap-wait' is a specific instance of a waiter. There is an open
# launchpad bug
# (https://bugs.launchpad.net/ubuntu/+source/upstart/+bug/962047) that may
# eventually explain how to use the wait-for-state service or perhaps why
# it should remain excluded. When that bug is adddressed this should be
# reexamined.
excludes += %w{wait-for-state portmap-wait}
# these excludes were found with grep -r -L start /etc/init.d
excludes += %w{rcS module-init-tools}
# Prevent puppet failing to get status of the new service introduced
# by the fix for this (bug https://bugs.launchpad.net/ubuntu/+source/lightdm/+bug/982889)
# due to puppet's inability to deal with upstart services with instances.
excludes += %w{plymouth-ready}
end
# List all services of this type.
def self.instances
get_services(self.defpath)
end
def self.get_services(defpath, exclude = self.excludes)
defpath = [defpath] unless defpath.is_a? Array
instances = []
defpath.each do |path|
unless FileTest.directory?(path)
Puppet.debug "Service path #{path} does not exist"
next
end
check = [:ensure]
check << :enable if public_method_defined? :enabled?
Dir.entries(path).each do |name|
fullpath = File.join(path, name)
next if name =~ /^\./
next if exclude.include? name
next if not FileTest.executable?(fullpath)
next if not is_init?(fullpath)
instances << new(:name => name, :path => path, :hasstatus => true)
end
end
instances
end
# Mark that our init script supports 'status' commands.
def hasstatus=(value)
case value
when true, "true"; @parameters[:hasstatus] = true
when false, "false"; @parameters[:hasstatus] = false
else
raise Puppet::Error, "Invalid 'hasstatus' value #{value.inspect}"
end
end
# Where is our init script?
def initscript
@initscript ||= self.search(@resource[:name])
end
def paths
@paths ||= @resource[:path].find_all do |path|
if File.directory?(path)
true
else
if Puppet::FileSystem::File.exist?(path)
self.debug "Search path #{path} is not a directory"
else
self.debug "Search path #{path} does not exist"
end
false
end
end
end
def search(name)
paths.each do |path|
fqname = File.join(path,name)
if Puppet::FileSystem::File.exist? fqname
return fqname
else
self.debug("Could not find #{name} in #{path}")
end
end
paths.each do |path|
fqname_sh = File.join(path,"#{name}.sh")
if Puppet::FileSystem::File.exist? fqname_sh
return fqname_sh
else
self.debug("Could not find #{name}.sh in #{path}")
end
end
raise Puppet::Error, "Could not find init script for '#{name}'"
end
# The start command is just the init scriptwith 'start'.
def startcmd
[initscript, :start]
end
# The stop command is just the init script with 'stop'.
def stopcmd
[initscript, :stop]
end
def restartcmd
(@resource[:hasrestart] == :true) && [initscript, :restart]
end
# If it was specified that the init script has a 'status' command, then
# we just return that; otherwise, we return false, which causes it to
# fallback to other mechanisms.
def statuscmd
(@resource[:hasstatus] == :true) && [initscript, :status]
end
private
def self.is_init?(script = initscript)
file = Puppet::FileSystem::File.new(script)
!file.symlink? || file.readlink != "/lib/init/upstart-job"
end
end
puppet-3.4.3/lib/puppet/provider/service/windows.rb 0000644 0052762 0001160 00000010717 12300765631 022333 0 ustar jenkins jenkins # 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
puppet-3.4.3/lib/puppet/provider/service/bsd.rb 0000644 0052762 0001160 00000002562 12300765631 021410 0 ustar jenkins jenkins # Manage FreeBSD services.
Puppet::Type.type(:service).provide :bsd, :parent => :init do
desc <<-EOT
FreeBSD's (and probably NetBSD's?) form of `init`-style service management.
Uses `rc.conf.d` for service enabling and disabling.
EOT
confine :operatingsystem => [:freebsd, :netbsd, :openbsd, :dragonfly]
def rcconf_dir
'/etc/rc.conf.d'
end
def self.defpath
superclass.defpath
end
# remove service file from rc.conf.d to disable it
def disable
rcfile = File.join(rcconf_dir, @model[:name])
File.delete(rcfile) if Puppet::FileSystem::File.exist?(rcfile)
end
# if the service file exists in rc.conf.d then it's already enabled
def enabled?
rcfile = File.join(rcconf_dir, @model[:name])
return :true if Puppet::FileSystem::File.exist?(rcfile)
:false
end
# enable service by creating a service file under rc.conf.d with the
# proper contents
def enable
Dir.mkdir(rcconf_dir) if not Puppet::FileSystem::File.exist?(rcconf_dir)
rcfile = File.join(rcconf_dir, @model[:name])
open(rcfile, 'w') { |f| f << "%s_enable=\"YES\"\n" % @model[:name] }
end
# Override stop/start commands to use one's and the avoid race condition
# where provider trys to stop/start the service before it is enabled
def startcmd
[self.initscript, :onestart]
end
def stopcmd
[self.initscript, :onestop]
end
end
puppet-3.4.3/lib/puppet/provider/service/runit.rb 0000644 0052762 0001160 00000005515 12300765631 022002 0 ustar jenkins jenkins # Daemontools service management
#
# author Brice Figureau
Puppet::Type.type(:service).provide :runit, :parent => :daemontools do
desc <<-'EOT'
Runit service management.
This provider manages daemons running supervised by Runit.
When detecting the service directory it will check, in order of preference:
* `/service`
* `/etc/service`
* `/var/service`
The daemon directory should be in one of the following locations:
* `/etc/sv`
* `/var/lib/service`
or this can be overriden in the service resource parameters::
service { "myservice":
provider => "runit",
path => "/path/to/daemons",
}
This provider supports out of the box:
* start/stop
* enable/disable
* restart
* status
EOT
commands :sv => "/usr/bin/sv"
class << self
# this is necessary to autodetect a valid resource
# default path, since there is no standard for such directory.
def defpath(dummy_argument=:work_arround_for_ruby_GC_bug)
unless @defpath
["/etc/sv", "/var/lib/service"].each do |path|
if Puppet::FileSystem::File.exist?(path)
@defpath = path
break
end
end
raise "Could not find the daemon directory (tested [/etc/sv,/var/lib/service])" unless @defpath
end
@defpath
end
end
# find the service dir on this node
def servicedir
unless @servicedir
["/service", "/etc/service","/var/service"].each do |path|
if Puppet::FileSystem::File.exist?(path)
@servicedir = path
break
end
end
raise "Could not find service directory" unless @servicedir
end
@servicedir
end
def status
begin
output = sv "status", self.daemon
return :running if output =~ /^run: /
rescue Puppet::ExecutionFailure => detail
unless detail.message =~ /(warning: |runsv not running$)/
raise Puppet::Error.new( "Could not get status for service #{resource.ref}: #{detail}" )
end
end
:stopped
end
def stop
sv "stop", self.service
end
def start
if enabled? != :true
enable
# Work around issue #4480
# runsvdir takes up to 5 seconds to recognize
# the symlink created by this call to enable
Puppet.info "Waiting 5 seconds for runsvdir to discover service #{self.service}"
sleep 5
end
sv "start", self.service
end
def restart
sv "restart", self.service
end
# disable by removing the symlink so that runit
# doesn't restart our service behind our back
# note that runit doesn't need to perform a stop
# before a disable
def disable
# unlink the daemon symlink to disable it
Puppet::FileSystem::File.unlink(self.service) if Puppet::FileSystem::File.new(self.service).symlink?
end
end
puppet-3.4.3/lib/puppet/provider/service/openwrt.rb 0000644 0052762 0001160 00000001471 12300765631 022334 0 ustar jenkins jenkins Puppet::Type.type(:service).provide :openwrt, :parent => :init, :source => :init do
desc <<-EOT
Support for OpenWrt flavored init scripts.
Uses /etc/init.d/service_name enable, disable, and enabled.
EOT
defaultfor :operatingsystem => :openwrt
confine :operatingsystem => :openwrt
has_feature :enableable
def self.defpath
["/etc/init.d"]
end
def enable
system(self.initscript, 'enable')
end
def disable
system(self.initscript, 'disable')
end
def enabled?
# We can't define the "command" for the init script, so we call system?
if system(self.initscript, 'enabled') then return :true else return :false end
end
# Purposely leave blank so we fail back to ps based status detection
# As OpenWrt init script do not have status commands
def statuscmd
end
end
puppet-3.4.3/lib/puppet/provider/service/smf.rb 0000644 0052762 0001160 00000005603 12300765631 021424 0 ustar jenkins jenkins # Solaris 10 SMF-style services.
Puppet::Type.type(:service).provide :smf, :parent => :base do
desc <<-EOT
Support for Sun's new Service Management Framework.
Starting a service is effectively equivalent to enabling it, so there is
only support for starting and stopping services, which also enables and
disables them, respectively.
By specifying `manifest => "/path/to/service.xml"`, the SMF manifest will
be imported if it does not exist.
EOT
defaultfor :osfamily => :solaris
confine :osfamily => :solaris
commands :adm => "/usr/sbin/svcadm", :svcs => "/usr/bin/svcs"
commands :svccfg => "/usr/sbin/svccfg"
def setupservice
if resource[:manifest]
[command(:svcs), "-l", @resource[:name]]
if $CHILD_STATUS.exitstatus == 1
Puppet.notice "Importing #{@resource[:manifest]} for #{@resource[:name]}"
svccfg :import, resource[:manifest]
end
end
rescue Puppet::ExecutionFailure => detail
raise Puppet::Error.new( "Cannot config #{self.name} to enable it: #{detail}" )
end
def self.instances
svcs.split("\n").select{|l| l !~ /^legacy_run/ }.collect do |line|
state,stime,fmri = line.split(/\s+/)
status = case state
when /online/; :running
when /maintenance/; :maintenance
else :stopped
end
new({:name => fmri, :ensure => status})
end
end
def enable
self.start
end
def enabled?
case self.status
when :running
return :true
else
return :false
end
end
def disable
self.stop
end
def restartcmd
[command(:adm), :restart, @resource[:name]]
end
def startcmd
self.setupservice
case self.status
when :maintenance
[command(:adm), :clear, @resource[:name]]
else
[command(:adm), :enable, "-s", @resource[:name]]
end
end
def status
if @resource[:status]
super
return
end
begin
# get the current state and the next state, and if the next
# state is set (i.e. not "-") use it for state comparison
states = svcs("-H", "-o", "state,nstate", @resource[:name]).chomp.split
state = states[1] == "-" ? states[0] : states[1]
rescue Puppet::ExecutionFailure
info "Could not get status on service #{self.name}"
return :stopped
end
case state
when "online"
#self.warning "matched running #{line.inspect}"
return :running
when "offline", "disabled", "uninitialized"
#self.warning "matched stopped #{line.inspect}"
return :stopped
when "maintenance"
return :maintenance
when "legacy_run"
raise Puppet::Error,
"Cannot manage legacy services through SMF"
else
raise Puppet::Error,
"Unmanageable state '#{state}' on service #{self.name}"
end
end
def stopcmd
[command(:adm), :disable, "-s", @resource[:name]]
end
end
puppet-3.4.3/lib/puppet/provider/service/debian.rb 0000644 0052762 0001160 00000004270 12300765631 022060 0 ustar jenkins jenkins # Manage debian services. Start/stop is the same as InitSvc, but enable/disable
# is special.
Puppet::Type.type(:service).provide :debian, :parent => :init do
desc <<-EOT
Debian's form of `init`-style management.
The only differences from `init` are support for enabling and disabling
services via `update-rc.d` and the ability to determine enabled status via
`invoke-rc.d`.
EOT
commands :update_rc => "/usr/sbin/update-rc.d"
# note this isn't being used as a command until
# http://projects.reductivelabs.com/issues/2538
# is resolved.
commands :invoke_rc => "/usr/sbin/invoke-rc.d"
defaultfor :operatingsystem => [:debian, :ubuntu]
# Remove the symlinks
def disable
if `dpkg --compare-versions $(dpkg-query -W --showformat '${Version}' sysv-rc) ge 2.88 ; echo $?`.to_i == 0
update_rc @resource[:name], "disable"
else
update_rc "-f", @resource[:name], "remove"
update_rc @resource[:name], "stop", "00", "1", "2", "3", "4", "5", "6", "."
end
end
def enabled?
# TODO: Replace system call when Puppet::Util::Execution.execute gives us a way
# to determine exit status. http://projects.reductivelabs.com/issues/2538
system("/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start")
# 104 is the exit status when you query start an enabled service.
# 106 is the exit status when the policy layer supplies a fallback action
# See x-man-page://invoke-rc.d
if [104, 106].include?($CHILD_STATUS.exitstatus)
return :true
elsif [105].include?($CHILD_STATUS.exitstatus)
# 105 is unknown, which generally means the the iniscript does not support query
# The debian policy states that the initscript should support methods of query
# For those that do not, peform the checks manually
# http://www.debian.org/doc/debian-policy/ch-opersys.html
if get_start_link_count >= 4
return :true
else
return :false
end
else
return :false
end
end
def get_start_link_count
Dir.glob("/etc/rc*.d/S??#{@resource[:name]}").length
end
def enable
update_rc "-f", @resource[:name], "remove"
update_rc @resource[:name], "defaults"
end
end
puppet-3.4.3/lib/puppet/provider/parsedfile.rb 0000644 0052762 0001160 00000032540 12300765631 021315 0 ustar jenkins jenkins require 'puppet'
require 'puppet/util/filetype'
require 'puppet/util/fileparsing'
# This provider can be used as the parent class for a provider that
# parses and generates files. Its content must be loaded via the
# 'prefetch' method, and the file will be written when 'flush' is called
# on the provider instance. At this point, the file is written once
# for every provider instance.
#
# Once the provider prefetches the data, it's the resource's job to copy
# that data over to the @is variables.
class Puppet::Provider::ParsedFile < Puppet::Provider
extend Puppet::Util::FileParsing
class << self
attr_accessor :default_target, :target
end
attr_accessor :property_hash
def self.clean(hash)
newhash = hash.dup
[:record_type, :on_disk].each do |p|
newhash.delete(p) if newhash.include?(p)
end
newhash
end
def self.clear
@target_objects.clear
@records.clear
end
def self.filetype
@filetype ||= Puppet::Util::FileType.filetype(:flat)
end
def self.filetype=(type)
if type.is_a?(Class)
@filetype = type
elsif klass = Puppet::Util::FileType.filetype(type)
@filetype = klass
else
raise ArgumentError, "Invalid filetype #{type}"
end
end
# Flush all of the targets for which there are modified records. The only
# reason we pass a record here is so that we can add it to the stack if
# necessary -- it's passed from the instance calling 'flush'.
def self.flush(record)
# Make sure this record is on the list to be flushed.
unless record[:on_disk]
record[:on_disk] = true
@records << record
# If we've just added the record, then make sure our
# target will get flushed.
modified(record[:target] || default_target)
end
return unless defined?(@modified) and ! @modified.empty?
flushed = []
begin
@modified.sort { |a,b| a.to_s <=> b.to_s }.uniq.each do |target|
Puppet.debug "Flushing #{@resource_type.name} provider target #{target}"
flushed << target
flush_target(target)
end
ensure
@modified.reject! { |t| flushed.include?(t) }
end
end
# Make sure our file is backed up, but only back it up once per transaction.
# We cheat and rely on the fact that @records is created on each prefetch.
def self.backup_target(target)
return nil unless target_object(target).respond_to?(:backup)
@backup_stats ||= {}
return nil if @backup_stats[target] == @records.object_id
target_object(target).backup
@backup_stats[target] = @records.object_id
end
# Flush all of the records relating to a specific target.
def self.flush_target(target)
backup_target(target)
records = target_records(target).reject { |r|
r[:ensure] == :absent
}
target_object(target).write(to_file(records))
end
# Return the header placed at the top of each generated file, warning
# users that modifying this file manually is probably a bad idea.
def self.header
%{# HEADER: This file was autogenerated at #{Time.now}
# HEADER: by puppet. While it can still be managed manually, it
# HEADER: is definitely not recommended.\n}
end
# An optional regular expression matched by third party headers.
#
# For example, this can be used to filter the vixie cron headers as
# erronously exported by older cron versions.
#
# @api private
# @abstract Providers based on ParsedFile may implement this to make it
# possible to identify a header maintained by a third party tool.
# The provider can then allow that header to remain near the top of the
# written file, or remove it after composing the file content.
# If implemented, the function must return a Regexp object.
# The expression must be tailored to match exactly one third party header.
# @see drop_native_header
# @note When specifying regular expressions in multiline mode, avoid
# greedy repititions such as '.*' (use .*? instead). Otherwise, the
# provider may drop file content between sparse headers.
def self.native_header_regex
nil
end
# How to handle third party headers.
# @api private
# @abstract Providers based on ParsedFile that make use of the support for
# third party headers may override this method to return +true+.
# When this is done, headers that are matched by the native_header_regex
# are not written back to disk.
# @see native_header_regex
def self.drop_native_header
false
end
# Add another type var.
def self.initvars
@records = []
@target_objects = {}
@target = nil
# Default to flat files
@filetype ||= Puppet::Util::FileType.filetype(:flat)
super
end
# Return a list of all of the records we can find.
def self.instances
targets.collect do |target|
prefetch_target(target)
end.flatten.reject { |r| skip_record?(r) }.collect do |record|
new(record)
end
end
# Override the default method with a lot more functionality.
def self.mk_resource_methods
[resource_type.validproperties, resource_type.parameters].flatten.each do |attr|
attr = attr.intern
define_method(attr) do
# If it's not a valid field for this record type (which can happen
# when different platforms support different fields), then just
# return the should value, so the resource shuts up.
if @property_hash[attr] or self.class.valid_attr?(self.class.name, attr)
@property_hash[attr] || :absent
else
if defined?(@resource)
@resource.should(attr)
else
nil
end
end
end
define_method(attr.to_s + "=") do |val|
mark_target_modified
@property_hash[attr] = val
end
end
end
# Always make the resource methods.
def self.resource_type=(resource)
super
mk_resource_methods
end
# Mark a target as modified so we know to flush it. This only gets
# used within the attr= methods.
def self.modified(target)
@modified ||= []
@modified << target unless @modified.include?(target)
end
# Retrieve all of the data from disk. There are three ways to know
# which files to retrieve: We might have a list of file objects already
# set up, there might be instances of our associated resource and they
# will have a path parameter set, and we will have a default path
# set. We need to turn those three locations into a list of files,
# prefetch each one, and make sure they're associated with each appropriate
# resource instance.
def self.prefetch(resources = nil)
# Reset the record list.
@records = prefetch_all_targets(resources)
match_providers_with_resources(resources)
end
# Match a list of catalog resources with provider instances
#
# @api private
#
# @param [Array] resources A list of resources using this class as a provider
def self.match_providers_with_resources(resources)
return unless resources
matchers = resources.dup
@records.each do |record|
# Skip things like comments and blank lines
next if skip_record?(record)
if (resource = resource_for_record(record, resources))
resource.provider = new(record)
elsif respond_to?(:match)
if resource = match(record, matchers)
matchers.delete(resource.title)
record[:name] = resource[:name]
resource.provider = new(record)
end
end
end
end
# Look up a resource based on a parsed file record
#
# @api private
#
# @param [Hash] record
# @param [Array] resources
#
# @return [Puppet::Resource, nil] The resource if found, else nil
def self.resource_for_record(record, resources)
name = record[:name]
if name
resources[name]
end
end
def self.prefetch_all_targets(resources)
records = []
targets(resources).each do |target|
records += prefetch_target(target)
end
records
end
# Prefetch an individual target.
def self.prefetch_target(target)
begin
target_records = retrieve(target)
rescue Puppet::Util::FileType::FileReadError => detail
puts detail.backtrace if Puppet[:trace]
Puppet.err "Could not prefetch #{self.resource_type.name} provider '#{self.name}' target '#{target}': #{detail}. Treating as empty"
target_records = []
end
target_records.each do |r|
r[:on_disk] = true
r[:target] = target
r[:ensure] = :present
end
target_records = prefetch_hook(target_records) if respond_to?(:prefetch_hook)
raise Puppet::DevError, "Prefetching #{target} for provider #{self.name} returned nil" unless target_records
target_records
end
# Is there an existing record with this name?
def self.record?(name)
return nil unless @records
@records.find { |r| r[:name] == name }
end
# Retrieve the text for the file. Returns nil in the unlikely
# event that it doesn't exist.
def self.retrieve(path)
# XXX We need to be doing something special here in case of failure.
text = target_object(path).read
if text.nil? or text == ""
# there is no file
return []
else
# Set the target, for logging.
old = @target
begin
@target = path
return self.parse(text)
rescue Puppet::Error => detail
detail.file = @target
raise detail
ensure
@target = old
end
end
end
# Should we skip the record? Basically, we skip text records.
# This is only here so subclasses can override it.
def self.skip_record?(record)
record_type(record[:record_type]).text?
end
# Initialize the object if necessary.
def self.target_object(target)
@target_objects[target] ||= filetype.new(target)
@target_objects[target]
end
# Find all of the records for a given target
def self.target_records(target)
@records.find_all { |r| r[:target] == target }
end
# Find a list of all of the targets that we should be reading. This is
# used to figure out what targets we need to prefetch.
def self.targets(resources = nil)
targets = []
# First get the default target
raise Puppet::DevError, "Parsed Providers must define a default target" unless self.default_target
targets << self.default_target
# Then get each of the file objects
targets += @target_objects.keys
# Lastly, check the file from any resource instances
if resources
resources.each do |name, resource|
if value = resource.should(:target)
targets << value
end
end
end
targets.uniq.compact
end
# Compose file contents from the set of records.
#
# If self.native_header_regex is not nil, possible vendor headers are
# identified by matching the return value against the expression.
# If one (or several consecutive) such headers, are found, they are
# either moved in front of the self.header if self.drop_native_header
# is false (this is the default), or removed from the return value otherwise.
#
# @api private
def self.to_file(records)
text = super
if native_header_regex and (match = text.match(native_header_regex))
if drop_native_header
# concatenate the text in front of and after the native header
text = match.pre_match + match.post_match
else
native_header = match[0]
return native_header + header + match.pre_match + match.post_match
end
end
header + text
end
def create
@resource.class.validproperties.each do |property|
if value = @resource.should(property)
@property_hash[property] = value
end
end
mark_target_modified
(@resource.class.name.to_s + "_created").intern
end
def destroy
# We use the method here so it marks the target as modified.
self.ensure = :absent
(@resource.class.name.to_s + "_deleted").intern
end
def exists?
!(@property_hash[:ensure] == :absent or @property_hash[:ensure].nil?)
end
# Write our data to disk.
def flush
# Make sure we've got a target and name set.
# If the target isn't set, then this is our first modification, so
# mark it for flushing.
unless @property_hash[:target]
@property_hash[:target] = @resource.should(:target) || self.class.default_target
self.class.modified(@property_hash[:target])
end
@resource.class.key_attributes.each do |attr|
@property_hash[attr] ||= @resource[attr]
end
self.class.flush(@property_hash)
end
def initialize(record)
super
# The 'record' could be a resource or a record, depending on how the provider
# is initialized. If we got an empty property hash (probably because the resource
# is just being initialized), then we want to set up some defaults.
@property_hash = self.class.record?(resource[:name]) || {:record_type => self.class.name, :ensure => :absent} if @property_hash.empty?
end
# Retrieve the current state from disk.
def prefetch
raise Puppet::DevError, "Somehow got told to prefetch with no resource set" unless @resource
self.class.prefetch(@resource[:name] => @resource)
end
def record_type
@property_hash[:record_type]
end
private
# Mark both the resource and provider target as modified.
def mark_target_modified
if defined?(@resource) and restarget = @resource.should(:target) and restarget != @property_hash[:target]
self.class.modified(restarget)
end
self.class.modified(@property_hash[:target]) if @property_hash[:target] != :absent and @property_hash[:target]
end
end
puppet-3.4.3/lib/puppet/provider/confine.rb 0000644 0052762 0001160 00000000415 12300765631 020614 0 ustar jenkins jenkins # Confines have been moved out of the provider as they are also used for other things.
# This provides backwards compatibility for people still including this old location.
require 'puppet/provider'
require 'puppet/confine'
Puppet::Provider::Confine = Puppet::Confine
puppet-3.4.3/lib/puppet/provider/sshkey/ 0000755 0052762 0001160 00000000000 12300765640 020154 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/sshkey/parsed.rb 0000644 0052762 0001160 00000001530 12300765631 021756 0 ustar jenkins jenkins 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]
hash[:name] = [hash[:name], hash[:host_aliases]].flatten.join(",")
hash.delete(:host_aliases)
end
}
end
puppet-3.4.3/lib/puppet/provider/selmodule/ 0000755 0052762 0001160 00000000000 12300765640 020637 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/selmodule/semodule.rb 0000644 0052762 0001160 00000006302 12300765631 023002 0 ustar jenkins jenkins Puppet::Type.type(:selmodule).provide(:semodule) do
desc "Manage SELinux policy modules using the semodule binary."
commands :semodule => "/usr/sbin/semodule"
def create
begin
execoutput("#{command(:semodule)} --install #{selmod_name_to_filename}")
rescue Puppet::ExecutionFailure => detail
raise Puppet::Error, "Could not load policy module: #{detail}";
end
:true
end
def destroy
execoutput("#{command(:semodule)} --remove #{@resource[:name]}")
rescue Puppet::ExecutionFailure => detail
raise Puppet::Error, "Could not remove policy module: #{detail}";
end
def exists?
self.debug "Checking for module #{@resource[:name]}"
execpipe("#{command(:semodule)} --list") do |out|
out.each_line do |line|
if line =~ /#{@resource[:name]}\b/
return :true
end
end
end
nil
end
def syncversion
self.debug "Checking syncversion on #{@resource[:name]}"
loadver = selmodversion_loaded
if(loadver) then
filever = selmodversion_file
if (filever == loadver)
return :true
end
end
:false
end
def syncversion= (dosync)
execoutput("#{command(:semodule)} --upgrade #{selmod_name_to_filename}")
rescue Puppet::ExecutionFailure => detail
raise Puppet::Error, "Could not upgrade policy module: #{detail}";
end
# Helper functions
def execoutput (cmd)
output = ''
begin
execpipe(cmd) do |out|
output = out.readlines.join('').chomp!
end
rescue Puppet::ExecutionFailure
raise Puppet::ExecutionFailure, output.split("\n")[0]
end
output
end
def selmod_name_to_filename
if @resource[:selmodulepath]
return @resource[:selmodulepath]
else
return "#{@resource[:selmoduledir]}/#{@resource[:name]}.pp"
end
end
def selmod_readnext (handle)
len = handle.read(4).unpack('V')[0]
handle.read(len)
end
def selmodversion_file
magic = 0xF97CFF8F
filename = selmod_name_to_filename
mod = File.new(filename, "r")
(hdr, ver, numsec) = mod.read(12).unpack('VVV')
raise Puppet::Error, "Found #{hdr} instead of magic #{magic} in #{filename}" if hdr != magic
raise Puppet::Error, "Unknown policy file version #{ver} in #{filename}" if ver != 1
# Read through (and throw away) the file section offsets, and also
# the magic header for the first section.
mod.read((numsec + 1) * 4)
## Section 1 should be "SE Linux Module"
selmod_readnext(mod)
selmod_readnext(mod)
# Skip past the section headers
mod.read(14)
# Module name
selmod_readnext(mod)
# At last! the version
v = selmod_readnext(mod)
self.debug "file version #{v}"
v
end
def selmodversion_loaded
lines = ()
begin
execpipe("#{command(:semodule)} --list") do |output|
output.each_line do |line|
line.chomp!
bits = line.split
if bits[0] == @resource[:name]
self.debug "load version #{bits[1]}"
return bits[1]
end
end
end
rescue Puppet::ExecutionFailure
raise Puppet::ExecutionFailure, "Could not list policy modules: #{lines.join(' ').chomp!}"
end
nil
end
end
puppet-3.4.3/lib/puppet/provider/zpool/ 0000755 0052762 0001160 00000000000 12300765640 020011 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/zpool/zpool.rb 0000644 0052762 0001160 00000005600 12300765631 021502 0 ustar jenkins jenkins Puppet::Type.type(:zpool).provide(:zpool) do
desc "Provider for zpool."
commands :zpool => 'zpool'
#NAME SIZE ALLOC FREE CAP HEALTH ALTROOT
def self.instances
zpool(:list, '-H').split("\n").collect do |line|
name, size, alloc, free, cap, health, altroot = line.split(/\s+/)
new({:name => name, :ensure => :present})
end
end
def process_zpool_data(pool_array)
if pool_array == []
return Hash.new(:absent)
end
#get the name and get rid of it
pool = Hash.new
pool[:pool] = pool_array[0]
pool_array.shift
tmp = []
#order matters here :(
pool_array.reverse.each do |value|
sym = nil
case value
when "spares";
sym = :spare
when "logs";
sym = :log
when /^mirror|^raidz1|^raidz2/;
sym = value =~ /^mirror/ ? :mirror : :raidz
pool[:raid_parity] = "raidz2" if value =~ /^raidz2/
else
tmp << value
sym = :disk if value == pool_array.first
end
if sym
pool[sym] = pool[sym] ? pool[sym].unshift(tmp.reverse.join(' ')) : [tmp.reverse.join(' ')]
tmp.clear
end
end
pool
end
def get_pool_data
# http://docs.oracle.com/cd/E19082-01/817-2271/gbcve/index.html
# we could also use zpool iostat -v mypool for a (little bit) cleaner output
out = execute("zpool status #{@resource[:pool]}", :failonfail => false, :combine => false)
zpool_data = out.lines.select { |line| line.index("\t") == 0 }.collect { |l| l.strip.split("\s")[0] }
zpool_data.shift
zpool_data
end
def current_pool
@current_pool = process_zpool_data(get_pool_data) unless (defined?(@current_pool) and @current_pool)
@current_pool
end
def flush
@current_pool= nil
end
#Adds log and spare
def build_named(name)
if prop = @resource[name.intern]
[name] + prop.collect { |p| p.split(' ') }.flatten
else
[]
end
end
#query for parity and set the right string
def raidzarity
@resource[:raid_parity] ? @resource[:raid_parity] : "raidz1"
end
#builds up the vdevs for create command
def build_vdevs
if disk = @resource[:disk]
disk.collect { |d| d.split(' ') }.flatten
elsif mirror = @resource[:mirror]
["mirror"] + mirror
elsif raidz = @resource[:raidz]
[raidzarity] + raidz
end
end
def create
zpool(*([:create, @resource[:pool]] + build_vdevs + build_named("spare") + build_named("log")))
end
def destroy
zpool :destroy, @resource[:pool]
end
def exists?
if current_pool[:pool] == :absent
false
else
true
end
end
[:disk, :mirror, :raidz, :log, :spare].each do |field|
define_method(field) do
current_pool[field]
end
define_method(field.to_s + "=") do |should|
self.fail "zpool #{field} can't be changed. should be #{should}, currently is #{current_pool[field]}"
end
end
end
puppet-3.4.3/lib/puppet/provider/mount.rb 0000644 0052762 0001160 00000002554 12300765631 020343 0 ustar jenkins jenkins require 'puppet'
# A module just to store the mount/unmount methods. Individual providers
# still need to add the mount commands manually.
module Puppet::Provider::Mount
# This only works when the mount point is synced to the fstab.
def mount
args = []
# In general we do not have to pass mountoptions because we always
# flush /etc/fstab before attempting to mount. But old code suggests
# that MacOS always needs the mount options to be explicitly passed to
# the mount command
if Facter.value(:kernel) == 'Darwin'
args << "-o" << self.options if self.options and self.options != :absent
end
args << resource[:name]
mountcmd(*args)
case get(:ensure)
when :absent; set(:ensure => :ghost)
when :unmounted; set(:ensure => :mounted)
end
end
def remount
info "Remounting"
if resource[:remounts] == :true
mountcmd "-o", "remount", resource[:name]
else
unmount
mount
end
end
# This only works when the mount point is synced to the fstab.
def unmount
umount(resource[:name])
# Update property hash for future queries (e.g. refresh is called)
case get(:ensure)
when :mounted; set(:ensure => :unmounted)
when :ghost; set(:ensure => :absent)
end
end
# Is the mount currently mounted?
def mounted?
[:mounted, :ghost].include?(get(:ensure))
end
end
puppet-3.4.3/lib/puppet/provider/network_device.rb 0000644 0052762 0001160 00000002645 12300765631 022212 0 ustar jenkins jenkins
# This is the base class of all prefetched network device provider
class Puppet::Provider::NetworkDevice < Puppet::Provider
def self.device(url)
raise "This provider doesn't implement the necessary device method"
end
def self.lookup(device, name)
raise "This provider doesn't implement the necessary lookup method"
end
def self.prefetch(resources)
resources.each do |name, resource|
device = Puppet::Util::NetworkDevice.current || device(resource[:device_url])
if result = lookup(device, name)
result[:ensure] = :present
resource.provider = new(device, result)
else
resource.provider = new(device, :ensure => :absent)
end
end
end
def exists?
@property_hash[:ensure] != :absent
end
attr_accessor :device
def initialize(device, *args)
super(*args)
@device = device
# Make a duplicate, so that we have a copy for comparison
# at the end.
@properties = @property_hash.dup
end
def create
@property_hash[:ensure] = :present
self.class.resource_type.validproperties.each do |property|
if val = resource.should(property)
@property_hash[property] = val
end
end
end
def destroy
@property_hash[:ensure] = :absent
end
def flush
@property_hash.clear
end
def self.instances
end
def former_properties
@properties.dup
end
def properties
@property_hash.dup
end
end
puppet-3.4.3/lib/puppet/provider/group/ 0000755 0052762 0001160 00000000000 12300765640 020002 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/group/windows_adsi.rb 0000644 0052762 0001160 00000004327 12300765631 023027 0 ustar jenkins jenkins require 'puppet/util/adsi'
Puppet::Type.type(:group).provide :windows_adsi do
desc "Local group management for Windows. Group members can be both users and groups.
Additionally, local groups can contain domain users."
defaultfor :operatingsystem => :windows
confine :operatingsystem => :windows
has_features :manages_members
def members_insync?(current, should)
return false unless current
# By comparing account SIDs we don't have to worry about case
# sensitivity, or canonicalization of account names.
# Cannot use munge of the group property to canonicalize @should
# since the default array_matching comparison is not commutative
should_empty = should.nil? or should.empty?
return false if current.empty? != should_empty
# dupes automatically weeded out when hashes built
Puppet::Util::ADSI::Group.name_sid_hash(current) == Puppet::Util::ADSI::Group.name_sid_hash(should)
end
def members_to_s(users)
return '' if users.nil? or !users.kind_of?(Array)
users = users.map do |user_name|
sid = Puppet::Util::Windows::Security.name_to_sid_object(user_name)
if sid.account =~ /\\/
account, _ = Puppet::Util::ADSI::User.parse_name(sid.account)
else
account = sid.account
end
resource.debug("#{sid.domain}\\#{account} (#{sid.to_s})")
"#{sid.domain}\\#{account}"
end
return users.join(',')
end
def group
@group ||= Puppet::Util::ADSI::Group.new(@resource[:name])
end
def members
group.members
end
def members=(members)
group.set_members(members)
end
def create
@group = Puppet::Util::ADSI::Group.create(@resource[:name])
@group.commit
self.members = @resource[:members]
end
def exists?
Puppet::Util::ADSI::Group.exists?(@resource[:name])
end
def delete
Puppet::Util::ADSI::Group.delete(@resource[:name])
end
# Only flush if we created or modified a group, not deleted
def flush
@group.commit if @group
end
def gid
Puppet::Util::Windows::Security.name_to_sid(@resource[:name])
end
def gid=(value)
fail "gid is read-only"
end
def self.instances
Puppet::Util::ADSI::Group.map { |g| new(:ensure => :present, :name => g.name) }
end
end
puppet-3.4.3/lib/puppet/provider/group/ldap.rb 0000644 0052762 0001160 00000003143 12300765631 021250 0 ustar jenkins jenkins require 'puppet/provider/ldap'
Puppet::Type.type(:group).provide :ldap, :parent => Puppet::Provider::Ldap do
desc "Group management via LDAP.
This provider requires that you have valid values for all of the
LDAP-related settings in `puppet.conf`, including `ldapbase`. You will
almost definitely need settings for `ldapuser` and `ldappassword` in order
for your clients to write to LDAP.
Note that this provider will automatically generate a GID for you if you do
not specify one, but it is a potentially expensive operation, as it
iterates across all existing groups to pick the appropriate next one."
confine :feature => :ldap, :false => (Puppet[:ldapuser] == "")
# We're mapping 'members' here because we want to make it
# easy for the ldap user provider to manage groups. This
# way it can just use the 'update' method in the group manager,
# whereas otherwise it would need to replicate that code.
manages(:posixGroup).at("ou=Groups").and.maps :name => :cn, :gid => :gidNumber, :members => :memberUid
# Find the next gid after the current largest gid.
provider = self
manager.generates(:gidNumber).with do
largest = 500
if existing = provider.manager.search
existing.each do |hash|
next unless value = hash[:gid]
num = value[0].to_i
largest = num if num > largest
end
end
largest + 1
end
# Convert a group name to an id.
def self.name2id(group)
return nil unless result = manager.search("cn=#{group}") and result.length > 0
# Only use the first result.
group = result[0]
group[:gid][0]
end
end
puppet-3.4.3/lib/puppet/provider/group/aix.rb 0000644 0052762 0001160 00000007670 12300765631 021122 0 ustar jenkins jenkins #
# Group Puppet provider for AIX. It uses standard commands to manage groups:
# mkgroup, rmgroup, lsgroup, chgroup
#
# Author:: Hector Rivas Gandara
#
require 'puppet/provider/aixobject'
Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject do
desc "Group management for AIX."
# This will the the default provider for this platform
defaultfor :operatingsystem => :aix
confine :operatingsystem => :aix
# Provider features
has_features :manages_aix_lam
has_features :manages_members
# Commands that manage the element
commands :list => "/usr/sbin/lsgroup"
commands :add => "/usr/bin/mkgroup"
commands :delete => "/usr/sbin/rmgroup"
commands :modify => "/usr/bin/chgroup"
# Group attributes to ignore
def self.attribute_ignore
[]
end
# AIX attributes to properties mapping.
#
# Valid attributes to be managed by this provider.
# It is a list with of hash
# :aix_attr AIX command attribute name
# :puppet_prop Puppet propertie name
# :to Method to adapt puppet property to aix command value. Optional.
# :from Method to adapt aix command value to puppet property. Optional
self.attribute_mapping = [
#:name => :name,
{:aix_attr => :id, :puppet_prop => :gid },
{:aix_attr => :users, :puppet_prop => :members,
:from => :users_from_attr},
{:aix_attr => :attributes, :puppet_prop => :attributes},
]
#--------------
# Command definition
# Return the IA module arguments based on the resource param ia_load_module
def get_ia_module_args
if @resource[:ia_load_module]
["-R", @resource[:ia_load_module].to_s]
else
[]
end
end
def lscmd(value=@resource[:name])
[self.class.command(:list)] +
self.get_ia_module_args +
[ value]
end
def lsallcmd()
lscmd("ALL")
end
def addcmd(extra_attrs = [])
# Here we use the @resource.to_hash to get the list of provided parameters
# Puppet does not call to self.= method if it does not exists.
#
# It gets an extra list of arguments to add to the user.
[self.class.command(:add) ] +
self.get_ia_module_args +
self.hash2args(@resource.to_hash) +
extra_attrs + [@resource[:name]]
end
def modifycmd(hash = property_hash)
args = self.hash2args(hash)
return nil if args.empty?
[self.class.command(:modify)] +
self.get_ia_module_args +
args + [@resource[:name]]
end
def deletecmd
[self.class.command(:delete)] +
self.get_ia_module_args +
[@resource[:name]]
end
#--------------
# Overwrite get_arguments to add the attributes arguments
def get_arguments(key, value, mapping, objectinfo)
# In the case of attributes, return a list of key=vlaue
if key == :attributes
raise Puppet::Error, "Attributes must be a list of pairs key=value on #{@resource.class.name}[#{@resource.name}]" \
unless value and value.is_a? Hash
return value.select { |k,v| true }.map { |pair| pair.join("=") }
end
super(key, value, mapping, objectinfo)
end
def filter_attributes(hash)
# Return only not managed attributtes.
hash.select {
|k,v| !self.class.attribute_mapping_from.include?(k) and
!self.class.attribute_ignore.include?(k)
}.inject({}) {
|hash, array| hash[array[0]] = array[1]; hash
}
end
def attributes
filter_attributes(getosinfo(false))
end
def attributes=(attr_hash)
#self.class.validate(param, value)
param = :attributes
cmd = modifycmd({param => filter_attributes(attr_hash)})
if cmd
begin
execute(cmd)
rescue Puppet::ExecutionFailure => detail
raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}"
end
end
end
# Force convert users it a list.
def users_from_attr(value)
(value.is_a? String) ? value.split(',') : value
end
end
puppet-3.4.3/lib/puppet/provider/group/pw.rb 0000644 0052762 0001160 00000002115 12300765631 020754 0 ustar jenkins jenkins require 'puppet/provider/nameservice/pw'
Puppet::Type.type(:group).provide :pw, :parent => Puppet::Provider::NameService::PW do
desc "Group management via `pw` on FreeBSD and DragonFly BSD."
commands :pw => "pw"
has_features :manages_members
defaultfor :operatingsystem => [:freebsd, :dragonfly]
options :members, :flag => "-M", :method => :mem
verify :gid, "GID must be an integer" do |value|
value.is_a? Integer
end
def addcmd
cmd = [command(:pw), "groupadd", @resource[:name]]
if gid = @resource.should(:gid)
unless gid == :absent
cmd << flag(:gid) << gid
end
end
if members = @resource.should(:members)
unless members == :absent
if members.is_a?(Array)
members = members.join(",")
end
cmd << "-M" << members
end
end
cmd << "-o" if @resource.allowdupe?
cmd
end
def modifycmd(param, value)
# members may be an array, need a comma separated list
if param == :members and value.is_a?(Array)
value = value.join(",")
end
super(param, value)
end
end
puppet-3.4.3/lib/puppet/provider/group/groupadd.rb 0000644 0052762 0001160 00000004441 12300765631 022137 0 ustar jenkins jenkins require 'puppet/provider/nameservice/objectadd'
require 'puppet/util/libuser'
Puppet::Type.type(:group).provide :groupadd, :parent => Puppet::Provider::NameService::ObjectAdd do
desc "Group management via `groupadd` and its ilk. The default for most platforms.
"
commands :add => "groupadd", :delete => "groupdel", :modify => "groupmod"
has_feature :system_groups unless %w{HP-UX Solaris}.include? Facter.value(:operatingsystem)
verify :gid, "GID must be an integer" do |value|
value.is_a? Integer
end
optional_commands :localadd => "lgroupadd"
has_feature :libuser if Puppet.features.libuser?
def exists?
return !!localgid if @resource.forcelocal?
super
end
def gid
return localgid if @resource.forcelocal?
get(:gid)
end
def findgroup(key, value)
group_file = "/etc/group"
group_keys = ['group_name', 'password', 'gid', 'user_list']
index = group_keys.index(key)
File.open(group_file) do |f|
f.each_line do |line|
group = line.split(":")
if group[index] == value
f.close
return group
end
end
end
false
end
def localgid
group = findgroup('group_name', resource[:name])
return group[2] if group
false
end
def check_allow_dup
# We have to manually check for duplicates when using libuser
# because by default duplicates are allowed. This check is
# to ensure consistent behaviour of the useradd provider when
# using both useradd and luseradd
if not @resource.allowdupe? and @resource.forcelocal?
if @resource.should(:gid) and findgroup('gid', @resource.should(:gid).to_s)
raise(Puppet::Error, "GID #{@resource.should(:gid).to_s} already exists, use allowdupe to force group creation")
end
elsif @resource.allowdupe? and not @resource.forcelocal?
return ["-o"]
end
[]
end
def addcmd
if @resource.forcelocal?
cmd = [command(:localadd)]
@custom_environment = Puppet::Util::Libuser.getenv
else
cmd = [command(:add)]
end
if gid = @resource.should(:gid)
unless gid == :absent
cmd << flag(:gid) << gid
end
end
cmd += check_allow_dup
cmd << "-r" if @resource.system? and self.class.system_groups?
cmd << @resource[:name]
cmd
end
end
puppet-3.4.3/lib/puppet/provider/group/directoryservice.rb 0000644 0052762 0001160 00000000600 12300765631 023710 0 ustar jenkins jenkins require 'puppet/provider/nameservice/directoryservice'
Puppet::Type.type(:group).provide :directoryservice, :parent => Puppet::Provider::NameService::DirectoryService do
desc "Group management using DirectoryService on OS X.
"
commands :dscl => "/usr/bin/dscl"
confine :operatingsystem => :darwin
defaultfor :operatingsystem => :darwin
has_feature :manages_members
end
puppet-3.4.3/lib/puppet/provider/nameservice/ 0000755 0052762 0001160 00000000000 12300765640 021147 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/nameservice/objectadd.rb 0000644 0052762 0001160 00000001461 12300765631 023415 0 ustar jenkins jenkins require 'puppet/provider/nameservice'
class Puppet::Provider::NameService
class ObjectAdd < Puppet::Provider::NameService
def deletecmd
[command(:delete), @resource[:name]]
end
# Determine the flag to pass to our command.
def flag(name)
name = name.intern if name.is_a? String
self.class.option(name, :flag) || "-" + name.to_s[0,1]
end
def modifycmd(param, value)
cmd = [command(param.to_s =~ /password_.+_age/ ? :password : :modify)]
cmd << flag(param) << value
if @resource.allowdupe? && ((param == :uid) || (param == :gid and self.class.name == :groupadd))
cmd << "-o"
end
cmd << @resource[:name]
cmd
end
def posixmethod(name)
name = name.intern if name.is_a? String
method = self.class.option(name, :method) || name
method
end
end
end
puppet-3.4.3/lib/puppet/provider/nameservice/pw.rb 0000644 0052762 0001160 00000000622 12300765631 022122 0 ustar jenkins jenkins require 'puppet/provider/nameservice/objectadd'
class Puppet::Provider::NameService
class PW < ObjectAdd
def deletecmd
[command(:pw), "#{@resource.class.name.to_s}del", @resource[:name]]
end
def modifycmd(param, value)
cmd = [
command(:pw),
"#{@resource.class.name.to_s}mod",
@resource[:name],
flag(param),
munge(param, value)
]
cmd
end
end
end
puppet-3.4.3/lib/puppet/provider/nameservice/directoryservice.rb 0000644 0052762 0001160 00000061233 12300765631 025066 0 ustar jenkins jenkins require 'puppet'
require 'puppet/provider/nameservice'
require 'facter/util/plist'
require 'fileutils'
class Puppet::Provider::NameService::DirectoryService < Puppet::Provider::NameService
# JJM: Dive into the singleton_class
class << self
# JJM: This allows us to pass information when calling
# Puppet::Type.type
# e.g. Puppet::Type.type(:user).provide :directoryservice, :ds_path => "Users"
# This is referenced in the get_ds_path class method
attr_writer :ds_path
attr_writer :macosx_version_major
end
initvars
commands :dscl => "/usr/bin/dscl"
commands :dseditgroup => "/usr/sbin/dseditgroup"
commands :sw_vers => "/usr/bin/sw_vers"
commands :plutil => '/usr/bin/plutil'
confine :operatingsystem => :darwin
defaultfor :operatingsystem => :darwin
# JJM 2007-07-25: This map is used to map NameService attributes to their
# corresponding DirectoryService attribute names.
# See: http://images.apple.com/server/docs.Open_Directory_v10.4.pdf
# JJM: Note, this is de-coupled from the Puppet::Type, and must
# be actively maintained. There may also be collisions with different
# types (Users, Groups, Mounts, Hosts, etc...)
def ds_to_ns_attribute_map; self.class.ds_to_ns_attribute_map; end
def self.ds_to_ns_attribute_map
{
'RecordName' => :name,
'PrimaryGroupID' => :gid,
'NFSHomeDirectory' => :home,
'UserShell' => :shell,
'UniqueID' => :uid,
'RealName' => :comment,
'Password' => :password,
'GeneratedUID' => :guid,
'IPAddress' => :ip_address,
'ENetAddress' => :en_address,
'GroupMembership' => :members,
}
end
# JJM The same table as above, inverted.
def ns_to_ds_attribute_map; self.class.ns_to_ds_attribute_map end
def self.ns_to_ds_attribute_map
@ns_to_ds_attribute_map ||= ds_to_ns_attribute_map.invert
end
def self.password_hash_dir
'/var/db/shadow/hash'
end
def self.users_plist_dir
'/var/db/dslocal/nodes/Default/users'
end
def self.instances
# JJM Class method that provides an array of instance objects of this
# type.
# JJM: Properties are dependent on the Puppet::Type we're managine.
type_property_array = [:name] + @resource_type.validproperties
# Create a new instance of this Puppet::Type for each object present
# on the system.
list_all_present.collect do |name_string|
self.new(single_report(name_string, *type_property_array))
end
end
def self.get_ds_path
# JJM: 2007-07-24 This method dynamically returns the DS path we're concerned with.
# For example, if we're working with an user type, this will be /Users
# with a group type, this will be /Groups.
# @ds_path is an attribute of the class itself.
return @ds_path if defined?(@ds_path)
# JJM: "Users" or "Groups" etc ... (Based on the Puppet::Type)
# Remember this is a class method, so self.class is Class
# Also, @resource_type seems to be the reference to the
# Puppet::Type this class object is providing for.
@resource_type.name.to_s.capitalize + "s"
end
def self.get_macosx_version_major
return @macosx_version_major if defined?(@macosx_version_major)
begin
# Make sure we've loaded all of the facts
Facter.loadfacts
product_version_major = Facter.value(:macosx_productversion_major)
fail("#{product_version_major} is not supported by the directoryservice provider") if %w{10.0 10.1 10.2 10.3 10.4}.include?(product_version_major)
@macosx_version_major = product_version_major
return @macosx_version_major
rescue Puppet::ExecutionFailure => detail
fail("Could not determine OS X version: #{detail}")
end
end
def self.list_all_present
# JJM: List all objects of this Puppet::Type already present on the system.
begin
dscl_output = execute(get_exec_preamble("-list"))
rescue Puppet::ExecutionFailure
fail("Could not get #{@resource_type.name} list from DirectoryService")
end
dscl_output.split("\n")
end
def self.parse_dscl_plist_data(dscl_output)
Plist.parse_xml(dscl_output)
end
def self.generate_attribute_hash(input_hash, *type_properties)
attribute_hash = {}
input_hash.keys.each do |key|
ds_attribute = key.sub("dsAttrTypeStandard:", "")
next unless (ds_to_ns_attribute_map.keys.include?(ds_attribute) and type_properties.include? ds_to_ns_attribute_map[ds_attribute])
ds_value = input_hash[key]
case ds_to_ns_attribute_map[ds_attribute]
when :members
ds_value = ds_value # only members uses arrays so far
when :gid, :uid
# OS X stores objects like uid/gid as strings.
# Try casting to an integer for these cases to be
# consistent with the other providers and the group type
# validation
begin
ds_value = Integer(ds_value[0])
rescue ArgumentError
ds_value = ds_value[0]
end
else ds_value = ds_value[0]
end
attribute_hash[ds_to_ns_attribute_map[ds_attribute]] = ds_value
end
# NBK: need to read the existing password here as it's not actually
# stored in the user record. It is stored at a path that involves the
# UUID of the user record for non-Mobile local acccounts.
# Mobile Accounts are out of scope for this provider for now
attribute_hash[:password] = self.get_password(attribute_hash[:guid], attribute_hash[:name]) if @resource_type.validproperties.include?(:password) and Puppet.features.root?
attribute_hash
end
def self.single_report(resource_name, *type_properties)
# JJM 2007-07-24:
# Given a the name of an object and a list of properties of that
# object, return all property values in a hash.
#
# This class method returns nil if the object doesn't exist
# Otherwise, it returns a hash of the object properties.
all_present_str_array = list_all_present
# NBK: shortcut the process if the resource is missing
return nil unless all_present_str_array.include? resource_name
dscl_vector = get_exec_preamble("-read", resource_name)
begin
dscl_output = execute(dscl_vector)
rescue Puppet::ExecutionFailure
fail("Could not get report. command execution failed.")
end
# (#11593) Remove support for OS X 10.4 and earlier
fail_if_wrong_version
dscl_plist = self.parse_dscl_plist_data(dscl_output)
self.generate_attribute_hash(dscl_plist, *type_properties)
end
def self.fail_if_wrong_version
fail("Puppet does not support OS X versions < 10.5") unless self.get_macosx_version_major >= "10.5"
end
def self.get_exec_preamble(ds_action, resource_name = nil)
# JJM 2007-07-24
# DSCL commands are often repetitive and contain the same positional
# arguments over and over. See http://developer.apple.com/documentation/Porting/Conceptual/PortingUnix/additionalfeatures/chapter_10_section_9.html
# for an example of what I mean.
# This method spits out proper DSCL commands for us.
# We EXPECT name to be @resource[:name] when called from an instance object.
# (#11593) Remove support for OS X 10.4 and earlier
fail_if_wrong_version
command_vector = [ command(:dscl), "-plist", "." ]
# JJM: The actual action to perform. See "man dscl"
# Common actiosn: -create, -delete, -merge, -append, -passwd
command_vector << ds_action
# JJM: get_ds_path will spit back "Users" or "Groups",
# etc... Depending on the Puppet::Type of our self.
if resource_name
command_vector << "/#{get_ds_path}/#{resource_name}"
else
command_vector << "/#{get_ds_path}"
end
# JJM: This returns most of the preamble of the command.
# e.g. 'dscl / -create /Users/mccune'
command_vector
end
def self.set_password(resource_name, guid, password_hash)
# Use Puppet::Util::Package.versioncmp() to catch the scenario where a
# version '10.10' would be < '10.7' with simple string comparison. This
# if-statement only executes if the current version is less-than 10.7
if (Puppet::Util::Package.versioncmp(get_macosx_version_major, '10.7') == -1)
password_hash_file = "#{password_hash_dir}/#{guid}"
begin
File.open(password_hash_file, 'w') { |f| f.write(password_hash)}
rescue Errno::EACCES => detail
fail("Could not write to password hash file: #{detail}")
end
# NBK: For shadow hashes, the user AuthenticationAuthority must contain a value of
# ";ShadowHash;". The LKDC in 10.5 makes this more interesting though as it
# will dynamically generate ;Kerberosv5;;username@LKDC:SHA1 attributes if
# missing. Thus we make sure we only set ;ShadowHash; if it is missing, and
# we can do this with the merge command. This allows people to continue to
# use other custom AuthenticationAuthority attributes without stomping on them.
#
# There is a potential problem here in that we're only doing this when setting
# the password, and the attribute could get modified at other times while the
# hash doesn't change and so this doesn't get called at all... but
# without switching all the other attributes to merge instead of create I can't
# see a simple enough solution for this that doesn't modify the user record
# every single time. This should be a rather rare edge case. (famous last words)
dscl_vector = self.get_exec_preamble("-merge", resource_name)
dscl_vector << "AuthenticationAuthority" << ";ShadowHash;"
begin
execute(dscl_vector)
rescue Puppet::ExecutionFailure => detail
fail("Could not set AuthenticationAuthority.")
end
else
# 10.7 uses salted SHA512 password hashes which are 128 characters plus
# an 8 character salt. Previous versions used a SHA1 hash padded with
# zeroes. If someone attempts to use a password hash that worked with
# a previous version of OX X, we will fail early and warn them.
if password_hash.length != 136
fail("OS X 10.7 requires a Salted SHA512 hash password of 136 characters. \
Please check your password and try again.")
end
if Puppet::FileSystem::File.exist?("#{users_plist_dir}/#{resource_name}.plist")
# If a plist already exists in /var/db/dslocal/nodes/Default/users, then
# we will need to extract the binary plist from the 'ShadowHashData'
# key, log the new password into the resultant plist's 'SALTED-SHA512'
# key, and then save the entire structure back.
users_plist = Plist::parse_xml(plutil( '-convert', 'xml1', '-o', '/dev/stdout', \
"#{users_plist_dir}/#{resource_name}.plist"))
# users_plist['ShadowHashData'][0].string is actually a binary plist
# that's nested INSIDE the user's plist (which itself is a binary
# plist). If we encounter a user plist that DOESN'T have a
# ShadowHashData field, create one.
if users_plist['ShadowHashData']
password_hash_plist = users_plist['ShadowHashData'][0].string
converted_hash_plist = convert_binary_to_xml(password_hash_plist)
else
users_plist['ShadowHashData'] = [StringIO.new]
converted_hash_plist = {'SALTED-SHA512' => StringIO.new}
end
# converted_hash_plist['SALTED-SHA512'].string expects a Base64 encoded
# string. The password_hash provided as a resource attribute is a
# hex value. We need to convert the provided hex value to a Base64
# encoded string to nest it in the converted hash plist.
converted_hash_plist['SALTED-SHA512'].string = \
password_hash.unpack('a2'*(password_hash.size/2)).collect { |i| i.hex.chr }.join
# Finally, we can convert the nested plist back to binary, embed it
# into the user's plist, and convert the resultant plist back to
# a binary plist.
changed_plist = convert_xml_to_binary(converted_hash_plist)
users_plist['ShadowHashData'][0].string = changed_plist
Plist::Emit.save_plist(users_plist, "#{users_plist_dir}/#{resource_name}.plist")
plutil('-convert', 'binary1', "#{users_plist_dir}/#{resource_name}.plist")
end
end
end
def self.get_password(guid, username)
# Use Puppet::Util::Package.versioncmp() to catch the scenario where a
# version '10.10' would be < '10.7' with simple string comparison. This
# if-statement only executes if the current version is less-than 10.7
if (Puppet::Util::Package.versioncmp(get_macosx_version_major, '10.7') == -1)
password_hash = nil
password_hash_file = "#{password_hash_dir}/#{guid}"
if Puppet::FileSystem::File.exist?(password_hash_file) and File.file?(password_hash_file)
fail("Could not read password hash file at #{password_hash_file}") if not File.readable?(password_hash_file)
f = File.new(password_hash_file)
password_hash = f.read
f.close
end
password_hash
else
if Puppet::FileSystem::File.exist?("#{users_plist_dir}/#{username}.plist")
# If a plist exists in /var/db/dslocal/nodes/Default/users, we will
# extract the binary plist from the 'ShadowHashData' key, decode the
# salted-SHA512 password hash, and then return it.
users_plist = Plist::parse_xml(plutil('-convert', 'xml1', '-o', '/dev/stdout', "#{users_plist_dir}/#{username}.plist"))
if users_plist['ShadowHashData']
# users_plist['ShadowHashData'][0].string is actually a binary plist
# that's nested INSIDE the user's plist (which itself is a binary
# plist).
password_hash_plist = users_plist['ShadowHashData'][0].string
converted_hash_plist = convert_binary_to_xml(password_hash_plist)
# converted_hash_plist['SALTED-SHA512'].string is a Base64 encoded
# string. The password_hash provided as a resource attribute is a
# hex value. We need to convert the Base64 encoded string to a
# hex value and provide it back to Puppet.
password_hash = converted_hash_plist['SALTED-SHA512'].string.unpack("H*")[0]
password_hash
end
end
end
end
# This method will accept a hash that has been returned from Plist::parse_xml
# and convert it to a binary plist (string value).
def self.convert_xml_to_binary(plist_data)
Puppet.debug('Converting XML plist to binary')
Puppet.debug('Executing: \'plutil -convert binary1 -o - -\'')
IO.popen('plutil -convert binary1 -o - -', 'r+') do |io|
io.write plist_data.to_plist
io.close_write
@converted_plist = io.read
end
@converted_plist
end
# This method will accept a binary plist (as a string) and convert it to a
# hash via Plist::parse_xml.
def self.convert_binary_to_xml(plist_data)
Puppet.debug('Converting binary plist to XML')
Puppet.debug('Executing: \'plutil -convert xml1 -o - -\'')
IO.popen('plutil -convert xml1 -o - -', 'r+') do |io|
io.write plist_data
io.close_write
@converted_plist = io.read
end
Puppet.debug('Converting XML values to a hash.')
@plist_hash = Plist::parse_xml(@converted_plist)
@plist_hash
end
# Unlike most other *nixes, OS X doesn't provide built in functionality
# for automatically assigning uids and gids to accounts, so we set up these
# methods for consumption by functionality like --mkusers
# By default we restrict to a reasonably sane range for system accounts
def self.next_system_id(id_type, min_id=20)
dscl_args = ['.', '-list']
if id_type == 'uid'
dscl_args << '/Users' << 'uid'
elsif id_type == 'gid'
dscl_args << '/Groups' << 'gid'
else
fail("Invalid id_type #{id_type}. Only 'uid' and 'gid' supported")
end
dscl_out = dscl(dscl_args)
# We're ok with throwing away negative uids here.
ids = dscl_out.split.compact.collect { |l| l.to_i if l.match(/^\d+$/) }
ids.compact!.sort! { |a,b| a.to_f <=> b.to_f }
# We're just looking for an unused id in our sorted array.
ids.each_index do |i|
next_id = ids[i] + 1
return next_id if ids[i+1] != next_id and next_id >= min_id
end
end
def ensure=(ensure_value)
super
# We need to loop over all valid properties for the type we're
# managing and call the method which sets that property value
# dscl can't create everything at once unfortunately.
if ensure_value == :present
@resource.class.validproperties.each do |name|
next if name == :ensure
# LAK: We use property.sync here rather than directly calling
# the settor method because the properties might do some kind
# of conversion. In particular, the user gid property might
# have a string and need to convert it to a number
if @resource.should(name)
@resource.property(name).sync
elsif value = autogen(name)
self.send(name.to_s + "=", value)
else
next
end
end
end
end
def password=(passphrase)
exec_arg_vector = self.class.get_exec_preamble("-read", @resource.name)
exec_arg_vector << ns_to_ds_attribute_map[:guid]
begin
guid_output = execute(exec_arg_vector)
guid_plist = Plist.parse_xml(guid_output)
# Although GeneratedUID like all DirectoryService values can be multi-valued
# according to the schema, in practice user accounts cannot have multiple UUIDs
# otherwise Bad Things Happen, so we just deal with the first value.
guid = guid_plist["dsAttrTypeStandard:#{ns_to_ds_attribute_map[:guid]}"][0]
self.class.set_password(@resource.name, guid, passphrase)
rescue Puppet::ExecutionFailure => detail
fail("Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}")
end
end
# NBK: we override @parent.set as we need to execute a series of commands
# to deal with array values, rather than the single command nameservice.rb
# expects to be returned by modifycmd. Thus we don't bother defining modifycmd.
def set(param, value)
self.class.validate(param, value)
current_members = @property_value_cache_hash[:members]
if param == :members
# If we are meant to be authoritative for the group membership
# then remove all existing members who haven't been specified
# in the manifest.
remove_unwanted_members(current_members, value) if @resource[:auth_membership] and not current_members.nil?
# if they're not a member, make them one.
add_members(current_members, value)
else
exec_arg_vector = self.class.get_exec_preamble("-create", @resource[:name])
# JJM: The following line just maps the NS name to the DS name
# e.g. { :uid => 'UniqueID' }
exec_arg_vector << ns_to_ds_attribute_map[param.intern]
# JJM: The following line sends the actual value to set the property to
exec_arg_vector << value.to_s
begin
execute(exec_arg_vector)
rescue Puppet::ExecutionFailure => detail
fail("Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}")
end
end
end
# NBK: we override @parent.create as we need to execute a series of commands
# to create objects with dscl, rather than the single command nameservice.rb
# expects to be returned by addcmd. Thus we don't bother defining addcmd.
def create
if exists?
info "already exists"
return nil
end
# NBK: First we create the object with a known guid so we can set the contents
# of the password hash if required
# Shelling out sucks, but for a single use case it doesn't seem worth
# requiring people install a UUID library that doesn't come with the system.
# This should be revisited if Puppet starts managing UUIDs for other platform
# user records.
guid = %x{/usr/bin/uuidgen}.chomp
exec_arg_vector = self.class.get_exec_preamble("-create", @resource[:name])
exec_arg_vector << ns_to_ds_attribute_map[:guid] << guid
begin
execute(exec_arg_vector)
rescue Puppet::ExecutionFailure => detail
fail("Could not set GeneratedUID for #{@resource.class.name} #{@resource.name}: #{detail}")
end
if value = @resource.should(:password) and value != ""
self.class.set_password(@resource[:name], guid, value)
end
# Now we create all the standard properties
Puppet::Type.type(@resource.class.name).validproperties.each do |property|
next if property == :ensure
value = @resource.should(property)
if property == :gid and value.nil?
value = self.class.next_system_id(id_type='gid')
end
if property == :uid and value.nil?
value = self.class.next_system_id(id_type='uid')
end
if value != "" and not value.nil?
if property == :members
add_members(nil, value)
else
exec_arg_vector = self.class.get_exec_preamble("-create", @resource[:name])
exec_arg_vector << ns_to_ds_attribute_map[property.intern]
next if property == :password # skip setting the password here
exec_arg_vector << value.to_s
begin
execute(exec_arg_vector)
rescue Puppet::ExecutionFailure => detail
fail("Could not create #{@resource.class.name} #{@resource.name}: #{detail}")
end
end
end
end
end
def remove_unwanted_members(current_members, new_members)
current_members.each do |member|
if not new_members.flatten.include?(member)
cmd = [:dseditgroup, "-o", "edit", "-n", ".", "-d", member, @resource[:name]]
begin
execute(cmd)
rescue Puppet::ExecutionFailure => detail
# TODO: We're falling back to removing the member using dscl due to rdar://8481241
# This bug causes dseditgroup to fail to remove a member if that member doesn't exist
cmd = [:dscl, ".", "-delete", "/Groups/#{@resource.name}", "GroupMembership", member]
begin
execute(cmd)
rescue Puppet::ExecutionFailure => detail
fail("Could not remove #{member} from group: #{@resource.name}, #{detail}")
end
end
end
end
end
def add_members(current_members, new_members)
new_members.flatten.each do |new_member|
if current_members.nil? or not current_members.include?(new_member)
cmd = [:dseditgroup, "-o", "edit", "-n", ".", "-a", new_member, @resource[:name]]
begin
execute(cmd)
rescue Puppet::ExecutionFailure => detail
fail("Could not add #{new_member} to group: #{@resource.name}, #{detail}")
end
end
end
end
def deletecmd
# JJM: Like addcmd, only called when deleting the object itself
# Note, this isn't used to delete properties of the object,
# at least that's how I understand it...
self.class.get_exec_preamble("-delete", @resource[:name])
end
def getinfo(refresh = false)
# JJM 2007-07-24:
# Override the getinfo method, which is also defined in nameservice.rb
# This method returns and sets @infohash
# I'm not re-factoring the name "getinfo" because this method will be
# most likely called by nameservice.rb, which I didn't write.
if refresh or (! defined?(@property_value_cache_hash) or ! @property_value_cache_hash)
# JJM 2007-07-24: OK, there's a bit of magic that's about to
# happen... Let's see how strong my grip has become... =)
#
# self is a provider instance of some Puppet::Type, like
# Puppet::Type::User::ProviderDirectoryservice for the case of the
# user type and this provider.
#
# self.class looks like "user provider directoryservice", if that
# helps you ...
#
# self.class.resource_type is a reference to the Puppet::Type class,
# probably Puppet::Type::User or Puppet::Type::Group, etc...
#
# self.class.resource_type.validproperties is a class method,
# returning an Array of the valid properties of that specific
# Puppet::Type.
#
# So... something like [:comment, :home, :password, :shell, :uid,
# :groups, :ensure, :gid]
#
# Ultimately, we add :name to the list, delete :ensure from the
# list, then report on the remaining list. Pretty whacky, ehh?
type_properties = [:name] + self.class.resource_type.validproperties
type_properties.delete(:ensure) if type_properties.include? :ensure
type_properties << :guid # append GeneratedUID so we just get the report here
@property_value_cache_hash = self.class.single_report(@resource[:name], *type_properties)
[:uid, :gid].each do |param|
@property_value_cache_hash[param] = @property_value_cache_hash[param].to_i if @property_value_cache_hash and @property_value_cache_hash.include?(param)
end
end
@property_value_cache_hash
end
end
puppet-3.4.3/lib/puppet/provider/ldap.rb 0000644 0052762 0001160 00000006767 12300765631 020133 0 ustar jenkins jenkins require 'puppet/provider'
# The base class for LDAP providers.
class Puppet::Provider::Ldap < Puppet::Provider
require 'puppet/util/ldap/manager'
class << self
attr_reader :manager
end
# Look up all instances at our location. Yay.
def self.instances
return [] unless list = manager.search
list.collect { |entry| new(entry) }
end
# Specify the ldap manager for this provider, which is
# used to figure out how we actually interact with ldap.
def self.manages(*args)
@manager = Puppet::Util::Ldap::Manager.new
@manager.manages(*args)
# Set up our getter/setter methods.
mk_resource_methods
@manager
end
# Query all of our resources from ldap.
def self.prefetch(resources)
resources.each do |name, resource|
if result = manager.find(name)
result[:ensure] = :present
resource.provider = new(result)
else
resource.provider = new(:ensure => :absent)
end
end
end
def manager
self.class.manager
end
def create
@property_hash[:ensure] = :present
self.class.resource_type.validproperties.each do |property|
if val = resource.should(property)
if property.to_s == 'gid'
self.gid = val
else
@property_hash[property] = val
end
end
end
end
def delete
@property_hash[:ensure] = :absent
end
def exists?
@property_hash[:ensure] != :absent
end
# Apply our changes to ldap, yo.
def flush
# Just call the manager's update() method.
@property_hash.delete(:groups)
@ldap_properties.delete(:groups)
manager.update(name, ldap_properties, properties)
@property_hash.clear
@ldap_properties.clear
end
def initialize(*args)
raise(Puppet::DevError, "No LDAP Configuration defined for #{self.class}") unless self.class.manager
raise(Puppet::DevError, "Invalid LDAP Configuration defined for #{self.class}") unless self.class.manager.valid?
super
@property_hash = @property_hash.inject({}) do |result, ary|
param, values = ary
# Skip any attributes we don't manage.
next result unless self.class.resource_type.valid_parameter?(param)
paramclass = self.class.resource_type.attrclass(param)
unless values.is_a?(Array)
result[param] = values
next result
end
# Only use the first value if the attribute class doesn't manage
# arrays of values.
if paramclass.superclass == Puppet::Parameter or paramclass.array_matching == :first
result[param] = values[0]
else
result[param] = values
end
result
end
# Make a duplicate, so that we have a copy for comparison
# at the end.
@ldap_properties = @property_hash.dup
end
# Return the current state of ldap.
def ldap_properties
@ldap_properties.dup
end
# Return (and look up if necessary) the desired state.
def properties
if @property_hash.empty?
@property_hash = query || {:ensure => :absent}
@property_hash[:ensure] = :absent if @property_hash.empty?
end
@property_hash.dup
end
# Collect the current attributes from ldap. Returns
# the results, but also stores the attributes locally,
# so we have something to compare against when we update.
# LAK:NOTE This is normally not used, because we rely on prefetching.
def query
# Use the module function.
unless attributes = manager.find(name)
@ldap_properties = {}
return nil
end
@ldap_properties = attributes
@ldap_properties.dup
end
end
puppet-3.4.3/lib/puppet/provider/file/ 0000755 0052762 0001160 00000000000 12300765640 017565 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/file/posix.rb 0000644 0052762 0001160 00000006260 12300765631 021260 0 ustar jenkins jenkins Puppet::Type.type(:file).provide :posix do
desc "Uses POSIX functionality to manage file ownership and permissions."
confine :feature => :posix
has_features :manages_symlinks
include Puppet::Util::POSIX
include Puppet::Util::Warnings
require 'etc'
def uid2name(id)
return id.to_s if id.is_a?(Symbol) or id.is_a?(String)
return nil if id > Puppet[:maximum_uid].to_i
begin
user = Etc.getpwuid(id)
rescue TypeError, ArgumentError
return nil
end
if user.uid == ""
return nil
else
return user.name
end
end
# Determine if the user is valid, and if so, return the UID
def name2uid(value)
Integer(value) rescue uid(value) || false
end
def gid2name(id)
return id.to_s if id.is_a?(Symbol) or id.is_a?(String)
return nil if id > Puppet[:maximum_uid].to_i
begin
group = Etc.getgrgid(id)
rescue TypeError, ArgumentError
return nil
end
if group.gid == ""
return nil
else
return group.name
end
end
def name2gid(value)
Integer(value) rescue gid(value) || false
end
def owner
unless stat = resource.stat
return :absent
end
currentvalue = stat.uid
# On OS X, files that are owned by -2 get returned as really
# large UIDs instead of negative ones. This isn't a Ruby bug,
# it's an OS X bug, since it shows up in perl, too.
if currentvalue > Puppet[:maximum_uid].to_i
self.warning "Apparently using negative UID (#{currentvalue}) on a platform that does not consistently handle them"
currentvalue = :silly
end
currentvalue
end
def owner=(should)
# Set our method appropriately, depending on links.
if resource[:links] == :manage
method = :lchown
else
method = :chown
end
begin
File.send(method, should, nil, resource[:path])
rescue => detail
raise Puppet::Error, "Failed to set owner to '#{should}': #{detail}"
end
end
def group
return :absent unless stat = resource.stat
currentvalue = stat.gid
# On OS X, files that are owned by -2 get returned as really
# large GIDs instead of negative ones. This isn't a Ruby bug,
# it's an OS X bug, since it shows up in perl, too.
if currentvalue > Puppet[:maximum_uid].to_i
self.warning "Apparently using negative GID (#{currentvalue}) on a platform that does not consistently handle them"
currentvalue = :silly
end
currentvalue
end
def group=(should)
# Set our method appropriately, depending on links.
if resource[:links] == :manage
method = :lchown
else
method = :chown
end
begin
File.send(method, nil, should, resource[:path])
rescue => detail
raise Puppet::Error, "Failed to set group to '#{should}': #{detail}"
end
end
def mode
if stat = resource.stat
return (stat.mode & 007777).to_s(8)
else
return :absent
end
end
def mode=(value)
begin
File.chmod(value.to_i(8), resource[:path])
rescue => detail
error = Puppet::Error.new("failed to set mode #{mode} on #{resource[:path]}: #{detail.message}")
error.set_backtrace detail.backtrace
raise error
end
end
end
puppet-3.4.3/lib/puppet/provider/file/windows.rb 0000644 0052762 0001160 00000004762 12300765631 021615 0 ustar jenkins jenkins Puppet::Type.type(:file).provide :windows do
desc "Uses Microsoft Windows functionality to manage file ownership and permissions."
confine :operatingsystem => :windows
has_feature :manages_symlinks if Puppet.features.manages_symlinks?
include Puppet::Util::Warnings
if Puppet.features.microsoft_windows?
require 'puppet/util/windows'
require 'puppet/util/adsi'
include Puppet::Util::Windows::Security
end
# Determine if the account is valid, and if so, return the UID
def name2id(value)
Puppet::Util::Windows::Security.name_to_sid(value)
end
# If it's a valid SID, get the name. Otherwise, it's already a name,
# so just return it.
def id2name(id)
if Puppet::Util::Windows::Security.valid_sid?(id)
Puppet::Util::Windows::Security.sid_to_name(id)
else
id
end
end
# We use users and groups interchangeably, so use the same methods for both
# (the type expects different methods, so we have to oblige).
alias :uid2name :id2name
alias :gid2name :id2name
alias :name2gid :name2id
alias :name2uid :name2id
def owner
return :absent unless resource.stat
get_owner(resource[:path])
end
def owner=(should)
begin
path = resource[:links] == :manage ? file.path.to_s : file.readlink
set_owner(should, path)
rescue => detail
raise Puppet::Error, "Failed to set owner to '#{should}': #{detail}"
end
end
def group
return :absent unless resource.stat
get_group(resource[:path])
end
def group=(should)
begin
path = resource[:links] == :manage ? file.path.to_s : file.readlink
set_group(should, path)
rescue => detail
raise Puppet::Error, "Failed to set group to '#{should}': #{detail}"
end
end
def mode
if resource.stat
mode = get_mode(resource[:path])
mode ? mode.to_s(8) : :absent
else
:absent
end
end
def mode=(value)
begin
set_mode(value.to_i(8), resource[:path])
rescue => detail
error = Puppet::Error.new("failed to set mode #{mode} on #{resource[:path]}: #{detail.message}")
error.set_backtrace detail.backtrace
raise error
end
:file_changed
end
def validate
if [:owner, :group, :mode].any?{|p| resource[p]} and !supports_acl?(resource[:path])
resource.fail("Can only manage owner, group, and mode on filesystems that support Windows ACLs, such as NTFS")
end
end
attr_reader :file
private
def file
@file ||= Puppet::FileSystem::File.new(resource[:path])
end
end
puppet-3.4.3/lib/puppet/provider/mcx/ 0000755 0052762 0001160 00000000000 12300765640 017435 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/mcx/mcxcontent.rb 0000644 0052762 0001160 00000010413 12300765631 022143 0 ustar jenkins jenkins require 'tempfile'
Puppet::Type.type(:mcx).provide :mcxcontent, :parent => Puppet::Provider do
desc "MCX Settings management using DirectoryService on OS X.
This provider manages the entire MCXSettings attribute available
to some directory services nodes. This management is 'all or nothing'
in that discrete application domain key value pairs are not managed
by this provider.
It is recommended to use WorkGroup Manager to configure Users, Groups,
Computers, or ComputerLists, then use 'ralsh mcx' to generate a puppet
manifest from the resulting configuration.
Original Author: Jeff McCune (mccune.jeff@gmail.com)
"
# This provides a mapping of puppet types to DirectoryService
# type strings.
TypeMap = {
:user => "Users",
:group => "Groups",
:computer => "Computers",
:computerlist => "ComputerLists",
}
class MCXContentProviderException < Exception
end
commands :dscl => "/usr/bin/dscl"
confine :operatingsystem => :darwin
defaultfor :operatingsystem => :darwin
def self.instances
mcx_list = []
TypeMap.keys.each do |ds_type|
ds_path = "/Local/Default/#{TypeMap[ds_type]}"
output = dscl 'localhost', '-list', ds_path
member_list = output.split
member_list.each do |ds_name|
content = mcxexport(ds_type, ds_name)
if content.empty?
Puppet.debug "/#{TypeMap[ds_type]}/#{ds_name} has no MCX data."
else
# This node has MCX data.
mcx_list << self.new(
:name => "/#{TypeMap[ds_type]}/#{ds_name}",
:ds_type => ds_type,
:ds_name => ds_name,
:content => content
)
end
end
end
mcx_list
end
def self.mcxexport(ds_type, ds_name)
ds_t = TypeMap[ds_type]
ds_n = ds_name.to_s
ds_path = "/Local/Default/#{ds_t}/#{ds_n}"
dscl 'localhost', '-mcxexport', ds_path
end
def create
self.content=(resource[:content])
end
def destroy
ds_parms = get_dsparams
ds_t = TypeMap[ds_parms[:ds_type]]
ds_n = ds_parms[:ds_name].to_s
ds_path = "/Local/Default/#{ds_t}/#{ds_n}"
dscl 'localhost', '-mcxdelete', ds_path
end
def exists?
begin
has_mcx?
rescue Puppet::ExecutionFailure
return false
end
end
def content
ds_parms = get_dsparams
self.class.mcxexport(ds_parms[:ds_type], ds_parms[:ds_name])
end
def content=(value)
# dscl localhost -mcximport
ds_parms = get_dsparams
mcximport(ds_parms[:ds_type], ds_parms[:ds_name], resource[:content])
end
private
def has_mcx?
!content.empty?
end
def mcximport(ds_type, ds_name, val)
ds_t = TypeMap[ds_type]
ds_path = "/Local/Default/#{ds_t}/#{ds_name}"
if has_mcx?
Puppet.debug "Removing MCX from #{ds_path}"
dscl 'localhost', '-mcxdelete', ds_path
end
tmp = Tempfile.new('puppet_mcx')
begin
tmp << val
tmp.flush
Puppet.debug "Importing MCX into #{ds_path}"
dscl 'localhost', '-mcximport', ds_path, tmp.path
ensure
tmp.close
tmp.unlink
end
end
# Given the resource name string, parse ds_type out.
def parse_type(name)
ds_type = name.split('/')[1]
unless ds_type
raise MCXContentProviderException,
"Coult not parse ds_type from resource name '#{name}'. Specify with ds_type parameter."
end
# De-pluralize and downcase.
ds_type = ds_type.chop.downcase.to_sym
unless TypeMap.key? ds_type
raise MCXContentProviderException,
"Coult not parse ds_type from resource name '#{name}'. Specify with ds_type parameter."
end
ds_type
end
# Given the resource name string, parse ds_name out.
def parse_name(name)
ds_name = name.split('/')[2]
unless ds_name
raise MCXContentProviderException,
"Could not parse ds_name from resource name '#{name}'. Specify with ds_name parameter."
end
ds_name
end
# Gather ds_type and ds_name from resource or parse it out of the name.
def get_dsparams
ds_type = resource[:ds_type]
ds_type ||= parse_type(resource[:name])
raise MCXContentProviderException unless TypeMap.keys.include? ds_type.to_sym
ds_name = resource[:ds_name]
ds_name ||= parse_name(resource[:name])
{
:ds_type => ds_type.to_sym,
:ds_name => ds_name,
}
end
end
puppet-3.4.3/lib/puppet/provider/exec.rb 0000644 0052762 0001160 00000006027 12300765631 020124 0 ustar jenkins jenkins require 'puppet/provider'
require 'puppet/util/execution'
class Puppet::Provider::Exec < Puppet::Provider
include Puppet::Util::Execution
def run(command, check = false)
output = nil
status = nil
dir = nil
checkexe(command)
if dir = resource[:cwd]
unless File.directory?(dir)
if check
dir = nil
else
self.fail "Working directory '#{dir}' does not exist"
end
end
end
dir ||= Dir.pwd
debug "Executing#{check ? " check": ""} '#{command}'"
begin
# Do our chdir
Dir.chdir(dir) do
environment = {}
environment[:PATH] = resource[:path].join(File::PATH_SEPARATOR) if resource[:path]
if envlist = resource[:environment]
envlist = [envlist] unless envlist.is_a? Array
envlist.each do |setting|
if setting =~ /^(\w+)=((.|\n)+)$/
env_name = $1
value = $2
if environment.include?(env_name) || environment.include?(env_name.to_sym)
warning "Overriding environment setting '#{env_name}' with '#{value}'"
end
environment[env_name] = value
else
warning "Cannot understand environment setting #{setting.inspect}"
end
end
end
Timeout::timeout(resource[:timeout]) do
# note that we are passing "false" for the "override_locale" parameter, which ensures that the user's
# default/system locale will be respected. Callers may override this behavior by setting locale-related
# environment variables (LANG, LC_ALL, etc.) in their 'environment' configuration.
output = Puppet::Util::Execution.execute(command, :failonfail => false, :combine => true,
:uid => resource[:user], :gid => resource[:group],
:override_locale => false,
:custom_environment => environment)
end
# The shell returns 127 if the command is missing.
if output.exitstatus == 127
raise ArgumentError, output
end
end
rescue Errno::ENOENT => detail
self.fail detail.to_s
end
# Return output twice as processstatus was returned before, but only exitstatus was ever called.
# Output has the exitstatus on it so it is returned instead. This is here twice as changing this
# would result in a change to the underlying API.
return output, output
end
def extractexe(command)
if command.is_a? Array
command.first
elsif match = /^"([^"]+)"|^'([^']+)'/.match(command)
# extract whichever of the two sides matched the content.
match[1] or match[2]
else
command.split(/ /)[0]
end
end
def validatecmd(command)
exe = extractexe(command)
# if we're not fully qualified, require a path
self.fail "'#{command}' is not qualified and no path was specified. Please qualify the command or specify a path." if !absolute_path?(exe) and resource[:path].nil?
end
end
puppet-3.4.3/lib/puppet/provider/mailalias/ 0000755 0052762 0001160 00000000000 12300765640 020602 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/mailalias/aliases.rb 0000644 0052762 0001160 00000001723 12300765631 022553 0 ustar jenkins jenkins require 'puppet/provider/parsedfile'
Puppet::Type.type(:mailalias).provide(
:aliases,
:parent => Puppet::Provider::ParsedFile,
:default_target => "/etc/aliases",
:filetype => :flat
) do
text_line :comment, :match => /^#/
text_line :blank, :match => /^\s*$/
record_line :aliases, :fields => %w{name recipient}, :separator => /\s*:\s*/, :block_eval => :instance do
def post_parse(record)
record[:recipient] = record[:recipient].split(/\s*,\s*/).collect { |d| d.gsub(/^['"]|['"]$/, '') }
record
end
def process(line)
ret = {}
records = line.split(':',2)
ret[:name] = records[0].strip
ret[:recipient] = records[1].strip
ret
end
def to_line(record)
dest = record[:recipient].collect do |d|
# Quote aliases that have non-alpha chars
if d =~ /[^-\w@.]/
'"%s"' % d
else
d
end
end.join(",")
"#{record[:name]}: #{dest}"
end
end
end
puppet-3.4.3/lib/puppet/provider/vlan/ 0000755 0052762 0001160 00000000000 12300765640 017606 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/vlan/cisco.rb 0000644 0052762 0001160 00000001040 12300765631 021226 0 ustar jenkins jenkins require 'puppet/provider/cisco'
Puppet::Type.type(:vlan).provide :cisco, :parent => Puppet::Provider::Cisco do
desc "Cisco switch/router provider for vlans."
mk_resource_methods
def self.lookup(device, id)
vlans = {}
device.command do |dev|
vlans = dev.parse_vlans || {}
end
vlans[id]
end
def initialize(device, *args)
super
end
# Clear out the cached values.
def flush
device.command do |dev|
dev.update_vlan(resource[:name], former_properties, properties)
end
super
end
end
puppet-3.4.3/lib/puppet/provider/augeas/ 0000755 0052762 0001160 00000000000 12300765640 020113 5 ustar jenkins jenkins puppet-3.4.3/lib/puppet/provider/augeas/augeas.rb 0000644 0052762 0001160 00000041267 12300765631 021717 0 ustar jenkins jenkins #
# Copyright 2011 Bryan Kearney