The websites in question are actually on GitHub Pages and my servers are just acting as reverse proxy to resolve domain and TLS, and a look into the web server’s error.log showed that the issue in serving was that the server could no longer reach its upstream at github.io when Tailscale was active. It wasn’t a general loss of external connectivity though - IPv4 addresses still worked great, the webserver however was trying to connect to the upstream via IPv6 and this is where things failed.

I did some quick tests, pinging Google’s DNS on both IPv4 (8.8.8.8) and IPv6 (2001:4860:4860::8888) with Tailscale running, and that showed that while Tailscale was running, IPv6 connectivity just broke down completely while IPv4 continued to work:

$ sudo tailscale up && ping -c 3 8.8.8.8 && sudo tailscale down
PING 8.8.8.8 (8.8.8.8) 56(84) bytes of data.
64 bytes from 8.8.8.8: icmp_seq=1 ttl=117 time=3.98 ms
64 bytes from 8.8.8.8: icmp_seq=2 ttl=117 time=3.69 ms
64 bytes from 8.8.8.8: icmp_seq=3 ttl=117 time=3.63 ms

--- 8.8.8.8 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2002ms
rtt min/avg/max/mdev = 3.631/3.771/3.986/0.162 ms

$ sudo tailscale up && ping -c 3 2001:4860:4860::8888 && sudo tailscale down
PING 2001:4860:4860::8888(2001:4860:4860::8888) 56 data bytes

--- 2001:4860:4860::8888 ping statistics ---
3 packets transmitted, 0 received, 100% packet loss, time 2051ms

As a next step, I checked the route that would be taken for resolving 2001:4860:4860::8888 with and without Tailscale:

$ ip route get 2001:4860:4860::8888
2001:4860:4860::8888 from :: via fe80::1 dev eth0 src aaaa:bbbb:cccc:dddd::1 metric 1024 pref medium

$ sudo tailscale up && ip route get 2001:4860:4860::8888 && sudo tailscale down
2001:4860:4860::8888 from :: via fe80::1 dev eth0 src fd7a:115c:a1e0::aaaa:bbbb metric 1024 pref medium

So, the issue was that for some reason, while Tailscale was running the system decided to use Tailscale’s internal IPv6 fd7a:115c:a1e0::aaaa:bbbb set on tailscale0 as the source IP but send the packet through the default route and eth0, and that didn’t work. It basically hijacked the IPv6 traffic, even when the Tailnet wasn’t even involved.

The routes looked fine to me and some buddies I asked also didn’t spot anything amiss:

$ ip -6 rule show
0:      from all lookup local
5210:   from all fwmark 0x80000/0xff0000 lookup main
5230:   from all fwmark 0x80000/0xff0000 lookup default
5250:   from all fwmark 0x80000/0xff0000 unreachable
5270:   from all lookup 52
32766:  from all lookup main

$ ip -6 route show table local
local ::1 dev lo proto kernel metric 0 pref medium
local aaaa:bbbb:cccc:dddd::1 dev eth0 proto kernel metric 0 pref medium
local fd7a:115c:a1e0::aaaa:bbbb dev tailscale0 proto kernel metric 0 pref medium
local fe80::5fdc:58a7:1a93:da5a dev tailscale0 proto kernel metric 0 pref medium
local fe80::9400:ff:fe0d:61a1 dev eth0 proto kernel metric 0 pref medium
multicast ff00::/8 dev eth0 proto kernel metric 256 pref medium
multicast ff00::/8 dev tailscale0 proto kernel metric 256 pref medium

$ ip -6 route show table 52
fd7a:115c:a1e0::53 dev tailscale0 metric 1024 pref medium
fd7a:115c:a1e0::/48 dev tailscale0 metric 1024 pref medium

$ ip -6 route show table main
aaaa:bbbb:cccc:dddd::/64 dev eth0 proto kernel metric 256 pref medium
fd7a:115c:a1e0::aaaa:bbbb dev tailscale0 proto kernel metric 256 pref medium
fe80::/64 dev eth0 proto kernel metric 256 pref medium
default via fe80::1 dev eth0 metric 1024 pref medium

From what I could see, firing up Tailscale would add the following new rules to the routing table:

$ ip route show table all > ts-off.txt
$ sudo tailscale up && ip route show table all > ts-on.txt && sudo tailscale down
$ diff ts-off.txt ts-on.txt
0a1,2
> 100.a.b.c dev tailscale0 table 52
> 100.100.100.100 dev tailscale0 table 52
3a6
> local 100.x.y.z dev tailscale0 table local proto kernel scope host src 100.x.y.z
12a16,17
> fd7a:115c:a1e0::53 dev tailscale0 table 52 metric 1024 pref medium
> fd7a:115c:a1e0::/48 dev tailscale0 table 52 metric 1024 pref medium
13a19
> fd7a:115c:a1e0::aaaa:bbbb dev tailscale0 proto kernel metric 256 pref medium
17a24
> local fd7a:115c:a1e0::aaaa:bbbb dev tailscale0 table local proto kernel metric 0 pref medium

I still have not figured out what is actually going on there, and a reproduction on a fresh server so far also wasn’t successful. The problem is that packets are being sent with the wrong source IPv6, but that’s just a symptom of the underlying cause.

Thankfully, my buddy Jub came up with the workaround to change the default route to use a fixed IPv6 source address - the correct one - and that solved the issue (by fixing the symptom):

ip -6 route replace default via fe80::1 dev eth0 src aaaa:bbbb:cccc:dddd::1

I put that on a new post-up line into the network setup in /etc/network/interface.d/50-cloud-init.cfg

auto eth0:0
iface eth0:0 inet6 static
    address aaaa:bbbb:cccc:dddd::/64
    gateway fe80::1
    post-up route add -net :: netmask 0 gw fe80::1%eth0 || true
    post-up ip -6 route replace default via fe80::1 dev eth0 src aaaa:bbbb:cccc:dddd::1 || true
    pre-down route del -net :: netmask 0 gw fe80::1%eth0 || true

A reboot confirmed that this works as a workaround.

But as I mentioned, I still can’t make any sense of the underlying issue. I found one open bug report in Tailscale’s bug tracker that sounded familiar, but it didn’t fully match my situation. I also have to admit that my administration skills kinda get a bit fuzzy when it comes to full blown route analysis & debugging - so should you have any ideas at all what is actually causing this behaviour here, please get in touch on Mastodon - I’d love to see this mystery solved, but am out of my depth here 😅

I thankfully already have an instance of rest980 running in my homelab anyhow, and it is still happily chatting with the bot. And tbh, I might just block cloud access again as having everything local is better anyhow.

In any case, I wanted to disable the schedule currently set on it internally to switch to scheduling stuff from my home automation, but without the app working I wasn’t sure on how. So I went hunting through rest980’s source - as the README didn’t tell me what I was looking for - and found that I could program the weekly schedule with some easy curl magic via the /api/local/config/week endpoint.

Firing off a GET against that, this is the data structure I received:

{
  "cycle": [
    "none",
    "start",
    "start",
    "start",
    "start",
    "start",
    "none"
  ],
  "h": [
    9,
    15,
    15,
    15,
    15,
    15,
    9
  ],
  "m": [
    0,
    0,
    0,
    0,
    0,
    0,
    0
  ]
}

cycle seems to be the on/off button from Sunday at index 0 to Saturday on index 6. start schedules a cleaning run, none disables it. h is the hours on which to start each day, and m the minute.

What I wanted to do was to set all of the days to off, and this I achieved with this combined GET/POST call with some jq manipulation in the middle:

curl $REST980_URL/api/local/config/week | \
    jq '.cycle[] = "none"' | \
    curl --json @- $REST980_URL/api/local/config/week

Another problem - hopefully - solved! I’ll see tomorrow if this really disabled the schedule 😅 but I’m optimistic!

You might remember from a previous TIL that I had my Steamdeck configured to push my screenshots into a custom album on Google Photos. Obviously I had to change that now as well, but sadly couldn’t use the existing rclone-based setup for it.

My first idea was to utilize immich-go, as I have just successfully used that for the three day long import of over 50000 pictures from my Google Photos takeout into immich. But that turned out to not be the right tool here: in order to not even try to upload already existing files it will fetch an asset list from immich first, and while that really improves performance for large batch imports, it takes way too long for uploading a single new screenshot.

So instead I went with something self-built which utilizes immich’s API.

A custom upload script

The first part is this little bash script that will take a file as input, upload it to a pre-configured immich instance and also add it to a pre-defined album (which already has to exist). This lives in ~/.local/bin/immich-upload.sh:

#!/bin/bash
set -e

IMMICH_SERVER="https://immich.example.com"
IMMICH_KEY="your api key goes here"
IMMICH_ALBUM="your album id goes here"

INPUT="$1"
if [ "$INPUT" == "" ]; then
    echo "immich-upload.sh <file>"
    exit 0
fi

file_modified=$(stat -c %Y "$INPUT" | date --iso-8601=seconds)
name=$(basename "$INPUT")

# ---

echo "Uploading $INPUT to immich..."

upload=$(curl -sL --request POST "$IMMICH_SERVER/api/assets" \
    -H "Content-Type: multipart/form-data" \
    -H "Accept: application/json" \
    -H "X-API-Key: $IMMICH_KEY" \
    -F "deviceId=\"curl/steamdeck\"" \
    -F "deviceAssetId=\"$name-$file_modified\"" \
    -F "fileCreatedAt=\"$file_modified\"" \
    -F "fileModifiedAt=\"$file_modified\"" \
    -F "assetData=@\"$INPUT\"")

id=$(echo "$upload" | jq -r .id)

echo "Uploaded file, asset id is $id"

# ---

echo "Adding file to album $IMMICH_ALBUM..."

payload=$(jq -n --arg id $id '{ids:[$ARGS.named.id]}')
album=$(curl -sL --request PUT "$IMMICH_SERVER/api/albums/$IMMICH_ALBUM/assets" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -H "X-API-Key: $IMMICH_KEY" \
    -d "$payload")

echo "... done"

Reacting to new screenshots

I use watchexec to listen for changes in my custom screenshot folder (see this TIL post on how to set that up) and calling the upload script with the correct file name. I downloaded a release build of watchexec and threw it into ~/.local/bin, then created another script ~/.local/bin/sync-screenshots that takes care of setting all of the correct parameters¹:

#!/usr/bin/env bash

WATCHEXEC="${HOME}/.local/bin/watchexec"
FOLDER="${HOME}/.steam_screenshots"

${WATCHEXEC} --exts jpg,png,mp4 --fs-events create --emit-events-to environment -w $FOLDER -o queue -p -v -- '/home/deck/.local/bin/immich-upload.sh "$WATCHEXEC_COMMON_PATH/$WATCHEXEC_CREATED_PATH"'

Putting it all together

Finally, a new systemd unit in ~/.config/systemd/user/sync-screenshots.service takes care of starting this bash script and keeping it running:

[Unit]
Description=Sync Steam Screenshots

[Service]
ExecStart=%h/.local/bin/sync-screenshots
Restart=on-failure
RestartSec=5

[Install]
WantedBy=default.target

I enabled and started that:

systemctl --user enable sync-screenshots
systemctl --user start sync-screenshots

Then I took a screenshot and confirmed that the script had run:

Mar 25 15:17:03 steamdeck sync_screenshots[77135]: [Running: /home/deck/.local/bin/immich-upload.sh "$WATCHEXEC_COMMON_PATH/$WATCHEXEC_CREATED_PATH"]
Mar 25 15:17:03 steamdeck sync_screenshots[77188]: Uploading /home/deck/.steam_screenshots/7_20250325151703_1.png to immich...
Mar 25 15:17:04 steamdeck sync_screenshots[77188]: Uploaded file, asset id is 141dc605-edef-48f1-83b5-00bd9d72b13e
Mar 25 15:17:04 steamdeck sync_screenshots[77188]: Adding file to album 0ce35e68-a564-4e26-921e-c486cd9e4725...
Mar 25 15:17:05 steamdeck sync_screenshots[77188]: ... done
Mar 25 15:17:05 steamdeck sync_screenshots[77135]: [Command was successful]

And indeed, upon checking my immich instance, I was also looking at the freshly uploaded screenshot. Mission accomplished!

VirtualBox can’t operate in VMX root mode. Please disable the KVM kernel extension, recompile your kernel and reboot (VERR_VMX_IN_VMX_ROOT_MODE).

A quick web search for “fedora update virtualbox vboxisomaker” gave me this forum post and consequently this bug report, in which I found the solution: I just had to add the kernel parameter kvm.enable_virt_at_load=0 to disable KVM - which comes enabled by default since Kernel 6.12. I accomplished that with grubby:

sudo grubby --update-kernel=ALL --args="kvm.enable_virt_at_load=0"

After a reboot, VirtualBox started again.

Given how often VirtualBox breaks for me on updates, long term I think I really need to find a different solution… And yes, I also really need to upgrade to Fedora 41, I know 😉

So far the latter was always quite annoying: We have only the names of the gnomes in our influx data, and adding the location/deployment status to the graph thus meant having something like this for every single graph:

import "strings"
import "dict"

locations = [
    "Bashful": "Uptime Bar",
    "Dopey": "c3cat",
    "Grumpy": "Späti",
    "Happy": "Kidspace",
    "Hefty": "HASS Assembly",
    "Moopsy": "Chaospost",
    "Kinky": "Eventphone",
    "Nerdy": "House of Tea",
    "Sleepy": "DDOS Bar",
    "Sneezy": "Wohnzimmer"
]

from(bucket: "datagnome")
  [...]
  |> map(fn: (r) => ({r with device: r.device + " (" + dict.get(dict: locations, key: r.device, default: "?") + ")"}))

Which of course means that I had to update this locations dict for every single panel, on every single deployment, at least twice (start and end of the event).

I finally decided I had to solve this differently and just now figured out how to keep the deployment info in a JSON file on our git repo and then querying that from the graphs, instead of manually keeping the lookup data updated in more than one place:

import "strings"
import "dict"
import "http/requests"
import "experimental/json"

response = requests.get(url: "https://raw.githubusercontent.com/romses/Datenzwerg/refs/heads/main/docs/deployment.json")
data = json.parse(data: response.body)
locations = dict.fromList(pairs: data)

from(bucket: "datagnome")
  [...]
  |> map(fn: (r) => ({r with device: r.device + " (" + dict.get(dict: locations, key: r.device, default: "?") + ")"}))

So far seems to work well, and I’m very happy to be able to do this faster now (and also more easily from my phone, should I need to).

Next step: Figuring out how to use that JSON file to also keep the event box on the home page updated. But that’s for another day :)

I’m using Aseprite, and recently came across the “record for aseprite” script for it that allows taking regular snapshots of what I’m currently drawing so a timelapse can be created from that. And that works nicely, but I had to realize that the timelapse would come with transparency until I came to the background during my drawing, which looked really weird when sharing the resulting GIF.

So I looked into adding the usual transparency checkerboard background to the GIF with a quick script, and of course, ImageMagick once more to the rescue. Alas, the resulting GIF was quite large and ImageMagick’s optimization options caused glitches in the GIF. So I looked for another option to optimize the GIF and came across gifsicle.

The result is this bash script which will take a GIF and an optional background image to set, add the background (or a freshly generated checkerboard pattern of the right size) to the GIF, then compress the GIF:

#!/bin/bash

GIF=$1
BG=$2

BASE=$(basename "${GIF%.*}")
OUTPUT="$BASE.bg.gif"

if [ -f "$BG" ]; then
    echo "Adding background image $BG to all frames of $GIF..."
    magick "$GIF" -coalesce null: "$BG" -compose dstOver -layers composite "$OUTPUT"
else
    size=$(gifsicle --sinfo "$GIF" | grep "logical screen" | xargs echo -n | cut -d" " -f 3)

    echo "Generating a $size checkerboard pattern and adding it as background to all frames of $GIF..."
    magick "$GIF" -coalesce null: \( -size $size tile:pattern:checkerboard \) -compose dstOver -layers composite "$OUTPUT"
fi

echo "Optimizing $OUTPUT..."
gifsicle --batch -O3 --lossy=35 "$OUTPUT"

echo "...done!"

Example call:

$ gif_bg 14.gif 
Generating a 256x256 checkerboard pattern and adding it as background to all frames of 14.gif...
Optimizing 14.bg.gif...
...done!

I’m quite happy with the result:

Gina Häußge @foosel@chaos.social

Now also with a creation timelapse (after I finally managed to get a proper workflow going for that)

October 14, 2024, 14:43 (UTC)

I reached out to UHK support, they confirmed they had gotten reports about this from other customers as well and were still investigating. They even created an FAQ page. In the end, after much troubleshooting I got a replacement, and for a while it looked like things were fixed. But then the flickering returned, just less frequent. For the longest time I’ve now just lived with having to occasionally replug my keyboard. But on Friday I found myself on speaker phone with my mom, helping her debug an issue with her PC through screen sharing, with my mobile located between the two halves of the keyboard, and the flickering started with a vengeance! I had to replug the keyboard three or four times during the call, which was super annoying.

So I decided investigate once more, to see if maybe some new information had come up. And indeed it had, I found this thread on the UHK forums:

Thought I’d start a topic about an issue which I’m aware at least a few people have experienced. Which is that the left module’s connection can flicker on/off if your mobile phone is placed to the left of it.

I realised this initially when I tried to capture a video of it happening and couldn’t do it, realising that the act of picking up my phone resolved it. These days I keep the phone away from that side of desk. It’s not a particular problem for me, but I’m sure it’ll be a confusing issue for people when they first encounter it.

My suspicion is that the I2C connection between the two halves has less protection against interference than USB. But it might be interesting to hear from actual engineers about this. And also if people have found a way to mitigate it.

And that got immediately confirmed by UHK:

Admittedly, the UHK is rather sensitive to electromagnetic interference, and we send this troubleshooting guide to our customers when they encounter such issues. We couldn’t catch this issue in the design phase, but fortunately, people can almost always work around it.

I2C is a likely reason; the bus is too long and has too many ICs on it. Future UHK versions will use UART between the halves. Another possible cause is insufficient ground pour on the PCBs, which will be much increased in future versions as well.

and matches my experiences perfectly! When it got really bad on Friday, the phone was actively being used and right next to the left half. And I usually keep my phone in my right pocket, and only occassionally put it on the desk, which could explain why the flickering is so intermittent for me. I checked the (adjusted) FAQ entry and found this advice at the end of it:

If [the issue persists], no matter what, then you can reduce the communication speed of the internal I2C bus of the UHK, making it more stable. The default value is 100000. You can half the communication speed by running the following smart macro commands, preferably in the $onInit macro:

set macroEngine.extendedCommands 1
set i2cBaudRate 500000

which should make communication more stable, but the smaller the value, the less responsive your UHK will get, which you will notice below a certain value

I’ve now applied that through the UHK Agent software, and so far (after a test call to my phone located in the same position as on Friday), things seem stable. Time will tell if this is a permanent fix, but I’m hopeful. And I’m glad I found this information, as it explains the issue and gives me a way to mitigate it (I might add some aluminum foil to the bottom of the left half too, as suggested).

I’m also glad that UHK is aware of the issue and working on a fix for future versions. I’m looking forward to that, as I really like the UHK otherwise.

Since we are talking about several thousand of IPs here in at least 1.5k of CIDR ranges, I was looking for the best way to do that that wouldn’t cause a lot of performance impact - the tracking server needs to be fast.

A list of all CIDR ranges with deny turned out to not work thanks to my endpoint definition in nginx using return statements, and those are apparently evaluated before allow and deny statements. But then I got the hint to look at the geo module and with that it was easy to build a map of IP ranges that should be matched and just combining that with an if.

For a first test I created a converter for this list of IP ranges, filtering for the really big players:

#!/bin/bash

URL=https://raw.githubusercontent.com/PodderApps/ipcat/main/datacenters.csv

if [ $1 != "" ]; then
	DATA=$(curl -s $URL | grep -E "$1")
else
	DATA=$(curl -s $URL)
fi


echo 'geo $is_cloud {'
echo '    default 0;'

while IFS= read -r line; do
	start_ip=$(echo $line | cut -d, -f1)
	end_ip=$(echo $line | cut -d, -f2)
	comment=$(echo $line | cut -d, -f3)

	script="import ipaddress; start_ip=ipaddress.IPv4Address(\"$start_ip\"); end_ip=ipaddress.IPv4Address(\"$end_ip\"); print(next(ipaddress.summarize_address_range(start_ip, end_ip)))"
	cidr=$(python3 -c "$script")

	echo "    $cidr 1; # $comment"
done <<< "$DATA"

echo '}'

Calling this like this then created a conf file:

$ sudo ./generate_is_cloud_map "AWS|DigitalOcean|Google" > /etc/nginx/snippets/is-cloud.conf
$ cat /etc/nginx/snippets/ip-cloud.conf
geo $is_cloud {
    default 0;
    3.0.0.0/15; # Amazon AWS
    # ...
}

which I then could use in my nginx location config through an include and an if statement:

include snippets/is-cloud.conf;

# ...

server {
    location /mylocation {
        if ($is_cloud = 1) {
            return 403;
        }
        # ...
    }
}

For now this seems to work. I’m going to give this a day or so and then look into further IP sources and also blocking off the IPv6 ranges.

Specifically, I wanted a quick CLI tool that would allow me to set up a reverse proxy listening on port 5555, forwarding to http://localhost:5000 while also setting the headers X-Remote-User to remote and X-Remote-Host to localhost:5555.

Enter mitmproxy, or more specifically its mitmdump tool, which turned out to be a great tool for this job.

All I needed was to run the following command:

mitmdump --mode reverse:http://localhost:5000@5555 --modify-headers "/X-Remote-User/remote" --modify-headers "/X-Forwarded-Host/localhost:5555"

This does the following:

• --mode reverse:http://localhost:5000@5555 sets up a reverse proxy listening on port 5555, forwarding to http://localhost:5000
• --modify-headers "/X-Remote-User/remote" sets the X-Remote-User header to remote
• --modify-headers "/X-Forwarded-Host/localhost:5555" sets the X-Forwarded-Host header to localhost:5555

With that the reverse proxy test page in OctoPrint turned all green and I could test my changes without having to set up an actual reverse proxy in front of the development server.

I recently acquired a Brother QL-820NWB label printer to be able to quickly create labels for boxes and such, and ideally also print out Deutsche Post’s “print yourself” stamps with it. The Deutsche Post stamp shop allows me to download PDFs targeting the 62mm wide endless labels for that printer, for the two types of stamps I’m interested in (stamp, and address label with stamp). But my attempts in printing those directly to the printer through Gnome’s printer integration weren’t successful, things were too small, the cutter didn’t work etc.

I knew that printing to the printer via my local instance of brother_ql_web works flawlessly, and that the library this is based on, brother_ql, has a command line interface. So I thought, why not just convert the PDFs to individual PNGs, and then print those?

Through the magic of some shell scripting, I’m now able to do just that, right from the command line.

I installed the brother_ql Python package via pip:

pip install --user brother_ql

I had to do a little manual patch to make it work with the latest versions of the required Pillow dependency, by editing brother_ql/conversion.py and changing Image.ANTIALIAS to Image.LANCZOS.

I also made sure my .bash_profile contains the address and model of my printer:

export BROTHER_QL_PRINTER=tcp://192.168.x.x
export BROTHER_QL_MODEL=QL-820NWB

Then I created two shell scripts, one for printing stamps and one for printing labels.

The first one, porto_print, takes care of printing the stamps. It resizes, trims, adds a new border and then extends to the native width for the selected label size (50mm by default, or 62mm if requested) while keeping a right alignment:

#!/bin/bash

# Usage:
#
#   porto_print <pdf> [50|62]

#!/bin/bash

tmpdir=$(mktemp -d)

cleanup() {
  rm -rf "$tmpdir"
}
trap cleanup EXIT

PDF=$1
LABEL=${2:-50}
PNG=$(basename "${PDF%.*}")

case $LABEL in
  "50")
    WIDTH="554"
    ;;
  "62")
    WIDTH="696"
    ;;
  *)
    echo "Unsupported label size: $LABEL"
    exit -1
    ;;
esac

echo "Converting PDF to individual PNGs..."
pdftoppm "$PDF" "$tmpdir/$PNG" -png -r 600

for file in $(ls $tmpdir/*.png); do
  echo "Printing $file..."
  mogrify -background white -bordercolor white -resize 696x -trim -border 25x25 -gravity east -extent ${WIDTH}x284 "$file"
  brother_ql print -l $LABEL "$file" 
done

The second one, porto_address_print, does basically the same, just with slightly different parameters and left alignment:

#!/bin/bash

# Usage:
#
#   porto_address_print <pdf>

tmpdir=$(mktemp -d)

cleanup() {
  rm -rf "$tmpdir"
}
trap cleanup EXIT

PDF=$1
LABEL=${2:-50}
PNG=$(basename "${PDF%.*}")

case $LABEL in
  "50")
    WIDTH="554"
    ;;
  "62")
    WIDTH="696"
    ;;
  *)
    echo "Unsupported label size: $LABEL"
    exit -1
    ;;
esac

echo "Converting PDF to individual PNGs..."
pdftoppm "$PDF" "$tmpdir/$PNG" -png -r 600

for file in $(ls $tmpdir/*.png); do
  echo "Printing $file..."
  mogrify -bordercolor white -background white -resize 696x -trim -border 25x25 -gravity West -extent ${WIDTH}x839 "$file" 
  brother_ql print -l $LABEL "$file" 
done

Both of these were placed under ~/.local/bin and made executable. I can now call them both from anywhere on the command line, just passing the path to the PDF to print.

The result is one or more nicely printed stamps or address labels, ready to be stuck to an envelope:

Now, this should hopefully make it easier for me to print all those address labels for OctoPrint sticker shipments in the future ;) Next step: Automated QR code labels for the various boxes on my shelves ^^

invoice.pdf: Error occurred while consuming document invoice.pdf: DigitalSignatureError: Input PDF has a digital signature. OCR would alter the document,
invalidating the signature.

I don’t know if a software update brought this refusal to run OCR on signed PDFs, or if AWS simply so long didn’t send me signed PDFs, but I needed to find a way to force paperless to ingest signed things as well as having all of that stuff stored in paperless is a vital part of my accounting workflow.

A quick search for the error message brought me to this discussion on the paperless-ngx GitHub repository and therein I also found the solution, which is to set the PAPERLESS_OCR_USER_ARGS config option to {"invalidate_digital_signatures": true}.

As I run paperless via Docker I needed to add the following to the environment section in my paperless docker-compose.yml:

services:
  # ...
  paperless:
    # ...
    environment:
      # ...
      PAPERLESS_OCR_USER_ARGS: '{"invalidate_digital_signatures": true}'
      # ...

And after adding this and a quick docker compose up -d things seem to now work as expected again. Yay!

He has a dual boot setup running using rEFInd, and while that survived the OS update just fine, when he wanted to return to SteamOS after a quick stint in Windows today, he was greeted by a GRUB boot menu.

Detective foosel to the rescue.

Attempting to boot the SteamOS entry in grub resulted in an error like this (with another device UUID):

error: no such device: aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee
error: file `/boot/vmlinuz-linux-neptune` not found.
error: you need to load the kernel first.

Press any key to continue...

So it couldn’t find it’s boot device and due to that also not the kernel stored thereon.

Entering the Deck’s boot manager and manually booting \efi\steamos\steamoscl.efi also led to the same situation.

I was able to still boot into SteamOS via the fallback entry however (which also had a different boot device UUID).

And it took me way too long¹ to simply just get the idea to let Linux update its GRUB entries:

sudo update-grub

That fixed it.

No idea if the dual boot setup played a roll in this mess or if it was just some random hiccup, my Deck’s update went without a hitch 🤷‍♀️ But if it happens again I now have this entry to check 😁

$ sudo /sbin/vboxconfig 
[sudo] password for gina: 
vboxdrv.sh: Stopping VirtualBox services.
depmod: WARNING: could not open modules.order at /lib/modules/6.3.8-200.fc38.x86_64: No such file or directory
depmod: WARNING: could not open modules.builtin at /lib/modules/6.3.8-200.fc38.x86_64: No such file or directory
depmod: WARNING: could not open modules.builtin.modinfo at /lib/modules/6.3.8-200.fc38.x86_64: No such file or directory
vboxdrv.sh: Starting VirtualBox services.
vboxdrv.sh: Building VirtualBox kernel modules.
egrep: warning: egrep is obsolescent; using grep -E
vboxdrv.sh: failed: Look at /var/log/vbox-setup.log to find out what went wrong.

There were problems setting up VirtualBox.  To re-start the set-up process, run
  /sbin/vboxconfig
as root.  If your system is using EFI Secure Boot you may need to sign the
kernel modules (vboxdrv, vboxnetflt, vboxnetadp, vboxpci) before you can load
them. Please see your Linux system's documentation for more information.

A look into /var/log/vbox-setup.log revealed an error along the lines of this one¹:

/tmp/akmodsbuild.bPlgZsDR/BUILD/VirtualBox-kmod-7.0.10/_kmod_build_6.4.10-200.fc38.x86_64/vboxnetflt/linux/VBoxNetFlt-linux.c: In function 'vboxNetFltLinuxForwardToIntNetInner':
/tmp/akmodsbuild.bPlgZsDR/BUILD/VirtualBox-kmod-7.0.10/_kmod_build_6.4.10-200.fc38.x86_64/vboxnetflt/linux/VBoxNetFlt-linux.c:1570:40: error: implicit declaration of function 'skb_gso_segment'; did you mean 'skb_gso_reset'? [-Werror=implicit-function-declaration]
 1570 |             struct sk_buff *pSegment = skb_gso_segment(pBuf, 0 /*supported features*/);
      |                                        ^~~~~~~~~~~~~~~
      |                                        skb_gso_reset
/tmp/akmodsbuild.bPlgZsDR/BUILD/VirtualBox-kmod-7.0.10/_kmod_build_6.4.10-200.fc38.x86_64/vboxnetflt/linux/VBoxNetFlt-linux.c:1570:40: warning: initialization of 'struct sk_buff *' from 'int' makes pointer from integer without a cast [-Wint-conversion]
cc1: some warnings being treated as errors

I did some web searching and came across this post on the Fedora forums with someone having the exact same issue, and found a solution in the comments courtesy of Peter Francis:

Adding

#include <net/gso.h>

below the line

#include <linux/inetdevice.h>

in /usr/share/virtualbox/src/vboxhost/vboxnetflt/linux/VBoxNetFlt-linux.c fixed it for me.

Hopefully when the file gets overwritten on next VirtualBox update the fix will be already added by VirtualBox’s programmers.

And what can I say, it also fixed it for me! And should this not get fixed in the next update, now I’ll know where to find the solution again - my own TIL post 😉

PS: Something tells me this won’t be the last VirtualBox related TIL post I’ll write…

ssh admin@192.168.1.1 'sudo tcpdump -f -i eth1 -w - src 192.168.1.12' | wireshark -k -i - 

I could confirm that this works and created a small script to make it easier to use by throwing this into ~/.local/bin/gatedump²:

#!/bin/bash

ARGS="$@"
TCPDUMP="sudo tcpdump -f -w - $ARGS"

ssh usg "$TCPDUMP" | wireshark -k -i -

This now allows me to easily run tcpdump remotely with custom arguments, e.g. gatedump -i eth1 host 192.168.1.123, and have it fire up Wireshark automatically. Wish me luck I’ll now be able to figure out what’s going on on my network, because it’s driving me up the wall.

Update from 2023-12-06: In case you are wondering how this story ended, the issue resolved itself with the next OS update of my partner’s iPhone. So whatever caused it, it’s gone now, and I hope for good.

Since I have some images in the docs that I want to be able to reference without having to use relative URLs (../../../../images/), especially since that would tie things in OctoPrint’s source tree structure too close to things in its documentation tree structure that might or might not end up being in a different repository in the future, I needed a way to use absolute URLs here (/images/). But since the docs will most likely also end up being hosted on a version specific subpath of docs.octoprint.org, just using (host) absolute URLs would not work either and break.

There’s several issues on the MkDocs issue tracker about workflow problems caused by this, but the suggested workarounds like using macros to prefix a variable’s contents to related URLs didn’t work for me due to me also heavily relying on mkdocstrings, and anything contained in docstrings is not processed by macros¹.

So I got the idea to implement a minimal MkDocs plugin that would just turn all URLs contained in href and src attributes that are prefixed with a custom schema site: schema into site relative URLs, with this effect. Example:

Using a hook I could register a callback for the on_page_content event that would then replace all URLs as needed in the generated page HTML.

And this is the resulting site_urls.py:

import logging
import urllib.parse
import re

import mkdocs.plugins

log = logging.getLogger("mkdocs")

SITE_URLS_REGEX = re.compile(r'(href|src)="site:([^"]+)"', re.IGNORECASE)

@mkdocs.plugins.event_priority(50)
def on_page_content(html, page, config, files):
    site_url = config["site_url"]
    path = urllib.parse.urlparse(site_url).path

    if not path:
        path = "/"
    if not path.endswith("/"):
        path += "/"

    def _replace(match):
        param = match.group(1)
        url = match.group(2)
        if url.startswith("/"):
            url = url[1:]

        log.info(f"Replacing site:{match.group(2)} with {path}{url}...")
        return f'{param}="{path}{url}"'

    return SITE_URLS_REGEX.sub(_replace, html)

that I’ve registered as a hook in my mkdocs.yaml like this:

hooks:
  - site_urls.py

Seems to work just fine, both for images and links! 😄

Update 2023-07-28: I’ve now published this as a proper plugin on PyPI, see mkdocs-site-urls. With that, all you need to do - given you are already on MkDocs 1.5 or newer - is installing the plugin via pip install mkdocs-site-urls and then adding this to your mkdocs.yaml:

plugins:
  - site-urls

Compiling .pioenvs/datenzwerg-sleepy/src/esphome/components/sound_pressure/sound_pressure_sensor.c.o
In file included from src/esphome/components/sound_pressure/sound_pressure_sensor.h:3,
                 from src/esphome/components/sound_pressure/sound_pressure_sensor.c:1:
src/esphome/core/component.h:3:10: fatal error: string: No such file or directory
    3 | #include <string>
      |          ^~~~~~~~
compilation terminated.
Compiling .pioenvs/datenzwerg-sleepy/src/main.cpp.o
*** [.pioenvs/datenzwerg-sleepy/src/esphome/components/sound_pressure/sound_pressure_sensor.c.o] Error 1

Other external and internal components compiled just fine, so that was quite a head scratcher, until I just finally noticed something in my source tree: my custom component’s source file had the file ending .c instead of .cpp. And that caused all of this, a quick rename from sound_pressure_sensor.c to sound_pressure_sensor.cpp resolved the compilation error 🤦‍♀️

And since it was utterly impossible for me to find anything about this particular problem online, I decided to share my mishap with all of you here, so that in the future someone else doing an internet search for this will have more luck than me today and not waste hours on this 😅

Jun 13 10:23:50 draper kernel: traps: Missing ENDBR: 0xffff9b688c308f30

After some searching I came across this thread on the VirtualBox forums which explained the issue and also includes the solution. Apparently the VirtualBox kernel driver triggers Intel’s IBT (indirect branch tracking). The solution is to disable that¹ by passing ibt=off as a kernel parameter:

sudo grubby --update-kernel=ALL --args="ibt=off"

After a reboot I could rebuild the vbox kernel driver via /sbin/vboxconfig, which ran through without issues, and after that the VM started up just fine.

1. First of all export your game using the “Web” export template

   

2. Navigate to your export folder, make sure to rename your .html file to index.html

3. Zip all of it up, with all the files right within the root of the zip file

   

4. Upload to itch, make sure to check “This file will be played in the browser”

   

5. Scroll down to “Embed Options” and make sure “SharedArrayBuffer support” is checked

   

That wouldn’t be so bad if a lot of the home automations didn’t factor in presence status which gets synced through that, so this has been a source of minor annoyance whenever his status refused to mirror his presence or absence. It just happened again and because every single time now we’ve had to try to remember how to fix it, here’s a quick TIL to encourage my memory 😅

And it’s simple really. Open the iOS settings, scroll down to the Home Assistant settings and make sure that location sharing is set to “Always”.

Battle.net is currently having a spring sale and I’ve been eyeing Diablo II: Resurrected for a while now, so I jumped on the chance (and while at it also got StarCraft Remastered). But given that these days I primarily game on the Steamdeck, I needed to find a way to install Battle.net on my deck and also install individual launchers for the games.

Battle.net

I first made the mistake of trying my luck with installing the Battle.net launcher directly via Steam Proton. Trust me: Don’t. Lots of work, doesn’t end up well. Instead, I went with Lutris. Lutris has been installed for a while, but if that’s not yet on your deck, install that first via the Discover app. Then:

1. Enter desktop mode
2. Navigate to https://lutris.net/games/battlenet/ and click on “Install”. That will fire up an install script in your Lutris setup. Follow the steps shown to you by the app.
3. Once the installer has run its course, log into Battle.net. You should now be able to download stuff.
4. Right click on Battle.net in Lutris, select “Add steam shortcut” (if that’s not available, but “Delete steam shortcut” is - nothing to do, the shortcut has already been added). This will become available after Steam has been restarted, don’t worry about it now.

Diablo II: Resurrected

This will create a Lutris app that uses the same Wine prefix as your Battle.net install. This is important! In desktop mode:

1. Navigate to https://lutris.net/games/diablo-2-ressurected/ (not a typo, there is a typo in that slug indeed), click “Install”. Follow the steps.
2. If not yet done, launch Battle.net and install Diablo II: Resurrected.
3. Launch Diablo once via Battle.net, exit as soon as you can.
4. In Lutris, right click on the Diablo entry, select “Configure” and go to “Game options”
5. Click “Browse” next to “Executable”. Change it to to /home/deck/Games/battlenet/drive_c/Program Files (x86)/Diablo II Resurrected/D2R.exe (so, one folder up, into the Diablo folder and there select D2R.exe)
6. Under Arguments add -launch
7. Save

Make sure the Steam shortcut for the app is added.

StarCraft

Just as with Diablo II, it is important that the StarCraft entry uses the same Wine prefix as Battle.net. Either duplicate the existing “Diablo II: Resurrected” entry or alternatively follow steps 1 and 2 above. Then do the following with your game entry:

1. Launch Battle.net, install Starcraft Remastered.
2. Right click on the designated game entry (either your duplicate of Diablo II, or the Diablo II entry you don’t intend to use), select “Configure”
3. Under “Game info”, change the name to “Starcraft Remastered” and the identifier to “starcraft-remastered”
4. Under “Game options”, change the executable to /home/deck/Games/battlenet/drive_c/Program Files (x86)/StarCraft/x86_64/StarCraft.exe and add -launch to the Arguments
5. Save

The art in Lutris should update automatically. Make sure the Steam shortcut for the app is added.

Once all of that is done, head back into game mode. Feel free to change the art for the newly created entries, e.g. through something like the SteamGridDB plugin for Decky. I also set up a dedicated “Battle.net” collection and added Battle.net itself plus both games to it.

You should now be able to launch your games through their individual Steam shortcuts. Note that the way we have set up things, Battle.net will not be fully available, so if you need that (for multiplayer or for unlocking DLCs) you’ll need to launch through the Battle.net shortcut instead. In the case of the Cartoon skin for StarCraft Remastered, launching Starcraft once through Battle.net sufficed however ^^

So far all of these scenarios were noted down as a Markdown table in my release checklist that these days I prepare in my Obsidian vault, including manually adjusting the testrig commands to match the scenario. Having to take care of the latter is something that has been annoying for a long time now, and during the preparation for yesterday’s release candidate I decided enough is enough and looked into improving my tooling a bit. In the end, I used Obsidian’s quite amazing Dataview plugin to query the information about the planned test scenarios from the checklist’s frontmatter, build the testrig command from that, then render all of this as a table, complete with some checkboxes for state logging during the tests and a copy button for the command.

Here’s the format of the frontmatter for the latest release candidate 1.9.0rc5:

update_test_type: maintenance
update_tests:
- image: 0.17.0-py3
  update_test_type: simplepip
  additional: pip=21.3.1
  wip: true
  done: true
- image: 0.18.0
  channel: maintenance
  start: 1.8.7
  wip: true
  done: true
- image: 0.18.0-latest
  channel: maintenance
  wip: true
  done: true
- image: 1.0.0
  channel: maintenance
  start: 1.8.7
  wip: true
  done: true
- image: 1.0.0-latest
  channel: stable
  wip: true
  done: true
- image: 1.0.0-latest
  channel: maintenance
  start: 1.9.0rc3
  wip: true
  done: true
- image: 1.0.0-latest
  channel: maintenance
  start: 1.9.0rc4
  wip: true
  done: true

And this is the dataviewjs query I used:

const createCheckbox = (checked) => {
	const checkbox = this.container.createEl("input", {"type": "checkbox"});
	checkbox.checked = checked;
	return checkbox;
}
const createDropdown = (options, selected) => {
	const dropdown = this.container.createEl("select");
	options.map((value, idx) => {
		const option = dropdown.createEl("option", {"text": value, "value": value});
		option.selected = (value == selected);
	});
	return dropdown;
}
const createCopyButton = (command) => {
	const button = this.container.createEl("button", {"text": "Copy"})
	button.addEventListener("click", (evt) => {
		evt.preventDefault();
		navigator.clipboard.writeText(command);
	});
	return button;
}

const DUTS = ["pia", "pib", "pic"];

const update_type = dv.current().update_test_type || "maintenance";
const tests = dv.current().update_tests;

dv.table(["ID", "WIP", "Done", "DUT", "OctoPi", "Channel", "Start", "Command", ""], tests
	.map((t, idx) => {
		const dut = t.dut || DUTS[idx % DUTS.length];
		const version = (!t.start || t.start == "stock") ? "" : `,version=${t.start}`;

		let command;
        switch (t.update_test_type) {
			case "simplepip": {
				command = `fab flashhost_flash_and_provision:${t.image} octopi_test_simplepip`;
				if (t.additional) {
					command += ":" + t.additional;
				}
				break;
			}
			default: {
				command = `fab flashhost_flash_and_provision:${t.image} octopi_test_update_${update_type}:${t.channel}${version}`;
				if (t.additional) {
				  command += "," + t.additional
				}
				break;
			}
		}

		const wipCheckbox = createCheckbox(t.wip);
		const doneCheckbox = createCheckbox(t.done);
		const dutDropdown = createDropdown(DUTS, dut);
		const copyButton = createCopyButton(command);

		return [idx + 1, wipCheckbox, doneCheckbox, dutDropdown, t.image, t.channel, t.start ? t.start : "stock", "`" + command + "`", copyButton]
	}));

This iterates over the list of scenarios, and for each generates a command, assigns one of the DUTs (Device Under Test) of the testrig, creates checkboxes for WIP and Done seeded from the frontmatter data and also a copy button. This then gets rendered as a table.

Throwing that query in a dataviewjs typed markdown code fence yields a nice rendition of the data that allows me to check if I have forgotten anything, track my progress with the checkboxes and also allows me to easily copy the generated command with the click of a button, so I don’t have to manually copy paste stuff anymore:

What I have not yet figured out is how to manipulate the frontmatter directly via the checkboxes and DUT dropdowns (for logging purposes) - right now I still have to edit the state changes manually to persist them. The MetaEdit plugin for Obsidian looked promising, but that doesn’t seem to be flexible enough to manipulate a list of items (yet).

In any case, this helped me a ton yesterday, and will save me a lot of time with future releases and release candidates!

My secondary monitor is a 24" DELL with a resolution of 1920x1200, so 16:10, instead of the more common 1080p and 16:9. In order to be able to connect all my three monitors to my laptop, I make use of both the laptop’s HDMI port as well as a USB-C dock that has 2 HDMI ports. The 4k main display is connected directly to the laptop’s HDMI port, secondary and tertiary display are connected to the dock.

The problem now was that as long as I had both secondary and tertiary connected, I could only select up to 1080p for the secondary. That would not have been that big of an issue if that wouldn’t have caused the monitor to try to scale the 16:9 output to 16:10, stretching it. With only the secondary display attached however, it would detect the 16:10 resolution just fine.

On Windows, with the same hardware setup (albeit a different laptop), this was quickly solved with a third party tool and ran just fine for months. On Linux I was stumped for the past few weeks since switching. Adding video= lines to the kernel parameters - as suggested by various guides - didn’t seem to do the trick, and that appears to be the only option these days with Wayland in the mix to do something like this.

Today however I fell over this helpful section on the ArchLinux wiki, and that gave me an idea. Apparently the EDID information of the secondary is correct when it is connected alone, or I wouldn’t be able to select 1920x1200 then. So I should be able to just grab the EDID data from it when working and force that to be used all the time via a kernel parameter.

I disconnected my tertiary display and verified the secondary was now again being detected as supporting 1920x1200. Then I first figured out its port by checking which of the available devices showed as connected (and wasn’t the internal laptop screen or the 4k primary):

$ for p in /sys/class/drm/*/status; do con=${p%/status}; echo -n "${con#*/card?-}: "; cat $p; done
DP-1: disconnected
DP-2: connected
DP-3: disconnected
DP-4: disconnected
DP-5: disconnected
DP-6: connected
DP-7: disconnected
eDP-1: connected

In my case that turned out to be DP-6¹. Next I quickly dumped the EDID information to a new file /usr/lib/firmware/edid/dell-24-1200p.bin:

sudo mkdir -p /usr/lib/firmware/edid
sudo cp /sys/class/drm/card1-DP-6/edid /usr/lib/firmware/edid/dell-24-1200p.bin

Then I used grubby to add a drm.edid_firmware kernel mode setting to all kernel entries for DP-6 that tells the kernel to use this EDID file:

sudo grubby --update-kernel=ALL --args="drm.edid_firmware=DP-6:edid/dell-24-1200p.bin"

And one reboot later I could finally select 1920x1200 for my display! 🥳

Addendum from 2023-05-24*: Recently the display’s identifier’s started switching between DP-6 and DP-8, sometimes even when waking up from sleep. I’m not sure why, and I so far did not have time to investigate, but just so I or anyone else stumbling over this knows how to do this in the future, it’s easy to set custom edid data on multiple devices as well, in my case:

sudo grubby --update-kernel=ALL --args="drm.edid_firmware=DP-6:edid/dell-24-1200p.bin,DP-8:edid/dell-24-1200p.bin"

So I finally dug into solving this quickly, and came across this post on Reddit with a quite nice solution. I modified ~/.config/gtk-3.0/gtk.css and added the following contents:

window.ssd headerbar.titlebar {
    padding-top: 2px;
    padding-bottom: 2px;
    min-height: 0;
}
window.ssd headerbar.titlebar button.titlebutton {
    padding: 1px;
    min-height: 0;
    min-width: 0;
}

That resulted in this:

And now I’m happy, at least with non-Gnome apps, my chosen development environment VSCode included.

Update 2023-04-30: Alas, that no longer works under Gnome 44, so for now I’m stuck with oversized titlebars again.

What cost me a bunch of time however is trying to figure out how to create an animated tile in a tilemap, which I finally figured out yesterday, and so I’m writing it down here for future me and everyone else wondering about this.

First of all, you need a graphic of your tile-to-be-animated. It should have all frames side by side, like this example:

This is going to become a floating 16x16px carot, its animation consisting of four frames.

Add it to a tileset by dragging the resource into the left column, and make sure that only the first frame becomes part of your tileset! If you have let automatic atlas tooling do its thing, delete the other frames again under “Setup”:

Then switch to the tileset editor’s “Select” panel and click on the first frame of your animation. On the left you’ll see some options for that tile. Open “Animation”, then increase the number of animation frames to the number of your available frames (4 for our carrot here), and after that make sure to click on “Add Frame” once for each of your frames. You then can also define how long the frame will be shown, 1s by default. 0.3s will result in something like 10fps.

After that, placing the first frame in a tilemap should show it being animated now:

🥳

$ ~?
Supported escape sequences:
 ~.   - terminate connection (and any multiplexed sessions)
 ~B   - send a BREAK to the remote system
 ~C   - open a command line
 ~R   - request rekey
 ~V/v - decrease/increase verbosity (LogLevel)
 ~^Z  - suspend ssh
 ~#   - list forwarded connections
 ~&   - background ssh (when waiting for connections to terminate)
 ~?   - this message
 ~~   - send the escape character by typing it twice
(Note that escapes are only recognized immediately after newline.)

I most commonly require ~. to disconnect from a broken SSH session (e.g. something I still had open on my laptop when I sent it to sleep).

The command line opened via ~C is quite interesting as well, as it allows configuration of port forwards on the fly, while the session is already running:

ssh> help
Commands:
      -L[bind_address:]port:host:hostport    Request local forward
      -R[bind_address:]port:host:hostport    Request remote forward
      -D[bind_address:]port                  Request dynamic forward
      -KL[bind_address:]port                 Cancel local forward
      -KR[bind_address:]port                 Cancel remote forward
      -KD[bind_address:]port                 Cancel dynamic forward

This is once again a “TIL” that I didn’t actually learn about only today, but I keep forgetting about it and then need to frantically google whenever I need it. I hope this way I’ll finally remember this stuff 😅

To once again explain my situation, I use OBS also for video conferencing, through the virtual camera¹. OBS does not offer a built-in way to provide a virtual microphone with all the filters and such applied as well (in my case noise reduction and a limiter), so I need to solve this in a separate way. Additionally, my camera setup has a small delay of around 350ms that I also need to compensate by delaying my audio.

OBS offers a monitoring port that you can push your audio devices on, and that will get the filters applied, but none of the configured offsets. On Windows, I solved this by using a combination of two Virtual Cable devices and RadioDelay between the two.

Today I rebuild basically the same setup on Linux via a bunch of virtual Pulseaudio devices. I have this in ~/.local/bin/obs-virtual-mic:

#!/bin/bash

# create virtual speaker
pactl load-module module-null-sink sink_name=Virtual-Speaker sink_properties=device.description=Virtual-Speaker

# create delayed virtual speaker & associated mic
pactl load-module module-null-sink sink_name=Virtual-Speaker-Delayed sink_properties=device.description=Virtual-Speaker-Delayed
pactl load-module module-remap-source source_name=Remap-Source master=Virtual-Speaker-Delayed.monitor

# copy from virtual to delayed virtual with 350ms delay
pactl load-module module-loopback latency_msec=350 source=Virtual-Speaker.monitor sink=Virtual-Speaker-Delayed

Let’s take a closer look at what this does:

• create two virtual sinks Virtual-Speaker and Virtual-Speaker-Delayed with pactl load-module module-null-sink ...
• create a virtual source for the delayed sink via pactl load-module module-remap-source ...
• finally mirror the sound from Virtual-Speaker.monitor to Virtual-Speaker-Delayed while adding a latency of 350ms

I run this. Then OBS gets set to use Virtual-Speaker as monitor. In my video conferencing software I then use Virtual-Speaker-Delayed as my input to get my video and audio synced up.

As a German living in Germany with umlauts in my last name and a US ANSI keyboard layout on all my devices¹ I need to remap some stuff to be able to easily type ä, ö, ü and ß. On Windows I solved this with Autohotkey, mapping AltGr+a to ä, AltGr+o to ö, AltGr+u to ü and AltGr+s to ß (well, technically RAlt - the right Alt key). That has burned itself into my muscle memory now, and so while currently setting up my new Framework laptop under Linux, with Gnome running on Wayland, I was looking for a way to remap the keys to this layout as well.

In the old days, I would have written an .Xmodmap file and called it a day, but that no longer works under Wayland. Thankfully however there’s a whole new generation of mapping tools that instead of depending on the X server allow remapping right at the kernel input level, and one of them is keyd which I used to solve my umlaut problem, and while at it also added a fancy mod layer and even a mouse layer.

First of all, in Gnome I set the keyboard layout to “English (intl., with AltGr dead keys)”, making it look like this:

Then I downloaded, compiled and installed keyd and created a config file at /etc/keyd/default.cfg with the following contents:

[ids]
*

[main]
capslock = layer(mod)
rightalt = layer(dia)
rightcontrol = overload(control, sysrq)

[dia]
a = G-q
o = G-p
u = G-y
s = G-s
e = G-5
` = G-S-;

[mod]
alt = layer(mouse)
j = left
k = down
l = right
i = up
u = home
o = end
y = pageup
h = pagedown
p = delete
; = insert

[mouse]
j = kp4
k = kp2
l = kp6
i = kp8
f = leftmouse
s = rightmouse
d = middlemouse

What this does is first of all attach two layers mod and dia to CapsLock and right Alt respectively, and then it also gives the right Ctrl key a second purpose in life. Holding it still makes it act like your regular Ctrl key, but merely tapping it now will make it act like PrintScreen aka SysRq, allowing me to take screenshots more quickly than my laptop’s keyboard layout would regularly allow².

But let’s take a closer look at the layers.

Solving my umlaut problem

Let’s start with the dia layer, since that is what solves my umlaut problem. I couldn’t get the compose key to work for me, so I went with mapping my desired shortcuts to the right shortcuts on the international layout for the key to pop up:

• a -> AltGr+q (ä)
• o -> AltGr+p (ö)
• u -> AltGr+y (ü)
• s -> AltGr+s (ß)
• e -> AltGr+5 (€)
• ` -> AltGr+Shift+; (°)

Adding a mod layer…

While at it I decided to also add another feature I’m used to from my UHK, and that is the Mod layer together with its arrow keys, home, end etc. So I replicated that as well, which is the mod layer here. And because I cannot remember a single time in my life where I ever needed CapsLock, that became my mod key. With Capslock held, we have the following mappings:

• j -> left
• k -> down
• l -> right
• i -> up
• u -> home
• o -> end
• y -> pageup
• h -> pagedown
• p -> delete
• ; -> insert

I’ve since also enabled CapsLock as Mod key on my UHK, in the hopes that this will accelerate my muscle memory learning process.

… and adding a mouse layer too!

And then I thought, hm, can I maybe even add a mouse layer? And yes, I can. So I added a mouse layer, which is activated by holding Alt and CapsLock together. I enabled mouse keys in Gnome’s accessibility settings, which allows me to move the mouse cursor with the numpad keys. My keyboard does not have numpad keys, but keyd doesn’t care, and so we end up with this mapping:

• j -> move cursor left
• k -> move cursor down
• l -> move cursor right
• i -> move cursor up
• f -> left mouse button
• s -> right mouse button
• d -> middle mouse button

I’m not sure I’ll actually use this a lot tbh, this was more a case of “can it be done?” and “why not?”. But it’s nice to have the option. Something I still need to experiment on however are the acceleration settings, because out of the box this was way too slow for me, so after finding an answer here I changed the mouse key parameters a bit via

gsettings set org.gnome.desktop.a11y.keyboard mousekeys-max-speed 2000;
gsettings set org.gnome.desktop.a11y.keyboard mousekeys-init-delay 20;
gsettings set org.gnome.desktop.a11y.keyboard mousekeys-accel-time 2000;

But I’m not 100% happy with this yet and need to play around with things a bit more.

Fixing the “Disable Touchpad while Typing” feature

One problem arose from all of this reconfiguration, and that was that the “Disable Touchpad while Typing” (DWT) feature was no longer working, which turned out to be a rather big deal - I kept unintentionally moving the cursor or even clicking on things while typing. Thankfully a quick search made me stumble over this helpful post that not only explained the issue but also showed me how to solve it.

To summarize, DWT works by pairing up touchpad and keyboard either by them having the same vendor and product id, or being marked as “internal”. In the case of keyd acting as my keyboard, neither was true anymore and thus DWT no longer worked. The solution was to modify the libinput properties of the virtual keyd keyboard such that it would be marked as “internal”. Putting this into /etc/libinput/local-overrides.quirks sufficed:

[Virtual Keyboard]
MatchUdevType=keyboard
MatchName=keyd virtual keyboard
AttrKeyboardIntegration=internal

Conclusion

keyd seems like a powerful tool, and even though I haven’t actually yet tested it, should at any point I want to switch to X11 or a blank terminal on this laptop now, all these mappings should continue to function (as long as I set the keyboard layout to English international). That’s definitely a way cleaner solution than the xmodmap approach I was using in the past. And I can now finally type my name again!

Something that got annoying quickly is that the package manager command dnf defaults to “no” when asking if you really want to install a package plus its dependencies. I’m very used to apt’s behaviour here that allows me to type sudo apt install <package> and then just hit Enter on the sanity check. I wanted the same for dnf, but without bypassing the sanity check altogether. I did some digging together with my buddy Ben and we found the answer.

Edit the file /etc/dnf/dnf.conf and add the following line to the [main] section:

defaultyes=True

And once that’s done, the sanity check now is Y/n instead of y/N and you can just hit Enter to install the package.

(This is btw the first post written on the new laptop and I’m really enjoying it so far!)

I stumbled across this Reddit post that recommended to use the itch.io Windows launcher instead of the native Linux one:

Itch.io has an app, that even has linux version. But it has issues - it can only use one wine version, if you have it installed globally, it can’t even handle linux games well. It pretends to install them, and when you launch them it opens a directory with the zip file… Or it just doesn’t work after installation. Then you need to add all the games to steam, setup their images, and other stuff. There’s boilr for that, but it doesn’t find everything, and most of the indies are not in the database anyway.

Sounds reasonable to go with the Windows version then, so I followed the post and got everything working. Quick summary in case the link goes stale:

• In desktop mode, download the Windows installer from https://itch.io/app, add it as a non steam game, configure stable Proton for it, launch it, complete the installer and log in.
• Open Dolphin, navigate to home/deck/.steam/steam/steamapps/compatdata
• Click on the search icon, check “From here”, search for itch and enter the first found folder of that name. Look at the address bar, you’ll be in a subfolder of something like /home/deck/.steam/steam/steamapps/compatdata/<number> for a random <number>, this parent folder is what to use for <basefolder> in any following steps.
• In desktop Steam, open the preferences of your non-steam itch.io installer “game”. Replace “Target” with <basefolder>/pfx/drive_c/users/steamuser/Desktop/itch.lnk and “Start in” with <basefolder>/pfx/drive_c/users/steamuser/AppData/Local/Itch. Rename it to “itch.io” or whatever else you want it to be called².

I then followed the steps to also allow Steam Rom Manager to detect my itch.io games, and created a custom itch.io parser. Here I had to slightly deviate from the suggested steps. Again, summarised here for reference:

• Parser type: glob
• Title: itch.io
• Steam category: ${itch.io}
• Steam directory: ${steamdirglobal}
• ROMs directory: <basefolder>/pfx/drive_c/users/steamuser/AppData/Roaming/itch/apps
• Executable modifier: "${exePath}" (with quotes!)
• User’s glob: ${title}/{*/,}!(Unity*).exe (this one is different than on the Reddit post, see below for why!)
• Leave anything else as is.

I changed the glob pattern as the original setting of ${title}/{*/*,*}.exe was happily detecting the Unity crash handler executable contained in some games as additional entry, obviously not what I wanted.

After some trial and error I thankfully was able to solve this with the slightly different glob pattern of ${title}/{*/,}!(Unity*).exe. It now matches any exe right in the game folder or one folder deep that doesn’t start with the string Unity. And if push comes to shove I can add additional forbidden patterns as well.

Even Unity games now only generate one entry, and seem to work fine once I’ve figured out the right Proton version 👍

Once again we are using rclone for syncing.

First I created a new target gphoto by running ~/bin/rclone config again and then following these steps. Quick summary:

1. New remote
2. gphoto
3. Empty application ID and secret
4. Full access
5. No advanced config
6. Use web browser to authenticate

I then created a new album:

rclone mkdir gphoto:album/Steamdeck

and adjusted ~/bin/sync_screenshots to use the new remote and remote path:

REMOTE_NAME='gphoto'
REMOTE_DIR='album/Steamdeck'

That was all.

Obviously the same can be done with any of the other sync targets that rclone supports, of which there are many. For ownCloud or NextCloud it looks like WebDAV is the right option to choose.

Update 2025-03-25: There’s now also a TIL on how to do the same for Immich.

First of all, in your unifi controller you should create a new user that Home Assistant will act as to manage your port forward(s) for you. So, log into the controller, go into Settings > Administrators and add a new Administrator user¹.

Then create your port forward in Settings > Routing & Firewall > Port Forwarding. Take note of the id of the port forward you have created - you can find it by clicking edit on it again, it will be the number at the end of the URL of the edit page. E.g. if the URL looks like this: https://my.unifi.controller/manage/site/default/settings/portforward/edit/1234567890 then this is the id of the port forward: 1234567890.

Next, copy this shell script to /config/scripts/unifi.sh in your Home Assistant. Make sure to adjust https://my.unifi.controller (and, if necessary, the site default) to your own values.

#!/bin/sh

set -e

# based on https://community.home-assistant.io/t/automating-unifi-port-forwarding-based-upon-presence-detection/168185

cookie=$(mktemp)
headers=$(mktemp)
curl_cmd="curl --silent --cookie ${cookie} --cookie-jar ${cookie} -D ${headers} --insecure"

BASEURL="https://my.unifi.controller"
SITE="default"

auth() {
  USERNAME=$1
  PASSWORD=$2

  # authenticate against unifi controller
  ${curl_cmd} --output /dev/null -d "{\"username\":\"$USERNAME\", \"password\":\"$PASSWORD\"}" $BASEURL/api/login

  # grab the `x-csrf-token` and strip the newline (added when upgraded to controller 6.1.26)
  csrf="$(awk -v FS=': ' '/^x-csrf-token/{print $2}' "${headers}" | tr -d '\r')"
  echo $csrf
}

portfwd() {
  USERNAME=$1
  PASSWORD=$2
  FORWARD_ID=$3
  FORWARD_ENABLED=$4

  # authenticate against unifi controller
  csrf=$(auth $USERNAME $PASSWORD)

  # enable/disable firewall rule
  body=$(${curl_cmd} -X GET $BASEURL/api/s/default/rest/portforward/$FORWARD_ID | jq '.data[0] | .enabled='$FORWARD_ENABLED'')
  ${curl_cmd} -X PUT $BASEURL/api/s/default/rest/portforward/$FORWARD_ID -H "Content-Type: application/json" -H "x-csrf-token: ${csrf}" -d @<(echo "$body")
}

isportfwd() {
  USERNAME=$1
  PASSWORD=$2
  FORWARD_ID=$3

  # authenticate against unifi controller
  csrf=$(auth $USERNAME $PASSWORD)

  ${curl_cmd} -X GET $BASEURL/api/s/default/rest/portforward/$FORWARD_ID | jq '.data[0].enabled'
}

"$@"

Now, let’s imagine you want to add a switch for an SFTP port forward that you’ve just created. Then, in your secrets.yaml file, add the following:

unifi_forward_sftp_check: '/bin/bash /config/scripts/unifi.sh isportfwd <user> <password> <forward_id>'
unifi_forward_sftp_enable: '/bin/bash /config/scripts/unifi.sh portfwd <user> <password> <forward_id> true'
unifi_forward_sftp_disable: '/bin/bash /config/scripts/unifi.sh portfwd <user> <password> <forward_id> false'

Replace <user>, <password> and <forward_id> with the login credentials and id of the forward you just created.

Next, add a command line switch definition to your configuration.yaml (or in my case to my packages/network.yaml file):

switch:
  - platform: command_line
    switches: 
      sftp_port_forward:
        friendly_name: "SFTP Port Forward"
        command_state: !secret unifi_forward_sftp_check
        command_on: !secret unifi_forward_sftp_enable
        command_off: !secret unifi_forward_sftp_disable
        value_template: '{{ bool(value, false) }}'

Throw that somewhere on your dashboard, or alternatively tie it into some automation, and you’re good to go!

I came across this gist by pegasd that accomplishes this via rclone, a path monitoring systemd service and some reconfiguration in Steam. However, I had to adjust things slightly for everything to really work - I could imagine that some past Steam update changed things slightly vs when the gist was created:

1. I had to make sure that I selected the option to make Steam create uncompressed screenshots.
2. I had to manually start the path watcher.

Here’s a quick summary of how I managed to make things work on my deck (all credits go to @pegasd, replicating things here mostly so they don’t get lost in the future).

Prerequisites

First of all I switched into Desktop mode.

Since I had not yet done this since upgrading my Deck’s SSD, I set a password for my user account by opening a terminal and running passwd. I also made sure to install Firefox from the package manager.

Setting up the screenshot directory

I opened a terminal and created a dedicated screenshot folder:

mkdir ~/.steam_screenshots

Next I had to tell Steam to use this folder. Still in desktop mode I opened Steam settings and on the “In-Game” tab set the screenshot folder to the one I had just created. I also made sure to check “Save uncompressed copy”, as otherwise Steam won’t use the just configured custom folder.

Installing and configuring rclone

Next, still on the deck, I downloaded rclone (“Intel/AMD - 64 Bit / Linux”). I opened the file browser, opened the archive I had just downloaded and extracted the rclone binary into ~/bin (if that doesn’t exist yet, just create it).

I then went back to the terminal, ran ~/bin/rclone config and configured a new remote gdrive following these steps. Quick summary:

1. New remote
2. gdrive
3. Empty application ID and secret
4. Full access to all files
5. No service account credentials file
6. Use web browser to authenticate
7. Not configured as a shared drive

Automatic sync

I created a file ~/bin/sync_screenshots

#!/usr/bin/env bash

RCLONE_BIN="${HOME}/bin/rclone"
REMOTE_NAME='gdrive'
REMOTE_DIR='Privat/Steamdeck/Screenshots'
SOURCE_DIR="${HOME}/.steam_screenshots"

${RCLONE_BIN} sync "${SOURCE_DIR}" "${REMOTE_NAME}:${REMOTE_DIR}"

and made it executable with chmod +x ~/bin/sync_screenshots.

Then I created a service file for it, ~/.config/systemd/user/sync_screenshots.service:

[Unit]
Description=Sync Steam Screenshots

[Service]
Type=oneshot
ExecStart=%h/bin/sync_screenshots

and another file setting up a path watcher, ~/.config/systemd/user/sync_screenshots.path:

[Unit]
Description=Sync Steam Screenshots

[Path]
PathModified=%h/.steam_screenshots
Unit=sync_screenshots.service

[Install]
WantedBy=default.target

I enabled the automation:

sudo systemctl daemon-reload
systemctl --user enable sync_screenshots.path
systemctl --user start sync_screenshots.path

A quick test

I checked that the path watcher was up and running with systemctl --user status sync_screenshots.path.

Then I created a quick test file in the synced folder

touch ~/.steam_screenshots/test

and verified it showed up in the target folder on my Google Drive.

Next I deleted the file on the deck and verified it got deleted in Google Drive.

Finally I booted back into Game mode, took a screenshot there as well with Steam+R1 and verified this showed up on my Drive.

Success!

Update 2023-02-19: There is now also a TIL on how to do the same for Google Photos. Update 2025-03-25: And now there’s also a TIL on how to do the same for Immich.

I put all my screenshot PNGs into a folder, and then in that folder ran this mogrify command:

magick mogrify -trim -define trim:percent-background=0% -background black -path output/ *.png

I found that I had to add the -define trim:percent-background=0% option to get rid of all black borders, as otherwise on some of the images a very slim one ended up remaining. I also specified the background color with -background black to make sure that it really only trimmed the black borders.

I then could combine the resulting images into a PDF with img2pdf¹:

img2pdf --output output.pdf *.png

Enter node-qrcode which runs easily via npx¹:

npx qrcode -o output.png -d FFFF -l 0000 -w 500  "https://foosel.net"

• -o output.png sets the output file
• -d FFFF sets the dark color (usually black) to white with 100% opacity
• -l 0000 sets the light color (usually white) to black with 0% opacity - fully transparent
• -w 500 sets the size to 500px

For further options like error correction or QR code version, or how to use it as a library or in the browser, see node-qrcode’s repo linked above.

I for one am happy with the result of this little exercise:

The idea is to get the current feed.json prior to publishing the page, and then compare it to the one that was just generated during the build. If there are any differences, we know that there are new posts and can trigger further actions from there.

# Get current feed.json
curl -s https://foosel.net/til/feed.json > feed.current.json

# Get new feed.json
cp public/til/feed.json feed.next.json

# Compare the two, this is where the magic happens
jq --slurpfile current til.current.json --slurpfile next til.next.json -n '$next[0].items - $current[0].items' > til.json

Let’s go through this jq command there:

• --slurpfile <variable> <file> reads in the given files and makes it accessible as an array contained in the given variable. In this case we read in til.current.json and make it accessible as $current, and also read in til.next.json and make it accessible as $next.
• -n doesn’t wait for input on stdin.
• '$next[0].items - $current[0].items' subtracts the items from the new feed from the items in the current feed¹.
• > til.json writes the output to til.json.

til.json will then contain all new items (as long as there weren’t more than the feed’s item size), can be uploaded as an artifact and then used in further jobs².

The format of the lines in octoprint.log is a simple %(asctime)s - %(name)s - %(levelname)s - %(message)s, so a log with an error and attached exception looks like this:

2023-01-30 17:50:45,704 - octoprint.events.fire - DEBUG - Firing event: Disconnecting (Payload: None)
2023-01-30 17:50:45,704 - octoprint.events - DEBUG - Sending action to <bound method PrinterStateConnection._onEvent of <octoprint.server.util.sockjs.PrinterStateConnection object at 0x000001635CB6EE50>>
2023-01-30 17:50:45,705 - octoprint.plugin - DEBUG - Calling on_event on action_command_notification
2023-01-30 17:50:45,705 - octoprint.plugin - DEBUG - Calling on_event on action_command_prompt
2023-01-30 17:50:45,705 - octoprint.plugin - DEBUG - Calling on_event on announcements
2023-01-30 17:50:45,705 - octoprint.plugin - DEBUG - Calling on_event on file_check
2023-01-30 17:50:45,706 - octoprint.plugin - DEBUG - Calling on_event on firmware_check
2023-01-30 17:50:45,706 - octoprint.plugin - DEBUG - Calling on_event on pluginmanager
2023-01-30 17:50:45,706 - octoprint.plugin - DEBUG - Calling on_event on softwareupdate
2023-01-30 17:50:45,706 - octoprint.plugin - DEBUG - Calling on_event on tracking
2023-01-30 17:50:45,711 - octoprint.plugin - DEBUG - Calling on_event on mqtt
2023-01-30 17:50:45,732 - octoprint.events.fire - DEBUG - Firing event: Disconnected (Payload: None)
2023-01-30 17:50:45,735 - octoprint.events - DEBUG - Sending action to <function Server.run.<locals>.<lambda> at 0x000001635BDB2CA0>
2023-01-30 17:50:45,750 - octoprint.events - ERROR - Got an exception while sending event Disconnected (Payload: None) to <function Server.run.<locals>.<lambda> at 0x000001635BDB2CA0>
Traceback (most recent call last):
  File "C:\Devel\OctoPrint\OctoPrint\src\octoprint\events.py", line 197, in _work
    listener(event, payload)
  File "C:\Devel\OctoPrint\OctoPrint\src\octoprint\server\__init__.py", line 1212, in <lambda>
    octoprint.events.Events.DISCONNECTED, lambda e, p: run_autorefresh()
                                                       ^^^^^^^^^^^^^^^^^
  File "C:\Devel\OctoPrint\OctoPrint\src\octoprint\server\__init__.py", line 1195, in run_autorefresh
    autorefresh.stop()
    ^^^^^^^^^^^^^^^^
AttributeError: 'RepeatedTimer' object has no attribute 'stop'
2023-01-30 17:50:45,753 - octoprint.events - DEBUG - Sending action to <bound method PrinterStateConnection._onEvent of <octoprint.server.util.sockjs.PrinterStateConnection object at 0x000001635CB6EE50>>
2023-01-30 17:50:45,755 - octoprint.plugin - DEBUG - Calling on_event on action_command_notification
2023-01-30 17:50:45,756 - octoprint.server.util.sockjs - DEBUG - Socket message held back until permissions cleared, added to backlog: plugin
2023-01-30 17:50:45,758 - octoprint.plugins.action_command_notification - INFO - Notifications cleared
2023-01-30 17:50:45,758 - octoprint.plugin - DEBUG - Calling on_event on action_command_prompt
2023-01-30 17:50:45,758 - octoprint.plugin - DEBUG - Calling on_event on announcements
2023-01-30 17:50:45,759 - octoprint.plugin - DEBUG - Calling on_event on file_check
2023-01-30 17:50:45,759 - octoprint.plugin - DEBUG - Calling on_event on firmware_check
2023-01-30 17:50:45,759 - octoprint.server.util.sockjs - DEBUG - Socket message held back until permissions cleared, added to backlog: plugin
2023-01-30 17:50:45,763 - octoprint.plugin - DEBUG - Calling on_event on pluginmanager
2023-01-30 17:50:45,764 - octoprint.plugin - DEBUG - Calling on_event on softwareupdate
2023-01-30 17:50:45,764 - octoprint.plugin - DEBUG - Calling on_event on tracking

What I now wanted is for grep to spit out just the ERROR line and the attached stack trace:

2023-01-30 17:50:45,750 - octoprint.events - ERROR - Got an exception while sending event Disconnected (Payload: None) to <function Server.run.<locals>.<lambda> at 0x000001635BDB2CA0>
Traceback (most recent call last):
  File "C:\Devel\OctoPrint\OctoPrint\src\octoprint\events.py", line 197, in _work
    listener(event, payload)
  File "C:\Devel\OctoPrint\OctoPrint\src\octoprint\server\__init__.py", line 1212, in <lambda>
    octoprint.events.Events.DISCONNECTED, lambda e, p: run_autorefresh()
                                                       ^^^^^^^^^^^^^^^^^
  File "C:\Devel\OctoPrint\OctoPrint\src\octoprint\server\__init__.py", line 1195, in run_autorefresh
    autorefresh.stop()
    ^^^^^^^^^^^^^^^^
AttributeError: 'RepeatedTimer' object has no attribute 'stop'

For this I needed a way to set grep to match multiple lines and do a (non-matching) look ahead for the end. It turns out that the secret to success here is to treat the whole input as one line, use Perl compatible regex mode, and make sure to set the multiline flag. After some fiddling around on regex101.com and reading up on Perl’s regex options¹, I came up with the following:

grep -Pazo '(?m)^\N+\- ERROR \-\N*\n(^\N*?\n)*?(?=\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3} \- )' octoprint.log

Let’s walk through this:

• -P enables Perl compatible regex mode
• -a enables text mode
• -z turns all newlines into null bytes and thus treats the whole input as a single line for finding matches²
• -o only outputs the matched part of the line (otherwise we’d get the whole file printed out)
• (?m) enables multiline mode
• ^\N+\- ERROR \-\N*\n matches the first line of the error, which is the one that starts with the timestamp and package and contains the word ERROR
• (^\N*?\n)*? non-greedily matches all following lines of the error, which are anything but a newline followed by a newline
• (?=\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3} \- ) is a positive look-ahead that matches a line starting with a timestamp again, which signifies the end of the error’s lines

Hooray, it works 🥳:

❯ grep -Pazo '(?m)^\N+\- ERROR \-\N*\n(^\N*?\n)*?(?=\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3} \- )' octoprint.log
2023-01-30 17:50:45,750 - octoprint.events - ERROR - Got an exception while sending event Disconnected (Payload: None) to <function Server.run.<locals>.<lambda> at 0x000001635BDB2CA0>
Traceback (most recent call last):
  File "C:\Devel\OctoPrint\OctoPrint\src\octoprint\events.py", line 197, in _work
    listener(event, payload)
  File "C:\Devel\OctoPrint\OctoPrint\src\octoprint\server\__init__.py", line 1212, in <lambda>
    octoprint.events.Events.DISCONNECTED, lambda e, p: run_autorefresh()
                                                       ^^^^^^^^^^^^^^^^^
  File "C:\Devel\OctoPrint\OctoPrint\src\octoprint\server\__init__.py", line 1195, in run_autorefresh
    autorefresh.stop()
    ^^^^^^^^^^^^^^^^
AttributeError: 'RepeatedTimer' object has no attribute 'stop'

(And yes, I’ve fixed the error that lead to this stack trace as well 😉)

Looking around a bit on how to go about caching these, I came across various approaches listed in this GitHub issue on the Playwright repo. Below is the result of reading through most of them and figuring out what works best for me and my use case (OctoPrint’s E2E tests, npm based test project).

These steps make sure to install Playwright, fetching the browser binaries from cache if possible, in any case installing the OS depencies, running the tests (replace ./path/to/tests accordingly for your setup) and finally upload the generated report as artifact, regardless of whether the tests succeeded or not:

# Run npm ci and get Playwright version
- name: 🏗 Prepare Playwright env
  working-directory: ./path/to/tests
  run: |
    npm ci
    PLAYWRIGHT_VERSION=$(npm ls --json @playwright/test | jq --raw-output '.dependencies["@playwright/test"].version')
    echo "PLAYWRIGHT_VERSION=$PLAYWRIGHT_VERSION" >> $GITHUB_ENV

# Cache browser binaries, cache key is based on Playwright version and OS
- name: 🧰 Cache Playwright browser binaries
  uses: actions/cache@v3
  id: playwright-cache
  with:
    path: "~/.cache/ms-playwright"
    key: "${{ runner.os }}-playwright-${{ env.PLAYWRIGHT_VERSION }}"
    restore-keys: |
      ${{ runner.os }}-playwright-

# Install browser binaries & OS dependencies if cache missed
- name: 🏗 Install Playwright browser binaries & OS dependencies
  if: steps.playwright-cache.outputs.cache-hit != 'true'
  working-directory: ./path/to/tests
  run: |
    npx playwright install --with-deps

# Install only the OS dependencies if cache hit
- name: 🏗 Install Playwright OS dependencies
  if: steps.playwright-cache.outputs.cache-hit == 'true'
  working-directory: ./path/to/tests
  run: |
    npx playwright install-deps

- name: 🚀 Run Playwright
  working-directory: ./path/to/tests
  run: |
    npx playwright test

- name: ⬆ Upload report
  uses: actions/upload-artifact@v3
  if: always()
  with:
    name: playwright-report
    path: tests/playwright/playwright-report

mediaTypes:
  application/feed+json:
    suffixes:
      - json

outputFormats:
  jsonfeed:
    mediaType: application/feed+json
    baseName: feed
    rel: alternate
    isPlainText: true

This adds a new media type application/feed+json with the extension json and creates a new output format jsonfeed rendering into that media type with a base name of feed (so feed.json as recommended by the JSON Feed spec).

This then needs to be added to the outputs it should be generated for - on this page I’ve only added it to sections. Again, in config.yaml:

outputs:
  home:
    - HTML
    - JSON
  section:
    - HTML
    - RSS
    - jsonfeed

Finally, a template needs to be created so that Hugo can actually render something. I’ve put this into layouts/_default/list.jsonfeed.json (following the expected naming scheme of list.<outputFormat>.<extension>):

{{- $pctx := . -}}
{{- if .IsHome -}}{{ $pctx = site }}{{- end -}}
{{- $pages := slice -}}
{{- if or $.IsHome $.IsSection -}}
{{- $pages = $pctx.RegularPages -}}
{{- else -}}
{{- $pages = $pctx.Pages -}}
{{- end -}}
{{- $limit := site.Config.Services.RSS.Limit -}}
{{- if ge $limit 1 -}}
{{- $pages = $pages | first $limit -}}
{{- end -}}
{{- $title := "" }}
{{- if eq .Title .Site.Title }}
{{- $title = .Site.Title }}
{{- else }}
{{- with .Title }}
{{- $title = print . " on "}}
{{- end }}
{{- $title = print $title .Site.Title }}
{{- end }}
{
    "version": "https://jsonfeed.org/version/1.1",
    "title": {{ $title | jsonify }},
    "home_page_url": {{ .Permalink | jsonify }},
    {{- with  .OutputFormats.Get "jsonfeed" }}
    "feed_url": {{ .Permalink | jsonify  }},
    {{- end }}
    {{- if (or .Site.Params.author .Site.Params.author_url) }}
    "authors": [{
      {{- if .Site.Params.author }}
        "name": {{ .Site.Params.author | jsonify }},
      {{- end }}
      {{- if .Site.Params.author_url }}
        "url": {{ .Site.Params.author_url | jsonify }}
      {{- end }}
    }],
    {{- end }}
    {{- if $pages }}
    "items": [
        {{- range $index, $element := $pages }}
        {{- with $element }}
        {{- if $index }},{{end}} {
            "title": {{ .Title | jsonify }},
            "id": {{ .Permalink | jsonify }},
            "url": {{ .Permalink | jsonify }},
            {{- if .Site.Params.showFullTextinJSONFeed }}
            "summary": {{ with .Description }}{{ . | jsonify }}{{ else }}{{ .Summary | jsonify }}{{ end -}},
            "content_html": {{ .Content | jsonify }},
            {{- else }}
            "content_text": {{ with .Description }}{{ . | jsonify }}{{ else }}{{ .Summary | jsonify }}{{ end -}},
            {{- end }}
            {{- if .Params.cover.image }}
            {{- $cover := (.Resources.ByType "image").GetMatch (printf "*%s*" (.Params.cover.image)) }}
            {{- if $cover }}
            "image": {{ (path.Join .RelPermalink $cover) | absURL | jsonify }},
            {{- end }}
            {{- end }}
            "date_published": {{ .Date.Format "2006-01-02T15:04:05Z07:00" | jsonify }}
        }
        {{- end }}
        {{- end }}
    ]
    {{ end }}
}

By default, this generates a feed with summaries only. If you want a full content feed, set params.showFullTextinJSONFeed to true in config.yaml.

The relevant docs for custom media types, output formats and template locations can be found here.

On the Papermod theme the above will automatically cause something like

<link rel="alternate" type="application/feed+json" href="https://foosel.net/til/feed.json">

to be added to the head of the page, as needed for discovery. In other themes you might have to do it yourself.

The result of all of this is something like this.

Example: https://foosel.net becomes view-source:https://foosel.net.

echo $PREFIX | grep -o "com.termux"

This can also be used to set a variable in a Taskfile:

vars:
  TERMUX: '{{and .PREFIX (contains "com.termux" .PREFIX)}}'

Source

• Action: android.intent.action.SEND
• Cat: None
• Mime Type: text/plain
• Data: content://net.dinglisch.android.taskerm.fileprovider/external_files/path/to/the/file (be sure to replace /path/to/the/file with the absolute path to the file you want to open)
• Package: net.gsantner.markor
• Class: net.gsantner.markor.activity.DocumentActivity

Source

Source

OBS used for video conferences through the virtual camera. Audio virtualized and with active OBS filters applied (limiter, noise suppression) through means of setting the monitor device to a sink created with VirtualCable and using its source in the video conferences tools.

Problem

The camera feed has a slight delay of 300-400ms. The audio is thus ahead.

Adding a delay through OBS doesn’t get applied to the monitor device (Source):

The sync offset that you apply in OBS only applies to either the recording from OBS or the output stream from OBS. It does not apply to the monitor. When you use a virtual cable, and you set it up as a monitor in OBS, you will hear the inputs without any sync delay. As far as I know there is no way to apply your delays to the audio monitor output.

Solution

Install RadioDelay.

Create a second virtual cable device. Use its sink as the monitoring device in OBS, its source as source in RadioDelay, and set the sink of the first virtual cable as sink in RadioDelay. Apply the delay in RadioDelay.

The first cable now outputs delayed audio and can be used as audio source in the video conferencing tools.

You can also create a shortcut to fire up RadioDelay with the right devices selected, the delay applied and the output active with something like this:

"C:\Program Files\Radiodelay\radiodelay.exe" -delay 0.3 -in 5 -out 3

in and out are the positions of the audio device in the drop-down list. delay is the delay in seconds.

Can of course also be used without OBS.

edit 2023-03-11: Here’s how I solved the same problem under Linux.

function version_and_build_for_kernelimg() {
    kernelimg=$1

    # uncompressed kernel?
    output=$(strings $kernelimg | grep 'Linux version' || echo)

    if [ -z "$output" ]; then
        # compressed kernel, needs more work, see https://raspberrypi.stackexchange.com/a/108107
        pos=$(LC_ALL=C grep -P -a -b -m 1 --only-matching '\x1f\x8b\x08' $kernelimg | cut -f 1 -d :)
        dd if=$kernelimg of=kernel.gz skip=$pos iflag=skip_bytes
        output=$(gzip --decompress --stdout kernel.gz | strings | grep 'Linux version' || echo)
    fi

    version=$(echo $output | awk '{print $3}' | tr -d '+')
    build=$(echo $output | awk -F"#" '{print $NF}' | awk '{print $1}')

    if [[ -n "$version" && -n "$build" ]]; then
        echo "Version: $kernel"
        echo "Build: $build"
    else
        echo
        echo "Cannot determine kernel version and build number for $kernelimg"
    fi
}

Note that this has only been tested with kernels on RaspberryPi OS images, YMMV.

“Every 10min” is a cron trigger node that fires every 10min. “timestamp” is an inject node for triggering the flow manually.

“Starred repos for foosel” is an HTTP GET request against https://api.github.com/users/foosel/starred, set to return an object parsed from the response JSON. Change foosel to your own username.

The “Preprocess” function node has this source:

const key = "feed_githubstars_repos";
const repos = flow.get(key) || [];
const added = msg.payload.filter(repo => !repos.includes(repo.full_name));
flow.set(key, repos.concat(added.map(repo => repo.full_name)));

return {
    payload: {
        items: added.map(repo => {
            return {
                title: `${repo.full_name}: ${repo.description}`,
                link: repo.html_url,
                tags: ["github", "starred"]
            }
        })
    }
}

“Save in Raindrop.io” performs an HTTP POST request against https://api.raindrop.io/rest/v1/raindrops with authentication type"Bearer" and an API token created here.