Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/matze/wastebin

wastebin is a pastebin 📝
https://github.com/matze/wastebin

axum pastebin rust self-hosted sqlite

Last synced: 10 days ago
JSON representation

wastebin is a pastebin 📝

Awesome Lists containing this project

README 

        
#  wastebin



[![Rust](https://github.com/matze/wastebin/actions/workflows/rust.yml/badge.svg)](https://github.com/matze/wastebin/actions/workflows/rust.yml)



A minimal pastebin with a design shamelessly copied from

[bin](https://github.com/WantGuns/bin).






DEMO (resets every day)



## Features



* axum and sqlite3 backend storing compressed paste data

* single binary with low memory footprint

* drag 'n' drop upload

* deletion after expiration, reading or by owners

* light/dark mode according to browser settings

* highlightable line numbers

* QR code to browse a paste's URL on mobile devices

* optional encryption with argon2 hashing and ChaCha20Poly1305 encryption



## Installation



### Build from source



Install a Rust 2021 toolchain containing Rust 1.70 with

[rustup](https://rustup.rs) and run the server binary with



    $ cargo run --release



### Run pre-built binaries



You can also download pre-built, statically compiled [Linux

binaries](https://github.com/matze/wastebin/releases). After extraction run the

contained `wastebin` binary.



### Build a container image



It's possible to build a container image using Docker or Podman. Assuming you're in the root directory of repository run

```bash

$ sudo docker build -t wastebin:v2.4.3 -f Dockerfile .

```

for Docker or

```bash

$ podman build -t wastebin:v2.4.3 -f Dockerfile

```

for Podman.



To cross-compile, make sure that your container engine of choice supports it,

e.g. Docker:



```bash

$ sudo docker buildx ls

NAME/NODE     DRIVER/ENDPOINT   STATUS    BUILDKIT   PLATFORMS

default*      docker

 \_ default    \_ default       running   v0.14.1    linux/amd64, linux/amd64/v2, linux/386, linux/arm64, linux/riscv64, linux/ppc64, linux/ppc64le, linux/s390x, linux/mips64le, linux/mips64, linux/loong64, linux/arm/v7, linux/arm/v6

```



To build an arm64 image on an x86_64 host run

```bash

$ sudo docker build --platform linux/arm64 -t wastebin:v2.4.3-arm64 -f Dockerfile.arm .

```

or

```bash

$ podman build --arch=arm64 -t wastebin:v2.4.3-arm64 -f Dockerfile.arm

```



### Run a Docker image



Alternatively, you can run a pre-built Docker image pushed to `quxfoo/wastebin`.

Here is how to persist the database as `state.db` via the

`WASTEBIN_DATABASE_PATH` environment variable and a bind mount to

`/path/for/storage`:



    $ docker run -e WASTEBIN_DATABASE_PATH=/data/state.db -v /path/for/storage:/data quxfoo/wastebin:latest



**NOTE**: The image is based on scratch which means it neither comes with a

shell nor with `TMPDIR` being set. If database migrations fail with an extended

sqlite error code 6410, pass `TMPDIR` pointing to a location, sqlite can write

to.



### Run with docker-compose

```

version: '3.3'

services:

  wastebin:

    environment:

      - WASTEBIN_DATABASE_PATH=/data/state.db

    ports:

      - "8088:8088"

    volumes:

      - './data:/data'

    image: 'quxfoo/wastebin:latest'

```

Make sure the `./data` folder is writable by the user 10001.



### Run with Nix



For Nix users, a `flake.nix` is also provided. Build and execute it directly

with:



```bash

nix run 'github:matze/wastebin#wastebin'

```



Or install the provided `wastebin` package like you normally would.



## Usage



### Browser interface



When viewing a paste, you can use



* r to view the raw paste,

* n to go the index page,

* y to copy the current URL to the clipboard,

* q to display the current URL as a QR code and

* p to view the formatted paste,

* ? to view the list of keybindings.



To paste some text you can also use the ctrl+s key

combination.



### Configuration



The following environment variables can be set to configure the server and

run-time behavior:



* `WASTEBIN_ADDRESS_PORT` string that determines which address and port to bind

  a. If not set, it binds by default to `0.0.0.0:8088`.

* `WASTEBIN_BASE_URL` string that determines the base URL for the QR code

  display. If not set, the user agent's `Host` header field is used as an

  approximation.

* `WASTEBIN_CACHE_SIZE` number of rendered syntax highlight items to cache.

  Defaults to 128 and can be disabled by setting to 0.

* `WASTEBIN_DATABASE_PATH` path to the sqlite3 database file. If not set, an

  in-memory database is used.

* `WASTEBIN_HTTP_TIMEOUT` maximum number of seconds a request can be processed

  until wastebin responds with 408, by default it is set to 5 seconds.

* `WASTEBIN_MAX_BODY_SIZE` number of bytes to accept for POST requests. Defaults

  to 1 MB.

* `WASTEBIN_MAX_PASTE_EXPIRATION` maximum allowed lifetime of a paste in

  seconds. Defaults to 0 meaning unlimited.

* `WASTEBIN_PASSWORD_SALT` salt used to hash user passwords used for encrypting

  pastes.

* `WASTEBIN_SIGNING_KEY` sets the key to sign cookies. If not set, a random key

  will be generated which means cookies will become invalid after restarts and

  paste creators will not be able to delete their pastes anymore.

* `WASTEBIN_TITLE` overrides the HTML page title. Defaults to `wastebin`.

* `RUST_LOG` influences logging. Besides the typical `trace`, `debug`, `info`

  etc. keys, you can also set the `tower_http` key to some log level to get

  additional information request and response logs.



### API endpoints



POST a new paste to the `/` endpoint with the following JSON payload:



```

{

  "text": "",

  "extension": "",

  "expires": ,

  "burn_after_reading": 

}

```



After successful insertion, you will receive a JSON response with the path to

the newly created paste:



```

{"path":"/Ibv9Fa.rs"}

```



To retrieve the raw content, make a GET request on the `/:id` route and an

accept header value that does not include `text/html`. If you use a client that

is able to handle cookies you can delete the paste once again using the cookie

in the `Set-Cookie` header set during redirect after creation.



In case the paste was encrypted, pass the password via the `Wastebin-Password`

header.



### Paste from neovim



Use the [wastebin.nvim](https://github.com/matze/wastebin.nvim) plugin and paste

the current buffer or selection with `:WastePaste`.



### Paste from clipboard



We can use the API POST endpoint to paste clipboard data easily from the command

line using `xclip`, `curl` and `jq`. Define the following function in your

`.bashrc` and you are good to go:



```bash

function paste_from_clipboard() {

    local URL=$(\

        jq -n --arg t "$(xclip -selection clipboard -o)" '{text: $t}' | \

            curl -s -H 'Content-Type: application/json' --data-binary @- https://wastebin.tld | \

            jq -r '. | "https://wastebin.tld\(.path)"')



    xdg-open $URL

}

```



### Paste from stdin



To paste from stdin use the following function in your `.bashrc`:



```bash

function paste_from_stdin() {

    jq -Rns '{text: inputs}' | \

        curl  -s -H 'Content-Type: application/json' --data-binary @- https://wastebin.tld | \

        jq -r '. | "wastebin.tld\(.path)"'

}

```



It can be handy for creating pastes from logs or the output of commands, e.g.

`cat file.log | paste_from_stdin`.



## License



[MIT](./LICENSE)