Esempio n. 1
0
 public async Task Send(Message message)
 {
     try
     {
         await _retryPolicy.Retry(() => _topicClient.SendAsync(message)).ConfigureAwait(false);
     }
     catch (InvalidOperationException exception) when(exception.Message.Contains("been consumed"))
     {
         // this is okay, it means we timed out and upon retry the message was accepted
     }
 }
        Task IRoutingSlipEventPersister.Persist <T>(Guid trackingNumber, T @event)
        {
            FilterDefinition <RoutingSlipDocument> filterDefinition = Builders <RoutingSlipDocument> .Filter.Eq(x => x.TrackingNumber, trackingNumber);

            UpdateDefinition <RoutingSlipDocument> update = Builders <RoutingSlipDocument> .Update.AddToSet(x => x.Events, @event);

            return(_retryPolicy.Retry(async() =>
            {
                var result = await _collection.UpdateOneAsync(filterDefinition, update, new UpdateOptions {
                    IsUpsert = true
                }).ConfigureAwait(false);

                if (!result.IsAcknowledged)
                {
                    throw new SaveEventException(trackingNumber, "Write was not acknowledged");
                }

                if (result.UpsertedId == null)
                {
                    if (result.IsModifiedCountAvailable && result.ModifiedCount != 1)
                    {
                        throw new SaveEventException(trackingNumber, $"Multiple documents were modified: {result.ModifiedCount}");
                    }
                }
            }));
        }
Esempio n. 3
0
        async Task <ConnectionContext> CreateConnection(ISupervisor supervisor)
        {
            return(await _connectionRetryPolicy.Retry(async() =>
            {
                if (supervisor.Stopping.IsCancellationRequested)
                {
                    throw new OperationCanceledException($"The connection is stopping and cannot be used: {_configuration.HostAddress}");
                }

                IConnection connection = null;
                try
                {
                    TransportLogMessages.ConnectHost(_configuration.Settings.ToString());

                    connection = _configuration.Settings.CreateConnection();

                    return new AmazonSqsConnectionContext(connection, _configuration, _hostTopology, supervisor.Stopped);
                }
                catch (OperationCanceledException)
                {
                    throw;
                }
                catch (Exception ex)
                {
                    throw new AmazonSqsConnectException("Connect failed: " + _configuration.Settings, ex);
                }
            }, supervisor.Stopping).ConfigureAwait(false));
        }
Esempio n. 4
0
            async Task Run()
            {
                while (!IsStopping)
                {
                    await _retryPolicy.Retry(async() =>
                    {
                        try
                        {
                            _supervisor = _supervisorFactory();

                            await _context.OnTransportStartup(_supervisor, Stopping).ConfigureAwait(false);

                            if (IsStopping)
                            {
                                return;
                            }

                            await _supervisor.Send(_transportPipe, Stopped).ConfigureAwait(false);
                        }
                        catch (ConnectionException exception)
                        {
                            await NotifyFaulted(exception).ConfigureAwait(false);
                            throw;
                        }
                        catch (OperationCanceledException exception)
                        {
                            throw await NotifyFaulted(exception, "ReceiveTransport canceled: ").ConfigureAwait(false);
                        }
                        catch (Exception exception)
                        {
                            throw await NotifyFaulted(exception, "ReceiveTransport faulted: ").ConfigureAwait(false);
                        }
                    }, Stopping).ConfigureAwait(false);
                }
            }
        private static void AttempRetryOnException(String logPrefix, Request request, VolleyError exception)
        {
            IRetryPolicy retryPolicy = request.GetRetryPolicy();
            int          oldTimeout  = request.GetTimeoutMs();

            try
            {
                retryPolicy.Retry(exception);
            }
            catch (VolleyError e)
            {
                request.AddMarker(String.Format("{0}-timeout-giveup[timeout={1}]", logPrefix, oldTimeout));
                throw e;
            }
            request.AddMarker(String.Format("{0}-retry [timeout-{1}]", logPrefix, oldTimeout));
        }
Esempio n. 6
0
        async Task <ConnectionContext> CreateConnection(ISupervisor supervisor)
        {
            return(await _connectionRetryPolicy.Retry(async() =>
            {
                if (supervisor.Stopping.IsCancellationRequested)
                {
                    throw new OperationCanceledException($"The connection is stopping and cannot be used: {_configuration.Description}");
                }

                IConnection connection = null;
                try
                {
                    TransportLogMessages.ConnectHost(_configuration.Description);

                    connection = _configuration.Settings.CreateConnection();

                    connection.Start();

                    LogContext.Debug?.Log("Connected: {Host} (client-id: {ClientId}, version: {Version})", _configuration.Description,
                                          connection.ClientId, connection.MetaData.NMSVersion);

                    return new ActiveMqConnectionContext(connection, _configuration, _hostTopology, supervisor.Stopped);
                }
                catch (OperationCanceledException)
                {
                    connection?.Dispose();
                    throw;
                }
                catch (NMSConnectionException ex)
                {
                    connection?.Dispose();
                    throw new ActiveMqConnectException("Connection exception: " + _configuration.Description, ex);
                }
                catch (Exception ex)
                {
                    connection?.Dispose();
                    throw new ActiveMqConnectException("Create Connection Faulted: " + _configuration.Description, ex);
                }
            }, supervisor.Stopping).ConfigureAwait(false));
        }
Esempio n. 7
0
        async Task <ConnectionContext> CreateConnection(IAsyncPipeContextAgent <ConnectionContext> asyncContext, IAgent supervisor)
        {
            return(await _connectionRetryPolicy.Retry(async() =>
            {
                if (supervisor.Stopping.IsCancellationRequested)
                {
                    throw new OperationCanceledException($"The connection is stopping and cannot be used: {_configuration.HostAddress}");
                }


                IConnection connection = null;
                try
                {
                    TransportLogMessages.ConnectHost(_configuration.Settings.ToString());

                    connection = _configuration.Settings.CreateConnection();

                    var connectionContext = new AmazonSqsConnectionContext(connection, _configuration, _hostTopology, supervisor.Stopped);

                    await asyncContext.Created(connectionContext).ConfigureAwait(false);

                    return connectionContext;
                }
                catch (OperationCanceledException)
                {
                    await asyncContext.CreateCanceled().ConfigureAwait(false);
                    throw;
                }
                catch (Exception ex)
                {
                    LogContext.Error?.Log(ex, "Amazon SQS connection failed");

                    await asyncContext.CreateFaulted(ex).ConfigureAwait(false);

                    throw new AmazonSqsConnectException("Connect failed: " + _configuration.Settings, ex);
                }
            }));
        }
Esempio n. 8
0
 public Task Send(BrokeredMessage message)
 {
     return(_retryPolicy.Retry(() => _queueClient.SendAsync(message)));
 }
Esempio n. 9
0
 IEnumerator IEnumerable.GetEnumerator()
 {
     return(_retryPolicy.Retry(() => _queryable.GetEnumerator()));
 }
Esempio n. 10
0
 public static void Retry(this IRetryPolicy retryPolicy, Action action)
 {
     retryPolicy.Retry <object>(() => { action(); return(null); });
 }
Esempio n. 11
0
 public static void SubmitChangesRetry(this DataContext dataContext, ConflictMode failureMode, IRetryPolicy retryPolicy)
 {
     retryPolicy.Retry(() => dataContext.SubmitChanges(failureMode));
 }
Esempio n. 12
0
 public static void ExecuteCommandRetry(this DataContext dataContext, IRetryPolicy retryPolicy, string command, params object[] parameters)
 {
     retryPolicy.Retry(() => dataContext.ExecuteCommand(command, parameters));
 }
Esempio n. 13
0
 public static void SubmitChangesRetry(this DataContext dataContext, IRetryPolicy retryPolicy)
 {
     retryPolicy.Retry(() => dataContext.SubmitChanges());
 }
        async Task <ConnectionContext> CreateConnection(ISupervisor supervisor)
        {
            return(await _connectionRetryPolicy.Retry(async() =>
            {
                if (supervisor.Stopping.IsCancellationRequested)
                {
                    throw new OperationCanceledException($"The connection is stopping and cannot be used: {_description}");
                }

                IConnection connection = null;
                try
                {
                    TransportLogMessages.ConnectHost(_description);

                    if (_configuration.Settings.EndpointResolver != null)
                    {
                        connection = _connectionFactory.Value.CreateConnection(_configuration.Settings.EndpointResolver,
                                                                               _configuration.Settings.ClientProvidedName);
                    }
                    else
                    {
                        var hostNames = new List <string>(1)
                        {
                            _configuration.Settings.Host
                        };

                        connection = _connectionFactory.Value.CreateConnection(hostNames, _configuration.Settings.ClientProvidedName);
                    }

                    LogContext.Debug?.Log("Connected: {Host} (address: {RemoteAddress}, local: {LocalAddress})", _description, connection.Endpoint,
                                          connection.LocalPort);

                    var connectionContext = new RabbitMqConnectionContext(connection, _configuration, _hostTopology, _description, supervisor.Stopped);

                    connectionContext.GetOrAddPayload(() => _configuration.Settings);

                    return (ConnectionContext)connectionContext;
                }
                catch (ConnectFailureException ex)
                {
                    connection?.Dispose();

                    throw new RabbitMqConnectionException("Connect failed: " + _description, ex);
                }
                catch (BrokerUnreachableException ex)
                {
                    connection?.Dispose();

                    throw new RabbitMqConnectionException("Broker unreachable: " + _description, ex);
                }
                catch (OperationInterruptedException ex)
                {
                    connection?.Dispose();

                    throw new RabbitMqConnectionException("Operation interrupted: " + _description, ex);
                }
                catch (OperationCanceledException)
                {
                    throw;
                }
                catch (Exception ex)
                {
                    connection?.Dispose();

                    throw new RabbitMqConnectionException("Create Connection Faulted: " + _description, ex);
                }
            }, supervisor.Stopping).ConfigureAwait(false));
        }
        // The Execute method executes queries that return a single value (instead of an enumerable sequence of values).
        // Expression trees that represent queries that return enumerable results are executed when their associated IQueryable object is enumerated.
        // From http://msdn.microsoft.com/en-us/library/bb535032(v=vs.100).aspx

        public object Execute(Expression expression)
        {
            return(_retryPolicy.Retry(() => _queryProvider.Execute(expression)));
        }