Forem: Dhanusha Perera

From Legacy FTP to Secure SFTP: Building a Reusable Java Library with Factory Pattern

Dhanusha Perera — Sun, 27 Apr 2025 14:03:13 +0000

Migrating from legacy FTP to SFTP is a crucial step in modernizing Java applications and ensuring data security. SFTP (SSH File Transfer Protocol) encrypts all data and credentials, protecting sensitive information and meeting compliance requirements. In this post, we’ll build a reusable, internal SFTP client library using the open-source JSch library and the Factory Pattern-now enhanced to support custom SSH algorithms (MACs, key exchange, ciphers), timeouts, and custom ports for maximum compatibility and flexibility.

Why Use an Internal, Configurable SFTP Library?

Consistent security practices across teams
Reduced code duplication
Centralized maintenance and upgrades
Easy adaptation to diverse server policies
No need to publish to a public Maven repository

Library Name

SecureSftpClient

Project Structure

secure-sftp-client/
 ├── src/main/java/com/yourcompany/sftp/
 │    ├── SftpConfig.java
 │    ├── SftpClient.java
 │    └── SftpClientFactory.java
 └── pom.xml

Step 1: Enhanced SftpConfig.java

package com.yourcompany.sftp;

public class SftpConfig {
    private String host;
    private int port = 22;  // Default SFTP port
    private String username;
    private String password;
    private int timeout = 0;  // Timeout in seconds (0 = no timeout)

    // SSH Algorithm configuration
    private String kexAlgorithms;    // Key exchange algorithms
    private String ciphersC2S;       // Client-to-server ciphers
    private String ciphersS2C;       // Server-to-client ciphers
    private String macsC2S;          // Client-to-server MACs
    private String macsS2C;          // Server-to-client MACs

    // Getters and setters
    public String getHost() { return host; }
    public void setHost(String host) { this.host = host; }

    public int getPort() { return port; }
    public void setPort(int port) { this.port = port; }

    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }

    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }

    public int getTimeout() { return timeout; }
    public void setTimeout(int timeout) { this.timeout = timeout; }

    public String getKexAlgorithms() { return kexAlgorithms; }
    public void setKexAlgorithms(String kexAlgorithms) { this.kexAlgorithms = kexAlgorithms; }

    public String getCiphersC2S() { return ciphersC2S; }
    public void setCiphersC2S(String ciphersC2S) { this.ciphersC2S = ciphersC2S; }

    public String getCiphersS2C() { return ciphersS2C; }
    public void setCiphersS2C(String ciphersS2C) { this.ciphersS2C = ciphersS2C; }

    public String getMacsC2S() { return macsC2S; }
    public void setMacsC2S(String macsC2S) { this.macsC2S = macsC2S; }

    public String getMacsS2C() { return macsS2C; }
    public void setMacsS2C(String macsS2C) { this.macsS2C = macsS2C; }
}

Step 2: Enhanced SftpClient.java

package com.yourcompany.sftp;

import com.jcraft.jsch.*;
import java.util.Properties;

public class SftpClient {
    private final SftpConfig config;
    private Session session;
    private ChannelSftp channelSftp;

    public SftpClient(SftpConfig config) {
        this.config = config;
    }

    public void connect() throws JSchException {
        JSch jsch = new JSch();
        session = jsch.getSession(config.getUsername(), config.getHost(), config.getPort());
        session.setPassword(config.getPassword());

        Properties properties = new Properties();
        properties.put("StrictHostKeyChecking", "no");

        // Apply custom algorithms if provided
        if (config.getKexAlgorithms() != null) {
            properties.put("kex", config.getKexAlgorithms());
        }
        if (config.getCiphersC2S() != null) {
            properties.put("cipher.c2s", config.getCiphersC2S());
        }
        if (config.getCiphersS2C() != null) {
            properties.put("cipher.s2c", config.getCiphersS2C());
        }
        if (config.getMacsC2S() != null) {
            properties.put("mac.c2s", config.getMacsC2S());
        }
        if (config.getMacsS2C() != null) {
            properties.put("mac.s2c", config.getMacsS2C());
        }

        session.setConfig(properties);

        if (config.getTimeout() > 0) {
            session.setTimeout(config.getTimeout() * 1000);  // Convert seconds to milliseconds
        }

        session.connect();

        Channel channel = session.openChannel("sftp");
        channel.connect();
        channelSftp = (ChannelSftp) channel;
    }

    public void upload(String localFile, String remoteDir) throws SftpException {
        validateConnection();
        channelSftp.cd(remoteDir);
        channelSftp.put(localFile, ".");
    }

    public void download(String remoteFile, String localDir) throws SftpException {
        validateConnection();
        channelSftp.get(remoteFile, localDir);
    }

    public void disconnect() {
        if (channelSftp != null && channelSftp.isConnected()) {
            channelSftp.exit();
        }
        if (session != null && session.isConnected()) {
            session.disconnect();
        }
    }

    private void validateConnection() throws SftpException {
        if (channelSftp == null || !channelSftp.isConnected()) {
            throw new SftpException(ChannelSftp.SSH_FX_CONNECTION_LOST, "Not connected to SFTP server");
        }
    }
}

Step 3: SftpClientFactory.java

package com.yourcompany.sftp;

public class SftpClientFactory {
    public static SftpClient create(SftpConfig config) {
        validateConfig(config);
        return new SftpClient(config);
    }

    private static void validateConfig(SftpConfig config) {
        if(config.getHost() == null || config.getHost().isEmpty()) {
            throw new IllegalArgumentException("Host cannot be empty");
        }
        if(config.getPort()  65535) {
            throw new IllegalArgumentException("Invalid port number");
        }
    }
}

Step 4: pom.xml

Add the JSch dependency:


<dependency>
    <groupId>com.jcraft</groupId>
    <artifactId>jsch</artifactId>
    <version>0.1.55</version>
</dependency>

Sharing the Library Internally

Since you don’t want to publish to a Maven repository, use one of these approaches:

Option 1: Share the JAR Directly

Build the JAR:

   mvn clean package

The JAR will be in target/secure-sftp-client-1.0.0.jar.

Distribute the JAR to other teams (e.g., via a shared folder).
Add the JAR to the consuming project’s lib/ directory.
Reference the JAR in the consuming project’s pom.xml:


<dependency>
    <groupId>com.yourcompany.sftp</groupId>
    <artifactId>secure-sftp-client</artifactId>
    <version>1.0.0</version>
    <scope>system</scope>
    <systemPath>${project.basedir}/lib/secure-sftp-client-1.0.0.jar</systemPath>
</dependency>

Option 2: Install to Local Maven Repository

Install the library to your local Maven cache:

   mvn install

Add the dependency in other projects’ pom.xml:


<dependency>
    <groupId>com.yourcompany.sftp</groupId>
    <artifactId>secure-sftp-client</artifactId>
    <version>1.0.0</version>
</dependency>

Usage Examples

1. Basic Usage with Default Port and Timeout

import com.yourcompany.sftp.*;

SftpConfig config = new SftpConfig();
config.setHost("sftp.example.com");
config.setUsername("user");
config.setPassword("secret");
config.setTimeout(30); // 30 seconds

SftpClient client = SftpClientFactory.create(config);
try {
    client.connect();
    client.upload("local/path/file.txt", "/remote/dir");
    client.download("/remote/dir/file.txt", "local/path/");
} finally {
    client.disconnect();
}

2. Custom Port and Timeout

config.setPort(2222); // Use a non-standard port
config.setTimeout(10); // 10-second timeout

3. Custom SSH Algorithms (KEX, Ciphers, MACs)

// Example: match server's supported algorithms for compatibility or compliance
config.setKexAlgorithms("diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha1");
config.setCiphersC2S("aes256-ctr,aes192-ctr,aes128-ctr");
config.setCiphersS2C("aes256-ctr,aes192-ctr,aes128-ctr");
config.setMacsC2S("hmac-sha2-256,hmac-sha1");
config.setMacsS2C("hmac-sha2-256,hmac-sha1");

Why Custom Algorithm Configuration Matters

When connecting to SFTP servers, especially legacy or highly secured environments, you may encounter errors like "Algorithm negotiation fail" due to mismatched supported algorithms between the client and server[5][6]. Configuring your client to use the correct key exchange, cipher, and MAC algorithms ensures compatibility and strengthens your security posture.

“The error typically occurs when there is a mismatch in encryption or key exchange algorithms between the client (JSch) and the server. Understanding the server's algorithm preferences and configuring the JSch client to match is often the key to solving this problem.”[5]

Best Practices

Always set a timeout to avoid hanging connections.
Use non-standard ports where possible for security.
Set only strong, required algorithms to comply with security policies.
Document and version your library for internal use.
Never hardcode credentials; use environment variables or a secret manager.

Conclusion

By building and sharing the SecureSftpClient library internally, your teams can standardize secure file transfers, reduce duplication, and adapt to any SFTP server’s requirements. With support for custom ports, timeouts, and SSH algorithms, your Java SFTP solutions will be robust, secure, and future-proof-without the need for a public Maven repository.

References:

[Java JSch SFTP Connection Issue: Resolving Algorithm][5]
[Setting SFTP Algorithms][6]

Citations:
[1] https://www.north-47.com/sftp-file-transfers-with-java/
[2] https://docs.ifs.com/techdocs/23r2/030_administration/030_integration/300_ifs_connect/010_configure_connect/060_transport_connectors/configure_sftp_transport_connector/
[3] https://stackoverflow.com/questions/75020056/sshj-java-library-set-cipher-suit-for-sftp-connection
[4] https://help.salesforce.com/s/articleView?id=001121369&language=fi&type=1
[5] https://www.tempmail.us.com/en/jsch/java-jsch-sftp-connection-issue-resolving-algorithm-negotiation-fail
[6] https://www.jscape.com/blog/setting-sftp-algorithms
[7] https://docs.spring.io/spring-integration/docs/6.1.5/reference/html/sftp.html
[8] https://stackoverflow.com/questions/15108923/sftp-file-transfer-using-java-jsch

Enabling SOAP Request and Response Logging in JBoss EAP 7

Dhanusha Perera — Tue, 11 Mar 2025 06:58:50 +0000

Logging SOAP request and response messages in JBoss EAP 7 can help with debugging and monitoring. This guide walks through configuring JBoss to log JAX-WS messages without restarting the server.

Step 1: Configure Logging in `standalone.xml`

Modify the standalone.xml file to include a periodic rotating file handler and loggers for JAX-WS:

Add the Periodic Rotating File Handler

Insert the following under <subsystem xmlns="urn:jboss:domain:logging:...">:

<periodic-rotating-file-handler name="JaxWsFileHandler" autoflush="true">
    <formatter>
        <named-formatter name="PATTERN"/>
    </formatter>
    <file relative-to="jboss.server.log.dir" path="myapp_soap_requests.log"/>
    <suffix value=".yyyy-MM-dd"/>
    <append value="true"/>
</periodic-rotating-file-handler>

Add Loggers for JAX-WS

Insert the following inside the <subsystem xmlns="urn:jboss:domain:logging:..."> section:

<logger category="com.sun.xml.ws">
    <level name="FINE"/>
    <handlers>
        <handler name="JaxWsFileHandler"/>
    </handlers>
</logger>
<logger category="com.sun.xml.ws.transport.http">
    <level name="FINEST"/>
    <handlers>
        <handler name="JaxWsFileHandler"/>
    </handlers>
</logger>
<logger category="com.sun.xml.ws.server">
    <level name="FINEST"/>
    <handlers>
        <handler name="JaxWsFileHandler"/>
    </handlers>
</logger>

Step 2: Enable SOAP Message Dumping in `standalone.conf`

Edit standalone.conf to add the required system properties:

JAVA_OPTS="$JAVA_OPTS -Dcom.sun.xml.internal.ws.transport.http.client.HttpTransportPipe.dump=true"
JAVA_OPTS="$JAVA_OPTS -Dcom.sun.xml.internal.ws.transport.http.HttpAdapter.dump=true"
JAVA_OPTS="$JAVA_OPTS -Dcom.sun.xml.internal.ws.transport.http.client.HttpTransportPipe.dumpTreshold=2147483647"
JAVA_OPTS="$JAVA_OPTS -Dcom.sun.xml.internal.ws.transport.http.HttpAdapter.dumpTreshold=2147483647"

Step 3: Apply Changes Without Restarting JBoss (Optional)

If you cannot restart JBoss, use the CLI to apply logging changes dynamically:

Add the Logging Handler

Run the following command in JBoss CLI:

/subsystem=logging/periodic-rotating-file-handler=JaxWsFileHandler:add(autoflush=true, file={"relative-to" => "jboss.server.log.dir", "path" => "myapp_soap_requests.log"}, suffix=".yyyy-MM-dd", append=true, named-formatter="PATTERN")

Add Loggers

/logger=com.sun.xml.ws:add(level=FINE, handlers=["JaxWsFileHandler"])
/logger=com.sun.xml.ws.transport.http:add(level=FINEST, handlers=["JaxWsFileHandler"])
/logger=com.sun.xml.ws.server:add(level=FINEST, handlers=["JaxWsFileHandler"])

Step 4: Verify Logs

Once configured, you should see SOAP request and response logs in myapp_soap_requests.log under the JBoss log directory.

Why This Solution Matters

This logging setup is crucial for debugging and monitoring SOAP web services. It allows developers to inspect incoming and outgoing SOAP messages, making it easier to identify issues, optimize performance, and ensure compliance with API requirements. The ability to apply these changes dynamically without a restart ensures minimal downtime and enhances production debugging capabilities.

What You Can Do with This Solution

Debug SOAP Issues: Capture full request and response payloads for troubleshooting.
Monitor API Activity: Track SOAP messages to ensure correct integration and detect anomalies.
Enhance Security Auditing: Log SOAP traffic for compliance and security reviews.
Minimize Downtime: Make logging adjustments dynamically without restarting JBoss.

Following this guide ensures SOAP messages are logged efficiently without requiring a server restart. Let me know if you encounter issues!

How to install Apache Tomcat 9 on Ubuntu 20.04 LTS

Dhanusha Perera — Thu, 18 Nov 2021 20:21:19 +0000

About This Article

This article is about how to install Apache Tomcat 9 using 'tar.gz' on Ubuntu 20.04 LTS. Hope you will learn something. Cheers!

Prerequisite

You need to have Java 8 installed on your machine.
Tomcat 9 works on only Java 8. More Information.

You can confirm the java version with the following command.

java -version

Let's install Apache Tomcat 9

Visit Apache Tomcat Site.
Download Apache Tomcat 9.
- Download tar.gz (pgp, sha512) the Core Binary Distributions of the Apache Tomcat.
Open up your terminal and cd into the directory where you have downloaded the Apache Tomcat tar.gz file.

Tip: You can open up the terminal by pressing Ctrl + Alt + T on your keyboard.

cd /home/<type-username-here>/Downloads

Extract the tar.gz file to /opt directory with the following command.

sudo tar -xf apache-tomcat-9.0.55.tar.gz -C /opt

Setting up the Catalina environment variable.

Let's cd into the Tomcat directory.

cd /opt/apache-tomcat-9.0.55/

You can see the current directory by running the following command. Copy the path of the current directory. This is the path of the tomcat 9.

pwd

Now open up the terminal and type the following command to get the root access. You will need to provide the password if needed.

sudo su

Open up the ~/.bashrc file using gedit and the Catalina environment variable.

gedit ~/.bashrc

Scroll down to the end of the document and set the Catalina environment variable. /opt/apache-tomcat-9.0.55 is the path of the tomcat which you copied earlier.

export CATALINA_HOME=/opt/apache-tomcat-9.0.55

Save the ~/.bashrc file and close gedit window.

Run Tomcat 9

You can run Tomcat 9 by running the following command.

sh startup.sh

Now you can open up a web browser and navigate to the tomcat URL. If you can see the Tomcat initial page. Then you have successfully installed and the tomcat 9 server is up and running.

http://localhost:8080/

If you want to shut down the Tomcat server, you can do so by running the following command.

sh shutdown.sh

Below you can find a screenshot of my terminal.

Docker Commands Everyone Should Know: [Short Note]

Dhanusha Perera — Wed, 17 Nov 2021 20:03:19 +0000

About This Article

This article is a short note of some of the essential Docker commands that I think are useful for beginners.

Tip: I have created this short note while following the tutorial. I invite you to follow this Docker Tutorial for Beginners [FULL COURSE in 3 Hours] and subscribe to her channel. She is doing a stunning job.

Docker Commands

Pulling a docker container image

# syntax
docker pull <docker-image>

# example
docker pull postgres

Pulling a specific version of a docker container image

# syntax
docker pull <docker-image>:<specify-the-version-here>

# example
docker pull postgres:9.6

Pulls the docker image and runs/starts the docker container | starts new container with a command

# pulls and starts the latest docker image
docker run postgres  

# or you can specify the version
docker run postgres:9.6

To see all the running containers | lists all the running containers

docker ps

Check all the existing images in the machine

docker images

Create a new container of an image

Tip: Please note that run command deals with Docker Images.

# syntax
docker run <docker-image>

# example
docker run redis

Run a container in detached mode

Tip: We can get the hashed ID of the container with this command.
--detach or -d means detached mode (Run container in background and print container ID)

docker run -d redis

Start and stop docker container | a.k.a restart a container (existing container)

Tip: start and stop command deals with existing docker containers.

# For example, you can restart a stopped container.
# syntax
docker start <hashed-ID-of-the-docker-container>

# For example you can stop a running container.
# syntax
docker stop <hashed-ID-of-the-docker-container>

Lists running and stopped containers | a.k.a history of running and stopped containers

docker ps -a

Binding ports between the host and the container

6000
: port specified for the host.

6379
: port of the container.

# since we did not specify a version of redis, it will bind to the latest one available. 
docker run -p6000:6379 redis

# starts with the detached mode.
docker run -p6000:6379 -d redis

Binding ports between the host and a different version of a container

# here I have to specify a different port for the host because port 6000 is already bound to to the container (redis latest version)
docker run -p6001:6379 -d redis:4.0

Debugging containers

To see the logs redis container is producing

# hashed ID of the running container of redis (we can get the hashed ID using `docker ps`)
docker logs <hash ID>`

# or name of the container (we can get the name using `docker ps`)
docker logs <name of the container>

Change the name of the container

Tip: old-redis-container is the name I have given for the container.

docker run -d -p6001:6379 --name old-redis-container redis:4.0

and,

Tip: latest-redis-container is the name I have given for the container.

docker run -d -p6000:6379 --name latest-redis-container redis

To see the container's stuffs

docker exec -it <container hashed ID or container-name> /bin/bash

# or (sometimes `/bin/bash` will not work)
docker exec -it <container hashed ID or container-name> /bin/sh

-it means 'Interacting Terminal'. We can use this terminal to interact with the container and see what is going on with the root access.
We can use some basic commands too, for example: ls, pwd, env
To exist from the container we can type exist command.

Docker Network Commands

List out all the docker networks

docker network ls

Create a Docker Network

docker network create <name-of-the-network>

#example
docker network create mongo-network

Let's connect mongo and mongo-express

Let's deal with MongoDB. Following command will start the mongo container.

docker run -d \                                 ---> We are going to start the container in detached mode.
-p:27017:27017 \                                ---> Binding ports for host and container (specifying ports).
-e MONGO_INITDB_ROOT_USERNAME=mongoadmin \      ---> Environment variable for username.
-e MONGO_INITDB_ROOT_PASSWORD=secret \          ---> Environment variable for password.
--name my_mongodb_container \                   ---> Gives a name to mongo container, ex: `my_mongodb_container`.
--network mongo-network \                       ---> Specifying the docker network. `mongo-network`
mongo

docker logs <hashed ID of the container> ---> We can check the logs to see if the Mongo container works properly.

Let's deal with Mongo-express. Following command will start the mongo-express container.


docker run -d \                                         ---> We are going to start the container in detached mode.
 -p 8081:8081 \                                         ---> Binding ports for host and container (specifying ports).
-e ME_CONFIG_MONGODB_ADMINUSERNAME=mongoadmin \         ---> username
-e ME_CONFIG_MONGODB_ADMINPASSWORD=secret \             ---> password
-e ME_CONFIG_MONGODB_SERVER=my_mongodb_container \      ---> Name of the Mongo container.
--name my_mongo_express_container \                     ---> Gives a name to mongo container, ex: `my_mongo_express_container`.
--network mongo-network \                               ---> Specifying the docker network. ex: `mongo-network`.
mongo-express

docker logs <hashed ID of the container> ---> We can check the logs to see if the Mongo-express container works properly.
We can also open up the web browser, and check mongo-express by opening http://localhost:8081

More with logs

Display the last part of the log.

docker logs <hashID-of-the-container> | tail

We can get the logs, then we can make a "-----------" line, then we can see the new logs clearly below that line.

docker logs -f

Docker Compose

It is exhausting to run commands when you want to run multiple containers.
Docker Compose is a tool for defining and running multi-container Docker applications.

Docker compose file.

# docker-compose.yml file
version: "3"
services:
    my_mongodb_container:
        image: "mongo"
        ports:
            - "27017:27017"
        environment:
            - MONGO_INITDB_ROOT_USERNAME=admin
            - MONGO_INITDB_ROOT_PASSWORD=password

    my_mongo_express_container:
        image: "mongo-express"
        ports: 
            - "8081:8081"
        environment:
            - ME_CONFIG_MONGODB_ADMINUSERNAME=admin
            - ME_CONFIG_MONGODB_ADMINPASSWORD=password
            - ME_CONFIG_MONGODB_SERVER=my_mongodb_container

Here docker compose takes care of creating a common network.
We do not have to worry about specifying and creating a network like we did in the command (like this --network)

How to run the docker compose file.

Assume that docker-compose.yml file is in the project directory.
Let's open up the terminal (from your project directory) and type following command.

  docker-compose -f docker-compose.yml up

How to stop the docker containers using docker-compose file.

To stop the docker containers type following command.
Please note that following command will also remove the docker network which created when we run the docker-compose.yml
```
docker-compose -f docker-compose.yml down
```

Docker file

It is a blueprint for building docker images.
All the commands that are in the dockerfile will apply to the docker container environment.

# save the file as a simple text file. File name should be `Dockerfile`
FROM node

ENV MONGO_DB_USERNAME=admin \
    MONGO_DB_PWD=password

RUN mkdir -p /home/app

COPY ./home/app

CMD ["node", "/home/app/server.js"]

How to build the Docker Image using Dockerfile

To create the Docker Image, type following command.

# syntax
docker build -t <name-of-the-image:tag> <location-of-the-Dockerfile>

# example
docker build -t my-app:1.0 .

Let's run Docker Image that we have created with

docker run my-app:1.0

How to delete a Docker Image

Delete the my-app Docker Container.
Delete the my-app Docker Image.

# let's list the Docker Images in the machine.
docker images

# let's list all the docker containers (history).
docker ps -a

# let's find out what Docker Container do we have to delete in order to delete the `my-app` Docker Image.
docker ps -a | grep my-app:1.0

# let's delete the Docker Container before we delete `my-app` Docker Image
docker rmi <hashedID-of-the-docker-container>

# then, we can remove the Docker Image using the hashID
docker rmi <hashID-of-the-image>

# Now, when we list down all the images, we do not see the Docker Image.
docker images

# [Optional Step] Then, if we want to rebuild the Docker Image
docker build -t my-app:1.0 .

# [Optional Step] After building successful, we can run our docker image
docker run my-app

Getting started with JEST JavaScript Testing Framework

Dhanusha Perera — Sun, 30 May 2021 12:53:06 +0000

About This Article

This article is very beginner-friendly, and we discuss how to use JEST using a simple example.

What is JEST?

Jest is javascript testing framework designed by Facebook. It allows you to test you javascript code with an approachable, familiar and feature-rich API that gives you results quickly.

You can find more details from the JEST official website.

Why JEST?

Let's learn how to work with JEST by using few simple examples. Before we dig into coding and testing, let's understand why do we need JEST.

Answer is very simple. When we develop an application using Javascript, we write several functions/methods. We group several statements/instruction in a function.

Our main intention is to do something and get something done using a function. We should check whether the function is working as intended. JEST is used for testing purposes. We can check our functions are working as intended using testcases. JEST helps to write the testcases and compare the actual output and expected output. This way we can guarantee our functions are working as it supposed to be.
Ultimately, we can find bugs, resolve issues, and we can develop a better application.

Getting started with JEST

Create a folder, cd into the directory and open up the terminal. Create a package.json file. You can use following command to create the package.json file. Then, enter necessary details to create the package.json file. (Feel free to use an IDE or code editor)

    npm init

Let's install jest as development dependency using following command.

npm install --save-dev jest

Add the following section to your package.json

{
  "scripts": {
    "test": "jest"
  }
}

package.json file will look like this:

{
  "name": "jest-demo",
  "version": "1.0.0",
  "scripts": {
    "test": "jest"
  },
  "devDependencies": {
    "jest": "^27.0.3"
  }
}

Now, we ready to do some javascript coding part.

Then, let's create sum.js file and let's write a function to return the sum of two numbers.

sum.js file:

/** This function will take two numbers and return the sum of the two numbers. */
function sum(number1, number2) {
    return (number1 + number2);
}

module.exports = sum;

let's create sum.test.js file to check the function we created.

sum.test.js file:

const sum = require('./sum');

/** let's check this function is performing the way as we intended. */
test('add 10 + 2 to equal 12', () => {
    expect(sum(10, 2)).toBe(12);
});

Let's run this testcase. You should open up the terminal and run following command. If the test case passed JEST will display the result as 'passed'. If test case failed, JEST will display the respective result.

npm run test

Result

JEST will display the test case is passed. That means sum function performs the way we want.

Let's do some changes.

Let's change the sum function to something like this. Then, run the testcase again and see the output.

sum.js file:

/** This function will take two numbers and return the sum of the two numbers. */
function sum(number1, number2) {
    return (number1 - number2); // instead of additon, let's do deduction.
}

module.exports = sum;

Result

JEST will display the test case is failed. Let's understand what happens here.
We did change the sum function to make a deduction and return the output, but we are expecting an addition, right?

Now, sum function is not doing what we are excepting it to do.
Then, we can decide something wrong with the sum function, and we need to fix it.

In this way, we find issues in our code and fix those issues immediately.

Note: When we work with Javascript, we deal with asynchronous programming, there we use callbacks, promises and 'async and await' keywords.
We can use JEST to test asynchronous functions too. You can find JEST documentation in the official documentation.
There you can find more details about how to use JEST for your need.

Difference between var, let and const

Dhanusha Perera — Mon, 12 Apr 2021 18:02:57 +0000

Let’s find out what are the differences between var and let in JavaScript.

We can use var or let to declare a variable in JavaScript. Since there are few differences when using these two, we need to have an idea about the difference between using var and let.

var

'var' is used to declare a variable before ES6. Due to its loose behaviour 'let' statement was introduced in ES6 (ECMAScript 2015).

A variable declared with the var has the global scope or function scoped (optionally, initializing it to a value).
Can be accessed using window object.

example 1 - globally scoped

var x = 10;

if (x === 10) {
    var x = 20;

    console.log(x);
    // expected output: 20
}

console.log(x);
// expected output: 20

example 2 - function scoped

var i = 10;

function printAmount(){
    var i = 50; // function-scoped variable
    console.log(i);
    console.log('window object ---> i: ' +  window.i); // logs 10
}

console.log(i); // logs 10

printAmount(); // logs 50

let

'let' statement was introduced in ES6 (ECMAScript 2015).

The scope of a variable declared using let is limited to the block in which it is declared (declares a block-scoped local variable, optionally initializing it to a value).
Does not get added to the global window object even when it is declared outside any block.

let x = 10;

if (x === 10) {
    let x = 20;

    console.log(window.x); // no global scope, but block-scoped, thus logs 'undefined'
    console.log(x);
    // expected output: 20
}

console.log(x);
// expected output: 10

const

Constants are block-scoped, much like variables declared using the let keyword. The value of a constant can't be changed through reassignment, and it can't be redeclared. Introduced in ES6 (ECMAScript 2015).

example

const number = 10;

try {
  number = 75;
} catch (err) {
  console.log(err);
/*  expected output: TypeError: invalid assignment to const `number'.
    On Google Chrome: TypeError: Assignment to constant variable.
    Note - error messages will vary depending on browser. */
}

console.log(number);
// expected output: 10

Let's explore async, await and promise in JavaScript

Dhanusha Perera — Mon, 22 Mar 2021 09:33:36 +0000

About This Article

in this article, we explore what async and await keywords are,
traits, and how we can use those keywords with few examples. Since we deal with async and await, we can discuss the Promises in JavaScript too.

What Is Async And Await in JavaScript?

async and await keywords are added to the JavaScript language more recently (It was added as a part of the ECMAScript 2017 JavaScript edition).

Both async and await are keywords in JavaScript language. async keyword is used in front of a function (before a function definition).
Then, inside function(within that function) you can use await keyword.

The keyword await is used with a promise and within async function. What it does is, it makes JavaScript wait until the promise settles and return its result.

If this is not clear for you, do not worry. Before we dig into async and await. Let's understand synchronous vs asynchronous execution nature in JavaScript. Let's go step by step.

Synchronous vs Asynchronous Execution

Why do we need async and await, and promises? That is good question.

JavaScript is a single threaded programming language. Did you know that the ECMAScript engine is responsible to run the JavaScript source code?

Yes, the ECMAScript engine is responsible to execute your JavaScript code. Your favorite browser also consists of an ECMAScript engine. Did you know that?

Okay, let’s quickly find out what ECMAScript engines are used in popular web browsers.

Web Browser	ECMAScript engines
Mozilla Firefox	SpiderMonkey
Google Chrome	V8
Opera	Carakan
Safari	JavaScriptCore
Edge	Chakra

Javascript code runs in a single thread, which means the ECMAScript engine is handling things using a single thread.

We write more and more code as programmers, but there is a single thread to run these all instructions. Some instructions that we give are executed in sequence. That means one after another.

Execution order in JavaScript is traditionally top to bottom. This is called 'synchronous execution'.

Notice this example given below. Execution happens one after another.

console.log('Hello Detective!'); // first, this is executed
console.log('I am Lucifer Morningstar!'); // after the first line, this line is executed
console.log('Welcome to Lux.'); // this line executed thirdly.

Programmers face some issues(or challenges) when only working with synchronous code because each statement waits for the previous statement to finish before executing.

Think about a single-threaded language like JavaScript, executes the code just only synchronously, If so; think about a scenario that there is a long-running, or CPU-intensive task, or I/O operation is going on, the program may freeze until that particular task is done. This is where asynchronous programming comes into play and makes it possible to express waiting for long-running actions without freezing the program during these actions.

That means when execution happens JavaScript does not wait for, some tasks or instructions that takes long time to run and blocks the synchronous code. That way it allows running rest of the code.

Asynchronous code does not have to wait, your program can continue to run. JavaScript's environment implements this style of programming using callbacks and functions that are called when the actions complete.

Let's understand what promises are.

Promises in JavaScript

A promise in JavaScript is something like a real-world promise that we make. If someone promised to do something, basically, there can be two outcomes.

if he or she can achieve the task successfully, outcome will be returned. Otherwise, if he or she could not achieve the task successfully, reason (why it failed) will be returned.

In fact, a promise is an object representing the eventual completion or
failure of an asynchronous operation.

Promise is a competitively new feature of JavaScript language, and it is used to handle an asynchronous result of an operation. We can defer the execution of a code block until an async request is completed. Thus, other operations can be run without interruption.

Promise has three states:

Pending: initial state, neither fulfilled nor rejected.
Fulfilled (Resolve): meaning that the operation was completed successfully.
Rejected: meaning that the operation failed.

We can create a promise object like this;

const myPromise = new Promise(function(resolve, reject) {
    // we can code the logic here
    // if success, we can resolve the promise
    // if fail/error, we can reject the promise
});

Notice that we have passed a function with two parameters to the Promise constructor. It takes two parameters, one for success (resolve) and one for fail (reject).

Let’s look at an example.

function checkAge(age) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (typeof age != "number") {
                reject(new Error('Given input for age is invalid. Input should be a number.')); // reject is for fail
            } else if (age >= 18) {
                resolve('allow membership'); // resolve is for success
            } else {
                reject(new Error('disapprove the membership request')); // reject is for fail
            }
        }, 3000);
    });
}

function validateAge() {
    const result = checkAge(25);

    result.then((value) => { 
        // if promise was successful, that means we can use then() block to get the returned value
        console.log(value); // expected output: allow membership
    }).catch((reason => {
        // if promise was failed, that means we can use catch() block to get the returned value(reason - why it failed)
        console.error(reason); // catch() block will not be executed because age = 25
    }));
}

validateAge();

If resolve executed, that means then() block will be executed. Thus, we can access the values of resolve in then() block.

If reject executed, that means catch() block will be executed. Thus, we can access the reason/error inside the catch() block.

Now, we have an idea about Promises too.

Async Keyword

Let’s try this code in your web browsers JavaScript console;

function hello() { return "Hello" };
hello(); //expected output: just return "Hello"

As result, this function returned “Hello”, just nothing special right?

Alright, now, let’s look at the syntax of the async function expression, try to use the async keyword, and run again those code lines;

Syntax (async)

async function name {
statements
}

async function hello() { return "Hello" };
hello(); // expected output: it returns a promise

Now, you should notice that this function returns a promise. Notice that an async function always returns a promise even though we do not return a Promise explicitly. This is one of the traits of an async function, their return values are guaranteed to be converted to promises.

This how you can use async keyword with arrow functions;

let hello = async () => { return "Hello" };
hello(); // returns a promise

To consume the return value, you can use .then() block.

With Regular Function.

hello().then(function (value){
    console.log(value);
});

Using An Arrow Function

hello().then((value) => console.log(value));

// or

hello().then(console.log);

Await Keyword

The await operator is used to wait for a Promise. It can only be used inside an async function.

Syntax (await)

[rv] = await expression;

expression : A Promise or any value to wait for.

rv : Returns the fulfilled value of the promise, or the value itself if it's not a Promise.

await expression causes async function execution to pause until a Promise is settled (that is, fulfilled or rejected).

Let’s look at examples and try to understand. We use this checkAge() method for our examples.

function checkAge(age) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (typeof age != "number") {
                reject(new Error('Given input for age is invalid. Input should be a number.')); //reject is for fail
            } else if (age >= 18) {
                resolve('allow membership'); // resolve is for success
            } else {
                reject(new Error('disapprove the membership request')); //reject is for fail
            }
        }, 3000); // approximately 3000 milliseconds = 3 seconds takes for this process
    });
}

then() and catch() blocks are used in this example. Since age(input) is 25, then() block is executed.

function validateAge() {
    const result = checkAge(25);
    console.log(result); // expected output: Promise { <pending> }

    result.then((value) => {
        console.log(value); // expected output( approximately after 3 seconds): allow membership
    }).catch((reason => {
        console.error(reason); // expected output: since age = 25, catch block will not be executed
    }))
}

validateAge();

Now, let’s change the age(input value) to 12, since the age = 12, catch() block is executed in this example.

function validateAge() {
    const result = checkAge(12);
    console.log(result); // expected output: Promise { <pending> }

    result.then((value) => {
        console.log(value); // since age = 12, then block will not executed
    }).catch((reason => {
        console.error(reason); // expected output: Error: disapprove the membership request
    }))
}

validateAge();

Now, let’s try await keyword with this example. try and catch block used to catch the error (If reject is executed). since age is 25, catch block will not be executed in this example.

async function validateAge() {
    // try and catch block used to catch the error, if reject is executed.
    // since age is 25, catch block will not be executed in this example
    try {
        const result = await checkAge(25);
        console.log(result); // since age is 25, expected output: allow membership
    } catch (error) {
        console.error(error);
    }

}

validateAge();

Let’s try the example with age = 12. since age is 12,
catch block will be executed in this example.

async function validateAge() {
    // try and catch block used to catch the error, if reject is executed.
    // since age is 12, catch block will be executed in this example
    try {
        const result = await checkAge(12);
        console.log(result);
    } catch (error) {
        console.error(error); //expected output: Error: disapprove the membership request
    }

}

validateAge();

If the Promise is resolved, the await expression will return the resolve value.
If the Promise is rejected, the await expression throws the rejected value.

You Should Notice

An async function is a function declared with the async keyword, and the await keyword is permitted within them. The async and await keywords enable asynchronous, promise-based behavior to be written in a cleaner style, avoiding the need to explicitly configure promise chains.
If a Promise is passed to an await expression, it waits for the Promise to be fulfilled and returns the fulfilled value.

Functions and Arrow Functions in JavaScript

Dhanusha Perera — Sun, 14 Mar 2021 06:13:44 +0000

Intro

Multiple ECMAScript (also very popular as JavaScript) editions introduced by ECMA-262 language specification throughout the time but ES5 (ECMAScript 2009) and ES6 (ECMAScript 2015) editions were significant.

Regular functions were there to define a function in ES5 version of JavaScript and Arrow functions were introduced in ES6 version.

Let us understand what are regular functions and arrow functions in JavaScript.

ES5 (ECMAScript 2009)

Traditional function expression

function [name]([param1[, param2[, ..., paramN]]]) { statements }

Traditional function expression is used to define a function. The function keyword can be used to define a function inside an expression.

var addition = function add(a,b) {
    return a + b;
}

console.log(addition(10,20));
// expected output: 30

Or, Function Constructor is used to defining a function. The Function constructor creates a new Function object. Function constructor creates functions that execute in the global scope only.

var deduction = new Function('a','b', 'return a-b;');

console.log(deduction(15,5));
// expected output: 5

ES6 (ECMAScript 2015)

Of course, we can use the traditional way of defining a function but the arrow function is introduced in ES6. A function can be declared without the function keyword by simply using parenthesis. An arrow function expression is a compact alternative to a traditional function expression, but is limited and can't be used in all situations.

Arrow Function Expressions

Basic Syntax

One param. With simple expression return is not needed:
param => expression
Multiple params require parentheses. With simple expression return is not needed:
(param1, paramN) => expression
Multiline statements require body brackets and return:
param => { let a = 1; return a + param; }
Multiple params require parentheses. Multiline statements require body brackets and return:
(param1, paramN) => { let a = 1; return a + param1 + paramN; }

Using Traditional Function Expression

// using function keyword (traditional way)
var printHello = function () {
    console.log('Hello!');
}

printHello();
// expected output: Hello!

Using Arrow function expression

let printHello = ()=>{
    console.log('Hello!');
}

printHello();
// expected output: Hello!

Differences & Limitations:

Does not have its own bindings to this or super, and should not be used as methods.
Does not have arguments, or new.target keywords.
Not suitable for call, apply and bind methods, which generally rely on establishing a scope.
Cannot be used as constructors.
Cannot use yield, within its body.

Arrow Functions and this keyword

With a Regular Function

‘this’ referred to the parent of the function in ES5.

let person = {
    name: 'John Doe',
    myMethod: function () {
        console.log(this);
    }
}

person.myMethod(); //this === person object
// expected output: person object

With an Arrow Function

in ES6, arrow functions use lexical scoping, ‘this’ refers to it’s current surrounding scope and no further. Thus the inner function knew to bind to the inner function only, and not to the object’s method or the object itself.

let person = {
    name: 'John Doe',
    myMethod: () => {
        console.log(this);
    }
}

person.myMethod(); // this === Window object

// expected output: Window object

Let’s go through with this example too.

const myObject = {
    myArrowFunction: null,
    myMethod: function () {
        this.myArrowFunction = () => {
            console.log(this);
        }
    }
}
// let’s initialize the myArrowFunction
myObject.myMethod(); // this === myObject


myObject.myArrowFunction(); // this === myObject
// expected output: myObject object

Traditional function expression is used for the myMethod property. Thus, in that function this refers to myObject object.

When we initialize the myArrowFunction property with the arrow function, this refers to myObject object.

Differences between ES5 and ES6

Dhanusha Perera — Sun, 07 Mar 2021 19:59:00 +0000

Intro

JavaScript remains the most popular programming language in the world due to various reasons, and it is a general-purpose programming language that is standardized by ECMA-262 - ECMA International language specification. ECMAScript is the official name for JavaScript but JavaScript is the most recognized name around the world.

There are multiple editions introduced by ECMA-262 language specification throughout the time but ES5 (ECMAScript 2009) and ES6 (ECMAScript 2015) editions were significant.

Let’s explore ES5, ES6 differences together.

Differences

ES5	ES6
5th edition of the ECMA-262 language specification.	6th edition of the ECMA-262 language specification.
Introduced in the year 2009.	Introduced in the year 2015.
There can be seen five primitive data types. string, number, boolean, null, undefined	Introduced a new primitive data type along with the data types that were there in ES5. string, number, boolean, null, undefined and symbol (Every symbol value returned from Symbol() is unique.)
‘var’ keyword is the only keyword that was there to define the variables.	Introduced let and const keywords other than the ‘var’ keyword to define variables.
When comparing to ES6 performance is slightly low.	When comparing to ES5 performance is better.
Since var is used to define variables; there were slight disadvantages, type safety issues. There is a loose nature when comparing to ES6. Variable declared by var, have their scope globally.	Variable declared by let, have their scope in the block which they are declared, as well as in any contained sub-blocks.
Developers could not easily declare a constant variable which can not be redeclared when compared to ES6.	Constants(const) are block-scoped, much like variables declared using the let keyword. The value of a constant can't be changed through reassignment, and it can't be redeclared. Constants can be declared easily when compared to ES5.
function and return keywords are used to define a function.	ES6 introduces us to many great features like arrow functions, template strings, class destruction, Modules
Provide larger range of community support for ES5 when compared with ES6	It provides a less range of community supports than that of ES5.

Forem: Dhanusha Perera

From Legacy FTP to Secure SFTP: Building a Reusable Java Library with Factory Pattern

Why Use an Internal, Configurable SFTP Library?

Library Name

Project Structure

Step 1: Enhanced SftpConfig.java

Step 2: Enhanced SftpClient.java

Step 3: SftpClientFactory.java

Step 4: pom.xml

Sharing the Library Internally

Option 1: Share the JAR Directly

Option 2: Install to Local Maven Repository

Usage Examples

1. Basic Usage with Default Port and Timeout

2. Custom Port and Timeout

3. Custom SSH Algorithms (KEX, Ciphers, MACs)

Why Custom Algorithm Configuration Matters

Best Practices

Conclusion

Enabling SOAP Request and Response Logging in JBoss EAP 7

Step 1: Configure Logging in standalone.xml

Add the Periodic Rotating File Handler

Add Loggers for JAX-WS

Step 2: Enable SOAP Message Dumping in standalone.conf

Step 3: Apply Changes Without Restarting JBoss (Optional)

Add the Logging Handler

Add Loggers

Step 4: Verify Logs

Why This Solution Matters

What You Can Do with This Solution

How to install Apache Tomcat 9 on Ubuntu 20.04 LTS

About This Article

Prerequisite

Let's install Apache Tomcat 9

Setting up the Catalina environment variable.

Run Tomcat 9

Docker Commands Everyone Should Know: [Short Note]

About This Article

Docker Commands

Pulling a docker container image

Pulling a specific version of a docker container image

Pulls the docker image and runs/starts the docker container | starts new container with a command

To see all the running containers | lists all the running containers

Check all the existing images in the machine

Create a new container of an image

Run a container in detached mode

Start and stop docker container | a.k.a restart a container (existing container)

Lists running and stopped containers | a.k.a history of running and stopped containers

Binding ports between the host and the container

Binding ports between the host and a different version of a container

Debugging containers

To see the logs redis container is producing

Change the name of the container

To see the container's stuffs

Docker Network Commands

List out all the docker networks

Create a Docker Network

Let's connect mongo and mongo-express

More with logs

Display the last part of the log.

We can get the logs, then we can make a "-----------" line, then we can see the new logs clearly below that line.

Docker Compose

Docker compose file.

How to run the docker compose file.

How to stop the docker containers using docker-compose file.

Docker file

How to build the Docker Image using Dockerfile

Let's run Docker Image that we have created with

How to delete a Docker Image

Getting started with JEST JavaScript Testing Framework

About This Article

What is JEST?

Why JEST?

Getting started with JEST

Result

Let's do some changes.

Result

Difference between var, let and const

var

example 1 - globally scoped

Step 1: Configure Logging in `standalone.xml`

Step 2: Enable SOAP Message Dumping in `standalone.conf`