OPNSense is built on FreeBSD and provides its own ports tree so we can build various packages from source.

Unfortunately I was continually getting build failures when running make install in the /usr/ports/security/tailscale dir. I kept failing at the point where we were trying to build Go, and was failing at this same point every time I tried. Sometimes accompanied by a hard crash of the server.

bootstrap/cmd/compile/internal/ssa
go build bootstrap/cmd/compile/internal/ssa: /usr/local/go14/pkg/tool/freebsd_amd64/6g: signal: killed
bootstrap/cmd/compile/internal/syntax
bootstrap/cmd/internal/gcprog
bootstrap/internal/goversion
bootstrap/internal/race
bootstrap/cmd/link/internal/sym
bootstrap/cmd/link/internal/loadelf
bootstrap/cmd/link/internal/loadmacho
bootstrap/cmd/link/internal/loadpe
bootstrap/cmd/link/internal/loadxcoff
bootstrap/cmd/link/internal/objfile
bootstrap/cmd/link/internal/ld
bootstrap/cmd/link/internal/amd64
bootstrap/cmd/link/internal/arm
bootstrap/cmd/link/internal/arm64
bootstrap/cmd/link/internal/mips
bootstrap/cmd/link/internal/mips64
bootstrap/cmd/link/internal/ppc64
bootstrap/cmd/link/internal/s390x
bootstrap/cmd/link/internal/wasm
bootstrap/cmd/link/internal/x86
bootstrap/cmd/link
go tool dist: FAILED: /usr/local/go14/bin/go install -gcflags=-l -tags=math_big_pure_go compiler_bootstrap -v bootstrap/cmd/...: exit status 1
*** Error code 2

Stop.
make: stopped in /usr/ports/lang/go

===>>> make build failed for lang/go
===>>> Aborting update

===>>> Update for lang/go failed
===>>> Aborting update

===>>> Update for net/wireguard-go failed
===>>> Aborting update

The only reference I could find on google to this error was an old post on the FreeBSD forums, which had no resolution. (I copied his error log for the example above, because I wasn't smart enough to grab one when I was building). Eventually I came across an issue on the Go-Bootstrap git repo, which suggested the process was killed due to an out of memory issue.

It finally made sense. I run the OPNSense machine in a VM on proxmox, and over time I had tuned it's specs down to just what it requires for it's duties as a router / firewall, trying to build software on it was not something I thought I'd be doing on it. I upped its memory from 1G to 4 temporarily and the build proceeded without any further issue.

After an unplanned landing that snapped the camera platform off the front of my ADS400, I needed to find a way to remount my gopro to the frame. Given that a replacement plate would take too long to get here (shipping from Florida to NSW takes roughly 3 years), I fired up my shitty 3d printer and sketchup'd my way to a new (dare i say, improved) camera mount.

And, It's pink!

I knocked up the mount in Sketchup, and tapped the holes so I could replace the forward nylon spacers with my mount.

The finished product, before tapping the holes to accept m3 screws.

I haven't flown it yet, I'm waiting on new props, but hopefully it will be strong enough to stand up to my style of umm... flying.

Django + Celery

Task queuing and asynchronous jobs, + user notification

Within our project we have identified the following issues:

• Some tasks take a long time to run (generating reports being the most obvious)
• Optimisations so far have only been able to reduce the larger reports to single digit minutes (still far from responsive as far as the user is concerned)
• Due to the nature of the reports, as more services are added, the generation of these reports will take longer.

One proposed solution is to move the generation of such reports to an asynchronous task runner to free up the user to do 'other things' while the reports are generated.

Celery

http://www.celeryproject.org/

Celery is an asynchronous task queue/job queue based on distributed message passing. It is focused on real-time operation, but supports scheduling as well.

Given the above, Celery seems to fit our needs fairly well. Generation of reports can be queued and users notified when the reports have been generated, this leaves us with a couple of options to choose from:

• How to notify the user?
  • In browser?
  • Via Email?
  • ???
• How to deliver the file?
• Via expiring link for direct download
• Send the document as email attachment
• Insert the document into the users securedocs

Celery also has the option of working with various backends to handle the storage of task queues, the most common of which being RabbitMQ and redis

Redis is an open source, BSD licensed, advanced key-value store. It is often referred to as a data structure server since keys can contain strings, hashes, lists, sets and sorted sets.

RabbitMQ doesn't have a handy copypastable tagline, but it is a higher level messaging system for applications.

I favour redis, as it is a lower level data store and can possibly be utilised for other needs within the project (ie. browser messages, discussed later).

Example Implementation

An example implementation has been committed at

This example uses redis as the backend for celery, and provides a system to inject messages into the Django Messaging Framework.

System Setup

We need to install redis-server to hold our tasks and messages, so:

sudo apt-get install redis-server

That's it as far as redis setup goes. Further configuration information can be found at http://redis.io/topics/config

Celery Setup

We can install celery and its required libraries for redis using pip

pip install celery[redis]

Code Walkthough

More complete information can be found here. But what follows is a simple explanation of my implementation.

Celery requires a celery.py settings file at the project level (same level as settings.py) This file instantiates the celery instance and iterates through installed apps looking for a tasks.py file to load tasks.

We then register the celery instance in the project's init.py, so that the instance is created when django starts, and is usable through all apps.

At the application level, we have blog/tasks.py which holds the tasks to be created. I the example, busywaitTask simply waits for a number of seconds, then completes.

To start the task, I have created a view that does nothing but start the task. blog/views.py:StartTaskView extends the generic detailview and simply adds the task to the celery queue:

busywaitTask.delay(self.request.user.username)

That's it. The task has been added to the queue and will be dealt with by the celery workers.

Messaging

As an aside, I needed an easy way to notify a user when their task has been completed. The Django Messaging Framework provides a neat way of showing messages to users in the browser, but unfortunately provides no hooks for apps outside of the session to use it.

This was failry trivial to work around using django middleware. I created a simple middleware class middleware/tests.py:getMessagefromRedisMiddleware and added it to middleware classes in settings.py. By overriding the process_request method we have access to the session, and can add messages using the framework. There is a function addUserMessage() which serializes a message and message level and pushes it to the redis db with a key of the sessions username. Then on every request, we lookup the key of the username, and pop messages until there are none left, adding them to the regular messaging framework.

Having just re-entered the professional workforce after eight years in hospitality, I need somewhere to put my notes and ideas. So a blog seems like the cool thing to do.

I've spun up an Ubuntu instance on digitalocean and installed ghost (it seems the trendy thing to do), so now all thats left is to write things down.

You can expect sporadic posts about Django, web design, remote control things and maybe some electronics crap too, but I guarantee, it will mostly be rubbish.

I thought I would try my hand at acro flying, so got hold of a Towelie Bro Edition frame. (www.multirotorsuperstore.com). The frame came without instructions, but was easy enough to put together like the photos online. I built it up with stuff I already had, so recycled the HK20A escs and NTM 1350kv motors of my (now disabled) HT-FPV and put them in together with a Naze32 Acro Edition (www.abusemark.com).

The Naze32 is on default pids, I have just set the looptime to 3500 and increased acc_lpf. The thing is totally locked in. After I first put it together I gave it a go in horizon mode, and it levelled perfectly. I had some issues with a motor stalling, but i think that was due to a dodgy esc connection, and that problem has since been solved.

A few days later, I charged up some more batteries and went for another go, this time abandoning horizon mode and using acro mode only. I can't believe how easy this combo is to fly. Immediately responsive and rock solid when holding attitude.

Getting the hang of it, can't wait to learn how to warthox so I can warthox while I warthox.

Here is a compilation of some of my unplanned landings.

Tonight I rebuilt the quad and attached some cob LEDs I had. There are 4 5W lights on the front arms of the quad and I can switch them on via the Tx. They are really quite bright and provide tons of light for the gopro to see quite far. I never looked through my fpv cam but I think its even more sensitive, so it should be good. Next step is getting the balls to fly fpv in the dark...

Always check that your battery is charged before flying. This was a close call, and I wasn't even using my own gopro, lucky the reeds caught my copter.

As part of my self diagnosed adult ADHD, I change hobbies like I change underwear. Currently my addiction of choice is remote controlled multirotors. By taking 3 or more motor / prop combos and applying enough power, you can make basically anything fly. Of course, learning about one hobby tends to blend back with existing ones, so combine a flying machine with a camera and the result can only be good fun.

So in learning to fly I have also had to try my hand at video editing, obviously neither are much good right now but I'm sure with a bit of practise I'll have something I'm proud of.