open-consul/ui/packages/consul-ui/app/services/repository/dc.js

219 lines
6.3 KiB
JavaScript

import Error from '@ember/error';
import { inject as service } from '@ember/service';
import RepositoryService from 'consul-ui/services/repository';
import dataSource from 'consul-ui/decorators/data-source';
import {
HEADERS_DEFAULT_ACL_POLICY as DEFAULT_ACL_POLICY,
} from 'consul-ui/utils/http/consul';
const SECONDS = 1000;
const MODEL_NAME = 'dc';
const zero = {
Total: 0,
Passing: 0,
Warning: 0,
Critical: 0
};
const aggregate = (prev, body, type) => {
return body[type].reduce((prev, item) => {
// for each Partitions, Namespaces
['Partition', 'Namespace'].forEach(bucket => {
// lazily initialize
let obj = prev[bucket][item[bucket]];
if(typeof obj === 'undefined') {
obj = prev[bucket][item[bucket]] = {
Name: item[bucket],
};
}
if(typeof obj[type] === 'undefined') {
obj[type] = {
...zero
};
}
//
// accumulate
obj[type].Total += item.Total;
obj[type].Passing += item.Passing;
obj[type].Warning += item.Warning;
obj[type].Critical += item.Critical;
});
// also aggregate the Datacenter, without doubling up
// for Partitions/Namespaces
prev.Datacenter[type].Total += item.Total;
prev.Datacenter[type].Passing += item.Passing;
prev.Datacenter[type].Warning += item.Warning;
prev.Datacenter[type].Critical += item.Critical;
return prev;
}, prev);
}
export default class DcService extends RepositoryService {
@service('env') env;
getModelName() {
return MODEL_NAME;
}
@dataSource('/:partition/:ns/:dc/datacenters')
async fetchAll({partition, ns, dc}, { uri }, request) {
const Local = this.env.var('CONSUL_DATACENTER_LOCAL');
const Primary = this.env.var('CONSUL_DATACENTER_PRIMARY');
return (await request`
GET /v1/catalog/datacenters
X-Request-ID: ${uri}
`)(
(headers, body, cache) => {
// TODO: Not sure nowadays whether we need to keep lowercasing everything
// I vaguely remember when I last looked it was not needed for browsers anymore
// but I also vaguely remember something about Pretender lowercasing things still
// so if we can work around Pretender I think we can remove all the header lowercasing
// For the moment we lowercase here so as to not effect the ember-data-flavoured-v1 fork
const entry = Object.entries(headers)
.find(([key, value]) => key.toLowerCase() === DEFAULT_ACL_POLICY.toLowerCase());
//
const DefaultACLPolicy = entry[1] || 'allow';
return {
meta: {
version: 2,
uri: uri,
},
body: body.map(dc => {
return cache(
{
Name: dc,
Datacenter: '',
Local: dc === Local,
Primary: dc === Primary,
DefaultACLPolicy: DefaultACLPolicy,
},
uri => uri`${MODEL_NAME}:///${''}/${''}/${dc}/datacenter`
);
})
};
});
}
@dataSource('/:partition/:ns/:dc/datacenter')
async fetch({partition, ns, dc}, { uri }, request) {
return (await request`
GET /v1/operator/autopilot/state?${{ dc }}
X-Request-ID: ${uri}
`)(
(headers, body, cache) => {
// turn servers into an array instead of a map/object
const servers = Object.values(body.Servers);
const grouped = [];
return {
meta: {
version: 2,
uri: uri,
},
body: cache(
{
...body,
// all servers
Servers: servers,
RedundancyZones: Object.entries(body.RedundancyZones || {}).map(([key, value]) => {
const zone = {
...value,
Name: key,
Healthy: true,
// convert the string[] to Server[]
Servers: value.Servers.reduce((prev, item) => {
const server = body.Servers[item];
// keep a record of things
grouped.push(server.ID);
prev.push(server);
return prev;
}, []),
}
return zone;
}),
ReadReplicas: (body.ReadReplicas || []).map(item => {
// keep a record of things
grouped.push(item);
return body.Servers[item];
}),
Default: {
Servers: servers.filter(item => !grouped.includes(item.ID))
}
},
uri => uri`${MODEL_NAME}:///${''}/${''}/${dc}/datacenter`
)
}
}
);
}
@dataSource('/:partition/:ns/:dc/catalog/health')
async fetchCatalogHealth({partition, ns, dc}, { uri }, request) {
return (await request`
GET /v1/internal/ui/catalog-overview?${{ dc, stale: null }}
X-Request-ID: ${uri}
`)(
(headers, body, cache) => {
// for each Services/Nodes/Checks aggregate
const agg = ['Nodes', 'Services', 'Checks']
.reduce((prev, item) => aggregate(prev, body, item), {
Datacenter: {
Name: dc,
Nodes: {
...zero
},
Services: {
...zero
},
Checks: {
...zero
}
},
Partition: {},
Namespace: {}
});
return {
meta: {
version: 2,
uri: uri,
interval: 30 * SECONDS
},
body: {
Datacenter: agg.Datacenter,
Partitions: Object.values(agg.Partition),
Namespaces: Object.values(agg.Namespace),
...body
}
};
}
);
}
@dataSource('/:partition/:ns/:dc/datacenter-cache/:name')
async find(params) {
const items = this.store.peekAll('dc');
const item = items.findBy('Name', params.name);
if (typeof item === 'undefined') {
// TODO: We should use a HTTPError error here and remove all occurances of
// the custom shaped ember-data error throughout the app
const e = new Error('Page not found');
e.status = '404';
throw { errors: [e] };
}
return item;
}
}