DEV Community: Pradipta Sarma

Launch Sublime from the Command Line

Pradipta Sarma — Fri, 17 Sep 2021 14:21:52 +0000

Sublime is a powerful source code editor. It is also used a lot to clip notes and stuff, thanks to it being very light weight.
As a developer, if you aren't using Sublime yet, I highly recommend you do.

Sublime Text comes with a CLI out of the box. For version 3 or 4, check in the directory /Applications/Sublime\ Text.app/Contents/SharedSupport/bin. There should be an executable named subl.
On that directory, try running ./subl on a the terminal, it should launch Sublime Text for you. Btw, I hope you're using iTerm 2 with ZSH and not the Terminal that comes with Mac, if you're on Mac. If not, check out this blog.
Now to move to this directory and then executing this command every time is not of a big help, we create a shortcut for us.

$PATH is an env variable that lists all the directories that the OS should look for, for an executable.
Run echo $PATH to check your env value. Pick any directory from there, for instance, I picked /usr/local/bin.

You now need to create a link from this directory to the executable. You can do that by running:

ln -s /Applications/Sublime\ Text.app/Contents/SharedSupport/bin/subl /usr/local/bin/sublime

This creates a symbolic link between two files. For my case, the /usr/local/bin/sublime actually points to /Applications/Sublime\ Text.app/Contents/SharedSupport/bin/subl.

With this link being created, you can execute/run sublime from anywhere using the Terminal app and it will launch Sublime for you.

Now you can launch sublime from anywhere executing sublime, as well as open a particular file by mentioning the file name as well. Example:

touch test
sublime test

The above commands would create a file named test and would open it in Sublime Test.

Sublime CLI also comes in with a lot of other stuff, check sublime --help for more.

PS: a lot of sites mention the link command as: ln -s "<the directory>" <target directory>, however, for me, avoiding the quotes worked, and not the other way around.

Save time remembering SSH hosts

Pradipta Sarma — Mon, 09 Aug 2021 05:02:55 +0000

As part of my work I regularly have to SSH into various hosts to perform some actions or to debug issues.
Every time I do it, I head to our internal cloud dashboard to figure out the IP address of the host that I need to SSH into. There are a few hosts for particular services that I SSH into very frequently, almost on a daily basis.

It is not possible to remember IP addresses, which look like 10.12.13.14.

Assigning a name is easier. I now have created aliases for my most frequently used hosts.

On the ~/.zshrc file, I added:

alias ssh-service-env-zone="ssh ipaddress"

The next time I wish to SSH into ipaddress, I can just do a ssh-service-env-zone.

This gets even better with Auto Suggestions and Syntax Highlighting. For details check out this blog

Manage Multiple Git Accounts on a Computer

Pradipta Sarma — Tue, 08 Jun 2021 17:21:53 +0000

Want to use a Git account for work and one for personal projects? Here's how.

I recently started working for a company that uses GitHub Enterprise for their Git solution. I set my work laptop and it's terminal to use that GitHub account and git credentials to manage git on my computer.
I also wanted to work on my personal projects which I have maintained on my GitHub account. The process to maintain multiple Git accounts on a single machine was straightforward but I wasn't aware of the how-tos.

I looked up upon it a little and got it to work. If you're looking for the same, follow the steps:

(The commands and directories are according to a Mac computer. Things might change on a Linux or a Windows, but the job to be done remains the same, please look uiip for the right commands in that case.)

1. Generate separate SSH Keys for both (or more?) accounts

head to your .ssh directory and generate sets of SSH keys for both the accounts. This can be ignored for the accounts which already have a pair generated. This was true for my case as I had already set up my work account.
To generate a pair of ssg keys, run ssh-keygen -t rsa
Follow the instructions that ask for a file location, name, etc. For the name, I prefer setting something like id_rsa_work and id_rsa_personal as it is easier to identify (in case I need to someday).

2. Manage ssh config file

There should be a file named config in the .ssh folder. If not, we need to create one by running touch config.
Edit the config and add the following lines into it:

#work account
Host github<-identifier>.com
   HostName <enterprice github host>
   User git
   IdentityFile ~/.ssh/id_rsa_work
   IdentitiesOnly yes

#personal account
Host github<-identifier>.com
   HostName github.com
   User git
   IdentityFile ~/.ssh/id_rsa_personal
   IdentitiesOnly yes

Example config:

#pradipta-sarma account
Host github.com
   HostName xyz.github.com
   User git
   IdentityFile ~/.ssh/id_rsa_work
   IdentitiesOnly yes

#pradipta account
Host github-personal.com
   HostName github.com
   User git
   IdentityFile ~/.ssh/id_rsa_personal
   IdentitiesOnly yes

And save the file.

3. Register the SSH keys on the respective GitHub accounts

This step is to let GitHub identify our machine and authorize it, to avoid typing in the id and password everytime.
Follow the steps here to add the keys to the respective accounts.

To avoid using the work account on a clone for a personal repo, you can change a clone from:
git clone git@github.com:user/repo.git to git clone git@github-personal.com:user/repo.git

With this, you're good to go. Let me know if there's an issue or if I have missed something.

Originally posted here

Mongock, Mongo and Java

Pradipta Sarma — Sun, 29 Nov 2020 16:55:51 +0000

Originally posted on my blog

Database Migration tools are essential with applications where you need to migrate data into a database, change a schema, update a record/document across all environments and where it is tedious to do it manually (almost always?). These can also help you with keeping a track of the changes made, just like version control.

With Java there are various libraries you can use for the purpose. There's Liquibase, Flyway, Mongock and maybe more.

When using MongoDB as the database for the application, I found that Mongock would be the best to go for.

Mongobee seems to be outdated and not being maintained anymore.

To use the same with a Java, you would need the following dependencies (in addition to the Mongo Java Driver/Spring Mongo data that you'd use to set up the application anyways):

Make sure not to import Mongock Core along with the above dependencies, as it will lead you into having multiple versions of a library in your classpath. Read more on this here

On importing the above, all you need to do is:

Annote the Application Class with @EnableMongock
Specify the package(s) where you'd localte your Changelog classes on your application.yml or application.properties under mongock.change-logs-scan-package

With this, the application should be ready to be run, without an issue. If you face any, leave a comment or visit the issues section on Github, and you'd most likely find a solution for it.

To add a changelog, create a changelog class in the package mentioned in the properties file. Annotate the class with @Changelog(order = "001..."). The order defines the order in which the changelog classes will be executed in case there are multiple. The class should now contain the changesets. The changesets are nothing but Java methods. You can create collections, insert a document, or do whatever you'd want to that you can do via a Java method. The method would run at the Startup and the changes (if any) would get executed (if not already).

Example class:

@ChangeLog(order = "001")
public class Changelog {
    @ChangeSet(order = "001", id="001", author = "pradipta")
    public void dummyChangeSet() {
        System.out.println("Dummy changeset");
    }

    @ChangeSet(order = "002", id="create collection", author = "pradipta")
    public void createCollection(MongoDatabase db) {
        MongoCollection<Document> mycollection = db.getCollection("dummycollection");
        Document doc = new Document("k1", "v1").append("k2", "v2");
        mycollection.insertOne(doc);
    }

    @ChangeSet(order = "003", id = "insert document", author = "pradipta")
    public void insertDocument(MongockTemplate mongockTemplate) {
        User user = new User("Name", "Email", "Phone");
        //User is an entity with a collection already defined
        mongockTemplate.save(user);
    }
}

There is also another method where you write the builder yourself and not annotate the application with @EnableMongock. You'd want to do it if you want to have a control over the beans and configure things. Read the documentation for more info.

With these, you can be sure to have the changes being executed onto the DB on a successful deployment to any environment.

Happy coding.

A Problem with JJWT With Java 11 (9+)

Pradipta Sarma — Fri, 13 Nov 2020 17:10:20 +0000

Originally posted on my blog

I was implementing Spring Security for a service I am working on for work. The project is based on Java 11 and the Spring Boot Framework.
Usign the JWT token, I was supposed to extract user details and roles. The JWT is signed using a secret key with has been stored in properties encoded in base 64.

Jwts.parser().setSigningKey(appProperties.getAuth().getTokenSecret()).parseClaimsJws(authToken);

The above code is used to validate the JWT's authenticity.

The setSigningKey(...) method looks like:

    public JwtParser setSigningKey(String base64EncodedKeyBytes) {
        Assert.hasText(base64EncodedKeyBytes, "signing key cannot be null or empty.");
        this.keyBytes = TextCodec.BASE64.decode(base64EncodedKeyBytes);
        return this;
    }

This method throws an error when it tries to decode the encoded key.
Logs:

java.lang.ClassNotFoundException: javax.xml.bind.DatatypeConverter
    at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:606) ~[na:na]
    at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:168) ~[na:na]
    at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:522) ~[na:na]
    at io.jsonwebtoken.impl.Base64Codec.decode(Base64Codec.java:26) ~[jjwt-0.5.jar:0.5]
    at io.jsonwebtoken.impl.DefaultJwtParser.setSigningKey(DefaultJwtParser.java:71) ~[jjwt-0.5.jar:0.5]

However, the same Library was being used on other projects I/my team had worked on written in Java 8. There, the decode method calls an api from jaxb, but I obserrved that on the Java 11 project, it wasn't the case. Even with exact same version of jjwt.

The problem lies with JJWT with Java 11 (or any after Java 8).

The jaxb APIs are considered to be Java EE APIs. The API is completely removed from the Java 11 SDK. With the introduction of modules since Java 9, the java.se module is available on the default classpath, and it doesn't include Java EE APIs.

To fix the same, you can pass --add-modules java.xml.bind as a command line argument.
A better fix is to add the jaxb API as a Maven/Gradle dependancy.

<!-- Runtime, com.sun.xml.bind module -->
<dependency>
    <groupId>org.glassfish.jaxb</groupId>
    <artifactId>jaxb-runtime</artifactId>
    <version>{version}</version>
</dependency>

compile group: 'javax.xml.bind', name: 'jaxb-api', version: '{version}'

This makes jaxb APIs available in the classpath and the above problem gets fixed.

Sources:

Link 1 | StackOverflow

Link 2 | ProgrammerSought Blog

Link 3 | GitHub

Manage Multiple JDK Versions on Your Computer

Pradipta Sarma — Thu, 12 Nov 2020 17:49:22 +0000

Originally published on my blog

Java now released a new version every 6 months, the latest as on the date of this post is the JDK 15, while the LTS are released at longer intervals.

You might be using a version of Java for work or your personal use, and may need to use another version of it for a different project. Or, if you're one who would want to try out the newest version as soon as it comes out and also have the stable version installed, this can help. Although, you can pick up a JAR from anytime in the past 25 years, and most likely it will run on the newest version of Java, it is good to have an LTS (or whatever your main version of need is) installed for your actual projects.

To change a version of Java, you need to change the JAVA_HOME environment variable. And it's a pain to do it every time.

I have two projects that I work on almost everyday. One runs on Java 8 while the other is on Java 11. Here's what I did to be able to switch between them when needed.

export JAVA8_HOME=$(/usr/libexec/java_home -v1.8)
export JAVA11_HOME=$(/usr/libexec/java_home -v11)

alias java8='export JAVA_HOME=$JAVA8_HOME'
alias java11='export JAVA_HOME=$JAVA11_HOME'

# To use Java 8
java8

# To use Java 11
java11

After doing so, I now have two aliases java8 and java11, calling which, sets my JAVA_HOME to either JAVA8_HOME or JAVA11_HOME. Adding a new one is as easy as exporting a new home and creating an alias for it.

In case you're using zsh, you can write these into your .zshrc file using echo or pasting them into the file manually and doing a source ~/.zshrc. An awesome tutorial to set up ZSH is up here or here

There is another way of doing this using jenv. A post on that will be here soon.

Day 1 with the Github CLI 1.0

Pradipta Sarma — Tue, 29 Sep 2020 18:30:41 +0000

Originally posted on my blog

GitHub finally launch their CLI, versioned 1.0 after 7 months of having it in Beta. Done with Cmd+Tab / Ctrl+tab to move to the browser. Do it all at one place.

You can install the GitHub CLI on you laptop and can perform entire GitHub's workflow right from the terminal, starting from creating an issue, reviewing a PR, to merging a PR.

You can create aliases against any commands.
You can also use GitHub APIs to trigger Actions.

Visit this link for the official documentation.

To install Github CLI, open the terminal and run:

brew install gh [Mac]

sudo apt-add-repository https://cli.github.com/packages && sudo apt update && sudo apt install gh [Linux]

scoop bucket add github-gh https://github.com/cli/scoop-gh.git [Windows]

After the installation, we need to authenticate the CLI with our GitHub Account. For that, run gh auth login and proceed with the instructions that follow.

On a successful login, we now can perform all the workflows of GitHub, for which, previously, we had to open the browser, right from the terminal.

Let's look at some of them.

gh repo clone <repo name>

A gh repo view would show us the Readme for the repo, if any.

We can create an issue on a repo using gh issue create and entering the details that it asks for.

I created a new branch and made some changes, commited them and pushed it to the branch. To raise a PR, I previously had to go to GitHub.com on my browser and raise it from there. No more. All you need is: gh pr create

We can also perform PR reviews from the CLI. I haven't tried out reviewing a big PR on it to put my thoughts about it. But yes, we can. We can approve, leave comments, or request for changes right from the CLI.

Also, have it merged.

This is just an overview, there are a whole lot of commands we need to play around and try out.

One of the best things: to create a new repo, we donot need to do a git init, Create Repo on GitHub.com, and git remote add origin .... It is just a command on the CLI.

Happy Git!

Build a Slackbot using Hubot

Pradipta Sarma — Sun, 14 Jun 2020 17:05:53 +0000

Originally posted on my blog

"Hubot is your friendly robot sidekick."

Hubot is open source, it is written in Coffee Script on NodeJS by Github. It can automate a lot of stuff and bring up fun in around the office, and improve efficiency in some tasks.

Hubot comes along with a few built-in scripts and is pretty fun to use in itself. It can be used on your command line, or can be integrated to other services, like Slack. You can even write your own script or an NPM module and import it into your Hubot project. The script can be written in CoffeeScript, or JS.

To get started with Hubot, you must have NodeJS and NPM installed.

To generate your hubot run npm install -g yo generator-hubot

Now think of a name for your Hubot and create a directory. I named mine Alfred

$ mkdir alfred
$ cd alfred

Here you can now generate your Hubot by running yo hubot

You can now run the hubot by running ./bin/hubot

To get a list of all supported commands by Alfred, run alfred help. Since it already comes with some scripts and modules installed, you can play around with it.

Although these are fun, they are not of actual help. We can write our own scripts that can do what we want them to do. We can automate stuff, make it talk to third party apis, deploy services, set reminders and what not! You can also persist data into its own Redis service (called Hubot Brain) or connect it to an external database service.

There are other open source Hubot scripts. Search for them on the NPM registry for hubot-scripts <your-search-term>. Once you find one you can install it and put it up on external-scripts.json.

To write your own script:

You must place the CoffeeScript or the JS in the scripts directory
You must have to export the function from the script

Let's create a custom script which gives you the idea of how to actually write one. Move to the scripts directory, and create a .coffee or or a .js file. I named mine alfred.coffee

cd scripts

The first thing you need to do is add this section in the script:

# Description:
#   Alfred Hubot
#
# Dependencies:
#   None
#
# Configuration:
#   None
#
# Commands:
#   hubot hello
#
# Author:
#   pradipta.sarma

This is where Hubot can index your command into its list of all commands, which shows up on hitting alfred help

To export the function off the script:

module.exports = (robot) ->
    #Your code here

To respond to messages, we write the respond code as:

models.respond /hello/i, (res) ->
    res.reply("Hey, what's up?")

This code will make the bot listen to his name followed by the Regex pattern /hello/i, and should reply with “Hey, what’s up?”

res is the object that contains the message details, sender name, channel (if on Slack) etc. You can look around and find some useful information in there. To customise the message you can change the code to:

module.exports = (robot) ->
    robot.respond /hello/i, (res) ->
        res.reply("Hey "+res.envelope.user.name+", what's up?")

On trying alfred hello now, the response would Hey Shell, what's up?. Since it is running it on Shell. This name would be replaced by a user's username if the bot had been running on Slack.

To add more functionalities to your bot, this is all you need to know. You can add more .respond code with a suitable regex so that it gets triggered and the code following it executes. You can make HTTP calls, run a workflow, send an email, trigger a deployment, or whatever you want to automate with it.

Slack comes with the option of integrating a Hubot out of the box. Go to .slack.com/apps and search for Hubot. Enter a name for the bot and other details that Slack asks for and once done, Slack will provide you with a Token. We need this token when we want to run the bot on Slack.

To run the bot on Slack, make sure your computer has an internet connection (if running locally), or you're running on a cloud server. Run command:

HUBOT_SLACK_TOKEN=YOUR_SLACK_TOKEN ./bin/hubot --adapter slack

It should now be up an running on Slack. Add the bot to a channel and send alfred ping. It should respond with PONG

In my previous organization there was Winky, a friendly bot which helped developers reserve dev and staging environments so that nobody has a conflict, nobody else deploys while somebody is testing a feature, but instead get the details of whoever is using an instance so that he/she can get in touch and maybe merge the changes and deploy together.

I wanted to build something similar for my current organisation and that’s when I started off with Alfred and learned how to build a Hubot, integrate it with Slack and have it running on a server. I drew the idea from Winky, and Alfred here does almost the same thing. Thanks to Nemo from Razorpay.

Checkout this repository for the code to the bot built for our workspace.

Good luck. Build a few bots. Happy coding.

Terminal Setup on macOS

Pradipta Sarma — Mon, 18 May 2020 03:59:27 +0000

Originally posted on my blog
This is what the default terminal looks like on a Mac:

And this sucks. It looks bad, it is hard to read, and differentiate. And there are no fancy colors.

To boost it up and level up the terminal game we’re going to use use the following:

iTerm2
ZSH
Oh My ZSH

Steps:

Install Homebrew. For that, run:

ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

You may need to install Command Line tool for X-Code before that.

xcode-select --install

Download and install iTerm2 from here or run:

brew cask install iterm2

Install ZSH and oh-my-zsh

brew install zsh
sh -c "$(curl -fsSL https://raw.github.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"

To run zsh shell, run:

zsh

We’re also going set up Auto Suggestions and Syntax Highlighting to make the experience friendlier and easier to use. To do that we need to edit the .zshrc file (located at ~/.zshrc). This is where most of our configuration is going to take place.

Install zsh-autosuggestions and zsh-syntax-highlighting:

brew install zsh-syntax-highlighting
brew install zsh-autosuggestions

You can set your ZSH theme by putting in this line into your .zshrc file. Make sure you import the .zshrc after any change for it to reflect.

ZSH_THEME=robbyrussell

At this point your terminal/iTerm2 should look something like:

And this is much better. Notice the short git commands that I’ve used? Well, those are configurable too. Follow this repository for the complete guide and .zshrc file with all the configurations, aliases and functions.

Thanks for reading.

Originally posted on https://pradipta.github.io/posts/zsh/

Find all my blogs at OmniaCode