Forem: Prakhil Thottipully

Add font ligatures to your Alacritty

Prakhil Thottipully — Fri, 08 Apr 2022 04:54:17 +0000

This article helps you to enable font ligatures on your Alacritty terminal.

We know that Alacritty does not support font ligatures. However, we stick to it due to its performance excellence.

Although, you have good news! Someone made it possible. See the fork of the Alacritty repository with the added font ligatures.

https://github.com/zenixls2/alacritty

Tl;dr

To solve the problem, let's build the repository and install the output binary on our system. Below are the steps to your destiny.

Clone the repository and build it
Backup the existing binary and install the new one.

How to do it?

Before we clone and build the repo, you should make sure you have the necessary build tools to build the application. The Rust is used to write the Alacritty. Therefore, you must ensure you have cargo installed on your system

 sudo apt install cargo

Now, let's clone the repo using the below command.

git clone https://github.com/zenixls2/alacritty

Use the following commands to build.

cd alacritty
git checkout ligature
cargo build --release

If all goes well, this should place a binary at target/release/alacritty

Install the binary

We got the binary file after the build. Now, we only need to move it to the right place. For that, we should backup the existing binary file and use the new one.

Backup the existing binary using this command

sudo mv /usr/bin/alacritty /usr/bin/alacritty.bak

Then, let's copy our build binary to the /usr/bin folder.

sudo cp ./target/release/alacritty /usr/bin

Also make sure you have the right font-family on your alacritty config.

font:
  normal:
    family: Fira Code
    style: Regular
  bold:
    family: Fira Code
    style: Bold
  italic:
    family: Fira Code
    style: Italic

There you go!

Relaunch the terminal and see the magic.

Conclusion

We have covered all the steps to enable the font ligatures on the alacritty terminal. Hope this article helps you.

GitLab CI/CD: A guideline to set up your pipeline

Prakhil Thottipully — Sun, 27 Sep 2020 18:34:46 +0000

This article is about making a successful CICD for your application using GitLab.

The modern development moves faster and demands more from developers than ever. Tools and concepts around CICD help developers deliver value faster and more transparently.

You might have heard the term CICD which is short for continuous integration (CI) and either continuous delivery or continuous deployment (CD). In a nutshell, CICD is an automated capability and practice aimed at enabling software developers to continuously deliver software from an environment to another with the help of a single command or push of a button.

Tl;dr

Making a pipeline in GitLab is easy as pie, and everyone can do it. A remote machine and a GitLab repository are all needed for the setup. The coming sessions will guide you gently to set up your remote-machine and clarify the basics of YAML file configuration.

1. Requirements
2. Setting up a GitLab runner agent on the remote machine
3. Pipeline configuration
4. Continuous Integration
5. Continuous Delivery

1. Requirements

Before we dive into the CI/CD implementation, we should make sure the following are ready with us.

1. GitLab repository
2. Remote server

Create a repository on GitLab and set up your project in it. We also need a remote machine with git installed on it. The remote instance can be used to run our pipeline scripts and also deploy our project.

2. Setting up GitLab runner agent

GitLab Runner is a tool that we used to run our jobs and send the results back to GitLab. It is designed to run on Linux, macOS, and Windows.

1. Install GitLab Runner

Here is the link to different installation methods, you can choose one that fits for your remote machine.

The binary installation method for Linux x86-64, is what I'm showing here. Basically, just download the binary file to the /usr/local/bin/ directory and make it executable.

Choose the binary fle according to the system architecture. Type arch on your terminal to know the system architecture.

Download the binary

# Linux x86-64
sudo curl -L --output /usr/local/bin/gitlab-runner https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-linux-amd64

Give permission to execute

  sudo chmod +x /usr/local/bin/gitlab-runner

Create GitLab CI user

  sudo useradd --comment 'GitLab Runner' --create-home gitlab-runner --shell /bin/bash

Install and run as service

  sudo gitlab-runner install --user=gitlab-runner --working-directory=/home/gitlab-runner
  sudo gitlab-runner start

2. Register the Runner

There are three types of runners:

Shared (for all projects)
Group (for all projects in a group)
Specific (for specific projects)

We're going to set up a specific runner here. So that make sure you have the ownership of the project. Alright, let's go through the following steps to register our runner.

Goto to the project's settings > CI/CD and expand the Runner section.
Click on the "Disable shared Runners" button If it's enabled.
Note the registration token.

Make sure you have got the registration token, then we're ready to register our GitLab Runner.

Run the following command.

sudo gitlab-runner register

The command will prompt you a few questions for the registration

Enter coordinator URL (https://gitlab.com/)
Enter the token you got.
Enter a description for this runner.
Enter the tags for the runner. (Leave it empty if you're not using multiple runners for the project.)
Select the runner executer (eg: shell )

We have one more step to do, is permitting root privileges to the GitLab Runner. It is not necessary If you're not going to use any permission needed (sudo) commands in your ci/cd job

Add the following line to the end of the /etc/sudoers file.

gitlab-runner ALL=(ALL) NOPASSWD:ALL

All set, now we're ready to move on to the pipeline configuration.

3. Pipeline configuration

We need the .gitlab-ci.yml file in the root of the repository, which defines the structure and order of pipelines and determines what to execute using GitLab Runner.

Let's dive into the fundamentals of the YAML file.

jobs

It is the most fundamental element of the .gitlab-ci.yml file. As its name suggests, here is we write our scripts. Jobs are picked by runners and executed within the environment of the runner.

  job 1:
    script: "execute script for job1"

  job 2:
    script: "execute script for job2"

stages

It helps to define different stages in the pipeline. The definition order will be the final execution order of the jobs.

  stages:
    - build
    - test
    - deploy

stage

It relies on stages and allows to group jobs into different stages. The jobs of the same stage are executed in parallel.

  stages:
    - build
    - test
    - deploy

  job 0:
    stage: .pre
    script: make something useful before build stage

  job 1:
    stage: build
    script: make build dependencies

  job 2:
    stage: build
    script: make build artifacts

  job 3:
    stage: test
    script: make test

  job 4:
    stage: deploy
    script: make deploy

  job 5:
    stage: .post
    script: make something useful at the end of the pipeline

The .pre and .post stages are available to every pipeline. User-defined stages are executed after .pre and before .post.

There are also two edge cases worth mentioning:

If no stages are defined in .gitlab-ci.yml, then the build, test, and deploy are allowed to be as the job's stage by default.
If a job does not specify a stage, the job will automatically be assigned to the test stage.

4. Continuous Integration

You can set up a set of scripts to build and test your application on every code push that could save your application from sudden surprises.

Let's do a simple CI.

stages:
  - test

Test:
  stage: test
  script:
    - echo "write your test here."
    - test -f "index.html"

The above job will check the index.html file exists or not. If it does not exist, the job will fail. Here the CI runs on every code push to the repository, Although we haven't given any control to the job Test.

Alright, Let's move on to the delivery.

5. Continuous Delivery

Continuous delivery is a development practice where code changes automatically prepared for a release to production. It is an extension of continuous integration to make sure that you can release new changes to your customers quickly in a sustainable way.

stages:
  - test
  - deploy

Test:
  stage: test
  script:
    - echo "write your test here."
    - test -f "index.html"

Deploy:
  only:
    refs:
      - master
  stage: deploy
  script:
    - sudo cp -R ./index.html /var/www/html/

Here you see a Deploy job with the only keyword, which lets the job trigger only on the master branch actions.

Whenever you come across any job failing, you'll be able to see the logs on the console. It will help you move forward.

Conclusion

Here we are! We took an extra step in our tech journey. In modern software development, CICD is an essential factor to be considered. So that I'm hoping this guideline makes sense to everyone.

“ Releasing software is too often an art; it should be an engineering discipline. ” -- David Farley

React Native CLI and Android Studio: Setting up the development environment on Linux

Prakhil Thottipully — Sat, 15 Aug 2020 22:45:19 +0000

This guideline will cover the absolute basics of getting started with React Native and Android studio using standard procedure.

Tl;dr

You'll need Node, JDK, React Native CLI, Android Studio to get started on your project.

1. Install Android Studio and Emulator.
2. Install Java Development Kit (JDK).
3. Configure environment variables.
4. Install Nvm, Node, yarn, react-native.
5. Running a new react-native app in a virtual device.
6. Troubleshoot.

These steps will show you how to install and configure tools for developing React native app on Linux. I've specifically used Fedora 32 for testing things out, but you should be able to translate the commands to the Linux distribution you're using.

1. Install Android Studio

Download and install the Android studio. Be sure to mark the following boxes while installing.

Android Virtual Device
Android SDK,
Android SDK Platform

Once it finishes, open the SDK manager.

under the SDK Platforms tab, select a platform and make sure the following boxes are in it.

Android SDK Platform 29
Intel x86 Atom_64 System Image or Google APIs Intel x86 Atom System Image

Same way, take the SDK Tools tab, make sure that the following are marked.

Android SDK Build-Tools
NDK (side by side)
Android Emulator
Android SDK Platform-Tools

2. Install Java Development Kit (JDK)

The JDK enables your computer to understand and run java code. React Native requires at least version 8 of the java development kit. You may download and install OpenJDK.

Run the following command to install OpenJDK in fedora.

    sudo dnf install java-11-openjdk.x86_64

3. Configure environment variables

Updating environment variables is necessary for the React native to build apps with native tools.

Open .bashrc file sudo vim ~/.bashrc
Feel free to use any text editor that you're comfortable with.

Add the following lines to your config file.

export JAVA_HOME="/usr/lib/jvm/java-11-openjdk-11.0.8.10-2.fc32.x86_64"
export ANDROID_HOME="$HOME/Android/Sdk"
export PATH="$PATH:$ANDROID_HOME/emulator"
export PATH="$PATH:$ANDROID_HOME/tools"
export PATH="$PATH:$ANDROID_HOME/tools/bin"
export PATH="$PATH:$ANDROID_HOME/platform-tools"

Save it. Then run source ~/.bashrc to make the changes get reflected.

4. Install node and react-native CLI

In this section, we're going to install necessary packages that help the react-native CLI to work smoothly.

4.1 Install nvm

Let's start with nvm, which allows us to manage different versions of the node.

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash

To verify that nvm has been installed, do: command -v nvm

If you don't have curl, then you need to install it first.

4.2 Install node

We will use the latest node stable version:

    nvm install stable

You might need to open a new terminal for the nvm path to be loaded.

4.3 Install yarn

we will use yarn to manage our node packages. In Fedora, you can install yarn via the RPM package repository.

curl --silent --location https://dl.yarnpkg.com/rpm/yarn.repo | sudo tee /etc/yum.repos.d/yarn.repo

Then you can simply:

 sudo dnf install yarn

Note: The above command only works for Fedora-based distributions. (check yarn website for other distributions.)

4.4 Install React Native

yarn global add react-native-cli

5. Running your app on a virtual device

Alright, let's initialize the project repository and create a virtual device to run the project.

5.1 Initialize new React native project

First, move to the folder where you want to create your project folder. Then follow the command below.

react-native init <project-title>

5.2 Create Virtual Device

Launch Android studio then select AVD Manager from the configure menu. Then a window will show up.

1. Click on the Create Virtual Device
2. Choose a device you wish to install. Ideally, you want to have ones that already have Play Store included.
3. Select system image with API Level 27 or above (download it if needed).
4. Click on Finish to view the next screen, which lists the created emulators.
5. Click the play button to launch the emulator.

Note: This may fail if your OS /tmp folder has insufficient space, displaying an error saying “No space left on device”. In this scenario, just increase its size to 8gb with the following command:
sudo mount -o remount,size=8G,noatime /tmp

5.3 Run your app

Finally, run your app on the emulator.

Go to your project directory
Open up two different terminals

One for running the Metro Bundler:

 react-native start

Another one for install and launch your app on the device:

 react-native run-android

That's it! Your app should be running on your virtual device.

6. Troubleshoot

Here we are going to look at the most common errors you may encounter while setting up the environment.

Task :app:compileDebugJavaWithJavac FAILED

message: Could not find tools.jar

This error will encounter when the JDK is not present in your system, or the system doesn’t recognize your JDK installation.

Solution: Verify the environment variable JAVA_HOME path is pointing to the right directory if not then update the path.
If it doesn't work for you, then reinstall the JDK.

Task :app:installDebug FAILED

message: No connected devices! OR Unknown failure: cmd: Can't find service: package

This error will encounter If you haven't created any virtual devices, or the runtime cannot recognize your device.

Solution: Creating a virtual device will help you to cover up the "No device connected" error.
For that, open up the Android Studio -> AVD Manager -> Create Virtual Device.

If it doesn't help you, then try the below commands.

adb devices

This command will show the list of devices available with their deviceID. Copy the deviceId and run our React Native app with the deviceId.

react-native run-android --deviceId <deviceId>

example: react-native run-android --deviceId emulator-5554

Conclusion

That's it! We've gone through every step to get started with the React Native on the Linux environment. I hope you guys got a little glimpse of wisdom from this article. See you in the next one.

What all trouble you got while setting up the environment? Share in the comments.

Cron Job made easy: A setup guide to cron

Prakhil Thottipully — Wed, 22 Jul 2020 09:17:40 +0000

You can use a cron job for any program which runs on Linux by using the following method.

Tl;dr

Create a script.sh file perform any action.
Make use of crontab -e command to create the cron job.
Set the job to run the script for the specified timings.
We troubleshoot the job by looking at the logs.

Commands to manage cron jobs.
Cron syntax.
Setting up the script.
Troubleshoot.
Conclusion

Cron is a useful tool in Linux that most developers love because it lets you run automated commands at specific periods (minutes, hours, days, etc.).

Cron jobs run in the background and its keep checking few files and directories (/etc/crontab/, /etc/cron.*/ and var/spool/cron ..etc). Cron files are not supported to be edit directly, and each user has a unique crontab. The crontab stands for the cron table. It is the list of commands that you want to run on a regular schedule.

Commands

The commands for creating and editing cron jobs are the same and simple. And what's even cooler is that you don't need to restart the cron after making changes to the existing one.
cool! right?

let's view our cron table entries before creating a new one.

crontab -l

It will list if it has any. Anyway, let's move on to the step to create a cron job.

crontab -e

Nothing special, single parameter change to command!.
The command may prompt you to select a text editor(nano, vim), go on with the comfortable one.

Now, we have a crontab file opened on a text editor to write our entries.

Cron syntax

Just as it is with any language, working with cron is a lot easier when you understand its syntax.

MIN HOUR DOM MON DOW CMD

Field	Description	Allowed Value
MIN	Minute field	0 to 59
HOUR	Hour field	0 to 23
DOM	Day of Month	1-31
MON	Month field	1-12
DOW	Day Of Week	0-6
CMD	Command	Any command to be executed.

That's not all. Cron uses 3 operator symbols which allow you to specify multiple values in a single field.

Asterisk (*) - specifies all possible values for a field.
The comma (,) - specifies a list of values.
Dash (-) - specifies a range of values.
Separator (/) - specifies a step value.

By looking at the syntax we can write our entries.

0 3 * * * /home/user/path/to/script.sh

Meaning, Run /home/user/path/to/script.sh at 3 am every day.
You can adjust periods by changing the time parameters.

*/30 * * * * /home/user/path/to/script.sh

The above one will run the script every 30 minutes.

30 * * * * /home/user/path/to/script.sh

This would run at 1:30,2:30,3:30.

0,30 * * * * /home/user/path/to/script.sh

This would run at 1:30,2:00,2:30,3:00,3:30.

Write this entry on the text editor we're previously opened using
crontab -e command. Before saving it we need to set up our script for this.

Setting up the script

Cron doesn't support relative path, therefore you've to write the absolute path for everything that you are pointing.

You can find the absolute paths of directories by simply typing pwd on your terminal.

Make sure your script has execute permission.

chmod +x script.sh

That's it!

Save it all to run the cron job for the specified time period.

Troubleshoot

Cron jobs are commands that your service runs at a specified interval and, as such, can be difficult to troubleshoot.

Although we can't directly troubleshoot, some of the common mistakes are:

Using a relative path. You must be sure to use only absolute paths inside that script.
Permissions are too strict. Please be sure all scripts, files that are being used are set to executable.

chmod +x <file name>

You can check the cron logs to make sure that the crontab is working correctly. The logs are default located in
/var/log/syslog. And running the following grep command will get you all cron logs.

grep -i "CRON" /var/log/syslog

If you're not finding the syslog file in your system, Then try the below command.

journalctl | grep "CRON"

Conclusion

Let's go through the steps we've done.

Created a script.sh file to perform the action.
Add an entry to the cron table using crontab -e command.
The crontab entry should point to the script.sh file.
We troubleshoot the job by looking at the logs

Forem: Prakhil Thottipully

Add font ligatures to your Alacritty

Tl;dr

How to do it?

Install the binary

Conclusion

GitLab CI/CD: A guideline to set up your pipeline

Tl;dr

1. Requirements

2. Setting up GitLab runner agent

1. Install GitLab Runner

2. Register the Runner

3. Pipeline configuration

jobs

stages

stage

4. Continuous Integration

5. Continuous Delivery

Conclusion

React Native CLI and Android Studio: Setting up the development environment on Linux

Tl;dr

1. Install Android Studio

2. Install Java Development Kit (JDK)

3. Configure environment variables

4. Install node and react-native CLI

4.1 Install nvm

4.2 Install node

4.3 Install yarn

4.4 Install React Native

5. Running your app on a virtual device

5.1 Initialize new React native project

5.2 Create Virtual Device

5.3 Run your app

6. Troubleshoot

Task :app:compileDebugJavaWithJavac FAILED

Task :app:installDebug FAILED

Conclusion

Cron Job made easy: A setup guide to cron

Tl;dr

Contents

Commands

Cron syntax

Setting up the script

Troubleshoot

Conclusion