Server compiled, ready for test

src/FileManager.cpp → src/FileWrapper.cpp

-#include <FileManager.h>
-#include <stdexcept>
+#include <FileWrapper.h>
 
 namespace DataExporter_ns
 {
 
 //==============================================================================
-//      FileManager::FileManager()
+//      FileWrapper::FileWrapper()
 //==============================================================================
-FileManager::FileManager(Tango::DeviceImpl* deviceImpl_p,
+FileWrapper::FileWrapper(Tango::DeviceImpl* deviceImpl_p,
     boost::filesystem::path& path) : Tango::LogAdapter(deviceImpl_p)
 {
-    DEBUG_STREAM << "FileManager::FileManager()" << endl;
+    DEBUG_STREAM << "FileWrapper::FileWrapper()" << endl;
 
     m_inputFileStream.open(path.string(), std::ios::binary | std::ios::ate);
 
@@ -20,51 +19,56 @@ FileManager::FileManager(Tango::DeviceImpl* deviceImpl_p,
 }
 
 //==============================================================================
-//      FileManager::~FileManager()
+//      FileWrapper::~FileWrapper()
 //==============================================================================
-FileManager::~FileManager()
+FileWrapper::~FileWrapper()
 {
-    DEBUG_STREAM << "FileManager::~FileManager()" << endl;
+    DEBUG_STREAM << "FileWrapper::~FileWrapper()" << endl;
 
     m_inputFileStream.close();
 }
 
 //==============================================================================
-//      FileManager::create()
+//      FileWrapper::create()
 //==============================================================================
-FileManager::SP FileManager::create(Tango::DeviceImpl* deviceImpl_p,
+FileWrapper::SP FileWrapper::create(Tango::DeviceImpl* deviceImpl_p,
     boost::filesystem::path& path)
 {
-    FileManager::SP d_sp(new FileManager(deviceImpl_p, path),
-        FileManager::Deleter());
+    FileWrapper::SP d_sp(new FileWrapper(deviceImpl_p, path),
+        FileWrapper::Deleter());
 
     return d_sp;
 }
 
 //==============================================================================
-//      FileManager::isOpen()
+//      FileWrapper::isOpen()
 //==============================================================================
-bool FileManager::isOpen()
+bool FileWrapper::isOpen()
 {
     return m_inputFileStream.is_open();
 }
 
 //==============================================================================
-//      FileManager::isCompleted()
+//      FileWrapper::isBad()
 //==============================================================================
-bool FileManager::isCompleted()
+bool FileWrapper::isBad()
 {
-    return m_inputFileStream.tellg() >= m_inputFileSize;
+    return m_inputFileStream.bad();
 }
 
 //==============================================================================
-//      FileManager::read()
+//      FileWrapper::isCompleted()
 //==============================================================================
-void FileManager::read(std::vector<char>& writeBuff) throw(std::runtime_error)
+bool FileWrapper::isCompleted()
 {
-    if(m_inputFileStream.tellg() >= m_inputFileSize)
-        throw std::runtime_error("Already completed");
+    return m_inputFileStream.tellg() >= m_inputFileSize;
+}
 
+//==============================================================================
+//      FileWrapper::read()
+//==============================================================================
+void FileWrapper::read(std::vector<char>& writeBuff) throw(std::runtime_error)
+{
     int leftToRead = m_inputFileSize - m_inputFileStream.tellg();
 
     int bufferSize = 0;

src/FileManager.h → src/FileWrapper.h

-#ifndef FILEMANAGER_H
-#define	FILEMANAGER_H
+#ifndef FILEWRAPPER_H
+#define	FILEWRAPPER_H
 
 #include <Configuration.h>
 
@@ -10,41 +10,43 @@
 namespace DataExporter_ns
 {
 
-class FileManager : public Tango::LogAdapter
+class FileWrapper : public Tango::LogAdapter
 {
 public:
 //------------------------------------------------------------------------------
 //  [Public] Shared pointer typedef
 //------------------------------------------------------------------------------
-    typedef boost::shared_ptr<FileManager> SP;
+    typedef boost::shared_ptr<FileWrapper> SP;
 
 protected:
 //------------------------------------------------------------------------------
 //  [Protected] Constructor destructor deleter
 //------------------------------------------------------------------------------
-    FileManager(Tango::DeviceImpl*, boost::filesystem::path&);
+    FileWrapper(Tango::DeviceImpl*, boost::filesystem::path&);
 
-    virtual ~FileManager();
+    virtual ~FileWrapper();
 
     class Deleter;
     friend Deleter;
     class Deleter
     {
         public:
-            void operator()(FileManager* d) { delete d; }
+            void operator()(FileWrapper* d) { delete d; }
     };
 
 public:
 //------------------------------------------------------------------------------
 //	[Public] Class creation method
 //------------------------------------------------------------------------------
-    static FileManager::SP create(Tango::DeviceImpl*, boost::filesystem::path&);
+    static FileWrapper::SP create(Tango::DeviceImpl*, boost::filesystem::path&);
 
 //------------------------------------------------------------------------------
 //	[Public] Input stream methods
 //------------------------------------------------------------------------------
     virtual bool isOpen();
 
+    virtual bool isBad();
+
     virtual bool isCompleted();
 
     virtual void read(std::vector<char>&) throw(std::runtime_error);
@@ -65,4 +67,4 @@ protected:
 
 }   //End of namespace
 
-#endif	/* FILEMANAGER_H */
+#endif	/* FILEWRAPPER_H */

src/PlainSession.cpp

@@ -154,52 +154,40 @@ void PlainSession::startWriteResponse()
     {
         ERROR_STREAM << "SSLSession::startWriteResponse() unknown error from "
             << m_remoteEndpoint << endl;
-
     }
 }
 
 //==============================================================================
 //      PlainSession::startWriteData()
 //==============================================================================
-void PlainSession::startWriteData()
+void PlainSession::startWriteData(FileWrapper::SP fileWrapper_sp)
 {
     try
     {
-        if(!m_inputStream.bad())
+        if(!fileWrapper_sp->isBad())
         {
-            if(m_inputStream.tellg()<m_inputStreamSize)
+            if(!fileWrapper_sp->isCompleted())
             {
-                int leftToRead = m_inputStreamSize - m_inputStream.tellg();
-
-                int bufferSize = 0;
-
-                if(leftToRead < BUFFER_SIZE)
-                        bufferSize = leftToRead;
-                else
-                        bufferSize = BUFFER_SIZE;
-
                 std::vector<char> writeBuff;
-                writeBuff.resize(bufferSize);
 
-                m_inputStream.read(&writeBuff[0], bufferSize);
+                fileWrapper_sp->read(writeBuff);
 
                 boost::asio::async_write(m_plainSocket, boost::asio::buffer(writeBuff),
                     m_strand.wrap(boost::bind(&PlainSession::handleWriteData,
-                    shared_from_this(), boost::asio::placeholders::error)));
+                    shared_from_this(), fileWrapper_sp,
+                    boost::asio::placeholders::error)));
             }
             else
             {
-                INFO_STREAM << "SSLSession::startWriteData() "
+                INFO_STREAM << "PlainSession::startWriteData() "
                     << " transfer completed " << endl;
 
-                m_inputStream.close();
-
                 startReadRequestHeader();
             }
         }
         else
         {
-            ERROR_STREAM << "SSLSession::startWriteData() error on file I/O "
+            ERROR_STREAM << "PlainSession::startWriteData() error on file I/O "
                 << "from " << m_remoteEndpoint << endl;
         }
     }

src/PlainSession.h

@@ -54,7 +54,7 @@ protected:
 
     virtual void startWriteResponse();
 
-    virtual void startWriteData();
+    virtual void startWriteData(FileWrapper::SP);
 
 //------------------------------------------------------------------------------
 //	[Protected] Class variables

src/ProtocolManager.cpp

@@ -11,8 +11,8 @@ namespace DataExporter_ns
 //==============================================================================
 ProtocolManager::ProtocolManager(Tango::DeviceImpl* deviceImpl_p,
     Configuration::SP configuration_sp, DBManager::SP dBManager_sp) :
-    Tango::LogAdapter(deviceImpl_p), m_configuration_sp(configuration_sp),
-    m_dBManager_sp(dBManager_sp)
+    Tango::LogAdapter(deviceImpl_p), m_deviceImpl_p(deviceImpl_p),
+    m_configuration_sp(configuration_sp), m_dBManager_sp(dBManager_sp)
 {
     DEBUG_STREAM << "ProtocolManager::ProtocolManager()" << endl;
 }
@@ -55,14 +55,17 @@ ResponseSP ProtocolManager::prepareResponse(RequestSP request_sp)
 {
     DEBUG_STREAM << "ProtocolManager::prepareResponse()" << endl;
 
+    m_fileFound = false;
+    m_fileWrapper_sp.reset();
+
     if(!request_sp->IsInitialized())
         throw std::runtime_error("Not initialized request!");
 
+    ResponseSP response_sp(new Response());
+
     std::string username = request_sp->username();
     std::string password = request_sp->password();
 
-    ResponseSP response_sp(new Response());
-
     if(m_configuration_sp->isUserAuthorized(username, password))
     {
         std::string schema = request_sp->schema();
@@ -91,8 +94,13 @@ ResponseSP ProtocolManager::prepareResponse(RequestSP request_sp)
                         boost::uint64_t fileSize =
                             boost::filesystem::file_size(absolutePath);
 
-                        DEBUG_STREAM << "ProtocolManager::prepareResponse() "
-                            << "file size " << fileSize << endl;
+                        INFO_STREAM << "ProtocolManager::prepareResponse() "
+                            << " transfer file " << fileName << " version "
+                            << fileVersion << " size " << fileSize << endl;
+
+                        m_fileFound = true;
+                        m_fileWrapper_sp =
+                            FileWrapper::create(m_deviceImpl_p, absolutePath);
 
                         response_sp->set_state(Response::REQUEST_ACCEPTED);
                         response_sp->set_status("Request accepted");
@@ -153,6 +161,29 @@ ResponseSP ProtocolManager::prepareResponse(RequestSP request_sp)
     return response_sp;
 }
 
+//==============================================================================
+//      ProtocolManager::isFileFound()
+//==============================================================================
+bool ProtocolManager::isFileFound()
+{
+    DEBUG_STREAM << "ProtocolManager::isFileFound()" << endl;
+
+    return m_fileFound;
+}
+
+//==============================================================================
+//      ProtocolManager::getFileWrapper()
+//==============================================================================
+FileWrapper::SP ProtocolManager::getFileWrapper() throw(std::runtime_error)
+{
+    DEBUG_STREAM << "ProtocolManager::getFileWrapper()" << endl;
+
+    if(!m_fileWrapper_sp)
+        throw std::runtime_error("File wrapper not created");
+
+    return m_fileWrapper_sp;
+}
+
 //==============================================================================
 //      ProtocolManager::composePath()
 //==============================================================================

src/ProtocolManager.h

@@ -5,6 +5,7 @@
 #include <Request.pb.h>
 #include <Configuration.h>
 #include <DBManager.h>
+#include <FileWrapper.h>
 
 #include <tango.h>
 
@@ -61,6 +62,13 @@ public:
     virtual ResponseSP prepareResponse(RequestSP)
         throw(std::runtime_error);
 
+//------------------------------------------------------------------------------
+//  [Public] File transfer methods
+//------------------------------------------------------------------------------
+    bool isFileFound();
+
+    FileWrapper::SP getFileWrapper() throw(std::runtime_error);
+
 protected:
 //------------------------------------------------------------------------------
 //  [Protected]
@@ -71,6 +79,9 @@ protected:
 //------------------------------------------------------------------------------
 //  [Protected] Class variables
 //------------------------------------------------------------------------------
+    //Device implementation pointer
+    Tango::DeviceImpl* m_deviceImpl_p;
+
     //Configuration parameters shared pointer
     Configuration::SP m_configuration_sp;
 
@@ -79,6 +90,12 @@ protected:
 
     //Address and port of remote endpoint
     std::string m_remoteEndpoint;
+
+    //File to transfer found
+    bool m_fileFound;
+
+    //File to transfer wrapper
+    FileWrapper::SP m_fileWrapper_sp;
 };
 
 }   //End of namespace

src/SSLSession.cpp

@@ -196,39 +196,28 @@ void SSLSession::startWriteResponse()
 //==============================================================================
 //      SSLSession::startWriteData()
 //==============================================================================
-void SSLSession::startWriteData()
+void SSLSession::startWriteData(FileWrapper::SP fileWrapper_sp)
 {
     try
     {
-        if(!m_inputStream.bad())
+        if(!fileWrapper_sp->isBad())
         {
-            if(m_inputStream.tellg() < m_inputStreamSize)
+            if(!fileWrapper_sp->isCompleted())
             {
-                int leftToRead = m_inputStreamSize - m_inputStream.tellg();
-
-                int bufferSize = 0;
-
-                if(leftToRead < BUFFER_SIZE)
-                        bufferSize = leftToRead;
-                else
-                        bufferSize = BUFFER_SIZE;
-
                 std::vector<char> writeBuff;
-                writeBuff.resize(bufferSize);
 
-                m_inputStream.read(&writeBuff[0], bufferSize);
+                fileWrapper_sp->read(writeBuff);
 
                 boost::asio::async_write(m_sslSocket, boost::asio::buffer(writeBuff),
                     m_strand.wrap(boost::bind(&SSLSession::handleWriteData,
-                    shared_from_this(), boost::asio::placeholders::error)));
+                    shared_from_this(), fileWrapper_sp,
+                    boost::asio::placeholders::error)));
             }
             else
             {
                 INFO_STREAM << "SSLSession::startWriteData() "
                     << " transfer completed " << endl;
 
-                m_inputStream.close();
-
                 startReadRequestHeader();
             }
         }

src/SSLSession.h

@@ -64,7 +64,7 @@ protected:
 
     virtual void startWriteResponse();
 
-    virtual void startWriteData();
+    virtual void startWriteData(FileWrapper::SP);
 
 //------------------------------------------------------------------------------
 //	[Protected] Class variables

src/Session.cpp

@@ -82,14 +82,14 @@ void Session::handleWriteResponse(const boost::system::error_code& errorCode)
 
     if(!errorCode)
     {
-//        if()
-//        {
-//            //TODO: open file and start read
-//        }
-//        else
-//        {
-//            startReadRequestHeader();
-//        }
+        if(m_protocolManager_sp->isFileFound())
+        {
+            startWriteData(m_protocolManager_sp->getFileWrapper());
+        }
+        else
+        {
+            startReadRequestHeader();
+        }
     }
     else if(errorCode == boost::asio::error::eof)
     {
@@ -106,11 +106,12 @@ void Session::handleWriteResponse(const boost::system::error_code& errorCode)
 //==============================================================================
 //      Session::handleWriteData()
 //==============================================================================
-void Session::handleWriteData(const boost::system::error_code& errorCode)
+void Session::handleWriteData(FileWrapper::SP fileWrapper_sp,
+    const boost::system::error_code& errorCode)
 {
     if(!errorCode)
     {
-        startWriteData();
+        startWriteData(fileWrapper_sp);
     }
     else if(errorCode == boost::asio::error::eof)
     {

src/Session.h

@@ -4,6 +4,7 @@
 #include <Configuration.h>
 #include <ProtocolManager.h>
 #include <DBManager.h>
+#include <FileWrapper.h>
 
 #include <tango.h>
 
@@ -64,9 +65,10 @@ protected:
 //------------------------------------------------------------------------------
 //  [Protected] Write data methods
 //------------------------------------------------------------------------------
-    virtual void startWriteData() = 0;
+    virtual void startWriteData(FileWrapper::SP) = 0;
 
-    virtual void handleWriteData(const boost::system::error_code&);
+    virtual void handleWriteData(FileWrapper::SP,
+        const boost::system::error_code&);
 
 //------------------------------------------------------------------------------
 //  [Protected] Encode decode header methods
@@ -97,13 +99,6 @@ protected:
 
     //Address and port of remote endpoint
     std::string m_remoteEndpoint;
-
-    //TODO: to delete
-    const int BUFFER_SIZE = 1024;
-
-    std::ifstream m_inputStream;
-
-    int m_inputStreamSize;
 };
 
 }   //End of namespace