Initial revision
[OpenSRF.git] / src / router / router.h
1 #include "transport_client.h"
2 #include "transport_message.h"
3 #include <time.h>
4 #include <sys/select.h>
5
6 #ifndef TRANSPORT_ROUTER_H
7 #define TRANSPORT_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 remove_server_class( transport_router_registrar* router, server_class_node* class );
228 // ----------------------------------------------------------------------
229 // Adds a handler for the SIGUSR1 that we send to wake all the 
230 // listening threads.
231 // ----------------------------------------------------------------------
232 //void sig_handler( int sig );
233
234 #endif