puppet 0.25.5 → 2.6.0

data/lib/puppet/file_bucket/file.rb

@@ -0,0 +1,136 @@
+require 'puppet/file_bucket'
+require 'puppet/indirector'
+require 'puppet/util/checksums'
+
+class Puppet::FileBucket::File
+  include Puppet::Util::Checksums
+
+  # This class handles the abstract notion of a file in a filebucket.
+  # There are mechanisms to save and load this file locally and remotely in puppet/indirector/filebucketfile/*
+  # There is a compatibility class that emulates pre-indirector filebuckets in Puppet::FileBucket::Dipper
+  extend Puppet::Indirector
+  require 'puppet/file_bucket/file/indirection_hooks'
+  indirects :file_bucket_file, :terminus_class => :file, :extend => Puppet::FileBucket::File::IndirectionHooks
+
+  attr :path, true
+  attr :paths, true
+  attr :contents, true
+  attr :checksum_type
+  attr :bucket_path, true
+
+  def self.default_checksum_type
+    "md5"
+  end
+
+  def initialize( contents, options = {} )
+    @bucket_path   = options[:bucket_path]
+    @path          = options[:path]
+    @paths         = options[:paths] || []
+
+    @checksum      = options[:checksum]
+    @checksum_type = options[:checksum_type]
+
+    self.contents  = contents
+
+    yield(self) if block_given?
+
+    validate!
+  end
+
+  def validate!
+    validate_checksum_type!(checksum_type)
+    validate_checksum!(checksum) if checksum
+  end
+
+  def contents=(str)
+    raise "You may not change the contents of a FileBucket File" if @contents
+    validate_content!(str)
+    @contents = str
+  end
+
+  def checksum
+    return @checksum if @checksum
+    @checksum = calculate_checksum if contents
+    @checksum
+  end
+
+  def checksum=(checksum)
+    validate_checksum!(checksum)
+    @checksum = checksum
+  end
+
+  def checksum_type=( new_checksum_type )
+    @checksum = nil
+    @checksum_type = new_checksum_type
+  end
+
+  def checksum_type
+    unless @checksum_type
+      if @checksum
+        @checksum_type = sumtype(checksum)
+      else
+        @checksum_type = self.class.default_checksum_type
+      end
+    end
+    @checksum_type
+  end
+
+  def checksum_data
+    sumdata(checksum)
+  end
+
+  def to_s
+    contents
+  end
+
+  def name
+    [checksum_type, checksum_data, path].compact.join('/')
+  end
+
+  def name=(name)
+    data = name.split('/',3)
+    self.path = data.pop
+    @checksum_type = nil
+    self.checksum = "{#{data[0]}}#{data[1]}"
+  end
+
+  def conflict_check?
+    true
+  end
+
+  def self.from_s( contents )
+    self.new( contents )
+  end
+
+  def to_pson
+    hash = { "contents" => contents }
+    hash["path"] = @path if @path
+    hash.to_pson
+  end
+
+  def self.from_pson( pson )
+    self.new( pson["contents"], :path => pson["path"] )
+  end
+
+  private
+
+  def calculate_checksum
+    "{#{checksum_type}}" + send(checksum_type, contents)
+  end
+
+  def validate_content!(content)
+    raise ArgumentError, "Contents must be a string" if content and ! content.is_a?(String)
+  end
+
+  def validate_checksum!(new_checksum)
+    newtype = sumtype(new_checksum)
+
+    unless sumdata(new_checksum) == (calc_sum = send(newtype, contents))
+      raise Puppet::Error, "Checksum #{new_checksum} does not match contents #{calc_sum}"
+    end
+  end
+
+  def validate_checksum_type!(type)
+    raise ArgumentError, "Invalid checksum type #{type}" unless respond_to?(type)
+  end
+end

data/lib/puppet/file_bucket/file/indirection_hooks.rb

@@ -0,0 +1,9 @@
+require 'puppet/file_bucket/file'
+
+# This module is used to pick the appropriate terminus
+# in filebucket indirections.
+module Puppet::FileBucket::File::IndirectionHooks
+  def select_terminus(request)
+    return(request.protocol == 'https' ? :rest : Puppet::FileBucket::File.indirection.terminus_class)
+  end
+end

data/lib/puppet/file_collection.rb

@@ -1,30 +1,30 @@
 # A simple way to turn file names into singletons,
 # so we don't have tons of copies of each file path around.
 class Puppet::FileCollection
-    require 'puppet/file_collection/lookup'
+  require 'puppet/file_collection/lookup'
 
-    def self.collection
-        @collection
-    end
+  def self.collection
+    @collection
+  end
 
-    def initialize
-        @paths = []
-        @inverse = {}
-    end
+  def initialize
+    @paths = []
+    @inverse = {}
+  end
 
-    def index(path)
-        if i = @inverse[path]
-            return i
-        else
-            @paths << path
-            i = @inverse[path] = @paths.length - 1
-            return i
-        end
+  def index(path)
+    if i = @inverse[path]
+      return i
+    else
+      @paths << path
+      i = @inverse[path] = @paths.length - 1
+      return i
     end
+  end
 
-    def path(index)
-        @paths[index]
-    end
+  def path(index)
+    @paths[index]
+  end
 
-    @collection = self.new
+  @collection = self.new
 end

data/lib/puppet/file_collection/lookup.rb

@@ -3,18 +3,18 @@ require 'puppet/file_collection'
 # A simple module for looking up file paths and indexes
 # in a file collection.
 module Puppet::FileCollection::Lookup
-    attr_accessor :line, :file_index
+  attr_accessor :line, :file_index
 
-    def file_collection
-        Puppet::FileCollection.collection
-    end
+  def file_collection
+    Puppet::FileCollection.collection
+  end
 
-    def file=(path)
-        @file_index = file_collection.index(path)
-    end
+  def file=(path)
+    @file_index = file_collection.index(path)
+  end
 
-    def file
-        return nil unless file_index
-        file_collection.path(file_index)
-    end
+  def file
+    return nil unless file_index
+    file_collection.path(file_index)
+  end
 end

data/lib/puppet/file_serving/base.rb

@@ -7,86 +7,82 @@ require 'puppet/file_serving'
 # The base class for Content and Metadata; provides common
 # functionality like the behaviour around links.
 class Puppet::FileServing::Base
-    # This is for external consumers to store the source that was used
-    # to retrieve the metadata.
-    attr_accessor :source
+  # This is for external consumers to store the source that was used
+  # to retrieve the metadata.
+  attr_accessor :source
 
-    # Does our file exist?
-    def exist?
-        begin
-            stat
-            return true
-        rescue => detail
-            return false
-        end
-    end
+  # Does our file exist?
+  def exist?
+      stat
+      return true
+  rescue => detail
+      return false
+  end
 
-    # Return the full path to our file.  Fails if there's no path set.
-    def full_path(dummy_argument=:work_arround_for_ruby_GC_bug)
-        (if relative_path.nil? or relative_path == "" or relative_path == "."
-            path
-        else
-            File.join(path, relative_path)
-        end).gsub(%r{/+}, "/")
-    end
+  # Return the full path to our file.  Fails if there's no path set.
+  def full_path(dummy_argument=:work_arround_for_ruby_GC_bug)
+    (if relative_path.nil? or relative_path == "" or relative_path == "."
+      path
+    else
+      File.join(path, relative_path)
+    end).gsub(%r{/+}, "/")
+  end
 
-    def initialize(path, options = {})
-        self.path = path
-        @links = :manage
+  def initialize(path, options = {})
+    self.path = path
+    @links = :manage
 
-        options.each do |param, value|
-            begin
-                send param.to_s + "=", value
-            rescue NoMethodError
-                raise ArgumentError, "Invalid option %s for %s" % [param, self.class]
-            end
-        end
+    options.each do |param, value|
+      begin
+        send param.to_s + "=", value
+      rescue NoMethodError
+        raise ArgumentError, "Invalid option #{param} for #{self.class}"
+      end
     end
+  end
 
-    # Determine how we deal with links.
-    attr_reader :links
-    def links=(value)
-        value = value.to_sym
-        value = :manage if value == :ignore
-        raise(ArgumentError, ":links can only be set to :manage or :follow") unless [:manage, :follow].include?(value)
-        @links = value
-    end
+  # Determine how we deal with links.
+  attr_reader :links
+  def links=(value)
+    value = value.to_sym
+    value = :manage if value == :ignore
+    raise(ArgumentError, ":links can only be set to :manage or :follow") unless [:manage, :follow].include?(value)
+    @links = value
+  end
 
-    # Set our base path.
-    attr_reader :path
-    def path=(path)
-        raise ArgumentError.new("Paths must be fully qualified") unless path =~ /^#{::File::SEPARATOR}/
-        @path = path
-    end
+  # Set our base path.
+  attr_reader :path
+  def path=(path)
+    raise ArgumentError.new("Paths must be fully qualified") unless path =~ /^#{::File::SEPARATOR}/
+    @path = path
+  end
 
-    # Set a relative path; this is used for recursion, and sets
-    # the file's path relative to the initial recursion point.
-    attr_reader :relative_path
-    def relative_path=(path)
-        raise ArgumentError.new("Relative paths must not be fully qualified") if path =~ /^#{::File::SEPARATOR}/
-        @relative_path = path
-    end
+  # Set a relative path; this is used for recursion, and sets
+  # the file's path relative to the initial recursion point.
+  attr_reader :relative_path
+  def relative_path=(path)
+    raise ArgumentError.new("Relative paths must not be fully qualified") if path =~ /^#{::File::SEPARATOR}/
+    @relative_path = path
+  end
 
-    # Stat our file, using the appropriate link-sensitive method.
-    def stat
-        unless defined?(@stat_method)
-            @stat_method = self.links == :manage ? :lstat : :stat
-        end
-        File.send(@stat_method, full_path())
-    end
+  # Stat our file, using the appropriate link-sensitive method.
+  def stat
+    @stat_method ||= self.links == :manage ? :lstat : :stat
+    File.send(@stat_method, full_path)
+  end
 
-    def to_pson_data_hash
-        {
-            # No 'document_type' since we don't send these bare
-            'data'       => {
-                'path'          => @path,
-                'relative_path' => @relative_path,
-                'links'         => @links
-                },
-            'metadata' => {
-                'api_version' => 1
-                }
-       }
-    end
+  def to_pson_data_hash
+    {
+      # No 'document_type' since we don't send these bare
+      'data'       => {
+        'path'          => @path,
+        'relative_path' => @relative_path,
+        'links'         => @links
+        },
+      'metadata' => {
+        'api_version' => 1
+        }
+    }
+  end
 
 end

data/lib/puppet/file_serving/configuration.rb

@@ -11,119 +11,117 @@ require 'puppet/file_serving/mount/plugins'
 require 'puppet/util/cacher'
 
 class Puppet::FileServing::Configuration
-    require 'puppet/file_serving/configuration/parser'
+  require 'puppet/file_serving/configuration/parser'
 
-    class << self
-        include Puppet::Util::Cacher
-        cached_attr(:configuration) { new() }
-    end
-
-    Mount = Puppet::FileServing::Mount
+  class << self
+    include Puppet::Util::Cacher
+    cached_attr(:configuration) { new }
+  end
 
-    # Create our singleton configuration.
-    def self.create
-        configuration
-    end
+  Mount = Puppet::FileServing::Mount
 
-    private_class_method  :new
+  # Create our singleton configuration.
+  def self.create
+    configuration
+  end
 
-    attr_reader :mounts
-    #private :mounts
+  private_class_method  :new
 
-    # Find the right mount.  Does some shenanigans to support old-style module
-    # mounts.
-    def find_mount(mount_name, environment)
-        # Reparse the configuration if necessary.
-        readconfig
+  attr_reader :mounts
+  #private :mounts
 
-        if mount = mounts[mount_name]
-            return mount
-        end
+  # Find the right mount.  Does some shenanigans to support old-style module
+  # mounts.
+  def find_mount(mount_name, environment)
+    # Reparse the configuration if necessary.
+    readconfig
 
-        if environment.module(mount_name)
-            Puppet::Util::Warnings.notice_once "DEPRECATION NOTICE: Files found in modules without specifying 'modules' in file path will be deprecated in the next major release.  Please fix module '%s' when no 0.24.x clients are present" % mount_name
-            return mounts["modules"]
-        end
-
-        # This can be nil.
-        mounts[mount_name]
+    if mount = mounts[mount_name]
+      return mount
     end
 
-    def initialize
-        @mounts = {}
-        @config_file = nil
-
-        # We don't check to see if the file is modified the first time,
-        # because we always want to parse at first.
-        readconfig(false)
+    if environment.module(mount_name)
+      Puppet::Util::Warnings.notice_once "DEPRECATION NOTICE: Files found in modules without specifying 'modules' in file path will be deprecated in the next major release.  Please fix module '#{mount_name}' when no 0.24.x clients are present"
+      return mounts["modules"]
     end
 
-    # Is a given mount available?
-    def mounted?(name)
-        @mounts.include?(name)
-    end
+    # This can be nil.
+    mounts[mount_name]
+  end
+
+  def initialize
+    @mounts = {}
+    @config_file = nil
 
-    # Split the path into the separate mount point and path.
-    def split_path(request)
-        # Reparse the configuration if necessary.
-        readconfig
+    # We don't check to see if the file is modified the first time,
+    # because we always want to parse at first.
+    readconfig(false)
+  end
 
-        mount_name, path = request.key.split(File::Separator, 2)
+  # Is a given mount available?
+  def mounted?(name)
+    @mounts.include?(name)
+  end
 
-        raise(ArgumentError, "Cannot find file: Invalid path '%s'" % mount_name) unless mount_name =~ %r{^[-\w]+$}
+  # Split the path into the separate mount point and path.
+  def split_path(request)
+    # Reparse the configuration if necessary.
+    readconfig
 
-        return nil unless mount = find_mount(mount_name, request.environment)
-        if mount.name == "modules" and mount_name != "modules"
-            # yay backward-compatibility
-            path = "%s/%s" % [mount_name, path]
-        end
+    mount_name, path = request.key.split(File::Separator, 2)
 
-        if path == ""
-            path = nil
-        elsif path
-            # Remove any double slashes that might have occurred
-            path = path.gsub(/\/+/, "/")
-        end
+    raise(ArgumentError, "Cannot find file: Invalid path '#{mount_name}'") unless mount_name =~ %r{^[-\w]+$}
 
-        return mount, path
+    return nil unless mount = find_mount(mount_name, request.environment)
+    if mount.name == "modules" and mount_name != "modules"
+      # yay backward-compatibility
+      path = "#{mount_name}/#{path}"
     end
 
-    def umount(name)
-        @mounts.delete(name) if @mounts.include? name
+    if path == ""
+      path = nil
+    elsif path
+      # Remove any double slashes that might have occurred
+      path = path.gsub(/\/+/, "/")
     end
 
-    private
+    return mount, path
+  end
 
-    def mk_default_mounts
-        @mounts["modules"] ||= Mount::Modules.new("modules")
-        @mounts["modules"].allow('*') if @mounts["modules"].empty?
-        @mounts["plugins"] ||= Mount::Plugins.new("plugins")
-        @mounts["plugins"].allow('*') if @mounts["plugins"].empty?
-    end
+  def umount(name)
+    @mounts.delete(name) if @mounts.include? name
+  end
 
-    # Read the configuration file.
-    def readconfig(check = true)
-        config = Puppet[:fileserverconfig]
+  private
 
-        return unless FileTest.exists?(config)
+  def mk_default_mounts
+    @mounts["modules"] ||= Mount::Modules.new("modules")
+    @mounts["modules"].allow('*') if @mounts["modules"].empty?
+    @mounts["plugins"] ||= Mount::Plugins.new("plugins")
+    @mounts["plugins"].allow('*') if @mounts["plugins"].empty?
+  end
 
-        @parser ||= Puppet::FileServing::Configuration::Parser.new(config)
+  # Read the configuration file.
+  def readconfig(check = true)
+    config = Puppet[:fileserverconfig]
 
-        if check and ! @parser.changed?
-            return
-        end
+    return unless FileTest.exists?(config)
 
-        # Don't assign the mounts hash until we're sure the parsing succeeded.
-        begin
-            newmounts = @parser.parse
-            @mounts = newmounts
-        rescue => detail
-            puts detail.backtrace if Puppet[:trace]
-            Puppet.err "Error parsing fileserver configuration: %s; using old configuration" % detail
-        end
+    @parser ||= Puppet::FileServing::Configuration::Parser.new(config)
 
-    ensure
-        # Make sure we've got our plugins and modules.
-        mk_default_mounts
+    return if check and ! @parser.changed?
+
+    # Don't assign the mounts hash until we're sure the parsing succeeded.
+    begin
+      newmounts = @parser.parse
+      @mounts = newmounts
+    rescue => detail
+      puts detail.backtrace if Puppet[:trace]
+      Puppet.err "Error parsing fileserver configuration: #{detail}; using old configuration"
     end
+
+  ensure
+    # Make sure we've got our plugins and modules.
+    mk_default_mounts
+  end
 end