//Tracking the commit messages. public Task TrackingCommitMessages(StreamMessage msg) { if (commitTrackingMap.ContainsKey(msg.BatchID)) { var targetBatch = commitTrackingMap[msg.BatchID]; Functions.CheckNotNull(msg.barrierOrCommitInfo); targetBatch.AddBarrierOrCommitMsgTrackingHelper(msg.barrierOrCommitInfo); } else if (msg.BatchID >= 0 && !committedBatch.Contains(msg.BatchID)) { PrettyConsole.Line("Committing a new batch" + msg.BatchID); StreamBatch newBatch = new StreamBatch(msg.BatchID); //The name should be changed Functions.CheckNotNull(msg.barrierOrCommitInfo); newBatch.AddBarrierOrCommitMsgTrackingHelper(msg.barrierOrCommitInfo); commitTrackingMap.Add(msg.BatchID, newBatch); //PrettyConsole.Line("Add batch " + msg.BatchID + " to the commitTrackingMap"); } else { throw new InvalidOperationException("Batch ID less 0 or the message of that batch ahs been committed"); } return(Task.CompletedTask); }
public void Initialize() { var dbName = DbConfig.DatabaseName; if (Process.GetProcesses().FirstOrDefault(x => x.ProcessName == "Raven.Server") == null) { PrettyConsole.Log(LogSeverity.Error, "Database", "Please make sure RavenDB is running."); Console.ReadLine(); Environment.Exit(0); } _store = new Lazy <IDocumentStore>( () => new DocumentStore { Database = DbConfig.DatabaseName, Urls = new[] { DbConfig.DatabaseUrl } } .Initialize(), true).Value; if (_store == null) { PrettyConsole.Log(LogSeverity.Error, "Database", "Failed to build document store."); } if (_store.Maintenance.Server.Send(new GetDatabaseNamesOperation(0, 5)).All(x => x != dbName)) { _store.Maintenance.Server.Send(new CreateDatabaseOperation(new DatabaseRecord(dbName))); } _store.AggressivelyCacheFor(TimeSpan.FromMinutes(30)); using (var session = _store.OpenSession()) { if (session.Advanced.Exists("Config")) { return; } PrettyConsole.Log(LogSeverity.Info, "Arcade's Bot", "Enter Bot's Token:"); var token = Console.ReadLine(); PrettyConsole.Log(LogSeverity.Info, "Arcade's Bot", "Enter Bot's Prefix:"); var prefix = Console.ReadLine(); var model = new ConfigModel { Prefix = prefix.Trim(), Blacklist = new List <ulong>(), Namespaces = new List <string>(), ApiKeys = new Dictionary <string, string> { { "Giphy", "dc6zaTOxFJmzC" }, { "Google", "" }, { "Discord", token.Trim() }, { "Imgur", "" }, { "Cleverbot", "" } } }; var id = "Config"; Create <ConfigModel>(ref id, model); } }
//Commit public Task StartCommit(int ID) { PrettyConsole.Line("Start Commit Batch " + ID); commitMsg.BatchID = ID; topologyManager.Commit(commitMsg); return(Task.CompletedTask); }
public async Task <bool> HandleCallbackAsync(SocketReaction reaction) { var emote = reaction.Emote; if (emote.Equals(_options.HitEmote)) { _userClicked = true; await Message.DeleteAsync(); Interactive.RemoveReactionCallback(Message); await Task.Run(async() => { await DisplayAsync(); }); //BlackJackService.RemovePlayerFromMatch(Context.User.Id); PrettyConsole.Log(LogSeverity.Info, "Callback", "User clicked HitEmote"); } if (emote.Equals(_options.StandEmote)) { _userClicked = true; //BlackJackService.RemovePlayerFromMatch(Context.User.Id); PrettyConsole.Log(LogSeverity.Info, "Callback", "User clicked StandEmote"); } await Message.RemoveReactionAsync(reaction.Emote, reaction.User.Value); //await RenderAsync().ConfigureAwait(false); return(false); }
public Task RemoveCustomDownStreamOperator(Guid guid) { int index = -1; for (int i = 0; i < downStreamOperators.Count; i++) { if (downStreamOperators[i].GetPrimaryKey() == guid) { index = i; break; } } if (index != -1) { downStreamOperators.RemoveAt(index); PrettyConsole.Line("Remove old stateful from upper stream"); operatorSettings.RemoveOperatorFromDict(guid); topologyManager.UpdateOperatorSettings(this.GetPrimaryKey(), operatorSettings); } else { throw new ArgumentException(); } return(Task.CompletedTask); }
private bool CheckCount(StreamMessage msg) { if (!upStreamMessageCountMaps.ContainsKey(msg.BatchID)) { if (msg.Count == 0) { return(true); } else { return(false); } } else if (upStreamMessageCountMaps[msg.BatchID].ContainsKey(msg.From) && msg.Count == upStreamMessageCountMaps[msg.BatchID][msg.From]) { return(true); } else if (!upStreamMessageCountMaps[msg.BatchID].ContainsKey(msg.From) && msg.Count == 0) { return(true); } else { PrettyConsole.Line("The count in stateless operator is not equal!"); return(false); } }
public Task MarkOperatorAsFailed() { isOperatorFailed = true; isARestartOperator = true; PrettyConsole.Line("Mark this as failed!"); return(Task.CompletedTask); }
public static void GracefulShutdownMiner(Process minerProcess, Process commandLineProcess) { if (minerProcess == null) { return; } PrettyConsole.WriteLine($"Freezing Miner Process ({minerProcess.Id})", ConsoleColor.Magenta); try { SuspendProcess(minerProcess.Id); } catch (Exception ex) { Log.Error(ex); PrettyConsole.WriteLine($"Miner Process Has Exited: {minerProcess.HasExited}"); } finally { Thread.Sleep(5000); } KillProcess(minerProcess); KillProcess(commandLineProcess); }
private void PrintMarker(float cpuUsage, int size) { var progressLines = (int)Math.Round(cpuUsage / 100 * size); Console.Write("\t["); var greenLines = 0; var yellowLines = 0; var redLines = 0; var empty = 0; if (cpuUsage < 80) { greenLines = progressLines; } else if (cpuUsage >= 80 && cpuUsage < 95) { greenLines = 80 * size / 100; yellowLines = progressLines - greenLines; } else if (cpuUsage > 95) { greenLines = 80 * size / 100; yellowLines = 15 * size / 100; redLines = progressLines - greenLines - yellowLines; } empty = size - progressLines; PrettyConsole.WriteColor(ConsoleColor.Green, new string('|', greenLines)); PrettyConsole.WriteColor(ConsoleColor.Yellow, new string('|', yellowLines)); PrettyConsole.WriteColor(ConsoleColor.Red, new string('|', redLines)); PrettyConsole.WriteColor(ConsoleColor.DarkGray, new string(' ', empty)); Console.WriteLine(']'); }
public async Task <Task> Commit(StreamMessage msg) { List <TopologyUnit> units = topology.GetAllTopologyUnits(); PrettyConsole.Line("Number of units: " + units.Count); msg.barrierOrCommitInfo = new BarrierOrCommitMsgTrackingInfo(Guid.NewGuid(), units.Count); msg.barrierOrCommitInfo.BatchID = msg.BatchID; await batchTracker.TrackingCommitMessages(msg); foreach (TopologyUnit unit in units) { if (unit.OperatorType == OperatorType.Source) { IStreamSource source = GrainFactory.GetGrain <IStreamSource>(unit.PrimaryKey); source.Commit(msg); } else if (unit.OperatorType == OperatorType.Stateful) { IStatefulOperator statefulOperator = GrainFactory.GetGrain <IStatefulOperator>(unit.PrimaryKey, Constants.Stateful_Operator_Prefix); statefulOperator.Commit(msg); } else if (unit.OperatorType == OperatorType.Stateless) { IStatelessOperator statelessOperator = GrainFactory.GetGrain <IStatelessOperator>(unit.PrimaryKey, Constants.Stateless_Operator_Prefix); statelessOperator.Commit(msg); } else { throw new ArgumentException("Commit: The operator type is in valid!"); } } return(Task.CompletedTask); }
private static void RedirectStandardError(object sendingProcess, DataReceivedEventArgs outLine) { if (string.IsNullOrEmpty(outLine?.Data)) { return; } var info = outLine.Data.ToLower(); bool output = false; ConsoleColor outputColor = ConsoleColor.White; foreach (var s in DisplayKeywords) { if (info.Contains(s)) { output = true; outputColor = ConsoleColor.Green; break; } } foreach (var s in ShareFoundKeywords) { if (info.Contains(s)) { _solutionsFound++; outputColor = ConsoleColor.Green; break; } } foreach (var s in RejectedShareKeywords) { if (info.Contains(s)) { _rejectedSolutions++; outputColor = ConsoleColor.Yellow; break; } } foreach (var s in ErrorKeywords) { if (info.Contains(s)) { PrettyConsole.WriteLine(outLine.Data, ConsoleColor.Red); Log.Error(outLine.Data); KillMiner(); return; } } if (VerboseOutput || output) { PrettyConsole.WriteLine(outLine.Data, outputColor); } UpdateAverageHashRate(outLine.Data); }
//Recovery public async Task <Task> CompleteOneOperatorRecovery(BarrierOrCommitMsgTrackingInfo msgInfo) { if (!recoveryTrackingMap.ContainsKey(msgInfo.BatchID)) { //Multiple batch has that problem PrettyConsole.Line("The recovery key " + msgInfo.BatchID + " is not exist"); } else { //PrettyConsole.Line("Finish Tracking one message in batchID: " + msgInfo.BatchID); StreamBatch targetBatch = recoveryTrackingMap[msgInfo.BatchID]; targetBatch.CompleteOneMessageTracking(msgInfo); if (targetBatch.readForCommitting) { if (batchCoordinator != null) { PrettyConsole.Line("Batch: " + msgInfo.BatchID + " commit has been successfully recoveryed"); await batchCoordinator.CompleteRecovery(msgInfo.BatchID); recoveryTrackingMap.Remove(msgInfo.BatchID); } } } return(Task.CompletedTask); }
private static void EnterMainMenu() { _exitFlag = false; while (!_exitFlag) { Console.WriteLine("-=Главное меню=-"); foreach (var item in _mainMenu) { Console.WriteLine(item.Key + " - " + item.Value.MenuText); } var key = Console.ReadKey(); Console.Clear(); try { if (_mainMenu.ContainsKey(key.Key)) { _mainMenu[key.Key].MenuAction.Invoke(); } } catch (Exception exp) { PrettyConsole.WriteLineColor(ConsoleColor.Red, exp.Message); } } }
private async Task RunAsync() { try { while (true) { await Task.Delay(_postEvery); int index = _random.Next(0, _messages.Count()); var selected = _messages.ElementAtOrDefault(index); if (selected == null) { await _log.SendMessageAsync("I couldn't find any messages to swindle <:ShibeSad:231546068960018433>"); return; } var mediaIds = await GetMediaIdsAsync(selected); var status = await _twitter.Statuses.UpdateAsync(selected.Resolve(), possibly_sensitive : true, media_ids : mediaIds); await _log.SendMessageAsync("", embed : TwitterHelper.GetPostedEmbed(selected, status.Id)); _ = _manager.LogAsync(status.Id, selected, _messages); _messages.Clear(); } } catch (Exception ex) { await PrettyConsole.LogAsync(LogSeverity.Error, "SwindleService", ex.ToString()); } }
public void CompleteMatch(ref ChessMatchModel chessMatch) { var statId = _statsHandler.AddStat(chessMatch); chessMatch.IdOfStat = statId; PrettyConsole.Log(LogSeverity.Info, "Complete ChessMatch", $"Completed Chess Match With Id: {chessMatch.Id}"); }
public override Task OnNextAsync(ChatMsg item, StreamSequenceToken token = null) { if (item.Author == "System") { PrettyConsole.Line($"==== System message: '{item.Text}'", ConsoleColor.Green); } return(Task.CompletedTask); }
public async Task StartAsync() { await _commands.AddModulesAsync(Assembly.GetEntryAssembly()); _discord.MessageReceived += OnMessageReceivedAsync; await PrettyConsole.LogAsync(LogSeverity.Info, "Services", $"Enabled CommandHandlingService with {_commands.Modules.Count()} modules and {_commands.Commands.Count()} commands"); }
public static ErrorCodes HandleClientException(IClientException <ErrorData> exception) { Console.Clear(); var res = HandleClientExceptionErrorData(exception); PrettyConsole.WriteLineColor(ConsoleColor.Red, "Ошибка: {0}", res.Item2); return(res.Item1); }
//Replay Logic public async Task <Task> ReplayTheMessageOnRecoveryCompleted() { PrettyConsole.Line("Start Replay!"); foreach (StreamMessage msg in messagesForRecovery) { await ProcessNormalMessage(msg); } return(Task.CompletedTask); }
private async Task <Task> DetectPossibleFailures(object org) { PrettyConsole.Line("Start Detect Failures"); Dictionary <Guid, Task <int> > taskMap = new Dictionary <Guid, Task <int> >(); List <Task <int> > taskList = new List <Task <int> >(); var topologyManager = GrainFactory.GetGrain <ITopology>(Constants.Topology_Manager); var operatorUnits = await topologyManager.GetAllUnits(); foreach (TopologyUnit unit in operatorUnits) { if (unit.OperatorType == OperatorType.Source) { IStreamSource source = GrainFactory.GetGrain <IStreamSource>(unit.PrimaryKey); var task = source.DetectErrors(); taskMap.Add(unit.PrimaryKey, task); } else if (unit.OperatorType == OperatorType.Stateful) { IStatefulOperator statefulOperator = GrainFactory.GetGrain <IStatefulOperator>(unit.PrimaryKey, Constants.Stateful_Operator_Prefix); var task = statefulOperator.DetectErrors(); taskMap.Add(unit.PrimaryKey, task); } else if (unit.OperatorType == OperatorType.Stateless) { IStatelessOperator statelessOperator = GrainFactory.GetGrain <IStatelessOperator>(unit.PrimaryKey, Constants.Stateless_Operator_Prefix); var task = statelessOperator.DetectErrors(); taskMap.Add(unit.PrimaryKey, task); } else { throw new ArgumentException("Commit: The operator type is in valid!"); } } try { await Task.WhenAny(Task.WhenAll(taskMap.Values), Task.Delay(TimeSpan.FromSeconds(2))); } catch (Exception e) { PrettyConsole.Line(e.ToString()); } foreach (var task in taskMap) { if (task.Value.Status != TaskStatus.RanToCompletion) { PrettyConsole.Line("Replace!"); await topologyManager.ReplaceTheOldOperator(task.Key); disposable.Dispose(); break; } } return(Task.CompletedTask); }
private Task TellTrackMessageSent(StreamMessage item) { if (tracker != null) { tracker.CompleteTracking(item); PrettyConsole.Line("Complete one barrier"); } return(Task.CompletedTask); }
protected async Task <Task> ExecuteMessagesByDownStreamOperators(StreamMessage msg, IAsyncStream <StreamMessage> stream, IOperator op) { if (downStreamOperators.Count > 0) { int batchID = msg.BatchID; var targetKey = op.GetPrimaryKey(); try { msg.From = this.GetPrimaryKey(); //if is barrier message, set the message count if (msg.Value == Constants.Barrier_Value) { if (downStreamMessageCountMaps.ContainsKey(batchID)) { if (downStreamMessageCountMaps[batchID].ContainsKey(op.GetPrimaryKey())) { msg.Count = downStreamMessageCountMaps[batchID][op.GetPrimaryKey()]; } else { msg.Count = 0; } } else { msg.Count = 0; } } //if it is a normal message, increment the count map else if (msg.Value != Constants.System_Key) { if (!downStreamMessageCountMaps.ContainsKey(batchID)) { downStreamMessageCountMaps.Add(batchID, new Dictionary <Guid, int>()); } var key = op.GetPrimaryKey(); if (downStreamMessageCountMaps[batchID].ContainsKey(key)) { downStreamMessageCountMaps[batchID][key] = downStreamMessageCountMaps[batchID][key] + 1; } else { downStreamMessageCountMaps[batchID].Add(key, 1); } } op.ExecuteMessage(msg, stream); } catch (Exception e) { PrettyConsole.Line("Get Exception : " + e + "; Start Receovry"); topologyManager.ReplaceTheOldOperator(targetKey); } } return(Task.CompletedTask); }
public override Task OnNextAsync(ChatMsg item, StreamSequenceToken token = null) { var textHasMention = item.Text.Contains("@"); if (textHasMention) { PrettyConsole.Line($"==== MENTION DETECTED: '{item.Author}' mentions someone. Sending a notification email.", ConsoleColor.Green); } return(Task.CompletedTask); }
public void Update <T>(object id, object data) { using (var session = _store.OpenSession()) { session.Store((T)data, $"{id}"); session.SaveChanges(); } PrettyConsole.Log(LogSeverity.Info, "Database", $"Updated {typeof(T).Name} with {id} id."); }
private static void VerifyProcesses() { LoopStart: if (!_running || _paused) { return; } if (_minerProcess != null && (_minerProcess.HasExited || !_minerProcess.Responding)) { PrettyConsole.WriteLine( $"{MinerExe}.exe is not running or not responding. Attempting to restart...", ConsoleColor.Yellow); KillMiner(); Thread.Sleep(1000); } if (_minerProcess == null && !_paused) { PrettyConsole.WriteLine($"Starting {MinerExe}.exe now.", ConsoleColor.Yellow); //Start a new cmd window so that it doesn't intercept ctrl+c in windows 7 and crash drivers during a process kill string commandLine = $"/K START /B {MinerLocation} {MinerCommandLineParameters}"; ProcessStartInfo pInfo = new ProcessStartInfo("cmd.exe", commandLine) { UseShellExecute = false, RedirectStandardOutput = true, RedirectStandardError = true, //RedirectStandardInput = true //Todo: Redirect standard input for miners that accept key commands }; _commandLineProcess = Process.Start(pInfo); if (_commandLineProcess != null) { //Note: Redirecting Standard Output/Error will only work if the mining sub process flushes console buffers, some miners (eg: xmr-stak) provide a flag to force console buffer flushing _commandLineProcess.EnableRaisingEvents = true; _commandLineProcess.OutputDataReceived += RedirectStandardOutput; _commandLineProcess.ErrorDataReceived += RedirectStandardError; _commandLineProcess.BeginOutputReadLine(); _commandLineProcess.BeginErrorReadLine(); } Thread.Sleep(5000); Console.Out.Flush(); _minerProcess = Process.GetProcessesByName(MinerExe).FirstOrDefault(); goto LoopStart; } }
public async Task InitializeAsync(DiscordSocketClient c, CommandService service) { PrettyConsole.Log(LogSeverity.Info, "Commands", $"Loading SQLite commands"); _client = c; _service = service; await _service.AddModulesAsync(Assembly.GetEntryAssembly()); _client.MessageReceived += HandleCommandAsync; PrettyConsole.Log(LogSeverity.Info, "Commands", $"Ready, loaded {_service.Commands.Count()} commands"); }
public void Delete <T>(object id) { using (var session = _store.OpenSession(_store.Database)) { PrettyConsole.Log(LogSeverity.Info, "Database", $"Removed {typeof(T).Name} with {id} id."); session.Delete(session.Load <T>($"{id}")); session.SaveChanges(); session.Dispose(); } }
public override Task OnActivateAsync() { currentBatchID = 0; committedID = -1; tracker = GrainFactory.GetGrain <IBatchTracker>(Utils.Constants.Tracker); topologyManager = GrainFactory.GetGrain <ITopology>(Constants.Topology_Manager); PrettyConsole.Line("Register Timer"); var streamProvider = GetStreamProvider(Constants.FaultTolerantStreamProvider); return(base.OnActivateAsync()); }
public void FightAgainstCorruption() { try { _game.FightAgainstInflation(); } catch (Exception exp) { PrettyConsole.WriteLineColor(ConsoleColor.Red, "Error: {0}", exp); } DisplayGameData(GetGameData()); }
public void BuyFundDriver(ConsoleKeyInfo keyInfo) { try { _game.BuyFundDriver((int)keyInfo.Key - 64); } catch (Exception exp) { PrettyConsole.WriteLineColor(ConsoleColor.Red, "Error: {0}", exp); } DisplayGameData(GetGameData()); }