public override async Task HandleTcpConnection(InConnectionTcp connection)
{
Exception e = null;
ConnectResult connectResult = null;
try {
connectResult = await Connect(connection);
} catch (Exception ex) when(if_failed != null)
{
Logging.exception(ex, Logging.Level.Error, $"{this}: {connection} failed ({connectResult.FailedReason}), redirecting to {if_failed}.");
connection.RedirectTo(if_failed);
return;
}
if (!connectResult.Ok && if_failed != null)
{
Logging.warning($": {connection} failed ({connectResult.FailedReason}), redirecting to {if_failed}.");
connection.RedirectTo(if_failed);
return;
}
try {
if (connectResult.Ok)
{
await connection.HandleAndPutStream(this, connectResult.Stream, connectResult.WhenCanRead);
}
else
{
await connection.HandleAndGetStream(connectResult);
}
} finally {
if (connectResult.Ok)
{
MyStream.CloseWithTimeout(connectResult.Stream);
}
}
}
public Task HandleAndPutStream(IAdapter outAdapter, IMyStream stream, Task waitForReadFromStream = null)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
var result = new ConnectResult(outAdapter, ConnectResultEnum.OK, stream)
{
WhenCanRead = waitForReadFromStream
};
return(SetResult(result));
}
public async Task <ConnectResult> Connect(ConnectArgument arg)
{
try {
var result = await ProtectedConnect(arg);
if (!result.IsRedirected && !result.Ok && if_failed != null)
{
Logging.error(ToString() + $": {arg} failed ({result.FailedReason}), redirecting to {if_failed}.");
return(ConnectResult.RedirectTo(this, if_failed));
}
return(result);
} catch (Exception ex) when(if_failed != null)
{
Logging.exception(ex, Logging.Level.Error, ToString() + $": {arg} failed, redirecting to {if_failed}.");
return(ConnectResult.RedirectTo(this, if_failed));
} catch (Exception) {
throw;
}
}
public Task <ConnectResponse> Connect(ConnectRequest request, IAdapter outAdapter)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
ConnectResult result;
if (outAdapter == null)
{
warning($"'{request.InAdapter.Name}' {request} -> (no out adapter)");
result = new ConnectResult(this, "no out adapter");
return(Task.FromResult(new ConnectResponse(result, request)));
}
request.tcs = new TaskCompletionSource <ConnectResponse>();
HandleInConnection(request, outAdapter as IConnectionHandler).Forget();
return(request.tcs.Task);
}
public static Task <ConnectResult> ConnectWrapper(IConnectionHandler handler, ConnectArgument arg)
{
var tcs = new TaskCompletionSource <ConnectResult>();
var newinc = InConnectionTcp.Create(arg.InAdapter, arg.Dest, async(r) => {
if (r.Ok)
{
var stream = new LoopbackStream();
r.Stream = stream;
tcs.SetResult(r);
return(stream.Another);
}
else
{
tcs.SetResult(r);
return(null);
}
});
newinc.Url = arg.Url;
newinc.DestOriginalName = arg.DestOriginalName;
NaiveUtils.RunAsyncTask(async() => {
try {
await handler.HandleTcpConnection(newinc).CAF();
} catch (Exception e) {
tcs.SetException(e);
return;
}
if (newinc.IsRedirected && tcs.Task.IsCompleted == false)
{
tcs.SetResult(ConnectResult.RedirectTo(handler, newinc.Redirected));
}
else
{
tcs.SetException(new Exception("handleConnection() did nothing."));
}
});
return(tcs.Task);
}
public async Task <IMyStream> HandleAndGetStream(ConnectResult result)
{
await SetResult(result);
return(DataStream);
}
public ConnectResponse(ConnectResult r, ConnectRequest req)
{
this.Result = r;
this.Request = req;
}
void SetConnectResponse(ConnectResult r)
{
tcs.SetResult(new ConnectResponse(r, this));
}
