rpm2 0.1.0

data/lib/rpm/package.rb

@@ -0,0 +1,332 @@
+
+module RPM
+  class ChangeLog
+    attr_accessor :time, :name, :text
+  end
+
+  class Package
+    # Create a new package object from data
+    # @param [String] str Header data
+    # @return [Package]
+    def load(_data)
+      raise NotImplementedError
+    end
+
+    def self.create(name, version)
+      unless name.is_a?(String)
+        raise TypeError, 'illegal argument type: name should be String'
+      end
+      unless version.is_a?(RPM::Version)
+        raise TypeError, 'illegal argument type: version should be RPM::Version'
+      end
+      hdr = RPM::C.headerNew
+      if RPM::C.headerPutString(hdr, :name, name) != 1
+        raise "Can't set package name: #{name}"
+      end
+      if RPM::C.headerPutString(hdr, :version, version.v) != 1
+        raise "Can't set package version: #{version.v}"
+      end
+      if version.e
+        if RPM::C.headerPutUint32(hdr, :epoch, version.e) != 1
+          raise "Can't set package epoch: #{version.e}"
+        end
+      end
+      Package.new(hdr)
+    end
+
+    # Add a dependency to the package header
+    # @param [Dependency] dep Dependency to add
+    def add_dependency(dep)
+      unless dep.is_a?(Dependency)
+        raise TypeError, 'illegal argument type: must be a Dependency'
+      end
+
+      raise NotImplementedError
+    end
+
+    # Add a int32 value to the package header
+    # @param [Number] tag Tag
+    # @param [Number] val Value
+    def add_int32(_tag, _val)
+      raise NotImplementedError
+    end
+
+    # Add a list of strings to the package header
+    # @param [Number] tag Tag
+    # @param [Array<String>] val Strings to add
+    def add_string_array(_tag, _val)
+      raise NotImplementedError
+    end
+
+    # Add a binary value to the package header
+    # @param [Number] tag Tag
+    # @param [String] val String to add
+    def add_string(_tag, _val)
+      raise NotImplementedError
+    end
+
+    # Add a binary value to the package header
+    # @param [Number] tag Tag
+    # @param [String] val Value
+    def add_binary(_tag, _val)
+      raise NotImplementedError
+    end
+
+    # Deletes a tag of the package header
+    # @param [Number] tag Tag
+    def delete_tag(_tag)
+      raise NotImplementedError
+    end
+
+    # @return a formated string
+    # @example
+    #   pkg.sprintf("%{name}") => "apache2"
+    def sprintf(fmt)
+      error = ::FFI::MemoryPointer.new(:pointer, 1)
+      val = RPM::C.headerFormat(@hdr, fmt, error)
+      raise error.get_pointer(0).read_string if val.null?
+      val.read_string
+    end
+
+    # @return [Number] This package signature
+    def signature
+      sprintf('%{sigmd5}')
+    end
+
+    # @return [Array<RPM::File>] File list for this package
+    def files
+      basenames = self[:basenames]
+
+      return [] if basenames.nil?
+
+      dirnames = self[:dirnames]
+      diridxs = self[:dirindexes]
+      statelist = self[:filestates]
+      flaglist = self[:fileflags]
+      sizelist = self[:filesizes]
+      modelist = self[:filemodes]
+      mtimelist = self[:filemtimes]
+      rdevlist = self[:filerdevs]
+      linklist = self[:filelinktos]
+      md5list = self[:filemd5s]
+      ownerlist = self[:fileusername]
+      grouplist = self[:filegroupname]
+
+      ret = []
+
+      basenames.each_with_index do |_basename, i|
+        file = RPM::File.new("#{dirnames[diridxs[i]]}#{basenames[i]}",
+                             md5list[i],
+                             linklist[i],
+                             sizelist[i],
+                             mtimelist[i],
+                             ownerlist[i],
+                             grouplist[i],
+                             rdevlist[i],
+                             modelist[i],
+                             flaglist.nil? ? RPM::C::FileAttrs[:none] : flaglist[i],
+                             statelist.nil? ? RPM::C::FileState[:normal] : statelist[i])
+        ret << file
+      end
+      ret
+    end
+
+    # @return [Array<RPM::Dependency>] Dependencies for +klass+
+    # @example
+    #    dependencies(RPM::Provide, :providename, :provideversion, :provideflags)
+    #
+    # @visibility private
+    def dependencies(klass, nametag, versiontag, flagtag)
+      deps = []
+
+      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::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::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
+
+    # @return [Array<RPM::Provide>] Provides list for this package
+    def provides
+      dependencies(RPM::Provide, :providename, :provideversion, :provideflags)
+    end
+
+    # @return [Array<RPM::Require>] Requires list for this package
+    def requires
+      dependencies(RPM::Require, :requirename, :requireversion, :requireflags)
+    end
+
+    # @return [Array<RPM::Conflicts>] Conflicts list for this package
+    def conflicts
+      dependencies(RPM::Conflict, :conflictname, :conflictversion, :conflictflags)
+    end
+
+    # @return [Array<RPM::Obsolete>] Obsoletes list for this package
+    def obsoletes
+      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::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::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::C.rpmtdInit(timetd)
+      while RPM::C.rpmtdNext(timetd) != -1
+        entry = RPM::ChangeLog.new
+        entry.time = RPM::C.rpmtdGetUint32(timetd)
+        entry.name = RPM::C.rpmtdNextString(nametd)
+        entry.text = RPM::C.rpmtdNextString(texttd)
+        entries << entry
+      end
+      entries
+    end
+
+    # Access a header entry
+    # @param [Number] tag Tag to return
+    # @return [] Value of the entry
+    # @example
+    #     pkg => #<RPM::Package name="xmlgraphics-fop", version=#<RPM::Version v="1.0", r="22.4">>
+    #     pkg[:name] => "xmlgraphics-fop"
+    #
+    #   or if you have the old ruby-rpm compat loaded
+    #
+    #     require 'rpm/compat'
+    #     pkg[RPM::TAG_NAME] => "xmlgraphics-fop"
+    #
+    # @return [String, Fixnum, Array<String>, Array<Fixnum>, nil]
+    #   The value of the entry
+    def [](tag)
+      tagc = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))
+
+      return nil if RPM::C.headerGet(ptr, tag, tagc,
+                                     RPM::C::HEADERGET_MINMEM) == 0
+
+      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
+                    when :string_type, :string_array_type, :bin_type then :rpmtdGetString
+                    else raise NotImplementedError, "Don't know how to retrieve type '#{type}'"
+                    end
+
+      is_array = if count > 1 then true
+                 elsif ret_type == :array_return_type then true
+                 elsif type == :string_array_type then true
+                 else false
+                 end
+
+      if is_array
+        ret = []
+        RPM::C.rpmtdInit(tagc)
+        ret << RPM::C.send(method_name, tagc) while RPM::C.rpmtdNext(tagc) != -1
+        return ret
+      end
+
+      RPM::C.send(method_name, tagc)
+    end
+
+    # @return [String] This package name
+    def name
+      self[:name]
+    end
+
+    # @return [String] This package architecture
+    def arch
+      self[:arch]
+    end
+
+    # TODO: signature
+
+    # @return [Version] Version for this package
+    def version
+      Version.new(self[:version], self[:release], self[:epoch])
+    end
+
+    # String representation of the package: "name-version-release-arch"
+    # @return [String]
+    def to_s
+      return '' if name.nil?
+      return name if version.nil?
+      return "#{name}-#{version}" if arch.nil?
+      "#{name}-#{version}-#{arch}"
+    end
+
+    def self.open(filename)
+      Package.new(filename)
+    end
+
+    # @visibility private
+    def self.release(ptr)
+      RPM::C.headerFree(ptr)
+    end
+
+    # @visibility private
+    def self.release_td(ptr)
+      RPM::C.rpmtdFree(ptr)
+    end
+
+    # @visibility private
+    def initialize(what)
+      case what
+      when String then initialize_from_filename(what)
+      else initialize_from_header(what)
+      end
+    end
+
+    # @visibility private
+    def initialize_from_header(hdr = nil)
+      if hdr.nil?
+        @hdr = ::FFI::AutoPointer.new(RPM::C.headerNew, Header.method(:release))
+      elsif hdr.is_a?(::FFI::Pointer)
+        # ref
+        hdr = RPM::C.headerLink(hdr)
+        @hdr = ::FFI::AutoPointer.new(hdr, Package.method(:release))
+      else
+        raise "Can't initialize header with '#{hdr}'"
+      end
+    end
+
+    def initialize_from_filename(filename)
+      # it sucks not using the std File.open here
+      hdr = ::FFI::MemoryPointer.new(:pointer)
+      fd = nil
+      begin
+        fd = RPM::C.Fopen(filename, 'r')
+        raise "#{filename} : #{RPM::C.Fstrerror(fd)}" if RPM::C.Ferror(fd) != 0
+        RPM.transaction do |ts|
+          RPM::C.rpmReadPackageFile(ts.ptr, fd, filename, hdr)
+        end
+      ensure
+        RPM::C.Fclose(fd) unless fd.nil?
+      end
+      initialize_from_header(hdr.get_pointer(0))
+    end
+
+    # @return [RPM::C::Header] header pointer
+    # @visibility private
+    def ptr
+      @hdr
+    end
+  end
+end

data/lib/rpm/problem.rb

@@ -0,0 +1,65 @@
+
+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
+    attr_reader :ptr
+  end
+end

data/lib/rpm/transaction.rb

@@ -0,0 +1,268 @@
+
+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::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::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::C.rpmtsInitIterator(@ptr, tag.nil? ? 0 : tag, val, 0)
+
+      raise "Can't init iterator for [#{tag}] -> '#{val}'" if it_ptr.null?
+      MatchIterator.from_ptr(it_ptr)
+    end
+
+    # @visibility private
+    attr_reader :ptr
+
+    #
+    # @yield [Package] Called for each match
+    # @param [Number] key RPM tag key
+    # @param [String] val Value to match
+    # @example
+    #   RPM.transaction do |t|
+    #     t.each_match(RPM::TAG_ARCH, "x86_64") do |pkg|
+    #       puts pkg.name
+    #     end
+    #   end
+    #
+    def each_match(key, val, &block)
+      it = init_iterator(key, val)
+
+      return it unless block_given?
+
+      it.each(&block)
+    end
+
+    #
+    # @yield [Package] Called for each package in the database
+    # @example
+    #   db.each do |pkg|
+    #     puts pkg.name
+    #   end
+    #
+    def each(&block)
+      each_match(0, nil, &block)
+    end
+
+    # 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)
+      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 "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::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::C.rpmtsRootDir(@ptr)
+    end
+
+    def flags=(fl)
+      RPM::C.rpmtsSetFlags(@ptr, fl)
+    end
+
+    def flags
+      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
+    # You can supply your own callback
+    # @example
+    #   transaction.commit do |data|
+    #   end
+    # end
+    # @yield [CallbackData] sig Transaction progress
+    def commit
+      callback = proc do |hdr, type, amount, total, key_ptr, data_ignored|
+        key_id = key_ptr.address
+        key = @keys.include?(key_id) ? @keys[key_id] : nil
+
+        if block_given?
+          package = hdr.null? ? nil : Package.new(hdr)
+          data = CallbackData.new(type, key, package, amount, total)
+          yield(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 do |hdr, type, amount, total, key_ptr, data_ignored|
+        key_id = key_ptr.address
+        key = @keys.include?(key_id) ? @keys[key_id] : nil
+
+        if block_given?
+          package = hdr.null? ? nil : Package.new(hdr)
+          data = CallbackData.new(type, key, package, amount, total)
+          ret = yield(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
+            unless 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 "Can't use opened file #{data.key}: #{RPM::C.Fstrerror(fdt)}"
+              RPM::C.Fclose(fdt) unless 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
+
+      rc = RPM::C.rpmtsSetNotifyCallback(@ptr, callback, nil)
+      raise "Can't set commit callback" if rc != 0
+
+      rc = RPM::C.rpmtsRun(@ptr, nil, :none)
+
+      raise "#{self}: #{RPM::C.rpmlogMessage}" if rc < 0
+
+      if rc > 0
+        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::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' unless 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

data/lib/rpm/utils.rb

@@ -0,0 +1,7 @@
+module RPM
+  module Utils
+    def self.check_type(var, type)
+      raise(TypeError, "wrong argument type #{var.class} (expected #{type.class})") unless var.is_a?(type)
+    end
+  end
+end