11232906442

Committed 08 Oct 2024 09:48AM UTC coverage: 79.891% (-2.9%) from 82.787%

Build # 11232906442

Build Type

Pull #544

github

Committed by

web-flow

Commit Message

Merge 744559321 into 2c45e28dd

Pull Request Pull Request #544: [WIP] Task/add access matches (about users, headers, path. .. ) to access Logger

Run Details

266 of 369 branches covered (72.09%)

Branch coverage included in aggregate %.

18 of 50 new or added lines in 4 files covered. (36.0%)

22 existing lines in 2 files now uncovered.

763 of 919 relevant lines covered (83.03%)

50.42 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.22

/lib/fiware-pep-steelskin.js

/*
 * Copyright 2014 Telefonica Investigación y Desarrollo, S.A.U
 *
 * This file is part of fiware-pep-steelskin
 *
 * fiware-pep-steelskin is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the License,
 * or (at your option) any later version.
 *
 * fiware-pep-steelskin is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public
 * License along with fiware-pep-steelskin.
 * If not, seehttp://www.gnu.org/licenses/.
 *
 * For those usages not covered by the GNU Affero General Public License
 * please contact with::[iot_support@tid.es]
 */

'use strict';

var http = require('http'),
    https = require('https'),
    fs = require('fs'),
    express = require('express'),
    errors = require('./errors'),
    config = require('../config'),
    adminMiddleware = require('./middleware/administration'),
    validation = require('./services/validation'),
    proxyMiddleware = require('./middleware/proxy'),
    authorization,
    async = require('async'),
    logger = require('logops'),
    loggingMiddleware = require('./middleware/logging').requestLogger('PEP' + (config.componentName || 'Proxy')),
    cacheUtils = require('./services/cacheUtils'),
    winston = require('winston'),
    bodyParser = require('body-parser'),
    accessLogger;

/**
 * Generic error handler for every request that raises an error in the validation process. TODO: change the error code
 * depending on the error type.
 *
 * @param {Object} error         Error that triggered the execution of the handler.
 * @param {Object} req           Incoming request.
 * @param {Object} res           Outgoing response.
 * @param {Function} next        Call to the next error handler in the chain.
 */
function handleError(error, req, res, next) {
    var code;

    if (error.code) {
        code = error.code;
    } else {
        code = 403;
    }

    res.status(code).json({
        name: error.name,
        message: error.message
    });
}

/**
 * Account info access error
 *
 * @param {Object} error         Error that triggered the execution of the handler.
 * @param {Object} req           Incoming request.
 * @param {Object} res           Outgoing response.
 * @param {Function} next        Call to the next error handler in the chain.
 */
function accountInfoError(error, req, res, next) {
    var accessMsg = 'Wrong Attempt';
    accessMsg = proxyMiddleware.checkAccessMatches(req, accessMsg);
    accessLogger.info(accessMsg +
                      ' | Error=' + error.name +
                      ' | Token=' + req.headers['x-auth-token'] +
                      ' | Origin=' + req.connection.remoteAddress +
                      ' | UserId=' + req.userId +
                      ' | ServiceId=' + req.serviceId +
                      ' | UserName=' + req.userName +
                      ' | Service=' + req.service +
                      ' | SubServiceId=' + req.subserviceId +
                      ' | SubService=' + req.subService +
                      ' | Action=' + req.action +
                      ' | Path=' + req.path +
                      ' | Body=' + JSON.stringify(req.body) +
                      ' | Date=' + new Date().toJSON());
    next(error);
}

/**
 * Error handler intended to transform errors triggered in the Express framework by middlewares we don't
 * control, wrapping the foreign errors in an error of our own. This middleware is very specific for the different
 * types of external errors.
 *
 * @param {Object} error         Error that triggered the execution of the handler.
 * @param {Object} req           Incoming request.
 * @param {Object} res           Outgoing response.
 * @param {Function} next        Call to the next error handler in the chain.
 */
function transformSystemErrors(error, req, res, next) {
    if (error.name === 'SyntaxError' || error.message === 'invalid json') {
        next(new errors.WrongJsonPayload());
    } else {
        next(error);
    }
}

function setAuthenticationModule(moduleName) {
    authorization = require('./services/' + config.authentication.module + 'Auth');
}


function setAccessLogger() {
    accessLogger = new winston.Logger({
        level: 'info',
        transports: [
            new(winston.transports.File)({
                filename: config.access.accountFile
            })
        ]
    });
    proxyMiddleware.watchConfigAccessMatchFile();
}

/**
 * Middleware that makes Express read the incoming body if the content-type is text/xml or application/xml (the default
 * behavior is to read the body if it can be parsed and leave it unread in any other case).
 *
 * @param {Object} req           Incoming request.
 * @param {Object} res           Outgoing response.
 * @param {Function} next        Invokes the next middleware in the chain.
 */
function xmlRawBody(req, res, next) {
    if (!req.is('*/xml')) {
        next();
    } else {
        var data = '';
        req.setEncoding('utf8');
        req.on('data', function(chunk) {
            data += chunk;
        });
        req.on('end', function() {
            req.rawBody = data;
            next();
        });
    }
}

/**
 * Middleware that makes Express read the incoming body if the content-type is text/plain (the default
 * behavior is to read the body if it can be parsed and leave it unread in any other case).
 *
 * @param {Object} req           Incoming request.
 * @param {Object} res           Outgoing response.
 * @param {Function} next        Invokes the next middleware in the chain.
 */
function rawBody(req, res, next) {
    if (!req.is('text/plain')) {
        next();
    } else {
        req.setEncoding('utf8');
        req.rawBody = '';
        req.on('data', function(chunk) {
            req.rawBody += chunk;
        });
        req.on('end', function() {
            next();
        });
    }
}

/**
 * This function creates a middleware that executes the current list of dynamic middlewares configured after the proxy
 * has been started.
 *
 * @return {Function}           Express middleware that executes the dynamic middlewares.
 */
function createDynamicMiddlewareExecutor(proxyObj) {
    return function dynamicMiddlewareExecutor(req, res, next) {
        var middlewareList = proxyObj.middlewares.slice(0);

        if (middlewareList.length > 0) {
            middlewareList[0] = async.apply(proxyObj.middlewares[0], req, res);
            async.waterfall(middlewareList, next);
        } else {
            next();
        }
    };
}

/**
 * Trace the incoming request data to the log. It prints headers and body, using an indentation of 4 spaces. NOTE:
 * in the case of this middleware there is no performance penalty for using the JSON.stringify() function instead of
 * the '%j' classifier in the log pattern, as this middleware will be executed just in the case where the proxy has
 * been started in debugging mode (so the indentation has been kept in this log entries to ease the debugging tasks).
 *
 * @param {Object} req           Incoming request.
 * @param {Object} res           Outgoing response.
 * @param {Function} next        Call to the next error handler in the chain.
 */
function traceRequest(req, res, next) {
    const logger = req.logger;
    logger.debug('Request for path [%s] from [%s]', req.path, req.get('host'));
    logger.debug('Headers:\n%j\n', req.headers);

    if (req.headers['content-type'] && req.headers['content-type'] !== undefined) {
        if (req.headers['content-type'].includes('application/json')) {
            logger.debug('Body:\n\n%s\n\n', JSON.stringify(req.body, null, 4));
        } else if ( req.headers['content-type'].includes('application/xml') ||
                    req.headers['content-type'].includes('text/plain') ) {
            logger.debug('Body:\n\n%s\n\n', req.rawBody);
        } else {
            logger.debug('Unrecognized body type', req.headers['content-type']);
        }
    } else {
        logger.debug('Not found body type');
    }

    next();
}

/**
 * Initializes the proxy server. It fills the proxyObj with information about the started proxy and passes it along.
 *
 * @param {Object} proxyObj         Running data of the whole proxy application.
 */
function initializeProxy(proxyObj, callback) {
    proxyObj.proxy = express();

    proxyObj.proxy.set('port', config.resource.proxy.port);
    proxyObj.proxy.set('host', '0.0.0.0');
    proxyObj.proxy.use(bodyParser.json({limit: config.bodyLimit ? config.bodyLimit : '1Mb'}));
    proxyObj.proxy.use(xmlRawBody);
    proxyObj.proxy.use(rawBody);
    proxyObj.proxy.use(bodyParser.urlencoded({limit: config.bodyLimit ? config.bodyLimit : '1Mb', extended: true}));
    proxyObj.proxy.use(loggingMiddleware);

    if (config.logLevel && config.logLevel.toUpperCase() === 'DEBUG') {
        proxyObj.proxy.use(traceRequest);
    }

    if (!config.access.disable || config.authentication.checkHeaders) {
        proxyObj.proxy.use(proxyMiddleware.checkMandatoryHeaders);
        proxyObj.proxy.use(proxyMiddleware.extractOrganization);
        proxyObj.proxy.use(proxyMiddleware.extractUserId);
    } else {
        proxyObj.proxy.use(proxyMiddleware.checkAuthorizationHeader);
    }

    proxyObj.proxy.use(createDynamicMiddlewareExecutor(proxyObj));
    proxyObj.proxy.use(proxyMiddleware.generateFRN);
    proxyObj.proxy.use(authorization.process);

    if (!config.access.disable) {
        proxyObj.proxy.use(validation.checkBypass);
        proxyObj.proxy.use(validation.validate);
    }

    proxyObj.proxy.use(proxyMiddleware.sendRequest);
    if (config.access.account === true) {
        proxyObj.proxy.use(proxyMiddleware.accountInfo);
    }
    proxyObj.proxy.use(proxyMiddleware.sendResponse);

    proxyObj.proxy.use(transformSystemErrors);
    if (config.access.account === true) {
        proxyObj.proxy.use(accountInfoError);
    }
    proxyObj.proxy.use(handleError);


    if (config.ssl.active) {
        var sslOptions = {
            key: fs.readFileSync('./' + config.ssl.keyFile),
            cert: fs.readFileSync('./' + config.ssl.certFile)
        };

        proxyObj.server = https.createServer(sslOptions, proxyObj.proxy);
    } else {
        proxyObj.server = http.createServer(proxyObj.proxy);
    }


    validation.init(function initValidation(loadingError) {
        if (loadingError) {
            logger.error('Error initValidation: ' + loadingError.message);
        } else {
            proxyObj.server.listen(
                proxyObj.proxy.get('port'),
                proxyObj.proxy.get('host'),
                function startServer(error) {
                    if (error) {
                        logger.error('[PROXY-GEN-003] Error initializing proxy: ' + error.message);
                        callback(error);
                    } else {
                        logger.info('Proxy listening on port %d', config.resource.proxy.port);
                        logger.info('Redirecting to host %s and port %d',
                                    config.resource.original.host, config.resource.original.port);
                        callback(error, proxyObj);
                    }
                });
        }
    });
}

/**
 * Initializes the administration server. It fills the proxyObj with information about the started proxy and passes
 * it along.
 *
 * @param {Object} proxyObj         Running data of the whole proxy application.
 */
function initializeAdmin(proxyObj, callback) {
    proxyObj.administration = express();

    proxyObj.administration.set('port', config.resource.proxy.adminPort);
    proxyObj.administration.set('host', '0.0.0.0');
    proxyObj.administration.use(bodyParser.json({limit: config.bodyLimit ? config.bodyLimit : '1Mb'}));
    proxyObj.administration.use(bodyParser.urlencoded({limit: config.bodyLimit ? config.bodyLimit : '1Mb',
                                                       extended: true}));
    proxyObj.administration.use(loggingMiddleware);
    proxyObj.administration.use(handleError);

    adminMiddleware.loadContextRoutes(proxyObj.administration);

    if (config.ssl.active) {
        var sslOptions = {
            key: fs.readFileSync('./' + config.ssl.keyFile),
            cert: fs.readFileSync('./' + config.ssl.certFile)
        };

        proxyObj.adminServer = https.createServer(sslOptions, proxyObj.administration);
    } else {
        proxyObj.adminServer = http.createServer(proxyObj.administration);
    }

    validation.init(function initValidation(loadingError) {
        if (loadingError) {
            logger.error('Error initValidation: ' + loadingError.message);
        } else {
            proxyObj.adminServer.listen(
                proxyObj.administration.get('port'),
                proxyObj.administration.get('host'),
                function startServer(error) {
                    if (error) {
                        logger.error('[PROXY-GEN-004] Error initializing administration server: ' + error.message);
                        callback(error);
                    } else {
                        logger.info('Administration service listening on port %d', config.resource.proxy.adminPort);
                        callback(error, proxyObj);
                    }
                });
        }
    });
}

/**
 * Start a new proxy for the configured target. All the configuration is picked up from the config file.
 *
 * @param {Function} callback      When the proxy is created, this handler is called with an object containing: the
 *                                 http server the proxy is using; the proxy itself; and an array of middlewares that
 *                                 can be populated with code to be executed after all the standard code has been
 *                                 executed.
 */
function startProxy(callback) {
    var proxyObj = {
        server: null,
        adminServer: null,
        middlewares: []
    };

    logger.setLevel(config.logLevel);

    logger.format = logger.formatters.pipe;

    logger.info('Creating proxy');

    setAccessLogger();

    cacheUtils.create();

    setAuthenticationModule(config.authentication.module);

    async.waterfall([
        async.apply(initializeProxy, proxyObj),
        initializeAdmin
    ], callback);

}

/**
 * Stops the proxy passed as a parameter.
 *
 * @param {Object} proxy         The proxy object as it was returned in the creation callback (this is not the proxy
 *                               field of the returned object, but the whole object).
 */
function stopProxy(proxy, callback) {
    logger.info('Stopping proxy');

    proxy.server.close(function() {
        proxy.adminServer.close(callback);
    });
}

exports.start = startProxy;
exports.stop = stopProxy;

1	/*
2	* Copyright 2014 Telefonica Investigación y Desarrollo, S.A.U
3	*
4	* This file is part of fiware-pep-steelskin
5	*
6	* fiware-pep-steelskin is free software: you can redistribute it and/or
7	* modify it under the terms of the GNU Affero General Public License as
8	* published by the Free Software Foundation, either version 3 of the License,
9	* or (at your option) any later version.
10	*
11	* fiware-pep-steelskin is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14	* See the GNU Affero General Public License for more details.
15	*
16	* You should have received a copy of the GNU Affero General Public
17	* License along with fiware-pep-steelskin.
18	* If not, seehttp://www.gnu.org/licenses/.
19	*
20	* For those usages not covered by the GNU Affero General Public License
21	* please contact with::[iot_support@tid.es]
22	*/
23
24	'use strict';
25
26	var http = require('http'),	1✔
27	https = require('https'),
28	fs = require('fs'),
29	express = require('express'),
30	errors = require('./errors'),
31	config = require('../config'),
32	adminMiddleware = require('./middleware/administration'),
33	validation = require('./services/validation'),
34	proxyMiddleware = require('./middleware/proxy'),
35	authorization,
36	async = require('async'),
37	logger = require('logops'),
38	loggingMiddleware = require('./middleware/logging').requestLogger('PEP' + (config.componentName \|\| 'Proxy')),	1!
39	cacheUtils = require('./services/cacheUtils'),
40	winston = require('winston'),
41	bodyParser = require('body-parser'),
42	accessLogger;
43
44	/**
45	* Generic error handler for every request that raises an error in the validation process. TODO: change the error code
46	* depending on the error type.
47	*
48	* @param {Object} error Error that triggered the execution of the handler.
49	* @param {Object} req Incoming request.
50	* @param {Object} res Outgoing response.
51	* @param {Function} next Call to the next error handler in the chain.
52	*/
53	function handleError(error, req, res, next) {	1✔
54	var code;	89✔
55
56	if (error.code) {	89!
57	code = error.code;	89✔
58	} else {
59	code = 403;	×
60	}
61
62	res.status(code).json({	89✔
63	name: error.name,
64	message: error.message
65	});
66	}
67
68	/**
69	* Account info access error
70	*
71	* @param {Object} error Error that triggered the execution of the handler.
72	* @param {Object} req Incoming request.
73	* @param {Object} res Outgoing response.
74	* @param {Function} next Call to the next error handler in the chain.
75	*/
76	function accountInfoError(error, req, res, next) {	1✔
NEW 77	var accessMsg = 'Wrong Attempt';	×
NEW 78	accessMsg = proxyMiddleware.checkAccessMatches(req, accessMsg);	×
NEW 79	accessLogger.info(accessMsg +	×
80	' \| Error=' + error.name +
81	' \| Token=' + req.headers['x-auth-token'] +
82	' \| Origin=' + req.connection.remoteAddress +
83	' \| UserId=' + req.userId +
84	' \| ServiceId=' + req.serviceId +
85	' \| UserName=' + req.userName +
86	' \| Service=' + req.service +
87	' \| SubServiceId=' + req.subserviceId +
88	' \| SubService=' + req.subService +
89	' \| Action=' + req.action +
90	' \| Path=' + req.path +
91	' \| Body=' + JSON.stringify(req.body) +
92	' \| Date=' + new Date().toJSON());
93	next(error);	×
94	}
95
96	/**
97	* Error handler intended to transform errors triggered in the Express framework by middlewares we don't
98	* control, wrapping the foreign errors in an error of our own. This middleware is very specific for the different
99	* types of external errors.
100	*
101	* @param {Object} error Error that triggered the execution of the handler.
102	* @param {Object} req Incoming request.
103	* @param {Object} res Outgoing response.
104	* @param {Function} next Call to the next error handler in the chain.
105	*/
106	function transformSystemErrors(error, req, res, next) {	1✔
107	if (error.name === 'SyntaxError' \|\| error.message === 'invalid json') {	89✔
108	next(new errors.WrongJsonPayload());	1✔
109	} else {
110	next(error);	88✔
111	}
112	}
113
114	function setAuthenticationModule(moduleName) {	1✔
115	authorization = require('./services/' + config.authentication.module + 'Auth');	143✔
116	}
117
118
119	function setAccessLogger() {	1✔
120	accessLogger = new winston.Logger({	143✔
121	level: 'info',
122	transports: [
123	new(winston.transports.File)({
124	filename: config.access.accountFile
125	})
126	]
127	});
128	proxyMiddleware.watchConfigAccessMatchFile();	143✔
129	}
130
131	/**
132	* Middleware that makes Express read the incoming body if the content-type is text/xml or application/xml (the default
133	* behavior is to read the body if it can be parsed and leave it unread in any other case).
134	*
135	* @param {Object} req Incoming request.
136	* @param {Object} res Outgoing response.
137	* @param {Function} next Invokes the next middleware in the chain.
138	*/
139	function xmlRawBody(req, res, next) {	1✔
140	if (!req.is('*/xml')) {	165✔
141	next();	164✔
142	} else {
143	var data = '';	1✔
144	req.setEncoding('utf8');	1✔
145	req.on('data', function(chunk) {	1✔
146	data += chunk;	1✔
147	});
148	req.on('end', function() {	1✔
149	req.rawBody = data;	1✔
150	next();	1✔
151	});
152	}
153	}
154
155	/**
156	* Middleware that makes Express read the incoming body if the content-type is text/plain (the default
157	* behavior is to read the body if it can be parsed and leave it unread in any other case).
158	*
159	* @param {Object} req Incoming request.
160	* @param {Object} res Outgoing response.
161	* @param {Function} next Invokes the next middleware in the chain.
162	*/
163	function rawBody(req, res, next) {	1✔
164	if (!req.is('text/plain')) {	165!
165	next();	165✔
166	} else {
UNCOV 167	req.setEncoding('utf8');	×
UNCOV 168	req.rawBody = '';	×
UNCOV 169	req.on('data', function(chunk) {	×
UNCOV 170	req.rawBody += chunk;	×
171	});
172	req.on('end', function() {	×
173	next();	×
174	});
175	}
176	}
177
178	/**
179	* This function creates a middleware that executes the current list of dynamic middlewares configured after the proxy
180	* has been started.
181	*
182	* @return {Function} Express middleware that executes the dynamic middlewares.
183	*/
184	function createDynamicMiddlewareExecutor(proxyObj) {	1✔
185	return function dynamicMiddlewareExecutor(req, res, next) {	143✔
186	var middlewareList = proxyObj.middlewares.slice(0);	154✔
187
188	if (middlewareList.length > 0) {	154✔
189	middlewareList[0] = async.apply(proxyObj.middlewares[0], req, res);	153✔
190	async.waterfall(middlewareList, next);	153✔
191	} else {
192	next();	1✔
193	}
194	};
195	}
196
197	/**
198	* Trace the incoming request data to the log. It prints headers and body, using an indentation of 4 spaces. NOTE:
199	* in the case of this middleware there is no performance penalty for using the JSON.stringify() function instead of
200	* the '%j' classifier in the log pattern, as this middleware will be executed just in the case where the proxy has
201	* been started in debugging mode (so the indentation has been kept in this log entries to ease the debugging tasks).
202	*
203	* @param {Object} req Incoming request.
204	* @param {Object} res Outgoing response.
205	* @param {Function} next Call to the next error handler in the chain.
206	*/
207	function traceRequest(req, res, next) {	1✔
UNCOV 208	const logger = req.logger;	×
UNCOV 209	logger.debug('Request for path [%s] from [%s]', req.path, req.get('host'));	×
UNCOV 210	logger.debug('Headers:\n%j\n', req.headers);	×
211
212	if (req.headers['content-type'] && req.headers['content-type'] !== undefined) {	×
213	if (req.headers['content-type'].includes('application/json')) {	×
214	logger.debug('Body:\n\n%s\n\n', JSON.stringify(req.body, null, 4));	×
UNCOV 215	} else if ( req.headers['content-type'].includes('application/xml') \|\|	×
216	req.headers['content-type'].includes('text/plain') ) {
217	logger.debug('Body:\n\n%s\n\n', req.rawBody);	×
218	} else {
219	logger.debug('Unrecognized body type', req.headers['content-type']);	×
220	}
221	} else {
UNCOV 222	logger.debug('Not found body type');	×
223	}
224
UNCOV 225	next();	×
226	}
227
228	/**
229	* Initializes the proxy server. It fills the proxyObj with information about the started proxy and passes it along.
230	*
231	* @param {Object} proxyObj Running data of the whole proxy application.
232	*/
233	function initializeProxy(proxyObj, callback) {	1✔
234	proxyObj.proxy = express();	143✔
235
236	proxyObj.proxy.set('port', config.resource.proxy.port);	143✔
237	proxyObj.proxy.set('host', '0.0.0.0');	143✔
238	proxyObj.proxy.use(bodyParser.json({limit: config.bodyLimit ? config.bodyLimit : '1Mb'}));	143!
239	proxyObj.proxy.use(xmlRawBody);	143✔
240	proxyObj.proxy.use(rawBody);	143✔
241	proxyObj.proxy.use(bodyParser.urlencoded({limit: config.bodyLimit ? config.bodyLimit : '1Mb', extended: true}));	143!
242	proxyObj.proxy.use(loggingMiddleware);	143✔
243
244	if (config.logLevel && config.logLevel.toUpperCase() === 'DEBUG') {	143!
UNCOV 245	proxyObj.proxy.use(traceRequest);	×
246	}
247
248	if (!config.access.disable \|\| config.authentication.checkHeaders) {	143✔
249	proxyObj.proxy.use(proxyMiddleware.checkMandatoryHeaders);	140✔
250	proxyObj.proxy.use(proxyMiddleware.extractOrganization);	140✔
251	proxyObj.proxy.use(proxyMiddleware.extractUserId);	140✔
252	} else {
253	proxyObj.proxy.use(proxyMiddleware.checkAuthorizationHeader);	3✔
254	}
255
256	proxyObj.proxy.use(createDynamicMiddlewareExecutor(proxyObj));	143✔
257	proxyObj.proxy.use(proxyMiddleware.generateFRN);	143✔
258	proxyObj.proxy.use(authorization.process);	143✔
259
260	if (!config.access.disable) {	143✔
261	proxyObj.proxy.use(validation.checkBypass);	140✔
262	proxyObj.proxy.use(validation.validate);	140✔
263	}
264
265	proxyObj.proxy.use(proxyMiddleware.sendRequest);	143✔
266	if (config.access.account === true) {	143!
UNCOV 267	proxyObj.proxy.use(proxyMiddleware.accountInfo);	×
268	}
269	proxyObj.proxy.use(proxyMiddleware.sendResponse);	143✔
270
271	proxyObj.proxy.use(transformSystemErrors);	143✔
272	if (config.access.account === true) {	143!
UNCOV 273	proxyObj.proxy.use(accountInfoError);	×
274	}
275	proxyObj.proxy.use(handleError);	143✔
276
277
278	if (config.ssl.active) {	143✔
279	var sslOptions = {	1✔
280	key: fs.readFileSync('./' + config.ssl.keyFile),
281	cert: fs.readFileSync('./' + config.ssl.certFile)
282	};
283
284	proxyObj.server = https.createServer(sslOptions, proxyObj.proxy);	1✔
285	} else {
286	proxyObj.server = http.createServer(proxyObj.proxy);	142✔
287	}
288
289
290	validation.init(function initValidation(loadingError) {	143✔
291	if (loadingError) {	143!
UNCOV 292	logger.error('Error initValidation: ' + loadingError.message);	×
293	} else {
294	proxyObj.server.listen(	143✔
295	proxyObj.proxy.get('port'),
296	proxyObj.proxy.get('host'),
297	function startServer(error) {
298	if (error) {	143!
UNCOV 299	logger.error('[PROXY-GEN-003] Error initializing proxy: ' + error.message);	×
UNCOV 300	callback(error);	×
301	} else {
302	logger.info('Proxy listening on port %d', config.resource.proxy.port);	143✔
303	logger.info('Redirecting to host %s and port %d',	143✔
304	config.resource.original.host, config.resource.original.port);
305	callback(error, proxyObj);	143✔
306	}
307	});
308	}
309	});
310	}
311
312	/**
313	* Initializes the administration server. It fills the proxyObj with information about the started proxy and passes
314	* it along.
315	*
316	* @param {Object} proxyObj Running data of the whole proxy application.
317	*/
318	function initializeAdmin(proxyObj, callback) {	1✔
319	proxyObj.administration = express();	143✔
320
321	proxyObj.administration.set('port', config.resource.proxy.adminPort);	143✔
322	proxyObj.administration.set('host', '0.0.0.0');	143✔
323	proxyObj.administration.use(bodyParser.json({limit: config.bodyLimit ? config.bodyLimit : '1Mb'}));	143!
324	proxyObj.administration.use(bodyParser.urlencoded({limit: config.bodyLimit ? config.bodyLimit : '1Mb',	143!
325	extended: true}));
326	proxyObj.administration.use(loggingMiddleware);	143✔
327	proxyObj.administration.use(handleError);	143✔
328
329	adminMiddleware.loadContextRoutes(proxyObj.administration);	143✔
330
331	if (config.ssl.active) {	143✔
332	var sslOptions = {	1✔
333	key: fs.readFileSync('./' + config.ssl.keyFile),
334	cert: fs.readFileSync('./' + config.ssl.certFile)
335	};
336
337	proxyObj.adminServer = https.createServer(sslOptions, proxyObj.administration);	1✔
338	} else {
339	proxyObj.adminServer = http.createServer(proxyObj.administration);	142✔
340	}
341
342	validation.init(function initValidation(loadingError) {	143✔
343	if (loadingError) {	143!
UNCOV 344	logger.error('Error initValidation: ' + loadingError.message);	×
345	} else {
346	proxyObj.adminServer.listen(	143✔
347	proxyObj.administration.get('port'),
348	proxyObj.administration.get('host'),
349	function startServer(error) {
350	if (error) {	143!
UNCOV 351	logger.error('[PROXY-GEN-004] Error initializing administration server: ' + error.message);	×
UNCOV 352	callback(error);	×
353	} else {
354	logger.info('Administration service listening on port %d', config.resource.proxy.adminPort);	143✔
355	callback(error, proxyObj);	143✔
356	}
357	});
358	}
359	});
360	}
361
362	/**
363	* Start a new proxy for the configured target. All the configuration is picked up from the config file.
364	*
365	* @param {Function} callback When the proxy is created, this handler is called with an object containing: the
366	* http server the proxy is using; the proxy itself; and an array of middlewares that
367	* can be populated with code to be executed after all the standard code has been
368	* executed.
369	*/
370	function startProxy(callback) {	1✔
371	var proxyObj = {	143✔
372	server: null,
373	adminServer: null,
374	middlewares: []
375	};
376
377	logger.setLevel(config.logLevel);	143✔
378
379	logger.format = logger.formatters.pipe;	143✔
380
381	logger.info('Creating proxy');	143✔
382
383	setAccessLogger();	143✔
384
385	cacheUtils.create();	143✔
386
387	setAuthenticationModule(config.authentication.module);	143✔
388
389	async.waterfall([	143✔
390	async.apply(initializeProxy, proxyObj),
391	initializeAdmin
392	], callback);
393
394	}
395
396	/**
397	* Stops the proxy passed as a parameter.
398	*
399	* @param {Object} proxy The proxy object as it was returned in the creation callback (this is not the proxy
400	* field of the returned object, but the whole object).
401	*/
402	function stopProxy(proxy, callback) {	1✔
403	logger.info('Stopping proxy');	143✔
404
405	proxy.server.close(function() {	143✔
406	proxy.adminServer.close(callback);	143✔
407	});
408	}
409
410	exports.start = startProxy;	1✔
411	exports.stop = stopProxy;	1✔

telefonicaid / fiware-pep-steelskin / 11232906442

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous