drop ipcheck source

Author: KodrAus

tools/ipcheck/.gitignore

@@ -0,0 +1 @@
+artifacts

tools/ipcheck/README.md

@@ -0,0 +1,31 @@
+# IP Check
+
+Created for https://github.com/rust-lang/rust/pull/76098
+
+This is a little utility program for checking the behavior of various language's IP address implementations.
+The goal is to make sure the Rust programs are either the same or deliberately different to other languages.
+
+This same approach might be useful for other APIs that have externally specified behavior that may diverge betweens implementations.
+
+## Implementations
+
+These live under the `impls` directory.
+
+- Rust (New) (`impls/rust`) with the behavior proposed in `#76098`
+- Rust (Current) (`impls/rust_current`) with the current behavior on `nightly`
+- .NET (`impls/dotnet`)
+- Python (`impls/python`)
+- Go (`impls/go`)
+- Java (`impls/java`)
+
+## Running
+
+With the comparison languages available, you can run `cd host && cargo run` to compare them.
+The results are written as a Markdown table to `stdout`.
+The set of interesting inputs to compare comes from the `/host/input.txt` file.
+
+## How it works
+
+The _host_ program (under `/host`) will attempt to build and execute a number of language implementations.
+Each language implementation will accept an input via `stdin` and write a JSON payload to `stdout` containing the results of its execution.
+These payloads are then compared against a reference implementation to see how they're affected by different inputs.

tools/ipcheck/host/.gitignore

@@ -0,0 +1,2 @@
+/target
+Cargo.lock

tools/ipcheck/host/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "ipcheck-host"
+version = "0.0.0"
+authors = ["Ashley Mannix <[email protected]>", "Christiaan Dirkx <[email protected]>"]
+publish = false
+edition = "2018"
+build = "build/build.rs"
+
+[[bin]]
+name = "ipcheck-host"
+path = "main.rs"
+
+[dependencies]
+serde_json = "1"
+
+[build-dependencies]
+cfg-if = "1"
+walkdir = "2"

tools/ipcheck/host/build/build.rs

@@ -0,0 +1,53 @@
+mod dotnet;
+mod go;
+mod java;
+mod python;
+mod rust;
+
+fn main() {
+    if !std::path::Path::new("../artifacts").exists() {
+        std::fs::create_dir("../artifacts").expect("failed to create artifacts dir");
+    }
+
+    let mut impls =
+        std::fs::File::create("../artifacts/.impls").expect("failed to create .impls file");
+
+    output_impl(&mut impls, "Rust (New)", rust::build_new());
+    output_impl(&mut impls, "Rust (Current)", rust::build_current());
+    output_impl(&mut impls, ".NET", dotnet::build());
+    output_impl(&mut impls, "Python", python::build());
+    output_impl(&mut impls, "Go", go::build());
+    output_impl(&mut impls, "Java", java::build());
+
+    rerun_if_changed("build");
+    rerun_if_changed("../impls");
+}
+
+fn output_impl(
+    file: &mut std::fs::File,
+    lang: impl AsRef<str>,
+    result: std::io::Result<impl AsRef<str>>,
+) {
+    use std::io::Write;
+
+    let lang = lang.as_ref();
+
+    println!("Building {}", lang);
+
+    match result {
+        Ok(artifact) => {
+            writeln!(file, "{}: {}", lang, artifact.as_ref()).expect("failed to write .impls file")
+        }
+        Err(err) => {
+            println!("cargo:warning=Failed to build {} impl: {}", lang, err)
+        }
+    }
+}
+
+fn rerun_if_changed(dir: &str) {
+    for entry in walkdir::WalkDir::new(dir) {
+        if let Ok(entry) = entry {
+            println!("cargo:rerun-if-changed={}", entry.path().display());
+        }
+    }
+}

tools/ipcheck/host/build/dotnet.rs

@@ -0,0 +1,25 @@
+pub fn build() -> std::io::Result<&'static str> {
+    if !std::path::Path::new("../artifacts/dotnet").exists() {
+        std::fs::create_dir("../artifacts/dotnet").expect("failed to create .NET artifacts dir");
+    }
+
+    std::fs::copy(
+        "../impls/dotnet/IPCheck.cs",
+        "../artifacts/dotnet/IPCheck.cs",
+    )?;
+    std::fs::copy(
+        "../impls/dotnet/IPCheck.csproj",
+        "../artifacts/dotnet/IPCheck.csproj",
+    )?;
+
+    let output = std::process::Command::new("dotnet").args(&["--version"]).output()?;
+
+    if output.status.success() {
+        Ok("dotnet run -p ../artifacts/dotnet/IpCheck.csproj")
+    } else {
+        Err(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            format!("{:?}", String::from_utf8_lossy(&output.stderr)),
+        ))
+    }
+}

tools/ipcheck/host/build/go.rs

@@ -0,0 +1,19 @@
+pub fn build() -> std::io::Result<&'static str> {
+    if !std::path::Path::new("../artifacts/go").exists() {
+        std::fs::create_dir("../artifacts/go").expect("failed to create Go artifacts dir");
+    }
+
+    let output = std::process::Command::new("go")
+        .args(&["build", "-o", "../../artifacts/go", "ipcheck.go"])
+        .current_dir("../impls/go")
+        .output()?;
+
+    if output.status.success() {
+        Ok("../artifacts/go/ipcheck")
+    } else {
+        Err(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            format!("{:?}", String::from_utf8_lossy(&output.stderr)),
+        ))
+    }
+}

tools/ipcheck/host/build/java.rs

@@ -0,0 +1,21 @@
+pub fn build() -> std::io::Result<&'static str> {
+    if !std::path::Path::new("../artifacts/java").exists() {
+        std::fs::create_dir("../artifacts/java").expect("failed to create Java artifacts dir");
+    }
+
+    std::fs::copy(
+        "../impls/java/IpCheck.java",
+        "../artifacts/java/IpCheck.java",
+    )?;
+
+    let output = std::process::Command::new("java").args(&["--version"]).output()?;
+
+    if output.status.success() {
+        Ok("java ../artifacts/java/IpCheck.java")
+    } else {
+        Err(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            format!("{:?}", String::from_utf8_lossy(&output.stderr)),
+        ))
+    }
+}

tools/ipcheck/host/build/python.rs

@@ -0,0 +1,21 @@
+pub fn build() -> std::io::Result<&'static str> {
+    if !std::path::Path::new("../artifacts/python").exists() {
+        std::fs::create_dir("../artifacts/python").expect("failed to create Python artifacts dir");
+    }
+
+    std::fs::copy(
+        "../impls/python/ipcheck.py",
+        "../artifacts/python/ipcheck.py",
+    )?;
+
+    let output = std::process::Command::new("python").args(&["--version"]).output()?;
+
+    if output.status.success() {
+        Ok("python ../artifacts/python/ipcheck.py")
+    } else {
+        Err(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            format!("{:?}", String::from_utf8_lossy(&output.stderr)),
+        ))
+    }
+}

tools/ipcheck/host/build/rust.rs

@@ -0,0 +1,54 @@
+use std::path::Path;
+
+pub fn build_new() -> std::io::Result<String> {
+    build_bin("../impls/rust_new", "../artifacts/rust_new", "ipcheck_new")
+}
+
+pub fn build_current() -> std::io::Result<String> {
+    build_bin(
+        "../impls/rust_current",
+        "../artifacts/rust_current",
+        "ipcheck_current",
+    )
+}
+
+fn build_bin(
+    src_path: impl AsRef<Path>,
+    artifact_path: impl AsRef<Path>,
+    bin: &str,
+) -> std::io::Result<String> {
+    let src_path = src_path.as_ref();
+    let artifact_path = artifact_path.as_ref();
+
+    if !std::path::Path::new(artifact_path).exists() {
+        std::fs::create_dir(artifact_path).expect("failed to create Rust artifacts dir");
+    }
+
+    std::fs::copy(src_path.join("main.rs"), artifact_path.join("main.rs"))?;
+    std::fs::copy(
+        src_path.join("Cargo.toml"),
+        artifact_path.join("Cargo.toml"),
+    )?;
+
+    let output = std::process::Command::new("cargo")
+        .args(&[
+            "+nightly",
+            "build",
+            "--release",
+            "-Z",
+            "unstable-options",
+            "--out-dir",
+            ".",
+        ])
+        .current_dir(artifact_path)
+        .output()?;
+
+    if output.status.success() {
+        Ok(artifact_path.join(bin).to_string_lossy().into_owned())
+    } else {
+        Err(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            format!("{:?}", String::from_utf8_lossy(&output.stderr)),
+        ))
+    }
+}