ilManzo's blog

Landlock idiomatic sandboxing in Nim

Thu, 09 Apr 2026 00:00:00 +0000

Harden linux programs using Linux Landlock

Rootless Podman as a Salt Lab Environment

Wed, 18 Mar 2026 00:00:00 +0000

🧂 Salt without the sudo

Follow-up from the previous post, today we are going to put our systemd-managed containers to work and use them for some useful tasks.

The idea is to set up an environment to learn how the configuration management Salt works, and play/hack around with it, without even needing root or sudo rights. After all, in the infra-world, the Salt must flow!

So we will setup two containers, one as a salt server and the other as a salt “minion” (representing the machine that will be configured via salt).

Zig Day 2026 recap

Sun, 22 Feb 2026 00:00:00 +0000

Small debriefing after coding event

A Friendly Guide to Podman Quadlets

Tue, 03 Feb 2026 00:00:00 +0000

🦎 Hi geekos!

If you’ve been running containers on your Leap or Tumbleweed machine, you probably started with podman run commands. Maybe you moved to Docker Compose files to manage stacks. Those are great tools, but they have a limitation, as they don’t integrate natively with systemd, your operating system’s init system.

When your server reboots, do your containers start back up automatically? If a container crashes, does it restart? How do you view its logs alongside your system journal?

A Headless Linux Router Build

Sat, 24 Jan 2026 00:00:00 +0000

👻 Void in the Basement

I have a basement, and I have a problem: no WiFi signal in said basement. I have also a piece of e-waste that refuses to die: a Samsung N130 netbook from 2009. It has a single-core Atom processor and 1GB of RAM. By modern standards, it can barely open a web browser. But for a Linux terminal, It’s a supercomputer. Instead of buying a generic ~10€ WiFi repeater, I decided to turn this little warrior into a fully programmable, secure, and transparent WiFi router using Void Linux. Here is exactly how I did it.

Automating OpenQA Job Cloning with Python and YAML

Wed, 07 Jan 2026 00:00:00 +0000

🎉 Happy New Year!

As anyone working with OpenQA knows, it is a powerful tool for automated testing. But sometimes, the workflow around re-triggering those tests for investigation purposes can feel a bit… Manual.

Recently, I found myself in a repetitive cycle while debugging complex test scenarios. My workflow looked something like this:

Take a known “good” job URL.
Open a scratchpad editor.
Craft a long openqa-clone-job command with tons of specific override parameters (BUILD=0, custom git branches, skipping specific modules, etc.).
Run the command in the terminal, wait for the output.
Painfully visual scan of the terminal output, to identify the newly created job URLs, and select them with my mouse, to copy them.
Paste them into openqa-mon or a text file to track their progress.

Till now I used a Bash script that kind of helped, but modifying giant arrays of arguments for every different debugging scenario was annoying and error-prone.

Advent of code 2025: the diaries

Mon, 01 Dec 2025 00:00:00 +0000

Having fun with Christmas code challenges

October 2025 conferences recap

Sat, 01 Nov 2025 00:00:00 +0000

Quick debriefing after autumn events

Automated files cleanup on Linux

Thu, 23 Oct 2025 00:00:00 +0000

🚮 Or: how I taught my Linux box to take out its own trash

From QEMU Headache to Headless

Sun, 28 Sep 2025 00:00:00 +0000

Taming a Command-Line Monster

my resume

Mon, 07 Jul 2025 00:00:00 +0000

curriculum vitae

June 2025 conferences recap

Sun, 29 Jun 2025 00:00:00 +0000

Quick debriefing after summer events

How much code are you testing ? (3)

Tue, 17 Jun 2025 00:00:00 +0000

Using Intel PIN to measure test coverage on binaries

Refactoring the D Koans with metaprogramming

Wed, 21 May 2025 00:00:00 +0000

How metaprogramming helped create a cleaner testing experience for D Koans

How much code are you testing ? (2)

Sun, 30 Mar 2025 00:00:00 +0000

Measuring test coverage on binaries

How much code are you testing ? (1)

Sun, 23 Feb 2025 00:00:00 +0000

Measuring coverage of integration tests

Systemd Socket Activation Explained

Sun, 02 Feb 2025 00:00:00 +0000

Stop Wasting Resources: how to start your services on demand

Writing shell filters for fun and profit

Sun, 19 Jan 2025 00:00:00 +0000

An utility to simplify monitoring openqa job clones

Debriefing Advent of Code 2024

Thu, 26 Dec 2024 00:00:00 +0000

A personal recap of Advent of Code 2024

Wrapping up GoLab 2024

Fri, 15 Nov 2024 00:00:00 +0000

Personal recap of GoLab 2024 conference

Linux Test Project part 2

Sun, 27 Oct 2024 00:00:00 +0000

Follow-up on LTP: the test options

Wrapping up ContainerDay 2024

Fri, 11 Oct 2024 00:00:00 +0000

Highlights from Italian ContainerDay 2024 conference

The Linux kernel ftrace

Tue, 01 Oct 2024 00:00:00 +0000

Overview of the Linux kernel tracing feature

Testing a cheap MicroSD card quality

Tue, 03 Sep 2024 00:00:00 +0000

Some basic checks to ensure you bought a good storage for your files

Playing with Linux kernel capabilities

Fri, 02 Aug 2024 00:00:00 +0000

What are and how to use the Linux kernel capabilities

Measure your program's power consumption

Sun, 30 Jun 2024 00:00:00 +0000

Understand how much power you are using

Headless Testing of PySide/PyQt GUI Applications with pytest-qt

Wed, 22 May 2024 00:00:00 +0000

An approach to headless testing of GUI programs

A different approach to terminal user interfaces

Fri, 03 May 2024 00:00:00 +0000

First steps with Bubble Tea, a Go TUI framework

SEGFAULT: Debugging a crashing application

Fri, 05 Apr 2024 00:00:00 +0000

What's a core dump and how to use it for debugging ?

Osday 2024 recap

Mon, 11 Mar 2024 00:00:00 +0000

Quick debriefing after a cool event in Florence

Playing with Rust on ARM architecture

Fri, 01 Mar 2024 00:00:00 +0000

Easy cross compilation for everyone

First steps with Linux Test Project

Sat, 10 Feb 2024 00:00:00 +0000

How the Linux Kernel is tested, one syscall at a time

Introduction to packaging Rust application

Fri, 19 Jan 2024 00:00:00 +0000

How to package a Rust application on openSUSE

Fault Injection in Network Namespace and Veth Environments

Sat, 06 Jan 2024 00:00:00 +0000

How to improve your software by simulating a faulty network device

Expect the unexpected

Sun, 19 Nov 2023 00:00:00 +0000

How to improve your software by simulating a faulty block device

A trip on the rusty D-Bus

Wed, 04 Oct 2023 00:00:00 +0000

How to expose a D-Bus service and create a simple client writing some Rust code

Quiet fans on Thinkpad P15

Fri, 01 Sep 2023 00:00:00 +0000

How to lower the default fan noise on Thinkpad P15 Gen2

Using containers for unit testing of bash functions

Thu, 17 Aug 2023 00:00:00 +0000

How to create an isolate environment to safely test your bash scripts

Embed git commit hash into an executable

Sat, 01 Jul 2023 00:00:00 +0000

How to insert the current HEAD commit hash in a binary

Old-School demo effects with Crystal

Thu, 18 May 2023 00:00:00 +0000

revisiting old code with a new programming language

Benchmarking a Rust function

Sun, 02 Apr 2023 00:00:00 +0000

A first look at Rust performance benchmarking

Debugging a problematic build

Tue, 14 Mar 2023 00:00:00 +0000

A technique to inspect Open Build Service build process

a SUSE hackweek22 report

Fri, 03 Feb 2023 00:00:00 +0000

writeup about learnings and achievements in last SUSE hackweek

compare package version across distros

Mon, 09 Jan 2023 00:00:00 +0000

a tool to check if an openSUSE package version is up to date against other distros

get update info about packages

Thu, 24 Nov 2022 00:00:00 +0000

a simple wrapper to get last update date on a package

get notifications about openQA job status

Wed, 05 Oct 2022 00:00:00 +0000

how to receive notification about your openQA job status update

web components with Nim and Karax

Thu, 07 Jul 2022 00:00:00 +0000

how to create a simple web component in a Karax web application

automate OTP credentials for multi-factor authentication

Tue, 14 Jun 2022 00:00:00 +0000

automate generation of OTP for multi-factor authentication

linux resource control with cgroups

Tue, 03 May 2022 00:00:00 +0000

using systemd slices to manage resources

integration between Python and Rust - Part 2

Fri, 07 Jan 2022 00:00:00 +0000

some experiments with language FFI

integration between Python and Rust - Part 1

Wed, 18 Aug 2021 00:00:00 +0000

some experiments with language FFI

playing with eBPF interface - 2

Wed, 19 May 2021 00:00:00 +0000

some fun experiments with tracing and snooping linux kernel

playing with eBPF interface - 1

Tue, 11 May 2021 00:00:00 +0000

some fun experiments with tracing and snooping linux kernel

a 'pythonic' fileinput module for the D programming language

Mon, 25 Jan 2021 00:00:00 +0000

an implementation of a custom iterator similar to Python's fileinput

Writing Python modules in Nim

Sat, 05 Dec 2020 00:00:00 +0000

how to write a Python module using the Nim programming language

A new project to learn the Crystal Programming Language

Fri, 20 Nov 2020 00:00:00 +0000

learn the crystal programming language by solving simple exercises

Hijack C library functions in D

Tue, 10 Mar 2020 00:00:00 +0000

I like playing with the D programming language and I wrote this little post to show how it’s easy to create a dynamic library (shared object, .so) that can be invoked in other programs; to have a little fun we will write a D replacement for the rand() C standard library function call. For your convenience, all the code is also on github

Let’s start with the demo implementation, a C program that calls 10 times the stdlib function rand() to get a random number.

a very simple NTP client in D

Thu, 20 Feb 2020 00:00:00 +0000

I am quite a fan of the D programming language and I think it deserves more attention, even if since a few months it’s becoming more and more popular, as it gained top20 in the TIOBE Index for February 2020.

As an experiment in network programming, I took this simple NTP client written in C and translated to D ; in my opinion while it’s keeping the low-level nature, it’s shorter, clearer and more effective. It’s only a dozen lines of code, but full program is available on my github; stars and contributions are welcome!

migrating a repository from mercurial to git

Sun, 15 Dec 2019 00:00:00 +0000

Since bitbucket is sunsetting the support for mercurial repositories, I wrote a quick and dirty script to automate the migration from mercurial to GIT:

#!/bin/bash
set -e
set -u

if [ "$#" -ne 3 ]; then
 echo "Illegal number of parameters"
 echo "usage: migrate.sh reponame hgrepourl gitrepourl"
 exit 1
fi

REPONAME=$1
HGURL=$2
GITURL=$3

echo "Migrating $REPONAME from $HGURL to $GITURL..."

cd /tmp
hg clone $HGURL
cd $REPONAME
hg bookmark -r default master
hg bookmarks hg
cd ..
mv $REPONAME ${REPONAME}_hg
mkdir ${REPONAME}_git
cd ${REPONAME}_git
git init --bare .
cd ../${REPONAME}_hg
hg push ../${REPONAME}_git
cd ../${REPONAME}_git
git remote add hgmigrate $GITURL
git push hgmigrate master
cd /tmp
rm -rf /tmp/${REPONAME}_hg /tmp/${REPONAME}_git
echo "...done"

Before running the script, you only need to install git and create a git repository (remote or local).

il linguaggio Lua: parte 14

Fri, 15 Feb 2019 00:00:00 +0000

introduzione al linguaggio Lua

il linguaggio Lua: parte 13

Sat, 19 Jan 2019 00:00:00 +0000

introduzione al linguaggio Lua

il linguaggio Lua: parte 12

Wed, 24 Oct 2018 00:00:00 +0000

introduzione al linguaggio Lua

il linguaggio Lua: parte 11

Fri, 07 Sep 2018 00:00:00 +0000

introduzione al linguaggio Lua

il linguaggio Lua: parte 10

Fri, 03 Aug 2018 00:00:00 +0000

introduzione al linguaggio Lua

a honeypot ssh server in Go

Tue, 26 Jun 2018 00:00:00 +0000

a fake ssh server that works as a honeypot, written in Go

il linguaggio Lua: parte 9

Fri, 22 Jun 2018 00:00:00 +0000

introduzione al linguaggio Lua

il linguaggio Lua: ottava parte

Mon, 23 Apr 2018 00:00:00 +0000

introduzione al linguaggio Lua

il linguaggio Lua: settima parte

Sat, 03 Mar 2018 00:00:00 +0000

introduzione al linguaggio Lua

a simple PNG decoder in Go

Sun, 28 Jan 2018 00:00:00 +0000

while working with image files, I needed a simple way to analyze content of a picture; so I wrote this tool that “walks” inside a PNG file and reports all the chunks seen; this is intended to be expanded with more features in a future.

package main

import (
 "encoding/binary"
 "fmt"
 "io"
 "os"
)

type chunk struct {
 Length uint32
 ChunkType [4]byte
}

func main() {
 if len(os.Args) != 2 {
 fmt.Printf("Usage: %s filename.png\n", os.Args[0])
 os.Exit(1)
 }
 f, err := os.Open(os.Args[1])
 if err != nil {
 panic(err)
 }
 defer f.Close()
 header := make([]byte, 8)
 _, err = f.Read(header)
 fmt.Printf("header: %v\n", header)
 if err != nil {
 panic(err)
 }
 var data chunk
 var offset int64
 offset = 8
 for {
 err = binary.Read(f, binary.BigEndian, &data)
 if err != nil {
 if err == io.EOF {
 break
 }
 panic(err)
 }
 fmt.Printf("Offset: %d chunk len=%d, type: %s\n", offset, data.Length, string(data.ChunkType[:4]))
 f.Seek(int64(data.Length+4), io.SeekCurrent)
 offset += int64(data.Length) + 4
 }
}

usage:

il linguaggio Lua: sesta parte

Fri, 22 Dec 2017 00:00:00 +0000

introduzione al linguaggio Lua

linux: how to access DHCP options from client

Mon, 06 Nov 2017 00:00:00 +0000

how to access DHCP options from client

il linguaggio Lua: quinta parte

Mon, 16 Oct 2017 00:00:00 +0000

introduzione al linguaggio Lua

il linguaggio Lua: parte 4

Tue, 11 Apr 2017 00:00:00 +0000

introduzione al linguaggio Lua

il linguaggio Lua: parte 3

Mon, 20 Mar 2017 00:00:00 +0000

introduzione al linguaggio Lua

convert a binary file to ascii using hexdump

Thu, 20 Oct 2016 00:00:00 +0000

convert a binary file to ascii using hexdump

playing with Crystal Programming Language

Tue, 11 Oct 2016 00:00:00 +0000

exploring new languages

a simple HTTP rewriting proxy

Fri, 12 Aug 2016 00:00:00 +0000

This is an example of using goproxy, a fast and robust multithread proxy engine to develop an HTTP proxy that rewrites content on the fly, with multiple search and substitutions. It can be useful for debugging and other less noble (but useful) purposes …

// rewriting_proxy project main.go
package main

import (
 "bytes"
 "flag"
 "io/ioutil"
 "log"
 "net/http"

 "github.com/elazarl/goproxy"
)

var replacements = []struct {
 from []byte
 to []byte
}{
 {[]byte("#e8ecec"), []byte("Red")}, // ugly colors!!
 {[]byte("Comic Sans MS"), []byte("Lucida Sans Unicode")}, // for eyes sanity
 {[]byte("Java "), []byte("Golang ")}, // just joking
}

func myHandler(resp *http.Response, ctx *goproxy.ProxyCtx) *http.Response {
 readBody, err := ioutil.ReadAll(resp.Body)
 if err != nil {
 //TODO handle read error gracefully
 return resp
 }
 resp.Body.Close()
 for _, elem := range replacements {
 readBody = bytes.Replace(readBody, elem.from, elem.to, -1)
 }
 resp.Body = ioutil.NopCloser(bytes.NewReader(readBody))
 return resp
}

func main() {
 verbose := flag.Bool("v", true, "should every proxy request be logged to stdout")
 proxy := goproxy.NewProxyHttpServer()
 proxy.Verbose = *verbose
 proxy.OnResponse().DoFunc(myHandler)
 log.Fatal(http.ListenAndServe(":8081", proxy))
}

wrapping c plus plus classes in Python

Mon, 08 Aug 2016 00:00:00 +0000

This is a quick and dirty way to interface C++ code with Python, translating one or more C++ classes in Python objects.

First, we need some c++ sample code:

//myclass.h
#ifndef MYCLASS_H
#define MYCLASS_H

#include <string>

using namespace std;

namespace pets {
 class Dog {
 public:
 Dog(string name, int age);
 virtual ~Dog();
 string talk();
 protected:
 string m_name;
 int m_age;
 };
}

//myclass.cpp
#include "myclass.h"

#include <string>

namespace pets {

 Dog::Dog(std::string name, int age):
 m_name(name),m_age(age) { }

 Dog::~Dog() { }

 std::string Dog::talk() {
 return "BARK! I am a DOG and my name is "+m_name;
 }
}

now, we can try a little test program just to exercise our class:

il linguaggio Lua: parte 2

Tue, 24 May 2016 00:00:00 +0000

introduzione al linguaggio Lua

how to automatically expire mysql records after a fixed amount of time

Thu, 05 May 2016 00:00:00 +0000

how to automatically delete mysql records after an amount of time

il linguaggio Lua: prima parte

Wed, 13 Apr 2016 00:00:00 +0000

introduzione al linguaggio Lua

monit helper for quota monitoring in go

Wed, 30 Mar 2016 00:00:00 +0000

a small program to parse quota information and report via monit

simple and easy linux job queue

Mon, 21 Dec 2015 00:00:00 +0000

exploiting linux printing queue facility to manage heterogeneous jobs

serata introduttiva al FabLab sulla programmazione Python

Thu, 19 Nov 2015 00:00:00 +0000

Pubblico qui le slide che ho usato durante la serata dedicata alla programmazione Python, svoltasi presso il FabLab Verona

http://ilmanzo.github.io/files/slide_serata_python_fablab_2015.html

CGI with the Go Programming Language

Thu, 29 Oct 2015 00:00:00 +0000

standard library of the Go Programming Language: CGI and templates

sample template usage in the Go Programming Language

Wed, 30 Sep 2015 00:00:00 +0000

how to use the standard library template of the Go Programming Language

redirect output of an already running process

Fri, 24 Apr 2015 00:00:00 +0000

how to store standard output/error of a process after the execution

Sincronizzare una directory tra due server linux

Fri, 20 Mar 2015 00:00:00 +0000

Sincronizzare una directory tra due server linux

A new project to learn the D Programming Language

Sun, 07 Dec 2014 00:00:00 +0000

learn D programming language by solving simple exercises

monitor apache performance statistics

Wed, 05 Nov 2014 00:00:00 +0000

how to use apache mod_status to collect performance statistics

Linux: get simple I/O statistics per process

Fri, 22 Aug 2014 00:00:00 +0000

I had a trouble with a long process running and wish to know how much I/O this process is doing, so I wrote this quick and dirty python 2.x script:

import time,sys,datetime

def read_stat(pid):
 f=open("/proc/%s/io" % pid ,"r")
 for line in f:
 if line.startswith('rchar'):
 rchar=line.split(':')[1]
 continue
 if line.startswith('wchar'):
 wchar=line.split(':')[1]
 continue
 f.close()
 return int(rchar),int(wchar)

pid=sys.argv[1]
r0,w0 = read_stat(pid)

while 1:
 time.sleep(1)
 r1,w1 = read_stat(pid)
 print "%s\t\tr=%s\t\tw=%s" % (datetime.datetime.now().time(),r1-r0,w1-w0)
 r0,w0=r1,w1

You must give the process PID number as input to the script. In the output you get the read/write throughput of the process in bytes per second, for instance:

how to setup disk redundancy with BTRFS filesystem

Wed, 09 Jul 2014 00:00:00 +0000

how to setup disk redundancy with BTRFS filesystem

Compress and encrypt your backups

Wed, 11 Jun 2014 00:00:00 +0000

How to securely backup your files in a remote location

how to display the IP address of a virtual machine before logon

Mon, 05 May 2014 00:00:00 +0000

a small trick to save time when using linux virtual machines

dovecot: cleaning old Spam and Trash messages after some days

Wed, 05 Mar 2014 00:00:00 +0000

a script to do maintenance of a small number of mail folders

number of physical sockets and cpu cores

Sat, 14 Sep 2013 00:00:00 +0000

how to find out how much your next licence will cost...

Automate Cisco ssh connections with plink in Windows

Mon, 27 May 2013 00:00:00 +0000

A quick and dirty way to send a bunch of commands to any ssh device (in my case, Cisco appliances)…

create a plain old batch file with commands echoed inside:

 @echo off
 echo ter len 0
 echo show ver
 echo show clock
 echo exit

execute the batch, piping its output to plink.exe (putty command link ssh client):

 c:\> commands.bat | plink -ssh -l username -pw password 11.22.33.44

semplice rate limit in Sinatra

Fri, 21 Dec 2012 00:00:00 +0000

Giocando con Sinatra ho avuto l’esigenza di servire una determinata pagina solo con un certa frequenza (tecnicamente un rate-limit); la cosa si puo’ fare installando il middleware Rack:Throttle ma non volevo aggiungere un’altra gemma alle dipendenze…

In questo esempio se al server arriva piu’ di una richiesta in un intervallo di cinque secondi, rispondiamo a tono…

SECONDS_BETWEEN_REQUEST=5

enable :sessions

def ratelimit?
 now=Time.new.to_i
 session['lastrequest']||=0 #inizializza se non presente
 result=(now-session['lastrequest'])<SECONDS_BETWEEN_REQUEST #passati dall'ultima richiesta ?
 session['lastrequest']=now # aggiorna
 return result
end

get '/' do
 if ratelimit?
 return "<h1>sorry, rate limit exceeded!</h1>"
 end
 "<h1>hello!</h1>"
end

run-parts e problemi di crontab

Thu, 06 Dec 2012 00:00:00 +0000

Mi e’ capitato di inserire degli script nelle varie directory /etc/cron.daily, /etc/cron.weekly ma di scoprire che questi script non vengono eseguiti. Il motivo e’ che il run-parts usato nelle Debian e derivate ignora i file che contengono un “.” (e quindi tutti quelli con l’estensione)

Questo comportamento e’ documentato anche nella man page, e previene alcuni inconvenienti come l’esecuzione dei .bak ma lo scrivo anche qui per ricordarmelo … E forse potra’ essere utile a qualcun altro :)

generare comandi di creazione utenze a partire da un passwd

Fri, 23 Nov 2012 00:00:00 +0000

A volte e’ necessario replicare le utenze con gli stessi parametri su piu’ server linux diversi.

Perche’ farlo a mano ? Se sono tanti e’ un lavoro noioso e potremmo anche commettere degli errori.

Ecco un semplice one-liner che fa il parsing di un file /etc/passwd e genera i corrispondenti comandi useradd

awk -F: '{printf "useradd -m -u%s -g%s -d%s -s%s %s\n" , $3,$4,$6,$7,$1}' /etc/passwd

Ovviamente l’output puo’ essere comodamente filtrato con grep, usato via copy&paste, inserito in uno script, eccetera…

gestire i led delle schede PC Engines ALIX in Ruby

Fri, 09 Nov 2012 00:00:00 +0000

Natale si avvicina: mentre smanettavo su queste ottime PC Engines ALIX su cui ho installato una Debian modificata, ho scritto una comoda interfaccia per accendere/spegnere e far lampeggiare i led alla velocita’ desiderata…

class Led
 #numero da 1 a 3
 def initialize(ledno)
 ledno++ # passo 0 ma comando 1
 ledno=1 if ledno<1
 ledno=3 if ledno>3
 @ledsyspath="/sys/devices/platform/leds_alix2/leds/alix:#{ledno}/"
 end
 def blink(millisec)
 File.open(@ledsyspath+'trigger','w') { |f| f.write('timer') }
 File.open(@ledsyspath+'delay_off','w') do |f|
 f.write(millisec.to_s)
 end
 File.open(@ledsyspath+'delay_on','w') do |f|
 f.write(millisec.to_s)
 end
 end
 def blink_slow!
 blink(500)
 end
 def blink_fast!
 blink(50)
 end
 def on!
 File.open(@ledsyspath+'trigger','w') { |f| f.write('default-on') }
 File.open(@ledsyspath+'brightness','w') do |f|
 f.write('1')
 end
 end
 def off!
 File.open(@ledsyspath+'trigger','w') { |f| f.write("none") }
 File.open(@ledsyspath+'brightness','w') do |f|
 f.write('0')
 end
 end
end

background tasks in Ruby e linux

Mon, 05 Nov 2012 00:00:00 +0000

A volte negli script Ruby ho bisogno di controllare l’esecuzione di un comando eseguito in modalita’ asincrona, ho creato pertanto una classe apposita:

class BackgroundJob

 def initialize(cmd)
 @pid = fork do
 # this code is run in the child process
 # you can do anything here, like changing current directory or reopening STDOUT
 exec cmd
 end
 end

 def stop!
 # kill it (other signals than TERM may be used, depending on the program you want
 # to kill. The signal KILL will always work but the process won't be allowed
 # to cleanup anything)
 Process.kill "TERM", @pid
 # you have to wait for its termination, otherwise it will become a zombie process
 # (or you can use Process.detach)
 Process.wait @pid
 end

end

come si usa ? Molto semplice:

Enerduino

Sat, 03 Nov 2012 00:00:00 +0000

il porting del progetto per il nuovo IDE Arduino 1.0

Linux Day 2012

Sat, 03 Nov 2012 00:00:00 +0000

Anche quest’anno ho avuto il piacere di partecipare al Linux Day, organizzato per Verona presso la sede del LUG Verona in via dei Gelsi a Montorio; Ho tenuto una breve presentazione su un argomento che mi sta a cuore: partecipare attivamente alla comunita’ del software libero, perche’ anche se ormai Linux e Il free software hanno una discreta diffusione, la maggior parte degli utenti si limita all’utilizzo passivo e anzi spesso si lamenta per la scarsa qualita’ del software open. Il software libero NON e’ solo avere programmi gratis! Vorrei invitare chiunque a “passare dall’altra parte” e abbandonare il comodo stato di “spettatori” per cominciare a dare il proprio contributo, ognuno per quello che puo'.