/// <summary>
/// Start discovering.
/// </summary>
public async Task StartAsync()
{
if (!IsStarted)
{
_discoveredServices = new List <ResonanceSignalRDiscoveredService <TReportedServiceInformation> >();
_client = SignalRClientFactory.Default.Create(Mode, HubUrl);
_client.EnableAutoReconnection = EnableAutoReconnection;
_client.Error += OnDisconnected;
await _client.StartAsync();
await _client.InvokeAsync(ResonanceHubMethods.RegisterDiscoveryClient, Credentials);
var services = await _client.InvokeAsync <List <TReportedServiceInformation> >(ResonanceHubMethods.GetAvailableServices, Credentials);
foreach (var serviceInfo in services)
{
OnServiceRegistered(serviceInfo);
}
_client.On <TReportedServiceInformation>(ResonanceHubMethods.ServiceRegistered, OnServiceRegistered);
_client.On <TReportedServiceInformation>(ResonanceHubMethods.ServiceUnRegistered, OnServiceUnregistered);
IsStarted = true;
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
if (Connection.State == HubConnectionState.Disconnected)
{
await _client.StartAsync(cancellationToken);
}
}
/// <summary>
/// Gets the collection of available services for the provided credentials.
/// </summary>
/// <typeparam name="TCredentials">The type of the credentials.</typeparam>
/// <typeparam name="TReportedServiceInformation">The type of the reported service information.</typeparam>
/// <param name="credentials">The credentials.</param>
/// <param name="url">The URL.</param>
/// <param name="mode">The mode.</param>
/// <returns></returns>
public async Task <List <TReportedServiceInformation> > GetAvailableServicesAsync <TCredentials, TReportedServiceInformation>(TCredentials credentials, String url, SignalRMode mode) where TReportedServiceInformation : IResonanceServiceInformation
{
ISignalRClient client = SignalRClientFactory.Default.Create(mode, url);
await client.StartAsync();
var services = await client.InvokeAsync <List <TReportedServiceInformation> >(ResonanceHubMethods.GetAvailableServices, credentials);
await client.DisposeAsync();
return(services);
}
/// <summary>
/// Registers a new Resonance SignalR service.
/// </summary>
/// <typeparam name="TCredentials">The type of the credentials.</typeparam>
/// <typeparam name="TResonanceServiceInformation">The type of the resonance service information.</typeparam>
/// <typeparam name="TAdapterInformation">The type of the adapter information.</typeparam>
/// <param name="credentials">The credentials used to authenticate the service.</param>
/// <param name="serviceInformation">The service information.</param>
/// <param name="url">The hub URL.</param>
/// <param name="mode">The SignalR mode (legacy/core).</param>
/// <returns></returns>
public async Task <ResonanceRegisteredService <TCredentials, TResonanceServiceInformation, TAdapterInformation> > RegisterServiceAsync <TCredentials, TResonanceServiceInformation, TAdapterInformation>(TCredentials credentials, TResonanceServiceInformation serviceInformation, String url, SignalRMode mode) where TResonanceServiceInformation : IResonanceServiceInformation
{
Logger.LogDebug($"Registering service {{@ServiceInformation}}...", serviceInformation);
ISignalRClient client = SignalRClientFactory.Default.Create(mode, url);
client.EnableAutoReconnection = true;
await client.StartAsync();
await client.InvokeAsync(ResonanceHubMethods.Login, credentials);
await client.InvokeAsync(ResonanceHubMethods.RegisterService, serviceInformation);
return(new ResonanceRegisteredService <TCredentials, TResonanceServiceInformation, TAdapterInformation>(credentials, serviceInformation, mode, client));
}
/// <summary>
/// Called when the adapter is connecting.
/// </summary>
/// <returns></returns>
protected override Task OnConnect()
{
bool completed = false;
TaskCompletionSource <object> completionSource = new TaskCompletionSource <object>();
Task.Factory.StartNew(() =>
{
try
{
_client = SignalRClientFactory.Default.Create(Mode, Url);
_client.StartAsync().GetAwaiter().GetResult();
if (Role == SignalRAdapterRole.Connect)
{
_client.On(ResonanceHubMethods.Connected, () =>
{
try
{
if (!completed)
{
completed = true;
completionSource.SetResult(true);
}
}
catch (Exception ex)
{
if (!completed)
{
Logger.LogError(ex, "Error occurred after successful connection.");
completed = true;
completionSource.SetException(ex);
}
}
});
_client.On(ResonanceHubMethods.Declined, () =>
{
try
{
if (!completed)
{
completed = true;
var ex = new ConnectionDeclinedException();
Logger.LogError(ex, "Error occurred after session created.");
completionSource.SetException(ex);
}
}
catch (Exception ex)
{
if (!completed)
{
Logger.LogError(ex, "Error occurred after session created.");
completed = true;
completionSource.SetException(ex);
}
}
});
}
_client.On(ResonanceHubMethods.Disconnected, () =>
{
if (State == ResonanceComponentState.Connected)
{
//OnDisconnect(false); //Don't know what to do here.. We already have the resonance disconnection message.
//Maybe just raise an event..
}
});
_client.On(ResonanceHubMethods.ServiceDown, () =>
{
OnFailed(new ServiceDownException());
});
Logger.LogInformation("Authenticating with the remote hub {HubUrl}...", _client.Url);
_client.InvokeAsync(ResonanceHubMethods.Login, Credentials).GetAwaiter().GetResult();
if (Role == SignalRAdapterRole.Connect)
{
Logger.LogInformation("Connecting to service {ServiceId}...", ServiceId);
SessionId = _client.InvokeAsync <String>(ResonanceHubMethods.Connect, ServiceId).GetAwaiter().GetResult();
}
else
{
Logger.LogInformation("Accepting connection {SessionId}...", SessionId);
_client.InvokeAsync(ResonanceHubMethods.AcceptConnection, SessionId).GetAwaiter().GetResult();
if (!completed)
{
completed = true;
completionSource.SetResult(true);
}
}
_client.On <byte[]>(ResonanceHubMethods.DataAvailable, (data) => { OnDataAvailable(data); });
_client.Error += OnError;
_client.Reconnecting += OnReconnecting;
_client.Reconnected += OnReconnected;
}
catch (Exception ex)
{
completed = true;
Logger.LogError(ex, "Error occurred while trying to connect.");
completionSource.SetException(ex);
}
});
TimeoutTask.StartNew(() =>
{
if (!completed)
{
completed = true;
completionSource.SetException(new TimeoutException("Could not connect after the given timeout."));
}
}, ConnectionTimeout);
return(completionSource.Task);
}