evt: handles broadcasting and tracking
[src/app-framework-binder.git] / src / afb-svc.c
1 /*
2  * Copyright (C) 2016 "IoT.bzh"
3  * Author: José Bollo <jose.bollo@iot.bzh>
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *   http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 #define _GNU_SOURCE
19
20 #include <stdlib.h>
21
22 #include <json-c/json.h>
23
24 #include <afb/afb-req-itf.h>
25 #include <afb/afb-service-itf.h>
26
27 #include "session.h"
28 #include "afb-context.h"
29 #include "afb-evt.h"
30 #include "afb-subcall.h"
31 #include "afb-svc.h"
32
33 /*
34  * Structure for recording service
35  */
36 struct afb_svc
37 {
38         /* session of the service */
39         struct AFB_clientCtx *session;
40
41         /* event listener of the service or NULL */
42         struct afb_evt_listener *listener;
43
44         /* on event callback for the service */
45         void (*on_event)(const char *event, struct json_object *object);
46 };
47
48 /*
49  * Structure for requests initiated by the service
50  */
51 struct svc_req
52 {
53         /*
54          * CAUTION: 'context' field should be the first because there
55          * is an implicit convertion to struct afb_context
56          */
57         struct afb_context context;
58
59         /* the service */
60         struct afb_svc *svc;
61
62         /* the count of references to the request */
63         int refcount;
64 };
65
66 /* functions for services */
67 static void svc_on_event(struct afb_svc *svc, const char *event, int eventid, struct json_object *object);
68 static void svc_call(struct afb_svc *svc, const char *api, const char *verb, struct json_object *args,
69                                 void (*callback)(void*, int, struct json_object*), void *closure);
70
71 /* the interface for services */
72 static const struct afb_service_itf service_itf = {
73         .call = (void*)svc_call
74 };
75
76 /* the interface for events */
77 static const struct afb_evt_itf evt_itf = {
78         .broadcast = (void*)svc_on_event,
79         .push = (void*)svc_on_event
80 };
81
82 /* functions for requests of services */
83 static void svcreq_addref(struct svc_req *svcreq);
84 static void svcreq_unref(struct svc_req *svcreq);
85 static int svcreq_subscribe(struct svc_req *svcreq, struct afb_event event);
86 static int svcreq_unsubscribe(struct svc_req *svcreq, struct afb_event event);
87 static void svcreq_subcall(struct svc_req *svcreq, const char *api, const char *verb, struct json_object *args,
88                                 void (*callback)(void*, int, struct json_object*), void *closure);
89
90 /* interface for requests of services */
91 const struct afb_req_itf afb_svc_req_itf = {
92         .addref = (void*)svcreq_addref,
93         .unref = (void*)svcreq_unref,
94         .context_get = (void*)afb_context_get,
95         .context_set = (void*)afb_context_set,
96         .session_close = (void*)afb_context_close,
97         .session_set_LOA = (void*)afb_context_change_loa,
98         .subscribe = (void*)svcreq_subscribe,
99         .unsubscribe = (void*)svcreq_unsubscribe,
100         .subcall = (void*)svcreq_subcall
101 };
102
103 /* the common session for services sahring their session */
104 static struct AFB_clientCtx *common_session;
105
106 /*
107  * Creates a new service
108  */
109 struct afb_svc *afb_svc_create(int share_session, int (*init)(struct afb_service service), void (*on_event)(const char *event, struct json_object *object))
110 {
111         int rc;
112         struct afb_svc *svc;
113
114         /* allocates the svc handler */
115         svc = malloc(sizeof * svc);
116         if (svc == NULL)
117                 goto error;
118
119         /* instanciate the session */
120         if (share_session) {
121                 /* session shared with other svcs */
122                 if (common_session == NULL) {
123                         common_session = ctxClientCreate (NULL, 0);
124                         if (common_session == NULL)
125                                 goto error2;
126                 }
127                 svc->session = ctxClientAddRef(common_session);
128         } else {
129                 /* session dedicated to the svc */
130                 svc->session = ctxClientCreate (NULL, 0);
131                 if (svc->session == NULL)
132                         goto error2;
133         }
134
135         /* initialises the listener if needed */
136         if (on_event == NULL)
137                 svc->listener = NULL;
138         else {
139                 svc->listener = afb_evt_listener_create(&evt_itf, svc);
140                 if (svc->listener == NULL)
141                         goto error3;
142         }
143
144         /* initialises the svc now */
145         rc = init((struct afb_service){ .itf = &service_itf, .closure = svc });
146         if (rc < 0)
147                 goto error4;
148
149         return svc;
150
151 error4:
152         if (svc->listener != NULL)
153                 afb_evt_listener_unref(svc->listener);
154 error3:
155         ctxClientUnref(svc->session);
156 error2:
157         free(svc);
158 error:
159         return NULL;
160 }
161
162 /*
163  * Propagates the event to the service
164  */
165 static void svc_on_event(struct afb_svc *svc, const char *event, int eventid, struct json_object *object)
166 {
167         svc->on_event(event, object);
168 }
169
170 /*
171  * Initiates a call for the service
172  */
173 static void svc_call(struct afb_svc *svc, const char *api, const char *verb, struct json_object *args, void (*callback)(void*, int, struct json_object*), void *closure)
174 {
175         struct svc_req *svcreq;
176
177         /* allocates the request */
178         svcreq = malloc(sizeof *svcreq);
179         if (svcreq == NULL)
180                 return afb_subcall_internal_error(callback, closure);
181
182         /* initialises the request */
183         afb_context_init(&svcreq->context, svc->session, NULL);
184         svcreq->context.validated = 1;
185         svcreq->svc = svc;
186         svcreq->refcount = 1;
187
188         /* makes the call */
189         afb_subcall(&svcreq->context, api, verb, args, callback, closure, (struct afb_req){ .itf = &afb_svc_req_itf, .closure = svcreq });
190
191         /* terminates and frees ressources if needed */
192         svcreq_unref(svcreq);
193 }
194
195 static void svcreq_addref(struct svc_req *svcreq)
196 {
197         svcreq->refcount++;
198 }
199
200 static void svcreq_unref(struct svc_req *svcreq)
201 {
202         if (0 == --svcreq->refcount) {
203                 afb_context_disconnect(&svcreq->context);
204                 free(svcreq);
205         }
206 }
207
208 static int svcreq_subscribe(struct svc_req *svcreq, struct afb_event event)
209 {
210         if (svcreq->svc->listener == NULL)
211                 return -1;
212         return afb_evt_add_watch(svcreq->svc->listener, event);
213 }
214
215 static int svcreq_unsubscribe(struct svc_req *svcreq, struct afb_event event)
216 {
217         if (svcreq->svc->listener == NULL)
218                 return -1;
219         return afb_evt_remove_watch(svcreq->svc->listener, event);
220 }
221
222 static void svcreq_subcall(struct svc_req *svcreq, const char *api, const char *verb, struct json_object *args, void (*callback)(void*, int, struct json_object*), void *closure)
223 {
224         afb_subcall(&svcreq->context, api, verb, args, callback, closure, (struct afb_req){ .itf = &afb_svc_req_itf, .closure = svcreq });
225 }
226