providing option to connect to memcache at general connect time
[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( const char* domain, const char* name, const char* resource, 
66         const char* password, int port, osrfStringArray* trustedClients,
67         osrfStringArray* trustedServers );
68
69 /**
70   Connects the given router to the network
71   */
72 int osrfRouterConnect( osrfRouter* router );
73
74 /**
75   Waits for incoming data to route
76   If this function returns, then the router's connection to the jabber server
77   has failed.
78   */
79 void osrfRouterRun( osrfRouter* router );
80
81
82 /**
83   Allocates and adds a new router class handler to the router's list of handlers.
84   Also connects the class handler to the network at <routername>@domain/<classname>
85   @param router The current router instance
86   @param classname The name of the class this node handles.
87   @return 0 on success, -1 on connection error.
88   */
89 osrfRouterClass* osrfRouterAddClass( osrfRouter* router, const char* classname );
90
91 /**
92   Adds a new server node to the given class.
93   @param rclass The Router class to add the node to
94   @param remoteId The remote login of this node
95   @return 0 on success, -1 on generic error
96   */
97 int osrfRouterClassAddNode( osrfRouterClass* rclass, const char* remoteId );
98
99
100 /**
101   Handles top level router messages
102   @return 0 on success
103   */
104 int osrfRouterHandleMessage( osrfRouter* router, transport_message* msg );
105
106
107 /**
108   Handles class level requests
109   @return 0 on success
110   */
111 int osrfRouterClassHandleMessage( osrfRouter* router, 
112                 osrfRouterClass* rclass, transport_message* msg );
113
114 /**
115   Removes a given class from the router, freeing as it goes
116   */
117 int osrfRouterRemoveClass( osrfRouter* router, const char* classname );
118
119 /**
120   Removes the given node from the class.  Also, if this is that last node in the set,
121   removes the class from the router 
122   @return 0 on successful removal with no class removal
123   @return 1 on successful remove with class removal
124   @return -1 error on removal
125  */
126 int osrfRouterClassRemoveNode( osrfRouter* router, const char* classname,
127                 const char* remoteId );
128
129 /**
130   Frees a router class object
131   Takes a void* since it is freed by the hash code
132   */
133 void osrfRouterClassFree( char* classname, void* rclass );
134
135 /**
136   Frees a router node object 
137   Takes a void* since it is freed by the list code
138   */
139 void osrfRouterNodeFree( char* remoteId, void* node );
140
141
142 /**
143   Frees a router
144   */
145 void osrfRouterFree( osrfRouter* router );
146
147 /**
148   Finds the class associated with the given class name in the list of classes
149   */
150 osrfRouterClass* osrfRouterFindClass( osrfRouter* router, const char* classname );
151
152 /**
153   Finds the router node within this class with the given remote id 
154   */
155 osrfRouterNode* osrfRouterClassFindNode( osrfRouterClass* rclass, const char* remoteId );
156
157
158 /**
159   Clears and populates the provided fd_set* with file descriptors
160   from the router's top level connection as well as each of the
161   router class connections
162   @return The largest file descriptor found in the filling process
163   */
164 int __osrfRouterFillFDSet( osrfRouter* router, fd_set* set );
165
166
167
168 /**
169   Utility method for handling incoming requests to the router
170   and making sure the sender is allowed.
171   */
172 void osrfRouterHandleIncoming( osrfRouter* router );
173
174 /**
175         Utility method for handling incoming requests to a router class,
176         makes sure sender is a trusted client
177         */
178 int osrfRouterClassHandleIncoming( osrfRouter* router,
179                 const char* classname,  osrfRouterClass* class );
180
181 /* handles case where router node is not longer reachable.  copies over the
182         data from the last sent message and returns a newly crafted suitable for treating
183         as a newly inconing message.  Removes the dead node and If there are no more
184         nodes to send the new message to, returns NULL.
185         */
186 transport_message* osrfRouterClassHandleBounce( osrfRouter* router,
187                 const char* classname, osrfRouterClass* rclass, transport_message* msg );
188
189
190
191 /**
192   handles messages that don't have a 'router_command' set.  They are assumed to
193   be app request messages 
194   */
195 int osrfRouterHandleAppRequest( osrfRouter* router, transport_message* msg );
196
197
198 /**
199   Handles connects, disconnects, etc.
200   */
201 int osrfRouterHandeStatusMessage( osrfRouter* router, transport_message* msg );
202
203
204 /**
205   Handles REQUEST messages 
206   */
207 int osrfRouterHandleRequestMessage( osrfRouter* router, transport_message* msg );
208
209
210
211 int osrfRouterHandleAppRequest( osrfRouter* router, transport_message* msg );
212
213
214 int osrfRouterRespondConnect( osrfRouter* router, transport_message* msg, osrfMessage* omsg );
215
216
217
218 int osrfRouterProcessAppRequest( osrfRouter* router, transport_message* msg, osrfMessage* omsg );
219
220 int osrfRouterHandleAppResponse( osrfRouter* router, 
221                 transport_message* msg, osrfMessage* omsg, const jsonObject* response );
222
223
224 int osrfRouterHandleMethodNFound( osrfRouter* router, transport_message* msg, osrfMessage* omsg );
225