opennebula 5.2.1 → 5.3.80.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a03807dc5cd00c6e5a42fe341caa95a84a5734b7
-  data.tar.gz: 8c4bd35f71422c0f168616d4d32422aee5feef69
+  metadata.gz: 793beff44dc5a782c2aafcfc3049362b981f972b
+  data.tar.gz: ed04d3cf4814a0715471a99342cf04811ad86520
 SHA512:
-  metadata.gz: 40a1c600b081b6190144d8ec8110b1dbf6a829e83cad138d08119621dfa958632a5918e12bdc0565e877b1d11b03faf2cbaddce40bc9fa1a5a613bd800f3c816
-  data.tar.gz: 928962cd78fcd5353ffcacb009e6b2ac7326345abe1cd4e6a4f2f844f350ab9d9b5defc203066b6e144374874e0dfbc62a93e20bceca2879279d1a311a0edeee
+  metadata.gz: c892fa6c7a0f2012185c432eae4b7954ed3500f35962e4b5d453279db3c702f716d27fed588ae653cf383d7d8eede5dd4ecb55534bbc62d1c46033b75b452161
+  data.tar.gz: e751d6869d55f43512f28746bf0f4d98b8e0cdb67576263b5577a676013823286e020a05bd45109937198f4209f5fe6240812d9790009f52bd291c4b6a22e56e

data/lib/VirtualMachineDriver.rb

@@ -50,6 +50,7 @@ class VirtualMachineDriver < OpenNebulaDriver
         :attach_nic  => "ATTACHNIC",
         :detach_nic  => "DETACHNIC",
         :disk_snapshot_create => "DISKSNAPSHOTCREATE",
+        :resize_disk => "RESIZEDISK",
         :update_sg   => "UPDATESG"
     }
 
@@ -93,6 +94,7 @@ class VirtualMachineDriver < OpenNebulaDriver
         register_action(ACTION[:attach_nic].to_sym, method("attach_nic"))
         register_action(ACTION[:detach_nic].to_sym, method("detach_nic"))
         register_action(ACTION[:disk_snapshot_create].to_sym, method("disk_snapshot_create"))
+        register_action(ACTION[:resize_disk].to_sym, method("resize_disk"))
         register_action(ACTION[:update_sg].to_sym, method("update_sg"))
     end
 
@@ -203,6 +205,11 @@ class VirtualMachineDriver < OpenNebulaDriver
         send_message(ACTION[:disk_snapshot_create],RESULT[:failure],id,error)
     end
 
+    def resize_disk(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:resize_disk],RESULT[:failure],id,error)
+    end
+
     def update_sg(id, drv_message)
         error = "Action not implemented by driver #{self.class}"
         send_message(ACTION[:update_sg],RESULT[:failure],id,error)

data/lib/cloud/CloudClient.rb

@@ -50,7 +50,7 @@ end
 module CloudClient
 
     # OpenNebula version
-    VERSION = '5.2.1'
+    VERSION = '5.3.80'
 
     # #########################################################################
     # Default location for the authentication file

data/lib/opennebula/acl.rb

@@ -23,19 +23,23 @@ module OpenNebula
     #                  @<num>
     #                  ALL
     #     RESOURCE  -> + separated list and "/{#,@,%}<num>|ALL"
-    #                  VM,
+    #                  VM
     #                  HOST
     #                  NET
     #                  IMAGE
     #                  USER
     #                  TEMPLATE
     #                  GROUP
-    #                  ACL
+    #                  DATASTORE
+    #                  CLUSTER
+    #                  DOCUMENT
+    #                  ZONE
     #                  SECGROUP
     #                  VDC
     #                  VROUTER
     #                  MARKETPLACE
     #                  MARKETPLACEAPP
+    #                  VMGROUP
     #     RIGHTS    -> + separated list
     #                  USE
     #                  MANAGE
@@ -67,7 +71,8 @@ module OpenNebula
             "VDC"           =>  0x2000000000000,
             "VROUTER"       =>  0x4000000000000,
             "MARKETPLACE"   =>  0x8000000000000,
-            "MARKETPLACEAPP"=> 0x10000000000000
+            "MARKETPLACEAPP"=> 0x10000000000000,
+            "VMGROUP"       => 0x20000000000000
         }
 
         RIGHTS =

data/lib/opennebula/client.rb

@@ -201,7 +201,7 @@ module OpenNebula
                     response[1] #response[1..-1]
                 end
             rescue Exception => e
-                Error.new(e.message)
+                Error.new(e.message, Error::EXML_RPC_CALL)
             end
         end
 

data/lib/opennebula/error.rb

@@ -28,8 +28,10 @@ module OpenNebula
         EACTION         = 0x0800
         EXML_RPC_API    = 0x1000
         EINTERNAL       = 0x2000
-        ENOTDEFINED     = 0x1111
-
+        EALLOCATE       = 0x4000
+        ENOTDEFINED     = 0xF001
+        EXML_RPC_CALL   = 0xF002
+        
         attr_reader :message, :errno
 
         # +message+ Description of the error
@@ -42,6 +44,11 @@ module OpenNebula
         def to_str()
             @message
         end
+
+        def is_exml_rpc_call?()
+            @errno == EXML_RPC_CALL
+        end
+
     end
 
     # Returns true if the object returned by a method of the OpenNebula
@@ -49,4 +56,5 @@ module OpenNebula
     def self.is_error?(value)
         value.class==OpenNebula::Error
     end
+
 end

data/lib/opennebula/group.rb

@@ -37,7 +37,7 @@ module OpenNebula
         SELF = -1
 
         # Default resource ACL's for group users (create)
-        GROUP_DEFAULT_ACLS = "VM+IMAGE+TEMPLATE+DOCUMENT+SECGROUP+VROUTER"
+        GROUP_DEFAULT_ACLS = "VM+IMAGE+TEMPLATE+DOCUMENT+SECGROUP+VROUTER+VMGROUP"
 
         # The default view for group and group admins, must be defined in
         # sunstone_views.yaml
@@ -104,14 +104,14 @@ module OpenNebula
             end
 
             # Allocate group
-            rc = self.allocate(group_hash[:name])
+            rc = allocate(group_hash[:name])
             return rc if OpenNebula.is_error?(rc)
 
             # Set group ACLs to create resources
             rc, msg = create_default_acls(group_hash[:resources])
 
             if OpenNebula.is_error?(rc)
-                self.delete
+                delete
                 error_msg =  "Error creating group ACL's: #{rc.message}"
                 return OpenNebula::Error.new(error_msg)
             end
@@ -119,7 +119,7 @@ module OpenNebula
             # Set group ACLs to share resources
             if group_hash[:shared_resources]
                 acls = Array.new
-                acls << "@#{self.id} #{group_hash[:shared_resources]}/@#{self.id} USE"
+                acls << "@#{id} #{group_hash[:shared_resources]}/@#{id} USE"
 
                 rc, msg = create_group_acls(acls)
 
@@ -134,7 +134,7 @@ module OpenNebula
             rc = create_admin_user(group_hash)
 
             if OpenNebula.is_error?(rc)
-                self.delete
+                delete
                 error_msg =  "Error creating admin user: #{rc.message}"
                 return OpenNebula::Error.new(error_msg)
             end
@@ -163,10 +163,40 @@ module OpenNebula
                 sunstone_attrs << "GROUP_ADMIN_DEFAULT_VIEW=#{GROUP_ADMIN_SUNSTONE_VIEWS}"
             end
 
+            do_update = false
+
             if sunstone_attrs.length > 0
-                rc = self.update("SUNSTONE=[#{sunstone_attrs.join(",\n")}]", true)
+                do_update = true
+
+                update_str = "SUNSTONE=[#{sunstone_attrs.join(",\n")}]\n"
+            end
+
+            opennebula_attrs = []
+
+            # Persistency attributes for new images
+            if group_hash[:opennebula]
+                if group_hash[:opennebula][:default_image_persistent]
+                    opennebula_attrs << "DEFAULT_IMAGE_PERSISTENT=\""\
+                        "#{group_hash[:opennebula][:default_image_persistent]}\""
+                end
+
+                if group_hash[:opennebula][:default_image_persistent_new]
+                    opennebula_attrs << "DEFAULT_IMAGE_PERSISTENT_NEW=\""\
+                        "#{group_hash[:opennebula][:default_image_persistent_new]}\""
+                end
+            end
+
+            if opennebula_attrs.length > 0
+                do_update = true
+
+                update_str += "OPENNEBULA=[#{opennebula_attrs.join(",\n")}]\n"
+            end
+
+            if do_update
+                rc = update(update_str, true)
+
                 if OpenNebula.is_error?(rc)
-                    self.delete
+                    delete
                     error_msg =  "Error updating group template: #{rc.message}"
                     return OpenNebula::Error.new(error_msg)
                 end

data/lib/opennebula/host.rb

@@ -223,12 +223,23 @@ module OpenNebula
             xml = OpenNebula::VirtualMachine.build_xml
             vm = OpenNebula::VirtualMachine.new(xml, @client)
 
-            rc = vm.allocate(template)
+            # vCenter wild VMs has a different process
+            # image and vnets objects representing existing nics and disks
+            # must be created and referenced
+            vcenter_wild_vm = wild.key? "VCENTER_TEMPLATE"
+            if vcenter_wild_vm
+                require 'vcenter_driver'
+                host_id = self["ID"]
+                vm_ref    = wild["DEPLOY_ID"]
+                return VCenterDriver::Importer.import_wild(host_id, vm_ref, vm, template)
+            else
+                rc = vm.allocate(template)
 
-            return rc if OpenNebula.is_error?(rc)
+                return rc if OpenNebula.is_error?(rc)
 
-            vm.deploy(id, false)
-            return vm.id
+                vm.deploy(id, false)
+                return vm.id
+            end
         end
 
         #######################################################################

data/lib/opennebula/server_cipher_auth.rb

@@ -39,12 +39,13 @@ class OpenNebula::ServerCipherAuth
         @srv_passwd = srv_passwd
 
         if !srv_passwd.empty?
-            @key = Digest::SHA1.hexdigest(@srv_passwd)
+            # truncate token to 32-bytes for Ruby >= 2.4
+            @key = Digest::SHA1.hexdigest(@srv_passwd)[0..31]
         else
             @key = ""
         end
 
-        @cipher = OpenSSL::Cipher::Cipher.new(CIPHER)
+        @cipher = OpenSSL::Cipher.new(CIPHER)
     end
 
     ###########################################################################
@@ -109,7 +110,8 @@ class OpenNebula::ServerCipherAuth
     # auth method for auth_mad
     def authenticate(srv_user,srv_pass, signed_text)
         begin
-            @key = srv_pass
+            # truncate token to 32-bytes for Ruby >= 2.4
+            @key = srv_pass[0..31]
 
             s_user, t_user, expires = decrypt(signed_text).split(':')
 

data/lib/opennebula/system.rb

@@ -29,7 +29,8 @@ module OpenNebula
             :groupquotainfo     => "groupquota.info",
             :groupquotaupdate   => "groupquota.update",
             :version            => "system.version",
-            :config             => "system.config"
+            :config             => "system.config",
+            :sql                => "system.sql"
         }
 
         #######################################################################
@@ -46,6 +47,17 @@ module OpenNebula
         # XML-RPC Methods
         #######################################################################
 
+        # Executes and replicates SQL commands on OpenNebula DB
+        #   @param [String] Sql string
+        #   @param [Boolean] True to replicate command on a federation. To
+        #   operate on federated tables
+        #   @return [Integer, OpenNebula::Error] Sql execution result in case
+        #   of success, Error otherwise
+        def sql_command(sql, federate)
+            return @client.call(SYSTEM_METHODS[:sql], sql, federate)
+        end
+
+        #
         # Gets the oned version
         #
         # @return [String, OpenNebula::Error] the oned version in case

data/lib/opennebula/virtual_machine.rb

@@ -47,6 +47,7 @@ module OpenNebula
             :disksnapshotcreate => "vm.disksnapshotcreate",
             :disksnapshotrevert => "vm.disksnapshotrevert",
             :disksnapshotdelete => "vm.disksnapshotdelete",
+            :diskresize     => "vm.diskresize",
             :updateconf     => "vm.updateconf"
         }
 
@@ -116,6 +117,9 @@ module OpenNebula
             DISK_SNAPSHOT_DELETE
             PROLOG_MIGRATE_UNKNOWN
             PROLOG_MIGRATE_UNKNOWN_FAILURE
+            DISK_RESIZE
+            DISK_RESIZE_POWEROFF
+            DISK_RESIZE_UNDEPLOYED
         }
 
         SHORT_VM_STATES={
@@ -193,26 +197,25 @@ module OpenNebula
             "DISK_SNAPSHOT"        => "snap",
             "DISK_SNAPSHOT_DELETE" => "snap",
             "PROLOG_MIGRATE_UNKNOWN" => "migr",
-            "PROLOG_MIGRATE_UNKNOWN_FAILURE" => "fail"
-        }
-
-        MIGRATE_REASON=%w{NONE ERROR USER}
-
-        SHORT_MIGRATE_REASON={
-            "NONE"          => "none",
-            "ERROR"         => "erro",
-            "USER"          => "user"
+            "PROLOG_MIGRATE_UNKNOWN_FAILURE" => "fail",
+            "DISK_RESIZE"            => "drsz",
+            "DISK_RESIZE_POWEROFF"   => "drsz",
+            "DISK_RESIZE_UNDEPLOYED" => "drsz"
         }
 
         HISTORY_ACTION=%w{none migrate live-migrate shutdown shutdown-hard
             undeploy undeploy-hard hold release stop suspend resume boot delete
             delete-recreate reboot reboot-hard resched unresched poweroff
             poweroff-hard disk-attach disk-detach nic-attach nic-detach
-            snap-create snap-delete terminate terminate-hard}
+            disk-snapshot-create disk-snapshot-delete terminate terminate-hard
+            disk-resize deploy chown chmod updateconf rename resize update
+            snapshot-resize snapshot-delete snapshot-revert disk-saveas
+            disk-snapshot-revert recover retry monitor}
 
         EXTERNAL_IP_ATTRS = [
             'GUEST_IP',
             'AWS_IP_ADDRESS',
+            'AWS_PUBLIC_IP_ADDRESS',
             'AWS_PRIVATE_IP_ADDRESS',
             'AZ_IPADDRESS',
             'SL_PRIMARYIPADDRESS'
@@ -256,13 +259,6 @@ module OpenNebula
             XMLElement.build_xml(vm_xml, 'VM')
         end
 
-        def VirtualMachine.get_reason(reason)
-            reason=MIGRATE_REASON[reason.to_i]
-            reason_str=SHORT_MIGRATE_REASON[reason]
-
-            reason_str
-        end
-
         def VirtualMachine.get_history_action(action)
             return HISTORY_ACTION[action.to_i]
         end
@@ -354,7 +350,7 @@ module OpenNebula
                 ds = OpenNebula::Datastore.new_with_id(ds_id, @client)
                 rc = ds.info
                 return rc if OpenNebula.is_error?(rc)
-               self.update("VCENTER_DATASTORE=#{ds['/DATASTORE/NAME']}", true)
+               self.update("VCENTER_DS_REF=#{ds['/DATASTORE/VCENTER_DS_REF']}", true)
             end
 
             return call(VM_METHODS[:deploy],
@@ -659,6 +655,16 @@ module OpenNebula
           return call(VM_METHODS[:disksnapshotdelete], @pe_id, disk_id, snap_id)
         end
 
+        # Changes the size of a disk
+        #
+        # @param disk_id [Integer] Id of the disk
+        # @param size [Integer] new size in MiB
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success or error
+        def disk_resize(disk_id, size)
+            return call(VM_METHODS[:diskresize], @pe_id, disk_id, size.to_s)
+        end
+
         # Recovers an ACTIVE VM
         #
         # @param result [Integer] Recover with failure (0), success (1),
@@ -739,13 +745,6 @@ module OpenNebula
             self['DEPLOY_ID']
         end
 
-        # Returns the deploy_id of the VirtualMachine (numeric value)
-        def keep_disks?
-            !self['USER_TEMPLATE/KEEP_DISKS_ON_DONE'].nil? &&
-                self['USER_TEMPLATE/KEEP_DISKS_ON_DONE'].downcase=="yes"
-        end
-
-
         # Clones the VM's source Template, replacing the disks with live snapshots
         # of the current disks. The VM capacity and NICs are also preserved
         #
@@ -755,6 +754,7 @@ module OpenNebula
         #
         # @return [Integer, OpenNebula::Error] the new Template ID in case of
         #   success, error otherwise
+        REMOVE_VNET_ATTRS = %w{AR_ID BRIDGE CLUSTER_ID IP MAC TARGET NIC_ID NETWORK_ID VN_MAD SECURITY_GROUPS}
         def save_as_template(name, persistent=nil)
             img_ids = []
             new_tid = nil
@@ -852,21 +852,18 @@ module OpenNebula
                 end
 
                 self.each('TEMPLATE/NIC') do |nic|
+
                     nic_id = nic["NIC_ID"]
                     if nic_id.nil? || nic_id.empty?
                         rc = Error.new('The NIC_ID is missing from the VM template')
                         raise
                     end
-
-                    net_id = nic["NETWORK_ID"]
-
-                    if !net_id.nil? && !net_id.empty?
-                        replace << "NIC = [ NETWORK_ID = #{net_id} ]\n"
-                    else
-                        # This NIC does not use a Virtual Network
-                        replace << self.template_like_str(
-                            "TEMPLATE", true, "NIC[NIC_ID=#{nic_id}]") << "\n"
+                     REMOVE_VNET_ATTRS.each do |attr|
+                        nic.delete_element(attr)
                     end
+
+                    replace << self.template_like_str(
+                        "TEMPLATE", true, "NIC[#{nic}]") << "\n"
                 end
 
                 # Required by the Sunstone Cloud View

data/lib/opennebula/virtual_network.rb

@@ -16,6 +16,7 @@
 
 
 require 'opennebula/pool_element'
+require 'ipaddr'
 
 module OpenNebula
     class VirtualNetwork < PoolElement
@@ -184,11 +185,9 @@ module OpenNebula
         def hold(ip, ar_id=-1)
             return Error.new('ID not defined') if !@pe_id
 
-            if ip.include?':'
-                addr_name = "MAC"
-            else
-                addr_name = "IP"
-            end
+            addr_name = address_type(ip)
+
+            return addr_name if OpenNebula.is_error?(addr_name)
 
             lease_template =  "LEASES = [ #{addr_name} = #{ip}"
             lease_template << ", AR_ID = #{ar_id}" if ar_id != -1
@@ -207,11 +206,9 @@ module OpenNebula
         def release(ip, ar_id=-1)
             return Error.new('ID not defined') if !@pe_id
 
-            if ip.include?':'
-                addr_name = "MAC"
-            else
-                addr_name = "IP"
-            end
+            addr_name = address_type(ip)
+
+            return addr_name if OpenNebula.is_error?(addr_name)
 
             lease_template =  "LEASES = [ #{addr_name} = #{ip}"
             lease_template << ", AR_ID = #{ar_id}" if ar_id != -1
@@ -243,11 +240,9 @@ module OpenNebula
             rtmpl << "NETWORK_ID = #{vnet}\n"  if !vnet.nil?
 
             if !addr.nil?
-                if addr.include?':'
-                    addr_name = "MAC"
-                else
-                    addr_name = "IP"
-                end
+                addr_name = address_type(addr)
+
+                return addr_name if OpenNebula.is_error?(addr_name)
 
                 rtmpl << "#{addr_name} = #{addr}\n"
             end
@@ -342,5 +337,27 @@ module OpenNebula
             chmod(-1, -1, -1, group_u, -1, -1, -1, -1, -1)
         end
 
+        # Returns the OpenNebula name of the address to use it in LEASE
+        # attributes. MAC, IP or IP6 is returned for MAC addresses in colon
+        # notation, ipv4 and ipv6 respectively
+        def address_type(addr)
+            begin
+                ipaddr = IPAddr.new addr
+
+                if ipaddr.ipv4?
+                    return "IP"
+                elsif ipaddr.ipv6?
+                    return "IP6"
+                else
+                    return Error.new('Unknown IP type')
+                end
+            rescue
+                if /^(\h{2}:){5}\h{2}$/ =~ addr
+                    return "MAC"
+                else
+                    return Error.new('Unknown address type')
+                end
+            end
+        end
     end
 end

data/lib/opennebula/vm_group.rb

@@ -0,0 +1,151 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2017, OpenNebula Project, OpenNebula Systems                #
+#                                                                            #
+# 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 VMGroup < PoolElement
+        #######################################################################
+        # Constants and Class Methods
+        #######################################################################
+        VMGROUP_METHODS = {
+            :allocate    => "vmgroup.allocate",
+            :info        => "vmgroup.info",
+            :update      => "vmgroup.update",
+            :delete      => "vmgroup.delete",
+            :chown       => "vmgroup.chown",
+            :chmod       => "vmgroup.chmod",
+            :rename      => "vmgroup.rename"
+        }
+
+        # Creates a VMGroup description with just its identifier
+        # this method should be used to create plain VMGroup objects.
+        # @param pe_id [Integer] the id of the object
+        def VMGroup.build_xml(pe_id=nil)
+            if pe_id
+                obj_xml = "<VM_GROUP><ID>#{pe_id}</ID></VM_GROUP>"
+            else
+                obj_xml = "<VM_GROUP></VM_GROUP>"
+            end
+
+            XMLElement.build_xml(obj_xml,'VM_GROUP')
+        end
+
+        # Class constructor
+        def initialize(xml, client)
+            super(xml,client)
+
+            @client = client
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the VMGroup Object
+        #######################################################################
+
+        # Retrieves the information of the VMGroup.
+        def info()
+            super(VMGROUP_METHODS[:info], 'VM_GROUP')
+        end
+
+        alias_method :info!, :info
+
+        # Allocates a new VMGroup in OpenNebula
+        #
+        # @param description [String] The contents of the VMGroup.
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def allocate(description)
+            super(VMGROUP_METHODS[:allocate], description)
+        end
+
+        # Deletes the SecurityGroup
+        def delete()
+            super(VMGROUP_METHODS[:delete])
+        end
+
+        # Replaces the vm group contents
+        #
+        # @param new_vmgroup [String] New vmgroup 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_vmgroup, append=false)
+            super(VMGROUP_METHODS[:update], new_vmgroup, 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(VMGROUP_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(VMGROUP_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(VMGROUP_METHODS[:chmod], owner_u, owner_m, owner_a, group_u,
+                group_m, group_a, other_u, other_m, other_a)
+        end
+
+        # Renames this VMGroup
+        #
+        # @param name [String] New name for the VMGroup.
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def rename(name)
+            return call(VMGROUP_METHODS[:rename], @pe_id, name)
+        end
+
+        #######################################################################
+        # Helpers to get VMGroup 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
+
+        # [return] _Array_ with the name of roles
+        def role_names
+            self.retrieve_elements('ROLES/ROLE/NAME')
+        end
+    end
+end