Docker and caching apt-get for guests on the same host

Docker is great for isolation, you probably still want some caching, the Dockerfile from extellisys is a great start: https://github.com/extellisys/docker-image-apt-cacher-ng Running the above, runs apt-cache-ng and exposes it's port as 3142. This is great for a LAN, if you want to use this for caching on your dev box then read on. If you just want lines to paste into other Dockerfiles, skip to the end.
To avoid surprises I tend to change the "FROM" part of any Ubuntu or Debian based Dockerfiles to use the same distro as the host (in this case "ubuntu:14.10"), this should save a little space too.

Optionally use the cache with Docker guests on the same host.

Desired result - use the cache if available, otherwise don't. Avahi is the usual way to do this, unfortunately it doesn't work easily in between host and guest. We can make our own way of doing this. So all we need to do is find the host IP from another guest -
$ route -n | awk '/^0.0.0.0/ {print $2}'
The other part is optionally using a proxy - the undocumented apt.conf.d setting Acquire::http::ProxyAutoDetect is what we want. It runs a discovery script that either outputs an IP of a proxy, or DIRECT if there is none.

Discovery script and setting

/usr/local/bin/apt-ng-host-discover:
 #!/bin/bash
 HOST_IP=$(route -n | awk '/^0.0.0.0/ {print $2}')
 if nc -w1 -z $HOST_IP 3142; then printf http://$HOST_IP:3142; else printf DIRECT; fi
/etc/apt/apt.conf.d/30proxy:
 Acquire::http::ProxyAutoDetect "/usr/local/bin/apt-ng-host-discover";

Putting it together / tl;dr;

Everything can be munged into 5 lines you paste into your Dockerfile:
 RUN HOST_IP=$(route -n | awk '/^0.0.0.0/ {print $2}'); \
 echo "#!/bin/bash" > /usr/local/bin/apt-ng-host-discover; \
 echo "if nc -w1 -z $HOST_IP 3142; then printf http://$HOST_IP:3142; else printf DIRECT; fi" >> /usr/local/bin/apt-ng-host-discover && \
 chmod +x /usr/local/bin/apt-ng-host-discover
 RUN echo 'Acquire::http::ProxyAutoDetect "/usr/local/bin/apt-ng-host-discover";' > /etc/apt/apt.conf.d/30proxy

Further work

Run the extellisys cache on boot, and disable any other caching ( http://ask.xmodulo.com/disable-apt-cache-debian-ubuntu.html ).

3d in the era of J2me

Back in the deep dark past (2004-2007) I worked on a 3D game for phones of that era (before iphone, android). I recently found some of the test files for the engine, here are some videos.

 

Very low poly racetrack

 

The ubiquitous cube

 

Spacekid in the spacestation corridors

Our Mascot wanders the corridors .. you can't look too far ahead, to keep things really low, which means popup is a little...severe.
Movement is a better in reality - the capture has made the movement a bit jerky.

Dire Straits

Obviously we didn't make this, but it heavily inspired our 3D engine ... textures were just too slow, so we aimed for this look.

Drawing to the same content to many windows, cairo and zeromq

Playing with python, zeromq and Gtk, I made this code to send graphics commands to several windows.

Commands are sent over a zeromq PUB socket, the windows recieve them using zeromq SUB.

Only a few commands are wrapped as it's a proof of concept.

I'll clean it up and abstract some bits and it should be quite easy for building something like a live coding environment.

Screenshot from 2013-06-15 19:19:37

See below for code -


[UPDATE]
Posted code to github, update to work with multiprocessing.

https://github.com/stuaxo/zeromq-gtk-playground

[/UPDATE]

(more…)

Moving things in shoebot, adding different behaviours..

In my last post we made an arrow move around the screen, in this post we'll look to extend things so it's easy to make many things move around the screen.

This will make the code a little more complex, but as usual it makes things simpler later on.

Note:

This python code runs in shoebot, planar.py is used to handle coordinates
https://github.com/shoebot
planar.py

At the end we'll have two arrows, a blue one controlled with the keyboard and a pink one that moves on it's own:

(more…)

Natural movement using polar coordinates in shoebot

Here's a little shoebot bot to experiment with natural movement.

This uses polar coordinates to decide the direction and velocity of an arrow on the screen.

Polar coordinates mean we can give an object a sense of 'forward', 'back', 'left' and 'right'

The code below works on the current version of shoebot
https://github.com/shoebot/shoebot.git

With planar.py to handle the directions and velocity
https://pypi.python.org/pypi/planar

(more…)

Cairo: Surface for recording commands and playback

An update on my latest cairo adventures...

When cairo 1.10 comes out we'll get a RecordingSurface so you can record commands and play them back to another surface, but how to do something similar now ? Skip to the end if you just want the code, explanation of how I got there ahead: My first advice was to try using PDFSurface, and set the file object to None.
# Record a red rectangle onto a surface.
#
# Create another surface and draw a background on it
# Draw the first surface onto this surface
#
from cairo import PDFSurface, ImageSurface, FORMAT_ARGB32, Context

recording = PDFSurface(None, 200, 200)
target = ImageSurface(FORMAT_ARGB32, 200, 200)

# Record a red rectangle
cr = Context(recording)
cr.set_source_rgb(1.0, 0.0, 1.0)
cr.rectangle(20, 20, 10, 10)

cr.fill_preserve()
cr.set_source_rgb(0.0, 0.0, 1.0)
cr.stroke()

target_context = Context(target)

# Draw background
target_context.set_source_rgb(1.0, 1.0, 0)
target_context.paint()

# Replay recording to target
target_context.set_source_surface(recording)
target_context.paint()

target.write_to_png('output.png')
That seems to work, except when I tried in Windows, when it complained that the file object was wrong. OK, we can work round that:
def RecordingSurface(w, h):
    if os.name == 'nt':
        fobj = 'nul'
    else:
        fobj = None
    return PDFSurface(fobj, w, h)
This seems to be working, but my animation seemed slow... time for some benchmarking; I rendered 1000 frames and got a rough wall clock time: 1m48. Hmm... perhaps SVGSurface will be quicker: 1m28 This is much better, 20 seconds difference just by changing what kind of surface is returned!

Animation not smooth though

The animation still seemed jerky it occured to me that when the surfaces are disposed they will attempt to out their content to the file object ! Luckily, get_similar_surface() comes to the rescue; it returns a surface not associated with a file object. Using this the original surface can be kept around forever, and never output. Wallclock time: 50 seconds!

And here it is:

_svg_surface = None
def RecordingSurface(*size):
    '''
    We don't have RecordingSurfaces until cairo 1.10, so this kludge is used

    SVGSurfaces are created, but to stop them ever attempting to output, they
    are kept in a dict.

    When a surface is needed, create_similar is called to get a Surface from
    the SVGSurface of the same size
    '''
    global _svg_surface
    if os.name == 'nt':
        fobj = 'nul'
    else:
        fobj = None
    if _svg_surface is None:
        _svg_surface = SVGSurface(fobj, 0, 0)
    return _svg_surface.create_similar(cairo.CONTENT_COLOR_ALPHA, *size)
This is really useful, you can record commands and play them back to other surfaces.

A simple cairo draw queue using closures

Often it's useful to be able to store up drawing commands so you can use them later somewhere else (or even just pass them to another thread). This is a simple drawing model, implemented in cairo, hopefully somebody will find it useful. Queue
class DrawQueue:
    '''
    A list of draw commands, stored as callables that, are
    passed a set of parameters to draw on from the canvas
    implementation.
    '''
    def __init__(self, render_callables = None):
        self.render_callables = render_callables or deque()

    def append(self, render_callable):
        '''
        Add a render callable to the queue
        '''
        self.render_callables.append(render_callable)

    def render(self, cairo_ctx):
        '''
        Call all the render callables with cairo_ctx
        '''
        for render_callable in self.render_callables:
            render_callable(cairo_ctx)
The queue just accepts callables (any old function), and calls them when you call render, passing them a cairo context you pass in. To get useful functions you can call closure functions like these:
def paint_closure():
    def paint(ctx):
        ctx.paint()
    return paint

def fill_closure():
    def fill(ctx):
        ctx.fill()
    return fill

def set_source_rgb_closure(r, g, b):
    def set_source_rgb(ctx):
        ctx.set_source_rgb(r, g, b)
    return set_source_rgb

def moveto_closure(x, y):
    def moveto(ctx):
        ctx.move_to(x, y)
    return moveto

def rectangle_closure(x, y, w, h):
    def rectangle(ctx):
        ctx.rectangle(x, y, w, h)
    return rectangle
Adding commands to the queue is simple:
dq = DrawQueue()
dq.append(set_source_rgb_closure(1, 1, 1))
dq.append(paint_closure())
dq.append(moveto_closure(10, 0))
dq.append(rectangle_closure(0, 0, 20, 20))
dq.append(set_source_rgb_closure(0, 0, 0))
dq.append(fill_closure())
This is the same drawing model I'm using in my branch of shoebot, I'm hoping to expand it to be multithreaded; while a foreground thread adds commands a background thread is executing them. Here it is all put together in a simple example to draw a black rectangle
from collections import deque
import cairo

class DrawQueue:
    '''
    A list of draw commands, stored as callables that, are
    passed a set of parameters to draw on from the canvas
    implementation.
    '''
    def __init__(self, render_callables = None):
        self.render_callables = render_callables or deque()

    def append(self, render_callable):
        '''
        Add a render callable to the queue
        '''
        self.render_callables.append(render_callable)

    def render(self, cairo_ctx):
        '''
        Call all the render callables with cairo_ctx
        '''
        for render_callable in self.render_callables:
            render_callable(cairo_ctx)

#### drawing closures
def paint_closure():
    def paint(ctx):
        ctx.paint()
    return paint

def fill_closure():
    def fill(ctx):
        ctx.fill()
    return fill

def set_source_rgb_closure(r, g, b):
    def set_source_rgb(ctx):
        ctx.set_source_rgb(r, g, b)
    return set_source_rgb

def moveto_closure(x, y):
    def moveto(ctx):
        ctx.move_to(x, y)
    return moveto

def rectangle_closure(x, y, w, h):
    def rectangle(ctx):
        ctx.rectangle(x, y, w, h)
    return rectangle

#### /drawing closures

dq = DrawQueue()

# Add some commands to the drawing queue
dq.append(set_source_rgb_closure(1, 1, 1))
dq.append(paint_closure())
dq.append(moveto_closure(10, 0))
dq.append(rectangle_closure(0, 0, 20, 20))
dq.append(set_source_rgb_closure(0, 0, 0))
dq.append(fill_closure())

# Create a surface and context
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 200, 200)
ctx = cairo.Context(surface)

# run defered rendering
dq.render(ctx)

surface.write_to_png('output.png')

Processing with Jython and Nodebox/Shoebot libraries

Update: 26/April/2010

Problems I was having with incomplete images have been fixed in the current version of the web library, available in shoebots mecurial repository.

Using Processing from Jython is a promising idea, so I took the base from this post on backspaces.net where they explained how to use Jython and built on it a little.

This is great as Shoebot/Nodebox have great libraries for data manipulation, while processing is more focused on graphics.

The result is the attached Netbeans project which demonstrates using the nodebox web library and  drawing with processing.

Slowcessing

The glue code is in slowcessing.py

Theres a special version of PApplet (PJApplet), and 'pj_frame' which can put this in a JFrame.

The other method is 'shoebot_imports' adds the shoebot imports to the library path

In case anybody doesn't want to download the whole project, heres the code:

imagestrip.py

from slowcessing import PJApplet, pj_frame, shoebot_imports
from processing.opengl import *

shoebot_imports()
import web
import thread

class ImageQueue(list):
    """
    Download images in the background and add them to a list
    """
    def __init__(self, search, size):
        list.__init__(self)
        self._search = search
        self._image_size = size
        thread.start_new_thread(self._get_images, ())

    def _image_downloaded(self, path):
        p = PJApplet()
        self.append(p.loadImage(path))

    def _get_images(self):
        for image in self._search:
            image.download(self._image_size, asynchronous=False)
            self._image_downloaded(image.path)

class WebTest (PJApplet):
  def setup(self):
    self.size(400, 400, self.P3D)
    self.images = ImageQueue(web.morguefile.search("sweets", max=1), size='small')

  def draw(self):
    self.background(0);
    y = (self.height * 0.2) - self.mouseY * (len(self.images) * 0.58)
    for image in self.images:
        self.image(image, 20, y)
        y += image.height

if __name__ == '__main__':
    pj_frame(WebTest)

slowcessing.py

from javax.swing import JFrame

from processing.core import PApplet

class PJApplet(PApplet):
  # rqd due to PApplet's using frameRate and frameRate(n) etc.
  def getField(self, name):
      return PApplet.getDeclaredField(name).get(self)

def pj_frame(pj_applet, **kwargs):
    from time import sleep

    frame = JFrame(kwargs.get('title', 'Slowcessing'))
    frame.defaultCloseOperation = kwargs.get('defaultCloseOperation', JFrame.EXIT_ON_CLOSE)
    frame.resizable = kwargs.get('resizable', False)

    panel = pj_applet()
    frame.add(panel)
    panel.init()

    while panel.defaultSize and not panel.finished:
        sleep(0.5)

    frame.pack()
    frame.visible = 1

    return frame

def shoebot_imports():
    """
    Allow import of the shoebot libraries
    """
    ##APP = 'shoebot'
    import sys
    DIR = sys.prefix + '/share/shoebot/locale'
    ##locale.setlocale(locale.LC_ALL, '')
    ##gettext.bindtextdomain(APP, DIR)
    ###gettext.bindtextdomain(APP)
    ##gettext.textdomain(APP)
    ##_ = gettext.gettext

    LIB_DIR = sys.prefix + '/share/shoebot/lib'
    sys.path.append(LIB_DIR)

Problems

There are some things I couldn't work :

The callback to say that images have been downloaded happens before the whole file is available, for this reason there are grey parts on the images on the first run.

Nodebox web...

While I did manage to fix things to get this working in Jython and get Morguefile working, I had a lot of trouble understanding what was going on here.

Cheers to Tom De Smedt for fixing these the areas of nodebox-web that I couldn't 🙂

Processing...

Some parts of PApplet to do with image loading seem to be static, which may also explain problems I was getting with reentrancy.

Download

If you want to have a go, you'll need to:

Install Netbeans 6.8

Install Jython (2.5 or higher) by installing the Netbeans python module

Add python to the path (if using Netbeans it's copy is where Netbeans is installed).

Get nodebox-web by downloading shoebot and install it with:

jython setup.py install

In Netbeans, add all the jars in the processing\lib folder to the Jython classpath, and opengl\library\opengl.jar

Download the PythonOnProcessing (tested on Netbeans 6.8)

Using Cairo to generate SVG in Django

Cairo is a 2D vector graphics api used by Firefox, Gtk and other desktop projects. I'm going to show here that it can also be used to generate web content, using Django. I'm going to port two examples from the Michael Urmans Cairo Tutorial for PyGTK Programmers. To understand the cairo and it's drawing model I'd recommend his his Cairo Tutorial for Python Programmers.
Note: In this example I'll be generating SVGs...  as I.E. (as of 2010) does not support them, you might want to generate PNG or PDF - if you need to do this with cairo, look for one of the many cairo tutorials on the web.
The example django project can be downloaded at the end of the article. (more…)

Scripts to help workflow now on google code.

I've uploaded my scripts to help workflow to google code, naming the project batch flow. Heres a summary of some of the things you can do.

Clipboard integration

Go to a directory in the clipboard.

If you have the address bar enabled in explorer: Copy the location, go to the prompt and enter 'pcd' to go to that folder Go to the location of a setting in netbeans or eclipse: Copy the location , go to the prompt and enter 'pcd' to go to the folder (or folder containing the file).

Get the current directory without dragging:

Enter 'ccd'

Directory bookmarks

dirsave and dirload let you save named bookmarks.

Using hotkeys

If you use the alternate shell 4nt (or the free TCC/LE) you can use the supplied configuration and aliases to access the bookmark functionality from the keyboard: In the 4nt or tcc/le prompt enter "option", under the "TCStart/TCExit" path, change the location to the location where batch-flow is installed + "\conf", for instance on my computer batch-flow is installed to c:\usr\batch-flow, so I set it to
c:\usr\batch-flow\conf
Now in new TCC/LE prompts F5-F10 are reserved for directories: Ctrl+Fkey to save, and Alt+Fkey to load.  Alt-F12 lists these shortcuts. Note:  Alt-F12 only lists shortcuts on FKeys, to list these and other shortcuts enter dirload /l
batch-flow comes with other handy hotkeys, use 'alias' in TCC/LE to see what they are.

Path manipulation

addpath

It's annoying after installing a program to have to add it to the path, so there is an 'addpath' command to do this.

regpath

This is a more general utility for viewing the registry path, you can list it, validate it, check for the location of files within it. Also useful is 'regpath /L' which sets the local prompts path to the one in the registry.

Further help

Most of the commands have help builtin, which you can access by using the /? option.