public Task <Response <T> > GetResponse <T>(object values, CancellationToken cancellationToken, RequestTimeout timeout) where T : class { var message = TypeMetadataCache <TRequest> .InitializeFromObject(values); return(GetResponse <T>(message, cancellationToken, timeout)); }
/// <summary> /// Send the request, and complete the response task when the response is received. If /// the request times out, a RequestTimeoutException is thrown. If the remote service /// returns a fault, the task is set to exception status. /// </summary> /// <param name="client">The request client</param> /// <param name="values">The values to initialize the request object, anonymously</param> /// <param name="cancellationToken">A cancellation token for the request</param> /// <returns>The response Task</returns> public static Task <TResponse> Request <TRequest, TResponse>(this IRequestClient <TRequest, TResponse> client, object values, CancellationToken cancellationToken = default(CancellationToken)) { TRequest request = TypeMetadataCache <TRequest> .InitializeFromObject(values); return(client.Request(request, cancellationToken)); }
/// <summary> /// Using a filter-supplied context type, block so that the one time code is only executed once regardless of how many /// threads are pushing through the pipe at the same time. /// </summary> /// <typeparam name="T">The payload type, should be an interface</typeparam> /// <param name="context">The pipe context</param> /// <param name="setupMethod">The setup method, called once regardless of the thread count</param> /// <param name="payloadFactory">The factory method for the payload context, optional if an interface is specified</param> /// <returns></returns> public static async Task OneTimeSetup <T>(this PipeContext context, Func <T, Task> setupMethod, PayloadFactory <T> payloadFactory = null) where T : class { OneTime <T> newContext = null; var existingContext = context.GetOrAddPayload <OneTimeSetupContext <T> >(() => { var payload = payloadFactory?.Invoke() ?? TypeMetadataCache <T> .InitializeFromObject(new {}); newContext = new OneTime <T>(payload); return(newContext); }); if (newContext == existingContext) { try { await setupMethod(newContext.Payload).ConfigureAwait(false); newContext.SetReady(); } catch (Exception exception) { newContext.SetFaulted(exception); throw; } } else { await existingContext.Ready.ConfigureAwait(false); } }
async Task IPublishEndpoint.Publish <T>(object values, IPipe <PublishContext> publishPipe, CancellationToken cancellationToken) { if (values == null) { throw new ArgumentNullException(nameof(values)); } var message = TypeMetadataCache <T> .InitializeFromObject(values); var adapter = new PublishPipeContextAdapter <T>(publishPipe, _publishPipe, _publishObserver, _sourceAddress, _correlationId, _conversationId, message); try { var sendEndpoint = await _endpointProvider.GetPublishSendEndpoint(typeof(T)).ConfigureAwait(false); await sendEndpoint.Send(message, adapter, cancellationToken).ConfigureAwait(false); await adapter.PostPublish().ConfigureAwait(false); } catch (Exception ex) { await adapter.PublishFaulted(ex).ConfigureAwait(false); throw; } }
public async Task Should_allow_reconfiguration_of_prefetch_count() { IRequestClient <SetPrefetchCount, PrefetchCountUpdated> client = new PublishRequestClient <SetPrefetchCount, PrefetchCountUpdated>(Bus, TestTimeout); for (int i = 0; i < 500; i++) { await Bus.Publish(new A()); await Task.Delay(50); } SetPrefetchCount request = TypeMetadataCache <SetPrefetchCount> .InitializeFromObject(new { PrefetchCount = (ushort)32, Timestamp = DateTime.UtcNow, QueueName = "input_queue", }); await client.Request(request, TestCancellationToken); for (int i = 0; i < 500; i++) { await Bus.Publish(new A()); await Task.Delay(50); } Assert.IsTrue(_consumer.Received.Select <A>().Any()); }
/// <summary> /// Send a request from the bus to the endpoint, and return a Task which can be awaited for the response. /// </summary> /// <param name="bus">A started bus instance</param> /// <param name="destinationAddress">The service address</param> /// <param name="values">The values used to initialize the request message</param> /// <param name="cancellationToken">An optional cancellationToken for this request</param> /// <param name="timeout">An optional timeout for the request (defaults to 30 seconds)</param> /// <param name="callback">A callback, which can modify the <see cref="SendContext"/> of the request</param> /// <typeparam name="TRequest">The request type</typeparam> /// <typeparam name="TResponse">The response type</typeparam> /// <returns></returns> public static Task <Response <TResponse> > Request <TRequest, TResponse>(this IBus bus, Uri destinationAddress, object values, CancellationToken cancellationToken = default, RequestTimeout timeout = default, Action <SendContext <TRequest> > callback = null) where TRequest : class where TResponse : class { var message = TypeMetadataCache <TRequest> .InitializeFromObject(values); return(Request <TRequest, TResponse>(bus, destinationAddress, message, cancellationToken, timeout, callback)); }
public async Task <Accept <T> > Ask <T>(Guid clientId, int count) where T : class { var entry = await _index.Get(clientId, CreateClientInfo).ConfigureAwait(false); entry.Add(count); return(TypeMetadataCache <Accept <T> > .InitializeFromObject(new { Endpoint = (EndpointInfo)_settings, Count = count, })); }
public void Byte_interface_array() { var msg = TypeMetadataCache <ByteArrayMessage> .InitializeFromObject(new { Contents = new byte[] { 0x56, 0x34, 0xf3 } }); var result = SerializeAndReturn(msg); result.Contents.SequenceEqual(msg.Contents).ShouldBeTrue(); }
ITransform <TMessage, TMessage> Build() { var builder = new MessageTransformBuilder <TMessage, TMessage>(() => TypeMetadataCache <TMessage> .InitializeFromObject(new object())); for (int i = 0; i < _specifications.Count; i++) { _specifications[i].Configure(builder); } return(builder.Build()); }
public Task RespondAsync <T>(object values, IPipe <SendContext> sendPipe) where T : class { if (values == null) { throw new ArgumentNullException(nameof(values)); } var message = TypeMetadataCache <T> .InitializeFromObject(values); return(RespondAsync(message, sendPipe)); }
public Task Send <T>(object values, IPipe <SendContext <T> > pipe, CancellationToken cancellationToken) where T : class { if (values == null) { throw new ArgumentNullException(nameof(values)); } T message = TypeMetadataCache <T> .InitializeFromObject(values); return(Send(message, pipe, cancellationToken)); }
public virtual Task RespondAsync <T>(object values) where T : class { if (values == null) { throw new ArgumentNullException(nameof(values)); } var message = TypeMetadataCache <T> .InitializeFromObject(values); return(RespondAsync(message)); }
public async Task Should_allow_reconfiguration() { IRequestClient <SetConcurrencyLimit, ConcurrencyLimitUpdated> client = new PublishRequestClient <SetConcurrencyLimit, ConcurrencyLimitUpdated>(Bus, TestTimeout); SetConcurrencyLimit request = TypeMetadataCache <SetConcurrencyLimit> .InitializeFromObject(new { ConcurrencyLimit = 16, Timestamp = DateTime.UtcNow }); await client.Request(request, TestCancellationToken); }
Task IPublishEndpoint.Publish <T>(object values, CancellationToken cancellationToken) { if (values == null) { throw new ArgumentNullException(nameof(values)); } var message = TypeMetadataCache <T> .InitializeFromObject(values); var adapter = new PublishPipeContextAdapter <T>(_publishPipe, _publishObserver, _sourceAddress, _correlationId, _conversationId, message); return(Publish(cancellationToken, message, adapter)); }
public async Task Should_be_faster_than_json() { var now = DateTime.UtcNow; var inputObject = new { StringValue = "Hello", IntValue = 27, DateTimeValue = now, NullableValue = 42, NotNullableValue = (int?)69, NullableDecimalValue = 123.45m, Numbers = new[] { 12, 24, 36 }, Names = new[] { "Curly", "Larry", "Moe" }, Exception = new IntentionalTestException("It Happens"), SubValue = new { Text = "Mary" }, SubValues = new object[] { new { Text = "Frank" }, new { Text = "Lola" }, }, Amount = 867.53m, // AsyncValue = GetIntResult().Select(x => x.Number), EngineStatus = Status.Started, NumberStatus = 12, StringStatus = "Started", // Strings = new Dictionary<string, string> {{"Hello", "World"}, {"Thank You", "Next"}} }; var context = await MessageInitializerCache <SuperComplexRequest> .Initialize(inputObject); var timer = Stopwatch.StartNew(); for (int i = 0; i < 100000; i++) { context = await MessageInitializerCache <SuperComplexRequest> .Initialize(inputObject); } timer.Stop(); var message = TypeMetadataCache <SuperComplexRequest> .InitializeFromObject(inputObject); var jsonTimer = Stopwatch.StartNew(); for (int i = 0; i < 100000; i++) { message = TypeMetadataCache <SuperComplexRequest> .InitializeFromObject(inputObject); } jsonTimer.Stop(); Console.WriteLine("Initializer: {0}", timer.ElapsedMilliseconds); Console.WriteLine("JsonMessage: {0}", jsonTimer.ElapsedMilliseconds); }
/// <summary> /// Send a message /// </summary> /// <typeparam name="T">The message type</typeparam> /// <param name="provider"></param> /// <param name="values"></param> /// <param name="cancellationToken"></param> /// <returns>The task which is completed once the Send is acknowledged by the broker</returns> public static async Task Send <T>(this ISendEndpointProvider provider, object values, CancellationToken cancellationToken = default) where T : class { var message = TypeMetadataCache <T> .InitializeFromObject(values); if (!EndpointConvention.TryGetDestinationAddress <T>(out var destinationAddress)) { throw new ArgumentException($"A convention for the message type {TypeMetadataCache<T>.ShortName} was not found"); } var endpoint = await provider.GetSendEndpoint(destinationAddress).ConfigureAwait(false); await endpoint.Send(message, cancellationToken).ConfigureAwait(false); }
Task <ScheduledMessage <T> > IMessageScheduler.ScheduleSend <T>(Uri destinationAddress, DateTime scheduledTime, object values, CancellationToken cancellationToken) { if (destinationAddress == null) { throw new ArgumentNullException(nameof(destinationAddress)); } if (values == null) { throw new ArgumentNullException(nameof(values)); } var message = TypeMetadataCache <T> .InitializeFromObject(values); return(ScheduleSend(destinationAddress, scheduledTime, message, Pipe.Empty <SendContext <T> >(), cancellationToken)); }
/// <summary> /// Sends an interface message, initializing the properties of the interface using the anonymous /// object specified /// </summary> /// <typeparam name="T">The interface type to send</typeparam> /// <param name="context">The consume context</param> /// <param name="scheduledTime">The time at which the message should be delivered to the queue</param> /// <param name="values">The property values to initialize on the interface</param> /// <param name="pipe"></param> /// <param name="cancellationToken"></param> /// <returns>The task which is completed once the Send is acknowledged by the broker</returns> public static Task <ScheduledMessage <T> > SchedulePublish <T>(this ConsumeContext context, DateTime scheduledTime, object values, IPipe <SendContext> pipe, CancellationToken cancellationToken = default(CancellationToken)) where T : class { if (values == null) { throw new ArgumentNullException(nameof(values)); } var pipeProxy = new ServiceBusScheduleMessagePipe <T>(scheduledTime, pipe); var message = TypeMetadataCache <T> .InitializeFromObject(values); return(Schedule(context, scheduledTime, message, pipeProxy, cancellationToken)); }
public void Should_property_initialize_the_values() { var values = new { CorrelationId = Guid.NewGuid(), Name = "Dru", Timestamp = DateTime.UtcNow, }; IMessageType message = TypeMetadataCache <IMessageType> .InitializeFromObject(values); message.CorrelationId.ShouldBe(values.CorrelationId); message.Name.ShouldBe(values.Name); message.Timestamp.ShouldBe(values.Timestamp); }
Task <ScheduledRecurringMessage <T> > IRecurringMessageScheduler.ScheduleRecurringSend <T>(Uri destinationAddress, RecurringSchedule schedule, object values, CancellationToken cancellationToken) { if (destinationAddress == null) { throw new ArgumentNullException(nameof(destinationAddress)); } if (values == null) { throw new ArgumentNullException(nameof(values)); } var message = TypeMetadataCache <T> .InitializeFromObject(values); return(ScheduleRecurringSend(destinationAddress, schedule, message, cancellationToken)); }
/// <summary> /// Sends an interface message, initializing the properties of the interface using the anonymous /// object specified /// </summary> /// <typeparam name="T">The interface type to send</typeparam> /// <param name="context">The consume context</param> /// <param name="scheduledTime">The time at which the message should be delivered to the queue</param> /// <param name="values">The property values to initialize on the interface</param> /// <param name="pipe"></param> /// <param name="cancellationToken"></param> /// <returns>The task which is completed once the Send is acknowledged by the broker</returns> public static Task <ScheduledMessage <T> > SchedulePublish <T>(this ConsumeContext context, DateTime scheduledTime, object values, IPipe <SendContext> pipe, CancellationToken cancellationToken = default(CancellationToken)) where T : class { if (values == null) { throw new ArgumentNullException(nameof(values)); } var message = TypeMetadataCache <T> .InitializeFromObject(values); var destinationAddress = GetDestinationAddress <T>(context); var scheduler = context.GetPayload <MessageSchedulerContext>(); return(scheduler.ScheduleSend(destinationAddress, scheduledTime, message, pipe, cancellationToken)); }
Task <ScheduledMessage <T> > IMessageScheduler.ScheduleSend <T>(Uri destinationAddress, DateTime scheduledTime, object values, CancellationToken cancellationToken = default(CancellationToken)) { if (destinationAddress == null) { throw new ArgumentNullException(nameof(destinationAddress)); } if (values == null) { throw new ArgumentNullException(nameof(values)); } var message = TypeMetadataCache <T> .InitializeFromObject(values); var pipeProxy = new ServiceBusScheduleMessagePipe <T>(scheduledTime); return(ScheduleSend(destinationAddress, scheduledTime, message, pipeProxy, cancellationToken)); }
public async Task Should_be_faster_than_json() { var inputObject = new { StringValue = _stringValue, BoolValue = _boolValue, ByteValue = _byteValue, ShortValue = _shortValue, IntValue = _intValue, LongValue = _longValue, DoubleValue = _doubleValue, DecimalValue = _decimalValue, DateTimeValue = _dateTimeValue, DateTimeOffsetValue = _dateTimeOffsetValue, TimeSpanValue = _timeSpanValue, DayValue = _dayValue, ObjectValue = _objectValue, }; var context = await MessageInitializerCache <TestInitializerMessage> .Initialize(inputObject); var timer = Stopwatch.StartNew(); for (int i = 0; i < 100000; i++) { context = await MessageInitializerCache <TestInitializerMessage> .Initialize(inputObject); } timer.Stop(); var message = TypeMetadataCache <TestInitializerMessage> .InitializeFromObject(inputObject); var jsonTimer = Stopwatch.StartNew(); for (int i = 0; i < 100000; i++) { message = TypeMetadataCache <TestInitializerMessage> .InitializeFromObject(inputObject); } jsonTimer.Stop(); Console.WriteLine("Initializer: {0}", timer.ElapsedMilliseconds); Console.WriteLine("JsonMessage: {0}", jsonTimer.ElapsedMilliseconds); }
public async Task <ExecutionResult> Execute(ExecuteContext <CardPaymentArguments> context) { var paymentDue = context.Arguments.PaymentDue; if (paymentDue == null) { throw new ArgumentNullException(nameof(PaymentDue)); } string transactionId = "123456"; return(context.CompletedWithVariables <CardPaymentLog>(new { TransactionId = transactionId, paymentDue.Amount }, new { PaymentReceipt = TypeMetadataCache <PaymentReceipt> .InitializeFromObject(new { Source = "Credit Card", paymentDue.Amount, }) })); }
public async Task <ExecutionResult> Execute(ExecuteContext <PingArguments> context) { return(context.Completed(TypeMetadataCache <PingLog> .InitializeFromObject(new { context.Arguments.CorrelationId }))); }
public RequestHandle <TRequest> Create(object values, CancellationToken cancellationToken = default, RequestTimeout timeout = default) { var message = TypeMetadataCache <TRequest> .InitializeFromObject(values); return(Create(message, cancellationToken, timeout)); }