private async Task UpdateProjectReverseAsync(CancellationManager cmSelf) { try { while (true) { if (cmSelf.Token.IsCancellationRequested) { cmSelf.Token.ThrowIfCancellationRequested(); } var proxy = new MonitorRepository(); try { await proxy.UpdateProjectReverseAsync(); } catch (Exception ex) { LogManager.Instance.Error($"{ex.Message}"); } LastUpdate = DateTime.Now; await Task.Delay(FREQ_UPDATE); } } catch (Exception) { //do nothing } finally { cmSelf.Dispose(); } }
// GET: api/CancellationBooking/5 public IHttpActionResult Get(string bookingNumber) { CancellationManager cancellation = new CancellationManager(); cancellation.CancelForAllProviders(bookingNumber); return(Ok(cancellation.cancelData)); }
public virtual void Handle(T item) { if (Handler != null) { CancellationManager.CheckForSignal(); Handler.Handle(item); } }
public CallCollector(CancellationManager cancellationManager) : this() { this.CancellationManager = cancellationManager; this.token = this.CancellationManager.GetToken(); this.Services = new ConcurrentDictionary <Type, CallAggregationServiceDescription>(); this.CallResults = new ConcurrentDictionary <CallAggregationCallDescription, TaskResultDispatcher>(); }
private async Task <bool> LoginBulkAsync(CancellationManager manager) { try { var ctrls = new List <UcSettingAccountItem>(); foreach (Control ctrl in flowAccount.Controls) { var ctrlAccount = ctrl as UcSettingAccountItem; if (ctrlAccount != null) { if (!ctrlAccount.IsEnabled) { ctrls.Add(ctrlAccount); } } } var delayMax = chkLoginProtect.Checked ? 30 : 0; var delayMin = chkLoginProtect.Checked ? 5 : 0; var rd = new Random(DateTime.Now.Second); ctrls = ctrls.OrderBy(c => rd.Next()).ToList(); for (var i = 0; i < ctrls.Count; i++) { if (!manager.Token.IsCancellationRequested) { var ctrlAccount = ctrls[i]; await ctrlAccount.TryLogin(); if (i == ctrls.Count - 1) { break; } await Task.Delay(rd.Next(delayMin, delayMax) * 1000); } else { manager.Token.ThrowIfCancellationRequested(); } } } catch (Exception) { //do nothing } finally { manager.Dispose(); } return(true); }
/// <summary> /// Instantiates a prompt object. This object can be re-used for multiple invocations of <see cref="ReadLineAsync()"/>. /// </summary> /// <param name="persistentHistoryFilepath">The filepath of where to store history entries. If null, persistent history is disabled.</param> /// <param name="callbacks">A collection of callbacks for modifying and intercepting the prompt's behavior</param> /// <param name="console">The implementation of the console to use. This is mainly for ease of unit testing</param> /// <param name="configuration">If null, default configuration is used.</param> public Prompt( string?persistentHistoryFilepath = null, PromptCallbacks?callbacks = null, IConsole?console = null, PromptConfiguration?configuration = null) { this.console = console ?? new SystemConsole(); this.console.InitVirtualTerminalProcessing(); this.configuration = configuration ?? new PromptConfiguration(); this.history = new HistoryLog(persistentHistoryFilepath, this.configuration.KeyBindings); this.cancellationManager = new CancellationManager(this.console); this.clipboard = (console is IConsoleWithClipboard consoleWithClipboard) ? consoleWithClipboard.Clipboard : new Clipboard(); promptCallbacks = callbacks ?? new PromptCallbacks(); this.highlighter = new SyntaxHighlighter(promptCallbacks, PromptConfiguration.HasUserOptedOutFromColor); }
/// <summary> /// Ported from void global_scope_t::report_error(const std::exception& err) /// </summary> public void ReportError(Exception ex) { VirtualConsole.Output.Flush(); // first display anything that was pending if (!CancellationManager.IsCancellationRequested) { // Display any pending error context information string context = ErrorContext.Current.GetContext(); if (!String.IsNullOrWhiteSpace(context)) { VirtualConsole.Error.WriteLine(context); } VirtualConsole.Error.WriteLine(String.Format("Error: {0}", ex.Message)); } else { CancellationManager.DiscardCancellationRequest(); } }
private async Task RefreshAsync(CancellationManager cmSelf) { try { while (true) { if (cmSelf.Token.IsCancellationRequested) { cmSelf.Token.ThrowIfCancellationRequested(); } BindMessage(); await Task.Delay(FREQ_REFRESH); } } catch (Exception) { //do nothing } finally { cmSelf.Dispose(); } }
public void CancellationManager_DiscardCancellationRequest_RestoresDefaultSignalValue() { MainApplicationContext.Current.CancellationSignal = CaughtSignalEnum.INTERRUPTED; CancellationManager.DiscardCancellationRequest(); Assert.Equal(CaughtSignalEnum.NONE_CAUGHT, MainApplicationContext.Current.CancellationSignal); }
public void CancellationManager_CheckForSignal_RaisesRTEIfSomethingCaught() { MainApplicationContext.Current.CancellationSignal = CaughtSignalEnum.INTERRUPTED; Assert.Throws <RuntimeError>(() => CancellationManager.CheckForSignal()); }
public void CancellationManager_CheckForSignal_DoesNothingIfNoneCaught() { MainApplicationContext.Current.CancellationSignal = CaughtSignalEnum.NONE_CAUGHT; CancellationManager.CheckForSignal(); }
public int Execute(string argString) { using (MainApplicationContext.AcquireCurrentThread()) { var envp = VirtualEnvironment.GetEnvironmentVariables(); var args = CommandLine.PreprocessSingleQuotes(argString); int status = 1; // The very first thing we do is handle some very special command-line // options, since they affect how the environment is setup: // // --verify ; turns on memory tracing // --verbose ; turns on logging // --debug CATEGORY ; turns on debug logging // --trace LEVEL ; turns on trace logging // --memory ; turns on memory usage tracing // --init-file ; directs ledger to use a different init file GlobalScope.HandleDebugOptions(args); // initialize_memory_tracing - [DM] #memory-tracing Logger.Current.Info(() => LedgerStarting); // ::textdomain("ledger"); - [DM] #localization GlobalScope globalScope = null; try { // Create the session object, which maintains nearly all state relating to // this invocation of Ledger; and register all known journal parsers. globalScope = new GlobalScope(envp); globalScope.Session.FlushOnNextDataFile = true; // Look for options and a command verb in the command-line arguments BindScope boundScope = new BindScope(globalScope, globalScope.Report); args = globalScope.ReadCommandArguments(boundScope, args); if (globalScope.ScriptHandler.Handled) { // Ledger is being invoked as a script command interpreter globalScope.Session.ReadJournalFiles(); status = 0; using (StreamReader sr = FileSystem.GetStreamReader(globalScope.ScriptHandler.Str())) { while (status == 0 && !sr.EndOfStream) { string line = sr.ReadLine().Trim(); if (!line.StartsWith("#")) { status = globalScope.ExecuteCommandWrapper(StringExtensions.SplitArguments(line), true); } } } } else if (args.Any()) { // User has invoke a verb at the interactive command-line status = globalScope.ExecuteCommandWrapper(args, false); } else { // Commence the REPL by displaying the current Ledger version VirtualConsole.Output.WriteLine(globalScope.ShowVersionInfo()); globalScope.Session.ReadJournalFiles(); bool exitLoop = false; VirtualConsole.ReadLineName = "Ledger"; string p; while ((p = VirtualConsole.ReadLine(globalScope.PromptString())) != null) { string expansion = null; int result = VirtualConsole.HistoryExpand(p.Trim(), ref expansion); if (result < 0 || result == 2) { throw new LogicError(String.Format(LogicError.ErrorMessageFailedToExpandHistoryReference, p)); } else if (expansion != null) { VirtualConsole.AddHistory(expansion); } CancellationManager.CheckForSignal(); if (!String.IsNullOrWhiteSpace(p) && p != "#") { if (String.Compare(p, "quit", true) == 0) { exitLoop = true; } else { globalScope.ExecuteCommandWrapper(StringExtensions.SplitArguments(p), true); } } if (exitLoop) { break; } } status = 0; // report success } } catch (CountError errors) { // used for a "quick" exit, and is used only if help text (such as // --help) was displayed status = errors.Count; } catch (Exception err) { if (globalScope != null) { globalScope.ReportError(err); } else { VirtualConsole.Error.WriteLine(String.Format(ExceptionDuringInitialization, err.Message)); } } if (globalScope != null) { globalScope.QuickClose(); globalScope.Dispose(); // {DM] It is the most appropriate place to call Dispose for the global scope. } Logger.Current.Info(() => LedgerEnded); // let global_scope leak! // Return the final status to the operating system, either 1 for error or 0 // for a successful completion. return(status); } }
public void CancellationManager_CheckForSignal_RaisesRTEIfSomethingCaught() { MainApplicationContext.Current.CancellationSignal = CaughtSignalEnum.INTERRUPTED; CancellationManager.CheckForSignal(); }
private void PerformSearching(CancellationManager manager) { Task.Factory.StartNew(() => { var settingInfo = BusinessCache.Settings; var rd = new Random(); var proxySearch = new ProxySearch(); try { while (!manager.Token.IsCancellationRequested) { var delay = (rd.Next(0, settingInfo.DelayTransfer)); var searchProxy = BusinessCache.UserProxies.GetRandomProxy(settingInfo.PageDiff); if (searchProxy != null) { try { var list = new List <ClientPortionTransferItem>(); for (var i = 0; i < settingInfo.SearchingKeywords.Count; i++) { var searchingKey = settingInfo.SearchingKeywords[i]; for (var j = settingInfo.PageFrom; j <= settingInfo.PageTo; j++) { var subList = proxySearch.SearchAsync(searchProxy.TokenOffical, ProxySearch.Parameter.Create(searchingKey, j)).Result; if (subList != null && subList.Count > 0) { list.AddRange(subList.rowSet); } if (j < settingInfo.PageTo) { Task.Delay(1000); } } if (i < settingInfo.SearchingKeywords.Count - 1) { Task.Delay(1000); } } BusinessCache.PoolTranser.Clear(); BusinessCache.PoolTranser.AddRange(list); BusinessCache.PoolTranser.UpdateFromPayment(BusinessCache.ProjectPayments); } catch (Exception ex) { LogManager.Instance.Error($"{ex.Message}"); } var msg = $"{BusinessCache.PoolTranser.TopItem.GetProjectInformation()} {searchProxy.UserName} {settingInfo.FreqTransfer}s+{delay}s"; LogManager.Instance.Message(msg); } else { throw new Exception("no proxy found"); } Task.Delay((settingInfo.FreqTransfer + delay) * 1000).Wait(manager.Token); } ; manager.Token.ThrowIfCancellationRequested(); } catch (Exception ex) { LogManager.Instance.Error($"{ex.Message}"); } finally { manager.Dispose(); } }, manager.Token); }
public KeepAliveChannelProxy() { this.cancellationManager = new CancellationManager(); }
public CallCollector(CancellationManager cancellationManager, bool measureDuration) : this(cancellationManager) { this.MeasureDuration = measureDuration; }