2 Overview of the bindings
3 ========================
5 The ***binder*** serves files through HTTP protocol and offers to
6 developers the capability to offer application API methods through HTTP or
9 The ***bindings*** are used to add **API** to ***binders***.
10 This part describes how to write a ***binding*** for ***binder***
11 or in other words how to add a new **API** to the system.
13 Excepting this summary, this section target developers.
15 This section shortly explain how to write a binding
16 using the C programming language.
18 It is convenient to install the ***binder*** on the
19 desktop used for writing the binding. It allows easy
22 ## Nature of a binding
24 A ***binding*** is an independent piece of software compiled as a shared
25 library and dynamically loaded by a ***binder***.
26 It is intended to provide one **API** (**A**pplication **P**rogramming
29 The **API** is designated and accessed through its name.
30 It contains several **verbs** that implement the ***binding***
31 functionalities. Each of these **verbs** is a **method** that
32 processes requests of applications and sends result.
34 The ***binding***'s methods are invoked by HTTP or websocket
37 The **methods** of the ***bindings*** are noted **api/verb**
38 where **api** is the **API** name of the binding and **verb** is
39 the **method**'s name within the **API**.
40 This notation comes from HTTP invocations that rely on URL path terminated
43 The name of an **API** can be made of any characters except:
45 - the control characters (\u0000 .. \u001f)
46 - the characters of the set { ' ', '"', '#', '%', '&',
47 '\'', '/', '?', '`', '\x7f' }
49 The names if the **verbs** can be any character.
51 The binder makes no distinctions between upper case and lower case
52 latin letters. So **API/VERB** matches **Api/Verb** or **api/verb**.
54 Actually it exists 2 ways of writing ***bindings***.
57 - a binding version 1 (not recommended);
58 - a binding version 2 (RECOMMENDED).
60 A ***binder*** loads and runs any of these version in any combination.
61 This document explain how to write bindings version 2.
65 Sample binding: tuto-1
66 ======================
68 This is the code of the binding **tuto-1.c**:
71 1 #define AFB_BINDING_VERSION 2
72 2 #include <afb/afb-binding.h>
74 4 void hello(afb_req req)
76 6 AFB_REQ_DEBUG(req, "hello world");
77 7 afb_req_success(req, NULL, "hello world");
80 10 const afb_verb_v2 verbs[] = {
81 11 { .verb="hello", .callback=hello },
85 15 const afb_binding_v2 afbBindingV2 = {
94 $ gcc -fPIC -shared tuto-1.c -o tuto-1.so $(pkg-config --cflags-only-I afb-daemon)
100 $ afb-daemon --binding tuto-1.so --port 3333 --token ''
103 Testing using **curl**:
106 $ curl http://localhost:3333/api/tuto-1/hello
107 {"jtype":"afb-reply","request":{"status":"success","info":"hello world","uuid":"1e587b54-900b-49ab-9940-46141bc2e1d6"}}
110 Testing using **afb-client-demo** (with option -H for
111 getting a human readable output):
114 $ afb-client-demo -H ws://localhost:3333/api?token=x tuto-1 hello
115 ON-REPLY 1:tuto-1/hello: OK
120 "info":"hello world",
121 "uuid":"03a84ad1-458a-4ace-af74-b1da917391b9"
126 This shows basic things:
128 - The include to get for creating a binding
129 - How to declare the API offered by the binding
130 - How to handle request made to the binding
133 ### Getting declarations for the binding
135 The lines 1 and 2 show how to get the include file **afb-binding.h**.
138 1 #define AFB_BINDING_VERSION 2
139 2 #include <afb/afb-binding.h>
142 You must define the version of ***binding*** that you are using.
143 This is done line 1 where we define that this is the version 2.
145 If you don't define it, a warning message is prompted by the compiler
146 and the version is switched to version 1. This behaviour is
147 temporarily and enables to continue to use previously written
148 ***binding*** without change but it will change in some future when
149 ***bindings*** V1 will become obsoletes.
151 To include **afb-binding.h** successfully, the include search path
152 should be set correctly if needed (not needed only if installed in
153 /usr/include/afb directory that is the default).
155 Setting the include path is easy using **pkg-config**:
158 $ pkg-config --cflags-only-I afb-daemon
161 Note for **C++** developers: The ***binder*** currently expose
162 only **C** language **API**. The file **afb/afb-binding.h**
163 isn't **C++** ready. You should use the construct **extern "C"**
167 #define AFB_BINDING_VERSION 2
169 #include <afb/afb-binding.h>
173 Future version of the ***binder*** will include a **C++**
174 interface. Until it is available, please, use the above
177 ### Declaring the API of the binding
179 Lines 10 to 18 show the declaration of the ***binding***.
181 The ***binder*** knows that this is a ***binding*** version 2 because
182 it finds the exported symbol **afbBindingV2** that is expected to be
183 a structure of type **afb_binding_v2**.
186 10 const afb_verb_v2 verbs[] = {
187 11 { .verb="hello", .callback=hello },
191 15 const afb_binding_v2 afbBindingV2 = {
197 The structure **afbBindingV2** actually tells that:
199 - the exported **API** name is **tuto-1** (line 16)
200 - the array of verbs is the above defined one
202 The exported list of verb is specified by an array of structures,
203 each describing a verb, ended with a verb NULL (line 12).
205 The only defined verb here (line 11) is named **hello** (field **.verb**)
206 and the function that handle the related request is **hello**
207 (field **.callback**).
209 Note that you can explicitly mark the fact that these are
210 struct by typing the **struct** as below:
213 10 const struct afb_verb_v2 verbs[] = {
214 11 { .verb="hello", .callback=hello },
218 15 const struct afb_binding_v2 afbBindingV2 = {
224 ### Handling binder's requests
226 As shown above this is by default the common include directory where
227 the AGL stuff is installed.
230 4 void hello(afb_req req)
232 6 AFB_REQ_DEBUG(req, "hello world");
233 7 afb_req_success(req, NULL, "hello world");
237 When the ***binder*** receives a request for the verb **hello** of
238 of the api **tuto-1**, it invoke the callback **hello** of the **binding**
239 with the argument **req** that handles the client request.
241 The callback has to treat synchronously or asynchronously the request and
242 should at the end emit a reply for the request.
244 Here, the callback for **tuto-1/hello** replies a successful answer
245 (line 7) to the request **req**. The second parameter (here NULL)
246 is a json object that is sent to the client with the reply.
247 The third parameter is also sent with the reply and is a string
248 called info that can be used as some meta data.
250 Here again, you can explicitly mark the fact that
251 **afb_req** is a structure by declaring **hello** as below:
254 4 void hello(struct afb_req req)
259 Sample binding: tuto-2
260 ======================
262 The second tutorial shows many important feature that can
263 commonly be used when writing a ***binding***: initialization,
264 getting arguments, sending replies, pushing events.
266 This is the code of the binding **tuto-2.c**:
269 1 #include <string.h>
270 2 #include <json-c/json.h>
272 4 #define AFB_BINDING_VERSION 2
273 5 #include <afb/afb-binding.h>
275 7 afb_event event_login, event_logout;
277 9 void login(afb_req req)
279 11 json_object *args, *user, *passwd;
282 14 args = afb_req_json(req);
283 15 if (!json_object_object_get_ex(args, "user", &user)
284 16 || !json_object_object_get_ex(args, "password", &passwd)) {
285 17 AFB_REQ_ERROR(req, "login, bad request: %s", json_object_get_string(args));
286 18 afb_req_fail(req, "bad-request", NULL);
287 19 } else if (afb_req_context_get(req)) {
288 20 AFB_REQ_ERROR(req, "login, bad state, logout first");
289 21 afb_req_fail(req, "bad-state", NULL);
290 22 } else if (strcmp(json_object_get_string(passwd), "please")) {
291 23 AFB_REQ_ERROR(req, "login, unauthorized: %s", json_object_get_string(args));
292 24 afb_req_fail(req, "unauthorized", NULL);
294 26 usr = strdup(json_object_get_string(user));
295 27 AFB_REQ_NOTICE(req, "login user: %s", usr);
296 28 afb_req_session_set_LOA(req, 1);
297 29 afb_req_context_set(req, usr, free);
298 30 afb_req_success(req, NULL, NULL);
299 31 afb_event_push(event_login, json_object_new_string(usr));
303 35 void action(afb_req req)
305 37 json_object *args, *val;
308 40 args = afb_req_json(req);
309 41 usr = afb_req_context_get(req);
310 42 AFB_REQ_NOTICE(req, "action for user %s: %s", usr, json_object_get_string(args));
311 43 if (json_object_object_get_ex(args, "subscribe", &val)) {
312 44 if (json_object_get_boolean(val)) {
313 45 AFB_REQ_NOTICE(req, "user %s subscribes to events", usr);
314 46 afb_req_subscribe(req, event_login);
315 47 afb_req_subscribe(req, event_logout);
317 49 AFB_REQ_NOTICE(req, "user %s unsubscribes to events", usr);
318 50 afb_req_unsubscribe(req, event_login);
319 51 afb_req_unsubscribe(req, event_logout);
322 54 afb_req_success(req, json_object_get(args), NULL);
325 57 void logout(afb_req req)
329 61 usr = afb_req_context_get(req);
330 62 AFB_REQ_NOTICE(req, "login user %s out", usr);
331 63 afb_event_push(event_logout, json_object_new_string(usr));
332 64 afb_req_session_set_LOA(req, 0);
333 65 afb_req_context_clear(req);
334 66 afb_req_success(req, NULL, NULL);
339 71 AFB_NOTICE("preinit");
345 77 AFB_NOTICE("init");
346 78 event_login = afb_daemon_make_event("login");
347 79 event_logout = afb_daemon_make_event("logout");
348 80 if (afb_event_is_valid(event_login) && afb_event_is_valid(event_logout))
350 82 AFB_ERROR("Can't create events");
354 86 const afb_verb_v2 verbs[] = {
355 87 { .verb="login", .callback=login },
356 88 { .verb="action", .callback=action, .session=AFB_SESSION_LOA_1 },
357 89 { .verb="logout", .callback=logout, .session=AFB_SESSION_LOA_1 },
361 93 const afb_binding_v2 afbBindingV2 = {
363 95 .specification = NULL,
365 97 .preinit = preinit,
367 99 .noconcurrency = 0
374 $ gcc -fPIC -shared tuto-2.c -o tuto-2.so $(pkg-config --cflags --libs afb-daemon)
380 $ afb-daemon --binding tuto-2.so --port 3333 --token ''
386 $ afb-client-demo -H localhost:3333/api?token=toto
387 tuto-2 login {"help":true}
388 ON-REPLY 1:tuto-2/login: ERROR
392 "status":"bad-request",
393 "uuid":"e2b24a13-fc43-487e-a5f4-9266dd1e60a9"
396 tuto-2 login {"user":"jose","password":"please"}
397 ON-REPLY 2:tuto-2/login: OK
404 tuto-2 login {"user":"jobol","password":"please"}
405 ON-REPLY 3:tuto-2/login: ERROR
412 tuto-2 action {"subscribe":true}
413 ON-REPLY 4:tuto-2/action: OK
425 In an other terminal:
428 $ afb-client-demo -H localhost:3333/api?token=toto
429 tuto-2 login {"user":"jobol","password":"please"}
430 ON-REPLY 1:tuto-2/login: OK
435 "uuid":"a09f55ff-0e89-4f4e-8415-c6e0e7f439be"
439 ON-REPLY 2:tuto-2/logout: OK
448 It produced in the first terminal:
451 ON-EVENT tuto-2/login:
453 "event":"tuto-2\/login",
457 ON-EVENT tuto-2/logout:
459 "event":"tuto-2\/logout",