From 5288c9f3ef7cf2f6daac5ed3c2d2b6c5ed56e98f Mon Sep 17 00:00:00 2001
From: Philippe Caseiro <pcaseiro@cadoles.com>
Date: Wed, 20 Apr 2016 14:12:28 +0200
Subject: [PATCH] =?UTF-8?q?Ajout=20du=20script=20opennebula.js=20qui=20cor?=
 =?UTF-8?q?rige=20le=20probl=C3=A8me=20d'upload=20d'images?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 bugfix/opennebula.js | 1824 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1824 insertions(+)
 create mode 100644 bugfix/opennebula.js

diff --git a/bugfix/opennebula.js b/bugfix/opennebula.js
new file mode 100644
index 0000000..f365299
--- /dev/null
+++ b/bugfix/opennebula.js
@@ -0,0 +1,1824 @@
+/* -------------------------------------------------------------------------- */
+/* Copyright 2002-2014, 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.                                             */
+/* -------------------------------------------------------------------------- */
+
+if (typeof(csrftoken) != "undefined")
+{
+    $.ajaxPrefilter(function(options, originalOptions, jqXHR) {
+        var params = originalOptions.data;
+
+        if (typeof(params)=="string")
+        {
+            params = JSON.parse(params);
+            params["csrftoken"] = csrftoken;
+            options.data = JSON.stringify(params);
+        }
+        else
+        {
+            params = params || {};
+            params["csrftoken"] = csrftoken;
+            options.data = $.param(params);
+        }
+    });
+}
+
+$.ajaxSetup({
+  converters: {
+    "text json": function( textValue ) {
+      return jQuery.parseJSON(jQuery('<div/>').text(textValue).html());
+    }
+  }
+});
+
+var list_cache = {};
+var list_waiting = {};
+var list_callbacks = {};
+var cache_expire = 60000; //ms
+
+
+var OpenNebula = {
+
+    "Error": function(resp)
+    {
+        var error = {};
+        if (resp.responseText)
+        {
+            try {
+                error = JSON.parse(resp.responseText);
+            }
+            catch (e) {
+                error.error = {message: "It appears there was a server exception. Please check server's log."};
+            };
+        }
+        else
+        {
+            error.error = {};
+        }
+        error.error.http_status = resp.status;
+        return error;
+    },
+
+    "is_error": function(obj)
+    {
+        return obj.error ? true : false;
+    },
+
+    "Helper": {
+        "resource_state": function(type, value)
+        {
+            var state;
+            switch(type)
+            {
+                case "HOST":
+                case "host":
+                    state = tr(["INIT",
+                               "MONITORING_MONITORED",
+                               "MONITORED",
+                               "ERROR",
+                               "DISABLED",
+                               "MONITORING_ERROR",
+                               "MONITORING_INIT",
+                               "MONITORING_DISABLED"][value]);
+                    break;
+                case "HOST_SIMPLE":
+                case "host_simple":
+                    state = tr(["INIT",
+                               "UPDATE",
+                               "ON",
+                               "ERROR",
+                               "OFF",
+                               "RETRY",
+                               "INIT",
+                               "OFF"][value]);
+                    break;
+                case "VM":
+                case "vm":
+                    state = tr(["INIT",
+                               "PENDING",
+                               "HOLD",
+                               "ACTIVE",
+                               "STOPPED",
+                               "SUSPENDED",
+                               "DONE",
+                               "FAILED",
+                               "POWEROFF",
+                               "UNDEPLOYED"][value]);
+                    break;
+                case "VM_LCM":
+                case "vm_lcm":
+                    state = tr(["LCM_INIT",
+                               "PROLOG",
+                               "BOOT",
+                               "RUNNING",
+                               "MIGRATE",
+                               "SAVE",
+                               "SAVE",
+                               "SAVE",
+                               "MIGRATE",
+                               "PROLOG",
+                               "EPILOG",
+                               "EPILOG",
+                               "SHUTDOWN",
+                               "SHUTDOWN",
+                               "FAILURE",
+                               "CLEANUP",
+                               "UNKNOWN",
+                               "HOTPLUG",
+                               "SHUTDOWN",
+                               "BOOT",
+                               "BOOT",
+                               "BOOT",
+                               "BOOT",
+                               "CLEANUP",
+                               "SNAPSHOT",
+                               "HOTPLUG",
+                               "HOTPLUG",
+                               "HOTPLUG",
+                               "HOTPLUG",
+                               "SHUTDOWN",
+                               "EPILOG",
+                               "PROLOG",
+                               "BOOT"][value]);
+                    break;
+                case "IMAGE":
+                case "image":
+                    state = tr(["INIT",
+                               "READY",
+                               "USED",
+                               "DISABLED",
+                               "LOCKED",
+                               "ERROR",
+                               "CLONE",
+                               "DELETE",
+                               "USED_PERS"][value]);
+                    break;
+                case "VM_MIGRATE_REASON":
+                case "vm_migrate_reason":
+                    state = tr(["NONE",
+                               "ERROR",
+                               "USER"][value]);
+                    break;
+                case "VM_MIGRATE_ACTION":
+                case "vm_migrate_action":
+                    state = tr(["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"][value]);
+                    break;
+                default:
+                    return value;
+            }
+            if (!state) state = value
+            return state;
+        },
+
+        "image_type": function(value)
+        {
+            return ["OS", "CDROM", "DATABLOCK", "KERNEL", "RAMDISK", "CONTEXT"][value];
+        },
+
+        "action": function(action, params)
+        {
+            obj = {
+                "action": {
+                    "perform": action
+                }
+            }
+            if (params)
+            {
+                obj.action.params = params;
+            }
+            return obj;
+        },
+
+        "request": function(resource, method, data) {
+            var r = {
+                "request": {
+                    "resource"  : resource,
+                    "method"    : method
+                }
+            }
+            if (data)
+            {
+                if (typeof(data) != "array")
+                {
+                    data = [data];
+                }
+                r.request.data = data;
+            }
+            return r;
+        },
+
+        "pool": function(resource, response)
+        {
+            var pool_name = resource + "_POOL";
+            var type = resource;
+            var pool;
+
+            if (typeof(pool_name) == "undefined")
+            {
+                return Error('Incorrect Pool');
+            }
+
+            var p_pool = [];
+
+            if (response[pool_name]) {
+                pool = response[pool_name][type];
+            } else {
+                pool = null;
+            }
+
+            if (pool == null)
+            {
+                return p_pool;
+            }
+            else if (pool.length)
+            {
+                for (i=0;i<pool.length;i++)
+                {
+                    p_pool[i]={};
+                    p_pool[i][type]=pool[i];
+                }
+                return(p_pool);
+            }
+            else
+            {
+                p_pool[0] = {};
+                p_pool[0][type] = pool;
+                return(p_pool);
+            }
+        },
+
+        "pool_hash_processing": function(pool_name, resource_name, response)
+        {
+            var pool;
+
+            if (typeof(pool_name) == "undefined")
+            {
+                return Error('Incorrect Pool');
+            }
+
+            var p_pool = {};
+
+            if (response[pool_name]) {
+                pool = response[pool_name][resource_name];
+            } else {
+                pool = null;
+            }
+
+            if (pool == null)
+            {
+                return p_pool;
+            }
+            else if (pool.length)
+            {
+                for (i=0;i<pool.length;i++)
+                {
+                    var res = {};
+                    res[resource_name] = pool[i];
+
+                    p_pool[res[resource_name]['ID']] = res;
+                }
+                return(p_pool);
+            }
+            else
+            {
+                var res = {};
+                res[resource_name] = pool;
+
+                p_pool[res[resource_name]['ID']] = res;
+
+                return(p_pool);
+            }
+        },
+
+        "clear_cache" : function(cache_name){
+            list_cache[cache_name] = null;
+            //console.log(cache_name+" cache cleaned");
+        }
+    },
+
+    "Action": {
+
+        //server requests helper methods
+
+        "create": function(params, resource, path){
+            var callback = params.success;
+            var callback_error = params.error;
+            var data = params.data;
+            var request = OpenNebula.Helper.request(resource,"create", data);
+            var req_path = path ? path : resource.toLowerCase();
+            var cache_name = params.cache_name ? params.cache_name : resource;
+
+            $.ajax({
+                url: req_path,
+                type: "POST",
+                dataType: "json",
+                data: JSON.stringify(data),
+                success: function(response){
+                    OpenNebula.Helper.clear_cache(cache_name);
+
+                    return callback ? callback(request, response) : null;
+                },
+                error: function(response){
+                    return callback_error ?
+                        callback_error(request, OpenNebula.Error(response)) : null;
+                }
+            });
+        },
+
+        "del": function(params, resource, path){
+            var callback = params.success;
+            var callback_error = params.error;
+            var id = params.data.id;
+            var request = OpenNebula.Helper.request(resource,"delete", id);
+            var req_path = path ? path : resource.toLowerCase();
+            var cache_name = params.cache_name ? params.cache_name : resource;
+
+            $.ajax({
+                url: req_path + "/" + id,
+                type: "DELETE",
+                success: function(){
+                    OpenNebula.Helper.clear_cache(cache_name);
+
+                    return callback ? callback(request) : null;
+                },
+                error: function(response){
+                    return callback_error ?
+                        callback_error(request, OpenNebula.Error(response)) : null;
+                }
+            });
+        },
+
+        "list": function(params, resource, path){
+            var callback = params.success;
+            var callback_error = params.error;
+            var timeout = params.timeout || false;
+            var request = OpenNebula.Helper.request(resource,"list");
+            var req_path = path ? path : resource.toLowerCase();
+            var cache_name = params.cache_name ? params.cache_name : resource;
+
+            var options = params.options;
+            var force = false;
+            if (options){
+                force = options.force;
+            }
+
+            if (force){
+                OpenNebula.Helper.clear_cache(cache_name);
+            }
+
+            if( !force &&
+                list_cache[cache_name] &&
+                list_cache[cache_name]["timestamp"] + cache_expire > new Date().getTime()){
+
+                //console.log(cache_name+" list. Cache used");
+
+                return callback ?
+                    callback(request, list_cache[cache_name]["data"]) : null;
+            }
+
+            // TODO: Because callbacks are queued, we may need to force a
+            // timeout. Otherwise a blocked call cannot be retried.
+
+            if (!list_callbacks[cache_name]){
+                list_callbacks[cache_name] = [];
+            }
+
+            list_callbacks[cache_name].push({
+                success : callback,
+                error : callback_error
+            });
+
+            //console.log(cache_name+" list. Callback queued");
+
+            if (list_waiting[cache_name]){
+                return;
+            }
+
+            list_waiting[cache_name] = true;
+
+            //console.log(cache_name+" list. NO cache, calling ajax");
+
+            $.ajax({
+                url: req_path,
+                type: "GET",
+                data: {timeout: timeout},
+                dataType: "json",
+                success: function(response){
+                    var list = OpenNebula.Helper.pool(resource,response)
+
+                    list_cache[cache_name] = {
+                        timestamp   : new Date().getTime(),
+                        data        : list
+                    };
+
+                    list_waiting[cache_name] = false;
+
+                    for (var i=0; i<list_callbacks[cache_name].length; i++)
+                    {
+                        var callback = list_callbacks[cache_name][i].success;
+
+                        if (callback){
+                            //console.log(cache_name+" list. Callback called");
+                            callback(request, list);
+                        }
+                    }
+
+                    list_callbacks[cache_name] = [];
+
+                    return;
+                },
+                error: function(response)
+                {
+                    list_waiting[cache_name] = false;
+
+                    for (var i=0; i<list_callbacks[cache_name].length; i++)
+                    {
+                        var callback = list_callbacks[cache_name][i].error;
+
+                        if (callback){
+                            //console.log(cache_name+" list. ERROR Callback called");
+                            callback(request, OpenNebula.Error(response));
+                        }
+                    }
+
+                    list_callbacks[cache_name] = [];
+
+                    return;
+                }
+            });
+        },
+
+        "list_in_zone": function(params, resource, path){
+            var callback = params.success;
+            var callback_error = params.error;
+            var timeout = params.timeout || false;
+            var request = OpenNebula.Helper.request(resource,"list");
+            var req_path = path ? path : resource.toLowerCase();
+
+            $.ajax({
+                url: req_path,
+                type: "GET",
+                data: {timeout: timeout, zone_id: params.data.zone_id},
+                dataType: "json",
+                success: function(response){
+                    var list = OpenNebula.Helper.pool(resource,response)
+                    return callback ?
+                        callback(request, list) : null;
+                },
+                error: function(response)
+                {
+                    return callback_error ?
+                        callback_error(request, OpenNebula.Error(response)) : null;
+                }
+            });
+        },
+
+        //Subresource examples: "fetch_template", "log"...
+        "show": function(params, resource, subresource, path){
+            var callback = params.success;
+            var callback_error = params.error;
+            var id = params.data.id;
+            var request = subresource ?
+                OpenNebula.Helper.request(resource,subresource,id) :
+                OpenNebula.Helper.request(resource,"show", id);
+
+            var req_path = path ? path : resource.toLowerCase();
+            var url = req_path + "/" + id;
+            url = subresource? url + "/" + subresource : url;
+
+            $.ajax({
+                url: url,
+                type: "GET",
+                dataType: "json",
+                success: function(response){
+                    return callback ? callback(request, response) : null;
+                },
+                error: function(response){
+                    return callback_error ?
+                        callback_error(request, OpenNebula.Error(response)) : null;
+                }
+            });
+        },
+
+        "chown": function(params, resource, path){
+            var id = params.data.extra_param;
+            var action_obj = {"owner_id": id,
+                              "group_id": "-1"};
+
+            OpenNebula.Action.simple_action(params,
+                                            resource,
+                                            "chown",
+                                            action_obj,
+                                            path);
+        },
+
+        "chgrp": function(params, resource, path){
+            var id = params.data.extra_param;
+            var action_obj = {"owner_id": "-1",
+                              "group_id": id};
+
+            OpenNebula.Action.simple_action(params,
+                                            resource,
+                                            "chown",
+                                            action_obj,
+                                            path);
+        },
+
+        //Example: Simple action: publish. Simple action with action obj: deploy
+        "simple_action": function(params, resource, method, action_obj, path){
+            var callback = params.success;
+            var callback_error = params.error;
+            var id = params.data.id;
+
+            var action,request;
+            if (action_obj) {
+                action = OpenNebula.Helper.action(method, action_obj);
+                request = OpenNebula.Helper.request(resource,method, [id, action_obj]);
+            } else {
+                action = OpenNebula.Helper.action(method);
+                request = OpenNebula.Helper.request(resource,method, id);
+            };
+
+            var req_path = path ? path : resource.toLowerCase();
+            var cache_name = params.cache_name ? params.cache_name : resource;
+
+            $.ajax({
+                url: req_path + "/" + id + "/action",
+                type: "POST",
+                data: JSON.stringify(action),
+                success: function(){
+                    OpenNebula.Helper.clear_cache(cache_name);
+
+                   return callback ? callback(request) : null;
+                },
+                error: function(response){
+                    return callback_error ?
+                        callback_error(request, OpenNebula.Error(response)) : null;
+                }
+            });
+        },
+
+        "monitor": function(params, resource, all, path){
+            var callback = params.success;
+            var callback_error = params.error;
+            var data = params.data;
+
+            var method = "monitor";
+            var request = OpenNebula.Helper.request(resource,method, data);
+
+            var url = path ? path : resource.toLowerCase();
+            url = all ? url + "/monitor" : url + "/" + params.data.id + "/monitor";
+
+            $.ajax({
+                url: url,
+                type: "GET",
+                data: data['monitor'],
+                dataType: "json",
+                success: function(response){
+                    return callback ? callback(request, response) : null;
+                },
+                error: function(response){
+                    return callback_error ?
+                        callback_error(request, OpenNebula.Error(response)) : null;
+                }
+            });
+        },
+
+        "accounting": function(params, resource, path){
+            var callback = params.success;
+            var callback_error = params.error;
+            var data = params.data;
+
+            var method = "accounting";
+            var request = OpenNebula.Helper.request(resource,method, data);
+
+            var url = path ? path : resource.toLowerCase() + "/accounting";
+
+            $.ajax({
+                url: url,
+                type: "GET",
+                data: data,
+                dataType: "json",
+                success: function(response){
+                    return callback ? callback(request, response) : null;
+                },
+                error: function(response){
+                    return callback_error ?
+                        callback_error(request, OpenNebula.Error(response)) : null;
+                }
+            });
+        },
+    },
+
+    "Auth": {
+        "resource": "AUTH",
+
+        "login": function(params)
+        {
+            var callback = params.success;
+            var callback_error = params.error;
+            var username = params.data.username;
+            var password = params.data.password;
+            var remember = params.remember;
+
+            var resource = OpenNebula.Auth.resource;
+            var request = OpenNebula.Helper.request(resource,"login");
+
+            $.ajax({
+                url: "login",
+                type: "POST",
+                data: {remember: remember},
+                beforeSend : function(req) {
+                    var token = username + ':' + password;
+                    var authString = 'Basic ';
+                    if (typeof(btoa) === 'function')
+                        authString += btoa(unescape(encodeURIComponent( token )))
+                    else {
+                        token = CryptoJS.enc.Utf8.parse(token);
+                        authString += CryptoJS.enc.Base64.stringify(token)
+                    }
+
+                    req.setRequestHeader( "Authorization", authString);
+                },
+                success: function(response){
+                    return callback ? callback(request, response) : null;
+                },
+                error: function(response){
+                    return callback_error ?
+                        callback_error(request, OpenNebula.Error(response)) : null;
+                }
+            });
+        },
+
+        "logout": function(params)
+        {
+            var callback = params.success;
+            var callback_error = params.error;
+
+            var resource = OpenNebula.Auth.resource;
+            var request = OpenNebula.Helper.request(resource,"logout");
+
+            $.ajax({
+                url: "logout",
+                type: "POST",
+                success: function(response){
+                    $.cookie("one-user", null);
+                    return callback ? callback(request, response) : null;
+                },
+                error: function(response){
+                    return callback_error ?
+                        callback_error(request, OpenNebula.Error(response)) : null;
+                }
+            });
+        }
+    },
+
+
+    "Host": {
+        "resource": "HOST",
+
+        "create": function(params){
+            OpenNebula.Action.create(params,OpenNebula.Host.resource);
+        },
+        "del": function(params){
+            OpenNebula.Action.del(params,OpenNebula.Host.resource);
+        },
+        "list": function(params){
+            OpenNebula.Action.list(params,OpenNebula.Host.resource);
+        },
+        "show": function(params){
+            OpenNebula.Action.show(params,OpenNebula.Host.resource);
+        },
+        "update": function(params){
+            var action_obj = {"template_raw" : params.data.extra_param };
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Host.resource,
+                                            "update",
+                                            action_obj);
+        },
+        "fetch_template" : function(params){
+            OpenNebula.Action.show(params,OpenNebula.Host.resource,"template");
+        },
+        "enable": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.Host.resource,"enable");
+        },
+        "disable": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.Host.resource,"disable");
+        },
+        "monitor" : function(params){
+            OpenNebula.Action.monitor(params,OpenNebula.Host.resource,false);
+        },
+        "pool_monitor" : function(params){
+            OpenNebula.Action.monitor(params,OpenNebula.Host.resource,true);
+        },
+        "rename" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Host.resource,
+                                            "rename",
+                                            action_obj);
+        }
+    },
+
+    "Network": {
+        "resource": "VNET",
+
+        "create": function(params){
+            OpenNebula.Action.create(params,OpenNebula.Network.resource);
+        },
+        "del": function(params){
+            OpenNebula.Action.del(params,OpenNebula.Network.resource);
+        },
+        "list": function(params){
+            OpenNebula.Action.list(params,OpenNebula.Network.resource);
+        },
+        "show": function(params){
+            OpenNebula.Action.show(params,OpenNebula.Network.resource);
+        },
+        "chown" : function(params){
+            OpenNebula.Action.chown(params,OpenNebula.Network.resource);
+        },
+        "chgrp" : function(params){
+            OpenNebula.Action.chgrp(params,OpenNebula.Network.resource);
+        },
+        "chmod" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Network.resource,
+                                            "chmod",
+                                            action_obj);
+        },
+        "publish": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.Network.resource,"publish");
+        },
+        "unpublish": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.Network.resource,"unpublish");
+        },
+        "hold" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Network.resource,
+                                            "hold",
+                                            action_obj);
+        },
+        "release" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Network.resource,
+                                            "release",
+                                            action_obj);
+        },
+        "add_ar" : function(params){
+            var action_obj = {"ar_template" : params.data.extra_param };
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Network.resource,
+                                            "add_ar",
+                                            action_obj);
+        },
+        "rm_ar" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Network.resource,
+                                            "rm_ar",
+                                            action_obj);
+        },
+        "update_ar": function(params){
+            var action_obj = {"ar_template" : params.data.extra_param };
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Network.resource,
+                                            "update_ar",
+                                            action_obj);
+        },
+        "reserve": function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Network.resource,
+                                            "reserve",
+                                            action_obj);
+        },
+        "update": function(params){
+            var action_obj = {"template_raw" : params.data.extra_param };
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Network.resource,
+                                            "update",
+                                            action_obj);
+        },
+        "fetch_template" : function(params){
+            OpenNebula.Action.show(params,OpenNebula.Network.resource,"template");
+        },
+        "rename" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Network.resource,
+                                            "rename",
+                                            action_obj);
+        }
+    },
+
+    "VM": {
+        "resource": "VM",
+
+        "create": function(params){
+            OpenNebula.Action.create(params,OpenNebula.VM.resource);
+        },
+        "del": function(params){
+            OpenNebula.Action.del(params,OpenNebula.VM.resource);
+        },
+        "list": function(params){
+            OpenNebula.Action.list(params,OpenNebula.VM.resource);
+        },
+        "show": function(params){
+            OpenNebula.Action.show(params,OpenNebula.VM.resource);
+        },
+        "chown" : function(params){
+            OpenNebula.Action.chown(params,OpenNebula.VM.resource);
+        },
+        "chgrp" : function(params){
+            OpenNebula.Action.chgrp(params,OpenNebula.VM.resource);
+        },
+        "chmod" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.VM.resource,
+                                            "chmod",
+                                            action_obj);
+        },
+        "shutdown": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"shutdown");
+        },
+        "hold": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"hold");
+        },
+        "release": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"release");
+        },
+        "stop": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"stop");
+        },
+        "cancel": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"cancel");
+        },
+        "suspend": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"suspend");
+        },
+        "resume": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"resume");
+        },
+        "restart": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"restart");
+        },
+        "resubmit": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"resubmit");
+        },
+        "poweroff" : function(params){
+            var action_obj = {"hard": false};
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"poweroff", action_obj);
+        },
+        "poweroff_hard" : function(params){
+            var action_obj = {"hard": true};
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"poweroff", action_obj);
+        },
+        "undeploy" : function(params){
+            var action_obj = {"hard": false};
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"undeploy", action_obj);
+        },
+        "undeploy_hard" : function(params){
+            var action_obj = {"hard": true};
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"undeploy", action_obj);
+        },
+        "reboot" : function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"reboot");
+        },
+        "reset" : function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"reset");
+        },
+
+        "log": function(params){
+            OpenNebula.Action.show(params,OpenNebula.VM.resource,"log");
+        },
+        "deploy": function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,
+                                            "deploy",action_obj);
+        },
+        "livemigrate": function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,
+                                            "livemigrate",action_obj);
+        },
+        "migrate": function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,
+                                            "migrate",action_obj);
+        },
+        "saveas": function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,
+                                            "saveas",action_obj);
+        },
+        "snapshot_create": function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,
+                                            "snapshot_create",action_obj);
+        },
+        "snapshot_revert": function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,
+                                            "snapshot_revert",action_obj);
+        },
+        "snapshot_delete": function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,
+                                            "snapshot_delete",action_obj);
+        },
+        "vnc" : function(params,startstop){
+            var callback = params.success;
+            var callback_error = params.error;
+            var id = params.data.id;
+            var resource = OpenNebula.VM.resource;
+
+            var method = startstop;
+            var action = OpenNebula.Helper.action(method);
+            var request = OpenNebula.Helper.request(resource,method, id);
+            $.ajax({
+                url: "vm/" + id + "/" + method,
+                type: "POST",
+                dataType: "json",
+                success: function(response){
+                    return callback ? callback(request, response) : null;
+                },
+                error: function(response){
+                    return callback_error ?
+                        callback_error(request, OpenNebula.Error(response)) : null;
+                }
+            });
+        },
+        "startvnc" : function(params){
+            OpenNebula.VM.vnc(params,"startvnc");
+        },
+        "update": function(params){
+            var action_obj = {"template_raw" : params.data.extra_param };
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.VM.resource,
+                                            "update",
+                                            action_obj);
+        },
+        "monitor" : function(params){
+            OpenNebula.Action.monitor(params,OpenNebula.VM.resource,false);
+        },
+        "pool_monitor" : function(params){
+            OpenNebula.Action.monitor(params,OpenNebula.VM.resource,true);
+        },
+        "resize" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,
+                                            "resize",action_obj);
+        },
+        "attachdisk" : function(params){
+            var action_obj = {"disk_template": params.data.extra_param};
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,
+                                            "attachdisk",action_obj);
+        },
+        "detachdisk" : function(params){
+            var action_obj = {"disk_id": params.data.extra_param};
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,
+                                            "detachdisk",action_obj);
+        },
+        "attachnic" : function(params){
+            var action_obj = {"nic_template": params.data.extra_param};
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,
+                                            "attachnic",action_obj);
+        },
+        "detachnic" : function(params){
+            var action_obj = {"nic_id": params.data.extra_param};
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,
+                                            "detachnic",action_obj);
+        },
+        "rename" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.VM.resource,
+                                            "rename",
+                                            action_obj);
+        },
+        "resched" : function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"resched");
+        },
+        "unresched" : function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"unresched");
+        },
+        "recover" : function(params){
+            var action_obj = {"with": params.data.extra_param};
+            OpenNebula.Action.simple_action(params,OpenNebula.VM.resource,"recover",action_obj);
+        },
+        "accounting": function(params){
+            OpenNebula.Action.accounting(params,OpenNebula.VM.resource);
+        },
+    },
+
+    "Group": {
+        "resource": "GROUP",
+
+        "create": function(params){
+            OpenNebula.Action.create(params,OpenNebula.Group.resource);
+        },
+        "del": function(params){
+            OpenNebula.Action.del(params,OpenNebula.Group.resource);
+        },
+        "list": function(params){
+
+            var resource = OpenNebula.Group.resource
+            var req_path = resource.toLowerCase();
+
+            var callback = params.success;
+            var callback_error = params.error;
+            var timeout = params.timeout || false;
+            var request = OpenNebula.Helper.request(resource,"list");
+
+            $.ajax({
+                url: req_path,
+                type: "GET",
+                data: {timeout: timeout},
+                dataType: "json",
+                success: function(response){
+                    // Get the default group quotas
+                    default_group_quotas = Quotas.default_quotas(response.GROUP_POOL.DEFAULT_GROUP_QUOTAS);
+
+                    var list = OpenNebula.Helper.pool(resource,response)
+                    var quotas_hash = OpenNebula.Helper.pool_hash_processing(
+                        'GROUP_POOL','QUOTAS',response);
+
+                    return callback ?
+                        callback(request, list, quotas_hash) : null;
+                },
+                error: function(response)
+                {
+                    return callback_error ?
+                        callback_error(request, OpenNebula.Error(response)) : null;
+                }
+            });
+        },
+        "update": function(params){
+            var action_obj = {"template_raw" : params.data.extra_param };
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Group.resource,
+                                            "update",
+                                            action_obj);
+        },
+        "set_quota" : function(params){
+            var action_obj = { quotas :  params.data.extra_param };
+            OpenNebula.Action.simple_action(params,OpenNebula.Group.resource,"set_quota",action_obj);
+        },
+        "show" : function(params){
+            OpenNebula.Action.show(params,OpenNebula.Group.resource);
+        },
+        "accounting" : function(params){
+            OpenNebula.Action.monitor(params,OpenNebula.Group.resource,false);
+        },
+        "add_provider" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,OpenNebula.Group.resource,"add_provider",action_obj);
+        },
+        "del_provider" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,OpenNebula.Group.resource,"del_provider",action_obj);
+        }
+    },
+
+    "User": {
+        "resource": "USER",
+
+        "create": function(params){
+            OpenNebula.Action.create(params,OpenNebula.User.resource);
+        },
+        "del": function(params){
+            OpenNebula.Action.del(params,OpenNebula.User.resource);
+        },
+        "list": function(params){
+
+            var resource = OpenNebula.User.resource
+            var req_path = resource.toLowerCase();
+
+            var callback = params.success;
+            var callback_error = params.error;
+            var timeout = params.timeout || false;
+            var request = OpenNebula.Helper.request(resource,"list");
+
+            $.ajax({
+                url: req_path,
+                type: "GET",
+                data: {timeout: timeout},
+                dataType: "json",
+                success: function(response){
+                    default_user_quotas = Quotas.default_quotas(response.USER_POOL.DEFAULT_USER_QUOTAS);
+
+                    var list = OpenNebula.Helper.pool(resource,response)
+                    var quotas_hash = OpenNebula.Helper.pool_hash_processing(
+                        'USER_POOL','QUOTAS',response);
+
+                    return callback ?
+                        callback(request, list, quotas_hash) : null;
+                },
+                error: function(response)
+                {
+                    return callback_error ?
+                        callback_error(request, OpenNebula.Error(response)) : null;
+                }
+            });
+        },
+        "show" : function(params){
+            OpenNebula.Action.show(params,OpenNebula.User.resource);
+        },
+        "passwd": function(params){
+            var action_obj = {"password": params.data.extra_param };
+            OpenNebula.Action.simple_action(params,OpenNebula.User.resource,
+                                            "passwd",action_obj);
+        },
+        "chgrp" : function(params){
+            var action_obj = {"group_id": params.data.extra_param };
+            OpenNebula.Action.simple_action(params,OpenNebula.User.resource,
+                                            "chgrp",action_obj);
+        },
+        "chauth" : function(params){
+            var action_obj = {"auth_driver" : params.data.extra_param };
+            OpenNebula.Action.simple_action(params,OpenNebula.User.resource,
+                                            "chauth",action_obj);
+        },
+        "update": function(params){
+            var action_obj = {"template_raw" : params.data.extra_param };
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.User.resource,
+                                            "update",
+                                            action_obj);
+        },
+        "fetch_template" : function(params){
+            OpenNebula.Action.show(params,OpenNebula.User.resource,"template");
+        },
+        "accounting" : function(params){
+            OpenNebula.Action.monitor(params,OpenNebula.User.resource,false);
+        },
+        "set_quota" : function(params){
+            var action_obj = { quotas :  params.data.extra_param };
+            OpenNebula.Action.simple_action(params,OpenNebula.User.resource,"set_quota",action_obj);
+        },
+        "addgroup" : function(params){
+            var action_obj = {"group_id": params.data.extra_param };
+            OpenNebula.Action.simple_action(params,OpenNebula.User.resource,
+                                            "addgroup",action_obj);
+        },
+        "delgroup" : function(params){
+            var action_obj = {"group_id": params.data.extra_param };
+            OpenNebula.Action.simple_action(params,OpenNebula.User.resource,
+                                            "delgroup",action_obj);
+        }
+    },
+
+    "Image": {
+        "resource": "IMAGE",
+
+        "create": function(params){
+            OpenNebula.Action.create(params,OpenNebula.Image.resource);
+        },
+        "del": function(params){
+            OpenNebula.Action.del(params,OpenNebula.Image.resource);
+        },
+        "list": function(params){
+            OpenNebula.Action.list(params,OpenNebula.Image.resource);
+        },
+        "show": function(params){
+            OpenNebula.Action.show(params,OpenNebula.Image.resource);
+        },
+        "chown" : function(params){
+            OpenNebula.Action.chown(params,OpenNebula.Image.resource);
+        },
+        "chgrp" : function(params){
+            OpenNebula.Action.chgrp(params,OpenNebula.Image.resource);
+        },
+        "chmod" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Image.resource,
+                                            "chmod",
+                                            action_obj);
+        },
+        "update": function(params){
+            var action_obj = {"template_raw" : params.data.extra_param };
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Image.resource,
+                                            "update",
+                                            action_obj);
+        },
+        "fetch_template" : function(params){
+            OpenNebula.Action.show(params,OpenNebula.Image.resource,"template");
+        },
+        "enable": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.Image.resource,"enable");
+        },
+        "disable": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.Image.resource,"disable");
+        },
+        "persistent": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.Image.resource,"persistent");
+        },
+        "nonpersistent": function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.Image.resource,"nonpersistent");
+        },
+        "chtype": function(params){
+            var action_obj = {"type" : params.data.extra_param};
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Image.resource,
+                                            "chtype",
+                                            action_obj);
+        },
+        "clone" : function(params) {
+            var imgName = params.data.extra_param ? params.data.extra_param : "";
+            var action_obj = { "name": imgName };
+            OpenNebula.Action.simple_action(params,OpenNebula.Image.resource, "clone", action_obj);
+        },
+        "rename" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Image.resource,
+                                            "rename",
+                                            action_obj);
+        }
+    },
+
+    "Template" : {
+        "resource" : "VMTEMPLATE",
+
+        "create" : function(params){
+            OpenNebula.Action.create(params,OpenNebula.Template.resource);
+        },
+        "del" : function(params){
+            OpenNebula.Action.del(params,OpenNebula.Template.resource);
+        },
+        "list" : function(params){
+            OpenNebula.Action.list(params,OpenNebula.Template.resource);
+        },
+        "show" : function(params){
+            OpenNebula.Action.show(params,OpenNebula.Template.resource);
+        },
+        "chown" : function(params){
+            OpenNebula.Action.chown(params,OpenNebula.Template.resource);
+        },
+        "chgrp" : function(params){
+            OpenNebula.Action.chgrp(params,OpenNebula.Template.resource);
+        },
+        "chmod" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Template.resource,
+                                            "chmod",
+                                            action_obj);
+        },
+        "update" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                     OpenNebula.Template.resource,
+                                     "update",
+                                     action_obj);
+        },
+        "fetch_template" : function(params){
+            OpenNebula.Action.show(params,OpenNebula.Template.resource,"template");
+        },
+        "publish" : function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.Template.resource,"publish");
+        },
+        "unpublish" : function(params){
+            OpenNebula.Action.simple_action(params,OpenNebula.Template.resource,"unpublish");
+        },
+        "instantiate" : function(params) {
+            var action_obj = params.data.extra_param ? params.data.extra_param : {};
+            OpenNebula.Action.simple_action(params,OpenNebula.Template.resource,
+                                            "instantiate",action_obj);
+        },
+        "clone" : function(params) {
+            var name = params.data.extra_param ? params.data.extra_param : "";
+            var action_obj = { "name" : name };
+            OpenNebula.Action.simple_action(params,OpenNebula.Template.resource, "clone", action_obj);
+        },
+        "rename" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Template.resource,
+                                            "rename",
+                                            action_obj);
+        }
+    },
+
+    "Acl" : {
+        "resource" : "ACL",
+
+        "create" : function(params){
+            OpenNebula.Action.create(params,OpenNebula.Acl.resource);
+        },
+        "del" : function(params){
+            OpenNebula.Action.del(params,OpenNebula.Acl.resource);
+        },
+        "list" : function(params){
+            OpenNebula.Action.list(params,OpenNebula.Acl.resource);
+        }
+    },
+
+    "Cluster" : {
+        "resource" : "CLUSTER",
+
+        "create" : function(params){
+            OpenNebula.Action.create(params,OpenNebula.Cluster.resource);
+        },
+        "del" : function(params){
+            OpenNebula.Action.del(params,OpenNebula.Cluster.resource);
+        },
+        "list" : function(params){
+            OpenNebula.Action.list(params,OpenNebula.Cluster.resource);
+        },
+        "list_in_zone" : function(params){
+            OpenNebula.Action.list_in_zone(params,OpenNebula.Cluster.resource);
+        },
+        "show" : function(params){
+            OpenNebula.Action.show(params,OpenNebula.Cluster.resource);
+        },
+        "addhost" : function(params){
+            var action_obj = { "host_id": params.data.extra_param };
+            OpenNebula.Action.simple_action(params,OpenNebula.Cluster.resource,
+                                            "addhost",action_obj);
+        },
+        "delhost" : function(params){
+            var action_obj = { "host_id": params.data.extra_param };
+            OpenNebula.Action.simple_action(params,OpenNebula.Cluster.resource,
+                                            "delhost",action_obj);
+        },
+        "adddatastore" : function(params){
+            var action_obj = { "ds_id": params.data.extra_param };
+            OpenNebula.Action.simple_action(params,OpenNebula.Cluster.resource,
+                                            "adddatastore",action_obj);
+        },
+        "deldatastore" : function(params){
+            var action_obj = { "ds_id": params.data.extra_param };
+            OpenNebula.Action.simple_action(params,OpenNebula.Cluster.resource,
+                                            "deldatastore",action_obj);
+        },
+        "addvnet" : function(params){
+            var action_obj = { "vnet_id": params.data.extra_param };
+            OpenNebula.Action.simple_action(params,OpenNebula.Cluster.resource,
+                                            "addvnet",action_obj);
+        },
+        "delvnet" : function(params){
+            var action_obj = { "vnet_id": params.data.extra_param };
+            OpenNebula.Action.simple_action(params,OpenNebula.Cluster.resource,
+                                            "delvnet",action_obj);
+        },
+        "fetch_template" : function(params){
+            OpenNebula.Action.show(params,OpenNebula.Cluster.resource,"template");
+        },
+        "update" : function(params){
+            var action_obj = {"template_raw" : params.data.extra_param };
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Cluster.resource,
+                                            "update",
+                                            action_obj);
+        },
+        "rename" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Cluster.resource,
+                                            "rename",
+                                            action_obj);
+        }
+    },
+    "Datastore" : {
+        "resource" : "DATASTORE",
+
+        "create" : function(params){
+            OpenNebula.Action.create(params,OpenNebula.Datastore.resource);
+        },
+        "del" : function(params){
+            OpenNebula.Action.del(params,OpenNebula.Datastore.resource);
+        },
+        "list" : function(params){
+            OpenNebula.Action.list(params,OpenNebula.Datastore.resource);
+        },
+        "show" : function(params){
+            OpenNebula.Action.show(params,OpenNebula.Datastore.resource);
+        },
+        "chown" : function(params){
+            OpenNebula.Action.chown(params,OpenNebula.Datastore.resource);
+        },
+        "chgrp" : function(params){
+            OpenNebula.Action.chgrp(params,OpenNebula.Datastore.resource);
+        },
+        "chmod" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Datastore.resource,
+                                            "chmod",
+                                            action_obj);
+        },
+        "update" : function(params){
+            var action_obj = {"template_raw" : params.data.extra_param };
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Datastore.resource,
+                                            "update",
+                                            action_obj);
+        },
+        "fetch_template" : function(params){
+            OpenNebula.Action.show(params,OpenNebula.Datastore.resource,"template");
+        },
+        "rename" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Datastore.resource,
+                                            "rename",
+                                            action_obj);
+        }
+    },
+
+    "Zone" : {
+        "resource" : "ZONE",
+
+        "create" : function(params){
+            OpenNebula.Action.create(params,OpenNebula.Zone.resource);
+        },
+        "del" : function(params){
+            OpenNebula.Action.del(params,OpenNebula.Zone.resource);
+        },
+        "list" : function(params){
+            OpenNebula.Action.list(params,OpenNebula.Zone.resource);
+        },
+        "show" : function(params){
+            OpenNebula.Action.show(params,OpenNebula.Zone.resource);
+        },
+        "update" : function(params){
+            var action_obj = {"template_raw" : params.data.extra_param };
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Zone.resource,
+                                            "update",
+                                            action_obj);
+        },
+        "fetch_template" : function(params){
+            OpenNebula.Action.show(params,OpenNebula.Zone.resource,"template");
+        },
+        "rename" : function(params){
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Zone.resource,
+                                            "rename",
+                                            action_obj);
+        }
+    },
+
+    "Marketplace" : {
+        "resource" : "MARKETPLACE",
+
+        "show" : function(params){
+            params.error = function() {
+                return notifyError("Cannot connect to OpenNebula Marketplace")
+            };
+            OpenNebula.Action.show(params,OpenNebula.Marketplace.resource);
+        },
+        "list" : function(params){
+            //Custom list request function, since the contents do not come
+            //in the same format as the rest of opennebula resources.
+            var callback = params.success;
+            var callback_error = params.error;
+            var timeout = params.timeout || false;
+            var request = OpenNebula.Helper.request('MARKETPLACE','list');
+
+            $.ajax({
+                url: 'marketplace',
+                type: 'GET',
+                data: {timeout: timeout},
+                dataType: "json",
+                success: function(response){
+                    $(".marketplace_error_message").hide();
+                    return callback ? callback(request, response) : null;
+                },
+                error: function(res){
+                    $(".marketplace_error_message").show();
+                    return callback_error ? callback_error(request, OpenNebula.Error(res)) : null;
+                }
+            });
+        }
+    },
+
+    "Service" : {
+        "resource" : 'DOCUMENT',
+        "path"     : 'service',
+        "del": function(params){
+            params.cache_name = "SERVICE";
+            OpenNebula.Action.del(params,OpenNebula.Service.resource, OpenNebula.Service.path);
+        },
+        "list" : function(params){
+            params.cache_name = "SERVICE";
+            OpenNebula.Action.list(params, OpenNebula.Service.resource, OpenNebula.Service.path)
+        },
+        "show" : function(params){
+            params.cache_name = "SERVICE";
+            OpenNebula.Action.show(params, OpenNebula.Service.resource, false, OpenNebula.Service.path)
+        },
+        "chown" : function(params){
+            params.cache_name = "SERVICE";
+            OpenNebula.Action.chown(params,OpenNebula.Service.resource, OpenNebula.Service.path);
+        },
+        "chgrp" : function(params){
+            params.cache_name = "SERVICE";
+            OpenNebula.Action.chgrp(params,OpenNebula.Service.resource, OpenNebula.Service.path);
+        },
+        "chmod" : function(params){
+            params.cache_name = "SERVICE";
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Service.resource,
+                                            "chmod",
+                                            action_obj,
+                                            OpenNebula.Service.path);
+        },
+        "shutdown" : function(params){
+            params.cache_name = "SERVICE";
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Service.resource,
+                                            "shutdown",
+                                            null,
+                                            OpenNebula.Service.path);
+        },
+        "recover" : function(params){
+            params.cache_name = "SERVICE";
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Service.resource,
+                                            "recover",
+                                            null,
+                                            OpenNebula.Service.path);
+        },
+        "state" : function(state_int){
+            var state = [
+                tr("PENDING"),
+                tr("DEPLOYING"),
+                tr("RUNNING"),
+                tr("UNDEPLOYING"),
+                tr("WARNING"),
+                tr("DONE"),
+                tr("FAILED_UNDEPLOYING"),
+                tr("FAILED_DEPLOYING"),
+                tr("SCALING"),
+                tr("FAILED_SCALING"),
+                tr("COOLDOWN")
+            ][state_int]
+            return state ? state : state_int;
+        }
+    },
+
+    "Role" : {
+        "resource" : 'DOCUMENT',
+        "path"     : 'service',
+        "state" : function(state_int){
+            state_int = state_int ? state_int : 0;
+            var state = [
+                tr("PENDING"),
+                tr("DEPLOYING"),
+                tr("RUNNING"),
+                tr("UNDEPLOYING"),
+                tr("WARNING"),
+                tr("DONE"),
+                tr("FAILED_UNDEPLOYING"),
+                tr("FAILED_DEPLOYING"),
+                tr("SCALING"),
+                tr("FAILED_SCALING"),
+                tr("COOLDOWN")
+            ][state_int]
+            return state ? state : state_int;
+        },
+        "hold" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "hold",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "release" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "release",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "suspend" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "suspend",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "resume" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "resume",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "stop" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "stop",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "boot" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "boot",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "delete_recreate" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "delete-recreate",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "reboot" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "reboot",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "reboot_hard" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "reboot-hard",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "poweroff" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "poweroff",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "poweroff_hard" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "poweroff-hard",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "undeploy" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "undeploy",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "undeploy_hard" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "undeploy-hard",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "snapshot_create" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "snapshot-create",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "shutdown" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "shutdown",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "cancel" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "shutdown-hard",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "del" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "delete",
+                                            generate_batch_action_params(),
+                                            OpenNebula.Role.path);
+        },
+        "recover" : function(params){
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.Role.resource,
+                                            "recover",
+                                            null,
+                                            OpenNebula.Role.path);
+        },
+        "update" : function(params){
+            request = OpenNebula.Helper.request(OpenNebula.Role.resource, "update", params.data.id);
+
+            $.ajax({
+                url: OpenNebula.Role.path + "/" + params.data.id,
+                type: "PUT",
+                dataType: "json",
+                data: JSON.stringify(params.data.extra_param),
+                success: function(response){
+                    return roleCallback(request, response);
+                },
+                error: function(response){
+                    return onError(request, OpenNebula.Error(response));
+                }
+            });
+        }
+    },
+
+
+    "ServiceTemplate" : {
+        "resource" : 'DOCUMENT',
+        "path"     : 'service_template',
+        "create": function(params){
+            params.cache_name = "SERVICE_TEMPLATE";
+            OpenNebula.Action.create(params, OpenNebula.ServiceTemplate.resource, OpenNebula.ServiceTemplate.path);
+        },
+
+        "instantiate": function(params){
+            params.cache_name = "SERVICE_TEMPLATE";
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.ServiceTemplate.resource,
+                                            "instantiate",
+                                            action_obj,
+                                            OpenNebula.ServiceTemplate.path);
+        },
+        "update": function(params){
+            params.cache_name = "SERVICE_TEMPLATE";
+            var action_obj = {"template_json" : params.data.extra_param };
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.ServiceTemplate.resource,
+                                            "update",
+                                            action_obj,
+                                            OpenNebula.ServiceTemplate.path);
+        },
+        "del": function(params){
+            params.cache_name = "SERVICE_TEMPLATE";
+            OpenNebula.Action.del(params,OpenNebula.ServiceTemplate.resource, OpenNebula.ServiceTemplate.path);
+        },
+        "list" : function(params){
+            params.cache_name = "SERVICE_TEMPLATE";
+            OpenNebula.Action.list(params, OpenNebula.ServiceTemplate.resource, OpenNebula.ServiceTemplate.path)
+        },
+        "show" : function(params){
+            params.cache_name = "SERVICE_TEMPLATE";
+            OpenNebula.Action.show(params, OpenNebula.ServiceTemplate.resource, false, OpenNebula.ServiceTemplate.path)
+        },
+        "chown" : function(params){
+            params.cache_name = "SERVICE_TEMPLATE";
+            OpenNebula.Action.chown(params,OpenNebula.ServiceTemplate.resource, OpenNebula.ServiceTemplate.path);
+        },
+        "chgrp" : function(params){
+            params.cache_name = "SERVICE_TEMPLATE";
+            OpenNebula.Action.chgrp(params,OpenNebula.ServiceTemplate.resource, OpenNebula.ServiceTemplate.path);
+        },
+        "chmod" : function(params){
+            params.cache_name = "SERVICE_TEMPLATE";
+            var action_obj = params.data.extra_param;
+            OpenNebula.Action.simple_action(params,
+                                            OpenNebula.ServiceTemplate.resource,
+                                            "chmod",
+                                            action_obj,
+                                            OpenNebula.ServiceTemplate.path);
+        }
+    }
+
+}