puppet 0.25.5 → 2.6.0

data/lib/puppet/dsl.rb

@@ -1,275 +1,11 @@
-# Just quick mess-around to see what a DSL would look like.
-#
-# This is what the executable could look like:
-##!/usr/bin/env ruby
-#
-#require 'puppet'
-#require 'puppet/dsl'
-#
-#Puppet::DSL.import(ARGV[0])
-#
-#bucket = Puppet::TransBucket.new
-#bucket.type = "top"
-#bucket.keyword = "class"
-#
-#Puppet::DSL.find_all do |name, sub|
-#    sub.included
-#end.each do |name, sub|
-#    bucket.push sub.export
-#end
-#
-#puts bucket.to_manifest
-#
-# And here's what an example config could look like:
-#
-
-##!/usr/bin/env ruby
-#
-#
-# require 'puppet'
-# require 'puppet/dsl'
-#
-# include Puppet::DSL
-# init()
-#
-# aspect :webserver do
-#     file "/tmp/testone", :content => "yaytest"
-#
-#     exec "testing", :command => "/bin/echo this is a test"
-# end
-#
-# aspect :other, :inherits => :webserver do
-#     file "/tmp/testone", :mode => "755"
-# end
-#
-# acquire :other
-#
-# apply
-
 require 'puppet'
 
-# Provide the actual commands for acting like a language.
 module Puppet::DSL
-    def aspect(name, options = {}, &block)
-        Puppet::DSL::Aspect.new(name, options, &block)
-    end
-
-    def acquire(*names)
-        names.each do |name|
-            if aspect = Puppet::DSL::Aspect[name]
-                unless aspect.evaluated?
-                    aspect.evaluate
-                end
-            else
-                raise "Could not find aspect %s" % name
-            end
-        end
-    end
-
-    def apply
-        bucket = export()
-        catalog = bucket.to_catalog
-        catalog.apply
-    end
-
-    def export
-        objects = Puppet::DSL::Aspect.collect do |name, aspect|
-            if aspect.evaluated?
-                aspect.export
-            end
-        end.reject { |a| a.nil? }.flatten.collect do |obj|
-            obj.to_trans
-        end
-        bucket = Puppet::TransBucket.new(objects)
-        bucket.name = "top"
-        bucket.type = "class"
-
-        return bucket
-    end
-
-    def init
-        unless Process.uid == 0
-            Puppet[:confdir] = File.expand_path("~/.puppet")
-            Puppet[:vardir] = File.expand_path("~/.puppet/var")
-        end
-        Puppet[:user] = Process.uid
-        Puppet[:group] = Process.gid
-        Puppet::Util::Log.newdestination(:console)
-        Puppet::Util::Log.level = :info
-    end
-
-    class Aspect
-        Resource = Puppet::Parser::Resource
-
-        include Puppet::Util
-        include Puppet::DSL
-        extend Puppet::Util
-        extend Enumerable
-        attr_accessor :parent, :name, :evaluated
-
-        @aspects = {}
-
-        @@objects = Hash.new do |hash, key|
-            hash[key] = {}
-        end
-
-        # Create an instance method for every type
-        Puppet::Type.loadall
-        Puppet::Type.eachtype do |type|
-            define_method(type.name) do |*args|
-                newresource(type, *args)
-            end
-        end
-
-        def self.[]=(name, aspect)
-            name = symbolize(name)
-            @aspects[name] = aspect
-        end
-
-        def self.[](name)
-            name = symbolize(name)
-
-            # Make sure there's always a main.  This can get deleted in testing.
-            if name == :main and ! @aspects[name]
-                new(:main) {}
-            end
-            @aspects[name]
-        end
-
-        def self.clear
-            @aspects.clear
-            @@objects.clear
-        end
-
-        def self.delete(name)
-            name = symbolize(name)
-            if @aspects.has_key?(name)
-                @aspects.delete(name)
-            end
-        end
-
-        def self.each
-            @aspects.each do |name, a|
-                yield name, a
-            end
-        end
-
-        def child_of?(aspect)
-            unless aspect.is_a?(self.class)
-                obj = self.class[aspect]
-                unless obj
-                    raise "Could not find aspect %s" % aspect
-                end
-                aspect = obj
-            end
-            if self.parent
-                if self.parent == aspect
-                    return true
-                elsif self.parent.child_of?(aspect)
-                    return true
-                else
-                    return false
-                end
-            else
-                return false
-            end
-        end
-
-        def evaluate
-            if self.parent and ! self.parent.evaluated?
-                self.parent.evaluate
-            end
-
-            unless evaluated?
-                if defined? @block
-                    instance_eval(&@block)
-                end
-                @evaluated = true
-            end
-        end
-
-        def evaluated?
-            if self.evaluated
-                true
-            else
-                false
-            end
-        end
-
-        def export
-            @resources.dup
-        end
-
-        def initialize(name, options = {}, &block)
-            name = symbolize(name)
-            @name = name
-            if block
-                @block = block
-            end
-            if pname = options[:inherits]
-                if pname.is_a?(self.class)
-                    @parent = pname
-                elsif parent = self.class[pname]
-                    @parent = parent
-                else
-                    raise "Could not find parent aspect %s" % pname
-                end
-            end
-
-            @resources = []
-
-            self.class[name] = self
-        end
-
-        def newresource(type, name, params = {})
-            if self.is_a?(Puppet::DSL::Aspect)
-                source = self
-            else
-                source = Puppet::DSL::Aspect[:main]
-            end
-            unless obj = @@objects[type][name]
-                obj = Resource.new :title => name, :type => type.name,
-                    :source => source, :scope => scope
-                @@objects[type][name] = obj
-
-                @resources << obj
-            end
-
-            params.each do |name, value|
-                param = Resource::Param.new(
-                    :name => name,
-                    :value => value,
-                    :source => source
-                )
-
-                obj.send(:set_parameter, param)
-            end
-
-            obj
-        end
+end
 
-        def scope
-            unless defined?(@scope)
-                # Set the code to something innocuous; we just need the
-                # scopes, not the interpreter.  Hackish, but true.
-                Puppet[:code] = " "
-                @interp = Puppet::Parser::Interpreter.new
-                require 'puppet/node'
-                @node = Puppet::Node.new(Facter.value(:hostname))
-                if env = Puppet[:environment] and env == ""
-                    env = nil
-                end
-                @node.parameters = Facter.to_hash
-                @compile = Puppet::Parser::Compiler.new(@node, @interp.send(:parser, env))
-                @scope = @compile.topscope
-            end
-            @scope
-        end
+require 'puppet/dsl/resource_type_api'
+require 'puppet/dsl/resource_api'
 
-        def type
-            self.name
-        end
-    end
+class Object
+  include Puppet::DSL::ResourceTypeAPI
 end
-
-@aspects = {}

data/lib/puppet/dsl/resource_api.rb

@@ -0,0 +1,120 @@
+# 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

data/lib/puppet/dsl/resource_type_api.rb

@@ -0,0 +1,40 @@
+require 'puppet/resource/type'
+
+module Puppet::DSL::ResourceTypeAPI
+  def define(name, *args, &block)
+    result = mk_resource_type(:definition, name, Hash.new, block)
+    result.set_arguments(munge_type_arguments(args))
+    result
+  end
+
+  def hostclass(name, options = {}, &block)
+    mk_resource_type(:hostclass, name, options, block)
+  end
+
+  def node(name, options = {}, &block)
+    mk_resource_type(:node, name, options, block)
+  end
+
+  private
+
+  def mk_resource_type(type, name, options, code)
+    klass = Puppet::Resource::Type.new(type, name, options)
+
+    klass.ruby_code = code if code
+
+    Puppet::Node::Environment.new.known_resource_types.add klass
+
+    klass
+  end
+
+  def munge_type_arguments(args)
+    args.inject([]) do |result, item|
+      if item.is_a?(Hash)
+        item.each { |p, v| result << [p, v] }
+      else
+        result << item
+      end
+      result
+    end
+  end
+end

data/lib/puppet/error.rb

@@ -1,45 +1,43 @@
 module Puppet # :nodoc:
-    # The base class for all Puppet errors.  We want to make it easy to add
-    # line and file information.  This probably isn't necessary for all
-    # errors, but...
-    class Error < RuntimeError
-        attr_accessor :line, :file
+  # The base class for all Puppet errors.  We want to make it easy to add
+  # line and file information.  This probably isn't necessary for all
+  # errors, but...
+  class Error < RuntimeError
+    attr_accessor :line, :file
 
-        def backtrace
-            if defined? @backtrace
-                return @backtrace
-            else
-                return super
-            end
-        end
+    def backtrace
+      if defined?(@backtrace)
+        return @backtrace
+      else
+        return super
+      end
+    end
 
-        def initialize(message, line = nil, file = nil)
-            @message = message
+    def initialize(message, line = nil, file = nil)
+      @message = message
 
-            @line = line if line
-            @file = file if file
-        end
+      @line = line if line
+      @file = file if file
+    end
 
-        def to_s
-            str = nil
-            if self.file and self.line
-                str = "%s at %s:%s" %
-                    [@message.to_s, @file, @line]
-            elsif self.line
-                str = "%s at line %s" %
-                    [@message.to_s, @line]
-            elsif self.file
-                str = "%s in %s" % [@message.to_s, self.file]
-            else
-                str = @message.to_s
-            end
+    def to_s
+      str = nil
+      if self.file and self.line
+        str = "#{@message} at #{@file}:#{@line}"
+      elsif self.line
+        str = "#{@message} at line #{@line}"
+      elsif self.file
+        str = "#{@message} in #{self.file}"
+      else
+        str = @message.to_s
+      end
 
-            return str
-        end
+      str
     end
+  end
 
-    # An error class for when I don't know what happened.  Automatically
-    # prints a stack trace when in debug mode.
-    class DevError < Puppet::Error
-    end
+  # An error class for when I don't know what happened.  Automatically
+  # prints a stack trace when in debug mode.
+  class DevError < Puppet::Error
+  end
 end