shaba/one
1
0
Fork 0
mirror of https://github.com/OpenNebula/one.git synced 2025-03-05 08:58:17 +03:00
Code Releases Wiki Activity

F #4032: Speed up C++ build (#4035)

Browse Source 
In Nebula.h use forward declarations instead of #include
This commit is contained in:
Pavel Czerný 2019-12-10 11:45:15 +01:00 committed by Ruben S. Montero
parent f56fa0d311
commit 8d12e78fbe
121 changed files with 2208 additions and 1640 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/AclManager.h
View File

@ -23,11 +23,10 @@
#include "AclRule.h"
#include "NebulaLog.h"
#include "SqlDB.h"
using namespace std;
class PoolObjectAuth;
class SqlDB;
extern "C" void * acl_action_loop(void *arg);

2
include/Callbackable.h
View File

@ -22,7 +22,7 @@
#include <set>
#include <vector>
#include <string.h>
#include <string>
using namespace std;

4
include/Client.h
View File

@ -21,11 +21,7 @@
#include <xmlrpc-c/client_simple.hpp>
#include <xmlrpc-c/girerr.hpp>
#include <iostream>
#include <string>
#include <sstream>
#include "NebulaLog.h"
using namespace std;

2
include/Cluster.h
View File

@ -17,7 +17,7 @@
#ifndef CLUSTER_H_
#define CLUSTER_H_
#include "PoolSQL.h"
#include "PoolObjectSQL.h"
#include "ObjectCollection.h"
#include "DatastorePool.h"
#include "ClusterTemplate.h"

2
include/ClusterPool.h
View File

@ -18,7 +18,7 @@
#define CLUSTER_POOL_H_
#include "Cluster.h"
#include "SqlDB.h"
#include "PoolSQL.h"
using namespace std;

2
include/Datastore.h
View File

@ -17,7 +17,7 @@
#ifndef DATASTORE_H_
#define DATASTORE_H_
#include "PoolSQL.h"
#include "PoolObjectSQL.h"
#include "ObjectCollection.h"
#include "DatastoreTemplate.h"
#include "Clusterable.h"

2
include/DatastorePool.h
View File

@ -18,7 +18,7 @@
#define DATASTORE_POOL_H_
#include "Datastore.h"
#include "SqlDB.h"
#include "PoolSQL.h"
using namespace std;

2
include/DefaultQuotas.h
View File

@ -18,8 +18,6 @@
#define DEFAULT_QUOTAS_H_
#include "Quotas.h"
#include "SqlDB.h"
#include "ObjectSQL.h"
class DefaultQuotas : public Quotas
{

3
include/Group.h
View File

@ -17,10 +17,9 @@
#ifndef GROUP_H_
#define GROUP_H_
#include "PoolSQL.h"
#include "PoolObjectSQL.h"
#include "GroupTemplate.h"
#include "ObjectCollection.h"
#include "User.h"
#include "QuotasSQL.h"
#include "Template.h"
#include "VMActions.h"

2
include/GroupPool.h
View File

@ -18,7 +18,7 @@
#define GROUP_POOL_H_
#include "Group.h"
#include "SqlDB.h"
#include "PoolSQL.h"
using namespace std;

2
include/Host.h
View File

@ -17,7 +17,7 @@
#ifndef HOST_H_
#define HOST_H_
#include "PoolSQL.h"
#include "PoolObjectSQL.h"
#include "HostTemplate.h"
#include "HostShare.h"
#include "ClusterableSingle.h"

8
include/HostPool.h
View File

@ -24,8 +24,6 @@
#include <time.h>
#include <sstream>
#include <iostream>
#include <vector>
using namespace std;
@ -56,7 +54,7 @@ public:
string& error_str);
/**
* Updates a Host in the data base. It also updates the previous state
* Updates a Host in the data base. It also updates the previous state
* after executing the hooks.
* @param objsql a pointer to the Host
*
@ -373,12 +371,12 @@ private:
struct HostVM
{
/**
* Tmp set of lost VM IDs.
* Tmp set of lost VM IDs.
*/
set<int> tmp_lost_vms;
/**
* Tmp set of zombie VM IDs.
* Tmp set of zombie VM IDs.
*/
set<int> tmp_zombie_vms;

1
include/MarketPlaceManagerDriver.h
View File

@ -19,7 +19,6 @@
#include <map>
#include <string>
#include <sstream>
#include "Mad.h"

4
include/MarketPlacePool.h
View File

@ -18,10 +18,8 @@
#define MARKETPLACE_POOL_H_
#include "MarketPlace.h"
#include "NebulaLog.h"
#include "SqlDB.h"
#include "PoolSQL.h"
class SqlDB;
class MarketPlaceApp;
class MarketPlacePool : public PoolSQL

120
include/Nebula.h
View File

@ -17,50 +17,50 @@
#ifndef NEBULA_H_
#define NEBULA_H_
#include "LogDB.h"
#include "NebulaTemplate.h"
#include "SystemDB.h"
#include "NebulaTemplate.h"
#include "VirtualMachinePool.h"
#include "VirtualNetworkPool.h"
#include "HostPool.h"
#include "UserPool.h"
#include "VMTemplatePool.h"
#include "GroupPool.h"
#include "DatastorePool.h"
#include "ClusterPool.h"
#include "DocumentPool.h"
#include "ZonePool.h"
#include "SecurityGroupPool.h"
#include "VdcPool.h"
#include "VirtualRouterPool.h"
#include "MarketPlacePool.h"
#include "MarketPlaceAppPool.h"
#include "VMGroupPool.h"
#include "VNTemplatePool.h"
#include "HookPool.h"
#include "VirtualMachineManager.h"
#include "LifeCycleManager.h"
#include "InformationManager.h"
#include "TransferManager.h"
#include "DispatchManager.h"
#include "RequestManager.h"
#include "HookManager.h"
#include "HookLog.h"
#include "AuthManager.h"
#include "AclManager.h"
#include "ImageManager.h"
#include "MarketPlaceManager.h"
#include "IPAMManager.h"
#include "RaftManager.h"
#include "FedReplicaManager.h"
#include "DefaultQuotas.h"
#include "UserPool.h"
#include "Callbackable.h"
class LogDB;
class FedLogDB;
class User;
class ClusterPool;
class DatastorePool;
class DocumentPool;
class GroupPool;
class HookPool;
class HostPool;
class ImagePool;
class MarketPlacePool;
class MarketPlaceAppPool;
class SecurityGroupPool;
class VdcPool;
class VMGroupPool;
class VMTemplatePool;
class VNTemplatePool;
class VirtualMachinePool;
class VirtualNetworkPool;
class VirtualRouterPool;
class ZonePool;
class AclManager;
class AuthManager;
class DispatchManager;
class FedReplicaManager;
class HookLog;
class HookManager;
class ImageManager;
class InformationManager;
class IPAMManager;
class LifeCycleManager;
class MarketPlaceManager;
class RaftManager;
class RequestManager;
class TransferManager;
class VirtualMachineManager;
/**
* This is the main class for the OpenNebula daemon oned. It stores references
@ -768,47 +768,7 @@ private:
}
};
~Nebula()
{
delete vmpool;
delete vnpool;
delete hpool;
delete upool;
delete ipool;
delete gpool;
delete tpool;
delete dspool;
delete clpool;
delete docpool;
delete zonepool;
delete secgrouppool;
delete vdcpool;
delete vrouterpool;
delete marketpool;
delete apppool;
delete vmgrouppool;
delete vmm;
delete lcm;
delete im;
delete tm;
delete dm;
delete rm;
delete hm;
delete hl;
delete authm;
delete aclm;
delete imagem;
delete marketm;
delete ipamm;
delete raftm;
delete frm;
delete nebula_configuration;
delete logdb;
delete fed_logdb;
delete system_db;
delete vntpool;
delete hkpool;
};
~Nebula();
Nebula& operator=(Nebula const&){return *this;};

1
include/NebulaLog.h
View File

@ -18,7 +18,6 @@
#define _NEBULA_LOG_H_
#include "Log.h"
#include "NebulaUtil.h"
#include <sstream>
#include <syslog.h>

2
include/PoolObjectSQL.h
View File

@ -22,7 +22,7 @@
#include "Template.h"
#include <pthread.h>
#include <string.h>
#include <string>
using namespace std;

1
include/PoolSQL.h
View File

@ -22,7 +22,6 @@
#include "SqlDB.h"
#include "PoolObjectSQL.h"
#include "PoolSQLCache.h"
#include "Log.h"
using namespace std;

2
include/RaftManager.h
View File

@ -27,6 +27,8 @@ extern "C" void * raft_manager_loop(void *arg);
extern "C" void * reconciling_thread(void *arg);
class LogDBRecord;
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */

2
include/Request.h
View File

@ -24,7 +24,7 @@
#include "AuthRequest.h"
#include "PoolObjectSQL.h"
#include "Quotas.h"
#include "History.h"
#include "UserPool.h"
using namespace std;

27
include/RequestManager.h
View File

@ -18,20 +18,13 @@
#define REQUEST_MANAGER_H_
#include "ActionManager.h"
#include "VirtualMachinePool.h"
#include "HostPool.h"
#include "UserPool.h"
#include "VirtualNetworkPool.h"
#include "ImagePool.h"
#include "VMTemplatePool.h"
#include "GroupPool.h"
#include "AuthManager.h"
#include <xmlrpc-c/base.hpp>
#include <xmlrpc-c/registry.hpp>
#include <xmlrpc-c/server_abyss.hpp>
#include <set>
using namespace std;
extern "C" void * rm_action_loop(void *arg);
@ -193,21 +186,7 @@ private:
// ------------------------------------------------------------------------
// ActioListener Interface
// ------------------------------------------------------------------------
virtual void finalize_action(const ActionRequest& ar)
{
NebulaLog::log("ReM",Log::INFO,"Stopping Request Manager...");
pthread_cancel(rm_xml_server_thread);
pthread_join(rm_xml_server_thread,0);
NebulaLog::log("ReM",Log::INFO,"XML-RPC server stopped.");
if ( socket_fd != -1 )
{
close(socket_fd);
}
};
void finalize_action(const ActionRequest& ar) override;
};
#endif

18
include/RequestManagerAllocate.h
View File

@ -24,6 +24,24 @@
#include "ImageTemplate.h"
#include "VirtualMachineTemplate.h"
#include "DatastoreTemplate.h"
#include "MarketPlaceTemplate.h"
#include "ClusterPool.h"
#include "DocumentPool.h"
#include "HookPool.h"
#include "HostPool.h"
#include "ImagePool.h"
#include "MarketPlacePool.h"
#include "MarketPlaceAppPool.h"
#include "SecurityGroupPool.h"
#include "VdcPool.h"
#include "VirtualMachinePool.h"
#include "VirtualNetworkPool.h"
#include "VirtualRouterPool.h"
#include "VMGroupPool.h"
#include "VMTemplatePool.h"
#include "VNTemplatePool.h"
#include "ZonePool.h"
using namespace std;

13
include/RequestManagerChmod.h
View File

@ -20,6 +20,19 @@
#include "Request.h"
#include "Nebula.h"
#include "DatastorePool.h"
#include "DocumentPool.h"
#include "ImagePool.h"
#include "MarketPlacePool.h"
#include "MarketPlaceAppPool.h"
#include "SecurityGroupPool.h"
#include "VirtualMachinePool.h"
#include "VirtualNetworkPool.h"
#include "VirtualRouterPool.h"
#include "VMGroupPool.h"
#include "VMTemplatePool.h"
#include "VNTemplatePool.h"
using namespace std;
/* ------------------------------------------------------------------------- */

13
include/RequestManagerChown.h
View File

@ -20,6 +20,19 @@
#include "Request.h"
#include "Nebula.h"
#include "DatastorePool.h"
#include "DocumentPool.h"
#include "ImagePool.h"
#include "MarketPlacePool.h"
#include "MarketPlaceAppPool.h"
#include "SecurityGroupPool.h"
#include "VirtualMachinePool.h"
#include "VirtualNetworkPool.h"
#include "VirtualRouterPool.h"
#include "VMGroupPool.h"
#include "VMTemplatePool.h"
#include "VNTemplatePool.h"
using namespace std;
/* ------------------------------------------------------------------------- */

4
include/RequestManagerClone.h
View File

@ -21,6 +21,10 @@
#include "RequestManagerVMTemplate.h"
#include "Nebula.h"
#include "DocumentPool.h"
#include "SecurityGroupPool.h"
#include "VNTemplatePool.h"
using namespace std;
/* ------------------------------------------------------------------------- */

3
include/RequestManagerCluster.h
View File

@ -19,6 +19,9 @@
#include "Request.h"
#include "Nebula.h"
#include "ClusterPool.h"
#include "DatastorePool.h"
#include "VirtualNetworkPool.h"
using namespace std;

6
include/RequestManagerDatastore.h
View File

@ -19,6 +19,7 @@
#include "Request.h"
#include "Nebula.h"
#include "DatastorePool.h"
using namespace std;
@ -40,8 +41,7 @@ protected:
auth_object = PoolObjectSQL::DATASTORE;
auth_op = AuthRequest::MANAGE;
};
~RequestManagerDatastore(){};
~RequestManagerDatastore() = default;
/* --------------------------------------------------------------------- */
@ -58,7 +58,7 @@ public:
DatastoreEnable(): RequestManagerDatastore("one.datastore.enable",
"Enables or disables an datastore", "A:sib"){};
~DatastoreEnable(){};
~DatastoreEnable() = default;
void request_execute(xmlrpc_c::paramList const& _paramList,
RequestAttributes& att) override;

232
include/RequestManagerDelete.h
View File

@ -18,8 +18,11 @@
#define REQUEST_MANAGER_DELETE_H_
#include "Request.h"
#include "Nebula.h"
#include "AuthManager.h"
#include "ClusterPool.h"
#include "Host.h"
#include "VirtualNetwork.h"
class AclManager;
using namespace std;
@ -32,28 +35,12 @@ class RequestManagerDelete: public Request
protected:
RequestManagerDelete(const string& method_name,
const string& params,
const string& help)
:Request(method_name, params, help)
{
auth_op = AuthRequest::MANAGE;
Nebula& nd = Nebula::instance();
clpool = nd.get_clpool();
aclm = nd.get_aclm();
};
const string& help);
RequestManagerDelete(const string& method_name,
const string& help)
:Request(method_name, "A:si", help)
{
auth_op = AuthRequest::MANAGE;
const string& help);
Nebula& nd = Nebula::instance();
clpool = nd.get_clpool();
aclm = nd.get_aclm();
};
~RequestManagerDelete(){};
~RequestManagerDelete() = default;
void request_execute(xmlrpc_c::paramList const& paramList,
@ -90,17 +77,9 @@ protected:
class TemplateDelete : public RequestManagerDelete
{
public:
TemplateDelete():
RequestManagerDelete("one.template.delete",
"A:sib"
"Deletes a virtual machine template")
{
Nebula& nd = Nebula::instance();
pool = nd.get_tpool();
auth_object = PoolObjectSQL::TEMPLATE;
};
TemplateDelete();
~TemplateDelete(){};
~TemplateDelete() = default;
ErrorCode request_execute(int oid, bool recursive, RequestAttributes& att)
{
@ -118,17 +97,9 @@ protected:
class VirtualNetworkTemplateDelete : public RequestManagerDelete
{
public:
VirtualNetworkTemplateDelete():
RequestManagerDelete("one.vntemplate.delete",
"A:si",
"Deletes a virtual network template")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vntpool();
auth_object = PoolObjectSQL::VNTEMPLATE;
};
VirtualNetworkTemplateDelete();
~VirtualNetworkTemplateDelete(){};
~VirtualNetworkTemplateDelete() = default;
ErrorCode request_execute(int oid, bool recursive, RequestAttributes& att)
{
@ -143,16 +114,9 @@ public:
class VirtualNetworkDelete: public RequestManagerDelete
{
public:
VirtualNetworkDelete():
RequestManagerDelete("one.vn.delete",
"Deletes a virtual network")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vnpool();
auth_object = PoolObjectSQL::NET;
};
VirtualNetworkDelete();
~VirtualNetworkDelete(){};
~VirtualNetworkDelete() = default;
protected:
@ -175,15 +139,9 @@ protected:
class ImageDelete: public RequestManagerDelete
{
public:
ImageDelete():
RequestManagerDelete("one.image.delete", "Deletes an image")
{
Nebula& nd = Nebula::instance();
pool = nd.get_ipool();
auth_object = PoolObjectSQL::IMAGE;
};
ImageDelete();
~ImageDelete(){};
~ImageDelete() = default;
ErrorCode request_execute(int oid, RequestAttributes& att)
{
@ -204,16 +162,9 @@ protected:
class HostDelete : public RequestManagerDelete
{
public:
HostDelete():
RequestManagerDelete("one.host.delete", "Deletes a host")
{
Nebula& nd = Nebula::instance();
pool = nd.get_hpool();
auth_object = PoolObjectSQL::HOST;
auth_op = AuthRequest::ADMIN;
};
HostDelete();
~HostDelete(){};
~HostDelete() = default;
protected:
@ -240,17 +191,9 @@ protected:
class GroupDelete: public RequestManagerDelete
{
public:
GroupDelete():
RequestManagerDelete("one.group.delete", "Deletes a group")
{
Nebula& nd = Nebula::instance();
pool = nd.get_gpool();
GroupDelete();
auth_object = PoolObjectSQL::GROUP;
auth_op = AuthRequest::ADMIN;
};
~GroupDelete(){};
~GroupDelete() = default;
protected:
@ -263,18 +206,9 @@ protected:
class UserDelete: public RequestManagerDelete
{
public:
UserDelete():
RequestManagerDelete("one.user.delete", "Deletes a user")
{
Nebula& nd = Nebula::instance();
pool = nd.get_upool();
gpool = nd.get_gpool();
UserDelete();
auth_object = PoolObjectSQL::USER;
auth_op = AuthRequest::ADMIN;
};
~UserDelete(){};
~UserDelete() = default;
protected:
@ -289,16 +223,9 @@ protected:
class DatastoreDelete: public RequestManagerDelete
{
public:
DatastoreDelete():
RequestManagerDelete("one.datastore.delete", "Deletes a datastore")
{
Nebula& nd = Nebula::instance();
pool = nd.get_dspool();
auth_object = PoolObjectSQL::DATASTORE;
auth_op = AuthRequest::ADMIN;
};
DatastoreDelete();
~DatastoreDelete(){};
~DatastoreDelete() = default;
/* -------------------------------------------------------------------- */
@ -321,17 +248,9 @@ public:
class ClusterDelete: public RequestManagerDelete
{
public:
ClusterDelete():
RequestManagerDelete("one.cluster.delete", "Deletes a cluster")
{
Nebula& nd = Nebula::instance();
pool = nd.get_clpool();
ClusterDelete();
auth_object = PoolObjectSQL::CLUSTER;
auth_op = AuthRequest::ADMIN;
};
~ClusterDelete(){};
~ClusterDelete() = default;
protected:
@ -344,16 +263,9 @@ protected:
class DocumentDelete : public RequestManagerDelete
{
public:
DocumentDelete():
RequestManagerDelete("one.document.delete",
"Deletes a generic document")
{
Nebula& nd = Nebula::instance();
pool = nd.get_docpool();
auth_object = PoolObjectSQL::DOCUMENT;
};
DocumentDelete();
~DocumentDelete(){};
~DocumentDelete() = default;
};
/* ------------------------------------------------------------------------- */
@ -362,16 +274,9 @@ public:
class ZoneDelete: public RequestManagerDelete
{
public:
ZoneDelete():
RequestManagerDelete("one.zone.delete", "Deletes a zone")
{
Nebula& nd = Nebula::instance();
pool = nd.get_zonepool();
auth_object = PoolObjectSQL::ZONE;
auth_op = AuthRequest::ADMIN;
};
ZoneDelete();
~ZoneDelete(){};
~ZoneDelete() = default;
protected:
@ -384,16 +289,9 @@ protected:
class SecurityGroupDelete : public RequestManagerDelete
{
public:
SecurityGroupDelete():
RequestManagerDelete("one.secgroup.delete",
"Deletes a security group")
{
Nebula& nd = Nebula::instance();
pool = nd.get_secgrouppool();
auth_object = PoolObjectSQL::SECGROUP;
};
SecurityGroupDelete();
~SecurityGroupDelete(){};
~SecurityGroupDelete() = default;
protected:
@ -406,16 +304,9 @@ protected:
class VdcDelete: public RequestManagerDelete
{
public:
VdcDelete():
RequestManagerDelete("one.vdc.delete", "Deletes a VDC")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vdcpool();
auth_object = PoolObjectSQL::VDC;
auth_op = AuthRequest::ADMIN;
};
VdcDelete();
~VdcDelete(){};
~VdcDelete() = default;
};
/* ------------------------------------------------------------------------- */
@ -424,16 +315,9 @@ public:
class VirtualRouterDelete : public RequestManagerDelete
{
public:
VirtualRouterDelete():
RequestManagerDelete("one.vrouter.delete",
"Deletes a virtual router")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vrouterpool();
auth_object = PoolObjectSQL::VROUTER;
};
VirtualRouterDelete();
~VirtualRouterDelete(){};
~VirtualRouterDelete() = default;
protected:
int drop(PoolObjectSQL * obj, bool resive, RequestAttributes& att) override;
@ -445,16 +329,9 @@ protected:
class MarketPlaceDelete : public RequestManagerDelete
{
public:
MarketPlaceDelete():
RequestManagerDelete("one.market.delete",
"Deletes a marketplace")
{
Nebula& nd = Nebula::instance();
pool = nd.get_marketpool();
auth_object = PoolObjectSQL::MARKETPLACE;
};
MarketPlaceDelete();
~MarketPlaceDelete(){};
~MarketPlaceDelete() = default;
protected:
@ -467,16 +344,9 @@ protected:
class MarketPlaceAppDelete : public RequestManagerDelete
{
public:
MarketPlaceAppDelete():
RequestManagerDelete("one.marketapp.delete",
"Deletes a marketplace app")
{
Nebula& nd = Nebula::instance();
pool = nd.get_apppool();
auth_object = PoolObjectSQL::MARKETPLACEAPP;
};
MarketPlaceAppDelete();
~MarketPlaceAppDelete(){};
~MarketPlaceAppDelete() = default;
protected:
@ -489,16 +359,9 @@ protected:
class VMGroupDelete : public RequestManagerDelete
{
public:
VMGroupDelete():
RequestManagerDelete("one.vmgroup.delete",
"Deletes a vm group")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vmgrouppool();
auth_object = PoolObjectSQL::VMGROUP;
};
VMGroupDelete();
~VMGroupDelete(){};
~VMGroupDelete() = default;
};
/* ------------------------------------------------------------------------- */
@ -507,16 +370,9 @@ public:
class HookDelete : public RequestManagerDelete
{
public:
HookDelete():
RequestManagerDelete("one.hook.delete",
"Deletes a hook")
{
Nebula& nd = Nebula::instance();
pool = nd.get_hkpool();
auth_object = PoolObjectSQL::HOOK;
};
HookDelete();
~HookDelete(){};
~HookDelete() = default;
};
#endif

5
include/RequestManagerHook.h
View File

@ -19,6 +19,7 @@
#include "Request.h"
#include "Nebula.h"
#include "HookPool.h"
using namespace std;
@ -40,7 +41,7 @@ protected:
auth_object = PoolObjectSQL::HOOK;
};
~RequestManagerHook(){};
~RequestManagerHook() = default;
/* -------------------------------------------------------------------- */
@ -60,7 +61,7 @@ public:
auth_op = AuthRequest::MANAGE;
};
~HookRetry(){};
~HookRetry() = default;
void request_execute(xmlrpc_c::paramList const& _paramList,
RequestAttributes& att);

1
include/RequestManagerHost.h
View File

@ -19,6 +19,7 @@
#include "Request.h"
#include "Nebula.h"
#include "HostPool.h"
using namespace std;

1
include/RequestManagerImage.h
View File

@ -19,6 +19,7 @@
#include "Request.h"
#include "Nebula.h"
#include "ImagePool.h"
using namespace std;

18
include/RequestManagerInfo.h
View File

@ -19,6 +19,24 @@
#include "Request.h"
#include "Nebula.h"
#include "ClusterPool.h"
#include "DatastorePool.h"
#include "DocumentPool.h"
#include "HookPool.h"
#include "HostPool.h"
#include "ImagePool.h"
#include "MarketPlacePool.h"
#include "MarketPlaceAppPool.h"
#include "SecurityGroupPool.h"
#include "VdcPool.h"
#include "VirtualMachinePool.h"
#include "VirtualNetworkPool.h"
#include "VirtualRouterPool.h"
#include "VMGroupPool.h"
#include "VMTemplatePool.h"
#include "VNTemplatePool.h"
#include "ZonePool.h"
using namespace std;

207
include/RequestManagerLock.h
View File

@ -18,7 +18,6 @@
#define REQUEST_MANAGER_LOCK_H_
#include "Request.h"
#include "Nebula.h"
using namespace std;
@ -36,7 +35,7 @@ protected:
auth_op = AuthRequest::MANAGE_NO_LCK;
};
~RequestManagerLock(){};
~RequestManagerLock() = default;
/* -------------------------------------------------------------------- */
@ -62,7 +61,7 @@ protected:
auth_op = AuthRequest::MANAGE_NO_LCK;
};
~RequestManagerUnlock(){};
~RequestManagerUnlock() = default;
/* -------------------------------------------------------------------- */
@ -81,16 +80,9 @@ protected:
class DocumentLock : public RequestManagerLock
{
public:
DocumentLock():
RequestManagerLock("one.document.lock",
"Tries to acquire the object's lock")
{
Nebula& nd = Nebula::instance();
pool = nd.get_docpool();
auth_object = PoolObjectSQL::DOCUMENT;
};
DocumentLock();
~DocumentLock(){};
~DocumentLock() = default;
};
/* ------------------------------------------------------------------------- */
@ -99,16 +91,9 @@ public:
class DocumentUnlock : public RequestManagerUnlock
{
public:
DocumentUnlock():
RequestManagerUnlock("one.document.unlock",
"Unlocks the object")
{
Nebula& nd = Nebula::instance();
pool = nd.get_docpool();
auth_object = PoolObjectSQL::DOCUMENT;
};
DocumentUnlock();
~DocumentUnlock(){};
~DocumentUnlock() = default;
};
/* -------------------------------------------------------------------------- */
@ -117,15 +102,9 @@ public:
class VirtualMachineLock: public RequestManagerLock
{
public:
VirtualMachineLock():
RequestManagerLock("one.vm.lock",
"Lock a VM"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VM;
pool = nd.get_vmpool();
};
VirtualMachineLock();
~VirtualMachineLock(){};
~VirtualMachineLock() = default;
};
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@ -133,15 +112,9 @@ public:
class VirtualMachineUnlock: public RequestManagerUnlock
{
public:
VirtualMachineUnlock():
RequestManagerUnlock("one.vm.unlock",
"Unlock a VM"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VM;
pool = nd.get_vmpool();
};
VirtualMachineUnlock();
~VirtualMachineUnlock(){};
~VirtualMachineUnlock() = default;
};
/* -------------------------------------------------------------------------- */
@ -150,15 +123,9 @@ public:
class VMTemplateLock: public RequestManagerLock
{
public:
VMTemplateLock():
RequestManagerLock("one.template.lock",
"Lock a Template"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::TEMPLATE;
pool = nd.get_tpool();
};
VMTemplateLock();
~VMTemplateLock(){};
~VMTemplateLock() = default;
};
/* -------------------------------------------------------------------------- */
@ -167,15 +134,9 @@ public:
class VMTemplateUnlock: public RequestManagerUnlock
{
public:
VMTemplateUnlock():
RequestManagerUnlock("one.template.unlock",
"Unlock a Template"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::TEMPLATE;
pool = nd.get_tpool();
};
VMTemplateUnlock();
~VMTemplateUnlock(){};
~VMTemplateUnlock() = default;
};
/* -------------------------------------------------------------------------- */
@ -184,15 +145,9 @@ public:
class VNTemplateLock: public RequestManagerLock
{
public:
VNTemplateLock():
RequestManagerLock("one.vntemplate.lock",
"Lock a VN Template"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VNTEMPLATE;
pool = nd.get_vntpool();
};
VNTemplateLock();
~VNTemplateLock(){};
~VNTemplateLock() = default;
};
/* -------------------------------------------------------------------------- */
@ -201,15 +156,9 @@ public:
class VNTemplateUnlock: public RequestManagerUnlock
{
public:
VNTemplateUnlock():
RequestManagerUnlock("one.vntemplate.unlock",
"Unlock a VN Template"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VNTEMPLATE;
pool = nd.get_vntpool();
};
VNTemplateUnlock();
~VNTemplateUnlock(){};
~VNTemplateUnlock() = default;
};
/* -------------------------------------------------------------------------- */
@ -218,15 +167,9 @@ public:
class VirtualNetworkLock: public RequestManagerLock
{
public:
VirtualNetworkLock():
RequestManagerLock("one.vn.lock",
"Lock a VNet"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::NET;
pool = nd.get_vnpool();
};
VirtualNetworkLock();
~VirtualNetworkLock(){};
~VirtualNetworkLock() = default;
};
/* -------------------------------------------------------------------------- */
@ -235,15 +178,9 @@ public:
class VirtualNetworkUnlock: public RequestManagerUnlock
{
public:
VirtualNetworkUnlock():
RequestManagerUnlock("one.vn.unlock",
"Unlock a VNet"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::NET;
pool = nd.get_vnpool();
};
VirtualNetworkUnlock();
~VirtualNetworkUnlock(){};
~VirtualNetworkUnlock() = default;
};
/* -------------------------------------------------------------------------- */
@ -252,15 +189,9 @@ public:
class ImageLock: public RequestManagerLock
{
public:
ImageLock():
RequestManagerLock("one.image.lock",
"Lock a Image"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::IMAGE;
pool = nd.get_ipool();
};
ImageLock();
~ImageLock(){};
~ImageLock() = default;
};
/* -------------------------------------------------------------------------- */
@ -269,15 +200,9 @@ public:
class ImageUnlock: public RequestManagerUnlock
{
public:
ImageUnlock():
RequestManagerUnlock("one.image.unlock",
"Unlock a Image"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::IMAGE;
pool = nd.get_ipool();
};
ImageUnlock();
~ImageUnlock(){};
~ImageUnlock() = default;
};
/* -------------------------------------------------------------------------- */
@ -286,15 +211,9 @@ public:
class MarketPlaceAppLock: public RequestManagerLock
{
public:
MarketPlaceAppLock():
RequestManagerLock("one.marketapp.lock",
"Lock a MarketPlaceApp"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::MARKETPLACEAPP;
pool = nd.get_apppool();
};
MarketPlaceAppLock();
~MarketPlaceAppLock(){};
~MarketPlaceAppLock() = default;
};
/* -------------------------------------------------------------------------- */
@ -303,15 +222,9 @@ public:
class MarketPlaceAppUnlock: public RequestManagerUnlock
{
public:
MarketPlaceAppUnlock():
RequestManagerUnlock("one.marketapp.unlock",
"Unlock a MarketPlaceApp"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::MARKETPLACEAPP;
pool = nd.get_apppool();
};
MarketPlaceAppUnlock();
~MarketPlaceAppUnlock(){};
~MarketPlaceAppUnlock() = default;
};
/* -------------------------------------------------------------------------- */
@ -320,15 +233,9 @@ public:
class VirtualRouterLock: public RequestManagerLock
{
public:
VirtualRouterLock():
RequestManagerLock("one.vrouter.lock",
"Lock a VirtualRouter"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VROUTER;
pool = nd.get_vrouterpool();
};
VirtualRouterLock();
~VirtualRouterLock(){};
~VirtualRouterLock() = default;
};
/* -------------------------------------------------------------------------- */
@ -337,15 +244,9 @@ public:
class VirtualRouterUnlock: public RequestManagerUnlock
{
public:
VirtualRouterUnlock():
RequestManagerUnlock("one.vrouter.unlock",
"Unlock a VirtualRouter"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VROUTER;
pool = nd.get_vrouterpool();
};
VirtualRouterUnlock();
~VirtualRouterUnlock(){};
~VirtualRouterUnlock() = default;
};
/* -------------------------------------------------------------------------- */
@ -354,15 +255,9 @@ public:
class VMGroupLock: public RequestManagerLock
{
public:
VMGroupLock():
RequestManagerLock("one.vmgroup.lock",
"Lock a VMGroup"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VMGROUP;
pool = nd.get_vmgrouppool();
};
VMGroupLock();
~VMGroupLock(){};
~VMGroupLock() = default;
};
/* -------------------------------------------------------------------------- */
@ -371,15 +266,9 @@ public:
class VMGroupUnlock: public RequestManagerUnlock
{
public:
VMGroupUnlock():
RequestManagerUnlock("one.vmgroup.unlock",
"Unlock a VMGroup"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VMGROUP;
pool = nd.get_vmgrouppool();
};
VMGroupUnlock();
~VMGroupUnlock(){};
~VMGroupUnlock() = default;
};
/* -------------------------------------------------------------------------- */
@ -388,15 +277,9 @@ public:
class HookLock: public RequestManagerLock
{
public:
HookLock():
RequestManagerLock("one.hook.lock",
"Lock a Hook"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::HOOK;
pool = nd.get_hkpool();
};
HookLock();
~HookLock(){};
~HookLock() = default;
};
/* -------------------------------------------------------------------------- */
@ -405,15 +288,9 @@ public:
class HookUnlock: public RequestManagerUnlock
{
public:
HookUnlock():
RequestManagerUnlock("one.hook.unlock",
"Unlock a Hook"){
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::HOOK;
pool = nd.get_hkpool();
};
HookUnlock();
~HookUnlock(){};
~HookUnlock() = default;
};
#endif

22
include/RequestManagerMarketPlaceApp.h
View File

@ -18,7 +18,6 @@
#define REQUEST_MANAGER_MARKETPLACEAPP_H
#include "Request.h"
#include "Nebula.h"
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
@ -27,17 +26,9 @@ class RequestManagerMarketPlaceApp: public Request
{
protected:
RequestManagerMarketPlaceApp(const std::string& method_name,
const std::string& help, const std::string& params) :
Request(method_name, params, help)
{
Nebula& nd = Nebula::instance();
pool = nd.get_apppool();
const std::string& help, const std::string& params);
auth_object = PoolObjectSQL::MARKETPLACEAPP;
auth_op = AuthRequest::MANAGE;
};
~RequestManagerMarketPlaceApp(){};
~RequestManagerMarketPlaceApp() = default;
/* --------------------------------------------------------------------- */
@ -51,10 +42,13 @@ protected:
class MarketPlaceAppEnable : public RequestManagerMarketPlaceApp
{
public:
MarketPlaceAppEnable(): RequestManagerMarketPlaceApp("one.marketapp.enable",
"Enables or disables a marketplace app", "A:sib"){};
MarketPlaceAppEnable()
: RequestManagerMarketPlaceApp("one.marketapp.enable",
"Enables or disables a marketplace app", "A:sib")
{
}
~MarketPlaceAppEnable(){};
~MarketPlaceAppEnable() = default;
void request_execute(xmlrpc_c::paramList const& _paramList,
RequestAttributes& att) override;

290
include/RequestManagerPoolInfoFilter.h
View File

@ -18,8 +18,6 @@
#define REQUEST_MANAGER_POOL_INFO_FILTER_H_
#include "Request.h"
#include "Nebula.h"
#include "AuthManager.h"
using namespace std;
@ -73,13 +71,9 @@ protected:
extended = false;
};
/* -------------------------------------------------------------------- */
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;
/* -------------------------------------------------------------------- */
void where_filter(RequestAttributes& att,
int filter_flag,
int start_id,
@ -91,8 +85,6 @@ protected:
bool disable_group_acl,
string& where_string);
/* -------------------------------------------------------------------- */
void dump(RequestAttributes& att,
int filter_flag,
int start_id,
@ -114,28 +106,11 @@ public:
/* -------------------------------------------------------------------- */
VirtualMachinePoolInfo():
RequestManagerPoolInfoFilter("one.vmpool.info",
"Returns the virtual machine instances pool",
"A:siiiis")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vmpool();
auth_object = PoolObjectSQL::VM;
};
VirtualMachinePoolInfo();
VirtualMachinePoolInfo(const string& method_name,
const string& help,
const string& signature)
:RequestManagerPoolInfoFilter(method_name, help, signature)
{
Nebula& nd = Nebula::instance();
pool = nd.get_vmpool();
auth_object = PoolObjectSQL::VM;
};
/* -------------------------------------------------------------------- */
const string& signature);
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;
@ -147,7 +122,6 @@ public:
class VirtualMachinePoolInfoExtended : public VirtualMachinePoolInfo
{
public:
VirtualMachinePoolInfoExtended():
VirtualMachinePoolInfo("one.vmpool.infoextended",
"Returns the virtual machine instances pool in extended format",
@ -164,18 +138,7 @@ public:
class VirtualMachinePoolAccounting : public RequestManagerPoolInfoFilter
{
public:
VirtualMachinePoolAccounting():
RequestManagerPoolInfoFilter("one.vmpool.accounting",
"Returns the virtual machine history records",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vmpool();
auth_object = PoolObjectSQL::VM;
};
/* -------------------------------------------------------------------- */
VirtualMachinePoolAccounting();
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;
@ -187,18 +150,7 @@ public:
class VirtualMachinePoolShowback : public RequestManagerPoolInfoFilter
{
public:
VirtualMachinePoolShowback():
RequestManagerPoolInfoFilter("one.vmpool.showback",
"Returns the virtual machine showback records",
"A:siiiii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vmpool();
auth_object = PoolObjectSQL::VM;
};
/* -------------------------------------------------------------------- */
VirtualMachinePoolShowback();
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;
@ -210,18 +162,7 @@ public:
class VirtualMachinePoolMonitoring : public RequestManagerPoolInfoFilter
{
public:
VirtualMachinePoolMonitoring():
RequestManagerPoolInfoFilter("one.vmpool.monitoring",
"Returns the virtual machine monitoring records",
"A:si")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vmpool();
auth_object = PoolObjectSQL::VM;
};
/* -------------------------------------------------------------------- */
VirtualMachinePoolMonitoring();
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;
@ -233,15 +174,7 @@ public:
class TemplatePoolInfo : public RequestManagerPoolInfoFilter
{
public:
TemplatePoolInfo():
RequestManagerPoolInfoFilter("one.templatepool.info",
"Returns the virtual machine template pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_tpool();
auth_object = PoolObjectSQL::TEMPLATE;
};
TemplatePoolInfo();
};
/* ------------------------------------------------------------------------- */
@ -250,15 +183,7 @@ public:
class VirtualNetworkPoolInfo: public RequestManagerPoolInfoFilter
{
public:
VirtualNetworkPoolInfo():
RequestManagerPoolInfoFilter("one.vnpool.info",
"Returns the virtual network pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vnpool();
auth_object = PoolObjectSQL::NET;
};
VirtualNetworkPoolInfo();
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;
@ -270,15 +195,7 @@ public:
class VirtualNetworkTemplatePoolInfo: public RequestManagerPoolInfoFilter
{
public:
VirtualNetworkTemplatePoolInfo():
RequestManagerPoolInfoFilter("one.vntemplatepool.info",
"Returns the virtual network template pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vntpool();
auth_object = PoolObjectSQL::VNTEMPLATE;
};
VirtualNetworkTemplatePoolInfo();
};
/* ------------------------------------------------------------------------- */
@ -287,15 +204,7 @@ public:
class ImagePoolInfo: public RequestManagerPoolInfoFilter
{
public:
ImagePoolInfo():
RequestManagerPoolInfoFilter("one.imagepool.info",
"Returns the image pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_ipool();
auth_object = PoolObjectSQL::IMAGE;
};
ImagePoolInfo();
};
/* ------------------------------------------------------------------------- */
@ -304,17 +213,7 @@ public:
class HostPoolInfo : public RequestManagerPoolInfoFilter
{
public:
HostPoolInfo():
RequestManagerPoolInfoFilter("one.hostpool.info",
"Returns the host pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_hpool();
auth_object = PoolObjectSQL::HOST;
};
/* -------------------------------------------------------------------- */
HostPoolInfo();
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;
@ -326,18 +225,7 @@ public:
class HostPoolMonitoring : public RequestManagerPoolInfoFilter
{
public:
HostPoolMonitoring():
RequestManagerPoolInfoFilter("one.hostpool.monitoring",
"Returns the host monitoring records",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_hpool();
auth_object = PoolObjectSQL::HOST;
};
/* -------------------------------------------------------------------- */
HostPoolMonitoring();
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;
@ -349,17 +237,7 @@ public:
class GroupPoolInfo: public RequestManagerPoolInfoFilter
{
public:
GroupPoolInfo():
RequestManagerPoolInfoFilter("one.grouppool.info",
"Returns the group pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_gpool();
auth_object = PoolObjectSQL::GROUP;
};
/* -------------------------------------------------------------------- */
GroupPoolInfo();
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;
@ -371,17 +249,7 @@ public:
class UserPoolInfo: public RequestManagerPoolInfoFilter
{
public:
UserPoolInfo():
RequestManagerPoolInfoFilter("one.userpool.info",
"Returns the user pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_upool();
auth_object = PoolObjectSQL::USER;
};
/* -------------------------------------------------------------------- */
UserPoolInfo();
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;
@ -393,17 +261,7 @@ public:
class DatastorePoolInfo: public RequestManagerPoolInfoFilter
{
public:
DatastorePoolInfo():
RequestManagerPoolInfoFilter("one.datastorepool.info",
"Returns the datastore pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_dspool();
auth_object = PoolObjectSQL::DATASTORE;
};
/* -------------------------------------------------------------------- */
DatastorePoolInfo();
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;
@ -415,17 +273,7 @@ public:
class ClusterPoolInfo: public RequestManagerPoolInfoFilter
{
public:
ClusterPoolInfo():
RequestManagerPoolInfoFilter("one.clusterpool.info",
"Returns the cluster pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_clpool();
auth_object = PoolObjectSQL::CLUSTER;
};
/* -------------------------------------------------------------------- */
ClusterPoolInfo();
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;
@ -437,17 +285,7 @@ public:
class DocumentPoolInfo : public RequestManagerPoolInfoFilter
{
public:
DocumentPoolInfo():
RequestManagerPoolInfoFilter("one.documentpool.info",
"Returns the generic document pool",
"A:siiii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_docpool();
auth_object = PoolObjectSQL::DOCUMENT;
};
/* -------------------------------------------------------------------- */
DocumentPoolInfo();
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;
@ -459,17 +297,7 @@ public:
class ZonePoolInfo : public RequestManagerPoolInfoFilter
{
public:
ZonePoolInfo():
RequestManagerPoolInfoFilter("one.zonepool.info",
"Returns the zone pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_zonepool();
auth_object = PoolObjectSQL::ZONE;
};
/* -------------------------------------------------------------------- */
ZonePoolInfo();
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;
@ -481,15 +309,7 @@ public:
class SecurityGroupPoolInfo : public RequestManagerPoolInfoFilter
{
public:
SecurityGroupPoolInfo():
RequestManagerPoolInfoFilter("one.secgrouppool.info",
"Returns the security group pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_secgrouppool();
auth_object = PoolObjectSQL::SECGROUP;
};
SecurityGroupPoolInfo();
};
/* ------------------------------------------------------------------------- */
@ -498,15 +318,7 @@ public:
class VdcPoolInfo : public RequestManagerPoolInfoFilter
{
public:
VdcPoolInfo():
RequestManagerPoolInfoFilter("one.vdcpool.info",
"Returns the VDC pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vdcpool();
auth_object = PoolObjectSQL::VDC;
};
VdcPoolInfo();
void request_execute(xmlrpc_c::paramList const& pl, RequestAttributes& att) override;
};
@ -517,15 +329,7 @@ public:
class VirtualRouterPoolInfo : public RequestManagerPoolInfoFilter
{
public:
VirtualRouterPoolInfo():
RequestManagerPoolInfoFilter("one.vrouterpool.info",
"Returns the virtual router pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vrouterpool();
auth_object = PoolObjectSQL::VROUTER;
};
VirtualRouterPoolInfo();
};
/* -------------------------------------------------------------------------- */
@ -534,15 +338,7 @@ public:
class MarketPlacePoolInfo : public RequestManagerPoolInfoFilter
{
public:
MarketPlacePoolInfo():
RequestManagerPoolInfoFilter("one.marketpool.info",
"Returns the marketplace pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_marketpool();
auth_object = PoolObjectSQL::MARKETPLACE;
};
MarketPlacePoolInfo();
void request_execute(xmlrpc_c::paramList const& pl, RequestAttributes& att) override;
};
@ -553,15 +349,7 @@ public:
class MarketPlaceAppPoolInfo : public RequestManagerPoolInfoFilter
{
public:
MarketPlaceAppPoolInfo():
RequestManagerPoolInfoFilter("one.marketapppool.info",
"Returns the market place pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_apppool();
auth_object = PoolObjectSQL::MARKETPLACEAPP;
};
MarketPlaceAppPoolInfo();
};
/* ------------------------------------------------------------------------- */
@ -570,15 +358,7 @@ public:
class VMGroupPoolInfo : public RequestManagerPoolInfoFilter
{
public:
VMGroupPoolInfo():
RequestManagerPoolInfoFilter("one.vmgrouppool.info",
"Returns the vm group pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vmgrouppool();
auth_object = PoolObjectSQL::VMGROUP;
};
VMGroupPoolInfo();
};
/* ------------------------------------------------------------------------- */
@ -587,17 +367,7 @@ public:
class HookPoolInfo : public RequestManagerPoolInfoFilter
{
public:
HookPoolInfo():
RequestManagerPoolInfoFilter("one.hookpool.info",
"Returns the hook pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_hkpool();
auth_object = PoolObjectSQL::HOOK;
};
~HookPoolInfo(){};
HookPoolInfo();
};
/* ------------------------------------------------------------------------- */
@ -606,17 +376,7 @@ public:
class HookLogInfo : public RequestManagerPoolInfoFilter
{
public:
HookLogInfo():
RequestManagerPoolInfoFilter("one.hooklog.info",
"Returns the hook pool log info",
"A:siiii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_hkpool();
auth_object = PoolObjectSQL::HOOK;
};
~HookLogInfo(){};
HookLogInfo();
void request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att) override;

53
include/RequestManagerRename.h
View File

@ -19,6 +19,24 @@
#include "Request.h"
#include "Nebula.h"
#include "ClusterPool.h"
#include "DatastorePool.h"
#include "DocumentPool.h"
#include "HookPool.h"
#include "HostPool.h"
#include "ImagePool.h"
#include "MarketPlacePool.h"
#include "MarketPlaceAppPool.h"
#include "SecurityGroupPool.h"
#include "VdcPool.h"
#include "VirtualMachinePool.h"
#include "VirtualNetworkPool.h"
#include "VirtualRouterPool.h"
#include "VMGroupPool.h"
#include "VMTemplatePool.h"
#include "VNTemplatePool.h"
#include "ZonePool.h"
using namespace std;
@ -39,7 +57,7 @@ protected:
auth_op = AuthRequest::MANAGE;
};
~RequestManagerRename(){};
~RequestManagerRename() = default;
/* -------------------------------------------------------------------- */
@ -164,7 +182,7 @@ public:
auth_object = PoolObjectSQL::TEMPLATE;
};
~TemplateRename(){};
~TemplateRename() = default;
int exist(const string& name, int uid) override
{
@ -187,7 +205,7 @@ public:
auth_object = PoolObjectSQL::VNTEMPLATE;
};
~VirtualNetworkTemplateRename(){};
~VirtualNetworkTemplateRename() = default;
int exist(const string& name, int uid) override
{
@ -210,7 +228,7 @@ public:
auth_object = PoolObjectSQL::NET;
};
~VirtualNetworkRename(){};
~VirtualNetworkRename() = default;
int exist(const string& name, int uid) override
{
@ -232,7 +250,7 @@ public:
auth_object = PoolObjectSQL::IMAGE;
};
~ImageRename(){};
~ImageRename() = default;
int exist(const string& name, int uid) override
{
@ -254,7 +272,7 @@ public:
auth_object = PoolObjectSQL::DOCUMENT;
};
~DocumentRename(){};
~DocumentRename() = default;
int exist(const string& name, int uid) override
{
@ -276,7 +294,7 @@ public:
auth_object = PoolObjectSQL::CLUSTER;
};
~ClusterRename(){};
~ClusterRename() = default;
int exist(const string& name, int uid) override
{
@ -300,7 +318,7 @@ public:
auth_object = PoolObjectSQL::DATASTORE;
};
~DatastoreRename(){};
~DatastoreRename() = default;
int exist(const string& name, int uid) override
{
@ -325,8 +343,7 @@ public:
auth_op = AuthRequest::ADMIN;
};
~HostRename(){};
~HostRename() = default;
int exist(const string& name, int uid) override
{
@ -350,7 +367,7 @@ public:
auth_object = PoolObjectSQL::ZONE;
};
~ZoneRename(){};
~ZoneRename() = default;
int exist(const string& name, int uid) override
{
@ -372,7 +389,7 @@ public:
auth_object = PoolObjectSQL::SECGROUP;
};
~SecurityGroupRename(){};
~SecurityGroupRename() = default;
int exist(const string& name, int uid) override
{
@ -394,7 +411,7 @@ public:
auth_object = PoolObjectSQL::VDC;
};
~VdcRename(){};
~VdcRename() = default;
int exist(const string& name, int uid) override
{
@ -416,7 +433,7 @@ public:
auth_object = PoolObjectSQL::VROUTER;
};
~VirtualRouterRename(){};
~VirtualRouterRename() = default;
int exist(const string& name, int uid) override
{
@ -438,7 +455,7 @@ public:
auth_object = PoolObjectSQL::MARKETPLACE;
};
~MarketPlaceRename(){};
~MarketPlaceRename() = default;
int exist(const string& name, int uid) override
{
@ -462,7 +479,7 @@ public:
auth_object = PoolObjectSQL::MARKETPLACEAPP;
};
~MarketPlaceAppRename(){};
~MarketPlaceAppRename() = default;
int exist(const string& name, int uid) override
{
@ -484,7 +501,7 @@ public:
auth_object = PoolObjectSQL::VMGROUP;
};
~VMGroupRename(){};
~VMGroupRename() = default;
int exist(const string& name, int uid) override
{
@ -506,7 +523,7 @@ public:
auth_object = PoolObjectSQL::HOOK;
};
~HookRename(){};
~HookRename() = default;
int exist(const string& name, int uid)
{

13
include/RequestManagerSecurityGroup.h
View File

@ -18,22 +18,13 @@
#define REQUEST_MANAGER_SECURITY_GROUP_H_
#include "Request.h"
#include "Nebula.h"
class SecurityGroupCommit : public Request
{
public:
SecurityGroupCommit() : Request("one.secgroup.commit", "A:sib",
"Commit security group changes to VMs")
{
Nebula& nd = Nebula::instance();
pool = nd.get_secgrouppool();
SecurityGroupCommit();
auth_object = PoolObjectSQL::SECGROUP;
auth_op = AuthRequest::MANAGE;
};
~SecurityGroupCommit(){};
~SecurityGroupCommit() = default;
void request_execute(xmlrpc_c::paramList const& pl, RequestAttributes& att) override;
};

18
include/RequestManagerUpdateTemplate.h
View File

@ -20,6 +20,24 @@
#include "Request.h"
#include "Nebula.h"
#include "ClusterPool.h"
#include "DatastorePool.h"
#include "DocumentPool.h"
#include "HookPool.h"
#include "HostPool.h"
#include "ImagePool.h"
#include "MarketPlacePool.h"
#include "MarketPlaceAppPool.h"
#include "SecurityGroupPool.h"
#include "VdcPool.h"
#include "VirtualMachinePool.h"
#include "VirtualNetworkPool.h"
#include "VirtualRouterPool.h"
#include "VMGroupPool.h"
#include "VMTemplatePool.h"
#include "VNTemplatePool.h"
#include "ZonePool.h"
using namespace std;
/* ------------------------------------------------------------------------- */

1
include/RequestManagerVMTemplate.h
View File

@ -19,6 +19,7 @@
#include "Request.h"
#include "Nebula.h"
#include "VMTemplatePool.h"
using namespace std;

16
include/RequestManagerVNTemplate.h
View File

@ -18,7 +18,6 @@
#define REQUEST_MANAGER_VN_TEMPLATE_H
#include "Request.h"
#include "Nebula.h"
using namespace std;
@ -31,18 +30,9 @@ class RequestManagerVNTemplate: public Request
protected:
RequestManagerVNTemplate(const string& method_name,
const string& help,
const string& params)
:Request(method_name,params,help)
{
Nebula& nd = Nebula::instance();
pool = nd.get_vntpool();
const string& params);
auth_object = PoolObjectSQL::VNTEMPLATE;
};
~RequestManagerVNTemplate(){};
/* -------------------------------------------------------------------- */
~RequestManagerVNTemplate() = default;
virtual void request_execute(xmlrpc_c::paramList const& _paramList,
RequestAttributes& att) = 0;
@ -61,7 +51,7 @@ public:
auth_op = AuthRequest::USE;
};
~VNTemplateInstantiate(){};
~VNTemplateInstantiate() = default;
/**
* Instantiates the VN Template, checking permissions, quotas, etc

25
include/RequestManagerVdc.h
View File

@ -19,6 +19,11 @@
#include "Request.h"
#include "Nebula.h"
#include "ClusterPool.h"
#include "HostPool.h"
#include "VdcPool.h"
#include "VirtualNetworkPool.h"
#include "ZonePool.h"
using namespace std;
@ -67,7 +72,7 @@ public:
VdcAddGroup():VdcEditGroup("one.vdc.addgroup", "Adds a group to the VDC",
"A:sii", true){};
~VdcAddGroup(){};
~VdcAddGroup() = default;
int edit_group(
Vdc* vdc, int group_id, string& error_msg) override;
@ -82,7 +87,7 @@ public:
VdcDelGroup():VdcEditGroup("one.vdc.delgroup","Deletes a group from the VDC",
"A:sii", false){};
~VdcDelGroup(){};
~VdcDelGroup() = default;
int edit_group(
Vdc* vdc, int group_id, string& error_msg) override;
@ -141,7 +146,7 @@ public:
"Adds a cluster to the VDC", "A:siii", true,
Nebula::instance().get_clpool(), PoolObjectSQL::CLUSTER){};
~VdcAddCluster(){};
~VdcAddCluster() = default;
int edit_resource(Vdc* vdc, int zone_id, int res_id, string& error_msg) override;
};
@ -156,7 +161,7 @@ public:
"Deletes a cluster from the VDC", "A:siii", false,
Nebula::instance().get_clpool(), PoolObjectSQL::CLUSTER){};
~VdcDelCluster(){};
~VdcDelCluster() = default;
int edit_resource(Vdc* vdc, int zone_id, int res_id, string& error_msg) override;
};
@ -170,7 +175,7 @@ public:
VdcAddHost(): VdcEditResource("one.vdc.addhost", "Adds a host to the VDC",
"A:siii", true, Nebula::instance().get_hpool(), PoolObjectSQL::HOST){};
~VdcAddHost(){};
~VdcAddHost() = default;
int edit_resource(Vdc* vdc, int zone_id, int res_id, string& error_msg) override;
};
@ -184,7 +189,7 @@ public:
VdcDelHost():VdcEditResource("one.vdc.delhost", "Deletes a host from the VDC",
"A:siii", false, Nebula::instance().get_hpool(), PoolObjectSQL::HOST){};
~VdcDelHost(){};
~VdcDelHost() = default;
int edit_resource(Vdc* vdc, int zone_id, int res_id, string& error_msg) override;
};
@ -199,7 +204,7 @@ public:
"Adds a datastore to the VDC", "A:siii", true,
Nebula::instance().get_dspool(), PoolObjectSQL::DATASTORE){};
~VdcAddDatastore(){};
~VdcAddDatastore() = default;
int edit_resource(Vdc* vdc, int zone_id, int res_id, string& error_msg) override;
};
@ -214,7 +219,7 @@ public:
"Deletes a datastore from the VDC", "A:siii", false,
Nebula::instance().get_dspool(), PoolObjectSQL::DATASTORE){};
~VdcDelDatastore(){};
~VdcDelDatastore() = default;
int edit_resource(Vdc* vdc, int zone_id, int res_id, string& error_msg) override;
};
@ -229,7 +234,7 @@ public:
"Adds a virtual network to the VDC", "A:siii", true,
Nebula::instance().get_vnpool(), PoolObjectSQL::NET){};
~VdcAddVNet(){};
~VdcAddVNet() = default;
int edit_resource(Vdc* vdc, int zone_id, int res_id, string& error_msg) override;
};
@ -244,7 +249,7 @@ public:
"Deletes a virtual network from the VDC", "A:siii", false,
Nebula::instance().get_vnpool(), PoolObjectSQL::NET){};
~VdcDelVNet(){};
~VdcDelVNet() = default;
int edit_resource(Vdc* vdc, int zone_id, int res_id, string& error_msg) override;
};

3
include/RequestManagerVirtualMachine.h
View File

@ -19,6 +19,7 @@
#include "Request.h"
#include "Nebula.h"
#include "VirtualMachinePool.h"
using namespace std;
@ -535,7 +536,7 @@ public:
VirtualMachineDiskSnapshotRename():
RequestManagerVirtualMachine("one.vm.disksnapshotrename",
"Rename a disk snapshot",
"A:siiis")
"A:siiis")
{
vm_action = VMActions::DISK_SNAPSHOT_RENAME_ACTION;
}

1
include/RequestManagerVirtualNetwork.h
View File

@ -19,6 +19,7 @@
#include "Request.h"
#include "Nebula.h"
#include "VirtualNetworkPool.h"
using namespace std;

23
include/RequestManagerVirtualRouter.h
View File

@ -18,7 +18,6 @@
#define REQUEST_MANAGER_VIRTUAL_ROUTER_H
#include "Request.h"
#include "Nebula.h"
using namespace std;
@ -30,20 +29,10 @@ class RequestManagerVirtualRouter: public Request
{
protected:
RequestManagerVirtualRouter(const string& method_name,
const string& help,
const string& params)
:Request(method_name,params,help)
{
Nebula& nd = Nebula::instance();
pool = nd.get_vrouterpool();
const string& help,
const string& params);
auth_object = PoolObjectSQL::VROUTER;
auth_op = AuthRequest::MANAGE;
};
~RequestManagerVirtualRouter(){};
/* -------------------------------------------------------------------- */
~RequestManagerVirtualRouter() = default;
virtual void request_execute(xmlrpc_c::paramList const& _paramList,
RequestAttributes& att) = 0;
@ -59,7 +48,7 @@ public:
"one.vrouter.instantiate", "Instantiates a new virtual machine "
"associated to a virtual router", "A:siiisbs") { }
~VirtualRouterInstantiate(){};
~VirtualRouterInstantiate() = default;
void request_execute(xmlrpc_c::paramList const& _paramList,
RequestAttributes& att) override;
@ -76,7 +65,7 @@ public:
"Attaches a new NIC to the virtual router, and its virtual machines",
"A:sis") { }
~VirtualRouterAttachNic(){};
~VirtualRouterAttachNic() = default;
void request_execute(xmlrpc_c::paramList const& _paramList,
RequestAttributes& att) override;
@ -92,7 +81,7 @@ public:
VirtualRouterDetachNic():RequestManagerVirtualRouter("one.vrouter.detachnic",
"Detaches a NIC from a virtual router, and its virtual machines","A:sii") { }
~VirtualRouterDetachNic(){};
~VirtualRouterDetachNic() = default;
void request_execute(xmlrpc_c::paramList const& _paramList,
RequestAttributes& att) override;

1
include/RequestManagerZone.h
View File

@ -19,6 +19,7 @@
#include "Request.h"
#include "Nebula.h"
#include "ZonePool.h"
using namespace std;

2
include/SystemDB.h
View File

@ -17,10 +17,10 @@
#ifndef SYSTEM_DB_H_
#define SYSTEM_DB_H_
#include "SqlDB.h"
#include "Callbackable.h"
class Nebula;
class SqlDB;
/**
* This class represents the OpenNebula core system data tables:

1
include/Template.h
View File

@ -17,7 +17,6 @@
#ifndef TEMPLATE_H_
#define TEMPLATE_H_
#include <iostream>
#include <map>
#include <set>
#include <vector>

2
include/User.h
View File

@ -17,7 +17,7 @@
#ifndef USER_H_
#define USER_H_
#include "PoolSQL.h"
#include "PoolObjectSQL.h"
#include "UserTemplate.h"
#include "ObjectCollection.h"
#include "QuotasSQL.h"

2
include/VNTemplatePool.h
View File

@ -14,7 +14,7 @@
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#ifndef VNetTEMPLATE_POOL_H_
#ifndef VNTEMPLATE_POOL_H_
#define VNTEMPLATE_POOL_H_
#include "PoolSQL.h"

22
include/VirtualMachine.h
View File

@ -21,13 +21,10 @@
#include "VirtualMachineDisk.h"
#include "VirtualMachineNic.h"
#include "VirtualMachineMonitorInfo.h"
#include "PoolSQL.h"
#include "PoolObjectSQL.h"
#include "History.h"
#include "Image.h"
#include "Log.h"
#include "NebulaLog.h"
#include "NebulaUtil.h"
#include "Quotas.h"
#include <time.h>
#include <set>
@ -1447,22 +1444,7 @@ public:
/**
* Deletes the alias of the NIC that was in the process of being attached/detached
*/
void delete_attach_alias(VirtualMachineNic *nic)
{
std::set<int> a_ids;
one_util::split_unique(nic->vector_value("ALIAS_IDS"), ',', a_ids);
for (std::set<int>::iterator it = a_ids.begin(); it != a_ids.end(); it++)
{
VirtualMachineNic * nic_a = nics.delete_nic(*it);
if ( nic_a != 0)
{
obj_template->remove(nic_a->vector_attribute());
}
}
}
void delete_attach_alias(VirtualMachineNic *nic);
// ------------------------------------------------------------------------
// Disk Snapshot related functions

2
include/VirtualMachineMonitorInfo.h
View File

@ -19,7 +19,7 @@
#include "Template.h"
#include <string.h>
#include <string>
using namespace std;

2
include/VirtualMachineTemplate.h
View File

@ -19,7 +19,7 @@
#include "Template.h"
#include <string.h>
#include <string>
using namespace std;

1
src/acl/AclManager.cc
View File

@ -18,6 +18,7 @@
#include "AclManager.h"
#include "PoolObjectAuth.h"
#include "SqlDB.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */

1
src/authm/AuthManager.cc
View File

@ -16,6 +16,7 @@
#include "AuthManager.h"
#include "AuthRequest.h"
#include "AclManager.h"
#include "NebulaUtil.h"
#include "PoolObjectAuth.h"
#include "Nebula.h"

7
src/client/Client.cc
View File

@ -15,16 +15,13 @@
/* -------------------------------------------------------------------------- */
#include "Client.h"
#include "NebulaLog.h"
#include <fstream>
#include <pwd.h>
#include <stdlib.h>
#include <stdexcept>
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <set>
#include <sstream>
#include <unistd.h>

8
src/cluster/Cluster.cc
View File

@ -14,16 +14,12 @@
/* limitations under the License. */
/* ------------------------------------------------------------------------ */
#include <limits.h>
#include <string.h>
#include <iostream>
#include <sstream>
#include "Cluster.h"
#include "GroupPool.h"
#include "Nebula.h"
#include <sstream>
const char * Cluster::table = "cluster_pool";
const char * Cluster::db_names =

2
src/datastore/Datastore.cc
View File

@ -15,9 +15,11 @@
/* ------------------------------------------------------------------------ */
#include "Datastore.h"
#include "DatastorePool.h"
#include "GroupPool.h"
#include "NebulaLog.h"
#include "Nebula.h"
#include "VirtualMachineDisk.h"
const char * Datastore::table = "datastore_pool";

2
src/datastore/DatastorePool.cc
View File

@ -18,6 +18,8 @@
#include "Nebula.h"
#include "NebulaLog.h"
#include "DatastoreTemplate.h"
#include "ClusterPool.h"
#include "ImageManager.h"
#include <stdexcept>

9
src/group/Group.cc
View File

@ -14,14 +14,11 @@
/* limitations under the License. */
/* ------------------------------------------------------------------------ */
#include <limits.h>
#include <string.h>
#include <iostream>
#include <sstream>
#include "Group.h"
#include "Nebula.h"
#include "AclManager.h"
#include <sstream>
const char * Group::table = "group_pool";

1
src/hm/Hook.cc
View File

@ -16,6 +16,7 @@
#include "Hook.h"
#include "Nebula.h"
#include "HookAPI.h"
#include "HookImplementation.h"
#include "HookStateHost.h"
#include "HookStateVM.h"

11
src/host/Host.cc
View File

@ -14,14 +14,13 @@
/* limitations under the License. */
/* ------------------------------------------------------------------------ */
#include <limits.h>
#include <string.h>
#include <iostream>
#include <sstream>
#include "Host.h"
#include "Nebula.h"
#include "ClusterPool.h"
#include "InformationManager.h"
#include "VirtualMachinePool.h"
#include <sstream>
/* ************************************************************************ */
/* Host :: Constructor/Destructor */

1
src/host/HostPool.cc
View File

@ -24,6 +24,7 @@
#include "Nebula.h"
#include "HostPool.h"
#include "HookStateHost.h"
#include "HookManager.h"
#include "NebulaLog.h"
#include "GroupPool.h"
#include "ClusterPool.h"

2
src/im/InformationManager.cc
View File

@ -17,6 +17,8 @@
#include "InformationManager.h"
#include "Cluster.h"
#include "Nebula.h"
#include "HostPool.h"
#include "RaftManager.h"
#include <sys/types.h>
#include <sys/stat.h>

4
src/im/MonitorThread.cc
View File

@ -22,6 +22,10 @@
#include "Nebula.h"
#include "NebulaUtil.h"
#include "DatastorePool.h"
#include "HostPool.h"
#include "LifeCycleManager.h"
#include "VirtualMachineManager.h"
using namespace std;

8
src/im_mad/collectd/OpenNebulaDriver.cc
View File

@ -14,6 +14,9 @@
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#include "OpenNebulaDriver.h"
#include "ListenerThread.h"
#include <sstream>
#include <iostream>
@ -23,10 +26,7 @@
#include <arpa/inet.h>
#include <netinet/in.h>
#include <errno.h>
#include <string.h>
#include "OpenNebulaDriver.h"
#include "ListenerThread.h"
#include <cstring>
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */

13
src/image/Image.cc
View File

@ -14,14 +14,6 @@
/* limitations under the License. */
/* ------------------------------------------------------------------------ */
#include <limits.h>
#include <string.h>
#include <iostream>
#include <sstream>
#include <openssl/evp.h>
#include <iomanip>
#include "Image.h"
#include "ImagePool.h"
@ -31,6 +23,11 @@
#include "LifeCycleManager.h"
#include "Nebula.h"
#include <sstream>
#include <openssl/evp.h>
#include <iomanip>
#define TO_UPPER(S) transform(S.begin(),S.end(),S.begin(),(int(*)(int))toupper)
/* ************************************************************************ */

2
src/image/ImageManager.cc
View File

@ -17,6 +17,8 @@
#include "ImageManager.h"
#include "ImagePool.h"
#include "Nebula.h"
#include "DatastorePool.h"
#include "RaftManager.h"
const char * ImageManager::image_driver_name = "image_exe";

7
src/image/ImageManagerActions.cc
View File

@ -20,7 +20,8 @@
#include "SyncRequest.h"
#include "Template.h"
#include "Nebula.h"
#include "DatastorePool.h"
#include "VirtualMachinePool.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@ -844,7 +845,7 @@ int ImageManager::register_image(int iid,
oss << "Using source " << source
<< " from template for image " << img->get_name();
}
else if ( img->is_saving() || img->get_type() == Image::DATABLOCK
else if ( img->is_saving() || img->get_type() == Image::DATABLOCK
|| img->get_type() == Image::OS)
{
imd->mkfs(img->get_oid(), *drv_msg);
@ -929,7 +930,7 @@ int ImageManager::stat_image(Template* img_tmpl,
<< one_util::xml_escape(res)
<< "</PATH></IMAGE>";
break;
case Image::OS:
img_tmpl->get("SOURCE", res);

4
src/image/ImageManagerDriver.cc
View File

@ -15,10 +15,14 @@
/* -------------------------------------------------------------------------- */
#include "ImageManagerDriver.h"
#include "ImageManager.h"
#include "ImagePool.h"
#include "NebulaLog.h"
#include "Quotas.h"
#include "VirtualMachinePool.h"
#include "VirtualMachineManagerDriver.h"
#include "TransferManager.h"
#include "Nebula.h"
#include <sstream>

3
src/image/ImagePool.cc
View File

@ -23,6 +23,9 @@
#include "AuthManager.h"
#include "Nebula.h"
#include "PoolObjectAuth.h"
#include "ImageManager.h"
#include "VirtualMachineDisk.h"
#include "DatastorePool.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */

1
src/log/Log.cc
View File

@ -16,7 +16,6 @@
#include "Log.h"
#include <string.h>
#include <stdlib.h>
#include <stdexcept>
#include <sstream>

14
src/mad/Mad.cc
View File

@ -14,20 +14,18 @@
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#include <iostream>
#include "Mad.h"
#include "NebulaLog.h"
#include "Nebula.h"
#include <sstream>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include "Mad.h"
#include "NebulaLog.h"
#include "Nebula.h"
#include <cstring>
#include <cerrno>

1
src/market/MarketPlaceManager.cc
View File

@ -20,6 +20,7 @@
#include "MarketPlaceManagerDriver.h"
#include "Nebula.h"
#include "RaftManager.h"
const char * MarketPlaceManager::market_driver_name = "market_exe";

4
src/market/MarketPlaceManagerActions.cc
View File

@ -19,8 +19,8 @@
#include "MarketPlaceAppPool.h"
#include "MarketPlaceManagerDriver.h"
#include "Image.h"
#include "Datastore.h"
#include "ImagePool.h"
#include "DatastorePool.h"
#include "ImageManager.h"
#include "NebulaLog.h"

8
src/market/MarketPlaceManagerDriver.cc
View File

@ -15,7 +15,11 @@
/* -------------------------------------------------------------------------- */
#include "MarketPlaceManagerDriver.h"
#include "Nebula.h"
#include "MarketPlace.h"
#include "MarketPlaceAppPool.h"
#include "MarketPlaceManager.h"
#include "MarketPlacePool.h"
#include "NebulaLog.h"
#include <sstream>
/* ************************************************************************** */
@ -169,7 +173,7 @@ static void monitor_action(
apps_mp.erase(app_id);
}
if (num > 0) // num = 0 when no APP information in monitor data
if (num > 0) // num = 0 when no APP information in monitor data
{
for (set<int>::iterator i = apps_mp.begin(); i != apps_mp.end(); ++i)
{

82
src/nebula/Nebula.cc
View File

@ -20,6 +20,43 @@
#include "SqliteDB.h"
#include "MySqlDB.h"
#include "Client.h"
#include "LogDB.h"
#include "SystemDB.h"
#include "ClusterPool.h"
#include "DatastorePool.h"
#include "DocumentPool.h"
#include "GroupPool.h"
#include "HookPool.h"
#include "HostPool.h"
#include "MarketPlacePool.h"
#include "MarketPlaceAppPool.h"
#include "SecurityGroupPool.h"
#include "UserPool.h"
#include "VdcPool.h"
#include "VirtualMachinePool.h"
#include "VirtualNetworkPool.h"
#include "VirtualRouterPool.h"
#include "VMGroupPool.h"
#include "VMTemplatePool.h"
#include "VNTemplatePool.h"
#include "ZonePool.h"
#include "AclManager.h"
#include "AuthManager.h"
#include "DispatchManager.h"
#include "FedReplicaManager.h"
#include "HookManager.h"
#include "HookLog.h"
#include "ImageManager.h"
#include "InformationManager.h"
#include "IPAMManager.h"
#include "LifeCycleManager.h"
#include "MarketPlaceManager.h"
#include "RaftManager.h"
#include "RequestManager.h"
#include "TransferManager.h"
#include "VirtualMachineManager.h"
#include <stdlib.h>
#include <stdexcept>
@ -41,6 +78,51 @@ using namespace std;
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
Nebula::~Nebula()
{
delete vmpool;
delete vnpool;
delete hpool;
delete upool;
delete ipool;
delete gpool;
delete tpool;
delete dspool;
delete clpool;
delete docpool;
delete zonepool;
delete secgrouppool;
delete vdcpool;
delete vrouterpool;
delete marketpool;
delete apppool;
delete vmgrouppool;
delete vmm;
delete lcm;
delete im;
delete tm;
delete dm;
delete rm;
delete hm;
delete hl;
delete authm;
delete aclm;
delete imagem;
delete marketm;
delete ipamm;
delete raftm;
delete frm;
delete nebula_configuration;
delete logdb;
delete fed_logdb;
delete system_db;
delete vntpool;
delete hkpool;
};
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void Nebula::start(bool bootstrap_only)
{
int rc;

1
src/nebula/NebulaTemplate.cc
View File

@ -21,6 +21,7 @@
#include <sys/stat.h>
#include <fstream>
#include <iostream>
using namespace std;

2
src/parsers/vm_var_syntax.h
View File

@ -57,6 +57,8 @@ extern int vm_var_debug;
#include "VirtualMachinePool.h"
#include "VirtualMachine.h"
#include "VirtualNetworkPool.h"
#include "ImagePool.h"
#include "Nebula.h"
#include "mem_collector.h"

1
src/pool/PoolObjectSQL.cc
View File

@ -19,6 +19,7 @@
#include "NebulaUtil.h"
#include "Nebula.h"
#include "Clusterable.h"
#include "ClusterableSingle.h"
const string PoolObjectSQL::INVALID_NAME_CHARS = "&|:\\\";/'#{}$<>";

14
src/pool/PoolSQL.cc
View File

@ -14,16 +14,14 @@
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#include <climits>
#include <sstream>
#include <iostream>
#include <stdexcept>
#include <algorithm>
#include "PoolSQL.h"
#include "RequestManagerPoolInfoFilter.h"
#include "AclManager.h"
#include "Nebula.h"
#include "ClusterPool.h"
#include <errno.h>
#include <sstream>
#include <algorithm>
/* ************************************************************************** */
/* PoolSQL constructor/destructor */
@ -313,7 +311,7 @@ int PoolSQL::dump(string& oss, const string& root_elem_name,
string_cb cb(1);
ostringstream oelem;
ostringstream oelem;
oelem << "<" << root_elem_name << ">";

2
src/raft/FedReplicaManager.cc
View File

@ -18,6 +18,8 @@
#include "ReplicaThread.h"
#include "Nebula.h"
#include "Client.h"
#include "ZonePool.h"
#include "LogDB.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */

6
src/raft/RaftManager.cc
View File

@ -14,12 +14,14 @@
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#include "Nebula.h"
#include "RaftManager.h"
#include "FedReplicaManager.h"
#include "ZoneServer.h"
#include "Client.h"
#include "ZonePool.h"
#include "LogDB.h"
#include "AclManager.h"
#include "Nebula.h"
#include <cstdlib>

9
src/raft/ReplicaThread.cc
View File

@ -14,14 +14,15 @@
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#include <errno.h>
#include <string>
#include "ReplicaThread.h"
#include "LogDB.h"
#include "RaftManager.h"
#include "ReplicaThread.h"
#include "Nebula.h"
#include "NebulaLog.h"
#include "FedReplicaManager.h"
#include <errno.h>
#include <string>
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------

3
src/rm/Request.cc
View File

@ -19,6 +19,9 @@
#include "Client.h"
#include "PoolObjectAuth.h"
#include "HookAPI.h"
#include "HookManager.h"
#include "RaftManager.h"
#include <xmlrpc-c/abyss.h>

17
src/rm/RequestManager.cc
View File

@ -64,7 +64,6 @@
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <cstring>
@ -1240,3 +1239,19 @@ void RequestManager::register_xml_methods()
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void RequestManager::finalize_action(const ActionRequest& ar)
{
NebulaLog::log("ReM",Log::INFO,"Stopping Request Manager...");
pthread_cancel(rm_xml_server_thread);
pthread_join(rm_xml_server_thread,0);
NebulaLog::log("ReM",Log::INFO,"XML-RPC server stopped.");
if (socket_fd != -1)
{
close(socket_fd);
}
}

1
src/rm/RequestManagerAcl.cc
View File

@ -15,6 +15,7 @@
/* -------------------------------------------------------------------------- */
#include "RequestManagerAcl.h"
#include "AclManager.h"
using namespace std;

3
src/rm/RequestManagerAllocate.cc
View File

@ -22,6 +22,9 @@
#include "MarketPlaceAppPool.h"
#include "VirtualMachineDisk.h"
#include "HookPool.h"
#include "FedReplicaManager.h"
#include "ImageManager.h"
#include "MarketPlaceManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */

2
src/rm/RequestManagerChown.cc
View File

@ -17,8 +17,8 @@
#include "RequestManagerChown.h"
#include "PoolObjectSQL.h"
#include "NebulaLog.h"
#include "Nebula.h"
#include "VirtualMachinePool.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */

1
src/rm/RequestManagerClone.cc
View File

@ -20,6 +20,7 @@
#include "RequestManagerVMTemplate.h"
#include "PoolObjectAuth.h"
#include "Nebula.h"
#include "VirtualMachineDisk.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */

1
src/rm/RequestManagerCluster.cc
View File

@ -15,6 +15,7 @@
/* -------------------------------------------------------------------------- */
#include "RequestManagerCluster.h"
#include "HostPool.h"
using namespace std;

981
src/rm/RequestManagerDelete.cc
View File

File diff suppressed because it is too large Load Diff

3
src/rm/RequestManagerHook.cc
View File

@ -14,9 +14,10 @@
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#include "RequestManagerHook.h"
#include "PoolObjectAuth.h"
#include "Nebula.h"
#include "RequestManagerHook.h"
#include "HookLog.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */

2
src/rm/RequestManagerImage.cc
View File

@ -15,6 +15,8 @@
/* -------------------------------------------------------------------------- */
#include "RequestManagerImage.h"
#include "ImageManager.h"
#include "DatastorePool.h"
using namespace std;

1
src/rm/RequestManagerInfo.cc
View File

@ -18,6 +18,7 @@
#include "RequestManagerPoolInfoFilter.h"
#include "VirtualMachineDisk.h"
#include "Nebula.h"
#include "VirtualRouterPool.h"
using namespace std;

251
src/rm/RequestManagerLock.cc
View File

@ -15,6 +15,17 @@
/* -------------------------------------------------------------------------- */
#include "RequestManagerLock.h"
#include "Nebula.h"
#include "DocumentPool.h"
#include "HookPool.h"
#include "ImagePool.h"
#include "MarketPlaceAppPool.h"
#include "VirtualMachinePool.h"
#include "VirtualNetworkPool.h"
#include "VirtualRouterPool.h"
#include "VMGroupPool.h"
#include "VMTemplatePool.h"
#include "VNTemplatePool.h"
using namespace std;
@ -124,3 +135,243 @@ void RequestManagerUnlock::request_execute(xmlrpc_c::paramList const& paramList,
return;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
DocumentLock::DocumentLock()
: RequestManagerLock("one.document.lock",
"Tries to acquire the object's lock")
{
Nebula& nd = Nebula::instance();
pool = nd.get_docpool();
auth_object = PoolObjectSQL::DOCUMENT;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
DocumentUnlock::DocumentUnlock():
RequestManagerUnlock("one.document.unlock",
"Unlocks the object")
{
Nebula& nd = Nebula::instance();
pool = nd.get_docpool();
auth_object = PoolObjectSQL::DOCUMENT;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VirtualMachineLock::VirtualMachineLock()
: RequestManagerLock("one.vm.lock",
"Lock a VM")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VM;
pool = nd.get_vmpool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VirtualMachineUnlock::VirtualMachineUnlock()
: RequestManagerUnlock("one.vm.unlock",
"Unlock a VM")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VM;
pool = nd.get_vmpool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VMTemplateLock::VMTemplateLock()
: RequestManagerLock("one.template.lock",
"Lock a Template")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::TEMPLATE;
pool = nd.get_tpool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VMTemplateUnlock::VMTemplateUnlock()
: RequestManagerUnlock("one.template.unlock",
"Unlock a Template")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::TEMPLATE;
pool = nd.get_tpool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VNTemplateLock::VNTemplateLock()
: RequestManagerLock("one.vntemplate.lock",
"Lock a VN Template")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VNTEMPLATE;
pool = nd.get_vntpool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VNTemplateUnlock::VNTemplateUnlock()
: RequestManagerUnlock("one.vntemplate.unlock",
"Unlock a VN Template")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VNTEMPLATE;
pool = nd.get_vntpool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VirtualNetworkLock::VirtualNetworkLock()
: RequestManagerLock("one.vn.lock",
"Lock a VNet")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::NET;
pool = nd.get_vnpool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VirtualNetworkUnlock::VirtualNetworkUnlock()
: RequestManagerUnlock("one.vn.unlock",
"Unlock a VNet")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::NET;
pool = nd.get_vnpool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
ImageLock::ImageLock()
: RequestManagerLock("one.image.lock",
"Lock a Image")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::IMAGE;
pool = nd.get_ipool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
ImageUnlock::ImageUnlock()
: RequestManagerUnlock("one.image.unlock",
"Unlock a Image")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::IMAGE;
pool = nd.get_ipool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
MarketPlaceAppLock::MarketPlaceAppLock()
: RequestManagerLock("one.marketapp.lock",
"Lock a MarketPlaceApp")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::MARKETPLACEAPP;
pool = nd.get_apppool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
MarketPlaceAppUnlock::MarketPlaceAppUnlock()
: RequestManagerUnlock("one.marketapp.unlock",
"Unlock a MarketPlaceApp")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::MARKETPLACEAPP;
pool = nd.get_apppool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VirtualRouterLock::VirtualRouterLock()
: RequestManagerLock("one.vrouter.lock",
"Lock a VirtualRouter")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VROUTER;
pool = nd.get_vrouterpool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VirtualRouterUnlock::VirtualRouterUnlock()
: RequestManagerUnlock("one.vrouter.unlock",
"Unlock a VirtualRouter")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VROUTER;
pool = nd.get_vrouterpool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VMGroupLock::VMGroupLock()
: RequestManagerLock("one.vmgroup.lock",
"Lock a VMGroup")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VMGROUP;
pool = nd.get_vmgrouppool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VMGroupUnlock::VMGroupUnlock()
: RequestManagerUnlock("one.vmgroup.unlock",
"Unlock a VMGroup")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::VMGROUP;
pool = nd.get_vmgrouppool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
HookLock::HookLock()
: RequestManagerLock("one.hook.lock",
"Lock a Hook")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::HOOK;
pool = nd.get_hkpool();
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
HookUnlock::HookUnlock()
: RequestManagerUnlock("one.hook.unlock",
"Unlock a Hook")
{
Nebula& nd = Nebula::instance();
auth_object = PoolObjectSQL::HOOK;
pool = nd.get_hkpool();
}

16
src/rm/RequestManagerMarketPlaceApp.cc
View File

@ -15,6 +15,22 @@
/* -------------------------------------------------------------------------- */
#include "RequestManagerMarketPlaceApp.h"
#include "Nebula.h"
#include "MarketPlaceAppPool.h"
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
RequestManagerMarketPlaceApp::RequestManagerMarketPlaceApp(const std::string& method_name,
const std::string& help, const std::string& params) :
Request(method_name, params, help)
{
Nebula& nd = Nebula::instance();
pool = nd.get_apppool();
auth_object = PoolObjectSQL::MARKETPLACEAPP;
auth_op = AuthRequest::MANAGE;
};
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */

955
src/rm/RequestManagerPoolInfoFilter.cc
View File

@ -15,6 +15,26 @@
/* -------------------------------------------------------------------------- */
#include "RequestManagerPoolInfoFilter.h"
#include "HookLog.h"
#include "Nebula.h"
#include "AuthManager.h"
#include "ClusterPool.h"
#include "DatastorePool.h"
#include "DocumentPool.h"
#include "HookPool.h"
#include "HostPool.h"
#include "ImagePool.h"
#include "MarketPlaceAppPool.h"
#include "MarketPlacePool.h"
#include "SecurityGroupPool.h"
#include "VdcPool.h"
#include "VirtualMachinePool.h"
#include "VirtualNetworkPool.h"
#include "VirtualRouterPool.h"
#include "VMGroupPool.h"
#include "VMTemplatePool.h"
#include "VNTemplatePool.h"
#include "ZonePool.h"
using namespace std;
@ -82,311 +102,6 @@ bool RequestManagerPoolInfoFilter::use_filter(RequestAttributes& att,
}
return all;
};
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void VirtualMachinePoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
int filter_flag = xmlrpc_c::value_int(paramList.getInt(1));
int start_id = xmlrpc_c::value_int(paramList.getInt(2));
int end_id = xmlrpc_c::value_int(paramList.getInt(3));
int state = xmlrpc_c::value_int(paramList.getInt(4));
std::string fts_query;
if (paramList.size() > 5)
{
fts_query = xmlrpc_c::value_string(paramList.getString(5));
if (!fts_query.empty() && !pool->is_fts_available())
{
att.resp_msg = "Full text search is not supported by the SQL backend";
failure_response(INTERNAL, att);
return;
}
}
ostringstream and_filter;
if (( state < VirtualMachinePoolInfo::ALL_VM ) ||
( state > VirtualMachine::CLONING_FAILURE ))
{
att.resp_msg = "Incorrect filter_flag, state";
failure_response(XML_RPC_API, att);
return;
}
switch (state)
{
case VirtualMachinePoolInfo::ALL_VM:
break;
case VirtualMachinePoolInfo::NOT_DONE:
and_filter << "state <> " << VirtualMachine::DONE;
break;
default:
and_filter << "state = " << state;
break;
}
if (!fts_query.empty())
{
char * _fts_query = pool->escape_str(fts_query);
if ( _fts_query == 0 )
{
att.resp_msg = "Error building search query";
failure_response(INTERNAL, att);
return;
}
if (!and_filter.str().empty())
{
and_filter << " AND ";
}
and_filter << "MATCH(search_token) AGAINST ('+\"";
one_util::escape_token(_fts_query, and_filter);
and_filter << "\"' in boolean mode)";
pool->free_str(_fts_query);
}
dump(att, filter_flag, start_id, end_id, and_filter.str(), "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void VirtualMachinePoolAccounting::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
int filter_flag = xmlrpc_c::value_int(paramList.getInt(1));
int time_start = xmlrpc_c::value_int(paramList.getInt(2));
int time_end = xmlrpc_c::value_int(paramList.getInt(3));
string oss;
string where;
int rc;
if ( filter_flag < GROUP )
{
att.resp_msg = "Incorrect filter_flag";
failure_response(XML_RPC_API, att);
return;
}
where_filter(att, filter_flag, -1, -1, "", "", false, false, false, where);
rc = (static_cast<VirtualMachinePool *>(pool))->dump_acct(oss,
where,
time_start,
time_end);
if ( rc != 0 )
{
att.resp_msg = "Internal error";
failure_response(INTERNAL, att);
return;
}
success_response(oss, att);
return;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void VirtualMachinePoolShowback::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
int filter_flag = xmlrpc_c::value_int(paramList.getInt(1));
int start_month = xmlrpc_c::value_int(paramList.getInt(2));
int start_year = xmlrpc_c::value_int(paramList.getInt(3));
int end_month = xmlrpc_c::value_int(paramList.getInt(4));
int end_year = xmlrpc_c::value_int(paramList.getInt(5));
string oss;
string where;
int rc;
if ( filter_flag < GROUP )
{
att.resp_msg = "Incorrect filter_flag";
failure_response(XML_RPC_API, att);
return;
}
where_filter(att, filter_flag, -1, -1, "", "", false, false, false, where);
rc = (static_cast<VirtualMachinePool *>(pool))->dump_showback(oss,
where,
start_month,
start_year,
end_month,
end_year);
if ( rc != 0 )
{
att.resp_msg = "Internal error";
failure_response(INTERNAL, att);
return;
}
success_response(oss, att);
return;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void VirtualMachinePoolMonitoring::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
int filter_flag = xmlrpc_c::value_int(paramList.getInt(1));
string oss;
string where;
int rc;
if ( filter_flag < GROUP )
{
att.resp_msg = "Incorrect filter_flag";
failure_response(XML_RPC_API, att);
return;
}
where_filter(att, filter_flag, -1, -1, "", "", false, false, false, where);
rc = (static_cast<VirtualMachinePool *>(pool))->dump_monitoring(oss, where);
if ( rc != 0 )
{
att.resp_msg = "Internal error";
failure_response(INTERNAL, att);
return;
}
success_response(oss, att);
return;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void HostPoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
dump(att, ALL, -1, -1, "", "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void HostPoolMonitoring::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
string oss;
string where;
int rc;
where_filter(att, ALL, -1, -1, "", "", false, false, false, where);
rc = (static_cast<HostPool *>(pool))->dump_monitoring(oss, where);
if ( rc != 0 )
{
att.resp_msg = "Internal error";
failure_response(INTERNAL, att);
return;
}
success_response(oss, att);
return;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void GroupPoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
dump(att, ALL, -1, -1, "", "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void UserPoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
dump(att, ALL, -1, -1, "", "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void DatastorePoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
dump(att, ALL, -1, -1, "", "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void ClusterPoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
dump(att, ALL, -1, -1, "", "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void DocumentPoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
int filter_flag = xmlrpc_c::value_int(paramList.getInt(1));
int start_id = xmlrpc_c::value_int(paramList.getInt(2));
int end_id = xmlrpc_c::value_int(paramList.getInt(3));
int type = xmlrpc_c::value_int(paramList.getInt(4));
ostringstream oss;
oss << "type = " << type;
dump(att, filter_flag, start_id, end_id, oss.str(), "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void ZonePoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
dump(att, ALL, -1, -1, "", "");
}
/* ------------------------------------------------------------------------- */
@ -544,6 +259,296 @@ void RequestManagerPoolInfoFilter::dump(
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VirtualMachinePoolInfo::VirtualMachinePoolInfo()
: RequestManagerPoolInfoFilter("one.vmpool.info",
"Returns the virtual machine instances pool",
"A:siiiis")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vmpool();
auth_object = PoolObjectSQL::VM;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VirtualMachinePoolInfo::VirtualMachinePoolInfo(const string& method_name,
const string& help,
const string& signature)
: RequestManagerPoolInfoFilter(method_name, help, signature)
{
Nebula& nd = Nebula::instance();
pool = nd.get_vmpool();
auth_object = PoolObjectSQL::VM;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void VirtualMachinePoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
int filter_flag = xmlrpc_c::value_int(paramList.getInt(1));
int start_id = xmlrpc_c::value_int(paramList.getInt(2));
int end_id = xmlrpc_c::value_int(paramList.getInt(3));
int state = xmlrpc_c::value_int(paramList.getInt(4));
std::string fts_query;
if (paramList.size() > 5)
{
fts_query = xmlrpc_c::value_string(paramList.getString(5));
if (!fts_query.empty() && !pool->is_fts_available())
{
att.resp_msg = "Full text search is not supported by the SQL backend";
failure_response(INTERNAL, att);
return;
}
}
ostringstream and_filter;
if (( state < VirtualMachinePoolInfo::ALL_VM ) ||
( state > VirtualMachine::CLONING_FAILURE ))
{
att.resp_msg = "Incorrect filter_flag, state";
failure_response(XML_RPC_API, att);
return;
}
switch (state)
{
case VirtualMachinePoolInfo::ALL_VM:
break;
case VirtualMachinePoolInfo::NOT_DONE:
and_filter << "state <> " << VirtualMachine::DONE;
break;
default:
and_filter << "state = " << state;
break;
}
if (!fts_query.empty())
{
char * _fts_query = pool->escape_str(fts_query);
if ( _fts_query == 0 )
{
att.resp_msg = "Error building search query";
failure_response(INTERNAL, att);
return;
}
if (!and_filter.str().empty())
{
and_filter << " AND ";
}
and_filter << "MATCH(search_token) AGAINST ('+\"";
one_util::escape_token(_fts_query, and_filter);
and_filter << "\"' in boolean mode)";
pool->free_str(_fts_query);
}
dump(att, filter_flag, start_id, end_id, and_filter.str(), "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VirtualMachinePoolAccounting::VirtualMachinePoolAccounting()
: RequestManagerPoolInfoFilter("one.vmpool.accounting",
"Returns the virtual machine history records",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vmpool();
auth_object = PoolObjectSQL::VM;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void VirtualMachinePoolAccounting::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
int filter_flag = xmlrpc_c::value_int(paramList.getInt(1));
int time_start = xmlrpc_c::value_int(paramList.getInt(2));
int time_end = xmlrpc_c::value_int(paramList.getInt(3));
string oss;
string where;
int rc;
if ( filter_flag < GROUP )
{
att.resp_msg = "Incorrect filter_flag";
failure_response(XML_RPC_API, att);
return;
}
where_filter(att, filter_flag, -1, -1, "", "", false, false, false, where);
rc = (static_cast<VirtualMachinePool *>(pool))->dump_acct(oss,
where,
time_start,
time_end);
if ( rc != 0 )
{
att.resp_msg = "Internal error";
failure_response(INTERNAL, att);
return;
}
success_response(oss, att);
return;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VirtualMachinePoolShowback::VirtualMachinePoolShowback()
: RequestManagerPoolInfoFilter("one.vmpool.showback",
"Returns the virtual machine showback records",
"A:siiiii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vmpool();
auth_object = PoolObjectSQL::VM;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void VirtualMachinePoolShowback::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
int filter_flag = xmlrpc_c::value_int(paramList.getInt(1));
int start_month = xmlrpc_c::value_int(paramList.getInt(2));
int start_year = xmlrpc_c::value_int(paramList.getInt(3));
int end_month = xmlrpc_c::value_int(paramList.getInt(4));
int end_year = xmlrpc_c::value_int(paramList.getInt(5));
string oss;
string where;
int rc;
if ( filter_flag < GROUP )
{
att.resp_msg = "Incorrect filter_flag";
failure_response(XML_RPC_API, att);
return;
}
where_filter(att, filter_flag, -1, -1, "", "", false, false, false, where);
rc = (static_cast<VirtualMachinePool *>(pool))->dump_showback(oss,
where,
start_month,
start_year,
end_month,
end_year);
if ( rc != 0 )
{
att.resp_msg = "Internal error";
failure_response(INTERNAL, att);
return;
}
success_response(oss, att);
return;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VirtualMachinePoolMonitoring::VirtualMachinePoolMonitoring()
: RequestManagerPoolInfoFilter("one.vmpool.monitoring",
"Returns the virtual machine monitoring records",
"A:si")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vmpool();
auth_object = PoolObjectSQL::VM;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void VirtualMachinePoolMonitoring::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
int filter_flag = xmlrpc_c::value_int(paramList.getInt(1));
string oss;
string where;
int rc;
if ( filter_flag < GROUP )
{
att.resp_msg = "Incorrect filter_flag";
failure_response(XML_RPC_API, att);
return;
}
where_filter(att, filter_flag, -1, -1, "", "", false, false, false, where);
rc = (static_cast<VirtualMachinePool *>(pool))->dump_monitoring(oss, where);
if ( rc != 0 )
{
att.resp_msg = "Internal error";
failure_response(INTERNAL, att);
return;
}
success_response(oss, att);
return;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
TemplatePoolInfo::TemplatePoolInfo()
: RequestManagerPoolInfoFilter("one.templatepool.info",
"Returns the virtual machine template pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_tpool();
auth_object = PoolObjectSQL::TEMPLATE;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VirtualNetworkPoolInfo::VirtualNetworkPoolInfo()
: RequestManagerPoolInfoFilter("one.vnpool.info",
"Returns the virtual network pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vnpool();
auth_object = PoolObjectSQL::NET;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void VirtualNetworkPoolInfo::request_execute(
xmlrpc_c::paramList const& paramList, RequestAttributes& att)
{
@ -613,6 +618,268 @@ void VirtualNetworkPoolInfo::request_execute(
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VirtualNetworkTemplatePoolInfo::VirtualNetworkTemplatePoolInfo()
: RequestManagerPoolInfoFilter("one.vntemplatepool.info",
"Returns the virtual network template pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vntpool();
auth_object = PoolObjectSQL::VNTEMPLATE;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
ImagePoolInfo::ImagePoolInfo()
: RequestManagerPoolInfoFilter("one.imagepool.info",
"Returns the image pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_ipool();
auth_object = PoolObjectSQL::IMAGE;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
HostPoolInfo::HostPoolInfo()
: RequestManagerPoolInfoFilter("one.hostpool.info",
"Returns the host pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_hpool();
auth_object = PoolObjectSQL::HOST;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void HostPoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
dump(att, ALL, -1, -1, "", "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
HostPoolMonitoring::HostPoolMonitoring()
: RequestManagerPoolInfoFilter("one.hostpool.monitoring",
"Returns the host monitoring records",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_hpool();
auth_object = PoolObjectSQL::HOST;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void HostPoolMonitoring::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
string oss;
string where;
int rc;
where_filter(att, ALL, -1, -1, "", "", false, false, false, where);
rc = (static_cast<HostPool *>(pool))->dump_monitoring(oss, where);
if ( rc != 0 )
{
att.resp_msg = "Internal error";
failure_response(INTERNAL, att);
return;
}
success_response(oss, att);
return;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
GroupPoolInfo::GroupPoolInfo()
: RequestManagerPoolInfoFilter("one.grouppool.info",
"Returns the group pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_gpool();
auth_object = PoolObjectSQL::GROUP;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void GroupPoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
dump(att, ALL, -1, -1, "", "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
UserPoolInfo::UserPoolInfo()
: RequestManagerPoolInfoFilter("one.userpool.info",
"Returns the user pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_upool();
auth_object = PoolObjectSQL::USER;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void UserPoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
dump(att, ALL, -1, -1, "", "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
DatastorePoolInfo::DatastorePoolInfo()
: RequestManagerPoolInfoFilter("one.datastorepool.info",
"Returns the datastore pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_dspool();
auth_object = PoolObjectSQL::DATASTORE;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void DatastorePoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
dump(att, ALL, -1, -1, "", "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
ClusterPoolInfo::ClusterPoolInfo()
: RequestManagerPoolInfoFilter("one.clusterpool.info",
"Returns the cluster pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_clpool();
auth_object = PoolObjectSQL::CLUSTER;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void ClusterPoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
dump(att, ALL, -1, -1, "", "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
DocumentPoolInfo::DocumentPoolInfo()
: RequestManagerPoolInfoFilter("one.documentpool.info",
"Returns the generic document pool",
"A:siiii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_docpool();
auth_object = PoolObjectSQL::DOCUMENT;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void DocumentPoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
int filter_flag = xmlrpc_c::value_int(paramList.getInt(1));
int start_id = xmlrpc_c::value_int(paramList.getInt(2));
int end_id = xmlrpc_c::value_int(paramList.getInt(3));
int type = xmlrpc_c::value_int(paramList.getInt(4));
ostringstream oss;
oss << "type = " << type;
dump(att, filter_flag, start_id, end_id, oss.str(), "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
ZonePoolInfo::ZonePoolInfo()
: RequestManagerPoolInfoFilter("one.zonepool.info",
"Returns the zone pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_zonepool();
auth_object = PoolObjectSQL::ZONE;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void ZonePoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
{
dump(att, ALL, -1, -1, "", "");
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
SecurityGroupPoolInfo::SecurityGroupPoolInfo()
: RequestManagerPoolInfoFilter("one.secgrouppool.info",
"Returns the security group pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_secgrouppool();
auth_object = PoolObjectSQL::SECGROUP;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VdcPoolInfo::VdcPoolInfo()
: RequestManagerPoolInfoFilter("one.vdcpool.info",
"Returns the VDC pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vdcpool();
auth_object = PoolObjectSQL::VDC;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void VdcPoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
@ -623,6 +890,32 @@ void VdcPoolInfo::request_execute(
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
VirtualRouterPoolInfo::VirtualRouterPoolInfo()
: RequestManagerPoolInfoFilter("one.vrouterpool.info",
"Returns the virtual router pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vrouterpool();
auth_object = PoolObjectSQL::VROUTER;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
MarketPlacePoolInfo::MarketPlacePoolInfo()
: RequestManagerPoolInfoFilter("one.marketpool.info",
"Returns the marketplace pool",
"A:s")
{
Nebula& nd = Nebula::instance();
pool = nd.get_marketpool();
auth_object = PoolObjectSQL::MARKETPLACE;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void MarketPlacePoolInfo::request_execute(
xmlrpc_c::paramList const& paramList,
RequestAttributes& att)
@ -633,6 +926,58 @@ void MarketPlacePoolInfo::request_execute(
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
MarketPlaceAppPoolInfo::MarketPlaceAppPoolInfo()
: RequestManagerPoolInfoFilter("one.marketapppool.info",
"Returns the market place pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_apppool();
auth_object = PoolObjectSQL::MARKETPLACEAPP;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
VMGroupPoolInfo::VMGroupPoolInfo():
RequestManagerPoolInfoFilter("one.vmgrouppool.info",
"Returns the vm group pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_vmgrouppool();
auth_object = PoolObjectSQL::VMGROUP;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
HookPoolInfo::HookPoolInfo()
: RequestManagerPoolInfoFilter("one.hookpool.info",
"Returns the hook pool",
"A:siii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_hkpool();
auth_object = PoolObjectSQL::HOOK;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
HookLogInfo::HookLogInfo()
: RequestManagerPoolInfoFilter("one.hooklog.info",
"Returns the hook pool log info",
"A:siiii")
{
Nebula& nd = Nebula::instance();
pool = nd.get_hkpool();
auth_object = PoolObjectSQL::HOOK;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void HookLogInfo::request_execute(xmlrpc_c::paramList const& _paramList,
RequestAttributes& att)
{

17
src/rm/RequestManagerSecurityGroup.cc
View File

@ -15,6 +15,23 @@
/* -------------------------------------------------------------------------- */
#include "RequestManagerSecurityGroup.h"
#include "LifeCycleManager.h"
#include "Nebula.h"
#include "SecurityGroupPool.h"
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
SecurityGroupCommit::SecurityGroupCommit()
: Request("one.secgroup.commit", "A:sib",
"Commit security group changes to VMs")
{
Nebula& nd = Nebula::instance();
pool = nd.get_secgrouppool();
auth_object = PoolObjectSQL::SECGROUP;
auth_op = AuthRequest::MANAGE;
}
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */

1
src/rm/RequestManagerSystem.cc
View File

@ -16,6 +16,7 @@
#include "RequestManagerSystem.h"
#include "Nebula.h"
#include "LogDB.h"
using namespace std;

2
src/rm/RequestManagerVMTemplate.cc
View File

@ -15,7 +15,9 @@
/* -------------------------------------------------------------------------- */
#include "RequestManagerVMTemplate.h"
#include "VirtualMachine.h"
#include "VirtualMachineDisk.h"
#include "VirtualMachinePool.h"
#include "PoolObjectAuth.h"
#include "Nebula.h"
#include "RequestManagerClone.h"

Some files were not shown because too many files have changed in this diff Show More