tpkg 1.23.3 → 1.25.1

data/Rakefile

@@ -5,7 +5,7 @@ spec = Gem::Specification.new do |s|
   s.add_dependency('facter')
   s.add_dependency('net-ssh')
   s.add_dependency('ddao-kwalify')
-  s.version = '1.23.3'
+  s.version = '1.25.1'
   s.authors = ['Darren Dao', 'Jason Heiss']
   s.email = 'tpkg-users@lists.sourceforge.net'
   s.homepage = 'http://tpkg.sourceforge.net'

data/bin/gem2tpkg

@@ -35,6 +35,7 @@ end
 @gemcmd = DEFAULT_GEM_COMMAND
 @rubygemspath = nil
 @extrapkgname = nil
+@verbose = false
 
 opts = OptionParser.new
 opts.banner = 'Usage: gem2tpkg [options] GEMNAME1 GEMNAME2 ...'
@@ -85,6 +86,9 @@ end
 opts.on('--extra-name', '=EXTRANAME', 'Extra string to add to package name') do |opt|
   @extrapkgname = opt
 end
+opts.on('--verbose', 'Provides more info on what is being executed') do |opt|
+  @verbose = opt
+end
 opts.on_tail("-h", "--help", "Show this message") do
   puts opts
   exit
@@ -99,7 +103,9 @@ leftover = opts.parse(ARGV)
 @geminstallpath = nil
 @gembinpath = nil
 @rubypath = nil
-IO.popen("#{@gemcmd} environment") do |pipe|
+cmd = "#{@gemcmd} environment"
+puts "Executing: #{cmd}" if @verbose
+IO.popen(cmd) do |pipe|
   pipe.each_line do |line|
     if line =~ /INSTALLATION DIRECTORY:\s+(\S+)/
       @geminstallpath = $1
@@ -180,6 +186,7 @@ if !@buildopts.empty?
   geminst.concat(@buildopts)
 end
 
+puts "Executing: #{geminst.join(" ")}" if @verbose
 r = system(*geminst)
 if !r
   abort('gem install failed')
@@ -240,7 +247,9 @@ def package(gem)
   # We want to exactly match the gem in question.  Turns out that if you
   # pass something that looks like a regex then gem dependency will use
   # that instead.  See rubygems/commands/dependency_command.rb
-  IO.popen("#{@gemcmd} dependency /^#{Regexp.escape(gem)}$/") do |pipe|
+  cmd = "#{@gemcmd} dependency /^#{Regexp.escape(gem)}$/"
+  puts "Executing: #{cmd}" if @verbose
+  IO.popen(cmd) do |pipe|
     pipe.each_line do |line|
       next if line =~ /^Gem /  # Skip header line
       next if line =~ /^\s*$/  # Skip blank lines

data/bin/tpkg

@@ -31,7 +31,7 @@ require 'tpkg'
 @tpkg_options = {}	# options for instantiating Tpkg object
 @init_options = {}      # options for how to run init scripts
 @other_options = {}     
-@compress = nil
+@compress = "gzip"
 
 
 def rerun_with_sudo_if_necessary
@@ -214,12 +214,19 @@ opts.on('--qX', '=FILENAME', 'Display tpkg.xml or tpkg.yml of the given package'
   @action = :query_tpkg_metadata
   @action_value = opt
 end
+opts.on('--history', 'Display package installation history') do |opt|
+  @action = :query_history
+end
 opts.on('--qenv', "Display machine's information") do |opt|
   @action = :query_env
 end
 opts.on('--source', '=NAME', 'Sources where packages are located', Array) do |opt|
   @tpkg_options["sources"] = opt
 end
+opts.on('--download', '=PACKAGES', 'Download one or more packages', Array) do |opt|
+  @action = :download
+  @action_value = opt
+end
 opts.on('-n', '--no-prompt', 'No confirmation prompts') do |opt|
   @prompt = opt
   Tpkg::set_prompt(@prompt)
@@ -252,7 +259,11 @@ opts.on('--deploy-as', '=USERNAME', 'What username to use for deploying to remot
   @deploy_params = @deploy_params - ['--deploy-as']
 end
 opts.on('--compress', '=[TYPE]', 'Compress files when making packages') do |opt|
-  @compress = opt
+  if opt == "no"
+    @compress= false
+  else
+    @compress = opt
+  end
 end
 opts.on('--debug', 'Print lots of messages about what tpkg is doing') do |opt|
   @debug = opt
@@ -392,6 +403,9 @@ when :upgrade
 when :remove
   tpkg = instantiate_tpkg(@tpkg_options)
   ret_val = tpkg.remove(@action_value, @other_options)
+when :download
+  tpkg = instantiate_tpkg(@tpkg_options)
+  ret_val = tpkg.download_pkgs(@action_value, @other_options)
 when :verify
   result = nil
   # Verify a given .tpkg file
@@ -614,5 +628,8 @@ when :query_tpkg_metadata
 when :query_env
   puts "Operating System: #{Tpkg::get_os}"
   puts "Architecture: #{Tpkg::get_arch}"
+when :query_history
+  tpkg = instantiate_tpkg(@tpkg_options)
+  tpkg.installation_history
 end
 exit ret_val

data/lib/tpkg.rb

@@ -56,7 +56,7 @@ require 'kwalify'        # for validating yaml
 
 class Tpkg
   
-  VERSION = '1.23.3'
+  VERSION = '1.25.1'
   CONFIGDIR = '/etc'
 
   GENERIC_ERR = 1  
@@ -153,7 +153,15 @@ class Tpkg
     else
       pass = passphrase
     end
-    
+
+    # special handling for directory
+    if File.directory?(filename)
+      Find.find(filename) do |f|
+        encrypt(pkgname, f, pass, cipher) if File.file?(f)
+      end
+      return
+    end
+ 
     salt = OpenSSL::Random::random_bytes(SALT_LEN)
     c = OpenSSL::Cipher::Cipher.new(cipher)
     c.encrypt
@@ -173,6 +181,7 @@ class Tpkg
     tmpfile.close
     File.rename(tmpfile.path, filename)
   end
+
   # Decrypt the given file in-place.
   def self.decrypt(pkgname, filename, passphrase, cipher='aes-256-cbc')
     # passphrase can be a callback Proc, call it if that's the case
@@ -185,6 +194,13 @@ class Tpkg
     else
       pass = passphrase
     end
+
+    if File.directory?(filename)
+      Find.find(filename) do |f|
+        decrypt(pkgname, f, pass, cipher) if File.file?(f)
+      end
+      return
+    end
     
     file = File.open(filename)
     if (buf = file.read(MAGIC.length)) != MAGIC
@@ -250,12 +266,11 @@ class Tpkg
     else
       workdir = tempdir('tpkg', File.dirname(pkgsrcdir))
     end
-
     begin
       # Make the 'tpkg' directory for storing the package contents
       tpkgdir = File.join(workdir, 'tpkg')
       Dir.mkdir(tpkgdir)
-      
+
       # A package really shouldn't be partially relocatable, warn the user if
       # they're creating such a scourge.
       if (File.exist?(File.join(pkgsrcdir, 'root')) && File.exist?(File.join(pkgsrcdir, 'reloc')))
@@ -267,20 +282,13 @@ class Tpkg
       # And on further reflection it makes sense to only have one chunk of
       # code (tar) ever touch the user's files.
       system("#{find_tar} -C #{pkgsrcdir} -cf - . | #{find_tar} -C #{tpkgdir} -xpf -") || raise("Package content copy failed")
-      
+ 
       # check metadata file 
       errors = []
-      if File.exists?(File.join(tpkgdir, 'tpkg.yml'))
-        metadata_file = File.join(tpkgdir, 'tpkg.yml')
-        metadata_format = 'yml'
-      elsif File.exists?(File.join(tpkgdir, 'tpkg.xml'))
-        metadata_file = File.join(tpkgdir, 'tpkg.xml')
-        metadata_format = 'xml'
-      else
+      metadata = Metadata::instantiate_from_dir(tpkgdir)
+      if !metadata
         raise 'Your source directory does not contain the metadata configuration file.'
       end
-      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"))
@@ -306,7 +314,6 @@ class Tpkg
         filemetadata = get_filemetadata_from_directory(tpkgdir)
         data = filemetadata.to_hash.recursively{|h| h.stringify_keys }
         Marshal::dump(data, file)
-#        YAML::dump(filemetadata.to_hash, file)  
       end
 
       # Check all the files are there as specified in the metadata config file
@@ -338,13 +345,13 @@ class Tpkg
 
         # Encrypt any files marked for encryption
         if tpkgfile[:encrypt]
-          if tpkgfile[:encrypt] == 'precrypt'
+          if tpkgfile[:encrypt][:precrypt]
             verify_precrypt_file(working_path)
           else
             if passphrase.nil?
               raise "Package requires encryption but supplied passphrase is nil"
             end
-            encrypt(metadata[:name], working_path, passphrase)
+            encrypt(metadata[:name], working_path, passphrase, *([tpkgfile[:encrypt][:algorithm]].compact))
           end
         end
       end unless metadata[:files].nil? or metadata[:files][:files].nil?
@@ -369,7 +376,10 @@ class Tpkg
         end
         File.delete(pkgfile)
       end
-      
+    
+      # update metadata file with the tpkg version 
+      # TODO
+ 
       # Tar up the tpkg directory
       tpkgfile = File.join(package_directory, 'tpkg.tar')
       system("#{find_tar} -C #{workdir} -cf #{tpkgfile} tpkg") || raise("tpkg.tar creation failed")
@@ -444,6 +454,11 @@ class Tpkg
       next if !File.exist?(f)
       relocatable = false
 
+      # Append file separator at the end for directory
+      if File.directory?(f)
+        f += File::SEPARATOR
+      end
+
       # check if it's from root dir or reloc dir
       if f =~ /^#{root_dir}/
         short_fn = f[root_dir.length ..-1]
@@ -864,15 +879,42 @@ class Tpkg
      barchlength, acurrentinstallnoprefer]
   end
   
-  def self.files_in_package(package_file)
+  def self.files_in_package(package_file, options = {})
+    file_lists = []
     files = {}
     files[:root] = []
     files[:reloc] = []
-    topleveldir = package_toplevel_directory(package_file)
-    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 the metadata_directory option is available, it means this package
+    # has been installed and the file_metadata might be available in that directory.
+    # If that's the case, then parse the file_metadata to get the file list. It's
+    # much faster than extracting from the tar file
+    if metadata_directory = options[:metadata_directory]
+      package_name = File.basename(package_file, File.extname(package_file))
+      file_metadata = FileMetadata::instantiate_from_dir(File.join(metadata_directory, package_name))
+    end
+
+    if file_metadata
+      file_metadata[:files].each do |file|
+        if file[:relocatable]
+          files[:reloc] << file[:path]
+        else
+          files[:root] << file[:path]
+        end
+      end
+    else
+      topleveldir = package_toplevel_directory(package_file)
+      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_lists << file.chomp!
+        end
+      end
+      if !$?.success?
+        raise "Extracting file list from #{package_file} failed"
+      end
+
+      file_lists.each do |file|
         if file =~ Regexp.new(File.join('tpkg', 'root'))
           files[:root] << file.sub(Regexp.new(File.join('tpkg', 'root')), '')
         elsif file =~ Regexp.new(File.join('tpkg', 'reloc', '.'))
@@ -880,9 +922,7 @@ class Tpkg
         end
       end
     end
-    if !$?.success?
-      raise "Extracting file list from #{package_file} failed"
-    end
+
     files
   end
   
@@ -1150,7 +1190,7 @@ class Tpkg
     eprime.set_backtrace(e.backtrace)
     eprime
   end
-  
+
   #
   # Instance methods
   #
@@ -1675,16 +1715,10 @@ class Tpkg
             File.join(@metadata_directory,
                       File.basename(entry, File.extname(entry)))
           metadata_file = File.join(package_metadata_dir, "tpkg.yml")
-          m = nil
-          if File.exists?(metadata_file)
-            metadata_text = File.read(metadata_file)
-            m = Metadata.new(metadata_text, 'yml')
-          elsif File.exists?(File.join(package_metadata_dir, "tpkg.xml"))
-            metadata_text = File.read(File.join(package_metadata_dir, "tpkg.xml"))
-            m = Metadata.new(metadata_text, 'xml')
+          m = Metadata::instantiate_from_dir(package_metadata_dir)
           # No cached metadata found, we have to extract it ourselves
           # and save it for next time
-          else
+          if !m
             m = Tpkg::metadata_from_package(
                   File.join(@installed_directory, entry))
             begin
@@ -1721,22 +1755,18 @@ class Tpkg
   end
   
   # Returns a hash of file_metadata for installed packages
-  def file_metadata_for_installed_packages
+  def file_metadata_for_installed_packages(package_files = nil)
     ret = {}
 
+    if package_files
+      packages_files.collect!{|package_file| File.basename(package_file, File.extname(package_file))}
+    end
+
     if File.directory?(@metadata_directory)
       Dir.foreach(@metadata_directory) do |entry|
         next if entry == '.' || entry == '..' 
-        if File.exists?(File.join(@metadata_directory, entry, "file_metadata.bin"))
-          file = File.join(@metadata_directory, entry, "file_metadata.bin")
-          file_metadata = FileMetadata.new(File.read(file), 'bin')
-        elsif File.exists?(File.join(@metadata_directory, entry, "file_metadata.yml"))
-          file = File.join(@metadata_directory, entry, "file_metadata.yml")
-          file_metadata = FileMetadata.new(File.read(file), 'yml')
-        elsif File.exists?(File.join(@metadata_directory, entry, "file_metadata.xml"))
-          file = File.join(@metadata_directory, entry, "file_metadata.xml")
-          file_metadata = FileMetadata.new(File.read(file), 'xml')
-        end
+        next if package_files && !package_files.include?(entry)
+        file_metadata = FileMetadata::instantiate_from_dir(File.join(@metadata_directory, entry))
         ret[file_metadata[:package_file]] = file_metadata
       end
     end
@@ -1871,10 +1901,11 @@ class Tpkg
         package_files << metadata[:filename]
       end
     end
+
     metadata_for_installed_packages.each do |metadata|
       package_file = metadata[:filename]
       if package_files.include?(package_file)
-        fip = Tpkg::files_in_package(File.join(@installed_directory, package_file))
+        fip = Tpkg::files_in_package(File.join(@installed_directory, package_file), {:metadata_directory => @metadata_directory})
         normalize_paths(fip)
         fip[:metadata] = metadata
         files[package_file] = fip
@@ -2206,14 +2237,13 @@ class Tpkg
     return {:number_of_possible_solutions_checked => number_of_possible_solutions_checked}
   end
  
-  def download(source, path, downloaddir = nil)
+  def download(source, path, downloaddir = nil, use_cache = true)
     http = Tpkg::gethttp(URI.parse(source))
     localdir = source_to_local_directory(source)
     localpath = File.join(localdir, File.basename(path))
-
     # Don't download again if file is already there from previous installation
     # and still has valid checksum
-    if File.file?(localpath)
+    if File.file?(localpath) && use_cache
       begin
         Tpkg::verify_package_checksum(localpath)
         return localpath
@@ -2521,7 +2551,7 @@ class Tpkg
         if File.directory?(f)
           File.chown(default_dir_uid, default_dir_gid, f)
         else
-          File.chown(default_uid, default_gid, f)
+          File.chown(default_uid, default_gid, f) 
         end
       rescue Errno::EPERM
         raise if Process.euid == 0
@@ -2590,7 +2620,7 @@ class Tpkg
         else
           (1..3).each do | i |
             begin
-              Tpkg::decrypt(metadata[:name], working_path, options[:passphrase])
+              Tpkg::decrypt(metadata[:name], working_path, options[:passphrase], *([tpkgfile[:encrypt][:algorithm]].compact))
               break 
             rescue OpenSSL::CipherError
               @@passphrase = nil
@@ -2601,10 +2631,12 @@ class Tpkg
               end
             end
           end
-          
-          digest = Digest::SHA256.hexdigest(File.read(working_path))
-          # get checksum for the decrypted file. Will be used for creating file_metadata
-          checksums_of_decrypted_files[File.expand_path(tpkg_path)] = digest 
+         
+          if File.file?(working_path) 
+            digest = Digest::SHA256.hexdigest(File.read(working_path))
+            # get checksum for the decrypted file. Will be used for creating file_metadata
+            checksums_of_decrypted_files[File.expand_path(tpkg_path)] = digest 
+          end
         end
       end
     end if metadata[:files] && metadata[:files][:files]
@@ -2998,18 +3030,10 @@ class Tpkg
     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
+    metadata.write(package_metadata_dir)
     
     # Save file_metadata 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
+    file_metadata = FileMetadata::instantiate_from_dir(File.join(workdir, 'tpkg'))
     if file_metadata
       file_metadata[:package_file] = File.basename(package_file)
       file_metadata[:files].each do |file|
@@ -3230,7 +3254,6 @@ class Tpkg
         end
       end
     end
-    
     # The remove method actually needs !conflicts, so invert in that case
     if mode == CHECK_REMOVE
       # Flatten conflicts to an array
@@ -3617,7 +3640,6 @@ class Tpkg
     # in order to report back to the server
     already_installed_pkgs = metadata_for_installed_packages.collect{|metadata| metadata.to_hash}
     
-    installed_files = files_for_installed_packages
     removed_pkgs = [] # keep track of what we removed so far
     while pkg = solution_packages.shift
       if pkg[:source] == :currently_installed ||
@@ -4020,17 +4042,9 @@ class Tpkg
       # Extract checksum.xml from the package
       checksum_xml = nil
 
-      # get file_metadata.xml from the installed package
-      file_metadata_bin = File.join(@metadata_directory, package_full_name, 'file_metadata.bin')
-      file_metadata_yml = File.join(@metadata_directory, package_full_name, 'file_metadata.yml')
-      file_metadata_xml = File.join(@metadata_directory, package_full_name, 'file_metadata.xml')
-      if File.exist?(file_metadata_bin)
-        file_metadata = FileMetadata.new(File.read(file_metadata_bin), 'bin')
-      elsif File.exist?(file_metadata_yml)
-        file_metadata = FileMetadata.new(File.read(file_metadata_yml), 'yml')
-      elsif File.exist?(file_metadata_xml)
-        file_metadata = FileMetadata.new(File.read(file_metadata_xml), 'xml')
-      else 
+      # get file_metadata from the installed package
+      file_metadata = FileMetadata::instantiate_from_dir(File.join(@metadata_directory, package_full_name))
+      if !file_metadata
         errors = []
         errors << "Can't find file metadata. Most likely this is because the package was created before the verify feature was added"
         results[package_file] = errors
@@ -4302,6 +4316,77 @@ class Tpkg
     return pre_reqs
   end
 
+  # print out history packages installation/remove
+  def installation_history
+    if !File.exists?(File.join(@log_directory,'changes.log'))
+      puts "Tpkg history log does not exist."
+      return GENERIC_ERR
+    end
+    IO.foreach(File.join(@log_directory,'changes.log')) do |line|
+      puts line 
+    end
+  end
+
+  # Download packages that meet the requests specified by the user.
+  # Packages are downloaded into the current directory or into the directory
+  # specified in options[:out]
+  def download_pkgs(requests, options={})
+    if options[:out] 
+      if !File.exists?(options[:out])
+        FileUtils.mkdir_p(options[:out])
+      elsif !File.directory?(options[:out])
+        puts "#{options[:out]} is not a valid directory."
+        return GENERIC_ERR
+      end
+    end
+    output_dir = options[:out] || Dir.pwd
+
+    requirements = []
+    packages = {}
+    original_dir = Dir.pwd
+
+    workdir = Tpkg::tempdir("tpkg_download")
+    Dir.chdir(workdir)
+    parse_requests(requests, requirements, packages)
+    packages = packages.values.flatten
+    if packages.size < 1
+      puts "Unable to find any packages that satisfy your request."
+      Dir.chdir(original_dir) 
+      return GENERIC_ERR
+    end
+
+    # Confirm with user what packages will be downloaded
+    packages.delete_if{|pkg|pkg[:source] !~ /^http/}
+    puts "The following packages will be downloaded:"
+    packages.each do |pkg|
+      puts "#{pkg[:metadata][:filename]} (source: #{pkg[:source]})"
+    end
+    if @@prompt && !Tpkg::confirm 
+      Dir.chdir(original_dir) 
+      return 0
+    end
+
+    err_code = 0
+    puts "Downloading to #{output_dir}"
+    packages.each do |pkg|
+      puts "Downloading #{pkg[:metadata][:filename]}"
+      begin
+        downloaded_file = download(pkg[:source], pkg[:metadata][:filename], Dir.pwd, false)
+        # copy downloaded files over to destination
+        FileUtils.cp(downloaded_file, output_dir)
+      rescue
+        warn "Warning: unable to download #{pkg[:metadata][:filename]} to #{output_dir}"
+        err_code = GENERIC_ERR
+      end
+    end
+
+    # clean up working directory
+    FileUtils.rm_rf(workdir)
+    
+    Dir.chdir(original_dir) 
+    return err_code
+  end
+
   # TODO: figure out what other methods above can be turned into protected methods
   protected
   # log changes of pkgs that were installed/removed

data/lib/tpkg/metadata.rb

@@ -242,6 +242,18 @@ class Metadata
     return metadata
   end
 
+  # Given the directory from which the metadata is saved, returns a Metadata
+  # object. The metadata file can be in yml or xml format
+  def self.instantiate_from_dir(dir)
+    metadata = nil
+    if File.exist?(File.join(dir, 'tpkg.yml'))
+      metadata = Metadata.new(File.read(File.join(dir, 'tpkg.yml')), 'yml')
+    elsif File.exists?(File.join(dir, 'tpkg.xml'))
+      metadata = Metadata.new(File.read(File.join(dir, 'tpkg.xml')), 'xml')
+    end
+    return metadata
+  end
+
   # metadata_text = text representation of the metadata
   # format = yml, xml, json, etc.
   def initialize(metadata_text, format, source=nil)
@@ -279,17 +291,43 @@ class Metadata
           end
         end
       end if @hash[:dependencies]
+
+      @hash[:files][:files].each do |file|
+        # We need to do this for backward compatibility. In the old yml schema,
+        # the encrypt field can either be "true" or a string value. Now, it is
+        # a hash. We need to use a hash because we need to store info like the 
+        # encryption algorithm.
+        if file[:encrypt] && !file[:encrypt].is_a?(Hash)
+          precrypt = true if file[:encrypt] == 'precrypt'
+          file[:encrypt] = {:precrypt => precrypt}
+        end
+        # perms value are octal, but kwalify might treat it as decimal if it's something like 4550
+        # the user might also use string instead of number
+        if file[:posix] && file[:posix][:perms] && 
+          (file[:posix][:perms].is_a?(String) or file[:posix][:perms] >= 1000)
+          file[:posix][:perms] = "#{file[:posix][:perms]}".oct
+        end
+      end if @hash[:files] && @hash[:files][:files]
     else
       @hash = metadata_xml_to_hash.with_indifferent_access
     end
     return @hash
   end
 
-  def write(file)
-    # When we convert xml to hash, we store the key as symbol. So when we
-    # write back out to file, we should stringify all the keys for readability.
-    data = to_hash.recursively{|h| h.stringify_keys }
-    YAML::dump(data, file)
+  # Write the metadata to a file under the specified directory
+  # The file will be saved as tpkg.yml or tpkg.xml.
+  def write(dir, retain_format=false)
+    file = nil
+    if retain_format && @format == 'xml'
+      puts "TODO"
+    else
+      file = File.new(File.join(dir, "tpkg.yml"), "w")
+      # When we convert xml to hash, we store the key as symbol. So when we
+      # write back out to file, we should stringify all the keys for readability.
+      data = to_hash.recursively{|h| h.stringify_keys }
+      YAML::dump(data, file)
+    end
+    file.close
   end
 
   def generate_package_filename
@@ -559,10 +597,13 @@ class Metadata
       file = {}
       file[:path] = filexml.elements['path'].text
       if filexml.elements['encrypt']
-        encrypt = true
+        encrypt = {}
         if filexml.elements['encrypt'].attribute('precrypt') &&
            filexml.elements['encrypt'].attribute('precrypt').value == 'true'
-          encrypt = "precrypt"
+          encrypt['precrypt'] = true
+        end
+        if filexml.elements['encrypt'].attribute('algorithm')
+          encrypt['algorithm'] = filexml.elements['encrypt'].attribute('algorithm').value
         end
         file[:encrypt] = encrypt
       end
@@ -618,6 +659,20 @@ class Metadata
 end
 
 class FileMetadata < Metadata
+  # Given the directory from which the file_metadata is saved, returns a FileMetadata
+  # object. The file_metadata file can be in binary, yaml or xml.
+  def self.instantiate_from_dir(dir)
+    file_metadata = nil
+    if File.exist?(File.join(dir, 'file_metadata.bin'))
+      file_metadata = FileMetadata.new(File.read(File.join(dir, 'file_metadata.bin')), 'bin')
+    elsif File.exist?(File.join(dir, 'file_metadata.yml'))
+      file_metadata = FileMetadata.new(File.read(File.join(dir, 'file_metadata.yml')), 'yml')
+    elsif File.exists?(File.join(dir, 'file_metadata.xml'))
+      file_metadata = FileMetadata.new(File.read(File.join(dir, 'file_metadata.xml')), 'xml')
+    end
+    return file_metadata
+  end
+
   def to_hash
     if @hash
       return @hash

data/schema/schema-1.0.7.yml

@@ -0,0 +1,91 @@
+type: map
+mapping: 
+  "schema_file": { type: text }
+  "name": { type: str, required: yes }
+  "version": { type: text, required: yes }
+  "package_version": { type: text }
+  "maintainer": { type: str, required: yes }
+  "operatingsystem": { type: seq, sequence: [ {type: str} ] }
+  "architecture": { type: seq, sequence: [ {type: str} ] }
+  "description": { type: str }
+  "bugreporting": { type: str }
+  "dependencies": 
+    type: seq
+    sequence: 
+      - type: map
+        mapping:
+          "name": { type: str, required: yes }
+          "minimum_version": { type: text }
+          "maximum_version": { type: text }
+          "minimum_package_version": { type: text }
+          "maximum_package_version": { type: text }
+          "allowed_versions": { type: text }
+          "native": { type: bool }
+          "type": { type: any, pattern: /(native|tpkg)$/ }
+  "conflicts":
+    type: seq
+    sequence:
+      - type: map
+        mapping:
+          "name": { type: str, required: yes }
+          "minimum_version": { type: text }
+          "maximum_version": { type: text }
+          "minimum_package_version": { type: text } 
+          "maximum_package_version": { type: text } 
+          "native": { type: bool }
+          "type": { type: any, pattern: /(native|tpkg)$/ }
+  "externals":
+    type: seq
+    sequence:
+      - type: map
+        mapping:
+          "name": { type: text, required: yes }
+          "data": { type: text }
+          "datascript": { type: text }
+          "datafile": { type: text }
+  "files":
+    type: map
+    mapping:
+      "file_defaults":
+        type: map
+        mapping:
+          "posix":
+            type: map
+            mapping:
+              "owner": { type: text }
+              "group": { type: text }
+              "perms": { type: text }
+      "dirs_defaults":
+        type: map
+        mapping:
+          "posix":
+            type: map
+            mapping:
+              "owner": { type: text }
+              "group": { type: text }
+              "perms": { type: text }
+      "files":
+        type: seq
+        sequence:
+          - type: map
+            mapping:
+              "path": { type: text, required: yes }
+              "encrypt": 
+                type: map
+                mapping:
+                  "algorithm": { type: text }
+                  "precrypt": { type: any, pattern: /^true$|^false$/ }
+              "init":
+                type: map
+                mapping:
+                  "start": { type: int }
+                  "levels": { type: seq, sequence: [ { type: int } ] }
+              "crontab":
+                type: map
+                mapping: { "user": { type: str } }
+              "posix":  
+                type: map
+                mapping: { "owner": { type: text },
+                           "group": { type: text },
+                           "perms": { type: text } }
+

data/schema/schema.yml

@@ -70,7 +70,11 @@ mapping:
           - type: map
             mapping:
               "path": { type: text, required: yes }
-              "encrypt": { type: any, pattern: /^true$|^precrypt$/ }
+              "encrypt": 
+                type: map
+                mapping:
+                  "algorithm": { type: text }
+                  "precrypt": { type: any, pattern: /^true$|^false$/ }
               "init":
                 type: map
                 mapping:

data/schema/tpkg-1.0.7.dtd

@@ -0,0 +1,43 @@
+<!ELEMENT tpkg (name, version, package_version?, maintainer+, operatingsystem*, architecture*, description?, bugreporting?, dependencies?, externals?, files?)>
+
+<!ELEMENT name (#PCDATA)>
+<!ELEMENT version (#PCDATA)>
+<!ELEMENT package_version (#PCDATA)>
+<!ELEMENT maintainer (#PCDATA)>
+<!ELEMENT operatingsystem (#PCDATA)>
+<!ELEMENT architecture (#PCDATA)>
+<!ELEMENT description (#PCDATA)>
+<!ELEMENT bugreporting (#PCDATA)>
+
+<!ELEMENT dependencies (dependency*)>
+<!ELEMENT dependency (name, minimum_version?, maximum_version?, minimum_package_version?, maximum_package_version?, allowed_versions?, native?)>
+<!ELEMENT minimum_version (#PCDATA)>
+<!ELEMENT maximum_version (#PCDATA)>
+<!ELEMENT minimum_package_version (#PCDATA)>
+<!ELEMENT maximum_package_version (#PCDATA)>
+<!ELEMENT allowed_versions (#PCDATA)>
+<!ELEMENT native EMPTY>
+
+<!ELEMENT externals (external*)>
+<!ELEMENT external (name, (data|datafile|datascript))>
+<!ELEMENT data (#PCDATA)>
+<!ELEMENT datafile (#PCDATA)>
+<!ELEMENT datascript (#PCDATA)>
+
+<!ELEMENT files (file_defaults?, file*)>
+<!ELEMENT file_defaults (posix?)>
+<!ELEMENT posix (owner?, group?, perms?)>
+<!ELEMENT owner (#PCDATA)>
+<!ELEMENT group (#PCDATA)>
+<!ELEMENT perms (#PCDATA)>
+<!ELEMENT file (path, encrypt?, init?, crontab?, posix?)>
+<!ELEMENT path (#PCDATA)>
+<!ELEMENT encrypt EMPTY>
+<!ATTLIST encrypt precrypt (true|false) #IMPLIED>
+<!ATTLIST encrypt algorithm CDATA #IMPLIED>
+<!ELEMENT init (start?, levels?)>
+<!ELEMENT start (#PCDATA)>
+<!ELEMENT levels (#PCDATA)>
+<!ELEMENT crontab (user?)>
+<!ELEMENT user (#PCDATA)>
+

data/schema/tpkg.dtd

@@ -34,6 +34,7 @@
 <!ELEMENT path (#PCDATA)>
 <!ELEMENT encrypt EMPTY>
 <!ATTLIST encrypt precrypt (true|false) #IMPLIED>
+<!ATTLIST encrypt algorithm CDATA #IMPLIED>
 <!ELEMENT init (start?, levels?)>
 <!ELEMENT start (#PCDATA)>
 <!ELEMENT levels (#PCDATA)>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tpkg
 version: !ruby/object:Gem::Version 
-  version: 1.23.3
+  version: 1.25.1
 platform: ruby
 authors: 
 - Darren Dao
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-20 00:00:00 +00:00
+date: 2010-07-14 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -63,8 +63,10 @@ files:
 - schema/tpkg-1.0.4.dtd
 - schema/tpkg-1.0.0.dtd
 - schema/tpkg-1.0.5.dtd
+- schema/schema-1.0.7.yml
 - schema/tpkg.dtd
 - schema/tpkg-1.0.1.dtd
+- schema/tpkg-1.0.7.dtd
 - schema/tpkg-1.0.3.dtd
 - schema/schema.yml
 - schema/tpkg-1.0.2.dtd