puppet 2.7.22 → 2.7.23

data/lib/puppet/module.rb

@@ -11,6 +11,7 @@ class Puppet::Module
   class IncompatiblePlatform < Error; end
   class MissingMetadata < Error; end
   class InvalidName < Error; end
+  class InvalidFilePattern < Error; end
 
   include Puppet::Util::Logging
 
@@ -138,10 +139,16 @@ class Puppet::Module
   # Return the list of manifests matching the given glob pattern,
   # defaulting to 'init.{pp,rb}' for empty modules.
   def match_manifests(rest)
-    pat = File.join(path, MANIFESTS, rest || 'init')
-    [manifest("init.pp"),manifest("init.rb")].compact + Dir.
-      glob(pat + (File.extname(pat).empty? ? '.{pp,rb}' : '')).
-      reject { |f| FileTest.directory?(f) }
+    if rest
+      wanted_manifests = wanted_manifests_from(rest)
+      searched_manifests = wanted_manifests.glob.reject { |f| FileTest.directory?(f) }
+    else
+      searched_manifests = []
+    end
+
+    # (#4220) Always ensure init.pp in case class is defined there.
+    init_manifests = [manifest("init.pp"), manifest("init.rb")].compact
+    init_manifests + searched_manifests
   end
 
   def metadata_file
@@ -286,6 +293,20 @@ class Puppet::Module
 
   private
 
+  def wanted_manifests_from(pattern)
+    begin
+      extended = File.extname(pattern).empty? ? "#{pattern}.{pp,rb}" : pattern
+      relative_pattern = Puppet::FileSystem::PathPattern.relative(extended)
+    rescue Puppet::FileSystem::PathPattern::InvalidPattern => error
+      raise Puppet::Module::InvalidFilePattern.new(
+        "The pattern \"#{pattern}\" to find manifests in the module \"#{name}\" " +
+        "is invalid and potentially unsafe.", error)
+    end
+
+    absolute_path_to_manifests = Puppet::FileSystem::PathPattern.absolute(subpath(MANIFESTS))
+    relative_pattern.prefix_with(absolute_path_to_manifests)
+  end
+
   def subpath(type)
     return File.join(path, type) unless type.to_s == "plugins"
 

data/lib/puppet/module_tool/applications/unpacker.rb

@@ -9,7 +9,8 @@ module Puppet::ModuleTool
         @filename = Pathname.new(filename)
         parsed = parse_filename(filename)
         super(options)
-        @module_dir = Pathname.new(options[:target_dir]) + parsed[:dir_name]
+        @module_path = Pathname(options[:target_dir])
+        @module_dir = @module_path + parsed[:dir_name]
       end
 
       def run
@@ -46,6 +47,9 @@ module Puppet::ModuleTool
             else
               Puppet::Util.execute("tar xzf #{@filename} -C #{build_dir}")
             end
+            Puppet::Util.execute("find #{build_dir} -type d -exec chmod 755 {} +")
+            Puppet::Util.execute("find #{build_dir} -type f -exec chmod 644 {} +")
+            Puppet::Util.execute("chown -R #{@module_path.stat.uid}:#{@module_path.stat.gid} #{build_dir}")
           rescue Puppet::ExecutionFailure => e
             raise RuntimeError, "Could not extract contents of module archive: #{e.message}"
           end

data/lib/puppet/parser/files.rb

@@ -8,23 +8,25 @@ require 'puppet/parser/parser'
 module Puppet::Parser::Files
   module_function
 
-  # Return a list of manifests (as absolute filenames) that match +pat+
-  # with the current directory set to +cwd+. If the first component of
-  # +pat+ does not contain any wildcards and is an existing module, return
-  # a list of manifests in that module matching the rest of +pat+
-  # Otherwise, try to find manifests matching +pat+ relative to +cwd+
-  def find_manifests(start, options = {})
-    cwd = options[:cwd] || Dir.getwd
-    module_name, pattern = split_file_path(start)
+  # Return a list of manifests as absolute filenames matching the given 
+  # pattern.
+  #
+  # @param pattern [String] A reference for a file in a module. It is the format "<modulename>/<file glob>"
+  # @param environment [Puppet::Node::Environment] the environment of modules
+  #
+  # @return [Array(String, Array<String>)] the module name and the list of files found
+  # @api private
+  def find_manifests_in_modules(pattern, environment)
+    module_name, file_pattern = split_file_path(pattern)
     begin
-      if mod = Puppet::Module.find(module_name, options[:environment])
-        return [mod.name, mod.match_manifests(pattern)]
+      if mod = Puppet::Module.find(module_name, environment)
+        return [mod.name, mod.match_manifests(file_pattern)]
       end
     rescue Puppet::Module::InvalidName
-      # Than that would be a "no."
+      # one of the modules being loaded might have an invalid name and so
+      # looking for one might blow up since we load them lazily.
     end
-    abspat = File::expand_path(start, cwd)
-    [nil, Dir.glob(abspat + (File.extname(abspat).empty? ? '{.pp,.rb}' : '' )).uniq.reject { |f| FileTest.directory?(f) }]
+    [nil, []]
   end
 
   # Find the concrete file denoted by +file+. If +file+ is absolute,
@@ -80,9 +82,12 @@ module Puppet::Parser::Files
 
   # Split the path into the module and the rest of the path, or return
   # nil if the path is empty or absolute (starts with a /).
-  # This method can return nil & anyone calling it needs to handle that.
   def split_file_path(path)
-    path.split(File::SEPARATOR, 2) unless path == "" or Puppet::Util.absolute_path?(path)
+    if path == "" or Puppet::Util.absolute_path?(path)
+      nil
+    else
+      path.split(File::SEPARATOR, 2)
+    end
   end
 
 end

data/lib/puppet/parser/parser_support.rb

@@ -101,7 +101,16 @@ class Puppet::Parser::Parser
   end
 
   def import(file)
-    known_resource_types.loader.import(file, @lexer.file)
+    if @lexer.file
+      # use a path relative to the file doing the importing
+      dir = File.dirname(@lexer.file)
+    else
+      # otherwise assume that everything needs to be from where the user is
+      # executing this command. Normally, this would be in a "puppet apply -e"
+      dir = Dir.pwd
+    end
+
+    known_resource_types.loader.import(file, dir)
   end
 
   def initialize(env)

data/lib/puppet/parser/type_loader.rb

@@ -59,40 +59,34 @@ class Puppet::Parser::TypeLoader
     end
   end
 
-  # Import our files.
-  def import(file, current_file = nil)
+  # Import manifest files that match a given file glob pattern.
+  #
+  # @param pattern [String] the file glob to apply when determining which files
+  #   to load
+  # @param dir [String] base directory to use when the file is not
+  #   found in a module
+  # @api private
+  def import(pattern, dir)
     return if Puppet[:ignoreimport]
 
-    # use a path relative to the file doing the importing
-    if current_file
-      dir = current_file.sub(%r{[^/]+$},'').sub(/\/$/, '')
-    else
-      dir = "."
-    end
-    if dir == ""
-      dir = "."
-    end
+    modname, files = Puppet::Parser::Files.find_manifests_in_modules(pattern, environment)
+    if files.empty?
+      abspat = File.expand_path(pattern, dir)
+      file_pattern = abspat + (File.extname(abspat).empty? ? '{.pp,.rb}' : '' )
 
-    pat = file
-    modname, files = Puppet::Parser::Files.find_manifests(pat, :cwd => dir, :environment => environment)
-    if files.size == 0
-      raise Puppet::ImportError.new("No file(s) found for import of '#{pat}'")
-    end
+      files = Dir.glob(file_pattern).uniq.reject { |f| FileTest.directory?(f) }
+      modname = nil
 
-    loaded_asts = []
-    files.each do |file|
-      unless Puppet::Util.absolute_path?(file)
-        file = File.join(dir, file)
+      if files.empty?
+        raise_no_files_found(pattern)
       end
-      @loading_helper.do_once(file) do
-        loaded_asts << parse_file(file)
-      end
-    end
-    loaded_asts.inject([]) do |loaded_types, ast|
-      loaded_types + known_resource_types.import_ast(ast, modname)
     end
+
+    load_files(modname, files)
   end
 
+  # Load all of the manifest files in all known modules.
+  # @api private
   def import_all
     module_names = []
     # Collect the list of all known modules
@@ -113,7 +107,7 @@ class Puppet::Parser::TypeLoader
       mod = Puppet::Module.new(name, :environment => environment)
       Find.find(File.join(mod.path, "manifests")) do |path|
         if path =~ /\.pp$/ or path =~ /\.rb$/
-          import(path)
+          load_files(mod.name, [path])
         end
       end
     end
@@ -133,7 +127,7 @@ class Puppet::Parser::TypeLoader
     return nil if fqname == "" # special-case main.
     name2files(fqname).each do |filename|
       begin
-        imported_types = import(filename)
+        imported_types = import_from_modules(filename)
         if result = imported_types.find { |t| t.type == type and t.name == fqname }
           Puppet.debug "Automatically imported #{fqname} from #{filename} into #{environment}"
           return result
@@ -157,6 +151,32 @@ class Puppet::Parser::TypeLoader
 
   private
 
+  def import_from_modules(pattern)
+    modname, files = Puppet::Parser::Files.find_manifests_in_modules(pattern, environment)
+    if files.empty?
+      raise_no_files_found(pattern)
+    end
+
+    load_files(modname, files)
+  end
+
+  def raise_no_files_found(pattern)
+    raise Puppet::ImportError, "No file(s) found for import of '#{pattern}'"
+  end
+
+  def load_files(modname, files)
+    loaded_asts = []
+    files.each do |file|
+      @loading_helper.do_once(file) do
+        loaded_asts << parse_file(file)
+      end
+    end
+
+    loaded_asts.collect do |ast|
+      known_resource_types.import_ast(ast, modname)
+    end.flatten
+  end
+
   # Return a list of all file basenames that should be tried in order
   # to load the object with the given fully qualified name.
   def name2files(fqname)

data/lib/puppet/version.rb

@@ -6,7 +6,7 @@
 # Raketasks and such to set the version based on the output of `git describe`
 #
 module Puppet
-  PUPPETVERSION = '2.7.22'
+  PUPPETVERSION = '2.7.23'
 
   def self.version
     @puppet_version || PUPPETVERSION

data/spec/unit/file_system/path_pattern_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet/file_system'
+
+describe Puppet::FileSystem::PathPattern do
+  include PuppetSpec::Files
+  InvalidPattern = Puppet::FileSystem::PathPattern::InvalidPattern
+
+  describe 'relative' do
+    it "can not be created with a traversal up the directory tree" do
+      expect do
+        Puppet::FileSystem::PathPattern.relative("my/../other")
+      end.to raise_error(InvalidPattern, "PathPatterns cannot be created with directory traversals.")
+    end
+
+    it "can be created with a '..' prefixing a filename" do
+      Puppet::FileSystem::PathPattern.relative("my/..other").to_s.should eq("my/..other")
+    end
+
+    it "can be created with a '..' suffixing a filename" do
+      Puppet::FileSystem::PathPattern.relative("my/other..").to_s.should eq("my/other..")
+    end
+
+    it "can be created with a '..' embedded in a filename" do
+      Puppet::FileSystem::PathPattern.relative("my/ot..her").to_s.should eq("my/ot..her")
+    end
+
+    it "can not be created with a \\0 byte embedded" do
+      expect do
+        Puppet::FileSystem::PathPattern.relative("my/\0/other")
+      end.to raise_error(InvalidPattern, /PathPatterns cannot be created with a zero byte./)
+    end
+
+    it "can not be created with a windows drive" do
+      expect do
+        Puppet::FileSystem::PathPattern.relative("c:\\relative\\path")
+      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be prefixed with a drive.")
+    end
+
+    it "can not be created with a windows drive (with space)" do
+      expect do
+        Puppet::FileSystem::PathPattern.relative(" c:\\relative\\path")
+      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be prefixed with a drive.")
+    end
+
+    it "can not create an absolute relative path" do
+      expect do
+        Puppet::FileSystem::PathPattern.relative("/no/absolutes")
+      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be an absolute path.")
+    end
+
+    it "can not create an absolute relative path (with space)" do
+      expect do
+        Puppet::FileSystem::PathPattern.relative("\t/no/absolutes")
+      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be an absolute path.")
+    end
+
+    it "can not create a relative path that is a windows path relative to the current drive" do
+      expect do
+        Puppet::FileSystem::PathPattern.relative("\\no\relatives")
+      end.to raise_error(InvalidPattern, "A PathPattern cannot be a Windows current drive relative path.")
+    end
+
+    it "creates a relative PathPattern from a valid relative path" do
+      Puppet::FileSystem::PathPattern.relative("a/relative/path").to_s.should eq("a/relative/path")
+    end
+
+    it "is not absolute" do
+      Puppet::FileSystem::PathPattern.relative("a/relative/path").should_not be_absolute
+    end
+  end
+
+  describe 'absolute' do
+    it "can not create a relative absolute path" do
+      expect do
+        Puppet::FileSystem::PathPattern.absolute("no/relatives")
+      end.to raise_error(InvalidPattern, "An absolute PathPattern cannot be a relative path.")
+    end
+
+    it "can not create an absolute path that is a windows path relative to the current drive" do
+      expect do
+        Puppet::FileSystem::PathPattern.absolute("\\no\\relatives")
+      end.to raise_error(InvalidPattern, "A PathPattern cannot be a Windows current drive relative path.")
+    end
+
+    it "creates an absolute PathPattern from a valid absolute path" do
+      Puppet::FileSystem::PathPattern.absolute("/an/absolute/path").to_s.should eq("/an/absolute/path")
+    end
+
+    it "creates an absolute PathPattern from a valid Windows absolute path" do
+      Puppet::FileSystem::PathPattern.absolute("c:/absolute/windows/path").to_s.should eq("c:/absolute/windows/path")
+    end
+
+    it "is absolute" do
+      Puppet::FileSystem::PathPattern.absolute("c:/absolute/windows/path").should be_absolute
+    end
+
+    it "can be created with a '..' embedded in a filename on windows", :if => Puppet.features.microsoft_windows? do
+      Puppet::FileSystem::PathPattern.absolute(%q{c:\..my\ot..her\one..}).to_s.should eq(%q{c:\..my\ot..her\one..})
+    end
+  end
+
+  it "prefixes the relative path pattern with another path" do
+    pattern = Puppet::FileSystem::PathPattern.relative("docs/*_thoughts.txt")
+    prefix = Puppet::FileSystem::PathPattern.absolute("/prefix")
+
+    absolute_pattern = pattern.prefix_with(prefix)
+
+    absolute_pattern.should be_absolute
+    absolute_pattern.to_s.should eq(File.join("/prefix", "docs/*_thoughts.txt"))
+  end
+
+  it "refuses to prefix with a relative pattern" do
+    pattern = Puppet::FileSystem::PathPattern.relative("docs/*_thoughts.txt")
+    prefix = Puppet::FileSystem::PathPattern.relative("prefix")
+
+    expect do
+      pattern.prefix_with(prefix)
+    end.to raise_error(InvalidPattern, "An absolute PathPattern cannot be a relative path.")
+  end
+
+  it "applies the pattern to the filesystem as a glob" do
+    dir = tmpdir('globtest')
+    create_file_in(dir, "found_one")
+    create_file_in(dir, "found_two")
+    create_file_in(dir, "third_not_found")
+
+    pattern = Puppet::FileSystem::PathPattern.relative("found_*").prefix_with(
+      Puppet::FileSystem::PathPattern.absolute(dir))
+
+    pattern.glob.should include(File.join(dir, "found_one"))
+    pattern.glob.should include(File.join(dir, "found_two"))
+    pattern.glob.should_not include(File.join(dir, "third_not_found"))
+  end
+
+  def create_file_in(dir, name)
+    File.open(File.join(dir, name), "w") { |f| f.puts "data" }
+  end
+end

data/spec/unit/module_spec.rb

@@ -604,7 +604,8 @@ describe Puppet::Module, "when finding matching manifests" do
   end
 
   it "should default to the 'init' file if no glob pattern is specified" do
-    Dir.expects(:glob).with("/a/manifests/init.{pp,rb}").returns(%w{/a/manifests/init.pp})
+    FileTest.expects(:exist?).with("/a/manifests/init.pp").returns(true)
+    FileTest.expects(:exist?).with("/a/manifests/init.rb").returns(false)
 
     @mod.match_manifests(nil).should == %w{/a/manifests/init.pp}
   end
@@ -626,6 +627,12 @@ describe Puppet::Module, "when finding matching manifests" do
 
     @mod.match_manifests(@pq_glob_with_extension).should == []
   end
+
+  it "should raise an error if the pattern tries to leave the manifest directory" do
+    expect do
+      @mod.match_manifests("something/../../*")
+    end.to raise_error(Puppet::Module::InvalidFilePattern, /The pattern "something\/\.\.\/\.\.\/\*" to find manifests in the module "mymod" is invalid and potentially unsafe./)
+  end
 end
 
 describe Puppet::Module do

data/spec/unit/module_tool/applications/unpacker_spec.rb

@@ -36,6 +36,9 @@ describe Puppet::ModuleTool::Applications::Unpacker, :fails_on_windows => true d
     context "on linux" do
       it "should attempt to untar file to temporary location using system tar" do
         Puppet::Util.expects(:execute).with("tar xzf #{filename} -C #{build_dir}").returns(true)
+        Puppet::Util.expects(:execute).with("find #{build_dir} -type d -exec chmod 755 {} +").returns(true)
+        Puppet::Util.expects(:execute).with("find #{build_dir} -type f -exec chmod 644 {} +").returns(true)
+        Puppet::Util.expects(:execute).with("chown -R #{build_dir.stat.uid}:#{build_dir.stat.gid} #{build_dir}").returns(true)
         unpacker.run
       end
     end
@@ -48,6 +51,9 @@ describe Puppet::ModuleTool::Applications::Unpacker, :fails_on_windows => true d
       it "should attempt to untar file to temporary location using gnu tar" do
         Puppet::Util.stubs(:which).with('gtar').returns('/usr/sfw/bin/gtar')
         Puppet::Util.expects(:execute).with("gtar xzf #{filename} -C #{build_dir}").returns(true)
+        Puppet::Util.expects(:execute).with("find #{build_dir} -type d -exec chmod 755 {} +").returns(true)
+        Puppet::Util.expects(:execute).with("find #{build_dir} -type f -exec chmod 644 {} +").returns(true)
+        Puppet::Util.expects(:execute).with("chown -R #{build_dir.stat.uid}:#{build_dir.stat.gid} #{build_dir}").returns(true)
         unpacker.run
       end
 

data/spec/unit/parser/files_spec.rb

@@ -10,14 +10,6 @@ describe Puppet::Parser::Files do
     @basepath = make_absolute("/somepath")
   end
 
-  it "should have a method for finding a template" do
-    Puppet::Parser::Files.should respond_to(:find_template)
-  end
-
-  it "should have a method for finding manifests" do
-    Puppet::Parser::Files.should respond_to(:find_manifests)
-  end
-
   describe "when searching for templates" do
     it "should return fully-qualified templates directly" do
       Puppet::Parser::Files.expects(:modulepath).never
@@ -127,75 +119,22 @@ describe Puppet::Parser::Files do
   describe "when searching for manifests" do
     it "should ignore invalid modules" do
       mod = mock 'module'
-      Puppet::Node::Environment.new.expects(:module).with("mymod").raises(Puppet::Module::InvalidName, "name is invalid")
+      env = Puppet::Node::Environment.new
+      env.expects(:module).with("mymod").raises(Puppet::Module::InvalidName, "name is invalid")
       Puppet.expects(:value).with(:modulepath).never
       Dir.stubs(:glob).returns %w{foo}
 
-      Puppet::Parser::Files.find_manifests("mymod/init.pp")
-    end
-  end
-
-  describe "when searching for manifests when no module is found" do
-    before do
-      File.stubs(:find).returns(nil)
-    end
-
-    it "should not look for modules when paths are fully qualified" do
-      Puppet.expects(:value).with(:modulepath).never
-      file = @basepath + "/fully/qualified/file.pp"
-      Dir.stubs(:glob).with(file).returns([file])
-      Puppet::Parser::Files.find_manifests(file)
-    end
-
-    it "should return nil and an array of fully qualified files" do
-      file = @basepath + "/fully/qualified/file.pp"
-      Dir.stubs(:glob).with(file).returns([file])
-      Puppet::Parser::Files.find_manifests(file).should == [nil, [file]]
-    end
-
-    it "should match against provided fully qualified patterns" do
-      pattern = @basepath + "/fully/qualified/pattern/*"
-      Dir.expects(:glob).with(pattern+'{.pp,.rb}').returns(%w{my file list})
-      Puppet::Parser::Files.find_manifests(pattern)[1].should == %w{my file list}
-    end
-
-    it "should look for files relative to the current directory" do
-      # We expand_path to normalize backslashes and slashes on Windows
-      cwd = File.expand_path(Dir.getwd)
-      Dir.expects(:glob).with("#{cwd}/foobar/init.pp").returns(["#{cwd}/foobar/init.pp"])
-      Puppet::Parser::Files.find_manifests("foobar/init.pp")[1].should == ["#{cwd}/foobar/init.pp"]
-    end
-
-    it "should only return files, not directories" do
-      pattern = @basepath + "/fully/qualified/pattern/*"
-      file = @basepath + "/my/file"
-      dir = @basepath + "/my/directory"
-      Dir.expects(:glob).with(pattern+'{.pp,.rb}').returns([file, dir])
-      FileTest.expects(:directory?).with(file).returns(false)
-      FileTest.expects(:directory?).with(dir).returns(true)
-      Puppet::Parser::Files.find_manifests(pattern)[1].should == [file]
-    end
-
-    it "should return files once only" do
-      pattern = @basepath + "/fully/qualified/pattern/*"
-      Dir.expects(:glob).with(pattern+'{.pp,.rb}').returns(%w{one two one})
-      Puppet::Parser::Files.find_manifests(pattern)[1].should == %w{one two}
+      Puppet::Parser::Files.find_manifests_in_modules("mymod/init.pp", env)
     end
   end
 
   describe "when searching for manifests in a found module" do
     it "should return the name of the module and the manifests from the first found module" do
       mod = Puppet::Module.new("mymod")
-      Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
-      mod.expects(:match_manifests).with("init.pp").returns(%w{/one/mymod/manifests/init.pp})
-      Puppet::Parser::Files.find_manifests("mymod/init.pp").should == ["mymod", ["/one/mymod/manifests/init.pp"]]
-    end
-
-    it "should use the node environment if specified" do
-      mod = Puppet::Module.new("mymod")
-      Puppet::Node::Environment.new("myenv").expects(:module).with("mymod").returns mod
+      env = Puppet::Node::Environment.new
+      env.expects(:module).with("mymod").returns mod
       mod.expects(:match_manifests).with("init.pp").returns(%w{/one/mymod/manifests/init.pp})
-      Puppet::Parser::Files.find_manifests("mymod/init.pp", :environment => "myenv")[1].should == ["/one/mymod/manifests/init.pp"]
+      Puppet::Parser::Files.find_manifests_in_modules("mymod/init.pp", env).should == ["mymod", ["/one/mymod/manifests/init.pp"]]
     end
 
     after { Puppet.settings.clear }