puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/transportable.rb

@@ -0,0 +1,248 @@
+require 'puppet'
+require 'yaml'
+
+module Puppet
+  # The transportable objects themselves.  Basically just a hash with some
+  # metadata and a few extra methods.  I used to have the object actually
+  # be a subclass of Hash, but I could never correctly dump them using
+  # YAML.
+  class TransObject
+    include Enumerable
+    attr_accessor :type, :name, :file, :line, :catalog
+
+    attr_writer :tags
+
+    %w{has_key? include? length delete empty? << [] []=}.each { |method|
+      define_method(method) do |*args|
+        @params.send(method, *args)
+      end
+    }
+
+    def each
+      @params.each { |p,v| yield p, v }
+    end
+
+    def initialize(name,type)
+      @type = type.to_s.downcase
+      @name = name
+      @params = {}
+      @tags = []
+    end
+
+    def longname
+      [@type,@name].join('--')
+    end
+
+    def ref
+      @ref ||= Puppet::Resource.new(@type, @name)
+      @ref.to_s
+    end
+
+    def tags
+      @tags
+    end
+
+    # Convert a defined type into a component.
+    def to_component
+      trans = TransObject.new(ref, :component)
+      @params.each { |param,value|
+        next unless Puppet::Type::Component.valid_parameter?(param)
+        Puppet.debug "Defining #{param} on #{ref}"
+        trans[param] = value
+      }
+      trans.catalog = self.catalog
+      Puppet::Type::Component.create(trans)
+    end
+
+    def to_hash
+      @params.dup
+    end
+
+    def to_s
+      "#{@type}(#{@name}) => #{super}"
+    end
+
+    def to_manifest
+      "%s { '%s':\n%s\n}" % [self.type.to_s, self.name,
+        @params.collect { |p, v|
+          if v.is_a? Array
+            "    #{p} => [\'#{v.join("','")}\']"
+          else
+            "    #{p} => \'#{v}\'"
+          end
+        }.join(",\n")
+        ]
+    end
+
+    # Create a normalized resource from our TransObject.
+    def to_resource
+      result = Puppet::Resource.new(type, name, :parameters => @params.dup)
+      result.tag(*tags)
+
+      result
+    end
+
+    def to_yaml_properties
+      instance_variables.reject { |v| %w{@ref}.include?(v) }
+    end
+
+    def to_ref
+      ref
+    end
+
+    def to_ral
+      to_resource.to_ral
+    end
+  end
+
+  # Just a linear container for objects.  Behaves mostly like an array, except
+  # that YAML will correctly dump them even with their instance variables.
+  class TransBucket
+    include Enumerable
+
+    attr_accessor :name, :type, :file, :line, :classes, :keyword, :top, :catalog
+
+    %w{delete shift include? length empty? << []}.each { |method|
+      define_method(method) do |*args|
+        #Puppet.warning "Calling #{method} with #{args.inspect}"
+        @children.send(method, *args)
+        #Puppet.warning @params.inspect
+      end
+    }
+
+    # Recursively yield everything.
+    def delve(&block)
+      @children.each do |obj|
+        block.call(obj)
+        if obj.is_a? self.class
+          obj.delve(&block)
+        else
+          obj
+        end
+      end
+    end
+
+    def each
+      @children.each { |c| yield c }
+    end
+
+    # Turn our heirarchy into a flat list
+    def flatten
+      @children.collect do |obj|
+        if obj.is_a? Puppet::TransBucket
+          obj.flatten
+        else
+          obj
+        end
+      end.flatten
+    end
+
+    def initialize(children = [])
+      @children = children
+    end
+
+    def push(*args)
+      args.each { |arg|
+        case arg
+        when Puppet::TransBucket, Puppet::TransObject
+          # nada
+        else
+          raise Puppet::DevError,
+            "TransBuckets cannot handle objects of type #{arg.class}"
+        end
+      }
+      @children += args
+    end
+
+    # Convert to a parseable manifest
+    def to_manifest
+      unless self.top
+        raise Puppet::DevError, "No keyword; cannot convert to manifest" unless @keyword
+      end
+
+      str = "#{@keyword} #{@name} {\n%s\n}"
+      str % @children.collect { |child|
+        child.to_manifest
+      }.collect { |str|
+        if self.top
+          str
+        else
+          str.gsub(/^/, "    ") # indent everything once
+        end
+      }.join("\n\n") # and throw in a blank line
+    end
+
+    def to_yaml_properties
+      instance_variables
+    end
+
+    # Create a resource graph from our structure.
+    def to_catalog(clear_on_failure = true)
+      catalog = Puppet::Resource::Catalog.new(Facter.value("hostname"))
+
+      # This should really use the 'delve' method, but this
+      # whole class is going away relatively soon, hopefully,
+      # so it's not worth it.
+      delver = proc do |obj|
+        obj.catalog = catalog
+        unless container = catalog.resource(obj.to_ref)
+          container = obj.to_ral
+          catalog.add_resource container
+        end
+        obj.each do |child|
+          child.catalog = catalog
+          unless resource = catalog.resource(child.to_ref)
+            resource = child.to_ral
+            catalog.add_resource resource
+          end
+
+          catalog.add_edge(container, resource)
+          delver.call(child) if child.is_a?(self.class)
+        end
+      end
+
+      begin
+        delver.call(self)
+        catalog.finalize
+      rescue => detail
+        # This is important until we lose the global resource references.
+        catalog.clear if (clear_on_failure)
+        raise
+      end
+
+      catalog
+    end
+
+    def to_ref
+      unless defined?(@ref)
+        if self.type and self.name
+          @ref = Puppet::Resource.new(self.type, self.name)
+        elsif self.type and ! self.name # This is old-school node types
+          @ref = Puppet::Resource.new("node", self.type)
+        elsif ! self.type and self.name
+          @ref = Puppet::Resource.new("component", self.name)
+        else
+          @ref = nil
+        end
+      end
+      @ref.to_s if @ref
+    end
+
+    def to_ral
+      to_resource.to_ral
+    end
+
+    # Create a normalized resource from our TransObject.
+    def to_resource
+      params = defined?(@parameters) ? @parameters.dup : {}
+      Puppet::Resource.new(type, name, :parameters => params)
+    end
+
+    def param(param,value)
+      @parameters ||= {}
+      @parameters[param] = value
+    end
+
+  end
+end
+

data/lib/vendor/puppet/type/augeas.rb

@@ -0,0 +1,218 @@
+#
+#   Copyright 2011 Bryan Kearney <bkearney@redhat.com>
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+Puppet::Type.newtype(:augeas) do
+  include Puppet::Util
+
+  feature :parse_commands, "Parse the command string"
+  feature :need_to_run?, "If the command should run"
+  feature :execute_changes, "Actually make the changes"
+
+  @doc = <<-'EOT'
+    Apply a change or an array of changes to the filesystem
+    using the augeas tool.
+
+    Requires:
+
+    - [Augeas](http://www.augeas.net)
+    - The ruby-augeas bindings
+
+    Sample usage with a string:
+
+        augeas{"test1" :
+          context => "/files/etc/sysconfig/firstboot",
+          changes => "set RUN_FIRSTBOOT YES",
+          onlyif  => "match other_value size > 0",
+        }
+
+    Sample usage with an array and custom lenses:
+
+        augeas{"jboss_conf":
+          context   => "/files",
+          changes   => [
+              "set etc/jbossas/jbossas.conf/JBOSS_IP $ipaddress",
+              "set etc/jbossas/jbossas.conf/JAVA_HOME /usr",
+            ],
+          load_path => "$/usr/share/jbossas/lenses",
+        }
+
+  EOT
+
+  newparam (:name) do
+    desc "The name of this task. Used for uniqueness."
+    isnamevar
+  end
+
+  newparam (:context) do
+    desc "Optional context path. This value is prepended to the paths of all
+      changes if the path is relative. If the `incl` parameter is set,
+      defaults to `/files + incl`; otherwise, defaults to the empty string."
+    defaultto ""
+    munge do |value|
+      if value.empty? and resource[:incl]
+        "/files" + resource[:incl]
+      else
+        value
+      end
+    end
+  end
+
+  newparam (:onlyif) do
+    desc "Optional augeas command and comparisons to control the execution of this type.
+      Supported onlyif syntax:
+
+      * `get <AUGEAS_PATH> <COMPARATOR> <STRING>`
+      * `match <MATCH_PATH> size <COMPARATOR> <INT>`
+      * `match <MATCH_PATH> include <STRING>`
+      * `match <MATCH_PATH> not_include <STRING>`
+      * `match <MATCH_PATH> == <AN_ARRAY>`
+      * `match <MATCH_PATH> != <AN_ARRAY>`
+
+      where:
+
+      * `AUGEAS_PATH` is a valid path scoped by the context
+      * `MATCH_PATH` is a valid match synatx scoped by the context
+      * `COMPARATOR` is one of `>, >=, !=, ==, <=,` or `<`
+      * `STRING` is a string
+      * `INT` is a number
+      * `AN_ARRAY` is in the form `['a string', 'another']`"
+    defaultto ""
+  end
+
+
+  newparam(:changes) do
+    desc "The changes which should be applied to the filesystem. This
+    can be a command or an array of commands. The following commands are supported:
+
+    `set <PATH> <VALUE>`
+    : Sets the value `VALUE` at loction `PATH`
+
+
+    `setm <PATH> <SUB> <VALUE>`
+    : Sets multiple nodes (matching `SUB` relative to `PATH`) to `VALUE`
+
+
+    `rm <PATH>`
+    : Removes the node at location `PATH`
+
+
+    `remove <PATH>`
+    : Synonym for `rm`
+
+
+    `clear <PATH>`
+    : Sets the node at `PATH` to `NULL`, creating it if needed
+
+
+    `ins <LABEL> (before|after) <PATH>`
+    : Inserts an empty node `LABEL` either before or after `PATH`.
+
+
+    `insert <LABEL> <WHERE> <PATH>`
+    : Synonym for `ins`
+
+
+    `mv <PATH> <OTHER PATH>`
+    : Moves a node at `PATH` to the new location `OTHER PATH`
+
+
+    `move <PATH> <OTHER PATH>`
+    : Synonym for `mv`
+
+
+    `defvar <NAME> <PATH>`
+    : Sets Augeas variable `$NAME` to `PATH`
+
+
+    `defnode <NAME> <PATH> <VALUE>`
+    : Sets Augeas variable `$NAME` to `PATH`, creating it with `VALUE` if needed
+
+    If the `context` parameter is set, that value is prepended to any relative `PATH`s."
+  end
+
+
+  newparam(:root) do
+    desc "A file system path; all files loaded by Augeas are loaded underneath `root`."
+    defaultto "/"
+  end
+
+  newparam(:load_path) do
+    desc "Optional colon-separated list or array of directories; these directories are searched for schema definitions. The agent's `$libdir/augeas/lenses` path will always be added to support pluginsync."
+    defaultto ""
+  end
+
+  newparam(:force) do
+    desc "Optional command to force the augeas type to execute even if it thinks changes
+    will not be made. This does not overide the `onlyif` parameter."
+
+    defaultto false
+  end
+
+  newparam(:type_check) do
+    desc "Whether augeas should perform typechecking. Defaults to false."
+    newvalues(:true, :false)
+
+    defaultto :false
+  end
+
+  newparam(:lens) do
+    desc "Use a specific lens, e.g. `Hosts.lns`. When this parameter is set, you
+      must also set the `incl` parameter to indicate which file to load."
+  end
+
+  newparam(:incl) do
+    desc "Load only a specific file, e.g. `/etc/hosts`. This can greatly speed
+      up the execution the resource. When this parameter is set, you must also
+      set the `lens` parameter to indicate which lens to use."
+  end
+
+  validate do
+    has_lens = !self[:lens].nil?
+    has_incl = !self[:incl].nil?
+    self.fail "You must specify both the lens and incl parameters, or neither." if has_lens != has_incl
+  end
+
+  # This is the actual meat of the code. It forces
+  # augeas to be run and fails or not based on the augeas return
+  # code.
+  newproperty(:returns) do |property|
+    include Puppet::Util
+    desc "The expected return code from the augeas command. Should not be set."
+
+    defaultto 0
+
+    # Make output a bit prettier
+    def change_to_s(currentvalue, newvalue)
+      "executed successfully"
+    end
+
+    # if the onlyif resource is provided, then the value is parsed.
+    # a return value of 0 will stop exection because it matches the
+    # default value.
+    def retrieve
+      if @resource.provider.need_to_run?()
+        :need_to_run
+      else
+        0
+      end
+    end
+
+    # Actually execute the command.
+    def sync
+      @resource.provider.execute_changes
+    end
+  end
+
+end

data/lib/vendor/puppet/type/component.rb

@@ -0,0 +1,85 @@
+
+require 'puppet'
+require 'puppet/type'
+require 'puppet/transaction'
+
+Puppet::Type.newtype(:component) do
+  include Enumerable
+
+  newparam(:name) do
+    desc "The name of the component.  Generally optional."
+    isnamevar
+  end
+
+  # Override how parameters are handled so that we support the extra
+  # parameters that are used with defined resource types.
+  def [](param)
+    return super if self.class.valid_parameter?(param)
+    @extra_parameters[param.to_sym]
+  end
+
+  # Override how parameters are handled so that we support the extra
+  # parameters that are used with defined resource types.
+  def []=(param, value)
+    return super if self.class.valid_parameter?(param)
+    @extra_parameters[param.to_sym] = value
+  end
+
+  # Initialize a new component
+  def initialize(*args)
+    @extra_parameters = {}
+    super
+
+    catalog.alias(self, ref) if catalog and ! catalog.resource(ref)
+  end
+
+  # Component paths are special because they function as containers.
+  def pathbuilder
+    if reference.type == "Class"
+      # 'main' is the top class, so we want to see '//' instead of
+      # its name.
+      if reference.title.to_s.downcase == "main"
+        myname = ""
+      else
+        myname = reference.title
+      end
+    else
+      myname = reference.to_s
+    end
+    if p = self.parent
+      return [p.pathbuilder, myname]
+    else
+      return [myname]
+    end
+  end
+
+  def ref
+    reference.to_s
+  end
+
+  # We want our title to just be the whole reference, rather than @title.
+  def title
+    ref
+  end
+
+  def title=(str)
+    @reference = Puppet::Resource.new(str)
+  end
+
+  def refresh
+    catalog.adjacent(self).each do |child|
+      if child.respond_to?(:refresh)
+        child.refresh
+        child.log "triggering #{:refresh}"
+      end
+    end
+  end
+
+  def to_s
+    reference.to_s
+  end
+
+  private
+
+  attr_reader :reference
+end

data/lib/vendor/puppet/type/computer.rb

@@ -0,0 +1,66 @@
+Puppet::Type.newtype(:computer) do
+
+  @doc = "Computer object management using DirectoryService
+    on OS X.
+
+    Note that these are distinctly different kinds of objects to 'hosts',
+    as they require a MAC address and can have all sorts of policy attached to
+    them.
+
+    This provider only manages Computer objects in the local directory service
+    domain, not in remote directories.
+
+    If you wish to manage `/etc/hosts` file on Mac OS X, then simply use the host
+    type as per other platforms.
+
+    This type primarily exists to create localhost Computer objects that MCX
+    policy can then be attached to.
+
+    **Autorequires:** If Puppet is managing the plist file representing a
+    Computer object (located at `/var/db/dslocal/nodes/Default/computers/{name}.plist`),
+    the Computer resource will autorequire it."
+
+  # ensurable
+
+  # We autorequire the computer object in case it is being managed at the
+  # file level by Puppet.
+
+  autorequire(:file) do
+    if self[:name]
+      "/var/db/dslocal/nodes/Default/computers/#{self[:name]}.plist"
+    else
+      nil
+    end
+  end
+
+  newproperty(:ensure, :parent => Puppet::Property::Ensure) do
+    desc "Control the existences of this computer record. Set this attribute to
+      `present` to ensure the computer record exists.  Set it to `absent`
+      to delete any computer records with this name"
+    newvalue(:present) do
+      provider.create
+    end
+
+    newvalue(:absent) do
+      provider.delete
+    end
+  end
+
+  newparam(:name) do
+    desc "The authoritative 'short' name of the computer record."
+    isnamevar
+  end
+
+  newparam(:realname) do
+    desc "The 'long' name of the computer record."
+  end
+
+  newproperty(:en_address) do
+    desc "The MAC address of the primary network interface. Must match en0."
+  end
+
+  newproperty(:ip_address) do
+    desc "The IP Address of the Computer object."
+  end
+
+end