DEV Community: Vincenzo Palazzo

Swing theming: Basic introduction to MaterialTheme System

Vincenzo Palazzo — Thu, 18 Aug 2022 23:42:17 +0000

Since 2019, material-ui-swing has an experimental feature that is called MaterialTheming. In particular, MaterialTheming is a proposal to add a declarative Theme system inside Swing like the material theming system implemented in Flutter or Jetpack Compose.

Introduction to Material-UI-Swing

Material-UI-Swing is a library that gives the possibility to import material style inside a very old framework like Swing with the original swing API. The library was originally born as College Project by atharva washimkar and transformed into a product by vincenzopalazzo.

In addition, the original project was forked by vincenzopalazzo because he started to implement some experiments in his own repository, after that, the repository https://github.com/vincenzopalazzo/material-ui-swing was the only repository maintained, but periodically the atharw's receive synchronization with the last update.

After the original maintainer left the project as maintainer in 2018 and the vincenzopalazzo new maintainer begin in 2018 until now, the scope development of the library start to be to grow as a product. This was also possible by the support from Arizona State University during the integration of the library with one of the most popular Swing software in the world which is JMars.

The development of the library was focused to experiment with some solutions that provide the building blocks for the end developers to implement any type of style that the user wants without using a standard palette built inside the library.

This opens two problems, that are described below:

Implementing a dynamic component that is able to change with user settings can be difficult because can contain a lot of corner cases.
Swing framework has no easy concept of theme inside (a theme in the sense of Style and not only colors), but that can also change the style of one component.

Introduction to MaterialTheming System

Material Theming system provided of constant build in the library under a MaterialTheme interface and with this concept to have an interface that provides the access to all the value that Swing process to build and styling the UI material-ui-swing is able to support external theme provided in separate jars that include only the style of the application.

One example of an external theme is DarkStackOverflowTheme, and this is an important feature to have inside a UI toolking.

In contrast, the MaterialTheme interface can be improved and allowed different formats of configuration, by file propriety or JSON, and so on.

This is particularly powerful when the user wants to import some theme from external resources like the Intellij themes or others.

Example of Usage

Change theme is super easy and doesn't require you to make any change inside the repository, you can have inside the static block the following code

static {
    try {
      // UIManager.setLookAndFeel(new MaterialLookAndFeel(new MaterialLiteTheme()));
// by including the https://github.com/material-ui-swing/DarkStackOverflowTheme
     UIManager.setLookAndFeel(new MaterialLookAndFeel(new DarkStackOverflowTheme())); mouse hover
    } catch (UnsupportedLookAndFeelException e) {
      e.printStackTrace();
    }

Conclusion

After many years I start to share my experiment started on material-ui-swing to implement a custom theme, and implement an alternative library to modernize Swing application.

If you like my work considered to sponsor me on Github sponsor page and follow me on Github @vincenzopalazzo

Run a cln node with clightning4j tools on a tiny VPS

Vincenzo Palazzo — Sat, 13 Aug 2022 13:46:26 +0000

In this post, we will talk on how to set up a lightning node quickly using clightning4j tools.
For this we will use a free AWS virtual machine but the same can be used with DigitalOcean where you can use my invite link to have $100 for free (for a couple of months of core lightning free).
Other than that, you need to install on your virtual machine, docker, and docker-compose
We will try to do it step by step below.

Introduction to clightning4j tools

clightning4j is a collection of tools to make integration of core lightning and running one node easier. One of the most important plugins is btcli4j which is a backend plugin that supports rest and pruning mode for bitcoin, so you can run your node in a lightweight environment and very quickly.
In addition, it offers a Java library JRPClightning to interact with core lightning and also develop a plugin for core lightning.
This collection of tools is just a way to implement ideas born more than 2 years ago, but the intention is to move the more successful idea into a more modern language like Dart, Rust, and Go. So, yeah I make a lot of mistakes but I also learned a lot in the process :)

Hands-on the configuration

For this article, I will choose to go with the AWS virtual machine where I installed Debian, and you can start to follow the guide from this page. However, this guide will be independent of the services and will be dependent only on the Debian operative system
When you have your machine up and running choose your best method to connect to the virtual machine, I will use ssh, and the first two commands that I run every time at the first login are the following:

>> sudo apt update && sudo apt upgrade -y

After the process will finish we need to install docker and docker-compose. We will start to install docker with the official guide and we will run the following commands for Debian:

>> sudo apt-get install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

After that, we add the GPG signature

>> sudo mkdir -p /etc/apt/keyrings
>> curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

and after

>> echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Ok, you don't see anything right? This is normal 👩🏾‍🔬
Let's run the last commands, which are:

>> sudo apt-get update
>> sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

After the completion of the process, we need to see if all is ok, and we run the hello-world in docker, with the following command
sudo docker run hello-world
Done, we have docker installed, you should also have the docker compose command available

Configuring clightning4j node

The easier way to start it is to visit the GitHub repository clightning-node and take one of the examples that are present in the example directory,
we will use the grpc-docker-compose.yml, now we run the following commands

>> mkdir cln && cd cln
>> wget https://raw.githubusercontent.com/clightning4j/clightning4j-node/main/examples/grpc-docker-compose.yml
>> sudo docker compose up --build

and when you have your node up un running, open a new console and run the following command

>> sudo docker compose run -T cln_test lightning-cli --testnet getinfo

and the output would be

{
   "id": "028fe59bd7bbe3982699535e7e43b305c69099fbdd9902b1af5875a121fdb9a3dc",
   "alias": "lndart-testnet",
   "color": "028fe5",
   "num_peers": 6,
   "num_pending_channels": 0,
   "num_active_channels": 8,
   "num_inactive_channels": 0,
   "address": [
      {
         "type": "ipv4",
         "address": "52.55.124.1",
         "port": 19735
      },
      {
         "type": "torv3",
         "address": "s5esrtw7l4uix5idxoa3lcdrihmchsk2evrtelnp6peke4rqfdjp54id.onion",
         "port": 19735
      }
   ],
   "binding": [
      {
         "type": "ipv4",
         "address": "172.31.95.0",
         "port": 19735
      }
   ],
   "version": "v0.12.0rc1",
   "blockheight": 2314748,
   "network": "testnet",
   "fees_collected_msat": 0,
   "lightning-dir": "/home/clightning4j/.lightning/testnet",
   "our_features": {
      "init": "088080080269a2",
      "node": "888080080269a2",
      "channel": "",
      "invoice": "02000000024100"
   }
}

Congratulation, you ran your first clightning4j-node in a very tiny virtual machine, and you can start to play with all the cool stuff that core lightning has.

Ah, you have also all your private data on the /cln/data dir so you will be able to move your data to another machine when you finish playing with the docker image.
Conclusion

The docker image is released in sync with core lightning (quite in sync) and the idea is to migrate all the stacks to a more performance one by removing JVM and using more of Rust and Golang. However, the system works quite well also integrates with Kotlin, so it is good to test if this will be just a side project or can be useful for someone.

Support

3BQ8qbn8hLdmBKEjt1Hj1Z6SiDsnjJurfU
liberapay.com/vincenzopalazzo
Github support
buymeacoffee
Lightning donation on vincenzopalazzo@lntxbot.com

In addition, there is also a bolt 12 offer on my website here

Or, simply connect to my ln node to grow my network :)
https://bruce.lnmetrics.info

You can find me on Github Vincenzo Palazzo

This work is sponsored by a Brink grant

Vlang as a scripting language for docker image entry point

Vincenzo Palazzo — Mon, 09 May 2022 05:32:52 +0000

In this small blog post, I will describe how to use the V language (https://vlang.io/) as a scripting language to configure the entry point of your docker configuration.

What is V language?

V language is a Simple language for building maintainable programs and also if a user friendling language with a syntax similar to the Go lang language, but with some additional features like mutability and generics.

In addition, the v standard library contains some methods for writing a shell script in a comfortable when for people that are born in the new era and find the original shell language like bash completely messy.

Docker image entry point

The common usage of docker image is to isolate the environment and make a reproducible environment for an application.

However, there are applications, like command-line applications that required interaction with the docker daemon to share the command with the container and return the result of the container directly to the user.

This type of operation is usually done by a shell script runner by docker each time that the container is invoked. However, if the command line application is complex like Bitcoin Core, or Core lightning the bash script starts to be very complex and full of strange commands to check equality between strings to check what type of operation in the docker image the script needs to run.

In addition, if managing the persistent status of docker the bash script starts to be not manageable, as a not bash friendly person that needs to resolve this complex use case with the docker image, I decided to use the V language as script language, and build a very cool script that resolves my problems.

In fact, the v compiler installed in the docker image is very minimal, and usually doesn't require external dependencies, so the impact is very minimal, and the API to run the os command is very user-friendly.

I build my docker image available at the following link and the pattern used in this case was to build a simple entrypoint.sh file, that looks like the following code

#!/bin/sh
set -e
v run /opt/conf_env.vsh "$@"

Where the conf_env.vsh looks like the following code

// V script to manage the envoirment lightning env
//
// author: https://github.com/vincenzopalazzo
import os

fn run_tor() {
    if os.exists('/home/clightning4j/.tor') {
        os.execute_or_panic('rm -r /home/clightning4j/.tor')
    }
    println(os.execute_or_panic('tor --runasdaemon 1').output)
    curl_res := os.execute_or_panic('curl --socks5 localhost:9050 --socks5-hostname localhost:9050 -s https://check.torproject.org/ | cat | grep -m 1 Congratulations | xargs')
    println(curl_res.output)
    os.execute_or_panic('chown -R clightning4j /home/clightning4j/.tor')
}

fn build_ln_directory() string {
    ln_dir := os.environ()['CLIGHTNING_DATA']
    if !os.exists(ln_dir) {
        os.mkdir(ln_dir) or { panic('dir at path $ln_dir not created') }
        os.execute_or_panic('cp /opt/config $ln_dir/config')
        os.execute_or_panic('mkdir $ln_dir/plugins')
        os.execute_or_panic('cp /opt/*.sh $ln_dir/plugins/')
        os.execute_or_panic('chown -R clightning4j $ln_dir')
    }
    run_tor()
    return ln_dir
}

mut args_str := ''
for idx in 1 .. os.args.len {
    arg := os.args[idx]
    args_str += arg + ' '
}

if args_str.contains('lightning-cli') || !args_str.contains('--') {
    println(os.execute_or_panic(args_str).output)
} else {
    ln_dir := build_ln_directory()
    os.execute_or_panic('lightningd --lightning-dir=$ln_dir $args_str')
}

Closing Thoughts

If you are trying V language in with any other type of use case, please share the information with us, we are super happy to know how you are using the language.

If you have any particular questions, leave a comment and follow me on Github https://github.com/vincenzopalazzo