handler_clusterstats.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2
   3 /* Cherokee
   4  *
   5  * Authors:
   6  *      Alvaro Lopez Ortega <alvaro@alobbs.com>
   7  *      Stefan de Konink <stefan@konink.de>
   8  *
   9  * Copyright (C) 2001-2008 Alvaro Lopez Ortega
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of version 2 of the GNU General Public
  13  * License as published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  23  * USA
  24  */
  25
  26 #include "handler_clusterstats.h"
  27 #include <cherokee/cherokee.h>
  28
  29 #include <avahi-client/client.h>
  30 #include <avahi-client/lookup.h>
  31
  32 #include <avahi-common/malloc.h>
  33 #include <avahi-common/error.h>
  34
  35 /* Plug-in initialization
  36  *
  37  * In this function you can use any of these:
  38  * http_delete | http_get | http_post | http_put
  39  *
  40  * For a full list: cherokee_http_method_t
  41  *
  42  * It is what your handler to be implements.
  43  *
  44  */
  45 PLUGIN_INFO_HANDLER_EASIEST_INIT (clusterstats, http_get);
  46
  47
  48 /* Methods implementation
  49  */
  50
  51 ret_t
  52 cherokee_handler_clusterstats_props_free (cherokee_handler_clusterstats_props_t *props)
  53 {
  54     if (props->threaded_poll)
  55        avahi_threaded_poll_stop(props->threaded_poll);
  56
  57     if (props->sb)
  58         avahi_service_browser_free(props->sb);
  59
  60     if (props->client)
  61        avahi_client_free(props->client);
  62
  63     if (props->threaded_poll)
  64         avahi_threaded_poll_free(props->threaded_poll);
  65
  66     cherokee_buffer_mrproper(&props->service_type);
  67
  68     cherokee_avl_r_mrproper (&props->entries, (cherokee_func_free_t) cherokee_buffer_mrproper);
  69
  70         return cherokee_module_props_free_base (MODULE_PROPS(props));
  71 }
  72
  73
  74 ret_t
  75 cherokee_handler_clusterstats_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props)
  76 {
  77         cherokee_list_t                      *i;
  78         cherokee_handler_clusterstats_props_t *props;
  79
  80         if (*_props == NULL) {
  81                 CHEROKEE_NEW_STRUCT (n, handler_clusterstats_props);
  82
  83                 cherokee_module_props_init_base (MODULE_PROPS(n),
  84                                                  MODULE_PROPS_FREE(cherokee_handler_clusterstats_props_free));
  85
  86         /* Look at handler_clusterstats.h
  87          * This is an avahi of configuration.
  88          */
  89         cherokee_buffer_init (&n->service_type);
  90
  91         cherokee_avl_r_init(&n->entries);
  92
  93         n->client = NULL;
  94         n->sb = NULL;
  95         n->threaded_poll = NULL;
  96
  97                 *_props = MODULE_PROPS(n);
  98         }
  99
 100
 101         props = PROP_CLUSTERSTATS(*_props);
 102
 103     cherokee_avl_r_init(&props->entries);
 104
 105         cherokee_config_node_foreach (i, conf) {
 106                 cherokee_config_node_t *subconf = CONFIG_NODE(i);
 107
 108         if (equal_buf_str (&subconf->key, "service_type")) {
 109             cherokee_buffer_add_buffer (&props->service_type, &subconf->val);
 110                 }
 111         }
 112
 113     /* If the configuration for avahi was not set, we should not continue */
 114     if (props->service_type.len == 0) {
 115         return ret_error;
 116     }
 117
 118     if (!(props->threaded_poll = avahi_threaded_poll_new())) {
 119         return ret_error;
 120     }
 121
 122     client_callback(NULL, AVAHI_CLIENT_FAILURE, props);
 123
 124     /* Finally, start the event loop thread */
 125     if (avahi_threaded_poll_start(props->threaded_poll) < 0) {
 126         return ret_error;
 127     }
 128
 129
 130         return ret_ok;
 131 }
 132
 133 ret_t
 134 cherokee_handler_clusterstats_new  (cherokee_handler_t **hdl, cherokee_connection_t *cnt, cherokee_module_props_t *props)
 135 {
 136         ret_t ret;
 137
 138         CHEROKEE_NEW_STRUCT (n, handler_clusterstats);
 139
 140         /* Init the base class object
 141          */
 142         cherokee_handler_init_base(HANDLER(n), cnt, HANDLER_PROPS(props), PLUGIN_INFO_HANDLER_PTR(clusterstats));
 143
 144         MODULE(n)->init         = (handler_func_init_t) cherokee_handler_clusterstats_init;
 145         MODULE(n)->free         = (module_func_free_t) cherokee_handler_clusterstats_free;
 146         HANDLER(n)->step        = (handler_func_step_t) cherokee_handler_clusterstats_step;
 147         HANDLER(n)->add_headers = (handler_func_add_headers_t) cherokee_handler_clusterstats_add_headers;
 148
 149         HANDLER(n)->support = hsupport_length | hsupport_range;
 150
 151         /* Init
 152          */
 153         ret = cherokee_buffer_init (&n->buffer);
 154         if (unlikely(ret != ret_ok))
 155                 return ret;
 156
 157         ret = cherokee_buffer_ensure_size (&n->buffer, 4*1024);
 158         if (unlikely(ret != ret_ok))
 159                 return ret;
 160
 161         *hdl = HANDLER(n);
 162
 163         return ret_ok;
 164 }
 165
 166
 167 ret_t
 168 cherokee_handler_clusterstats_free (cherokee_handler_clusterstats_t *hdl)
 169 {
 170         cherokee_buffer_mrproper (&hdl->buffer);
 171
 172         return ret_ok;
 173 }
 174
 175 ret_t
 176 cherokee_handler_clusterstats_while_func_entries (cherokee_buffer_t *key, void *value, void *param) {
 177     cherokee_buffer_t *buf = (cherokee_buffer_t *)param;
 178     AvahiStringList *list  = (AvahiStringList *)value;
 179     char *avahi_key, *avahi_value;
 180     unsigned int len;
 181
 182     cherokee_buffer_add_str (buf, "  <domain status=\"running\">\n");
 183     cherokee_buffer_add_va  (buf, "    <name>%s</name>\n", key->buf);
 184
 185     if ((len = avahi_string_list_length (list)) > 0) {
 186     unsigned int i;
 187     cherokee_buffer_add_str (buf, "    <properties>\n");
 188
 189     for (i = 0; i < len; i++) {
 190         avahi_string_list_get_pair (list, &avahi_key, &avahi_value, NULL);
 191         cherokee_buffer_add_va  (buf, "      <property name=\"%s\">%s</property>\n", avahi_key, avahi_value);
 192         avahi_free(avahi_key);
 193         avahi_free(avahi_value);
 194         list = avahi_string_list_get_next(list);
 195     }
 196
 197     cherokee_buffer_add_str (buf, "    </properties>\n");
 198     } else {
 199     cherokee_buffer_add_str (buf, "    <properties/>\n");
 200     }
 201
 202     cherokee_buffer_add_str (buf, "  </domain>\n");
 203
 204     return ret_ok;
 205 }
 206
 207 static void
 208 clusterstats_build_page (cherokee_handler_clusterstats_t *hdl)
 209 {
 210     cherokee_buffer_t *buf;
 211     size_t len;
 212
 213     /* Init
 214      */
 215     buf = &hdl->buffer;
 216
 217     /* Useful output
 218      */
 219
 220     /* First, block the event loop */
 221 //    avahi_threaded_poll_lock(HDL_CLUSTERSTATS_PROPS(hdl)->threaded_poll);
 222
 223     /* Than, do your stuff */
 224     if (cherokee_avl_r_len(&HDL_CLUSTERSTATS_PROPS(hdl)->entries, &len) == ret_ok && len > 0) {
 225         cherokee_buffer_add_str (buf, "<domains>\n");
 226         cherokee_avl_r_while (&HDL_CLUSTERSTATS_PROPS(hdl)->entries, (cherokee_avl_while_func_t) cherokee_handler_clusterstats_while_func_entries, (void *) buf, NULL, NULL);
 227         cherokee_buffer_add_str (buf, "</domains>");
 228     } else {
 229         cherokee_buffer_add_str (buf, "<domains/>");
 230     }
 231
 232     /* Finally, unblock the event loop */
 233 //    avahi_threaded_poll_unlock(HDL_CLUSTERSTATS_PROPS(hdl)->threaded_poll);
 234 }
 235
 236 ret_t
 237 cherokee_handler_clusterstats_init (cherokee_handler_clusterstats_t *hdl)
 238 {
 239         cint_t  web_interface = 1;
 240
 241         /* Build the page
 242          */
 243         if (web_interface) {
 244                 clusterstats_build_page (hdl);
 245         }
 246
 247         hdl->action = send_page;
 248
 249         return ret_ok;
 250 }
 251
 252
 253 ret_t
 254 cherokee_handler_clusterstats_step (cherokee_handler_clusterstats_t *hdl, cherokee_buffer_t *buffer)
 255 {
 256         cuint_t tosend;
 257
 258         if (cherokee_buffer_is_empty (&hdl->buffer))
 259                 return ret_eof;
 260
 261         tosend = (hdl->buffer.len > 1024 ? 1024 : hdl->buffer.len);
 262
 263         cherokee_buffer_add (buffer, hdl->buffer.buf, tosend);
 264         cherokee_buffer_move_to_begin (&hdl->buffer, tosend);
 265
 266         if (cherokee_buffer_is_empty (&hdl->buffer))
 267                 return ret_eof_have_data;
 268
 269         return ret_ok;
 270 }
 271
 272
 273 ret_t
 274 cherokee_handler_clusterstats_add_headers (cherokee_handler_clusterstats_t *hdl, cherokee_buffer_t *buffer)
 275 {
 276     if (hdl->buffer.len == 0) {
 277         cherokee_connection_t *conn = HANDLER_CONN(hdl);
 278         conn->error_code = http_not_found;
 279     }
 280
 281         cherokee_buffer_add_va (buffer, "Content-Length: %d"CRLF, hdl->buffer.len);
 282
 283         switch (hdl->action) {
 284         case send_page:
 285         default:
 286                 cherokee_buffer_add_str (buffer, "Content-Type: application/xml"CRLF);
 287                     break;
 288         }
 289
 290         return ret_ok;
 291 }
 292
 293
 294 /* Avahi example stuff */
 295
 296 static void resolve_callback(
 297     AvahiServiceResolver *r,
 298     AVAHI_GCC_UNUSED AvahiIfIndex interface,
 299     AVAHI_GCC_UNUSED AvahiProtocol protocol,
 300     AvahiResolverEvent event,
 301     const char *name,
 302     const char *type,
 303     const char *domain,
 304     const char *host_name,
 305     const AvahiAddress *address,
 306     uint16_t port,
 307     AvahiStringList *txt,
 308     AvahiLookupResultFlags flags,
 309     void* userdata) {
 310     cherokee_handler_clusterstats_props_t *props = userdata;
 311     assert(r);
 312
 313     /* Called whenever a service has been resolved successfully or timed out */
 314
 315     switch (event) {
 316         case AVAHI_RESOLVER_FAILURE:
 317             TRACE("avahi", "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))));
 318              avahi_service_resolver_free(r);
 319             break;
 320
 321         case AVAHI_RESOLVER_FOUND: {
 322             char a[AVAHI_ADDRESS_STR_MAX];
 323             AvahiStringList *val;
 324             AvahiStringList *nonvol = avahi_string_list_copy(txt);
 325
 326             avahi_address_snprint(a, sizeof(a), address);
 327
 328
 329             cherokee_buffer_t buf = CHEROKEE_BUF_INIT;
 330             cherokee_buffer_add(&buf, name, strlen(name));
 331
 332             if (cherokee_avl_r_del(&props->entries, &buf, (void *) &val) == ret_ok) {
 333                 avahi_string_list_free(val);
 334             }
 335
 336             nonvol = avahi_string_list_add_pair(nonvol, "dom0", host_name);
 337
 338             cherokee_avl_r_add(&props->entries, &buf, (void* ) nonvol);
 339             cherokee_buffer_mrproper(&buf);
 340
 341             TRACE("avahi", "Service '%s' of type '%s' in domain '%s':\n", name, type, domain);
 342         }
 343     }
 344 }
 345
 346 static void browse_callback(
 347     AvahiServiceBrowser *b,
 348     AvahiIfIndex interface,
 349     AvahiProtocol protocol,
 350     AvahiBrowserEvent event,
 351     const char *name,
 352     const char *type,
 353     const char *domain,
 354     AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 355     void* userdata) {
 356     cherokee_handler_clusterstats_props_t *props = userdata;
 357     assert(b);
 358
 359     /* Called whenever a new services becomes available on the LAN or is removed from the LAN */
 360
 361     switch (event) {
 362         case AVAHI_BROWSER_FAILURE:
 363             TRACE("avahi", "(Browser) %s\n", avahi_strerror(avahi_client_errno(avahi_service_browser_get_client(b))));
 364             avahi_service_browser_free(b);
 365             return;
 366
 367         case AVAHI_BROWSER_NEW:
 368             TRACE("avahi", "(Browser) NEW: service '%s' of type '%s' in domain '%s'\n", name, type, domain);
 369
 370             /* We ignore the returned resolver object. In the callback
 371                function we free it. If the server is terminated before
 372                the callback function is called the server will free
 373                the resolver for us. */
 374
 375             if (!(avahi_service_resolver_new(avahi_service_browser_get_client(b), interface, protocol, name, type, domain, AVAHI_PROTO_UNSPEC, 0, resolve_callback, userdata)))
 376                 TRACE("avahi", "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_client_errno(avahi_service_browser_get_client(b))));
 377
 378             break;
 379
 380         case AVAHI_BROWSER_REMOVE: {
 381             void *val;
 382             cherokee_buffer_t buf = CHEROKEE_BUF_INIT;
 383             cherokee_buffer_add(&buf, name, strlen(name));
 384             if (cherokee_avl_r_del(&props->entries, &buf, &val) == ret_ok) {
 385                 avahi_string_list_free((AvahiStringList*) val);
 386             }
 387             cherokee_buffer_mrproper(&buf);
 388
 389 //            cherokee_avl_r_del_ptr(&PROP_CLUSTERSTATS(userdata)->entries, name, val);
 390
 391             TRACE("avahi", "(Browser) REMOVE: service '%s' of type '%s' in domain '%s'\n", name, type, domain);
 392             break;
 393         }
 394         case AVAHI_BROWSER_ALL_FOR_NOW:
 395         case AVAHI_BROWSER_CACHE_EXHAUSTED:
 396             TRACE("avahi", "(Browser) %s\n", event == AVAHI_BROWSER_CACHE_EXHAUSTED ? "CACHE_EXHAUSTED" : "ALL_FOR_NOW");
 397             break;
 398     }
 399 }
 400
 401 static void client_callback(AvahiClient *c, AvahiClientState state, void * userdata) {
 402     cherokee_handler_clusterstats_props_t *props = userdata;
 403
 404     /* Called whenever the client or server state changes */
 405
 406     switch (state) {
 407         case AVAHI_CLIENT_S_RUNNING: {
 408             if (!(props->sb = avahi_service_browser_new(c, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, props->service_type.buf, NULL, 0, browse_callback, props))) {
 409                 TRACE ("avahi", "Failed to create service browser: %s (%s)\n", avahi_strerror(avahi_client_errno(c)), props->service_type.buf);
 410             }
 411             break;
 412         }
 413
 414         case AVAHI_CLIENT_FAILURE: {
 415             int error;
 416             if (c)
 417                 avahi_client_free(c);
 418
 419             props->client = avahi_client_new(avahi_threaded_poll_get(props->threaded_poll), AVAHI_CLIENT_NO_FAIL, client_callback, props, &error);
 420             break;
 421         }
 422
 423         default:
 424             break;
 425     }
 426 }
 427
 428 ret_t
 429 cherokee_handler_clusterstats_props_init_base (cherokee_handler_clusterstats_props_t *props, module_func_props_free_t free_func)
 430 {
 431     cherokee_buffer_init (&props->service_type);
 432
 433     return cherokee_handler_props_init_base (HANDLER_PROPS(props), free_func);
 434 }