converted format strings to f strings

daemon/core/api/grpc/server.py

@@ -247,9 +247,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
         """
         session = self.coreemu.sessions.get(session_id)
         if not session:
-            context.abort(
+            context.abort(grpc.StatusCode.NOT_FOUND, f"session {session_id} not found")
-                grpc.StatusCode.NOT_FOUND, "session {} not found".format(session_id)
-            )
         return session
 
     def get_node(self, session, node_id, context):
@@ -265,9 +263,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
         try:
             return session.get_node(node_id)
         except CoreError:
-            context.abort(
+            context.abort(grpc.StatusCode.NOT_FOUND, f"node {node_id} not found")
-                grpc.StatusCode.NOT_FOUND, "node {} not found".format(node_id)
-            )
 
     def CreateSession(self, request, context):
         """
@@ -1577,17 +1573,13 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
         nem_one = request.nem_one
         emane_one, netif = session.emane.nemlookup(nem_one)
         if not emane_one or not netif:
-            context.abort(
+            context.abort(grpc.StatusCode.NOT_FOUND, f"nem one {nem_one} not found")
-                grpc.StatusCode.NOT_FOUND, "nem one {} not found".format(nem_one)
-            )
         node_one = netif.node
 
         nem_two = request.nem_two
         emane_two, netif = session.emane.nemlookup(nem_two)
         if not emane_two or not netif:
-            context.abort(
+            context.abort(grpc.StatusCode.NOT_FOUND, f"nem two {nem_two} not found")
-                grpc.StatusCode.NOT_FOUND, "nem two {} not found".format(nem_two)
-            )
         node_two = netif.node
 
         if emane_one.id == emane_two.id:

daemon/core/nodes/base.py

@@ -492,9 +492,7 @@ class CoreNode(CoreNodeBase):
                 raise ValueError("starting a node that is already up")
 
             # create a new namespace for this node using vnoded
-            vnoded = "{cmd} -v -c {name} -l {name}.log -p {name}.pid".format(
+            vnoded = f"{VNODED_BIN} -v -c {self.ctrlchnlname} -l {self.ctrlchnlname}.log -p {self.ctrlchnlname}.pid"
-                cmd=VNODED_BIN, name=self.ctrlchnlname
-            )
             if self.nodedir:
                 vnoded += f" -C {self.nodedir}"
             env = self.session.get_environment(state=False)
@@ -593,9 +591,7 @@ class CoreNode(CoreNodeBase):
         if self.server is None:
             return terminal
         else:
-            return "ssh -X -f {host} xterm -e {terminal}".format(
+            return f"ssh -X -f {self.server.host} xterm -e {terminal}"
-                host=self.server.host, terminal=terminal
-            )
 
     def privatedir(self, path):
         """

daemon/core/nodes/docker.py

@@ -19,23 +19,18 @@ class DockerClient(object):
 
     def create_container(self):
         self.run(
-            "docker run -td --init --net=none --hostname {name} --name {name} "
+            f"docker run -td --init --net=none --hostname {self.name} --name {self.name} "
-            "--sysctl net.ipv6.conf.all.disable_ipv6=0 "
+            f"--sysctl net.ipv6.conf.all.disable_ipv6=0 {self.image} /bin/bash"
-            "{image} /bin/bash".format(
+        )
-                name=self.name,
-                image=self.image
-            ))
         self.pid = self.get_pid()
         return self.pid
 
     def get_info(self):
-        args = "docker inspect {name}".format(name=self.name)
+        args = f"docker inspect {self.name}"
         output = self.run(args)
         data = json.loads(output)
         if not data:
-            raise CoreCommandError(
+            raise CoreCommandError(-1, args, f"docker({self.name}) not present")
-                -1, args, "docker({name}) not present".format(name=self.name)
-            )
         return data[0]
 
     def is_alive(self):
@@ -46,43 +41,28 @@ class DockerClient(object):
             return False
 
     def stop_container(self):
-        self.run("docker rm -f {name}".format(
+        self.run(f"docker rm -f {self.name}")
-            name=self.name
-        ))
 
     def check_cmd(self, cmd):
         logging.info("docker cmd output: %s", cmd)
-        return utils.check_cmd("docker exec {name} {cmd}".format(
+        return utils.check_cmd(f"docker exec {self.name} {cmd}")
-            name=self.name,
-            cmd=cmd
-        ))
 
     def create_ns_cmd(self, cmd):
-        return "nsenter -t {pid} -u -i -p -n {cmd}".format(
+        return f"nsenter -t {self.pid} -u -i -p -n {cmd}"
-            pid=self.pid,
-            cmd=cmd
-        )
 
     def ns_cmd(self, cmd, wait):
-        args = "nsenter -t {pid} -u -i -p -n {cmd}".format(
+        args = f"nsenter -t {self.pid} -u -i -p -n {cmd}"
-            pid=self.pid,
-            cmd=cmd
-        )
         return utils.check_cmd(args, wait=wait)
 
     def get_pid(self):
-        args = "docker inspect -f '{{{{.State.Pid}}}}' {name}".format(name=self.name)
+        args = f"docker inspect -f '{{{{.State.Pid}}}}' {self.name}"
         output = self.run(args)
         self.pid = output
         logging.debug("node(%s) pid: %s", self.name, self.pid)
         return output
 
     def copy_file(self, source, destination):
-        args = "docker cp {source} {name}:{destination}".format(
+        args = f"docker cp {source} {self.name}:{destination}"
-            source=source,
-            name=self.name,
-            destination=destination
-        )
         return self.run(args)
 
 
@@ -185,7 +165,7 @@ class DockerNode(CoreNode):
         :param str sh: shell to execute command in
         :return: str
         """
-        return "docker exec -it {name} bash".format(name=self.name)
+        return f"docker exec -it {self.name} bash"
 
     def privatedir(self, path):
         """
@@ -195,7 +175,7 @@ class DockerNode(CoreNode):
         :return: nothing
         """
         logging.debug("creating node dir: %s", path)
-        args = "mkdir -p {path}".format(path=path)
+        args = f"mkdir -p {path}"
         self.node_net_cmd(args)
 
     def mount(self, source, target):

daemon/core/nodes/lxd.py

@@ -18,19 +18,17 @@ class LxdClient(object):
         self.pid = None
 
     def create_container(self):
-        self.run("lxc launch {image} {name}".format(name=self.name, image=self.image))
+        self.run(f"lxc launch {self.image} {self.name}")
         data = self.get_info()
         self.pid = data["state"]["pid"]
         return self.pid
 
     def get_info(self):
-        args = "lxc list {name} --format json".format(name=self.name)
+        args = f"lxc list {self.name} --format json"
         output = self.run(args)
         data = json.loads(output)
         if not data:
-            raise CoreCommandError(
+            raise CoreCommandError(-1, args, f"LXC({self.name}) not present")
-                -1, args, "LXC({name}) not present".format(name=self.name)
-            )
         return data[0]
 
     def is_alive(self):
@@ -41,13 +39,13 @@ class LxdClient(object):
             return False
 
     def stop_container(self):
-        self.run("lxc delete --force {name}".format(name=self.name))
+        self.run(f"lxc delete --force {self.name}")
 
     def create_cmd(self, cmd):
-        return "lxc exec -nT {name} -- {cmd}".format(name=self.name, cmd=cmd)
+        return f"lxc exec -nT {self.name} -- {cmd}"
 
     def create_ns_cmd(self, cmd):
-        return "nsenter -t {pid} -m -u -i -p -n {cmd}".format(pid=self.pid, cmd=cmd)
+        return f"nsenter -t {self.pid} -m -u -i -p -n {cmd}"
 
     def check_cmd(self, cmd, wait=True):
         args = self.create_cmd(cmd)
@@ -57,9 +55,7 @@ class LxdClient(object):
         if destination[0] != "/":
             destination = os.path.join("/root/", destination)
 
-        args = "lxc file push {source} {name}/{destination}".format(
+        args = f"lxc file push {source} {self.name}/{destination}"
-            source=source, name=self.name, destination=destination
-        )
         self.run(args)
 
 
@@ -142,7 +138,7 @@ class LxcNode(CoreNode):
         :param str sh: shell to execute command in
         :return: str
         """
-        return "lxc exec {name} -- {sh}".format(name=self.name, sh=sh)
+        return f"lxc exec {self.name} -- {sh}"
 
     def privatedir(self, path):
         """
@@ -152,7 +148,7 @@ class LxcNode(CoreNode):
         :return: nothing
         """
         logging.info("creating node dir: %s", path)
-        args = "mkdir -p {path}".format(path=path)
+        args = f"mkdir -p {path}"
         return self.node_net_cmd(args)
 
     def mount(self, source, target):