polisher 0.10.2 → 0.11.1

data/lib/polisher/targets/fedora.rb

@@ -0,0 +1,47 @@
+# Polisher Fedora Operations
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'polisher/targets/bodhi'
+require 'open-uri'
+
+module Polisher
+  class Fedora
+    PACKAGE_LIST_API = 'https://admin.fedoraproject.org/pkgdb/api'
+
+    # Retrieve list of gems owned/co-maintained by the specified user
+    #
+    # @param [String] user Fedora username to lookup
+    # @return [Array<String>] list of gems which the user owns/has access to
+    def self.gems_owned_by(user)
+      user_packages_url = "#{PACKAGE_LIST_API}/packager/package/#{user}"
+      pkg_list = JSON.load(open(user_packages_url))
+
+      pkg_owns = pkg_list['point of contact']
+                 .select { |pkg| pkg['name'] =~ /^rubygem-/ }
+                 .collect { |pkg| pkg['name'].gsub(/rubygem-/, '') }
+
+      pkg_has_access = pkg_list['co-maintained']
+                       .select { |pkg| pkg['name'] =~ /^rubygem-/ }
+                       .collect { |pkg| pkg['name'].gsub(/rubygem-/, '') }
+
+      pkg_owns + pkg_has_access
+
+      # TODO: instantiate Polisher::Gem instances & return
+    end
+
+    # Retrieve list of the versions of the specified package in the various
+    # Fedora releases.
+    #
+    # @param [String] name name of the package to lookup
+    # @param [Callable] bl optional callback to invoke with versions retrieved
+    # @return [Array<String>] list of versions in Fedora
+    def self.versions_for(name, &bl)
+      # simply dispatch to bodhi to get latest updates
+      Polisher::Bodhi.versions_for name do |_target, pkg_name, versions|
+        bl.call(:fedora, pkg_name, versions) unless bl.nil?
+      end
+    end
+  end # class Fedora
+end # module Polisher

data/lib/polisher/targets/koji.rb

@@ -0,0 +1,39 @@
+# Polisher Koji Operations
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'polisher/util/conf_helpers'
+
+require 'polisher/targets/koji/rpc'
+require 'polisher/targets/koji/versions'
+require 'polisher/targets/koji/builder'
+require 'polisher/targets/koji/diff'
+
+module Polisher
+  class Koji
+    include ConfHelpers
+
+    include KojiRpc
+    include KojiVersions
+    include KojiBuilder
+    include KojiDiff
+
+    conf_attr :koji_url, 'koji.fedoraproject.org/kojihub'
+    conf_attr :koji_tag, 'f21'
+    conf_attr :package_prefix, 'rubygem-'
+
+    # 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'
+
+    def self.koji_tags
+      [koji_tag].flatten
+    end
+
+    def self.package_prefixes
+      [package_prefix].flatten
+    end
+  end # class Koji
+end # module Polisher

data/lib/polisher/targets/koji/builder.rb

@@ -0,0 +1,38 @@
+# Polisher Koji Build Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+module Polisher
+  module KojiBuilder
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Run a build against the specified target using the specified rpm
+      def build(args = {})
+        require 'awesome_spawn'
+        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 parse_url(output)
+        task_info = output.lines.detect { |l| l =~ /Task info:.*/ }
+        task_info ? task_info.split.last : ''
+      end
+
+      # def build_logs(url) # TODO
+    end # module ClassMethods
+  end # module KojiBuilder
+end # module Polisher

data/lib/polisher/targets/koji/diff.rb

@@ -0,0 +1,39 @@
+# Polisher Koji RPC Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+module Polisher
+  module KojiDiff
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Return diff between list of packages in two tags in koji
+      def diff(tag1, tag2)
+        #                                   tag event inherit prefix latest
+        builds1 = client.call('listTagged', tag1, nil, false, nil, true)
+        builds2 = client.call('listTagged', tag2, nil, false, nil, true)
+        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 # module ClassMethods
+  end # module KojiDiff
+end # module Polisher

data/lib/polisher/targets/koji/rpc.rb

@@ -0,0 +1,43 @@
+# Polisher Koji RPC Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'xmlrpc/client'
+require 'active_support'
+require 'active_support/core_ext/kernel/reporting'
+
+silence_warnings do
+  XMLRPC::Config::ENABLE_NIL_PARSER = true
+  XMLRPC::Config::ENABLE_NIL_CREATE = true
+end
+
+module Polisher
+  module KojiRpc
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Retrieve shared instance of xmlrpc client to use
+      def 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 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
+    end # module ClassMethods
+  end # module KojiRpc
+end # module Polisher

data/lib/polisher/targets/koji/versions.rb

@@ -0,0 +1,67 @@
+# Polisher Koji Versions Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+module Polisher
+  module KojiVersions
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Return bool indiciating if koji has a build exactly
+      # matching the specified version
+      def has_build?(name, version)
+        versions = versions_for name
+        versions.include?(version)
+      end
+
+      # Return bool indicating if koji has a build which
+      # satisfies the specified ruby dependency
+      def has_build_satisfying?(name, version)
+        dep = ::Gem::Dependency.new name, version
+        versions_for(name).any? { |v| dep.match?(name, v) }
+      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 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
+
+      def tagged_versions_for(name)
+        versions = {}
+        koji_tags.each do |tag|
+          versions[tag] = versions_for_tag(name, tag).flatten.uniq
+        end
+        versions
+      end
+
+      def tagged_version_for(name)
+        versions = {}
+        tagged_versions_for(name).each do |tag, tagged_versions|
+          versions[tag] = tagged_versions.first
+        end
+        versions
+      end
+
+      def 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
+    end # module ClassMethods
+  end # module KojiRpc
+end # module Polisher

data/lib/polisher/targets/rhn.rb

@@ -0,0 +1,12 @@
+# Polisher RHN Operations
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+module Polisher
+  class RHN
+    def self.version_for(_name)
+      # TODO
+    end
+  end
+end

data/lib/polisher/targets/yum.rb

@@ -0,0 +1,36 @@
+# Polisher Yum Operations
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'polisher/util/conf_helpers'
+
+module Polisher
+  class Yum
+    include ConfHelpers
+
+    conf_attr :yum_cmd, '/usr/bin/yum'
+
+    # Retrieve version of gem available in yum
+    #
+    # @param [String] name name of gem to loopup
+    # @param [Callable] bl optional callback to invoke with version retrieved
+    # @returns [String] version of gem in yum or nil if not found
+    def self.version_for(name, &bl)
+      require 'awesome_spawn'
+
+      require_cmd! yum_cmd
+
+      version = nil
+      result  = AwesomeSpawn.run "#{yum_cmd} info rubygem-#{name}"
+      out = result.output
+
+      if out.include?("Version")
+        version = out.lines.to_a.detect { |l| l =~ /^Version.*/ }
+        version = version.split(':').last.strip
+      end
+      bl.call(:yum, name, [version]) unless bl.nil?
+      version
+    end
+  end
+end # module Polisher

data/lib/polisher/{component.rb → util/component.rb}

@@ -9,11 +9,11 @@ require 'active_support/core_ext'
 module Polisher
   module Component
     class Missing
-      def initialize(*args)
+      def initialize(*)
         raise "polisher is missing a dependency - cannot instantiate"
       end
 
-      def method_missing(method_id, *args, &bl)
+      def method_missing(method_id, *_args, &_bl)
         raise "polisher is missing a dependency - cannot invoke #{method_id} on #{self}"
       end
     end # class MissingComponent
@@ -34,7 +34,7 @@ module Polisher
       desired_namespace = Polisher
 
       klasses.each do |k|
-        desired_namespace.const_set(k, Missing) unless desired_namespace.const_defined?(k)
+        desired_namespace.const_set(k, Missing) unless desired_namespace.const_defined?(k, false)
         desired_namespace = "#{desired_namespace.name}::#{k}".constantize
       end
       warn "Failed to require #{dependency}.  Added runtime exception in Polisher::#{polisher_klass}"

data/lib/polisher/util/conf_helpers.rb

@@ -0,0 +1,77 @@
+# Polisher Config Helper Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+module ConfHelpers
+  module ClassMethods
+    attr_reader :conf_attrs
+
+    def conf_attrs?
+      conf_attrs.is_a?(Array)
+    end
+
+    # Defines a 'config attribute' or attribute on the class
+    # which this is defined in. Accessors to the single shared
+    # attribute will be added to the class as well as instances
+    # of the class. Specify the default value with the attr name
+    # or via an env variable
+    #
+    # @example
+    #   class Custom
+    #     extend ConfHelpers
+    #     conf_attr :data_dir, '/etc/'
+    #   end
+    #   Custom.data_dir # => '/etc/'
+    #   ENV['POLISHER_DATA_DIR'] = '/usr/'
+    #   Custom.data_dir # => '/usr/'
+    #   Custom.data_dir == Custom.new.data_dir # => true
+    #
+    def conf_attr(name, default = nil)
+      @conf_attrs ||= []
+      @conf_attrs  << name
+
+      send(:define_singleton_method, name) do |*args|
+        nvar = "@#{name}".intern
+        current = instance_variable_get(nvar)
+        envk    = "POLISHER_#{name.to_s.upcase}"
+        instance_variable_set(nvar, default)    unless current
+        instance_variable_set(nvar, ENV[envk])  if ENV.key?(envk)
+        instance_variable_set(nvar, args.first) unless args.empty?
+        instance_variable_get(nvar)
+      end
+
+      send(:define_method, name) do
+        self.class.send(name)
+      end
+    end
+
+    def cmd_available?(cmd)
+      File.exist?(cmd) && File.executable?(cmd)
+    end
+
+    def require_cmd!(cmd)
+      raise "command #{cmd} not available" unless cmd_available?(cmd)
+    end
+
+    def require_dep!(dep, obj=nil)
+      require dep
+    rescue LoadError => e
+      m  = e.backtrace[obj.nil? ? 3 : 4].split.last
+      ms = obj.nil? ? m : "#{obj.class} #{m}"
+      raise "dependency #{dep} is not available - cannot invoke #{ms}"
+    end
+  end # module ClassMethods
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def require_cmd!(cmd)
+    self.class.require_cmd!(cmd)
+  end
+
+  def require_dep!(dep)
+    self.class.require_dep!(dep, self)
+  end
+end

data/lib/polisher/util/config.rb

@@ -0,0 +1,45 @@
+# Polisher Config Operations
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'yaml'
+require 'active_support'
+require 'active_support/core_ext'
+require 'polisher/util/core_ext'
+
+module Polisher
+  class Config
+    CONF    = "#{ENV['HOME']}/.polisher/config"
+    TARGETS = [['koji',    'polisher/targets/koji',    'Koji'],
+               ['distgit', 'polisher/git/pkg',         'Git::Pkg'],
+               ['rpm',     'polisher/rpm/spec',        'RPM::Requirement'],
+               ['tags',    'polisher/util/tag_mapper', 'TagMapper']]
+
+    def self.target_classes
+      TARGETS.collect do |target, req, polisher_class_str|
+        require req
+        polisher_class_str.to_polisher_class
+      end
+    end
+
+    def self.opts
+      @opts ||=  File.exist?(CONF) ? YAML.load_file(CONF) : {}
+    end
+
+    def self.set
+      TARGETS.each do |target, req, polisher_class_str|
+        next unless opts[target]
+        require req
+        target_class = polisher_class_str.to_polisher_class
+        opts[target].each { |k, v| target_class.send(k.intern, v) }
+      end
+    end
+
+    def self.get
+      TARGETS.each do |target, req, polisher_class_str|
+        require req
+      end
+    end
+  end # class Config
+end # module Polisher