Forem: Dhanushka madushan

How to start Jenkins Docker container with a given version

Dhanushka madushan — Fri, 21 Apr 2023 07:32:45 +0000

Jenkins is a widely used automation server that helps to streamline software development processes. Docker, on the other hand, is a popular tool for creating and managing containers. Running Jenkins in a Docker container can offer several benefits, such as easy deployment and portability. However, it's important to make sure you're using the right version of Jenkins to ensure compatibility with your existing tools and processes. In this guide, we'll explore how to start a Jenkins Docker container with a specific version, ensuring you have the right tools for the job.

Use the following docker registry to pull docker image to start a Jenkins Docker image:
https://hub.docker.com/r/bitnami/jenkins

Following is the docker pull command to pull 2.346.3 version:

docker pull bitnami/jenkins:2.346.3

Once pull is completed we can start the Jenkins Docker container with the following command:

docker volume create --name jenkins_data
docker run -d -p 8080:8080 --name jenkins \
  --network jenkins-network \
  --volume jenkins_data:/bitnami/jenkins \
  bitnami/jenkins:2.346.3

Here I set the port mapping from 8080 to 8080. If you need to map to another port(ex 9000), use -p 9000:8080 option.

It take some time and you can see jenkins logs with docker logs <container_ID> command.

Then, open a browser and go to http://localhost:8080 and you will see Jenkins login page. User the following credentials to log into it:
Username: user
Password: bitnami

CAP theorem and what does it means

Dhanushka madushan — Mon, 20 Feb 2023 16:13:31 +0000

The CAP theorem addresses the trade-off between consistency, availability, and partition tolerance in a distributed system. In this video, let's go through each of these properties and altogether what these properties mean in a distributed system.

Decompile all the jar files in given directory

Dhanushka madushan — Thu, 12 Jan 2023 04:57:52 +0000

Procyon is a Java decompiler for reverse engineering compiled Java code. It can be used to decompile Java 5 and Java 7 bytecode and is open-source. Procyon's ability to decompile complex Java code and generate comprehensible output is one of its benefits. Decompiling JAR files is one of Procyon's common uses. The file format known as a JAR file, or Java Archive, is used to store multiple files, including Java classes and resources, in a single archive. Typically, these files are turned into Java bytecode, which can then be run on any Java Virtual Machine (JVM).

You must first download the Procyon decompiler file from the official website and put it in a directory on your system before you can use Procyon to decompile a JAR file. After that, you can run the JAR file from the command line while specifying the JAR file you want to decompile as an argument. For instance, the "example.jar" JAR file can be decompiled using the following command:

java -jar procyon-decompiler.jar example.jar

By doing this, all of the class files in the JAR file will be extracted, and the decompiled source code will be written to separate files with the same name as the class file but a.java extension. The JAR file and the decompiled code will both be kept in the same directory.

You can use Procyon decompiler and have a recursive look into folders with the following command.

find <jar_files_directory> -name "*.jar" -exec java -jar <procyon_decompiler_location> -jar {} -o <output_directory> \;

Example

find . -name "*.jar" -exec java -jar /Users/abc/Desktop/procyon-decompiler-0.6.0.jar -jar {} -o output/ \;

It's important to keep in mind that Java code decompiling is not always correct, and the resulting source code might not exactly match the original. Decompiling Java code may also be permitted in some circumstances, but it frequently violates copyright regulations, so it should be used with caution.

Procyon is a powerful resource for debugging Java code and has a wide range of applications. Procyon is a dependable decompiler that can assist you in achieving your objectives, whether you're looking to comprehend how a third-party library operates or recover lost source code.

7 Facts on securing your WSO2 Micro integrator

Dhanushka madushan — Thu, 29 Sep 2022 13:33:08 +0000

WSO2 Micro Integrator is an integration solution that is widely used in enterprise integration. You can use MI(For short let's use Micro Integrator as MI) to implement mediation policies, message transformation, security, and many more. In this article, we are going to focus on how you can securely place MI on your deployment.

First thing first:

WSO2 MI comes with a default Keystore that is used in many cryptography-related features including SSL, mutual SSL, password encryption, and so on. Since this is a public one, you should make sure that you have generated a new Keystore and truststore for the MI.

If you are looking for steps on how you do it, then refer to the following document:

https://apim.docs.wso2.com/en/latest/install-and-setup/setup/mi-setup/security/configuring_keystores

Avoid having the default H2 database and use a proper one

By default WSO2 MI ships with H2 embedded database to store data for the following purposes:

Cluster coordination
RDBMS user store
Transaction counter

It is not good practice to use the H2 database in the deployment environment as it is stored in the deployment environment where people who have access to the deployment able to acess this file. WSO2 MI provides the following list of databases that you can easily configure with MI:

MySQL
MSSQL
Oracle
Postgre
IBM DB

These databases are enterprise databases that provide much more security than the simple H2 database. Therefore, make sure to configure any of the databases given here rather than using the default H2 database to have a good security level.

Use the secure vault to store sensitive data

WSO2 MI use synapse-based XML document to specify and store mediation policies. In some cases, you might need to access secure services/endpoints with particular inputs such as passwords. Storing these inside the mediation flow might not good solution in case of attacker get access to the MI instance as these mediation sequences are stored in a file.

MI provides a secure vault to store this sensitive information in an encrypted manner. Instead of keeping data as plain text, you can save data encrypted where MI is able to decrypt it whenever it is needed.

You can configure the text you need to encrypt under the [secrets] section on the /conf/deployment.toml folder(Define this at the bottom of the file). Check the following example values that you are defined in the deployment.toml file:

[secrets]
hello=”[abcd]”

You can notice that value is given as a plain text value and surrounded with square brackets. We will use the Keystore file to encrypt this content and replace this value. For that, you can use ./ciphertool.sh -Dconfigure command. It will ask you the Keystore password where by default it would be wso2carbon(Make sure to create a new one when you are using this in a production environment). If you check the deployment.toml file again, you may notice that the value with the square bracket gets changed into an encrypted value. This is the encrypted value and you can use the key whenever you need to use this particular secret.

If you are using MI in a microservices environment, you have to generate these encrypted entities first and then copy them inside the image.

Now you can use this key inside the MI sequences. Check the following example property mediator that retrieves an encrypted entity and logs it:

<property expression="wso2:vault-lookup('hello')" name="helloProperty" scope="default" type="STRING"/>
<log level="custom">
 <property expression="$ctx:helloProperty" name="secure valut log"/>
</log>

The wso2:vault-lookup() function lets you retrieve decrypted values you have specified in the deployment.toml in an encrypted format. Now, you can use this property anywhere in the mediation flow. As early mentioned this is an elegant way of storing passwords that you need to access third-party services.

https://apim.docs.wso2.com/en/latest/install-and-setup/setup/mi-setup/security/encrypting_plain_text/

Using Hashicorp secure vault

If you have dynamic content that you need to change, then you can consider using Hashicorp secure vault with the MI. Hashicorp Vault is a secure vault provided by Hashicorp, especially for microservices environments. In the Hashicorop vault, you can define the secrets you need and Vault API lets services access these secrets.

You can configure MI to access the Hashicorp vault by Secure Vault driver into the <MI_HOME>/lib directory and by adding the following TOML configuration into the <MI_HOME>/conf/deployment.toml file:

[[external_vault]] 
name = "hashicorp" 
address = "http://127.0.0.1:8200" 
# If Static Token authentication is used, apply the rootToken: rootToken = "ROOT_TOKEN" 
# If AppRole Pull authentication is used, apply the roleId and secretId: 
roleId = "ROLE_ID" 
secretId = "SECRET_ID" 
cachableDuration = 15000 
engineVersion = 2 
namespace = "NAMESPACE" 
trustStoreFile = "${carbon.home}/repository/resources/security/client-truststore.jks" keyStoreFile = "${carbon.home}/repository/resources/security/wso2carbon.jks" keyStorePassword = "KEY_STORE_PASSWORD"

Now you can access secret values with hashicorp:vault-lookup(‘path-name’, ‘field-name’) expression which is the same as the MI secure vault.

For more instruction on how to do it, refer to the following documentation:

https://apim.docs.wso2.com/en/latest/install-and-setup/setup/mi-setup/security/using-hashicorp-secrets

Other than the local secure vault and Hashicorp secure vault, you can use Docker secrets and Kubernetes secrets as well. The implementation of those two methods is pretty much similar. Check the following documentation to learn more about these two methods:

https://apim.docs.wso2.com/en/latest/integrate/develop/creating-artifacts/using_docker_secrets/

https://apim.docs.wso2.com/en/latest/integrate/develop/creating-artifacts/using_k8s_secrets/

Hide observable data with log masking

Logging is an important requirement when you are building a server-side application. Logging is the most basic observability principle that you can implement to track errors and find the root cause. While it makes simplify your process, it may cause a security impact if you log sensitive information. If you need to log sensitive information such as credit card numbers and passwords, you need to care about how you are going to keep it secure.

MI may place where transactions with sensitive data are present. If you logging enabled and sensitive data may be logged with message payload or header. WSO2 MI let you mask this sensitive information while it logging in to the given destination. WSO2 MI uses log4j as the logging library and you can specify what are the logs that need to print and where they should print.

You can enable log masking for WSO2 MI by adding an additional ‘m’ to the CARBON_CONSOLE layout appender in the <MI_HOME>/conf/log4j2.properties file. Following is what looks like when you enable log masking for log4.

appender.CARBON_CONSOLE.layout.pattern = [%d] %5p {%c{1}} - %mm%ex%n

Now, you can define masking patterns in RegEx format in the deployment.toml file. This will search RegEx patterns on the log line and replace those with ***** values.

[masking_pattern.properties] 
"CREDIT_CARD_VISA" = "4[0-9]{6,}$"

https://apim.docs.wso2.com/en/latest/administer/logging-and-monitoring/logging/masking-sensitive-information-in-logs

Secure your proxy services in MI

One of the main purposes of MI is to expose its mediation endpoints to the client endpoint. When you need to expose MI services outside, you need to have a proper security mechanism to authorize your services. Web Service Security(WS Security) helps you to achieve this by applying different authentication and authorization policies to the MI endpoints.

With MI, you can authenticate and authorized client before access its endpoint. MI provide multiple different ways including Username Token, Non-repudiation, Integrity, Confidentiality and so on. For an example, you can configure your proxy services with Username Token, where you can authenticate request with username and password against MI user store. In MI, you can create user and roles with MI CLI tool. Then you can map those roles with WS security policies created by using a registry resource project.

Do you wan’t more details on how to configure WS security for MI, then follow the instruction in here.

https://apim.docs.wso2.com/en/latest/integrate/develop/advanced-development/applying-security-to-a-proxy-service/

Secure your REST APIs in MI

Now you know how to secure proxy service with WSO2 MI. How about APIs? Now web services are fading away and APIs take the lead of web space. WSO2 MI gives you to define your API and do some mediations same as the proxy services do.

APIs WSO2 MI does not directly provide you a way to secure REST API and you need to use WSO2 API Manager(APIM) Gateway to expose your services. If you already have a proxy service that you need to expose, then you can easily configure WSO2 APIM to access MI APIs. Here MI automatically publish artefacts to the APIM service catalog such that you can manage MI APIs with the APIM.

https://apim.docs.wso2.com/en/latest/tutorials/integration-tutorials/service-catalog-tutorial/

On the other hand, you can do API first integration by starting creating API specs. First you need to create mock API with APIM that include how the API looks like. Then you can import API specs into the Integration Studio and implement the mediation logics in there. Following is the detailed steps to how to do it.

https://apim.docs.wso2.com/en/latest/tutorials/develop-an-integration-with-a-managed-api/

Now you know how to expose WSO2 MI API through the WSO2 APIM. WSO2 APIM let you to apply various different policies of exposing APIs that include securing APIs as well. You can enable transport level security with SSL verification and authentication with OAuth2 protocol.

Other than those security features, you can use other features such as API lifecycle management, throttling, monotization as well.

If you don’t need to use APIM to secure your MI APIs, you can use MI handlers and some JAVA code to secure MI APIs. MI API handlers is a JAVA hook that get trigger before the request hit the API mediation flow and before send the response.

It provide two methods handleRequest() and handleResponse() to handle request and the response. Both of these methods return a boolean value that say whether the request or response should be proceed as usual or restricted. Now you know the trick. You can implement authorization on the handleRequest() method and limit the access to the API. The API that need to have this authorization mechanism can be specified in the MI Synapse API definition. You can get more details on how to configure it with the following documentation.

https://apim.docs.wso2.com/en/latest/integrate/develop/advanced-development/applying-security-to-an-api/

Get a WSO2 MI subscription and always up to date

Finally, non of the software is one hundred present secure where vulnerabilities get discovered when the time goes on. Therefore, the software product that you are using, should always get updated to withstand cyber attacks. MI security scans are performed frequently and check if there are any vulnerabilities. If there are any vulnerabilities, WSO2 sends security updates to subscription customers. For more security, get a subscription and keep on updating the deployment.

In this article we have focus on the basic security practices that you should follow to secure your Micro Integrator from vulnerabilities. Keep it mind that there are lot more of best practices that you need to follow inorder to secure you whole deployment. Always keep on mind to secure links with SSL or mutual SSL, update vulnerable dependencies, handle attacks such as DDoS and XSS to make sure your deployment is secure.

Simple tool to read messages on RabbitMQ

Dhanushka madushan — Thu, 05 May 2022 06:07:19 +0000

I found the following repository that let you to read RabbitMQ messages easily.
https://github.com/dubek/rabbitmq-dump-queue
This is Go lang based tool and you can use it with the following command:

go get github.com/dubek/rabbitmq-dump-queue

This will compile the code into the $GOPATH/bin and you can use the tool from there.
Following is a sample command that you can dump upto 500 messages from the rabbitmq along with its header data:

./rabbitmq-dump-queue  -uri="amqp://guest:guest@localhost:5672/" -queue=queue1 -max-messages=500 -output-dir=/output/locaiton -full

Undestanding Java OSGI framework

Dhanushka madushan — Wed, 22 Sep 2021 03:46:25 +0000

OSGI is a framework used in building complex Java applications that contain multiple components. With OSGI, you can build Java application that can load dynamically. When you are building a basic Java application, you might create a jar file for each module and load it with the class path. But, with the OSGI framework, you can load OSGI jar file dynamically whenever you needed.
Lets discuss some of the terminologies and concepts that you should know about OSGI framework:

Bundle

Bundle is the OSGI module that contain all your logics. Bundle is a jar file that contain your business logic that provide some service. Other than a regular jar file, it also contain information about how it supposed to work in OSGI runtime in MANIFEST.MF file. These information include a bundle name, version, exported and imported libraries.
Following is a sample definition of OSGI bundle definition:

 Bundle-Name: Hello World
 Bundle-SymbolicName: org.dhanushka.helloworld
 Bundle-Description: A Hello World bundle
 Bundle-ManifestVersion: 2
 Bundle-Version: 1.0.0
 Bundle-Activator: org.dhanushka.Activator
 Export-Package: org.dhanushka.helloworld;version="1.0.0"
 Import-Package: org.osgi.framework;version="1.3.0"

Bundle-name is used to identify the bundle. This is just a optional string value.
Bundle-SymbolicName is a unique identifier for the bundle. This follows the common java package naming standard.
Bundle-Description is a description about what this bundle does.
Bundle-ManifestVersion is versioning used by OSGI framework to read bundle manifest.
Bundle-Version is the version number you allocated for the OSGI bundle.
Bundle-Activator is the starting point of your module. You bundle can have multiple class implementations. OSGI use this property to mark what is the class that used as starting point of the bundle. We will discuss about bundle activator more later.
Export-Package is a set of packages that you need to expose to other OSGI bundles. If you didn't specify export packages, then other OSGI bundles unable to access classes in your OSGI bundle.
Import-Package is a set of packages that required to your OSGI bundle. You should import packages in here if you need to refer any other OSGI bundles.

Bundle is simply a module that contain all of your programming logics. You can import another bundle functionality into it and expose your own functionality to other bundles.

Services

Services are the way how each of the bundles are connected together. As I have already explained, multiple bundles can be connected together to provide some service.
Check the following sample bundle implementation that has activation method on it:

public class Activator implements BundleActivator {
    private BundleContext context;

    @Override
    public void start(BundleContext context) throws Exception {
        System.out.println("Starting");
        this.context = context;
    }

    @Override
    public void stop(BundleContext context) throws Exception {
        System.out.println("Stopping");
        this.context = null;
    }
}

In this source code, the bundle activator is the Activator class. When the OSGI starting up it start executing the start method. This is much similar to the main method. When the OSGI framework stopping, it trigger the stop method. Whenever you add this bundle into the OSGI runtime, it will start execution by calling the start method and end its execution by calling the stop method.
As you can see, this bundle does not have any dependency with other OSGI bundles. It can start its execution independently. In some scenarios, you might need to start this bundle when some conditions are met. Until condition satisfy, OSGI runtime does not call the start method.
This can be achieved with references. References let you to call start method once given conditions are met. Check the following modification done to the Activator class:

public class Activator implements BundleActivator {
    private BundleContext context;

    @Override
    public void start(BundleContext context) throws Exception {
        System.out.println("Starting");
        this.context = context;
    }
        @Reference(
            name = "activator.service",
            service = ActivatorService.class,
            cardinality = ReferenceCardinality.MANDATORY,
            policy = ReferencePolicy.DYNAMIC,
            unbind = "unsetActivatorService")
    protected void setActivatorService(ActivatorService activatorService) {
            // Set values
     }

    protected void unsetActivatorService(ActivatorService activatorService) {
            // Unset values
    }

    @Override
    public void stop(BundleContext context) throws Exception {
        System.out.println("Stopping");
        this.context = null;
    }
}

In this code, other than previous start and stop method, there are another two methods. @Reference annotation used here to mark these dependencies. Here, we have given a service name and service class. Under the reference annotation, we defined the cardinality as mandatory. Since the cardinality marked as mandatory, to trigger start function, setActivatorService should be satisfied. If the cardinality is optional, then it is not mandatory to call setActivatorService to start this bundle. This method can be triggered from another bundle. Following is a sample code, how to trigger setActivatorService method.

context.getBundleContext().registerService(ActivatorService.class.getName(), activatorService, null);

Here, the activatorService is the object that contain details that need to send to the setActivatorService. Once this method get called, OSGI bundle will start the ActivatorService start method.

You can build more advanced applications by using the OSGI framework. You build dynamically pluggable components with dependency injection design pattern.

Change Elasticsearch watermark size

Dhanushka madushan — Tue, 27 Jul 2021 04:01:04 +0000

Storage overflow watermark error message is a common message that throws when disk space is not enough on your elasticsearch cluster. You can reduce the allocated disk watermark size by sending a HTTP request to the elasticsearch. Following is the curl command that you can use to change the watermark size on elasticsearch instance running on the localhost:

curl -X PUT "localhost:9200/_cluster/settings?pretty" -H 'Content-Type: application/json' -d'
{
  "transient": {
    "cluster.routing.allocation.disk.watermark.low": "10gb",
    "cluster.routing.allocation.disk.watermark.high": "5gb",
    "cluster.routing.allocation.disk.watermark.flood_stage": "5gb",
    "cluster.info.update.interval": "1m"
  }
}'

Important keytool commands to work with keystores and truststores

Dhanushka madushan — Thu, 29 Apr 2021 08:37:00 +0000

Generate Keystore

keytool -genkey -alias alice -keyalg RSA -keysize 2048 -keystore interop2.jks -dname "CN=Alice, OU=Wso2, O=Wso2, L=Wso2, ST=Wso2, C=LK" -storepass password -keypass password

View Keystore details

keytool -v -list -keystore interop2.jks

Export certificate from Keystore

keytool -export -alias alice -keystore interop2.jks -file interop2alice.pem

Import certificates to Truststore

keytool -import -alias alice -file interop2alice.pem -keystore sts.jks -storepass password

Creating a simple HTTP server with NPM

Dhanushka madushan — Thu, 28 Jan 2021 16:46:53 +0000

What is Git and how it works

Dhanushka madushan — Mon, 15 Jun 2020 18:26:07 +0000

As programmers we use Git to save last successful state of a code. Git has simple way of keeping and versioning history in Git repository. Git keep data as combination of following objects.

Blob : This object used to store content of single file
Tree : Reference to another blog or sub-tree
Commit : Commit data (Auther, Commiter ect) and reference to tree object
Tag : Reference to Commit object.

Here, what is git and how it works.

First glimpse of Ballerina language: The Language of Integration

Dhanushka madushan — Tue, 03 Sep 2019 05:04:41 +0000

Ballerina is the latest programming language released on the alpha version on August 3rd of this year. There are more than a thousand programming languages out there. Why do you need another programming language? Ballerina language intended to simplify the particular programming domain known as integration. You may be a developer who develops different kinds of web services and intends to interconnect those services. Then the Ballerina language will be your next programming companion.

This post is intended to give you an introduction to Ballerina, a flexible, powerful and beautiful programming language that helps you implement any sort of integration requirements. You can download and install Ballerina from the official Ballerinalang website.

What does it look like?

When I said that this is a programming language, the first concern that comes to your mind is how it looks. Ballerina language syntax takes shape based on programming languages such as Java, Go and JavaScript. Ballerina is a static typed language. For example, if you need to define an integer, the syntax would be the following.

int total = 99;

Same as the other languages, Ballerina has the main method, which is the primary program entry point. You can write a simple "hello world" as shown below.

import ballerina/io;

public function main() {
    io:println("Hello, World!");
}

Apart from regular primitive data types, Ballerina provides various non-primitive data types, such as Arrays, Tuples, Maps, Tables, Union, etc. Ballerina represent nil as bracket "()"

Since Ballerina specifically designed to construct apps operating on networks, it natively supports JSON and XML. You can easily define a JSON variables as the following in JavaScript.

json user = {
         fname: "Peter",
         lname: "Stallone",
         "age": age,
         address: {
             line: "20 Palm Grove",
             city: "Colombo 03",
             country: "Sri Lanka"
         }
    };
io:println(user.address.country);

Same way you can define XML object as well.

xml x1 = xml `<book>The Lost World</book>`;
io:println(x1);

Ballerina offers built-in libraries for the implementation of different kinds of functionalities. In Ballerina, this is called modules. Modules are working the same as Java packages. You can import built-in modules or your own modules into your application. Ballerina has built-in logging, math, encoding, string, caching, time, file processing, and many more modules.

Flow control of the syntax is the same as other languages. It provides support for the syntax "if else," "while" and "foreach." Foreach syntax provides iteration support over arrays and maps. If you are looking for an appealing way to verify the null, then Ballerina will give the to Elvis operator to verify whether the specified variable is null or not. Syntax would be as 'expression?: expressionIfNil' and, below, an example to verify whether variable x is null or not.

string elvisOutput = x ?: "value is nil";

Object Oriented Programming with Ballerina

Ballerina does provide assistance for object-oriented programming. The Ballerina OOP syntax seems closer to the Python OOP syntax. Here is an example for defining objects with a constructors.

type Person object {
    public int age;
    public string firstName;
    public string lastName;

    function __init(int age, string firstName, string lastName) {
        self.age = age;
        self.firstName = firstName;
        self.lastName = lastName;
    }

    function getFullName() returns string {
        return self.firstName + " " + self.lastName;
    }

    function checkAndModifyAge(int condition, int a);
};

function Person.checkAndModifyAge(int condition, int a) {

    if (self.age < condition) {
        self.age = a;
    }
}

Instantiating object is simple and straight forward as "Person p1 = new(5, "John", "Doe");". Object can be access with dot(".") operator which is same as other languages.

p1.getFullName()

Ballerina is providing assistance for Encapsulation. Here you can define variables within an object with the appropriate access level. Ballerina supports the following access modifiers.

public — visible everywhere
private — visible only within the same object
no modifier — visible only within same package.

You can also use abstraction concepts with Ballerina. Abstraction is a powerful OOP concept that is essential in the design of big modular software. You can define and reuse abstract objects in ballerina. You can convert an object to an abstract object by using an abstract keyword. Example abstract Person object would be as follows.

type Person abstract object {
    public int age;
    public string firstName;
    public string lastName;

    function getFullName() returns string;

    function checkAndModifyAge(int condition, int a);
};

You can reuse the Person object as follows to reuse the variables and methods in the Person objects

type Employee abstract object {

    *Person;    
    public float salary;

    function __init(int age, string firstName, string lastName) {
        self.age = age;
        self.firstName = firstName;
        self.lastName = lastName;
    }
    function getSalary() returns float;

};

There is one more remaining concept of OOP known as Polymorphism to finish OOP concepts in the Ballerina languages. Polymorphism can also be implemented in the Ballerina language as follows in previous code segments. Here, a person object can have many types, as it is an abstract class.

Person p = new Employee(5, "John", "Doe");

Integration with Ballerina language

As I mentioned earlier on the introduction, Ballerina was specially designed to solve integration problems. We live in a globe where thousands of web servers are running and interacting with each other. Early developers had problems of connecting these services with each other. Enterprise Integration Bus emerges as a solution to the problems of integration. The ESB model offers an elegant way to interconnect distinct kinds of services with each other. The common issue with these ESB products is that it is difficult to configure and less flexible.

Compared to ESB, Ballerina is more user-friendly so that developers can design the system by coding. Ballerina offers built-in libraries to solve all kinds of integration problems.

The general requirement of integration is to read, forward and transform messages between distinct protocols. Ballerina provides built-in assistance for HTTP, HTTPS, HTTP2, Websockets, GRPC, TCP, UDP, etc transports.

Ballerina can function as both a client and a server. Sending a request to another endpoint is simple, as it requires only three lines of code. You can easily call the REST API backend by setting the request headers as needed. Since Ballerina supports JSON natively, you can directly manipulate JSON content within the software without importing modules from third parties.

import ballerina/http;
http:Client clientEndpoint = new("https://postman-echo.com");
public function main() {
    var response = clientEndpoint->get("/get?test=123");
}

On the other hand, you can create an HTTP server with a ballerina language. You can use built-in security features to secure your HTTPS link.

import ballerina/http;
import ballerina/log;
http:ServiceEndpointConfiguration helloWorldEPConfig = {
    secureSocket: {
        keyStore: {
            path: "${ballerina.home}/bre/security/ballerinaKeystore.p12",
            password: "ballerina"
        }
    }
};

listener http:Listener helloWorldEP = new(9095, config = helloWorldEPConfig);

@http:ServiceConfig {
    basePath: "/hello"
}
service helloWorld on helloWorldEP {
    @http:ResourceConfig {
        methods: ["GET"],
        path: "/"
    }
    resource function sayHello(http:Caller caller, http:Request req) {
        var result = caller->respond("Hello World!");
        if (result is error) {
            log:printError("Error in responding ", err = result);
        }
    }
}

Ballerina also provides support for streaming through the HTTP interface. Building GRPC and web socket based servers is straight forward and easy as building HTTP servers.

Message brokers are one of the most important aspects of integration when it comes to reliable messaging. If you need to send messages reliably, you can use the Message Broker along with the Ballerina Integrator. Ballerina provides assistance for famous Message Brokers such as ActiveMQ, RabbitMQ and NATS. You can generate messages and receive messages with only a few lines of Ballerina codes that make it the best language to use with all integration requirements.

Conclusion

In this article, I attempted to explain the capabilities of Ballerina as a generic programming language as well as a specialized programming language for integration. There are a lot more features like threading, streaming, security, and native support for microservices that I haven't addressed here. I'm going to clarify these features to you in detail in another article.

You can learn more about Ballerina language from their official site. There you can find example implementation for each use cases. You can follow me in twitter to know more about tech stuff. Go to the Ballerina download page and try it now. As its name suggests, it is flexible, powerful and beautiful.

A Weird Java Code and How It Works

Dhanushka madushan — Mon, 22 Jul 2019 15:28:49 +0000

I discovered following strange Java code that print Just another Java hacker on your terminal.

Obviously, that piece of code looks like mess. Even if you copy this code into your favorite IDE, IDE could not figure out the syntax of this code. Trust me, this piece of code works, and this is how it works.

Obviously it has class name with main method. Let's clear out the code and format it. Now it look like this.

class Sig{
    public static void main(String...args){
        \u0066or(int\u0020$:"vÌÈÊ\"¤¾ÀÊ²¬Æ\"v¤Î¤\"²¤¨¸¬Æ".to\u0043h\u0061rArray()
        )System./*goto/*$/%\u0126//^\u002A\u002Fout.print((char)(($>>
        +(~'"'&'#'))+('<'>>('\\'/'.')/\u002Array.const(~1)\*\u002F)));
    }
}

Now you can see that there are some unicode characters in this code. Next we'll extract all unicode characters. Also I'm removing /*goto/*$/%\u0126//^\u002A\u002F and \u002Array.const(~1)\*\u002F section since those code sections are just commented line written in unicode characters.

class Sig{
    public static void main(String...args){
        for(int $:"vÌÈÊ\"¤¾ÀÊ²¬Æ\"v¤Î¤\"²¤¨¸¬Æ".toCharArray())
            System.out.print((char)(($>>+(~'"'&'#'))+('<'>>('\\'/'.'))));
    }
}

If you replace (char)(($>>+(~'"'&'#'))+('<'>>('\\'/'.'))) expression with relevant ascii values then it would be something like (char)(($>>+(~42&35))+(60>>(92/46))). This is equivalent to (char)(c / 2 + 15). Final output of the simplified code would be something like below.

class Sig{
    public static void main(String...args){
        for(int $:"vÌÈÊ\"¤¾ÀÊ²¬Æ\"v¤Î¤\"²¤¨¸¬Æ".toCharArray())
            System.out.print((char)($ / 2 + 15));
    }
}

Now the mystery has been resolved. For loop take each of the characters from the string change it value according to the equation and print it.

Why don't you give it a try to write such a code with your favaourite language and comment it down?

Warning: Don't ever write this type of code in production repositories.