Barren, Frozen Wasteland

Updating Autohandbrake

Mon, 14 Nov 2022 14:00:00 +0000

A few years ago, I was ripping a large collection of DVDs, but I found the standard open source tool, Handbrake, to be very fiddly especially when ripping multiple episodes from the same disc or set of discs. To make my life a bit easier, I wrote AutoHandbrake, a script which attempts to identify whether a disk contains a single long title (likely a movie) or several similar-length titles (likely a set of episodes), then assists with naming and numbering the resulting files. The heavy lifting is done by HandBrakeCLI, which reads, rips and encodes the videos.

Since I wrote the tool, things have moved on a bit. DVD manufacturers often employ various tricks to bamboozle rippers: adding dozens of tiny titles, duplicate titles, putting titles in strange orders, or other tricks to make it hard to tell which titles you want to rip. At the same time, the rising populatity of Blu-Ray means that the HD version of a movie or show is often only a few quid more than the DVD, and even less when buying second-hand.

Both of these have led me to change my workflow when ripping disks. MakeMKV is not only capable of ripping Blu-Ray disks as well as DVDs, but has much smarter algoithms than mine for working out which titles on a disk are the ones you actually want. MakeMKV doesn’t do encoding, so I still rely on Handbrake to encode the ripped files and save on disk space.

This has required some changes to AutoHandbrake. I have added a new --directory option which allows it to by pointed at a directory of titles that have already been ripped by MakeMKV, rather than pointing it at a disk itself. In this case, it will list the files and treat them as a movie (if a single file) or a set of episodes (if multiple files), and use HandBrakeCLI to encode them as before.

As well as fixing a few bugs on the way, I discovered that gdialog which I use to provide GUI dialogs has been replaced with a wrapper for Zenity, a similar tool that doesn’t interface with the rdialog gem quite so nicely. I hope to find time to improve this, probably by detecting if we’re in a graphical environment and using a Ruby Zenity gem instead.

I also found that HandBrake is now using Flatpak as its primary means of distribution on Linux. This meant modifying the commands use to rip and encode titles. While it will still support using the HandBrakeCLI command however it is installed, it will prefer to use the flatpak using flatpak run --command=HandBrakeCLI fr.handbrake.ghb, unless you specifically tell it not to with --no-flatpak.

You can find AutoHandbrake on my GitHub page, and I will mention future developments on Mastodon.

Missing Linux save games on Steam Deck

Sun, 08 May 2022 14:00:00 +0000

I recently recieved my Steam Deck, and I have realised an odd quirk when installing some of my games. I’ve doing all my PC gaming on Linux for a long time, so when I installed Pillars of Eternity to carry on my current playthrough, I was a bit surprised to find that none of my save games were showing up.

I checked that Steam Cloud was working, and it told me that it was in-sync. I checked on the filesystem at .local/share/PillarsOfEnernity, and there were my savegame files, as they should be, but the game wasn’t seeing them.

I tried creating a new save game, quit and reloaded, and the game found it fine. What was going on?

The answer came when I tried searching for .savegame files in my home folder:

(deck@steamdeck ~)$ find . -type f -name "*.savegame"
...
./.local/share/PillarsOfEternity/SavedGames/cbd27084-3c24-4566-a371-ab09b4c175f2 quicksave.savegame
./.local/share/PillarsOfEternity/SavedGames/e21b6851-61ce-478a-8a0c-6392aa40cdf5 autosave_2.savegame
./.local/share/PillarsOfEternity/SavedGames/e21b6851-61ce-478a-8a0c-6392aa40cdf5 autosave_0.savegame
./.local/share/Steam/steamapps/compatdata/291650/pfx/drive_c/users/steamuser/Saved Games/Pillars of Eternity/cceab8afef9c4e4cbc58904c0f8d9667 7656277 Encampment.savegame
./.local/share/Steam/steamapps/compatdata/291650/pfx/drive_c/users/steamuser/Saved Games/Pillars of Eternity/cceab8af-ef9c-4e4c-bc58-904c0f8d9667 autosave_0.savegame

There were all my old save games in ./local/share/PillarsOfEternity, but my new ones were under a a completely different path. drive_c is the clue here, it’s under a WINE prefix! Checking the game’s files confirms that I’ve got the Windows build of the game installed, running under Proton.

(deck@steamdeck ~)$ ls -l .steam/steam/steamapps/common/Pillars\ of\ Eternity/
total 15624
drwxr-xr-x  2 deck deck     4096 May  8 14:47 Docs
drwxr-xr-x  2 deck deck     4096 May  8 14:47 EmptySteamDepot
-rwxr-xr-x  1 deck deck   188416 May  8 14:46 GalaxyCSharpGlue.dll
-rwxr-xr-x  1 deck deck  3824640 May  8 14:47 Galaxy.dll
drwxr-xr-x  2 deck deck     4096 May  8 14:47 Links
drwxr-xr-x 10 deck deck    20480 May  8 14:48 PillarsOfEternity_Data
-rwxr-xr-x  1 deck deck 11632128 May  8 14:39 PillarsOfEternity.exe
-rwxr-xr-x  1 deck deck   187584 May  8 14:47 steam_api.dll
-rwxr-xr-x  1 deck deck        6 May  8 14:47 steam_appid.txt
-rwxr-xr-x  1 deck deck   126976 May  8 14:47 SteamworksNative.dll

One solution would be to copy the old saves into the WINE prefix, meaning the Windows build should see them. This assumes that the Linux save files are compatible with the Windows version of the game, so your mileage may vary.

Forcing Steam Deck to install the Linux build

The other solution which I have found works well for the games I’ve tried, is to force Steam to install the Linux build, rather than using Proton.

To do this:

Find the game in your Steam library, go to the “cog” icon on the right, then select “Manage > Uninstall”.
Click the “cog” icon again. Go to “Properties > Compatibility”.
Check “Force the use of a specific Steam Play compatibility tool”.
Select “Steam linux runtime” from the list.
Go back and install the game again. You will now have the Linux version installed.

Why is this happening?

It came to me as a surprise that games with a native Linux build would have the Windows build installed by default. Especially as this isn’t true for all games. In my brief experimentation, I found that Pillars of Eternity and Nuclear Throne both behave this way, but Wildermyth does not, and installs the Linux build by default.

One possibility is that the former 2 games have a Steam Deck Compatilbity rating, where Wildermyth does not yet. Valve have undertaken a big task in testing the Steam catalogue for Deck compatibility. As many games they are testing require Proton, they may have decided to do all their testing via Proton, and once they have verified a game it will default to the version of Proton it was verified on.

This does make me curious about Valve’s strategy for Linux compatibility. I has assumed that Proton was intended as a gateway to show developers that Linux was a viable platform, to encourage them to produce native builds. But, if “Steam linux runtime” is just one on a list of compatibility tools, and Proton is the default, maybe the strategy is instead to make Proton the preferred option for running games on Linux?

Software RAID on Ubuntu 20.04

Sun, 03 Apr 2022 19:00:00 +0000

I recently decided to rebuild my HP Microserver, replacing the NAS appliance I use with extra disks in the microserver configured as a RAID 5. There are various guides online for the commands to set this up manually with mdadm, but as part of the rebuild I upgraded the Ubuntu OS to version 20.04, which presented a much nicer option. Following the upgrade, the login prompt included a message directing me to a web console at https://hostname:9090, which is using Cockpit.

Setting up RAID with Cockpit

Cockpit provides a modern web interface for a number of common but complex server administration tasks, including setting up networking and storage devices. Logging in an navigating to Host > Storage will provide a comprehensive overview of disk I/O, mounted filesystems, available devices, and more.

Creating a RAID with Cockpit is very straightforward. From this screen, click the hamburger menu by the “Devices” heading, and select “Create RAID device”. You’ll be prompted for a name, the RAID level, and a chunk size, then you simply check the boxes next to the drives you want to use, and click “Create”. Drives that are already in use won’t be listed, so no need to worry about accidentally formatting the wrong drive.

Once the RAID is created, you will see the progress of its set-up job. This may take several hours depending on the size and set-up you are creating, so you can check back on this page to see how it is going. While this is going on, you can also use cockpit to create your filesystems.

Click on the newly created RAID device and you’ll see a page listing the configuration, disks, state and content. The new device will be empty, so clicking “Create Partition Table” will let you define your new partitions in a similar manner to a graphical partitioner like GNOME Disks or gparted. In my case I followed the defaults and created a single XFS partition, but you may want to set up multiple partitions, LVM, or LUKS-encrypted partitions, which are all supported. You can also mount the new filesystem right from the web console.

Under the hood, this is all using mdadm, for which the Arch Wiki RAID page provides lots of in-depth information on configuration and maintenance, but for basic set-up and monitoring, this web console is all you need.

Cockpit has set a new bar for me in linux server administration. It’s a massive step up in terms of discoverability, and making those complex operations a lot less scary. I look forward to using it more in the future.

Having fun isn't hard, when you've got a library card

Tue, 24 Aug 2021 21:00:00 +0000

I’ve recently found myself guilty of doomscrolling. When I have a spare moment, I’ll pick up my phone and mindlessly scroll through Twitter, or a news website, and read or re-read about the most horrible things that are happening in world today. I caught myself doing it, and I wondered how much of my time I’m wasting on things other people want me to read, rather than choosing to read things I’m actually interested in.

When I was a kid, I used to subscribe to magazines. One in particular was NGC, an unofficial Nintendo magazine from the Gamecube era. Remembering their website, gamesradar.com, I went to see what’s there now and found an article from Retro Gamer magazine about the making of TimeSplitters, a series of games I owned and loved. The experience of finding and reading something because I wanted to was a joyful and calming feeling.

I recently discovered an app called Libby, made by a company called Overdrive. Libby is a digital library catalogue, which offers you eBooks, audiobooks and magazines for free through your local library. You just sign up with your library card. After reading their article, I searched for Retro Gamer in Libby and subscribed. I also found some other magazines in the technical, gaming and music categories that I’d bought before, and subscribed to them, all for free. I decided that instead of opening Twitter in my moments of downtime, I’d open a magazine.

Using Libby is an excellent experience. Magazines can be viewed as a digital version of the print layout, scrolled and zoomed, but you can also select the articles on each page to have them presented in a re-flowed “reader” view, like you see on most modern web browsers. As I’m mainly using Libby on my phone, this works very nicely.

Libby can be installed on your mobile device, but it’s also a web app. Going to libbyapp.com gives you 90% of the same experience, and it syncs between devices. I can’t recommend it highly enough.

Reading a publication designed for A4 sheets of paper on my phone, I of course started mulling over the possibility of a tablet or e-reader for this purpose. But the reason this works so well for me is that my phone is pocketable, so its always there in those moments of downtime.

The app aside, reading magazines again is a breath of fresh air. In the 15 years since I last had a subscription, the web has become an appalling place to consume content (the irony is not lost on me, dear reader). A million things are trying to take your attention, get your consent, harvest your email address, get you to go to this page instead of this one… with a magazine, it’s just you and an article.

Migrating password store to self hosted Bitwarden

Sun, 04 Apr 2021 21:00:00 +0000

I’ve been using password store to manage my passwords for several years. I really like its simplicity, it’s just a shell script that relies on gpg and git to handle the encryption and synchronisation. However, the apps and browser extensions are all third-party, so are of varying quality. Also, using it across devices requires you to manage your gpg keys across those devices, something I’ve never managed with 100% success.

I’ve been hearing a lot about Bitwarden recently. It’s another open-source password manager with free, premium, hosted or self-hosted options, it doesn’t rely on gpg and the apps are developed by the same project, so are far more consistent. I thought I’d give it a go!

Self-hosting Bitwarden is fairly involved, it’s not just “snap install bitwarden”. However, it’s a very well documented process and I didn’t have any issue getting it running after an evening’s tinkering. The result is a cluster of about a dozen docker containers, which provide a web UI and the API for any apps.

As with my other self-hosted services, I have this running behind an nginx reverse proxy to have everything running over HTTPS on standard ports.

This all worked well, but I am running it on my HP Microserver and it was feeling the strain a bit. Running 12 containers including an mssql database might make sense if you’re running a service that needs to scale up to serve a company’s users, but for a single user or a few family members it’s a bit excessive.

Luckily there is an alternative. Bitwarden_rs is a third-party implementation of the Bitwarden API, so its compatible with the apps, but it runs as a single, much lighter container and uses SQLite by default. Also very well documented, I set it up to run on boot using systemd-docker. I mapped the container to the same port as I had the original Bitwarden, so my nginx config pointed at the new service with no changes.

To migrate from pass, I used pass2csv to output all of my passwords to a CSV flatfile. I then used this script from github to convert the file to be bitwarden-compatible, and imported through the web interface. The script is written in javascript so runs with nodejs, and requires the fast-csv package to be installed through npm.

When switching from Bitwarden to bitwarden_rs, the new service doesn’t know about users and password stores imported to the original service. To handle this migration, I used the web interface to export an import in Bitwarden’s own JSON format.

Image credit: Safe by Rob Pongsajapan

Syncing Rocketbook to Nextcloud notes

Fri, 22 Jan 2021 21:00:00 +0000

In an effort to write more often and more legibly, I recently bought myself a Rocketbook Core, an erasable pen-and- not quite-paper notebook with a companion app. The app will scan your notes and send a cloud service of your choice. For work, OneNote is supported which suits me fine. However, at home I use the Nextcloud Notes app to keep my notes on my own server, which stores notes in .txt files and gives you a markdown-aware editor on web and mobile.

There is a beta Rocketbook app with Nextcloud Support, but it relies on WebDAV and I couldn’t get it working, so I decided to roll my own. The first step is to share my notes via email. I set it to a dedicated address with OCR transcription enabled.

On my Nextcloud server, I run the following script :

!/bin/bash
MAILDIR=$1
DESTINATION=$2
offlineimap
mkdir /tmp/rocketbook
cd /tmp/rocketbook
for i in `ls $MAILDIR`
do
    munpack $MAILDIR/$i
    rm $MAILDIR/$i
done
rm ./*.desc
mv ./* $DESTINATION
rm -rf /tmp/rocketbook
offlineimap

The heavy lifting is done by offlineimap and munpack.

offlineimap will syncronise your email account to a local directory in my case I configure it to sync a single folder. My offlineimap config looks like this:

[general]
accounts = Rocketbook

[Account Rocketbook]
localrepository = Local
remoterepository = Remote

[Repository Local]
type = Maildir
localfolders = ~/Rocketbook

[Repository Remote]
type = IMAP
remotehost = mail.xxx.net
remoteuser = xxx@barrenfrozenwasteland.com
remotepassfile = ~/.imappassword

sslcacertfile = /etc/ssl/certs/ca-certificates.crt

munpack will extract the parts of an email (such as attachments) into separate files This gives me a .pdf containing the image, a .txt file containing the transcribed text, and and the email body in a .desc file which I discard. At this point, you could use the txt and pdf files however you like. I move these files to Nextcloud’s Notes folder, delete the email and re-run offlineimap to sync the deletion. The script runs on a cron job to check for new notes every 5 minutes.

How well does it work? I hand-wrote this blog post, so if you’re reading it, it worked pretty well!

Using a Steam controller with the Nintendo switch

Sun, 01 Nov 2020 21:00:00 +0000

I have been playing Hades a lot recently on my Switch. I’ve had the switch for a couple of years ago, but the long sessions of Hades are the first time I have been dissatisfied with the Joy-cons. The Pro Controller is highly reccommended by Switch fans, but I don’t have £55 to spend on a new controller right now, so I started wondering if I can use my current favourite controller, the Steam controller on the Nintendo Switch.

The answer came from the OpenSteamController project on GitHub. The project contains several different threads and lots of documentation, so I’ve pulled together just the bits you need to make make this possible.

You will need:

A steam controller.
A USB-A to micro-B cable, long enough to reach your Switch from your chair.
A computer.
The OpenSteamController firmware, configured for the Switch: OpenSteamControllerNinSwitch.bin

Steps:

Hold the right trigger of your Steam controller, and connect it to your computer with the USB controller. This will put it in USB programming mode, and show up as a USB storage device called “CRP DISABLD”
Back up the default firmware.bin file. On Ubuntu, run dd "if=/media/$USER/CRP DISABLD/firmware.bin" of=~/backup.bin. On other platforms, consult the Loading Firmware documentation.
Load the custom firmware. On Ubuntu, run dd conv=nocreat,notrunc oflag=direct bs=512 if=OpenSteamControllerNinSwitch.bin "of=/media/$USER/CRP DISABLD/firmware.bin"
Unplug the USB cable from your computer, and plug it in to the Switch’s dock. Press L+R to connect, it will show up as a generic “USB” controller. You’re ready to play!

A few things to be aware of about this solution:

This process isn’t supported by Valve, Nintendo, me, or anyone else. Proceed at your own risk.
The current firmware doesn’t support connecting to the Switch via Bluetooth, you must use a USB cable.
The controller won’t work with Steam while using the custom firmware. You can restore the original firmware by running step 3 above with backup.bin as the input file.
The A and B buttons on the Switch and Steam controllers are the other way around, so the Steam controller button labelled “B” will function as “A” on the Switch, and vice-versa.
The right hand touch pad (which operates as the right stick) is quite sensitive, it will sometimes detect your thumb when you press a button next to it if you aren’t careful.

How (not) to calculate student grades

Fri, 14 Aug 2020 21:00:00 +0000

In my first job out of university, I had the task of developing a tool to calculate “minimum target grades” for FE students based on GCSE scores and regression statistics. These grades would be used by teachers as a basis for setting target grades for their students.

I’m no statistican. When I did my maths A-level I chose Decisions for my applied units. However, looking at the regression statistics, began to notice that some some of these statistics looks suspect. Some of the sample sizes were tiny. Some of the standard deviations were larger than a whole grade boundary.

After realising this, I felt like it would be irresponsible for me to use these datasets to calculate target grades. I built safeguards in to the system so that it wouldn’t calculate grades if the data was of insuffient quality, and target grades would have to be determined by other means.

I hope that anyone designing algorithms to determine students’ final grades would take a similar level of care.

Image credit: “Exams 10” by charbeck10 is licensed under CC BY-NC-SA 2.0

Hosting your own cloud, 2019 edition

Sat, 13 Jul 2019 13:00:00 +0000

It’s been a long time since I first wrote about self hosting “cloud” services to avoid reliance on third party companies that harvest your data. Things have moved on a lot since then, so I thought it was about time to write about my current set-up.

Hardware

I’m still running the same HP Proliant Microserver that I have for years. I’ve upgraded the RAM and added an extra gigabit ethernet interface. The big change is how I handle my storage.

Rather than using software RAID on the microserver, I now have a separate RAID appliance. I’m using a Neatgear ReadyNAS Ultra 4 with 4 2TB disks. This gives me total usable storage of around 5TB.

Since the server and NAS each have 2 gigabit network interfaces, as well as having them both connected to my LAN, I also have them directly connected together. I then mount the NAS volume on the Microserver using this dedicated connection, to avoid any contention from other network traffic when accessing the storage.

Server software

The Microserver is running Ubuntu 18.04 LTS, which will come as no surprise to anyone who knows me. I have Nextcloud installed using the snap package, which keeps it contained an updated. Since I am using the NAS for my storage, I had to allow the Nextcloud snap to access removable media using the following command:

$ sudo snap connect nextcloud:removable-media

With my NAS mounted at /media/nas, I can then use Nextcloud’s external storage plugin to make folders on my NAS available to Nextcloud, using the “local” option.

The Nextcloud snap has its own instance of the apache web server, running on port 80 by default. Since I might have other web apps running on the server, I changed this to port 8080 (instructions in the snap readme linked above), and set up nginx as a reverse proxy. This allows me to access nextcloud at http://myserver/nextcloud/. The nginx configuration to make this possible goes in /etc/nginx/sites-available/default.conf and looks like this:

location /nextcloud/ {
    proxy_pass http://localhost:8080/;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

I am also using the Nextcloud Contact and Calendar apps, to provide me with a CalDAV and CardDAV server.

Alongside Nextcloud, I want a way of serving my media so that I can stream music and video from my server to whereever I am without having to sync it. I have tried various solutions for this in the past including the Owncloud music app, Ampache, and Emby, but I am currently using Plex. Sadly Plex is not open source. I was using Emby for a long time because it was open source, but when they changed their licensing this advantage went away. Testing Plex as an alternative, I found it to be slightly better in every conceivable way, which makes it much better overall. They key is that I can still run it on my own server, and keep my data on my own hardware rather than having to upload it to someone else’s service or rely on a subscription to another company’s library.

Client software

On my laptop, I am using the offical Nextcloud client to synchronise my files. In the past, the official OwnCloud and Nextcloud clients weren’t up to the task when it came to syncing large volumes of data, so I used alternative solutions such as Bittorrent Sync and Syncthing. However, these days the modern Nextcloud client works like a charm. It gives the option to choose which folders are synced to which device, so I exclude some folders such as my video collection from syncing to my laptop. I could still access these files via WebDAV if I needed to.

On Ubuntu 19.04, you can add your Nextcloud server in the “Online accounts” settings, which will provide integration with the desktop calendar and add a shortcut in the file manager to view and access your files via WebDAV.

On on mobile, I again use the offical Nextcloud app, which doesn’t sync your files automatically but does download them on demand. It also has an “instanct upload” feature which will watch configured directories for new images, and automatically upload them to the server. To synchronise the calendar and contacts, I use DAVx⁵.

Plex allows you to play media through its web interface using any browser, and also has native apps for many platforms, some of which require payment. The option I’ve found most effective is to run Kodi with the Plex plugin, which is free and gives you full access to stream your media. I am currently running this on my steam box/HTPC for video, a Joggler for music, and laptop (with Kodi in windowed mode) for music. It’s worth noting that the client is just for consuming your media. If you want to manage your library or edit playlists, you need to use the web interface.

Configuration

A key part of this solution for me was being able to point my devices at my server a to access my data from anywhere, while avoiding a round-trip via the Internet when I’m at home with my server. In order to do this, I need my server to be accessible to the Internet, on a domain name that I control. However, have a regular domestic ISP without a fixed IP address.

The first part of this solution is to make my web server available to the Internet. Since I’ve got nginx running on port 80, this is a simple case of configuring my router to allow inbound traffic on port 80, and forward it to my server’s internal IP address. I did this through the web interface on my ISP’s router.

The next thing to do was set up dynamic DNS, which provides me with a domain name that will always point to my current public IP address. There are several providers for this type of service, but I went with afraid.org. This gives me an address like mydomain.afraid.org which will always point to my home. Putting http://mydomain.afraid.org/nextcloud/ into a web browser now gives me the Nextcloud login page.

With my data available over the Internet, I needed to set up HTTPS so that it’s all encrypted in transit. LetsEncrypt is a free service that will issue you a certificate and configure your web service to use it, with its certbot tool. You can even set up a cron job so that it will auto-renew your certificate when needed. However, since mydomain.afraid.org isn’t owned by me, I can’t (or at least, should’t) get an SSL certificate for that domain.

I already own a domain name that is registered with Gandi who I’d definitely recommend for good value and features. In my DNS settings, I have set up a CNAME record, which allows me to point myserver.mydomain.com to mydomain.afraid.org. This means that myserver.mydomain.com will now always resolve to my home IP address, and going to http://myserver.mydomain.com/nextcloud/ gives me access to Nextcloud.

Now I’ve got my own domain name pointing at my server, I was able to use certbot to issue a certificate for that domain and configure nginx, allowing me securely access to Nextcloud over the Internet.

This is fine when I’m not at home, but if I connect to myserver.mydomain.com, all the traffic will be routed via my Internet connection, rather than just over my LAN, which will slow things down. When I’m connected to my LAN, I want myserver.mydomain.com to go straight to my Microserver’s LAN address.

To do this, I have dnsmasq installed on my Microserver, which provides local DHCP and DNS services. I have turned off DHCP on my router, so whenever a device connects to my LAN, it will get its IP address from dnsmasq. The DCHP configuration will also tell the device to use the Microserver as its default DNS server. In dnsmasq’s DNS records, I then point myserver.mydomain.com to the Microserver’s LAN IP address. With all this configured, when I am connected the LAN, requests to myserver.mydomain.com stay within the LAN, but if I’m somewhere else they find their way over the Internet. The dnsmasq configuration to achieve this looks something like this:

interface=lo
bind-interfaces
listen-address=127.0.0.1
listen-address=192.168.0.10
server=1.1.1.1 # Upstream DNS servers for other domain names
server=1.0.0.1
address=/myserver.mydomain.com/192.168.0.10
dhcp-range=192.168.0.50,192.168.0.150,12h
dhcp-option=option:router,192.168.0.1

Plex is a bit awkward. The supported way to access your Plex server over the Internet is to enable the “Remote access” feature, then access your server via the plex.tv web client. It can’t be configured to use an address like myserver.mydomain.com/plex, since it expects to be running at the root of the server, and it doesn’t like it if it’s in a subdirectory. To get around this, I set up a second CNAME record, plex.mydomain.com, a second SSL certificate with certbot, and a second “site” in nginx. This now makes plex.mydomain.com the universal address for my Plex server.

New year, new website

Sun, 27 Jan 2019 13:30:00 +0000

For about 10 years, I’ve had my website hosted by Surpass Hosting, and served my blog variously with Drupal, Wordpress and manually crafted static pages. Unfortunately, Surpass no longer offer the package that I originally signed up with, and the cheapest package the offered me was double the cost I have been paying. On top of that, they were charging me over $20 to renew my domain name. Given that I only host a simple blog and an old fansite, it was time to move to something simpler and cheaper.

I’ve already had experience building a website with Jekyll, and using this removed the need for me to find a host that provided a database and scripting language like PHP. Jekyll builds your site as plain old HTML.

Since my old website was using Wordpress, I needed to extract it to something Jekyll-friendly. Of course, someone’s already done the work for me. I installed the Jekyll exporter plugin for Wordpress, and was able to download my whole site as static HTML files, that I could add to a fresh Jekyll site. As the site had been previously converted from Drupal, I needed to do a bit of find-and-replace across the site to standardise all the metadata.

I had heard that AWS S3 was a good choice for hosting static websites. While it’s primarily intended for file storage for cloud applications, it also supports serving files over HTTP using a simple webserver. However, it seems that S3 is only really designed to be accessed programmatically. While command line tools exist and its possible to mount an S3 filesystem locally, building a Jekyll locally site and syncing it to an S3 bucket is not a simple process. Furthermore, the limited nature of the webserver it provides made it difficult to achieve what I wanted.

After looking at some other hosts, I decided that GitHub Pages was the simplest solution. You can enable Pages on any public repository, and Jekyll will automatically compute your site when you push a new commit. This does limit you to the basic Jekyll software without plugins, but you can use it with your own domain name, it supports HTTPS, and its free.

Finally, I needed a new domain registrar and email host. After asking friends for some recommendations, I settled on Gandi. Along with your domain, you get a straightforward DNS interface and subdomain redirects (so you can point www.yourdomain.com to yourdomain.com, for example). You also get email with Sieve support, and alias that support wildcards, so you can make unique addresses for each service you sign up to, and filter them as required.

This whole solution costs me about £10 a year, where my previous solution cost me around £40, and was going up to something closer to £100.