| /** |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| import { Commit, ActionTree, Dispatch } from 'vuex'; |
| import graph from '@/graph'; |
| import * as types from '../../mutation-types'; |
| import axios, { AxiosPromise, AxiosResponse } from 'axios'; |
| import { cancelToken } from '@/utils/cancelToken'; |
| import { Call, Node, EndpointDependencyConidition } from '@/types/topo'; |
| import { Duration, Option } from '@/types/global'; |
| import { DEFAULT, TopologyType } from '@/constants/constant'; |
| import { uuid } from '@/utils/uuid'; |
| export interface State { |
| callback: any; |
| calls: Call[]; |
| nodes: Node[]; |
| detectPoints: string[]; |
| selectedServiceCall: Call | null; |
| currentNode: any; |
| currentLink: any; |
| current: Option; |
| mode: boolean; |
| instanceDependency: { |
| calls: Call[]; |
| nodes: Node[]; |
| }; |
| endpointDependency: { |
| calls: Call[]; |
| nodes: Node[]; |
| }; |
| selectedInstanceCall: Call | null; |
| selectedEndpointCall: Call | null; |
| endpointDependencyMetrics: { [key: string]: any }; |
| currentEndpointDepth: { key: number; label: string }; |
| topoEndpoints: { [key: string]: any[] }; |
| topoInstances: { [key: string]: any[] }; |
| topoServices: { [key: string]: any[] }; |
| topoServicesDependency: { [key: string]: any[] }; |
| topoServicesInstanceDependency: { [key: string]: any[] }; |
| topoEndpointDependency: { [key: string]: any[] }; |
| instanceDependencyMode: string; |
| editDependencyMetrics: boolean; |
| topoTemplatesType: { [key: string]: any }; |
| endpointErrors: string; |
| getTopoErrors: string; |
| endpointTopoErrors: string; |
| instanceTopoErrors: string; |
| topoErrors: { [key: string]: string }; |
| } |
| |
| const DefaultConfig = { |
| width: 12, |
| title: 'Title', |
| height: 250, |
| metricType: 'UNKNOWN', |
| }; |
| |
| const initState: State = { |
| callback: '', |
| mode: true, |
| detectPoints: [], |
| selectedServiceCall: null, |
| calls: [], |
| nodes: [], |
| currentNode: {}, |
| currentLink: {}, |
| current: { |
| key: 'default', |
| label: 'default', |
| }, |
| instanceDependency: { |
| calls: [], |
| nodes: [], |
| }, |
| endpointDependency: { |
| calls: [], |
| nodes: [], |
| }, |
| selectedInstanceCall: null, |
| selectedEndpointCall: null, |
| endpointDependencyMetrics: {}, |
| currentEndpointDepth: { key: 2, label: '2' }, |
| topoEndpoints: {}, |
| topoInstances: {}, |
| topoServices: {}, |
| topoServicesDependency: {}, |
| topoServicesInstanceDependency: {}, |
| instanceDependencyMode: '', |
| editDependencyMetrics: false, |
| topoEndpointDependency: {}, |
| topoTemplatesType: JSON.parse(localStorage.getItem('topoTemplateTypes') || JSON.stringify({})), |
| endpointErrors: '', |
| getTopoErrors: '', |
| endpointTopoErrors: '', |
| instanceTopoErrors: '', |
| topoErrors: {}, |
| }; |
| |
| // getters |
| const getters = {}; |
| |
| // mutations |
| const mutations = { |
| [types.SET_MODE](state: State, data: string[]) { |
| state.detectPoints = data; |
| const temp = state.mode ? 'SERVER' : 'CLIENT'; |
| if (data.indexOf(temp) === -1) { |
| state.mode = !state.mode; |
| } |
| }, |
| [types.SET_MODE_STATUS](state: State, data: boolean) { |
| state.mode = data; |
| }, |
| [types.SET_INSTANCE_DEPENDENCY_MODE_STATUS](state: State, data: string) { |
| state.instanceDependencyMode = data; |
| }, |
| [types.SET_NODE](state: State, data: Node) { |
| state.currentNode = data; |
| }, |
| [types.SET_LINK](state: State, data: Call) { |
| state.currentLink = data; |
| }, |
| [types.SET_TOPO](state: State, data: { nodes: Node[]; calls: Call[] }) { |
| state.calls = data.calls; |
| state.nodes = data.nodes; |
| }, |
| [types.SET_SELECTED_CALL](state: State, data: any) { |
| state.selectedServiceCall = data; |
| }, |
| [types.SET_INSTANCE_DEPENDENCY](state: State, data: any) { |
| state.instanceDependency = data; |
| }, |
| [types.SET_SELECTED_INSTANCE_CALL](state: State, data: Call) { |
| state.selectedInstanceCall = data; |
| }, |
| [types.SET_SELECTED_ENDPOINT_CALL](state: State, data: Call) { |
| state.selectedEndpointCall = data; |
| }, |
| [types.SET_TOPO_ENDPOINT](state: State, data: { [key: string]: unknown[] }) { |
| state.topoEndpoints = data; |
| window.localStorage.setItem('topologyEndpoints', JSON.stringify(data)); |
| }, |
| [types.SET_TOPO_INSTANCE](state: State, data: { [key: string]: unknown[] }) { |
| state.topoInstances = data; |
| window.localStorage.setItem('topologyInstances', JSON.stringify(data)); |
| }, |
| [types.SET_TOPO_SERVICE_DEPENDENCY](state: State, data: any) { |
| state.topoServicesDependency = data; |
| localStorage.setItem('topologyServicesDependency', JSON.stringify(data)); |
| }, |
| [types.SET_TOPO_SERVICE_INSTANCE_DEPENDENCY](state: State, data: any) { |
| state.topoServicesInstanceDependency = data; |
| localStorage.setItem('topologyServicesInstanceDependency', JSON.stringify(data)); |
| }, |
| [types.SET_TOPO_ENDPOINT_DEPENDENCY](state: State, data: any) { |
| state.topoEndpointDependency = data; |
| localStorage.setItem('topologyEndpointDependency', JSON.stringify(data)); |
| }, |
| [types.DELETE_TOPO_ENDPOINT](state: State, id: string) { |
| const serviceTemplateType = state.topoTemplatesType[TopologyType.TOPOLOGY_ENDPOINT] || {}; |
| const temps = serviceTemplateType[state.currentNode.type || DEFAULT] || [{ key: DEFAULT, label: DEFAULT }]; |
| let index = -1; |
| |
| for (const type of temps) { |
| index = state.topoEndpoints[type.key].findIndex((d) => d.uuid === id); |
| if (index > -1) { |
| state.topoEndpoints[type.key].splice(index, 1); |
| localStorage.setItem('topologyEndpoints', JSON.stringify(state.topoEndpoints)); |
| } |
| } |
| }, |
| [types.DELETE_TOPO_INSTANCE](state: State, id: string) { |
| const instanceTemplateType = state.topoTemplatesType[TopologyType.TOPOLOGY_INSTANCE] || {}; |
| const temps = instanceTemplateType[state.currentNode.type || DEFAULT] || [{ key: DEFAULT, label: DEFAULT }]; |
| let index = -1; |
| |
| for (const type of temps) { |
| index = state.topoInstances[type.key].findIndex((d) => d.uuid === id); |
| if (index > -1) { |
| state.topoInstances[type.key].splice(index, 1); |
| window.localStorage.setItem('topologyInstances', JSON.stringify(state.topoInstances)); |
| } |
| } |
| }, |
| [types.DELETE_TOPO_SERVICE](state: State, id: string) { |
| const serviceTemplateType = state.topoTemplatesType[TopologyType.TOPOLOGY_SERVICE] || {}; |
| const temps = serviceTemplateType[state.currentNode.type || DEFAULT] || [{ key: DEFAULT }]; |
| let index = -1; |
| |
| for (const type of temps) { |
| index = state.topoServices[type.key].findIndex((d) => d.uuid === id); |
| if (index > -1) { |
| state.topoServices[type.key].splice(index, 1); |
| localStorage.setItem('topologyServices', JSON.stringify(state.topoServices)); |
| } |
| } |
| }, |
| [types.DELETE_TOPO_SERVICE_DEPENDENCY](state: State, id: string) { |
| if (!state.selectedServiceCall) { |
| return; |
| } |
| const typeCall = state.selectedServiceCall.source.type || DEFAULT; |
| const serviceDependencyTemplateType = state.topoTemplatesType[TopologyType.TOPOLOGY_SERVICE_DEPENDENCY] || {}; |
| const temps = |
| serviceDependencyTemplateType[typeCall] || |
| serviceDependencyTemplateType[DEFAULT] || [{ key: DEFAULT, label: DEFAULT }] || |
| []; |
| const mode: any = state.mode ? 'server' : 'client'; |
| let index = -1; |
| |
| for (const type of temps) { |
| index = state.topoServicesDependency[type.key][mode].findIndex((d: any) => d.uuid === id); |
| if (index > -1) { |
| state.topoServicesDependency[type.key][mode].splice(index, 1); |
| localStorage.setItem('topologyServicesDependency', JSON.stringify(state.topoServicesDependency)); |
| } |
| } |
| }, |
| [types.DELETE_TOPO_ENDPOINT_DEPENDENCY](state: State, id: string) { |
| if (!state.selectedEndpointCall) { |
| return; |
| } |
| const typeCall = state.selectedEndpointCall.type || DEFAULT; |
| const serviceDependencyTemplateType = state.topoTemplatesType[TopologyType.TOPOLOGY_ENDPOINT_DEPENDENCY] || {}; |
| const temps = serviceDependencyTemplateType[typeCall] || [{ key: DEFAULT, label: DEFAULT }]; |
| let index = -1; |
| |
| for (const type of temps) { |
| index = state.topoEndpointDependency[type.key].findIndex((d) => d.uuid === id); |
| if (index > -1) { |
| state.topoEndpointDependency[type.key].splice(index, 1); |
| localStorage.setItem('topologyEndpointDependency', JSON.stringify(state.topoEndpointDependency)); |
| } |
| } |
| }, |
| [types.DELETE_TOPO_INSTANCE_DEPENDENCY](state: State, id: string) { |
| const { sourceObj } = state.selectedInstanceCall || ({} as any); |
| const typeCall = sourceObj.type || DEFAULT; |
| const mode: any = state.instanceDependencyMode; |
| const serviceDependencyTemplateType = |
| state.topoTemplatesType[TopologyType.TOPOLOGY_SERVICE_INSTANCE_DEPENDENCY] || {}; |
| const temps = serviceDependencyTemplateType[typeCall] || [{ key: DEFAULT, label: DEFAULT }]; |
| let index = -1; |
| |
| for (const type of temps) { |
| index = state.topoServicesInstanceDependency[type.key][mode].findIndex((d: any) => d.uuid === id); |
| if (index > -1) { |
| state.topoServicesInstanceDependency[type.key][mode].splice(index, 1); |
| localStorage.setItem( |
| 'topologyServicesInstanceDependency', |
| JSON.stringify(state.topoServicesInstanceDependency), |
| ); |
| } |
| } |
| }, |
| [types.EDIT_TOPO_INSTANCE_CONFIG](state: State, params: { values: any; index: number; uuid: string }) { |
| const templateType = state.topoTemplatesType[TopologyType.TOPOLOGY_INSTANCE] || {}; |
| const temps = templateType[state.currentNode.type] || [{ key: DEFAULT, label: DEFAULT }]; |
| let index = -1; |
| |
| for (const type of temps) { |
| index = state.topoInstances[type.key].findIndex((d) => d.uuid === params.uuid); |
| if (index > -1) { |
| state.topoInstances[type.key][params.index] = { |
| ...state.topoInstances[type.key][params.index], |
| ...params.values, |
| }; |
| localStorage.setItem('topologyInstances', JSON.stringify(state.topoInstances)); |
| } |
| } |
| }, |
| [types.EDIT_TOPO_ENDPOINT_CONFIG](state: State, params: { values: any; index: number; uuid: string }) { |
| const templateType = state.topoTemplatesType[TopologyType.TOPOLOGY_INSTANCE] || {}; |
| const temps = templateType[state.currentNode.type] || [{ key: DEFAULT, label: DEFAULT }]; |
| let index = -1; |
| |
| for (const type of temps) { |
| index = state.topoEndpoints[type.key].findIndex((d) => d.uuid === params.uuid); |
| if (index > -1) { |
| state.topoEndpoints[type.key][params.index] = { |
| ...state.topoEndpoints[type.key][params.index], |
| ...params.values, |
| }; |
| localStorage.setItem('topologyEndpoints', JSON.stringify(state.topoEndpoints)); |
| } |
| } |
| }, |
| [types.EDIT_TOPO_SERVICE_CONFIG](state: State, params: { values: any; index: number; uuid: string }) { |
| const serviceTemplateType = state.topoTemplatesType[TopologyType.TOPOLOGY_SERVICE] || {}; |
| const temps = serviceTemplateType[state.currentNode.type] || [{ key: DEFAULT }]; |
| let index = -1; |
| |
| for (const type of temps) { |
| index = state.topoServices[type.key].findIndex((d) => d.uuid === params.uuid); |
| if (index > -1) { |
| state.topoServices[type.key][params.index] = { |
| ...state.topoServices[type.key][params.index], |
| ...params.values, |
| }; |
| window.localStorage.setItem('topologyServices', JSON.stringify(state.topoServices)); |
| } |
| } |
| }, |
| [types.EDIT_ENDPOINT_DEPENDENCY_CONFIG](state: State, params: { values: any; index: number; uuid: string }) { |
| if (!state.selectedEndpointCall) { |
| return; |
| } |
| const endpointTemplateType = state.topoTemplatesType[TopologyType.TOPOLOGY_ENDPOINT_DEPENDENCY] || {}; |
| const temps = endpointTemplateType[state.selectedEndpointCall.type || DEFAULT] || [ |
| { key: DEFAULT, label: DEFAULT }, |
| ]; |
| let index = -1; |
| |
| for (const type of temps) { |
| index = state.topoEndpointDependency[type.key].findIndex((d) => d.uuid === params.uuid); |
| if (index > -1) { |
| state.topoEndpointDependency[type.key][index] = { |
| ...state.topoEndpointDependency[type.key][index], |
| ...params.values, |
| }; |
| localStorage.setItem('topologyEndpointDependency', JSON.stringify(state.topoEndpointDependency)); |
| } |
| } |
| }, |
| [types.EDIT_TOPO_SERVICE_DEPENDENCY_CONFIG](state: State, params: { values: any; index: number; uuid: string }) { |
| const { source } = state.currentLink; |
| const mode: any = state.mode ? 'server' : 'client'; |
| const serviceEndpointTemplateType = state.topoTemplatesType[TopologyType.TOPOLOGY_SERVICE_DEPENDENCY] || {}; |
| const temps = serviceEndpointTemplateType[source.type || DEFAULT] || [{ key: DEFAULT, label: DEFAULT }]; |
| let index = -1; |
| |
| for (const type of temps) { |
| index = state.topoServicesDependency[type.key][mode].findIndex((d: any) => d.uuid === params.uuid); |
| if (index > -1) { |
| state.topoServicesDependency[type.key][mode][params.index] = { |
| ...state.topoServicesDependency[type.key][mode][params.index], |
| ...params.values, |
| }; |
| localStorage.setItem('topologyServicesDependency', JSON.stringify(state.topoServicesDependency)); |
| } |
| } |
| }, |
| [types.EDIT_TOPO_INSTANCE_DEPENDENCY_CONFIG](state: State, params: { values: any; index: number; uuid: string }) { |
| const { sourceObj } = state.selectedInstanceCall || ({} as any); |
| const typeCall = sourceObj.type || DEFAULT; |
| const mode: any = state.instanceDependencyMode; |
| |
| if (!(state.topoServicesInstanceDependency[typeCall] && state.topoServicesInstanceDependency[typeCall][mode])) { |
| return; |
| } |
| const endpointTemplateType = state.topoTemplatesType[TopologyType.TOPOLOGY_SERVICE_INSTANCE_DEPENDENCY] || {}; |
| const temps = endpointTemplateType[typeCall] || [{ key: DEFAULT, label: DEFAULT }]; |
| let index = -1; |
| |
| for (const type of temps) { |
| index = state.topoServicesInstanceDependency[type.key][mode].findIndex((d: any) => d.uuid === params.uuid); |
| if (index > -1) { |
| state.topoServicesInstanceDependency[type.key][mode][params.index] = { |
| ...state.topoServicesInstanceDependency[type.key][mode][params.index], |
| ...params.values, |
| }; |
| localStorage.setItem( |
| 'topologyServicesInstanceDependency', |
| JSON.stringify(state.topoServicesInstanceDependency), |
| ); |
| } |
| } |
| }, |
| [types.ADD_TOPO_INSTANCE_COMP](state: State) { |
| const serviceTemplateType = state.topoTemplatesType[TopologyType.TOPOLOGY_SERVICE] || {}; |
| const temps = serviceTemplateType[state.currentNode.type] || [{ key: DEFAULT }]; |
| const type = temps[temps.length - 1 || 0].key; |
| const comp = { |
| ...DefaultConfig, |
| width: 3, |
| uuid: uuid(), |
| entityType: 'ServiceInstance', |
| }; |
| |
| state.topoInstances[type].push(comp); |
| window.localStorage.setItem('topologyInstances', JSON.stringify(state.topoInstances)); |
| }, |
| [types.ADD_TOPO_ENDPOINT_COMP](state: State) { |
| const serviceTemplateType = state.topoTemplatesType[TopologyType.TOPOLOGY_SERVICE] || {}; |
| const temps = serviceTemplateType[state.currentNode.type] || [{ key: DEFAULT }]; |
| const type = temps[temps.length - 1 || 0].key; |
| const comp = { |
| ...DefaultConfig, |
| width: 3, |
| uuid: uuid(), |
| entityType: 'Endpoint', |
| }; |
| |
| state.topoEndpoints[type].push(comp); |
| window.localStorage.setItem('topologyEndpoints', JSON.stringify(state.topoEndpoints)); |
| }, |
| [types.ADD_TOPO_SERVICE_COMP](state: State) { |
| const serviceTemplateType = state.topoTemplatesType[TopologyType.TOPOLOGY_SERVICE] || {}; |
| const temps = serviceTemplateType[state.currentNode.type] || [{ key: DEFAULT }]; |
| const type = temps[temps.length - 1 || 0].key; |
| const comp = { |
| ...DefaultConfig, |
| entityType: 'Service', |
| uuid: uuid(), |
| }; |
| state.topoServices[type].push(comp); |
| window.localStorage.setItem('topologyServices', JSON.stringify(state.topoServices)); |
| }, |
| [types.ADD_TOPO_ENDPOINT_DEPENDENCY_COMP](state: State) { |
| if (!state.selectedEndpointCall) { |
| return; |
| } |
| const callType = state.selectedEndpointCall.type || DEFAULT; |
| const endpointDependencyTemplateType = state.topoTemplatesType[TopologyType.TOPOLOGY_ENDPOINT_DEPENDENCY] || {}; |
| const temps = endpointDependencyTemplateType[callType] || [{ key: DEFAULT, label: DEFAULT }]; |
| const type = temps[temps.length - 1 || 0].key; |
| const comp = { |
| ...DefaultConfig, |
| height: 200, |
| width: 3, |
| uuid: uuid(), |
| entityType: 'EndpointRelation', |
| }; |
| |
| state.topoEndpointDependency[type].push(comp); |
| localStorage.setItem('topologyEndpointDependency', JSON.stringify(state.topoEndpointDependency)); |
| }, |
| [types.ADD_TOPO_SERVICE_DEPENDENCY_COMP](state: State) { |
| if (!state.selectedServiceCall) { |
| return; |
| } |
| const sourceType = state.selectedServiceCall.source.type || DEFAULT; |
| const serviceDependencyTemplateType = state.topoTemplatesType[TopologyType.TOPOLOGY_SERVICE_DEPENDENCY] || {}; |
| const temps = serviceDependencyTemplateType[sourceType] || serviceDependencyTemplateType[DEFAULT] || []; |
| const type = temps[temps.length - 1 || 0] ? temps[temps.length - 1 || 0].key : [DEFAULT]; |
| const mode: any = state.mode ? 'server' : 'client'; |
| |
| if (!(state.topoServicesDependency[type] && state.topoServicesDependency[type][mode])) { |
| return; |
| } |
| const comp = { |
| ...DefaultConfig, |
| uuid: uuid(), |
| entityType: 'ServiceRelation', |
| }; |
| state.topoServicesDependency[type][mode].push(comp); |
| window.localStorage.setItem('topologyServicesDependency', JSON.stringify(state.topoServicesDependency)); |
| }, |
| [types.ADD_TOPO_INSTANCE_DEPENDENCY_COMP](state: State) { |
| if (!state.selectedInstanceCall) { |
| return; |
| } |
| const sourceType = state.selectedInstanceCall.sourceObj.type || DEFAULT; |
| const serviceDependencyTemplateType = |
| state.topoTemplatesType[TopologyType.TOPOLOGY_SERVICE_INSTANCE_DEPENDENCY] || {}; |
| const temps = serviceDependencyTemplateType[sourceType] || [{ key: DEFAULT, label: DEFAULT }]; |
| const type = temps[temps.length - 1 || 0].key; |
| const mode: any = state.instanceDependencyMode; |
| |
| if (!(state.topoServicesInstanceDependency[type] && state.topoServicesInstanceDependency[type][mode])) { |
| return; |
| } |
| const comp = { |
| ...DefaultConfig, |
| uuid: uuid(), |
| entityType: 'ServiceInstanceRelation', |
| }; |
| state.topoServicesInstanceDependency[type][mode].push(comp); |
| localStorage.setItem('topologyServicesInstanceDependency', JSON.stringify(state.topoServicesInstanceDependency)); |
| }, |
| [types.SET_ENDPOINT_DEPENDENCY](state: State, data: { calls: Call[]; nodes: Node[] }) { |
| const obj = {} as any; |
| let nodes = []; |
| let calls = []; |
| nodes = data.nodes.reduce((prev: Node[], next: Node) => { |
| if (!obj[next.id]) { |
| obj[next.id] = true; |
| prev.push(next); |
| } |
| return prev; |
| }, []); |
| calls = data.calls.reduce((prev: Call[], next: Call) => { |
| if (!obj[next.id]) { |
| obj[next.id] = true; |
| prev.push(next); |
| } |
| return prev; |
| }, []); |
| state.endpointDependency = { nodes, calls }; |
| state.selectedEndpointCall = null; |
| }, |
| [types.SET_ENDPOINT_DEPTH](state: State, data: { key: number; label: string }) { |
| state.currentEndpointDepth = data; |
| }, |
| [types.SET_TOPO_SERVICE](state: State, data: any) { |
| state.topoServices = data; |
| localStorage.setItem('topologyServices', JSON.stringify(data)); |
| }, |
| [types.EDIT_DEPENDENCY_METRICS](state: State, isEdit: boolean) { |
| state.editDependencyMetrics = isEdit; |
| }, |
| [types.IMPORT_TREE_SERVICE](state: State, data: any) { |
| const keys = Object.keys(data); |
| |
| for (const key of keys) { |
| if (state.topoServices[key]) { |
| state.topoServices[key].push(...data[key]); |
| } else { |
| state.topoServices[key] = data[key]; |
| } |
| } |
| localStorage.setItem('topologyServices', JSON.stringify(state.topoServices)); |
| }, |
| [types.IMPORT_TREE_SERVICE_DEPENDENCY](state: State, data: any) { |
| const keys = Object.keys(data); |
| const modes: any = ['server', 'client']; |
| |
| for (const key of keys) { |
| if (state.topoServicesDependency[key]) { |
| for (const mode of modes) { |
| if (state.topoServicesDependency[key][mode]) { |
| state.topoServicesDependency[key][mode].push(...data[key][mode]); |
| } else { |
| state.topoServicesDependency[key][mode] = data[key][mode]; |
| } |
| } |
| } else { |
| state.topoServicesDependency[key] = data[key]; |
| } |
| } |
| localStorage.setItem('topologyServicesDependency', JSON.stringify(state.topoServicesDependency)); |
| }, |
| [types.IMPORT_TREE_ENDPOINT_DEPENDENCY](state: State, data: any) { |
| const keys = Object.keys(data); |
| |
| for (const key of keys) { |
| if (state.topoEndpointDependency[key]) { |
| state.topoEndpointDependency[key].push(...data[key]); |
| } else { |
| state.topoEndpointDependency[key] = data[key]; |
| } |
| } |
| localStorage.setItem('topologyEndpointDependency', JSON.stringify(state.topoEndpointDependency)); |
| }, |
| [types.IMPORT_TREE_INSTANCE_DEPENDENCY](state: State, data: any) { |
| const keys = Object.keys(data); |
| const modes: any = ['server', 'client']; |
| |
| for (const key of keys) { |
| if (state.topoServicesInstanceDependency[key]) { |
| for (const mode of modes) { |
| if (state.topoServicesInstanceDependency[key][mode]) { |
| state.topoServicesInstanceDependency[key][mode].push(...data[key][mode]); |
| } else { |
| state.topoServicesInstanceDependency[key][mode] = data[key][mode]; |
| } |
| } |
| } else { |
| state.topoServicesInstanceDependency[key] = data[key]; |
| } |
| } |
| localStorage.setItem('topologyServicesInstanceDependency', JSON.stringify(state.topoServicesInstanceDependency)); |
| }, |
| [types.UPDATE_TOPO_TEMPLATE_TYPES](state: State, data: any) { |
| state.topoTemplatesType = data; |
| localStorage.setItem('topoTemplateTypes', JSON.stringify(data)); |
| }, |
| [types.SET_TOPO_ERRORS](state: State, data: { msg: string; desc: string }) { |
| state.topoErrors = { |
| ...state.topoErrors, |
| [data.msg]: data.desc, |
| }; |
| }, |
| }; |
| |
| // actions |
| const actions: ActionTree<State, any> = { |
| GET_SERVICES(context: { commit: Commit }, params: { duration: Duration; keyword: string }) { |
| if (!params.keyword) { |
| params.keyword = ''; |
| } |
| return graph |
| .query('queryServices') |
| .params(params) |
| .then((res: AxiosResponse) => { |
| context.commit(types.SET_TOPO_ERRORS, { msg: 'serviceTopoErrors', desc: res.data.errors }); |
| if (res.data.errors) { |
| return []; |
| } |
| return res.data.data.services || []; |
| }); |
| }, |
| GET_SERVICE_ENDPOINTS(context: { commit: Commit }, params: { serviceId: string; keyword: string }) { |
| if (!params.serviceId) { |
| return new Promise((resolve) => resolve([])); |
| } |
| if (!params.keyword) { |
| params.keyword = ''; |
| } |
| return graph |
| .query('queryEndpoints') |
| .params(params) |
| .then((res: AxiosResponse) => { |
| context.commit(types.SET_TOPO_ERRORS, { msg: 'endpointErrors', desc: res.data.errors }); |
| if (res.data.errors) { |
| return []; |
| } |
| return res.data.data.getEndpoints || []; |
| }); |
| }, |
| CLEAR_TOPO(context: { commit: Commit; state: State }) { |
| context.commit(types.SET_TOPO, { calls: [], nodes: [] }); |
| }, |
| CLEAR_TOPO_INFO(context: { commit: Commit; state: State }) { |
| context.commit(types.SET_SELECTED_CALL, null); |
| }, |
| GET_TOPO(context: { commit: Commit; state: State }, params: any) { |
| let query = 'queryTopo'; |
| if (params.serviceId) { |
| query = 'queryServiceTopo'; |
| } |
| if (params.serviceIds) { |
| query = 'queryServicesTopo'; |
| } |
| return graph |
| .query(query) |
| .params(params) |
| .then((res: AxiosResponse) => { |
| context.commit(types.SET_TOPO_ERRORS, { msg: query, desc: res.data.errors || '' }); |
| if (!res.data.data) { |
| context.commit(types.SET_TOPO, { calls: [], nodes: [] }); |
| return; |
| } |
| const calls = res.data.data.topo.calls; |
| const nodes = res.data.data.topo.nodes; |
| const ids = nodes.map((i: any) => i.id); |
| const idsC = calls.filter((i: any) => i.detectPoints.includes('CLIENT')).map((b: any) => b.id); |
| const idsS = calls.filter((i: any) => i.detectPoints.includes('SERVER')).map((b: any) => b.id); |
| if (!ids.length) { |
| return context.commit(types.SET_TOPO, { calls: [], nodes: [] }); |
| } |
| const queryName = !idsC.length ? 'queryTopoInfoServer' : !idsS.length ? 'queryTopoInfoClient' : 'queryTopoInfo'; |
| return graph |
| .query(queryName) |
| .params({ ...params, ids, idsC, idsS }) |
| .then((info: AxiosResponse) => { |
| context.commit(types.SET_TOPO_ERRORS, { msg: 'queryTopoInfo', desc: info.data.errors || '' }); |
| const resInfo = info.data.data; |
| if (!resInfo) { |
| context.commit(types.SET_TOPO, { calls: [], nodes: [] }); |
| return; |
| } |
| if (!resInfo.sla) { |
| return context.commit(types.SET_TOPO, { calls, nodes }); |
| } |
| for (let i = 0; i < resInfo.sla.values.length; i += 1) { |
| for (let j = 0; j < nodes.length; j += 1) { |
| if (nodes[j].id === resInfo.sla.values[i].id) { |
| nodes[j] = { |
| ...nodes[j], |
| isGroupActive: true, |
| sla: resInfo.sla.values[i].value ? resInfo.sla.values[i].value / 100 : -1, |
| cpm: resInfo.nodeCpm.values[i] ? resInfo.nodeCpm.values[i].value : -1, |
| latency: resInfo.nodeLatency.values[i] ? resInfo.nodeLatency.values[i].value : -1, |
| }; |
| } |
| } |
| } |
| if (!resInfo.cpmC) { |
| return context.commit(types.SET_TOPO, { calls, nodes }); |
| } |
| for (let i = 0; i < resInfo.cpmC.values.length; i += 1) { |
| for (let j = 0; j < calls.length; j += 1) { |
| if (calls[j].id === resInfo.cpmC.values[i].id) { |
| calls[j] = { |
| ...calls[j], |
| isGroupActive: true, |
| cpm: resInfo.cpmC.values[i] ? resInfo.cpmC.values[i].value : '', |
| latency: resInfo.latencyC.values[i] ? resInfo.latencyC.values[i].value : '', |
| }; |
| } |
| } |
| } |
| if (!resInfo.cpmS) { |
| return context.commit(types.SET_TOPO, { calls, nodes }); |
| } |
| for (let i = 0; i < resInfo.cpmS.values.length; i += 1) { |
| for (let j = 0; j < calls.length; j += 1) { |
| if (calls[j].id === resInfo.cpmS.values[i].id) { |
| calls[j] = { |
| ...calls[j], |
| cpm: resInfo.cpmS.values[i] ? resInfo.cpmS.values[i].value : '', |
| latency: resInfo.latencyS.values[i] ? resInfo.latencyS.values[i].value : '', |
| }; |
| } |
| } |
| } |
| context.commit(types.SET_TOPO, { calls, nodes }); |
| }); |
| }); |
| }, |
| // todo sync |
| GET_ALL_ENDPOINT_DEPENDENCY( |
| context: { commit: Commit; state: State; dispatch: Dispatch }, |
| params: { endpointIds: string[]; duration: Duration }, |
| ) { |
| context.dispatch('GET_ENDPOINT_TOPO', params).then((res) => { |
| if (!res) { |
| return; |
| } |
| if (context.state.currentEndpointDepth.key > 1) { |
| const endpointIds = res.nodes |
| .map((item: Node) => item.id) |
| .filter((d: string) => !params.endpointIds.includes(d)); |
| if (!endpointIds.length) { |
| context.commit(types.SET_ENDPOINT_DEPENDENCY, res); |
| return; |
| } |
| context.dispatch('GET_ENDPOINT_TOPO', { endpointIds, duration: params.duration }).then((json) => { |
| if (context.state.currentEndpointDepth.key > 2) { |
| const ids = json.nodes |
| .map((item: Node) => item.id) |
| .filter((d: string) => ![...endpointIds, ...params.endpointIds].includes(d)); |
| if (!ids.length) { |
| const nodes = [...res.nodes, ...json.nodes]; |
| const calls = [...res.calls, ...json.calls]; |
| context.commit(types.SET_ENDPOINT_DEPENDENCY, { nodes, calls }); |
| return; |
| } |
| context.dispatch('GET_ENDPOINT_TOPO', { endpointIds: ids, duration: params.duration }).then((topo) => { |
| if (context.state.currentEndpointDepth.key > 3) { |
| const endpoints = topo.nodes |
| .map((item: Node) => item.id) |
| .filter((d: string) => ![...ids, ...endpointIds, ...params.endpointIds].includes(d)); |
| if (!endpoints.length) { |
| const nodes = [...res.nodes, ...json.nodes, ...topo.nodes]; |
| const calls = [...res.calls, ...json.calls, ...topo.calls]; |
| context.commit(types.SET_ENDPOINT_DEPENDENCY, { nodes, calls }); |
| } |
| context |
| .dispatch('GET_ENDPOINT_TOPO', { endpointIds: endpoints, duration: params.duration }) |
| .then((data) => { |
| if (context.state.currentEndpointDepth.key > 4) { |
| const nodeIds = data.nodes |
| .map((item: Node) => item.id) |
| .filter( |
| (d: string) => ![...endpoints, ...ids, ...endpointIds, ...params.endpointIds].includes(d), |
| ); |
| if (!nodeIds.length) { |
| const nodes = [...res.nodes, ...json.nodes, ...topo.nodes, ...data.nodes]; |
| const calls = [...res.calls, ...json.calls, ...topo.calls, ...data.calls]; |
| context.commit(types.SET_ENDPOINT_DEPENDENCY, { nodes, calls }); |
| return; |
| } |
| context |
| .dispatch('GET_ENDPOINT_TOPO', { endpointIds: nodeIds, duration: params.duration }) |
| .then((toposObj) => { |
| const nodes = [...res.nodes, ...json.nodes, ...topo.nodes, ...data.nodes, ...toposObj.nodes]; |
| const calls = [...res.calls, ...json.calls, ...topo.calls, ...data.calls, ...toposObj.calls]; |
| context.commit(types.SET_ENDPOINT_DEPENDENCY, { nodes, calls }); |
| }); |
| } else { |
| const nodes = [...res.nodes, ...json.nodes, ...topo.nodes, ...data.nodes]; |
| const calls = [...res.calls, ...json.calls, ...topo.calls, ...data.calls]; |
| context.commit(types.SET_ENDPOINT_DEPENDENCY, { nodes, calls }); |
| } |
| }); |
| } else { |
| const nodes = [...res.nodes, ...json.nodes, ...topo.nodes]; |
| const calls = [...res.calls, ...json.calls, ...topo.calls]; |
| context.commit(types.SET_ENDPOINT_DEPENDENCY, { nodes, calls }); |
| } |
| }); |
| } else { |
| const nodes = [...res.nodes, ...json.nodes]; |
| const calls = [...res.calls, ...json.calls]; |
| context.commit(types.SET_ENDPOINT_DEPENDENCY, { nodes, calls }); |
| } |
| }); |
| } else { |
| context.commit(types.SET_ENDPOINT_DEPENDENCY, res); |
| } |
| }); |
| }, |
| GET_ENDPOINT_TOPO(context: { commit: Commit; state: State }, params: { endpointIds: string[]; duration: Duration }) { |
| const variables = ['$duration: Duration!']; |
| const fragment = params.endpointIds.map((id: string, index: number) => { |
| return `endpointTopology${index}: getEndpointDependencies(endpointId: "${id}", duration: $duration) { |
| nodes { |
| id |
| name |
| serviceId |
| serviceName |
| type |
| isReal |
| } |
| calls { |
| id |
| source |
| target |
| detectPoints |
| } |
| }`; |
| }); |
| const querys = `query queryData(${variables}) {${fragment}}`; |
| return axios |
| .post('/graphql', { query: querys, variables: { duration: params.duration } }, { cancelToken: cancelToken() }) |
| .then((res: AxiosResponse) => { |
| if (res.data.errors) { |
| const msg = res.data.errors.map((e: { message: string }) => e.message).join(' '); |
| |
| context.commit(types.SET_TOPO_ERRORS, { msg: 'endpointDependencyError', desc: msg }); |
| context.commit(types.SET_ENDPOINT_DEPENDENCY, { calls: [], nodes: [] }); |
| return; |
| } |
| const topo = res.data.data; |
| let calls = [] as any; |
| let nodes = [] as any; |
| for (const key of Object.keys(topo)) { |
| calls.push(...topo[key].calls); |
| nodes.push(...topo[key].nodes); |
| } |
| if (!nodes.length) { |
| context.commit(types.SET_TOPO_ERRORS, { msg: 'endpointDependencyError', desc: '' }); |
| context.commit(types.SET_ENDPOINT_DEPENDENCY, { calls: [], nodes: [] }); |
| return; |
| } |
| const obj = {} as any; |
| nodes = nodes.reduce((prev: Node[], next: Node) => { |
| if (!obj[next.id]) { |
| obj[next.id] = true; |
| prev.push(next); |
| } |
| return prev; |
| }, []); |
| calls = calls.reduce((prev: Call[], next: Call) => { |
| if (!obj[next.id]) { |
| obj[next.id] = true; |
| prev.push(next); |
| } |
| return prev; |
| }, []); |
| const queryVariables = ['$duration: Duration!']; |
| const fragments = calls |
| .map((call: Call & EndpointDependencyConidition, index: number) => { |
| let source = {} as any; |
| let target = {} as any; |
| for (const node of nodes) { |
| if (node.id === call.source) { |
| source = node; |
| call.serviceName = node.serviceName; |
| call.endpointName = node.name; |
| call.serviceId = node.serviceId; |
| call.endpointId = node.id; |
| call.type = node.type; |
| } |
| if (node.id === call.target) { |
| target = node; |
| call.destServiceName = node.serviceName; |
| call.destServiceId = node.serviceId; |
| call.destEndpointName = node.name; |
| call.destEndpointId = node.id; |
| } |
| } |
| return `cpm_${index}: readMetricsValue(condition: { |
| name: "endpoint_relation_cpm" |
| entity: { |
| scope: EndpointRelation |
| serviceName: "${source.serviceName}" |
| normal: true |
| endpointName: "${source.name}" |
| destNormal: true |
| destServiceName: "${target.serviceName}" |
| destEndpointName: "${target.name}" |
| } |
| }, duration: $duration)`; |
| }) |
| .join(' '); |
| const query = `query queryData(${queryVariables}) {${fragments}}`; |
| return axios |
| .post('/graphql', { query, variables: { duration: params.duration } }, { cancelToken: cancelToken() }) |
| .then((json: AxiosResponse<any>) => { |
| if (json.data.errors) { |
| const msg = json.data.errors.map((e: { message: string }) => e.message).join(' '); |
| |
| context.commit(types.SET_TOPO_ERRORS, { msg: 'endpointDependencyError', desc: msg }); |
| context.commit(types.SET_ENDPOINT_DEPENDENCY, { calls: [], nodes: [] }); |
| return; |
| } |
| context.commit(types.SET_TOPO_ERRORS, { msg: 'endpointDependencyError', desc: '' }); |
| const cpms = json.data.data; |
| const keys = Object.keys(cpms); |
| for (const key of keys) { |
| const index = Number(key.split('_')[1]); |
| calls[index].value = cpms[key] || 0.01; |
| } |
| return { calls, nodes }; |
| }) |
| .catch(() => { |
| context.commit(types.SET_ENDPOINT_DEPENDENCY, { calls: [], nodes: [] }); |
| }); |
| }); |
| }, |
| GET_TOPO_INSTANCE_DEPENDENCY( |
| context: { commit: Commit; state: State }, |
| params: { |
| clientServiceId: string; |
| serverServiceId: string; |
| duration: Duration; |
| }, |
| ) { |
| graph |
| .query('queryTopoInstanceDependency') |
| .params(params) |
| .then((res: AxiosResponse) => { |
| context.commit(types.SET_TOPO_ERRORS, { msg: 'queryTopoInstanceDependency', desc: res.data.errors || '' }); |
| if (res.data.errors) { |
| return []; |
| } |
| const clientIdsC = [] as string[]; |
| const serverIdsC = [] as string[]; |
| const topoCalls = res.data.data.topo.calls; |
| for (const call of topoCalls) { |
| if (call.detectPoints.includes('CLIENT')) { |
| clientIdsC.push(call.id); |
| } else { |
| serverIdsC.push(call.id); |
| } |
| } |
| let callback; |
| let callbackServer; |
| if (clientIdsC.length) { |
| callback = graph |
| .query('queryDependencyInstanceClientMetric') |
| .params({ |
| idsC: clientIdsC, |
| duration: params.duration, |
| }) |
| .then((json: AxiosResponse) => { |
| context.commit(types.SET_TOPO_ERRORS, { |
| msg: 'queryDependencyInstanceClientMetric', |
| desc: json.data.errors || '', |
| }); |
| if (json.data.errors) { |
| return []; |
| } |
| const clientCalls = [] as string[]; |
| for (const call of topoCalls) { |
| for (const cpm of json.data.data.cpmC.values) { |
| if (cpm.id === call.id) { |
| clientCalls.push({ |
| ...call, |
| ...cpm, |
| }); |
| } |
| } |
| } |
| return clientCalls; |
| }); |
| } else { |
| callback = new Promise((resolve) => resolve([])); |
| } |
| if (serverIdsC.length) { |
| callbackServer = graph |
| .query('queryDependencyInstanceServerMetric') |
| .params({ |
| idsC: serverIdsC, |
| duration: params.duration, |
| }) |
| .then((jsonResp: AxiosResponse) => { |
| context.commit(types.SET_TOPO_ERRORS, { |
| msg: 'queryDependencyInstanceServerMetric', |
| desc: jsonResp.data.errors || '', |
| }); |
| if (jsonResp.data.errors) { |
| return []; |
| } |
| const serverCalls = [] as string[]; |
| for (const call of topoCalls) { |
| for (const cpm of jsonResp.data.data.cpmC.values) { |
| if (cpm.id === call.id) { |
| serverCalls.push({ |
| ...call, |
| ...cpm, |
| }); |
| } |
| } |
| } |
| return serverCalls; |
| }); |
| } else { |
| callbackServer = new Promise((resolve) => resolve([])); |
| } |
| Promise.all([callback, callbackServer]).then((values: any) => { |
| const instanceDependency = { |
| nodes: res.data.data.topo.nodes, |
| calls: [...values[0], ...values[1]], |
| }; |
| for (const call of instanceDependency.calls) { |
| for (const node of instanceDependency.nodes) { |
| if (call.source === node.id) { |
| call.sourceObj = node; |
| } |
| if (call.target === node.id) { |
| call.targetObj = node; |
| } |
| } |
| } |
| context.commit(types.SET_INSTANCE_DEPENDENCY, instanceDependency); |
| }); |
| }); |
| }, |
| }; |
| |
| export default { |
| namespaced: true, |
| state: initState, |
| getters, |
| actions, |
| mutations, |
| }; |
