#include <stdio.h>
#include <unistd.h>

int main() {
    for (int i = 1; i <= 5; i++) {
        printf("line %d\n", i);
        sleep(1);
    }
    return 0;
}

$ gcc -o cprint cprint.c
$ ./cprint
line 1       ← appears at t=1
line 2       ← appears at t=2
line 3       ← appears at t=3
line 4       ← appears at t=4
line 5       ← appears at t=5

$ ./cprint | cat
             ← nothing for 5 seconds...
line 1       ← appears at t=5
line 2
line 3
line 4
line 5

use std::io::{self, Write};
use std::thread::sleep;
use std::time::Duration;

fn main() {
    print!("Hello");
    sleep(Duration::from_secs(3));
    println!(" World!");
}

$ cargo run
                ← nothing for 3 seconds...
Hello World!

use std::io::{self, Write};
use std::thread::sleep;
use std::time::Duration;

fn main() {
    print!("Hello");
    io::stdout().flush().unwrap();
    sleep(Duration::from_secs(3));
    println!(" World!");
}

$ cargo run
Hello           ← t=0
Hello World!    ← t=3

$ cargo run | cat
Hello           ← t=0
Hello World!    ← t=3

use std::io::{self, IsTerminal, Write};

fn main() {
    let is_tty = io::stdout().is_terminal();
    if is_tty {
        write!(&mut io::stdout(), "TTY!").unwrap();
    } else {
        write!(&mut io::stdout(), "NOT TTY!").unwrap();
    }
}

$ cargo run
TTY!

$ cargo run | cat
NOT TTY!

$ cargo run > output && cat output
NOT TTY!

let mut printer = StandardBuilder::new()
    .color_specs(ColorSpecs::default_with_color())
    .build(cli::stdout(if std::io::stdout().is_terminal() {
        ColorChoice::Auto
    } else {
        ColorChoice::Never
    }));

/// Returns a possibly buffered writer to stdout for the given color choice.
///
/// The writer returned is either line buffered or block buffered. The decision
/// between these two is made automatically based on whether a tty is attached
/// to stdout or not. If a tty is attached, then line buffering is used.
/// Otherwise, block buffering is used. In general, block buffering is more
/// efficient, but may increase the time it takes for the end user to see the
/// first bits of output.
///
/// If you need more fine grained control over the buffering mode, then use one
/// of `stdout_buffered_line` or `stdout_buffered_block`.
///
/// The color choice given is passed along to the underlying writer. To
/// completely disable colors in all cases, use `ColorChoice::Never`.
pub fn stdout(color_choice: termcolor::ColorChoice) -> StandardStream {
    if std::io::stdout().is_terminal() {
        stdout_buffered_line(color_choice)
    } else {
        stdout_buffered_block(color_choice)
    }
}

#include <stdio.h>
#include <unistd.h>

int main() {
    for (int i = 1; i <= 5; i++) {
        printf("line %d\n", i);
        sleep(1);
    }
    return 0;
}

use std::thread::sleep;
use std::time::Duration;

fn main() {
    for i in 1..=5 {
        println!("line {}", i);
        sleep(Duration::from_secs(1));
    }
}

$ cargo run
line 1       ← appears at t=1
line 2       ← appears at t=2
line 3       ← appears at t=3
line 4       ← appears at t=4
line 5       ← appears at t=5

$ cargo run | cat
line 1       ← appears at t=1
line 2       ← appears at t=2
line 3       ← appears at t=3
line 4       ← appears at t=4
line 5       ← appears at t=5

#[stable(feature = "rust1", since = "1.0.0")]
pub struct Stdout {
    // FIXME: this should be LineWriter or BufWriter depending on the state of
    //        stdout (tty or not). Note that if this is not line buffered it
    //        should also flush-on-panic or some form of flush-on-abort.
    inner: &'static ReentrantLock<RefCell<LineWriter<StdoutRaw>>>,
}

Io(Os { code: 24, kind: Other, message: "Too many open files" })

$ ls -lah /dev/fd
Permissions Size User         Date Modified Name
crw--w----  16,2 mattrighetti  4 Jun 00:44  0
crw--w----  16,2 mattrighetti  4 Jun 00:44  1
crw--w----  16,2 mattrighetti  4 Jun 00:44  2
dr--r--r--     - root         24 May 08:23  3

$ echo $$ // prints the current process id
2806524

$ sudo ls -lah /proc/2806524/fd
total 0
dr-x------ 2 root root 11 Jun  4 00:40 .
dr-xr-xr-x 9 pi   pi    0 Jun  4 00:39 ..
lrwx------ 1 root root 64 Jun  4 00:40 0 -> /dev/null
lrwx------ 1 root root 64 Jun  4 00:40 1 -> /dev/null
lrwx------ 1 root root 64 Jun  4 00:40 10 -> /dev/ptmx
lrwx------ 1 root root 64 Jun  4 00:40 11 -> /dev/ptmx
lrwx------ 1 root root 64 Jun  4 00:40 2 -> /dev/null
lrwx------ 1 root root 64 Jun  4 00:40 3 -> 'socket:[14023056]'
lrwx------ 1 root root 64 Jun  4 00:40 4 -> 'socket:[14023019]'
lrwx------ 1 root root 64 Jun  4 00:40 5 -> 'socket:[14022300]'
lrwx------ 1 root root 64 Jun  4 00:40 6 -> 'socket:[14023037]'
lrwx------ 1 root root 64 Jun  4 00:40 7 -> /dev/ptmx
l-wx------ 1 root root 64 Jun  4 00:40 8 -> /run/systemd/sessions/1501.ref

$ lsof -p $(echo $$)
COMMAND   PID         USER   FD   TYPE DEVICE SIZE/OFF                NODE NAME
zsh     39367 mattrighetti  cwd    DIR   1,17     2496              250127 /Users/mattrighetti
zsh     39367 mattrighetti  txt    REG   1,17  1361200 1152921500312522433 /bin/zsh
zsh     39367 mattrighetti  txt    REG   1,17    81288 1152921500312535786 /usr/share/locale/en_US.UTF-8/LC_COLLATE
zsh     39367 mattrighetti  txt    REG   1,17   170960 1152921500312525313 /usr/lib/zsh/5.9/zsh/zutil.so
zsh     39367 mattrighetti  txt    REG   1,17   118896 1152921500312525297 /usr/lib/zsh/5.9/zsh/terminfo.so
zsh     39367 mattrighetti  txt    REG   1,17   171344 1152921500312525281 /usr/lib/zsh/5.9/zsh/parameter.so
zsh     39367 mattrighetti  txt    REG   1,17   135696 1152921500312525255 /usr/lib/zsh/5.9/zsh/datetime.so
zsh     39367 mattrighetti  txt    REG   1,17   135568 1152921500312525291 /usr/lib/zsh/5.9/zsh/stat.so
zsh     39367 mattrighetti  txt    REG   1,17   338592 1152921500312525247 /usr/lib/zsh/5.9/zsh/complete.so
zsh     39367 mattrighetti  txt    REG   1,17   136880 1152921500312525293 /usr/lib/zsh/5.9/zsh/system.so
zsh     39367 mattrighetti  txt    REG   1,17   593088 1152921500312525303 /usr/lib/zsh/5.9/zsh/zle.so
zsh     39367 mattrighetti  txt    REG   1,17   134928 1152921500312525287 /usr/lib/zsh/5.9/zsh/rlimits.so
zsh     39367 mattrighetti  txt    REG   1,17   117920 1152921500312525263 /usr/lib/zsh/5.9/zsh/langinfo.so
zsh     39367 mattrighetti  txt    REG   1,17  2289328 1152921500312524246 /usr/lib/dyld
zsh     39367 mattrighetti  txt    REG   1,17   208128 1152921500312525249 /usr/lib/zsh/5.9/zsh/complist.so
zsh     39367 mattrighetti  txt    REG   1,17   118688 1152921500312525285 /usr/lib/zsh/5.9/zsh/regex.so
zsh     39367 mattrighetti  txt    REG   1,17   118288 1152921500312525305 /usr/lib/zsh/5.9/zsh/zleparameter.so
zsh     39367 mattrighetti    0u   CHR   16,1  0t17672                1643 /dev/ttys001
zsh     39367 mattrighetti    1u   CHR   16,1  0t17672                1643 /dev/ttys001
zsh     39367 mattrighetti    2u   CHR   16,1  0t17672                1643 /dev/ttys001
zsh     39367 mattrighetti   10u   CHR   16,1   0t5549                1643 /dev/ttys001

$ sysctl kern.maxfiles
kern.maxfiles: 245760

$ sysctl kern.maxfilesperproc
kern.maxfilesperproc: 122880

$ ulimit -n
256

#!/bin/bash

# This function exits the script gracefully
function cleanup() {
    echo -e "\nstopping."
    exit 0
}

# This function encapsulates the logic for formatting and printing the monitoring output.
# Arguments:
#   $1: Initial PID
#   $2: Total number of open files
print_status() {
    local initial_pid="$1"
    local total_open_files="$2"
    echo "$(date '+%H:%M:%S') - Main PID ($initial_pid) - open: ${total_open_files}"
}

PROCESS_NAME="cargo"
COMMAND_ARGS="test"

echo "press ctrl+c to stop."

# Find the Process ID (PID) of the initial command.
INITIAL_PID=$(pgrep -f "$PROCESS_NAME.*$COMMAND_ARGS" | head -n 1)

if [ -z "$INITIAL_PID" ]; then
    echo "waiting for '$PROCESS_NAME $COMMAND_ARGS' to start..."
    # If the process isn't found immediately, loop and wait for it.
    sleep 0.01
    while [ -z "$INITIAL_PID" ]; do
        INITIAL_PID=$(pgrep -f "$PROCESS_NAME.*$COMMAND_ARGS" | head -n 1)
    done
fi

echo "Found '$PROCESS_NAME $COMMAND_ARGS' with PID: $INITIAL_PID"

# trap command catches the INT signal (triggered by Ctrl+C)
# and calls the cleanup function to exit gracefully.
trap cleanup INT

while true; do
    # check if the main process (INITIAL_PID) is still running.
    if ! ps -p "$INITIAL_PID" > /dev/null; then
        echo "PID $INITIAL_PID no longer running. bye!"
        break
    fi

    # `sudo lsof -p "$INITIAL_PID"` lists all open files for this specific PID.
    # `2>/dev/null` redirects stderr (errors like "process not found") to null.
    # `grep -v " txt "` filters out loaded executable code and libraries for a more relevant count.
    # `wc -l` counts the lines, effectively the number of open files.
    # `tr -d ' '` removes any leading/trailing spaces for clean arithmetic.
    OPEN_FILES_COUNT=$(sudo lsof -p "$INITIAL_PID" 2>/dev/null | grep -v " txt " | wc -l | tr -d ' ')

    # Ensure COUNT is not empty (it might be if lsof returns nothing)
    if [ -z "$OPEN_FILES_COUNT" ]; then
        OPEN_FILES_COUNT=0
    fi

    print_status "$INITIAL_PID" "$TOTAL_OPEN_FILES"
done

$ sudo ./monitor.sh
press ctrl+c to stop.
waiting for 'cargo test' to start...
Found 'cargo test' with PID: 44152
01:46:21 - Main PID (44152) - open: 14
01:46:21 - Main PID (44152) - open: 32
01:46:21 - Main PID (44152) - open: 78
01:46:21 - Main PID (44152) - open: 155
01:46:21 - Main PID (44152) - open: 201
01:46:21 - Main PID (44152) - open: 228
01:46:21 - Main PID (44152) - open: 231
01:46:21 - Main PID (44152) - open: 237 # errors started happening here
01:46:21 - Main PID (44152) - open: 219
01:46:21 - Main PID (44152) - open: 205
01:46:21 - Main PID (44152) - open: 180
01:46:21 - Main PID (44152) - open: 110
01:46:21 - Main PID (44152) - open: 55
01:46:21 - Main PID (44152) - open: 28
01:46:21 - Main PID (44152) - open: 15
01:46:21 - Main PID (44152) - open: 0
PID 44152 no longer running. bye!

$ ulimit -n 8192
$ ulimit -n
8192

<!DOCTYPE html>
<html lang="en">

<head>
    <title>{% block title %}{% endblock %}</title>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    {% block head %}{% endblock %}
</head>
<body>
    <nav>
        <div>
            <div>
                {% if ctx.authed %}
                    <a href="/profile">Profile</a>
                {% else %}
                    <a href="/login">Login</a>
                {% endif %}
            </div>
        </div>
    </nav>
    {% block content %}
    {% endblock %}
</body>
</html>

#[derive(Debug, Default)]
pub struct Context {
    authed: bool,
}

#[derive(Template)]
#[templage = "layout.jinja"]
struct HomeTemplate {
    ctx: Context
};

pub async fn home() -> impl IntoResponse {
    HtmlTemplate(
        HomeTemplate { ctx: Context::default() }
    ).into_response()
}

HTTP/1.1 200 OK
Content-Type: application/json
Set-Cookie: session=xyz123; HttpOnly; Secure; SameSite=Strict; Max-Age=86400; Path=/; Domain=api.example.com

pub(crate) fn default_cookie<'a>(
    key: &str,
    token: String,
    duration_hrs: i64
) -> Cookie<'a> {
    Cookie::build((key.to_string(), token))
        .path("/")
        .http_only(true)
        .max_age(Duration::hours(duration_hrs))
        .secure(if cfg!(debug_assertions) {
            // Safari won't allow secure cookies
            // coming from localhost in debug mode
            false
        } else {
            // Secure cookies in release mode
            true
        })
        .build()
}

#[derive(Debug)]
struct LoginData {
    username: String,
    password: String
}

pub async fn login(
    State(app): State<AppState>,
    jar: CookieJar, // CookieJar is available in axum_extras
    Form(LoginData { username, password }): Form<LoginData>
) -> impl IntoResponse {
    // dummy function to get a user
    let user = match db::user::get(&app.pg_pool, &username, &password).await {
        None => return Redirect::to("/signup").into_response()
        Some(user) => user
    };

    // get/create a refresh token for the user
    let refresh_token = match db::refresh_tokens::create(user.id).await {
        Ok(token) => token,
        Err(_) => {
            return (
                StatusCode::INTERNAL_SERVER_ERROR,
                "Somethign bad happened, try again later"
            ).into_response();
        }
    };

    let claims = Claims::with(user.email, user.id);
    match jwt::generate_jwt(app.jwt_signing_key.as_bytes(), claims) {
        Ok(token) => (
            [("hx-redirect", "/")],
            jar.add(default_cookie("jwt", token, 1)).add(default_cookie(
                "refresh",
                refresh_token,
                30 * 24,
            ),
        )
            .into_response()),
        Err(_) => {
            return (
                StatusCode::INTERNAL_SERVER_ERROR,
                "Somethign bad happened, try again later"
            ).into_response();
        }
    }
}

/// Basic claims that a classic jwt contain
#[derive(Debug, Serialize, Deserialize)]
pub struct Claims {
    pub sub: String,
    pub exp: usize,
    pub user_id: uuid::Uuid,
}

/// A flexible extractor that tries
/// to get a type `T` from a request cookie
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CookieJwt<T: DeserializeOwned>(pub T);

// since axum 0.8 you can implement extractors meant to be Option<T>
// this is very useful, expecially for scenarios where endpoint can be accessed
// both by authed users and non-authed users
impl<S, T> OptionalFromRequestParts<S> for CookieJwt<T>
where
    AppState: FromRef<S>,
    S: Send + Sync,
    T: DeserializeOwned,
{
    type Rejection = Redirect;

    async fn from_request_parts(
        req: &mut Parts,
        state: &S,
    ) -> Result<Option<Self>, Self::Rejection> {
        let jar = CookieJar::from_headers(&req.headers);
        if let Some(jwt) = jar.get("jwt").map(|c| c.value()) {
            return match validate_jwt::<T>(JWT_SIGNING_KEY, jwt) {
                Ok(data) => return Ok(Some(CookieJwt(data))),
                // user tampered with cookie here, we want to delete that cookie
                // returning None here would have been okay too if you're okay with
                // manufactured cookies :)
                Err(_) => Err(Redirect::to("/logout")),
            };
        }

        // if refresh token is present, try and get a new jwt
        // by redirecting user to /refresh_token endpoint
        if jar.get("refresh").is_some() {
            return Err(Redirect::to(
                format!("/refresh_token?next={}", req.uri).as_str(),
            ));
        }

        // at this point, user has no jwt and no refresh token
        Ok(None)
    }
}

pub async fn home(jwt: Option<CookieJwt<Claims>>) -> impl IntoResponse {
    HtmlTemplate(
        HomeTemplate { ctx: Context { authed: jwt.is_some() } }
    ).into_response()
}

#[derive(Debug, Deserialize)]
pub struct RefreshTokenQuery {
    next: Option<String>,
}

pub async fn refresh_token(
    State(app): State<AppState>,
    jar: CookieJar,
    Query(RefreshTokenQuery { next }): Query<RefreshTokenQuery>,
) -> impl IntoResponse {
    let token = match jar.get("refresh") {
        Some(token) => token,
        None => {
            // if there's no token then the user goes back to /login
            return Redirect::to("/login").into_response();
        }
    };

    // if something goes wrong here we remove the token, otherwise the user could end up
    // in a loop where he's constantly being redirected here and this function fails every time
    let user = match db::refresh_tokens::get_user(&app.pg_pool, token.value()).await {
        Ok(Some(user)) => user,
        _ => {
            return (jar.remove(Cookie::from("refresh")), Redirect::to("/login")).into_response();
        }
    };

    // set new jwt
    let claims = Claims::with(user.email, user.id);
    match jwt::generate_jwt(app.jwt_signing_key.as_bytes(), claims) {
        Ok(token) => (
            jar.add(default_cookie("jwt", token, 1)),
            Redirect::to(&next.unwrap_or("/".to_owned())),
        )
        .into_response(),
        Err(_) => {
            (jar.remove(Cookie::from("refresh")), Redirect::to("/login")).into_response()
        }
    }
}

/// Middleware that handles both authenticated and unauthenticated requests.
///
/// This middleware performs JWT-based authentication by checking for `jwt` and `refresh` cookies.
/// It establishes a [`UserContext`] that flows through the request chain and manages cookie updates.
///
/// # Behavior
/// - **JWT Present**: Validates the JWT and extracts user claims if successful.
///   - Invalid JWT: Clears auth cookies (potential tampering)
/// - **No JWT but Refresh Token Present**:
///   - Attempts to refresh the token and issue a new JWT
///   - On success: Sets new cookies and establishes authenticated context
/// - **No Auth Cookies**: Proceeds with default unauthenticated context
///
/// # Cookie Management
/// - Automatically removes suspicious/invalid auth cookies
/// - Adds new JWT cookies when refresh is successful
/// - Propagates all cookie changes in the response
pub async fn base(
    State(app): State<AppState>,
    mut request: Request,
    next: Next,
) -> impl IntoResponse {
    let mut jar = CookieJar::from_headers(request.headers());
    let jwt = jar.get("jwt");
    let refresh = jar.get("refresh");

    // Default context for unauthenticated requests
    let mut context = UserContext {
        user_id: None,
        is_admin: false,
    };

    // JWT takes precedence if present
    if let Some(jwt) = jwt {
        match validate_jwt::<Claims>(JWT_SIGNING_KEY, jwt.value()) {
            Ok(claims) => {
                context.user_id = Some(claims.user_id);
            }
            Err(_) => {
                // Clear potentially compromised cookies
                jar = jar.remove("jwt").remove("refresh");
            }
        }
    }
    // Fall back to refresh token if JWT is absent/invalid
    else if let Some(refresh) = refresh {
        if let Ok(Some(user)) = db::refresh_tokens::get_user(&app.pg_pool, refresh.value()).await {
            let claims = Claims::with(user.email, user.uuid);
            if let Ok(jwt) = generate_jwt(app.jwt_signing_key.as_bytes(), claims) {
                context.user_id = Some(user.uuid);
                jar = jar.add(default_cookie("jwt", jwt, 1));
            }
            // Note: JWT generation errors are intentionally swallowed here
            // to prevent refresh token from being invalidated due to
            // temporary JWT generation issues
        }
    }

    // Inject the resolved context into request extensions
    request.extensions_mut().insert(context);

    let response = next.run(request).await;

    // Merge cookie updates with the response
    (jar, response).into_response()
}

pub async fn home(Extension(usr_ctx): Extension<UserContext>) -> impl IntoResponse {
    HtmlTemplate(
        HomeTemplate { ctx: Context { authed: usr_ctx.user_id.is_some() } }
    ).into_response()
}

pub async fn home(Extension(ctx): Extension<Context>) -> impl IntoResponse {
    HtmlTemplate(HomeTemplate { ctx }).into_response()
}

/// middleware that requires the user to be authenticated
pub async fn required_auth(
    Extension(context): Extension<UserContext>,
    request: Request,
    next: Next
) -> impl IntoResponse {
    if context.user_id.is_none() {
        return Redirect::to("/login").into_response();
    }

    next.run(request).await
}

/// middleware that requires the user to be authenticated
pub async fn required_admin(
    Extension(context): Extension<UserContext>,
    request: Request,
    next: Next,
) -> impl IntoResponse {
    if !context.is_admin {
        return Redirect::to("/").into_response();
    }

    next.run(request).await
}

+-----------------------+
|       Requests        |
+-----------------------+
           |
           v
+-----------------------+
|      Layer Three      |
|  +-----------------+  |
|  |    Layer Two    |  |
|  |  +-----------+  |  |
|  |  | Layer One |  |  |
|  |  |   +---+   |  |  |
|  |  |   | H |   |  |  |
|  |  |   | a |   |  |  |
|  |  |   | n |   |  |  |
|  |  |   | d |   |  |  |
|  |  |   | l |   |  |  |
|  |  |   | e |   |  |  |
|  |  |   | r |   |  |  |
|  |  |   +---+   |  |  |
|  |  +-----------+  |  |
|  +-----------------+  |
+-----------------------+
           |
           v
+-----------------------+
|      Responses        |
+-----------------------+

let app = Router::new()
    .route("/admin", get(admin::get))
    // only admins can access the routes above
    .layer(
        middleware::from_fn_with_state(state.clone(), required_admin)
    )
    .route("/profile", get(profile::get))
    // routes above will need to be authenticated
    .layer(
        middleware::from_fn_with_state(state.clone(), required_auth)
    )
    .route("/", get(home))
    // most external layer, will provide
    // `Extension<UserContext>` to all the routes above
    .layer(
        middleware::from_fn_with_state(state.clone(), base)
    );

let admin = Router::new()
    .route("/admin", get(handler))
    .layer(
        middleware::from_fn_with_state(state.clone(), required_admin)
    );

let protected = Router::new()
    .route("/profile")
    .layer(
        middleware::from_fn_with_state(state.clone(), required_auth)
    );

let public = Router::new()
    .route("/");

let app = Router::new()
    .merge(public)
    .merge(protected)
    .merge(admin);
    .layer(
        middleware::from_fn_with_state(state.clone(), base)
    )

GET /v1/availability?sport_id=PADEL&start_max=2025-03-06T23:59:59&start_min=2025-03-06T00:00:00&tenant_id=2ab75436-9bb0-4e9c-9a6f-b12931a9ca4a
Host: api.playtomic.io
Content-Type: application/json
X-Datadog-Parent-Id: ********
Tracestate: ********
X-Datadog-Sampling-Priority: 0
Authorization: Bearer *******
Accept: */*
X-Requested-With: com.playtomic.app 6.13.0
X-Datadog-Trace-Id: ********
Accept-Language: en-US,en;q=0.9
Accept-Encoding: gzip, deflate, br
User-Agent: iOS 18.3.1
X-Datadog-Tags: _dd.p.tid=67c4561000000000
X-Datadog-Origin: rum
Traceparent: ********
Connection: keep-alive

GET /v1/availability?sport_id=PADEL&start_max=2025-03-06T23:59:59&start_min=2025-03-06T00:00:00&tenant_id=2ab75436-9bb0-4e9c-9a6f-b12931a9ca4a
Host: api.playtomic.io
Content-Type: application/json
Authorization: Bearer *******
X-Requested-With: com.playtomic.app 6.13.0
User-Agent: iOS 18.3.1

>>>

HTTP/1.1 200 OK
Content-Type: application/json
Transfer-Encoding: chunked
Connection: close
Date: Mon, 03 Mar 2025 21:38:46 GMT
Vary: Origin, Access-Control-Request-Method, Access-Control-Request-Headers
X-Content-Type-Options: nosniff
Expires: 0
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
X-XSS-Protection: 1; mode=block
Pragma: no-cache
Timing-Allow-Origin: *
X-Frame-Options: DENY
X-Cache: Miss from cloudfront
Via: 1.1 2eadda0e57cd7e495ec3550f05424d3e.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: LHR50-P5
X-Amz-Cf-Id: h5udBjkJjJJyPBavztnnhDXbsS1E-7VesGxqmH7riMWhv225ShTZqg==

[
  {
    "resource_id": "021872eb-b49b-47f4-a66e-ad19173a7a75",
    "start_date": "2025-03-06",
    "slots": [
      {
        "start_time": "09:30:00",
        "duration": 90,
        "price": "72 GBP"
      },
      {
        "start_time": "16:30:00",
        "duration": 60,
        "price": "52 GBP"
      }
    ]
  },
  {
    "resource_id": "b983547f-93c7-489d-9475-52f269b1c39a",
    "start_date": "2025-03-06",
    "slots": [
      {
        "start_time": "09:30:00",
        "duration": 90,
        "price": "72 GBP"
      },
      {
        "start_time": "16:30:00",
        "duration": 60,
        "price": "52 GBP"
      }
    ]
  },
  {
    "resource_id": "3df036e3-7dba-4c39-b966-ab088edaade4",
    "start_date": "2025-03-06",
    "slots": [
      {
        "start_time": "09:30:00",
        "duration": 60,
        "price": "48 GBP"
      },
      {
        "start_time": "10:30:00",
        "duration": 60,
        "price": "48 GBP"
      },
      {
        "start_time": "13:30:00",
        "duration": 90,
        "price": "72 GBP"
      }
    ]
  }
]

GET /v1/availability?sport_id=PADEL&start_max=2025-03-06T23:59:59&start_min=2025-03-06T00:00:00&tenant_id=2ab75436-9bb0-4e9c-9a6f-b12931a9ca4a
Host: api.playtomic.io
Content-Type: application/json
X-Requested-With: com.playtomic.app 6.13.0
User-Agent: iOS 18.3.1

>>>

HTTP/1.1 200 OK
Content-Type: application/json
...

GET /v1/availability?sport_id=PADEL&start_max=2025-04-06T23:59:59&start_min=2025-03-06T00:00:00&tenant_id=2ab75436-9bb0-4e9c-9a6f-b12931a9ca4a
Host: api.playtomic.io
Content-Type: application/json
X-Requested-With: com.playtomic.app 6.13.0
User-Agent: iOS 18.3.1

>>>

HTTP/1.1 400 Bad Request
...
{
  "localized_message": "Not allowed to request more than 25h",
  "status": "INCORRECT_PARAMETERS"
}

// Slot represents a single availability slot
type Slot struct {
	StartTime string `json:"start_time"` // Start time of the slot (e.g., "09:30:00")
	Duration  int    `json:"duration"`   // Duration of the slot in minutes
	Price     string `json:"price"`      // Price of the slot (e.g., "48 GBP")
}

// AvailabilityResponse represents the entire JSON response
type AvailabilityResponse struct {
	ResourceID string `json:"resource_id"` // Resource ID (e.g., "3df036e3-7dba-4c39-b966-ab088edaade4")
	StartDate  string `json:"start_date"`  // Start date of the availability (e.g., "2025-03-06")
	Slots      []Slot `json:"slots"`       // List of available slots
}

// getNextWeekends returns the next two Saturdays and Sundays from today
func getNextWeekends() []time.Time {
	today := time.Now()
	var weekends []time.Time

	// Find the next Saturday and Sunday
	daysUntilSaturday := (time.Saturday - today.Weekday() + 7) % 7
	nextSaturday := today.AddDate(0, 0, int(daysUntilSaturday))
	nextSunday := nextSaturday.AddDate(0, 0, 1)

	// Add the next two weekends
	weekends = append(weekends, nextSaturday, nextSunday)
	weekends = append(weekends, nextSaturday.AddDate(0, 0, 7), nextSunday.AddDate(0, 0, 7))

	return weekends
}

// buildGetRequest builds a GET request for the given target date
func buildGetRequest(targetDate time.Time) (*http.Request, error) {
	// Base URL
	baseURL := "https://api.playtomic.io/v1/availability"

	// Derive start and end times from the target date
	startDate := time.Date(targetDate.Year(), targetDate.Month(), targetDate.Day(), 0, 0, 0, 0, targetDate.Location())
	endDate := time.Date(targetDate.Year(), targetDate.Month(), targetDate.Day(), 23, 59, 59, 0, targetDate.Location())

	// Query parameters
	params := url.Values{}
	params.Add("sport_id", "PADEL")
	params.Add("start_min", startDate.Format("2006-01-02T15:04:05"))
	params.Add("start_max", endDate.Format("2006-01-02T15:04:05"))
	params.Add("tenant_id", "2ab75436-9bb0-4e9c-9a6f-b12931a9ca4a")

	// Construct the full URL with query parameters
	fullURL := fmt.Sprintf("%s?%s", baseURL, params.Encode())

	// Create the GET request
	req, err := http.NewRequest("GET", fullURL, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create request: %w", err)
	}

	return req, nil
}

// fetchAvailability fetches the availability for the given target date
func fetchAvailability(targetDate time.Time) ([]AvailabilityResponse, error) {
	// Build the GET request
	req, err := buildGetRequest(targetDate)
	if err != nil {
		return nil, fmt.Errorf("error building request: %w", err)
	}

	// Make the HTTP request
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error making request: %w", err)
	}
	defer resp.Body.Close()

	// Read the response body
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("error reading response body: %w", err)
	}

	// Parse the JSON response into a slice of AvailabilityResponse
	var availability []AvailabilityResponse
	err = json.Unmarshal(body, &availability)
	if err != nil {
		return nil, fmt.Errorf("error unmarshalling JSON: %w", err)
	}

	return availability, nil
}

func main() {
	// Get the next two Saturdays and Sundays
	weekends := getNextWeekends()

	// Fetch availability for each date
	availabilityByDate := make(map[string][]Slot)
	for _, targetDate := range weekends {
		fmt.Printf("Fetching availability for date: %s\n", targetDate.Format("2006-01-02"))

		// Fetch availability
		availabilities, err := fetchAvailability(targetDate)
		if err != nil {
			fmt.Printf("Error fetching availability: %v\n", err)
			continue
		}

		// Process each availability response
		for _, availability := range availabilities {
			// Append slots to the date key
			availabilityByDate[availability.StartDate] = append(availabilityByDate[availability.StartDate], availability.Slots...)
		}
	}

    fmt.Println(prettyPrintTable(availabilityByDate))
}

$ go run main.go
DATE         START TIME  DURATION
2025-03-08   19:00:00       60
2025-03-09   20:00:00       60

// computeHash computes a SHA-256 hash of the availability data
func computeHash(data map[string][]Slot) string {
	jsonData, err := json.Marshal(data)
	if err != nil {
		return ""
	}
	hash := sha256.Sum256(jsonData)
	return hex.EncodeToString(hash[:])
}

// notify sends an email notification using Gmail using App passwords
func notify(message string) {
	// Gmail account credentials
	from := "my-supersecret-email@youwillneverknow.com"
	password := os.Getenv("SMTP_PWD")

	// List of recipients
	subscribers := os.Getenv("SUBSCRIBERS")
	var to []string

	err := json.Unmarshal([]byte(subscribers), &to)
	if err != nil {
		panic("cannot parse emails")
	}

	// SMTP server configuration
	smtpHost := "smtp.gmail.com"
	smtpPort := "587"

	// Email content
	subject := "Playtomic Update"
	body := fmt.Sprintf("The availability table has changed:\n\n%s", message)

	// Construct the email message
	msg := fmt.Sprintf("From: %s\nTo: %s\nSubject: %s\n\n%s",
		from, strings.Join(to, ","), subject, body)

	// Authenticate and send the email
	auth := smtp.PlainAuth("", from, password, smtpHost)
	err = smtp.SendMail(smtpHost+":"+smtpPort, auth, from, to, []byte(msg))
	if err != nil {
		fmt.Printf("Error sending email: %v\n", err)
	} else {
		fmt.Println("Email notification sent successfully!")
	}
}

func main() {
	// Get the next two Saturdays and Sundays
	weekends := getNextWeekends()

	// Fetch availability for each date
	availabilityByDate := make(map[string][]Slot)
	for _, targetDate := range weekends {
		fmt.Printf("Fetching availability for date: %s\n", targetDate.Format("2006-01-02"))

		// Fetch availability
		availabilities, err := fetchAvailability(targetDate)
		if err != nil {
			fmt.Printf("Error fetching availability: %v\n", err)
			continue
		}

		// Process each availability response
		for _, availability := range availabilities {
			// Append slots to the date key
			availabilityByDate[availability.StartDate] = append(availabilityByDate[availability.StartDate], availability.Slots...)
		}
	}

	// Compute the hash of the current availability data
	currentHash := computeHash(availabilityByDate)

	// Read the previous hash from a file (if it exists)
	var previousHash string
	hashFile := "availability_hash.txt"
	if _, err := os.Stat(hashFile); err == nil {
		hashBytes, err := os.ReadFile(hashFile)
		if err != nil {
			fmt.Printf("Error reading hash file: %v\n", err)
		} else {
			previousHash = string(hashBytes)
		}
	}

	// Compare hashes to detect changes
	if currentHash != previousHash {
		// Write the new hash to the file
		err := os.WriteFile(hashFile, []byte(currentHash), 0644)
		if err != nil {
			fmt.Printf("Error writing hash file: %v\n", err)
		}

		// Write the table to a file
		outputFile := "availability_table.txt"
		err = writeTableToFile(outputFile, availabilityByDate)
		if err != nil {
			fmt.Printf("Error writing table to file: %v\n", err)
		} else {
			fmt.Printf("Table written to %s\n", outputFile)
		}

		// Send a notification
		notify(prettyPrintTable(availabilityByDate))
	} else {
		fmt.Println("No changes detected in the availability table.")
	}
}

$ SUBSCRIBERS="[\"my-supersecret-email@youwillneverknow.com\"]" SMTP_PWD="secret" go run main.go

name: Run Availability Checker

on:
  schedule:
    # Run every 10 minutes
    - cron: '*/10 * * * *'
  workflow_dispatch: # Allow manual triggering

jobs:
  check-availability:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Set up Go
        uses: actions/setup-go@v4
        with:
          go-version: '1.24'

      # We can leverage the runner's cache to store the hash of the availability table
      - name: Restore hash cache
        id: cache-hash
        uses: actions/cache@v3
        with:
          path: availability_hash.txt
          key: availability-hash

      # Run the Go program
      - name: Run Go program
        env:
          SUBSCRIBERS: ${{ secrets.SUBSCRIBERS }}
          SMTP_PWD: ${{ secrets.SMTP_PWD }}
        run: |
          echo ${{ env.SUBSCRIBERS }}
          go run main.go

      # Save the hash file to cache
      - name: Save hash cache
        if: steps.cache-hash.outputs.cache-hit != 'true'
        uses: actions/cache@v3
        with:
          path: availability_hash.txt
          key: availability-hash

#[cfg(test)]
pub async fn test_db() -> EnvelopeDb {
    let pool = sqlx::sqlite::SqlitePoolOptions::new()
        .connect(":memory:")
        .await
        .expect("cannot connect to db");

    // Run migrations
    sqlx::migrate!("./migrations")
        .run(&pool)
        .await?;

    // Connection wrapper
    EnvelopeDb::with(pool)
}

version: "3.8"

services:
  postgres:
    image: postgres:latest
    restart: always
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: 1234
      POSTGRES_DB: postgres

#[cfg(test)]
mod tests {
    use sqlx::postgres::PgPoolOptions;
    use sqlx::PgPool;

    use super::model::UserRow;

    pub async fn test_db() -> Result<(PgPool, i64), sqlx::Error> {
        let db_url = "postgres://postgres:1234@localhost:5432/postgres";

        let pool = PgPoolOptions::new()
            .max_connections(1)
            .acquire_timeout(Duration::from_secs(3))
            .connect(&db_url)
            .await?;

        sqlx::migrate!("./migrations")
            .run(&pool)
            .await?;

        let id: i64 = sqlx::query_as(
            r"INSERT INTO users(id, name, lastname, email)
            VALUES (
                0,
                'testname',
                'testlastname',
                'test@example.com'
            )
            RETURNING id",
        )
        .fetch_one(&pool)
        .await?;

        Ok((pool, id))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_user_exists() {
        let (pool, _) = test_db().await.unwrap();
        assert!(
            user_exists(&pool, "test@example.com").await.unwrap(),
            "user should exist"
        );
        assert!(
            !user_exists(&pool, "another@example.com").await.unwrap(),
            "this user should not exist"
        );
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_user_exists() {
        let (pool, _) = test_db().await.unwrap();
        assert!(
            user_exists(&pool, "test@example.com").await.unwrap(),
            "user should exist"
        );
        assert!(
            !user_exists(&pool, "another@example.com").await.unwrap(),
            "this user should not exist"
        );
    }

    #[tokio::test]
    async fn test_get_user_id() {
        let (pool, _) = test_db().await.unwrap();
        assert_eq!(
            get_user_id(&pool, "test@example.com").await.unwrap(),
            0,
            "test user should have id = 0"
        );
    }
}

#[cfg(test)]
mod tests {
    use sqlx::postgres::PgPoolOptions;
    use sqlx::PgPool;

    use super::model::UserRow;

    pub async fn test_db() -> Result<(PgPool, i64), sqlx::Error> {
        let db_url = "postgres://postgres:1234@localhost:5432/postgres";

        let pool = PgPoolOptions::new()
            .max_connections(1)
            .acquire_timeout(Duration::from_secs(3))
            .connect(&db_url)
            .await?;

        sqlx::migrate!("./migrations")
            .run(&pool)
            .await?;

        // truncate everything that's left in the database
        sqlx::query("TRUNCATE TABLE users")
            .execute(&pool)
            .await?;

        let id: i64 = sqlx::query_as(
            r"INSERT INTO users(id, name, lastname, email)
            VALUES (
                0,
                'testname',
                'testlastname',
                'test@example.com',
            )
            RETURNING id",
        )
        .fetch_one(&pool)
        .await?;

        Ok((pool, id))
    }
}

#[cfg(test)]
mod tests {
    use sqlx::postgres::{PgPoolOptions, PgConnection};
    use sqlx::{Connection, Executor, PgPool};
    use uuid::Uuid;

    pub async fn test_db() -> Result<(PgPool, i64), sqlx::Error> {
        // Generate a unique database name
        let db_base = "postgres://postgres:1234@localhost:5432";
        let db_name = Uuid::new_v4().to_string();
        let connection_string = format!("{db_base}/{db_name}");

        // Connect to the default `postgres` database to create a new database
        let mut connection = PgConnection::connect(db_base)
            .await?;

        // create unique logical database
        connection
            .execute(format!(r#"CREATE DATABASE "{}";"#, db_name).as_str())
            .await?;

        // Connect to the new database and run migrations
        let pool = PgPool::connect(&connection_string).await?;

        sqlx::migrate!("./migrations")
            .run(&pool)
            .await?;

        // Insert a test user and return the pool and database name
        let id: i64 = sqlx::query_as(
            r"INSERT INTO users(id, name, lastname, email)
            VALUES (
                0,
                'testname',
                'testlastname',
                'test@example.com'
            )
            RETURNING id",
        )
        .fetch_one(&pool)
        .await?;

        Ok((pool, Uuid::parse_str(&db_name).unwrap()))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // note that the function now takes a PgPool as an argument
    #[sqlx::test] // by default this will also apply the migrations!
    async fn test_user_exists(pool: PgPool) {
        assert!(user_exists(&pool, "test@example.com").await.unwrap());
        assert!(!user_exists(&pool, "another@example.com").await.unwrap())
    }

    // if you want you can specify a different migrations directory
    #[sqlx::test(migrations = "./someothermigrations")]
    async fn test_get_user_id(pool: PgPool) {
        assert_eq!(
            get_user_id(&pool, "test@example.com").await.unwrap(),
            0,
            "test user should have id = 0"
        );
    }
}

struct Search {
    id: i64,
    username: Option<String>,
    min_age: Option<i8>,
    max_age: Option<i8>,
}

fn search_query(search: Search) -> String {
    let mut query = QueryBuilder::new("SELECT * from users where id = ");
    query.push_bind(search.id);

    if let Some(username) = search.username {
        query.push(" AND username = ");
        query.push_bind(username);
    }

    if let Some(min_age) = search.min_age {
        query.push(" AND age > ");
        query.push_bind(min_age);
    }

    if let Some(max_age) = search.max_age {
        query.push(" AND age < ");
        query.push_bind(max_age);
    }

    query.build().sql().into()
}

fn search_query(search: Search) -> String {
    let mut query = QueryBuilder::new("SELECT * from users");

    if let Some(id) = search.id {
        query.push(" AND id = ");
        query.push_bind(search.id);
    }

    if let Some(username) = search.username {
        query.push(" AND username = ");
        query.push_bind(username);
    }

    if let Some(min_age) = search.min_age {
        query.push(" AND age > ");
        query.push_bind(min_age);
    }

    if let Some(max_age) = search.max_age {
        query.push(" AND age < ");
        query.push_bind(max_age);
    }

    query.build().sql().into()
}

fn search_query(search: Search) -> String {
    let mut query = QueryBuilder::new("SELECT * from users WHERE 1 = 1");

    if let Some(id) = search.id {
        query.push(" AND id = ");
        query.push_bind(search.id);
    }

    if let Some(username) = search.username {
        query.push(" AND username = ");
        query.push_bind(username);
    }

    if let Some(min_age) = search.min_age {
        query.push(" AND age > ");
        query.push_bind(min_age);
    }

    if let Some(max_age) = search.max_age {
        query.push(" AND age < ");
        query.push_bind(max_age);
    }

    query.build().sql().into()
}

async fn search_query(search: Search) -> String {
    let query = r"
    SELECT * from users
    WHERE id = $1
        AND ($2 IS NULL OR username = $2)
        AND ($3 IS NULL or age > $3)
        AND ($4 IS NULL or age < $4)
    ".into()
}

async fn search_query(search: Search, pg: &PgPool) {
    let query = sqlx::query(r"
    SELECT * FROM users
    WHERE id = $1
        AND ($2 IS NULL OR username = $2)
        AND ($3 IS NULL OR age > $3)
        AND ($4 IS NULL OR age < $4)
    ")
    .bind(search.id)
    .bind(search.username)
    .bind(search.min_age)
    .bind(search.max_age)
    .fetch_all(pg)
    .await
    .expect("failed querying users");
}

async fn filter(nicknames: Option<Vec<i64>>, pg: &PgPool) {
    sqlx::query(
        r"SELECT *
        FROM users
        WHERE 1 = 1
            AND ($1 IS NULL
                 OR CARDINALITY($1::integer[]) = 0
                 OR nickname = $1
            )"
    )
    .bind(nicknames)
    .fetch_all(pg)
    .await
    .unwrap();
}

async fn filter(ids: String, pg: &PgPool) {
    sqlx::query(
        r"SELECT *
        FROM users
        WHERE
            id IN (ARRAY_REMOVE(STRING_TO_ARRAY($1, ','), ''))"
    )
    .bind(ids)
    .fetch_all(pg)
    .await
    .unwrap();
}

struct Filter {
    /// current page
    pub page: Option<i64>,
    /// number of items per page
    pub limit_per_page: Option<i64>
}

impl Filter {
    fn validate(&self) -> Result<(), String> {
        match self.page {
            Some(page) if page < 0 => {
                return Err("page can't be negative")
            }
            _ => {}
        }

        match self.limit_per_page {
            Some(limit) if limit < 10 && limit > 100 {
                return Err("limit must be between 10 and 100")
            }
            _ => {}
        }

        Ok(())
    }
}

async fn filter(filter: Filter, pg: &PgPool) {
    sqlx::query(
    r"SELECT *
    FROM users
    LIMIT
        CASE WHEN $2 > 0 THEN $2 END
    OFFSET
        CASE
            WHEN $2 BETWEEN 0 AND 100 AND $1 > 0
                THEN (($1 - 1) * $2)
            ELSE
                50
        END"
    )
    // if page is not provided, fallback to 0
    .bind(filter.page.unwrap_or(0))
    // if limit is not provided, fallback to 50
    .bind(filter.limit_per_page.unwrap_or(50))
    .fetch_all(pg)
    .await
    .unwrap();
}

struct UpdateForm {
    id: Uuid
    name: Option<String>
    surname: Option<String>
}

async fn update_user(UpdateForm { id, name, surname }: UpdateForm, pg: &PgPool) {
    sqlx::query(
        r"UPDATE user
        SET name = COALESCE($2, name),
            surname = COALESCE($3, surname)
        WHERE id = $1"
    )
    .bind(id)
    .bind(name)
    .bind(surname)
    .fetch_one(pg)
    .await
    .unwrap();
}

/// This is a strongly typed version of your `environments` database table
/// with its columns
#[derive(Debug, sea_query::Iden)]
pub enum Environments {
    Table,
    Env,
    Key,
    Value,
    CreatedAt,
}

/// inserts `key` and `value` to environment `env`
pub async fn insert(&self, env: &str, key: &str, var: &str) -> io::Result<()> {
    let (sql, values) = Query::insert()
        .into_table(Environments::Table)
        .columns([Environments::Env, Environments::Key, Environments::Value])
        .values([env.into(), Func::upper(key).into(), var.into()])
        .unwrap()
        .build_sqlx(SqliteQueryBuilder);

    sqlx::query_with(&sql, values)
        .execute(&self.db)
        .await
        .map_err(|e| std_err!("db error: {}", e))?;

    Ok(())
}

{% block content %}
    <h1>Hello, {{email}}</h1>
    {% if let Some(name) = name %}
        <h1>Hello, {{name}}</h1>
    {% else %}
    {% endif %}
{% endblock %}

use askama::Template;

#[derive(Template)]
#[template(path="home.jinja")]
pub struct HomeTemplate {
    // some users might not have one upon sign-up
    name: Option<String>,
    // email is required
    email: String,
}

{% block content %}
    {% if let Some(name) = name %}
        <h1>Hello, {{name}}</h1>
    {% else %}
        <h1>Hello, {{email}}</h1>
    {% endif %}
{% endblock %}

#[derive(Debug, PartialEq, Eq)]
pub enum LinkNote {
    /// note is a valid HN link
    HN(String),
    /// note is a valid link
    Link(String),
    /// general note
    General(String),
}

{% if let Some(note) = link.note %}
    {% match note %}
        {% when LinkNote::HN with (url) %}
            <a href="{{url}}"><p>hn</p></a>
        {% when LinkNote::Link with (url) %}
            <a href="{{url}}"><p>link</p></a>
        {% else %}
            <p>note</p>
    {% endmatch %}
{% endif %}

pub fn spawn_with(data: &[u8]) -> Result<Vec<u8>> {
    let editor = editor_cmd();
    let pb = env::current_dir()?.join(".ENVELOPE_EDITMSG");

    let mut file = OpenOptions::new()
        .write(true)
        .read(true)
        .create(true)
        .truncate(true)
        .open(&pb)?;

    file.write_all(data)
	    .map_err(|e| std_err!("error writing data to file: {}", e))?;
    file.write(b"\n\n# Comment variables to remove them")?;

    let args = &[pb.to_str().unwrap()];
    let cmd = ChildProcess::new(&editor, args, &[]);

    // this command is blocking, so it's going to wait
    // for the child process to exit before proceeding
    cmd.run_shell_command()
        .map_err(|e| std_err!("error running child process: {}", e))?;

    let mut buf = Vec::new();
    file.read_to_end(&mut buf).unwrap();

    std::fs::remove_file(pb)?;
    Ok(buf)
}

pub fn spawn_with(data: &[u8]) -> Result<Vec<u8>> {
    // ...

    let mut file = OpenOptions::new()
        .write(true)
        .read(true)
        .create(true)
        .truncate(true)
        .open(&pb)?;

    println!("{:?}", file);

    // ...

    Ok(buf)
}

File { fd: 7, path: "/home/matt/Developer/envelope/.ENVELOPE_EDITMSG", read: true, write: true }

int open(const char *pathname, int flags, mode_t mode);

ssize_t read(int fd, void *buf, size_t count);

ssize_t write(int fd, const void *buf, size_t count);

$ strace -e trace=open,openat,write,read,close,lseek target/debug/run_function

...
openat(AT_FDCWD, "/tmp/ENVELOPE_EDITMSG", O_RDWR|O_CREAT|O_TRUNC|O_CLOEXEC, 0666) = 7
write(7, "\n\n# Comment variables to remove "..., 36) = 36
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=28814, si_uid=1000, si_status=0, si_utime=1, si_stime=0} ---
lseek(7, 0, SEEK_CUR)                   = 36
read(7, "\n", 8)                        = 1
read(7, "", 7)                          = 0
close(7)                                = 0
...

off_t lseek(int fd, off_t offset, int whence);

pub fn spawn_with(data: &[u8]) -> Result<Vec<u8>> {
    // ...

    cmd.run_shell_command()
        .map_err(|e| std_err!("error running child process: {}", e))?;

    // Reposition the offset at the start of the file
    file.seek(SeekFrom::Start(0)).unwrap();

    let mut buf = Vec::new();
    file.read_to_end(&mut buf).unwrap();

    // ...
}

pub fn spawn_with(data: &[u8]) -> Result<Vec<u8>> {
    // ...

    cmd.run_shell_command()
        .map_err(|e| std_err!("error running child process: {}", e))?;

    let mut file = OpenOptions::new()
        .read(true)
        .open(&pb)?;

    let mut buf = Vec::new();
    file.read_to_end(&mut buf).unwrap();

    // ...
}