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