moog-graze
Version:
Interact with MOOG.AIOps via Graze (REST)
1,693 lines (1,513 loc) • 129 kB
JavaScript
/**
* Created by stephen on 17/05/2016.
*/
// Export the options and the graze methods
// hide the auth, retry and proxy complexity
// Aim to provide a simple API based on the
// http://docs.moogsoft.com/display/MOOG/Graze+API
// remove need for auth_token paramter for each call
// pass a callback as the finnal parameter
//
// @example getAlertDetails(alert_id, callback(res, err) {});
//
// Error conditions are returned in the err as a standard error
// object, res is the response message from Moog as an object
//
/**
* Module dependencies.
*/
var https = require('https');
var util = require('util');
var httpsProxy = require('https-proxy-agent');
var debug = require('debug')('graze');
var debugDetail = require('debug')('graze:verbose');
/**
* Module exports.
*/
exports = module.exports = Graze;
exports.version = '0.2.1';
/**
* Main module
*/
function Graze(grazeOpts)
{
if (!(this instanceof Graze))
{
return new Graze(grazeOpts);
}
debug('creating new graze instance.');
grazeOpts = grazeOpts || {};
// Build the options object for the first time
//
this.connectOptions = {
// return a default options object
grazeUser : "graze",
grazePass : "graze",
grazeBasePath : "/graze/v1",
retry : 3,
hostname : 'hostName',
port : 8080,
rejectUnauthorized: false,
caCert : '',
key : '',
cert : '',
useProxy : false,
proxyHost : '',
proxyPort : 0,
grazeHeaders : {
'accept' : 'application/json',
'content-type': 'application/json'
},
authToken : '',
retryCount : 0
};
// Add in any paramters passed
//
this.setOps(grazeOpts);
}
/**
*
* @param opts
* @returns {Promise}
*/
function authenticate(opts)
{
return new Promise(function (resolve, reject)
{
debug('Enter authenticate promise');
// From 6.1.0+ use basic auth rather than auth token
if (opts.auth && opts.auth.length > 0) {
debug('authenticate use basic auth:' + opts.auth);
resolve({auth_token: 'Using Basic Auth'});
return;
}
// We already have an auth_token lets try and use it
//
if (opts.authToken)
{
debug('authenticate reuse existing token:' + opts.authToken);
console.log('WARNING: Authenticate with auth token deprecated in 6.1.0+ use basic auth instead');
resolve({auth_token: opts.authToken});
return;
}
var grazeAuthPath = opts.grazeBasePath +
"/authenticate?username=" + opts.grazeUser + "&password=" + opts.grazePass;
var grazeLoginOpts = {
host : opts.hostname,
port : parseInt(opts.port),
path : grazeAuthPath,
method : 'GET',
headers : opts.grazeHeaders,
rejectUnauthorized: opts.rejectUnauthorized
};
callGrazeEndpoint(grazeLoginOpts).then(function (response)
{
debug("authenticate - callGrazeEndpoint response " + response);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("authenticate - callGrazeEndpoint error: ", error.statusCode);
if (error.statusCode !== 503)
{
debug("authenticate rejecting with an http error");
reject(error);
}
else if (opts.retryCount < opts.retry)
{
console.log("authenticate: Retry " + opts.retryCount++ + ' of ' + opts.retry);
authenticate(opts).then(function (response)
{
console.log("authenticate: Success!", response);
resolve(response);
}, function (error)
{
console.error("authenticate: Failed!", error.statusCode);
reject(error);
});
}
else
{
console.log('Retry count exceded');
reject(error);
}
});
});
}
/**
*
* @param type
* @param opts
* @param grazePath
* @param [byteLengthBody]
* @returns {object}
*/
function buildOpts(type, opts, grazePath, byteLengthBody)
{
debug('Entering buildOpts type:' + type);
var retvar = {
host : opts.hostname,
port : parseInt(opts.port),
path : grazePath,
method : type,
headers : opts.grazeHeaders,
rejectUnauthorized: opts.rejectUnauthorized
};
if (opts.auth && opts.auth.length > 0) {
debug('buildOpts use Basic Auth');
retvar.auth = opts.auth;
}
if (type === 'POST')
{
debug('buildOpts body length:' + byteLengthBody);
retvar.headers['content-length'] = byteLengthBody;
debug('buildOps headers:' + util.inspect(retvar.headers));
} else
{
delete retvar.headers['content-length'];
}
return retvar;
}
/**
*
* @param opts
* @param {object} [body] Only for POST
* @returns {Promise}
*/
function callGrazeEndpoint(opts, body)
{
return new Promise(function (resolve, reject)
{
if (opts.port === 0 || !opts.port)
{
debug('Enter callGrazeEndpoint promise: https://' + opts.host + "" + opts.path);
delete opts.port;
} else
{
debug('Enter callGrazeEndpoint promise: https://' + opts.host + ":" + opts.port + "" + opts.path);
}
// We use an agent so we can add a proxy if needed
//
if (!opts.agent)
{
debug('callGrazeEndpoint generating https agent');
opts.agent = new https.Agent(opts);
}
debugDetail('callGrazeEndpoint opts: ' + util.inspect(opts));
var req = https.request(opts, (res) =>
{
res.setEncoding('utf8');
var resData = {};
var returnString = "";
debug('callGrazeEndpoint https.request: response statusCode: ' + res.statusCode);
debugDetail('callGrazeEndpoint https.request: headers: ' + res.headers);
res.on('data', function (d)
{
returnString += d;
debugDetail("callGrazeEndpoint: on chunk returnString:" + returnString.toString('utf8'));
});
res.on('end', function ()
{
debug("callGrazeEndpoint: on end returnString: " + returnString.toString('utf8'));
try
{
resData = JSON.parse(returnString.toString('utf8'));
}
catch (e)
{
debug("callGrazeEndpoint: Failed to parse returned JSON string: " + e);
resData = {};
resData.description = 'No Data returned';
}
if (res.statusCode === 200 && res.statusMessage === 'OK')
{
debug("callGrazeEndpoint received graze data " + res.statusCode + ': ' + res.statusMessage);
resolve(resData);
}
else if (resData.message)
{
var moogStatusMessage = resData.statusMessage
if (!moogStatusMessage && resData.additional && resData.additional.debugMessage) {
moogStatusMessage = resData.additional.debugMessage;
}
console.log("callGrazeEndpoint: Failed to get graze data statusCode:" +
res.statusCode + ' statusMessage: ' + res.statusMessage + ' MOOG message: ' + resData.statusCode + ':' +
resData.message + " moog status message:" + moogStatusMessage);
res.message = resData;
reject(res);
}
else
{
console.log("callGrazeEndpoint: Failed " + res.statusCode + ': ' + res.statusMessage);
reject(res);
}
});
});
// If it is a POST we want to send the JSON body
req.on('error', function (err)
{
console.log("callGrazeEndpoint: Connection to graze failed: " + err);
reject(err);
});
if (opts.method === 'POST' && body)
{
req.end(body);
}
else
{
req.end();
}
});
}
/**
*
* @returns {object}
*/
Graze.prototype.getOps = function ()
{
debug('Entering getOps');
debugDetail('getOps connectOptions: ' + util.inspect(this.connectOptions));
return Object.assign({}, this.connectOptions);
};
/**
*
* @param {object} opts
*/
Graze.prototype.setOps = function (opts)
{
debug('Entering setOps');
var localOps = opts || {};
var keysUpdated = 0;
if (localOps && typeof localOps !== 'object')
{
console.log('setOps: Paramter passed is not an object ignoring.');
localOps = {};
}
debugDetail('setOps connectOptions before update: ' + util.inspect(this.connectOptions));
for (var option in localOps)
{
if (localOps.hasOwnProperty(option))
{
debug('setOps seting option ' + option + ' from:' + this.connectOptions[option] + ' to:' + localOps[option]);
this.connectOptions[option] = localOps[option];
keysUpdated++;
}
}
debugDetail('setOps connectOptions after update: ' + util.inspect(this.connectOptions));
return keysUpdated;
};
// We could probably make these calls more generic but my brain hurts
//
// Add a function for each endpoint (As of 6.0.0);
// Update to add basic auth (6.1.0)
//
// addAlertCustomInfo
// addAlertToSituation
// addCustomInfo (deprecated)
// addProcess
// addService
// addSigCorrelationInfo
// addSituationCustomInfo
// addThreadEntry
// assignAlert(user_id)
// assignAlert(username)
// assignAndAcknowledgeAlert(user_id)
// assignAndAcknowledgeAlert(username)
// assignAndAcknowledgeSituation(user_id)
// assignAndAcknowledgeSituation(username)
// assignSituation(user_id)
// assignSituation(username)
// closeAlert
// closeSituation
// createSituation
// createTeam (6.1.0)
// createThread
// createMaintenanceWindow
// createUser (6.1.0)
// deassignAlert
// deassignSituation
// deleteMaintenanceWindow
// getActiveSituationIds
// getAlertDetails
// getAlertIds
// getMaintenanceWindows
// getSituationAlertIds
// getSituationDescription
// getSituationDetails
// getSituationHosts
// getSituationIds
// getSituationProcesses
// getSituationServices
// getSystemStatus
// getSystemSummary
// getTeamSituationIds
// getThreadEntries
// getUserInfo(user_id)
// getUserInfo(username)
// getUserRoles(user_id)
// getUserRoles(username)
// getUserTeams(user_id)
// getUserTeams(username)
// mergeSituations
// removeAlertFromSituation
// resolveSituation
// setAlertAcknowledgeState
// setAlertSeverity
// setSituationAcknowledgeState
// setSituationDescription
// setSituationExternalSeverity [*Deprecated* 5.2.3]
// setSituationProcesses
// setSituationServices
// updateTeam (6.1.0)
/**
*
* @param {number} alertId
* @param {object} customInfo
* @param {function} callback
*/
Graze.prototype.addAlertCustomInfo = function (alertId, customInfo, callback)
{
debug("Entering addAlertCustomInfo");
var opts = this.connectOptions;
var self = this;
var _addAlertCustomInfo = function (alertId, customInfo)
{
debug('Entering _addAlertCustomInfo');
debug('_addAlertCustomInfo authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/addAlertCustomInfo";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.alert_id = alertId;
grazeBody.custom_info = customInfo;
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_addAlertCustomInfo - callGrazeEndpoint response " + response.description);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_addAlertCustomInfo - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('addAlertCustomInfo authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_addAlertCustomInfo(alertId, customInfo).then(function (response)
{
debug("addAlertCustomInfo response from _addAlertCustomInfo:" + response.description);
debug("addAlertCustomInfo _addAlertCustomInfo call callback with OK");
callback(200, response);
}, function (error)
{
console.log("addAlertCustomInfo _addAlertCustomInfo error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("addAlertCustomInfo authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
*
* @param alertId
* @param sitnId
* @param callback
*/
Graze.prototype.addAlertToSituation = function (alertId, sitnId, callback)
{
debug("Entering addAlertToSituation");
var opts = this.connectOptions;
var self = this;
var _addAlertToSituation = function (alertId, sitnId)
{
debug('Entering _addAlertToSituation alert_id:' + alertId + ' sitn_id:' + sitnId);
debug('_addAlertToSituation authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/addAlertToSituation";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.alert_id = alertId;
grazeBody.sitn_id = sitnId;
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_addAlertToSituation - callGrazeEndpoint response " + response);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_addAlertToSituation - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('addAlertToSituation authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_addAlertToSituation(alertId, sitnId).then(function (response)
{
debug("addAlertToSituation response from _addAlertToSituation:" + response.description);
debug("addAlertToSituation _addAlertToSituation call callback with OK");
callback(200, response);
}, function (error)
{
console.log("addAlertToSituation _addAlertToSituation error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("addAlertToSituation authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
*
* @param name
* @param description
* @param callback
*/
Graze.prototype.addProcess = function (name, description, callback)
{
debug("Entering addProcess");
var opts = this.connectOptions;
var self = this;
var _addProcess = function (name, description)
{
debug('Entering _addProcess');
debug('_addProcess authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/addProcess";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.name = name;
grazeBody.description = description;
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_addProcess - callGrazeEndpoint response " + response);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_addProcess - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('addProcess authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_addProcess(name, description).then(function (response)
{
debug("addProcess response from _addProcess:" + response.description);
debug("addProcess _addProcess call callback with OK");
callback(200, response);
}, function (error)
{
console.log("addProcess _addProcess error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("addProcess authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
*
* @param name
* @param description
* @param callback
*/
Graze.prototype.addService = function (name, description, callback)
{
debug("Entering addService");
var opts = this.connectOptions;
var self = this;
var _addService = function (name, description)
{
debug('Entering _addService');
debug('_addService authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/addService";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.name = name;
grazeBody.description = description;
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_addService - callGrazeEndpoint response " + response);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_addService - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('addService authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_addService(name, description).then(function (response)
{
debug("addService response from _addService:" + response.description);
debug("addService _addService call callback with OK");
callback(200, response);
}, function (error)
{
console.log("addService _addService error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("addService authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
*
* @param sitnId
* @param serviceName
* @param resourceId
* @param callback
*/
Graze.prototype.addSigCorrelationInfo = function (sitnId, serviceName, resourceId, callback)
{
debug("Entering addSigCorrelationInfo");
var opts = this.connectOptions;
var self = this;
var _addSigCorrelationInfo = function (sitnId, serviceName, resourceId)
{
debug('Entering _addSigCorrelationInfo sitn_id:' + sitnId +
' service_name:' + serviceName + ' resource_id:' + resourceId);
debug('_addSigCorrelationInfo authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/addSigCorrelationInfo";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.sitn_id = sitnId;
grazeBody.service_name = serviceName;
grazeBody.resource_id = resourceId;
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_addSigCorrelationInfo - callGrazeEndpoint response " + response);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_addSigCorrelationInfo - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('addSigCorrelationInfo authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_addSigCorrelationInfo(sitnId, serviceName, resourceId).then(function (response)
{
debug("addSigCorrelationInfo response from _addSigCorrelationInfo:" + response.description);
debug("addSigCorrelationInfo _addSigCorrelationInfo call callback with OK");
callback(200, response);
}, function (error)
{
console.log("addSigCorrelationInfo _addSigCorrelationInfo error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("addSigCorrelationInfo authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
*
* @param sitnId
* @param customInfo
* @param callback
*/
Graze.prototype.addSituationCustomInfo = function (sitnId, customInfo, callback)
{
debug("Entering addSituationCustomInfo");
var opts = this.connectOptions;
var self = this;
var _addSituationCustomInfo = function (sitnId, customInfo)
{
debug('Entering _addSituationCustomInfo sitn_id:' + sitnId);
debug('_addSituationCustomInfo authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/addSituationCustomInfo";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.sitn_id = sitnId;
grazeBody.custom_info = customInfo;
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_addSituationCustomInfo - callGrazeEndpoint response " + response);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_addSituationCustomInfo - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('addSituationCustomInfo authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_addSituationCustomInfo(sitnId, customInfo).then(function (response)
{
debug("addSituationCustomInfo response from _addSituationCustomInfo:" + response.description);
debug("addSituationCustomInfo _addSituationCustomInfo call callback with OK");
callback(200, response);
}, function (error)
{
console.log("addSituationCustomInfo _addSituationCustomInfo error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("addSituationCustomInfo authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
*
* @param sitnId
* @param threadName
* @param entry
* @param callback
*/
Graze.prototype.addThreadEntry = function (sitnId, threadName, entry, callback)
{
debug("Entering addThreadEntry");
var opts = this.connectOptions;
var self = this;
var _addThreadEntry = function (sitnId, threadName, entry)
{
debug('Entering _addThreadEntry sitn_id:' + sitnId);
debug('_addThreadEntry authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/addThreadEntry";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.sitn_id = sitnId;
grazeBody.thread_name = threadName;
grazeBody.entry = entry;
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_addThreadEntry - callGrazeEndpoint response " + response);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_addThreadEntry - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('addThreadEntry authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_addThreadEntry(sitnId, threadName, entry).then(function (response)
{
debug("addThreadEntry response from _addThreadEntry:" + response.description);
debug("addThreadEntry _addThreadEntry call callback with OK");
callback(200, response);
}, function (error)
{
console.log("addThreadEntry _addThreadEntry error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("addThreadEntry authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
*
* @param {number} alertId
* @param {number,string} user
* @param {function} callback
*/
Graze.prototype.assignAlert = function (alertId, user, callback)
{
debug("Entering assignAlert");
var opts = this.connectOptions;
var self = this;
var _assignAlert = function (alertId, user)
{
debug('Entering _assignAlert');
debug('_assignAlert authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/assignAlert";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.alert_id = alertId;
if (typeof user === 'string')
{
grazeBody.username = user;
} else if (typeof user === 'number')
{
grazeBody.user_id = user;
} else
{
reject({statusCode: 400, statusMessage: 'parameter user ' + user + ' is unsupported type ' + typeof user});
}
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_assignAlert - callGrazeEndpoint response " + response.description);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_assignAlert - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('assignAlert authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_assignAlert(alertId, user).then(function (response)
{
debug("assignAlert response from _assignAlert:" + response.description);
debug("assignAlert _assignAlert call callback with OK");
callback(200, response);
}, function (error)
{
console.log("assignAlert _assignAlert error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("assignAlert authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
*
* @param {number} alertId
* @param {number,string} user
* @param {function} callback
*/
Graze.prototype.assignAndAcknowledgeAlert = function (alertId, user, callback)
{
debug("Entering assignAndAcknowledgeAlert");
var opts = this.connectOptions;
var self = this;
var _assignAndAcknowledgeAlert = function (alertId, user)
{
debug('Entering _assignAndAcknowledgeAlert');
debug('_assignAndAcknowledgeAlert authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/assignAndAcknowledgeAlert";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.alert_id = alertId;
if (typeof user === 'string')
{
grazeBody.username = user;
} else if (typeof user === 'number')
{
grazeBody.user_id = user;
} else
{
reject({statusCode: 400, statusMessage: 'parameter user ' + user + ' is unsupported type ' + typeof user});
}
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_assignAndAcknowledgeAlert - callGrazeEndpoint response " + response.description);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_assignAndAcknowledgeAlert - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('assignAndAcknowledgeAlert authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_assignAndAcknowledgeAlert(alertId, user).then(function (response)
{
debug("assignAndAcknowledgeAlert response from _assignAndAcknowledgeAlert:" + response.description);
debug("assignAndAcknowledgeAlert _assignAndAcknowledgeAlert call callback with OK");
callback(200, response);
}, function (error)
{
console.log("assignAndAcknowledgeAlert _assignAndAcknowledgeAlert error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("assignAndAcknowledgeAlert authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
*
* @param {number} sitnId
* @param {number,string} user
* @param {function} callback
*/
Graze.prototype.assignAndAcknowledgeSituation = function (sitnId, user, callback)
{
debug("Entering assignAndAcknowledgeSituation");
var opts = this.connectOptions;
var self = this;
var _assignAndAcknowledgeSituation = function (sitnId, user)
{
debug('Entering _assignAndAcknowledgeSituation');
debug('_assignAndAcknowledgeSituation authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/assignAndAcknowledgeSituation";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.sitn_id = sitnId;
if (typeof user === 'string')
{
grazeBody.username = user;
} else if (typeof user === 'number')
{
grazeBody.user_id = user;
} else
{
reject({statusCode: 400, statusMessage: 'parameter user ' + user + ' is unsupported type ' + typeof user});
}
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_assignAndAcknowledgeSituation - callGrazeEndpoint response " + response.description);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_assignAndAcknowledgeSituation - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('assignAndAcknowledgeSituation authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_assignAndAcknowledgeSituation(sitnId, user).then(function (response)
{
debug("assignAndAcknowledgeSituation response from _assignAndAcknowledgeSituation:" + response.description);
debug("assignAndAcknowledgeSituation _assignAndAcknowledgeSituation call callback with OK");
callback(200, response);
}, function (error)
{
console.log("assignAndAcknowledgeSituation _assignAndAcknowledgeSituation error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("assignAndAcknowledgeSituation authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
*
* @param {number} sitnId
* @param {number,string} user
* @param {function} callback
*/
Graze.prototype.assignSituation = function (sitnId, user, callback)
{
debug("Entering assignSituation");
var opts = this.connectOptions;
var self = this;
var _assignSituation = function (sitnId, user)
{
debug('Entering _assignSituation');
debug('_assignSituation authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/assignSituation";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.sitn_id = sitnId;
if (typeof user === 'string')
{
grazeBody.username = user;
} else if (typeof user === 'number')
{
grazeBody.user_id = user;
} else
{
reject({statusCode: 400, statusMessage: 'parameter user ' + user + ' is unsupported type ' + typeof user});
}
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_assignSituation - callGrazeEndpoint response " + response.description);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_assignSituation - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('assignSituation authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_assignSituation(sitnId, user).then(function (response)
{
debug("assignSituation response from _assignSituation:" + response.description);
debug("assignSituation _assignSituation call callback with OK");
callback(200, response);
}, function (error)
{
console.log("assignSituation _assignSituation error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("assignSituation authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
*
* @param {number} alertId
* @param {function} callback
*/
Graze.prototype.closeAlert = function (alertId, callback)
{
debug("Entering closeAlert");
var opts = this.connectOptions;
var self = this;
var _closeAlert = function (alertId)
{
debug('Entering _closeAlert');
debug('_closeAlert authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/closeAlert";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.alert_id = alertId;
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_closeAlert - callGrazeEndpoint response " + response);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_closeAlert - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('closeAlert authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_closeAlert(alertId).then(function (response)
{
debug("closeAlert response from _closeAlert:" + response.description);
debug("closeAlert _closeAlert call callback with OK");
callback(200, response);
}, function (error)
{
console.log("closeAlert _closeAlert error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("closeAlert authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
*
* @param {number} sitnId
* @param {string} resolution
* @param {function} callback
*/
Graze.prototype.closeSituation = function (sitnId, resolution, callback)
{
debug("Entering closeSituation");
var opts = this.connectOptions;
var self = this;
var _closeSituation = function (sitnId, resolution)
{
debug('Entering _closeSituation sitn_id:' + sitnId);
debug('_closeSituation authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/closeSituation";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.sitn_id = sitnId;
grazeBody.resolution = resolution;
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_closeSituation - callGrazeEndpoint response " + response);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_closeSituation - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('closeSituation authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_closeSituation(sitnId, resolution).then(function (response)
{
debug("closeSituation response from _closeSituation:" + response.description);
debug("closeSituation _closeSituation call callback with OK");
callback(200, response);
}, function (error)
{
console.log("closeSituation _closeSituation error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("closeSituation authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
*
* @param {string} description
* @param {function} callback
*/
Graze.prototype.createSituation = function (description, callback)
{
debug("Entering createSituation");
var opts = this.connectOptions;
var self = this;
var _createSituation = function (description)
{
debug('Entering _createSituation description:' + description);
debug('_createSituation authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/createSituation";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.description = description;
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_createSituation - callGrazeEndpoint response " + response);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_createSituation - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('createSituation authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_createSituation(description).then(function (response)
{
debug("createSituation response from _createSituation:" + response.description);
debug("createSituation _createSituation call callback with OK");
callback(200, response);
}, function (error)
{
console.log("createSituation _createSituation error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("createSituation authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
*
* @param {number} sitnId
* @param {string} threadName
* @param {function} callback
*/
Graze.prototype.createThread = function (sitnId, threadName, callback)
{
debug("Entering createThread");
var opts = this.connectOptions;
var self = this;
var _createThread = function (sitnId, threadName)
{
debug('Entering _createThread sitn_id:' + sitnId);
debug('_createThread authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/createThread";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.sitn_id = sitnId;
grazeBody.thread_name = threadName;
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_createThread - callGrazeEndpoint response " + response);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_createThread - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('createThread authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_createThread(sitnId, threadName).then(function (response)
{
debug("createThread response from _createThread:" + response.description);
debug("createThread _createThread call callback with OK");
callback(200, response);
}, function (error)
{
console.log("createThread _createThread error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("createThread authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
* This is a maintenance object constructor to be used in relation to this Graze implementation, it is not used in
* the general Graze definition as seen in the Moogsoft documents and is used as a convenience and abstration here.
*
* @param {string} name - The name of the window
* @param {string} description - Description of the window
* @param {string} filter - JSON Object, filter for which alerts to match
* @param {number} startDateTime - Epoch Seconds time to start the window from
* @param {number} duration - Seconds duration of the window in seconds
* @param {boolean} forwardAlerts - Do we forward the Alerts that are captured?
* @param {number} recurringPeriod - How many days/weeks/months to wait before this recurs
* @param {number} recurringPeriodUnits - Decides what the recurring period counts in
* 0 = minutes, 1 = hours, 2 = days, 3 = weeks, 4 = months
* @type {{}}
*/
Graze.prototype.maintObj = function () {
this.name = '';
this.description = '';
this.filter = '{}';
this.startDateTime = 0;
this.duration = 0;
this.forwardAlerts = false;
this.recurringPeriod = 0;
this.recurringPeriodUnits = 0;
}
/**
* @param {maintObj} maintObj - An instance of the maintenance object (see above prototype)
* @param {function} callback
*/
Graze.prototype.createMaintenanceWindow = function (maintObj, callback)
{
debug("Entering createMaintenanceWindow");
var opts = this.connectOptions;
var self = this;
// TODO: Test the maintObj.filter to see if it's SQL and convert to Moog gobbledegook
var _createMaintenanceWindow = function (maintObj)
{
debug('Entering _createMaintenanceWindow');
debug('_createMaintenanceWindow authToken: ' + opts.authToken);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/createMaintenanceWindow";
var grazeBody = {};
grazeBody.auth_token = opts.authToken;
grazeBody.name = maintObj.name;
grazeBody.description = maintObj.description;
grazeBody.filter = maintObj.filter;
grazeBody.start_date_time = maintObj.startDateTime;
grazeBody.duration = maintObj.duration;
grazeBody.forward_alerts = maintObj.forwardAlerts;
grazeBody.recurring_period = maintObj.recurringPeriod;
grazeBody.recurring_period_units = maintObj.recurringPeriodUnits;
try
{
var body = JSON.stringify(grazeBody);
}
catch (e)
{
reject({statusCode: 400, statusMessage: e});
return;
}
var grazeLoginOpts = buildOpts('POST', opts, grazePath, Buffer.byteLength(body));
callGrazeEndpoint(grazeLoginOpts, body).then(function (response)
{
debug("_createMaintenanceWindow - callGrazeEndpoint response " + response.description);
opts.retryCount = 0;
resolve(response);
}, function (error)
{
console.log("_createMaintenanceWindow - callGrazeEndpoint error " + error.statusCode);
reject(error);
});
});
};
authenticate(opts).then(function (response)
{
debug('createMaintenanceWindow authenticate response authToken:' + response.auth_token);
opts.authToken = response.auth_token;
_createMaintenanceWindow(maintObj).then(function (response)
{
debug("createMaintenanceWindow response from _createMaintenanceWindow:" + response.description);
debug("createMaintenanceWindow _createMaintenanceWindow call callback with OK");
callback(200, response);
}, function (error)
{
console.log("createMaintenanceWindow _createMaintenanceWindow error: " + error.statusCode);
callback(error.statusCode, error.statusMessage);
})
}, function (error)
{
console.log("createMaintenanceWindow authenticate error: " + error.statusCode + ' ' + error.statusMessage);
self.authToken = '';
callback(error.statusCode, error.statusMessage);
});
};
/**
* This is a team object constructor to be used in relation to this Graze implementation, it is not used in
* the general Graze definition as seen in the Moogsoft documents and is used as a convenience and abstration here.
*
* @param {number} teamId - Only used for update, delete for create
* @param {string} name - The new team (unique) name
* @param {string} alertFilter - Either a SQL like filter or an JSON representation of the filter
* @param {boolean} active - False if the team is inactive, true if the team is active. Default to true
* @param {string} services - JSON List of the team services names or IDs
* @param {string} sigFilter - The situation filters. Either a SQL like filter or an JSON representation of the filter
* @param {string} landingPage - The team default landing page
* @param {string} description - The team description
* @param {string} users - List of numbers or strings The team users (either IDs or usernames)
*
* @type {{}}
*/
Graze.prototype.teamObj = function () {
this.teamId = 0;
this.name = '';
this.alertFilter = '';
this.active = true;
this.services = '[]';
this.sigFilter = '';
this.landingPage = '';
this.description = '';
this.users = '[]';
}
/**
* @param {teamObj} teamObj - An instance of the team object (see above prototype)
* @param {function} callback
*/
Graze.prototype.createTeam = function (teamObj, callback)
{
debug("Entering createTeam");
var opts = this.connectOptions;
var self = this;
var _createTeam = function (teamObj)
{
debug('Entering _createTeam');
debug('_createTeam authToken: ' + opts.authToken);
delete(teamObj.teamId);
return new Promise(function (resolve, reject)
{
var grazePath = opts.grazeBasePath + "/createTeam";
var graze