internal static bool NotFound(this ResponseAdapter response)
{
response.SetHeader(HeaderConstants.TusResumable, HeaderConstants.TusResumableValue);
response.SetHeader(HeaderConstants.CacheControl, HeaderConstants.NoStore);
response.SetStatus((int)HttpStatusCode.NotFound);
return(true);
}
/// <summary>
/// Handles the tus.io request.
/// </summary>
/// <param name="context">The IOwinContext</param>
/// <returns></returns>
public override async Task Invoke(IOwinContext context)
{
var request = new RequestAdapter
{
Headers = context.Request.Headers.ToDictionary(f => f.Key, f => f.Value.ToList(), StringComparer.OrdinalIgnoreCase),
Body = context.Request.Body,
Method = context.Request.Method,
RequestUri = context.Request.Uri
};
var response = new ResponseAdapter
{
Body = context.Response.Body,
SetHeader = (key, value) => context.Response.Headers[key] = value,
SetStatus = status => context.Response.StatusCode = status
};
var config = await _configFactory(context.Request);
var handled = await TusProtocolHandler.Invoke(new ContextAdapter
{
Request = request,
Response = response,
Configuration = config,
CancellationToken = context.Request.CallCancelled
});
if (!handled)
{
await Next.Invoke(context);
}
}
internal static async Task <bool> Error(this ResponseAdapter response, HttpStatusCode statusCode, string message)
{
response.SetHeader(HeaderConstants.ContentType, "text/plain");
response.SetHeader(HeaderConstants.TusResumable, HeaderConstants.TusResumableValue);
response.SetStatus((int)statusCode);
var buffer = new UTF8Encoding().GetBytes(message);
await response.Body.WriteAsync(buffer, 0, buffer.Length);
return(true);
}
public static ResponseAdapter RegraBuscaCarta(string cidade)
{
var response = new ResponseAdapter();
response.isSucess = !string.IsNullOrWhiteSpace(cidade);
response.details = string.IsNullOrWhiteSpace(cidade) ? "Informe alguma cidade" : "";
response.returnBody = null;
return(response);
}
/// <summary>
/// Handles the tus.io request.
/// </summary>
/// <param name="context">The HttpContext</param>
/// <returns></returns>
public async Task Invoke(HttpContext context)
{
var config = await _configFactory(context);
if (config == null)
{
await _next(context);
return;
}
var requestUri = GetRequestUri(context);
if (!TusProtocolHandlerIntentBased.RequestIsForTusEndpoint(requestUri, config))
{
await _next(context);
return;
}
var request = new RequestAdapter(config.UrlPath)
{
Headers =
context.Request.Headers.ToDictionary(
f => f.Key,
f => f.Value.ToList(),
StringComparer.OrdinalIgnoreCase),
Body = context.Request.Body,
Method = context.Request.Method,
RequestUri = requestUri
};
var response = new ResponseAdapter
{
Body = context.Response.Body,
SetHeader = (key, value) => context.Response.Headers[key] = value,
SetStatus = status => context.Response.StatusCode = (int)status
};
var handled = await TusProtocolHandlerIntentBased.Invoke(new ContextAdapter
{
Request = request,
Response = response,
Configuration = config,
CancellationToken = context.RequestAborted,
HttpContext = context
});
if (handled == ResultType.ContinueExecution)
{
await _next(context);
}
}
public static ResponseAdapter RegraCarta(Carta carta)
{
var validator = new CartaValidator(carta);
var errorMsg = validator.Validate();
var response = new ResponseAdapter();
response.isSucess = errorMsg == null || errorMsg.Count == 0;
response.details = errorMsg;
response.returnBody = null;
return(response);
}
internal static async Task Error(this ResponseAdapter response, HttpStatusCode statusCode, string message, bool includeTusResumableHeader = true)
{
if (includeTusResumableHeader)
{
response.SetHeader(HeaderConstants.TusResumable, HeaderConstants.TusResumableValue);
}
response.SetStatus(statusCode);
if (message != null)
{
response.SetHeader(HeaderConstants.ContentType, "text/plain");
var buffer = _utf8Encoding.GetBytes(message);
await response.Body.WriteAsync(buffer, 0, buffer.Length);
}
}
/// <summary>
/// Handles the tus.io request.
/// </summary>
/// <param name="context">The HttpContext</param>
/// <returns></returns>
public async Task Invoke(HttpContext context)
{
var request = new RequestAdapter
{
Headers =
context.Request.Headers.ToDictionary(
f => f.Key,
f => f.Value.ToList(),
StringComparer.OrdinalIgnoreCase),
Body = context.Request.Body,
Method = context.Request.Method,
RequestUri = new Uri(
$"{context.Request.Scheme}://{context.Request.Host}{context.Request.Path}")
};
var response = new ResponseAdapter
{
Body = context.Response.Body,
SetHeader = (key, value) => context.Response.Headers[key] = value,
SetStatus = status => context.Response.StatusCode = status
};
var config = _configFactory(context);
var handled = await TusProtocolHandler.Invoke(
new ContextAdapter
{
Request = request,
Response = response,
CancellationToken = context.RequestAborted,
Configuration = config,
});
if (!handled)
{
await _next(context);
}
}
public async Task Handles_Abrupt_Disconnects_Gracefully(string pipeline)
{
// This test differs in structure from the others as this test needs to test that tusdotnet handles pipeline specifics correctly.
// We can only emulate the pipelines so this test might not be 100% accurate.
// Also we must bypass the TestServer and go directly for the TusProtcolHandler as we would otherwise introduce yet another pipeline.
var pipelineDetails = PipelineDisconnectEmulationDataAttribute.GetInfo(pipeline);
var cts = new CancellationTokenSource();
var store = Substitute.For <ITusStore>().WithExistingFile("testfile", uploadLength: 10, uploadOffset: 5);
var requestStream = Substitute.For <Stream>();
requestStream.ReadAsync(Arg.Any <byte[]>(), Arg.Any <int>(), Arg.Any <int>(), Arg.Any <CancellationToken>())
.ThrowsForAnyArgs(_ =>
{
if (pipelineDetails.FlagsCancellationTokenAsCancelled)
{
cts.Cancel();
}
throw pipelineDetails.ExceptionThatIsThrown;
});
store.AppendDataAsync("testfile", Arg.Any <Stream>(), Arg.Any <CancellationToken>())
.ReturnsForAnyArgs <Task <long> >(async callInfo => await callInfo.Arg <Stream>().ReadAsync(null, 0, 0, callInfo.Arg <CancellationToken>()));
var responseHeaders = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
var responseStatus = HttpStatusCode.OK;
var response = new ResponseAdapter
{
Body = new MemoryStream(),
SetHeader = (key, value) => responseHeaders[key] = value,
SetStatus = status => responseStatus = status
};
var context = new ContextAdapter
{
CancellationToken = cts.Token,
Configuration = new DefaultTusConfiguration
{
UrlPath = "/files",
Store = store
},
Request = new RequestAdapter("/files")
{
Headers = new Dictionary <string, List <string> >(StringComparer.OrdinalIgnoreCase)
{
{ "Content-Type", new List <string>(1)
{
"application/offset+octet-stream"
} },
{ "Tus-Resumable", new List <string>(1)
{
"1.0.0"
} },
{ "Upload-Offset", new List <string>(1)
{
"5"
} }
},
Method = "PATCH",
Body = requestStream,
RequestUri = new Uri("https://localhost:8080/files/testfile")
},
Response = response
};
var handled = await TusProtocolHandlerIntentBased.Invoke(context);
handled.ShouldBe(ResultType.StopExecution);
responseStatus.ShouldBe(HttpStatusCode.OK);
responseHeaders.Count.ShouldBe(0);
response.Body.Length.ShouldBe(0);
}
