afonso/core-extra
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

more updates to using f string

Browse source
This commit is contained in:
Blake Harnden 2019-10-18 10:33:31 -07:00
parent 79cde8cd59
commit 7d2a615716
23 changed files with 248 additions and 251 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
daemon/core/config.py
View file

@ -40,10 +40,8 @@ class ConfigShim(object):
""" """
group_strings = [] group_strings = []
for config_group in config_groups: for config_group in config_groups:
group_string = "%s:%s-%s" % ( group_string = (
config_group.name, f"{config_group.name}:{config_group.start}-{config_group.stop}"
config_group.start,
config_group.stop,
) )
group_strings.append(group_string) group_strings.append(group_string)
return "|".join(group_strings) return "|".join(group_strings)
@ -74,7 +72,7 @@ class ConfigShim(object):
if not captions: if not captions:
captions = configuration.label captions = configuration.label
else: else:
captions += "|%s" % configuration.label captions += f"|{configuration.label}"
data_types.append(configuration.type.value) data_types.append(configuration.type.value)
@ -83,11 +81,11 @@ class ConfigShim(object):
_id = configuration.id _id = configuration.id
config_value = config.get(_id, configuration.default) config_value = config.get(_id, configuration.default)
key_value = "%s=%s" % (_id, config_value) key_value = f"{_id}={config_value}"
if not key_values: if not key_values:
key_values = key_value key_values = key_value
else: else:
key_values += "|%s" % key_value key_values += f"|{key_value}"
groups_str = cls.groups_to_str(configurable_options.config_groups()) groups_str = cls.groups_to_str(configurable_options.config_groups())
return ConfigData( return ConfigData(
@ -130,13 +128,7 @@ class Configuration(object):
self.label = label self.label = label
def __str__(self): def __str__(self):
return "%s(id=%s, type=%s, default=%s, options=%s)" % ( return f"{self.__class__.__name__}(id={self.id}, type={self.type}, default={self.default}, options={self.options})"
self.__class__.__name__,
self.id,
self.type,
self.default,
self.options,
)
class ConfigurableManager(object): class ConfigurableManager(object):
@ -333,7 +325,7 @@ class ModelManager(ConfigurableManager):
# get model class to configure # get model class to configure
model_class = self.models.get(model_name) model_class = self.models.get(model_name)
if not model_class: if not model_class:
raise ValueError("%s is an invalid model" % model_name) raise ValueError(f"{model_name} is an invalid model")
# retrieve default values # retrieve default values
model_config = self.get_model_config(node_id, model_name) model_config = self.get_model_config(node_id, model_name)
@ -361,7 +353,7 @@ class ModelManager(ConfigurableManager):
# get model class to configure # get model class to configure
model_class = self.models.get(model_name) model_class = self.models.get(model_name)
if not model_class: if not model_class:
raise ValueError("%s is an invalid model" % model_name) raise ValueError(f"{model_name} is an invalid model")
config = self.get_configs(node_id=node_id, config_type=model_name) config = self.get_configs(node_id=node_id, config_type=model_name)
if not config: if not config:

6
daemon/core/emane/commeffect.py
View file

@ -73,9 +73,7 @@ class EmaneCommEffectModel(emanemodel.EmaneModel):
shim_name = emanexml.shim_file_name(self, interface) shim_name = emanexml.shim_file_name(self, interface)
# create and write nem document # create and write nem document
nem_element = etree.Element( nem_element = etree.Element("nem", name=f"{self.name} NEM", type="unstructured")
"nem", name="%s NEM" % self.name, type="unstructured"
)
transport_type = "virtual" transport_type = "virtual"
if interface and interface.transport_type == "raw": if interface and interface.transport_type == "raw":
transport_type = "raw" transport_type = "raw"
@ -90,7 +88,7 @@ class EmaneCommEffectModel(emanemodel.EmaneModel):
# create and write shim document # create and write shim document
shim_element = etree.Element( shim_element = etree.Element(
"shim", name="%s SHIM" % self.name, library=self.shim_library "shim", name=f"{self.name} SHIM", library=self.shim_library
) )
# append all shim options (except filterfile) to shimdoc # append all shim options (except filterfile) to shimdoc

21
daemon/core/emane/emanemanager.py
View file

@ -227,7 +227,7 @@ class EmaneManager(ModelManager):
with self._emane_node_lock: with self._emane_node_lock:
if emane_net.id in self._emane_nets: if emane_net.id in self._emane_nets:
raise KeyError( raise KeyError(
"non-unique EMANE object id %s for %s" % (emane_net.id, emane_net) f"non-unique EMANE object id {emane_net.id} for {emane_net}"
) )
self._emane_nets[emane_net.id] = emane_net self._emane_nets[emane_net.id] = emane_net
@ -342,7 +342,7 @@ class EmaneManager(ModelManager):
try: try:
with open(emane_nems_filename, "w") as f: with open(emane_nems_filename, "w") as f:
for nodename, ifname, nemid in nems: for nodename, ifname, nemid in nems:
f.write("%s %s %s\n" % (nodename, ifname, nemid)) f.write(f"{nodename} {ifname} {nemid}\n")
except IOError: except IOError:
logging.exception("Error writing EMANE NEMs file: %s") logging.exception("Error writing EMANE NEMs file: %s")
@ -535,7 +535,7 @@ class EmaneManager(ModelManager):
logging.info("setting user-defined EMANE log level: %d", cfgloglevel) logging.info("setting user-defined EMANE log level: %d", cfgloglevel)
loglevel = str(cfgloglevel) loglevel = str(cfgloglevel)
emanecmd = "emane -d -l %s" % loglevel emanecmd = f"emane -d -l {loglevel}"
if realtime: if realtime:
emanecmd += " -r" emanecmd += " -r"
@ -580,11 +580,9 @@ class EmaneManager(ModelManager):
node.node_net_client.create_route(eventgroup, eventdev) node.node_net_client.create_route(eventgroup, eventdev)
# start emane # start emane
args = "%s -f %s %s" % ( log_file = os.path.join(path, f"emane{n}.log")
emanecmd, platform_xml = os.path.join(path, f"platform{n}.xml")
os.path.join(path, "emane%d.log" % n), args = f"{emanecmd} -f {log_file} {platform_xml}"
os.path.join(path, "platform%d.xml" % n),
)
output = node.node_net_cmd(args) output = node.node_net_cmd(args)
logging.info("node(%s) emane daemon running: %s", node.name, args) logging.info("node(%s) emane daemon running: %s", node.name, args)
logging.info("node(%s) emane daemon output: %s", node.name, output) logging.info("node(%s) emane daemon output: %s", node.name, output)
@ -593,8 +591,9 @@ class EmaneManager(ModelManager):
return return
path = self.session.session_dir path = self.session.session_dir
emanecmd += " -f %s" % os.path.join(path, "emane.log") log_file = os.path.join(path, "emane.log")
emanecmd += " %s" % os.path.join(path, "platform.xml") platform_xml = os.path.join(path, "platform.xml")
emanecmd += f" -f {log_file} {platform_xml}"
utils.check_cmd(emanecmd, cwd=path) utils.check_cmd(emanecmd, cwd=path)
self.session.distributed.execute(lambda x: x.remote_cmd(emanecmd, cwd=path)) self.session.distributed.execute(lambda x: x.remote_cmd(emanecmd, cwd=path))
logging.info("host emane daemon running: %s", emanecmd) logging.info("host emane daemon running: %s", emanecmd)
@ -797,7 +796,7 @@ class EmaneManager(ModelManager):
node = self.session.get_node(n) node = self.session.get_node(n)
except CoreError: except CoreError:
logging.exception( logging.exception(
"location event NEM %s has no corresponding node %s" % (nemid, n) "location event NEM %s has no corresponding node %s", nemid, n
) )
return False return False

2
daemon/core/emane/emanemanifest.py
View file

@ -115,7 +115,7 @@ def parse(manifest_path, defaults):
# define description and account for gui quirks # define description and account for gui quirks
config_descriptions = config_name config_descriptions = config_name
if config_name.endswith("uri"): if config_name.endswith("uri"):
config_descriptions = "%s file" % config_descriptions config_descriptions = f"{config_descriptions} file"
configuration = Configuration( configuration = Configuration(
_id=config_name, _id=config_name,

2
daemon/core/emane/nodes.py
View file

@ -210,7 +210,7 @@ class EmaneNet(CoreNetworkBase):
nemid = self.getnemid(netif) nemid = self.getnemid(netif)
ifname = netif.localname ifname = netif.localname
if nemid is None: if nemid is None:
logging.info("nemid for %s is unknown" % ifname) logging.info("nemid for %s is unknown", ifname)
continue continue
x, y, z = netif.node.getposition() x, y, z = netif.node.getposition()
lat, lon, alt = self.session.location.getgeo(x, y, z) lat, lon, alt = self.session.location.getgeo(x, y, z)

2
daemon/core/emane/tdma.py
View file

@ -62,5 +62,5 @@ class EmaneTdmaModel(emanemodel.EmaneModel):
logging.info( logging.info(
"setting up tdma schedule: schedule(%s) device(%s)", schedule, event_device "setting up tdma schedule: schedule(%s) device(%s)", schedule, event_device
) )
args = "emaneevent-tdmaschedule -i %s %s" % (event_device, schedule) args = f"emaneevent-tdmaschedule -i {event_device} {schedule}"
utils.check_cmd(args) utils.check_cmd(args)

4
daemon/core/emulator/distributed.py
View file

@ -128,7 +128,7 @@ class DistributedController(object):
""" """
server = DistributedServer(name, host) server = DistributedServer(name, host)
self.servers[name] = server self.servers[name] = server
cmd = "mkdir -p %s" % self.session.session_dir cmd = f"mkdir -p {self.session.session_dir}"
server.remote_cmd(cmd) server.remote_cmd(cmd)
def execute(self, func): def execute(self, func):
@ -158,7 +158,7 @@ class DistributedController(object):
# remove all remote session directories # remove all remote session directories
for name in self.servers: for name in self.servers:
server = self.servers[name] server = self.servers[name]
cmd = "rm -rf %s" % self.session.session_dir cmd = f"rm -rf {self.session.session_dir}"
server.remote_cmd(cmd) server.remote_cmd(cmd)
# clear tunnels # clear tunnels

4
daemon/core/emulator/emudata.py
View file

@ -284,7 +284,7 @@ class InterfaceData(object):
:return: ip4 string or None :return: ip4 string or None
""" """
if self.has_ip4(): if self.has_ip4():
return "%s/%s" % (self.ip4, self.ip4_mask) return f"{self.ip4}/{self.ip4_mask}"
else: else:
return None return None
@ -295,7 +295,7 @@ class InterfaceData(object):
:return: ip4 string or None :return: ip4 string or None
""" """
if self.has_ip6(): if self.has_ip6():
return "%s/%s" % (self.ip6, self.ip6_mask) return f"{self.ip6}/{self.ip6_mask}"
else: else:
return None return None

74
daemon/core/emulator/session.py
View file

@ -90,7 +90,7 @@ class Session(object):
self.master = False self.master = False
# define and create session directory when desired # define and create session directory when desired
self.session_dir = os.path.join(tempfile.gettempdir(), "pycore.%s" % self.id) self.session_dir = os.path.join(tempfile.gettempdir(), f"pycore.{self.id}")
if mkdir: if mkdir:
os.mkdir(self.session_dir) os.mkdir(self.session_dir)
@ -164,7 +164,7 @@ class Session(object):
""" """
node_class = NODES.get(_type) node_class = NODES.get(_type)
if node_class is None: if node_class is None:
raise CoreError("invalid node type: %s" % _type) raise CoreError(f"invalid node type: {_type}")
return node_class return node_class
@classmethod @classmethod
@ -178,7 +178,7 @@ class Session(object):
""" """
node_type = NODES_TYPE.get(_class) node_type = NODES_TYPE.get(_class)
if node_type is None: if node_type is None:
raise CoreError("invalid node class: %s" % _class) raise CoreError(f"invalid node class: {_class}")
return node_type return node_type
def _link_nodes(self, node_one_id, node_two_id): def _link_nodes(self, node_one_id, node_two_id):
@ -254,7 +254,7 @@ class Session(object):
""" """
objects = [x for x in objects if x] objects = [x for x in objects if x]
if len(objects) < 2: if len(objects) < 2:
raise CoreError("wireless link failure: %s" % objects) raise CoreError(f"wireless link failure: {objects}")
logging.debug( logging.debug(
"handling wireless linking objects(%s) connect(%s)", objects, connect "handling wireless linking objects(%s) connect(%s)", objects, connect
) )
@ -665,13 +665,13 @@ class Session(object):
node_options = NodeOptions() node_options = NodeOptions()
name = node_options.name name = node_options.name
if not name: if not name:
name = "%s%s" % (node_class.__name__, _id) name = f"{node_class.__name__}{_id}"
# verify distributed server # verify distributed server
server = self.distributed.servers.get(node_options.emulation_server) server = self.distributed.servers.get(node_options.emulation_server)
if node_options.emulation_server is not None and server is None: if node_options.emulation_server is not None and server is None:
raise CoreError( raise CoreError(
"invalid distributed server: %s" % node_options.emulation_server f"invalid distributed server: {node_options.emulation_server}"
) )
# create node # create node
@ -854,7 +854,7 @@ class Session(object):
:return: nothing :return: nothing
""" """
# hack to conform with old logic until updated # hack to conform with old logic until updated
state = ":%s" % state state = f":{state}"
self.set_hook(state, file_name, source_name, data) self.set_hook(state, file_name, source_name, data)
def add_node_file(self, node_id, source_name, file_name, data): def add_node_file(self, node_id, source_name, file_name, data):
@ -1066,7 +1066,7 @@ class Session(object):
self.run_state_hooks(state_value) self.run_state_hooks(state_value)
if send_event: if send_event:
event_data = EventData(event_type=state_value, time="%s" % time.time()) event_data = EventData(event_type=state_value, time=str(time.time()))
self.broadcast_event(event_data) self.broadcast_event(event_data)
def write_state(self, state): def write_state(self, state):
@ -1078,7 +1078,7 @@ class Session(object):
""" """
try: try:
state_file = open(self._state_file, "w") state_file = open(self._state_file, "w")
state_file.write("%d %s\n" % (state, EventTypes(self.state).name)) state_file.write(f"{state} {EventTypes(self.state).name}\n")
state_file.close() state_file.close()
except IOError: except IOError:
logging.exception("error writing state file: %s", state) logging.exception("error writing state file: %s", state)
@ -1195,9 +1195,9 @@ class Session(object):
try: try:
hook(state) hook(state)
except Exception: except Exception:
message = "exception occured when running %s state hook: %s" % ( state_name = EventTypes(self.state).name
EventTypes(self.state).name, message = (
hook, f"exception occured when running {state_name} state hook: {hook}"
) )
logging.exception(message) logging.exception(message)
self.exception( self.exception(
@ -1258,16 +1258,16 @@ class Session(object):
:rtype: dict :rtype: dict
""" """
env = os.environ.copy() env = os.environ.copy()
env["SESSION"] = "%s" % self.id env["SESSION"] = str(self.id)
env["SESSION_SHORT"] = "%s" % self.short_session_id() env["SESSION_SHORT"] = self.short_session_id()
env["SESSION_DIR"] = "%s" % self.session_dir env["SESSION_DIR"] = self.session_dir
env["SESSION_NAME"] = "%s" % self.name env["SESSION_NAME"] = str(self.name)
env["SESSION_FILENAME"] = "%s" % self.file_name env["SESSION_FILENAME"] = str(self.file_name)
env["SESSION_USER"] = "%s" % self.user env["SESSION_USER"] = str(self.user)
env["SESSION_NODE_COUNT"] = "%s" % self.get_node_count() env["SESSION_NODE_COUNT"] = str(self.get_node_count())
if state: if state:
env["SESSION_STATE"] = "%s" % self.state env["SESSION_STATE"] = str(self.state)
# attempt to read and add environment config file # attempt to read and add environment config file
environment_config_file = os.path.join(constants.CORE_CONF_DIR, "environment") environment_config_file = os.path.join(constants.CORE_CONF_DIR, "environment")
@ -1356,7 +1356,7 @@ class Session(object):
with self._nodes_lock: with self._nodes_lock:
if node.id in self.nodes: if node.id in self.nodes:
node.shutdown() node.shutdown()
raise CoreError("duplicate node id %s for %s" % (node.id, node.name)) raise CoreError(f"duplicate node id {node.id} for {node.name}")
self.nodes[node.id] = node self.nodes[node.id] = node
return node return node
@ -1371,7 +1371,7 @@ class Session(object):
:raises core.CoreError: when node does not exist :raises core.CoreError: when node does not exist
""" """
if _id not in self.nodes: if _id not in self.nodes:
raise CoreError("unknown node id %s" % _id) raise CoreError(f"unknown node id {_id}")
return self.nodes[_id] return self.nodes[_id]
def delete_node(self, _id): def delete_node(self, _id):
@ -1416,9 +1416,7 @@ class Session(object):
with open(file_path, "w") as f: with open(file_path, "w") as f:
for _id in self.nodes.keys(): for _id in self.nodes.keys():
node = self.nodes[_id] node = self.nodes[_id]
f.write( f.write(f"{_id} {node.name} {node.apitype} {type(node)}\n")
"%s %s %s %s\n" % (_id, node.name, node.apitype, type(node))
)
except IOError: except IOError:
logging.exception("error writing nodes file") logging.exception("error writing nodes file")
@ -1585,7 +1583,7 @@ class Session(object):
interface names, where length may be limited. interface names, where length may be limited.
""" """
ssid = (self.id >> 8) ^ (self.id & ((1 << 8) - 1)) ssid = (self.id >> 8) ^ (self.id & ((1 << 8) - 1))
return "%x" % ssid return f"{ssid:x}"
def boot_nodes(self): def boot_nodes(self):
""" """
@ -1670,7 +1668,7 @@ class Session(object):
def get_control_net(self, net_index): def get_control_net(self, net_index):
# TODO: all nodes use an integer id and now this wants to use a string # TODO: all nodes use an integer id and now this wants to use a string
_id = "ctrl%dnet" % net_index _id = f"ctrl{net_index}net"
return self.get_node(_id) return self.get_node(_id)
def add_remove_control_net(self, net_index, remove=False, conf_required=True): def add_remove_control_net(self, net_index, remove=False, conf_required=True):
@ -1718,7 +1716,7 @@ class Session(object):
return None return None
# build a new controlnet bridge # build a new controlnet bridge
_id = "ctrl%dnet" % net_index _id = f"ctrl{net_index}net"
# use the updown script for control net 0 only. # use the updown script for control net 0 only.
updown_script = None updown_script = None
@ -1797,13 +1795,12 @@ class Session(object):
control_ip = node.id control_ip = node.id
try: try:
addrlist = [ address = control_net.prefix.addr(control_ip)
"%s/%s" prefix = control_net.prefix.prefixlen
% (control_net.prefix.addr(control_ip), control_net.prefix.prefixlen) addrlist = [f"{address}/{prefix}"]
]
except ValueError: except ValueError:
msg = "Control interface not added to node %s. " % node.id msg = f"Control interface not added to node {node.id}. "
msg += "Invalid control network prefix (%s). " % control_net.prefix msg += f"Invalid control network prefix ({control_net.prefix}). "
msg += "A longer prefix length may be required for this many nodes." msg += "A longer prefix length may be required for this many nodes."
logging.exception(msg) logging.exception(msg)
return return
@ -1811,7 +1808,7 @@ class Session(object):
interface1 = node.newnetif( interface1 = node.newnetif(
net=control_net, net=control_net,
ifindex=control_net.CTRLIF_IDX_BASE + net_index, ifindex=control_net.CTRLIF_IDX_BASE + net_index,
ifname="ctrl%d" % net_index, ifname=f"ctrl{net_index}",
hwaddr=MacAddress.random(), hwaddr=MacAddress.random(),
addrlist=addrlist, addrlist=addrlist,
) )
@ -1834,7 +1831,7 @@ class Session(object):
logging.exception("error retrieving control net node") logging.exception("error retrieving control net node")
return return
header = "CORE session %s host entries" % self.id header = f"CORE session {self.id} host entries"
if remove: if remove:
logging.info("Removing /etc/hosts file entries.") logging.info("Removing /etc/hosts file entries.")
utils.file_demunge("/etc/hosts", header) utils.file_demunge("/etc/hosts", header)
@ -1844,9 +1841,10 @@ class Session(object):
for interface in control_net.netifs(): for interface in control_net.netifs():
name = interface.node.name name = interface.node.name
for address in interface.addrlist: for address in interface.addrlist:
entries.append("%s %s" % (address.split("/")[0], name)) address = address.split("/")[0]
entries.append(f"{address} {name}")
logging.info("Adding %d /etc/hosts file entries." % len(entries)) logging.info("Adding %d /etc/hosts file entries.", len(entries))
utils.file_munge("/etc/hosts", header, "\n".join(entries) + "\n") utils.file_munge("/etc/hosts", header, "\n".join(entries) + "\n")

19
daemon/core/location/mobility.py
View file

@ -165,15 +165,16 @@ class MobilityManager(ModelManager):
elif model.state == model.STATE_PAUSED: elif model.state == model.STATE_PAUSED:
event_type = EventTypes.PAUSE.value event_type = EventTypes.PAUSE.value
data = "start=%d" % int(model.lasttime - model.timezero) start_time = int(model.lasttime - model.timezero)
data += " end=%d" % int(model.endtime) end_time = int(model.endtime)
data = f"start={start_time} end={end_time}"
event_data = EventData( event_data = EventData(
node=model.id, node=model.id,
event_type=event_type, event_type=event_type,
name="mobility:%s" % model.name, name=f"mobility:{model.name}",
data=data, data=data,
time="%s" % time.time(), time=str(time.time()),
) )
self.session.broadcast_event(event_data) self.session.broadcast_event(event_data)
@ -991,7 +992,7 @@ class Ns2ScriptedMobility(WayPointMobility):
"ns-2 scripted mobility failed to load file: %s", self.file "ns-2 scripted mobility failed to load file: %s", self.file
) )
return return
logging.info("reading ns-2 script file: %s" % filename) logging.info("reading ns-2 script file: %s", filename)
ln = 0 ln = 0
ix = iy = iz = None ix = iy = iz = None
inodenum = None inodenum = None
@ -1112,7 +1113,7 @@ class Ns2ScriptedMobility(WayPointMobility):
:return: nothing :return: nothing
""" """
if self.autostart == "": if self.autostart == "":
logging.info("not auto-starting ns-2 script for %s" % self.wlan.name) logging.info("not auto-starting ns-2 script for %s", self.wlan.name)
return return
try: try:
t = float(self.autostart) t = float(self.autostart)
@ -1124,9 +1125,7 @@ class Ns2ScriptedMobility(WayPointMobility):
) )
return return
self.movenodesinitial() self.movenodesinitial()
logging.info( logging.info("scheduling ns-2 script for %s autostart at %s", self.wlan.name, t)
"scheduling ns-2 script for %s autostart at %s" % (self.wlan.name, t)
)
self.state = self.STATE_RUNNING self.state = self.STATE_RUNNING
self.session.event_loop.add_event(t, self.run) self.session.event_loop.add_event(t, self.run)
@ -1187,7 +1186,7 @@ class Ns2ScriptedMobility(WayPointMobility):
if filename is None or filename == "": if filename is None or filename == "":
return return
filename = self.findfile(filename) filename = self.findfile(filename)
args = "/bin/sh %s %s" % (filename, typestr) args = f"/bin/sh {filename} {typestr}"
utils.check_cmd( utils.check_cmd(
args, cwd=self.session.session_dir, env=self.session.get_environment() args, cwd=self.session.session_dir, env=self.session.get_environment()
) )

63
daemon/core/nodes/base.py
View file

@ -46,7 +46,7 @@ class NodeBase(object):
_id = session.get_node_id() _id = session.get_node_id()
self.id = _id self.id = _id
if name is None: if name is None:
name = "o%s" % self.id name = f"o{self.id}"
self.name = name self.name = name
self.server = server self.server = server
@ -265,7 +265,7 @@ class CoreNodeBase(NodeBase):
""" """
if self.nodedir is None: if self.nodedir is None:
self.nodedir = os.path.join(self.session.session_dir, self.name + ".conf") self.nodedir = os.path.join(self.session.session_dir, self.name + ".conf")
self.net_cmd("mkdir -p %s" % self.nodedir) self.net_cmd(f"mkdir -p {self.nodedir}")
self.tmpnodedir = True self.tmpnodedir = True
else: else:
self.tmpnodedir = False self.tmpnodedir = False
@ -281,7 +281,7 @@ class CoreNodeBase(NodeBase):
return return
if self.tmpnodedir: if self.tmpnodedir:
self.net_cmd("rm -rf %s" % self.nodedir) self.net_cmd(f"rm -rf {self.nodedir}")
def addnetif(self, netif, ifindex): def addnetif(self, netif, ifindex):
""" """
@ -292,7 +292,7 @@ class CoreNodeBase(NodeBase):
:return: nothing :return: nothing
""" """
if ifindex in self._netif: if ifindex in self._netif:
raise ValueError("ifindex %s already exists" % ifindex) raise ValueError(f"ifindex {ifindex} already exists")
self._netif[ifindex] = netif self._netif[ifindex] = netif
# TODO: this should have probably been set ahead, seems bad to me, check for failure and fix # TODO: this should have probably been set ahead, seems bad to me, check for failure and fix
netif.netindex = ifindex netif.netindex = ifindex
@ -305,7 +305,7 @@ class CoreNodeBase(NodeBase):
:return: nothing :return: nothing
""" """
if ifindex not in self._netif: if ifindex not in self._netif:
raise ValueError("ifindex %s does not exist" % ifindex) raise ValueError(f"ifindex {ifindex} does not exist")
netif = self._netif.pop(ifindex) netif = self._netif.pop(ifindex)
netif.shutdown() netif.shutdown()
del netif del netif
@ -334,7 +334,7 @@ class CoreNodeBase(NodeBase):
:return: nothing :return: nothing
""" """
if ifindex not in self._netif: if ifindex not in self._netif:
raise ValueError("ifindex %s does not exist" % ifindex) raise ValueError(f"ifindex {ifindex} does not exist")
self._netif[ifindex].attachnet(net) self._netif[ifindex].attachnet(net)
def detachnet(self, ifindex): def detachnet(self, ifindex):
@ -345,7 +345,7 @@ class CoreNodeBase(NodeBase):
:return: nothing :return: nothing
""" """
if ifindex not in self._netif: if ifindex not in self._netif:
raise ValueError("ifindex %s does not exist" % ifindex) raise ValueError(f"ifindex {ifindex} does not exist")
self._netif[ifindex].detachnet() self._netif[ifindex].detachnet()
def setposition(self, x=None, y=None, z=None): def setposition(self, x=None, y=None, z=None):
@ -472,7 +472,7 @@ class CoreNode(CoreNodeBase):
:rtype: bool :rtype: bool
""" """
try: try:
self.net_cmd("kill -0 %s" % self.pid) self.net_cmd(f"kill -0 {self.pid}")
except CoreCommandError: except CoreCommandError:
return False return False
@ -496,10 +496,11 @@ class CoreNode(CoreNodeBase):
cmd=VNODED_BIN, name=self.ctrlchnlname cmd=VNODED_BIN, name=self.ctrlchnlname
) )
if self.nodedir: if self.nodedir:
vnoded += " -C %s" % self.nodedir vnoded += f" -C {self.nodedir}"
env = self.session.get_environment(state=False) env = self.session.get_environment(state=False)
env["NODE_NUMBER"] = str(self.id) env["NODE_NUMBER"] = str(self.id)
env["NODE_NAME"] = str(self.name) env["NODE_NAME"] = str(self.name)
logging.info("env: %s", env)
output = self.net_cmd(vnoded, env=env) output = self.net_cmd(vnoded, env=env)
self.pid = int(output) self.pid = int(output)
@ -545,13 +546,13 @@ class CoreNode(CoreNodeBase):
# kill node process if present # kill node process if present
try: try:
self.net_cmd("kill -9 %s" % self.pid) self.net_cmd(f"kill -9 {self.pid}")
except CoreCommandError: except CoreCommandError:
logging.exception("error killing process") logging.exception("error killing process")
# remove node directory if present # remove node directory if present
try: try:
self.net_cmd("rm -rf %s" % self.ctrlchnlname) self.net_cmd(f"rm -rf {self.ctrlchnlname}")
except CoreCommandError: except CoreCommandError:
logging.exception("error removing node directory") logging.exception("error removing node directory")
@ -604,11 +605,11 @@ class CoreNode(CoreNodeBase):
:return: nothing :return: nothing
""" """
if path[0] != "/": if path[0] != "/":
raise ValueError("path not fully qualified: %s" % path) raise ValueError(f"path not fully qualified: {path}")
hostpath = os.path.join( hostpath = os.path.join(
self.nodedir, os.path.normpath(path).strip("/").replace("/", ".") self.nodedir, os.path.normpath(path).strip("/").replace("/", ".")
) )
self.net_cmd("mkdir -p %s" % hostpath) self.net_cmd(f"mkdir -p {hostpath}")
self.mount(hostpath, path) self.mount(hostpath, path)
def mount(self, source, target): def mount(self, source, target):
@ -622,8 +623,8 @@ class CoreNode(CoreNodeBase):
""" """
source = os.path.abspath(source) source = os.path.abspath(source)
logging.debug("node(%s) mounting: %s at %s", self.name, source, target) logging.debug("node(%s) mounting: %s at %s", self.name, source, target)
self.node_net_cmd("mkdir -p %s" % target) self.node_net_cmd(f"mkdir -p {target}")
self.node_net_cmd("%s -n --bind %s %s" % (MOUNT_BIN, source, target)) self.node_net_cmd(f"{MOUNT_BIN} -n --bind {source} {target}")
self._mounts.append((source, target)) self._mounts.append((source, target))
def newifindex(self): def newifindex(self):
@ -650,22 +651,22 @@ class CoreNode(CoreNodeBase):
ifindex = self.newifindex() ifindex = self.newifindex()
if ifname is None: if ifname is None:
ifname = "eth%d" % ifindex ifname = f"eth{ifindex}"
sessionid = self.session.short_session_id() sessionid = self.session.short_session_id()
try: try:
suffix = "%x.%s.%s" % (self.id, ifindex, sessionid) suffix = f"{self.id:x}.{ifindex}.{sessionid}"
except TypeError: except TypeError:
suffix = "%s.%s.%s" % (self.id, ifindex, sessionid) suffix = f"{self.id}.{ifindex}.{sessionid}"
localname = "veth" + suffix localname = f"veth{suffix}"
if len(localname) >= 16: if len(localname) >= 16:
raise ValueError("interface local name (%s) too long" % localname) raise ValueError(f"interface local name ({localname}) too long")
name = localname + "p" name = localname + "p"
if len(name) >= 16: if len(name) >= 16:
raise ValueError("interface name (%s) too long" % name) raise ValueError(f"interface name ({name}) too long")
veth = Veth( veth = Veth(
self.session, self, name, localname, start=self.up, server=self.server self.session, self, name, localname, start=self.up, server=self.server
@ -716,10 +717,10 @@ class CoreNode(CoreNodeBase):
ifindex = self.newifindex() ifindex = self.newifindex()
if ifname is None: if ifname is None:
ifname = "eth%d" % ifindex ifname = f"eth{ifindex}"
sessionid = self.session.short_session_id() sessionid = self.session.short_session_id()
localname = "tap%s.%s.%s" % (self.id, ifindex, sessionid) localname = f"tap{self.id}.{ifindex}.{sessionid}"
name = ifname name = ifname
tuntap = TunTap(self.session, self, name, localname, start=self.up) tuntap = TunTap(self.session, self, name, localname, start=self.up)
@ -778,7 +779,7 @@ class CoreNode(CoreNodeBase):
try: try:
interface.deladdr(addr) interface.deladdr(addr)
except ValueError: except ValueError:
logging.exception("trying to delete unknown address: %s" % addr) logging.exception("trying to delete unknown address: %s", addr)
if self.up: if self.up:
self.node_net_client.delete_address(interface.name, str(addr)) self.node_net_client.delete_address(interface.name, str(addr))
@ -850,11 +851,11 @@ class CoreNode(CoreNodeBase):
logging.info("adding file from %s to %s", srcname, filename) logging.info("adding file from %s to %s", srcname, filename)
directory = os.path.dirname(filename) directory = os.path.dirname(filename)
if self.server is None: if self.server is None:
self.client.check_cmd("mkdir -p %s" % directory) self.client.check_cmd(f"mkdir -p {directory}")
self.client.check_cmd("mv %s %s" % (srcname, filename)) self.client.check_cmd(f"mv {srcname} {filename}")
self.client.check_cmd("sync") self.client.check_cmd("sync")
else: else:
self.net_cmd("mkdir -p %s" % directory) self.net_cmd(f"mkdir -p {directory}")
self.server.remote_put(srcname, filename) self.server.remote_put(srcname, filename)
def hostfilename(self, filename): def hostfilename(self, filename):
@ -866,7 +867,7 @@ class CoreNode(CoreNodeBase):
""" """
dirname, basename = os.path.split(filename) dirname, basename = os.path.split(filename)
if not basename: if not basename:
raise ValueError("no basename for filename: %s" % filename) raise ValueError(f"no basename for filename: {filename}")
if dirname and dirname[0] == "/": if dirname and dirname[0] == "/":
dirname = dirname[1:] dirname = dirname[1:]
dirname = dirname.replace("/", ".") dirname = dirname.replace("/", ".")
@ -891,9 +892,9 @@ class CoreNode(CoreNodeBase):
open_file.write(contents) open_file.write(contents)
os.chmod(open_file.name, mode) os.chmod(open_file.name, mode)
else: else:
self.net_cmd("mkdir -m %o -p %s" % (0o755, dirname)) self.net_cmd(f"mkdir -m {0o755:o} -p {dirname}")
self.server.remote_put_temp(hostfilename, contents) self.server.remote_put_temp(hostfilename, contents)
self.net_cmd("chmod %o %s" % (mode, hostfilename)) self.net_cmd(f"chmod {mode:o} {hostfilename}")
logging.debug( logging.debug(
"node(%s) added file: %s; mode: 0%o", self.name, hostfilename, mode "node(%s) added file: %s; mode: 0%o", self.name, hostfilename, mode
) )
@ -914,7 +915,7 @@ class CoreNode(CoreNodeBase):
else: else:
self.server.remote_put(srcfilename, hostfilename) self.server.remote_put(srcfilename, hostfilename)
if mode is not None: if mode is not None:
self.net_cmd("chmod %o %s" % (mode, hostfilename)) self.net_cmd(f"chmod {mode:o} {hostfilename}")
logging.info( logging.info(
"node(%s) copied file: %s; mode: %s", self.name, hostfilename, mode "node(%s) copied file: %s; mode: %s", self.name, hostfilename, mode
) )

34
daemon/core/plugins/sdt.py
View file

@ -7,6 +7,7 @@ import socket
from urllib.parse import urlparse from urllib.parse import urlparse
from core import constants from core import constants
from core.constants import CORE_DATA_DIR
from core.emane.nodes import EmaneNet from core.emane.nodes import EmaneNet
from core.emulator.enumerations import ( from core.emulator.enumerations import (
EventTypes, EventTypes,
@ -161,7 +162,7 @@ class Sdt(object):
return False return False
self.seturl() self.seturl()
logging.info("connecting to SDT at %s://%s" % (self.protocol, self.address)) logging.info("connecting to SDT at %s://%s", self.protocol, self.address)
if self.sock is None: if self.sock is None:
try: try:
if self.protocol.lower() == "udp": if self.protocol.lower() == "udp":
@ -192,14 +193,14 @@ class Sdt(object):
:return: initialize command status :return: initialize command status
:rtype: bool :rtype: bool
""" """
if not self.cmd('path "%s/icons/normal"' % constants.CORE_DATA_DIR): if not self.cmd(f'path "{CORE_DATA_DIR}/icons/normal"'):
return False return False
# send node type to icon mappings # send node type to icon mappings
for node_type, icon in self.DEFAULT_SPRITES: for node_type, icon in self.DEFAULT_SPRITES:
if not self.cmd("sprite %s image %s" % (node_type, icon)): if not self.cmd(f"sprite {node_type} image {icon}"):
return False return False
lat, long = self.session.location.refgeo[:2] lat, long = self.session.location.refgeo[:2]
return self.cmd("flyto %.6f,%.6f,%d" % (long, lat, self.DEFAULT_ALT)) return self.cmd(f"flyto {long:.6f},{lat:.6f},{self.DEFAULT_ALT}")
def disconnect(self): def disconnect(self):
""" """
@ -240,8 +241,8 @@ class Sdt(object):
if self.sock is None: if self.sock is None:
return False return False
try: try:
logging.info("sdt: %s" % cmdstr) logging.info("sdt: %s", cmdstr)
self.sock.sendall("%s\n" % cmdstr) self.sock.sendall(f"{cmdstr}\n")
return True return True
except IOError: except IOError:
logging.exception("SDT connection error") logging.exception("SDT connection error")
@ -266,23 +267,21 @@ class Sdt(object):
if not self.connect(): if not self.connect():
return return
if flags & MessageFlags.DELETE.value: if flags & MessageFlags.DELETE.value:
self.cmd("delete node,%d" % nodenum) self.cmd(f"delete node,{nodenum}")
return return
if x is None or y is None: if x is None or y is None:
return return
lat, lon, alt = self.session.location.getgeo(x, y, z) lat, lon, alt = self.session.location.getgeo(x, y, z)
pos = "pos %.6f,%.6f,%.6f" % (lon, lat, alt) pos = f"pos {lon:.6f},{lat:.6f},{alt:.6f}"
if flags & MessageFlags.ADD.value: if flags & MessageFlags.ADD.value:
if icon is not None: if icon is not None:
node_type = name node_type = name
icon = icon.replace("$CORE_DATA_DIR", constants.CORE_DATA_DIR) icon = icon.replace("$CORE_DATA_DIR", constants.CORE_DATA_DIR)
icon = icon.replace("$CORE_CONF_DIR", constants.CORE_CONF_DIR) icon = icon.replace("$CORE_CONF_DIR", constants.CORE_CONF_DIR)
self.cmd("sprite %s image %s" % (type, icon)) self.cmd(f"sprite {node_type} image {icon}")
self.cmd( self.cmd(f'node {nodenum} type {node_type} label on,"{name}" {pos}')
'node %d type %s label on,"%s" %s' % (nodenum, node_type, name, pos)
)
else: else:
self.cmd("node %d %s" % (nodenum, pos)) self.cmd(f"node {nodenum} {pos}")
def updatenodegeo(self, nodenum, lat, long, alt): def updatenodegeo(self, nodenum, lat, long, alt):
""" """
@ -298,8 +297,8 @@ class Sdt(object):
# TODO: received Node Message with lat/long/alt. # TODO: received Node Message with lat/long/alt.
if not self.connect(): if not self.connect():
return return
pos = "pos %.6f,%.6f,%.6f" % (long, lat, alt) pos = f"pos {long:.6f},{lat:.6f},{alt:.6f}"
self.cmd("node %d %s" % (nodenum, pos)) self.cmd(f"node {nodenum} {pos}")
def updatelink(self, node1num, node2num, flags, wireless=False): def updatelink(self, node1num, node2num, flags, wireless=False):
""" """
@ -316,14 +315,13 @@ class Sdt(object):
if not self.connect(): if not self.connect():
return return
if flags & MessageFlags.DELETE.value: if flags & MessageFlags.DELETE.value:
self.cmd("delete link,%s,%s" % (node1num, node2num)) self.cmd(f"delete link,{node1num},{node2num}")
elif flags & MessageFlags.ADD.value: elif flags & MessageFlags.ADD.value:
attr = ""
if wireless: if wireless:
attr = " line green,2" attr = " line green,2"
else: else:
attr = " line red,2" attr = " line red,2"
self.cmd("link %s,%s%s" % (node1num, node2num, attr)) self.cmd(f"link {node1num},{node2num}{attr}")
def sendobjs(self): def sendobjs(self):
""" """

23
daemon/core/utils.py
View file

@ -137,7 +137,7 @@ def which(command, required):
break break
if found_path is None and required: if found_path is None and required:
raise ValueError("failed to find required executable(%s) in path" % command) raise ValueError(f"failed to find required executable({command}) in path")
return found_path return found_path
@ -238,12 +238,13 @@ def hex_dump(s, bytes_per_word=2, words_per_line=8):
line = s[:total_bytes] line = s[:total_bytes]
s = s[total_bytes:] s = s[total_bytes:]
tmp = map( tmp = map(
lambda x: ("%02x" * bytes_per_word) % x, lambda x: (f"{bytes_per_word:02x}" * bytes_per_word) % x,
zip(*[iter(map(ord, line))] * bytes_per_word), zip(*[iter(map(ord, line))] * bytes_per_word),
) )
if len(line) % 2: if len(line) % 2:
tmp.append("%x" % ord(line[-1])) tmp.append(f"{ord(line[-1]):x}")
dump += "0x%08x: %s\n" % (count, " ".join(tmp)) tmp = " ".join(tmp)
dump += f"0x{count:08x}: {tmp}\n"
count += len(line) count += len(line)
return dump[:-1] return dump[:-1]
@ -261,9 +262,9 @@ def file_munge(pathname, header, text):
file_demunge(pathname, header) file_demunge(pathname, header)
with open(pathname, "a") as append_file: with open(pathname, "a") as append_file:
append_file.write("# BEGIN %s\n" % header) append_file.write(f"# BEGIN {header}\n")
append_file.write(text) append_file.write(text)
append_file.write("# END %s\n" % header) append_file.write(f"# END {header}\n")
def file_demunge(pathname, header): def file_demunge(pathname, header):
@ -281,9 +282,9 @@ def file_demunge(pathname, header):
end = None end = None
for i, line in enumerate(lines): for i, line in enumerate(lines):
if line == "# BEGIN %s\n" % header: if line == f"# BEGIN {header}\n":
start = i start = i
elif line == "# END %s\n" % header: elif line == f"# END {header}\n":
end = i + 1 end = i + 1
if start is None or end is None: if start is None or end is None:
@ -305,7 +306,7 @@ def expand_corepath(pathname, session=None, node=None):
:rtype: str :rtype: str
""" """
if session is not None: if session is not None:
pathname = pathname.replace("~", "/home/%s" % session.user) pathname = pathname.replace("~", f"/home/{session.user}")
pathname = pathname.replace("%SESSION%", str(session.id)) pathname = pathname.replace("%SESSION%", str(session.id))
pathname = pathname.replace("%SESSION_DIR%", session.session_dir) pathname = pathname.replace("%SESSION_DIR%", session.session_dir)
pathname = pathname.replace("%SESSION_USER%", session.user) pathname = pathname.replace("%SESSION_USER%", session.user)
@ -364,7 +365,7 @@ def load_classes(path, clazz):
# validate path exists # validate path exists
logging.debug("attempting to load modules from path: %s", path) logging.debug("attempting to load modules from path: %s", path)
if not os.path.isdir(path): if not os.path.isdir(path):
logging.warning("invalid custom module directory specified" ": %s" % path) logging.warning("invalid custom module directory specified" ": %s", path)
# check if path is in sys.path # check if path is in sys.path
parent_path = os.path.dirname(path) parent_path = os.path.dirname(path)
if parent_path not in sys.path: if parent_path not in sys.path:
@ -380,7 +381,7 @@ def load_classes(path, clazz):
# import and add all service modules in the path # import and add all service modules in the path
classes = [] classes = []
for module_name in module_names: for module_name in module_names:
import_statement = "%s.%s" % (base_module, module_name) import_statement = f"{base_module}.{module_name}"
logging.debug("importing custom module: %s", import_statement) logging.debug("importing custom module: %s", import_statement)
try: try:
module = importlib.import_module(import_statement) module = importlib.import_module(import_statement)

2
daemon/core/xml/corexml.py
View file

@ -600,7 +600,7 @@ class CoreXmlReader(object):
name = hook.get("name") name = hook.get("name")
state = hook.get("state") state = hook.get("state")
data = hook.text data = hook.text
hook_type = "hook:%s" % state hook_type = f"hook:{state}"
logging.info("reading hook: state(%s) name(%s)", state, name) logging.info("reading hook: state(%s) name(%s)", state, name)
self.session.set_hook( self.session.set_hook(
hook_type, file_name=name, source_name=None, data=data hook_type, file_name=name, source_name=None, data=data

23
daemon/core/xml/corexmldeployment.py
View file

@ -31,20 +31,20 @@ def add_emane_interface(host_element, netif, platform_name="p1", transport_name=
host_id = host_element.get("id") host_id = host_element.get("id")
# platform data # platform data
platform_id = "%s/%s" % (host_id, platform_name) platform_id = f"{host_id}/{platform_name}"
platform_element = etree.SubElement( platform_element = etree.SubElement(
host_element, "emanePlatform", id=platform_id, name=platform_name host_element, "emanePlatform", id=platform_id, name=platform_name
) )
# transport data # transport data
transport_id = "%s/%s" % (host_id, transport_name) transport_id = f"{host_id}/{transport_name}"
etree.SubElement( etree.SubElement(
platform_element, "transport", id=transport_id, name=transport_name platform_element, "transport", id=transport_id, name=transport_name
) )
# nem data # nem data
nem_name = "nem%s" % nem_id nem_name = f"nem{nem_id}"
nem_element_id = "%s/%s" % (host_id, nem_name) nem_element_id = f"{host_id}/{nem_name}"
nem_element = etree.SubElement( nem_element = etree.SubElement(
platform_element, "nem", id=nem_element_id, name=nem_name platform_element, "nem", id=nem_element_id, name=nem_name
) )
@ -68,7 +68,7 @@ def get_address_type(address):
def get_ipv4_addresses(hostname): def get_ipv4_addresses(hostname):
if hostname == "localhost": if hostname == "localhost":
addresses = [] addresses = []
args = "%s -o -f inet address show" % IP_BIN args = f"{IP_BIN} -o -f inet address show"
output = utils.check_cmd(args) output = utils.check_cmd(args)
for line in output.split(os.linesep): for line in output.split(os.linesep):
split = line.split() split = line.split()
@ -94,13 +94,12 @@ class CoreXmlDeployment(object):
self.add_deployment() self.add_deployment()
def find_device(self, name): def find_device(self, name):
device = self.scenario.find("devices/device[@name='%s']" % name) device = self.scenario.find(f"devices/device[@name='{name}']")
return device return device
def find_interface(self, device, name): def find_interface(self, device, name):
interface = self.scenario.find( interface = self.scenario.find(
"devices/device[@name='%s']/interfaces/interface[@name='%s']" f"devices/device[@name='{device.name}']/interfaces/interface[@name='{name}']"
% (device.name, name)
) )
return interface return interface
@ -114,7 +113,8 @@ class CoreXmlDeployment(object):
def add_physical_host(self, name): def add_physical_host(self, name):
# add host # add host
host_id = "%s/%s" % (self.root.get("id"), name) root_id = self.root.get("id")
host_id = f"{root_id}/{name}"
host_element = etree.SubElement(self.root, "testHost", id=host_id, name=name) host_element = etree.SubElement(self.root, "testHost", id=host_id, name=name)
# add type element # add type element
@ -128,10 +128,11 @@ class CoreXmlDeployment(object):
def add_virtual_host(self, physical_host, node): def add_virtual_host(self, physical_host, node):
if not isinstance(node, CoreNodeBase): if not isinstance(node, CoreNodeBase):
raise TypeError("invalid node type: %s" % node) raise TypeError(f"invalid node type: {node}")
# create virtual host element # create virtual host element
host_id = "%s/%s" % (physical_host.get("id"), node.name) phys_id = physical_host.get("id")
host_id = f"{phys_id}/{node.name}"
host_element = etree.SubElement( host_element = etree.SubElement(
physical_host, "testHost", id=host_id, name=node.name physical_host, "testHost", id=host_id, name=node.name
) )

34
daemon/core/xml/emanexml.py
View file

@ -57,8 +57,7 @@ def create_file(xml_element, doc_name, file_path, server=None):
:return: nothing :return: nothing
""" """
doctype = ( doctype = (
'<!DOCTYPE %(doc_name)s SYSTEM "file:///usr/share/emane/dtd/%(doc_name)s.dtd">' f'<!DOCTYPE {doc_name} SYSTEM "file:///usr/share/emane/dtd/{doc_name}.dtd">'
% {"doc_name": doc_name}
) )
if server is not None: if server is not None:
temp = NamedTemporaryFile(delete=False) temp = NamedTemporaryFile(delete=False)
@ -208,7 +207,7 @@ def build_node_platform_xml(emane_manager, control_net, node, nem_id, platform_x
node.setnemid(netif, nem_id) node.setnemid(netif, nem_id)
macstr = _hwaddr_prefix + ":00:00:" macstr = _hwaddr_prefix + ":00:00:"
macstr += "%02X:%02X" % ((nem_id >> 8) & 0xFF, nem_id & 0xFF) macstr += f"{(nem_id >> 8) & 0xFF:02X}:{nem_id & 0xFF:02X}"
netif.sethwaddr(MacAddress.from_string(macstr)) netif.sethwaddr(MacAddress.from_string(macstr))
# increment nem id # increment nem id
@ -222,7 +221,7 @@ def build_node_platform_xml(emane_manager, control_net, node, nem_id, platform_x
file_path = os.path.join(emane_manager.session.session_dir, file_name) file_path = os.path.join(emane_manager.session.session_dir, file_name)
create_file(platform_element, doc_name, file_path) create_file(platform_element, doc_name, file_path)
else: else:
file_name = "platform%d.xml" % key file_name = f"platform{key}.xml"
file_path = os.path.join(emane_manager.session.session_dir, file_name) file_path = os.path.join(emane_manager.session.session_dir, file_name)
linked_node = emane_manager.session.nodes[key] linked_node = emane_manager.session.nodes[key]
create_file(platform_element, doc_name, file_path, linked_node.server) create_file(platform_element, doc_name, file_path, linked_node.server)
@ -290,8 +289,8 @@ def build_transport_xml(emane_manager, node, transport_type):
""" """
transport_element = etree.Element( transport_element = etree.Element(
"transport", "transport",
name="%s Transport" % transport_type.capitalize(), name=f"{transport_type.capitalize()} Transport",
library="trans%s" % transport_type.lower(), library=f"trans{transport_type.lower()}",
) )
# add bitrate # add bitrate
@ -330,7 +329,7 @@ def create_phy_xml(emane_model, config, file_path, server):
will run on, default is None for localhost will run on, default is None for localhost
:return: nothing :return: nothing
""" """
phy_element = etree.Element("phy", name="%s PHY" % emane_model.name) phy_element = etree.Element("phy", name=f"{emane_model.name} PHY")
if emane_model.phy_library: if emane_model.phy_library:
phy_element.set("library", emane_model.phy_library) phy_element.set("library", emane_model.phy_library)
@ -362,7 +361,7 @@ def create_mac_xml(emane_model, config, file_path, server):
raise ValueError("must define emane model library") raise ValueError("must define emane model library")
mac_element = etree.Element( mac_element = etree.Element(
"mac", name="%s MAC" % emane_model.name, library=emane_model.mac_library "mac", name=f"{emane_model.name} MAC", library=emane_model.mac_library
) )
add_configurations( add_configurations(
mac_element, emane_model.mac_config, config, emane_model.config_ignore mac_element, emane_model.mac_config, config, emane_model.config_ignore
@ -399,7 +398,7 @@ def create_nem_xml(
will run on, default is None for localhost will run on, default is None for localhost
:return: nothing :return: nothing
""" """
nem_element = etree.Element("nem", name="%s NEM" % emane_model.name) nem_element = etree.Element("nem", name=f"{emane_model.name} NEM")
if is_external(config): if is_external(config):
nem_element.set("type", "unstructured") nem_element.set("type", "unstructured")
else: else:
@ -450,7 +449,7 @@ def transport_file_name(node_id, transport_type):
:param str transport_type: transport type to generate transport file :param str transport_type: transport type to generate transport file
:return: :return:
""" """
return "n%strans%s.xml" % (node_id, transport_type) return f"n{node_id}trans{transport_type}.xml"
def _basename(emane_model, interface=None): def _basename(emane_model, interface=None):
@ -461,14 +460,14 @@ def _basename(emane_model, interface=None):
:return: basename used for file creation :return: basename used for file creation
:rtype: str :rtype: str
""" """
name = "n%s" % emane_model.id name = f"n{emane_model.id}"
if interface: if interface:
node_id = interface.node.id node_id = interface.node.id
if emane_model.session.emane.getifcconfig(node_id, interface, emane_model.name): if emane_model.session.emane.getifcconfig(node_id, interface, emane_model.name):
name = interface.localname.replace(".", "_") name = interface.localname.replace(".", "_")
return "%s%s" % (name, emane_model.name) return f"{name}{emane_model.name}"
def nem_file_name(emane_model, interface=None): def nem_file_name(emane_model, interface=None):
@ -484,7 +483,7 @@ def nem_file_name(emane_model, interface=None):
append = "" append = ""
if interface and interface.transport_type == "raw": if interface and interface.transport_type == "raw":
append = "_raw" append = "_raw"
return "%snem%s.xml" % (basename, append) return f"{basename}nem{append}.xml"
def shim_file_name(emane_model, interface=None): def shim_file_name(emane_model, interface=None):
@ -496,7 +495,8 @@ def shim_file_name(emane_model, interface=None):
:return: shim xml filename :return: shim xml filename
:rtype: str :rtype: str
""" """
return "%sshim.xml" % _basename(emane_model, interface) name = _basename(emane_model, interface)
return f"{name}shim.xml"
def mac_file_name(emane_model, interface=None): def mac_file_name(emane_model, interface=None):
@ -508,7 +508,8 @@ def mac_file_name(emane_model, interface=None):
:return: mac xml filename :return: mac xml filename
:rtype: str :rtype: str
""" """
return "%smac.xml" % _basename(emane_model, interface) name = _basename(emane_model, interface)
return f"{name}mac.xml"
def phy_file_name(emane_model, interface=None): def phy_file_name(emane_model, interface=None):
@ -520,4 +521,5 @@ def phy_file_name(emane_model, interface=None):
:return: phy xml filename :return: phy xml filename
:rtype: str :rtype: str
""" """
return "%sphy.xml" % _basename(emane_model, interface) name = _basename(emane_model, interface)
return f"{name}phy.xml"

7
daemon/examples/python/emane80211.py
View file

@ -48,12 +48,11 @@ def main():
logging.basicConfig(level=logging.INFO) logging.basicConfig(level=logging.INFO)
options = parser.parse_options("emane80211") options = parser.parse_options("emane80211")
start = datetime.datetime.now() start = datetime.datetime.now()
print( logging.info(
"running emane 80211 example: nodes(%s) time(%s)" "running emane 80211 example: nodes(%s) time(%s)", options.nodes, options.time
% (options.nodes, options.time)
) )
example(options) example(options)
print("elapsed time: %s" % (datetime.datetime.now() - start)) logging.info("elapsed time: %s", datetime.datetime.now() - start)
if __name__ == "__main__" or __name__ == "__builtin__": if __name__ == "__main__" or __name__ == "__builtin__":

6
daemon/examples/python/parser.py
View file

@ -6,7 +6,7 @@ DEFAULT_STEP = 1
def parse_options(name): def parse_options(name):
parser = argparse.ArgumentParser(description="Run %s example" % name) parser = argparse.ArgumentParser(description=f"Run {name} example")
parser.add_argument( parser.add_argument(
"-n", "-n",
"--nodes", "--nodes",
@ -25,8 +25,8 @@ def parse_options(name):
options = parser.parse_args() options = parser.parse_args()
if options.nodes < 2: if options.nodes < 2:
parser.error("invalid min number of nodes: %s" % options.nodes) parser.error(f"invalid min number of nodes: {options.nodes}")
if options.time < 1: if options.time < 1:
parser.error("invalid test time: %s" % options.time) parser.error(f"invalid test time: {options.time}")
return options return options

16
daemon/examples/python/switch.py
View file

@ -41,14 +41,12 @@ def example(options):
first_node = session.get_node(2) first_node = session.get_node(2)
last_node = session.get_node(options.nodes + 1) last_node = session.get_node(options.nodes + 1)
print("starting iperf server on node: %s" % first_node.name) logging.info("starting iperf server on node: %s", first_node.name)
first_node.node_net_cmd("iperf -s -D") first_node.node_net_cmd("iperf -s -D")
first_node_address = prefixes.ip4_address(first_node) first_node_address = prefixes.ip4_address(first_node)
print("node %s connecting to %s" % (last_node.name, first_node_address)) logging.info("node %s connecting to %s", last_node.name, first_node_address)
output = last_node.node_net_cmd( output = last_node.node_net_cmd(f"iperf -t {options.time} -c {first_node_address}")
"iperf -t %s -c %s" % (options.time, first_node_address) logging.info(output)
)
print(output)
first_node.node_net_cmd("killall -9 iperf") first_node.node_net_cmd("killall -9 iperf")
# shutdown session # shutdown session
@ -59,9 +57,11 @@ def main():
logging.basicConfig(level=logging.INFO) logging.basicConfig(level=logging.INFO)
options = parser.parse_options("switch") options = parser.parse_options("switch")
start = datetime.datetime.now() start = datetime.datetime.now()
print("running switch example: nodes(%s) time(%s)" % (options.nodes, options.time)) logging.info(
"running switch example: nodes(%s) time(%s)", options.nodes, options.time
)
example(options) example(options)
print("elapsed time: %s" % (datetime.datetime.now() - start)) logging.info("elapsed time: %s", datetime.datetime.now() - start)
if __name__ == "__main__": if __name__ == "__main__":

12
daemon/examples/python/wlan.py
View file

@ -45,11 +45,11 @@ def example(options):
first_node = session.get_node(2) first_node = session.get_node(2)
last_node = session.get_node(options.nodes + 1) last_node = session.get_node(options.nodes + 1)
print("starting iperf server on node: %s" % first_node.name) logging.info("starting iperf server on node: %s", first_node.name)
first_node.node_net_cmd("iperf -s -D") first_node.node_net_cmd("iperf -s -D")
address = prefixes.ip4_address(first_node) address = prefixes.ip4_address(first_node)
print("node %s connecting to %s" % (last_node.name, address)) logging.info("node %s connecting to %s", last_node.name, address)
last_node.node_net_cmd("iperf -t %s -c %s" % (options.time, address)) last_node.node_net_cmd(f"iperf -t {options.time} -c {address}")
first_node.node_net_cmd("killall -9 iperf") first_node.node_net_cmd("killall -9 iperf")
# shutdown session # shutdown session
@ -61,9 +61,11 @@ def main():
options = parser.parse_options("wlan") options = parser.parse_options("wlan")
start = datetime.datetime.now() start = datetime.datetime.now()
print("running wlan example: nodes(%s) time(%s)" % (options.nodes, options.time)) logging.info(
"running wlan example: nodes(%s) time(%s)", options.nodes, options.time
)
example(options) example(options)
print("elapsed time: %s" % (datetime.datetime.now() - start)) logging.info("elapsed time: %s", datetime.datetime.now() - start)
if __name__ == "__main__": if __name__ == "__main__":

38
daemon/scripts/core-daemon
View file

@ -17,7 +17,9 @@ from core import constants
from core.api.grpc.server import CoreGrpcServer from core.api.grpc.server import CoreGrpcServer
from core.api.tlv.corehandlers import CoreHandler, CoreUdpHandler from core.api.tlv.corehandlers import CoreHandler, CoreUdpHandler
from core.api.tlv.coreserver import CoreServer, CoreUdpServer from core.api.tlv.coreserver import CoreServer, CoreUdpServer
from core.constants import CORE_CONF_DIR, COREDPY_VERSION
from core.emulator import enumerations from core.emulator import enumerations
from core.emulator.enumerations import CORE_API_PORT
from core.utils import close_onexec, load_logging_config from core.utils import close_onexec, load_logging_config
@ -67,7 +69,9 @@ def cored(cfg):
# initialize grpc api # initialize grpc api
if cfg["grpc"] == "True": if cfg["grpc"] == "True":
grpc_server = CoreGrpcServer(server.coreemu) grpc_server = CoreGrpcServer(server.coreemu)
grpc_address = "%s:%s" % (cfg["grpcaddress"], cfg["grpcport"]) address_config = cfg["grpcaddress"]
port_config = cfg["grpcport"]
grpc_address = f"{address_config}:{port_config}"
grpc_thread = threading.Thread(target=grpc_server.listen, args=(grpc_address,)) grpc_thread = threading.Thread(target=grpc_server.listen, args=(grpc_address,))
grpc_thread.daemon = True grpc_thread.daemon = True
grpc_thread.start() grpc_thread.start()
@ -91,30 +95,34 @@ def get_merged_config(filename):
:rtype: dict :rtype: dict
""" """
# these are the defaults used in the config file # these are the defaults used in the config file
default_log = os.path.join(constants.CORE_CONF_DIR, "logging.conf")
default_grpc_port = "50051"
default_threads = "1"
default_address = "localhost"
defaults = { defaults = {
"port": "%d" % enumerations.CORE_API_PORT, "port": str(CORE_API_PORT),
"listenaddr": "localhost", "listenaddr": default_address,
"numthreads": "1", "numthreads": default_threads,
"grpcport": "50051", "grpcport": default_grpc_port,
"grpcaddress": "localhost", "grpcaddress": default_address,
"logfile": os.path.join(constants.CORE_CONF_DIR, "logging.conf") "logfile": default_log
} }
parser = argparse.ArgumentParser( parser = argparse.ArgumentParser(
description="CORE daemon v.%s instantiates Linux network namespace nodes." % constants.COREDPY_VERSION) description=f"CORE daemon v.{COREDPY_VERSION} instantiates Linux network namespace nodes.")
parser.add_argument("-f", "--configfile", dest="configfile", parser.add_argument("-f", "--configfile", dest="configfile",
help="read config from specified file; default = %s" % filename) help=f"read config from specified file; default = {filename}")
parser.add_argument("-p", "--port", dest="port", type=int, parser.add_argument("-p", "--port", dest="port", type=int,
help="port number to listen on; default = %s" % defaults["port"]) help=f"port number to listen on; default = {CORE_API_PORT}")
parser.add_argument("-n", "--numthreads", dest="numthreads", type=int, parser.add_argument("-n", "--numthreads", dest="numthreads", type=int,
help="number of server threads; default = %s" % defaults["numthreads"]) help=f"number of server threads; default = {default_threads}")
parser.add_argument("--ovs", action="store_true", help="enable experimental ovs mode, default is false") parser.add_argument("--ovs", action="store_true", help="enable experimental ovs mode, default is false")
parser.add_argument("--grpc", action="store_true", help="enable grpc api, default is false") parser.add_argument("--grpc", action="store_true", help="enable grpc api, default is false")
parser.add_argument("--grpc-port", dest="grpcport", parser.add_argument("--grpc-port", dest="grpcport",
help="grpc port to listen on; default %s" % defaults["grpcport"]) help=f"grpc port to listen on; default {default_grpc_port}")
parser.add_argument("--grpc-address", dest="grpcaddress", parser.add_argument("--grpc-address", dest="grpcaddress",
help="grpc address to listen on; default %s" % defaults["grpcaddress"]) help=f"grpc address to listen on; default {default_address}")
parser.add_argument("-l", "--logfile", help="core logging configuration; default %s" % defaults["logfile"]) parser.add_argument("-l", "--logfile", help=f"core logging configuration; default {default_log}")
# parse command line options # parse command line options
args = parser.parse_args() args = parser.parse_args()
@ -146,7 +154,7 @@ def main():
:return: nothing :return: nothing
""" """
# get a configuration merged from config file and command-line arguments # get a configuration merged from config file and command-line arguments
cfg = get_merged_config("%s/core.conf" % constants.CORE_CONF_DIR) cfg = get_merged_config(f"{CORE_CONF_DIR}/core.conf")
# load logging configuration # load logging configuration
load_logging_config(cfg["logfile"]) load_logging_config(cfg["logfile"])

29
daemon/scripts/core-manage
View file

@ -38,7 +38,7 @@ class FileUpdater(object):
txt = "Updating" txt = "Updating"
if self.action == "check": if self.action == "check":
txt = "Checking" txt = "Checking"
sys.stdout.write("%s file: %s\n" % (txt, self.filename)) sys.stdout.write(f"{txt} file: {self.filename}\n")
if self.target == "service": if self.target == "service":
r = self.update_file(fn=self.update_services) r = self.update_file(fn=self.update_services)
@ -52,9 +52,9 @@ class FileUpdater(object):
if not r: if not r:
txt = "NOT " txt = "NOT "
if self.action == "check": if self.action == "check":
sys.stdout.write("String %sfound.\n" % txt) sys.stdout.write(f"String {txt} found.\n")
else: else:
sys.stdout.write("File %supdated.\n" % txt) sys.stdout.write(f"File {txt} updated.\n")
return r return r
@ -70,7 +70,7 @@ class FileUpdater(object):
r = self.update_keyvals(key, vals) r = self.update_keyvals(key, vals)
if self.action == "check": if self.action == "check":
return r return r
valstr = "%s" % r valstr = str(r)
return "= ".join([key, valstr]) + "\n" return "= ".join([key, valstr]) + "\n"
def update_emane_models(self, line): def update_emane_models(self, line):
@ -125,7 +125,7 @@ class FileUpdater(object):
else: else:
raise ValueError("unknown target") raise ValueError("unknown target")
if not os.path.exists(filename): if not os.path.exists(filename):
raise ValueError("file %s does not exist" % filename) raise ValueError(f"file {filename} does not exist")
return search, filename return search, filename
def update_file(self, fn=None): def update_file(self, fn=None):
@ -187,18 +187,17 @@ class FileUpdater(object):
def main(): def main():
actions = ", ".join(FileUpdater.actions)
targets = ", ".join(FileUpdater.targets)
usagestr = "usage: %prog [-h] [options] <action> <target> <string>\n" usagestr = "usage: %prog [-h] [options] <action> <target> <string>\n"
usagestr += "\nHelper tool to add, remove, or check for " usagestr += "\nHelper tool to add, remove, or check for "
usagestr += "services, models, and node types\nin a CORE installation.\n" usagestr += "services, models, and node types\nin a CORE installation.\n"
usagestr += "\nExamples:\n %prog add service newrouting" usagestr += "\nExamples:\n %prog add service newrouting"
usagestr += "\n %prog -v check model RfPipe" usagestr += "\n %prog -v check model RfPipe"
usagestr += "\n %prog --userpath=\"$HOME/.core\" add nodetype \"{ftp ftp.gif ftp.gif {DefaultRoute FTP} netns {FTP server} }\" \n" usagestr += "\n %prog --userpath=\"$HOME/.core\" add nodetype \"{ftp ftp.gif ftp.gif {DefaultRoute FTP} netns {FTP server} }\" \n"
usagestr += "\nArguments:\n <action> should be one of: %s" % \ usagestr += f"\nArguments:\n <action> should be one of: {actions}"
", ".join(FileUpdater.actions) usagestr += f"\n <target> should be one of: {targets}"
usagestr += "\n <target> should be one of: %s" % \ usagestr += f"\n <string> is the text to {actions}"
", ".join(FileUpdater.targets)
usagestr += "\n <string> is the text to %s" % \
", ".join(FileUpdater.actions)
parser = optparse.OptionParser(usage=usagestr) parser = optparse.OptionParser(usage=usagestr)
parser.set_defaults(userpath=None, verbose=False, ) parser.set_defaults(userpath=None, verbose=False, )
@ -222,14 +221,14 @@ def main():
action = args[0] action = args[0]
if action not in FileUpdater.actions: if action not in FileUpdater.actions:
usage("invalid action %s" % action, 1) usage(f"invalid action {action}", 1)
target = args[1] target = args[1]
if target not in FileUpdater.targets: if target not in FileUpdater.targets:
usage("invalid target %s" % target, 1) usage(f"invalid target {target}", 1)
if target == "nodetype" and not options.userpath: if target == "nodetype" and not options.userpath:
usage("user path option required for this target (%s)" % target) usage(f"user path option required for this target ({target})")
data = args[2] data = args[2]
@ -237,7 +236,7 @@ def main():
up = FileUpdater(action, target, data, options) up = FileUpdater(action, target, data, options)
r = up.process() r = up.process()
except Exception as e: except Exception as e:
sys.stderr.write("Exception: %s\n" % e) sys.stderr.write(f"Exception: {e}\n")
sys.exit(1) sys.exit(1)
if not r: if not r:
sys.exit(1) sys.exit(1)

54
daemon/scripts/coresendmsg
View file

@ -21,9 +21,9 @@ def print_available_tlvs(t, tlv_class):
""" """
Print a TLV list. Print a TLV list.
""" """
print("TLVs available for %s message:" % t) print(f"TLVs available for {t} message:")
for tlv in sorted([tlv for tlv in tlv_class.tlv_type_map], key=lambda x: x.name): for tlv in sorted([tlv for tlv in tlv_class.tlv_type_map], key=lambda x: x.name):
print("%s:%s" % (tlv.value, tlv.name)) print(f"{tlv.value}:{tlv.name}")
def print_examples(name): def print_examples(name):
@ -54,9 +54,9 @@ def print_examples(name):
"srcname=\"./test.log\"", "srcname=\"./test.log\"",
"move a test.log file from host to node 2"), "move a test.log file from host to node 2"),
] ]
print("Example %s invocations:" % name) print(f"Example {name} invocations:")
for cmd, descr in examples: for cmd, descr in examples:
print(" %s %s\n\t\t%s" % (name, cmd, descr)) print(f" {name} {cmd}\n\t\t{descr}")
def receive_message(sock): def receive_message(sock):
@ -86,11 +86,11 @@ def receive_message(sock):
except KeyError: except KeyError:
msg = coreapi.CoreMessage(msgflags, msghdr, msgdata) msg = coreapi.CoreMessage(msgflags, msghdr, msgdata)
msg.message_type = msgtype msg.message_type = msgtype
print("unimplemented CORE message type: %s" % msg.type_str()) print(f"unimplemented CORE message type: {msg.type_str()}")
return msg return msg
if len(data) > msglen + coreapi.CoreMessage.header_len: if len(data) > msglen + coreapi.CoreMessage.header_len:
print("received a message of type %d, dropping %d bytes of extra data" \ data_size = len(data) - (msglen + coreapi.CoreMessage.header_len)
% (msgtype, len(data) - (msglen + coreapi.CoreMessage.header_len))) print(f"received a message of type {msgtype}, dropping {data_size} bytes of extra data")
return msgcls(msgflags, msghdr, msgdata) return msgcls(msgflags, msghdr, msgdata)
@ -132,7 +132,7 @@ def connect_to_session(sock, requested):
print("requested session not found!") print("requested session not found!")
return False return False
print("joining session: %s" % session) print(f"joining session: {session}")
tlvdata = coreapi.CoreSessionTlv.pack(SessionTlvs.NUMBER.value, session) tlvdata = coreapi.CoreSessionTlv.pack(SessionTlvs.NUMBER.value, session)
flags = MessageFlags.ADD.value flags = MessageFlags.ADD.value
smsg = coreapi.CoreSessionMessage.pack(flags, tlvdata) smsg = coreapi.CoreSessionMessage.pack(flags, tlvdata)
@ -147,9 +147,9 @@ def receive_response(sock, opt):
print("waiting for response...") print("waiting for response...")
msg = receive_message(sock) msg = receive_message(sock)
if msg is None: if msg is None:
print("disconnected from %s:%s" % (opt.address, opt.port)) print(f"disconnected from {opt.address}:{opt.port}")
sys.exit(0) sys.exit(0)
print("received message: %s" % msg) print(f"received message: {msg}")
def main(): def main():
@ -160,36 +160,36 @@ def main():
flags = [flag.name for flag in MessageFlags] flags = [flag.name for flag in MessageFlags]
usagestr = "usage: %prog [-h|-H] [options] [message-type] [flags=flags] " usagestr = "usage: %prog [-h|-H] [options] [message-type] [flags=flags] "
usagestr += "[message-TLVs]\n\n" usagestr += "[message-TLVs]\n\n"
usagestr += "Supported message types:\n %s\n" % types usagestr += f"Supported message types:\n {types}\n"
usagestr += "Supported message flags (flags=f1,f2,...):\n %s" % flags usagestr += f"Supported message flags (flags=f1,f2,...):\n {flags}"
parser = optparse.OptionParser(usage=usagestr) parser = optparse.OptionParser(usage=usagestr)
default_address = "localhost"
default_session = None
default_tcp = False
parser.set_defaults( parser.set_defaults(
port=CORE_API_PORT, port=CORE_API_PORT,
address="localhost", address=default_address,
session=None, session=default_session,
listen=False, listen=False,
examples=False, examples=False,
tlvs=False, tlvs=False,
tcp=False tcp=default_tcp
) )
parser.add_option("-H", dest="examples", action="store_true", parser.add_option("-H", dest="examples", action="store_true",
help="show example usage help message and exit") help="show example usage help message and exit")
parser.add_option("-p", "--port", dest="port", type=int, parser.add_option("-p", "--port", dest="port", type=int,
help="TCP port to connect to, default: %d" % \ help=f"TCP port to connect to, default: {CORE_API_PORT}")
parser.defaults["port"])
parser.add_option("-a", "--address", dest="address", type=str, parser.add_option("-a", "--address", dest="address", type=str,
help="Address to connect to, default: %s" % \ help=f"Address to connect to, default: {default_address}")
parser.defaults["address"])
parser.add_option("-s", "--session", dest="session", type=str, parser.add_option("-s", "--session", dest="session", type=str,
help="Session to join, default: %s" % \ help=f"Session to join, default: {default_session}")
parser.defaults["session"])
parser.add_option("-l", "--listen", dest="listen", action="store_true", parser.add_option("-l", "--listen", dest="listen", action="store_true",
help="Listen for a response message and print it.") help="Listen for a response message and print it.")
parser.add_option("-t", "--list-tlvs", dest="tlvs", action="store_true", parser.add_option("-t", "--list-tlvs", dest="tlvs", action="store_true",
help="List TLVs for the specified message type.") help="List TLVs for the specified message type.")
parser.add_option("--tcp", dest="tcp", action="store_true", parser.add_option("--tcp", dest="tcp", action="store_true",
help="Use TCP instead of UDP and connect to a session default: %s" % parser.defaults["tcp"]) help=f"Use TCP instead of UDP and connect to a session default: {default_tcp}")
def usage(msg=None, err=0): def usage(msg=None, err=0):
sys.stdout.write("\n") sys.stdout.write("\n")
@ -209,7 +209,7 @@ def main():
# given a message type t, determine the message and TLV classes # given a message type t, determine the message and TLV classes
t = args.pop(0) t = args.pop(0)
if t not in types: if t not in types:
usage("Unknown message type requested: %s" % t) usage(f"Unknown message type requested: {t}")
message_type = MessageTypes[t] message_type = MessageTypes[t]
msg_cls = coreapi.CLASS_MAP[message_type.value] msg_cls = coreapi.CLASS_MAP[message_type.value]
tlv_cls = msg_cls.tlv_class tlv_cls = msg_cls.tlv_class
@ -225,7 +225,7 @@ def main():
for a in args: for a in args:
typevalue = a.split("=") typevalue = a.split("=")
if len(typevalue) < 2: if len(typevalue) < 2:
usage("Use \"type=value\" syntax instead of \"%s\"." % a) usage(f"Use \"type=value\" syntax instead of \"{a}\".")
tlv_typestr = typevalue[0] tlv_typestr = typevalue[0]
tlv_valstr = "=".join(typevalue[1:]) tlv_valstr = "=".join(typevalue[1:])
if tlv_typestr == "flags": if tlv_typestr == "flags":
@ -237,7 +237,7 @@ def main():
tlv_type = tlv_cls.tlv_type_map[tlv_name] tlv_type = tlv_cls.tlv_type_map[tlv_name]
tlvdata += tlv_cls.pack_string(tlv_type.value, tlv_valstr) tlvdata += tlv_cls.pack_string(tlv_type.value, tlv_valstr)
except KeyError: except KeyError:
usage("Unknown TLV: \"%s\"" % tlv_name) usage(f"Unknown TLV: \"{tlv_name}\"")
flags = 0 flags = 0
for f in flagstr.split(","): for f in flagstr.split(","):
@ -249,7 +249,7 @@ def main():
n = flag_enum.value n = flag_enum.value
flags |= n flags |= n
except KeyError: except KeyError:
usage("Invalid flag \"%s\"." % f) usage(f"Invalid flag \"{f}\".")
msg = msg_cls.pack(flags, tlvdata) msg = msg_cls.pack(flags, tlvdata)
@ -264,7 +264,7 @@ def main():
try: try:
sock.connect((opt.address, opt.port)) sock.connect((opt.address, opt.port))
except Exception as e: except Exception as e:
print("Error connecting to %s:%s:\n\t%s" % (opt.address, opt.port, e)) print(f"Error connecting to {opt.address}:{opt.port}:\n\t{e}")
sys.exit(1) sys.exit(1)
if opt.tcp and not connect_to_session(sock, opt.session): if opt.tcp and not connect_to_session(sock, opt.session):