web30 0.21.0

Async endian safe web3 library
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

//! This module contains an extremely simple memory usage parser for Linux based systems.
//! Obviously this will not work on other platforms and we'll default to our normal buffer size.
//! The intent is to protect low memory systems (usually embedded Linux) from crashes caused by
//! OOM events. This may not work in containers or on specific cloud systems either.

use std::cmp::min;
use std::fs::File;
use std::io::BufRead;
use std::io::BufReader;

/// This struct represents memory info in a Linux
/// system parsed from 'proc/meminfo'. All amounts
/// are in kilobytes
#[derive(Copy, Clone, PartialEq, Eq)]
struct MemInfo {
    /// total system memory
    mem_total: usize,
    /// memory not currently used by anything
    mem_free: usize,
    /// memory not used + memory used by disk cache
    mem_available: usize,
}

fn get_memory_info() -> Option<MemInfo> {
    let lines = get_lines("/proc/meminfo")?;
    let mut lines = lines.iter();
    let mem_total: usize = match lines.next() {
        Some(line) => match line.split_whitespace().nth(1) {
            Some(val) => {
                let res = val.parse();
                if res.is_err() {
                    return None;
                }
                res.unwrap()
            }
            None => return None,
        },
        None => return None,
    };
    let mem_free: usize = match lines.next() {
        Some(line) => match line.split_whitespace().nth(1) {
            Some(val) => {
                let res = val.parse();
                if res.is_err() {
                    return None;
                }
                res.unwrap()
            }
            None => return None,
        },
        None => return None,
    };
    let mem_available: usize = match lines.next() {
        Some(line) => match line.split_whitespace().nth(1) {
            Some(val) => {
                let res = val.parse();
                if res.is_err() {
                    return None;
                }
                res.unwrap()
            }
            None => return None,
        },
        None => return None,
    };

    Some(MemInfo {
        mem_available,
        mem_free,
        mem_total,
    })
}

fn get_lines(filename: &str) -> Option<Vec<String>> {
    let f = File::open(filename);

    if f.is_err() {
        return None;
    }
    let f = f.unwrap();

    let file = BufReader::new(&f);
    let mut out_lines = Vec::new();
    for line in file.lines() {
        match line {
            Ok(val) => out_lines.push(val),
            Err(_) => break,
        }
    }

    Some(out_lines)
}

/// Gets the request buffer size which is either DEFAULT_BUFFER or the systems
/// available memory if parsing /proc/meminfo succeeds, the DEFAULT_BUFFER size
/// is larger than the total memory available on many users systems, this is ok
/// must of the time because the memory is not actually allocated until it is used.
///
/// On the other hand it is possible for a payload that large to be sent, and the
/// program or worse the system, will die due out of memory. This function resolves this
/// issue for a subset of users running Linux by using the systems available memory, for
/// those users an OOM crash will be impossible no matter the input size, although parsing
/// will of course fail in that case.
pub fn get_buffer_size() -> usize {
    // default buffer size of 10GB in bytes, this is excessive by a good margin
    // but memory is not actually allocated until it is used
    const DEFAULT_BUFFER: usize = 10_000_000_000;
    if let Some(mem_status) = get_memory_info() {
        trace!("Successfully got memory info",);
        // proc/meminfo has memory in kilobytes but the buffer uses bytes for it's memory
        // size spec, we perform a conversion here. The only way this can ever fail is if
        // we have a very strange system where memory addressing has several more bits than
        // the system integer size and then that system is actually loaded with a huge amount
        // of memory.
        let mul_res = mem_status.mem_available.checked_mul(1000);
        match mul_res {
            Some(value) => {
                // effectively just checking for zero, since this is probably
                // a parsing error we're going to ignore it
                let div_res = value.checked_div(2);
                match div_res {
                    Some(value) => min(DEFAULT_BUFFER, value),
                    None => DEFAULT_BUFFER,
                }
            }
            None => DEFAULT_BUFFER,
        }
    } else {
        DEFAULT_BUFFER
    }
}