void ObjectRegistrar::onFutureFinished(qi::Future<unsigned int> fut, long id, qi::Promise<unsigned int> result)
{
if (fut.hasError()) {
result.setError(fut.error());
return;
}
qi::ServiceInfo si;
RegisterServiceMap::iterator it;
{
boost::mutex::scoped_lock sl(_registerServiceRequestMutex);
it = _registerServiceRequest.find(id);
if (it != _registerServiceRequest.end())
si = it->second.second;
if (fut.hasError()) {
_registerServiceRequest.erase(id);
result.setError(fut.error());
return;
}
}
unsigned int idx = fut.value();
si.setServiceId(idx);
{
boost::mutex::scoped_lock sl(_servicesMutex);
BoundService bs;
bs.id = idx;
bs.object = it->second.first;
bs.serviceInfo = si;
bs.name = si.name();
BoundServiceMap::iterator it;
it = _services.find(idx);
if (it != _services.end()) {
qiLogError() << "A service is already registered with that id:" << idx;
result.setError("Service already registered.");
return;
}
_services[idx] = bs;
//todo register the object on the server (find a better way)
Server::addObject(idx, bs.object);
}
{
boost::mutex::scoped_lock sl(_serviceNameToIndexMutex);
_serviceNameToIndex[si.name()] = idx;
}
{
boost::mutex::scoped_lock sl(_registerServiceRequestMutex);
_registerServiceRequest.erase(it);
}
// ack the Service directory to tell that we are ready
qi::Future<void> fut2 = _sdClient->serviceReady(idx);
fut2.connect(boost::bind(&serviceReady, _1, result, idx));
}
void serviceReady(qi::Future<void> fut, qi::Promise<unsigned int> result, unsigned int idx) {
if (fut.hasError()) {
result.setError(fut.error());
return;
}
result.setValue(idx);
}
static void onEventConnected(RemoteObject* ro, qi::Future<SignalLink> fut, qi::Promise<SignalLink> prom, SignalLink id) {
if (fut.hasError()) {
prom.setError(fut.error());
return;
}
prom.setValue(id);
}
static void call_from_java_cont(qi::Future<qi::AnyReference> ret,
qi::Promise<qi::AnyValue> promise)
{
if (ret.hasError())
promise.setError(ret.error());
else
promise.setValue(qi::AnyValue(ret.value(), false, true));
}
void RemoteObject::onMetaObject(qi::Future<qi::MetaObject> fut, qi::Promise<void> prom) {
if (fut.hasError()) {
qiLogVerbose() << "MetaObject error: " << fut.error();
prom.setError(fut.error());
return;
}
qiLogVerbose() << "Fetched metaobject";
setMetaObject(fut.value());
prom.setValue(0);
}
void SessionPrivate::listenStandaloneCont(qi::Promise<void> p, qi::Future<void> f)
{
if (f.hasError())
p.setError(f.error());
else
{
_sdClient.setServiceDirectory(boost::static_pointer_cast<ServiceBoundObject>(_sd._serviceBoundObject)->object());
// _sdClient will trigger its connected, which will trigger our connected
p.setValue(0);
}
}
void SessionPrivate::addSdSocketToCache(Future<void> f, const qi::Url& url,
qi::Promise<void> p)
{
qiLogDebug() << "addSocketToCache processing";
if (f.hasError())
{
qiLogDebug() << "addSdSocketToCache: connect reported failure";
_serviceHandler.removeService("ServiceDirectory");
p.setError(f.error());
return;
}
// Allow the SD process to use the existing socket to talk to our services
_serverObject.registerSocket(_sdClient.socket());
/* Allow reusing the SD socket for communicating with services.
* To do this, we must add it to our socket cache, and for this we need
* to know the sd machineId
*/
std::string mid;
try
{
mid = _sdClient.machineId();
}
catch (const std::exception& e)
{ // Provide a nice message for backward compatibility
qiLogVerbose() << e.what();
qiLogWarning() << "Failed to obtain machineId, connection to service directory will not be reused for other services.";
p.setValue(0);
return;
}
TransportSocketPtr s = _sdClient.socket();
qiLogVerbose() << "Inserting sd to cache for " << mid <<" " << url.str() << std::endl;
_socketsCache.insert(mid, s->remoteEndpoint(), s);
p.setValue(0);
}