public static void Run()
{
using (var factory = new PipelineFactory())
{
var filePath = Path.GetFullPath("Program.cs");
// This is what Stream looks like
//var fs = File.OpenRead(filePath);
//var compressed = new MemoryStream();
//var compressStream = new DeflateStream(compressed, CompressionMode.Compress);
//fs.CopyTo(compressStream);
//compressStream.Flush();
//compressed.Seek(0, SeekOrigin.Begin);
var input = factory.ReadFile(filePath)
.DeflateCompress(factory, CompressionLevel.Optimal)
.DeflateDecompress(factory);
// Wrap the console in a pipeline writer
var output = factory.CreateWriter(Console.OpenStandardOutput());
// Copy from the file reader to the console writer
input.CopyToAsync(output).GetAwaiter().GetResult();
input.Complete();
output.Complete();
}
}
public async Task TestIndexOfWorksForAllLocations()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
const int Size = 5 * 4032; // multiple blocks
// populate with a pile of dummy data
byte[] data = new byte[512];
for (int i = 0; i < data.Length; i++) data[i] = 42;
int totalBytes = 0;
var writeBuffer = readerWriter.Alloc();
for (int i = 0; i < Size / data.Length; i++)
{
writeBuffer.Write(data);
totalBytes += data.Length;
}
await writeBuffer.FlushAsync();
// now read it back
var result = await readerWriter.ReadAsync();
var readBuffer = result.Buffer;
Assert.False(readBuffer.IsSingleSpan);
Assert.Equal(totalBytes, readBuffer.Length);
TestIndexOfWorksForAllLocations(ref readBuffer, 42);
}
}
/// <summary>
/// Releases all resources owned by the listener
/// </summary>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
GC.SuppressFinalize(this);
_socket?.Dispose();
_socket = null;
if (_ownsFactory) { _factory?.Dispose(); }
_factory = null;
}
}
public async Task Reference_Invalid_Token_Sent()
{
_options.BackchannelHttpHandler = new FailureValidationEndointHandler();
var client = PipelineFactory.CreateHttpClient(_options);
client.SetBearerToken("invalid");
var result = await client.GetAsync("http://test")
.ConfigureAwait(false);
result.StatusCode.Should().Be(HttpStatusCode.Unauthorized);
}
public void Return <T>(T errorCode)
{
var returnMessage = ControlMessage.Create(Address.Local);
returnMessage.MessageIntent = MessageIntentEnum.Reply;
returnMessage.Headers[Headers.ReturnMessageErrorCodeHeader] = errorCode.GetHashCode().ToString();
returnMessage.CorrelationId = !string.IsNullOrEmpty(MessageBeingProcessed.CorrelationId) ? MessageBeingProcessed.CorrelationId : MessageBeingProcessed.Id;
var options = SendOptions.ReplyTo(MessageBeingProcessed.ReplyToAddress);
PipelineFactory.InvokeSendPipeline(options, returnMessage);
}
public async Task InactiveToken()
{
_options.IntrospectionHttpHandler = new IntrospectionEndpointHandler(IntrospectionEndpointHandler.Behavior.Inactive);
var client = PipelineFactory.CreateHttpClient(_options);
client.SetBearerToken("sometoken");
var result = await client.GetAsync("http://test")
.ConfigureAwait(false);
result.StatusCode.Should().Be(HttpStatusCode.Unauthorized);
}
public void NullTest()
{
try
{
PipelineFactory.Create(null, null);
}
catch (ArgumentException)
{
return;
}
throw new Exception("PipelineFactory.Create should throw exception for null");
}
public async Task Token_Sent_No_Scope_Api1_Api2_ScopeRequirements()
{
_options.RequiredScopes = new[] { TokenFactory.Api1Scope, TokenFactory.Api2Scope };
var client = PipelineFactory.CreateHttpClient(_options);
var token = TokenFactory.CreateTokenString(TokenFactory.CreateToken());
client.SetBearerToken(token);
var result = await client.GetAsync("http://test");
result.StatusCode.Should().Be(HttpStatusCode.Forbidden);
}
public async Task invalid_jwt_token_should_return_401()
{
var client = PipelineFactory.CreateClient(options =>
{
options.Authority = "https://demo.identityserver.io";
options.ApiName = "api1";
});
client.SetBearerToken("header.payload.signature");
var response = await client.GetAsync("http://api");
response.StatusCode.Should().Be(HttpStatusCode.Unauthorized);
}
public async Task Reference_Sent_No_Scope_No_ScopeRequirements()
{
_options.BackchannelHttpHandler = new SuccessValidationEndointHandler();
var client = PipelineFactory.CreateHttpClient(_options);
client.SetBearerToken("reference");
var result = await client.GetAsync("http://test")
.ConfigureAwait(false);
result.StatusCode.Should().Be(HttpStatusCode.OK);
}
private void Load(DcmDataset dataset)
{
Dataset = dataset;
if (Dataset.InternalTransferSyntax.IsEncapsulated)
{
Dataset.ChangeTransferSyntax(DicomTransferSyntax.ExplicitVRLittleEndian, null);
}
DcmPixelData pixelData = new DcmPixelData(Dataset);
_pixelData = PixelDataFactory.Create(pixelData, 0);
_pipeline = PipelineFactory.Create(Dataset, pixelData);
pixelData.Unload();
}
public async Task Reference_Sent_No_Scope_Api1_ScopeRequirements()
{
_options.RequiredScopes = new[] { TokenFactory.Api1Scope };
_options.BackchannelHttpHandler = new SuccessValidationEndointHandler();
var client = PipelineFactory.CreateHttpClient(_options);
client.SetBearerToken("reference");
var result = await client.GetAsync("http://test");
result.StatusCode.Should().Be(HttpStatusCode.Forbidden);
}
public async Task JWT_Sent_No_Scope_No_ScopeRequirements()
{
_options.BackchannelHttpHandler = new DiscoveryEndpointHandler();
var client = PipelineFactory.CreateHttpClient(_options);
var token = TokenFactory.CreateTokenString(TokenFactory.CreateToken());
client.SetBearerToken(token);
var result = await client.GetAsync("http://test")
.ConfigureAwait(false);
result.StatusCode.Should().Be(HttpStatusCode.OK);
}
public void TestChangeInvalidEncoding()
{
var pipeline = PipelineFactory.CreateEmptyReceivePipeline();
var setCharset = new SetCharset
{
TargetCharset = "invalid"
};
var message = MessageHelper.CreateFromString("<test></test>");
pipeline.AddComponent(setCharset, PipelineStage.Decode);
var result = pipeline.Execute(message);
}
public void Setup()
{
var container = TestControllerBuilder.GetWindsorContainer();
var pipelineFactory =
new PipelineFactory(container, null, null, null, null, new SingleStepPipelineProviderForTest(typeof(DeleteReferentialExceptionStep <, , ,>)));
var controller = TestControllerBuilder.GetController <StudentsController>(pipelineFactory, this._id.ToString("N"));
_id = Guid.NewGuid();
_responseMessage = controller.Delete(_id)
.GetResultSafely()
.ExecuteAsync(new CancellationToken())
.GetResultSafely();
}
public void TestCompressInvalidExtension()
{
var pipeline = PipelineFactory.CreateEmptySendPipeline();
var component = new CompressMessage {
DefaultZipEntryFileExtension = ".xml"
};
var msg = MessageHelper.CreateFromString("<testmessage1></testmessage1>");
pipeline.AddComponent(component, PipelineStage.Encode);
var result = pipeline.Execute(msg);
}
public void Dispose()
{
if (_pipeline != null)
{
_pipeline.Dispose();
_pipeline = null;
}
if (_factoryContext != null)
{
_factoryContext.Dispose();
_factoryContext = null;
}
}
public async Task JWT_Sent_No_Scope_Api1_ScopeRequirements()
{
_options.BackchannelHttpHandler = new DiscoveryEndpointHandler();
_options.RequiredScopes = new[] { TokenFactory.Api1Scope };
var client = PipelineFactory.CreateHttpClient(_options);
var token = TokenFactory.CreateTokenString(TokenFactory.CreateToken());
client.SetBearerToken(token);
var result = await client.GetAsync("http://test");
result.StatusCode.Should().Be(HttpStatusCode.Forbidden);
}
public void LeaveReview(Product product, string name, string email, string ratingKey, string reviewHeadline, string reviewText)
{
var request = HttpContext.Current.Request;
var basket = SiteContext.Current.OrderContext.GetBasket();
if (request.Form.AllKeys.All(x => x != "review-product"))
{
return;
}
var rating = Convert.ToInt32(request.Form[ratingKey]) * 20;
if (basket.PurchaseOrder.Customer == null)
{
basket.PurchaseOrder.Customer = new Customer()
{
FirstName = name, LastName = String.Empty, EmailAddress = email
};
}
else
{
basket.PurchaseOrder.Customer.FirstName = name;
if (basket.PurchaseOrder.Customer.LastName == null)
{
basket.PurchaseOrder.Customer.LastName = String.Empty;
}
basket.PurchaseOrder.Customer.EmailAddress = email;
}
basket.PurchaseOrder.Customer.Save();
var review = new ProductReview()
{
ProductCatalogGroup = SiteContext.Current.CatalogContext.CurrentCatalogGroup,
ProductReviewStatus = ProductReviewStatus.SingleOrDefault(s => s.Name == "New"),
CreatedOn = DateTime.Now,
CreatedBy = "System",
Product = product,
Customer = basket.PurchaseOrder.Customer,
Rating = rating,
ReviewHeadline = reviewHeadline,
ReviewText = reviewText,
Ip = request.UserHostName
};
product.AddProductReview(review);
PipelineFactory.Create <ProductReview>("ProductReview").Execute(review);
Response.Redirect(Request.RawUrl);
}
OutgoingContext InvokeSendPipeline(DeliveryOptions sendOptions, LogicalMessage message)
{
if (sendOptions.ReplyToAddress == null && !SendOnlyMode)
{
sendOptions.ReplyToAddress = Configure.PublicReturnAddress;
}
if (PropagateReturnAddressOnSend && CurrentMessageContext != null)
{
sendOptions.ReplyToAddress = CurrentMessageContext.ReplyToAddress;
}
return(PipelineFactory.InvokeSendPipeline(sendOptions, message));
}
SendLogicalMessagesContext InvokeSendPipeline(SendOptions sendOptions, List <LogicalMessage> messages)
{
if (sendOptions.ReplyToAddress == null && !Configure.SendOnlyMode)
{
sendOptions.ReplyToAddress = Address.Local;
}
if (PropagateReturnAddressOnSend && CurrentMessageContext != null)
{
sendOptions.ReplyToAddress = CurrentMessageContext.ReplyToAddress;
}
return(PipelineFactory.InvokeSendPipeline(sendOptions, messages));
}
public void CanAddDocSpecByName()
{
ReceivePipelineWrapper pipeline = PipelineFactory.CreateEmptyReceivePipeline();
pipeline.AddDocSpec("SampleSchemas.Schema1_NPP+Root", "SampleSchemas");
IDocumentSpec docSpec =
pipeline.GetKnownDocSpecByName(typeof(Schema1_NPP.Root).AssemblyQualifiedName);
Assert.IsNotNull(docSpec);
docSpec = pipeline.GetKnownDocSpecByType("http://SampleSchemas.Schema1_NPP#Root");
Assert.IsNotNull(docSpec);
}
/// <summary>
/// Releases all resources owned by the listener
/// </summary>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
GC.SuppressFinalize(this);
_socket?.Dispose();
_socket = null;
if (_ownsFactory)
{
_factory?.Dispose();
}
_factory = null;
}
}
public async Task ActiveToken()
{
var client = PipelineFactory.CreateClient((o) =>
{
_options(o);
o.IntrospectionHttpHandler = new IntrospectionEndpointHandler(IntrospectionEndpointHandler.Behavior.Active);
});
client.SetBearerToken("sometoken");
var result = await client.GetAsync("http://test");
result.StatusCode.Should().Be(HttpStatusCode.OK);
}
public override void Process(ServicePipelineArgs args)
{
AddShippingInfoRequest request;
AddShippingInfoResult result;
using (new DisposableThreadLifestyleScope())
{
CheckParametersAndSetupRequestAndResult(args, out request, out result);
Assert.ArgumentNotNull(request.ShippingInfo, "request.ShippingInfo");
Assert.ArgumentNotNull(request.Cart, "request.Cart");
Assert.ArgumentCondition(request.ShippingInfo.Count != 0, "request.ShippingInfo",
"request.ShippingInfo cannot be empty");
Assert.ArgumentCondition(request.ShippingInfo.Count == 1, "request.ShippingInfo",
"request.ShippingInfo cannot contain more than 1 ShippingInfo");
var shipments = new List <Shipment>();
var purchaseOrder = _basketService.GetBasketByCartExternalId(request.Cart.ExternalId).PurchaseOrder;
if (!IsFromUcommerce(request))
{
var createShipmentPipeline = PipelineFactory.Create <IPipelineArgs <CreateShipmentRequest, CreateShipmentResult> >("CreateShipment");
var createShipmentPipelineArgs = new CreateShipmentPipelineArgs(new CreateShipmentRequest()
{
ShippingMethod = GetShippingMethod(request.ShippingInfo.First()),
OverwriteExisting = false,
PurchaseOrder = purchaseOrder,
ShippingAddress = GetOrderAddress(GetPartyFromCart(request.ShippingInfo.First(), request.Cart))
}, new CreateShipmentResult());
createShipmentPipelineArgs.Request.Properties["FromUCommerce"] = false;
createShipmentPipeline.Execute(createShipmentPipelineArgs);
shipments.Add(createShipmentPipelineArgs.Response.Shipment);
PipelineFactory.Create <PurchaseOrder>("Basket").Execute(purchaseOrder);
}
else
{
shipments.Add(purchaseOrder.Shipments.Last());
}
var shippingInfos = _shipmentMapper.Map(shipments);
result.ShippingInfo = new ReadOnlyCollection <ShippingInfo>(shippingInfos);
result.Cart = _purchaseOrderMapper.Map(purchaseOrder);
}
}
public async Task Reference_Sent_Api1_Scope_Api1_ScopeRequirements()
{
_options.RequiredScopes = new[] { TokenFactory.Api1Scope };
_options.BackchannelHttpHandler = new SuccessValidationEndointHandler(
new[] { Tuple.Create <object, object>("scope", TokenFactory.Api1Scope) });
var client = PipelineFactory.CreateHttpClient(_options);
client.SetBearerToken("reference");
var result = await client.GetAsync("http://test")
.ConfigureAwait(false);
result.StatusCode.Should().Be(HttpStatusCode.OK);
}
private static ReceivePipelineWrapper GeneratePipeline(string customPropertyNamespace, bool excludeSystemProperties)
{
PropertyMessageDecoder propertyMessageDecoder = new PropertyMessageDecoder();
propertyMessageDecoder.CustomPropertyNamespace = customPropertyNamespace;
propertyMessageDecoder.ExcludeSystemProperties = excludeSystemProperties;
ReceivePipelineWrapper pipeline = PipelineFactory.CreateEmptyReceivePipeline();
pipeline.AddComponent(propertyMessageDecoder, PipelineStage.Decode);
pipeline.AddComponent(new Microsoft.BizTalk.Component.XmlDasmComp(), PipelineStage.Disassemble);
pipeline.AddDocSpec(typeof(PropertyMessage));
return(pipeline);
}
void TransportFinishedMessageProcessing(object sender, FinishedMessageProcessingEventArgs e)
{
try
{
modules.ForEach(module =>
{
Log.Debug("Calling 'HandleEndMessage' on " + module.GetType().FullName);
module.HandleEndMessage();
});
}
finally
{
PipelineFactory.CompletePhysicalMessagePipelineContext();
}
}
/// <summary>
/// Begins an asynchronous connect operation to the designated endpoint
/// </summary>
/// <param name="endPoint">The endpoint to which to connect</param>
/// <param name="factory">Optionally allows the underlying <see cref="PipelineFactory"/> (and hence memory pool) to be specified; if one is not provided, a <see cref="PipelineFactory"/> will be instantiated and owned by the connection</param>
public static Task <SocketConnection> ConnectAsync(IPEndPoint endPoint, PipelineFactory factory = null)
{
var args = new SocketAsyncEventArgs();
args.RemoteEndPoint = endPoint;
args.Completed += _asyncCompleted;
var tcs = new TaskCompletionSource <SocketConnection>(factory);
args.UserToken = tcs;
if (!Socket.ConnectAsync(SocketType.Stream, ProtocolType.Tcp, args))
{
OnConnect(args); // completed sync - usually means failure
}
return(tcs.Task);
}
public void CanExecuteEmptyPipeline()
{
ReceivePipelineWrapper pipeline =
PipelineFactory.CreateEmptyReceivePipeline();
// Create the input message to pass through the pipeline
Stream stream = DocLoader.LoadStream("SampleDocument.xml");
IBaseMessage inputMessage = MessageHelper.CreateFromStream(stream);
// Execute the pipeline, and check the output
MessageCollection outputMessages = pipeline.Execute(inputMessage);
Assert.IsNotNull(outputMessages);
Assert.IsTrue(outputMessages.Count > 0);
}
public void IngnoresOpeningYaml()
{
var text =
@"---
key:value
...
now markdown";
var factory = new PipelineFactory(new TestFileSystem(), new TestBlogServer());
var pipeline = factory.Build();
var html = Markdown.ToHtml(text, pipeline);
Assert.Single(pipeline.Extensions.OfType <YamlFrontMatterExtension>());
Assert.DoesNotContain("key", html);
Assert.Contains("now markdown", html);
}
private static IQueryPipelineStage CreatePipeline(IDocumentContainer documentContainer, string query, int pageSize = 10, CosmosElement state = null)
{
TryCatch <IQueryPipelineStage> tryCreatePipeline = PipelineFactory.MonadicCreate(
ExecutionEnvironment.Compute,
documentContainer,
new SqlQuerySpec(query),
new List <FeedRangeEpk>()
{
FeedRangeEpk.FullRange
},
partitionKey: null,
GetQueryPlan(query),
pageSize: pageSize,
maxConcurrency: 10,
requestCancellationToken: default,
public async Task Token_Sent_Api1_Scope_Api1_ScopeRequirements()
{
_options.RequiredScopes = new[] { TokenFactory.Api1Scope };
var client = PipelineFactory.CreateHttpClient(_options);
var token = TokenFactory.CreateTokenString(
TokenFactory.CreateToken(scope: new[] { TokenFactory.Api1Scope }));
client.SetBearerToken(token);
var result = await client.GetAsync("http://test")
.ConfigureAwait(false);
result.StatusCode.Should().Be(HttpStatusCode.OK);
}
public async Task ReaderShouldNotGetUnflushedBytesWhenOverflowingSegments()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
// Fill the block with stuff leaving 5 bytes at the end
var buffer = readerWriter.Alloc(1);
var len = buffer.Memory.Length;
// Fill the buffer with garbage
// block 1 -> block2
// [padding..hello] -> [ world ]
var paddingBytes = Enumerable.Repeat((byte)'a', len - 5).ToArray();
buffer.Write(paddingBytes);
await buffer.FlushAsync();
// Write 10 and flush
buffer = readerWriter.Alloc();
buffer.WriteLittleEndian(10);
// Write 9
buffer.WriteLittleEndian(9);
// Write 8
buffer.WriteLittleEndian(8);
// Make sure we don't see it yet
var result = await readerWriter.ReadAsync();
var reader = result.Buffer;
Assert.Equal(len - 5, reader.Length);
// Don't move
readerWriter.Advance(reader.End);
// Now flush
await buffer.FlushAsync();
reader = (await readerWriter.ReadAsync()).Buffer;
Assert.Equal(12, reader.Length);
Assert.Equal(10, reader.ReadLittleEndian<int>());
Assert.Equal(9, reader.Slice(4).ReadLittleEndian<int>());
Assert.Equal(8, reader.Slice(8).ReadLittleEndian<int>());
}
}
internal SocketConnection(Socket socket, PipelineFactory factory)
{
socket.NoDelay = true;
_socket = socket;
if (factory == null)
{
_ownsFactory = true;
factory = new PipelineFactory();
}
_factory = factory;
_input = PipelineFactory.Create();
_output = PipelineFactory.Create();
ShutdownSocketWhenWritingCompletedAsync();
ReceiveFromSocketAndPushToWriterAsync();
ReadFromReaderAndWriteToSocketAsync();
}
public async Task PeekWorkesWithEmptySegments()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
var w = readerWriter.Alloc();
w.Append(ReadableBuffer.Create(new byte[] { 0 }, 0, 0));
w.Append(ReadableBuffer.Create(new byte[] { 1 }, 0, 1));
await w.FlushAsync();
var result = await readerWriter.ReadAsync();
var buffer = result.Buffer;
var reader = new ReadableBufferReader(buffer);
Assert.Equal(1, reader.Peek());
Assert.Equal(1, reader.Take());
Assert.Equal(-1, reader.Peek());
Assert.Equal(-1, reader.Take());
}
}
public async Task TakeTraversesSegments()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
var w = readerWriter.Alloc();
w.Append(ReadableBuffer.Create(new byte[] { 1 }, 0, 1));
w.Append(ReadableBuffer.Create(new byte[] { 2 }, 0, 1));
w.Append(ReadableBuffer.Create(new byte[] { 3 }, 0, 1));
await w.FlushAsync();
var result = await readerWriter.ReadAsync();
var buffer = result.Buffer;
var reader = new ReadableBufferReader(buffer);
Assert.Equal(1, reader.Take());
Assert.Equal(2, reader.Take());
Assert.Equal(3, reader.Take());
Assert.Equal(-1, reader.Take());
}
}
public async Task EqualsDetectsDeltaForAllLocations()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
// populate with dummy data
const int DataSize = 10000;
byte[] data = new byte[DataSize];
var rand = new Random(12345);
rand.NextBytes(data);
var writeBuffer = readerWriter.Alloc();
writeBuffer.Write(data);
await writeBuffer.FlushAsync();
// now read it back
var result = await readerWriter.ReadAsync();
var readBuffer = result.Buffer;
Assert.False(readBuffer.IsSingleSpan);
Assert.Equal(data.Length, readBuffer.Length);
// check the entire buffer
EqualsDetectsDeltaForAllLocations(readBuffer, data, 0, data.Length);
// check the first 32 sub-lengths
for (int i = 0; i <= 32; i++)
{
var slice = readBuffer.Slice(0, i);
EqualsDetectsDeltaForAllLocations(slice, data, 0, i);
}
// check the last 32 sub-lengths
for (int i = 0; i <= 32; i++)
{
var slice = readBuffer.Slice(data.Length - i, i);
EqualsDetectsDeltaForAllLocations(slice, data, data.Length - i, i);
}
}
}
public async Task ReaderShouldNotGetUnflushedBytes()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
// Write 10 and flush
var buffer = readerWriter.Alloc();
buffer.WriteLittleEndian(10);
await buffer.FlushAsync();
// Write 9
buffer = readerWriter.Alloc();
buffer.WriteLittleEndian(9);
// Write 8
buffer.WriteLittleEndian(8);
// Make sure we don't see it yet
var result = await readerWriter.ReadAsync();
var reader = result.Buffer;
Assert.Equal(4, reader.Length);
Assert.Equal(10, reader.ReadLittleEndian<int>());
// Don't move
readerWriter.Advance(reader.Start);
// Now flush
await buffer.FlushAsync();
reader = (await readerWriter.ReadAsync()).Buffer;
Assert.Equal(12, reader.Length);
Assert.Equal(10, reader.ReadLittleEndian<int>());
Assert.Equal(9, reader.Slice(4).ReadLittleEndian<int>());
Assert.Equal(8, reader.Slice(8).ReadLittleEndian<int>());
}
}
public static IPipelineReader GZipCompress(this IPipelineReader reader, PipelineFactory factory, CompressionLevel compressionLevel)
{
var deflater = new WritableDeflateTransform(compressionLevel, ZLibNative.GZip_DefaultWindowBits);
return factory.CreateReader(reader, deflater.Execute);
}
public static IPipelineReader GZipDecompress(this IPipelineReader reader, PipelineFactory factory)
{
var inflater = new ReadableDeflateTransform(ZLibNative.GZip_DefaultWindowBits);
return factory.CreateReader(reader, inflater.Execute);
}
public void WriteHex(int value, string hex)
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
var buffer = readerWriter.Alloc();
buffer.Append(value, EncodingData.InvariantUtf8, 'x');
Assert.Equal(hex, buffer.AsReadableBuffer().GetAsciiString());
}
}
public async Task ReaderShouldNotGetUnflushedBytesWithAppend()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
// Write 10 and flush
var buffer = readerWriter.Alloc();
buffer.WriteLittleEndian(10);
await buffer.FlushAsync();
// Write Hello to another pipeline and get the buffer
var bytes = Encoding.ASCII.GetBytes("Hello");
var c2 = factory.Create();
await c2.WriteAsync(bytes);
var result = await c2.ReadAsync();
var c2Buffer = result.Buffer;
Assert.Equal(bytes.Length, c2Buffer.Length);
// Write 9 to the buffer
buffer = readerWriter.Alloc();
buffer.WriteLittleEndian(9);
// Append the data from the other pipeline
buffer.Append(c2Buffer);
// Mark it as consumed
c2.Advance(c2Buffer.End);
// Now read and make sure we only see the comitted data
result = await readerWriter.ReadAsync();
var reader = result.Buffer;
Assert.Equal(4, reader.Length);
Assert.Equal(10, reader.ReadLittleEndian<int>());
// Consume nothing
readerWriter.Advance(reader.Start);
// Flush the second set of writes
await buffer.FlushAsync();
reader = (await readerWriter.ReadAsync()).Buffer;
// int, int, "Hello"
Assert.Equal(13, reader.Length);
Assert.Equal(10, reader.ReadLittleEndian<int>());
Assert.Equal(9, reader.Slice(4).ReadLittleEndian<int>());
Assert.Equal("Hello", reader.Slice(8).GetUtf8String());
}
}
public async Task CopyToAsyncNativeMemory()
{
using (var pool = new NativePool())
using (var factory = new PipelineFactory(pool))
{
var readerWriter = factory.Create();
var output = readerWriter.Alloc();
output.Append("Hello World", TextEncoding.Utf8);
await output.FlushAsync();
var ms = new MemoryStream();
var result = await readerWriter.ReadAsync();
var rb = result.Buffer;
await rb.CopyToAsync(ms);
ms.Position = 0;
Assert.Equal(11, rb.Length);
Assert.Equal(11, ms.Length);
Assert.Equal(rb.ToArray(), ms.ToArray());
Assert.Equal("Hello World", Encoding.ASCII.GetString(ms.ToArray()));
}
}
/// <summary>
/// Creates a new SocketListener instance
/// </summary>
/// <param name="factory">Optionally allows the underlying <see cref="PipelineFactory"/> (and hence memory pool) to be specified; if one is not provided, a <see cref="PipelineFactory"/> will be instantiated and owned by the listener</param>
public SocketListener(PipelineFactory factory = null)
{
_ownsFactory = factory == null;
_factory = factory ?? new PipelineFactory();
}
public async Task WriteAndCancellingPendingReadBeforeReadAsync()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
var bytes = Encoding.ASCII.GetBytes("Hello World");
var output = readerWriter.Alloc();
output.Write(bytes);
await output.FlushAsync();
readerWriter.CancelPendingRead();
var result = await readerWriter.ReadAsync();
var buffer = result.Buffer;
Assert.False(result.IsCompleted);
Assert.True(result.IsCancelled);
Assert.False(buffer.IsEmpty);
Assert.Equal(11, buffer.Length);
Assert.True(buffer.IsSingleSpan);
var array = new byte[11];
buffer.First.Span.CopyTo(array);
Assert.Equal("Hello World", Encoding.ASCII.GetString(array));
readerWriter.CompleteWriter();
readerWriter.CompleteReader();
}
}
public void ReadingStartedCompletesOnCallToReadAsync()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
readerWriter.ReadAsync();
Assert.True(readerWriter.ReadingStarted.IsCompleted);
}
}
public void AllocMoreThanPoolBlockSizeThrows()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
Assert.Throws<ArgumentOutOfRangeException>(() => readerWriter.Alloc(8192));
}
}
public async Task SlowPathIndexOfAcrossBlocks()
{
const int blockSize = 4032;
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
// block 1 -> block2
// [padding..hello] -> [ world ]
var paddingBytes = Enumerable.Repeat((byte)'a', blockSize - 5).ToArray();
var bytes = Encoding.ASCII.GetBytes("Hello World");
var writeBuffer = readerWriter.Alloc();
writeBuffer.Write(paddingBytes);
writeBuffer.Write(bytes);
await writeBuffer.FlushAsync();
var result = await readerWriter.ReadAsync();
var buffer = result.Buffer;
ReadableBuffer slice;
ReadCursor cursor;
Assert.False(buffer.IsSingleSpan);
Assert.True(buffer.TrySliceTo((byte)' ', out slice, out cursor));
slice = buffer.Slice(cursor).Slice(1);
var array = slice.ToArray();
Assert.Equal("World", Encoding.ASCII.GetString(array));
}
}
public async Task WritingDataMakesDataReadableViaPipeline()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
var bytes = Encoding.ASCII.GetBytes("Hello World");
await readerWriter.WriteAsync(bytes);
var result = await readerWriter.ReadAsync();
var buffer = result.Buffer;
Assert.Equal(11, buffer.Length);
Assert.True(buffer.IsSingleSpan);
var array = new byte[11];
buffer.First.Span.CopyTo(array);
Assert.Equal("Hello World", Encoding.ASCII.GetString(array));
}
}
public async Task AdvanceEmptyBufferAfterWritingResetsAwaitable()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
var bytes = Encoding.ASCII.GetBytes("Hello World");
await readerWriter.WriteAsync(bytes);
var result = await readerWriter.ReadAsync();
var buffer = result.Buffer;
Assert.Equal(11, buffer.Length);
Assert.True(buffer.IsSingleSpan);
var array = new byte[11];
buffer.First.Span.CopyTo(array);
Assert.Equal("Hello World", Encoding.ASCII.GetString(array));
readerWriter.Advance(buffer.End);
// Now write 0 and advance 0
await readerWriter.WriteAsync(Span<byte>.Empty);
result = await readerWriter.ReadAsync();
readerWriter.Advance(result.Buffer.End);
var awaitable = readerWriter.ReadAsync();
Assert.False(awaitable.IsCompleted);
}
}
public async Task HelloWorldAcrossTwoBlocks()
{
const int blockSize = 4032;
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
// block 1 -> block2
// [padding..hello] -> [ world ]
var paddingBytes = Enumerable.Repeat((byte)'a', blockSize - 5).ToArray();
var bytes = Encoding.ASCII.GetBytes("Hello World");
var writeBuffer = readerWriter.Alloc();
writeBuffer.Write(paddingBytes);
writeBuffer.Write(bytes);
await writeBuffer.FlushAsync();
var result = await readerWriter.ReadAsync();
var buffer = result.Buffer;
Assert.False(buffer.IsSingleSpan);
var helloBuffer = buffer.Slice(blockSize - 5);
Assert.False(helloBuffer.IsSingleSpan);
var memory = new List<Memory<byte>>();
foreach (var m in helloBuffer)
{
memory.Add(m);
}
var spans = memory;
Assert.Equal(2, memory.Count);
var helloBytes = new byte[spans[0].Length];
spans[0].Span.CopyTo(helloBytes);
var worldBytes = new byte[spans[1].Length];
spans[1].Span.CopyTo(worldBytes);
Assert.Equal("Hello", Encoding.ASCII.GetString(helloBytes));
Assert.Equal(" World", Encoding.ASCII.GetString(worldBytes));
}
}
public async Task ReadingCanBeCancelled()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
var cts = new CancellationTokenSource();
cts.Token.Register(() =>
{
readerWriter.CompleteWriter(new OperationCanceledException(cts.Token));
});
var ignore = Task.Run(async () =>
{
await Task.Delay(1000);
cts.Cancel();
});
await Assert.ThrowsAsync<OperationCanceledException>(async () =>
{
var result = await readerWriter.ReadAsync();
var buffer = result.Buffer;
});
}
}
public void ReadableBufferSequenceWorks()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
var output = readerWriter.Alloc();
{
// empty buffer
var readable = output.AsReadableBuffer() as ISequence<ReadOnlyMemory<byte>>;
var position = Position.First;
ReadOnlyMemory<byte> memory;
int spanCount = 0;
while (readable.TryGet(ref position, out memory, advance: true))
{
spanCount++;
Assert.Equal(0, memory.Length);
}
Assert.Equal(1, spanCount);
}
{ // 3 segment buffer
output.Write(new byte[] { 1 });
output.Ensure(4032);
output.Write(new byte[] { 2, 2 });
output.Ensure(4031);
output.Write(new byte[] { 3, 3, 3 });
var readable = output.AsReadableBuffer() as ISequence<ReadOnlyMemory<byte>>;
var position = Position.First;
ReadOnlyMemory<byte> memory;
int spanCount = 0;
while (readable.TryGet(ref position, out memory, advance: true))
{
spanCount++;
Assert.Equal(spanCount, memory.Length);
}
Assert.Equal(3, spanCount);
}
}
}
public async Task IndexOfNotFoundReturnsEnd()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
var bytes = Encoding.ASCII.GetBytes("Hello World");
await readerWriter.WriteAsync(bytes);
var result = await readerWriter.ReadAsync();
var buffer = result.Buffer;
ReadableBuffer slice;
ReadCursor cursor;
Assert.False(buffer.TrySliceTo(10, out slice, out cursor));
}
}
/// <summary>
/// Releases all resources owned by the connection
/// </summary>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
_output.CompleteWriter();
_output.CompleteReader();
_input.CompleteWriter();
_input.CompleteReader();
GC.SuppressFinalize(this);
_socket?.Dispose();
_socket = null;
if (_ownsFactory) { _factory?.Dispose(); }
_factory = null;
}
}
public async Task AdvanceShouldResetStateIfReadCancelled()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
readerWriter.CancelPendingRead();
var result = await readerWriter.ReadAsync();
var buffer = result.Buffer;
readerWriter.Advance(buffer.End);
Assert.False(result.IsCompleted);
Assert.True(result.IsCancelled);
Assert.True(buffer.IsEmpty);
var awaitable = readerWriter.ReadAsync();
Assert.False(awaitable.IsCompleted);
}
}
public async Task FastPathIndexOfAcrossBlocks()
{
var vecUpperR = new Vector<byte>((byte)'R');
const int blockSize = 4032;
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
// block 1 -> block2
// [padding..hello] -> [ world ]
var paddingBytes = Enumerable.Repeat((byte)'a', blockSize - 5).ToArray();
var bytes = Encoding.ASCII.GetBytes("Hello World");
var writeBuffer = readerWriter.Alloc();
writeBuffer.Write(paddingBytes);
writeBuffer.Write(bytes);
await writeBuffer.FlushAsync();
var result = await readerWriter.ReadAsync();
var buffer = result.Buffer;
ReadableBuffer slice;
ReadCursor cursor;
Assert.False(buffer.TrySliceTo((byte)'R', out slice, out cursor));
}
}
public async Task CancellingPendingAfterReadAsync()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
var bytes = Encoding.ASCII.GetBytes("Hello World");
var output = readerWriter.Alloc();
output.Write(bytes);
var task = Task.Run(async () =>
{
var result = await readerWriter.ReadAsync();
var buffer = result.Buffer;
readerWriter.Advance(buffer.End);
Assert.False(result.IsCompleted);
Assert.True(result.IsCancelled);
Assert.True(buffer.IsEmpty);
await output.FlushAsync();
result = await readerWriter.ReadAsync();
buffer = result.Buffer;
Assert.Equal(11, buffer.Length);
Assert.True(buffer.IsSingleSpan);
Assert.False(result.IsCancelled);
var array = new byte[11];
buffer.First.Span.CopyTo(array);
Assert.Equal("Hello World", Encoding.ASCII.GetString(array));
readerWriter.CompleteReader();
});
// Wait until reading starts to cancel the pending read
await readerWriter.ReadingStarted;
readerWriter.CancelPendingRead();
await task;
readerWriter.CompleteWriter();
}
}
/// <summary>
/// Begins an asynchronous connect operation to the designated endpoint
/// </summary>
/// <param name="endPoint">The endpoint to which to connect</param>
/// <param name="factory">Optionally allows the underlying <see cref="PipelineFactory"/> (and hence memory pool) to be specified; if one is not provided, a <see cref="PipelineFactory"/> will be instantiated and owned by the connection</param>
public static Task<SocketConnection> ConnectAsync(IPEndPoint endPoint, PipelineFactory factory = null)
{
var args = new SocketAsyncEventArgs();
args.RemoteEndPoint = endPoint;
args.Completed += _asyncCompleted;
var tcs = new TaskCompletionSource<SocketConnection>(factory);
args.UserToken = tcs;
if (!Socket.ConnectAsync(SocketType.Stream, ProtocolType.Tcp, args))
{
OnConnect(args); // completed sync - usually means failure
}
return tcs.Task;
}
