gapinc-cobbler 2.0.0

data/lib/cobbler.rb

@@ -0,0 +1,35 @@
+#
+# cobbler.rb - Cobbler module declaration.
+#
+# Copyright (C) 2008,2009 Red Hat, Inc.
+# Written by Darryl L. Pierce <dpierce@redhat.com>
+# Extended 2012 by duritong <peter.meier@immerda.ch>
+#
+# This file is part of rubygem-cobbler.
+#
+# rubygem-cobbler is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# rubygem-cobbler is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with rubygem-cobbler.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'active_support/inflector'
+require 'cobbler/base'
+require 'cobbler/distro'
+require 'cobbler/image'
+require 'cobbler/profile'
+require 'cobbler/repo'
+require 'cobbler/system'
+
+module Cobbler
+
+  VERSION = '2.0.0'
+
+end

data/lib/cobbler/base.rb

@@ -0,0 +1,128 @@
+#
+# base.rb
+#
+# Copyright (C) 2008,2009 Red Hat, Inc.
+# Written by Darryl L. Pierce <dpierce@redhat.com>
+# Extended 2012 by duritong <peter.meier@immerda.ch>
+#
+# This file is part of rubygem-cobbler.
+#
+# rubygem-cobbler is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# rubygem-cobbler is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with rubygem-cobbler.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+require 'cobbler/common/debug'
+require 'cobbler/connection/handling'
+require 'cobbler/connection/common'
+require 'cobbler/common/lifecycle'
+require 'cobbler/common/finders'
+
+# +Base+ represents a type of item on the Cobbler server.
+#
+# Child classes can define fields that will be retrieved from Cobbler by
+# using the +cobbler_field+ method. For example:
+#
+#   class System < Base
+#       cobbler_lifecycle :find_all => 'get_systems'
+#       cobbler_field :name
+#       cobbler_collection :owners, :type => 'String', :packing => :hash
+#   end
+#
+# declares a class named System that contains two fields and a class-level
+# method.
+#
+# The first field, "name", is a simple property. It will be retrieved from
+# the value "name" in the remote definition for a system, identifyed by the
+# +:owner+ argument.
+#
+# The second field, "owners", is similarly retrieved from a property also
+# named "owners" in the remote definition. However, this property is a
+# collection: in this case, it is an array of definitions itself. The
+# +:type+ argument identifies what the +local+ class type is that will be
+# used to represent each element in the collection.
+#
+# A +cobbler_collection+ is packed in one of two ways: either as an array
+# of values or as a hash of keys and associated values. These are defined by
+# the +:packing+ argument with the values +Array+ and +Hash+, respectively.
+#
+# The +cobbler_lifecycle+ method allows for declaring different methods for
+# retrieving remote instances of the class. +cobbler_lifecycle+ also declares
+# automatically the various API methods if they aren't overwritten.
+# These methods are (defaults are shown for an item called Model):
+#
+# +find_one+ - to find a single instance (get_model)
+# +find_all+ - to find all instances (get_models)
+# +remove+   - to remove an instance (remove_model)
+# +handle+   - to obtain the handle for this item (get_model_handle)
+# +save+     - to store an item (save_model)
+# +new+      - to create a new item (new_model)
+# +modify+   - to modify an existing model (modfiy_model)
+#
+module Cobbler
+    class Base
+        
+        def initialize(defs = {},new_record = true)
+            if new_record
+                @user_definitions = defs
+            else
+                @definitions = defs
+            end
+        end
+        
+        include Cobbler::Common::Debug
+        include Cobbler::Connection::Handling
+        include Cobbler::Connection::Common
+        
+        include Cobbler::Common::Lifecycle
+        include Cobbler::Common::Finders
+
+        # Save an item on the remote cobbler server
+        # This will first lookup if the item already exists on the remote server
+        # and use its handle store the attributes. Otherwise a new item is created.
+        def save
+            unless [ :handle, :new, :modify, :save ].all?{|method| api_methods[method] }
+                raise "Not all necessary api methods are defined to process this action!"            
+            end
+            entry = self.class.find_one(name)
+            self.class.in_transaction(true) do |token|
+                if entry
+                    entryid = self.class.make_call(api_methods[:handle],name,token) 
+                else
+                    entryid = self.class.make_call(api_methods[:new],token)
+                    self.class.make_call(api_methods[:modify],entryid,'name', name, token)
+                end
+                
+                cobbler_record_fields.each do |field|
+                    field_s = field.to_s
+                    if !locked_fields.include?(field) && user_definitions.has_key?(field_s)
+                        self.class.make_call(api_methods[:modify],entryid,field_s, user_definitions[field_s], token)
+                    end
+                end
+                
+                cobbler_collections_store_callbacks.each do |callback|
+                    send(callback,entryid,token)
+                end
+                
+                self.class.make_call(api_methods[:save],entryid,token)
+            end
+        end
+        
+        # delete the item on the cobbler server
+        def remove
+            raise "Not all necessary api methods are defined to process this action!" unless api_methods[:remove]
+            self.class.in_transaction(true) do |token|
+                self.class.make_call(api_methods[:remove],name,token)
+            end
+        end
+    end
+end

data/lib/cobbler/common/debug.rb

@@ -0,0 +1,59 @@
+#
+# debug.rb
+#
+# Copyright (C) 2008,2009 Red Hat, Inc.
+# Written by Darryl L. Pierce <dpierce@redhat.com>
+# Extended 2012 by duritong <peter.meier@immerda.ch>
+#
+# This file is part of rubygem-cobbler.
+#
+# rubygem-cobbler is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# rubygem-cobbler is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with rubygem-cobbler.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+# +Debug+ provides a basic debugging infrastructure.
+module Cobbler
+    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
+                end
+                
+                def output=(output)
+                    @output = output
+                end
+                
+                def output
+                    @output ||= STDOUT
+                end
+                
+                def debug(msg)
+                    output.puts msg if @debug_enabled
+                end
+            end
+        end
+    end
+end

data/lib/cobbler/common/finders.rb

@@ -0,0 +1,55 @@
+#
+# finders.rb
+#
+# Copyright (C) 2008,2009 Red Hat, Inc.
+# Written by Darryl L. Pierce <dpierce@redhat.com>
+# Extended 2012 by duritong <peter.meier@immerda.ch>
+#
+# This file is part of rubygem-cobbler.
+#
+# rubygem-cobbler is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# rubygem-cobbler is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with rubygem-cobbler.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+# +Finders+ provides the basic 2 finder methods to query a cobbler server
+#
+# +find_one+ to fetch exactly one item based on its name
+# +find+ to find all items, takes a block to work with the fetched items
+module Cobbler
+    module Common
+        module Finders
+            def self.included(base)
+                base.extend(ClassMethods)
+            end
+            
+            module ClassMethods
+                def find(&block)
+                    raise "No idea how to fetch a list of myself, as no find_all method is defined" unless api_methods[:find_all]
+                    result = []
+                    in_transaction { make_call(api_methods[:find_all]) }.to_a.each do |record|
+                        c_record = new(record,false)
+                        result << c_record
+                        yield(c_record) if block_given?
+                    end
+                    return result
+                end
+                
+                def find_one(name)
+                    raise "No idea how to fetch myself, as no find_one method is defined" unless api_methods[:find_one]
+                    properties = in_transaction { make_call(api_methods[:find_one],name) }
+                    valid_properties?(properties) ? new(properties,false) : nil
+                end
+            end
+        end
+    end
+end

data/lib/cobbler/common/lifecycle.rb

@@ -0,0 +1,163 @@
+#
+# lifecycle.rb
+#
+# Copyright (C) 2008,2009 Red Hat, Inc.
+# Written by Darryl L. Pierce <dpierce@redhat.com>
+# Extended 2012 by duritong <peter.meier@immerda.ch>
+#
+# This file is part of rubygem-cobbler.
+#
+# rubygem-cobbler is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# rubygem-cobbler is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with rubygem-cobbler.  If not, see <http://www.gnu.org/licenses/>.
+
+# +Lifecycle+ implements a default set of functionality that a cobbler item
+# can have.
+# Usually the +Lifecycle+ methods are used to define query functions and define
+# which fields of a cobbler item is exposed through the api.
+module Cobbler
+    module Common
+        module Lifecycle
+            def self.included(base)
+                base.extend ClassMethods
+            end
+            
+            def definitions
+                @definitions ||= {}
+            end
+            
+            def user_definitions
+                @user_definitions ||= {}
+            end
+            
+            def locked_fields
+                self.class.locked_fields
+            end
+            
+            def cobbler_record_fields
+                self.class.cobbler_record_fields
+            end
+            def cobbler_collections_store_callbacks
+                self.class.cobbler_collections_store_callbacks
+            end
+            
+            def api_methods
+                self.class.api_methods
+            end
+            
+            module ClassMethods
+                def api_methods
+                    return @api_methods if @api_methods
+                    model_name = self.name.gsub(/.*::/,'').underscore
+                    @api_methods = {
+                      :find_all => "get_#{model_name.pluralize}",
+                      :find_one => "get_#{model_name}",
+                      :handle => "get_#{model_name}_handle",
+                      :remove => "remove_#{model_name}",
+                      :save => "save_#{model_name}",
+                      :new => "new_#{model_name}",
+                      :modify => "modify_#{model_name}"
+                    }
+                end
+                
+                def cobbler_record_fields
+                    @cobbler_record_fields ||= []
+                end
+                
+                def locked_fields
+                    @locked_fields ||= []
+                end
+                
+                def cobbler_collections_store_callbacks
+                    @cobbler_collections_store_callbacks ||= []
+                end
+                
+                # Define/adjust all necessary lookup methods for a usual
+                # cobbler item.
+                #
+                def cobbler_lifecycle(lookup_methods={})
+                    api_methods.merge!(lookup_methods)
+                end
+                
+                # Allows for dynamically declaring fields that will come from
+                # Cobbler.
+                #
+                def cobbler_field(field,options={})
+                    # name is always locked and findable as this is a special field
+                    if field == :name
+                        options[:locked] = true if options[:locked] || options[:locked].nil?
+                        options[:findable] = api_methods[:find_one] if options[:findable] || options[:findable].nil? 
+                    end
+                    options.each do |key,value|
+                        case key
+                            when :findable then
+                            if value
+                                module_eval <<-"MEND"
+                                def self.find_by_#{field}(value)
+                                    properties = in_transaction{ make_call('#{value}',value) }
+                                    valid_properties?(properties) ? new(properties,false) : nil
+                                end
+                                MEND
+                            end
+                            when :locked then
+                            locked_fields << field if value
+                        end
+                    end
+                    
+                    module_eval("def #{field}() user_definitions['#{field}'] || definitions['#{field}']; end")
+                    module_eval("def #{field}=(val) user_definitions['#{field}'] = val; end")
+                    
+                    cobbler_record_fields << field
+                end
+                
+                # Declare many fields at once.
+                def cobbler_fields(*fields)
+                    fields.to_a.each {|field| cobbler_field field }
+                end
+                
+                # Allows a field to be defined as a collection of objects. The type for that
+                # other class must be provided.
+                #
+                def cobbler_collection(field, options={})
+                    classname = options[:type] || 'String'
+                    packing = options[:packing] ? options[:packing].to_s.classify : 'Array'
+                    
+                    packing_code = {
+              'Array' => "(definitions['#{field}']||[]).each{|value| new_value << #{classname}.new(value) }",
+              'Hash' => "(definitions['#{field}']||{}).each{|key,value| new_value[key] = #{classname}.new(value) }"
+                    }
+                    
+                    cobbler_collections_store_callbacks << options[:store] if options[:store]
+                    # unless we have a seperate store callback we store collections normally
+                    cobbler_record_fields << field unless options[:store]
+                    
+                    module_eval <<-"MEND"
+                    def #{field}
+                        if !user_definitions['#{field}'] && !definitions['#{field}'].is_a?(#{packing})
+                                                                                           new_value = #{packing}.new
+                                                                                           #{packing_code[packing]}
+                                                                                           definitions['#{field}'] = new_value
+                        end
+                        user_definitions['#{field}'] ||= definitions['#{field}']
+                        # return always the user_definitions as we might do operations on these objects, e.g. <<
+                        user_definitions['#{field}'] 
+                    end
+                    
+                    def #{field}=(value)
+                        user_definitions['#{field}'] = value
+                    end
+                    MEND
+                end        
+            end
+        end
+    end
+end

data/lib/cobbler/connection/common.rb

@@ -0,0 +1,79 @@
+#
+# common.rb
+#
+# Copyright (C) 2008,2009 Red Hat, Inc.
+# Written by Darryl L. Pierce <dpierce@redhat.com>
+# Extended 2012 by duritong <peter.meier@immerda.ch>
+#
+# This file is part of rubygem-cobbler.
+#
+# rubygem-cobbler is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# rubygem-cobbler is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with rubygem-cobbler.  If not, see <http://www.gnu.org/licenses/>.
+
+# +Common+ provides common methods of the cobbler server exposed through the
+# api. 
+module Cobbler
+    module Connection
+        module Common
+            def self.included(base)
+                base.extend(ClassMethods)
+            end
+            
+            module ClassMethods
+                # tests a connections
+                def test_connection
+                    !in_transaction do
+                        result = login
+                        logout if result
+                        result
+                    end.nil?
+                end
+                
+                # start a sync on the cobbler server
+                def sync
+                    in_transaction(true) do |token|
+                        make_call('sync',token)
+                    end
+                end
+                
+                # get all events (for a certain user)
+                def events(for_user='')
+                    in_transaction do
+                        make_call('get_events',for_user)
+                    end
+                end
+                
+                # get the log for a certain event
+                def event_log(event_id)
+                    in_transaction do
+                        make_call('get_event_log',event_id)
+                    end
+                end
+                
+                # import a tree into cobbler
+                def import(path,name,arch,additional_options={})
+                    in_transaction(true) do |token|
+                        make_call('background_import',{'path' => path ,'name' => name , 'arch' => arch}.merge(additional_options),token)
+                    end
+                end
+                
+                # start syncing the following repositories.
+                def reposync(repos=[],tries=3)
+                    in_transaction(true) do |token|
+                        make_call('background_reposync',{'repos' => repos, 'tries' => tries},token)
+                    end
+                end
+            end
+        end
+    end
+end