tpkg 1.19.2 → 1.20.0

data/Rakefile

@@ -4,8 +4,8 @@ spec = Gem::Specification.new do |s|
   s.summary	= 'tpkg Application Packaging & Deployment'
   s.add_dependency('facter')
   s.add_dependency('net-ssh')
-  s.add_dependency('kwalify')
-  s.version = '1.19.2'
+  s.add_dependency('ddao-kwalify')
+  s.version = '1.20.0'
   s.authors = ['Darren Dao', 'Jason Heiss']
   s.email = 'tpkg-users@lists.sourceforge.net'
   s.homepage = 'http://tpkg.sourceforge.net'

data/bin/gem2tpkg

@@ -12,7 +12,7 @@ require 'facter'
 
 # We don't want to just use the first gem command in the user's PATH by
 # default, as that may not be a tpkg gem.  I.e. /usr/bin/gem on Mac OS X.
-DEFAULT_GEM_COMMAND = "#{Tpkg::DEFAULT_BASE}/ruby-1.8/bin/gem"
+DEFAULT_GEM_COMMAND = "#{Tpkg::DEFAULT_BASE}/ruby-ypc/bin/gem"
 
 # Haven't found a Ruby method for creating temporary directories,
 # so create a temporary file and replace it with a directory.

data/bin/tpkg

@@ -30,11 +30,17 @@ require 'tpkg'
 @rerun_with_sudo = false
 @tpkg_options = {}
 @init_options = {}           
+@compress = nil
+
 
 def rerun_with_sudo_if_necessary
   if Process.euid != 0 && @sudo
     warn "Executing with sudo"
-    exec('sudo', $0, *ARGV)
+    if ENV['TPKG_HOME']
+      exec('sudo', 'env', "TPKG_HOME=#{ENV['TPKG_HOME']}", $0, *ARGV)
+    else
+      exec('sudo', $0, *ARGV)
+    end
   end
 end
 
@@ -234,6 +240,9 @@ opts.on('--deploy-as', '=USERNAME', 'What username to use for deploying to remot
   @deploy_options["deploy-as"] = opt
   @deploy_params = @deploy_params - ['--deploy-as']
 end
+opts.on('--compress', '=[TYPE]', 'Compress files when making packages.') do |opt|
+  @compress = opt
+end
 opts.on('--debug', 'Print lots of messages about what tpkg is doing') do |opt|
   @debug = opt
   Tpkg::set_debug(@debug)
@@ -336,7 +345,7 @@ end
 ret_val = 0
 case @action
 when :make
-  pkgfile = Tpkg::make_package(@action_value, passphrase_callback, {:force => @force})
+  pkgfile = Tpkg::make_package(@action_value, passphrase_callback, {:force => @force, :compress => @compress})
   if pkgfile
     puts "Package is #{pkgfile}"
   else

data/lib/tpkg.rb

@@ -56,7 +56,7 @@ require 'kwalify'        # for validating yaml
 
 class Tpkg
   
-  VERSION = '1.19.2'
+  VERSION = '1.20.0'
   CONFIGDIR = '/etc'
 
   GENERIC_ERR = 1  
@@ -86,7 +86,7 @@ class Tpkg
   # Raises an exception if a suitable tar cannot be found
   @@tar = nil
   @@taroptions = ""
-  @@tartype = nil
+  @@tarinfo = {:version => 'unknown'}
   TARNAMES = ['tar', 'gtar', 'gnutar', 'bsdtar']
   def self.find_tar
     if !@@tar
@@ -96,15 +96,17 @@ class Tpkg
             if File.executable?(File.join(path, tarname))
               IO.popen("#{File.join(path, tarname)} --version 2>/dev/null") do |pipe|
                 pipe.each_line do |line|
-                  if line.include?('GNU tar') 
-                    @@tartype = 'gnu'
+                  if line.include?('GNU tar')
+                    @@tarinfo[:type] = 'gnu'
                     @@tar = File.join(path, tarname)
-                    throw :tar_found
                   elsif line.include?('bsdtar')
-                    @@tartype = 'bsd'
+                    @@tarinfo[:type] = 'bsd'
                     @@tar = File.join(path, tarname)
-                    throw :tar_found
                   end
+                  if line =~ /(?:(\d+)\.)?(?:(\d+)\.)?(\*|\d+)/
+                    @@tarinfo[:version] = [$1, $2, $3].compact.join(".")
+                  end
+                  throw :tar_found if @@tar
                 end
               end
             end
@@ -120,7 +122,7 @@ class Tpkg
     # gnu tar should just ignore them and gives a warning. This is what the latest gnu tar
     # will do. However, on older gnu tar, it only threw an error at the end. The work 
     # around is to explicitly tell gnu tar to ignore those extensions.
-    if @@tartype == 'gnu'
+    if @@tarinfo[:type] == 'gnu' && @@tarinfo[:version] != 'unknown' && @@tarinfo[:version] >= '1.15.1'
       @@taroptions = "--pax-option='delete=SCHILY.*'"
     end
     @@tar.dup
@@ -265,14 +267,18 @@ class Tpkg
       metadata_text = File.read(metadata_file)
       metadata = Metadata.new(metadata_text, metadata_format)
 
+      # This is for when we're in developement mode or when installed as gem
+      if File.exists?(File.join(File.dirname(File.dirname(__FILE__)), "schema"))
+        schema_dir = File.join(File.dirname(File.dirname(__FILE__)), "schema")
       # This is the directory where we put our dtd/schema for validating
       # the metadata file
-      if File.exist?(File.join(CONFIGDIR, 'tpkg', 'schema'))
+      elsif File.exist?(File.join(CONFIGDIR, 'tpkg', 'schema'))
         schema_dir = File.join(CONFIGDIR, 'tpkg', 'schema')
-      else # This is for when we're in developement mode or when installed as gem
-        schema_dir = File.join(File.dirname(File.dirname(__FILE__)), "schema")
+      else
+        warn "Warning: unable to find schema for tpkg.yml"
       end
-      errors = metadata.validate(schema_dir)
+      
+      errors = metadata.validate(schema_dir) if schema_dir
       if errors && !errors.empty? 
         puts "Bad metadata file. Possible error(s):"
         errors.each {|e| puts e }
@@ -362,6 +368,11 @@ class Tpkg
         csx.puts('</tpkg_checksums>')
       end
       
+      # compress if needed
+      if options[:compress]
+        tpkgfile = compress_file(tpkgfile, options[:compress]) 
+      end
+
       # Tar up checksum.xml and the main tarball
       system("#{find_tar} -C #{workdir} -cf #{pkgfile} #{package_filename}") || raise("Final package creation failed")
     ensure
@@ -508,7 +519,9 @@ class Tpkg
         raise("Unrecognized checksum algorithm #{checksum.elements['algorithm']}")
       end
       # Extract tpkg.tar from the package and digest it
-      IO.popen("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} #{@@taroptions}") do |pipe|
+      extract_tpkg_tar_command = cmd_to_extract_tpkg_tar(package_file, topleveldir)
+      IO.popen(extract_tpkg_tar_command) do |pipe|
+      #IO.popen("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} #{@@taroptions}") do |pipe|
         # Package files can be quite large, so we digest the package in
         # chunks.  A survey of the Internet turns up someone who tested
         # various chunk sizes on various platforms and found 4k to be
@@ -537,10 +550,13 @@ class Tpkg
     ['yml','xml'].each do |format|
       file = File.join('tpkg', "tpkg.#{format}")
 
+      extract_tpkg_tar_command = cmd_to_extract_tpkg_tar(package_file, topleveldir)
+
       # use popen3 instead of popen because popen display stderr when there's an error such as
       # tpkg.yml not being there, which is something we want to ignore since old tpkg doesn't 
       # have tpkg.yml file
-      stdin, stdout, stderr = Open3.popen3("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} | #{find_tar} -xf - -O #{file}") 
+      #stdin, stdout, stderr = Open3.popen3("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} | #{find_tar} -xf - -O #{file}") 
+      stdin, stdout, stderr = Open3.popen3("#{extract_tpkg_tar_command} | #{find_tar} -xf - -O #{file}") 
       filecontent = stdout.read
       if filecontent.nil? or filecontent.empty?
         next
@@ -566,7 +582,8 @@ class Tpkg
     verify_package_checksum(package_file)
     # Extract and parse tpkg.xml
     tpkg_xml = nil
-    IO.popen("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} | #{find_tar} -xf - -O #{File.join('tpkg', 'tpkg.xml')}") do |pipe|
+    extract_tpkg_tar_command = cmd_to_extract_tpkg_tar(package_file, topleveldir)
+    IO.popen("#{extract_tpkg_tar_command} | #{find_tar} -xf - -O #{File.join('tpkg', 'tpkg.xml')}") do |pipe|
       tpkg_xml = REXML::Document.new(pipe.read)
     end
     if !$?.success?
@@ -671,7 +688,8 @@ class Tpkg
     # And write that out to metadata.yml
     metadata_tmpfile = Tempfile.new('metadata.yml', dest)
     metadata.each do | metadata |
-      YAML::dump(metadata.to_hash, metadata_tmpfile)  
+      YAML::dump(metadata.to_hash.recursively{|h| h.stringify_keys }, metadata_tmpfile)  
+      #YAML::dump(metadata.to_hash, metadata_tmpfile)  
     end
     metadata_tmpfile.close
     File.chmod(0644, metadata_tmpfile.path)
@@ -718,6 +736,12 @@ class Tpkg
          Facter['lsbmajdistrelease'].value &&
          !Facter['lsbmajdistrelease'].value.empty?
         osver = Facter['lsbmajdistrelease'].value
+      elsif operatingsystem == 'Ubuntu'
+        # Work around lack of lsbmajdistrelease on older versions of Ubuntu
+        # due to older version of facter.  Support for lsbmajdistrelease on
+        # Ubuntu was added in facter 1.5.3, but there's no good way to force
+        # older Ubuntu systems to a newer version of facter.
+        osver = Facter['lsbdistrelease'].value.split('.').first
       elsif Facter['kernel'] &&
             Facter['kernel'].value == 'Darwin' &&
             Facter['macosx_productversion'] &&
@@ -940,7 +964,8 @@ class Tpkg
     files[:root] = []
     files[:reloc] = []
     topleveldir = package_toplevel_directory(package_file)
-    IO.popen("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} #{@@taroptions}| #{find_tar} #{@@taroptions} -tf -") do |pipe|
+    extract_tpkg_tar_cmd = cmd_to_extract_tpkg_tar(package_file, topleveldir)
+    IO.popen("#{extract_tpkg_tar_cmd} | #{find_tar} #{@@taroptions} -tf -") do |pipe|
       pipe.each do |file|
         file.chomp!
         if file =~ Regexp.new(File.join('tpkg', 'root'))
@@ -1104,7 +1129,8 @@ class Tpkg
     begin
       topleveldir = Tpkg::package_toplevel_directory(package_file)
       workdir = Tpkg::tempdir(topleveldir)
-      system("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} #{@@taroptions}| #{find_tar} #{@@taroptions} -C #{workdir} -xpf -")
+      extract_tpkg_tar_command = cmd_to_extract_tpkg_tar(package_file, topleveldir)
+      system("#{extract_tpkg_tar_command} | #{find_tar} #{@@taroptions} -C #{workdir} -xpf -")
      
       if File.exist?(File.join(workdir,"tpkg", "tpkg.yml"))
         metadata_file = File.join(workdir,"tpkg", "tpkg.yml")
@@ -1162,6 +1188,53 @@ class Tpkg
     end
     return perms, uid, gid
   end 
+
+  # Given a package file, figure out of tpkg.tar was compressed
+  def self.get_compression(package_file)
+    compression = nil
+    IO.popen("#{find_tar} -tf #{package_file} #{@@taroptions}") do |pipe|
+      pipe.each do |file|
+        if file =~ /tpkg.tar.gz$/
+          compression = "gzip" 
+        elsif file =~ /tpkg.tar.bz2$/
+          compression = "bz2"
+        end
+      end
+    end
+    return compression
+  end
+
+  # Given a .tpkg file and the topleveldir, generate the command for
+  # extracting tpkg.tar
+  def self.cmd_to_extract_tpkg_tar(package_file, topleveldir)
+    compression = get_compression(package_file)
+    if compression == "gzip"
+      cmd = "#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar.gz')} #{@@taroptions} | gunzip -c"
+    elsif compression == "bz2"
+      cmd = "#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar.bz2')} #{@@taroptions} | bunzip2 -c"
+    else
+      cmd = "#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} #{@@taroptions}"
+    end
+  end
+ 
+  # Compresses the file using the compression type
+  # specified by the compress flag 
+  # Returns the compressed file
+  def self.compress_file(file, compress)
+    if compress == true or compress == "gzip"
+      result = "#{file}.gz"
+      system("gzip #{file}")
+    elsif compress == "bz2"
+      result = "#{file}.bz2"
+      system("bzip2 #{file}")
+    else
+      raise "Compression #{compress} is not supported"
+    end
+    if !$?.success? or !File.exists?(result)
+      raise "Failed to compress the package" 
+    end
+    return result
+  end
   
   #
   # Instance methods
@@ -1512,7 +1585,11 @@ class Tpkg
             else
               version = debversion
             end
-            if status =~ /installed/
+	    # We want packages with a state of "installed".  However,
+	    # there's also a state of "not-installed", and the state
+	    # field contains several space-seperated values, so we have
+	    # to be somewhat careful to pick out "installed".
+            if status.split(' ').include?('installed')
               pkg = pkg_for_native_package(name, version, package_version, :native_installed)
               native_packages << pkg
             end
@@ -2457,7 +2534,7 @@ class Tpkg
   # permissions and ownership, etc.  Does not check for conflicting
   # files or packages, etc.  Those checks (if desired) must be done before
   # calling this method.
-  def unpack(package_file, passphrase=nil, options={})
+  def unpack(package_file, options={})
     ret_val = 0
     metadata = Tpkg::metadata_from_package(package_file)
 
@@ -2470,7 +2547,8 @@ class Tpkg
     # directory structure in the package.
     topleveldir = Tpkg::package_toplevel_directory(package_file)
     workdir = Tpkg::tempdir(topleveldir, @tmp_directory)
-    system("#{@tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} #{@@taroptions} | #{@tar} #{@@taroptions} -C #{workdir} -xpf -")
+    extract_tpkg_tar_cmd = Tpkg::cmd_to_extract_tpkg_tar(package_file, topleveldir)
+    system("#{extract_tpkg_tar_cmd} | #{@tar} #{@@taroptions} -C #{workdir} -xpf -")
     files_info = {} # store perms, uid, gid, etc. for files
     checksums_of_decrypted_files = {}
     root_dir = File.join(workdir, 'tpkg', 'root')
@@ -2481,7 +2559,7 @@ class Tpkg
     # Get list of conflicting files/directories & store their perm/ownership. That way, we can
     # set them to the correct values later on in order to preserve them.
     # TODO: verify this command works on all platforms
-    files = `#{@tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} #{@@taroptions} | #{@tar} #{@@taroptions} -tf -`
+    files = `#{extract_tpkg_tar_cmd} | #{@tar} #{@@taroptions} -tf -`
     files = files.split("\n")
     conflicting_files = {}
     files.each do | file |
@@ -2495,59 +2573,9 @@ class Tpkg
       end
     end
     
-    # Run preinstall script
-    if File.exist?(File.join(workdir, 'tpkg', 'preinstall'))
-      pwd = Dir.pwd
-      # chdir into the working directory so that the user can specify a
-      # relative path to their file/script.
-      Dir.chdir(File.join(workdir, 'tpkg'))
-
-      # Warn the user about non-executable files, as system will just
-      # silently fail and exit if that's the case.
-      if !File.executable?(File.join(workdir, 'tpkg', 'preinstall'))
-        warn "Warning: preinstall script for #{File.basename(package_file)} is not executable, execution will likely fail"
-      end
-      if @force
-        system(File.join(workdir, 'tpkg', 'preinstall')) || warn("Warning: preinstall for #{File.basename(package_file)} failed with exit value #{$?.exitstatus}")
-      else
-        system(File.join(workdir, 'tpkg', 'preinstall')) || raise("Error: preinstall for #{File.basename(package_file)} failed with exit value #{$?.exitstatus}")
-      end
-      # Switch back to our previous directory
-      Dir.chdir(pwd)
-    end
+    run_preinstall(package_file, workdir)
     
-    # Run any externals
-    metadata[:externals].each do |external|
-      # If the external references a datafile or datascript then read/run it
-      # now that we've unpacked the package contents and have the file/script
-      # available.  This will get us the data for the external.
-      if external[:datafile] || external[:datascript]
-        pwd = Dir.pwd
-        # chdir into the working directory so that the user can specify a
-        # relative path to their file/script.
-        Dir.chdir(File.join(workdir, 'tpkg'))
-        if external[:datafile]
-          # Read the file
-          external[:data] = IO.read(external[:datafile])
-          # Drop the datafile key so that we don't waste time re-reading the
-          # datafile again in the future.
-          external.delete(:datafile)
-        elsif external[:datascript]
-          # Run the script
-          IO.popen(external[:datascript]) do |pipe|
-            external[:data] = pipe.read
-          end
-          # Drop the datascript key so that we don't waste time re-running the
-          # datascript again in the future.
-          external.delete(:datascript)
-        end
-        # Switch back to our previous directory
-        Dir.chdir(pwd)
-      end
-      if !options[:externals_to_skip] || !options[:externals_to_skip].include?(external)
-        run_external(metadata[:filename], :install, external[:name], external[:data])
-      end
-    end if metadata[:externals]
+    run_externals_for_install(metadata, workdir, options[:externals_to_skip])
     
     # Since we're stuck with unpacking to a temporary folder take
     # advantage of that to handle permissions, ownership and decryption
@@ -2665,7 +2693,7 @@ class Tpkg
       
       # Decrypt any files marked for decryption
       if tpkgfile[:encrypt]
-        if passphrase.nil?
+        if !options[:passphrase]
           # If the user didn't supply a passphrase then just remove the
           # encrypted file.  This allows users to install packages that
           # contain encrypted files for which they don't have the
@@ -2675,7 +2703,7 @@ class Tpkg
         else
           (1..3).each do | i |
             begin
-              Tpkg::decrypt(metadata[:name], working_path, passphrase)
+              Tpkg::decrypt(metadata[:name], working_path, options[:passphrase])
               break 
             rescue OpenSSL::CipherError
               @@passphrase = nil
@@ -2686,8 +2714,7 @@ class Tpkg
               end
             end
           end
-
-          #digest = Digest::SHA256.file(working_path).hexdigest
+          
           digest = Digest::SHA256.hexdigest(File.read(working_path))
           # get checksum for the decrypted file. Will be used for creating file_metadata.xml
           checksums_of_decrypted_files[File.expand_path(tpkg_path)] = digest 
@@ -2733,67 +2760,10 @@ class Tpkg
     install_init_scripts(metadata)
     install_crontabs(metadata)
     
-    # Run postinstall script
-    if File.exist?(File.join(workdir, 'tpkg', 'postinstall'))
-      pwd = Dir.pwd
-      # chdir into the working directory so that the user can specify a
-      # relative path to their file/script.
-      Dir.chdir(File.join(workdir, 'tpkg'))
-
-      # Warn the user about non-executable files, as system will just
-      # silently fail and exit if that's the case.
-      if !File.executable?(File.join(workdir, 'tpkg', 'postinstall'))
-        warn "Warning: postinstall script for #{File.basename(package_file)} is not executable, execution will likely fail"
-      end
-      # Note this only warns the user if the postinstall fails, it does
-      # not raise an exception like we do if preinstall fails.  Raising
-      # an exception would leave the package's files installed but the
-      # package not registered as installed, which does not seem
-      # desirable.  We could remove the package's files and raise an
-      # exception, but this seems the best approach to me.
-      system(File.join(workdir, 'tpkg', 'postinstall')) || warn("Warning: postinstall for #{File.basename(package_file)} failed with exit value #{$?.exitstatus}")
-      ret_val = POSTINSTALL_ERR if $?.exitstatus > 0
-
-      # Switch back to our previous directory
-      Dir.chdir(pwd)
-    end
+    ret_val = run_postinstall(package_file, workdir)
+    
+    save_package_metadata(package_file, workdir, metadata, files_info, checksums_of_decrypted_files)
     
-    # Save metadata for this pkg
-    package_name = File.basename(package_file, File.extname(package_file))
-    package_metadata_dir = File.join(@metadata_directory, package_name)
-    FileUtils.mkdir_p(package_metadata_dir)
-    metadata_file = File.new(File.join(package_metadata_dir, "tpkg.yml"), "w")
-    metadata.write(metadata_file)
-    metadata_file.close    
-
-    # Save file_metadata.yml for this pkg
-    if File.exist?(File.join(workdir, 'tpkg', 'file_metadata.bin'))
-      file_metadata = FileMetadata.new(File.read(File.join(workdir, 'tpkg', 'file_metadata.bin')), 'bin')
-    elsif File.exist?(File.join(workdir, 'tpkg', 'file_metadata.yml'))
-      file_metadata = FileMetadata.new(File.read(File.join(workdir, 'tpkg', 'file_metadata.yml')), 'yml')
-    elsif File.exists?(File.join(workdir, 'tpkg', 'file_metadata.xml'))
-      file_metadata = FileMetadata.new(File.read(File.join(workdir, 'tpkg', 'file_metadata.xml')), 'xml')
-    end
-    if file_metadata
-      file_metadata[:package_file] = File.basename(package_file)
-      file_metadata[:files].each do |file|
-        acl = files_info[file[:path]] 
-        file.merge!(acl) unless acl.nil?
-        digest = checksums_of_decrypted_files[File.expand_path(file[:path])]
-        if digest
-          digests = file[:checksum][:digests]
-          digests[0][:encrypted] = true
-          digests[1] = {:decrypted => true, :value => digest}
-        end
-      end
-      
-      file = File.open(File.join(package_metadata_dir, "file_metadata.bin"), "w")
-      Marshal.dump(file_metadata.to_hash, file)
-      file.close
-    else
-      warn "Warning: package #{File.basename(package_file)} does not include file_metadata information."
-    end
-
     # Copy the package file to the directory for installed packages
     FileUtils.cp(package_file, @installed_directory)
     
@@ -3039,6 +3009,135 @@ class Tpkg
     end
   end
   
+  def run_preinstall(package_file, workdir)
+    if File.exist?(File.join(workdir, 'tpkg', 'preinstall'))
+      pwd = Dir.pwd
+      # chdir into the working directory so that the user can specify
+      # relative paths to other files in the package.
+      Dir.chdir(File.join(workdir, 'tpkg'))
+      
+      begin
+        # Warn the user about non-executable files, as system will just
+        # silently fail and exit if that's the case.
+        if !File.executable?(File.join(workdir, 'tpkg', 'preinstall'))
+          warn "Warning: preinstall script for #{File.basename(package_file)} is not executable, execution will likely fail"
+        end
+        if @force
+          system(File.join(workdir, 'tpkg', 'preinstall')) || warn("Warning: preinstall for #{File.basename(package_file)} failed with exit value #{$?.exitstatus}")
+        else
+          system(File.join(workdir, 'tpkg', 'preinstall')) || raise("Error: preinstall for #{File.basename(package_file)} failed with exit value #{$?.exitstatus}")
+        end
+      ensure
+        # Switch back to our previous directory
+        Dir.chdir(pwd)
+      end
+    end
+  end
+  def run_postinstall(package_file, workdir)
+    r = 0
+    if File.exist?(File.join(workdir, 'tpkg', 'postinstall'))
+      pwd = Dir.pwd
+      # chdir into the working directory so that the user can specify
+      # relative paths to other files in the package.
+      Dir.chdir(File.join(workdir, 'tpkg'))
+      
+      begin
+        # Warn the user about non-executable files, as system will just
+        # silently fail and exit if that's the case.
+        if !File.executable?(File.join(workdir, 'tpkg', 'postinstall'))
+          warn "Warning: postinstall script for #{File.basename(package_file)} is not executable, execution will likely fail"
+        end
+        # Note this only warns the user if the postinstall fails, it does
+        # not raise an exception like we do if preinstall fails.  Raising
+        # an exception would leave the package's files installed but the
+        # package not registered as installed, which does not seem
+        # desirable.  We could remove the package's files and raise an
+        # exception, but this seems the best approach to me.
+        system(File.join(workdir, 'tpkg', 'postinstall'))
+        if !$?.success?
+          warn("Warning: postinstall for #{File.basename(package_file)} failed with exit value #{$?.exitstatus}")
+          r = POSTINSTALL_ERR
+        end
+      ensure
+        # Switch back to our previous directory
+        Dir.chdir(pwd)
+      end
+    end
+    r
+  end
+  
+  def run_externals_for_install(metadata, workdir, externals_to_skip)
+    metadata[:externals].each do |external|
+      # If the external references a datafile or datascript then read/run it
+      # now that we've unpacked the package contents and have the file/script
+      # available.  This will get us the data for the external.
+      if external[:datafile] || external[:datascript]
+        pwd = Dir.pwd
+        # chdir into the working directory so that the user can specify a
+        # relative path to their file/script.
+        Dir.chdir(File.join(workdir, 'tpkg'))
+        if external[:datafile]
+          # Read the file
+          external[:data] = IO.read(external[:datafile])
+          # Drop the datafile key so that we don't waste time re-reading the
+          # datafile again in the future.
+          external.delete(:datafile)
+        elsif external[:datascript]
+          # Run the script
+          IO.popen(external[:datascript]) do |pipe|
+            external[:data] = pipe.read
+          end
+          # Drop the datascript key so that we don't waste time re-running the
+          # datascript again in the future.
+          external.delete(:datascript)
+        end
+        # Switch back to our previous directory
+        Dir.chdir(pwd)
+      end
+      if !externals_to_skip || !externals_to_skip.include?(external)
+        run_external(metadata[:filename], :install, external[:name], external[:data])
+      end
+    end if metadata[:externals]
+  end
+  
+  def save_package_metadata(package_file, workdir, metadata, files_info, checksums_of_decrypted_files)
+    # Save metadata for this pkg
+    package_name = File.basename(package_file, File.extname(package_file))
+    package_metadata_dir = File.join(@metadata_directory, package_name)
+    FileUtils.mkdir_p(package_metadata_dir)
+    metadata_file = File.new(File.join(package_metadata_dir, "tpkg.yml"), "w")
+    metadata.write(metadata_file)
+    metadata_file.close
+    
+    # Save file_metadata.yml for this pkg
+    if File.exist?(File.join(workdir, 'tpkg', 'file_metadata.bin'))
+      file_metadata = FileMetadata.new(File.read(File.join(workdir, 'tpkg', 'file_metadata.bin')), 'bin')
+    elsif File.exist?(File.join(workdir, 'tpkg', 'file_metadata.yml'))
+      file_metadata = FileMetadata.new(File.read(File.join(workdir, 'tpkg', 'file_metadata.yml')), 'yml')
+    elsif File.exists?(File.join(workdir, 'tpkg', 'file_metadata.xml'))
+      file_metadata = FileMetadata.new(File.read(File.join(workdir, 'tpkg', 'file_metadata.xml')), 'xml')
+    end
+    if file_metadata
+      file_metadata[:package_file] = File.basename(package_file)
+      file_metadata[:files].each do |file|
+        acl = files_info[file[:path]] 
+        file.merge!(acl) unless acl.nil?
+        digest = checksums_of_decrypted_files[File.expand_path(file[:path])]
+        if digest
+          digests = file[:checksum][:digests]
+          digests[0][:encrypted] = true
+          digests[1] = {:decrypted => true, :value => digest}
+        end
+      end
+      
+      file = File.open(File.join(package_metadata_dir, "file_metadata.bin"), "w")
+      Marshal.dump(file_metadata.to_hash, file)
+      file.close
+    else
+      warn "Warning: package #{File.basename(package_file)} does not include file_metadata information."
+    end
+  end
+  
   def requirements_for_currently_installed_package(pkgname=nil)
     requirements = []
     metadata_for_installed_packages.each do |metadata|
@@ -3461,7 +3560,7 @@ class Tpkg
           warn "Skipping #{File.basename(pkgfile)}, already installed"
         else
           if prompt_for_conflicting_files(pkgfile)
-            ret_val |= unpack(pkgfile, passphrase)
+            ret_val |= unpack(pkgfile, :passphrase => passphrase)
           end
         end
       end
@@ -3697,7 +3796,7 @@ class Tpkg
             end
           end if pkg[:metadata][:dependencies]
           if can_unpack
-            ret_val |= unpack(pkgfile, passphrase, :externals_to_skip => externals_to_skip)
+            ret_val |= unpack(pkgfile, :passphrase => passphrase, :externals_to_skip => externals_to_skip)
           end
 
           has_updates = true
@@ -3829,7 +3928,8 @@ class Tpkg
     
       topleveldir = Tpkg::package_toplevel_directory(package_file)
       workdir = Tpkg::tempdir(topleveldir, @tmp_directory)
-      system("#{@tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} #{@@taroptions} | #{@tar} #{@@taroptions} -C #{workdir} -xpf -")
+      extract_tpkg_tar_command = Tpkg::cmd_to_extract_tpkg_tar(package_file, topleveldir)
+      system("#{extract_tpkg_tar_command} | #{@tar} #{@@taroptions} -C #{workdir} -xpf -")
     
       # Run preremove script
       if File.exist?(File.join(workdir, 'tpkg', 'preremove'))

data/lib/tpkg/deployer.rb

@@ -16,22 +16,12 @@ rescue LoadError
   require 'rubygems'
   require 'net/ssh'
 end
-#require 'highline/import'
 
 class Deployer
-#  def self.new
-#    begin
-#      require 'rubygems'
-#      require 'net/ssh'
-#      require 'highline/import'
-#    rescue LoadError
-#      raise LoadError, "In order to use the deployment feature, you must have rubygems installed. Additionally, you need to install the following gems: net-ssh, highline"
-#    else
-#      super
-#    end
-#  end
-
+  
   def initialize(options = nil)
+    @sudo_pw = nil
+    @pw_prompts = {}
     @mutex = Mutex.new
     @max_worker = 4
     @abort_on_failure = false
@@ -47,21 +37,12 @@ class Deployer
     end
   end
 
-  def prompt
-    user = prompt_username
-    password = prompt_password
-    return user, password
-  end
-
   def prompt_username
-    print "Username: "
-    user = $stdin.gets.chomp
-    return user
+    ask("Username: ")
   end     
          
   def prompt_password
-    password = ask("SSH Password (leave blank if using ssh key): ", true) 
-    return password 
+    ask("SSH Password (leave blank if using ssh key): ", true) 
   end
 
   def ask(str,mask=false)
@@ -75,31 +56,29 @@ class Deployer
     return input
   end
 
-  $sudo_pw = nil
   def get_sudo_pw
     @mutex.synchronize {
-      if $sudo_pw.nil?
-        $sudo_pw = ask("Sudo password: ", true)
+      if @sudo_pw.nil?
+        @sudo_pw = ask("Sudo password: ", true)
       else
-        return $sudo_pw
+        return @sudo_pw
       end    
     }
   end
 
-  $passphrases = {}
-  def get_passphrase(package)
+  # Prompt user for input and cache it. If in the future, we see
+  # the same prompt again, we can reuse the existing inputs. This saves
+  # the users from having to type in a bunch of inputs (such as password)
+  def get_input_for_pw_prompt(prompt)
     @mutex.synchronize {
-      if $passphrases[package].nil?
-      #  $stdout.write package
-      #  $stdout.flush
-      #  $passphrases[package] = $stdin.gets.chomp
-        $passphrases[package] = ask(package, true)
-      else
-        return $passphrases[package]
-      end   
+      if @pw_prompts[prompt].nil?
+        @pw_prompts[prompt] = ask(prompt, true)
+      end
+      return @pw_prompts[prompt]
     }
   end
 
+  # Return a block that can be used for executing a cmd on the remote server
   def ssh_execute(server, username, password, cmd)
     return lambda { 
       exit_status = 0
@@ -130,19 +109,14 @@ class Deployer
               # for; now we can check to see if it's a password prompt, and
               # interactively return data if so (see request_pty above).
               channel.on_data do |ch, data|
-                if data =~ /Password/
-                  #sudo_password = (!password.nil && password != "" && password) ||  get_sudo_pw
+                if data =~ /Password:/
                   password = get_sudo_pw unless !password.nil? && password != ""
                   channel.send_data "#{password}\n"
-                elsif data  =~ /Passphrase/ or data =~ /pass phrase/ or data =~ /incorrect passphrase/i
-                  passphrase = get_passphrase(data)  
-                  channel.send_data "#{passphrase}\n"
+                elsif data =~ /password/i or data  =~ /passphrase/i or 
+                      data =~ /pass phrase/i or data =~ /incorrect passphrase/i
+                  input = get_input_for_pw_prompt(data)
+                  channel.send_data "#{input}\n"
                 else
-#                  print "#{server}: #{data}" if $debug
-                  # ssh channels can be treated as a hash for the specific purpose of
-                  # getting values out of the block later
-#                channel[:result] ||= ""
-#                channel[:result] << data
                   result << data unless data.nil? or data.empty?
                 end
               end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tpkg
 version: !ruby/object:Gem::Version 
-  version: 1.19.2
+  version: 1.20.0
 platform: ruby
 authors: 
 - Darren Dao
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-16 00:00:00 -08:00
+date: 2010-02-27 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,7 +34,7 @@ dependencies:
         version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
-  name: kwalify
+  name: ddao-kwalify
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
@@ -55,24 +55,24 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- bin/cpan2tpkg
-- bin/tpkg_xml_to_yml
-- bin/tpkg
-- bin/gem2tpkg
-- schema/tpkg.dtd
-- schema/schema-1.0.yml
-- schema/tpkg-1.0.0.dtd
-- schema/tpkg-1.0.4.dtd
-- schema/tpkg-1.0.3.dtd
-- schema/schema.yml
-- schema/tpkg-1.0.5.dtd
-- schema/tpkg-1.0.2.dtd
-- schema/tpkg-1.0.1.dtd
 - lib/tpkg/versiontype.rb
 - lib/tpkg/deployer.rb
 - lib/tpkg/thread_pool.rb
 - lib/tpkg/metadata.rb
 - lib/tpkg.rb
+- schema/tpkg-1.0.4.dtd
+- schema/tpkg-1.0.0.dtd
+- schema/tpkg-1.0.5.dtd
+- schema/tpkg.dtd
+- schema/tpkg-1.0.1.dtd
+- schema/tpkg-1.0.3.dtd
+- schema/schema.yml
+- schema/tpkg-1.0.2.dtd
+- schema/schema-1.0.yml
+- bin/tpkg
+- bin/cpan2tpkg
+- bin/gem2tpkg
+- bin/tpkg_xml_to_yml
 - Rakefile
 has_rdoc: true
 homepage: http://tpkg.sourceforge.net