added pydocs for netclient

daemon/core/emane/emanemanager.py

@@ -733,11 +733,11 @@ class EmaneManager(ModelManager):
                 )
 
             # multicast route is needed for OTA data
-            node.node_net_client.add_route(otagroup, otadev)
+            node.node_net_client.create_route(otagroup, otadev)
 
             # multicast route is also needed for event data if on control network
             if eventservicenetidx >= 0 and eventgroup != otagroup:
-                node.node_net_client.add_route(eventgroup, eventdev)
+                node.node_net_client.create_route(eventgroup, eventdev)
 
             # start emane
             args = emanecmd + [

daemon/core/nodes/base.py

@@ -53,7 +53,7 @@ class NodeBase(object):
         self.type = None
         self.server = None
         self.services = None
-        # ifindex is key, PyCoreNetIf instance is value
+        # ifindex is key, CoreInterface instance is value
         self._netif = {}
         self.ifindex = 0
         self.canvas = None
@@ -364,6 +364,17 @@ class CoreNodeBase(NodeBase):
 
         return common
 
+    def network_cmd(self, args):
+        """
+        Runs a command for a node that is used to configure and setup network interfaces.
+
+        :param list[str]|str args: command to run
+        :return: combined stdout and stderr
+        :rtype: str
+        :raises CoreCommandError: when a non-zero exit status occurs
+        """
+        raise NotImplementedError
+
     def check_cmd(self, args):
         """
         Runs shell command on node.

daemon/core/nodes/netclient.py

@@ -13,67 +13,136 @@ class LinuxNetClient(object):
     Client for creating Linux bridges and ip interfaces for nodes.
     """
 
-    def __init__(self, run_func):
+    def __init__(self, run):
-        self.run_func = run_func
+        """
+        Create LinuxNetClient instance.
 
-    def run(self, cmd):
+        :param run: function to run commands with
-        return self.run_func(cmd)
+        """
+        self.run = run
 
     def set_hostname(self, name):
+        """
+        Set network hostname.
+
+        :param str name: name for hostname
+        :return: nothing
+        """
         self.run(["hostname", name])
 
-    def add_route(self, route, device):
+    def create_route(self, route, device):
+        """
+        Create a new route for a device.
+
+        :param str route: route to create
+        :param str device: device to add route to
+        :return: nothing
+        """
         self.run([IP_BIN, "route", "add", route, "dev", device])
 
     def device_up(self, device):
+        """
+        Bring a device up.
+
+        :param str device: device to bring up
+        :return: nothing
+        """
         self.run([IP_BIN, "link", "set", device, "up"])
 
     def device_down(self, device):
+        """
+        Bring a device down.
+
+        :param str device: device to bring down
+        :return: nothing
+        """
         self.run([IP_BIN, "link", "set", device, "down"])
 
     def device_name(self, device, name):
+        """
+        Set a device name.
+
+        :param str device: device to set name for
+        :param str name: name to set
+        :return: nothing
+        """
         self.run([IP_BIN, "link", "set", device, "name", name])
 
     def device_show(self, device):
+        """
+        Show information for a device.
+
+        :param str device: device to get information for
+        :return: device information
+        :rtype: str
+        """
         return self.run([IP_BIN, "link", "show", device])
 
     def device_ns(self, device, namespace):
+        """
+        Set netns for a device.
+
+        :param str device: device to setns for
+        :param str namespace: namespace to set device to
+        :return: nothing
+        """
         self.run([IP_BIN, "link", "set", device, "netns", namespace])
 
     def device_flush(self, device):
+        """
+        Flush device addresses.
+
+        :param str device: device to flush
+        :return: nothing
+        """
         self.run([IP_BIN, "-6", "address", "flush", "dev", device])
 
     def device_mac(self, device, mac):
+        """
+        Set MAC address for a device.
+
+        :param str device: device to set mac for
+        :param str mac: mac to set
+        :return: nothing
+        """
         self.run([IP_BIN, "link", "set", "dev", device, "address", mac])
 
     def delete_device(self, device):
+        """
+        Delete device.
+
+        :param str device: device to delete
+        :return: nothing
+        """
         self.run([IP_BIN, "link", "delete", device])
 
     def delete_tc(self, device):
+        """
+        Remove traffic control settings for a device.
+
+        :param str device: device to remove tc
+        :return: nothing
+        """
         self.run([TC_BIN, "qdisc", "del", "dev", device, "root"])
 
     def checksums_off(self, interface_name):
+        """
+        Turns interface checksums off.
+
+        :param str interface_name: interface to update
+        :return: nothing
+        """
         self.run([ETHTOOL_BIN, "-K", interface_name, "rx", "off", "tx", "off"])
 
-    def delete_address(self, device, address):
-        self.run([IP_BIN, "address", "delete", address, "dev", device])
-
-    def create_veth(self, name, peer):
-        self.run(
-            [IP_BIN, "link", "add", "name", name, "type", "veth", "peer", "name", peer]
-        )
-
-    def create_gretap(self, device, address, local, ttl, key):
-        cmd = [IP_BIN, "link", "add", device, "type", "gretap", "remote", address]
-        if local is not None:
-            cmd.extend(["local", local])
-        if ttl is not None:
-            cmd.extend(["ttl", ttl])
-        if key is not None:
-            cmd.extend(["key", key])
-        self.run(cmd)
-
     def create_address(self, device, address, broadcast=None):
+        """
+        Create address for a device.
+
+        :param str device: device to add address to
+        :param str address: address to add
+        :param str broadcast: broadcast address to use, default is None
+        :return: nothing
+        """
         if broadcast is not None:
             self.run(
                 [
@@ -90,6 +159,48 @@ class LinuxNetClient(object):
         else:
             self.run([IP_BIN, "address", "add", address, "dev", device])
 
+    def delete_address(self, device, address):
+        """
+        Delete an address from a device.
+
+        :param str device: targeted device
+        :param str address: address to remove
+        :return: nothing
+        """
+        self.run([IP_BIN, "address", "delete", address, "dev", device])
+
+    def create_veth(self, name, peer):
+        """
+        Create a veth pair.
+
+        :param str name: veth name
+        :param str peer: peer name
+        :return: nothing
+        """
+        self.run(
+            [IP_BIN, "link", "add", "name", name, "type", "veth", "peer", "name", peer]
+        )
+
+    def create_gretap(self, device, address, local, ttl, key):
+        """
+        Create a GRE tap on a device.
+
+        :param str device: device to add tap to
+        :param str address: address to add tap for
+        :param str local: local address to tie to
+        :param str ttl: time to live value
+        :param str key: key for tap
+        :return: nothing
+        """
+        cmd = [IP_BIN, "link", "add", device, "type", "gretap", "remote", address]
+        if local is not None:
+            cmd.extend(["local", local])
+        if ttl is not None:
+            cmd.extend(["ttl", ttl])
+        if key is not None:
+            cmd.extend(["key", key])
+        self.run(cmd)
+
     def create_bridge(self, name):
         """
         Create a Linux bridge and bring it up.