/// <summary> /// Insert terminal message into queue if it doesn't exist in queue and so on. /// </summary> /// <param name="terminalMessage"></param> public void InsertOrUpdate(TerminalMessage terminalMessage) { // Find command in existing queue. var instance = FindCommandInQueue(terminalMessage.CommandSequence, terminalMessage.CommandIndex); // Command doesn't exist in queue. if (instance == null) { // Insert command in queue. CommandsQueue.Add(terminalMessage); return; } // Update the command. instance.CommandSequence = terminalMessage.CommandSequence; instance.CommandIndex = terminalMessage.CommandIndex; instance.Command = terminalMessage.Command; instance.Status = terminalMessage.Status; instance.From = terminalMessage.From; instance.To = terminalMessage.To; instance.PalletNo = terminalMessage.PalletNo; instance.Filter = terminalMessage.Filter; instance.Date = terminalMessage.Date; instance.Sent = terminalMessage.Sent; instance.IsAck = terminalMessage.IsAck; instance.SentCount = terminalMessage.SentCount; }
/// <summary> /// This method checks if help output is requested or required. /// Help can be called explicitly or if a user uses JsMrg without /// params. /// </summary> private CheckResult HelpCheck(out List <TerminalMessage> messages, bool force = false) { var helpCheck = new HelpCheck(); var helpCheckResult = helpCheck.Run(Args); // Will be passed through empty if help is not applied. messages = new List <TerminalMessage>(); var initialMessagesWLicense = TerminalMessages.InitialMessagesWLicense1 .Concat(TerminalMessages.InitialMessagesWLicense2).ToArray(); foreach (var message in initialMessagesWLicense) { messages.Add(TerminalMessage.Create(message)); } if (force || helpCheckResult.CheckResult == CheckResult.Apply) { foreach (var message in TerminalMessages.Help) { messages.Add(TerminalMessage.Create(message)); } return(CheckResult.Apply); } return(CheckResult.Ignore); }
void ExecuteMessage(string messageString) { var message = new TerminalMessage(messageString); if (!_controllersByName.ContainsKey(message.ControllerName)) { if (Aos.Node.IsMainNode) { throw new Exception($"no controller \"{message.ControllerName}\""); } _log.Warning($"Can't handle message here, redirecting to main node: {messageString}"); _sender.DispatchMessage(new Tag(Aos.Node.MainNodeId), messageString); return; } var controller = _controllersByName[message.ControllerName]; if (!controller.Actions.ContainsKey(message.ActionName)) { throw new Exception($"{message.ControllerName} has no action {message.ActionName}"); } controller.Actions[message.ActionName] .Do(message.Argument) .Then(x => _log.Debug($"{message.Path} returned {x}")); _log.Debug($"Action executed OK: {messageString}"); }
public bool Run(string inputFile, string outputFile, out List <TerminalMessage> messages) { messages = new List <TerminalMessage>(); EnvironmentPath = IoHelper.GetEnvironmentPath(); ResultingFileContent = File.ReadAllText(inputFile); OperatedFile = inputFile; var regex = new Regex(@"/\*\*(jsmrg)(?:(?!\*/).)*\*/", RegexOptions.Singleline); var matches = regex.Matches(ResultingFileContent); var operationResult = OperateMatches(messages, matches); messages = operationResult.Messages; if (operationResult.IsOk) { if (IoHelper.WriteOutputFile(outputFile, ResultingFileContent)) { messages.Add(TerminalMessage.Create($"JsMrg successful.", Color.DarkGreen)); messages.Add(TerminalMessage.LineBreak()); } else { messages.Add(TerminalMessage.Create($"JsMrg complete, but failed to write output file {outputFile}.", Color.Red)); // Last operation failed, so overwrite IsOk: operationResult.IsOk = false; } } return(operationResult.IsOk); }
public ActionResult Terminal(string userId, string name) { TerminalMessage message = new TerminalMessage(); var result = db.Desktops.Where(v => v.UserId == userId).Where(v => v.Name == name).FirstOrDefault(); if (result == null) { message.Error = new TerminalErrorModel() { ErrorText = $" You can't get access to Terminal : {name}", ErrorType = "Access denied.", UserId = userId, TerminalName = name }; return(View(message)); } message.Success = new TerminalSuccessModel() { TerminalName = name, TerminalIp = result.Ip, SuccessText = $"Connection to Terminal :: {name} with ip :: {result.Ip} - SUCCESS" }; return(View(message)); }
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local private static void ExpectOkOrError(Check result) { if (!(result.CheckResult == CheckResult.Ok || result.CheckResult == CheckResult.Error)) { var message = "Unexpected Runtime error at adf09599-a0ea-4929-878a-f3e9a26f335a. Please report to developer on ytils.com."; var terminalMessage = new TerminalMessage(); terminalMessage.Color = Color.Red; terminalMessage.Message = message; throw new JsmrgException(terminalMessage, message); } }
private OperateMatchesResult OperateMatches(List <TerminalMessage> messages, MatchCollection matches) { var error = false; var matchOperator = new MatchOperator(); var latestMatchValue = string.Empty; var resultingFileContent = ResultingFileContent; try { foreach (Match match in matches) { var inspection = matchOperator.Operate(match); latestMatchValue = inspection.Match.Value; switch (inspection.Command) { case MatchInspectionType.Include: resultingFileContent = Include(inspection, resultingFileContent); break; case MatchInspectionType.HtmlVar: resultingFileContent = HtmlVar(inspection, resultingFileContent); break; case MatchInspectionType.Error: messages.Add(TerminalMessage.Create(string.Format(TerminalMessages.StoppingJsMrgRunner, match.Value), Color.Red)); error = true; break; } } } catch (JsMrgRunnerException jsMrgRunnerException) { messages.Add(TerminalMessage.Create(string.Format(jsMrgRunnerException.Message, jsMrgRunnerException.Message), Color.Red)); error = true; } catch (Exception) { messages.Add(TerminalMessage.Create(string.Format(TerminalMessages.UnexpectedExceptionWhileJsMrgRunner, latestMatchValue), Color.Red)); error = true; } if (false == error) { ResultingFileContent = resultingFileContent; } return(new OperateMatchesResult() { Messages = messages, IsOk = false == error }); }
/// <summary> /// Send terminal message to external system. /// </summary> /// <param name="terminalMessage"></param> /// <param name="outgoing">Outgoing gateway</param> public void Send(TerminalMessage terminalMessage, ConnectionSetting outgoing) { using (var tcpClient = new TcpClient()) { tcpClient.Connect(outgoing.Address, outgoing.Port); using (var stream = tcpClient.GetStream()) using (var streamWriter = new StreamWriter(stream)) { streamWriter.AutoFlush = true; streamWriter.WriteLine(terminalMessage); } } }
/// <summary> /// Send terminal message to external system. /// </summary> /// <param name="terminalMessage"></param> /// <param name="endPoint"></param> public void Send(TerminalMessage terminalMessage, IPEndPoint endPoint) { using (var tcpClient = new TcpClient()) { tcpClient.Connect(endPoint); using (var stream = tcpClient.GetStream()) using (var streamWriter = new StreamWriter(stream)) { streamWriter.AutoFlush = true; streamWriter.WriteLine(terminalMessage); } } }
/// <summary> /// Check whether terminal message is sendable or not. /// </summary> /// <param name="terminalMessage"></param> /// <returns></returns> public bool IsSendable(TerminalMessage terminalMessage) { // Time limit is not exceeded. if (DateTime.Now - terminalMessage.Sent < TimeSpan.FromMilliseconds(Setting.CommandTimeOut)) { return(false); } // Already acknowledged or the command has been sent out more than 3 times. if (terminalMessage.IsAck || terminalMessage.SentCount >= 3) { return(false); } return(true); }
/// <summary> /// Runs JsMrg. /// </summary> public ProgramRunnerExit Run() { var helpCheck = false; List <TerminalMessage> helpMessages = new List <TerminalMessage>(); if (0 == Args.Length) { helpCheck = true; HelpCheck(out helpMessages, true); } if (helpCheck || CheckResult.Apply == HelpCheck(out helpMessages)) { TerminalWriter.WriteTerminalMessages(helpMessages); return(ProgramRunnerExit.Help); } OutputStartupMessages(); // If help is not requested, we are expecting exactly two parameters. if (2 != Args.Length) { var tm = TerminalMessage.Create(TerminalMessages.UnexpectedNumberOfParams, Color.Red); TerminalWriter.WriteTerminalMessage(tm); return(ProgramRunnerExit.Error); } InputFile = Args[0]; InputFile = IoHelper.OptionalAdjustmentToAbsolutPath(InputFile); OutputFile = Args[1]; if (CheckResult.Ok != IoCheck(out var terminalMessages)) { TerminalWriter.WriteTerminalMessages(terminalMessages); // Bail out, we are not ready to run. return(ProgramRunnerExit.IoCheckOut); } var jsMrgRunner = new JsMrgRunner(); var runResult = jsMrgRunner.Run(InputFile, OutputFile, out var combinedRunMessages); var runExit = ProgramRunnerExit.Done; if (false == runResult) { var tm = TerminalMessage.Create(TerminalMessages.JsMrgRunEndedWErrors, Color.Red); TerminalWriter.WriteTerminalMessage(tm); runExit = ProgramRunnerExit.Error; } TerminalWriter.WriteTerminalMessages(combinedRunMessages); if (runExit == ProgramRunnerExit.Done) { JsMrgOutput = jsMrgRunner.ResultingFileContent; } return(runExit); }
/// <summary> /// Delete terminal message from queue. /// </summary> /// <param name="terminalMessage"></param> public void Delete(TerminalMessage terminalMessage) { CommandsQueue.Remove(terminalMessage); }
/// <summary> /// Insert terminal message into queue. /// </summary> /// <param name="terminalMessage"></param> public void Insert(TerminalMessage terminalMessage) { CommandsQueue.Add(terminalMessage); }
public JsmrgException(TerminalMessage terminalMessage, string excMessage) : base(excMessage) { TerminalWriter.WriteTerminalMessage(terminalMessage); }
/// <summary> /// Task which is used for sending status request to external terminal. /// </summary> private void SendingStatusRequestCommands() { while (true) { // Task is not allowed to run. if (!_isTaskRunning) { Thread.Sleep(Setting.CommandScanTaskInterval); continue; } // Wait for status request. _manualResetStatusRequest.WaitOne(); var terminalMessage = new TerminalMessage(); try { // Maximum command sequence number. var maximumCommandSeq = 1; using (var context = new KCSGDbContext()) using (var unitOfWork = new UnitOfWork(context)) { // Find no manage in database. var noManage = unitOfWork.NoManageRepository.GetAll().FirstOrDefault(); if (noManage == null) { Thread.Sleep(Setting.CommandScanTaskInterval); continue; } if (TerminalName.Material.Equals(_terminalSetting.Key)) { maximumCommandSeq = noManage.F48_MtrWhsCmdNo + 1; if (maximumCommandSeq > 9999) { noManage.F48_MtrWhsCmdNo = 0; maximumCommandSeq = 0; } noManage.F48_MtrWhsCmdNo = maximumCommandSeq; } else if (TerminalName.PreProduct.Equals(_terminalSetting.Key)) { // delete off empty command var preProduct = unitOfWork.PreProductWarehouseCommandRepository.GetMany( i => i.F50_From.Trim().Equals("")) .FirstOrDefault(); if (preProduct != null) { unitOfWork.PreProductWarehouseCommandRepository.Delete(preProduct); unitOfWork.Commit(); } maximumCommandSeq = noManage.F48_PrePdtWhsCmdNo + 1; if (maximumCommandSeq > 9999) { noManage.F48_PrePdtWhsCmdNo = 0; maximumCommandSeq = 0; } noManage.F48_PrePdtWhsCmdNo = maximumCommandSeq; } else if (TerminalName.Product.Equals(_terminalSetting.Key)) { maximumCommandSeq = noManage.F48_PdtWhsCmdNo + 1; if (maximumCommandSeq > 9999) { noManage.F48_PdtWhsCmdNo = 0; maximumCommandSeq = 0; } noManage.F48_PdtWhsCmdNo = maximumCommandSeq; } // Update no manage first. unitOfWork.NoManageRepository.Update(noManage); unitOfWork.Commit(); } terminalMessage.CommandIndex = "5000"; terminalMessage.CommandSequence = maximumCommandSeq.ToString("D4"); using (var tcpClient = new TcpClient()) { var endpoint = new IPEndPoint(IPAddress.Parse(_terminalSetting.Value.Outgoing.Address), _terminalSetting.Value.Outgoing.Port); tcpClient.Connect(endpoint); //using (var stream = tcpClient.GetStream()) //using (var streamWriter = new StreamWriter(stream, new UTF8Encoding())) //{ // streamWriter.AutoFlush = true; // streamWriter.WriteLine(terminalMessage); //} using (var stream = tcpClient.GetStream()) { var bytes = Encoding.UTF8.GetBytes(terminalMessage.ToString()); stream.Write(bytes, 0, bytes.Length); stream.Flush(); } } Message.InitiateMessage(DateTime.Now, MessageType.StatusRequest, "Sent status request", terminalMessage.ToString()); } catch (Exception exception) { Message.InitiateMessage(DateTime.Now, MessageType.Error, $"Failed to send status request: {terminalMessage}"); Log.Debug(exception.Message, exception); } finally { // 2017-05-15: Disabled status request message notification. //Message.InitiateMessage(DateTime.Now, MessageType.Information, $"Status request will be sent after {CommandStatusTime} milliseconds"); Thread.Sleep(CommandStatusTime); } } }
/// <summary> /// Task which is used for listening to incoming connection. /// </summary> private void ListenIncomingConnection() { while (true) { if (!_isTaskRunning) { continue; } if (_tcpListener == null) { continue; } // Wait the thread for signal. _manualResetListenerEvent.WaitOne(); try { // Accept one connection at one time. using (var tcpClient = _tcpListener.AcceptTcpClient()) using (var stream = tcpClient.GetStream()) { // Read buffer from stream. var buffer = new byte[64]; var rb = stream.Read(buffer, 0, buffer.Length); if (rb != 64) { continue; } // Read commands sent from external. var content = Encoding.UTF8.GetString(buffer, 0, buffer.Length); content = content.Trim(); if (string.IsNullOrEmpty(content)) { continue; } var information = $"(Port: {_terminalSetting.Value.Incoming.Port}) Received message: {content} from external component - {rb} bytes received"; Message.InitiateMessage(DateTime.Now, MessageType.Receive, "Received message", content); Log.Info(information); // Parse terminal message obtained from external terminal. var terminalMessage = TerminalMessage.Parse(content, false); if (terminalMessage == null) { Message.InitiateMessage(DateTime.Now, MessageType.Information, $"Incoming message is incorrect. Restart listener in {Setting.CommandScanTaskInterval} millisecs."); Thread.Sleep(Setting.CommandScanTaskInterval); continue; } if ("5000".Equals(terminalMessage.CommandIndex)) { continue; } // Display message to screen. Log.Info("Command sending process is blocked for analyzing listening process."); //Message.InitiateMessage(DateTime.Now, MessageType.Information, "Command sending process is blocked for analyzing listening process."); try { // ProceedIncommingCommand incoming automated warehouse controller command if (TerminalName.Material.Equals(_terminalSetting.Key)) { MaterialAutoWarehouseController.ProceedIncommingCommand(terminalMessage, AutoController.MaterialAutoWarehouseDeviceCode); // Remove command from cache MaterialAutoWarehouseController.RemoveCommand(x => x.IsAck && x.CommandIndex.Equals(terminalMessage.CommandIndex, StringComparison.InvariantCultureIgnoreCase) && x.CommandSequence.Equals(terminalMessage.CommandSequence, StringComparison.InvariantCultureIgnoreCase)); } else if (TerminalName.PreProduct.Equals(_terminalSetting.Key)) { if ("0100".Equals(terminalMessage.Command) || "0101".Equals(terminalMessage.Command)) { PreProductAutoWarehouseController.ProceedIncommingCommand(terminalMessage, AutoController.PreProductAutoWarehouseDeviceCode); } // Remove command from cache PreProductAutoWarehouseController.RemoveCommand(x => x.IsAck && x.CommandIndex.Equals(terminalMessage.CommandIndex, StringComparison.InvariantCultureIgnoreCase) && x.CommandSequence.Equals(terminalMessage.CommandSequence, StringComparison.InvariantCultureIgnoreCase)); } else if (TerminalName.Product.Equals(_terminalSetting.Key)) { ProductAutoWarehouseController.ProceedIncommingCommand(terminalMessage, AutoController.ProductAutoWarehouseDeviceCode); // Remove command from cache ProductAutoWarehouseController.RemoveCommand(x => x.IsAck && x.CommandIndex.Equals(terminalMessage.CommandIndex, StringComparison.InvariantCultureIgnoreCase) && x.CommandSequence.Equals(terminalMessage.CommandSequence, StringComparison.InvariantCultureIgnoreCase)); } Message.InitiateMessage(DateTime.Now, MessageType.Information, $"Command: {content} has been proceeded. Restart listener in {Setting.CommandScanTaskInterval} millisecs."); Thread.Sleep(Setting.CommandScanTaskInterval); } catch (Exception exception) { Log.Error(exception.Message, exception); Message.InitiateMessage(DateTime.Now, MessageType.Error, $"Command: {content} hasn't been proceeded. Restart listener in {Setting.CommandScanTaskInterval} millisecs."); Thread.Sleep(Setting.CommandScanTaskInterval); } } } catch (Exception exception) { Log.Error(exception.Message, exception); } Message.InitiateMessage(DateTime.Now, MessageType.Information, "Command sending process is unblocked."); } }