// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
string serviceBusHost = Configuration.GetSection("MessageBroker").GetValue <string>("ServiceBusHost");
services.AddMassTransit(x =>
{
x.SetKebabCaseEndpointNameFormatter();
x.UsingAzureServiceBus((context, config) =>
{
config.Host(serviceBusHost);
config.ConfigureEndpoints(context);
});
x.AddRequestClient <IGetDeliveriesEvent>(RequestTimeout.After(0, 1, 0, 0, 0));
});
services.AddControllers();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "FoodPal.Delivery.API", Version = "v1"
});
});
}
public override int GetHashCode()
{
int hash = 1;
if (ApiType != global::Envoy.Api.V2.Core.ApiConfigSource.Types.ApiType.UnsupportedRestLegacy)
{
hash ^= ApiType.GetHashCode();
}
hash ^= clusterNames_.GetHashCode();
hash ^= grpcServices_.GetHashCode();
if (refreshDelay_ != null)
{
hash ^= RefreshDelay.GetHashCode();
}
if (requestTimeout_ != null)
{
hash ^= RequestTimeout.GetHashCode();
}
if (rateLimitSettings_ != null)
{
hash ^= RateLimitSettings.GetHashCode();
}
if (SetNodeOnFirstMessageOnly != false)
{
hash ^= SetNodeOnFirstMessageOnly.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public Task <Response <T1, T2> > GetResponse <T1, T2>(TRequest message, CancellationToken cancellationToken,
RequestTimeout timeout)
where T1 : class
where T2 : class
{
return(GetResponse <T1, T2>(message, null, cancellationToken, timeout));
}
public RequestHandle <T> CreateRequest <T>(ConsumeContext consumeContext, Uri destinationAddress, object values,
CancellationToken cancellationToken = default,
RequestTimeout timeout = default)
where T : class
{
return(_clientFactory.CreateRequest <T>(consumeContext, destinationAddress, values, cancellationToken, timeout));
}
public async Task Should_complete()
{
var orderId = NewId.NextGuid();
var orderLineId = NewId.NextGuid();
var startedAt = DateTime.UtcNow;
var scope = Provider.CreateScope();
var client = scope.ServiceProvider.GetRequiredService <IRequestClient <OrderCombo> >();
Response <ComboCompleted> response = await client.GetResponse <ComboCompleted>(new
{
OrderId = orderId,
OrderLineId = orderLineId,
Number = 5
}, timeout : RequestTimeout.After(s: 5));
Assert.That(response.Message.OrderId, Is.EqualTo(orderId));
Assert.That(response.Message.OrderLineId, Is.EqualTo(orderLineId));
Assert.That(response.Message.Created, Is.GreaterThan(startedAt));
Assert.That(response.Message.Completed, Is.GreaterThan(response.Message.Created));
Assert.That(response.Message.Description, Contains.Substring("Fries"));
Assert.That(response.Message.Description, Contains.Substring("Shake"));
}
protected override TSettings Configure <TSettings>(TSettings listenerSettings)
{
base.Configure(listenerSettings);
listenerSettings.ConcurrentAccepts = 10;
listenerSettings.RequestTimeout = RequestTimeout.Subtract(TimeSpan.FromSeconds(1));
return(listenerSettings);
}
public IRequestClient <T> CreateRequestClient <T>(Uri destinationAddress, RequestTimeout timeout)
where T : class
{
IRequestSendEndpoint <T> requestSendEndpoint = _context.GetRequestEndpoint <T>(destinationAddress);
return(new RequestClient <T>(_context, requestSendEndpoint, timeout.Or(_context.DefaultTimeout)));
}
public IRequestClient <T> CreateRequestClient <T>(RequestTimeout timeout)
where T : class
{
IRequestSendEndpoint <T> requestSendEndpoint = _serviceClient.CreateRequestSendEndpoint <T>();
return(new RequestClient <T>(_context, requestSendEndpoint, timeout.Or(_context.DefaultTimeout)));
}
public async Task Should_accept_that_faults_happen()
{
var client = Bus.CreateRequestClient <CreateShortLink>(RequestTimeout.After(s: 30));
Assert.That(async() =>
await client.GetResponse <ShortLinkCreated>(new { Link = new Uri("http://www.google.com") }), Throws.TypeOf <RequestFaultException>());
}
public IRequestClient <T> CreateRequestClient <T>(Uri destinationAddress, RequestTimeout timeout)
where T : class
{
var requestSendEndpoint = new SendRequestSendEndpoint(_context, destinationAddress);
return(new RequestClient <T>(_context, requestSendEndpoint, timeout));
}
public override int GetHashCode()
{
int hash = 1;
if (Cluster.Length != 0)
{
hash ^= Cluster.GetHashCode();
}
if (attachmentTemplate_ != null)
{
hash ^= AttachmentTemplate.GetHashCode();
}
if (requestTimeout_ != null)
{
hash ^= RequestTimeout.GetHashCode();
}
if (attachmentTimeout_ != null)
{
hash ^= AttachmentTimeout.GetHashCode();
}
if (attachmentPollPeriod_ != null)
{
hash ^= AttachmentPollPeriod.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public ResponseFuture(IPipe pipe, RequestTimeout timeoutInfo, CancellationToken cancellation)
{
_pipe = pipe ?? throw new ArgumentNullException(nameof(pipe));
_cancellation = cancellation;
_responseReadTimeout = new Timeouter(timeoutInfo.AsReadTimeout ? _pipe.ReadTimeout : timeoutInfo.Timeout);
_waitTimeout = new Timeouter(_pipe.ReadTimeout);
}
/// <summary>
/// Returns true if ComAdobeXmpWorkerFilesNcommXMPFilesNCommProperties instances are equal
/// </summary>
/// <param name="other">Instance of ComAdobeXmpWorkerFilesNcommXMPFilesNCommProperties to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(ComAdobeXmpWorkerFilesNcommXMPFilesNCommProperties other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
MaxConnections == other.MaxConnections ||
MaxConnections != null &&
MaxConnections.Equals(other.MaxConnections)
) &&
(
MaxRequests == other.MaxRequests ||
MaxRequests != null &&
MaxRequests.Equals(other.MaxRequests)
) &&
(
RequestTimeout == other.RequestTimeout ||
RequestTimeout != null &&
RequestTimeout.Equals(other.RequestTimeout)
) &&
(
LogDir == other.LogDir ||
LogDir != null &&
LogDir.Equals(other.LogDir)
));
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (MaxConnections != null)
{
hashCode = hashCode * 59 + MaxConnections.GetHashCode();
}
if (MaxRequests != null)
{
hashCode = hashCode * 59 + MaxRequests.GetHashCode();
}
if (RequestTimeout != null)
{
hashCode = hashCode * 59 + RequestTimeout.GetHashCode();
}
if (LogDir != null)
{
hashCode = hashCode * 59 + LogDir.GetHashCode();
}
return(hashCode);
}
}
static void Main()
{
var bus = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
cfg.Host("rabbitmq://localhost", hostConfigurator =>
{
hostConfigurator.Username("admin");
hostConfigurator.Password("admin");
});
cfg.OverrideDefaultBusEndpointQueueName("OrderRegistration-PublisherExchange");
});
bus.Start();
var orderRegisteredMessage = new OrderRegistered
{
OrderId = 1,
OrderDate = DateTime.Now,
CustomerNumber = DateTime.Now.Millisecond.ToString(),
};
var requestClient = bus.CreateRequestClient <OrderRegistered>(RequestTimeout.After(s: 5));
var response = requestClient.GetResponse <OrderAccepted, OrderRejected>(orderRegisteredMessage).Result;
//DO Some thing with response.
Console.ReadKey();
bus.Stop();
}
public Task <Response <T1, T2> > GetResponse <T1, T2>(object values, CancellationToken cancellationToken = default,
RequestTimeout timeout = default)
where T1 : class
where T2 : class
{
return(GetResponse <T1, T2>(values, null, cancellationToken, timeout));
}
public Task Handle(RequestTimeout <TMessage> sideEffect, CancellationToken cancellationToken = default)
{
var dueDate = _currentTimeProvider().Add(sideEffect.TimeSpan);
_timeoutsManager.NewTimeoutRegistered(dueDate);
return(_timeoutsRepository.Add(new TimeoutRecord(sideEffect.InstanceId, dueDate, sideEffect.Message, typeof(TMessage))));
}
public override bool Equals(object obj)
{
if (ReferenceEquals(null, obj))
{
return(false);
}
if (ReferenceEquals(this, obj))
{
return(true);
}
if (obj.GetType() != GetType())
{
return(false);
}
var other = (ServiceDiscoveryConfig)obj;
return(Scope == other.Scope &&
RequestTimeout.Equals(other.RequestTimeout) &&
FirstAttemptDelaySeconds.Equals(other.FirstAttemptDelaySeconds) &&
MaxAttemptDelaySeconds.Equals(other.MaxAttemptDelaySeconds) &&
DelayMultiplier.Equals(other.DelayMultiplier) &&
Source == other.Source &&
string.Equals(Hosts, other.Hosts) &&
DefaultPort == other.DefaultPort &&
DefaultSlotNumber == other.DefaultSlotNumber &&
UseHttpsOverride == other.UseHttpsOverride &&
string.Equals(SecurityRole, other.SecurityRole) &&
Equals(CachingPolicy, other.CachingPolicy) &&
SuppressHealthCheckAfterServiceUnused.Equals(other.SuppressHealthCheckAfterServiceUnused));
}
public ClientRequestHandle(ClientFactoryContext context, IRequestSendEndpoint requestSendEndpoint, TRequest message,
CancellationToken cancellationToken = default, RequestTimeout timeout = default, Guid?requestId = default, TaskScheduler taskScheduler = default)
{
_context = context;
_message = message;
_requestSendEndpoint = requestSendEndpoint;
_cancellationToken = cancellationToken;
var requestTimeout = timeout.HasValue ? timeout : _context.DefaultTimeout.HasValue ? _context.DefaultTimeout.Value : RequestTimeout.Default;
_timeToLive = requestTimeout;
_requestId = requestId ?? NewId.NextGuid();
_taskScheduler = taskScheduler ??
(SynchronizationContext.Current == null
? TaskScheduler.Default
: TaskScheduler.FromCurrentSynchronizationContext());
_pipeConfigurator = new PipeConfigurator <SendContext <TRequest> >();
_sendContext = new TaskCompletionSource <SendContext <TRequest> >();
_readyToSend = new TaskCompletionSource <bool>();
_responseHandlers = new Dictionary <Type, HandlerConnectHandle>();
_timeoutTimer = new Timer(TimeoutExpired, this, (long)requestTimeout.Value.TotalMilliseconds, -1L);
if (cancellationToken != default && cancellationToken.CanBeCanceled)
{
_registration = cancellationToken.Register(Cancel);
}
_send = SendRequest();
HandleFault();
}
public async Task Should_complete_the_request()
{
var client = Bus.CreateRequestClient <CreateShortLink>(RequestTimeout.After(s: 30));
var response = await client.GetResponse <ShortLinkCreated>(new { Link = new Uri("http://www.microsoft.com") });
Console.WriteLine("Link: {0}, Short Link: {1}", response.Message.Link, response.Message.ShortLink);
}
public async Task Setup()
{
_clientFactory = await Host.CreateClientFactory(RequestTimeout.After(s: 8));
_requestClient = await Host.CreateRequestClient <PingMessage>(InputQueueAddress, RequestTimeout.After(s: 8));
_response = _requestClient.GetResponse <PongMessage>(new PingMessage());
}
public async Task Should_throw_a_timeout_exception()
{
var client = Bus.CreateRequestClient <GetValue>(InputQueueAddress, RequestTimeout.After(s: 1));
Assert.That(async() => await client.GetResponse <Value>(new GetValue {
Discard = true
}), Throws.TypeOf <RequestTimeoutException>());
}
async Task <Response <T> > GetResponseInternal <T>(ClientRequestHandle <TRequest> .SendRequestCallback request, CancellationToken cancellationToken,
RequestTimeout timeout)
where T : class
{
using RequestHandle <TRequest> handle = new ClientRequestHandle <TRequest>(_context, request, cancellationToken, timeout.Or(_timeout));
return(await handle.GetResponse <T>().ConfigureAwait(false));
}
public RequestHandle <T> CreateRequest <T>(ConsumeContext consumeContext, Uri destinationAddress, object values, CancellationToken cancellationToken,
RequestTimeout timeout)
where T : class
{
IRequestClient <T> client = CreateRequestClient <T>(consumeContext, destinationAddress, timeout);
return(client.Create(values, cancellationToken));
}
/// <summary>
/// Builds the complete arguments for invoking newman
/// </summary>
/// <param name="args">The argument builder.</param>
public void Build(ProcessArgumentBuilder args)
{
if (EnvironmentFile != null)
{
args.AppendSwitchQuoted(ArgumentNames.Environment, EnvironmentFile.FullPath);
}
if (GlobalVariablesFile != null)
{
args.AppendSwitchQuoted(ArgumentNames.Globals, GlobalVariablesFile.FullPath);
}
if (!string.IsNullOrWhiteSpace(Folder))
{
args.AppendSwitchQuoted(ArgumentNames.Folder, Folder);
}
if (ExportEnvironmentPath != null)
{
args.AppendSwitchQuoted(ArgumentNames.ExportEnvironment, ExportEnvironmentPath.FullPath);
}
if (ExportGlobalsPath != null)
{
args.AppendSwitchQuoted(ArgumentNames.ExportGlobals, ExportGlobalsPath.FullPath);
}
if (ExportCollectionPath != null)
{
args.AppendSwitchQuoted(ArgumentNames.ExportCollection, ExportCollectionPath.FullPath);
}
if (RequestTimeout != default(int))
{
args.AppendSwitch(ArgumentNames.RequestTimeout, RequestTimeout.ToString());
}
if (DisableStrictSSL)
{
args.Append(ArgumentNames.Insecure);
}
if (IgnoreRedirects)
{
args.Append(ArgumentNames.IgnoreRedirects);
}
if (RequestDelay != default(int))
{
args.AppendSwitch(ArgumentNames.RequestDelay, RequestDelay.ToString());
}
if (ExitOnFirstFailure)
{
args.Append(ArgumentNames.Bail);
}
if (Reporters.Any())
{
args.AppendSwitch(ArgumentNames.Reporters,
string.Join(",", Reporters.Keys.Select(k => k.Trim())));
foreach (var reporter in Reporters)
{
reporter.Value?.RenderOptions(args);
}
}
}
public IRequestClient <T> CreateRequestClient <T>(RequestTimeout timeout)
where T : class
{
if (EndpointConvention.TryGetDestinationAddress <T>(out var destinationAddress))
{
return(CreateRequestClient <T>(destinationAddress, timeout));
}
return(new RequestClient <T>(_context, new PublishRequestSendEndpoint(_context.PublishEndpoint), timeout));
}
public IRequestClient <T> CreateRequestClient <T>(RequestTimeout timeout)
where T : class
{
if (EndpointConvention.TryGetDestinationAddress <T>(out var destinationAddress))
{
return(CreateRequestClient <T>(destinationAddress, timeout));
}
return(new RequestClient <T>(_context, _context.GetRequestEndpoint <T>(), timeout.Or(_context.DefaultTimeout)));
}
static IRequestClient <T> CreateRequestClient <T>(Uri destinationAddress, RequestTimeout timeout, IContext context)
where T : class
{
var clientFactory = context.GetInstance <IClientFactory>();
var consumeContext = context.TryGetInstance <ConsumeContext>();
return(consumeContext != null
? clientFactory.CreateRequestClient <T>(consumeContext, destinationAddress, timeout)
: clientFactory.CreateRequestClient <T>(destinationAddress, timeout));
}
void IContainerRegistrar.RegisterRequestClient <T>(Uri destinationAddress, RequestTimeout timeout)
{
_collection.AddScoped(context =>
{
var clientFactory = context.GetRequiredService <IClientFactory>();
var consumeContext = context.GetRequiredService <ScopedConsumeContextProvider>().GetContext();
return(consumeContext != null
? clientFactory.CreateRequestClient <T>(consumeContext, destinationAddress, timeout)
: clientFactory.CreateRequestClient <T>(destinationAddress, timeout));
});
}
public void RegisterRequestClient <T>(Uri destinationAddress, RequestTimeout timeout = default)
where T : class
{
_builder.Register(context =>
{
var clientFactory = context.Resolve <IClientFactory>();
return(context.TryResolve(out ConsumeContext consumeContext)
? clientFactory.CreateRequestClient <T>(consumeContext, destinationAddress, timeout)
: clientFactory.CreateRequestClient <T>(destinationAddress, timeout));
});
}
