rzg

Basic Tips for Data Entry on Spreadsheets

Tue, 03 Jan 2023 00:00:00 +0000

Spreadsheets are a quick way of entering tabular data. Usually, it is done as a “temporary” measure, until someone comes and turns it into a proper database. Sometimes, it is used as an intermediate structure for future extra processing.

Whatever the scenario, there are some mistakes that occur so consistently, that they cause a lot of problems later on, and will need a lot of rework before they can be made machine readable.

Here are some basic tips, and what not to do when entering data on a spreadsheet.

Do not enter the full name in one column

Possibly the most common issue. The person’s name, last name, middle name, father name, all entered in the same cell.

Why is this a problem?

Even if they are entered correctly, names are very non standard, some people have multiple first names or last names, some names are multi word. Sometimes parts of it may be missing, like father for some, first name for others. Overall, it is near impossible to separate these later, without manual intervention.

Solution:

Have separate columns for first name, family name, father name, mother name, or any other name information that you have. If the information does not exist for an entry, simply leave it blank.

As a general rule, each column/cell should contain only one piece of information.

Do not enter the date of birth in one column

Despite the name, in practice, a date of birth is not really a full proper date. Mostly because some piece of information may be missing. For example, with personal data, it is very common for some people to have missing day and/or month values.

Why is this a problem?

Assuming missing days or months to be 1 will be introducing wrong information. The person may actually be born on day 31 of month 12, causing an error of one full year. Moreover, it will then be impossible to differentiate them with people actually born on 1/1.

Solution:

The solution is to have separate columns for the three, and keep them empty or 0 in case the information is missing.

This applies to any date information, that may not have all three components for every case.

Enter dates in ISO format

The ISO-8601 standard defines date and time formats that are unambiguous, and understood by humans and machines alike.

For dates, it comes down to the following format: YYYY-MM-DD. For example, 2022-12-01 corresponds to the first of December 2022.

Why is this a problem?

There are two mainstream date formats, that are directly contradictory to each other. These are DD/MM/YYYY and the infamous MM/DD/YYYY. To make matters worse, spreadsheet programs try to assume the formats of the date columns, by relying on the localization settings of the operating system where the file is opened.

For example, if a file was written on a system set to MM/DD/YYYY, opening it on another one set to DD/MM/YYYY will interpret the dates incorrectly, some of them not even registering as dates.

Related issue, is that people operating on the data will not know which format is used, especially when dealing internationally.

Solution:

Use the YYYY-MM-DD format described above. It will be understood by programs, and can be exported and imported safely.

Related tip:

Always use the ISO-8601 format in CSV or other text files, that you need to import into spreadsheets. It is the only format programs will correctly convert to dates.

Do not enter explanations and elaborations

Usually happens with a combination of the first mistake, and a typical example is something like: “Name (couldn’t read the last name)”.

Solution:

If you need to convey information, that some data was illegible, put it in a dedicated column, if it is obvious and happens systemically. Or, if you need to write a lot, have a notes column. In both cases, this will be a column made obviously for manual processing.

Do not highlight by colors

A lot of times, after data entry is completed, people come back to it and start coloring some lines in red, green, blue, yellow, etc, indicating some status the data of that line has achieved.

Why is this a problem?

While some programs may be capable of filtering or sorting by color, it is an information that does not get exported, and it cannot be post-processed without extra steps. Moreover, the meaning of the different colors is not inherent and could be lost over time.

Solution:

Add columns for status, action, etc, and enter the information there as codes. You can still use colors as an additional visual indicator, or use the conditional formatting capabilities available in most programs, that will let you color based on the values of the cell.

Personal File Hosting Service with SFTP on OpenBSD

Sun, 03 Oct 2021 00:00:00 +0000

I’ve used Nextcloud for file hosting, calendar and contacts services, since its very first release. However, I recently had to downgrade my large servers, and found myself lacking resources for running a hungry service like that.

Goal

To have an “offsite” backup of my documents, and to be able to view them on a phone. The documents are read-only on the server, and the synchronization is one way, local to server.

Create a dedicated user for file hosting

Since sftp implies ssh access, we need to restrict things as much as possible.

Thankfully, OpenSSH has an easy way of achieving this, by forcing an sftp only mode on a user, and confining it to a directory.

Which means we need a dedicated user on the server for the file store.

useradd -m syncuser

Restrict SFTP

Create a new root directory:

mkdir /chroot

Add to /etc/sshd_config the following:

Match User syncuser
    ForceCommand internal-sftp
    ChrootDirectory /chroot

This will disable ssh login for syncuser, and restrict sftp to the directory /chroot.

Mount file storage directory

We can keep our files directly under /chroot, however it’s likely we don’t have that much space in the root partition, especially if we followed the standard OpenBSD installation.

To solve this, we can create a sync directory under our user’s home, and mount it to /chroot with nfs. As an extra, mounting it with -ro will make the share, and thus our sftp server, read-only.

mkdir /home/syncuser/sync
mkdir /chroot/sync

rcctl enable portmap nfsd mountd
echo "/home/syncuser/sync -network=127.0.0.1 -mask=255.255.255.255 -ro" \
    > /etc/exports
rcctl start portmap nfsd mountd

mount localhost:/home/syncuser/sync/ /chroot/sync

Sync files

Synchronization of our files from the local to the server can be done with rsync. However, since we don’t have regular ssh to syncuser, we need a workaround.

The solution is to send the files using another user (for example privuser) with regular ssh access, while running rsync on the server as syncuser through rsync-path:

rsync --rsync-path 'doas -u syncuser /usr/local/bin/rsync' \
      -ar --delete \
      /home/localuser/sync/ \
      <privuser>@<server>:/home/syncuser/sync/

The above requires a rule in doas:

permit nopass privuser as syncuser cmd /usr/local/bin/rsync

As mentioned before, this is just a one-way sync. For two-way sync, the tool unison may do the job.

View on phone

To view and open the files on a smartphone, we need an application that can access sftp. The Android file manager that I use, “Material Files”, already has this capability.

Material Files

Conclusion

The gain from all this, is that we can now access the sftp server through the restricted syncuser, without needing access to privuser on the phone.

Sources

Change git commit Authorship with git-filter-repo

Sat, 25 Sep 2021 00:00:00 +0000

Recently, I needed to change the email address on all commits in most of my personal git repos.

Searching on the web, there are a few methods of doing this, most involving git rebase. There are also some that use git-filter-branch.

Interestingly, applying git-filter-branch puts out a warning/recommendarion to use git-filter-repo instead, which is what I ended up doing in the end.

Important to note, that all of these methods will rewrite the whole commit history, and change all the hashes. Since, I am the sole committer here, I wasn’t too much concered about that. Needless to say, take backups!

Installation

git-filter-repo is not included in a standard git package. It is available on most Linux distributions though.

# Arch Linux
pacman -S git-filter-repo

# OpenSUSE
zypper install git-filter-repo

Procedure

Before doing anything, taking a full backup of the repo is a must!

# clone a temporary fresh bare repository
git clone --bare <repo>

# change the email and name on all commits
git filter-repo \
    --email-callback 'return b"test@example.com"' \
    --name-callback 'return b"testname"'

# push with force
git push --force

# remove temporary repo
rm -rf <repo>

# clone the fixed repo
git clone <repo>

git-filter-repo

Floating and Sticky Windows in BSPWM

Sun, 09 May 2021 00:00:00 +0000

BSPWM is a tiling window manager, with various interesting and unique features that I haven’t seen anywhere else. One of these features is sticky floating windows.

A sticky window, is one that persists on all workspaces all at once. In other words, once you mark a window as ‘sticky’, it will stick to its place even when you switch to another workspace.

This feature works best with floating windows, because a tiled window will behave unpredictably on another workspace with existing tiles.

We can make windows floating and sticky, manually, with the following commands.

# set to floating
bspc node -t floating

# set to sticky 
bspc node -g sticky

Obviously, these can be mapped to keys with sxhkd. But, we can also define rules, to set these properties automatically with bspc rule.

These rules work based on the window class and instance names, which we can retrieve using xprop. Look for WM_CLASS and WM_NAME.

At first glance, it may not seem obvious what this may be used for, so here are a few of the ways that I used it.

MPV

I have an ultrawide monitor, so it works well for me, to send all mpv windows to a corner of my screen. Moreover, I can freely switch between workspaces while still keeping the mpv screen in view. This can also work with the Firefox Picture-in-Picture window.

Here is the relevant bspwmrc config:

bspc rule -a mpv \
     state=floating sticky=on follow=off focus=on \
     rectangle=640x360+2760+1040
bspc rule -a "*:Toolkit:Picture-in-Picture" \
     state=floating sticky=on follow=off focus=on \
     rectangle=640x360+2760+1040

Onboard

Onboard is an onscreen keyboard. I use it on the desktop for typing words in languages that I don’t know, but sometimes need.

bspc rule -a Onboard state=floating sticky=on

Terminals

There are some terminal based programs, like volume controls or calculators, that this may apply as well.

But, since we don’t want all terminals to open floating and sticky, we need to define our own class when running, and map our rule to this class only.

Here is my sxhkd definition, for terminal based programs that I intend to run as sticky/floating.

super + x ; {c,v}
    alacritty --class progterm -e {qalc -nocurrencies,pulsemixer}

And the rule in bspwmrc:

bspc rule -a Alacritty:progterm state=floating sticky=on

Note, that other terminals may use different switches for the class, for example xterm is -class.

About my Armenian Keyboard

Fri, 30 Apr 2021 00:00:00 +0000

I’ve been getting questions and comments about my Armenian keyboard picture lately. So, it’s probably time to write a post about it!

Background

The Armenian language has its own alphabet. This means, Armenians either have to memorize the places of the letters, use a roughly phonetic layout matching the Latin letters, or stick labels on every key. Needless to say, sticking labels will soon get very messy, some of them will be lost, leaving the keyboard with glue residue all over.

While I haven’t encountered any (I have searched), I’m sure there must be printed keyboards available in Armenia. But, those will likely be generic cheap keyboards. So, how to achieve something very custom looking and unique like this?

mechanical keyboard with custom keycaps

The key terms are: “mechanical keyboard”, “custom keycaps”.

Mechanical Keyboards

Mechanical keyboards are a world of their own, with serious communities and many hobbyists. Moreover, there seems to be a boom in YouTube channels lately.

To get an idea about what it encompasses, the Mechanical Keyboards subreddit is probably the best place to start, with lots of pictures and information.

The Mechanical Keyboards subreddit

While I do own four such keyboards, I wouldn’t consider myself a hobbyist yet, and I’m certainly not an expert. So, I will try to stick to the basics, and not give incomplete or false information. Mechanical keyboards can be costly, and they require individual research and a bit of understanding before diving into them.

Switches

Probably the most important and defining component of a keyboard are the switches. There are three main categories, clicky, tactile and linear. Going into all the differences and people’s preferences is a huge task, so this part is left to every person to do their own research. These days, there are thousands of videos, demonstrating every switch ever made.

The keyboard in the picture is a “Vortexgear Poker 3 (Pok3r)” with “Cherry MX Clear” tactile switches.

Custom Keycaps

Mechanical Keyboards are very customizable. Almost all of them, regardless of the switch type, will have replaceable keycaps.

Keycaps are sold separately, and as long as they are compatible with your switches, they will be replaceable. For example, Cherry and its compatible switches will work with their corresponding keycaps.

Other than the compatibility, there is another important factor to consider, and that is the keycap profile. For example, there are keycaps where all the rows are of identical heights and sizes (like DSA), and others where each row is different.

However, we want a bit more than replacement keycaps, since we want to design our own labels. We need keycap sellers, that also provide services for printing custom labels. One such seller is WASD, which is where I got mine from. They sell these keycaps either separately, or together with a keyboard.

WASD Custom Printed Keyboards

Layout

Finally, a note about the layout.

I thought a lot about what layout to go for, especially since the keys cannot be rearranged due to the differing heights of the rows. In the end, I went with “Western Phonetic”, because this is not the only keyboard I use, and on keyboards with no printed letters the phonetic one is the easiest to remember.

Others can of course do their own layouts, whether it be “Eastern Phonetic”, the traditional “Typewriter”, or something else.

In conclusion, I would love to see many more such keyboards! I claim that this is the only exclusive Armenian one, but if you have made your own Armenian keyboard, I would like to see it as well :) Feel free to send it to contact@rzg.one.

Switch Keyboard Layouts with Mouse Buttons and sxhkd

Sun, 11 Apr 2021 00:00:00 +0000

Switching keyboard layouts quickly and efficiently has been a long-standing problem for me. My latest attempt is by utilizing the extra buttons, that some mice and trackballs have.

The solution that eventually worked for me, was switching between two layouts for every button. The decision to switch is made based on the current active layout.

This allows me to switch between the second and third layout, by pressing the corresponding buttons, without going through the default layout.

Getting the current layout was surprisingly involved though, and I ended up with this.

setxkbmap -query | grep -P 'layout:\s+\K[a-z]{2}' -o

The -P instructs grep to use Perl style regular expressions, and the revelation for me that did the trick was \K, which effectively discards what comes before from getting captured.

Perldoc reference

I also need to choose variants for every layout, so the full switchkb script ended up like this.

SWITCH=${1:-us}

current=$(setxkbmap -query | grep -P 'layout:\s+\K[a-z]{2}' -o)

if [[ "${current}" == "${SWITCH}" ]] ; then
    setxkbmap us altgr-intl
    exit 0
fi

case "${SWITCH}" in
    am)
        setxkbmap am western
        ;;
    ru)
        setxkbmap ru phonetic
        ;;
    us|*)
        setxkbmap us altgr-intl
        ;;
esac

Most mice have a button under the scroll wheel, equivalent to double-click, this is button2. Other button names are usually button8, button9, etc. They can be retrieved with xev.

Mapping the mouse buttons to the switch script was simple enough with sxhkd.

button2
    switchkb am

button8
    switchkb ru

The above can be rewritten simply like this:

button{2,8}
    switchkb {am,ru}

Worth noting here, that I find sxhkd indispensable, especially with tiling window managers. In addition to its powerful and concise config style, it makes using multiple window managers trivial, by making the keyboard mapping definitions independent.

Copy Encrypted Partition between Disks

Sat, 10 Apr 2021 00:00:00 +0000

Recently, I had to copy/move an openSUSE Tumbleweed encrypted partition, and its EFI boot files, from one USB drive to another.

All the below are specific to this particular case. But, I’m sure it can be adapted to other similar situations as well.

Preparing Space

My target device already had an OS and a EFI boot partition. So, first I had to create space on the target.

Since the source partition is encrypted, and we are moving irrespective of the internal file system, we need to make the target partition size to be at least the same size, or preferably larger.

I did the resize using a GParted live disk.

Copy the Partition

This can be done with a simple dd. The most critical part here is to get the source /dev/sdXn and target /dev/sdYn partitions right.

dd if=/dev/sdXn of=/dev/sdYn bs=1M status=progress

Copy the EFI Files

We also need to copy the EFI bootloader files from the original disk boot partition, to the target. These are found in small FAT16 or FAT32 partitions.

Mount the source boot partition, and copy the following directory /boot/efi/EFI/opensuse to the EFI directory of the target disk’s boot partition.

Mount the Target Partition

Before booting, there are a few things to fix, so we need to mount our partition on another host system.

Obviously, if this step fails, and we can’t see our files, the partition is corrupted and there is no use continuing further…

cryptsetup --type luks open /dev/sdYn target 
mount /dev/mapper/target /mnt

Resize the File system

Since we copied into a larger area, we need to resize the file system to take the whole available space.

Each file system has its own commands, in my case it is btrfs, so we can resize it as follows.

# expanding a mounted btrfs partition
btrfs filesystem resize max /mnt

For ext2/ext3/ext4 file systems, resize2fs can be used.

Fix the Boot Partition UUID

Since the boot partition has changed, we need to update the reference in the mounted /mnt/etc/fstab to the correct UUID of the new disk.

Regenerate the Initrd

After doing all of the above, I rebooted to test the process. I was initially happy the bootloader was recognized, and it started booting the moved partition.

But, it didn’t go far, and the boot stalled for a minute or so, before complaining about the missing old boot partition UUID.

Apparently, the openSUSE Initrd includes this UUID as well, so we need to regenerate it, by going into a chroot environment on the host machine where we mounted the target, and run mkinitrd.

# Arch Linux has a script that prepares the chroot for us:
arch-chroot /mnt

# Now we are in the openSUSE environment and we can run:
/usr/bin/mkinitrd

After this the reboot worked fine, and the move is complete.

Manually add External Volume Entry in rEFInd

Fri, 02 Apr 2021 00:00:00 +0000

rEFInd is an excellent UEFI boot manager, that does almost everything for you. It is able to automatically find all bootable partitions on the available internal and external disks, and detect the operating systems on them.

rEFInd boot menu

When not using the automatic scan however, we need to add the OS entries manually.

Examples are available in the config file, but, to add an entry from an external hard drive, there’s a small trick involved, that may not be apparent at first.

A volume parameter needs to be specified, pointing to the exact boot partition of the external disk. All parameters coming after the volume definition will work relative to the new disk, while parameters coming before will assume the original disk.

menuentry "GuixSD" {
    icon /EFI/refind/myicons/os_guixsd.png
    volume 12345678-9abc-def0-1234-56789abcdef0
    loader /EFI/Guix/grubx64.efi
}

It should be noted, that the volume ID above is not the file-system one, but the partition PARTUUID, that can be retrieved using blkid.

Incidentally, to get a screenshot of the boot screen, simply press F10, and the image file will be saved in the rEFInd root directory.

The boot menu screenshot above is based on the “Minimalistic rEFInd theme”, while the icons are from “rEFInd theme Regular”.

GNU Guix System Installation with Static Networking

Wed, 10 Feb 2021 00:00:00 +0000

During Guix system installation, the manual option, I had to connect to my home network, where I use static IP addresses. I stumbled a bit to get it working, but in the end it was simple enough.

Here are some notes on the process. Assuming the interface name is eth0 and the static IP address is 192.168.1.12.

First, we need to stop the networking service, as it is interfering by assigning addresses and routes.

herd stop networking

Then, we can assign an IP address on our device, bring it up, and add a route for our default gateway.

ip addr add 192.168.1.12/24 dev eth0
ip link set dev eth0 up
ip route add default via 192.168.1.1

That’s it. One last thing would be to add the appropriate name servers in the installer’s /etc/resolv.conf.

nameserver 192.168.1.1

Static address for the installed system

The above was during installation, but how do we set up networking with a persistent static address in our config?

The “GNU Guix Reference Manual” defines this, and can be done as follows.

(static-networking-service
          "eth0" "192.168.1.12"
          #:netmask "255.255.255.0"
          #:gateway "192.168.1.1"
          #:name-servers '("192.168.1.1"))

Removing default services

In the manual they are adding the static networking service on %base-services which does not itself include networking.

On the other hand, if our services are based on %desktop-services, then it includes NetworkManager, so we need to remove that, otherwise guix system will complain about the existence of two networking tools.

(remove (lambda (service)
          (eq? (service-kind service) network-manager-service-type)
          %desktop-services))

The above removes only one service, NetworkManager. But, I had to remove multiple ones, and that can be achieved with the or procedure.

Static networking can most likely be setup in the config with NetworkManager as well, but I found this simpler for my first install.

Putting everything together, a services section, that includes just networking, looks something like this.

(services
 (cons*
  (static-networking-service "eth0" "192.168.1.12"
                             #:netmask "255.255.255.0"
                             #:gateway "192.168.1.1"
                             #:name-servers '("192.168.1.1"))
  (remove (lambda (service)
            (or 
             (eq? (service-kind service) network-manager-service-type)
             (eq? (service-kind service) avahi-service-type)))
          %desktop-services)))

JavaScript Allow List in qutebrowser

Sun, 31 Jan 2021 00:00:00 +0000

qutebrowser is a keyboard-focused browser with a minimal GUI. It’s based on Python and PyQt5 and free software, licensed under the GPL. It was inspired by other browsers/addons like dwb and Vimperator/Pentadactyl.

Official website of qutebrowser

Updated on 2021-02-05

The below solution allows an external manually configured list. However, qutebrowser has a built-in way of achieving something similar with the t commands.

For example tSh would enable JavaScript on the opened site and reload. It will also ask to make the change permanent.

I did not know this before writing this post, thanks to Hund for bringing this to attention.

Link to discussion.

I use qutebrowser sometimes, and it is an excellent fully keyboard driven browser. One thing I miss though, is the control on the loading of scripts. Once you get used to uMatrix, it is difficult to live without.

We can however disable JavaScript altogether, and then selectively allow it for a small number of websites. Not the same level of control, but still could be useful.

c.content.javascript.enabled = False

with config.pattern("https://fosstodon.org/*") as p:
    p.content.javascript.enabled = True

But, instead of adding code for every website, we can have an external plain text list, for example js.sites, and load it in the config.

try:
    with (config.configdir / 'js.sites').open() as js_file:
        js_sites = js_file.read().split("\n")
        js_file.close()

    for js_site in js_sites:
        if js_site != '':
            config.set('content.javascript.enabled', True, js_site)
except FileNotFoundError:
    print('js.sites not found')

Now, we can add the list of websites in js.sites.

Apply Font in emacsclient

Mon, 25 Jan 2021 00:00:00 +0000

I set the default font in my Emacs config as follows:

(set-frame-font "Source Code Pro 11" nil t)

However it was not applied when Emacs was ran in client-server mode. Emacsclient behaved weird with tiny text.

To apply in emacsclient as well, it seems another change needs to be done as well.

(add-to-list 'default-frame-alist '(font . "Source Code Pro 11"))

As the font has to be set twice, I wanted to set a variable, which led to an interesting dive into Emacs Lisp.

(defvar my-font)
(setq my-font "Source Code Pro 11")

(set-frame-font my-font nil t)
(add-to-list 'default-frame-alist `(font . ,my-font))

The “backquote” concept took a while to discover. Initially, used the more general form (cons 'font my-font) until I discovered this shortcut.

So, in this particular case, we do not want to evaluate font, but we do want my-font, thus we cannot put a quote for the whole cons. What the backquote allows, is to evaluate any symbol that has a comma in front.

Rofi Menu for the buku Bookmark Manager

Wed, 06 Jan 2021 00:00:00 +0000

Buku is a command-line bookmark manager, that takes the bookmarks out of the browser. I have completely converted to it, since it allows bookmarks to work independently of the browser, and makes syncing between different machines very trivial.

I’m not going into the usage details here, since it is well documented by buku themselves.

buku - Bookmark manager

To share the bookmarks between different machines, all that is needed is the copying of the database file, located at .local/share/buku/bookmarks.db.

There are various ways of invoking buku, including browser based add-ons. However, I prefer using it through a dmenu/rofi style menu.

An existing implementation is buku_run, which tries to offer most of the buku functionality, including adding/deleting entries.

buku_run - rofi frontend for buku bookmarks manager

However, I find that too complicated for my needs. Especially, since it’s very easy to make your own.

But, the problem was, none of the buku output formats were suitable for me.

One way is by using buku --format:

buku -p --format 5 \
    | tail -n +2 \
    | awk -F$'\t' '{ print $1"\t"$3"\t"$2 }' \
    | column -t -s $'\t'

Getting the output in JSON format is more consistent, however, you will then need to parse that, with some lengthy complication like this:

buku -p -j \
    | tail -n +2 \
    | jq -r '.[] | "\(.index)\t\(.tags)\t\(.title)"' \
    | column -t -s $'\t'

Turns out we also need tail -n +2 for both these cases, or a way to skip the first line, because when not run from a terminal, buku prints a message before the output.

So, in the end, I decided to “cheat” and access the database directly, since it’s standard SQLite anyway.

Following is my complete buku_menu:

#!/usr/bin/env bash

getbookmarks() {
    sqlite3 -column -separator $'\t' ~/.local/share/buku/bookmarks.db \
        "select id,trim(tags,','),metadata from bookmarks order by tags"
}

menu=$(getbookmarks | rofi -dmenu -i -width 1000 -p '> ')
id="${menu%% *}"

buku -o "${id}"

I am also sorting the bookmarks by tags, which is one of the advantages of this method, as we can extract and display the data however we want.

Build Go Application with Version Information from Git

Fri, 25 Dec 2020 00:00:00 +0000

To automatically add version information to a Go application, we can pass that information from git through build arguments.

This can be especially useful, if we are using git tags.

For example, the following will get the latest git tag, the last commit hash, and whether there are locally modified uncommitted (dirty) files.

$ git describe --always --long --dirty
v0.12.1-0-gca3521e-dirty

More information on the options are available with man git-describe.

To pass this information into our program, we can define a global variable, and assign it through build arguments.

So, define a variable appver in the main.

package main

import (
	"fmt"
)

var (
	appver = "undefined"
)

func main() {
	fmt.Println(appver)
}

And build while assinging main.appver.

go build -ldflags="-X main.appver=$(git describe --always --long --dirty)" main.go

Same flags will work with go run.

Additionally, one can pass other variables like build time.

To get the version of Go itself, import "runtime" and get it with runtime.Version().

Gopher Version

Fri, 18 Dec 2020 00:00:00 +0000

Updated on 2022-12-18

I have stopped updating the Gopher and Gemini versions of this site. At the time, I tried them out of curiosity, and I still think Gemini has interesting use cases.

However, since I cannot do away with the regular http site, maintaining multiple versions actually makes things more complicated than otherwise.

I have setup a Gopher mirror of this website.

Since, the posts on this site are simple markdown files, it was easy converting them to plain text. I had to do some additional changes as well, like removing the image tags. Hopefully, I’ll have a better, more automated solution soon.

Why Gopher? Curiosity, interest.

Easiest way to access is with the lynx browser:

lynx gopher://blog.rzg.one

Allow Access by Country with Firewalld

Fri, 11 Dec 2020 00:00:00 +0000

There are various guides on the web, regarding how to block a whole country, or a group of IP addresses using various firewall methods.

But, what if we need to do the opposite. Allow only one country, and block everyone else.

This may be particularly useful for personal services, like Nextcloud, that you know will only be used by yourself.

Nextcloud - Self-hosted file-sharing solution

Of course, using the same method, it is also possible to allow only a few IP addresses, a city, or just one ISP. All that is needed are the group of IP blocks.

For countries, we can get them from the IPdeny lists. The aggregated files will be more efficient, since they will have less blocks and thus fewer rules.

IPdeny - Country based IP zone files

Since this article uses firewalld, some quick notes on how it works.

By default, firewalld will have one active zone, with some default services attached.

# get all active zones
$ firewall-cmd --get-active-zones
public
  interfaces: eth0

# list all rules on the public zone
$ firewall-cmd --zone=public --list-all
public (active)
  target: default
  icmp-block-inversion: no
  interfaces: eth0
  sources: 
  services: dhcpv6-client ssh
  ports: 
  protocols: 
  masquerade: no
  forward-ports: 
  source-ports: 
  icmp-blocks: 
  rich rules:

The above rules mean, that everyone coming through the interface eth0 will be allowed on the services ssh and dhcpv6-client.

Now back to our goal. We will need to do the following:

Get the IP address blocks.
Create a list, and populate it with our addresses.
Create a new zone, and set the list to it.
Assign all the needed services to this zone, remove them from the other zones.

# download the country IP blocks
wget "https://www.ipdeny.com/ipblocks/data/aggregated/am-aggregated.zone"

Here we create an ipset with the name allowlist (could be anything), and we populate it with the downloaded list.

# create list
firewall-cmd --permanent --new-ipset=allowlist \
    --type=hash:net --option=family=inet \
    --option=hashsize=4096 --option=maxelem=200000

# populate list
firewall-cmd --permanent --ipset=allowlist \
    --add-entries-from-file=./am-aggregated.zone
    
# we can display the list like this
firewall-cmd --ipset=allowlist --get-entries

Then, we create a new zone allowzone, assign the allowlist to it, and enable some services and ports.

# create zone
firewall-cmd --permanent --new-zone allowzone

# assign the list to the new zone
firewall-cmd --permanent --zone=allowzone --add-source=ipset:allowlist

# allow services
firewall-cmd --permanent --zone=allowzone --add-service ssh
firewall-cmd --permanent --zone=allowzone --add-service http
firewall-cmd --permanent --zone=allowzone --add-service https

Now, allowzone will only allow the added services for the allowlist, and no one else.

# check all the rules on the new zone
$ firewall-cmd --permanent --zone=allowzone --list-all
allowzone (active)
  target: default
  icmp-block-inversion: no
  interfaces: 
  sources: ipset:allowlist
  services: http https ssh
  ports: 
  protocols: 
  masquerade: no
  forward-ports: 
  source-ports: 
  icmp-blocks: 
  rich rules:

We still need to remove any enabled services from the public zone, otherwise it will keep allowing everyone on eth0.

Up until this point, since we are using the --permanent option, nothing will be applied until we reload or restart firewalld. And since we added a new zone, it is not yet dangerous to do so now. However, once we remove services like ssh from the active public zone, we may lock ourselves out. So, some common sense care should be applied here. Maybe start by removing a less dangerous port first.

# remove services from public zone
firewall-cmd --permanent --zone=public --remove-service ssh

Finally, reload or restart firewalld.

firewall-cmd --reload

Multiple Keyboards with Different Layouts

Mon, 07 Dec 2020 00:00:00 +0000

I need to type in multiple languages, each having a different script. So, I have shortcuts set up to change the layout using setxkbmap.

# setxkbmap [ layout [ variant ] ]
setxkbmap us altgr-intl
setxkbmap am western
...

But, sometimes, every other word is in a different language, so it is very cumbersome to switch layouts back and forth for every word.

Turns out, it is possible to add a second keyboard, and assign a persistent layout to it. We simply need to apply setxkbmap on a specific device id.

my second keyboard - Armenian Phonetic layout

First we need to get the device ID of the second keyboard, which we can do with xinput.

Sometimes, the same keyboard appears multiple times. I couldn’t find a better way, other than trial and error with every device id.

Now, we can set the global layout, and then set an alternative layout for the second keyboard.

# each keyboard gets a different layout
setxkbmap us altgr-intl
setxkbmap am western -device 17

Thankfully, the device id appears to persist through reboots, and stays the same.

VirtualBox Selection Menu

Sun, 06 Dec 2020 00:00:00 +0000

In a previous post, I showed my dialog based login menu.

The menu included an option to start a VirtualBox virtual machine.

The idea is to open a dmenu or rofi selection list of all virtual machines available. It can work either from an existing session, or by itself on login, without a window manager.

virtual machines menu

We can get the list of virtual machines, and strip the unnecessary parts like this.

vboxmanage list -s vms | cut -d'"' -f 2

This list can be passed to rofi, and can then be used to start the VM.

The standard way of starting a VirtualBox VM is as follows.

vboxmanage startvm "${VMNAME}"

However, there is a problem with this method, because vboxmanage spawns another process and disappears.

While this will work if ran from an existing session, it will not work on login, without a window manager, since the X session will end immediately and kill all processes including the virtual machine.

Fortunately, by looking at the processes, we can see that vboxmanage runs the following process /usr/lib/virtualbox/VirtualBoxVM. We can use that directly, and the VM can now start without a window manager.

Here is the menu script in full.

getvms() {
    vboxmanage list -s vms | cut -d'"' -f 2
}

CHOSEN=$(getvms | rofi -dmenu -i -p "Select VirtualBox Machine")

[[ -z ${CHOSEN} ]] && exit

/usr/lib/virtualbox/VirtualBoxVM --comment "${CHOSEN}" \
    --startvm "${CHOSEN}" \
    --no-startvm-errormsgbox

When ran without a window manager, powering off the VM will exit the X session automatically.

One last note, sometimes vboxmanage list is very slow, and takes a few seconds to display the menu. For my case, I am taking the list directly from the directory names. Both methods have the same result.

Login Menu with dialog

Tue, 01 Dec 2020 00:00:00 +0000

Most standard Linux distribution installations come with a Display Manager, usually tied to the desktop environment. Like GDM for Gnome, LXDM for LXDE, etc. There are also a few lighter ones, like XDM/LightDM…

But, not everyone likes a full Desktop Environment, or even a Display Manager. Some simply login on the shell and run startx.

However, a Display Manager serves another purpose as well, that is selecting which environment to log into.

So, for that I have made a custom menu with dialog.

dialog selection

The setup is based on .zlogin and .xinitrc.

The first one may vary between Linux distributions, and default shells. On Arch Linux with zsh, logging in executes .zlogin, startx executes .xinitrc.

         +-----------+  startx  +-----------+
login -->| .zlogin   |--------->| .xinitrc  |
         +-----------+          +-----------+

So, in .zlogin I have a menu of all the possible window managers, and even some applications.

# select window manager
if [[ -z ${DISPLAY} && ${XDG_VTNR} -le 2 && -z "${SSH_TTY}" ]] ; then
    export WM=$(dialog --backtitle "Login Manager" \
                       --nook --nocancel --no-tags \
                       --timeout 5 \
                       --menu "Select WM" 15 60 8 \
                   "spectrwm" "1: spectrwm" \
                   "hlwm"     "2: herbstluftwm" \
                   "bspwm"    "3: bspwm" \
                   "emacs"    "4: Emacs" \
                   "browser"  "5: Browser" \
                   "vbox"     "6: VirtualBox" \
                   "tmux"     "7: tmux" \
                   3>&1 1>&2 2>&3)
    clear
    exec startx
fi

By testing for ${XDG_VTNR} -le 2, this menu will run only on tty1 and tty2, and not from ssh.

In addition to the Window Managers, I also have a terminal with a tmux session, Emacs, a VirtualBox virtual machines selection menu, and Firefox.

VirtualBox Selection Menu

Based on the selection, .xinitrc will run the equivalent WM or application.

case ${WM} in
    browser)
        exec firefox --kiosk --new-instance
        ;;
    emacs)
        xsetroot -solid black
        exec emacs -fs -mm
        ;;
    vbox)
        exec vboxmenu
        ;;
    tmux)
        xsetroot -solid black
        exec alacritty -d 382 80 --position 0 0 -e tmux
        ;;
    bspwm)
        exec bspwm
        ;;
    hlwm)
        exec herbstluftwm --locked
        ;;
    spectrwm|*)
        exec spectrwm
        ;;
esac

The menu will timeout in 5 seconds, and automatically login to the default option, which is spectrwm.

Important to note, that it is perfectly possible to have two different Window Managers or applications running concurrently on different ttys.