protected override IEnumerator <IAsyncResult> GetQueueAclImpl(IAccountIdentifier identifier, string account, string queue, TimeSpan timeout, RequestContext requestContext, AsyncIteratorContext <ContainerAclSettings> context) { Duration startingNow = Duration.StartingNow; if (identifier == null) { throw new ArgumentNullException("identifier"); } if (string.IsNullOrEmpty(account)) { throw new ArgumentException("account", "Cannot be null or empty"); } if (string.IsNullOrEmpty(queue)) { throw new ArgumentException("queue", "Cannot be null or empty"); } if (timeout <= TimeSpan.Zero) { throw new TimeoutException("Timed out in GetQueueAcl"); } RemainingTime remainingTime = new RemainingTime(timeout); IAsyncResult asyncResult = this.BeginGetQueue(identifier, account, queue, PermissionLevel.ReadAcl, ContainerPropertyNames.ServiceMetadata, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetQueueAclImpl")); yield return(asyncResult); IQueueContainer operationStatus = this.EndGetQueue(asyncResult); if (requestContext != null) { operationStatus.OperationStatus = requestContext.OperationStatus; } context.ResultData = new ContainerAclSettings(operationStatus.ServiceMetadata); }
public void InitializeHollidayCountDown() { IsBusy = true; // get the next holliday Holliday nextHolliday = GetNextHolliday(); NextHolliday = nextHolliday; DateTime currentDate = DateTime.Now; long elapsedTicks = _nextHolliday.Date.Ticks - currentDate.Ticks; TimeSpan elapsedSpan = new TimeSpan(elapsedTicks); RemainingTime = new RemainingTime(); RemainingTime.Days = elapsedSpan.Days; RemainingTime.Hours = elapsedSpan.Hours; RemainingTime.Minutes = elapsedSpan.Minutes; RemainingTime.Seconds = elapsedSpan.Seconds; // Attach a couple event handlers. Device.StartTimer(TimeSpan.FromMilliseconds(16), OnTimerTick); IsBusy = false; }
public override string GetStepParameters() { var parameters = new List <string>(); parameters.Add(Name != null ? Name.ToStepValue() : "$"); parameters.Add(DataOrigin.ToStepValue()); parameters.Add(UserDefinedDataOrigin != null ? UserDefinedDataOrigin.ToStepValue() : "$"); parameters.Add(DurationType.ToStepValue()); parameters.Add(ScheduleDuration != null ? ScheduleDuration.ToStepValue() : "$"); parameters.Add(ScheduleStart != null ? ScheduleStart.ToStepValue() : "$"); parameters.Add(ScheduleFinish != null ? ScheduleFinish.ToStepValue() : "$"); parameters.Add(EarlyStart != null ? EarlyStart.ToStepValue() : "$"); parameters.Add(EarlyFinish != null ? EarlyFinish.ToStepValue() : "$"); parameters.Add(LateStart != null ? LateStart.ToStepValue() : "$"); parameters.Add(LateFinish != null ? LateFinish.ToStepValue() : "$"); parameters.Add(FreeFloat != null ? FreeFloat.ToStepValue() : "$"); parameters.Add(TotalFloat != null ? TotalFloat.ToStepValue() : "$"); parameters.Add(IsCritical != null ? IsCritical.ToStepValue() : "$"); parameters.Add(StatusTime != null ? StatusTime.ToStepValue() : "$"); parameters.Add(ActualDuration != null ? ActualDuration.ToStepValue() : "$"); parameters.Add(ActualStart != null ? ActualStart.ToStepValue() : "$"); parameters.Add(ActualFinish != null ? ActualFinish.ToStepValue() : "$"); parameters.Add(RemainingTime != null ? RemainingTime.ToStepValue() : "$"); parameters.Add(Completion != null ? Completion.ToStepValue() : "$"); return(string.Join(", ", parameters.ToArray())); }
/// <summary> /// Throws <see cref="TimeoutException"/> if timeout occurs. /// </summary> /// <param name="remaining">The remaining time before timeout.</param> public void ThrowIfExpired(out TimeSpan remaining) { if (!RemainingTime.TryGetValue(out remaining)) { throw new TimeoutException(); } }
void GameIntro() { if (Input.touchCount != 0 && !hasStarted) { hasStarted = true; readyText1 = Instantiate(readyText, transform); readyText1.GetComponent <TextMeshProUGUI>().color = player1Color; readyText1.transform.position = startText1.transform.position; readyText1.transform.rotation = startText1.transform.rotation; readyText2 = Instantiate(readyText, transform); readyText2.transform.position = startText2.transform.position; readyText2.transform.rotation = startText2.transform.rotation; readyText2.GetComponent <TextMeshProUGUI>().color = player2Color; Destroy(startText2); Destroy(startText1); Time.timeScale = 1; } if (hasStarted == true && remainingTime <= initialTime - 3f && !countdown) { countdown = true; remainingTime = initialTime; } if (remainingTime <= initialTime - 3f && countdown && !fullStart) { fullStart = true; remainingTime = initialTime; } if (fullStart) { RemainingTime.GetComponent <TextMeshProUGUI>().text = "Time : " + Mathf.RoundToInt(remainingTime).ToString(); } }
protected override IEnumerator <IAsyncResult> GetQueuePropertiesImpl(IAccountIdentifier identity, string account, string queue, bool getMessageCount, SASAuthorizationParameters sasParams, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <QueueProperties> context) { RemainingTime remainingTime = new RemainingTime(timeout); IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Read, sasParams, ContainerPropertyNames.ApplicationMetadata, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetQueuePropertiesImpl")); yield return(asyncResult); IQueueContainer operationStatus = this.EndGetQueue(asyncResult); if (requestContext != null) { operationStatus.OperationStatus = requestContext.OperationStatus; } NameValueCollection nameValueCollection = QueueHelpers.DeserializeMetadata(operationStatus.ApplicationMetadata); long?nullable = null; if (getMessageCount) { operationStatus.Timeout = remainingTime; asyncResult = operationStatus.BeginGetQueueStatistics(true, true, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetQueuePropertiesImpl")); yield return(asyncResult); nullable = new long?(operationStatus.EndGetQueueStatistics(asyncResult).TotalMessages); } context.ResultData = new QueueProperties(account, queue, nullable, nameValueCollection); }
protected override IEnumerator <IAsyncResult> PeekMessagesImpl(IAccountIdentifier identity, string account, string queue, int numMessages, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <IEnumerable <PeekedMessage> > context) { this.ValidateNumMessages(numMessages, this.config.MaxMessagesToReturn); RemainingTime remainingTime = new RemainingTime(timeout); SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters() { SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas, SignedResourceType = SasResourceType.Object, SignedPermission = SASPermission.Read }; SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter; IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Read, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.PeekMessagesImpl")); yield return(asyncResult); IQueueContainer operationStatus = this.EndGetQueue(asyncResult); if (requestContext != null) { operationStatus.OperationStatus = requestContext.OperationStatus; } operationStatus.Timeout = remainingTime; asyncResult = operationStatus.BeginPeekMessage(numMessages, context.GetResumeCallback(), context.GetResumeState("QueueManager.PeekMessagesImpl")); yield return(asyncResult); IEnumerable <IMessageData> messageDatas = operationStatus.EndPeekMessage(asyncResult); context.ResultData = this.WrapPeekedMessageResults(messageDatas); }
private async Task <bool> PassMeridian(CancellationToken token, IProgress <ApplicationStatus> progress) { Logger.Trace("Meridian Flip - Passing meridian"); progress.Report(new ApplicationStatus() { Status = Locale.Loc.Instance["LblStopTracking"] }); Logger.Trace("Meridian Flip - Stopping tracking to pass meridian"); telescopeMediator.SetTracking(false); do { progress.Report(new ApplicationStatus() { Status = RemainingTime.ToString(@"hh\:mm\:ss") }); //progress.Report(string.Format("Next exposure paused until passing meridian. Remaining time: {0} seconds", RemainingTime)); var delta = await Utility.Utility.Delay(1000, token); RemainingTime -= delta; } while (RemainingTime.TotalSeconds >= 1); progress.Report(new ApplicationStatus() { Status = Locale.Loc.Instance["LblResumeTracking"] }); Logger.Trace("Meridian Flip - Resuming tracking after passing meridian"); telescopeMediator.SetTracking(true); Logger.Trace("Meridian Flip - Meridian passed"); return(true); }
public static void ShutDown(RemainingTime remainingTime, params IShutDownable[] shutDownables) { if (shutDownables == null) { return; } foreach (var shutDownable in shutDownables) { if (shutDownable != null) { shutDownable.SignalShutDown (); } } foreach (var shutDownable in shutDownables) { if (shutDownable != null) { try { shutDownable.ShutDown (remainingTime); } catch (Exception exc) { Log.Exception ("Failed to shutdown: {0}", exc); } } } }
protected override IEnumerator <IAsyncResult> SetQueueMetadataImpl(IAccountIdentifier identity, string account, string queue, NameValueCollection metadata, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <NoResults> context) { RemainingTime remainingTime = new RemainingTime(timeout); SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters() { SupportedSasTypes = SasType.AccountSas, SignedResourceType = SasResourceType.Container, SignedPermission = SASPermission.Write }; SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter; IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Write, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.SetQueueMetadataImpl")); yield return(asyncResult); IQueueContainer operationStatus = this.EndGetQueue(asyncResult); if (requestContext != null) { operationStatus.OperationStatus = requestContext.OperationStatus; } operationStatus.ApplicationMetadata = QueueHelpers.SerializeMetadata(metadata); operationStatus.Timeout = remainingTime; asyncResult = operationStatus.BeginSetProperties(ContainerPropertyNames.ApplicationMetadata, null, context.GetResumeCallback(), context.GetResumeState("QueueManager.SetQueueMetadataImpl")); yield return(asyncResult); operationStatus.EndSetProperties(asyncResult); }
protected override IEnumerator <IAsyncResult> ClearQueueImpl(IAccountIdentifier identity, string account, string queue, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <NoResults> context) { RemainingTime remainingTime = new RemainingTime(timeout); SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters() { SupportedSasTypes = SasType.AccountSas, SignedResourceType = SasResourceType.Object, SignedPermission = SASPermission.Delete }; SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter; IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Delete, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.ClearQueueImpl")); yield return(asyncResult); IQueueContainer operationStatus = this.EndGetQueue(asyncResult); if (requestContext != null) { operationStatus.OperationStatus = requestContext.OperationStatus; } operationStatus.Timeout = remainingTime; asyncResult = operationStatus.BeginClearQueue(context.GetResumeCallback(), context.GetResumeState("QueueManager.ClearQueueImpl")); yield return(asyncResult); operationStatus.EndClearQueue(asyncResult); }
public void AddBlock(String label, TimeSpan time) { if (HasStarted) { return; } var interval = new IntervalBlock(); interval.CenterText = label; interval.CurrentTime = time; interval.OnFinished += delegate(object o, EventArgs args) { _elapsedTime = _elapsedTime.Add(interval.OriginalTime); if (Blocks.Count == Blocks.Count(b => b.HasFinished)) { Stop(); HasFinished = true; var oldBlock = CurrentBlock; Blocks.RemoveAt(0); Blocks.Add(oldBlock); } else { StartNextBlock(); } Common.PlaySound(Common.AlertSound1); }; RemainingTime = RemainingTime.Add(interval.CurrentTime); _orignalTime = RemainingTime; // keep the original time in memory so we can substract when running Blocks.Add(interval); }
private IEnumerator <IAsyncResult> ClearQueueImpl(AsyncIteratorContext <NoResults> context) { IAsyncResult asyncResult; RemainingTime remainingTime = new RemainingTime(base.Timeout); try { this.InternalContainer.Timeout = StorageStampHelpers.AdjustTimeoutRange(remainingTime); } catch (Exception exception) { StorageStamp.TranslateException(exception); throw; } try { asyncResult = this.InternalContainer.BeginGetProperties(ContainerPropertyNames.None, null, context.GetResumeCallback(), context.GetResumeState("QueueContainer.GetMessageImpl")); } catch (Exception exception1) { StorageStamp.TranslateException(exception1); throw; } yield return(asyncResult); try { this.InternalContainer.EndGetProperties(asyncResult); } catch (Exception exception2) { StorageStamp.TranslateException(exception2); throw; } try { this.InternalContainer.Timeout = remainingTime; asyncResult = this.InternalContainer.BeginClearQueue(context.GetResumeCallback(), context.GetResumeState("QueueContainer.GetMessageImpl")); } catch (Exception exception3) { StorageStamp.TranslateException(exception3); throw; } yield return(asyncResult); try { this.InternalContainer.EndClearQueue(asyncResult); } catch (Exception exception4) { StorageStamp.TranslateException(exception4); throw; } }
private IEnumerator <IAsyncResult> GetMessageImpl(int numberOfMessages, TimeSpan visibilityTimeout, AsyncIteratorContext <IEnumerable <IMessageData> > context) { IAsyncResult asyncResult; RemainingTime remainingTime = new RemainingTime(base.Timeout); try { this.InternalContainer.Timeout = remainingTime; } catch (Exception exception) { StorageStamp.TranslateException(exception); throw; } try { asyncResult = this.InternalContainer.BeginGetProperties(ContainerPropertyNames.None, null, context.GetResumeCallback(), context.GetResumeState("QueueContainer.GetMessageImpl")); } catch (Exception exception1) { StorageStamp.TranslateException(exception1); throw; } yield return(asyncResult); try { this.InternalContainer.EndGetProperties(asyncResult); } catch (Exception exception2) { StorageStamp.TranslateException(exception2); throw; } try { this.InternalContainer.Timeout = remainingTime; asyncResult = this.InternalContainer.BeginGetMessage(numberOfMessages, visibilityTimeout, context.GetResumeCallback(), context.GetResumeState("QueueContainer.GetMessageImpl")); } catch (Exception exception3) { StorageStamp.TranslateException(exception3); throw; } yield return(asyncResult); try { context.ResultData = this.InternalContainer.EndGetMessage(asyncResult); } catch (Exception exception4) { StorageStamp.TranslateException(exception4); throw; } }
private IEnumerator <IAsyncResult> GetQueueStatisticsImpl(bool includeInvisibleMessages, bool includeExpiredMessages, AsyncIteratorContext <IQueueStatistics> context) { IAsyncResult asyncResult; RemainingTime remainingTime = new RemainingTime(base.Timeout); try { this.InternalContainer.Timeout = StorageStampHelpers.AdjustTimeoutRange(remainingTime); } catch (Exception exception) { StorageStamp.TranslateException(exception); throw; } try { asyncResult = this.InternalContainer.BeginGetProperties(ContainerPropertyNames.None, null, context.GetResumeCallback(), context.GetResumeState("QueueContainer.GetMessageImpl")); } catch (Exception exception1) { StorageStamp.TranslateException(exception1); throw; } yield return(asyncResult); try { this.InternalContainer.EndGetProperties(asyncResult); } catch (Exception exception2) { StorageStamp.TranslateException(exception2); throw; } try { this.InternalContainer.Timeout = remainingTime; asyncResult = this.InternalContainer.BeginGetQueueStatistics(includeInvisibleMessages, includeExpiredMessages, context.GetResumeCallback(), context.GetResumeState("QueueContainer.GetMessageImpl")); } catch (Exception exception3) { StorageStamp.TranslateException(exception3); throw; } yield return(asyncResult); try { context.ResultData = this.InternalContainer.EndGetQueueStatistics(asyncResult); } catch (Exception exception4) { StorageStamp.TranslateException(exception4); throw; } }
private IEnumerator <IAsyncResult> ListMessagesImpl(string queueNameStart, DateTime?visibilityStart, Guid messageIdStart, int?subQueueId, bool includeInvisibleMessages, int numberOfMessages, AsyncIteratorContext <ListMessagesResult> context) { IAsyncResult asyncResult; RemainingTime remainingTime = new RemainingTime(base.Timeout); try { this.InternalContainer.Timeout = StorageStampHelpers.AdjustTimeoutRange(remainingTime); } catch (Exception exception) { StorageStamp.TranslateException(exception); throw; } try { asyncResult = this.InternalContainer.BeginGetProperties(ContainerPropertyNames.None, null, context.GetResumeCallback(), context.GetResumeState("QueueContainer.ListMessagesImpl")); } catch (Exception exception1) { StorageStamp.TranslateException(exception1); throw; } yield return(asyncResult); try { this.InternalContainer.EndGetProperties(asyncResult); } catch (Exception exception2) { StorageStamp.TranslateException(exception2); throw; } try { this.InternalContainer.Timeout = remainingTime; asyncResult = this.InternalContainer.BeginListMessages(queueNameStart, visibilityStart, messageIdStart, subQueueId, includeInvisibleMessages, numberOfMessages, context.GetResumeCallback(), context.GetResumeState("QueueContainer.ListMessagesImpl")); } catch (Exception exception3) { StorageStamp.TranslateException(exception3); throw; } yield return(asyncResult); try { context.ResultData = this.InternalContainer.EndListMessages(asyncResult); } catch (Exception exception4) { StorageStamp.TranslateException(exception4); throw; } }
private IEnumerator <IAsyncResult> PutMessageImpl(List <PushedMessage> messagesList, bool usePutMessageRowCommand, AsyncIteratorContext <List <IMessageData> > context) { IAsyncResult asyncResult; RemainingTime remainingTime = new RemainingTime(base.Timeout); try { this.InternalContainer.Timeout = StorageStampHelpers.AdjustTimeoutRange(remainingTime); } catch (Exception exception) { StorageStamp.TranslateException(exception); throw; } try { asyncResult = this.InternalContainer.BeginGetProperties(ContainerPropertyNames.None, null, context.GetResumeCallback(), context.GetResumeState("QueueContainer.PutMessageImpl")); } catch (Exception exception1) { StorageStamp.TranslateException(exception1); throw; } yield return(asyncResult); try { this.InternalContainer.EndGetProperties(asyncResult); } catch (Exception exception2) { StorageStamp.TranslateException(exception2); throw; } try { this.InternalContainer.Timeout = remainingTime; asyncResult = this.InternalContainer.BeginPutMessage(messagesList, usePutMessageRowCommand, context.GetResumeCallback(), context.GetResumeState("QueueContainer.PutMessageImpl")); } catch (Exception exception3) { StorageStamp.TranslateException(exception3); throw; } yield return(asyncResult); try { context.ResultData = this.InternalContainer.EndPutMessage(asyncResult); } catch (Exception exception4) { StorageStamp.TranslateException(exception4); throw; } }
private IEnumerator <IAsyncResult> UpdateMessageImpl(IQueueMessageReceipt receipt, byte[] body, TimeSpan visibilityTimeout, TimeSpan?timeToLive, AsyncIteratorContext <IQueueMessageReceipt> context) { IAsyncResult asyncResult; RemainingTime remainingTime = new RemainingTime(base.Timeout); try { this.InternalContainer.Timeout = StorageStampHelpers.AdjustTimeoutRange(remainingTime); } catch (Exception exception) { StorageStamp.TranslateException(exception); throw; } try { asyncResult = this.InternalContainer.BeginGetProperties(ContainerPropertyNames.None, null, context.GetResumeCallback(), context.GetResumeState("QueueContainer.GetMessageImpl")); } catch (Exception exception1) { StorageStamp.TranslateException(exception1); throw; } yield return(asyncResult); try { this.InternalContainer.EndGetProperties(asyncResult); } catch (Exception exception2) { StorageStamp.TranslateException(exception2); throw; } try { this.InternalContainer.Timeout = remainingTime; asyncResult = this.InternalContainer.BeginUpdateMessage(receipt, body, visibilityTimeout, timeToLive, context.GetResumeCallback(), context.GetResumeState("QueueContainer.GetMessageImpl")); } catch (Exception exception3) { StorageStamp.TranslateException(exception3); throw; } yield return(asyncResult); try { context.ResultData = this.InternalContainer.EndUpdateMessage(asyncResult); } catch (Exception exception4) { StorageStamp.TranslateException(exception4); throw; } }
protected IEnumerator <IAsyncResult> SetTableAclImpl(IAccountIdentifier identifier, string account, string tableName, ContainerAclSettings acl, TimeSpan timeout, RequestContext requestContext, AsyncIteratorContext <NoResults> context) { byte[] numArray; Duration startingNow = Duration.StartingNow; if (identifier == null) { throw new ArgumentNullException("identifier"); } if (string.IsNullOrEmpty(account)) { throw new ArgumentException("account", "Cannot be null or empty"); } if (string.IsNullOrEmpty(tableName)) { throw new ArgumentException("tableName", "Cannot be null or empty"); } if (acl == null) { throw new ArgumentNullException("acl"); } if (acl.SASIdentifiers == null) { throw new ArgumentNullException("sasidentifiers"); } if (timeout <= TimeSpan.Zero) { throw new TimeoutException("Timed out in SetTableAcl"); } RemainingTime remainingTime = new RemainingTime(timeout); if (identifier is TableSignedAccessAccountIdentifier || identifier is AccountSasAccessIdentifier) { throw new NephosUnauthorizedAccessException("Signed access not supported for this request", AuthorizationFailureReason.InvalidOperationSAS); } IAsyncResult asyncResult = this.authorizationManager.BeginCheckAccess(identifier, account, tableName, null, PermissionLevel.WriteAcl, remainingTime, context.GetResumeCallback(), context.GetResumeState("TableManager.SetTableAclImpl")); yield return(asyncResult); this.authorizationManager.EndCheckAccess(asyncResult); using (IStorageAccount storageAccount = this.storageManager.CreateAccountInstance(account)) { using (ITableContainer tableContainer = storageAccount.CreateTableContainerInstance(tableName)) { acl.EncodeToServiceMetadata(out numArray); ContainerCondition containerCondition = null; tableContainer.ServiceMetadata = numArray; tableContainer.Timeout = startingNow.Remaining(timeout); asyncResult = tableContainer.BeginSetProperties(ContainerPropertyNames.ServiceMetadata, containerCondition, context.GetResumeCallback(), context.GetResumeState("TableManager.SetTableAclImpl")); yield return(asyncResult); tableContainer.EndSetProperties(asyncResult); } } }
public void TimerStart() { MyEventArgs eventArgs = new MyEventArgs(); for (int i = 0; i < TimerTime; i++) { eventArgs.SetRemainigTime(TimerTime - i); RemainingTime?.Invoke(this, eventArgs); Thread.Sleep(1000); } TimerStop?.Invoke(this, null); }
public void Reset() { RemainingTime.CopyFrom(attachedTabata.CompleteLength); RemainingPhaseTime.CopyFrom(attachedTabata.PreparationLength); WholePhaseTime.CopyFrom(attachedTabata.PreparationLength); CurrentState = State.Preparation; CurrentRoundNumber = 0; CurrentExerciseNumber = 0; playTimer.Stop(); PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(StateChangedEventName)); PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(RoundChangedEventName)); PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(ExerciceChangedEventName)); PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(TimeChangedEventName)); }
/// <summary> /// Starts the timer. /// </summary> private void StartTimer() { _timer = new DispatcherTimer(new TimeSpan(0, 0, 1), DispatcherPriority.DataBind, delegate { if (_remainingTime == TimeSpan.Zero) { _timer.Stop(); MainWindow.Instance.TimerExpire(); ((QuizViewModel)CurrentPage).GotoResultView(); } RemainingTime = RemainingTime.Add(TimeSpan.FromSeconds(-1)); }, Application.Current.Dispatcher); _timer.Start(); }
protected override IEnumerator <IAsyncResult> GetMessagesImpl(IAccountIdentifier identity, string account, string queue, int numMessages, long?visibilityTimeout, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <IEnumerable <PoppedMessage> > context) { object obj; this.ValidateNumMessages(numMessages, this.config.MaxMessagesToReturn); RemainingTime remainingTime = new RemainingTime(timeout); SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters() { SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas, SignedResourceType = SasResourceType.Object, SignedPermission = SASPermission.Process }; SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter; IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.ReadDelete, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetMessagesImpl")); yield return(asyncResult); IQueueContainer operationStatus = this.EndGetQueue(asyncResult); if (requestContext != null) { operationStatus.OperationStatus = requestContext.OperationStatus; } long?nullable = visibilityTimeout; obj = (nullable.HasValue ? nullable.GetValueOrDefault() : this.config.DefaultVisibilityTimeoutSeconds); TimeSpan timeSpan = TimeSpan.FromSeconds((double)obj); operationStatus.Timeout = remainingTime; asyncResult = operationStatus.BeginGetMessage(numMessages, timeSpan, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetMessagesImpl")); yield return(asyncResult); IEnumerable <IMessageData> messageDatas = operationStatus.EndGetMessage(asyncResult); StringBuilder stringBuilder = new StringBuilder(); context.ResultData = this.WrapGetMessageResults(messageDatas); int num = 0; foreach (PoppedMessage resultDatum in context.ResultData) { stringBuilder.Append(string.Format("[{0}],", resultDatum.ToString())); num++; } IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug; object[] str = new object[] { num, stringBuilder.ToString() }; verboseDebug.Log("GetMessages response: Count={0} Messages={1}", str); }
protected override IEnumerator <IAsyncResult> SetQueueAclImpl(IAccountIdentifier identifier, string account, string queue, ContainerAclSettings acl, TimeSpan timeout, RequestContext requestContext, AsyncIteratorContext <NoResults> context) { byte[] numArray; Duration startingNow = Duration.StartingNow; if (identifier == null) { throw new ArgumentNullException("identifier"); } if (string.IsNullOrEmpty(account)) { throw new ArgumentException("account", "Cannot be null or empty"); } if (string.IsNullOrEmpty(queue)) { throw new ArgumentException("queue", "Cannot be null or empty"); } if (acl == null) { throw new ArgumentNullException("acl"); } if (acl.SASIdentifiers == null) { throw new ArgumentNullException("sasidentifiers"); } if (timeout <= TimeSpan.Zero) { throw new TimeoutException("Timed out in SetQueueAcl"); } RemainingTime remainingTime = new RemainingTime(timeout); IAsyncResult asyncResult = this.BeginGetQueue(identifier, account, queue, PermissionLevel.WriteAcl, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.SetQueueAclImpl")); yield return(asyncResult); IQueueContainer operationStatus = this.EndGetQueue(asyncResult); if (requestContext != null) { operationStatus.OperationStatus = requestContext.OperationStatus; } acl.EncodeToServiceMetadata(out numArray); operationStatus.ServiceMetadata = numArray; operationStatus.Timeout = remainingTime; asyncResult = operationStatus.BeginSetProperties(ContainerPropertyNames.ServiceMetadata, null, context.GetResumeCallback(), context.GetResumeState("QueueManager.SetQueueAclImpl")); yield return(asyncResult); operationStatus.EndSetProperties(asyncResult); }
private void Timer_Tick(object sender, EventArgs e) { RemainingTime = RemainingTime.Subtract(new TimeSpan(0, 0, 1)); timeDisplayBlock.Text = RemainingTime.ToString(); DoubleAnimation progressAnimation = new DoubleAnimation(progressBar.Value + _increment, new Duration(new TimeSpan(0, 0, 1))); progressBar.BeginAnimation(ProgressBar.ValueProperty, progressAnimation); if (RemainingTime.TotalSeconds == 30) { timeDisplayBlock.Foreground = progressBar.Foreground = new SolidColorBrush(Colors.Red); } if (RemainingTime == TimeSpan.Zero) { SubmitButton_Click(null, null); } }
protected override IEnumerator <IAsyncResult> DeleteMessageImpl(IAccountIdentifier identity, string account, string queue, string messageId, byte[] popReceipt, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <NoResults> context) { RemainingTime remainingTime = new RemainingTime(timeout); SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters() { SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas, SignedResourceType = SasResourceType.Object, SignedPermission = SASPermission.Process }; SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter; NephosAssertionException.Assert(popReceipt != null); IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Delete, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.DeleteMessageImpl")); yield return(asyncResult); IQueueContainer operationStatus = this.EndGetQueue(asyncResult); if (requestContext != null) { operationStatus.OperationStatus = requestContext.OperationStatus; } try { Guid guid = new Guid(messageId); } catch (Exception exception) { throw new MessageNotFoundException("Invalid message name", exception); } IQueueMessageReceipt queueMessageReceipt = this.DecodeReceipt(popReceipt, new Guid(messageId)); operationStatus.Timeout = remainingTime; asyncResult = operationStatus.BeginDeleteMessage(queueMessageReceipt, context.GetResumeCallback(), context.GetResumeState("QueueManager.DeleteMessageImpl")); yield return(asyncResult); bool flag = operationStatus.EndDeleteMessage(asyncResult); IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug; object[] str = new object[] { flag, queueMessageReceipt.ToString() }; verboseDebug.Log("DeleteMessage response: status={0} message={1}", str); if (!flag) { throw new MessageNotFoundException("The message could not be deleted or pop receipt invalid."); } }
protected override IEnumerator <IAsyncResult> PutMessageImpl(IAccountIdentifier identity, string account, string queue, List <PushedMessage> messagesList, TimeSpan?timeout, RequestContext requestContext, bool usePutMessageRowCommand, AsyncIteratorContext <IEnumerable <PoppedMessage> > context) { TimeSpan timeSpan; RemainingTime remainingTime = new RemainingTime(timeout); SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters() { SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas, SignedResourceType = SasResourceType.Object, SignedPermission = SASPermission.Add }; SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter; IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Write, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.PutMessageImpl")); yield return(asyncResult); IQueueContainer operationStatus = this.EndGetQueue(asyncResult); if (requestContext != null) { operationStatus.OperationStatus = requestContext.OperationStatus; } object obj = messagesList; if (obj == null) { obj = Enumerable.Empty <PushedMessage>(); } foreach (PushedMessage pushedMessage in (IEnumerable <PushedMessage>)obj) { PushedMessage nullable = pushedMessage; TimeSpan? messageTTL = pushedMessage.MessageTTL; timeSpan = (messageTTL.HasValue ? messageTTL.GetValueOrDefault() : TimeSpan.FromSeconds((double)this.config.MaxTtlSeconds)); nullable.MessageTTL = new TimeSpan?(timeSpan); } operationStatus.Timeout = remainingTime; asyncResult = operationStatus.BeginPutMessage(messagesList, usePutMessageRowCommand, context.GetResumeCallback(), context.GetResumeState("QueueManager.PutMessageImpl")); yield return(asyncResult); List <IMessageData> messageDatas = operationStatus.EndPutMessage(asyncResult); context.ResultData = this.WrapGetMessageResults(messageDatas); IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug; verboseDebug.Log("PutMessage response: MessageId={0}", new object[] { context.ResultData }); }
private IEnumerator <IAsyncResult> GetQueueImpl(IAccountIdentifier identity, string account, string queue, PermissionLevel permission, SASAuthorizationParameters sasParams, ContainerPropertyNames propertyNames, TimeSpan timeout, RequestContext requestContext, AsyncIteratorContext <IQueueContainer> context) { RemainingTime remainingTime = new RemainingTime(timeout); IAsyncResult asyncResult = this.authorizationManager.BeginCheckAccess(identity, account, null, null, permission, sasParams, remainingTime, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetQueueImpl")); yield return(asyncResult); this.authorizationManager.EndCheckAccess(asyncResult); IStorageAccount storageAccount = this.storageManager.CreateAccountInstance(account); IQueueContainer queueContainer = storageAccount.CreateQueueContainerInstance(queue); queueContainer.Timeout = remainingTime; asyncResult = queueContainer.BeginGetProperties(propertyNames, null, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetQueueImpl")); yield return(asyncResult); queueContainer.EndGetProperties(asyncResult); context.ResultData = queueContainer; }
public MainWindow() { InitializeComponent(); CurrentPlayerId = GameSession.CurrentPlayer.RegNo; Timer = new DispatcherTimer(); Timer.Tick += Timer_Tick; Timer.Interval = new TimeSpan(0, 0, 1); RemainingTime = GameSession.RoundDetails.TimeLimit; _increment = 100 / RemainingTime.TotalSeconds; timeDisplayBlock.Text = RemainingTime.ToString(); Timer.Start(); this.DataContext = this; Manager.PushToLog(LogEvents.GameStart, GameSession.RoundDetails.RoundNo.ToString()); CommandManager.AddPreviewExecutedHandler(inputTextBox, HandleCommandExecution); lastText = inputTextBox.Text; }
protected override IEnumerator <IAsyncResult> UpdateMessageImpl(IAccountIdentifier identity, string account, string queue, string messageId, byte[] popReceipt, byte[] body, TimeSpan visibilityTimeout, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <PoppedMessage> context) { Guid guid; RemainingTime remainingTime = new RemainingTime(timeout); SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters() { SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas, SignedResourceType = SasResourceType.Object, SignedPermission = SASPermission.Update }; SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter; IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Write, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.UpdateMessageImpl")); yield return(asyncResult); IQueueContainer operationStatus = this.EndGetQueue(asyncResult); if (requestContext != null) { operationStatus.OperationStatus = requestContext.OperationStatus; } operationStatus.Timeout = remainingTime; try { guid = new Guid(messageId); } catch (Exception exception) { throw new MessageNotFoundException("Invalid message name", exception); } IQueueMessageReceipt queueMessageReceipt = this.DecodeReceipt(popReceipt, guid); TimeSpan? nullable = null; asyncResult = operationStatus.BeginUpdateMessage(queueMessageReceipt, body, visibilityTimeout, nullable, context.GetResumeCallback(), context.GetResumeState("QueueManager.UpdateMessageImpl")); yield return(asyncResult); IQueueMessageReceipt queueMessageReceipt1 = operationStatus.EndUpdateMessage(asyncResult); context.ResultData = this.GetPoppedMessageInfoFromReceipt(queueMessageReceipt1); }
public void Test_TaskScheduler_ShutDown () { var sequentialTaskScheduler = new SequentialTaskScheduler ( "TestScheduler" ); var taskFactory = new TaskFactory (sequentialTaskScheduler); var usageCount = 0; var firstTask = taskFactory.StartNew (() => {Thread.Sleep (500); ++usageCount;}); var secondTask = taskFactory.StartNew (() => {Thread.Sleep (500); ++usageCount;}); var stopwatch = new Stopwatch (); stopwatch.Start (); var remainingTime = new RemainingTime (TimeSpan.FromMilliseconds(4000)); sequentialTaskScheduler.ShutDown(remainingTime); stopwatch.Stop(); TestFor.Equality(true, stopwatch.ElapsedMilliseconds < 750, "Shutdwn time is expected to be less than 0.75 sec"); }
protected override IEnumerator <IAsyncResult> ListQueuesImpl(IAccountIdentifier identity, string account, string queuePrefix, string delimiter, string marker, int maxResults, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <IListQueuesResultCollection> context) { RemainingTime remainingTime = new RemainingTime(timeout); SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters() { SupportedSasTypes = SasType.AccountSas, SignedResourceType = SasResourceType.Service, SignedPermission = SASPermission.List }; SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter; IAsyncResult asyncResult = this.authorizationManager.BeginCheckAccess(identity, account, null, null, PermissionLevel.Read, sASAuthorizationParameter1, remainingTime, context.GetResumeCallback(), context.GetResumeState("QueueManager.ListQueuesImpl")); yield return(asyncResult); this.authorizationManager.EndCheckAccess(asyncResult); IStorageAccount storageAccount = this.storageManager.CreateAccountInstance(account); storageAccount.Timeout = remainingTime; asyncResult = storageAccount.BeginListQueueContainers(queuePrefix, ContainerPropertyNames.ApplicationMetadata, delimiter, marker, null, maxResults, context.GetResumeCallback(), context.GetResumeState("QueueManager.ListQueuesImpl")); yield return(asyncResult); context.ResultData = new ListQueuesResult(storageAccount.EndListQueueContainers(asyncResult)); }
public void ShutDown(RemainingTime remainingTime) { var thread = Interlocked.Exchange (ref m_executingThread, null); if (thread != null) { try { SignalShutDown (); var joinTimeOut = (int)remainingTime.Remaining.TotalMilliseconds/2; if (!thread.Join (joinTimeOut)) { Log.Warning ( "SequentialTaskScheduler.Dispose: {0} - Executing thread didn't shutdown, aborting it...", Name ); thread.Abort (); var abortTimeOut = remainingTime.Remaining; if (!thread.Join (abortTimeOut)) { Log.Warning ( "SequentialTaskScheduler.Dispose: {0} - Executing thread didn't shutdown after abort, ignoring it...", Name ); } } } catch (Exception exc) { Log.Exception ( "SequentialTaskScheduler.Dispose: {0} - Caught exception: {1}", Name, exc ); } } }