/// <summary> /// Асинхронная смена сценария /// </summary> /// <returns></returns> private async Task ChangeScenarioAsync(string fileName, bool isQuickLoad) { if (isQuickLoad) { mFileName = fileName; await ProgressDialogService.ExecuteAsync(LoadAsync).ConfigureAwait(false); } else { await TaskExtension.Delay(1).ConfigureAwait(false); var dialog = new OpenFileDialog { Filter = "Файл с описанием сценария (xmlinfo)|*.xmlinfo" }; if (!string.IsNullOrEmpty(DataHolder.Instance.FullFolderPath)) { dialog.InitialDirectory = DataHolder.Instance.FullFolderPath; dialog.FileName = Path.Combine(DataHolder.Instance.FullFolderPath, Constants.cScenarioDescriptor); } if (dialog.ShowDialog() == true) { mFileName = dialog.FileName; await ProgressDialogService.ExecuteAsync(LoadAsync).ConfigureAwait(false); } } }
async Task TrySendKeepAliveMessagesAsync(CancellationToken cancellationToken) { try { _logger.Verbose("Start sending keep alive packets."); var keepAlivePeriod = Options.KeepAlivePeriod; while (!cancellationToken.IsCancellationRequested) { // Values described here: [MQTT-3.1.2-24]. var waitTime = keepAlivePeriod - _sendTracker.Elapsed; if (waitTime <= TimeSpan.Zero) { await SendAndReceiveAsync <MqttPingRespPacket>(new MqttPingReqPacket(), cancellationToken).ConfigureAwait(false); } // Wait a fixed time in all cases. Calculation of the remaining time is complicated // due to some edge cases and was buggy in the past. Now we wait half a second because the // min keep alive value is one second so that the server will wait 1.5 seconds for a PING // packet. await TaskExtension.Delay(TimeSpan.FromMilliseconds(100), cancellationToken).ConfigureAwait(false); } } catch (Exception exception) { if (_cleanDisconnectInitiated) { return; } if (exception is OperationCanceledException) { } else if (exception is MqttCommunicationException) { _logger.Warning(exception, "Communication error while sending/receiving keep alive packets."); } else { _logger.Error(exception, "Error exception while sending/receiving keep alive packets."); } if (!DisconnectIsPending()) { await DisconnectInternalAsync(_keepAlivePacketsSenderTask, exception, null).ConfigureAwait(false); } } finally { _logger.Verbose("Stopped sending keep alive packets."); } }
private async Task CreateNewScenarioAsync(CancellationToken token) { await await Task.Factory.StartNew(async() => { if (MessageBox.Show(Constants.cInsureCreateScenarioText, Constants.cAttention, MessageBoxButton.YesNo) == MessageBoxResult.No) { await TaskExtension.Delay(1); return; } await DataHolder.Instance.ReleaseMedia(false, null, token); await DataHolder.Instance.ClearAllData().ConfigureAwait(false); await UnselectCurrentScenario(); await DataHolder.Instance.CreateStartUpData().ConfigureAwait(false); }, token, TaskCreationOptions.AttachedToParent, TaskScheduler.FromCurrentSynchronizationContext()); IndicatorCreate = Indicators.Warn.GetColor(); }
/// <summary> /// Асинхронная загрузка сценария /// </summary> /// <param name="cancellation"></param> /// <param name="progress"></param> /// <returns></returns> private async Task LoadAsync(CancellationToken cancellation, IProgress <string> progress) { await await Task.Factory.StartNew(async() => { await DataHolder.Instance.ReleaseMedia(false, progress, cancellation); progress.Report("Загрузка данных"); Thread.Sleep(3000); if (DataHolder.Instance.LoadAllData(mFileName, progress, cancellation)) { Debug.Assert(Path.GetDirectoryName(mFileName) != null, "Path.GetDirectoryName(mFileName) != null"); } else { while (true) { if (cancellation.IsCancellationRequested) { break; } Thread.Sleep(100); } } if (cancellation.IsCancellationRequested) { await DataHolder.Instance.ClearAllData(); return(TaskExtension.Delay(1)); } DispatcherServices.BeginInvoke(() => { DynamicText = Constants.cChangeScenarioText; IndicatorLoad = Indicators.Warn.GetColor(); IndicatorCreate = Indicators.Warn.GetColor(); IndicatorSave = Indicators.Accept.GetColor(); ScenarioItem loadedScenario = Scenarios.FirstOrDefault(s => s.ScenarioInfo.Key.Equals(mFileName)); if (loadedScenario == null) { loadedScenario = new ScenarioItem(new KeyValuePair <string, string>(mFileName, DataHolder.Instance.ScenarioProperties.ScenarioName)); loadedScenario.Selecting += NewScenatioItemOnSelecting; Scenarios.Add(loadedScenario); } loadedScenario.SelecteItem(); }); return(TaskExtension.Delay(1)); }, cancellation).ConfigureAwait(false); }
private static async Task Main(string[] args) { try { Program.config = new ConfigService(); Startup.Configure(Program.config); Program.services = new ServiceCollection(); Program.services.AddSingleton <ConfigService>(Program.config); Program.services.AddSingleton <App>(); Startup.ConfigureServices(Program.services, Program.config); Program.provider = Program.services.BuildServiceProvider(); Program.app = provider.GetRequiredService <App>(); Program.logger = provider.GetService <Logger>(); Program.cancellation = provider.GetService <CancellationTokenSource>(); Console.CancelKeyPress += (_, eventArgs) => { eventArgs.Cancel = true; Program.cancellation?.Cancel(); }; await Program.app.RunAsync(); await TaskExtension.Delay(-1, Program.cancellation); } catch (TaskCanceledException ex) { Program.Out(LogEventLevel.Debug, ex.Message); } catch (Exception ex) { Program.Out(LogEventLevel.Fatal, ex); } finally { Log.CloseAndFlush(); } Program.Out(LogEventLevel.Information, "The End!"); }
/// <summary> /// Асинхронная выгрузка сценария /// </summary> /// <param name="path">путь к выгрузки</param> /// <param name="cancellation"></param> /// <param name="progress"></param> /// <param name="rewrite">True-перезаписать старые данные</param> /// <returns></returns> private async Task UploadScenarioAsync(string path, CancellationToken cancellation, IProgress <string> progress, bool rewrite = true) { await Task.Factory.StartNew(async() => { progress.Report("Сохранение сценария"); Thread.SpinWait(1000); DataHolder.Instance.TargetDirectory = path; if (rewrite) { progress.Report("Очистка старых данных"); DataHolder.Instance.PrepareForRewriteScenario(); } if (!DataHolder.Instance.UpLoadData(path, progress, cancellation)) { // DataHolder.Instance.ScenarioProperties.Folder = Path.GetDirectoryName(mFileName); //else while (true) { if (cancellation.IsCancellationRequested) { break; } Thread.Sleep(100); } } if (cancellation.IsCancellationRequested) { await DataHolder.Instance.ClearAllData(); return(TaskExtension.Delay(1)); } DispatcherServices.BeginInvoke(() => { DynamicText = Constants.cChangeScenarioText; IndicatorLoad = Indicators.Warn.GetColor(); IndicatorCreate = Indicators.Warn.GetColor(); IndicatorSave = Indicators.Accept.GetColor(); }); return(TaskExtension.Delay(1)); }, cancellation).Unwrap().ConfigureAwait(false); }
public async Task RunAsync() { using IConnection connection = this.connectionFactory.CreateConnection(); using IModel channel = connection.CreateModel(); try { AsyncEventingBasicConsumer consumer = new AsyncEventingBasicConsumer(channel); consumer.Received += async(_, eventArgs) => { await this.Callback?.Invoke(eventArgs) !; await Task.Yield(); }; channel.BasicConsume( queue: this.configService.QueueConfig.Rabbit.Queue, autoAck: true, consumer: consumer ); this.logger?.Debug("Subscribed to {queue}", this.configService.QueueConfig.Rabbit.Queue); await TaskExtension.Delay(-1, this.cancellationTokenSource); } catch (OperationCanceledException ex) { this.logger?.Debug(ex.Message); } catch (Exception ex) { this.logger?.Error(ex, ex.Message); } finally { connection.Close(); } }
async Task RunAsync(int keepAlivePeriod, CancellationToken cancellationToken) { try { _lastPacketReceivedTracker.Restart(); while (!cancellationToken.IsCancellationRequested) { // Values described here: [MQTT-3.1.2-24]. // If the client sends 5 sec. the server will allow up to 7.5 seconds. // If the client sends 1 sec. the server will allow up to 1.5 seconds. if (!_isPaused && _lastPacketReceivedTracker.Elapsed.TotalSeconds >= keepAlivePeriod * 1.5D) { _logger.Warning(null, "Client '{0}': Did not receive any packet or keep alive signal.", _clientId); await _keepAliveElapsedCallback().ConfigureAwait(false); return; } // The server checks the keep alive timeout every 50 % of the overall keep alive timeout // because the server allows 1.5 times the keep alive value. This means that a value of 5 allows // up to 7.5 seconds. With an interval of 2.5 (5 / 2) the 7.5 is also affected. Waiting the whole // keep alive time will hit at 10 instead of 7.5 (but only one time instead of two times). await TaskExtension.Delay(TimeSpan.FromSeconds(keepAlivePeriod * 0.5D), cancellationToken).ConfigureAwait(false); } } catch (OperationCanceledException) { } catch (Exception exception) { _logger.Error(exception, "Client '{0}': Unhandled exception while checking keep alive timeouts.", _clientId); } finally { _logger.Verbose("Client '{0}': Stopped checking keep alive timeout.", _clientId); } }
#pragma warning disable 4014 async Task AcceptClientConnectionsAsync(CancellationToken cancellationToken) { while (!cancellationToken.IsCancellationRequested) { try { var clientSocket = await _socket.AcceptAsync().ConfigureAwait(false); if (clientSocket == null) { continue; } #if NET40 TaskExtension.Run(() => TryHandleClientConnectionAsync(clientSocket).Wait(), cancellationToken).Forget(_logger); #else TaskExtension.Run(() => TryHandleClientConnectionAsync(clientSocket), cancellationToken).Forget(_logger); #endif } catch (OperationCanceledException) { } catch (Exception exception) { if (exception is SocketException socketException) { if (socketException.SocketErrorCode == SocketError.ConnectionAborted || socketException.SocketErrorCode == SocketError.OperationAborted) { continue; } } _logger.Error(exception, $"Error while accepting connection at TCP listener {_localEndPoint} TLS={_tlsCertificate != null}."); await TaskExtension.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false); } } }
/// <summary> /// Проверка параметров загрузки сценария /// </summary> /// <param name="param"></param> /// <param name="fileName"></param> /// <param name="loadingMode"></param> /// <returns></returns> private async Task <bool> CheckLoadParameter(object param, string fileName, bool loadingMode) { bool result = false; if (IndicatorLoad.IsEqual(Indicators.Warn.GetColor())) { if (MessageBox.Show(Constants.cInsureChangeScenarioText, Constants.cAttention, MessageBoxButton.YesNo) == MessageBoxResult.Yes) { await ChangeScenarioAsync(fileName, loadingMode).ConfigureAwait(false); result = true; } } else if (IndicatorLoad.IsEqual(Indicators.Accept.GetColor())) { await ChangeScenarioAsync(fileName, loadingMode).ConfigureAwait(false); result = true; } await TaskExtension.Delay(1); CommandManager.InvalidateRequerySuggested(); return(await TaskExtension.FromResult(result)); }
/// <summary> /// Асинхронное сохранение сценария /// </summary> /// <returns></returns> private async Task SaveScenarioHandlerAsync(object param) { if (IndicatorSave.IsEqual(Indicators.Accept.GetColor())) { if (!DataHolder.Instance.SlideDataHolders.Any(x => (x as ISaveValidator).With(valid => valid.OwnScenarioTypes.Contains(DataHolder.Instance.ScenarioProperties.ScenarioType) && !valid.IsValid))) { var dialog = new FolderBrowserDialog { SelectedPath = DataHolder.Instance.FullFolderPath }; if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK) { await DataHolder.Instance.ReleaseMedia(true, null, new CancellationToken()); string directoryName = dialog.SelectedPath; IEnumerable <string> scenarioInfos = Directory.GetFiles(directoryName) .ToList() .Where(x => x.Contains(".xmlinfo")) .Select(Path.GetFileName) .ToList(); if (!scenarioInfos.Any()) { await ProgressDialogService.ExecuteAsync((cancellation, progress) => UploadScenarioAsync(dialog.SelectedPath, cancellation, progress)).ConfigureAwait(false); } else if (scenarioInfos.Any(x => x == Constants.cScenarioDescriptor)) { switch (MessageBox.Show(Application.Current.MainWindow, Constants.cInsureRewriteScenario, "Сохранение сценария", MessageBoxButton.YesNo)) { case MessageBoxResult.Yes: await ProgressDialogService.ExecuteAsync(async (cancellation, progress) => await UploadScenarioAsync(dialog.SelectedPath, cancellation, progress)).ConfigureAwait(false); break; case MessageBoxResult.No: await TaskExtension.Delay(1); return; } } else { await ProgressDialogService.ExecuteAsync((cancellation, progress) => UploadScenarioAsync(dialog.SelectedPath, cancellation, progress)).ConfigureAwait(false); } } } else { MessageBox.Show(string.Format("Данный Сценарий нельзя сохранить. Проверьте правильность запонения следующих вкладок для корректного сохранения \n{0}", DataHolder.Instance.SlideDataHolders.Where(x => (x as ISaveValidator).With(valid => valid.OwnScenarioTypes.Contains(DataHolder.Instance.ScenarioProperties.ScenarioType) && !valid.IsValid)).Select(x => x.Name).EnumerableToString("{0}\n")), Constants.cScenarioEditorTitle, MessageBoxButton.OK, MessageBoxImage.Error); } } else { throw new NotImplementedException("ScenarioEditor.ViewModel.ViewModels.StartPageViewModelsSaveScenarioHandlerAsync"); } await TaskExtension.Delay(1); CommandManager.InvalidateRequerySuggested(); }