Our research on the Knowledge Plane

The Knowledge Plane is the core of the architecture. It contains the digital representation of the world. Every entity (device, service) that wants to profit from our new control and management architecture has to connect to the knowledge plane. This happens via the Knowledge Agent (KA).

The Knowledge Agent provides a unified interface that can handle Knowledge Objects. It provides only a limited amount of functions and mechanisms. This distinguishes it from many classical agent systems. We only want to provide the minimum amount of functionality inside the agent. This limitation is the base for the compatibility of all elements inside the platform as seen in Fig. 2.

Fig. 3: Knowledge Agents connectors to content-centric knowledge overlay.

The Knowledge Agent is the node's logical communication endpoint for everything concerning the knowledge overlay. If data from other nodes has to be retrieved this happens by requesting the data at the local agent. The agent will retrieve the data then and deliver it to the inquirer. The addressing of the data is done via XPath. The data exchange format is XML based. As container we use SOAP.

The platform supports subscriptions, publications (with data) and notifications (without data). This enables us to handle asynchronous as well as synchronous* (only limited as the platform is autonomic) interaction.

The Knowledge Agent is the entity that publishes the model of the local device (with its available services). It takes care of updating its local model as well as the information which remote data is available where.

The Knowledge Agent uses a Knowledge Store to store its (the node's) data. The Knowledge Store can be realized in different ways like a text file or a database as it fits best to the resources of the node.

The Knowledge Agents are addressed via their public keys. Automatic key verifications authenticate the communicating entities. The KAs also enforce the security policies. Transport security over encryption is also realized inside the Knowledge Agent.

The Knowledge agents organize themselves autonomously. Also the data replication takes place without user interaction.

Unified Data Representation

Another key of our architecture is the unified data representation. They are also XML based. We have a hierarchy of different abstraction layers of representations.

The uppermost layer contains the so-called models:

          model ::= (leaf | model)+ modelContext
        

Models contain the common denominator between objects of a class. A model could be a switch port or a generic router. Models can aggregate other models.

The next level is the prototype. A prototype is a specific device like Toaster XYZ. In contrast to the model it contains already data like the vendor string.

      prototype ::= (model' | leaf)+ objectContext
    

Both hierarchy class representatives above are stored globally on a server.

When a device is installed inside a house an instance of a prototype is instantiated. This is done automatically via the Knowledge Agent. Through the models the Knowledge Agent performs integrity checks (syntax) of the local information automatically.

The instanciated prototype is called object.

      object ::= (model~ | prototype~) objectContext
    

The contexts above contain access information etc. Additionally to the ones named we have a system context that contains information about the running ACMP as a whole.

Fig. 4: Hierachical data representation structure.

The models already define the basic interaction possibilities of the device. This is important for services as they want to interact with the devices.

For a service it is enough to know the model it wants to interact with. The model might be "heater" and it might contain a field "desired temperature". As service author I only have to provide to my Knowledge Agent "Give me all heater.desired_temperature" and I can talk to all heaters inside a house.

Great abstraction...
developing applications for the ACMP gets almost easier as with the iPhone :)

Using Addressing for Authentication

A Knowledge Overlay for Autonomous Network management

A Reliable Scalable Secure Knowledge-Distribution Overlay

Support Mechanisms for Model Creation