Commit 09b6b338 authored by Marco De Marco's avatar Marco De Marco
Browse files

Servers, sessions, worker thread, and db manager classes added

parent 83c62649

src/Configuration.h

0 → 100644
+177 −0
Original line number Diff line number Diff line 
#ifndef CONFIGURATION_H

#define	CONFIGURATION_H



#include <map>

#include <string>

#include <vector>



#include <boost/shared_ptr.hpp>



namespace DataExporter_ns

{



class Configuration

{

public:

//------------------------------------------------------------------------------

//	[Public] Shared pointer typedef

//------------------------------------------------------------------------------

	typedef boost::shared_ptr<Configuration> SP;



//------------------------------------------------------------------------------

//	[Public] Map typedef

//------------------------------------------------------------------------------

	typedef const std::multimap<const std::string, const std::string> ExportedTablesMap;

	typedef const std::map<const std::string, const std::string> AuthorisedUsersMap;



protected:

//------------------------------------------------------------------------------

//	[Private] Constructor destructor deleter

//------------------------------------------------------------------------------

	Configuration(std::string certificateFile, std::string privateKeyFile,

        std::string dHTempFile, ExportedTablesMap exportedTablesMap,

        AuthorisedUsersMap authorisedUsersMap, std::string storagePath,

        std::string localHost, unsigned int localPort, unsigned int workerNumber,

        std::string databaseHost, unsigned int databasePort,

        std::string databaseUsername, std::string databasePassword,

        unsigned int databaseConnectionNumber) :

        m_certificateFile(certificateFile), m_privateKeyFile(privateKeyFile),

        m_dHTempFile(dHTempFile), m_exportedTablesMap(exportedTablesMap),

        m_authorisedUsersMap(authorisedUsersMap), m_storagePath(storagePath),

         m_localHost(localHost), m_localPort(localPort), m_workerNumber(workerNumber),

        m_databaseHost(databaseHost), m_databasePort(databasePort),

        m_databaseUsername(databaseUsername), m_databasePassword(databasePassword),

        m_databaseConnectionNumber(databaseConnectionNumber) {}



	virtual ~Configuration() {}



	class Deleter;

	friend class Deleter;

	class Deleter

	{

	public:

		void operator()(Configuration* c) { delete c; }

	};



public:

//------------------------------------------------------------------------------

//	[Public] Create class method

//------------------------------------------------------------------------------

	static Configuration::SP create(std::string certificateFile,

        std::string privateKeyFile, std::string dHTempFile,

        ExportedTablesMap exportedTablesMap, AuthorisedUsersMap authorisedUsersMap,

        std::string storagePath, std::string localHost,

         unsigned int localPort, unsigned int workerNumber,

        std::string databaseHost, unsigned int databasePort,

        std::string databaseUsername, std::string databasePassword,

        unsigned int databaseConnectionNumber)

	{

		Configuration::SP c_sp(new Configuration(certificateFile, privateKeyFile,

            dHTempFile, exportedTablesMap, authorisedUsersMap, storagePath,

            localHost, localPort, workerNumber, databaseHost, databasePort,

            databaseUsername, databasePassword, databaseConnectionNumber),

            Configuration::Deleter());



		return c_sp;

	}



//------------------------------------------------------------------------------

//	[Public] Getter methods

//------------------------------------------------------------------------------

	std::string getCertificateFile() const { return m_certificateFile; }

	std::string getPrivateKeyFile() const { return m_privateKeyFile; }

	std::string getDHTempFile() const { return m_dHTempFile; }

    ExportedTablesMap& getExportedTablesMap() const { return m_exportedTablesMap; }

    AuthorisedUsersMap& getAuthorisedUsersMap() const { return m_authorisedUsersMap; }

    std::string getStoragePath() const { return m_storagePath; }

	std::string getLocalHost() const { return m_localHost; }

	unsigned int getLocalPort() const { return m_localPort; }

	unsigned int getWorkerNumber() const { return m_workerNumber; }

	std::string getDatabaseHost() const { return m_databaseHost; }

	unsigned int getDatabasePort() const { return m_databasePort; }

	std::string getDatabaseUsername() const { return m_databaseUsername; }

	std::string getDatabasePassword() const { return m_databasePassword; }

    unsigned int getDatabaseConnectionNumber() const { return m_databaseConnectionNumber; }



//------------------------------------------------------------------------------

//	[Public] Utilities methods

//------------------------------------------------------------------------------

    bool isTableExported(const std::string schema, const std::string table)

    {

        std::pair<ExportedTablesMap::const_iterator, ExportedTablesMap::const_iterator > ret;



        ret = m_exportedTablesMap.equal_range(schema);



        ExportedTablesMap::const_iterator it;



        for(it=ret.first; it!=ret.second; ++it)

        {

            if(it->second.compare(table) == 0)

                return true;

        }



        return false;

    }



    bool isUserAuthorized(const std::string username, const std::string password)

    {

        AuthorisedUsersMap::const_iterator it = m_authorisedUsersMap.find(username);



        if(it!=m_authorisedUsersMap.end() &&

            it->second.compare(password)==0)

            return true;



        return false;

    }



protected:

//------------------------------------------------------------------------------

//	[Private] class variables

//------------------------------------------------------------------------------

	//Absolute path to certificate chain file

	const std::string m_certificateFile;



	//Absolute path to private key file

	const std::string m_privateKeyFile;



	//Absolute path to Diffie Hellman temporary file

	const std::string m_dHTempFile;



    //Exported tables multi map [schema table]

	ExportedTablesMap m_exportedTablesMap;



    //Authorised users map [user password]

	AuthorisedUsersMap m_authorisedUsersMap;



    //Absolute path to storage

    const std::string m_storagePath;



	//Local host address for incoming connection

	const std::string m_localHost;



	//Local port for wait incoming connection

	const unsigned int m_localPort;



	//Number of threads that call io service run methods

	const unsigned int m_workerNumber;



	//Metadata database host

	const std::string m_databaseHost;



	//Metadata database port

	const unsigned int m_databasePort;



	//Metadata database login username

	const std::string m_databaseUsername;



	//Metadata database login password

	const std::string m_databasePassword;



    //Metadata database connections number

    const unsigned int m_databaseConnectionNumber;

};



}   //End of namespace



#endif	/* CONFIGURATION_H */

src/DBManager.cpp

0 → 100644
+80 −0
Original line number Diff line number Diff line 
#include <DBManager.h>



#include <boost/date_time.hpp>



#include <soci/mysql/soci-mysql.h>

#include <soci/use.h>



namespace DataExporter_ns

{



//==============================================================================

//      DBManager::DBManager()

//==============================================================================

DBManager::DBManager(Tango::DeviceImpl* deviceImpl_p,

    Configuration::SP configuration_sp) : Tango::LogAdapter(deviceImpl_p),

    m_configuration_sp(configuration_sp)

{

    DEBUG_STREAM << "DBManager::DBManager()" << endl;

}



//==============================================================================

//      DBManager::DBManager()

//==============================================================================

DBManager::~DBManager()

{

    DEBUG_STREAM << "DBManager::~DBManager()" << endl;

}



//==============================================================================

//      DBManager::DBManager()

//==============================================================================

DBManager::SP DBManager::create(Tango::DeviceImpl* deviceImpl_p,

    Configuration::SP configuration_sp)

{

    DBManager::SP d_sp(new DBManager(deviceImpl_p, configuration_sp),

        DBManager::Deleter());



    return d_sp;

}



//==============================================================================

//      DBManager::connect()

//==============================================================================

void DBManager::connect() throw(soci::soci_error)

{

    DEBUG_STREAM << "DBManager::connect()" << endl;



    boost::mutex::scoped_lock lock(m_connectionPoolMutex);



    unsigned int connectionNumber = m_configuration_sp->getDatabaseConnectionNumber();



    m_connectionPool_sp.reset(new soci::connection_pool(connectionNumber));



    std::stringstream connection;

    connection << " host=" << m_configuration_sp->getDatabaseHost();

    connection << " port=" << m_configuration_sp->getDatabasePort();

    connection << " user=" << m_configuration_sp->getDatabaseUsername();

    connection << " password=" << m_configuration_sp->getDatabasePassword();



    #ifdef VERBOSE_DEBUG

        INFO_STREAM << "DBManager::connect(): " << connection.str() << endl;

    #endif



    for(unsigned int i=0; i<connectionNumber; ++i)

        m_connectionPool_sp->at(i).open(soci::mysql, connection.str());

}



//==============================================================================

//      DBManager::disconnect()

//==============================================================================

void DBManager::disconnect()

{

    DEBUG_STREAM << "DBManager::disconnect()" << endl;



    boost::mutex::scoped_lock lock(m_connectionPoolMutex);



    m_connectionPool_sp.reset();

}



}   //namespace

src/DBManager.h

0 → 100644
+80 −0
Original line number Diff line number Diff line 
#ifndef DBMANAGER_H

#define	DBMANAGER_H



#include <Configuration.h>



#include <tango.h>



#include <ctime>



#include <boost/tuple/tuple.hpp>

#include <boost/optional/optional.hpp>

#include <boost/scoped_ptr.hpp>

#include <boost/thread/mutex.hpp>



#include <soci/soci.h>

#include <soci/error.h>

#include <soci/row.h>

#include <soci/rowset.h>

#include <soci/boost-tuple.h>

#include <soci/boost-optional.h>

#include <soci/session.h>

#include <soci/connection-pool.h>



namespace DataExporter_ns

{



class DBManager : public Tango::LogAdapter

{

public:

//------------------------------------------------------------------------------

//  [Public] Shared pointer typedef

//------------------------------------------------------------------------------

    typedef boost::shared_ptr<DBManager> SP;



protected:

//------------------------------------------------------------------------------

//  [Protected] Constructor destructor deleter

//------------------------------------------------------------------------------

    DBManager(Tango::DeviceImpl*, Configuration::SP);



    virtual ~DBManager();



    class Deleter;

    friend Deleter;

    class Deleter

    {

        public:

            void operator()(DBManager* d) { delete d; }

    };



public:

//------------------------------------------------------------------------------

//	[Public] Class creation method

//------------------------------------------------------------------------------

    static DBManager::SP create(Tango::DeviceImpl*, Configuration::SP);



//------------------------------------------------------------------------------

//  [Public] Connection management methods

//------------------------------------------------------------------------------

    virtual void connect() throw(soci::soci_error);



    virtual void disconnect();



protected:

//------------------------------------------------------------------------------

//  [Protected] Class variables

//------------------------------------------------------------------------------

    //Configuration shared pointer

    Configuration::SP m_configuration_sp;



    //Connection pool mutex

    boost::mutex m_connectionPoolMutex;



    //Database connection pool scoped pointer

    boost::scoped_ptr<soci::connection_pool> m_connectionPool_sp;

};



}   //End of namespace



#endif	/* DBMANAGER_H */

src/DataExporter.cpp

+534 −28

File changed.

Preview size limit exceeded, changes collapsed.

src/DataExporter.h

+99 −8
Original line number Diff line number Diff line
@@ -8,20 +8,20 @@ 
// project :     Data exporter

//

// This file is part of Tango device class.

// 

//

// Tango is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// 

//

// Tango is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// 

//

// You should have received a copy of the GNU General Public License

// along with Tango.  If not, see <http://www.gnu.org/licenses/>.

// 

//

// $Author:  $

//

// $Revision:  $
@@ -38,6 +38,9 @@ 
#ifndef DataExporter_H

#define DataExporter_H



#include <Configuration.h>

#include <Server.h>



#include <tango.h>
@@ -45,7 +48,7 @@ 


/**

 *  DataExporter class description:

 *    

 *

 */



namespace DataExporter_ns
@@ -61,10 +64,64 @@ class DataExporter : public TANGO_BASE_CLASS 


/*----- PROTECTED REGION ID(DataExporter::Data Members) ENABLED START -----*/



//	Add your own data members

//------------------------------------------------------------------------------

//  [Protected] Class variables

//------------------------------------------------------------------------------

    //Configuration class shared pointer

    Configuration::SP m_configuration_sp;



    //Server base class shared pointer

    Server::SP m_server_sp;



    //Max local port number allowed value

    static const unsigned int MAX_LOCAL_PORT = 65535;



    //Max number of worker thread allowed

    static const unsigned int MAX_WORKER_NUMBER = 100;



    //Max number of database connection allowed

    static const unsigned int MAX_DB_CONNECTION_NUMBER = 100;



    //Max database port number allowed value

    static const unsigned int MAX_DB_PORT = 65535;





/*----- PROTECTED REGION END -----*/	//	DataExporter::Data Members



//	Device property data members

public:

	//	CertificateFile:	Absolute path to certificate chain file

	string	certificateFile;

	//	PrivateKeyFile:	Absolute path to private key file

	string	privateKeyFile;

	//	DHTempFile:	Absolute path to Diffie Hellman temporary file

	string	dHTempFile;

	//	ExportedTables:	Tables exported from database: one table per row

	//  [schema table]

	vector<string>	exportedTables;

	//	AuthorisedUsers:	Authorised user list: one user per row

	//  [username password]

	vector<string>	authorisedUsers;

	//	StoragePath:	Absolute path to storage

	string	storagePath;

	//	LocalHost:	Local host address for incoming connection

	string	localHost;

	//	LocalPort:	Local port for wait incoming connection

	Tango::DevULong	localPort;

	//	WorkerNumber:	Number of threads that call io service run methods

	Tango::DevUShort	workerNumber;

	//	EnableSSL:	Enable or disable SSL connections

	Tango::DevBoolean	enableSSL;

	//	DatabaseHost:	Metadata database host

	string	databaseHost;

	//	DatabasePort:	Metadata database port

	Tango::DevULong	databasePort;

	//	DatabaseUsername:	Metadata database login username

	string	databaseUsername;

	//	DatabasePassword:	Metadata database login password

	string	databasePassword;

	//	DatabaseConnectionNumber:	Number of database connection created

	Tango::DevUShort	databaseConnectionNumber;





//	Constructors and destructors
@@ -93,7 +150,7 @@ public: 
	DataExporter(Tango::DeviceClass *cl,const char *s,const char *d);

	/**

	 * The device object destructor.

	 */	

	 */

	~DataExporter() {delete_device();};
@@ -107,6 +164,10 @@ public: 
	 *	Initialize the device

	 */

	virtual void init_device();

	/*

	 *	Read the device properties from database

	 */

	void get_device_property();

	/*

	 *	Always executed method before execution command method.

	 */
@@ -136,11 +197,41 @@ public: 


//	Command related methods

public:

	/**

	 *	Command On related method

	 *	Description: Activate data exporter

	 *

	 */

	virtual void on();

	virtual bool is_On_allowed(const CORBA::Any &any);

	/**

	 *	Command Off related method

	 *	Description: Deactivate data exporter

	 *

	 */

	virtual void off();

	virtual bool is_Off_allowed(const CORBA::Any &any);





/*----- PROTECTED REGION ID(DataExporter::Additional Method prototypes) ENABLED START -----*/



//	Additional Method prototypes

//------------------------------------------------------------------------------

//  [Protected] Utilities methods

//------------------------------------------------------------------------------

    virtual void importExportedTables(std::vector<std::string>&,

        std::multimap<const std::string, const std::string>&)

        throw(std::invalid_argument);



    virtual void importAuthorisedUsers(std::vector<std::string>&,

        std::map<const std::string, const std::string>&)

        throw(std::invalid_argument);



    virtual void checkIfFileExists(std::string)

        throw(std::invalid_argument);



    virtual void checkIfDirectoryExists(std::string)

        throw(std::invalid_argument);





/*----- PROTECTED REGION END -----*/	//	DataExporter::Additional Method prototypes

};