blob: 7c6e5522b9bd3777d6e8c17522fd781ca4e5d0e9 [file] [log] [blame]
import * as _ from 'lodash';
import {Observable, BehaviorSubject, Subscription} from 'rxjs';
import {IXosModelStoreService} from '../../datasources/stores/model.store';
import {
IXosServiceGraph, IXosServiceModel, IXosTenantModel, IXosCoarseGraphData,
IXosServiceGraphNode, IXosServiceGraphLink, IXosFineGrainedGraphData
} from '../interfaces';
import {IXosDebouncer} from '../../core/services/helpers/debounce.helper';
export interface IXosServiceGraphStore {
get(): Observable<IXosServiceGraph>;
getCoarse(): Observable<IXosServiceGraph>;
}
export class XosServiceGraphStore implements IXosServiceGraphStore {
static $inject = [
'$log',
'XosModelStore',
'XosDebouncer'
];
// graph data store
private graphData: BehaviorSubject<IXosFineGrainedGraphData> = new BehaviorSubject({
services: [],
tenants: [],
networks: [],
subscribers: [],
servicedependencys: []
});
private emptyGraph: IXosServiceGraph = {
nodes: [],
links: []
};
// representation of the graph as D3 requires
private d3CoarseGraph = new BehaviorSubject(this.emptyGraph);
private d3FineGrainedGraph = new BehaviorSubject(this.emptyGraph);
// storing locally reference to the data model
private services;
private tenants;
private subscribers;
private networks;
private servicedependencys;
// debounced functions
private handleData;
// datastore
private ServiceSubscription: Subscription;
private TenantSubscription: Subscription;
private SubscriberSubscription: Subscription;
private NetworkSubscription: Subscription;
private ServiceDependencySubscription: Subscription;
constructor (
private $log: ng.ILogService,
private XosModelStore: IXosModelStoreService,
private XosDebouncer: IXosDebouncer
) {
this.$log.info(`[XosServiceGraphStore] Setup`);
// we want to have a quiet period of 500ms from the last event before doing anything
this.handleData = this.XosDebouncer.debounce(this._handleData, 500, this, false);
// observe models and populate graphData
this.ServiceSubscription = this.XosModelStore.query('Service', '/core/services')
.subscribe(
(res) => {
this.combineData(res, 'services');
},
(err) => {
this.$log.error(`[XosServiceGraphStore] Service Observable: `, err);
}
);
this.ServiceDependencySubscription = this.XosModelStore.query('ServiceDependency', '/core/servicedependencys')
.subscribe(
(res) => {
this.combineData(res, 'servicedependencys');
},
(err) => {
this.$log.error(`[XosServiceGraphStore] Service Observable: `, err);
}
);
this.TenantSubscription = this.XosModelStore.query('Tenant', '/core/tenants')
.subscribe(
(res) => {
this.combineData(res, 'tenants');
},
(err) => {
this.$log.error(`[XosServiceGraphStore] Tenant Observable: `, err);
}
);
this.SubscriberSubscription = this.XosModelStore.query('Tenantroot', '/core/tenantroots')
.subscribe(
(res) => {
this.combineData(res, 'subscribers');
},
(err) => {
this.$log.error(`[XosServiceGraphStore] Subscriber Observable: `, err);
}
);
this.NetworkSubscription = this.XosModelStore.query('Network', '/core/networks')
.subscribe(
(res) => {
this.combineData(res, 'networks');
},
(err) => {
this.$log.error(`[XosServiceGraphStore] graphData Observable: `, err);
}
);
// observe graphData and build Coarse and FineGrained graphs
this.graphData
.subscribe(
(res: IXosFineGrainedGraphData) => {
this.$log.debug(`[XosServiceGraphStore] New graph data received`, res);
this.graphDataToCoarseGraph(res);
this.graphDataToFineGrainedGraph(res);
},
(err) => {
this.$log.error(`[XosServiceGraphStore] graphData Observable: `, err);
}
);
}
public get() {
return this.d3FineGrainedGraph.asObservable();
}
public getCoarse() {
return this.d3CoarseGraph.asObservable();
}
private combineData(data: any, type: 'services'|'tenants'|'subscribers'|'networks'|'servicedependencys') {
switch (type) {
case 'services':
this.services = data;
break;
case 'tenants':
this.tenants = data;
break;
case 'subscribers':
this.subscribers = data;
break;
case 'networks':
this.networks = data;
break;
case 'servicedependencys':
this.servicedependencys = data;
break;
}
this.handleData(this.services, this.tenants);
}
private _handleData(services: IXosServiceModel[], tenants: IXosTenantModel[]) {
this.graphData.next({
services: this.services,
tenants: this.tenants,
subscribers: this.subscribers,
networks: this.networks,
servicedependencys: this.servicedependencys
});
}
private getNodeIndexById(id: number | string, nodes: IXosServiceModel[]) {
return _.findIndex(nodes, {id: id});
}
private d3Id(type: string, id: number) {
return `${type.toLowerCase()}~${id}`;
}
private getTargetId(tenant: IXosTenantModel) {
let targetId;
if (tenant.subscriber_service_id) {
targetId = this.d3Id('service', tenant.subscriber_service_id);
}
else if (tenant.subscriber_tenant_id) {
targetId = this.d3Id('tenant', tenant.subscriber_tenant_id);
}
else if (tenant.subscriber_network_id) {
targetId = this.d3Id('network', tenant.subscriber_network_id);
}
else if (tenant.subscriber_root_id) {
// FIXME understand what's the correct model for the subscriber
targetId = this.d3Id('tenantroot', tenant.subscriber_root_id);
}
return targetId;
}
private getSourceId(tenant: IXosTenantModel) {
return this.d3Id('service', tenant.provider_service_id);
}
private getNodeType(n: any) {
return n.class_names.split(',')[0].toLowerCase();
}
private getNodeLabel(n: any) {
if (this.getNodeType(n) === 'tenant') {
return n.id;
}
return n.humanReadableName ? n.humanReadableName : n.name;
}
private removeUnwantedFineGrainedData(data: IXosFineGrainedGraphData): IXosFineGrainedGraphData {
data.tenants = _.filter(data.tenants, t => t.kind !== 'coarse');
data.networks = _.filter(data.networks, n => {
const subscriber = _.findIndex(data.tenants, {subscriber_network_id: n.id});
return subscriber > -1;
});
return data;
}
private graphDataToCoarseGraph(data: IXosCoarseGraphData) {
try {
const links: IXosServiceGraphLink[] = _.chain(data.servicedependencys)
.map((t: IXosTenantModel) => {
return {
id: t.id,
source: this.getNodeIndexById(t.provider_service_id, data.services),
target: this.getNodeIndexById(t.subscriber_service_id, data.services),
model: t
};
})
.value();
const nodes: IXosServiceGraphNode[] = _.map(data.services, (s: IXosServiceModel) => {
return {
id: s.id,
label: s.name,
model: s
};
});
let graph: IXosServiceGraph = {
nodes,
links
};
this.d3CoarseGraph.next(graph);
} catch (e) {
this.d3CoarseGraph.error(e);
}
}
private graphDataToFineGrainedGraph(data: IXosFineGrainedGraphData) {
try {
data = this.removeUnwantedFineGrainedData(data);
let nodes = _.reduce(Object.keys(data), (list: any[], k: string) => {
return list.concat(data[k]);
}, []);
nodes = _.chain(nodes)
.map(n => {
n.d3Id = this.d3Id(this.getNodeType(n), n.id);
return n;
})
.map(n => {
let node: IXosServiceGraphNode = {
id: n.d3Id,
label: this.getNodeLabel(n),
model: n,
type: this.getNodeType(n)
};
return node;
})
.value();
const links = _.reduce(data.tenants, (links: IXosServiceGraphLink[], tenant: IXosTenantModel) => {
const sourceId = this.getSourceId(tenant);
const targetId = this.getTargetId(tenant);
if (!angular.isDefined(targetId) || !angular.isDefined(sourceId)) {
// if the tenant is not pointing to anything, don't draw links
return links;
}
const tenantToProvider = {
id: `${sourceId}_${tenant.d3Id}`,
source: this.getNodeIndexById(sourceId, nodes),
target: this.getNodeIndexById(tenant.d3Id, nodes),
model: tenant
};
const tenantToSubscriber = {
id: `${tenant.d3Id}_${targetId}`,
source: this.getNodeIndexById(tenant.d3Id, nodes),
target: this.getNodeIndexById(targetId, nodes),
model: tenant
};
if (angular.isDefined(tenantToProvider.source) && angular.isDefined(tenantToProvider.target)) {
links.push(tenantToProvider);
}
if (angular.isDefined(tenantToSubscriber.source) && angular.isDefined(tenantToSubscriber.target)) {
links.push(tenantToSubscriber);
}
return links;
}, []);
if (nodes.length === 0 && links.length === 0) {
return;
}
let graph: IXosServiceGraph = {
nodes,
links
};
this.d3FineGrainedGraph.next(graph);
} catch (e) {
this.d3FineGrainedGraph.error(e);
}
}
}