neton.network.ServerHandler source code

1 module neton.network.ServerHandler;
2 
3 import hunt.logging;
4 import hunt.util.Serialize;
5 
6 import hunt.net;
7 import hunt.raft;
8 
9 import core.stdc.string;
10 
11 import neton.network.Interface;
12 
13 import std.bitmanip;
14 import std.stdint;
15 
16 class ServerHandler
17 {
18 
19     enum PACK_HEAD_LEN = 4;
20 
21     this(MessageReceiver receiver)
22     {
23         // this.sock = sock;
24         this.receiver = receiver;
25         // sock.handler((in ubyte[] data) { onRead(data); });
26         // sock.closeHandler(() { onClose(); });
27     }
28 
29     void onRead(in ubyte[] data)
30     {
31         Message[] msgs;
32         int index = 0;
33         int length = cast(int) data.length;
34         int used;
35         while (index < length)
36         {
37             int left = length - index;
38             if (headLen < PACK_HEAD_LEN)
39             {
40                 if (left >= PACK_HEAD_LEN - headLen)
41                 {
42                     used = PACK_HEAD_LEN - headLen;
43                     header[headLen .. headLen + used] = data[index .. index + used];
44                     index += used;
45                     headLen += used;
46                     msgLen = bigEndianToNative!int32_t(header);
47                     buffer.length = 0;
48                     if (msgLen == 0)
49                     {
50                         msgs ~= unserialize!Message(cast(byte[]) buffer);
51                         headLen = 0;
52                     }
53                 }
54                 else
55                 {
56                     header[headLen .. headLen + left] = data[index .. index + left];
57                     index += left;
58                     headLen += left;
59                 }
60             }
61             else
62             {
63                 if (left >= msgLen - cast(int) buffer.length)
64                 {
65                     used = msgLen - cast(int) buffer.length;
66                     buffer ~= data[index .. index + used];
67                     index += used;
68                     msgs ~= unserialize!Message(cast(byte[]) buffer);
69                     headLen = 0;
70                 }
71                 else
72                 {
73                     buffer ~= data[index .. index + left];
74                     index += left;
75                 }
76             }
77 
78         }
79 
80         foreach (m; msgs)
81         {
82             // logDebug("recv a message " , m);
83             receiver.step(m);
84         }
85 
86     }
87 
88     void onClose()
89     {
90 
91     }
92 
93     // NetSocket sock;
94 
95     int msgLen;
96     ubyte[] buffer;
97     int headLen = 0;
98     ubyte[PACK_HEAD_LEN] header;
99     MessageReceiver receiver;
100 }