The varnish-agent2 existing code base is pretty solid, rather beautiful I might add. These simple words, keep it simple, has been realised by the following rule of thumb.
– Close to 0 configuration
– “Just works”
For those that are keen to get started on the varnish-agent2 code base, I hope that this document will be of some use. I have used a tiny subset of the Concurrent Object Modeling and architectural design mEThod (COMET), particularly the Requirements Modeling, Analysis Modeling and snippets of the actual Design Model.
Lastly, this document mostly serves as a mental note for myself 🙂
The requirement for the vagent2 is to provide an extendible restful interface for varnish cache. In addition, vagent2 act as the point of integration for varnish cache with other systems – e.g. an administrative or monitoring system.
The use cases are simple right now, and is depicted in the use case diagram below.
vagent2 is designed to support the full spectrum of HTTP method types. A user of the vagent2 will issue these HTTP requests and receive JSON data as response where applicable. Furthermore, the vagent2 is built with modules in mind to address a potentially expanding feature set. Lastly, each modules should be able to communicate and reused by another module.
IPC lies at the heart of the varnish-agent2 code base and message passing is the norm here for implementing an event driven model. Each module follows vagent2’s plugin paradigm, and comes equipped with the module’s own private data set. The plugin therefore follows the IPC set of callback methods, such as
ipc_run. These methods are assigned to the appropriate functions within each module.
For the module to be exposed as a restful interface, a simple
httpd_register method will hook in the module’s reply method of choice, and expose it appropriately.
For any module, the basic dependencies is depicted below.
varnish-agent2 ships with a few core modules, such as the logger, shmlog access, httpd and ipc modules. vstatus and vadmin provides access to the shmlog via Varnish API. Note that as of writing this blog, varnish 3.0.3 was used.
These aforementioned modules provide the building blocks for managing varnish cache. For an overview of the static models, see the class diagram below.
The process of initialising a module is rather straightforward. First, add a new init method for the new module in
plugins.h, ensure that you have called the init method in
main.c, and of course, allocated some memory for the new plugin in
This new module must provide an implementation of the new init method. See diagram below depicting vban’s initialisation process.
Once initialised, by hooking onto
struct agent_plugin* structure, the new module will correspond to the IPC life cycle.
plugin->start = ipc_start;
plugin->ipc->priv = your_private_plugin_data;
plugin->ipc->cb = your_plugin_callback;
plugin->start is called when your plugin starts. Note that you need to assign a start method if you want the IPC to execute your callback.
plug->ipc->priv refers to a persisted data for your plugin. This can be anything, and as a rule of thumb, this is a good place to hold references to other modules.
plug->ipc-cb refers to the callback method of when ipc_run is issued by another module.
A sample execution path
To tie it all together, the collaboration diagram below illustrate the execution path of issuing a ban to the vagent2. Note that ipc is used to reach the vadmin module.