Пример #1
0
        /// <summary>
        ///     Handle request from command
        /// </summary>
        /// <param name="request">Received request</param>
        /// <param name="account">Access to account</param>
        /// <param name="waitForFinish">If true, wait task to finish progress</param>
        /// <returns>Response for client</returns>

        #region G9CallHandler

        public void G9CallHandler(G9SendAndReceivePacket request, TAccount account, bool waitForFinish = false)
        {
            Action callCommand = () =>
            {
                CommandDataType <TAccount> command = null;
                try
                {
                    // Check exist command

                    #region Unhandled Command

                    if (!_accessToCommandDataTypeCollection.ContainsKey(request.Command))
                    {
                        _onUnhandledCommand?.Invoke(request, account);
                        return;
                    }

                    #endregion

                    // Get normal command
                    command = _accessToCommandDataTypeCollection[request.Command];

                    // Set log
                    if (_logging.CheckLoggingIsActive(LogsType.EVENT))
                    {
                        _logging.LogEvent(
                            $"{LogMessage.RunningCommand}: {request.Command}", G9LogIdentity.RUNNING_COMMAND,
                            LogMessage.SuccessfulOperation);
                    }

                    // Execute command with information
                    command.AccessToMethodReceiveCommand(request.Body, account, request.RequestId,
                                                         command.ExecuteRegisterCallBack);
                }
                catch (Exception ex)
                {
                    // Add to log exception
                    if (_logging.CheckLoggingIsActive(LogsType.EXCEPTION))
                    {
                        _logging.LogException(ex, LogMessage.ErrorInRunningCommand,
                                              G9LogIdentity.RUNNING_COMMAND, LogMessage.FailedOperation);
                    }

                    // If not null call OnError in this command
                    command?.AccessToMethodOnErrorInCommand?.Invoke(ex, account);
                }
            };

            if (waitForFinish)
            {
                callCommand.Invoke();
            }
            else
            {
                Task.Run(callCommand);
            }
        }
Пример #2
0
        public G9PacketSplitHandler PackingRequestByData(byte[] command, byte[] body,
                                                         G9PacketDataType dataType, Guid?customRequestId)
#endif
        {
            try
            {
                if (command.Length == CalculateCommandSize)
                {
                    var requestId      = customRequestId ?? Guid.NewGuid();
                    var requestIdBytes = requestId.ToByteArray();
                    G9PacketSplitHandler packet;
                    if (body.Length <= CalculateBodySize)
                    {
                        // Initialize packet split handler
                        packet = new G9PacketSplitHandler(requestId, 1);

                        // Initialize memory stream and save packet data
                        using (var memoryStream = new MemoryStream())
                        {
                            memoryStream.WriteByte((byte)G9PacketType.OnePacket);
                            memoryStream.WriteByte((byte)dataType);
                            memoryStream.WriteByte(checked ((byte)body.Length));
#if NETSTANDARD2_1 || NETCOREAPP3_0 || NETCOREAPP3_1
                            memoryStream.Write(command);
                            memoryStream.Write(body);
                            memoryStream.Write(requestIdBytes);
#else
                            memoryStream.Write(command, 0, command.Length);
                            memoryStream.Write(body, 0, body.Length);
                            memoryStream.Write(requestIdBytes, 0, requestIdBytes.Length);
#endif

                            // Add packet
                            packet.AddPacket(0, memoryStream.ToArray());
                        }
                    }
                    else
                    {
                        // Calculate packet size
                        var counter = (byte)Math.Ceiling(body.Length / (decimal)CalculateBodySize);

                        // Packet size plus one => because first packet specify packet count information
                        // counter.ToString().Length * counter => Reserve first byte for packet number
                        counter = (byte)(Math.Ceiling(((decimal)body.Length +
                                                       counter.ToString().Length *counter) /
                                                      CalculateBodySize) + 1);

                        // Specify counter length
                        // counter length = 1 => Like byte 0 To 256
                        var counterLength = 1;

                        // Initialize packet split
                        packet = new G9PacketSplitHandler(requestId, counter);

                        // Initialize memory stream and save packet data
                        using (var memoryStream = new MemoryStream())
                        {
                            memoryStream.WriteByte((byte)G9PacketType.MultiPacket);
                            memoryStream.WriteByte((byte)dataType);
                            // First packet length is 2 | 0 => packet number | 1 => Total packet count
                            memoryStream.WriteByte(2);
#if NETSTANDARD2_1 || NETCOREAPP3_0 || NETCOREAPP3_1
                            memoryStream.Write(command);
#else
                            memoryStream.Write(command, 0, command.Length);
#endif
                            // write packet number
                            memoryStream.WriteByte(0);
                            // write total packet count
                            memoryStream.WriteByte(counter);
#if NETSTANDARD2_1 || NETCOREAPP3_0 || NETCOREAPP3_1
                            memoryStream.Write(requestIdBytes);
#else
                            memoryStream.Write(requestIdBytes, 0, requestIdBytes.Length);
#endif

                            // Set first packet => packet count information
                            packet.AddPacket(0, memoryStream.ToArray());
                        }

                        for (byte i = 1; i < counter; i++)
                        {
                            var newBodyStandardSize = CalculateBodySize - (i == 1
                                                          ? 0
                                                          : counterLength);

                            var offset = newBodyStandardSize * i - newBodyStandardSize;

                            var length = i == counter - 1
                                ? body.Length - offset
                                : CalculateBodySize - counterLength;

                            // Initialize memory stream and save packet data
                            using (var memoryStream = new MemoryStream())
                            {
                                memoryStream.WriteByte((byte)G9PacketType.MultiPacket);
                                memoryStream.WriteByte((byte)dataType);
                                memoryStream.WriteByte(checked ((byte)(length + 1)));
#if NETSTANDARD2_1 || NETCOREAPP3_0 || NETCOREAPP3_1
                                memoryStream.Write(command);
#else
                                memoryStream.Write(command, 0, command.Length);
#endif
                                memoryStream.WriteByte(i);
#if NETSTANDARD2_1 || NETCOREAPP3_0 || NETCOREAPP3_1
                                memoryStream.Write(body.Slice(offset, length));
                                memoryStream.Write(requestId.ToByteArray());
#else
                                memoryStream.Write(body, offset, length);
                                memoryStream.Write(requestIdBytes, 0, requestIdBytes.Length);
#endif


                                // Add total packet
                                packet.AddPacket(i, memoryStream.ToArray());
                            }
                        }
                    }

                    return(packet);
                }

                if (_logging.CheckLoggingIsActive(LogsType.EXCEPTION))
                {
                    _logging.LogException(new ArgumentException(
                                              $"{LogMessage.CommandLengthError}\n{LogMessage.StandardLength}: {CalculateCommandSize}\n{LogMessage.LengthEntered}: {command.Length}"),
                                          null, G9LogIdentity.GENERATE_PACKET, LogMessage.FailedOperation);
                }

                return(null);
            }
            catch (Exception ex)
            {
                if (_logging.CheckLoggingIsActive(LogsType.EXCEPTION))
                {
                    _logging.LogException(ex, LogMessage.FailGeneratePacket, G9LogIdentity.GENERATE_PACKET,
                                          LogMessage.FailedOperation);
                }
                return(null);
            }
        }