moved C code to a unified logging framework which currently supports syslogging and...
[OpenSRF.git] / src / router / osrf_router.h
1 #include <sys/select.h>
2 #include <signal.h>
3 #include <stdio.h>
4
5 #include "opensrf/utils.h"
6 #include "opensrf/log.h"
7 #include "opensrf/osrf_list.h"
8 #include "opensrf/osrf_hash.h"
9
10 #include "opensrf/string_array.h"
11 #include "opensrf/transport_client.h"
12 #include "opensrf/transport_message.h"
13
14 #include "opensrf/osrf_message.h"
15
16
17
18 /* a router maintains a list of server classes */
19 struct __osrfRouterStruct {
20
21         osrfHash* classes;      /* our list of server classes */
22         char* domain;                   /* our login domain */
23         char* name;
24         char* resource;
25         char* password;
26         int port;
27
28         osrfStringArray* trustedClients;
29         osrfStringArray* trustedServers;
30
31         transport_client* connection;
32 };
33
34 typedef struct __osrfRouterStruct osrfRouter;
35
36
37 /* a class maintains a set of server nodes */
38 struct __osrfRouterClassStruct {
39         osrfRouter* router; /* our router handle */
40         osrfHashIterator* itr;
41         osrfHash* nodes;
42         transport_client* connection;
43 };
44 typedef struct __osrfRouterClassStruct osrfRouterClass;
45
46 /* represents a link to a single server's inbound connection */
47 struct __osrfRouterNodeStruct {
48         char* remoteId; /* send message to me via this login */
49         int count;                      /* how many message have been sent to this node */
50         transport_message* lastMessage;
51 };
52 typedef struct __osrfRouterNodeStruct osrfRouterNode;
53
54 /**
55   Allocates a new router.  
56   @param domain The jabber domain to connect to
57   @param name The login name for the router
58   @param resource The login resource for the router
59   @param password The login password for the new router
60   @param port The port to connect to the jabber server on
61   @param trustedClients The array of client domains that we allow to send requests through us
62   @param trustedServers The array of server domains that we allow to register, etc. with ust.
63   @return The allocated router or NULL on memory error
64   */
65 osrfRouter* osrfNewRouter( char* domain, char* name, char* resource, 
66         char* password, int port, osrfStringArray* trustedClients, osrfStringArray* trustedServers );
67
68 /**
69   Connects the given router to the network
70   */
71 int osrfRouterConnect( osrfRouter* router );
72
73 /**
74   Waits for incoming data to route
75   If this function returns, then the router's connection to the jabber server
76   has failed.
77   */
78 void osrfRouterRun( osrfRouter* router );
79
80
81 /**
82   Allocates and adds a new router class handler to the router's list of handlers.
83   Also connects the class handler to the network at <routername>@domain/<classname>
84   @param router The current router instance
85   @param classname The name of the class this node handles.
86   @return 0 on success, -1 on connection error.
87   */
88 osrfRouterClass* osrfRouterAddClass( osrfRouter* router, char* classname );
89
90 /**
91   Adds a new server node to the given class.
92   @param rclass The Router class to add the node to
93   @param remoteId The remote login of this node
94   @return 0 on success, -1 on generic error
95   */
96 int osrfRouterClassAddNode( osrfRouterClass* rclass, char* remoteId );
97
98
99 /**
100   Handles top level router messages
101   @return 0 on success
102   */
103 int osrfRouterHandleMessage( osrfRouter* router, transport_message* msg );
104
105
106 /**
107   Handles class level requests
108   @return 0 on success
109   */
110 int osrfRouterClassHandleMessage( osrfRouter* router, 
111                 osrfRouterClass* rclass, transport_message* msg );
112
113 /**
114   Removes a given class from the router, freeing as it goes
115   */
116 int osrfRouterRemoveClass( osrfRouter* router, char* classname );
117
118 /**
119   Removes the given node from the class.  Also, if this is that last node in the set,
120   removes the class from the router 
121   @return 0 on successful removal with no class removal
122   @return 1 on successful remove with class removal
123   @return -1 error on removal
124  */
125 int osrfRouterClassRemoveNode( osrfRouter* router, char* classname, char* remoteId );
126
127 /**
128   Frees a router class object
129   Takes a void* since it is freed by the hash code
130   */
131 void osrfRouterClassFree( char* classname, void* rclass );
132
133 /**
134   Frees a router node object 
135   Takes a void* since it is freed by the list code
136   */
137 void osrfRouterNodeFree( char* remoteId, void* node );
138
139
140 /**
141   Frees a router
142   */
143 void osrfRouterFree( osrfRouter* router );
144
145 /**
146   Finds the class associated with the given class name in the list of classes
147   */
148 osrfRouterClass* osrfRouterFindClass( osrfRouter* router, char* classname );
149
150 /**
151   Finds the router node within this class with the given remote id 
152   */
153 osrfRouterNode* osrfRouterClassFindNode( osrfRouterClass* rclass, char* remoteId );
154
155
156 /**
157   Clears and populates the provided fd_set* with file descriptors
158   from the router's top level connection as well as each of the
159   router class connections
160   @return The largest file descriptor found in the filling process
161   */
162 int __osrfRouterFillFDSet( osrfRouter* router, fd_set* set );
163
164
165
166 /**
167   Utility method for handling incoming requests to the router
168   and making sure the sender is allowed.
169   */
170 void osrfRouterHandleIncoming( osrfRouter* router );
171
172 /**
173         Utility method for handling incoming requests to a router class,
174         makes sure sender is a trusted client
175         */
176 int osrfRouterClassHandleIncoming( osrfRouter* router, char* classname,  osrfRouterClass* class );
177
178 /* handles case where router node is not longer reachable.  copies over the
179         data from the last sent message and returns a newly crafted suitable for treating
180         as a newly inconing message.  Removes the dead node and If there are no more
181         nodes to send the new message to, returns NULL.
182         */
183 transport_message* osrfRouterClassHandleBounce(
184                 osrfRouter* router, char* classname, osrfRouterClass* rclass, transport_message* msg );
185
186
187
188 /**
189   handles messages that don't have a 'router_command' set.  They are assumed to
190   be app request messages 
191   */
192 int osrfRouterHandleAppRequest( osrfRouter* router, transport_message* msg );
193
194
195 /**
196   Handles connects, disconnects, etc.
197   */
198 int osrfRouterHandeStatusMessage( osrfRouter* router, transport_message* msg );
199
200
201 /**
202   Handles REQUEST messages 
203   */
204 int osrfRouterHandleRequestMessage( osrfRouter* router, transport_message* msg );
205
206
207
208 int osrfRouterHandleAppRequest( osrfRouter* router, transport_message* msg );
209
210
211 int osrfRouterRespondConnect( osrfRouter* router, transport_message* msg, osrfMessage* omsg );
212
213
214
215 int osrfRouterProcessAppRequest( osrfRouter* router, transport_message* msg, osrfMessage* omsg );
216
217 int osrfRouterHandleAppResponse( osrfRouter* router, 
218                 transport_message* msg, osrfMessage* omsg, jsonObject* response );
219
220
221 int osrfRouterHandleMethodNFound( osrfRouter* router, transport_message* msg, osrfMessage* omsg );
222