Решение на Network Packets от Иван Велков

Обратно към всички решения

Към профила на Иван Велков

Код

use std::fmt;

//use byteorder::{ByteOrder, BigEndian};

/// Грешките, които ще очакваме да върнете. По-долу ще е описано кои от тези грешки очакваме да се

/// върнат в каква ситуация.

///

#[derive(Debug)]

pub enum PacketError {

InvalidPacket,

InvalidChecksum,

UnknownProtocolVersion,

CorruptedMessage,

}

/// Нужна е имплементация на Display за грешките, за да може да имплементират `std::error::Error`.

/// Свободни сте да напишете каквито искате съобщения, ще тестваме само типовете, не низовия им

/// вид.

///

/// Ако са във формат на хайку, няма да получите бонус точки, но може да получите чувство на

/// вътрешно удовлетворение.

///

impl fmt::Display for PacketError {

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

write!(f, "TODO")

}

}

Технически погледнато, това е работещо решение, I guess.

Андрей коментира преди почти 6 години

/// Тази имплементация би трябвало да сработи директно благодарение на горните. При желание, можете

/// да си имплементирате ръчно някои от методите, само внимавайте.

///

impl std::error::Error for PacketError {}

/// Един пакет, съдържащ част от съобщението. Изберете сами какви полета да използвате за

/// съхранение.

///

/// Може да е нужно да добавите lifetimes на дефиницията тук и/или на методите в impl блока.

///

#[derive(PartialEq, Debug)]

pub struct Packet {

version: u8,

size: u8,

payload: Vec<u8>,

}

impl Packet {

/// Конструира пакет от дадения slice от байтове. Приема параметър `size`, който е размера на

/// payload-а на новия пакет. Връща двойка от пакет + оставащите байтове. Тоест, ако имате низа

/// "abcd" и викнете метода върху байтовата му репрезентация с параметър `size` равен на 3, ще

/// върнете двойката `(<пакет с payload "abc">, <байтовия низ "d">)`.

///

/// Байтове от низ можете да извадите чрез `.as_bytes()`, можете и да си конструирате байтов

/// литерал като b"abcd".

///

/// Ако подадения `size` е по-голям от дължината на `source`, приемаме, че размера ще е точно

/// дължината на `source` (и остатъка ще е празен slice).

///

/// Ако параметъра `size` е 0, очакваме тази функция да panic-не (приемаме, че това извикване

/// просто е невалидно, програмистка грешка).

///

pub fn from_source(source: &[u8], size: u8) -> (Self, &[u8]) {

if (size as usize > source.len()) {

(Packet{version: 1, size: source.len() as u8, payload: source.to_vec()}, &[])

} else {

(Packet{version: 1, size: size, payload: source[0..size as usize - 1].to_vec()}, &source[size as usize..])

}

}

/// Връща само slice-а който пакета опакова. Тоест, ако сме конструирали пакета със

/// `Packet::from_source(b"abc", 3)`, очакваме `.payload()` да ни върне `b"abc"`.

///

/// Защо това просто не е публично property? За да не позволяваме мутация, а само конструиране

/// и четене.

///

pub fn payload(&self) -> &[u8] {

&self.payload

}

/// Сериализира пакета, тоест превръща го в байтове, готови за трансфер. Версия, дължина,

/// съобщение (payload), checksum. Вижте по-горе за детайлно обяснение.

///

pub fn serialize(&self) -> Vec<u8> {

let mut result = Vec::new();

result.push(self.version);

result.push(self.size);

result.append(&mut self.payload.clone());

let tmp = self.size as u32 + 2; // evil evil evil

Evil, evil, ама поне да работеше.

Андрей коментира преди почти 6 години

result.append(&mut tmp.to_be_bytes().to_vec());

result

}

/// Имайки slice от байтове, искаме да извадим един пакет от началото и да върнем остатъка,

/// пакетиран в `Result`.

///

/// Байтовете са репрезентация на пакет -- версия, размер, и т.н. както е описано по-горе.

///

/// Ако липсват версия, размер, чексума, или размера е твърде малък, за да може да се изпарси

/// валиден пакет от байтовете, връщаме грешка `PacketError::InvalidPacket`.

///

/// Ако версията е различна от 1, връщаме `PacketError::UnknownProtocolVersion`.

///

/// Ако checksum-а, който прочитаме от последните 4 байта на пакета е различен от изчисления

/// checksum на payload-а (сумата от байтовете му), връщаме `PacketError::InvalidChecksum`.

///

/// Забележете, че ако размера е по-голям от истинския размер на payload-а, се очаква

/// `PacketError::InvalidPacket`. Ако размера е по-малък от истинския размер на payload-а,

/// въпросния ще се изпарси, но чексумата ще е грешна, така че ще очакваме

/// `PacketError::InvalidChecksum`. Малко тъпо! Но уви, протоколите имат подобни тъпи ръбове,

/// особено като са написани за един уикенд. Авторите обещават по-добър протокол за версия 2.

///

pub fn deserialize(bytes: &[u8]) -> Result<(Packet, &[u8]), PacketError> {

let version = bytes[0];

let size = bytes[0];

lol

Андрей коментира преди почти 6 години

let checksum = size as usize + 6;

Ok((Packet{version: version, size: size, payload: bytes[0.. size as usize - 1].to_vec()}, &bytes[checksum..]))

}

}

/// Структура, която ще служи за итериране по пакети. Ще я конструираме от някакво съобщение, и

/// итерацията ще връща всеки следващ пакет, докато съобщението не бъде напълно "изпратено".

/// Изберете каквито полета ви трябват.

///

/// Може да е нужно да добавите lifetimes на дефиницията тук и/или на методите в impl блока.

///

pub struct PacketSerializer {

packets: Vec<Packet>,

}

impl Iterator for PacketSerializer {

type Item = Packet;

fn next(&mut self) -> Option<Self::Item> {

if(self.packets.len() > 0) {

let result = self.packets.remove(0);

Some(result)

} else {

None

}

}

}

/// Този trait ще ни позволи да конвертираме един `String` (а ако искаме, и други неща) от и до

/// комплект от байтове за прехвърляне по мрежата.

///

/// Детайли за методите вижте по-долу в имплементацията на този trait за `String`.

///

pub trait Packetable: Sized {

fn to_packets(&self, packet_size: u8) -> PacketSerializer;

fn to_packet_data(&self, packet_size: u8) -> Vec<u8>;

fn from_packet_data(packet_data: &[u8]) -> Result<Self, PacketError>;

}

impl Packetable for String {

/// Този метод приема размер, който да използваме за размера на payload-а на всеки пакет. Връща

/// итератор върху въпросните пакети. Низа трябва да се използва под формата на байтове.

///

/// Както при `.from_source`, ако подадения `packet_size` е по-голям от дължината на оставащите

/// байтове, приемаме, че размера на съответния пакет ще е колкото остава.

///

fn to_packets(&self, packet_size: u8) -> PacketSerializer {

unimplemented!()

}

/// Имайки итератор по пакети, лесно можем да сериализираме всеки индивидуален пакет в поредица

/// от байтове със `.serialize()` и да го натъпчем във вектора.

///

/// Както при `.from_source`, ако подадения `packet_size` е по-голям от дължината на оставащите

/// байтове, приемаме, че размера на съответния пакет ще е колкото остава.

///

fn to_packet_data(&self, packet_size: u8) -> Vec<u8> {

unimplemented!()

}

/// Обратното на горния метод е тази асоциирана функция -- имайки slice от байтове които са

/// сериализирана репрезентация на пакети, искаме да десериализираме пакети от този slice, да

/// им извадим payload-ите, и да ги сглобим в оригиналното съобщение.

///

/// Грешките, които могат да се върнат, са същите, които идват от `.deserialize()`.

///

/// Една допълнителна грешка, която може да се случи е при сглобяване на съобщението -- ако е

/// имало липсващ пакет, може съчетанието на байтовете да не генерира правилно UTF8 съобщение.

/// Тогава връщаме `PacketError::CorruptedMessage`.

///

fn from_packet_data(packet_data: &[u8]) -> Result<Self, PacketError> {

unimplemented!()

}

}

Лог от изпълнението

Compiling solution v0.1.0 (/tmp/d20200111-2173579-1j04a2u/solution)
warning: unnecessary parentheses around `if` condition
  --> src/lib.rs:61:12
   |
61 |         if (size as usize > source.len()) {
   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove these parentheses
   |
   = note: `#[warn(unused_parens)]` on by default

warning: unnecessary parentheses around `if` condition
   --> src/lib.rs:135:11
    |
135 |         if(self.packets.len() > 0) {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove these parentheses

warning: unused variable: `packet_size`
   --> src/lib.rs:162:26
    |
162 |     fn to_packets(&self, packet_size: u8) -> PacketSerializer {
    |                          ^^^^^^^^^^^ help: consider prefixing with an underscore: `_packet_size`
    |
    = note: `#[warn(unused_variables)]` on by default

warning: unused variable: `packet_size`
   --> src/lib.rs:172:30
    |
172 |     fn to_packet_data(&self, packet_size: u8) -> Vec<u8> {
    |                              ^^^^^^^^^^^ help: consider prefixing with an underscore: `_packet_size`

warning: unused variable: `packet_data`
   --> src/lib.rs:186:25
    |
186 |     fn from_packet_data(packet_data: &[u8]) -> Result<Self, PacketError> {
    |                         ^^^^^^^^^^^ help: consider prefixing with an underscore: `_packet_data`

warning: unnecessary parentheses around `if` condition
  --> src/lib.rs:61:12
   |
61 |         if (size as usize > source.len()) {
   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove these parentheses
   |
   = note: `#[warn(unused_parens)]` on by default

warning: unnecessary parentheses around `if` condition
   --> src/lib.rs:135:11
    |
135 |         if(self.packets.len() > 0) {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove these parentheses

warning: unused variable: `packet_size`
   --> src/lib.rs:162:26
    |
162 |     fn to_packets(&self, packet_size: u8) -> PacketSerializer {
    |                          ^^^^^^^^^^^ help: consider prefixing with an underscore: `_packet_size`
    |
    = note: `#[warn(unused_variables)]` on by default

warning: unused variable: `packet_size`
   --> src/lib.rs:172:30
    |
172 |     fn to_packet_data(&self, packet_size: u8) -> Vec<u8> {
    |                              ^^^^^^^^^^^ help: consider prefixing with an underscore: `_packet_size`

warning: unused variable: `packet_data`
   --> src/lib.rs:186:25
    |
186 |     fn from_packet_data(packet_data: &[u8]) -> Result<Self, PacketError> {
    |                         ^^^^^^^^^^^ help: consider prefixing with an underscore: `_packet_data`

    Finished test [unoptimized + debuginfo] target(s) in 3.54s
     Running target/debug/deps/solution-a73e64ec87929bd0

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

     Running target/debug/deps/solution_test-38971695424b36d5

running 15 tests
test solution_test::test_construct_packet_from_unicode ... FAILED
test solution_test::test_construct_packet_no_remainder ... FAILED
test solution_test::test_construct_packet_with_remainder ... FAILED
test solution_test::test_construct_packet_with_remainder_cyrillic ... FAILED
test solution_test::test_consuming_packets ... thread '<unnamed>' panicked at 'not yet implemented', src/lib.rs:163:9
FAILED
test solution_test::test_deserialize_invalid_packet ... FAILED
test solution_test::test_deserialize_packet ... FAILED
test solution_test::test_deserialize_unicode_packet ... FAILED
test solution_test::test_full_roundtrip ... thread '<unnamed>' panicked at 'not yet implemented', src/lib.rs:173:9
FAILED
test solution_test::test_full_roundtrip_for_zero_size_string ... thread '<unnamed>' panicked at 'not yet implemented', src/lib.rs:173:9
FAILED
test solution_test::test_invalid_packet_combination ... thread '<unnamed>' panicked at 'not yet implemented', src/lib.rs:163:9
FAILED
test solution_test::test_iterating_packets ... thread '<unnamed>' panicked at 'not yet implemented', src/lib.rs:163:9
FAILED
test solution_test::test_iterating_packets_for_zero_size_string ... thread '<unnamed>' panicked at 'not yet implemented', src/lib.rs:163:9
FAILED
test solution_test::test_serialize_packet ... FAILED
test solution_test::test_zero_size ... ok

failures:

---- solution_test::test_construct_packet_from_unicode stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `[209, 128, 208, 176, 208]`,
 right: `[209, 128, 208, 176, 208, 183]`', tests/solution_test.rs:83:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

---- solution_test::test_construct_packet_no_remainder stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `[208, 177, 208, 176, 208, 177, 208]`,
 right: `[208, 177, 208, 176, 208, 177, 208, 176]`', tests/solution_test.rs:47:5

---- solution_test::test_construct_packet_with_remainder stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `[116, 101, 115, 116]`,
 right: `[116, 101, 115, 116, 32]`', tests/solution_test.rs:54:5

---- solution_test::test_construct_packet_with_remainder_cyrillic stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `[208, 180, 209]`,
 right: `[208, 180, 209, 143]`', tests/solution_test.rs:65:5

---- solution_test::test_consuming_packets stdout ----
thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', src/libcore/option.rs:378:21

---- solution_test::test_deserialize_invalid_packet stdout ----
thread 'main' panicked at 'Expression Ok((Packet { version: 2, size: 2, payload: [2] }, [107])) does not match the pattern "Err(PacketError::UnknownProtocolVersion)"', tests/solution_test.rs:147:5

---- solution_test::test_deserialize_packet stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `(Packet { version: 1, size: 1, payload: [] }, [1, 107])`,
 right: `(Packet { version: 1, size: 3, payload: [120, 121, 122] }, [])`', tests/solution_test.rs:114:5

---- solution_test::test_deserialize_unicode_packet stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `(Packet { version: 1, size: 1, payload: [] }, [130, 209, 128, 208, 190, 0, 0, 7, 16])`,
 right: `(Packet { version: 1, size: 10, payload: [209, 133, 208, 184, 209, 130, 209, 128, 208, 190] }, [])`', tests/solution_test.rs:131:5

---- solution_test::test_full_roundtrip stdout ----
thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', src/libcore/option.rs:378:21

---- solution_test::test_full_roundtrip_for_zero_size_string stdout ----
thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', src/libcore/option.rs:378:21

---- solution_test::test_invalid_packet_combination stdout ----
thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', src/libcore/option.rs:378:21

---- solution_test::test_iterating_packets stdout ----
thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', src/libcore/option.rs:378:21

---- solution_test::test_iterating_packets_for_zero_size_string stdout ----
thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', src/libcore/option.rs:378:21

---- solution_test::test_serialize_packet stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `[0, 0, 0, 5]`,
 right: `[0, 0, 1, 107]`', tests/solution_test.rs:103:5


failures:
    solution_test::test_construct_packet_from_unicode
    solution_test::test_construct_packet_no_remainder
    solution_test::test_construct_packet_with_remainder
    solution_test::test_construct_packet_with_remainder_cyrillic
    solution_test::test_consuming_packets
    solution_test::test_deserialize_invalid_packet
    solution_test::test_deserialize_packet
    solution_test::test_deserialize_unicode_packet
    solution_test::test_full_roundtrip
    solution_test::test_full_roundtrip_for_zero_size_string
    solution_test::test_invalid_packet_combination
    solution_test::test_iterating_packets
    solution_test::test_iterating_packets_for_zero_size_string
    solution_test::test_serialize_packet

test result: FAILED. 1 passed; 14 failed; 0 ignored; 0 measured; 0 filtered out

error: test failed, to rerun pass '--test solution_test'

История (1 версия и 3 коментара)