/// <summary>
/// Builds a <see cref="ClientChannel"/> instance connecting the transport.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <IClientChannel> BuildAsync(CancellationToken cancellationToken)
{
var transport = _transportFactory();
if (!transport.IsConnected)
{
await transport.OpenAsync(ServerUri, cancellationToken).ConfigureAwait(false);
}
var clientChannel = new ClientChannel(
transport,
SendTimeout,
EnvelopeBufferSize,
autoReplyPings: false,
consumeTimeout: ConsumeTimeout,
closeTimeout: CloseTimeout,
channelCommandProcessor: ChannelCommandProcessor);
try
{
foreach (var moduleFactory in _messageChannelModules.ToList())
{
clientChannel.MessageModules.Add(moduleFactory(clientChannel));
}
foreach (var moduleFactory in _notificationChannelModules.ToList())
{
clientChannel.NotificationModules.Add(moduleFactory(clientChannel));
}
foreach (var moduleFactory in _commandChannelModules.ToList())
{
clientChannel.CommandModules.Add(moduleFactory(clientChannel));
}
foreach (var handler in _builtHandlers.ToList())
{
cancellationToken.ThrowIfCancellationRequested();
await handler(clientChannel, cancellationToken).ConfigureAwait(false);
}
}
catch
{
clientChannel.DisposeIfDisposable();
throw;
}
return(clientChannel);
}
private static async Task<IClientChannel> ConnectAsync()
{
var transport = new TcpTransport ();
await transport.OpenAsync (
new Uri ("net.tcp://iris.limeprotocol.org:55321"),
CancellationToken.None);
var channel = new ClientChannel (
transport,
TimeSpan.FromSeconds (60));
return channel;
}
public async Task LoginAsync()
{
IClientChannel client = null;
ITraceWriter traceWriter = null;
if (ShowTraceWindow)
{
traceWriter = Owner.TraceViewModel;
base.MessengerInstance.Send<OpenWindowMessage>(
new OpenWindowMessage()
{
WindowName = "Trace",
DataContext = Owner.TraceViewModel
});
}
IsBusy = true;
this.ErrorMessage = string.Empty;
try
{
var cancellationToken = _loginTimeout.ToCancellationToken();
var transport = new TcpTransport(traceWriter: traceWriter);
await transport.OpenAsync(_serverAddressUri, cancellationToken);
client = new ClientChannel(
transport,
_sendTimeout,
fillEnvelopeRecipients: true,
autoReplyPings: true,
autoNotifyReceipt: true);
if (RegisterUser)
{
var guestSessionResult = await client.EstablishSessionAsync(
compressionOptions => compressionOptions.First(),
encryptionOptions => SessionEncryption.TLS,
new Identity() { Name = Guid.NewGuid().ToString(), Domain = _userNameNode.Domain },
(schemeOptions, roundtrip) => new GuestAuthentication(),
null,
cancellationToken
);
if (guestSessionResult.State == SessionState.Established)
{
// Creates the account
var account = new Account()
{
Password = this.Password.ToBase64()
};
await client.SetResourceAsync<Account>(
LimeUri.Parse(UriTemplates.ACCOUNT),
account,
_userNameNode,
cancellationToken);
await client.SendFinishingSessionAsync();
await client.ReceiveFinishedSessionAsync(cancellationToken);
client.DisposeIfDisposable();
transport = new TcpTransport(traceWriter: traceWriter);
await transport.OpenAsync(_serverAddressUri, cancellationToken);
client = new ClientChannel(
transport,
_sendTimeout,
fillEnvelopeRecipients: true,
autoReplyPings: true,
autoNotifyReceipt: true);
}
else if (guestSessionResult.Reason != null)
{
this.ErrorMessage = guestSessionResult.Reason.Description;
}
else
{
this.ErrorMessage = "Could not establish a guest session with the server";
}
}
var authentication = new PlainAuthentication();
authentication.SetToBase64Password(this.Password);
var sessionResult = await client.EstablishSessionAsync(
compressionOptions => compressionOptions.First(),
encryptionOptions => SessionEncryption.TLS,
new Identity() { Name = _userNameNode.Name, Domain = _userNameNode.Domain },
(schemeOptions, roundtrip) => authentication,
_userNameNode.Instance,
cancellationToken);
if (sessionResult.State == SessionState.Established)
{
var rosterViewModel = new RosterViewModel(client, this);
base.Owner.ContentViewModel = rosterViewModel;
}
else if (sessionResult.Reason != null)
{
this.ErrorMessage = sessionResult.Reason.Description;
}
else
{
this.ErrorMessage = "Could not connect to the server";
}
}
catch (Exception ex)
{
ErrorMessage = ex.Message;
client.DisposeIfDisposable();
}
finally
{
IsBusy = false;
}
}