more updates to using f string
This commit is contained in:
Blake Harnden
parent
79cde8cd59
commit
7d2a615716
23 changed files with 248 additions and 251 deletions
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
)
|
||||
|
|
|
|||
|
|
@ -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):
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
)
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
|
|
|
|||
|
|
@ -48,12 +48,11 @@ def main():
|
|||
logging.basicConfig(level=logging.INFO)
|
||||
options = parser.parse_options("emane80211")
|
||||
start = datetime.datetime.now()
|
||||
print(
|
||||
"running emane 80211 example: nodes(%s) time(%s)"
|
||||
% (options.nodes, options.time)
|
||||
logging.info(
|
||||
"running emane 80211 example: nodes(%s) time(%s)", options.nodes, options.time
|
||||
)
|
||||
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__":
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ DEFAULT_STEP = 1
|
|||
|
||||
|
||||
def parse_options(name):
|
||||
parser = argparse.ArgumentParser(description="Run %s example" % name)
|
||||
parser = argparse.ArgumentParser(description=f"Run {name} example")
|
||||
parser.add_argument(
|
||||
"-n",
|
||||
"--nodes",
|
||||
|
|
@ -25,8 +25,8 @@ def parse_options(name):
|
|||
options = parser.parse_args()
|
||||
|
||||
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:
|
||||
parser.error("invalid test time: %s" % options.time)
|
||||
parser.error(f"invalid test time: {options.time}")
|
||||
|
||||
return options
|
||||
|
|
|
|||
|
|
@ -41,14 +41,12 @@ def example(options):
|
|||
first_node = session.get_node(2)
|
||||
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_address = prefixes.ip4_address(first_node)
|
||||
print("node %s connecting to %s" % (last_node.name, first_node_address))
|
||||
output = last_node.node_net_cmd(
|
||||
"iperf -t %s -c %s" % (options.time, first_node_address)
|
||||
)
|
||||
print(output)
|
||||
logging.info("node %s connecting to %s", last_node.name, first_node_address)
|
||||
output = last_node.node_net_cmd(f"iperf -t {options.time} -c {first_node_address}")
|
||||
logging.info(output)
|
||||
first_node.node_net_cmd("killall -9 iperf")
|
||||
|
||||
# shutdown session
|
||||
|
|
@ -59,9 +57,11 @@ def main():
|
|||
logging.basicConfig(level=logging.INFO)
|
||||
options = parser.parse_options("switch")
|
||||
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)
|
||||
print("elapsed time: %s" % (datetime.datetime.now() - start))
|
||||
logging.info("elapsed time: %s", datetime.datetime.now() - start)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
|
|
|||
|
|
@ -45,11 +45,11 @@ def example(options):
|
|||
first_node = session.get_node(2)
|
||||
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")
|
||||
address = prefixes.ip4_address(first_node)
|
||||
print("node %s connecting to %s" % (last_node.name, address))
|
||||
last_node.node_net_cmd("iperf -t %s -c %s" % (options.time, address))
|
||||
logging.info("node %s connecting to %s", last_node.name, address)
|
||||
last_node.node_net_cmd(f"iperf -t {options.time} -c {address}")
|
||||
first_node.node_net_cmd("killall -9 iperf")
|
||||
|
||||
# shutdown session
|
||||
|
|
@ -61,9 +61,11 @@ def main():
|
|||
options = parser.parse_options("wlan")
|
||||
|
||||
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)
|
||||
print("elapsed time: %s" % (datetime.datetime.now() - start))
|
||||
logging.info("elapsed time: %s", datetime.datetime.now() - start)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
|
|
|||
|
|
@ -17,7 +17,9 @@ from core import constants
|
|||
from core.api.grpc.server import CoreGrpcServer
|
||||
from core.api.tlv.corehandlers import CoreHandler, CoreUdpHandler
|
||||
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.enumerations import CORE_API_PORT
|
||||
from core.utils import close_onexec, load_logging_config
|
||||
|
||||
|
||||
|
|
@ -67,7 +69,9 @@ def cored(cfg):
|
|||
# initialize grpc api
|
||||
if cfg["grpc"] == "True":
|
||||
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.daemon = True
|
||||
grpc_thread.start()
|
||||
|
|
@ -91,30 +95,34 @@ def get_merged_config(filename):
|
|||
:rtype: dict
|
||||
"""
|
||||
# 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 = {
|
||||
"port": "%d" % enumerations.CORE_API_PORT,
|
||||
"listenaddr": "localhost",
|
||||
"numthreads": "1",
|
||||
"grpcport": "50051",
|
||||
"grpcaddress": "localhost",
|
||||
"logfile": os.path.join(constants.CORE_CONF_DIR, "logging.conf")
|
||||
"port": str(CORE_API_PORT),
|
||||
"listenaddr": default_address,
|
||||
"numthreads": default_threads,
|
||||
"grpcport": default_grpc_port,
|
||||
"grpcaddress": default_address,
|
||||
"logfile": default_log
|
||||
}
|
||||
|
||||
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",
|
||||
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,
|
||||
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,
|
||||
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("--grpc", action="store_true", help="enable grpc api, default is false")
|
||||
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",
|
||||
help="grpc address to listen on; default %s" % defaults["grpcaddress"])
|
||||
parser.add_argument("-l", "--logfile", help="core logging configuration; default %s" % defaults["logfile"])
|
||||
help=f"grpc address to listen on; default {default_address}")
|
||||
parser.add_argument("-l", "--logfile", help=f"core logging configuration; default {default_log}")
|
||||
|
||||
# parse command line options
|
||||
args = parser.parse_args()
|
||||
|
|
@ -146,7 +154,7 @@ def main():
|
|||
:return: nothing
|
||||
"""
|
||||
# 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_config(cfg["logfile"])
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ class FileUpdater(object):
|
|||
txt = "Updating"
|
||||
if self.action == "check":
|
||||
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":
|
||||
r = self.update_file(fn=self.update_services)
|
||||
|
|
@ -52,9 +52,9 @@ class FileUpdater(object):
|
|||
if not r:
|
||||
txt = "NOT "
|
||||
if self.action == "check":
|
||||
sys.stdout.write("String %sfound.\n" % txt)
|
||||
sys.stdout.write(f"String {txt} found.\n")
|
||||
else:
|
||||
sys.stdout.write("File %supdated.\n" % txt)
|
||||
sys.stdout.write(f"File {txt} updated.\n")
|
||||
|
||||
return r
|
||||
|
||||
|
|
@ -70,7 +70,7 @@ class FileUpdater(object):
|
|||
r = self.update_keyvals(key, vals)
|
||||
if self.action == "check":
|
||||
return r
|
||||
valstr = "%s" % r
|
||||
valstr = str(r)
|
||||
return "= ".join([key, valstr]) + "\n"
|
||||
|
||||
def update_emane_models(self, line):
|
||||
|
|
@ -125,7 +125,7 @@ class FileUpdater(object):
|
|||
else:
|
||||
raise ValueError("unknown target")
|
||||
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
|
||||
|
||||
def update_file(self, fn=None):
|
||||
|
|
@ -187,18 +187,17 @@ class FileUpdater(object):
|
|||
|
||||
|
||||
def main():
|
||||
actions = ", ".join(FileUpdater.actions)
|
||||
targets = ", ".join(FileUpdater.targets)
|
||||
usagestr = "usage: %prog [-h] [options] <action> <target> <string>\n"
|
||||
usagestr += "\nHelper tool to add, remove, or check for "
|
||||
usagestr += "services, models, and node types\nin a CORE installation.\n"
|
||||
usagestr += "\nExamples:\n %prog add service newrouting"
|
||||
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 += "\nArguments:\n <action> should be one of: %s" % \
|
||||
", ".join(FileUpdater.actions)
|
||||
usagestr += "\n <target> should be one of: %s" % \
|
||||
", ".join(FileUpdater.targets)
|
||||
usagestr += "\n <string> is the text to %s" % \
|
||||
", ".join(FileUpdater.actions)
|
||||
usagestr += f"\nArguments:\n <action> should be one of: {actions}"
|
||||
usagestr += f"\n <target> should be one of: {targets}"
|
||||
usagestr += f"\n <string> is the text to {actions}"
|
||||
parser = optparse.OptionParser(usage=usagestr)
|
||||
parser.set_defaults(userpath=None, verbose=False, )
|
||||
|
||||
|
|
@ -222,14 +221,14 @@ def main():
|
|||
|
||||
action = args[0]
|
||||
if action not in FileUpdater.actions:
|
||||
usage("invalid action %s" % action, 1)
|
||||
usage(f"invalid action {action}", 1)
|
||||
|
||||
target = args[1]
|
||||
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:
|
||||
usage("user path option required for this target (%s)" % target)
|
||||
usage(f"user path option required for this target ({target})")
|
||||
|
||||
data = args[2]
|
||||
|
||||
|
|
@ -237,7 +236,7 @@ def main():
|
|||
up = FileUpdater(action, target, data, options)
|
||||
r = up.process()
|
||||
except Exception as e:
|
||||
sys.stderr.write("Exception: %s\n" % e)
|
||||
sys.stderr.write(f"Exception: {e}\n")
|
||||
sys.exit(1)
|
||||
if not r:
|
||||
sys.exit(1)
|
||||
|
|
|
|||
|
|
@ -21,9 +21,9 @@ def print_available_tlvs(t, tlv_class):
|
|||
"""
|
||||
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):
|
||||
print("%s:%s" % (tlv.value, tlv.name))
|
||||
print(f"{tlv.value}:{tlv.name}")
|
||||
|
||||
|
||||
def print_examples(name):
|
||||
|
|
@ -54,9 +54,9 @@ def print_examples(name):
|
|||
"srcname=\"./test.log\"",
|
||||
"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:
|
||||
print(" %s %s\n\t\t%s" % (name, cmd, descr))
|
||||
print(f" {name} {cmd}\n\t\t{descr}")
|
||||
|
||||
|
||||
def receive_message(sock):
|
||||
|
|
@ -86,11 +86,11 @@ def receive_message(sock):
|
|||
except KeyError:
|
||||
msg = coreapi.CoreMessage(msgflags, msghdr, msgdata)
|
||||
msg.message_type = msgtype
|
||||
print("unimplemented CORE message type: %s" % msg.type_str())
|
||||
print(f"unimplemented CORE message type: {msg.type_str()}")
|
||||
return msg
|
||||
if len(data) > msglen + coreapi.CoreMessage.header_len:
|
||||
print("received a message of type %d, dropping %d bytes of extra data" \
|
||||
% (msgtype, len(data) - (msglen + coreapi.CoreMessage.header_len)))
|
||||
data_size = 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)
|
||||
|
||||
|
||||
|
|
@ -132,7 +132,7 @@ def connect_to_session(sock, requested):
|
|||
print("requested session not found!")
|
||||
return False
|
||||
|
||||
print("joining session: %s" % session)
|
||||
print(f"joining session: {session}")
|
||||
tlvdata = coreapi.CoreSessionTlv.pack(SessionTlvs.NUMBER.value, session)
|
||||
flags = MessageFlags.ADD.value
|
||||
smsg = coreapi.CoreSessionMessage.pack(flags, tlvdata)
|
||||
|
|
@ -147,9 +147,9 @@ def receive_response(sock, opt):
|
|||
print("waiting for response...")
|
||||
msg = receive_message(sock)
|
||||
if msg is None:
|
||||
print("disconnected from %s:%s" % (opt.address, opt.port))
|
||||
print(f"disconnected from {opt.address}:{opt.port}")
|
||||
sys.exit(0)
|
||||
print("received message: %s" % msg)
|
||||
print(f"received message: {msg}")
|
||||
|
||||
|
||||
def main():
|
||||
|
|
@ -160,36 +160,36 @@ def main():
|
|||
flags = [flag.name for flag in MessageFlags]
|
||||
usagestr = "usage: %prog [-h|-H] [options] [message-type] [flags=flags] "
|
||||
usagestr += "[message-TLVs]\n\n"
|
||||
usagestr += "Supported message types:\n %s\n" % types
|
||||
usagestr += "Supported message flags (flags=f1,f2,...):\n %s" % flags
|
||||
usagestr += f"Supported message types:\n {types}\n"
|
||||
usagestr += f"Supported message flags (flags=f1,f2,...):\n {flags}"
|
||||
parser = optparse.OptionParser(usage=usagestr)
|
||||
default_address = "localhost"
|
||||
default_session = None
|
||||
default_tcp = False
|
||||
parser.set_defaults(
|
||||
port=CORE_API_PORT,
|
||||
address="localhost",
|
||||
session=None,
|
||||
address=default_address,
|
||||
session=default_session,
|
||||
listen=False,
|
||||
examples=False,
|
||||
tlvs=False,
|
||||
tcp=False
|
||||
tcp=default_tcp
|
||||
)
|
||||
|
||||
parser.add_option("-H", dest="examples", action="store_true",
|
||||
help="show example usage help message and exit")
|
||||
parser.add_option("-p", "--port", dest="port", type=int,
|
||||
help="TCP port to connect to, default: %d" % \
|
||||
parser.defaults["port"])
|
||||
help=f"TCP port to connect to, default: {CORE_API_PORT}")
|
||||
parser.add_option("-a", "--address", dest="address", type=str,
|
||||
help="Address to connect to, default: %s" % \
|
||||
parser.defaults["address"])
|
||||
help=f"Address to connect to, default: {default_address}")
|
||||
parser.add_option("-s", "--session", dest="session", type=str,
|
||||
help="Session to join, default: %s" % \
|
||||
parser.defaults["session"])
|
||||
help=f"Session to join, default: {default_session}")
|
||||
parser.add_option("-l", "--listen", dest="listen", action="store_true",
|
||||
help="Listen for a response message and print it.")
|
||||
parser.add_option("-t", "--list-tlvs", dest="tlvs", action="store_true",
|
||||
help="List TLVs for the specified message type.")
|
||||
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):
|
||||
sys.stdout.write("\n")
|
||||
|
|
@ -209,7 +209,7 @@ def main():
|
|||
# given a message type t, determine the message and TLV classes
|
||||
t = args.pop(0)
|
||||
if t not in types:
|
||||
usage("Unknown message type requested: %s" % t)
|
||||
usage(f"Unknown message type requested: {t}")
|
||||
message_type = MessageTypes[t]
|
||||
msg_cls = coreapi.CLASS_MAP[message_type.value]
|
||||
tlv_cls = msg_cls.tlv_class
|
||||
|
|
@ -225,7 +225,7 @@ def main():
|
|||
for a in args:
|
||||
typevalue = a.split("=")
|
||||
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_valstr = "=".join(typevalue[1:])
|
||||
if tlv_typestr == "flags":
|
||||
|
|
@ -237,7 +237,7 @@ def main():
|
|||
tlv_type = tlv_cls.tlv_type_map[tlv_name]
|
||||
tlvdata += tlv_cls.pack_string(tlv_type.value, tlv_valstr)
|
||||
except KeyError:
|
||||
usage("Unknown TLV: \"%s\"" % tlv_name)
|
||||
usage(f"Unknown TLV: \"{tlv_name}\"")
|
||||
|
||||
flags = 0
|
||||
for f in flagstr.split(","):
|
||||
|
|
@ -249,7 +249,7 @@ def main():
|
|||
n = flag_enum.value
|
||||
flags |= n
|
||||
except KeyError:
|
||||
usage("Invalid flag \"%s\"." % f)
|
||||
usage(f"Invalid flag \"{f}\".")
|
||||
|
||||
msg = msg_cls.pack(flags, tlvdata)
|
||||
|
||||
|
|
@ -264,7 +264,7 @@ def main():
|
|||
try:
|
||||
sock.connect((opt.address, opt.port))
|
||||
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)
|
||||
|
||||
if opt.tcp and not connect_to_session(sock, opt.session):
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue