IP Router Interface

Library for the ip-router integration

This library contains the Requires and Provides classes for interactions through the ip-router interface

Getting Started

From a charm directory, fetch the library using charmcraft:

charmcraft fetch-lib charms.ip_router_interface.v0.ip_router_interface

Provider charm

This example provider charm is all we need to listen to ip-router requirer requests. The ip-router provider fulfills the routing function for multiple charms that are requirers of the ip-router interface. For that reason, this charm will continuously track and update all of the connected requirers and the networks and routes they've requested, which it does in a routing table. As new charms are connected and disconnected to the relation, this routing table is automatically adds and removes the dependent networks.

The library handles the listening and synchronization for all of the ip-router network requests internally, which means as the charm author you don't need to worry about any of the business logic of validating or orchestrating the relation network.

You can also listen to the routing_table_updated event that is emitted after the tables are synced.

import logging, json
import ops
from charms.ip_router_interface.v0.ip_router_interface import *

class SimpleIPRouteProviderCharm(ops.CharmBase):

    def __init__(self, *args):
        super().__init__(*args)
        self.RouterProvider = RouterProvides(charm=self)
        self.framework.observe(self.on.install, self._on_install)
        self.framework.observe(self.RouterProvider.on.routing_table_updated, self._routing_table_updated)
        self.framework.observe(self.on.get_routing_table_action, self._action_get_routing_table)

    def _on_install(self, event: ops.InstallEvent):
        self.unit.status = ops.ActiveStatus("Ready to Provide")

    def _routing_table_updated(self, event: RoutingTableUpdatedEvent):
        routing_table = event.routing_table

        # Process the networks however you like
        implement_networks(all_networks)
        
        
    def _action_get_routing_table(self, event: ops.ActionEvent):
        all_networks = self.RouterProvider.get_flattened_routing_table()
        event.set_results({"msg": json.dumps(all_networks)})
    


if __name__ == "__main__":  # pragma: nocover
    ops.main(SimpleIPRouteProviderCharm)  # type: ignore

Requirer charm

This example requirer charm shows the two available actions as a host in the network:

• get the latest list of all networks available from the provider
• request a network to be assigned to the requirer charm

The ip-router requirer allows a foolproof, typechecked, secure and safe way to interact with the router that handles validation and format of the network request, so you can focus on more important things. The library also provides a way to list out all of the available networks. This list is not cached, and comes directly from the provider.

import logging, json
import ops

from charms.ip_router_interface.v0.ip_router_interface import *

class SimpleIPRouteRequirerCharm(ops.CharmBase):

    def __init__(self, *args):
        super().__init__(*args)
        self.RouterRequirer = RouterRequires(charm=self)
        self.framework.observe(self.on.install, self._on_install)
        self.framework.observe(self.on.ip_router_relation_joined, self._on_relation_joined)
        self.framework.observe(self.RouterProvider.on.routing_table_updated, self._routing_table_updated)

        self.framework.observe(self.on.get_all_networks_action, self._action_get_all_networks)
        self.framework.observe(self.on.request_network_action, self._action_request_network)

    def _on_install(self, event: ops.InstallEvent):
        self.unit.status = ops.ActiveStatus("Ready to Provide")

    def _on_relation_joined(self, event: ops.RelationJoinedEvent):
        self.unit.status = ops.ActiveStatus("Ready to Require")

    def _routing_table_updated(self, event: RoutingTableUpdatedEvent):
        # Get and process all of the available networks when they're updated
        all_networks = self.RouterRequirer.get_all_networks()

    def _action_get_all_networks(self, event: ops.ActionEvent):
        # Get and process all of the available networks any time you like
        all_networks = self.RouterRequirer.get_all_networks()
        event.set_results({"msg": json.dumps(all_networks)})

    def _action_request_network(self, event: ops.ActionEvent):
        # Request a new network as required in the required format
        self.RouterRequirer.request_network(event.params["network"])

        event.set_results({"msg": "ok"})


if __name__ == "__main__":  # pragma: nocover
    ops.main.main(SimpleIPRouteRequirerCharm)  # type: ignore

You can relate both charms by running:

juju integrate <ip-router provider charm> <ip-router requirer charm>