wishful_handover_controller

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
wifi_handover_controller.py: A simple client load-balancing (handover) demo. Here 1-2 client STAs are
periodically handovered from one AP to another.

Req.:
- 2 APs,
- 1 GW node,
- 1-2 client STAs

Usage:
   wifi_handover_controller.py [options] [-q | -v]

Options:
   --logfile name      Name of the logfile
   --config configFile Config file path

Example:
   ./wifi_handover_controller -v

Other options:
   -h, --help          show this help message and exit
   -q, --quiet         print less text
   -v, --verbose       print more text
   --version           show version and exit
"""

import sys
import gevent
import logging
import wishful_controller
import wishful_upis as upis
import time

__author__ = "Piotr Gawlowicz, Anatolij Zubow"
__copyright__ = "Copyright (c) 2015, Technische Universitat Berlin"
__version__ = "0.1.0"
__email__ = "{gawlowicz, zubow}@tkn.tu-berlin.de"


log = logging.getLogger('wishful_agent.main')
controller = wishful_controller.Controller(dl="tcp://127.0.0.1:8990", ul="tcp://127.0.0.1:8989")
nodes = []

#
# Topology: 2x AP, 1x GW and 1-2 STAs
#

# AP0
node0_name = "nuc4"
node0_ip = "192.168.103.136"
node0_ch = 44

# AP1
node1_name = "nuc2"
node1_ip = "192.168.103.125"
node1_ch = 48

# Gateway node
gateway_name = "nuc1"
gateway_ip = "192.168.103.115"

# iface to use
wlan_iface = 'ap1'
wlan_inject_iface = 'inject1'

# BSSID of our Network
network_bssid = "D0:0E:A4:09:11:A3"


gateway = None

@controller.new_node_callback()
def new_node_cb(node):
    nodes.append(node.id)
    log.debug('NodeEnter: NodeID: ' % node)
    if node.ip == gateway_ip:
        gateway = node

@controller.node_exit_callback()
def exit_node_cb(node, reason):
    if node.id in nodes:
        nodes.remove(node.id)
    log.debug("NodeExit : NodeID : %s Reason : %s" % (node.id, reason))


def runDualPeriodicSwitching(switchingInterval):
    """
     Periodic handover of two client STAs
    """

    sta1_mac_addr = "ec:1f:72:82:09:56"
    sta1_ip = "192.168.5.222"
    ho1_type = 0 #HandoverTypes.Soft_CSA

    sta2_mac_addr = 'd0:22:be:b7:76:8c'
    sta2_ip = "192.168.5.200"
    ho2_type = 1 #HandoverTypes.Hard_BL

    numSTAs = 2

    while True:

        # for each STA
        for sta_ii in range(numSTAs):
            if sta_ii == 0:
                sta_mac_addr = sta1_mac_addr
                sta_ip = sta1_ip
                ho_type = ho1_type
            else:
                sta_mac_addr = sta2_mac_addr
                sta_ip = sta2_ip
                ho_type = ho2_type

            log.info("Performing Handover OP ...")
            performHO(sta_mac_addr, sta_ip, ho_type)

        # reschedule handover
        log.info("Handover successful")
        time.sleep(switchingInterval)  # wait


def runSinglePeriodicSwitching(ho_scheme, switching_interval = 30):

    """
     Periodic handover of singe client STA
    """

    sta_mac_addr = 'd0:22:be:b7:76:8c'
    sta_ip = "192.168.5.200"

    while True:
        performHO(sta_mac_addr, sta_ip, ho_scheme)
        time.sleep(switching_interval)


def performHO(sta_mac_addr, sta_ip, ho_scheme):

    """
        perform handover
    """

    try:
        log.debug('********* testPerformHardHO **********')

        # find out which AP is currently controlling this client STA
        serving_AP = controller.wireless_topology.is_associated_with(nodes, wlan_iface, sta_mac_addr)

        if str(serving_AP) == str(nodes[0]):
            target_AP = nodes[1]
            target_channel = node1_ch
            serving_channel = node0_ch
            serving_AP_ip = node0_ip
            target_AP_ip = node1_ip
            serving_AP_name = node0_name
            target_AP_name = node1_name
        elif str(serving_AP) == str(nodes[1]):
            target_AP = nodes[0]
            target_channel = node0_ch
            serving_channel = node1_ch
            serving_AP_ip = node1_ip
            target_AP_ip = node0_ip
            serving_AP_name = node1_name
            target_AP_name = node0_name
        else:
            log.debug('STA is served by an unknown AP; backoff')
            return

        log.debug('Serving AP of %s is %s' % (str(sta_mac_addr), str(serving_AP_name)))
        log.debug('Move STA %s from %s to %s' % (str(sta_mac_addr), str(serving_AP_name), str(target_AP_name)))

        retVal = controller.handover.perform_handover(wlan_iface, serving_AP, target_AP, sta_mac_addr,
                                                      wlan_inject_iface = wlan_inject_iface, sta_ip = sta_ip,
                                                      servingAP_ip = serving_AP_ip, servingChannel = serving_channel,
                                                      network_bssid = network_bssid, targetAP_ip = target_AP_ip,
                                                      targetChannel = target_channel, gateway = gateway,
                                                      ho_type = ho_scheme)

        log.debug('HO result %s' % (str(retVal)))

    except Exception as e:
        log.fatal("... An error occurred : %s" % e)
        raise e

# possible scenarios
class HOScenarios:
    SINGLE_HARD, SINGLE_SOFT, DOUBLE_HARD_SOFT = list(range(2))

def main(args):
    log.debug(args)
    controller.add_module(moduleName="handover", pyModuleName="wishful_module_handover",
                          className="HandoverModule", importAs="handover")

    controller.start()

    log.debug("waiting for nodes ...")

    # wait until all nodes become available
    while True:
        gevent.sleep(1)

        if len(nodes) == 3:
            # we need two APs and a GW node
            break

    log.debug(" ... done: %s" % str(nodes))

    mode = HOScenarios.SINGLE_SOFT

    # in seconds
    switchingInterval = 30

    if mode == HOScenarios.DOUBLE_HARD_SOFT:
        # two nodes are periodically switched
        runDualPeriodicSwitching(switchingInterval)
    elif mode == HOScenarios.SINGLE_SOFT:
        # single node HO via soft
        runSinglePeriodicSwitching(0, switchingInterval)
    elif mode == HOScenarios.SINGLE_HARD:
        # single node HO via hard
        runSinglePeriodicSwitching(1, switchingInterval)
    else:
        log.fatal('Unknown scenario; stopping')
        raise Exception("Unknown scenario")

    log.info('Global controller stopped')


if __name__ == "__main__":
    try:
        from docopt import docopt
    except:
        print("""
        Please install docopt using:
            pip install docopt==0.6.1
        For more refer to:
        https://github.com/docopt/docopt
        """)
        raise

    args = docopt(__doc__, version=__version__)

    log_level = logging.INFO  # default
    if args['--verbose']:
        log_level = logging.DEBUG
    elif args['--quiet']:
        log_level = logging.ERROR

    logfile = None
    if args['--logfile']:
        logfile = args['--logfile']

    logging.basicConfig(filename=logfile, level=log_level,
        format='%(asctime)s - %(name)s.%(funcName)s() - %(levelname)s - %(message)s')

    try:
        main(args)
    except KeyboardInterrupt:
        log.debug("Controller exits")
    finally:
        log.debug("Exit")
        controller.stop()