def my_start_function(self): self.log.info("start control app") self.running = True node = self.localNode self.log.debug("My local node: {}, Local: {}".format( node.hostname, node.local)) for dev in node.get_devices(): self.log.debug("Dev: %s" % dev.name) for m in node.get_modules(): self.log.debug("Module: %s" % m.name) for apps in node.get_control_applications(): self.log.debug("App: %s" % apps.name) self.device = node.get_device(0) # activate GnuRadio RP self.grc_radio_program_name = 'test' inval = {} inval['ID'] = 11 inval['grc_radio_program_code'] = self.grc_xml self.device.activate_radio_program(self.grc_radio_program_name, **inval) self.timeInterval = 1 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval)
class Pinger(modules.ControlApplication): def __init__(self, hostList=[], interval=1): super(Pinger, self).__init__() self.log = logging.getLogger('Pinger') self.pingInterval = interval self.pingTimer = TimerEventSender(self, PingTimeEvent) self.pingTimer.start(self.pingInterval) self.hostList = hostList def _ping(self, address): status, result = sp.getstatusoutput("ping -c1 -w5 " + str(address)) if status == 0: return True else: return False @modules.on_event(PingTimeEvent) def send_random_samples(self, event): # reschedule function self.pingTimer.start(self.pingInterval) # ping devices for host in self.hostList: isUp = self._ping(host) if isUp: self.log.debug("Host {} is UP".format(host)) else: self.log.debug("Host {} is DOWN".format(host)) event = HostStateEvent(host, isUp) self.send_event(event)
def my_start_function(self): self.log.info("start control app") node = self.localNode self.log.debug("My local node: {}, Local: {}" .format(node.hostname, node.local)) for dev in node.get_devices(): self.log.debug("Dev: %s" % dev.name) for m in node.get_modules(): self.log.debug("Module: %s" % m.name) for apps in node.get_control_applications(): self.log.debug("App: %s" % apps.name) # start iperf server iperfServerEvent = IperfServerRequestEvent() #iperfServerEvent.resultReportInterval = 1 iperfServerEvent.stopAfterFirstReport = True self.log.info("Start iperf server ...") self.send_event(iperfServerEvent) self.timeInterval = 1 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval)
def __init__(self): super(MyController, self).__init__() self.log = logging.getLogger('MyController') self.running = False self.timeInterval = 10 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval)
def __init__(self, hostList=[], interval=1): super(Pinger, self).__init__() self.log = logging.getLogger('Pinger') self.pingInterval = interval self.pingTimer = TimerEventSender(self, PingTimeEvent) self.pingTimer.start(self.pingInterval) self.hostList = hostList
class MyIperfController(modules.ControlApplication): def __init__(self): super(MyIperfController, self).__init__() self.log = logging.getLogger('MyIperfControllerWithAppIntents') @modules.on_start() def my_start_function(self): self.log.info("start control app") node = self.localNode self.log.debug("My local node: {}, Local: {}".format( node.hostname, node.local)) for dev in node.get_devices(): self.log.debug("Dev: %s" % dev.name) for m in node.get_modules(): self.log.debug("Module: %s" % m.name) for apps in node.get_control_applications(): self.log.debug("App: %s" % apps.name) # start iperf server iperfServerEvent = IperfServerRequestEvent() #iperfServerEvent.resultReportInterval = 1 iperfServerEvent.stopAfterFirstReport = True iperfServerEvent.app_intent = LongBulkTransferIntent() self.log.info("Start iperf server ...") self.send_event(iperfServerEvent) self.timeInterval = 1 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval) @modules.on_exit() def my_stop_function(self): print("stop control app") @modules.on_event(PeriodicEvaluationTimeEvent) def start_iperf_client(self, event): self.log.info("Start iperf client ...") self.log.info("application intent: ") # start iperf client iperfClientEvent = IperfClientRequestEvent() iperfClientEvent.resultReportInterval = 1 iperfClientEvent.stopAfterFirstReport = False iperfClientEvent.transmissionTime = 5 iperfClientEvent.destination = '127.0.0.1' iperfClientEvent.app_intent = LongBulkTransferIntent() self.log.info("Start iperf client ...") self.send_event(iperfClientEvent)
def __init__(self): super(SlaveController, self).__init__() self.log = logging.getLogger('SlaveController') self.running = False self.timeInterval = 10 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval) self.dut_iface = "eno1" self.bn_iface = "wlp2s0"
def __init__(self): super(MyController, self).__init__() self.log = logging.getLogger('MyController') self.running = False self.nodes = [] self.timeInterval = 10 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval) self.myFilterRunning = False self.packetLossEventsEnabled = False
def __init__(self, title=''): super(SimpleBenchmark, self).__init__() self.log = logging.getLogger('SimpleBenchmark') self.title = title self.running = False self.timeInterval = 4 self.blocking_timer = TimerEventSender( self, PeriodicBlockingEvaluationTimeEvent) self.non_blocking_timer = TimerEventSender( self, PeriodicNonBlockingEvaluationTimeEvent) self.non_blocking_timer.start(self.timeInterval) self.packetLossEventsEnabled = False
def my_start_function(self): self.log.info("start control app") self.channel_lst = (1, 3, 6, 9, 11) self.next_channel_idx = 1 self.ifaceName = 'mon0' self.start = None #self.hopping_interval = 3 self.margot_uuid = None # CSI stuff self.results = [] self.timeInterval = 1 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval)
def my_start_function(self): self.log.info("start wifi radio slicer") # store object referenes node = self.localNode self.log.info(node) self.device = node.get_device(0) self.log.info(self.device) self.myHMACID = 'RadioSlicerID' self.iface = 'ap5' self.total_slots = 30 self.phy_to_data_factor = 0.4 # slots are in microseonds slot_duration = 10000 # 20 ms sta1 = "00:15:6d:86:0f:84" #tv set, IP: 192.168.6.10 sta2 = '00:16:ea:5f:2a:03' #internet radio, IP: 192.168.6.20 sta3 = "ec:1f:72:82:09:56" #Mobile Phone youtube, IP 192.168.6.30 sta4 = "00:15:6d:84:3c:12" #Guest Smartphone 1, IP: 192.168.7.10 sta5 = "00:15:6d:84:3c:13" #Guest Smartphone 2, IP: 192.168.7.20 self.min_rates = {sta1: 10.0, sta2: 1.0} self.min_rate_home_devices = 1.0 self.phy_rates = {} self.min_slots = {} # create new MAC for local node self.mac = HMACConfigParam(no_slots_in_superframe=self.total_slots, slot_duration_ns=slot_duration) # assign allow all to each slot for slot_nr in range(self.total_slots): acGuard = HMACAccessPolicyParam() acGuard.allowAll() # allow all self.mac.addAccessPolicy(slot_nr, acGuard) self.mac.printConfiguration() # install configuration in MAC #self.device.install_mac_processor(self.iface, self.mac) self.device.activate_radio_program(self.myHMACID, self.mac, self.iface) self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.update_interval) self.log.info('... done')
def my_start_function(self): self.log.debug("start scanner app") # start scanner self.exec_file = 'scanner/scanner' self.processArgs = self.exec_file + ' ' + self.scan_iface self.process = subprocess.Popen(self.processArgs.split(), shell=False) # wait to settle down time.sleep(1) # channel hopping every 100ms self.chHoppingTimeInterval = self.hopping_interval self.chTimer = TimerEventSender(self, PeriodicChannelSwitchTimeEvent) self.chTimer.start(self.chHoppingTimeInterval) # reporting signal quality as event self.reportingTimeInterval = self.reporting_interval self.reportingTimer = TimerEventSender(self, PeriodicCQIReportingTimeEvent) self.reportingTimer.start(self.reportingTimeInterval)
def my_start_function(self): self.log.info("start wifi radio slicer") # store object referenes node = self.localNode self.log.info(node) self.device = node.get_device(0) self.log.info(self.device) self.iface = 'ap5' self.total_slots = 20 # slots are in microseonds slot_duration = 20000 # 20 ms sta1 = "00:15:6d:84:fb:7a" #fernseher self.min_rates = {sta1 : 15.0} self.phy_rates = {} self.min_slots = {} # create new MAC for local node self.mac = HMACConfigParam( no_slots_in_superframe=self.total_slots, slot_duration_ns=slot_duration) # assign allow all to each slot for slot_nr in range(self.total_slots): acGuard = HMACAccessPolicyParam() acGuard.allowAll() # allow all self.mac.addAccessPolicy(slot_nr, acGuard) self.mac.printConfiguration() # install configuration in MAC self.device.install_mac_processor(self.iface, self.mac) self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.update_interval) self.log.info('... done')
class ChannelSounderWiFiController(modules.ControlApplication): def __init__(self, num_nodes): super(ChannelSounderWiFiController, self).__init__() self.log = logging.getLogger('ChannelSounderWiFiController') self.log.info("ChannelSounderWiFiController") self.nodes = {} # APs UUID -> node self.num_nodes = num_nodes @modules.on_start() def my_start_function(self): self.log.info("start control app") self.channel_lst = (1, 3, 6, 9, 11) self.next_channel_idx = 1 self.ifaceName = 'mon0' self.start = None #self.hopping_interval = 3 self.margot_uuid = None # CSI stuff self.results = [] self.timeInterval = 1 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval) def schedule_ch_switch(self): try: # schedule first channel switch in now + 3 seconds #if self.start == None: # self.start = datetime.datetime.now() + datetime.timedelta(seconds=3) #else: # self.start = self.start + datetime.timedelta(seconds=self.hopping_interval) # new channel self.next_channel_idx = (self.next_channel_idx + 1) % len( self.channel_lst) nxt_channel = self.channel_lst[self.next_channel_idx] self.log.info('schedule_ch_switch at %s to %d' % (str(self.start), nxt_channel)) for node in self.nodes.values(): device = node.get_device(0) #device.exec_time(self.start).callback(self.channel_set_cb).set_channel(nxt_channel, self.ifaceName) if node.uuid == self.margot_uuid: device.callback(self.channel_set_cb).set_channel( nxt_channel, self.ifaceName) else: device.callback(self.channel_set_cb).set_channel( nxt_channel, 'wlan0') except Exception as e: self.log.error("{} !!!Exception!!!: {}".format( datetime.datetime.now(), e)) def channel_set_cb(self, data): """ Callback function called when channel switching is done """ node = data.node device = node.get_device(0) samples = 1 csi = device.get_csi(samples, False) tuple = (self.channel_lst[self.next_channel_idx], node.uuid, csi) self.results.append(tuple) @modules.on_exit() def my_stop_function(self): print("stop control app") @modules.on_event(events.NewNodeEvent) def add_node(self, event): node = event.node self.log.info("Added new node: {}, Local: {}".format( node.uuid, node.local)) self.nodes[node.uuid] = node devs = node.get_devices() for dev in devs: self.log.info("Dev: %s" % str(dev.name)) ifaces = dev.get_interfaces() self.log.info('Ifaces %s' % ifaces) if 'mon0' in ifaces: self.margot_uuid = node.uuid @modules.on_event(events.NodeExitEvent) @modules.on_event(events.NodeLostEvent) def remove_node(self, event): self.log.info("Node lost".format()) node = event.node reason = event.reason if node in self.nodes: del self.nodes[node.uuid] self.log.info("Node: {}, Local: {} removed reason: {}".format( node.uuid, node.local, reason)) @modules.on_event(PeriodicEvaluationTimeEvent) def periodic_evaluation(self, event): print("all node are available ...") self.timer.start(self.timeInterval) if len(self.nodes) < self.num_nodes: # wait again pass else: self.schedule_ch_switch()
def my_start_function(self): self.log.info("start wifi radio slicer") # store object referenes node = self.localNode self.log.info(node) self.device = node.get_device(0) self.log.info(self.device) self.myHMACID = 'RadioSlicerID' self.iface = 'ap5' self.total_slots = 20 self.phy_to_data_factor = 0.6 # slots are in microseonds self.slot_duration = 10000 # 10 ms self.stepperiod = 3 sta1 = "00:15:6d:86:0f:84" #tv set, IP: 192.168.6.10 sta2 = '00:16:ea:5f:2a:03' #internet radio, IP: 192.168.6.20 sta3 = "ec:1f:72:82:09:56" #Mobile Phone youtube, IP 192.168.6.30 sta4 = "00:15:6d:84:3c:12" #Guest Smartphone 1, IP: 192.168.7.10 sta5 = "00:15:6d:84:3c:13" #Guest Smartphone 2, IP: 192.168.7.20 self.min_rates = {sta1: 15.0, sta2: 1.0} self.min_rate_home_devices = 1.0 self.phy_rates = {} self.min_slots = {} self.stop = False self.runs = 0 # create new MAC for local node self.mac = HMACConfigParam(no_slots_in_superframe=self.total_slots, slot_duration_ns=self.slot_duration) # assign allow all to each slot for slot_nr in range(self.total_slots): acGuard = HMACAccessPolicyParam() acGuard.allowAll() # allow all self.mac.addAccessPolicy(slot_nr, acGuard) self.mac.printConfiguration() # install configuration in MAC #self.device.install_mac_processor(self.iface, self.mac) self.device.activate_radio_program(self.myHMACID, self.mac, self.iface) print( "*************************************************************\n") print("EQUAL SHARE FOR ALL\n") print( "*************************************************************\n") staslotshareevent = StaSlotShareEvent("TV", 33) self.send_event(staslotshareevent) staslotshareevent = StaSlotShareEvent("Guest1", 33) self.send_event(staslotshareevent) staslotshareevent = StaSlotShareEvent("Guest2", 33) self.send_event(staslotshareevent) #self.log.debug('... Waiting 100s') #time.sleep(100) #print("*************************************************************\n") #print("SLICER ACTIVATED!!!!\n") #print("*************************************************************\n") self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.update_interval) #self.log.debug('... Waiting 100s') #time.sleep(100) #self.log.debug('... done') #self.stop = True #self.log.debug('... Enabling free for all') # assign allow all to each slot #for slot_nr in range(self.total_slots): # acGuard = HMACAccessPolicyParam() # acGuard.allowAll() # allow all # self.mac.addAccessPolicy(slot_nr, acGuard) #self.mac.printConfiguration() #self.log.debug('... Calling Stop Function') #self.my_stop_function() self.log.debug('... done')
class LocalRadioSlicer(modules.ControlApplication): def __init__(self): super(LocalRadioSlicer, self).__init__() self.log = logging.getLogger('LocalRadioSlicer') self.update_interval = 10 # 1 sec @modules.on_start() def my_start_function(self): self.log.info("start wifi radio slicer") # store object referenes node = self.localNode self.log.info(node) self.device = node.get_device(0) self.log.info(self.device) self.myHMACID = 'RadioSlicerID' self.iface = 'ap5' self.total_slots = 20 self.phy_to_data_factor = 0.6 # slots are in microseonds self.slot_duration = 10000 # 10 ms self.stepperiod = 3 sta1 = "00:15:6d:86:0f:84" #tv set, IP: 192.168.6.10 sta2 = '00:16:ea:5f:2a:03' #internet radio, IP: 192.168.6.20 sta3 = "ec:1f:72:82:09:56" #Mobile Phone youtube, IP 192.168.6.30 sta4 = "00:15:6d:84:3c:12" #Guest Smartphone 1, IP: 192.168.7.10 sta5 = "00:15:6d:84:3c:13" #Guest Smartphone 2, IP: 192.168.7.20 self.min_rates = {sta1: 15.0, sta2: 1.0} self.min_rate_home_devices = 1.0 self.phy_rates = {} self.min_slots = {} self.stop = False self.runs = 0 # create new MAC for local node self.mac = HMACConfigParam(no_slots_in_superframe=self.total_slots, slot_duration_ns=self.slot_duration) # assign allow all to each slot for slot_nr in range(self.total_slots): acGuard = HMACAccessPolicyParam() acGuard.allowAll() # allow all self.mac.addAccessPolicy(slot_nr, acGuard) self.mac.printConfiguration() # install configuration in MAC #self.device.install_mac_processor(self.iface, self.mac) self.device.activate_radio_program(self.myHMACID, self.mac, self.iface) print( "*************************************************************\n") print("EQUAL SHARE FOR ALL\n") print( "*************************************************************\n") staslotshareevent = StaSlotShareEvent("TV", 33) self.send_event(staslotshareevent) staslotshareevent = StaSlotShareEvent("Guest1", 33) self.send_event(staslotshareevent) staslotshareevent = StaSlotShareEvent("Guest2", 33) self.send_event(staslotshareevent) #self.log.debug('... Waiting 100s') #time.sleep(100) #print("*************************************************************\n") #print("SLICER ACTIVATED!!!!\n") #print("*************************************************************\n") self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.update_interval) #self.log.debug('... Waiting 100s') #time.sleep(100) #self.log.debug('... done') #self.stop = True #self.log.debug('... Enabling free for all') # assign allow all to each slot #for slot_nr in range(self.total_slots): # acGuard = HMACAccessPolicyParam() # acGuard.allowAll() # allow all # self.mac.addAccessPolicy(slot_nr, acGuard) #self.mac.printConfiguration() #self.log.debug('... Calling Stop Function') #self.my_stop_function() self.log.debug('... done') @modules.on_exit() def my_stop_function(self): self.log.info("stop wifi radio slicer") # install configuration in MAC #self.device.uninstall_mac_processor(self.iface, self.mac) self.device.deactivate_radio_program(self.myHMACID) @modules.on_event(PeriodicEvaluationTimeEvent) def periodic_slice_adapdation(self, event): print("Number of Runs: " + str(self.runs)) if self.runs < self.stepperiod: staslotshareevent = StaSlotShareEvent("TV", 33) self.send_event(staslotshareevent) staslotshareevent = StaSlotShareEvent("Guest1", 33) self.send_event(staslotshareevent) staslotshareevent = StaSlotShareEvent("Guest2", 33) self.send_event(staslotshareevent) self.runs = self.runs + 1 self.timer.start(self.update_interval) elif (self.runs >= self.stepperiod) and (self.runs < 2 * self.stepperiod): self.runs = self.runs + 1 print("Periodic slice adaptations ...") if self.runs == 5: print( "*************************************************************\n" ) print( "SLICER ACTIVATED - Guaranteed Bandwidth for HOME STA1: 15Mbps\n" ) print( "*************************************************************\n" ) primary_slots_exclusive = 0 #Slots used by primary devices getting exclusive slots needed_slots_standard_primary = 0 # Slots needed by standard primary users if True: if True: # step 1: get information about client STAs being served tx_bitrate_link = self.device.get_tx_bitrate_of_connected_devices( self.iface) for sta_mac_addr, sta_speed in tx_bitrate_link.items(): #sta_tx_bitrate_val = float(sta_speed[0]) # e.g. 12 sta_tx_bitrate_val = 54.0 # e.g. 12 sta_tx_bitrate_unit = sta_speed[1] # e.g. Mbit/s print( str(sta_mac_addr) + ": STA_TX_BITRATE PHY: " + str(sta_tx_bitrate_val) + " " + str(sta_tx_bitrate_unit)) sta_tx_bitrate_val = sta_tx_bitrate_val * self.phy_to_data_factor print( str(sta_mac_addr) + ": STA_TX_BITRATE DATA: " + str(sta_tx_bitrate_val) + " " + str(sta_tx_bitrate_unit)) if sta_tx_bitrate_unit == "MBit/s": self.phy_rates[ sta_mac_addr] = sta_tx_bitrate_val #Store all PHY Rates of Primary STAs else: print("CONVERT THE BITRATE!!!!!") # TODO write converter # step 2: process link info & decide on new slice sizes for sta_mac_addr in self.phy_rates: slot_bitrate = float( self.phy_rates[sta_mac_addr]) / float( self.total_slots) print("Slot Bitrate for STA: " + str(slot_bitrate)) if sta_mac_addr in self.min_rates.keys( ): #If this primary device should get an exclusive slice print("STA need to get explusive slice") print("Policy Min Bitrate: " + str(self.min_rates[sta_mac_addr])) number_of_slots = round( self.min_rates[sta_mac_addr] / slot_bitrate + 0.5) self.min_slots[ sta_mac_addr] = number_of_slots + 1 # plus 1 because of guard slots primary_slots_exclusive = primary_slots_exclusive + number_of_slots print("Min Slots needed for exclusive primary: " + str(self.min_slots[sta_mac_addr])) else: #Primary STA will get standard slot with other non exclusive primaries but trying to get min Rate per Primary print("STA gets slice with other primaries") print( "Standard Min Bitrate for non-exclusive primaries: " + str(self.min_rate_home_devices)) number_of_slots = round( self.min_rate_home_devices / slot_bitrate + 0.5) + 1 # 1 for backup slots print( "Min Slots needed for non-exclusive primary: " + str(number_of_slots)) needed_slots_standard_primary = needed_slots_standard_primary + number_of_slots # step 3: update hMAC print("Exclusive primaries total slots: " + str(primary_slots_exclusive)) print("Non exclusive primaries total slots: " + str(needed_slots_standard_primary)) # assign access policies to each slot in superframe #Count needed slots for primary user total_used_slots_exclusive_primary = 0.0 total_used_slots_non_exclusive_primary = 0.0 total_used_slots = 0.0 for sta_mac_addr in self.min_slots: total_used_slots = total_used_slots + self.min_slots[ sta_mac_addr] if total_used_slots > self.total_slots: print( "Warning!: More slots for exclusive primaries needed as available, target bitrate for all primary users not achievable! Needed: " + str(total_used_slots) + " Available: " + str(self.total_slots)) total_used_slots = self.total_slots else: print("Total used slots for exclusive primaries: " + str(total_used_slots)) total_used_slots_exclusive_primary = total_used_slots total_used_slots = total_used_slots + needed_slots_standard_primary if total_used_slots > self.total_slots: print( "Warning!: More slots for primaries needed as available, target bitrate for all primary users not achievable! Needed: " + str(total_used_slots) + " Available: " + str(self.total_slots)) total_used_slots = self.total_slots else: print("Total used slots for primaries: " + str(total_used_slots)) total_used_slots_non_exclusive_primary = total_used_slots - total_used_slots_exclusive_primary print("Total used slots for non-exclusive primaries: " + str(total_used_slots_non_exclusive_primary)) check_exclusives = [0] * len(self.min_slots) for slot_nr in range(0, int(self.total_slots)): print("Processing slot nr: " + str(slot_nr)) #ac_slot = self.mac.getAccessPolicy(slot_nr) ac_slot = HMACAccessPolicyParam() if slot_nr == 0: print("Guard between secondaries and primaries") ac_slot.disableAll() elif slot_nr < total_used_slots_exclusive_primary: sta_number = 0 for sta_mac_addr in self.min_slots: if check_exclusives[ sta_number] < self.min_slots[ sta_mac_addr]: ac_slot.addDestMacAndTosValues( sta_mac_addr, 0) check_exclusives[ sta_number] = check_exclusives[ sta_number] + 1 if check_exclusives[ sta_number] == self.min_slots[ sta_mac_addr]: ac_slot.disableAll() print("Guard between primaries") else: print("Adding mac " + str(sta_mac_addr)) break sta_number = sta_number + 1 #ac_slot.addDestMacAndTosValues(sta_mac_addr, 0) #elif slot_nr == total_used_slots_exclusive_primary: #ac_slot.disableAll() elif slot_nr > total_used_slots_exclusive_primary and slot_nr < total_used_slots: for sta_mac_addr in self.phy_rates: if sta_mac_addr not in self.min_slots.keys(): print("Adding mac " + str(sta_mac_addr)) ac_slot.addDestMacAndTosValues( sta_mac_addr, 0) elif slot_nr == total_used_slots: ac_slot.disableAll() print("Guard after primaries") else: #ac_slot.disableAll() ac_slot.allowAll() print("Secondaries") self.mac.addAccessPolicy(slot_nr, ac_slot) #for slot_nr in range(int(total_used_slots), int(self.total_slots)): # TODO Replace this with STAs of Guest Network # print("Processing secondary slot nr: "+str(slot_nr)) # ac_slot = self.mac.getAccessPolicy(slot_nr) # ac_slot = ac_slot.disableAll() #self.mac.addAccessPolicy(slot_nr, ac_slot) # TODO: sven do something ... # node on which scheme should be applied, e.g. nuc15 interface sta1 # staDstHWAddr = "04:f0:21:17:36:68" # ac_slot.addDestMacAndTosValues(staDstHWAddr, 0) # update configuration in hMAC self.mac.printConfiguration() #self.device.update_mac_processor(self.iface, self.mac) self.device.update_radio_program(self.myHMACID, self.mac, self.iface) staslotshareevent = StaSlotShareEvent( "TV", int((100 / self.total_slots) * (total_used_slots_exclusive_primary + ((self.total_slots - total_used_slots_exclusive_primary) / 3)))) self.send_event(staslotshareevent) staslotshareevent = StaSlotShareEvent( "Guest1", int((100 / self.total_slots) * (((self.total_slots - total_used_slots_exclusive_primary) / 3)))) self.send_event(staslotshareevent) staslotshareevent = StaSlotShareEvent( "Guest2", int((100 / self.total_slots) * (((self.total_slots - total_used_slots_exclusive_primary) / 3)))) self.send_event(staslotshareevent) #except Exception as e: # self.log.error("{} Failed updating mac processor, err_msg: {}" # .format(datetime.datetime.now(), e)) # raise e self.timer.start(self.update_interval) else: print("Demo Finished, repeating...") # self.log.debug('... Enabling free for all') print( "*************************************************************\n" ) print("EQUAL SHARE FOR ALL\n") print( "*************************************************************\n" ) #assign allow all to each slot # create new MAC for local node self.mac = HMACConfigParam(no_slots_in_superframe=self.total_slots, slot_duration_ns=self.slot_duration) # assign allow all to each slot for slot_nr in range(self.total_slots): acGuard = HMACAccessPolicyParam() if slot_nr == 0: acGuard.disableAll() else: acGuard.allowAll() # allow all self.mac.addAccessPolicy(slot_nr, acGuard) self.mac.printConfiguration() #self.device.deactivate_radio_program(self.myHMACID) #self.device.activate_radio_program(self.myHMACID, self.mac, self.iface) self.device.update_radio_program(self.myHMACID, self.mac, self.iface) #self.log.debug('... Calling Stop Function') #self.my_stop_function() staslotshareevent = StaSlotShareEvent("TV", 33) self.send_event(staslotshareevent) staslotshareevent = StaSlotShareEvent("Guest1", 33) self.send_event(staslotshareevent) staslotshareevent = StaSlotShareEvent("Guest2", 33) self.send_event(staslotshareevent) self.log.debug('... done') self.runs = 0 self.timer.start(self.update_interval)
class LocalRadioSlicer(modules.ControlApplication): def __init__(self): super(LocalRadioSlicer, self).__init__() self.log = logging.getLogger('LocalRadioSlicer') self.update_interval = 1 # 1 sec @modules.on_start() def my_start_function(self): self.log.info("start wifi radio slicer") # store object referenes node = self.localNode self.log.info(node) self.device = node.get_device(0) self.log.info(self.device) self.iface = 'ap5' self.total_slots = 20 # slots are in microseonds slot_duration = 20000 # 20 ms sta1 = "00:15:6d:84:fb:7a" #fernseher self.min_rates = {sta1 : 15.0} self.phy_rates = {} self.min_slots = {} # create new MAC for local node self.mac = HMACConfigParam( no_slots_in_superframe=self.total_slots, slot_duration_ns=slot_duration) # assign allow all to each slot for slot_nr in range(self.total_slots): acGuard = HMACAccessPolicyParam() acGuard.allowAll() # allow all self.mac.addAccessPolicy(slot_nr, acGuard) self.mac.printConfiguration() # install configuration in MAC self.device.install_mac_processor(self.iface, self.mac) self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.update_interval) self.log.info('... done') @modules.on_exit() def my_stop_function(self): self.log.info("stop wifi radio slicer") # install configuration in MAC self.device.uninstall_mac_processor(self.iface, self.mac) @modules.on_event(PeriodicEvaluationTimeEvent) def periodic_slice_adapdation(self, event): print("Periodic slice adaptations ...") if True: if True: # step 1: get information about client STAs being served tx_bitrate_link = self.device.get_tx_bitrate_of_connected_devices(self.iface) for sta_mac_addr, sta_speed in tx_bitrate_link.items(): sta_tx_bitrate_val = sta_speed[0] # e.g. 12 sta_tx_bitrate_unit = sta_speed[1] # e.g. Mbit/s print(str(sta_mac_addr)+": STA_TX_BITRATE: "+str(sta_tx_bitrate_val)+" "+str(sta_tx_bitrate_unit)) if sta_tx_bitrate_unit == "MBit/s": self.phy_rates[sta_mac_addr] = sta_tx_bitrate_val else: print("CONVERT THE BITRATE!!!!!") # TODO write converter # step 2: process link info & decide on new slice sizes for sta_mac_addr in self.phy_rates: if sta_mac_addr in self.min_rates.keys(): print("STA is in min_rates") slot_bitrate = float(self.phy_rates[sta_mac_addr]) / float(self.total_slots) print("Slot Bitrate for STA: "+str(slot_bitrate)) print("Policy Min Bitrate: "+str(self.min_rates[sta_mac_addr])) number_of_slots = round(self.min_rates[sta_mac_addr] / slot_bitrate + 0.5) self.min_slots[sta_mac_addr]= number_of_slots print("Min Slots needed: "+str(self.min_slots[sta_mac_addr])) # step 3: update hMAC # assign access policies to each slot in superframe #Count needed slots for primary user total_used_slots = 0.0 for sta_mac_addr in self.min_slots: total_used_slots = total_used_slots + self.min_slots[sta_mac_addr] if total_used_slots > self.total_slots: print("Warning!: More slots needed as available, target bitrate for all primary users not achievable! Needed: "+str(total_used_slots)+" Available: "+str(self.total_slots)) total_used_slots = self.total_slots else: print("Total used slots for primary: "+str(total_used_slots)) self.mac.printConfiguration() for slot_nr in range(0,int(total_used_slots)): print("Processing primary slot nr: "+str(slot_nr)) #ac_slot = self.mac.getAccessPolicy(slot_nr) ac_slot = HMACAccessPolicyParam() for sta_mac_addr in self.min_slots: print("Adding mac "+str(sta_mac_addr)) ac_slot.addDestMacAndTosValues(sta_mac_addr, 0) self.mac.addAccessPolicy(slot_nr, ac_slot) #for slot_nr in range(int(total_used_slots), int(self.total_slots)): # TODO Replace this with STAs of Guest Network # print("Processing secondary slot nr: "+str(slot_nr)) # ac_slot = self.mac.getAccessPolicy(slot_nr) # ac_slot = ac_slot.disableAll() #self.mac.addAccessPolicy(slot_nr, ac_slot) # TODO: sven do something ... # node on which scheme should be applied, e.g. nuc15 interface sta1 # staDstHWAddr = "04:f0:21:17:36:68" # ac_slot.addDestMacAndTosValues(staDstHWAddr, 0) # update configuration in hMAC self.mac.printConfiguration() self.device.update_mac_processor(self.iface, self.mac) #except Exception as e: # self.log.error("{} Failed updating mac processor, err_msg: {}" # .format(datetime.datetime.now(), e)) # raise e self.timer.start(self.update_interval)
class MyController(modules.ControlApplication): def __init__(self): super(MyController, self).__init__() self.log = logging.getLogger('MyController') self.running = False self.timeInterval = 10 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval) @modules.on_start() def my_start_function(self): print("start control app") self.running = True @modules.on_exit() def my_stop_function(self): print("stop control app") self.running = False @modules.on_event(events.NewNodeEvent) def add_node(self, event): node = event.node self.log.info("Added new node: {}, Local: {}".format( node.uuid, node.local)) self._add_node(node) @modules.on_event(events.NodeExitEvent) @modules.on_event(events.NodeLostEvent) def remove_node(self, event): self.log.info("Node lost".format()) node = event.node reason = event.reason if self._remove_node(node): self.log.info("Node: {}, Local: {} removed reason: {}".format( node.uuid, node.local, reason)) @modules.on_event(PacketLossEvent) def serve_packet_loss_event(self, event): node = event.node device = event.device self.log.info("Packet loss in node {}, dev: {}".format( node.hostname, device.name)) @modules.on_event(AveragedSpectrumScanSampleEvent) def serve_spectral_scan_sample(self, event): avgSample = event.avg self.log.info("Averaged Spectral Scan Sample: {}".format(avgSample)) def default_cb(self, data): node = data.node devName = None if data.device: devName = data.device.name msg = data.msg print("Default Callback: " "Node: {}, Dev: {}, Data: {}".format(node.hostname, devName, msg)) def get_power_cb(self, data): node = data.node dev = data.device msg = data.msg print("Power in " "Node: {}, Dev: {}, was set to: {}".format( node.hostname, dev.name, msg)) @modules.on_event(PeriodicEvaluationTimeEvent) def periodic_evaluation(self, event): # go over collected samples, etc.... # make some decisions, etc... print("Periodic Evaluation") print("My nodes: ", [node.hostname for node in self.get_nodes()]) self.timer.start(self.timeInterval) if len(self.get_nodes()) == 0: return return
class SlaveController(modules.ControlApplication): def __init__(self): super(SlaveController, self).__init__() self.log = logging.getLogger('SlaveController') self.running = False self.timeInterval = 10 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval) self.dut_iface = "eno1" self.bn_iface = "wlp2s0" def _run_command(self, command): sp = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) out, err = sp.communicate() if out: self.log.debug("standard output of subprocess:") self.log.debug(out) if err: self.log.debug("standard error of subprocess:") self.log.debug(err) return [sp.returncode, out.decode("utf-8"), err.decode("utf-8")] def _setup_l2_tunneling(self): self.log.info( "Create VXLAN (virtual) interface and add it to the Linux bridge") self._run_command( "ip link add vxlan10 type vxlan id 10 group 224.10.10.10 ttl 10 dev " + self.bn_iface) self._run_command("ip link set vxlan10 up") self._run_command("brctl addif br0 vxlan10") self.log.info("Set bigger MTU to fit packets from DUT nodes") self._run_command("ifconfig wlp2s0 mtu 1550") self._run_command("ifconfig vxlan10 mtu 1500") def _teardown_l2_tunneling(self): self.log.info("Destroy VXLAN (virtual) interface") self._run_command("brctl delif br0 vxlan10") self._run_command("ip link set vxlan10 down") self._run_command("ip link delete vxlan10") self.log.info("Set default MTU on wireless iface") self._run_command("ifconfig wlp2s0 mtu 1500") @modules.on_start() def my_start_function(self): print("Start Control Application") self.running = True self._setup_l2_tunneling() @modules.on_exit() def my_stop_function(self): print("stop control app") self.running = False self._teardown_l2_tunneling() @modules.on_event(PeriodicEvaluationTimeEvent) def periodic_evaluation(self, event): # go over collected samples, etc.... # make some decisions, etc... print("Periodic Evaluation") self.timer.start(self.timeInterval) return
class Scanner(modules.ControlApplication): def __init__(self, mode, ap_iface, scan_iface, channels, hopping_interval, reporting_interval): super(Scanner, self).__init__() self.log = logging.getLogger('Scanner') self.mode = mode self.ap_iface = ap_iface self.scan_iface = scan_iface self.channels = channels self.hopping_interval = hopping_interval self.reporting_interval = reporting_interval self.sta_map_file = '/tmp/sta_map.dat' self.next_ch_id = 0 @modules.on_start() def my_start_function(self): self.log.debug("start scanner app") # start scanner self.exec_file = 'scanner/scanner' self.processArgs = self.exec_file + ' ' + self.scan_iface self.process = subprocess.Popen(self.processArgs.split(), shell=False) # wait to settle down time.sleep(1) # channel hopping every 100ms self.chHoppingTimeInterval = self.hopping_interval self.chTimer = TimerEventSender(self, PeriodicChannelSwitchTimeEvent) self.chTimer.start(self.chHoppingTimeInterval) # reporting signal quality as event self.reportingTimeInterval = self.reporting_interval self.reportingTimer = TimerEventSender(self, PeriodicCQIReportingTimeEvent) self.reportingTimer.start(self.reportingTimeInterval) @modules.on_exit() def my_stop_function(self): self.log.debug("stop scanner app") # stop scanner self.process.kill() @modules.on_event(PeriodicChannelSwitchTimeEvent) def periodic_channel_switch(self, event): self.log.debug("Periodic channel hopping") self.log.debug("My node: %s" % self.localNode.hostname) self.chTimer.start(self.chHoppingTimeInterval) device = self.localNode.get_device(0) try: # switch to next channel device.radio.set_channel(self.channels[self.next_ch_id]) self.next_ch_id = (self.next_ch_id + 1) % len(self.channels) except Exception as e: self.log.error("{} !!!Exception!!!: {}".format( datetime.datetime.now(), e)) @modules.on_event(PeriodicCQIReportingTimeEvent) def periodic_reporting(self, event): self.log.debug("Periodic reporting") self.log.debug("My node: %s" % self.localNode.hostname) self.chTimer.start(self.reportingTimeInterval) device = self.localNode.get_device(0) try: # read and create event # CQI towards co-located client not being served candidate_sigpower = self.read_passive_scan_results() # CQI towards served client curr_sigpower = self.get_avg_sigpower() event = CQIReportingEvent(candidate_sigpower, curr_sigpower) self.send_event(event) except Exception as e: self.log.error("{} !!!Exception!!!: {}".format( datetime.datetime.now(), e)) def read_passive_scan_results(self): """ Get the signal quality towards co-located clients being served by neighboring APs. STA_MAC_ADDR -> dBm Returns in dBm """ scan_results = open(self.sta_map_file, 'r') rv = {} for line in scan_results: row_arr = line.split(",") if (len(row_arr) >= 2): macAddr = row_arr[0] sigPow = row_arr[1] else: continue rv[macAddr] = sigPow return rv def get_avg_sigpower(self): """ Get the signal quality of currently served/associated client stations. STA_MAC_ADDR -> dBm Returns in dBm """ rv = {} station_info = self.localNode.net.iface( self.ap_iface).get_info_of_connected_devices() if station_info is not None: for node in station_info.keys(): agent_control_ip = node.ip station_info_node = station_info[node] for mac in station_info_node.keys(): rv[mac] = station_info[node][mac]['signal avg'][0] return rv
class GuiFeeder(modules.ControlApplication): def __init__(self, staList=[]): super(GuiFeeder, self).__init__() self.log = logging.getLogger('GuiFeeder') self.sta_list = [] for sta in staList: self.log.debug("New STA: {},{},{}".format(sta[0], sta[1], sta[2])) s = StaInfo(sta[0], sta[1], sta[2]) self.sta_list.append(s) @modules.on_start() def my_start(self): self.timeInterval = 10 self.timer = TimerEventSender(self, SampleSendTimeEvent) self.timer.start(self.timeInterval) @modules.on_event(StaThroughputConfigEvent) def serve_throughput_config_event(self, event): sta = event.sta throughput = event.throughput self.log.info("Set Thrughput for STA: {}: to: {}".format( sta, throughput)) @modules.on_event(HostStateEvent) def change_sta_state(self, event): self.log.info("Host: {} state info".format(event.ip, )) for s in self.sta_list: if s.ip == event.ip: if s.state is None: s.state = event.state return elif ((s.state and not event.state) or (not s.state and event.state)): self.log.info("STA {}:{} changed state to {}".format( s.name, s.ip, event.state)) s.state = event.state # sent event to GUI ev = StaStateEvent(s.name, s.state) self.send_event(ev) # if new state if UP start iperf if s.state: if s.iperfProcess is None: s.iperfProcess = IperfClientProcess( self, s.name, s.ip) s.iperfProcess.start() else: if s.iperfProcess: s.iperfProcess.stop() @modules.on_event(SampleSendTimeEvent) def send_random_samples(self, ev): self.timer.start(1) share = 100 for sta in self.sta_list: #if sta.state: self.log.info("Send new random samples for device: {}".format( sta.name)) event = StaStateEvent(sta.name, True) self.send_event(event) throughput = random.uniform(5, 108) event = StaThroughputEvent(sta.name, throughput) self.send_event(event) phyRate = random.uniform(5, 54) event = StaPhyRateEvent(sta.name, phyRate) self.send_event(event) slotShare = random.uniform(0, share) share = share - slotShare event = StaSlotShareEvent(sta.name, slotShare) self.send_event(event)
class SimpleBenchmark(modules.ControlApplication): def __init__(self, title=''): super(SimpleBenchmark, self).__init__() self.log = logging.getLogger('SimpleBenchmark') self.title = title self.running = False self.timeInterval = 4 self.blocking_timer = TimerEventSender( self, PeriodicBlockingEvaluationTimeEvent) self.non_blocking_timer = TimerEventSender( self, PeriodicNonBlockingEvaluationTimeEvent) self.non_blocking_timer.start(self.timeInterval) self.packetLossEventsEnabled = False @modules.on_start() def my_start_function(self): self.log.info("start control app") print('"Experiment";"Call type";"Nr calls";"Total duration";"Average per call"') self.csv_template = '"{title}";{call};{nr};{total};{per_call}' self.running = True @modules.on_exit() def my_stop_function(self): self.log.info("stop control app") self.running = False @modules.on_event(events.NewNodeEvent) def add_node(self, event): node = event.node self.log.info("Added new node: {}, Local: {}" .format(node.uuid, node.local)) self._add_node(node) @modules.on_event(events.NodeExitEvent) @modules.on_event(events.NodeLostEvent) def remove_node(self, event): self.log.info("Node lost".format()) node = event.node reason = event.reason if self._remove_node(node): self.log.info("Node: {}, Local: {} removed reason: {}" .format(node.uuid, node.local, reason)) def non_blocking_cb(self, data): self.current_num += 1 if self.current_num >= self.repeatNum: end = datetime.datetime.now() duration = end - self.start perCall = duration / self.repeatNum self.log.info( "{} RPC calls were executed in: {}s".format( self.repeatNum, duration)) self.log.info( "--- mean duration of single call: {}s".format(perCall)) print(self.csv_template.format( title=self.title, call='non blocking', nr=self.repeatNum, total=duration, per_call=perCall)) self.blocking_timer.start(self.timeInterval) @modules.on_event(PeriodicNonBlockingEvaluationTimeEvent) def periodic_non_blocking_evaluation(self, event): self.log.info("Periodic Non Blocking Evaluation") self.log.info( "My nodes: %s", ', '.join([node.hostname for node in self.get_nodes()])) if len(self.get_nodes()) == 0: self.non_blocking_timer.start(self.timeInterval) return node = self.get_node(0) device = node.get_device(0) self.current_num = 0 self.repeatNum = 5000 self.start = datetime.datetime.now() self.log.info( "Start performace test, execute {} non blocking RPC calls".format( self.repeatNum)) for i in range(self.repeatNum): device.callback(self.non_blocking_cb).get_channel("wlan0") time.sleep(0.0001) @modules.on_event(PeriodicBlockingEvaluationTimeEvent) def periodic_blocking_evaluation(self, event): self.log.info("Periodic Blocking Evaluation") self.log.info( "My nodes: %s", ', '.join([node.hostname for node in self.get_nodes()])) if len(self.get_nodes()) == 0: self.blocking_timer.start(self.timeInterval) return node = self.get_node(0) device = node.get_device(0) # test blocking call in loop self.current_num = 0 self.repeatNum = 5000 self.start = datetime.datetime.now() self.log.info( "Start performace test, execute {} blocking RPC calls".format( self.repeatNum)) for i in range(self.repeatNum): device.get_channel("wlan0") end = datetime.datetime.now() duration = end - self.start perCall = duration / self.repeatNum self.log.info( "{} blocking RPC calls were executed in: {}s".format( self.repeatNum, duration)) self.log.info( "--- mean duration of single blocking call: {}s".format( perCall)) print(self.csv_template.format( title=self.title, call='blocking', nr=self.repeatNum, total=duration, per_call=perCall)) self.non_blocking_timer.start(self.timeInterval)
class MyController(modules.ControlApplication): def __init__(self, mode): super(MyController, self).__init__() self.log = logging.getLogger('MyController') self.mode = mode self.running = False self.timeInterval = 10 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval) @modules.on_start() def my_start_function(self): print("start control app") self.running = True @modules.on_exit() def my_stop_function(self): print("stop control app") self.running = False @modules.on_event(events.NewNodeEvent) def add_node(self, event): node = event.node self.log.info("Added new node: {}, Local: {}".format( node.uuid, node.local)) self._add_node(node) for dev in node.get_devices(): print("Dev: ", dev.name) print(dev) for m in node.get_modules(): print("Module: ", m.name) print(m) for app in node.get_control_applications(): print("App: ", app.name) print(app) device = node.get_device(0) device.set_tx_power(15, "wlan0") device.set_channel(random.randint(1, 11), "wlan0") device.packet_loss_monitor_start() device.spectral_scan_start() @modules.on_event(events.NodeExitEvent) @modules.on_event(events.NodeLostEvent) def remove_node(self, event): self.log.info("Node lost".format()) node = event.node reason = event.reason if self._remove_node(node): self.log.info("Node: {}, Local: {} removed reason: {}".format( node.uuid, node.local, reason)) @modules.on_event(PacketLossEvent) def serve_packet_loss_event(self, event): node = event.node device = event.device self.log.info("Packet loss in node {}, dev: {}".format( node.hostname, device.name)) @modules.on_event(AveragedSpectrumScanSampleEvent) def serve_spectral_scan_sample(self, event): avgSample = event.avg self.log.info("Averaged Spectral Scan Sample: {}".format(avgSample)) @modules.on_event(PeriodicEvaluationTimeEvent) def periodic_evaluation(self, event): # go over collected samples, etc.... # make some decisions, etc... print("Periodic Evaluation") print("My nodes: ", [node.hostname for node in self.get_nodes()]) self.timer.start(self.timeInterval) if len(self.get_nodes()) == 0: return
def my_start(self): self.timeInterval = 10 self.timer = TimerEventSender(self, SampleSendTimeEvent) self.timer.start(self.timeInterval)
class MyController(modules.ControlApplication): def __init__(self): super(MyController, self).__init__() self.log = logging.getLogger('MyController') self.running = False self.timeInterval = 10 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval) self.packetLossEventsEnabled = False @modules.on_start() def my_start_function(self): print("start control app") self.running = True @modules.on_exit() def my_stop_function(self): print("stop control app") self.running = False @modules.on_event(events.NewNodeEvent) def add_node(self, event): node = event.node self.log.info("Added new node: {}, Local: {}".format( node.uuid, node.local)) self._add_node(node) for dev in node.get_devices(): print("Dev: ", dev.name) print(dev) for m in node.get_modules(): print("Module: ", m.name) print(m) for app in node.get_control_applications(): print("App: ", app.name) print(app) @modules.on_event(events.NodeExitEvent) @modules.on_event(events.NodeLostEvent) def remove_node(self, event): self.log.info("Node lost".format()) node = event.node reason = event.reason if self._remove_node(node): self.log.info("Node: {}, Local: {} removed reason: {}".format( node.uuid, node.local, reason)) def default_cb(self, data): node = data.node devName = None if data.device: devName = data.device.name msg = data.msg print("Default Callback: " "Node: {}, Dev: {}, Data: {}".format(node.hostname, devName, msg)) @modules.on_event(PeriodicEvaluationTimeEvent) def periodic_evaluation(self, event): # go over collected samples, etc.... # make some decisions, etc... print("Periodic Evaluation") print("My nodes: ", [node.hostname for node in self.get_nodes()]) self.timer.start(self.timeInterval) if len(self.get_nodes()) == 0: return node = self.get_node(0) device = node.get_device(0) # node.is_access_locked() # device.is_access_locked() ## atomic lock (check if locked and if not lock) # device.lock_access() # device.unlock_access() transaction = transactions.Transaction() task1 = transactions.Task() task1.set_entities(device) task1.set_save_point_func(func=device.get_channel, args=["wlan0"]) task1.set_function(func=device.set_channel, args=[12, "wlan0"]) transaction.add_task(task1) task2 = transactions.Task() task2.set_entities(device) task2.set_save_point_value(args=[10, "wlan0"]) task2.set_function(func=device.set_tx_power, args=[8, "wlan0"]) transaction.add_task(task2) # rollback configuration change # if it breaks the connection with the controller and any node transaction.rollback_if_connection_lost(True, timeout=10) # commit is a blocking call that # runs three-phase-commit (3PC) protocol transaction.commit() transaction.is_executed() transaction.is_rolled_back() tstatus = transaction.get_status() print("Transaction status: ", tstatus)
class MyController(modules.ControlApplication): def __init__(self): super(MyController, self).__init__() self.log = logging.getLogger('MyController') self.running = False self.timeInterval = 10 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval) self.packetLossEventsEnabled = False @modules.on_start() def my_start_function(self): print("start control app") self.running = True @modules.on_exit() def my_stop_function(self): print("stop control app") self.running = False @modules.on_event(events.NewNodeEvent) def add_node(self, event): node = event.node self.log.info("Added new node: {}, Local: {}".format( node.uuid, node.local)) self._add_node(node) for dev in node.get_devices(): print("Dev: ", dev.name) print(dev) for m in node.get_modules(): print("Module: ", m.name) print(m) for app in node.get_control_applications(): print("App: ", app.name) print(app) device = node.get_device(0) device.set_tx_power(15, "wlan0") device.set_channel(random.randint(1, 11), "wlan0") device.packet_loss_monitor_start() device.spectral_scan_start() # device.play_waveform() # TODO: is_implemented() @modules.on_event(events.NodeExitEvent) @modules.on_event(events.NodeLostEvent) def remove_node(self, event): self.log.info("Node lost".format()) node = event.node reason = event.reason if self._remove_node(node): self.log.info("Node: {}, Local: {} removed reason: {}".format( node.uuid, node.local, reason)) @modules.on_event(PacketLossEvent) def serve_packet_loss_event(self, event): node = event.node device = event.device self.log.info("Packet loss in node {}, dev: {}".format( node.hostname, device.name)) @modules.on_event(AveragedSpectrumScanSampleEvent) def serve_spectral_scan_sample(self, event): avgSample = event.avg self.log.info("Averaged Spectral Scan Sample: {}".format(avgSample)) def default_cb(self, data): node = data.node devName = None if data.device: devName = data.device.name msg = data.msg print("Default Callback: " "Node: {}, Dev: {}, Data: {}".format(node.hostname, devName, msg)) def get_power_cb(self, data): node = data.node msg = data.msg dev = node.get_device(0) print("Power in " "Node: {}, Dev: {}, was set to: {}".format( node.hostname, dev.name, msg)) newPwr = random.randint(1, 20) dev.blocking(False).set_tx_power(newPwr, "wlan0") print("Power in " "Node: {}, Dev: {}, was set to: {}".format( node.hostname, dev.name, newPwr)) def scheduled_get_channel_cb(self, data): node = data.node msg = data.msg dev = node.get_device(0) print("Scheduled get_channel; Power in " "Node: {}, Dev: {}, was set to: {}".format( node.hostname, dev.name, msg)) @modules.on_event(PeriodicEvaluationTimeEvent) def periodic_evaluation(self, event): # go over collected samples, etc.... # make some decisions, etc... print("Periodic Evaluation") print("My nodes: ", [node.hostname for node in self.get_nodes()]) self.timer.start(self.timeInterval) if len(self.get_nodes()) == 0: return node = self.get_node(0) device = node.get_device(0) if device.is_packet_loss_monitor_running(): device.packet_loss_monitor_stop() device.spectral_scan_stop() else: device.packet_loss_monitor_start() device.spectral_scan_start() avgFilterApp = None for app in node.get_control_applications(): if app.name == "MyAvgFilter": avgFilterApp = app break if avgFilterApp.is_running(): myValue = random.randint(1, 20) [nValue1, nValue2] = avgFilterApp.blocking(True).add_two(myValue) print("My value: {} + 2 = {}".format(myValue, nValue1)) print("My value: {} * 2 = {}".format(myValue, nValue2)) avgFilterApp.stop() newWindow = random.randint(10, 50) old = avgFilterApp.blocking(True).get_window_size() print("Old Window Size : {}".format(old)) avgFilterApp.blocking(True).change_window_size_func(newWindow) nValue = avgFilterApp.blocking(True).get_window_size() print("New Window Size : {}".format(nValue)) else: avgFilterApp.start() newWindow = random.randint(10, 50) event = ChangeWindowSizeEvent(newWindow) avgFilterApp.send_event(event) # execute non-blocking function immediately device.blocking(False).set_tx_power(random.randint(1, 20), "wlan0") # execute non-blocking function immediately, with specific callback device.callback(self.get_power_cb).get_tx_power("wlan0") # schedule non-blocking function delay device.delay(3).callback(self.default_cb).get_tx_power("wlan0") # schedule non-blocking function exec time exec_time = datetime.datetime.now() + datetime.timedelta(seconds=3) newChannel = random.randint(1, 11) device.exec_time(exec_time).set_channel(newChannel, "wlan0") # schedule execution of function multiple times start_date = datetime.datetime.now() + datetime.timedelta(seconds=2) interval = datetime.timedelta(seconds=1) repetitionNum = 3 device.exec_time(start_date, interval, repetitionNum).callback( self.scheduled_get_channel_cb).get_channel("wlan0") # execute blocking function immediately result = device.get_channel("wlan0") print("{} Channel is: {}".format(datetime.datetime.now(), result)) # exception handling, clean_per_flow_tx_power_table implementation # raises exception try: device.clean_per_flow_tx_power_table("wlan0") except Exception as e: print("{} !!!Exception!!!: {}".format(datetime.datetime.now(), e))
class MyController(modules.ControlApplication): def __init__(self): super(MyController, self).__init__() self.log = logging.getLogger('MyController') self.running = False self.nodes = [] self.timeInterval = 10 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval) self.myFilterRunning = False self.packetLossEventsEnabled = False @modules.on_start() def my_start_function(self): print("start control app") self.running = True node = self.localNode self.log.info("My local, Local: {}".format(node.local)) for dev in node.get_devices(): print("Dev: ", dev.name) print(dev) for m in node.get_modules(): print("Module: ", m.name) print(m) for app in node.get_control_applications(): print("App: ", app.name) print(app) device = node.get_device(0) device.set_tx_power(15, 'ath0') device.set_channel(random.randint(1, 11), 'ath0') device.packet_loss_monitor_start() self.packetLossEventsEnabled = True device.spectral_scan_start() @modules.on_exit() def my_stop_function(self): print("stop control app") self.running = False @modules.on_event(PacketLossEvent) def serve_packet_loss_event(self, event): node = event.node device = event.device self.log.info("Packet loss, dev: {}".format(device)) @modules.on_event(AveragedSpectrumScanSampleEvent) def serve_spectral_scan_sample(self, event): avgSample = event.avg self.log.info("Averaged Spectral Scan Sample: {}".format(avgSample)) def default_cb(self, data): node = data.node devName = None if data.device: devName = data.device.name msg = data.msg print("Default Callback: " "Dev: {}, Data: {}".format(devName, msg)) def get_power_cb(self, data): node = data.node dev = data.device msg = data.msg print("Power in " "Dev: {}, was set to: {}".format(dev.name, msg)) @modules.on_event(PeriodicEvaluationTimeEvent) def periodic_evaluation(self, event): # go over collected samples, etc.... # make some decisions, etc... print("Periodic Evaluation") node = self.localNode device = node.get_device(0) self.log.info("My local node, Local: {}".format(node.local)) self.timer.start(self.timeInterval) if self.packetLossEventsEnabled: device.packet_loss_monitor_stop() self.packetLossEventsEnabled = False else: device.packet_loss_monitor_start() self.packetLossEventsEnabled = True if self.myFilterRunning: self.send_event(StopMyFilterEvent()) self.myFilterRunning = False else: self.send_event(StartMyFilterEvent()) self.myFilterRunning = True # execute non-blocking function immediately device.blocking(False).set_tx_power(random.randint(1, 20), 'ath0') # execute non-blocking function immediately, with specific callback device.callback(self.get_power_cb).get_tx_power('ath0') # schedule non-blocking function delay device.delay(3).callback(self.default_cb).get_tx_power("wlan0") # schedule non-blocking function exec time exec_time = datetime.datetime.now() + datetime.timedelta(seconds=3) newChannel = random.randint(1, 11) device.exec_time(exec_time).set_channel(newChannel, 'ath0') # execute blocking function immediately result = device.get_channel('ath0') print("{} Channel is: {}".format(datetime.datetime.now(), result)) # exception handling, clean_per_flow_tx_power_table implementation # raises exception try: device.clean_per_flow_tx_power_table("wlan0") except Exception as e: print("{} !!!Exception!!!: {}".format(datetime.datetime.now(), e))
class MyGnuRadioController(modules.ControlApplication): def __init__(self): super(MyGnuRadioController, self).__init__() self.log = logging.getLogger('MyGnuRadioController') self.running = False # GnuRadio program to be loaded fid = open(os.path.join(os.path.expanduser("."), "testgrc.grc")) self.grc_xml = fid.read() self.min_freq = 5200e6 self.max_freq = 5300e6 self.step_freq = 10e6 self.freq = self.min_freq @modules.on_start() def my_start_function(self): self.log.info("start control app") self.running = True node = self.localNode self.log.debug("My local node: {}, Local: {}".format( node.hostname, node.local)) for dev in node.get_devices(): self.log.debug("Dev: %s" % dev.name) for m in node.get_modules(): self.log.debug("Module: %s" % m.name) for apps in node.get_control_applications(): self.log.debug("App: %s" % apps.name) self.device = node.get_device(0) # activate GnuRadio RP self.grc_radio_program_name = 'test' inval = {} inval['ID'] = 11 inval['grc_radio_program_code'] = self.grc_xml self.device.activate_radio_program(self.grc_radio_program_name, **inval) self.timeInterval = 1 self.timer = TimerEventSender(self, PeriodicEvaluationTimeEvent) self.timer.start(self.timeInterval) @modules.on_exit() def my_stop_function(self): print("stop control app") tvals = {} tvals['do_pause'] = str(False) self.device.deactivate_radio_program(self.grc_radio_program_name, **tvals) self.running = False @modules.on_event(PeriodicEvaluationTimeEvent) def periodic_evaluation(self, event): print("Periodic channel hopping ...") self.freq = self.freq + self.step_freq if self.freq > self.max_freq: self.freq = self.min_freq inval = {} inval['freq'] = self.freq # set new freq self.device.set_parameters(inval) self.log.info("New freq is: %s" % self.freq) self.timer.start(self.timeInterval)