From 99fb10ecca6b1679c1fe402508216c0f82140ef5 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Jos=C3=A9=20Bollo?= Date: Fri, 16 Sep 2016 18:47:57 +0200 Subject: [PATCH] Improvement of the documentation MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Change-Id: I8f220d7508d939a16eba956ab1fdf975f4048332 Signed-off-by: JosÃ© Bollo --- doc/FAQ.html | 4 +- doc/afb-application-writing.html | 56 +++-- doc/afb-bindings-overview.html | 4 +- doc/afb-bindings-writing.html | 176 ++++++++------- doc/afb-daemon-vocabulary.html | 4 +- doc/afb-events-guide.html | 279 ++++++++++++++++++++++++ doc/afb-events-guide.md | 449 +++++++++++++++++++++++++++++++++++++++ doc/afb-overview.html | 4 +- doc/afb-tests-overview.html | 4 +- doc/doc.css | 3 + 10 files changed, 879 insertions(+), 104 deletions(-) create mode 100644 doc/afb-events-guide.html create mode 100644 doc/afb-events-guide.md diff --git a/doc/FAQ.html b/doc/FAQ.html index 5cc8b653..f3584e0e 100644 --- a/doc/FAQ.html +++ b/doc/FAQ.html @@ -7,10 +7,10 @@ Frequently Asked Question about AFB-DAEMON + -

diff --git a/doc/afb-application-writing.html b/doc/afb-application-writing.html index 12a2f13f..9d051d5e 100644 --- a/doc/afb-application-writing.html +++ b/doc/afb-application-writing.html @@ -8,29 +8,47 @@ HOWTO WRITE an APPLICATION above AGL FRAMEWORK - +

@@ -184,7 +202,7 @@ ON-REPLY 1:auth/check: {"jtype":"afb-reply","request&qu

This object contains at least 2 mandatory fields of name jtype and request and one optional field of name response.

Template

This is a template of replies:

{
+{
    "jtype": "afb-reply",
    "request": {
       "status": "success",
@@ -194,7 +212,7 @@ ON-REPLY 1:auth/check: {"jtype":"afb-reply","request&qu
       "reqid": "application-generated-id-23456"
    },
    "response": ....any response object....
-}
+}

Field jtype

The field jtype must have a value of type string equal to "afb-reply".

Field request

@@ -216,11 +234,11 @@ ON-REPLY 1:auth/check: {"jtype":"afb-reply","request&qu

This object contains at least 2 mandatory fields of name jtype and event and one optional field of name data.

Template

Here is a template of event:

{
+{
    "jtype": "afb-event",
    "event": "sample_api_name/sample_event_name",
    "data": ...any event data...
-}
+}

Field jtype

The field jtype must have a value of type string equal to "afb-event".

Field event

diff --git a/doc/afb-bindings-overview.html b/doc/afb-bindings-overview.html index b650860c..0ffc769a 100644 --- a/doc/afb-bindings-overview.html +++ b/doc/afb-bindings-overview.html @@ -7,10 +7,10 @@ Overview of bindings shipped with AFB-Daemon + -

diff --git a/doc/afb-bindings-writing.html b/doc/afb-bindings-writing.html index b32912b6..ea03801f 100644 --- a/doc/afb-bindings-writing.html +++ b/doc/afb-bindings-writing.html @@ -7,35 +7,53 @@ HOWTO WRITE a BINDING for AFB-DAEMON - +

HOWTO WRITE a BINDING for AFB-DAEMON

JosÃ© Bollo

24 juin 2016

27 juillet 2016

Header files to include

Binding tictactoe has following includes:

#define _GNU_SOURCE
+#define _GNU_SOURCE
 #include <stdio.h>
 #include <string.h>
 #include <json-c/json.h>
-#include <afb/afb-binding.h>
+#include <afb/afb-binding.h>

Header afb/afb-binding.h is the only hard dependency, it includes all features that a binding MUST HAVE. Outside of includes used to support application logic, common external headers used within bindings are:

json-c/json.h: should be include to handle json objects;

It is a good practice, even for arguments not to rely on case sensitivity. This may reduce headache strength at debug time, especially with interpreted language like javascript that may not warn you that a variable was not defined.

Writing a synchronous method implementation

The method tictactoe/board is a synchronous implementation. Here is its listing:

/*
+/*
  * get the board
  */
 static void board(struct afb_req req)
@@ -213,7 +231,7 @@ code > span.er { color: #ff0000; font-weight: bold; }
 
     /* send the board's description */
     afb_req_success(req, description, NULL);
-}
+}

This example shows many aspects of a synchronous method implementation. Let summarise it:

The function board_of_req retrieves the context stored for the binding: the board.

Note that this is a PLAIN structure, not a pointer to a structure.

The definition of struct afb_req is:

/*
+/*
  * Describes the request by bindings from afb-daemon
  */
 struct afb_req {
     const struct afb_req_itf *itf;  /* the interfacing functions */
     void *closure;          /* the closure for functions */
-};
+};

It contains two pointers: first one itf, points to functions used to handle internal request. Second one closure point onto function closure.

The structure must never be used directly. Instead developer should use the intended functions provided by afb-daemon as described here after.
@@ -255,16 +273,16 @@ code > span.er { color: #ff0000; font-weight: bold; }
afb_req_context_clear: reset the stored context data.

The binding tictactoe use a convenient function to retrieve its context: the board. This function is board_of_req:

/*
+/*
  * retrieves the board of the request
  */
 static inline struct board *board_of_req(struct afb_req req)
 {
     return afb_req_context(req, (void*)get_new_board, (void*)release_board);
-}
+}

The function afb_req_context ensures an existing context for the session of the request. Its two last arguments are functions to allocate and free context. Note function type casts to avoid compilation warnings.

Here is the definition of the function afb_req_context

/*
+/*
  * Gets the pointer stored by the binding for the session of 'req'.
  * If the stored pointer is NULL, indicating that no pointer was
  * already stored, afb_req_context creates a new context by calling
@@ -279,11 +297,11 @@ code > span.er { color: #ff0000; font-weight: bold; }
         afb_req_context_set(req, result, free_context);
     }
     return result;
-}
+}

The second argument if the function that creates the context. For binding tic-tac-toe (function get_new_board). The function get_new_board creates a new board and set usage its count to 1. The boards are checking usage count to free resources when not used.

The third argument is a function that frees context resources. For binding tic-tac-toe (function release_board). The function release_board decrease usage count of the board passed in argument. When usage count falls to zero, data board are freed.

Definition of other functions dealing with contexts:

/*
+/*
  * Gets the pointer stored by the binding for the session of 'req'.
  * When the binding has not yet recorded a pointer, NULL is returned.
  */
@@ -305,14 +323,14 @@ code > span.er { color: #ff0000; font-weight: bold; }
 static inline void afb_req_context_clear(struct afb_req req)
 {
     afb_req_context_set(req, NULL, NULL);
-}
+}

Sending reply to a request

Two kinds of replies: successful or failure.

Sending a reply to a request MUST be done once and only once.

It exists two functions for "success" replies: afb_req_success and afb_req_success_f.

/*
+/*
  * Sends a reply of kind success to the request 'req'.
  * The status of the reply is automatically set to "success".
  * Its send the object 'obj' (can be NULL) with an
@@ -332,9 +350,9 @@ code > span.er { color: #ff0000; font-weight: bold; }
  * Thus, in the case where 'obj' should remain available after
  * the function returns, the function 'json_object_get' shall be used.
  */
-void afb_req_success_f(struct afb_req req, struct json_object *obj, const char *info, ...);
+void afb_req_success_f(struct afb_req req, struct json_object *obj, const char *info, ...);

It exists two functions for "failure" replies: afb_req_fail and afb_req_fail_f.

/*
+/*
  * Sends a reply of kind failure to the request 'req'.
  * The status of the reply is set to 'status' and an
  * informational comment 'info' (can also be NULL) can be added.
@@ -357,7 +375,7 @@ code > span.er { color: #ff0000; font-weight: bold; }
  * Thus, in the case where 'obj' should remain available after
  * the function returns, the function 'json_object_get' shall be used.
  */
-void afb_req_fail_f(struct afb_req req, const char *status, const char *info, ...);
+void afb_req_fail_f(struct afb_req req, const char *status, const char *info, ...);

For convenience, these functions automatically call json_object_put to release obj. Because obj usage count is null after being passed to a reply function, it SHOULD not be used anymore. If exceptionally obj needs to remain usable after reply function then using json_object_get on obj to increase usage count and cancels the effect the json_object_put is possible.

Many methods expect arguments. Afb-daemon's bindings retrieve arguments by name and not by position.

Arguments are passed by requests through either HTTP or WebSockets.

For example, the method join of binding tic-tac-toe expects one argument: the boardid to join. Here is an extract:

/*
+/*
  * Join a board
  */
 static void join(struct afb_req req)
@@ -381,14 +399,14 @@ code > span.er { color: #ff0000; font-weight: bold; }
     id = afb_req_value(req, "boardid");
     if (id == NULL)
         goto bad_request;
-    ...
+    ...

The function afb_req_value searches in the request req for argument name passed in the second argument. When argument name is not passed, afb_req_value returns NULL.

The search is case sensitive and boardid is not equivalent to BoardId. Nevertheless having argument names that only differ by name case is not a good idea.

Basic functions for querying arguments

The function afb_req_value is defined here after:

/*
+/*
  * Gets from the request 'req' the string value of the argument of 'name'.
  * Returns NULL if when there is no argument of 'name'.
  * Returns the value of the argument of 'name' otherwise.
@@ -398,9 +416,9 @@ code > span.er { color: #ff0000; font-weight: bold; }
 static inline const char *afb_req_value(struct afb_req req, const char *name)
 {
     return afb_req_get(req, name).value;
-}
+}

It is defined as a shortcut to call the function afb_req_get. That function is defined here after:

/*
+/*
  * Gets from the request 'req' the argument of 'name'.
  * Returns a PLAIN structure of type 'struct afb_arg'.
  * When the argument of 'name' is not found, all fields of result are set to NULL.
@@ -412,11 +430,11 @@ code > span.er { color: #ff0000; font-weight: bold; }
  * an HTTP POST of Content-Type "application/json". In that case, the
  * argument of name "" receives the value of the body of the HTTP request.
  */
-struct afb_arg afb_req_get(struct afb_req req, const char *name);
+struct afb_arg afb_req_get(struct afb_req req, const char *name);

That function takes 2 parameters: the request and the name of the argument to retrieve. It returns a PLAIN structure of type struct afb_arg.

There is a special name that is defined when the request is of type HTTP/POST with a Content-Type being application/json. This name is "" (the empty string). In that case, the value of this argument of empty name is the string received as a body of the post and is supposed to be a JSON string.

The definition of struct afb_arg is:

/*
+/*
  * Describes an argument (or parameter) of a request
  */
 struct afb_arg {
@@ -425,9 +443,9 @@ code > span.er { color: #ff0000; font-weight: bold; }
                 /* original filename of the argument if path != NULL */
     const char *path;   /* if not NULL, path of the received file for the argument */
                 /* when the request is finalized this file is removed */
-};
+};

The structure returns the data arguments that are known for the request. This data include a field named path. This path can be accessed using the function afb_req_path defined here after:

/*
+/*
  * Gets from the request 'req' the path for file attached to the argument of 'name'.
  * Returns NULL if when there is no argument of 'name' or when there is no file.
  * Returns the path of the argument of 'name' otherwise.
@@ -437,29 +455,29 @@ code > span.er { color: #ff0000; font-weight: bold; }
 static inline const char *afb_req_path(struct afb_req req, const char *name)
 {
     return afb_req_get(req, name).path;
-}
+}

The path is only defined for HTTP/POST requests that send file.

Arguments for received files

As it is explained above, clients can send files using HTTP/POST requests.

Received files are attached to "file" argument name. For example, the following HTTP fragment (from test/sample-post.html) will send an HTTP/POST request to the method post/upload-image with 2 arguments named file and hidden.

<h2>Sample Post File</h2>
+<h2>Sample Post File</h2>
 <form enctype="multipart/form-data">
     <input type="file" name="file" />
     <input type="hidden" name="hidden" value="bollobollo" />
     <br>
     <button formmethod="POST" formaction="api/post/upload-image">Post File</button>
-</form>
+</form>

Argument named file should have both its value and path defined.

The value is the name of the file as it was set by the HTTP client. Generally it is the filename on client side.

The path is the effective path of saved file on the temporary local storage area of the application. This is a randomly generated and unique filename. It is not linked with the original filename as used on client side.

After success the binding can use the uploaded file directly from local storage path with no restriction: read, write, remove, copy, rename... Nevertheless when request reply is set and query terminated, the uploaded temporary file at path is destroyed.

Arguments as a JSON object

Bindings may also request every arguments of a given call as one single object. This feature is provided by the function afb_req_json defined here after:

/*
+/*
  * Gets from the request 'req' the json object hashing the arguments.
  * The returned object must not be released using 'json_object_put'.
  */
-struct json_object *afb_req_json(struct afb_req req);
+struct json_object *afb_req_json(struct afb_req req);

It returns a json object. This object depends on how the request was built:

For HTTP requests, this json object uses key names mapped on argument name. Values are either string for common arguments or object ie: { "file": "...", "path": "..." }
Afb-daemon checks that the returned version and name can be managed. If so, binding and its methods are register to become usable as soon as afb-daemon initialisation is finished.

Here after the code used for afbBindingV1Register from binding tic-tac-toe:

/*
+/*
  * activation function for registering the binding called by afb-daemon
  */
 const struct afb_binding *afbBindingV1Register(const struct afb_binding_interface *itf)
 {
    afbitf = itf;         // records the interface for accessing afb-daemon
    return &binding_description;  // returns the description of the binding
-}
+}

It is a very minimal initialisation function because tic-tac-toe binding doesn't have any application related initialisation step. It merely record daemon's interface and returns its description.

The variable afbitf is a binding global variable. It keeps the interface to afb-daemon that should be used for logging and pushing events. Here is its declaration:

/*
+/*
  * the interface to afb-daemon
  */
-const struct afb_binding_interface *afbitf;
+const struct afb_binding_interface *afbitf;

The description of the binding is defined here after.

/*
+/*
  * array of the methods exported to afb-daemon
  */
 static const struct afb_verb_desc_v1 binding_methods[] = {
@@ -525,7 +543,7 @@ code > span.er { color: #ff0000; font-weight: bold; }
       .info= "Sample tac-tac-toe game", /* short description of of the binding */
       .methods = binding_methods        /* the array describing the methods of the API */
    }
-};
+};

The structure binding_description describes the binding. It declares the type and version of the binding, its name, a short description and its methods list.

The list of methods is an array of structures describing the methods and terminated by a NULL marker.

In version one of afb-damon binding, a method description contains 4 fields:

a short description.

The structure describing methods is defined as follows:

/*
+/*
  * Description of one method of the API provided by the binding
  * This enumeration is valid for bindings of type 1
  */
@@ -546,10 +564,14 @@ code > span.er { color: #ff0000; font-weight: bold; }
        enum AFB_session_v1 session;            /* authorisation and session requirements of the method */
        void (*callback)(struct afb_req req);   /* callback function implementing the method */
        const char *info;                       /* textual description of the method */
-};
+};

For technical reasons, the enumeration enum AFB_session_v1 is not exactly an enumeration but the wrapper of constant definitions that can be mixed using bitwise or (the C operator |).

The constants that can bit mixed are:

Constant name

You can note that the 2 methods WARNING and INFO have the same level of verbosity. But they don't have the same syslog level. It means that they are output with a different level on the logging system.

All of these methods have the same signature:

void ERROR(const struct afb_binding_interface *afbitf, const char *message, ...);

void ERROR(const struct afb_binding_interface *afbitf, const char *message, ...);

The first argument afbitf is the interface to afb daemon that the binding received at initialisation time when afbBindingV1Register is called.

The second argument message is a formatting string compatible with printf/sprintf.

The remaining arguments are arguments of the formating message like with printf.

Sending events

Since version 0.5, bindings can broadcast events to any potential listener. As today only unattended even are supported. Targeted events are expected for next coming version.

The binding tic-tac-toe broadcasts events when the board changes. This is done in the function changed:

/*
+/*
  * signals a change of the board
  */
 static void changed(struct board *board, const char *reason)
@@ -772,11 +794,11 @@ code > span.er { color: #ff0000; font-weight: bold; }
     ...
 
     afb_daemon_broadcast_event(afbitf->daemon, reason, description);
-}
+}

The description of the changed board is pushed via the daemon interface.

Within binding tic-tac-toe, reason indicates the origin of the change. In function afb_daemon_broadcast_event the second parameter is the name of broadcasted event. The third argument is the object that is transmitted with the event.

Function afb_daemon_broadcast_event is defined here after:

/*
+/*
  * Broadcasts widely the event of 'name' with the data 'object'.
  * 'object' can be NULL.
  * 'daemon' MUST be the daemon given in interface when activating the binding.
@@ -785,7 +807,7 @@ code > span.er { color: #ff0000; font-weight: bold; }
  * Thus, in the case where 'object' should remain available after
  * the function returns, the function 'json_object_get' shall be used.
  */
-void afb_daemon_broadcast_event(struct afb_daemon daemon, const char *name, struct json_object *object);
+void afb_daemon_broadcast_event(struct afb_daemon daemon, const char *name, struct json_object *object);

Be aware, as with reply functions object is automatically released using json_object_put when using this function. Call json_object_get before calling afb_daemon_broadcast_event to keep object available after function returns.

Here, this is an invocation of the binding by an other client that unblock the suspended wait call. Nevertheless in most case this should be a timer, a hardware event, a sync with a concurrent process or thread, ...

Common case of an asynchronous implementation.

Here is the listing of the function wait:

static void wait(struct afb_req req)
+static void wait(struct afb_req req)
 {
     struct board *board;
     struct waiter *waiter;
@@ -827,7 +849,7 @@ code > span.er { color: #ff0000; font-weight: bold; }
     waiter->next = board->waiters;
     afb_req_addref(req);
     board->waiters = waiter;
-}
+}

After retrieving the board, the function adds a new waiter to waiters list and returns without setting a reply.

Before returning, it increases req request's reference count using afb_req_addref function.

@@ -835,7 +857,7 @@ code > span.er { color: #ff0000; font-weight: bold; }

Later, when a board changes, it calls tic-tac-toe changed function with reason of change in parameter.

Here is the full listing of the function changed:

/*
+/*
  * signals a change of the board
  */
 static void changed(struct board *board, const char *reason)
@@ -857,18 +879,18 @@ code > span.er { color: #ff0000; font-weight: bold; }
     }
 
     afb_event_sender_push(afb_daemon_get_event_sender(afbitf->daemon), reason, description);
-}
+}

The list of waiters is walked and a reply is sent to each waiter. After sending the reply, the reference count of the request is decremented using afb_req_unref to allow resources to be freed.

The reference count MUST be decremented using afb_req_unref to free resources and avoid memory leaks. This usage count decrement should happen AFTER setting reply or bad things may happen.

How to build a binding

Afb-daemon provides a pkg-config configuration file that can be queried by providing afb-daemon in command line arguments. This configuration file provides data that should be used for bindings compilation. Examples:

$ pkg-config --cflags afb-daemon
-$ pkg-config --libs afb-daemon

$ pkg-config --cflags afb-daemon
+$ pkg-config --libs afb-daemon

Example for cmake meta build system

This example is the extract for building the binding afm-main using CMAKE.

pkg_check_modules(afb afb-daemon)
+pkg_check_modules(afb afb-daemon)
 if(afb_FOUND)
     message(STATUS "Creation afm-main-binding for AFB-DAEMON")
     add_library(afm-main-binding MODULE afm-main-binding.c)
@@ -882,11 +904,15 @@ $ pkg-config --libs afb-daemon
     install(TARGETS afm-main-binding LIBRARY DESTINATION ${binding_dir})
 else()
     message(STATUS "Not creating the binding for AFB-DAEMON")
-endif()

endif

Let now describe some of these lines.

pkg_check_modules(afb afb-daemon)

pkg_check_modules(afb afb-daemon)

This first lines searches to the pkg-config configuration file for afb-daemon. Resulting data are stored in the following variables:

pkg-config

Variable

If development files are found, the binding can be added to the set of target to build.

add_library(afm-main-binding MODULE afm-main-binding.c)

add_library(afm-main-binding MODULE afm-main-binding.c)

This line asks to create a shared library having a single source file named afm-main-binding.c to be compiled. The default name of the created shared object is libafm-main-binding.so.

set_target_properties(afm-main-binding PROPERTIES
+set_target_properties(afm-main-binding PROPERTIES
     PREFIX ""
     LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/afm-main-binding.export-map"
-)
+)

This lines are doing two things:

It renames the built library from libafm-main-binding.so to afm-main-binding.so by removing the implicitly added prefix lib. This step is not mandatory because afb-daemon doesn't check names of files at load time. The only filename convention used by afb-daemon relates to .so termination. *.so pattern is used when afb-daemon automatically discovers binding from a directory hierarchy.
It applies a version script at link time to only export the reserved name afbBindingV1Register for registration entry point. By default, when building a shared library linker exports all the public symbols (C functions that are not static).

Next line are:

target_include_directories(afm-main-binding PRIVATE ${afb_INCLUDE_DIRS})
-target_link_libraries(afm-main-binding utils ${afb_LIBRARIES})

target_include_directories(afm-main-binding PRIVATE ${afb_INCLUDE_DIRS})
+target_link_libraries(afm-main-binding utils ${afb_LIBRARIES})

As you can see it uses the variables computed by pkg_check_modules(afb afb-daemon) to configure the compiler and the linker.

Exporting the function afbBindingV1Register

The function afbBindingV1Register MUST be exported. This can be achieved using a version script at link time. Here after is a version script used for tic-tac-toe (bindings/samples/export.map).

Vocabulary for AFB-DAEMON

diff --git a/doc/afb-events-guide.html b/doc/afb-events-guide.html new file mode 100644 index 00000000..aa606400 --- /dev/null +++ b/doc/afb-events-guide.html @@ -0,0 +1,279 @@ + + + + + + + + Guid for developing with events + + + + + + +

Guid for developing with events

JosÃ© Bollo

16 septembre 2016

+ +

Guid for developing with events

Signaling agents are services that send events to any clients that subscribed for receiving it. The sent events carry any data.

To have a good understanding of how to write a signaling agent, the actions of subscribing, unsubscribing, producing, sending, receiving events must be described and explained.

The basis of a signaling agent is shown on the following figure:

scenario of using events

+ +

This figure shows the main role of the signaling framework for the propagation of events.

For people not familiar with the framework, a signaling agent and a âbindingâ are similar.

Subscribing and unsubscribing

Subscribing and subscription is the action that makes a client able to receive data from a signaling agent. Subscription must create resources for generating the data and for delivering the data to the client. These two aspects are not handled by the same piece of software: generating the data is the responsibility of the developer of the signaling agent while delivering the data is handled by the framework.

When a client subscribes for data, the agent must:

check that the subscription request is correct;
establish the computation chain of the required data, if not already done;
create a named event for the computed data, if not already done;
ask the framework to establish the subscription to the event for the request;
optionally give indications about the event in the reply to the client.

The first two steps are not involving the framework. They are linked to the business logic of the binding. The request can be any description of the requested data and the computing stream can be of any nature, this is specific to the binding.

As said before, the framework uses and integrates âlibsystemdâ and its event loop. Within the framework, "libsystemd" is the standard API/library for bindings expecting to setup and handle I/O, timer or signal events.

Steps 3 and 4 are bound to the framework.

The agent must create an object for handling the propagation of produced data to its clients. That object is called âeventâ in the framework. An event has a name that allows clients to distinguish it from other events.

Events are created using the afb_daemon_make_event function that takes the name of the event. Example:

    event = afb_daemon_make_event(afb_daemon, name);

Once created, the event can be used either to push data to its subscribers or to broadcast data to any listener.

The event must be used to establish the subscription for the requesting client. This is done using the afb_req_subscribe function that takes the current request object and event and associates them together. Example:

    rc = afb_req_subscribe(afb_req, event);

When successful, this function make the connection between the event and the client that emitted the request. The client becomes a subscriber of the event until it unsubscribes or disconnects. The afb_req_subscribe function will fail if the client connection is weak: if the request comes from a HTTP link. To receive signals, the client must be connected. The AGL framework allows connections using WebSocket.

The name of the event is either a well known name or an ad hoc name forged for the usecase.

Let's see a basic example: client A expects to receive the speed in km/h every second while client B expects the speed in mph twice a second. In that case, there are two different events because it is not the same unit and it is not the same frequency. Having two different events allows to associate clients to the correct event. But this doesn't tell any word about the name of these events. The designer of the signaling agent has two options for naming:

names can be the same (âspeedâ for example) with sent data self-describing itself or having a specific tag (requiring from clients awareness about requesting both kinds of speed isn't safe).
names of the event include the variations (by example: âspeed-km/h-1Hzâ and âspeed-mph-2Hzâ) and, in that case, sent data can self-describe itself or not.

In both cases, the signaling agent might have to send the name of the event and/or an associated tag to its client in the reply of the subscription. This is part of the step 5 above.

The framework only uses the event (not its name) for subscription, unsubscription and pushing.

When the requested data is already generated and the event used for pushing it already exists, the signaling agent must not instantiate a new processing chain and must not create a new event object for pushing data. The signaling agent must reuse the existing chain and event.

Unsubscribing is made by the signaling agent on a request of its client. The afb_req_unsubscribe function tells the framework to remove the requesting client from the event's list of subscribers. Example:

    afb_req_unsubscribe(afb_req, event);

Subscription count does not matter to the framework: subscribing the same client several times has the same effect that subscribing only one time. Thus, when unsubscribing is invoked, it becomes immediately effective.

More on naming events

Within the AGL framework, a signaling agent is a binding that has an API prefix. This prefix is meant to be unique and to identify the binding API. The names of the events that this signaling agent creates are automatically prefixed by the framework, using the API prefix of the binding.

Thus, if a signaling agent of API prefix api creates an event of name event and pushes data to that event, the subscribers will receive an event of name api/event.

Generating and pushing signals and data

This of the responsibility of the designer of the signaling agent to establish the processing chain for generating events. In many cases, this can be achieved using I/O or timer or signal events inserted in the main loop. For this case, the AGL framework uses âlibsystemdâ and provide a way to integrates to the main loop of this library using afb_daemon_get_event_loop. Example:

    sdev = afb_daemon_get_event_loop(af_daemon);
+    rc = sd_event_add_io(sdev, &source, fd, EPOLLIN, myfunction, NULL);

In some other cases, the events are coming from D-Bus. In that case, the framework also uses âlibsystemdâ internally to access D-Bus. It provides two methods to get the available D-Bus objects, already existing and bound to the main libsystemd event loop. Use either afb_daemon_get_system_bus or afb_daemon_get_user_bus to get the required instance. Then use functions of âlibsystemdâ to handle D-Bus.

In some rare cases, the generation of the data requires to start a new thread.

When a data is generated and ready to be pushed, the signaling agent should call the function afb_event_push. Example:

    rc = afb_event_push(event, json);
+    if (rc == 0) {
+        stop_generating(event);
+        afb_event_drop(event);
+    }

The function afb_event_push pushes json data to all the subscribers. It then returns the count of subscribers. When the count is zero, there is no subscriber listening for the event. The example above shows that in that case, the signaling agent stops to generate data for the event and delete the event using afb_event_drop. This is one possible option. Other valuable options are: do nothing and continue to generate and push the event or just stop to generate and push the data but keep the event existing.

Receiving the signals

Understanding what a client expects when it receives signals, events or data shall be the most important topic of the designer of a signaling agent. The good point here is that because JSON¹ is the exchange format, structured data can be sent in a flexible way.

The good design is to allow as much as possible the client to describe what is needed with the goal to optimize the processing to the requirements only.

The exceptional case of wide broadcast

Some data or events have so much importance that they can be widely broadcasted to alert any listening client. Examples of such an alert are:

system is entering/leaving âpower safeâ mode
system is shutting down
the car starts/stops moving
...

An event can be broadcasted using one of the two following methods: afb_daemon_broadcast_event or afb_event_broadcast.

Example 1:

    afb_daemon_broadcast_event(afb_daemon, name, json);

Example 2:

    event = afb_daemon_make_event(afb_daemon, name);
+    . . . .
+    afb_event_broadcast(event, json);

As for other events, the name of events broadcasted using afb_daemon_broadcast_event are automatically prefixed by the framework with API prefix of the binding (signaling agent).

Reference of functions

Function afb_event afb_daemon_make_event

The function afb_daemon_make_event that is defined as below:

/*
+ * Creates an event of 'name' and returns it.
+ * 'daemon' MUST be the daemon given in interface when activating the binding.
+ */
+struct afb_event afb_daemon_make_event(struct afb_daemon daemon, const char *name);

The daemon is the handler to the application framework binder daemon received during initialisation steps of the binding.

Calling the function afb_daemon_make_event within the initialisation function afbBindingV1Register will fail because the plugin name is not known at this time.

The correct way to create the event at initialisation is to call the function afb_daemon_make_event within the initialisation function afbBindingV1ServiceInit.

Function afb_event_push

The function afb_event_push is defined as below:

/*
+ * Pushes the 'event' with the data 'object' to its observers.
+ * 'object' can be NULL.
+ *
+ * For convenience, the function calls 'json_object_put' for object'.
+ * Thus, in the case where 'object' should remain available after
+ * the function returns, the function 'json_object_get' shall be used.
+ *
+ * Returns the count of clients that received the event.
+ */
+int afb_event_push(struct afb_event event, struct json_object *object);

As the function afb_event_push returns 0 when there is no more subscriber, a binding can remove such unexpected event using the function afb_event_drop.

Function afb_event_drop

The function afb_event_drop is defined as below:

/*
+ * Drops the data associated to the event
+ * After calling this function, the event
+ * MUST NOT BE USED ANYMORE.
+ */
+void afb_event_drop(struct afb_event event);

Function afb_req_subscribe

The function afb_req_subscribe is defined as below:

/*
+ * Establishes for the client link identified by 'req' a subscription
+ * to the 'event'.
+ * Returns 0 in case of successful subscription or -1 in case of error.
+ */
+int afb_req_subscribe(struct afb_req req, struct afb_event event);

The subscription adds the client of the request to the list of subscribers to the event.

Function afb_req_unsubscribe

The function afb_req_unsubscribe is defined as below:

/*
+ * Revokes the subscription established to the 'event' for the client
+ * link identified by 'req'.
+ * Returns 0 in case of successful unsubscription or -1 in case of error.
+ */
+int afb_req_unsubscribe(struct afb_req req, struct afb_event event);

The unsubscription removes the client of the request of the list of subscribers to the event. When the list of subscribers to the event becomes empty, the function afb_event_push will return zero.

Function afb_event_broadcast

The function afb_event_broadcast is defined as below:

/*
+ * Broadcasts widely the 'event' with the data 'object'.
+ * 'object' can be NULL.
+ *
+ * For convenience, the function calls 'json_object_put' for 'object'.
+ * Thus, in the case where 'object' should remain available after
+ * the function returns, the function 'json_object_get' shall be used.
+ *
+ * Returns the count of clients that received the event.
+ */
+int afb_event_broadcast(struct afb_event event, struct json_object *object);

This uses an existing event (created with afb_daemon_make_event) for broadcasting an event having its name.

Function afb_daemon_broadcast_event

The function afb_daemon_broadcast_event is defined as below:

/*
+ * Broadcasts widely the event of 'name' with the data 'object'.
+ * 'object' can be NULL.
+ * 'daemon' MUST be the daemon given in interface when activating the binding.
+ *
+ * For convenience, the function calls 'json_object_put' for 'object'.
+ * Thus, in the case where 'object' should remain available after
+ * the function returns, the function 'json_object_get' shall be used.
+ *
+ * Returns the count of clients that received the event.
+ */
+int afb_daemon_broadcast_event(struct afb_daemon daemon, const char *name, struct json_object *object);

The name is given here explicitely. The name is automatically prefixed with the name of the binding. For example, a binding of prefix "xxx" would broadcat the event "xxx/name".

Architectural digressions

Based on their dependencies to hardware, signaling agents can be split into 2 categories: low-level signaling agents and high-level signaling agents.

Low-level signaling agents are bound to the hardware and focused on interfacing and driving.

High-level signaling agent are independent of the hardware and ocused on providing service.

This separation (that may in the corner look artificial) aim to help in the systems design. The main idea here is that high-level signaling agents are providing âbusiness logicâ, also known as âapplication logicâ, that is proper to the car industry and that can be reused and that can evolve as a foundation for the future of the industry.

The implementation of this decomposition may follow 2 paths: strict separation or soft composition.

Strict separation

The strict separation implements the modularity composition of signaling agent through the framework. The high-level signaling agent subscribes to the low level signaling agent using the standard client API.

Advantages:

Modularity
Separation of responsibilities
Possible aggregation of multiple sources
Soft binding of agent good for maintenance

Drawbacks:

Cost of propagation of data (might serialize)
Difficulties to abstract low-level signaling agent or to find a trade-of between abstracting and specializing

The key is modularity versus cost of propagation. It can be partly solved when logical group of signaling agent are launched together in the same binder process. In that particular case, the cost of propagation of data between agents is reduced² because there is no serialization.

This reduction of the propagation cost (and of the resources used) precludes implementation of strong security between the agents because they share the same memory.

Soft composition

The soft composition implements the business logic of high-level signaling agents as libraries that can then be used directly by the low level signaling agents.

Advantages:

No propagation: same memory, sharing of native structures

Drawbacks:

Cannot be used for aggregation of several sources
Difficulties to abstract low-level signaling agent or to find a trade-of between abstracting and specializing
Source code binding not good for maintenance

There are two aspect in using JSON: the first is the flexible data structure that mixes common types (booleans, numbers, strings, arrays, dictionaries, nulls), the second, is the streaming specification. Streaming is often seen as the bottleneck of using JSON (see http://bjson.org). When the agent share the same process, there is no streaming at all.â©
Within the same process, there is not serialization, the propagation has the cost of wrapping a json data and calling callbacks with the benefit of having a powerful callback manager: the event mechanism of the framework.â©

+ + diff --git a/doc/afb-events-guide.md b/doc/afb-events-guide.md new file mode 100644 index 00000000..488c52af --- /dev/null +++ b/doc/afb-events-guide.md @@ -0,0 +1,449 @@ +Guid for developing with events +------------------------------- + +Signaling agents are services that send events to any clients that +subscribed for receiving it. The sent events carry any data. + +To have a good understanding of how to write a signaling agent, the +actions of subscribing, unsubscribing, producing, sending, receiving +events must be described and explained. + +The basis of a signaling agent is shown on the following figure: + +![scenario of using events](signaling-basis.svg) + +This figure shows the main role of the signaling framework for the +propagation of events. + +For people not familiar with the framework, a signaling agent and +a âbindingâ are similar. + +### Subscribing and unsubscribing + +Subscribing and subscription is the action that makes a client able to +receive data from a signaling agent. Subscription must create resources +for generating the data and for delivering the data to the client. These +two aspects are not handled by the same piece of software: generating +the data is the responsibility of the developer of the signaling agent +while delivering the data is handled by the framework. + +When a client subscribes for data, the agent must: + +1. check that the subscription request is correct; +2. establish the computation chain of the required data, if not already + done; +3. create a named event for the computed data, if not already done; +4. ask the framework to establish the subscription to the event for the + request; +5. optionally give indications about the event in the reply to + the client. + +The first two steps are not involving the framework. They are linked to +the business logic of the binding. The request can be any description of +the requested data and the computing stream can be of any nature, this +is specific to the binding. + +As said before, the framework uses and integrates âlibsystemdâ and its event +loop. Within the framework, "libsystemd" is the standard API/library for +bindings expecting to setup and handle I/O, timer or signal events. + +Steps 3 and 4 are bound to the framework. + +The agent must create an object for handling the propagation of produced +data to its clients. That object is called âeventâ in the framework. An +event has a name that allows clients to distinguish it from other +events. + +Events are created using the ***afb\_daemon\_make\_event*** function +that takes the name of the event. Example: + +```C + event = afb_daemon_make_event(afb_daemon, name); +``` + +Once created, the event can be used either to push data to its +subscribers or to broadcast data to any listener. + +The event must be used to establish the subscription for the requesting +client. This is done using the ***afb\_req\_subscribe*** function +that takes the current request object and event and associates them +together. Example: + +```C + rc = afb_req_subscribe(afb_req, event); +``` + +When successful, this function make the connection between the event and +the client that emitted the request. The client becomes a subscriber of +the event until it unsubscribes or disconnects. The +***afb\_req\_subscribe*** function will fail if the client +connection is weak: if the request comes from a HTTP link. To receive +signals, the client must be connected. The AGL framework allows +connections using WebSocket. + +The name of the event is either a well known name or an ad hoc name +forged for the usecase. + +Let's see a basic example: client A expects to receive the speed in km/h +every second while client B expects the speed in mph twice a second. In +that case, there are two different events because it is not the same +unit and it is not the same frequency. Having two different events +allows to associate clients to the correct event. But this doesn't tell +any word about the name of these events. The designer of the signaling +agent has two options for naming: + +1. names can be the same (âspeedâ for example) with sent data + self-describing itself or having a specific tag (requiring from + clients awareness about requesting both kinds of speed isn't safe). +2. names of the event include the variations (by example: + âspeed-km/h-1Hzâ and âspeed-mph-2Hzâ) and, in that case, sent data + can self-describe itself or not. + +In both cases, the signaling agent might have to send the name of the +event and/or an associated tag to its client in the reply of the +subscription. This is part of the step 5 above. + +The framework only uses the event (not its name) for subscription, +unsubscription and pushing. + +When the requested data is already generated and the event used for +pushing it already exists, the signaling agent must not instantiate a +new processing chain and must not create a new event object for pushing +data. The signaling agent must reuse the existing chain and event. + +Unsubscribing is made by the signaling agent on a request of its client. +The ***afb\_req\_unsubscribe*** function tells the framework to +remove the requesting client from the event's list of subscribers. +Example: + +```C + afb_req_unsubscribe(afb_req, event); +``` + +Subscription count does not matter to the framework: subscribing the +same client several times has the same effect that subscribing only one +time. Thus, when unsubscribing is invoked, it becomes immediately +effective. + +#### More on naming events + +Within the AGL framework, a signaling agent is a binding that has an API +prefix. This prefix is meant to be unique and to identify the binding +API. The names of the events that this signaling agent creates are +automatically prefixed by the framework, using the API prefix of the +binding. + +Thus, if a signaling agent of API prefix ***api*** creates an event +of name ***event*** and pushes data to that event, the subscribers +will receive an event of name ***api/event***. + +### Generating and pushing signals and data + +This of the responsibility of the designer of the signaling agent to +establish the processing chain for generating events. In many cases, +this can be achieved using I/O or timer or signal events inserted in the +main loop. For this case, the AGL framework uses âlibsystemdâ and +provide a way to integrates to the main loop of this library using +afb\_daemon\_get\_event\_loop. Example: + +```C + sdev = afb_daemon_get_event_loop(af_daemon); + rc = sd_event_add_io(sdev, &source, fd, EPOLLIN, myfunction, NULL); +``` + +In some other cases, the events are coming from D-Bus. In that case, the +framework also uses âlibsystemdâ internally to access D-Bus. It provides +two methods to get the available D-Bus objects, already existing and +bound to the main libsystemd event loop. Use either +***afb\_daemon\_get\_system\_bus*** or +***afb\_daemon\_get\_user\_bus*** to get the required instance. Then +use functions of âlibsystemdâ to handle D-Bus. + +In some rare cases, the generation of the data requires to start a new +thread. + +When a data is generated and ready to be pushed, the signaling agent +should call the function ***afb\_event\_push***. Example: + +```C + rc = afb_event_push(event, json); + if (rc == 0) { + stop_generating(event); + afb_event_drop(event); + } +``` + +The function ***afb\_event\_push*** pushes json data to all the +subscribers. It then returns the count of subscribers. When the count is +zero, there is no subscriber listening for the event. The example above +shows that in that case, the signaling agent stops to generate data for +the event and delete the event using afb\_event\_drop. This is one +possible option. Other valuable options are: do nothing and continue to +generate and push the event or just stop to generate and push the data +but keep the event existing. + +### Receiving the signals + +Understanding what a client expects when it receives signals, events or +data shall be the most important topic of the designer of a signaling +agent. The good point here is that because JSON[^1] is the exchange +format, structured data can be sent in a flexible way. + +The good design is to allow as much as possible the client to describe +what is needed with the goal to optimize the processing to the +requirements only. + +### The exceptional case of wide broadcast + +Some data or events have so much importance that they can be widely +broadcasted to alert any listening client. Examples of such an alert +are: + +- system is entering/leaving âpower safeâ mode +- system is shutting down +- the car starts/stops moving +- ... + +An event can be broadcasted using one of the two following methods: +***afb\_daemon\_broadcast\_event*** or +***afb\_event\_broadcast***. + +Example 1: + +```C + afb_daemon_broadcast_event(afb_daemon, name, json); +``` + +Example 2: + +```C + event = afb_daemon_make_event(afb_daemon, name); + . . . . + afb_event_broadcast(event, json); +``` + +As for other events, the name of events broadcasted using +***afb\_daemon\_broadcast\_event*** are automatically prefixed by +the framework with API prefix of the binding (signaling agent). + +Reference of functions +---------------------- + +### Function afb\_event afb\_daemon\_make\_event + +The function ***afb\_daemon\_make\_event*** that is defined as below: + +```C +/* + * Creates an event of 'name' and returns it. + * 'daemon' MUST be the daemon given in interface when activating the binding. + */ +struct afb_event afb_daemon_make_event(struct afb_daemon daemon, const char *name); +``` + +The daemon is the handler to the application framework binder daemon +received during initialisation steps of the binding. + +Calling the function ***afb\_daemon\_make\_event*** within the initialisation +function ***afbBindingV1Register*** will _fail_ because the plugin +name is not known at this time. + +The correct way to create the event at initialisation is to call the function +***afb\_daemon\_make\_event*** within the initialisation +function ***afbBindingV1ServiceInit***. + +### Function afb\_event\_push + +The function ***afb\_event\_push*** is defined as below: + +```C +/* + * Pushes the 'event' with the data 'object' to its observers. + * 'object' can be NULL. + * + * For convenience, the function calls 'json_object_put' for object'. + * Thus, in the case where 'object' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * Returns the count of clients that received the event. + */ +int afb_event_push(struct afb_event event, struct json_object *object); +``` + +As the function ***afb\_event\_push*** returns 0 when there is no +more subscriber, a binding can remove such unexpected event using the +function ***afb\_event\_drop***. + +### Function afb\_event\_drop + +The function ***afb\_event\_drop*** is defined as below: + +```C +/* + * Drops the data associated to the event + * After calling this function, the event + * MUST NOT BE USED ANYMORE. + */ +void afb_event_drop(struct afb_event event); +``` + +### Function afb\_req\_subscribe + +The function ***afb\_req\_subscribe*** is defined as below: + +```C +/* + * Establishes for the client link identified by 'req' a subscription + * to the 'event'. + * Returns 0 in case of successful subscription or -1 in case of error. + */ +int afb_req_subscribe(struct afb_req req, struct afb_event event); +``` + +The subscription adds the client of the request to the list of subscribers +to the event. + +### Function afb\_req\_unsubscribe + +The function ***afb\_req\_unsubscribe*** is defined as +below: + +```C +/* + * Revokes the subscription established to the 'event' for the client + * link identified by 'req'. + * Returns 0 in case of successful unsubscription or -1 in case of error. + */ +int afb_req_unsubscribe(struct afb_req req, struct afb_event event); +``` + +The unsubscription removes the client of the request of the list of subscribers +to the event. +When the list of subscribers to the event becomes empty, +the function ***afb\_event\_push*** will return zero. + +### Function afb\_event\_broadcast + +The function ***afb\_event\_broadcast*** is defined as below: + +```C +/* + * Broadcasts widely the 'event' with the data 'object'. + * 'object' can be NULL. + * + * For convenience, the function calls 'json_object_put' for 'object'. + * Thus, in the case where 'object' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * Returns the count of clients that received the event. + */ +int afb_event_broadcast(struct afb_event event, struct json_object *object); +``` + +This uses an existing event (created with ***afb\_daemon\_make\_event***) +for broadcasting an event having its name. + + +### Function afb\_daemon\_broadcast\_event + +The function ***afb\_daemon\_broadcast\_event*** is defined as below: + +```C +/* + * Broadcasts widely the event of 'name' with the data 'object'. + * 'object' can be NULL. + * 'daemon' MUST be the daemon given in interface when activating the binding. + * + * For convenience, the function calls 'json_object_put' for 'object'. + * Thus, in the case where 'object' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * Returns the count of clients that received the event. + */ +int afb_daemon_broadcast_event(struct afb_daemon daemon, const char *name, struct json_object *object); +``` + +The name is given here explicitely. The name is automatically prefixed +with the name of the binding. For example, a binding of prefix "xxx" +would broadcat the event "xxx/name". + + +Architectural digressions +------------------------- + +Based on their dependencies to hardware, signaling agents can be split +into 2 categories: low-level signaling agents and high-level signaling +agents. + +Low-level signaling agents are bound to the hardware and focused on +interfacing and driving. + +High-level signaling agent are independent of the hardware and ocused on +providing service. + +This separation (that may in the corner look artificial) aim to help in +the systems design. The main idea here is that high-level signaling +agents are providing âbusiness logicâ, also known as âapplication +logicâ, that is proper to the car industry and that can be reused and +that can evolve as a foundation for the future of the industry. + +The implementation of this decomposition may follow 2 paths: strict +separation or soft composition. + +### Strict separation + +The strict separation implements the modularity composition of signaling +agent through the framework. The high-level signaling agent subscribes +to the low level signaling agent using the standard client API. + +Advantages: + +- Modularity +- Separation of responsibilities +- Possible aggregation of multiple sources +- Soft binding of agent good for maintenance + +Drawbacks: + +- Cost of propagation of data (might serialize) +- Difficulties to abstract low-level signaling agent or to find a + trade-of between abstracting and specializing + +The key is modularity versus cost of propagation. It can be partly +solved when logical group of signaling agent are launched together in +the same binder process. In that particular case, the cost of +propagation of data between agents is reduced[^2] because there is no +serialization. + +This reduction of the propagation cost (and of the resources used) +precludes implementation of strong security between the agents because +they share the same memory. + +### Soft composition + +The soft composition implements the business logic of high-level +signaling agents as libraries that can then be used directly by the low +level signaling agents. + +Advantages: + +- No propagation: same memory, sharing of native structures + +Drawbacks: + +- Cannot be used for aggregation of several sources +- Difficulties to abstract low-level signaling agent or to find a + trade-of between abstracting and specializing +- Source code binding not good for maintenance + +[^1]: There are two aspect in using JSON: the first is the flexible data + structure that mixes common types (booleans, numbers, strings, + arrays, dictionaries, nulls), the second, is the streaming + specification. Streaming is often seen as the bottleneck of using + JSON (see http://bjson.org). When the agent share the same process, + there is no streaming at all. + +[^2]: Within the same process, there is not serialization, the + propagation has the cost of wrapping a json data and calling + callbacks with the benefit of having a powerful callback manager: + the event mechanism of the framework. diff --git a/doc/afb-overview.html b/doc/afb-overview.html index caf11d81..707443cc 100644 --- a/doc/afb-overview.html +++ b/doc/afb-overview.html @@ -7,10 +7,10 @@ Overview of AFB-DAEMON + -

diff --git a/doc/afb-tests-overview.html b/doc/afb-tests-overview.html index 549fe492..27231a08 100644 --- a/doc/afb-tests-overview.html +++ b/doc/afb-tests-overview.html @@ -8,10 +8,10 @@ Overview of tests shipped with AFB-Daemon + -

diff --git a/doc/doc.css b/doc/doc.css index 8c327c09..f3d55f9d 100644 --- a/doc/doc.css +++ b/doc/doc.css @@ -35,3 +35,6 @@ table { thead {background-color: #a6f;} tr:nth-child(even) {background-color: #aee;} td { padding: 0.1em 0.5em; } + +figure img {width: 80%;} +figure {text-align: center;} -- 2.16.6