DEV Community: Kinjal

Configure JDK17 in Ubuntu 20.04

Kinjal — Fri, 03 Dec 2021 06:33:03 +0000

Java 17 was released in September 2017. Java has multiple distributors as it is open source.
Download from jdk.java.net for openjdk. The commerical verion can be found from oracle.

In this setup openjdk x64 version is used.

Here are the steps to configure jdk17.

Create default jdk location if it is not there

$ mkdir /usr/lib/jvm/ cd $_ 
$ tar -xvzf ~/Downloads/openjdk-17.0.1_linux-x64_bin.tar.gz

Inside /opt create a directory for jdk which will link to the actual jdk package.

$ cd /opt
$ mkdir jdk
$ ln -s /usr/lib/jvm/jdk-17.0.1 jdk17

Once the following symlink is created, the next is to update ~/.bashrc file to update path for Java.

$ jdk17 -> /usr/lib/jvm/jdk-17.0.1

Add the following lines to ~./bashrc

export JAVA_HOME=/opt/sun/jdk17/bin
export PATH=$PATH:$JAVA_HOME/bin

The setup is completed and now Ubuntu should be informed about the new package by using update-alternatives

$ sudo update-alternatives --install "/usr/bin/java" "java" "/usr/lib/jvm/jdk-17.0.1/bin/java" 0
$ sudo update-alternatives --install "/usr/bin/javac" "javac" "/usr/lib/jvm/jdk-17.0.1/bin/javac" 0
$ sudo update-alternatives --install "/usr/bin/javap" "javap" "/usr/lib/jvm/jdk-17.0.1/bin/javap" 0
$ sudo update-alternatives --set java /usr/lib/jvm/jdk-17.0.1/bin/java
$ sudo update-alternatives --set javac /usr/lib/jvm/jdk-17.0.1/bin/javac
$ sudo update-alternatives --set javap /usr/lib/jvm/jdk-17.0.1/bin/javap

Now, verify the setup to know jdk location as it was provided

$ update-alternatives --list java 
$ update-alternatives --list javac
$ update-alternatives --list javap

Finally, verify the java version

$ java -version
openjdk version "17.0.1" 2021-10-19
OpenJDK Runtime Environment (build 17.0.1+12-39) 
OpenJDK 64-Bit Server VM (build 17.0.1+12-39, mixed mode, sharing)

Sample code to setup Selenium, chrome driver with a java project

Kinjal — Thu, 02 Dec 2021 10:35:54 +0000

Slenium is popular open source project that consists of a range of tools and libraries. Here is the most basic example to get started selenium with a java project.

At the core of the selenium is webdriver.

It is a powerful API that drives a browser natively, just as a user would do.

Major components of webdriver are - selenium client library, JSON wire protocol over HTTP, browser drivers, and browsers.

To get started first, download webdriver version 96. Select the webdriver version as per the chrome browser version where the tests will be executed.

Get chromedriver_linux64.zip file and unzip it the project directory.

The project that I am using here is a java project created using gradle build.

The next step is to unzip and copy the driver the project directory.

unzip /tmp/chromedriver_linux64.zip -d <PROJECT_DIR>/webdriver/v96/

Once the driver is ready, now it is time to write a sample program.

Make sure program should import the selenium related packages from org.openqa.selenium



import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;

public class SeleniumBasicExample { 
 final static String PROJECT_PATH = System.getProperty("user.dir");
  public void run() 
    throws Exception
     {
      System.setProperty("webdriver.chrome.driver", PROJECT_PATH + "/webdriver/v96/chromedriver");
      ChromeOptions chromeOptions = new ChromeOptions();
      chromeOptions
        .addArguments("--headless")
        .addArguments("--no-sandbox");

      WebDriver driver = new ChromeDriver(chromeOptions); 
      driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);

      // set any url for test, here is an example with google
      driver.get("https://google.com");
      Thread.sleep(1000);
      if (driver.getPageSource().contains("I'm Feeling Lucky")) {
       log("pass");  
      } else {
       log("fail");
      }
      driver.quit();
     }
}

Here is the output of the above program -

Download SeleniumBasicExample

Clear out MySql/MariaDB binary log files

Kinjal — Tue, 07 Sep 2021 12:47:49 +0000

I came across the following error while resroting a databsae in MariaDB.



ERROR 3 (HY000) at line 87066: Error writing file '/tmp/MLvCaXNh' (Errcode: 28 "No space left on device")

This is due to the excesive binary logs which are generated by database server.

From MariaDB documentation - The binary log contains a record of all changes to the databases, both data and structure, as well as how long each statement took to execute. It consists of a set of binary log files and an index.

It is required to periodically clear out those logs to avoid runninng into the problem of No space left on device.

Clearing old log files also helps the process of database replication.

List all the binary logs:



mysql> show binary logs;

And the query to delete all old files that were generated 2 days back:



mysql> purge binary logs before date(now() - interval 2 day);

You can only delete the files that are older than the oldest file that is used by the slaves.

The diskspace error should be gone after clearing the logs.

Where these log files are stored?

Usually log files are stored in /opt/mariadb/data.

^{Reference:

PURGE BINARY LOGS}

A simple Gradle build with example on Ubuntu

Kinjal — Thu, 02 Sep 2021 18:34:44 +0000

Gradle is a higly customizable, powerful and fast build system.
Let's walk through a simple example to configure a project using gradle.

First, download a specific release.

Here are the steps to configure it.



$ mkdir /opt/gradle
$ unzip -d /opt/gradle gradle-7.2-bin.zip
$ ls /opt/gradle/gradle-7.2/
LICENSE  NOTICE  README  bin  init.d  lib

Add the following line in ~/.bashrc.



export PATH=$HOME/.local/bin:$PATH

~/.bashrc file should be updated to get the changes.



$ source ~/.bashrc

Run gradle -version when the above steps are completed.

Let's call the project name blue and scaffold gradle for it.



$ mkdir blue
$ cd blue
$ gradle init

It will ask few to setup the directory strucutre



Select type of project to generate:
 1. basic
 2. application
 3. library
 4. Gradle plugin

For this example, let's select 2. application.

The following question will ask selecting the implementation language which I choose java.

The other options could be selected as per the given default choice.

Let's create a makefile and add some basic gradle commands there.



$ cat makefile
 JAVA_HOME = /opt/sun/jdk15
 GRADLE_HOME = /opt/gradle/gradle-7.2

 GRADLE = $(GRADLE_HOME)/bin/gradle
 clean:
       ./gradlew clean  
 build:
      ./gradlew build
 run:
      ./gradlew run
 test:
      gradle test --tests AppTest

App.java which is located in app/src/main/java/blue/ is the entry point to the project.
Edit this class and add soem message to it.



package blue;

public class App {
 private String getMessage() { return "My Gradle Project"; } 

 public static void main(String[] args) {
   App app = new App();
   System.out.println(app.getMessage());
 }
}

Now, run the project.



$ make build
$ make run

The sample message should be printed in the console if the build is successful.

Download this sample.

Linux make install command

Kinjal — Wed, 01 Sep 2021 13:56:49 +0000

While installing packages in linux, we come across the following command many times.

$ make install

Let's understand this with a simple example.

install is a command that was written for software installation, but it can do more than that. make install will do whatever instruction is defined in makefile.

This example uses a sample hello world C program.

#include <stdio.h> 
int main() {
 printf("Hello, World!"); 
}

Here is the directory structure of testapp which is created for this example.

$ ls testapp
installer.sh  makefile  testapp  testapp.c  testapp.conf

Let's take closer look at installer.sh

#!/bin/bash
ROOTDIR=${1:-/opt/testapp}
OWNER=${2:-testapp}
GROUP=${3:-testapp}

# Create bin and opt directories
install -v -m 755 -o $OWNER -g $GROUP -d $ROOTDIR/bin $ROOTDIR/etc
if [ "$?" -ne "0" ]; then
  echo "Install: Failed to create directories."
  exit 1
fi

# install binary
install -b -v -m 750 -o $OWNER -g $GROUP -s testapp $ROOTDIR/bin
if [ "$?" -ne "0" ]; then
  echo "Install: Failed to install the binary"
  exit 2
fi

# install configuration file
install -b -v -m 600 -o $OWNER -g $GROUP testapp.conf $ROOTDIR/etc
if [ "$?" -ne "0" ]; then
  echo "Install: Failed to install the config file"
  exit 3
fi

echo "installation completed.."

All the chown install ect commands are defined in installer.sh and insatller itself is wrapped up in makefile so that makefile can be kept clean.

Here is makefile

all:    testapp.c
    $(CC) -o testapp     testapp.c

clean:
    rm -f testapp

install: testapp
    ./installer.sh /opt/testapp kiwi kiwi

purge:
    rm -rf /opt/testapp

In the install command, kiwi refers to the username. You can have your custom name here.

And the content of sample conf file testapp.conf

$ cat testapp.conf
testapp=testapp

Finally, running it.

$ sudo make install
./installer.sh /opt/testapp kiwi kiwi
'testapp' -> '/opt/testapp/bin/testapp' (backup: '/opt/testapp/bin/testapp~')
'testapp.conf' -> '/opt/testapp/etc/testapp.conf' (backup: '/opt/testapp/etc/testapp.conf~')
installation completed..

testapp can be found in /opt directory if the installation is successful.

That's a very simple example. Here is one useful link for further reading.

Download the code here.

Reference:

^{Shell Scripting: Expert Recipes for Linux, Bash, and more}