Forem: Kamil

When JavaScript regex can surprise you - a silly bug story

Kamil — Wed, 15 Feb 2023 09:25:00 +0000

Recently one of my customers let me know that they have probably a bug in their app. They want me to look into it - so I jump into “Sherlock, the bug hunter” mode and start snooping!

The misbehaving feature was some kind of search. It takes an input, a Javascript regular expression and as an output returns true if regex was satisfied - and false otherwise.

The feature was pretty simple on the code side - the search function looked similar to the one below:

var search = function(regex, text) {
    if (regex && regex.test(text)) {
        return true;
    }
    return false;
}

So we can see that the heart of it was a simple regex.test call.

The bug report stated that misbehaving example was regex /pony/g and text this is a pony and not a horse - we have 100% sure that pony is in this sentence. To check if everything was working correctly I opened console in Chrome Developer Tools, loaded the search function and check its result:

// Below returns true
search(/pony/g, "this is a pony and not a horse"); 
// this also returns true!
search(/pony/g, "this is a pony and not a horse"); 
// ... five runs later
// eh? still returns true!
search(/pony/g, "this is a pony and not a horse");

What is going on?! Every run of this function returns the correct and expected value.

But wait… the regex and text was passed using variables from somewhere else. Let’s put them in the variables and try to run the function multiple times again:

var regex = /pony/g
var text = "this is a pony and not a horse";
search(regex, pony); // returns true as expected
search(regex, pony); // returns false :O
search(regex, pony); // returns true - what a trickery!
search(regex, pony); // returns false - wut?!

And now we have a problem - despite the fact we should get true every time we sometimes get false instead.

The answer to this weird behaviour is in the… documentation. Quick look at the RegExp.prototype.test() on mdn web docsand we have found the culprit:

JavaScript RegExp objects are stateful when they have the global or sticky flags set (e.g., /foo/g or /foo/y). They store a lastIndex from the previous match

And the latIndex property is described as:

The lastIndex data property of a RegExp instance specifies the index at which to start the next match.

We have the global option in our regex - and that was the reason that it behaves in a not expected manner. Similar results will be if our test text were this is a pony and second pony - it will give us true for the first and the second search (as we have two ponies!) and false for the third one.

The solution for this issue was simply to reset the lastIndex property of regex if something was found

var search = function(regex, text) {
    if (regex && regex.test(text)) {
        // reset lastIndex property to make sure 
        // that next test will start from beginning
        regex.lastIndex = 0; 
        return true;
    }
    return false;
}

That’s all folks! One line, resetting one property, is all that was needed to fix the issue.

What is the takeaway from this issue? When in doubt and especially when working with regexes - read documentation. It can save you a lot of time. :-)

Accessing Kubernetes cluster using SSH tunnel

Kamil — Wed, 14 Dec 2022 10:20:00 +0000

Whether we want it or not adoption of Kubernetes is growing. It can be set up as a managed solution (all major cloud providers provide such products) or we can set it up by yourselves. No matter if we select the former or the latter - we would like to make it as secure as it can be. One of the solutions to make the Kubernetes cluster more secure is to hide a control plane (to be more specific - kube-apiserver) behind a firewall. That means cluster management is not available from the Internet.

That creates problems with accessing it. We can SSH to a server that is in the same network and run kubectl commands from there, but this is a nuisance which we want to avoid. Fortunately, SSH tunnels came with help in that case (not for the first time!) - we can create a tunnel to the server in the same network and pass all traffic to the cluster through it!

To do it we can run the command:

$ ssh our-gate.example.com -L 16443:10.0.10.2:443

In the command, we’re assuming that:

our server is available with the domain our-gate.example.com,
the cluster is in the same local network as the server and its control plane is available at 10.0.10.2 IP address,
we want the tunnel to be available at port 16443.

Now we need to replace IP address / hostname of cluster in ~/.kube/config to point to local tunnel. To do this we will open aforementioned file and replace put https://127.0.0.1:16443 in clusters.cluster.server property:

apiVersion: v1
clusters:
- cluster:
certificate-authority-data: <long string with CA data>
# line below was something like https://our-public-address-of-cluster.example.com or just local IP like https://10.0.10.2 
server: https://127.0.0.1:16443 
name: my-k8s-cluster

After that we can try to run a command like kubectl cluster-info:

~ > kubectl cluster-info
To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
Unable to connect to the server: x509: certificate is valid for our-public-address-of-cluster.example.com, 10.0.10.2, not 127.0.0.1

It fails, but why? It is because we want to connect to 127.0.0.1 but API (securely server over https) is responding with a certificate issued for different domain / IP address. Fortunately solution for that is simple which is to put clusters.cluster.tls-server-name property with one of the valid values from the error message - in our case it can be 10.0.10.2.

Our final configuration will look like this:

apiVersion: v1
clusters:
- cluster:
certificate-authority-data: <long string with CA data>
server: https://127.0.0.1:16443
tls-server-name: 10.0.10.2
name: my-k8s-cluster
contexts:
- context:
cluster: my-k8s-cluster
user: admin
name: my-k8s-cluster
current-context: my-k8s-cluster
kind: Config
preferences: {}
users:
- name: admin
user:
token: <some-fancy-token>

And now running cluster-info command will gives us what we expect:

~ > kubectl cluster-info
Kubernetes control plane is running at https://10.0.10.2:16443
GLBCDefaultBackend is running at https://10.0.10.2:16443/api/v1/namespaces/kube-system/services/default-http-backend:http/proxy
KubeDNS is running at https://10.0.10.2:16443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
Metrics-server is running at https://10.0.10.2:16443/api/v1/namespaces/kube-system/services/https:metrics-server:/proxy

Yay! Now we can use kubectl, helm and other software that uses configuration from ~/.kube/config from our local machine!

And a small “bonus” (and also describing it to the future myself) - accessing Kubernetes in GCP (GKE) through Identity Aware Proxy:

$ gcloud compute ssh "some-instance" --zone "$ZONE" --project "$PROJECT" --tunnel-through-iap --ssh-flag="-L 16443:10.0.10.2:443"

That is it - the SSH tunnel again saves the day! :-)

Project YALA - MongoDB Atlas Hackathon 2022 on DEV submission

Kamil — Mon, 05 Dec 2022 07:32:49 +0000

What I built

I built Project YALA (or simply YALA) which is "Yet Another Link-shortener App".

Category Submission:

Think Outside the JS Box - as it is not-the-JS-stack but still nothing wacky to put in other category ;-)

App Link

https://project-yala.fly.dev/

App is run in preview mode - no add/delete options provided.

Example links with data (some short link which redirects to dev.to):

details page: https://project-yala.fly.dev/link/638a74cb82478a464c478282/3d9ae405-ba98-4930-9979-4ec11c7c2454
details (analitycs) page: https://project-yala.fly.dev/link/638a74cb82478a464c478282/3d9ae405-ba98-4930-9979-4ec11c7c2454/visits
link to click with preview - to show what URL is going to be opened: https://project-yala.fly.dev/j/3fe3fd2/preview

Screenshots

Description

YALA is a simple link shortener that works without logging in - instead it creates "secret key" which allows to view details of created short link and it's statistics.

Generally it is simple app to show that we do not need fancy frameworks to make nice looking, fully working application.

Link to Source Code

https://github.com/elwin013/project-yala

Permissive License

MIT, https://github.com/elwin013/project-yala/blob/master/LICENSE.md

Background

I always wanted to create simple link shortener, just for fun. :-) Additionally this was good moment to look into new Timeseries features from MongoDB.

Instead of using commonly used frameworks (like Spring Framework) I preffered to use something that is small and doesn't have "magic" in it. So I've chosen Javalin as a simple web framework, added MongoDB client libraries nad jte as template engine. To show that simple and clean looking apps doesn't need any big JS libraries I've selected chota - one of micro CSS frameworks.

How I built it

On the app side I've used:

https://javalin.io/ - simple web framework,
https://jte.gg/ - template library,
https://jenil.github.io/chota - micro CSS framework,
MongoDB for database.

On the MongoDB side I've used just two collections - one with data about links and the second one with visits. For the latter I used timeseries collection to aggregate data into some chunks (in case of example - group visits per hour).

All MongoDB related stuff was done on the code side (except creating cluster, database and user to access). It is pretty great that as long as you have access to database you can work with it freely - e.g. collection is created as soon as first document is saved!

For deployment I've used https://fly.io - mostly because I wanted to check out some Big-Three (AWS,GCP,Azure) alternative for hosting apps!

Additional Resources/Info

Nothing I can think of! ;-)

MongoDB sequences (auto-increment) - The Java Way

Kamil — Fri, 02 Dec 2022 21:30:00 +0000

tl;dr: Full code available at my Github - elwin013/mongodb-sequences.

One of the missing elements while using MongoDB is lack of the auto-increment fields, commonly called sequences (e.g. in PostgreSQL). For MongoDB Atlas (managed MongoDB solution) there is a posibility to mimic this feature using database triggers (as mentioned on MongoDB page).

But what about self-hosted database? Unfortunately, there are no triggers there (or I’m not aware of them :-)), so we need to improvise and make that happen with custom code.

To make this work we will create a collection called sequence which will have documents with two fields describing the sequence:

_id with a name,
value with a value.

The code will be relying on MongoDB’s document write atomicity. Linked documentation says:

A findAndModify operation on a document is atomic

In the case of the Java Mongo driver, our operation is findOneAndUpdate. We will be searching for exactly one document with the selected id (name of the sequence), increment value and return that document after the update. Let’s do it!

Below is Sequence record (it can be replaced with the classic POJO if we need to run code on e.g. Java 11 or 8).

import org.bson.codecs.pojo.annotations.BsonId;

public record Sequence(@BsonId String name, Long value) {}

Worth mentioning is the @BsonId annotation - this annotation will make field name an id field (_id) for document in collection. So our document will have two fields - _id (which will contain sequence name and will be mapped to name field in code) and value with value.

Now we can write code to update (increment) and return sequence value. We also want to be sure that the document always is created (update and insert, so upsert) and will be returned after creation. To achieve that we will customize options of findOneAndUpdate request:

var options = new FindOneAndUpdateOptions()
                .upsert(true)
                .returnDocument(ReturnDocument.AFTER);

And the cherry on the top - findOneAndUpdate operation:

 var seq = db.getCollection("sequence", Sequence.class)
            .findOneAndUpdate(
                    Filters.eq("important_sequence"),
                    Updates.inc("value", 1),
                    options
            );

The code above will search for a document with id important_sequence, increment the document’s value field by one and return the document - exactly what we need. And if the document doesn’t exist - it will be created and seq.value() will give us 1.

We can always change the value of sequence using similar code (Updates.set instead of Updates.inc) - but we need to set it to 0 if the next value needs to be 1.

And that is all - we have sequences in MongoDB without any additional tools! Feels great! :-)

Full code available at my Github - elwin013/mongodb-sequences - including record class, DAO and some fancy tests using TestContainers to test code using MongoDB on Docker.

Reading JWT token claims without a library

Kamil — Fri, 14 Oct 2022 13:49:00 +0000

Almost everybody who works on web apps knows what JWT (JSON Web Token) is. They become pretty popular and are now widely used.

Without going into details (which can be read e.g. at jwt.io/introduction) JWT is built from three parts divided by dots:

header.payload.signature

The middle part, payload, is interesting for us. It contains claims, which are statements about an entity (e.g. the user) and some additional data.

For purpose of this post we will use an example token from jwt.io (click on the link to open it in the debugger!) which looks like this:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

The payload in the token is just a base64 encoded JSON object. That means we can decode it and load this JSON string into the dictionary to have easy access to properties.

There is only one tricky part here - base64 padding! The payload in the JWT is alfa-numeric only, there is no = character. To be sure that it will be decoded properly we need to add max padding (==) to the payload string - it will be ignored if not needed. But if we will not have it there (but it is expected to be) - decoder will throw an error.

To sum up all above stuff in simple lines of code in Python:

import base64
import json
# Assuming the token is in the token variable 
token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9." \
"eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ." \
"SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
# Split by dot and get middle, payload, part;
token_payload = token.split(".")[1]
# Payload is base64 encoded, let's decode it to plain string
# To make sure decoding will always work - we're adding max padding ("==")
# to payload - it will be ignored if not needed.
token_payload_decoded = str(base64.b64decode(token_payload + "=="), "utf-8")
# Payload is JSON - we can load it to dict for easy access
payload = json.loads(token_payload_decoded)
# And now we can access its' elements - e.g. name
name = payload["name"]
# Let's print it - it should show "John Doe"
print(name)

You can run it in the browser on Replit (Reading JWT token without library on Replit) or locally with Python 3.

And that’s all. It is pretty simple, isn’t it?

And it feels great to be able to do it without any additional tools! :-)

How to customize Jetty in Spring - Custom Error Handler

Kamil — Tue, 21 Jun 2022 13:41:00 +0000

Last week we found out that in some cases our application is showing redundant data on error - for example stacktrace. It happens when there was an error which was handled by the application container which was Jetty. For example, sending a header like X-FORWARDED-PORT: some-not-numeric-value causesNumberFormatException and shows a full stacktrace.

We’ve looked over the documentation and see that we could hide stacktrace in default error handler. Instead of that, we decided to replace it with a custom one. That allows us to put an additional logging logic and customize the output. And this is a short description of how to do it. ;-)

To implement the custom error handler we can extend org.eclipse.jetty.server.handler.AbstractHandler and override handle method. On the code snippet below there is an example handler. For sake of clarity it returns always simple text (content-type text/plain) with code, error message and URL used.

We can extend it by adding additional logic like different responses based on headers from the client, additional logging and so on. :-)

package pl.net.banach.customizeJetty;

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.nio.BufferOverflowException;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.eclipse.jetty.http.MimeTypes;
import org.eclipse.jetty.io.ByteBufferOutputStream;
import org.eclipse.jetty.server.Dispatcher;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.handler.AbstractHandler;
import org.eclipse.jetty.util.StringUtil;

public class CustomJettyErrorHandler extends AbstractHandler {

    @Override
    public void handle(String target, Request baseRequest, 
                       HttpServletRequest request,
                       HttpServletResponse response) 
                       throws IOException, ServletException {


        try {
            // Get error message, sanitize it, just in case.
            String message = StringUtil.sanitizeXmlString(
                (String) request.getAttribute(Dispatcher.ERROR_MESSAGE)
            );

            // Get error code that will returned
            int code = response.getStatus();

            var charset = StandardCharsets.UTF_8;

            // Get writer used
            var buffer = baseRequest.getResponse().getHttpOutput().getBuffer();
            var out = new ByteBufferOutputStream(buffer);
            var writer = new PrintWriter(new OutputStreamWriter(out, charset));

            // Set content type, encoding and write response
            response.setContentType(MimeTypes.Type.TEXT_PLAIN.asString());
            response.setCharacterEncoding(charset.name());
            writer.print("HTTP ERROR ");
            writer.print(code);
            writer.print("\nMessage: ");
            writer.print(message);
            writer.print("\nURI: ");
            writer.print(request.getRequestURI());


            writer.flush();
        } catch (BufferOverflowException e) {
            baseRequest.getResponse().resetContent();
        }

        baseRequest.getHttpChannel().sendResponseAndComplete();
    }
}

When we have the error handler ready then it registering it is easy. To do this we will create a custom configuration which implements WebServerFactoryCustomizer with @Configuration annotation. In a customize method we will create a customizer and add a newly created error handler.

Seems simple, but be sure to put this configuration class in a package that is scanned by Spring @ComponentScan annotation!

package pl.net.banach.customizeJetty;

import org.springframework.boot.web.embedded.jetty.JettyServerCustomizer;
import org.springframework.boot.web.embedded.jetty.JettyServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.context.annotation.Configuration;

@Configuration
public class JettyConfiguration
            implements WebServerFactoryCustomizer<JettyServletWebServerFactory> {

    @Override
    public void customize(JettyServletWebServerFactory factory) {
        JettyServerCustomizer customizer = server -> {
            server.setErrorHandler(new CustomJettyErrorHandler());
        };
        factory.addServerCustomizers(customizer);
    }
}

And that’s all - from now all errors that go to Jetty (application server) will be handled by our custom handler. :-)

How to expose local service using nginx and SSH

Kamil — Fri, 25 Mar 2022 19:20:00 +0000

One of my colleagues needs to expose the local running app to an external service. There were simple constraints - the domain name under which service was exposed cannot change (because it needs to be whitelisted) and need to be a subdomain of the company domain.

They already have some virtual machines for developers with external IP adresses and SSH access running. I’ve proposed using them to solve this task - below you can find the solution that can be applied.

What will be needed:

publicly available server (external IP) with (GNU/)Linux and nginx (for this post I’m assuming it is Ubuntu),
user and permissions to change nginx configuration (sudo/root),
SSH access for that server,
some domain name, for example - some.domain.tld - pointing to the server external IP.

Let’s start with configuration - in /etc/nginx/sites-available/some.domain.tld write:

server {
  listen 80;
  listen [::]:80;

  gzip on;
  server_name         some.domain.tld;

  location / {
    proxy_pass http://127.0.0.1:8080;
    proxy_redirect off;
    proxy_set_header Host 127.0.0.1;
    proxy_set_header X-Original-Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
  }
}

This configuration will proxy requests for some.domain.tld to the local port 8080 on the server.

To enable it we need to link this configuration to sites-enabled directory using command:

ln -s /etc/nginx/sites-available/some.domain.tld /etc/nginx/sites-enabled/some.domain.tld

and restart nginx - systemctl restart nginx. Now under domain some.domain.tld visitors will see an error page with the message “bad gateway” - all because on 8080 port there is nothing.

Now, with the power of a ssh tunnel, we will make this 8080 port on remote server will point to some port on our local machine.

To expose our local service we can use the command:

ssh -N -R $PORT_ON_SERVER:localhost:$LOCAL_PORT $LOGIN@$SERVER

where:

$PORT_ON_SERVER is the port which we forward request to on server,
$LOCAL_PORT - local port on dev machine where something is running,
$LOGIN and $SERVER are the username and address of the server running proxy.

Assuming that username is alice, the server is available under some.domain.tld domain and our local service is available under port 4502:

ssh -N -R 8080:localhost:4502 alice@some.domain.tld

And that’s all - after opening the domain in the browser we will see our local service. And anybody on the Internet can also view it, so watch out! ;-)

How to prevent running script if there are changes in local Git working space

Kamil — Fri, 30 Jul 2021 08:49:00 +0000

Recently I spent some time making improvements around deploying an application. Some of them are bash scripts automating some boring actions. All of them has one common part - should not be run if there are any changes (staged or not) in the local Git repository (working tree). Fortunately, it is simple to incorporate checks like this into scripts!

To get the information about staged (added with git add) and not staged files we will use git diff command. Without any parameters, it will give us detailed information of what changed. That is a bit too much than our needs, so we will use --stat flag to get only statistics - path to file and the number of lines added and removed:

# ~/repository> git diff --stat
unstagedFile.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)

For staged files we will use very similar command - it will be git diff --stat but with--cached flag:

# ~/repository> git diff --cached --stat
stagedFile.txt | 1 +
1 file changed, 1 insertion(+)

Both commands will return empty strings when no changes. We will use that information to show the message and stop (exit) script. In the end, script will look like this:

#!/bin/bash

# Fill up variables
STAGED_CHANGES=`git diff --cached --stat`
NOT_STAGED_CHANGES=`git diff --stat`
# Check if there are any staged but not committed changes
if [! -z "$STAGED_CHANGES"]
then
# Show message
echo -e "You have staged, but not committed changes. Not releasing!"
# And exit with non-zero code
exit 1;
fi
# Check if there are any not staged
if [! -z "$NOT_STAGED_CHANGES"]
then
# Show message
echo -e "You have not staged and not committed changes. Not releasing!"
# And exit with non-zero code
exit 1;
fi
## Anything else we need to do! ##

This script:

run commands mentioned above,
store results in variables,
if any of those variables are not empty - show the message and exit script with non-zero return value.

Why non-zero return value? Because by default 0 is treated as “everything was OK” and any other value means “error”. This allows to chain commands like doSomething && doMagic - in that case, doMagic will run only if doSomething return exited with 0.

Bonus stuff - we can make output red using some magic numbers which we can put in a script (in echo command):

#!/bin/bash
RED_START="\033[1;31m"
RED_END="\e[0m"
echo -e "Normal message!"
echo -e "${RED_START}Normal message but in RED!${RED_END}"

The result of the script above will look like this:

And that’s all folks! If you find this post useful - let me know! :-)

How to put pom.xml version and build date in properties?

Kamil — Fri, 04 Jun 2021 19:27:55 +0000

While working on webapp API in Java I need to send the app version and the build date to the frontend. But how to make this?

As my API build is based on maven I thought about getting version from pom.xml file. So, let's make it this way!

Solution! Almost...

I need to put in the pom.xml file configuration responsible for resources filtering:

<build>
 <!-- clipped -->
   <resources>
     <resource>
       <directory>src/main/resources</directory>
       <filtering>true</filtering>
     </resource>
   </resources>
</build>

And in the app.properties properties which will be replaced during build:

build.version=${pom.version}
build.date=${timestamp}

After the build my app.properties is filled with expected data:

Now I can access version from POM and last build in Java app easily!

And fin^H^H... another problem?

Everything works smoothly, I can get the version from the pom.xml and also the build date. But... a favicon is now broken! What?!

Frontend is deployed along with backend (using Javalin static files feature and files were loaded from resources folder.

It turns out that the resource filtering plugin processe favicon.ico (in fact all .ico files) and broke them by saving them incorrectly. So I need to exclude those files from filtering!

Final solution

Final configuration in the pom.xml looks like in snippet below.

It processing all files in src/main/resources except all .ico files. But I want .ico in resource folder - so I need add them but without filtering (processing them).

<build>
 <!-- clipped -->
   <resources>
     <resource>
       <directory>src/main/resources</directory>
       <filtering>true</filtering>
       <excludes>
         <exclude>**/*.ico</exclude>
       </excludes>
     </resource>
     <resource>
       <directory>src/main/resources</directory>
       <filtering>false</filtering>
       <includes>
         <include>**/*.ico</include>
       </includes>
     </resource>
   </resources>
</build>

And that's all - everything is now OK ;-)

Why my session is not persisted?! Another story of (de)serialising...

Kamil — Thu, 14 Jan 2021 08:00:00 +0000

Yep, that’s another story of “always check if serialising and de-serialising works as expected”. And some kind of reminder for future-me if I forgot about this! ;-)

Session of logged users seems to be a pretty easy topic, yep? For sure it is! What if you want to share that session between different instances of your app? That seems quite easy too - let’s store it in a database and you’re good to go.

Need and sort of “background”

For my last project, I’m using a simple web framework called Javalin, which runs default on Jetty. And after making PoC I’ve come across of topic “single user using many app instances”. Fortunately, there is even tutorial about it on Javalin page (here). I’ve checked it, wrote a bit code aaaand… it is not working as expected!

Problem

When enabled saving session into database and user was… logged out instantly! Error 401 was sent from the secured resource and frontend was redirecting to the login which invalidates session (which, in fact, was desired behaviour). But the question is - why this 401 was sent if the user logged in correctly?

After debugging and looking into saved session object in database I’ve found out that there is NO USER DATA THERE!

Wait, what? I’m sure that I’ve put that data into the session. It works if the session was in memory!

Let’s see how writing and reading values into session looks in Javalin:

// saving value
ctx.sessionAttribute("mystery", "I like trains");
// and reading value to the "value" variable
var value = ctx.sessionAttribute("mystery");

Pretty simple, yep? And this is how saving user details was in my app:

var userDetails = new UserDetails();
// ... filling up data and saving to session
ctx.sessionAttribute("USER", userDetails);

Looks the same… and not working. But mystery above works, so what the heck is going on?!

Solution!

You might already know because I’ve already written it in the beginning - serialisation. Session store (from class JDBCSessionDataStoreFactory) didn’t know how to save object with user details to the database. So it simply ignores it. And the rest of the app didn’t work because there was no user data, so no info about user roles, so no cookies and big “NONONO”.

So, solution was simply to serialise and de-serialise it, for example as a JSON. For that I’ve used Jackson mapper:

// yep, simple com.fasterxml.jackson.databind.ObjectMapper
var objectMapper = new ObjectMapper();
// serialize before saving to session
var userDetails = new UserDetails();
// ... filling up data and saving to session
ctx.sessionAttribute(
    "USER", 
    objectMapper.writeValueAsString(userDetails)
);

// and reading it in some other place
String userDetailsStr = ctx.sessionAttribute(
    USER_SESSION_KEY
);
var userDetails = objectMapper.readValue(
    userDetailsStr, 
    UserDetails.class
);

And everything started to work smoothly and as expected!

Takeaways

I will repeat myself from the beginning - always check if serialising and de-serialising works as it should. And additionally - check if data is saved. That can save a lot of work and time. :-)

Git config based on current (sub)folder

Kamil — Sun, 29 Nov 2020 15:00:00 +0000

Some time ago I’ve looked over my current company repositories. Surprisingly there was a lot of commits with emails that are not company ones. Instead of those - a lot of gmail.com, _outlook.com_and other free email providers!

That looks a bit unprofessional, isn’t it? Even if we do some freelance gigs - we probably want to put nicer email than private one used for social websites. And if, for some reason, we’re forced to use company email - we need to be sure that it will be used!

So, what we can do to make it better? Just configure it with couple lines of code ;-) Let’s assume that all our work-related stuff will live in ~/work folder and all other is personal. So, let’s start with a simple ~/.gitconfig configuration:

# ~/.gitconfig
[user]
name = Johny Mnemonic
email = johny@mnemonic.tld
[includeIf "gitdir:~/work/"]
path = ~/work/.gitconfig

Configuration in user section will be default one. We will overwrite it in other configuration files, like in folders with work.

Let’s then create an additional configuration for work, just in our work folder:

# ~/work/.gitconfig
[user]
email = johny@memory.courier.tld

We want to put our name in commits, yep? So only one thing that we overwrite will be the email address. Instead of private one, there will be company email.

And that’s it. Now all repositories, that didn’t have set up individual user settings, will use ones that are based on the folder, e.g.:

~/work/super-duper will use work configuration,
~/project/my-website will use private (default) one.

I hope that “short writeup” will help somebody in some way. :-) Also - did you have any comments? Drop me a line on Twitter!