public static void WithRetry([NotNull] Action action, int retries = 1, int milliSecondTimeBetweenExecutions = 0, CancellationToken token = default(CancellationToken)) { if (retries < 1) { throw new ArgumentOutOfRangeException(nameof(retries)); } int remaining = retries + 1; while (!token.IsCancellationRequested) { try { action(); } catch { remaining--; if (remaining == 0) { throw; } if (milliSecondTimeBetweenExecutions > 0) { TimeSpanHelper.WasteTime(milliSecondTimeBetweenExecutions, token); } } } }
public ActionResult Edit(Guid?id) { var model = new EditModel() { ModalMode = Request.IsAjaxRequest() }; if (id.HasValue) { var metricType = GetMetricTypeById(id.Value); model.Id = metricType.Id; model.SystemName = metricType.SystemName; model.DisplayName = metricType.DisplayName; model.NoSignalColor = ColorStatusSelectorValue.FromColor(metricType.NoSignalColor); model.ActualTime = TimeSpanHelper.FromSeconds(metricType.ActualTimeSecs); model.ConditionRed = metricType.ConditionAlarm; model.ConditionYellow = metricType.ConditionWarning; model.ConditionGreen = metricType.ConditionSuccess; model.ElseColor = ColorStatusSelectorValue.FromColor(metricType.ConditionElseColor); } else { // значения по умолчанию model.NoSignalColor = new ColorStatusSelectorValue() { RedChecked = true }; model.ElseColor = new ColorStatusSelectorValue() { RedChecked = true }; } return(View(model)); }
public bool Send([NotNull] string value) { ThrowIfDisposed(); if (!IsConnected) { throw new NotConnectedException(); } if (value.Length == 0) { return(false); } TimeSpan dif = _lastSent.Elapsed(); if (dif < __timeBetweenActions) { TimeSpanHelper.WasteTime(dif); } int s = _client.Send(Encoding.GetBytes($"{value}\r\n\r\n")); _lastSent = DateTime.Now; if (__timeBetweenActions > TimeSpan.Zero) { TimeSpanHelper.WasteTime(__timeBetweenActions); } return(s > 0); }
private void snapshotsTextBox_Validating(object sender, CancelEventArgs e) { if (SuppressEvents) { return; } e.Cancel = false; errorProvider.SetError(snapshotsTextBox, null); var snapshotTimes = new ObservableList <TimeSpan>(); var matches = Regex.Matches(snapshotsTextBox.Text, @"(\d+[ ;,\t]*\w+)"); foreach (Match m in matches) { TimeSpan value; if (!TimeSpanHelper.TryGetFromNaturalFormat(m.Value, out value)) { e.Cancel = !snapshotsTextBox.ReadOnly && snapshotsTextBox.Enabled; // don't cancel an operation that cannot be edited errorProvider.SetError(snapshotsTextBox, "Error parsing " + m.Value + ", please provide a valid time span, e.g. 20 seconds ; 45s ; 4min ; 1h ; 3 hours ; 2 days ; 4d"); return; } else { snapshotTimes.Add(value); } } Content.SnapshotTimes = snapshotTimes; }
private void OnEnter(object sender, EventArgs e) { var context = ((HttpApplication)sender).Context; if (context.Error != null || context.CurrentHandler == null || context.CurrentHandler is DefaultHttpHandler) { return; } var cache = new WebCache(context.Cache); var request = context.Request; foreach (var ip in request.UserHosts()) { var key = KeyPrefix + ip; if (cache.Increment(key, ThrottlePeriod) >= RateQuota) { if (NoExceptionPathRegex == null || !NoExceptionPathRegex.IsMatch(request.RawUrl)) { throw new LimitExceededException(string.Format(CultureInfo.InvariantCulture, "The maximum quota for incoming requests ({0} queries per {1}) has been exceeded.", RateQuota, TimeSpanHelper.ToLongTimeString(ThrottlePeriod).ToLowerInvariant())); } } } }
public UnitTest CreateEf() { return(new UnitTest() { Id = Id, ErrorColor = ErrorColor, Enable = Enable, DisplayName = DisplayName, DisableToDate = DisableToDate, DisableComment = DisableComment, CreateDate = CreateDate, ComponentId = ComponentId, IsDeleted = IsDeleted, NextExecutionDate = NextDate, ParentEnable = ParentEnable, PeriodSeconds = PeriodSeconds, SimpleMode = SimpleMode, StatusDataId = StatusDataId, SystemName = SystemName, TypeId = TypeId, NoSignalColor = NoSignalColor, ActualTimeSecs = TimeSpanHelper.GetSeconds(ActualTime), LastExecutionDate = LastExecutionDate }); }
public void Load(Guid?id, Guid?componentId) { if (id.HasValue) { var test = GetUnitTest(id.Value); CheckName = test.DisplayName; ComponentId = test.ComponentId; Period = TimeSpan.FromSeconds(test.PeriodSeconds ?? 0); ActualTime = TimeSpanHelper.FromSeconds(test.ActualTimeSecs); NoSignalColor = ColorStatusSelectorValue.FromColor(test.NoSignalColor); ErrorColor = ColorStatusSelectorValue.FromUnitTestResultStatus(test.ErrorColor); if (ErrorColor.NotChecked) { ErrorColor.RedChecked = true; } } else { Period = TimeSpan.FromMinutes(10); ActualTime = TimeSpan.FromMinutes(20); ComponentId = componentId; CheckName = DefaultCheckName; ErrorColor = ColorStatusSelectorValue.FromUnitTestResultStatus(UnitTestResult.Alarm); NoSignalColor = ColorStatusSelectorValue.FromUnitTestResultStatus(UnitTestResult.Alarm); } }
public void SetTodayTest() { TimeSpan _actual = TimeSpanHelper.ParseTimeString("12:12:00").SetToday(); TimeSpan _expected = new TimeSpan(DateTime.Now.Day, 12, 12, 0); Assert.AreEqual(_expected, _actual); }
public ActionResult Edit(EventTypeEditModel model) { if (!ModelState.IsValid) { return(View(model)); } var dispatcher = GetDispatcherClient(); var data = new UpdateEventTypeRequestData() { EventTypeId = model.Id, DisplayName = model.DisplayName, SystemName = model.SystemName, OldVersion = model.OldVersion, JoinIntervalSeconds = TimeSpanHelper.GetSeconds(model.JoinInterval), ImportanceForOld = model.ImportanceForOld, ImportanceForNew = model.ImportanceForNew, UpdateActualEvents = true }; var response = dispatcher.UpdateEventType(CurrentUser.AccountId, data); response.Check(); this.SetTempMessage(TempMessageType.Success, "Тип события сохранён"); return(RedirectToAction("Show", new { id = model.Id })); }
public void Select(TimeSpan begin, TimeSpan end) { DMSentence first = null; DMSentence last = null; foreach (var sentence in this.Dictation.Sentences) { if (TimeSpanHelper.Intersect(begin, end, sentence.BeginTime, sentence.EndTime)) { if (first == null) { first = sentence; } last = sentence; } else if (first != null) { break; } } if (first != null && last != null) { this.SelectElement(first, last); } }
public static WebResponse GetResponse([NotNull] this WebRequest thisValue, IOResponseSettings settings = null) { if (settings == null) { return(thisValue.GetResponse()); } WebResponse response = null; int retries = 0; int maxRetries = settings.Retries; int timeBeforeRetries = settings.TimeBeforeRetries.TotalIntMilliseconds(); while (response == null && retries < maxRetries) { if (retries > 0 && timeBeforeRetries > 0) { TimeSpanHelper.WasteTime(timeBeforeRetries); } try { response = thisValue.GetResponse(); } catch (Exception ex) { retries++; if (retries >= maxRetries) { settings.OnError?.Invoke(ex); } } } return(response); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { var valueResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName); if (valueResult == null) { return(null); } var value = valueResult.ConvertTo(typeof(string)) as string; if (string.IsNullOrEmpty(value)) { return(null); } var controller = (ContextController)controllerContext.Controller; try { return(TimeSpanHelper.ParseHtml(value)); } catch (Exception) { controller.ModelState.AddModelError(bindingContext.ModelName, "Неверный формат"); controller.ModelState.SetModelValue(bindingContext.ModelName, valueResult); return(null); } }
public ActionResult Edit(UnitTestEditModel model) { model.UnitTest = GetUnitTestById(model.Id); if (!ModelState.IsValid) { View(model); } var updateData = new UpdateUnitTestRequestData() { NoSignalColor = model.NoSignalColor.GetSelectedOne(), ActualTime = TimeSpanHelper.GetSeconds(model.ActualTime), DisplayName = model.DisplayName, ComponentId = model.ComponentId, PeriodSeconds = model.PeriodSeconds, UnitTestId = model.Id, SystemName = model.UnitTest.SystemName }; var dispatcher = GetDispatcherClient(); var response = dispatcher.UpdateUnitTest(CurrentUser.AccountId, updateData); if (response.Success) { return(RedirectToAction("ResultDetails", new { id = model.Id })); } SetCommonError(response.ErrorMessage); return(View(model)); }
public static TResult WithRetry <TResult>([NotNull] Func <TResult> func, int retries = 1, int milliSecondTimeBetweenExecutions = 0, CancellationToken token = default(CancellationToken)) { if (retries < 1) { throw new ArgumentOutOfRangeException(nameof(retries)); } int remaining = retries + 1; TResult result = default(TResult); while (!token.IsCancellationRequested) { try { result = func(); } catch { remaining--; if (remaining == 0) { throw; } if (milliSecondTimeBetweenExecutions > 0) { TimeSpanHelper.WasteTime(milliSecondTimeBetweenExecutions, token); } } } return(result); }
public IMetricTypeCacheReadObject CreateMetricType(Guid accountId, CreateMetricTypeRequestData data) { if (data == null) { throw new ArgumentNullException("data"); } if (string.IsNullOrWhiteSpace(data.SystemName)) { throw new UserFriendlyException("Не укзан SystemName"); } if (string.IsNullOrWhiteSpace(data.DisplayName)) { data.DisplayName = data.SystemName; } var metricTypeId = AllCaches.MetricTypes.CreateMetricType(accountId, data.SystemName); var cache = new AccountCache(accountId); using (var metricType = cache.MetricTypes.Write(metricTypeId)) { metricType.DisplayName = data.DisplayName; metricType.ConditionRed = data.AlarmCondition; metricType.ConditionYellow = data.WarningCondition; metricType.ConditionGreen = data.SuccessCondition; metricType.ElseColor = data.ElseColor; metricType.ActualTime = TimeSpanHelper.FromSeconds(data.ActualTimeSecs); metricType.NoSignalColor = data.NoSignalColor; metricType.BeginSave(); metricType.WaitSaveChanges(); return(metricType); } }
public ActionResult Edit(Guid?id, Guid?componentId, Guid?metricTypeId) { var model = new EditModel() { ComponentId = componentId, MetricTypeId = metricTypeId }; if (id.HasValue) { var metric = GetMetricById(id.Value); if (metric != null) { model.Metric = metric; model.MetricType = metric.MetricType; model.Id = metric.Id; model.ComponentId = metric.ComponentId; model.MetricTypeId = metric.MetricTypeId; model.ConditionRed = metric.ConditionAlarm; model.ConditionYellow = metric.ConditionWarning; model.ConditionGreen = metric.ConditionSuccess; model.ElseColor = ColorStatusSelectorValue.FromColor(metric.ConditionElseColor); model.ActualTime = TimeSpanHelper.FromSeconds(metric.ActualTimeSecs); } } return(View(model)); }
public static UnitTestCacheWriteObject Create(UnitTest unitTest, Guid accountId) { if (unitTest == null) { return(null); } return(new UnitTestCacheWriteObject() { Id = unitTest.Id, AccountId = accountId, ErrorColor = unitTest.ErrorColor, Enable = unitTest.Enable, DisableComment = unitTest.DisableComment, DisableToDate = unitTest.DisableToDate, DisplayName = unitTest.DisplayName, CreateDate = unitTest.CreateDate, ComponentId = unitTest.ComponentId, IsDeleted = unitTest.IsDeleted, NextDate = unitTest.NextExecutionDate, ParentEnable = unitTest.ParentEnable, PeriodSeconds = unitTest.PeriodSeconds, SimpleMode = unitTest.SimpleMode, StatusDataId = unitTest.StatusDataId, SystemName = unitTest.SystemName, TypeId = unitTest.TypeId, NoSignalColor = unitTest.NoSignalColor, ActualTime = TimeSpanHelper.FromSeconds(unitTest.ActualTimeSecs), LastExecutionDate = unitTest.LastExecutionDate }); }
protected override void UpdateBatchObject(AccountDbContext accountDbContext, UnitTestCacheWriteObject unitTest, bool useCheck) { if (unitTest.Response.LastSavedData == null) { throw new Exception("unitTest.Response.LastSavedData == null"); } var dbEntity = unitTest.Response.LastSavedData.CreateEf(); accountDbContext.UnitTests.Attach(dbEntity); dbEntity.IsDeleted = unitTest.IsDeleted; dbEntity.ComponentId = unitTest.ComponentId; dbEntity.CreateDate = unitTest.CreateDate; dbEntity.DisplayName = unitTest.DisplayName; dbEntity.Enable = unitTest.Enable; dbEntity.DisableComment = unitTest.DisableComment; dbEntity.DisableToDate = unitTest.DisableToDate; dbEntity.ErrorColor = unitTest.ErrorColor; dbEntity.IsDeleted = unitTest.IsDeleted; dbEntity.NextExecutionDate = unitTest.NextDate; dbEntity.ParentEnable = unitTest.ParentEnable; dbEntity.PeriodSeconds = unitTest.PeriodSeconds; dbEntity.SimpleMode = unitTest.SimpleMode; dbEntity.StatusDataId = unitTest.StatusDataId; dbEntity.SystemName = unitTest.SystemName; dbEntity.NoSignalColor = unitTest.NoSignalColor; dbEntity.ActualTimeSecs = TimeSpanHelper.GetSeconds(unitTest.ActualTime); dbEntity.LastExecutionDate = unitTest.LastExecutionDate; }
public static bool Die(this Thread thisValue) { if (!IsAwaitable(thisValue)) { return(true); } if (IsWaiting(thisValue)) { TimeSpanHelper.WasteTime(TimeSpanHelper.HALF); } if (IsStopped(thisValue)) { return(true); } if (IsSuspended(thisValue)) { Awake(thisValue); } try { thisValue.Abort(); SpinWait.SpinUntil(() => !thisValue.IsAlive); return(true); } catch (ThreadAbortException) { return(true); } catch { return(false); } }
protected override void UpdateBatchObject(AccountDbContext accountDbContext, MetricTypeCacheWriteObject metricType, bool useCheck) { var oldMetricType = metricType.Response.LastSavedData; if (oldMetricType == null) { throw new Exception("oldMetricType == null"); } var dbEntity = oldMetricType.CreateEf(); accountDbContext.MetricTypes.Attach(dbEntity); dbEntity.CreateDate = metricType.CreateDate; dbEntity.IsDeleted = metricType.IsDeleted; dbEntity.CreateDate = metricType.CreateDate; dbEntity.SystemName = metricType.SystemName; dbEntity.DisplayName = metricType.DisplayName; dbEntity.ActualTimeSecs = TimeSpanHelper.GetSeconds(metricType.ActualTime); dbEntity.NoSignalColor = metricType.NoSignalColor; dbEntity.ConditionAlarm = metricType.ConditionRed; dbEntity.ConditionWarning = metricType.ConditionYellow; dbEntity.ConditionSuccess = metricType.ConditionGreen; dbEntity.ConditionElseColor = metricType.ElseColor; }
public async Task IncrementalAsyncWithoutResultTest() { const int RetryCount = 5; TimeSpan retryInterval = TimeSpan.FromSeconds(1); TimeSpan incremental = TimeSpan.FromSeconds(1); Counter <InvalidOperationException> counter = new(RetryCount); int retryFuncCount = 0; int retryHandlerCount = 0; await Retry.IncrementalAsync( async() => { retryFuncCount++; counter.Increase(); await Task.Yield(); }, RetryCount, exception => exception is InvalidOperationException, (sender, e) => { Assert.IsInstanceOfType(e.LastException, typeof(InvalidOperationException)); Assert.AreEqual(retryInterval + TimeSpan.FromTicks(incremental.Ticks *retryHandlerCount), e.Delay); Assert.AreEqual(counter.Time.Count, e.CurrentRetryCount); retryHandlerCount++; }, retryInterval, incremental, false); Assert.AreEqual(RetryCount, retryFuncCount); Assert.AreEqual(RetryCount - 1, retryHandlerCount); Assert.AreEqual(RetryCount, counter.Time.Count); TimeSpan[] intervals = counter.Time.Take(counter.Time.Count - 1).Zip(counter.Time.Skip(1), (a, b) => b - a).ToArray(); Assert.AreEqual(RetryCount - 1, intervals.Length); intervals.ForEach((interval, index) => Assert.IsTrue(TimeSpanHelper.AlmostEquals(interval.Ticks, retryInterval.Ticks + incremental.Ticks * index))); }
public static bool Die(this Process thisValue, int delay = 0) { if (!IsAwaitable(thisValue)) { return(true); } if (delay > 0) { TimeSpanHelper.WasteTime(delay); if (!IsAwaitable(thisValue)) { return(true); } } try { if (!KillChildren(thisValue)) { return(false); } if (!IsAwaitable(thisValue)) { return(true); } thisValue.Kill(); return(true); } catch { return(false); } }
protected override void OnContentChanged() { base.OnContentChanged(); SuppressEvents = true; try { if (Content == null) { timeLimitTextBox.Text = TimeSpanHelper.FormatNatural(TimeSpan.FromSeconds(60)); snapshotsTextBox.Text = String.Empty; storeAlgorithmInEachSnapshotCheckBox.Checked = false; algorithmViewHost.Content = null; snapshotsView.Content = null; runsView.Content = null; } else { timeLimitTextBox.Text = TimeSpanHelper.FormatNatural(Content.MaximumExecutionTime); snapshotsTextBox.Text = String.Join(" ; ", Content.SnapshotTimes.Select(x => TimeSpanHelper.FormatNatural(x, true))); storeAlgorithmInEachSnapshotCheckBox.Checked = Content.StoreAlgorithmInEachSnapshot; algorithmViewHost.Content = Content.Algorithm; snapshotsView.Content = Content.Snapshots; runsView.Content = Content.Runs; } } finally { SuppressEvents = false; } }
public Metric CreateEf() { return(new Metric() { Id = Id, Enable = Enable, DisableComment = DisableComment, DisableToDate = DisableToDate, IsDeleted = IsDeleted, ParentEnable = ParentEnable, CreateDate = CreateDate, Value = Value, BeginDate = BeginDate, ComponentId = ComponentId, ActualDate = ActualDate, MetricTypeId = MetricTypeId, StatusDataId = StatusDataId, NoSignalColor = NoSignalColor, ConditionAlarm = ConditionRed, ConditionWarning = ConditionYellow, ConditionSuccess = ConditionGreen, ConditionElseColor = ElseColor, ActualTimeSecs = TimeSpanHelper.GetSeconds(ActualTime) }); }
/// <summary> /// Редактирует подписку /// </summary> /// <param name="id"></param> /// <returns></returns> public ActionResult Edit(Guid id) { var subscriptionRepository = CurrentAccountDbContext.GetSubscriptionRepository(); var subscription = subscriptionRepository.GetById(id); var model = new SubscriptionEditModel() { ModalMode = Request.IsAjaxRequest(), ReturnUrl = Url.Action("Index", new { userId = subscription.UserId }), Id = subscription.Id, Object = subscription.Object, NotifyBetterStatus = subscription.NotifyBetterStatus, UserId = subscription.UserId, ComponentTypeId = subscription.ComponentTypeId, ComponentId = subscription.ComponentId, Channel = subscription.Channel, CanShowChannel = false, CanShowComponentType = false, CanShowComponent = false, IsEnabled = subscription.IsEnabled, Color = ColorStatusSelectorValue.FromEventImportance(subscription.Importance), MinimumDuration = TimeSpanHelper.FromSeconds(subscription.DurationMinimumInSeconds), ResendTime = TimeSpanHelper.FromSeconds(subscription.ResendTimeInSeconds) }; return(View(model)); }
public static MetricCacheWriteObject Create(Metric metric, Guid accountId) { if (metric == null) { return(null); } var cache = new MetricCacheWriteObject() { Id = metric.Id, Enable = metric.Enable, DisableToDate = metric.DisableToDate, DisableComment = metric.DisableComment, StatusDataId = metric.StatusDataId, Value = metric.Value, ParentEnable = metric.ParentEnable, ComponentId = metric.ComponentId, AccountId = accountId, BeginDate = metric.BeginDate, ActualDate = metric.ActualDate, IsDeleted = metric.IsDeleted, CreateDate = metric.CreateDate, MetricTypeId = metric.MetricTypeId, ActualTime = TimeSpanHelper.FromSeconds(metric.ActualTimeSecs), ConditionRed = metric.ConditionAlarm, ConditionYellow = metric.ConditionWarning, ConditionGreen = metric.ConditionSuccess, ElseColor = metric.ConditionElseColor, NoSignalColor = metric.NoSignalColor }; return(cache); }
public ActionResult Edit(UnitTestTypeEditModel model) { if (!ModelState.IsValid) { return(View(model)); } var repository = CurrentAccountDbContext.GetUnitTestTypeRepository(); var unitTestType = repository.GetById(model.Id); CheckEditingPermissions(unitTestType); var client = GetDispatcherClient(); var response = client.UpdateUnitTestType(CurrentUser.AccountId, new UpdateUnitTestTypeRequestData() { UnitTestTypeId = unitTestType.Id, DisplayName = model.DisplayName, SystemName = model.SystemName, ActualTimeSecs = TimeSpanHelper.GetSeconds(model.ActualTime), NoSignalColor = model.NoSignalColor.GetSelectedOne() }); response.Check(); return(RedirectToAction("Show", new { id = model.Id })); }
public IMetricCacheReadObject CreateMetric(Guid accountId, CreateMetricRequestData data) { if (data == null) { throw new ArgumentNullException("data"); } var meticType = GetOrCreateType(accountId, data.MetricName); var metricId = CreateMetric(accountId, data.ComponentId, meticType.Id); var cache = new AccountCache(accountId); using (var metric = cache.Metrics.Write(metricId)) { metric.ActualTime = TimeSpanHelper.FromSeconds(data.ActualTimeSecs); metric.NoSignalColor = data.NoSignalColor; metric.ConditionRed = data.AlarmCondition; metric.ConditionYellow = data.WarningCondition; metric.ConditionGreen = data.SuccessCondition; metric.ElseColor = data.ElseColor; metric.BeginSave(); } var metrikRead = cache.Metrics.Read(metricId); metrikRead.WaitSaveChanges(); return(metrikRead); }
private void textBox_Validating(object sender, CancelEventArgs e) { var textBox = (TextBox)sender; TimeSpan value; errorProvider.SetError(textBox, String.Empty); if (!TimeSpanHelper.TryGetFromNaturalFormat(textBox.Text, out value)) { errorProvider.SetError(textBox, "Please enter a valid timespan."); e.Cancel = true; return; } if (textBox == minimumTextBox) { Minimum = value; } else if (textBox == maximumTextBox) { Maximum = value; } else if (textBox == stepSizeTextBox) { Step = value; } okButton.Enabled = IsValid(); }
protected override void UpdateBatchObject(AccountDbContext accountDbContext, MetricCacheWriteObject metric, bool useCheck) { var oldMetric = metric.Response.LastSavedData; if (oldMetric == null) { throw new Exception("oldMetric == null"); } var dbEntity = oldMetric.CreateEf(); accountDbContext.Metrics.Attach(dbEntity); dbEntity.ActualDate = metric.ActualDate; dbEntity.BeginDate = metric.BeginDate; dbEntity.ComponentId = metric.ComponentId; dbEntity.CreateDate = metric.CreateDate; dbEntity.Enable = metric.Enable; dbEntity.DisableComment = metric.DisableComment; dbEntity.DisableToDate = metric.DisableToDate; dbEntity.IsDeleted = metric.IsDeleted; dbEntity.MetricTypeId = metric.MetricTypeId; dbEntity.ParentEnable = metric.ParentEnable; dbEntity.StatusDataId = metric.StatusDataId; dbEntity.Value = metric.Value; dbEntity.ConditionAlarm = metric.ConditionRed; dbEntity.ConditionWarning = metric.ConditionYellow; dbEntity.ConditionSuccess = metric.ConditionGreen; dbEntity.ActualTimeSecs = TimeSpanHelper.GetSeconds(metric.ActualTime); dbEntity.NoSignalColor = metric.NoSignalColor; dbEntity.ConditionElseColor = metric.ElseColor; }