var app = angular.module('sentinelDashboardApp');
|
|
app.controller('SentinelClusterAppServerListController', ['$scope', '$stateParams', 'ngDialog',
|
'MachineService', 'ClusterStateService',
|
function ($scope, $stateParams, ngDialog, MachineService, ClusterStateService) {
|
$scope.app = $stateParams.app;
|
const UNSUPPORTED_CODE = 4041;
|
|
const CLUSTER_MODE_CLIENT = 0;
|
const CLUSTER_MODE_SERVER = 1;
|
const DEFAULT_CLUSTER_SERVER_PORT = 18730;
|
const DEFAULT_NAMESPACE = 'default';
|
const DEFAULT_MAX_ALLOWED_QPS = 20000;
|
|
// tmp for dialog temporary data.
|
$scope.tmp = {
|
curClientChosen: [],
|
curRemainingClientChosen: [],
|
curChosenServer: {},
|
};
|
|
$scope.remainingMachineList = [];
|
|
function convertSetToString(set) {
|
if (set === undefined) {
|
return '';
|
}
|
if (set.length === 1 && set[0] === DEFAULT_NAMESPACE) {
|
return DEFAULT_NAMESPACE;
|
}
|
let s = '';
|
for (let i = 0; i < set.length; i++) {
|
let ns = set[i];
|
if (ns !== DEFAULT_NAMESPACE) {
|
s = s + ns;
|
if (i < set.length - 1) {
|
s = s + ',';
|
}
|
}
|
}
|
return s;
|
}
|
|
function convertStrToNamespaceSet(str) {
|
if (str === undefined || str === '') {
|
return [];
|
}
|
let arr = [];
|
let spliced = str.split(',');
|
spliced.forEach((v) => {
|
arr.push(v.trim());
|
});
|
return arr;
|
}
|
|
function processAppSingleData(data) {
|
if (data.state.server && data.state.server.namespaceSet) {
|
data.state.server.namespaceSetStr = convertSetToString(data.state.server.namespaceSet);
|
data.mode = data.state.stateInfo.mode;
|
}
|
}
|
|
function removeFromArr(arr, v) {
|
for (let i = 0; i < arr.length; i++) {
|
if (arr[i] === v) {
|
arr.splice(i, 1);
|
break;
|
}
|
}
|
}
|
|
function removeFromArrIf(arr, f) {
|
for (let i = 0; i < arr.length; i++) {
|
if (f(arr[i]) === true) {
|
arr.splice(i, 1);
|
break;
|
}
|
}
|
}
|
|
function resetAssignDialogChosen() {
|
$scope.tmp.curClientChosen = [];
|
$scope.tmp.curRemainingClientChosen = [];
|
}
|
|
function generateMachineId(e) {
|
return e.ip + '@' + e.commandPort;
|
}
|
|
function applyClusterMap(appClusterMachineList) {
|
if (!appClusterMachineList) {
|
return;
|
}
|
let tmpMap = new Map();
|
let serverCommandPortMap = new Map();
|
$scope.clusterMap = [];
|
$scope.remainingMachineList = [];
|
let tmpServerList = [];
|
let tmpClientList = [];
|
appClusterMachineList.forEach((e) => {
|
if (e.mode === CLUSTER_MODE_CLIENT) {
|
tmpClientList.push(e);
|
} else if (e.mode === CLUSTER_MODE_SERVER) {
|
tmpServerList.push(e);
|
} else {
|
$scope.remainingMachineList.push(generateMachineId(e));
|
}
|
});
|
tmpServerList.forEach((e) => {
|
let ip = e.ip;
|
let machineId = ip + '@' + e.commandPort;
|
let group = {
|
ip: ip,
|
machineId: machineId,
|
port: e.state.server.port,
|
clientSet: [],
|
namespaceSetStr: e.state.server.namespaceSetStr,
|
maxAllowedQps: e.state.server.flow.maxAllowedQps,
|
belongToApp: true,
|
};
|
if (!tmpMap.has(machineId)) {
|
tmpMap.set(machineId, group);
|
}
|
serverCommandPortMap.set(ip + ':' + e.state.server.port, e.commandPort);
|
});
|
tmpClientList.forEach((e) => {
|
let ip = e.ip;
|
let machineId = ip + '@' + e.commandPort;
|
|
let targetServer = e.state.client.clientConfig.serverHost;
|
let targetPort = e.state.client.clientConfig.serverPort;
|
if (targetServer === undefined || targetServer === '' ||
|
targetPort === undefined || targetPort <= 0) {
|
$scope.remainingMachineList.push(generateMachineId(e));
|
return;
|
}
|
|
let serverHostPort = targetServer + ':' + targetPort;
|
|
if (serverCommandPortMap.has(serverHostPort)) {
|
let serverCommandPort = serverCommandPortMap.get(serverHostPort);
|
let g;
|
if (serverCommandPort < 0) {
|
// Not belong to this app.
|
g = tmpMap.get(serverHostPort);
|
} else {
|
// Belong to this app.
|
g = tmpMap.get(targetServer + '@' + serverCommandPort);
|
}
|
g.clientSet.push(machineId);
|
} else {
|
let group = {
|
ip: targetServer,
|
machineId: serverHostPort,
|
port: targetPort,
|
clientSet: [machineId],
|
belongToApp: false,
|
};
|
tmpMap.set(serverHostPort, group);
|
// Indicates that it's not belonging to current app.
|
serverCommandPortMap.set(serverHostPort, -1);
|
}
|
|
// if (!tmpMap.has(serverHostPort)) {
|
// let group = {
|
// ip: targetServer,
|
// machineId: targetServer,
|
// port: targetPort,
|
// clientSet: [machineId],
|
// belongToApp: false,
|
// };
|
// tmpMap.set(targetServer, group);
|
// } else {
|
// let g = tmpMap.get(targetServer);
|
// g.clientSet.push(machineId);
|
// }
|
});
|
tmpMap.forEach((v) => {
|
if (v !== undefined) {
|
$scope.clusterMap.push(v);
|
}
|
});
|
}
|
|
$scope.notChosenServer = (id) => {
|
return id !== $scope.serverAssignDialogData.serverData.currentServer;
|
};
|
|
$scope.onCurrentServerChange = () => {
|
resetAssignDialogChosen();
|
};
|
|
$scope.moveToServerGroup = () => {
|
$scope.tmp.curRemainingClientChosen.forEach(e => {
|
$scope.serverAssignDialogData.serverData.clientSet.push(e);
|
removeFromArr($scope.remainingMachineList, e);
|
});
|
resetAssignDialogChosen();
|
};
|
|
$scope.moveToRemainingSharePool = () => {
|
$scope.tmp.curClientChosen.forEach(e => {
|
$scope.remainingMachineList.push(e);
|
removeFromArr($scope.serverAssignDialogData.serverData.clientSet, e);
|
});
|
resetAssignDialogChosen();
|
};
|
|
function parseIpFromMachineId(machineId) {
|
if (machineId.indexOf(':') !== -1) {
|
return machineId.split(':')[0];
|
}
|
if (machineId.indexOf('@') === -1) {
|
return machineId;
|
}
|
let arr = machineId.split('@');
|
return arr[0];
|
}
|
|
function retrieveClusterAssignInfoOfApp() {
|
ClusterStateService.fetchClusterUniversalStateOfApp($scope.app).success(function (data) {
|
if (data.code === 0 && data.data) {
|
$scope.loadError = undefined;
|
$scope.appClusterMachineList = data.data;
|
$scope.appClusterMachineList.forEach(processAppSingleData);
|
applyClusterMap($scope.appClusterMachineList);
|
} else {
|
$scope.appClusterMachineList = {};
|
if (data.code === UNSUPPORTED_CODE) {
|
$scope.loadError = {message: '该应用的 Sentinel 客户端不支持集群限流，请升级至 1.4.0 以上版本并引入相关依赖。'}
|
} else {
|
$scope.loadError = {message: data.msg};
|
}
|
}
|
}).error(() => {
|
$scope.loadError = {message: '未知错误'};
|
});
|
}
|
|
|
$scope.newServerDialog = () => {
|
retrieveClusterAssignInfoOfApp();
|
$scope.serverAssignDialogData = {
|
title: '新增 Token Server',
|
type: 'add',
|
confirmBtnText: '保存',
|
serverData: {
|
serverType: 0,
|
clientSet: [],
|
serverPort: DEFAULT_CLUSTER_SERVER_PORT,
|
maxAllowedQps: DEFAULT_MAX_ALLOWED_QPS,
|
}
|
};
|
$scope.serverAssignDialog = ngDialog.open({
|
template: '/app/views/dialog/cluster/cluster-server-assign-dialog.html',
|
width: 1000,
|
overlay: true,
|
scope: $scope
|
});
|
};
|
|
$scope.modifyServerAssignConfig = (serverVO) => {
|
let id = serverVO.id;
|
ClusterStateService.fetchClusterUniversalStateOfApp($scope.app).success(function (data) {
|
if (data.code === 0 && data.data) {
|
$scope.loadError = undefined;
|
$scope.appClusterMachineList = data.data;
|
$scope.appClusterMachineList.forEach(processAppSingleData);
|
applyClusterMap($scope.appClusterMachineList);
|
let clusterMap = $scope.clusterMap;
|
let d;
|
for (let i = 0; i < clusterMap.length; i++) {
|
if (clusterMap[i].machineId === id) {
|
d = clusterMap[i];
|
}
|
}
|
if (!d) {
|
alert('状态错误');
|
return;
|
}
|
$scope.serverAssignDialogData = {
|
title: 'Token Server 分配编辑',
|
type: 'edit',
|
confirmBtnText: '保存',
|
serverData: {
|
currentServer: d.machineId,
|
belongToApp: serverVO.belongToApp,
|
serverPort: d.port,
|
clientSet: d.clientSet,
|
}
|
};
|
if (d.maxAllowedQps !== undefined) {
|
$scope.serverAssignDialogData.serverData.maxAllowedQps = d.maxAllowedQps;
|
}
|
$scope.serverAssignDialog = ngDialog.open({
|
template: '/app/views/dialog/cluster/cluster-server-assign-dialog.html',
|
width: 1000,
|
overlay: true,
|
scope: $scope
|
});
|
} else {
|
if (data.code === UNSUPPORTED_CODE) {
|
$scope.loadError = {message: '该应用的 Sentinel 客户端不支持集群限流，请升级至 1.4.0 以上版本并引入相关依赖。'}
|
} else {
|
$scope.loadError = {message: data.msg};
|
}
|
}
|
}).error(() => {
|
$scope.loadError = {message: '未知错误'};
|
});
|
};
|
|
function getRemainingMachineList() {
|
return $scope.remainingMachineList.filter((e) => $scope.notChosenServer(e));
|
}
|
|
function doApplyNewSingleServerAssign() {
|
let ok = confirm('是否确认执行变更？');
|
if (!ok) {
|
return;
|
}
|
let serverData = $scope.serverAssignDialogData.serverData;
|
let belongToApp = serverData.serverType == 0; // don't modify here!
|
let machineId = serverData.currentServer;
|
let request = {
|
clusterMap: {
|
machineId: machineId,
|
ip: parseIpFromMachineId(machineId),
|
port: serverData.serverPort,
|
clientSet: serverData.clientSet,
|
belongToApp: belongToApp,
|
maxAllowedQps: serverData.maxAllowedQps,
|
},
|
remainingList: getRemainingMachineList(),
|
};
|
ClusterStateService.applyClusterSingleServerAssignOfApp($scope.app, request).success((data) => {
|
if (data.code === 0 && data.data) {
|
let failedServerSet = data.data.failedServerSet;
|
let failedClientSet = data.data.failedClientSet;
|
if (failedClientSet.length === 0 && failedServerSet.length === 0) {
|
alert('全部推送成功');
|
} else {
|
let failedSet = [];
|
if (failedServerSet) {
|
failedServerSet.forEach((e) => {
|
failedSet.push(e);
|
});
|
}
|
if (failedClientSet) {
|
failedClientSet.forEach((e) => {
|
failedSet.push(e);
|
});
|
}
|
|
alert('推送完毕。失败机器列表：' + JSON.stringify(failedSet));
|
}
|
|
location.reload();
|
} else {
|
if (data.code === UNSUPPORTED_CODE) {
|
alert('该应用的 Sentinel 客户端不支持集群限流，请升级至 1.4.0 以上版本并引入相关依赖。');
|
} else {
|
alert('推送失败：' + data.msg);
|
}
|
}
|
}).error(() => {
|
alert('未知错误');
|
});
|
}
|
|
function doApplySingleServerAssignEdit() {
|
let ok = confirm('是否确认执行变更？');
|
if (!ok) {
|
return;
|
}
|
let serverData = $scope.serverAssignDialogData.serverData;
|
let machineId = serverData.currentServer;
|
let request = {
|
clusterMap: {
|
machineId: machineId,
|
ip: parseIpFromMachineId(machineId),
|
port: serverData.serverPort,
|
clientSet: serverData.clientSet,
|
belongToApp: serverData.belongToApp,
|
},
|
remainingList: $scope.remainingMachineList,
|
};
|
if (serverData.maxAllowedQps !== undefined) {
|
request.clusterMap.maxAllowedQps = serverData.maxAllowedQps;
|
}
|
ClusterStateService.applyClusterSingleServerAssignOfApp($scope.app, request).success((data) => {
|
if (data.code === 0 && data.data) {
|
let failedServerSet = data.data.failedServerSet;
|
let failedClientSet = data.data.failedClientSet;
|
if (failedClientSet.length === 0 && failedServerSet.length === 0) {
|
alert('全部推送成功');
|
} else {
|
let failedSet = [];
|
failedServerSet.forEach(failedSet.push);
|
failedClientSet.forEach(failedSet.push);
|
alert('推送完毕。失败机器列表：' + JSON.stringify(failedSet));
|
}
|
|
location.reload();
|
} else {
|
if (data.code === UNSUPPORTED_CODE) {
|
alert('该应用的 Sentinel 客户端不支持集群限流，请升级至 1.4.0 以上版本并引入相关依赖。');
|
} else {
|
alert('推送失败：' + data.msg);
|
}
|
}
|
}).error(() => {
|
alert('未知错误');
|
});
|
}
|
|
$scope.saveAssignForDialog = () => {
|
if (!checkAssignDialogValid()) {
|
return;
|
}
|
if ($scope.serverAssignDialogData.type === 'add') {
|
doApplyNewSingleServerAssign();
|
} else if ($scope.serverAssignDialogData.type === 'edit') {
|
doApplySingleServerAssignEdit();
|
} else {
|
alert('未知的操作');
|
}
|
};
|
|
function checkAssignDialogValid() {
|
let serverData = $scope.serverAssignDialogData.serverData;
|
if (serverData.currentServer === undefined || serverData.currentServer === '') {
|
alert('请指定有效的 Token Server');
|
return false;
|
}
|
if (serverData.serverPort === undefined || serverData.serverPort <= 0 || serverData.serverPort > 65535) {
|
alert('请输入合法的端口值');
|
return false;
|
}
|
if (serverData.maxAllowedQps !== undefined && serverData.maxAllowedQps < 0) {
|
alert('请输入合法的最大允许 QPS');
|
return false;
|
}
|
return true;
|
}
|
|
$scope.viewConnectionDetail = (serverVO) => {
|
$scope.connectionDetailDialogData = {
|
serverData: serverVO
|
};
|
$scope.connectionDetailDialog = ngDialog.open({
|
template: '/app/views/dialog/cluster/cluster-server-connection-detail-dialog.html',
|
width: 700,
|
overlay: true,
|
scope: $scope
|
});
|
};
|
|
function generateRequestLimitDataStr(limitData) {
|
if (limitData.length === 1 && limitData[0].namespace === DEFAULT_NAMESPACE) {
|
return 'default: ' + limitData[0].currentQps + ' / ' + limitData[0].maxAllowedQps;
|
}
|
for (let i = 0; i < limitData.length; i++) {
|
let crl = limitData[i];
|
if (crl.namespace === $scope.app) {
|
return '' + crl.currentQps + ' / ' + crl.maxAllowedQps;
|
}
|
}
|
return '0';
|
}
|
|
function processServerListData(serverVO) {
|
if (serverVO.state && serverVO.state.namespaceSet) {
|
serverVO.state.namespaceSetStr = convertSetToString(serverVO.state.namespaceSet);
|
}
|
if (serverVO.state && serverVO.state.requestLimitData) {
|
serverVO.state.requestLimitDataStr = generateRequestLimitDataStr(serverVO.state.requestLimitData);
|
}
|
}
|
|
$scope.generateConnectionSet = (data) => {
|
let connectionSet = data;
|
let s = '';
|
if (connectionSet) {
|
s = s + '[';
|
for (let i = 0; i < connectionSet.length; i++) {
|
s = s + connectionSet[i].address;
|
if (i < connectionSet.length - 1) {
|
s = s + ', ';
|
}
|
}
|
s = s + ']';
|
} else {
|
s = '[]';
|
}
|
return s;
|
};
|
|
function retrieveClusterServerInfo() {
|
ClusterStateService.fetchClusterServerStateOfApp($scope.app).success(function (data) {
|
if (data.code === 0 && data.data) {
|
$scope.loadError = undefined;
|
$scope.serverVOList = data.data;
|
$scope.serverVOList.forEach(processServerListData);
|
} else {
|
$scope.serverVOList = {};
|
if (data.code === UNSUPPORTED_CODE) {
|
$scope.loadError = {message: '该应用的 Sentinel 客户端不支持集群限流，请升级至 1.4.0 以上版本并引入相关依赖。'}
|
} else {
|
$scope.loadError = {message: data.msg};
|
}
|
}
|
}).error(() => {
|
$scope.loadError = {message: '未知错误'};
|
});
|
}
|
|
retrieveClusterServerInfo();
|
|
let confirmUnbindServerDialog;
|
$scope.unbindServer = (id) => {
|
$scope.pendingUnbindIds = [id];
|
$scope.confirmDialog = {
|
title: '移除 Token Server',
|
type: 'unbind_token_server',
|
attentionTitle: '请确认是否移除以下 Token Server（该 server 下的 client 也会解除分配）',
|
attention: id + '',
|
confirmBtnText: '移除',
|
};
|
confirmUnbindServerDialog = ngDialog.open({
|
template: '/app/views/dialog/confirm-dialog.html',
|
scope: $scope,
|
overlay: true
|
});
|
};
|
|
function apiUnbindServerAssign(ids) {
|
ClusterStateService.applyClusterServerBatchUnbind($scope.app, ids).success((data) => {
|
if (data.code === 0 && data.data) {
|
let failedServerSet = data.data.failedServerSet;
|
let failedClientSet = data.data.failedClientSet;
|
if (failedClientSet.length === 0 && failedServerSet.length === 0) {
|
alert('成功');
|
} else {
|
alert('操作推送完毕，部分失败机器列表：' + JSON.stringify(failedClientSet));
|
}
|
|
location.reload();
|
} else {
|
if (data.code === UNSUPPORTED_CODE) {
|
alert('该应用的 Sentinel 客户端不支持集群限流，请升级至 1.4.0 以上版本并引入相关依赖。');
|
} else {
|
alert('推送失败：' + data.msg);
|
}
|
}
|
}).error(() => {
|
alert('未知错误');
|
});
|
// confirmUnbindServerDialog.close();
|
}
|
|
// Confirm function for confirm dialog.
|
$scope.confirm = () => {
|
if ($scope.confirmDialog.type === 'unbind_token_server') {
|
apiUnbindServerAssign($scope.pendingUnbindIds);
|
} else {
|
console.error('Error dialog when unbinding token server');
|
}
|
};
|
}]);
|
