Posts

How to make responsive GTK+ applications

Image
Introduction
This weekend I've made a GTK+ application, I've done my best to make it responsive by applying my old Android development experience.

Android make it clear that you should not block UI thread (main thread) not non-UI tasks like:

disk IO (read a file)network IO (request remote API)internal SQLite databaseintensive computations  Let me quote:

"You should not perform the work on the UI thread, but instead create a worker thread and do most of the work there."

private class MyTask extends AsyncTask... { protected Long doInBackground(URL... urls) { // worker thread } protected void onProgressUpdate(Integer... progress) { // ui thread } protected void onPostExecute(Long result) { // ui thread } }
GTK+ GTK+ is not threadsafe, in the sense all calls to GTK+ should be from a single thread that is the main thread or the UI thread, which seems similar to Android.

We have a class that loads the glade XML files and show the main …

DIY Docker using Skopeo+OStree+Runc

Image
Docker is awesome, but what is even more awesome about UNIX philosophy is that you can use combine small tools to create a something that work like docker.

Actually Dockerlite used BTRFS and LXC to make a toy version of docker.

In this post we are going to discuss show how one can pull a Docker image and run the containers without a docker daemon, of course we do this for fun.

We are going the achieve the following:


ability to pull docker imagesspace efficient  storage of images and containerseven better that docker (not just reuse layers, but even files)run the container We are going to use OSTree: content addressable storage, git-like for OS Images, space efficient and uses hardlinksSkopeo: a way to pull all kinds of images and convert them to all kinds of storageRunc (or any OCI runtime like bubble wraps oci) In this post we are going to run everything as non-root regular user (to make it even more challenging)
let's create a bare OSTree storage (similar to bare git), which stor…

Making minimal graphical operating system

Image
Back in my first days of Linux I had a bootable floppy disk with fully functional Linux distro (a kernel, a shell and busybox tools and lua scripting). Maybe that was not much, but it was less than 2MB and would work on an old 386 PC with 4MB of RAM. But shell is boring, graphical minimal Linux distros was several hundreds of mega bytes and need hundreds of MB of RAM.

Embedded devices typically have a minimal Linux with busybox or alike running with no graphical interface but instead they have some sort of web interface exposed to some port.

If you tried to run a minimal graphical Linux distro let's say XFCE on an embedded device (let's say a raspberry pi) you would notice that most of its limited resources are taken by Xorg the legacy graphical server.

Introducing Wayland Wayland is a new different approach to graphical interface, instead of sending drawing instruction over a legacy protocol (with so many extensions) to a legacy daemon (with so many extensions) that most of …

Summary of kubernetes features and terminologies

Image
Introduction Kubernetes had won the container orchestration war. Here is a summary of its features. It's an API, command line and UI. It uses etcd to keep its state. Every thing is done via Yaml or JSON (your choice). GeneralNode: a machine or instance (used to be called "minion")Namespace: a grouping of resourcesLabel: a tag applied to a resource ex. role=frontendAnnotations: another form of meta data  WorkloadsContainer (spec): the building block of deployable service or runnable task using linux containers ex. docker image and params to pass at runtime. Typically created in a Pod see belowPod (spec): one of more containers scheduled to nodes together and thus can share volumes. Most common pods have a single container but there are use cases for more (ex. nginx and php-fpm) . If you replicate a pod to have 3 replicas it would have 3 nginx and 3 php-fpm. If php-fpm created a file in the volume, nginx can see it. Typically created on its own or by controllers like a Re…

Bootstrapping Alpine Linux QCow2 image

IntroductionAlpine Linux is a minimal distro with package manager (APK) that is based on busybox and musl library. Like the CirrOS, it's very lightweight, but unlike it, it's full featured. In case you don't know me, my Linux distro of choice is Fedora/CentOS, in this post I'm going to bootstrap a QCow2 cloud image of Alpine Linux on my distro of choice.


Using docker to bootstrap a working chroot Type mkdir alpine35-root docker run --rm -ti -v $PWD/alpine35-root:/data alpine:3.5 apk --arch x86_64 -X http://nl.alpinelinux.org/alpine/v3.5/main/ -U --allow-untrusted --root /data --initdb add alpine-base 
and you should get a line like this
OK: 6 MiB in 16 packages
so now we have a working alpine chroot in the directory alpine35-root
Creating Bootable QCoW2 Image Because I don't want to format my hard disk by mistake and because I know Murphy's law, I'll take those 6MB as tarball and continue on a VM.
dd if=/dev/zero of=alpine.raw bs=1M seek=511 count=1 dd if=…

Let systemd manage your running of unprivileged scripts

Image
Instructions
let's save a text file named "test.sh" having the following content


#! /bin/bash for i in `seq 50` do    echo $i    sleep 1 done

it just print number from 1 to 50 second by second (you can change 50 to any number) now as regular user type

chmod +x ./test.sh systemd-run --user --unit=my-test ./test.sh 
the above command will run the script as a user service called my-test
at any time you can trace it with systemctl and see the logs using journalctl like this

journalctl -ln 100 -f --user-unit=my-test systemctl --user status my-test
you can abort it using

systemctl --user stop my-test


Use cases
Let's assume you have a web interface that trigger something and you want to trace it later just make your unprivileged web application (written in php/python and running as regular non-root user) called "systemd-run --user" and query the status and follow the logs using systemctl and journactl
for example if you have a web interface that triggers building…

playing with "unc" the unprivileged user containers

Image
Introduction
If you are familiar with docker then you are going to love this little hack. UNC is a tool to demonstrate how to launch containers without being root.

Getting the code and compiling it git clone https://github.com/LK4D4/unc.git
cd unc
mkdir -p gopath/src/
ln -s ../.. gopath/src/unc
export GOPATH=$PWD/gopath
cd gopath/src/unc
go get
go build
cd unet
go build
cd ..
sudo cp unc unet/unet /usr/local/bin/
sudo chmod u+s /usr/local/bin/unet

What is SetUID for? "unet" is a tool used "unc" that creates veth pairs and assign one of them to container. Root user (via setuid) is needed to be able to assign a network interface for the user container.


Creating some minimal root filesystems sudo dnf install busybox # as regular unprivileged user type mkdir -p roots/busybox1/{bin,sbin,proc,dev,etc} cp /sbin/busybox roots/busybox1/sbin/ echo "root:x:0:0:root:/root:/bin/bash" > roots/busybox1/etc/passwd echo "root:x:0:" > roots/busybox1/etc/gr…