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