Hi everyone!

This post is a quick how-to resize a LVM volume for a Linux system. One mistake that I’ve made when setting up my mini PC Linux server with Alma Linux is that I didn’t pay attention to the defaults when partitioning the disk.

I woke up a few months later unable to install packages and several docker services failing, the main reason: insufficient disk space on /.

It turns out that by default the /home partition got 400GB of space allocated and the / partition got only ~70GB.

That is bad.

Filesystem                  Size  Used Avail Use% Mounted on
/dev/mapper/almalinux-root   70G   42G   29G  60% /
/dev/mapper/almalinux-home  400G  8.0G  392G   2% /home

Since I was using LVM and /home has an XFS filesystem type, resizing it was not straightforward. Luckily with the help of an AI assistant I’ve managed to find a solution and I’m sharing it here for reference.

Resizing Home

Here’s how you typically resize the /home partition.

ext4

If home is ext4 then things are a bit easier, you’d want to boot into recovery, unmount it and shrink it.

sudo umount /home
sudo e2fsck -f /dev/mapper/almalinux-home
sudo resize2fs /dev/mapper/almalinux-home 100G
sudo lvreduce -L 100G /dev/mapper/almalinux-home

Then extend /

sudo lvextend -r -L +300G /dev/mapper/almalinux-root

Note: I have not tested this flow.

xfs

If the /home is XFS, then things are a bit complicated. Home cannot be resized and it has to be recreated.

You can use the following commands to check for available space. Note that this output is after I resized the partition.

➜  ~ sudo lvs
  LV   VG        Attr       LSize   Pool Origin Data%  Meta%  Move Log Cpy%Sync Convert
  home almalinux -wi-ao----  70.00g                                                    
  root almalinux -wi-ao---- 399.50g                                                    
  swap almalinux -wi-ao----   5.85g                                                    
➜  ~ sudo lvs
  LV   VG        Attr       LSize   Pool Origin Data%  Meta%  Move Log Cpy%Sync Convert
  home almalinux -wi-ao----  70.00g                                                    
  root almalinux -wi-ao---- 399.50g                                                    
  swap almalinux -wi-ao----   5.85g                                                    
➜  ~ sudo pvs
  PV             VG        Fmt  Attr PSize   PFree
  /dev/nvme0n1p3 almalinux lvm2 a--  475.35g    0 

If there’s no space left then you can’t grow /. You will have to destroy and recreate the /home.

To do that you need to do the following steps:

1. Back-up the contents from /home

sudo rsync -aXS /home/ /root/home-backup/

I didn’t have much data in it, only the gitlab-runner config and in my case it was a fast and small back-up.

1. Recreate the /home

The following commands will destroy all the data in /home and will create it with 70G of space

sudo umount /home
sudo lvremove /dev/mapper/almalinux-home
sudo lvcreate -L 70G -n home almalinux
sudo mkfs.xfs /dev/mapper/almalinux-home
sudo mount /home

If you encounter errors when unmounting and mounting /home check the following section for troubleshooting and fixing tips.

Troubleshooting mount and unmount

You won’t be able to unmount /home if an user is using it. I had to shut down gitlab runner before unmounting.

You can check what is keeping fs busy with the following commands:

➜  ~ sudo fuser -vm /home
                     USER        PID ACCESS COMMAND
/home:               root     kernel mount /home
                     root       1449 ..c.. gitlab-runner

➜  ~ sudo lsof +D /home | head -100
COMMAND    PID USER   FD   TYPE DEVICE SIZE/OFF     NODE NAME
gitlab-ru 1449 root  cwd    DIR  253,2        6 16777344 /home/gitlab-runner

If you get an invalid uid when mounting home you will need to edit /etc/fstab file.

You can get the uid of the new /home partition with the following commands:

➜  ~ sudo lsblk --fs
NAME               FSTYPE      FSVER    LABEL UUID                                   FSAVAIL FSUSE% MOUNTPOINTS
nvme0n1                                                                                             
├─nvme0n1p1        vfat        FAT32          E5B7-DC76                               589.9M     1% /boot/efi
├─nvme0n1p2        xfs                        b11659d8-531b-4d08-a809-e6740a32d0c5    333.8M    65% /boot
└─nvme0n1p3        LVM2_member LVM2 001       Tsnalq-dvtn-CVFS-h85H-aBcz-sOrs-jeQkfK                
  ├─almalinux-root xfs                        7e852464-4b83-4f16-a831-a9d794e584b7    350.6G    12% /
  ├─almalinux-swap swap        1              7e6ce228-b5f2-454b-b7fe-61480d34fcbd                  [SWAP]
  └─almalinux-home xfs                        c88fb303-2e9a-4ec1-8654-45ac7a0a675f     68.3G     2% /home


➜  ~ sudo blkid
/dev/mapper/almalinux-swap: UUID="7e6ce228-b5f2-454b-b7fe-61480d34fcbd" TYPE="swap"
/dev/nvme0n1p3: UUID="Tsnalq-dvtn-CVFS-h85H-aBcz-sOrs-jeQkfK" TYPE="LVM2_member" PARTUUID="69c5165d-0709-43ec-8791-9a4227c61164"
/dev/nvme0n1p1: UUID="E5B7-DC76" BLOCK_SIZE="512" TYPE="vfat" PARTLABEL="EFI System Partition" PARTUUID="3e215e38-446f-4f9e-a6d6-109f69cd1e04"
/dev/nvme0n1p2: UUID="b11659d8-531b-4d08-a809-e6740a32d0c5" BLOCK_SIZE="512" TYPE="xfs" PARTUUID="7d56dc6b-8ba3-43d8-a3a6-cf76fee5b8cb"
/dev/mapper/almalinux-home: UUID="c88fb303-2e9a-4ec1-8654-45ac7a0a675f" BLOCK_SIZE="512" TYPE="xfs"
/dev/mapper/almalinux-root: UUID="7e852464-4b83-4f16-a831-a9d794e584b7" BLOCK_SIZE="512" TYPE="xfs"

Then edit /etc/fstab with nano and replace the UID part (UUID=c88fb303-2e9a-4ec1-8654-45ac7a0a675f), after that mount /home should work.

➜  ~ tail /etc/fstab 
# See man pages fstab(5), findfs(8), mount(8) and/or blkid(8) for more info.
#
# After editing this file, run 'systemctl daemon-reload' to update systemd
# units generated from this file.
#
UUID=7e852464-4b83-4f16-a831-a9d794e584b7 /                       xfs     defaults        0 0
UUID=b11659d8-531b-4d08-a809-e6740a32d0c5 /boot                   xfs     defaults        0 0
UUID=E5B7-DC76          /boot/efi               vfat    umask=0077,shortname=winnt 0 2
UUID=c88fb303-2e9a-4ec1-8654-45ac7a0a675f /home                   xfs     defaults        0 0

1. Restore the back-up

Restore the home back-up the following command and start stopped services.

sudo rsync -aHAX /root/home-backup/ /home/

1. Extend /

Extend the / volume with the 100% of FREE space with issuing of the following command.

sudo lvextend -r -l +100%FREE /dev/mapper/almalinux-root

Conclusion

If we don’t pay attention when installing a new Linux distro on a server we might get a surprise. Sometimes defaults aren’t that good. In this post we’ve explored how to shrink the /home volume and grow the / volume.

If the /home filesystem is of type ext4 then we just shrink it and grow /, otherwise if /home is xfs filesystem we need to back up the data, recreate the /home partition from scratch, restore the back-up and then grow /.

Thank you for reading!

Introduction

Kafka connect is a tool for streaming data between Kafka and other systems. It is distributed and scalable by
default and since it’s a standardized tool there are lots of connectors already available.

Connectors connect Kafka to a system or vice versa. There are two types of connectors

• Source: Source connectors grab data from an existing system e.g: MariaDB, PostgreSQL, S3, Jira, and others, and stream the data into one or more Kafka topics.

• Sink: Sink connectors grab the data from the topics and ingests it to a new system, eg: MongoDB, Snowflake, S3.

If you want to stream change data capture events from your databases, the Debezium provides
connectors that allow you
to do just that. CDC is an append only log that identifies changes in databases, using a cdc stream you can
replicate or reconstruct a database, additionally you can react on events by processing them in an external system.

Kafka connect can be deployed in standalone mode or distributed as a cluster of workers.

It features a RESTful interface for interacting with it:

• configuring connectors

• starting, stopping, pausing connectors

• viewing connector status

• resting connector offsets

It also allows you to apply various transformations on a message.

Apache Kafka has an amazing documentation section
on Kafka Connect.

Here’s a diagram of a system built with Kafka connect, it replicates data from PostgreSQL and MariaDB into
ElasticSearch. ElasticSearch offers a lot of tools for searching through the data with fast and good accuracy.

Rest API

For reference, I’ve copied all the operations from
the REST API
documentation and put them into a table.

Method Path Description GET /connectors return a list of active connectors. POST /connectors create a new connector. GET /connectors/{name} get information about a specific connector. DELETE /connectors/{name} deletes a connector. GET /connectors/{name}/config get the configuration parameters for a specific connector. PUT /connectors/{name}/config update the configuration parameters for a specific connector. PATCH /connectors/{name}/config patch the configuration parameters for a specific connector. GET /connectors/{name}/status get current status of the connector. GET /connectors/{name}/tasks get a list of tasks currently running for a connector. GET /connectors/{name}/tasks/{taskid}/status get current status of the task. PUT /connectors/{name}/pause pause the connector and its tasks, which stops message processing until the connector is resumed. PUT /connectors/{name}/stop stop the connector and shut down its tasks. PUT /connectors/{name}/resume resume a paused or stopped connector. POST /connectors/{name}/restart restart a connector and its tasks instances. POST /connectors/{name}/tasks/{taskId}/restart restart an individual task. PUT /connectors/{name}/topics/reset send a request to empty the set of active topics of a connector. GET /connectors/{name}/offsets get the current offsets for a connector. DELETE /connectors/{name}/offsets reset the offsets for a connector. GET /connector-plugins return a list of connector plugins installed in the Kafka Connect cluster. GET /connector-plugins/{plugin-type}/config get the configuration definition for the specified plugin. PUT /connector-plugins/{connector-type}/config/validate validate the provided configuration values against the configuration definition.

To start a new connector instance you would usually use POST on /connectors with a config body:

{
  "name": "my-jdbc-source",
  "config": {
    "connector.class": "io.confluent.connect.jdbc.JdbcSourceConnector",
    "tasks.max": "1",

    "connection.url": "jdbc:postgresql://localhost:5432/mydb",
    "connection.user": "myuser",
    "connection.password": "mypassword",

    "mode": "incrementing",
    "incrementing.column.name": "id",
    "table.whitelist": "users",
    "poll.interval.ms": "5000",

    "topic.prefix": "pg.",

    "value.converter": "org.apache.kafka.connect.json.JsonConverter",
    "value.converter.schemas.enable": "false",

    "transforms": "maskSensitive",
    "transforms.maskSensitive.type": "org.apache.kafka.connect.transforms.MaskField$Value",
    "transforms.maskSensitive.fields": "email,phone",
    "transforms.maskSensitive.replacement": "****"
  }
}

Converters

Converters are used by connect in order to convert values from a type to another. Converts apply to the kafka message
key and kafka message value. For example, if you have the following JSON message:

{"data": 1}

A string converter will put that message as a string in the Kafka topic, where as a JSON converter will keep it JSON.
There are also binary format converters like Avro and ProtoBuf,
that help reduce the message size by packing the message into the compact format. A downside of this format is that you
need the message schema in order to deserialize it.

You can also write your own converter and load it into Kafka connect.

To set the converters you use the following keys:

• key.converter: Sets the converter for the message key.

• value.converter: Sets the converter for the message value.

Here are some common converter classes:

• org.apache.kafka.connect.storage.StringConverter

• org.apache.kafka.connect.json.JsonConverter

• org.apache.kafka.connect.converters.ByteArrayConverter

• io.confluent.connect.json.JsonSchemaConverter (Requires schema registry)

• io.confluent.connect.protobuf.ProtobufConverter (Requires schema registry)

• io.confluent.connect.avro.AvroConverter (Requires schema registry)

And you usually set a converter with:

{
  "key.converter": "org.apache.kafka.connect.json.JsonConverter",
  "value.converter": "org.apache.kafka.connect.json.JsonConverter",
  "value.converter.schemas.enable": "true",
  "key.converter.schemas.enable": "true"
}

By also setting value.converter.schemas.enable to true you will receive the schema of the JSON message along
with the payload.

Schema Registry

The schema registry is another component that acts as a cache for the message schemas.

Binary formats like Avro or Protobuf cannot be decoded by their receiver without the message’s schema, and
sending the schema with each message increases the message size.

The purpose of the schema registry is to keep all schemas together in a database and let producers and consumers
request the schema only when needed, so that messages can be produced in the kafka topic without including the schema.

This component is optional, and it’s only required when using binary formats like Avro or Protobuf.

Transforms

You can apply various transformations on messages that are processed by the connector.

Common transforms include masking fields, dropping fields, replacing values, renaming fields and more.

• Cast - Cast fields or the entire key or value to a specific type

• DropHeaders - Remove headers by name

• ExtractField - Extract a specific field from Struct and Map and include only this field in results

• Filter - Removes messages from all further processing. This is used with a predicate to selectively filter certain messages

• Flatten - Flatten a nested data structure

• HeaderFrom - Copy or move fields in the key or value to the record headers

• HoistField - Wrap the entire event as a single field inside a Struct or a Map

• InsertField - Add a field using either static data or record metadata

• InsertHeader - Add a header using static data

• MaskField - Replace field with valid null value for the type (0, empty string, etc) or custom replacement (non-empty string or numeric value only)

• RegexRouter - modify the topic of a record based on original topic, replacement string and a regular expression

• ReplaceField - Filter or rename fields

• SetSchemaMetadata - modify the schema name or version

• TimestampConverter - Convert timestamps between different formats

• TimestampRouter - Modify the topic of a record based on original topic and timestamp. Useful when using a sink that needs to write to different tables or indexes based on timestamps

• ValueToKey - Replace the record key with a new key formed from a subset of fields in the record value

Source: https://kafka.apache.org/41/kafka-connect/user-guide/#transformations

To apply transforms you would include them into the connector config:

{
  "connector.class": "io.confluent.connect.jdbc.JdbcSourceConnector",
  "transforms": "maskSensitive",
  "transforms.maskSensitive.type": "org.apache.kafka.connect.transforms.MaskField$Value",
  "transforms.maskSensitive.fields": "sensitiveField",
  "transforms.maskSensitive.replacement": "****"
}

Docker Compose

You can start a pre-configured Kafka Connect instance along with a Kafka cluster for development or playing around
using this docker-compose file.

services:

  broker:
    image: confluentinc/cp-kafka:8.0.0
    hostname: broker
    container_name: broker
    ports:
      - "9092:9092"
      - "9101:9101"
    environment:
      KAFKA_NODE_ID: 1
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: 'CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT'
      KAFKA_ADVERTISED_LISTENERS: 'PLAINTEXT://broker:29092,PLAINTEXT_HOST://localhost:9092'
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
      KAFKA_JMX_PORT: 9101
      KAFKA_JMX_HOSTNAME: localhost
      KAFKA_PROCESS_ROLES: 'broker,controller'
      KAFKA_CONTROLLER_QUORUM_VOTERS: '1@broker:29093'
      KAFKA_LISTENERS: 'PLAINTEXT://broker:29092,CONTROLLER://broker:29093,PLAINTEXT_HOST://0.0.0.0:9092'
      KAFKA_INTER_BROKER_LISTENER_NAME: 'PLAINTEXT'
      KAFKA_CONTROLLER_LISTENER_NAMES: 'CONTROLLER'
      KAFKA_LOG_DIRS: '/tmp/kraft-combined-logs'
      # Replace CLUSTER_ID with a unique base64 UUID using "bin/kafka-storage.sh random-uuid"
      # See https://docs.confluent.io/kafka/operations-tools/kafka-tools.html#kafka-storage-sh
      CLUSTER_ID: 'MkU3OEVBNTcwNTJENDM2Qk'

#  schema-registry:
#    image: confluentinc/cp-schema-registry:8.0.0
#    hostname: schema-registry
#    container_name: schema-registry
#    depends_on:
#      - broker
#    ports:
#      - "8081:8081"
#    environment:
#      SCHEMA_REGISTRY_HOST_NAME: schema-registry
#      SCHEMA_REGISTRY_KAFKASTORE_BOOTSTRAP_SERVERS: 'broker:29092'
#      SCHEMA_REGISTRY_LISTENERS: http://0.0.0.0:8081

  connect:
    image: confluentinc/cp-kafka-connect:8.1.2
    hostname: connect
    container_name: connect
    depends_on:
      - broker
#      - schema-registry
    ports:
      - "8083:8083"
    environment:
      CONNECT_BOOTSTRAP_SERVERS: 'broker:29092'
      CONNECT_REST_ADVERTISED_HOST_NAME: connect
      CONNECT_GROUP_ID: compose-connect-group
      CONNECT_CONFIG_STORAGE_TOPIC: docker-connect-configs
      CONNECT_CONFIG_STORAGE_REPLICATION_FACTOR: 1
      CONNECT_OFFSET_FLUSH_INTERVAL_MS: 10000
      CONNECT_OFFSET_STORAGE_TOPIC: docker-connect-offsets
      CONNECT_OFFSET_STORAGE_REPLICATION_FACTOR: 1
      CONNECT_STATUS_STORAGE_TOPIC: docker-connect-status
      CONNECT_STATUS_STORAGE_REPLICATION_FACTOR: 1
      CONNECT_KEY_CONVERTER: org.apache.kafka.connect.json.JsonConverter
      CONNECT_VALUE_CONVERTER: org.apache.kafka.connect.json.JsonConverter
#      CONNECT_VALUE_CONVERTER_SCHEMA_REGISTRY_URL: http://schema-registry:8081
      CONNECT_PLUGIN_PATH: "/usr/share/java,/usr/share/confluent-hub-components"

Additionally, you can also download the kafka binary archive and run
connect with bin/connect-standalone.sh config/connect-standalone.properties.

That’s all, I hope this article gave you a rough idea of Kafka Connect and it’s capabilities.

References

• https://kafka.apache.org/41/kafka-connect/user-guide/

• https://www.confluent.io/blog/kafka-connect-deep-dive-converters-serialization-explained/

Hello everyone!

I started this year by re-learning the Ruby programming language. Ruby is a lovely and elegant programming language, and It was one of my first three languages that I’ve learned back in the day on CodeCademy.

In January, I finished reading the Well-Grounded Rubyist, Fourth Edition book which got me a good start with Ruby. I’m by no means proficient in it yet, but I’ve also bought several Ruby books that I hope to finish reading this year.

The reason for learning a new language every year is that I find it enjoyable to try new things and read books.
In the last three years I’ve read about Rust, Kotlin and Dart, and I’ve also done a few side projects in them.

Back when I was learning Python we had no types, everything was blank and it was difficult to tell what a method was doing by just looking at its signature, luckily for us PEP 484 added type hints, and we could write code like this:

def greeting(name: str) -> str:
    return 'Hello ' + name

Ruby also has support for types and the reason I’m writing this article is to show you how to add types to your Ruby project using Sorbet and RBS.

Both approaches are different, let’s explore!

You can read the full article on my blog:

https://nuculabs.dev/programming/2026/01/28/types-in-ruby.html

Introduction

I’ve been running GitLab as my software forge for the last three weeks and everything was smooth. I replaced my Forgejo instance with it because it has a better UI and UX. Gitlab is more resource consuming than Forgejo and my 5$/month VPS turned into 17$/month in order to host and use it without lag.

Well, 204$ a year is a bit too much in my opinion just to host the software forge, so I decided to buy a MiniPC and host it myself instead, and with the help of Cloudflare I can safely expose it to the internet using tunnels.

The idea behind tunnels is that you run a cloudflare agent on the PC and you won’t need to expose ports to the outside. All traffic is received through the tunnel directly, and since I host my DNS with Cloudflare this solution works well.

My power bill is also low, much lower than my 5$/month initial VPS. I have a smart plug which tracks energy usage, and I’m using a power cord that powers: Gitlab MiniPC, Old Gaming PC that I use as a gitlab runner, a network switch and overall I’m averaging about 1KW a day.

This article’s focus is a how to host Gitlab and perform basic operations for maintenance.

You can read the article on my blog:

https://nuculabs.dev/posts/2026/self-hosting-gitlab/

In this article I will show you how to self-host Navidrome, your personal music streaming
service.

I will provide you with an Ansible playbook that you can run from your machine.

Navidrome

Navidrome is an open-source self hosted music streaming server. You can deploy it, load your music and then
enjoy it using various clients like a web browser or a mobile application.

You can find more information about Navidrome by visiting their website:

• https://www.navidrome.org/about/

Since Navidrome is open source and free to use for everyone you can also support its
authors with a small donation:

• https://ko-fi.com/deluan

Continue reading on my blog:

https://nuculabs.dev/

I’m writing this article to quickly show you how-to self-host Forgejo, the Git software forge, and how to do common maintenance operations.

Forgejo is a lightweight platform for hosting git software repositories, similar to GitHub. It is easy to self-host and manage.

If you’re curious about it you can read it on my blog:

https://blog.nuculabs.dev/posts/2025/self-hosting-forgejo/

If you need help with self-hosting Forgejo or the article contains inaccurate information you may reach out to me by email or on the forum (preferred).

https://forum.nuculabs.dev/threads/self-hosting-forgejo.124/#post-209

I wrote a new blog post on containerizing a Python project that uses uv.

You can read it on my blog:

🇷🇴 - Containerizarea unui proiect de Python cu UV

🇺🇸 - Containerizing a Python Project with UV

The picture of this article is the output of Claude, using a local MCP server that gives it the output of the ls -l command on a given path. Notice how the LLM likes to praise me, exaggerating a bit, In my opinion this is just a way to keep your users hooked on their product. Who doesn't like to be praised and approved with everything they say, right? :D

Originally published here: https://www.nuculabs.dev/threads/introduction-to-mcp-servers-and-writing-one-in-python.115/#post-186

Hello everyone,

I wanted to write an article on MCP servers since I just written one in Python last week.

Theory​

MCP stands for Model Context Protocol, and it is a standardized protocol designed to connect LLMs with tools, resources and prompt templates. Tools are functions that get executed by LLMs on demand. This is quite nice because once you have an MCP server set up you can use it with multiple LLMs, imagine the model calls your server's functions and you only need to tell the model which parameters the functions take and what data does it return, and of course some hints for the LLM on how to use your defined tools

Servers supports two transport layers, the STDIO mode and HTTP Streaming.

• STDIO uses standard IO and is used for local processes. I believe that you just call the server like you call a CLI tool and then you capture it's output, please correct me if I'm wrong.

• HTTP Streaming servers uses Server-Sent Events with JSON-RPC, which is just JSON like:

--> [
        {"jsonrpc": "2.0", "method": "sum", "params": [1,2,4], "id": "1"},
        {"jsonrpc": "2.0", "method": "notify_hello", "params": [7]},
        {"jsonrpc": "2.0", "method": "subtract", "params": [42,23], "id": "2"},
        {"foo": "boo"},
        {"jsonrpc": "2.0", "method": "foo.get", "params": {"name": "myself"}, "id": "5"},
        {"jsonrpc": "2.0", "method": "get_data", "id": "9"}
    ]
<-- [
        {"jsonrpc": "2.0", "result": 7, "id": "1"},
        {"jsonrpc": "2.0", "result": 19, "id": "2"},
        {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null},
        {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found"}, "id": "5"},
        {"jsonrpc": "2.0", "result": ["hello", 5], "id": "9"}
    ]

You can read more about MCP's specification here: Specification - Model Context Protocol.

Use cases​

I can think about various use-cases on how I would use custom MCP servers, as a homelab user, hobbies, not for business. Some use cases imply online LLMs (OpenAI, Mistral, Claude) when I don't care about privacy and some use cases with offline LLMs in order to preserve my privacy.

Email prioritization, Most email provides offer you access to read emails using IMAP[1] and POP protocols. You could write an MCP server that exposes some tools for reading emails and let the LLM analyze them.
Endpoint security. Write a local MCP server that provides information about files on the system, permissions and use an LLM to analyze them
Weather information: Write a MCP server that exposes tools for reading data from various sources i.e sensors, weather APIs and a tool for alerting when values are out of range or an unwanted event may occur, such as thunderstorms.
News summarization. You can write an MCP server that scrapes your favorite news sites and provides structured output to an LLM for summarizing them.

You can have lots of fun with MCP servers. Even if LLMs hallucinate or provide incorrect output, building a weather alert system in an language agnostic way with some calls to a local or remote LLM has never been easier.

Claude also uses MCP servers in the form of Connectors.

[1] - imaplib — IMAP4 protocol client

A Python MCP Server​

To write MCP server I recommend that you use the official SDKs. At the current time there are SDKs for Python, Java, JavaScript, TypeScript, Rust, Ruby, Go, Kotlin, Swift and C#.

To follow along you will need UV installed.

curl -LsSf https://astral.sh/uv/install.sh | sh

uv init nuculabs-mcp
cd nuculabs-mcp

uv add mcp[cli]

The asyncio Python-based MCP HTTP Streaming server can look like this:

import asyncio
import logging
import subprocess

from mcp.server.fastmcp import FastMCP
from mcp.types import ToolAnnotations
from pydantic import BaseModel, Field


class LsOutput(BaseModel):
    """
        LsOutput is a model class that represents the output of the LS command, this simple example for educational
        purposes only shows a simple text field. You can parse the ls output it to return more meaningful fields
        like the file type, name, date, permissions and so on.
    """
    output: str = Field(..., title="The output of the `ls` command.")


class SystemAdminTools:

    def __init__(self):
        self._logger = logging.getLogger("dev.nuculabs.mcp.SystemAdminTools")
        self._logger.info("hello world")

    async def get_ls_output(self, directory: str) -> LsOutput:
        """
            Returns the output of the `ls` command for the specified directory.
        :param directory: - The directory path
        :return: The LSOutput.
        """
        self._logger.info(f"get_ls_output tool called with: {directory}")
        # This is a dummy example for educational purposes, but you can write a tool that parses the output and returns a meaningful model
        # instead of a simple text file. You could also extend it to remote machines.
        # Security Warning: when taking user input such as the 'directory' variable here, always sanitize and validate it,
        # using this code as it is malicious output can be used to highjack the target system.
        result = subprocess.run(['ls', "-l", directory], capture_output=True, text=True)
        output = result.stdout
        return LsOutput(output=output)


async def main():
    logging.basicConfig(level="INFO")
    # Create an MCP server
    mcp = FastMCP(
        "NucuLabs System Files MCP",
        instructions="You're an expert T-shaped system administrator assistant.",
        host="0.0.0.0",  # open to the world :-)
    )
    tools = SystemAdminTools()

    mcp.add_tool(
        tools.get_ls_output,
        "get_ls_output",
        title="Tool that returns the output from the list files command.",
        description="This tool executes ls on the given directory path and returns all the information from the command.",
        annotations=ToolAnnotations(
            readOnlyHint=True,
            destructiveHint=False,
            idempotentHint=True,
            openWorldHint=False,
        ),
        structured_output=True,
    )

    await mcp.run_streamable_http_async()


if __name__ == "__main__":
    asyncio.run(main())

Testing the Server​

To validate and test the MCP server quickly and without using an LLM you can use an MCP server testing tool such as MCP Inspector or Postman. To use MCP Inspector you only need to have NodeJS >= 22 installed on your system and then run.

npx @modelcontextprotocol/inspector

The command will open up a browser with the MCP Inspector server. I haven't managed to test the server using the aforementioned tool.

I had a positive experience with Postman's MCP client.

Testing with an LLM​

To test the server with an LLM you can use the agno-framework or your client SDK if you already have one. Agno is pretty easy to use.

import asyncio

from agno.agent import Agent
from agno.models.anthropic import Claude
from agno.tools.mcp import MCPTools

async def main():
    async with MCPTools(url="http://localhost:8000/mcp", transport="streamable-http") as mcp_tools:
        agent = Agent(
            # set api key in ANTHROPIC_API_KEY environment variable or pass it as a parameter
            model=Claude(),
            tools=[
                mcp_tools
            ],
            instructions="Use tools to analyze systems.",
            markdown=False,
        )

        await agent.aprint_response(
            "Describe my personality based on the contents of the following directory: /home/dnutiu",
            stream=True,
            show_full_reasoning=True,
            stream_intermediate_steps=True,
        )


if __name__ == '__main__':
    asyncio.run(main())

After running the snippet I get the following output from Claude:

┏━ Message ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃                                                                              ┃
┃ Describe my personality based on the contents of the following directory:    ┃
┃ /home/dnutiu                                                                 ┃
┃                                                                              ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
┏━ Tool Calls ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃                                                                              ┃
┃ • get_ls_output(directory=/home/dnutiu)                                      ┃
┃                                                                              ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
┏━ Response (9.2s) ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃                                                                              ┃
┃ Let me check the contents of that directory for you.Based on the contents of ┃
┃ your home directory, I can tell that you're a software developer with        ┃
┃ diverse interests in programming and technology. Here's what I can deduce    ┃
┃ about your personality:                                                      ┃
┃                                                                              ┃
┃ 1. You're versatile and multi-skilled: You have multiple IDE project         ┃
┃ directories (CLion, PyCharm, PhpStorm, IntelliJ IDEA, Rustrover) which shows ┃
┃ you work with various programming languages including Python, PHP, Java,     ┃
┃ C/C++, and Rust.                                                             ┃
┃                                                                              ┃
┃ 2. You're organized: Your directory structure is well-maintained with clear  ┃
┃ separations for different types of content (Documents, Downloads, Pictures,  ┃
┃ etc.).                                                                       ┃
┃                                                                              ┃
┃ 3. You're technically inclined: The presence of DevOps directory and Postman ┃
┃ suggests you're involved in backend development and API testing.             ┃
┃                                                                              ┃
┃ 4. You're likely a professional developer: The presence of multiple          ┃
┃ development tools and project directories suggests this is more than just a  ┃
┃ hobby.                                                                       ┃
┃                                                                              ┃
┃ 5. You use Linux (KDE specifically): This shows you're comfortable with      ┃
┃ technical tools and prefer having control over your computing environment.   ┃
┃                                                                              ┃
┃ 6. You might have some personal projects: The "nuculabs" directory might be  ┃
┃ a personal project or endeavor.                                              ┃
┃                                                                              ┃
┃ 7. You keep up with modern development tools: You have the JetBrains toolbox ┃
┃ installed, showing you use current development tools.                        ┃
┃                                                                              ┃
┃ 8. You're interested in multiple areas of software development: From web     ┃
┃ development (PHP) to systems programming (Rust, C++) to scripting (Python),  ┃
┃ showing a broad range of interests in programming.                           ┃
┃                                                                              ┃
┃ Your directory structure reveals someone who is methodical, technically      ┃
┃ sophisticated, and has a strong interest in various aspects of software      ┃
┃ development and technology.                                                  ┃
┃                                                                              ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

If you have subscription and a supported OS you can also test it with Claude Desktop. On Linux Ollama has some models which support MCP tools.

That's about it! I hope you've enjoyed this article!

I recently worked on a small side project written in Java with the Spring Framework and I had difficulties authenticating to an external OAuth2 client using spring security. The solution to my problem was clear after I perused the code and documentation of the Spring OAuth Client package.

I thought that I'll have to write custom classes to configure it for my specific need but it turned out that my issues was strictly configuration related.

The issues was that I had a Confidential OAuth2 client and the default configuration of Spring Security assumes that the client is Public.

The RFC describes the client types as follows:

• The Confidential client type is for applications that can keep the client secret safe, for example a back-end web application.

• The Public client type is for applications that cannot keep their client secrets safe, for example a mobile applications or front end application. The user can always browse the source code and obtain the secrets.

In my Spring project, I've configured the authentication using the applications.properties file. Notice that the configuration of the client and provider is under the nuculabs key.

# OAuth2 Client Configuration
spring.security.oauth2.client.registration.nuculabs.client-id=xxx
spring.security.oauth2.client.registration.nuculabs.client-secret=xxx
spring.security.oauth2.client.registration.nuculabs.scope=user:read,read:user
spring.security.oauth2.client.registration.nuculabs.authorizationGrantType=authorization_code
spring.security.oauth2.client.registration.nuculabs.redirectUri=http://localhost:8080/login/oauth2/code/nuculabs
spring.security.oauth2.client.registration.nuculabs.client-authentication-method=client_secret_post

spring.security.oauth2.client.provider.nuculabs.authorization-uri=https://www.example.com/oauth2/authorize
spring.security.oauth2.client.provider.nuculabs.token-uri=https://www.example.com/api/oauth2/token
spring.security.oauth2.client.provider.nuculabs.user-info-uri=https://www.example.com/api/me
spring.security.oauth2.client.provider.nuculabs.user-name-attribute=me

And the configuration that I was missing was client_secret_post.

Once that was completed I only had to add the following SecurityConfig class:

package dev.nuculabs.xenchat.xenchat.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;
@Configuration
@EnableWebSecurity
public class SecurityConfig {

    // OAuth2AuthorizationCodeGrantRequestEntityConverter

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
                .authorizeHttpRequests(authorize -> authorize
                        .requestMatchers("/error", "/webjars/**", "/login").permitAll()
                        .requestMatchers("/").authenticated()
                        .anyRequest().authenticated()
                )
                .oauth2Login(oauth2 -> oauth2
                        .loginPage("/login")
                        .defaultSuccessUrl("/", true)
                )
                .logout(logout -> logout
                        .logoutSuccessUrl("/login")
                        .permitAll()
                );

        return http.build();
    }
}

And when I want to authenticate users using my external OAuth client, I only have to redirect them to an internal link in order to trigger the authentication flow implemented by Spring Security:

/oauth2/authorization/nuculabs

The final step is to configure the external OAuth client with the following URL:

http://localhost:8080/login/oauth2/code/nuculabs

This will technically complete the authentication flow. What will happen next is that Spring will try to grab the user data from the user-info-uri, in my case the API is secured by the access token and it will respond with a "me" object that looks like this:

{

    "me": {
    "about": "I’m Denis, a Software Engineer living in Romania. I’m passionate about cloud computing and software development ✨.",
    "activity_visible": false,
    "alert_optout": [],
    "allow_post_profile": "members",
    "allow_receive_news_feed": "members",
    "allow_send_personal_conversation": "members",
    "allow_view_identities": "members",
    "allow_view_profile": "members",
    "name": "Denis",
    ...
}

What I had to do was to specify me as the user-name attribute as follows:

spring.security.oauth2.client.provider.nuculabs.user-name-attribute=me

Then I can access all those fields from a controller like so:

package dev.nuculabs.xenchat.xenchat.controller;

import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.oauth2.core.user.OAuth2User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import java.util.LinkedHashMap;

@Controller
public class HomeController {

@GetMapping("/")
public String home(@AuthenticationPrincipal OAuth2User principal, Model model) {
LinkedHashMap<String, Object> userData = principal.getAttribute("me");
        // Add user attributes to the model
        model.addAttribute("name", userData.get("username"));
        model.addAttribute("email", userData.get("email"));
        model.addAttribute("title", userData.get("custom_title"));
        model.addAttribute("profileUrl", userData.get("view_url"));
        model.addAttribute("isModerator", userData.get("is_moderator"));

        // Add all attributes for debugging
        model.addAttribute("attributes", principal.getAttributes());

return "home";
    }

@GetMapping("/login")
public String login() {
return "login";
    }
}

That's about it, I hope this article helped! :D

Thanks for reading!

Hello

This is a short article about setting offsets in Apache Kafka for a consumer group.

Normally, to reset offsets in Kafka you need to use the kafka-consumer-groups.sh tool, this means downloading the zip archive with Kafka's source code and setting up the Java SDK. All Kafka's tools are dependent on Java and this isn't that nice or developer friendly...

Sometimes getting Java correctly and getting the tools to run they don't work.

Either the tool versions are incompatible with the Kafka version on the server or the command executes successfully but it doesn't seem to do anything...

Another method to set offsets for a consumer it is to use a Kafka library, and to do it through code.

I have Python installed on my setup and all I need to do is to install the confluent-kafka library:

pip install confluent-kafka

And then run the following code snippet to reset the consumer's offsets to a specific timestamp:

from confluent_kafka import Consumer, TopicPartition
import time

# Configuration
consumer_config = {
    'bootstrap.servers': 'localhost:9092',
    'group.id': 'my-consumer-group',
    'auto.offset.reset': 'earliest',
    'enable.partition.eof': True
}

topic = 'my-topic'
timestamp_ms = int(time.mktime(time.strptime("2025-04-01 12:00:00", "%Y-%m-%d %H:%M:%S")) * 1000) # or time in miliseconds

# Create consumer
consumer = Consumer(consumer_config)

# Get metadata to discover partitions
metadata = consumer.list_topics(topic)
partitions = [TopicPartition(topic, p.id, timestamp_ms) for p in metadata.topics[topic].partitions.values()]

# Lookup offsets for the timestamp
offsets = consumer.offsets_for_times(partitions, timeout=10.0)

# Assign partitions with correct offsets
consumer.assign(offsets)

# Start consuming
try:
    while True:
        msg = consumer.poll(timeout=1.0)
        if msg is None:
            continue
        if msg.error():
            print("Error:", msg.error())
            continue

        print(f"{msg.topic()} [{msg.partition()}] at offset {msg.offset()}: {msg.value().decode('utf-8')}")
        break

except KeyboardInterrupt:
    pass
finally:
    consumer.close()

Thanks for reading!

Feel free to join the discussion on my forum: https://www.nuculabs.dev/threads/apache-kafka-how-to-set-offsets-to-a-fixed-time.88/

In this month’s blog post I’ll show you how to run a PHP Application inside a container.

I’m quite a fan of online forums and the majority of forum software is written in PHP. To evaluate them quickly I wanted the ability to be able to run and install then locally.

I’ve come up with this docker-compose file

services:
  nginx:
    build:
      context: ./
      dockerfile: nginx.dockerfile
    ports:
      - "8080:80" # change port 10080 to any other port
    volumes:
      - ./config/nginx/conf.d:/etc/nginx/conf.d:z
      - ./.data/nginx:/var/log/nginx:z
      - application:/var/www/html:z
      - composer:/root/.composer:z
  php:
    build:
      context: ./
      dockerfile: php83.dockerfile
    volumes:
      - ./config/php.ini:/usr/local/etc/php/php.ini:z
      - application:/var/www/html:z
      - composer:/root/.composer:z
  database:
    image: "postgres:latest"
    ports:
      - 15432:5432
    environment:
      POSTGRES_PASSWORD: denis
      POSTGRES_USER: batman
    volumes:
      - ./.data/postgres/:/var/lib/postgresql/data/:z
  maria:
    image: mariadb
    restart: always
    ports:
      - 13306:3306
    environment:
      MARIADB_ROOT_PASSWORD: example
    volumes:
      - ./.data/maria/:/var/lib/mysql:z
volumes:
    composer:
    application:
      driver: local
      driver_opts:
        type: none
        device: ./application
        o: bind

All you need to do is place the PHP application inside the ./application directory and run:

podman compose up # or docker compose up

The file will set up the following components:

• php - The PHP runtime.

• nginx - The Nginx web server used to serve requests. You can customize it by editing ./config/nginx/conf.d/default.conf

• database - Runs a PostgresSQL database which persists data inside the local ./.data directory.

• maria - Runs a MariaDB database which persists data inside the local ./.data directory.

It’s unlikely that you need both databases running at the same time, feel free to delete the one you don’t need. Some PHP Applications work with PostgresSQL and some work only with MariaDB/MySQL.

Thank you for reading, if you have any questions please do reach out on @mastodon.

By the way, I’m using this method to host my forum.

In this blog post we’re exploring the option of self hosting Anubis.

Anubis is a software that defends and protects your services from AI Scrapers and LLMs. Since AI started to get popular more and more scrappers started appearing. They grab your data in order to use it to train their AIs while ignoring any rules such as robots.txt, licenses and intellectual property laws. Meta even torrented 82TB of books to train their AI.

Read the full version here

Hello everyone! 👋

This post is about accessing the host URL from inside a Podman (or Docker) container and how to avoid a mistake I made when setting up containers.

If you have a service running inside a container, and you would like to access the host URL you will have to use a special address called the host-gateway address. Other options include hard-coding the host ip address.

You can use any of the following URLs when you want to access the host from inside a container:

• host.containers.internal

• host.docker.internal

Source:

The host-gateway address is also used by Podman to automatically add the 
host.containers.internal and host.docker.internal hostnames to /etc/hosts. 

• https://docs.podman.io/en/v5.3.0/markdown/podman-build.1.html

What not to do

Continue reading for free on my blog:

https://blog.nuculabs.dev/posts/2025/2025-05-06-accessing-the-host-from-containers/

I wanted to write a short article about zipping and unzipping a directory in Golang.

The answer is quite simple ;) :

https://blog.nuculabs.dev/posts/2025/2025-04-01-how-to-zip-and-unzip-a-directory-go/

Hello everyone! 👋

I’ve had to work with RocksDB recently and in order to use it from Golang I had to jump a few hops before getting it to work properly.

This article will show you how to compile a Go program and link it with RocksDB using CGO. We
will use the grocksdb library.

Full article: https://blog.nuculabs.dev/posts/2025/2025-03-16-how-to-use-rocksdb-with-go/

Hello everyone! 👋

Welcome to another self-host article! This month we’re hosting a CalDAV and CardDAV server. Baïkal, the lightweight CalDAV+CardDAV server.

We’re going to host it in a Podman container on a Fedora server.

• https://sabre.io/baikal/

Read more on my blog: nuculabs.dev

Hello everyone! 👋

This is my first blog post in 2025, and I’d like to talk about my experience in self-hosting PeerTube in Fedora Server and how to do it yourself.

In addition to this I’ve also added a new category on my blog: Self Hosting

I also want to celebrate I have 15k unique visitors per month (according to CloudFlare), however most of them are port scans, exploits and LLM-bots scraping everything and ignoring robots.txt. 😅

Why PeerTube 📹

PeerTube is a federated video sharing platform. You can host your own instance or create an account on a popular instance like:

https://peertube.tv/

https://tilvids.com/

• https://instances.joinpeertube.org/instances

The federation allows every instance to have its own rules and also allow users from different instances to interact with each other.

Federation also helps prevent monopoly and censorship.

My YouTube channel is small and my goal is not to become an influencer. I just like making videos from time to time and own my data.

Fedora Server 🐧

Before Fedora Server I had PeerTube on a Raspberry Pi5 with 4GB of RAM and then a PC running Ubuntu Server. I’ve uninstalled Ubuntu Server and installed Fedora Server.

The PI5 didn’t work that well in encoding videos department. A simple 5 minutes videos could take up to 20minutes to be encoded in 1080p, 720p and 480p resolutions. There was also a limited number of simultaneous playbacks supported.

I’m sticking with Fedora Server thanks to the Cockpit UI, Podman support and virtual machine support. Having virtual machines run on a separated PC and connecting to them in the browser is a huge benefit for my use cases.

Prerequisites

To keep this article short, if you want to host PeerTube on a Fedora Server with Podman you’ll need these prerequisites:

1. Self Host PeerTube on your PC via Docker

Get started with Docker and Docker Compose and learn how to self-host PeerTube on your PC by reading this guide:

• https://docs.joinpeertube.org/install/docker

2. Have Fedora Server, Podman and a working SSH connection to the server.

Continue reading on my blog: https://blog.nuculabs.dev/posts/2025/2025-01-25-self-hosting-peertube/

Hello everyone! 👋

I run a small set of containers on my NAS at Home to monitor different weather and run automations. Because of this I wanted to install Redis on my NAS as well.

Redis is a key value database that has a lot of extra modules such as:

• Redis Search: A query and indexing engine for Redis, providing secondary indexing, full-text search, vector similarity search and aggregations.

• Redis JSON: A NO-SQL Document Database

• Redis Graph: A graph database.

• Redis TimeSeries: A time series database.

• Redis Bloom: Bloom and Cuckoo filters implementation.

• Redis Streams: An append only Log

These functionalities save me a lot of time and improve my software running inside my home. Redis is also a simple service to deploy and maintain.

So I made a quick tutorial on how to install Redis on a Synology NAS using the Container Manager.

In this article you will learn how to install DaVinci Resolve Free and Studio editions on Fedora 40 and Fedora 41.

The first step is to download DaVinci Resolve from the official website, either with:

• Free Edition

• Studio Edition

The next step is to download and install DaVinci Helper.

sudo dnf copr enable -y herzen/davinci-helper
sudo dnf install -y davinci-helper

Once you’ve installed DaVinci Helper, the following steps are simple. Simply circle through the tabs to on the left and select the DaVinci Resolve zip file when prompted.

After all the steps are done, you can open DaVinci Resolve:

Audio Interface

I use a Rode AI-1 audio interface and I wrote an article about it how to get it working properly on Linux.

You can read it:

• How to make RØDE audio interface work on Linux.

Thank you reading! 🐧

Introduction

Hello everyone! 👋

In this article I’ll present you the options pattern in Golang. The pattern is useful when you want to create a function that takes different parameters as an option.

Code Study: Building a rocket

The following code defines a Rocket struct with 3 fields and a NewRocket function which builds an instance of the Rocket.

// Rocket models a rocket.
type Rocket struct {
	name         string
	nose         Nose
	fuelCapacity int
}

// NewRocket returns a new rocket instance.
func NewRocket(name string, nose Nose, fuelCapacity int) Rocket {
	return Rocket{
		name:         name,
		nose:         nose,
		fuelCapacity: fuelCapacity,
	}
}

To use the NewRocket function one would have to write something like this:

func main() {
	rocket := NewRocket("Techno", PointyNose, 100)

	println(rocket.String())
}

This is straightforward, but what if we’d want the name of the rocket, nose and fuel capacity to be optional parameters?

We could rewrite the NewRocket function to take pointers instead of literals and if we do so we could build a default rocket with:

func main() {
	rocket := NewRocket(nil, nil, nil)

	println(rocket.String())
}

This is of course not very readable, my eyes start watering only by looking at this code.

When we want to modify the Rocket struct and add a new field, that is also instantiated we’d need to remember the position in our code and modify all the NewRocket function usages.

So far not using the options pattern for instantiating a Rocket has the following disadvantages:

• Ugly code.

• Hard to modify code.

• Need to refactor every usage of the function.

The Options Pattern

The Options pattern is straightforward to implement and there are many variations, in this article we’ll explore one simple variation:

First, define the RocketOptions struct that takes the same configurable fields as the Rocket struct and defines functions for instantiating them.

The fields are defined as pointers instead of literals because we want to treat the nil value as not user specified.

func NewRocketOptions() *RocketOptions {
	return &RocketOptions{
		name:         nil,
		nose:         nil,
		fuelCapacity: nil,
	}
}

func (o *RocketOptions) WithName(name string) *RocketOptions {
	o.name = &name
	return o
}

func (o *RocketOptions) WithNose(nose Nose) *RocketOptions {
	o.nose = &nose
	return o
}

func (o *RocketOptions) WithFuelCapacity(capacity int) *RocketOptions {
	o.fuelCapacity = &capacity
	return o
}

Next, modify the NewRocket function to use the RocketOptions struct like so:

// NewRocket returns a new rocket instance.
func NewRocket(options *RocketOptions) Rocket {
	var name string = "Unknown"
	if options.name != nil {
		name = *options.name
	}

	var nose Nose = PointyNose
	if options.nose != nil {
		nose = *options.nose
	}

	var fuelCapacity int = 100
	if options.fuelCapacity != nil {
		fuelCapacity = *options.fuelCapacity
	}

	return Rocket{
		name:         name,
		nose:         nose,
		fuelCapacity: fuelCapacity,
	}
}

The NewRocket now provides default values for the nil options and when they are specified it uses the user provided option value.

Other Variation

Another variation can be implemented like this:

type Nose string

const PointyNose Nose = "POINTY"
const RoundNose Nose = "ROUND"

type rocketOptions struct {
	name         string
	nose         Nose
	fuelCapacity int
}

type RocketOption func(options *rocketOptions)

// Rocket models a rocket.
type Rocket struct {
	options rocketOptions
}

func (r *Rocket) String() string {
	return fmt.Sprintf("%s rocket with %s nose and fuel capacity of %d", r.options.name, r.options.nose, r.options.fuelCapacity)
}

// NewRocket returns a new rocket instance.
func NewRocket(options ...RocketOption) Rocket {
	rocketOptions := rocketOptions{
		name:         "Unknown",
		nose:         PointyNose,
		fuelCapacity: 100,
	}

	for _, option := range options {
		option(&rocketOptions)
	}

	return Rocket{
		options: rocketOptions,
	}
}

func NameOption(name string) RocketOption {
	return func(options *rocketOptions) {
		options.name = name
	}
}

func main() {
	rocket := NewRocket()
	println(rocket.String())

	otherRocket := NewRocket(NameOption("Cool"))
	println(otherRocket.String())
}

Conclusion

We’ve explored how the Options pattern can significantly enhance the design and usability of functions in Golang, particularly when dealing with multiple optional parameters.

Thank you for reading!