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
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 = []
for config_group in config_groups:
group_string = "%s:%s-%s" % (
config_group.name,
config_group.start,
config_group.stop,
group_string = (
f"{config_group.name}:{config_group.start}-{config_group.stop}"
)
group_strings.append(group_string)
return "|".join(group_strings)
@ -74,7 +72,7 @@ class ConfigShim(object):
if not captions:
captions = configuration.label
else:
captions += "|%s" % configuration.label
captions += f"|{configuration.label}"
data_types.append(configuration.type.value)
@ -83,11 +81,11 @@ class ConfigShim(object):
_id = configuration.id
config_value = config.get(_id, configuration.default)
key_value = "%s=%s" % (_id, config_value)
key_value = f"{_id}={config_value}"
if not key_values:
key_values = key_value
else:
key_values += "|%s" % key_value
key_values += f"|{key_value}"
groups_str = cls.groups_to_str(configurable_options.config_groups())
return ConfigData(
@ -130,13 +128,7 @@ class Configuration(object):
self.label = label
def __str__(self):
return "%s(id=%s, type=%s, default=%s, options=%s)" % (
self.__class__.__name__,
self.id,
self.type,
self.default,
self.options,
)
return f"{self.__class__.__name__}(id={self.id}, type={self.type}, default={self.default}, options={self.options})"
class ConfigurableManager(object):
@ -333,7 +325,7 @@ class ModelManager(ConfigurableManager):
# get model class to configure
model_class = self.models.get(model_name)
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
model_config = self.get_model_config(node_id, model_name)
@ -361,7 +353,7 @@ class ModelManager(ConfigurableManager):
# get model class to configure
model_class = self.models.get(model_name)
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)
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)
# create and write nem document
nem_element = etree.Element(
"nem", name="%s NEM" % self.name, type="unstructured"
)
nem_element = etree.Element("nem", name=f"{self.name} NEM", type="unstructured")
transport_type = "virtual"
if interface and interface.transport_type == "raw":
transport_type = "raw"
@ -90,7 +88,7 @@ class EmaneCommEffectModel(emanemodel.EmaneModel):
# create and write shim document
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

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

@ -227,7 +227,7 @@ class EmaneManager(ModelManager):
with self._emane_node_lock:
if emane_net.id in self._emane_nets:
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
@ -342,7 +342,7 @@ class EmaneManager(ModelManager):
try:
with open(emane_nems_filename, "w") as f:
for nodename, ifname, nemid in nems:
f.write("%s %s %s\n" % (nodename, ifname, nemid))
f.write(f"{nodename} {ifname} {nemid}\n")
except IOError:
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)
loglevel = str(cfgloglevel)
emanecmd = "emane -d -l %s" % loglevel
emanecmd = f"emane -d -l {loglevel}"
if realtime:
emanecmd += " -r"
@ -580,11 +580,9 @@ class EmaneManager(ModelManager):
node.node_net_client.create_route(eventgroup, eventdev)
# start emane
args = "%s -f %s %s" % (
emanecmd,
os.path.join(path, "emane%d.log" % n),
os.path.join(path, "platform%d.xml" % n),
)
log_file = os.path.join(path, f"emane{n}.log")
platform_xml = os.path.join(path, f"platform{n}.xml")
args = f"{emanecmd} -f {log_file} {platform_xml}"
output = node.node_net_cmd(args)
logging.info("node(%s) emane daemon running: %s", node.name, args)
logging.info("node(%s) emane daemon output: %s", node.name, output)
@ -593,8 +591,9 @@ class EmaneManager(ModelManager):
return
path = self.session.session_dir
emanecmd += " -f %s" % os.path.join(path, "emane.log")
emanecmd += " %s" % os.path.join(path, "platform.xml")
log_file = os.path.join(path, "emane.log")
platform_xml = os.path.join(path, "platform.xml")
emanecmd += f" -f {log_file} {platform_xml}"
utils.check_cmd(emanecmd, cwd=path)
self.session.distributed.execute(lambda x: x.remote_cmd(emanecmd, cwd=path))
logging.info("host emane daemon running: %s", emanecmd)
@ -797,7 +796,7 @@ class EmaneManager(ModelManager):
node = self.session.get_node(n)
except CoreError:
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

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

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

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

@ -210,7 +210,7 @@ class EmaneNet(CoreNetworkBase):
nemid = self.getnemid(netif)
ifname = netif.localname
if nemid is None:
logging.info("nemid for %s is unknown" % ifname)
logging.info("nemid for %s is unknown", ifname)
continue
x, y, z = netif.node.getposition()
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(
"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)

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

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

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

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

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

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

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

@ -165,15 +165,16 @@ class MobilityManager(ModelManager):
elif model.state == model.STATE_PAUSED:
event_type = EventTypes.PAUSE.value
data = "start=%d" % int(model.lasttime - model.timezero)
data += " end=%d" % int(model.endtime)
start_time = int(model.lasttime - model.timezero)
end_time = int(model.endtime)
data = f"start={start_time} end={end_time}"
event_data = EventData(
node=model.id,
event_type=event_type,
name="mobility:%s" % model.name,
name=f"mobility:{model.name}",
data=data,
time="%s" % time.time(),
time=str(time.time()),
)
self.session.broadcast_event(event_data)
@ -991,7 +992,7 @@ class Ns2ScriptedMobility(WayPointMobility):
"ns-2 scripted mobility failed to load file: %s", self.file
)
return
logging.info("reading ns-2 script file: %s" % filename)
logging.info("reading ns-2 script file: %s", filename)
ln = 0
ix = iy = iz = None
inodenum = None
@ -1112,7 +1113,7 @@ class Ns2ScriptedMobility(WayPointMobility):
:return: nothing
"""
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
try:
t = float(self.autostart)
@ -1124,9 +1125,7 @@ class Ns2ScriptedMobility(WayPointMobility):
)
return
self.movenodesinitial()
logging.info(
"scheduling ns-2 script for %s autostart at %s" % (self.wlan.name, t)
)
logging.info("scheduling ns-2 script for %s autostart at %s", self.wlan.name, t)
self.state = self.STATE_RUNNING
self.session.event_loop.add_event(t, self.run)
@ -1187,7 +1186,7 @@ class Ns2ScriptedMobility(WayPointMobility):
if filename is None or filename == "":
return
filename = self.findfile(filename)
args = "/bin/sh %s %s" % (filename, typestr)
args = f"/bin/sh {filename} {typestr}"
utils.check_cmd(
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()
self.id = _id
if name is None:
name = "o%s" % self.id
name = f"o{self.id}"
self.name = name
self.server = server
@ -265,7 +265,7 @@ class CoreNodeBase(NodeBase):
"""
if self.nodedir is None:
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
else:
self.tmpnodedir = False
@ -281,7 +281,7 @@ class CoreNodeBase(NodeBase):
return
if self.tmpnodedir:
self.net_cmd("rm -rf %s" % self.nodedir)
self.net_cmd(f"rm -rf {self.nodedir}")
def addnetif(self, netif, ifindex):
"""
@ -292,7 +292,7 @@ class CoreNodeBase(NodeBase):
:return: nothing
"""
if ifindex in self._netif:
raise ValueError("ifindex %s already exists" % ifindex)
raise ValueError(f"ifindex {ifindex} already exists")
self._netif[ifindex] = netif
# TODO: this should have probably been set ahead, seems bad to me, check for failure and fix
netif.netindex = ifindex
@ -305,7 +305,7 @@ class CoreNodeBase(NodeBase):
:return: nothing
"""
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.shutdown()
del netif
@ -334,7 +334,7 @@ class CoreNodeBase(NodeBase):
:return: nothing
"""
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)
def detachnet(self, ifindex):
@ -345,7 +345,7 @@ class CoreNodeBase(NodeBase):
:return: nothing
"""
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()
def setposition(self, x=None, y=None, z=None):
@ -472,7 +472,7 @@ class CoreNode(CoreNodeBase):
:rtype: bool
"""
try:
self.net_cmd("kill -0 %s" % self.pid)
self.net_cmd(f"kill -0 {self.pid}")
except CoreCommandError:
return False
@ -496,10 +496,11 @@ class CoreNode(CoreNodeBase):
cmd=VNODED_BIN, name=self.ctrlchnlname
)
if self.nodedir:
vnoded += " -C %s" % self.nodedir
vnoded += f" -C {self.nodedir}"
env = self.session.get_environment(state=False)
env["NODE_NUMBER"] = str(self.id)
env["NODE_NAME"] = str(self.name)
logging.info("env: %s", env)
output = self.net_cmd(vnoded, env=env)
self.pid = int(output)
@ -545,13 +546,13 @@ class CoreNode(CoreNodeBase):
# kill node process if present
try:
self.net_cmd("kill -9 %s" % self.pid)
self.net_cmd(f"kill -9 {self.pid}")
except CoreCommandError:
logging.exception("error killing process")
# remove node directory if present
try:
self.net_cmd("rm -rf %s" % self.ctrlchnlname)
self.net_cmd(f"rm -rf {self.ctrlchnlname}")
except CoreCommandError:
logging.exception("error removing node directory")
@ -604,11 +605,11 @@ class CoreNode(CoreNodeBase):
:return: nothing
"""
if path[0] != "/":
raise ValueError("path not fully qualified: %s" % path)
raise ValueError(f"path not fully qualified: {path}")
hostpath = os.path.join(
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)
def mount(self, source, target):
@ -622,8 +623,8 @@ class CoreNode(CoreNodeBase):
"""
source = os.path.abspath(source)
logging.debug("node(%s) mounting: %s at %s", self.name, source, target)
self.node_net_cmd("mkdir -p %s" % target)
self.node_net_cmd("%s -n --bind %s %s" % (MOUNT_BIN, source, target))
self.node_net_cmd(f"mkdir -p {target}")
self.node_net_cmd(f"{MOUNT_BIN} -n --bind {source} {target}")
self._mounts.append((source, target))
def newifindex(self):
@ -650,22 +651,22 @@ class CoreNode(CoreNodeBase):
ifindex = self.newifindex()
if ifname is None:
ifname = "eth%d" % ifindex
ifname = f"eth{ifindex}"
sessionid = self.session.short_session_id()
try:
suffix = "%x.%s.%s" % (self.id, ifindex, sessionid)
suffix = f"{self.id:x}.{ifindex}.{sessionid}"
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:
raise ValueError("interface local name (%s) too long" % localname)
raise ValueError(f"interface local name ({localname}) too long")
name = localname + "p"
if len(name) >= 16:
raise ValueError("interface name (%s) too long" % name)
raise ValueError(f"interface name ({name}) too long")
veth = Veth(
self.session, self, name, localname, start=self.up, server=self.server
@ -716,10 +717,10 @@ class CoreNode(CoreNodeBase):
ifindex = self.newifindex()
if ifname is None:
ifname = "eth%d" % ifindex
ifname = f"eth{ifindex}"
sessionid = self.session.short_session_id()
localname = "tap%s.%s.%s" % (self.id, ifindex, sessionid)
localname = f"tap{self.id}.{ifindex}.{sessionid}"
name = ifname
tuntap = TunTap(self.session, self, name, localname, start=self.up)
@ -778,7 +779,7 @@ class CoreNode(CoreNodeBase):
try:
interface.deladdr(addr)
except ValueError:
logging.exception("trying to delete unknown address: %s" % addr)
logging.exception("trying to delete unknown address: %s", addr)
if self.up:
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)
directory = os.path.dirname(filename)
if self.server is None:
self.client.check_cmd("mkdir -p %s" % directory)
self.client.check_cmd("mv %s %s" % (srcname, filename))
self.client.check_cmd(f"mkdir -p {directory}")
self.client.check_cmd(f"mv {srcname} {filename}")
self.client.check_cmd("sync")
else:
self.net_cmd("mkdir -p %s" % directory)
self.net_cmd(f"mkdir -p {directory}")
self.server.remote_put(srcname, filename)
def hostfilename(self, filename):
@ -866,7 +867,7 @@ class CoreNode(CoreNodeBase):
"""
dirname, basename = os.path.split(filename)
if not basename:
raise ValueError("no basename for filename: %s" % filename)
raise ValueError(f"no basename for filename: {filename}")
if dirname and dirname[0] == "/":
dirname = dirname[1:]
dirname = dirname.replace("/", ".")
@ -891,9 +892,9 @@ class CoreNode(CoreNodeBase):
open_file.write(contents)
os.chmod(open_file.name, mode)
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.net_cmd("chmod %o %s" % (mode, hostfilename))
self.net_cmd(f"chmod {mode:o} {hostfilename}")
logging.debug(
"node(%s) added file: %s; mode: 0%o", self.name, hostfilename, mode
)
@ -914,7 +915,7 @@ class CoreNode(CoreNodeBase):
else:
self.server.remote_put(srcfilename, hostfilename)
if mode is not None:
self.net_cmd("chmod %o %s" % (mode, hostfilename))
self.net_cmd(f"chmod {mode:o} {hostfilename}")
logging.info(
"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 core import constants
from core.constants import CORE_DATA_DIR
from core.emane.nodes import EmaneNet
from core.emulator.enumerations import (
EventTypes,
@ -161,7 +162,7 @@ class Sdt(object):
return False
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:
try:
if self.protocol.lower() == "udp":
@ -192,14 +193,14 @@ class Sdt(object):
:return: initialize command status
: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
# send node type to icon mappings
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
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):
"""
@ -240,8 +241,8 @@ class Sdt(object):
if self.sock is None:
return False
try:
logging.info("sdt: %s" % cmdstr)
self.sock.sendall("%s\n" % cmdstr)
logging.info("sdt: %s", cmdstr)
self.sock.sendall(f"{cmdstr}\n")
return True
except IOError:
logging.exception("SDT connection error")
@ -266,23 +267,21 @@ class Sdt(object):
if not self.connect():
return
if flags & MessageFlags.DELETE.value:
self.cmd("delete node,%d" % nodenum)
self.cmd(f"delete node,{nodenum}")
return
if x is None or y is None:
return
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 icon is not None:
node_type = name
icon = icon.replace("$CORE_DATA_DIR", constants.CORE_DATA_DIR)
icon = icon.replace("$CORE_CONF_DIR", constants.CORE_CONF_DIR)
self.cmd("sprite %s image %s" % (type, icon))
self.cmd(
'node %d type %s label on,"%s" %s' % (nodenum, node_type, name, pos)
)
self.cmd(f"sprite {node_type} image {icon}")
self.cmd(f'node {nodenum} type {node_type} label on,"{name}" {pos}')
else:
self.cmd("node %d %s" % (nodenum, pos))
self.cmd(f"node {nodenum} {pos}")
def updatenodegeo(self, nodenum, lat, long, alt):
"""
@ -298,8 +297,8 @@ class Sdt(object):
# TODO: received Node Message with lat/long/alt.
if not self.connect():
return
pos = "pos %.6f,%.6f,%.6f" % (long, lat, alt)
self.cmd("node %d %s" % (nodenum, pos))
pos = f"pos {long:.6f},{lat:.6f},{alt:.6f}"
self.cmd(f"node {nodenum} {pos}")
def updatelink(self, node1num, node2num, flags, wireless=False):
"""
@ -316,14 +315,13 @@ class Sdt(object):
if not self.connect():
return
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:
attr = ""
if wireless:
attr = " line green,2"
else:
attr = " line red,2"
self.cmd("link %s,%s%s" % (node1num, node2num, attr))
self.cmd(f"link {node1num},{node2num}{attr}")
def sendobjs(self):
"""

23
daemon/core/utils.py
View file

@ -137,7 +137,7 @@ def which(command, required):
break
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
@ -238,12 +238,13 @@ def hex_dump(s, bytes_per_word=2, words_per_line=8):
line = s[:total_bytes]
s = s[total_bytes:]
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),
)
if len(line) % 2:
tmp.append("%x" % ord(line[-1]))
dump += "0x%08x: %s\n" % (count, " ".join(tmp))
tmp.append(f"{ord(line[-1]):x}")
tmp = " ".join(tmp)
dump += f"0x{count:08x}: {tmp}\n"
count += len(line)
return dump[:-1]
@ -261,9 +262,9 @@ def file_munge(pathname, header, text):
file_demunge(pathname, header)
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("# END %s\n" % header)
append_file.write(f"# END {header}\n")
def file_demunge(pathname, header):
@ -281,9 +282,9 @@ def file_demunge(pathname, header):
end = None
for i, line in enumerate(lines):
if line == "# BEGIN %s\n" % header:
if line == f"# BEGIN {header}\n":
start = i
elif line == "# END %s\n" % header:
elif line == f"# END {header}\n":
end = i + 1
if start is None or end is None:
@ -305,7 +306,7 @@ def expand_corepath(pathname, session=None, node=None):
:rtype: str
"""
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_DIR%", session.session_dir)
pathname = pathname.replace("%SESSION_USER%", session.user)
@ -364,7 +365,7 @@ def load_classes(path, clazz):
# validate path exists
logging.debug("attempting to load modules from path: %s", 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
parent_path = os.path.dirname(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
classes = []
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)
try:
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")
state = hook.get("state")
data = hook.text
hook_type = "hook:%s" % state
hook_type = f"hook:{state}"
logging.info("reading hook: state(%s) name(%s)", state, name)
self.session.set_hook(
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")
# platform data
platform_id = "%s/%s" % (host_id, platform_name)
platform_id = f"{host_id}/{platform_name}"
platform_element = etree.SubElement(
host_element, "emanePlatform", id=platform_id, name=platform_name
)
# transport data
transport_id = "%s/%s" % (host_id, transport_name)
transport_id = f"{host_id}/{transport_name}"
etree.SubElement(
platform_element, "transport", id=transport_id, name=transport_name
)
# nem data
nem_name = "nem%s" % nem_id
nem_element_id = "%s/%s" % (host_id, nem_name)
nem_name = f"nem{nem_id}"
nem_element_id = f"{host_id}/{nem_name}"
nem_element = etree.SubElement(
platform_element, "nem", id=nem_element_id, name=nem_name
)
@ -68,7 +68,7 @@ def get_address_type(address):
def get_ipv4_addresses(hostname):
if hostname == "localhost":
addresses = []
args = "%s -o -f inet address show" % IP_BIN
args = f"{IP_BIN} -o -f inet address show"
output = utils.check_cmd(args)
for line in output.split(os.linesep):
split = line.split()
@ -94,13 +94,12 @@ class CoreXmlDeployment(object):
self.add_deployment()
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
def find_interface(self, device, name):
interface = self.scenario.find(
"devices/device[@name='%s']/interfaces/interface[@name='%s']"
% (device.name, name)
f"devices/device[@name='{device.name}']/interfaces/interface[@name='{name}']"
)
return interface
@ -114,7 +113,8 @@ class CoreXmlDeployment(object):
def add_physical_host(self, name):
# 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)
# add type element
@ -128,10 +128,11 @@ class CoreXmlDeployment(object):
def add_virtual_host(self, physical_host, node):
if not isinstance(node, CoreNodeBase):
raise TypeError("invalid node type: %s" % node)
raise TypeError(f"invalid node type: {node}")
# 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(
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
"""
doctype = (
'<!DOCTYPE %(doc_name)s SYSTEM "file:///usr/share/emane/dtd/%(doc_name)s.dtd">'
% {"doc_name": doc_name}
f'<!DOCTYPE {doc_name} SYSTEM "file:///usr/share/emane/dtd/{doc_name}.dtd">'
)
if server is not None:
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)
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))
# 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)
create_file(platform_element, doc_name, file_path)
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)
linked_node = emane_manager.session.nodes[key]
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",
name="%s Transport" % transport_type.capitalize(),
library="trans%s" % transport_type.lower(),
name=f"{transport_type.capitalize()} Transport",
library=f"trans{transport_type.lower()}",
)
# add bitrate
@ -330,7 +329,7 @@ def create_phy_xml(emane_model, config, file_path, server):
will run on, default is None for localhost
: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:
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")
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(
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
: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):
nem_element.set("type", "unstructured")
else:
@ -450,7 +449,7 @@ def transport_file_name(node_id, transport_type):
:param str transport_type: transport type to generate transport file
: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):
@ -461,14 +460,14 @@ def _basename(emane_model, interface=None):
:return: basename used for file creation
:rtype: str
"""
name = "n%s" % emane_model.id
name = f"n{emane_model.id}"
if interface:
node_id = interface.node.id
if emane_model.session.emane.getifcconfig(node_id, interface, emane_model.name):
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):
@ -484,7 +483,7 @@ def nem_file_name(emane_model, interface=None):
append = ""
if interface and interface.transport_type == "raw":
append = "_raw"
return "%snem%s.xml" % (basename, append)
return f"{basename}nem{append}.xml"
def shim_file_name(emane_model, interface=None):
@ -496,7 +495,8 @@ def shim_file_name(emane_model, interface=None):
:return: shim xml filename
: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):
@ -508,7 +508,8 @@ def mac_file_name(emane_model, interface=None):
:return: mac xml filename
: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):
@ -520,4 +521,5 @@ def phy_file_name(emane_model, interface=None):
:return: phy xml filename
:rtype: str
"""
return "%sphy.xml" % _basename(emane_model, interface)
name = _basename(emane_model, interface)
return f"{name}phy.xml"