public Relay(IJournal journal, RelayName name, ISignalsFactory signals)
{
mJournal = journal;
mOutput = signals.GetSignal(SensorName.Relay(name));
// TODO: uncomment
mFeedback = signals.GetSignal(SensorName.Relay(name, SignalName.Feedback));
if (mFeedback != null)
{
mFeedback.OnChange += FeedbackOnChange;
}
if (mOnTimeout == null)
{
mOnTimeout = signals.GetSignal("relay.feedback.on.timeout");
}
if (mFeedback != null)
{
mOnTimeout.OnUpdate += signal =>
{
var rv = signal.ValueAsInt < 1500 ? 1500 : signal.ValueAsInt > 6000 ? 6000 : signal.ValueAsInt;
mJournal.Debug(string.Format("Таймер реле (ОС) установлен в {0} мс для {1}", rv, mOutput.Specification.Id), MessageLevel.System);
mTask.SetTimeout(rv);
};
}
// задержка на контроль обратной связи по контактору по умолчанию
mTask = new DelayedTask(mOnTimeout == null ? 3000 : mOnTimeout.ValueAsInt < 1500 ? 1500 : mOnTimeout.ValueAsInt > 6000 ? 6000 : mOnTimeout.ValueAsInt);
mTask.OnTimeout += Checkout;
}
public void TestDelay1_Zero()
{
Task task = DelayedTask.Delay(TimeSpan.Zero);
Assert.IsTrue(task.IsCompleted);
Assert.AreEqual(TaskStatus.RanToCompletion, task.Status);
}
private HotKeyManager()
{
//if (Svc.Configuration != null)
//Initialize();
_delayedTask = new DelayedTask(SaveConfig);
}
private IJob ScheduleSequence(object repeatOpt = null)
{
IJob job = null;
Sequence sequence = Sequence.MakeInstance();
sequence.SetGroupTag(superInvokeTag);
float seqDelay = 0;
if (thereIsSequenceDelayToAdd)
{
seqDelay = sequenceDelayToAdd;
thereIsSequenceDelayToAdd = false;
}
for (int i = 0; i < tasks.Count; i++)
{
DelayedTask t = tasks[i];
SingleTask singleTask = SingleTask.MakeInstance(t.Method, seqDelay + t.DelayTime, null);
seqDelay = 0;
sequence.AddSingleTask(singleTask);
}
if (thereIsDelayToAdd)
{
SingleTask singleTask = SingleTask.MakeInstance(delegate {}, seqDelay + delayToAdd, null);
sequence.AddSingleTask(singleTask);
}
else if (tasks.Count == 0)
{
SingleTask singleTask = SingleTask.MakeInstance(delegate {}, seqDelay, null);
sequence.AddSingleTask(singleTask);
}
if (repeatOpt != null)
{
RepeatSettings repeatSettings = (RepeatSettings)repeatOpt;
JobRepeat jobRepeat = new JobRepeat()
{
TotalRepeatsNumber = repeatSettings.repeats
};
sequence.SetIterativeMode(repeatSettings);
job = jobRepeat;
}
else
{
job = new Job();
}
sequence.SetJob(job);
ScheduleBridge.Schedule(sequence);
ResetStuff();
return(job);
}
public void TestDelay2_NoCancel_Zero()
{
Task task = DelayedTask.Delay(TimeSpan.Zero, CancellationToken.None);
Assert.IsTrue(task.IsCompleted);
Assert.AreEqual(TaskStatus.RanToCompletion, task.Status);
}
private HotKeyManager()
{
//if (_cfgSvc != null)
//Initialize();
_delayedTask = new DelayedTask(SaveConfig);
}
public static void onSyncTick()
{
while (syncTasks.Count > 0)
{
ThreadStart ts = syncTasks.Dequeue();
if (ts != null)
{
ts.Invoke();
}
}
for (LinkedListNode <DelayedTask> node = delayedTasks.First; node != null && node != delayedTasks.Last; node = node.Next)
{
DelayedTask task = node.Value;
task.currentDelayCount--;
if (task.currentDelayCount <= 0)
{
if (task.isAsync)
{
runTaskAsynchronously(task.threadStart);
}
else
{
runTaskSynchronously(task.threadStart);
}
if (task.repeat)
{
task.currentDelayCount = task.delay;
}
else
{
delayedTasks.Remove(node);
}
}
}
}
public void TestDelay2_CancelAfter_GCBehavior()
{
using (CancellationTokenSource cts = new CancellationTokenSource())
{
Stopwatch timer = Stopwatch.StartNew();
TimeSpan cancelAfter = TimeSpan.FromSeconds(0.25);
TimeSpan tolerance = TimeSpan.FromSeconds(0.025);
cts.CancelAfter(cancelAfter);
TimeSpan timeout = TimeSpan.FromSeconds(1);
Task delayTask = DelayedTask.Delay(timeout, cts.Token);
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true);
try
{
delayTask.Wait();
Assert.Fail("Expected an exception.");
}
catch (AggregateException ex)
{
Assert.AreEqual(TaskStatus.Canceled, delayTask.Status);
Assert.AreEqual(1, ex.InnerExceptions.Count);
Assert.IsInstanceOfType(ex.InnerExceptions[0], typeof(TaskCanceledException));
}
TimeSpan elapsed = timer.Elapsed;
Assert.IsTrue(elapsed >= cancelAfter - tolerance, "The Delay expired too soon ({0} sec < {1} sec).", elapsed.TotalSeconds, (cancelAfter - tolerance).TotalSeconds);
Assert.IsTrue(elapsed <= cancelAfter + tolerance, "The Delay expired too late ({0} sec > {1} sec).", elapsed.TotalSeconds, (cancelAfter + tolerance).TotalSeconds);
}
}
public void TestDelay1_Negative_Fractional()
{
TimeSpan delay = TimeSpan.FromTicks(-100);
Task task = DelayedTask.Delay(delay);
Assert.IsTrue(task.IsCompleted);
Assert.AreEqual(TaskStatus.RanToCompletion, task.Status);
}
public static void Init(IJournal journal, ISignalsFactory signals)
{
mRelay = new Relay(journal, RelayName.Kv4, signals);
mOnTimeout = signals.GetSignal("soundalarm.on.timeout");
mOnTimeout.OnUpdate += signal =>
{
var rv = signal.ValueAsInt < 1500 ? 1500 : signal.ValueAsInt > 6000 ? 6000 : signal.ValueAsInt;
journal.Debug(string.Format("Таймер вкл. сирены установлен в {0} мс", rv), MessageLevel.System);
mTask.SetTimeout(rv);
};
mOffTimeout = signals.GetSignal("soundalarm.off.timeout");
mOffTimeout.OnUpdate += signal =>
{
var rv = signal.ValueAsInt < 2500 ? 2500 : signal.ValueAsInt > 10000 ? 10000 : signal.ValueAsInt;
journal.Debug(string.Format("Таймер выкл. сирены установлен в {0} мс", rv), MessageLevel.System);
mUnlockInterval = rv;
};
// values by default
mTask = new DelayedTask(mOnTimeout.ValueAsInt); // 1500
mUnlockInterval = mOffTimeout.ValueAsInt; // 5000
mTask.OnTimeout += ProcessTimerEvent;
}
public async Task TestCancel(int timeout)
{
bool executed = false;
var delayedTask = new DelayedTask(() =>
{
executed = true;
return(Task.CompletedTask);
}, 500);
Assert.IsNull(delayedTask.Canceled);
await Task.Delay(100).ConfigureAwait(false);
delayedTask.Cancel();
if (timeout < 0)
{
await delayedTask.Task.ConfigureAwait(false);
}
else
{
await Task.Delay(timeout).ConfigureAwait(false);
}
Assert.IsTrue(delayedTask.Canceled ?? false);
Assert.IsFalse(executed);
}
public void GetJuggernautTrainerFromServer(string trainerUID, int sceneViewID, int recursionCount)
{
int num = 100;
Character character = CharacterManager.Instance.GetCharacter(trainerUID);
bool flag = character != null;
if (flag)
{
JuggernautTrainer.SetupTrainerClientSide(character.gameObject, sceneViewID);
}
else
{
bool flag2 = recursionCount * num < 5000;
if (flag2)
{
DelayedTask.GetTask(num).ContinueWith(delegate(Task _)
{
this.GetJuggernautTrainerFromServer(trainerUID, sceneViewID, recursionCount + 1);
});
Console.Read();
}
else
{
Debug.Log("Juggernaut could not fetch trainer ID from Server");
}
}
}
protected ComRrConnection(ComRRRequest request,
int requestLength,
byte requestHeader,
int responseLength,
byte responseHeader,
int timeout,
object info,
ComPortWithThreshold port,
ComPortWithThresholdSettings portSettings,
Action <ComRrConnection> onDone)
{
Request = request;
this.requestLength = requestLength;
this.requestHeader = requestHeader;
this.responseLength = responseLength;
this.responseHeader = responseHeader;
Responses = new List <ComRRResponse>();
this.port = port;
this.portSettings = portSettings;
finished = onDone;
Info = info;
timeoutTask = new DelayedTask(onTimeout, timeout);
State = ComRRConnectionStates.None;
ResponsePackets = new List <List <byte> >();
}
public void TestDelay2_Uncancel_Negative()
{
using (CancellationTokenSource cts = new CancellationTokenSource())
{
TimeSpan delay = TimeSpan.FromSeconds(-1);
DelayedTask.Delay(delay, cts.Token);
}
}
public void TestDelay2_Uncancel_Zero()
{
using (CancellationTokenSource cts = new CancellationTokenSource())
{
Task task = DelayedTask.Delay(TimeSpan.Zero, cts.Token);
Assert.IsTrue(task.IsCompleted);
Assert.AreEqual(TaskStatus.RanToCompletion, task.Status);
}
}
public void TestNoForcedGCAllowsTimer()
{
bool executed = false;
new Timer(_ => executed = true, null, TimeSpan.FromSeconds(0.4), TimeSpan.FromMilliseconds(-1));
DelayedTask.Delay(TimeSpan.FromSeconds(0.6)).Wait();
Assert.IsTrue(executed);
}
public void TestDelay2_Uncancel_Negative_Fractional()
{
using (CancellationTokenSource cts = new CancellationTokenSource())
{
TimeSpan delay = TimeSpan.FromTicks(-100);
Task task = DelayedTask.Delay(delay, cts.Token);
Assert.IsTrue(task.IsCompleted);
Assert.AreEqual(TaskStatus.RanToCompletion, task.Status);
}
}
async Task ChangeQuestion()
{
AcceptMessages = false;
StopQuestionTimer();
foreach (var gameplayer in GamePlayers)
{
await Program.Server.Client.SendChatActionAsync(gameplayer.Player.ChatId, ChatAction.Typing);
gameplayer.Answered = false;
}
if (QuestionNum == 0)
{
SendToAll.SendText(GamePlayers, "First question:");
}
else if (QuestionNum == GameConfig.QuestionsPerGame)
{
SendToAll.SendText(GamePlayers, "Last question:");
}
else if (QuestionNum > GameConfig.QuestionsPerGame)
{
SendToAll.SendText(GamePlayers, "Playing untill getting winner:");
}
else
{
SendToAll.SendText(GamePlayers, "Question " + QuestionNum + ":");
}
Question = QuestionSelector.SelectQuestion();
QuestionNum++;
await Task.Delay(250);
var outtext = Question.QuestionText;
int i = 0;
foreach (var answer in Question.Answers)
{
i++;
outtext += "\n" + i + ") " + answer;
}
SendToAll.SendText(GamePlayers, outtext);
AcceptMessages = true;
TillNewQuestionDelayer = DelayedTask.DelayTask(new List <DelayedTask>()
{
new DelayedTask(() => ChangeQuestion(), 60),
new DelayedTask(() => SendToAll.SendText(GamePlayers, "30 seconds remaining"), 30),
new DelayedTask(() => SendToAll.SendText(GamePlayers, "15 seconds remaining"), 45),
new DelayedTask(() => SendToAll.SendText(GamePlayers, "5 seconds remaining"), 55)
});
}
void StartDelay()
{
Delayer = DelayedTask.DelayTask(new List <DelayedTask>()
{
new DelayedTask(() => StartGame(), 60),
new DelayedTask(() => SendToAll.SendText(Players.ToArray(), "Game will start in 60 seconds."), 0),
new DelayedTask(() => SendToAll.SendText(Players.ToArray(), "Game will start in 30 seconds."), 30),
new DelayedTask(() => SendToAll.SendText(Players.ToArray(), "Game will start in 15 seconds."), 45),
new DelayedTask(() => SendToAll.SendText(Players.ToArray(), "Game will start in 5 seconds."), 55)
});
}
public void TestDelay2_CancelAfter_Negative()
{
using (CancellationTokenSource cts = new CancellationTokenSource())
{
TimeSpan cancelAfter = TimeSpan.FromSeconds(0.25);
cts.CancelAfter(cancelAfter);
TimeSpan delay = TimeSpan.FromSeconds(-1);
DelayedTask.Delay(delay, cts.Token);
}
}
public LayoutEditorWindow(XamlLayout xamlLayout)
{
OriginalLayout = xamlLayout;
NewLayout = new XamlLayout(xamlLayout, autoValidationSuspended: true);
NewLayout.XamlChanged += OnXamlChanged;
IsDefault = OriginalLayout.IsDefault;
_parseXamlTask = new DelayedTask(ParseXaml);
InitializeComponent();
}
public void TestDelay2_CancelAfter_Zero()
{
using (CancellationTokenSource cts = new CancellationTokenSource())
{
TimeSpan cancelAfter = TimeSpan.FromSeconds(0.25);
cts.CancelAfter(cancelAfter);
Task task = DelayedTask.Delay(TimeSpan.Zero, cts.Token);
Assert.IsTrue(task.IsCompleted);
Assert.AreEqual(TaskStatus.RanToCompletion, task.Status);
}
}
public void TestDelay1_Timing()
{
TimeSpan timeout = TimeSpan.FromSeconds(0.25);
TimeSpan tolerance = TimeSpan.FromSeconds(0.025);
Stopwatch timer = Stopwatch.StartNew();
DelayedTask.Delay(timeout).Wait();
TimeSpan elapsed = timer.Elapsed;
Assert.IsTrue(elapsed >= timeout - tolerance, "The Delay expired too soon ({0} sec < {1} sec).", elapsed.TotalSeconds, (timeout - tolerance).TotalSeconds);
Assert.IsTrue(elapsed <= timeout + tolerance, "The Delay expired too late ({0} sec > {1} sec).", elapsed.TotalSeconds, (timeout + tolerance).TotalSeconds);
}
public static void Init(IJournal journal, ISignalsFactory signals)
{
mJournal = journal;
TankSensorHandler.Init(journal, signals);
//TankSensorHandler.OnError += OnErrorCaller;
//TankSensorHandler.OnWarning += OnWarningCaller;
BrakePressureHandler.Init(journal, signals);
//BrakePressureHandler.OnError += OnErrorCaller;
//BrakePressureHandler.OnWarning += OnWarningCaller;
SteeringPressureHandler.Init(journal, signals);
//SteeringPressureHandler.OnError += OnErrorCaller;
//SteeringPressureHandler.OnWarning += OnWarningCaller;
CabelPressureHandler.Init(journal, signals);
//CabelPressureHandler.OnError += OnErrorCaller;
//CabelPressureHandler.OnWarning += OnWarningCaller;
AlarmStopTimeout = (ushort)(signals.GetSignal("pump.alarm.shutdown.timeout").Value *1000);
// делаем отключение асинхронным - команда на стоп не связана с реальной остановкой двигателя
mTaskPumpStop = new DelayedTask(100);
mTaskPumpStop.OnTimeout += sender =>
{
mTaskPumpStop.Stop();
// TODO: тут может понадобится пауза между отключением частотников и насосной станцией
mRelay.Off();
mStartAt = DateTime.MaxValue; // выключаем
if (mState.ValueAsInt != (uint)EquipmentState.Failure)
{
mState.Update((uint)EquipmentState.Stop);
}
};
mRelay = new Relay(journal, RelayName.Kv11, signals);
mRelay.OnError += sensor => OnErrorCaller(SystemStateCodes.Alarm.Kv11OutOfControl);
mCord = new Cord(signals.GetSignal(SensorName.Cord(1)));
mCord.OnChange += sensor =>
{
if (sensor.IsSet)
{
OnErrorCaller(SystemStateCodes.Alarm.Cord1OutOfControl);
}
};
mState = signals.GetSignal(SensorName.Derivative(SystemName.Pump, SignalName.Status));
}
public void TestDelay2_NoCancel_Timing()
{
TimeSpan timeout = TimeSpan.FromSeconds(0.25);
Stopwatch timer = Stopwatch.StartNew();
DelayedTask.Delay(timeout, CancellationToken.None).Wait();
TimeSpan elapsed = timer.Elapsed;
Assert.IsTrue(elapsed >= timeout - AdvanceTolerance, "The Delay expired too soon ({0} sec < {1} sec).", elapsed.TotalSeconds, (timeout - AdvanceTolerance).TotalSeconds);
Assert.IsTrue(elapsed <= timeout + DelayTolerance, "The Delay expired too late ({0} sec > {1} sec).", elapsed.TotalSeconds, (timeout + DelayTolerance).TotalSeconds);
}
public void TestDelay2_PreCancel_Timing()
{
using (CancellationTokenSource cts = new CancellationTokenSource())
{
cts.Cancel();
TimeSpan timeout = TimeSpan.FromSeconds(0.25);
Task task = DelayedTask.Delay(timeout, cts.Token);
Assert.IsTrue(task.IsCompleted);
Assert.AreEqual(TaskStatus.Canceled, task.Status);
}
}
public void TestForcedGCHaltsTimer()
{
bool executed = false;
new Timer(_ => executed = true, null, TimeSpan.FromSeconds(0.4), TimeSpan.FromMilliseconds(-1));
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
GC.WaitForFullGCComplete();
DelayedTask.Delay(TimeSpan.FromSeconds(0.6)).Wait();
Assert.IsFalse(executed);
}
public void TestDelay2_Uncancel_Timing()
{
using (CancellationTokenSource cts = new CancellationTokenSource())
{
TimeSpan timeout = TimeSpan.FromSeconds(0.25);
TimeSpan tolerance = TimeSpan.FromSeconds(0.025);
Stopwatch timer = Stopwatch.StartNew();
DelayedTask.Delay(timeout, cts.Token).Wait();
TimeSpan elapsed = timer.Elapsed;
Assert.IsTrue(elapsed >= timeout - tolerance, "The Delay expired too soon ({0} sec < {1} sec).", elapsed.TotalSeconds, (timeout - tolerance).TotalSeconds);
Assert.IsTrue(elapsed <= timeout + tolerance, "The Delay expired too late ({0} sec > {1} sec).", elapsed.TotalSeconds, (timeout + tolerance).TotalSeconds);
}
}
public async Task StartSendPriorityMessage(Message message, IClient exclude, long excludeFcmAccountId)
{
var sessions = await database.ChannelMembers.AsQueryable()
.Where(m => m.ChannelId == message.ChannelId)
.Join(database.Sessions, m => m.AccountId, s => s.AccountId, (m, s) => new { s.AccountId, s.SessionId })
.OrderBy(s => s.AccountId)
.ToArrayAsync().ConfigureAwait(false);
long lastAccountId = default;
DelayedTask lastTimer = null;
foreach (var session in sessions)
{
if (session.AccountId != lastAccountId)
{
lastAccountId = session.AccountId;
lastTimer = new DelayedTask(() =>
{
if (session.AccountId != excludeFcmAccountId)
{
return(notification.SendFcmNotification(session.AccountId));
}
else
{
return(Task.CompletedTask);
}
}, fcmOptions.Value.PriorityMessageAckTimeout);
}
// Declare a separate variable that can be safely captured and is not changed with the next iteration
DelayedTask timer = lastTimer;
void callback(IClient client, Packet packet)
{
if (packet is P22MessageReceived received && received.Dependencies[0].MessageId == message.MessageId)
{
timer.Cancel(); // Cancel timer because message has been received
client.PacketReceived -= callback;
}
}
if (connections.TryGet(session.SessionId, out IClient client) && !ReferenceEquals(client, exclude))
{
client.PacketReceived += callback;
_ = client.Enqueue(message.ToPacket(packets, client.AccountId));
}
}
}
public ISuperInvokeSequence AddMethod(Action method, float delay = 0)
{
CheckMethod(method);
CheckDelay(delay);
DelayedTask task = new DelayedTask(method, delay);
if (thereIsDelayToAdd)
{
task.DelayTime += delayToAdd;
thereIsDelayToAdd = false;
}
tasks.Add(task);
return(this);
}
