rpm 0.0.2 → 0.0.3

data/lib/rpm/gem_version.rb

@@ -3,5 +3,5 @@
 # is because it conflicts with the version.rb class
 module RPM
   PKG_NAME = "ruby-rpm"
-  GEM_VERSION = "0.0.2"
+  GEM_VERSION = "0.0.3"
 end

data/lib/rpm/match_iterator.rb

@@ -7,7 +7,7 @@ module RPM
 
     # @visibility private
     def self.release(ptr)
-      RPM::FFI.rpmdbFreeIterator(ptr)
+      RPM::C.rpmdbFreeIterator(ptr)
     end
 
     # Creates a managed MatchIterator from a raw pointer
@@ -27,7 +27,7 @@ module RPM
     end
 
     def next_iterator
-      pkg_ptr = RPM::FFI.rpmdbNextIterator(@ptr)
+      pkg_ptr = RPM::C.rpmdbNextIterator(@ptr)
         if !pkg_ptr.null?
           return RPM::Package.new(pkg_ptr)
         end
@@ -37,11 +37,11 @@ module RPM
     # @ return header join key for current position of rpm 
     # database iterator
     def offset
-      RPM::FFI.rpmdbGetIteratorOffset(@ptr)
+      RPM::C.rpmdbGetIteratorOffset(@ptr)
     end
 
     def set_iterator_re(tag, mode, string)
-      ret = RPM::FFI.rpmdbSetIteratorRE(@ptr, tag, mode, string)
+      ret = RPM::C.rpmdbSetIteratorRE(@ptr, tag, mode, string)
       raise "Error when setting regular expression '#{string}'" if ret != 0
       self
     end
@@ -63,7 +63,7 @@ module RPM
     alias :version :set_iterator_version
     
     def get_iterator_count
-      RPM::FFI.rpmdbGetIteratorCount(@ptr)
+      RPM::C.rpmdbGetIteratorCount(@ptr)
     end
 
     alias :count :get_iterator_count

data/lib/rpm/package.rb

@@ -1,4 +1,4 @@
-require 'rpm/ffi'
+require 'rpm/c'
 require 'rpm/file'
 
 module RPM
@@ -23,15 +23,15 @@ module RPM
       if not version.is_a?(RPM::Version)
         raise TypeError, "illegal argument type: version should be RPM::Version"
       end
-      hdr = RPM::FFI.headerNew
-      if RPM::FFI.headerPutString(hdr, :name, name) != 1
+      hdr = RPM::C.headerNew
+      if RPM::C.headerPutString(hdr, :name, name) != 1
         raise "Can't set package name: #{name}"
       end
-      if RPM::FFI.headerPutString(hdr, :version, version.v) != 1
+      if RPM::C.headerPutString(hdr, :version, version.v) != 1
         raise "Can't set package version: #{version.v}"
       end
       if version.e
-        if RPM::FFI.headerPutUint32(hdr, :epoch, version.e) != 1
+        if RPM::C.headerPutUint32(hdr, :epoch, version.e) != 1
           raise "Can't set package epoch: #{version.e}"
         end
       end
@@ -87,7 +87,7 @@ module RPM
     #   pkg.sprintf("%{name}") => "apache2"
     def sprintf(fmt)
       error = ::FFI::MemoryPointer.new(:pointer, 1)
-      val = RPM::FFI.headerFormat(@hdr, fmt, error)
+      val = RPM::C.headerFormat(@hdr, fmt, error)
       raise error.get_pointer(0).read_string if val.null?
       val.read_string
     end
@@ -129,8 +129,8 @@ module RPM
                 grouplist[i],
                 rdevlist[i],
                 modelist[i],
-                flaglist.nil? ? RPM::FFI::FileAttrs[:none] : flaglist[i],
-                statelist.nil? ? RPM::FFI::FileState[:normal] : statelist[i]
+                flaglist.nil? ? RPM::C::FileAttrs[:none] : flaglist[i],
+                statelist.nil? ? RPM::C::FileState[:normal] : statelist[i]
         )
         ret << file
       end
@@ -145,20 +145,20 @@ module RPM
     def dependencies(klass, nametag, versiontag, flagtag)
       deps = []
 
-      nametd = ::FFI::AutoPointer.new(RPM::FFI.rpmtdNew, Package.method(:release_td))
-      versiontd = ::FFI::AutoPointer.new(RPM::FFI.rpmtdNew, Package.method(:release_td))
-      flagtd = ::FFI::AutoPointer.new(RPM::FFI.rpmtdNew, Package.method(:release_td))
+      nametd = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))
+      versiontd = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))
+      flagtd = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))
 
-      min = RPM::FFI::HEADERGET_MINMEM
-      return deps if (RPM::FFI.headerGet(@hdr, nametag, nametd, min) != 1)
-      return deps if (RPM::FFI.headerGet(@hdr, versiontag, versiontd, min) != 1)
-      return deps if (RPM::FFI.headerGet(@hdr, flagtag, flagtd, min) != 1)
+      min = RPM::C::HEADERGET_MINMEM
+      return deps if (RPM::C.headerGet(@hdr, nametag, nametd, min) != 1)
+      return deps if (RPM::C.headerGet(@hdr, versiontag, versiontd, min) != 1)
+      return deps if (RPM::C.headerGet(@hdr, flagtag, flagtd, min) != 1)
 
-      RPM::FFI.rpmtdInit(nametd)
-      while RPM::FFI.rpmtdNext(nametd) != -1
-        deps << klass.new(RPM::FFI.rpmtdGetString(nametd),
-                  RPM::Version.new(RPM::FFI.rpmtdNextString(versiontd)),
-                  RPM::FFI.rpmtdNextUint32(flagtd).read_uint, self)
+      RPM::C.rpmtdInit(nametd)
+      while RPM::C.rpmtdNext(nametd) != -1
+        deps << klass.new(RPM::C.rpmtdGetString(nametd),
+                  RPM::Version.new(RPM::C.rpmtdNextString(versiontd)),
+                  RPM::C.rpmtdNextUint32(flagtd).read_uint, self)
       end
       deps
     end
@@ -175,32 +175,32 @@ module RPM
 
     # @return [Array<RPM::Conflicts>] Conflicts list for this package
     def conflicts
-      dependencies(RPM::conflicts, :conflictsname, :conflictsversion, :conflictsflags)
+      dependencies(RPM::Conflict, :conflictname, :conflictversion, :conflictflags)
     end
 
     # @return [Array<RPM::Obsolete>] Obsoletes list for this package
     def obsoletes
-      dependencies(RPM::Obsoletes, :obsoletename, :obsoleteversion, :obsoleteflags)
+      dependencies(RPM::Obsolete, :obsoletename, :obsoleteversion, :obsoleteflags)
     end
 
     # @return [Array<RPM::Changelog>] changelog of the package as an array 
     def changelog
       entries = []
-      nametd = ::FFI::AutoPointer.new(RPM::FFI.rpmtdNew, Package.method(:release_td))
-      timetd = ::FFI::AutoPointer.new(RPM::FFI.rpmtdNew, Package.method(:release_td))
-      texttd = ::FFI::AutoPointer.new(RPM::FFI.rpmtdNew, Package.method(:release_td))
+      nametd = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))
+      timetd = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))
+      texttd = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))
     
-      min = RPM::FFI::HEADERGET_MINMEM
-      return deps if (RPM::FFI.headerGet(@hdr, :changelogtime, timetd, min) != 1)
-      return deps if (RPM::FFI.headerGet(@hdr, :changelogname, nametd, min) != 1)
-      return deps if (RPM::FFI.headerGet(@hdr, :changelogtext, texttd, min) != 1)
+      min = RPM::C::HEADERGET_MINMEM
+      return deps if (RPM::C.headerGet(@hdr, :changelogtime, timetd, min) != 1)
+      return deps if (RPM::C.headerGet(@hdr, :changelogname, nametd, min) != 1)
+      return deps if (RPM::C.headerGet(@hdr, :changelogtext, texttd, min) != 1)
 
-      RPM::FFI.rpmtdInit(timetd)
-      while RPM::FFI.rpmtdNext(timetd) != -1
+      RPM::C.rpmtdInit(timetd)
+      while RPM::C.rpmtdNext(timetd) != -1
         entry = RPM::ChangeLog.new
-        entry.time = RPM::FFI.rpmtdGetUint32(timetd)
-        entry.name = RPM::FFI.rpmtdNextString(nametd)
-        entry.text = RPM::FFI.rpmtdNextString(texttd)
+        entry.time = RPM::C.rpmtdGetUint32(timetd)
+        entry.name = RPM::C.rpmtdNextString(nametd)
+        entry.text = RPM::C.rpmtdNextString(texttd)
         entries << entry
       end
       entries
@@ -222,14 +222,14 @@ module RPM
     #   The value of the entry
     def [](tag)
       val = nil
-      tagc = ::FFI::AutoPointer.new(RPM::FFI.rpmtdNew, Package.method(:release_td))
+      tagc = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))
 
-      return nil if (RPM::FFI.headerGet(ptr, tag, tagc, 
-                      RPM::FFI::HEADERGET_MINMEM) == 0)
+      return nil if (RPM::C.headerGet(ptr, tag, tagc, 
+                      RPM::C::HEADERGET_MINMEM) == 0)
 
-      type = RPM::FFI.rpmtdType(tagc)
-      count = RPM::FFI.rpmtdCount(tagc)
-      ret_type = RPM::FFI.rpmTagGetReturnType(tag)
+      type = RPM::C.rpmtdType(tagc)
+      count = RPM::C.rpmtdCount(tagc)
+      ret_type = RPM::C.rpmTagGetReturnType(tag)
 
       method_name = case type
         when :int8_type, :char_type, :int16_type, :int32_type, :int64_type then :rpmtdGetNumber
@@ -246,14 +246,14 @@ module RPM
 
       if is_array
         ret = []
-        RPM::FFI.rpmtdInit(tagc)
-        while RPM::FFI.rpmtdNext(tagc) != -1
-          ret << RPM::FFI.send(method_name, tagc)
+        RPM::C.rpmtdInit(tagc)
+        while RPM::C.rpmtdNext(tagc) != -1
+          ret << RPM::C.send(method_name, tagc)
         end
         return ret
       end
       
-      return RPM::FFI.send(method_name, tagc)
+      return RPM::C.send(method_name, tagc)
     end
 
     # @return [String] This package name
@@ -273,7 +273,7 @@ module RPM
       v_ptr = ::FFI::MemoryPointer.new(:pointer, 1)
       r_ptr = ::FFI::MemoryPointer.new(:pointer, 1)
 
-      RPM::FFI.headerNVR(ptr, nil, v_ptr, r_ptr)
+      RPM::C.headerNVR(ptr, nil, v_ptr, r_ptr)
       v = v_ptr.read_pointer.read_string
       r = r_ptr.read_pointer.read_string
       v_ptr.free
@@ -295,43 +295,43 @@ module RPM
       hdr = ::FFI::MemoryPointer.new(:pointer)
       fd = nil
       begin
-        fd = RPM::FFI.Fopen(filename, 'r')
-        if RPM::FFI.Ferror(fd) != 0
-          raise "#{filename} : #{RPM::FFI.Fstrerror(fd)}"
+        fd = RPM::C.Fopen(filename, 'r')
+        if RPM::C.Ferror(fd) != 0
+          raise "#{filename} : #{RPM::C.Fstrerror(fd)}"
         end
         RPM.transaction do |ts|
-          rc = RPM::FFI.rpmReadPackageFile(ts.ptr, fd, filename, hdr)
+          rc = RPM::C.rpmReadPackageFile(ts.ptr, fd, filename, hdr)
         end
       ensure
-        RPM::FFI.Fclose(fd) unless fd.nil?
+        RPM::C.Fclose(fd) unless fd.nil?
       end
       Package.new(hdr.get_pointer(0))
     end
 
     # @visibility private
     def self.release(ptr)
-      RPM::FFI.headerFree(ptr)
+      RPM::C.headerFree(ptr)
     end
 
     # @visibility private
     def self.release_td(ptr)
-      RPM::FFI.rpmtdFree(ptr)
+      RPM::C.rpmtdFree(ptr)
     end
 
     # @visibility private
     def initialize(hdr=nil)
       if hdr.nil?
-        @hdr = ::FFI::AutoPointer.new(RPM::FFI.headerNew, Header.method(:release))
+        @hdr = ::FFI::AutoPointer.new(RPM::C.headerNew, Header.method(:release))
       elsif hdr.is_a?(::FFI::Pointer)
         # ref
-        hdr = RPM::FFI.headerLink(hdr)
+        hdr = RPM::C.headerLink(hdr)
         @hdr = ::FFI::AutoPointer.new(hdr, Package.method(:release))
       else
         raise "Can't initialize header with '#{hdr}'"
       end
     end
 
-    # @return [RPM::FFI::Header] header pointer
+    # @return [RPM::C::Header] header pointer
     # @visibility private
     def ptr
       @hdr

data/lib/rpm/problem.rb

@@ -0,0 +1,71 @@
+
+module RPM
+
+  class Problem
+
+    def self.release(ptr)
+      RPM::C.rpmProblemFree(ptr)
+    end
+
+    # Creates a problem from an existing C pointer, refcounting it
+    # first.
+    # @param [FFI::Pointer] ptr existing C pointer
+    # @return [RPM::Problem] wrapped object
+    def self.from_ptr(ptr)
+      case ptr
+        when FFI::Pointer
+          new(FFI::AutoPointer.new(RPM::C.rpmProblemLink(ptr), Problem.method(:release)))
+        else
+          raise "Can't initialize header with '#{ptr}'"
+      end
+    end
+
+    # Create a problem item. 
+    # @param [RPM::ProblemType] type problem type
+    # @param [String] pkg_nver name-version-edition-release of the related package
+    # @param [String] key key of the related package
+    # @param [String] alt_nver name-version-edition-release of the other related package
+    # @param [String] str generic data string from a problem
+    def self.create(type, pkg_nevr, key, alt_nevr, str, number)
+      ptr = ::FFI::AutoPointer.new(RPM::C.rpmProblemCreate(type, pkg_nevr, key, alt_nevr, str, number), Problem.method(:release))
+      new(ptr)
+    end
+
+    # @visibility private
+    def initialize(ptr)
+      @ptr = ptr
+    end
+
+    # @return [RPM::ProblemType] type of problem (dependency, diskpace etc). 
+    def type
+      RPM::C.rpmProblemGetType(@ptr)
+    end
+
+    # @return [String] filename or python object address of a problem. 
+    def key
+      RPM::C.rpmProblemGetKey(@ptr).read_string
+    end
+
+    # @return [String] a generic data string from a problem. 
+    def str
+      RPM::C.rpmProblemGetStr(@ptr)
+    end
+
+    # @return [String] formatted string representation of a problem
+    def to_s
+      RPM::C.rpmProblemString(@ptr)
+    end
+
+    # @return [Fixnum] compare two problems for equality. 
+    def <=>(other)
+      RPM::C.rpmProblemCompare(@ptr, other.ptr)
+    end
+
+    # @visibility private
+    def ptr
+      @ptr
+    end
+
+  end
+
+end

data/lib/rpm/transaction.rb

@@ -2,26 +2,38 @@ require 'rpm'
 
 module RPM
 
+  CallbackData = Struct.new(:type, :key, :package, :amount, :total) do
+
+
+    def to_s
+      "#{type} #{key} #{package} #{amount} #{total}"
+    end
+  end
+
   class Transaction
 
     def self.release(ptr)
-      RPM::FFI.rpmtsFree(ptr)
+      RPM::C.rpmtsFree(ptr)
     end
 
     def initialize(opts={})
-
+      # http://markmail.org/message/ypsiqxop442p7rzz
+      # The key pointer needs to stay valid during commit 
+      # so we keep a reference to them mapping from
+      # object_id to ruby object.
+      @keys = {}
       opts[:root] ||= '/'
 
-      @ptr = ::FFI::AutoPointer.new(RPM::FFI.rpmtsCreate, Transaction.method(:release))
-      RPM::FFI.rpmtsSetRootDir(@ptr, opts[:root])
+      @ptr = ::FFI::AutoPointer.new(RPM::C.rpmtsCreate, Transaction.method(:release))
+      RPM::C.rpmtsSetRootDir(@ptr, opts[:root])
     end
 
     # @return [RPM::MatchIterator] Creates an iterator for +tag+ and +val+
     def init_iterator(tag, val)
       raise TypeError if (val && !val.is_a?(String))
-      
-      it_ptr = RPM::FFI.rpmtsInitIterator(@ptr, tag.nil? ? 0 : tag, val, 0)
-      
+
+      it_ptr = RPM::C.rpmtsInitIterator(@ptr, tag.nil? ? 0 : tag, val, 0)
+
       raise "Can't init iterator for [#{tag}] -> '#{val}'" if it_ptr.null?
       return MatchIterator.from_ptr(it_ptr)
     end
@@ -30,7 +42,7 @@ module RPM
     def ptr
       @ptr
     end
-    
+
     #
     # @yield [Package] Called for each match
     # @param [Number] key RPM tag key
@@ -63,68 +75,207 @@ module RPM
 
     # Add a install operation to the transaction
     # @param [Package] pkg Package to install
+    # @param [String] key e.g. filename where to install from
     def install(pkg, key)
-      raise TypeError if not pkg.is_a?(RPM::Package)
-      
-      @keys ||= Array.new
-      raise ArgError, "key must be unique" if @keys.include?(key)
-      @keys << key
-      
-      RPM::FFI.rpmtsAddInstallElement(@ptr, pkg.ptr, key.to_s, 0, nil)
-      nil
+      install_element(pkg, key, :upgrade => false)
+    end
+
+    # Add an upgrade operation to the transaction
+    # @param [Package] pkg Package to upgrade
+    # @param [String] key e.g. filename where to install from
+    def upgrade(pkg, key)
+      install_element(pkg, key, :upgrade => true)
+    end
+
+    # Add a delete operation to the transaction
+    # @param [String, Package, Dependency] pkg Package to delete
+    def delete(pkg)
+      iterator = case pkg
+      when Package
+        pkg[:sigmd5] ? each_match(:sigmd5, pkg[:sigmd5]) : each_match(:label, pkg[:label])
+      when String
+        each_match(:label, pkg)
+      when Dependency
+        each_match(:label, pkg.name).set_iterator_version(pkg.version)
+      else
+        raise TypeError, "illegal argument type"
+      end
+
+      iterator.each do |header|
+        ret = RPM::C.rpmtsAddEraseElement(@ptr, header.ptr, iterator.offset)
+        raise RuntimeError, "Error while adding erase/#{pkg} to transaction" if ret != 0
+      end
     end
 
     # Sets the root directory for this transaction
     # @param [String] root directory
     def root_dir=(dir)
-      rc = RPM::FFI.rpmtsSetRootDir(@ptr, dir)
+      rc = RPM::C.rpmtsSetRootDir(@ptr, dir)
       raise "Can't set #{dir} as root directory" if rc < 0
     end
 
     # @return [String ] the root directory for this transaction
     def root_dir
-      RPM::FFI.rpmtsRootDir(@ptr)
+      RPM::C.rpmtsRootDir(@ptr)
     end
 
     def flags=(fl)
-      RPM::FFI.rpmtsSetFlags(@ptr, fl)
+      RPM::C.rpmtsSetFlags(@ptr, fl)
     end
 
     def flags
-      RPM::FFI.rpmtsFlags(@ptr)
+      RPM::C.rpmtsFlags(@ptr)
+    end
+
+    # Determine package order in the transaction according to dependencies
+    #
+    # The final order ends up as installed packages followed by removed
+    # packages, with packages removed for upgrades immediately following
+    # the new package to be installed.
+    #
+    # @returns [Fixnum] no. of (added) packages that could not be ordered
+    def order
+      RPM::C.rpmtsOrder(@ptr)
+    end
+
+    # Free memory needed only for dependency checks and ordering.
+    def clean
+      RPM::C.rpmtsClean(@ptr)
+    end
+
+    def check
+      rc = RPM::C.rpmtsCheck(@ptr)
+      probs = RPM::C.rpmtsProblems(@ptr)
+
+      return if rc < 0
+      begin
+        psi = RPM::C.rpmpsInitIterator(probs)
+        while (RPM::C.rpmpsNextIterator(psi) >= 0)
+          problem = Problem.from_ptr(RPM::C.rpmpsGetProblem(psi))
+          yield problem
+        end
+      ensure
+        RPM::C.rpmpsFree(probs)
+      end
     end
 
     # Performs the transaction.
     # @param [Number] flag Transaction flags, default +RPM::TRANS_FLAG_NONE+
     # @param [Number] filter Transaction filter, default +RPM::PROB_FILTER_NONE+
     # @example
-    #   transaction.commit do |sig|
+    #   transaction.commit
+    # You can supply your own callback
+    # @example
+    #   transaction.commit do |data|
+    #   end
     # end
     # @yield [CallbackData] sig Transaction progress
-    def commit
-      self.flags = RPM::FFI::TransFlags[:none]
+    def commit(&user_callback)
+      flags = RPM::C::TransFlags[:none]
+
+      callback = Proc.new do |hdr, type, amount, total, key_ptr, data_ignored|
+        key_id = key_ptr.address
+        key = @keys.include?(key_id) ? @keys[key_id] : nil
+
+        case
+          when block_given?
+            package = hdr.null? ? nil : Package.new(hdr)
+            data = CallbackData.new(type, key, package, amount, total)
+            user_callback.call(data)
+          else
+            RPM::C.rpmShowProgress(hdr, type, amount, total, key, data_ignored)
+        end
+      end
+      # We create a callback to pass to the C method and we
+      # call the user supplied callback from there
+      #
+      # The C callback expects you to return a file handle,
+      # We expect from the user to get a File, which we
+      # then convert to a file handle to return.
+      callback = Proc.new do |hdr, type, amount, total, key_ptr, data_ignored|
+        key_id = key_ptr.address
+        key = @keys.include?(key_id) ? @keys[key_id] : nil
 
-      callback = Proc.new do |h, what, amount, total, key, data|
-        puts "#{h} #{what} #{amount} #{total} #{key} #{data}"
+        case
+          when block_given?
+            package = hdr.null? ? nil : Package.new(hdr)
+            data = CallbackData.new(type, key, package, amount, total)
+            ret = user_callback.call(data)
+
+            # For OPEN_FILE we need to do some type conversion
+            # for certain callback types we need to do some
+            case type
+              when :inst_open_file
+                # For :inst_open_file the user callback has to
+                # return the open file
+                if !ret.is_a?(::File)
+                  raise TypeError, "illegal return value type #{ret.class}. Expected File."
+                end
+                fdt = RPM::C.fdDup(ret.to_i)
+                if (fdt.null? || RPM::C.Ferror(fdt) != 0)
+                  raise RuntimeError, "Can't use opened file #{data.key}: #{RPM::C.Fstrerror(fdt)}"
+                  RPM::C.Fclose(fdt) if not fdt.nil?
+                else
+                  fdt = RPM::C.fdLink(fdt)
+                  @fdt = fdt
+                end
+                # return the (RPM type) file handle
+                fdt
+              when :inst_close_file
+                fdt = @fdt
+                RPM::C.Fclose(fdt)
+                @fdt = nil
+              else
+                ret
+            end
+          else
+            # No custom callback given, use the default to show progress
+            RPM::C.rpmShowProgress(hdr, type, amount, total, key, data_ignored)
+        end
       end
 
-      RPM::FFI.rpmtsSetNotifyCallback(@ts, callback, nil)
+      rc = RPM::C.rpmtsSetNotifyCallback(@ptr, callback, nil)
+      raise "Can't set commit callback" if rc != 0
+
+      rc = RPM::C.rpmtsRun(@ptr, nil, :none)
 
-      rc = RPM::FFI.rpmtsRun(@ptr, nil, :none)
+      raise "#{self}: #{RPM::C.rpmlogMessage}" if rc < 0
 
-      raise "Transaction Error" if rc < 0
-      
       if rc > 0
-        ps = RPM::FFI.rpmtsProblems(@ptr)
-        psi = RPM::FFI.rpmpsInitIterator(ps)
-        while (RPM::FFI.rpmpsNextIterator(psi) >= 0)
-          problem = RPM::FFI.rpmpsGetProblem(psi)
-          puts RPM::FFI.rpmProblemString.read_string
+        ps = RPM::C.rpmtsProblems(@ptr)
+        psi = RPM::C.rpmpsInitIterator(ps)
+        while (RPM::C.rpmpsNextIterator(psi) >= 0)
+          problem = Problem.from_ptr(RPM::C.rpmpsGetProblem(psi))
+          STDERR.puts problem
         end
-        RPM::FFI.rpmpsFree(ps)
+        RPM::C.rpmpsFree(ps)
       end
     end
 
+    # @return [DB] the database associated with this transaction
+    def db
+      RPM::DB.new(self)
+    end
+
+    private
+
+    # @param [Package] pkg package to install
+    # @param [String] key e.g. filename where to install from
+    # @param opts options
+    #   @option :upgrade Upgrade packages if true
+    def install_element(pkg, key, opts={})
+      raise TypeError, "illegal argument type" if not pkg.is_a?(RPM::Package)
+      raise ArgumentError, "#{self}: key '#{key}' must be unique" if @keys.include?(key.object_id)
+
+      # keep a reference to the key as rpmtsAddInstallElement will keep a copy
+      # of the passed pointer (we pass the object_id)
+      @keys[key.object_id] = key
+
+      ret = RPM::C.rpmtsAddInstallElement(@ptr, pkg.ptr, FFI::Pointer.new(key.object_id), opts[:upgrade] ? 1 : 0, nil)
+      raise RuntimeError if ret != 0
+      nil
+    end
+
   end
 
 end