11252568670

Committed 09 Oct 2024 09:53AM UTC coverage: 79.598% (-3.2%) from 82.787%

Build # 11252568670

Build Type

Pull #544

github

Committed by

web-flow

Commit Message

Merge e762d4942 into 2c45e28dd

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

Run Details

266 of 371 branches covered (71.7%)

Branch coverage included in aggregate %.

19 of 54 new or added lines in 4 files covered. (35.19%)

24 existing lines in 2 files now uncovered.

764 of 923 relevant lines covered (82.77%)

50.21 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 +
                      ' | Query=' + JSON.stringify(req.query) +
                      ' | 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	' \| Query=' + JSON.stringify(req.query) +
92	' \| Body=' + JSON.stringify(req.body) +
93	' \| Date=' + new Date().toJSON());
94	next(error);	×
95	}
96
97	/**
98	* Error handler intended to transform errors triggered in the Express framework by middlewares we don't
99	* control, wrapping the foreign errors in an error of our own. This middleware is very specific for the different
100	* types of external errors.
101	*
102	* @param {Object} error Error that triggered the execution of the handler.
103	* @param {Object} req Incoming request.
104	* @param {Object} res Outgoing response.
105	* @param {Function} next Call to the next error handler in the chain.
106	*/
107	function transformSystemErrors(error, req, res, next) {	1✔
108	if (error.name === 'SyntaxError' \|\| error.message === 'invalid json') {	89✔
109	next(new errors.WrongJsonPayload());	1✔
110	} else {
111	next(error);	88✔
112	}
113	}
114
115	function setAuthenticationModule(moduleName) {	1✔
116	authorization = require('./services/' + config.authentication.module + 'Auth');	143✔
117	}
118
119
120	function setAccessLogger() {	1✔
121	accessLogger = new winston.Logger({	143✔
122	level: 'info',
123	transports: [
124	new(winston.transports.File)({
125	filename: config.access.accountFile
126	})
127	]
128	});
129	proxyMiddleware.watchConfigAccessMatchFile();	143✔
130	}
131
132	/**
133	* Middleware that makes Express read the incoming body if the content-type is text/xml or application/xml (the default
134	* behavior is to read the body if it can be parsed and leave it unread in any other case).
135	*
136	* @param {Object} req Incoming request.
137	* @param {Object} res Outgoing response.
138	* @param {Function} next Invokes the next middleware in the chain.
139	*/
140	function xmlRawBody(req, res, next) {	1✔
141	if (!req.is('*/xml')) {	165✔
142	next();	164✔
143	} else {
144	var data = '';	1✔
145	req.setEncoding('utf8');	1✔
146	req.on('data', function(chunk) {	1✔
147	data += chunk;	1✔
148	});
149	req.on('end', function() {	1✔
150	req.rawBody = data;	1✔
151	next();	1✔
152	});
153	}
154	}
155
156	/**
157	* Middleware that makes Express read the incoming body if the content-type is text/plain (the default
158	* behavior is to read the body if it can be parsed and leave it unread in any other case).
159	*
160	* @param {Object} req Incoming request.
161	* @param {Object} res Outgoing response.
162	* @param {Function} next Invokes the next middleware in the chain.
163	*/
164	function rawBody(req, res, next) {	1✔
165	if (!req.is('text/plain')) {	165!
166	next();	165✔
167	} else {
UNCOV 168	req.setEncoding('utf8');	×
UNCOV 169	req.rawBody = '';	×
UNCOV 170	req.on('data', function(chunk) {	×
171	req.rawBody += chunk;	×
172	});
173	req.on('end', function() {	×
174	next();	×
175	});
176	}
177	}
178
179	/**
180	* This function creates a middleware that executes the current list of dynamic middlewares configured after the proxy
181	* has been started.
182	*
183	* @return {Function} Express middleware that executes the dynamic middlewares.
184	*/
185	function createDynamicMiddlewareExecutor(proxyObj) {	1✔
186	return function dynamicMiddlewareExecutor(req, res, next) {	143✔
187	var middlewareList = proxyObj.middlewares.slice(0);	154✔
188
189	if (middlewareList.length > 0) {	154✔
190	middlewareList[0] = async.apply(proxyObj.middlewares[0], req, res);	153✔
191	async.waterfall(middlewareList, next);	153✔
192	} else {
193	next();	1✔
194	}
195	};
196	}
197
198	/**
199	* Trace the incoming request data to the log. It prints headers and body, using an indentation of 4 spaces. NOTE:
200	* in the case of this middleware there is no performance penalty for using the JSON.stringify() function instead of
201	* the '%j' classifier in the log pattern, as this middleware will be executed just in the case where the proxy has
202	* been started in debugging mode (so the indentation has been kept in this log entries to ease the debugging tasks).
203	*
204	* @param {Object} req Incoming request.
205	* @param {Object} res Outgoing response.
206	* @param {Function} next Call to the next error handler in the chain.
207	*/
208	function traceRequest(req, res, next) {	1✔
UNCOV 209	const logger = req.logger;	×
UNCOV 210	logger.debug('Request for path [%s] from [%s]', req.path, req.get('host'));	×
UNCOV 211	logger.debug('Headers:\n%j\n', req.headers);	×
212
213	if (req.headers['content-type'] && req.headers['content-type'] !== undefined) {	×
214	if (req.headers['content-type'].includes('application/json')) {	×
UNCOV 215	logger.debug('Body:\n\n%s\n\n', JSON.stringify(req.body, null, 4));	×
216	} else if ( req.headers['content-type'].includes('application/xml') \|\|	×
217	req.headers['content-type'].includes('text/plain') ) {
218	logger.debug('Body:\n\n%s\n\n', req.rawBody);	×
219	} else {
UNCOV 220	logger.debug('Unrecognized body type', req.headers['content-type']);	×
221	}
222	} else {
223	logger.debug('Not found body type');	×
224	}
225
226	next();	×
227	}
228
229	/**
230	* Initializes the proxy server. It fills the proxyObj with information about the started proxy and passes it along.
231	*
232	* @param {Object} proxyObj Running data of the whole proxy application.
233	*/
234	function initializeProxy(proxyObj, callback) {	1✔
235	proxyObj.proxy = express();	143✔
236
237	proxyObj.proxy.set('port', config.resource.proxy.port);	143✔
238	proxyObj.proxy.set('host', '0.0.0.0');	143✔
239	proxyObj.proxy.use(bodyParser.json({limit: config.bodyLimit ? config.bodyLimit : '1Mb'}));	143!
240	proxyObj.proxy.use(xmlRawBody);	143✔
241	proxyObj.proxy.use(rawBody);	143✔
242	proxyObj.proxy.use(bodyParser.urlencoded({limit: config.bodyLimit ? config.bodyLimit : '1Mb', extended: true}));	143!
243	proxyObj.proxy.use(loggingMiddleware);	143✔
244
245	if (config.logLevel && config.logLevel.toUpperCase() === 'DEBUG') {	143!
UNCOV 246	proxyObj.proxy.use(traceRequest);	×
247	}
248
249	if (!config.access.disable \|\| config.authentication.checkHeaders) {	143✔
250	proxyObj.proxy.use(proxyMiddleware.checkMandatoryHeaders);	140✔
251	proxyObj.proxy.use(proxyMiddleware.extractOrganization);	140✔
252	proxyObj.proxy.use(proxyMiddleware.extractUserId);	140✔
253	} else {
254	proxyObj.proxy.use(proxyMiddleware.checkAuthorizationHeader);	3✔
255	}
256
257	proxyObj.proxy.use(createDynamicMiddlewareExecutor(proxyObj));	143✔
258	proxyObj.proxy.use(proxyMiddleware.generateFRN);	143✔
259	proxyObj.proxy.use(authorization.process);	143✔
260
261	if (!config.access.disable) {	143✔
262	proxyObj.proxy.use(validation.checkBypass);	140✔
263	proxyObj.proxy.use(validation.validate);	140✔
264	}
265
266	proxyObj.proxy.use(proxyMiddleware.sendRequest);	143✔
267	if (config.access.account === true) {	143!
UNCOV 268	proxyObj.proxy.use(proxyMiddleware.accountInfo);	×
269	}
270	proxyObj.proxy.use(proxyMiddleware.sendResponse);	143✔
271
272	proxyObj.proxy.use(transformSystemErrors);	143✔
273	if (config.access.account === true) {	143!
UNCOV 274	proxyObj.proxy.use(accountInfoError);	×
275	}
276	proxyObj.proxy.use(handleError);	143✔
277
278
279	if (config.ssl.active) {	143✔
280	var sslOptions = {	1✔
281	key: fs.readFileSync('./' + config.ssl.keyFile),
282	cert: fs.readFileSync('./' + config.ssl.certFile)
283	};
284
285	proxyObj.server = https.createServer(sslOptions, proxyObj.proxy);	1✔
286	} else {
287	proxyObj.server = http.createServer(proxyObj.proxy);	142✔
288	}
289
290
291	validation.init(function initValidation(loadingError) {	143✔
292	if (loadingError) {	143!
UNCOV 293	logger.error('Error initValidation: ' + loadingError.message);	×
294	} else {
295	proxyObj.server.listen(	143✔
296	proxyObj.proxy.get('port'),
297	proxyObj.proxy.get('host'),
298	function startServer(error) {
299	if (error) {	143!
UNCOV 300	logger.error('[PROXY-GEN-003] Error initializing proxy: ' + error.message);	×
UNCOV 301	callback(error);	×
302	} else {
303	logger.info('Proxy listening on port %d', config.resource.proxy.port);	143✔
304	logger.info('Redirecting to host %s and port %d',	143✔
305	config.resource.original.host, config.resource.original.port);
306	callback(error, proxyObj);	143✔
307	}
308	});
309	}
310	});
311	}
312
313	/**
314	* Initializes the administration server. It fills the proxyObj with information about the started proxy and passes
315	* it along.
316	*
317	* @param {Object} proxyObj Running data of the whole proxy application.
318	*/
319	function initializeAdmin(proxyObj, callback) {	1✔
320	proxyObj.administration = express();	143✔
321
322	proxyObj.administration.set('port', config.resource.proxy.adminPort);	143✔
323	proxyObj.administration.set('host', '0.0.0.0');	143✔
324	proxyObj.administration.use(bodyParser.json({limit: config.bodyLimit ? config.bodyLimit : '1Mb'}));	143!
325	proxyObj.administration.use(bodyParser.urlencoded({limit: config.bodyLimit ? config.bodyLimit : '1Mb',	143!
326	extended: true}));
327	proxyObj.administration.use(loggingMiddleware);	143✔
328	proxyObj.administration.use(handleError);	143✔
329
330	adminMiddleware.loadContextRoutes(proxyObj.administration);	143✔
331
332	if (config.ssl.active) {	143✔
333	var sslOptions = {	1✔
334	key: fs.readFileSync('./' + config.ssl.keyFile),
335	cert: fs.readFileSync('./' + config.ssl.certFile)
336	};
337
338	proxyObj.adminServer = https.createServer(sslOptions, proxyObj.administration);	1✔
339	} else {
340	proxyObj.adminServer = http.createServer(proxyObj.administration);	142✔
341	}
342
343	validation.init(function initValidation(loadingError) {	143✔
344	if (loadingError) {	143!
UNCOV 345	logger.error('Error initValidation: ' + loadingError.message);	×
346	} else {
347	proxyObj.adminServer.listen(	143✔
348	proxyObj.administration.get('port'),
349	proxyObj.administration.get('host'),
350	function startServer(error) {
351	if (error) {	143!
UNCOV 352	logger.error('[PROXY-GEN-004] Error initializing administration server: ' + error.message);	×
UNCOV 353	callback(error);	×
354	} else {
355	logger.info('Administration service listening on port %d', config.resource.proxy.adminPort);	143✔
356	callback(error, proxyObj);	143✔
357	}
358	});
359	}
360	});
361	}
362
363	/**
364	* Start a new proxy for the configured target. All the configuration is picked up from the config file.
365	*
366	* @param {Function} callback When the proxy is created, this handler is called with an object containing: the
367	* http server the proxy is using; the proxy itself; and an array of middlewares that
368	* can be populated with code to be executed after all the standard code has been
369	* executed.
370	*/
371	function startProxy(callback) {	1✔
372	var proxyObj = {	143✔
373	server: null,
374	adminServer: null,
375	middlewares: []
376	};
377
378	logger.setLevel(config.logLevel);	143✔
379
380	logger.format = logger.formatters.pipe;	143✔
381
382	logger.info('Creating proxy');	143✔
383
384	setAccessLogger();	143✔
385
386	cacheUtils.create();	143✔
387
388	setAuthenticationModule(config.authentication.module);	143✔
389
390	async.waterfall([	143✔
391	async.apply(initializeProxy, proxyObj),
392	initializeAdmin
393	], callback);
394
395	}
396
397	/**
398	* Stops the proxy passed as a parameter.
399	*
400	* @param {Object} proxy The proxy object as it was returned in the creation callback (this is not the proxy
401	* field of the returned object, but the whole object).
402	*/
403	function stopProxy(proxy, callback) {	1✔
404	logger.info('Stopping proxy');	143✔
405
406	proxy.server.close(function() {	143✔
407	proxy.adminServer.close(callback);	143✔
408	});
409	}
410
411	exports.start = startProxy;	1✔
412	exports.stop = stopProxy;	1✔

telefonicaid / fiware-pep-steelskin / 11252568670

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