DispatchStatus
Ice::BlobjectArray::__dispatch(Incoming& in, const Current& current)
{
pair<const Byte*, const Byte*> inEncaps;
Int sz;
in.readParamEncaps(inEncaps.first, sz);
inEncaps.second = inEncaps.first + sz;
vector<Byte> outEncaps;
bool ok = ice_invoke(inEncaps, outEncaps, current);
if(outEncaps.empty())
{
in.__writeParamEncaps(0, 0, ok);
}
else
{
in.__writeParamEncaps(&outEncaps[0], static_cast<Ice::Int>(outEncaps.size()), ok);
}
if(ok)
{
return DispatchOK;
}
else
{
return DispatchUserException;
}
}
DispatchStatus
Ice::Object::___ice_ping(Incoming& __inS, const Current& __current)
{
__inS.readEmptyParams();
ice_ping(__current);
__inS.__writeEmptyParams();
return DispatchOK;
}
void KeyValueStore::InternalThread::incomingRoutine()
{
const Config::ServerInformation& info = config.getServerInformation();
Config::ThreadControl& control = config.getThreadControl();
Mutex& inMutex = control.getInMutex();
Condition& cond = control.getInCondition();
Thread incoming;
Incoming inTask;
int currId = -1;
static bool first = true;
// Init connection info
SocketAddress sock(info.address, info.internalPort);
ServerSocket server;
try {
server.bind(sock, true);
server.listen(5);
} catch(Exception& e) {
printKv("Could not initialize internal thread, please restart server ("<< e.displayText()<< ")");
}
StreamSocket client;
while(control.isLive()) {
inMutex.lock();
cond.wait(inMutex);
unsigned nextId = control.getConnectedId();
inMutex.unlock();
// NOTE: From a security perspective this is not safe.
// if someone tries to connect at the same time a rejoin
// was initiated, they could easily perform a MITM attack.
// However, since this is an academic exercise, I am not too
// concerned with security (as can be seen by many other components
// in this system as well).
if(currId != (int)nextId) {
currId = nextId;
// TODO: Update processing thread somehow
printKv("Told a new server should be connecting...");
try {
client = server.acceptConnection();
printKv("Incoming server connected: "<< currId);
inTask.cancel();
if(!first)
incoming.join();
first = false;
inTask = Incoming(client, &config.getThreadControl());
incoming.start(inTask);
printKv("Handling new server");
} catch(TimeoutException& e) {
printKv("Server did not connect in time - we don't want the system to be hung up, though ("<< e.displayText() <<")");
}
}
}
server.close();
}
IncomingAsyncPtr
IceInternal::IncomingAsync::create(Incoming& in)
{
IncomingAsyncPtr self = make_shared<IncomingAsync>(in);
if(in.isRetriable())
{
in.setActive(self->shared_from_this());
}
return self;
}
DispatchStatus
Ice::Object::___ice_id(Incoming& __inS, const Current& __current)
{
__inS.readEmptyParams();
string __ret = ice_id(__current);
BasicStream* __os = __inS.__startWriteParams(DefaultFormat);
__os->write(__ret, false);
__inS.__endWriteParams(true);
return DispatchOK;
}
DispatchStatus
Ice::Object::___ice_ids(Incoming& __inS, const Current& __current)
{
__inS.readEmptyParams();
vector<string> __ret = ice_ids(__current);
BasicStream* __os = __inS.__startWriteParams(DefaultFormat);
__os->write(&__ret[0], &__ret[0] + __ret.size(), false);
__inS.__endWriteParams(true);
return DispatchOK;
}
IceInternal::IncomingAsync::IncomingAsync(Incoming& in) :
IncomingBase(in),
_instanceCopy(_os.instance()),
_responseHandlerCopy(_responseHandler),
_retriable(in.isRetriable()),
_active(true)
{
if(_retriable)
{
in.setActive(*this);
}
}
DispatchStatus
Ice::Object::___ice_isA(Incoming& __inS, const Current& __current)
{
BasicStream* __is = __inS.startReadParams();
string __id;
__is->read(__id, false);
__inS.endReadParams();
bool __ret = ice_isA(__id, __current);
BasicStream* __os = __inS.__startWriteParams(DefaultFormat);
__os->write(__ret);
__inS.__endWriteParams(true);
return DispatchOK;
}
IceInternal::IncomingAsync::IncomingAsync(Incoming& in) :
IncomingBase(in),
_instanceCopy(_os.instance()),
_responseHandlerCopy(_responseHandler->shared_from_this()), // Acquire reference on response handler
_retriable(in.isRetriable()),
_active(true)
{
#ifndef ICE_CPP11_MAPPING
if(_retriable)
{
in.setActive(this);
}
#endif
}
void
IceInternal::IncomingAsync::__deactivate(Incoming& in)
{
assert(_retriable);
{
IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
if(!_active)
{
//
// Since _deactivate can only be called on an active object,
// this means the response has already been sent (see __validateXXX below)
//
throw ResponseSentException(__FILE__, __LINE__);
}
_active = false;
}
in.__adopt(*this);
}
DispatchStatus
Ice::BlobjectAsync::__dispatch(Incoming& in, const Current& current)
{
const Byte* inEncaps;
Int sz;
in.readParamEncaps(inEncaps, sz);
AMD_Object_ice_invokePtr cb = new ::IceAsync::Ice::AMD_Object_ice_invoke(in);
try
{
ice_invoke_async(cb, vector<Byte>(inEncaps, inEncaps + sz), current);
}
catch(const ::std::exception& ex)
{
cb->ice_exception(ex);
}
catch(...)
{
cb->ice_exception();
}
return DispatchAsync;
}
DispatchStatus
Ice::BlobjectArrayAsync::__dispatch(Incoming& in, const Current& current)
{
pair<const Byte*, const Byte*> inEncaps;
Int sz;
in.readParamEncaps(inEncaps.first, sz);
inEncaps.second = inEncaps.first + sz;
AMD_Object_ice_invokePtr cb = new ::IceAsync::Ice::AMD_Object_ice_invoke(in);
try
{
ice_invoke_async(cb, inEncaps, current);
}
catch(const ::std::exception& ex)
{
cb->ice_exception(ex);
}
catch(...)
{
cb->ice_exception();
}
return DispatchAsync;
}
