2008-06-17 20:27:32 +04:00
/* -------------------------------------------------------------------------- */
2019-01-16 13:27:59 +03:00
/* Copyright 2002-2019, OpenNebula Project, OpenNebula Systems */
2008-06-17 20:27:32 +04:00
/* */
/* 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 POOL_SQL_H_
# define POOL_SQL_H_
# include <string>
2010-04-03 18:54:54 +04:00
# include "SqlDB.h"
2008-06-17 20:27:32 +04:00
# include "PoolObjectSQL.h"
2018-03-18 01:31:52 +03:00
# include "PoolSQLCache.h"
2008-06-17 20:27:32 +04:00
# include "Log.h"
2009-03-27 03:32:02 +03:00
# include "Hook.h"
2008-06-17 20:27:32 +04:00
using namespace std ;
/**
* PoolSQL class . Provides a base class to implement persistent generic pools .
2010-04-03 18:54:54 +04:00
* The PoolSQL provides a synchronization mechanism ( mutex ) to operate in
* multithreaded applications . Any modification or access function to the pool
2008-06-17 20:27:32 +04:00
* SHOULD block the mutex .
*/
2018-03-18 01:31:52 +03:00
class PoolSQL : public Hookable
2008-06-17 20:27:32 +04:00
{
public :
/**
* Initializes the oid counter . This function sets lastOID to
* the last used Object identifier by querying the corresponding database
* table . This function SHOULD be called before any pool related function .
* @ param _db a pointer to the database
2012-04-20 12:23:51 +04:00
* @ param _table the name of the table supporting the pool ( to set the oid
2008-06-17 20:27:32 +04:00
* counter ) . If null the OID counter is not updated .
*/
2017-06-21 04:22:56 +03:00
PoolSQL ( SqlDB * _db , const char * _table ) ;
2008-06-17 20:27:32 +04:00
virtual ~ PoolSQL ( ) ;
/**
* Allocates a new object , writting it in the pool database . No memory is
* allocated for the object .
* @ param objsql an initialized ObjectSQL
* @ return the oid assigned to the object or - 1 in case of failure
*/
virtual int allocate (
2010-08-05 21:28:28 +04:00
PoolObjectSQL * objsql ,
string & error_str ) ;
2008-06-17 20:27:32 +04:00
/**
2010-04-03 18:54:54 +04:00
* Gets an object from the pool ( if needed the object is loaded from the
2008-06-17 20:27:32 +04:00
* database ) .
* @ param oid the object unique identifier
2010-04-03 18:54:54 +04:00
*
2008-06-17 20:27:32 +04:00
* @ return a pointer to the object , 0 in case of failure
*/
2018-03-18 01:31:52 +03:00
PoolObjectSQL * get ( int oid ) ;
2008-06-17 20:27:32 +04:00
2018-10-09 12:05:08 +03:00
/**
* Gets a read only object from the pool ( if needed the object is loaded from the
* database ) .
* @ param oid the object unique identifier
*
* @ return a pointer to the object , 0 in case of failure
*/
PoolObjectSQL * get_ro ( int oid ) ;
2012-01-25 18:54:57 +04:00
/**
2018-03-18 01:31:52 +03:00
* Check if there is an object with the same for a given user
* @ param name of object
* @ param ouid of user
2012-01-25 18:54:57 +04:00
*
2018-03-18 01:31:52 +03:00
* @ return oid of the object if it exists , - 1 otherwise
2012-01-25 18:54:57 +04:00
*/
2018-03-18 01:31:52 +03:00
int exist ( const string & name , int ouid )
{
return PoolObjectSQL : : select_oid ( db , table . c_str ( ) , name , ouid ) ;
}
int exist ( const string & name )
{
return PoolObjectSQL : : select_oid ( db , table . c_str ( ) , name , - 1 ) ;
}
int exist ( int oid )
{
return PoolObjectSQL : : exist ( db , table . c_str ( ) , oid ) ;
}
2012-01-25 18:54:57 +04:00
2018-11-20 19:24:59 +03:00
void exist ( const string & id_str , std : : set < int > & id_list ) ;
2008-06-17 20:27:32 +04:00
/**
* Finds a set objects that satisfies a given condition
* @ param oids a vector with the oids of the objects .
* @ param the name of the DB table .
* @ param where condition in SQL format .
2010-04-03 18:54:54 +04:00
*
* @ return 0 on success
2008-06-17 20:27:32 +04:00
*/
virtual int search (
vector < int > & oids ,
const char * table ,
const string & where ) ;
2010-04-03 18:54:54 +04:00
2013-06-27 03:11:41 +04:00
/**
* List the objects in the pool
* @ param oids a vector with the oids of the objects .
2013-07-12 18:51:36 +04:00
* @ param table the name of the DB table .
2013-06-27 03:11:41 +04:00
*
* @ return 0 on success
*/
int list (
vector < int > & oids ,
const char * table )
{
return search ( oids , table , " " ) ;
}
2008-06-17 20:27:32 +04:00
/**
* Updates the object ' s data in the data base . The object mutex SHOULD be
* locked .
* @ param objsql a pointer to the object
2010-04-03 18:54:54 +04:00
*
2008-06-17 20:27:32 +04:00
* @ return 0 on success .
*/
virtual int update (
PoolObjectSQL * objsql )
{
2009-03-27 03:32:02 +03:00
int rc ;
2010-04-03 18:54:54 +04:00
2009-03-27 03:32:02 +03:00
rc = objsql - > update ( db ) ;
2010-04-03 18:54:54 +04:00
2009-03-27 03:32:02 +03:00
if ( rc = = 0 )
{
2009-03-30 01:34:37 +04:00
do_hooks ( objsql , Hook : : UPDATE ) ;
2009-03-27 03:32:02 +03:00
}
2010-04-03 18:54:54 +04:00
2009-03-27 03:32:02 +03:00
return rc ;
2008-06-17 20:27:32 +04:00
} ;
2010-04-03 18:54:54 +04:00
2010-04-06 01:34:09 +04:00
/**
* Drops the object ' s data in the data base . The object mutex SHOULD be
* locked .
* @ param objsql a pointer to the object
2011-06-08 21:18:12 +04:00
* @ param error_msg Error reason , if any
* @ return 0 on success , - 1 DB error
2010-04-06 01:34:09 +04:00
*/
2011-06-08 21:18:12 +04:00
virtual int drop ( PoolObjectSQL * objsql , string & error_msg )
2010-04-06 01:34:09 +04:00
{
2018-03-18 01:31:52 +03:00
int rc = objsql - > drop ( db ) ;
2011-06-08 21:18:12 +04:00
if ( rc ! = 0 )
{
error_msg = " SQL DB error " ;
return - 1 ;
}
2012-10-08 01:33:19 +04:00
else
{
do_hooks ( objsql , Hook : : REMOVE ) ;
}
2011-06-08 21:18:12 +04:00
return 0 ;
2010-04-06 01:34:09 +04:00
} ;
2010-04-21 17:06:26 +04:00
/**
* Dumps the pool in XML format . A filter can be also added to the
* query
* @ param oss the output stream to dump the pool contents
* @ param where filter for the objects , defaults to all
2018-07-24 12:41:41 +03:00
* @ param desc descending order of pool elements
2010-04-21 17:06:26 +04:00
*
* @ return 0 on success
*/
2018-10-09 12:05:08 +03:00
int dump ( string & oss , const string & where , bool desc )
2014-01-13 19:30:43 +04:00
{
2018-07-24 12:41:41 +03:00
return dump ( oss , where , " " , desc ) ;
2014-01-13 19:30:43 +04:00
}
/**
* Dumps the pool in XML format . A filter and limit can be also added
* to the query
* @ param oss the output stream to dump the pool contents
* @ param where filter for the objects , defaults to all
* @ param limit parameters used for pagination
2018-07-24 12:41:41 +03:00
* @ param desc descending order of pool elements
2014-01-13 19:30:43 +04:00
*
* @ return 0 on success
*/
2018-10-09 12:05:08 +03:00
virtual int dump ( string & oss , const string & where ,
2018-07-24 12:41:41 +03:00
const string & limit , bool desc ) = 0 ;
2010-04-21 17:06:26 +04:00
2012-05-05 05:18:25 +04:00
// -------------------------------------------------------------------------
// Function to generate dump filters
// -------------------------------------------------------------------------
2012-05-04 19:27:57 +04:00
/**
2012-10-08 01:33:19 +04:00
* Creates a filter for those objects ( oids ) or objects owned by a given
2012-05-05 05:18:25 +04:00
* group that an user can access based on the ACL rules
* @ param uid the user id
2013-08-23 17:36:43 +04:00
* @ param user_groups Set of group IDs that the user is part of
2012-05-05 05:18:25 +04:00
* @ param auth_object object type
* @ param all returns if the user can access all objects
2014-09-23 22:18:18 +04:00
* @ param disable_all_acl e . g . NET \ *
* @ param disable_cluster_acl e . g . NET / % 100
* @ param disable_group_acl e . g . NET / @ 102
2012-05-05 05:18:25 +04:00
* @ param filter the resulting filter string
2014-09-23 22:18:18 +04:00
*
2012-05-04 19:27:57 +04:00
*/
2012-10-08 01:33:19 +04:00
static void acl_filter ( int uid ,
2013-08-23 17:36:43 +04:00
const set < int > & user_groups ,
2012-05-05 05:18:25 +04:00
PoolObjectSQL : : ObjectType auth_object ,
bool & all ,
2014-09-23 22:18:18 +04:00
bool disable_all_acl ,
bool disable_cluster_acl ,
bool disable_group_acl ,
2012-05-05 05:18:25 +04:00
string & filter ) ;
/**
* Creates a filter for the objects owned by a given user / group
* @ param uid the user id
2016-09-30 18:31:49 +03:00
* @ param gid the primary group of the user
2013-08-23 17:36:43 +04:00
* @ param user_groups Set of group IDs that the user is part of
2012-05-05 05:18:25 +04:00
* @ param filter_flag query type ( ALL , MINE , GROUP )
* @ param all user can access all objects
* @ param filter the resulting filter string
*/
2013-08-23 17:36:43 +04:00
static void usr_filter ( int uid ,
2016-09-30 18:31:49 +03:00
int gid ,
2013-08-23 17:36:43 +04:00
const set < int > & user_groups ,
int filter_flag ,
bool all ,
const string & acl_str ,
string & filter ) ;
2012-05-05 05:18:25 +04:00
/**
* Creates a filter for a given set of objects based on their id
* @ param start_id first id
* @ param end_id last id
* @ param filter the resulting filter string
*/
static void oid_filter ( int start_id ,
int end_id ,
string & filter ) ;
2008-06-17 20:27:32 +04:00
protected :
2012-10-09 13:56:01 +04:00
/**
* Register on " CREATE " and on " REMOVE " hooks for the pool . The hooks are
* meant to be executed locally by the generic AllocateHook and RemoveHook
* classes .
* @ param hook_mads , array of HOOKs to be installed
* @ param remotes_location , path to remotes in the front - end where the
* hooks are installed
*/
2016-02-04 15:10:42 +03:00
void register_hooks ( vector < const VectorAttribute * > hook_mads ,
const string & remotes_location ) ;
2012-10-09 13:56:01 +04:00
2012-04-20 12:23:51 +04:00
/**
* Gets an object from the pool ( if needed the object is loaded from the
* database ) .
* @ param name of the object
* @ param uid id of owner
*
* @ return a pointer to the object , 0 in case of failure
*/
2018-03-18 01:31:52 +03:00
PoolObjectSQL * get ( const string & name , int uid ) ;
2012-04-20 12:23:51 +04:00
2018-10-09 12:05:08 +03:00
/**
* Gets a read only object from the pool ( if needed the object is loaded from the
* database ) .
* @ param name of the object
* @ param uid id of owner
*
* @ return a pointer to the object , 0 in case of failure
*/
PoolObjectSQL * get_ro ( const string & name , int uid ) ;
2008-06-17 20:27:32 +04:00
/**
* Pointer to the database .
*/
2010-04-03 18:54:54 +04:00
SqlDB * db ;
2014-01-13 19:30:43 +04:00
/**
* Dumps the pool in XML format . A filter and limit can be also added
* to the query
* @ param oss the output stream to dump the pool contents
* @ param elem_name Name of the root xml pool name
* @ param table Pool table name
* @ param where filter for the objects , defaults to all
* @ param limit parameters used for pagination
2018-07-24 12:41:41 +03:00
* @ param desc descending order of pool elements
2014-01-13 19:30:43 +04:00
*
* @ return 0 on success
*/
2018-10-09 12:05:08 +03:00
int dump ( string & oss ,
2014-01-13 19:30:43 +04:00
const string & elem_name ,
2018-10-09 12:05:08 +03:00
const string & column ,
2014-01-13 19:30:43 +04:00
const char * table ,
const string & where ,
2018-07-24 12:41:41 +03:00
const string & limit ,
bool desc ) ;
2014-01-13 19:30:43 +04:00
2011-03-09 13:23:58 +03:00
/**
* Dumps the pool in XML format . A filter can be also added to the
* query
* @ param oss the output stream to dump the pool contents
* @ param elem_name Name of the root xml pool name
* @ param table Pool table name
* @ param where filter for the objects , defaults to all
2018-07-24 12:41:41 +03:00
* @ param desc descending order of pool elements
2011-03-09 13:23:58 +03:00
*
* @ return 0 on success
*/
2018-10-09 12:05:08 +03:00
int dump ( string & oss ,
2012-05-05 05:18:25 +04:00
const string & elem_name ,
2012-10-08 01:33:19 +04:00
const char * table ,
2018-07-24 12:41:41 +03:00
const string & where ,
bool desc )
2014-01-13 19:30:43 +04:00
{
2018-10-09 12:05:08 +03:00
return dump ( oss , elem_name , " body " , table , where , " " , desc ) ;
2014-01-13 19:30:43 +04:00
}
2012-05-05 05:18:25 +04:00
/**
* Dumps the output of the custom sql query into an xml
*
* @ param oss The output stream to dump the xml contents
* @ param root_elem_name Name of the root xml element name
* @ param sql_query The SQL query to execute
*
* @ return 0 on success
*/
2018-10-09 12:05:08 +03:00
int dump ( string & oss ,
2012-05-05 05:18:25 +04:00
const string & root_elem_name ,
2012-10-08 01:33:19 +04:00
ostringstream & sql_query ) ;
2011-03-09 13:23:58 +03:00
2011-05-21 04:06:29 +04:00
/* ---------------------------------------------------------------------- */
/* Interface to access the lastOID assigned by the pool */
/* ---------------------------------------------------------------------- */
2011-03-17 23:04:24 +03:00
/**
2011-05-21 04:06:29 +04:00
* Gets the value of the last identifier assigned by the pool
* @ return the lastOID of the pool
2011-03-17 23:04:24 +03:00
*/
2017-05-06 01:20:29 +03:00
int get_lastOID ( ) ;
2011-03-17 23:04:24 +03:00
2011-05-21 04:06:29 +04:00
/**
* Sets the lastOID of the pool and updates the control database
* @ param _lastOID for the pool
*/
2017-05-06 01:20:29 +03:00
void set_lastOID ( int _lastOID ) ;
2011-05-21 04:06:29 +04:00
2008-06-17 20:27:32 +04:00
private :
2011-05-21 04:06:29 +04:00
pthread_mutex_t mutex ;
2008-06-17 20:27:32 +04:00
2011-05-09 18:09:56 +04:00
/**
* Tablename for this pool
*/
2011-05-21 04:06:29 +04:00
string table ;
2011-05-09 18:09:56 +04:00
2008-06-17 20:27:32 +04:00
/**
2018-03-18 01:31:52 +03:00
* The pool cache is implemented with a Map of SQL object pointers ,
* using the OID as key .
2008-06-17 20:27:32 +04:00
*/
2018-03-18 01:31:52 +03:00
PoolSQLCache cache ;
2011-03-05 05:24:11 +03:00
2008-06-17 20:27:32 +04:00
/**
* Factory method , must return an ObjectSQL pointer to an allocated pool
* specific object .
*/
virtual PoolObjectSQL * create ( ) = 0 ;
2010-06-03 13:47:03 +04:00
/**
* Function to lock the pool
*/
void lock ( )
{
pthread_mutex_lock ( & mutex ) ;
} ;
/**
* Function to unlock the pool
*/
void unlock ( )
{
pthread_mutex_unlock ( & mutex ) ;
} ;
2008-06-17 20:27:32 +04:00
} ;
2010-04-21 17:06:26 +04:00
# endif /*POOL_SQL_H_*/