Introduction

I keep my notes in an Obsidian vault. While Obsidian offers Obsidian Sync which syncs your notes to the cloud, I could not pay for it because I am a student. What I did was manually push my notes to my private GitHub repository every week. However, one day I was messing around with a shell script that used rm -rf and very stupidly did not test it. This resulted in the loss of three quarters of my notes.

After that experience all I wanted to do was to be able to have this backup process happen on its own and as frequently as possible. So, I came up with a simple solution: Performing the add, commit and push before the computer can shutdown. This way backups are extremely frequent and damage would be incredibly minimal. This is a suitable use case because I need to move around a lot and as a result I turn off my PC a lot. This means this pre-shutdown task would trigger very often.

I spent some time looking at options to achieve what I wanted and I managed to find a solution I'm quite happy with. Which is to leverage an init system called systemd.

What is systemd?

systemd is an init system. It is the first thing that runs when your Linux machine starts (it has a PID of 1). When it runs it will activate other components known as services and there are a lot of them—WiFi, audio, a lot of them. It also has various conditions it keeps track of. To configure a pre-shutdown task, I will leverage this by making a systemd service that runs when it detects the shutdown condition, in addition I can also specify certain things to be available such as WiFi, because an internet connection is required for this.

This is a super simplified version of what systemd is. If you’d like an accurate technical definition, refer to this article from the Arch wiki.

Creating systemd units

Tasks ran by systemd are called units and all units have the .service extension. These units are made by users and therefore must be placed in ~/.config/systemd/user/[^1]. Thank the Arch Wiki because there's a guide that tells you exactly how to write units. Based on the functionality desired I wrote a simple script (stored in ~/script to keep things simple) and then made it executable with chmod u+x <script>.[^2]

Keep in mind that this script can do literally anything you want, it doesn’t even have to be a .fish script, it can be a python script. Be creative, and see what works for you!

I named the unit backup.service and placed it in ~/.config/systemd/user. You can name it whatever you want, as long as it's name clearly describes its purpose. This is the content of the unit.

[Unit]
Description=Backup obsidian notes before shutdown
DefaultDependencies=no
Requires=network-online.target
After=network-online.target

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStop=fish /home/yjh/scripts/backup.fish

[Install]
WantedBy=default.target shutdown.target

It took me a while to figure out what the purpose of [Install] is and if you'd like to know more take a look at the man page for this.

There are a few items that relate to my use case of (1) running scripts before shutdown and (2) pushing a local repo to a remote repsitory.

• RemainAfterExit, ExecStop is for service units that will run scripts.

RemainAfterExit[^3] is a must for these service units as it won't even get into an active state it will always be dead.[^4]

• Requires=network-online.target

Requires= makes sure that network-online.target will be started if it isn't when this service unit activates. This is because to push to remote repository an internet connection is required.

• After=network-online.target

After= makes sure that network-online.target has started. If network-online.target fails to start for whatever reason the script will not be executed.[^5] This ensures that the script will only execute if there is an internet connection otherwise, nothing happens.

Something very important that I'd like to bring up is the help I received from dnaka and Freddy a unix user who helped me solve this issue. He also explained that if DefaultDependencies is removed then shutdown.target is implicitly included when the service unit is run!

Working around user input

After password authentication was shutdown in 2021, I decided to use SSH keys for authorisation. However, my SSH keys are password protected which means that user input is required. Inputs which I cannot give because when the system is shutting down the screen goes black. So, a way to circumvent this is to create a new SSH key and only use it for that specific repository. GitHub already has documentation on how to do exactly that.

Enabling the unit

After writing up the service unit they are not detected yet and systemd will need to know about them to do that run sudo systemctl daemon-reload. Then you'll need to enable it with systemctl --user enable <service> and there will be some output this is what I got.

Created symlink /home/yjh/.config/systemd/user/shutdown.target.wants/backup.service → /home/yjh/.config/systemd/user/backup.service.

I made some random changes and I restarted my PC. I looked at the repository through my phone and saw a new commit. A huge success!

Closing thoughts

This actually took me a while to deal with. I spent many hours on this and even skipped class, probably not a smart idea. I was in class sure, but I was at the back doing my own thing. Anyways, the moral of the story is

1. Don't run rm -rf without testing it first.

2. Automate backups for redundancy.

3. This let me gain more control over my device and it feels really, really good to be a master of my own device to such a specific degree, it is honestly awesome.

I implemented this about two years ago, and I've never been happier at my lack of data loss. I even manually backup my data once every few months to an external drive I carry around everywhere. I'm proud to say that if you threw my laptop into a volcano I would suffer no data loss!

[^1]: ~/.config/systemd/user/ where the user puts their own units.

[^2]: Along side the manuals and wikipages the article on running scripts with systemd by golinuxcloud was also very helpful.

[^3]: About RemainAfterExit will require some serching with CTRL+F.

[^4]: Type=oneshot and relation to RemainAfterExit. Will require some searching with CTRL+F.

[^5]: Detailed info on Requires=. Will require searching.