/// <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.");
}
}
