- rcf-09c.zip
- RCF-0.9c
- demo
- vs2003
- RCF
- include
- RCF
- SF
- license.txt
- src
- RCF
- SF
- test
- rcf-04.zip
- RCF-0.4
- demo
- vs2003
- RCF
- doc
- html
- latex
- include
- RCF
- SF
- license.txt
- src
- RCF
- SF
- test
- vs2003
- RCF
- RCF.sln
- RCF
- RCF.vcproj
- RCFTest
- client.pem
- RCFTest.vcproj
- server.pem
|
//*****************************************************************************
// RCF - Remote Call Framework
// Copyright (c) 2005. All rights reserved.
// Developed by Jarl Lindrud.
// Contact: jlindrud@hotmail.com .
//*****************************************************************************
#include <RCF/EndpointServerService.hpp>
#include <RCF/CurrentSession.hpp>
#include <RCF/RcfServer.hpp>
#include <RCF/Session.hpp>
#include <RCF/ServerInterfaces.hpp>
#include <RCF/StubFactory.hpp>
#include <RCF/Tools.hpp>
namespace RCF {
// remotely invoked (on the master connection)
bool EndpointServer::spawnConnections(unsigned int requestedConnections)
{
if (requestedConnections > 10)
{
requestedConnections = 10;
}
I_ServerTransport &serverTransport = getCurrentSessionPtr()->getProactorPtr()->getServerTransport();
I_ServerTransportEx *pServerTransportEx = dynamic_cast<I_ServerTransportEx *>(&serverTransport);
if (NULL == pServerTransportEx)
{
return false;
}
I_ServerTransportEx &serverTransportEx = *pServerTransportEx;
for (unsigned int i=0; i<requestedConnections && mClients.size() < 50; ++i)
{
ClientTransportAutoPtr clientTransportAutoPtr( mClients.front()->getClientStub().getTransport().clone() );
Client client(clientTransportAutoPtr);
client.establishEndpointConnection(Oneway, mEndpointName, mEndpointServerPassword); // TODO: handle exceptions
boost::shared_ptr<I_Session> sessionPtr( serverTransportEx.createServerSession(client.getClientStub().releaseTransport()) );
std::auto_ptr<I_ClientTransport> apClientTransport( serverTransportEx.createClientTransport(sessionPtr) );
ClientPtr clientPtr( new Client(apClientTransport) );
mClients.push_back(clientPtr);
}
return true;
}
EndpointServerService::EndpointServerService() :
mEndpointServersMutex(WriterPriority)
{}
void EndpointServerService::onServiceAdded(RcfServer &server)
{
mServerTransportPtr = server.getServerTransportPtr();
}
void EndpointServerService::onServiceRemoved(RcfServer &)
{}
EndpointServerService::EndpointId EndpointServerService::openEndpoint(const I_Endpoint &brokerEndpoint, const std::string &endpointName)
{
I_ServerTransportEx &serverTransportEx = dynamic_cast<I_ServerTransportEx &>(*mServerTransportPtr);
ClientTransportAutoPtr clientTransportAutoPtr(serverTransportEx.createClientTransport(brokerEndpoint));
return openEndpoint(clientTransportAutoPtr, endpointName);
}
EndpointServerService::EndpointId EndpointServerService::openEndpoint(ClientTransportAutoPtr clientTransportAutoPtr, const std::string &endpointName)
{
EndpointId endpointId = 0;
std::string endpointClientPassword = ""; // TODO
std::string endpointServerPassword = ""; // TODO
I_ServerTransportEx &serverTransportEx = dynamic_cast<I_ServerTransportEx &>(*mServerTransportPtr);
EndpointServerPtr endpointServerPtr;
{
WriteLock lock(mEndpointServersMutex);
while (++endpointId < 10 && mEndpointServers.find(endpointId) != mEndpointServers.end()); // TODO: user configuration of the limit
if (endpointId < 10)
{
endpointServerPtr.reset( new EndpointServer() );
endpointServerPtr->mEndpointName = endpointName;
endpointServerPtr->mEndpointId = endpointId;
mEndpointServers[endpointServerPtr->getEndpointId()] = endpointServerPtr;
}
}
if (endpointServerPtr)
{
RcfClient<I_EndpointBroker> client(clientTransportAutoPtr);
bool ok = client.openEndpoint(Twoway, endpointName, endpointClientPassword, endpointServerPassword);
if (ok)
{
boost::shared_ptr<I_Session> sessionPtr0( serverTransportEx.createServerSession(client.getClientStub().releaseTransport()) );
boost::shared_ptr<Session> sessionPtr( boost::static_pointer_cast<Session>(sessionPtr0) );
clientTransportAutoPtr = serverTransportEx.createClientTransport(sessionPtr0);
endpointServerPtr->mEndpointClientPassword = endpointClientPassword;
endpointServerPtr->mEndpointServerPassword = endpointServerPassword;
endpointServerPtr->mClients.push_back( EndpointServer::ClientPtr( new EndpointServer::Client(clientTransportAutoPtr) ) );
// weak_ptr so we don't get circular references session->endpointserverstub->clientConnection->session
EndpointServerWeakPtr endpointServerWeakPtr(endpointServerPtr);
boost::shared_ptr< I_Deref<EndpointServer> > derefPtr( new DerefWeakPtr<EndpointServer>(endpointServerWeakPtr) );
RcfClientPtr rcfClientPtr( RCF_createServerStub((I_EndpointServer *) 0, (EndpointServer *) 0, derefPtr) );
StubEntryPtr stubEntryPtr(new StubEntry);
stubEntryPtr->setRcfClientPtr(rcfClientPtr);
sessionPtr->setStubEntryPtr(stubEntryPtr);
return endpointServerPtr->getEndpointId();
}
else
{
WriteLock writeLock(mEndpointServersMutex);
mEndpointServers.erase( mEndpointServers.find( endpointServerPtr->getEndpointId()) );
}
}
return EndpointId();
}
void EndpointServerService::closeEndpoint(EndpointId endpointId)
{
WriteLock writeLock(mEndpointServersMutex);
mEndpointServers.erase( mEndpointServers.find(endpointId) );
}
} // namespace RCF
|
By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.
If a file you wish to view isn't highlighted, and is a text file (not binary), please
let us know and we'll add colourisation support for it.
Software developer, from Sweden and now living in Canberra, Australia, working on distributed C++ applications. When he is not programming, Jarl enjoys skiing and playing table tennis. He derives immense satisfaction from referring to himself in third person.