web/topology_rest.py

#! /usr/bin/env python
import pprint
import os
import sys
import subprocess
import json
import argparse
import io
import time
import random
import re
from urllib2 import Request, urlopen, URLError, HTTPError

from flask import Flask, json, Response, render_template, make_response, request

CONFIG_FILE=os.getenv("HOME") + "/ONOS/web/config.json"
LINK_FILE=os.getenv("HOME") + "/ONOS/web/link.json"
ONOSDIR=os.getenv("HOME") + "/ONOS"

## Global Var for ON.Lab local REST ##
RestIP="localhost"
RestPort=8080
ONOS_DEFAULT_HOST="localhost" ;# Has to set if LB=False
DEBUG=1

pp = pprint.PrettyPrinter(indent=4)
app = Flask(__name__)

def read_config():
  global LB, TESTBED, controllers, core_switches, ONOS_GUI3_HOST, ONOS_GUI3_CONTROL_HOST
  f = open(CONFIG_FILE)
  conf = json.load(f)
  LB = conf['LB']
  TESTBED = conf['TESTBED']
  controllers = conf['controllers']
  core_switches=conf['core_switches']
  ONOS_GUI3_HOST=conf['ONOS_GUI3_HOST']
  ONOS_GUI3_CONTROL_HOST=conf['ONOS_GUI3_CONTROL_HOST']
  f.close()

def read_link_def():
  global link_def
  f=open(LINK_FILE)
  try:
    link_def=json.load(f)
    f.close()
  except:
    print "Can't read link def file (link.json)"
    sys.exit(1)

def get_link_ports(src_dpid, dst_dpid):
  ret = (-1, -1)
  for link in link_def:
    if link['src-switch'] == src_dpid and link['dst-switch'] == dst_dpid:
        ret = (link['src-port'], link['dst-port'])
        break
  return ret

## Worker Functions ##
def log_error(txt):
  print '%s' % (txt)

def debug(txt):
  if DEBUG:
    print '%s' % (txt)

### File Fetch ###
@app.route('/ui/img/<filename>', methods=['GET'])
@app.route('/img/<filename>', methods=['GET'])
@app.route('/css/<filename>', methods=['GET'])
@app.route('/js/models/<filename>', methods=['GET'])
@app.route('/js/views/<filename>', methods=['GET'])
@app.route('/js/<filename>', methods=['GET'])
@app.route('/lib/<filename>', methods=['GET'])
@app.route('/log/<filename>', methods=['GET'])
@app.route('/', methods=['GET'])
@app.route('/<filename>', methods=['GET'])
@app.route('/tpl/<filename>', methods=['GET'])
@app.route('/ons-demo/<filename>', methods=['GET'])
@app.route('/ons-demo/js/<filename>', methods=['GET'])
@app.route('/ons-demo/d3/<filename>', methods=['GET'])
@app.route('/ons-demo/css/<filename>', methods=['GET'])
@app.route('/ons-demo/assets/<filename>', methods=['GET'])
@app.route('/ons-demo/data/<filename>', methods=['GET'])
def return_file(filename="index.html"):
  if request.path == "/":
    fullpath = "./index.html"
  else:
    fullpath = str(request.path)[1:]

  try:
    open(fullpath)
  except:
    response = make_response("Cannot find a file: %s" % (fullpath), 500)
    response.headers["Content-type"] = "text/html"
    return response

  response = make_response(open(fullpath).read())
  suffix = fullpath.split(".")[-1]

  if suffix == "html" or suffix == "htm":
    response.headers["Content-type"] = "text/html"
  elif suffix == "js":
    response.headers["Content-type"] = "application/javascript"
  elif suffix == "css":
    response.headers["Content-type"] = "text/css"
  elif suffix == "png":
    response.headers["Content-type"] = "image/png"
  elif suffix == "svg":
    response.headers["Content-type"] = "image/svg+xml"

  return response

## Proxy ##
@app.route("/proxy/gui/link/<cmd>/<src_dpid>/<src_port>/<dst_dpid>/<dst_port>")
def proxy_link_change(cmd, src_dpid, src_port, dst_dpid, dst_port):
  url = "%s/gui/link/%s/%s/%s/%s/%s" % (ONOS_GUI3_CONTROL_HOST, cmd, src_dpid, src_port, dst_dpid, dst_port)
  try:
    response = urlopen(url)
    result = response.read()
  except:
    result = ""
    print "REST IF has issue %s" % url

  resp = Response(result, status=200, mimetype='application/json')
  return resp

@app.route("/proxy/gui/switchctrl/<cmd>")
def proxy_switch_controller_setting(cmd):
  url = "%s/gui/switchctrl/%s" % (ONOS_GUI3_CONTROL_HOST, cmd)
  try:
    response = urlopen(url)
    result = response.read()
  except:
    result = ""
    print "REST IF has issue %s" % url

  resp = Response(result, status=200, mimetype='application/json')
  return resp

@app.route("/proxy/gui/switch/<cmd>/<dpid>")
def proxy_switch_status_change(cmd, dpid):
  url = "%s/gui/switch/%s/%s" % (ONOS_GUI3_CONTROL_HOST, cmd, dpid)
  try:
    response = urlopen(url)
    result = response.read()
  except:
    result = ""
    print "REST IF has issue %s" % url

  resp = Response(result, status=200, mimetype='application/json')
  return resp

@app.route("/proxy/gui/controller/<cmd>/<controller_name>")
def proxy_controller_status_change(cmd, controller_name):
  url = "%s/gui/controller/%s/%s" % (ONOS_GUI3_CONTROL_HOST, cmd, controller_name)
  try:
    response = urlopen(url)
    result = response.read()
  except:
    result = ""
    print "REST IF has issue %s" % url
 
  resp = Response(result, status=200, mimetype='application/json')
  return resp

@app.route("/proxy/gui/addflow/<src_dpid>/<src_port>/<dst_dpid>/<dst_port>/<srcMAC>/<dstMAC>")
def proxy_add_flow(src_dpid, src_port, dst_dpid, dst_port, srcMAC, dstMAC):
  try:
    url = "%s/gui/addflow/%s/%s/%s/%s/%s/%s" % (ONOS_GUI3_CONTROL_HOST, src_dpid, src_port, dst_dpid, dst_port, srcMAC, dstMAC)
    #print "proxy gui addflow " + url
    (code, result) = get_json(url)
  except:
    print "REST IF has issue %s" % url
    print "Result %s" % result
    exit()

  resp = Response(result, status=200, mimetype='application/json')
  return resp

@app.route("/proxy/gui/delflow/<flow_id>")
def proxy_del_flow(flow_id):
  url = "%s/gui/delflow/%s" % (ONOS_GUI3_CONTROL_HOST, flow_id)
  try:
    response = urlopen(url)
    result = response.read()
  except:
    result = ""
    print "REST IF has issue %s" % url

  resp = Response(result, status=200, mimetype='application/json')
  return resp

@app.route("/proxy/gui/iperf/start/<flow_id>/<duration>/<samples>")
def proxy_iperf_start(flow_id,duration,samples):
  url = "%s/gui/iperf/start/%s/%s/%s" % (ONOS_GUI3_CONTROL_HOST, flow_id, duration, samples)
  try:
    response = urlopen(url)
    result = response.read()
  except:
    result = ""
    print "REST IF has issue %s" % url

  resp = Response(result, status=200, mimetype='application/json')
  return resp

@app.route("/proxy/gui/iperf/rate/<flow_id>")
def proxy_iperf_rate(flow_id):
  url = "%s/gui/iperf/rate/%s" % (ONOS_GUI3_CONTROL_HOST, flow_id)
  try:
    response = urlopen(url)
    result = response.read()
  except:
    result = ""
    print "REST IF has issue %s" % url

  resp = Response(result, status=200, mimetype='application/json')
  return resp

@app.route("/proxy/gui/reset")
def proxy_gui_reset():
  url = "%s/gui/reset" % (ONOS_GUI3_CONTROL_HOST)
  try:
    response = urlopen(url)
    result = response.read()
  except:
    result = ""
    print "REST IF has issue %s" % url

  resp = Response(result, status=200, mimetype='application/json')
  return resp

@app.route("/proxy/gui/scale")
def proxy_gui_scale():
  url = "%s/gui/scale" % (ONOS_GUI3_CONTROL_HOST)
  try:
    response = urlopen(url)
    result = response.read()
  except:
    result = ""
    print "REST IF has issue %s" % url

  resp = Response(result, status=200, mimetype='application/json')
  return resp

###### ONOS REST API ##############################
## Worker Func ###
def get_json(url):
  code = 200;
  try:
    response = urlopen(url)
  except URLError, e:
    print "get_json: REST IF %s has issue. Reason: %s" % (url, e.reason)
    result = ""
    return (500, result)
  except HTTPError, e:
    print "get_json: REST IF %s has issue. Code %s" % (url, e.code)
    result = ""
    return (e.code, result)

  result = response.read()
#  parsedResult = json.loads(result)
  return (code, result)

def pick_host():
  if LB == True:
    nr_host=len(controllers)
    r=random.randint(0, nr_host - 1)
    host=controllers[r]
  else:
    host=ONOS_DEFAULT_HOST

  return "http://" + host + ":8080"

## Switch ##
@app.route("/wm/onos/topology/switches/all/json")
def switches():
  if request.args.get('proxy') == None:
    host = pick_host()
  else:
    host = ONOS_GUI3_HOST

  url ="%s/wm/onos/topology/switches/all/json" % (host)
  (code, result) = get_json(url)

  resp = Response(result, status=code, mimetype='application/json')
  return resp

## Link ##
@app.route("/wm/onos/topology/links/json")
def links():
  if request.args.get('proxy') == None:
    host = pick_host()
  else:
    host = ONOS_GUI3_HOST

  url ="%s/wm/onos/topology/links/json" % (host)
  (code, result) = get_json(url)

  resp = Response(result, status=code, mimetype='application/json')
  return resp

## FlowSummary ##
@app.route("/wm/onos/flows/getsummary/<start>/<range>/json")
def flows(start, range):
  if request.args.get('proxy') == None:
    host = pick_host()
  else:
    host = ONOS_GUI3_HOST

  url ="%s/wm/onos/flows/getsummary/%s/%s/json" % (host, start, range)
  (code, result) = get_json(url)

  resp = Response(result, status=code, mimetype='application/json')
  return resp

@app.route("/wm/onos/registry/controllers/json")
def registry_controllers():
  if request.args.get('proxy') == None:
    host = pick_host()
  else:
    host = ONOS_GUI3_HOST

  url= "%s/wm/onos/registry/controllers/json" % (host)
  (code, result) = get_json(url)

  resp = Response(result, status=code, mimetype='application/json')
  return resp


@app.route("/wm/onos/registry/switches/json")
def registry_switches():
  if request.args.get('proxy') == None:
    host = pick_host()
  else:
    host = ONOS_GUI3_HOST

  url="%s/wm/onos/registry/switches/json" % (host)
  (code, result) = get_json(url)

  resp = Response(result, status=code, mimetype='application/json')
  return resp

def node_id(switch_array, dpid):
  id = -1
  for i, val in enumerate(switch_array):
    if val['name'] == dpid:
      id = i
      break

  return id

## API for ON.Lab local GUI ##
@app.route('/topology', methods=['GET'])
def topology_for_gui():
  try:
    url="http://%s:%s/wm/onos/topology/switches/all/json" % (RestIP, RestPort)
    (code, result) = get_json(url)
    parsedResult = json.loads(result)
  except:
    log_error("REST IF has issue: %s" % url)
    log_error("%s" % result)
    return

  topo = {}
  switches = []
  links = []
  devices = []

  for v in parsedResult:
    if v.has_key('dpid'):
#      if v.has_key('dpid') and str(v['state']) == "ACTIVE":#;if you want only ACTIVE nodes
      dpid = str(v['dpid'])
      state = str(v['state'])
      sw = {}
      sw['name']=dpid
      sw['group']= -1

      if state == "INACTIVE":
        sw['group']=0
      switches.append(sw)

  try:
    url="http://%s:%s/wm/onos/registry/switches/json" % (RestIP, RestPort)
    (code, result) = get_json(url)
    parsedResult = json.loads(result)
  except:
    log_error("REST IF has issue: %s" % url)
    log_error("%s" % result)

  for key in parsedResult:
    dpid = key
    ctrl = parsedResult[dpid][0]['controllerId']
    sw_id = node_id(switches, dpid)
    if sw_id != -1:
      if switches[sw_id]['group'] != 0:
        switches[sw_id]['group'] = controllers.index(ctrl) + 1

  try:
    url = "http://%s:%s/wm/onos/topology/links/json" % (RestIP, RestPort)
    (code, result) = get_json(url)
    parsedResult = json.loads(result)
  except:
    log_error("REST IF has issue: %s" % url)
    log_error("%s" % result)
    return
#    sys.exit(0)

  for v in parsedResult:
    link = {}
    if v.has_key('dst-switch'):
      dst_dpid = str(v['dst-switch'])
      dst_id = node_id(switches, dst_dpid)
    if v.has_key('src-switch'):
      src_dpid = str(v['src-switch'])
      src_id = node_id(switches, src_dpid)
    link['source'] = src_id
    link['target'] = dst_id

    #onpath = 0
    #for (s,d) in path:
    #  if s == v['src-switch'] and d == v['dst-switch']:
    #    onpath = 1
    #    break
    #link['type'] = onpath

    links.append(link)

  topo['nodes'] = switches
  topo['links'] = links

  js = json.dumps(topo)
  resp = Response(js, status=200, mimetype='application/json')
  return resp

@app.route("/wm/floodlight/topology/toporoute/<v1>/<p1>/<v2>/<p2>/json")
def shortest_path(v1, p1, v2, p2):
  try:
    url = "http://%s:%s/wm/onos/topology/switches/all/json" % (RestIP, RestPort)
    (code, result) = get_json(url)
    parsedResult = json.loads(result)
  except:
    log_error("REST IF has issue: %s" % command)
    log_error("%s" % result)
    return

  topo = {}
  switches = []
  links = []

  for v in parsedResult:
    if v.has_key('dpid'):
      dpid = str(v['dpid'])
      state = str(v['state'])
      sw = {}
      sw['name']=dpid
      if str(v['state']) == "ACTIVE":
        if dpid[-2:-1] == "a":
         sw['group']=1
        if dpid[-2:-1] == "b":
         sw['group']=2
        if dpid[-2:-1] == "c":
         sw['group']=3
      if str(v['state']) == "INACTIVE":
         sw['group']=0

      switches.append(sw)

  try:
    url = "http://%s:%s/wm/onos/topology/route/%s/%s/%s/%s/json" % (RestIP, RestPort, v1, p1, v2, p2)
    (code, result) = get_json(url)
    parsedResult = json.loads(result)
  except:
    log_error("No route")
    parsedResult = []

  path = [];
  for i, v in enumerate(parsedResult):
    if i < len(parsedResult) - 1:
      sdpid= parsedResult['flowEntries'][i]['dpid']['value']
      ddpid= parsedResult['flowEntries'][i+1]['dpid']['value']
      path.append( (sdpid, ddpid))

  try:
    url = "http://%s:%s/wm/onos/topology/links/json" % (RestIP, RestPort)
    (code, result) = get_json(url)
    parsedResult = json.loads(result)
  except:
    log_error("REST IF has issue: %s" % command)
    log_error("%s" % result)
    return

  for v in parsedResult:
    link = {}
    if v.has_key('dst-switch'):
      dst_dpid = str(v['dst-switch'])
      dst_id = node_id(switches, dst_dpid)
    if v.has_key('src-switch'):
      src_dpid = str(v['src-switch'])
      src_id = node_id(switches, src_dpid)
    link['source'] = src_id
    link['target'] = dst_id
    onpath = 0
    for (s,d) in path:
      if s == v['src-switch'] and d == v['dst-switch']:
        onpath = 1
        break

    link['type'] = onpath
    links.append(link)

  topo['nodes'] = switches
  topo['links'] = links

  js = json.dumps(topo)
  resp = Response(js, status=200, mimetype='application/json')
  return resp

@app.route("/wm/floodlight/core/controller/switches/json")
def query_switch():
  try:
    url = "http://%s:%s/wm/onos/topology/switches/all/json" % (RestIP, RestPort)
    (code, result) = get_json(url)
    parsedResult = json.loads(result)
  except:
    log_error("REST IF has issue: %s" % url)
    log_error("%s" % result)
    return
#    sys.exit(0)

#  print command
#  print result
  switches_ = []
  for v in parsedResult:
    if v.has_key('dpid'):
      if v.has_key('dpid') and str(v['state']) == "ACTIVE":#;if you want only ACTIVE nodes
        dpid = str(v['dpid'])
        state = str(v['state'])
        sw = {}
        sw['dpid']=dpid
        sw['active']=state
        switches_.append(sw)

#  pp.pprint(switches_)
  js = json.dumps(switches_)
  resp = Response(js, status=200, mimetype='application/json')
  return resp

## return fake stat for now
@app.route("/wm/floodlight/core/switch/<switchId>/<statType>/json")
def switch_stat(switchId, statType):
    if statType == "desc":
        desc=[{"length":1056,"serialNumber":"None","manufacturerDescription":"Nicira Networks, Inc.","hardwareDescription":"Open vSwitch","softwareDescription":"1.4.0+build0","datapathDescription":"None"}]
        ret = {}
        ret[switchId]=desc
    elif statType == "aggregate":
        aggr = {"packetCount":0,"byteCount":0,"flowCount":0}
        ret = {}
        ret[switchId]=aggr
    else:
        ret = {}

    js = json.dumps(ret)
    resp = Response(js, status=200, mimetype='application/json')
    return resp

@app.route("/controller_status")
def controller_status():
  url= "http://%s:%d/wm/onos/registry/controllers/json" % (RestIP, RestPort)
  (code, result) = get_json(url)
  parsedResult = json.loads(result)

  cont_status=[]
  for i in controllers:
    status={}
    if i in parsedResult:
      onos=1
    else:
      onos=0
    status["name"]=i
    status["onos"]=onos
    status["cassandra"]=0
    cont_status.append(status)

  js = json.dumps(cont_status)
  resp = Response(js, status=200, mimetype='application/json')
  return resp


### Command ###
@app.route("/gui/controller/<cmd>/<controller_name>")
def controller_status_change(cmd, controller_name):
  if (TESTBED == "hw"):
    start_onos="/home/admin/bin/onos start %s" % (controller_name[-1:])
#    start_onos="/home/admin/bin/onos start %s > /tmp/debug " % (controller_name[-1:])
    stop_onos="/home/admin/bin/onos stop %s" % (controller_name[-1:])
#    stop_onos="/home/admin/bin/onos stop %s > /tmp/debug " % (controller_name[-1:])
#    print "Debug: Controller command %s called %s" % (cmd, controller_name)
  else:
    # No longer use -i to specify keys (use .ssh/config to specify it)
    start_onos="ssh %s \"cd ONOS; ./start-onos.sh start\"" % (controller_name)
    stop_onos="ssh %s \"cd ONOS; ./start-onos.sh stop\"" % (controller_name)
#    start_onos="ssh -i ~/.ssh/onlabkey.pem %s ONOS/start-onos.sh start" % (controller_name)
#    stop_onos="ssh -i ~/.ssh/onlabkey.pem %s ONOS/start-onos.sh stop" % (controller_name)

  if cmd == "up":
    result=os.popen(start_onos).read()
    ret = "controller %s is up: %s" % (controller_name, result)
  elif cmd == "down":
    result=os.popen(stop_onos).read()
    ret = "controller %s is down: %s" % (controller_name, result)

  return ret

@app.route("/gui/switchctrl/<cmd>")
def switch_controller_setting(cmd):
  if cmd =="local":
    print "All aggr switches connects to local controller only"
    result=""
    if (TESTBED == "sw"):
      for i in range(1, len(controllers)):
          cmd_string="ssh %s 'cd ONOS/scripts; ./ctrl-local.sh'" % (controllers[i])
          result += os.popen(cmd_string).read()
    else:
      cmd_string="cd; switch local > /tmp/watch"
      result += os.popen(cmd_string).read()
  elif cmd =="all":
    print "All aggr switches connects to all controllers except for core controller"
    result=""
    if (TESTBED == "sw"):
      for i in range(1, len(controllers)):
        cmd_string="ssh %s 'cd ONOS/scripts; ./ctrl-add-ext.sh'" % (controllers[i])
#        cmd_string="ssh -i ~/.ssh/onlabkey.pem %s 'cd ONOS/scripts; ./ctrl-add-ext.sh'" % (controllers[i])
        print "cmd is: "+cmd_string
        result += os.popen(cmd_string).read()
    else:
      cmd_string="/home/admin/bin/switch all > /tmp/watch"
      result += os.popen(cmd_string).read()

  return result

@app.route("/gui/reset")
def reset_demo():
  if (TESTBED == "hw"):
    cmd_string="cd ~/bin; ./demo-reset-hw.sh > /tmp/watch &"
  else:
    cmd_string="cd ~/ONOS/scripts; ./demo-reset-sw.sh > /tmp/watch &"
  os.popen(cmd_string)
  return "Reset" 

@app.route("/gui/scale")
def scale_demo():
  if (TESTBED == "hw"):
    cmd_string="cd ~/bin;  ~/bin/demo-scale-out-hw.sh > /tmp/watch &"
  else:
    cmd_string="cd ~/ONOS/scripts; ./demo-scale-out-sw.sh > /tmp/watch &"
  os.popen(cmd_string)
  return "scale"

@app.route("/gui/switch/<cmd>/<dpid>")
def switch_status_change(cmd, dpid):
  result = ""
  if (TESTBED == "hw"):
    return result

  r = re.compile(':')
  dpid = re.sub(r, '', dpid)
  host=controllers[0]
  cmd_string="ssh %s 'cd ONOS/scripts; ./switch.sh %s %s'" % (host, dpid, cmd)
#  cmd_string="ssh -i ~/.ssh/onlabkey.pem %s 'cd ONOS/scripts; ./switch.sh %s %s'" % (host, dpid, cmd)
  get_status="ssh -i ~/.ssh/onlabkey.pem %s 'cd ONOS/scripts; ./switch.sh %s'" % (host, dpid)
  print "cmd_string"

  if cmd =="up" or cmd=="down":
    print "make dpid %s %s" % (dpid, cmd)
    os.popen(cmd_string)
    result=os.popen(get_status).read()

  return result

#* Link Up
#http://localhost:9000/gui/link/up/<src_dpid>/<src_port>/<dst_dpid>/<dst_port>
@app.route("/gui/link/up/<src_dpid>/<src_port>/<dst_dpid>/<dst_port>")
def link_up(src_dpid, src_port, dst_dpid, dst_port):
  result = ""

  if (TESTBED == "sw"):
    result = link_up_sw(src_dpid, src_port, dst_dpid, dst_port)
  else:
    result = link_up_hw(src_dpid, src_port, dst_dpid, dst_port)
  return result

# Link up on software testbed
def link_up_sw(src_dpid, src_port, dst_dpid, dst_port):

  cmd = 'up'
  result=""
  for dpid in (src_dpid, dst_dpid):
    if dpid in core_switches:
      host = controllers[0]
    else:
      hostid=int(dpid.split(':')[-2])
      host = controllers[hostid-1]

    if dpid == src_dpid:
      (port, dontcare) = get_link_ports(dpid, dst_dpid)
    else:
      (port, dontcare) = get_link_ports(dpid, src_dpid)

#    cmd_string="ssh -i ~/.ssh/onlabkey.pem %s 'cd ONOS/scripts; ./link.sh %s %s %s'" % (host, dpid, port, cmd)
    cmd_string="ssh %s 'cd ONOS/scripts; ./link.sh %s %s %s'" % (host, dpid, port, cmd)
    print cmd_string
    res=os.popen(cmd_string).read()
    result = result + ' ' + res

  return result

#      if hostid == 2 :
#        src_ports = [51]
#      else :
#        src_ports = [26]
#
#    for port in src_ports :
#      cmd_string="ssh -i ~/.ssh/onlabkey.pem %s 'cd ONOS/scripts; ./link.sh %s %s %s'" % (host, dpid, port, cmd)
#      print cmd_string
#      res=os.popen(cmd_string).read()



# Link up on hardware testbed
def link_up_hw(src_dpid, src_port, dst_dpid, dst_port):

	port1 = src_port
	port2 = dst_port
	if src_dpid == "00:00:00:00:ba:5e:ba:11":
		if dst_dpid == "00:00:00:08:a2:08:f9:01":
			port1 = 24
			port2 = 24
		elif dst_dpid == "00:01:00:16:97:08:9a:46":
			port1 = 23
			port2 = 23
	elif src_dpid == "00:00:00:00:ba:5e:ba:13":
                if dst_dpid == "00:00:20:4e:7f:51:8a:35":
			port1 = 22
			port2 = 22
                elif dst_dpid == "00:00:00:00:00:00:ba:12":
			port1 = 23
			port2 = 23
	elif src_dpid == "00:00:00:00:00:00:ba:12":
                if dst_dpid == "00:00:00:00:ba:5e:ba:13":
			port1 = 23
			port2 = 23
                elif dst_dpid == "00:00:00:08:a2:08:f9:01":
			port1 = 22
			port2 = 22
                elif dst_dpid == "00:00:20:4e:7f:51:8a:35":
			port1 = 24
			port2 = 21
	elif src_dpid == "00:01:00:16:97:08:9a:46":
                if dst_dpid == "00:00:00:00:ba:5e:ba:11":
			port1 = 23
			port2 = 23
                elif dst_dpid == "00:00:20:4e:7f:51:8a:35":
			port1 = 24
			port2 = 24
	elif src_dpid == "00:00:00:08:a2:08:f9:01":
                if dst_dpid == "00:00:00:00:ba:5e:ba:11":
			port1 = 24
			port2 = 24
                elif dst_dpid == "00:00:00:00:00:00:ba:12":
			port1 = 22
			port2 = 22
                elif dst_dpid == "00:00:20:4e:7f:51:8a:35":
			port1 = 23
			port2 = 23
	elif src_dpid == "00:00:20:4e:7f:51:8a:35":
                if dst_dpid == "00:00:00:00:00:00:ba:12":
			port1 = 21
			port2 = 24
                elif dst_dpid == "00:00:00:00:ba:5e:ba:13":
			port1 = 22
			port2 = 22
                elif dst_dpid == "00:01:00:16:97:08:9a:46":
			port1 = 24
			port2 = 24
                elif dst_dpid == "00:00:00:08:a2:08:f9:01":
			port1 = 23
			port2 = 23

	cmd = 'up'
	result=""
	host = controllers[0]
	cmd_string="~/ONOS/scripts/link-hw.sh %s %s %s " % (src_dpid, port1, cmd)
	print cmd_string
	res=os.popen(cmd_string).read()
	result = result + ' ' + res
	cmd_string="~/ONOS/scripts/link-hw.sh %s %s %s " % (dst_dpid, port2, cmd)
	print cmd_string
	res=os.popen(cmd_string).read()
	result = result + ' ' + res


	return result


#* Link Down
#http://localhost:9000/gui/link/down/<src_dpid>/<src_port>/<dst_dpid>/<dst_port>
@app.route("/gui/link/<cmd>/<src_dpid>/<src_port>/<dst_dpid>/<dst_port>")
def link_down(cmd, src_dpid, src_port, dst_dpid, dst_port):

  if src_dpid in core_switches:
    host = controllers[0]
  else:
    hostid=int(src_dpid.split(':')[-2])
    host = controllers[hostid-1]

  if (TESTBED == "sw"):
    cmd_string="ssh %s 'cd ONOS/scripts; ./link.sh %s %s %s'" % (host, src_dpid, src_port, cmd)
  else:
    if ( src_dpid == "00:00:00:08:a2:08:f9:01" ):
      cmd_string="~/ONOS/scripts/link-hw.sh %s %s %s " % ( dst_dpid, dst_port, cmd)
    else:
      cmd_string="~/ONOS/scripts/link-hw.sh %s %s %s " % ( src_dpid, src_port, cmd)
  print cmd_string

  result=os.popen(cmd_string).read()

  return result

#* Create Flow
#http://localhost:9000/gui/addflow/<src_dpid>/<src_port>/<dst_dpid>/<dst_port>/<srcMAC>/<dstMAC>
#1 FOOBAR 00:00:00:00:00:00:01:01 1 00:00:00:00:00:00:01:0b 1 matchSrcMac 00:00:00:00:00:00 matchDstMac 00:01:00:00:00:00
@app.route("/gui/addflow/<src_dpid>/<src_port>/<dst_dpid>/<dst_port>/<srcMAC>/<dstMAC>")
def add_flow(src_dpid, src_port, dst_dpid, dst_port, srcMAC, dstMAC):
  host = pick_host()
  url ="%s/wm/onos/flows/getsummary/%s/%s/json" % (host, 0, 0)
  (code, result) = get_json(url)
  parsedResult = json.loads(result)
  if len(parsedResult) > 0:
    if parsedResult[-1].has_key('flowId'):
      flow_nr = int(parsedResult[-1]['flowId']['value'], 16)
  else:
    flow_nr = -1  # first flow
    print "first flow"

  flow_nr += 1
  command =  "%s/web/add_flow.py -m onos %d %s %s %s %s %s matchSrcMac %s matchDstMac %s" % (ONOSDIR, flow_nr, "dummy", src_dpid, src_port, dst_dpid, dst_port, srcMAC, dstMAC)
  flow_nr += 1
  command1 = "%s/web/add_flow.py -m onos %d %s %s %s %s %s matchSrcMac %s matchDstMac %s" % (ONOSDIR, flow_nr, "dummy", dst_dpid, dst_port, src_dpid, src_port, dstMAC, srcMAC)
  print "add flow: %s, %s" % (command, command1)
  errcode = os.popen(command).read()
  errcode1 = os.popen(command1).read()
  ret=command+":"+errcode+" "+command1+":"+errcode1
  print ret 
  return ret

#* Delete Flow
#http://localhost:9000/gui/delflow/<flow_id>
@app.route("/gui/delflow/<flow_id>")
def del_flow(flow_id):
  command = "%/web/delete_flow.py %s" % (ONOSDIR, flow_id)
  print command
  errcode = os.popen(command).read()
  return errcode

#* Start Iperf Througput
#http://localhost:9000/gui/iperf/start/<flow_id>/<duration>
@app.route("/gui/iperf/start/<flow_id>/<duration>/<samples>")
def iperf_start(flow_id,duration,samples):
  url = "http://%s:%s/wm/onos/flows/get/%s/json" % (RestIP, RestPort, flow_id)
  try:
    response = urlopen(url)
    result = response.read()
    if len(result) == 0:
      print "No Flow found"
      return "Flow %s not found" % (flow_id);
  except:
    print "REST IF has issue %s" % url
    return "REST IF has issue %s" % url

  parsedResult = json.loads(result)

  flowId = int(parsedResult['flowId']['value'], 16)
  src_dpid = parsedResult['dataPath']['srcPort']['dpid']['value']
  src_port = parsedResult['dataPath']['srcPort']['port']['value']
  dst_dpid = parsedResult['dataPath']['dstPort']['dpid']['value']
  dst_port = parsedResult['dataPath']['dstPort']['port']['value']
#  print "FlowPath: (flowId = %s src = %s/%s dst = %s/%s" % (flowId, src_dpid, src_port, dst_dpid, dst_port)

  if src_dpid in core_switches:
      src_host = controllers[0]
  else:
      hostid=int(src_dpid.split(':')[-2])
      if TESTBED == "hw":
        src_host = "mininet%i" % hostid
      else:
        src_host = controllers[hostid-1]

  if dst_dpid in core_switches:
      dst_host = controllers[0]
  else:
      hostid=int(dst_dpid.split(':')[-2])
      if TESTBED == "hw":
        dst_host = "mininet%i" % hostid
      else:
        dst_host = controllers[hostid-1]

# /runiperf.sh <flowid> <src_dpid> <dst_dpid> hw:svr|sw:svr|hw:client|sw:client <proto>/<duration>/<interval>/<samples>
  protocol="udp"
  interval=0.1
  if TESTBED == "hw":
    cmd_string="dsh -w %s 'cd ONOS/scripts; " % dst_host
  else:
    cmd_string="ssh %s 'cd ONOS/scripts; " % dst_host
  cmd_string += "./runiperf.sh %d %s %s %s:%s %s/%s/%s/%s'" % (flowId, src_dpid, dst_dpid, TESTBED, "svr", protocol, duration, interval, samples)
  print cmd_string
  os.popen(cmd_string)

  if TESTBED == "hw":
    cmd_string="dsh -w %s 'cd ONOS/scripts; " % src_host
  else:
    cmd_string="ssh %s 'cd ONOS/scripts;" % src_host
  cmd_string+="./runiperf.sh %d %s %s %s:%s %s/%s/%s/%s'" % (flowId, src_dpid, dst_dpid, TESTBED, "client", protocol, duration, interval, samples)
  print cmd_string
  os.popen(cmd_string)

  return cmd_string


#* Get Iperf Throughput
#http://localhost:9000/gui/iperf/rate/<flow_id>
@app.route("/gui/iperf/rate/<flow_id>")
def iperf_rate(flow_id):
  url = "http://%s:%s/wm/onos/flows/get/%s/json" % (RestIP, RestPort, flow_id)
  try:
    response = urlopen(url)
    result = response.read()
    if len(result) == 0:
      return "no such iperf flow (flowid %s)" % flow_id
  except:
    print "REST IF has issue %s" % url
    exit

  parsedResult = json.loads(result)

  flowId = int(parsedResult['flowId']['value'], 16)
  src_dpid = parsedResult['dataPath']['srcPort']['dpid']['value']
  src_port = parsedResult['dataPath']['srcPort']['port']['value']
  dst_dpid = parsedResult['dataPath']['dstPort']['dpid']['value']
  dst_port = parsedResult['dataPath']['dstPort']['port']['value']

  if dst_dpid in core_switches:
    host = controllers[0]
  else:
    hostid=int(dst_dpid.split(':')[-2])
    if TESTBED == "hw":
      host = "mininet%i" % hostid
    else:
      host = controllers[hostid-1]

  url="http://%s:%s/log/iperfsvr_%s.out" % (host, 9000, flow_id)
  try:
    response = urlopen(url)
    result = response.read()
  except:
    print "REST IF has issue %s" % url
    return 

  if re.match("Cannot", result):
    resp = Response(result, status=400, mimetype='text/html')
    return "no iperf file found (host %s flowid %s): %s" % (host, flow_id, result)
  else:
    resp = Response(result, status=200, mimetype='application/json')
    return resp

if __name__ == "__main__":
  random.seed()
  read_config()
  read_link_def()
  if len(sys.argv) > 1 and sys.argv[1] == "-d":
    # for debugging
    #add_flow("00:00:00:00:00:00:02:02", 1, "00:00:00:00:00:00:03:02", 1, "00:00:00:00:02:02", "00:00:00:00:03:0c")
    #proxy_link_change("up", "00:00:00:00:ba:5e:ba:11", 1, "00:00:00:00:00:00:00:00", 1)
    #proxy_link_change("down", "00:00:20:4e:7f:51:8a:35", 1, "00:00:00:00:00:00:00:00", 1)
    #proxy_link_change("up", "00:00:00:00:00:00:02:03", 1, "00:00:00:00:00:00:00:00", 1)
    #proxy_link_change("down", "00:00:00:00:00:00:07:12", 1, "00:00:00:00:00:00:00:00", 1)
    #print "-- query all switches --"
    #query_switch()
    #print "-- query topo --"
    #topology_for_gui()
    ##print "-- query all links --"
    ##query_links()
    #print "-- query all devices --"
    #devices()
    #links()
    #switches()
    #reset_demo()
    pass
  else:
    app.debug = True
    app.run(threaded=True, host="0.0.0.0", port=9000)