Cargo dist! Here’s a nice workflow you can use : https://blog.orhun.dev/automated-rust-releases/

I prefer main simply because it faster to type. I propose main branches be renamed to “m”

It’s like vim but with lsp support out of the box and the keybindings make sense

Note that there are many security concerns with this, notably the fact that there is no input validation on the id path segment which means you can get the content of any file (e.g. http://localhost:3000/src%2Fmain.rs). It’s also very easy to scrape the content of all the files because the IDs are easy to predict. When the server reboots, you will overwrite previously written files because the counter starts back at zero. Using a UUID would probably mostly solve both these issues.

Here’s a slightly more idiomatic version:

use std::{
    fs,
    sync::atomic::{AtomicUsize, Ordering},
};

use axum::{extract::Path, http::StatusCode, routing::get, routing::post, Router};

const MAX_FILE_SIZE: usize = 1024 * 1024 * 10;
static FILE_COUNT: AtomicUsize = AtomicUsize::new(0);

async fn handle(Path(id): Path<String>) -> (StatusCode, String) {
    match fs::read_to_string(id) {
        Ok(content) => (StatusCode::OK, content),
        Err(e) => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
    }
}

async fn submit_handle(bytes: String) -> (StatusCode, String) {
    dbg!(&bytes);
    if bytes.len() > MAX_FILE_SIZE {
        // Don't store the file if it exceeds max size
        return (
            StatusCode::BAD_REQUEST,
            "ERROR: max size exceeded".to_string(),
        );
    }
    let path = FILE_COUNT.fetch_add(1, Ordering::SeqCst);
    if let Err(e) = fs::write(path.to_string(), bytes) {
        return (StatusCode::INTERNAL_SERVER_ERROR, e.to_string());
    }
    (StatusCode::CREATED, format!("http://localhost:3000/%7Bpath%7D"))
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/", get(|| async { "Paste something in pastebin! use curl -X POST http://localhost:3000/submit -d 'this is some data'" }))
        .route("/{id}", get(handle))
        .route("/submit", post(submit_handle));

    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .unwrap();
    axum::serve(listener, app).await.unwrap();
}

Note that there are no unwrap in the handlers which would absolutely want to avoid (it would crash your server). The endpoints now also return the correct HTTP code for each case. Some minor changes regarding creating the string values (use of format! and to_string() on string slices). Lemmy messes with the curly braces in the format! macro, there should be curly braces around the path variable name.

Fetch add will return the old value before updating it so you don’t need the “.load” call above it!

I will probably post an improved version (if you like) but the main point is that you do not need the atomic to be mut, and so you don’t need unsafe. Have a look at https://doc.rust-lang.org/std/sync/atomic/struct.AtomicUsize.html#method.fetch_add too

Did you check out the Examples ?

That was my point exactly :) glad you got it

Literally copy pasted from a random repo as an illustration

OP: “typescript is easy and rust is ugly”

Typescript :

export type PayloadActionCreator<
  P = void,
  T extends string = string,
  PA extends PrepareAction<P> | void = void
> = IfPrepareActionMethodProvided<
  PA,
  _ActionCreatorWithPreparedPayload<PA, T>,
  // else
  IsAny<
    P,
    ActionCreatorWithPayload<any, T>,
    IsUnknownOrNonInferrable<
      P,
      ActionCreatorWithNonInferrablePayload<T>,
      // else
      IfVoid<
        P,
        ActionCreatorWithoutPayload<T>,
        // else
        IfMaybeUndefined<
          P,
          ActionCreatorWithOptionalPayload<P, T>,
          // else
          ActionCreatorWithPayload<P, T>
        >
      >
    >
  >
>

Check out Zen Browser

Kagi and Zen works for me

Started using Zen browser recently and it’s not bad! Basically Firefox but more stylish and more privacy. It syncs with my Mozilla/Firefox account so on mobile I just use Firefox.

And install python and install those dependencies before you can even run the thing

Thanks for all the suggestions! I switched to qbittorrent and it works nicely for now. The web ui is fine for the little I use it so all good! I’ll report if something starts failing again which would indicate another issue with me setup.

Seems to work very nicely and it’s much more responsive than transmission. Great, thanks!

I’m not set on transmission, I tried qbittorrent just now and it seems to work for me. But thanks! I anyway use a separate container and network for vpn.

I’ll give it a go! Is there a GUI for it? I like to sometimes check the progress live and transmission provides that out of the box.

Started contributing to https://github.com/mario-eth/soldeer , mainly refactoring but also helping with new features.