Merge pull request Katello#2706 from jlsherrill/multi-pulp

updating katello to use Runcible 1.0.0

app/lib/util/thread_session.rb

@@ -24,6 +24,20 @@
 # http://rails-bestpractices.com/posts/47-fetch-current-user-in-models
 #
 
+module Katello
+  def self.pulp_server=(server)
+    Thread.current[:pulp_server] = server
+  end
+
+  def self.update_runcible_user(username)
+    self.pulp_server.update_config('user', username)
+  end
+
+  def self.pulp_server
+    Thread.current[:pulp_server]
+  end
+end
+
 
 module Util
   module ThreadSession
@@ -45,27 +59,7 @@ def self.current=(o)
             Rails.logger.debug "Setting current user thread-local variable to " + username
             Thread.current[:user] = o
 
-            set_pulp_config(remote_id) if Katello.config.katello?
-
-          end
-
-          def self.set_pulp_config(user_id)
-            if user_id
-              uri = URI.parse(Katello.config.pulp.url)
-
-              ::Runcible::Base.config = {
-                :url      => "#{uri.scheme}://#{uri.host.downcase}",
-                :api_path => uri.path,
-                :user     => user_id,
-                :timeout      => Katello.config.rest_client_timeout,
-                :open_timeout => Katello.config.rest_client_timeout,
-                :oauth    => {:oauth_secret => Katello.config.pulp.oauth_secret,
-                              :oauth_key    => Katello.config.pulp.oauth_key },
-                :logging  => {:logger     => ::Logging.logger['pulp_rest'],
-                              :exception  => true,
-                              :debug      => true }
-              }
-            end
+            Katello.update_runcible_user(remote_id) if Katello.config.use_pulp
           end
 
           # Executes given block on behalf of a different user. Mostly for debuggin purposes since

app/models/glue/pulp/consumer.rb

@@ -23,15 +23,15 @@ def self.included(base)
       add_system_group_hook     lambda { |system_group| system_group.add_consumer(self) }
       remove_system_group_hook  lambda { |system_group| system_group.remove_consumer(self) }
 
-      lazy_accessor :pulp_facts, :initializer => lambda {|s| Runcible::Extensions::Consumer.retrieve(uuid) }
+      lazy_accessor :pulp_facts, :initializer => lambda {|s| Katello.pulp_server.extensions.consumer.retrieve(uuid) }
       lazy_accessor :package_profile, :initializer => lambda{|s| fetch_package_profile}
       lazy_accessor :simple_packages, :initializer => lambda {|s| fetch_package_profile["profile"].
                                                               collect{|package| Glue::Pulp::SimplePackage.new(package)} }
-      lazy_accessor :errata, :initializer => lambda {|s| Runcible::Extensions::Consumer.applicable_errata(uuid).
+      lazy_accessor :errata, :initializer => lambda {|s| Katello.pulp_server.extensions.consumer.applicable_errata(uuid).
                                                           map{|k,v| v.values}.flatten.
                                                           map{|e| Errata.new(e[:details])}
                                                     }
-      lazy_accessor :repoids, :initializer => lambda {|s| Runcible::Extensions::Consumer.retrieve_bindings(uuid).
+      lazy_accessor :repoids, :initializer => lambda {|s| Katello.pulp_server.extensions.consumer.retrieve_bindings(uuid).
                                                               collect{ |repo| repo["repo_id"]} }
     end
   end
@@ -56,7 +56,7 @@ def enable_repos update_ids
 
       unbind_ids.each do |repoid|
         begin
-          events.concat(Runcible::Extensions::Consumer.unbind_all(uuid, repoid))
+          events.concat(Katello.pulp_server.extensions.consumer.unbind_all(uuid, repoid))
           processed_ids << repoid
         rescue => e
           Rails.logger.error "Failed to unbind repo #{repoid}: #{e}, #{e.backtrace.join("\n")}"
@@ -66,7 +66,7 @@ def enable_repos update_ids
 
       bind_ids.each do |repoid|
         begin
-          events.concat(Runcible::Extensions::Consumer.bind_all(uuid, repoid, false))
+          events.concat(Katello.pulp_server.extensions.consumer.bind_all(uuid, repoid, false))
           processed_ids << repoid
         rescue => e
           Rails.logger.error "Failed to bind repo #{repoid}: #{e}, #{e.backtrace.join("\n")}"
@@ -95,7 +95,7 @@ def enable_repos update_ids
 
     def del_pulp_consumer
       Rails.logger.debug "Deleting consumer in pulp: #{self.name}"
-      Runcible::Extensions::Consumer.delete(self.uuid)
+      Katello.pulp_server.extensions.consumer.delete(self.uuid)
     rescue => e
       Rails.logger.error "Failed to delete pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
       raise e
@@ -113,7 +113,7 @@ def rollback_on_pulp_create
 
     def set_pulp_consumer
       Rails.logger.debug "Creating a consumer in pulp: #{self.name}"
-      return Runcible::Extensions::Consumer.create(self.uuid, {:display_name => self.name})
+      return Katello.pulp_server.extensions.consumer.create(self.uuid, {:display_name => self.name})
     rescue => e
       Rails.logger.error "Failed to create pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
       raise e
@@ -123,31 +123,31 @@ def update_pulp_consumer
       return true if @changed_attributes.empty?
 
       Rails.logger.debug "Updating consumer in pulp: #{self.name}"
-      Runcible::Extensions::Consumer.update(self.uuid, :display_name => self.name)
+      Katello.pulp_server.extensions.consumer.update(self.uuid, :display_name => self.name)
     rescue => e
       Rails.logger.error "Failed to update pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
       raise e
     end
 
     def upload_package_profile profile
       Rails.logger.debug "Uploading package profile for consumer #{self.name}"
-      Runcible::Extensions::Consumer.upload_profile(self.uuid, 'rpm', profile)
+      Katello.pulp_server.extensions.consumer.upload_profile(self.uuid, 'rpm', profile)
     rescue => e
       Rails.logger.error "Failed to upload package profile to pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
       raise e
     end
 
     def install_package packages
       Rails.logger.debug "Scheduling package install for consumer #{self.name}"
-      pulp_task = Runcible::Extensions::Consumer.install_content(self.uuid, 'rpm', packages, {"importkeys" => true})
+      pulp_task = Katello.pulp_server.extensions.consumer.install_content(self.uuid, 'rpm', packages, {"importkeys" => true})
     rescue => e
       Rails.logger.error "Failed to schedule package install for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
       raise e
     end
 
     def uninstall_package packages
       Rails.logger.debug "Scheduling package uninstall for consumer #{self.name}"
-      pulp_task = Runcible::Extensions::Consumer.uninstall_content(self.uuid, 'rpm', packages)
+      pulp_task = Katello.pulp_server.extensions.consumer.uninstall_content(self.uuid, 'rpm', packages)
     rescue => e
       Rails.logger.error "Failed to schedule package uninstall for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
       raise e
@@ -157,31 +157,31 @@ def update_package packages
       Rails.logger.debug "Scheduling package update for consumer #{self.name}"
       options = {"importkeys" => true}
       options[:all] = true if packages.blank?
-      pulp_task = Runcible::Extensions::Consumer.update_content(self.uuid, 'rpm', packages, options)
+      pulp_task = Katello.pulp_server.extensions.consumer.update_content(self.uuid, 'rpm', packages, options)
     rescue => e
       Rails.logger.error "Failed to schedule package update for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
       raise e
     end
 
     def install_package_group groups
       Rails.logger.debug "Scheduling package group install for consumer #{self.name}"
-      pulp_task = Runcible::Extensions::Consumer.install_content(self.uuid, 'package_group', groups, {"importkeys" => true})
+      pulp_task = Katello.pulp_server.extensions.consumer.install_content(self.uuid, 'package_group', groups, {"importkeys" => true})
     rescue => e
       Rails.logger.error "Failed to schedule package group install for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
       raise e
     end
 
     def uninstall_package_group groups
       Rails.logger.debug "Scheduling package group uninstall for consumer #{self.name}"
-      pulp_task = Runcible::Extensions::Consumer.uninstall_content(self.uuid, 'package_group', groups)
+      pulp_task = Katello.pulp_server.extensions.consumer.uninstall_content(self.uuid, 'package_group', groups)
     rescue => e
       Rails.logger.error "Failed to schedule package group uninstall for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
       raise e
     end
 
     def install_consumer_errata errata_ids
       Rails.logger.debug "Scheduling errata install for consumer #{self.name}"
-      pulp_task = Runcible::Extensions::Consumer.install_content(self.uuid, 'erratum', errata_ids, {"importkeys" => true})
+      pulp_task = Katello.pulp_server.extensions.consumer.install_content(self.uuid, 'erratum', errata_ids, {"importkeys" => true})
     rescue => e
       Rails.logger.error "Failed to schedule errata install for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
       raise e
@@ -200,7 +200,7 @@ def save_pulp_orchestration
     private
 
     def fetch_package_profile
-      Runcible::Extensions::Consumer.retrieve_profile(uuid, 'rpm')
+      Katello.pulp_server.extensions.consumer.retrieve_profile(uuid, 'rpm')
     rescue RestClient::ResourceNotFound =>e
       {:profile=>[]}.with_indifferent_access
     end

app/models/glue/pulp/consumer_group.rb

@@ -18,7 +18,7 @@ def self.included(base)
     base.send :include, LazyAccessor
 
     base.class_eval do
-      lazy_accessor  :consumer_ids, :initializer => lambda { |s| Runcible::Extensions::ConsumerGroup.retrieve(pulp_id) }
+      lazy_accessor  :consumer_ids, :initializer => lambda { |s| Katello.pulp_server.extensions.consumer_group.retrieve(pulp_id) }
 
       before_save     :save_consumer_group_orch
       before_destroy  :destroy_consumer_group_orch
@@ -33,15 +33,15 @@ module InstanceMethods
     def set_pulp_consumer_group
       consumer_ids = self.systems.collect { |system| system.uuid }
       Rails.logger.debug "creating pulp consumer group '#{self.pulp_id}'"
-      Runcible::Extensions::ConsumerGroup.create(self.pulp_id, :description=>self.description, :consumer_ids=>(consumer_ids || []))
+      Katello.pulp_server.extensions.consumer_group.create(self.pulp_id, :description=>self.description, :consumer_ids=>(consumer_ids || []))
     rescue => e
       Rails.logger.error "Failed to create pulp consumer group #{self.pulp_id}: #{e}, #{e.backtrace.join("\n")}"
       raise e
     end
 
     def del_pulp_consumer_group
       Rails.logger.debug "deleting pulp consumer group '#{self.pulp_id}'"
-      Runcible::Extensions::ConsumerGroup.delete(self.pulp_id)
+      Katello.pulp_server.extensions.consumer_group.delete(self.pulp_id)
     rescue => e
       Rails.logger.error "Failed to delete pulp consumer group #{self.pulp_id}: #{e}, #{e.backtrace.join("\n")}"
       raise e
@@ -53,7 +53,7 @@ def add_consumer(system)
 
     def add_consumers(id_list)
       Rails.logger.debug "adding consumers to pulp consumer group '#{self.pulp_id}'"
-      Runcible::Extensions::ConsumerGroup.add_consumers_by_id(pulp_id, id_list)
+      Katello.pulp_server.extensions.consumer_group.add_consumers_by_id(pulp_id, id_list)
     rescue => e
       Rails.logger.error "Failed to add consumers to pulp consumer group  #{self.pulp_id}: #{e}, #{e.backtrace.join("\n")}"
       raise e
@@ -65,7 +65,7 @@ def remove_consumer(system)
 
     def remove_consumers(id_list)
       Rails.logger.debug "removing consumers from pulp consumer group '#{self.pulp_id}'"
-      Runcible::Extensions::ConsumerGroup.remove_consumers_by_id(pulp_id, id_list)
+      Katello.pulp_server.extensions.consumer_group.remove_consumers_by_id(pulp_id, id_list)
     rescue => e
       Rails.logger.error "Failed to remove consumers from consumer group #{self.pulp_id}: #{e}, #{e.backtrace.join("\n")}"
       raise e
@@ -74,7 +74,7 @@ def remove_consumers(id_list)
     def install_package(packages)
       Rails.logger.debug "Scheduling package install for consumer group #{self.pulp_id}"
 
-      pulp_task = Runcible::Extensions::ConsumerGroup.install_content(self.pulp_id,
+      pulp_task = Katello.pulp_server.extensions.consumer_group.install_content(self.pulp_id,
                                                                       'rpm',
                                                                       packages,
                                                                       {'importkeys' => true})
@@ -86,7 +86,7 @@ def install_package(packages)
     def uninstall_package(packages)
       Rails.logger.debug "Scheduling package uninstall for consumer group #{self.pulp_id}"
 
-      pulp_task = Runcible::Extensions::ConsumerGroup.uninstall_content(self.pulp_id,
+      pulp_task = Katello.pulp_server.extensions.consumer_group.uninstall_content(self.pulp_id,
                                                                         'rpm',
                                                                         packages)
     rescue => e
@@ -99,7 +99,7 @@ def update_package(packages)
 
       options = {"importkeys" => true}
       options[:all] = true if packages.blank?
-      pulp_task = Runcible::Extensions::ConsumerGroup.update_content(self.pulp_id,
+      pulp_task = Katello.pulp_server.extensions.consumer_group.update_content(self.pulp_id,
                                                                      'rpm',
                                                                      packages,
                                                                      options)
@@ -111,7 +111,7 @@ def update_package(packages)
     def install_package_group(groups)
       Rails.logger.debug "Scheduling package group install for consumer group #{self.pulp_id}"
 
-      pulp_task = Runcible::Extensions::ConsumerGroup.install_content(self.pulp_id,
+      pulp_task = Katello.pulp_server.extensions.consumer_group.install_content(self.pulp_id,
                                                                       'package_group',
                                                                       groups,
                                                                       {'importkeys' => true})
@@ -123,7 +123,7 @@ def install_package_group(groups)
     def uninstall_package_group(groups)
       Rails.logger.debug "Scheduling package group uninstall for consumer group #{self.pulp_id}"
 
-      pulp_task = Runcible::Extensions::ConsumerGroup.uninstall_content(self.pulp_id,
+      pulp_task = Katello.pulp_server.extensions.consumer_group.uninstall_content(self.pulp_id,
                                                                         'package_group',
                                                                         groups)
     rescue => e
@@ -134,7 +134,7 @@ def uninstall_package_group(groups)
     def install_consumer_errata(errata_ids)
       Rails.logger.debug "Scheduling errata install for consumer group #{self.pulp_id}"
 
-      pulp_task = Runcible::Extensions::ConsumerGroup.install_content(self.pulp_id,
+      pulp_task = Katello.pulp_server.extensions.consumer_group.install_content(self.pulp_id,
                                                                       'erratum',
                                                                       errata_ids,
                                                                       {'importkeys' => true})

app/models/glue/pulp/distribution.rb

@@ -19,7 +19,7 @@ def self.included(base)
       attr_accessor :_id, :id, :description, :files, :family, :variant, :version, :url, :arch
 
       def self.find(id)
-        ::Distribution.new(Runcible::Extensions::Distribution.find(id))
+        ::Distribution.new(Katello.pulp_server.extensions.distribution.find(id))
       end
     end
   end

app/models/glue/pulp/errata.rb

@@ -26,22 +26,22 @@ def self.included(base)
                     :reboot_suggested, :references, :pkglist, :severity, :repoids
 
       def self.errata_by_consumer(repos)
-        errata = Runcible::Extensions::Consumer.applicable_errata([], repos.map(&:pulp_id), false)
+        errata = Katello.pulp_server.extensions.consumer.applicable_errata([], repos.map(&:pulp_id), false)
         errata[:erratum] || []
       end
 
       def self.find(id)
-        erratum_attrs = Runcible::Extensions::Errata.find_by_unit_id(id)
+        erratum_attrs = Katello.pulp_server.extensions.errata.find_by_unit_id(id)
         ::Errata.new(erratum_attrs) if not erratum_attrs.nil?
       end
 
       def self.find_by_errata_id(id)
-        erratum_attrs = Runcible::Extensions::Errata.find(id)
+        erratum_attrs = Katello.pulp_server.extensions.errata.find(id)
         ::Errata.new(erratum_attrs) if not erratum_attrs.nil?
       end
 
       def self.list_by_filter_clauses(clauses)
-        errata = Runcible::Extensions::Errata.search(::Errata::CONTENT_TYPE,
+        errata = Katello.pulp_server.extensions.errata.search(::Errata::CONTENT_TYPE,
                                 :filters => clauses)
         if errata
           errata.collect do |attrs|

app/models/glue/pulp/package.rb

@@ -28,7 +28,7 @@ def self.included(base)
       alias_method 'id', '_id'
 
       def self.find(id)
-        package_attrs = Runcible::Extensions::Rpm.find_by_unit_id(id)
+        package_attrs = Katello.pulp_server.extensions.rpm.find_by_unit_id(id)
         return if package_attrs.nil?
         Package.new(package_attrs) if package_attrs
       rescue RestClient::ResourceNotFound => exception