module Puppet

The main Puppet class. Everything is contained here.

@api public

The majority of Puppet’s configuration settings are set in this file.

see the bottom of the file for the rest of the inclusions

Manage file modes. This state should support different formats for specification (e.g., u+rwx, or -0011), but for now only supports specifying the full mode.

Manage SELinux context of files.

This code actually manages three pieces of data in the context.

[root@delenn files]# ls -dZ / drwxr-xr-x root root system_u:object_r:root_t /

The context of ‘/’ here is ‘system_u:object_r:root_t’. This is three seperate fields:

system_u is the user context object_r is the role context root_t is the type context

All three of these fields are returned in a single string by the output of the stat command, but set individually with the chcon command. This allows the user to specify a subset of the three values while leaving the others alone.

See www.nsa.gov/selinux/ for complete docs on SELinux.

Simple module for logging messages on the client-side

Manage a router abstraction

This is our main way of managing processes right now.

a service is distinct from a process in that services can only be managed through the interface of an init script which is why they have a search path for initscripts and such

A common module for converting between constants and file names.

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.

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`

Constants

ABSENT_DOC

Doc string for properties that can be made ‘absent’

Face
Log

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.

Metric

A class for handling metrics. This is currently ridiculously hackish.

PUPPETVERSION
ResourceType
SEPARATOR_REGEX
ScheduleMethods
ScheduleScales

Attributes

features[R]
filetype[RW]
inifile[W]
name[W]
yumconf[RW]

The writer is only used for testing, there should be no need to change yumconf or inifile in any other context

Public Class Methods

[](param) click to toggle source

Get the value for a setting

@param [Symbol] param the setting to retrieve

@api public

# File lib/puppet.rb, line 60
def self.[](param)
  if param == :debug
    return Puppet::Util::Log.level == :debug
  else
    return @@settings[param]
  end
end
[]=(param,value) click to toggle source

configuration parameter access and stuff

# File lib/puppet.rb, line 69
def self.[]=(param,value)
  @@settings[param] = value
end
checks() click to toggle source 
# File lib/puppet/type/exec.rb, line 41
def self.checks
  @checks.keys
end
clear() click to toggle source 
# File lib/puppet.rb, line 73
def self.clear
  @@settings.clear
end
debug=(value) click to toggle source 
# File lib/puppet.rb, line 77
def self.debug=(value)
  if value
    Puppet::Util::Log.level=(:debug)
  else
    Puppet::Util::Log.level=(:notice)
  end
end
define_settings(section, hash) click to toggle source

Store a new default value.

# File lib/puppet.rb, line 51
def self.define_settings(section, hash)
  @@settings.define_settings(section, hash)
end
genmanifest() click to toggle source 
# File lib/puppet.rb, line 107
def self.genmanifest
  if Puppet[:genmanifest]
    puts Puppet.settings.to_manifest
    exit(0)
  end
end
inifile() click to toggle source

Return the Puppet::Util::IniConfig::File for the whole yum config

# File lib/puppet/type/yumrepo.rb, line 105
def self.inifile
  if @inifile.nil?
    @inifile = read
    main = @inifile['main']
    raise Puppet::Error, "File #{yumconf} does not contain a main section" if main.nil?
    reposdir = main['reposdir']
    reposdir ||= "/etc/yum.repos.d, /etc/yum/repos.d"
    reposdir.gsub!(/[\n,]/, " ")
    reposdir.split.each do |dir|
      Dir::glob("#{dir}/*.repo").each do |file|
        @inifile.read(file) if ::File.file?(file)
      end
    end
    reposdir.split.each do |dir|
      if ::File.directory?(dir) && ::File.writable?(dir)
        @defaultrepodir = dir
        break
      end
    end
  end
  @inifile
end
initialize_settings(args = []) click to toggle source

Initialize puppet’s settings. This is intended only for use by external tools that are not

built off of the Faces API or the Puppet::Util::Application class. It may also be used
to initialize state so that a Face may be used programatically, rather than as a stand-alone
command-line tool.

@api public @param args [Array<String>] the command line arguments to use for initialization @return [void]

# File lib/puppet.rb, line 129
def self.initialize_settings(args = [])
  do_initialize_settings_for_run_mode(:user, args)
end
initialize_settings_for_run_mode(run_mode) click to toggle source

Initialize puppet’s settings for a specified run_mode.

@deprecated Use {#initialize_settings}

# File lib/puppet.rb, line 136
def self.initialize_settings_for_run_mode(run_mode)
  Puppet.deprecation_warning("initialize_settings_for_run_mode may be removed in a future release, as may run_mode itself")
  do_initialize_settings_for_run_mode(run_mode, [])
end
instances() click to toggle source 
# File lib/puppet/type/exec.rb, line 485
def self.instances
  []
end
mkdefaultbucket() click to toggle source

Create a default filebucket.

# File lib/puppet/type/filebucket.rb, line 79
def self.mkdefaultbucket
  new(:name => "puppet", :path => Puppet[:clientbucketdir])
end
mkdefaultschedules() click to toggle source 
# File lib/puppet/type/schedule.rb, line 422
def self.mkdefaultschedules
  result = []
  Puppet.debug "Creating default schedules"

        result << self.new(

    :name => "puppet",
    :period => :hourly,

    :repeat => "2"
  )

  # And then one for every period
  @parameters.find { |p| p.name == :period }.value_collection.values.each { |value|

          result << self.new(
      :name => value.to_s,
      :period => value
    )
  }

  result
end
newcheck(name, options = {}, &block) click to toggle source

Create a new check mechanism. It’s basically just a parameter that provides one extra ‘check’ method.

# File lib/puppet/type/exec.rb, line 34
def self.newcheck(name, options = {}, &block)
  @checks ||= {}

  check = newparam(name, options, &block)
  @checks[name] = check
end
newtype(name, options = {}, &block) click to toggle source

Create a new type. Just proxy to the Type class. The mirroring query code was deprecated in 2008, but this is still in heavy use. I suppose this can count as a soft deprecation for the next dev. –daniel 2011-04-12

# File lib/puppet.rb, line 153
def self.newtype(name, options = {}, &block)
  Puppet::Type.newtype(name, options, &block)
end
parse_config() click to toggle source

Parse the config file for this process. @deprecated Use {#initialize_settings}

# File lib/puppet.rb, line 116
def self.parse_config()
  Puppet.deprecation_warning("Puppet.parse_config is deprecated; please use Faces API (which will handle settings and state management for you), or (less desirable) call Puppet.initialize_settings")
  Puppet.initialize_settings
end
read() click to toggle source

Parse the yum config files. Only exposed for the tests Non-test code should use self.inifile to get at the underlying file

# File lib/puppet/type/yumrepo.rb, line 131
def self.read
  result = Puppet::Util::IniConfig::File.new
  result.read(yumconf)
  main = result['main']
  raise Puppet::Error, "File #{yumconf} does not contain a main section" if main.nil?
  reposdir = main['reposdir']
  reposdir ||= "/etc/yum.repos.d, /etc/yum/repos.d"
  reposdir.gsub!(/[\n,]/, " ")
  reposdir.split.each do |dir|
    Dir::glob("#{dir}/*.repo").each do |file|
      result.read(file) if ::File.file?(file)
    end
  end
  if @defaultrepodir.nil?
    reposdir.split.each do |dir|
      if ::File.directory?(dir) && ::File.writable?(dir)
        @defaultrepodir = dir
        break
      end
    end
  end
  result
end
run_mode() click to toggle source 
# File lib/puppet.rb, line 90
def self.run_mode
  # This sucks (the existence of this method); there are a lot of places in our code that branch based the value of
  # "run mode", but there used to be some really confusing code paths that made it almost impossible to determine
  # when during the lifecycle of a puppet application run the value would be set properly.  A lot of the lifecycle
  # stuff has been cleaned up now, but it still seems frightening that we rely so heavily on this value.
  #
  # I'd like to see about getting rid of the concept of "run_mode" entirely, but there are just too many places in
  # the code that call this method at the moment... so I've settled for isolating it inside of the Settings class
  # (rather than using a global variable, as we did previously...).  Would be good to revisit this at some point.
  #
  # --cprice 2012-03-16
  Puppet::Util::RunMode[@@settings.preferred_run_mode]
end
section(name) click to toggle source

Return the Puppet::Util::IniConfig::Section with name NAME from the yum config

# File lib/puppet/type/yumrepo.rb, line 157
def self.section(name)
  result = inifile[name]
  if result.nil?
    # Brand new section
    path = yumconf
    path = ::File.join(@defaultrepodir, "#{name}.repo") unless @defaultrepodir.nil?
    Puppet::info "create new repo #{name} in file #{path}"
    result = inifile.add_section(name, path)
  end
  result
end
settings() click to toggle source 
# File lib/puppet.rb, line 85
def self.settings
  @@settings
end
store() click to toggle source

Store all modifications back to disk

# File lib/puppet/type/yumrepo.rb, line 170
def self.store
  inifile.store
  unless Puppet[:noop]
    target_mode = 0644 # FIXME: should be configurable
    inifile.each_file do |file|
      current_mode = ::File.stat(file).mode & 0777
      unless current_mode == target_mode
        Puppet::info "changing mode of #{file} from %03o to %03o" % [current_mode, target_mode]
        ::File.chmod(target_mode, file)
      end
    end
  end
end
version() click to toggle source

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”

# File lib/puppet/version.rb, line 62
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
version=(version) click to toggle source 
# File lib/puppet/version.rb, line 71
def self.version=(version)
  @puppet_version = version
end

Public Instance Methods

bucket() click to toggle source 
# File lib/puppet/type/filebucket.rb, line 83
def bucket
  mkbucket unless defined?(@bucket)
  @bucket
end
change_to_s(currentvalue, newvalue) click to toggle source

Make output a bit prettier

# File lib/puppet/type/exec.rb, line 63
def change_to_s(currentvalue, newvalue)
  "executed successfully"
end
check(value) click to toggle source

We always fail this test, because we’re only supposed to run on refresh.

# File lib/puppet/type/exec.rb, line 304
def check(value)
  # We have to invert the values.
  if value == :true
    false
  else
    true
  end
end
check_all_attributes(refreshing = false) click to toggle source

Verify that we pass all of the checks. The argument determines whether we skip the :refreshonly check, which is necessary because we now check within refresh

# File lib/puppet/type/exec.rb, line 492
def check_all_attributes(refreshing = false)
  self.class.checks.each { |check|
    next if refreshing and check == :refreshonly
    if @parameters.include?(check)
      val = @parameters[check].value
      val = [val] unless val.is_a? Array
      val.each do |value|
        return false unless @parameters[check].check(value)
      end
    end
  }

  true
end
checksum() click to toggle source 
# File lib/puppet/type/file/source.rb, line 95
def checksum
  metadata && metadata.checksum
end
checksum_type() click to toggle source 
# File lib/puppet/type/file/content.rb, line 75
def checksum_type
  if source = resource.parameter(:source)
    result = source.checksum
  else checksum = resource.parameter(:checksum)
    result = resource[:checksum]
  end
  if result =~ /^\{(\w+)\}.+/
    return $1.to_sym
  else
    return result
  end
end
chunk_file_from_disk(source_or_content) { |chunk| ... } click to toggle source 
# File lib/puppet/type/file/content.rb, line 195
def chunk_file_from_disk(source_or_content)
  File.open(source_or_content.full_path, "rb") do |src|
    while chunk = src.read(8192)
      yield chunk
    end
  end
end
chunk_file_from_source(source_or_content) { |uncompress| ... } click to toggle source 
# File lib/puppet/type/file/content.rb, line 213
def chunk_file_from_source(source_or_content)
  get_from_source(source_or_content) do |response|
    case response.code
    when /^2/;  uncompress(response) { |uncompressor| response.read_body { |chunk| yield uncompressor.uncompress(chunk) } }
    else
      # Raise the http error if we didn't get a 'success' of some kind.
      message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
      raise Net::HTTPError.new(message, response)
    end
  end
end
clear() click to toggle source

This only exists for testing.

# File lib/puppet/type/package.rb, line 362
def clear
  if obj = @parameters[:ensure]
    obj.latest = nil
  end
end
content() click to toggle source 
# File lib/puppet/type/file/content.rb, line 92
def content
  self.should
end
content_is_really_a_checksum?() click to toggle source 
# File lib/puppet/type/file/content.rb, line 191
def content_is_really_a_checksum?
  checksum?(should)
end
copy_source_values() click to toggle source

Copy the values from the source to the resource. Yay.

# File lib/puppet/type/file/source.rb, line 111
def copy_source_values
  devfail "Somehow got asked to copy source values without any metadata" unless metadata

  # Take each of the stats and set them as states on the local file
  # if a value has not already been provided.
  [:owner, :mode, :group, :checksum].each do |metadata_method|
    param_name = (metadata_method == :checksum) ? :content : metadata_method
    next if metadata_method == :owner and !Puppet.features.root?
    next if metadata_method == :checksum and metadata.ftype == "directory"
    next if metadata_method == :checksum and metadata.ftype == "link" and metadata.links == :manage

    if Puppet.features.microsoft_windows?
      next if [:owner, :group].include?(metadata_method) and !local?
    end

    if resource[param_name].nil? or resource[param_name] == :absent
      resource[param_name] = metadata.send(metadata_method)
    end
  end

  if resource[:ensure] == :absent
    # We know all we need to
  elsif metadata.ftype != "link"
    resource[:ensure] = metadata.ftype
  elsif @resource[:links] == :follow
    resource[:ensure] = :present
  else
    resource[:ensure] = "link"
    resource[:target] = metadata.destination
  end
end
delimiter() click to toggle source 
# File lib/puppet/type/group.rb, line 122
def delimiter
  " "
end
desired_mode_from_current(desired, current) click to toggle source 
# File lib/puppet/type/file/mode.rb, line 74
def desired_mode_from_current(desired, current)
  current = current.to_i(8) if current.is_a? String
  is_a_directory = @resource.stat and @resource.stat.directory?
  symbolic_mode_to_int(desired, current, is_a_directory)
end
dirmask(value) click to toggle source

If we’re a directory, we need to be executable for all cases that are readable. This should probably be selectable, but eh.

# File lib/puppet/type/file/mode.rb, line 82
def dirmask(value)
  orig = value
  if FileTest.directory?(resource[:path]) and value =~ /^\d+$/ then
    value = value.to_i(8)
    value |= 0100 if value & 0400 != 0
    value |= 010 if value & 040 != 0
    value |= 01 if value & 04 != 0
    value = value.to_s(8)
  end

  value
end
each_chunk_from(source_or_content) { |source_or_content| ... } click to toggle source

the content is munged so if it’s a checksum source_or_content is nil unless the checksum indirectly comes from source

# File lib/puppet/type/file/content.rb, line 173
def each_chunk_from(source_or_content)
  if source_or_content.is_a?(String)
    yield source_or_content
  elsif content_is_really_a_checksum? && source_or_content.nil?
    yield read_file_from_filebucket
  elsif source_or_content.nil?
    yield ''
  elsif Puppet[:default_file_terminus] == :file_server
    yield source_or_content.content
  elsif source_or_content.local?
    chunk_file_from_disk(source_or_content) { |chunk| yield chunk }
  else
    chunk_file_from_source(source_or_content) { |chunk| yield chunk }
  end
end
event_name() click to toggle source 
# File lib/puppet/type/exec.rb, line 51
def event_name
  :executed_command
end
exists?() click to toggle source

This method has been exposed for puppet to manage users and groups of files in its settings and should not be considered available outside of puppet.

(see Puppet::Settings#service_group_available?)

@returns [Boolean] if the group exists on the system @api private

# File lib/puppet/type/group.rb, line 157
def exists?
  provider.exists?
end
flush() click to toggle source

Store modifications to this yumrepo resource back to disk

# File lib/puppet/type/yumrepo.rb, line 197
def flush
  self.class.store
end
found?() click to toggle source 
# File lib/puppet/type/file/source.rb, line 143
def found?
  ! (metadata.nil? or metadata.ftype.nil?)
end
full_path() click to toggle source 
# File lib/puppet/type/file/source.rb, line 174
def full_path
  Puppet::Util.uri_to_path(uri) if found?
end
generate() click to toggle source 
# File lib/puppet/type/maillist.rb, line 48
def generate
  if provider.respond_to?(:aliases)
    should = self.should(:ensure) || :present
    if should == :purged
      should = :absent
    end
    atype = Puppet::Type.type(:mailalias)

    provider.aliases.
      reject  { |name,recipient| catalog.resource(:mailalias, name) }.
      collect { |name,recipient| atype.new(:name => name, :recipient => recipient, :ensure => should) }
  end
end
get_from_source(source_or_content, &block) click to toggle source 
# File lib/puppet/type/file/content.rb, line 203
def get_from_source(source_or_content, &block)
  request = Puppet::Indirector::Request.new(:file_content, :find, source_or_content.full_path.sub(/^\//,''), nil, :environment => resource.catalog.environment)

  request.do_request(:fileserver) do |req|
    connection = Puppet::Network::HttpPool.http_instance(req.server, req.port)
    connection.request_get(indirection2uri(req), add_accept_encoding({"Accept" => "raw"}), &block)
  end
end
inclusive?() click to toggle source 
# File lib/puppet/type/host.rb, line 41
def inclusive?
  true
end
insync?(is) click to toggle source

Override this method to provide diffs if asked for. Also, fix #872: when content is used, and replace is true, the file should be insync when it exists

Calls superclass method 
# File lib/puppet/type/file/content.rb, line 99
def insync?(is)
  if resource.should_be_file?
    return false if is == :absent
  else
    return true
  end

  return true if ! @resource.replace?

  result = super

  if ! result and Puppet[:show_diff]
    write_temporarily do |path|
      notice "\n" + diff(@resource[:path], path)
    end
  end
  result
end
is_to_s(currentvalue) click to toggle source

We want to print names, not numbers

# File lib/puppet/type/file/group.rb, line 33
def is_to_s(currentvalue)
  provider.gid2name(currentvalue) || currentvalue
end
length() click to toggle source 
# File lib/puppet/type/file/content.rb, line 88
def length
  (actual_content and actual_content.length) || 0
end
local?() click to toggle source 
# File lib/puppet/type/file/source.rb, line 170
def local?
  found? and scheme == "file"
end
match?(previous, now) click to toggle source 
# File lib/puppet/type/schedule.rb, line 130
def match?(previous, now)
  # The lowest-level array is of the hour, minute, second triad
  # then it's an array of two of those, to present the limits
  # then it's array of those ranges
  @value = [@value] unless @value[0][0].is_a?(Array)

  @value.each do |value|
    limits = value.collect do |range|
      ary = [now.year, now.month, now.day, range[0]]
      if range[1]
        ary << range[1]
      else
        ary << 0
      end

      if range[2]
        ary << range[2]
      else
        ary << 0
      end

      time = Time.local(*ary)

      unless time.hour == range[0]
        self.devfail(
          "Incorrectly converted time: #{time}: #{time.hour} vs #{range[0]}"
        )
      end

      time
    end

    unless limits[0] < limits[1]
      self.info(
      "Assuming upper limit should be that time the next day"
      )

      # Find midnight between the two days. Adding one second
      # to the end of the day is easier than dealing with dates.
      ary = limits[0].to_a
      ary[0] = 59
      ary[1] = 59
      ary[2] = 23
      midnight = Time.local(*ary)+1

      # If it is currently between the range start and midnight
      # we consider that a successful match.
      if now.between?(limits[0], midnight)
        # We have to check the weekday match here as it is special-cased
        # to support day-spanning ranges.
        if @resource[:weekday]
          return false unless @resource[:weekday].has_key?(now.wday)
        end
        return true
      end

      # If we didn't match between the starting time and midnight
      # we must now move our midnight back 24 hours and try
      # between the new midnight (24 hours prior) and the
      # ending time.
      midnight -= 86400

      # Now we compare the current time between midnight and the
      # end time.
      if now.between?(midnight, limits[1])
        # This case is the reason weekday matching is special cased
        # in the range parameter. If we match a range that has spanned
        # past midnight we want to match against the weekday when the range
        # started, not when it currently is.
        if @resource[:weekday]
          return false unless @resource[:weekday].has_key?((now - 86400).wday)
        end
        return true
      end

      # If neither of the above matched then we don't match the
      # range schedule.
      return false
    end

    # Check to see if a weekday parameter was specified and, if so,
    # do we match it or not. If we fail we can stop here.
    # This is required because spanning ranges forces us to check
    # weekday within the range parameter.
    if @resource[:weekday]
      return false unless @resource[:weekday].has_key?(now.wday)
    end

    return true if now.between?(*limits)
  end

  # Else, return false, since our current time isn't between
  # any valid times
  false
end
membership() click to toggle source 
# File lib/puppet/type/group.rb, line 118
def membership
  :attribute_membership
end
metadata() click to toggle source

Provide, and retrieve if necessary, the metadata for this file. Fail if we can’t find data about this host, and fail if there are any problems in our query.

# File lib/puppet/type/file/source.rb, line 152
def metadata
  return @metadata if @metadata
  return nil unless value
  value.each do |source|
    begin
      if data = Puppet::FileServing::Metadata.indirection.find(source, :environment => resource.catalog.environment)
        @metadata = data
        @metadata.source = source
        break
      end
    rescue => detail
      fail detail, "Could not retrieve file metadata for #{source}: #{detail}"
    end
  end
  fail "Could not retrieve information from environment #{resource.catalog.environment} source(s) #{value.join(", ")}" unless @metadata
  @metadata
end
mkbucket() click to toggle source 
# File lib/puppet/type/filebucket.rb, line 90
def mkbucket
  # Default is a local filebucket, if no server is given.
  # If the default path has been removed, too, then
  # the puppetmaster is used as default server

  type = "local"
  args = {}
  if self[:path]
    args[:Path] = self[:path]
  else
    args[:Server] = self[:server]
    args[:Port] = self[:port]
  end

  begin
    @bucket = Puppet::FileBucket::Dipper.new(args)
  rescue => detail
    message = "Could not create #{type} filebucket: #{detail}"
    self.log_exception(detail, message)
    self.fail(message)
  end

  @bucket.name = self.name
end
mklink() click to toggle source

Create our link.

output() click to toggle source 
# File lib/puppet/type/exec.rb, line 507
def output
  if self.property(:returns).nil?
    return nil
  else
    return self.property(:returns).output
  end
end
port() click to toggle source 
# File lib/puppet/type/file/source.rb, line 186
def port
  (uri and uri.port) or Puppet.settings[:masterport]
end
property_matches?(current, desired) click to toggle source 
# File lib/puppet/type/file/mode.rb, line 106
def property_matches?(current, desired)
  return false unless current
  current_bits = normalize_symbolic_mode(current)
  desired_bits = desired_mode_from_current(desired, current).to_s(8)
  current_bits == desired_bits
end
read_file_from_filebucket() click to toggle source 
# File lib/puppet/type/file/content.rb, line 225
def read_file_from_filebucket
  raise "Could not get filebucket from file" unless dipper = resource.bucket
  sum = should.sub(/\{\w+\}/, '')

  dipper.getfile(sum)
rescue => detail
  fail "Could not retrieve content for #{should} from filebucket: #{detail}"
end
refresh() click to toggle source

Run the command, or optionally run a separately-specified command.

# File lib/puppet/type/exec.rb, line 516
def refresh
  if self.check_all_attributes(true)
    if cmd = self[:refresh]
      provider.run(cmd)
    else
      self.property(:returns).sync
    end
  end
end
retrieve() click to toggle source

First verify that all of our checks pass.

# File lib/puppet/type/exec.rb, line 68
def retrieve
  # We need to return :notrun to trigger evaluation; when that isn't
  # true, we *LIE* about what happened and return a "success" for the
  # value, which causes us to be treated as in_sync?, which means we
  # don't actually execute anything.  I think. --daniel 2011-03-10
  if @resource.check_all_attributes
    return :notrun
  else
    return self.should
  end
end
scheme() click to toggle source 
# File lib/puppet/type/file/source.rb, line 191
def scheme
  (uri and uri.scheme)
end
section() click to toggle source

Return the Puppet::Util::IniConfig::Section for this yumrepo resource

# File lib/puppet/type/yumrepo.rb, line 192
def section
  self.class.section(self[:name])
end
server() click to toggle source 
# File lib/puppet/type/file/source.rb, line 182
def server
  (uri and uri.host) or Puppet.settings[:server]
end
server?() click to toggle source 
# File lib/puppet/type/file/source.rb, line 178
def server?
   uri and uri.host
end
should() click to toggle source 
# File lib/puppet/type/mailalias.rb, line 23
def should
  @should
end
should=(value) click to toggle source

Make sure we’re also managing the checksum property.

Calls superclass method 
# File lib/puppet/type/file/content.rb, line 132
def should=(value)
  @resource.newattr(:checksum) unless @resource.parameter(:checksum)
  super
end
should_to_s(newvalue) click to toggle source 
# File lib/puppet/type/file/group.rb, line 37
def should_to_s(newvalue)
  provider.gid2name(newvalue) || newvalue
end
sync() click to toggle source

Actually execute the command.

# File lib/puppet/type/exec.rb, line 81
def sync
  olddir = nil

  # We need a dir to change to, even if it's just the cwd
  dir = self.resource[:cwd] || Dir.pwd

  event = :executed_command
  tries = self.resource[:tries]
  try_sleep = self.resource[:try_sleep]

  begin
    tries.times do |try|
      # Only add debug messages for tries > 1 to reduce log spam.
      debug("Exec try #{try+1}/#{tries}") if tries > 1
      @output, @status = provider.run(self.resource[:command])
      break if self.should.include?(@status.exitstatus.to_s)
      if try_sleep > 0 and tries > 1
        debug("Sleeping for #{try_sleep} seconds between tries")
        sleep try_sleep
      end
    end
  rescue Timeout::Error
    self.fail "Command exceeded timeout" % value.inspect
  end

  if log = @resource[:logoutput]
    case log
    when :true
      log = @resource[:loglevel]
    when :on_failure
      unless self.should.include?(@status.exitstatus.to_s)
        log = @resource[:loglevel]
      else
        log = :false
      end
    end
    unless log == :false
      @output.split(/\n/).each { |line|
        self.send(log, line)
      }
    end
  end

  unless self.should.include?(@status.exitstatus.to_s)
    self.fail("#{self.resource[:command]} returned #{@status.exitstatus} instead of one of [#{self.should.join(",")}]")
  end

  event
end
syncothers() click to toggle source 
# File lib/puppet/type/mount.rb, line 97
def syncothers
  # We have to flush any changes to disk.
  currentvalues = @resource.retrieve_resource

  # Determine if there are any out-of-sync properties.
  oos = @resource.send(:properties).find_all do |prop|
    unless currentvalues.include?(prop)
      raise Puppet::DevError, "Parent has property %s but it doesn't appear in the current values", [prop.name]
    end
    if prop.name == :ensure
      false
    else
      ! prop.safe_insync?(currentvalues[prop])
    end
  end.each { |prop| prop.sync }.length
  @resource.flush if oos > 0
end
uri() click to toggle source 
# File lib/puppet/type/file/source.rb, line 195
def uri
  @uri ||= URI.parse(URI.escape(metadata.source))
end
valid_v4?(addr) click to toggle source 
# File lib/puppet/type/host.rb, line 11
def valid_v4?(addr)
  if /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/ =~ addr
    return $~.captures.all? {|i| i = i.to_i; i >= 0 and i <= 255 }
  end
  return false
end
valid_v6?(addr) click to toggle source 
# File lib/puppet/type/host.rb, line 18
def valid_v6?(addr)
  # http://forums.dartware.com/viewtopic.php?t=452
  # ...and, yes, it is this hard.  Doing it programatically is harder.
  return true if addr =~ /^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$/

  return false
end
value(name) click to toggle source 
# File lib/puppet/type/mount.rb, line 223
def value(name)
  name = name.intern
  ret = nil
  if property = @parameters[name]
    return property.value
  end
end
value=(*values) click to toggle source

Support both arrays and colon-separated fields.

# File lib/puppet/type/exec.rb, line 148
def value=(*values)
  @value = values.flatten.collect { |val|
    val.split(File::PATH_SEPARATOR)
  }.flatten
end
write(file) click to toggle source 
# File lib/puppet/type/file/content.rb, line 162
def write(file)
  resource.parameter(:checksum).sum_stream { |sum|
    each_chunk_from(actual_content || resource.parameter(:source)) { |chunk|
      sum << chunk
      file.print chunk
    }
  }
end
write_temporarily() { |path| ... } click to toggle source 
# File lib/puppet/type/file/content.rb, line 149
def write_temporarily
  tempfile = Tempfile.new("puppet-file")
  tempfile.open

  write(tempfile)

  tempfile.close

  yield tempfile.path

  tempfile.delete
end