public void HandleClientMessage(IClientMessage message)
{
if (message.IsFlagSet(ClientMessage.ListenerEventFlag))
{
object state = message.GetPartitionId();
var eventTask = new Task(o =>
{
if (!_isShutDown)
{
HandleEventMessage(message);
}
}, state);
eventTask.Start(_taskScheduler);
}
else
{
_client.GetClientExecutionService().Submit(() =>
{
if (!_isShutDown)
{
HandleResponseMessage(message);
}
});
}
}
public void Start()
{
if (!_live.CompareAndSet(false, true))
{
return;
}
//start Heartbeat
_heartbeatToken = new CancellationTokenSource();
_client.GetClientExecutionService().ScheduleWithFixedDelay(Heartbeat,
(long)_heartbeatInterval.TotalMilliseconds,
(long)_heartbeatInterval.TotalMilliseconds,
TimeUnit.Milliseconds,
_heartbeatToken.Token);
}
private bool RetryRequest(ClientInvocation invocation, Exception exception)
{
var retryNr = invocation.IncrementAndGetRetryCount();
if (retryNr > _retryCount)
{
return(false);
}
Logger.Finest("Retry #" + retryNr + " for request " + invocation.Message);
_client.GetClientExecutionService().SubmitWithDelay(() =>
{
if (_isShutDown)
{
FailRequestDueToShutdown(invocation);
}
else
{
// get the appropriate connection for retry
var connection = GetConnectionForInvocation(invocation);
Send(connection, invocation);
}
}, _retryWaitTime).ContinueWith(t =>
{
if (t.IsFaulted)
{
var innerException = t.Exception.InnerExceptions.First();
Logger.Finest("Retry of request " + invocation.Message + " failed with ", innerException);
HandleException(invocation, innerException);
}
});
return(true);
}
public void Start()
{
if (_live)
{
return;
}
_live = true;
//start Heartbeat
_heartbeatToken = new CancellationTokenSource();
_client.GetClientExecutionService().ScheduleWithFixedDelay(Heartbeat,
_heartbeatInterval,
_heartbeatInterval,
TimeUnit.Milliseconds,
_heartbeatToken.Token);
}
public void HandleClientMessage(IClientMessage message)
{
if (message.IsFlagSet(ClientMessage.ListenerEventFlag))
{
_clientListenerService.HandleResponseMessage(message);
}
else
{
_client.GetClientExecutionService().Submit(() =>
{
if (!_isShutDown)
{
HandleResponseMessage(message);
}
});
}
}
public void ConnectionRemoved(ClientConnection connection)
{
var executionService = (ClientExecutionService)_client.GetClientExecutionService();
if (Equals(connection.GetAddress(), OwnerConnectionAddress))
{
if (_client.GetLifecycleService().IsRunning())
{
executionService.SubmitInternal(() =>
{
try
{
FireConnectionEvent(LifecycleEvent.LifecycleState.ClientDisconnected);
ConnectToCluster();
}
catch (Exception e)
{
Logger.Warning("Could not re-connect to cluster shutting down the client", e);
_client.GetLifecycleService().Shutdown();
}
});
}
}
}
public Task <ClientConnection> GetOrConnectAsync(Address address)
{
lock (_pendingConnections)
{
if (!_pendingConnections.ContainsKey(address))
{
var task = _client.GetClientExecutionService().Submit(() => GetOrConnect(address));
task.ContinueWith(t =>
{
lock (_pendingConnections)
{
_pendingConnections.Remove(address);
}
});
_pendingConnections[address] = task;
}
return(_pendingConnections[address]);
}
}
public string AddDistributedObjectListener(IDistributedObjectListener listener)
{
var request = ClientAddDistributedObjectListenerCodec.EncodeRequest(false);
var context = new ClientContext(_client.GetSerializationService(), _client.GetClientClusterService(),
_client.GetClientPartitionService(), _client.GetInvocationService(), _client.GetClientExecutionService(),
_client.GetListenerService(),
this, _client.GetClientConfig());
//EventHandler<PortableDistributedObjectEvent> eventHandler = new _EventHandler_211(this, listener);
DistributedEventHandler eventHandler = delegate(IClientMessage message)
{
ClientAddDistributedObjectListenerCodec.AbstractEventHandler.Handle(message,
(name, serviceName, type) =>
{
var ns = new ObjectNamespace(serviceName, name);
ClientProxy proxy;
_proxies.TryGetValue(ns, out proxy);
if (proxy == null)
{
proxy = GetProxy(serviceName, name);
}
var _event = new DistributedObjectEvent(type, serviceName, proxy);
if (DistributedObjectEvent.EventType.Created.Equals(type))
{
listener.DistributedObjectCreated(_event);
}
else
{
if (DistributedObjectEvent.EventType.Destroyed.Equals(type))
{
listener.DistributedObjectDestroyed(_event);
}
}
});
};
//PortableDistributedObjectEvent
return(context.GetListenerService()
.StartListening(request, eventHandler,
m => ClientAddDistributedObjectListenerCodec.DecodeResponse(m).response));
}
public string AddDistributedObjectListener(IDistributedObjectListener listener)
{
var isSmart = _client.GetClientConfig().GetNetworkConfig().IsSmartRouting();
var request = ClientAddDistributedObjectListenerCodec.EncodeRequest(isSmart);
var context = new ClientContext(_client.GetSerializationService(), _client.GetClientClusterService(),
_client.GetClientPartitionService(), _client.GetInvocationService(), _client.GetClientExecutionService(),
_client.GetListenerService(), _client.GetNearCacheManager(), this, _client.GetClientConfig());
DistributedEventHandler eventHandler = delegate(IClientMessage message)
{
ClientAddDistributedObjectListenerCodec.EventHandler.HandleEvent(message, (name, serviceName, eventType) =>
{
var _event = new LazyDistributedObjectEvent(eventType, serviceName, name, this);
switch (eventType)
{
case DistributedObjectEvent.EventType.Created:
listener.DistributedObjectCreated(_event);
break;
case DistributedObjectEvent.EventType.Destroyed:
listener.DistributedObjectDestroyed(_event);
break;
default:
Logger.Warning(string.Format("Undefined DistributedObjectListener event type received: {0} !!!",
eventType));
break;
}
});
};
return(context.GetListenerService().RegisterListener(request,
m => ClientAddDistributedObjectListenerCodec.DecodeResponse(m).response,
ClientRemoveDistributedObjectListenerCodec.EncodeRequest, eventHandler));
}
public void RefreshPartitions()
{
_client.GetClientExecutionService().Submit(() => { GetPartitions(); }).IgnoreExceptions();
}