polisher 0.9.1 → 0.10.1

data/lib/polisher/git/repo.rb

@@ -3,72 +3,85 @@
 # Licensed under the MIT license
 # Copyright (C) 2013-2014 Red Hat, Inc.
 
-require 'awesome_spawn'
 require 'polisher/core'
 require 'polisher/git_cache'
+require 'polisher/component'
 
 module Polisher
   module Git
-    # Git Repository
-    class Repo
-      extend ConfHelpers
-  
-      # TODO use ruby git api
-      conf_attr :git_cmd, '/usr/bin/git'
-  
-      attr_accessor :url
-  
-      def initialize(args={})
-        @url  = args[:url]
-      end
-  
-      def path
-        GitCache.path_for(@url)
-      end
-  
-      # Clobber the git repo
-      def clobber!
-        FileUtils.rm_rf path
-      end
-  
-      def clone
-        AwesomeSpawn.run "#{git_cmd} clone #{url} #{path}"
-      end
-  
-      def cloned?
-        File.directory?(path)
-      end
-  
-      def in_repo
-        Dir.chdir path do
-          yield
+    Component.verify("Git::Repo", 'awesome_spawn') do
+      # Git Repository
+      class Repo
+        include ConfHelpers
+
+        # TODO use ruby git api
+        conf_attr :git_cmd, '/usr/bin/git'
+
+        attr_accessor :url
+        attr_accessor :path
+
+        def initialize(args={})
+          @url   = args[:url]
+          @path  = args[:path]
+        end
+
+        def path
+          @path || GitCache.path_for(@url)
+        end
+
+        # Clobber the git repo
+        def clobber!
+          FileUtils.rm_rf path
+        end
+
+        def clone
+          require_cmd! git_cmd
+          AwesomeSpawn.run! "#{git_cmd} clone #{url} #{path}"
+        end
+
+        def cloned?
+          File.directory?(path)
+        end
+
+        def in_repo
+          Dir.chdir path do
+            yield
+          end
+        end
+
+        def file_paths
+          in_repo { Dir['**/*'] }
+        end
+
+        def include?(file)
+          file_paths.include?(file)
+        end
+
+        # Note be careful when invoking:
+        def reset!
+          require_cmd! git_cmd
+          in_repo { AwesomeSpawn.run! "#{git_cmd} reset HEAD~ --hard" }
+          self
+        end
+
+        def pull
+          require_cmd! git_cmd
+          in_repo { AwesomeSpawn.run! "#{git_cmd} pull" }
+          self
+        end
+
+        def checkout(tgt)
+          require_cmd! git_cmd
+          in_repo { AwesomeSpawn.run! "#{git_cmd} checkout #{tgt}" }
+          self
+        end
+
+        def commit(msg)
+          require_cmd! git_cmd
+          in_repo { AwesomeSpawn.run! "#{git_cmd} commit -m '#{msg}'" }
+          self
         end
-      end
-  
-      def file_paths
-        in_repo { Dir['**/*'] }
-      end
-  
-      # Note be careful when invoking:
-      def reset!
-        in_repo { AwesomeSpawn.run "#{git_cmd} reset HEAD~ --hard" }
-        self
-      end
-  
-      def pull
-        in_repo { AwesomeSpawn.run "#{git_cmd} pull" }
-        self
-      end
-  
-      def checkout(tgt)
-        in_repo { AwesomeSpawn.run "#{git_cmd} checkout #{tgt}" }
-        self
-      end
-  
-      def commit(msg)
-        in_repo { AwesomeSpawn.run "#{git_cmd} commit -m '#{msg}'" }
-        self
-      end
-    end # class Repo
+      end # class Repo
+    end # Component.verify("Git::Repo")
   end # module Git
 end # module Polisher

data/lib/polisher/koji.rb

@@ -3,104 +3,157 @@
 # Licensed under the MIT license
 # Copyright (C) 2013-2014 Red Hat, Inc.
 
-require 'xmlrpc/client'
-require 'active_support/core_ext/kernel/reporting'
-silence_warnings do
-  XMLRPC::Config::ENABLE_NIL_PARSER = true
-  XMLRPC::Config::ENABLE_NIL_CREATE = true
-end
-
 require 'polisher/core'
+require 'polisher/component'
 
 module Polisher
-  class Koji
-    extend ConfHelpers
+  deps = ['awesome_spawn', 'xmlrpc/client', 'active_support',
+          'active_support/core_ext/kernel/reporting']
+  Component.verify("Koji", *deps) do
+    silence_warnings do
+      XMLRPC::Config::ENABLE_NIL_PARSER = true
+      XMLRPC::Config::ENABLE_NIL_CREATE = true
+    end
 
-    # TODO Koji#build (on class or instance?)
+    class Koji
+      include ConfHelpers
 
-    conf_attr :koji_url, 'koji.fedoraproject.org/kojihub'
-    conf_attr :koji_tag, 'f21'
-    conf_attr :package_prefix, 'rubygem-'
+      conf_attr :koji_url, 'koji.fedoraproject.org/kojihub'
+      conf_attr :koji_tag, 'f21'
+      conf_attr :package_prefix, 'rubygem-'
 
-    def self.koji_tags
-      [koji_tag].flatten
-    end
+      # XXX don't like having to shell out to koji but quickest
+      # way to get an authenticated session so as to launch builds
+      conf_attr :build_cmd, '/usr/bin/koji'
+      conf_attr :build_tgt,    'rawhide'
 
-    # Retrieve shared instance of xmlrpc client to use
-    def self.client
-      @client ||= begin
-        url = koji_url.split('/')
-        XMLRPC::Client.new(url[0..-2].join('/'),
-                           "/#{url.last}")
+      def self.koji_tags
+        [koji_tag].flatten
       end
-    end
 
-    # Return bool indiciating if koji has a build exactly
-    # matching the specified version
-    def self.has_build?(name, version)
-      versions = self.versions_for name
-      versions.include?(version)
-    end
+      def self.package_prefixes
+        [package_prefix].flatten
+      end
 
-    # Return bool indicating if koji has a build which
-    # satisfies the specified ruby dependency
-    def self.has_build_satisfying?(name, version)
-      dep = ::Gem::Dependency.new name, version
-      self.versions_for(name).any? { |v|
-        dep.match?(name, v)
-      }
-    end
+      # Retrieve shared instance of xmlrpc client to use
+      def self.client
+        @client ||= begin
+          url = koji_url.split('/')
+          XMLRPC::Client.new(url[0..-2].join('/'),
+                             "/#{url.last}")
+        end
+      end
 
-    # Return list of tags for which a package exists
-    #
-    # @param [String] name of package to lookup
-    # @return [Hash<String,String>] hash of tag names to package versions for tags
-    # which package was found in
-    def self.tagged_in(name)
-      #                               tagid  userid         pkgid  prefix inherit with_dups
-      pkgs = client.call('listPackages', nil, nil, "rubygem-#{name}", nil, false, true)
-      pkgs.collect { |pkg| pkg['tag_name'] }
-    end
+      # Return bool indiciating if koji has a build exactly
+      # matching the specified version
+      def self.has_build?(name, version)
+        versions = versions_for name
+        versions.include?(version)
+      end
 
-    # Retrieve list of the versions of the specified package in koji
-    #
-    # @param [String] name name of package to lookup
-    # @param [Callable] bl optional block to invoke with versions retrieved
-    # @return [Array<String>] versions retrieved, empty array if none found
-    def self.versions_for(name, &bl)
-      # koji xmlrpc call
-      builds =
-        koji_tags.collect do |tag|
-          client.call('listTagged', tag, nil, false, nil, false,
-                      "#{package_prefix}#{name}")
-        end.flatten
-      versions = builds.collect { |b| b['version'] }
-      bl.call(:koji, name, versions) unless(bl.nil?) 
-      versions
-    end
+      # Return bool indicating if koji has a build which
+      # satisfies the specified ruby dependency
+      def self.has_build_satisfying?(name, version)
+        dep = ::Gem::Dependency.new name, version
+        versions_for(name).any? { |v| dep.match?(name, v) }
+      end
 
-    # Return diff between list of packages in two tags in koji
-    def self.diff(tag1, tag2)
-      builds1 = client.call('listTagged', tag1, nil, false, nil, false)
-      builds2 = client.call('listTagged', tag2, nil, false, nil, false)
-      builds  = {}
-      builds1.each do |build|
-        name         = build['package_name']
-        build2       = builds2.find { |b| b['name'] == name }
-        version1     = build['version']
-        version2     = build2 && build2['version']
-        builds[name] = {tag1 => version1, tag2 => version2}
+      # Return list of tags for which a package exists
+      #
+      # @param [String] name of package to lookup
+      # @return [Hash<String,String>] hash of tag names to package versions for tags
+      # which package was found in
+      def self.tagged_in(name)
+        #                               tagid  userid         pkgid  prefix inherit with_dups
+        pkgs = client.call('listPackages', nil, nil, "rubygem-#{name}", nil, false, true)
+        pkgs.collect { |pkg| pkg['tag_name'] }
       end
 
-      builds2.each do |build|
-        name = build['package_name']
-        next if builds.key?(name)
+      # Retrieve list of the versions of the specified package in koji
+      #
+      # @param [String] name name of package to lookup
+      # @param [Callable] bl optional block to invoke with versions retrieved
+      # @return [Array<String>] versions retrieved, empty array if none found
+      def self.versions_for(name, &bl)
+        # koji xmlrpc call
+        versions = tagged_versions_for(name).values.flatten.uniq
+        bl.call(:koji, name, versions) unless bl.nil?
+        versions
+      end
 
-        version = build['version']
-        builds[name] = {tag1 => nil, tag2 => version}
+      def self.tagged_versions_for(name)
+        versions = {}
+        koji_tags.each do |tag|
+          versions[tag] = versions_for_tag(name, tag).flatten.uniq
+        end
+        versions
       end
 
-      builds
-    end
-  end
-end
+      def self.tagged_version_for(name)
+        versions = {}
+        tagged_versions_for(name).each do |tag, tagged_versions|
+          versions[tag] = tagged_versions.first
+        end
+        versions
+      end
+
+      def self.versions_for_tag(name, tag)
+        metadata =
+          package_prefixes.collect do |prefix|
+            #                         tag  event inherit prefix latest
+            client.call('listTagged', tag, nil,  true,   nil,   false,
+                        "#{prefix}#{name}")
+          end
+
+        metadata.flatten.collect { |b| b['version'] }.uniq
+      end
+
+      # Run a build against the specified target using the specified rpm
+      def self.build(args = {})
+        require_cmd! build_cmd
+
+        target  = args[:target] || build_tgt
+        srpm    = args[:srpm]
+        scratch = args[:scratch] ? '--scratch' : ''
+
+        cmd = "#{build_cmd} build #{scratch} #{target} #{srpm}"
+        result = AwesomeSpawn.run(cmd)
+        url = parse_url(result.output)
+        raise url if result.exit_status != 0
+        url
+      end
+
+      # Parse a koji build url from output
+      def self.parse_url(output)
+        task_info = output.lines.detect { |l| l =~ /Task info:.*/ }
+        task_info ? task_info.split.last : ''
+      end
+
+      # def self.build_logs(url) # TODO
+
+      # Return diff between list of packages in two tags in koji
+      def self.diff(tag1, tag2)
+        builds1 = client.call('listTagged', tag1, nil, false, nil, false)
+        builds2 = client.call('listTagged', tag2, nil, false, nil, false)
+        builds  = {}
+        builds1.each do |build|
+          name         = build['package_name']
+          build2       = builds2.detect { |b| b['name'] == name }
+          version1     = build['version']
+          version2     = build2 && build2['version']
+          builds[name] = {tag1 => version1, tag2 => version2}
+        end
+
+        builds2.each do |build|
+          name = build['package_name']
+          next if builds.key?(name)
+
+          version = build['version']
+          builds[name] = {tag1 => nil, tag2 => version}
+        end
+
+        builds
+      end
+    end # class Koji
+  end # Component.verify("Koji")
+end # module Polisher

data/lib/polisher/logger.rb

@@ -0,0 +1,23 @@
+# Polisher Logging Module
+#
+# Licensed under the MIT license
+# Copyright (C) 2014 Red Hat, Inc.
+
+module Polisher
+  module Logging
+    # This is the magical bit that gets mixed into your classes
+    def logger
+      Logging.logger
+    end
+
+    # Set the log level
+    def self.level=(level)
+      logger.level = Logger.const_get(level.to_s.upcase)
+    end
+
+    # Global, memoized, lazy initialized instance of a logger
+    def self.logger
+      @logger ||= Logger.new(STDOUT)
+    end
+  end # module Logging
+end # module Polisher

data/lib/polisher/rhn.rb

@@ -2,13 +2,14 @@
 #
 # Licensed under the MIT license
 # Copyright (C) 2013-2014 Red Hat, Inc.
-
-require 'pkgwat'
+require 'polisher/component'
 
 module Polisher
-  class RHN
-    def self.version_for(name)
-      # TODO
+  Component.verify("RHN", "pkgwat") do
+    class RHN
+      def self.version_for(name)
+        # TODO
+      end
     end
   end
 end

data/lib/polisher/rpm/requirement.rb

@@ -3,186 +3,195 @@
 # Licensed under the MIT license
 # Copyright (C) 2013-2014 Red Hat, Inc.
 
-require 'gem2rpm'
-require 'versionomy'
-require 'active_support/core_ext'
-
-require 'polisher/core'
 require 'polisher/gem'
+require 'polisher/core'
+require 'polisher/component'
 
 module Polisher
-  module RPM
-    class Requirement
-      # Bool indiciating if req is a BR
-      attr_accessor :br
-
-      # Name of requirement
-      attr_accessor :name
-
-      # Condition, eg >=, =, etc
-      attr_accessor :condition
-
-      # Version number
-      attr_accessor :version
-
-      # Requirement string
-      def str
-        sp = self.specifier
-        sp.nil? ? "#{@name}" : "#{@name} #{sp}"
-      end
-
-      # Specified string
-      def specifier
-        @version.nil? ? nil : "#{@condition} #{@version}"
-      end
-
-      # Instantiate / return new rpm spec requirements from string
-      def self.parse(str, opts={})
-        stra   = str.split
-        br = str.include?('BuildRequires')
-        name = condition = version = nil
-
-        if str.include?('Requires')
-          name      = stra[1] 
-          condition = stra[2]
-          version   = stra[3]
-
-        else
-          name      = stra[0]
-          condition = stra[1]
-          version   = stra[2]
+  deps = ['gem2rpm', 'versionomy', 'active_support/core_ext']
+  Component.verify("RPM::Requirement", *deps) do
+    module RPM
+      class Requirement
+        include ConfHelpers
+
+        conf_attr :rubygem_prefix, 'rubygem'
+        conf_attr :scl_prefix, '' # set to %{?scl_prefix} to enable scl's
+
+        def self.prefix
+          "#{scl_prefix}#{rubygem_prefix}"
+        end
+
+        # Bool indiciating if req is a BR
+        attr_accessor :br
+
+        # Name of requirement
+        attr_accessor :name
+
+        # Condition, eg >=, =, etc
+        attr_accessor :condition
+
+        # Version number
+        attr_accessor :version
+
+        # Requirement string
+        def str
+          sp = self.specifier
+          sp.nil? ? "#{@name}" : "#{@name} #{sp}"
+        end
+
+        # Specified string
+        def specifier
+          @version.nil? ? nil : "#{@condition} #{@version}"
+        end
+
+        # Instantiate / return new rpm spec requirements from string
+        def self.parse(str, opts={})
+          stra   = str.split
+          br = str.include?('BuildRequires')
+          name = condition = version = nil
+
+          if str.include?('Requires')
+            name      = stra[1]
+            condition = stra[2]
+            version   = stra[3]
+
+          else
+            name      = stra[0]
+            condition = stra[1]
+            version   = stra[2]
+
+          end
+
+          req = self.new({:name      => name,
+                          :condition => condition,
+                          :version   => version,
+                          :br        => br}.merge(opts))
+          req
+        end
+
+        # Instantiate / return new rpm spec requirements from gem dependency.
+        #
+        # Because a gem dependency may result in multiple spec requirements
+        # this will always return an array of Requirement instances
+        def self.from_gem_dep(gem_dep, br=false)
+          gem_dep.requirement.to_s.split(',').collect { |req|
+            expanded = Gem2Rpm::Helpers.expand_requirement [req.split]
+            expanded.collect { |e|
+              new :name      => "#{prefix}(#{gem_dep.name})",
+                  :condition => e.first.to_s,
+                  :version   => e.last.to_s,
+                  :br        => br
+            }
+          }.flatten
+        end
 
+        def initialize(args={})
+          @br        = args[:br] || false
+          @name      = args[:name]
+          @condition = args[:condition]
+          @version   = args[:version]
+
+          @name.strip!      unless @name.nil?
+          @condition.strip! unless @condition.nil?
+          @version.strip!   unless @version.nil?
+        end
+
+        def ==(other)
+          @br        == other.br &&
+          @name      == other.name &&
+          @condition == other.condition &&
+          @version   == other.version
+        end
+
+        # Greatest Common Denominator,
+        # Max version in list that is less than the local version
+        def gcd(versions)
+          lversion = Versionomy.parse(self.version)
+          versions.collect { |v| Versionomy.parse(v) }.
+                   sort { |a,b| a <=> b }.reverse.
+                   find { |v| v < lversion }.to_s
+        end
+
+        # Minimum gem version which satisfies this dependency
+        def min_satisfying_version
+          return "0.0"        if self.version.nil?      ||
+                                 self.condition == '<'  ||
+                                 self.condition == '<='
+          return self.version if self.condition == '='  ||
+                                 self.condition == '>='
+          Versionomy.parse(self.version).bump(:tiny).to_s # self.condition == '>'
+        end
+
+        # Max gem version which satisfies this dependency
+        #
+        # Can't automatically deduce in '<' case, so if that is the conditional
+        # we require a version list, and will return the gcd from it
+        def max_satisfying_version(versions=nil)
+          return Float::INFINITY if self.version.nil?      ||
+                                    self.condition == '>'  ||
+                                    self.condition == '>='
+          return self.version    if self.condition == '='  ||
+                                    self.condition == '<='
+
+          raise ArgumentError    if versions.nil?
+          self.gcd(versions)
         end
 
-        req = self.new({:name      => name,
-                        :condition => condition,
-                        :version   => version,
-                        :br        => br}.merge(opts))
-        req
-      end
-
-      # Instantiate / return new rpm spec requirements from gem dependency.
-      #
-      # Because a gem dependency may result in multiple spec requirements
-      # this will always return an array of Requirement instances
-      def self.from_gem_dep(gem_dep, br=false)
-        gem_dep.requirement.to_s.split(',').collect { |req|
-          expanded = Gem2Rpm::Helpers.expand_requirement [req.split]
-          expanded.collect { |e|
-            self.new :name      => "rubygem(#{gem_dep.name})",
-                     :condition => e.first.to_s,
-                     :version   => e.last.to_s,
-                     :br        => br
-          }
-        }.flatten
-      end
-
-      def initialize(args={})
-        @br        = args[:br] || false
-        @name      = args[:name]
-        @condition = args[:condition]
-        @version   = args[:version]
-
-        @name.strip!      unless @name.nil?
-        @condition.strip! unless @condition.nil?
-        @version.strip!   unless @version.nil?
-      end
-
-      def ==(other)
-        @br        == other.br &&
-        @name      == other.name &&
-        @condition == other.condition &&
-        @version   == other.version
-      end
-
-      # Greatest Common Denominator,
-      # Max version in list that is less than the local version
-      def gcd(versions)
-        lversion = Versionomy.parse(self.version)
-        versions.collect { |v| Versionomy.parse(v) }.
-                 sort { |a,b| a <=> b }.reverse.
-                 find { |v| v < lversion }.to_s
-      end
-
-      # Minimum gem version which satisfies this dependency
-      def min_satisfying_version
-        return "0.0"        if self.version.nil?      ||
-                               self.condition == '<'  ||
-                               self.condition == '<='
-        return self.version if self.condition == '='  ||
-                               self.condition == '>='
-        Versionomy.parse(self.version).bump(:tiny).to_s # self.condition == '>'
-      end
-
-      # Max gem version which satisfies this dependency
-      #
-      # Can't automatically deduce in '<' case, so if that is the conditional
-      # we require a version list, and will return the gcd from it
-      def max_satisfying_version(versions=nil)
-        return Float::INFINITY if self.version.nil?      ||
-                                  self.condition == '>'  ||
-                                  self.condition == '>='
-        return self.version    if self.condition == '='  ||
-                                  self.condition == '<='
-
-        raise ArgumentError    if versions.nil?
-        self.gcd(versions)
-      end
-
-      # Minimum gem version for which this dependency fails
-      def min_failing_version
-        raise ArgumentError if self.version.nil?
-        return "0.0"        if self.condition == '>'  ||
-                               self.condition == '>='
-        return self.version if self.condition == '<'
-        Versionomy.parse(self.version).bump(:tiny).to_s # self.condition == '<=' and '='
-      end
-
-      # Max gem version for which this dependency fails
-      #
-      # Can't automatically deduce in '>=', and '=' cases, so if that is the
-      # conditional we require a version list, and will return the gcd from it
-      def max_failing_version(versions=nil)
-        raise ArgumentError if self.version.nil?      ||
-                               self.condition == '<=' ||
-                               self.condition == '<'
-        return self.version if self.condition == '>'
-
-        raise ArgumentError if versions.nil?
-        self.gcd(versions)
-      end
-
-      # Return bool indicating if requirement matches specified
-      # depedency.
-      #
-      # Comparison mechanism will depend on type of class
-      # passed to this. Valid types include
-      # - Polisher::RPM::Requirements
-      # - ::Gem::Dependency
-      def matches?(dep)
-        return self == dep      if dep.is_a?(self.class)
-        raise ArgumentError unless dep.is_a?(::Gem::Dependency)
-
-        return false if !self.gem? || self.gem_name != dep.name
-        return true  if  self.version.nil?
-
-        Gem2Rpm::Helpers.expand_requirement([dep.requirement.to_s.split]).
-          any?{ |req|
-            req.first == self.condition && req.last.to_s == self.version
-          }
-      end
-
-      # Whether or not this requirement specified a ruby gem dependency
-      def gem?
-        !!(self.str =~ RPM::Spec::SPEC_GEM_REQ_MATCHER)
-      end
-
-      # Return the name of the gem which this requirement is for.
-      # Returns nil if this is not a gem requirement
-      def gem_name
-        # XXX need to explicitly run regex here to get $1
-        !!(self.str =~ RPM::Spec::SPEC_GEM_REQ_MATCHER) ? $1 : nil
-      end
-    end # class Requirement
-  end # module RPM 
-end
+        # Minimum gem version for which this dependency fails
+        def min_failing_version
+          raise ArgumentError if self.version.nil?
+          return "0.0"        if self.condition == '>'  ||
+                                 self.condition == '>='
+          return self.version if self.condition == '<'
+          Versionomy.parse(self.version).bump(:tiny).to_s # self.condition == '<=' and '='
+        end
+
+        # Max gem version for which this dependency fails
+        #
+        # Can't automatically deduce in '>=', and '=' cases, so if that is the
+        # conditional we require a version list, and will return the gcd from it
+        def max_failing_version(versions=nil)
+          raise ArgumentError if self.version.nil?      ||
+                                 self.condition == '<=' ||
+                                 self.condition == '<'
+          return self.version if self.condition == '>'
+
+          raise ArgumentError if versions.nil?
+          self.gcd(versions)
+        end
+
+        # Return bool indicating if requirement matches specified
+        # depedency.
+        #
+        # Comparison mechanism will depend on type of class
+        # passed to this. Valid types include
+        # - Polisher::RPM::Requirements
+        # - ::Gem::Dependency
+        def matches?(dep)
+          return self == dep      if dep.is_a?(self.class)
+          raise ArgumentError unless dep.is_a?(::Gem::Dependency)
+
+          return false if !self.gem? || self.gem_name != dep.name
+          return true  if  self.version.nil?
+
+          Gem2Rpm::Helpers.expand_requirement([dep.requirement.to_s.split]).
+            any?{ |req|
+              req.first == self.condition && req.last.to_s == self.version
+            }
+        end
+
+        # Whether or not this requirement specified a ruby gem dependency
+        def gem?
+          !!(self.str =~ RPM::Spec::SPEC_GEM_REQ_MATCHER)
+        end
+
+        # Return the name of the gem which this requirement is for.
+        # Returns nil if this is not a gem requirement
+        def gem_name
+          # XXX need to explicitly run regex here to get $1
+          !!(self.str =~ RPM::Spec::SPEC_GEM_REQ_MATCHER) ? $1 : nil
+        end
+      end # class Requirement
+    end # module RPM
+  end # Component.verify("RPM::Requirement")
+end # module Polisher