Class: ShadowPuppet::Manifest

Inherits:
Object
  • Object
show all
Defined in:
lib/shadow_puppet/test.rb,
lib/shadow_puppet/manifest.rb

Overview

A Manifest is an executable collection of Puppet Resources.

===Example

class ManifestExample < ShadowPuppet::Manifest
recipe :sample
recipe :lamp, :ruby               # queue calls to self.lamp and
                                  # self.ruby when executing

recipe :mysql, {                  # queue a call to self.mysql
  :root_password => 'OMGSEKRET'   # passing the provided hash
}                                 # as an option

def sample
  exec :foo, :command => 'echo "foo" > /tmp/foo.txt'

  package :foo, :ensure => :installed

  file '/tmp/example.txt',
    :ensure   => :present,
    :contents => Facter.to_hash_inspect,
    :require  => package(:foo)
end

def lamp
  #install a basic LAMP stack
end

def ruby
  #install a ruby interpreter and tools
end

def mysql(options)
   #install a mysql server and set the root password to options[:root_password]
end

end

To execute the above manifest, instantiate it and call execute on it:

m = ManifestExample.new
m.execute

As shown in the sample method in ManifestExample above, instance methods are created for each Puppet::Type available on your system. These methods behave identally to the Puppet Resources methods. See here for documentation on these methods.

To view a list of all defined methods on your system, run:

ruby -rubygems -e 'require "shadow_puppet";puts ShadowPuppet::Manifest.puppet_type_methods'

The use of methods (+sample+, lamp, ruby, and mysql above) as a container for resources facilitates recipie re-use through the use of Ruby Modules. For example:

module ApachePuppet
# Required options:
#   domain
#   path
def php_vhost(options)
  #...
end
end

class MyWebMainfest < ShadowPuppet::Manifest
include ApachePuppet
recipe :php_vhost, {
  :domain => 'foo.com',
  :path => '/var/www/apps/foo'
}
end

Direct Known Subclasses

Setup

Defined Under Namespace

Classes: Setup

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(config = {}) ⇒ Manifest

Initialize a new instance of this manifest. This can take a config hash, which is immediately passed on to the configure method



85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/shadow_puppet/manifest.rb', line 85

def initialize(config = {})
  if Process.uid == 0
    Puppet[:confdir] = File.expand_path("/etc/shadow_puppet")
    Puppet[:vardir] = File.expand_path("/var/shadow_puppet")
  else
    Puppet[:confdir] = File.expand_path("~/.shadow_puppet")
    Puppet[:vardir] = File.expand_path("~/.shadow_puppet/var")
  end
  Puppet[:user] = Process.uid
  Puppet[:group] = Process.gid
  Puppet::Util::Log.newdestination(:console)

  configure(config)
  @executed = false
  @puppet_resources = Hash.new do |hash, key|
    hash[key] = {}
  end
end

Instance Attribute Details

#puppet_resources ⇒ Object (readonly)

Returns the value of attribute puppet_resources.



78
79
80
 
# File 'lib/shadow_puppet/manifest.rb', line 78

def puppet_resources
  @puppet_resources
end

Class Method Details

.configuration ⇒ Object

A hash describing any configuration that has been performed on the class. Modify this hash by calling configure:

class SampleManifest < ShadowPuppet::Manifest
configure(:name => 'test')
end

>> SampleManifest.configuration
=> {:name => 'test'}

All keys on this hash are coerced into symbols for ease of access.

Subclasses of the Manifest class properly inherit the parent classes' configuration.



136
137
138
 
# File 'lib/shadow_puppet/manifest.rb', line 136

def self.configuration
  __config__.deep_symbolize_keys
end

.configure(hash) ⇒ Object

Define configuration on this manifest. This is useful for storing things such as hostnames, password, or usernames that may change between different implementations of a shared manifest. Access this hash by calling configuration:

class SampleManifest < ShadowPuppet::Manifest
configure('name' => 'test')
end

>> SampleManifest.configuration
=> {:name => 'test'}

All keys on this hash are coerced into symbols for ease of access.

Subsequent calls to configure perform a deep_merge of the provided hash into the pre-existing configuration.



168
169
170
 
# File 'lib/shadow_puppet/manifest.rb', line 168

def self.configure(hash)
  __config__.deep_merge!(hash)
end

.puppet_type_methods ⇒ Object

An array of all methods defined for creation of Puppet Resources



187
188
189
 
# File 'lib/shadow_puppet/manifest.rb', line 187

def self.puppet_type_methods
  Puppet::Type.eachtype { |t| t.name }.keys.map { |n| n.to_s }.sort.inspect
end

.recipe(*methods) ⇒ Object

Declares that the named method or methods will be called whenever execute is called on an instance of this class. If the last argument is a Hash, this hash is passed as an argument to all provided methods. If no options hash is provided, each method is passed the contents of configuration.

Subclasses of the Manifest class properly inherit the parent classes' calls to recipe.



112
113
114
115
116
117
118
119
120
 
# File 'lib/shadow_puppet/manifest.rb', line 112

def self.recipe(*methods)
  return nil if methods.nil? || methods == []
  options = methods.extract_options!
  methods.each do |meth|
    options = configuration[meth.to_sym] if options == {}
    options ||= {}
    recipes << [meth.to_sym, options]
  end
end

.register_puppet_types ⇒ Object

Create an instance method for every type that either creates or references a resource



197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
# File 'lib/shadow_puppet/manifest.rb', line 197

def self.register_puppet_types
  Puppet::Type.loadall
  Puppet::Type.eachtype do |type|
    #remove the method rdoc placeholders
    remove_method(type.name) rescue nil
    define_method(type.name) do |*args|
      if args && args.flatten.size == 1
        reference(type.name, args.first)
      else
        new_resource(type, args.first, args.last)
      end
    end
  end
end

.register_puppet_types_for_testing ⇒ Object

Creates an instance method for every puppet type that either creates or references a resource



55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/shadow_puppet/test.rb', line 55

def self.register_puppet_types_for_testing
  Puppet::Type.loadall
  Puppet::Type.eachtype do |type|
    plural_type = type.name.to_s.downcase.pluralize
    #undefine the method rdoc placeholders
    undef_method(plural_type) rescue nil
    define_method(plural_type) do |*args|
      puppet_resources[type]
    end
  end
end

Instance Method Details

#configuration ⇒ Object

Access to the configuration of the class of this instance.

class SampleManifest < ShadowPuppet::Manifest
configure(:name => 'test')
end

@manifest = SampleManifest.new
@manifest.configuration[:name] => "test"


148
149
150
 
# File 'lib/shadow_puppet/manifest.rb', line 148

def configuration
  self.class.configuration
end

#configure(hash) ⇒ Object Also known as: configuration=

Update the configuration of this manifest instance's class.

class SampleManifest < ShadowPuppet::Manifest
configure({})
end

@manifest = SampleManifest.new
@manifest.configure(:name => "test")
@manifest.configuration[:name] => "test"


181
182
183
 
# File 'lib/shadow_puppet/manifest.rb', line 181

def configure(hash)
  self.class.configure(hash)
end

#executable? ⇒ Boolean

Returns true if this Manifest respond_to? all methods named by calls to recipe, and if this Manifest has not been executed before.

Returns:

  • (Boolean) 


215
216
217
218
219
220
221
 
# File 'lib/shadow_puppet/manifest.rb', line 215

def executable?
  self.class.recipes.each do |meth,args|
    return false unless respond_to?(meth)
  end
  return false if executed?
  true
end

#execute(force = false) ⇒ Object

Execute this manifest, applying all resources defined. Execute returns true if successfull, and false if unsucessfull. By default, this will only execute a manifest that has not already been executed?. The force argument, if true, removes this check.



233
234
235
236
237
238
239
240
241
242
243
 
# File 'lib/shadow_puppet/manifest.rb', line 233

def execute(force=false)
  return false if executed? && !force
  evaluate_recipes
  apply
rescue Exception => e
  false
else
  true
ensure
  @executed = true
end

#execute!(force = false) ⇒ Object

Execute this manifest, applying all resources defined. Execute returns true if successfull, and raises an exception if not. By default, this will only execute a manifest that has not already been executed?. The force argument, if true, removes this check.



249
250
251
252
253
254
255
256
257
258
259
 
# File 'lib/shadow_puppet/manifest.rb', line 249

def execute!(force=false)
  return false if executed? && !force
  evaluate_recipes
  apply
rescue Exception => e
  raise e
else
  true
ensure
  @executed = true
end

#missing_recipes ⇒ Object 



223
224
225
226
227
 
# File 'lib/shadow_puppet/manifest.rb', line 223

def missing_recipes
  missing = self.class.recipes.each do |meth,args|
    !respond_to?(meth)
  end
end

#name ⇒ Object 



191
192
193
 
# File 'lib/shadow_puppet/manifest.rb', line 191

def name
  @name ||= "#{self.class}##{self.object_id}"
end