//--- Methods ---
public ResourceContentBE CreateDbSerializedContentFromStream(Stream stream, long length, MimeType type)
{
var memorystream = new ChunkedMemoryStream();
stream.CopyTo(memorystream, length);
return(new ResourceContentBE(memorystream, type));
}
public Stream GetRequestStream(IMessage msg, int contentLength, ITransportHeaders headers)
{
IMethodCallMessage message = (IMethodCallMessage) msg;
string uri = message.Uri;
this._bOneWayRequest = RemotingServices.IsOneWay(message.MethodBase);
ChunkedMemoryStream outputStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
base.WritePreambleAndVersion(outputStream);
if (!this._bOneWayRequest)
{
base.WriteUInt16(0, outputStream);
}
else
{
base.WriteUInt16(1, outputStream);
}
base.WriteUInt16(0, outputStream);
base.WriteInt32(contentLength, outputStream);
base.WriteUInt16(4, outputStream);
base.WriteByte(1, outputStream);
base.WriteCountedString(uri, outputStream);
base.WriteHeaders(headers, outputStream);
outputStream.WriteTo(base.NetStream);
outputStream.Close();
this._requestStream = base.NetStream;
return this._requestStream;
}
private static void ProcessGetResponseCompletion(IAsyncResult iar)
{
HttpClientTransportSink.AsyncHttpClientRequestState asyncState = (HttpClientTransportSink.AsyncHttpClientRequestState)iar.AsyncState;
try
{
asyncState.RequestStream.Close();
HttpWebResponse response = null;
HttpWebRequest webRequest = asyncState.WebRequest;
try
{
response = (HttpWebResponse)webRequest.EndGetResponse(iar);
}
catch (WebException exception)
{
HttpClientTransportSink.ProcessResponseException(exception, out response);
}
asyncState.WebResponse = response;
ChunkedMemoryStream target = new ChunkedMemoryStream(CoreChannel.BufferPool);
asyncState.ActualResponseStream = target;
StreamHelper.BeginAsyncCopyStream(response.GetResponseStream(), target, true, false, true, false, s_processAsyncCopyRequestStreamCompletion, asyncState);
}
catch (Exception exception2)
{
asyncState.SinkStack.DispatchException(exception2);
}
}
public static void Serialize(XElement value, TextWriter sw, bool minimal)
{
if (StringFormat || minimal)
{
using (var cms = ChunkedMemoryStream.Create())
{
var writer = cms.GetWriter();
value.Save(writer, SaveOptions.DisableFormatting);
writer.Flush();
cms.Position = 0;
var reader = cms.GetReader();
var buf = cms.CharBuffer;
int len;
sw.Write('"');
while ((len = reader.Read(buf, 0, 4096)) > 0)
{
StringConverter.SerializePart(buf, len, sw);
}
sw.Write('"');
}
}
else
{
JsonNet.Serialize(sw, value, typeof(XElement));
}
}
public void ChunkedMemoryStream_Read_CanReadAllTheDataOutCorrectly()
{
var buffers = new[]
{
new byte[10] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
},
new byte[20] {
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
}
};
var chunkedMemoryStream = new ChunkedMemoryStream(buffers, 0, 30);
var outBuffer = new byte[30];
// Read all the data
var bytesRead = chunkedMemoryStream.Read(outBuffer, 0, 30);
Assert.AreEqual(30, bytesRead);
for (int i = 0; i < buffers.Length; i++)
{
Assert.AreEqual(i, outBuffer[i]);
}
}
static void Main(string[] args)
{
ChunkedMemoryStream cms = new ChunkedMemoryStream();
Debug.Assert(cms.Length == 0);
Debug.Assert(cms.Position == 0);
cms.Position = 0;
byte[] helloworld = Encoding.UTF8.GetBytes("hello world");
cms.Write(helloworld, 0, 3);
cms.Write(helloworld, 3, 3);
cms.Write(helloworld, 6, 5);
Debug.Assert(cms.Length == 11);
Debug.Assert(cms.Position == 11);
cms.Position = 0;
byte[] b = new byte[20];
cms.Read(b, 3, (int)cms.Length);
Debug.Assert(b.Skip(3).Take(11).SequenceEqual(helloworld));
cms.Position = 0;
cms.Write(Encoding.UTF8.GetBytes("seeya"), 0, 5);
Debug.Assert(cms.Length == 11);
Debug.Assert(cms.Position == 5);
cms.Position = 0;
cms.Read(b, 0, (byte)cms.Length);
Debug.Assert(b.Take(11).SequenceEqual(Encoding.UTF8.GetBytes("seeya world")));
Debug.Assert(cms.Length == 11);
Debug.Assert(cms.Position == 11);
cms.Write(Encoding.UTF8.GetBytes(" again"), 0, 6);
Debug.Assert(cms.Length == 17);
Debug.Assert(cms.Position == 17);
cms.Position = 0;
cms.Read(b, 0, (byte)cms.Length);
Debug.Assert(b.Take(17).SequenceEqual(Encoding.UTF8.GetBytes("seeya world again")));
}
public Stream GetRequestStream(IMessage msg, int contentLength, ITransportHeaders headers)
{
IMethodCallMessage message = (IMethodCallMessage)msg;
string uri = message.Uri;
this._bOneWayRequest = RemotingServices.IsOneWay(message.MethodBase);
ChunkedMemoryStream outputStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
base.WritePreambleAndVersion(outputStream);
if (!this._bOneWayRequest)
{
base.WriteUInt16(0, outputStream);
}
else
{
base.WriteUInt16(1, outputStream);
}
base.WriteUInt16(0, outputStream);
base.WriteInt32(contentLength, outputStream);
base.WriteUInt16(4, outputStream);
base.WriteByte(1, outputStream);
base.WriteCountedString(uri, outputStream);
base.WriteHeaders(headers, outputStream);
outputStream.WriteTo(base.NetStream);
outputStream.Close();
this._requestStream = base.NetStream;
return(this._requestStream);
}
protected internal ImapAppendMessageBodyStream(int readTimeout, int writeTimeout)
{
this.ReadTimeout = readTimeout;
this.WriteTimeout = writeTimeout;
buffer = new ChunkedMemoryStream();
}
public void Write_199k_bytes()
{
byte[] bytes = GetBytes(199 * 1024);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
}
private void MakeStream()
{
if (IsClosed)
{
throw new InvalidOperationException("message has already been closed");
}
if (_stream == null)
{
if (_bytes != null)
{
_stream = new MemoryStream(_bytes, 0, _bytes.Length, true, true);
}
else
{
var stream = new ChunkedMemoryStream();
_doc.WriteTo(stream, ContentType.CharSet);
stream.Position = 0;
_stream = stream;
}
_streamOpen = false;
// NOTE: the content-length and body length may differ (e.g. HEAD verb)
// update content-length if it isn't set yet
if (Headers.ContentLength == null)
{
Headers.ContentLength = _stream.Length;
}
}
}
public void Write_100_bytes()
{
byte[] bytes = GetBytes(100);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
Assert.AreEqual(100, stream.Length);
}
internal void SendResponse(ITransportHeaders headers, Stream contentStream)
{
// bail out if the original request was OneWay (means the client doesn't even
// want or expect to receive responses or error messages)
if (_bOneWayRequest)
{
return;
}
// build up headers and send
ChunkedMemoryStream headerStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
// output preamble and version
WritePreambleAndVersion(headerStream);
// output opcode
WriteUInt16(TcpOperations.Reply, headerStream);
// output content length delimiter
WriteUInt16(TcpContentDelimiter.ContentLength, headerStream);
WriteInt32((int)contentStream.Length, headerStream);
// No status code header is needed because if we're in this code path
// the data transfer succeeded as far as the transport protocol is
// concerned (and the success status code is optional).
WriteHeaders(headers, headerStream);
headerStream.WriteTo(NetStream);
headerStream.Close();
StreamHelper.CopyStream(contentStream, NetStream);
contentStream.Close();
}
private static void RunLoop <T>(
int repeat,
Action <object, ChunkedMemoryStream> serialize,
Func <ChunkedMemoryStream, Type, object> deserialize,
BenchType type,
ChunkedMemoryStream ms,
Func <int, T> factory) where T : IEquatable <T>
{
var sw = Stopwatch.StartNew();
var incorrect = 0;
long size = 0;
for (int i = 0; i < repeat; i++)
{
ms.SetLength(0);
var instance = factory(i);
if (type == BenchType.None)
{
continue;
}
serialize(instance, ms);
size += ms.Position;
if (type == BenchType.Both || type == BenchType.Check)
{
ms.Position = 0;
var deser = (T)deserialize(ms, typeof(T));
if (type == BenchType.Check && !instance.Equals(deser))
{
incorrect++;
//throw new SerializationException("not equal");
}
}
}
ReportStatsAndRestart(sw, size, incorrect);
}
public static void Serialize(Image value, TextWriter sw)
{
if (value == null)
{
sw.Write("null");
}
else
{
sw.Write('"');
using (var cms = ChunkedMemoryStream.Create())
{
if (Codecs.Contains(value.RawFormat.Guid))
{
value.Save(cms, value.RawFormat);
}
else
{
value.Save(cms, ImageFormat.Png);
}
cms.Position = 0;
cms.ToBase64Writer(sw);
}
sw.Write('"');
}
}
internal void SendRequest(IMessage msg, ITransportHeaders headers, Stream contentStream)
{
IMethodCallMessage message = (IMethodCallMessage)msg;
int length = (int)contentStream.Length;
string uri = message.Uri;
this._bOneWayRequest = RemotingServices.IsOneWay(message.MethodBase);
ChunkedMemoryStream outputStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
base.WritePreambleAndVersion(outputStream);
if (!this._bOneWayRequest)
{
base.WriteUInt16(0, outputStream);
}
else
{
base.WriteUInt16(1, outputStream);
}
base.WriteUInt16(0, outputStream);
base.WriteInt32(length, outputStream);
base.WriteUInt16(4, outputStream);
base.WriteByte(1, outputStream);
base.WriteCountedString(uri, outputStream);
base.WriteHeaders(headers, outputStream);
outputStream.WriteTo(base.NetStream);
outputStream.Close();
StreamHelper.CopyStream(contentStream, base.NetStream);
contentStream.Close();
}
public Stream ConvertStream <TCommand, TArgument>(TArgument argument)
{
var match = new UriTemplateMatch();
match.RelativePathSegments.Add(typeof(TCommand).FullName);
ThreadContext.Request.UriTemplateMatch = match;
if (argument == null)
{
return(Application.Get());
}
switch (ThreadContext.Request.ContentType)
{
case "application/x-protobuf":
return(Application.Post(Protobuf.Serialize(argument)));
case "application/json":
return(Application.Post(Json.Serialize(argument).BaseStream));
}
using (var ms = ChunkedMemoryStream.Create())
{
var sw = ms.GetWriter();
sw.Write(Xml.Serialize(argument));
sw.Flush();
ms.Position = 0;
return(Application.Post(ms));
}
}
public XElement Serialize <T>(T value)
{
var declaredType = typeof(T);
var type = value != null?value.GetType() : declaredType;
var cms = ChunkedMemoryStream.Create();
var settings = new XmlWriterSettings();
settings.CheckCharacters = false;
settings.NewLineHandling = NewLineHandling.Entitize;
using (var xw = XmlWriter.Create(cms, settings))
using (var dw = XmlDictionaryWriter.CreateDictionaryWriter(xw))
{
var serializer = new DataContractSerializer(type);
serializer.WriteObject(dw, value, GenericResolver);
dw.Flush();
cms.Position = 0;
using (var sr = new StreamReader(cms))
{
var doc = XElement.Load(sr);
if (type != declaredType || !(declaredType.IsClass || declaredType.IsValueType))
{
doc.Add(new XAttribute("type", type.FullName));
}
return(doc);
}
}
}
public HttpSocketContext(string prefix, int limit)
{
this.Prefix = prefix;
this.Limit = limit;
InputStream = ChunkedMemoryStream.Static();
OutputStream = ChunkedMemoryStream.Static();
}
public void ChunkedMemoryStream_Write_CanWriteDataPartiallyInOneTime()
{
var buffers = new[]
{
new byte[10],
new byte[20]
};
var chunkedMemoryStream = new ChunkedMemoryStream(buffers, 0, 30);
// Write the data partially in 1 time
var inBuffer = new byte[20];
for (int i = 0; i < 20; i++)
{
inBuffer[i] = (byte)i;
}
chunkedMemoryStream.Write(inBuffer, 0, 20);
Assert.AreEqual(20, chunkedMemoryStream.Position);
Assert.AreEqual(30, chunkedMemoryStream.Length);
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(inBuffer[i], buffers[0][i]);
}
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(inBuffer[10 + i], buffers[1][i]);
}
}
internal void SendRequest(IMessage msg, ITransportHeaders headers, Stream contentStream)
{
IMethodCallMessage message = (IMethodCallMessage) msg;
int length = (int) contentStream.Length;
string uri = message.Uri;
this._bOneWayRequest = RemotingServices.IsOneWay(message.MethodBase);
ChunkedMemoryStream outputStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
base.WritePreambleAndVersion(outputStream);
if (!this._bOneWayRequest)
{
base.WriteUInt16(0, outputStream);
}
else
{
base.WriteUInt16(1, outputStream);
}
base.WriteUInt16(0, outputStream);
base.WriteInt32(length, outputStream);
base.WriteUInt16(4, outputStream);
base.WriteByte(1, outputStream);
base.WriteCountedString(uri, outputStream);
base.WriteHeaders(headers, outputStream);
outputStream.WriteTo(base.NetStream);
outputStream.Close();
StreamHelper.CopyStream(contentStream, base.NetStream);
contentStream.Close();
}
protected Stream GenerateDocument(params object[] data)
{
var file = Path.Combine(DocumentFolder, TemplateFile);
if (!File.Exists(file))
{
throw new IOException("Can't find template document: " + TemplateFile);
}
var ext = Path.GetExtension(TemplateFile);
var cms = ChunkedMemoryStream.Create();
using (var fs = new FileStream(file, FileMode.Open, FileAccess.Read))
{
fs.CopyTo(cms);
}
cms.Position = 0;
using (var document = Factory.Open(cms, ext))
{
if (data != null)
{
foreach (var d in data)
{
document.Process(d);
}
}
}
cms.Position = 0;
return(ToPdf ? PdfConverter.Convert(cms, ext, true) : cms);
}
private object DeserializeReader(ChunkedMemoryStream cms, TextReader reader, Type type, StreamingContext context)
{
var deserializer = GetDeserializer(type);
if (deserializer == null)
{
try
{
if (context.Context == null)
{
return(SharedSerializer.Deserialize(new JsonTextReader(reader), type));
}
var jsonNet = new JsonSerializer();
jsonNet.Converters.Add(EnumConverter);
jsonNet.Converters.Add(TextReaderConverter);
jsonNet.Converters.Add(TreePathConverter);
jsonNet.TypeNameHandling = TypeNameHandling.Auto;
jsonNet.Context = context;
jsonNet.Binder = Binder;
return(jsonNet.Deserialize(new JsonTextReader(reader), type));
}
catch (TargetInvocationException tex)
{
if (tex.InnerException != null)
{
throw tex.InnerException;
}
throw;
}
}
return(deserializer.Deserialize(cms, reader, context));
}
public void CopyTo(Stream source, byte[] expected)
{
using var destination = new ChunkedMemoryStream(this.allocator);
source.CopyTo(destination);
Assert.InRange(source.Position, source.Length, int.MaxValue); // Copying the data should have read to the end of the stream or stayed past the end.
Assert.Equal(expected, destination.ToArray());
}
public void MemoryStream_CopyTo_Invalid()
{
ChunkedMemoryStream memoryStream;
const string BufferSize = "bufferSize";
using (memoryStream = new ChunkedMemoryStream(this.allocator))
{
const string Destination = "destination";
Assert.Throws <ArgumentNullException>(Destination, () => memoryStream.CopyTo(destination: null));
// Validate the destination parameter first.
Assert.Throws <ArgumentNullException>(Destination, () => memoryStream.CopyTo(destination: null, bufferSize: 0));
Assert.Throws <ArgumentNullException>(Destination, () => memoryStream.CopyTo(destination: null, bufferSize: -1));
// Then bufferSize.
Assert.Throws <ArgumentOutOfRangeException>(BufferSize, () => memoryStream.CopyTo(Stream.Null, bufferSize: 0)); // 0-length buffer doesn't make sense.
Assert.Throws <ArgumentOutOfRangeException>(BufferSize, () => memoryStream.CopyTo(Stream.Null, bufferSize: -1));
}
// After the Stream is disposed, we should fail on all CopyTos.
Assert.Throws <ArgumentOutOfRangeException>(BufferSize, () => memoryStream.CopyTo(Stream.Null, bufferSize: 0)); // Not before bufferSize is validated.
Assert.Throws <ArgumentOutOfRangeException>(BufferSize, () => memoryStream.CopyTo(Stream.Null, bufferSize: -1));
ChunkedMemoryStream disposedStream = memoryStream;
// We should throw first for the source being disposed...
Assert.Throws <ObjectDisposedException>(() => memoryStream.CopyTo(disposedStream, 1));
// Then for the destination being disposed.
memoryStream = new ChunkedMemoryStream(this.allocator);
Assert.Throws <ObjectDisposedException>(() => memoryStream.CopyTo(disposedStream, 1));
memoryStream.Dispose();
}
public void ChunkedMemoryStream_Read_CanReadPartOfDataOutCorrectly()
{
var buffers = new[]
{
new byte[10] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
},
new byte[20] {
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
}
};
var chunkedMemoryStream = new ChunkedMemoryStream(buffers, 0, 30);
var outBuffer = new byte[30];
// Read first 20 bytes out
var bytesRead = chunkedMemoryStream.Read(outBuffer, 0, 20);
Assert.AreEqual(20, bytesRead);
for (int i = 0; i < buffers.Length; i++)
{
Assert.AreEqual(i, outBuffer[i]);
}
// Read last 20 bytes out
chunkedMemoryStream.Position = 10;
bytesRead = chunkedMemoryStream.Read(outBuffer, 0, 20);
Assert.AreEqual(20, bytesRead);
for (int i = 0; i < buffers.Length; i++)
{
Assert.AreEqual(i + 10, outBuffer[i]);
}
}
public object Deserialize(Stream s, Type target, StreamingContext context)
{
var serializer = new DataContractSerializer(target);
var result = serializer.ReadObject(s);
if (context.Context == null)
{
return(result);
}
//TODO fix double serialization because of context
using (var cms = ChunkedMemoryStream.Create())
{
#if NETSTANDARD2_0
Json.Serialize(result, cms, true);
cms.Position = 0;
return(Json.Deserialize(cms, target, context));
#else
var ns = new NetDataContractSerializer(context);
ns.Serialize(cms, result);
ns.Binder = GenericBinder;
cms.Position = 0;
return(ns.Deserialize(cms));
#endif
}
}
public void CreateStreams()
{
this.stream1 = new MemoryStream(this.buffer);
this.stream2 = new MemoryStream(this.buffer);
this.stream3 = new MemoryStream(this.buffer);
this.stream4 = new MemoryStream(this.buffer);
this.stream5 = new MemoryStream(this.buffer);
this.stream6 = new MemoryStream(this.buffer);
this.stream6 = new MemoryStream(this.buffer);
this.chunkedMemoryStream1 = new ChunkedMemoryStream(Configuration.Default.MemoryAllocator);
this.chunkedMemoryStream1.Write(this.buffer);
this.chunkedMemoryStream1.Position = 0;
this.chunkedMemoryStream2 = new ChunkedMemoryStream(Configuration.Default.MemoryAllocator);
this.chunkedMemoryStream2.Write(this.buffer);
this.chunkedMemoryStream2.Position = 0;
this.bufferedStream1 = new BufferedReadStream(Configuration.Default, this.stream3);
this.bufferedStream2 = new BufferedReadStream(Configuration.Default, this.stream4);
this.bufferedStream3 = new BufferedReadStream(Configuration.Default, this.chunkedMemoryStream1);
this.bufferedStream4 = new BufferedReadStream(Configuration.Default, this.chunkedMemoryStream2);
this.bufferedStreamWrap1 = new BufferedReadStreamWrapper(this.stream5);
this.bufferedStreamWrap2 = new BufferedReadStreamWrapper(this.stream6);
}
public static Stream ParseStream(TextReader reader, int context)
{
var cur = reader.Read();
if (cur == ',' || cur == ')')
{
return(null);
}
var len = context + (context << 1);
for (int i = 0; i < len; i++)
{
reader.Read();
}
cur = reader.Read();
var cms = ChunkedMemoryStream.Create();
while (cur != -1 && cur != '\\' && cur != '"')
{
cms.WriteByte((byte)((CharLookup[cur] << 4) + CharLookup[reader.Read()]));
cur = reader.Read();
}
for (int i = 0; i < context; i++)
{
reader.Read();
}
cms.Position = 0;
return(cms);
}
public void ChunkedMemoryStreamLengthShouldBeRight()
{
var buffers = new[] { new byte[10], new byte[20] };
var chunkedMemoryStream = new ChunkedMemoryStream(buffers, 0, 30);
Assert.AreEqual(30, chunkedMemoryStream.Length);
}
public void TestCreateTextDataFromStream()
{
var stream = new ChunkedMemoryStream();
var str = Encoding.ASCII.GetBytes("string");
stream.Write(str, 0, str.Length);
stream.Position = 0L;
var text = ImapData.CreateTextData(stream);
Assert.AreEqual(ImapDataFormat.Text, text.Format);
Assert.AreEqual(6, text.GetTextLength());
Assert.AreEqual(Encoding.ASCII.GetBytes("string"), text.GetTextAsByteArray());
Assert.AreEqual(new ByteString(str), text.GetTextAsByteString());
Assert.AreEqual("string", text.GetTextAsString());
Assert.AreSame(stream, text.GetTextAsStream());
FileAssert.AreEqual(new MemoryStream(str, false), text.GetTextAsStream());
var buffer = new byte[3];
text.CopyText(buffer, 0, buffer.Length);
Assert.AreEqual(str.Slice(0, 3), buffer);
}
private object Deserialize(Type type, XmlReader reader, StreamingContext context)
{
using (var dict = XmlDictionaryReader.CreateDictionaryReader(reader))
{
var serializer = new DataContractSerializer(type);
var result = serializer.ReadObject(dict, false, GenericResolver);
if (context.Context == null)
{
return(result);
}
//TODO NO need for actual xml serializer now
//implement recursive descent and provide context to all objects
using (var cms = ChunkedMemoryStream.Create())
{
var ns = new NetDataContractSerializer(context);
try
{
ns.Serialize(cms, result);
cms.Position = 0;
ns.Binder = GenericBinder;
return(ns.Deserialize(cms));
}
catch (Exception ex)
{
Logger.Trace(ex.ToString());
cms.Position = 0;
Logger.Trace(() => new StreamReader(cms).ReadToEnd());
throw;
}
}
}
}
public void ChunkedMemoryStream_Read_CanReadAllDataOutCorrectlyWhenUndelyingBufferSizeIsGreaterThanActualLength()
{
var buffers = new[]
{
new byte[10] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
},
new byte[20] {
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
}
};
// Length 20 is less than the underlying buffer length 30
var chunkedMemoryStream = new ChunkedMemoryStream(buffers, 0, 20);
Assert.AreEqual(20, chunkedMemoryStream.Length);
var outBuffer = new byte[20];
// Read all out
var bytesRead = chunkedMemoryStream.Read(outBuffer, 0, 20);
Assert.AreEqual(20, bytesRead);
for (int i = 0; i < buffers.Length; i++)
{
Assert.AreEqual(i, outBuffer[i]);
}
}
public Stream Build(bool bulk, Action <StreamWriter, char> mappings)
{
if (Properties == null)
{
return(new MemoryStream(new byte[] { (byte)'N', (byte)'U', (byte)'L', (byte)'L' }));
}
var cms = ChunkedMemoryStream.Create();
var sw = cms.GetWriter();
if (bulk)
{
for (int i = 0; i < Properties.Length; i++)
{
var p = Properties[i];
if (p != null)
{
p.InsertRecord(sw, string.Empty, mappings);
}
else
{
sw.Write("\\N");
}
if (i < Properties.Length - 1)
{
sw.Write('\t');
}
}
}
else
{
sw.Write('(');
for (int i = 0; i < Properties.Length; i++)
{
var p = Properties[i];
if (p != null)
{
if (p.MustEscapeRecord)
{
sw.Write('"');
//TODO string.Empty !?
p.InsertRecord(sw, "1", null);
sw.Write('"');
}
else
{
p.InsertRecord(sw, string.Empty, null);
}
}
if (i < Properties.Length - 1)
{
sw.Write(',');
}
}
sw.Write(')');
}
sw.Flush();
cms.Position = 0;
return(cms);
}
/// <summary>
/// Create reusable stream.
/// Disposing the stream only has the effect of resetting it.
/// </summary>
/// <returns></returns>
public static ChunkedMemoryStream Static()
{
var cms = new ChunkedMemoryStream(new byte[BlockSize]);
cms.GetReader();
cms.GetWriter();
cms.UseBufferedReader(string.Empty);
return cms;
}
public void Write_100_bytes_100_times()
{
byte[] bytes = GetBytes(100);
var stream = new ChunkedMemoryStream();
for(int i = 0; i < 100; ++i) {
stream.Write(bytes, 0, bytes.Length);
}
}
public void Read_from_an_initialized_buffer()
{
var originalBytes = GetBytes(100);
var stream = new ChunkedMemoryStream(originalBytes);
var readBytes = new byte[100];
stream.Read(readBytes, 0, readBytes.Length);
Assert.AreEqual(originalBytes, readBytes);
}
public XmlTuple(XElement xml)
{
var cms = ChunkedMemoryStream.Create();
xml.Save(cms);
cms.Position = 0;
Reader = cms.GetReader();
}
Stream ISerialization <Stream> .Serialize <T>(T value)
{
var cs = ChunkedMemoryStream.Create();
Model.Serialize(cs, value);
cs.Position = 0;
return(cs);
}
public static void Serialize(this IJsonObject instance, ChunkedMemoryStream stream)
{
stream.Reset();
var sw = stream.GetWriter();
instance.Serialize(sw, false, null);
sw.Flush();
stream.Position = 0;
}
public Context(IServiceProvider service)
{
Stream = ChunkedMemoryStream.Static();
Writer = Stream.GetWriter();
var dqm = service.Resolve<IDatabaseQueryManager>();
var factory = service.Resolve<IObjectFactory>().CreateInnerFactory();
factory.RegisterInterfaces(dqm.StartQuery(false));
Repository = factory.Resolve<IPersistableRepository<World>>();
BulkReader = factory.BulkRead(ChunkedMemoryStream.Static());
}
public ResourceContentBE(XDoc doc)
: this(true) {
if(doc == null) {
throw new ArgumentNullException("doc");
}
_stream = new ChunkedMemoryStream();
doc.WriteTo(_stream);
_mimeType = MimeType.TEXT_XML;
_size = (uint)_stream.Length;
}
public ResourceContentBE(string value, MimeType mimeType)
: this(true) {
if(value == null) {
throw new ArgumentNullException("value");
}
if(mimeType == null) {
throw new ArgumentNullException("mimeType");
}
_mimeType = mimeType;
_stream = new ChunkedMemoryStream();
_stream.Write(mimeType.CharSet, value);
_size = (uint)_stream.Length;
}
public void Write_100_bytes_100_times_Read_10000_bytes()
{
byte[] bytes = GetBytes(100);
byte[][] arrays = new byte[100][];
var stream = new ChunkedMemoryStream();
for(int i = 0; i < 100; ++i) {
stream.Write(bytes, 0, bytes.Length);
arrays[i] = bytes;
}
stream.Position = 0;
byte[] buffer = new byte[100 * bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, read);
Assert.AreEqual(ArrayUtil.Concat(arrays), buffer);
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public static void Serialize(this IList<IJsonObject> values, ChunkedMemoryStream stream)
{
stream.Reset();
var sw = stream.GetWriter();
sw.Write('[');
if (values.Count > 0)
{
values[0].Serialize(sw, false, null);
for (int i = 1; i < values.Count; i++)
{
sw.Write(',');
values[i].Serialize(sw, false, null);
}
}
sw.Write(']');
sw.Flush();
stream.Position = 0;
}
public static void Serialize(this IJsonObject[] array, ChunkedMemoryStream stream, int len)
{
stream.Reset();
var sw = stream.GetWriter();
sw.Write('[');
if (len > 0)
{
array[0].Serialize(sw, false, null);
for (int i = 1; i < len; i++)
{
sw.Write(',');
array[i].Serialize(sw, false, null);
}
}
sw.Write(']');
sw.Flush();
stream.Position = 0;
}
private Stream GetPreparedCommandStream()
{
NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "GetPreparedCommandText");
if (parameters.Count == 0)
return new MemoryStream(Encoding.UTF8.GetBytes("execute " + planName));
var cms = new ChunkedMemoryStream();
var sw = new StreamWriter(cms);
sw.Write("execute " + planName);
sw.Write('(');
for (int i = 0; i < parameters.Count; i++)
{
var p = parameters[i];
// Add parentheses wrapping parameter value before the type cast to avoid problems with Int16.MinValue, Int32.MinValue and Int64.MinValue
// See bug #1010543
sw.Write('(');
//TODO fix LOH issue
sw.Write(p.TypeInfo.ConvertToBackend(p.Value, false));
sw.Write('(');
if (p.UseCast)
{
sw.Write("::");
sw.Write(p.TypeInfo.CastName);
if (p.TypeInfo.UseSize && (p.Size > 0))
{
sw.Write('(');
sw.Write(p.Size);
sw.Write(')');
}
}
if (i < parameters.Count - 1)
sw.Write(',');
}
sw.Write(')');
sw.Flush();
return cms;
}
} // AsyncProcessMessage
//
// end of IMessageSink implementation
//
// helper function to serialize the message
private void SerializeMessage(IMethodCallMessage mcm,
out ITransportHeaders headers, out Stream stream)
{
BaseTransportHeaders requestHeaders = new BaseTransportHeaders();
headers = requestHeaders;
// add SOAPAction header
MethodBase mb = mcm.MethodBase;
headers["SOAPAction"] =
'"' +
HttpEncodingHelper.EncodeUriAsXLinkHref(
SoapServices.GetSoapActionFromMethodBase(mb)) +
'"';
// add other http soap headers
requestHeaders.ContentType = CoreChannel.SOAPContentType;
if (_channelProtocol == SinkChannelProtocol.Http)
headers["__RequestVerb"] = "POST";
bool bMemStream = false;
stream = _nextSink.GetRequestStream(mcm, headers);
if (stream == null)
{
stream = new ChunkedMemoryStream(CoreChannel.BufferPool);
bMemStream = true;
}
CoreChannel.SerializeSoapMessage(mcm, stream, _includeVersioning);
if (bMemStream)
stream.Position = 0;
} // SerializeMessage
} // AsyncProcessMessage
// helper function to serialize the message
private void SerializeMessage(IMessage msg,
out ITransportHeaders headers, out Stream stream)
{
BaseTransportHeaders requestHeaders = new BaseTransportHeaders();
headers = requestHeaders;
// add other http soap headers
requestHeaders.ContentType = CoreChannel.BinaryMimeType;
if (_channelProtocol == SinkChannelProtocol.Http)
headers["__RequestVerb"] = "POST";
bool bMemStream = false;
stream = _nextSink.GetRequestStream(msg, headers);
if (stream == null)
{
stream = new ChunkedMemoryStream(CoreChannel.BufferPool);
bMemStream = true;
}
CoreChannel.SerializeBinaryMessage(msg, stream, _includeVersioning);
if (bMemStream)
stream.Position = 0;
} // SerializeMessage
private void SerializeResponse(IServerResponseChannelSinkStack sinkStack,
IMessage msg, ref ITransportHeaders headers,
out Stream stream)
{
BaseTransportHeaders responseHeaders = new BaseTransportHeaders();
if (headers != null)
{
// copy old headers into new headers
foreach (DictionaryEntry entry in headers)
{
responseHeaders[entry.Key] = entry.Value;
}
}
headers = responseHeaders;
if (_protocol == Protocol.Http)
{
responseHeaders.ContentType = CoreChannel.BinaryMimeType;
}
bool bMemStream = false;
stream = sinkStack.GetResponseStream(msg, headers);
if (stream == null)
{
stream = new ChunkedMemoryStream(CoreChannel.BufferPool);
bMemStream = true;
}
bool bBashUrl = CoreChannel.SetupUrlBashingForIisSslIfNecessary();
try
{
CallContext.SetData("__ClientIsClr", true);
CoreChannel.SerializeBinaryMessage(msg, stream, _includeVersioning);
}
finally
{
CallContext.FreeNamedDataSlot("__ClientIsClr");
CoreChannel.CleanupUrlBashingForIisSslIfNecessary(bBashUrl);
}
if (bMemStream)
stream.Position = 0;
} // SerializeResponse
public Stream GetResponseStream(string statusCode, string reasonPhrase, ITransportHeaders headers)
{
bool flag = false;
bool flag2 = false;
int length = 0;
object obj2 = headers["__HttpStatusCode"];
string str = headers["__HttpReasonPhrase"] as string;
if (obj2 != null)
{
statusCode = obj2.ToString();
}
if (str != null)
{
reasonPhrase = str;
}
if (!this.CanServiceAnotherRequest())
{
headers["Connection"] = "Close";
}
object obj3 = headers["Content-Length"];
if (obj3 != null)
{
flag = true;
if (obj3 is int)
{
length = (int) obj3;
}
else
{
length = Convert.ToInt32(obj3, CultureInfo.InvariantCulture);
}
}
flag2 = this.AllowChunkedResponse && !flag;
if (flag2)
{
headers["Transfer-Encoding"] = "chunked";
}
ChunkedMemoryStream outputStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
base.WriteResponseFirstLine(statusCode, reasonPhrase, outputStream);
base.WriteHeaders(headers, outputStream);
outputStream.WriteTo(base.NetStream);
outputStream.Close();
if (flag2)
{
this._responseStream = new HttpChunkedResponseStream(base.NetStream);
}
else
{
this._responseStream = new HttpFixedLengthResponseStream(base.NetStream, length);
}
return this._responseStream;
}
private void SerializeResponse(IServerResponseChannelSinkStack sinkStack,
IMessage msg, bool bClientIsClr, ref ITransportHeaders headers,
out Stream stream)
{
BaseTransportHeaders responseHeaders = new BaseTransportHeaders();
if (headers != null)
{
// copy old headers into new headers
foreach (DictionaryEntry entry in headers)
{
responseHeaders[entry.Key] = entry.Value;
}
}
headers = responseHeaders;
responseHeaders.ContentType = CoreChannel.SOAPContentType;
if (_protocol == Protocol.Http)
{
// check to see if an exception occurred (requires special status code for HTTP)
IMethodReturnMessage mrm = msg as IMethodReturnMessage;
if ((mrm != null) && (mrm.Exception != null))
{
headers["__HttpStatusCode"] = "500";
headers["__HttpReasonPhrase"] = "Internal Server Error";
}
}
bool bMemStream = false;
stream = sinkStack.GetResponseStream(msg, headers);
if (stream == null)
{
stream = new ChunkedMemoryStream(CoreChannel.BufferPool);
bMemStream = true;
}
bool bBashUrl = CoreChannel.SetupUrlBashingForIisSslIfNecessary();
CallContext.SetData("__ClientIsClr", bClientIsClr);
try
{
CoreChannel.SerializeSoapMessage(msg, stream, _includeVersioning);
}
finally
{
CallContext.FreeNamedDataSlot("__ClientIsClr");
CoreChannel.CleanupUrlBashingForIisSslIfNecessary(bBashUrl);
}
if (bMemStream)
stream.Position = 0;
} // SerializeResponse
public CustomWriter(ChunkedMemoryStream cms)
: base(cms) { }
public void Write_100_bytes_100_times_Read_100_bytes_100_times()
{
byte[] bytes = GetBytes(100);
var stream = new ChunkedMemoryStream();
for(int i = 0; i < 100; ++i) {
stream.Write(bytes, 0, bytes.Length);
}
stream.Position = 0;
byte[] buffer = new byte[bytes.Length];
for(int i = 0; i < 100; ++i) {
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, read);
Assert.AreEqual(bytes, buffer);
}
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public void Write_64k_bytes()
{
byte[] bytes = GetBytes(64 * 1024);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
}
} // ProcessAsyncCopyRequestStreamCompletion
// called from ProcessAsyncCopyRequestStreamCompletion
private static void ProcessGetResponseCompletion(IAsyncResult iar)
{
// We've just received a response.
AsyncHttpClientRequestState asyncRequestState = (AsyncHttpClientRequestState)iar.AsyncState;
try
{
// close the request stream since we are done with it.
asyncRequestState.RequestStream.Close();
HttpWebResponse httpWebResponse = null;
HttpWebRequest httpWebRequest = asyncRequestState.WebRequest;
try
{
httpWebResponse = (HttpWebResponse)httpWebRequest.EndGetResponse(iar);
}
catch (WebException webException)
{
ProcessResponseException(webException, out httpWebResponse);
}
asyncRequestState.WebResponse = httpWebResponse;
// Asynchronously pump the web response stream into a memory stream.
ChunkedMemoryStream responseStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
asyncRequestState.ActualResponseStream = responseStream;
StreamHelper.BeginAsyncCopyStream(
httpWebResponse.GetResponseStream(), responseStream,
true, false, // async read, sync write
true, false, // close source, leave target open
s_processAsyncCopyRequestStreamCompletion,
asyncRequestState);
}
catch (Exception e)
{
asyncRequestState.SinkStack.DispatchException(e);
}
catch {
asyncRequestState.SinkStack.DispatchException(new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")));
}
} // ProcessGetResponseCompletion
public void Write_64k_bytes_Read_64k_bytes()
{
byte[] bytes = GetBytes(64 * 1024);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
stream.Position = 0;
byte[] buffer = new byte[bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, read);
Assert.AreEqual(bytes, buffer);
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public void Write_XDoc()
{
var doc = new XDoc("test").Start("content").Value("this is content").End();
var stream = new ChunkedMemoryStream();
doc.WriteTo(stream);
stream.Position = 0;
var newdoc = XDocFactory.From(stream, MimeType.XML);
Assert.AreEqual(doc, newdoc, "xdoc changed during serialization");
}
public void Write_fixed_buffer_with_offset_and_overflow()
{
var bytes = GetBytes(100);
var stream = new ChunkedMemoryStream(bytes, 10, 9);
var writtenBytes = GetBytes(10).Reverse().ToArray();
stream.Write(writtenBytes, 0, writtenBytes.Length);
}
public void Write_fixed_buffer_with_offset()
{
var bytes = GetBytes(100);
var stream = new ChunkedMemoryStream(bytes, 10, 10);
var writtenBytes = GetBytes(10).Reverse().ToArray();
stream.Write(writtenBytes, 0, writtenBytes.Length);
stream.Position = 0;
var readBytes = new byte[10];
stream.Read(readBytes, 0, readBytes.Length);
Assert.AreEqual(writtenBytes, readBytes);
}
public void Write_64k_bytes_Truncate_17k_Read_64k()
{
byte[] bytes = GetBytes(64 * 1024);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
stream.SetLength(17 * 1024);
stream.Position = 0;
byte[] buffer = new byte[bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(17 * 1024, read);
Assert.AreEqual(bytes.Take(17 * 1024).ToArray(), buffer.Take(17 * 1024).ToArray());
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
