Commit 6b4bade0 authored by Marco De Marco's avatar Marco De Marco
Browse files

Connection with the server works; very basic

parent 0ce0e96b

src/Client.cpp

+84 −1
Original line number Original line Diff line number Diff line 
#include <Client.h>

#include <Client.h>





#include <boost/bind.hpp>



namespace MetadataImporter_ns

namespace MetadataImporter_ns

{

{





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

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

//      Client::Client()

//      Client::Client()

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

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

Client::Client(Tango::DeviceImpl* deviceImpl_p) : Tango::LogAdapter(deviceImpl_p)

Client::Client(Tango::DeviceImpl* deviceImpl_p, Configuration::SP configuration_sp) :

    Tango::LogAdapter(deviceImpl_p), m_configuration_sp(configuration_sp),

    m_work(m_ioService), m_resolver(m_ioService)

{

{

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

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



    m_state = Tango::OFF;

    m_status="Disconnected";

}

}





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

//==============================================================================
@@ -17,6 +24,15 @@ Client::Client(Tango::DeviceImpl* deviceImpl_p) : Tango::LogAdapter(deviceImpl_p 
Client::~Client()

Client::~Client()

{

{

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

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



    m_ioService.stop();



    if(m_thread_sp)

    {

        m_thread_sp->interrupt();



        m_thread_sp->join();

    }

}

}





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

//==============================================================================
@@ -25,6 +41,8 @@ Client::~Client() 
void Client::start()

void Client::start()

{

{

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

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



    m_thread_sp.reset(new boost::thread(boost::bind(&Client::run, this)));

}

}





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

//==============================================================================
@@ -33,6 +51,71 @@ void Client::start() 
void Client::stop()

void Client::stop()

{

{

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

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



    m_ioService.stop();



    if(m_thread_sp)

    {

        m_thread_sp->interrupt();



        m_thread_sp->join();

    }

}



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

//      Client::readState()

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

Tango::DevState Client::readState()

{

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



    boost::mutex::scoped_lock stateLock(m_stateMutex);



    return m_state;

}



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

//      Client::getStatus()

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

std::string Client::readStatus()

{

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



    boost::mutex::scoped_lock statusLock(m_stateMutex);



    return m_status;

}



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

//      Client::run()

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

void Client::run()

{

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



    while(true)

    {

        try

        {

            boost::system::error_code ec;

            m_ioService.run(ec);



            if(ec)

            {

                ERROR_STREAM << "Client::run() " << ec.message() << endl;

            }

            break;

        }

        catch(std::exception& ex)

        {

            ERROR_STREAM << "Client::run() " << ex.what() << endl;

        }

        catch(boost::thread_interrupted& ex)

        {

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

            break;

        }

    }   //while

}

}





}   //namespace
 
}   //namespace
 
 No newline at end of file

src/Client.h

+35 −7
Original line number Original line Diff line number Diff line 
#ifndef CLIENT_H

#ifndef CLIENT_H

#define	CLIENT_H

#define	CLIENT_H





#include <Configuration.h>



#include <tango.h>

#include <tango.h>





#include <boost/shared_ptr.hpp>

#include <boost/asio.hpp>

#include <boost/asio.hpp>

#include <boost/thread.hpp>

#include <boost/scoped_ptr.hpp>





namespace MetadataImporter_ns

namespace MetadataImporter_ns

{

{
@@ -20,7 +25,7 @@ protected: 
//------------------------------------------------------------------------------

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

//  [Protected] Constructor destructor

//  [Protected] Constructor destructor

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

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

    Client(Tango::DeviceImpl*);

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





    virtual ~Client();

    virtual ~Client();
@@ -28,20 +33,43 @@ public: 
//------------------------------------------------------------------------------

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

//  [Public] Users methods

//  [Public] Users methods

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

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

    virtual void start();

    virtual void start() = 0;



    virtual void stop() = 0;



    virtual Tango::DevState readState();





    virtual void stop();

    virtual std::string readStatus();





protected:

protected:

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

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

//  [Protected] Utilities methods

//  [Protected] Utilities methods

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

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

    //virtual boost::asio::ip::tcp::endpoint resolveEndpoint();

    virtual void run();





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

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

//  [Protected] Class variables

//  [Protected] Class variables

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

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





    Tango::DeviceImpl* deviceImpl_p;



    Configuration::SP m_configuration_sp;



    boost::asio::io_service m_ioService;



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



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



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



    boost::mutex m_stateMutex;



    Tango::DevState m_state;



    boost::mutex m_statusMutex;



    std::string m_status;

};

};





}   //End of namespace

}   //End of namespace

src/Configuration.h

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

#define	CONFIGURATION_H



#include <boost/shared_ptr.hpp>



namespace MetadataImporter_ns

{



class Configuration

{

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) {}

	virtual ~Configuration() {}



	class Deleter;

	friend class Deleter;

	class Deleter

	{

	public:

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

	};



public:

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

//	[Public] User methods

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

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

        std::string certificateFile)

	{

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

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



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;

};



}   //End of namespace



#endif	/* CONFIGURATION_H */

src/MetadataImporter.cpp

+14 −6
Original line number Original line Diff line number Diff line
@@ -41,6 +41,7 @@ 




#include <MetadataImporter.h>

#include <MetadataImporter.h>

#include <MetadataImporterClass.h>

#include <MetadataImporterClass.h>

#include <Configuration.h>

#include <PlainClient.h>

#include <PlainClient.h>

#include <SSLClient.h>

#include <SSLClient.h>
@@ -153,12 +154,12 @@ void MetadataImporter::init_device() 
    {

    {

        try

        try

        {

        {

            /*

            Configuration::SP configuration_sp = Configuration::create(address, port, certificateFile);



            if(enableSSL)

            if(enableSSL)

                m_client_sp;

                m_client_sp = SSLClient::create(this, configuration_sp);

            else

            else

                m_client_sp;

                m_client_sp = PlainClient::create(this, configuration_sp);

            */

        }

        }

        catch(std::exception& ex)

        catch(std::exception& ex)

        {

        {
@@ -295,7 +296,12 @@ void MetadataImporter::always_executed_hook() 




    if(get_state() != Tango::FAULT)

    if(get_state() != Tango::FAULT)

    {

    {

        if(m_client_sp)

        {

            set_state(m_client_sp->readState());





            set_status(m_client_sp->readStatus());

        }

    }

    }





	/*----- PROTECTED REGION END -----*/	//	MetadataImporter::always_executed_hook

	/*----- PROTECTED REGION END -----*/	//	MetadataImporter::always_executed_hook
@@ -348,7 +354,8 @@ void MetadataImporter::on() 




    try

    try

    {

    {



        if(m_client_sp)

            m_client_sp->start();

    }

    }

    catch(std::exception& ex)

    catch(std::exception& ex)

    {

    {
@@ -380,7 +387,8 @@ void MetadataImporter::off() 




    try

    try

    {

    {



        if(m_client_sp)

            m_client_sp->stop();

    }

    }

    catch(std::exception& ex)

    catch(std::exception& ex)

    {

    {

src/PlainClient.cpp

+111 −3
Original line number Original line Diff line number Diff line 
#include <PlainClient.h>

#include <PlainClient.h>





#include <boost/lexical_cast.hpp>



namespace MetadataImporter_ns

namespace MetadataImporter_ns

{

{





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

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

//      PlainClient::PlainClient()

//      PlainClient::PlainClient()

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

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

PlainClient::PlainClient(Tango::DeviceImpl* deviceImpl_p) : Client(deviceImpl_p)

PlainClient::PlainClient(Tango::DeviceImpl* deviceImpl_p,

    Configuration::SP configuration_sp) : Client(deviceImpl_p, configuration_sp),

    m_plainSocket(m_ioService)

{

{

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

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

}

}
@@ -22,9 +26,11 @@ PlainClient::~PlainClient() 
//==============================================================================

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

//      PlainClient::create()

//      PlainClient::create()

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

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

Client::SP PlainClient::create(Tango::DeviceImpl* deviceImpl_p)

Client::SP PlainClient::create(Tango::DeviceImpl* deviceImpl_p,

    Configuration::SP configuration_sp)

{

{

    Client::SP c_sp(new PlainClient(deviceImpl_p), PlainClient::Deleter());

    Client::SP c_sp(new PlainClient(deviceImpl_p, configuration_sp),

        PlainClient::Deleter());





    return c_sp;

    return c_sp;

}

}
@@ -35,6 +41,15 @@ Client::SP PlainClient::create(Tango::DeviceImpl* deviceImpl_p) 
void PlainClient::start()

void PlainClient::start()

{

{

    DEBUG_STREAM << "PlainClient::start()" << endl;

    DEBUG_STREAM << "PlainClient::start()" << endl;



    Client::start();



    boost::asio::ip::tcp::resolver::query query(m_configuration_sp->getAddress(),

        boost::lexical_cast<std::string>(m_configuration_sp->getPort()));



    m_resolver.async_resolve(query, boost::bind(&PlainClient::handleResolve, this,

        boost::asio::placeholders::error, boost::asio::placeholders::iterator));



}

}





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

//==============================================================================
@@ -43,6 +58,99 @@ void PlainClient::start() 
void PlainClient::stop()

void PlainClient::stop()

{

{

    DEBUG_STREAM << "PlainClient::stop()" << endl;

    DEBUG_STREAM << "PlainClient::stop()" << endl;



    Client::stop();

}



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

//      PlainClient::handleResolve()

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

void PlainClient::handleResolve(const boost::system::error_code& errorCode,

    boost::asio::ip::tcp::resolver::iterator endPointIterator)

{

    DEBUG_STREAM << "PlainClient::handleResolve()" << endl;



    INFO_STREAM << "PlainClient::handleResolve() " << endPointIterator->host_name() << endl;



    if(!errorCode)

    {

        boost::asio::async_connect(m_plainSocket, endPointIterator,

            boost::bind(&PlainClient::handleConnect, this,

            boost::asio::placeholders::error));

    }

    else

    {

        ERROR_STREAM << "PlainClient::handleResolve() "

            << errorCode.message() << endl;

    }

}



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

//      PlainClient::handleConnect()

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

void PlainClient::handleConnect(const boost::system::error_code& errorCode)

{

    DEBUG_STREAM << "PlainClient::handleConnect()" << endl;



    if(!errorCode)

    {

        std::ostream requestStream(&m_request);

        requestStream << "Request \r\n";



        boost::asio::async_write(m_plainSocket, m_request,

            boost::bind(&PlainClient::handleRequest, this,

            boost::asio::placeholders::error));

    }

    else

    {

        ERROR_STREAM << "PlainClient::handleConnect() "

            << errorCode.message() << endl;

    }

}



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

//      PlainClient::handleRequest()

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

void PlainClient::handleRequest(const boost::system::error_code& errorCode)

{

    DEBUG_STREAM << "PlainClient::handleRequest()" << endl;



    if(!errorCode)

    {

        boost::asio::async_read_until(m_plainSocket, m_response, "\r\n",

            boost::bind(&PlainClient::handleResponse, this,

            boost::asio::placeholders::error));



        INFO_STREAM << "PlainClient::handleRequest() " << &m_response << endl;

    }

    else

    {

        ERROR_STREAM << "PlainClient::handleRequest() "

            << errorCode.message() << endl;

    }

}



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

//      PlainClient::handleResponse()

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

void PlainClient::handleResponse(const boost::system::error_code& errorCode)

{

    DEBUG_STREAM << "PlainClient::handleResponse()" << endl;



    if(!errorCode)

    {

        std::ostream requestStream(&m_request);

        requestStream << "Request \r\n";



        boost::asio::async_write(m_plainSocket, m_request,

            boost::bind(&PlainClient::handleRequest, this,

            boost::asio::placeholders::error));

    }

    else

    {

        ERROR_STREAM << "PlainClient::handleResponse() "

            << errorCode.message() << endl;

    }

}

}





}   //namespace
 
}   //namespace