DEV Community: Lovelin

I am making a distributed in-memory key value db

Lovelin — Fri, 24 Jan 2025 18:37:09 +0000

Hi guys, I am Lovelin, 19, 2nd year Engineering.
I named the project as Lally. Lally is a distributed in-memory key-value database, Rust and Tokio.

I am new to distributed systems, so it would be great if someone with experience could mentor me on the latter. I don't have many connections, so it's hard and I am unsure whether I am going in the right direction

Make Wezterm Mimic Tmux

Lovelin — Mon, 09 Sep 2024 17:31:36 +0000

I have been using the Alacritty + Tmux setup for a while, and it's one of those things I would call "that just stuck".

My setup is so minimal that I could happily live with just a terminal and an emulator. I need to manage a lot of processes, like running an npm server, editing a couple of Neovim buffers, overseeing a Docker image build, etc. This is where Tmux comes in handy, and life has been good ever since.

A month ago, I came across WezTerm, a new GPU-accelerated, cross-platform terminal emulator written in Rust (and I’m not a Rust fanboy, for real!). It piqued my interest, so I decided to give it a try.

Wezterm matched my expectations. It's feels fast and looks modern, with support for ligatures, tab + pane support and image rendering out of the box, something I have been sorely missing out in Alacritty.

In my opinion, the biggest selling point of WezTerm is its full customization through Lua. The documentation is robust for a project of its maturity, and with sensible Lua defaults, the configuration process feels almost zen.

I’m tired of working with the domain-specific configuration languages of Tmux and Kitty, so I thought, why not make WezTerm mimic Tmux as much as possible?

So, I sat down for an hour and came up with the configuration below. There are numerous keybindings based on my personal preferences, so feel free to modify them to suit your needs.

The configuration

Wezterm's config lives as .wezterm.lua in our home directory.

local wezterm = require("wezterm")
local config = wezterm.config_builder()
-- our config overrides goes in here
return config

So let's do some basic config

config.font_size = 16

config.window_decorations = "RESIZE"

config.window_frame = {
    font_size = 13.0,
}

config.window_padding = {
    top = 10,
    bottom = 10,
    left = 10,
    right = 10,
}

config.term = "xterm-256color"

We changed the font size, window padding, and set the window_decorations as "RESIZE" which disables the title bar but enable the resizable border.

Setting term as "xterm-256color" allow wezterm to utilize 256 colors for text output

Also, I would like to launch wezterm in fullscreen mode by default.

wezterm.on("gui-startup", function(cmd)
    local tab, pane, window = mux.spawn_window(cmd or {})
    window:gui_window():maximize()
end)

Alright, now the niceties are done, let's make wezterm mimic tmux.

Leader Key

We will be setting up a leader key in wezterm, just like we have one in tmux. Our Leader Key here, is CTRL + A. You can use anything you feel comfortable.

config.leader = { key = "a", mods = "CTRL", timeout_milliseconds = 2000 }

Splitting Panes

We will add keybindings to split panes horizontally and vertically.

local action = wezterm.action
config.keys = {
    {
        key = "-",
        mods = "LEADER",
        action = action.SplitVertical({ domain = "CurrentPaneDomain" }),
    },

    {
        key = "\\",
        mods = "LEADER",
        action = action.SplitHorizontal({ domain = "CurrentPaneDomain" }),
    },
}

Triggering LEADER + \ will split panes horizontally while LEADER + - will split panes vertically.

Adjusting pane size

Let's add some keybindings to adjust a pane's size

config.keys = {
    {
        key = "h",
        mods = "CTRL|SHIFT",
        action = action.AdjustPaneSize({ "Left", 5 }),
    },
    {
        key = "l",
        mods = "CTRL|SHIFT",
        action = action.AdjustPaneSize({ "Right", 5 }),
    },
    {
        key = "j",
        mods = "CTRL|SHIFT",
        action = action.AdjustPaneSize({ "Down", 5 }),
    },
    {
        key = "k",
        mods = "CTRL|SHIFT",
        action = action.AdjustPaneSize({ "Up", 5 }),
    },
        {
        key = "m",
        mods = "LEADER",
        action = action.TogglePaneZoomState,
    }
}

I used Vim motions to adjust the size of the focused pane. Pressing CTRL + SHIFT + h|j|k|l will increase the pane's size by 5 units in the corresponding Vim motion direction.

Additionally, pressing LEADER + m will zoom the pane to take up the full window. Clicking it again will return the pane to its previous state.

Tab configuration

We will be using wezterm tabs as an equivalent to tmux windows.

config.key = {
    {
        key = "c",
        mods = "LEADER",
        action = action.SpawnTab("CurrentPaneDomain"),
    },

    {
        key = "p",
        mods = "LEADER",
        action = action.ActivateTabRelative(-1),
    },
    {
        key = "n",
        mods = "LEADER",
        action = action.ActivateTabRelative(1),
    }
}

The keybinding LEADER + c will create a new tab, while LEADER + p and LEADER + n will shift the focus to the previous tab and the next tab, respectively.

for i = 1, 9 do
    table.insert(config.keys, {
        key = tostring(i),
        mods = "LEADER",
        action = action.ActivateTab(i - 1),
    })
end

This loop would add keybindings which will allow us to activate a specific tab by its number from 1 to 9. For instance, if I am on the fifth tab and I need to go to the first tab, I can just click LEADER + 1.

Setup VI Mode

The VI mode, or copy mode, allows you to copy content in your terminal using Vim keybindings.

config.key = {
    { key = "[", mods = "LEADER", action = action.ActivateCopyMode },
}

With this configuration, WezTerm will enter VI mode when you trigger LEADER + [. You can now navigate WezTerm like a Vim buffer, selecting and yanking lines using Vim keybindings. Pressing CTRL + C will exit VI mode.

Navigating between nvim splits and wezterm splits

eovim split or a WezTerm split. If it's a Neovim split, the keypress will be passed to it; if it's a normal WezTerm split, WezTerm will take control.

To make this work, you should install the smart-splits plugin for neovim, with the this configuration

local direction_keys = {
    h = "Left",
    j = "Down",
    k = "Up",
    l = "Right",
}

local function split_nav(key)
    return {
        key = key,
        mods = "CTRL",
        action = wezterm.action_callback(function(win, pane)
            if pane:Get_users_vars().IS_NVIM == "true" then
                -- pass the keys through to vim/nvim
                win:perform_action({
                    SendKey = { key = key, mods = "CTRL" },
                }, pane)
            else
                win:perform_action({ ActivatePaneDirection = direction_keys[key] }, pane)
            end
        end),
    }
end

config.keys = {
    split_nav("h"),
    split_nav("j"),
    split_nav("k"),
    split_nav("l"),
}

Now we can navigate through neovim splits and wezterm panes seamlessly using CTRL + h|j|k|l.

Here is how the whole configuration should look like

local wezterm = require("wezterm")
local mux = wezterm.mux

wezterm.on("gui-startup", function(cmd)
    local tab, pane, window = mux.spawn_window(cmd or {})
    window:gui_window():maximize()
end)

local config = wezterm.config_builder()

config.term = "xterm-256color"

local direction_keys = {
    h = "Left",
    j = "Down",
    k = "Up",
    l = "Right",
}

local function split_nav(key)
    return {
        key = key,
        mods = "CTRL",
        action = wezterm.action_callback(function(win, pane)
            if pane:Get_users_vars().IS_NVIM == "true" then
                -- pass the keys through to vim/nvim
                win:perform_action({
                    SendKey = { key = key, mods = "CTRL" },
                }, pane)
            else
                win:perform_action({ ActivatePaneDirection = direction_keys[key] }, pane)
            end
        end),
    }
end

config.font_size = 16

config.window_decorations = "RESIZE"

config.window_padding = {
    top = 10,
    bottom = 10,
    left = 10,
    right = 10,
}

config.leader = { key = "a", mods = "CTRL", timeout_milliseconds = 2000 }

local action = wezterm.action

config.keys = {
    {
        key = "\\",
        mods = "LEADER",
        action = action.SplitHorizontal({ domain = "CurrentPaneDomain" }),
    },
    split_nav("h"),
    split_nav("j"),
    split_nav("k"),
    split_nav("l"),
    {
        key = "h",
        mods = "CTRL|SHIFT",
        action = action.AdjustPaneSize({ "Left", 5 }),
    },
    {
        key = "l",
        mods = "CTRL|SHIFT",
        action = action.AdjustPaneSize({ "Right", 5 }),
    },
    {
        key = "j",
        mods = "CTRL|SHIFT",
        action = action.AdjustPaneSize({ "Down", 5 }),
    },
    {
        key = "k",
        mods = "CTRL|SHIFT",
        action = action.AdjustPaneSize({ "Up", 5 }),
    },
    {
        key = "-",
        mods = "LEADER",
        action = action.SplitVertical({ domain = "CurrentPaneDomain" }),
    },
    {
        key = "m",
        mods = "LEADER",
        action = action.TogglePaneZoomState,
    },
    { key = "[", mods = "LEADER", action = action.ActivateCopyMode },
    {
        key = "c",
        mods = "LEADER",
        action = action.SpawnTab("CurrentPaneDomain"),
    },

    {
        key = "p",
        mods = "LEADER",
        action = action.ActivateTabRelative(-1),
    },
    {
        key = "n",
        mods = "LEADER",
        action = action.ActivateTabRelative(1),
    },
}

for i = 1, 9 do
    table.insert(config.keys, {
        key = tostring(i),
        mods = "LEADER",
        action = action.ActivateTab(i - 1),
    })
end

return config

Conclusion

WezTerm is cool! I was able to ditch the overhead of Tmux by using WezTerm. While it may not match all of Tmux's capabilities, it works perfectly for my simple use cases. There’s much more to explore in WezTerm’s configuration, which you can find on their official website. Here is my dotfiles in case if you want to peek. See ya!

Cover Image from wezfurlong.org/wezterm

Sync music between your PC and mobile using Rsync

Lovelin — Fri, 06 Sep 2024 17:55:19 +0000

In the previous post, we saw how to configure a SSH connection between our PC and mobile. Go check that out, if you landed here without checking that that.

In this post, we will see how we can configure rsync to sync our music files between our devices, and finally listen to some music 🎶🎶

What is Rsync??

Rsync is a command-line tool that enables syncing files and directories between the local and remote system. It's highly flexible and it's similar to scp, if you worked on scp before, the rsync is just scp on steroids.

Rsync needs a transporting mechanism to sync files between two systems, and that's why we had SSH configured between our devices on the previous post.

Installing Rsync

Rsync comes pre-installed on most Linux distributions and macOS. For Windows, you can use WSL (Windows Subsystem for Linux) or install Cygwin.

For Android, open Termux and run

pkg install rsync

Verify the installation with:

rsync --version

Create a common directory

We are going to setup a common directory which will hold all our music files, subtitles etc.. on our device.

Create a Music directory in the home folder on both devices. If it doesn't exist, create it with the following commands:

On PC

cd ~ && mkdir Music

On Mobile (on Termux):

cd storage 
mkdir Music

Now, any new MP3 files added to the Music directory on one device can be synced to the other device seamlessly

Let's Rsync!

Let's have a look at the files we are syncing

I have these on my PC

And my Music folder on my mobile is empty.

On PC

rsync -avP -e 'ssh -p 8022' ~/Music/ <Mobile_username>@<Mobile_IPaddress>:storage/Music/

Let's break that down!

a - Enables archive mode. It is necessary for syncing directories recursively.
v - Enables verbose mode. Does some helpful logging if something goes wrong or right.
P - It enables both the progress and partial flag. This progress flag provides a progress bar for the transfers, and the partial flag allows you to resume interrupted transfers.
e - Specifies the SSH port to which we are connecting too. The default port that termux uses is 8022.

We used our mobile username and the IP address which we have acquired through termux. If you are clueless, then please read the previous post.

Notice the trailing slash in the Music directory. The trailing slash signifies the content of the Music folder. If we don't specifiy the trailing slash then it would create a heirarchy in our mobile like Music/Music

You will see the progress of each file incremently and all the files would be transfered to our mobile's Music directory.

If you want to transfer the files from your mobile to your PC,

rsync -avP storage/Music/ <PC_username>@<PC_IPaddress>:Music/

We had our host aliases configured on our previous post. So we can just do

rsync -avP ~/Music/ myGoodPhone:storage/Music/

rsync -avP storage/Music/ myGoodPC:Music/

And that is how you get things done.

Conclusion

Syncing music files over SSH using Rsync might sounds like an overkill, because it is an overkill. Rsync's has a lot of use cases, and it's widely used in automated incremental backups, synchronizing directories between servers etc.. I hope you guys found this series informative

See ya!

Cover image by Namroud Gorguis on Unsplash

Configure SSH between your PC and mobile

Lovelin — Fri, 06 Sep 2024 17:55:06 +0000

You might call me old school, but I prefer downloading MP3 files and listening to them offline on my devices. Music streaming services never appealed to me more than my good old MP3 player.

The only thing that I used to sorely miss was syncing music files between my devices. I used to transfer MP3 through bluetooth or godforbid Whatsapp 😔

But now, I am syncing files across my devices using a utility called
rsync over an ssh connection.
All through the command line, what more a dev could ask for ✨

This post is a series of two parts, first part covering how to setup a ssh connection between your phone and PC and the second part, the better part, deals on utilizing Rsync to sync files between our devices bidirectionally! If you are good with SSH, then please skip this post and continue on the next part of the series.

Get Started

Hold on, let's see some theory first. They would be short, I promise, bear with me.

What is SSH btw?

SSH stands for Secure Shell—though the acronym might be a bit misleading, it’s a network protocol that creates a secure connection between a client and server using cryptographic techniques. To give you an idea, other network protocols are https, ftp, smptp and ssh is one of them.

How does it work?

Assume, two computers, one is a client and another one is a server. To initiate a connection, on the client side, we would using the server's ip address along with the username in which we need access. Here, there are two ways, in which we can initialize a successful connection to the server.

Using password based authentication - Simple, not so cool
Using ssh keys - Little bit complex, looks chad

In password-based authentication, when you try to connect to the server using it's IP address and username, it will prompt you to enter the password for the user which you are trying to access. Once verified, you will get the whole shell access of the server on your client. The downside is, you will be enter the password every time whenever you are trying to connect to the server.

In ssh-keys based authentication, you will be generating a cryptographic key-pair, a public key and the private key on the client. The private key stays on the client, and the public key is sent to the server in which you are accessing to. So whenever, you try to access the server, the server creates a math puzzle for you based on the public key you sent to it. This math puzzle can be only solved by the private key on your client, which results in a verified, secure connection between the client and server.

And that's enough theory for now!

Setting up the environment

To use SSH, you will need a ssh-daemon on both your phone and PC. Let's set up the PC first!

On Mac OS

SSH and the ssh-daemon comes preinstalled, no worries. Start the daemon by running



sudo systemsetup -setremotelogin on

On Linux

Like Mac, most of the linux distributions has SSH and the daemon preinstalled.
If not, then run

For Fedora:



sudo dnf install openssh-server

For Ubuntu:



sudo apt install openssh-server

For Arch Linux:



sudo pacman -S openssh

Then enable the SSH service to start at boot (applicable for all distros)



sudo systemctl enable sshd

On Windows

Sheesh... I don't use windows. We can setup a SSH connection using the openssh-server, but I will suggest you to use WSL (Windows Subsystem for Linux) as this series would be more linux-focussed.

On Mobile

On android, install the Termux app from Fdroid. Termux is a UNIX-like terminal emulator for android without root access.

On IOS, there is a emulator called ISH which looks great. I haven't tried personally though, I couldn't afford an iphone. I will be using Termux on android for the rest of the post.

Let's really get started!

We will be initiating a SSH connection between our PC and android. To do this make sure you have connected both of them on the same network , like your home network or on your mobile hotspot. Although, SSH works perfectly fine for devices connected across different networks, it needs some heavy work like port forwarding on the router. We will be avoiding that for the blogsake, as our main motivation of doing all these is to listen to the music 🎵 🎵

On PC,

Open up your favourite terminal emulator and enter



whoami

It will print your username. Note this one down.

Then for Linux and Mac, run



ifconfig

For windows, run



ipconfig

It will show you a lot of numbers, but the one we are interested is the IP address of our PC.

Check for network interfaces like eth0, wlan0, enp0s3, wl01 etc..
And within that there would be field called inet which has our ip address.

For me, my ip address 192.168.1.6 is under the wlo1 network interface. Best bet, your IP address will also starts at 192.168.

Now we have both our username and IP address of our PC, let's move to android setup

On Android

Install the Termux app from fdroid

We need to give storage permissions for termux. Open the termux app and enter



termux-setup-storage

Termux doesn’t come with an SSH daemon pre-installed, so you’ll need to set it up manually.



pkg install openssh termux-auth

This will install the daemon and auth utility to setup a password for our termux user.

Start the SSH-Daemon by running



sshd

Now run,



whoami

you will see something like u0_a36. Copy this down, this is the username for our android.

And just like we did for PC, run



ifconfig

and note down the IP address. Make sure you have connected both of your devices on the same network.

Now we have the username and IP address of both our PC and mobile.

It's about time to SSH!

To initate a connection from your mobile to your PC, open up termux and run



ssh <PC_username>@<PC_IPaddress>

It will prompt your for password, and once you are done with that, you can access your PC right from your mobile.

To initiate a connection from your PC to mobile, open up your favourite terminal emulator and run,



ssh -p 8022 <Mobile_username>@<Mobile_IPaddress>

The p flag here specifies which port is to be used to connect to termux. The default PORT that SSH uses is PORT 22, but on termux the PORT is 8022, so we need to manually pass 8022 as port. If no port is passed, then the PORT 22 is assumed by default.

You’ll be prompted for a password; once entered, you’ll gain access to your PC from your mobile device.

Setup Key-Based Authentication

Great, now we can access our devices from each other over SSH. Here, we will go a step deep. Let's use keys to authenticate each of our devices so we don't need to manually enter password each time. If you are good with how current things are, then you can safely skip this part.

We’ll generate a key pair (public and private) on each device and then exchange the public keys.

On Termux

To generate a key pair, run



ssh-keygen -t ed25519

Accept the default location, name and leave the passphrase as empty. We won't be needing that for our usecase.

Here the ssh-keygen command generates a public and private key. The t flag specifies the type of key to be created, and we used the ed25519.
Other type of keys are rsa, ecdsa, dsa etc.

The key-pair is stored in the .ssh folder on the root. Run



tree .ssh

And we will see something like this

id_ed25519 - Has the private key. This should never be shared with anyone. The id_ed25519 differs if you used some other type of key.
id_ed25519.pub - Stores the public key. We copy this key to the server we are accessing to. The id_ed25519.pub differs if you used some other type of key.
known_hosts - Stores the IP addresses along with the port and the base64 encoded public key of servers for which we have access to.
authorized_keys - It has the public keys of clients that are authorized to access our device.

Now we have generated a key-pair, we will be sending our public key to the PC. We can either manually copy the contents of id_ed25519.pub to the authorized_keys file on our PC or use ssh-copy-id utility.



ssh-copy-id -i .ssh/id_ed25519.pub <PC_username>@<PC_IPaddress>

This copies our public key to our PC.

We can simply use ssh <PC_username@<PC_IPaddress> to access our PC on our mobile.

On PC

Now to access our mobile from our PC, we just going to repeat the same steps but from our PC end.

Generate a key-pair



ssh-keygen -t ed25519

We can see the newly generated key-pair on the ~/.ssh folder.
We will be sending the generated public key on our PC to our phone, by running



ssh-copy-id -i ~/.ssh/id_ed25519.pub <Mobile_username>@<Mobile_IPaddress>

Great, we can access each of our devices from one another over SSH without entering the password each time.

Try doing this on mobile



ssh <PC_username>@<PC_IPaddress>

and this one in your PC



ssh -p 8022 <Mobile_username>@<Mobile_IPaddress>

Setup Host Aliases

Life's good, but it still sucks to enter the username and IP address each time, we can also skip this part by setting an alias.

Let's create a new file in the .ssh folder on both the PC and mobile.

Create the config file on both the devices



vi .ssh/config

Add these lines

For the config file in PC,



Host myGoodPhone
    HostName <Mobile_IPaddress>
    User <Mobile_username>
    Port 8022

and for the config file in mobile,



Host myGoodPC
    HostName <PC_IPaddress>
    User <PC_username>

save and exit the file.

Now, on mobile, we can just do



ssh myGoodPC

and on PC



ssh myGoodPhone

Remember, when you change the network in which your devices are connected, then these aliases won't work because they IP address differs. So you may need to upate these, setup a new alias, or manually enter username and IP address to connect.

Conclusion

Phew, that's was quite a labour, but here’s a quick recap…

What is SSH, and how it works on a high level
Setup the PC and mobile for SSH connection
Setup key-based authentication between devices
Added host aliases for our devices.

So we have our SSH connection all oiled and ready to go. In the next post on the series, we will see how can we use Rsync to sync our music files, bidirectionally. See ya, on the next tab.

Cover image by Namroud Gorguis on Unsplash