A code example

terraform
/ˈtɛrəfɔːm/
verb: 
terraform something to make a planet more like Earth, so that people can live on it

Oops not this kind of terraform..

If you are a DevOps Engineer or you have widen responsibilities inside your team, probably you have needed to create a server on cloud , or a pipeline or whatever..
And if you use AWS cloud, wow so many configurations and screens etc. mess.

Here comes the Terraform, an infrastructure as code tool that let you define both cloud and on-prem resources in human-readable configuration files that you can version, reuse, and share.

In other words, Terraform is a DevOps tool that you can use to design, create, destroy infrastructure.
Example given you can create applications, environments, networks, servers, pipelines etc.

Terraform provides support for manage resources on Amazon Web Services (AWS), Azure, Google Cloud Platform (GCP), Kubernetes etc.

For more info you can check the official terraform website.

---

Few months ago, in my team we faced the problem to automate our deployment process and we needed more environments to test the new deliverables with QA team and partners. The environments should be identical and have same build and deployment flow. 
So we decided to use Terraform to create new applications, environments and code pipelines on AWS cloud.

In this post, I will step on the first part of the solution we followed and I will describe the procedure how to build an AWS Beanstalk environment.

---

Prerequisite:

• Before we start Download Terraform
• Assume also that you already have already an AWS account.
  So you already have an:

access_key
secret_key 
region

We need these credentials in order to login on AWS cloud.

Starting:

Let’s see what resources we need to create :
1. An aws elastic beanstalk application 
2. An aws elastic beanstalk environment

May you want to associate an aws key pair . 
A key pair (public key, private key) is used to control login access to EC2 instances. Anyone with the private key, you can SSH into the EC2 machine .

Check here how can create one

We declare all resources inside the resources.tf file and all the variables inside the var.tf file.

So on resources.tf we want to create the elastic beanstalk application and theelastic beanstalk environment that will run a specific application version. Remember more than one environments can belong to one application.

# Create elastic beanstalk application resource 

“aws_elastic_beanstalk_application” “beanstalk-app” { 
   name = var.beanstalk_app_name
}

# Create elastic beanstalk Environment resource 

“aws_elastic_beanstalk_environment” “beanstalk-app-env” {
 name = var.beanstalk_env_name 
 application = var.beanstalk_app_name 
 solution_stack_name = var.solution_stack_name
<... add environment properties... >
}

As you see , we define 
the name of the environment, 
the application name, 
the solution_stack_name which specifies the platform will be used , in my example “64bit Amazon Linux 2018.03 v3.4.19 running Tomcat 8.5 Java 8”(check the supproted EB platforms here) 
and of course all the environment properties, as is the aws credentials, the database configuration (here a postgres configuration) etc

The environment properties (in Environment Configuration) can be declared “static”

setting {
  namespace =“aws:elasticbeanstalk:application:environment”
  name = “AWS_ACCESS_KEY_ID”
  value = var.aws_access_key
 }

or “dynamic”

dynamic “setting” {
 for_each = var.settings
  content {
   namespace = setting.value[“namespace”]
   name = setting.value[“name”]
   value = setting.value[“value”]
  }
 }

Go to Action:

Now we have created the resources.tf and var.tf file, we will execute the terraform commands to create the infrastructure.

On terminal, locate to folder that you have created these files.

First of all we need to initialise Terraform

terraform init

Now, terraform should creates an execution plan, detects the changes needed which and lets you preview them . The below command will show the resources that will be created, versioned, or scaled down

terraform plan

If everything looks fine to you, time to apply the changes. Terraform executes the actions scripted in the resources.tf file and creates the infrastructure.

terraform apply

Now assume that you want to destroy all remote objects managed by the configuration file (resources.tf ), execute

terraform destroy

You may want to destroy only some parts of infrastructure, e.g. to destroy the beanstalk environment or the the beanstalk application

terraform destroy -target=aws_elastic_beanstalk_environment.beanstalk-app-env

terraform destroy -target=aws_elastic_beanstalk_application.beanstalk-app

A more complete guide of how you can destroy resources in respect of terraform state you can check how-to-destroy-terraform-resources.

You can check the example source code on GitHub .

Happy “colonize” AWS :))

What is Redis: 
Redis is an open source , in-memory data structure store used as a database, cache, message broker, and streaming engine.
More info in https://redis.io/docs/about/

Jedis is a client library in Java for Redis

Install Redis
Check the instructions in https://redis.io/docs/getting-started/installation/

Java implementation

Add the Maven dependency in pom.xml

<dependency>
 <groupId>redis.clients</groupId>
 <artifactId>jedis</artifactId>
 <version>4.2.2</version>
</dependency>

Create a new class JedisCacheService

private Jedis jedis;
 /**
 * Initialize the cache (default: port 6379 , localhost)
 * if you have started the service on a non-default port or a remote machine,
 * you should configure it by passing the correct values as parameters into the constructor.*/
JedisCacheService(){
 jedis = new Jedis();
}
/** expirationTimeinSeconds = timeout for the specified key. */ void set(String key, String value, int expirationTimeinSeconds) {
 jedis.setex(key, expirationTimeinSeconds, value);
}
String get(String key) {
String data = jedis.get(key);
 if (data != null)
   return data;
return null;
}

Unit Test:

@Test
public void storeDataToRedisCache(){
 int expirationTimeInSeconds = (int) TimeUnit.DAYS.toSeconds(30);
 JedisCacheService jedisCacheService = new JedisCacheService();
 String key = “key-1”;
 String value = “value-1”;
 jedisCacheService.set(key, value,expirationTimeInSeconds);
 String valueInCache = jedisCacheService.get(key);
 Assert.assertEquals(value,valueInCache);
}

Redis CLI

You can verify by checking from command line the data stored in Redis using the redis-cli

redis:6379> keys *
1) “key-1”

redis:6379> mget key-1
1) “value-1”

For more info for redis commands check the documentation https://redis.io/commands/
and for Jedis implemetation the https://javadoc.io/doc/redis.clients/jedis/latest/index.html

Code is also availible in https://github.com/despoina555/CodeExamples/blob/main/src/main/java/org/despina/JedisCacheService.java
and the unit test in
https://github.com/despoina555/CodeExamples/blob/main/src/test/java/org/despina/AppTest.java

Asynchronous programming in Action

Modern life is fast.
We eat fast food, demand faster internet, shorter delivery times and instant news. So modern applications need to be fast.
Fast and reliable.

One way to achieve this is by using asynchronous programming.
In Asynchronous programming, main thread continues its execution without to be blocked by separate tasks that run on other threads , when they are completed , main thread is notified about their progress, completion or failure.

Asynchronous programming:
+ improves application performance
+ enhance responsiveness

Introduced in Java 8, CompletableFuture, is a way to perform Asynchronous programming , implements Future interface and provides the ability to complete a future, perform error handling , chain several futures , combine results of multiple futures .

Let’s see an example, nail your keyboards!

Assume that we have a sophisticated application that check the rates between Bitcoin and other currencies and suggest the user which currency to buy, EURO or CHF.

To implement it , I used the investing-cryptocurrency-markets API. 

We will send the 2 requests concurrently and when both responses fetched , we will check which currency have the minimum rate and will return it to the client.

So, we will send 2 CompletableFuture futureBTCtoEURO and futureBTCtoCHF to get the Rates .

final CompletableFuture<Double> futureBTCtoEURO = getRate(BTC,EURO);
final CompletableFuture<Double> futureBTCtoCHF = getRate(BTC, CHF);

getRate(int fromCurrency, int toCurrency) method, will send the request to find the rate to buy fromCurrency, toCurrency and returns a CompletableFuture. In case of exception , return as default 0d.

private CompletableFuture<Double> getRate(int fromCurrency, int toCurrency) {
 return CompletableFuture.supplyAsync(() ->     sendRequest(fromCurrency, toCurrency))
     .exceptionally(exception -> {
      System.err.println(exception);
      return 0d;
 });
}

combinedFuture is created by futureBTCtoEURO and futureBTCtoCHF , waits both features to complete

CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(futureBTCtoEURO, futureBTCtoCHF);

CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(futureBTCtoEURO, futureBTCtoCHF);

combinedFuture.get();

get is a blocking method so waits all futures to be completed

When they are completed, we assign on double basicBTCtoEURO and double basicBTCtoCHF the results of request.
First we validate if the futures are Completed without exception and then we update the value.

double basicBTCtoEURO = 0;
double basicBTCtoCHF = 0;

if (!futureBTCtoEURO.isCompletedExceptionally() && futureBTCtoEURO.isDone()) {
   basicBTCtoEURO = futureBTCtoEURO.get();
 }
 if (!futureBTCtoCHF.isCompletedExceptionally() && futureBTCtoCHF.isDone()) {
   basicBTCtoCHF = futureBTCtoCHF.get();
 }

To sum up:

String getBestRate() {

    int BTC = 189;
    int EURO = 17;
    int CHF = 4;

    double basicBTCtoEURO = 0;
    double basicBTCtoCHF = 0;

    final CompletableFuture<Double> futureBTCtoEURO = getRate(BTC, EURO);
    final CompletableFuture<Double> futureBTCtoCHF = getRate(BTC, CHF);

    // allOf :: waits to complete features futureBTCtoEURO,futureBTCtoCHF
    CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(futureBTCtoEURO, futureBTCtoCHF);
    try {
        combinedFuture.get();//get: blocking method, waits all futures to be completed

        if (!futureBTCtoEURO.isCompletedExceptionally() && futureBTCtoEURO.isDone()) {
            basicBTCtoEURO = futureBTCtoEURO.get();
        }
        if (!futureBTCtoCHF.isCompletedExceptionally() && futureBTCtoCHF.isDone()) {
            basicBTCtoCHF = futureBTCtoCHF.get();
        }

    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    return findMin(basicBTCtoEURO, basicBTCtoCHF);
}

Let’s run unit test:

@Test
public void sendMultipleRequests(){
    CompletableFutureImpl fut = new CompletableFutureImpl();
    String currency = fut.getBestRate();
    System.out.println( " Buy " + currency);
    Assert.assertNotNull(currency);
 }

Console logs:

Let's get started!
 getRate :fromCurrency  189 to currency 17
sending
 getRate :fromCurrency  189 to currency 4
sending
 getRate :fromCurrency  189 to currency 17 response {"data":[[{"currency_ID":17,"basic":"34910.1","reverse":"0.0000286","digits":1}]]}
 getRate :fromCurrency  189 to currency 4 response {"data":[[{"currency_ID":4,"basic":"36053.4","reverse":"0.0000277","digits":1}]]}
 Buy EURO

Check the code on Github : https://github.com/despoina555/CodeExamples/blob/main/src/main/java/org/despina/CompletableFutureImpl.java

Step by step, how to create an HttpClient that supports NTLM authentication in Java

The Problem:

Suppose that we have an instance of Apache HttpClient ( we will use the CloseableHttpClient implementation). We want to perform ΗΤΤP requests to a server that it uses the NTLM authentication security.

Some Theory:

NTLM is a challenge-response authentication protocol which uses three messages to authenticate a client .
Participants:

• Client
• Server
• Domain Controller(DC)

The Flow:

• The client sends the user name to the server (format DomainName\Username) (Username)
• The server generates a 16-byte random number, called a Challenge or Nonce, and sends it to the client. (Challenge)
• The client encrypts this challenge with the hash of the user’s password and returns the result to the server. (Response)
• The server sends to the DC the Username,Challenge,Response
• The DC validates if the authentication is successful.
  
  For more info check the Microsoft Doc

Let’s go to Action!

Maven dependency:

<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.12</version>
</dependency>

The Code:

In order to create the ΝTLM auth provider we need to create:

1. CredentialsProvider

CredentialsProvider credsProvider = new BasicCredentialsProvider();
 credsProvider.setCredentials(AuthScope.ANY, new NTCredentials(“username”, “password”,”workstasion”,”domain name”));

2. AuthSchemeRegistry

Registry<AuthSchemeProvider> authSchemeRegistry = RegistryBuilder.<AuthSchemeProvider>create()
 .register(AuthSchemes.NTLM, new NTLMSchemeFactory())
 .build()

AuthSchemeProvider implementation creates and initializes NTLMScheme instances configured to use the default NTLMEngine implementation. The NTLMEngine can be used to generate Type1 messages and Type3 messages in response to a Type2 challenge

3. Set the TargetPreferredAuthSchemes

RequestConfig config = RequestConfig.custom()
 .setConnectTimeout(connectionTimeout * 1000)
 .setConnectionRequestTimeout(connectionRequestTimeout * 1000)
 .setCookieSpec(CookieSpecs.DEFAULT)
 .setTargetPreferredAuthSchemes(Arrays.asList(AuthSchemes.NTLM,   AuthSchemes.KERBEROS, AuthSchemes.SPNEGO))
 .build();

We give higher priority to NTLM auth schema compare to others

** Notice **
The order is important , also, if you set only setTargetPreferredAuthSchemes(Arrays.asList(AuthSchemes.NTLM)) you will fail to authenticate and will have in logs :
“Authentication scheme Negotiate not supported” . 
This means that the client is only willing to do NTLM while the server is only willing to do Negotiate, thus failing to agree on a common authentication scheme.

4. Build the Client:

CloseableHttpClient httpClient = HttpClientBuilder.create()
 .setDefaultCredentialsProvider(credsProvider)
 .setDefaultAuthSchemeRegistry(authSchemeRegistry)
 .setConnectionManager(new PoolingHttpClientConnectionManager())
 .setDefaultCookieStore(new BasicCookieStore())
 .setDefaultRequestConfig(config)
 .build()

Our client is ready to use!

5. Unit Test

HttpGet httpGet = new HttpGet(“path”);
httpGet.addHeader(“Content-type”, “application/json; charset=utf-8”);
CloseableHttpResponse response = httpClient.execute(httpGet);
Assert.assertEquals(200,response.getStatusLine().getStatusCode());

Check the code in GitHub Repo:
https://github.com/despoina555/CodeExamples
Class: /src/main/java/org/despina/NtlmAuthImplemetation.java
Unit test: src/test/java/org/despina/AppTest.java

Sexy, Chic , Powerful

Sexy and Chic because they produce elegant code by constraining the choices of what you can pass.
Powerful, because by limit your choices , actually increase the code effectiveness (it means the code you write today will work if reused 10 years later )

But , first things first…

What is an Enum type? 
They are classes that export one instance for each enumeration constant (think a public static final field ), or consider it as a generalization of singletons ( singleton as an single element enum)

What they Provide?:

• Compile-time Type Safety:
  Prevent typos and invalid parameters passing in compile-time checking and prevent errors like passing Null values that will fail in Run-time
• Make testing easier
  If enum is passed as parameter in a method, testing is easier for edge conditions, for example no need to write unit tests for invalid input
• They are Self-documented
  The set of choices for a parameter is finite and self-describing, so no need to write comments or documentation
• Can have methods and other fields 
  In Java doc , enum is defined as:

public abstract class Enum<E extends Enum<E>>

extends Object

implements Comparable<E>, Serializable

So you can add methods, fields and implement any behavior you want. **PS** An Enum cannot extend other Enum, all of them extend java.lang.Enum class and Java doesn’t supports multiple inheritance !

When to use them?

• When you need a set of constants that are known at compile time(e.g transaction statuses, planets , days of week , lipstick color codes )
• According to Bloch , a single-element enum type is the best way to implement a singleton.
• Use them to implement the Strategy design pattern
  In this case each enum or many enums can share a behavior.
  Let’s see the below example, the strategy is the ConnectType , enums INSTAGRAM, LINKEDIN, TINDER share the same way to connect, sending a PM, but PHONE and SKYPE follow a different approach.

public enum Networking {

    INSTAGRAM,LINKEDIN, TINDER,
    PHONE(ConnectType.LANDLINE), SKYPE(ConnectType.VoIP);

    private final ConnectType connectType;
    Networking() { this.connectType= ConnectType.TEXT; }
    Networking(ConnectType connectType) {
        this.connectType=connectType;
    }

    void connect(){
        connectType.connect();
    }

    private enum ConnectType {

        TEXT {
            @Override
            void connect() {
                System.out.print("Send a PM ..");
            }
        },

        VoIP {
            @Override
            void connect() {
                System.out.print(" Do a video call! ");
            }
        },

        LANDLINE {
            @Override
            void connect() {
                System.out.print("Classic and Vintage! ");
            }
        };

        abstract void connect();
    }
}