runcible 0.4.12 → 1.0.0

data/README.md

@@ -4,7 +4,7 @@
 
 Exposing Pulp's juiciest parts. http://www.pulpproject.org/
 
-Latest Live Tested Version: **pulp-server-2.2.0-0.20.beta.el6.noarch**
+Latest Live Tested Version: **pulp-server-2.2.0-0.22.beta.el6.noarch**
 
 Current stable Runcible: https://github.com/Katello/runcible/tree/0.3
 
@@ -28,16 +28,28 @@ Or install it yourself as:
 
 ### Set Configuration
 
-The base configuration allows for the following to be set.
+To use a single resource or extension, the configuration can be set:
 
-    Runcible::Base.config = { 
+    repo_api = Runcible::Resources::Repository.new({
                 :url      => "",
                 :api_path => "",
                 :user     => "",
                 :logger   => ""
-              }
+              })
+    repo_api.find(id)
 
-Required Configuration
+Alternatively, a single 'server' instance which can easily use all 
+  resources and extensions can be instantiated:
+
+    my_runcible = Runcible::Instance.new({
+                :url      => "",
+                :api_path => "",
+                :user     => "",
+                :logger   => ""
+              })
+     runcible.resources.repository.find(id)
+
+Required Configuration:
 
     :uri      => The base URI of the Pulp server (default: https://localhost)
     :api_path => The API path of the Pulp server (default: pulp/api/v2/)
@@ -55,7 +67,7 @@ For an example on parsing the Pulp server.conf and using values provided within
 
 ### Make a Request
 
-Runcible provides two represntation's of Pulp entities to make API calls: [resources](https://github.com/Katello/runcible/tree/master/lib/runcible/resources) and [extensions](https://github.com/Katello/runcible/tree/master/lib/runcible/extensions)
+Runcible provides two representations of Pulp entities to make API calls: [resources](https://github.com/Katello/runcible/tree/master/lib/runcible/resources) and [extensions](https://github.com/Katello/runcible/tree/master/lib/runcible/extensions)
 
 The best examples of how to use either the resources or extensions can be found within the [tests](https://github.com/Katello/runcible/tree/master/test/integration)
 
@@ -63,22 +75,39 @@ The best examples of how to use either the resources or extensions can be found
 
 Resources are designed to be one-for-one with the Pulp API calls in terms of required parameters and naming of the calls.  For example, in order to create a repository, associate a Yum importer and a distributor:
 
-    Runcible::Resources::Repository.create("Repository_ID")
-    Runcible::Resources::Repository.associate_importer("Repository_ID", "yum_importer", {})
-    Runcible::Resources::Repository.associate_distributor("Repository_ID", "yum_distributor", {"relative_url" => "/", "http" => true, "https" => true})
+    my_runcible = Runcible::Instance.new(config)
+    my_runcible.resources.repository.create("Repository_ID")
+    my_runcible.resources.repository.associate_importer("Repository_ID", "yum_importer", {})
+    my_runcible.resources.repository.associate_distributor("Repository_ID", "yum_distributor", {"relative_url" => "/", "http" => true, "https" => true})
+
+    or
+
+    Runcible::Resources::Repository.new(config).create("Repository_ID")
+    Runcible::Resources::Repository.new(config).associate_importer("Repository_ID", "yum_importer", {})
+    Runcible::Resources::Repository.new(config).associate_distributor("Repository_ID", "yum_distributor", {"relative_url" => "/", "http" => true, "https" => true})
 
 #### Extensions
 
 Extensions are constructs around the Pulp API that make retrieving, accessing or creating certain data types easier.  For example, providing objects that represent the details of a yum importer or distributor, and providing functions to create a Repository with an importer and distributors in a single call.  The same three step process above using extensions is:
 
-    Runcible::Extensions::Repository.create_with_importer_and_distributors("Repository_ID", {:id=>'yum_importer'}, [{'type_id' => 'yum_distributor', 'id'=>'123', 'auto_publish'=>true, 'config'=>{'relative_url' => '/', 'http' => true, 'https' => true}}])
+    my_runcible = Runcible::Instance.new(config)
+    my_runcible.extensions.repository.create_with_importer_and_distributor("Repository_ID", {:id=>'yum_importer'}, [{'type_id' => 'yum_distributor', 'id'=>'123', 'auto_publish'=>true, 'config'=>{'relative_url' => '/', 'http' => true, 'https' => true}}])
+
+    or
+
+    Runcible::Extensions::Repository.new(config).create_with_importer_and_distributors("Repository_ID", {:id=>'yum_importer'}, [{'type_id' => 'yum_distributor', 'id'=>'123', 'auto_publish'=>true, 'config'=>{'relative_url' => '/', 'http' => true, 'https' => true}}])
 
 Alternatively, using distributor and importer objects:
 
-    distributors = [Runcible::Extensions::YumDistributor.new('/path', true, true, :id => '123')]
-    importer = Runcible::Extensions::YumImporter.new()
-    Runcible::Extensions::Repository.create_with_importer_and_distributors("Repository_ID", importer, distributors)
+    distributors = [Runcible::Models::YumDistributor.new('/path', true, true, :id => '123')]
+    importer = Runcible::Models::YumImporter.new()
+
+    my_runcible = Runcible::Instance.new(config)
+    my_runcible.extensions.repository.create_with_importer_and_distributors("Repository_ID", importer, distributors)
+
+    or
 
+    Runcible::Extensions::Repository.new(config).create_with_importer_and_distributors("Repository_ID", importer, distributors)
 
 ## Testing
 

data/Rakefile

@@ -16,7 +16,7 @@ namespace :test do
     t.pattern = 'test/unit/test_*.rb'
   end
 
-  [:resources, :extensions].each do |task_name|
+  [:resources, :extensions, :unit].each do |task_name|
     desc "Runs the #{task_name} tests"
     task task_name do
       options = {}
@@ -60,22 +60,6 @@ task :update_test_version do
   end
 end
 
-desc "Finds functions without dedicated tests"
-task :untested do
-  test_functions  = `grep -r 'def test_' test/ --exclude-dir=test/fixtures --include=*.rb --no-filename` 
-  lib_functions   = `grep -r 'def self' lib/ --exclude=base.rb --include=*.rb --no-filename`
-  
-  test_functions  = test_functions.split("\n").map{ |str| str.strip.split("def test_")[1] }.to_set
-  lib_functions   = lib_functions.split("\n").map{ |str| str.strip.split("def self.")[1].split("(").first }.to_set
-
-  difference = (lib_functions - test_functions).to_a
-
-  if !difference.empty?
-    puts difference
-    exit 1 
-  end
-end
-
 desc "Clears out all cassette files"
 task :clear_cassettes do
   clear_cassettes

data/lib/runcible/base.rb

@@ -29,37 +29,23 @@ require 'json'
 module Runcible
   class Base
 
-    # Accepted Configuration Values
-    # 
-    # :user     Pulp username
-    # :password Password for this user
-    # :oauth    Oauth credentials
-    # :headers  Additional headers e.g. content-type => "application/json"
-    # :url      Scheme and hostname for the pulp server e.g. https://localhost/
-    # :api_path URL path for the api e.g. pulp/api/v2/
-    # :timeout  timeout in seconds for the connection (defaults to rest client's default)
-    # :open_timeout  timeout in seconds for the connection to open(defaults to rest client's default)
-    def self.config=(conf={})
-      @@config = {
-        :api_path   => '/pulp/api/v2/',
-        :url        => 'https://localhost',
-        :user       => '',
-        :http_auth  => {:password => {} },
-        :headers    => {:content_type => 'application/json',
-                        :accept       => 'application/json'},
-        :logging    => {}
-      }.merge(conf)
-    end
-
-    def self.config
-      if defined?(@@config)
-        @@config
+    def initialize(config={})
+      @config = config
+    end
+
+    def config
+      if defined?(@config)
+        @config
       else
         raise Runcible::ConfigurationUndefinedError, Runcible::ConfigurationUndefinedError.message
       end
     end
 
-    def self.call(method, path, options={})
+    def path(*args)
+      self.class.path(*args)
+    end
+
+    def call(method, path, options={})
       clone_config = self.config.clone
       #on occation path will already have prefix (sync cancel)
       path = clone_config[:api_path] + path if !path.start_with?(clone_config[:api_path])
@@ -100,7 +86,7 @@ module Runcible
       raise e
     end
 
-    def self.get_response(client, path, *args)
+    def get_response(client, path, *args)
       client[path].send(*args) do |response, request, result, &block|
         resp = response.return!(request, result)
         log_debug
@@ -108,7 +94,7 @@ module Runcible
       end
     end
 
-    def self.combine_get_params(path, params)
+    def combine_get_params(path, params)
       query_string  = params.collect do |k, v|
         if v.is_a? Array
           v.collect{|y| "#{k.to_s}=#{y.to_s}" }.join('&')
@@ -119,7 +105,7 @@ module Runcible
       path + "?#{query_string}"
     end
 
-    def self.generate_payload(options)
+    def generate_payload(options)
       if options[:payload]
         if options[:payload][:optional]
           if options[:payload][:required]
@@ -139,7 +125,7 @@ module Runcible
       return payload.to_json
     end
 
-    def self.process_response(response)
+    def process_response(response)
       begin
         body = JSON.parse(response.body)
         if body.respond_to? :with_indifferent_access
@@ -156,7 +142,7 @@ module Runcible
       return response
     end
 
-    def self.required_params(local_names, binding, keys_to_remove=[])
+    def required_params(local_names, binding, keys_to_remove=[])
       local_names = local_names.reduce({}) do |acc, v|
         value = binding.eval(v.to_s) unless v == :_
         acc[v] = value unless value.nil?
@@ -176,11 +162,11 @@ module Runcible
       return local_names
     end
 
-    def self.add_http_auth_header
+    def add_http_auth_header
       return {:user => config[:user], :password => config[:http_auth][:password]}
     end
 
-    def self.add_oauth_header(method, path, headers)
+    def add_oauth_header(method, path, headers)
       default_options = { :site               => config[:url],
                           :http_method        => method,
                           :request_token_path => "",
@@ -202,24 +188,28 @@ module Runcible
       return headers
     end
 
-    def self.log_debug
+    def log_debug
       if self.config[:logging][:debug]
         log_message = generate_log_message                  
         self.config[:logging][:logger].debug(log_message)
       end
     end
 
-    def self.log_exception
+    def log_exception
       if self.config[:logging][:exception]
         log_message = generate_log_message
         self.config[:logging][:logger].error(log_message)
       end
     end
 
-    def self.generate_log_message
+    def generate_log_message
       RestClient.log.join('\n')
     end
 
+    def logger
+      self.config[:logging][:logger]
+    end
+
   end 
 
   class ConfigurationUndefinedError < StandardError

data/lib/runcible/extensions/consumer.rb

@@ -32,9 +32,9 @@ module Runcible
       # @param  [String]               repo_id  the repo ID to bind to
       # @param  [Boolean]              notify_agent sends consumer a notification
       # @return [RestClient::Response]          set of tasks representing each bind operation
-      def self.bind_all(id, repo_id, notify_agent=true)
-        Runcible::Extensions::Repository.retrieve_with_details(repo_id)['distributors'].collect do |d|
-          self.bind(id, repo_id, d['id'], {:notify_agent=>notify_agent})
+      def bind_all(id, repo_id, notify_agent=true)
+        repository_extension.retrieve_with_details(repo_id)['distributors'].collect do |d|
+          bind(id, repo_id, d['id'], {:notify_agent=>notify_agent})
         end.flatten
       end
 
@@ -43,9 +43,9 @@ module Runcible
       # @param  [String]               id       the consumer ID
       # @param  [String]               repo_id  the repo ID to unbind from
       # @return [RestClient::Response]          set of tasks representing each unbind operation
-      def self.unbind_all(id, repo_id)
-        Runcible::Extensions::Repository.retrieve_with_details(repo_id)['distributors'].collect do |d|
-          self.unbind(id, repo_id, d['id'])
+      def unbind_all(id, repo_id)
+        repository_extension.retrieve_with_details(repo_id)['distributors'].collect do |d|
+          unbind(id, repo_id, d['id'])
         end.flatten
       end
 
@@ -56,8 +56,8 @@ module Runcible
       # @param  [Array]                units    array of units to install
       # @param  [Hash]                 options to pass to content install
       # @return [RestClient::Response]          task representing the install operation
-      def self.install_content(id, type_id, units, options={})
-        self.install_units(id, generate_content(type_id, units), options)
+      def install_content(id, type_id, units, options={})
+        install_units(id, generate_content(type_id, units), options)
       end
 
       # Update content on a consumer
@@ -67,8 +67,8 @@ module Runcible
       # @param  [Array]                units    array of units to update
       # @param  [Hash]                 options to pass to content update
       # @return [RestClient::Response]          task representing the update operation
-      def self.update_content(id, type_id, units, options={})
-        self.update_units(id, generate_content(type_id, units, options), options)
+      def update_content(id, type_id, units, options={})
+        update_units(id, generate_content(type_id, units, options), options)
       end
 
       # Uninstall content from a consumer
@@ -77,8 +77,8 @@ module Runcible
       # @param  [String]               type_id  the type of content to uninstall (e.g. rpm, errata)
       # @param  [Array]                units    array of units to uninstall
       # @return [RestClient::Response]          task representing the uninstall operation
-      def self.uninstall_content(id, type_id, units)
-        self.uninstall_units(id, generate_content(type_id, units))
+      def uninstall_content(id, type_id, units)
+        uninstall_units(id, generate_content(type_id, units))
       end
 
       # Generate the content units used by other functions
@@ -87,7 +87,7 @@ module Runcible
       # @param  [Array]   units   array of units
       # @param  [Hash]    options contains options which may impact the format of the content (e.g :all => true)
       # @return [Array]           array of formatted content units
-      def self.generate_content(type_id, units, options={})
+      def generate_content(type_id, units, options={})
         content = []
 
         case type_id
@@ -123,7 +123,7 @@ module Runcible
       #                                                 applicable errata; otherwise, it will list
       #                                                 errata and the consumers they are applicable to
       # @return [RestClient::Response]  content applicability hash with details of errata available to consumer(s)
-      def self.applicable_errata(ids, repoids = [], consumer_report = true)
+      def applicable_errata(ids, repoids = [], consumer_report = true)
 
         ids = [ids] if ids.is_a? String
         consumer_criteria = { 'filters' => { 'id' => { '$in' => ids } } } unless ids.empty?
@@ -136,7 +136,14 @@ module Runcible
           'unit_criteria' => { 'erratum' => { } },
           'override_config' => { 'report_style' => report_style }
         }
-        self.applicability(criteria)
+        applicability(criteria)
+      end
+
+
+      private
+
+      def repository_extension
+        Runcible::Extensions::Repository.new(self.config)
       end
 
     end

data/lib/runcible/extensions/consumer_group.rb

@@ -31,8 +31,8 @@ module Runcible
       # @param  [String]                id            the consumer group ID
       # @param  [Array]                 consumer_ids  array of consumer IDs to add to the group
       # @return [RestClient::Response]                list of consumer IDs
-      def self.add_consumers_by_id(id, consumer_ids)
-        self.associate(id, make_consumer_criteria(consumer_ids))
+      def add_consumers_by_id(id, consumer_ids)
+        associate(id, make_consumer_criteria(consumer_ids))
       end
 
       # Remove consumers by ID from a consumer group
@@ -40,15 +40,15 @@ module Runcible
       # @param  [String]                id            the consumer group ID
       # @param  [Array]                 consumer_ids  array of consumer IDs to remove from the group
       # @return [RestClient::Response]                list of consumer IDs
-      def self.remove_consumers_by_id(id, consumer_ids)
-        self.unassociate(id, make_consumer_criteria(consumer_ids))
+      def remove_consumers_by_id(id, consumer_ids)
+        unassociate(id, make_consumer_criteria(consumer_ids))
       end
 
       # Generates consumer criteria query
       #
       # @param  [Array] consumer_ids  array of consumer IDs
       # @return [Hash]                the formatted query for consumers
-      def self.make_consumer_criteria(consumer_ids)
+      def make_consumer_criteria(consumer_ids)
         {:criteria =>
               {:filters =>
                 {:id =>{"$in" =>consumer_ids}}
@@ -63,8 +63,8 @@ module Runcible
       # @param  [Array]                units    array of units to install
       # @param  [Hash]                 options  to pass to content install
       # @return [RestClient::Response]          task representing the install operation
-      def self.install_content(id, type_id, units, options={})
-        self.install_units(id, generate_content(type_id, units), options)
+      def install_content(id, type_id, units, options={})
+        install_units(id, generate_content(type_id, units), options)
       end
 
       # Update content on a consumer group
@@ -74,8 +74,8 @@ module Runcible
       # @param  [Array]                units    array of units to update
       # @param  [Hash]                 options  to pass to content update
       # @return [RestClient::Response]          task representing the update operation
-      def self.update_content(id, type_id, units, options={})
-        self.update_units(id, generate_content(type_id, units, options), options)
+      def update_content(id, type_id, units, options={})
+        update_units(id, generate_content(type_id, units, options), options)
       end
 
       # Uninstall content from a consumer group
@@ -84,8 +84,8 @@ module Runcible
       # @param  [String]               type_id  the type of content to uninstall (e.g. rpm, errata)
       # @param  [Array]                units    array of units to uninstall
       # @return [RestClient::Response]          task representing the uninstall operation
-      def self.uninstall_content(id, type_id, units)
-        self.uninstall_units(id, generate_content(type_id, units))
+      def uninstall_content(id, type_id, units)
+        uninstall_units(id, generate_content(type_id, units))
       end
 
       # Generate the content units used by other functions
@@ -94,7 +94,7 @@ module Runcible
       # @param  [Array]   units   array of units
       # @param  [Hash]    options contains options which may impact the format of the content (e.g :all => true)
       # @return [Array]           array of formatted content units
-      def self.generate_content(type_id, units, options={})
+      def generate_content(type_id, units, options={})
         content = []
 
         case type_id

data/lib/runcible/extensions/repository.rb

@@ -31,7 +31,7 @@ module Runcible
       # @param  [String]                               id       the id of the repository being created
       # @param  [Hash, Runcible::Extensions::Importer] importer either a hash representing an importer or an Importer object
       # @return [RestClient::Response]                          the created repository         
-      def self.create_with_importer(id, importer)
+      def create_with_importer(id, importer)
         create_with_importer_and_distributors(id, importer)
       end
 
@@ -40,7 +40,7 @@ module Runcible
       # @param  [String]                id            the id of the repository being created
       # @param  [Array]                 distributors  an array of hashes representing distributors or an array of Distributor objects
       # @return [RestClient::Response]                the created repository         
-      def self.create_with_distributors(id, distributors)
+      def create_with_distributors(id, distributors)
         create_with_importer_and_distributors(id, nil, distributors)
       end
 
@@ -51,8 +51,8 @@ module Runcible
       # @param  [Array]                                 distributors  an array of hashes representing distributors or an array of Distributor objects
       # @param  [Hash]                                  optional      container for all optional parameters
       # @return [RestClient::Response]                                the created repository         
-      def self.create_with_importer_and_distributors(id, importer, distributors=[], optional={})
-        if importer.is_a?(Importer)
+      def create_with_importer_and_distributors(id, importer, distributors=[], optional={})
+        if importer.is_a?(Runcible::Models::Importer)
           optional[:importer_type_id] = importer.id
           optional[:importer_config] = importer.config
         else
@@ -61,7 +61,7 @@ module Runcible
         end if importer
 
         optional[:distributors] = distributors.collect do |d|
-          if d.is_a?(Distributor)
+          if d.is_a?(Runcible::Models::Distributor)
             {'distributor_type' => d.type_id,
               "distributor_config" => d.config,
               "auto_publish" => d.auto_publish,
@@ -83,23 +83,23 @@ module Runcible
       #
       # @param  [String]                repo_id the repository ID
       # @return [RestClient::Response]          a task representing the sync status
-      def self.sync_status(repo_id)
-        Runcible::Resources::Task.list(["pulp:repository:#{repo_id}", "pulp:action:sync"])
+      def sync_status(repo_id)
+        Runcible::Resources::Task.new(self.config).list(["pulp:repository:#{repo_id}", "pulp:action:sync"])
       end
 
       # Retrieves the publish status for a repository
       #
       # @param  [String]                repo_id the repository ID
       # @return [RestClient::Response]          a task representing the sync status
-      def self.publish_status(repo_id)
-        Runcible::Resources::Task.list(["pulp:repository:#{repo_id}", "pulp:action:publish"])
+      def publish_status(repo_id)
+        Runcible::Resources::Task.new(self.config).list(["pulp:repository:#{repo_id}", "pulp:action:publish"])
       end
 
       # Retrieves a set of repositories by their IDs
       #
       # @param  [Array]                repository_ids the repository ID
       # @return [RestClient::Response]                the set of repositories requested
-      def self.search_by_repository_ids(repository_ids)
+      def search_by_repository_ids(repository_ids)
         criteria = {:filters => 
                       { "id" => {"$in" => repository_ids}}
                    }
@@ -111,7 +111,13 @@ module Runcible
       #
       # @param [String]             id the ID of the repository
       # @return [Array<String>]     the array of repository RPM IDs
-      def self.rpm_ids(id)
+
+      def rpm_ids(id)
+        criteria = {:type_ids=>[Runcible::Extensions::Rpm.content_type],
+                            :fields=>{:unit=>[], :association=>['unit_id']}}
+        self.unit_search(id, criteria).collect{|i| i['unit_id']}
+      rescue RestClient::RequestTimeout
+        self.logger.warn("Call to rpm_ids timed out")
         # lazy evaluated iterator from zero to infinite
         pages = Enumerator.new { |y| page = 0; loop { y << page; page += 1 } }
 
@@ -122,7 +128,7 @@ module Runcible
                         :fields   => { :unit => [], :association => ['unit_id'] },
                         :limit    => page_size,
                         :skip     => 0 + page*page_size }
-          result    = self.unit_search(id, criteria).collect { |i| i['unit_id'] }
+          result    = unit_search(id, criteria).collect { |i| i['unit_id'] }
           rpm_ids.concat(result)
           if result.empty? || result.size < 500
             break rpm_ids
@@ -136,9 +142,9 @@ module Runcible
       #
       # @param  [String]                id the ID of the repository
       # @return [RestClient::Response]     the set of repository RPMs
-      def self.rpms(id)
+      def rpms(id)
         criteria = {:type_ids=>[Runcible::Extensions::Rpm.content_type]}
-        self.unit_search(id, criteria).collect{|i| i['metadata'].with_indifferent_access}
+        unit_search(id, criteria).collect{|i| i['metadata'].with_indifferent_access}
       end
 
       # Retrieves the RPMs by NVRE for a single repository
@@ -149,7 +155,7 @@ module Runcible
       # @param  [String]                release the release of the RPMs
       # @param  [String]                epoch   the epoch of the RPMs
       # @return [RestClient::Response]          the set of repository RPMs
-      def self.rpms_by_nvre(id, name, version=nil, release=nil, epoch=nil)
+      def rpms_by_nvre(id, name, version=nil, release=nil, epoch=nil)
         and_condition = []
         and_condition << {:name=>name} if name
         and_condition << {:version=>version} if version
@@ -165,56 +171,56 @@ module Runcible
                 :sort => {
                     :unit => [ ['name', 'ascending'], ['version', 'descending'] ]
                 }}
-        self.unit_search(id, criteria).collect{|p| p['metadata'].with_indifferent_access}
+        unit_search(id, criteria).collect{|p| p['metadata'].with_indifferent_access}
       end
 
       # Retrieves the errata IDs for a single repository
       #
       # @param  [String]                id the ID of the repository
       # @return [RestClient::Response]     the set of repository errata IDs
-      def self.errata_ids(id)
+      def errata_ids(id)
          criteria = {:type_ids=>[Runcible::Extensions::Errata.content_type],
                      :fields=>{:unit=>[], :association=>['unit_id']}}
 
-         self.unit_search(id, criteria).collect{|i| i['unit_id']}
+         unit_search(id, criteria).collect{|i| i['unit_id']}
       end
 
       # Retrieves the errata for a single repository
       #
       # @param  [String]                id the ID of the repository
       # @return [RestClient::Response]     the set of repository errata
-      def self.errata(id)
+      def errata(id)
          criteria = {:type_ids=>[Runcible::Extensions::Errata.content_type]}
-         self.unit_search(id, criteria).collect{|i| i['metadata'].with_indifferent_access}
+         unit_search(id, criteria).collect{|i| i['metadata'].with_indifferent_access}
       end
 
       # Retrieves the distributions for a single repository
       #
       # @param  [String]                id the ID of the repository
       # @return [RestClient::Response]     the set of repository distributions
-      def self.distributions(id)
+      def distributions(id)
         criteria = {:type_ids=>[Runcible::Extensions::Distribution.content_type]}
 
-        self.unit_search(id, criteria).collect{|i| i['metadata'].with_indifferent_access}
+        unit_search(id, criteria).collect{|i| i['metadata'].with_indifferent_access}
       end
 
       # Retrieves the package groups for a single repository
       #
       # @param  [String]                id the ID of the repository
       # @return [RestClient::Response]     the set of repository package groups
-      def self.package_groups(id)
+      def package_groups(id)
         criteria = {:type_ids=>[Runcible::Extensions::PackageGroup.content_type]}
 
-        self.unit_search(id, criteria).collect{|i| i['metadata'].with_indifferent_access}
+        unit_search(id, criteria).collect{|i| i['metadata'].with_indifferent_access}
       end
 
       # Retrieves the package group categoriess for a single repository
       #
       # @param  [String]                id the ID of the repository
       # @return [RestClient::Response]     the set of repository package group categories
-      def self.package_categories(id)
+      def package_categories(id)
         criteria = {:type_ids=>[Runcible::Extensions::PackageCategory.content_type]}
-        self.unit_search(id, criteria).collect{|i| i['metadata'].with_indifferent_access}
+        unit_search(id, criteria).collect{|i| i['metadata'].with_indifferent_access}
       end
 
       # Creates or updates a sync schedule for a repository
@@ -223,12 +229,12 @@ module Runcible
       # @param  [String]                type      the importer type
       # @param  [String]                schedule  the time as an iso8601 interval
       # @return [RestClient::Response]            the newly created or updated schedule
-      def self.create_or_update_schedule(repo_id, type, schedule)
-        schedules = Runcible::Resources::RepositorySchedule.list(repo_id, type)
+      def create_or_update_schedule(repo_id, type, schedule)
+        schedules = Runcible::Resources::RepositorySchedule.new(self.config).list(repo_id, type)
         if schedules.empty?
-          Runcible::Resources::RepositorySchedule.create(repo_id, type, schedule)
+          Runcible::Resources::RepositorySchedule.new(self.config).create(repo_id, type, schedule)
         else
-          Runcible::Resources::RepositorySchedule.update(repo_id, type, schedules[0]['_id'], {:schedule=>schedule})
+          Runcible::Resources::RepositorySchedule.new(self.config).update(repo_id, type, schedules[0]['_id'], {:schedule=>schedule})
         end
       end
 
@@ -237,10 +243,10 @@ module Runcible
       # @param  [String]                repo_id   the ID of the repository
       # @param  [String]                type      the importer type
       # @return [RestClient::Response]            
-      def self.remove_schedules(repo_id, type)
-        schedules = Runcible::Resources::RepositorySchedule.list(repo_id, type)
+      def remove_schedules(repo_id, type)
+        schedules = Runcible::Resources::RepositorySchedule.new(self.config).list(repo_id, type)
         schedules.each do |schedule|
-          Runcible::Resources::RepositorySchedule.delete(repo_id, type, schedule['_id'])
+          Runcible::Resources::RepositorySchedule.new(self.config).delete(repo_id, type, schedule['_id'])
         end
       end
 
@@ -248,10 +254,10 @@ module Runcible
       #
       # @param  [String]                repo_id the ID of the repository
       # @return [RestClient::Response]          set of tasks representing each publish  
-      def self.publish_all(repo_id)
+      def publish_all(repo_id)
         to_ret = []
-        self.retrieve_with_details(repo_id)['distributors'].each do |d|
-          to_ret << self.publish(repo_id, d['id'])
+        retrieve_with_details(repo_id)['distributors'].each do |d|
+          to_ret << publish(repo_id, d['id'])
         end
         to_ret
       end
@@ -260,8 +266,8 @@ module Runcible
       #
       # @param  [String]                repo_id the ID of the repository
       # @return [RestClient::Response]          the repository with full details
-      def self.retrieve_with_details(repo_id)
-        self.retrieve(repo_id, {:details => true})
+      def retrieve_with_details(repo_id)
+        retrieve(repo_id, {:details => true})
       end
 
     end