| author | alfadur |
| Mon, 08 Apr 2019 22:16:44 +0300 | |
| changeset 14780 | 09d46ab83361 |
| parent 14462 | 98ef2913ec73 |
| child 14782 | 8015a6e4ca3c |
| permissions | -rw-r--r-- |
|
13436
6a818f9192f4
Implement parsing for rnd and add a little documentation
Marcin Mielniczuk <marmistrz.dev@zoho.eu>
parents:
13428
diff
changeset
|
1 |
/** The parsers for the chat and multiplayer protocol. The main parser is `message`. |
|
6a818f9192f4
Implement parsing for rnd and add a little documentation
Marcin Mielniczuk <marmistrz.dev@zoho.eu>
parents:
13428
diff
changeset
|
2 |
* # Protocol |
|
6a818f9192f4
Implement parsing for rnd and add a little documentation
Marcin Mielniczuk <marmistrz.dev@zoho.eu>
parents:
13428
diff
changeset
|
3 |
* All messages consist of `\n`-separated strings. The end of a message is |
|
6a818f9192f4
Implement parsing for rnd and add a little documentation
Marcin Mielniczuk <marmistrz.dev@zoho.eu>
parents:
13428
diff
changeset
|
4 |
* indicated by a double newline - `\n\n`. |
|
6a818f9192f4
Implement parsing for rnd and add a little documentation
Marcin Mielniczuk <marmistrz.dev@zoho.eu>
parents:
13428
diff
changeset
|
5 |
* |
|
6a818f9192f4
Implement parsing for rnd and add a little documentation
Marcin Mielniczuk <marmistrz.dev@zoho.eu>
parents:
13428
diff
changeset
|
6 |
* For example, a nullary command like PING will be actually sent as `PING\n\n`. |
|
6a818f9192f4
Implement parsing for rnd and add a little documentation
Marcin Mielniczuk <marmistrz.dev@zoho.eu>
parents:
13428
diff
changeset
|
7 |
* A unary command, such as `START_GAME nick` will be actually sent as `START_GAME\nnick\n\n`. |
|
6a818f9192f4
Implement parsing for rnd and add a little documentation
Marcin Mielniczuk <marmistrz.dev@zoho.eu>
parents:
13428
diff
changeset
|
8 |
*/ |
| 12138 | 9 |
use nom::*; |
| 14780 | 10 |
use std::{
|
11 |
num::ParseIntError, |
|
12 |
ops::Range, |
|
13 |
str, |
|
14 |
str::{FromStr, Utf8Error},
|
|
15 |
}; |
|
| 12138 | 16 |
|
| 14462 | 17 |
use super::messages::{HWProtocolMessage, HWProtocolMessage::*};
|
18 |
use crate::server::coretypes::{GameCfg, HedgehogInfo, TeamInfo, VoteType, MAX_HEDGEHOGS_PER_TEAM};
|
|
| 14780 | 19 |
|
| 13801 | 20 |
#[cfg(test)] |
| 13810 | 21 |
use {
|
22 |
super::test::gen_proto_msg, |
|
| 14462 | 23 |
proptest::{proptest, proptest_helper},
|
| 13424 | 24 |
}; |
|
13124
1e39b8749072
separated the server logic from all the async io mess.
alfadur
parents:
12147
diff
changeset
|
25 |
|
| 14780 | 26 |
#[derive(Debug, PartialEq)] |
27 |
pub struct HWProtocolError {}
|
|
28 |
||
29 |
impl HWProtocolError {
|
|
30 |
fn new() -> Self {
|
|
31 |
HWProtocolError {}
|
|
32 |
} |
|
33 |
} |
|
34 |
||
35 |
impl<I> ParseError<I> for HWProtocolError {
|
|
36 |
fn from_error_kind(input: I, kind: ErrorKind) -> Self {
|
|
37 |
HWProtocolError::new() |
|
38 |
} |
|
39 |
||
40 |
fn append(input: I, kind: ErrorKind, other: Self) -> Self {
|
|
41 |
HWProtocolError::new() |
|
42 |
} |
|
43 |
} |
|
44 |
||
45 |
impl From<Utf8Error> for HWProtocolError {
|
|
46 |
fn from(_: Utf8Error) -> Self {
|
|
47 |
HWProtocolError::new() |
|
48 |
} |
|
49 |
} |
|
50 |
||
51 |
impl From<ParseIntError> for HWProtocolError {
|
|
52 |
fn from(_: ParseIntError) -> Self {
|
|
53 |
HWProtocolError::new() |
|
54 |
} |
|
55 |
} |
|
56 |
||
57 |
pub type HWResult<'a, O> = IResult<&'a [u8], O, HWProtocolError>; |
|
58 |
||
59 |
fn end_of_message(input: &[u8]) -> HWResult<&[u8]> {
|
|
60 |
tag("\n\n")(input)
|
|
61 |
} |
|
62 |
||
63 |
fn convert_utf8(input: &[u8]) -> HWResult<&str> {
|
|
64 |
match str::from_utf8(input) {
|
|
65 |
Ok(str) => Ok((b"", str)), |
|
66 |
Err(utf_err) => Result::Err(Err::Failure(utf_err.into())), |
|
67 |
} |
|
68 |
} |
|
69 |
||
70 |
fn convert_from_str<T>(str: &str) -> HWResult<T> |
|
71 |
where |
|
72 |
T: FromStr<Err = ParseIntError>, |
|
73 |
{
|
|
74 |
match T::from_str(str) {
|
|
75 |
Ok(x) => Ok((b"", x)), |
|
76 |
Err(format_err) => Result::Err(Err::Failure(format_err.into())), |
|
77 |
} |
|
78 |
} |
|
79 |
||
80 |
fn str_line(input: &[u8]) -> HWResult<&str> {
|
|
81 |
let (i, text) = not_line_ending(input)?; |
|
82 |
Ok((i, convert_utf8(text)?.1)) |
|
83 |
} |
|
84 |
||
85 |
fn a_line(input: &[u8]) -> HWResult<String> {
|
|
86 |
let (i, str) = str_line(input)?; |
|
87 |
Ok((i, str.to_string())) |
|
88 |
} |
|
89 |
||
90 |
fn hw_tag<'a>(tag_str: &'a str) -> impl Fn(&'a [u8]) -> HWResult<'a, ()> {
|
|
91 |
move |i| tag(tag_str)(i).map(|(i, _)| (i, ())) |
|
92 |
} |
|
93 |
||
94 |
fn hw_tag_no_case<'a>(tag_str: &'a str) -> impl Fn(&'a [u8]) -> HWResult<'a, ()> {
|
|
95 |
move |i| tag_no_case(tag_str)(i).map(|(i, _)| (i, ())) |
|
96 |
} |
|
97 |
||
98 |
fn cmd_arg(input: &[u8]) -> HWResult<String> {
|
|
99 |
let delimiters = b" \n"; |
|
100 |
let (i, str) = take_while(move |c| !delimiters.contains(&c))(input)?; |
|
101 |
Ok((i, convert_utf8(str)?.1.to_string())) |
|
102 |
} |
|
103 |
||
104 |
fn u8_line(input: &[u8]) -> HWResult<u8> {
|
|
105 |
let (i, str) = str_line(input)?; |
|
106 |
Ok((i, convert_from_str(str)?.1)) |
|
107 |
} |
|
108 |
||
109 |
fn u16_line(input: &[u8]) -> HWResult<u16> {
|
|
110 |
let (i, str) = str_line(input)?; |
|
111 |
Ok((i, convert_from_str(str)?.1)) |
|
112 |
} |
|
113 |
||
114 |
fn u32_line(input: &[u8]) -> HWResult<u32> {
|
|
115 |
let (i, str) = str_line(input)?; |
|
116 |
Ok((i, convert_from_str(str)?.1)) |
|
117 |
} |
|
118 |
||
119 |
fn yes_no_line(input: &[u8]) -> HWResult<bool> {
|
|
120 |
alt(( |
|
121 |
|i| tag_no_case(b"YES")(i).map(|(i, _)| (i, true)), |
|
122 |
|i| tag_no_case(b"NO")(i).map(|(i, _)| (i, false)), |
|
123 |
))(input) |
|
124 |
} |
|
125 |
||
126 |
fn opt_arg<'a>(input: &'a [u8]) -> HWResult<'a, Option<String>> {
|
|
127 |
alt(( |
|
128 |
|i: &'a [u8]| peek!(i, end_of_message).map(|(i, _)| (i, None)), |
|
129 |
|i| precededc(i, hw_tag("\n"), a_line).map(|(i, v)| (i, Some(v))),
|
|
130 |
))(input) |
|
131 |
} |
|
132 |
||
133 |
fn spaces(input: &[u8]) -> HWResult<&[u8]> {
|
|
134 |
precededc(input, hw_tag(" "), |i| take_while(|c| c == b' ')(i))
|
|
135 |
} |
|
136 |
||
137 |
fn opt_space_arg<'a>(input: &'a [u8]) -> HWResult<'a, Option<String>> {
|
|
138 |
alt(( |
|
139 |
|i: &'a [u8]| peek!(i, end_of_message).map(|(i, _)| (i, None)), |
|
140 |
|i| precededc(i, spaces, a_line).map(|(i, v)| (i, Some(v))), |
|
141 |
))(input) |
|
142 |
} |
|
| 12139 | 143 |
|
| 14780 | 144 |
fn hedgehog_array(input: &[u8]) -> HWResult<[HedgehogInfo; 8]> {
|
145 |
fn hedgehog_line(input: &[u8]) -> HWResult<HedgehogInfo> {
|
|
146 |
let (i, name) = terminatedc(input, a_line, eol)?; |
|
147 |
let (i, hat) = a_line(i)?; |
|
148 |
Ok((i, HedgehogInfo { name, hat }))
|
|
149 |
} |
|
150 |
||
151 |
let (i, h1) = terminatedc(input, hedgehog_line, eol)?; |
|
152 |
let (i, h2) = terminatedc(i, hedgehog_line, eol)?; |
|
153 |
let (i, h3) = terminatedc(i, hedgehog_line, eol)?; |
|
154 |
let (i, h4) = terminatedc(i, hedgehog_line, eol)?; |
|
155 |
let (i, h5) = terminatedc(i, hedgehog_line, eol)?; |
|
156 |
let (i, h6) = terminatedc(i, hedgehog_line, eol)?; |
|
157 |
let (i, h7) = terminatedc(i, hedgehog_line, eol)?; |
|
158 |
let (i, h8) = hedgehog_line(i)?; |
|
159 |
||
160 |
Ok((i, [h1, h2, h3, h4, h5, h6, h7, h8])) |
|
161 |
} |
|
| 12138 | 162 |
|
| 14780 | 163 |
fn voting(input: &[u8]) -> HWResult<VoteType> {
|
164 |
alt(( |
|
165 |
|i| tag_no_case("PAUSE")(i).map(|(i, _)| (i, VoteType::Pause)),
|
|
166 |
|i| tag_no_case("NEWSEED")(i).map(|(i, _)| (i, VoteType::NewSeed)),
|
|
167 |
|i| {
|
|
168 |
precededc(i, |i| precededc(i, hw_tag_no_case("KICK"), spaces), a_line)
|
|
169 |
.map(|(i, s)| (i, VoteType::Kick(s))) |
|
170 |
}, |
|
171 |
|i| {
|
|
172 |
precededc( |
|
173 |
i, |
|
174 |
|i| precededc(i, hw_tag_no_case("HEDGEHOGS"), spaces),
|
|
175 |
u8_line, |
|
176 |
) |
|
177 |
.map(|(i, n)| (i, VoteType::HedgehogsPerTeam(n))) |
|
178 |
}, |
|
179 |
|i| precededc(i, hw_tag_no_case("MAP"), opt_space_arg).map(|(i, v)| (i, VoteType::Map(v))),
|
|
180 |
))(input) |
|
181 |
} |
|
| 12140 | 182 |
|
| 14780 | 183 |
fn no_arg_message(input: &[u8]) -> HWResult<HWProtocolMessage> {
|
184 |
fn messagec<'a>( |
|
185 |
input: &'a [u8], |
|
186 |
name: &'a str, |
|
187 |
msg: HWProtocolMessage, |
|
188 |
) -> HWResult<'a, HWProtocolMessage> {
|
|
189 |
tag(name)(input).map(|(i, _)| (i, msg.clone())) |
|
190 |
} |
|
191 |
||
192 |
alt(( |
|
193 |
|i| messagec(i, "PING", Ping), |
|
194 |
|i| messagec(i, "PONG", Pong), |
|
195 |
|i| messagec(i, "LIST", List), |
|
196 |
|i| messagec(i, "BANLIST", BanList), |
|
197 |
|i| messagec(i, "GET_SERVER_VAR", GetServerVar), |
|
198 |
|i| messagec(i, "TOGGLE_READY", ToggleReady), |
|
199 |
|i| messagec(i, "START_GAME", StartGame), |
|
200 |
|i| messagec(i, "TOGGLE_RESTRICT_JOINS", ToggleRestrictJoin), |
|
201 |
|i| messagec(i, "TOGGLE_RESTRICT_TEAMS", ToggleRestrictTeams), |
|
202 |
|i| messagec(i, "TOGGLE_REGISTERED_ONLY", ToggleRegisteredOnly), |
|
203 |
))(input) |
|
204 |
} |
|
| 12140 | 205 |
|
| 14780 | 206 |
fn single_arg_message(input: &[u8]) -> HWResult<HWProtocolMessage> {
|
207 |
fn messagec<'a, T, F, G>( |
|
208 |
input: &'a [u8], |
|
209 |
name: &'a str, |
|
210 |
parser: F, |
|
211 |
constructor: G, |
|
212 |
) -> HWResult<'a, HWProtocolMessage> |
|
213 |
where |
|
214 |
F: Fn(&[u8]) -> HWResult<T>, |
|
215 |
G: Fn(T) -> HWProtocolMessage, |
|
216 |
{
|
|
217 |
precededc(input, hw_tag(name), parser).map(|(i, v)| (i, constructor(v))) |
|
218 |
} |
|
219 |
||
220 |
alt(( |
|
221 |
|i| messagec(i, "NICK\n", a_line, Nick), |
|
222 |
|i| messagec(i, "INFO\n", a_line, Info), |
|
223 |
|i| messagec(i, "CHAT\n", a_line, Chat), |
|
224 |
|i| messagec(i, "PART", opt_arg, Part), |
|
225 |
|i| messagec(i, "FOLLOW\n", a_line, Follow), |
|
226 |
|i| messagec(i, "KICK\n", a_line, Kick), |
|
227 |
|i| messagec(i, "UNBAN\n", a_line, Unban), |
|
228 |
|i| messagec(i, "EM\n", a_line, EngineMessage), |
|
229 |
|i| messagec(i, "TEAMCHAT\n", a_line, TeamChat), |
|
230 |
|i| messagec(i, "ROOM_NAME\n", a_line, RoomName), |
|
231 |
|i| messagec(i, "REMOVE_TEAM\n", a_line, RemoveTeam), |
|
232 |
|i| messagec(i, "ROUNDFINISHED", opt_arg, |_| RoundFinished), |
|
233 |
|i| messagec(i, "PROTO\n", u16_line, Proto), |
|
234 |
|i| messagec(i, "QUIT", opt_arg, Quit), |
|
235 |
))(input) |
|
236 |
} |
|
| 12140 | 237 |
|
| 14780 | 238 |
fn cmd_message<'a>(input: &'a [u8]) -> HWResult<'a, HWProtocolMessage> {
|
239 |
fn cmdc_no_arg<'a>( |
|
240 |
input: &'a [u8], |
|
241 |
name: &'a str, |
|
242 |
msg: HWProtocolMessage, |
|
243 |
) -> HWResult<'a, HWProtocolMessage> {
|
|
244 |
tag_no_case(name)(input).map(|(i, _)| (i, msg.clone())) |
|
245 |
} |
|
246 |
||
247 |
fn cmdc_single_arg<'a, T, F, G>( |
|
248 |
input: &'a [u8], |
|
249 |
name: &'a str, |
|
250 |
parser: F, |
|
251 |
constructor: G, |
|
252 |
) -> HWResult<'a, HWProtocolMessage> |
|
253 |
where |
|
254 |
F: Fn(&'a [u8]) -> HWResult<'a, T>, |
|
255 |
G: Fn(T) -> HWProtocolMessage, |
|
256 |
{
|
|
257 |
precededc(input, |i| pairc(i, hw_tag_no_case(name), spaces), parser) |
|
258 |
.map(|(i, v)| (i, constructor(v))) |
|
259 |
} |
|
260 |
||
261 |
fn cmd_no_arg_message(input: &[u8]) -> HWResult<HWProtocolMessage> {
|
|
262 |
alt(( |
|
263 |
|i| cmdc_no_arg(i, "STATS", Stats), |
|
264 |
|i| cmdc_no_arg(i, "FIX", Fix), |
|
265 |
|i| cmdc_no_arg(i, "UNFIX", Unfix), |
|
266 |
|i| cmdc_no_arg(i, "REGISTERED_ONLY", ToggleServerRegisteredOnly), |
|
267 |
|i| cmdc_no_arg(i, "SUPER_POWER", SuperPower), |
|
268 |
))(input) |
|
269 |
} |
|
| 12140 | 270 |
|
| 14780 | 271 |
fn cmd_single_arg_message(input: &[u8]) -> HWResult<HWProtocolMessage> {
|
272 |
alt(( |
|
273 |
|i| cmdc_single_arg(i, "RESTART_SERVER", |i| tag("YES")(i), |_| RestartServer),
|
|
274 |
|i| cmdc_single_arg(i, "DELEGATE", a_line, Delegate), |
|
275 |
|i| cmdc_single_arg(i, "DELETE", a_line, Delete), |
|
276 |
|i| cmdc_single_arg(i, "SAVEROOM", a_line, SaveRoom), |
|
277 |
|i| cmdc_single_arg(i, "LOADROOM", a_line, LoadRoom), |
|
278 |
|i| cmdc_single_arg(i, "GLOBAL", a_line, Global), |
|
279 |
|i| cmdc_single_arg(i, "WATCH", a_line, Watch), |
|
280 |
|i| cmdc_single_arg(i, "GREETING", a_line, Greeting), |
|
281 |
|i| cmdc_single_arg(i, "VOTE", yes_no_line, Vote), |
|
282 |
|i| cmdc_single_arg(i, "FORCE", yes_no_line, ForceVote), |
|
283 |
|i| cmdc_single_arg(i, "INFO", a_line, Info), |
|
284 |
|i| cmdc_single_arg(i, "MAXTEAMS", u8_line, MaxTeams), |
|
285 |
|i| cmdc_single_arg(i, "CALLVOTE", |i| opt!(i, voting), CallVote), |
|
286 |
))(input) |
|
287 |
} |
|
288 |
||
289 |
precededc( |
|
290 |
input, |
|
291 |
hw_tag("CMD\n"),
|
|
292 |
alt(( |
|
293 |
cmd_no_arg_message, |
|
294 |
cmd_single_arg_message, |
|
295 |
|i| precededc(i, hw_tag_no_case("PART"), opt_space_arg).map(|(i, s)| (i, Part(s))),
|
|
296 |
|i| precededc(i, hw_tag_no_case("QUIT"), opt_space_arg).map(|(i, s)| (i, Quit(s))),
|
|
297 |
|i| {
|
|
298 |
precededc(i, hw_tag_no_case("SAVE"), |i| {
|
|
299 |
pairc( |
|
300 |
i, |
|
301 |
|i| precededc(i, spaces, cmd_arg), |
|
302 |
|i| precededc(i, spaces, cmd_arg), |
|
303 |
) |
|
304 |
}) |
|
305 |
.map(|(i, (n, l))| (i, Save(n, l))) |
|
306 |
}, |
|
307 |
|i| {
|
|
308 |
let (i, _) = tag_no_case("RND")(i)?;
|
|
309 |
let (i, _) = alt((spaces, |i: &'a [u8]| peek!(i, end_of_message)))(i)?; |
|
310 |
let (i, v) = str_line(i)?; |
|
311 |
Ok((i, Rnd(v.split_whitespace().map(String::from).collect()))) |
|
312 |
}, |
|
313 |
)), |
|
314 |
) |
|
315 |
} |
|
316 |
||
317 |
fn config_message<'a>(input: &'a [u8]) -> HWResult<'a, HWProtocolMessage> {
|
|
318 |
fn cfgc_single_arg<'a, T, F, G>( |
|
319 |
input: &'a [u8], |
|
320 |
name: &'a str, |
|
321 |
parser: F, |
|
322 |
constructor: G, |
|
323 |
) -> HWResult<'a, GameCfg> |
|
324 |
where |
|
325 |
F: Fn(&[u8]) -> HWResult<T>, |
|
326 |
G: Fn(T) -> GameCfg, |
|
327 |
{
|
|
328 |
precededc(input, |i| terminatedc(i, hw_tag(name), eol), parser) |
|
329 |
.map(|(i, v)| (i, constructor(v))) |
|
330 |
} |
|
331 |
||
332 |
let (i, cfg) = precededc( |
|
333 |
input, |
|
334 |
hw_tag("CFG\n"),
|
|
335 |
alt(( |
|
336 |
|i| cfgc_single_arg(i, "THEME", a_line, GameCfg::Theme), |
|
337 |
|i| cfgc_single_arg(i, "SCRIPT", a_line, GameCfg::Script), |
|
338 |
|i| cfgc_single_arg(i, "MAP", a_line, GameCfg::MapType), |
|
339 |
|i| cfgc_single_arg(i, "MAPGEN", u32_line, GameCfg::MapGenerator), |
|
340 |
|i| cfgc_single_arg(i, "MAZE_SIZE", u32_line, GameCfg::MazeSize), |
|
341 |
|i| cfgc_single_arg(i, "TEMPLATE", u32_line, GameCfg::Template), |
|
342 |
|i| cfgc_single_arg(i, "FEATURE_SIZE", u32_line, GameCfg::FeatureSize), |
|
343 |
|i| cfgc_single_arg(i, "SEED", a_line, GameCfg::Seed), |
|
344 |
|i| cfgc_single_arg(i, "DRAWNMAP", a_line, GameCfg::DrawnMap), |
|
345 |
|i| {
|
|
346 |
precededc( |
|
347 |
i, |
|
348 |
|i| terminatedc(i, hw_tag("AMMO"), eol),
|
|
349 |
|i| {
|
|
350 |
let (i, name) = a_line(i)?; |
|
351 |
let (i, value) = opt_arg(i)?; |
|
352 |
Ok((i, GameCfg::Ammo(name, value))) |
|
353 |
}, |
|
354 |
) |
|
355 |
}, |
|
356 |
|i| {
|
|
357 |
precededc( |
|
358 |
i, |
|
359 |
|i| terminatedc(i, hw_tag("SCHEME"), eol),
|
|
360 |
|i| {
|
|
361 |
let (i, name) = a_line(i)?; |
|
362 |
let (i, values) = alt(( |
|
363 |
|i: &'a [u8]| peek!(i, end_of_message).map(|(i, _)| (i, None)), |
|
364 |
|i| {
|
|
365 |
precededc(i, eol, |i| separated_list(eol, a_line)(i)) |
|
366 |
.map(|(i, v)| (i, Some(v))) |
|
367 |
}, |
|
368 |
))(i)?; |
|
369 |
Ok((i, GameCfg::Scheme(name, values.unwrap_or_default()))) |
|
370 |
}, |
|
371 |
) |
|
372 |
}, |
|
373 |
)), |
|
374 |
)?; |
|
375 |
Ok((i, Cfg(cfg))) |
|
376 |
} |
|
| 12138 | 377 |
|
| 14780 | 378 |
fn complex_message(input: &[u8]) -> HWResult<HWProtocolMessage> {
|
379 |
alt(( |
|
380 |
|i| {
|
|
381 |
precededc( |
|
382 |
i, |
|
383 |
|i| terminatedc(i, hw_tag("PASSWORD"), eol),
|
|
384 |
|i| {
|
|
385 |
let (i, pass) = terminatedc(i, a_line, eol)?; |
|
386 |
let (i, salt) = a_line(i)?; |
|
387 |
Ok((i, Password(pass, salt))) |
|
388 |
}, |
|
389 |
) |
|
390 |
}, |
|
391 |
|i| {
|
|
392 |
precededc( |
|
393 |
i, |
|
394 |
|i| terminatedc(i, hw_tag("CHECKER"), eol),
|
|
395 |
|i| {
|
|
396 |
let (i, protocol) = terminatedc(i, u16_line, eol)?; |
|
397 |
let (i, name) = terminatedc(i, a_line, eol)?; |
|
398 |
let (i, pass) = a_line(i)?; |
|
399 |
Ok((i, Checker(protocol, name, pass))) |
|
400 |
}, |
|
401 |
) |
|
402 |
}, |
|
403 |
|i| {
|
|
404 |
precededc( |
|
405 |
i, |
|
406 |
|i| terminatedc(i, hw_tag("CREATE_ROOM"), eol),
|
|
407 |
|i| {
|
|
408 |
let (i, name) = a_line(i)?; |
|
409 |
let (i, pass) = opt_arg(i)?; |
|
410 |
Ok((i, CreateRoom(name, pass))) |
|
411 |
}, |
|
412 |
) |
|
413 |
}, |
|
414 |
|i| {
|
|
415 |
precededc( |
|
416 |
i, |
|
417 |
|i| terminatedc(i, hw_tag("JOIN_ROOM"), eol),
|
|
418 |
|i| {
|
|
419 |
let (i, name) = a_line(i)?; |
|
420 |
let (i, pass) = opt_arg(i)?; |
|
421 |
Ok((i, JoinRoom(name, pass))) |
|
422 |
}, |
|
423 |
) |
|
424 |
}, |
|
425 |
|i| {
|
|
426 |
precededc( |
|
427 |
i, |
|
428 |
|i| terminatedc(i, hw_tag("ADD_TEAM"), eol),
|
|
429 |
|i| {
|
|
430 |
let (i, name) = terminatedc(i, a_line, eol)?; |
|
431 |
let (i, color) = terminatedc(i, u8_line, eol)?; |
|
432 |
let (i, grave) = terminatedc(i, a_line, eol)?; |
|
433 |
let (i, fort) = terminatedc(i, a_line, eol)?; |
|
434 |
let (i, voice_pack) = terminatedc(i, a_line, eol)?; |
|
435 |
let (i, flag) = terminatedc(i, a_line, eol)?; |
|
436 |
let (i, difficulty) = terminatedc(i, u8_line, eol)?; |
|
437 |
let (i, hedgehogs) = hedgehog_array(i)?; |
|
438 |
Ok(( |
|
439 |
i, |
|
440 |
AddTeam(Box::new(TeamInfo {
|
|
441 |
name, |
|
442 |
color, |
|
443 |
grave, |
|
444 |
fort, |
|
445 |
voice_pack, |
|
446 |
flag, |
|
447 |
difficulty, |
|
448 |
hedgehogs, |
|
449 |
hedgehogs_number: 0, |
|
450 |
})), |
|
451 |
)) |
|
452 |
}, |
|
453 |
) |
|
454 |
}, |
|
455 |
|i| {
|
|
456 |
precededc( |
|
457 |
i, |
|
458 |
|i| terminatedc(i, hw_tag("HH_NUM"), eol),
|
|
459 |
|i| {
|
|
460 |
let (i, name) = terminatedc(i, a_line, eol)?; |
|
461 |
let (i, count) = u8_line(i)?; |
|
462 |
Ok((i, SetHedgehogsNumber(name, count))) |
|
463 |
}, |
|
464 |
) |
|
465 |
}, |
|
466 |
|i| {
|
|
467 |
precededc( |
|
468 |
i, |
|
469 |
|i| terminatedc(i, hw_tag("TEAM_COLOR"), eol),
|
|
470 |
|i| {
|
|
471 |
let (i, name) = terminatedc(i, a_line, eol)?; |
|
472 |
let (i, color) = u8_line(i)?; |
|
473 |
Ok((i, SetTeamColor(name, color))) |
|
474 |
}, |
|
475 |
) |
|
476 |
}, |
|
477 |
|i| {
|
|
478 |
precededc( |
|
479 |
i, |
|
480 |
|i| terminatedc(i, hw_tag("BAN"), eol),
|
|
481 |
|i| {
|
|
482 |
let (i, n) = terminatedc(i, a_line, eol)?; |
|
483 |
let (i, r) = terminatedc(i, a_line, eol)?; |
|
484 |
let (i, t) = u32_line(i)?; |
|
485 |
Ok((i, Ban(n, r, t))) |
|
486 |
}, |
|
487 |
) |
|
488 |
}, |
|
489 |
|i| {
|
|
490 |
precededc( |
|
491 |
i, |
|
492 |
|i| terminatedc(i, hw_tag("BAN_IP"), eol),
|
|
493 |
|i| {
|
|
494 |
let (i, n) = terminatedc(i, a_line, eol)?; |
|
495 |
let (i, r) = terminatedc(i, a_line, eol)?; |
|
496 |
let (i, t) = u32_line(i)?; |
|
497 |
Ok((i, BanIP(n, r, t))) |
|
498 |
}, |
|
499 |
) |
|
500 |
}, |
|
501 |
|i| {
|
|
502 |
precededc( |
|
503 |
i, |
|
504 |
|i| terminatedc(i, hw_tag("BAN_NICK"), eol),
|
|
505 |
|i| {
|
|
506 |
let (i, n) = terminatedc(i, a_line, eol)?; |
|
507 |
let (i, r) = terminatedc(i, a_line, eol)?; |
|
508 |
let (i, t) = u32_line(i)?; |
|
509 |
Ok((i, BanNick(n, r, t))) |
|
510 |
}, |
|
511 |
) |
|
512 |
}, |
|
513 |
))(input) |
|
514 |
} |
|
| 13427 | 515 |
|
| 14780 | 516 |
fn empty_message(input: &[u8]) -> HWResult<HWProtocolMessage> {
|
517 |
let (i, _) = alt((end_of_message, eol))(input)?; |
|
518 |
Ok((i, Empty)) |
|
519 |
} |
|
|
12142
193dfdcb0620
- Use logging facilities instead of plain println!
unc0rr
parents:
12141
diff
changeset
|
520 |
|
| 14780 | 521 |
fn malformed_message(input: &[u8]) -> HWResult<HWProtocolMessage> {
|
522 |
let (i, _) = separated_listc(input, eol, a_line)?; |
|
523 |
Ok((i, Malformed)) |
|
524 |
} |
|
|
12142
193dfdcb0620
- Use logging facilities instead of plain println!
unc0rr
parents:
12141
diff
changeset
|
525 |
|
| 14780 | 526 |
fn message(input: &[u8]) -> HWResult<HWProtocolMessage> {
|
527 |
alt(( |
|
528 |
|i| {
|
|
529 |
terminatedc( |
|
530 |
i, |
|
531 |
alt(( |
|
532 |
no_arg_message, |
|
533 |
single_arg_message, |
|
534 |
cmd_message, |
|
535 |
config_message, |
|
536 |
complex_message, |
|
537 |
)), |
|
538 |
end_of_message, |
|
539 |
) |
|
540 |
}, |
|
541 |
|i| terminatedc(i, malformed_message, end_of_message), |
|
542 |
empty_message, |
|
543 |
))(input) |
|
544 |
} |
|
| 12138 | 545 |
|
| 14780 | 546 |
pub fn extract_messages<'a>(input: &'a [u8]) -> HWResult<Vec<HWProtocolMessage>> {
|
547 |
many0(|i: &'a [u8]| complete!(i, message))(input) |
|
548 |
} |
|
| 12138 | 549 |
|
| 13801 | 550 |
#[cfg(test)] |
|
13124
1e39b8749072
separated the server logic from all the async io mess.
alfadur
parents:
12147
diff
changeset
|
551 |
proptest! {
|
|
1e39b8749072
separated the server logic from all the async io mess.
alfadur
parents:
12147
diff
changeset
|
552 |
#[test] |
|
1e39b8749072
separated the server logic from all the async io mess.
alfadur
parents:
12147
diff
changeset
|
553 |
fn is_parser_composition_idempotent(ref msg in gen_proto_msg()) {
|
|
1e39b8749072
separated the server logic from all the async io mess.
alfadur
parents:
12147
diff
changeset
|
554 |
println!("!! Msg: {:?}, Bytes: {:?} !!", msg, msg.to_raw_protocol().as_bytes());
|
| 13443 | 555 |
assert_eq!(message(msg.to_raw_protocol().as_bytes()), Ok((&b""[..], msg.clone()))) |
|
13124
1e39b8749072
separated the server logic from all the async io mess.
alfadur
parents:
12147
diff
changeset
|
556 |
} |
|
1e39b8749072
separated the server logic from all the async io mess.
alfadur
parents:
12147
diff
changeset
|
557 |
} |
|
1e39b8749072
separated the server logic from all the async io mess.
alfadur
parents:
12147
diff
changeset
|
558 |
|
| 12138 | 559 |
#[test] |
560 |
fn parse_test() {
|
|
| 14462 | 561 |
assert_eq!(message(b"PING\n\n"), Ok((&b""[..], Ping))); |
562 |
assert_eq!(message(b"START_GAME\n\n"), Ok((&b""[..], StartGame))); |
|
563 |
assert_eq!( |
|
564 |
message(b"NICK\nit's me\n\n"), |
|
565 |
Ok((&b""[..], Nick("it's me".to_string())))
|
|
566 |
); |
|
567 |
assert_eq!(message(b"PROTO\n51\n\n"), Ok((&b""[..], Proto(51)))); |
|
568 |
assert_eq!( |
|
569 |
message(b"QUIT\nbye-bye\n\n"), |
|
570 |
Ok((&b""[..], Quit(Some("bye-bye".to_string()))))
|
|
571 |
); |
|
572 |
assert_eq!(message(b"QUIT\n\n"), Ok((&b""[..], Quit(None)))); |
|
573 |
assert_eq!( |
|
574 |
message(b"CMD\nwatch demo\n\n"), |
|
575 |
Ok((&b""[..], Watch("demo".to_string())))
|
|
576 |
); |
|
577 |
assert_eq!( |
|
578 |
message(b"BAN\nme\nbad\n77\n\n"), |
|
579 |
Ok((&b""[..], Ban("me".to_string(), "bad".to_string(), 77)))
|
|
580 |
); |
|
| 12141 | 581 |
|
| 14462 | 582 |
assert_eq!(message(b"CMD\nPART\n\n"), Ok((&b""[..], Part(None)))); |
583 |
assert_eq!( |
|
584 |
message(b"CMD\nPART _msg_\n\n"), |
|
585 |
Ok((&b""[..], Part(Some("_msg_".to_string()))))
|
|
586 |
); |
|
|
13124
1e39b8749072
separated the server logic from all the async io mess.
alfadur
parents:
12147
diff
changeset
|
587 |
|
| 13443 | 588 |
assert_eq!(message(b"CMD\nRND\n\n"), Ok((&b""[..], Rnd(vec![])))); |
|
13436
6a818f9192f4
Implement parsing for rnd and add a little documentation
Marcin Mielniczuk <marmistrz.dev@zoho.eu>
parents:
13428
diff
changeset
|
589 |
assert_eq!( |
|
6a818f9192f4
Implement parsing for rnd and add a little documentation
Marcin Mielniczuk <marmistrz.dev@zoho.eu>
parents:
13428
diff
changeset
|
590 |
message(b"CMD\nRND A B\n\n"), |
| 13443 | 591 |
Ok((&b""[..], Rnd(vec![String::from("A"), String::from("B")])))
|
|
13436
6a818f9192f4
Implement parsing for rnd and add a little documentation
Marcin Mielniczuk <marmistrz.dev@zoho.eu>
parents:
13428
diff
changeset
|
592 |
); |
|
6a818f9192f4
Implement parsing for rnd and add a little documentation
Marcin Mielniczuk <marmistrz.dev@zoho.eu>
parents:
13428
diff
changeset
|
593 |
|
| 14462 | 594 |
assert_eq!( |
595 |
extract_messages(b"QUIT\n1\n2\n\n"), |
|
596 |
Ok((&b""[..], vec![Malformed])) |
|
597 |
); |
|
| 12145 | 598 |
|
| 14462 | 599 |
assert_eq!( |
600 |
extract_messages(b"PING\n\nPING\n\nP"), |
|
601 |
Ok((&b"P"[..], vec![Ping, Ping])) |
|
602 |
); |
|
603 |
assert_eq!( |
|
604 |
extract_messages(b"SING\n\nPING\n\n"), |
|
605 |
Ok((&b""[..], vec![Malformed, Ping])) |
|
606 |
); |
|
607 |
assert_eq!( |
|
608 |
extract_messages(b"\n\n\n\nPING\n\n"), |
|
609 |
Ok((&b""[..], vec![Empty, Empty, Ping])) |
|
610 |
); |
|
611 |
assert_eq!( |
|
612 |
extract_messages(b"\n\n\nPING\n\n"), |
|
613 |
Ok((&b""[..], vec![Empty, Empty, Ping])) |
|
614 |
); |
|
|
13436
6a818f9192f4
Implement parsing for rnd and add a little documentation
Marcin Mielniczuk <marmistrz.dev@zoho.eu>
parents:
13428
diff
changeset
|
615 |
} |