private Task ProcessReceiveRequest(ITransportConnection connection)
{
Func <Task> initialize = null;
bool newConnection = Heartbeat.AddConnection(this);
if (IsConnectRequest)
{
if (newConnection)
{
initialize = Connected;
_counters.ConnectionsConnected.Increment();
}
}
else if (IsReconnectRequest)
{
initialize = Reconnected;
}
var series = new Func <object, Task>[]
{
state => ((Func <Task>)state).Invoke(),
state => ((Func <Task>)state).Invoke()
};
var states = new object[] { TransportConnected ?? _emptyTaskFunc,
initialize ?? _emptyTaskFunc };
Func <Task> fullInit = () => TaskAsyncHelper.Series(series, states);
return(ProcessMessages(connection, fullInit));
}
private Task ProcessReceiveRequest(ITransportConnection connection)
{
Func <Task> initialize = null;
// If this transport isn't replacing an existing transport, oldConnection will be null.
ITrackingConnection oldConnection = Heartbeat.AddOrUpdateConnection(this);
bool newConnection = oldConnection == null;
if (IsConnectRequest)
{
Func <Task> connected;
if (newConnection)
{
connected = Connected ?? _emptyTaskFunc;
_counters.ConnectionsConnected.Increment();
}
else
{
// Wait until the previous call to Connected completes.
// We don't want to call Connected twice
connected = () => oldConnection.ConnectTask;
}
initialize = () =>
{
return(connected().Then((conn, id) => conn.Initialize(id), connection, ConnectionId));
};
}
else
{
initialize = Reconnected;
}
var series = new Func <object, Task>[]
{
state => ((Func <Task>)state).Invoke(),
state => ((Func <Task>)state).Invoke()
};
var states = new object[] { TransportConnected ?? _emptyTaskFunc,
initialize ?? _emptyTaskFunc };
Func <Task> fullInit = () => TaskAsyncHelper.Series(series, states).ContinueWith(_connectTcs);
return(ProcessMessages(connection, fullInit));
}
private Task ProcessReceiveRequestWithoutTracking(ITransportConnection connection, Func <Task> postReceive = null)
{
Func <Task> afterReceive = () =>
{
return(TaskAsyncHelper.Series(OnTransportConnected,
() =>
{
if (postReceive != null)
{
return postReceive();
}
return TaskAsyncHelper.Empty;
},
() => InitializeResponse(connection)));
};
return(ProcessMessages(connection, afterReceive));
}
private Task ProcessReceiveRequestWithoutTracking(ITransportConnection connection, Func <Task> postReceive = null)
{
if (TransportConnected != null)
{
TransportConnected().Catch();
}
// ReceiveAsync() will async wait until a message arrives then return
var receiveTask = IsConnectRequest ?
connection.ReceiveAsync(null, ConnectionEndToken, MaxMessages) :
connection.ReceiveAsync(MessageId, ConnectionEndToken, MaxMessages);
return(TaskAsyncHelper.Series(() =>
{
if (postReceive != null)
{
return postReceive();
}
return TaskAsyncHelper.Empty;
},
() =>
{
return receiveTask.Then(response =>
{
response.TimedOut = IsTimedOut;
if (response.Aborted)
{
// If this was a clean disconnect then raise the event
OnDisconnect();
}
return Send(response);
});
}));
}
