tpkg 2.2.4 → 2.3.0

data/bin/tpkg_xml_to_yml

@@ -1,12 +1,14 @@
 #!/usr/bin/ruby -w
 ##############################################################################
 # tpkg package management system
-# Copyright 2009, 2010, 2011 AT&T Interactive
 # License: MIT (http://www.opensource.org/licenses/mit-license.php)
 ##############################################################################
 
-# Ensure we can find tpkg.rb
-$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+# When run from the source repository or from an unpacked copy of the
+# distribution we want to find the local library, even if there's a copy
+# installed on the system.  The installed copy is likely older, and the API
+# may be out of sync with this executable.
+$:.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
 
 # This script expects one argument, which is the tpkg.xml file
 # that you want to convert to yml format.

data/lib/tpkg.rb

@@ -1,6 +1,5 @@
 ##############################################################################
 # tpkg package management system
-# Copyright 2009, 2010, 2011 AT&T Interactive
 # License: MIT (http://www.opensource.org/licenses/mit-license.php)
 ##############################################################################
 
@@ -20,27 +19,30 @@ Silently.silently do
     require 'facter'
   end
   require 'digest/sha2'    # Digest::SHA256#hexdigest, etc.
-  require 'uri'            # URI
-  require 'net/http'       # Net::HTTP
-  require 'net/https'      # Net::HTTP#use_ssl, etc.
-  require 'time'           # Time#httpdate
-  require 'rexml/document' # REXML::Document
+  require 'etc'            # Etc.getpwnam, getgrnam
   require 'fileutils'      # FileUtils.cp, rm, etc.
-  require 'tempfile'       # Tempfile
   require 'find'           # Find
-  require 'etc'            # Etc.getpwnam, getgrnam
+  require 'net/http'       # Net::HTTP
+  require 'net/https'      # Net::HTTP#use_ssl, etc.
   require 'openssl'        # OpenSSL
   require 'open3'          # Open3
   require 'set'            # Enumerable#to_set
+  require 'rexml/document' # REXML::Document
+  require 'stringio'       # StringIO
+  require 'tempfile'       # Tempfile
+  require 'time'           # Time#httpdate
+  require 'uri'            # URI
   require 'yaml'           # YAML
 end
-require 'tpkg/versiontype' # Version
 require 'tpkg/deployer'
 require 'tpkg/metadata'
+require 'tpkg/versiontype' # Version
+
+OpenSSLCipherError = OpenSSL::Cipher.const_defined?(:CipherError) ? OpenSSL::Cipher::CipherError : OpenSSL::CipherError
 
 class Tpkg
   
-  VERSION = '2.2.4'
+  VERSION = '2.3.0'
 
   GENERIC_ERR = 1  
   POSTINSTALL_ERR = 2
@@ -82,17 +84,40 @@ class Tpkg
         if !ENV['PATH']
           raise "tpkg cannot run because the PATH env variable is not set."
         end
-        ENV['PATH'].split(':').each do |path|
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
           TARNAMES.each do |tarname|
-            if File.executable?(File.join(path, tarname))
-              IO.popen("#{File.join(path, tarname)} --version 2>/dev/null") do |pipe|
-                pipe.each_line do |line|
+            tarpath = nil
+            if RUBY_PLATFORM == 'i386-mingw32'
+              # Turns out that File.join is fairly pointless, at least as far
+              # as Windows compatibility.  Ruby always uses '/' as the path
+              # separator, even on Windows.  I.e. File::SEPARATOR is '/' on
+              # Windows (yes, really!).  File::ALT_SEPARATOR is '\' but
+              # File.join and its ilk will never use it.  The forward slash
+              # works fine for API-level file operations, Windows will accept
+              # either forward slashes or backslashes at the API level. But
+              # you can't execute a path with forward slashes, apparently due
+              # to some backwards-compatibility thing with cmd.exe. Sigh.
+              tarpath = path.gsub('/', '\\') + '\\' + tarname + '.exe'
+            else
+              tarpath = File.join(path, tarname)
+            end
+            if File.executable?(tarpath)
+              # Particularly on Windows it is possible that the path contains
+              # spaces.  I.e. C:\Program Files (x86)\GnuWin32\bin\bsdtar.exe
+              # It looks like that needs to be wrapped in quotes to execute
+              # properly.
+              if tarpath.include?(' ')
+                tarpath = '"' + tarpath + '"'
+              end
+              Open3.popen3("#{tarpath} --version") do |stdin, stdout, stderr|
+                stdin.close
+                stdout.each_line do |line|
                   if line.include?('GNU tar')
                     @@tarinfo[:type] = 'gnu'
-                    @@tar = File.join(path, tarname)
+                    @@tar = tarpath
                   elsif line.include?('bsdtar')
                     @@tarinfo[:type] = 'bsd'
-                    @@tar = File.join(path, tarname)
+                    @@tar = tarpath
                   end
                   if line =~ /(?:(\d+)\.)?(?:(\d+)\.)?(\*|\d+)/
                     @@tarinfo[:version] = [$1, $2, $3].compact.join(".")
@@ -103,7 +128,6 @@ class Tpkg
             end
           end
         end
-        # Raise an exception if we didn't find a suitable tar
         raise "Unable to find GNU tar or bsdtar in PATH"
       end
     end
@@ -163,10 +187,13 @@ class Tpkg
       File.chown(st.uid, st.gid, tmpfile.path)
     rescue Errno::EPERM
       raise if Process.euid == 0
+    rescue Errno::EINVAL
+      raise if RUBY_PLATFORM != 'i386-cygwin'
     end
     tmpfile.write(MAGIC)
     tmpfile.write(salt)
-    tmpfile.write(c.update(IO.read(filename)) + c.final)
+    content = IO.read(filename)
+    tmpfile.write(c.update(content) + c.final) unless content.empty?
     tmpfile.close
     File.rename(tmpfile.path, filename)
   end
@@ -207,8 +234,11 @@ class Tpkg
       File.chown(st.uid, st.gid, tmpfile.path)
     rescue Errno::EPERM
       raise if Process.euid == 0
+    rescue Errno::EINVAL
+      raise if RUBY_PLATFORM != 'i386-cygwin'
     end
-    tmpfile.write(c.update(file.read) + c.final)
+    content = file.read
+    tmpfile.write(c.update(content) + c.final) unless content.empty?
     tmpfile.close
     File.rename(tmpfile.path, filename)
   end
@@ -433,22 +463,12 @@ class Tpkg
     # 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?
+      Open3.popen3("#{find_tar} -tf - #{@@taroptions}") do |stdin, stdout, stderr|
+        stdin.write(tarblocks)
+        stdin.close
+        toplevel = stdout.read
+      end
+      if !toplevel.empty?
         break
       else
         toplevel = nil
@@ -711,6 +731,13 @@ class Tpkg
         # Extract 7 from 7.1-RELEASE, for example
         fbver = Facter['operatingsystemrelease'].value
         osver = fbver.split('.').first
+      elsif Facter['operatingsystem'] &&
+            Facter['operatingsystem'].value == 'windows'
+        # Extract 6.1 from 6.1.7601, for example
+        # That seems like the right level to split at
+        # based on http://en.wikipedia.org/wiki/Ver_(command)
+        winver = Facter['operatingsystemrelease'].value
+        osver = winver.split('.')[0,2].join('.')
       elsif Facter['operatingsystemrelease'] &&
             Facter['operatingsystemrelease'].value &&
             !Facter['operatingsystemrelease'].value.empty?
@@ -772,6 +799,14 @@ class Tpkg
           same_min_ver_req = true
         end
       end
+      if req[:version_greater_than]
+        pkgver = Version.new(metadata[:version])
+        reqver = Version.new(req[:version_greater_than])
+        if pkgver <= reqver
+          puts "Package fails version_greater_than (#{pkgver} <= #{reqver})" if @@debug
+          result = false
+        end
+      end
       if req[:maximum_version]
         pkgver = Version.new(metadata[:version])
         reqver = Version.new(req[:maximum_version])
@@ -782,6 +817,14 @@ class Tpkg
           same_max_ver_req = true
         end
       end
+      if req[:version_less_than]
+        pkgver = Version.new(metadata[:version])
+        reqver = Version.new(req[:version_less_than])
+        if pkgver >= reqver
+          puts "Package fails version_less_than (#{pkgver} >= #{reqver})" if @@debug
+          result = false
+        end
+      end
       if same_min_ver_req && req[:minimum_package_version]
         pkgver = Version.new(metadata[:package_version])
         reqver = Version.new(req[:minimum_package_version])
@@ -790,6 +833,14 @@ class Tpkg
           result = false
         end
       end
+      if same_min_ver_req && req[:package_version_greater_than]
+        pkgver = Version.new(metadata[:package_version])
+        reqver = Version.new(req[:package_version_greater_than])
+        if pkgver <= reqver
+          puts "Package fails package_version_greater_than (#{pkgver} <= #{reqver})" if @@debug
+          result = false
+        end
+      end
       if same_max_ver_req && req[:maximum_package_version]
         pkgver = Version.new(metadata[:package_version])
         reqver = Version.new(req[:maximum_package_version])
@@ -798,6 +849,14 @@ class Tpkg
           result = false
         end
       end
+      if same_max_ver_req && req[:package_version_less_than]
+        pkgver = Version.new(metadata[:package_version])
+        reqver = Version.new(req[:package_version_less_than])
+        if pkgver >= reqver
+          puts "Package fails package_version_less_than (#{pkgver} >= #{reqver})" if @@debug
+          result = false
+        end
+      end
       # The empty? check ensures that a package with no operatingsystem
       # field matches all clients.
       if metadata[:operatingsystem] &&
@@ -1005,37 +1064,100 @@ class Tpkg
   # foo
   # foo=1.0
   # foo=1.0=1
-  # foo-1.0-1.tpkg	
-  def self.parse_request(request, installed_dir = nil)
-    # FIXME: Add support for <, <=, >, >=
+  # foo>1.0
+  # foo<=1.0=2
+  # foo<=1.0>=3
+  # foo=1.0<=6
+  # foo-1.0-1.tpkg
+  def self.parse_request(request)
     req = {}
-    parts = request.split('=')
-
+    # Note that the ordering in the regex is important.  <= and >= have to
+    # appear before others so that they match rather than two separate matches
+    # for the '>' and '=' characters.  I.e. '1>=2'.split(/(>=|>|=)/) ==
+    # ['1', '>=', '2'] but '1>=2'.split(/(>|=|>=)/) == ['1', '>', '=', '2']
+    parts = request.split(/(<=|>=|<|>|=)/)
+    
     # upgrade/remove/query options could take package filenames
     # We're assuming that the filename ends in .tpkg and has a version number that starts
     # with a digit. For example: foo-1.0.tpkg, foo-bar-1.0-1.tpkg
     if request =~ /\.tpkg$/
       req = {:filename => request, :name => request.split(/-\d/)[0]}
-    elsif parts.length > 2 && parts[-2] =~ /^[\d\.]/ && parts[-1] =~ /^[\d\.]/
-      package_version = parts.pop
-      version = parts.pop
-      req[:name] = parts.join('-')
-      req[:minimum_version] = version
-      req[:maximum_version] = version
-      req[:minimum_package_version] = package_version
-      req[:maximum_package_version] = package_version
-    elsif parts.length > 1 && parts[-1] =~ /^[\d\.]/
-      version = parts.pop
-      req[:name] = parts.join('-')
-      req[:minimum_version] = version
-      req[:maximum_version] = version
     else
-      req[:name] = parts.join('-')
+      if parts.length > 4 && parts[-3] =~ /^[\d\.]/ && parts[-1] =~ /^[\d\.]/
+        package_version = parts.pop
+        package_version_sign = parts.pop
+        version = parts.pop
+        version_sign = parts.pop
+        
+        case version_sign
+        when '<'
+          # E.g. foo<1.0
+          req[:version_less_than] = version
+        when '<='
+          # E.g. foo<=1.0
+          req[:maximum_version] = version
+        when '='
+          # E.g. foo=1.0
+          req[:minimum_version] = version
+          req[:maximum_version] = version
+        when '>'
+          # E.g. foo>1.0
+          req[:version_greater_than] = version
+        when '>='
+          # E.g. foo>=1.0
+          req[:minimum_version] = version
+        end
+        
+        case package_version_sign
+        when '<'
+          # E.g. foo=1.0<2.0
+          req[:package_version_less_than] = package_version
+        when '<='
+          # E.g. foo=1.0<=2.0
+          req[:maximum_package_version] = package_version
+        when '='
+          # E.g. foo=1.0=2.0
+          req[:minimum_package_version] = package_version
+          req[:maximum_package_version] = package_version
+        when '>'
+          # E.g. foo=1.0>2.0
+          req[:package_version_greater_than] = package_version
+        when '>='
+          # E.g. foo=1.0>=2.0
+          req[:minimum_package_version] = package_version
+        end
+      elsif parts.length > 1 && parts[-1] =~ /^[\d\.]/
+        version = parts.pop
+        version_sign = parts.pop
+        if version_sign == '=' && version.include?('*')
+          req[:allowed_versions] = version
+        else
+          case version_sign
+          when '<'
+            # E.g. foo<1.0
+            req[:version_less_than] = version
+          when '<='
+            # E.g. foo<=1.0
+            req[:maximum_version] = version
+          when '='
+            # E.g. foo=1.0
+            req[:minimum_version] = version
+            req[:maximum_version] = version
+          when '>'
+            # E.g. foo>1.0
+            req[:version_greater_than] = version
+          when '>='
+            # E.g. foo>=1.0
+            req[:minimum_version] = version
+          end
+        end
+      end
+      req[:name] = parts.join('')
     end
     req[:type] = :tpkg
     req
   end
-
+  
   # deploy_options is used for configuration the deployer. It is a map of option_names => option_values. Possible
   # options are: use-ssh-key, deploy-as, worker-count, abort-on-fail
   #
@@ -1355,17 +1477,25 @@ class Tpkg
           name = metadata_yml[:name]
           metadata[name] = [] if !metadata[name]
           metadata[name] << metadata_yml
-        elsif File.directory?(source)
-          if !File.exists?(File.join(source, 'metadata.yml'))
-            warn "Warning: the source directory #{source} has no metadata.yml file. Try running tpkg -x #{source} first."
-            next
+        elsif source[0,1] == File::SEPARATOR || File.directory?(source)
+          if File.directory?(source)
+            if !File.exists?(File.join(source, 'metadata.yml'))
+              warn "Source directory #{source} has no metadata.yml file. Try running tpkg -x #{source} first."
+              next
+            end
+            metadata_contents = File.read(File.join(source, 'metadata.yml'))
+            Metadata::get_pkgs_metadata_from_yml_doc(metadata_contents, metadata, source)
+          else
+            warn "Source directory #{source} does not exist, skipping."
           end
-          
-          metadata_contents = File.read(File.join(source, 'metadata.yml'))
-          Metadata::get_pkgs_metadata_from_yml_doc(metadata_contents, metadata, source)
         else
           uri = http = localdate = remotedate = localdir = localpath = nil
           
+          if !URI.parse(source).absolute?
+            warn "Source #{source} is not a file, directory, or absolute URI, skipping"
+            next
+          end
+          
           uri = URI.join(source, 'metadata.yml')
           http = gethttp(uri)
           
@@ -1880,6 +2010,10 @@ class Tpkg
     end
     pkgs
   end
+  
+  # Returns an array (possibly empty) of the packages that meet the given
+  # requirement.  If the given requirement is nil or not specified then all
+  # installed packages are returned.
   def installed_packages_that_meet_requirement(req=nil)
     pkgs = []
     if req && req[:type] == :native
@@ -2334,6 +2468,7 @@ class Tpkg
       File.chmod(0644, tmpfile.path)
       File.rename(tmpfile.path, localpath)
     rescue
+      # FIXME: should include original exception message to help user debug
       raise "Unable to download and/or verify the package."
     end
 
@@ -2620,6 +2755,8 @@ class Tpkg
         end
       rescue Errno::EPERM
         raise if Process.euid == 0
+      rescue Errno::EINVAL
+        raise if RUBY_PLATFORM != 'i386-cygwin'
       end
       if File.symlink?(f)
         if default_perms
@@ -2644,7 +2781,13 @@ class Tpkg
       stat = info[:stat]
       file_path = info[:normalized]
       File.chmod(stat.mode, file_path)
-      File.chown(stat.uid, stat.gid, file_path)
+      begin
+        File.chown(stat.uid, stat.gid, file_path)
+      rescue Errno::EPERM
+        raise if Process.euid == 0
+      rescue Errno::EINVAL
+        raise if RUBY_PLATFORM != 'i386-cygwin'
+      end
     end
     
     # Handle any decryption, ownership/permissions, and other issues for specific files
@@ -2681,6 +2824,8 @@ class Tpkg
             end
           rescue Errno::EPERM
             raise if Process.euid == 0
+          rescue Errno::EINVAL
+            raise if RUBY_PLATFORM != 'i386-cygwin'
           end
         end
         if tpkgfile[:posix][:perms]
@@ -2710,7 +2855,7 @@ class Tpkg
             begin
               Tpkg::decrypt(metadata[:name], working_path, options[:passphrase], *([tpkgfile[:encrypt][:algorithm]].compact))
               break
-            rescue OpenSSL::CipherError
+            rescue OpenSSLCipherError
               @@passphrase = nil
               if i == 3
                 raise "Incorrect passphrase."
@@ -2937,6 +3082,8 @@ class Tpkg
         else
           raise e
         end
+      rescue Errno::EINVAL
+        raise if RUBY_PLATFORM != 'i386-cygwin'
       end
       # Insert the contents of the current crontab file
       File.open(destination[:file]) { |file| tmpfile.write(file.read) }
@@ -3029,6 +3176,8 @@ class Tpkg
         else
           raise
         end
+      rescue Errno::EINVAL
+        raise if RUBY_PLATFORM != 'i386-cygwin'
       end
       # Remove section associated with this package
       skip = false
@@ -3267,7 +3416,8 @@ class Tpkg
   #   requirements << { :name => 'bar' }, packages['bar'] = { :source => 'http://server/pkgs/bar-2.3.pkg' }
   #   requirements << { :name => 'blat', :minimum_version => '0.5', :maximum_version => '0.5' }, packages['blat'] populated with available packages meeting that requirement
   # Note: the requirements and packages arguments are modified by this method
-  def parse_requests(requests, requirements, packages)
+  # FIXME: This method has a terrible API, can we fix it?
+  def parse_requests(requests, requirements, packages, options = {})
     newreqs = []
     
     requests.each do |request|
@@ -3313,14 +3463,16 @@ class Tpkg
       else # basic package specs ('foo' or 'foo=1.0')
         puts "parse_requests request looks like package spec" if @@debug
 
-        # Tpkg::parse_request is a class method and doesn't know where packages are installed.
-        # So we have to tell it ourselves.
-        req = Tpkg::parse_request(request, @installed_directory)
+        req = Tpkg::parse_request(request)
         newreqs << req
 
         puts "Initializing the list of possible packages for this req" if @@debug
         if !packages[req[:name]]
-          packages[req[:name]] = available_packages_that_meet_requirement(req)
+          if !options[:installed_only]
+            packages[req[:name]] = available_packages_that_meet_requirement(req)
+          else
+            packages[req[:name]] = installed_packages_that_meet_requirement(req)
+          end
         end
       end
     end
@@ -3657,7 +3809,7 @@ class Tpkg
             puts "Running '/opt/local/bin/port install #{pkgname}' to install native package" if @@debug
             system("/opt/local/bin/port install #{pkgname}")
           else
-            # Fink support would be nice
+            # Fink, Homebrew support would be nice
             raise "No supported native package tool available on #{Tpkg::get_os}"
           end
         else
@@ -3900,8 +4052,8 @@ class Tpkg
         end
 
         if prompt_for_conflicting_files(pkgfile, CHECK_UPGRADE)
-          # If the old and new packages have overlapping externals flag them
-          # to be skipped so that the external isn't removed and then
+          # If the old and new packages have overlapping externals then flag
+          # them to be skipped so that the external isn't removed and then
           # immediately re-added
           oldpkgs = installed_packages_that_meet_requirement({:name => pkg[:metadata][:name], :type => :tpkg})
           externals_to_skip = []
@@ -3909,7 +4061,7 @@ class Tpkg
             if oldpkgs.all? {|oldpkg| oldpkg[:metadata][:externals] && oldpkg[:metadata][:externals].include?(external)}
               externals_to_skip << external
             end
-          end if pkg[:metadata][:externals]
+          end if pkg[:metadata][:externals] && !oldpkgs.empty?
 
           # Remove the old package if we haven't done so
           unless oldpkgs.nil? or oldpkgs.empty? or removed_pkgs.include?(pkg[:metadata][:name])
@@ -3969,7 +4121,7 @@ class Tpkg
       requests.uniq! if requests.is_a?(Array)
       packages_to_remove = []
       requests.each do |request|
-        req = Tpkg::parse_request(request, @installed_directory)
+        req = Tpkg::parse_request(request)
         packages_to_remove.concat(installed_packages_that_meet_requirement(req))
       end
     else
@@ -4063,7 +4215,7 @@ class Tpkg
     end
     
     # Stop the services if there's init script
-    if !options[:upgrade]
+    if !options[:upgrade] && !options[:skip_remove_stop]
       packages_to_remove.each do |pkg|
        init_scripts_metadata = init_scripts(pkg[:metadata])
        if init_scripts_metadata && !init_scripts_metadata.empty?
@@ -4539,6 +4691,8 @@ class Tpkg
     original_dir = Dir.pwd
     
     workdir = Tpkg::tempdir("tpkg_download")
+    # FIXME: should use begin/ensure to make sure we chdir back when done
+    # But I also wonder why we have to chdir at all...
     Dir.chdir(workdir)
     parse_requests(requests, requirements, packages)
     packages = packages.values.flatten