tpkg 2.2.2 → 2.2.3

data/Rakefile

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

data/lib/tpkg.rb

@@ -40,7 +40,7 @@ require 'tpkg/metadata'
 
 class Tpkg
   
-  VERSION = '2.2.2'
+  VERSION = '2.2.3'
 
   GENERIC_ERR = 1  
   POSTINSTALL_ERR = 2
@@ -372,10 +372,18 @@ class Tpkg
         end
         File.delete(pkgfile)
       end
-    
+      
       # update metadata file with the tpkg version
-      metadata.add_tpkg_version(VERSION)
- 
+      begin
+        metadata.add_tpkg_version(VERSION)
+      rescue Errno::EACCES => e
+        # The source directory from which the package is made may not be
+        # writeable by the user making the package.  It is not critical that
+        # the tpkg version get added to the package metadata, so just warn the
+        # user if that happens.
+        warn "Failed to insert tpkg_version into tpkg.(xml|yml): #{e.message}"
+      end 
+      
       # 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")
@@ -415,23 +423,41 @@ class Tpkg
     # This assumes the first entry in the tarball is the top level directory.
     # I think that is a safe assumption.
     toplevel = nil
-    # FIXME: This is so lame, to read the whole package to get the
-    # first filename.  Blech.
-    IO.popen("#{find_tar} -tf #{package_file} #{@@taroptions}") do |pipe|
-      toplevel = pipe.gets
-      if toplevel.nil?
-         raise "Package directory structure of #{package_file} unexpected. Unable to get top level."
-      end
-      toplevel.chomp!
-      # Avoid SIGPIPE, if we don't sink the rest of the output from tar
-      # then tar ends up getting SIGPIPE when it tries to write to the
-      # closed pipe and exits with error, which causes us to throw an
-      # exception down below here when we check the exit status.
-      pipe.read
+    # We need one or more 512 byte tar blocks from the file to get the first
+    # filename.  In most cases we'll just need one block, but if the top-level
+    # directory has an exceptionally long name it may be spread over multiple
+    # blocks.  The trick is that we don't want any additional blocks because
+    # that will confuse tar and it will report that the archive is damaged. 
+    # So start with one block and go up to an arbitrarily picked limit of 10
+    # blocks (I've been unable to make a test tarball that needed more than 3
+    # blocks) and see if tar succeeds in listing a file.
+    1.upto(10) do |numblocks|
+      tarblocks = File.read(package_file, 512*numblocks)
+      # Open3.popen3("#{find_tar} -tf - #{@@taroptions}") do |stdin, stdout, stderr|
+      #   stdin.write(tarblocks)
+      #   stdin.close
+      #   toplevel = stdout.read
+      # end
+      # Unfortunately popen3 doesn't provide a mechanism for determining the
+      # success or failure of the command until ruby 1.9.  ($? is never
+      # accurately set for popen3, the mechanism in ruby 1.9 for getting the
+      # exit status for popen3 is unique to popen3.)  So we're left with this,
+      # which it rather Unix-specific.
+      IO.popen("#{find_tar} -tf - #{@@taroptions} 2> /dev/null", 'r+') do |pipe|
+        pipe.write(tarblocks)
+        pipe.close_write
+        toplevel = pipe.read
+      end
+      if $?.success?
+        break
+      else
+        toplevel = nil
+      end
     end
-    if !$?.success?
+    if toplevel.nil?
       raise "Error reading top level directory from #{package_file}"
     end
+    toplevel.chomp!
     # Strip off the trailing slash
     toplevel.sub!(Regexp.new("#{File::SEPARATOR}$"), '')
     if toplevel.include?(File::SEPARATOR)
@@ -1501,6 +1527,7 @@ class Tpkg
             end
             stderr_first_line = stderr.gets
           end
+          # FIXME: popen3 doesn't set $?
           if !$?.success?
             # Ignore 'no matching packages', raise anything else
             if stderr_first_line != "Error: No matching Packages to list\n"
@@ -1538,6 +1565,7 @@ class Tpkg
           end
           stderr_first_line = stderr.gets
         end
+        # FIXME: popen3 doesn't set $?
         if !$?.success?
           # Ignore 'no matching packages', raise anything else
           if stderr_first_line !~ 'No packages found matching'
@@ -2541,6 +2569,10 @@ class Tpkg
     if (metadata[:files][:file_defaults][:posix][:group] rescue nil)
       default_gid = Tpkg::lookup_gid(metadata[:files][:file_defaults][:posix][:group])
     end
+    # FIXME: Default file permissions aren't likely to be generally useful
+    # since different classes of files often require different permissions.
+    # I.e. executables should be 0555, links 0777, everything else 0444.
+    # Something more like a umask would probably be more generally useful.
     if (metadata[:files][:file_defaults][:posix][:perms] rescue nil)
       default_perms = metadata[:files][:file_defaults][:posix][:perms]
     end
@@ -2560,28 +2592,39 @@ class Tpkg
       default_dir_perms = metadata[:files][:dir_defaults][:posix][:perms]
     end
     
-    # FIXME: attempt lchown/lchmod on symlinks
     root_dir = File.join(workdir, 'tpkg', 'root')
     reloc_dir = File.join(workdir, 'tpkg', 'reloc')
     Find.find(*Tpkg::get_package_toplevels(File.join(workdir, 'tpkg'))) do |f|
       begin
-        if File.file?(f) && !File.symlink?(f)
+        if File.symlink?(f)
+          begin
+            File.lchown(default_uid, default_gid, f)
+          rescue NotImplementedError
+          end
+        elsif File.file?(f)
           File.chown(default_uid, default_gid, f)
-        elsif File.directory?(f) && !File.symlink?(f)
+        elsif File.directory?(f)
           File.chown(default_dir_uid, default_dir_gid, f)
         end
       rescue Errno::EPERM
         raise if Process.euid == 0
       end
-      if File.file?(f) && !File.symlink?(f)
+      if File.symlink?(f)
+        if default_perms
+          begin
+            File.lchmod(default_perms, f)
+          rescue NotImplementedError
+          end
+        end
+      elsif File.file?(f)
         if default_perms
           File.chmod(default_perms, f)
         end
-      elsif File.directory?(f) && !File.symlink?(f)
+      elsif File.directory?(f)
         File.chmod(default_dir_perms, f)
       end
     end
-
+    
     # Reset the permission/ownership of the conflicting files as how they were before.
     # This needs to be done after the default permission/ownership is applied, but before
     # the handling of ownership/permissions on specific files
@@ -2619,7 +2662,10 @@ class Tpkg
             if !File.symlink?(working_path)
               File.chown(uid, gid, working_path)
             else
-              # FIXME: attempt lchown
+              begin
+                File.lchown(uid, gid, working_path)
+              rescue NotImplementedError
+              end
             end
           rescue Errno::EPERM
             raise if Process.euid == 0
@@ -2630,7 +2676,10 @@ class Tpkg
           if !File.symlink?(working_path)
             File.chmod(perms, working_path)
           else
-            # FIXME: attempt lchmod
+            begin
+              File.lchmod(perms, working_path)
+            rescue NotImplementedError
+            end
           end
         end
       end
@@ -4581,8 +4630,7 @@ class Tpkg
   def stub_native_pkg(pkg)
     # gather all of the native dependencies
     native_deps = pkg[:metadata].get_native_deps
-    
-    return if native_deps.nil? or native_deps.empty?
+    return if native_deps.empty?
     
     if Tpkg::get_os =~ /RedHat|CentOS|Fedora/
       rpm = create_rpm("stub_for_#{pkg[:metadata][:name]}", native_deps)
@@ -4604,7 +4652,7 @@ class Tpkg
   def remove_native_stub_pkg(pkg)
     # Don't have to do anything if this package has no native dependencies
     native_deps = pkg[:metadata].get_native_deps
-    return if native_deps.nil? or native_deps.empty?
+    return if native_deps.empty?
     
     # the convention is that stub package is named as "stub_for_pkgname"
     stub_pkg_name = "stub_for_#{pkg[:metadata][:name]}"

data/lib/tpkg/metadata.rb

@@ -230,7 +230,8 @@ end
 # is that you can give it a metadata file of any format, such as yaml or xml,
 # and it will provide you a uniform interface for accessing/dealing with the metadata.
 class Metadata
-  attr_accessor :source, :file_path
+  attr_reader :text, :format, :file
+  attr_accessor :source
   REQUIRED_FIELDS = [:name, :version, :maintainer, :description]
 
   # Cleans up a string to make it suitable for use in a filename
@@ -247,7 +248,7 @@ class Metadata
       if metadata_text =~ /^:?name:(.+)/
         name = $1.strip
         metadata[name] ||= []
-        metadata[name] << Metadata.new(metadata_text,'yml', source)
+        metadata[name] << Metadata.new(metadata_text,'yml', nil, source)
       end
     end
     return metadata
@@ -258,26 +259,31 @@ class Metadata
   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')
-      metadata.file_path = File.join(dir, 'tpkg.yml')
+      metadata = Metadata.new(File.read(File.join(dir, 'tpkg.yml')),
+                              'yml',
+                              File.join(dir, 'tpkg.yml'))
     elsif File.exists?(File.join(dir, 'tpkg.xml'))
-      metadata = Metadata.new(File.read(File.join(dir, 'tpkg.xml')), 'xml')
-      metadata.file_path = File.join(dir, 'tpkg.xml')
+      metadata = Metadata.new(File.read(File.join(dir, 'tpkg.xml')),
+                              'xml',
+                              File.join(dir, 'tpkg.xml'))
     end
     return metadata
   end
 
-  # metadata_text = text representation of the metadata
+  # text = text representation of the metadata
   # format = yml, xml, json, etc.
+  # file = Path to the metadata file that was the source of this metadata
   # source = Source, in the tpkg sense, of the package described by this
   # metadata.  I.e. the filename of an individual package or a directory or
   # URL containing multiple packages and a metadata.yml file.  Used by tpkg to
   # report on how many packages are available from various sources.
-  def initialize(metadata_text, format, source=nil)
-    @hash = nil
-    @metadata_text = metadata_text
+  def initialize(text, format, file=nil, source=nil)
+    @text = text
+    # FIXME: should define enum of supported formats and reject others
     @format = format
+    @file = file
     @source = source
+    @hash = nil
   end
 
   def [](key)
@@ -287,16 +293,16 @@ class Metadata
   def []=(key,value)
     to_hash[key]=value
   end
-
+  
   def to_hash
     if @hash  
       return @hash 
     end
-
+    
     if @format == 'yml'
-      hash = YAML::load(@metadata_text)
+      hash = YAML::load(@text)
       @hash = hash.with_indifferent_access
-
+      
       # We need this for backward compatibility. With xml, we specify
       # native dependency as type: :native rather then native: true
       @hash[:dependencies].each do | dep |
@@ -308,7 +314,7 @@ 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
@@ -325,60 +331,55 @@ class Metadata
           file[:posix][:perms] = "#{file[:posix][:perms]}".oct
         end
       end if @hash[:files] && @hash[:files][:files]
-    else
+    elsif @format == 'xml'
       @hash = metadata_xml_to_hash.with_indifferent_access
+    else
+      raise "Unknown metadata format"
     end
-    return @hash
+    @hash
   end
-
+  
   # 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")
+  # The file will be saved as tpkg.yml, even if originally loaded as XML.
+  def write(dir)
+    File.open(File.join(dir, "tpkg.yml"), "w") do |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)
     end
-    file.close
   end
-
+  
   # Add tpkg_version to the existing tpkg.xml or tpkg.yml file
   def add_tpkg_version(version)
-    begin
-      if @format == 'xml'
-        metadata_xml = REXML::Document.new(@metadata_text)
-        if metadata_xml.root.elements["tpkg_version"] && (tpkg_version = metadata_xml.root.elements["tpkg_version"].text) != Tpkg::VERSION
-          warn "Warning: tpkg_version is specified as #{tpkg_version}, which doesn't match with the actual tpkg version being used (#{Tpkg::VERSION})."
-        elsif !metadata_xml.root.elements["tpkg_version"]
-          tpkg_version_ele = REXML::Element.new("tpkg_version")
-          tpkg_version_ele.text = Tpkg::VERSION
+    if self[:tpkg_version]
+      if self[:tpkg_version] != version
+        warn "Warning: tpkg_version is specified as #{self[:tpkg_version]}, which doesn't match with the actual tpkg version being used (#{version})."
+      end
+    else
+      # Add to in-memory data
+      self[:tpkg_version] = version
+      # Update the metadata source file (if known)
+      if @file
+        if @format == 'yml'
+          File.open(@file, 'a') do |file|
+            file.puts "tpkg_version: #{version}"
+          end 
+        elsif @format == 'xml'
+          metadata_xml = REXML::Document.new(@text)
+          tpkg_version_ele = REXML::Element.new('tpkg_version')
+          tpkg_version_ele.text = version
           metadata_xml.root.add_element(tpkg_version_ele)  
-          File.open(@file_path, 'w') do |file|
+          File.open(@file, 'w') do |file|
             metadata_xml.write(file)
           end
+        else
+          raise "Unknown metadata format"
         end
-      elsif @format == 'yml'
-        if (tpkg_version = to_hash[:tpkg_version]) && tpkg_version != Tpkg::VERSION
-          warn "Warning: tpkg_version is specified as #{tpkg_version}, which doesn't match with the actual tpkg version being used (#{Tpkg::VERSION})."
-        elsif !tpkg_version
-          File.open(@file_path, 'a') do |file|
-            file.puts "tpkg_version: #{Tpkg::VERSION}"
-          end 
-        end
-      else
-        raise "Unknown metadata format"
       end
-    rescue Errno::EACCES => e
-      warn "Warning: Failed to insert tpkg_version into tpkg.(xml|yml)."
-      puts e
-    end 
+    end
   end
-
+  
   def generate_package_filename
     name = to_hash[:name]
     version = to_hash[:version]
@@ -445,7 +446,7 @@ class Metadata
         warn "Warning: unable to validate metadata because #{schema_file} does not exist"
         return
       end 
-      errors = verify_yaml(schema_file, @metadata_text)
+      errors = verify_yaml(schema_file, @text)
     elsif @format == 'xml'
       # TODO: use DTD to validate XML
       errors = verify_required_fields
@@ -464,12 +465,14 @@ class Metadata
   # Verify the yaml text against the given schema
   # Return array of errors (if there are any)
   def verify_yaml(schema, yaml_text)
-    schema = Kwalify::Yaml.load_file(schema)
-
-    ## create validator
-    validator = Kwalify::Validator.new(schema.with_indifferent_access)
-    ## validate
-    errors = validator.validate(YAML::load(yaml_text).with_indifferent_access)
+    errors = nil
+    # Kwalify generates lots of warnings, silence it
+    Silently.silently do
+      schema = Kwalify::Yaml.load_file(schema)
+      validator = Kwalify::Validator.new(schema.with_indifferent_access)
+      errors = validator.validate(YAML::load(yaml_text).with_indifferent_access)
+    end
+    errors
   end
 
   # Once we implement validating the XML using the DTD, we won't need
@@ -491,7 +494,7 @@ class Metadata
     return if @format != "xml"
 
     metadata_hash = {}
-    metadata_xml = REXML::Document.new(@metadata_text)
+    metadata_xml = REXML::Document.new(@text)
 
     if metadata_xml.root.attributes['filename'] # && !metadata_xml.root.attributes['filename'].empty?
       metadata_hash[:filename] = metadata_xml.root.attributes['filename'] 
@@ -719,12 +722,13 @@ class Metadata
 
     return metadata_hash
   end
-
+  
   def get_native_deps
-    dependencies = to_hash[:dependencies]
-    return nil if dependencies.nil? or dependencies.empty?
-
-    return dependencies.select{|dep| dep[:type] == :native}
+    native_deps = []
+    if self[:dependencies]
+      native_deps = self[:dependencies].select{|dep| dep[:type] == :native}
+    end
+    native_deps
   end
 end
 
@@ -749,10 +753,10 @@ class FileMetadata < Metadata
     end
 
     if @format == 'bin'
-      hash = Marshal::load(@metadata_text)
+      hash = Marshal::load(@text)
       @hash = hash.with_indifferent_access
     elsif @format == 'yml'
-      hash = YAML::load(@metadata_text)
+      hash = YAML::load(@text)
       @hash = hash.with_indifferent_access
     elsif @format == 'xml'
       @hash = file_metadata_xml_to_hash
@@ -765,7 +769,7 @@ class FileMetadata < Metadata
 
     file_metadata_hash = {}
     files = []
-    file_metadata_xml = REXML::Document.new(@metadata_text)
+    file_metadata_xml = REXML::Document.new(@text)
     file_metadata_hash[:package_file] = file_metadata_xml.root.attributes['package_file']
     file_metadata_xml.elements.each("files/file") do | file_ele |
       file = {}

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: tpkg
 version: !ruby/object:Gem::Version 
-  hash: 3
-  prerelease: 
+  hash: 1
+  prerelease: false
   segments: 
   - 2
   - 2
-  - 2
-  version: 2.2.2
+  - 3
+  version: 2.2.3
 platform: ruby
 authors: 
 - Darren Dao
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-14 00:00:00 -08:00
+date: 2011-02-20 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -133,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: tpkg
-rubygems_version: 1.5.0
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: tpkg Application Packaging & Deployment