Skip to contentSkip to conversation

tools/net/ynl: enable json configuration

PATCH In review Maryam Tahhan 2 participants 8 messages Jul 27, 2023 – Jul 31, 2023

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

v2 cover tools/net/ynl: enable json configuration

Use a json configuration file to pass parameters to ynl to allow for operations on multiple specs in one go. Additionally, check this new configuration against a schema to validate it in the cli module before parsing it and passing info to the ynl module.

Example configs would be:

{
    "yaml-specs-path": "/<path-to>/linux/Documentation/netlink/specs",
    "spec-args": {
        "ethtool.yaml": {
            "do": "rings-get",
            "json-params": {
                "header": {
                    "dev-name": "eno1"
                }
            }
        },
       "netdev.yaml": {
            "do": "dev-get",
            "json-params": {
            "ifindex": 3
            }
        }
    }
}

OR

{
    "yaml-specs-path": "/<path-to>/linux/Documentation/netlink/specs",
    "spec-args": {
        "ethtool.yaml": {
            "subscribe": "monitor",
            "sleep": 10
        },
        "netdev.yaml": {
            "subscribe": "mgmt",
            "sleep": 5
        }
    }
}

v2:
- Removed From:... that was preceding the commit description.

Maryam Tahhan (2):
tools/net/ynl: configuration through json
tools/net/ynl: validate config against schema

 tools/net/ynl/cli.py            | 135 +++++++++++++++++++++++++++-----
 tools/net/ynl/ynl-config.schema |  72 +++++++++++++++++
 2 files changed, 187 insertions(+), 20 deletions(-)
 create mode 100644 tools/net/ynl/ynl-config.schema
Signature · 1 line
2.41.0
#1 lore raw

PATCH v2 1/2 tools/net/ynl: configuration through json

Enable YNL configuration through a json file alongside the current commandline arguments. This will allow one to cycle through multiple specs and commands at once.

---
 tools/net/ynl/cli.py | 108 ++++++++++++++++++++++++++++++++++---------
 1 file changed, 87 insertions(+), 21 deletions(-)
tools/net/ynl/cli.py +87 -21
index ffaa8038aa8c..1749851f8460 100755
@@ -5,13 +5,54 @@ import argparse
 import json
 import pprint
 import time
+import os
 
 from lib import YnlFamily
 
+class ynlConfig():
+    def __init__(self):
+        self.no_schema = True
+        self.schema = None
+        self.spec = None
+        self.json_text = None
+        self.ntf = None
+        self.sleep = None
+        self.do = None
+        self.dump = None
+    def run(self):
+        ynl_cfg(self.no_schema, self.spec, self.schema, self.json_text, self.ntf, self.sleep, self.do, self.dump)
+
+def ynl_cfg(no_schema, spec, schema, json_text, ntf, sleep, do, dump):
+
+        if no_schema:
+            schema = ''
+
+        attrs = {}
+        if json_text:
+            attrs = json.loads(json_text)
+
+        ynl = YnlFamily(spec, schema)
+
+        if ntf:
+            ynl.ntf_subscribe(ntf)
+
+        if sleep:
+            time.sleep(sleep)
+
+        if do:
+            reply = ynl.do(do, attrs)
+            pprint.PrettyPrinter().pprint(reply)
+        if dump:
+            reply = ynl.dump(dump, attrs)
+            pprint.PrettyPrinter().pprint(reply)
+
+        if ntf:
+            ynl.check_ntf()
+            pprint.PrettyPrinter().pprint(ynl.async_msg_queue)
 
 def main():
     parser = argparse.ArgumentParser(description='YNL CLI sample')
-    parser.add_argument('--spec', dest='spec', type=str, required=True)
+    parser.add_argument('--spec', dest='spec', type=str)
     parser.add_argument('--schema', dest='schema', type=str)
     parser.add_argument('--no-schema', action='store_true')
     parser.add_argument('--json', dest='json_text', type=str)
@@ -19,34 +60,59 @@ def main():
     parser.add_argument('--dump', dest='dump', type=str)
     parser.add_argument('--sleep', dest='sleep', type=int)
     parser.add_argument('--subscribe', dest='ntf', type=str)
+    parser.add_argument('--config', dest='config', type=str)
     args = parser.parse_args()
 
-    if args.no_schema:
-        args.schema = ''
-
-    attrs = {}
-    if args.json_text:
-        attrs = json.loads(args.json_text)
+    if args.config:
+        directory = ""
+        yamls = {}
 
-    ynl = YnlFamily(args.spec, args.schema)
+        if not os.path.exists(args.config):
+             print("Error: ", args.config, " doesn't exist")
+             exit(-1)
 
-    if args.ntf:
-        ynl.ntf_subscribe(args.ntf)
+        f = open(args.config)
+        data = json.load(f)
 
-    if args.sleep:
-        time.sleep(args.sleep)
+        for k in data:
+            if k == 'yaml-specs-path':
+                directory = data[k]
 
-    if args.do:
-        reply = ynl.do(args.do, attrs)
-        pprint.PrettyPrinter().pprint(reply)
-    if args.dump:
-        reply = ynl.dump(args.dump, attrs)
-        pprint.PrettyPrinter().pprint(reply)
+                # Scan the dir and get all the yaml files.
+                for filename in os.scandir(directory):
+                    if filename.is_file():
+                        if filename.name.endswith('.yaml'):
+                            yamls[filename.name] = filename.path
 
-    if args.ntf:
-        ynl.check_ntf()
-        pprint.PrettyPrinter().pprint(ynl.async_msg_queue)
+            elif k == 'spec-args':
+               for v in data[k]:
+                    print("############### ",v," ###############\n")
+                    cfg = ynlConfig()
+                    # Check for yaml from the specs we found earlier
+                    if v in yamls:
+                        # FOUND
+                        cfg.spec = yamls[v]
+                        if 'no-schema' in data[k][v]:
+                            cfg.no_schema = data[k][v]['no-schema']
+                        if 'schema' in data[k][v]:
+                            cfg.schema = data[k][v]['schema']
+                            cfg.no_schema = False
+                        if 'do' in data[k][v]:
+                            cfg.do = data[k][v]['do']
+                        if 'dump' in data[k][v]:
+                            cfg.dump = data[k][v]['dump']
+                        if 'subscribe' in data[k][v]:
+                            cfg.ntf = data[k][v]['subscribe']
+                        if 'sleep' in data[k][v]:
+                            cfg.sleep = data[k][v]['sleep']
+                        if 'json-params' in data[k][v]:
+                            cfg.json_text = json.dumps(data[k][v]['json-params'])
 
+                        cfg.run()
+                    else:
+                        print("Error: ", v, " doesn't have a valid yaml file in ", directory, "\n")
+    else:
+        ynl_cfg(args.no_schema, args.spec, args.schema, args.json_text, args.ntf, args.sleep, args.do, args.dump)
 
 if __name__ == "__main__":
     main()
Signature · 1 line
2.41.0
maintainer
#2 lore raw

Re: [PATCH net-next v2 1/2] tools/net/ynl: configuration through json

Quoted 1 line · On Thu, 27 Jul 2023 08:03:30 -0400 Maryam Tahhan wrote:
 tools/net/ynl/cli.py | 108 ++++++++++++++++++++++++++++++++++---------

I think we should keep cli.py nice and simple, it'd be better to create a separate script which suits you use case.

Signature · 1 line
pw-bot: cr
#3 lore raw

PATCH v2 2/2 tools/net/ynl: validate config against schema

In reply to Maryam Tahhan

Validate the provided configuration file against
the ynl-config.schema.

---
 tools/net/ynl/cli.py            | 43 ++++++++++++++++----
 tools/net/ynl/ynl-config.schema | 72 +++++++++++++++++++++++++++++++++
 2 files changed, 108 insertions(+), 7 deletions(-)
 create mode 100644 tools/net/ynl/ynl-config.schema
tools/net/ynl/cli.py +36 -7
index 1749851f8460..3071ef9e3117 100755
@@ -9,6 +9,12 @@ import os
 
 from lib import YnlFamily
 
+try:
+    import jsonschema
+except ModuleNotFoundError as e:
+    print('Error: {}. Try `pip install jsonschema`'.format(e))
+    raise SystemExit(1)
+
 class ynlConfig():
     def __init__(self):
         self.no_schema = True
@@ -66,13 +72,36 @@ def main():
     if args.config:
         directory = ""
         yamls = {}
-
-        if not os.path.exists(args.config):
-             print("Error: ", args.config, " doesn't exist")
-             exit(-1)
-
-        f = open(args.config)
-        data = json.load(f)
+        configSchema = os.path.dirname(__file__) + "/ynl-config.schema"
+
+        # Load ynl-config json schema
+        try:
+            with open(configSchema, 'r') as f:
+                s = json.load(f)
+        except FileNotFoundError as e:
+            print('Error:', e)
+            raise SystemExit(1)
+        except json.decoder.JSONDecodeError as e:
+            print('Error: {}:'.format(args.schema), e)
+            raise SystemExit(1)
+
+        # Load config file
+        try:
+            with open(args.config, 'r') as f:
+                data = json.load(f)
+        except FileNotFoundError as e:
+            print('Error:', e)
+            raise SystemExit(1)
+        except json.decoder.JSONDecodeError as e:
+            print('Error: {}:'.format(args.schema), e)
+            raise SystemExit(1)
+
+        # Validate json config against the ynl-config schema
+        try:
+            jsonschema.validate(instance=data, schema=s)
+        except jsonschema.exceptions.ValidationError as e:
+            print('Error:', e)
+            raise SystemExit(1)
 
         for k in data:
             if k == 'yaml-specs-path':
tools/net/ynl/ynl-config.schema new file +72 -0

72 lines not on this page · raw message

Signature · 1 line
2.41.0
maintainer
#4 lore raw
In reply to Maryam Tahhan
Quoted 4 lines · On Thu, 27 Jul 2023 08:03:29 -0400 Maryam Tahhan wrote:

Use a json configuration file to pass parameters to ynl to allow for operations on multiple specs in one go. Additionally, check this new configuration against a schema to validate it in the cli module before parsing it and passing info to the ynl module.

Interesting. Is this related to Donald's comments about subscribing to notifications from multiple families?

Can you share some info about your use case?

Quoted 13 lines

Example configs would be:

{
    "yaml-specs-path": "/<path-to>/linux/Documentation/netlink/specs",
    "spec-args": {
        "ethtool.yaml": {
            "do": "rings-get",
            "json-params": {
                "header": {
                    "dev-name": "eno1"
                }
            }
        },
Quoted 8 lines
       "netdev.yaml": {
            "do": "dev-get",
            "json-params": {
            "ifindex": 3
            }
        }
    }
}

Why is the JSON preferable to writing a script to the same effect? It'd actually be shorter and more flexible.
Maybe we should focus on packaging YNL as a python lib?

Quoted 15 lines

OR

{
    "yaml-specs-path": "/<path-to>/linux/Documentation/netlink/specs",
    "spec-args": {
        "ethtool.yaml": {
            "subscribe": "monitor",
            "sleep": 10
        },
        "netdev.yaml": {
            "subscribe": "mgmt",
            "sleep": 5
        }
    }
}

Could you also share the outputs the examples would produce?

#5 lore raw
Quoted 9 lines · Jakub Kicinski
Quoted 4 lines · On Thu, 27 Jul 2023 08:03:29 -0400 Maryam Tahhan wrote:

Use a json configuration file to pass parameters to ynl to allow for operations on multiple specs in one go. Additionally, check this new configuration against a schema to validate it in the cli module before parsing it and passing info to the ynl module.

Interesting. Is this related to Donald's comments about subscribing to notifications from multiple families?

Can you share some info about your use case?

Yes it's related. We are working towards using YNL as a netlink agent or part of a netlink agent that's driven by YAML specs. We are

trying to enable existing Kubernetes CNIs to integrate with DPUs via an OPI [1] API without having to change these existing CNIs. In several

cases these CNIs program the Kernel as both the control plane and the fallback dataplane (for packets the DPU accelerator doesn't know what

to do with). And so being able to monitor netlink state and reflect it to the DPU accelerator (and vice versa) via an OPI API would be extremely useful.

We think the YAML part gives us a solid model that showcases the breadth of what these CNIs program (via netlink) as well as a base for the grpc protobufs that

the OPI API would like to define/use.

Quoted 21 lines
Quoted 13 lines

Example configs would be:

{
     "yaml-specs-path": "/<path-to>/linux/Documentation/netlink/specs",
     "spec-args": {
         "ethtool.yaml": {
             "do": "rings-get",
             "json-params": {
                 "header": {
                     "dev-name": "eno1"
                 }
             }
         },
Quoted 8 lines
        "netdev.yaml": {
             "do": "dev-get",
             "json-params": {
             "ifindex": 3
             }
         }
     }
}
Quoted 3 lines

Why is the JSON preferable to writing a script to the same effect? It'd actually be shorter and more flexible.
Maybe we should focus on packaging YNL as a python lib?

I guess you can write a script. The reasons I picked JSON were mainly:

-  Simplicity and Readability for both developers and non-developers/users.

- With the JSON Schema Validation I could very quickly validate the incoming configuration without too much logic in cli.py.

- I thought of it as a stepping stone towards an agent configuration file if YNL evolves to provide or be part of a netlink agent (driven by yaml specs)...

Quoted 16 lines
Quoted 16 lines

OR

{
     "yaml-specs-path": "/<path-to>/linux/Documentation/netlink/specs",
     "spec-args": {
         "ethtool.yaml": {
             "subscribe": "monitor",
             "sleep": 10
         },
         "netdev.yaml": {
             "subscribe": "mgmt",
             "sleep": 5
         }
     }
}
Quoted 2 lines

Could you also share the outputs the examples would produce?

Right now the output is simple, an example would be for the first config in the email:

[ linux]# ./tools/net/ynl/cli.py --config ./tools/net/ynl/multi-do.json ###############  ethtool.yaml  ###############

{'header': {'dev-index': 3, 'dev-name': 'eno1'},
 'rx': 512,
 'rx-max': 8192,
 'rx-push': 0,
 'tx': 512,
 'tx-max': 8192,
 'tx-push': 0}
###############  netdev.yaml  ###############

{'ifindex': 3, 'xdp-features': {'xsk-zerocopy', 'redirect', 'basic'}}

Or for the second config in the email (note: I just toggled the tx ring descriptors on one of my NICs to trigger an ethtool notification):

[root@nfvsdn-06 linux]# ./tools/net/ynl/cli.py --config ./tools/net/ynl/multi-ntf.json ###############  ethtool.yaml  ###############

[{'msg': {'header': {'dev-index': 3, 'dev-name': 'eno1'}, 'rx': 512,
          'rx-max': 8192,
          'rx-push': 0,
          'tx': 8192,
          'tx-max': 8192,
          'tx-push': 0},
  'name': 'rings-ntf'}]
###############  netdev.yaml  ###############

[]

At the moment (even with these changes) YNL subscribes-sleeps-checks for notification for each family sequentially... I will be looking into enabling an agent like behaviour: subscribe to notifications from multiple families and monitor (babysteps)....

[1] https://opiproject.org/

maintainer
#6 lore raw
Quoted 25 lines · On Fri, 28 Jul 2023 11:24:51 +0100 Maryam Tahhan wrote:
Quoted 9 lines · Jakub Kicinski
Quoted 4 lines · On Thu, 27 Jul 2023 08:03:29 -0400 Maryam Tahhan wrote:

Use a json configuration file to pass parameters to ynl to allow for operations on multiple specs in one go. Additionally, check this new configuration against a schema to validate it in the cli module before parsing it and passing info to the ynl module.

Interesting. Is this related to Donald's comments about subscribing to notifications from multiple families?

Can you share some info about your use case?

Yes it's related. We are working towards using YNL as a netlink agent or part of a netlink agent that's driven by YAML specs. We are

trying to enable existing Kubernetes CNIs to integrate with DPUs via an OPI [1] API without having to change these existing CNIs. In several

cases these CNIs program the Kernel as both the control plane and the fallback dataplane (for packets the DPU accelerator doesn't know what to do with). And so being able to monitor netlink state and reflect it to the DPU accelerator (and vice versa) via an OPI API would be extremely useful.

Quoted 3 lines

We think the YAML part gives us a solid model that showcases the breadth of what these CNIs program (via netlink) as well as a base for the grpc protobufs that the OPI API would like to define/use.

So agent on the host is listening to netlink and sending to DPU gRPC requests? From what you're describing it sounds like you'd mostly want to pass the notifications. The multi-command thing is to let the DPU also make requests if it needs to do/know something specific?

Quoted 27 lines
Quoted 21 lines
Quoted 13 lines

Example configs would be:

{
     "yaml-specs-path": "/<path-to>/linux/Documentation/netlink/specs",
     "spec-args": {
         "ethtool.yaml": {
             "do": "rings-get",
             "json-params": {
                 "header": {
                     "dev-name": "eno1"
                 }
             }
         },
Quoted 8 lines
        "netdev.yaml": {
             "do": "dev-get",
             "json-params": {
             "ifindex": 3
             }
         }
     }
}  
Quoted 3 lines

Why is the JSON preferable to writing a script to the same effect? It'd actually be shorter and more flexible.
Maybe we should focus on packaging YNL as a python lib?

I guess you can write a script. The reasons I picked JSON were mainly:

Quoted 8 lines

-  Simplicity and Readability for both developers and non-developers/users.

- With the JSON Schema Validation I could very quickly validate the incoming configuration without too much logic in cli.py.

- I thought of it as a stepping stone towards an agent configuration file if YNL evolves to provide or be part of a netlink agent (driven by yaml specs)...

Those are very valid. My worry is that:
- it's not a great fit for asynchronous stuff like notifications (at least a simple version built directly from cli.py)
- we'd end up needing some flow control and/or transfer of values at some point, and it will evolve into a full blown DSL

Quoted 32 lines
Quoted 15 lines
Quoted 15 lines

OR

{
     "yaml-specs-path": "/<path-to>/linux/Documentation/netlink/specs",
     "spec-args": {
         "ethtool.yaml": {
             "subscribe": "monitor",
             "sleep": 10
         },
         "netdev.yaml": {
             "subscribe": "mgmt",
             "sleep": 5
         }
     }
}  
Quoted 2 lines

Could you also share the outputs the examples would produce?

Right now the output is simple, an example would be for the first config in the email:

[ linux]# ./tools/net/ynl/cli.py --config ./tools/net/ynl/multi-do.json ###############  ethtool.yaml  ###############

{'header': {'dev-index': 3, 'dev-name': 'eno1'},
 'rx': 512,
 'rx-max': 8192,
 'rx-push': 0,
 'tx': 512,
 'tx-max': 8192,
 'tx-push': 0}
###############  netdev.yaml  ###############

Quoted 1 line

{'ifindex': 3, 'xdp-features': {'xsk-zerocopy', 'redirect', 'basic'}}

My concern was that this will not be optimal for the receiver to parse. Because the answer is not valid JSON. We'd need something like:

[
{ "cmd-id": "some-identifier?".
"response": { ... }
},
{ "cmd-id": "identifier-of-second-command".
"response": { ... }
}
]

Quoted 17 lines

Or for the second config in the email (note: I just toggled the tx ring descriptors on one of my NICs to trigger an ethtool notification):

[root@nfvsdn-06 linux]# ./tools/net/ynl/cli.py --config ./tools/net/ynl/multi-ntf.json
###############  ethtool.yaml  ###############

[{'msg': {'header': {'dev-index': 3, 'dev-name': 'eno1'},
          'rx': 512,
          'rx-max': 8192,
          'rx-push': 0,
          'tx': 8192,
          'tx-max': 8192,
          'tx-push': 0},
  'name': 'rings-ntf'}]
###############  netdev.yaml  ###############

Quoted 8 lines

[]

At the moment (even with these changes) YNL subscribes-sleeps-checks for notification for each family sequentially...
I will be looking into enabling an agent like behaviour: subscribe to notifications from multiple families and monitor (babysteps)....

[1] https://opiproject.org/

Modulo the nits it sounds fairly reasonable. Main question is how much of that we put in the kernel tree, and how much lives elsewhere :S If we have a dependency on gRPC at some point, for example, that may be too much for kernel tools/

#7 lore raw
Quoted 25 lines · Jakub Kicinski
Quoted 24 lines · On Fri, 28 Jul 2023 11:24:51 +0100 Maryam Tahhan wrote:
Quoted 9 lines · Jakub Kicinski
Quoted 4 lines · On Thu, 27 Jul 2023 08:03:29 -0400 Maryam Tahhan wrote:

Use a json configuration file to pass parameters to ynl to allow for operations on multiple specs in one go. Additionally, check this new configuration against a schema to validate it in the cli module before parsing it and passing info to the ynl module.

Interesting. Is this related to Donald's comments about subscribing to notifications from multiple families?

Can you share some info about your use case?

Yes it's related. We are working towards using YNL as a netlink agent or part of a netlink agent that's driven by YAML specs. We are

trying to enable existing Kubernetes CNIs to integrate with DPUs via an OPI [1] API without having to change these existing CNIs. In several

cases these CNIs program the Kernel as both the control plane and the fallback dataplane (for packets the DPU accelerator doesn't know what to do with). And so being able to monitor netlink state and reflect it to the DPU accelerator (and vice versa) via an OPI API would be extremely useful.

Quoted 7 lines
Quoted 3 lines

We think the YAML part gives us a solid model that showcases the breadth of what these CNIs program (via netlink) as well as a base for the grpc protobufs that the OPI API would like to define/use.

So agent on the host is listening to netlink and sending to DPU gRPC requests? From what you're describing it sounds like you'd mostly want to pass the notifications. The multi-command thing is to let the DPU also make requests if it needs to do/know something specific?

Yes, this is pretty much the idea.

Quoted 32 lines
Quoted 32 lines
Quoted 22 lines
Quoted 14 lines

Example configs would be:

{
      "yaml-specs-path": "/<path-to>/linux/Documentation/netlink/specs",
      "spec-args": {
          "ethtool.yaml": {
              "do": "rings-get",
              "json-params": {
                  "header": {
                      "dev-name": "eno1"
                  }
              }
          },
Quoted 8 lines
         "netdev.yaml": {
              "do": "dev-get",
              "json-params": {
              "ifindex": 3
              }
          }
      }
}
Quoted 3 lines

Why is the JSON preferable to writing a script to the same effect? It'd actually be shorter and more flexible.
Maybe we should focus on packaging YNL as a python lib?

I guess you can write a script. The reasons I picked JSON were mainly:

-  Simplicity and Readability for both developers and non-developers/users.

- With the JSON Schema Validation I could very quickly validate the incoming configuration without too much logic in cli.py.

Quoted 8 lines
Quoted 3 lines

- I thought of it as a stepping stone towards an agent configuration file if YNL evolves to provide or be part of a netlink agent (driven by yaml specs)...

Those are very valid. My worry is that:
- it's not a great fit for asynchronous stuff like notifications (at least a simple version built directly from cli.py)
- we'd end up needing some flow control and/or transfer of values at some point, and it will evolve into a full blown DSL

Ok, I can look at a script and see what this looks like.

Quoted 37 lines
Quoted 33 lines
Quoted 16 lines
Quoted 16 lines

OR

{
      "yaml-specs-path": "/<path-to>/linux/Documentation/netlink/specs",
      "spec-args": {
          "ethtool.yaml": {
              "subscribe": "monitor",
              "sleep": 10
          },
          "netdev.yaml": {
              "subscribe": "mgmt",
              "sleep": 5
          }
      }
}
Quoted 2 lines

Could you also share the outputs the examples would produce?

Right now the output is simple, an example would be for the first config in the email:

[ linux]# ./tools/net/ynl/cli.py --config ./tools/net/ynl/multi-do.json ###############  ethtool.yaml  ###############

{'header': {'dev-index': 3, 'dev-name': 'eno1'},
 'rx': 512,
 'rx-max': 8192,
 'rx-push': 0,
 'tx': 512,
 'tx-max': 8192,
 'tx-push': 0}
###############  netdev.yaml  ###############

Quoted 1 line

{'ifindex': 3, 'xdp-features': {'xsk-zerocopy', 'redirect', 'basic'}}

My concern was that this will not be optimal for the receiver to parse. Because the answer is not valid JSON. We'd need something like:

Quoted 9 lines

[
{ "cmd-id": "some-identifier?".

    "response": { ... }
  },
  { "cmd-id": "identifier-of-second-command".
    "response": { ... }

}
]

Yeah - makes sense. I was only focused on the configuration part for this patchset. This can be added.

Quoted 24 lines
Quoted 24 lines

Or for the second config in the email (note: I just toggled the tx ring descriptors on one of my NICs to trigger an ethtool notification):

[root@nfvsdn-06 linux]# ./tools/net/ynl/cli.py --config ./tools/net/ynl/multi-ntf.json
###############  ethtool.yaml  ###############

[{'msg': {'header': {'dev-index': 3, 'dev-name': 'eno1'},
          'rx': 512,
          'rx-max': 8192,
          'rx-push': 0,
          'tx': 8192,
          'tx-max': 8192,
          'tx-push': 0},
  'name': 'rings-ntf'}]
###############  netdev.yaml  ###############

[]

At the moment (even with these changes) YNL subscribes-sleeps-checks for notification for each family sequentially...
I will be looking into enabling an agent like behaviour: subscribe to notifications from multiple families and monitor (babysteps)....

Quoted 5 lines
Quoted 1 line

[1] https://opiproject.org/

Modulo the nits it sounds fairly reasonable. Main question is how much of that we put in the kernel tree, and how much lives elsewhere :S If we have a dependency on gRPC at some point, for example, that may be too much for kernel tools/

Yeah, that's a fair question. We would like to get all the gRPC stuff into the OPI repos. In the Kernel tree we'd like to get the netlink

agent and the YAML specs.

Thanks for the feedback. I will take it onboard.

Quoted 1 line