Commit 050d49cd authored by Marco De Marco's avatar Marco De Marco
Browse files

DBManager and protocol buffer classes added

parent b5e37ad1

proto/Response.proto

+27 −3
Original line number Diff line number Diff line
@@ -60,11 +60,35 @@ message Response 
		message DtInteger 

		{

			required string key = 1;

			required int64 value = 2;

			required int32 value = 2;

		}



		repeated DtInteger integer_list = 3;



		//Mysql: not used with mysql, needed for postgres

		//SOCI:  dt_unsigned_long 

		//C++:   unsigned long 



		message DtUnsignedLong

		{

			required string key = 1;

			required uint64 value = 2;

		}



		repeated DtUnsignedLong unsinged_long_list = 4;



		//Mysql: not used with mysql, needed for postgres

		//SOCI:  dt_long_long

		//C++:   long long 



		message DtLongLong

		{

			required string key = 1;

			required int64 value = 2;

		}



		repeated DtLongLong long_long_list = 5;



		//Mysql: STRING/BINARY, VARCHAR/VARBINARY

		//SOCI:  dt_string

		//C++:   string
@@ -75,7 +99,7 @@ message Response 
			required string value = 2;

		}



		repeated DtString strings_list = 4;

		repeated DtString strings_list = 6;



		//Mysql: TIMESTAMP DATE, TIME, DATETIME

		//SOCI:  dt_date
@@ -87,7 +111,7 @@ message Response 
			required sfixed64 value = 2;

		}



		repeated DtDate date_list = 5;

		repeated DtDate date_list = 7;

	}



	optional Metadata metadata = 3;

src/Client.cpp

+3 −0
Original line number Diff line number Diff line
@@ -14,7 +14,10 @@ Client::Client(Tango::DeviceImpl* deviceImpl_p, Configuration::SP configuration_ 
{

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



    m_dBManager_sp = DBManager::create(deviceImpl_p, configuration_sp);



    m_state = Tango::OFF;

    

    m_status="Disconnected";

}

src/Client.h

+14 −1
Original line number Diff line number Diff line
@@ -2,6 +2,7 @@ 
#define	CLIENT_H



#include <Configuration.h>

#include <DBManager.h>



#include <tango.h>
@@ -50,25 +51,37 @@ protected: 
//------------------------------------------------------------------------------

//  [Protected] Class variables

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



    //Tango server class pointer

    Tango::DeviceImpl* deviceImpl_p;



    //Configuration shared pointer

    Configuration::SP m_configuration_sp;



    //Database manager shared pointer

    DBManager::SP m_dBManager_sp;



    //IO service instance

    boost::asio::io_service m_ioService;



    //Work IO service instance

    boost::asio::io_service::work m_work;



    //DNS resolver instance

    boost::asio::ip::tcp::resolver m_resolver;



    //Thread for IO service run scoped pointer

    boost::scoped_ptr<boost::thread> m_thread_sp;



    //Tango state property mutex

    boost::mutex m_stateMutex;



    //Tango state property

    Tango::DevState m_state;



    //Tango status property mutex

    boost::mutex m_statusMutex;



    //Tango status property

    std::string m_status;

};

src/Configuration.h

+75 −16
Original line number Diff line number Diff line
@@ -13,15 +13,26 @@ public: 
//	[Public] Shared pointer typedef

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

	typedef boost::shared_ptr<Configuration> SP;

	typedef std::vector< SP > SPVector;



private:

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

//	[Private] Constructor destructor deleter

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

	Configuration(std::string address, unsigned int port,

        std::string certificateFile) : m_address(address), m_port(port),

        m_certificateFile(certificateFile) {}

	Configuration(std::string certificateFile,

        std::string remoteHost, unsigned int remotePort,

        std::string remoteUsername, std::string remotePassword,

        std::string databaseHost, unsigned int databasePort,

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

        std::string databaseSchema, std::string databaseTable,

        unsigned int refreshTime, unsigned int timeout) :

        m_certificateFile (certificateFile), m_remoteHost(remoteHost),

        m_remotePort(remotePort), m_remoteUsername(remoteUsername),

        m_remotePassword(remotePassword), m_databaseHost(databaseHost),

        m_databasePort(databasePort), m_databaseUsername(databaseUsername),

        m_databasePassword(databasePassword), m_databaseSchema(databaseSchema),

        m_databaseTable(databaseTable), m_refreshTime(refreshTime),

        m_timeout(timeout) { };



	virtual ~Configuration() {}



	class Deleter;
@@ -36,31 +47,79 @@ public: 
//------------------------------------------------------------------------------

//	[Public] User methods

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

	static Configuration::SP create(std::string address, unsigned int port,

        std::string certificateFile)

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

        std::string m_remoteHost, unsigned int m_remotePort,

        std::string m_remoteUsername, std::string m_remotePassword,

        std::string m_databaseHost, unsigned int m_databasePort,

        std::string m_databaseUsername, std::string m_databasePassword,

        std::string m_databaseSchema, std::string m_databaseTable,

        unsigned int m_refreshTime, unsigned int m_timeout)

	{

		Configuration::SP c_sp(new Configuration(address, port, certificateFile),

		Configuration::SP c_sp(new Configuration(m_certificateFile, m_remoteHost,

            m_remotePort, m_remoteUsername, m_remotePassword, m_databaseHost,

            m_databasePort, m_databaseUsername, m_databasePassword,

            m_databaseSchema, m_databaseTable, m_refreshTime, m_timeout),

            Configuration::Deleter());



		return c_sp;

	}



	std::string getAddress() const { return m_address; }

    unsigned int getPort() const { return m_port; }

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

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

	std::string	getRemoteHost() const { return m_remoteHost; };

	unsigned int getRemotePort() const { return m_remotePort; };

	std::string	getRemoteUsername() const { return m_remoteUsername; };

	std::string	getRemotePassword() const { return m_remotePassword; };

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

	std::string	getDatabaseSchema() const { return m_databaseSchema; };

	std::string	getDatabaseTable() const { return m_databaseTable; };

	unsigned int getRefreshTime() const { return m_refreshTime; };

	unsigned int getTimeout() const { return m_timeout; };



private:

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

//	[Private] class variables

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

	//Address used for wait incoming connection

    const std::string m_address;



	//Port used for wait incoming connection

    const unsigned int m_port;



	//Absolute path to certificate chain file

	const std::string	m_certificateFile;



    //Metadata exporter remote host

	const std::string	m_remoteHost;



    //Metadata exporter remote port

	const unsigned int m_remotePort;



    //Metadata exporter login username

	const std::string	m_remoteUsername;



    //Metadata exporter remote password

	const std::string	m_remotePassword;



    //Metadata local database host

	const std::string	m_databaseHost;



    //Metadata local database port

	const unsigned int m_databasePort;



    //Metadata local database username

	const std::string	m_databaseUsername;



    //Metadata local database password

	const std::string	m_databasePassword;



    //Metadata local database schema

	const std::string	m_databaseSchema;



    //Metadata local database table

	const std::string	m_databaseTable;



    //Remote database request period (seconds)

	const unsigned int m_refreshTime;



	//Connection timeout (seconds)

	const unsigned int m_timeout;

};



}   //End of namespace

src/DBManager.cpp

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



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



namespace MetadataImporter_ns

{



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

//      DBManager::DBManager()

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

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

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

    m_deviceImpl_p(deviceImpl_p), m_configuration_sp(configuration_sp)

{

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



    m_session_sp.reset(new soci::session);

}



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

//      DBManager::DBManager()

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

DBManager::~DBManager()

{

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



    m_session_sp->close();

}



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

//      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;



    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();

    connection << " dbname=" << m_configuration_sp->getDatabaseSchema();



#ifdef VERBOSE_DEBUG

    INFO_STREAM << "CONNECTION: " << connection.str() << endl;

    INFO_STREAM << "-------------------------------------------------" << endl;

#endif



    m_session_sp->open(soci::mysql, connection.str());

}



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

//      DBManager::isConnected()

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

bool DBManager::isConnected()

{

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



    if(m_session_sp->get_backend() == NULL)

        return false;

    else

        return true;

}



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

//      DBManager::disconnect()

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

void DBManager::disconnect()

{

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



    m_session_sp->close();

}



}   //namespace