def stop_hostapd(self): self.log.info('stop hostapd()') cmd_str = 'ps aux | grep hostapd | wc -l' try: [rcode, sout, serr] = self.run_command(cmd_str) except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) if (int(sout) > 2): cmd_str = 'killall -9 hostapd' try: [rcode, sout, serr] = self.run_command(cmd_str) except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) cmd_str = 'ifconfig wlan0 down; ifconfig wlan0 up' try: [rcode, sout, serr] = self.run_command(cmd_str) except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) self.log.info('stop hostapd() completed') return True
def set_inactive(self, radio_program_name): param_key_values = {} if self.radio_programs.has_key(radio_program_name): param_key_values["TAISC_ACTIVERADIOPROGRAM"] = self.radio_programs[ 'NO_MAC'] node = self.node_factory.get_node(self.interface) if node != None: ret = node.write_parameters('taisc', param_key_values) if type(ret) == dict: return ret["TAISC_ACTIVERADIOPROGRAM"] else: fname = inspect.currentframe().f_code.co_name self.log.fatal("Error executing function %s: %s!" % (fname, ret)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg="Error executing function") else: fname = inspect.currentframe().f_code.co_name self.log.fatal("%s Interface %s does not exist!" % (self.interface, fname)) raise exceptions.InvalidArgumentException( func_name=fname, err_msg="Interface does not exist") else: fname = inspect.currentframe().f_code.co_name self.log.warn("Wrong radio program name: %s" % radio_program_name) raise exceptions.InvalidArgumentException( func_name=fname, err_msg="Radio Program does not exist")
def start_monitor(self, driver, iface): self.log.info('start monitor setup') try: if driver == "ath9k": iface_mon = 'mon0' [rcode, sout, serr] = self.run_command( 'sudo iw dev {0} interface add {1} type monitor'.format( iface, iface_mon)) [rcode, sout, serr ] = self.run_command('sudo ifconfig {0} up'.format(iface_mon)) elif driver == "b43": iface_mon = 'mon0' [rcode, sout, serr] = self.run_command( 'sudo iw dev {0} interface add {1} type monitor'.format( iface, iface_mon)) [rcode, sout, serr ] = self.run_command('sudo ifconfig {0} up'.format(iface_mon)) else: self.log.info('driver not supported yet') except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) self.log.info('setup monitor completed')
def configure_radio_sensitivity(self, phy_dev, **kwargs): ''' Configuring the carrier receiving sensitivity of the radio. Req.: modprobe ath5k/9k debug=0xffffffff #configuration of ath5k's ANI settings # disable ani echo "0" > /sys/kernel/debug/ieee80211/phy0/ath9k/ani supported ani modes: - 0 - disable ANI - tbd ''' prefix = 'ath9k' ani_mode = kwargs.get('ani_mode') self.log.info('Setting ANI sensitivity w/ = %s' % str(ani_mode)) try: myfile = open( '/sys/kernel/debug/ieee80211/' + phy_dev + '/' + prefix + '/ani', 'w') myfile.write(ani_mode) myfile.close() except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) return True
def set_per_flow_tx_power(self, flowId, txPower): self.log.debug('set_per_flow_tx_power on iface: {}'.format( self.interface)) tcMgr = TrafficControl() markId = tcMgr.generateMark() self.setMarking(flowId, table="mangle", chain="POSTROUTING", markId=markId) cmd_str = ('sudo iw ' + self.interface + ' info') cmd_output = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT) for item in cmd_output.split("\n"): if "wiphy" in item: line = item.strip() phyId = [int(s) for s in line.split() if s.isdigit()][0] try: myfile = open( '/sys/kernel/debug/ieee80211/phy' + str(phyId) + '/ath9k/per_flow_tx_power', 'w') value = str(markId) + " " + str(txPower) + " 0" myfile.write(value) myfile.close() return "OK" except Exception as e: self.log.fatal("Operation not supported: %s" % e) raise exceptions.UPIFunctionExecutionFailedException( func_name='radio.set_per_flow_tx_power', err_msg='cannot open file')
def clean_per_flow_tx_power_table(self): self.log.debug('clean_per_flow_tx_power_table on iface: {}'.format( self.interface)) cmd_str = ('sudo iw ' + self.interface + ' info') cmd_output = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT) for item in cmd_output.split("\n"): if "wiphy" in item: line = item.strip() phyId = [int(s) for s in line.split() if s.isdigit()][0] try: myfile = open( '/sys/kernel/debug/ieee80211/phy' + str(phyId) + '/ath9k/per_flow_tx_power', 'w') value = "0 0 0" myfile.write(value) myfile.close() return "OK" except Exception as e: self.log.fatal("Operation not supported: %s" % e) raise exceptions.UPIFunctionExecutionFailedException( func_name='radio.clean_per_flow_tx_power_table', err_msg='cannot open file')
def getEdcaParameters(self): self.log.debug("ATH9K gets EDCA parameters for interface: {}".format( self.interface)) cmd_str = ('sudo iw ' + self.interface + ' info') cmd_output = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT) for item in cmd_output.split("\n"): if "wiphy" in item: line = item.strip() phyId = [int(s) for s in line.split() if s.isdigit()][0] try: myfile = open( '/sys/kernel/debug/ieee80211/phy' + str(phyId) + '/ath9k/txq_params', 'r') data = myfile.read() myfile.close() return data except Exception as e: self.log.fatal("Operation not supported: %s" % e) raise exceptions.UPIFunctionExecutionFailedException( func_name='radio.get_mac_access_parameters', err_msg='cannot open file')
def configure_radio_sensitivity(self, phy_dev, **kwargs): ''' Configuring the carrier receiving sensitivity of the radio. Req.: modprobe ath5k/9k debug=0xffffffff #configuration of ath5k's ANI settings echo "ani-off" > /sys/kernel/debug/ieee80211/phy0/ath5k/ani supported ani modes: - sens-low - sens-high - ani-off - ani-on - noise-low - noise-high - spur-low - spur-high - fir-low - fir-high - ofdm-off - ofdm-on - cck-off - cck-on Documentation from Linux Kernel: Adaptive Noise Immunity (ANI) controls five noise immunity parameters depending on the amount of interference in the environment, increasing or reducing sensitivity as necessary. The parameters are: - "noise immunity" - "spur immunity" - "firstep level" - "OFDM weak signal detection" - "CCK weak signal detection" Basically we look at the amount of ODFM and CCK timing errors we get and then raise or lower immunity accordingly by setting one or more of these parameters. ''' prefix = 'ath5k' ani_mode = kwargs.get('ani_mode') self.log.info('Setting ANI sensitivity w/ = %s' % str(ani_mode)) try: myfile = open( '/sys/kernel/debug/ieee80211/' + phy_dev + '/' + prefix + '/ani', 'w') myfile.write(ani_mode) myfile.close() except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) return True
def flush_iptables(self): try: [rcode, sout, serr] = self.run_command('sudo iptables -F') return sout except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException(func_name=fname, err_msg=str(e))
def filter_mac(self, neighbor_mac_address): filter_cmd = "sudo iptables -I INPUT -i {} -m mac --mac-source {} " \ "-j DROP".format(self.interface, neighbor_mac_address) try: [rcode, sout, serr] = self.run_command(filter_cmd) return sout except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException(func_name=fname, err_msg=str(e))
def set_ARP_entry(self, iface, mac_addr, ip_addr): """ Manipulates the local ARP cache. todo: use Netlink API """ try: [rcode, sout, serr] = self.run_command('sudo arp -s ' + ip_addr + ' -i '+ iface + ' ' + mac_addr) return sout except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException(func_name=fname, err_msg=str(e))
def get_parameter(self, parameter_name): param_keys = [parameter_name] node = self.node_factory.get_node(self.interface) parameter_list = self.create_attribute_list_from_keys( node, param_keys, "parameter") ret = node.get_parameters(parameter_list) if type(ret) == dict: return ret[parameter_name] else: fname = inspect.currentframe().f_code.co_name self.log.fatal("Error executing function %s: %s!" % (fname, ret)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg="Error executing function")
def set_rts_threshold(self, rts_threshold): self.log.info('setting set_rts_threshold(): %s->%s' % (str(self.interface), str(rts_threshold))) try: [rcode, sout, serr] = self.run_command('sudo iwconfig {0} rts {1}'.format( self.interface, rts_threshold)) except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) self.power = rts_threshold
def start_adhoc(self, driver, iface, essid, freq, txpower, rate, ip_addr, rts='off', mac_address="aa:bb:cc:dd:ee:ff", skip_reload=False): self.log.info('start adhoc setup') try: if driver == "ath9k": if skip_reload == False: [rcode, sout, serr] = self.run_command( 'sudo rmmod ath9k ath9k_common ath9k_hw ath mac80211 cfg80211; sleep 1' ) [rcode, sout, serr] = self.run_command('sudo modprobe ath9k; sleep 1') else: [rcode, sout, serr] = self.run_command( 'sudo iw {0} ibss leave'.format(iface)) [rcode, sout, serr] = self.run_command( 'sudo iwconfig {0} mode ad-hoc; sudo ifconfig {0} {5} up;sudo iwconfig {0} txpower {3} fixed; sudo iwconfig {0} rate {4}M fixed; sudo iw dev {0} ibss join {1} {2} fixed-freq {6} ' .format(iface, essid, freq, txpower, rate, ip_addr, mac_address)) [rcode, sout, serr] = self.run_command('sudo iwconfig {0} rts {1}'.format( iface, rts)) if driver == "b43": if skip_reload == False: [rcode, sout, serr] = self.run_command('sudo rmmod b43') [rcode, sout, serr] = self.run_command('sudo modprobe b43 qos=0') else: [rcode, sout, serr] = self.run_command( 'sudo iw {0} ibss leave'.format(iface)) [rcode, sout, serr] = self.run_command( 'sudo iwconfig {0} mode ad-hoc; sudo ifconfig {0} {5} up;sudo iwconfig {0} txpower {3}; sudo iwconfig {0} rate {4}M fixed;sudo iw dev {0} ibss join {1} {2} fixed-freq {6}' .format(iface, essid, freq, txpower, rate, ip_addr, mac_address)) except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) self.log.info('adhoc setup completed')
def network_dump(self, iface): self.log.info('dump_network on interface %s' % (str(iface))) cmd_str = 'sudo iw dev ' + str(iface) + ' link' try: [rcode, sout, serr] = self.run_command(cmd_str) except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) return sout
def connect_to_network(self, iface, ssid): self.log.info('connecting via to AP with SSID: %s->%s' % (str(self.interface), str(ssid))) cmd_str = 'sudo iwconfig ' + str(iface) + ' essid ' + str(ssid) try: [rcode, sout, serr] = self.run_command(cmd_str) except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) return True
def set_ip_address(self, iface, ip_address): self.log.info('setting ip address(): %s->%s' % (str(self.interface), str(ip_address))) cmd_str = 'sudo ifconfig ' + str(iface) + ' ' + str(ip_address) try: [rcode, sout, serr] = self.run_command(cmd_str) except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) return True
def uninstall_mac_processor(self, interface, hybridMac): self.log.info('Function: uninstallMacProcessor') #hybridMac = pickle.loads(mac_profile) # set allow all # generate configuration string conf_str = None for ii in range(hybridMac.getNumSlots()): # for each slot # slot_id, mac_addr, tid_mask if conf_str is None: conf_str = str(ii) + "," + 'FF:FF:FF:FF:FF:FF' + "," + str(255) else: conf_str = conf_str + "#" + str( ii) + "," + 'FF:FF:FF:FF:FF:FF' + "," + str(255) # command string terminate_str = 'TERMINATE' # update MAC processor configuration try: # todo cache sockets!!! context = zmq.Context() socket = context.socket(zmq.REQ) socket.connect("tcp://localhost:" + str("1217")) #socket.connect("ipc:///tmp/localmacprocessor") # (1) set new config socket.send(conf_str) message = socket.recv() self.log.info("Received reply from HMAC: %s" % message) # give one second to settle down time.sleep(1) # (2) terminate MAC socket.send(terminate_str) message = socket.recv() self.log.info("Received reply from HMAC: %s" % message) return True except zmq.ZMQError as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e))
def set_modulation_rate(self, rate_Mbps): self.log.info('setting modulation rate(): %s->%s' % (str(self.interface), str(rate_Mbps))) cmd_str = 'sudo iwconfig ' + self.interface + ' rate ' + \ str(rate_Mbps) + 'M' + ' fixed' try: [rcode, sout, serr] = self.run_command(cmd_str) except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) self.modulation_rate = rate_Mbps
def start_hostapd(self, file_path): self.log.info('start hostapd()') cmd_str = 'sudo hostapd -B ' + str(file_path) try: [rcode, sout, serr] = self.run_command(cmd_str) #sp = subprocess.Popen(cmd_str, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) #out, err = sp.communicate() except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) self.log.info('start hostapd() completed') return True
def set_tx_power(self, power_dBm): self.log.info('setting set_power(): %s->%s' % (str(self.interface), str(power_dBm))) cmd_str = 'sudo iw dev ' + self.interface + ' set txpower fixed ' + \ str(power_dBm * 100) try: [rcode, sout, serr] = self.run_command(cmd_str) except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) self.power = power_dBm
def get_info_of_connected_devices(self): ''' Returns information about associated STAs for a node running in AP mode tbd: use Netlink API ''' self.log.info( "WIFI Module get info on associated clients on interface: {}". format(self.interface)) try: [rcode, sout, serr ] = self.run_command('iw dev ' + self.interface + ' station dump') # mac_addr -> stat_key -> list of (value, unit) res = {} sout_arr = sout.split("\n") for line in sout_arr: s = line.strip() if s == '': continue if "Station" in s: arr = s.split() mac_addr = arr[1].strip() res[mac_addr] = {} else: arr = s.split(":") key = arr[0].strip() val = arr[1].strip() arr2 = val.split() val2 = arr2[0].strip() if len(arr2) > 1: unit = arr2[1].strip() else: unit = None res[mac_addr][key] = (val2, unit) return res except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e))
def set_channel(self, channel): self.log.info('setting channel(): %s->%s' % (str(self.interface), str(channel))) cmd_str = 'sudo iwconfig ' + self.interface + ' channel ' + str( channel) try: [rcode, sout, serr] = self.run_command(cmd_str) self.channel = channel except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e)) return True
def get_entry_of_connected_devices(self, key): try: res = self.get_info_of_connected_devices() rv = {} for mac_addr in res: value = res[mac_addr][key] self.log.info('%s -> %s' % (mac_addr, value)) rv[mac_addr] = value # dict of mac_addr -> value return rv except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e))
def install_mac_processor(self, interface, hybridMac): self.log.info('Function: installMacProcessor') #self.log.info('margs = %s' % str(myargs)) # hybridMac = pickle.loads(mac_profile) conf_str = None for ii in range(hybridMac.getNumSlots()): # for each slot ac = hybridMac.getAccessPolicy(ii) entries = ac.getEntries() for ll in range(len(entries)): entry = entries[ll] # slot_id, mac_addr, tid_mask if conf_str is None: conf_str = str(ii) + "," + str(entry[0]) + "," + str( entry[1]) else: conf_str = conf_str + "#" + str(ii) + "," + str( entry[0]) + "," + str(entry[1]) # set-up executable here. note: it is platform-dependent exec_file = str(os.path.join( self.get_platform_path_hybrid_MAC())) + '/hybrid_tdma_csma_mac' processArgs = str(exec_file) + " -d 0 " + " -i" + str( interface) + " -f" + str( hybridMac.getSlotDuration()) + " -n" + str( hybridMac.getNumSlots()) + " -c" + conf_str self.log.info('Calling hybrid mac executable w/ = %s' % str(processArgs)) try: # run as background process subprocess.Popen(processArgs.split(), shell=False) return True except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e))
def update_mac_processor(self, interface, hybridMac): self.log.info('Function: updateMacProcessor') self.log.info('margs = %s' % str(myargs)) #hybridMac = pickle.loads(mac_profile) # generate configuration string conf_str = None for ii in range(hybridMac.getNumSlots()): # for each slot ac = hybridMac.getAccessPolicy(ii) entries = ac.getEntries() for ll in range(len(entries)): entry = entries[ll] # slot_id, mac_addr, tid_mask if conf_str is None: conf_str = str(ii) + "," + str(entry[0]) + "," + str( entry[1]) else: conf_str = conf_str + "#" + str(ii) + "," + str( entry[0]) + "," + str(entry[1]) # update MAC processor configuration try: # todo cache sockets!!! context = zmq.Context() socket = context.socket(zmq.REQ) socket.connect("tcp://localhost:" + str(LOCAL_MAC_PROCESSOR_CTRL_PORT)) #socket.connect("ipc:///tmp/localmacprocessor") socket.send(conf_str) message = socket.recv() self.log.info("Received reply from HMAC: %s" % message) return True except zmq.ZMQError as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e))
def get_txchannel(self): param_keys = [] param_keys = ["IEEE802154_phyCurrentChannel"] node = self.node_factory.get_node(self.interface) if node != None: ret = node.read_parameters('taisc', param_keys) if type(ret) == dict: return ret["IEEE802154_phyCurrentChannel"] else: fname = inspect.currentframe().f_code.co_name self.log.fatal("Error executing function %s: %s!" % (fname, ret)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg="Error executing function") else: fname = inspect.currentframe().f_code.co_name self.log.fatal("%s Interface %s does not exist!" % (self.interface, fname)) raise exceptions.InvalidArgumentException( func_name=fname, err_msg="Interface does not exist")
def set_txpower(self, power_dBm): param_key_values = {} param_key_values['IEEE802154_phyTXPower'] = power_dBm node = self.node_factory.get_node(self.interface) if node != None: ret = node.write_parameters('taisc', param_key_values) if type(ret) == dict: return ret["IEEE802154_phyTXPower"] else: fname = inspect.currentframe().f_code.co_name self.log.fatal("Error executing function %s: %s!" % (fname, ret)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg="Error executing function") else: fname = inspect.currentframe().f_code.co_name self.log.fatal("%s Interface %s does not exist!" % (self.interface, fname)) raise exceptions.InvalidArgumentException( func_name=fname, err_msg="Interface does not exist")
def get_active(self): param_keys = [] param_keys = ["TAISC_ACTIVERADIOPROGRAM"] node = self.node_factory.get_node(self.interface) if node != None: ret = node.read_parameters('taisc', param_keys) if type(ret) == dict: return self.radio_program_names[ ret["TAISC_ACTIVERADIOPROGRAM"]] else: fname = inspect.currentframe().f_code.co_name self.log.fatal("Error executing function %s: %s!" % (fname, ret)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg="Error executing function") else: fname = inspect.currentframe().f_code.co_name self.log.fatal("%s Interface %s does not exist!" % (self.interface, fname)) raise exceptions.InvalidArgumentException( func_name=fname, err_msg="Interface does not exist")
def add_device_to_blacklist(self, iface, sta_mac_addr): """ Blacklist a given STA in the AP, i.e. any request for association by the STA will be ignored by the AP. tbd: what is -p ?? Please simplify """ exec_file = str(os.path.join( self.getPlatformPathHandover())) + '/hostapd_cli' args = '-p /tmp/hostapd-' + iface + ' blacklist_sta' command = exec_file + ' ' + args + ' ' + sta_mac_addr self.log.debug('Blacklist node %s on iface %s' % (sta_mac_addr, iface)) self.log.debug('exec %s' % command) try: [rcode, sout, serr] = self.run_command(command) return sout except Exception as e: fname = inspect.currentframe().f_code.co_name self.log.fatal("An error occurred in %s: %s" % (fname, e)) raise exceptions.UPIFunctionExecutionFailedException( func_name=fname, err_msg=str(e))