1825 lines
72 KiB
JavaScript
1825 lines
72 KiB
JavaScript
/* -------------------------------------------------------------------------- */
|
||
/* 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);
|
||
}
|
||
}
|
||
|
||
}
|