const convertOpValue = async (identifier, {
authInfo
} = {}) => {
const organisation = getOrgFromAuthInfo(authInfo);
const personaService = getService();
const filter = {
key: identifier.key.replace('persona.import.', ''),
value: identifier.value
};
// todo, check when actually exsits.
let attributes;
try {
// TODO: change to use non connection api.
const result = await personaService.getAttributes({
filter,
organisation,
limit: Number.MAX_SAFE_INTEGER,
maxTimeMS: MAX_TIME_MS,
maxScan: MAX_SCAN
});
attributes = map(result.edges, ({ node }) => node);
} catch (err) {
logger.error('convert$personaIdent', err);
return;
}
return { $in: without(map(attributes, ({ personaId }) => personaId), undefined, null) };
};
export default async ({ organisationId, emailType }, jobDone) => {
// get all users in an org
const users = await Users.find({
organisations: {
$in: [organisationId]
}
}).exec();
const organisation = await Organisation.findById(organisationId);
try {
await map(users, async (user) => {
// send the email
if (emailType === WEEK_BEFORE_NOTIFICATION) {
await sendOrganisationAboutToExpire(user, organisation);
} else if (emailType === EXPIRATION_NOTIFICATION) {
await sendOrganisationExpired(user, organisation);
}
});
} catch (err) {
logger.error(err);
}
if (emailType === WEEK_BEFORE_NOTIFICATION) {
organisation.expirationNotifications.weekBeforeNotificationSent = EMAIL_SENT;
} else if (emailType === EXPIRATION_NOTIFICATION) {
organisation.expirationNotifications.expirationNotificationSent = EMAIL_SENT;
}
await organisation.save();
jobDone();
};
sqs.purgeQueue({ QueueUrl: queueUrl }, (err) => {
if (err) {
logger.error('FAILED to purge queue', err);
return reject(err);
}
return resolve();
})
toInterpolationContext: function (err) {
// For data returned by backend, see
// https://github.com/mozilla/fxa-auth-server/blob/master/error.js
try {
if (this.is(err, 'INVALID_PARAMETER')) {
return {
param: err.param || err.validation.keys
};
} else if (this.is(err, 'MISSING_PARAMETER')) {
return {
param: err.param
};
} else if (this.is(err, 'INVALID_RESUME_TOKEN_PROPERTY')) {
return {
property: err.property
};
} else if (this.is(err, 'MISSING_RESUME_TOKEN_PROPERTY')) {
return {
property: err.property
};
}
} catch (e) {
// handle invalid/unexpected data from the backend.
logger.error('Error in errors.js->toInterpolationContext: %s', String(e));
}
return {};
}
captureError: function (error, sentryMetrics, metrics, win) {
var logger = new Logger(win);
logger.error(error);
sentryMetrics.captureException(error);
if (metrics) {
metrics.logError(error);
}
},
}, (err) => {
if (err) {
logger.error(`FAILED sending statement ${updatedStatement._id} to ${STATEMENT_FORWARDING_REQUEST_DELAYED_QUEUE}`, err);
done(err);
throw new Error('Error publishing to queue');
}
done();
return;
});
export const addStatementToPendingQueues = (statement, passedQueues, done) => {
const queues = passedQueues || queueDependencies;
if (!statement) {
logger.error('No statement provided');
return done();
}
const queueNames = keys(queues);
const pendingQueueNames = reject(queueNames, (queueName) => {
const queue = queues[queueName];
const completedQueues = statement.completedQueues || [];
const processingQueues = statement.processingQueues || [];
const intersectionQueues = intersection(queue.preReqs, completedQueues);
// are the preReqs a subset of the queues which have already been completed?
const preReqsCompleted = intersectionQueues.length === queue.preReqs.length;
// or is this queue in the completed queues?
const queueCompleted = includes(completedQueues, queueName);
// or is this queue in the queues being processed?
const queueProcessing = includes(processingQueues, queueName);
return !preReqsCompleted || queueCompleted || queueProcessing;
});
return Statement.updateOne(
{ _id: statement._id },
{
$addToSet: { processingQueues: { $each: pendingQueueNames } }
},
(err) => {
if (err) return done(err);
// adding to queue returns a promise
// turns queue names into a stream of promises
// call done when they have all completed
return highland(pendingQueueNames).flatMap((queueName) => {
logger.debug('ADDING STATEMENT TO QUEUE', queueName);
const response = Queue.publish({
queueName,
payload: { statementId: statement._id },
opts: { lifo: true }
});
return highland(response);
}).apply(() => {
if (size(pendingQueueNames) > 0) {
logger.debug(`ADDED ${statement._id} to ${pendingQueueNames.join(', ')}`);
} else {
logger.debug(`PROCESSED QUEUE FOR STATEMENT ${statement._id}`);
}
return done();
});
}
);
};
async (err) => {
const statement = await Statement.findOne(idFilter)
.select({ _id: 1, completedQueues: 1, processingQueues: 1 })
.lean();
if (err) logger.error('Statement update error', err);
if (err) return jobDone(err);
// get the statement so that we can find which queues it has already been through
return addStatementToPendingQueues(statement, queueDependencies, (err) => {
if (err) logger.error('addStatementToPendingQueues error', err);
if (jobDone) return jobDone(err);
});
}
captureError: function (error, sentryMetrics, metrics, win) {
var logger = new Logger(win);
logger.error(error);
// Ensure the message is interpolated before sending to
// sentry and metrics.
error.message = this.getErrorMessage(error);
sentryMetrics.captureException(error);
if (metrics) {
metrics.logError(error);
}
},
export default async (model, organisation) => {
const pathsBatch = QueryBuilderCache.collection.initializeUnorderedBulkOp();
const valuesBatch = QueryBuilderCacheValue.collection.initializeUnorderedBulkOp();
const caches = getCachesFromStatement(model);
saveCachePaths(caches, organisation, pathsBatch);
saveCacheValues(caches, organisation, valuesBatch);
try {
await Promise.all([
pathsBatch.execute({ w: 0 }), // write concern set to 0 to supress warnings of duplicate key errors
valuesBatch.execute({ w: 0 }) // these are expected, letting mongo assert the uniqueness is the fastest way
]);
} catch (err) {
logger.error(err);
}
};
export default ({ status, statementId }, jobDone) => {
try {
if (status) {
logger.debug(`COMPLETED ${statementId} - ${status}`);
const idFilter = { _id: statementId };
return Statement.updateOne(
idFilter,
{
$addToSet: { completedQueues: status },
$pull: { processingQueues: status }
},
async (err) => {
const statement = await Statement.findOne(idFilter)
.select({ _id: 1, completedQueues: 1, processingQueues: 1 })
.lean();
if (err) logger.error('Statement update error', err);
if (err) return jobDone(err);
// get the statement so that we can find which queues it has already been through
return addStatementToPendingQueues(statement, queueDependencies, (err) => {
if (err) logger.error('addStatementToPendingQueues error', err);
if (jobDone) return jobDone(err);
});
}
);
}
logger.debug(`NO STATUS, statementId: ${statementId}`);
return Statement.findById(
statementId,
{ _id: 1, completedQueues: 1, processingQueues: 1 },
(err, statement) => {
addStatementToPendingQueues(statement, queueDependencies, (err) => {
if (err) logger.error('addStatementToPendingQueues error', err);
if (jobDone) return jobDone(err);
});
}
);
} catch (err) {
logger.error('statementHandler error', err);
if (jobDone) jobDone(err);
}
};
const handleStatement = personaService => async (statement) => {
const ifi = getIfiFromActor(statement.statement.actor);
// This will only apply to the persona if they are created
const personaName = statement.statement.actor.name
? statement.statement.actor.name
: getIfiDisplayName(ifi);
const {
personaId,
identifierId,
wasCreated,
} = await personaService.createUpdateIdentifierPersona({
organisation: statement.organisation,
ifi,
personaName,
});
let display = 'Unknown name';
try {
const { persona } = await personaService.getPersona({
organisation: statement.organisation,
personaId
});
if (persona) {
display = persona.name;
}
} catch (err) {
logger.error('Error finding person - not updating statement', err);
}
if (!wasCreated) {
statement.personaIdentifier = identifierId;
statement.person = {
_id: personaId,
display,
};
await statement.save();
} else {
await asignIdentifierToStatements({ organisation: statement.organisation.toString(), toIdentifierId: identifierId });
}
};
this.getAccessTokenAsync(user, (err, token) => {
if (err) {
logger.error("Error while creating token for rollNo: " + user.rollNo, err)
res.status(500)
.json({ success: false, error: { code: "SERVER_ERROR" }})
} else {
// Save `token` to database.
AccessToken.create({
token: token,
ttl: config.jwtTTL,
rollNo: user.rollNo
}).then(token => {
res.status(200)
.json({ success: true, token: token.token })
}).catch(err => {
logger.error("Error while saving token to database for rollNo: " + user.rollNo, err)
res.status(500)
.json({ success: false, error: { code: "SERVER_ERROR" }})
})
}
})
const defaultHandleResponse = (err) => {
if (err) logger.error(`ERROR SUBSCRIBING TO QUEUE ${EMAIL_EXPIRATION_NOTIFICATION_QUEUE}`, err);
return err;
};
assert.doesNotThrow(function () {
logger.error('Error Firefox!');
});
define(function (require, exports, module) {
'use strict';
const AuthErrors = require('lib/auth-errors');
const domWriter = require('lib/dom-writer');
const FiveHundredTemplate = require('stache!templates/500');
const FourHundredTemplate = require('stache!templates/400');
const Logger = require('lib/logger');
const OAuthErrors = require('lib/oauth-errors');
const p = require('lib/promise');
module.exports = {
/**
* Get the URL of the error page to which an error should redirect.
*
* @param {Error} error - error for which to get error page URL
* @returns {String}
*/
getErrorPageTemplate (error) {
if (AuthErrors.is(error, 'INVALID_PARAMETER') ||
AuthErrors.is(error, 'MISSING_PARAMETER') ||
OAuthErrors.is(error, 'INVALID_PARAMETER') ||
OAuthErrors.is(error, 'MISSING_PARAMETER') ||
OAuthErrors.is(error, 'UNKNOWN_CLIENT')) {
return FourHundredTemplate;
}
return FiveHundredTemplate;
},
/**
* Report an error to metrics. No metrics report is sent.
*
* @param {Error} error
* @param {Object} sentryMetrics
* @param {Object} metrics
* @param {Object} win
*/
captureError (error, sentryMetrics, metrics, win) {
var logger = new Logger(win);
logger.error(error);
// Ensure the message is interpolated before sending to
// sentry and metrics.
try {
// some errors do not allow reassigning a read-only message property
error.message = this.getErrorMessage(error);
} catch (e) {
// unable to change error message.
}
sentryMetrics.captureException(error);
if (metrics) {
metrics.logError(error);
}
},
/**
* Report an error to metrics. Send metrics report.
*
* @param {Error} error
* @param {Object} sentryMetrics
* @param {Object} metrics
* @param {Object} win
* @returns {Promise};
*/
captureAndFlushError (error, sentryMetrics, metrics, win) {
this.captureError(error, sentryMetrics, metrics, win);
return p().then(function () {
if (metrics) {
return metrics.flush();
}
});
},
/**
* Render an error to the DOM
*
* @param {Error} error
* @param {Object} win
* @param {Object} translator
*/
renderError (error, win, translator) {
var errorPageTemplate = this.getErrorPageTemplate(error);
var errorMessage = this.getErrorMessage(error, translator);
var errorHtml = errorPageTemplate({
message: errorMessage,
t: getTranslationHelper(translator)
});
domWriter.write(win, errorHtml);
},
/**
* Handle a fatal error. Logs and reports the error, then redirects
* to the appropriate error page.
*
* @param {Error} error
* @param {Object} sentryMetrics
* @param {Object} metrics
* @param {Object} win
* @param {Object} translator
* @returns {Promise}
*/
fatalError (error, sentryMetrics, metrics, win, translator) {
return p.all([
this.captureAndFlushError(error, sentryMetrics, metrics, win),
this.renderError(error, win, translator)
]);
},
/**
* Get the error message, performing any interpolation. If a translator
* is passed, return value will be translated to the user's locale.
*
* @param {String} error - an error object
* @param {Object} [translator] - translator to translate error
* @return {String} interpolated error text.
*/
getErrorMessage (error, translator) {
if (error && error.errorModule) {
return error.errorModule.toInterpolatedMessage(error, translator);
}
return error.message;
}
};
function getTranslationHelper(translator) {
// Use the translator's helper if available, if the translator
// is not available (the app could error before the translator is
// created), then create a standin.
if (translator) {
return translator.translateInTemplate.bind(translator);
}
// create the standin helper.
return function () {
return function (msg) {
return msg;
};
};
}
});
}).catch(err => {
logger.error(err)
res.status(500)
.json({ success: false, error: { code: "SERVER_ERROR" }})
})
}).catch(err => {
logger.error("Error while saving token to database for rollNo: " + user.rollNo, err)
res.status(500)
.json({ success: false, error: { code: "SERVER_ERROR" }})
})
.catch((err) => {
logger.error(err);
});
define(function (require, exports, module) {
'use strict';
const _ = require('underscore');
const Errors = require('lib/errors');
const Logger = require('lib/logger');
var logger = new Logger();
const Strings = require('lib/strings');
var t = function (msg) {
return msg;
};
var UNEXPECTED_ERROR = t('Unexpected error');
/*eslint-disable sorting/sort-object-props*/
var ERRORS = {
UNKNOWN_CLIENT: {
errno: 101,
message: t('Unknown client')
},
INCORRECT_REDIRECT: {
errno: 103,
message: t('Incorrect redirect_uri')
},
INVALID_ASSERTION: {
errno: 104,
message: t('Invalid assertion')
},
UNKNOWN_CODE: {
errno: 105,
message: t('Unknown code')
},
INCORRECT_CODE: {
errno: 106,
message: t('Incorrect code')
},
EXPIRED_CODE: {
errno: 107,
message: t('Expired code')
},
INVALID_TOKEN: {
errno: 108,
message: t('Invalid token')
},
INVALID_PARAMETER: {
errno: 109,
message: t('Invalid OAuth parameter: %(param)s')
},
INVALID_RESPONSE_TYPE: {
errno: 110,
message: UNEXPECTED_ERROR
},
UNAUTHORIZED: {
errno: 111,
message: t('Unauthorized')
},
FORBIDDEN: {
errno: 112,
message: t('Forbidden')
},
INVALID_CONTENT_TYPE: {
errno: 113,
message: UNEXPECTED_ERROR
},
INVALID_SCOPES: {
errno: 114,
message: Strings.interpolate(
// `scope` should not be translated, so interpolate it in.
t('Invalid OAuth parameter: %(param)s'), { param: 'scope' })
},
SERVICE_UNAVAILABLE: {
errno: 998,
message: t('System unavailable, try again soon')
},
UNEXPECTED_ERROR: {
errno: 999,
message: UNEXPECTED_ERROR
},
TRY_AGAIN: {
errno: 1000,
message: t('Something went wrong. Please close this tab and try again.')
},
INVALID_RESULT: {
errno: 1001,
message: UNEXPECTED_ERROR
},
INVALID_RESULT_REDIRECT: {
errno: 1002,
message: UNEXPECTED_ERROR
},
INVALID_RESULT_CODE: {
errno: 1003,
message: UNEXPECTED_ERROR
},
USER_CANCELED_OAUTH_LOGIN: {
errno: 1004,
message: t('no message')
},
MISSING_PARAMETER: {
errno: 1005,
message: t('Missing OAuth parameter: %(param)s')
}
};
/*eslint-enable sorting/sort-object-props*/
module.exports = _.extend({}, Errors, {
ERRORS: ERRORS,
NAMESPACE: 'oauth',
/**
* Fetch the interpolation context out of the server error.
* @param {Error} err
* @returns {Object}
*/
toInterpolationContext (err) {
// For data returned by backend, see
// https://github.com/mozilla/fxa-oauth-server/blob/master/docs/api.md#errors
try {
if (this.is(err, 'MISSING_PARAMETER')) {
return {
param: err.param
};
} else if (this.is(err, 'INVALID_PARAMETER')) {
return {
param: err.param || err.validation.keys.join(',')
};
}
} catch (e) {
// handle invalid/unexpected data from the backend.
logger.error('Error in oauth-errors.js->toInterpolationContext: %s', String(e));
}
return {};
}
});
});
const defaultHandleResponse = (err) => {
if (err) logger.error(`ERROR SUBSCRIBING TO QUEUE ${BATCH_STATEMENT_DELETION_QUEUE}`, err);
return err;
};
addStatementToPendingQueues(statement, queueDependencies, (err) => {
if (err) logger.error('addStatementToPendingQueues error', err);
if (jobDone) return jobDone(err);
});
statementStream.on('error', (err) => {
logger.error(err);
process.exit();
});
app.use((err, req, res, next) => {
logger.error(err)
res.status(500)
.send({ success: false, error: { code: "SERVER_ERROR" }})
})
cacheStream.on('error', (err) => {
logger.error(err);
process.exit();
});
const statementForwardingRequestHandler = async (
{ statement, statementForwarding },
done,
{
queue = Queue
} = {}
) => {
try {
await setPendingStatements(
statement,
statementForwarding._id
);
await sendRequest(
statementForwarding.fullDocument ? statement : statement.statement,
statementForwarding,
statement
);
await setCompleteStatements(statement, statementForwarding._id);
logger.debug(
`SUCCESS sending statement ${statement._id} to ${statementForwarding.configuration.url}`
);
done();
} catch (err) {
logger.info(
`FAILED sending statement ${statement._id} to ${statementForwarding.configuration.url}`,
err
);
let update = {
timestamp: new Date(),
statementForwarding_id: objectId(statementForwarding._id),
message: err.toString()
};
if (err.messageBody) {
if (isPlainObject(err.messageBody)) {
update = assign({}, update, { errorInfo: err.messageBody });
}
}
try {
await Statement.updateOne(
{ _id: statement._id },
{
$addToSet: {
failedForwardingLog: update
}
}
);
const updatedStatement = await Statement.findOne({ _id: statement._id });
if (
updatedStatement.failedForwardingLog.length <=
statementForwarding.configuration.maxRetries
) {
logger.info(`SENDING statement ${updatedStatement._id} to ${STATEMENT_FORWARDING_REQUEST_DELAYED_QUEUE}`);
queue.publish({
queueName: STATEMENT_FORWARDING_REQUEST_DELAYED_QUEUE,
payload: {
status: STATEMENT_FORWARDING_REQUEST_DELAYED_QUEUE,
statement: updatedStatement,
statementForwarding
}
}, (err) => {
if (err) {
logger.error(`FAILED sending statement ${updatedStatement._id} to ${STATEMENT_FORWARDING_REQUEST_DELAYED_QUEUE}`, err);
done(err);
throw new Error('Error publishing to queue');
}
done();
return;
});
} else {
logger.info(`EXCEEDED max retry for statement ${updatedStatement._id}, failing (should go to dead letter queue).`);
done(err); // failed, let redrive send to dead letter queue
}
} catch (err) {
logger.error('Failed updating failedForwardingLog', err);
}
}
return [statement._id];
};
const logError = err => logger.error(err);
const promise = handleJob(statements).catch((err) => {
logger.error(err);
return err;
});