puppet 0.24.9 → 0.25.0

data/lib/puppet/network/format_handler.rb

@@ -0,0 +1,156 @@
+require 'yaml'
+require 'puppet/network'
+require 'puppet/network/format'
+
+module Puppet::Network::FormatHandler
+    class FormatError < Puppet::Error; end
+
+    class FormatProtector
+        attr_reader :format
+
+        def protect(method, args)
+            begin
+                Puppet::Network::FormatHandler.format(format).send(method, *args)
+            rescue => details
+                direction = method.to_s.include?("intern") ? "from" : "to"
+                error = FormatError.new("Could not %s %s %s: %s" % [method, direction, format, details])
+                error.set_backtrace(details.backtrace)
+                raise error
+            end
+        end
+
+        def initialize(format)
+            @format = format
+        end
+
+        [:intern, :intern_multiple, :render, :render_multiple, :mime].each do |method|
+            define_method(method) do |*args|
+                protect(method, args)
+            end
+        end
+    end
+
+    @formats = {}
+    def self.create(*args, &block)
+        instance = Puppet::Network::Format.new(*args)
+        instance.instance_eval(&block) if block_given?
+
+        @formats[instance.name] = instance
+        instance
+    end
+
+    def self.extended(klass)
+        klass.extend(ClassMethods)
+
+        # LAK:NOTE This won't work in 1.9 ('send' won't be able to send
+        # private methods, but I don't know how else to do it.
+        klass.send(:include, InstanceMethods)
+    end
+
+    def self.format(name)
+        @formats[name.to_s.downcase.intern]
+    end
+
+    # Provide a list of all formats.
+    def self.formats
+        @formats.keys
+    end
+
+    # Return a format capable of handling the provided mime type.
+    def self.mime(mimetype)
+        mimetype = mimetype.to_s.downcase
+        @formats.values.find { |format| format.mime == mimetype }
+    end
+
+    # Use a delegator to make sure any exceptions generated by our formats are
+    # handled intelligently.
+    def self.protected_format(name)
+        name = format_to_canonical_name(name)
+        @format_protectors ||= {}
+        @format_protectors[name] ||= FormatProtector.new(name)
+        @format_protectors[name]
+    end
+
+    # Return a format name given:
+    #  * a format name
+    #  * a mime-type
+    #  * a format instance
+    def self.format_to_canonical_name(format)
+        case format
+        when Puppet::Network::Format
+            out = format
+        when %r{\w+/\w+}
+            out = mime(format)
+        else
+            out = format(format)
+        end
+        raise ArgumentError, "No format match the given format name or mime-type (%s)" % format if out.nil?
+        out.name
+    end
+
+    module ClassMethods
+        def format_handler
+            Puppet::Network::FormatHandler
+        end
+
+        def convert_from(format, data)
+            format_handler.protected_format(format).intern(self, data)
+        end
+
+        def convert_from_multiple(format, data)
+            format_handler.protected_format(format).intern_multiple(self, data)
+        end
+
+        def render_multiple(format, instances)
+            format_handler.protected_format(format).render_multiple(instances)
+        end
+
+        def default_format
+            supported_formats[0]
+        end
+
+        def support_format?(name)
+            Puppet::Network::FormatHandler.format(name).supported?(self)
+        end
+
+        def supported_formats
+            result = format_handler.formats.collect { |f| format_handler.format(f) }.find_all { |f| f.supported?(self) }.collect { |f| f.name }.sort do |a, b|
+                # It's an inverse sort -- higher weight formats go first.
+                format_handler.format(b).weight <=> format_handler.format(a).weight
+            end
+
+            put_preferred_format_first(result)
+        end
+
+        private
+
+        def put_preferred_format_first(list)
+            preferred_format = Puppet.settings[:preferred_serialization_format].to_sym
+            if list.include?(preferred_format)
+                list.delete(preferred_format)
+                list.unshift(preferred_format)
+            end
+            list
+        end
+    end
+
+    module InstanceMethods
+        def render(format = nil)
+            format ||= self.class.default_format
+
+            Puppet::Network::FormatHandler.protected_format(format).render(self)
+        end
+
+        def mime(format = nil)
+            format ||= self.class.default_format
+
+            Puppet::Network::FormatHandler.protected_format(format).mime
+        end
+
+        def support_format?(name)
+            self.class.support_format?(name)
+        end
+    end
+end
+
+require 'puppet/network/formats'

data/lib/puppet/network/formats.rb

@@ -0,0 +1,123 @@
+require 'puppet/network/format_handler'
+
+Puppet::Network::FormatHandler.create(:yaml, :mime => "text/yaml") do
+    # Yaml doesn't need the class name; it's serialized.
+    def intern(klass, text)
+        YAML.load(text)
+    end
+
+    # Yaml doesn't need the class name; it's serialized.
+    def intern_multiple(klass, text)
+        YAML.load(text)
+    end
+
+    def render(instance)
+        yaml = instance.to_yaml
+
+        yaml = fixup(yaml) unless yaml.nil?
+        yaml
+    end
+
+    # Yaml monkey-patches Array, so this works.
+    def render_multiple(instances)
+        yaml = instances.to_yaml
+
+        yaml = fixup(yaml) unless yaml.nil?
+        yaml
+    end
+
+    # Everything's supported
+    def supported?(klass)
+        true
+    end
+
+    # fixup invalid yaml as per:
+    # http://redmine.ruby-lang.org/issues/show/1331
+    def fixup(yaml)
+        yaml.gsub!(/((?:&id\d+\s+)?!ruby\/object:.*?)\s*\?/) { "? #{$1}" }
+        yaml
+    end
+end
+
+
+Puppet::Network::FormatHandler.create(:marshal, :mime => "text/marshal") do
+    # Marshal doesn't need the class name; it's serialized.
+    def intern(klass, text)
+        Marshal.load(text)
+    end
+
+    # Marshal doesn't need the class name; it's serialized.
+    def intern_multiple(klass, text)
+        Marshal.load(text)
+    end
+
+    def render(instance)
+        Marshal.dump(instance)
+    end
+
+    # Marshal monkey-patches Array, so this works.
+    def render_multiple(instances)
+        Marshal.dump(instances)
+    end
+
+    # Everything's supported
+    def supported?(klass)
+        true
+    end
+end
+
+Puppet::Network::FormatHandler.create(:s, :mime => "text/plain")
+
+# A very low-weight format so it'll never get chosen automatically.
+Puppet::Network::FormatHandler.create(:raw, :mime => "application/x-raw", :weight => 1) do
+    def intern_multiple(klass, text)
+        raise NotImplementedError
+    end
+
+    def render_multiple(instances)
+        raise NotImplementedError
+    end
+
+    # LAK:NOTE The format system isn't currently flexible enough to handle
+    # what I need to support raw formats just for individual instances (rather
+    # than both individual and collections), but we don't yet have enough data
+    # to make a "correct" design.
+    #   So, we hack it so it works for singular but fail if someone tries it
+    # on plurals.
+    def supported?(klass)
+        true
+    end
+end
+
+Puppet::Network::FormatHandler.create(:json, :mime => "text/json", :weight => 10, :required_methods => [:render_method, :intern_method]) do
+    confine :true => Puppet.features.json?
+
+    def intern(klass, text)
+        data_to_instance(klass, JSON.parse(text))
+    end
+
+    def intern_multiple(klass, text)
+        JSON.parse(text).collect do |data|
+            data_to_instance(klass, data)
+        end
+    end
+
+    # JSON monkey-patches Array, so this works.
+    def render_multiple(instances)
+        instances.to_json
+    end
+
+    # If they pass class information, we want to ignore it.  By default,
+    # we'll include class information but we won't rely on it - we don't
+    # want class names to be required because we then can't change our
+    # internal class names, which is bad.
+    def data_to_instance(klass, data)
+        if data.is_a?(Hash) and d = data['data']
+            data = d
+        end
+        if data.is_a?(klass)
+            return data
+        end
+        klass.from_json(data)
+    end
+end

data/lib/puppet/network/handler/filebucket.rb

@@ -129,7 +129,7 @@ class Puppet::Network::Handler # :nodoc:
             File.open(bfile) { |of|
                 contents = of.read
             }
-            
+
             if client
                 return Base64.encode64(contents)
             else

data/lib/puppet/network/handler/fileserver.rb

@@ -53,7 +53,7 @@ class Puppet::Network::Handler
             mount = Mount.new(MODULES)
             mount.allow("*")
             @mounts[MODULES] = mount
-            
+
             Puppet.debug "No file server configuration file; autocreating #{PLUGINS} mount with default permissions"
             mount = PluginMount.new(PLUGINS)
             mount.allow("*")
@@ -77,7 +77,7 @@ class Puppet::Network::Handler
             return "" unless metadata.exist?
 
             begin
-                metadata.collect_attributes
+                metadata.collect
             rescue => detail
                 puts detail.backtrace if Puppet[:trace]
                 Puppet.err detail
@@ -145,7 +145,7 @@ class Puppet::Network::Handler
 
             desc.collect { |sub| sub.join("\t") }.join("\n")
         end
-        
+
         def local?
             self.local
         end
@@ -254,9 +254,8 @@ class Puppet::Network::Handler
             end
 
             # And use the environment to look up the module.
-            mod = Puppet::Module::find(module_name, env)
-            if mod
-                return @mounts[MODULES].copy(mod.name, mod.files)
+            if mod = Puppet::Node::Environment.new(env).module(module_name) and mod.files?
+                return @mounts[MODULES].copy(mod.name, mod.file_directory)
             else
                 return nil
             end
@@ -279,9 +278,9 @@ class Puppet::Network::Handler
                     count = 1
                     f.each { |line|
                         case line
-                        when /^\s*#/: next # skip comments
-                        when /^\s*$/: next # skip blank lines
-                        when /\[([-\w]+)\]/:
+                        when /^\s*#/; next # skip comments
+                        when /^\s*$/; next # skip blank lines
+                        when /\[([-\w]+)\]/
                             name = $1
                             if newmounts.include?(name)
                                 raise FileServerError, "%s is already mounted at %s" %
@@ -289,11 +288,11 @@ class Puppet::Network::Handler
                             end
                             mount = Mount.new(name)
                             newmounts[name] = mount
-                        when /^\s*(\w+)\s+(.+)$/:
+                        when /^\s*(\w+)\s+(.+)$/
                             var = $1
                             value = $2
                             case var
-                            when "path":
+                            when "path"
                                 if mount.name == MODULES
                                     Puppet.warning "The '#{mount.name}' module can not have a path. Ignoring attempt to set it"
                                 else
@@ -305,7 +304,7 @@ class Puppet::Network::Handler
                                         newmounts.delete(mount.name)
                                     end
                                 end
-                            when "allow":
+                            when "allow"
                                 value.split(/\s*,\s*/).each { |val|
                                     begin
                                         mount.info "allowing %s access" % val
@@ -315,7 +314,7 @@ class Puppet::Network::Handler
                                             count, @configuration.file)
                                     end
                                 }
-                            when "deny":
+                            when "deny"
                                 value.split(/\s*,\s*/).each { |val|
                                     begin
                                         mount.info "denying %s access" % val
@@ -350,14 +349,14 @@ class Puppet::Network::Handler
                 mount.allow("*")
                 newmounts[MODULES] = mount
             end
-            
+
             unless newmounts[PLUGINS]
                 Puppet.debug "No #{PLUGINS} mount given; autocreating with default permissions"
                 mount = PluginMount.new(PLUGINS)
                 mount.allow("*")
                 newmounts[PLUGINS] = mount
             end
-            
+
             unless newmounts[PLUGINS].valid?
                 Puppet.debug "No path given for #{PLUGINS} mount; creating a special PluginMount"
                 # We end up here if the user has specified access rules for
@@ -373,7 +372,7 @@ class Puppet::Network::Handler
                                  )
                 newmounts[PLUGINS] = mount
             end
-                
+
             # Verify each of the mounts are valid.
             # We let the check raise an error, so that it can raise an error
             # pointing to the specific problem.
@@ -434,7 +433,7 @@ class Puppet::Network::Handler
             # Create a map for a specific client.
             def clientmap(client)
                 {
-                    "h" => client.sub(/\..*$/, ""), 
+                    "h" => client.sub(/\..*$/, ""),
                     "H" => client,
                     "d" => client.sub(/[^.]+\./, "") # domain name
                 }
@@ -455,7 +454,7 @@ class Puppet::Network::Handler
                 end
                 path.gsub(/%(.)/) do |v|
                     key = $1
-                    if key == "%" 
+                    if key == "%"
                         "%"
                     else
                         map[key] || v
@@ -477,7 +476,10 @@ class Puppet::Network::Handler
             def file_path(relative_path, node = nil)
                 full_path = path(node)
 
-                raise ArgumentError.new("Mounts without paths are not usable") unless full_path
+                unless full_path
+                    p self
+                    raise ArgumentError.new("Mounts without paths are not usable") unless full_path
+                end
 
                 # If there's no relative path name, then we're serving the mount itself.
                 return full_path unless relative_path and relative_path != "/"
@@ -498,22 +500,25 @@ class Puppet::Network::Handler
                     @path = nil
                 end
 
+                @files = {}
+
                 super()
             end
 
             def fileobj(path, links, client)
                 obj = nil
-                if obj = Puppet.type(:file)[file_path(path, client)]
+                if obj = @files[file_path(path, client)]
                     # This can only happen in local fileserving, but it's an
                     # important one.  It'd be nice if we didn't just set
                     # the check params every time, but I'm not sure it's worth
                     # the effort.
                     obj[:check] = CHECKPARAMS
                 else
-                    obj = Puppet.type(:file).create(
+                    obj = Puppet::Type.type(:file).new(
                         :name => file_path(path, client),
                         :check => CHECKPARAMS
                     )
+                    @files[file_path(path, client)] = obj
                 end
 
                 if links == :manage
@@ -530,7 +535,7 @@ class Puppet::Network::Handler
 
             # Read the contents of the file at the relative path given.
             def read_file(relpath, client)
-               File.read(file_path(relpath, client))
+                File.read(file_path(relpath, client))
             end
 
             # Cache this manufactured map, since if it's used it's likely
@@ -667,7 +672,11 @@ class Puppet::Network::Handler
             def reclist(abspath, recurse, ignore)
                 require 'puppet/file_serving'
                 require 'puppet/file_serving/fileset'
-                args = { :recurse => recurse, :links => :follow }
+                if recurse.is_a?(Fixnum)
+                    args = { :recurse => true, :recurselimit => recurse, :links => :follow }
+                else
+                    args = { :recurse => recurse, :links => :follow }
+                end
                 args[:ignore] = ignore if ignore
                 fs = Puppet::FileServing::Fileset.new(abspath, args)
                 ary = fs.files.collect do |file|
@@ -689,18 +698,18 @@ class Puppet::Network::Handler
         # A special mount class specifically for the plugins mount -- just
         # has some magic to effectively do a union mount of the 'plugins'
         # directory of all modules.
-        # 
+        #
         class PluginMount < Mount
             def path(client)
                 ''
             end
 
             def mod_path_exists?(mod, relpath, client = nil)
-                File.exists?(File.join(mod, PLUGINS, relpath))
+                ! mod.plugin(relpath).nil?
             end
 
             def path_exists?(relpath, client = nil)
-               !valid_modules.find { |m| mod_path_exists?(m, relpath, client) }.nil?
+               !valid_modules(client).find { |mod| mod.plugin(relpath) }.nil?
             end
 
             def valid?
@@ -710,18 +719,17 @@ class Puppet::Network::Handler
             def mod_file_path(mod, relpath, client = nil)
                 File.join(mod, PLUGINS, relpath)
             end
-            
+
             def file_path(relpath, client = nil)
-                return nil unless mod = valid_modules.map { |m| mod_path_exists?(m, relpath, client) ? m : nil }.compact.first
-                mod_file_path(mod, relpath, client)
+                return nil unless mod = valid_modules(client).find { |m| m.plugin(relpath) }
+                mod.plugin(relpath)
             end
 
             # create a list of files by merging all modules
             def list(relpath, recurse, ignore, client = nil)
                 result = []
-                valid_modules.each do |m|
-                    modpath = mod_file_path(m, relpath, client)
-                    if FileTest.exists?(modpath)
+                valid_modules(client).each do |mod|
+                    if modpath = mod.plugin(relpath)
                         if FileTest.directory?(modpath) and recurse
                             ary = reclist(modpath, recurse, ignore)
                             ary = [] if ary.nil?
@@ -735,10 +743,10 @@ class Puppet::Network::Handler
             end
 
             private
-            def valid_modules
-               Puppet::Module.all.find_all { |m| File.directory?(File.join(m, PLUGINS)) }
+            def valid_modules(client)
+                Puppet::Node::Environment.new.modules.find_all { |mod| mod.exist? }
             end
-            
+
             def add_to_filetree(f, filetree)
                first, rest = f.split(File::SEPARATOR, 2)
             end