OpenVPN 2.0.9 mipsel-linux [SSL] [LZO] built on Aug 28 2008
IMPORTANT: OpenVPN's default port number is now 1194, based on an official port number assignment by IANA.  OpenVPN 2.0-beta16 and earlier used 5000 as the default port.
Note: Cannot open TUN/TAP dev /dev/net/tun: No such file or directory (errno=2)
Note: Attempting fallback to kernel 2.2 TUN/TAP interface
Cannot allocate TUN/TAP dev dynamically
Exiting

The only solution I’ve found for this problem has been in a message in the OpenWRT forum:

insmod tun
mkdir /dev/net
mknod /dev/net/tun c 10 200

However sometimes this seems to cause OpenVPN to seg-fault.

What was the problem? Have a look at the script /etc/init.d/network, specifically tell me about the “restart” function. I was surprised to see that it wasn’t deliberately stopping the interfaces. Why is that? I understood that there isn’t a difference between restart versus start/stop.

I modified the restart function so that it explicitly called stop and start:

restart() {
        stop

        setup_switch() { return 0; }
        include /lib/network
        setup_switch

        start
}

Now, the networking side of things seems to behave a lot better. However I haven’t re-tried my attempts to get the switch working.

Windows 7 no longer comes with HyperTerminal. Fortunately, putty does serial communications. The only thing I had to enter was the COM port and the baud rate. Running Device Manager told me the USB-to-serial cable had been allocated COM3 (see the Ports section) and the baud rate is 115,200.

The connection worked first time.

When the box has just booted up ifconfig returns nothing whatsoever and pinging 127.0.0.1 results in an error:

OmnimaEMB USB root fs v1.8 (info@omnima.co.uk)

root@(none):/# ifconfig
root@(none):/# ping 127.0.0.1
PING 127.0.0.1 (127.0.0.1): 56 data bytes
ping: sendto: Network is unreachable

To modify the configuration of the ports edit the file /etc/config/network. Documentation for the file can be found at the OpenWrt site. The default initial configuration is:

# Copyright (C) 2006 OpenWrt.org

config interface loopback
	option ifname	lo
	option proto	static
	option ipaddr	127.0.0.1
	option netmask	255.0.0.0

config interface lan
	option ifname	eth0
	option type 	bridge
	option proto	static
	option ipaddr	192.168.1.1
	option netmask	255.255.255.0

To activate the ports execute /etc/init.d/network restart

root@(none):/# /etc/init.d/network restart
root@(none):/# ifconfig
eth0      Link encap:Ethernet  HWaddr 22:DA:E2:A8:86:2A
          inet addr:192.168.1.1  Bcast:192.168.1.255  Mask:255.255.255.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:1 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:0 (0.0 B)  TX bytes:1043 (1.0 KiB)
          Interrupt:17 

lo        Link encap:Local Loopback
          inet addr:127.0.0.1  Mask:255.0.0.0
          UP LOOPBACK RUNNING  MTU:16436  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

root@(none):/# ping 127.0.0.1
PING 127.0.0.1 (127.0.0.1): 56 data bytes
64 bytes from 127.0.0.1: seq=0 ttl=64 time=2.032 ms
64 bytes from 127.0.0.1: seq=1 ttl=64 time=1.292 ms
64 bytes from 127.0.0.1: seq=2 ttl=64 time=1.287 ms
64 bytes from 127.0.0.1: seq=3 ttl=64 time=1.465 ms
64 bytes from 127.0.0.1: seq=4 ttl=64 time=1.284 ms
^C
--- 127.0.0.1 ping statistics ---
5 packets transmitted, 5 packets received, 0% packet loss
round-trip min/avg/max = 1.284/1.472/2.032 ms

For me this activated the port labelled “WAN”, but I understand that this too is configurable.

(I have since learned that there is an open source system that is very similar: the Arduino.)

Having put it together—and I really loved the lack of instructions—I have just started to learn how these things work. Here is a summary of things I wish had been clear from the start:

• It’s important to buy the flash drive as an option, otherwise the system is not set up to boot from a USB disk.
• It’s important to buy the USB-to-serial cable or you’d never know what was going on.
• To use the serial cable: plug it in on its own (i.e. not connected to the embedded controller). Type dmesg | tail to get some seriously useful information:

  [99127.316231] usb 6-2: Product: USB-Serial Controller
  [99127.316233] usb 6-2: Manufacturer: Prolific Technology Inc.
  [99127.321238] pl2303 6-2:1.0: pl2303 converter detected
  [99127.333254] usb 6-2: pl2303 converter now attached to ttyUSB0
  

• Now that we know what the serial port is called we can test communications. (No need to plug in the embedded controller yet.) Type picocom -b 115200 /dev/ttyUSB0 which sets the specifications required for communication.

If it works, great, if not (a) you might need to install picocom, and (b) you might need to fix permissions or ignore all security issues and just run as root.

• Now, unplug the USB end of the serial cable from the computer. Plug in the other end with the engraved dot at pin 1. Plug in the power supply. Plug in the USB end of the serial cable. Start picocom with the line picocom -b 115200 /dev/ttyUSB0. You should now be able to watch it boot. If you weren’t fast enough: no stress, just hit the enter key and you’ll be greeted with a command line interface.
• You can play with the LEDs. Try issuing these commands at the embedded controller’s command line:

  echo 21 > /sys/class/gpio/
  echo out > /sys/class/gpio/gpio21/direction
  echo 1 > /sys/class/gpio/gpio21/value    # did that turn the LED on?
  echo 0 > /sys/class/gpio/gpio21/value    # what did that do?
  

Cool. Good start.

It is clear how to go about changing the earthquake loads in AutoPIPE (Load > Static Earthquake). Ignoring the henious user-interface, it’s at least clear how to change the values per earthquake case. What is not clear are the consequences.

If you add to the number of earthquake cases then you must also modify the “analysis sets” (Load > Static Analysis Sets). Select the analysis set and click Modify. Tick the new earthquake cases for inclusion.

But wait there’s more! AutoPIPE doesn’t tell you that it’s possibly just deleted a whole lot of load combinations! Go to Tools > Combinations and make sure all that you’re interested in is still there. In my case I discovered that eight non-code combinations had been automatically deleted without warning.

To modify a pipe’s corrosion allowance: Modify > Properties of Pipe Identifier > (select identifier) > Ok > modify Corrosion Allow > Ok.

Do not try to select the pipe beforehand. If you select pipes of different sizes and use “Modify Pipe Properties over Range” you’ll just get an error that won’t go away and thus you are blocked from modifying the corrosion allowance.

x+y

Yup, that’s all.

>>> x = (1,2)
>>> y = (3,4)
>>> x+y
(1, 2, 3, 4)

A progress bar is tricky because it immediately introduces the idea that something is going to take a long time. If this thing were to be run as a standard on-click-do-this type of function, the interface would freeze up. That wouldn’t be ok. How is this fixed? By using either multi-threading or multi-processing.

(Ok, so there’s another option, but the idea of doing little bits of work and returning control to the interface, and then going back to doing more work… it’s just not attractive to me. One reason is that it binds the program’s functionality to the program’s interface, and that’s just not a good thing.)

For the work I’m doing, I prefer the multi-processing option. The Art of Unix Programming gives a good summary of the differences [1]. Multi-processing in Python has been made really easy thanks to the multiprocessing library. Unfortunately however, I still found it necessary to use multi-threading as well, in order to watch for when data arrives from the worker process.

To summarise the system:

• The main work is done within a separate process. Updates are shared with the calling process via a multiprocessing.Queue. A fraction is placed on the queue to indicate how much of the work has been complete. Further messages can be placed on the queue to indicate what will be done next or what has just been done.
• The calling process creates a thread to listen for any data being placed on the queue. When a fraction is read from the queue, the observing thread emits an “updated” signal. Depending on the queue data, the observer may also emit message_event, finished, or errored signals.
• A ProgressBar is attached to an Observer to allow graphical feedback of progress.
• And when all that is set up, we start the observer thread and the worker process
• There is also a CombinedObserver that summarises multiple Observers

To use the system to create one worker whose progress is monitored:

worker1 = WorkerExample() 
process1 = Process(worker1.go, ())
observer1 = process1.getObserver()
window1 = ProgressBarWindow(observer1, "Workers One's progress")
process1.start()
gtk.main()
process1.join()

Finally, any comments or recommendations you may have would be gratefully received.

Update: Threads on PyGTK discusses progress bars and I’ve learnt that my approach has a flaw in that I should call gtk.threads_enter() and gtk.threads_leave() before changing the progress bar. I also found a nice explanation of why.

The system, including test and example code:

#!/usr/bin/env python

import sys #exit
import gobject
import pygtk
pygtk.require('2.0')
import gtk
import multiprocessing
import threading
import time

gtk.gdk.threads_init()


# Any time you connect to any of these signals, they should be
# protected with a threading.Lock or similar.
class ObserverBase(gobject.GObject):
    __gsignals__ = {
        'message_event' : (gobject.SIGNAL_RUN_LAST,
                           gobject.TYPE_NONE,
                           (gobject.TYPE_STRING,)),
        'updated' : (gobject.SIGNAL_RUN_LAST,
                     gobject.TYPE_NONE,
                     (gobject.TYPE_FLOAT,)),
        'finished': (gobject.SIGNAL_RUN_LAST,
                     gobject.TYPE_NONE,
                     ()),
        'errored': (gobject.SIGNAL_RUN_LAST,
                     gobject.TYPE_NONE,
                     ())
        }

    def __init__(self):
        gobject.GObject.__init__(self)

gobject.type_register(ObserverBase)

class Observer(ObserverBase):
    def __init__(self, queue):
        ObserverBase.__init__(self)
        self.queue = queue

    def start(self):
        # Create new thread to do the listening
        self.thread = threading.Thread(target=self.listen, args=())
        self.thread.start()

    def join(self):
        self.thread.join()

    def listen(self):
        while True:
            # Listen for results on the queue and process them accordingly
            print "Observer is waiting for data"
            data = self.queue.get()
            print "Observer received: ",data
            dataType = type(data).__name__
            if dataType=="bool" and data==True:
                self.emit('finished')
                return
            if dataType=="bool" and data==False:
                self.emit('errored')
                return
            elif dataType=="str":
                self.emit('message_event', data)
            elif dataType=="float":
                self.emit('updated', data)
            else:
                raise RuntimeError("Queue had an unknown data type ('"+dataType+"') with value '"+str(data)+"'")

gobject.type_register(Observer)

        
class Process(gobject.GObject):
    __gsignals__ = {
        'starting': (gobject.SIGNAL_RUN_LAST,
                     gobject.TYPE_NONE,
                     ()),
        'joined': (gobject.SIGNAL_RUN_LAST,
                     gobject.TYPE_NONE,
                     ())
        }

    def __init__(self, function, arguments):
        gobject.GObject.__init__(self)
        # Create queue
        self.queue = multiprocessing.Queue()

        # Create process
        if arguments==(): arguments=(self.queue,)
        self.process = multiprocessing.Process(target=function, args=arguments)

        # Create observer
        self.observer = Observer(self.queue)


    def getObserver(self):
        return self.observer

    def start(self):
        # Starting observer
        self.emit("starting")
        print "starting observer"
        self.observer.start()
        # Start process
        print "starting process"
        self.process.start()

    def join(self):
        # Clean up after process
        print "cleaning up after process"
        self.process.join()
        self.emit("joined")
        # Clean up after observer
        print "cleaning up after observer"
        self.queue.put(False) # If the false is ever read, it's an error
        self.observer.join()
        # Clean up queue
        #self.queue.close()
        

gobject.type_register(Process)




class CombinedObserver(ObserverBase):
    def __init__(self, observers, weights=None):
        ObserverBase.__init__(self)
        self.observers = observers
        numObservers = len(observers)
        if weights==None:
            self.weights = [1 for i in range(numObservers)]
        else:
            self.weights = weights
            
        sum_weights = sum(self.weights)
        self.weights = [float(w)/sum_weights for w in self.weights]
        print "weights = ",self.weights

        index = 0
        for observer in self.observers:
            #observer.connect("message_event", onMessageReceived, index)
            observer.connect("updated", self.onUpdate, index)
            observer.connect("finished", self.onFinished, index)
            observer.connect("errored", self.onErrored, index)
            index = index+1

        self.fractions = [0 for i in range(numObservers)]
        self.finished = [False for i in range(numObservers)]
        self.errored = [False for i in range(numObservers)]
        self.lock = threading.RLock()

    def onUpdate(self, widget, fraction, index):
        self.lock.acquire()
        self.fractions[index] = fraction * self.weights[index]
        self.emit("updated", sum(self.fractions))
        self.lock.release()
                                   
    def onFinished(self, widget, index):
        self.lock.acquire()
        self.finished[index] = True
        if all(self.finished):
            self.emit("finished")
        self.lock.release()

    def onErrored(self, widget, index):
        self.lock.acquire()
        self.errored[index] = True
        self.emit("errored")
        self.lock.release()
        


gobject.type_register(CombinedObserver)


# A ProgressWorker is responsible for (a) getting the job done and (b)
# reporting progress.  Progress is reported via the queue.  Fractions
# (from 0 to 1) indicate the proportion of the job that is finished.
# Strings may indicate what has been done or what is about to be done.
# The boolean 'True' is placed on the queue when the job is finished.
class ProgressWorker():
    def getResult(self):
        return None

    def setQueue(self, queue):
        self.queue = queue

    def go(self):
        raise RuntimeError("Worker.go() has not been overridden")


class WorkerExample(ProgressWorker):
    def __init__(self):
        #Worker.__init__(self)
        manager = multiprocessing.Manager()
        self.result = manager.list()

    def getResult(self):
        return self.result

    def go(self, queue):
        self.setQueue(queue)
        print "The worker has started doing some work (counting from 0 to 9)"
        for i in range(10):
            self.queue.put("working on step "+str(i)+"...")
            proportion = (float(i)+1)/10
            time.sleep(0.75)
            self.queue.put(proportion)
        self.queue.put("done.")
        self.queue.put(1.0)
        self.queue.put(True)
        print "The worker has finished."
        self.result.append("The the work has been finished and the result isn't 42.")




class ProgressBar(gobject.GObject):
    __gsignals__ = {
        'updated' : (gobject.SIGNAL_RUN_LAST,
                     gobject.TYPE_NONE,
                     (gobject.TYPE_FLOAT,)),
        'finished': (gobject.SIGNAL_RUN_LAST,
                     gobject.TYPE_NONE,
                     ())
        }

    def __init__(self, observer):
        gobject.GObject.__init__(self)
        self.observer = observer
        self.observer.connect("updated",self.displayUpdate)
        self.observer.connect("message_event",self.displayMessage)
        self.observer.connect("finished",self.finish)
        self.progress = gtk.ProgressBar()
        self.progress.connect("destroy", self.destroy)
        self.process=None
        self.lock = threading.RLock()

    def displayUpdate(self, obj, fraction):
        self.lock.acquire()
        self.progress.set_fraction(fraction)
        self.emit("updated", fraction)
        self.lock.release()

    def displayMessage(self, obj, text):
        self.lock.acquire()
        self.progress.set_text(text)
        self.lock.release()

    def finish(self, obj, data=None):
        self.emit("finished")

    def destroy(self, widget, data=None):
        print "Destroying"
        if self.process==None:
            return
        self.queue.put("finished")
        self.process.join()
        self.thread.join()

        

gobject.type_register(ProgressBar)


class ProgressBarWindow:
    def __init__(self, observer, title):
        self.progressBar = ProgressBar(observer)
        self.progressBar.connect("finished", self.done)
        window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        window.set_border_width(10)
        window.set_title(title)
        window.add(self.progressBar.progress)
        window.show_all()
        window.connect("destroy", self.destroy)

    def main(self):
        gtk.main()

    def done(self, widget, data=None):
        #self.destroy()
        print "FINISHED!"

    def destroy(self, widget=None, data=None):
        gtk.main_quit()



# Test
if __name__ == '__main__':
    # Three workers
    worker1 = WorkerExample()
    process1 = Process(worker1.go, ())
    observer1 = process1.getObserver()

    worker2 = WorkerExample()
    process2 = Process(worker2.go, ())
    observer2 = process2.getObserver()

    worker3 = WorkerExample()
    process3 = Process(worker3.go, ())
    observer3 = process3.getObserver()

    combo = CombinedObserver([observer1, observer2, observer3])

    window0 = ProgressBarWindow(combo, "Workers' progress")
    window1 = ProgressBarWindow(observer1, "Workers One's progress")
    window2 = ProgressBarWindow(observer2, "Workers Two's progress")
    window3 = ProgressBarWindow(observer3, "Workers Three's progress")

    process1.start()
    #time.sleep(0.1)
    process2.start()
    #time.sleep(0.1)
    process3.start()
    gtk.main()
    process1.join()
    process2.join()
    process3.join()
    print "finished"
    sys.exit()

    # Two workers
    worker1 = WorkerExample()
    process1 = Process(worker1.go, ())
    observer1 = process1.getObserver()

    worker2 = WorkerExample()
    process2 = Process(worker2.go, ())
    observer2 = process2.getObserver()

    combo = CombinedObserver([observer1, observer2])

    window0 = ProgressBarWindow(combo, "Workers' progress")
    window1 = ProgressBarWindow(observer1, "Workers One's progress")
    window2 = ProgressBarWindow(observer2, "Workers Two's progress")

    process1.start()
    time.sleep(0.1)
    process2.start()
    gtk.main()
    process1.join()
    process2.join()
    print "finished"
    sys.exit()

    # One worker
    print "creating worker1"
    worker1 = WorkerExample() # The task to do, carefully constructed to give feedback via a queue
    print "creating process1"
    process1 = Process(worker1.go, ()) # Responsible for looking after the worker: supplying the queue, setting up the observer, starting process
    observer1 = process1.getObserver() # An observer of the worker's progress that listens to the queue
    window1 = ProgressBarWindow(observer1, "Workers One's progress") # A display of the progress, connected to the observer
    process1.start()
    gtk.main()
    process1.join()
    print "result = ", worker1.result
    print "finished"
    sys.exit()

[1] The Art of Unix Programming. Section “Threads: Threat or Menace?”