pulp 0.0.8

data/examples/test_pulp.yml

@@ -0,0 +1,4 @@
+hostname: localhost
+username: admin
+password: admin
+debug: false

data/lib/pulp.rb

@@ -0,0 +1,26 @@
+require 'rest_client'
+require 'json'
+require 'active_support/inflector'
+
+require 'pulp/common/debug'
+require 'pulp/common/lifecycle'
+require 'pulp/common/lifecycle/create'
+require 'pulp/common/lifecycle/delete'
+require 'pulp/common/lifecycle/get'
+require 'pulp/common/lifecycle/update'
+require 'pulp/connection/base'
+require 'pulp/connection/handler'
+
+# types
+%w{consumer consumergroup content distribution errata event filter task_snapshot task
+  cds package package_group package_group_category repository service task_history user}.each {|type| require "pulp/#{type}" }
+
+
+if file = [ ENV['PULP_YML'], File.expand_path('~/.pulp.yaml'),'/etc/pulp/pulp.yaml' ].find{|f| f && File.exists?(f) }
+  require 'yaml'
+  global_options = YAML.load_file(file)
+  Pulp::Connection::Handler.hostname = global_options['hostname']
+  Pulp::Connection::Handler.username = global_options['username']
+  Pulp::Connection::Handler.password = global_options['password']
+  Pulp::Connection::Handler.debug_enabled = global_options['debug']||false
+end

data/lib/pulp/cds.rb

@@ -0,0 +1,25 @@
+module Pulp
+  class Cds < Pulp::Connection::Base
+    
+    has_crud
+
+    pulp_fields :cluster_id, :description, :hostname, :name, :sync_schedule
+    
+    pulp_locked_fields :repo_ids, :last_sync , :secret, :hearbeat
+
+    pulp_action :associate, :params => true, :returns => Pulp::Task
+    pulp_action :unassociate, :params => true, :returns => Pulp::Task
+
+    pulp_action :history, :params => true
+
+    pulp_action :sync, :params => false, :returns => Pulp::Task, :task_list => true
+
+    def history(action)
+      self.class.base_get("history/#{action}/",self.id).collect{|th| Pulp::TaskHistory.new(th) }
+    end
+    
+    def repositories
+      repo_ids.collect{|repo_id| Pulp::Repository.find_by_id(repo_id).first }.compact
+    end
+  end
+end

data/lib/pulp/common/debug.rb

@@ -0,0 +1,37 @@
+module Pulp
+    module Common
+        module Debug
+            def self.included(base)
+                base.extend(ClassMethods)
+            end
+            
+            def debug(msg)
+                self.class.debug(msg)
+            end
+            
+            module ClassMethods
+                def debug_enabled
+                    @debug_enabled ||= false
+                end
+                
+                def debug_enabled=(enable)
+                    @debug_enabled = enable
+                    self.output = self.output # reset output to activate it
+                end
+                
+                def output=(o)
+                    @output = o
+                    RestClient.log = debug_enabled ? output : nil
+                end
+                
+                def output
+                    @output ||= STDERR
+                end
+                
+                def debug(msg)
+                    output.puts msg if @debug_enabled
+                end
+            end
+        end
+    end
+end

data/lib/pulp/common/lifecycle.rb

@@ -0,0 +1,166 @@
+module Pulp
+  module Common
+    module Lifecycle
+      def self.included(base)
+        base.extend ClassMethods
+      end
+      def fields
+        @fields ||= {}
+      end
+      
+      def user_fields
+        @user_fields ||= {}
+      end
+      def record_fields
+        self.class.record_fields
+      end
+      def special_fields
+        self.class.special_fields
+      end
+      
+      def locked_fields
+        self.class.locked_fields
+      end
+      
+      module ClassMethods
+        # Allows for dynamically declaring fields that will come from
+        # Pulp.
+        #
+        def pulp_field(field,options={})
+          locked_fields << field if options[:locked]
+
+          module_eval("def #{field}() user_fields['#{field}'] || fields['#{field}']; end")
+          module_eval("def #{field}=(val) user_fields['#{field}'] = val; end") unless options[:locked]
+          
+          record_fields[field] = options
+        end
+        
+        # Declare many fields at once.
+        def pulp_fields(*fields)
+          fields.to_a.each {|field| pulp_field(field) }
+        end
+
+        def pulp_deferred_field(field,options={})
+          if options[:array]
+            module_eval("def #{field}() self.class.plain_get(fields['#{field}']).collect{|p| #{options[:array]}.new(p) }; end")
+          elsif options[:returns] == :plain
+            module_eval("def #{field}() self.class.plain_base.connection[fields['#{field}'].sub(/^\\/pulp\\/api\\//,'')].get; end")
+          elsif options[:returns]
+            module_eval("def #{field}() (res = self.class.plain_get(fields['#{field}'])).empty? ? nil : #{options[:returns]}.new(res); end")
+          else
+            module_eval("def #{field}() self.class.plain_get(fields['#{field}']); end")
+          end
+          module_eval("def #{field}_link() fields['#{field}']; end")
+        end
+        
+        # Declare many deffered fields at once.
+        def pulp_deferred_fields(*fields)
+          [*fields].each {|field| pulp_deferred_field(field) }
+        end
+        
+        # declare a field that is locked
+        def pulp_locked_field(field,options={})
+          pulp_field field, options.merge(:locked => true)
+        end
+
+        # Declare many locked fields at once.
+        def pulp_locked_fields(*fields)
+          [*fields].each {|field| pulp_locked_field(field) }
+        end
+        
+        # special fields are locked and registered as being special
+        def pulp_special_field(field,options={})
+          pulp_locked_field(field,options)
+          special_fields << field
+        end
+        
+        #Declare multiple special fields at once
+        def pulp_special_fields(*fields)
+          [*fields].each{|f| pulp_special_field(f) }
+        end
+        
+        # optional features
+        def has_collection(options={})
+          
+          instance_eval %{ def all
+            base_get('').collect {|e| self.new(e) }
+          end}
+          
+          options[:all_filters] && options[:all_filters].each do |filter|
+            instance_eval %{
+              def find_by_#{filter}(f)
+                base_get('',nil,{ :#{filter} => f }).collect {|e| self.new(e) }
+              end}
+          end
+        end
+        
+        def has_crud(options={})
+          has_collection(options[:collection]||{})
+          has_create
+          has_get
+          has_update
+          has_delete
+        end
+        
+        def has_delete
+          include Pulp::Common::Lifecycle::Delete
+        end
+        
+        def has_create
+          include Pulp::Common::Lifecycle::Create
+        end
+        
+        def has_get
+          include Pulp::Common::Lifecycle::Get
+        end
+        
+        def has_update
+          include Pulp::Common::Lifecycle::Update
+        end
+        
+        def pulp_action(action_name, options={})
+          options[:method] ||= :post
+          options[:params] = true if options[:params].nil?
+          # default is true
+          slash = (options[:append_slash].nil? || options[:append_slash]) ? '/' : '' 
+          if options[:returns]
+            module_eval %{
+            def #{action_name}(#{"params#{"={}" if options[:params] == :optional}" if options[:params]})
+              #{options[:returns]}.new(self.class.base_#{(options[:parse] == false) ? 'unparsed_' : '' }#{options[:method]}('#{action_name}#{slash}',self.id,#{options[:params] ? 'params' : 'nil' }))
+            end}
+          else
+            module_eval %{
+            def #{action_name}(#{"params#{"={}" if options[:params] == :optional}" if options[:params]})
+              self.class.base_#{(options[:parse] == false) ? 'unparsed_' : '' }#{options[:method]}('#{action_name}#{slash}',self.id,#{options[:params] ? 'params' : 'nil' })
+            end}
+          end
+          if options[:task_list]
+            module_eval %{
+              def #{action_name}_tasks
+                self.class.base_get('#{action_name}#{slash}',self.id).collect{|p| Pulp::Task.new(p) }
+              end}
+          end
+        end
+        
+        def pulp_update_action(action_name,options)
+          module_eval %{
+            def update_#{action_name}(#{[*options[:params]].join(', ')})
+              self.class.base_put('',self.id,{ #{[*options[:params]].collect{|p| ":#{p} => #{p}" }.join(', ')} })
+            end}
+        end
+
+        def special_fields
+          @special_fields ||= []
+        end
+        
+        def record_fields
+          @record_fields ||= {}
+        end
+        
+        def locked_fields
+          @locked_fields ||= []
+        end
+      end
+    end
+  end
+end

data/lib/pulp/common/lifecycle/create.rb

@@ -0,0 +1,16 @@
+module Pulp
+  module Common
+    module Lifecycle
+      module Create
+        def self.included(base)
+          base.extend ClassMethods
+        end
+        module ClassMethods
+          def create(fields)
+            self.new(base_post('',nil,fields))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pulp/common/lifecycle/delete.rb

@@ -0,0 +1,23 @@
+module Pulp
+  module Common
+    module Lifecycle
+      module Delete
+        def self.included(base)
+          base.extend ClassMethods 
+        end
+        def delete
+          self.class.delete(id)
+        end
+        module ClassMethods
+          def delete_all
+            base_unparsed_delete('','')
+          end
+          
+          def delete(item_id)
+            base_delete("",item_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pulp/common/lifecycle/get.rb

@@ -0,0 +1,22 @@
+module Pulp
+  module Common
+    module Lifecycle
+      module Get
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        def refresh
+          set_fields(self.class.base_get('',id))
+          self
+        end
+
+        module ClassMethods
+          def get(item_id)
+            self.new(base_get('',item_id))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pulp/common/lifecycle/update.rb

@@ -0,0 +1,23 @@
+module Pulp
+  module Common
+    module Lifecycle
+      module Update
+        def self.included(base)
+          base.extend ClassMethods
+        end
+        
+        def save
+          res = self.class.update(self.id,user_fields.reject{|key,value| self.class.special_fields.include?(key) })
+          refresh if self.respond_to?(:refresh)
+          res
+        end
+        
+        module ClassMethods
+          def update(item,fields)
+            self.new(base_put('',item,fields))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pulp/connection/base.rb

@@ -0,0 +1,84 @@
+module Pulp
+  module Connection
+    class Base
+      include Pulp::Common::Lifecycle
+      
+      pulp_special_fields :_id, :id
+      
+      def initialize(data={})
+        set_fields(data)
+      end
+
+      def set_fields(field_data)
+        @fields = field_data
+      end
+
+      class << self
+        attr_accessor :hostname, :username, :password, :https
+
+        def reset
+          Pulp::Connection::Handler.reset_instance(self.identifier)
+        end
+
+        def identifier
+          @identifier ||= name.demodulize.downcase
+        end
+
+        def plain_unparsed_get(cmd, params=nil)
+          plain_base.connection[cmd.sub(/^#{Regexp.escape(plain_base.api_path)}\//,'')].get(merge_params(params)).body
+        end
+
+        def base_unparsed_get(cmd,item=nil,params=nil)
+          base.connection[parse_item_cmd(item,cmd)].get(merge_params(params)).body
+        end
+
+        def base_unparsed_delete(cmd,item=nil,params=nil)
+          base.connection[parse_item_cmd(item,cmd)].delete(merge_params(params)).body
+        end
+
+        def base_unparsed_post(cmd,item=nil,params=nil)
+          base.connection[parse_item_cmd(item,cmd)].post(params.nil? ? nil : params.to_json, :content_type => :json ).body
+        end
+
+        def base_unparsed_put(cmd,item=nil,params=nil)
+          base.connection[parse_item_cmd(item,cmd)].put(params.nil? ? nil : params.to_json, :content_type => :json ).body
+        end
+
+        def plain_get(cmd, params=nil)
+          plain_base.parsed{|conn| conn[cmd.sub(/^#{Regexp.escape(plain_base.api_path)}\//,'')].get(merge_params(params)) }
+        end
+        
+        def base_get(cmd,item=nil,params=nil)
+          base.parsed{|conn| conn[parse_item_cmd(item,cmd)].get(merge_params(params)) }
+        end
+        
+        def base_delete(cmd,item=nil,params=nil)
+          base.parsed{|conn| conn[parse_item_cmd(item,cmd)].delete(merge_params(params)) }
+        end
+        
+        def base_post(cmd,item=nil,params=nil)
+          base.parsed{|conn| conn[parse_item_cmd(item,cmd)].post(params.nil? ? nil : params.to_json, :content_type => :json ) }
+        end
+        def base_put(cmd,item=nil,params=nil)
+          base.parsed{|conn| conn[parse_item_cmd(item,cmd)].put(params.nil? ? nil : params.to_json, :content_type => :json ) }
+        end
+        
+        def base
+          Pulp::Connection::Handler.instance_for(self.identifier, hostname, username, password, (https.nil? ? true : https))
+        end
+        
+        def plain_base
+          Pulp::Connection::Handler.instance_for('', hostname, username, password, (https.nil? ? true : https))
+        end
+        
+        def parse_item_cmd(item,cmd)
+          "#{"/#{item}" unless item.nil?}#{(cmd =~ /^\//) ? cmd : "/#{cmd}"}"
+        end
+        
+        def merge_params(params)
+          params.nil? ? {} : { :params => params }
+        end
+      end
+    end
+  end
+end

data/lib/pulp/connection/handler.rb

@@ -0,0 +1,59 @@
+module Pulp
+  module Connection
+    class Handler
+      
+      include Pulp::Common::Debug
+      
+      class << self
+        attr_accessor :hostname,:username, :password
+        
+        def instance_for(identifier,h=nil,u=nil,p=nil,https=true)
+          instances[identifier] ||= Handler.new(identifier,
+                                                h||hostname,
+                                                u||username,
+                                                p||password,
+                                                https
+          )
+        end
+        
+        def reset_instance(identifier)
+          instances.delete(identifier)
+        end
+        
+        def reset_all
+          @instances = {}
+        end
+        
+        private
+        def instances
+          @instances ||= {}
+        end
+      end
+      
+      def initialize(identifier,hostname,username=nil,password=nil,https=true)
+        @identifier = identifier
+        @hostname = hostname
+        @username = username
+        @password = password
+        @https = https
+      end
+      
+      def parsed
+        JSON.parse((yield self.connection).body)
+      end
+      
+      def connection
+        @connection ||= RestClient::Resource.new(url, :user => @username, :password => @password, :headers => { :accept => :json })
+      end
+
+      def api_path
+        "/pulp/api" 
+      end
+      
+      def url
+        @url ||= "#{@https ? 'https' : 'http'}://#{@hostname}#{api_path}/#{@identifier.to_s.pluralize}"
+      end
+      
+    end
+  end
+end