aboutsummaryrefslogtreecommitdiffstats
path: root/doc/writing-afb-plugins.html
diff options
context:
space:
mode:
authorjobol <jobol@nonadev.net>2016-05-26 18:12:12 +0200
committerjobol <jobol@nonadev.net>2016-05-26 18:12:12 +0200
commitebb9bd69a97516763d5d9203245ded592b825a86 (patch)
tree5c08595c5a3958311faab2698ece730fc18f6dc9 /doc/writing-afb-plugins.html
parentcfa0067c4e1df2def1660e2da31efd62df6a3d30 (diff)
update documentation
Signed-off-by: jobol <jobol@nonadev.net>
Diffstat (limited
/*
 * Copyright (C) 2016 "IoT.bzh"
 * Author Fulup Ar Foll <fulup@iot.bzh>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, something express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Reference:
 *   Json load using json_unpack https://jansson.readthedocs.io/en/2.9/apiref.html#parsing-and-validating-values
 */

#ifndef _CTL_CONFIG_INCLUDE_
#define _CTL_CONFIG_INCLUDE_

#define _GNU_SOURCE

#include "ctl-plugin.h"
#include <filescan-utils.h>
#include <wrap-json.h>

#ifndef CONTROL_MAXPATH_LEN
  #define CONTROL_MAXPATH_LEN 255
#endif

#ifndef CONTROL_CONFIG_PRE
  #define CONTROL_CONFIG_PRE "onload"
#endif

#ifndef CTL_PLUGIN_EXT
  #define CTL_PLUGIN_EXT ".ctlso"
#endif

typedef struct ConfigSectionS {
  const char *key;
  const char *uid;
  const char *info;
  int (*loadCB)(AFB_ApiT apihandle, struct ConfigSectionS *section, json_object *sectionJ);
  void *handle;
  CtlActionT *actions;  
} CtlSectionT;

typedef struct {
    const char* api;
    const char* uid;
    const char *info;
    const char *version;
    json_object *configJ;
    json_object *requireJ;
    CtlSectionT *sections;
} CtlConfigT;


#ifdef CONTROL_SUPPORT_LUA
  #include "ctl-lua.h"
#endif
 
// This should not be global as application may want to define their own sections 
typedef enum {
  CTL_SECTION_PLUGIN,  
  CTL_SECTION_ONLOAD,  
  CTL_SECTION_CONTROL,  
  CTL_SECTION_EVENT,
  CTL_SECTION_HAL,
          
  CTL_SECTION_ENDTAG, 
} SectionEnumT;


// ctl-action.c
PUBLIC CtlActionT *ActionConfig(AFB_ApiT apiHandle, json_object *actionsJ,  int exportApi);
PUBLIC void ActionExecUID(AFB_ReqT request, CtlConfigT *ctlConfig, const char *uid, json_object *queryJ);
PUBLIC void ActionExecOne( CtlSourceT *source, CtlActionT* action, json_object *queryJ);
PUBLIC int ActionLoadOne(AFB_ApiT apiHandle, CtlActionT *action, json_object *, int exportApi);
PUBLIC int ActionLabelToIndex(CtlActionT* actions, const char* actionLabel);


// ctl-config.c
PUBLIC int CtlConfigMagicNew();
PUBLIC json_object* CtlConfigScan(const char *dirList, const char *prefix) ;
PUBLIC char* CtlConfigSearch(AFB_ApiT apiHandle, const char *dirList, const char *prefix) ;
PUBLIC int CtlConfigExec(AFB_ApiT apiHandle, CtlConfigT *ctlConfig) ;
PUBLIC CtlConfigT *CtlLoadMetaData(AFB_ApiT apiHandle,const char* filepath) ;
PUBLIC int CtlLoadSections(AFB_ApiT apiHandle, CtlConfigT *ctlHandle, CtlSectionT *sections);



// ctl-event.c
PUBLIC int EventConfig(AFB_ApiT apihandle, CtlSectionT *section, json_object *actionsJ);
#ifdef AFB_BINDING_PREV3
PUBLIC void CtrlDispatchApiEvent (AFB_ApiT apiHandle, const char *evtLabel, struct json_object *eventJ);
#else
PUBLIC void CtrlDispatchV2Event(const char *evtLabel, json_object *eventJ);
#endif

// ctl-control.c
PUBLIC int ControlConfig(AFB_ApiT apiHandle, CtlSectionT *section, json_object *actionsJ);

// ctl-onload.c
PUBLIC int OnloadConfig(AFB_ApiT apiHandle, CtlSectionT *section, json_object *actionsJ);

// ctl-plugin.c
PUBLIC int PluginConfig(AFB_ApiT UNUSED_ARG(apiHandle), CtlSectionT *section, json_object *pluginsJ);
PUBLIC int PluginGetCB (AFB_ApiT apiHandle, CtlActionT *action , json_object *callbackJ);


#endif /* _CTL_CONFIG_INCLUDE_ */
add'>+ afb_req_success(req, description, NULL);
}
</code></pre>
<p>This examples show many aspects of writing a synchronous
-verb implementation.</p>
+verb implementation. Let summarize it:</p>
-<a name="The.incoming.request"></a>
-<h3>The incoming request</h3>
+<ol>
+<li><p>The function <strong>board_of_req</strong> retrieves the context stored
+for the plugin: the board.</p></li>
+<li><p>The macro <strong>INFO</strong> sends a message of kind <em>INFO</em>
+to the logging system. The global variable named <strong>afbitf</strong>
+used represents the interface to afb-daemon.</p></li>
+<li><p>The function <strong>describe</strong> creates a json_object representing
+the board.</p></li>
+<li><p>The function <strong>afb_req_success</strong> sends the reply, attaching to
+it the object <em>description</em>.</p></li>
+</ol>
+
+
+<h3 id="The.incoming.request">The incoming request</h3>
-<p>For any implementation, the request is received by a structure of type
+<p>For any implementation, the request is received by a structure of type
<strong>struct afb_req</strong>.</p>
-<p><strong><em>Important: note that this is a PLAIN structure, not a pointer to a structure.</em></strong></p>
+<blockquote><p>Note that this is a PLAIN structure, not a pointer to a structure.</p></blockquote>
+
+<p>The definition of <strong>struct afb_req</strong> is:</p>
+
+<pre><code>/*
+ * Describes the request by plugins from afb-daemon
+ */
+struct afb_req {
+ const struct afb_req_itf *itf; /* the interfacing functions */
+ void *closure; /* the closure for functions */
+};
+</code></pre>
+
+<p>It contains two pointers: one, <em>itf</em>, points to the functions needed
+to handle the internal request represented by the second pointer, <em>closure</em>.</p>
-<p>This structure, here named <em>req</em>, is used</p>
+<blockquote><p>The structure must never be used directly.
+Insted, use the intended functions provided
+by afb-daemon and described here.</p></blockquote>
<p><em>req</em> is used to get arguments of the request, to send
answer, to store session data.</p>
@@ -394,8 +443,7 @@ the session of the request.</p>
<p>The second time, it is used to send the reply: an object that
describes the current board.</p>
-<a name="Associating.an.object.to.the.session.for.the.plugin"></a>
-<h3>Associating an object to the session for the plugin</h3>
+<h3 id="Associating.a.context.to.the.session">Associating a context to the session</h3>
<p>When the plugin <em>tic-tac-toe</em> receives a request, it musts regain
the board that describes the game associated to the session.</p>
@@ -430,14 +478,14 @@ its context: the board. This function is <em>board_of_req</em>:</p>
*/
static inline struct board *board_of_req(struct afb_req req)
{
- return afb_req_context(req, (void*)get_new_board, (void*)release_board);
+ return afb_req_context(req, (void*)get_new_board, (void*)release_board);
}
</code></pre>
-<p>This function is very simple because it merely wraps
-a call to the function <strong>afb_req_context</strong>, providing
-all needed arguments.
-The casts are required to avoid a warning when compiling.</p>
+<p>The function <strong>afb_req_context</strong> ensure an existing context
+for the session of the request.
+Its two last arguments are functions. Here, the casts are required
+to avoid a warning when compiling.</p>
<p>Here is the definition of the function <strong>afb_req_context</strong></p>
@@ -450,33 +498,286 @@ The casts are required to avoid a warning when compiling.</p>
*/
static inline void *afb_req_context(struct afb_req req, void *(*create_context)(), void (*free_context)(void*))
{
- void *result = afb_req_context_get(req);
- if (result == NULL) {
- result = create_context();
- afb_req_context_set(req, result, free_context);
- }
- return result;
+ void *result = afb_req_context_get(req);
+ if (result == NULL) {
+ result = create_context();
+ afb_req_context_set(req, result, free_context);
+ }
+ return result;
}
</code></pre>
-<p>This powerful function ensures that the context exists and is
-stored for the session.</p>
-
-<p>The function <strong>get_new_board</strong> creates a new board and set its
+<p>The second argument if the function that creates the context.
+For the plugin <em>tic-tac-toe</em> it is the function <strong>get_new_board</strong>.
+The function <strong>get_new_board</strong> creates a new board and set its
count of use to 1. The boards are counting their count of use
to free there ressources when no more used.</p>
-<p>The function <strong>release_board</strong></p>
+<p>The third argument if the function that frees the context.
+For the plugin <em>tic-tac-toe</em> it is the function <strong>release_board</strong>.
+The function <strong>release_board</strong> decrease the the count of use of
+the board given as argument. If the use count decrease to zero,
+the board data are freed.</p>
+
+<p>The definition of the other functions for dealing with contexts are:</p>
+
+<pre><code>/*
+ * Gets the pointer stored by the plugin for the session of 'req'.
+ * When the plugin has not yet recorded a pointer, NULL is returned.
+ */
+void *afb_req_context_get(struct afb_req req);
+
+/*
+ * Stores for the plugin the pointer 'context' to the session of 'req'.
+ * The function 'free_context' will be called when the session is closed
+ * or if plugin stores an other pointer.
+ */
+void afb_req_context_set(struct afb_req req, void *context, void (*free_context)(void*));
+
+/*
+ * Frees the pointer stored by the plugin for the session of 'req'
+ * and sets it to NULL.
+ *
+ * Shortcut for: afb_req_context_set(req, NULL, NULL)
+ */
+static inline void afb_req_context_clear(struct afb_req req)
+{
+ afb_req_context_set(req, NULL, NULL);
+}
+</code></pre>
+
+<h3 id="Sending.the.reply.to.a.request">Sending the reply to a request</h3>
+
+<p>Two kinds of replies can be made: successful replies and
+failure replies.</p>
+
+<blockquote><p>Sending a reply to a request must be done at most one time.</p></blockquote>
+
+<p>The two functions to send a reply of kind &ldquo;success&rdquo; are
+<strong>afb_req_success</strong> and <strong>afb_req_success_f</strong>.</p>
+
+<pre><code>/*
+ * 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
+ * informationnal comment 'info (can also be NULL).
+ */
+void afb_req_success(struct afb_req req, struct json_object *obj, const char *info);
+
+/*
+ * Same as 'afb_req_success' but the 'info' is a formatting
+ * string followed by arguments.
+ */
+void afb_req_success_f(struct afb_req req, struct json_object *obj, const char *info, ...);
+</code></pre>
+
+<p>The two functions to send a reply of kind &ldquo;failure&rdquo; are
+<strong>afb_req_fail</strong> and <strong>afb_req_fail_f</strong>.</p>
+
+<pre><code>/*
+ * Sends a reply of kind failure to the request 'req'.
+ * The status of the reply is set to 'status' and an
+ * informationnal comment 'info' (can also be NULL) can be added.
+ *
+ * Note that calling afb_req_fail("success", info) is equivalent
+ * to call afb_req_success(NULL, info). Thus even if possible it
+ * is strongly recommanded to NEVER use "success" for status.
+ */
+void afb_req_fail(struct afb_req req, const char *status, const char *info);
+
+/*
+ * Same as 'afb_req_fail' but the 'info' is a formatting
+ * string followed by arguments.
+ */
+void afb_req_fail_f(struct afb_req req, const char *status, const char *info, ...);
+</code></pre>
+
+<h2 id="Getting.argument.of.invocation">Getting argument of invocation</h2>
+
+<p>Many verbs expect arguments. Afb-daemon let plugins
+retrieve their arguments by name not by position.</p>
+
+<p>Arguments are given by the requests either through HTTP
+or through WebSockets.</p>
+
+<p>For example, the verb <strong>join</strong> of the plugin <strong>tic-tac-toe</strong>
+expects one argument: the <em>boardid</em> to join. Here is an extract:</p>
+
+<pre><code>/*
+ * Join a board
+ */
+static void join(struct afb_req req)
+{
+ struct board *board, *new_board;
+ const char *id;
+
+ /* retrieves the context for the session */
+ board = board_of_req(req);
+ INFO(afbitf, "method 'join' called for boardid %d", board-&gt;id);
+
+ /* retrieves the argument */
+ id = afb_req_value(req, "boardid");
+ if (id == NULL)
+ goto bad_request;
+ ...
+</code></pre>
+
+<p>The function <strong>afb_req_value</strong> search in the request <em>req</em>
+for an argument whose name is given. When no argument of the
+given name was passed, <strong>afb_req_value</strong> returns NULL.</p>
+
+<blockquote><p>The search is case sensitive. So the name <em>boardid</em> is not the
+same name than <em>BoardId</em>. But this must not be assumed so two
+expected names of argument should not differ only by case.</p></blockquote>
+
+<h3 id="Basic.functions.for.querying.arguments">Basic functions for querying arguments</h3>
+
+<p>The function <strong>afb_req_value</strong> is defined as below:</p>
+
+<pre><code>/*
+ * 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.
+ *
+ * Shortcut for: afb_req_get(req, name).value
+ */
+static inline const char *afb_req_value(struct afb_req req, const char *name)
+{
+ return afb_req_get(req, name).value;
+}
+</code></pre>
+
+<p>It is defined as a shortcut to call the function <strong>afb_req_get</strong>.
+That function is defined as below:</p>
+
+<pre><code>/*
+ * 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.
+ * When the argument of 'name' is found, the fields are filled,
+ * in particular, the field 'result.name' is set to 'name'.
+ *
+ * There is a special name value: the empty string.
+ * The argument of name "" is defined only if the request was made using
+ * 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);
+</code></pre>
+
+<p>That function takes 2 parameters: the request and the name
+of the argument to retrieve. It returns a PLAIN structure of
+type <strong>struct afb_arg</strong>.</p>
+
+<p>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 <strong>&ldquo;&rdquo;</strong> (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.</p>
+
+<p>The definition of <strong>struct afb_arg</strong> is:</p>
+
+<pre><code>/*
+ * Describes an argument (or parameter) of a request
+ */
+struct afb_arg {
+ const char *name; /* name of the argument or NULL if invalid */
+ const char *value; /* string representation of the value of the argument */
+ /* 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 */
+};
+</code></pre>
+
+<p>The structure returns the data arguments that are known for the
+request. This data include a field named <strong>path</strong>. This <strong>path</strong>
+can be accessed using the function <strong>afb_req_path</strong> defined as
+below:</p>
+
+<pre><code>/*
+ * 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.
+ *
+ * Shortcut for: afb_req_get(req, name).path
+ */
+static inline const char *afb_req_path(struct afb_req req, const char *name)
+{
+ return afb_req_get(req, name).path;
+}
+</code></pre>
+
+<p>The path is only defined for HTTP/POST requests that send file.</p>
+
+<h3 id="Arguments.for.received.files">Arguments for received files</h3>
+
+<p>As it is explained just above, clients can send files using
+HTTP/POST requests.</p>
+
+<p>Received files are attached to a arguments. For example, the
+following HTTP fragment (from test/sample-post.html)
+will send an HTTP/POST request to the method
+<strong>post/upload-image</strong> with 2 arguments named <em>file</em> and
+<em>hidden</em>.</p>
+
+<pre><code>&lt;h2&gt;Sample Post File&lt;/h2&gt;
+&lt;form enctype="multipart/form-data"&gt;
+ &lt;input type="file" name="file" /&gt;
+ &lt;input type="hidden" name="hidden" value="bollobollo" /&gt;
+ &lt;br&gt;
+ &lt;button formmethod="POST" formaction="api/post/upload-image"&gt;Post File&lt;/button&gt;
+&lt;/form&gt;
+</code></pre>
+
+<p>In that case, the argument named <strong>file</strong> has its value and its
+path defined and not NULL.</p>
+
+<p>The value is the name of the file as it was
+set by the HTTP client and is generally the filename on the
+client side.</p>
+
+<p>The path is the path of the file saved on the temporary local storage
+area of the application. This is a randomly generated and unic filename
+not linked in any way with the original filename on the client.</p>
+
+<p>The plugin can use the file at the given path the way that it wants:
+read, write, remove, copy, rename&hellip;
+But when the reply is sent and the query is terminated, the file at
+this path is destroyed if it still exist.</p>
+
+<h3 id="Arguments.as.a.JSON.object">Arguments as a JSON object</h3>
+
+<p>Plugins can get all the arguments as one single object.
+This feature is provided by the function <strong>afb_req_json</strong>
+that is defined as below:</p>
+
+<pre><code>/*
+ * 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);
+</code></pre>
+
+<p>It returns a json object. This object depends on how the request was
+made:</p>
+
+<ul>
+<li><p>For HTTP requests, this is an object whose keys are the names of the
+arguments and whose values are either a string for common arguments or
+an object like { &ldquo;file&rdquo;: &ldquo;&hellip;&rdquo;, &ldquo;path&rdquo;: &ldquo;&hellip;&rdquo; }</p></li>
+<li><p>For WebSockets requests, the returned object is the object
+given by the client transparently transported.</p></li>
+</ul>
+
-<a name="Sending.the.reply.to.a.request"></a>
-<h3>Sending the reply to a request</h3>
+<blockquote><p>In fact, for Websockets requests, the function <strong>afb_req_value</strong>
+can be seen as a shortcut to
+<em>json_object_get_string(json_object_object_get(afb_req_json(req), name))</em></p></blockquote>
-<a name="Getting.argument.of.invocation"></a>
-<h2>Getting argument of invocation</h2>
+<h2 id="Sending.messages.to.the.log.system">Sending messages to the log system</h2>
-<a name="How.to.build.a.plugin"></a>
-<h2>How to build a plugin</h2>
+<h2 id="How.to.build.a.plugin">How to build a plugin</h2>
-<p>Afb-daemon provides a The packaging of afb-daemon</p>
+<p>Afb-daemon provides a <em>pkg-config</em> configuration file.</p>
</body>
</html>