437 lines
17 KiB
JavaScript
437 lines
17 KiB
JavaScript
/*global jQuery */
|
|
|
|
'use strict';
|
|
|
|
angular.module('bansho.surveil')
|
|
.service('surveilStatus', ['$http', '$q',
|
|
function ($http, $q) {
|
|
var getObjects = function (fields, filters, apiName) {
|
|
var query = {},
|
|
transformations;
|
|
|
|
function appendTransform(defaults, transform) {
|
|
// We can't guarantee that the default transformation is an array
|
|
defaults = angular.isArray(defaults) ? defaults : [defaults];
|
|
|
|
return defaults.concat(transform);
|
|
}
|
|
|
|
if (apiName === 'hosts') {
|
|
transformations = hostMiddleware;
|
|
} else if (apiName === 'services' || apiName === 'events') {
|
|
transformations = apiMiddleware;
|
|
} else {
|
|
throw new Error('getObjects : ' + apiName + ' API is not supported');
|
|
}
|
|
|
|
if (apiName === 'hosts') {
|
|
hostQueryTransform(fields, filters);
|
|
}
|
|
|
|
if (fields.length > 0) {
|
|
query.fields = fields;
|
|
}
|
|
|
|
query.filters = JSON.stringify(filters);
|
|
|
|
return $http({
|
|
url: 'surveil/v2/status/' + apiName + '/',
|
|
method: 'POST',
|
|
data: query,
|
|
transformResponse: appendTransform($http.defaults.transformResponse, transformations),
|
|
}).error(function () {
|
|
throw new Error('getObjects : POST Request failed');
|
|
});
|
|
};
|
|
|
|
var getMetric = function (host, service, metric) {
|
|
var url = 'surveil/v2/status/hosts/' + host,
|
|
responsePromise = $q.defer();
|
|
|
|
if (service !== undefined) {
|
|
url += '/services/' + service;
|
|
}
|
|
|
|
url += '/metrics/' + metric;
|
|
|
|
$http.get(url).success(function (metric) {
|
|
responsePromise.resolve(metric);
|
|
})
|
|
.error(function () {
|
|
throw new Error('getMetric: GET Request failed');
|
|
});
|
|
|
|
return responsePromise.promise;
|
|
};
|
|
|
|
var getMetricNames = function (host, service) {
|
|
var url = '/surveil/v2/status/hosts/' + host,
|
|
responsePromise = $q.defer();
|
|
|
|
if (service !== undefined) {
|
|
url += '/services/' + service;
|
|
}
|
|
|
|
url += '/metrics/';
|
|
|
|
$http.get(url).success(function (metrics) {
|
|
var result = [];
|
|
for (var i = 0; i < metrics.length; i += 1) {
|
|
if (metrics[i].metric_name.indexOf("metric_") === 0) {
|
|
result.push(metrics[i]);
|
|
}
|
|
}
|
|
|
|
responsePromise.resolve(result);
|
|
})
|
|
.error(function () {
|
|
throw new Error('getMetricNames: GET Request failed');
|
|
});
|
|
|
|
return responsePromise.promise;
|
|
};
|
|
|
|
var getService = function (hostName, description) {
|
|
var fields = [],
|
|
filters = {
|
|
'is': {
|
|
'host_name': [hostName],
|
|
'service_description': [description]
|
|
}
|
|
};
|
|
|
|
return this.getObjects(fields, filters, 'services')
|
|
.error(function () {
|
|
throw new Error('getService : POST Request failed');
|
|
});
|
|
};
|
|
|
|
var getServicesByHost = function (hostName) {
|
|
var fields = [],
|
|
filters = {
|
|
'is': {
|
|
'host_name': [hostName]
|
|
}
|
|
};
|
|
|
|
return this.getObjects(fields, filters, 'services')
|
|
.error(function () {
|
|
throw new Error('getService : POST Request failed');
|
|
});
|
|
};
|
|
|
|
var getHostOpenProblems = function () {
|
|
var fields = ['state'],
|
|
filters = {
|
|
'is': {
|
|
'state': ['DOWN', 'UNREACHABLE'],
|
|
'acknowledged': [false]
|
|
}
|
|
},
|
|
apiName = 'hosts';
|
|
|
|
return getObjects(fields, filters, apiName)
|
|
.error(function () {
|
|
throw new Error('getHostOpenProblems : POST Request failed');
|
|
});
|
|
};
|
|
|
|
var getServiceOpenProblems = function () {
|
|
var serviceFields = ['host_name', 'state'],
|
|
serviceFilters = {
|
|
'isnot': {
|
|
'state': ['OK']
|
|
},
|
|
'is': {
|
|
'acknowledged': [false]
|
|
}
|
|
},
|
|
hostFields = ['host_name', 'state'],
|
|
hostFilters = {'isnot': {'state': ['DOWN', 'UNREACHABLE']}},
|
|
responsePromise = $q.defer();
|
|
|
|
getObjects(hostFields, hostFilters, 'hosts')
|
|
.success(function (hostData) {
|
|
var hostsResult = {},
|
|
i;
|
|
|
|
// Creates a host dictionnary for performance
|
|
for (i = 0; i < hostData.length; i += 1) {
|
|
hostsResult[hostData[i].host_name] = '';
|
|
}
|
|
|
|
getObjects(serviceFields, serviceFilters, 'services')
|
|
.success(function (serviceData) {
|
|
var result = [];
|
|
for (i = 0; i < serviceData.length; i += 1) {
|
|
if (serviceData[i].host_name in hostsResult) {
|
|
result.push(serviceData[i]);
|
|
}
|
|
}
|
|
responsePromise.resolve(result);
|
|
});
|
|
});
|
|
|
|
return responsePromise.promise;
|
|
};
|
|
|
|
var getHostProblems = function () {
|
|
var fields = ['state'],
|
|
filters = {'isnot': {'state': ['UP']}},
|
|
apiName = 'hosts';
|
|
|
|
return getObjects(fields, filters, apiName)
|
|
.error(function () {
|
|
throw new Error('getHostProblems : POST Request failed');
|
|
});
|
|
};
|
|
|
|
// This service is used to count the number of service problems
|
|
var getServiceProblems = function () {
|
|
var fields = ['state'],
|
|
filters = {'isnot': {'state': ['OK']}},
|
|
apiName = 'services';
|
|
|
|
return getObjects(fields, filters, apiName)
|
|
.error(function () {
|
|
throw new Error('getServiceOpenProblems : POST Request failed');
|
|
});
|
|
};
|
|
|
|
// This service is used to count the number of hosts
|
|
var getTotalHosts = function () {
|
|
var fields = ['host_name'],
|
|
filters = {},
|
|
apiName = 'hosts';
|
|
|
|
return getObjects(fields, filters, apiName)
|
|
.error(function () {
|
|
throw new Error('getTotalHosts : POST Request failed');
|
|
});
|
|
};
|
|
|
|
// This service is used to count the number of services
|
|
var getTotalServices = function () {
|
|
var fields = ['host_name'],
|
|
filters = {},
|
|
apiName = 'services';
|
|
|
|
return getObjects(fields, filters, apiName)
|
|
.error(function () {
|
|
throw new Error('getTotalServices : POST Request failed');
|
|
});
|
|
};
|
|
|
|
var getHost = function (objectType, objectIdentifier) {
|
|
var objectData = {},
|
|
endpoints = {
|
|
"host": "hosts",
|
|
"service": "services"
|
|
},
|
|
liveUrl = 'surveil/v2/status/' + endpoints[objectType] + '/' + objectIdentifier.host_name + '/',
|
|
configUrl = 'surveil/v2/config/' + endpoints[objectType] + '/' + objectIdentifier.host_name + '/',
|
|
responsePromise = $q.defer();
|
|
|
|
$http.get(liveUrl).success(function (liveData) {
|
|
$http.get(configUrl).success(function (configData) {
|
|
objectData.live = liveData;
|
|
objectData.config = configData;
|
|
responsePromise.resolve(objectData);
|
|
});
|
|
});
|
|
|
|
return responsePromise.promise;
|
|
};
|
|
|
|
var getHostMetric = function (host, metric) {
|
|
return getMetric(host, undefined, metric);
|
|
};
|
|
|
|
var getHostMetricNames = function (host, metric) {
|
|
return getMetricNames(host, undefined);
|
|
};
|
|
|
|
var getServiceMetric = function (host, service, metric) {
|
|
return getMetric(host, service, metric);
|
|
};
|
|
|
|
var getServiceMetricNames = function (host, service) {
|
|
return getMetricNames(host, service);
|
|
};
|
|
|
|
var hostQueryTransform = function (fields, filters) {
|
|
var i,
|
|
transformations = {
|
|
'host_state': 'state',
|
|
};
|
|
|
|
for (i = 0; i < fields.length; i += 1) {
|
|
if (fields[i] in transformations) {
|
|
fields[i] = transformations[fields[i]];
|
|
}
|
|
}
|
|
};
|
|
|
|
// Modify response object to conform to web ui
|
|
var hostMiddleware = function (data) {
|
|
var i = 0,
|
|
conversions = {
|
|
'state': 'host_state'
|
|
};
|
|
|
|
for (i = 0; i < data.length; i += 1) {
|
|
angular.forEach(data[i], function (value, field) {
|
|
if (field in conversions) {
|
|
data[i][conversions[field]] = value;
|
|
delete data[i][field];
|
|
}
|
|
});
|
|
}
|
|
|
|
return data;
|
|
};
|
|
|
|
// Modify response object to conform to web ui
|
|
var apiMiddleware = function (data) {
|
|
var i = 0,
|
|
conversions = {};
|
|
|
|
if (jQuery.isEmptyObject(conversions)) {
|
|
return data;
|
|
}
|
|
|
|
for (i = 0; i < data.length; i += 1) {
|
|
angular.forEach(data[i], function (value, field) {
|
|
if (field in conversions) {
|
|
data[i][conversions[field]] = value;
|
|
delete data[i][field];
|
|
}
|
|
});
|
|
}
|
|
|
|
return data;
|
|
};
|
|
|
|
var getTableData = function (fields, inputSourceConfig) {
|
|
var hostFields = [],
|
|
serviceFields = [],
|
|
hostFilters = {},
|
|
serviceFilters = {},
|
|
hostKeys = {
|
|
'host_state': 'state',
|
|
'address': 'address',
|
|
'childs': 'childs'
|
|
},
|
|
responsePromise = $q.defer(),
|
|
i,
|
|
found = false;
|
|
|
|
if (inputSourceConfig.apiName === 'hosts') {
|
|
this.getObjects(fields, inputSourceConfig.filters, 'hosts')
|
|
.success(function (data) {
|
|
responsePromise.resolve(data);
|
|
});
|
|
return responsePromise.promise;
|
|
} else if (inputSourceConfig.apiName === 'services') {
|
|
angular.forEach(fields, function (field) {
|
|
if (field in hostKeys) {
|
|
hostFields.push(hostKeys[field]);
|
|
} else {
|
|
serviceFields.push(field);
|
|
}
|
|
});
|
|
|
|
// Make sure that 'host_name' is in both queries as we
|
|
// use this field to merge data
|
|
if ($.inArray('host_name', hostFields) === -1) {
|
|
hostFields.push('host_name');
|
|
}
|
|
if ($.inArray('host_name', serviceFields) === -1) {
|
|
serviceFields.push('host_name');
|
|
}
|
|
|
|
angular.forEach(inputSourceConfig.filters, function (filterData, filterName) {
|
|
angular.forEach(filterData, function (values, field) {
|
|
if (field in hostKeys) {
|
|
if (!(filterData in hostFilters)) {
|
|
hostFilters[filterName] = {};
|
|
}
|
|
hostFilters[filterName][hostKeys[field]] = values;
|
|
} else {
|
|
if (!(filterData in serviceFilters)) {
|
|
serviceFilters[filterName] = {};
|
|
}
|
|
serviceFilters[filterName][field] = values;
|
|
}
|
|
});
|
|
});
|
|
|
|
// Queries host and service APIs and merges responses
|
|
getObjects(hostFields, hostFilters, 'hosts')
|
|
.success(function (hostData) {
|
|
getObjects(serviceFields, serviceFilters, 'services')
|
|
.success(function (serviceData) {
|
|
var hostDict = {};
|
|
|
|
// Create a host dict for performance
|
|
for (i = 0; i < hostData.length; i += 1) {
|
|
var host_name = hostData[i].host_name;
|
|
|
|
angular.forEach(hostData[i], function (value, field) {
|
|
if (!(host_name in hostDict)) {
|
|
hostDict[host_name] = {};
|
|
}
|
|
|
|
hostDict[host_name][field] = value;
|
|
});
|
|
}
|
|
|
|
for (i = 0; i < serviceData.length; i += 1) {
|
|
angular.forEach(hostDict[serviceData[i].host_name],
|
|
function (value, field) {
|
|
serviceData[i][field] = value;
|
|
});
|
|
}
|
|
|
|
responsePromise.resolve(serviceData);
|
|
});
|
|
});
|
|
|
|
return responsePromise.promise;
|
|
} else if (inputSourceConfig.apiName === 'events') {
|
|
var queryFields = [];
|
|
|
|
// Queries events API
|
|
if (inputSourceConfig.fields)
|
|
queryFields = inputSourceConfig.fields;
|
|
|
|
getObjects(queryFields, inputSourceConfig.filters, 'events')
|
|
.success(function (eventsData) {
|
|
responsePromise.resolve(eventsData);
|
|
});
|
|
|
|
return responsePromise.promise;
|
|
}
|
|
};
|
|
|
|
return {
|
|
getHost: getHost,
|
|
getObjects : getObjects,
|
|
getService : getService,
|
|
hostQueryTransform: hostQueryTransform,
|
|
getHostOpenProblems: getHostOpenProblems,
|
|
hostMiddleware: hostMiddleware,
|
|
getServiceProblems: getServiceProblems,
|
|
getServiceOpenProblems: getServiceOpenProblems,
|
|
getHostProblems: getHostProblems,
|
|
getTableData: getTableData,
|
|
getTotalHosts: getTotalHosts,
|
|
getTotalServices: getTotalServices,
|
|
getServicesByHost: getServicesByHost,
|
|
getHostMetric: getHostMetric,
|
|
getHostMetricNames: getHostMetricNames,
|
|
getServiceMetric: getServiceMetric,
|
|
getServiceMetricNames: getServiceMetricNames
|
|
};
|
|
}]);
|