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) { }