[Ignore] // REVIEW public void TestSqlAzureTransientErrorDetectionStrategyWithRetryableError() { int[] errors = new int[] { 40197, 40501, 40540, 10053, 10054, 10060, 40549, 40550, 40551, 40552, 40553, 40613, 40143, 233, 64 }; Type type = typeof(SqlDatabaseTransientErrorDetectionStrategy).GetNestedType("ProcessNetLibErrorCode", BindingFlags.NonPublic); errors = errors.AddRange((int[])Enum.GetValues(type)); Exception[] exceptions = FakeSqlExceptionGenerator.GenerateFakeSqlExceptions(errors); exceptions = exceptions.AddRange(new TimeoutException(), new EntityException("Forced Exception")); RetryPolicy defaultPolicy = new RetryPolicy<SqlDatabaseTransientErrorDetectionStrategy>(exceptions.Length - 1, RetryStrategy.DefaultRetryInterval); int execCount = 0; try { defaultPolicy.ExecuteAction(() => { Exception ex = exceptions[execCount]; execCount++; throw ex; }); } catch (EntityException ex) { Assert.AreEqual("Forced Exception", ex.Message); } Assert.AreEqual<int>(exceptions.Length, execCount, "The action was not executed the expected amount of times"); }
/// <summary> /// Executes a query against the database and returns a DataTable /// </summary> /// <param name="commandText"></param> /// <param name="cmdType"></param> /// <param name="parms"></param> public DataTable ExcecuteDataTable(string commandText, CommandType cmdType, List <SqlParameter> parms) { DataTable returnValue = new DataTable(); if (retryPolicy == null) { SetupRetryManager(); } retryPolicy.ExecuteAction(() => { OpenConnectionIfClosedOrNonExistent(); using (var cmd = new SqlCommand(commandText, TransactionScope.Connection.Current, TransactionScope.Transaction)) { cmd.CommandTimeout = _commandTimeout; cmd.CommandType = cmdType; SetupParameters(cmd, ref parms); using (var adapter = new SqlDataAdapter(cmd)) { adapter.Fill(returnValue); } CurrentCommand = cmd; } //Close connection if not in transaction scope CloseConnectionNoTransaction(); }); return(returnValue); }
// GET api/nextsession public Session Get() { var retryStrategy = new Incremental(5, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)); var retryPolicy = new RetryPolicy <SqlAzureTransientErrorDetectionStrategy>(retryStrategy); Session nextSession = new Session(); using (VidPackEntities db = new VidPackEntities()) { retryPolicy.ExecuteAction(() => { db.Database.Connection.Open(); }); ExistingSession dbSession = retryPolicy.ExecuteAction <ExistingSession>(() => db.ExistingSession.Where(item => item.IsNextSession == 1).FirstOrDefault() ); if (dbSession != null) { nextSession = new VidPackModel.Session() { SessionDate = dbSession.SessionDate.ToString(), SessionDescription = dbSession.SessionDescription, SessionSubTitle = dbSession.SessionSubTitle, SessionThumbnailUrl = String.Format("{0}{1}", ThumbnailStorageUrl, dbSession.SessionThumbnailUri), SessionTitle = dbSession.SessionSubTitle, SessionVideoUrl = dbSession.SessionVideoUri == null ? "" : dbSession.SessionVideoUri, Speaker = dbSession.Speaker } } ; } return(nextSession); }
private void HandleBadDataCacheBug(Action action) { var retryStrategy = new Incremental(5, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)); var retryPolicy = new RetryPolicy <CacheRetryPolicy>(retryStrategy); try { retryPolicy.ExecuteAction(action); } catch (DataCacheException ex) { if (ex.ErrorCode == DataCacheErrorCode.ConnectionTerminated || ex.ErrorCode == DataCacheErrorCode.Timeout || ex.ErrorCode == DataCacheErrorCode.RetryLater) { ErrorLogUtils.AddError( new Exception( "DataCache connection was lost. Trying to reinitialize DataCache through DataCacheFactory and retrying last operation.", ex)); InitDataCache(); retryPolicy.ExecuteAction(action); } else { throw; } } }
public void Initialize() { var retryStrategy = new Incremental(3, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)); var retryPolicy = new RetryPolicy <ServiceBusTransientErrorDetectionStrategy>(retryStrategy); var tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey); var serviceUri = ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath); var namespaceManager = new NamespaceManager(serviceUri, tokenProvider); this.settings.Topics.AsParallel().ForAll(topic => { retryPolicy.ExecuteAction(() => CreateTopicIfNotExists(namespaceManager, topic)); topic.Subscriptions.AsParallel().ForAll(subscription => { retryPolicy.ExecuteAction(() => CreateSubscriptionIfNotExists(namespaceManager, topic, subscription)); retryPolicy.ExecuteAction(() => UpdateRules(namespaceManager, topic, subscription)); }); }); // Execute migration support actions only after all the previous ones have been completed. foreach (var topic in this.settings.Topics) { foreach (var action in topic.MigrationSupport) { retryPolicy.ExecuteAction(() => UpdateSubscriptionIfExists(namespaceManager, topic, action)); } } this.initialized = true; }
public void Initialize() { var retryStrategy = new Incremental(3, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)); var retryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(retryStrategy); var tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey); var serviceUri = ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath); var namespaceManager = new NamespaceManager(serviceUri, tokenProvider); this.settings.Topics.AsParallel().ForAll(topic => { retryPolicy.ExecuteAction(() => CreateTopicIfNotExists(namespaceManager, topic)); topic.Subscriptions.AsParallel().ForAll(subscription => { retryPolicy.ExecuteAction(() => CreateSubscriptionIfNotExists(namespaceManager, topic, subscription)); retryPolicy.ExecuteAction(() => UpdateRules(namespaceManager, topic, subscription)); }); }); // Execute migration support actions only after all the previous ones have been completed. foreach (var topic in this.settings.Topics) { foreach (var action in topic.MigrationSupport) { retryPolicy.ExecuteAction(() => UpdateSubscriptionIfExists(namespaceManager, topic, action)); } } this.initialized = true; }
public void Initialize() { var retryStrategy = new Incremental(3, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)); var retryPolicy = new RetryPolicy <ServiceBusTransientErrorDetectionStrategy>(retryStrategy); var namespaceManager = NamespaceManager.CreateFromConnectionString(settings.ConnectionString); this.settings.Topics.AsParallel().ForAll(topic => { retryPolicy.ExecuteAction(() => CreateTopicIfNotExists(namespaceManager, topic)); topic.Subscriptions.AsParallel().ForAll(subscription => { retryPolicy.ExecuteAction(() => CreateSubscriptionIfNotExists(namespaceManager, topic, subscription)); retryPolicy.ExecuteAction(() => UpdateRules(namespaceManager, this.settings.ConnectionString, topic, subscription)); }); }); // Execute migration support actions only after all the previous ones have been completed. foreach (var topic in this.settings.Topics) { foreach (var action in topic.MigrationSupport) { retryPolicy.ExecuteAction(() => UpdateSubscriptionIfExists(namespaceManager, this.settings.ConnectionString, topic, action)); } } this.initialized = true; }
// GET api/nextsession public Session Get() { var retryStrategy = new Incremental(5, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)); var retryPolicy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(retryStrategy); Session nextSession = new Session(); using (VidPackEntities db = new VidPackEntities()) { retryPolicy.ExecuteAction(() => { db.Database.Connection.Open(); }); ExistingSession dbSession = retryPolicy.ExecuteAction<ExistingSession>(() => db.ExistingSession.Where(item => item.IsNextSession == 1).FirstOrDefault() ); if (dbSession != null) nextSession = new VidPackModel.Session() { SessionDate = dbSession.SessionDate.ToString(), SessionDescription = dbSession.SessionDescription, SessionSubTitle = dbSession.SessionSubTitle, SessionThumbnailUrl = String.Format("{0}{1}", ThumbnailStorageUrl, dbSession.SessionThumbnailUri), SessionTitle = dbSession.SessionSubTitle, SessionVideoUrl = dbSession.SessionVideoUri == null ? "" : dbSession.SessionVideoUri, Speaker = dbSession.Speaker }; } return nextSession; }
public void Save(string id, string contentType, byte[] blob) { var client = account.CreateCloudBlobClient(); var containerReference = client.GetContainerReference(rootContainerName); var blobReference = containerReference.GetBlobReference(id); writeRetryPolicy.ExecuteAction(() => { blobReference.UploadByteArray(blob); }); }
protected async Task <T> GetDataAsync <T>() { var response = await RetryPolicy.ExecuteAction(() => { var message = new HttpRequestMessage(HttpMethod.Get, BaseUri); return(ExecuteRequest <T>(message)); }).ConfigureAwait(false); return(response.Data); }
/// <summary> /// Insert a new record containing data from the specified object. The primary key in the specified record must be zero. /// Very similar to Dapper.Contrib.SqlMapperExtensions Insert method except: /// <list type="bullet"> /// <item><description>It manages (obtains, opens, closes and returns) the database connection itself</description></item> /// <item><description>Transient errors are automatically retried</description></item> /// <item><description>Transactions are not supported (in order to support retries)</description></item> /// <item><description>Table / primary key naming conventions are <EntityName>.<EntityName>Id rather than <EntityName>s.Id</description></item> /// </list> /// </summary> /// <typeparam name="T"></typeparam> /// <param name="goc"></param> /// <param name="entity"></param> /// <param name="commandTimeout"></param> /// <returns>The primary key of the </returns> public static long Insert <T>(this IGetOpenConnection goc, T entity, int?commandTimeout = null) where T : class { // TODO: Log that user did this query return(RetryPolicy.ExecuteAction <long>(() => { using (var conn = goc.GetOpenConnection()) { return conn.Insert <T>(entity, null, commandTimeout); } })); }
private void ProcessMessagesForSubscriptionAzure() { logger.Info("ProcessMessagesForSubscription Message Start {0} Declared {1} MessageTytpe {2}, IsReusable {3}", data.EndPointData.SubscriptionName, data.EndPointData.DeclaredType.ToString(), data.EndPointData.MessageType.ToString(), data.EndPointData.IsReusable); retryPolicy.ExecuteAction(() => { try { data.Client.OnMessage(OnMessageHandler, options); } catch (Exception ex) { logger.Error("Error Calling OnMessage {0}", ex.ToString()); } }); }
/// <summary> /// Executes a Transact-SQL statement against the connection and returns the number of rows affected. /// </summary> public int ExecuteNonQuery() { Tracer.TraceEvent(TraceEventType.Verbose, 0, "ReliableSqlCommand => ExecuteNonQuery"); return(RetryPolicy.ExecuteAction(() => { if (Connection.State != ConnectionState.Open) { Connection.Open(); } return _sqlCommandToWrap.ExecuteNonQuery(); })); }
public void OnMessageHandler(IBrokeredMessage msg) { //receive loop begin bool failed = false; if (msg != null) { // Make sure we are not told to stop receiving while we were waiting for a new message. if (!data.CancelToken.IsCancellationRequested) { // Process the received message. logger.Debug("ProcessMessagesForSubscription Start received new message: {0}", data.EndPointData.SubscriptionNameDebug); var receiveState = new AzureReceiveState(data, methodInfo, serializer, msg); failed = OnReceiveProcess(receiveState); logger.Debug("ProcessMessagesForSubscription End received new message: {0}", data.EndPointData.SubscriptionNameDebug); } } if (data.CancelToken.IsCancellationRequested) { //Cancel the message pump. data.SetMessageLoopCompleted(); try { if (!data.Client.IsClosed) { data.Client.Close(); } } catch { } } else if (failed) { if (data.EndPointData.AttributeData.PauseTimeIfErrorWasThrown > 0) { lock (lockObject) { if (DateTime.Now.AddMilliseconds(-data.EndPointData.AttributeData.PauseTimeIfErrorWasThrown) >= lastResetTime) { retryPolicy.ExecuteAction(() => { if (!data.Client.IsClosed) { data.Client.Close(); } }); Thread.Sleep(data.EndPointData.AttributeData.PauseTimeIfErrorWasThrown); lastResetTime = DateTime.Now; retryPolicy.ExecuteAction(() => { Configure(endpoint); data.Client.OnMessage(OnMessageHandler, options); }); } } } else { Thread.Sleep(1000); //This has zero impact if the thread count is > 1 } } }
public void LoadTestAddPointMapping() { try { ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager( Globals.ShardMapManagerConnectionString, ShardMapManagerLoadPolicy.Lazy); ListShardMap <int> lsm = smm.GetListShardMap <int>(ShardMapManagerLoadTests.s_listShardMapName); Assert.IsNotNull(lsm); do { // Chose a random shard to add mapping. Shard s = GetRandomOnlineShardFromShardMap((ShardMap)lsm); if (s == null) { continue; } // Create a random integer key for a new mapping and verify that its not already present in this shard map. int key = _r.Next(MinMappingPoint, MaxMappingPoint); PointMapping <int> pExisting = null; // choose different mapping if this one already exists. if (lsm.TryGetMappingForKey(key, out pExisting)) { continue; } Debug.WriteLine("Trying to add point mapping for key {0} to shard location {1}", key, s.Location); PointMapping <int> p1 = lsm.CreatePointMapping(key, s); Assert.IsNotNull(p1); // Validate mapping by trying to connect s_retryPolicy.ExecuteAction( () => ValidateImpl( (ShardMap)lsm, key)); }while (false); } catch (ShardManagementException sme) { Debug.WriteLine("Exception caught: {0}", sme.Message); } }
protected void EnsureTopic(string topicName, bool enablePartitioning) { Guard.ArgumentNotNull(topicName, "topicName"); bool createNew = false; try { logger.Info("EnsureTopic Try {0} ", topicName); // First, let's see if a topic with the specified name already exists. defaultTopic = verifyRetryPolicy.ExecuteAction <TopicDescription>(() => { return(configurationFactory.NamespaceManager.GetTopic(topicName)); }); createNew = (defaultTopic == null); } catch (MessagingEntityNotFoundException) { logger.Info("EnsureTopic Does Not Exist {0} ", topicName); // Looks like the topic does not exist. We should create a new one. createNew = true; } if (!createNew && defaultTopic != null && !defaultTopic.EnablePartitioning && enablePartitioning) { throw new Exception("EnablePartitioning may not be changed on an existing Topic."); } // If a topic with the specified name doesn't exist, it will be auto-created. if (createNew) { try { logger.Info("EnsureTopic CreateTopic {0} ", topicName); var newTopic = new TopicDescription(topicName) { EnablePartitioning = enablePartitioning }; defaultTopic = retryPolicy.ExecuteAction <TopicDescription>(() => { return(configurationFactory.NamespaceManager.CreateTopic(newTopic)); }); } catch (MessagingEntityAlreadyExistsException) { logger.Info("EnsureTopic GetTopic {0} ", topicName); // A topic under the same name was already created by someone else, perhaps by another instance. Let's just use it. defaultTopic = retryPolicy.ExecuteAction <TopicDescription>(() => { return(configurationFactory.NamespaceManager.GetTopic(topicName)); }); } } }
/// <summary> /// Executes a stored procedure. /// </summary> /// <param name="procedureName">The procedure name.</param> /// <param name="parameters">The set of parameters.</param> /// <param name="outputParameters">The set of output parameters.</param> /// <param name="resultCallback">The result callback.</param> /// <param name="returnValue">The procedure result.</param> public void ExecuteStoredProcedure(string procedureName, ParameterSet parameters, ParameterSet outputParameters, Action <IDatabaseResult> resultCallback, out int returnValue) { ThrowIf.NullOrWhiteSpace(procedureName, "procedureName"); ThrowIf.Null(parameters, "parameters"); int?procedureReturnValue = null; if (this.settings != null) { var settingsParameter = new QueryResultSettingsTableType(this.settings); parameters.Add(QueryResultSettingsTableType.ParameterName, settingsParameter.DataTable); } RetryPolicy retryPolicy = this.DatabaseProvider.GetRetryPolicy(); try { retryPolicy.ExecuteAction( () => this.DatabaseProvider.ExecuteStoredProcedure(this.ConnectionManager.Connection, procedureName, parameters, outputParameters, resultCallback, out procedureReturnValue), (policy, retryCount, ex) => RetailLogger.Log.CrtDataAccessTransientExceptionOccurred(policy.RetryCount, policy.RetryInterval, retryCount, ex)); } catch (DatabaseException ex) { throw new StorageException( StorageErrors.Microsoft_Dynamics_Commerce_Runtime_CriticalStorageError, (int)ex.ErrorCode, ex, "Failed to read from the database. See inner exception for details"); } returnValue = procedureReturnValue.GetValueOrDefault(0); }
/// <summary> /// Sets the specified key and data. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="key">The key.</param> /// <param name="data">The data.</param> /// <param name="returnIfExists">if set to <c>true</c> [return if exists].</param> public T Set <T>(string key, T data, bool returnIfExists) { // Define your retry strategy: retry 3 times, 1 second apart. var retryStrategy = new Incremental(5, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)); // Define your retry policy using the retry strategy and the Windows Azure storage // transient fault detection strategy. var retryPolicy = new RetryPolicy <StorageTransientErrorDetectionStrategy>(retryStrategy); // Do some work that may result in a transient fault. try { // Call a method that uses Windows Azure storage and which may // throw a transient exception. retryPolicy.ExecuteAction( () => { var database = _connectionMultiplexer.GetDatabase(); database.StringSet(key, JsonSerializer.Serialize(data), ConfigurationHelper.SessionPoolTimeOut); }); } catch (Exception ex) { //Logger.Error(ex, $"{GetType().FullName} / {MethodBase.GetCurrentMethod().Name}"); } return(returnIfExists ? Get <T>(key) : data); }
/// <summary> /// Gets the specified key. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="key">The key.</param> /// <returns></returns> public T Get <T>(string key) { var cachedData = default(T); var retryStrategy = new Incremental(5, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)); var retryPolicy = new RetryPolicy <StorageTransientErrorDetectionStrategy>(retryStrategy); // Do some work that may result in a transient fault. try { retryPolicy.ExecuteAction(() => { var database = _connectionMultiplexer.GetDatabase(); var data = database.StringGet(key); if (data.HasValue) { cachedData = JsonSerializer.Deserialize <T>(database.StringGet(key)); } }); } catch (Exception ex) { //Logger.Error(ex, $"{GetType().FullName} / {MethodBase.GetCurrentMethod().Name}"); } return(cachedData); }
[Ignore] // REVIEW public void TestSqlAzureTransientErrorDetectionStrategyWithRetryableError() { int[] errors = { 40197, 40501, 40540, 10053, 10054, 10060, 40549, 40550, 40551, 40552, 40553, 40613, 40143, 233, 64 }; Type type = typeof(SqlDatabaseTransientErrorDetectionStrategy).GetNestedType("ProcessNetLibErrorCode", BindingFlags.NonPublic) !; errors = errors.AddRange((int[])Enum.GetValues(type)); Exception[] exceptions = FakeSqlExceptionGenerator.GenerateFakeSqlExceptions(errors); exceptions = exceptions.AddRange(new TimeoutException(), new EntityException("Forced Exception")); RetryPolicy defaultPolicy = new RetryPolicy <SqlDatabaseTransientErrorDetectionStrategy>(exceptions.Length - 1, RetryStrategy.DefaultRetryInterval); int execCount = 0; try { defaultPolicy.ExecuteAction(() => { Exception ex = exceptions[execCount]; execCount++; throw ex; }); } catch (EntityException ex) { Assert.AreEqual("Forced Exception", ex.Message); } Assert.AreEqual(exceptions.Length, execCount, "The action was not executed the expected amount of times"); }
/// <summary> /// /// </summary> /// <param name="request"></param> /// <returns></returns> private IRestResponse CallApi(IRestRequest request) { Func <IRestResponse> func = () => { RestClient client = new RestClient(_apiHost); var res = client.Execute(request); if (res.StatusCode != HttpStatusCode.OK) { throw new Exception("Fetch Fail"); } return(res); }; IRestResponse response = null; //如果CallApi失败,抛出的异常由外部调用方,即ConfigManager来处理,该部分不与异常处理产生交集 if (_policy != null) { response = _policy.ExecuteAction(func); } else { response = func(); } return(response); }
void Worker_DoWork(object sender, DoWorkEventArgs e) { try { // Build the Queries var rootQuery = DatabaseHelper.BuildInsertQuery(); var batchQuery = DatabaseHelper.BuildBatchQuery(_model.BulkPurchaseQty, rootQuery); // Create the Retry Policy var retryPolicy = new RetryPolicy <ErrorDetectionStrategy>(_backoffStrategy); retryPolicy.ExecuteAction(() => { do { if (_worker.CancellationPending) { e.Cancel = true; break; } // Load the Database & Sleep for x amount of time LoadDatabase(retryPolicy, batchQuery); Sleep(); // Switch Databases _loadingPrimaryDatabase = !_loadingPrimaryDatabase; }while (_totalElapsedSeconds < ConfigHelper.Runtime); }); } catch (Exception ex) { e.Result = ex.Message; } }
protected RetriableTransformBlock(ExecutionDataflowBlockOptions options, RetryPolicy retryPolicy, bool throwOnException = true) { if (retryPolicy == null) { throw new ArgumentNullException("retryPolicy"); } retryPolicy.Retrying += (sender, args) => OnRetry(args); _block = new TransformManyBlock <TInput, TOutput>(input => { try { return(retryPolicy.ExecuteAction(() => new[] { Handle(input) })); } catch { if (throwOnException) { throw; } return(Enumerable.Empty <TOutput>()); } }, options); }
private async Task <string> PostAsync(DataMessage requestMessage) { WebRequest wRequest = WebRequest.Create(baseUri); wRequest.ContentType = "application/json"; wRequest.Method = WebRequestMethods.Http.Post; wRequest.Headers.Add($"Authorization:key={apiKey}"); using (var reqStream = await wRequest.GetRequestStreamAsync()) using (var streamWriter = new StreamWriter(reqStream)) { string json = JSON.SerializeDynamic(requestMessage, Options.IncludeInherited); await streamWriter.WriteAsync(json); } var retryStrategy = new ExponentialBackoff(3, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(20), TimeSpan.FromSeconds(1)); var retryPolicy = new RetryPolicy <WebExceptionDetectionStrategy>(retryStrategy); return(await retryPolicy.ExecuteAction(async() => { using (var httpResponse = await wRequest.GetResponseAsync()) using (var responseStream = httpResponse.GetResponseStream()) using (var streamReader = new StreamReader(responseStream)) { return await streamReader.ReadToEndAsync(); } })); }
public void Execute(int?timeout, IsolationLevel isolationLevel, Action action) { RetryPolicy policy = new RetryPolicy <SqlDatabaseTransientErrorDetectionStrategy>(3, TimeSpan.FromMilliseconds(750)); try { policy.ExecuteAction(() => { var context = _unitOfWork.GetContext(); if (timeout.HasValue) { context.Database.SetCommandTimeout(timeout.Value); } using (IDbContextTransaction transaction = context.Database.BeginTransaction(isolationLevel)) { try { action(); transaction.Commit(); } catch { transaction.Rollback(); throw; } } }); } catch { } }
public Telegram Process(TelegramBodyType type, Telegram telegram) { try { var policy = new RetryPolicy(new TelegramProcessingErrorDetectionStrategy(telegram), new FixedInterval(_retryPolicyCount, TimeSpan.FromSeconds(_retryPolicyTime))); return(policy.ExecuteAction(() => ProcessTelegram(telegram))); } catch (Exception ex) { // if (ex is UnauthorizedAccessException) // throw; if (ex is TimeoutException) { _log.Error(ex); } else { IsConnected = false; _log.Error("Ошибка отправки телеграммы", ex); } throw; } }
/// <summary> /// Uses a reliable connection retry policy and transaction /// scoping to add and submit a set of EntityObjects. /// </summary> /// <typeparam name="T">Must derive from <typeparamref name="EntityObject"/>.</typeparam> /// <param name="context">Any ObjectContext</param> /// <param name="objects">A set of <typeparamref name="EntityObject"/>s to save.</param> public static void AddObjectsAndSave <T>(this ObjectContext context, IEnumerable <T> objects) where T : EntityObject { if (!objects.Any()) { return; } var policy = new RetryPolicy <SqlAzureTransientErrorDetectionStrategy> (10, TimeSpan.FromSeconds(10)); var tso = new TransactionOptions(); tso.IsolationLevel = IsolationLevel.ReadCommitted; var name = context.GetTableName <T>(); foreach (var item in objects) { context.AddObject(name, item); } policy.ExecuteAction(() => { using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required, tso)) { context.SaveChanges(); ts.Complete(); } }); }
/// <summary> /// Returns an opened connection to the caller /// </summary> /// <returns></returns> public static SqlConnection GetSqlConnection() { RetryPolicy rp = new RetryPolicy(new ConnectionExceptionDetectionStrategy(), 3); rp.Retrying += (sender, args) => { // This code runs when a retry is taking place... System.Diagnostics.Debug.WriteLine("Retrying... count=" + args.CurrentRetryCount.ToString()); }; // Open the database connection with retries SqlConnection conn = new SqlConnection(ConnectionString); //conn.OpenWithRetry(rp); rp.ExecuteAction(() => { // The action to perform with retry conn.Open(); }); conn.StatisticsEnabled = EnableStatistics; conn.StateChange += conn_StateChange; return(conn); }
public string GetContainerSasUri(string containerDirectory) { var connectionString = _applicationConfiguration.GetSetting("storage_connection_string"); var retryStrategy = new FixedInterval(3, TimeSpan.FromSeconds(1)); var retryPolicy = new RetryPolicy <StorageTransientErrorDetectionStrategy>(retryStrategy); var sasContainerToken = Empty; try { retryPolicy.ExecuteAction( () => { var storageAccount = CloudStorageAccount.Parse(connectionString); var cloudBlobClient = storageAccount.CreateCloudBlobClient(); var cloudBlobContainer = cloudBlobClient.GetContainerReference(containerDirectory); cloudBlobContainer.CreateIfNotExists(); cloudBlobContainer.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Off }); var adHocPolicy = new SharedAccessBlobPolicy() { SharedAccessExpiryTime = DateTime.UtcNow.AddHours(3), Permissions = SharedAccessBlobPermissions.Read }; sasContainerToken = cloudBlobContainer.GetSharedAccessSignature(adHocPolicy, null); }); } catch (Exception exception) { var e = exception.Message; return(sasContainerToken); } return(sasContainerToken); }
internal static void TestRetryPolicy(RetryPolicy retryPolicy, out int retryCount, out TimeSpan totalDelay) { int callbackCount = 0; double totalDelayInMs = 0; retryPolicy.Retrying += (sender, args) => { callbackCount++; totalDelayInMs += args.Delay.TotalMilliseconds; }; try { retryPolicy.ExecuteAction(() => { throw new TimeoutException("Forced Exception"); }); } catch (TimeoutException ex) { Assert.AreEqual("Forced Exception", ex.Message); } retryCount = callbackCount; totalDelay = TimeSpan.FromMilliseconds(totalDelayInMs); }
public void Sample3_Level300_AutomaticRetry_ManuallyUsingMicrosoftTransientFaultHandling_UsingOperationsProperty() { using (var service = ServiceConsumerFactory.Create <IFakeService>(() => new FakeServiceClient())) { try { int actual = 0; var microsoftRetryStrategy = new Incremental(5, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(2)); var microsoftRetryPolicy = new RetryPolicy <SoapFaultWebServiceTransientErrorDetectionStrategy>(microsoftRetryStrategy); microsoftRetryPolicy.ExecuteAction(() => { actual = service.Operations.AddIntegers(1, 1); }); Console.WriteLine("Actual: " + actual); Assert.AreEqual(2, actual); return; } catch (FaultException fe) { Console.WriteLine("Service operation threw a fault: " + fe.ToString()); } catch (Exception ex) { Console.WriteLine("Technical error occurred while calling the service operation: " + ex.ToString()); } Assert.Fail("Service operation was not successfully called"); } }
private void GetToken() { using (WebClient client = new WebClient()) { client.BaseAddress = this._acsBaseAddress; var oauthRequestValues = new NameValueCollection { { "grant_type", GrantType }, { "client_id", this._clientId }, { "client_secret", this._clientSecret }, { "scope", this._scope }, }; RetryPolicy retryPolicy = new RetryPolicy( new WebRequestTransientErrorDetectionStrategy(), RetryStrategyFactory.DefaultStrategy()); retryPolicy.ExecuteAction( () => { byte[] responseBytes = client.UploadValues("/v2/OAuth2-13", "POST", oauthRequestValues); using (var responseStream = new MemoryStream(responseBytes)) { OAuth2TokenResponse tokenResponse = (OAuth2TokenResponse) new DataContractJsonSerializer(typeof(OAuth2TokenResponse)).ReadObject(responseStream); this.AccessToken = tokenResponse.AccessToken; this._tokenExpiration = DateTime.Now.AddSeconds(tokenResponse.ExpirationInSeconds - ExpirationTimeBufferInSeconds); } }); } }
public bool DeleteFile(string filename, string personFolder, string containerDirectory) { //var targetFilename = Path.Combine(@"C:\Development\MediClinic\BlobStorage", personFolder, filename); //File.Delete(targetFilename); //return true; var destinationBlobName = IsNullOrEmpty(personFolder) ? filename : Format("{0}/{1}", personFolder, filename); var connectionString = _applicationConfiguration.GetSetting("storage_connection_string"); var retryStrategy = new FixedInterval(3, TimeSpan.FromSeconds(1)); var retryPolicy = new RetryPolicy <StorageTransientErrorDetectionStrategy>(retryStrategy); try { retryPolicy.ExecuteAction( () => { var account = CloudStorageAccount.Parse(connectionString); var client = account.CreateCloudBlobClient(); var container = client.GetContainerReference(containerDirectory); var blob = container.GetBlockBlobReference(destinationBlobName); blob.Delete(); return(true); }); } catch (Exception exception) { //We will catch deletes as it just means it doesnt exist var e = exception.Message; //_logger.Error(string.Format("Blob storage exception {0}", e.Message), e); } return(false); }
public void Initialize() { var retryStrategy = new Incremental(3, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)); var retryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(retryStrategy); var tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey); var serviceUri = ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath); var namespaceManager = new NamespaceManager(serviceUri, tokenProvider); foreach (var topic in this.settings.Topics) { retryPolicy.ExecuteAction(() => CreateTopicIfNotExists(namespaceManager, topic)); foreach (var subscription in topic.Subscriptions) { retryPolicy.ExecuteAction(() => CreateSubscriptionIfNotExists(namespaceManager, topic, subscription)); } } this.initialized = true; }
// GET api/notification public IEnumerable<NotificationInfo> Get() { var retryStrategy = new Incremental(5, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)); var retryPolicy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(retryStrategy); List<NotificationInfo> notifications = new List<NotificationInfo>(); using (VidPackEntities db = new VidPackEntities()) { retryPolicy.ExecuteAction(() => { db.Database.Connection.Open(); }); notifications = retryPolicy.ExecuteAction<List<NotificationInfo>>(() => db.Notification.Select(item => new NotificationInfo() { NotificationTag = item.NotificationTag, }).ToList<NotificationInfo>() ); } return notifications; }
public DataSet GetBulkRows() { var ds = new DataSet(TableName); using (var con = new SqlConnection(Connection.ConnectionString)) { using (var cmd = SelectBulkRows) { var policy = new RetryPolicy<SqlTransientErrorDetectionStrategy>(2, TimeSpan.FromSeconds(5)); cmd.Connection = con; con.Open(); var adapter = new SqlDataAdapter(cmd); policy.ExecuteAction(() => adapter.Fill(ds, TableName)); } } return ds; }
protected override void RunDatabaseLoad(DoWorkEventArgs e) { try { // Create the Retry Policy var retryPolicy = new RetryPolicy<ErrorDetectionStrategy>(BackoffStrategy); retryPolicy.ExecuteAction(() => LoadDatabase(retryPolicy, _data)); if (Worker.CancellationPending) { e.Cancel = true; } } catch (Exception ex) { e.Result = ex.Message; } }
public void TestSqlAzureTransientErrorDetectionStrategyWithNonRetryableError() { RetryPolicy defaultPolicy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(1, RetryStrategy.DefaultRetryInterval); int execCount = 0; try { defaultPolicy.ExecuteAction(() => { execCount++; throw new ApplicationException("Forced Exception"); }); } catch (ApplicationException ex) { Assert.AreEqual("Forced Exception", ex.Message); } Assert.AreEqual<int>(1, execCount, "The action was not executed the expected amount of times"); }
public void TestBackoffRetryPolicyWithRetryableError() { RetryPolicy retryPolicy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(RetryStrategy.DefaultClientRetryCount, RetryStrategy.DefaultMinBackoff, RetryStrategy.DefaultMaxBackoff, RetryStrategy.DefaultClientBackoff); int execCount = 0; try { retryPolicy.ExecuteAction(() => { execCount++; throw new TimeoutException("Forced Exception"); }); } catch (TimeoutException ex) { Assert.AreEqual("Forced Exception", ex.Message); } Assert.AreEqual<int>(RetryStrategy.DefaultClientRetryCount, execCount - 1, "The action was not retried using the expected amount of times"); }
[Ignore] // REVIEW - Test will continue throwing the exception so the action will eventually run out of retry attempts public void TestThrottlingConditionSimulation() { // Instantiate a retry policy capable of detecting transient faults that are specific to SQL Database. Use the default retry count. RetryPolicy retryPolicy = new RetryPolicy<SqlDatabaseTransientErrorDetectionStrategy>(RetryStrategy.DefaultClientRetryCount); // Register a custom event handler that will be invoked by the policy whenever a retry condition is encountered. retryPolicy.Retrying += (sender, args) => { // Log a warning message to indicate that a retry loop kicked in. Trace.TraceWarning("Retry condition encountered. Reason: {0} (retry count: {1}, retry delay: {2})", args.LastException.Message, args.CurrentRetryCount, args.Delay); // Make sure we are dealing with a SQL exception. if (args.LastException is SqlException) { // Parse the exception to find out whether it is indicative of any throttling conditions. ThrottlingCondition throttlingCondition = ThrottlingCondition.FromException(args.LastException as SqlException); // Verify whether throttling condition were detected. if (!throttlingCondition.IsUnknown) { // Log a further warning message with details on throttling conditions encountered. Trace.TraceWarning("Throttling condition detected. Details: {0}", throttlingCondition); } } }; // Invoke a database operation or set of database operations against SQL Database. retryPolicy.ExecuteAction(() => { // Open a connection, execute a SQL query or stored procedure, perform any kind of database operations. // ... var sqlEx = FakeSqlExceptionGenerator.GenerateFakeSqlException(ThrottlingCondition.ThrottlingErrorNumber, Resources.SampleThrottlingErrorMsg); throw sqlEx; }); }
private static void RetryPolityUsingCode(IUnityContainer container, IService service, OutputWriterService writer) { writer.WriteLine("Begin sample: RetryPolityUsingCode"); // Define your retry strategy: retry 5 times, starting 1 second apart // and adding 2 seconds to the interval each retry. var retryStrategy = new Incremental(5, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)); // Define your retry policy using the retry strategy and the Windows Azure storage // transient fault detection strategy. var retryPolicy = new RetryPolicy<FileSystemTransientErrorDetectionStrategy>(retryStrategy); try { // Do some work that may result in a transient fault. retryPolicy.ExecuteAction(service.DoSlowAndImportantTask); } catch (Exception exception) { // All the retries failed. writer.WriteLine("An Exception has been thrown:\n{0}", exception); } writer.WriteLine("End sample: RetryPolityUsingCode"); }
internal static void TestRetryPolicy(RetryPolicy retryPolicy, out int retryCount, out TimeSpan totalDelay) { var callbackCount = 0; double totalDelayInMs = 0; retryPolicy.Retrying += (sender, args) => { callbackCount++; totalDelayInMs += args.Delay.TotalMilliseconds; }; try { retryPolicy.ExecuteAction(() => { throw new TimeoutException("Forced Exception"); }); } catch (TimeoutException ex) { Assert.Equal("Forced Exception", ex.Message); } retryCount = callbackCount; totalDelay = TimeSpan.FromMilliseconds(totalDelayInMs); }
public void TestBackoffRetryPolicyWithRetryableError() { const int MaxRetryCount = 4; RetryPolicy retryPolicy = new RetryPolicy<SqlDatabaseTransientErrorDetectionStrategy>(MaxRetryCount, TimeSpan.FromMilliseconds(500), TimeSpan.FromSeconds(1)); int execCount = 0; try { retryPolicy.ExecuteAction(() => { execCount++; throw new TimeoutException("Forced Exception"); }); } catch (TimeoutException ex) { Assert.AreEqual("Forced Exception", ex.Message); } Assert.AreEqual<int>(MaxRetryCount, execCount - 1, "The action was not retried using the expected amount of times"); }
void purchaseWorker_DoWork(object sender, DoWorkEventArgs e) { try { object[] args = e.Argument as object[]; if (args.Length != 8 || Convert.ToInt32(args[3]) <= 0 || Convert.ToInt32(args[4]) <= 0 || Convert.ToInt32(args[5]) <= 0 || Convert.ToInt32(args[6]) <= 0 || Convert.ToInt32(args[7]) <= 0) { e.Result = "Please ensure you have selected a concert, ticket level, and customer, as well as supplied the ticket count and bulk purchase quantity."; return; } string conn = ConstructConn(args[0].ToString(), TenantDbName, args[1].ToString(), args[2].ToString()); string rootQuery = string.Format("Insert Into Tickets (CustomerId, Name, TicketLevelId, ConcertId, PurchaseDate) Values ({0}, '', {1}, {2}, GETDATE())", Convert.ToInt32(args[5]).ToString(), Convert.ToInt32(args[4]).ToString(), Convert.ToInt32(args[3]).ToString()); string runtimeQuery = string.Empty; int bulkPurchase = Convert.ToInt32(args[7]); for (int i = 0; i < bulkPurchase; i++) runtimeQuery += rootQuery + "; "; int ticketCount = Convert.ToInt32(args[6]); int purchaseCounter = 0; var retryPolicy = new RetryPolicy<CustomTransientErrorDetectionStrategy>(exponentialBackoffStrategy); retryPolicy.ExecuteAction(() => { using (ReliableSqlConnection reliableSqlConnection = new ReliableSqlConnection(conn, retryPolicy)) { reliableSqlConnection.Open(retryPolicy); IDbTransaction transaction = reliableSqlConnection.BeginTransaction(); using (var cmd = new SqlCommand(runtimeQuery, reliableSqlConnection.Current, (SqlTransaction)transaction)) { while (purchaseCounter < ticketCount) { if (purchaseWorker.CancellationPending) break; if (ticketCount - purchaseCounter < bulkPurchase) { runtimeQuery = string.Empty; bulkPurchase = ticketCount - purchaseCounter; for (int i = 0; i < bulkPurchase; i++) runtimeQuery += rootQuery; cmd.CommandText = runtimeQuery; } cmd.ExecuteNonQueryWithRetry(retryPolicy); purchaseWorker.ReportProgress(Convert.ToInt32(((purchaseCounter * 1.0) / ticketCount) * 100), purchaseCounter); purchaseCounter = purchaseCounter + bulkPurchase; } transaction.Commit(); } } }); e.Result = purchaseCounter + " tickets purchased"; } catch (Exception ex) { e.Result = ex.Message; } }
private Uri GetAccountApiEndpoint(OAuthDataServiceAdapter dataServiceAdapter, ServiceVersionAdapter versionAdapter, Uri apiServer) { RetryPolicy retryPolicy = new RetryPolicy( GetWebRequestTransientErrorDetectionStrategy(), RetryStrategyFactory.DefaultStrategy()); Uri apiEndpoint = null; retryPolicy.ExecuteAction( () => { HttpWebRequest request = (HttpWebRequest) WebRequest.Create(apiServer); request.AllowAutoRedirect = false; dataServiceAdapter.AddAccessTokenToRequest(request); versionAdapter.AddVersionToRequest(request); using (WebResponse response = request.GetResponse()) { apiEndpoint = GetAccountApiEndpointFromResponse(response); } } ); return apiEndpoint; }
private void GetToken() { using (WebClient client = new WebClient()) { client.BaseAddress = this._acsBaseAddress; var oauthRequestValues = new NameValueCollection { {"grant_type", GrantType}, {"client_id", this._clientId}, {"client_secret", this._clientSecret}, {"scope", this._scope}, }; RetryPolicy retryPolicy = new RetryPolicy( new WebRequestTransientErrorDetectionStrategy(), RetryStrategyFactory.DefaultStrategy()); retryPolicy.ExecuteAction( () => { byte[] responseBytes = client.UploadValues("/v2/OAuth2-13", "POST", oauthRequestValues); using (var responseStream = new MemoryStream(responseBytes)) { OAuth2TokenResponse tokenResponse = (OAuth2TokenResponse)new DataContractJsonSerializer(typeof (OAuth2TokenResponse)).ReadObject(responseStream); this.AccessToken = tokenResponse.AccessToken; this._tokenExpiration = DateTime.Now.AddSeconds(tokenResponse.ExpirationInSeconds - ExpirationTimeBufferInSeconds); } }); } }
public void TestFastFirstRetry() { RetryPolicy retryPolicy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(new FixedInterval("", 1, TimeSpan.FromMinutes(10), true)); Stopwatch stopwatch = Stopwatch.StartNew(); try { retryPolicy.ExecuteAction(() => { SimulateFailure(retryPolicy); }); } catch (TimeoutException ex) { Assert.AreEqual("Forced Exception", ex.Message); } stopwatch.Stop(); Assert.IsFalse(stopwatch.Elapsed.TotalSeconds > 5, "FastFirstRetry does not seem to work correctly"); retryPolicy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(2, TimeSpan.FromSeconds(1)); stopwatch.Start(); try { retryPolicy.ExecuteAction(() => { SimulateFailure(retryPolicy); }); } catch (TimeoutException ex) { Assert.AreEqual("Forced Exception", ex.Message); } stopwatch.Stop(); Assert.IsTrue(stopwatch.Elapsed.TotalSeconds >= 1 && stopwatch.Elapsed.TotalSeconds < 2, "FastFirstRetry does not seem to work correctly"); }
private static void RunLoop() { MessagingFactory factory = MessagingFactory.Create(); SubscriptionClient auditSubscriptionClient = factory.CreateSubscriptionClient("IssueTrackingTopic", "AuditSubscription", ReceiveMode.ReceiveAndDelete); var retryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(RetryStrategy.DefaultClientRetryCount); var waitTimeout = TimeSpan.FromSeconds(10); // Declare an action acting as a callback whenever a message arrives on a queue. AsyncCallback completeReceive = null; // Declare an action acting as a callback whenever a non-transient exception occurs while receiving or processing messages. Action<Exception> recoverReceive = null; // Declare a cancellation token that is used to signal an exit from the receive loop. var cts = new CancellationTokenSource(); // Declare an action implementing the main processing logic for received messages. Action<BrokeredMessage> processMessage = ((msg) => { // Put your custom processing logic here. DO NOT swallow any exceptions. Console.WriteLine(msg.Properties["HorseId"]); }); // Declare an action responsible for the core operations in the message receive loop. Action receiveMessage = (() => { // Use a retry policy to execute the Receive action in an asynchronous and reliable fashion. retryPolicy.ExecuteAction ( (cb) => { // Start receiving a new message asynchronously. auditSubscriptionClient.BeginReceive(waitTimeout, cb, null); }, (ar) => { // Make sure we are not told to stop receiving while we were waiting for a new message. if (!cts.IsCancellationRequested) { // Complete the asynchronous operation. This may throw an exception that will be handled internally by retry policy. BrokeredMessage msg = auditSubscriptionClient.EndReceive(ar); // Check if we actually received any messages. if (msg != null) { // Make sure we are not told to stop receiving while we were waiting for a new message. if (!cts.IsCancellationRequested) { try { // Process the received message. processMessage(msg); // With PeekLock mode, we should mark the processed message as completed. if (auditSubscriptionClient.Mode == ReceiveMode.PeekLock) { // Mark brokered message as completed at which point it's removed from the queue. msg.Complete(); } } catch { // With PeekLock mode, we should mark the failed message as abandoned. if (auditSubscriptionClient.Mode == ReceiveMode.PeekLock) { // Abandons a brokered message. This will cause Service Bus to unlock the message and make it available // to be received again, either by the same consumer or by another completing consumer. msg.Abandon(); } // Re-throw the exception so that we can report it in the fault handler. throw; } finally { // Ensure that any resources allocated by a BrokeredMessage instance are released. msg.Dispose(); } } else { // If we were told to stop processing, the current message needs to be unlocked and return back to the queue. if (auditSubscriptionClient.Mode == ReceiveMode.PeekLock) { msg.Abandon(); } } } } // Invoke a custom callback method to indicate that we have completed an iteration in the message receive loop. completeReceive(ar); }, () => { Console.WriteLine("Success Handler"); }, (ex) => { // Invoke a custom action to indicate that we have encountered an exception and // need further decision as to whether to continue receiving messages. recoverReceive(ex); }); }); // Initialize a custom action acting as a callback whenever a message arrives on a queue. completeReceive = ((ar) => { if (!cts.IsCancellationRequested) { // Continue receiving and processing new messages until we are told to stop. receiveMessage(); } }); // Initialize a custom action acting as a callback whenever a non-transient exception occurs while receiving or processing messages. recoverReceive = ((ex) => { // Just log an exception. Do not allow an unhandled exception to terminate the message receive loop abnormally. Console.WriteLine(ex.Message); if (!cts.IsCancellationRequested) { // Continue receiving and processing new messages until we are told to stop regardless of any exceptions. receiveMessage(); } }); // Start receiving messages asynchronously. receiveMessage(); // Perform any other work. Message will keep arriving asynchronously while we are busy doing something else. // Stop the message receive loop gracefully. cts.Cancel(); }
public EventProcessor CreateEventProcessor(string topic, string subscription, SubscriptionSettings subscriptionSettings, IEventHandler handler, ITextSerializer serializer, bool instrumentationEnabled = false) { var retryStrategy = new Incremental(3, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)); var retryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(retryStrategy); var namespaceManager = settings.GetNamespaceManager(); var topicSettings = new TopicSettings { IsEventBus = true, DuplicateDetectionHistoryTimeWindow = new TimeSpan(0, 30, 0), Path = topic }; retryPolicy.ExecuteAction(() => CreateSubscriptionIfNotExists(namespaceManager, topicSettings, subscriptionSettings)); retryPolicy.ExecuteAction(() => UpdateRules(namespaceManager, topicSettings, subscriptionSettings, settings.GetMessagingFactory())); IMessageReceiver receiver; if (subscriptionSettings.RequiresSession) { var instrumentation = new SessionSubscriptionReceiverInstrumentation(subscription, instrumentationEnabled); try { receiver = (IMessageReceiver)new SessionSubscriptionReceiver(this.settings, topic, subscription, true, instrumentation); } catch { instrumentation.Dispose(); throw; } } else { var instrumentation = new SubscriptionReceiverInstrumentation(subscription, instrumentationEnabled); try { receiver = (IMessageReceiver)new SubscriptionReceiver(this.settings, topic, subscription, true, instrumentation); } catch { instrumentation.Dispose(); throw; } } EventProcessor processor; try { processor = new EventProcessor(receiver, serializer); } catch { using (receiver as IDisposable) { } throw; } try { processor.Register(handler); return processor; } catch { processor.Dispose(); throw; } }
public void RegisterTopicsAndSubscriptions(List<TopicSettings> topics) { var namespaceManager = settings.GetNamespaceManager(); var retryStrategy = new Incremental(3, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)); var retryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(retryStrategy); topics.AsParallel().ForAll(topic => { retryPolicy.ExecuteAction(() => CreateTopicIfNotExists(namespaceManager, topic)); topic.Subscriptions.AsParallel().ForAll(subscription => { retryPolicy.ExecuteAction(() => CreateSubscriptionIfNotExists(namespaceManager, topic, subscription)); retryPolicy.ExecuteAction(() => UpdateRules(namespaceManager, topic, subscription, settings.GetMessagingFactory())); }); }); // Execute migration support actions only after all the previous ones have been completed. foreach (var topic in topics) { foreach (var action in topic.MigrationSupport) { retryPolicy.ExecuteAction(() => UpdateSubscriptionIfExists(namespaceManager, topic, action, settings.GetMessagingFactory())); } } }
private static void SimulateFailure(RetryPolicy retryPolicy) { try { // Action #2 retryPolicy.ExecuteAction(() => { throw new TimeoutException("Forced Exception"); }); } catch (Exception ex) { // By now, we exhausted all retry attempts when establishing a connection. This means we should also // stop retrying the SQL command. Should we not do that, we will continue retrying substantially // increasing the command execution time. The strategy here is that we wrap the transient error into an // RetryLimitExceededException and re-throw. This will ensure that the command will not be retried. throw new RetryLimitExceededException(ex); } }
/// <summary> /// Requests ACS token from the server and stores it for future use. /// </summary> public void RefreshToken() { using (WebClient client = new WebClient()) { client.BaseAddress = this.AcsBaseAddress; var oauthRequestValues = new NameValueCollection { {"grant_type", GrantType}, {"client_id", this.ClientId}, {"client_secret", this.ClientSecret}, {"scope", this.Scope}, }; RetryPolicy retryPolicy = new RetryPolicy(new WebRequestTransientErrorDetectionStrategy(), RetryStrategyFactory.DefaultStrategy()); retryPolicy.ExecuteAction( () => { byte[] responseBytes = client.UploadValues("/v2/OAuth2-13", "POST", oauthRequestValues); SetAcsToken(responseBytes); }); } }
/// <summary> /// Kills all precess by names with retries. Ignores exceptions. /// </summary> /// <param name="processNames"></param> public void Kill(params string[] processNames) { Contract.Requires(processNames != null); var retry = new RetryPolicy(RetryPolicy.DefaultFixed.ErrorDetectionStrategy, 3, TimeSpan.FromSeconds(10)); retry.ExecuteAction(() => KillInternal(processNames)); }
protected override void RunDatabaseLoad(DoWorkEventArgs e) { try { // Create the Retry Policy var retryPolicy = new RetryPolicy<ErrorDetectionStrategy>(BackoffStrategy); retryPolicy.ExecuteAction(() => { do { if (Worker.CancellationPending) { e.Cancel = true; break; } // Load the Database & Sleep for x amount of time if (CanLoadDatabase) { LoadDatabase(retryPolicy, _data); Sleep(); // Switch Databases IsLoadingPrimaryDatabase = !IsLoadingPrimaryDatabase; } else { Thread.Sleep(500); } } while (TotalElapsedSeconds < ConfigHelper.Runtime); }); } catch (Exception ex) { e.Result = ex.Message; } }
internal static void SafeMessagingActionAsync(Action<AsyncCallback> begin, Action<IAsyncResult> end, BrokeredMessage message, Action<bool> callback, string actionErrorDescription, string messageId, string subscription, long processingElapsedMilliseconds, long schedulingElapsedMilliseconds, Stopwatch roundtripStopwatch) { var retryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(retryStrategy); retryPolicy.Retrying += (s, e) => { Trace.TraceWarning("An error occurred in attempt number {1} to release message {3} in subscription {2}: {0}", e.LastException.GetType().Name + " - " + e.LastException.Message, e.CurrentRetryCount, subscription, message.MessageId); }; long messagingActionStart = 0; retryPolicy.ExecuteAction( ac => { messagingActionStart = roundtripStopwatch.ElapsedMilliseconds; begin(ac); }, end, () => { roundtripStopwatch.Stop(); callback(true); }, e => { roundtripStopwatch.Stop(); if (e is MessageLockLostException || e is MessagingException || e is TimeoutException) { Trace.TraceWarning(actionErrorDescription, messageId, subscription, e.GetType().Name + " - " + e.Message, processingElapsedMilliseconds, schedulingElapsedMilliseconds, messagingActionStart, roundtripStopwatch.ElapsedMilliseconds); } else { Trace.TraceError("Unexpected error releasing message in subscription {1}:\r\n{0}", e, subscription); } callback(false); }); }
private static void SpecifyRetryStrategiesInCode() { // Define your retry strategy: retry 5 times, starting 1 second apart // and adding 2 seconds to the interval each retry. var retryStrategy = new Incremental(5, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)); // Define your retry policy using the retry strategy and the Windows Azure storage // transient fault detection strategy. var retryPolicy = new RetryPolicy<StorageTransientErrorDetectionStrategy>(retryStrategy); // Receive notifications about retries. retryPolicy.Retrying += (sender, args) => { // Log details of the retry. var msg = String.Format("Retry - Count:{0}, Delay:{1}, Exception:{2}", args.CurrentRetryCount, args.Delay, args.LastException); Trace.WriteLine(msg, "Information"); }; try { var queue = Queue.GetQueueReference("orders"); // Do some work that may result in a transient fault. retryPolicy.ExecuteAction( () => { // Call a method that uses Windows Azure storage and which may // throw a transient exception. queue.CreateIfNotExists(); }); } catch (Exception) { // All the retries failed. } }
// GET api/session public IEnumerable<Session> Get(ODataQueryOptions<Session> queryOptions) { var retryStrategy = new Incremental(5, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)); var retryPolicy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(retryStrategy); List<Session> session = new List<Session>(); try { using (VidPackEntities db = new VidPackEntities()) { retryPolicy.ExecuteAction(() => { db.Database.Connection.Open(); }); var listSession = retryPolicy.ExecuteAction(() => db.ExistingSession.Include("DownloadItem").Select(item => new { SessionDate = item.SessionDate, SessionDescription = item.SessionDescription, SessionSubTitle = item.SessionSubTitle, SessionThumbnailUrl = item.SessionThumbnailUri, SessionTitle = item.SessionSubTitle, SessionVideoUrl = item.SessionVideoUri == null ? "" : item.SessionVideoUri, Speaker = item.Speaker, isActual = item.IsActualSession, DownloadItem = item.DownloadItem.Select(_ => new { Caption = _.Caption, Description = _.Description, Url = _.Url, }) }).ToList() ); //ToString() / String.Format() is not know within projection session = listSession.Select(item => new Session() { SessionDate = Convert.ToString(item.SessionDate), SessionDescription = item.SessionDescription, SessionSubTitle = item.SessionSubTitle, SessionThumbnailUrl = String.Format("{0}{1}", ThumbnailStorageUrl, item.SessionThumbnailUrl), SessionTitle = item.SessionSubTitle, SessionVideoUrl = item.SessionVideoUrl, Speaker = item.Speaker, SessionDownloadItem = item.DownloadItem.Select(_ => new DownloadItemInfo() { Caption = _.Caption, Description = _.Description, Url = _.Url, }).ToList<DownloadItemInfo>(), }).ToList<Session>(); return session; } } catch (Exception ex) { //TODO: Implement Error Handling return new List<Session>(); } }
public void TestRetryStrategyInExtensionMethods() { int maxRetryCount = 5; RetryPolicy retryPolicy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(maxRetryCount, TimeSpan.FromMilliseconds(500)); int callbackCount = 0; retryPolicy.Retrying += (sender, args) => { callbackCount++; Trace.WriteLine(String.Format("Current Retry Count: {0}", args.CurrentRetryCount)); Trace.WriteLine(String.Format("Last Exception: {0}", args.LastException.Message)); Trace.WriteLine(String.Format("Delay (ms): {0}", args.Delay.TotalMilliseconds)); }; try { // Action #1 retryPolicy.ExecuteAction(() => { SimulateFailure(retryPolicy); }); } catch (TimeoutException ex) { Assert.AreEqual("Forced Exception", ex.Message); } // NO LONGER VALID STRATEGY (initial implementation) // We expect to call the SimulateFailure method (maxRetryCount + 1) number of times (first pass + maxRetryCount attempts). // Each time we call SimulateFailure, we are going to retry for maxRetryCount times. The callback method is shared, hence it will be invoked // whenever we retry inside SimulateFailure as well as outside. The outer retry will impose extra hits on the callback method. // Therefore we should account for these extra calls and add further maxRetryCount number of attempts. Hence, the formula below. // int expectedRetryCount = (maxRetryCount + 1) * maxRetryCount + maxRetryCount; int expectedRetryCount = maxRetryCount; Assert.AreEqual<int>(expectedRetryCount, callbackCount, "The action was not retried using the expected amount of times"); }
public void TestRetryCallback() { RetryPolicy retryPolicy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(RetryStrategy.DefaultClientRetryCount); int callbackCount = 0; retryPolicy.Retrying += (sender, args) => { callbackCount++; Trace.WriteLine(String.Format("Current Retry Count: {0}", args.CurrentRetryCount)); Trace.WriteLine(String.Format("Last Exception: {0}", args.LastException.Message)); Trace.WriteLine(String.Format("Delay (ms): {0}", args.Delay.TotalMilliseconds)); }; try { retryPolicy.ExecuteAction(() => { throw new TimeoutException("Forced Exception"); }); } catch (TimeoutException ex) { Assert.AreEqual("Forced Exception", ex.Message); } Assert.AreEqual<int>(RetryStrategy.DefaultClientRetryCount, callbackCount, "The callback has not been made using the expected amount of times"); }
private static void RetryPolityUsingCode(IUnityContainer container, IBlockService service) { System.Diagnostics.Trace.WriteLine("Begin sample: RetryPolityUsingCode"); // Define your retry strategy: retry 5 times, starting 1 second apart // and adding 2 seconds to the interval each retry. var retryStrategy = new Incremental(5, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)); // Define your retry policy using the retry strategy and the Windows Azure storage // transient fault detection strategy. var retryPolicy = new RetryPolicy<BlockServiceExceptionDetectionStrategy>(retryStrategy); // Do some work that may result in a transient fault. System.Threading.Tasks.Parallel.For(0, 100, index => { try { retryPolicy.Retrying += OnRetryPolicyRetrying; retryPolicy.ExecuteAction(() => { _blockService.PutBlock(index.ToString(), index); }); retryPolicy.Retrying -= OnRetryPolicyRetrying; } catch (Exception exception) { // All the retries failed. System.Diagnostics.Trace.WriteLine(string.Format("An Exception has been thrown:\n{0}", exception)); } }); System.Diagnostics.Trace.WriteLine("End sample: RetryPolityUsingCode"); }