192 lines
4.8 KiB
C++
192 lines
4.8 KiB
C++
/*
|
|
----
|
|
This file is part of SECONDO.
|
|
|
|
Copyright (C) 2004, University in Hagen, Department of Computer Science,
|
|
Database Systems for New Applications.
|
|
|
|
SECONDO 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 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
SECONDO 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 SECONDO; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
----
|
|
|
|
//paragraph [1] Title: [{\Large \bf \begin{center}] [\end{center}}]
|
|
//characters [1] Type: [] []
|
|
//characters [2] Type: [] []
|
|
//[ae] [\"{a}]
|
|
//[oe] [\"{o}]
|
|
//[ue] [\"{u}]
|
|
//[ss] [{\ss}]
|
|
//[Ae] [\"{A}]
|
|
//[Oe] [\"{O}]
|
|
//[Ue] [\"{U}]
|
|
//[x] [$\times $]
|
|
//[->] [$\rightarrow $]
|
|
//[toc] [\tableofcontents]
|
|
|
|
[1] Implementation of DistributeStreamServer.
|
|
|
|
[toc]
|
|
|
|
1 DistributeStreamServer class implementation
|
|
|
|
2 Includes
|
|
|
|
|
|
*/
|
|
#include "StringUtils.h"
|
|
#include "Algebras/DBService/CommunicationUtils.hpp"
|
|
|
|
#include "DistributeStreamProtocol.h"
|
|
#include "VTHelpers.h"
|
|
#include "Algebras/Relation-C++/RelationAlgebra.h"
|
|
#include "DistributeStreamServer.h"
|
|
|
|
using namespace std;
|
|
|
|
namespace cstream {
|
|
|
|
/*
|
|
1.1 Constructor
|
|
|
|
Creates a server with a given port number and a given provided format.
|
|
If provided format is set to true the binary format is provided. If
|
|
the variable is false, the text format is provieded.
|
|
|
|
*/
|
|
DistributeStreamServer::DistributeStreamServer(
|
|
const int port, const bool providedFormat) :
|
|
Server(port), _providedFormat(providedFormat), _runner(0) {
|
|
|
|
}
|
|
|
|
/*
|
|
1.2 Destructor
|
|
|
|
Stoppes the server and all running workers.
|
|
|
|
*/
|
|
DistributeStreamServer::~DistributeStreamServer() {
|
|
if(_runner) {
|
|
_runner->interrupt();
|
|
if(listener->IsOk()) {
|
|
listener->ShutDown();
|
|
}
|
|
_runner->join();
|
|
}
|
|
|
|
boost::unique_lock<boost::mutex> lock(_workerListGuard);
|
|
for(list<DistributeStreamWorker*>::iterator it=_workerList.begin() ;
|
|
it != _workerList.end() ; ++it)
|
|
delete (*it);
|
|
}
|
|
|
|
/*
|
|
1.3 Function Definitions
|
|
|
|
1.3.1 run
|
|
|
|
Starts the server in a separate thread to wait for new client connections.
|
|
For a new communication with a client a worker thread will be started.
|
|
|
|
*/
|
|
void DistributeStreamServer::run() {
|
|
listener = Socket::CreateGlobal("localhost", stringutils::int2str(port));
|
|
_runner = new boost::thread(boost::bind(
|
|
&DistributeStreamServer::start,
|
|
this));
|
|
}
|
|
|
|
/*
|
|
1.3.2 start
|
|
|
|
This function runs in a separate thread and waits for connection requests.
|
|
If a client connect to the server the communication will be done in a
|
|
worker thread.
|
|
|
|
*/
|
|
int DistributeStreamServer::start() {
|
|
if (!listener->IsOk()) {
|
|
return 1;
|
|
}
|
|
|
|
while(true) {
|
|
try {
|
|
// wait for incoming connections and pass
|
|
// them to a new worker thread
|
|
Socket* serverConnection = listener->Accept();
|
|
if (!serverConnection || !serverConnection->IsOk()) {
|
|
if(listener)
|
|
listener->ShutDown();
|
|
return 2;
|
|
}
|
|
|
|
startCommunication(serverConnection);
|
|
}
|
|
catch (boost::thread_interrupted) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
1.3.3 handleCommunicationThread
|
|
|
|
This function is used to start a new worker for a new client connection.
|
|
|
|
*/
|
|
void DistributeStreamServer::startCommunication(Socket* serverConnection) {
|
|
DistributeStreamWorker* worker =
|
|
new DistributeStreamWorker(serverConnection, _providedFormat);
|
|
if(worker->run()) {
|
|
boost::unique_lock<boost::mutex> lock(_workerListGuard);
|
|
_workerList.push_back(worker);
|
|
}
|
|
}
|
|
|
|
/*
|
|
1.3.4 pushTuple
|
|
|
|
This function pushes a given vtuple to all connected workers.
|
|
|
|
*/
|
|
void DistributeStreamServer::pushTuple(VTuple* vt) {
|
|
boost::unique_lock<boost::mutex> lock(_workerListGuard);
|
|
queue<DistributeStreamWorker*> deadWorkers;
|
|
for(list<DistributeStreamWorker*>::iterator it=_workerList.begin() ;
|
|
it != _workerList.end() ; ++it) {
|
|
|
|
if((*it)->isConnected()) {
|
|
vt->IncReference();
|
|
(*it)->pushTuple(vt);
|
|
}
|
|
else {
|
|
deadWorkers.push((*it));
|
|
}
|
|
}
|
|
|
|
// delete workers without a connection
|
|
while(!deadWorkers.empty()) {
|
|
DistributeStreamWorker* deadWorker = deadWorkers.front();
|
|
deadWorkers.pop();
|
|
_workerList.remove(deadWorker);
|
|
delete deadWorker;
|
|
}
|
|
|
|
vt->DeleteIfAllowed();
|
|
}
|
|
|
|
} /* namespace cstream */
|