opennebula 4.10.2 → 4.11.80.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1405cdbd2929cbba2006e8fc8b3f5babf8063d17
-  data.tar.gz: 5fd0a3980a8c556b5f2b436a444432d20ac9cad2
+  metadata.gz: b55fbcd210776bb0c2c343d9d42f1debef46541f
+  data.tar.gz: 09fbe6a0dd0e784de398efef0a00ac42294d1283
 SHA512:
-  metadata.gz: b3ab73f9baba7c9359297e6093f8b7e30ca5b8e1943a139c20cd3e0e6cdfa28d0077dd1d7486de4afceccb37ea1759bc72dbb91a479b64583b36aae10b71ea0f
-  data.tar.gz: cb437ef6456d5426c2d84fa2852516bd8213fde9e7f5f049e531955cd793a141393a1883e3d44ddf8e8c8a54fd0e9172651f4a5ece65e4816e859ecb1c1799e7
+  metadata.gz: f7755255b96a584aacc078dd9c79a9a9bb8395956547ddd01eb9cc73b29ad1987eed11046a96b399eee1e89a259dd0febfb4f96b2006f0d5a910231beeb2e00a
+  data.tar.gz: 356821d145ebc6ee6d068b85806f5f22b1b2359a2cf0515d380f8b2df2309a9f796ea12bde198f7588fd36576f3840f682ef61d35cdddf7817d51aed36f0b2d9

data/lib/opennebula.rb

@@ -51,10 +51,14 @@ require 'opennebula/document'
 require 'opennebula/document_pool'
 require 'opennebula/zone'
 require 'opennebula/zone_pool'
+require 'opennebula/security_group'
+require 'opennebula/security_group_pool'
+require 'opennebula/vdc'
+require 'opennebula/vdc_pool'
 require 'opennebula/system'
 
 module OpenNebula
 
     # OpenNebula version
-    VERSION = '4.10.2'
+    VERSION = '4.11.80'
 end

data/lib/opennebula/acl.rb

@@ -31,6 +31,8 @@ module OpenNebula
     #                  TEMPLATE
     #                  GROUP
     #                  ACL
+    #                  SECGROUP
+    #                  VDC
     #     RIGHTS    -> + separated list
     #                  USE
     #                  MANAGE
@@ -47,17 +49,19 @@ module OpenNebula
 
         RESOURCES =
         {
-            "VM"            => 0x1000000000,
-            "HOST"          => 0x2000000000,
-            "NET"           => 0x4000000000,
-            "IMAGE"         => 0x8000000000,
-            "USER"          => 0x10000000000,
-            "TEMPLATE"      => 0x20000000000,
-            "GROUP"         => 0x40000000000,
-            "DATASTORE"     => 0x100000000000,
-            "CLUSTER"       => 0x200000000000,
-            "DOCUMENT"      => 0x400000000000,
-            "ZONE"          => 0x800000000000
+            "VM"            =>    0x1000000000,
+            "HOST"          =>    0x2000000000,
+            "NET"           =>    0x4000000000,
+            "IMAGE"         =>    0x8000000000,
+            "USER"          =>   0x10000000000,
+            "TEMPLATE"      =>   0x20000000000,
+            "GROUP"         =>   0x40000000000,
+            "DATASTORE"     =>  0x100000000000,
+            "CLUSTER"       =>  0x200000000000,
+            "DOCUMENT"      =>  0x400000000000,
+            "ZONE"          =>  0x800000000000,
+            "SECGROUP"      => 0x1000000000000,
+            "VDC"           => 0x2000000000000
         }
 
         RIGHTS =

data/lib/opennebula/datastore.rb

@@ -30,7 +30,8 @@ module OpenNebula
             :update     => "datastore.update",
             :chown      => "datastore.chown",
             :chmod      => "datastore.chmod",
-            :rename     => "datastore.rename"
+            :rename     => "datastore.rename",
+            :enable     => "datastore.enable"
         }
 
         DATASTORE_TYPES=%w{IMAGE SYSTEM FILE}
@@ -41,6 +42,13 @@ module OpenNebula
             "FILE"  => "fil"
         }
 
+        DATASTORE_STATES=%w{READY DISABLED}
+
+        SHORT_DATASTORE_STATES={
+            "READY"     => "on",
+            "DISABLED"  => "off"
+        }
+
         # Creates a Datastore description with just its identifier
         # this method should be used to create plain Datastore objects.
         # +id+ the id of the user
@@ -66,20 +74,6 @@ module OpenNebula
         #######################################################################
         # XML-RPC Methods for the Datastore Object
         #######################################################################
-        # Returns the datastore type
-        def type
-            self['TYPE'].to_i
-        end
-
-        # Returns the datastore type (string value)
-        def type_str
-            DATASTORE_TYPES[type]
-        end
-
-        # Returns the datastore type (string value)
-        def short_type_str
-            SHORT_DATASTORE_TYPES[type_str]
-        end
 
         # Retrieves the information of the given Datastore.
         def info()
@@ -157,10 +151,50 @@ module OpenNebula
             return call(DATASTORE_METHODS[:rename], @pe_id, name)
         end
 
+        # Enables a Datastore
+        def enable
+            return call(DATASTORE_METHODS[:enable], @pe_id, true)
+        end
+
+        # Disables a Datastore
+        def disable
+            return call(DATASTORE_METHODS[:enable], @pe_id, false)
+        end
+
         # ---------------------------------------------------------------------
         # Helpers to get information
         # ---------------------------------------------------------------------
 
+        # Returns the datastore type
+        def type
+            self['TYPE'].to_i
+        end
+
+        # Returns the datastore type (string value)
+        def type_str
+            DATASTORE_TYPES[type]
+        end
+
+        # Returns the datastore type (string value)
+        def short_type_str
+            SHORT_DATASTORE_TYPES[type_str]
+        end
+
+        # Returns the state of the datastore (numeric value)
+        def state
+            self['STATE'].to_i
+        end
+
+        # Returns the state of the datastore (string value)
+        def state_str
+            DATASTORE_STATES[state]
+        end
+
+        # Returns the state of the datastore (string value)
+        def short_state_str
+            SHORT_DATASTORE_STATES[state_str]
+        end
+
         # Returns whether or not the image with id 'id' is part of this datastore
         def contains(id)
             #This doesn't work in ruby 1.8.5

data/lib/opennebula/group.rb

@@ -29,20 +29,19 @@ module OpenNebula
             :update         => "group.update",
             :delete         => "group.delete",
             :quota          => "group.quota",
-            :add_provider   => "group.addprovider",
-            :del_provider   => "group.delprovider"
+            :add_admin      => "group.addadmin",
+            :del_admin      => "group.deladmin",
         }
 
         # Flag for requesting connected user's group info
         SELF = -1
 
         # Default resource ACL's for group users (create)
-        GROUP_DEFAULT_ACLS = "VM+IMAGE+TEMPLATE+DOCUMENT"
-        ALL_CLUSTERS_IN_ZONE = 10
+        GROUP_DEFAULT_ACLS = "VM+IMAGE+TEMPLATE+DOCUMENT+SECGROUP"
 
         # The default view for group and group admins, must be defined in
         # sunstone_views.yaml
-        GROUP_ADMIN_SUNSTONE_VIEWS = "vdcadmin"
+        GROUP_ADMIN_SUNSTONE_VIEWS = "groupadmin"
 
         # Creates a Group description with just its identifier
         # this method should be used to create plain Group objects.
@@ -82,13 +81,14 @@ module OpenNebula
         #   group_hash[:name] the group name
         #   group_hash[:group_admin] the admin user definition hash, see def
         #   create_admin_user function description for details.
-        #   group_hash[:resource_providers]
-        #   group_hash[:resource_providers][:zone_id]
-        #   group_hash[:resource_providers][:cluster_id]
         #   group_hash[:views] Array of sunstone view names, to be stored
         #       in SUNSTONE_VIEWS
         #   group_hash[:default_view] Default sunstone view name, to be stored
         #       in DEFAULT_VIEW
+        #   group_hash[:admin_views] Array of sunstone view names, to be stored
+        #       in GROUP_ADMIN_VIEWS
+        #   group_hash[:default_admin_view] Default sunstone view name, to be stored
+        #       in DEFAULT_ADMIN_DEFAULT_VIEW
         #
         def create(group_hash)
             # Check arguments
@@ -107,17 +107,6 @@ module OpenNebula
             rc = self.allocate(group_hash[:name])
             return rc if OpenNebula.is_error?(rc)
 
-            # Handle resource providers
-            group_hash[:resource_providers].each { |rp|
-                next if rp[:zone_id].nil? && rp[:cluster_id].nil?
-
-                if rp[:cluster_id].class == String && rp[:cluster_id] == "ALL"
-                    add_provider(rp[:zone_id],ALL_CLUSTERS_IN_ZONE)
-                else
-                    add_provider(rp[:zone_id],rp[:cluster_id])
-                end
-            } if !group_hash[:resource_providers].nil?
-
             # Set group ACLs to create resources
             rc, msg = create_default_acls(group_hash[:resources])
 
@@ -151,24 +140,31 @@ module OpenNebula
             end
 
             str = ""
-            update = false
 
             # Add Sunstone views for the group
             if group_hash[:views]
                 str += "SUNSTONE_VIEWS=\"#{group_hash[:views].join(",")}\"\n"
-                update = true
             end
 
-            # Add Sunstone views for the group
             if group_hash[:default_view]
                 str += "DEFAULT_VIEW=\"#{group_hash[:default_view]}\"\n"
-                update = true
             end
 
-            if update
-                self.update(str, true)
+            # And the admin views
+            if group_hash[:admin_views]
+                str += "GROUP_ADMIN_VIEWS=\"#{group_hash[:admin_views].join(",")}\"\n"
+            else
+                str += "GROUP_ADMIN_VIEWS=#{GROUP_ADMIN_SUNSTONE_VIEWS}\n"
             end
 
+            if group_hash[:default_admin_view]
+                str += "GROUP_ADMIN_DEFAULT_VIEW=\"#{group_hash[:default_admin_view]}\"\n"
+            else
+                str += "GROUP_ADMIN_DEFAULT_VIEW=#{GROUP_ADMIN_SUNSTONE_VIEWS}"
+            end
+
+            self.update(str, true)
+
             return 0
         end
 
@@ -210,24 +206,22 @@ module OpenNebula
             return rc
         end
 
-        # Adds a resource provider to this group
-        # @param zone_id [Integer] Zone ID
-        # @param cluster_id [Integer] Cluster ID
+        # Adds a User to the Group administrators set
+        # @param user_id [Integer] User ID
         #
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
-        def add_provider(zone_id, cluster_id)
-            return call(GROUP_METHODS[:add_provider], @pe_id, zone_id.to_i, cluster_id.to_i)
+        def add_admin(user_id)
+            return call(GROUP_METHODS[:add_admin], @pe_id, user_id.to_i)
         end
 
-        # Deletes a resource provider from this group
-        # @param zone_id [Integer] Zone ID
-        # @param cluster_id [Integer] Cluster ID
+        # Removes a User from the Group administrators set
+        # @param user_id [Integer] User ID
         #
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
-        def del_provider(zone_id, cluster_id)
-            return call(GROUP_METHODS[:del_provider], @pe_id, zone_id.to_i, cluster_id.to_i)
+        def del_admin(user_id)
+            return call(GROUP_METHODS[:del_admin], @pe_id, user_id.to_i)
         end
 
         # ---------------------------------------------------------------------
@@ -243,15 +237,31 @@ module OpenNebula
             return id_array != nil && id_array.include?(uid.to_s)
         end
 
+        # Returns whether or not the user with id 'uid' is an admin of this group
+        def contains_admin(uid)
+            #This doesn't work in ruby 1.8.5
+            #return self["ADMINS/ID[.=#{uid}]"] != nil
+
+            id_array = retrieve_elements('ADMINS/ID')
+            return id_array != nil && id_array.include?(uid.to_s)
+        end
+
         # Returns an array with the numeric user ids
         def user_ids
-            array = Array.new
+            ids = self.retrieve_elements("USERS/ID")
+            
+            return [] if ids.nil?
 
-            self.each("USERS/ID") do |id|
-                array << id.text.to_i
-            end
+            return ids.collect! {|x| x.to_i}
+        end
+
+        # Returns an array with the numeric admin user ids
+        def admin_ids
+            ids = self.retrieve_elements("ADMINS/ID")
+
+            return [] if ids.nil?
 
-            return array
+            return ids.collect! {|x| x.to_i}
         end
 
         private
@@ -297,10 +307,6 @@ module OpenNebula
         #     gdef[:group_admin][:name] username for group admin
         #     gdef[:group_admin][:password] password for group admin
         #     gdef[:group_admin][:auth_driver] auth driver for group admin
-        #     gdef[:group_admin][:resources] resources that group admin manage
-        #     gdef[:group_admin][:manage_resources] whether group admin manages
-        #                                           group users
-        #     gdef[:resources] resources that group users manage
         #
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         def create_admin_user(gdef)
@@ -336,37 +342,13 @@ module OpenNebula
                 return rc
             end
 
-            # Set the default admin view to vdcadmin
-            group_admin.update("DEFAULT_VIEW=#{GROUP_ADMIN_SUNSTONE_VIEWS}", true)
-
-            #Create admin group acls
-            acls = Array.new
-
-            acls_str = (gdef[:group_admin][:resources] || \
-                        gdef[:resources] || GROUP_DEFAULT_ACLS)
-
-            manage_users = gdef[:group_admin][:manage_users] || "YES"
-
-            if manage_users.upcase == "YES"
-                acls << "##{group_admin.id} USER/@#{self.id} CREATE+USE+MANAGE+ADMIN"
-            end
-
-            acls << "##{group_admin.id} #{acls_str}/@#{self.id} " +
-                    "CREATE+USE+MANAGE"
-
-            rc, tmp = create_group_acls(acls)
+            rc = self.add_admin(group_admin.id)
 
             if OpenNebula.is_error?(rc)
                 group_admin.delete
                 return rc
             end
 
-            #Set Sunstone Views for the group
-            gtmpl =  "GROUP_ADMINS=#{gdef[:group_admin][:name]}\n"
-            gtmpl << "GROUP_ADMIN_VIEWS=#{GROUP_ADMIN_SUNSTONE_VIEWS}\n"
-
-            self.update(gtmpl, true)
-
             return nil
         end
     end

data/lib/opennebula/pool.rb

@@ -25,7 +25,7 @@ module OpenNebula
         alias_method :each_with_xpath, :each
 
         PAGINATED_POOLS=%w{VM_POOL IMAGE_POOL TEMPLATE_POOL VN_POOL
-                           DOCUMENT_POOL}
+                           DOCUMENT_POOL SECGROUP_POOL}
 
     protected
         #pool:: _String_ XML name of the root element

data/lib/opennebula/security_group.rb

@@ -0,0 +1,164 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2015, OpenNebula Project (OpenNebula.org), C12G Labs        #
+#                                                                            #
+# 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_element'
+
+module OpenNebula
+    class SecurityGroup < PoolElement
+        #######################################################################
+        # Constants and Class Methods
+        #######################################################################
+
+
+        SECGROUP_METHODS = {
+            :allocate    => "secgroup.allocate",
+            :info        => "secgroup.info",
+            :update      => "secgroup.update",
+            :delete      => "secgroup.delete",
+            :chown       => "secgroup.chown",
+            :chmod       => "secgroup.chmod",
+            :clone       => "secgroup.clone",
+            :rename      => "secgroup.rename"
+        }
+
+        # Creates a SecurityGroup description with just its identifier
+        # this method should be used to create plain SecurityGroup objects.
+        # @param pe_id [Integer] the id of the object
+        def SecurityGroup.build_xml(pe_id=nil)
+            if pe_id
+                obj_xml = "<SECURITY_GROUP><ID>#{pe_id}</ID></SECURITY_GROUP>"
+            else
+                obj_xml = "<SECURITY_GROUP></SECURITY_GROUP>"
+            end
+
+            XMLElement.build_xml(obj_xml,'SECURITY_GROUP')
+        end
+
+        # Class constructor
+        def initialize(xml, client)
+            super(xml,client)
+
+            @client = client
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the SecurityGroup Object
+        #######################################################################
+
+        # Retrieves the information of the given SecurityGroup.
+        def info()
+            super(SECGROUP_METHODS[:info], 'SECURITY_GROUP')
+        end
+
+        alias_method :info!, :info
+
+        # Allocates a new SecurityGroup in OpenNebula
+        #
+        # @param description [String] The contents of the SecurityGroup.
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def allocate(description)
+            super(SECGROUP_METHODS[:allocate], description)
+        end
+
+        # Deletes the SecurityGroup
+        def delete()
+            super(SECGROUP_METHODS[:delete])
+        end
+
+        # Replaces the securitygroup contents
+        #
+        # @param new_securitygroup [String] New securitygroup contents
+        # @param append [true, false] True to append new attributes instead of
+        #   replace the whole securitygroup
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def update(new_securitygroup, append=false)
+            super(SECGROUP_METHODS[:update], new_securitygroup, append ? 1 : 0)
+        end
+
+        # Changes the owner/group
+        #
+        # @param uid [Integer] the new owner id. Set to -1 to leave the current one
+        # @param gid [Integer] the new group id. Set to -1 to leave the current one
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def chown(uid, gid)
+            super(SECGROUP_METHODS[:chown], uid, gid)
+        end
+
+        # Changes the SecurityGroup 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(SECGROUP_METHODS[:chmod], octet)
+        end
+
+        # Changes the SecurityGroup 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(SECGROUP_METHODS[:chmod], owner_u, owner_m, owner_a, group_u,
+                group_m, group_a, other_u, other_m, other_a)
+        end
+
+        # Clones this SecurityGroup into a new one
+        #
+        # @param [String] name for the new SecurityGroup.
+        #
+        # @return [Integer, OpenNebula::Error] The new SecurityGroup ID in case
+        #   of success, Error otherwise
+        def clone(name)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(SECGROUP_METHODS[:clone], @pe_id, name)
+
+            return rc
+        end
+
+        # Renames this SecurityGroup
+        #
+        # @param name [String] New name for the SecurityGroup.
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def rename(name)
+            return call(SECGROUP_METHODS[:rename], @pe_id, name)
+        end
+
+        #######################################################################
+        # Helpers to get SecurityGroup information
+        #######################################################################
+
+        # Returns the group identifier
+        # [return] _Integer_ the element's group ID
+        def gid
+            self['GID'].to_i
+        end
+
+        def owner_id
+            self['UID'].to_i
+        end
+    end
+end

data/lib/opennebula/security_group_pool.rb

@@ -0,0 +1,78 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2015, OpenNebula Project (OpenNebula.org), C12G Labs        #
+#                                                                            #
+# 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 SecurityGroupPool < Pool
+        #######################################################################
+        # Constants and Class attribute accessors
+        #######################################################################
+
+        SECGROUP_POOL_METHODS = {
+            :info => "secgrouppool.info"
+        }
+
+        #######################################################################
+        # Class constructor & Pool Methods
+        #######################################################################
+
+        # +client+ a Client object that represents an XML-RPC connection
+        # +user_id+ used to refer to a Pool with Templates from that user
+        def initialize(client, user_id=-1)
+            super('SECURITY_GROUP_POOL','SECURITY_GROUP',client)
+
+            @user_id  = user_id
+        end
+
+        # Factory method to create Template objects
+        def factory(element_xml)
+            OpenNebula::SecurityGroup.new(element_xml,@client)
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the Template Object
+        #######################################################################
+
+        # Retrieves all or part of the objects in the pool.
+        def info(*args)
+            case args.size
+                when 0
+                    info_filter(SECGROUP_POOL_METHODS[:info],@user_id,-1,-1)
+                when 3
+                    info_filter(SECGROUP_POOL_METHODS[:info],args[0],args[1],args[2])
+            end
+        end
+
+        def info_all()
+            return super(SECGROUP_POOL_METHODS[:info])
+        end
+
+        def info_mine()
+            return super(SECGROUP_POOL_METHODS[:info])
+        end
+
+        def info_group()
+            return super(SECGROUP_POOL_METHODS[:info])
+        end
+
+        alias_method :info!, :info
+        alias_method :info_all!, :info_all
+        alias_method :info_mine!, :info_mine
+        alias_method :info_group!, :info_group
+    end
+end

data/lib/opennebula/vdc.rb

@@ -0,0 +1,236 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2015, OpenNebula Project (OpenNebula.org), C12G Labs        #
+#                                                                            #
+# 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_element'
+
+module OpenNebula
+    class Vdc < PoolElement
+        #######################################################################
+        # Constants and Class Methods
+        #######################################################################
+
+        ALL_RESOURCES = "-10"
+
+        VDC_METHODS = {
+            :info           => "vdc.info",
+            :allocate       => "vdc.allocate",
+            :update         => "vdc.update",
+            :rename         => "vdc.rename",
+            :delete         => "vdc.delete",
+
+            :add_group      => "vdc.addgroup",
+            :del_group      => "vdc.delgroup",
+            :add_cluster    => "vdc.addcluster",
+            :del_cluster    => "vdc.delcluster",
+            :add_host       => "vdc.addhost",
+            :del_host       => "vdc.delhost",
+            :add_datastore  => "vdc.adddatastore",
+            :del_datastore  => "vdc.deldatastore",
+            :add_vnet       => "vdc.addvnet",
+            :del_vnet       => "vdc.delvnet",
+        }
+
+        # Creates a Vdc description with just its identifier
+        # this method should be used to create plain Vdc objects.
+        # @param id [Integer] the id of the Vdc
+        #
+        # Example:
+        #   vdc = Vdc.new(Vdc.build_xml(3),rpc_client)
+        #
+        def Vdc.build_xml(pe_id=nil)
+            if pe_id
+                vdc_xml = "<VDC><ID>#{pe_id}</ID></VDC>"
+            else
+                vdc_xml = "<VDC></VDC>"
+            end
+
+            XMLElement.build_xml(vdc_xml,'VDC')
+        end
+
+        # Class constructor
+        def initialize(xml, client)
+            super(xml,client)
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the Vdc Object
+        #######################################################################
+
+        # Retrieves the information of the given Vdc.
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def info()
+            super(VDC_METHODS[:info], 'VDC')
+        end
+
+        alias_method :info!, :info
+
+        # Allocates a new Vdc in OpenNebula
+        #
+        # @param description [String] The template of the Vdc.
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def allocate(description)
+            super(VDC_METHODS[:allocate], description)
+        end
+
+        # Replaces the template contents
+        #
+        # @param new_template [String] New template contents
+        # @param append [true, false] True to append new attributes instead of
+        #   replace the whole template
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def update(new_template=nil, append=false)
+            super(VDC_METHODS[:update], new_template, append ? 1 : 0)
+        end       
+
+        # Deletes the Vdc
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def delete()
+            super(VDC_METHODS[:delete])
+        end
+
+        # Renames this Vdc
+        #
+        # @param name [String] New name for the Vdc.
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def rename(name)
+            return call(VDC_METHODS[:rename], @pe_id, name)
+        end
+
+        # Adds a group to this VDC
+        # @param group_id [Integer] Group ID
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def add_group(group_id)
+            return call(VDC_METHODS[:add_group], @pe_id, group_id.to_i)
+        end
+
+        # Deletes a group from this VDC
+        # @param group_id [Integer] Group ID
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def del_group(group_id)
+            return call(VDC_METHODS[:del_group], @pe_id, group_id.to_i)
+        end
+
+        # Adds a cluster to this VDC
+        # @param zone_id [Integer] Zone ID
+        # @param cluster_id [Integer] Cluster ID
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def add_cluster(zone_id, cluster_id)
+            return call(VDC_METHODS[:add_cluster], @pe_id, zone_id.to_i, cluster_id.to_i)
+        end
+
+        # Deletes a cluster from this VDC
+        # @param zone_id [Integer] Zone ID
+        # @param cluster_id [Integer] Cluster ID
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def del_cluster(zone_id, cluster_id)
+            return call(VDC_METHODS[:del_cluster], @pe_id, zone_id.to_i, cluster_id.to_i)
+        end
+
+        # Adds a host to this VDC
+        # @param zone_id [Integer] Zone ID
+        # @param host_id [Integer] Host ID
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def add_host(zone_id, host_id)
+            return call(VDC_METHODS[:add_host], @pe_id, zone_id.to_i, host_id.to_i)
+        end
+
+        # Deletes a host from this VDC
+        # @param zone_id [Integer] Zone ID
+        # @param host_id [Integer] Host ID        # Adds a host to this VDC
+        # @param zone_id [Integer] Zone ID
+        # @param host_id [Integer] Host ID
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def add_host(zone_id, host_id)
+            return call(VDC_METHODS[:add_host], @pe_id, zone_id.to_i, host_id.to_i)
+        end
+
+        # Deletes a host from this VDC
+        # @param zone_id [Integer] Zone ID
+        # @param host_id [Integer] Host ID
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def del_host(zone_id, host_id)
+            return call(VDC_METHODS[:del_host], @pe_id, zone_id.to_i, host_id.to_i)
+        end
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def del_host(zone_id, host_id)
+            return call(VDC_METHODS[:del_host], @pe_id, zone_id.to_i, host_id.to_i)
+        end
+
+        # Adds a datastore to this VDC
+        # @param zone_id [Integer] Zone ID
+        # @param datastore_id [Integer] Datastore ID
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def add_datastore(zone_id, datastore_id)
+            return call(VDC_METHODS[:add_datastore], @pe_id, zone_id.to_i, datastore_id.to_i)
+        end
+
+        # Deletes a datastore from this VDC
+        # @param zone_id [Integer] Zone ID
+        # @param datastore_id [Integer] Datastore ID
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def del_datastore(zone_id, datastore_id)
+            return call(VDC_METHODS[:del_datastore], @pe_id, zone_id.to_i, datastore_id.to_i)
+        end
+
+        # Adds a vnet to this VDC
+        # @param zone_id [Integer] Zone ID
+        # @param vnet_id [Integer] Vnet ID
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def add_vnet(zone_id, vnet_id)
+            return call(VDC_METHODS[:add_vnet], @pe_id, zone_id.to_i, vnet_id.to_i)
+        end
+
+        # Deletes a vnet from this VDC
+        # @param zone_id [Integer] Zone ID
+        # @param vnet_id [Integer] Vnet ID
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def del_vnet(zone_id, vnet_id)
+            return call(VDC_METHODS[:del_vnet], @pe_id, zone_id.to_i, vnet_id.to_i)
+        end
+    end
+end

data/lib/opennebula/vdc_pool.rb

@@ -0,0 +1,58 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2015, OpenNebula Project (OpenNebula.org), C12G Labs        #
+#                                                                            #
+# 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 VdcPool < Pool
+        #######################################################################
+        # Constants and Class attribute accessors
+        #######################################################################
+
+        VDC_POOL_METHODS = {
+            :info => "vdcpool.info"
+        }
+
+        #######################################################################
+        # Class constructor & Pool Methods
+        #######################################################################
+
+        # @param client [OpenNebula::Client] XML-RPC connection
+        def initialize(client)
+            super('VDC_POOL','VDC',client)
+        end
+
+        # Factory method to create Vdc objects
+        # @return [Vdc] new Vdc object
+        def factory(element_xml)
+            OpenNebula::Vdc.new(element_xml,@client)
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the Vdc Object
+        #######################################################################
+
+        # Retrieves all the VDCs in the pool.
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def info()
+            super(VDC_POOL_METHODS[:info])
+        end
+
+        alias_method :info!, :info
+    end
+end

data/lib/opennebula/virtual_machine_pool.rb

@@ -25,9 +25,11 @@ module OpenNebula
 
 
         VM_POOL_METHODS = {
-            :info       => "vmpool.info",
-            :monitoring => "vmpool.monitoring",
-            :accounting => "vmpool.accounting"
+            :info               => "vmpool.info",
+            :monitoring         => "vmpool.monitoring",
+            :accounting         => "vmpool.accounting",
+            :showback           => "vmpool.showback",
+            :calculate_showback => "vmpool.calculateshowback"
         }
 
         # Constants for info queries (include/RequestManagerPoolInfoFilter.h)
@@ -162,6 +164,27 @@ module OpenNebula
             return @client.call(VM_POOL_METHODS[:monitoring], filter_flag)
         end
 
+        # Processes all the history records, and stores the monthly cost for
+        # each VM
+        #
+        #  @param [Integer] start_month First month (+year) to process. January is 1.
+        #  Use -1 to unset
+        #  @param [Integer] start_year First year (+month) to process. e.g. 2014.
+        #  Use -1 to unset
+        #  @param [Integer] end_month Last month (+year) to process. January is 1.
+        #  Use -1 to unset
+        #  @param [Integer] end_year Last year (+month) to process. e.g. 2014.
+        #  Use -1 to unset
+        def calculate_showback(start_month, start_year, end_month, end_year)
+            start_month ||= -1
+            start_year  ||= -1
+            end_month   ||= -1
+            end_year    ||= -1
+
+            return @client.call(VM_POOL_METHODS[:calculate_showback],
+                                start_month, start_year, end_month, end_year)
+        end
+
         # Retrieves the accounting data for all the VMs in the pool
         #
         # @param [Integer] filter_flag Optional filter flag to retrieve all or
@@ -283,6 +306,92 @@ module OpenNebula
             xml_str
         end
 
+        # Retrieves the showback data for all the VMs in the pool
+        #
+        # @param [Integer] filter_flag Optional filter flag to retrieve all or
+        #   part of the Pool. Possible values: INFO_ALL, INFO_GROUP, INFO_MINE
+        #   or user_id
+        # @param [Hash] options
+        # @option params [Integer] :start_year First month (+year) to take
+        #   into account, if no start time is required use -1
+        # @option params [Integer] :start_month First year (+month) to take
+        #   into account, if no start time is required use -1
+        # @option params [Integer] :end_year Last month (+year) to take
+        #   into account, if no end time is required use -1
+        # @option params [Integer] :end_month Last year (+month) to take
+        #   into account, if no end time is required use -1
+        # @option params [Integer] :group Group id to filter the results
+        # @option params [String] :xpath Xpath expression to filter the results.
+        #    For example: SHOWBACK[TOTAL_COST>0]
+        # @option params [String] :order_by_1 Xpath expression to group the
+        # @option params [String] :order_by_2 Xpath expression to group the
+        #   returned hash. This will be the second level of the hash
+        #
+        # @return [Hash, OpenNebula::Error]
+        #   The first level hash uses the :order_by_1 values as keys, and
+        #   as value a Hash with the :order_by_2 values and the SHOWBACK_RECORDS
+        def showback(filter_flag=INFO_ALL, options={})
+            data_hash = Hash.new
+
+            rc = build_showback(filter_flag, options) do |record|
+                hash = data_hash
+
+                if options[:order_by_1]
+                    id_1 = record[options[:order_by_1]]
+                    data_hash[id_1] ||= Hash.new
+
+                    if options[:order_by_2]
+                        id_2 = record[options[:order_by_2]]
+                        data_hash[id_1][id_2] ||= Hash.new
+
+                        hash = data_hash[id_1][id_2]
+                    else
+                        hash = data_hash[id_1]
+                    end
+                end
+
+                hash["SHOWBACK_RECORDS"] ||= Hash.new
+                hash["SHOWBACK_RECORDS"]["SHOWBACK"] ||= Array.new
+                hash["SHOWBACK_RECORDS"]["SHOWBACK"] << record.to_hash['SHOWBACK']
+            end
+
+            return rc if OpenNebula.is_error?(rc)
+
+            data_hash
+        end
+
+        # Retrieves the showback data for all the VMs in the pool, in xml
+        #
+        # @param [Integer] filter_flag Optional filter flag to retrieve all or
+        #   part of the Pool. Possible values: INFO_ALL, INFO_GROUP, INFO_MINE
+        #   or user_id
+        # @param [Hash] options
+        # @option params [Integer] :start_year First month (+year) to take
+        #   into account, if no start time is required use -1
+        # @option params [Integer] :start_month First year (+month) to take
+        #   into account, if no start time is required use -1
+        # @option params [Integer] :end_year Last month (+year) to take
+        #   into account, if no end time is required use -1
+        # @option params [Integer] :end_month Last year (+month) to take
+        #   into account, if no end time is required use -1
+        # @option params [Integer] :group Group id to filter the results
+        # @option params [String] :xpath Xpath expression to filter the results.
+        #    For example: SHOWBACK[TOTAL_COST>10]
+        #
+        # @return [String] the xml representing the showback data
+        def showback_xml(filter_flag=INFO_ALL, options={})
+            xml_str = "<SHOWBACK_RECORDS>\n"
+
+            rc = build_showback(filter_flag, options) do |showback|
+                xml_str << showback.to_xml
+            end
+
+            return rc if OpenNebula.is_error?(rc)
+
+            xml_str << "\n</SHOWBACK_RECORDS>"
+            xml_str
+        end
+
         private
 
         def build_accounting(filter_flag, options, &block)
@@ -316,6 +425,38 @@ module OpenNebula
             acct_hash
         end
 
+        def build_showback(filter_flag, options, &block)
+            xml_str = @client.call(VM_POOL_METHODS[:showback],
+                        filter_flag,
+                        options[:start_month],
+                        options[:start_year],
+                        options[:end_month],
+                        options[:end_year])
+
+            return xml_str if OpenNebula.is_error?(xml_str)
+
+            xmldoc = XMLElement.new
+            xmldoc.initialize_xml(xml_str, 'SHOWBACK_RECORDS')
+
+            xpath_array = Array.new
+            xpath_array << "SHOWBACK[GID=#{options[:group]}]" if options[:group]
+            xpath_array << options[:xpath] if options[:xpath]
+
+            if xpath_array.empty?
+                xpath_str = "SHOWBACK"
+            else
+                xpath_str = xpath_array.join(' | ')
+            end
+
+            data_hash = Hash.new
+
+            xmldoc.each(xpath_str) do |showback|
+                block.call(showback)
+            end
+
+            data_hash
+        end
+
         def info_filter(xml_method, who, start_id, end_id, state)
             return xmlrpc_info(xml_method, who, start_id, end_id, state)
         end

data/lib/opennebula/virtual_network.rb

@@ -224,7 +224,7 @@ module OpenNebula
         end
 
         # Reserve a set of addresses from this virtual network
-        # @param name [String] of the reservation
+        # @param rname [String] of the reservation
         # @param rsize[String] number of addresses to reserve
         # @param ar_id[String] the ar_id to make the reservation. If set to nil
         #        any address range will be used
@@ -232,6 +232,8 @@ module OpenNebula
         #        nil the first free address will be used
         # @param vnet [String] ID of the VNET to add the reservation to. If not
         #        set a new VNET will be created.
+        # @return [Integer, OpenNebula::Error] The reservation vnet id on
+        #        success, Error otherwise
         def reserve(rname, rsize, ar_id, addr, vnet)
             return Error.new('ID not defined') if !@pe_id
 
@@ -250,10 +252,7 @@ module OpenNebula
                 rtmpl << "#{addr_name} = #{addr}\n"
             end
 
-            rc = @client.call(VN_METHODS[:reserve], @pe_id, rtmpl)
-            rc = nil if !OpenNebula.is_error?(rc)
-
-            return rc
+            return @client.call(VN_METHODS[:reserve], @pe_id, rtmpl)
         end
 
         # Removes an Address Range from the VirtualNetwork

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opennebula
 version: !ruby/object:Gem::Version
-  version: 4.10.2
+  version: 4.11.80.beta
 platform: ruby
 authors:
 - OpenNebula
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-16 00:00:00.000000000 Z
+date: 2015-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -84,6 +84,8 @@ files:
 - lib/opennebula/oneflow_client.rb
 - lib/opennebula/pool.rb
 - lib/opennebula/pool_element.rb
+- lib/opennebula/security_group.rb
+- lib/opennebula/security_group_pool.rb
 - lib/opennebula/server_cipher_auth.rb
 - lib/opennebula/server_x509_auth.rb
 - lib/opennebula/ssh_auth.rb
@@ -92,6 +94,8 @@ files:
 - lib/opennebula/template_pool.rb
 - lib/opennebula/user.rb
 - lib/opennebula/user_pool.rb
+- lib/opennebula/vdc.rb
+- lib/opennebula/vdc_pool.rb
 - lib/opennebula/virtual_machine.rb
 - lib/opennebula/virtual_machine_pool.rb
 - lib/opennebula/virtual_network.rb
@@ -117,9 +121,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.5
@@ -127,3 +131,4 @@ signing_key:
 specification_version: 4
 summary: OpenNebula Client API
 test_files: []
+has_rdoc: