DEV Community: Max

MariaDB Dump Bash-Script

Max — Mon, 20 May 2024 14:31:07 +0000

I published a my utility script for backing up a mariadb to GitHub:
https://gist.github.com/MaaxGr/b0ed9675a9d581518543bd70a6b514ac

It has the following features:

Help with list of all available databases
Standardized output directory: /root/backups/mariadb
Standardized file name with datetime and db name
Progressbar
Success-Message with filename, size and first 10 rows of dumpfile

Debian/LVM increase disk size cheatsheet

Max — Sun, 28 Jan 2024 20:22:14 +0000

Just a quick cheatsheet for increasing disk sizes for my TrueNAS scale VMs with debian os and lvm.

Make sure you created a snapshot!
Stop VM
Increase ZVOL
Start VM
lsblk => Check new size of /dev/sda
fdisk /dev/sda
1. p (print)
2. Copy partition row
3. d (delete)
4. n (new) -
5. KEEP lvm signature!
6. t (change type) => 30 for Linux LVM
7. p (print again)
8. Compare row (startbytes, size, type) with row from above
9. w (write changes)
Reboot VM
pvresize /dev/sdaX (Replace X with actual number)
pvs => Check
lvs => Get VG and LV
lvresize -l +100%FREE /dev/<VG>/<LV>
resize2fs /dev/<VG>/<LV>
Reboot VM

Python Script to check if all docker containers are running

Max — Sun, 30 Jul 2023 19:13:28 +0000

I created a small python script that checks if all docker containers are running.

Backup all container names into a file: docker ps --format "{{.Names}}" > /root/containers.txt
Create a script that checks if all containers are running: vim /root/check.py (Content see below)
Do stuff that might impact container uptime
Run the script: python3 /root/check.py
See if every container are still running

=> Offline-Containers are highlighted in red.

Script Content:

#!/usr/bin/python3

import subprocess

class bcolors:
    HEADER = '\033[95m'
    OKBLUE = '\033[94m'
    OKCYAN = '\033[96m'
    OKGREEN = '\033[92m'
    WARNING = '\033[93m'
    FAIL = '\033[91m'
    ENDC = '\033[0m'
    BOLD = '\033[1m'
    UNDERLINE = '\033[4m'


f = open("/root/containers.txt", "r")
containers = f.read().splitlines()

docker_ps_output = str(subprocess.check_output('docker ps', shell=True))

for container in containers:
    if docker_ps_output.find(container) != -1:
       print(f"{bcolors.OKGREEN}Container found {container}{bcolors.ENDC}")
    else:
       print(f"{bcolors.FAIL}Container not found {container}{bcolors.ENDC}")

Improve code readability when taking pictures in android development

Max — Wed, 19 Jul 2023 15:52:31 +0000

Here is an extension function that wraps the code of taking pictures into shorter and better readable code:

fun ComponentActivity.registerForTakePicture(
    callback: (Result<Unit>) -> Unit
): ActivityResultLauncher<Uri> {
    return registerForActivityResult(
        ActivityResultContracts.TakePicture()
    ) { success ->
        if (success) {
            callback(Result.success(Unit))
        } else {
            callback(
                Result.failure(
                    Throwable(
                        "Didn't save a picture. " +
                                "ACTION_IMAGE_CAPTURE-Activity cancel?"
                    )
                )
            )
        }
    }
}

=> Watch out: A failure will be also returned if the user presses the abort-button in the Take Image Screen intentionally. Unfortunately we can't differ if the user aborts intentionally or if there was an error recording the image.

But there is another bad code design in the default android api. The trigger point of launching the take-photo activity and the result handler are very separate although they logically belong to each other in my opinion:

See this article: https://medium.com/codex/how-to-use-the-android-activity-result-api-for-selecting-and-taking-images-5dbcc3e6324b

This forces the developer to create a global variable (either as an activity member field or in the ViewModel/State) that has to be nullable or lateinit.

What if we can create a better api?

Singleton that solves the problem

class TakePictureContract {

    private val logger by provideLogger(this::class.java.simpleName)

    private var activityResultLauncher: ActivityResultLauncher<Uri>? = null
    private var targetUri: Uri? = null
    private var continuation: Continuation<Boolean>? = null

    fun registerForActivity(activity: ComponentActivity) {
        activityResultLauncher = activity.registerForTakePicture { result ->
            result
                .onSuccess {
                    val uri = targetUri
                        ?: throw IllegalStateException(
                            "targetUri is null"
                        )

                    continuation?.resume(true)

                    this.continuation = null
                    this.targetUri = null
                }
                .onFailure {
                    logger.d(it.message.toString())
                    continuation?.resume(false)

                    this.continuation = null
                    this.targetUri = null
                }
        }

    }

    suspend fun run(targetUri: Uri) = suspendCoroutine {
        if (this.continuation != null) {
            throw IllegalStateException(
                "TakePictureContract is already running"
            )
        }
        this.targetUri = targetUri
        this.continuation = it
        activityResultLauncher?.launch(targetUri)
    }

}

Usage from ViewModel

fun newImage(fileUri: Uri) {
    viewModelScope.launchIO {
        try {
            _state.update { it.copy(isLoading = true) }

            val result = takePictureContract.run(fileUri)
            if (result) {
                addTakenImage(fileUri)
            }
        } finally {
            _state.update { it.copy(isLoading = false) }
        }
    }
}

Register Activity in onCreate

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    takePictureContract.registerForActivity(this)
}

Some additional notes

The Instance of TakePictureContract has to be the same in Activity and ViewModel. I solved this via Koin Dependency Injection. An easy alternative to DI would be to use kotlin object TakePictureContract instead of class.
DI for TakePictureContract also allows mocking the wanted behaviour for unit tests
It is okay to use a singleton in my opinion because there can only be one camera activity active at a single time.

Let me know that you think about the class in the comments!

Regards
Max

MySql: Compact sensor data to minute averages

Max — Sun, 02 Jul 2023 11:27:26 +0000

Our home battery measures different sensor data, such as:

Current energy consumption in watts
Current energy production (by photovoltaic) in watts
Amount of watts that was fed into the grid

I collect this data every second via a python script and insert it into a mysql table. Because that data sums up over the years (Multiple Gigabytes!), i wanted to compress the data to minute averages for the old data.

Table schema

Sensor Table:

create table status_sensor
(
    # timestamp with second precision
    measured_at timestamp   not null,
    # e.g. PRODUCTION for PV-Energy produced in that second
    type        varchar(30) not null,
    # numeric value in watts
    measurement int         not null,
    primary key (measured_at, type)
);

Table for compressed data:

create table status_compressed
(
    # timestamp with minute precision
    measured_at timestamp   not null,
    # e.g. PRODUCTION for PV-Energy produced in that second
    type        varchar(30) not null,
    # Average watt value in that minute
    measurement int         not null,
    primary key (measured_at, type)
);

Compact Algorithm

Compact can be performed directly via sql. No programming necessary.

High-Level Steps:

Get entries grouped by type and measured_at minute from the table status_sensor for a specific year.
Insert them to the status_compressed table
Delete the sensor entries from status_sensor for that specific year

SQLs:

1+2:

INSERT INTO status_compressed (measured_at, type, measurement)
SELECT SUBSTRING_INDEX(entry, '/', 1)  AS date,
       SUBSTRING_INDEX(entry, '/', -1) AS type,
       average
FROM (SELECT CONCAT(DATE_FORMAT(measured_at, '%Y-%m-%d %H:%i'), '/', type) entry, avg(measurement) average
      FROM status_sensor
      WHERE measured_at LIKE '2020%'
      GROUP BY CONCAT(DATE_FORMAT(measured_at, '%Y-%m-%d %H:%i'), '/', type)) sub

DELETE FROM status_sensor WHERE measured_at LIKE '2020%';

Jetpack Compose Grid without Lazy

Max — Sat, 14 Jan 2023 19:19:54 +0000

Introduction

For most grid situations we could use LazyVerticalGrid. But not if you want to add the grid to a scrollable column with multiple scrollable elements.

My custom grid-component fixes this exception:
Nesting scrollable in the same direction layouts like LazyColumn and Column(Modifier.verticalScroll()) is not allowed.

Example

Usage

=> The number of columns can be passed via columns-property.

Column(
    modifier = Modifier
        .fillMaxWidth()
) {
    Text(
        text = "Features",
        style = MaterialTheme.typography.h1,
        modifier = Modifier.padding(15.dp)
    )

    NonlazyGrid(
        columns = 3,
        itemCount = features.size,
        modifier = Modifier
            .padding(start = 7.5.dp, end = 7.5.dp)
    ) {
        FeatureItem(features[it])
    }
}

Implementation

@Composable
fun NonlazyGrid(
    columns: Int,
    itemCount: Int,
    modifier: Modifier = Modifier,
    content: @Composable() (Int) -> Unit
) {
    Column(modifier = modifier) {
        var rows = (itemCount / columns)
        if (itemCount.mod(columns) > 0) {
            rows += 1
        }

        for (rowId in 0 until rows) {
            val firstIndex = rowId * columns

            Row {
                for (columnId in 0 until columns) {
                    val index = firstIndex + columnId
                    Box(
                        modifier = Modifier
                            .fillMaxWidth()
                            .weight(1f)
                    ) {
                        if (index < itemCount) {
                            content(index)
                        }
                    }
                }
            }
        }
    }
}

Better "docker ps" for small monitors

Max — Sun, 04 Dec 2022 12:13:04 +0000

The output of "docker ps" often becomes really confusing on small screens (1080p or smaller).

So i created a wrapper python script that solves that problem.

Before

After

Script

/root/bin/docker-ps:

#!/usr/bin/python3

import os
import subprocess
import json

class bcolors:
    HEADER = '\033[95m'
    OKBLUE = '\033[94m'
    OKDARKGRAY = '\033[90m'
    OKCYAN = '\033[96m'
    OKGREEN = '\033[92m'
    WARNING = '\033[93m'
    FAIL = '\033[91m'
    ENDC = '\033[0m'
    BOLD = '\033[1m'
    UNDERLINE = '\033[4m'


command = "docker ps --format '{\"ID\":\"{{ .ID }}\", \"Image\": \"{{ .Image }}\", \"Names\":\"{{ .Names }}\", \"Status\":\"{{ .Status }}\", \"CreatedAt\":\"{{ .CreatedAt }}\", \"Ports\":\"{{ .Ports }}\"}'"

output = subprocess.check_output(command, shell=True).splitlines()
print("")

for entry in output:
    entry_json = entry.decode("utf-8")
    entry_json_object = json.loads(entry_json)

    id = entry_json_object["ID"]
    names = entry_json_object["Names"]
    status = entry_json_object["Status"]
    created = entry_json_object["CreatedAt"]
    image = entry_json_object["Image"]
    ports = entry_json_object["Ports"]
    print(f"{id}\t{bcolors.WARNING}{names}{bcolors.ENDC}\t ({bcolors.OKDARKGRAY}Status: {status}, Created At: {created}{bcolors.ENDC})")
    print(f"  {bcolors.BOLD}Image:{bcolors.ENDC} {image}")
    print(f"  {bcolors.BOLD}Ports:{bcolors.ENDC} {ports}")
    print("")

The Script is also available as a GitHub Gist.

In .bashrc i override the "docker ps" command with the script:

function docker() {
  case $* in
    ps ) shift 1; command /root/bin/docker-ps ;;
    * ) command docker "$@" ;;
  esac
}

Alternative Idea

Just display the columns that are important to you:

e.g.:

docker ps --format "table {{.ID}}\t{{.Names}}\t{{.Ports}} "

Disable Auto-Update-Notifications of Citrix Workspace for MacOS

Max — Tue, 01 Nov 2022 14:40:58 +0000

Motivation

I dont want any update-notification popping up on macos when there is again a new Citrix Workspace version available. Instead i want to update citrix regulary via brew by myself.

Fix

Unfortunately there is no official checkbox to disable auto updates in the app settings.
Instead i found out that there is a config file that manages auto-updates in the following folder:

/Library/Application Support/Citrix Receiver/Auto Update/Prod

Just rename/remove the config folder and the auto-update notification should be gone:
sudo mv msr.xml msr.xml_tmp

Create secure Touchbar-Quickaction

Max — Sat, 22 Oct 2022 18:03:38 +0000

I wanted to create a Touchbar-Button that automatically pastes a password to the current cursor position. That button should be secured by Touch-Id.

Save Password at a secure location

The password should be stored at a secure location (e.g. in the Home-Directory of the Root-User).

sudo vim /var/root/masterpw

(You need the file path in the Automator-Script below)

I also consider storing the password on a YubiKey. But that is worth another blog post.

Create Quick Action in Automator

Automator is a default application of MacOS with that you can configure scripts for repetitive tasks.

Create and save a new Quick Action that runs the following AppleScript:

on run {input, parameters}
    do shell script "sudo cat /var/root/masterpw"
    tell application "System Events" to keystroke result
    return input
end run

Configure Touch-ID to be used with sudo

Per default sudo-commands require the root-password and can not be authorised with Touch-ID.

That can be changed by adding the following line of code to the sudo-File:

sudo vim /etc/pam.d/sudo:

auth       sufficient     pam_tid.so

Add "Quick Actions" to Control Strip

Done!

Now you can paste the password into every application. Just Klick on the "Quick Actions"-Button on the Touchbar, then on "Master PW" and confirm via TouchId Fingerprint.

Security advice

Due to SSO and LDAP login at work for many services using the same password is wanted in my situation. I want to highlight that it is best practice to use a Password Manager and try to avoid sharing the same password across multiple services as much as possible.