puppet 0.18.4 → 0.22.4

data/test/{server → network/handler}/fileserver.rb

@@ -1,20 +1,28 @@
-if __FILE__ == $0
-    if Dir.getwd =~ /test\/server$/
-        Dir.chdir("..")
-    end
-
-    $:.unshift '../lib'
-    $puppetbase = ".."
+#!/usr/bin/env ruby
 
-end
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
 
-require 'puppet'
-require 'puppet/server/fileserver'
-require 'test/unit'
-require 'puppettest.rb'
+require 'puppettest'
+require 'puppet/network/handler/fileserver'
 
 class TestFileServer < Test::Unit::TestCase
-	include TestPuppet
+	include PuppetTest
+
+    def mkmount(path = nil)
+        mount = nil
+        name = "yaytest"
+        base = path || tempfile()
+        unless FileTest.exists?(base)
+            Dir.mkdir(base)
+        end
+        # Create a test file
+        File.open(File.join(base, "file"), "w") { |f| f.puts "bazoo" }
+        assert_nothing_raised {
+            mount = Puppet::Network::Handler.fileserver::Mount.new(name, base)
+        }
+
+        return mount
+    end
     # make a simple file source
     def mktestdir
         testdir = File.join(tmpdir(), "remotefilecopytesting")
@@ -37,8 +45,6 @@ class TestFileServer < Test::Unit::TestCase
     def mktestfiles(testdir)
         @@tmpfiles << testdir
         assert_nothing_raised {
-            Dir.mkdir(testdir)
-            @@tmpfiles << testdir
             files = %w{a b c d e}.collect { |l|
                 name = File.join(testdir, "file%s" % l)
                 File.open(name, "w") { |f|
@@ -66,27 +72,17 @@ class TestFileServer < Test::Unit::TestCase
     def test_namefailures
         server = nil
         assert_nothing_raised {
-            server = Puppet::Server::FileServer.new(
+            server = Puppet::Network::Handler.fileserver.new(
                 :Local => true,
                 :Config => false
             )
         }
 
-        assert_raise(Puppet::FileServerError) {
-            server.mount("/tmp", "invalid+name")
-        }
-
-        assert_raise(Puppet::FileServerError) {
-            server.mount("/tmp", "invalid-name")
-        }
-
-        assert_raise(Puppet::FileServerError) {
-            server.mount("/tmp", "invalid name")
-        }
-
-        assert_raise(Puppet::FileServerError) {
-            server.mount("/tmp", "")
-        }
+        [" ", "=" "+", "&", "#", "*"].each do |char|
+            assert_raise(Puppet::Network::Handler::FileServerError, "'%s' did not throw a failure in fileserver module names" % char) {
+                server.mount("/tmp", "invalid%sname" % char)
+            }
+        end
     end
 
     # verify that listing the root behaves as expected
@@ -95,11 +91,11 @@ class TestFileServer < Test::Unit::TestCase
         testdir, pattern, tmpfile = mktestdir()
 
         file = nil
-        checks = Puppet::Server::FileServer::CHECKPARAMS
+        checks = Puppet::Network::Handler.fileserver::CHECKPARAMS
 
         # and make our fileserver
         assert_nothing_raised {
-            server = Puppet::Server::FileServer.new(
+            server = Puppet::Network::Handler.fileserver.new(
                 :Local => true,
                 :Config => false
             )
@@ -133,7 +129,7 @@ class TestFileServer < Test::Unit::TestCase
         file = nil
 
         assert_nothing_raised {
-            server = Puppet::Server::FileServer.new(
+            server = Puppet::Network::Handler.fileserver.new(
                 :Local => true,
                 :Config => false
             )
@@ -188,10 +184,10 @@ class TestFileServer < Test::Unit::TestCase
 
         # go through the whole schtick again...
         file = nil
-        checks = Puppet::Server::FileServer::CHECKPARAMS
+        checks = Puppet::Network::Handler.fileserver::CHECKPARAMS
 
         assert_nothing_raised {
-            server = Puppet::Server::FileServer.new(
+            server = Puppet::Network::Handler.fileserver.new(
                 :Local => true,
                 :Config => false
             )
@@ -226,10 +222,10 @@ class TestFileServer < Test::Unit::TestCase
 
     # verify we can mount /, which is what local file servers will
     # normally do
-    def test_zmountroot
+    def test_mountroot
         server = nil
         assert_nothing_raised {
-            server = Puppet::Server::FileServer.new(
+            server = Puppet::Network::Handler.fileserver.new(
                 :Local => true,
                 :Config => false
             )
@@ -258,7 +254,7 @@ class TestFileServer < Test::Unit::TestCase
     def test_recursionlevels
         server = nil
         assert_nothing_raised {
-            server = Puppet::Server::FileServer.new(
+            server = Puppet::Network::Handler.fileserver.new(
                 :Local => true,
                 :Config => false
             )
@@ -309,7 +305,7 @@ class TestFileServer < Test::Unit::TestCase
     def test_listedpath
         server = nil
         assert_nothing_raised {
-            server = Puppet::Server::FileServer.new(
+            server = Puppet::Network::Handler.fileserver.new(
                 :Local => true,
                 :Config => false
             )
@@ -352,7 +348,7 @@ class TestFileServer < Test::Unit::TestCase
     def test_widelists
         server = nil
         assert_nothing_raised {
-            server = Puppet::Server::FileServer.new(
+            server = Puppet::Network::Handler.fileserver.new(
                 :Local => true,
                 :Config => false
             )
@@ -385,14 +381,14 @@ class TestFileServer < Test::Unit::TestCase
     # verify that 'describe' works as advertised
     def test_describe
         server = nil
-        testdir = tempfile()
+        testdir = tstdir()
         files = mktestfiles(testdir)
 
         file = nil
-        checks = Puppet::Server::FileServer::CHECKPARAMS
+        checks = Puppet::Network::Handler.fileserver::CHECKPARAMS
 
         assert_nothing_raised {
-            server = Puppet::Server::FileServer.new(
+            server = Puppet::Network::Handler.fileserver.new(
                 :Local => true,
                 :Config => false
             )
@@ -433,7 +429,7 @@ class TestFileServer < Test::Unit::TestCase
 
         # Now try to describe some sources that don't even exist
         retval = nil
-        assert_raise(Puppet::FileServerError,
+        assert_raise(Puppet::Network::Handler::FileServerError,
             "Describing non-existent mount did not raise an error") {
             retval = server.describe("/notmounted/" + "noexisties")
         }
@@ -450,8 +446,9 @@ class TestFileServer < Test::Unit::TestCase
         # make some dirs for mounting
         Dir.mkdir(basedir)
         mounts = {}
-        %w{thing thus these those}.each { |dir|
+        %w{thing thus the-se those}.each { |dir|
             path = File.join(basedir, dir)
+            Dir.mkdir(path)
             mounts[dir] = mktestfiles(path)
 
         }
@@ -472,8 +469,8 @@ class TestFileServer < Test::Unit::TestCase
     allow *.madstop.com, *.kanies.com
     deny *.sub.madstop.com
 
-[these]
-    path #{basedir}/these
+[the-se]
+    path #{basedir}/the-se
 
 [those]
     path #{basedir}/those
@@ -484,8 +481,8 @@ class TestFileServer < Test::Unit::TestCase
 
         # create a server with the file
         assert_nothing_raised {
-            server = Puppet::Server::FileServer.new(
-                :Local => true,
+            server = Puppet::Network::Handler.fileserver.new(
+                :Local => false,
                 :Config => conffile
             )
         }
@@ -544,7 +541,7 @@ class TestFileServer < Test::Unit::TestCase
 
                     case type
                     when :deny:
-                        assert_raise(Puppet::Server::AuthorizationError,
+                        assert_raise(Puppet::AuthorizationError,
                             "Host %s, ip %s, allowed %s" %
                             [host, ip, mount]) {
                                 list = server.list(mount, :ignore, true, false, host, ip)
@@ -597,13 +594,13 @@ class TestFileServer < Test::Unit::TestCase
             # create a server with the file
             server = nil
             assert_nothing_raised {
-                server = Puppet::Server::FileServer.new(
+                server = Puppet::Network::Handler.fileserver.new(
                     :Local => true,
                     :Config => conffile
                 )
             }
 
-            assert_raise(Puppet::FileServerError,
+            assert_raise(Puppet::Network::Handler::FileServerError,
                 "Invalid mount was mounted") {
                     server.list(mount, :ignore)
             }
@@ -617,9 +614,9 @@ class TestFileServer < Test::Unit::TestCase
 
             # create a server with the file
             server = nil
-            assert_raise(Puppet::FileServerError,
+            assert_raise(Puppet::Network::Handler::FileServerError,
                 "Invalid config %s did not raise error" % i) {
-                server = Puppet::Server::FileServer.new(
+                server = Puppet::Network::Handler.fileserver.new(
                     :Local => true,
                     :Config => conffile
                 )
@@ -631,12 +628,10 @@ class TestFileServer < Test::Unit::TestCase
     def test_filereread
         server = nil
 
+        conffile = tempfile()
         dir = tstdir()
 
         files = mktestfiles(dir)
-
-        conffile = tempfile()
-
         File.open(conffile, "w") { |f|
             f.print "# a test config file
  
@@ -646,12 +641,13 @@ class TestFileServer < Test::Unit::TestCase
 "
         }
         
+        # Reset the timeout, so we reload faster
+        Puppet[:filetimeout] = 0.5
 
         # start our server with a fast timeout
         assert_nothing_raised {
-            server = Puppet::Server::FileServer.new(
-                :Local => true,
-                :ConfigTimeout => 0.5,
+            server = Puppet::Network::Handler.fileserver.new(
+                :Local => false,
                 :Config => conffile
             )
         }
@@ -663,7 +659,7 @@ class TestFileServer < Test::Unit::TestCase
         }
         assert(list != "", "List returned nothing in rereard test")
 
-        assert_raise(Puppet::Server::AuthorizationError, "List allowed invalid host") {
+        assert_raise(Puppet::AuthorizationError, "List allowed invalid host") {
             list = server.list("/thing/", :ignore, false, false,
                 "test2.domain.com", "127.0.0.1")
         }
@@ -678,7 +674,7 @@ class TestFileServer < Test::Unit::TestCase
 "
         }
         
-        assert_raise(Puppet::Server::AuthorizationError, "List allowed invalid host") {
+        assert_raise(Puppet::AuthorizationError, "List allowed invalid host") {
             list = server.list("/thing/", :ignore, false, false,
                 "test1.domain.com", "127.0.0.1")
         }
@@ -699,7 +695,7 @@ class TestFileServer < Test::Unit::TestCase
         name = "yaytest"
         path = tmpdir()
         assert_nothing_raised {
-            mount = Puppet::Server::FileServer::Mount.new(name, path)
+            mount = Puppet::Network::Handler.fileserver::Mount.new(name, path)
         }
 
         assert_equal("mount[#{name}]", mount.to_s)
@@ -714,7 +710,7 @@ class TestFileServer < Test::Unit::TestCase
         File.open(file, "w") { |f| f.puts "yay" }
         File.symlink(file, link)
         assert_nothing_raised {
-            server = Puppet::Server::FileServer.new(
+            server = Puppet::Network::Handler.fileserver.new(
                 :Local => true,
                 :Config => false
             )
@@ -728,7 +724,7 @@ class TestFileServer < Test::Unit::TestCase
         results = {}
         assert_nothing_raised {
             server.describe("/mount/link", :follow).split("\t").zip(
-                Puppet::Server::FileServer::CHECKPARAMS
+                Puppet::Network::Handler.fileserver::CHECKPARAMS
             ).each { |v,p| results[p] = v }
         }
 
@@ -738,7 +734,7 @@ class TestFileServer < Test::Unit::TestCase
         results = {}
         assert_nothing_raised {
             server.describe("/mount/link", :ignore).split("\t").zip(
-                Puppet::Server::FileServer::CHECKPARAMS
+                Puppet::Network::Handler.fileserver::CHECKPARAMS
             ).each { |v,p| results[p] = v }
         }
 
@@ -749,7 +745,386 @@ class TestFileServer < Test::Unit::TestCase
             assert(v != "", "%s has no value" % p)
         }
     end
+
+    # Test that substitution patterns in the path are exapanded
+    # properly.  Disabled, because it was testing too much of the process
+    # and in a non-portable way.  This is a thorough enough test that it should
+    # be kept, but it should be done in a way that is clearly portable (e.g.,
+    # no md5 sums of file paths).
+    def test_host_specific
+        client1 = "client1.example.com"
+        client2 = "client2.example.com"
+        ip = "127.0.0.1"
+
+        # Setup a directory hierarchy for the tests
+        fsdir = File.join(tmpdir(), "host-specific")
+        @@tmpfiles << fsdir
+        hostdir = File.join(fsdir, "host")
+        fqdndir = File.join(fsdir, "fqdn")
+        client1_hostdir = File.join(hostdir, "client1")
+        client2_fqdndir = File.join(fqdndir, client2)
+        contents = {
+            client1_hostdir => "client1\n",
+            client2_fqdndir => client2 + "\n"
+        }
+        [fsdir, hostdir, fqdndir, 
+         client1_hostdir, client2_fqdndir].each { |d|  Dir.mkdir(d) }
+        
+        [client1_hostdir, client2_fqdndir].each do |d|
+            File.open(File.join(d, "file.txt"), "w") do |f| 
+                f.print contents[d] 
+            end
+        end
+        conffile = tempfile()
+        File.open(conffile, "w") do |f|
+            f.print("
+[host]
+path #{hostdir}/%h
+allow *
+[fqdn]
+path #{fqdndir}/%H
+allow *
+")
+        end
+
+        server = nil
+        assert_nothing_raised {
+            server = Puppet::Network::Handler.fileserver.new(
+                :Local => true,
+                :Config => conffile
+            )
+        }
+
+        # check that list returns the correct thing for the two clients
+        list = nil
+        sfile = "/host/file.txt"
+        assert_nothing_raised {
+            list = server.list(sfile, :ignore, true, false, client1, ip)
+        }
+        assert_equal("/\tfile", list)
+        assert_nothing_raised {
+            list = server.list(sfile, :ignore, true, false, client2, ip)
+        }
+        assert_equal("", list)
+
+        sfile = "/fqdn/file.txt"
+        assert_nothing_raised {
+            list = server.list(sfile, :ignore, true, false, client1, ip)
+        }
+        assert_equal("", list)
+        assert_nothing_raised {
+            list = server.list(sfile, :ignore, true, false, client2, ip)
+        }
+        assert_equal("/\tfile", list)
+
+        # check describe
+        sfile = "/host/file.txt"
+        assert_nothing_raised {
+            list = server.describe(sfile, :ignore, client1, ip).split("\t")
+        }
+        assert_equal(5, list.size)
+        assert_equal("file", list[1])
+        md5 = Digest::MD5.hexdigest(contents[client1_hostdir])
+        assert_equal("{md5}#{md5}", list[4])
+
+        assert_nothing_raised {
+            list = server.describe(sfile, :ignore, client2, ip).split("\t")
+        }
+        assert_equal([], list)
+
+        sfile = "/fqdn/file.txt"
+        assert_nothing_raised {
+            list = server.describe(sfile, :ignore, client1, ip).split("\t")
+        }
+        assert_equal([], list)
+
+        assert_nothing_raised {
+            list = server.describe(sfile, :ignore, client2, ip).split("\t")
+        }
+        assert_equal(5, list.size)
+        assert_equal("file", list[1])
+        md5 = Digest::MD5.hexdigest(contents[client2_fqdndir])
+        assert_equal("{md5}#{md5}", list[4])
+
+        # Check retrieve
+        sfile = "/host/file.txt"
+        assert_nothing_raised {
+            list = server.retrieve(sfile, :ignore, client1, ip).chomp
+        }
+        assert_equal(contents[client1_hostdir].chomp, list)
+
+        assert_nothing_raised {
+            list = server.retrieve(sfile, :ignore, client2, ip).chomp
+        }
+        assert_equal("", list)
+
+        sfile = "/fqdn/file.txt"
+        assert_nothing_raised {
+            list = server.retrieve(sfile, :ignore, client1, ip).chomp
+        }
+        assert_equal("", list)
+
+        assert_nothing_raised {
+            list = server.retrieve(sfile, :ignore, client2, ip).chomp
+        }
+        assert_equal(contents[client2_fqdndir].chomp, list)
+    end
+
+    # Make sure the 'subdir' method in Mount works.
+    def test_mount_subdir
+        mount = nil
+        base = tempfile()
+        Dir.mkdir(base)
+        subdir = File.join(base, "subdir")
+        Dir.mkdir(subdir)
+        [base, subdir].each do |d|
+            File.open(File.join(d, "file"), "w") { |f| f.puts "bazoo" }
+        end
+        mount = mkmount(base)
+
+        assert_equal(base, mount.subdir(), "Did not default to base path")
+        assert_equal(subdir, mount.subdir("subdir"), "Did not default to base path")
+    end
+
+    # Make sure mounts get correctly marked expandable or not, depending on
+    # the path.
+    def test_expandable
+        name = "yaytest"
+        dir = tempfile()
+        Dir.mkdir(dir)
+
+        mount = mkmount()
+        assert_nothing_raised {
+            mount.path = dir
+        }
+
+        assert(! mount.expandable?, "Mount incorrectly called expandable")
+
+        assert_nothing_raised {
+            mount.path = "/dir/a%a"
+        }
+        assert(mount.expandable?, "Mount not called expandable")
+
+        # This isn't a valid replacement pattern, so it should throw an error
+        # because the dir doesn't exist
+        assert_raise(Puppet::Network::Handler::FileServerError) {
+            mount.path = "/dir/a%"
+        }
+
+        # Now send it back to a normal path
+        assert_nothing_raised {
+            mount.path = dir
+        }
+        # Make sure it got reverted
+        assert(! mount.expandable?, "Mount incorrectly called expandable")
+
+
+    end
+
+    def test_mount_expand
+        mount = mkmount()
+
+        check = proc do |client, pattern, repl|
+            path = "/my/#{pattern}/file"
+            assert_equal("/my/#{repl}/file", mount.expand(path, client))
+        end
+
+        # Do a round of checks with a fake client
+        client = "host.domain.com"
+        {"%h" => "host", # Short name
+         "%H" => client, # Full name
+         "%d" => "domain.com", # domain
+         "%%" => "%", # escape
+         "%o" => "%o" # other
+         }.each do |pat, repl|
+             result = check.call(client, pat, repl)
+         end
+
+        # Now, check that they use Facter info 
+        Puppet.notice "The following messages are normal"
+        client = nil
+        local = Facter["hostname"].value
+        domain = Facter["domain"].value
+        fqdn = [local, domain].join(".")
+        {"%h" => local, # Short name
+         "%H" => fqdn, # Full name
+         "%d" => domain, # domain
+         "%%" => "%", # escape
+         "%o" => "%o" # other
+         }.each do |pat, repl|
+             check.call(client, pat, repl)
+         end
+
+    end
+
+    # Test that the fileserver expands the %h and %d things.
+    def test_fileserver_expansion
+        server = nil
+        assert_nothing_raised {
+            server = Puppet::Network::Handler.fileserver.new(
+                :Local => true,
+                :Config => false
+            )
+        }
+
+        dir = tempfile()
+        ip = Facter.value(:ipaddress)
+
+        Dir.mkdir(dir)
+        host = "host.domain.com"
+        {
+            "%H" => "host.domain.com", "%h" => "host", "%d" => "domain.com"
+        }.each do |pattern, string|
+            file = File.join(dir, string)
+            mount = File.join(dir, pattern)
+            File.open(file, "w") do |f| f.puts "yayness: %s" % string end
+            name = "name"
+            obj = nil
+            assert_nothing_raised {
+                obj = server.mount(mount, name)
+            }
+            obj.allow "*"
+
+            ret = nil
+            assert_nothing_raised do
+                ret = server.list("/name", :ignore, false, false, host, ip)
+            end
+
+            assert_equal("/\tfile", ret)
+
+            assert_nothing_raised do
+                ret = server.describe("/name", :ignore, host, ip)
+            end
+            assert(ret =~ /\tfile\t/, "Did not get valid a description")
+
+            assert_nothing_raised do
+                ret = server.retrieve("/name", :ignore, host, ip)
+            end
+
+            assert_equal(ret, File.read(file))
+
+            server.umount(name)
+
+            File.unlink(file)
+        end
+    end
+
+    # Test the default modules fileserving
+    def test_modules_default
+        moddir = tempfile
+        Dir.mkdir(moddir)
+        mounts = {}
+        Puppet[:modulepath] = moddir
+
+        mods = %w{green red}.collect do |name|
+            path = File::join(moddir, name, Puppet::Module::FILES)
+            FileUtils::mkdir_p(path)
+            if name == "green"
+                file = File::join(path, "test.txt")
+                File::open(file, "w") { |f| f.print name }
+            end
+
+           Puppet::Module::find(name)
+        end
+
+        conffile = tempfile
+        @@tmpfiles << conffile
+
+        File.open(conffile, "w") { |f| f.puts "# a test config file" }
+
+        # create a server with the file
+        server = nil
+        assert_nothing_raised {
+            server = Puppet::Network::Handler::FileServer.new(
+                :Local => false ,
+                :Config => conffile
+            )
+        }
+
+        mods.each do |mod|
+            mount = "/#{mod.name}/"
+            list = nil
+            assert_nothing_raised {
+                list = server.list(mount, :ignore, true, false)
+            }
+            list = list.split("\n")
+            if mod.name == "green"
+                assert_equal(2, list.size)
+                assert_equal("/\tdirectory", list[0])
+                assert_equal("/test.txt\tfile", list[1])
+            else
+                assert_equal(1, list.size)
+                assert_equal("/\tdirectory", list[0])
+            end
+
+            assert_nothing_raised("Host 'allow' denied #{mount}") {
+                server.list(mount, :ignore, true, false,
+                            'allow.example.com', "192.168.0.1")
+            }
+        end
+    end
+
+    # Test that configuring deny/allow for modules works
+    def test_modules_config
+        moddir = tempfile
+        Dir.mkdir(moddir)
+        mounts = {}
+        Puppet[:modulepath] = moddir
+
+        path = File::join(moddir, "amod", Puppet::Module::FILES)
+        file = File::join(path, "test.txt")
+        FileUtils::mkdir_p(path)
+        File::open(file, "w") { |f| f.print "Howdy" }
+
+        mod = Puppet::Module::find("amod")
+
+        conffile = tempfile
+        @@tmpfiles << conffile
+
+        File.open(conffile, "w") { |f|
+            f.print "# a test config file
+[modules]
+    path #{basedir}/thing
+    allow 192.168.0.*
+"
+        }
+
+        # create a server with the file
+        server = nil
+        assert_nothing_raised {
+            server = Puppet::Network::Handler::FileServer.new(
+                :Local => false,
+                :Config => conffile
+            )
+        }
+
+        list = nil
+        mount = "/#{mod.name}/"
+        assert_nothing_raised {
+            list = server.list(mount, :ignore, true, false)
+        }
+
+        assert_nothing_raised {
+            list.split("\n").each { |line|
+                file, type = line.split("\t")
+                server.describe(mount + file)
+            }
+        }
+
+        assert_describe(mount, file, server)
+
+        # now let's check that things are being correctly forbidden
+        assert_raise(Puppet::AuthorizationError,
+                     "Host 'deny' allowed #{mount}") {
+            server.list(mount, :ignore, true, false,
+                        'deny.example.com', "192.168.1.1")
+        }
+        assert_nothing_raised("Host 'allow' denied #{mount}") {
+            server.list(mount, :ignore, true, false,
+                        'allow.example.com', "192.168.0.1")
+        }
+    end
 end
 
-# $Id: fileserver.rb 1016 2006-03-12 03:29:13Z luke $
+# $Id: fileserver.rb 2443 2007-04-30 21:08:06Z luke $