stavola.xyz
Small Rust scripts
Merge pull request #3 from mbStavola/add-rustfmt-config
Reformat scripts
authored by
Matt Freitas-Stavola
and committed by
GitHub
08b599c2
ca15b7d9
+54
-49
+9
-13
cidrcheck
+9
-13
cidrcheck
···
2
3
// cargo-deps: argh = "0.1", cidr = "0.2.1"
4
5
-
use argh::FromArgs;
6
-
use cidr::IpCidr;
7
-
8
use std::net::IpAddr;
9
use std::str::FromStr;
10
11
#[derive(FromArgs)]
12
#[argh(description = "Display the ip range for a CIDR and check if an ip falls within.")]
···
18
)]
19
ip: Option<IpAddr>,
20
21
-
#[argh(
22
-
positional,
23
-
description = "CIDR to inspect",
24
-
from_str_fn(parse_cidr)
25
-
)]
26
cidr: IpCidr,
27
}
28
29
fn main() {
30
let App { ip, cidr } = argh::from_env();
31
println!(
32
-
"CIDR {} has a range of: {} to {}",
33
-
cidr,
34
-
cidr.first_address(),
35
cidr.last_address()
36
);
37
38
println!("CIDR {} has a netmask of {}", cidr, cidr.mask());
39
-
40
if let Some(ip) = ip {
41
print!("IP {}", ip);
42
let falls_within = cidr.contains(&ip);
···
46
print!(" does not fall ");
47
}
48
49
-
println!("within {}", cidr);
50
}
51
}
52
···
2
3
// cargo-deps: argh = "0.1", cidr = "0.2.1"
4
5
use std::net::IpAddr;
6
use std::str::FromStr;
7
+
8
+
use argh::FromArgs;
9
+
use cidr::IpCidr;
10
11
#[derive(FromArgs)]
12
#[argh(description = "Display the ip range for a CIDR and check if an ip falls within.")]
···
18
)]
19
ip: Option<IpAddr>,
20
21
+
#[argh(positional, description = "CIDR to inspect", from_str_fn(parse_cidr))]
22
cidr: IpCidr,
23
}
24
25
fn main() {
26
let App { ip, cidr } = argh::from_env();
27
println!(
28
+
"CIDR {} has a range of: {} to {}",
29
+
cidr,
30
+
cidr.first_address(),
31
cidr.last_address()
32
);
33
34
println!("CIDR {} has a netmask of {}", cidr, cidr.mask());
35
+
36
if let Some(ip) = ip {
37
print!("IP {}", ip);
38
let falls_within = cidr.contains(&ip);
···
42
print!(" does not fall ");
43
}
44
45
+
println!("within {}", cidr);
46
}
47
}
48
+8
-9
dbg_server
+8
-9
dbg_server
···
2
3
// cargo-deps: argh = "0.1"
4
5
-
use argh::FromArgs;
6
-
7
use std::net::TcpListener;
8
-
use std::io::BufRead;
9
-
use std::io::BufReader;
10
use std::str;
11
12
#[derive(FromArgs)]
13
#[argh(description = "simple debug server which logs the data sent to it.")]
···
35
let stream = stream.expect("stream should be present");
36
let mut stream = BufReader::new(stream);
37
38
-
// This is not the "best" way to get the data sent over
39
-
// but it sure is the easiest :^)
40
-
let data = stream.fill_buf().expect("should have data");
41
-
let output = str::from_utf8(data).expect("should be able to parse data as text");
42
-
println!("{}", output);
43
}
44
}
···
2
3
// cargo-deps: argh = "0.1"
4
5
+
use std::io::{BufRead, BufReader};
6
use std::net::TcpListener;
7
use std::str;
8
+
9
+
use argh::FromArgs;
10
11
#[derive(FromArgs)]
12
#[argh(description = "simple debug server which logs the data sent to it.")]
···
34
let stream = stream.expect("stream should be present");
35
let mut stream = BufReader::new(stream);
36
37
+
// This is not the "best" way to get the data sent over
38
+
// but it sure is the easiest :^)
39
+
let data = stream.fill_buf().expect("should have data");
40
+
let output = str::from_utf8(data).expect("should be able to parse data as text");
41
+
println!("{}", output);
42
}
43
}
+3
-3
emojidex
+3
-3
emojidex
···
9
//! image = "0.23.14"
10
//! ```
11
12
use argh::FromArgs;
13
use image::io::Reader;
14
use reqwest::blocking::Client;
15
use serde::Deserialize;
16
use viuer::Config;
17
-
18
-
use std::io::{BufReader, Cursor};
19
-
use std::str::FromStr;
20
21
const BASE_API_URL: &str = "https://www.emojidex.com/api/v1";
22
const BASE_CDN_URL: &str = "https://cdn.emojidex.com/emoji";
···
9
//! image = "0.23.14"
10
//! ```
11
12
+
use std::io::{BufReader, Cursor};
13
+
use std::str::FromStr;
14
+
15
use argh::FromArgs;
16
use image::io::Reader;
17
use reqwest::blocking::Client;
18
use serde::Deserialize;
19
use viuer::Config;
20
21
const BASE_API_URL: &str = "https://www.emojidex.com/api/v1";
22
const BASE_CDN_URL: &str = "https://cdn.emojidex.com/emoji";
+15
-10
flush_cache
+15
-10
flush_cache
···
2
3
// cargo-deps: argh = "0.1"
4
5
use argh::FromArgs;
6
-
7
-
use std::net::Shutdown;
8
-
use std::net::TcpStream;
9
-
use std::io::BufRead;
10
-
use std::io::BufReader;
11
-
use std::io::Write;
12
13
const FLUSH_COMMAND: &str = "FLUSHALL\r\n";
14
···
32
let address = format!("{}:{}", app.host, app.port);
33
let mut stream = TcpStream::connect(address).expect("should be able to connect to redis");
34
35
-
stream.write(FLUSH_COMMAND.as_bytes()).expect("should be able to write flush command");
36
-
stream.flush().expect("should be able to send flush command");
37
-
stream.shutdown(Shutdown::Write).expect("should be able to shutdown writer");
38
39
let mut stream = BufReader::new(stream);
40
41
let mut output = String::new();
42
-
let _ = stream.read_line(&mut output).expect("should be able to read response");
43
println!("{}", &output);
44
}
···
2
3
// cargo-deps: argh = "0.1"
4
5
+
use std::io::{BufRead, BufReader, Write};
6
+
use std::net::{Shutdown, TcpStream};
7
+
8
use argh::FromArgs;
9
10
const FLUSH_COMMAND: &str = "FLUSHALL\r\n";
11
···
29
let address = format!("{}:{}", app.host, app.port);
30
let mut stream = TcpStream::connect(address).expect("should be able to connect to redis");
31
32
+
stream
33
+
.write(FLUSH_COMMAND.as_bytes())
34
+
.expect("should be able to write flush command");
35
+
stream
36
+
.flush()
37
+
.expect("should be able to send flush command");
38
+
stream
39
+
.shutdown(Shutdown::Write)
40
+
.expect("should be able to shutdown writer");
41
42
let mut stream = BufReader::new(stream);
43
44
let mut output = String::new();
45
+
let _ = stream
46
+
.read_line(&mut output)
47
+
.expect("should be able to read response");
48
println!("{}", &output);
49
}
+2
-2
kill_port
+2
-2
kill_port
+7
rustfmt.toml
+7
rustfmt.toml
+2
-2
sierpinski
+2
-2
sierpinski
+2
-2
stopwatch
+2
-2
stopwatch
+1
-2
strs
+1
-2
strs
+1
-2
tag_release
+1
-2
tag_release