private void Execute <T>(Func <IDbCommand, Task <T> > commandFunc, DispatchingTaskCompletionSource <T> tcs)
{
IDbConnection connection = null;
try
{
connection = _dbProviderFactory.CreateConnection();
connection.ConnectionString = ConnectionString;
var command = CreateCommand(connection);
connection.Open();
commandFunc(command)
.Then(result => tcs.SetResult(result))
.Catch(ex => tcs.SetUnwrappedException(ex), Trace)
.Finally(state =>
{
var conn = (DbConnection)state;
if (conn != null)
{
conn.Dispose();
}
}, connection);
}
catch (Exception)
{
if (connection != null)
{
connection.Dispose();
}
throw;
}
}
private Task ExecuteHubEvent(IRequest request, string connectionId, Func <IHub, Task> action)
{
var hubs = GetHubs(request, connectionId).ToList();
var operations = hubs.Select(instance => action(instance).OrEmpty().Catch(Trace)).ToArray();
if (operations.Length == 0)
{
DisposeHubs(hubs);
return(TaskAsyncHelper.Empty);
}
var tcs = new DispatchingTaskCompletionSource <object>();
Task.Factory.ContinueWhenAll(operations, tasks =>
{
DisposeHubs(hubs);
var faulted = tasks.FirstOrDefault(t => t.IsFaulted);
if (faulted != null)
{
tcs.SetUnwrappedException(faulted.Exception);
}
else if (tasks.Any(t => t.IsCanceled))
{
tcs.SetCanceled();
}
else
{
tcs.SetResult(null);
}
});
return(tcs.Task);
}
public static Task <string> ReadAsString(this IResponse response, Func <ArraySegment <byte>, bool> onChunk)
{
if (response == null)
{
throw new ArgumentNullException("response");
}
var stream = response.GetStream();
var reader = new AsyncStreamReader(stream);
var result = new StringBuilder();
var resultTcs = new DispatchingTaskCompletionSource <string>();
reader.Data = buffer =>
{
if (onChunk(buffer))
{
result.Append(Encoding.UTF8.GetString(buffer.Array, buffer.Offset, buffer.Count));
}
};
reader.Closed = exception =>
{
response.Dispose();
resultTcs.SetResult(result.ToString());
};
reader.Start();
return(resultTcs.Task);
}
private void Execute <T>(Func <IQuery, Task <T> > commandFunc, DispatchingTaskCompletionSource <T> tcs)
{
using (var session = SessionFactoryInfo.SessionFactory.OpenSession())
{
var command = CreateCommand(session);
commandFunc(command)
.Then(result => tcs.SetResult(result))
.Catch(ex => tcs.SetUnwrappedException(ex), Trace);
}
}
private void ResolveTransport(IConnection connection, string data, CancellationToken disconnectToken, DispatchingTaskCompletionSource <object> tcs, int index)
{
// Pick the current transport
IClientTransport transport = _transports[index];
transport.Start(connection, data, disconnectToken).ContinueWith(task =>
{
if (task.IsFaulted || task.IsCanceled)
{
Exception ex;
if (task.IsCanceled)
{
ex = new OperationCanceledException(Resources.Error_TaskCancelledException);
}
else
{
ex = task.Exception.GetBaseException();
}
connection.Trace(TraceLevels.Events, "Auto: Failed to connect to using transport {0}. {1}", transport.Name, ex);
// If that transport fails to initialize, then fallback.
// If it is that /start request that failed, do not fallback.
var next = index + 1;
if (next < _transports.Count && !(ex is StartException))
{
// Try the next transport
ResolveTransport(connection, data, disconnectToken, tcs, next);
}
else
{
// If there's nothing else to try then just fail
tcs.SetException(ex);
}
}
else
{
// Set the active transport
_transport = transport;
// Complete the process
tcs.SetResult(null);
}
},
TaskContinuationOptions.ExecuteSynchronously);
}
public virtual Task <int> ExecuteNonQueryAsync()
{
var tcs = new DispatchingTaskCompletionSource <int>();
return(new Task <int>(() =>
{
int a;
try
{
a = ExecuteNonQuery();
tcs.SetResult(a);
return a;
}
catch (Exception ex)
{
tcs.SetUnwrappedException(ex);
throw;
}
}));
}
private Task StartTransport()
{
return(_transport.Start(this, _connectionData, _disconnectCts.Token)
.RunSynchronously(() =>
{
// NOTE: We have tests that rely on this state change occuring *BEFORE* the start task is complete
ChangeState(ConnectionState.Connecting, ConnectionState.Connected);
// Now that we're connected complete the start task that the
// receive queue is waiting on
_startTcs.SetResult(null);
// Start the monitor to check for server activity
_lastMessageAt = DateTime.UtcNow;
_lastActiveAt = DateTime.UtcNow;
Monitor.Start();
})
// Don't return until the last receive has been processed to ensure messages/state sent in OnConnected
// are processed prior to the Start() method task finishing
.Then(() => _lastQueuedReceiveTask));
}