Linux on Miek Gieben

Uncloud Prometheus

Sun, 26 Apr 2026 18:22:52 +0200

Prometheus metrics are being worked on by me, and will hopefully soon be merged in Uncloud.

The uncloudd metrics endpoint is exposed into the cluster network, so this makes it possible for a Prometheus service running inside the cluster to scrape it. For this it just needs to be able to access the API to get all machines in the cluster. This can be done by mounting the uncloud socket inside the container, and using uc with structured output.

Uncloud L4

Sat, 25 Apr 2026 13:21:52 +0200

Natively Uncloud doesn’t do L4 forwarding. This is an open issue as we are figuring out how to actually do this. But it turns out you can already do this with the current code - well almost.

Buckle up, because there is quite some stuff you may need:

A patched Uncloud, see this PR for that.
A custom Caddy build, with the L4 plugin.
A DNS server, I use atomdns of course.

Caddy

With the following Dockerfile you create a custom caddy image that we will use.

Uncloud Private Registries

Tue, 14 Apr 2026 19:31:00 +0200

While pushing this PR, the answer was that this was already working! But kind of unintuitive, but smart as it re-uses whatever docker setup you got (i.e. credentials helpers).

So to get this working you:

% docker login registry.science.ru.nl
Username: bla
Password:
...

And then use uc deploy -f .../compose.yml just like you did before. Now it should pull from the private repo and things “just work”.

See this guide for canonical text on this.

Uncloud

Mon, 16 Mar 2026 14:00:40 +0100

I’m playing with Uncloud to see if it is something we can use at $WORK. Pretty impressed with it already, as I’ve written something worse pgo, that was (obviously) not good enough. Uncloud does: implement a subset of the Docker(-compose) API, uses gRPC and wireguard to create mini network; just brilliant. Haven’t seen prometheus metrics yet, although Caddy is used for the proxy, but more prometheus metrics would make sense. (Which you can then observe through a cluster hosted prometheus…?)

PAM unixsock

Fri, 14 Mar 2025 12:14:47 +0100

Ever felt the need to do something with PAM, like implementing 2FA in SSH? You are left with a few bad choices, among others you’ll need to write something (complex) in C. I rather not do that, so I’ve created pam-unixsock.

This is tiny, the most trouble I had with concatenating strings with a space in between, because, you know, C. Anyway tiny. It doesn’t do much and gets you into another language quickly!

Format Go HTML templates

Wed, 19 Feb 2025 15:20:33 +0100

Because I was fed up with the lack of options (none), I write a tool that can format Go HTML templates: you can find it here. Includes screenshots!

Formatting Go text templates is pure madness, but the above code works well on HTML templates. If have find issues or need more functionality open a PR against the repo.

Have this in neovim:

au FileType gohtmltmpl command! Fmt silent %!gotmplfmt
au FileType gohtmltmpl let &l:formatprg="gotmplfmt"

Update 2025-05-31

In my new neovim setup (with conform.lua) I have this:

Matchup in Neovim for Go templates

Sat, 07 Dec 2024 12:04:24 +0100

After dealing with Go templates (also HTML templates) for more than a year and keep loosing track of where each block {{end}}s I finally did something about it.

But that didn’t work that good. So I’ve switch to the match-up plugin, which is better than the built-in matchit that I was using previously. With Neovim I’m using this setup:

Plug 'andymass/vim-matchup'

And this extra bit of config:

require'nvim-treesitter.configs'.setup {
  matchup = {
    enable = true,
  },
}

This in itself does not make template matching work, for this I just copied the Hugo template matcher (which is just like Go templating) to the correct place. Doing this with some automation from inside Neovim:

eBPF from Go - IV - Code generation

Mon, 28 Oct 2024 15:47:08 +0200

Played more with TinyGo, but it always generates code for (minimal) reflection - i.e. the reflect package, because it requires that for its map implementation. I could skip or not generate that, but then that would mean using a map would be … weird? Anyhow it looked that even TinyGo does too much for eBPF. So plan D: generate eBPF code (and Go code) using Go. Cilium has done a lot of work in this regard.

eBPF from Go - III - Reducing the SSA

Mon, 30 Sep 2024 15:47:08 +0200

Again some progress. I’m mostly focussing on removing code from the SSA representation (-internal-dumpssa), so that I can work with a clean slate. As BPF is so limited almost none of the features from Go make sense, although in some far fetched future it would be super cool to have channels and goroutines to something in BPF - but not today. First need to get to “Hello World”.

I’m building this code:

eBPF from Go - II

Fri, 30 Aug 2024 15:47:08 +0200

Following up from the previous blog post… I’ve got a JSON file with the string ‘bpf’ in the correct place. Let’s see what tinygo thinks of that:

% ./build/tinygo build -o miekg/main.bpf -target bpf ./miekg/main.go
No available targets are compatible with triple "bpf-unknown-unknown"

clang indeed does not list bpf as a valid target, so this needs to be added.

The llvm build is configured from the main GNUMakefile, with -DLLVM_TARGETS_TO_BUILD.... Using grep and find I found the “llvm/test/CodeGen” directory, which, in addition to all listed targets also has a BPF directory. Let’s add BPF to that list and recompile.

eBPF from Go; First Steps

Thu, 29 Aug 2024 20:04:35 +0200

So I had this itch that I wanted to make a Go program compile to eBPF and be able to load that program in the Linux kernel by use of bpftool.

As I say in github.com/miekg/ebpf

eBPF in C? What am I, a farmer?

After much reading about eBPF and thinking about how that would work from Go, I figured that would involve writing a Go compiler.

So I could:

hack the official Go compiler and (try to) add a eBPF target (which would probably never be added as an official target because of all the constraints eBPF has).

Printing from Android

Sat, 24 Feb 2024 20:03:54 +0100

Quick note to self.

Printing from Android requires IPP. If your printing does not support this protocol out of the box you will not be able to directly print from Android devices.

CUPS can then be used to translate between IPP and JetDirect (in my case). Install and configure CUPS and then on Android configure the printer. The later means connecting to a printer by IP address. In that form enter the following:

Config Management, part III: Rolling Back

Fri, 02 Feb 2024 15:20:33 +0100

The second part.

In the previous part we looked how a micro language would look like, now I want to focus on what it means to roll back to a previous version. First take a look at an instruction that have no obvious reverse: CHMOD

When rolling back CHMOD you want to revert to the previous permissions. This would work automatically if there was an older CHMOD that would also set the permission, but in a lot of situations you probably just go with the (package) defaults. This implies you don’t know what a CHMOD reversal would be, and that implies we need to track that, like in a proper journal. As said each instruction has an implicit condition, if that condition doesn’t hold, it executes the instruction, we can utilize that state and save it in the journal. Let’s see in detail how this would work with something like CHMOD.

Config Management, part II: Microcode Language

Thu, 01 Feb 2024 15:20:33 +0100

The first part.

This cfg mgmt system uses a micro language to perform the changes on the target system. This language is limited in its scope and has the following “instructions”:

INSTRUCTION	ARITY	ARGUMENTS	REMARK
REM	1	TEXT	a comment
MKDIR	2	MODE PATH	create a directory
COPY	2	SRC-PATH DST-PATH	copy a file
CHMOD	2	MODE PATH	set the mode
CHOWN	2	USER/ID PATH	set the owner
CHGRP	2	GROUP/ID PATH	set the group
RM	1	PATH	rm the file
EXEC	1	CMD	install a package

These micro-instruction basically all call a simple system call to make the changes. Note, except for the latter this is the Unix API of everything is a file. EXEC is now only used to install/deinstall a package; of course such a generic instruction is ripe for abuse…

OSC52: My Cut & Paste Journey

Wed, 31 Jan 2024 11:03:41 +0000

In the olden days with X11, you could just do x11-forwarding in SSH and remote cut and paste would work. Now with Wayland, this is all broken and supposedly “there are better ways of doing it”. One of those is OSC52 support in terminals, but not in VTE based ones, like Tilix, which is was my default terminal. (See https://gitlab.gnome.org/GNOME/vte/-/issues/2495 for the 5(!) year old bug).

So I wanted this to work, which meant changing terminal and configuring Neovim - where the latter was way more complex, hard to debug and reason about.

Config Management

Mon, 29 Jan 2024 14:20:33 +0100

this project needs a name and a domain.

After many years of playing with YAML in k8s, I’ve returned to using CFEngine (at work). The last config management software before that was Puppet. An issue I see with all modern config management tooling is the lack of monitoring and the impossibility to cleanly roll back. In k8s it works better, but that’s only for pods running in k8s (which are stateless), not the underlying machines.

Graaf

Thu, 28 Dec 2023 18:11:35 +0100

Graaf is a Go program that translates simple dashboards written in YAML to Grafana JSON. It has an extensive manual page that explains its usage. This is also known as Grafana as code, but then for real.

The following is a dashboard with 4 panels that I use for my own monitoring.

title: Overview i
uid: dashboard-overview
panels:
  - timeseries:
      title: 'Network Bytes [5m] - edgemax.i'
      y:
        unit: Bps
      exprs:
        - expr: 'rate(ifHCOutOctets{ifAlias="eth0",job="edgemax"}[5m])'
          legend: '{{ifAlias}} transmit'
        - expr: 'rate(ifHCInOctets{ifAlias="eth0",job="edgemax"}[5m])'
          legend: '{{ifAlias}} receive'
          transform: negative-y
  - timeseries:
      title: 'HTTPS Queries [5m]'
      y:
        unit: rps
      exprs:
        - expr: 'sum by (host) (rate(caddy_http_request_count_total{job="caddy"}[5m]))'
          legend: '{{host}}'
        - expr: 'sum (rate(caddy_http_request_count_total{job="caddy"}[5m]))'
          legend: total
          transform: negative-y
  - timeseries:
      title: 'DNS Queries [5m]'
      y:
        unit: rps
      exprs:
        - expr: 'sum by (zone) (rate(coredns_dns_requests_total{job="nsdns",zone!="dropped"}[5m]))'
          legend: '{{zone}}'
        - expr: 'sum (rate(coredns_dns_requests_total{job="nsdns"}[5m]))'
          legend: total
          transform: negative-y
        - expr: 'sum (rate(coredns_dns_requests_total{job="nsdns",zone="dropped"}[5m]))'
          legend: dropped
          transform: negative-y
  - timeseries:
      title: 'Network Bytes [5m] - nuc.i'
      y:
        unit: Bps
      exprs:
        - expr: 'rate(node_network_transmit_bytes_total{job="node",device="eno1"}[5m])'
          legend: '{{device}} transmit'
          threshold: 'ok{value="0"}'
        - expr: 'rate(node_network_receive_bytes_total{job="node",device="eno1"}[5m])'
          legend: '{{device}} receive'
          transform: negative-y

This dashboard is 47 lines, the generated JSON dashboard is 500 lines, a ~10-fold reduction in cruft. Not bad!

ASCII art in motd

Wed, 15 Nov 2023 06:17:36 +0000

I wanted a nicer login experience (see image above) when logging into my server.

For this I used the following sites, tools and steps.

https://www.svgrepo.com/
https://asciiart.club/
Little Go program from below

Steps:

Search a nice SVG image at “svgrepo” and save it;
Upload it to “asciiart”, and generate an ASCII art you are happy with;
Download the BBCode variant of the image and (if you want colors) run the program to translate [color=#...] to terminal control characters.
```
go run replace.go <image> && cat out
```

The used program is hacky, but does the job. Also used “inkscape” to fiddle with another logo, and made that output something decent as well.

Nvim Debian Pkg

Sun, 10 Sep 2023 11:20:31 +0200

NVIM stopped making Debian packages a while back, so here is a short note on how to do this yourself. Had a hard time finding this info, hence reproduced here. Assuming you’ve got the source.

make CMAKE_BUILD_TYPE=Release
cd build && cpack -G DEB
sudo dpkg -i nvim-linux64.deb

… and of course you then find the authoritative text.

If you use RelWithDebInfo an ever growing log file will be created in ~/.local/state/nvim/log.

Provisioning Services

Tue, 15 Nov 2022 07:35:00 +0000

There is a large gap between folks running their own machines and provisioning those and folks running Kubernetes and having Gitops at their disposal. In the latter case you can just put some YAML in Git and apply it in Kubernetes. Folks running their own machines on the other hand… are not so lucky.

Several “solutions” have existed for years, the umbrella term being “provisioning systems”, cfengine (one of the first), puppet, ansible and more. These work, but are (too?) powerful in that they allow actions and edits on the system being provisioned. This creates (hidden) problems when you’re asking yourself questions like: “Is the system’s state correct and in sync?”; “Can we easily rollback to a previously working version?”; “What content should file /path/to/file actually have?”.

How to install xml2rfc on Debian

Wed, 13 Nov 2019 07:17:36 +0000

Xml2rfc is the tool the IETF uses to convert the canonical XML for an Internet-Draft into text, HTML or a PDF. This utility has seen many releases while the XML schema was being finalized. It’s important (if you write I-Ds) that you have the latest version of xml2rfc installed.

Installing it as a Debian package is done with:

go to https://pypi.org/project/xml2rfc/#files
download the tar archive (say “xml2rfc-2.35.0.tar.gz”)
execute: py2dsc-deb xml2rfc-2.35.0.tar.gz (“py2dsc-deb” can be found in the “python-stdeb” package)
execute: sudo dpkg -i deb_dist/python-xml2rfc_2.35.0-1_all.deb

Note a py2dsc also exists, but that doesn’t create a Debian package.

My Terminal Setup

Mon, 12 Aug 2019 07:24:27 +0000

Every so often I tweak my setup which includes the shell, terminal, mutt, Vim and their color configuration. Currently I’m using a setup that I’ve tweaked a couple of years back - it seems I like this one. The color setup between my often used application are all unified, giving everything a consistent look.

As for colors; I like contrast: I have a black background terminal and the main text is white. I’m also using a minimal color scheme, just a few tints here and there. Most of the text is just white.

A k8s LB using ARP

Sat, 16 Dec 2017 09:33:57 +0000

A k8s LB using ARP

Metallb now supports ARM LBs. This is great, because it allows you to create an working LB in your (shitty) home network with off-the-shelve, cheap, router hardware. Running k8s at home (on ARM), became a whole lot more interesting!

Note: this will all be different in metallb 0.3.0, but if you want to play with this now you can follow this little guide.

We follow some of steps in the tutorial.

Enable Prometheus metrics in Caddy

Wed, 02 Mar 2016 07:53:58 +0000

The Caddy webserver is a modern webserver written in Go. I like it because I can easily extend it by writing some middleware (in Go). One of the things missing is metrics, which prompted me to implement enough metrics to make me happy.

Using this is relatively straight forward, but you’ll need to compile Caddy yourself and add this middleware.

Setup

(Assuming you have Go installed), first get the goodies:

Caddy:: go get github.com/mholt/caddy
Caddyext:: This is needed to compile in the new middleware, go get github.com/caddyserver/caddyext
Caddy-prometheus:: go get github.com/miekg/caddy-prometheus

Then, with caddyext register the new middleware:

Monitoring with SSH and Prometheus

Wed, 24 Feb 2016 11:35:01 +0000

I just wanted to see some qps metrics from BIND9.

This is a bit of hand wavey post on how to set up remote monitoring with Prometheus, Grafana and SSH tunnels.

Initially I just wanted to monitor BIND9 because it actually exports some reasonable metrics, that can be made usable with bind_exporter. But of course BIND is BIND so this is different in BIND 9.10 which is what I have on my server…. sigh. @jpmens also has some interesting tidbits about this BIND9 feature.

lean prompt (for zsh)

Tue, 24 Nov 2015 17:36:00 +0000

After having used prompt pure for about a year, I felt that a two-line prompt was not for me. Also not utilizing the right side of the terminal seemed a missed opportunity. Still there is much to like: the elapsed time of a process, the coloring of the prompt if the exit code of the process isn’t 0, git integration and the stay out of my way. So I took “pure”, mixed in my ideas of what a prompt should look like and came up with “lean” - a 1 line prompt that stays out of your face.

Spontaneous wake ups from suspend

Sat, 27 Jun 2015 13:34:00 +0000

When I upgraded my Ubuntu 14.04 to use kernel 4.0 (and now kernel 4.1) it apparently got a new feature: it would wake up from suspend in the middle of the day…

This bug provides a good read and has pointers to articles with more background. I’m seeing this on my Macbook Air and I am still not sure what the root cause is. I’m also not sure if it is “Intel Rapid Start Technology”, as Apples don’t have a BIOS to speak off.

Go and Alpine Linux

Sat, 06 Jun 2015 11:13:00 +0000

Alpine Linux is the small Linux OS everybody is using for Docker images. It is super small and has a sh*tload of packages. It’s libc is musl libc, which is different than glibc most other Linux distros are using. When deploying Go on such a image you want a truly static binary.

Building a static binary can be done with the following command (this is for SkyDNS):

% go build -ldflags "-linkmode external -extldflags -static"
# github.com/miekg/skydns
/var/tmp/go-link-FI6Ox0/000000.o: In function `_cgo_632c88804cec_C2func_getaddrinfo':
/home/miek/upstream/go/src/net/cgo_unix.go:55: warning: Using 'getaddrinfo' in
statically linked applications requires at runtime the shared libraries from the
glibc version used for linking

That ugly warning is because glibc uses nss(5) “Nameserver Service Switch” which uses dlopen(3) to dynamically load the correct resolver library. The end result is that the Go binary can’t resolve any DNS records!

Docker Alpine Linux Image for ARM

Mon, 25 May 2015 15:25:00 +0000

Alpine Linux is a super small Linux distribution which targets Docker. The only downside is that they use musl libc instead of glibc, which causes some issues for Golang programs. But I want this as a base image for SkyDNS on my Raspberry Pi, running HypriotOS.

After reading a modest amount of documentation I found the mkimage-alpine.sh script which build a docker image ala alpine, but makes it possible to select different archs. I had to tweak this script a little to make it do what I want, but after that it worked.

Pi cluster fun

Sun, 15 Feb 2015 16:21:00 +0000

I’ve bought 3 Raspberry Pis (B+, a week before the announcement of the Pi 2), and created a little cluster with them. Each Pi is connected to wireless (192.168.1.0/24) and they share an internal, wired, 10.248.0.0/16 network.

Virtual IP

I want one IP address to be load balanced across the three Pis. This can be with the CLUSTERIP target in iptables. In raspbian the kernel module for this was not enabled, but luckily this was fixed very quickly.

xmodmap is dead

Tue, 28 Oct 2014 20:18:00 +0000

I’m using an Apple keyboard at work since a day or two, but for some reason this keyboard has a special key for eject, because in 1898 that was useful when you wanted to eject a cdrom.

Anyway making this key do something useful proved incredible painful, especially since xmodmap is deprecated and we should all use xkb (setxkbmap andxkbcomp). In our new world of hotplugging everything this kinda makes sense (xmodmap settings are lost when your USB keyboard goes to sleep).

Vim live preview (sort of)

Wed, 08 Oct 2014 22:40:00 +0000

When editing Markdown files or internet drafts in Pandoc’s Markdown, I wanted to see some live preview window. I looked around a bit, but the solutions presented on the Internet, seemed to be insufficient, either to clumsy or don’t work at all.

My usual routine is: edit -> write -> make -> reload “rendered” file.

Turns out you can automate most of this. Vim has a feature: --servername <id> which allows you to send commands to another vim instance using that <id>. So we need two pieces to make this work.

grub_term_highlight_color

Mon, 21 Apr 2014 19:38:00 +0000

During two Ubuntu 14.04 upgrades, both on a Mac (so needing an EFI boot), grub was borked after the install resulting in a grub rescue prompt when booting.

The actual error was error: symbol 'grub_term_highlight_color' not found.

Needless to say I couldn’t get the system to boot from this prompt.

I had a Fedora boot USB stick laying around, but using that did not really fix the problem, in any case I could use it to copy off /home if I could not rescue the system.

i3

Sat, 08 Mar 2014 07:34:00 +0000

GNOME 3 finally pushed me over the edge. After I brief stint with cinnamon, I decided the only thing left was to configure a tiling window manager and some tweaks to make it more usable. For no reason at all, I settled on i3, which seems really nice and simple to configure.

But how to use i3 comfortable? i3 is a tiling window manager, which makes it ubercool, but with it you loose things like automount, brightness keys, etc.; all the things you expect from a Linux desktop nowadays. This blog item deals with getting the goodies from i3, without giving up on all the other things you like. I basically use a lot of GNOME tools, but let them run in the background.

Short kernel compile howto for Debian/Ubuntu

Tue, 10 Sep 2013 08:18:00 +0000

Download the kernel’s source from http://kernel.org;
Unpack it somewhere (will use ~/src/linux-3.11 here);

Copy the config from the distribution over;

 cp /boot/config-3.8.0.30-generic ~/src/linux-3.11/.config

Apply any patches;
Go to the kernel source and create an up to date config.
```
 make oldconfig
```
Just use the defaults for all the questions you’ll get;
Compile the kernel into a debian package for easy installation and removal.
```
 fakeroot make-kpkg --initrd -j 8 --revision 3.11custom kernel_image
```
Install the resulting .deb file and reboot.

Macbook Air (6,1) 2013 model with Ubuntu

Sat, 31 Aug 2013 11:48:00 +0000

Assorted notes, not a step-by-step HOWTO!

How to get Ubuntu Raring (13.04) up and running on your shining new MacbookAir. Note some things are not working (yet). This is with 3.11:

audio (speakers don’t work, plugged in headset does work), however see this latest patch;
webcam (see http://mactaris.blogspot.co.uk/2013/07/webcam-settings-20-will-support.html for a list of changes, it is not a UVC device anymore);
after a resume the screen brightness only knows on/off.

Expectation for 3.12 (when released), everything is working, except:

vim and editing pandoc2rfc

Sun, 16 Jun 2013 14:27:00 +0000

… or any other document format for that matter.

I thought it might be nice to have some sort of split window view in that allows you to edit a Pandoc file on the left and see the generated I-D on the right (in vim, with no extra daemons and not relying on inotify).

Turns out you can do that, though it is not optimal, but it works. The jury is still out if this works well enough to actually make it useful.

Make GNOME3 usable

Mon, 03 Jun 2013 18:50:00 +0000

GNOME3 in the default install is unusable, not as bad as Unity, but bad. Luckily with some ~~minor~~ tweaking it can be made to work quite nicely.

These are some assorted notes on how I got stuff working the way I like.

From a fresh Ubuntu install, install GNOME3:

sudo apt-get install gnome-desktop-environment

Then:

Normal focus mode:

 gsettings set org.gnome.desktop.wm.preferences focus-mode 'sloppy'
 gsettings set org.gnome.desktop.wm.preferences auto-raise false

Extensions:

Persistent Synaptic Touchpad settings in Ubuntu 12.10+

Wed, 27 Feb 2013 20:29:00 +0000

I was wondering how to make my touchpad settings permanent in Ubuntu. I could find a few pointers on the net, like:

But sometimes it makes sense to look at your own system’s documentation:

% cd /usr/share/X11/xorg.conf.d
% head 50-synaptics.conf
# Example xorg.conf.d snippet that assigns the touchpad driver
# to all touchpads. See xorg.conf.d(5) for more information on
# InputClass.
# DO NOT EDIT THIS FILE, your distribution will likely overwrite
# it when updating. Copy (and rename) this file into
# /etc/X11/xorg.conf.d first.
# Additional options may be added in the form of
#   Option "OptionName" "value"
#
Section "InputClass"

Which seems pretty obvious to me. I added

Make me a sandwich, MAKE me a sandwich

Wed, 30 Jan 2013 23:17:00 +0000

We all know this comic:

And now in zsh!

With the following snippet all commands that are started with an uppercase word will be prefixed with sudo and then executed.

So MAKE me a sandwich, becomes sudo make me a sandwich.

accept-line() {
    local B
    B=(${=BUFFER})
    if [[ "$B[1]" != [A-Z]* ]]; then
        zle .accept-line
        return
    fi
    if [[ $B[1] != "" && $B[1] == $B[1]:u ]]; then
        BUFFER="sudo $B[1]:l $B[2,-1]"
    fi
    zle .accept-line
}

And activate with:

Vim as MANPAGER

Sat, 19 Jan 2013 18:59:00 +0000

I like Vim, so I try to use it at many places. Like in my shell (set -o vi), and when writing and coding.

After some Googling I found that Vim can also be used as a MANPAGER. But there is one nagging issue. To quit viewing the manual page you have to type ‘:q’, which is one keystroke more then when using less as your MANPAGER… Needless to say: this is unacceptable.

Dynamic Syntax Highlighting in Vim

Thu, 20 Sep 2012 09:57:00 +0000

I’m a huge fan of syntax highlighting in my editor Vim. One thing I started to
miss was that user defined type miss out on the highlighting, because Vim does
not know about them. Wouldn’t it be cool to have some sort of automatic support that
detect your types and adds them to the correct highlighting group? I call
this “dynamic syntax highlighting”.

As a proof-of-concept I took the tagbar
plugin, and modified it a little to take advantage of the language detection (specifically the types). The modified code can be found in my fork on github.