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
);
}
}
}
