示例#1
0
        internal void InitializeForSend(Converter converter, uint cmd, uint flags, object payload)
        {
            Packet header = new Packet
            {
                Seq   = _sequenceId,
                Cmd   = cmd,
                Flags = flags
            };

            Raw = new MessageRaw();

            Base = new MessageBase
            {
                Header  = header,
                Payload = payload
            };

            if (payload != null)
            {
                Raw.Payload = converter.Serialize(payload);

                Base.Header.Size    = (uint)Raw.Payload.Length;
                Base.Header.CrcData = CRC.ComputeCRC(Raw.Payload, 0);
            }
        }
示例#2
0
        protected override void Execute(TContext model)
        {
            var ev      = model.Event;
            var eventId = ev.ExtendedDatas()[Constants.EventId].GetValue(model).ToString();
            var taskId  = ev.ExtendedDatas()[Constants.TaskUuid].GetValue(model).ToString();

            if (model.Workflow.GetEvent(Guid.Parse(eventId), out Event e))
            {
                if (e.GetAction(Guid.Parse(taskId), out PushedAction a))
                {
                    a.Change = ChangeEnum.New;
                    var i    = model.IncomingEvent;
                    var m    = new MessageRaw();
                    var body = new MessageBlock()
                               .Add(nameof(i.CreationDate), i.CreationDate.ToString())
                               .Add(nameof(i.EventDate), i.EventDate.ToString())
                    ;

                    foreach (var item in i.ExtendedDatas().Items)
                    {
                        body.Add(item.Key, item.Value.GetValue(model));
                    }

                    m.Body          = body;
                    a.ResultMessage = m;
                }
            }
        }
示例#3
0
        private void Xmpp_OnMessage(object sender, Message msg)
        {
            Friend friend;

            if (friends.TryGetValue(msg.From.User, out friend))
            {
                OnMessage(new ChatMessage(msg.From.User, msg, false));
            }
            else
            {
                MessageRaw?.Invoke(this, msg);
            }
        }
示例#4
0
        public async Task <int> Fetch(ITargetBlock <MessageRaw> buffer, long fromPosition, int limit, CancellationToken cancellationToken = default(CancellationToken))
        {
            using (var cnn = new SqlConnection(_connectionString))
            {
                var cmd = cnn.CreateCommand();
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.CommandText = spuReadAllStreamsForward;
                cmd.AddInputParam(limitParamName, SqlDbType.Int, limit);
                cmd.AddInputParam(fromPositionParamName, SqlDbType.Int, fromPosition);

                await cnn.OpenAsync(cancellationToken).NotOnCapturedContext();

                var rows = 0;
                using (var reader = await cmd.ExecuteReaderAsync(CommandBehavior.SingleResult, cancellationToken).NotOnCapturedContext())
                {
                    while (await reader.ReadAsync(cancellationToken).NotOnCapturedContext())
                    {
                        var raw = new MessageRaw
                        {
                            StreamId               = reader.GetString(colIndexForStreamName),
                            MessageContractName    = reader.GetString(colIndexForContractName),
                            CorrelationId          = reader.GetGuid(colIndexForCorrelationId),
                            Timestamp              = reader.GetDateTime(colIndexForTimestamp),
                            MessageId              = reader.GetGuid(colIndexForMessageId),
                            MessageVersion         = reader.GetInt32(colIndexForMessageVersion),
                            MessagePosition        = reader.GetInt64(colIndexForMessagePosition),
                            MessagePayload         = reader.GetStream(colIndexForMessagePayload),
                            MessageMetadataPayload = reader.IsDBNull(colIndexForMessageMetadataPayload)
                                ? null
                                : reader.GetStream(colIndexForMessageMetadataPayload)
                        };

                        await buffer.SendAsync(raw, cancellationToken).NotOnCapturedContext();

                        rows++;
                    }
                }
                return(rows);
            }
        }
        internal void InitializeForSend( IController parent, Converter converter, uint cmd, uint flags, object payload )
        {
            Packet header = parent.NewPacket();

            header.m_cmd   = cmd;
            header.m_flags = flags;

            m_parent              = parent;

            m_raw                 = new MessageRaw ();
            m_base                = new MessageBase();
            m_base.m_header       = header;
            m_base.m_payload      = payload;

            if(payload != null)
            {                
                m_raw.m_payload = converter.Serialize( payload );

                m_base.m_header.m_size    = (uint)m_raw.m_payload.Length;
                m_base.m_header.m_crcData = CRC.ComputeCRC( m_raw.m_payload, 0 );
            }
        }
        internal void InitializeForSend(IController parent, Converter converter, uint cmd, uint flags, object payload)
        {
            Packet header = parent.NewPacket();

            header.m_cmd   = cmd;
            header.m_flags = flags;

            m_parent = parent;

            m_raw            = new MessageRaw();
            m_base           = new MessageBase();
            m_base.m_header  = header;
            m_base.m_payload = payload;

            if (payload != null)
            {
                m_raw.m_payload = converter.Serialize(payload);

                m_base.m_header.m_size    = (uint)m_raw.m_payload.Length;
                m_base.m_header.m_crcData = CRC.ComputeCRC(m_raw.m_payload, 0);
            }
        }
 public IncomingMessage(IController parent, MessageRaw raw, MessageBase messageBase)
 {
     _parent = parent;
     _raw    = raw;
     _base   = messageBase;
 }
 public IncomingMessage( IController parent, MessageRaw raw, MessageBase messageBase)
 {
     m_parent = parent;
     m_raw    = raw;
     m_base   = messageBase;
 }
 public static JToken Serialize(this MessageRaw self)
 {
     return(visitor.VisitMessageRaw(self));
 }
示例#10
0
 public abstract T VisitMessageRaw(MessageRaw m);
示例#11
0
        public static void SendMessage(BinaryWriter stream, INetMessage msg)
        {
            var msgRaw = new MessageRaw(msg);

            msgRaw.WriteTo(stream);
        }
示例#12
0
        static INetMessage OnReceivedMessage(MessageRaw msg, Side side)
        {
            if (messageTypes.TryGetValue(msg.type, out var msgType))
            {
                var netMsg = (INetMessage)Activator.CreateInstance(msgType);

                netMsg.Side = side;

                using (var ms = new MemoryStream(msg.data))
                {
                    var subId = -1;
                    try
                    {
                        netMsg.OnDeserialize(new BinaryReader(ms));
                        if (netMsg is Msg82NetModule netModule)
                        {
                            subId = netModule.moduleId;

                            if (subId == 1)
                            {
                                if (netMsg.Side == Side.Server)
                                {
                                    Console.WriteLine($"<{netMsg.Side}> : {((NetworkText)netModule.moduleValue["text"]).text}");
                                }
                            }
                        }
                    }
                    catch (NotImplementedException e)
                    {
                        throw e;
                    }
                    catch (Exception e)
                    {
                        throw new Exception($"(SubPackage:{subId}) Failed to deserialize message\n" + e.ToString());
                    }
                    //Console.WriteLine($"Reveiced msg {msg.type} from " + netMsg.Side.ToString());

                    if (ms.Position != ms.Length)
                    {
                        throw new Exception($"(SubPackage:{subId}) Part of the data is not read");
                    }

                    // check whether the serialized result is same
                    byte[] data = null;
                    using (var memorystream = new MemoryStream())
                        using (var testWriter = new BinaryWriter(memorystream))
                        {
                            netMsg.OnSerialize(testWriter);
                            memorystream.Seek(0, SeekOrigin.Begin);
                            data = new byte[memorystream.Length];
                            memorystream.Read(data, 0, (int)memorystream.Length);
                        }

                    for (var i = 0; i < data.Length; ++i)
                    {
                        if (data[i] != msg.data[i])
                        {
                            Console.WriteLine($"Warning: (SubPackage:{subId}) Serialized result is not same with the original one");
                            break;
                        }
                    }
                }
                return(netMsg);
            }
            else
            {
                Console.WriteLine($"Unknown msg {msg.type}");
            }
            return(null);
        }
示例#13
0
        static Task StartForward(NetworkStream from, NetworkStream to)
        {
            var task = new Task(() =>
            {
                while (serverConnection.Connected && playerConnection.Connected)
                {
                    MessageRaw msg;
                    try
                    {
                        var reader = new BinaryReader(from);
                        msg        = new MessageRaw(reader);
                    }
                    catch
                    {
                        break;
                    }

                    INetMessage netMessage = null;

                    try
                    {
                        if (from == serverStream)
                        {
                            netMessage = OnReceivedMessage(msg, Side.Server);
                        }
                        else
                        {
                            netMessage = OnReceivedMessage(msg, Side.Client);
                        }
                    }
                    catch (NotImplementedException)
                    {
                        Console.WriteLine($"An not implemented message {msg.type}");
                        netMessage = null;
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine($"Failed to read net message {msg.type} because {e.Message}");
                        netMessage = null;
                    }

                    try
                    {
                        if (netMessage != null)
                        {
                            try
                            {
                                using (var memoryStream = new MemoryStream())
                                {
                                    if (msg.type == Msg10SendSection.ID)
                                    {
                                        var sectionData = (Msg10SendSection)netMessage;
                                        foreach (var tile in sectionData.tiles)
                                        {
                                            tile.Value.wall = 0;
                                        }
                                    }
                                    if (msg.type == Msg16PlayerHP.ID)
                                    {
                                        var playerHp   = (Msg16PlayerHP)netMessage;
                                        playerHp.maxHp = 1000;
                                        playerHp.hp    = 1000;
                                    }
                                    using (var writer = new BinaryWriter(memoryStream))
                                    {
                                        netMessage.OnSerialize(writer);
                                        var message    = new MessageRaw();
                                        message.type   = msg.type;
                                        message.length = (short)(memoryStream.Length + 3);
                                        message.data   = memoryStream.GetBuffer();

                                        var netWriter = new BinaryWriter(to);
                                        message.WriteTo(netWriter);
                                    }
                                }
                            }
                            catch (Exception e)
                            {
                                Console.WriteLine($"Failed to serialize net message {msg.type} because {e.Message}");
                                var writer = new BinaryWriter(to);
                                msg.WriteTo(writer);
                            }
                        }
                        else
                        {
                            var writer = new BinaryWriter(to);
                            msg.WriteTo(writer);
                        }
                    }
                    catch (Exception e)
                    {
                        break;
                    }
                }
            });

            task.Start();
            return(task);
        }