DEV Community: Stefanos Kouroupis

The importance of building your own tools

Stefanos Kouroupis — Fri, 29 Sep 2023 12:24:39 +0000

Building your own tools for the command-line interface (CLI) is a crucial step any user should take to deepen the understanding of the system they are working on.

In oner part it provides a great path to both knowledge and efficiency.

Knowledge as the foundation for crafting effective Linux tools rotates around exploring the inner workings of the Linux ecosystem. It involves understanding

the core components and commands.
Standard Linux utilities such as grep, awk, sed, cat, ps, cut and their combination.
scripting (i.e. bash)

Efficiency, as it will allow you to automate, simplify and streamline every day tasks.

In my view, everyone should posses a basic understanding of the fundamental of the system their are using including the command line interface. However, even among software engineers, I keep observing a reluctance, I could even call it fear of using the command line interface. They are prisoners of the UI and mouse driver environments. In the rare instance that they have to use the terminal they restrict themselves in copy pasting commands from various sources, without properly understanding them.

I was definitely one of those people 10 years or so ago. But in the mean time I understood how powerful the command line interface is, and how now it feels to be able to do nearly everything in a single interface.

This is my cheap take. =) And because a good article always needs some shameless self promotion. Here is mine.

I recently encountered a use case where I had to navigate between randomly located but highly specific paths on my system. As repeatedly searching through the bash history became cumbersome, I decided to create a tool for seamless navigation. So, I built a small command-line tool to facilitate this process.

But... cd is a part of the shell's core functionality, which means that when you execute cd within a process, it affects the current directory of that specific process. Once you exit the process, your working directory reverts to the state of the shell where you originally started.

So in order to work around that problem, I decided not to. So the command just prints the path in the console. Then with $() I capture the stdout into a local variable, which then allows me when using cd to act upon it.

so my command looks like

cd $(bmk go 1) and that works beautifully! Simple yet effective.

if you are interested in this tiny command line tool, you can find it here . It's written in Rust and since I don't provide binaries, you would need to build it yourself.

enjoy!

Why use Neovim

Stefanos Kouroupis — Thu, 22 Jun 2023 11:01:13 +0000

StackOverflow results are out (2023) and once again #vscode is the most popular editor in the neighbourhood.

But Vim and especially Neovim seem to gain some traction the last years. Especially Neovim jumping from the 16th place in 2022 to the 10th place in the 2023.

What exactly is Neovim though? Neovim is a fork of Vim, which is attempts to streamline contributions and simplify the process of writing extensions.

So why opt in for an editor, which upon launch, greets you with a empty screen that you cannot even write anything without switching to insert mode.

The most obvious reasons are

customisation
fast and lightweight
environment agnostic/portable
vim compatibility

Customisation is hard to describe, best understood through firsthand experience. It bears some high level similarities with the vscode plugin model. Notably there is no central store for publishing plugins, but rather github assumes that role.

All it takes to add a Plugin is configure a Plugin manager (i.e packer, vim-plug, etc) and providing a relative path to a github repository.

Then depending on the plugin, you can either provide options, or even writing custom code to alter it's default behaviour.

Fast and lightweight is easier to describe, Neovim handles jobs in a non blocking manner, which means the main TUI remains unobstructed and responsive.

Environment agnostic/portable - Works in Windows, Linux, Mac without needing a GUI.

Vim compatibility - This is only relevant for people that work in remote linux servers/environments or sometimes containers. vim is always there, and knowing neovim will allow you to efficiently use vim, if you ever require an editor.

Obviously it's not all sunshine and roses.

Customising the look and feel of Neovim takes time, patience and a lot of experimentation
A lot of shortcuts to learn and a lot of shortcuts to customise

For me, experimentation and customisation is an ongoing process, However most neovim users reach a point of satisfaction after a few weeks.

Drawing images on the terminal

Stefanos Kouroupis — Wed, 07 Jun 2023 13:36:50 +0000

Lately, I've been experimenting with stable diffusion, and it has proven to be a captivating experience. However, if you're using a version that lacks a webUI, you're required to repeatedly switch back to a graphical user interface to view the output.

If you have used stable diffusion locally, especially for generating portraits you will know that it produces a lot of images with two heads, or multiple limbs, long necks etc. No matter how good your prompts are if you move away from producing square images of a certain size, it's something you get a lot. So I wanted to be able to quickly inspect the images from the terminal.

If you've worked with stable diffusion on a local setup, particularly for generating portraits, you're likely familiar with the phenomenon of resulting images featuring multiple heads, limbs, elongated necks, and more. Regardless of the quality of the prompts, if you opt out from generating square images of specific dimensions often results in such artifacts. Therefore, I had to find a way to examine the images directly from the terminal.

So, I wrote a small Rust application that converts images into coloured text. The added benefit is that it functions seamlessly in both Windows PowerShell and Linux terminal environments.

https://github.com/elasticrash/image-peek

The underlying logic of the application is relatively straightforward:

Get the dimensions of the image
Get the size of the terminal
Scale down the image so it can fit in our current terminal
Calculate the color of the character in relation to the image.
Print the character

Designing a scheduling service

Stefanos Kouroupis — Thu, 16 Mar 2023 10:20:52 +0000

It's been so long since I have written a technical post, that I feel like I have completely forgotten how to write one. Deep breath and let's start.

Historically in most places I worked for, there was always a need for a scheduling service. These could come into many different flavours:

Embedded into an app
Implemented through a queuing mechanism
Triggering jobs or services
Notifying through a webhook

Some of them can be solved with traditional ways i.e cron jobs, others need a more complex solutions.

For dotnet languages the solution would usually be Hangfire.
For Java was the language of choice that would usually be Quartz.

But when this discussion starts, it is always a heated one with lots of opinions on the how(s) and why(s).

I always found it fascinating, when a certain space has so many opinions. In these cases, I feel the urge to add my opinion to the pool.

This is just a mental exercise, I like to overthink a problem and try to create a solution that makes sense to me.

So I came up with this

Initially, I tried to make the components to run on different threads. Which worked, but something bugged me.

Then I thought, it would be nice, if individual component could scale based on its needs, without the need to redeploy all of them.

So I split everything, on it's own executable. They didn't have to communicate with each other anyway. Every binary has a single specific responsibility. At this stage I am using the database to sort any data race conditions. But the actual datastore shouldn't matter that much, you could use one, or many.

My language of choice is Rust and I have used Postgres as the db engine and SeaORM and Rocket for the main frameworks.

It's definitely a project I want to see through and create something stable, but as typically things that are not used or are intended to be used in production, rarely survive as actual projects. But, they do make excellent references as training material.

This is the repository if anyone is interested. link here

Orchestration in Rust

Stefanos Kouroupis — Sat, 07 Nov 2020 18:59:57 +0000

Porting patterns from Object Oriented concepts in Rust do not always work, but there are certain cases they not only work but sometimes they are easier to follow when compared with the original OOP implementation.

Here I am going to demonstrate the concept of orchestration in Rust.

Taking a step back orchestration resembles vaguely of redux, with the key difference that a reducer has not only has to deal with the state but a payload as well.

Orchestration is basically a pipeline for which the previous state is passed in the next operation. The key thing in orchestration is the ability to pause and resume.

I classify this example as an intermediate one, but not that hard to follow.

We will start by talking about and defining our State object;

#[derive(Debug, Clone)]
pub struct State {
    pub proceed: bool,
    pub outcome: f32,
    pub stage: Vec<bool>,
}

Our state has the following

proceed: which marks each stage as successful or not, marking proceed as false, that will stop the execution of the remaining stages
outcome: result of each stage
stage: record the outcome of the stage

Then we will define the Orchestrate trait

trait Orchestrate {
    fn execute(self, state: State) -> State;
}

and we will implement the Orchestrate trait on a Vector of Functions

impl Orchestrate for Vec<fn(State) -> Result<State, Error>> {
     fn execute(self, state: State) -> State {
        self.iter().enumerate().fold(state, |output, (i, func)| {
            let new_state = output.clone();
            if new_state.stage.len() > i {
                if new_state.stage[i] {
                    return new_state;
                } else {
                    let mut next_state = func(new_state).unwrap();
                    next_state.stage[i] = next_state.proceed;
                    return next_state;
                }
            }
            let mut next_state = func(new_state).unwrap();
            next_state.stage.push(next_state.proceed);
            return next_state;
        })
    }
}

It's already easy to see where this is going.

we received the array of functions
for each execution we check if the operation has been completed in a previous execution (stage)
we either execute the stage or ignore it

Next we will define 3 simple operations we want to perform in this orchestration. How are they going to be used, one would wonder.

fn pow2(n: f32) -> f32 {
    n.powf(2.0)
}

fn pow3(n: f32) -> f32 {
    n.powf(3.0)
}

fn sqrt(n: f32) -> f32 {
    n.sqrt()
}

And now my favourite part, instead of just creating a function that gets a State and returns a state and has the pause resume logic in it I am going to create a macro that creates the functions by accepting a function as an argument.

macro_rules! state_function {
    ( $func:expr ) => {{
        pub fn state_fn(c: State) -> Result<State, Error> {
            let stage: Vec<bool> = c.stage.to_vec();
            if c.proceed == false {
                Ok(State {
                    proceed: false,
                    outcome: c.outcome,
                    stage: stage,
                })
            } else {
                let mut rng = rand::thread_rng();
                let y: bool = rng.gen();
                Ok(State {
                    proceed: y,
                    outcome: $func(c.outcome),
                    stage: stage,
                })
            }
        }

        state_fn
    }};
}

If proceed is false, don't do anything
else return the state with the new outcome.

And to spice things a bit up I used a random boolean, to disrupt the processing and make things a bit more interesting.

So finally on our main function,
Step 1: we create our functions

    let a: fn(State) -> Result<State, Error> = state_function!(pow2);
    let b: fn(State) -> Result<State, Error> = state_function!(pow3);
    let c: fn(State) -> Result<State, Error> = state_function!(sqrt);

Step 2: we define our chain

    let chain: Vec<fn(State) -> Result<State, Error>> =  vec![a, b, c];

Step 3: we execute our chain

    let result = chain
        .execute(State {
            proceed: true,
            outcome: 6.,
            stage: Vec::<bool>::new(),
        });

    println!("{:?}", result);

BONUS
Step 4: we execute our chain with assuming some steps have been completed

    let result = chain
        .execute(State {
            proceed: true,
            outcome: 6.,
            stage: vec![true, false, false],
        });

    println!("{:?}", result);

I hope you enjoyed it... :D

Update: a generic version of this pattern can be found here https://github.com/elasticrash/orchestrator

Drawing tables in console using Rust

Stefanos Kouroupis — Fri, 17 Apr 2020 22:59:43 +0000

I keep finding myself, coming back and thinking...Rust is not that popular, not that many people are using/reading about Rust.

Maybe I should write something about Javascript. At the end of the day I owe Javascript 80% of my traffic (over 15k view) while Rust ...has around 300 views. One could argue that I haven't written much about Rust or that my articles/examples (I am not kidding myself most things I write are kind of examples/tutorials...maybe) are a bit pointless.

And that's the thing. In my free time I don't feel like being productive. I love pointless stupid things. Like this one.

I created a small app....which takes absolutely no advantage whatsoever of any feature that rust has to offer. But I am having fun.

And this app..🥁..draws tables in a console using utf characters 😞. This article though is less than an example but rather a journey down the memory lane.

So you get this nice output

You could think of those projects as an 1 hour challenge. And I do try to do things as much as properly as my patience allows me, outside work.

Our glorious imports. I am only using a single external dependency in this project and the reason why, is simple. Rust has no build in functionality to return the width and height of the console (in characters). If someone prefers not to use an external dependency, they have to write that functionality in C and wrap it up for Rust.

extern crate term_size;
use std::io::{self};
use std::process::exit;
use std::str::{self};

One of the reasons I did this exercise was partly sentimental. I grew up in late 80s/early 90s and I remember my mother writing documents using a computer. She was using a software called Volkswriter which was a document editor which bears no resemblance to modern document editors (like Word). It was, and still is, in my mind the vim or document editors.

So quite frequently my mum had to draft a table. The way you "insert" a table was by using characters. So basically you had to "type" a table. Modifying a table was a pain in the $%^&!

Here is the list of characters that were quite popular back then (along with double line variations.

fn main() {
    let characters: Vec<&str> = vec![
        "━", "┏", "┓", "┗", "┛", "┃", " ", "┠", "┨", "┯", "┷", "│", "─", "┼",
    ];

Being 12 at the time, I tried to automate the process using BASIC and failed miserably and then went back to keep playing golden axe. So now ~30 years later I came back and finished the unfinished job.

The app takes a pair of numbers as an input (no of cells to divide horizontally and vertically) and types the desired table to fit all the available console.

    match term_size::dimensions() {
        Some((w, h)) => {
            println!("divide horizontally (max value {})", w / 4);
            let hor_div = get_value();
            if hor_div > ((w as u32) / 4) {
                println!("invalid range, terminating application");
                exit(0);
            }

            println!("divide vertically (max value {})", h / 4);
            let vert_div = get_value();
            if vert_div > ((h as u32) / 4) {
                println!("invalid range, terminating application");
                exit(0);
            }
            let every = h as u32/vert_div;

            for j in 0..h {
                if j == 0 {
                    output(
                        characters[1],
                        characters[0],
                        characters[2],
                        w,
                        characters[9],
                        hor_div,
                    );
                } else if j == h - 1 {
                    output(
                        characters[3],
                        characters[0],
                        characters[4],
                        w,
                        characters[10],
                        hor_div,
                    );
                } else {
                    if j as u32 % every != 0 {
                        output(
                            characters[5],
                            characters[6],
                            characters[5],
                            w,
                            characters[11],
                            hor_div,
                        );
                    } else {
                        output(
                            characters[7],
                            characters[12],
                            characters[8],
                            w,
                            characters[13],
                            hor_div,
                        );
                    }
                }
            }
        }
        _ => {}
    }
}

pub fn output(a: &str, b: &str, c: &str, w: usize, d: &str, div: u32) {
    print!("{}", a);
    let every = w as u32/div;
    for _i in 1..w {
        if _i as u32 % every == 0 {
            print!("{}", d);
        } else {
            print!("{}", b);
        }
    }
    print!("{}", c);
}

pub fn get_value() -> u32 {
    let mut dim = String::new();
    match io::stdin().read_line(&mut dim) {
        Err(why) => panic!("couldn't read {:?}", why.raw_os_error()),
        _ => (),
    };

    let value = match dim.trim().parse::<u32>() {
        Ok(v) => v,
        Err(why) => panic!("Invalid input ...exiting due to {:?}", why),
    };

    return value;
}

Displaying all printable* utf-8 characters using Rust

Stefanos Kouroupis — Thu, 16 Apr 2020 00:54:47 +0000

Since I got my first year badge I decided to celebrate by listing my achievements and writing one of the most useless applications I've ever written.

achievements

> 20.000 views...pretty neat! nearly 60 per day
> 2500 followers ...again nice! that's nearly 7 per day
2.5 years on the same job.

application

This amazing application as the title states prints all utf8 characters that can be printed. The star on the title is that I limited the output to the first 3 bytes.

ENJOY

Our main function has 3 loops

one for the single byte chars 0000 - 007F
one for the two byte chars 00C0 - 00DF | 0080 - 00BF
one for the three byte chars 00E0 - 00EF | 0080 - 00BF | 0080 - 00BF

use std::num::ParseIntError;
use std::str;

fn main() {
    let mut char_index = 0;
    let one_byte = vec![0, 127];

    for i in one_byte[0]..one_byte[1] {
        let mut first = format!("{:X}", i);
        first = make_even(first);
        char_index = output(first, char_index);
    }

    let two_bytes = vec![192, 223, 64, 191];

    for i in two_bytes[0]..two_bytes[1] {
        for j in two_bytes[2]..two_bytes[3] {
            let mut first = format!("{:X}", i);
            let mut second = format!("{:X}", j);

            first = make_even(first);
            second = make_even(second);

            char_index = output(first.to_string() + &second.to_string(), char_index);
        }
    }

    let three_bytes = vec![224, 239, 64, 191, 64, 191];

    for i in three_bytes[0]..three_bytes[1] {
        for j in three_bytes[2]..three_bytes[3] {
            for k in three_bytes[4]..three_bytes[5] {
                let mut first = format!("{:X}", i);
                let mut second = format!("{:X}", j);
                let mut third = format!("{:X}", k);

                first = make_even(first);
                second = make_even(second);
                third = make_even(third);

                char_index = output(
                    first.to_string() + &second.to_string() + &third.to_string(),
                    char_index,
                );
            }
        }
    }
}

Hex string needs an even amount of characters

pub fn make_even(mut s: String) -> String {
    if s.len() % 2 == 1 {
        s = "0".to_string() + &s.to_string();
    }
    return s;
}

I got this function from here. What it basically does is, it converts a hex string to a u8 array.

pub fn decode_hex(s: &str) -> Result<Vec<u8>, ParseIntError> {
    (0..s.len())
        .step_by(2)
        .map(|i| u8::from_str_radix(&s[i..i + 2], 16))
        .collect()
}

Nested matches for the win. Checks :

if the hex string is valid
if the character is valid in utf-8
if the character has a printable representation (by looking the printed output length)

pub fn output(hex: String, mut i: i32) -> i32 {
    match &decode_hex(&hex) {
        Ok(dh) => match str::from_utf8(dh) {
            Ok(v) => {
                if format!("{:?}", v).len() < 7 {
                    if i % 10 == 0 {
                        println!("{:?} {:?} \t", hex, v);
                    } else {
                        print!("{:?} {:?} \t", hex, v);
                    }
                    i += 1;
                }
            }
            _ => {}
        },
        _ => {}
    }

    return i;
}

Passive monitoring, in a .net core worker service using Nagios NRDP protocol

Stefanos Kouroupis — Mon, 27 Jan 2020 23:28:23 +0000

Nagios for those not aware is an infrastructure monitoring system. In Nagios you can have two types of checks

Active (run a scheduled script to figure out the problem)
Passive (have the service report back to nagios in a scheduled manner)

When you have a big infrastructure you can use Nagios to monitor things like disc spaces/ temperatures/ dbs etc, but you can also use it to monitor applications. Especially if you have a microservice architecture and you have to monitor hundreds of different services it is convenient to have checks and alerts.

So for example

if you want to monitor the health of an API, you could write an active check that performs certain requests and compare the results with an expected outcome
if you want to monitor a consumer service, you could write an active check that sends a message and if possible examine its impact. But what if there is no visible impact?
if you have a worker service...its a closed system and monitoring from the outside system is nearly impossible.

And thus for point 3 and sometimes for point 2 we need to write a passive check. Which is a check within the worker/consumer services.

Nagios supports two different ways to do passive checks

Nsca (Nagios Service Check Adapter)
Nrdp (Nagios Remote Data Processor)

Nsca needs the messages to be encrypted, where Nrdp is a simple http request with either JSON or XML as a payload (and a secret key).

Here is a basic implementation of Nrdp using JSON.

The model that needs to be posted looks like:

  public class NrdpJsonMessage
    {
        [JsonProperty("checkresults")]
        public List<JsonRecord> Records { get; set; }
    }

    public class JsonRecord
    {
        [JsonProperty("checkresult")]
        public JsonCheckResult CheckResult { get; set; }
        [JsonProperty("hostname")]
        public string HostName { get; set; }
        [JsonProperty("servicename")]
        public string ServiceName { get; set; }
        [JsonProperty("state")]
        public string State { get; set; }
        [JsonProperty("output")]
        public string Output { get; set; }
    }

    public class JsonCheckResult
    {
        [JsonProperty("type")]
        public string Type { get; set; }
        [JsonProperty("checktype")]
        public string CheckType { get; set; }
    }

The class responsible for sending the passive check to nagios

public class Monitor
    {
        private readonly Configuration _configuration =
        new Configuration();

        public Monitor()
        {
        }

        public async Task<bool> SendPassiveCheck(NagiosWarningLevel level,
            string hostName, string serviceName, string message)
        {
            KeyValuePair<string, string> monitorObject;

            var nrdpMessage =
                new NrdpJsonMessage()
                {
                    Records = new List<JsonRecord>()
                    {
                        new JsonRecord()
                        {
                            CheckResult = new JsonCheckResult()
                            {
                                Type = "service",
                                CheckType = "1"
                            },
                            HostName = hostName,
                            ServiceName = serviceName,
                            State = Convert.ToString((int) level),
                            Output = message + " | perfdata=1;"
                        }
                    }
                };

            monitorObject = new KeyValuePair<string, string>("JSONDATA",
                JsonHelper.Serialize(nrdpMessage));

            var postDataObject = new FormUrlEncodedContent(new KeyValuePair<string, string>[]
            {
                new KeyValuePair<string, string>("cmd", "submitcheck"),
                new KeyValuePair<string, string>("token", _configuration.ProcessorPassword),
                monitorObject,
            });

            var data = await postDataObject.ReadAsStringAsync();

            var response = await _someTypeOfHttpRequestClass.Post(
                $ "{_configuration.Protocol}://{_configuration.Address}:{_configuration.Port}/nrdp/",
            null, data, null,
            "application/x-www-form-urlencoded");
            return true;
        }
    }

One of the things, that you need to be aware when implementing this. Is that, if you send any message, valid or invalid to the nrdp endpoint, you will get a 200 back regardless, with a small description that either denote success, or what went wrong.

so as it is obvious the only thing you need to do with just to send a message.

_monitor?.SendPassiveCheck(NagiosWarningLevel.Critical,
                           _nagiosConfiguration.HostName,
                           _nagiosConfiguration.ServiceName,
                           ex.Message);

by selecting one of the warning levels

public enum NagiosWarningLevel
    {
        OK,
        Warning,
        Critical,
        Unknown
    }

But the only thing you managed to achieve so far is send one message to nagios. Which is not an achievement of great importance.

What you need is periodic messages, and recoverability. So when something goes wrong, nagios can alert you, that something is wrong, or a service managed to recover.

    public class PassiveMonitor : IDisposable
    {
        private readonly Monitor _monitor;
        private readonly Configuration _configuration = new Configuration ();
        private Timer _timer;

        public NagiosWarningLevel NagiosWarningLevel { private get; set; }
        public string Message { private get; set; }

        public PassiveMonitor(Monitor monitor)
        {
            _monitor = monitor;
            NagiosWarningLevel = NagiosWarningLevel.OK;
            Message =
                $"HeartBeat at {DateTime.UtcNow.ToString(CultureInfo.InvariantCulture)}";
        }

        private void OnTimedEvent(object source, ElapsedEventArgs e)
        {
            // ... do checks here and set the NagiosWarningLevel and Message
            _monitor.SendPassiveCheck(NagiosWarningLevel,
                                      _configuration.HostName,
                                      _configuration.ServiceName,
                                      Message).Wait();
        }

        public void SetTimer()
        {
            CreateTimer();
        }

        public void PauseTimer()
        {
            if (_timer == null) return;
            _timer.Enabled = false;
        }

        public void ResumeTimer()
        {
            if (_timer == null) return;
            _timer.Enabled = true;
        }

        private void CreateTimer()
        {
            if (_timer != null) return;

            // Create a timer with a X minute interval.
            _timer = new Timer(_configuration.RepeatTestEveryXMinutes * 60000);
            // Hook up the Elapsed event for the timer. 
            _timer.Elapsed += OnTimedEvent;
            _timer.AutoReset = true;
            _timer.Enabled = true;
        }

        public void Dispose()
        {
            _timer?.Dispose();
        }
    }

Happy Monitoring

Chain of responsibility pattern

Stefanos Kouroupis — Tue, 21 Jan 2020 00:10:36 +0000

This article is a couple of thoughts around specific patterns and specifically the chain of responsibility pattern. As the title obviously states. I think some basic knowledge around certain patterns is required.

In a way it's a bit of a philosophical article.

If you look up what is the recipe for making a chain of responsibility, the most common one, include the following ingredients (if you don't mind my cooking references) :

Decouples receiver and handler
Passes the request along a chain of objects

The key idea behind this pattern is to give the opportunity to more than one object to handle a specific request.

Personally I believe, that these attributes are incomplete when describing this pattern, and they are a few rogue attributes that mutate this pattern to a certain degree, those are among others:

define a chain in the Handler
define the chain in the Concrete Handler
the order of the chain does not affect the outcome
it is acceptable in some cases to let a single object to be handled by more than one object

The last one is a hazy line between the chain of responsibility and visitor pattern.

and if you suddenly add state to each operation in the chain then you start throwing mud at the water and make the line between chain of responsibility and memento (or even orchestration) patterns even more indistinguible.

State is the key here. Chain of responsibility does not have a state whereas memento and orchestration do.

Slow RabbitMq Producer (load tests)

Stefanos Kouroupis — Wed, 18 Dec 2019 08:55:32 +0000

This article, is nothing more, than a silly way of how to push random rabbitMq messages in a controlled (lol) way in an exchange. Really Useful to simulate a load test.

From this point I am going to refer to RabbitMq, as just rabbit 🐇 and I am going to use a large number of emoji....just because.

Step 1 import all the necessary libraries 📚, which are basically the following two-ish.

amqplib - rabbit library and client
fs - aka filesystem

import * as amqp from 'amqplib';
import * as fs from 'fs';

Step 2 declare all our configurable values;

const DATA_LENGTH = 100;
const EXCHANGE = "MyExchange";
const ROUTING_KEY = "MyRoutingKey";
const MESSAGE_TYPE = "MyMessageType";
const RABBIT_USERNAME = "MyUsername";
const RABBIT_PASSWORD = "MyPassword";
const RABBIT_HOSTNAME = "localhost";
const RABBIT_PORT = "5672";
const RABBIT_VIRTUAL_HOST= "/";
const DELAY_BETWEEN_MESSAGES= "80";

Step 3 define a model with some initial values (any other way, is way more complicated for such simple example)

class UserModel {
    userId: number = 1;
    fistName: string = "";
    lastName: string = "";
}

Step 4 write a function that gives random values to our model


function generateRandomValue(value: any): any {
    if (typeof (value) == "string") {
        return Math.random().toString(36).substring(7);
    }
    if (typeof (value) == "number") {
        return Math.random();
    }
}

Step 5 (optional) log to a file 🗄️, if you really care about any errors. Logging to console would also work fine, except, sometimes on load tests, you could send million of messages, which could make logging to console a bit of a fuss, 🥁 soooooo I would say we need one.

function log2file(obj: any) {
    fs.appendFile(`./log.txt`, `${JSON.stringify(obj)} 
    `, (err) => {
        if (err) {
            console.log("undefined error");
        }
    });
}

Step 6 send Random object(🥕) to rabbit

function send2Rabbit(channel: any) {
    // GENERATE RANDOM MESSAGE
    const user: any = new UserModel();
    for (var prop in user) {
        if (Object.prototype.hasOwnProperty.call(user, prop)) {
            user[prop] = generateRandomValue((user[prop]) as unknown as any);
        }
    }

    const content = new Buffer(JSON.stringify(user));

    if (channel) {
        try {
            channel.publish(EXCHANGE, ROUTING_KEY, content, {
                type: MESSAGE_TYPE
            });

        } catch (error) {
            log2file(error);
        }
    }
}

Step 7 push the power on 🔌 and see the world 🌍 crumble 💥 before your eyes 👀

// IIFE
(async () => {
    try {
        const rabbitConnection = await amqp.connect({
            protocol: 'amqp',
            hostname: RABBIT_HOSTNAME,
            port: RABBIT_PORT,
            username: RABBIT_USERNAME,
            password: RABBIT_PASSWORD,
            vhost: RABBIT_VIRTUAL_HOST,
        });
        const rabbitChannel = await rabbitConnection.createChannel();

        for (let index = 0; index < DATA_LENGTH; index++) {
            send2Rabbit(rabbitChannel)
            await threadSleep(DELAY_BETWEEN_MESSAGES);
        }

    } catch (error) {
        log2file(error);
    }
})();

Step 8 bonus (sleep function 💤)

function threadSleep(ms: any) {
    return new Promise((resolve) => setTimeout(resolve, ms));
}

Angular: Using custom made SVG icons through Angular Material

Stefanos Kouroupis — Tue, 22 Oct 2019 22:44:33 +0000

This is a tiny, but useful post that will demonstrate how to create a service that registers custom svg icons in order to use them through the mat-icon component.

Step 1. I place all my icons under assets/svg/icons
Step 2. I create an string enum with all the icon names i.e. (you could just have a string array but I like the idea of using an enum)

export enum Icons {
    Close = 'close',
    Done = 'done',
    Edit = 'edit'
}

Step 3. I create my service. Which simply iterates all values in my string enum and registers them again the MatIconRegistry. bypassSecurityTrustResourceUrl simply bypass the security checks and trusts the svg file (make sure the svgs are to be trusted).

@Injectable({
  providedIn: 'root'
})
export class IconService {

  constructor(
    private matIconRegistry: MatIconRegistry,
    private domSanitizer: DomSanitizer
  ) { }

  public registerIcons(): void {
    this.loadIcons(Object.values(Icons), '../assets/svg/icons');
  }

  private loadIcons(iconKeys: string[], iconUrl: string): void {
    iconKeys.forEach(key => {
      this.matIconRegistry.addSvgIcon(key, this.domSanitizer.bypassSecurityTrustResourceUrl(`${iconUrl}/${key}.svg`));
    });
  }
}

Step 4. Then simply on the app.component.ts ngOnInit call the registerIcons function

  constructor(private iconService: IconService) {
  }

  ngOnInit() {
    this.iconService.registerIcons();
  }

Step 5. Use them anywhere in the application

    <mat-icon svgIcon="edit"></mat-icon>

Operator Overloading in Rust

Stefanos Kouroupis — Fri, 11 Oct 2019 22:21:43 +0000

This is my first post about Rust, So I'm going to keep it simple and at the same time a bit unrealistic, just to prove some points. ;-)

This article, as the title already revealed, is all about operator overloading. Specifically we will implement the following 4 traits.

PartialEq
PartialOrd
Add
Not

Our example, as other similar tutorials will be based upon a little bit of Geometry, specifically Points and Lines.

so we need to use the following

use std::cmp::Ordering;
use std::ops::Add;
use std::ops::Not;

a Point will be a pair of cartesian coordinates (x,y)

#[derive(Copy, Clone)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}

a Line will be a pair of Points

#[derive(Copy, Clone)]
pub struct Line {
    pub start: Point,
    pub end: Point,
}

The Point trait will just have a constructor

pub trait PointProperties {
    fn new(x: f32, y: f32) -> Self;
}

impl PointProperties for Point {
    fn new(x: f32, y: f32) -> Self {
        return Self { x: x, y: y };
    }
}

The Line trait will have a constructor and a function that calculates the length of the Line. The length is calculated with the distance formula ( √(b.x-a.x)^2 + (b.y-a.y)^2 ) that (I assume) we all know from school.


pub trait LineProperties {
    fn length(&self) -> f32;
    fn new(a: Point, b: Point) -> Self;
}

impl LineProperties for Line {
    fn length(&self) -> f32 {
        return ((&self.end.x - &self.start.x).powf(2.0) + (&self.end.y - &self.start.y).powf(2.0))
            .sqrt();
    }
    fn new(a: Point, b: Point) -> Self {
        return Self { start: a, end: b };
    }
}

First we will implement the equality. What is equality between two lines? In this case I am choosing to consider equal two lines that have the same length, regardless where they lie in our cartesian plane.

impl PartialEq for Line {
    fn eq(&self, other: &Self) -> bool {
        return &self.length() == &other.length();
    }
}

Then we have the less than and greater than symbols. Again how can we compare two lines? Again I am choosing to compare the lengths of two lines, again regardless where they line in our cartesian plane

impl PartialOrd for Line {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        self.length().partial_cmp(&other.length())
    }
}

Finally we down to the more unrealistic but handy nevertheless examples.

The not operator (!). In this case when applying the not operator in a line, flips the line along the y axis. This is achieved by simply reversing the signs of all cartesian coordinates that make up our line.

impl Not for Line {
    type Output = Line;
    fn not(mut self) -> Line {
        self.start.x = -self.start.x;
        self.start.y = -self.start.y;
        self.end.x = -self.end.x;
        self.end.y = -self.end.y;

        return self;
    }
}

Finally I implement the add operator (+). Again adding two lines doesn't make much sense, so what I am doing with the add operator is that I take the min_x, min_y and max_x, max_y for each pair of coordinates (start vs end)

impl Add for Line {
    type Output = Line;
    fn add(self, other: Self) -> Line {
        let min_start_x: f32;
        if &self.start.x > &other.start.x {
            min_start_x = other.start.x;
        } else {
            min_start_x = self.start.x;
        }

        let min_start_y: f32;
        if &self.start.x > &other.start.x {
            min_start_y = other.start.y;
        } else {
            min_start_y = self.start.y;
        }

        let max_end_x: f32;
        if &self.start.x < &other.start.x {
            max_end_x = other.start.x;
        } else {
            max_end_x = self.start.x;
        }

        let max_end_y: f32;
        if &self.start.x < &other.start.x {
            max_end_y = other.start.y;
        } else {
            max_end_y = self.start.y;
        }

        let p_a = Point::new(min_start_x, min_start_y);
        let p_b = Point::new(max_end_x, max_end_y);

        return Line::new(p_a, p_b);
    }
}

and too prove that everything is working this is our main function

fn main() {
    println!("Points & Lines");
    let point_a: Point = Point::new(0.0, 0.0);
    let point_b: Point = Point::new(0.0, 10.0);
    let line_a: Line = Line::new(point_a, point_b);

    println!("line a has a length of {:?}", line_a.length());

    let point_c: Point = Point::new(10.0, 10.0);
    let point_d: Point = Point::new(10.0, 20.0);
    let line_b: Line = Line::new(point_c, point_d);

    println!("line b has a length of  {:?}", line_b.length());
    println!("are line a and b lengths equal? {:?}", line_a == line_b);
    println!(
        "is the mirror line's a length equal to line b {:?}",
        !line_a == line_b
    );

    let line_c: Line = Line::new(point_a, point_d);
    let line_d: Line = Line::new(point_b, point_c);

    println!("line c has a length of {:?}", line_c.length());
    println!("line d has a length of {:?}", line_d.length());
    println!("is line c smaller than line b? {:?}", line_c < line_b);

    println!(
        "adding up lines give you a length of {:?}",
        (line_c + line_b).length()
    );
}

and our output

Points & Lines
line a has a length of 10.0
line b has a length of  10.0
are line a and b lengths equal? true
is the mirror line's a length equal to line b true
line c has a length of 22.36068
line d has a length of 10.0
is line c smaller than line b? false
adding up lines give you a length of 14.142136

I hope someone, out there, to find this piece useful. I certainly enjoyed writing it.