all opensrf related headers are shoved into opensrf/*.h
[working/Evergreen.git] / OpenSRF / 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