1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 |
|
23 |
|
24 |
|
25 |
|
26 |
|
27 |
|
28 |
|
29 |
|
30 |
|
31 | console.log('running up/handlers.js in process ' + process.pid);
|
32 |
|
33 | var createDocStoreEvents = require('./createDocStoreEvents');
|
34 | var handleDocStoreEvents = require('./handleDocStoreEvents');
|
35 |
|
36 | var ignorePaths = {};
|
37 | var beforeHandlerFn;
|
38 | var errorResponse;
|
39 | var onWorkerLoad;
|
40 | var docStoreEventsArr;
|
41 | var docStoreEvents;
|
42 | var workerResponseHandler = {};
|
43 | var onResponseHandler = {};
|
44 |
|
45 | function getRoutes(isMaster) {
|
46 | var fs = require('fs');
|
47 | var cwd = process.cwd();
|
48 |
|
49 |
|
50 | if (fs.existsSync(cwd + '/mapped')) cwd = cwd + '/mapped';
|
51 | if (process.env.qewd_service_name) {
|
52 | cwd = cwd + '/' + process.env.qewd_service_name;
|
53 | }
|
54 |
|
55 | var routes_data = require(cwd + '/configuration/routes.json');
|
56 | var routes = [];
|
57 |
|
58 | var handlerRootPath = cwd + '/apis';
|
59 | var orchestratorHandlerPath = cwd + '/orchestrator/apis';
|
60 | if (fs.existsSync(orchestratorHandlerPath)) {
|
61 | handlerRootPath = orchestratorHandlerPath;
|
62 |
|
63 | }
|
64 | console.log('handlerRootPath = ' + handlerRootPath);
|
65 |
|
66 | routes_data.forEach(function(route) {
|
67 | if (route.router) {
|
68 | console.log('dynamically routed');
|
69 |
|
70 | return;
|
71 | }
|
72 | if (route.else) {
|
73 | errorResponse = route.else;
|
74 | return;
|
75 | }
|
76 |
|
77 | if (route.on_microservice) return;
|
78 |
|
79 | var path_root = '';
|
80 | var handler;
|
81 | var ms_source = handlerRootPath;
|
82 | if (route.handler_source) {
|
83 | ms_source = cwd + '/' + route.handler_source;
|
84 | }
|
85 | var handlerPath = ms_source + '/' + route.handler;
|
86 | var handlerPaths = [
|
87 | handlerPath + '/handler.js',
|
88 | handlerPath
|
89 | ];
|
90 | var handlerFound = false;
|
91 | for (var i = 0; i < handlerPaths.length; i++) {
|
92 | if (fs.existsSync(handlerPaths[i])) {
|
93 | try {
|
94 | handler = require(handlerPaths[i]);
|
95 | console.log('loaded handler from ' + handlerPaths[i]);
|
96 | }
|
97 | catch(err) {
|
98 | console.log('** Warning - unable to load handler from ' + handlerPaths[i] + ': ');
|
99 | console.log(err);
|
100 | }
|
101 | handlerFound = true;
|
102 | break;
|
103 | }
|
104 | }
|
105 | if (!handlerFound) {
|
106 | console.log('** Warning: unable to find handler module for ' + route.handler);
|
107 | }
|
108 |
|
109 | var routeObj = {
|
110 | url: route.uri,
|
111 | method: route.method,
|
112 | handler: handler
|
113 | };
|
114 |
|
115 | var onRequestPath = handlerPath + '/onRequest.js';
|
116 | console.log('onRequestPath: ' + onRequestPath);
|
117 | if (fs.existsSync(onRequestPath)) {
|
118 | routeObj.onRequest = require(onRequestPath);
|
119 | }
|
120 |
|
121 | var onResponsePath = handlerPath + '/onResponse.js';
|
122 | if (fs.existsSync(onResponsePath)) {
|
123 |
|
124 | var pathPieces = route.uri.split('/');
|
125 | var type = pathPieces[2];
|
126 | if (!workerResponseHandler[type]) {
|
127 | workerResponseHandler[type] = function(message, req) {
|
128 | if (onResponseHandler[req.originalUrl]) {
|
129 | return onResponseHandler[req.originalUrl].call(this, message, req);
|
130 | }
|
131 | return message;
|
132 | };
|
133 | }
|
134 | try {
|
135 | onResponseHandler[route.uri] = require(onResponsePath);
|
136 | console.log('Successfully loaded ' + onResponsePath);
|
137 | }
|
138 | catch(err) {
|
139 | console.log('*** Warning: unable to load ' + onResponsePath);
|
140 | }
|
141 | }
|
142 |
|
143 | routes.push(routeObj);
|
144 | if (route.applyBeforeHandler === false) {
|
145 | ignorePaths[route.uri] = true;
|
146 | }
|
147 |
|
148 | });
|
149 |
|
150 | if (!isMaster) {
|
151 |
|
152 | var onWorkerLoadPath = cwd + '/onWorkerLoad.js';
|
153 | if (fs.existsSync(onWorkerLoadPath)) {
|
154 | try {
|
155 | onWorkerLoad = require(onWorkerLoadPath);
|
156 | console.log('Loaded onWorkerLoad module from ' + onWorkerLoadPath);
|
157 | }
|
158 | catch(err) {
|
159 | console.log('** Warning - unable to load onWorkerLoad module from ' + onWorkerLoadPath);
|
160 | }
|
161 | }
|
162 | else {
|
163 | onWorkerLoadPath = cwd + '/apis/onWorkerLoad.js';
|
164 | if (fs.existsSync(onWorkerLoadPath)) {
|
165 | try {
|
166 | onWorkerLoad = require(onWorkerLoadPath);
|
167 | console.log('Loaded onWorkerLoad module from ' + onWorkerLoadPath);
|
168 | }
|
169 | catch(err) {
|
170 | console.log('** Warning - unable to load onWorkerLoad module from ' + onWorkerLoadPath);
|
171 | }
|
172 | }
|
173 | }
|
174 |
|
175 | var beforeHandlerPath = handlerRootPath + '/beforeHandler.js';
|
176 | console.log('beforeHandlerPath: ' + beforeHandlerPath);
|
177 |
|
178 | if (fs.existsSync(beforeHandlerPath)) {
|
179 | try {
|
180 | beforeHandlerFn = require(beforeHandlerPath);
|
181 | console.log('Loaded beforeHandler module from ' + beforeHandlerPath);
|
182 | }
|
183 | catch(err) {
|
184 | console.log('** Warning - unable to load ' + beforeHandlerPath);
|
185 | }
|
186 | }
|
187 |
|
188 | console.log('Loading ' + cwd + '/docStoreEvents/events.json');
|
189 | var docStoreEventsPath = cwd + '/docStoreEvents/events.json';
|
190 | if (fs.existsSync(docStoreEventsPath)) {
|
191 | docStoreEvents = createDocStoreEvents(docStoreEventsPath, cwd);
|
192 | }
|
193 | }
|
194 |
|
195 |
|
196 | return routes;
|
197 | }
|
198 |
|
199 | function beforeHandler(req, finished) {
|
200 | if (!beforeHandlerFn) return;
|
201 | if (ignorePaths[req.path]) return;
|
202 | return beforeHandlerFn.call(this, req, finished);
|
203 | }
|
204 |
|
205 | module.exports = {
|
206 | restModule: true,
|
207 | up: true,
|
208 | init: function(application, isMaster) {
|
209 | var _this = this;
|
210 | var router = require('qewd-router');
|
211 | var routes = getRoutes(isMaster);
|
212 | routes = router.initialise(routes, module.exports);
|
213 | if (errorResponse) {
|
214 | var statusCode = errorResponse.statusCode || 404;
|
215 | var text = errorResponse.text || 'Not Found';
|
216 | router.setErrorResponse(statusCode, text);
|
217 | this.setCustomErrorResponse.call(this, {
|
218 | application: application,
|
219 | errorType: 'noTypeHandler',
|
220 | text: text,
|
221 | statusCode: statusCode
|
222 | });
|
223 | }
|
224 | module.exports.workerResponseHandlers = workerResponseHandler;
|
225 |
|
226 | if (onWorkerLoad && !isMaster) {
|
227 | onWorkerLoad.call(this);
|
228 | }
|
229 |
|
230 | if (docStoreEvents && !isMaster) {
|
231 | handleDocStoreEvents.call(this, docStoreEvents);
|
232 | }
|
233 |
|
234 | },
|
235 | beforeHandler: function(req, finished) {
|
236 | return beforeHandler.call(this, req, finished);
|
237 | },
|
238 | workerResponseHandlers: {
|
239 | }
|
240 | };
|