Merge branch 'feature-203'

This commit is contained in:
Ruben S. Montero committed 2010-07-15 16:39:13 +02:00
commit d548ee264d
97 files changed
+5489 -1186

No files matched your search

+2
View File
@@ -57,6 +57,7 @@ main_env.Append(LIBPATH=[
cwd+'/src/vnm',
cwd+'/src/hm',
cwd+'/src/um',
cwd+'/src/authm',
])
# Compile flags
@@ -161,6 +162,7 @@ build_scripts=[
'src/vnm/SConstruct',
'src/hm/SConstruct',
'src/um/SConstruct',
'src/authm/SConstruct',
]
for script in build_scripts:
+469
View File
@@ -0,0 +1,469 @@
/* -------------------------------------------------------------------------- */
/* Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); you may */
/* not use this file except in compliance with the License. You may obtain */
/* a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
/* See the License for the specific language governing permissions and */
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#ifndef AUTH_MANAGER_H_
#define AUTH_MANAGER_H_
#include <time.h>
#include "MadManager.h"
#include "ActionManager.h"
#include "AuthManagerDriver.h"
using namespace std;
//Forward definition of the AuthRequest
class AuthRequest;
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
extern "C" void * authm_action_loop(void *arg);
class AuthManager : public MadManager, public ActionListener
{
public:
AuthManager(
time_t timer,
time_t __time_out,
vector<const Attribute*>& _mads):
MadManager(_mads), timer_period(timer)
{
_time_out = __time_out;
am.addListener(this);
pthread_mutex_init(&mutex,0);
};
~AuthManager(){};
enum Actions
{
AUTHENTICATE,
AUTHORIZE,
FINALIZE
};
/**
* Triggers specific actions to the Auth Manager. This function
* wraps the ActionManager trigger function.
* @param action the Auth Manager action
* @param request an auth request
*/
void trigger(
Actions action,
AuthRequest * request);
/**
* This functions starts the associated listener thread, and creates a
* new thread for the AuthManager. This thread will wait in
* an action loop till it receives ACTION_FINALIZE.
* @return 0 on success.
*/
int start();
/**
* Loads Virtual Machine Manager Mads defined in configuration file
* @param uid of the user executing the driver. When uid is 0 the nebula
* identity will be used. Otherwise the Mad will be loaded through the
* sudo application.
*/
void load_mads(int uid);
/**
* Gets the thread identification.
* @return pthread_t for the manager thread (that in the action loop).
*/
pthread_t get_thread_id() const
{
return authm_thread;
};
/**
* Notify the result of an auth request
*/
void notify_request(int auth_id, bool result, const string& message);
/**
* Discards a pending request. Call this before freeing not notified or
* timeout requests.
*/
void discard_request(int auth_id)
{
lock();
auth_requests.erase(auth_id);
unlock();
}
/**
* Gets default timeout for Auth requests
*/
static time_t time_out()
{
return _time_out;
}
private:
/**
* Thread id for the Transfer Manager
*/
pthread_t authm_thread;
/**
* Action engine for the Manager
*/
ActionManager am;
/**
* List of pending requests
*/
map<int, AuthRequest *> auth_requests;
/**
* Mutex to access the auth_requests
*/
pthread_mutex_t mutex;
/**
* Default timeout for Auth requests
*/
static time_t _time_out;
/**
* Timer for the Manager (periocally triggers timer action)
*/
time_t timer_period;
/**
* Generic name for the Auth driver
*/
static const char * auth_driver_name;
/**
* Returns a pointer to a Auth Manager driver.
* @param name of an attribute of the driver (e.g. its type)
* @param value of the attribute
* @return the Auth driver with attribute name equal to value
* or 0 in not found
*/
const AuthManagerDriver * get(
const string& name,
const string& value)
{
return static_cast<const AuthManagerDriver *>
(MadManager::get(0,name,value));
};
/**
* Returns a pointer to a Auth Manager driver. The driver is
* searched by its name.
* @param name the name of the driver
* @return the TM driver owned by uid with attribute name equal to value
* or 0 in not found
*/
const AuthManagerDriver * get()
{
string name("NAME");
return static_cast<const AuthManagerDriver *>
(MadManager::get(0,name,auth_driver_name));
};
/**
* Function to execute the Manager action loop method within a new pthread
* (requires C linkage)
*/
friend void * authm_action_loop(void *arg);
/**
* The action function executed when an action is triggered.
* @param action the name of the action
* @param arg arguments for the action function
*/
void do_action(
const string & action,
void * arg);
/**
* This function authenticates a user
*/
void authenticate_action(AuthRequest * ar);
/**
* This function authorizes a user request
*/
void authorize_action(AuthRequest * ar);
/**
* This function is periodically executed to check time_outs on requests
*/
void timer_action();
/**
* Function to lock the pool
*/
void lock()
{
pthread_mutex_lock(&mutex);
};
/**
* Function to unlock the pool
*/
void unlock()
{
pthread_mutex_unlock(&mutex);
};
/**
* Add a new request to the Request map
* @param ar pointer to the AuthRequest
* @return the id for the request
*/
int add_request(AuthRequest *ar);
/**
* Gets request from the Request map
* @param id for the request
* @return pointer to the AuthRequest
*/
AuthRequest * get_request(int id);
};
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/**
* The AuthRequest class is used to pass an Authorization or Authentication
* request to the AuthManager. The result of the request will be stored
* in the result and message attributes of this class.
*/
class AuthRequest : public ActionListener
{
public:
AuthRequest(int _uid):
result(false),
timeout(false),
uid(_uid),
time_out(0),
self_authorize(true)
{
am.addListener(this);
};
~AuthRequest(){};
/**
* Authorization Request Type
*/
enum Operation
{
CREATE, /** Authorization to create an object (host, vm, net, image)*/
DELETE, /** Authorization to delete an object */
USE, /** Authorization to use an object */
MANAGE, /** Authorization to manage an object */
INFO /** Authorization to view an object */
};
/**
* OpenNebula objects to perform an Operation
*/
enum Object
{
VM,
HOST,
NET,
IMAGE,
USER,
CLUSTER
};
/**
* Sets the challenge to authenticate an user
* @param challenge a driver specific authentication challenge
*/
void add_authenticate(const string &_username,
const string &_password,
const string &_session)
{
username = _username;
password = _password;
session = _session;
}
/**
* Adds a new authorization item to this request
*
* OBJECT:OBJECT_ID:ACTION:OWNER:PUBLIC
*
* @param ob the object over which the operation will be performed
* @param ob_id the object unique id
* @param op the operation to be authorized
* @param owner id of user that owns the object. For creates MUST equals
uid, hosts owner is uid=0
* @param pub public attribute
*/
void add_auth(Object ob,
const string& ob_id,
Operation op,
int owner,
bool pub);
/**
* Adds a new authorization item to this requests
*/
void add_auth(Object ob,
int ob_id,
Operation op,
int owner,
bool pub)
{
ostringstream oss;
oss << ob_id;
add_auth(ob,oss.str(),op,owner,pub);
};
/**
* Gets the authorization requests in a single string
* @return a space separated list of auth requests.
*/
string get_auths()
{
ostringstream oss;
for (unsigned int i=0; i<auths.size(); i++)
{
oss << auths[i] << " ";
}
return oss.str();
};
/**
* Notify client that we have an answer for the request
*/
void notify()
{
am.trigger(ActionListener::ACTION_FINALIZE,0);
};
/**
* Wait for the AuthRequest to be completed
*/
void wait()
{
time_out = time(0) + AuthManager::time_out();
am.loop(0,0);
};
bool plain_authorize()
{
return ( uid == 0 || self_authorize );
}
bool plain_authenticate()
{
return (password == session);
}
/**
* The result of the request, true if authorized or authenticated
*/
bool result;
/**
* Error message for negative results
*/
string message;
/**
* Time out
*/
bool timeout;
/**
* Identification of this request
*/
int id;
private:
friend class AuthManager;
/**
* The ActionManager that will be notify when the request is ready.
*/
ActionManager am;
/**
* The user id for this request
*/
int uid;
/**
* Timeout for this request
*/
time_t time_out;
/**
* Username to authenticate the user
*/
string username;
/**
* User password to authenticate the user
*/
string password;
/**
* Authentication token as sent in the XML-RPC call (user:session)
*/
string session;
/**
* A list of authorization requests
*/
vector<string> auths;
/**
* Plain authorization for the request
*/
bool self_authorize;
/**
* No actions defined for the Auth request, just FINALIZE when done
*/
void do_action(const string &name, void *args){};
/**
* Base 64 encoding
* @param in the string to encoded
* @return a pointer to the encoded string (must be freed) or 0 in case of
* error
*/
static string * base64_encode(const string& in);
};
#endif /*AUTH_MANAGER_H*/
+98
View File
@@ -0,0 +1,98 @@
/* -------------------------------------------------------------------------- */
/* Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); you may */
/* not use this file except in compliance with the License. You may obtain */
/* a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
/* See the License for the specific language governing permissions and */
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#ifndef AUTH_MANAGER_DRIVER_H_
#define AUTH_MANAGER_DRIVER_H_
#include <map>
#include <string>
#include <sstream>
#include "Mad.h"
using namespace std;
//Forward definition of the AuthManager Class
class AuthManager;
/**
* AuthManagerDriver provides a base class to implement TM
* Drivers. This class implements the protocol and recover functions
* from the Mad interface.
*/
class AuthManagerDriver : public Mad
{
public:
AuthManagerDriver(
int userid,
const map<string,string>& attrs,
bool sudo,
AuthManager * _authm):
Mad(userid,attrs,sudo), authm(_authm){};
virtual ~AuthManagerDriver(){};
/**
* Implements the VM Manager driver protocol.
* @param message the string read from the driver
*/
void protocol(
string& message);
/**
* Re-starts the driver
*/
void recover();
private:
friend class AuthManager;
/**
* The AuthManager to notify results.
*/
AuthManager * authm;
/**
* Sends an authorization request to the MAD:
* "AUTHORIZE OPERATION_ID USER_ID REQUEST1 REQUEST2..."
* @param oid an id to identify the request.
* @param uid the user id.
* @param requests space separated list of requests in the form OP:OBJ:ID
*/
void authorize(int oid, int uid, const string& requests) const;
/**
* Sends an authorization request to the MAD:
* "AUTHENTICATE REQUEST_ID USER_ID USER_NAME PASSWORD XMLRPC_TOKEN"
* @param oid an id to identify the request.
* @param uid the user id.
* @param username
* @param password
* @param session token from the xml-rpc parameter
*/
void authenticate(int oid,
int uid,
const string& username,
const string& password,
const string& session) const;
};
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
#endif /*AUTH_MANAGER_DRIVER_H_*/
+46 -56
View File
@@ -55,7 +55,7 @@ public:
* Triggers specific actions to the Dispatch Manager. This function
* wraps the ActionManager trigger function.
* @param action the DM action
* @param vid VM unique id. This is the argument of the passed to the
* @param vid VM unique id. This is the argument of the passed to the
* invoked action.
*/
void trigger(
@@ -63,12 +63,12 @@ public:
int _vid);
/**
* This functions creates a new thread for the Dispatch Manager. This
* This functions creates a new thread for the Dispatch Manager. This
* thread will wait in an action loop till it receives ACTION_FINALIZE.
* @return 0 on success.
*/
int start();
/**
* Gets the thread identification.
* @return pthread_t for the manager thread (that in the action loop).
@@ -81,132 +81,122 @@ public:
//--------------------------------------------------------------------------
// DM Actions, the RM and the Scheduler will invoke this methods
//--------------------------------------------------------------------------
/**
* Allocates a new virtual machine
* @return 0 on success
*/
int allocate (
int uid,
const string& stemplate,
int * oid);
/**
* Deploys a VM. A new history record MUST be added before calling this
* function. Also the VM MUST have its mutex locked. If the function fails
* the calling funtion is responsible for recovering from the error.
* @param vm pointer to a VirtualMachine with its mutex locked.
* @return 0 on success
* @return 0 on success
*/
int deploy (
VirtualMachine * vm);
/**
* Migrates a VM. The following actions must be performed before calling
* this function:
* Migrates a VM. The following actions must be performed before calling
* this function:
* - Lock the VM mutex.
* - Update the History statistics of the current host.
* - Add a new History record with the new host.
* If the function fails the calling funtion is responsible for recovering
* - Add a new History record with the new host.
* If the function fails the calling funtion is responsible for recovering
* from the error.
* @param vm pointer to a VirtualMachine with its mutex locked.
* @return 0 on success
* @return 0 on success
*/
int migrate(
VirtualMachine * vm);
/**
* Migrates a VM. The following actions must be performed before calling
* this function:
* Migrates a VM. The following actions must be performed before calling
* this function:
* - Lock the VM mutex.
* - Update the History statistics of the current host.
* - Add a new History record with the new host.
* If the function fails the calling funtion is responsible for recovering
* - Add a new History record with the new host.
* If the function fails the calling funtion is responsible for recovering
* from the error.
* @param vm pointer to a VirtualMachine with its mutex locked.
* @return 0 on success
* @return 0 on success
*/
int live_migrate(
VirtualMachine * vm);
/**
* Shuts down a VM.
* @param vid VirtualMachine identification
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
int shutdown (
int vid);
/**
* Holds a VM.
* @param vid VirtualMachine identification
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
int hold(
int vid);
/**
* Releases a VM.
* @param vid VirtualMachine identification
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
int release(
int vid);
/**
* Stops a VM.
* @param vid VirtualMachine identification
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
int stop(
int vid);
/**
* Cancels a VM.
* @param vid VirtualMachine identification
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
int cancel(
int vid);
/**
* Suspends a VM.
* @param vid VirtualMachine identification
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
int suspend(
int vid);
/**
* Resumes a VM.
* @param vid VirtualMachine identification
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
int resume(
int vid);
/**
* Restart a previusly deployed VM.
* @param vid VirtualMachine identification
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
int restart(
int vid);
/**
* Ends a VM life cycle inside ONE.
* @param vid VirtualMachine identification
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
* @return 0 on success, -1 if the VM does not exits or -2 if the VM is
* in a wrong a state
*/
int finalize(
int vid);
@@ -232,7 +222,7 @@ private:
ActionManager am;
/**
* Function to execute the Manager action loop method within a new pthread
* Function to execute the Manager action loop method within a new pthread
* (requires C linkage)
*/
friend void * dm_action_loop(void *arg);
@@ -249,14 +239,14 @@ private:
//--------------------------------------------------------------------------
// DM Actions associated with a VM state transition
//--------------------------------------------------------------------------
void suspend_success_action(int vid);
void stop_success_action(int vid);
void done_action(int vid);
void failed_action(int vid);
void failed_action(int vid);
};
#endif /*DISPATCH_MANAGER_H*/
+16 -17
View File
@@ -31,20 +31,15 @@ class HookManager : public MadManager, public ActionListener
public:
HookManager(vector<const Attribute*>& _mads, VirtualMachinePool * _vmpool)
:MadManager(_mads),vmpool(_vmpool)
:MadManager(_mads),vmpool(_vmpool)
{
am.addListener(this);
};
~HookManager(){};
/**
* Generic name for the Hook driver
*/
static const char * hook_driver_name;
/**
* This functions starts the associated listener thread, and creates a
* This functions starts the associated listener thread, and creates a
* new thread for the Hook Manager. This thread will wait in
* an action loop till it receives ACTION_FINALIZE.
* @return 0 on success.
@@ -61,12 +56,12 @@ public:
};
/**
*
*
*/
void load_mads(int uid=0);
/**
*
*
*/
void finalize()
{
@@ -74,39 +69,43 @@ public:
};
/**
* Returns a pointer to a Information Manager MAD. The driver is
* Returns a pointer to a Information Manager MAD. The driver is
* searched by its name and owned by oneadmin with uid=0.
* @param name of the driver
* @return the Hook driver owned by uid 0, with attribute "NAME" equal to
* @return the Hook driver owned by uid 0, with attribute "NAME" equal to
* name or 0 in not found
*/
const HookManagerDriver * get()
{
string name("NAME");
string hook_name(hook_driver_name);
return static_cast<const HookManagerDriver *>
(MadManager::get(0,name,hook_driver_name));
};
private:
/**
* Generic name for the Hook driver
*/
static const char * hook_driver_name;
/**
* Pointer to the VirtualMachine Pool
*/
VirtualMachinePool * vmpool;
/**
* Thread id for the HookManager
*/
pthread_t hm_thread;
/**
* Action engine for the Manager
*/
ActionManager am;
/**
* Function to execute the Manager action loop method within a new pthread
* Function to execute the Manager action loop method within a new pthread
* (requires C linkage)
*/
friend void * hm_action_loop(void *arg);
+8 -8
View File
@@ -105,7 +105,7 @@ public:
* Returns true if the image is public
* @return true if the image is public
*/
bool is_public()
bool isPublic()
{
return (public_img == 1);
};
@@ -221,7 +221,7 @@ public:
string& name,
vector<const Attribute*>& values) const
{
return image_template.get(name,values);
return image_template->get(name,values);
};
/**
@@ -235,7 +235,7 @@ public:
vector<const Attribute*>& values) const
{
string str=name;
return image_template.get(str,values);
return image_template->get(str,values);
};
/**
@@ -248,7 +248,7 @@ public:
string& value) const
{
string str=name;
image_template.get(str,value);
image_template->get(str,value);
}
/**
@@ -261,7 +261,7 @@ public:
int& value) const
{
string str=name;
image_template.get(str,value);
image_template->get(str,value);
}
/**
@@ -270,7 +270,7 @@ public:
*/
int remove_template_attribute(SqlDB * db, const string& name)
{
return image_template.remove_attribute(db, name);
return image_template->remove_attribute(db, name);
}
private:
@@ -332,7 +332,7 @@ private:
/**
* The Image template, holds the Image attributes.
*/
ImageTemplate image_template;
ImageTemplate * image_template;
// *************************************************************************
@@ -382,7 +382,7 @@ protected:
// Constructor
// *************************************************************************
Image(int id=-1);
Image(int uid=-1, ImageTemplate *img_template = 0);
virtual ~Image();
+14 -29
View File
@@ -27,6 +27,8 @@
#include <iostream>
#include <vector>
class AuthRequest;
using namespace std;
/**
@@ -53,9 +55,9 @@ public:
* -2 in case of template parse failure
*/
int allocate (
int uid,
const string& stemplate,
int * oid);
int uid,
ImageTemplate * img_template,
int * oid);
/**
* Function to get a Image from the pool, if the object is not in memory
@@ -131,7 +133,7 @@ public:
{
SingleAttribute * sattr = new SingleAttribute(name,value);
return image->image_template.replace_attribute(db,sattr);
return image->image_template->replace_attribute(db,sattr);
}
/** Delete an image attribute in the template (Image MUST be locked)
@@ -143,7 +145,7 @@ public:
Image * image,
const string& name)
{
return image->image_template.remove_attribute(db, name);
return image->image_template->remove_attribute(db, name);
}
/**
@@ -168,31 +170,14 @@ public:
* @param disk the disk to be generated
* @return 0 on success, -1 error, -2 not using the pool
*/
int disk_attribute(VectorAttribute * disk, int * index)
{
string source;
Image * img;
int disk_attribute(VectorAttribute * disk, int * index);
source = disk->vector_value("NAME");
if (source.empty())
{
return -2;
}
img = get(source,true);
if (img == 0)
{
return -1;
}
int rc = img->disk_attribute(disk,index);
img->unlock();
return rc;
}
/**
* Generates an Authorization token for the DISK attribute
* @param disk the disk to be authorized
* @param ar the AuthRequest
*/
void authorize_disk(VectorAttribute * disk, AuthRequest * ar);
static const string& source_prefix()
{
+14 -1
View File
@@ -33,6 +33,7 @@
#include "DispatchManager.h"
#include "RequestManager.h"
#include "HookManager.h"
#include "AuthManager.h"
class Nebula
{
@@ -108,6 +109,12 @@ public:
return hm;
};
AuthManager * get_authm()
{
return authm;
};
// --------------------------------------------------------------
// Environment & Configuration
// --------------------------------------------------------------
@@ -217,7 +224,7 @@ private:
// -----------------------------------------------------------------------
Nebula():nebula_configuration(0),db(0),vmpool(0),hpool(0),vnpool(0),upool(0),
ipool(0),lcm(0),vmm(0),im(0),tm(0),dm(0),rm(0)
ipool(0),lcm(0),vmm(0),im(0),tm(0),dm(0),rm(0),hm(0),authm(0)
{
const char * nl = getenv("ONE_LOCATION");
@@ -308,6 +315,11 @@ private:
delete hm;
}
if ( authm != 0)
{
delete authm;
}
if ( nebula_configuration != 0)
{
delete nebula_configuration;
@@ -363,6 +375,7 @@ private:
DispatchManager * dm;
RequestManager * rm;
HookManager * hm;
AuthManager * authm;
// ---------------------------------------------------------------
// Implementation functions
+137 -27
View File
@@ -166,7 +166,130 @@ private:
void register_xml_methods();
int setup_socket();
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
// Error Messages
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
/**
* Logs authorization errors
* @param method name of the RM method where the error arose
* @param action authorization action
* @param object object that needs to be authorized
* @param uid user that is authorized
* @param id id of the object, -1 for Pool
* @returns string for logging
*/
static string authorization_error (const string& method,
const string &action,
const string &object,
int uid,
int id)
{
ostringstream oss;
oss << "[" << method << "]" << " User [" << uid << "] not authorized"
<< " to perform " << action << " on " << object;
if ( id != -1 )
{
oss << " [" << id << "].";
}
else
{
oss << " Pool";
}
return oss.str();
}
/**
* Logs authenticate errors
* @param method name of the RM method where the error arose
* @returns string for logging
*/
static string authenticate_error (const string& method)
{
ostringstream oss;
oss << "[" << method << "]" << " User couldn't be authenticated," <<
" aborting call.";
return oss.str();
}
/**
* Logs get object errors
* @param method name of the RM method where the error arose
* @param object over which the get failed
* @param id of the object over which the get failed
* @returns string for logging
*/
static string get_error (const string& method,
const string &object,
int id)
{
ostringstream oss;
oss << "[" << method << "]" << " Error getting " <<
object;
if ( id != -1 )
{
oss << " [" << id << "].";
}
else
{
oss << " Pool.";
}
return oss.str();
}
/**
* Logs action errors
* @param method name of the RM method where the error arose
* @param action that triggered the error
* @param object over which the action was applied
* @param id id of the object, -1 for Pool, -2 for no-id objects
* (allocate error, parse error)
* @param rc returned error code (NULL to ignore)
* @returns string for logging
*/
static string action_error (const string& method,
const string &action,
const string &object,
int id,
int rc)
{
ostringstream oss;
oss << "[" << method << "]" << " Error trying to " << action << " "
<< object;
switch(id)
{
case -2:
break;
case -1:
oss << "Pool.";
break;
default:
oss << " [" << id << "].";
break;
}
if ( rc != (int)NULL )
{
oss << " Returned error code [" << rc << "].";
}
return oss.str();
}
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
// XML-RPC Methods
@@ -180,8 +303,14 @@ private:
{
public:
VirtualMachineAllocate(
UserPool * _upool):
upool(_upool)
VirtualMachinePool * _vmpool,
VirtualNetworkPool * _vnpool,
ImagePool * _ipool,
UserPool * _upool):
vmpool(_vmpool),
vnpool(_vnpool),
ipool(_ipool),
upool(_upool)
{
_signature="A:ss";
_help="Allocates a virtual machine in the pool";
@@ -193,6 +322,9 @@ private:
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retval);
private:
VirtualMachinePool * vmpool;
VirtualNetworkPool * vnpool;
ImagePool * ipool;
UserPool * upool;
};
@@ -203,8 +335,8 @@ private:
public:
VirtualMachineDeploy(
VirtualMachinePool * _vmpool,
HostPool * _hpool,
UserPool * _upool):
HostPool * _hpool,
UserPool * _upool):
vmpool(_vmpool),
hpool(_hpool),
upool(_upool)
@@ -779,28 +911,6 @@ private:
UserPool * upool;
};
/* ---------------------------------------------------------------------- */
class UserInfo: public xmlrpc_c::method
{
public:
UserInfo(UserPool * _upool):upool(_upool)
{
_signature="A:si";
_help="Returns the Info of the user";
};
~UserInfo(){};
void execute(
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retvalP);
private:
UserPool * upool;
};
/* ---------------------------------------------------------------------- */
class UserDelete: public xmlrpc_c::method
-7
View File
@@ -50,7 +50,6 @@ public:
*/
string& to_xml(string& xml) const;
/**
* Get the User unique identifier UID, that matches the OID of the object
* @return UID User identifier
@@ -119,12 +118,6 @@ public:
password = _password;
};
/**
* Looks for a match between _password and user password
* @return -1 if disabled or wrong password, uid otherwise
**/
int authenticate(string _password);
/**
* Splits an authentication token (<usr>:<pass>)
* @param secret, the authentication token
+10 -1
View File
@@ -29,6 +29,8 @@
using namespace std;
class AuthRequest; //Forward definition of AuthRequest
/**
* The User Pool class. ...
*/
@@ -127,10 +129,17 @@ public:
/**
* Returns whether there is a user with given username/password or not
* @param session, colon separated username and password string
* @return -1 if there is no such a user, uid of the user if it exists
* @return -1 if authn failed, uid of the user in other case
*/
int authenticate(string& session);
/**
* Returns whether there is a user with given username/password or not
* @param ar, an Authorization Request
* @return -1 if authz failed, 0 otherwise
*/
static int authorize(AuthRequest& ar);
/**
* Dumps the User pool in XML format. A filter can be also added to the
* query
+9 -9
View File
@@ -553,7 +553,7 @@ public:
string& name,
vector<const Attribute*>& values) const
{
return vm_template.get(name,values);
return vm_template->get(name,values);
};
/**
@@ -567,7 +567,7 @@ public:
vector<const Attribute*>& values) const
{
string str=name;
return vm_template.get(str,values);
return vm_template->get(str,values);
};
/**
@@ -581,7 +581,7 @@ public:
string& value) const
{
string str=name;
vm_template.get(str,value);
vm_template->get(str,value);
}
/**
@@ -595,7 +595,7 @@ public:
int& value) const
{
string str=name;
vm_template.get(str,value);
vm_template->get(str,value);
}
/**
@@ -604,7 +604,7 @@ public:
*/
void template_to_xml(string &xml) const
{
vm_template.to_xml(xml);
vm_template->to_xml(xml);
}
/**
@@ -771,7 +771,7 @@ private:
/**
* The Virtual Machine template, holds the VM attributes.
*/
VirtualMachineTemplate vm_template;
VirtualMachineTemplate* vm_template;
// Dynamic state of the Virtual Machine
@@ -930,7 +930,7 @@ private:
int rc;
sattr = new SingleAttribute(name,value);
rc = vm_template.replace_attribute(db,sattr);
rc = vm_template->replace_attribute(db,sattr);
if (rc != 0)
{
@@ -949,7 +949,7 @@ private:
*/
int insert_template_attribute(SqlDB * db, Attribute * attribute)
{
return vm_template.insert_attribute(db,attribute);
return vm_template->insert_attribute(db,attribute);
}
// -------------------------------------------------------------------------
@@ -987,7 +987,7 @@ protected:
// Constructor
//**************************************************************************
VirtualMachine(int id=-1);
VirtualMachine(int id=-1, VirtualMachineTemplate * _vm_template = 0);
virtual ~VirtualMachine();
+5 -5
View File
@@ -39,7 +39,7 @@ public:
/**
* Function to allocate a new VM object
* @param uid user id (the owner of the VM)
* @param stemplate a string describing the VM
* @param vm_template a VM Template object describing the VM
* @param oid the id assigned to the VM (output)
* @param on_hold flag to submit on hold
* @return oid on success, -1 error inserting in DB or -2 error parsing
@@ -47,7 +47,7 @@ public:
*/
int allocate (
int uid,
const string& stemplate,
VirtualMachineTemplate *vm_template,
int * oid,
bool on_hold = false);
@@ -99,9 +99,9 @@ public:
* @return 0 on success
*/
int update_template_attribute(
VirtualMachine * vm,
string& name,
string& value)
VirtualMachine * vm,
string& name,
string& value)
{
return vm->update_template_attribute(db,name,value);
}
+18 -9
View File
@@ -58,6 +58,15 @@ public:
// Virtual Network Public Methods
// *************************************************************************
/**
* Get the Vnet unique identifier VNID, that matches the OID of the object
* @return VNID Image identifier
*/
int get_vnid() const
{
return oid;
};
/**
* Gets the uid of the owner of the Virtual Network
* @return uid
@@ -71,7 +80,7 @@ public:
* Returns true if the Virtual Network is public
* @return true if the Virtual Network is public
*/
bool is_public()
bool isPublic()
{
return (public_vnet == 1);
};
@@ -186,7 +195,7 @@ public:
string& name,
vector<const Attribute*>& values) const
{
return vn_template.get(name,values);
return vn_template->get(name,values);
};
/**
@@ -200,7 +209,7 @@ public:
vector<const Attribute*>& values) const
{
string str=name;
return vn_template.get(str,values);
return vn_template->get(str,values);
};
/**
@@ -213,7 +222,7 @@ public:
string& value) const
{
string str=name;
vn_template.get(str,value);
vn_template->get(str,value);
}
/**
@@ -226,7 +235,7 @@ public:
int& value) const
{
string str=name;
vn_template.get(str,value);
vn_template->get(str,value);
}
private:
@@ -284,7 +293,7 @@ private:
/**
* The Virtual Network template, holds the VNW attributes.
*/
VirtualNetworkTemplate vn_template;
VirtualNetworkTemplate * vn_template;
// *************************************************************************
// DataBase implementation (Private)
@@ -346,7 +355,7 @@ private:
int rc;
sattr = new SingleAttribute(name,value);
rc = vn_template.replace_attribute(db,sattr);
rc = vn_template->replace_attribute(db,sattr);
if (rc != 0)
{
@@ -362,7 +371,7 @@ protected:
// Constructor
//**************************************************************************
VirtualNetwork();
VirtualNetwork(VirtualNetworkTemplate * _vn_template = 0);
~VirtualNetwork();
@@ -419,7 +428,7 @@ protected:
{
int rc;
rc = vn_template.drop(db);
rc = vn_template->drop(db);
rc += leases->drop(db);
+13 -30
View File
@@ -22,8 +22,9 @@
#include <time.h>
using namespace std;
class AuthRequest;
using namespace std;
/**
* The Virtual Network Pool class. ...
@@ -39,16 +40,15 @@ public:
~VirtualNetworkPool(){};
/**
* Function to allocate a new VN object
* Function to allocate a new VNET object
* @param uid user identifier
* @param stemplate a string describing the VN
* @param vn_template a VirtualNetworkTemplate describing the VNET
* @param oid the id assigned to the VM (output)
* @return oid on success, -1 error inserting in DB,-2 error parsing
* the template, -3 wrong attributes in template
* @return oid on success, -1 error
*/
int allocate (
int uid,
const string& stemplate,
VirtualNetworkTemplate * vn_template,
int * oid);
/**
@@ -87,31 +87,14 @@ public:
* @param vid of the VM requesting the lease
* @return 0 on success, -1 error, -2 not using the pool
*/
int nic_attribute(VectorAttribute * nic, int vid)
{
string network;
VirtualNetwork * vnet;
int nic_attribute(VectorAttribute * nic, int vid);
network = nic->vector_value("NETWORK");
if (network.empty())
{
return -2;
}
vnet = get(network,true);
if (vnet == 0)
{
return -1;
}
int rc = vnet->nic_attribute(nic,vid);
vnet->unlock();
return rc;
}
/**
* Generates an Authorization token for a NIC attribute
* @param nic the nic to be authorized
* @param ar the AuthRequest
*/
void authorize_nic(VectorAttribute * nic, AuthRequest * ar);
/**
* Updates the template of a VN, adding a new attribute (replacing it if
+21 -6
View File
@@ -157,6 +157,7 @@ ETC_DIRS="$ETC_LOCATION/im_kvm \
$ETC_LOCATION/tm_dummy \
$ETC_LOCATION/tm_lvm \
$ETC_LOCATION/hm \
$ETC_LOCATION/auth \
$ETC_LOCATION/ec2query_templates \
$ETC_LOCATION/occi_templates"
@@ -240,10 +241,11 @@ INSTALL_ETC_FILES[10]="TM_SSH_ETC_FILES:$ETC_LOCATION/tm_ssh"
INSTALL_ETC_FILES[11]="TM_DUMMY_ETC_FILES:$ETC_LOCATION/tm_dummy"
INSTALL_ETC_FILES[12]="TM_LVM_ETC_FILES:$ETC_LOCATION/tm_lvm"
INSTALL_ETC_FILES[13]="HM_ETC_FILES:$ETC_LOCATION/hm"
INSTALL_ETC_FILES[14]="ECO_ETC_FILES:$ETC_LOCATION"
INSTALL_ETC_FILES[15]="ECO_ETC_TEMPLATE_FILES:$ETC_LOCATION/ec2query_templates"
INSTALL_ETC_FILES[16]="OCCI_ETC_FILES:$ETC_LOCATION"
INSTALL_ETC_FILES[17]="OCCI_ETC_TEMPLATE_FILES:$ETC_LOCATION/occi_templates"
INSTALL_ETC_FILES[14]="AUTH_ETC_FILES:$ETC_LOCATION/auth"
INSTALL_ETC_FILES[15]="ECO_ETC_FILES:$ETC_LOCATION"
INSTALL_ETC_FILES[16]="ECO_ETC_TEMPLATE_FILES:$ETC_LOCATION/ec2query_templates"
INSTALL_ETC_FILES[17]="OCCI_ETC_FILES:$ETC_LOCATION"
INSTALL_ETC_FILES[18]="OCCI_ETC_TEMPLATE_FILES:$ETC_LOCATION/occi_templates"
#-------------------------------------------------------------------------------
# Binary files, to be installed under $BIN_LOCATION
@@ -282,7 +284,11 @@ RUBY_LIB_FILES="src/mad/ruby/one_mad.rb \
src/cli/client_utilities.rb \
src/cli/command_parse.rb \
src/oca/ruby/OpenNebula.rb \
src/tm_mad/TMScript.rb"
src/tm_mad/TMScript.rb \
src/authm_mad/one_usage.rb \
src/authm_mad/quota.rb \
src/authm_mad/simple_auth.rb \
src/authm_mad/simple_permissions.rb"
RUBY_OPENNEBULA_LIB_FILES="src/oca/ruby/OpenNebula/Host.rb \
src/oca/ruby/OpenNebula/HostPool.rb \
@@ -321,7 +327,9 @@ MADS_LIB_FILES="src/mad/sh/madcommon.sh \
src/tm_mad/one_tm \
src/tm_mad/one_tm.rb \
src/hm_mad/one_hm.rb \
src/hm_mad/one_hm"
src/hm_mad/one_hm \
src/authm_mad/one_auth_mad.rb \
src/authm_mad/one_auth_mad"
#-------------------------------------------------------------------------------
# Information Manager Probes, to be installed under $LIB_LOCATION/im_probes
@@ -439,6 +447,13 @@ TM_LVM_ETC_FILES="src/tm_mad/lvm/tm_lvm.conf \
HM_ETC_FILES="src/hm_mad/hmrc"
#-------------------------------------------------------------------------------
# Hook Manager driver config. files, to be installed under $ETC_LOCATION/hm
#-------------------------------------------------------------------------------
AUTH_ETC_FILES="src/authm_mad/auth_mad \
src/authm_mad/auth.conf"
#-------------------------------------------------------------------------------
# Sample files, to be installed under $SHARE_LOCATION/examples
#-------------------------------------------------------------------------------
+21 -3
View File
@@ -258,12 +258,12 @@ TM_MAD = [
HM_MAD = [
executable = "one_hm" ]
#-------------------------------- Image Hook -----------------------------------
# This hook is used to handle image saving and overwriting when virtual machines
# reach the DONE state after being shutdown.
#
# reach the DONE state after being shutdown.
#
# Uncomment one of the following:
#
# Self-contained (substitute [ONE_LOCATION] with its proper path)
@@ -302,3 +302,21 @@ HM_MAD = [
# arguments = "$VMID $NAME",
# remote = "no" ]
#------------------------------------------------------------------------------
#*******************************************************************************
# Auth Manager Configuration
#*******************************************************************************
# The Driver (AUTHM_MAD) that will be used to authenticate and authorize
# OpenNebula requests. If not defined OpenNebula will use the built-in auth
# policies
# executable: path of the auth driver executable, can be an
# absolute path or relative to $ONE_LOCATION/lib/mads (or
# /usr/lib/one/mads/ if OpenNebula was installed in /)
#
# arguments : for the driver executable, can be an absolute path or relative
# to $ONE_LOCATION/etc (or /etc/one/ if OpenNebula was installed
# in /)
#-------------------------------------------------------------------------------
#AUTH_MAD = [
# executable = "<path_to_auth_mad>" ]
+5 -3
View File
@@ -62,8 +62,10 @@ done
if [ "$MYSQL" = "yes" ] ; then
TEST_ARGS="-m"
BUILD_ARGS="mysql=yes sqlite=no"
else
TEST_ARGS="-s"
BUILD_ARGS="mysql=no sqlite=yes"
fi
if [ "$LOGS" = "yes" ] ; then
@@ -78,7 +80,7 @@ elif [ "$VAL_CALL" = "yes" ] ; then
CALLER="valgrind --tool=callgrind"
fi
TESTS=`find $TWD_DIR -name test -type d`
TESTS=`find $TWD_DIR -name test -type d | grep -v ruby`
for i in $TESTS ; do
cd $BASE_DIR
@@ -88,9 +90,9 @@ for i in $TESTS ; do
if [ "$CLEAR" = "yes" ] ; then
scons -c
rm -f callgrind.out* test.db* test.log* memgrid.out*
rm -f callgrind.out* test.db* *.log* memgrid.out*
elif [ "$BUILD" = "yes" ] ; then
scons
scons $BUILD_ARGS
else
for j in `ls test*` ; do
$CALLER ./$j $TEST_ARGS
+513
View File
@@ -0,0 +1,513 @@
/* -------------------------------------------------------------------------- */
/* Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); you may */
/* not use this file except in compliance with the License. You may obtain */
/* a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
/* See the License for the specific language governing permissions and */
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#include "AuthManager.h"
#include "NebulaLog.h"
#include "Nebula.h"
#include <openssl/sha.h>
#include <openssl/hmac.h>
#include <openssl/evp.h>
#include <openssl/bio.h>
#include <openssl/buffer.h>
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
time_t AuthManager::_time_out;
const char * AuthManager::auth_driver_name = "auth_exe";
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
string * AuthRequest::base64_encode(const string& in)
{
BIO * bio_mem;
BIO * bio_64;
char * encoded_c;
long int size;
bio_64 = BIO_new(BIO_f_base64());
bio_mem = BIO_new(BIO_s_mem());
BIO_push(bio_64, bio_mem);
BIO_set_flags(bio_64,BIO_FLAGS_BASE64_NO_NL);
BIO_write(bio_64, in.c_str(), in.length());
if (BIO_flush(bio_64) != 1)
{
return 0;
}
size = BIO_get_mem_data(bio_mem,&encoded_c);
string * encoded = new string(encoded_c,size);
BIO_free_all(bio_64);
return encoded;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void AuthRequest::add_auth(Object ob,
const string& ob_id,
Operation op,
int owner,
bool pub)
{
ostringstream oss;
bool auth;
switch (ob)
{
case VM: oss << "VM:" ; break;
case HOST: oss << "HOST:" ; break;
case NET: oss << "NET:" ; break;
case IMAGE: oss << "IMAGE:" ; break;
case USER: oss << "USER:" ; break;
case CLUSTER: oss << "CLUSTER:" ; break;
}
if (op == CREATE) //encode the ob_id, it is a template
{
string * encoded_id = base64_encode(ob_id);
if (encoded_id != 0)
{
oss << *encoded_id << ":";
delete (encoded_id);
}
else
{
oss << "-:";
}
}
else
{
oss << ob_id << ":";
}
switch (op)
{
case CREATE:
oss << "CREATE:" ;
break;
case DELETE:
oss << "DELETE:" ;
break;
case USE:
oss << "USE:" ;
break;
case MANAGE:
oss << "MANAGE:" ;
break;
case INFO:
oss << "INFO:" ;
break;
}
oss << owner << ":" << pub;
// -------------------------------------------------------------------------
// Authorize the request for self authorization
// -------------------------------------------------------------------------
if ( uid == 0 )
{
auth = true;
}
else
{
auth = false;
switch (op)
{
case CREATE:
if ( ob == VM || ob == NET || ob == IMAGE )
{
auth = true;
}
break;
case DELETE:
auth = owner == uid;
break;
case USE:
if (ob == NET || ob == IMAGE)
{
auth = (owner == uid) || pub;
}
else if (ob == HOST)
{
auth = true;
}
break;
case MANAGE:
auth = owner == uid;
break;
case INFO: // This is for completeness, as the only INFO existing
// is for UserPool, and just oneadmin can see it
break;
}
}
self_authorize = self_authorize && auth;
auths.push_back(oss.str());
};
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
extern "C" void * authm_action_loop(void *arg)
{
AuthManager * authm;
if ( arg == 0 )
{
return 0;
}
authm = static_cast<AuthManager *>(arg);
NebulaLog::log("AuM",Log::INFO,"Authorization Manager started.");
authm->am.loop(authm->timer_period,0);
NebulaLog::log("AuM",Log::INFO,"Authorization Manager stopped.");
return 0;
}
/* -------------------------------------------------------------------------- */
int AuthManager::start()
{
int rc;
pthread_attr_t pattr;
rc = MadManager::start();
if ( rc != 0 )
{
return -1;
}
NebulaLog::log("AuM",Log::INFO,"Starting Auth Manager...");
pthread_attr_init (&pattr);
pthread_attr_setdetachstate (&pattr, PTHREAD_CREATE_JOINABLE);
rc = pthread_create(&authm_thread,&pattr,authm_action_loop,(void *) this);
return rc;
};
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void AuthManager::trigger(Actions action, AuthRequest * request)
{
string aname;
switch (action)
{
case AUTHENTICATE:
aname = "AUTHENTICATE";
break;
case AUTHORIZE:
aname = "AUTHORIZE";
break;
case FINALIZE:
aname = ACTION_FINALIZE;
break;
default:
return;
}
am.trigger(aname,request);
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void AuthManager::do_action(const string &action, void * arg)
{
AuthRequest * request;
request = static_cast<AuthRequest *>(arg);
if (action == "AUTHENTICATE" && request != 0)
{
authenticate_action(request);
}
else if (action == "AUTHORIZE" && request != 0)
{
authorize_action(request);
}
else if (action == ACTION_TIMER)
{
timer_action();
}
else if (action == ACTION_FINALIZE)
{
NebulaLog::log("AuM",Log::INFO,"Stopping Authorization Manager...");
MadManager::stop();
}
else
{
ostringstream oss;
oss << "Unknown action name: " << action;
NebulaLog::log("AuM", Log::ERROR, oss);
}
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void AuthManager::authenticate_action(AuthRequest * ar)
{
const AuthManagerDriver * authm_md;
// ------------------------------------------------------------------------
// Get the driver
// ------------------------------------------------------------------------
authm_md = get();
if (authm_md == 0)
{
goto error_driver;
}
// ------------------------------------------------------------------------
// Queue the request
// ------------------------------------------------------------------------
ar->id = add_request(ar);
// ------------------------------------------------------------------------
// Make the request to the driver
// ---- --------------------------------------------------------------------
authm_md->authenticate(ar->id,
ar->uid,
ar->username,
ar->password,
ar->session);
return;
error_driver:
ar->result = false;
ar->message = "Could not find Authorization driver";
ar->notify();
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void AuthManager::authorize_action(AuthRequest * ar)
{
const AuthManagerDriver * authm_md;
string auths;
// ------------------------------------------------------------------------
// Get the driver
// ------------------------------------------------------------------------
authm_md = get();
if (authm_md == 0)
{
goto error_driver;
}
// ------------------------------------------------------------------------
// Queue the request
// ------------------------------------------------------------------------
ar->id = add_request(ar);
// ------------------------------------------------------------------------
// Make the request to the driver
// ------------------------------------------------------------------------
auths = ar->get_auths();
authm_md->authorize(ar->id, ar->uid, auths);
return;
error_driver:
ar->result = false;
ar->message = "Could not find Authorization driver";
ar->notify();
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void AuthManager::timer_action()
{
map<int,AuthRequest *>::iterator it;
time_t the_time = time(0);
lock();
for (it=auth_requests.begin();it!=auth_requests.end();it++)
{
if (the_time > it->second->time_out)
{
AuthRequest * ar = it->second;
auth_requests.erase(it);
ar->result = false;
ar->timeout = true;
ar->message = "Auth request timeout";
ar->notify();
}
}
unlock();
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
int AuthManager::add_request(AuthRequest *ar)
{
static int auth_id = 0;
int id;
lock();
id = auth_id++;
auth_requests.insert(auth_requests.end(),make_pair(id,ar));
unlock();
return id;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
AuthRequest * AuthManager::get_request(int id)
{
AuthRequest * ar = 0;
map<int,AuthRequest *>::iterator it;
ostringstream oss;
lock();
it=auth_requests.find(id);
if ( it != auth_requests.end())
{
ar = it->second;
auth_requests.erase(it);
}
unlock();
return ar;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void AuthManager::notify_request(int auth_id,bool result,const string& message)
{
AuthRequest * ar;
ar = get_request(auth_id);
if ( ar == 0 )
{
return;
}
ar->result = result;
ar->message= message;
ar->notify();
}
/* ************************************************************************** */
/* MAD Loading */
/* ************************************************************************** */
void AuthManager::load_mads(int uid)
{
ostringstream oss;
const VectorAttribute * vattr;
int rc;
string name;
AuthManagerDriver * authm_driver = 0;
oss << "Loading Auth. Manager driver.";
NebulaLog::log("AuM",Log::INFO,oss);
vattr = static_cast<const VectorAttribute *>(mad_conf[0]);
if ( vattr == 0 )
{
NebulaLog::log("AuM",Log::ERROR,"Failed to load Auth. Manager driver.");
return;
}
VectorAttribute auth_conf("AUTH_MAD",vattr->value());
auth_conf.replace("NAME",auth_driver_name);
authm_driver = new AuthManagerDriver(uid,auth_conf.value(),(uid!=0),this);
rc = add(authm_driver);
if ( rc == 0 )
{
oss.str("");
oss << "\tAuth Manager loaded";
NebulaLog::log("AuM",Log::INFO,oss);
}
}
+127
View File
@@ -0,0 +1,127 @@
/* -------------------------------------------------------------------------- */
/* Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); you may */
/* not use this file except in compliance with the License. You may obtain */
/* a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
/* See the License for the specific language governing permissions and */
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#include "AuthManagerDriver.h"
#include "AuthManager.h"
#include "NebulaLog.h"
#include "Nebula.h"
#include <sstream>
/* ************************************************************************** */
/* Driver ASCII Protocol Implementation */
/* ************************************************************************** */
void AuthManagerDriver::authorize(int oid, int uid, const string& reqs) const
{
ostringstream os;
os << "AUTHORIZE " << oid << " " << uid << " " << reqs << endl;
write(os);
}
void AuthManagerDriver::authenticate(int oid,
int uid,
const string& username,
const string& password,
const string& session) const
{
ostringstream os;
os << "AUTHENTICATE " << oid << " "
<< uid << " "
<< username << " "
<< password << " "
<< session << endl;
write(os);
}
/* ************************************************************************** */
/* MAD Interface */
/* ************************************************************************** */
void AuthManagerDriver::protocol(
string& message)
{
istringstream is(message);
ostringstream os;
string action;
string result;
string info="";
int id;
os << "Message received: " << message;
NebulaLog::log("AuM", Log::DEBUG, os);
// Parse the driver message
if ( is.good() )
is >> action >> ws;
else
return;
if ( is.good() )
is >> result >> ws;
else
return;
if ( is.good() )
{
is >> id >> ws;
if ( is.fail() )
{
if ( action == "LOG" )
{
is.clear();
getline(is,info);
NebulaLog::log("AuM",Log::INFO, info.c_str());
}
return;
}
}
else
return;
if (action == "LOG")
{
getline(is,info);
NebulaLog::log("AuM",Log::INFO,info.c_str());
}
else if (result == "SUCCESS")
{
authm->notify_request(id,true,info);
}
else
{
getline(is,info);
authm->notify_request(id,false,info);
}
return;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void AuthManagerDriver::recover()
{
NebulaLog::log("AuM",Log::INFO,"Recovering Authorization drivers");
}
+30
View File
@@ -0,0 +1,30 @@
# SConstruct for src/vm
# -------------------------------------------------------------------------- #
# Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may #
# not use this file except in compliance with the License. You may obtain #
# a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
#--------------------------------------------------------------------------- #
Import('env')
lib_name='nebula_authm'
# Sources to generate the library
source_files=[
'AuthManager.cc',
'AuthManagerDriver.cc'
]
# Build library
env.StaticLibrary(lib_name, source_files)
+292
View File
@@ -0,0 +1,292 @@
/* -------------------------------------------------------------------------- */
/* Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); you may */
/* not use this file except in compliance with the License. You may obtain */
/* a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
/* See the License for the specific language governing permissions and */
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#include <string>
#include <iostream>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include "AuthManager.h"
#include "Template.h"
#include "NebulaLog.h"
#include <TestFixture.h>
#include <TestAssert.h>
#include <TestSuite.h>
#include <TestCaller.h>
#include <ui/text/TestRunner.h>
#include <cppunit/extensions/HelperMacros.h>
using namespace std;
/* ************************************************************************* */
/* ************************************************************************* */
class AuthManagerTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE (AuthManagerTest);
CPPUNIT_TEST (load);
//CPPUNIT_TEST (timeout);
CPPUNIT_TEST (authenticate);
CPPUNIT_TEST (authorize);
CPPUNIT_TEST (self_authorize);
CPPUNIT_TEST (self_authenticate);
CPPUNIT_TEST_SUITE_END ();
public:
AuthManagerTest(){};
~AuthManagerTest(){};
/* ********************************************************************* */
/* ********************************************************************* */
void setUp()
{
ostringstream oss;
vector<const Attribute *> am_mads;
char *error = 0;
MadManager::mad_manager_system_init();
oss << "AUTH_MAD = [ executable=\"/" << getenv("PWD")
<< "/dummy\"]" << endl;
t = new Template();
t->parse(oss.str(),&error);
t->get("AUTH_MAD", am_mads);
am = new AuthManager(1,3,am_mads);
};
void tearDown()
{
delete am;
delete t;
};
void load()
{
int rc;
rc = am->start();
CPPUNIT_ASSERT(rc==0);
am->load_mads(0);
am->trigger(AuthManager::FINALIZE,0);
pthread_join(am->get_thread_id(),0);
CPPUNIT_ASSERT(0==0);
}
//This test needs a driver that takes more than 3 secs to AUTHENTICATE
void timeout()
{
int rc;
AuthRequest ar(2);
rc = am->start();
CPPUNIT_ASSERT(rc==0);
am->load_mads(0);
ar.add_authenticate("the_user","the_pass","the_secret");
am->trigger(AuthManager::AUTHENTICATE,&ar);
ar.wait();
CPPUNIT_ASSERT(ar.result==false);
CPPUNIT_ASSERT(ar.timeout==true);
am->discard_request(ar.id);
am->trigger(AuthManager::FINALIZE,0);
pthread_join(am->get_thread_id(),0);
CPPUNIT_ASSERT(0==0);
}
void authenticate()
{
int rc;
AuthRequest ar(2);
rc = am->start();
CPPUNIT_ASSERT(rc==0);
am->load_mads(0);
ar.add_authenticate("the_user","the_pass","the_secret");
am->trigger(AuthManager::AUTHENTICATE,&ar);
ar.wait();
CPPUNIT_ASSERT(ar.result==true);
am->trigger(AuthManager::FINALIZE,0);
pthread_join(am->get_thread_id(),0);
CPPUNIT_ASSERT(0==0);
}
void authorize()
{
int rc;
AuthRequest ar(2);
rc = am->start();
CPPUNIT_ASSERT(rc==0);
am->load_mads(0);
//OBJECT:OBJECT_ID:ACTION:OWNER:PUBLIC
string astr="VM:VGhpcyBpcyBhIHRlbXBsYXRlCg==:CREATE:-1:0 "
"IMAGE:2:USE:3:0 "
"NET:4:DELETE:5:1 "
"HOST:6:MANAGE:7:1";
ar.add_auth(AuthRequest::VM,
"This is a template\n",
AuthRequest::CREATE,
-1,
false);
ar.add_auth(AuthRequest::IMAGE,
2,
AuthRequest::USE,
3,
false);
ar.add_auth(AuthRequest::NET,
4,
AuthRequest::DELETE,
5,
true);
ar.add_auth(AuthRequest::HOST,
6,
AuthRequest::MANAGE,
7,
true);
am->trigger(AuthManager::AUTHORIZE,&ar);
ar.wait();
CPPUNIT_ASSERT(ar.result==false);
CPPUNIT_ASSERT(ar.message==astr);
am->trigger(AuthManager::FINALIZE,0);
pthread_join(am->get_thread_id(),0);
CPPUNIT_ASSERT(0==0);
}
void self_authorize()
{
AuthRequest ar(2);
AuthRequest ar1(2);
AuthRequest ar2(3);
AuthRequest ar3(4);
AuthRequest ar4(2);
AuthRequest ar5(0);
AuthRequest ar6(0);
ar.add_auth(AuthRequest::VM,"dGhpcy",AuthRequest::CREATE,2,false);
ar.add_auth(AuthRequest::NET,2,AuthRequest::USE,2,false);
ar.add_auth(AuthRequest::IMAGE,3,AuthRequest::USE,4,true);
CPPUNIT_ASSERT(ar.plain_authorize() == true);
ar1.add_auth(AuthRequest::VM,"dGhpcy",AuthRequest::CREATE,2,false);
ar1.add_auth(AuthRequest::NET,2,AuthRequest::USE,2,false);
ar1.add_auth(AuthRequest::IMAGE,3,AuthRequest::USE,4,false);
CPPUNIT_ASSERT(ar1.plain_authorize() == false);
ar2.add_auth(AuthRequest::HOST,"dGhpcy",AuthRequest::CREATE,0,false);
CPPUNIT_ASSERT(ar2.plain_authorize() == false);
ar3.add_auth(AuthRequest::VM,5,AuthRequest::MANAGE,2,false);
CPPUNIT_ASSERT(ar3.plain_authorize() == false);
ar4.add_auth(AuthRequest::VM,4,AuthRequest::MANAGE,2,false);
CPPUNIT_ASSERT(ar4.plain_authorize() == true);
ar5.add_auth(AuthRequest::HOST,4,AuthRequest::MANAGE,0,false);
CPPUNIT_ASSERT(ar5.plain_authorize() == true);
ar6.add_auth(AuthRequest::HOST,4,AuthRequest::CREATE,0,false);
CPPUNIT_ASSERT(ar6.plain_authorize() == true);
}
void self_authenticate()
{
AuthRequest ar(2);
AuthRequest ar1(2);
ar.add_authenticate("the_user","the_pass","the_secret");
CPPUNIT_ASSERT(ar.plain_authenticate() == false);
ar1.add_authenticate("the_user","the_pass","the_pass");
CPPUNIT_ASSERT(ar1.plain_authenticate() == true);
}
private:
AuthManager * am;
Template * t;
};
/* ************************************************************************* */
/* ************************************************************************* */
int main(int argc, char ** argv)
{
CppUnit::TextUi::TestRunner runner;
NebulaLog::init_log_system(NebulaLog::FILE, Log::DEBUG,"test.log");
NebulaLog::log("Test", Log::INFO, "Test started");
runner.addTest(AuthManagerTest::suite());
runner.run();
NebulaLog::finalize_log_system();
return 0;
}
+88
View File
@@ -0,0 +1,88 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2009, Distributed Systems Architecture Group, Universidad #
# Complutense de Madrid (dsa-research.org) #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may #
# not use this file except in compliance with the License. You may obtain #
# a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
#--------------------------------------------------------------------------- #
import os
import sys
import shutil
sys.path.append("../../../share/scons")
from lex_bison import *
# This is the absolute path where the project is located
cwd="../../../"
# Environment that will be applied to each scons child
main_env=Environment()
main_env['ENV']['PATH']=os.environ['PATH']
# Add builders for flex and bison
add_lex(main_env)
add_bison(main_env)
# Include dirs
main_env.Append(CPPPATH=[
cwd + '/include',
'/usr/include/cppunit/'
])
# Library dirs
main_env.Append(LIBPATH=[
cwd + '/src/common',
cwd + '/src/template',
cwd + '/src/mad',
cwd + '/src/nebula',
cwd + '/src/authm',
cwd + '/src/sql',
cwd + '/src/log',
])
main_env.Append(LIBS=[
'nebula_template',
'nebula_common',
'nebula_core',
'nebula_mad',
'nebula_authm',
'nebula_sql',
'nebula_log',
'cppunit',
'dl',
'pthread',
'ssl'
])
# Compile flags
main_env.Append(CPPFLAGS=[
"-g",
"-Wall"
])
# MYSQL
main_env.Append(LIBPATH=["/usr/lib/mysql"])
main_env.Append(CPPPATH=["/usr/include/mysql"])
sqlite=ARGUMENTS.get('sqlite', 'yes')
if sqlite=='yes':
main_env.Append(CPPFLAGS=["-DSQLITE_DB"])
main_env.Append(LIBS=[ 'sqlite3', ])
# MySQL
mysql=ARGUMENTS.get('mysql', 'no')
if mysql=='yes':
main_env.Append(CPPFLAGS=["-DMYSQL_DB"])
main_env.Append(LIBS=[ 'mysqlclient', ])
main_env.Program('test','AuthManagerTest.cc')
#
+44
View File
@@ -0,0 +1,44 @@
#!/bin/bash
# --------------------------------------------------------------------------
# Copyright 2002-2006 GridWay Team, Distributed Systems Architecture
# Group, Universidad Complutense de Madrid
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# --------------------------------------------------------------------------
echo "MAD started" >> mad.log
while read COMMAND ARG1 ARG2 ARG3
do
echo "$COMMAND $ARG1 $ARG2 $ARG3" >> mad.log
case $COMMAND in
"INIT")
echo "INIT SUCCESS"
;;
"FINALIZE")
echo "FINALIZE SUCCESS"
exit 0
;;
"AUTHORIZE")
echo "AUTHORIZE FAILURE $ARG1 $ARG3"
;;
"AUTHENTICATE")
echo "AUTHENTICATE SUCCESS $ARG1"
;;
*)
echo "$COMMAND - FAILURE Unknown command"
;;
esac
done
+5
View File
@@ -0,0 +1,5 @@
:database: sqlite://auth.db
:quota:
:defaults:
:cpu: 10.0
:memory: 1048576
+1
View File
@@ -0,0 +1 @@
+39
View File
@@ -0,0 +1,39 @@
#!/bin/bash
# -------------------------------------------------------------------------- #
# Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may #
# not use this file except in compliance with the License. You may obtain #
# a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
#--------------------------------------------------------------------------- #
if [ -z "${ONE_LOCATION}" ]; then
DRIVERRC=/etc/one/auth/authrc
MADCOMMON=/usr/lib/one/mads/madcommon.sh
VAR_LOCATION=/var/lib/one
else
DRIVERRC=$ONE_LOCATION/etc/auth/authrc
MADCOMMON=$ONE_LOCATION/lib/mads/madcommon.sh
VAR_LOCATION=$ONE_LOCATION/var
fi
. $MADCOMMON
# Export the vmm_mad specific rc
export_rc_vars $DRIVERRC
# Go to ONE_LOCATION
cd $VAR_LOCATION
# Execute the actual MAD
execute_mad $*
+87
View File
@@ -0,0 +1,87 @@
#!/usr/bin/env ruby
# -------------------------------------------------------------------------- #
# Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may #
# not use this file except in compliance with the License. You may obtain #
# a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
#--------------------------------------------------------------------------- #
ONE_LOCATION=ENV["ONE_LOCATION"]
if !ONE_LOCATION
RUBY_LIB_LOCATION="/usr/lib/one/ruby"
ETC_LOCATION="/etc/one/"
else
RUBY_LIB_LOCATION=ONE_LOCATION+"/lib/ruby"
ETC_LOCATION=ONE_LOCATION+"/etc/"
end
$: << RUBY_LIB_LOCATION
require 'pp'
require 'rubygems'
require 'OpenNebulaDriver'
require 'simple_auth'
require 'simple_permissions'
require 'yaml'
require 'sequel'
class AuthorizationManager < OpenNebulaDriver
def initialize
super(1, false)
config_data=File.read(ETC_LOCATION+'/auth/auth.conf')
STDERR.puts(config_data)
@config=YAML::load(config_data)
STDERR.puts @config.inspect
database_url=@config[:database]
@db=Sequel.connect(database_url)
@authenticate=SimpleAuth.new
@permissions=SimplePermissions.new(@db, OpenNebula::Client.new,
@config)
register_action(:AUTHENTICATE, method('action_authenticate'))
register_action(:AUTHORIZE, method('action_authorize'))
end
def action_authenticate(request_id, user_id, user, password, token)
auth=@authenticate.auth(user_id, user, password, token)
if auth==true
send_message('AUTHENTICATE', RESULT[:success],
request_id, 'Successfully authenticated')
else
send_message('AUTHENTICATE', RESULT[:failure],
request_id, auth)
end
end
def action_authorize(request_id, user_id, *tokens)
auth=@permissions.auth(user_id, tokens.flatten)
if auth==true
send_message('AUTHORIZE', RESULT[:success],
request_id, 'success')
else
send_message('AUTHORIZE', RESULT[:failure],
request_id, auth)
end
end
end
am=AuthorizationManager.new
am.start_driver
+86
View File
@@ -0,0 +1,86 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may #
# not use this file except in compliance with the License. You may obtain #
# a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
#--------------------------------------------------------------------------- #
require 'OpenNebula'
# This class holds usage information for a virtual machine or
# total usage for a user. Variables inside are cpu and memory
# consumption
class VmUsage
attr_accessor :cpu, :memory
def initialize(cpu, memory)
@cpu=cpu
@memory=memory
end
end
# This class retrieves and caches vms and its consuption grouped
# by users. 'update_user' method should be called to fill data for
# a user before any calculation is made
class OneUsage
# 'client' is an OpenNebula::Client object used to connect
# to OpenNebula daemon. Ideally it should connect as user 0
def initialize(client)
@client=client
@users=Hash.new
end
# Gets information about VMs defined for a user. It caches new
# VMs and takes out from the cache deleted VMs
def update_user(user)
@users[user]=Hash.new if !@users[user]
vmpool=OpenNebula::VirtualMachinePool.new(@client, user)
vmpool.info
one_ids=vmpool.map {|vm| vm.id }
vms=@users[user]
user_ids=vms.keys
deleted_vms=user_ids-one_ids
added_vms=one_ids-user_ids
deleted_vms.each {|vmid| vms.delete(vmid) }
added_vms.each do |vmid|
vm=OpenNebula::VirtualMachine.new(
OpenNebula::VirtualMachine.build_xml(vmid), @client)
vm.info
hash=vm.to_hash['VM']['TEMPLATE']
usage=VmUsage.new(hash['CPU'].to_f, hash['MEMORY'].to_i)
vms[vmid.to_i]=usage
end
end
# Returns the cache of defined VMs for a user. It is a hash with
# VM id as key and VmUsage as value
def vms(user)
vms=@users[user]
@users[user]=vms=Hash.new if !vms
vms
end
# Returns total consumption by a user into a VmUsage object
def total(user)
usage=VmUsage.new(0.0, 0)
@users[user].each do |id, vm|
usage.cpu+=vm.cpu
usage.memory+=vm.memory
end
usage
end
end
+115
View File
@@ -0,0 +1,115 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may #
# not use this file except in compliance with the License. You may obtain #
# a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
#--------------------------------------------------------------------------- #
require 'one_usage'
# Quota functionality for auth driver. Stores in database limits for each
# user and using OneUsage is able to retrieve resource usage from
# OpenNebula daemon and check if it is below limits
class Quota
attr_accessor :defaults
TABLE_NAME=:quotas
# 'db' is a Sequel database where to store user limits and client
# is OpenNebula::Client used to connect to OpenNebula daemon
def initialize(db, client, conf={})
@db=db
@client=client
@conf={
:defaults => {
:cpu => nil,
:memory => nil
}
}.merge(conf)
STDERR.puts conf.inspect
STDERR.puts @conf.inspect
@defaults=@conf[:defaults]
@usage=OneUsage.new(@client)
create_table
@table=@db[TABLE_NAME]
end
# Creates database quota table if it does not exist
def create_table
@db.create_table?(TABLE_NAME) do
primary_key :id
Integer :uid
Float :cpu
Integer :memory
Integer :num_vms
index :uid
end
end
# Adds new user limits
def set(uid, cpu, memory, num_vms)
data={
:cpu => cpu,
:memory => memory,
:num_vms => num_vms
}
quotas=@table.filter(:uid => uid)
if quotas.first
quotas.update(data)
else
@table.insert(data.merge!(:uid => uid))
end
end
# Gets user limits
def get(uid)
limit=@table.filter(:uid => uid).first
if limit
limit
else
@defaults
end
end
# Checks if the user is below resource limits. If new_vm is defined
# checks if its requirements fit in limits
def check(user, new_vm=nil)
usage=@usage.total(user)
user_quota=get(user)
if new_vm
usage.cpu+=new_vm.cpu
usage.memory+=new_vm.memory
end
STDERR.puts [user_quota, usage, new_vm].inspect
(!user_quota[:cpu] || usage.cpu<=user_quota[:cpu]) &&
(!user_quota[:memory] || usage.memory<=user_quota[:memory])
end
# Updates user resource consuption
def update(user)
@usage.update_user(user)
end
# Get cache for the user
def get_user(user)
@usage.vms(user)
end
end
+33
View File
@@ -0,0 +1,33 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may #
# not use this file except in compliance with the License. You may obtain #
# a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
#--------------------------------------------------------------------------- #
class SimpleAuth
def initialize
end
def auth(user_id, user, password, token)
STDERR.puts [user_id, user, password, token].inspect
STDERR.flush
t_user, t_password=token.split(':')
#auth=(user==t_user && password==t_password)
auth=(password==token)
auth="Invalid credentials" if auth!=true
auth
end
end
+87
View File
@@ -0,0 +1,87 @@
require 'quota'
require 'base64'
class SimplePermissions
def initialize(database, client, conf={})
@quota=Quota.new(database, client, conf[:quota] || {})
end
def auth_message(result, message)
result ? true : message
end
def get_vm_usage(data)
vm_xml=Base64::decode64(data)
vm=OpenNebula::VirtualMachine.new(vm_xml)
vm_hash=vm.to_hash
# Should set more sensible defaults or get driver configuration
cpu=vm_hash['TEMPLATE']['CPU']
cpu||=1.0
memory=vm_hash['TEMPLATE']['MEMORY']
memory||=64
VmUsage.new(cpu, memory)
end
def auth(uid, tokens)
STDERR.puts [uid, tokens].inspect
result=true
tokens.each do |token|
object, id, action, owner, pub=token.split(':')
result=auth_object(uid.to_s, object, id, action, owner, pub)
break result if result!=true
end
result
end
def auth_object(uid, object, id, action, owner, pub)
return true if uid=='0'
case object
when 'VM'
return auth_vm(uid, object, id, action, owner, pub)
when 'HOST'
return auth_host(uid, object, id, action, owner, pub)
else
return auth_generic(uid, object, id, action, owner, pub)
end
end
def auth_vm(uid, object, id, action, owner, pub)
case action
when 'CREATE'
STDERR.puts "create vm"
if @quota.check(uid, get_vm_usage(id))
return true
else
return "Quota exceeded"
end
else
auth_message(uid==owner, "You cannot manage VM #{id}")
end
end
def auth_host(uid, object, id, action, owner, pub)
auth_message(action=='USE', 'Only oneadmin can manage hosts')
end
def auth_generic(uid, object, id, action, owner, pub)
case action
when 'CREATE'
true
when 'USE'
auth_message(uid==owner || pub=='1', "You are not allowed to "<<
"#{action} #{object} #{id}")
else
auth_message(uid==owner, "You are not allowed to "<<
"#{action} #{object} #{id}")
end
end
end
+55
View File
@@ -0,0 +1,55 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may #
# not use this file except in compliance with the License. You may obtain #
# a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
#--------------------------------------------------------------------------- #
class ClientMock
def initialize(mock_data)
@mock_data=mock_data
end
def search_method(methods, args)
keys=methods.keys
if keys.include? args[0]
value=methods[args[0]]
if value.class != Hash
return value
elsif args.length>1
return search_method(value, args[1..-1])
else
nil
end
else
nil
end
end
def call(action, *args)
value=search_method(@mock_data, [action]+args.flatten)
if value
if value.class==Proc
value.call(action, args.flatten)
else
value
end
else
message="Action '#{action}(#{args.join(',')})' not defined"
STDERR.puts message
OpenNebula::Error.new(message)
end
end
end
+25
View File
@@ -0,0 +1,25 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may #
# not use this file except in compliance with the License. You may obtain #
# a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
#--------------------------------------------------------------------------- #
require 'rubygems'
require 'sequel'
def check_column(schema, column)
schema.find {|c| c[0] == column }.should_not == nil
end
+551
View File
@@ -0,0 +1,551 @@
vmpool.info:
0: "<VM_POOL>
<VM>
<ID>
0
</ID>
<UID>
0
</UID>
<USERNAME>
jfontan
</USERNAME>
<NAME>
test
</NAME>
<LAST_POLL>
0
</LAST_POLL>
<STATE>
1
</STATE>
<LCM_STATE>
0
</LCM_STATE>
<STIME>
1278433840
</STIME>
<ETIME>
0
</ETIME>
<DEPLOY_ID/>
<MEMORY>
0
</MEMORY>
<CPU>
0
</CPU>
<NET_TX>
0
</NET_TX>
<NET_RX>
0
</NET_RX>
</VM>
<VM>
<ID>
1
</ID>
<UID>
0
</UID>
<USERNAME>
jfontan
</USERNAME>
<NAME>
test
</NAME>
<LAST_POLL>
0
</LAST_POLL>
<STATE>
1
</STATE>
<LCM_STATE>
0
</LCM_STATE>
<STIME>
1278433841
</STIME>
<ETIME>
0
</ETIME>
<DEPLOY_ID/>
<MEMORY>
0
</MEMORY>
<CPU>
0
</CPU>
<NET_TX>
0
</NET_TX>
<NET_RX>
0
</NET_RX>
</VM>
</VM_POOL>"
1: "<VM_POOL>
<VM>
<ID>
2
</ID>
<UID>
1
</UID>
<USERNAME>
lero
</USERNAME>
<NAME>
test
</NAME>
<LAST_POLL>
0
</LAST_POLL>
<STATE>
1
</STATE>
<LCM_STATE>
0
</LCM_STATE>
<STIME>
1278433868
</STIME>
<ETIME>
0
</ETIME>
<DEPLOY_ID/>
<MEMORY>
0
</MEMORY>
<CPU>
0
</CPU>
<NET_TX>
0
</NET_TX>
<NET_RX>
0
</NET_RX>
</VM>
<VM>
<ID>
3
</ID>
<UID>
1
</UID>
<USERNAME>
lero
</USERNAME>
<NAME>
test
</NAME>
<LAST_POLL>
0
</LAST_POLL>
<STATE>
1
</STATE>
<LCM_STATE>
0
</LCM_STATE>
<STIME>
1278433869
</STIME>
<ETIME>
0
</ETIME>
<DEPLOY_ID/>
<MEMORY>
0
</MEMORY>
<CPU>
0
</CPU>
<NET_TX>
0
</NET_TX>
<NET_RX>
0
</NET_RX>
</VM>
</VM_POOL>"
vm.info:
0: "<VM>
<ID>
0
</ID>
<UID>
0
</UID>
<NAME>
test
</NAME>
<LAST_POLL>
0
</LAST_POLL>
<STATE>
1
</STATE>
<LCM_STATE>
0
</LCM_STATE>
<STIME>
1278433840
</STIME>
<ETIME>
0
</ETIME>
<DEPLOY_ID/>
<MEMORY>
0
</MEMORY>
<CPU>
0
</CPU>
<NET_TX>
0
</NET_TX>
<NET_RX>
0
</NET_RX>
<TEMPLATE>
<CPU>
<![CDATA[0.5]]>
</CPU>
<DISK>
<READONLY>
<![CDATA[no]]>
</READONLY>
<SOURCE>
<![CDATA[/local/xen/domains/etch/disk.img]]>
</SOURCE>
<TARGET>
<![CDATA[sda]]>
</TARGET>
</DISK>
<DISK>
<READONLY>
<![CDATA[no]]>
</READONLY>
<SIZE>
<![CDATA[1024]]>
</SIZE>
<TARGET>
<![CDATA[sdb]]>
</TARGET>
<TYPE>
<![CDATA[swap]]>
</TYPE>
</DISK>
<MEMORY>
<![CDATA[64]]>
</MEMORY>
<NAME>
<![CDATA[test]]>
</NAME>
<NIC>
<MAC>
<![CDATA[00:ff:72:17:20:27]]>
</MAC>
</NIC>
<OS>
<INITRD>
<![CDATA[/initrd.img]]>
</INITRD>
<KERNEL>
<![CDATA[/vmlinuz]]>
</KERNEL>
<ROOT>
<![CDATA[sda]]>
</ROOT>
</OS>
<VMID>
<![CDATA[0]]>
</VMID>
</TEMPLATE>
</VM>"
1: "<VM>
<ID>
1
</ID>
<UID>
0
</UID>
<NAME>
test
</NAME>
<LAST_POLL>
0
</LAST_POLL>
<STATE>
1
</STATE>
<LCM_STATE>
0
</LCM_STATE>
<STIME>
1278433841
</STIME>
<ETIME>
0
</ETIME>
<DEPLOY_ID/>
<MEMORY>
0
</MEMORY>
<CPU>
0
</CPU>
<NET_TX>
0
</NET_TX>
<NET_RX>
0
</NET_RX>
<TEMPLATE>
<CPU>
<![CDATA[1]]>
</CPU>
<DISK>
<READONLY>
<![CDATA[no]]>
</READONLY>
<SOURCE>
<![CDATA[/local/xen/domains/etch/disk.img]]>
</SOURCE>
<TARGET>
<![CDATA[sda]]>
</TARGET>
</DISK>
<DISK>
<READONLY>
<![CDATA[no]]>
</READONLY>
<SIZE>
<![CDATA[1024]]>
</SIZE>
<TARGET>
<![CDATA[sdb]]>
</TARGET>
<TYPE>
<![CDATA[swap]]>
</TYPE>
</DISK>
<MEMORY>
<![CDATA[256]]>
</MEMORY>
<NAME>
<![CDATA[test]]>
</NAME>
<NIC>
<MAC>
<![CDATA[00:ff:72:17:20:27]]>
</MAC>
</NIC>
<OS>
<INITRD>
<![CDATA[/initrd.img]]>
</INITRD>
<KERNEL>
<![CDATA[/vmlinuz]]>
</KERNEL>
<ROOT>
<![CDATA[sda]]>
</ROOT>
</OS>
<VMID>
<![CDATA[1]]>
</VMID>
</TEMPLATE>
</VM>"
2: "<VM>
<ID>
2
</ID>
<UID>
1
</UID>
<NAME>
test
</NAME>
<LAST_POLL>
0
</LAST_POLL>
<STATE>
1
</STATE>
<LCM_STATE>
0
</LCM_STATE>
<STIME>
1278433868
</STIME>
<ETIME>
0
</ETIME>
<DEPLOY_ID/>
<MEMORY>
0
</MEMORY>
<CPU>
0
</CPU>
<NET_TX>
0
</NET_TX>
<NET_RX>
0
</NET_RX>
<TEMPLATE>
<CPU>
<![CDATA[1.5]]>
</CPU>
<DISK>
<READONLY>
<![CDATA[no]]>
</READONLY>
<SOURCE>
<![CDATA[/local/xen/domains/etch/disk.img]]>
</SOURCE>
<TARGET>
<![CDATA[sda]]>
</TARGET>
</DISK>
<DISK>
<READONLY>
<![CDATA[no]]>
</READONLY>
<SIZE>
<![CDATA[1024]]>
</SIZE>
<TARGET>
<![CDATA[sdb]]>
</TARGET>
<TYPE>
<![CDATA[swap]]>
</TYPE>
</DISK>
<MEMORY>
<![CDATA[512]]>
</MEMORY>
<NAME>
<![CDATA[test]]>
</NAME>
<NIC>
<MAC>
<![CDATA[00:ff:72:17:20:27]]>
</MAC>
</NIC>
<OS>
<INITRD>
<![CDATA[/initrd.img]]>
</INITRD>
<KERNEL>
<![CDATA[/vmlinuz]]>
</KERNEL>
<ROOT>
<![CDATA[sda]]>
</ROOT>
</OS>
<VMID>
<![CDATA[2]]>
</VMID>
</TEMPLATE>
</VM>"
3: "<VM>
<ID>
3
</ID>
<UID>
1
</UID>
<NAME>
test
</NAME>
<LAST_POLL>
0
</LAST_POLL>
<STATE>
1
</STATE>
<LCM_STATE>
0
</LCM_STATE>
<STIME>
1278433869
</STIME>
<ETIME>
0
</ETIME>
<DEPLOY_ID/>
<MEMORY>
0
</MEMORY>
<CPU>
0
</CPU>
<NET_TX>
0
</NET_TX>
<NET_RX>
0
</NET_RX>
<TEMPLATE>
<CPU>
<![CDATA[2]]>
</CPU>
<DISK>
<READONLY>
<![CDATA[no]]>
</READONLY>
<SOURCE>
<![CDATA[/local/xen/domains/etch/disk.img]]>
</SOURCE>
<TARGET>
<![CDATA[sda]]>
</TARGET>
</DISK>
<DISK>
<READONLY>
<![CDATA[no]]>
</READONLY>
<SIZE>
<![CDATA[1024]]>
</SIZE>
<TARGET>
<![CDATA[sdb]]>
</TARGET>
<TYPE>
<![CDATA[swap]]>
</TYPE>
</DISK>
<MEMORY>
<![CDATA[1024]]>
</MEMORY>
<NAME>
<![CDATA[test]]>
</NAME>
<NIC>
<MAC>
<![CDATA[00:ff:72:17:20:27]]>
</MAC>
</NIC>
<OS>
<INITRD>
<![CDATA[/initrd.img]]>
</INITRD>
<KERNEL>
<![CDATA[/vmlinuz]]>
</KERNEL>
<ROOT>
<![CDATA[sda]]>
</ROOT>
</OS>
<VMID>
<![CDATA[3]]>
</VMID>
</TEMPLATE>
</VM>"
+75
View File
@@ -0,0 +1,75 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may #
# not use this file except in compliance with the License. You may obtain #
# a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
#--------------------------------------------------------------------------- #
require 'spec_common'
require 'client_mock'
require 'one_usage'
describe "OneUsage" do
before(:all) do
mock_data=YAML::load(File.read('spec/oca_vms.yaml'))
client=ClientMock.new(mock_data)
@one_usage=OneUsage.new(client)
end
it "should get information about vm users" do
@one_usage.update_user(0)
vms=@one_usage.vms(0)
vms.size.should == 2
vms[0].cpu.should == 0.5
vms[0].memory.should == 64
vms[1].cpu.should == 1.0
vms[1].memory.should == 256
usage=@one_usage.total(0)
usage.cpu.should == 1.5
usage.memory.should == 64+256
@one_usage.update_user(1)
vms=@one_usage.vms(1)
vms.size.should == 2
vms[2].cpu.should == 1.5
vms[2].memory.should == 512
vms[3].cpu.should == 2.0
vms[3].memory.should == 1024
usage=@one_usage.total(1)
usage.cpu.should == 3.5
usage.memory.should == 512+1024
end
it "should update information" do
vms=@one_usage.vms(1)
vms[4]=VmUsage.new(4.0, 2048)
usage=@one_usage.total(1)
usage.cpu.should == 1.5 + 2.0 + 4.0
usage.memory.should == 512+1024+2048
vms.delete(3)
usage=@one_usage.total(1)
usage.cpu.should == 1.5 + 4.0
usage.memory.should == 512+2048
@one_usage.update_user(1)
usage=@one_usage.total(1)
usage.cpu.should == 1.5 + 2.0
usage.memory.should == 512+1024
end
end
+95
View File
@@ -0,0 +1,95 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may #
# not use this file except in compliance with the License. You may obtain #
# a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
#--------------------------------------------------------------------------- #
require 'spec_common'
require 'client_mock'
require 'quota'
def check_quota(uid, cpu, memory, num_vms)
quota=@quota.get(uid)
quota.should_not == nil
quota[:cpu].should == cpu
quota[:memory].should == memory
quota[:num_vms].should == num_vms
end
describe 'Quota' do
before(:all) do
@db=Sequel.sqlite
mock_data=YAML::load(File.read('spec/oca_vms.yaml'))
client=ClientMock.new(mock_data)
@quota=Quota.new(@db, client)
end
it 'should create table' do
@db.table_exists?(:quotas).should == true
schema=@db.schema(:quotas)
check_column(schema, :uid)
check_column(schema, :cpu)
check_column(schema, :memory)
check_column(schema, :num_vms)
end
it 'should let add and retrieve quotas' do
@quota.set(0, 10.0, 1024, 10)
@quota.set(1, 20.0, 2048, 20)
@quota.set(2, 40.0, 4096, 40)
check_quota(0, 10.0, 1024, 10)
check_quota(1, 20.0, 2048, 20)
check_quota(2, 40.0, 4096, 40)
@quota.get(3).should == @quota.defaults
end
it 'should check for quotas' do
@quota.update(0)
@quota.update(1)
@quota.check(0).should == true
@quota.check(1).should == true
vms=@quota.get_user(0)
vms[5]=VmUsage.new(40.0, 8192)
vms=@quota.get_user(1)
vms[6]=VmUsage.new(40.0, 8192)
@quota.check(0).should == false
@quota.check(1).should == false
@quota.update(0)
@quota.update(1)
@quota.check(0).should == true
@quota.check(1).should == true
end
it 'should let update limits' do
@quota.set(0, nil, nil, nil)
check_quota(0, nil, nil, nil)
end
it 'should understand unlimited quotas' do
vms=@quota.get_user(0)
vms[7]=VmUsage.new(9999999999.0, 99999999999)
@quota.check(0).should == true
@quota.check(0, VmUsage.new(999999999.0, 99999999)).should == true
end
end
@@ -0,0 +1,91 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may #
# not use this file except in compliance with the License. You may obtain #
# a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
#--------------------------------------------------------------------------- #
require 'spec_common'
require 'client_mock'
require 'simple_permissions'
def gen_tokens(user_, action_, options={})
user=user_.to_s
action=action_.to_s.upcase
options={
:vm => true,
:host => true
}.merge!(options)
pub=(options[:public] ? '1' : '0')
id=(options[:id] ? options[:id].to_s : '1')
#owner=(options[:owner] ? options[:owner].to_s : '1')
if action=='CREATE'
vmowner='-'
vmid='-'
else
vmowner=user
vmid=user
end
tokens=[]
tokens<<"VM:#{vmid}:#{action}:#{vmowner}:#{pub}" if options[:vm]
tokens+=[
"NET:#{id}:#{action}:#{user}:#{pub}",
"IMAGE:#{id}:#{action}:#{user}:#{pub}"
]
tokens<<"HOST:#{id}:#{action}:#{user}:#{pub}" if options[:host]
#pp tokens
tokens
end
describe SimplePermissions do
before(:all) do
@db=Sequel.sqlite
mock_data=YAML::load(File.read('spec/oca_vms.yaml'))
client=ClientMock.new(mock_data)
@perm=SimplePermissions.new(@db, client)
end
it 'should let root manage everything' do
@perm.auth(0, gen_tokens(1, :create)).should == true
@perm.auth(0, gen_tokens(1, :delete)).should == true
@perm.auth(0, gen_tokens(1, :manage)).should == true
@perm.auth(0, gen_tokens(1, :use)).should == true
end
it 'should let anyone use public objects' do
@perm.auth(2, gen_tokens(1, :delete, :public => true)).
should_not == true
@perm.auth(2, gen_tokens(1, :manage, :public => true)).
should_not == true
# take out vm create (the first token) as it can not be "used" by
# other users even if public
@perm.auth(2, gen_tokens(1, :use, :public => true, :vm => false)).
should == true
end
it 'should let users use their own objects' do
@perm.auth(1, gen_tokens(1, :create, :host => false)).should == true
@perm.auth(1, gen_tokens(1, :delete, :host => false)).should == true
@perm.auth(1, gen_tokens(1, :manage, :host => false)).should == true
@perm.auth(1, gen_tokens(1, :use)).should == true
end
end
+26
View File
@@ -0,0 +1,26 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may #
# not use this file except in compliance with the License. You may obtain #
# a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
#--------------------------------------------------------------------------- #
require 'pp'
require 'db_helpers'
$: << '../oca/ruby'
$: << './spec'
-12
View File
@@ -18,18 +18,6 @@
#include "NebulaLog.h"
#include "Nebula.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
int DispatchManager::allocate (
int uid,
const string& stemplate,
int * oid)
{
NebulaLog::log("DiM",Log::DEBUG,"Allocating a new VM");
return vmpool->allocate(uid,stemplate,oid);
};
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
+16 -16
View File
@@ -34,28 +34,28 @@ extern "C" void * hm_action_loop(void *arg)
NebulaLog::log("HKM",Log::INFO,"Hook Manager started.");
hm = static_cast<HookManager *>(arg);
hm->am.loop(0,0);
NebulaLog::log("HKM",Log::INFO,"Hook Manager stopped.");
return 0;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void HookManager::load_mads(int uid)
void HookManager::load_mads(int uid)
{
HookManagerDriver * hm_mad;
ostringstream oss;
const VectorAttribute * vattr;
int rc;
NebulaLog::log("HKM",Log::INFO,"Loading Hook Manager driver.");
vattr = static_cast<const VectorAttribute *>(mad_conf[0]);
if ( vattr == 0 )
{
NebulaLog::log("HKM",Log::INFO,"Failed to load Hook Manager driver.");
@@ -63,18 +63,18 @@ void HookManager::load_mads(int uid)
}
VectorAttribute hook_conf("HOOK_MAD",vattr->value());
hook_conf.replace("NAME",hook_driver_name);
hm_mad = new HookManagerDriver(0,hook_conf.value(),false,vmpool);
rc = add(hm_mad);
if ( rc == 0 )
{
oss.str("");
oss.str("");
oss << "\tHook Manager loaded";
NebulaLog::log("HKM",Log::INFO,oss);
}
}
@@ -95,7 +95,7 @@ int HookManager::start()
}
NebulaLog::log("HKM",Log::INFO,"Starting Hook Manager...");
pthread_attr_init (&pattr);
pthread_attr_setdetachstate (&pattr, PTHREAD_CREATE_JOINABLE);
@@ -112,14 +112,14 @@ void HookManager::do_action(const string &action, void * arg)
if (action == ACTION_FINALIZE)
{
NebulaLog::log("HKM",Log::INFO,"Stopping Hook Manager...");
MadManager::stop();
MadManager::stop();
}
else
{
ostringstream oss;
oss << "Unknown action name: " << action;
NebulaLog::log("HKM", Log::ERROR, oss);
}
}
+15 -3
View File
@@ -15,6 +15,7 @@
/* -------------------------------------------------------------------------- */
#include "ClusterPool.h"
#include "NebulaLog.h"
const char * ClusterPool::table = "cluster_pool";
@@ -31,10 +32,11 @@ const string ClusterPool::DEFAULT_CLUSTER_NAME = "default";
int ClusterPool::allocate(int * clid, string name, SqlDB *db)
{
int rc;
int rc;
map<int, string>::iterator it;
ostringstream oss;
// Return error if name already exists
for(it=cluster_names.begin();it!=cluster_names.end();it++)
{
@@ -56,10 +58,20 @@ int ClusterPool::allocate(int * clid, string name, SqlDB *db)
return *clid;
// TODO: LOG ERRORS
error_existing_name:
oss << "Could not allocate new cluster: Name \""
<< name << "\" already exists.";
goto error_common;
error_db:
oss << "Could not allocate new cluster \"" << name
<< "\": Database returned error code " << rc << ".";
goto error_common;
error_common:
NebulaLog::log("CLUSTER", Log::ERROR, oss);
*clid = -1;
return *clid;
}
+2 -1
View File
@@ -336,7 +336,8 @@ public:
}
// Discover the enabled hosts
rc = hp->discover(&dh, 100);
rc = hp->discover(&dh,100);
CPPUNIT_ASSERT(rc == 0);
CPPUNIT_ASSERT(dh.size() == 8);
+41 -23
View File
@@ -25,12 +25,14 @@
#include "Image.h"
#include "ImagePool.h"
#include "AuthManager.h"
#include "UserPool.h"
/* ************************************************************************ */
/* Image :: Constructor/Destructor */
/* ************************************************************************ */
Image::Image(int _uid):
Image::Image(int _uid, ImageTemplate * _image_template):
PoolObjectSQL(-1),
uid(_uid),
name(""),
@@ -39,9 +41,24 @@ Image::Image(int _uid):
source(""),
state(INIT),
running_vms(0)
{};
{
if (_image_template != 0)
{
image_template = _image_template;
}
else
{
image_template = new ImageTemplate;
}
};
Image::~Image(){};
Image::~Image()
{
if (image_template != 0)
{
delete image_template;
}
};
/* ************************************************************************ */
/* Image :: Database Access Functions */
@@ -91,7 +108,7 @@ int Image::select_cb(void * nil, int num, char **values, char ** names)
running_vms = atoi(values[RUNNING_VMS]);
image_template.id = oid;
image_template->id = oid;
return 0;
}
@@ -121,7 +138,7 @@ int Image::select(SqlDB *db)
// Get the template
rc = image_template.select(db);
rc = image_template->select(db);
if ( rc != 0 )
{
@@ -180,7 +197,7 @@ int Image::insert(SqlDB *db)
// ------------ PUBLIC --------------------
get_template_attribute("PUBLIC", public_attr);
image_template.erase("PUBLIC");
image_template->erase("PUBLIC");
transform (public_attr.begin(), public_attr.end(), public_attr.begin(),
(int(*)(int))toupper);
@@ -196,7 +213,7 @@ int Image::insert(SqlDB *db)
SingleAttribute * dev_att = new SingleAttribute("DEV_PREFIX",
ImagePool::default_dev_prefix());
image_template.set(dev_att);
image_template->set(dev_att);
}
// ------------ SOURCE (path to store the image)--------------------
@@ -208,29 +225,31 @@ int Image::insert(SqlDB *db)
source = tmp_sourcestream.str();
// ------------ INSERT THE TEMPLATE --------------------
// Set up the template ID, to insert it
if ( image_template.id == -1 )
if ( image_template->id == -1 )
{
image_template.id = oid;
image_template->id = oid;
}
state = DISABLED;
// Insert the Template
rc = image_template.insert(db);
rc = image_template->insert(db);
if ( rc != 0 )
{
return rc;
}
//Insert the Image
//--------------------------------------------------------------------------
// Insert the Image
//--------------------------------------------------------------------------
rc = insert_replace(db, false);
if ( rc != 0 )
{
image_template.drop(db);
image_template->drop(db);
return rc;
}
@@ -240,9 +259,11 @@ int Image::insert(SqlDB *db)
error_name:
NebulaLog::log("IMG", Log::ERROR, "NAME not present in image template");
goto error_common;
error_type:
NebulaLog::log("IMG", Log::ERROR, "Incorrect TYPE in image template");
goto error_common;
error_common:
return -1;
}
@@ -368,7 +389,7 @@ int Image::drop(SqlDB * db)
return -1;
}
image_template.drop(db);
image_template->drop(db);
oss << "DELETE FROM " << table << " WHERE oid=" << oid;
@@ -418,7 +439,7 @@ string& Image::to_xml(string& xml) const
"<SOURCE>" << source << "</SOURCE>" <<
"<STATE>" << state << "</STATE>" <<
"<RUNNING_VMS>" << running_vms << "</RUNNING_VMS>" <<
image_template.to_xml(template_xml) <<
image_template->to_xml(template_xml) <<
"</IMAGE>";
xml = oss.str();
@@ -446,7 +467,7 @@ string& Image::to_str(string& str) const
"STATE = " << state << endl <<
"RUNNING_VMS = " << running_vms << endl <<
"TEMPLATE" << endl
<< image_template.to_str(template_str)
<< image_template->to_str(template_str)
<< endl;
str = os.str();
@@ -529,12 +550,10 @@ int Image::disk_attribute(VectorAttribute * disk, int * index)
{
string overwrite;
string saveas;
string name;
string bus;
ostringstream iid;
name = disk->vector_value("NAME");
overwrite = disk->vector_value("OVERWRITE");
saveas = disk->vector_value("SAVE_AS");
bus = disk->vector_value("BUS");
@@ -564,10 +583,9 @@ int Image::disk_attribute(VectorAttribute * disk, int * index)
map<string,string> new_disk;
new_disk.insert(make_pair("NAME",name));
new_disk.insert(make_pair("IID", iid.str()));
new_disk.insert(make_pair("SOURCE", source));
new_disk.insert(make_pair("IMAGE", name));
new_disk.insert(make_pair("IMAGE_ID", iid.str()));
new_disk.insert(make_pair("SOURCE", source));
if (!overwrite.empty())
{
+100 -30
View File
@@ -19,6 +19,7 @@
/* ************************************************************************** */
#include "ImagePool.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -88,55 +89,31 @@ ImagePool::ImagePool( SqlDB * db,
int ImagePool::allocate (
int uid,
const string& stemplate,
ImageTemplate* img_template,
int * oid)
{
int rc;
Image * img;
string name;
char * error_msg;
// ---------------------------------------------------------------------
// Build a new Image object
// ---------------------------------------------------------------------
img = new Image(uid);
// ---------------------------------------------------------------------
// Parse template
// ---------------------------------------------------------------------
rc = img->image_template.parse(stemplate, &error_msg);
if ( rc != 0 )
{
ostringstream oss;
oss << "ImagePool template parse error: " << error_msg;
NebulaLog::log("IMG", Log::ERROR, oss);
free(error_msg);
delete img;
return -1;
}
img = new Image(uid,img_template);
img->get_template_attribute("NAME", name);
// ---------------------------------------------------------------------
// Insert the Object in the pool
// ---------------------------------------------------------------------
*oid = PoolSQL::allocate(img);
if ( *oid == -1 )
{
return -1;
}
// ---------------------------------------------------------------------
// Add the image name to the map of image_names
// ---------------------------------------------------------------------
image_names.insert(make_pair(name, *oid));
if ( *oid != -1 )
{
image_names.insert(make_pair(name, *oid));
}
return *oid;
}
@@ -187,3 +164,96 @@ int ImagePool::dump(ostringstream& oss, const string& where)
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
int ImagePool::disk_attribute(VectorAttribute * disk, int * index)
{
string source;
Image * img = 0;
source = disk->vector_value("IMAGE");
if (source.empty())
{
istringstream is;
int image_id;
source = disk->vector_value("IMAGE_ID");
if (source.empty())
{
return -2;
}
is.str(source);
is >> image_id;
if( !is.fail() )
{
img = get(image_id,true);
}
}
else
{
img = get(source,true);
}
if (img == 0)
{
return -1;
}
int rc = img->disk_attribute(disk,index);
img->unlock();
return rc;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void ImagePool::authorize_disk(VectorAttribute * disk, AuthRequest * ar)
{
string source;
Image * img = 0;
source = disk->vector_value("IMAGE");
if (source.empty())
{
istringstream is;
int image_id;
source = disk->vector_value("IMAGE_ID");
if (source.empty())
{
return;
}
is.str(source);
is >> image_id;
if( !is.fail() )
{
img = get(image_id,true);
}
}
else
{
img = get(source,true);
}
if (img == 0)
{
return;
}
ar->add_auth(AuthRequest::IMAGE,
img->get_iid(),
AuthRequest::USE,
img->get_uid(),
img->isPublic());
img->unlock();
}
+117 -7
View File
@@ -65,6 +65,40 @@ const string xml_dump_where =
const string replacement = "0000000000";
class ImagePoolFriend : public ImagePool
{
public:
ImagePoolFriend(SqlDB * db,
const string& _source_prefix,
const string& _default_type,
const string& _default_dev_prefix):
ImagePool( db,
_source_prefix,
_default_type,
_default_dev_prefix){};
int allocate(const int& uid, const std::string& stemplate, int* oid)
{
ImageTemplate * img_template;
char * error_msg = 0;
int rc;
img_template = new ImageTemplate;
rc = img_template->parse(stemplate,&error_msg);
if( rc == 0 )
{
return ImagePool::allocate(uid, img_template, oid);
}
else
{
return -2;
}
};
};
/* ************************************************************************* */
/* ************************************************************************* */
@@ -86,6 +120,7 @@ class ImagePoolTest : public PoolTest
CPPUNIT_TEST ( bus_source_assignment );
CPPUNIT_TEST ( public_attribute );
CPPUNIT_TEST ( disk_overwrite );
CPPUNIT_TEST ( imagepool_disk_attribute );
CPPUNIT_TEST ( dump );
CPPUNIT_TEST ( dump_where );
@@ -100,13 +135,15 @@ protected:
PoolSQL* create_pool(SqlDB* db)
{
return new ImagePool(db, "source_prefix", "OS", "hd");
ImagePoolFriend * imp =
new ImagePoolFriend(db, "source_prefix", "OS", "hd");
return imp;
};
int allocate(int index)
{
int oid;
return ((ImagePool*)pool)->allocate(uids[index],
return ((ImagePoolFriend*)pool)->allocate(uids[index],
templates[index],
&oid);
@@ -320,7 +357,7 @@ public:
void duplicates()
{
int rc, oid;
ImagePool * imp = static_cast<ImagePool *>(pool);
ImagePoolFriend * imp = static_cast<ImagePoolFriend *>(pool);
// Allocate an image.
rc = imp->allocate(uids[0], templates[0], &oid);
@@ -371,7 +408,7 @@ public:
void wrong_templates()
{
int rc;
ImagePool * imp = static_cast<ImagePool *>(pool);
ImagePoolFriend * imp = static_cast<ImagePoolFriend *>(pool);
string templates[] =
{
@@ -410,7 +447,7 @@ public:
void target_generation()
{
ImagePool * imp = static_cast<ImagePool *>(pool);
ImagePoolFriend * imp = static_cast<ImagePoolFriend *>(pool);
Image * img;
VectorAttribute * disk;
@@ -682,13 +719,85 @@ public:
delete disk;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void imagepool_disk_attribute()
{
ImagePoolFriend * imp = static_cast<ImagePoolFriend *>(pool);
Image * img;
VectorAttribute * disk;
int oid_0, oid_1;
string value;
// ---------------------------------------------------------------------
// Allocate 2 images, with different dev_prefix
string template_0 = "NAME = \"Image 0\"\n"
"DEV_PREFIX = \"hd\"\n";
string template_1 = "NAME = \"Image 1\"\n"
"DEV_PREFIX = \"sd\"\n";
imp->allocate(0, template_0, &oid_0);
CPPUNIT_ASSERT( oid_0 == 0 );
imp->allocate(0, template_1, &oid_1);
CPPUNIT_ASSERT( oid_1 == 1 );
img = imp->get(oid_0, false);
CPPUNIT_ASSERT( img != 0 );
img->enable(true);
img = imp->get(oid_1, false);
CPPUNIT_ASSERT( img != 0 );
img->enable(true);
// Disk using image 0
disk = new VectorAttribute("DISK");
disk->replace("IMAGE", "Image 0");
((ImagePool*)imp)->disk_attribute(disk, 0);
value = "";
value = disk->vector_value("TARGET");
CPPUNIT_ASSERT( value == "hda" );
value = "";
value = disk->vector_value("IMAGE_ID");
CPPUNIT_ASSERT( value == "0" );
delete disk;
// Disk using image 1 index
disk = new VectorAttribute("DISK");
disk->replace("IMAGE_ID", "1");
((ImagePool*)imp)->disk_attribute(disk, 0);
value = "";
value = disk->vector_value("TARGET");
CPPUNIT_ASSERT( value == "sda" );
value = "";
value = disk->vector_value("IMAGE");
CPPUNIT_ASSERT( value == "Image 1" );
delete disk;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void public_attribute()
{
int oid;
ImagePool * imp = static_cast<ImagePool *>(pool);
ImagePoolFriend * imp = static_cast<ImagePoolFriend *>(pool);
Image * img;
string templates[] =
@@ -754,7 +863,8 @@ public:
img = imp->get( oid, false );
CPPUNIT_ASSERT( img != 0 );
//cout << endl << i << " : exp. " << results[i] << " got " << img->is_public();
CPPUNIT_ASSERT( img->is_public() == results[i] );
CPPUNIT_ASSERT( img->isPublic() == results[i] );
i++;
}
+3 -1
View File
@@ -51,6 +51,7 @@ main_env.Append(LIBPATH=[
cwd + '/src/mad',
cwd + '/src/vnm',
cwd + '/src/um',
cwd + '/src/authm',
cwd + '/src/image',
'/usr/include/openssl/',
])
@@ -59,11 +60,12 @@ main_env.Append(LIBS=[
'nebula_image',
'nebula_um',
'nebula_vm',
'nebula_mad',
'nebula_hm',
'nebula_vnm',
'nebula_authm',
'nebula_template',
'nebula_pool',
'nebula_mad',
'nebula_common',
'nebula_log',
'nebula_core',
+42 -5
View File
@@ -233,19 +233,19 @@ void Nebula::start()
vnpool = new VirtualNetworkPool(db,mac_prefix,size);
upool = new UserPool(db);
nebula_configuration->get("IMAGE_REPOSITORY_PATH", repository_path);
if (repository_path.empty()) // Defaults to ONE_LOCATION/var
{
repository_path = var_location;
}
nebula_configuration->get("DEFAULT_IMAGE_TYPE", default_image_type);
nebula_configuration->get("DEFAULT_DEVICE_PREFIX",
default_device_prefix);
ipool = new ImagePool(db,
ipool = new ImagePool(db,
repository_path,
default_image_type,
default_device_prefix);
@@ -447,6 +447,38 @@ void Nebula::start()
throw runtime_error("Could not start the Hook Manager");
}
// ---- Auth Manager ----
try
{
vector<const Attribute *> auth_mads;
nebula_configuration->get("AUTH_MAD", auth_mads);
if (!auth_mads.empty())
{
//Defaults 60s to timeout auth requests
authm = new AuthManager(timer_period,60,auth_mads);
}
else
{
authm = 0; //Built-in authm/authz
}
}
catch (bad_alloc&)
{
throw;
}
if (authm != 0)
{
rc = authm->start();
if ( rc != 0 )
{
throw runtime_error("Could not start the Auth Manager");
}
}
// -----------------------------------------------------------
// Load mads
// -----------------------------------------------------------
@@ -459,6 +491,11 @@ void Nebula::start()
tm->load_mads(0);
hm->load_mads(0);
if ( authm != 0 )
{
authm->load_mads(0);
}
// -----------------------------------------------------------
// Wait for a SIGTERM or SIGINT signal
// -----------------------------------------------------------
+1
View File
@@ -40,6 +40,7 @@ env.Append(LIBS=[
'nebula_dm',
'nebula_tm',
'nebula_um',
'nebula_authm',
'nebula_mad',
'nebula_template',
'nebula_image',
+1 -5
View File
@@ -214,7 +214,7 @@ void RequestManager::do_action(
void RequestManager::register_xml_methods()
{
xmlrpc_c::methodPtr vm_allocate(new
RequestManager::VirtualMachineAllocate(upool));
RequestManager::VirtualMachineAllocate(vmpool, vnpool, ipool, upool));
xmlrpc_c::methodPtr vm_deploy(new
RequestManager::VirtualMachineDeploy(vmpool,hpool,upool));
@@ -282,9 +282,6 @@ void RequestManager::register_xml_methods()
xmlrpc_c::methodPtr user_allocate(new
RequestManager::UserAllocate(upool));
xmlrpc_c::methodPtr user_info(new
RequestManager::UserInfo(upool));
xmlrpc_c::methodPtr user_delete(new
RequestManager::UserDelete(upool));
@@ -357,7 +354,6 @@ void RequestManager::register_xml_methods()
/* User related methods*/
RequestManagerRegistry.addMethod("one.user.allocate", user_allocate);
RequestManagerRegistry.addMethod("one.user.info", user_info);
RequestManagerRegistry.addMethod("one.user.delete", user_delete);
RequestManagerRegistry.addMethod("one.userpool.info", userpool_info);
+33 -16
View File
@@ -42,6 +42,8 @@ void RequestManager::VirtualMachineAction::execute(
VirtualMachine * vm;
ostringstream oss;
const string method_name = "VirtualMachineAction";
NebulaLog::log("ReM",Log::DEBUG,"VirtualMachineAction invoked");
@@ -49,7 +51,6 @@ void RequestManager::VirtualMachineAction::execute(
action = xmlrpc_c::value_string(paramList.getString(1));
vid = xmlrpc_c::value_int(paramList.getInt(2));
// Get the VM
vm = VirtualMachineAction::vmpool->get(vid,true);
@@ -58,21 +59,34 @@ void RequestManager::VirtualMachineAction::execute(
goto error_vm_get;
}
uid = vm->get_uid();
uid = vm->get_uid();
vm->unlock();
// Only oneadmin or the VM owner can perform operations upon the VM
//Authenticate the user
rc = VirtualMachineAction::upool->authenticate(session);
if ( rc != 0 && rc != uid)
{
goto error_authenticate;
if (rc == -1)
{
goto error_authenticate;
}
//Authorize the operation
if ( rc != 0 ) // rc == 0 means oneadmin
{
AuthRequest ar(rc);
ar.add_auth(AuthRequest::VM,vid,AuthRequest::MANAGE,uid,false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
if (action == "shutdown")
{
rc = dm->shutdown(vid);
rc = dm->shutdown(vid);
}
else if (action == "hold")
{
@@ -108,13 +122,12 @@ void RequestManager::VirtualMachineAction::execute(
}
else
{
rc = -3;
rc = -3;
}
if (rc != 0)
{
goto error_operation;
}
arrayData.push_back(xmlrpc_c::value_boolean(true));
@@ -139,24 +152,28 @@ error_operation:
goto error_common;
error_vm_get:
oss << "The virtual machine " << vid << " does not exists";
oss.str(get_error(method_name, "VM", vid));
goto error_common;
error_authenticate:
oss << "User not authorized to perform operation upon VirtualMachine [" << vid << "]";
oss.str(authenticate_error(method_name));
goto error_common;
error_authorize:
oss.str(authorization_error(method_name, "MANAGE", "VM", rc, vid));
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false));
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
xmlrpc_c::value_array arrayresult_error(arrayData);
NebulaLog::log("ReM",Log::ERROR,oss);
*retval = arrayresult_error;
return;
}
/* -------------------------------------------------------------------------- */
+89 -37
View File
@@ -27,55 +27,103 @@ void RequestManager::VirtualMachineAllocate::execute(
xmlrpc_c::value * const retval)
{
string session;
string username;
string password;
string vm_template;
string str_template;
int vid;
int uid;
const string method_name = "VirtualMachineAllocate";
int vid, uid;
int rc;
Nebula& nd = Nebula::instance();
DispatchManager * dm = nd.get_dm();
User * user;
ostringstream oss;
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
VirtualMachineTemplate * vm_template;
char * error_msg = 0;
int num;
vector<Attribute * > vectors;
VectorAttribute * vector;
NebulaLog::log("ReM",Log::DEBUG,"VirtualMachineAllocate invoked");
session = xmlrpc_c::value_string(paramList.getString(0));
vm_template = xmlrpc_c::value_string(paramList.getString(1));
vm_template += "\n";
session = xmlrpc_c::value_string(paramList.getString(0));
str_template = xmlrpc_c::value_string(paramList.getString(1));
str_template += "\n";
//--------------------------------------------------------------------------
// Authenticate the user
//--------------------------------------------------------------------------
uid = VirtualMachineAllocate::upool->authenticate(session);
// First, we need to authenticate the user
rc = VirtualMachineAllocate::upool->authenticate(session);
if ( rc == -1 )
if (uid == -1)
{
goto error_authenticate;
}
User::split_secret(session,username,password);
//--------------------------------------------------------------------------
// Authorize this request
//--------------------------------------------------------------------------
vm_template = new VirtualMachineTemplate;
// Now let's get the user
user = VirtualMachineAllocate::upool->get(username,true);
rc = vm_template->parse(str_template,&error_msg);
if ( user == 0 )
if ( rc != 0 )
{
goto error_get_user;
goto error_parse;
}
uid = user->get_uid();
if ( uid != 0 )
{
AuthRequest ar(uid);
string t64;
user->unlock();
num = vm_template->get("DISK",vectors);
rc = dm->allocate(uid,vm_template,&vid);
for(int i=0; i<num; i++)
{
vector = dynamic_cast<VectorAttribute * >(vectors[i]);
if ( vector == 0 )
{
continue;
}
VirtualMachineAllocate::ipool->authorize_disk(vector,&ar);
}
num = vm_template->get("NIC",vectors);
for(int i=0; i<num; i++)
{
vector = dynamic_cast<VectorAttribute * >(vectors[i]);
if ( vector == 0 )
{
continue;
}
VirtualMachineAllocate::vnpool->authorize_nic(vector,&ar);
}
ar.add_auth(AuthRequest::VM,
vm_template->to_xml(t64),
AuthRequest::CREATE,
uid,
false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
//--------------------------------------------------------------------------
// Allocate the VirtualMAchine
//--------------------------------------------------------------------------
rc = VirtualMachineAllocate::vmpool->allocate(uid,vm_template,&vid,false);
if ( rc < 0 )
{
@@ -92,26 +140,30 @@ void RequestManager::VirtualMachineAllocate::execute(
delete arrayresult; // and get rid of the original
return;
error_authenticate:
oss << "User not authenticated, aborting RequestManagerAllocate call.";
oss.str(authenticate_error(method_name));
goto error_common;
error_get_user:
oss << "User not recognized, cannot allocate VirtualMachine";
error_authorize:
oss.str(authorization_error(method_name, "CREATE", "VM", uid, -1));
delete vm_template;
goto error_common;
error_parse:
oss << action_error(method_name, "PARSE", "VM TEMPLATE",-2,rc);
if (error_msg != 0)
{
oss << ". Reason: " << error_msg;
free(error_msg);
}
delete vm_template;
goto error_common;
error_allocate:
if (rc == -1)
{
oss << "Error inserting VM in the database, check oned.log";
}
else
{
oss << "Error parsing VM template";
}
oss.str(action_error(method_name, "CREATE", "VM", -2, rc));
goto error_common;
error_common:
+46 -31
View File
@@ -23,21 +23,23 @@
void RequestManager::VirtualMachineCancel::execute(
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retval)
{
{
string session;
// <vid> of the vid to retrieve the information for
int vid;
int vid;
int uid;
const string method_name = "VirtualMachineCancel";
VirtualMachine * vm;
ostringstream oss;
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
Nebula& nd = Nebula::instance();
DispatchManager * dm = nd.get_dm();
@@ -47,62 +49,75 @@ void RequestManager::VirtualMachineCancel::execute(
session = xmlrpc_c::value_string(paramList.getString(0));
vid = xmlrpc_c::value_int (paramList.getInt(1));
// Retrieve the VM from the vmpool
// Retrieve the VM from the vmpool
vm = VirtualMachineCancel::vmpool->get(vid,true);
if ( vm == 0 )
{
goto error_vm_get;
if ( vm == 0 )
{
goto error_vm_get;
}
uid = vm->get_uid();
vm->unlock();
// Only oneadmin or the VM owner can perform operations upon the VM
//Authenticate the user
rc = VirtualMachineCancel::upool->authenticate(session);
if ( rc != 0 && rc != uid)
{
goto error_authenticate;
if ( rc == -1 )
{
goto error_authenticate;
}
//Authorize the operation
if ( rc != 0 ) // rc == 0 means oneadmin
{
AuthRequest ar(rc);
ar.add_auth(AuthRequest::VM,vid,AuthRequest::MANAGE,uid,false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
//Cancel the VM
dm->cancel(vid);
// Send results to client
arrayData.push_back(xmlrpc_c::value_boolean(true));
arrayresult = new xmlrpc_c::value_array(arrayData);
*retval = *arrayresult;
delete arrayresult;
return;
error_authenticate:
oss << "User not authorized to cancel VM";
oss.str(authenticate_error(method_name));
goto error_common;
error_authorize:
oss.str(authorization_error(method_name, "MANAGE", "VM", uid, vid));
goto error_common;
error_vm_get:
oss << "Error getting vm for cancelling with VID = " << vid;
oss.str(get_error(method_name, "VM", vid));
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
Nebula::log("ReM",Log::ERROR,oss);
Nebula::log("ReM",Log::ERROR,oss);
xmlrpc_c::value_array arrayresult_error(arrayData);
*retval = arrayresult_error;
return;
}
+27 -8
View File
@@ -17,6 +17,8 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -29,6 +31,8 @@ void RequestManager::ClusterAdd::execute(
int hid;
int clid;
int rc;
const string method_name = "ClusterAdd";
Host * host;
@@ -45,15 +49,28 @@ void RequestManager::ClusterAdd::execute(
hid = xmlrpc_c::value_int (paramList.getInt(1));
clid = xmlrpc_c::value_int (paramList.getInt(2));
// Only oneadmin can add hosts to clusters
//Authenticate the user
rc = ClusterAdd::upool->authenticate(session);
if ( rc != 0 )
if ( rc == -1 )
{
goto error_authenticate;
}
//Authorize the operation
if ( rc != 0 ) // rc == 0 means oneadmin
{
AuthRequest ar(rc);
ar.add_auth(AuthRequest::HOST,hid,AuthRequest::MANAGE,0,false);
ar.add_auth(AuthRequest::CLUSTER,clid,AuthRequest::USE,0,false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
// Check if host exists
host = ClusterAdd::hpool->get(hid,true);
@@ -87,18 +104,20 @@ void RequestManager::ClusterAdd::execute(
return;
error_authenticate:
oss << "User not authorized to add hosts to clusters";
oss.str(authenticate_error(method_name));
goto error_common;
error_authorize:
oss.str(authorization_error(method_name, "USE", "CLUSTER", rc, clid));
goto error_common;
error_host_get:
oss << "The host " << hid << " does not exists";
oss.str(get_error(method_name, "HOST", hid));
goto error_common;
error_cluster_add:
host->unlock();
oss << "Can not add host " << hid << " to cluster " << clid <<
", returned error code [" << rc << "]";
oss.str(action_error(method_name, "USE", "CLUSTER", clid, rc));
goto error_common;
error_common:
+27 -8
View File
@@ -17,6 +17,8 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -27,8 +29,9 @@ void RequestManager::ClusterAllocate::execute(
string session;
string clustername;
int id;
const string method_name = "ClusterAllocate";
int rc;
ostringstream oss;
@@ -43,14 +46,27 @@ void RequestManager::ClusterAllocate::execute(
session = xmlrpc_c::value_string(paramList.getString(0));
clustername = xmlrpc_c::value_string(paramList.getString(1));
// Only oneadmin can add new clusters
//Authenticate the user
rc = ClusterAllocate::upool->authenticate(session);
if ( rc != 0 )
if ( rc == -1 )
{
goto error_authenticate;
}
//Authorize the operation
if ( rc != 0 ) // rc == 0 means oneadmin
{
AuthRequest ar(rc);
ar.add_auth(AuthRequest::CLUSTER,-1,AuthRequest::CREATE,0,false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
// Perform the allocation in the hostpool
rc = ClusterAllocate::hpool->allocate_cluster(&id, clustername);
@@ -71,12 +87,15 @@ void RequestManager::ClusterAllocate::execute(
return;
error_authenticate:
oss << "User not authorized to add new clusters";
oss.str(authenticate_error(method_name));
goto error_common;
error_authorize:
oss.str(authorization_error(method_name, "CREATE", "CLUSTER", rc, -1));
goto error_common;
error_cluster_allocate:
oss << "Can not allocate cluster " << clustername <<
" in the ClusterPool, returned error code [" << rc << "]";
oss.str(action_error(method_name, "CREATE", "CLUSTER", -2, rc));
goto error_common;
error_common:
@@ -84,8 +103,8 @@ error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
NebulaLog::log("ReM",Log::ERROR,oss);
NebulaLog::log("ReM",Log::ERROR,oss);
xmlrpc_c::value_array arrayresult_error(arrayData);
*retval = arrayresult_error;
+26 -6
View File
@@ -17,6 +17,8 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -29,7 +31,9 @@ void RequestManager::ClusterDelete::execute(
// <clid> of the cluster to delete from the HostPool
int clid;
ostringstream oss;
int rc;
int rc;
const string method_name = "ClusterDelete";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
@@ -41,14 +45,27 @@ void RequestManager::ClusterDelete::execute(
session = xmlrpc_c::value_string(paramList.getString(0));
clid = xmlrpc_c::value_int (paramList.getInt(1));
// Only oneadmin can delete clusters
//Authenticate the user
rc = ClusterDelete::upool->authenticate(session);
if ( rc != 0 )
if ( rc == -1 )
{
goto error_authenticate;
}
//Authorize the operation
if ( rc != 0 ) // rc == 0 means oneadmin
{
AuthRequest ar(rc);
ar.add_auth(AuthRequest::CLUSTER,clid,AuthRequest::DELETE,0,false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
rc = ClusterDelete::hpool->drop_cluster(clid);
if ( rc != 0 )
@@ -68,12 +85,15 @@ void RequestManager::ClusterDelete::execute(
return;
error_authenticate:
oss << "User not authorized to delete clusters";
oss.str(authenticate_error(method_name));
goto error_common;
error_authorize:
oss.str(authorization_error(method_name, "DELETE", "CLUSTER", rc, clid));
goto error_common;
error_cluster_delete:
oss << "Can not delete cluster with CLID " << clid <<
" from the ClusterPool, returned error code [" << rc << "]";
oss.str(action_error(method_name, "DELETE", "CLUSTER", clid, rc));
goto error_common;
error_common:
+7 -3
View File
@@ -17,6 +17,8 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -29,6 +31,8 @@ void RequestManager::ClusterInfo::execute(
int clid;
int rc;
const string method_name = "ClusterInfo";
ostringstream oss;
@@ -42,7 +46,7 @@ void RequestManager::ClusterInfo::execute(
session = xmlrpc_c::value_string(paramList.getString(0));
clid = xmlrpc_c::value_int (paramList.getInt(1));
// Check if it is a valid user
//Authenticate the user
rc = ClusterInfo::upool->authenticate(session);
if ( rc == -1 )
@@ -71,11 +75,11 @@ void RequestManager::ClusterInfo::execute(
return;
error_authenticate:
oss << "User not authenticated, ClusterInfo call aborted.";
oss.str(authenticate_error(method_name));
goto error_common;
error_cluster:
oss << "Error getting cluster with CLID = " << clid;
oss.str(get_error(method_name, "CLUSTER", clid));
goto error_common;
error_common:
+10 -7
View File
@@ -17,6 +17,8 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -26,7 +28,9 @@ void RequestManager::ClusterPoolInfo::execute(
{
string session;
ostringstream oss;
int rc;
int rc;
const string method_name = "ClusterPoolInfo";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
@@ -37,8 +41,7 @@ void RequestManager::ClusterPoolInfo::execute(
// Get the parameters
session = xmlrpc_c::value_string(paramList.getString(0));
// Check if it is a valid user
//Authenticate the user
rc = ClusterPoolInfo::upool->authenticate(session);
if ( rc == -1 )
@@ -46,7 +49,7 @@ void RequestManager::ClusterPoolInfo::execute(
goto error_authenticate;
}
// Perform the allocation in the vmpool
// Perform the allocation in the vmpool
rc = ClusterPoolInfo::hpool->dump_cluster(oss);
if ( rc != 0 )
@@ -69,11 +72,11 @@ void RequestManager::ClusterPoolInfo::execute(
return;
error_authenticate:
oss << "User not authenticated, RequestManagerClusterPoolInfo aborted.";
oss.str(authenticate_error(method_name));
goto error_common;
error_dump:
oss << "Error getting Cluster pool";
oss.str(get_error(method_name, "CLUSTER", -1));
goto error_common;
error_common:
@@ -81,7 +84,7 @@ error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
NebulaLog::log("ReM",Log::ERROR,oss);
NebulaLog::log("ReM",Log::ERROR,oss);
xmlrpc_c::value_array arrayresult_error(arrayData);
+30 -14
View File
@@ -17,6 +17,8 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -24,12 +26,14 @@ void RequestManager::ClusterRemove::execute(
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retval)
{
string session;
string session;
int hid;
int rc;
const string method_name = "ClusterRemove";
int hid;
int rc;
Host * host;
Host * host;
ostringstream oss;
@@ -43,15 +47,26 @@ void RequestManager::ClusterRemove::execute(
session = xmlrpc_c::value_string(paramList.getString(0));
hid = xmlrpc_c::value_int (paramList.getInt(1));
// Only oneadmin can remove hosts from clusters
// Only oneadmin can delete clusters
rc = ClusterRemove::upool->authenticate(session);
if ( rc != 0 )
if ( rc == -1 )
{
goto error_authenticate;
}
//Authorize the operation
if ( rc != 0 ) // rc == 0 means oneadmin
{
AuthRequest ar(rc);
ar.add_auth(AuthRequest::HOST,hid,AuthRequest::MANAGE,0,false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
// Check if host exists
host = ClusterRemove::hpool->get(hid,true);
@@ -86,22 +101,23 @@ void RequestManager::ClusterRemove::execute(
return;
error_authenticate:
oss << "User not authorized to remove hosts from clusters";
oss.str(authenticate_error(method_name));
goto error_common;
error_authorize:
oss.str(authorization_error(method_name, "MANAGE", "HOST", rc, -1));
goto error_common;
error_host_get:
oss << "The host " << hid << " does not exists";
oss.str(get_error(method_name, "HOST", hid));
goto error_common;
error_cluster_remove:
host->unlock();
oss << "Can not remove host " << hid << " from its cluster, "
<< "returned error code [" << rc << "]";
oss.str(action_error(method_name, "MANAGE", "HOST", hid, rc));
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
+45 -32
View File
@@ -37,6 +37,8 @@ void RequestManager::VirtualMachineDeploy::execute(
string tm_mad;
string vmdir;
const string method_name = "VirtualMachineDeploy";
VirtualMachine * vm;
Host * host;
@@ -56,10 +58,7 @@ void RequestManager::VirtualMachineDeploy::execute(
vid = xmlrpc_c::value_int(paramList.getInt(1));
hid = xmlrpc_c::value_int(paramList.getInt(2));
//We also need the hsid
//Get host info to deploy the VM
host = VirtualMachineDeploy::hpool->get(hid,true);
if ( host == 0 )
@@ -76,7 +75,6 @@ void RequestManager::VirtualMachineDeploy::execute(
host->unlock();
//Get the VM
vm = VirtualMachineDeploy::vmpool->get(vid,true);
if ( vm == 0 )
@@ -86,21 +84,34 @@ void RequestManager::VirtualMachineDeploy::execute(
uid = vm->get_uid();
// Only oneadmin or the VM owner can perform operations upon the VM
rc = VirtualMachineDeploy::upool->authenticate(session);
if ( rc != 0 && rc != uid)
{
goto error_authenticate;
}
if ( vm->get_state() != VirtualMachine::PENDING )
{
goto error_state;
}
//Update host info and share usage (cpu,mem....)
//Authenticate the user
rc = VirtualMachineDeploy::upool->authenticate(session);
if ( rc == -1 )
{
goto error_authenticate;
}
//Authorize the operation
if ( rc != 0 ) // rc == 0 means oneadmin
{
AuthRequest ar(rc);
ar.add_auth(AuthRequest::VM,vid,AuthRequest::MANAGE,uid,false);
ar.add_auth(AuthRequest::HOST,hid,AuthRequest::USE,0,false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
//Update host info and share usage (cpu,mem....)
vm->add_history(hid,hostname,vmdir,vmm_mad,tm_mad);
rc = VirtualMachineDeploy::vmpool->update_history(vm);
@@ -113,13 +124,11 @@ void RequestManager::VirtualMachineDeploy::execute(
vmpool->update(vm); //Insert last_seq in the DB
//Deploy the VM
dm->deploy(vm);
vm->unlock();
// Send results to client
arrayData.push_back(xmlrpc_c::value_boolean(true));
arrayresult = new xmlrpc_c::value_array(arrayData);
@@ -130,36 +139,40 @@ void RequestManager::VirtualMachineDeploy::execute(
return;
error_authenticate:
vm->unlock();
oss << "User not authorized to perform the deploy";
goto error_common;
error_host_get:
oss << "The host " << hid << " does not exists";
oss.str(get_error(method_name, "HOST", hid));
goto error_common;
error_vm_get:
oss << "The virtual machine " << vid << " does not exists";
goto error_common;
error_history:
vm->unlock();
oss << "Can not deploy VM " << vid << ", can not insert history";
oss.str(get_error(method_name, "VM", vid));
goto error_common;
error_state:
vm->unlock();
oss << action_error(method_name, "MANAGE", "VM", vid, -1)
<< ". Reason: VM in wrong state.";
goto error_common_lock;
oss << "Can not deploy VM " << vid << ", wrong state";
goto error_common;
error_authenticate:
oss.str(authenticate_error(method_name));
goto error_common_lock;
error_authorize:
oss.str(authorization_error(method_name, "MANAGE", "VM", rc, vid));
goto error_common_lock;
error_history:
oss.str(action_error(method_name, "INSERT HISTORY", "VM", vid, rc));
goto error_common_lock;
error_common_lock:
vm->unlock();
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false));
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
NebulaLog::log("ReM",Log::ERROR,oss);
xmlrpc_c::value_array arrayresult_error(arrayData);
*retval = arrayresult_error;
+44 -25
View File
@@ -17,23 +17,27 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void RequestManager::HostAllocate::execute(
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retval)
{
{
string session;
string hostname;
string im_mad_name;
string vmm_mad_name;
string im_mad_name;
string vmm_mad_name;
string tm_mad_name;
const string method_name = "HostAllocate";
int hid;
int hid;
int rc;
int rc;
ostringstream oss;
/* -- RPC specific vars -- */
@@ -49,25 +53,39 @@ void RequestManager::HostAllocate::execute(
vmm_mad_name = xmlrpc_c::value_string(paramList.getString(3));
tm_mad_name = xmlrpc_c::value_string(paramList.getString(4));
// Only oneadmin can add new hosts
//Authenticate the user
rc = HostAllocate::upool->authenticate(session);
if ( rc != 0 )
{
goto error_authenticate;
if ( rc == -1 )
{
goto error_authenticate;
}
//Authorize the operation
if ( rc != 0 ) // rc == 0 means oneadmin
{
AuthRequest ar(rc);
ar.add_auth(AuthRequest::HOST,-1,AuthRequest::CREATE,0,false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
// Perform the allocation in the hostpool
rc = HostAllocate::hpool->allocate(&hid,
hostname,
im_mad_name,
im_mad_name,
vmm_mad_name,
tm_mad_name);
if ( rc == -1 )
{
goto error_host_allocate;
tm_mad_name);
if ( rc == -1 )
{
goto error_host_allocate;
}
// All nice, return the new hid to client
// All nice, return the new hid to client
arrayData.push_back(xmlrpc_c::value_boolean(true)); // SUCCESS
arrayData.push_back(xmlrpc_c::value_int(hid));
arrayresult = new xmlrpc_c::value_array(arrayData);
@@ -79,25 +97,26 @@ void RequestManager::HostAllocate::execute(
return;
error_authenticate:
oss << "User not authorized to add new hosts";
oss.str(authenticate_error(method_name));
goto error_common;
error_authorize:
oss.str(authorization_error(method_name, "CREATE", "HOST", rc, -1));
goto error_common;
error_host_allocate:
oss << "Can not allocate host " << hostname <<
" in the HostPool, returned error code [" << rc << "]";
oss.str(action_error(method_name, "CREATE", "HOST", -2, rc));
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
NebulaLog::log("ReM",Log::ERROR,oss);
NebulaLog::log("ReM",Log::ERROR,oss);
xmlrpc_c::value_array arrayresult_error(arrayData);
*retval = arrayresult_error;
return;
}
+44 -23
View File
@@ -17,20 +17,24 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void RequestManager::HostDelete::execute(
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retval)
{
{
string session;
// <hid> of the host to delete from the HostPool
int hid;
int hid;
Host * host;
ostringstream oss;
int rc;
int rc;
const string method_name = "HostDelete";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
@@ -41,31 +45,44 @@ void RequestManager::HostDelete::execute(
// Get the parameters
session = xmlrpc_c::value_string(paramList.getString(0));
hid = xmlrpc_c::value_int (paramList.getInt(1));
// Only oneadmin can delete hosts
//Authenticate the user
rc = HostDelete::upool->authenticate(session);
if ( rc != 0 )
{
goto error_authenticate;
if ( rc == -1 )
{
goto error_authenticate;
}
// Perform the allocation in the hostpool
host = HostDelete::hpool->get(hid,true);
if ( host == 0 )
{
goto error_host_get;
//Authorize the operation
if ( rc != 0 ) // rc == 0 means oneadmin
{
AuthRequest ar(rc);
ar.add_auth(AuthRequest::HOST,hid,AuthRequest::DELETE,0,false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
// Perform the allocation in the hostpool
host = HostDelete::hpool->get(hid,true);
if ( host == 0 )
{
goto error_host_get;
}
rc = HostDelete::hpool->drop(host);
host->unlock();
// All nice, return the host info to the client
// All nice, return the host info to the client
arrayData.push_back(xmlrpc_c::value_boolean( rc == 0 )); // SUCCESS
arrayresult = new xmlrpc_c::value_array(arrayData);
// Copy arrayresult into retval mem space
*retval = *arrayresult;
// and get rid of the original
@@ -74,11 +91,15 @@ void RequestManager::HostDelete::execute(
return;
error_authenticate:
oss << "User not authorized to delete hosts";
oss.str(authenticate_error(method_name));
goto error_common;
error_authorize:
oss.str(authorization_error(method_name, "DELETE", "HOST", rc, hid));
goto error_common;
error_host_get:
oss << "Error getting host with HID = " <<hid;
oss.str(get_error(method_name, "HOST", hid));
goto error_common;
error_common:
@@ -86,11 +107,11 @@ error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
xmlrpc_c::value_array arrayresult_error(arrayData);
*retval = arrayresult_error;
return;
}
+44 -24
View File
@@ -17,23 +17,27 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void RequestManager::HostEnable::execute(
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retval)
{
{
string session;
int hid;
int rc;
bool enable;
bool enable;
Host * host;
ostringstream oss;
const string method_name = "HostEnable";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
NebulaLog::log("ReM",Log::DEBUG,"HostEnable method invoked");
@@ -43,39 +47,51 @@ void RequestManager::HostEnable::execute(
hid = xmlrpc_c::value_int(paramList.getInt(1));
enable = xmlrpc_c::value_boolean(paramList.getBoolean(2));
// Only oneadmin can enable hosts
//Authenticate the user
rc = HostEnable::upool->authenticate(session);
if ( rc != 0)
{
goto error_authenticate;
if ( rc == -1 )
{
goto error_authenticate;
}
host = HostEnable::hpool->get(hid,true);
if ( host == 0 )
{
goto error_host_get;
//Authorize the operation
if ( rc != 0 ) // rc == 0 means oneadmin
{
AuthRequest ar(rc);
ar.add_auth(AuthRequest::HOST,hid,AuthRequest::MANAGE,0,false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
host = HostEnable::hpool->get(hid,true);
if ( host == 0 )
{
goto error_host_get;
}
if ( enable == true)
{
host->enable();
host->enable();
}
else
{
host->disable();
host->disable();
}
HostEnable::hpool->update(host);
host->unlock();
//Result
arrayData.push_back(xmlrpc_c::value_boolean(true));
arrayresult = new xmlrpc_c::value_array(arrayData);
*retval = *arrayresult;
delete arrayresult;
@@ -83,15 +99,19 @@ void RequestManager::HostEnable::execute(
return;
error_authenticate:
oss << "Only oneadmin can enable hosts";
oss.str(authenticate_error(method_name));
goto error_common;
error_authorize:
oss.str(authorization_error(method_name, "MANAGE", "HOST", rc, hid));
goto error_common;
error_host_get:
oss << "Error getting host with HID = " << hid;
oss.str(get_error(method_name, "HOST", hid));
goto error_common;
error_common:
NebulaLog::log("ReM",Log::ERROR,oss);
NebulaLog::log("ReM",Log::ERROR,oss);
arrayData.push_back(xmlrpc_c::value_boolean(false));
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
@@ -99,7 +119,7 @@ error_common:
xmlrpc_c::value_array arrayresult_error(arrayData);
*retval = arrayresult_error;
return;
}
+24 -23
View File
@@ -23,14 +23,16 @@
void RequestManager::HostInfo::execute(
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retval)
{
string session;
{
string session;
int hid;
int rc;
Host * host;
int hid;
int rc;
Host * host;
ostringstream oss;
const string method_name = "HostInfo";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
@@ -42,7 +44,7 @@ void RequestManager::HostInfo::execute(
session = xmlrpc_c::value_string(paramList.getString(0));
hid = xmlrpc_c::value_int (paramList.getInt(1));
// Check if it is a valid user
//Authenticate the user
rc = HostInfo::upool->authenticate(session);
if ( rc == -1 )
@@ -51,18 +53,18 @@ void RequestManager::HostInfo::execute(
}
// Get the host from the HostPool
host = HostInfo::hpool->get(hid,true);
if ( host == 0 )
{
goto error_host_get;
host = HostInfo::hpool->get(hid,true);
if ( host == 0 )
{
goto error_host_get;
}
oss << *host;
host->unlock();
// All nice, return the host info to the client
// All nice, return the host info to the client
arrayData.push_back(xmlrpc_c::value_boolean(true)); // SUCCESS
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
@@ -75,24 +77,23 @@ void RequestManager::HostInfo::execute(
return;
error_authenticate:
oss << "User not authenticated, HostInfo call aborted.";
oss.str(authenticate_error(method_name));
goto error_common;
error_host_get:
oss << "Error getting host with HID = " << hid;
oss.str(get_error(method_name, "HOST", hid));
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
NebulaLog::log("ReM",Log::ERROR,oss);
NebulaLog::log("ReM",Log::ERROR,oss);
xmlrpc_c::value_array arrayresult_error(arrayData);
*retval = arrayresult_error;
return;
}
+18 -17
View File
@@ -23,11 +23,13 @@
void RequestManager::HostPoolInfo::execute(
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retval)
{
{
string session;
ostringstream oss;
int rc;
int rc;
const string method_name = "HostPoolInfo";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
@@ -37,8 +39,7 @@ void RequestManager::HostPoolInfo::execute(
// Get the parameters
session = xmlrpc_c::value_string(paramList.getString(0));
// Check if it is a valid user
//Authenticate the user
rc = HostPoolInfo::upool->authenticate(session);
if ( rc == -1 )
@@ -46,16 +47,16 @@ void RequestManager::HostPoolInfo::execute(
goto error_authenticate;
}
// Perform the allocation in the vmpool
// Perform the allocation in the vmpool
rc = HostPoolInfo::hpool->dump(oss,"");
if ( rc != 0 )
{
{
goto error_dump;
}
//All nice, return the host info to the client
arrayData.push_back(xmlrpc_c::value_boolean(true)); // SUCCESS
//All nice, return the host info to the client
arrayData.push_back(xmlrpc_c::value_boolean(true)); // SUCCESS
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
arrayresult = new xmlrpc_c::value_array(arrayData);
@@ -69,24 +70,24 @@ void RequestManager::HostPoolInfo::execute(
return;
error_authenticate:
oss << "User not authenticated, RequestManagerHostPoolInfo aborted.";
oss.str(authenticate_error(method_name));
goto error_common;
error_dump:
oss << "Error getting host pool";
oss.str(get_error(method_name, "HOST", -1));
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
NebulaLog::log("ReM",Log::ERROR,oss);
NebulaLog::log("ReM",Log::ERROR,oss);
xmlrpc_c::value_array arrayresult_error(arrayData);
*retval = arrayresult_error;
return;
}
+73 -22
View File
@@ -15,10 +15,12 @@
/* -------------------------------------------------------------------------- */
#include "RequestManager.h"
#include "NebulaLog.h"
#include "NebulaLog.h"
#include "Nebula.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -27,36 +29,76 @@ void RequestManager::ImageAllocate::execute(
xmlrpc_c::value * const retval)
{
string session;
string image_template;
string str_template;
ImageTemplate * img_template;
int iid;
int uid;
int rc;
char * error_msg = 0;
ostringstream oss;
const string method_name = "ImageAllocate";
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
NebulaLog::log("ReM",Log::DEBUG,"ImageAllocate invoked");
session = xmlrpc_c::value_string(paramList.getString(0));
image_template = xmlrpc_c::value_string(paramList.getString(1));
image_template += "\n";
session = xmlrpc_c::value_string(paramList.getString(0));
str_template = xmlrpc_c::value_string(paramList.getString(1));
str_template += "\n";
//--------------------------------------------------------------------------
// Authorize this request
//--------------------------------------------------------------------------
uid = ImageAllocate::upool->authenticate(session);
// First, we need to authenticate the user
rc = ImageAllocate::upool->authenticate(session);
if ( rc == -1 )
if ( uid == -1 )
{
goto error_authenticate;
}
uid = rc;
rc = ImageAllocate::ipool->allocate(uid,image_template,&iid);
//--------------------------------------------------------------------------
// Authorize this request
//--------------------------------------------------------------------------
img_template = new ImageTemplate;
rc = img_template->parse(str_template,&error_msg);
if ( rc != 0 )
{
goto error_parse;
}
if ( uid != 0 )
{
AuthRequest ar(uid);
string t64;
string pub;
string pub_name = "PUBLIC";
img_template->get(pub_name, pub);
transform (pub.begin(), pub.end(), pub.begin(),(int(*)(int))toupper);
ar.add_auth(AuthRequest::IMAGE,
img_template->to_xml(t64),
AuthRequest::CREATE,
uid,
(pub == "YES"));
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
//--------------------------------------------------------------------------
// Allocate the Image
//--------------------------------------------------------------------------
rc = ImageAllocate::ipool->allocate(uid,img_template,&iid);
if ( rc < 0 )
{
@@ -76,18 +118,27 @@ void RequestManager::ImageAllocate::execute(
return;
error_authenticate:
oss << "User not authenticated, aborting ImageAllocate call.";
oss.str(authenticate_error(method_name));
goto error_common;
error_authorize:
oss.str(authorization_error(method_name, "CREATE", "IMAGE", uid, -1));
delete img_template;
goto error_common;
error_parse:
oss << action_error(method_name, "PARSE", "IMAGE TEMPLATE",-2,rc);
if (error_msg != 0)
{
oss << ". Reason: " << error_msg;
free(error_msg);
}
delete img_template;
goto error_common;
error_allocate:
if (rc == -1)
{
oss << "Error allocating image, check oned.log";
}
else
{
oss << "Error parsing image template";
}
oss.str(action_error(method_name, "CREATE", "IMAGE", -2, rc));
goto error_common;
error_common:
+45 -15
View File
@@ -15,10 +15,12 @@
/* -------------------------------------------------------------------------- */
#include "RequestManager.h"
#include "NebulaLog.h"
#include "NebulaLog.h"
#include "Nebula.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -31,10 +33,15 @@ void RequestManager::ImageDelete::execute(
int iid;
int uid;
int rc;
int image_owner;
bool is_public;
Image * image;
ostringstream oss;
const string method_name = "ImageDelete";
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
@@ -47,15 +54,13 @@ void RequestManager::ImageDelete::execute(
// First, we need to authenticate the user
rc = ImageDelete::upool->authenticate(session);
uid = ImageDelete::upool->authenticate(session);
if ( rc == -1 )
if ( uid == -1 )
{
goto error_authenticate;
}
uid = rc;
// Get image from the ImagePool
image = ImageDelete::ipool->get(iid,true);
@@ -63,10 +68,35 @@ void RequestManager::ImageDelete::execute(
{
goto error_image_get;
}
if ( uid != 0 && uid != image->get_uid() )
image_owner = image->get_uid();
is_public = image->isPublic();
image->unlock();
//Authorize the operation
if ( uid != 0 ) // uid == 0 means oneadmin
{
goto error_authorization;
AuthRequest ar(uid);
ar.add_auth(AuthRequest::IMAGE,
iid,
AuthRequest::DELETE,
image_owner,
is_public);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
// Get image from the ImagePool
image = ImageDelete::ipool->get(iid,true);
if ( image == 0 )
{
goto error_image_get;
}
rc = ImageDelete::ipool->drop(image);
@@ -91,20 +121,20 @@ void RequestManager::ImageDelete::execute(
return;
error_authenticate:
oss << "User not authenticated, aborting ImageDelete call.";
oss.str(authenticate_error(method_name));
goto error_common;
error_image_get:
oss << "Error getting image with ID = " << iid;
oss.str(get_error(method_name, "IMAGE", iid));
goto error_common;
error_authorization:
oss << "User not authorized to delete image, aborting ImageDelete call.";
image->unlock();
error_authorize:
oss.str(authorization_error(method_name, "DELETE", "IMAGE", uid, iid));
goto error_common;
error_delete:
oss << "Cannot delete image, VMs might be running on it.";
oss << action_error(method_name, "DELETE", "IMAGE", iid, rc)
<< ". Reason: VMs might be running on it.";
image->unlock();
goto error_common;
+43 -15
View File
@@ -15,10 +15,12 @@
/* -------------------------------------------------------------------------- */
#include "RequestManager.h"
#include "NebulaLog.h"
#include "NebulaLog.h"
#include "Nebula.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -33,9 +35,14 @@ void RequestManager::ImageEnable::execute(
int uid;
int rc;
int image_owner;
bool is_public;
Image * image;
ostringstream oss;
const string method_name = "ImageEnable";
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
@@ -48,15 +55,13 @@ void RequestManager::ImageEnable::execute(
enable_flag = xmlrpc_c::value_boolean(paramList.getBoolean(2));
// First, we need to authenticate the user
rc = ImageEnable::upool->authenticate(session);
uid = ImageEnable::upool->authenticate(session);
if ( rc == -1 )
if ( uid == -1 )
{
goto error_authenticate;
}
uid = rc;
// Get image from the ImagePool
image = ImageEnable::ipool->get(iid,true);
@@ -65,11 +70,36 @@ void RequestManager::ImageEnable::execute(
goto error_image_get;
}
if ( uid != 0 && uid != image->get_uid() )
image_owner = image->get_uid();
is_public = image->isPublic();
image->unlock();
//Authorize the operation
if ( uid != 0 ) // uid == 0 means oneadmin
{
goto error_authorization;
}
AuthRequest ar(uid);
ar.add_auth(AuthRequest::IMAGE,
iid,
AuthRequest::MANAGE,
image_owner,
is_public);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
// Get image from the ImagePool
image = ImageEnable::ipool->get(iid,true);
if ( image == 0 )
{
goto error_image_get;
}
rc = image->enable(enable_flag);
if ( rc < 0 )
@@ -94,21 +124,19 @@ void RequestManager::ImageEnable::execute(
return;
error_authenticate:
oss << "[ImageEnable] User not authenticated, aborting call.";
oss.str(authenticate_error(method_name));
goto error_common;
error_image_get:
oss << "[ImageEnable] Error getting image with ID = " << iid;
oss.str(get_error(method_name, "IMAGE", iid));
goto error_common;
error_authorization:
oss << "[ImageEnable] User not authorized to enable/disable image" <<
" attributes, aborting call.";
image->unlock();
error_authorize:
oss.str(authorization_error(method_name, "MANAGE", "IMAGE", uid, iid));
goto error_common;
error_enable:
oss << "[ImageEnable] Cannot enable/disable image [" << iid << "]";
oss.str(action_error(method_name, "ENABLE/DISABLE", "IMAGE", iid, rc));
image->unlock();
goto error_common;
+30 -28
View File
@@ -17,21 +17,25 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void RequestManager::ImageInfo::execute(
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retval)
{
{
string session;
int iid;
int uid;
int rc;
Image * image;
int iid;
int uid; // Image owner user id
int rc; // Requesting user id
Image * image;
ostringstream oss;
const string method_name = "ImageInfo";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
@@ -42,30 +46,30 @@ void RequestManager::ImageInfo::execute(
// Get the parameters
session = xmlrpc_c::value_string(paramList.getString(0));
iid = xmlrpc_c::value_int (paramList.getInt(1));
// Get image from the ImagePool
image = ImageInfo::ipool->get(iid,true);
if ( image == 0 )
{
goto error_image_get;
image = ImageInfo::ipool->get(iid,true);
if ( image == 0 )
{
goto error_image_get;
}
uid = image->get_uid();
// Check if it is a valid user
rc = ImageInfo::upool->authenticate(session);
if ( rc != 0 && rc != uid && !image->is_public())
{
goto error_authenticate;
if ( rc == -1 )
{
goto error_authenticate;
}
oss << *image;
image->unlock();
// All nice, return the host info to the client
// All nice, return the host info to the client
arrayData.push_back(xmlrpc_c::value_boolean(true)); // SUCCESS
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
@@ -76,28 +80,26 @@ void RequestManager::ImageInfo::execute(
delete arrayresult; // and get rid of the original
return;
error_image_get:
oss << "Error getting image with ID = " << iid;
oss.str(get_error(method_name, "IMAGE", iid));
goto error_common;
error_authenticate:
oss << "User doesn't exist, or not authorized to use image with " <<
"ID = " << iid << " , ImageInfo call aborted.";
oss.str(authenticate_error(method_name));
image->unlock();
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
NebulaLog::log("ReM",Log::ERROR,oss);
NebulaLog::log("ReM",Log::ERROR,oss);
xmlrpc_c::value_array arrayresult_error(arrayData);
*retval = arrayresult_error;
return;
}
+7 -20
View File
@@ -32,6 +32,8 @@ void RequestManager::ImagePoolInfo::execute(
int rc;
int uid;
int filter_flag;
const string method_name = "ImagePoolInfo";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
@@ -44,14 +46,12 @@ void RequestManager::ImagePoolInfo::execute(
filter_flag = xmlrpc_c::value_int(paramList.getInt(1));
// Check if it is a valid user
rc = ImagePoolInfo::upool->authenticate(session);
uid = ImagePoolInfo::upool->authenticate(session);
if ( rc == -1 )
if ( uid == -1 )
{
goto error_authenticate;
}
uid = rc;
where_string.str("");
@@ -68,21 +68,13 @@ void RequestManager::ImagePoolInfo::execute(
switch(filter_flag)
{
case -2:
if ( uid != 0 )
{
goto error_authorization;
}
// TODO define authentication bug #278
// where remains empty.
break;
case -1:
where_string << "UID=" << uid << " OR public = 'YES'";
break;
default:
// Only oneadmin or the user can list a specific user's images.
if ( uid != 0 && uid != filter_flag )
{
goto error_authorization;
}
where_string << "UID=" << filter_flag;
}
@@ -109,23 +101,18 @@ void RequestManager::ImagePoolInfo::execute(
return;
error_authenticate:
oss << "User not authenticated, ImagePoolInfo call aborted.";
oss.str(authenticate_error(method_name));
goto error_common;
error_authorization:
oss << "User not authorized to perform this operation.";
goto error_common;
error_filter_flag:
oss << "Incorrect filter_flag, must be >= -2.";
goto error_common;
error_dump:
oss << "Error getting image pool";
oss.str(get_error(method_name, "IMAGE", -1));
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
+42 -15
View File
@@ -15,10 +15,12 @@
/* -------------------------------------------------------------------------- */
#include "RequestManager.h"
#include "NebulaLog.h"
#include "NebulaLog.h"
#include "Nebula.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -31,11 +33,15 @@ void RequestManager::ImagePublish::execute(
int iid;
bool publish_flag;
int uid;
int rc;
int image_owner;
bool is_public;
Image * image;
ostringstream oss;
const string method_name = "ImagePublish";
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
@@ -48,15 +54,13 @@ void RequestManager::ImagePublish::execute(
publish_flag = xmlrpc_c::value_boolean(paramList.getBoolean(2));
// First, we need to authenticate the user
rc = ImagePublish::upool->authenticate(session);
uid = ImagePublish::upool->authenticate(session);
if ( rc == -1 )
if ( uid == -1 )
{
goto error_authenticate;
}
uid = rc;
// Get image from the ImagePool
image = ImagePublish::ipool->get(iid,true);
@@ -65,11 +69,36 @@ void RequestManager::ImagePublish::execute(
goto error_image_get;
}
if ( uid != 0 && uid != image->get_uid() )
image_owner = image->get_uid();
is_public = image->isPublic();
image->unlock();
//Authorize the operation
if ( uid != 0 ) // uid == 0 means oneadmin
{
goto error_authorization;
}
AuthRequest ar(uid);
ar.add_auth(AuthRequest::IMAGE,
iid,
AuthRequest::MANAGE,
image_owner,
is_public);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
// Get the image locked again
image = ImagePublish::ipool->get(iid,true);
if ( image == 0 )
{
goto error_image_get;
}
image->publish(publish_flag);
ImagePublish::ipool->update(image);
@@ -88,17 +117,15 @@ void RequestManager::ImagePublish::execute(
return;
error_authenticate:
oss << "[ImagePublish] User not authenticated, aborting call.";
oss.str(authenticate_error(method_name));
goto error_common;
error_image_get:
oss << "[ImagePublish] Error getting image with ID = " << iid;
oss.str(get_error(method_name, "IMAGE", iid));
goto error_common;
error_authorization:
oss << "[ImagePublish] User not authorized to publish/unpublish image" <<
", aborting call.";
image->unlock();
error_authorize:
oss.str(authorization_error(method_name, "MANAGE", "IMAGE", uid, iid));
goto error_common;
error_common:
+44 -18
View File
@@ -15,10 +15,12 @@
/* -------------------------------------------------------------------------- */
#include "RequestManager.h"
#include "NebulaLog.h"
#include "NebulaLog.h"
#include "Nebula.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -32,10 +34,15 @@ void RequestManager::ImageRemoveAttribute::execute(
int iid;
int uid;
int rc;
int image_owner;
bool is_public;
Image * image;
ostringstream oss;
const string method_name = "ImageRemoveAttribute";
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
@@ -48,15 +55,13 @@ void RequestManager::ImageRemoveAttribute::execute(
name = xmlrpc_c::value_string(paramList.getString(2));
// First, we need to authenticate the user
rc = ImageRemoveAttribute::upool->authenticate(session);
uid = ImageRemoveAttribute::upool->authenticate(session);
if ( rc == -1 )
if ( uid == -1 )
{
goto error_authenticate;
}
uid = rc;
// Get image from the ImagePool
image = ImageRemoveAttribute::ipool->get(iid,true);
@@ -64,11 +69,35 @@ void RequestManager::ImageRemoveAttribute::execute(
{
goto error_image_get;
}
if ( uid != 0 && uid != image->get_uid() )
image_owner = image->get_uid();
is_public = image->isPublic();
image->unlock();
//Authorize the operation
if ( uid != 0 ) // uid == 0 means oneadmin
{
goto error_authorization;
AuthRequest ar(uid);
ar.add_auth(AuthRequest::IMAGE,
iid,
AuthRequest::MANAGE,
image_owner,
is_public);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
// Get image from the ImagePool
image = ImageRemoveAttribute::ipool->get(iid,true);
if ( image == 0 )
{
goto error_image_get;
}
rc = ImageRemoveAttribute::ipool->remove_attribute(image, name);
@@ -92,22 +121,19 @@ void RequestManager::ImageRemoveAttribute::execute(
return;
error_authenticate:
oss << "[ImageRemoveAttribute] User not authenticated, aborting call.";
oss.str(authenticate_error(method_name));
goto error_common;
error_image_get:
oss << "[ImageRemoveAttribute] Error getting image with ID = " << iid;
oss.str(get_error(method_name, "IMAGE", iid));
goto error_common;
error_authorization:
oss << "[ImageRemoveAttribute] User not authorized to remove image" <<
" attributes aborting call.";
image->unlock();
error_authorize:
oss.str(authorization_error(method_name, "MANAGE", "IMAGE", uid, iid));
goto error_common;
error_remove_attribute:
oss << "[ImageRemoveAttribute] Cannot remove attribute with name = "
<< name << " for image [" << iid << "]";
oss.str(action_error(method_name, "PUBLISH/UNPUBLISH", "IMAGE", iid, rc));
image->unlock();
goto error_common;
+44 -17
View File
@@ -15,10 +15,12 @@
/* -------------------------------------------------------------------------- */
#include "RequestManager.h"
#include "NebulaLog.h"
#include "NebulaLog.h"
#include "Nebula.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -33,6 +35,9 @@ void RequestManager::ImageUpdate::execute(
string name;
string value;
int rc;
int image_owner;
bool is_public;
Image * image;
@@ -40,7 +45,8 @@ void RequestManager::ImageUpdate::execute(
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
const string method_name = "ImageUpdate";
NebulaLog::log("ReM",Log::DEBUG,"ImageUpdate invoked");
@@ -50,15 +56,13 @@ void RequestManager::ImageUpdate::execute(
value = xmlrpc_c::value_string(paramList.getString(3));
// First, we need to authenticate the user
rc = ImageUpdate::upool->authenticate(session);
uid = ImageUpdate::upool->authenticate(session);
if ( rc == -1 )
if ( uid == -1 )
{
goto error_authenticate;
}
uid = rc;
// Get image from the ImagePool
image = ImageUpdate::ipool->get(iid,true);
@@ -66,10 +70,35 @@ void RequestManager::ImageUpdate::execute(
{
goto error_image_get;
}
if ( uid != 0 && uid != image->get_uid() )
image_owner = image->get_uid();
is_public = image->isPublic();
image->unlock();
//Authorize the operation
if ( uid != 0 ) // uid == 0 means oneadmin
{
goto error_authorization;
AuthRequest ar(uid);
ar.add_auth(AuthRequest::IMAGE,
iid,
AuthRequest::MANAGE,
image_owner,
is_public);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
// Get image from the ImagePool
image = ImageUpdate::ipool->get(iid,true);
if ( image == 0 )
{
goto error_image_get;
}
// This will perform the update on the DB as well,
@@ -95,21 +124,19 @@ void RequestManager::ImageUpdate::execute(
return;
error_authenticate:
oss << "User not authenticated, aborting ImageUpdate call.";
oss.str(authenticate_error(method_name));
goto error_common;
error_image_get:
oss << "Error getting image with ID = " << iid;
oss.str(get_error(method_name, "IMAGE", iid));
goto error_common;
error_authorization:
oss << "User not authorized to modify image attributes " <<
", aborting ImageUpdate call.";
image->unlock();
error_authorize:
oss.str(authorization_error(method_name, "MANAGE", "IMAGE", uid, iid));
goto error_common;
error_update:
oss << "Cannot modify image [" << iid << "] attribute with name = " << name;
oss.str(action_error(method_name, "UPDATE ATTRIBUTE", "IMAGE", iid, rc));
image->unlock();
goto error_common;
+30 -17
View File
@@ -23,13 +23,15 @@
void RequestManager::VirtualMachineInfo::execute(
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retval)
{
{
string session;
int vid;
int vid, rc;
VirtualMachine * vm;
ostringstream oss;
ostringstream oss;
const string method_name = "VirtualMachineInfo";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
@@ -41,19 +43,27 @@ void RequestManager::VirtualMachineInfo::execute(
session = xmlrpc_c::value_string(paramList.getString(0));
vid = xmlrpc_c::value_int (paramList.getInt(1));
// Get the details of the virtual machine
// Check if it is a valid user
rc = VirtualMachineInfo::upool->authenticate(session);
if ( rc == -1 )
{
goto error_authenticate;
}
// Get the details of the virtual machine
vm = VirtualMachineInfo::vmpool->get(vid,true);
if ( vm == 0 )
{
goto error_vm_get;
if ( vm == 0 )
{
goto error_vm_get;
}
oss << *vm;
vm->unlock();
// All nice, return the vm info to the client
// All nice, return the vm info to the client
arrayData.push_back(xmlrpc_c::value_boolean(true)); // SUCCESS
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
@@ -65,21 +75,24 @@ void RequestManager::VirtualMachineInfo::execute(
return;
error_authenticate:
oss.str(authenticate_error(method_name));
goto error_common;
error_vm_get:
oss << "Error getting vm with VID = " << vid;
oss.str(get_error(method_name, "VM", vid));
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
NebulaLog::log("ReM",Log::ERROR,oss);
NebulaLog::log("ReM",Log::ERROR,oss);
xmlrpc_c::value_array arrayresult_error(arrayData);
*retval = arrayresult_error;
return;
}
+35 -20
View File
@@ -48,18 +48,18 @@ void RequestManager::VirtualMachineMigrate::execute(
xmlrpc_c::value_array * arrayresult;
ostringstream oss;
const string method_name = "VirtualMachineMigrate";
NebulaLog::log("ReM",Log::DEBUG,"VirtualMachineMigrate invoked");
//Parse Arguments
session = xmlrpc_c::value_string(paramList.getString(0));
vid = xmlrpc_c::value_int(paramList.getInt(1));
hid = xmlrpc_c::value_int(paramList.getInt(2));
live = xmlrpc_c::value_boolean(paramList.getBoolean(3));
//Get host info to deploy the VM
//Get host info to migrate the VM
host = VirtualMachineMigrate::hpool->get(hid,true);
if ( host == 0 )
@@ -76,7 +76,6 @@ void RequestManager::VirtualMachineMigrate::execute(
host->unlock();
//Get the VM and migrate it
vm = VirtualMachineMigrate::vmpool->get(vid,true);
if ( vm == 0 )
@@ -89,11 +88,25 @@ void RequestManager::VirtualMachineMigrate::execute(
// Only oneadmin or the VM owner can perform operations upon the VM
rc = VirtualMachineMigrate::upool->authenticate(session);
if ( rc != 0 && rc != uid)
if ( rc == -1)
{
goto error_authenticate;
}
//Authorize the operation
if ( rc != 0 ) // rc == 0 means oneadmin
{
AuthRequest ar(rc);
ar.add_auth(AuthRequest::VM,vid,AuthRequest::MANAGE,uid,false);
ar.add_auth(AuthRequest::HOST,hid,AuthRequest::USE,0,false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
if ((vm->get_state() != VirtualMachine::ACTIVE) ||
(vm->get_lcm_state() != VirtualMachine::RUNNING))
{
@@ -123,7 +136,6 @@ void RequestManager::VirtualMachineMigrate::execute(
vm->unlock();
// Send results to client
arrayData.push_back(xmlrpc_c::value_boolean(true));
arrayresult = new xmlrpc_c::value_array(arrayData);
@@ -134,33 +146,36 @@ void RequestManager::VirtualMachineMigrate::execute(
return;
error_authenticate:
vm->unlock();
oss << "User not authorized to perform migration upon this VM";
goto error_common;
error_host_get:
oss << "The host " << hid << " does not exists";
oss.str(get_error(method_name, "HOST", hid));
goto error_common;
error_vm_get:
oss << "The virtual machine " << vid << " does not exists";
oss.str(get_error(method_name, "VM", vid));
goto error_common;
error_authenticate:
oss.str(authenticate_error(method_name));
goto error_common_lock;
error_authorize:
oss.str(authorization_error(method_name, "MANAGE", "VM", uid, vid));
goto error_common_lock;
error_history:
vm->unlock();
oss << "Can not migrate VM " << vid << ", can not insert history";
goto error_common;
oss.str(action_error(method_name, "INSERT HISTORY", "VM", vid, rc));
goto error_common_lock;
error_state:
vm->unlock();
oss << action_error(method_name, "MANAGE", "VM", vid, rc)
<< ". Reason: VM in wrong state.";
goto error_common_lock;
oss << "Can not migrate VM " << vid << ", wrong state";
goto error_common;
error_common_lock:
vm->unlock();
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false));
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
+20 -40
View File
@@ -23,22 +23,22 @@
void RequestManager::VirtualMachinePoolInfo::execute(
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retval)
{
{
string session;
string username;
string password;
int filter_flag;
int rc;
ostringstream oss;
ostringstream where_string;
User * user;
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
const string method_name = "VirtualMachinePoolInfo";
NebulaLog::log("ReM",Log::DEBUG,"VirtualMachinePoolInfo method invoked");
@@ -54,43 +54,28 @@ void RequestManager::VirtualMachinePoolInfo::execute(
goto error_authenticate;
}
where_string.str("");
/** Filter flag meaning table
/* Filter flag meaning table
* <=-2 :: ALL VMs
* -1 :: User's VMs
* >=0 :: UID User's VMs
**/
*/
if (filter_flag == -1)
{
User::split_secret(session,username,password);
// Now let's get the user
user = VirtualMachinePoolInfo::upool->get(username,true);
if ( user == 0 )
{
goto error_get_user;
}
where_string << "UID=" << user->get_uid();
user->unlock();
where_string << "UID=" << rc;
}
else if (filter_flag>=0)
{
where_string << "UID=" << filter_flag;
}
{
where_string << "UID=" << filter_flag;
}
// Perform the allocation in the vmpool
rc = VirtualMachinePoolInfo::vmpool->dump(oss,where_string.str());
if ( rc != 0 )
{
{
goto error_dump;
}
// All nice, return the vm info to the client
// All nice, return the vm info to the client
arrayData.push_back(xmlrpc_c::value_boolean(true)); // SUCCESS
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
@@ -103,30 +88,25 @@ void RequestManager::VirtualMachinePoolInfo::execute(
return;
error_authenticate:
oss << "User not authenticated, aborting RequestManagerPoolInfo call.";
goto error_common;
error_get_user:
oss << "An error ocurred getting the user from the UserPool, aborting RequestManagerPoolInfo call";
oss.str(authenticate_error(method_name));
goto error_common;
error_dump:
oss << "Error getting the pool info";
oss.str(get_error(method_name, "VM", -1));
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
NebulaLog::log("ReM",Log::ERROR,oss);
xmlrpc_c::value_array arrayresult_error(arrayData);
*retval = arrayresult_error;
return;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
+54 -31
View File
@@ -17,25 +17,29 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void RequestManager::UserAllocate::execute(
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retval)
{
{
string session;
string username;
string password;
string password;
int uid;
int rc;
int rc;
ostringstream oss;
User * user;
const string method_name = "UserAllocate";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
@@ -44,16 +48,32 @@ void RequestManager::UserAllocate::execute(
// Get the parameters
session = xmlrpc_c::value_string(paramList.getString(0));
username = xmlrpc_c::value_string(paramList.getString(1));
password = xmlrpc_c::value_string(paramList.getString(2));
// Only oneadmin can add users
rc = UserAllocate::upool->authenticate(session);
if ( rc != 0 )
{
goto error_authenticate;
if ( rc == -1 )
{
goto error_authenticate;
}
//Authorize the operation
if ( rc != 0 ) // rc == 0 means oneadmin
{
AuthRequest ar(rc);
ar.add_auth(AuthRequest::USER,
-1,
AuthRequest::CREATE,
0,
false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
// Let's make sure that the user doesn't exist in the database
@@ -63,51 +83,54 @@ void RequestManager::UserAllocate::execute(
{
goto error_duplicate;
}
// Now let's add the user
rc = UserAllocate::upool->allocate(&uid,username,password,true);
if ( rc == -1 )
{
goto error_allocate;
}
// All nice, return the new uid to client
if ( rc == -1 )
{
goto error_allocate;
}
// All nice, return the new uid to client
arrayData.push_back(xmlrpc_c::value_boolean(true)); // SUCCESS
arrayData.push_back(xmlrpc_c::value_int(uid));
// Copy arrayresult into retval mem space
arrayresult = new xmlrpc_c::value_array(arrayData);
*retval = *arrayresult;
delete arrayresult; // and get rid of the original
return;
error_authenticate:
oss << "User not authorized to add new users";
goto error_common;
error_duplicate:
oss << "Existing user, cannot duplicate";
oss.str(authenticate_error(method_name));
goto error_common;
error_authorize:
oss.str(authorization_error(method_name, "CREATE", "USER", rc, -1));
goto error_common;
error_duplicate:
oss << action_error(method_name, "CREATE", "USER", -2, -1)
<< ". Reason: Existing user, cannot duplicate.";
goto error_common;
error_allocate:
oss << "Error allocating user";
oss.str(action_error(method_name, "CREATE", "USER", -2, rc));
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
NebulaLog::log("ReM",Log::ERROR,oss);
NebulaLog::log("ReM",Log::ERROR,oss);
xmlrpc_c::value_array arrayresult_error(arrayData);
*retval = arrayresult_error;
return;
}
+54 -29
View File
@@ -17,21 +17,25 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void RequestManager::UserDelete::execute(
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retval)
{
string session;
{
string session;
int uid;
User * user;
int uid;
User * user;
int rc;
int rc;
ostringstream oss;
const string method_name = "UserDelete";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
@@ -47,33 +51,49 @@ void RequestManager::UserDelete::execute(
{
goto error_oneadmin_deletion;
}
// Only oneadmin can delete users
rc = UserDelete::upool->authenticate(session);
if ( rc != 0 )
if ( rc == -1 )
{
goto error_authenticate;
}
// Now let's get the user
//Authorize the operation
if ( rc != 0 ) // rc == 0 means oneadmin
{
AuthRequest ar(rc);
ar.add_auth(AuthRequest::USER,
uid,
AuthRequest::DELETE,
0,
false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
// Now let's get the user
user = UserDelete::upool->get(uid,true);
if ( user == 0)
if ( user == 0)
{
goto error_get_user;
}
rc = UserDelete::upool->drop(user);
user->unlock();
if ( rc != 0 )
{
goto error_delete;
}
// All nice, return the new uid to client
if ( rc != 0 )
{
goto error_delete;
}
// All nice, return the new uid to client
arrayData.push_back(xmlrpc_c::value_boolean(true)); // SUCCESS
// Copy arrayresult into retval mem space
@@ -85,31 +105,36 @@ void RequestManager::UserDelete::execute(
return;
error_oneadmin_deletion:
oss << "User oneadmin cannot be deleted";
oss << action_error(method_name, "DELETE", "USER", uid, -1)
<< ". Reason: Oneadmin cannot be deleted.";
goto error_common;
error_authenticate:
oss << "User not authorized to delete users";
oss.str(authenticate_error(method_name));
goto error_common;
error_authorize:
oss.str(authorization_error(method_name, "DELETE", "USER", rc, uid));
goto error_common;
error_get_user:
oss << "Error retrieving user " << uid;
oss.str(get_error(method_name, "USER", uid));
goto error_common;
error_delete:
oss << "Error deleting user " << uid;
oss.str(action_error(method_name, "DELETE", "USER", uid, rc));
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
NebulaLog::log("ReM",Log::ERROR,oss);
NebulaLog::log("ReM",Log::ERROR,oss);
xmlrpc_c::value_array arrayresult_error(arrayData);
*retval = arrayresult_error;
return;
}
-100
View File
@@ -1,100 +0,0 @@
/* -------------------------------------------------------------------------- */
/* Copyright 2002-2010, OpenNebula Project Leads (OpenNebula.org) */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); you may */
/* not use this file except in compliance with the License. You may obtain */
/* a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
/* See the License for the specific language governing permissions and */
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#include "RequestManager.h"
#include "NebulaLog.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void RequestManager::UserInfo::execute(
xmlrpc_c::paramList const& paramList,
xmlrpc_c::value * const retval)
{
string session;
int uid;
User * user;
int rc;
ostringstream oss;
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
NebulaLog::log("ReM",Log::DEBUG,"UserInfo method invoked");
// Get the parameters
session = xmlrpc_c::value_string(paramList.getString(0));
uid = xmlrpc_c::value_int(paramList.getInt(1));
// Only oneadmin can retrieve user information
rc = UserInfo::upool->authenticate(session);
if ( rc != 0 )
{
goto error_authenticate;
}
// Now let's get the user
user = UserInfo::upool->get(uid,true);
if ( user == 0 )
{
goto error_get_user;
}
oss << *user;
user->unlock();
// All nice, return the new uid to client
arrayData.push_back(xmlrpc_c::value_boolean(true)); // SUCCESS
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
// Copy arrayresult into retval mem space
arrayresult = new xmlrpc_c::value_array(arrayData);
*retval = *arrayresult;
delete arrayresult; // and get rid of the original
return;
error_authenticate:
oss << "User not authorized to retrieve user information";
goto error_common;
error_get_user:
oss << "Error getting user";
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
NebulaLog::log("ReM",Log::ERROR,oss);
xmlrpc_c::value_array arrayresult_error(arrayData);
*retval = arrayresult_error;
return;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
+32 -8
View File
@@ -17,6 +17,8 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -26,8 +28,11 @@ void RequestManager::UserPoolInfo::execute(
{
string session;
int rc;
int rc;
int uid;
ostringstream oss;
const string method_name = "UserPoolInfo";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
@@ -39,15 +44,31 @@ void RequestManager::UserPoolInfo::execute(
session = xmlrpc_c::value_string(paramList.getString(0));
// Only oneadmin can list the whole user pool
rc = UserPoolInfo::upool->authenticate(session);
uid = UserPoolInfo::upool->authenticate(session);
if ( rc != 0 )
if ( uid == -1 )
{
goto error_authenticate;
}
// Now let's get the info
//Authorize the operation
if ( uid != 0 ) // uid == 0 means oneadmin
{
AuthRequest ar(uid);
ar.add_auth(AuthRequest::USER,
-1,
AuthRequest::INFO,
0,
false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
// Now let's get the info
rc = UserPoolInfo::upool->dump(oss,"");
if ( rc != 0 )
@@ -67,15 +88,18 @@ void RequestManager::UserPoolInfo::execute(
return;
error_authenticate:
oss << "User not authorized to pull user pool info. Error code: " << rc;
oss.str(authenticate_error(method_name));
goto error_common;
error_authorize:
oss.str(authorization_error(method_name, "INFO", "USER", uid, -1));
goto error_common;
error_dumping:
oss << "Error dumping pool info";
oss.str(get_error(method_name, "USER", -1));
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
+66 -21
View File
@@ -17,6 +17,8 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -25,19 +27,20 @@ void RequestManager::VirtualNetworkAllocate::execute(
xmlrpc_c::value * const retval)
{
string session;
string username;
string password;
string name;
string stemplate;
string str_template;
VirtualNetworkTemplate * vn_template;
int nid;
int uid;
int rc;
User * user;
char * error_msg = 0;
ostringstream oss;
const string method_name = "VirtualNetworkAllocate";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
@@ -45,27 +48,57 @@ void RequestManager::VirtualNetworkAllocate::execute(
NebulaLog::log("ReM",Log::DEBUG,"VirtualNetworkAllocate method invoked");
// Get the parameters & host
session = xmlrpc_c::value_string(paramList.getString(0));
stemplate = xmlrpc_c::value_string(paramList.getString(1));
session = xmlrpc_c::value_string(paramList.getString(0));
str_template = xmlrpc_c::value_string(paramList.getString(1));
if ( User::split_secret(session,username,password) != 0 )
//--------------------------------------------------------------------------
// Authorize this request
//--------------------------------------------------------------------------
uid = VirtualNetworkAllocate::upool->authenticate(session);
if ( uid == -1 )
{
goto error_session;
goto error_authenticate;
}
// Now let's get the user
user = VirtualNetworkAllocate::upool->get(username,true);
//--------------------------------------------------------------------------
// Authorize this request
//--------------------------------------------------------------------------
vn_template = new VirtualNetworkTemplate;
if ( user == 0 )
rc = vn_template->parse(str_template,&error_msg);
if ( rc != 0 )
{
goto error_get_user;
goto error_parse;
}
uid = user->get_uid();
if ( uid != 0 )
{
AuthRequest ar(uid);
string t64;
string pub;
string pub_name = "PUBLIC";
user->unlock();
vn_template->get(pub_name, pub);
transform (pub.begin(), pub.end(), pub.begin(),(int(*)(int))toupper);
rc = vnpool->allocate(uid,stemplate,&nid);
ar.add_auth(AuthRequest::NET,
vn_template->to_xml(t64),
AuthRequest::CREATE,
uid,
(pub == "YES"));
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
//--------------------------------------------------------------------------
// Allocate the Virtual Network
//--------------------------------------------------------------------------
rc = vnpool->allocate(uid,vn_template,&nid);
if ( rc < 0 )
{
@@ -84,16 +117,28 @@ void RequestManager::VirtualNetworkAllocate::execute(
return;
error_session:
oss << "Session information malformed, cannot allocate VirtualNetwork";
error_authenticate:
oss.str(authenticate_error(method_name));
goto error_common;
error_get_user:
oss << "User not recognized, cannot allocate VirtualNetwork";
error_authorize:
oss.str(authorization_error(method_name, "CREATE", "VNET", uid, -1));
delete vn_template;
goto error_common;
error_parse:
oss << action_error(method_name, "PARSE", "VNET TEMPLATE",-2,rc);
if (error_msg != 0)
{
oss << ". Reason: " << error_msg;
free(error_msg);
}
delete vn_template;
goto error_common;
error_vn_allocate:
oss << "Error allocating VN with template: " << endl << stemplate;
oss.str(action_error(method_name, "CREATE", "NET", -2, rc));
goto error_common;
error_common:
+32 -12
View File
@@ -17,6 +17,8 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -34,6 +36,8 @@ void RequestManager::VirtualNetworkDelete::execute(
int rc;
ostringstream oss;
const string method_name = "VirtualNetworkDelete";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
@@ -45,6 +49,27 @@ void RequestManager::VirtualNetworkDelete::execute(
session = xmlrpc_c::value_string(paramList.getString(0));
nid = xmlrpc_c::value_int (paramList.getInt (1));
// Only oneadmin or the VN owner can perform operations upon the VN
rc = VirtualNetworkDelete::upool->authenticate(session);
if ( rc == -1 )
{
goto error_authenticate;
}
//Authorize the operation
if ( rc != 0 ) // rc == 0 means oneadmin
{
AuthRequest ar(rc);
ar.add_auth(AuthRequest::NET,nid,AuthRequest::DELETE,0,false);
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
// Retrieve VN from the pool
vn = vnpool->get(nid,true);
@@ -54,14 +79,6 @@ void RequestManager::VirtualNetworkDelete::execute(
}
uid = vn->get_uid();
// Only oneadmin or the VN owner can perform operations upon the VN
rc = VirtualNetworkDelete::upool->authenticate(session);
if ( rc != 0 && rc != uid)
{
goto error_authenticate;
}
rc = vnpool->drop(vn);
@@ -79,16 +96,19 @@ void RequestManager::VirtualNetworkDelete::execute(
return;
error_authenticate:
vn->unlock();
oss << "User cannot delete VN";
oss.str(authenticate_error(method_name));
goto error_common;
error_authorize:
oss.str(authorization_error(method_name, "DELETE", "NET", rc, nid));
goto error_common;
error_vn_get:
oss << "Error getting Virtual Network with NID = " << nid;
oss.str(get_error(method_name, "NET", nid));
goto error_common;
error_common:
NebulaLog::log ("Rem",Log::ERROR,oss);
NebulaLog::log ("ReM",Log::ERROR,oss);
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
+8 -5
View File
@@ -17,6 +17,8 @@
#include "RequestManager.h"
#include "NebulaLog.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -33,6 +35,8 @@ void RequestManager::VirtualNetworkInfo::execute(
VirtualNetwork * vn;
ostringstream oss;
const string method_name = "VirtualNetworkInfo";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
@@ -51,7 +55,7 @@ void RequestManager::VirtualNetworkInfo::execute(
{
goto error_authenticate;
}
vn = vnpool->get(nid,true);
if ( vn == 0 )
@@ -76,15 +80,14 @@ void RequestManager::VirtualNetworkInfo::execute(
return;
error_authenticate:
oss << "User not authenticated, VirtualNetworkInfo call aborted.";
oss.str(authenticate_error(method_name));
goto error_common;
error_vn_get:
oss << "Error getting Virtual Network with NID = " << nid;
oss.str(get_error(method_name, "NET", nid));
goto error_common;
error_common:
arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE
arrayData.push_back(xmlrpc_c::value_string(oss.str()));
@@ -31,11 +31,13 @@ void RequestManager::VirtualNetworkPoolInfo::execute(
ostringstream oss;
ostringstream where_string;
int rc;
int rc;
int filter_flag;
User * user;
const string method_name = "VirtualNetworkPoolInfo";
/* -- RPC specific vars -- */
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
@@ -61,6 +63,8 @@ void RequestManager::VirtualNetworkPoolInfo::execute(
* -1 :: User's VMs
* >=0 :: UID User's VMs
**/
// TODO define authorization (bug #278)
if (filter_flag == -1)
{
User::split_secret(session,username,password);
@@ -105,15 +109,15 @@ void RequestManager::VirtualNetworkPoolInfo::execute(
return;
error_authenticate:
oss << "User not authenticated, NetworkPoolInfo call aborted.";
oss.str(authenticate_error(method_name));
goto error_common;
error_get_user:
oss << "Error getting user, aborting NetworkPoolInfo call";
oss.str(get_error(method_name, "USER", -1));
goto error_common;
error_dump:
oss << "Error getting virtual network pool";
oss.str(get_error(method_name, "HOST", -1));
goto error_common;
error_common:
+25 -13
View File
@@ -15,10 +15,12 @@
/* -------------------------------------------------------------------------- */
#include "RequestManager.h"
#include "NebulaLog.h"
#include "NebulaLog.h"
#include "Nebula.h"
#include "AuthManager.h"
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -31,12 +33,13 @@ void RequestManager::VirtualNetworkPublish::execute(
int nid;
bool publish_flag;
int uid;
int rc;
VirtualNetwork * vn;
ostringstream oss;
const string method_name = "VirtualNetworkPublish";
vector<xmlrpc_c::value> arrayData;
xmlrpc_c::value_array * arrayresult;
@@ -48,15 +51,13 @@ void RequestManager::VirtualNetworkPublish::execute(
publish_flag = xmlrpc_c::value_boolean(paramList.getBoolean(2));
// First, we need to authenticate the user
rc = VirtualNetworkPublish::upool->authenticate(session);
uid = VirtualNetworkPublish::upool->authenticate(session);
if ( rc == -1 )
if ( uid == -1 )
{
goto error_authenticate;
}
uid = rc;
// Get virtual network from the VirtualNetworkPool
vn = VirtualNetworkPublish::vnpool->get(nid,true);
@@ -65,9 +66,21 @@ void RequestManager::VirtualNetworkPublish::execute(
goto error_vn_get;
}
if ( uid != 0 && uid != vn->get_uid() )
//Authorize the operation
if ( uid != 0 ) // uid == 0 means oneadmin
{
goto error_authorization;
AuthRequest ar(uid);
ar.add_auth(AuthRequest::NET,
nid,
AuthRequest::MANAGE,
0,
vn->isPublic());
if (UserPool::authorize(ar) == -1)
{
goto error_authorize;
}
}
vn->publish(publish_flag);
@@ -88,16 +101,15 @@ void RequestManager::VirtualNetworkPublish::execute(
return;
error_authenticate:
oss << "[VirtualNetworkPublish] User not authenticated, aborting call.";
oss.str(authenticate_error(method_name));
goto error_common;
error_vn_get:
oss << "[VirtualNetworkPublish] Error getting VN with ID = " << nid;
oss.str(get_error(method_name, "NET", nid));
goto error_common;
error_authorization:
oss << "[VirtualNetworkPublish] User not authorized to (un)publish VN" <<
", aborting call.";
error_authorize:
oss.str(authorization_error(method_name, "MANAGE", "NET", uid, nid));
vn->unlock();
goto error_common;
-1
View File
@@ -54,7 +54,6 @@ source_files=[
'RequestManagerVirtualNetworkPublish.cc',
'RequestManagerVirtualNetworkDelete.cc',
'RequestManagerUserAllocate.cc',
'RequestManagerUserInfo.cc',
'RequestManagerUserDelete.cc',
'RequestManagerUserPoolInfo.cc'
]
-15
View File
@@ -307,21 +307,6 @@ string& User::to_str(string& str) const
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
int User::authenticate(string _password)
{
if (enabled && _password==password)
{
return oid;
}
else
{
return -1;
}
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
int User::split_secret(const string secret, string& user, string& pass)
{
size_t pos;
+124 -8
View File
@@ -20,6 +20,8 @@
#include "UserPool.h"
#include "NebulaLog.h"
#include "Nebula.h"
#include "AuthManager.h"
#include <fstream>
#include <sys/types.h>
@@ -165,21 +167,98 @@ int UserPool::authenticate(string& session)
{
map<string, int>::iterator index;
User * user = 0;
string username;
string password;
string secret, u_pass;
int uid;
int user_id = -1;
int user_id = -1;
int rc;
// session holds username:password
Nebula& nd = Nebula::instance();
AuthManager * authm = nd.get_authm();
if ( User::split_secret(session,username,password) == 0 )
rc = User::split_secret(session,username,secret);
if ( rc != 0 )
{
index = known_users.find(username);
return -1;
}
if ( index != known_users.end() )
index = known_users.find(username);
if ( index != known_users.end() ) //User known to OpenNebula
{
user = get((int)index->second,true);
if ( user == 0 )
{
User * user = get((int)index->second,false);
user_id = user->authenticate(password);
return -1;
}
u_pass = user->password;
uid = user->get_uid();
user->unlock();
}
else //External User
{
u_pass = "-";
uid = -1;
}
AuthRequest ar(uid);
ar.add_authenticate(username,u_pass,secret);
if ( uid == 0 ) //oneadmin
{
if (ar.plain_authenticate())
{
user_id = 0;
}
}
else if (authm == 0) //plain auth
{
if ( user != 0 && ar.plain_authenticate()) //no plain for external users
{
user_id = uid;
}
}
else //use the driver
{
authm->trigger(AuthManager::AUTHENTICATE,&ar);
ar.wait();
if (ar.result==true)
{
if ( user != 0 ) //knwon user_id
{
user_id = uid;
}
else //External user, user_id in driver message
{
istringstream is(ar.message);
if ( is.good() )
{
is >> user_id;
}
if ( is.fail() || user_id <= 0 )
{
ar.message = "Can't convert user_id from driver";
user_id = -1;
}
}
}
if (user_id == -1)
{
ostringstream oss;
oss << "Auth Error: " << ar.message;
NebulaLog::log("AuM",Log::ERROR,oss);
}
}
@@ -189,6 +268,43 @@ int UserPool::authenticate(string& session)
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
int UserPool::authorize(AuthRequest& ar)
{
Nebula& nd = Nebula::instance();
AuthManager * authm = nd.get_authm();
int rc = -1;
if (authm == 0)
{
if (ar.plain_authorize())
{
rc = 0;
}
}
else
{
authm->trigger(AuthManager::AUTHORIZE,&ar);
ar.wait();
if (ar.result==true)
{
rc = 0;
}
else
{
ostringstream oss;
oss << "Auth Error: " << ar.message;
NebulaLog::log("AuM",Log::ERROR,oss);
}
}
return rc;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
int UserPool::dump_cb(void * _oss, int num, char **values, char **names)
{
ostringstream * oss;
+4
View File
@@ -41,10 +41,12 @@ main_env.Append(CPPPATH=[
# Library dirs
main_env.Append(LIBPATH=[
cwd + '/src/common',
cwd + '/src/mad',
cwd + '/src/log',
cwd + '/src/nebula',
cwd + '/src/pool',
cwd + '/src/sql',
cwd + '/src/authm',
cwd + '/src/um',
'/usr/include/openssl/',
])
@@ -53,7 +55,9 @@ main_env.Append(LIBS=[
'nebula_um',
'nebula_pool',
'nebula_log',
'nebula_authm',
'nebula_common',
'nebula_mad',
'nebula_core',
'nebula_sql',
'cppunit',
+34 -21
View File
@@ -36,12 +36,11 @@
/* Virtual Machine :: Constructor/Destructor */
/* ************************************************************************** */
VirtualMachine::VirtualMachine(int id):
VirtualMachine::VirtualMachine(int id, VirtualMachineTemplate * _vm_template):
PoolObjectSQL(id),
uid(-1),
last_poll(0),
name(""),
vm_template(),
state(INIT),
lcm_state(LCM_INIT),
stime(time(0)),
@@ -56,6 +55,14 @@ VirtualMachine::VirtualMachine(int id):
previous_history(0),
_log(0)
{
if (_vm_template != 0)
{
vm_template = _vm_template;
}
else
{
vm_template = new VirtualMachineTemplate;
}
}
VirtualMachine::~VirtualMachine()
@@ -74,6 +81,11 @@ VirtualMachine::~VirtualMachine()
{
delete _log;
}
if ( vm_template != 0 )
{
delete vm_template;
}
}
/* ************************************************************************** */
@@ -140,7 +152,7 @@ int VirtualMachine::select_cb(void *nil, int num, char **values, char **names)
last_seq = atoi(values[LAST_SEQ]);
// Virtual Machine template ID is the VM ID
vm_template.id = oid;
vm_template->id = oid;
return 0;
}
@@ -176,7 +188,7 @@ int VirtualMachine::select(SqlDB * db)
}
//Get the template
rc = vm_template.select(db);
rc = vm_template->select(db);
if (rc != 0)
{
@@ -270,9 +282,9 @@ int VirtualMachine::insert(SqlDB * db)
// -----------------------------------------------------------------------
// Set a template ID if it wasn't already assigned
// ------------------------------------------------------------------------
if ( vm_template.id == -1 )
if ( vm_template->id == -1 )
{
vm_template.id = oid;
vm_template->id = oid;
}
// -----------------------------------------------------------------------
@@ -283,7 +295,7 @@ int VirtualMachine::insert(SqlDB * db)
attr = new SingleAttribute("VMID",value);
vm_template.set(attr);
vm_template->set(attr);
get_template_attribute("NAME",name);
@@ -294,7 +306,7 @@ int VirtualMachine::insert(SqlDB * db)
name = oss.str();
attr = new SingleAttribute("NAME",name);
vm_template.set(attr);
vm_template->set(attr);
}
this->name = name;
@@ -345,7 +357,7 @@ int VirtualMachine::insert(SqlDB * db)
// Insert the template first, so we get a valid template ID. Then the VM
// ------------------------------------------------------------------------
rc = vm_template.insert(db);
rc = vm_template->insert(db);
if ( rc != 0 )
{
@@ -363,7 +375,7 @@ int VirtualMachine::insert(SqlDB * db)
error_update:
NebulaLog::log("ONE",Log::ERROR, "Can not update VM in the database");
vm_template.drop(db);
vm_template->drop(db);
goto error_common;
error_template:
@@ -385,6 +397,7 @@ error_context:
error_requirements:
NebulaLog::log("ONE",Log::ERROR, "Could not parse REQUIREMENTS for VM");
goto error_common;
error_common:
release_network_leases();
@@ -405,7 +418,7 @@ int VirtualMachine::parse_context()
string * str;
string parsed;
num = vm_template.remove("CONTEXT", array_context);
num = vm_template->remove("CONTEXT", array_context);
if ( num == 0 )
{
@@ -437,7 +450,7 @@ int VirtualMachine::parse_context()
context_parsed = new VectorAttribute("CONTEXT");
context_parsed->unmarshall(parsed," @^_^@ ");
vm_template.set(context_parsed);
vm_template->set(context_parsed);
}
/* --- Delete old context attributes --- */
@@ -463,7 +476,7 @@ void VirtualMachine::parse_graphics()
vector<Attribute *> array_graphics;
VectorAttribute * graphics;
num = vm_template.get("GRAPHICS", array_graphics);
num = vm_template->get("GRAPHICS", array_graphics);
if ( num == 0 )
{
@@ -510,7 +523,7 @@ int VirtualMachine::parse_requirements()
string parsed;
num = vm_template.remove("REQUIREMENTS", array_reqs);
num = vm_template->remove("REQUIREMENTS", array_reqs);
if ( num == 0 )
{
@@ -532,7 +545,7 @@ int VirtualMachine::parse_requirements()
SingleAttribute * reqs_parsed;
reqs_parsed = new SingleAttribute("REQUIREMENTS",parsed);
vm_template.set(reqs_parsed);
vm_template->set(reqs_parsed);
}
/* --- Delete old requirements attributes --- */
@@ -802,7 +815,7 @@ int VirtualMachine::get_disk_images()
Nebula& nd = Nebula::instance();
ipool = nd.get_ipool();
num_disks = vm_template.get("DISK",disks);
num_disks = vm_template->get("DISK",disks);
for(int i=0, index=0; i<num_disks; i++)
{
@@ -852,7 +865,7 @@ void VirtualMachine::release_disk_images()
continue;
}
iid = disk->vector_value("IID");
iid = disk->vector_value("IMAGE_ID");
if ( iid.empty() )
{
@@ -885,7 +898,7 @@ int VirtualMachine::get_network_leases()
Nebula& nd = Nebula::instance();
vnpool = nd.get_vnpool();
num_nics = vm_template.get("NIC",nics);
num_nics = vm_template->get("NIC",nics);
for(int i=0; i<num_nics; i++)
{
@@ -935,7 +948,7 @@ void VirtualMachine::release_network_leases()
continue;
}
vnid = nic->vector_value("VNID");
vnid = nic->vector_value("NETWORK_ID");
if ( vnid.empty() )
{
@@ -1125,7 +1138,7 @@ string& VirtualMachine::to_xml(string& xml) const
<< "<NET_TX>" << net_tx << "</NET_TX>"
<< "<NET_RX>" << net_rx << "</NET_RX>"
<< "<LAST_SEQ>" << last_seq << "</LAST_SEQ>"
<< vm_template.to_xml(template_xml);
<< vm_template->to_xml(template_xml);
if ( hasHistory() )
{
@@ -1162,7 +1175,7 @@ string& VirtualMachine::to_str(string& str) const
<< "NET TX : " << net_tx << endl
<< "NET RX : " << net_rx << endl
<< "LAST SEQ : " << last_seq << endl
<< "Template" << endl << vm_template.to_str(template_str) << endl;
<< "Template" << endl << vm_template->to_str(template_str) << endl;
if ( hasHistory() )
{
+2 -23
View File
@@ -151,19 +151,16 @@ VirtualMachinePool::VirtualMachinePool(SqlDB * db,
int VirtualMachinePool::allocate (
int uid,
const string& stemplate,
VirtualMachineTemplate * vm_template,
int * oid,
bool on_hold)
{
VirtualMachine * vm;
char * error_msg;
int rc;
// ------------------------------------------------------------------------
// Build a new Virtual Machine object
// ------------------------------------------------------------------------
vm = new VirtualMachine;
vm = new VirtualMachine(-1,vm_template);
if (on_hold == true)
{
@@ -176,24 +173,6 @@ int VirtualMachinePool::allocate (
vm->uid = uid;
// ------------------------------------------------------------------------
// Parse template
// ------------------------------------------------------------------------
rc = vm->vm_template.parse(stemplate,&error_msg);
if ( rc != 0 )
{
ostringstream oss;
oss << error_msg;
NebulaLog::log("ONE", Log::ERROR, oss);
free(error_msg);
delete vm;
return -1;
}
// ------------------------------------------------------------------------
// Insert the Object in the pool
// ------------------------------------------------------------------------
+3 -1
View File
@@ -48,6 +48,7 @@ main_env.Append(LIBPATH=[
cwd + '/src/template',
cwd + '/src/vm',
cwd + '/src/hm',
cwd + '/src/authm',
cwd + '/src/mad',
cwd + '/src/vnm',
cwd + '/src/um',
@@ -58,12 +59,13 @@ main_env.Append(LIBPATH=[
main_env.Append(LIBS=[
'nebula_um',
'nebula_vm',
'nebula_mad',
'nebula_hm',
'nebula_vnm',
'nebula_authm',
'nebula_template',
'nebula_pool',
'nebula_image',
'nebula_mad',
'nebula_common',
'nebula_log',
'nebula_core',
+49 -11
View File
@@ -80,6 +80,40 @@ const string xml_history_dump =
const string replacement = "0000000000";
/* ************************************************************************* */
/* ************************************************************************* */
class VirtualMachinePoolFriend : public VirtualMachinePool
{
public:
VirtualMachinePoolFriend(SqlDB * db, vector<const Attribute *> hook_mads):
VirtualMachinePool(db, hook_mads)
{};
int allocate (
int uid,
const string& stemplate,
int * oid,
bool on_hold = false)
{
VirtualMachineTemplate * vm_template;
char * error_msg = 0;
int rc;
vm_template = new VirtualMachineTemplate;
rc = vm_template->parse(stemplate,&error_msg);
if( rc == 0 )
{
return VirtualMachinePool::allocate(uid, vm_template, oid, on_hold);
}
else
{
return -1;
}
};
};
/* ************************************************************************* */
/* ************************************************************************* */
@@ -114,15 +148,15 @@ protected:
{
// The VM pool needs a vector containing the vm hooks
vector<const Attribute *> vm_hooks;
return new VirtualMachinePool(db, vm_hooks);
return new VirtualMachinePoolFriend(db, vm_hooks);
};
int allocate(int index)
{
int oid;
return ((VirtualMachinePool*)pool)->allocate(uids[index],
templates[index],
&oid, false);
return ((VirtualMachinePoolFriend*)pool)->allocate( uids[index],
templates[index],
&oid, false);
};
void check(int index, PoolObjectSQL* obj)
@@ -231,7 +265,8 @@ public:
void dump()
{
VirtualMachinePool * vmp = static_cast<VirtualMachinePool*>(pool);
VirtualMachinePoolFriend * vmp =
static_cast<VirtualMachinePoolFriend*>(pool);
set_up_user_pool();
@@ -253,7 +288,8 @@ public:
void dump_where()
{
VirtualMachinePool * vmp = static_cast<VirtualMachinePool*>(pool);
VirtualMachinePoolFriend * vmp =
static_cast<VirtualMachinePoolFriend*>(pool);
set_up_user_pool();
@@ -275,7 +311,8 @@ public:
void dump_history()
{
VirtualMachinePool * vmp = static_cast<VirtualMachinePool*>(pool);
VirtualMachinePoolFriend * vmp =
static_cast<VirtualMachinePoolFriend*>(pool);
VirtualMachine* vm;
string hostnames[] = {"A_hostname", "B_hostname", "C_hostname"};
@@ -374,8 +411,9 @@ public:
void history()
{
VirtualMachine * vm;
VirtualMachinePool * vmp = static_cast<VirtualMachinePool*>(pool);
VirtualMachine * vm;
VirtualMachinePoolFriend * vmp =
static_cast<VirtualMachinePoolFriend*>(pool);
int rc, oid;
@@ -395,7 +433,7 @@ public:
// Add a history item
vm->add_history(0, hostname, vm_dir, vmm_mad, tm_mad);
rc = vmp->update(vm);
rc = vmp->update(vm);
CPPUNIT_ASSERT( rc == 0 );
rc = vmp->update_history(vm);
@@ -403,7 +441,7 @@ public:
vm->add_history(0, new_hostname, vm_dir, vmm_mad, tm_mad);
rc = vmp->update(vm);
rc = vmp->update(vm);
CPPUNIT_ASSERT( rc == 0 );
vm->set_reason(History::USER);
+37 -20
View File
@@ -22,17 +22,30 @@
#include "RangedLeases.h"
#include "FixedLeases.h"
#include "AuthManager.h"
#include "UserPool.h"
/* ************************************************************************** */
/* Virtual Network :: Constructor/Destructor */
/* ************************************************************************** */
VirtualNetwork::VirtualNetwork():
VirtualNetwork::VirtualNetwork(VirtualNetworkTemplate *_vn_template):
PoolObjectSQL(-1),
name(""),
uid(-1),
bridge(""),
type(UNINITIALIZED),
leases(0){};
leases(0)
{
if (_vn_template != 0)
{
vn_template = _vn_template;
}
else
{
vn_template = new VirtualNetworkTemplate;
}
};
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
@@ -43,6 +56,11 @@ VirtualNetwork::~VirtualNetwork()
{
delete leases;
}
if (vn_template != 0)
{
delete vn_template;
}
}
/* ************************************************************************** */
@@ -86,7 +104,7 @@ int VirtualNetwork::select_cb(void * nil, int num, char **values, char **names)
public_vnet = atoi(values[PUBLIC]);
// Virtual Network template ID is the Network ID
vn_template.id = oid;
vn_template->id = oid;
return 0;
}
@@ -125,7 +143,7 @@ int VirtualNetwork::select(SqlDB * db)
}
//Get the template
rc = vn_template.select(db);
rc = vn_template->select(db);
if (rc != 0)
{
@@ -312,16 +330,16 @@ int VirtualNetwork::insert(SqlDB * db)
public_vnet = (pub == "YES");
vn_template.erase("PUBLIC");
vn_template->erase("PUBLIC");
// ------------ TEMPLATE --------------------
// ------------ INSERT THE TEMPLATE --------------------
if ( vn_template.id == -1 )
if ( vn_template->id == -1 )
{
vn_template.id = oid;
vn_template->id = oid;
}
rc = vn_template.insert(db);
rc = vn_template->insert(db);
if ( rc != 0 )
{
@@ -422,7 +440,7 @@ error_template:
error_update:
ose << "Can not update Virtual Network id " << oid;
vn_template.drop(db);
vn_template->drop(db);
goto error_common;
error_addr:
@@ -503,7 +521,7 @@ int VirtualNetwork::vn_drop(SqlDB * db)
ostringstream oss;
int rc;
vn_template.drop(db);
vn_template->drop(db);
if ( leases != 0 )
{
@@ -555,7 +573,7 @@ string& VirtualNetwork::to_xml(string& xml) const
"<TYPE>" << type << "</TYPE>" <<
"<BRIDGE>" << bridge << "</BRIDGE>" <<
"<PUBLIC>" << public_vnet << "</PUBLIC>" <<
vn_template.to_xml(template_xml);
vn_template->to_xml(template_xml);
if (leases)
{
os << leases->to_xml(leases_xml);
@@ -593,7 +611,8 @@ string& VirtualNetwork::to_str(string& str) const
os << "Bridge : " << bridge << endl;
os << "Public : " << public_vnet << endl << endl;
os << "....: Template :...." << vn_template.to_str(template_str) << endl << endl;
os << "....: Template :...." << vn_template->to_str(template_str) << endl <<
endl;
if (leases)
{
@@ -612,7 +631,6 @@ int VirtualNetwork::nic_attribute(VectorAttribute *nic, int vid)
{
int rc;
string network;
string model;
string ip;
string mac;
@@ -621,7 +639,6 @@ int VirtualNetwork::nic_attribute(VectorAttribute *nic, int vid)
map<string,string> new_nic;
network = nic->vector_value("NETWORK");
model = nic->vector_value("MODEL");
ip = nic->vector_value("IP");
vnid << oid;
@@ -648,11 +665,11 @@ int VirtualNetwork::nic_attribute(VectorAttribute *nic, int vid)
// NEW NIC ATTRIBUTES
//--------------------------------------------------------------------------
new_nic.insert(make_pair("NETWORK",network));
new_nic.insert(make_pair("MAC" ,mac));
new_nic.insert(make_pair("BRIDGE" ,bridge));
new_nic.insert(make_pair("VNID" ,vnid.str()));
new_nic.insert(make_pair("IP" ,ip));
new_nic.insert(make_pair("NETWORK" ,name));
new_nic.insert(make_pair("MAC" ,mac));
new_nic.insert(make_pair("BRIDGE" ,bridge));
new_nic.insert(make_pair("NETWORK_ID",vnid.str()));
new_nic.insert(make_pair("IP" ,ip));
if (!model.empty())
{
+99 -22
View File
@@ -17,6 +17,7 @@
#include "VirtualNetworkPool.h"
#include "NebulaLog.h"
#include "AuthManager.h"
#include <sstream>
#include <ctype.h>
@@ -70,35 +71,15 @@ VirtualNetworkPool::VirtualNetworkPool(SqlDB * db,
int VirtualNetworkPool::allocate (
int uid,
const string& stemplate,
VirtualNetworkTemplate * vn_template,
int * oid)
{
VirtualNetwork * vn;
char * error_msg;
int rc;
// Build a new Virtual Network object
vn = new VirtualNetwork();
vn = new VirtualNetwork(vn_template);
vn->uid = uid;
rc = vn->vn_template.parse(stemplate,&error_msg);
if ( rc != 0 )
{
ostringstream oss;
oss << error_msg;
NebulaLog::log("VNM", Log::ERROR, oss);
free(error_msg);
delete vn;
return -1;
}
// Insert the VN in the pool so we have a valid OID
*oid = PoolSQL::allocate(vn);
return *oid;
@@ -214,3 +195,99 @@ int VirtualNetworkPool::dump(ostringstream& oss, const string& where)
return rc;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
int VirtualNetworkPool::nic_attribute(VectorAttribute * nic, int vid)
{
string network;
VirtualNetwork * vnet = 0;
network = nic->vector_value("NETWORK");
if (network.empty())
{
istringstream is;
int network_id;
network = nic->vector_value("NETWORK_ID");
if(network.empty())
{
return -2;
}
is.str(network);
is >> network_id;
if( !is.fail() )
{
vnet = get(network_id,true);
}
}
else
{
vnet = get(network,true);
}
if (vnet == 0)
{
return -1;
}
int rc = vnet->nic_attribute(nic,vid);
vnet->unlock();
return rc;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void VirtualNetworkPool::authorize_nic(VectorAttribute * nic, AuthRequest * ar)
{
string network;
VirtualNetwork * vnet = 0;
network = nic->vector_value("NETWORK");
if (network.empty())
{
istringstream is;
int network_id;
network = nic->vector_value("NETWORK_ID");
if(network.empty())
{
return;
}
is.str(network);
is >> network_id;
if( !is.fail() )
{
vnet = get(network_id,true);
}
}
else
{
vnet = get(network,true);
}
if (vnet == 0)
{
return;
}
ar->add_auth(AuthRequest::NET,
vnet->get_vnid(),
AuthRequest::USE,
vnet->get_uid(),
vnet->isPublic());
vnet->unlock();
}
+4
View File
@@ -40,7 +40,9 @@ main_env.Append(CPPPATH=[
# Library dirs
main_env.Append(LIBPATH=[
cwd + '/src/authm',
cwd + '/src/common',
cwd + '/src/mad',
cwd + '/src/nebula',
cwd + '/src/sql',
cwd + '/src/log',
@@ -54,9 +56,11 @@ main_env.Append(LIBS=[
'nebula_log',
'nebula_um',
'nebula_vnm',
'nebula_authm',
'nebula_template',
'nebula_pool',
'nebula_common',
'nebula_mad',
'nebula_core',
'nebula_sql',
'cppunit',
+217 -25
View File
@@ -85,6 +85,41 @@ const string xml_dump_where =
/* ************************************************************************* */
/* ************************************************************************* */
class VirtualNetworkPoolFriend : public VirtualNetworkPool
{
public:
VirtualNetworkPoolFriend( SqlDB * db,
const string& str_mac_prefix,
int default_size):
VirtualNetworkPool( db, str_mac_prefix, default_size)
{};
int allocate(const int& uid, const std::string& stemplate, int* oid)
{
VirtualNetworkTemplate * vn_template;
char * error_msg = 0;
int rc;
vn_template = new VirtualNetworkTemplate;
rc = vn_template->parse(stemplate,&error_msg);
if( rc == 0 )
{
return VirtualNetworkPool::allocate(uid, vn_template, oid);
}
else
{
return -1;
}
};
};
/* ************************************************************************* */
/* ************************************************************************* */
class VirtualNetworkPoolTest : public PoolTest
{
CPPUNIT_TEST_SUITE (VirtualNetworkPoolTest);
@@ -107,6 +142,7 @@ class VirtualNetworkPoolTest : public PoolTest
CPPUNIT_TEST (overlapping_leases_rr);
CPPUNIT_TEST (drop_leases);
CPPUNIT_TEST (public_attribute);
CPPUNIT_TEST (vnpool_nic_attribute);
CPPUNIT_TEST_SUITE_END ();
@@ -127,7 +163,7 @@ protected:
int allocate(int index)
{
int oid;
return ((VirtualNetworkPool*)pool)->allocate(uids[index],
return ((VirtualNetworkPoolFriend*)pool)->allocate(uids[index],
templates[index], &oid);
};
@@ -181,9 +217,10 @@ public:
void allocate_rcs()
{
VirtualNetworkPool * vnpool = static_cast<VirtualNetworkPool *>(pool);
VirtualNetworkPoolFriend * vnpool =
static_cast<VirtualNetworkPoolFriend *>(pool);
VirtualNetwork * vn;
int rc;
int rc;
// Check case
rc = allocate(2);
@@ -207,6 +244,9 @@ public:
CPPUNIT_ASSERT( rc == -1 );
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void get_using_name()
{
VirtualNetworkPool * vnpool = static_cast<VirtualNetworkPool *>(pool);
@@ -235,6 +275,9 @@ public:
check(1, vn);
};
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void wrong_get_name()
{
VirtualNetworkPool * vnpool = static_cast<VirtualNetworkPool *>(pool);
@@ -252,16 +295,23 @@ public:
CPPUNIT_ASSERT( vn == 0 );
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void update()
{
// TODO
};
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void size()
{
VirtualNetworkPool * vnpool = static_cast<VirtualNetworkPool*>(pool);
VirtualNetworkPoolFriend * vnpool =
static_cast<VirtualNetworkPoolFriend*>(pool);
int rc;
int rc;
VirtualNetwork* vnet;
string templ[] = {
@@ -338,10 +388,14 @@ public:
}
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void duplicates()
{
int rc, oid_0, oid_1;
VirtualNetworkPool * vnpool = static_cast<VirtualNetworkPool *>(pool);
VirtualNetworkPoolFriend * vnpool =
static_cast<VirtualNetworkPoolFriend *>(pool);
VirtualNetwork * vnet;
// Allocate a vnet
@@ -382,9 +436,13 @@ public:
check(0, vnet);
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void dump()
{
VirtualNetworkPool * vnpool = static_cast<VirtualNetworkPool*>(pool);
VirtualNetworkPoolFriend * vnpool =
static_cast<VirtualNetworkPoolFriend*>(pool);
int oid, rc;
ostringstream oss;
@@ -401,9 +459,13 @@ public:
CPPUNIT_ASSERT( result == xml_dump );
};
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void dump_where()
{
VirtualNetworkPool * vnpool = static_cast<VirtualNetworkPool*>(pool);
VirtualNetworkPoolFriend * vnpool =
static_cast<VirtualNetworkPoolFriend*>(pool);
int oid, rc;
ostringstream oss;
@@ -421,8 +483,13 @@ public:
CPPUNIT_ASSERT( result == xml_dump_where );
};
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void fixed_leases()
{
VirtualNetworkPoolFriend * vnpool =
static_cast<VirtualNetworkPoolFriend*>(pool);
int rc, oid;
VirtualNetwork *vn;
@@ -435,7 +502,7 @@ public:
oid = allocate(0);
CPPUNIT_ASSERT( oid != -1 );
vn = ((VirtualNetworkPool*)pool)->get(oid, false);
vn = vnpool->get(oid, false);
CPPUNIT_ASSERT( vn != 0 );
// Ask for an IP
@@ -454,7 +521,7 @@ public:
pool->clean();
// Read the Vnet from the DB
vn = ((VirtualNetworkPool*)pool)->get(oid, false);
vn = vnpool->get(oid, false);
CPPUNIT_ASSERT( vn != 0 );
// Ask for another IP
@@ -495,8 +562,13 @@ public:
CPPUNIT_ASSERT( bridge == "br1" );
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void ranged_leases()
{
VirtualNetworkPoolFriend * vnpool =
static_cast<VirtualNetworkPoolFriend*>(pool);
int rc, oid;
VirtualNetwork *vn;
@@ -512,10 +584,10 @@ public:
"NETWORK_ADDRESS = 192.168.50.0\n";
((VirtualNetworkPool*)pool)->allocate(45, tmpl, &oid);
vnpool->allocate(45, tmpl, &oid);
CPPUNIT_ASSERT( oid != -1 );
vn = ((VirtualNetworkPool*)pool)->get(oid, false);
vn = vnpool->get(oid, false);
CPPUNIT_ASSERT( vn != 0 );
// Ask for an IP
@@ -533,7 +605,7 @@ public:
pool->clean();
// Read the Vnet from the DB
vn = ((VirtualNetworkPool*)pool)->get(oid, false);
vn = vnpool->get(oid, false);
CPPUNIT_ASSERT( vn != 0 );
// Ask for the IP already in use
@@ -587,8 +659,13 @@ public:
CPPUNIT_ASSERT( bridge == "bridge0" );
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void wrong_leases()
{
VirtualNetworkPoolFriend * vnpool =
static_cast<VirtualNetworkPoolFriend*>(pool);
int rc, oid_0, oid_1;
VirtualNetwork *vn;
@@ -601,7 +678,7 @@ public:
oid_0 = allocate(0);
CPPUNIT_ASSERT( oid_0 != -1 );
vn = ((VirtualNetworkPool*)pool)->get(oid_0, false);
vn = vnpool->get(oid_0, false);
CPPUNIT_ASSERT( vn != 0 );
// Ask for a non-defined IP
@@ -616,7 +693,7 @@ public:
oid_1 = allocate(1);
CPPUNIT_ASSERT( oid_1 != -1 );
vn = ((VirtualNetworkPool*)pool)->get(oid_1, false);
vn = vnpool->get(oid_1, false);
CPPUNIT_ASSERT( vn != 0 );
// Ask for an out of range IP
@@ -635,6 +712,9 @@ public:
CPPUNIT_ASSERT( rc == -1 );
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void overlapping_leases_ff()
{
// It is a different Vnet from #0: different user, name, and bridge.
@@ -649,6 +729,9 @@ public:
overlapping_leases(templates[0], tmpl_B);
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void overlapping_leases_fr()
{
// Now use a ranged network, also containig the IP 130.10.0.1
@@ -662,6 +745,9 @@ public:
overlapping_leases(templates[0], tmpl_B);
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void overlapping_leases_rf()
{
// It is a different Vnet from #0: different user, name, and bridge.
@@ -676,6 +762,9 @@ public:
overlapping_leases(tmpl_A, templates[0]);
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void overlapping_leases_rr()
{
// It is a different Vnet from #0: different user, name, and bridge.
@@ -697,10 +786,14 @@ public:
overlapping_leases(tmpl_A, tmpl_B);
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
// Runs a test using the given templates
void overlapping_leases(string tmpl_A, string tmpl_B)
{
VirtualNetworkPoolFriend * vnpool =
static_cast<VirtualNetworkPoolFriend*>(pool);
int rc, oid_0, oid_new;
VirtualNetwork *vn;
@@ -712,15 +805,15 @@ public:
// First VNet template
((VirtualNetworkPool*)pool)->allocate(13, tmpl_A, &oid_0);
vnpool->allocate(13, tmpl_A, &oid_0);
CPPUNIT_ASSERT( oid_0 != -1 );
// Second VNet
((VirtualNetworkPool*)pool)->allocate(45, tmpl_B, &oid_new);
vnpool->allocate(45, tmpl_B, &oid_new);
CPPUNIT_ASSERT( oid_new != -1 );
// Get this second VNet
vn = ((VirtualNetworkPool*)pool)->get(oid_new, false);
vn = vnpool->get(oid_new, false);
CPPUNIT_ASSERT( vn != 0 );
// Set a lease. Ask for the IP that both Vnets have
@@ -742,7 +835,7 @@ public:
// Now check that the first VNet has that IP available
vn = ((VirtualNetworkPool*)pool)->get(oid_0, false);
vn = vnpool->get(oid_0, false);
CPPUNIT_ASSERT( vn != 0 );
// Ask the first VNet for the IP that both Vnets have
@@ -759,7 +852,7 @@ public:
// Get again the second VNet
vn = ((VirtualNetworkPool*)pool)->get(oid_new, false);
vn = vnpool->get(oid_new, false);
CPPUNIT_ASSERT( vn != 0 );
// Ask for the IP, should be still used
@@ -778,8 +871,13 @@ public:
CPPUNIT_ASSERT(results.size() == 1);
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void drop_leases()
{
VirtualNetworkPoolFriend * vnpool =
static_cast<VirtualNetworkPoolFriend*>(pool);
int rc, oid;
VirtualNetwork *vn;
@@ -793,7 +891,7 @@ public:
oid = allocate(0);
CPPUNIT_ASSERT( oid != -1 );
vn = ((VirtualNetworkPool*)pool)->get(oid, false);
vn = vnpool->get(oid, false);
CPPUNIT_ASSERT( vn != 0 );
// Drop the VNet
@@ -808,11 +906,14 @@ public:
CPPUNIT_ASSERT(results.size() == 0);
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void public_attribute()
{
int oid;
VirtualNetworkPool * vnp = static_cast<VirtualNetworkPool *>(pool);
VirtualNetworkPoolFriend * vnp =
static_cast<VirtualNetworkPoolFriend*>(pool);
VirtualNetwork * vn;
string templates[] =
@@ -897,12 +998,103 @@ public:
CPPUNIT_ASSERT( vn != 0 );
//cout << endl << i << ":expected " << results[i] << " got " << vn->is_public();
CPPUNIT_ASSERT( vn->is_public() == results[i] );
CPPUNIT_ASSERT( vn->isPublic() == results[i] );
i++;
}
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void vnpool_nic_attribute()
{
VirtualNetworkPoolFriend * vnp =
static_cast<VirtualNetworkPoolFriend *>(pool);
VectorAttribute * disk;
int oid_0, oid_1;
string value;
// ---------------------------------------------------------------------
// Allocate 2 vnets
string template_0 = "NAME = \"Net 0\"\n"
"TYPE = FIXED\n"
"BRIDGE = br1\n"
"LEASES = [IP=130.10.0.1, MAC=50:20:20:20:20:20]";
string template_1 = "NAME = \"Net 1\"\n"
"TYPE = FIXED\n"
"BRIDGE = br2\n"
"LEASES = [IP=130.10.0.5, MAC=50:20:20:20:20:25]";
vnp->allocate(0, template_0, &oid_0);
CPPUNIT_ASSERT( oid_0 == 0 );
vnp->allocate(0, template_1, &oid_1);
CPPUNIT_ASSERT( oid_1 == 1 );
// Disk using network 0
disk = new VectorAttribute("DISK");
disk->replace("NETWORK", "Net 0");
((VirtualNetworkPool*)vnp)->nic_attribute(disk, 0);
value = "";
value = disk->vector_value("NETWORK");
CPPUNIT_ASSERT( value == "Net 0" );
value = "";
value = disk->vector_value("MAC");
CPPUNIT_ASSERT( value == "50:20:20:20:20:20" );
value = "";
value = disk->vector_value("BRIDGE");
CPPUNIT_ASSERT( value == "br1" );
value = "";
value = disk->vector_value("NETWORK_ID");
CPPUNIT_ASSERT( value == "0" );
value = "";
value = disk->vector_value("IP");
CPPUNIT_ASSERT( value == "130.10.0.1" );
delete disk;
// Disk using network 1 index
disk = new VectorAttribute("DISK");
disk->replace("NETWORK_ID", "1");
((VirtualNetworkPool*)vnp)->nic_attribute(disk, 0);
value = "";
value = disk->vector_value("NETWORK");
CPPUNIT_ASSERT( value == "Net 1" );
value = "";
value = disk->vector_value("MAC");
CPPUNIT_ASSERT( value == "50:20:20:20:20:25" );
value = "";
value = disk->vector_value("BRIDGE");
CPPUNIT_ASSERT( value == "br2" );
value = "";
value = disk->vector_value("NETWORK_ID");
CPPUNIT_ASSERT( value == "1" );
value = "";
value = disk->vector_value("IP");
CPPUNIT_ASSERT( value == "130.10.0.5" );
delete disk;
}
};
/* ************************************************************************* */