daxvena/elemeld - Change V3OPQUNK5UPWNZ7BBESYQ2XDBOGDYS3DMOOVYIM2K7WHEPSIPMGAC

Fixed ip

Created by daxvena on September 19, 2020

V3OPQUNK5UPWNZ7BBESYQ2XDBOGDYS3DMOOVYIM2K7WHEPSIPMGAC

Dependencies

In channels

main

Change contents

Deletion in Cargo.lock at line 23 [4.34]
∅:D[3.531] → [4.792:805]
B:BD[4.792] → [4.792:805]
B:BD[4.805] → [5.0:21]
B:BD[5.21] → [6.0:19]
∅:D[6.19] → [5.40:105]
B:BD[5.40] → [5.40:105]
B:BD[5.105] → [6.20:98]
∅:D[6.98] → [5.183:236]
B:BD[5.183] → [5.183:236]
```
[[package]]
name = "async-trait"
version = "0.1.40"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "687c230d85c0a52504709705fc8a53e4a692b83a2184f03dae73e38e1e93a783"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
```
Deletion in Cargo.lock at line 148 [4.34]
B:BD[3.1964] → [5.1060:1076]
```
 "async-trait",
```
Insertion in Cargo.lock at line 149 [4.34]
[5.1088]
[3.1964]
```
 "bytes",
```
Insertion in Cargo.lock at line 160 [4.34]
[5.1099]
[7.218]
```
 "tokio-util",
```

Insertion in Cargo.lock at line 659 [4.34]

[5.3714]

 "pin-project-lite",
]
[[package]]
name = "tokio-util"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "be8242891f2b6cbef26a2d7e8605133c2c554cd35b3e4948ea892d6d68436499"
dependencies = [
 "bytes",
 "futures-core",
 "futures-sink",
 "log",

Insertion in Cargo.lock at line 673 [4.34]
[5.3735]
[5.3735]
```
 "tokio",
```
Deletion in Cargo.toml at line 8 [8.18912]
B:BD[8.19021] → [5.4196:4216]
```
async-trait = "0.1"
```
Insertion in Cargo.toml at line 9 [8.18912]
[5.4232]
[3.7145]
```
bytes = "0.5.6"
```

Insertion in Cargo.toml at line 20 [8.18912]

[6.3952]

[7.411]

tokio-util = { version = "0.3", features = ["codec", "udp"]}

Deletion in src/io.rs at line 3 [9.11]
B:BD[3.8213] → [5.4292:4322]
```
use async_trait::async_trait;
```

Replacement in src/io.rs at line 8 [9.11]

B:BD[10.10926] → [11.0:97]

pub trait HostInterface: Stream<Item=io::Result<HostEvent>> + Sink<HostEvent, Error=io::Error> {

[10.10926]

[12.34]

pub trait HostInterface
    : Stream<Item=io::Result<HostEvent>>
    + Sink<HostEvent, Error=io::Error>
{

Deletion in src/io.rs at line 19 [9.11]
B:BD[9.313] → [9.313:314]
B:BD[9.314] → [5.4323:4338]
∅:D[5.4338] → [10.11019:11044]
B:BD[9.314] → [10.11019:11044]
B:BD[10.11044] → [5.4339:4354]
```
#[async_trait]
pub trait NetInterface {
    type Addr;
```

Replacement in src/io.rs at line 20 [9.11]

B:BD[5.4355] → [5.4355:4589]

    async fn send_to(&mut self, event: &NetEvent, addr: &Self::Addr) -> io::Result<()>;
    async fn send_to_all(&mut self, event: &NetEvent) -> io::Result<()>;
    async fn recv_from(&mut self) -> io::Result<(NetEvent, Self::Addr)>;

[5.4355]

[12.356]

pub trait NetworkInterface<Addr>
    : Stream<Item=bincode::Result<(NetEvent, Addr)>>
    + Sink<(NetEvent, Addr), Error=bincode::Error>
    + Sink<NetEvent, Error=bincode::Error>
{

Replacement in src/ip.rs at line 3 [10.11607]

B:BD[10.11639] → [5.4609:4639]

use async_trait::async_trait;

[10.11639]

[5.4639]

use bytes::buf::ext::{BufExt, BufMutExt};
use bytes::BytesMut;
use futures::{Sink, Stream};

Insertion in src/ip.rs at line 8 [10.11607]

[5.4682]

[10.11664]

use tokio_util::codec::{Decoder, Encoder};
use tokio_util::udp::UdpFramed;

Insertion in src/ip.rs at line 13 [10.11607]
[5.4729]
[10.11752]
```
use std::pin::Pin;
use std::task::{Context, Poll};
```
Replacement in src/ip.rs at line 22 [10.11607]
B:BD[13.6647] → [13.6647:6672]
B:BD[13.6672] → [5.4730:4753]
```
pub struct IpInterface {
    socket: UdpSocket,
```
[13.6647]
[13.6673]
```
pub struct Network {
    framed: UdpFramed<Codec>,
```
Replacement in src/ip.rs at line 27 [10.11607]
B:BD[10.11893] → [13.6694:6713]
```
impl IpInterface {
```
[10.11893]
[5.4754]
```
impl Network {
```

Insertion in src/ip.rs at line 43 [10.11607]

[5.5331]

            framed: UdpFramed::new(socket, Codec),

Deletion in src/ip.rs at line 45 [10.11607]
B:BD[5.5351] → [5.5351:5371]
```
            socket,
```

Replacement in src/ip.rs at line 49 [10.11607]

B:BD[10.12545] → [5.5372:5387]

∅:D[5.5387] → [13.6768:6804]

B:BD[10.12545] → [13.6768:6804]

B:BD[13.6804] → [5.5388:5416]

#[async_trait]
impl NetInterface for IpInterface {
    type Addr = SocketAddr;

[10.12545]

[5.5416]

impl Stream for Network {
    type Item = bincode::Result<(NetEvent, SocketAddr)>;
    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
        let item = Pin::new(&mut self.framed).poll_next(cx);
        if let Poll::Ready(Some(Ok((event, addr)))) = &item {
            debug!("<= {} => {:#?}", addr, event);
        }
        item
    }
}
impl Sink<(NetEvent, SocketAddr)> for Network {
    type Error = bincode::Error;
    fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
        Pin::new(&mut self.framed).poll_ready(cx)
    }
    fn start_send(mut self: Pin<&mut Self>, item: (NetEvent, SocketAddr)) -> Result<(), Self::Error> {
        let (event, addr) = &item;
        debug!("=> {} <= {:#?}", addr, event);
        Pin::new(&mut self.framed).start_send(item)
    }

Replacement in src/ip.rs at line 74 [10.11607]

B:BD[5.5417] → [5.5417:5563]

∅:D[14.8001] → [15.1242:1314]

∅:D[5.5563] → [15.1242:1314]

B:BD[15.1242] → [15.1242:1314]

B:BD[15.1314] → [5.5564:5630]

    async fn send_to(&mut self, event: &NetEvent, addr: &Self::Addr) -> io::Result<()> {
        let packet = bincode::serialize(event).unwrap();
        debug!("=> {} <= ({} bytes) {:#?}", addr, packet.len(), event);
        self.socket.send_to(&packet, addr).await?;
        Ok(())

[5.5417]

[10.13109]

    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
        Pin::new(&mut self.framed).poll_flush(cx)

Replacement in src/ip.rs at line 78 [10.11607]

B:BD[10.13116] → [5.5631:5705]

    async fn send_to_all(&mut self, event: &NetEvent) -> io::Result<()> {

[10.13116]

[5.5705]

    fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
        Pin::new(&mut self.framed).poll_close(cx)
    }
}
impl Sink<NetEvent> for Network {
    type Error = bincode::Error;
    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
        <Network as Sink<(NetEvent, SocketAddr)>>::poll_ready(self, cx)
    }
    fn start_send(self: Pin<&mut Self>, event: NetEvent) -> Result<(), Self::Error> {

Replacement in src/ip.rs at line 92 [10.11607]

B:BD[5.5787] → [5.5787:5845]

        self.send_to(event, &addr).await?;
        Ok(())

[5.5787]

[10.13342]

        <Network as Sink<(NetEvent, SocketAddr)>>::start_send(self, (event, addr))
    }
    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
        <Network as Sink<(NetEvent, SocketAddr)>>::poll_flush(self, cx)
    }
    fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
        <Network as Sink<(NetEvent, SocketAddr)>>::poll_close(self, cx)
    }
}
struct Codec;
impl Decoder for Codec {
    type Item = NetEvent;
    type Error = bincode::Error;
    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
        // Assume that an event will be received in a single packet
        Ok(Some(bincode::deserialize_from(src.reader())?))

Insertion in src/ip.rs at line 114 [10.11607]
[10.13348]
[10.13348]
```
}
```

Replacement in src/ip.rs at line 116 [10.11607]

B:BD[10.13349] → [5.5846:5920]

∅:D[16.5745] → [10.13418:13451]

∅:D[17.5712] → [10.13418:13451]

∅:D[5.5920] → [10.13418:13451]

B:BD[10.13418] → [10.13418:13451]

B:BD[10.13451] → [5.5921:6140]

    async fn recv_from(&mut self) -> io::Result<(NetEvent, Self::Addr)> {
        let mut buf = [0; 1024];
        let (len, addr) = self.socket.recv_from(&mut buf).await?;
        let event = bincode::deserialize(&buf[..len]).unwrap();
        debug!("<= {} => ({} bytes) {:#?}", addr, len, event);
        Ok((event, addr))

[10.13349]

[10.14919]

impl Encoder<NetEvent> for Codec {
    type Error = bincode::Error;
    fn encode(&mut self, event: NetEvent, dst: &mut BytesMut) -> Result<(), Self::Error> {
        // Assume that a serialized event won't exceed the MTU
        bincode::serialize_into(dst.writer(), &event)

Insertion in src/ip.rs at line 124 [10.11607]
[10.14927]
```
impl NetworkInterface<SocketAddr> for Network { }
```

Replacement in src/x11.rs at line 332 [8.308]

B:BD[6.10841] → [2.1007:1117]

    fn poll_next(
        self: Pin<&mut Self>,
        cx: &mut Context,
    ) -> Poll<Option<Self::Item>> {

[6.10841]

[11.267]

    fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {

Fixed ip

Dependencies

In channels

Change contents

Deletion in Cargo.lock at line 23 [4.34]

Deletion in Cargo.lock at line 148 [4.34]

Insertion in Cargo.lock at line 149 [4.34]

Insertion in Cargo.lock at line 160 [4.34]

Insertion in Cargo.lock at line 659 [4.34]

Insertion in Cargo.lock at line 673 [4.34]

Deletion in Cargo.toml at line 8 [8.18912]

Insertion in Cargo.toml at line 9 [8.18912]

Insertion in Cargo.toml at line 20 [8.18912]

Deletion in src/io.rs at line 3 [9.11]

Replacement in src/io.rs at line 8 [9.11]

Deletion in src/io.rs at line 19 [9.11]

Replacement in src/io.rs at line 20 [9.11]

Replacement in src/ip.rs at line 3 [10.11607]

Insertion in src/ip.rs at line 8 [10.11607]

Insertion in src/ip.rs at line 13 [10.11607]

Replacement in src/ip.rs at line 22 [10.11607]

Replacement in src/ip.rs at line 27 [10.11607]