src/router/router.h

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