Servers, sessions, worker thread, and db manager classes added (09b6b338) · Commits · IA2 / data_exporter

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

+512 −6

File changed.

Preview size limit exceeded, changes collapsed.

src/DataExporter.h

+93 −2

Original line number	Diff line number	Diff line
		@@ -38,6 +38,9 @@
		#ifndef DataExporter_H
		#define DataExporter_H

		#include <Configuration.h>
		#include <Server.h>

		#include <tango.h>


		@@ -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
		@@ -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
		};