..JavaBendeR...

Daily life Linux problems..

noreply@blogger.com (Serkan Sunel) — Thu, 05 Mar 2026 19:51:00 +0000

## Confessions of a Distracted Linux Coder: How "Port Already in Use" Turned into Heimdall

Hey everyone,

You know those moments when you're deep in code on Linux and suddenly…

**"Why can't I delete this file?"**

**"Which damn process is holding port 8080?"**

**"Wait, who just opened that socket?"**

One minute you're writing a function, the next you're running `lsof`, `ss`, `fuser`, `ps aux | grep`, `journalctl -u`, and `iotop` like a madman.

By the time you fix the tiny problem, you’ve completely forgotten what you were actually working on.

**"What was I doing again?"** 😅

Or worse — that paranoid feeling creeps in:

"Is everything okay? Why is systemd-journald eating CPU?

Who is scraping my disk like it's a frying pan?

Why are the modem lights blinking non-stop?

Who is sending all these packets?!"

And the worst one:

"Did that innocent little package I just installed silently start talking to the outside world without telling me?"

Switching between five different TUIs and terminals just to answer basic questions gets exhausting.

I got tired of it.

So… I ended up going down the rabbit hole.

What started as a quick hack to find "who's using this port" slowly grew into something bigger.

And because I can't help myself, I added way too many icons to make it feel a little more fun 😄

Ladies and gentlemen, meet **Heimdall** – my little terminal watchdog that's still very much in its crawling baby stage.

https://github.com/sunels/heimdall

It's nowhere near perfect, but it already saves me a surprising amount of time every day.

If you ever feel the same frustration, give it a try.

Feedback, suggestions, or even a tiny PR would genuinely make me happy.

Thanks for reading,

Heimdall – How a Simple Port Error Turned into My Crazy Terminal Side Project

noreply@blogger.com (Serkan Sunel) — Sun, 22 Feb 2026 10:47:00 +0000

Hey folks,

Everything started because I got so tired of that classic Spring Boot error: “Port already in use”. Every time I had to hunt down the PID in the terminal, kill it manually, and pray it didn’t happen again five minutes later… ugh.

I was fed up scrolling through ss, netstat, lsof, ps — all that noise just to free a port during a busy workday.

Then things got out of hand (in a good way 😄).

I started building something small… and it kept growing. Now Heimdall is this beautiful curses-based TUI that watches ports, processes, files, risks — and even runs as a daemon in the background.

The coolest parts right now are Sentinel (it spots shady behavior like backdoors, masquerading processes, deleted binaries, suspicious listeners) and Daemon mode (it quietly monitors suspicious outbound connections, suspends the process, and asks you to allow or kill — either via a popup modal if the TUI is open, or a notification + timeout if not).

Whenever I think “hey, this would be cool to add”, I throw it at an AI agent while I still have tokens left 😂. Sometimes I just feel like the product owner who never stops adding features.

If you want to join the fun, check out the repo: https://github.com/sunels/heimdall

or https://pypi.org/project/heimdall-linux/

Give it a star, try it, break it, send feedback/PRs — I’d love to hear what you think (or what crazy feature I should add next).

Thanks for reading, stay safe out there!

Love, Serkan ❤️

Linux terminal tool for port process open files

noreply@blogger.com (Serkan Sunel) — Sat, 17 Jan 2026 22:46:00 +0000

Interactive terminal-based port, process, file, and resource inspector for Linux

portwitr-interactive is a high-performance, curses-based Terminal User Interface (TUI) designed to give you instant visibility and control over your Linux system — all from a single, interactive view.

Tool for sysadmins and developers

✨ Features

🔍 Live port listing using ss

⚡ Shows CPU% / MEM% usage per process

🧠 Maps PORT → PID → PROGRAM

⛔ Firewall toggle for selected port (temporarily block/unblock traffic)

📂 Displays all open files of the selected process (/proc/<pid>/fd)

🧾 Deep inspection via witr --port

🖥️ Fully interactive terminal UI (curses)

⚡ Real-time refresh

🛑 Stop a process or systemd service directly from the UI (with confirmation)

📝 Warnings annotation (e.g., suspicious working directory is flagged but explained)

Checkout and Play: https://github.com/sunels/heimdall

Installation: https://github.com/sunels/heimdall?tab=readme-ov-file#-installation

    wget https://github.com/sunels/heimdall/releases/download/v0.1.0/heimdall_0.1.0-1_all.deb
    sudo dpkg -i heimdall_0.1.0-1_all.deb

    Run:
    sudo heimdall
    
    # or just
    heimdall

TCP Socket: Accept, Buffer, 3 Ways Handshake Manim Animation Scripts

noreply@blogger.com (Serkan Sunel) — Sun, 10 Aug 2025 19:22:00 +0000

Ollama - open-webui - deepseek - CPU - local run

noreply@blogger.com (Serkan Sunel) — Sat, 25 Jan 2025 19:28:00 +0000

Conversations on it :

Let's build a mini-ChatGPT that's powered by DeepSeek-R1 (100% local):

Why do we need to run it locally when we can always run it from deepseek site?

Privacy mainly, You can run it from the site if you want but this is for companies or tech departments that want to run it locally and not worry about what data / info could be leaked

Okay, but why build your own front end when open webUI exists? I can build an identical local solution with 2 commands (ollama pull, docker run).

A company may want to incorporate it into their own site for specific purpose to incorporate their branding and feel

Various reasons, but yes if I was just messing with it I would just do what you mentioned

sunels@sunels:~$ docker run -d -p 3000:8080 -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

Unable to find image 'ghcr.io/open-webui/open-webui:ollama' locally

http://localhost:11434/

http://localhost:3000/

Settings

run distilled model

ollama run yasserrmd/DeepSeek-R1-Distill-Qwen-1.5B

Download and use Distilled DeepSeek Model within open-webui

Dont forget to fetch metadata from ollama before search/download

Distilled model thinking duration 3 min (original model took 11 mins)

MicroService ASYNC Communication via Message Brokers [Spring, RabbitMQ, Microservice]

noreply@blogger.com (Serkan Sunel) — Mon, 18 Mar 2024 11:18:00 +0000

UserService is Communicationg with Balance Service using rabbitMQ.

Async communication microservices

RabbitMQ DynamicQueue Names + replyTO semantic

REPO : https://github.com/sunels/RabbitSyncSpringDemo

USER SERVICE

@RabbitListener(queues = "#{dynamicQueueNameResolver.resolveResponseQueueName()}")
public void handleResponse(@Payload UserBalanceResponse response, org.springframework.amqp.core.Message message) {
    System.out.println("UserController Got a rabbit message = " + response);
    String correlationId = message.getMessageProperties().getCorrelationId();
    correlationIdResponseMap.put(correlationId, response);
    CountDownLatch latch = correlationIdLatchMap.get(correlationId);
    if (latch != null) {
        latch.countDown();
    }
}

@PostMapping("/get-user-balance")
public ResponseEntity<String> getUserBalance(@RequestBody UserRequest userRequest) throws InterruptedException {
    // Generate a correlation ID for the request
    String correlationId = UUID.randomUUID().toString();
    // Setup latch to wait for the response
    CountDownLatch latch = new CountDownLatch(1);
    correlationIdLatchMap.put(correlationId, latch);

    // Send request to the BalanceService with the correlation ID
    rabbitTemplate.convertAndSend("user_balance_request_queue", userRequest, message -> {
        message.getMessageProperties().setCorrelationId(correlationId);
        // Set replyTo to a dynamic queue based on correlation ID
        message.getMessageProperties().setReplyTo(dynamicQueueNameResolver.resolveResponseQueueName());
        return message;
    });
    System.out.println("UserController has SENT a rabbit message = " + userRequest);

    // Wait for response with a timeout
    latch.await(5, TimeUnit.SECONDS);
    correlationIdLatchMap.remove(correlationId);
    UserBalanceResponse userBalance = correlationIdResponseMap.remove(correlationId);

    if (userBalance != null) {
        return ResponseEntity.ok("User balance for user ID " + userRequest.getUserId() + " is: " + userBalance);
    } else {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Failed to get user balance for user ID: " + userRequest.getUserId());
    }
}

BALANCE SERVICE

@RabbitListener(queues = "user_balance_request_queue")
public void processBalanceRequest(UserRequest userRequest, Message requestMessage) {
    System.out.println("GOT userRequest = " + userRequest);
    // Simulate processing the balance request
    // In a real scenario, this could involve querying a database or external service
    String userBalance = "Balance for user " + userRequest.getUserId() + ": $123"; // Example balance

    // Construct the response object
    UserBalanceResponse response = new UserBalanceResponse(userRequest.getUserId(), userBalance);

    // Send the response back to the UserController using the replyTo queue specified in the request message
    rabbitTemplate.convertAndSend(requestMessage.getMessageProperties().getReplyTo(), response, message -> {
        message.getMessageProperties().
                setCorrelationId(
                        requestMessage.getMessageProperties().getCorrelationId()
                );
        return message;
    });
}

Got tired with Rust Borrow Checker ! Try WebAssembly instead :)

noreply@blogger.com (Serkan Sunel) — Fri, 02 Feb 2024 13:03:00 +0000

I needed to give a break to the figh with "Rust borrow checker" :) Just had some fun with Rust & Tensorflow & Webassembly - How ? - Ask to your favorite AI !

Caching with Spring

noreply@blogger.com (Serkan Sunel) — Sat, 23 Apr 2022 19:21:00 +0000

@Cachable: Runs before actual method invocation

@CachePut: Runs after the actual method invocation

Unless: works for return value

Condition: works for method parameter

@Cacheable(value = "saveCache", key = "{#a, #b, #c}", unless="#result.result.size() > 0")

@CachePut(value="defaultCache", key="#pk",unless="#result==null")

@Cacheable(value="actors", key="#key", condition="#key == 'sean'")

Rest Post Mock Intellij Mockoon

noreply@blogger.com (Serkan Sunel) — Tue, 02 Mar 2021 19:02:00 +0000

Easy test your endpoints within the Ide : there is a world icon on the rest controller click on it

Here you can add your sample request and run easily

If you need to mock some requests Mockoon is a very handy tool for it

Does given array contains a triplet (a^2 + b^2 = c^2) ?

noreply@blogger.com (Serkan Sunel) — Tue, 02 Feb 2021 20:10:00 +0000

SpringBoot StringKafkaTemplate Conductor Kafka Topic Producer Consumer

noreply@blogger.com (Serkan Sunel) — Thu, 28 Jan 2021 16:29:00 +0000

Wanna produce and consume from Kafka topics with SpringBoot ?

Wanna watch your Kafka Topics via Conductor ?

Wanna send some rest request to produce data to send your Kafka topic ?

Don't wanna write code ?

Get The Code

Just checkout and sit back :)

Your custom java annotation and check for it on the classes with reflection

noreply@blogger.com (Serkan Sunel) — Thu, 28 Jan 2021 16:02:00 +0000

Just another copy paste run bye article !

Java Maze Solver

noreply@blogger.com (Serkan Sunel) — Sun, 29 Nov 2020 16:13:00 +0000

AVL TREE LEFT RIGHT DOUBLE ROTATIONS, DEPTH FIRST SEARCHs, BREADTH FIRST SEARCH, RECURSIVE and ITERATIVE TRAVERSALS, HEIGHT, DEPTH, SIZE, LEAF, NODE FINDERS, ROOT to LEAF NODE PATHS

noreply@blogger.com (Serkan Sunel) — Wed, 18 Nov 2020 20:46:00 +0000

SINGLE ROTATION

DOUBLE ROTATION

Suppose the node to be rebalanced is X.

There are 4 cases that we might have to fix (two are the mirror images of the other two):

An insertion in the left subtree of the left child of X,
An insertion in the right subtree of the left child of X,
An insertion in the left subtree of the right child of X, or
An insertion in the right subtree of the right child of X.

Balance is restored by tree rotations.

Case 1 and case 4 are symmetric and requires the same operation for balance.

Cases 1,4 are handled by single rotation.

Case 2 and case 3 are symmetric and requires the same operation for balance.

Cases 2,3 are handled by double rotation

REDIS STREAM - CLI

noreply@blogger.com (Serkan Sunel) — Sun, 09 Feb 2020 21:58:00 +0000

DOCKER

docker run -it --rm --net host --name redis1 redis

docker exec -it redis1 redis-cli

XREADGROUP

XGROUP CREATE mystream mygroup $ MKSTREAM

XADD mystream * message apple

XADD mystream * message orange

XADD mystream * message strawberry

XGROUP CREATE mystream grp1 0

XREADGROUP GROUP grp1 Bob COUNT 2 STREAMS mystream >

XGROUP CREATE mystream grp2 0

XREADGROUP GROUP grp2 Bobiy COUNT 2 STREAMS mystream >

The special ID >. This special ID is only valid in the context of consumer groups, and it means: messages never delivered to other consumers so far.

XREAD

XADD mystream * message newcoronavirus

XADD mystream * message nextvirus

XREAD BLOCK 0 STREAMS mystream $

The special ID $. This special ID means that XREAD should use as last ID the maximum ID already stored in the stream mystream, so that we will receive only new messages, starting from the time we started listening. This is similar to the tail -f Unix command in some way.

Use ConsumerGroups for FANOUT

Use XREAD for P2P

Sample Simple Stupid Redis Message Queue Producer Consumer Example

noreply@blogger.com (Serkan Sunel) — Fri, 07 Dec 2018 13:47:00 +0000

Just Copy & Paste & Run...And Then Customize & Enhance...

Java 8 CompletableFuture parallel tasks and Timeout example

noreply@blogger.com (Serkan Sunel) — Sun, 02 Dec 2018 19:53:00 +0000

Suppose that you have a list of item (id list referring to a table, url list to fetch page data from internet, customer keys for location query from a map service etc...). And you will start some parallel tasks for those ids. But you don't want to wait no longer than your threshold. Also you want to collect the data from the returned "CompletableFutures" which are not timed out.

How can you achieve this while using a CompletableFuture ?

PS: There is no .orTimeout () option in Java 8. It is included in Java10. And other option is using .get(N, TimeUnit.SECONDS) but it will not gave you what you want.

Outputs :

pool-1-thread-1 - - > will sleep for secs :0

Duration here = 233

pool-1-thread-2 - - > will sleep for secs :1000

pool-1-thread-3 - - > will sleep for secs :2000

pool-1-thread-4 - - > will sleep for secs :3000

pool-1-thread-5 - - > will sleep for secs :4000

pool-1-thread-6 - - > will sleep for secs :5000

Collected Results = [0, 1000, 2000, 3000, 4000, 5000, null, null, null, null]

Total Duration = 5235

How did i come here :) See below code pls
In this example your main thread will be waiting 2 seconds for each uncompleted future.
I guess N*2 seconds waiting is not the thing that you expect to see here
And yes.. There is 20 seconds duration job and it is cancelled You have a minimal gain at that point but ! But if you would have 20 tasks ...The picture would be very nagative again .

Outputs :

ForkJoinPool.commonPool-worker-1 - - > will sleep : 0
ForkJoinPool.commonPool-worker-5 - - > will sleep : 4
ForkJoinPool.commonPool-worker-3 - - > will sleep : 2
ForkJoinPool.commonPool-worker-4 - - > will sleep : 3
ForkJoinPool.commonPool-worker-7 - - > will sleep : 6
ForkJoinPool.commonPool-worker-1 - - > will sleep : 5
ForkJoinPool.commonPool-worker-2 - - > will sleep : 1
ForkJoinPool.commonPool-worker-6 - - > will sleep : 7
Tasks are created here, duration = 79
Getting results
Getting results
Getting results
ForkJoinPool.commonPool-worker-2 - - > will sleep : 8
Getting results
ForkJoinPool.commonPool-worker-3 - - > will sleep : 9
Getting results
ForkJoinPool.commonPool-worker-4 - - > will sleep : 20
Getting results
Getting results
Getting results
Getting results
Getting results
Getting results
Total duration = 13080
CollectedResults = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, java.util.concurrent.TimeoutException]

weak wifi , remote jmx

noreply@blogger.com (Serkan Sunel) — Wed, 25 Jul 2018 15:39:00 +0000

................HOW TO SEE CONNECTION POOL STATS ON COMMAND LINE VIA JMX ............................

Tool page : https://nofluffjuststuff.com/blog/vladimir_vivien/2012/04/jmx_cli_a_command_line_console_to_jmx

wget https://github.com/downloads/vladimirvivien/jmx-cli/jmxcli-0.1.2-bin.zip
unzip jmxcli-0.1.2-bin.zip
cd jmxcli-0.1.2
java -jar cli.jar
cp /usr/lib/jvm/java-8-oracle/lib/tools.jar lib/
chmod 777 lib/tools.jar 
list filter:"com.mchange.v2.c3p0:type=PooledDataSource*" label:true
desc bean:$0
exec bean:"com.mchange.v2.c3p0:type=PooledDataSource[z8kflt9w1cicerh10mnh44|20c29a6f]" get:"numBusyConnections"
exec bean:"com.mchange.v2.c3p0:type=PooledDataSource[z8kflt9w1jggz5o1xv9pi5|2101f18a]" get:"numBusyConnections"

Evolve ....

noreply@blogger.com (Serkan Sunel) — Tue, 09 May 2017 07:55:00 +0000

Collections.sort(itemList, new Comparator<Item>() {
    @Override    public int compare(Item o1, Item o2) {
        return o1.getItemId().compareTo(o2.getItemId());    }
});

Collections.sort(itemList, (o1, o2) -> o1.getItemId().compareTo(o2.getItemId()));

Collections.sort(itemList, Comparator.comparing(Item::getItemId));

Java8 streams and lambda expression GroupBy MaxBy MinBy Example

noreply@blogger.com (Serkan Sunel) — Sun, 02 Apr 2017 12:16:00 +0000

How Hadoop works

noreply@blogger.com (Serkan Sunel) — Wed, 22 Mar 2017 12:17:00 +0000

Hadoop divides the given input file into small parts to increase parallel processing. It uses its own file system called HDFS. Each spitted file is assigned to the mapper which works on the same physical machine with the given chunk.

Mappers are processing small file chunks and passing their processing results to context.Mappers are processing splitted files (each chunk {piece of the main file} size = HDFS block size) line by line in the map function .

Hadoop supports different programming languages so it uses its own serilization/deseriliazation mechanism. That why you see IntWritable, LongWritable,etc types in the examples. You can write your own Writable classess by implementing the Writable interface according to your requirements.

Hadoop collects all different outputs of the mappers and sort them by KEY and forwards these results to Reducers.

"Book says all values with same key will go to same reducer"

map (Key inputKey, Value inputValue, Key outputKey, Value outputValue)

reduce (Key inputKeyFromMapper, Value inputValueFromMapper, Key outputKey, Value output value)

Hadoop calls reduce function for the each line of given file.

And finally writes the result of reducers to the HDFS file system.

See the WordCount example for better understanding : hadoop-wordcount-example

Kafka Basics, Producer, Consumer, Partitions, Topic, Offset, Messages

noreply@blogger.com (Serkan Sunel) — Fri, 10 Mar 2017 10:41:00 +0000

Kafka is a distributed system that runs on a cluster with many computers. Producers are the programs that feeds kafka brokers. A broker is a kafka server which stores/keeps/maintains incoming messages in files with offsets. Each message is stored in a file with an index , actually this index is an offset. Consumers are the programs which consumes the given data with offsets. Kafka does not deletes consumed messages with its default settings. Messages stays still persistent for 7 days with default configuration of Kafka.

Topics are the contracts between the producer and consumers. Producer pushes messages to a specific topic and consumers consumes messages from that specific topic. There can be many different topics and Consumer Groups which are consuming data from a specific topic according to your business requirements.

If topic is very large (larger than the storage capacity of a computer) then kafka can use other computers as a cluster node to store that large topic. Those nodes are called as partition in kafka terminology. So each topic may be divided in many partitions (computers) in the Kafka Cluster.

So how kafka make decisions on storing and dividing large topics in to the partitions ? Answer : It does not !

So you should make calculations according to your producer/consumer load, message size and storage capacity. This concept is called as partitioning. Kafka expect you to implement Partitioner interface. Of course there is a default partitioner (SimplePartitioner implements Partitioner).

As a result; A topic is divided into many partitions and each partition has its own OffSet and each consumer reads from different partitions but many consumers can not read from same partition to prevent duplicated reads.

If you need to collect specific messages on the specific partition you should use message keys. Same keys are always collected in the same partition. By the way those messages are consumed by the same Consumer.

Topic partitioning is the key for parallelism in Kafka. On both the producer and the broker side, writes to different partitions can be done fully in parallel. So it is important to have much partitions for a better Performance !

Please see the below use case which shows semantics of a kafka server for a game application's events for some specifics business requirements. All the messages related to a specific game player is collected on the particular partition. UserIds are used as message keys here.

I tried to briefly summarize it... I am planning to add more post about data pipelining with:

Hadoop->Kafka->Spark | Storm etc..

Bye

Images are taken from: Learning Journal and Cloudera

Scalable System Design Patterns

noreply@blogger.com (Serkan Sunel) — Mon, 06 Mar 2017 12:36:00 +0000

1) Load Balancer :

2) Scatter and Gather:

3) Result Cache :

4) Shared Space

5) Pipe and Filter

6) Map Reduce

7)Bulk Synchronous Parellel

8)Execution Orchestrator

REDIS 101

noreply@blogger.com (Serkan Sunel) — Fri, 03 Mar 2017 09:54:00 +0000

Client Libraries:

JRedis: https://github.com/alphazero/jredis

Jedis: https://github.com/xetorthio/jedis

lettuce: https://github.com/wg/lettuce

Data Types

1) Strings : BinarySafe: MAX 512 MB, you can even save images etc..
2) Set : Unique list of elements. Useful when operation on two different key with : intersect, union, difference
3) SortedSet

4) List
5) Hash : Useful for storing objects with fields. name, surname etc...

Pipelining : Less blocking client code can be achived by means of it : Send multiple request and get one answer as result. Consider: split them to multiple pipelines to reduce memory requirements on server side.using pipelining Redis running on an average Linux system can deliver even 500k requests per second.Is not it enough ?

Pub/Sub: implements org.springframework.data.redis.connection.MessageListener

Java 8 Optional examples and usage

noreply@blogger.com (Serkan Sunel) — Thu, 16 Feb 2017 10:55:00 +0000

Why Optional : Use it with streams , use it in your return types, make your code safer against to the NPE, make your code more readable...This allows the caller to continue a chain of fluent method calls.

And Note: The key here is the focus on use as a return type. The class is definitively not intended for use as a property of a Java Bean. Witness to this is that Optional does not implement Serializable, which is generally necessary for widespread use as a property of an object.

If you really wonder what will change in your life with this new Stolen keyword (from Guava) you'd better to read its origin.

More code & less bullshit.. Lets see its usage then..

And you can use in streams as follows