occi 1.2.1 → 2.0.0

data/lib/OpenNebula/Image.rb

@@ -0,0 +1,256 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2012, OpenNebula Project Leads (OpenNebula.org)             #
+#                                                                            #
+# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
+# not use this file except in compliance with the License. You may obtain    #
+# a copy of the License at                                                   #
+#                                                                            #
+# http://www.apache.org/licenses/LICENSE-2.0                                 #
+#                                                                            #
+# Unless required by applicable law or agreed to in writing, software        #
+# distributed under the License is distributed on an "AS IS" BASIS,          #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
+# See the License for the specific language governing permissions and        #
+# limitations under the License.                                             #
+#--------------------------------------------------------------------------- #
+
+
+require 'OpenNebula/Pool'
+require 'fileutils'
+
+module OpenNebula
+    class Image < PoolElement
+        #######################################################################
+        # Constants and Class Methods
+        #######################################################################
+
+
+        IMAGE_METHODS = {
+            :info        => "image.info",
+            :allocate    => "image.allocate",
+            :update      => "image.update",
+            :enable      => "image.enable",
+            :persistent  => "image.persistent",
+            :delete      => "image.delete",
+            :chown       => "image.chown",
+            :chmod       => "image.chmod",
+            :chtype      => "image.chtype"
+        }
+
+        IMAGE_STATES=%w{INIT READY USED DISABLED LOCKED ERROR}
+
+        SHORT_IMAGE_STATES={
+            "INIT"      => "init",
+            "READY"     => "rdy",
+            "USED"      => "used",
+            "DISABLED"  => "disa",
+            "LOCKED"    => "lock",
+            "ERROR"     => "err"
+        }
+
+        IMAGE_TYPES=%w{OS CDROM DATABLOCK}
+
+        SHORT_IMAGE_TYPES={
+            "OS"         => "OS",
+            "CDROM"      => "CD",
+            "DATABLOCK"  => "DB"
+        }
+
+        # Creates an Image description with just its identifier
+        # this method should be used to create plain Image objects.
+        # +id+ the id of the image
+        #
+        # Example:
+        #   image = Image.new(Image.build_xml(3),rpc_client)
+        #
+        def Image.build_xml(pe_id=nil)
+            if pe_id
+                image_xml = "<IMAGE><ID>#{pe_id}</ID></IMAGE>"
+            else
+                image_xml = "<IMAGE></IMAGE>"
+            end
+
+            XMLElement.build_xml(image_xml,'IMAGE')
+        end
+
+        # Class constructor
+        def initialize(xml, client)
+            super(xml,client)
+
+            @client = client
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the Image Object
+        #######################################################################
+
+        # Retrieves the information of the given Image.
+        def info()
+            super(IMAGE_METHODS[:info], 'IMAGE')
+        end
+
+        # Allocates a new Image in OpenNebula
+        #
+        # +description+ A string containing the template of the Image.
+        def allocate(description)
+            super(IMAGE_METHODS[:allocate],description)
+        end
+
+        # Replaces the template contents
+        #
+        # +new_template+ New template contents
+        def update(new_template)
+            super(IMAGE_METHODS[:update], new_template)
+        end
+
+        # Enables an Image
+        def enable
+            set_enabled(true)
+        end
+
+        # Disables an Image
+        def disable
+            set_enabled(false)
+        end
+
+        # Publishes the Image, to be used by other users
+        def publish
+            set_publish(true)
+        end
+
+        # Unplubishes the Image
+        def unpublish
+            set_publish(false)
+        end
+
+        # Makes the Image persistent
+        def persistent
+            set_persistent(true)
+        end
+
+        # Makes the Image non persistent
+        def nonpersistent
+            set_persistent(false)
+        end
+
+        # Deletes the Image
+        def delete()
+            super(IMAGE_METHODS[:delete])
+        end
+
+        # Changes the owner/group
+        # uid:: _Integer_ the new owner id. Set to -1 to leave the current one
+        # gid:: _Integer_ the new group id. Set to -1 to leave the current one
+        # [return] nil in case of success or an Error object
+        def chown(uid, gid)
+            super(IMAGE_METHODS[:chown], uid, gid)
+        end
+
+        # Changes the Image permissions.
+        #
+        # @param octet [String] Permissions octed , e.g. 640
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def chmod_octet(octet)
+            super(IMAGE_METHODS[:chmod], octet)
+        end
+
+        # Changes the Image permissions.
+        # Each [Integer] argument must be 1 to allow, 0 deny, -1 do not change
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def chmod(owner_u, owner_m, owner_a, group_u, group_m, group_a, other_u,
+                other_m, other_a)
+            super(IMAGE_METHODS[:chmod], owner_u, owner_m, owner_a, group_u,
+                group_m, group_a, other_u, other_m, other_a)
+        end
+
+        # Changes the Image type
+        # @param type [String] new Image type
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def chtype(type)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(IMAGE_METHODS[:chtype], @pe_id, type)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        #######################################################################
+        # Helpers to get Image information
+        #######################################################################
+
+        # Returns the state of the Image (numeric value)
+        def state
+            self['STATE'].to_i
+        end
+
+        # Returns the state of the Image (string value)
+        def state_str
+            IMAGE_STATES[state]
+        end
+
+        # Returns the state of the Image (string value)
+        def short_state_str
+            SHORT_IMAGE_STATES[state_str]
+        end
+
+        # Returns the type of the Image (numeric value)
+        def type
+            self['TYPE'].to_i
+        end
+
+        # Returns the type of the Image (string value)
+        def type_str
+            IMAGE_TYPES[type]
+        end
+
+        # Returns the state of the Image (string value)
+        def short_type_str
+            SHORT_IMAGE_TYPES[type_str]
+        end
+
+        # Returns the group identifier
+        # [return] _Integer_ the element's group ID
+        def gid
+            self['GID'].to_i
+        end
+
+        def public?
+            if self['PERMISSIONS/GROUP_U'] == "1" || self['PERMISSIONS/OTHER_U'] == "1"
+                true
+            else
+                false
+            end
+        end
+
+    private
+
+        def set_enabled(enabled)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(IMAGE_METHODS[:enable], @pe_id, enabled)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        def set_publish(published)
+            group_u = published ? 1 : 0
+
+            chmod(-1, -1, -1, group_u, -1, -1, -1, -1, -1)
+        end
+        
+        def set_persistent(persistence)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(IMAGE_METHODS[:persistent], @pe_id, persistence)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+    end
+end

data/lib/OpenNebula/ImagePool.rb

@@ -0,0 +1,74 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2012, OpenNebula Project Leads (OpenNebula.org)             #
+#                                                                            #
+# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
+# not use this file except in compliance with the License. You may obtain    #
+# a copy of the License at                                                   #
+#                                                                            #
+# http://www.apache.org/licenses/LICENSE-2.0                                 #
+#                                                                            #
+# Unless required by applicable law or agreed to in writing, software        #
+# distributed under the License is distributed on an "AS IS" BASIS,          #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
+# See the License for the specific language governing permissions and        #
+# limitations under the License.                                             #
+#--------------------------------------------------------------------------- #
+
+
+require 'OpenNebula/Pool'
+
+module OpenNebula
+    class ImagePool < Pool
+        #######################################################################
+        # Constants and Class attribute accessors
+        #######################################################################
+
+
+        IMAGE_POOL_METHODS = {
+            :info => "imagepool.info"
+        }
+
+        #######################################################################
+        # Class constructor & Pool Methods
+        #######################################################################
+
+        # +client+ a Client object that represents a XML-RPC connection
+        # +user_id+ is to refer to a Pool with Images from that user
+        def initialize(client, user_id=-1)
+            super('IMAGE_POOL','IMAGE',client)
+
+            @user_id  = user_id
+        end
+
+        # Default Factory Method for the Pools
+        def factory(element_xml)
+            OpenNebula::Image.new(element_xml,@client)
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the Image Object
+        #######################################################################
+
+        # Retrieves all or part of the VirtualMachines in the pool.
+        def info(*args)
+            case args.size
+                when 0
+                    info_filter(IMAGE_POOL_METHODS[:info],@user_id,-1,-1)
+                when 3
+                    info_filter(IMAGE_POOL_METHODS[:info],args[0],args[1],args[2])
+            end
+        end
+
+        def info_all()
+            return super(IMAGE_POOL_METHODS[:info])
+        end
+
+        def info_mine()
+            return super(IMAGE_POOL_METHODS[:info])
+        end
+
+        def info_group()
+            return super(IMAGE_POOL_METHODS[:info])
+        end
+    end
+end

data/lib/OpenNebula/OpenNebula.rb

@@ -0,0 +1,137 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2012, OpenNebula Project Leads (OpenNebula.org)             #
+#                                                                            #
+# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
+# not use this file except in compliance with the License. You may obtain    #
+# a copy of the License at                                                   #
+#                                                                            #
+# http://www.apache.org/licenses/LICENSE-2.0                                 #
+#                                                                            #
+# Unless required by applicable law or agreed to in writing, software        #
+# distributed under the License is distributed on an "AS IS" BASIS,          #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
+# See the License for the specific language governing permissions and        #
+# limitations under the License.                                             #
+#--------------------------------------------------------------------------- #
+
+
+begin # require 'rubygems'
+    require 'rubygems'
+rescue Exception
+end
+
+require 'xmlrpc/client'
+require 'digest/sha1'
+require 'rexml/document'
+require 'pp'
+
+require 'OpenNebula/XMLUtils'
+require 'OpenNebula/VirtualMachine'
+require 'OpenNebula/VirtualMachinePool'
+require 'OpenNebula/VirtualNetwork'
+require 'OpenNebula/VirtualNetworkPool'
+require 'OpenNebula/Image'
+require 'OpenNebula/ImagePool'
+require 'OpenNebula/User'
+require 'OpenNebula/UserPool'
+require 'OpenNebula/Host'
+require 'OpenNebula/HostPool'
+require 'OpenNebula/Template'
+require 'OpenNebula/TemplatePool'
+require 'OpenNebula/Group'
+require 'OpenNebula/GroupPool'
+require 'OpenNebula/Acl'
+require 'OpenNebula/AclPool'
+
+module OpenNebula
+
+    # The Error Class represents a generic error in the OpenNebula
+    # library. It contains a readable representation of the error.
+    # Any function in the OpenNebula module will return an Error
+    # object in case of error.
+    class Error
+        ESUCCESS        = 0x0000
+        EAUTHENTICATION = 0x0100
+        EAUTHORIZATION  = 0x0200
+        ENO_EXISTS      = 0x0400
+        EACTION         = 0x0800
+        EXML_RPC_API    = 0x1000
+        EINTERNAL       = 0x2000
+        ENOTDEFINED     = 0x1111
+
+        attr_reader :message, :errno
+
+        # +message+ Description of the error
+        # +errno+   OpenNebula code error
+        def initialize(message=nil, errno=0x1111)
+            @message = message
+            @errno   = errno
+        end
+
+        def to_str()
+            @message
+        end
+    end
+
+    # Returns true if the object returned by a method of the OpenNebula
+    # library is an Error
+    def self.is_error?(value)
+        value.class==OpenNebula::Error
+    end
+
+    # The client class, represents the connection with the core and handles the
+    # xml-rpc calls.
+    class Client
+        attr_accessor :one_auth
+
+        begin
+            require 'xmlparser'
+            XMLPARSER=true
+        rescue LoadError
+            XMLPARSER=false
+        end
+
+        def initialize(secret=nil, endpoint=nil)
+            if secret
+                @one_auth = secret
+            elsif ENV["ONE_AUTH"] and !ENV["ONE_AUTH"].empty? and File.file?(ENV["ONE_AUTH"])
+                @one_auth = File.read(ENV["ONE_AUTH"])
+            elsif File.file?(ENV["HOME"]+"/.one/one_auth")
+                @one_auth = File.read(ENV["HOME"]+"/.one/one_auth")
+            else
+                raise "ONE_AUTH file not present"
+            end
+
+            @one_auth.rstrip!
+
+            if endpoint
+                @one_endpoint = endpoint
+            elsif ENV["ONE_XMLRPC"]
+                @one_endpoint = ENV["ONE_XMLRPC"]
+            else
+                @one_endpoint = "http://localhost:2633/RPC2"
+            end
+
+            @server = XMLRPC::Client.new2(@one_endpoint)
+        end
+
+        def call(action, *args)
+
+            if XMLPARSER
+                @server.set_parser(XMLRPC::XMLParser::XMLStreamParser.new)
+            end
+
+            begin
+                response = @server.call_async("one."+action, @one_auth, *args)
+
+                if response[0] == false
+                    Error.new(response[1], response[2])
+                else
+                    response[1] #response[1..-1]
+                end
+            rescue Exception => e
+                Error.new(e.message)
+            end
+        end
+    end
+end