]> rtime.felk.cvut.cz Git - frescor/forb.git/blob - src/forb.c
376651f44c269482d91d28848ae54e1223cf2bbf
[frescor/forb.git] / src / forb.c
1 /**************************************************************************/
2 /* ---------------------------------------------------------------------- */
3 /* Copyright (C) 2006 - 2008 FRESCOR consortium partners:                 */
4 /*                                                                        */
5 /*   Universidad de Cantabria,              SPAIN                         */
6 /*   University of York,                    UK                            */
7 /*   Scuola Superiore Sant'Anna,            ITALY                         */
8 /*   Kaiserslautern University,             GERMANY                       */
9 /*   Univ. Politécnica  Valencia,           SPAIN                        */
10 /*   Czech Technical University in Prague,  CZECH REPUBLIC                */
11 /*   ENEA                                   SWEDEN                        */
12 /*   Thales Communication S.A.              FRANCE                        */
13 /*   Visual Tools S.A.                      SPAIN                         */
14 /*   Rapita Systems Ltd                     UK                            */
15 /*   Evidence                               ITALY                         */
16 /*                                                                        */
17 /*   See http://www.frescor.org for a link to partners' websites          */
18 /*                                                                        */
19 /*          FRESCOR project (FP6/2005/IST/5-034026) is funded             */
20 /*       in part by the European Union Sixth Framework Programme          */
21 /*       The European Union is not liable of any use that may be          */
22 /*       made of this code.                                               */
23 /*                                                                        */
24 /*                                                                        */
25 /*  This file is part of FORB (Frescor Object Request Broker)             */
26 /*                                                                        */
27 /* FORB is free software; you can redistribute it and/or modify it        */
28 /* under terms of the GNU General Public License as published by the      */
29 /* Free Software Foundation; either version 2, or (at your option) any    */
30 /* later version.  FORB is distributed in the hope that it will be        */
31 /* useful, but WITHOUT ANY WARRANTY; without even the implied warranty    */
32 /* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU    */
33 /* General Public License for more details. You should have received a    */
34 /* copy of the GNU General Public License along with FORB; see file       */
35 /* COPYING. If not, write to the Free Software Foundation, 675 Mass Ave,  */
36 /* Cambridge, MA 02139, USA.                                              */
37 /*                                                                        */
38 /* As a special exception, including FORB header files in a file,         */
39 /* instantiating FORB generics or templates, or linking other files       */
40 /* with FORB objects to produce an executable application, does not       */
41 /* by itself cause the resulting executable application to be covered     */
42 /* by the GNU General Public License. This exception does not             */
43 /* however invalidate any other reasons why the executable file might be  */
44 /* covered by the GNU Public License.                                     */
45 /**************************************************************************/
46
47 /**
48  * @file   forb.c
49  * @author Michal Sojka <sojkam1@fel.cvut.cz>
50  * @date   Sun Oct 12 16:57:01 2008
51  * 
52  * @brief  Implementation of basic FORB's functions.
53  * 
54  * 
55  */
56
57 #ifndef _BSD_SOURCE
58 #define _BSD_SOURCE             /* Because of on_exit()  */
59 #endif
60 #include "proto.h"
61 #include "regref.h"
62 #include <forb/config.h>
63 #include <forb/forb-internal.h>
64 #include <forb.h>
65 #include "forb-idl.h"
66 #include <forb/iop.h>
67 #include <forb/object.h>
68 #include <forb/uuid.h>
69 #include <stdio.h>
70 #include <string.h>
71 #include <sys/stat.h>
72 #include <sys/types.h>
73 #include <ul_gavlcust.h>
74 #include <ul_log.h>
75 #include <ul_logreg.h>
76 #include <unistd.h>
77 #include "discovery.h"
78 #ifdef CONFIG_FORB_PROTO_UNIX
79 #include <forb/proto_unix.h>
80 #endif
81 #ifdef CONFIG_FORB_PROTO_INET_DEFAULT
82 #include <forb/proto_inet.h>
83 #endif
84 #ifdef CONFIG_FCB
85 #include <fcb.h>
86 #include <fcb_contact_info.h>
87 #endif
88 #include <fcntl.h>
89
90 #ifdef DEBUG
91 #define UL_LOGL_DEF UL_LOGL_DEB
92 #else
93 #define UL_LOGL_DEF UL_LOGL_ERR
94 #endif
95 #include "log_domains.inc"
96
97 extern UL_LOG_CUST(ulogd_forb);
98 static int init_ul_log(void);
99
100 UL_LOGREG_DOMAINS_INIT_FUNCTION(forb_logreg_domains, forb_logreg_domains_array);
101
102 #if 0
103 static void
104 destroy_forb_on_exit(int exitcode, void *arg)
105 {
106         forb_orb orb = arg;
107         forb_destroy(orb);
108 }
109 #endif
110
111 static void
112 forb_is_alive(forb_orb _obj, CORBA_Environment *ev)
113 {
114         ul_logdeb("%s called\n", __FUNCTION__);
115 }
116
117 static struct forb_forb_orb_impl forb_implementation = {
118         .is_alive = forb_is_alive,
119 };
120
121 /**
122  * Prepares #FORB_TMP_DIR directory for use by forb
123  *
124  * @return Zero on succes, -1 on error and errno is set appropriately.
125  */
126 int
127 forb_init_tmp_dir(void)
128 {
129         struct stat st;
130         int ret;
131
132         ret = stat(FORB_TMP_DIR, &st);
133
134         if (ret == 0 && !S_ISDIR(st.st_mode)) {
135                 ret = unlink(FORB_TMP_DIR);
136                 if (ret) return -1;
137         } else if (ret == 0) {
138                 return 0;
139         }
140         return mkdir(FORB_TMP_DIR, 0777);
141 }
142
143 /** 
144  * Thread for execution of remote requests for a FORB object.
145  * 
146  * @param arg 
147  * 
148  * @return 
149  */
150 static void *
151 forb_execution_thread(void *arg)
152 {
153         forb_executor_t *executor = arg;
154         forb_executor_run(executor);
155         return NULL;
156 }
157
158 #ifdef CONFIG_FCB
159 void hack_register_fcb(forb_orb orb, forb_port_t *port)
160 {
161         forb_object fcb = forb_object_new(orb, &FCB_SERVER_ID, 1);
162         if (!fcb) {
163                 ul_logerr("Cannot allocate FCB reference\n");
164                 return;
165         }
166         forb_register_reference(fcb, fres_contract_broker_reg_name);
167         forb_object_release(fcb);
168 }
169 #else
170 #define hack_register_fcb(orb)
171 #endif
172
173
174
175 forb_orb
176 forb_init(int *argc, char **argv[], const struct forb_init_attr *attr)
177 {
178         forb_orb orb;
179         forb_t *forb;
180         int ret;
181
182         forb = forb_malloc(sizeof(*forb));
183         if (!forb) goto err;
184         memset(forb, 0, sizeof(*forb));
185
186         /* Initialize ULUT logging facility */
187         init_ul_log();
188         forb_logreg_domains();
189
190         if (attr) {
191                 forb->attr = *attr;
192         } else {
193                 memset(&forb->attr, 0, sizeof(forb->attr));
194         }
195
196         sem_init(&forb->server_ready, 0, 0);
197
198         if (forb_server_id_empty(&forb->attr.fixed_server_id)) {
199                 forb_server_id_init(&forb->server_id);
200         } else {
201                 forb->server_id = forb->attr.fixed_server_id;
202         }
203         forb_server_id_to_string(forb->server_id_str, &forb->server_id,
204                                  sizeof(forb->server_id_str));
205         ul_logdeb("Initializing forb %s\n", forb->server_id_str);
206
207         if (fosa_mutex_init(&forb->request_id_mutex, 0) != 0) goto err2;
208         if (fosa_mutex_init(&forb->port_mutex, 0) != 0) goto err2;
209         forb_port_init_head(forb);
210         
211         if (fosa_mutex_init(&forb->request_mutex, 0) != 0) goto err2;
212         forb_request_nolock_init_root_field(forb);
213
214         if (forb_discovery_init(forb) != 0) goto err2;
215
216         if (fosa_mutex_init(&forb->regref_mutex, 0) != 0) goto err2;
217         forb_regref_nolock_init_root_field(forb);
218
219         ret = forb_init_tmp_dir();
220         if (ret != 0) {
221                 ul_logerr("Cannot prepare " FORB_TMP_DIR "\n");
222                 return NULL;
223         }
224
225         forb_executor_prepare();        
226
227         orb = forb_forb_orb_new(NULL, &forb_implementation, forb);
228         if (!orb) goto err2;
229         /* Server ID must be assigned manualy */
230         orb->server = forb->server_id;
231
232         forb->orb = orb;
233
234         /* Insert our object reference to objects tree, so that we
235          * can accept remote request to our new ORB. */
236         forb_objects_nolock_insert(forb, orb);
237
238         ret = forb_executor_init(&forb->default_executor);
239         if (ret) goto err2;
240         ret = forb_executor_register_object(&forb->default_executor, orb);
241         if (ret) goto err3;
242
243         ret = fosa_thread_create(&forb->execution_thread, NULL,
244                                  forb_execution_thread, &forb->default_executor);
245         if (ret != 0)
246                 goto err3;
247
248         /* FIXME: I do not know how to deregister the exit handler if
249          * forb_destroy() is called manually. */
250         /* on_exit(destroy_forb_on_exit, orb); */
251
252 #ifdef CONFIG_FORB_PROTO_UNIX
253         {
254                 forb_port_t *port = forb_malloc(sizeof(*port));
255                 if (port) {
256                         memset(port, 0, sizeof(*port));
257                         ret = forb_unix_port_init(&port->desc, &forb->server_id);
258                         if (ret) goto err_free_unix;
259                         ret = forb_register_port(orb, port);
260                         if (ret) goto err_free_unix; /* TODO: forb_unix_port_done() */
261                         goto unix_ok;
262                 }
263         err_free_unix:
264                 free(port);
265                 goto err3;
266         unix_ok:;
267         }
268 #endif
269 #ifdef CONFIG_FORB_PROTO_INET_DEFAULT
270         {
271                 forb_port_t *port = forb_malloc(sizeof(*port));
272                 if (port) {
273                         struct in_addr listen_on;
274
275                         memset(port, 0, sizeof(*port));
276                         listen_on.s_addr = INADDR_ANY;
277                         ret = forb_inet_port_init(&port->desc, listen_on,
278                                                   forb->attr.fixed_tcp_port);
279                         if (ret) goto err_free_inet;
280                         ret = forb_register_port(orb, port);
281                         if (ret) goto err_free_inet; /* TODO: forb_inet_port_done() */
282                         goto inet_ok;
283                 }
284         err_free_inet:
285                 free(port);
286                 goto err3;
287         inet_ok:;
288                 hack_register_fcb(orb, port);
289         }
290 #endif
291         return orb;
292
293 err3:   forb_executor_destroy(&forb->default_executor);
294 err2:   forb_free(forb);
295 err:    return NULL;
296 }
297
298 void forb_destroy(forb_orb orb)
299 {
300         forb_t *forb = forb_object_to_forb(orb);
301         forb_port_t *port;
302         forb_regref_t *regref;
303         forb_object obj;
304
305         /* Destroy ports to prevent remote requests from coming */
306         ul_list_for_each_cut(forb_port, forb, port) {
307                 forb_destroy_port(port);
308         }
309
310         /* Wait for executors to finish all requests (and thus close
311          * connections to peers). This is very inefficient for big
312          * number of objects, but we do not care */
313         gavl_cust_for_each(forb_objects_nolock, forb, obj) {
314                 forb_executor_t *executor;
315                 executor = forb_object_get_executor(obj);
316                 if (executor)
317                         forb_executor_synchronize(executor);
318         }
319
320         pthread_cancel(forb->execution_thread.pthread_id);
321         pthread_join(forb->execution_thread.pthread_id, NULL);
322         
323         /* Unregister all registered references */
324         while ((regref = forb_regref_first(forb))) {
325                 forb_unregister_reference(orb, regref->name.str);
326         }
327         
328         forb_object_release(orb);
329         forb_free(forb);
330 }
331
332 /* void */
333 /* forb_register_interface(const struct forb_interface *interface) */
334 /* { */
335 /*      gavl_insert(&type_registry, &interface->node); */
336 /* } */
337
338 /** 
339  * Initializes server ID variable.
340  * 
341  * @param server_id Serer ID to initialize.
342  */
343 void
344 forb_server_id_init(forb_server_id *server_id)
345 {
346         forb_uuid_generate((forb_uuid_t*)server_id->uuid);
347 }
348
349 /** 
350  * Checks whether the @a object is stale. Stale object is an object
351  * reference whose server cannot be contacted to handle requests.
352  * 
353  * @param object Object reference to check.
354  * 
355  * @return True if the object is stale, false otherwise.
356  */
357 bool forb_object_is_stale(forb_object object)
358 {
359         forb_orb remote_orb;
360         struct forb_env env;
361         bool stale = true;
362         
363         remote_orb = forb_get_orb_of(object);
364         if (!remote_orb) {      /* This shohuld never happen */
365                 goto err;
366         }
367         /* TODO: Check not only the ORB, but also whether the object
368          * is still registered with the remote orb. */
369         forb_orb_is_alive(remote_orb, &env);
370         if (env.major == FORB_EX_COMM_FAILURE) {
371                 /* Orb is not alive */
372                 stale = true;
373         } else {
374                 if (forb_exception_occurred(&env)) {
375                         ul_logerr("%s: unexpected exception: %s\n", __FUNCTION__, forb_strerror(&env));
376                 }
377                 stale = false;  
378         }
379
380         forb_object_release(remote_orb);
381 err:
382         return stale;
383 }
384
385
386 /** 
387  * Returns object reference of forb::orb object associated with the
388  * given object.
389  * 
390  * @param obj 
391  * 
392  * @return 
393  */
394 forb_orb
395 forb_get_orb_of(const forb_object obj)
396 {
397         forb_orb orb;
398
399         if (forb_server_id_cmp(&obj->server, &obj->orb->server) == 0) {
400                 orb = forb_object_duplicate(obj->orb);
401         } else {
402                 orb = forb_object_new(obj->orb, &obj->server, 0);
403         }
404         return orb;
405 }
406
407 /** 
408  * Returns server ID of an object reference.
409  * 
410  * @param obj 
411  * @param dest 
412  */
413 void
414 forb_get_server_id(const forb_object obj, forb_server_id *dest)
415 {
416         if (obj) {
417                 *dest = obj->server;
418         }
419 }
420
421
422 /** 
423  * Return instance data registered when the object was created by
424  * forb_XXX_new().
425  * 
426  * @param obj Object reference
427  * 
428  * @return Pointer to the registered data.
429  */
430 void *
431 forb_instance_data(const forb_object obj)
432 {
433         return forb_object_instance_data(obj);
434 }
435
436 /** 
437  * Returns error message correspondings FORB exception.
438  * 
439  * @param env Environemnt
440  * 
441  * @return Non-NULL pointer to a string.
442  */
443 const char *
444 forb_strerror(CORBA_Environment *env)
445 {
446         if (!env) {
447                 return "Invalid environemnt";
448         }
449 #define ex(e) case FORB_EX_##e: return #e; break;
450         switch (env->major) {
451         ex(NONE);
452         ex(UNKNOWN);
453         ex(BAD_PARAM);
454         ex(NO_MEMORY);
455         ex(IMP_LIMIT);
456         ex(COMM_FAILURE);
457         ex(INV_OBJREF);
458         ex(NO_PERMISSION);
459         ex(INTERNAL);
460         ex(MARSHAL);
461         ex(INITIALIZE);
462         ex(NO_IMPLEMENT);
463         ex(BAD_OPERATION);
464         ex(NO_RESOURCES);
465         ex(NO_RESPONSE);
466         ex(TRANSIENT);
467         ex(FREE_MEM);
468         ex(INV_IDENT);
469         ex(INV_FLAG);
470         ex(DATA_CONVERSION);
471         ex(OBJECT_NOT_EXIST);
472         ex(TIMEOUT);
473         ex(APPLICATION);
474         }
475 #undef ex
476         return "Invalid error number";
477 }
478
479 /** 
480  * Return server id of the requesting application.
481  *
482  * This function should be only called from within interface
483  * implementation,
484  * 
485  * @param[in] obj Object being requested
486  * @param[out] req_source Server ID of the requesting application
487  */
488 void
489 forb_get_req_source(const forb_object obj, forb_server_id *req_source)
490 {
491         if (req_source) {
492                 if (obj && obj->exec_req) {
493                         *req_source = obj->exec_req->source;
494                 } else {
495                         memset(req_source, 0, sizeof(*req_source));
496                 }
497         }
498 }
499
500 /**
501  * Internal function for allocation of sequence bufers. Used by
502  * forb_sequence_alloc_buf().
503  *
504  * @param seq
505  * @param seq_size
506  * @param buf_pptr
507  * @param maximum_ptr
508  * @param num_elements
509  * @param elem_size
510  *
511  * @return CORBA_TRUE if the allocation was sucessfull, CORBA_FALSE if
512  * it wasn't.
513  */
514 CORBA_boolean
515 __forb_sequence_alloc_buf_internal(void *seq, size_t seq_size,
516                                    void **buf_pptr, CORBA_unsigned_long *maximum_ptr,
517                                    unsigned num_elements, size_t elem_size)
518 {
519         memset(seq, 0, seq_size);
520         /*(seq)._length = 0;*/
521         if (num_elements && elem_size) *buf_pptr = forb_malloc(num_elements * elem_size);
522         else *buf_pptr = NULL;
523         *maximum_ptr = *buf_pptr ? num_elements : 0;
524         return (*buf_pptr != NULL) || (num_elements == 0);
525 }
526
527 static FILE *forb_ul_log_file;
528 static char progname[64] = "";
529
530 void
531 forb_ul_log_fnc(ul_log_domain_t *domain, int level,
532                 const char *format, va_list ap)
533 {
534         struct timespec now;
535         if(!(level&UL_LOGL_CONT)) {
536                 level&=UL_LOGL_MASK;
537                 clock_gettime(CLOCK_MONOTONIC, &now);
538                 fprintf(forb_ul_log_file,"%ld.%6ld: ", now.tv_sec, now.tv_nsec/1000);
539                 if (progname[0])
540                         fprintf(forb_ul_log_file,"%s: ", progname);
541                 if(domain && domain->name)
542                         fprintf(forb_ul_log_file,"%s: ",domain->name);
543         }
544         vfprintf(forb_ul_log_file, format, ap);
545         fflush(forb_ul_log_file);
546 }
547
548 static int init_ul_log(void)
549 {
550         char *s;
551         char *log_fname;
552         int fd;
553         int flg = 0;
554         char path[128];
555
556 /*      if(ul_log_output != NULL) */
557 /*              return 0; */
558
559         fd = open("/proc/self/cmdline", O_RDONLY);
560         if (fd >= 0) {
561                 int ret;
562                 ret = read(fd, path, sizeof(path)-1);
563                 if (ret > 0) {
564                         path[ret]=0;
565                         s = strrchr(path, '/');
566                         if (s) s++;
567                         else s = path;
568                         strncpy(progname, s, sizeof(progname)-1);
569                 }
570                 close(fd);
571         }
572
573         if((log_fname=getenv("UL_LOG_FILENAME"))!=NULL){
574                 forb_ul_log_file=fopen(log_fname,"a");
575         }
576         if(forb_ul_log_file==NULL)
577                 forb_ul_log_file=stderr;
578         
579         if((s=getenv("UL_DEBUG_FLG")) != NULL){
580                 flg=atoi(s);
581         }
582
583         ul_log_redir(forb_ul_log_fnc, flg);
584
585         if((s = getenv("UL_LOG_LEVELS")) != NULL)
586                 ul_log_domain_arg2levels(s);
587
588         return 0;
589 }
590
591 /** 
592  * Wait for the server to be ready. Internal function intended forb
593  * forbrun.
594  * 
595  * @param orb ORB.
596  * 
597  * @return Zero on success; on error -1 is returned, and errno is set
598  * to indicate the error.
599  */
600 int forb_wait_for_server_ready(forb_orb orb)
601 {
602         forb_t *forb = forb_object_to_forb(orb);
603         return sem_wait(&forb->server_ready);
604 }
605
606 /** 
607  * Signal the the FORB core that the server is ready for accepting
608  * requests.
609  *
610  * This function should be called at the initialization of server
611  * implementation at the time when all objects are registered with
612  * executors. All other servers in the same address space are
613  * initialized after this function is called which allows the other
614  * servers to use the services provided by the calling server.
615  * 
616  * @param orb ORB object.
617  * 
618  * @return Zero on success; on error -1 is returned, and errno is set
619  * to indicate the error.
620  */
621 int forb_signal_server_ready(forb_orb orb)
622 {
623         forb_t *forb = forb_object_to_forb(orb);
624         return sem_post(&forb->server_ready);
625 }