private static async Task RunTest(string baseAddress)
{
HttpClient client = new HttpClient();
HttpRequestMessage batchRequest = new HttpRequestMessage(
HttpMethod.Post,
baseAddress + "/api/batch"
);
MultipartContent batchContent = new MultipartContent("batch");
batchRequest.Content = batchContent;
CreateBatchedRequest(baseAddress, batchContent);
using (var stdout = Console.OpenStandardOutput())
{
Console.WriteLine("<<< REQUEST >>>");
Console.WriteLine();
Console.WriteLine(batchRequest);
Console.WriteLine();
await batchContent.CopyToAsync(stdout);
Console.WriteLine();
var batchResponse = await client.SendAsync(batchRequest);
Console.WriteLine("<<< RESPONSE >>>");
Console.WriteLine();
Console.WriteLine(batchResponse);
Console.WriteLine();
await batchResponse.Content.CopyToAsync(stdout);
Console.WriteLine();
Console.WriteLine();
}
}
public Task ExecuteResultAsync(ActionContext context)
{
var stringContent = new StringContent(statement.ToJson(format), Encoding.UTF8, MediaTypes.Application.Json);
if (statement.Attachments.Any(x => x.Payload != null))
{
var multipart = new MultipartContent("mixed")
{
stringContent
};
foreach (var attachment in statement.Attachments)
{
if (attachment.Payload != null)
{
var byteArrayContent = new ByteArrayContent(attachment.Payload);
byteArrayContent.Headers.ContentType = new MediaTypeHeaderValue(attachment.ContentType);
byteArrayContent.Headers.Add(ApiHeaders.ContentTransferEncoding, "binary");
byteArrayContent.Headers.Add(ApiHeaders.XExperienceApiHash, attachment.SHA2);
multipart.Add(byteArrayContent);
}
}
return(multipart.CopyToAsync(context.HttpContext.Response.Body));
}
return(stringContent.CopyToAsync(context.HttpContext.Response.Body));
}
public Task ExecuteResultAsync(ActionContext context)
{
var stringContent = new StringContent(result.ToJson(format), Encoding.UTF8, MediaTypes.Application.Json);
var attachmentsWithPayload = result.Statements.SelectMany(x => x.Attachments.Where(a => a.Payload != null));
if (attachmentsWithPayload.Count() > 0)
{
string boundary = Guid.NewGuid().ToString();
using var multipart = new MultipartContent("mixed", boundary)
{
stringContent
};
foreach (var attachment in attachmentsWithPayload)
{
var byteArrayContent = new ByteArrayContent(attachment.Payload);
var attachmentMediaType = MediaTypeHeaderValue.Parse(attachment.ContentType);
byteArrayContent.Headers.ContentType = attachmentMediaType;
byteArrayContent.Headers.Add(ApiHeaders.ContentTransferEncoding, "binary");
byteArrayContent.Headers.Add(ApiHeaders.XExperienceApiHash, attachment.SHA2);
multipart.Add(byteArrayContent);
}
// Write Content-Type header with Boundary parameter
var mediaType = MediaTypeHeaderValue.Parse(MediaTypes.Multipart.Mixed);
mediaType.Parameters.Add(new NameValueHeaderValue("boundary", boundary));
context.HttpContext.Response.ContentType = mediaType.ToString();
return(multipart.CopyToAsync(context.HttpContext.Response.Body));
}
return(stringContent.CopyToAsync(context.HttpContext.Response.Body));
}
public async Task MimeMultipartParserTestMultipartContent(string boundary)
{
MultipartContent content = new MultipartContent("mixed", boundary);
content.Add(new StringContent("A"));
content.Add(new StringContent("B"));
content.Add(new StringContent("C"));
MemoryStream memStream = new MemoryStream();
await content.CopyToAsync(memStream);
memStream.Position = 0;
byte[] data = memStream.ToArray();
for (var readSize = 1; readSize <= data.Length; readSize++)
{
MimeMultipartParser parser = CreateMimeMultipartParser(boundary);
int totalBytesConsumed;
List <string> bodyParts;
MimeMultipartParser.State state = ParseBufferInSteps(parser, data, readSize, out bodyParts, out totalBytesConsumed);
Assert.Equal(MimeMultipartParser.State.BodyPartCompleted, state);
Assert.Equal(data.Length, totalBytesConsumed);
Assert.Equal(4, bodyParts.Count);
Assert.Empty(bodyParts[0]);
Assert.EndsWith("A", bodyParts[1]);
Assert.EndsWith("B", bodyParts[2]);
Assert.EndsWith("C", bodyParts[3]);
}
}
public void MimeMultipartParserTestMultipartContent(string boundary)
{
MultipartContent content = new MultipartContent("mixed", boundary);
content.Add(new StringContent("A"));
content.Add(new StringContent("B"));
content.Add(new StringContent("C"));
MemoryStream memStream = new MemoryStream();
content.CopyToAsync(memStream).Wait();
memStream.Position = 0;
byte[] data = memStream.ToArray();
for (var cnt = 1; cnt <= data.Length; cnt++)
{
MimeMultipartParser parser = CreateMimeMultipartParser(data.Length, boundary);
Assert.NotNull(parser);
int totalBytesConsumed;
List <string> bodyParts;
MimeMultipartParser.State state = ParseBufferInSteps(parser, data, cnt, out bodyParts, out totalBytesConsumed);
Assert.Equal(MimeMultipartParser.State.BodyPartCompleted, state);
Assert.Equal(data.Length, totalBytesConsumed);
Assert.Equal(4, bodyParts.Count);
Assert.Empty(bodyParts[0]);
Assert.True(bodyParts[1].EndsWith("A"));
Assert.True(bodyParts[2].EndsWith("B"));
Assert.True(bodyParts[3].EndsWith("C"));
}
}
private static async Task <string> MultipartContentToStringAsync(MultipartContent content, MultipartContentToStringMode mode, bool async)
{
Stream stream;
switch (mode)
{
case MultipartContentToStringMode.ReadAsStreamAsync:
stream = await content.ReadAsStreamAsync(async);
break;
default:
stream = new MemoryStream();
if (async)
{
await content.CopyToAsync(stream);
}
else
{
content.CopyTo(stream, null, default);
}
stream.Position = 0;
break;
}
using (var reader = new StreamReader(stream))
{
return(await reader.ReadToEndAsync());
}
}
/// <summary>
/// Prepare an archived response based on a folder or fileStore in the response.
/// </summary>
/// <param name="targetStream">
/// The target Stream.
/// </param>
/// <param name="resourceResponse">
/// The resource response.
/// </param>
/// <param name="requestDataModelVersion">
/// The request data model version.
/// </param>
/// <param name="partition">
/// The database partition (schema) where the requested resource is stored.
/// </param>
/// <param name="routeSegments">
/// The route segments.
/// </param>
private void PrepareArchivedResponse(
Stream targetStream,
List <Thing> resourceResponse,
Version requestDataModelVersion,
string partition,
dynamic routeSegments)
{
string folderPath = this.FileArchiveService.CreateFileStructure(resourceResponse, partition, routeSegments);
try
{
var content = new MultipartContent("mixed", "----Boundary");
using (var stream = new MemoryStream())
{
this.CreateFilteredResponseStream(resourceResponse, stream, requestDataModelVersion);
// rewind stream prior to reading
stream.Position = 0;
// write out the json content to the first multipart content entry
var jsonContent = new StringContent(new StreamReader(stream).ReadToEnd());
jsonContent.Headers.Clear();
jsonContent.Headers.Add(this.ContentTypeHeader, this.MimeTypeJson);
content.Add(jsonContent);
stream.Flush();
}
this.FileArchiveService.CreateZipArchive(folderPath);
byte[] buffer;
long fileSize;
using (var fileStream = new FileStream(folderPath + ".zip", FileMode.Open))
{
fileSize = fileStream.Length;
buffer = new byte[(int)fileSize];
fileStream.Read(buffer, 0, (int)fileSize);
}
var binaryContent = new ByteArrayContent(buffer);
binaryContent.Headers.Add(this.ContentTypeHeader, this.MimeTypeOctetStream);
// use the file hash value to easily identify the multipart content for each respective filerevision hash entry
binaryContent.Headers.Add(
ContentDispositionHeader,
string.Format("attachment; filename={0}", folderPath + ".zip"));
binaryContent.Headers.Add(ContentLengthHeader, fileSize.ToString());
content.Add(binaryContent);
// stream the multipart content to the request contents target stream
content.CopyToAsync(targetStream);
}
finally
{
this.FileArchiveService.DeleteFileStructureWithArchive(folderPath);
}
}
static void Main(string[] args)
{
var client = new HttpClient();
var batchRequest = new HttpRequestMessage(
HttpMethod.Post,
"http://fsatnav:8080/api/batch"
);
var batchContent = new MultipartContent("mixed");
batchRequest.Content = batchContent;
batchContent.Add(
new HttpMessageContent(
new HttpRequestMessage(
HttpMethod.Get,
"http://localhost:8080/api/products"
)
)
);
batchContent.Add(
new HttpMessageContent(
new HttpRequestMessage(
HttpMethod.Put,
"http://localhost:8080/api/products"
)
{
Content = new StringContent("{\"Name\":\"Product X\",\"StockQuantity\":300}", Encoding.UTF8, "application/json")
}
)
);
using (Stream stdout = Console.OpenStandardOutput())
{
Console.WriteLine("<<< REQUEST >>>");
Console.WriteLine();
Console.WriteLine(batchRequest);
Console.WriteLine();
batchContent.CopyToAsync(stdout).Wait();
Console.WriteLine();
var batchResponse = client.SendAsync(batchRequest).Result;
Console.WriteLine("<<< RESPONSE >>>");
Console.WriteLine();
Console.WriteLine(batchResponse);
Console.WriteLine();
batchResponse.Content.CopyToAsync(stdout).Wait();
Console.WriteLine();
Console.WriteLine();
}
Console.ReadLine();
}
/// <summary>
/// Prepare a multi part response based on all included fileRevisions in the response.
/// </summary>
/// <param name="targetStream">
/// The target Stream.
/// </param>
/// <param name="fileRevisions">
/// The file Revisions.
/// </param>
/// <param name="resourceResponse">
/// The resource response.
/// </param>
/// <param name="requestDataModelVersion">
/// The request data model version.
/// </param>
private void PrepareMultiPartResponse(
Stream targetStream,
List <FileRevision> fileRevisions,
List <Thing> resourceResponse,
Version requestDataModelVersion)
{
if (!fileRevisions.Any())
{
// do nothing if no file revisions are present
return;
}
var content = new MultipartContent("mixed", BoundaryString);
using (var stream = new MemoryStream())
{
this.CreateFilteredResponseStream(resourceResponse, stream, requestDataModelVersion);
// rewind stream prior to reading
stream.Position = 0;
// write out the json content to the first multipart content entry
var jsonContent = new StringContent(new StreamReader(stream).ReadToEnd());
jsonContent.Headers.Clear();
jsonContent.Headers.Add(this.ContentTypeHeader, this.MimeTypeJson);
content.Add(jsonContent);
stream.Flush();
}
foreach (var hash in fileRevisions.Select(x => x.ContentHash).Distinct())
{
byte[] buffer;
long fileSize;
using (var fileStream = this.FileBinaryService.RetrieveBinaryData(hash))
{
fileSize = fileStream.Length;
buffer = new byte[(int)fileSize];
fileStream.Read(buffer, 0, (int)fileSize);
}
// write out the binary content to the first multipart content entry
var binaryContent = new ByteArrayContent(buffer);
binaryContent.Headers.Add(this.ContentTypeHeader, this.MimeTypeOctetStream);
// use the file hash value to easily identify the multipart content for each respective filerevision hash entry
binaryContent.Headers.Add(ContentDispositionHeader, $"attachment; filename={hash}");
binaryContent.Headers.Add(ContentLengthHeader, fileSize.ToString());
content.Add(binaryContent);
}
// stream the multipart content to the request contents target stream
content.CopyToAsync(targetStream).Wait();
this.AddMultiPartMimeEndpoint(targetStream);
}
static void Main(string[] args)
{
var client = new HttpClient();
var batchRequest = new HttpRequestMessage(
HttpMethod.Post,
"http://fsatnav:8080/api/batch"
);
var batchContent = new MultipartContent("mixed");
batchRequest.Content = batchContent;
batchContent.Add(
new HttpMessageContent(
new HttpRequestMessage(
HttpMethod.Get,
"http://localhost:8080/api/products"
)
)
);
batchContent.Add(
new HttpMessageContent(
new HttpRequestMessage(
HttpMethod.Put,
"http://localhost:8080/api/products"
)
{
Content = new StringContent("{\"Name\":\"Product X\",\"StockQuantity\":300}", Encoding.UTF8, "application/json")
}
)
);
using (Stream stdout = Console.OpenStandardOutput())
{
Console.WriteLine("<<< REQUEST >>>");
Console.WriteLine();
Console.WriteLine(batchRequest);
Console.WriteLine();
batchContent.CopyToAsync(stdout).Wait();
Console.WriteLine();
var batchResponse = client.SendAsync(batchRequest).Result;
Console.WriteLine("<<< RESPONSE >>>");
Console.WriteLine();
Console.WriteLine(batchResponse);
Console.WriteLine();
batchResponse.Content.CopyToAsync(stdout).Wait();
Console.WriteLine();
Console.WriteLine();
}
Console.ReadLine();
}
static void Main(string[] args)
{
var client = new HttpClient();
var batchRequest = new HttpRequestMessage(
HttpMethod.Post,
"http://localhost:52857/api/$batch"
);
var batchContent = new MultipartContent("mixed");
batchRequest.Content = batchContent;
batchContent.Add(
new HttpMessageContent(
new HttpRequestMessage(
HttpMethod.Get,
"http://localhost:52857/api/TestClassOne"
)
)
);
batchContent.Add(
new HttpMessageContent(
new HttpRequestMessage(
HttpMethod.Get,
"http://localhost:52857/api/TestClassTwo"
)
)
);
using (Stream stdout = Console.OpenStandardOutput())
{
Console.WriteLine("<<< REQUEST >>>");
Console.WriteLine();
Console.WriteLine(batchRequest);
Console.WriteLine();
batchContent.CopyToAsync(stdout).Wait();
Console.WriteLine();
var batchResponse = client.SendAsync(batchRequest).Result;
Console.WriteLine("<<< RESPONSE >>>");
Console.WriteLine();
Console.WriteLine(batchResponse);
Console.WriteLine();
batchResponse.Content.CopyToAsync(stdout).Wait();
Console.WriteLine();
Console.WriteLine();
}
Console.ReadLine();
}
public async Task MultipartContent_TryComputeLength_ReturnsSameLengthAsCopyToAsync(MultipartContent multipartContent)
{
Assert.True(multipartContent.TryComputeLength(out long length));
var copyToStream = new MemoryStream();
multipartContent.CopyTo(copyToStream, context: null, cancellationToken: default);
Assert.Equal(length, copyToStream.Length);
var copyToAsyncStream = new MemoryStream();
await multipartContent.CopyToAsync(copyToAsyncStream, context : null, cancellationToken : default);
Assert.Equal(length, copyToAsyncStream.Length);
Assert.Equal(copyToStream.ToArray(), copyToAsyncStream.ToArray());
}
public async Task ReadAsStreamAsync_Seek_JumpsToSpecifiedPosition(bool nestedContent, bool readStreamAsync)
{
var mc = new MultipartContent();
if (nestedContent)
{
mc.Add(new ByteArrayContent(Encoding.UTF8.GetBytes("This is a ByteArrayContent")));
mc.Add(new StringContent("This is a StringContent"));
mc.Add(new ByteArrayContent(Encoding.UTF8.GetBytes("Another ByteArrayContent :-)")));
}
var memStream = new MemoryStream();
await mc.CopyToAsync(memStream);
byte[] buf1 = new byte[1], buf2 = new byte[1];
using (Stream s = await mc.ReadAsStreamAsync(readStreamAsync))
{
var targets = new[]
{
new { Origin = SeekOrigin.Begin, Offset = memStream.Length / 2 },
new { Origin = SeekOrigin.Begin, Offset = memStream.Length - 1 },
new { Origin = SeekOrigin.Begin, Offset = memStream.Length },
new { Origin = SeekOrigin.Begin, Offset = memStream.Length + 1 },
new { Origin = SeekOrigin.Begin, Offset = 0L },
new { Origin = SeekOrigin.Begin, Offset = 1L },
new { Origin = SeekOrigin.Current, Offset = 1L },
new { Origin = SeekOrigin.Current, Offset = 2L },
new { Origin = SeekOrigin.Current, Offset = -2L },
new { Origin = SeekOrigin.Current, Offset = 0L },
new { Origin = SeekOrigin.Current, Offset = 1000L },
new { Origin = SeekOrigin.End, Offset = 0L },
new { Origin = SeekOrigin.End, Offset = memStream.Length },
new { Origin = SeekOrigin.End, Offset = memStream.Length / 2 },
};
foreach (var target in targets)
{
memStream.Seek(target.Offset, target.Origin);
s.Seek(target.Offset, target.Origin);
Assert.Equal(memStream.Position, s.Position);
Assert.Equal(memStream.Read(buf1, 0, 1), s.Read(buf2, 0, 1));
Assert.Equal(buf1[0], buf2[0]);
}
}
}
public async override Task ExecuteResultAsync(ActionContext context)
{
EnsureArg.IsNotNull(context, nameof(context));
var content = new MultipartContent(MultipartContentSubType);
foreach (MultipartItem item in _multipartItems)
{
content.Add(item.Content);
context.HttpContext.Response.RegisterForDispose(item);
}
context.HttpContext.Response.ContentLength = content.Headers.ContentLength;
context.HttpContext.Response.ContentType = content.Headers.ContentType.ToString();
context.HttpContext.Response.StatusCode = _statusCode;
await content.CopyToAsync(context.HttpContext.Response.Body);
}
public async Task CompareExample()
{
var mw = new MultipartContent("mixed", "batch_357647d1-a6b5-4e6a-aa73-edfc88d8866e")
{
new HttpApplicationContent(new HttpRequestMessage(HttpMethod.Get,
"http://localhost:12345/api/WebCustomers?Query=Parts")),
new HttpApplicationContent(
new HttpRequestMessage(HttpMethod.Post, "http://localhost:12345/api/WebCustomers")
{
Content = new StringContent(
"{\"Id\":129,\"Name\":\"Name4752cbf0-e365-43c3-aa8d-1bbc8429dbf8\"}", Encoding.UTF8,
"application/json")
}),
new HttpApplicationContent(
new HttpRequestMessage(HttpMethod.Put, "http://localhost:12345/api/WebCustomers/1")
{
Content = new StringContent("{\"Id\":1,\"Name\":\"Peter\"}", Encoding.UTF8, "application/json")
}),
new HttpApplicationContent(new HttpRequestMessage(HttpMethod.Delete,
"http://localhost:12345/api/WebCustomers/2"))
};
string output;
using (var memoryStream = new MemoryStream())
{
await mw.CopyToAsync(memoryStream).ConfigureAwait(false);
memoryStream.Position = 0;
output = Encoding.ASCII.GetString(memoryStream.ToArray());
}
string input;
using (var refTextStream = TestUtilities.GetNormalizedContentStream("MultipartRequest.txt"))
{
Assert.NotNull(refTextStream);
input = await refTextStream.ReadAsStringAsync().ConfigureAwait(false);
}
Assert.Equal(input, output);
}
private static async Task RunTest(string baseAddress)
{
HttpClient client = new HttpClient();
HttpRequestMessage batchRequest = new HttpRequestMessage(
HttpMethod.Post,
baseAddress + "/api/batch"
);
MultipartContent batchContent = new MultipartContent("batch");
batchRequest.Content = batchContent;
CreateBatchedRequest(baseAddress, batchContent);
using (var stdout = Console.OpenStandardOutput())
{
Console.WriteLine("<<< REQUEST >>>");
Console.WriteLine();
Console.WriteLine(batchRequest);
Console.WriteLine();
await batchContent.CopyToAsync(stdout);
Console.WriteLine();
var batchResponse = await client.SendAsync(batchRequest);
Console.WriteLine("<<< RESPONSE >>>");
Console.WriteLine();
Console.WriteLine(batchResponse);
Console.WriteLine();
await batchResponse.Content.CopyToAsync(stdout);
Console.WriteLine();
Console.WriteLine();
}
}
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
{
var boundry = Guid.NewGuid().ToString();
var multipartFormDataContent = new MultipartContent("mixed", boundry);
//content. .StatusCode = (int)System.Net.HttpStatusCode.OK;
var contentType = new MediaTypeHeaderValue("multipart/mixed"); // String.Format("multipart/mixed; boundary={0}", boundry));
var boundaryParameter = new NameValueHeaderValue("boundary", boundry);
contentType.Parameters.Add(boundaryParameter);
contentType.Parameters.Add(new System.Net.Http.Headers.NameValueHeaderValue("revision", "0.1"));
content.Headers.ContentType = contentType;
//content.Headers.Add("Accept", "multipart/mixed");
//content.Headers.Add("MIME-Version", "1.0");
var entities = (IEnumerable<object>)value;
foreach (var entity in entities)
{
var entityContent = new ObjectContent<object>(entity, new JsonMediaTypeFormatter());
entityContent.Headers.LastModified = DateTime.UtcNow; // Add("Last-Modified", entity.LastModified.ToUniversalTime().ToString("R"));
entityContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/x-" + entity.GetType().Name);
multipartFormDataContent.Add(entityContent);
}
return multipartFormDataContent.CopyToAsync(writeStream);
}
public async Task ExecuteResultAsync(ActionContext context)
{
await _content.CopyToAsync(context.HttpContext.Response.Body);
}
public void ReadAsMultipartAsync_NestedMultipartContent(string boundary)
{
const int nesting = 10;
const string innerText = "Content";
MultipartContent innerContent = new MultipartContent("mixed", boundary);
innerContent.Add(new StringContent(innerText));
for (var cnt = 0; cnt < nesting; cnt++)
{
string outerBoundary = String.Format("{0}_{1}", boundary, cnt);
MultipartContent outerContent = new MultipartContent("mixed", outerBoundary);
outerContent.Add(innerContent);
innerContent = outerContent;
}
MemoryStream memStream = new MemoryStream();
innerContent.CopyToAsync(memStream).Wait();
memStream.Position = 0;
byte[] data = memStream.ToArray();
HttpContent content = new ByteArrayContent(data);
content.Headers.ContentType = innerContent.Headers.ContentType;
for (var cnt = 0; cnt < nesting + 1; cnt++)
{
MultipartMemoryStreamProvider result = content.ReadAsMultipartAsync().Result;
Assert.Equal(1, result.Contents.Count);
content = result.Contents[0];
Assert.NotNull(content);
}
string text = content.ReadAsStringAsync().Result;
Assert.Equal(innerText, text);
}
public void ReadAsMultipartAsync_UsingMultipartContent(string boundary)
{
MultipartContent content = new MultipartContent("mixed", boundary);
content.Add(new StringContent("A"));
content.Add(new StringContent("B"));
content.Add(new StringContent("C"));
MemoryStream memStream = new MemoryStream();
content.CopyToAsync(memStream).Wait();
memStream.Position = 0;
byte[] data = memStream.ToArray();
var byteContent = new ByteArrayContent(data);
byteContent.Headers.ContentType = content.Headers.ContentType;
MultipartMemoryStreamProvider result = byteContent.ReadAsMultipartAsync().Result;
Assert.Equal(3, result.Contents.Count);
Assert.Equal("A", result.Contents[0].ReadAsStringAsync().Result);
Assert.Equal("B", result.Contents[1].ReadAsStringAsync().Result);
Assert.Equal("C", result.Contents[2].ReadAsStringAsync().Result);
}
public void MimeMultipartParserTestMultipartContent(string boundary)
{
MultipartContent content = new MultipartContent("mixed", boundary);
content.Add(new StringContent("A"));
content.Add(new StringContent("B"));
content.Add(new StringContent("C"));
MemoryStream memStream = new MemoryStream();
content.CopyToAsync(memStream).Wait();
memStream.Position = 0;
byte[] data = memStream.ToArray();
for (var readSize = 1; readSize <= data.Length; readSize++)
{
MimeMultipartParser parser = CreateMimeMultipartParser(boundary);
int totalBytesConsumed;
List<string> bodyParts;
MimeMultipartParser.State state = ParseBufferInSteps(parser, data, readSize, out bodyParts, out totalBytesConsumed);
Assert.Equal(MimeMultipartParser.State.BodyPartCompleted, state);
Assert.Equal(data.Length, totalBytesConsumed);
Assert.Equal(4, bodyParts.Count);
Assert.Empty(bodyParts[0]);
Assert.True(bodyParts[1].EndsWith("A"));
Assert.True(bodyParts[2].EndsWith("B"));
Assert.True(bodyParts[3].EndsWith("C"));
}
}
public void ReadAsMultipartAsyncNestedMultipartContentAsync(string boundary)
{
const int nesting = 10;
const string innerText = "Content";
MultipartContent innerContent = new MultipartContent("mixed", boundary);
innerContent.Add(new StringContent(innerText));
for (var cnt = 0; cnt < nesting; cnt++)
{
string outerBoundary = String.Format("{0}_{1}", boundary, cnt);
MultipartContent outerContent = new MultipartContent("mixed", outerBoundary);
outerContent.Add(innerContent);
innerContent = outerContent;
}
MemoryStream memStream = new MemoryStream();
innerContent.CopyToAsync(memStream).Wait();
memStream.Position = 0;
byte[] data = memStream.ToArray();
HttpContent content = new ByteArrayContent(data);
content.Headers.ContentType = innerContent.Headers.ContentType;
for (var cnt = 0; cnt < nesting + 1; cnt++)
{
Task<IEnumerable<HttpContent>> task = content.ReadAsMultipartAsync();
task.Wait(TimeoutConstant.DefaultTimeout);
IEnumerable<HttpContent> result = task.Result;
Assert.Equal(1, result.Count());
content = result.ElementAt(0);
Assert.NotNull(content);
}
string text = content.ReadAsStringAsync().Result;
Assert.Equal(innerText, text);
}
private static async Task<string> MultipartContentToStringAsync(MultipartContent content, MultipartContentToStringMode mode)
{
Stream stream;
switch (mode)
{
case MultipartContentToStringMode.ReadAsStreamAsync:
stream = await content.ReadAsStreamAsync();
break;
default:
stream = new MemoryStream();
await content.CopyToAsync(stream);
stream.Position = 0;
break;
}
using (var reader = new StreamReader(stream))
{
return await reader.ReadToEndAsync();
}
}
public async Task ReadAsStreamAsync_Seek_JumpsToSpecifiedPosition(bool nestedContent)
{
var mc = new MultipartContent();
if (nestedContent)
{
mc.Add(new ByteArrayContent(Encoding.UTF8.GetBytes("This is a ByteArrayContent")));
mc.Add(new StringContent("This is a StringContent"));
mc.Add(new ByteArrayContent(Encoding.UTF8.GetBytes("Another ByteArrayContent :-)")));
}
var memStream = new MemoryStream();
await mc.CopyToAsync(memStream);
byte[] buf1 = new byte[1], buf2 = new byte[1];
using (Stream s = await mc.ReadAsStreamAsync())
{
var targets = new[]
{
new { Origin = SeekOrigin.Begin, Offset = memStream.Length / 2 },
new { Origin = SeekOrigin.Begin, Offset = memStream.Length - 1 },
new { Origin = SeekOrigin.Begin, Offset = memStream.Length },
new { Origin = SeekOrigin.Begin, Offset = memStream.Length + 1 },
new { Origin = SeekOrigin.Begin, Offset = 0L },
new { Origin = SeekOrigin.Begin, Offset = 1L },
new { Origin = SeekOrigin.Current, Offset = 1L },
new { Origin = SeekOrigin.Current, Offset = 2L },
new { Origin = SeekOrigin.Current, Offset = -2L },
new { Origin = SeekOrigin.Current, Offset = 0L },
new { Origin = SeekOrigin.Current, Offset = 1000L },
new { Origin = SeekOrigin.End, Offset = 0L },
new { Origin = SeekOrigin.End, Offset = memStream.Length },
new { Origin = SeekOrigin.End, Offset = memStream.Length / 2 },
};
foreach (var target in targets)
{
memStream.Seek(target.Offset, target.Origin);
s.Seek(target.Offset, target.Origin);
Assert.Equal(memStream.Position, s.Position);
Assert.Equal(memStream.Read(buf1, 0, 1), s.Read(buf2, 0, 1));
Assert.Equal(buf1[0], buf2[0]);
}
}
}
public void ReadAsMultipartAsyncUsingMultipartContentAsync(string boundary)
{
MultipartContent content = new MultipartContent("mixed", boundary);
content.Add(new StringContent("A"));
content.Add(new StringContent("B"));
content.Add(new StringContent("C"));
MemoryStream memStream = new MemoryStream();
content.CopyToAsync(memStream).Wait();
memStream.Position = 0;
byte[] data = memStream.ToArray();
var byteContent = new ByteArrayContent(data);
byteContent.Headers.ContentType = content.Headers.ContentType;
Task<IEnumerable<HttpContent>> task = byteContent.ReadAsMultipartAsync();
task.Wait(TimeoutConstant.DefaultTimeout);
IEnumerable<HttpContent> result = task.Result;
Assert.Equal(3, result.Count());
Assert.Equal("A", result.ElementAt(0).ReadAsStringAsync().Result);
Assert.Equal("B", result.ElementAt(1).ReadAsStringAsync().Result);
Assert.Equal("C", result.ElementAt(2).ReadAsStringAsync().Result);
}
public override async Task ExecuteResultAsync(IWebDavResponse response, CancellationToken ct)
{
await base.ExecuteResultAsync(response, ct);
response.Headers["Accept-Ranges"] = new[] { "bytes" };
var properties = await _document.GetProperties(response.Dispatcher).ToList(ct);
var etagProperty = properties.OfType <GetETagProperty>().FirstOrDefault();
if (etagProperty != null)
{
var propValue = await etagProperty.GetValueAsync(ct);
response.Headers["ETag"] = new[] { propValue.ToString() };
}
if (!_returnFile)
{
var lastModifiedProp = properties.OfType <LastModifiedProperty>().FirstOrDefault();
if (lastModifiedProp != null)
{
var propValue = await lastModifiedProp.GetValueAsync(ct);
response.Headers["Last-Modified"] = new[] { propValue.ToString("R") };
}
return;
}
var views = new List <StreamView>();
try
{
foreach (var rangeItem in _rangeItems)
{
var baseStream = await _document.OpenReadAsync(ct);
var streamView = await StreamView
.CreateAsync(baseStream, rangeItem.From, rangeItem.Length, ct)
;
views.Add(streamView);
}
string contentType;
var contentTypeProp = properties.OfType <GetContentTypeProperty>().FirstOrDefault();
if (contentTypeProp != null)
{
contentType = await contentTypeProp.GetValueAsync(ct);
}
else
{
contentType = MimeTypesMap.DefaultMimeType;
}
if (_rangeItems.Count == 1)
{
// No multipart content
var rangeItem = _rangeItems.Single();
var streamView = views.Single();
using (var streamContent = new StreamContent(streamView))
{
streamContent.Headers.ContentRange = new ContentRangeHeaderValue(
rangeItem.From,
rangeItem.To,
_document.Length);
streamContent.Headers.ContentLength = rangeItem.Length;
streamContent.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType);
await SetPropertiesToContentHeaderAsync(streamContent, properties, ct)
;
foreach (var header in streamContent.Headers)
{
response.Headers.Add(header.Key, header.Value.ToArray());
}
// Use the CopyToAsync function of the stream itself, because
// we're able to pass the cancellation token. This is a workaround
// for issue dotnet/corefx#9071 and fixes FubarDevelopment/WebDavServer#47.
await streamView.CopyToAsync(response.Body, 81920, ct)
;
}
}
else
{
// Multipart content
using (var multipart = new MultipartContent("byteranges"))
{
var index = 0;
foreach (var rangeItem in _rangeItems)
{
var streamView = views[index++];
var partContent = new StreamContent(streamView);
partContent.Headers.ContentRange = new ContentRangeHeaderValue(
rangeItem.From,
rangeItem.To,
_document.Length);
partContent.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType);
partContent.Headers.ContentLength = rangeItem.Length;
multipart.Add(partContent);
}
await SetPropertiesToContentHeaderAsync(multipart, properties, ct)
;
foreach (var header in multipart.Headers)
{
response.Headers.Add(header.Key, header.Value.ToArray());
}
// TODO: Workaround for issue dotnet/corefx#9071
await multipart.CopyToAsync(response.Body);
}
}
}
finally
{
foreach (var streamView in views)
{
streamView.Dispose();
}
}
}
