public Message(CommandHeader command, MessageFlagHeader flag, byte[] messageBody)
: this()
{
this.Command = command;
this.MessageFlag = flag;
this.MessageBody = messageBody;
}
private byte[] CreateCommandBuffer(CommandHeader cmd, params byte[] data)
{
byte[] bufs = new byte[data.Length + 1];
bufs[0] = (byte)cmd;
data.CopyTo(bufs, 1);
return(bufs);
}
public static byte[] Serialize(this RequestCommand requestCommand, CommandHeader commandHeader)
{
if (commandHeader == CommandHeader.Yes)
{
return(Serialize(requestCommand.Contents).AddHeader(requestCommand.CommandId));
}
return(Serialize(requestCommand.Contents));
}
public static void SendMessageAccepted()
{
var commandHeader = new CommandHeader {
Count = 1,
Type = (int)CommandTypeEnum.MessageAccepted
};
SendAnswer(IP, Port, commandHeader.ToBytes());
}
public static void SendClearLogDataGrid()
{
var commandHeader = new CommandHeader
{
Count = 1,
Type = (int)CommandTypeEnum.ClearLogDataGrid
};
SendAnswer(IP, Port, commandHeader.ToBytes());
}
// demonstrates how to build a set of command headers for a complex command request
static ICommandHeaders GetCommandHeaders()
{
var crob = new ControlRelayOutputBlock(ControlCode.PULSE_ON, 1, 100, 100);
var ao = new AnalogOutputDouble64(1.37);
return(CommandSet.From(
CommandHeader.From(IndexedValue.From(crob, 0)),
CommandHeader.From(IndexedValue.From(ao, 1))
));
}
public static void SendQueryCommand(QueryCommand queryCommand)
{
var commandHeader = new CommandHeader
{
Count = 1,
Type = (int)CommandTypeEnum.QueryCommand
};
byte[] commandBytes = CommandUtils.ConcatByteArrays(commandHeader.ToBytes(), queryCommand.ToBytes());
SendAnswer(IP, Port, commandBytes);
}
public Byte[] CreateReadParametersRequest()
{
CommandHeader datagram = new CommandHeader();
SingleTaskCommand order = datagram.order;
// datagram.order.task = 'I';
order.task = Commands.ReadParameters;
datagram.order = order;
buffer.Initialize();
Buffer.BlockCopy(datagram.GetOrderArrayBytes(), 0, buffer, 0, buffer.Length);
return(buffer);
}
/// <summary>
/// Создает команду из заголовка. Если данных недостаточно, то возвращает <code>null</code>.
/// </summary>
/// <param name="command_header"></param>
/// <param name="not_ready_data"></param>
/// <returns></returns>
public Command CreateCommand(CommandHeader command_header, out Tuple <FunctionHeader, List <DataCellHeader> > not_ready_data)
{
not_ready_data = null;
var input_data = new List <DataCell>();
var empty_input_data = new List <DataCellHeader>();
foreach (var data_cell_header in command_header.InputDataHeaders)
{
var data = _dataCellRepository.Get(new[] { data_cell_header }).FirstOrDefault();
if (data != null)
{
input_data.Add(data);
}
else
{
empty_input_data.Add(data_cell_header);
}
}
var output_data = _dataCellRepository.Get(new[] { command_header.OutputDataHeader }).FirstOrDefault();
if (output_data == null)
{
output_data = new DataCell()
{
Header = command_header.OutputDataHeader,
//HasValue = false,
HasValue = null,
Data = null
};
}
var function = _functionRepository.Get(new[] { command_header.FunctionHeader }).FirstOrDefault();
if (empty_input_data.Any() || function == null)
{
not_ready_data = new Tuple <FunctionHeader, List <DataCellHeader> >(function == null ? command_header.FunctionHeader : null, empty_input_data);
return(null);
}
return(new Command()
{
Header = new InvokeHeader()
{
CallStack = command_header.CallStack
},
Function = function,
InputData = input_data,
OutputData = output_data
});
}
public void PrepareCommand(CommandHeader command_header)
{
if (_preparingCommands.ContainsKey(command_header.Token))
{
throw new NotImplementedException("PreparationCommandService.PrepareCommand Такая команда уже находится в подготовке");
}
// Добавляем новую команду, находящуюся в процессе подготовки.
if (TryCreateCommand(command_header, out Command new_command))
{
OnPreparedCommand(new_command);
}
}
private Tuple <FunctionHeader, List <DataCellHeader> > InvokeOrSendToWait(CommandHeader command_headers, Action <Command> invoke_method)
{
Tuple <FunctionHeader, List <DataCellHeader> > not_ready_data;
var command = CreateCommand(command_headers, out not_ready_data);
if (command == null)
{
return(not_ready_data);
}
invoke_method(command);
return(null);
}
public static byte[] Serialize(this RequestCommand requestCommand, CommandHeader commandHeader, out string networkPayloadHash)
{
if (commandHeader == CommandHeader.Yes)
{
var bodyPart = Serialize(requestCommand.Contents);
networkPayloadHash = NetworkPayloadHash.ComputeAsGuidString(bodyPart);
return(bodyPart.AddHeader(requestCommand.CommandId));
}
var body = Serialize(requestCommand.Contents);
networkPayloadHash = NetworkPayloadHash.ComputeAsGuidString(body);
return(body);
}
public Byte[] CreateWriteParametersMessage(UserParameters p)
{
var size = Marshal.SizeOf(parametersMessage);
buffer = new Byte[size];
CommandHeader datagram = new CommandHeader();
SingleTaskCommand order = datagram.order;
order.task = Commands.WriteParameters;
datagram.order = order;
ParametersMessage m;
m.header = order;
m.parameters = p;
buffer.Initialize();
Buffer.BlockCopy(GetWriteParametersArrayBytes(m), 0, buffer, 0, size);
return(buffer);
}
public CommandHandlingService(DiscordSocketClient client, CommandService commands, XDocument configXML, bool devMode)
{
this._client = client;
this._commands = commands;
this._devMode = devMode;
var prefixQuery = from pre in configXML.Descendants("General")
select pre;
foreach (var item in prefixQuery)
{
this._prefix = item.Element("Prefix").Value[0];
}
this._header = new CommandHeader();
this._commandsWithPrivilegs = CompleteCommandListWithPropertys();
this._client.MessageReceived += MessageReceived;
}
private ExpoMessageOutput callService(uint appClassId, uint commandId, ExpoMessageInput request)
{
request.RequestMessageId = Guid.NewGuid().ToString();
var header = new CommandHeader(request.UserId, appClassId, commandId);
object[] retValues = null;
bool isSuccess = _proxy.DoCommandProxy(header, request.BuidExpoMessageBody(), out retValues);
if (isSuccess)
{
var response = new ExpoMessageOutput(retValues);
return(response);
}
else
{
throw new Exception("unknow error!");
}
}
private void Parse(byte[] bytes, TcpClient tcpClient)
{
if (bytes.Length >= CommandHeader.GetLenght())
{
CommandHeader commandHeader = CommandHeader.FromBytes(bytes);
IEnumerable <byte> nextCommandBytes = bytes.Skip(CommandHeader.GetLenght());
switch ((CommandTypeEnum)commandHeader.Type)
{
case CommandTypeEnum.QueryCommand:
QueryCommand presentationFileCommand = QueryCommand.FromBytes(nextCommandBytes.ToArray());
OnQueryCommand(presentationFileCommand, tcpClient);
break;
case CommandTypeEnum.ClearLogDataGrid:
OnClearLogDataGrid(tcpClient);
break;
}
}
}
/// <summary>
/// Для уже существующих заголовков команд добаляет в список владельцев новых владельцев команды.
/// Новые команды отправляет на подготовку к исполнению.
/// </summary>
/// <param name="command_header"></param>
public void AddNewCommandHeader(CommandHeader command_header)
{
//Console.WriteLine("! AddNewCommandHeader {0}", command_header.CallstackToString());
if (_allCommandHeaders.ContainsKey(command_header.Token))
{
CommandHeader header;
if (_allCommandHeaders.TryGetValue(command_header.Token, out header))
{
header.AddOwners(command_header.Owners);
}
else
{
throw new NotImplementedException("DataFlowLogicsService.AddNewCommandHeader Не удалось получить.");
}
}
else
{
if (!_allCommandHeaders.TryAdd(command_header.Token, command_header))
{
throw new NotImplementedException("DataFlowLogicsService.AddNewCommandHeader _allCommandHeaders Не удалось добавить.");
}
if (_jobManager.HasFreeJob())
{
if (!_preparationCommandHeaders.TryAdd(command_header.Token, command_header))
{
throw new NotImplementedException("DataFlowLogicsService.AddNewCommandHeader _rawCommandHeaders Не удалось добавить.");
}
_preparationCommandService.PrepareCommand(command_header);
//Console.WriteLine("! AddNewCommandHeader _preparationCommandHeaders {0}", command_header.CallstackToString());
}
else
{
if (!_awaitingPreparationCommandHeaders.TryAdd(command_header.Token, command_header))
{
throw new NotImplementedException("DataFlowLogicsService.AddNewCommandHeader _rawCommandHeaders Не удалось добавить.");
}
}
}
}
/// <summary>
/// Проверяет, что для команды либо нет услувий, либо хотя бы одно условие уже получено.
/// </summary>
/// <param name="command_header">Заголовок команды.</param>
/// <param name="condition_data_cells">Условия.</param>
/// <returns>True, если нет условий или хотя бы одно условие уже получено.</returns>
private bool CheckCommandCodition(CommandHeader command_header, out List <DataCell> condition_data_cells)
{
condition_data_cells = new List <DataCell>();
var condition_data_cells_out = new List <DataCell>();
if (command_header.ConditionDataHeaders.Any() && !command_header.ConditionDataHeaders.Any(x =>
{
var data = GetDataCell(x);
condition_data_cells_out.Add(data);
return(data.HasValue != null && data.HasValue.Value);
}))
{
if (_waitConditionCommands.TryAdd(command_header.Token, command_header))
{
//throw new NotImplementedException("PreparationCommandService.CheckCommandCodition не удалось добавить.");
}
foreach (var input_dataa in command_header.ConditionDataHeaders)
{
if (_dataLinksWithCommands.ContainsKey(input_dataa.Token))
{
_dataLinksWithCommands[input_dataa.Token].Add(command_header.Token);
}
else
{
_dataLinksWithCommands[input_dataa.Token] = new List <string>()
{
command_header.Token
};
}
}
return(false);
}
condition_data_cells.AddRange(condition_data_cells_out);
return(true);
}
public ClientAsync(string server, int port, PropertyInfo propertyInfo, CommandHeader header, Action <T> callback) : base(null, 0, null, null, null)
{
_server = server;
_port = port;
_header = header;
header.ReadData = true;
_propertyInfo = propertyInfo;
init();
while (true)
{
int len = _stream.ReadInt();
if (len == -1)
{
break;
}
var bs = _stream.ReceiveDatas(len);
var content = Encoding.UTF8.GetString(bs);
callback(Newtonsoft.Json.JsonConvert.DeserializeObject <T>(content));
}
header.ReadData = false;
new Thread(runForSend).Start();
}
public UpdateLocalsCommand(CommandHeader cmdHeader)
: base(cmdHeader)
{
}
public virtual void Execute(Function function, IEnumerable <DataCell> input_data, DataCell output, CommandContext command_context = null)
{
var control_function = (ControlFunction)function;
var input_data_count = input_data.Count();
var tmp_count = control_function.Commands.Count() + input_data_count /* + 1*/;
// Локальный массив временных данных функции. Добавляем выходные данные нулевым элементом.
var tmp_array = new List <DataCell>(tmp_count)
{
output
};
// Добавляем входные данные.
tmp_array.AddRange(input_data);
int count = input_data.Count() + 1;
// Добавляем ячейки для всех остальных команд.
for (int i = 0; i < control_function.Commands.Count() - 1; i++)
{
var callstack = command_context.Header.CallStack.ToList();
callstack.Add(function.GetHeader <FunctionHeader>().CallstackToString("."));
callstack.Add(string.Format("tmp_var_{0}", i + count));
var data = new DataCell()
{
Header = new DataCellHeader()
{
CallStack = callstack.ToArray()
},
Data = null,
HasValue = null
};
tmp_array.Add(data);
}
// Добавляем ячейки с константами.
for (int i = 0; i < control_function.Constants.Count; i++)
{
var callstack = new List <string>();
callstack.Add(function.GetHeader <FunctionHeader>().CallstackToString("."));
callstack.Add(string.Format("const_{0}", i));
var data = new DataCell()
{
Header = new DataCellHeader()
{
CallStack = callstack.ToArray()
},
Data = control_function.Constants[i],
HasValue = true
};
tmp_array.Add(data);
}
// Создаем список новых команд.
var command_list = control_function.Commands.ToList();
// Добаляем новые команды на исполнение
foreach (var command_template in command_list)
{
var callstack = command_context.Header.CallStack.ToList();
callstack.Add(string.Format("{0}<{1}>", command_template.FunctionHeader.CallstackToString("."), command_template.OutputDataId));
var new_command_header = new CommandHeader
{
Owners = new List <Owner>(),
CallStack = callstack.ToArray(),
InputDataHeaders = command_template.InputDataIds.Select(x => (DataCellHeader)tmp_array[x].Header).ToList(),
OutputDataHeader = (DataCellHeader)tmp_array[command_template.OutputDataId].Header,
TriggeredCommands = command_template.TriggeredCommandIds.Select(x => command_list[x].Header).ToList(),
FunctionHeader = command_template.FunctionHeader,
ConditionDataHeaders = command_template.ConditionId.Select(x => (DataCellHeader)tmp_array[x].Header).ToList()
};
Parallel.Invoke(() => { _dataFlowLogicsService.AddNewCommandHeader(new_command_header); });
}
}
public UnBreakAtLineCommand(CommandHeader cmdHeader)
: base(cmdHeader)
{
}
static void Main(string[] args)
{
///TCP port k
string ip_str; // zmienna IP - adres IP, zapisana w stringu
Console.WriteLine("Podaj adres IP serwera"); //komunikat tekstowy w konsoli
ip_str = Console.ReadLine(); // zczytanie adresu ip do zmiennej string
IPAddress ip_address = IPAddress.Parse(ip_str); // parsowanie ip string do klasy IPAddress, wczytanie zmiennej
Console.WriteLine("Podaj nr portu, na ktorym chcesz nawiazac polaczenie"); // komunikat tekstowy w konsoli
int port_k; // zmienna int - numer portu k, sluzy do nawiazywania polaczenia przez klienta
port_k = Convert.ToInt32(Console.ReadLine()); // wczytanie zmiennej, parsowanie do int
TcpClient client = new TcpClient(); // inicjacja instancji klasy TcpKlient
try
{
client.Connect(ip_str, port_k); // polaczenie sie za pomoca TCP na podanym IP i porcie k
}
catch (System.Net.Sockets.SocketException)
{
Console.WriteLine("Zrestartuj program, sprawdz polaczenie sieciowe lub poprawnosc danych serwera!");
Console.ReadKey();
return;
}
UdpClient clientUDP = new UdpClient(); // inicjacja klasy client UDP
IPEndPoint host = new IPEndPoint(ip_address, port_k + 1); //zdef. zdalnego hosta dla polaczenia UDP
CommandHeader header_s; // zbudowany przez nas naglowek
//wstepna nieznaczaca inicjalizacja danych
//stworzona na potrzeby sytuacja nieprzewidzianych
string command = "BUSY";
string data = "";
int id_i = 0;
header_s.id_num = id_i;
header_s.command_length = 3;
header_s.port = ((IPEndPoint)client.Client.LocalEndPoint).Port; // port przy wysylaniu UDP jest ustawiony na domyslny lokalny port TCP
header_s.data_length = 0;
header_s.part_num = 0;
header_s.last_part = 1;
/*
* COMMAND_LENGTH|ID_NUM |PORT |DATA_LENGTH |PART_NUM |LAST_PART |COMMAND |DATA
* 1B |4B |4B |4B |4B |1B |COMMAND_LENGTHB |DATA_LENGTHB
* fixed |fixed |fixed |fixed |fixed |fixed |vary |vary
* as bits value |bits value|bits value |bits value |bits value |T/F |as string |string
* HEADER PART | command+data part
* 18B | command_length+data_length bytes
*
*
* COMMAND_LENGTH - dl polecenia
* COMMAND - polecenie(nazwa)
* ID_NUM - identyfikator polecenia (w odpowiedzi będzie taki sam co przysłany, pozwala na identyfikację
* czego dotyczy odpowiedź, każde następne o 1 większe) >=1
* PORT - dla pakietów UDP zawiera odpowiadający port TCP, a dla połączeń TCP odpowiadający port UDP
* DATA_LENGTH - dl przesylanych danych
* LAST_PART - czy to ostatni fragment danych, jeżeli nie to można spodziewać się następnych komunikatów związanych z tym poleceniem (wówczas ID_NUM nie będzie zmieniane)
* 0 - to nie jest ostatni part
* >0 - to jest ostatni part
* w TCP zawsze >0
* DATA - ewentualne dane
* PART_NUM - numer części (offset) >=0, potrzebny przy wysyłaniu większych komunikatów przez UDP, w TCP nieużywany
* w praktyce raczej nie będziemy tego używali
*
* wartości liczbowe(w nagłówku) przesyłane w BigEndian (network endian)
*
* obsługiwane komunikaty:
* GET, DISCONNECT, OK
*
* obsługiwane odpowiedzi:
* OK, NOTCONNECTED, UNSUPPORTED, BUSY, DATA
*
* commands e.g.
* klient -> serwer
* 3100TGET - rządanie wysłania bloku danych (port k+1)
* 10200TDISCONNECT - zainicjowanie rozłączenia (port k+1)
*
* responses e.g.
* serwer->client
* 2100TOK (port k+1) - potwierdzenie odbioru komunikatu, i to że zostaje przetworzone
* 12100TNOTCONNECTED (port k+1) - informacja zwrotna, że klient nie jest połączony na porcie k
* 4100TBUSY (port k+1) - informacja zwrotna, że serwer aktualnie przetwarza inne żądanie
* 4250FDATAVALUE (port k) - komunikat z zawartością bloku danych (lub jego fragmentu, tak jak w tym przypadku)
* 4261TDATAVALUE1 (port k) - komunikat z zawartością ostatniej części bloku danych (flaga LAST_PART)
*
* scenariusze klient->serwer
* I.
* 1. klient wysyła GET (port k+1)
* 2. serwer odsyła OK, NOTCONNECTED lub BUSY w zależności od sytuacji (port k+1)
* 3. jeżeli serwer wysłał OK to przesyła komunikat DATA (port k)
*
* II.
* 1. klient wysyła DISCONNECT (port k+1)
* 2. serwer odsyła OK, NOTCONNECTED lub BUSY w zależności od sytuacji (port k+1)
* 3. jeżeli serwer wysłał OK, to klient odsyła OK (k+1) i zamyka połączenie (k)
* 4. serwer odbiera OK i zamyka połączenie po swojej stronie (k)
*
* III.
* 1. klient wysyła TRALALALA(nie wspierane polecenie) (port k+1)
* 2. serwer odsyła NOTCONNECTED lub UNSUPPORTED w zależności od sytuacji (k+1)
*
*/
//zmienne na pobrane polecenie i dane
byte[] recv; // tablica na przychodze dane
byte[] dane; // tablica do ktorej beda serializowane dane
NetworkStream ns = client.GetStream(); //obiekt strumienia danych
while (command == "BUSY" || command == "UNSUPPORTED")
{
Thread.Sleep(500);
++id_i;
header_s.id_num = id_i;
header_s.command_length = 3;
header_s.port = ((IPEndPoint)client.Client.LocalEndPoint).Port; // port przy wysylaniu UDP jest ustawiony na domyslny lokalny port TCP
header_s.data_length = 0;
header_s.part_num = 0;
header_s.last_part = 1;
dane = MessageHelper.serialize(ref header_s, "GET", ""); // serializacja danych, dane naglowka w postaci bitow
// dane oraz polecenie w postaci zakodowanych znakow ASCII
clientUDP.Send(dane, dane.Length, host); // wysylanie danych
Console.WriteLine("3100TGET zostal wyslany* \n");
//zapisanie odebranych danych to tablicy bajtów:
recv = clientUDP.Receive(ref host);
CommandHeader.getHeader(recv, ref header_s); // pobranie danych naglowkowych z tablicy bajtow
MessageHelper.unserialize(recv, ref header_s, ref command, ref data); // deserializacja komendy i danych
//wypisanie danych odpowiedzi na ekran
Console.WriteLine("ID_NUM: " + header_s.id_num);
Console.WriteLine("COMMAND_LENGTH: " + header_s.command_length);
Console.WriteLine("PORT: " + header_s.port);
Console.WriteLine("DATA LENGTH: " + header_s.data_length);
Console.WriteLine("PORT NUM: " + header_s.part_num);
Console.WriteLine("PORT LAST PART: " + header_s.last_part);
Console.WriteLine("CMD: " + command);
Console.WriteLine("DATA SENT: " + data + " \n");
}
if (command == "NOTCONNECTED")
{
while (true)
{
Console.WriteLine("Zrestartuj program, sprawdz polaczenie sieciowe lub poprawnosc danych serwera!");
Console.ReadKey();
}
}
else if (command == "OK")
{
//Pobranie referencji do obiektu strumienia
ns = client.GetStream();
int totalBytesReaded = 0; // wszystkie odczytane bajty
int readed = 0; // aktualnie odczytywane bajty
int bytesReaded = 0; //odczytane bajty w pewnych zakresach (naglowek, cz. danych, komenda etc.)
byte[] bytes = new byte[CommandHeader.HEADER_SIZE]; // o wielkosci naglowka
while (bytesReaded < CommandHeader.HEADER_SIZE) //odczytywanie czesci naglowkowej:
{
readed = ns.Read(bytes, bytesReaded, CommandHeader.HEADER_SIZE - bytesReaded);
totalBytesReaded += readed;
bytesReaded += readed;
}
CommandHeader header = new CommandHeader();
//odczytywanie komendy
if (CommandHeader.getHeader(bytes, ref header))
{
bytes = new byte[header.command_length];
bytesReaded = 0;
while (bytesReaded < header.command_length)
{
readed = ns.Read(bytes, bytesReaded, header.command_length - bytesReaded);
totalBytesReaded += readed;
bytesReaded += readed;
}
string recv_command = Encoding.ASCII.GetString(bytes); //komenda dekodowana do postaci Stringa
//odczytywanie danych:
bytes = new byte[header.data_length];
bytesReaded = 0;
while (bytesReaded < header.data_length)
{
readed = ns.Read(bytes, bytesReaded, header.data_length - bytesReaded);
totalBytesReaded += readed;
bytesReaded += readed;
}
string recv_data = Encoding.ASCII.GetString(bytes); //dane dekodowane do postaci Stringa
Console.WriteLine("ID_NUM: " + header.id_num);
Console.WriteLine("COMMAND_LENGTH: " + header.command_length);
Console.WriteLine("PORT: " + header.port);
Console.WriteLine("DATA LENGTH: " + header.data_length);
Console.WriteLine("PORT NUM: " + header.part_num);
Console.WriteLine("PORT LAST PART: " + header.last_part);
Console.WriteLine("CMD: " + recv_command);
Console.WriteLine("DATA SENT: " + recv_data + " \n");
}
}
command = "BUSY";
while (command == "BUSY")
{
Thread.Sleep(500);
//przygotowanie danych do wyslania polecenia DISCONNECT
id_i++;
header_s.id_num = id_i;
header_s.command_length = 10;
header_s.port = ((IPEndPoint)client.Client.LocalEndPoint).Port;
header_s.data_length = 0;
header_s.part_num = 0;
header_s.last_part = 1;
// 10200TDISCONNECT
dane = MessageHelper.serialize(ref header_s, "DISCONNECT", ""); // serializacja datagramu
clientUDP.Send(dane, dane.Length, host); // wyslanie datagramu
Console.WriteLine("10200TDISCONNECT zostal wyslany* \n"); //potwierdzenie wyslania w konsoli
recv = clientUDP.Receive(ref host); // pobieramy odpowiedz zwrotną
//zerujemy zmienne
command = "";
data = "";
CommandHeader.getHeader(recv, ref header_s); //pobieranie danych naglowkowych
MessageHelper.unserialize(recv, ref header_s, ref command, ref data); //deserializacja danych
//wypisanie odpowiedzi
Console.WriteLine("ID_NUM: " + header_s.id_num);
Console.WriteLine("COMMAND_LENGTH: " + header_s.command_length);
Console.WriteLine("PORT: " + header_s.port);
Console.WriteLine("DATA LENGTH: " + header_s.data_length);
Console.WriteLine("PORT NUM: " + header_s.part_num);
Console.WriteLine("PORT LAST PART: " + header_s.last_part);
Console.WriteLine("CMD: " + command);
Console.WriteLine("DATA SENT: " + data + " \n");
}
if (command == "NOTCONNECTED")
{
while (true)
{
Console.WriteLine("Zrestartuj program, sprawdz polaczenie sieciowe lub poprawnosc danych serwera!");
Console.ReadKey();
}
}
else if (command == "OK")
// jezeli odpowiedz to OK to odsylamy rowniez OK aby zakonczyc polaczenie
{
// id_i++;
header_s.id_num = id_i;
header_s.command_length = 2;
header_s.port = ((IPEndPoint)client.Client.LocalEndPoint).Port;
header_s.data_length = 0;
header_s.part_num = 0;
header_s.last_part = 1;
dane = MessageHelper.serialize(ref header_s, "OK", "");
clientUDP.Send(dane, dane.Length, host);
Console.WriteLine("2100TOK zostal wyslany* \n");
//zamkniecie strumieni
ns.Close();
client.Close();
clientUDP.Close();
Console.WriteLine("Polaczenie zostalo przerwane, konczenie programu");
Console.ReadKey();
}
}
public DebugActionCommand(CommandHeader cmdHeader)
: base(cmdHeader)
{
}
public LuaOutputCommand(CommandHeader cmdHeader)
: base(cmdHeader)
{
}
public SetLuaVariableCommand(CommandHeader cmdHeader)
: base(cmdHeader)
{
}
public RunToCommand(CommandHeader cmdHeader)
: base(cmdHeader)
{
}
/// <summary>
/// Пытается созадть готовую к исполнению команду. Если команда не может быть исполнена на данный момент, то возвращает false.
/// </summary>
/// <param name="command_header">Заголовок команды.</param>
/// <param name="new_command">Созданная команда.</param>
/// <returns>Удалось ли создать готовую к исполнению команду.</returns>
private bool TryCreateCommand(CommandHeader command_header, out Command new_command)
{
new_command = null;
// Если условия ещё не готовы, то возвращаем null.
if (!CheckCommandCodition(command_header, out List <DataCell> condition_data))
{
return(false);
}
// Если нет ни одного истинного условия, то возвращаем null.
if (condition_data.Any(x => x.HasValue.HasValue && x.HasValue.Value && !(bool)x.Data))
{
return(false);
}
// Подготавливае места для ячеек с выходными данными.
var count = command_header.InputDataHeaders.Count;
var input_data = new DataCell[count];
new_command = new Command()
{
Header = new InvokeHeader()
{
CallStack = command_header.CallStack
},
InputData = input_data.ToList(),
OutputData = GetOutputData(command_header.OutputDataHeader),
ConditionData = condition_data
};
var all_ready = true;
switch (command_header.FunctionHeader.Condition)
{
case InputParamCondition.All:
// Получаем или подписываемся на получение входных параметров.
for (int i = 0; i < command_header.InputDataHeaders.Count; i++)
{
var result = GetDataCell(command_header.InputDataHeaders[i]);
new_command.InputData[i] = result;
if (result.HasValue == null)
{
all_ready = false;
}
}
break;
case InputParamCondition.Any:
var any = false;
// Получаем или подписываемся на получение входных параметров.
for (int i = 0; i < command_header.InputDataHeaders.Count; i++)
{
var result = GetDataCell(command_header.InputDataHeaders[i]);
new_command.InputData[i] = result;
if (result.HasValue != null && result.HasValue.Value)
{
any = true;
}
}
if (!any)
{
all_ready = false;
}
break;
default:
throw new Exception($"CreateNewCommand Неизвестный тип: {command_header.FunctionHeader.Condition}");
}
if (!all_ready)
{
AddCommandToPreparing(new_command);
}
_dataCellRepository.Add(new_command.InputData.Where(x => x.HasValue == null), false);
// Получаем или подписываемся на получение функций.
var function = _functionRepository.Get(command_header.FunctionHeader.Token).FirstOrDefault();
if (function == null)
{
if (all_ready)
{
all_ready = false;
AddCommandToPreparing(new_command);
}
//_functionRepository.Subscribe(function_header, OnFunctionReady);
// TODO: нужно отправлять запросы на другие узлы для получения функции.
}
else
{
new_command.Function = function;
}
return(all_ready);
}
public UpdateTableDetailsCommand(CommandHeader cmdHeader)
: base(cmdHeader)
{
}
public CopyScriptCommand(CommandHeader cmdHeader)
: base(cmdHeader)
{
}
public LuaErrorCommand(CommandHeader cmdHeader)
: base(cmdHeader)
{
}
