retrieve a named instance of the current type

add an instance by name to the class list of instances

Create an alias. We keep these in a separate hash so that we don‘t encounter the objects multiple times when iterating over them.

All parameters, in the appropriate order. The key_attributes come first, then the provider, then the properties, and finally the params and metaparams in the order they were specified in the files.

Retrieve an attribute alias, if there is one.

Find the class associated with any given attribute.

What type of parameter are we dealing with? Cache the results, because this method gets called so many times.

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.

remove all of the instances of a single type

Force users to call this, so that we can merge objects if necessary.

Find the default provider.

remove a specified object

this is a retarded hack method to get around the difference between component children and file children

We need to add documentation for each provider.

iterate across each of the type‘s instances

Yield each of those autorequires in turn, yo.

Create the ‘ensure’ class. This is a separate method so other types can easily call it and create their own ‘ensure’ values.

Should we add the ‘ensure’ property to this class?

Deal with any options passed into parameters.

does the type have an object with the given name?

Convert a simple hash into a Resource instance.

all of the variables that must be initialized for each subclass

Retrieve all known instances. Either requires providers or must be overridden.

Is this type‘s name isomorphic with the object? That is, if the name conflicts, does it necessarily mean that the objects conflict? Defaults to true.

Is the parameter in question a meta-parameter?

Find the metaparameter class associated with a given metaparameter name.

initialize the type instance

Create a new metaparam. Requires a block and a name, stores it in the @parameters array, and does some basic checking on it.

Create a new parameter. Requires a block and a name, stores it in the @parameters array, and does some basic checking on it.

Create a new property. The first parameter must be the name of the property; this is how users will refer to the property when creating new instances. The second parameter is a hash of options; the options are:

• :parent: The parent class for the property. Defaults to Puppet::Property.
• :retrieve: The method to call on the provider or @parent object (if the provider is not set) to retrieve the current value.

Find the parameter class associated with a given parameter name.

Return the parameter names

Return the property class associated with a name

Create a new provider of a type. This method must be called directly on the type that it‘s implementing.

Retrieve a provider by name.

Just list all of the providers.

Return a list of one suitable provider per source, with the default provider first.

Make sure we have a :provider parameter defined. Only gets called if there are providers.

Create an alias to an existing attribute. This will cause the aliased attribute to be valid when setting and retrieving values on the instance.

Return an array of all of the suitable providers.

This is a forward-compatibility method - it‘s the validity interface we‘ll use in Puppet::Resource.

Create a block to validate that our object is set up entirely. This will be run before the object is operated on.

does the name reflect a valid parameter?

Return the list of validproperties

does the name reflect a valid property?

abstract accessing parameters and properties, and normalize access to always be symbols, not strings This returns a value, not an object. It returns the ‘is’ value, but you can also specifically return ‘is’ and ‘should’ values using ‘object.is(:property)’ or ‘object.should(:property)’.

Abstract setting parameters and properties, and normalize access to always be symbols, not strings. This sets the ‘should’ value on properties, and otherwise just sets the appropriate parameter.

Create a new property if it is valid but doesn‘t exist Returns: true if a new parameter was added, false otherwise

Return either the attribute alias or the attribute.

Figure out of there are any objects we can automatically add as dependencies.

Build the dependencies associated with an individual object.

Get a hash of the current properties. Returns a hash with the actual property instance as the key and the current value as the, um, value.

remove a property from the object; useful in testing or in cleanup when an error has been encountered

Are we deleting this resource?

iterate across the existing properties

Create a transaction event. Called by Transaction or by a property.

Let the catalog determine whether a given cached value is still valid or has expired.

Set up all of our autorequires.

Flush the provider, if it supports it. This is called by the transaction.

if all contained objects are in sync, then we‘re in sync FIXME I don‘t think this is used on the type instances any more, it‘s really only used for testing

create a log at specified level

is the instance 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

For now, leave the ‘name’ method functioning like it used to. Once ‘title’ works everywhere, I‘ll switch it.

The name_var is the key_attribute in the case that there is only one.

Create the actual attribute instance. Requires either the attribute name or class as the first argument, then an optional hash of attributes to set during initialization.

Are we running in noop mode?

return the value of a parameter

Look up our parent in the catalog, if we have one.

Create the path for logging and such.

Return all of the property objects, in the order specified in the class.

Return an actual property instance by name; to return the value, use ‘resource[param]’ LAK:NOTE(20081028) Since the ‘parameter’ method is now a superset of this method, this one should probably go away at some point.

Is the named property defined?

Mark that we‘re purging.

Is this resource being purged? Used by transactions to forbid deletion when there are dependencies.

Return the "type[name]" style reference.

Remove an object. The argument determines whether the object‘s subscriptions get eliminated, too.

retrieve the current value of all contained properties

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.

retrieve the ‘should’ value for a specified property

Define the initial list of tags.

Retrieve the title of an object. If no title was set separately, then use the object‘s name.

Convert our object to a hash. This just includes properties.

convert to a string

Convert to a transportable object

Return a specific value for an attribute.