public void Dispose() { if (_disposeUnderlying) { _underlying?.Dispose(); } _copy?.Dispose(); }
public void ConstructorCreatesAMemoryStream() { var stream = new RecyclableMemoryStream(); Assert.That( stream.BaseStream, Is.TypeOf <Microsoft.IO.RecyclableMemoryStream>()); stream.Dispose(); }
protected override void Dispose(bool disposing) { base.Dispose(disposing); if (disposing) { _decompressedStream.Dispose(); } _decompressedStream = null; _decoder = null; }
/// <summary> /// Reset the decoder so that we can parse a new message /// </summary> public void Clear() { _bytesLeftForCurrentState = sizeof(short); _bytesLeftInSocketBuffer = 0; _contentStream?.Dispose(); _socketBufferOffset = 0; _contentLengths = null; _objects = null; _stateMethod = ReadHeaderLength; _payloadPosition = 0; }
private void EventLoop(CancellationToken token) { try { for (; ;) { token.ThrowIfCancellationRequested(); long length = (long)Varint.GetUInt64(_stream); if (length == 0) { continue; } Stream resultSteram = null; try { resultSteram = new RecyclableMemoryStream(_bufferManager); using (var safeBuffer = _bufferManager.CreateSafeBuffer(1024 * 32)) { long remain = length; while (remain > 0) { int readLength = _stream.Read(safeBuffer.Value, 0, (int)Math.Min(remain, safeBuffer.Value.Length)); resultSteram.Write(safeBuffer.Value, 0, readLength); remain -= readLength; } } resultSteram.Seek(0, SeekOrigin.Begin); this.OnReceive(resultSteram); } catch (Exception) { if (resultSteram != null) { resultSteram.Dispose(); resultSteram = null; } } } } catch (Exception) { } }
/// <summary> /// Retrieve a new MemoryStream object with the given tag and with contents copied from the provided /// buffer. The provided buffer is not wrapped or used after construction. /// </summary> /// <remarks>The new stream's position is set to the beginning of the stream when returned.</remarks> /// <param name="id">A unique identifier which can be used to trace usages of the stream.</param> /// <param name="tag">A tag which can be used to track the source of the stream.</param> /// <param name="buffer">The byte buffer to copy data from.</param> /// <param name="offset">The offset from the start of the buffer to copy from.</param> /// <param name="count">The number of bytes to copy from the buffer.</param> /// <returns>A MemoryStream.</returns> public RecyclableMemoryStream GetStream(Guid id, object tag, byte[] buffer, int offset, int count) { RecyclableMemoryStream stream = null; try { stream = new RecyclableMemoryStream(this, id, tag, count); stream.Write(buffer, offset, count); stream.Position = 0; return(stream); } catch { stream?.Dispose(); throw; } }
/// <summary> /// Retrieve a new MemoryStream object with the given tag and with contents copied from the provided /// buffer. The provided buffer is not wrapped or used after construction. /// </summary> /// <remarks>The new stream's position is set to the beginning of the stream when returned.</remarks> /// <param name="id">A unique identifier which can be used to trace usages of the stream.</param> /// <param name="tag">A tag which can be used to track the source of the stream.</param> /// <param name="buffer">The byte buffer to copy data from.</param> /// <returns>A MemoryStream.</returns> public MemoryStream GetStream(Guid id, string tag, Memory <byte> buffer) { RecyclableMemoryStream stream = null; try { stream = new RecyclableMemoryStream(this, id, tag, buffer.Length); stream.Write(buffer.Span); stream.Position = 0; return(stream); } catch { stream?.Dispose(); throw; } }
private Stream GetStream(string url) { var recyclableMemoryStream = new RecyclableMemoryStream(_bufferManager); try { using (var client = new HttpClient()) { using (var stream = client.GetStreamAsync(url).Result) { if (stream.Length > 1024 * 1024 * 32) { throw new Exception("too large"); } using (var safeBuffer = _bufferManager.CreateSafeBuffer(1024 * 4)) { int length; while ((length = stream.Read(safeBuffer.Value, 0, safeBuffer.Value.Length)) > 0) { recyclableMemoryStream.Write(safeBuffer.Value, 0, length); if (recyclableMemoryStream.Length > 1024 * 1024 * 32) { throw new Exception("too large"); } } } recyclableMemoryStream.Seek(0, SeekOrigin.Begin); return(recyclableMemoryStream); } } } catch (Exception) { recyclableMemoryStream.Dispose(); throw; } }
private (int, WaitQueue <ResponseInfo>) Send <TArgument>(AmoebaFunctionType type, TArgument argument) { int id = this.CreateId(); var queue = new WaitQueue <ResponseInfo>(); _queueMap.Add(id, queue); var messageStream = new RecyclableMemoryStream(_bufferManager); var writer = new MessageStreamWriter(messageStream, _bufferManager); writer.Write((ulong)type); writer.Write((ulong)id); Stream valueStream = null; if (argument != null) { try { valueStream = new RecyclableMemoryStream(_bufferManager); JsonUtils.Save(valueStream, argument); } catch (Exception) { if (valueStream != null) { valueStream.Dispose(); valueStream = null; } throw; } } messageStream.Seek(0, SeekOrigin.Begin); _messagingManager.Send(new UniteStream(messageStream, valueStream)); return(id, queue); }
public void PublicMethodThrowAfterDispose() { var stream = new RecyclableMemoryStream(); stream.Dispose(); byte[] buffer = new byte[1]; Assert.That( () => stream.SetLength(10), Throws.InstanceOf <ObjectDisposedException>()); Assert.That( () => stream.WriteByte(0x00), Throws.InstanceOf <ObjectDisposedException>()); Assert.That( () => stream.Write(buffer, 0, 1), Throws.InstanceOf <ObjectDisposedException>()); Assert.That( () => stream.ReadByte(), Throws.InstanceOf <ObjectDisposedException>()); Assert.That( () => stream.Read(buffer, 0, 1), Throws.InstanceOf <ObjectDisposedException>()); }
public async Task <Stream> SendMessageAsync(Stream message) { using (var pipe = new NamedPipeClientStream(_serverName, _pipeName, PipeDirection.InOut, PipeOptions.Asynchronous)) { await pipe.ConnectAsync(); var requestLengthBytes = BitConverter.GetBytes(message.Length); await pipe.WriteAsync(requestLengthBytes, 0, 4); await message.CopyToAsync(pipe); await pipe.FlushAsync(); var responseLengthBytes = await pipe.ReadExactlyAsync(4); var responseLength = BitConverter.ToInt32(responseLengthBytes, 0); bool success = false; var ms = new RecyclableMemoryStream(StreamPool.Shared); try { await pipe.ReadExactlyAsync(ms, responseLength); ms.Position = 0; success = true; } finally { if (!success) { ms.Dispose(); } } return(ms); } }
public void UpdatedLongBufferIsClean() { var stream = new RecyclableMemoryStream(); stream.WriteByte(0x42); stream.SetLength(11); Assert.That(stream.Length, Is.EqualTo(11)); stream.Position = 0; Assert.That(stream.ReadByte(), Is.EqualTo(0x42)); for (int i = 0; i < 10; i++) { Assert.That(stream.ReadByte(), Is.EqualTo(0)); } stream.SetLength(80 * 1024); stream.Position = 1; for (int i = 1; i < stream.Length; i++) { Assert.That(stream.ReadByte(), Is.EqualTo(0)); } stream.Dispose(); }
private static Stream Encrypt(Stream stream, ExchangePublicKey publicKey) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } if (publicKey == null) { throw new ArgumentNullException(nameof(publicKey)); } try { RecyclableMemoryStream outStream = null; try { outStream = new RecyclableMemoryStream(_bufferManager); Varint.SetUInt64(outStream, (uint)ConvertCryptoAlgorithm.Aes256); var cryptoKey = new byte[32]; var iv = new byte[32]; using (var random = RandomNumberGenerator.Create()) { random.GetBytes(cryptoKey); random.GetBytes(iv); } { var encryptedBuffer = Exchange.Encrypt(publicKey, cryptoKey); Varint.SetUInt64(outStream, (uint)encryptedBuffer.Length); outStream.Write(encryptedBuffer, 0, encryptedBuffer.Length); } outStream.Write(iv, 0, iv.Length); using (var aes = Aes.Create()) { aes.KeySize = 256; aes.Mode = CipherMode.CBC; aes.Padding = PaddingMode.PKCS7; using (var inStream = new WrapperStream(stream)) using (var cs = new CryptoStream(inStream, aes.CreateEncryptor(cryptoKey, iv), CryptoStreamMode.Read)) using (var safeBuffer = _bufferManager.CreateSafeBuffer(1024 * 4)) { int length; while ((length = cs.Read(safeBuffer.Value, 0, safeBuffer.Value.Length)) > 0) { outStream.Write(safeBuffer.Value, 0, length); } } } outStream.Seek(0, SeekOrigin.Begin); } catch (Exception) { if (outStream != null) { outStream.Dispose(); } throw; } return(outStream); } catch (Exception e) { throw new ArgumentException(e.Message, e); } finally { if (stream != null) { stream.Dispose(); } } }
private static Stream Decompress(Stream stream) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } try { stream.Seek(0, SeekOrigin.Begin); int type = (int)Varint.GetUInt64(stream); if (type == (int)ConvertCompressionAlgorithm.None) { return(new RangeStream(stream)); } else if (type == (int)ConvertCompressionAlgorithm.Deflate) { RecyclableMemoryStream deflateBufferStream = null; try { deflateBufferStream = new RecyclableMemoryStream(_bufferManager); using (var deflateStream = new DeflateStream(stream, CompressionMode.Decompress)) using (var safeBuffer = _bufferManager.CreateSafeBuffer(1024 * 4)) { int length; while ((length = deflateStream.Read(safeBuffer.Value, 0, safeBuffer.Value.Length)) > 0) { deflateBufferStream.Write(safeBuffer.Value, 0, length); if (deflateBufferStream.Length > 1024 * 1024 * 256) { throw new Exception("too large"); } } } deflateBufferStream.Seek(0, SeekOrigin.Begin); return(deflateBufferStream); } catch (Exception) { if (deflateBufferStream != null) { deflateBufferStream.Dispose(); } throw; } } else { throw new ArgumentException("ArgumentException"); } } catch (Exception e) { if (stream != null) { stream.Dispose(); } throw new ArgumentException(e.Message, e); } }
private void RunWriteQueueAction() { //Dequeue all items until threshold is passed long totalLength = 0; RecyclableMemoryStream stream = null; while (totalLength < CoalescingThreshold) { OperationState state; if (!_writeQueue.TryDequeue(out state)) { //No more items in the write queue break; } short streamId; if (!_freeOperations.TryPop(out streamId)) { //Queue it up for later. _writeQueue.Enqueue(state); //When receiving the next complete message, we can process it. Logger.Info("Enqueued, no streamIds available. If this message is recurrent consider configuring more connections per host or lower the pressure"); break; } Logger.Verbose("Sending #{0} for {1} to {2}", streamId, state.Request.GetType().Name, Address); if (_isCanceled) { state.InvokeCallback(new SocketException((int)SocketError.NotConnected)); break; } _pendingOperations.AddOrUpdate(streamId, state, (k, oldValue) => state); Interlocked.Increment(ref _inFlight); int frameLength; try { //lazy initialize the stream stream = stream ?? (RecyclableMemoryStream)Configuration.BufferPool.GetStream(StreamWriteTag); frameLength = state.Request.WriteFrame(streamId, stream, _serializer); if (state.TimeoutMillis > 0) { var requestTimeout = Configuration.Timer.NewTimeout(OnTimeout, streamId, state.TimeoutMillis); state.SetTimeout(requestTimeout); } } catch (Exception ex) { //There was an error while serializing or begin sending Logger.Error(ex); //The request was not written, clear it from pending operations RemoveFromPending(streamId); //Callback with the Exception state.InvokeCallback(ex); break; } //We will not use the request any more, stop reference it. state.Request = null; totalLength += frameLength; } if (totalLength == 0L) { // Nothing to write, set the queue as not running Interlocked.CompareExchange(ref _writeState, WriteStateInit, WriteStateRunning); // Until now, we were preventing other threads to running the queue. // Check if we can now write: // a read could have finished (freeing streamIds) or new request could have been added to the queue if (!_freeOperations.IsEmpty && !_writeQueue.IsEmpty) { //The write queue is not empty //An item was added to the queue but we were running: try to launch a new queue RunWriteQueue(); } if (stream != null) { //The stream instance could be created if there was an exception while generating the frame stream.Dispose(); } return; } //Write and close the stream when flushed // ReSharper disable once PossibleNullReferenceException : if totalLength > 0 the stream is initialized _tcpSocket.Write(stream, () => stream.Dispose()); }
private void RunWriteQueueAction() { //Dequeue all items until threshold is passed long totalLength = 0; RecyclableMemoryStream stream = null; var timestamp = GetTimestamp(); while (totalLength < Connection.CoalescingThreshold) { OperationState state = null; while (_writeQueue.TryDequeue(out var tempState)) { if (tempState.CanBeWritten()) { state = tempState; break; } DecrementInFlight(); } if (state == null) { //No more items in the write queue break; } if (!_freeOperations.TryPop(out short streamId)) { //Queue it up for later. _writeQueue.Enqueue(state); //When receiving the next complete message, we can process it. Connection.Logger.Info("Enqueued, no streamIds available. If this message is recurrent consider configuring more connections per host or lower the pressure"); break; } Connection.Logger.Verbose("Sending #{0} for {1} to {2}", streamId, state.Request.GetType().Name, EndPoint.EndpointFriendlyName); if (_isCanceled) { DecrementInFlight(); state.InvokeCallback(RequestError.CreateClientError(new SocketException((int)SocketError.NotConnected), true), timestamp); break; } _pendingOperations.AddOrUpdate(streamId, state, (k, oldValue) => state); var startLength = stream?.Length ?? 0; try { //lazy initialize the stream stream = stream ?? (RecyclableMemoryStream)Configuration.BufferPool.GetStream(Connection.StreamWriteTag); var frameLength = state.WriteFrame(streamId, stream, Serializer, timestamp); _connectionObserver.OnBytesSent(frameLength); totalLength += frameLength; } catch (Exception ex) { //There was an error while serializing or begin sending Connection.Logger.Error(ex); //The request was not written, clear it from pending operations RemoveFromPending(streamId); //Callback with the Exception state.InvokeCallback(RequestError.CreateClientError(ex, true), timestamp); //Reset the stream to before we started writing this frame stream?.SetLength(startLength); break; } } if (totalLength == 0L) { // Nothing to write, set the queue as not running Interlocked.CompareExchange(ref _writeState, Connection.WriteStateInit, Connection.WriteStateRunning); // Until now, we were preventing other threads to running the queue. // Check if we can now write: // a read could have finished (freeing streamIds) or new request could have been added to the queue if (!_freeOperations.IsEmpty && !_writeQueue.IsEmpty) { //The write queue is not empty //An item was added to the queue but we were running: try to launch a new queue RunWriteQueue(); } if (stream != null) { //The stream instance could be created if there was an exception while generating the frame stream.Dispose(); } return; } //Write and close the stream when flushed // ReSharper disable once PossibleNullReferenceException : if totalLength > 0 the stream is initialized _tcpSocket.Write(stream, () => stream.Dispose()); }
public void Dispose() { m_disposed = true; m_stream?.Dispose(); m_stream = null; }
private void _messagingManager_ReceiveEvent(Stream requestStream) { var reader = new MessageStreamReader(new WrapperStream(requestStream), _bufferManager); { var type = (AmoebaFunctionType)reader.GetUInt64(); int id = (int)reader.GetUInt64(); if (type == AmoebaFunctionType.Exit) { SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); _tokenSource.Cancel(); } else if (type == AmoebaFunctionType.Cancel) { if (_tasks.TryGetValue(id, out var responseTask)) { responseTask.Stop(); } } else { var responseTask = ResponseTask.Create((token) => { try { switch (type) { case AmoebaFunctionType.GetReport: { SendResponse(AmoebaFunctionResponseType.Result, id, _serviceManager.Report); break; } case AmoebaFunctionType.GetNetworkConnectionReports: { SendResponse(AmoebaFunctionResponseType.Result, id, _serviceManager.GetNetworkConnectionReports()); break; } case AmoebaFunctionType.GetCacheContentReports: { SendResponse(AmoebaFunctionResponseType.Result, id, _serviceManager.GetCacheContentReports()); break; } case AmoebaFunctionType.GetDownloadContentReports: { SendResponse(AmoebaFunctionResponseType.Result, id, _serviceManager.GetDownloadContentReports()); break; } case AmoebaFunctionType.GetConfig: { SendResponse(AmoebaFunctionResponseType.Result, id, _serviceManager.Config); break; } case AmoebaFunctionType.SetConfig: { var config = JsonUtils.Load <ServiceConfig>(requestStream); _serviceManager.SetConfig(config); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.SetCloudLocations: { var cloudLocations = JsonUtils.Load <Location[]>(requestStream); _serviceManager.SetCloudLocations(cloudLocations); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.GetSize: { SendResponse(AmoebaFunctionResponseType.Result, id, _serviceManager.Size); break; } case AmoebaFunctionType.Resize: { long size = JsonUtils.Load <long>(requestStream); _serviceManager.Resize(size); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.CheckBlocks: { _serviceManager.CheckBlocks(new Action <CheckBlocksProgressReport>((report) => { SendResponse(AmoebaFunctionResponseType.Output, id, report); }), token).Wait(); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.AddContent: { var arguments = JsonUtils.Load <(string, DateTime)>(requestStream); var result = _serviceManager.AddContent(arguments.Item1, arguments.Item2, token).Result; SendResponse(AmoebaFunctionResponseType.Result, id, result); break; } case AmoebaFunctionType.RemoveContent: { string path = JsonUtils.Load <string>(requestStream); _serviceManager.RemoveContent(path); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.Diffusion: { string path = JsonUtils.Load <string>(requestStream); _serviceManager.DiffuseContent(path); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.AddDownload: { var arguments = JsonUtils.Load <(Metadata, string, long)>(requestStream); _serviceManager.AddDownload(arguments.Item1, arguments.Item2, arguments.Item3); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.RemoveDownload: { var arguments = JsonUtils.Load <(Metadata, string)>(requestStream); _serviceManager.RemoveDownload(arguments.Item1, arguments.Item2); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.ResetDownload: { var arguments = JsonUtils.Load <(Metadata, string)>(requestStream); _serviceManager.ResetDownload(arguments.Item1, arguments.Item2); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.SetProfile: { var arguments = JsonUtils.Load <(ProfileContent, DigitalSignature)>(requestStream); _serviceManager.SetProfile(arguments.Item1, arguments.Item2, token).Wait(); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.SetStore: { var arguments = JsonUtils.Load <(StoreContent, DigitalSignature)>(requestStream); _serviceManager.SetStore(arguments.Item1, arguments.Item2, token).Wait(); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.SetUnicastCommentMessage: { var arguments = JsonUtils.Load <(Signature, CommentContent, AgreementPublicKey, DigitalSignature)>(requestStream); _serviceManager.SetUnicastCommentMessage(arguments.Item1, arguments.Item2, arguments.Item3, arguments.Item4, token).Wait(); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.SetMulticastCommentMessage: { var arguments = JsonUtils.Load <(Tag, CommentContent, DigitalSignature, TimeSpan)>(requestStream); _serviceManager.SetMulticastCommentMessage(arguments.Item1, arguments.Item2, arguments.Item3, arguments.Item4, token).Wait(); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.GetProfile: { var signature = JsonUtils.Load <Signature>(requestStream); var result = _serviceManager.GetProfile(signature, token).Result; SendResponse(AmoebaFunctionResponseType.Result, id, result); break; } case AmoebaFunctionType.GetStore: { var signature = JsonUtils.Load <Signature>(requestStream); var result = _serviceManager.GetStore(signature, token).Result; SendResponse(AmoebaFunctionResponseType.Result, id, result); break; } case AmoebaFunctionType.GetUnicastCommentMessages: { var arguments = JsonUtils.Load <(Signature, AgreementPrivateKey)>(requestStream); var result = _serviceManager.GetUnicastCommentMessages(arguments.Item1, arguments.Item2, token).Result; SendResponse(AmoebaFunctionResponseType.Result, id, result); break; } case AmoebaFunctionType.GetMulticastCommentMessages: { var tag = JsonUtils.Load <Tag>(requestStream); var result = _serviceManager.GetMulticastCommentMessages(tag, token).Result; SendResponse(AmoebaFunctionResponseType.Result, id, result); break; } case AmoebaFunctionType.GetState: { SendResponse(AmoebaFunctionResponseType.Result, id, _serviceManager.State); break; } case AmoebaFunctionType.Start: { _serviceManager.Start(); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.Stop: { _serviceManager.Stop(); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.Load: { _serviceManager.Load(); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } case AmoebaFunctionType.Save: { _serviceManager.Save(); SendResponse(AmoebaFunctionResponseType.Result, id, (object)null); break; } } } catch (OperationCanceledException) { SendResponse(AmoebaFunctionResponseType.Cancel, id, (object)null); } catch (Exception e) { Log.Error(string.Format("Rpc Error: {0}", type.ToString())); Log.Error(e); var argument = new AmoebaErrorMessage(e.GetType().ToString(), e.Message, e.StackTrace?.ToString()); SendResponse(AmoebaFunctionResponseType.Error, id, argument); } finally { requestStream.Dispose(); _tasks.Remove(id); } }); _tasks.Add(id, responseTask); responseTask.Start(); } } void SendResponse <T>(AmoebaFunctionResponseType type, int id, T value) { var messageStream = new RecyclableMemoryStream(_bufferManager); var writer = new MessageStreamWriter(messageStream, _bufferManager); writer.Write((ulong)type); writer.Write((ulong)id); Stream valueStream = null; if (value != null) { try { valueStream = new RecyclableMemoryStream(_bufferManager); JsonUtils.Save(valueStream, value); } catch (Exception) { if (valueStream != null) { valueStream.Dispose(); valueStream = null; } return; } } messageStream.Seek(0, SeekOrigin.Begin); _messagingManager.Send(new UniteStream(messageStream, valueStream)); } }
private static Stream Decrypt(Stream stream, ExchangePrivateKey privateKey) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } if (privateKey == null) { throw new ArgumentNullException(nameof(privateKey)); } try { int type = (int)Varint.GetUInt64(stream); if (type == (int)ConvertCryptoAlgorithm.Aes256) { byte[] cryptoKey; { int length = (int)Varint.GetUInt64(stream); var encryptedBuffer = new byte[length]; if (stream.Read(encryptedBuffer, 0, encryptedBuffer.Length) != encryptedBuffer.Length) { throw new ArgumentException(); } cryptoKey = Exchange.Decrypt(privateKey, encryptedBuffer); } var iv = new byte[32]; stream.Read(iv, 0, iv.Length); RecyclableMemoryStream outStream = null; try { outStream = new RecyclableMemoryStream(_bufferManager); using (var aes = Aes.Create()) { aes.KeySize = 256; aes.Mode = CipherMode.CBC; aes.Padding = PaddingMode.PKCS7; using (var inStream = new RangeStream(stream, stream.Position, stream.Length - stream.Position, true)) using (var cs = new CryptoStream(inStream, aes.CreateDecryptor(cryptoKey, iv), CryptoStreamMode.Read)) using (var safeBuffer = _bufferManager.CreateSafeBuffer(1024 * 4)) { int length; while ((length = cs.Read(safeBuffer.Value, 0, safeBuffer.Value.Length)) > 0) { outStream.Write(safeBuffer.Value, 0, length); } } } outStream.Seek(0, SeekOrigin.Begin); } catch (Exception) { if (outStream != null) { outStream.Dispose(); } throw; } return(outStream); } else { throw new NotSupportedException(); } } catch (Exception e) { throw new ArgumentException(e.Message, e); } finally { if (stream != null) { stream.Dispose(); } } }
private static Stream Compress(Stream stream) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } try { var dic = new Dictionary <byte, Stream>(); try { stream.Seek(0, SeekOrigin.Begin); RecyclableMemoryStream deflateBufferStream = null; try { deflateBufferStream = new RecyclableMemoryStream(_bufferManager); using (var deflateStream = new DeflateStream(deflateBufferStream, CompressionMode.Compress, true)) using (var safeBuffer = _bufferManager.CreateSafeBuffer(1024 * 4)) { int length; while ((length = stream.Read(safeBuffer.Value, 0, safeBuffer.Value.Length)) > 0) { deflateStream.Write(safeBuffer.Value, 0, length); } } deflateBufferStream.Seek(0, SeekOrigin.Begin); dic.Add((byte)ConvertCompressionAlgorithm.Deflate, deflateBufferStream); } catch (Exception) { if (deflateBufferStream != null) { deflateBufferStream.Dispose(); } } } catch (Exception) { } dic.Add((byte)ConvertCompressionAlgorithm.None, stream); var list = dic.ToList(); list.Sort((x, y) => { int c = x.Value.Length.CompareTo(y.Value.Length); if (c != 0) { return(c); } return(x.Key.CompareTo(y.Key)); }); for (int i = 1; i < list.Count; i++) { list[i].Value.Dispose(); } var headerStream = new RecyclableMemoryStream(_bufferManager); Varint.SetUInt64(headerStream, list[0].Key); return(new UniteStream(headerStream, list[0].Value)); } catch (Exception ex) { if (stream != null) { stream.Dispose(); } throw new ArgumentException(ex.Message, ex); } }
public void AllocationStackIsRecorded() { var memMgr = this.GetMemoryManager(); memMgr.GenerateCallStacks = true; var stream = new RecyclableMemoryStream(memMgr); Assert.That(stream.AllocationStack, Is.StringContaining("RecyclableMemoryStream..ctor")); stream.Dispose(); memMgr.GenerateCallStacks = false; var stream2 = new RecyclableMemoryStream(memMgr); Assert.That(stream2.AllocationStack, Is.Null); stream2.Dispose(); }