hypercore-protocol 0.7.0

Replication protocol for Hypercore feeds
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use anyhow::Result;
use instant::Duration;
use std::{
    fs::{create_dir_all, remove_dir_all, remove_file},
    path::Path,
    process::Command,
};

use tokio::{process, task, time::sleep};

use crate::_util::wait_for_localhost_port;

pub fn cleanup() {
    if Path::new("tests/js/node_modules").exists() {
        remove_dir_all("tests/js/node_modules").expect("Unable to run rm to delete node_modules");
    }
    if Path::new("tests/js/work").exists() {
        remove_dir_all("tests/js/work").expect("Unable to run rm to delete work");
    }
    if Path::new("tests/js/package-lock.json").exists() {
        remove_file("tests/js/package-lock.json")
            .expect("Unable to run rm to delete package-lock.json");
    }
}

pub fn install() {
    let status = Command::new("npm")
        .current_dir("tests/js")
        .args(["install"])
        .status()
        .expect("Unable to run npm install");
    assert_eq!(
        Some(0),
        status.code(),
        "npm install did not run successfully. Do you have npm installed and a network connection?"
    );
}

pub fn prepare_test_set(test_set: &str) -> (String, String, String) {
    let path_result = format!("tests/js/work/{test_set}/result.txt");
    let path_writer = format!("tests/js/work/{test_set}/writer");
    let path_reader = format!("tests/js/work/{test_set}/reader");
    create_dir_all(&path_writer).expect("Unable to create work writer directory");
    create_dir_all(&path_reader).expect("Unable to create work reader directory");
    (path_result, path_writer, path_reader)
}

pub struct JavascriptServer {
    handle: Option<task::JoinHandle<()>>,
}

impl JavascriptServer {
    pub fn new() -> JavascriptServer {
        JavascriptServer { handle: None }
    }

    pub async fn run(
        &mut self,
        is_writer: bool,
        port: u32,
        data_count: usize,
        data_size: usize,
        data_char: char,
        test_set: String,
    ) {
        self.handle = Some(task::spawn(async move {
            // This sometimes fails on OSX immediately with unix signal 4, let's retry a few times
            let mut retries = 3;
            let mut code: Option<i32> = None;
            while code.is_none() && retries > 0 {
                let status = process::Command::new("node")
                    .current_dir("tests/js")
                    .args([
                        "interop.js",
                        "server",
                        if is_writer { "writer" } else { "reader" },
                        &port.to_string(),
                        &data_count.to_string(),
                        &data_size.to_string(),
                        &data_char.to_string(),
                        &test_set,
                    ])
                    .kill_on_drop(true)
                    .status()
                    .await
                    .expect("Unable to execute node");
                code = status.code();
                if code.is_none() {
                    sleep(Duration::from_millis(100)).await;
                    retries -= 1;
                }
            }

            assert_eq!(
                Some(0),
                code,
                "node server did not exit successfully, is_writer={is_writer}, port={port}, data_count={data_count}, data_size={data_size}, data_char={data_char}, test_set={test_set}",
            );
        }));
        wait_for_localhost_port(port).await;
    }
}

pub async fn js_start_server(
    is_writer: bool,
    port: u32,
    data_count: usize,
    data_size: usize,
    data_char: char,
    test_set: String,
) -> Result<JavascriptServer> {
    let mut server = JavascriptServer::new();
    server
        .run(is_writer, port, data_count, data_size, data_char, test_set)
        .await;
    Ok(server)
}

pub async fn js_run_client(
    is_writer: bool,
    port: u32,
    data_count: usize,
    data_size: usize,
    data_char: char,
    test_set: &str,
) {
    let status = process::Command::new("node")
        .current_dir("tests/js")
        .args([
            "interop.js",
            "client",
            if is_writer { "writer" } else { "reader" },
            &port.to_string(),
            &data_count.to_string(),
            &data_size.to_string(),
            &data_char.to_string(),
            test_set,
        ])
        .kill_on_drop(true)
        .status()
        .await
        .expect("Unable to execute node");
    assert_eq!(
        Some(0),
        status.code(),
        "node client did not run successfully, \
        is_writer={is_writer}, \
        port={port}, \
        data_count={data_count}, \
        data_size={data_size}, \
        data_char={data_char}, \
        test_set={test_set}"
    );
}