if comment is not None:

comment = colored('(%s)' % comment, 'green')

else:

comment = ''

print '# %s %s' % (colored(s, 'yellow'), comment)

if not settings.dryrun:

def __init__(self,p):

pass

def start(self):

pass

def stop(self):

pass

def create(self):

pass

def destroy(self):

def __init__(self,id):

self.id = id

self.name = 'h%d' % id

self.ifaces = []

# Create scratch area if not there already

self.create()

def create(self):

cmd("vzctl create %d --hostname %s --ostemplate debian-5.0-x86_64" % (self.id, self.name))

def start(self):

cmd("vzctl start %d" % self.id)

self.add_iface()

#self.shell = Cmd(self)

def stop(self):

cmd("vzctl stop %d" % self.id)

def configure(self, ip=None, mask=None):

# bring up the eth0 and set ip address

if ip is None:

# 10.0.0.0 + id

ip = ipStr(self.id)

mask = 8

cmd("vzctl exec %d ifconfig eth0 %s/%s" % (self.id, ip, mask))

self.ip = ip

self.mask = mask

def IP(self):

return self.ip

def cmd(self, c):

cmd("vzctl exec %d '%s'" % (self.id, c))

#self.shell.cmd(c)

def sendCmd(self, c):

return self.send_command(c)

def send_command(self, c):

"""

send command c to this particular host

and return a "command" handle that can

later be used to fetch output

this is non blocking

"""

return Command(["vzctl", "exec2", "%d" % self.id, c])

def open(self, file):

# check if root fs is mounted. if it is, then return

# that file. else return from private dir

fullpath1 = os.path.join("/var/lib/vz/root/%d" % self.id, file)

fullpath2 = os.path.join("/var/lib/vz/private/%d" % self.id, file)

print '# open %s' % fullpath1

try:

ret = fileopen(fullpath1)

except:

ret = fileopen(fullpath2)

return ret

def add_iface(self):

next_iface_id = len(self.ifaces)

veth = 'veth%d.%d' % (self.id, next_iface_id)

eth = 'eth%d' % next_iface_id

self.ifaces.append((veth, eth))

cmd("vzctl set %d --netif_add eth%d" % (self.id, next_iface_id))

def del_iface(self):

pass

def destroy(self):

"""Destroy's the host's root directory.

Please don't do it unless needed."""

""" Ideally this should be a subclass of a switch class

but not for now."""

def __init__(self,id):

self.name = 'sw%d' % (id)

self.id = id

# container's id

self.cid = self.id + settings.offset_switch_id

self.created = []

self.create()

self.ifaces = []

self.bridgewires = []

def create(self):

"""This will create a userspace switch, which is nothing

but a container with a switch process in it"""

cmd("vzctl create %d --hostname %s --ostemplate debian-5.0-x86_64" % (self.cid, self.name))

# useless thing, avoid copying again and again

# maybe hook to a settings variable

# TODO!!

files_to_copy = [

"/home/jvimal/openflow/controller/controller",

"/home/jvimal/openflow/udatapath/ofdatapath",

"/home/jvimal/openflow/secchan/ofprotocol",

]

dst_dir = "/var/lib/vz/private/%d/bin" % self.cid

for f in files_to_copy:

cmd("cp %s %s" % (f, dst_dir))

def create_iface(self, insidename):

"""Just create an iface for the container and return its global

name."""

cmd("vzctl set %d --netif_add %s" % (self.cid, insidename),

"it's inside!")

self.ifaces.append(insidename)

outside_name = 'veth%d.%d' % (self.cid, len(self.ifaces))

return outside_name

def add_iface(self, node):

"""it's actually connect host's iface (node), bad choice of

naming this function. TODO: should change this!"""

iface = node.ifaces[0][0]

# add a corresponding interface to our switch

# let's name it the same because, it doesn't matter

# and it's useful to debug

# it will be visible as veth<container_id>.<n> to the outside world

outside_name = self.create_iface('in'+iface)

bridgewire_name = 'br%d' % next_bridgewire_id()

# this is the only new thing we've created.. a br<id>

self.bridgewires.append(bridgewire_name)

cmd("brctl addbr %s" % bridgewire_name)

# bridge the iface and our **outside** iface

# this is like the wire between the host and the switch

cmd("brctl addif %s %s" % (bridgewire_name, outside_name))

cmd("brctl addif %s %s" % (bridgewire_name, iface))

def connect_switch(self, sw):

# this becomes simple actually...

# no need for veth pair as in the normal switch case

# just bridge the two interfaces that the switches anyway have!

bridgewire_name = 'br%d' % next_bridgewire_id()

cmd("brctl addbr %s" % bridgewire_name)

# our interface goes to switch sw

our_their_outside = self.create_iface(sw.name)

their_our_outside = sw.create_iface(self.name)

cmd("brctl addif %s %s" % (bridgewire_name, our_their_outside))

cmd("brctl addif %s %s" % (bridgewire_name, their_our_outside))

self.bridgewires.append(bridgewire_name)

def configure(self):

for br in self.bridgewires:

cmd("ifconfig %s up" % br)

cmd("ifconfig %s 0" % br)

# let's initialise our own loopback

# needed for the controller

# let's just forget the case of having a

# single controller. right now, every switch

# has its own controller ;)

# need to worry about ip address and all that.. :-/

self.cmd("ifconfig lo up")

for iface in self.ifaces:

self.cmd("ifconfig %s up" % iface)

# make the tun device

self.cmd("mkdir -p /dev/net")

self.cmd("mknod /dev/net/tun c 10 200","enabling tun/tap for container")

self.cmd("chmod 600 /dev/net/tun")

self.cmd("controller -v ptcp: 2>&1 1> /tmp/controller.log &")

intfs = ','.join( self.ifaces )

self.cmd("ofdatapath --no-slicing -i %s punix:/tmp/ofsock 2>&1 1> /tmp/ofdp.log &" % intfs)

self.cmd("ofprotocol unix:/tmp/ofsock tcp:127.0.0.1 2>&1 1> /tmp/ofp.log &")

def cmd(self,c, comment=None):

cmd("vzctl exec %d '%s'" % (self.cid, c), comment)

def start(self):

# should use the host's command interface to

# start the of switch process

# self.cmd("ofprotocol blah blah")

cmd("vzctl set %d --devices c:10:200:rw" % self.cid)

cmd("vzctl set %d --capability net_admin:on" % self.cid)

cmd("vzctl start %d" % (self.cid))

def stop(self):

for br in self.bridgewires:

cmd("ifconfig %s down" % br)

# no veths created...

# but containers were created

cmd("vzctl stop %d" % self.cid)

def destroy(self):

# will remove all its files

def __init__(self,id):

# This will be a bridge sw<id>

self.name = 'sw%d' % id

self.id = id

self.created = []

self.create()

self.ifaces = []

def create(self):

cmd("brctl addbr %s" % self.name)

def add_iface(self, node):

iface = node.ifaces[0][0]

cmd("brctl addif %s %s" % (self.name, iface))

self.ifaces.append(iface)

def connect_switch(self, sw):

name = '%s%s' % (self.name, sw.name)

peer = '%s%s' % (sw.name, self.name)

#this command works ONLY on kernel versions 2.6.28+,

# as it requires the veth module support.

if settings.veth:

cmd("ip link add name %s type veth peer name %s" % (name, peer))

# with a patched 2.6.18 kernel having etun

# support, we should have something similar setup

# patch here: http://lwn.net/Articles/229677/

# i'll arrange a standalone patch shortly

elif settings.etun:

cmd("echo -n '%s,%s' > /sys/module/etun/parameters/newif" % (name, peer))

else:

print '*** Cannot proceed. Need support for virtual ethernet pair'

print '*** to create (%s,%s)' % (name, peer)

cmd("ifconfig %s up" % name)

cmd("ifconfig %s up" % peer)

cmd("brctl addif %s %s" % (self.name, name))

self.ifaces.append(name)

cmd("brctl addif %s %s" % (sw.name, peer))

sw.ifaces.append(peer)

self.created += [name] # It's enough to delete one of the pairs

def configure(self):

cmd("ifconfig %s 0" % self.name)

def stop(self):

# TODO: should we delif's first?

# We should do it at least for the links we create..

# The hosts will take care of the rest

for iface in self.created:

cmd("ifconfig %s down" % iface)

if settings.veth:

cmd("ip link del dev %s" % iface)

else:

cmd("echo -n '%s' > /sys/module/etun/parameters/delif" % iface)

cmd("ifconfig %s down" % self.name)