src/router/router.h

   1 #include "opensrf/transport_client.h"
   2 #include "opensrf/transport_message.h"
   3 #include <time.h>
   4 #include <sys/select.h>
   5
   6 #ifndef ROUTER_H
   7 #define ROUTER_H
   8
   9 // ----------------------------------------------------------------------
  10 // Jabber router_registrar/load balancer.  There is a top level linked list of
  11 // server_class_nodes.  A server class represents the a cluster of Jabber
  12 // clients that define a single logical routing endpoint.  Each of these
  13 // server_class_nodes maintains a list of connected server_nodes, which
  14 // represents the pool of connected server endpoints.  A request
  15 // directed at a particular class is routed to the next available
  16 // server endpoint.
  17 //
  18 // ----------------------------------------------------------------------
  19
  20
  21 // ----------------------------------------------------------------------
  22 // Defines an element in a server list.  The server list is a circular
  23 // doubly linked list.  User is responsible for freeing a server_node with
  24 // server_node_free()
  25 // ----------------------------------------------------------------------
  26 struct server_node_struct {
  27
  28         struct server_node_struct* next;
  29         struct server_node_struct* prev;
  30
  31         time_t la_time; /* last time we sent a message to a server */
  32         time_t reg_time;        /* time we originally registered */
  33         time_t upd_time;        /* last re-register time */
  34         int available;          /* true if we may be used */
  35
  36         int serve_count; /* how many messages we've sent */
  37
  38         /* jabber remote id  for this server node*/
  39         char* remote_id;
  40
  41         /* we cache the last sent message in case our remote
  42                 endpoint has gone away.  If it has, the next server
  43                 node in the list will re-send our last message */
  44         transport_message* last_sent;
  45
  46 };
  47 typedef struct server_node_struct server_node;
  48
  49
  50 // ----------------------------------------------------------------------
  51 // Models a basic jabber connection structure.  Any component that
  52 // connects to jabber will have one of these.
  53 // ----------------------------------------------------------------------
  54 struct jabber_connect_struct {
  55
  56         char* server;
  57         int port;
  58         char* username;
  59         char* password;
  60         char* resource;
  61         int connect_timeout;
  62
  63         transport_client* t_client;
  64 };
  65 typedef struct jabber_connect_struct jabber_connect;
  66
  67
  68
  69 // ----------------------------------------------------------------------
  70 // Defines an element in the list of server classes.  User is
  71 // responsible for freeing a server_class_node with
  72 // server_class_node_free().
  73 // The server_node_list is a doubly (not circular) linked list
  74 // ----------------------------------------------------------------------
  75 struct server_class_node_struct {
  76
  77         /* the name of our class.  This will be used as the jabber
  78          resource when we create a class level connection*/
  79         char* server_class;
  80
  81         /* the current node in the ring of available server nodes */
  82         server_node* current_server_node;
  83
  84         /* next and prev class_node pointers */
  85         struct server_class_node_struct* next;
  86         struct server_class_node_struct* prev;
  87
  88         /* our jabber connection struct */
  89         jabber_connect* jabber;
  90
  91 };
  92 typedef struct server_class_node_struct server_class_node;
  93
  94 // ----------------------------------------------------------------------
  95 // Top level router_registrar object.  Maintains the list of
  96 // server_class_nodes and the top level router jabber connection.
  97 // ----------------------------------------------------------------------
  98 struct transport_router_registrar_struct {
  99
 100         /* the list of server class nodes */
 101         server_class_node* server_class_list;
 102
 103         /* if we don't hear from the client in this amount of time
 104                 we consider them dead... */
 105         /* not currently used */
 106         int client_timeout; /* seconds */
 107
 108         /* our top level connection to the jabber server */
 109         jabber_connect* jabber;
 110
 111
 112 };
 113 typedef struct transport_router_registrar_struct transport_router_registrar;
 114
 115
 116
 117
 118 // ----------------------------------------------------------------------
 119 // Returns an allocated transport_router_registrar.  The user is responsible for
 120 // freeing the allocated memory with router_registrar_free()
 121 // client_timeout is unused at this time.
 122 // connect_timeout is how long we will wait for a failed jabber connect
 123 // attempt for the top level connection.
 124 // ----------------------------------------------------------------------
 125 transport_router_registrar* router_registrar_init( char* server,
 126                 int port, char* username, char* password, char* resource,
 127                 int client_timeout, int connect_timeout );
 128
 129 // ----------------------------------------------------------------------
 130 // Connects the top level router_registrar object to the Jabber server.
 131 // ----------------------------------------------------------------------
 132 int router_registrar_connect( transport_router_registrar* router );
 133
 134 // ----------------------------------------------------------------------
 135 // Connects the given jabber_connect object to the Jabber server
 136 // ----------------------------------------------------------------------
 137 int j_connect( jabber_connect* jabber );
 138
 139
 140 // ----------------------------------------------------------------------
 141 // Builds and initializes a jabber_connect object. User is responsible
 142 // for freeing the memory with jabber_connect_free();
 143 // ----------------------------------------------------------------------
 144 jabber_connect* jabber_connect_init( char* server,
 145                 int port, char* username, char* password,
 146                 char* resource, int connect_timeout );
 147
 148 // ----------------------------------------------------------------------
 149 // Allocates and initializes a server class instance.  This will be
 150 // called when a new class message arrives.  It will connect to Jabber
 151 // as router_registrar->username@router_registrar->server/new_class
 152 // ----------------------------------------------------------------------
 153 server_class_node* init_server_class(
 154                 transport_router_registrar* router_registrar, char* remote_id, char* server_class );
 155
 156 // ----------------------------------------------------------------------
 157 // Allocates and initializes a server_node object.  The object must
 158 // be freed with server_node_free().
 159 // remote_id is the full jabber login for the remote server connection
 160 // I.e. where we send messages when we want to send them to this
 161 // server.
 162 // ----------------------------------------------------------------------
 163 server_node* init_server_node(  char* remote_id );
 164
 165
 166 // ----------------------------------------------------------------------
 167 // Routes messages sent to the provided server_class_node's class
 168 // ----------------------------------------------------------------------
 169 int  server_class_handle_msg( transport_router_registrar* router,
 170                 server_class_node* s_node, transport_message* msg );
 171
 172 // ----------------------------------------------------------------------
 173 // Determines what to do with an inbound register/unregister message.
 174 // ----------------------------------------------------------------------
 175 int router_registrar_handle_msg( transport_router_registrar*, transport_message* msg );
 176
 177 // ----------------------------------------------------------------------
 178 // Deallocates the memory occupied by the given server_node
 179 // ----------------------------------------------------------------------
 180 int server_node_free( server_node* node );
 181
 182 // ----------------------------------------------------------------------
 183 // Deallocates the memory used by the given server_class_node.  This
 184 // will also free any attached server_node's.
 185 // ----------------------------------------------------------------------
 186 int server_class_node_free( server_class_node* node );
 187
 188 // ----------------------------------------------------------------------
 189 // Deallocates the memory used by a server_node
 190 // ----------------------------------------------------------------------
 191 int server_node_free( server_node* node );
 192
 193
 194 // ----------------------------------------------------------------------
 195 // Deallocates a jabber_connect node
 196 // ----------------------------------------------------------------------
 197 int jabber_connect_free( jabber_connect* jabber );
 198
 199 // ----------------------------------------------------------------------
 200 // Deallocates the memory used by the router_registrar.  This will also call
 201 // server_class_node_free on any attached server_class_nodes.
 202 // ----------------------------------------------------------------------
 203 int router_registrar_free( transport_router_registrar* router_registrar );
 204
 205
 206 // ----------------------------------------------------------------------
 207 //  Returns the server_node with the given Jabber remote_id
 208 // ----------------------------------------------------------------------
 209 server_node * find_server_node ( server_class_node * class, const char * remote_id );
 210
 211
 212 // ----------------------------------------------------------------------
 213 // Returns the server_class_node object with the given class_name
 214 // ----------------------------------------------------------------------
 215 server_class_node * find_server_class ( transport_router_registrar * router, const char * class_id );
 216
 217 // ----------------------------------------------------------------------
 218 // Removes a server class from the top level router_registrar
 219 // ----------------------------------------------------------------------
 220 int unregister_server_node( server_class_node* active_class_node, char* remote_id );
 221
 222 int fill_fd_set( transport_router_registrar* router, fd_set* set );
 223
 224 void listen_loop( transport_router_registrar* router );
 225
 226
 227 int router_return_server_info( transport_router_registrar* router, transport_message* msg );
 228
 229 int remove_server_class( transport_router_registrar* router, server_class_node* class );
 230 // ----------------------------------------------------------------------
 231 // Adds a handler for the SIGUSR1 that we send to wake all the
 232 // listening threads.
 233 // ----------------------------------------------------------------------
 234 //void sig_handler( int sig );
 235
 236 #endif