There this three types of functions which as class can have:

• "normal" when the first argument is "self"
• classmethod (using the @classmethod decorator before the function). In that case self replaced from an instance of the class by a reference to the class itself (often called cls, in that case InterfaceClass)
• staticmethod (where the function does not need class data and is jus placed under the class) can be called with InterfaceClass.func()

get_dict() should be a classmethod.

Also get_dict should take care of the deepcopy and should be config = InterfaceClass.get_dict()

The recent change in implementation have changed the code from "if/else" to data-driven.
For example, every class now has a "definition" dictionary which indicates what the interface can/cannot do, for example, be bonded or not or it it supports vlan.

It will allow to change code like in list_interface.py from:

elif args.broadcast:
    eth = Interface.listing("ethernet")
    bridge = Interface.listing("bridge")
    bond = Interface.listing("bonding")
    interfaces = eth + bridge + bond

where listing is already a class method of Interface returning the name of the interface under that the named section.
(off-topic, the name should be surely changed from Interface.listing to Interface.section for clarity)

It should lead to something like a "get_capability" classmethod on the Interface class returning for all the classes which are matching a particular attribute.

Then it can lead to something like (not implemented - example)

interfaces = []
for name Interface.get_capablity("broadcast"):  # returns the name/type of the interfaces which can bond (ethernet, dummy, ...)
    interfaces.append(Interface.interfaces(name))  # returns the name of the router interfaces of that type (eth0, dum1)

with no risk of new interface being added without the list_interface missing them.

This is made possible by having all the sub-classes of Interface to "register" (see @Interface.register decorator at the top of the class)

When a dictionary is defined with a parent class and not re-defined by the children, the dict is in effect the same (vs a dict created in init where the value is per instance)

class Parent:
  shared = {}

class Child(Parent):
   pass

Parent and Child then share the "shared" a dictionary.

from vyos.ifconfig import *
EthernetIf._prefixes is DummyIf._prefixes
True

Regarding the reference counter for changes. It can also be implemented by storing in an Interface specific class level dictionary the last know state of the interface.
However, should multiple instances of the class be run by multiple programs then this could become problematic and this limitation should be kept in mind.

There is an issue with storing the state of the interface and then applying it in bulk. For some interface we want to admin it down before performing change and then bringing it back up.
If we store this then only the change and the up command will be applied, this is not going to work.

We could however load the interface state for the field we can get from operational command and then only run then if they do not perform a NOP.
It will remove a few system calls to the OS ( ip link ..), which probably have no effect anyway.

The current behaviour whilst "heavier" has the benefit of getting the interface fully re-setup which is a good thing and could prevent hard to find bugs.

with T2238 interface can be listed using their feature definition (broadcast, bonding, bridge ...).