public HttpCsvPushStreamResponse(string filename, Action<Action<string[]>> writeAction)
: base(HttpStatusCode.OK)
{
Content = new PushStreamContent((outputStream, content, context) => {
using (StreamWriter writer = new StreamWriter(outputStream, Encoding.UTF8)) {
writeAction((values) => CsvWriter.WriteRow(writer, values));
}
outputStream.Close();
});
Content.Headers.ContentType = new MediaTypeHeaderValue("text/csv");
Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = filename };
}
public HttpResponseMessage Get(String resolution)
{
Trace.TraceInformation("Get");
//var content = new PushStreamContent(PushImage);
var content = new PushStreamContent((stream, cont, ctx) =>
{
Trace.TraceInformation("pushing new frame");
long beginTime = Convert.ToInt64((DateTime.Now - epoch).TotalMilliseconds);
long endTime = 0;
while (true)
{
endTime = _Server.GetCurrentImageEndTime();
if(endTime == 0)
{
endTime = Convert.ToInt64((DateTime.Now - epoch).TotalMilliseconds) + 3 * 1000;
}
MemoryStream img = _Server.GetCurrentImage(Size.Empty);
do
{
// wait for 25fps
Thread.Sleep(40);
img.Seek(0, SeekOrigin.Begin);
img.WriteTo(stream);
img.Flush();
} while (Convert.ToInt64((DateTime.Now - epoch).TotalMilliseconds) < endTime);
}
//stream.Close();
});
content.Headers.ContentType = new MediaTypeWithQualityHeaderValue("image/jpeg");
_content.Add(content);
return new HttpResponseMessage()
{
Content = _content
};
}
public void Constructor_SetsDefaultMediaType()
{
MockStreamAction streamAction = new MockStreamAction();
PushStreamContent content = new PushStreamContent(streamAction.Action);
Assert.Equal(MediaTypeConstants.ApplicationOctetStreamMediaType, content.Headers.ContentType);
}
public HttpResponseMessage Fickle()
{
var options = new ServiceModelReflectionOptions
{
ControllersTypesToIgnore = new[] { this.GetType() }
};
var reflector = new WebApiRuntimeServiceModelReflector(options, this.Configuration, this.GetType().Assembly, Request.RequestUri.Host);
var serviceModel = reflector.Reflect();
var content = new PushStreamContent(
(stream, httpContent, transportContext) =>
{
using (var streamWriter = new StreamWriter(stream))
{
var writer = new FicklefileWriter(streamWriter);
writer.Write(serviceModel);
}
},
new MediaTypeHeaderValue("text/fickle"));
var response = new HttpResponseMessage
{
Content = content
};
return response;
}
public HttpResponseMessage Put(NewClassConfiguration classConfiguration)
{
var generator = new Generator();
var zipEntries = generator.Generate(classConfiguration).ToList();
var pushStreamContent = new PushStreamContent((stream, content, context) =>
{
using (var zipFile = new ZipFile())
{
foreach (var zipEntry in zipEntries)
{
var newStream = new MemoryStream(zipEntry.Stream.ToArray());
newStream.Seek(0, SeekOrigin.Begin);
zipFile.AddEntry(zipEntry.FileName, newStream);
}
zipFile.Save(stream);
stream.Close();
}
}, "application/zip");
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = pushStreamContent
};
//response.Headers.Add("content-disposition", $"attachment; filename={classConfiguration.Name}.zip");
return response;
}
public async Task PushStreamContentWithAsyncOnStreamAvailableHandler_ExceptionsInOnStreamAvailable_AreCaught()
{
// Arrange
bool faulted = false;
Exception exception = new ApplicationException();
PushStreamContent content = new PushStreamContent(async(s, c, tc) =>
{
await Task.FromResult(42);
throw exception;
});
MemoryStream stream = new MemoryStream();
try
{
// Act
await content.CopyToAsync(stream);
}
catch (ApplicationException e)
{
Assert.Same(exception, e);
faulted = true;
}
// Assert
Assert.True(faulted);
}
static async void RunClient()
{
// Create an HttpClient instance
HttpClient client = new HttpClient();
// Create a push content so that we can use XDocument.Save to a stream
XDocument xDoc = XDocument.Load("Sample.xml", LoadOptions.None);
PushStreamContent xDocContent = new PushStreamContent(
(stream, content, context) =>
{
// After save we close the stream to signal that we are done writing.
xDoc.Save(stream);
stream.Close();
},
"application/xml");
// Send POST request to server and wait asynchronously for the response
Uri address = new Uri(_baseAddress, "/api/book");
HttpResponseMessage response = await client.PostAsync(address, xDocContent);
// Ensure we get a successful response.
response.EnsureSuccessStatusCode();
// Read the response using XDocument as well
Stream responseStream = await response.Content.ReadAsStreamAsync();
XDocument xResponseDoc = XDocument.Load(responseStream);
Console.WriteLine("Received response: {0}", xResponseDoc.ToString());
}
public void Constructor_SetsDefaultMediaType()
{
Action <Stream, HttpContent, TransportContext> streamAction = new MockStreamAction().Action;
PushStreamContent content = new PushStreamContent(streamAction);
Assert.Equal(MediaTypeConstants.ApplicationOctetStreamMediaType, content.Headers.ContentType);
}
public Task SerializeToStreamAsync_CallsAction()
{
// Arrange
MemoryStream outputStream = new MemoryStream();
MockStreamAction streamAction = new MockStreamAction(close: true);
PushStreamContent content = new PushStreamContent((Action <Stream, HttpContent, TransportContext>)streamAction.Action);
// Act
return(content.CopyToAsync(outputStream).ContinueWith(
copyTask =>
{
// Assert
Assert.Equal(TaskStatus.RanToCompletion, copyTask.Status);
Assert.True(streamAction.WasInvoked);
Assert.Same(content, streamAction.Content);
Assert.IsType <PushStreamContent.CompleteTaskOnCloseStream>(streamAction.OutputStream);
#if NETFX_CORE
// In portable libraries, we expect the dispose to be called because we passed close: true above
// on netfx45, we let the HttpContent call close on the stream.
// CompleteTaskOnCloseStream for this reason does not dispose the innerStream when close is called
Assert.False(outputStream.CanRead);
#else
Assert.True(outputStream.CanRead);
#endif
}));
}
public void Constructor_SetsMediaType()
{
Action <Stream, HttpContent, TransportContext> streamAction = new MockStreamAction().Action;
PushStreamContent content = new PushStreamContent(streamAction, MediaTypeConstants.TextXmlMediaType);
Assert.Equal(MediaTypeConstants.TextXmlMediaType, content.Headers.ContentType);
}
static void Main()
{
var user = new User();
user.Id = 1;
user.Email = "*****@*****.**";
user.Image = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
user.CreatedAt = DateTime.Now;
user.Tags = new List<string>();
user.Tags.Add("soccer");
var serializer = new Serializer();
var content = new PushStreamContent((stream, httpContent, transportContext) =>
{
serializer.SerializeToStream(user, stream);
stream.Close();
});
var client = new HttpClient();
var response = client.PostAsync("http://localhost:19012/api/values/myItem?replace=false", content).ConfigureAwait(false).GetAwaiter().GetResult();
response.EnsureSuccessStatusCode();
var nextResponse = client.GetAsync("http://localhost:19012/api/values/myItem").ConfigureAwait(false).GetAwaiter().GetResult();
var responseStream = nextResponse.Content.ReadAsStreamAsync().ConfigureAwait(false).GetAwaiter().GetResult();
var otherUser = serializer.DeserializeFromStream<User>(responseStream);
}
static async Task RunClient()
{
// Create an HttpClient instance
HttpClient client = new HttpClient();
// Use chunked encoding as otherwise HttpClient would try buffering the content to
// figure out the content length.
client.DefaultRequestHeaders.TransferEncodingChunked = true;
// Create a push content so that we can use XDocument.Save to a stream
XDocument xDoc = XDocument.Load("Sample.xml", LoadOptions.None);
PushStreamContent xDocContent = new PushStreamContent(
(stream, content, context) =>
{
// After save we close the stream to signal that we are done writing.
using (stream)
{
xDoc.Save(stream);
}
},
"application/xml");
// Send POST request to server and wait asynchronously for the response
Uri address = new Uri(_baseAddress + "/api/book");
HttpResponseMessage response = await client.PostAsync(address, xDocContent);
// Ensure we get a successful response.
response.EnsureSuccessStatusCode();
// Read the response using XDocument as well
Stream responseStream = await response.Content.ReadAsStreamAsync();
XDocument xResponseDoc = XDocument.Load(responseStream);
Console.WriteLine("Received response: {0}", xResponseDoc.ToString());
}
public void Constructor_SetsMediaType()
{
MockStreamAction streamAction = new MockStreamAction();
PushStreamContent content = new PushStreamContent(streamAction.Action, MediaTypeConstants.TextXmlMediaType);
Assert.Equal(MediaTypeConstants.TextXmlMediaType, content.Headers.ContentType);
}
public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
{
var content = new PushStreamContent(async (strm, _, __) =>
{
using (strm)
{
await _blob.DownloadToStreamAsync(strm);
}
});
content.Headers.ContentType = MediaTypeHeaderValue.Parse(_blob.Properties.ContentType);
if (!String.IsNullOrEmpty(_blob.Properties.ContentEncoding))
{
content.Headers.ContentEncoding.Add(_blob.Properties.ContentEncoding);
}
if (!String.IsNullOrEmpty(_blob.Properties.ContentLanguage))
{
content.Headers.ContentLanguage.Add(_blob.Properties.ContentLanguage);
}
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = content
};
if (!String.IsNullOrEmpty(_blob.Properties.ETag))
{
response.Headers.ETag = EntityTagHeaderValue.Parse(_blob.Properties.ETag);
}
return Task.FromResult(response);
}
public Task SerializeToStreamAsync_CallsAction()
{
// Arrange
MemoryStream outputStream = new MemoryStream();
MockStreamAction streamAction = new MockStreamAction(close: true);
PushStreamContent content = new PushStreamContent((Action<Stream, HttpContent, TransportContext>)streamAction.Action);
// Act
return content.CopyToAsync(outputStream).ContinueWith(
copyTask =>
{
// Assert
Assert.Equal(TaskStatus.RanToCompletion, copyTask.Status);
Assert.True(streamAction.WasInvoked);
Assert.Same(content, streamAction.Content);
Assert.IsType<PushStreamContent.CompleteTaskOnCloseStream>(streamAction.OutputStream);
#if NETFX_CORE
// In portable libraries, we expect the dispose to be called because we passed close: true above
// on netfx45, we let the HttpContent call close on the stream.
// CompleteTaskOnCloseStream for this reason does not dispose the innerStream when close is called
Assert.False(outputStream.CanRead);
#else
Assert.True(outputStream.CanRead);
#endif
});
}
//GET CUAHSI/HydroClient/WaterOneFlowArchive/{id}
public async Task<HttpResponseMessage> Get(string fileName, string fileExtension)
{
HttpResponseMessage response = new HttpResponseMessage();
//Validate/initialize input parameters
if (String.IsNullOrWhiteSpace(fileName) || String.IsNullOrWhiteSpace(fileExtension))
{
response.StatusCode = HttpStatusCode.BadRequest; //Missing/invalid parameter(s) - return early
response.ReasonPhrase = "Invalid parameter(s)";
return response;
}
string fileNameAndExtension = String.Format("{0}.{1}", fileName, fileExtension).ToString();
MemoryStream ms = new MemoryStream();
bool bFound = await _ac.RetrieveBlobAsync(fileNameAndExtension, CancellationToken.None, ms);
if (!bFound)
{
response.StatusCode = HttpStatusCode.NotFound; //Blob not found - return early
response.ReasonPhrase = String.Format("Requested archive file: ({0}) not found.", fileNameAndExtension.ToString());
return response;
}
//Blob found - stream to client...
ms.Seek(0, SeekOrigin.Begin);
var pushStreamContent = new PushStreamContent((stream, content, context) =>
{
try
{
ms.CopyTo(stream);
stream.Close(); // After save we close the stream to signal that we are done writing.
ms.Close();
}
catch (Exception ex)
{
int n = 5;
++n;
}
}, "application/zip");
response.StatusCode = HttpStatusCode.OK;
response.Content = pushStreamContent;
response.Content.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment")
{
FileName = fileNameAndExtension.ToString()
};
return response;
}
public HttpResponseMessage Video(string name, string ext)
{
ext = ".pdb";
name = "System.Web.Http.SelfHost";
var currentDir= Environment.CurrentDirectory;
var filePath = System.IO.Path.Combine(currentDir,name);
var video = new VideoStream(name, ext);
var response = Request.CreateResponse();
onStreamAvailable = video.WriteToStream;
PushStreamContent videoContent = new PushStreamContent(onStreamAvailable, new MediaTypeHeaderValue("txt/json"));
response.Content = videoContent;
return response;
}
private static PushStreamContent CreateZip(string fileName, Action<ZipArchive> onZip)
{
var content = new PushStreamContent((outputStream, httpContent, transportContext) =>
{
using (var zip = new ZipArchive(new StreamWrapper(outputStream), ZipArchiveMode.Create, leaveOpen: false))
{
onZip(zip);
}
});
content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");
content.Headers.ContentDisposition.FileName = fileName;
return content;
}
public async Task SerializeToStreamAsync_CompletesTaskOnActionException()
{
// Arrange
MemoryStream outputStream = new MemoryStream();
MockStreamAction streamAction = new MockStreamAction(throwException: true);
PushStreamContent content = new PushStreamContent((Action <Stream, HttpContent, TransportContext>)streamAction.Action);
// Act & Assert
await Assert.ThrowsAsync <ApplicationException>(() => content.CopyToAsync(outputStream));
Assert.True(streamAction.WasInvoked);
Assert.IsType <PushStreamContent.CompleteTaskOnCloseStream>(streamAction.OutputStream);
Assert.True(outputStream.CanRead);
}
async System.Threading.Tasks.Task UploadJsonObject1Async <T>(System.Uri uri, T data)
{
using (System.Net.Http.HttpClient client = new System.Net.Http.HttpClient())
{
System.Net.Http.PushStreamContent content = new System.Net.Http.PushStreamContent((stream, httpContent, transportContext) =>
{
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
using (System.IO.TextWriter writer = new System.IO.StreamWriter(stream))
{
serializer.Serialize(writer, data);
}
});
System.Net.Http.HttpResponseMessage response = await client.PostAsync(uri, content);
response.EnsureSuccessStatusCode();
}
}
public async Task SerializeToStreamAsync_CallsAction()
{
// Arrange
MemoryStream outputStream = new MemoryStream();
MockStreamAction streamAction = new MockStreamAction(close: true);
PushStreamContent content = new PushStreamContent((Action <Stream, HttpContent, TransportContext>)streamAction.Action);
// Act
await content.CopyToAsync(outputStream);
// Assert
Assert.True(streamAction.WasInvoked);
Assert.Same(content, streamAction.Content);
Assert.IsType <PushStreamContent.CompleteTaskOnCloseStream>(streamAction.OutputStream);
// We don't close the underlying stream
Assert.True(outputStream.CanRead);
}
public Task SerializeToStreamAsync_CompletesTaskOnActionException()
{
// Arrange
MemoryStream outputStream = new MemoryStream();
MockStreamAction streamAction = new MockStreamAction(throwException: true);
PushStreamContent content = new PushStreamContent(streamAction.Action);
// Act
return(content.CopyToAsync(outputStream).ContinueWith(
copyTask =>
{
// Assert
Assert.Equal(TaskStatus.Faulted, copyTask.Status);
Assert.IsType <ApplicationException>(copyTask.Exception.GetBaseException());
Assert.True(streamAction.WasInvoked);
Assert.IsType <PushStreamContent.CompleteTaskOnCloseStream>(streamAction.OutputStream);
Assert.True(outputStream.CanRead);
}));
}
public Task SerializeToStreamAsync_CallsAction()
{
// Arrange
MemoryStream outputStream = new MemoryStream();
MockStreamAction streamAction = new MockStreamAction(close: true);
PushStreamContent content = new PushStreamContent(streamAction.Action);
// Act
return(content.CopyToAsync(outputStream).ContinueWith(
copyTask =>
{
// Assert
Assert.Equal(TaskStatus.RanToCompletion, copyTask.Status);
Assert.True(streamAction.WasInvoked);
Assert.Same(content, streamAction.Content);
Assert.IsType <PushStreamContent.CompleteTaskOnCloseStream>(streamAction.OutputStream);
Assert.True(outputStream.CanRead);
}));
}
public Task SerializeToStreamAsync_CompletesTaskOnActionException()
{
// Arrange
MemoryStream outputStream = new MemoryStream();
MockStreamAction streamAction = new MockStreamAction(throwException: true);
PushStreamContent content = new PushStreamContent(streamAction.Action);
// Act
return content.CopyToAsync(outputStream).ContinueWith(
copyTask =>
{
// Assert
Assert.Equal(TaskStatus.Faulted, copyTask.Status);
Assert.IsType<ApplicationException>(copyTask.Exception.GetBaseException());
Assert.True(streamAction.WasInvoked);
Assert.IsType<PushStreamContent.CompleteTaskOnCloseStream>(streamAction.OutputStream);
Assert.True(outputStream.CanRead);
});
}
public Task SerializeToStreamAsync_CallsAction()
{
// Arrange
MemoryStream outputStream = new MemoryStream();
MockStreamAction streamAction = new MockStreamAction(close: true);
PushStreamContent content = new PushStreamContent(streamAction.Action);
// Act
return content.CopyToAsync(outputStream).ContinueWith(
copyTask =>
{
// Assert
Assert.Equal(TaskStatus.RanToCompletion, copyTask.Status);
Assert.True(streamAction.WasInvoked);
Assert.Same(content, streamAction.Content);
Assert.IsType<PushStreamContent.CompleteTaskOnCloseStream>(streamAction.OutputStream);
Assert.True(outputStream.CanRead);
});
}
private PushStreamContent ToGeoJsonStream(List<Permit> permits, FieldChoices choice)
{
PushStreamContent geoJsonContent = new PushStreamContent(
(stream, content, context) =>
{
TextWriter writer = new StreamWriter(stream);
JsonWriter jsonWriter = new JsonTextWriter(writer);
jsonWriter.Formatting = Formatting.None;
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("type");
jsonWriter.WriteValue("FeatureCollection");
jsonWriter.WritePropertyName("features");
jsonWriter.WriteStartArray();
foreach (var permit in permits)
{
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("type");
jsonWriter.WriteValue("Feature");
jsonWriter.WritePropertyName("id");
jsonWriter.WriteValue(permit.PermitNum);
jsonWriter.WritePropertyName("geometry");
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("type");
jsonWriter.WriteValue("Point");
jsonWriter.WritePropertyName("coordinates");
jsonWriter.WriteStartArray();
jsonWriter.WriteValue(permit.Longitude);
jsonWriter.WriteValue(permit.Latitude);
jsonWriter.WriteEndArray();
jsonWriter.WriteEndObject();
if ((choice & FieldChoices.Recommended) > 0)
{
// TODO Serialize required fields
}
if ((choice & FieldChoices.Optional) > 0)
{
// TODO Serialize optional fields
}
if ((choice & FieldChoices.All) > 0)
{
// TODO Serialize all
}
jsonWriter.WriteEndObject();
}
jsonWriter.WriteEndArray();
jsonWriter.WriteEndObject();
jsonWriter.Flush();
jsonWriter.Close();
});
return geoJsonContent;
}
public static HttpContent AsHttpContent(this IWritable w, string mediaType)
{
var content = new PushStreamContent((s, c, tc) => Push(w, s));
content.Headers.ContentType = new MediaTypeHeaderValue(mediaType);
return content;
}
public HttpResponseMessage Pull(long id, string connection)
{
Database.Subscriptions.AssertOpenSubscriptionConnection(id, connection);
var pushStreamContent = new PushStreamContent((stream, content, transportContext) => StreamToClient(id, Database.Subscriptions, stream))
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
{
CharSet = "utf-8"
}
}
};
return new HttpResponseMessage(HttpStatusCode.OK)
{
Content = pushStreamContent
};
}
private async Task<Result<Stream>> CreatePlaylist_Request(string title, string description, IEnumerable<Song> songs)
{
string url = AppendXt("https://play.google.com/music/services/createplaylist?format=jsarray");
Stream response;
try
{
using (var streamContent = new PushStreamContent(async (stream, httpContent, transportContext) => await Task.Run(() => CreatePlaylist_BuildJson(title, description, songs, stream)), "application/x-www-form-urlencoded"))
{
response = await (await http.Client.PostAsync(url, streamContent)).Content.ReadAsStreamAsync();
}
}
catch (Exception e) { return new Result<Stream>(false, null, this, e); }
return new Result<Stream>(true, response, this);
}
public void Constructor_SetsMediaType()
{
Action<Stream, HttpContent, TransportContext> streamAction = new MockStreamAction().Action;
PushStreamContent content = new PushStreamContent(streamAction, MediaTypeConstants.TextXmlMediaType);
Assert.Equal(MediaTypeConstants.TextXmlMediaType, content.Headers.ContentType);
}
public void Constructor_SetsMediaType()
{
MockStreamAction streamAction = new MockStreamAction();
PushStreamContent content = new PushStreamContent(streamAction.Action, MediaTypeConstants.TextXmlMediaType);
Assert.Equal(MediaTypeConstants.TextXmlMediaType, content.Headers.ContentType);
}
public void Constructor_SetsDefaultMediaType()
{
MockStreamAction streamAction = new MockStreamAction();
PushStreamContent content = new PushStreamContent(streamAction.Action);
Assert.Equal(MediaTypeConstants.ApplicationOctetStreamMediaType, content.Headers.ContentType);
}
public FileResultFromStream(PushStreamContent stream, string contentType)
{
Stream = stream;
ContentType = contentType;
}
public void Constructor_SetsDefaultMediaType()
{
Action<Stream, HttpContent, TransportContext> streamAction = new MockStreamAction().Action;
PushStreamContent content = new PushStreamContent(streamAction);
Assert.Equal(MediaTypeConstants.ApplicationOctetStreamMediaType, content.Headers.ContentType);
}
public HttpResponseMessage GetAllFiles()
{
ZipFile zip = new ZipFile();
List<IFile> files = repository.GetAll();
for (int i = 0; i < files.Count; i++)
{
byte[] contents = files[i].Contents;
zip.AddEntry("file_" + (i + 1), contents);
}
PushStreamContent streamContent = new PushStreamContent((outputStream, httpContent, transportContext) =>
{
zip.Save(outputStream);
outputStream.Close();
}, "application/zip");
return CreateDownloadResponse(streamContent, "files.zip");
}
public async Task PushStreamContentWithAsyncOnStreamAvailableHandler_ExceptionsInOnStreamAvailable_AreCaught()
{
// Arrange
bool faulted = false;
Exception exception = new ApplicationException();
PushStreamContent content = new PushStreamContent(async (s, c, tc) =>
{
await Task.FromResult(42);
throw exception;
});
MemoryStream stream = new MemoryStream();
try
{
// Act
await content.CopyToAsync(stream);
}
catch (ApplicationException e)
{
Assert.Same(exception, e);
faulted = true;
}
// Assert
Assert.True(faulted);
}
public HttpResponseMessage TurnCameraOn()
{
try
{
var video = this.videos.All().FirstOrDefault();
var videoStream = new VideoStream(video.Data);
var response = Request.CreateResponse();
var header = new MediaTypeHeaderValue("video/avi");
var streamContent = new PushStreamContent((Action<Stream, HttpContent, TransportContext>)videoStream.WriteToStream, header);
response.Content = streamContent;
return response;
}
catch (Exception e)
{
return Request.CreateResponse(HttpStatusCode.BadRequest, e.Message);
}
}
public HttpResponseMessage Get(HttpRequestMessage request, string id)
{
if (string.IsNullOrWhiteSpace(id))
{
return Request.CreateResponse(HttpStatusCode.BadRequest);
}
Guid parsedID = Guid.Parse(id);
HttpResponseMessage response = request.CreateResponse();
response.Headers.Add("Access-Control-Allow-Origin", "*");
response.Headers.Add("Cache-Control", "no-cache, must-revalidate");
var pushContent = new PushStreamContent((Stream stream, HttpContent content, TransportContext context) =>
{
StreamWriter streamwriter = new StreamWriter(stream);
var client = new Client(streamwriter, id);
lock (_clients)
{
if (_clients.ContainsKey(client.id))
_RemoveClient(client.id);
bool isAdded = _clients.TryAdd(client.id, client);
if (isAdded)
++_clientCount;
}
_CheckCleanUpTimer();
}, "text/event-stream");
response.Content = pushContent;
return response;
}
private static void UsePushStreamContent()
{
XNamespace ns = "http://schemas.microsoft.com/2003/10/Serialization/";
var xml = new XElement(ns + "string", "Hello");
var content = new PushStreamContent((stream, cont, ctx) =>
{
using (var writer = XmlWriter.Create(stream,
new XmlWriterSettings { CloseOutput = true }))
// Write xml to the request stream
{ xml.WriteTo(writer); }
});
content.Headers.ContentType = new MediaTypeHeaderValue("application/xml");
var client = new HttpClient();
var response = client.PostAsync(_greetingsBaseUri, content).Result;
response.EnsureSuccessStatusCode();
}
public static PushStreamContent Create(string fileName, ITracer tracer, Action<ZipArchive> onZip)
{
var content = new PushStreamContent((outputStream, httpContent, transportContext) =>
{
using (tracer.Step("ZipStreamContent.OnZip"))
{
try
{
using (var zip = new ZipArchive(new StreamWrapper(outputStream), ZipArchiveMode.Create, leaveOpen: false))
{
onZip(zip);
}
}
catch (Exception ex)
{
tracer.TraceError(ex);
throw;
}
}
});
content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");
content.Headers.ContentDisposition.FileName = fileName;
return content;
}
