1934 lines
75 KiB
JavaScript
1934 lines
75 KiB
JavaScript
define(['uiRouter', 'angularTable', 'angularDragDrop', 'angularTouch', 'ngSpinner', 'angularAnimate'], function() {
|
|
var wizardModule = angular.module('compass.wizard', [
|
|
'ui.router',
|
|
'ui.bootstrap',
|
|
'ngTable',
|
|
//'compass.charts',
|
|
//'compass.findservers',
|
|
'ngDragDrop',
|
|
'ngTouch',
|
|
'angularSpinner',
|
|
'ngAnimate'
|
|
]);
|
|
|
|
wizardModule.config(function config($stateProvider) {
|
|
$stateProvider
|
|
.state('wizard', {
|
|
url: '/wizard/{id}?config',
|
|
controller: 'wizardCtrl',
|
|
templateUrl: 'src/app/wizard/wizard.tpl.html',
|
|
authenticate: true,
|
|
resolve: {
|
|
clusterData: function($stateParams, $q, dataService) {
|
|
var clusterId = $stateParams.id;
|
|
var deferred = $q.defer();
|
|
dataService.getClusterById(clusterId).success(function(data) {
|
|
deferred.resolve(data);
|
|
});
|
|
return deferred.promise;
|
|
},
|
|
machinesHostsData: function($q, dataService, clusterData) {
|
|
var deferred = $q.defer();
|
|
dataService.getAllMachineHosts().success(function(data) {
|
|
deferred.resolve(data);
|
|
});
|
|
return deferred.promise;
|
|
},
|
|
wizardStepsData: function($q, dataService) { // get the create-cluster-wizard steps
|
|
var deferred = $q.defer();
|
|
dataService.getWizardSteps().success(function(data) {
|
|
deferred.resolve(data);
|
|
});
|
|
return deferred.promise;
|
|
},
|
|
clusterConfigData: function($stateParams, $q, dataService) {
|
|
var clusterId = $stateParams.id;
|
|
var deferred = $q.defer();
|
|
dataService.getClusterConfig(clusterId).success(function(data) {
|
|
deferred.resolve(data);
|
|
});
|
|
return deferred.promise;
|
|
},
|
|
adaptersData: function($q, dataService) {
|
|
var deferred = $q.defer();
|
|
dataService.getAdapters().success(function(data) {
|
|
deferred.resolve(data);
|
|
});
|
|
return deferred.promise;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
wizardModule.controller('wizardCtrl', function($scope, dataService, wizardFactory, $stateParams, $state, $modal, clusterData, adaptersData, machinesHostsData, wizardStepsData, clusterConfigData) {
|
|
$scope.loading = false;
|
|
$scope.clusterId = $stateParams.id;
|
|
$scope.cluster = clusterData;
|
|
wizardFactory.setClusterInfo($scope.cluster);
|
|
wizardFactory.setAllMachinesHost(machinesHostsData);
|
|
|
|
$scope.adapters = adaptersData;
|
|
|
|
angular.forEach($scope.adapters, function(adapter) {
|
|
if (adapter.id == $scope.cluster.adapter_id) {
|
|
$scope.currentAdapterName = adapter.name;
|
|
}
|
|
});
|
|
|
|
// get pre-config data for wizard and set wizard steps based on different adapters
|
|
var oldConfig = clusterConfigData;
|
|
$scope.steps = [];
|
|
if ($stateParams.config == "true") {
|
|
dataService.getWizardPreConfig().success(function(data) {
|
|
var preConfigData = {};
|
|
switch ($scope.currentAdapterName) {
|
|
case "openstack_icehouse":
|
|
preConfigData = data["openstack"];
|
|
$scope.steps = wizardStepsData["os_and_ts"];
|
|
wizardFactory.setSteps($scope.steps);
|
|
break;
|
|
case "os_only":
|
|
preConfigData = data["os_only"];
|
|
$scope.steps = wizardStepsData["os"];
|
|
wizardFactory.setSteps($scope.steps);
|
|
break;
|
|
case "ceph_openstack_icehouse":
|
|
preConfigData = data["openstack_ceph"];
|
|
$scope.steps = wizardStepsData["os_and_ts"];
|
|
wizardFactory.setSteps($scope.steps);
|
|
break;
|
|
case "ceph_firefly":
|
|
preConfigData = data["ceph_firefly"];
|
|
$scope.steps = wizardStepsData["os_and_ts"];
|
|
wizardFactory.setSteps($scope.steps);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (preConfigData) {
|
|
wizardFactory.preConfig(preConfigData);
|
|
|
|
if (oldConfig.os_config) {
|
|
if (oldConfig.os_config.general) {
|
|
wizardFactory.setGeneralConfig(oldConfig.os_config.general);
|
|
}
|
|
if (oldConfig.os_config.partition) {
|
|
wizardFactory.setPartition(oldConfig.os_config.partition);
|
|
}
|
|
if (oldConfig.os_config.server_credentials) {
|
|
wizardFactory.setServerCredentials(oldConfig.os_config.server_credentials);
|
|
}
|
|
}
|
|
if (oldConfig.package_config) {
|
|
if (oldConfig.package_config.security) {
|
|
if (oldConfig.package_config.security.service_credentials) {
|
|
wizardFactory.setServiceCredentials(oldConfig.package_config.security.service_credentials);
|
|
}
|
|
if (oldConfig.package_config.security.console_credentials) {
|
|
wizardFactory.setConsoleCredentials(oldConfig.package_config.security.console_credentials);
|
|
}
|
|
}
|
|
if (oldConfig.package_config.network_mapping) {
|
|
wizardFactory.setNetworkMapping(oldConfig.package_config.network_mapping);
|
|
}
|
|
if (oldConfig.package_config.ceph_config) {
|
|
wizardFactory.setCephConfig(oldConfig.package_config.ceph_config);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
$scope.$on('loading', function(event, data) {
|
|
$scope.loading = data;
|
|
});
|
|
|
|
$scope.currentStep = 1;
|
|
$scope.maxStep = 1;
|
|
$scope.pendingStep = 1;
|
|
|
|
// Watch commit state change
|
|
$scope.$watch(function() {
|
|
return wizardFactory.getCommitState()
|
|
}, function(newCommitState, oldCommitState) {
|
|
if (newCommitState != oldCommitState && newCommitState.name == $scope.steps[$scope.currentStep - 1].name) {
|
|
if (newCommitState.state == "success") {
|
|
console.warn("### catch success in wizardCtrl ###", newCommitState, oldCommitState);
|
|
if (newCommitState.name == "review") {
|
|
$state.go("cluster.overview", {
|
|
'id': $scope.cluster.id
|
|
});
|
|
}
|
|
$scope.stepControl(goToPreviousStep = false);
|
|
if ($scope.currentStep > $scope.maxStep) {
|
|
$scope.maxStep = $scope.currentStep;
|
|
}
|
|
} else if (newCommitState.state == "invalid") {
|
|
console.warn("### catch invalid in wizardCtrl ###", newCommitState, oldCommitState);
|
|
$scope.openErrMessageModal(newCommitState.message);
|
|
|
|
} else if (newCommitState.state == "goToPreviousStep") {
|
|
$scope.stepControl(goToPreviousStep = true);
|
|
if ($scope.currentStep > $scope.maxStep) {
|
|
$scope.maxStep = $scope.currentStep;
|
|
}
|
|
} else if (newCommitState.state == "error") {
|
|
console.warn("### catch error in wizardCtrl ###", newCommitState, oldCommitState);
|
|
}
|
|
}
|
|
$scope.loading = false;
|
|
});
|
|
|
|
$scope.stepControl = function(goToPrevious) {
|
|
if ($scope.pendingStep <= $scope.maxStep + 1) {
|
|
var previousStepsIncomplete = false;
|
|
for (var i = 0; i < $scope.pendingStep - 1; i++) {
|
|
if ($scope.steps[i].state == "incomplete") {
|
|
previousStepsIncomplete = true;
|
|
break;
|
|
}
|
|
}
|
|
if (previousStepsIncomplete) {
|
|
var message = {
|
|
"message": "Please make sure pre-requisite steps are complete."
|
|
};
|
|
alert(message.message);
|
|
} else {
|
|
$scope.updateStepProgress($scope.pendingStep, $scope.currentStep, goToPrevious);
|
|
$scope.currentStep = $scope.pendingStep;
|
|
}
|
|
} else {
|
|
var message = {
|
|
"message": "Please complete previous steps first"
|
|
};
|
|
alert(message.message);
|
|
$scope.pendingStep = $scope.currentStep;
|
|
}
|
|
}
|
|
|
|
for (var i = 0; i < $scope.steps.length; i++) {
|
|
if ($scope.steps[i].name == 'network') {
|
|
$scope.networkStep = i;
|
|
}
|
|
if ($scope.steps[i].name == 'role_assign') {
|
|
$scope.roleAssignStep = i;
|
|
}
|
|
if ($scope.steps[i].name == 'network_mapping') {
|
|
$scope.networkMappingStep = i;
|
|
}
|
|
}
|
|
|
|
// Updates CSS Classes on Step state change
|
|
$scope.updateStepProgress = function(newStep, oldStep, goToPrevious) {
|
|
$scope.steps[newStep - 1].state = "active";
|
|
|
|
if (goToPrevious) {
|
|
$scope.steps[oldStep - 1].state = "";
|
|
} else {
|
|
$scope.steps[oldStep - 1].state = "complete";
|
|
}
|
|
|
|
$scope.steps[oldStep - 1].state = "complete";
|
|
if ($scope.steps[newStep - 1].name == 'sv_selection') {
|
|
if ($scope.maxStep > $scope.networkStep) {
|
|
$scope.steps[$scope.networkStep].state = "incomplete";
|
|
}
|
|
if ($scope.maxStep > $scope.roleAssignStep) {
|
|
$scope.steps[$scope.roleAssignStep].state = "incomplete";
|
|
}
|
|
if ($scope.maxStep > $scope.networkMappingStep) {
|
|
$scope.steps[$scope.networkMappingStep].state = "incomplete";
|
|
}
|
|
}
|
|
if (newStep == $scope.networkStep + 1) {
|
|
if ($scope.maxStep > $scope.networkMappingStep) {
|
|
$scope.steps[$scope.networkMappingStep].state = "incomplete";
|
|
}
|
|
}
|
|
if (oldStep == $scope.steps.length) {
|
|
$scope.steps[$scope.steps.length - 1].state = "";
|
|
}
|
|
};
|
|
|
|
$scope.triggerCommit = function(stepId, nextStep) {
|
|
var sendRequest = false;
|
|
if (nextStep > stepId) {
|
|
sendRequest = true;
|
|
}
|
|
if ($scope.steps[stepId - 1].name != "review") {
|
|
var commitState = {
|
|
"name": $scope.steps[stepId - 1].name,
|
|
"state": "triggered",
|
|
"sendRequest": sendRequest,
|
|
"message": {}
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
} else {
|
|
$scope.stepControl();
|
|
}
|
|
};
|
|
|
|
$scope.deploy = function() {
|
|
var wizard_complete = true;
|
|
for (var i = 0; i < $scope.steps.length - 1; i++) {
|
|
if ($scope.steps[i].state != "complete") {
|
|
wizard_complete = false;
|
|
break;
|
|
}
|
|
}
|
|
if (wizard_complete) {
|
|
var commitState = {
|
|
"name": "review",
|
|
"state": "triggered",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
}
|
|
};
|
|
|
|
$scope.stepForward = function() {
|
|
$scope.pendingStep = $scope.currentStep + 1;;
|
|
$scope.triggerCommit($scope.currentStep, $scope.pendingStep);
|
|
};
|
|
|
|
// go to previous step
|
|
$scope.stepBackward = function() {
|
|
$scope.pendingStep = $scope.currentStep - 1;
|
|
$scope.triggerCommit($scope.currentStep, $scope.pendingStep);
|
|
};
|
|
|
|
// go to step by stepId
|
|
$scope.skipForward = function(stepId) {
|
|
if ($scope.currentStep != stepId) {
|
|
$scope.pendingStep = stepId;
|
|
$scope.triggerCommit($scope.currentStep, stepId);
|
|
}
|
|
};
|
|
|
|
$scope.openErrMessageModal = function(message) {
|
|
var modalInstance = $modal.open({
|
|
templateUrl: "messagemodal.html",
|
|
controller: wizardModalInstanceCtrl,
|
|
resolve: {
|
|
warning: function() {
|
|
return message;
|
|
}
|
|
}
|
|
});
|
|
modalInstance.result.then(function() {
|
|
|
|
}, function() {
|
|
console.log("modal dismissed")
|
|
})
|
|
};
|
|
|
|
dataService.getSubnetConfig().success(function(data) {
|
|
wizardFactory.setSubnetworks(data);
|
|
});
|
|
});
|
|
|
|
wizardModule.animation('.fade-animation', function() {
|
|
return {
|
|
enter: function(element, done) {
|
|
element.css('display', 'none');
|
|
element.fadeIn(500, done);
|
|
return function() {
|
|
element.stop();
|
|
}
|
|
},
|
|
leave: function(element, done) {
|
|
element.fadeOut(500, done)
|
|
return function() {
|
|
element.stop();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
wizardModule.controller('svSelectCtrl', function($scope, wizardFactory, dataService, $filter, ngTableParams, sortingService) {
|
|
$scope.hideunselected = '';
|
|
$scope.search = {};
|
|
|
|
var cluster = wizardFactory.getClusterInfo();
|
|
|
|
$scope.allservers = wizardFactory.getAllMachinesHost();
|
|
|
|
$scope.tableParams = new ngTableParams({
|
|
page: 1, // show first page
|
|
count: $scope.allservers.length // count per page
|
|
}, {
|
|
counts: [], // hide count-per-page box
|
|
total: $scope.allservers.length, // length of data
|
|
getData: function($defer, params) {
|
|
var reverse = false;
|
|
var orderBy = params.orderBy()[0];
|
|
var orderBySort = "";
|
|
var orderByColumn = "";
|
|
|
|
if (orderBy) {
|
|
orderByColumn = orderBy.substring(1);
|
|
orderBySort = orderBy.substring(0, 1);
|
|
if (orderBySort == "+") {
|
|
reverse = false;
|
|
} else {
|
|
reverse = true;
|
|
}
|
|
}
|
|
|
|
var orderedData = params.sorting() ?
|
|
$filter('orderBy')($scope.allservers, function(item) {
|
|
if (orderByColumn == "switch_ip") {
|
|
return sortingService.ipAddressPre(item.switch_ip);
|
|
} else {
|
|
return item[orderByColumn];
|
|
}
|
|
}, reverse) : $scope.allservers;
|
|
|
|
$defer.resolve(orderedData.slice((params.page() - 1) * params.count(), params.page() * params.count()));
|
|
}
|
|
});
|
|
|
|
|
|
$scope.selectAllServers = function(flag) {
|
|
if (flag) {
|
|
angular.forEach($scope.allservers, function(sv) {
|
|
if (!sv.disabled) {
|
|
sv.selected = true;
|
|
}
|
|
})
|
|
} else {
|
|
angular.forEach($scope.allservers, function(sv) {
|
|
sv.selected = false;
|
|
})
|
|
}
|
|
};
|
|
|
|
dataService.getServerColumns().success(function(data) {
|
|
$scope.server_columns = data.showall;
|
|
});
|
|
|
|
$scope.hideUnselected = function() {
|
|
if ($scope.hideunselected) {
|
|
$scope.search.selected = true;
|
|
} else {
|
|
delete $scope.search.selected;
|
|
}
|
|
};
|
|
|
|
$scope.ifPreSelect = function(server) {
|
|
server.disabled = false;
|
|
if (server.clusters) {
|
|
if (server.clusters.length > 0) {
|
|
server.disabled = true;
|
|
}
|
|
angular.forEach(server.clusters, function(svCluster) {
|
|
if (svCluster.id == cluster.id) {
|
|
server.selected = true;
|
|
server.disabled = false;
|
|
}
|
|
})
|
|
}
|
|
};
|
|
|
|
$scope.$watch(function() {
|
|
return wizardFactory.getCommitState()
|
|
}, function(newCommitState, oldCommitState) {
|
|
if (newCommitState !== undefined) {
|
|
if (newCommitState.name == "sv_selection" && newCommitState.state == "triggered") {
|
|
$scope.commit();
|
|
}
|
|
}
|
|
});
|
|
|
|
$scope.commit = function() {
|
|
$scope.$emit("loading", true);
|
|
var selectedServers = [];
|
|
var noSelection = true;
|
|
angular.forEach($scope.allservers, function(sv) {
|
|
if (sv.selected) {
|
|
noSelection = false;
|
|
selectedServers.push(sv);
|
|
}
|
|
})
|
|
if (noSelection) {
|
|
var message = {
|
|
"message": "Please select at least one server"
|
|
};
|
|
var commitState = {
|
|
"name": "sv_selection",
|
|
"state": "invalid",
|
|
"message": message
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
} else {
|
|
var addHostsAction = {
|
|
"add_hosts": {
|
|
"machines": []
|
|
}
|
|
};
|
|
angular.forEach($scope.allservers, function(server) {
|
|
if (server.selected) {
|
|
if (server.reinstallos === undefined) {
|
|
addHostsAction.add_hosts.machines.push({
|
|
"machine_id": server.machine_id
|
|
});
|
|
} else {
|
|
addHostsAction.add_hosts.machines.push({
|
|
"machine_id": server.machine_id,
|
|
"reinstall_os": server.reinstallos
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
// add hosts
|
|
dataService.postClusterActions(cluster.id, addHostsAction).success(function(data) {
|
|
var commitState = {
|
|
"name": "sv_selection",
|
|
"state": "success",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
wizardFactory.setAllMachinesHost($scope.allservers);
|
|
|
|
}).error(function(response) {
|
|
var commitState = {
|
|
"name": "sv_selection",
|
|
"state": "error",
|
|
"message": response
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
});
|
|
wizardFactory.setServers(selectedServers);
|
|
}
|
|
};
|
|
|
|
// add newly found servers at the top if allservers array
|
|
$scope.$watch('foundResults', function(newResults, oldResults) {
|
|
if (newResults != oldResults) {
|
|
for (var i = 0; i < newResults.length; i++) {
|
|
var sv = $filter('filter')($scope.allservers, newResults[i].mac, true);
|
|
if (sv.length == 0) {
|
|
newResults[i].machine_id = newResults[i].id;
|
|
delete newResults[i]['id'];
|
|
newResults[i].new = true;
|
|
$scope.allservers.unshift(newResults[i]);
|
|
}
|
|
}
|
|
|
|
if ($scope.tableParams) {
|
|
$scope.tableParams.$params.count = $scope.allservers.length;
|
|
$scope.tableParams.reload();
|
|
}
|
|
}
|
|
}, true);
|
|
|
|
});
|
|
|
|
wizardModule.controller('globalCtrl', function($scope, wizardFactory, dataService, $q) {
|
|
var cluster = wizardFactory.getClusterInfo();
|
|
|
|
$scope.general = wizardFactory.getGeneralConfig();
|
|
$scope.server_credentials = wizardFactory.getServerCredentials();
|
|
|
|
if (!$scope.general["dns_servers"]) {
|
|
$scope.general["dns_servers"] = [""];
|
|
}
|
|
if (!$scope.general["search_path"]) {
|
|
$scope.general["search_path"] = [""];
|
|
}
|
|
if (!$scope.general["no_proxy"]) {
|
|
$scope.general["no_proxy"] = [""];
|
|
}
|
|
|
|
$scope.addValue = function(key) {
|
|
$scope.general[key].push("");
|
|
};
|
|
|
|
dataService.getTimezones().success(function(data) {
|
|
$scope.timezones = data;
|
|
});
|
|
|
|
//For Routing Table Section
|
|
//keep routing table for later use
|
|
/*
|
|
$scope.routingtable = wizardFactory.getRoutingTable();
|
|
$scope.addRoute = function() {
|
|
$scope.routingtable.push({});
|
|
console.log($scope.routingtable);
|
|
};
|
|
$scope.removeRoute = function(index) {
|
|
$scope.routingtable.splice(index, 1)
|
|
};
|
|
$scope.$watch('routingtable', function() {
|
|
if ($scope.routingtable.length == 0) {
|
|
$scope.routingtable.push({});
|
|
}
|
|
}, true);
|
|
*/
|
|
|
|
$scope.$watch(function() {
|
|
return wizardFactory.getCommitState()
|
|
}, function(newCommitState, oldCommitState) {
|
|
|
|
if (newCommitState !== undefined) {
|
|
if (newCommitState.name == "os_global" && newCommitState.state == "triggered") {
|
|
$scope.commit(newCommitState.sendRequest);
|
|
}
|
|
}
|
|
});
|
|
|
|
$scope.commit = function(sendRequest) {
|
|
if (!sendRequest) {
|
|
var commitState = {
|
|
"name": "os_global",
|
|
"state": "goToPreviousStep",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
return;
|
|
}
|
|
$scope.$emit("loading", true);
|
|
var osGlobalConfig = {
|
|
"os_config": {
|
|
"general": $scope.general,
|
|
"server_credentials": {
|
|
"username": $scope.server_credentials.username,
|
|
"password": $scope.server_credentials.password
|
|
}
|
|
}
|
|
};
|
|
if ($scope.generalForm.$valid) {
|
|
dataService.updateClusterConfig(cluster.id, osGlobalConfig).success(function(configData) {
|
|
wizardFactory.setGeneralConfig($scope.general);
|
|
var commitState = {
|
|
"name": "os_global",
|
|
"state": "success",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
}).error(function(response) {
|
|
var commitState = {
|
|
"name": "os_global",
|
|
"state": "error",
|
|
"message": response
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
});
|
|
} else {
|
|
var message = {};
|
|
if ($scope.generalForm.$error.required) {
|
|
message = {
|
|
"message": "The required(*) fields can not be empty !"
|
|
};
|
|
} else if ($scope.generalForm.$error.match) {
|
|
message = {
|
|
"message": "The passwords do not match"
|
|
};
|
|
}
|
|
var commitState = {
|
|
"name": "os_global",
|
|
"state": "invalid",
|
|
"message": message
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
}
|
|
};
|
|
|
|
|
|
// keey routing table for later use
|
|
/*
|
|
$scope.updateRoutingTable = function() {
|
|
var routingCount = $scope.routingtable.length;
|
|
var routingTable = [];
|
|
var i = 0;
|
|
angular.forEach($scope.routingtable, function(rt) {
|
|
if (rt.id === undefined) {
|
|
// post routing table
|
|
dataService.postRoutingTable(cluster.id, rt).success(function(routingData) {
|
|
routingTable.push(routingData);
|
|
i++;
|
|
if (i == routingCount) {
|
|
$scope.routingtable = routingTable;
|
|
wizardFactory.setRoutingTable(routingTable);
|
|
}
|
|
})
|
|
} else {
|
|
// put routing table
|
|
dataService.putRoutingTable(cluster.id, rt.id, rt).success(function(routingData) {
|
|
routingTable.push(routingData);
|
|
i++;
|
|
if (i == routingCount) {
|
|
$scope.routingtable = routingTable;
|
|
wizardFactory.setRoutingTable(routingTable);
|
|
}
|
|
})
|
|
}
|
|
})
|
|
};
|
|
*/
|
|
});
|
|
|
|
wizardModule.controller('networkCtrl', function($scope, $timeout, wizardFactory, dataService, $filter, ngTableParams, sortingService, $q, $modal) {
|
|
var cluster = wizardFactory.getClusterInfo();
|
|
$scope.subnetworks = wizardFactory.getSubnetworks();
|
|
$scope.interfaces = wizardFactory.getInterfaces();
|
|
$scope.autoFill = false;
|
|
$scope.autoFillButtonDisplay = "Enable Autofill";
|
|
//$scope.servers = wizardFactory.getServers();
|
|
$scope.autoFillMange = function() {
|
|
$scope.autoFill = !$scope.autoFill;
|
|
if ($scope.autoFill) {
|
|
$scope.autoFillButtonDisplay = "Disable Autofill";
|
|
} else {
|
|
$scope.autoFillButtonDisplay = "Enable Autofill";
|
|
}
|
|
};
|
|
|
|
dataService.getServerColumns().success(function(data) {
|
|
$scope.server_columns = data.showless;
|
|
});
|
|
|
|
dataService.getClusterHosts(cluster.id).success(function(data) {
|
|
$scope.servers = data;
|
|
|
|
// Assume all hosts in the same cluster have same interface settings
|
|
if ($scope.servers[0].networks) {
|
|
if (Object.keys($scope.servers[0].networks).length != 0) {
|
|
$scope.interfaces = $scope.servers[0].networks;
|
|
wizardFactory.setInterfaces($scope.interfaces);
|
|
}
|
|
}
|
|
|
|
$scope.tableParams = new ngTableParams({
|
|
page: 1, // show first page
|
|
count: $scope.servers.length + 1 // count per page
|
|
}, {
|
|
counts: [], // hide count-per-page box
|
|
total: $scope.servers.length, // length of data
|
|
getData: function($defer, params) {
|
|
var reverse = false;
|
|
var orderBy = params.orderBy()[0];
|
|
var orderBySort = "";
|
|
var orderByColumn = "";
|
|
|
|
if (orderBy) {
|
|
orderByColumn = orderBy.substring(1);
|
|
orderBySort = orderBy.substring(0, 1);
|
|
if (orderBySort == "+") {
|
|
reverse = false;
|
|
} else {
|
|
reverse = true;
|
|
}
|
|
}
|
|
|
|
var orderedData = params.sorting() ?
|
|
$filter('orderBy')($scope.servers, function(item) {
|
|
if (orderByColumn == "switch_ip") {
|
|
return sortingService.ipAddressPre(item.switch_ip);
|
|
} else {
|
|
return item[orderByColumn];
|
|
}
|
|
}, reverse) : $scope.servers;
|
|
$scope.servers = orderedData;
|
|
|
|
$defer.resolve(orderedData.slice((params.page() - 1) * params.count(), params.page() * params.count()));
|
|
}
|
|
});
|
|
});
|
|
|
|
$scope.addInterface = function(newInterface) {
|
|
var isExist = false;
|
|
if (newInterface) {
|
|
angular.forEach($scope.interfaces, function(value, key) {
|
|
if (key == newInterface.name) {
|
|
isExist = true;
|
|
alert("This interface already exists. Please try another one");
|
|
}
|
|
})
|
|
if (!isExist) {
|
|
$scope.interfaces[newInterface.name] = {
|
|
"subnet_id": parseInt(newInterface.subnet_id),
|
|
"is_mgmt": false
|
|
}
|
|
}
|
|
$scope.newInterface = {};
|
|
}
|
|
};
|
|
|
|
$scope.deleteInterface = function(delInterface) {
|
|
delete $scope.interfaces[delInterface];
|
|
angular.forEach($scope.servers, function(sv) {
|
|
delete sv.networks[delInterface];
|
|
})
|
|
};
|
|
|
|
$scope.$watch(function() {
|
|
return wizardFactory.getCommitState()
|
|
}, function(newCommitState, oldCommitState) {
|
|
if (newCommitState !== undefined) {
|
|
if (newCommitState.name == "network" && newCommitState.state == "triggered") {
|
|
$scope.commit(newCommitState.sendRequest);
|
|
}
|
|
}
|
|
});
|
|
|
|
$scope.commit = function(sendRequest) {
|
|
if (!sendRequest) {
|
|
var commitState = {
|
|
"name": "network",
|
|
"state": "goToPreviousStep",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
return;
|
|
}
|
|
$scope.$emit("loading", true);
|
|
wizardFactory.setInterfaces($scope.interfaces);
|
|
|
|
|
|
var interfaceCount = Object.keys($scope.interfaces).length;
|
|
if (interfaceCount == 0) {
|
|
alert("Please add interface");
|
|
} else {
|
|
var hostnamePromises = [];
|
|
var hostNetworkPromises = [];
|
|
|
|
angular.forEach($scope.servers, function(server) {
|
|
var hostname = {
|
|
"name": server["hostname"]
|
|
};
|
|
// update hostname
|
|
var updateHostname = dataService.putHost(server.id, hostname).then(function(hostData) {
|
|
// success callback
|
|
}, function(response) {
|
|
// error callback
|
|
return $q.reject(response);
|
|
});
|
|
hostnamePromises.push(updateHostname);
|
|
|
|
angular.forEach(server.networks, function(value, key) {
|
|
var network = {
|
|
"interface": key,
|
|
"ip": value.ip,
|
|
"subnet_id": parseInt($scope.interfaces[key].subnet_id),
|
|
"is_mgmt": $scope.interfaces[key].is_mgmt,
|
|
"is_promiscuous": $scope.interfaces[key].is_promiscuous
|
|
};
|
|
if (value.id === undefined) {
|
|
// post host network
|
|
var updateNetwork = dataService.postHostNetwork(server.id, network).then(function(networkData) {
|
|
// success callback
|
|
var interface = networkData.data.interface;
|
|
var networkId = networkData.data.id;
|
|
server.networks[interface].id = networkId;
|
|
}, function(response) {
|
|
// error callback
|
|
return $q.reject(response);
|
|
// keep this part for later use
|
|
/*
|
|
if(response.status == 409) { // if (host_id, interface) already exists
|
|
var updateNetwork = dataService.putHostNetwork(server.id, value.id, network).then(function(networkData) {
|
|
// success callback
|
|
}, function(response) {
|
|
// error callback
|
|
return $q.reject(response);
|
|
});
|
|
hostNetworkPromises.push(updateNetwork);
|
|
}
|
|
*/
|
|
});
|
|
hostNetworkPromises.push(updateNetwork);
|
|
} else {
|
|
// put host network
|
|
var updateNetwork = dataService.putHostNetwork(server.id, value.id, network).then(function(networkData) {
|
|
// success callback
|
|
}, function(response) {
|
|
// error callback
|
|
return $q.reject(response);
|
|
});
|
|
hostNetworkPromises.push(updateNetwork);
|
|
}
|
|
});
|
|
});
|
|
|
|
$q.all(hostnamePromises.concat(hostNetworkPromises)).then(function() {
|
|
// update hostname and network for all hosts successfully
|
|
wizardFactory.setServers($scope.servers);
|
|
var commitState = {
|
|
"name": "network",
|
|
"state": "success",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
}, function(response) {
|
|
wizardFactory.setServers($scope.servers);
|
|
var commitState = {
|
|
"name": "network",
|
|
"state": "error",
|
|
"message": response.data
|
|
};
|
|
console.info(response.data);
|
|
wizardFactory.setCommitState(commitState);
|
|
});
|
|
|
|
}
|
|
};
|
|
|
|
$scope.openAddSubnetModal = function() {
|
|
var modalInstance = $modal.open({
|
|
templateUrl: "addSubnetModal.html",
|
|
controller: addSubnetModalInstanceCtrl,
|
|
resolve: {
|
|
subnets: function() {
|
|
return $scope.subnetworks;
|
|
}
|
|
}
|
|
});
|
|
modalInstance.result.then(function(subnets) {
|
|
$scope.subnetworks = [];
|
|
angular.forEach(subnets, function(subnet) {
|
|
$scope.subnetworks.push(subnet);
|
|
});
|
|
wizardFactory.setSubnetworks($scope.subnetworks);
|
|
}, function() {
|
|
console.log("modal dismissed")
|
|
})
|
|
};
|
|
|
|
|
|
$scope.autofill = function(alertFade) {
|
|
// Autofill IP for each interface
|
|
angular.forEach($scope.interfaces, function(value, key) {
|
|
var ip_start = $("#" + key + "-ipstart").val();
|
|
var interval = parseInt($("#" + key + "-increase-num").val());
|
|
$scope.fillIPBySequence(ip_start, interval, key);
|
|
});
|
|
// Autofill hostname
|
|
var hostname_rule = $("#hostname-rule").val();
|
|
$scope.fillHostname(hostname_rule);
|
|
$scope.networkAlerts = [{
|
|
msg: 'Autofill Done!'
|
|
}];
|
|
if (alertFade) {
|
|
$timeout(function() {
|
|
$scope.networkAlerts = [];
|
|
}, alertFade);
|
|
}
|
|
};
|
|
|
|
$scope.fillHostname = function(rule) {
|
|
if (rule) {
|
|
switch (rule) {
|
|
case "host":
|
|
var server_index = 1;
|
|
angular.forEach($scope.servers, function(server) {
|
|
server.hostname = "host-" + server_index;
|
|
server_index++;
|
|
})
|
|
break;
|
|
case "switch_ip":
|
|
angular.forEach($scope.servers, function(server) {
|
|
server.hostname = server.switch_ip.replace(/\./g, "-") + "-p" + server.port;
|
|
})
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
$scope.fillIPBySequence = function(ipStart, interval, interface) {
|
|
if (ipStart == "")
|
|
return;
|
|
var ipStartParts = ipStart.split(".");
|
|
var ipParts = ipStartParts.map(function(x) {
|
|
return parseInt(x);
|
|
});
|
|
|
|
angular.forEach($scope.servers, function(server) {
|
|
if (ipParts[3] > 255) {
|
|
ipParts[3] = ipParts[3] - 256;
|
|
ipParts[2] ++;
|
|
}
|
|
if (ipParts[2] > 255) {
|
|
ipParts[2] = ipParts[2] - 256;
|
|
ipParts[1] ++;
|
|
}
|
|
if (ipParts[1] > 255) {
|
|
ipParts[1] = ipParts[1] - 256;
|
|
ipParts[0] ++;
|
|
}
|
|
if (ipParts[0] > 255) {
|
|
server.networks[interface].ip = "";
|
|
return;
|
|
} else {
|
|
var ip = ipParts[0] + "." + ipParts[1] + "." + ipParts[2] + "." + ipParts[3]
|
|
server.networks[interface].ip = ip;
|
|
ipParts[3] = ipParts[3] + interval;
|
|
}
|
|
})
|
|
}
|
|
});
|
|
|
|
wizardModule.controller('partitionCtrl', function($scope, wizardFactory, dataService) {
|
|
var cluster = wizardFactory.getClusterInfo();
|
|
$scope.partition = wizardFactory.getPartition();
|
|
$scope.partitionInforArray = [];
|
|
$scope.duplicated = false;
|
|
$scope.duplicatedIndexArray = [];
|
|
|
|
angular.forEach($scope.partition, function(value, key) {
|
|
$scope.partitionInforArray.push({
|
|
"name": key,
|
|
"percentage": value.percentage,
|
|
"max_size": value.max_size
|
|
});
|
|
});
|
|
|
|
|
|
/*$scope.addPartition = function() {
|
|
var mount_point = $scope.newPartition.mount_point;
|
|
$scope.partition[mount_point] = {};
|
|
$scope.partition[mount_point].percentage = $scope.newPartition.percentage;
|
|
$scope.partition[mount_point].max_size = $scope.newPartition.max_size;
|
|
$scope.newPartition = {};
|
|
};*/
|
|
|
|
$scope.addPartition = function() {
|
|
var newRowExist = false;
|
|
angular.forEach($scope.partitionInforArray, function(partitionInfo) {
|
|
if (partitionInfo.name == "") {
|
|
newRowExist = true;
|
|
}
|
|
|
|
});
|
|
if (newRowExist == false && $scope.duplicated == false) {
|
|
$scope.partitionInforArray.push({
|
|
"name": "",
|
|
"percentage": 0,
|
|
"max_size": 0
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
$scope.deletePartition = function(index) {
|
|
var emptyRowIndex = -1; // no empty row
|
|
if ($scope.partitionInforArray.length <= 2) {
|
|
if ($scope.partitionInforArray[0]['name'] == "") {
|
|
emptyRowIndex = 0;
|
|
} else if ($scope.partitionInforArray[1]['name'] == "") {
|
|
emptyRowIndex = 1;
|
|
}
|
|
|
|
if (emptyRowIndex == index || emptyRowIndex == -1) {
|
|
$scope.partitionInforArray.splice(index, 1);
|
|
}
|
|
|
|
} else {
|
|
$scope.partitionInforArray.splice(index, 1);
|
|
}
|
|
if ($scope.duplicatedIndexArray.indexOf(index) >= 0) {
|
|
$scope.duplicated = false;
|
|
|
|
}
|
|
};
|
|
|
|
$scope.$watch('partitionInforArray', function() {
|
|
$scope.partitionarray = [];
|
|
var total = 0;
|
|
angular.forEach($scope.partitionInforArray, function(partitionInfo) {
|
|
total += parseFloat(partitionInfo.percentage);
|
|
$scope.partitionarray.push({
|
|
"name": partitionInfo.name,
|
|
"number": partitionInfo.percentage
|
|
});
|
|
});
|
|
$scope.partitionarray.push({
|
|
"name": "others",
|
|
"number": 100 - total
|
|
})
|
|
}, true);
|
|
|
|
$scope.mount_point_change = function(index, name) {
|
|
var duplicatedIndexContainer = [];
|
|
$scope.duplicatedIndexArray = [];
|
|
var count = 0;
|
|
$scope.duplicated = false;
|
|
var numberOfNames = 0;
|
|
angular.forEach($scope.partitionInforArray, function(partitionInfo) {
|
|
|
|
if (partitionInfo.name == name) {
|
|
numberOfNames++;
|
|
duplicatedIndexContainer.push(count);
|
|
}
|
|
count++;
|
|
});
|
|
if (numberOfNames > 1) {
|
|
$scope.duplicated = true;
|
|
$scope.duplicatedIndexArray = angular.copy(duplicatedIndexContainer);
|
|
}
|
|
}
|
|
|
|
$scope.$watch(function() {
|
|
return wizardFactory.getCommitState()
|
|
}, function(newCommitState, oldCommitState) {
|
|
if (newCommitState !== undefined) {
|
|
if (newCommitState.name == "partition" && newCommitState.state == "triggered") {
|
|
$scope.commit(newCommitState.sendRequest);
|
|
}
|
|
}
|
|
});
|
|
|
|
$scope.commit = function(sendRequest) {
|
|
if (!sendRequest) {
|
|
var commitState = {
|
|
"name": "partition",
|
|
"state": "goToPreviousStep",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
return;
|
|
}
|
|
$scope.$emit("loading", true);
|
|
if ($scope.duplicated == true) {
|
|
var message = {
|
|
"message": "Mount Point cannot be the same"
|
|
}
|
|
var commitState = {
|
|
"name": "partition",
|
|
"state": "invalid",
|
|
"message": message
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
|
|
} else {
|
|
var newPartition = {};
|
|
var data = {};
|
|
angular.forEach($scope.partitionInforArray, function(partitionInfo) {
|
|
newPartition[partitionInfo['name']] = {};
|
|
newPartition[partitionInfo['name']]['percentage'] = partitionInfo['percentage'];
|
|
newPartition[partitionInfo['name']]['max_size'] = partitionInfo['max_size'];
|
|
});
|
|
$scope.partition = angular.copy(newPartition);
|
|
var os_partition = {
|
|
"os_config": {
|
|
"partition": $scope.partition
|
|
}
|
|
};
|
|
|
|
dataService.updateClusterConfig(cluster.id, os_partition).success(function(configData) {
|
|
wizardFactory.setPartition(configData["os_config"]["partition"]);
|
|
var commitState = {
|
|
"name": "partition",
|
|
"state": "success",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
}).error(function(response) {
|
|
var commitState = {
|
|
"name": "partition",
|
|
"state": "error",
|
|
"message": response
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
});
|
|
}
|
|
};
|
|
});
|
|
|
|
wizardModule.controller('packageConfigCtrl', function($scope, wizardFactory, dataService) {
|
|
var cluster = wizardFactory.getClusterInfo();
|
|
$scope.service_credentials = wizardFactory.getServiceCredentials();
|
|
$scope.console_credentials = wizardFactory.getConsoleCredentials();
|
|
|
|
$scope.mSave = function() {
|
|
$scope.originalMangementData = angular.copy($scope.console_credentials);
|
|
}
|
|
$scope.sSave = function() {
|
|
$scope.originalServiceData = angular.copy($scope.service_credentials);
|
|
}
|
|
|
|
$scope.mSave();
|
|
$scope.sSave();
|
|
|
|
var keyLength_service_credentials = Object.keys($scope.service_credentials).length;
|
|
$scope.editServiceMode = [];
|
|
$scope.editServiceMode.length = keyLength_service_credentials;
|
|
|
|
var keyLength_console_credentials = Object.keys($scope.console_credentials).length;
|
|
$scope.editMgntMode = [];
|
|
$scope.editMgntMode.length = keyLength_console_credentials;
|
|
|
|
$scope.$watch(function() {
|
|
return wizardFactory.getCommitState()
|
|
}, function(newCommitState, oldCommitState) {
|
|
if (newCommitState !== undefined) {
|
|
if (newCommitState.name == "package_config" && newCommitState.state == "triggered") {
|
|
$scope.commit(newCommitState.sendRequest);
|
|
}
|
|
}
|
|
});
|
|
|
|
$scope.mgmtAccordion = {};
|
|
|
|
$scope.$watch('mgmtAccordion', function(val) {
|
|
if ($scope.mgmtAccordion.open == true) {
|
|
$scope.mSave();
|
|
} else if ($scope.mgmtAccordion.open == false) {
|
|
$scope.mReset();
|
|
$scope.mcloseAll();
|
|
}
|
|
}, true)
|
|
|
|
$scope.mcloseAll = function() {
|
|
for (var i = 0; i < $scope.editMgntMode.length; i++) {
|
|
if ($scope.editMgntMode[i] == true) {
|
|
$scope.editMgntMode[i] = false;
|
|
} else {}
|
|
}
|
|
}
|
|
|
|
$scope.mEdit = function(index) {
|
|
for (var i = 0; i < $scope.editMgntMode.length; i++) {
|
|
if (i != index) {
|
|
$scope.editMgntMode[i] = false;
|
|
} else {
|
|
$scope.editMgntMode[i] = true;
|
|
}
|
|
}
|
|
$scope.mReset();
|
|
}
|
|
|
|
$scope.mReset = function() {
|
|
$scope.console_credentials = angular.copy($scope.originalMangementData);
|
|
}
|
|
|
|
// Service Credentials
|
|
$scope.serviceAccordion = {};
|
|
|
|
$scope.$watch('serviceAccordion', function(val) {
|
|
if ($scope.serviceAccordion.open == true) {
|
|
$scope.sSave();
|
|
} else if ($scope.serviceAccordion.open == false) {
|
|
$scope.sReset();
|
|
$scope.scloseAll();
|
|
}
|
|
}, true)
|
|
|
|
$scope.scloseAll = function() {
|
|
for (var i = 0; i < $scope.editServiceMode.length; i++) {
|
|
if ($scope.editServiceMode[i] == true) {
|
|
$scope.editServiceMode[i] = false;
|
|
} else {}
|
|
}
|
|
}
|
|
|
|
$scope.sEdit = function(index) {
|
|
for (var i = 0; i < $scope.editServiceMode.length; i++) {
|
|
if (i != index) {
|
|
$scope.editServiceMode[i] = false;
|
|
} else {
|
|
$scope.editServiceMode[i] = true;
|
|
}
|
|
}
|
|
$scope.sReset();
|
|
}
|
|
|
|
$scope.sReset = function() {
|
|
$scope.service_credentials = angular.copy($scope.originalServiceData);
|
|
}
|
|
|
|
// Ceph Config
|
|
$scope.cephAccordion = {};
|
|
/*$scope.cephConfig = {
|
|
"global_config": {},
|
|
"osd_config": {},
|
|
"osd_devices": {}
|
|
};*/
|
|
$scope.cephConfig = wizardFactory.getCephConfig();
|
|
|
|
$scope.commit = function(sendRequest) {
|
|
if (!sendRequest) {
|
|
var commitState = {
|
|
"name": "package_config",
|
|
"state": "goToPreviousStep",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
return;
|
|
}
|
|
$scope.$emit("loading", true);
|
|
var targetSysConfigData = {
|
|
"package_config": {
|
|
"security": {
|
|
"service_credentials": $scope.service_credentials,
|
|
"console_credentials": $scope.console_credentials
|
|
}
|
|
}
|
|
};
|
|
if ($scope.currentAdapterName == "ceph_openstack_icehouse") {
|
|
targetSysConfigData["package_config"]["ceph_config"] = $scope.cephConfig;
|
|
}
|
|
if ($scope.currentAdapterName == "ceph_firefly") {
|
|
targetSysConfigData["package_config"]={};
|
|
targetSysConfigData["package_config"]["ceph_config"] = $scope.cephConfig;
|
|
}
|
|
dataService.updateClusterConfig(cluster.id, targetSysConfigData).success(function(data) {
|
|
var commitState = {
|
|
"name": "package_config",
|
|
"state": "success",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
}).error(function(response) {
|
|
var commitState = {
|
|
"name": "package_config",
|
|
"state": "error",
|
|
"message": response
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
});
|
|
};
|
|
});
|
|
|
|
wizardModule.controller('roleAssignCtrl', function($scope, wizardFactory, dataService, $filter, ngTableParams, sortingService, $q) {
|
|
var cluster = wizardFactory.getClusterInfo();
|
|
$scope.servers = wizardFactory.getServers();
|
|
//var colors = ['#8EA16C', '#C2CF30', '#FEC700', '#FF8900', '#D3432B', '#BB2952', '#8E1E5F', '#DE4AB6', '#9900EC', '#3A1AA8', '#3932FE', '#278BC0', '#35B9F6', '#91E0CB', '#42BC6A', '#5B4141'];
|
|
var colors = ['#a4ebc6', '#cbe375', '#f5d185', '#ee9f97', '#de8ea8', '#8a8ae7', '#85c9fc', '#ffdc4d', '#f2af58', '#f1a3d7', '#e0a9f8', '#88e8db', '#7dc9df', '#bfbfbf', '#bece91', '#84efa7'];
|
|
|
|
$scope.existingRoles = [];
|
|
$scope.realRole = [];
|
|
|
|
dataService.getServerColumns().success(function(data) {
|
|
$scope.server_columns = data.showless;
|
|
});
|
|
|
|
dataService.getClusterById(cluster.id).success(function(data) {
|
|
// wizardFactory.setAdapter(data);
|
|
$scope.roles = data.flavor.roles;
|
|
angular.forEach($scope.roles, function(role, role_key) {
|
|
role.color = colors[role_key];
|
|
$scope.roles[role_key].dragChannel = role_key;
|
|
$scope.realRole.push(role_key);
|
|
});
|
|
angular.forEach($scope.servers, function(value, key) {
|
|
$scope.existingRoles.push(angular.copy($scope.realRole));
|
|
$scope.servers[key].dropChannel = $scope.existingRoles[key].toString();
|
|
angular.forEach($scope.servers[key].roles, function(server_role, server_role_key) {
|
|
$scope.server_role = "";
|
|
angular.forEach($scope.roles, function(role, role_key) {
|
|
if (server_role.name == $scope.roles[role_key].name) {
|
|
$scope.server_role = role_key;
|
|
}
|
|
});
|
|
server_role.color = colors[$scope.server_role];
|
|
});
|
|
});
|
|
$scope.checkExistRolesDrag();
|
|
});
|
|
|
|
$scope.selectAllServers = function(flag) {
|
|
if (flag) {
|
|
angular.forEach($scope.servers, function(sv) {
|
|
sv.checked = true;
|
|
});
|
|
} else {
|
|
angular.forEach($scope.servers, function(sv) {
|
|
sv.checked = false;
|
|
});
|
|
}
|
|
};
|
|
|
|
$scope.removeRole = function(server, role) {
|
|
var serverIndex = $scope.servers.indexOf(server);
|
|
var roleIndex = $scope.servers[serverIndex].roles.indexOf(role);
|
|
$scope.servers[serverIndex].roles.splice(roleIndex, 1);
|
|
angular.forEach($scope.roles, function(role_value, role_key) {
|
|
if (role.name == $scope.roles[role_key].name) {
|
|
$scope.existingRoles[serverIndex].splice(role_key, 1, role_key)
|
|
}
|
|
});
|
|
$scope.servers[serverIndex].dropChannel = $scope.existingRoles[serverIndex].toString();
|
|
};
|
|
|
|
$scope.assignRole = function(role) {
|
|
var serverChecked = false;
|
|
for (var i = 0; i < $scope.servers.length; i++) {
|
|
if ($scope.servers[i].checked) {
|
|
serverChecked = true;
|
|
}
|
|
}
|
|
if (!serverChecked) {
|
|
alert("Please select at least one server");
|
|
} else {
|
|
// get selected servers and assign role to them
|
|
for (var i = 0; i < $scope.servers.length; i++) {
|
|
if ($scope.servers[i].checked) {
|
|
var roleExist = $scope.checkRoleExist($scope.servers[i].roles, role);
|
|
if (!roleExist) {
|
|
$scope.servers[i].roles.push(role);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// Assume all servers have not been assigned any roles before calling this function
|
|
$scope.autoAssignRoles = function() {
|
|
var roles = angular.copy($scope.roles);
|
|
var svIndex = 0;
|
|
angular.forEach(roles, function(newrole) {
|
|
var i = 0;
|
|
var loopStep = 0;
|
|
while (i < newrole.count && loopStep < $scope.servers.length) {
|
|
if (svIndex >= $scope.servers.length) {
|
|
svIndex = 0;
|
|
}
|
|
var roleExist = $scope.checkRoleExist($scope.servers[svIndex].roles, newrole);
|
|
if (!roleExist) {
|
|
$scope.servers[svIndex].roles.push(newrole);
|
|
i++;
|
|
loopStep = 0;
|
|
} else {
|
|
loopStep++;
|
|
}
|
|
svIndex++;
|
|
}
|
|
});
|
|
};
|
|
|
|
$scope.checkRoleExist = function(existingRoles, newRole) {
|
|
var roleExist = false;
|
|
angular.forEach(existingRoles, function(existingRole) {
|
|
if (existingRole.name == newRole.name) {
|
|
roleExist = true;
|
|
}
|
|
})
|
|
return roleExist;
|
|
};
|
|
|
|
$scope.$watch('roles', function(roles) {
|
|
var count = 0;
|
|
angular.forEach(roles, function(role) {
|
|
count += role.count;
|
|
})
|
|
$scope.rolesTotalCount = count;
|
|
}, true);
|
|
$scope.tableParams = new ngTableParams({
|
|
page: 1, // show first page
|
|
count: $scope.servers.length + 1 // count per page
|
|
}, {
|
|
counts: [], // hide count-per-page box
|
|
total: $scope.servers.length, // length of data
|
|
getData: function($defer, params) {
|
|
var reverse = false;
|
|
var orderBy = params.orderBy()[0];
|
|
var orderBySort = "";
|
|
var orderByColumn = "";
|
|
|
|
if (orderBy) {
|
|
orderByColumn = orderBy.substring(1);
|
|
orderBySort = orderBy.substring(0, 1);
|
|
if (orderBySort == "+") {
|
|
reverse = false;
|
|
} else {
|
|
reverse = true;
|
|
}
|
|
}
|
|
|
|
var orderedData = params.sorting() ?
|
|
$filter('orderBy')($scope.servers, function(item) {
|
|
if (orderByColumn == "switch_ip") {
|
|
return sortingService.ipAddressPre(item.switch_ip);
|
|
} else {
|
|
return item[orderByColumn];
|
|
}
|
|
}, reverse) : $scope.servers;
|
|
$scope.servers = orderedData;
|
|
|
|
$defer.resolve(orderedData.slice((params.page() - 1) * params.count(), params.page() * params.count()));
|
|
}
|
|
});
|
|
|
|
$scope.$watch(function() {
|
|
return wizardFactory.getCommitState()
|
|
}, function(newCommitState, oldCommitState) {
|
|
if (newCommitState !== undefined) {
|
|
if (newCommitState.name == "role_assign" && newCommitState.state == "triggered") {
|
|
$scope.commit(newCommitState.sendRequest);
|
|
}
|
|
}
|
|
});
|
|
|
|
$scope.commit = function(sendRequest) {
|
|
if (!sendRequest) {
|
|
var commitState = {
|
|
"name": "role_assign",
|
|
"state": "goToPreviousStep",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
return;
|
|
}
|
|
$scope.$emit("loading", true);
|
|
var promises = [];
|
|
angular.forEach($scope.servers, function(server) {
|
|
var roles = [];
|
|
angular.forEach(server.roles, function(role) {
|
|
roles.push(role.name);
|
|
});
|
|
var data = {
|
|
"roles": roles
|
|
};
|
|
var updateRoles = dataService.updateClusterHost(cluster.id, server.id, data).then(function(configData) {
|
|
// success callback
|
|
}, function(response) {
|
|
// error callback
|
|
return $q.reject(response);
|
|
});
|
|
promises.push(updateRoles);
|
|
});
|
|
|
|
if ($scope.ha_vip) {
|
|
var config = {
|
|
"package_config": {
|
|
"ha_vip": $scope.ha_vip
|
|
}
|
|
}
|
|
var updateHAVIP = dataService.updateClusterConfig(cluster.id, config).then(function(configData) {
|
|
// success callback
|
|
}, function(response) {
|
|
// error callback
|
|
return $q.reject(response);
|
|
});
|
|
promises.push(updateHAVIP);
|
|
}
|
|
|
|
$q.all(promises).then(function() {
|
|
wizardFactory.setServers($scope.servers);
|
|
var commitState = {
|
|
"name": "role_assign",
|
|
"state": "success",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
}, function(response) {
|
|
console.log("promises error", response);
|
|
var commitState = {
|
|
"name": "role_assign",
|
|
"state": "error",
|
|
"message": response.data
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
});
|
|
};
|
|
|
|
$scope.onDrop = function($event, server) {
|
|
$scope.dragKey = $scope.servers.indexOf(server);
|
|
};
|
|
|
|
$scope.dropSuccessHandler = function($event, role_value, key) {
|
|
var roleExist = $scope.checkRoleExist($scope.servers[$scope.dragKey].roles, role_value);
|
|
if (!roleExist) {
|
|
$scope.servers[$scope.dragKey].roles.push(role_value);
|
|
} else {
|
|
console.log("role exists");
|
|
}
|
|
$scope.checkExistRolesDrag();
|
|
};
|
|
|
|
$scope.checkExistRolesDrag = function() {
|
|
angular.forEach($scope.servers, function(value, key) {
|
|
angular.forEach($scope.servers[key].roles, function(server_role, server_role_key) {
|
|
angular.forEach($scope.roles, function(role, role_key) {
|
|
if ($scope.servers[key].roles[server_role_key].name == $scope.roles[role_key].name) {
|
|
$scope.existingRoles[key].splice(role_key, 1, "p");
|
|
}
|
|
});
|
|
});
|
|
$scope.servers[key].dropChannel = $scope.existingRoles[key].toString();
|
|
});
|
|
};
|
|
});
|
|
|
|
wizardModule.controller('networkMappingCtrl', function($scope, wizardFactory, dataService) {
|
|
var cluster = wizardFactory.getClusterInfo();
|
|
$scope.interfaces = wizardFactory.getInterfaces();
|
|
$scope.original_networking = wizardFactory.getNetworkMapping();
|
|
$scope.pendingInterface = "";
|
|
|
|
$scope.onDrop = function($event, key) {
|
|
$scope.pendingInterface = key;
|
|
};
|
|
|
|
angular.forEach($scope.interfaces, function(value, key) {
|
|
$scope.interfaces[key].dropChannel = "others";
|
|
});
|
|
|
|
$scope.networking = {};
|
|
angular.forEach($scope.original_networking, function(value, key) {
|
|
$scope.networking[key] = {};
|
|
$scope.networking[key].mapping_interface = value;
|
|
if (key == "external") {
|
|
$scope.networking[key].dragChannel = "external";
|
|
} else
|
|
$scope.networking[key].dragChannel = "others";
|
|
});
|
|
|
|
|
|
$scope.dropSuccessHandler = function($event, key, dict) {
|
|
dict[key].mapping_interface = $scope.pendingInterface;
|
|
};
|
|
if ($scope.currentAdapterName != "ceph_firefly") {
|
|
angular.forEach($scope.interfaces, function(value, key) {
|
|
// The interface with promisc mode is required to be set as External Network
|
|
if (value.is_promiscuous) {
|
|
$scope.networking["external"].mapping_interface = key;
|
|
$scope.interfaces[key].dropChannel = "external";
|
|
}
|
|
// The interface marked as management is required to be set as Management Network
|
|
if (value.is_mgmt) {
|
|
$scope.networking["management"].mapping_interface = key;
|
|
}
|
|
});
|
|
}
|
|
|
|
$scope.$watch(function() {
|
|
return wizardFactory.getCommitState()
|
|
}, function(newCommitState, oldCommitState) {
|
|
if (newCommitState !== undefined) {
|
|
if (newCommitState.name == "network_mapping" && newCommitState.state == "triggered") {
|
|
$scope.commit(newCommitState.sendRequest);
|
|
}
|
|
}
|
|
});
|
|
|
|
$scope.commit = function(sendRequest) {
|
|
if (!sendRequest) {
|
|
var commitState = {
|
|
"name": "network_mapping",
|
|
"state": "goToPreviousStep",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
return;
|
|
}
|
|
|
|
$scope.$emit("loading", true);
|
|
var networks = {};
|
|
angular.forEach($scope.networking, function(value, key) {
|
|
networks[key] = value.mapping_interface;
|
|
});
|
|
var network_mapping = {
|
|
"package_config": {
|
|
"network_mapping": networks
|
|
}
|
|
};
|
|
dataService.updateClusterConfig(cluster.id, network_mapping).success(function(data) {
|
|
wizardFactory.setNetworkMapping(networks);
|
|
var commitState = {
|
|
"name": "network_mapping",
|
|
"state": "success",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
}).error(function(response) {
|
|
var commitState = {
|
|
"name": "network_mapping",
|
|
"state": "error",
|
|
"message": response
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
});
|
|
};
|
|
});
|
|
|
|
wizardModule.controller('reviewCtrl', function($scope, wizardFactory, dataService, $filter, ngTableParams, sortingService) {
|
|
var cluster = wizardFactory.getClusterInfo();
|
|
$scope.servers = wizardFactory.getServers();
|
|
$scope.interfaces = wizardFactory.getInterfaces();
|
|
$scope.partition = wizardFactory.getPartition();
|
|
$scope.network_mapping = wizardFactory.getNetworkMapping();
|
|
$scope.server_credentials = wizardFactory.getServerCredentials();
|
|
$scope.service_credentials = wizardFactory.getServiceCredentials();
|
|
$scope.console_credentials = wizardFactory.getConsoleCredentials();
|
|
$scope.global_config = wizardFactory.getGeneralConfig();
|
|
$scope.cephConfig = wizardFactory.getCephConfig();
|
|
|
|
dataService.getServerColumns().success(function(data) {
|
|
$scope.server_columns = data.review;
|
|
});
|
|
|
|
$scope.tabs = [{
|
|
"title": "Database & Queue",
|
|
"url": "service.tpl.html"
|
|
}, {
|
|
"title": "Keystone User",
|
|
"url": "console.tpl.html"
|
|
}];
|
|
|
|
if ($scope.currentAdapterName == "ceph_openstack_icehouse") {
|
|
$scope.tabs.push({
|
|
"title": "Ceph",
|
|
"url": "ceph.tpl.html"
|
|
});
|
|
}
|
|
|
|
$scope.currentTab = $scope.tabs[0].url;
|
|
|
|
$scope.onClickTab = function(tab) {
|
|
$scope.currentTab = tab.url;
|
|
}
|
|
|
|
$scope.isActiveTab = function(tabUrl) {
|
|
return tabUrl == $scope.currentTab;
|
|
}
|
|
|
|
$scope.tableParams = new ngTableParams({
|
|
page: 1, // show first page
|
|
count: $scope.servers.length + 1 // count per page
|
|
}, {
|
|
counts: [], // hide count-per-page box
|
|
total: $scope.servers.length, // length of data
|
|
getData: function($defer, params) {
|
|
var reverse = false;
|
|
var orderBy = params.orderBy()[0];
|
|
var orderBySort = "";
|
|
var orderByColumn = "";
|
|
|
|
if (orderBy) {
|
|
orderByColumn = orderBy.substring(1);
|
|
orderBySort = orderBy.substring(0, 1);
|
|
if (orderBySort == "+") {
|
|
reverse = false;
|
|
} else {
|
|
reverse = true;
|
|
}
|
|
}
|
|
|
|
var orderedData = params.sorting() ?
|
|
$filter('orderBy')($scope.servers, function(item) {
|
|
if (orderByColumn == "switch_ip") {
|
|
return sortingService.ipAddressPre(item.switch_ip);
|
|
} else {
|
|
return item[orderByColumn];
|
|
}
|
|
}, reverse) : $scope.servers;
|
|
|
|
$defer.resolve(orderedData.slice((params.page() - 1) * params.count(), params.page() * params.count()));
|
|
}
|
|
});
|
|
|
|
$scope.$watch(function() {
|
|
return wizardFactory.getCommitState()
|
|
}, function(newCommitState, oldCommitState) {
|
|
if (newCommitState !== undefined) {
|
|
if (newCommitState.name == "review" && newCommitState.state == "triggered") {
|
|
$scope.commit();
|
|
}
|
|
}
|
|
});
|
|
|
|
$scope.commit = function() {
|
|
var reviewAction = {
|
|
"review": {
|
|
"hosts": []
|
|
}
|
|
};
|
|
var deployAction = {
|
|
"deploy": {
|
|
"hosts": []
|
|
}
|
|
};
|
|
angular.forEach($scope.servers, function(server) {
|
|
reviewAction.review.hosts.push(server.id);
|
|
deployAction.deploy.hosts.push(server.id);
|
|
});
|
|
|
|
dataService.postClusterActions(cluster.id, reviewAction).success(function(data) {
|
|
dataService.postClusterActions(cluster.id, deployAction).success(function(data) {
|
|
var commitState = {
|
|
"name": "review",
|
|
"state": "success",
|
|
"message": ""
|
|
};
|
|
wizardFactory.setCommitState(commitState);
|
|
}).error(function(data) {
|
|
console.warn("Deploy hosts error: ", data);
|
|
});
|
|
}).error(function(data) {
|
|
console.warn("Review hosts error: ", data);
|
|
});
|
|
//TODO: error handling
|
|
};
|
|
|
|
$scope.returnStep = function(reviewName) {
|
|
for (var i = 0; i < $scope.steps.length; i++) {
|
|
if (reviewName == $scope.steps[i].name) {
|
|
$scope.skipForward(i + 1);
|
|
}
|
|
}
|
|
};
|
|
});
|
|
|
|
wizardModule.directive('ngKeypress', function() {
|
|
return function(scope, element, attrs) {
|
|
element.bind("keydown keypress", function(event) {
|
|
if (event.which === 9) { // 9 is tab key
|
|
var current = attrs.position;
|
|
var result = current.split('_');
|
|
var next = result[0] + "_" + (parseInt(result[1]) + 1);
|
|
if ($("input[data-position=" + next + "]").length) {
|
|
|
|
$("input[data-position=" + next + "]").focus();
|
|
} else {
|
|
$(".btn-next").focus();
|
|
}
|
|
event.preventDefault();
|
|
}
|
|
});
|
|
};
|
|
});
|
|
|
|
//Used for roles panel on Role Assignment page
|
|
wizardModule.directive("rolepanelscroll", function($window) {
|
|
return function(scope, element, attrs) {
|
|
angular.element($window).bind("scroll", function() {
|
|
var window_top = this.pageYOffset;
|
|
var sticky_anchor_elem = angular.element($('#sticky-anchor'));
|
|
var window_height = $(window).height();
|
|
var scroll_panel_height = $('.role-assign-drag').height();
|
|
if (sticky_anchor_elem.length != 0) {
|
|
var div_top = sticky_anchor_elem.offset().top;
|
|
if (window_top > div_top + 10 && window_height > scroll_panel_height + 150) {
|
|
$('.role-panel').addClass('stick');
|
|
} else {
|
|
$('.role-panel').removeClass('stick');
|
|
}
|
|
scope.$apply();
|
|
}
|
|
});
|
|
};
|
|
});
|
|
|
|
var wizardModalInstanceCtrl = function($scope, $modalInstance, warning) {
|
|
$scope.warning = warning;
|
|
|
|
$scope.ok = function() {
|
|
$modalInstance.close();
|
|
};
|
|
};
|
|
|
|
|
|
var addSubnetModalInstanceCtrl = function($scope, $modalInstance, $q, subnets, dataService, $filter) {
|
|
$scope.subnetworks = angular.copy(subnets);
|
|
$scope.subnetAllValid = true;
|
|
|
|
angular.forEach($scope.subnetworks, function(subnet) {
|
|
subnet['valid'] = true;
|
|
});
|
|
|
|
var allValid = function() {
|
|
var invalid = 0;
|
|
angular.forEach($scope.subnetworks, function(subnet) {
|
|
if (subnet['valid'] == false) {
|
|
invalid = 1;
|
|
}
|
|
});
|
|
if (invalid == 0) {
|
|
$scope.subnetAllValid = true;
|
|
} else {
|
|
|
|
$scope.subnetAllValid = false;
|
|
}
|
|
}
|
|
$scope.subnet_change = function(index, subnet) {
|
|
var subnetRegExp = /(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}(\/){1}([0-9]|[0-2][0-9]|3[0-2])$/;
|
|
var valid = subnetRegExp.test(subnet);
|
|
$scope.subnetworks[index]['valid'] = valid;
|
|
allValid();
|
|
};
|
|
|
|
$scope.ok = function() {
|
|
var newsubnetworks = [];
|
|
var promises = [];
|
|
angular.forEach($scope.subnetworks, function(subnet) {
|
|
var requestData = {
|
|
"subnet": subnet.subnet
|
|
}
|
|
if (subnet.id === undefined) {
|
|
// post subnetworks
|
|
var updateSubnetConfig = dataService.postSubnetConfig(requestData).then(function(subnetData) {
|
|
newsubnetworks.push(subnetData.data);
|
|
}, function(response) {
|
|
return $q.reject(response);
|
|
});
|
|
promises.push(updateSubnetConfig);
|
|
} else {
|
|
// put subnetworks
|
|
var updateSubnetConfig = dataService.putSubnetConfig(subnet.id, requestData).then(function(subnetData) {
|
|
newsubnetworks.push(subnetData.data);
|
|
}, function(response) {
|
|
return $q.reject(response);
|
|
});
|
|
promises.push(updateSubnetConfig);
|
|
}
|
|
});
|
|
|
|
$q.all(promises).then(function() {
|
|
$scope.subnetworks = newsubnetworks;
|
|
for (var i = 0; i < subnets.length && i < $scope.subnetworks.length; i++) {
|
|
$scope.subnetworks[i].$$hashKey = subnets[i].$$hashKey;
|
|
}
|
|
$modalInstance.close($scope.subnetworks);
|
|
}, function(response) {
|
|
console.log("promises error", response);
|
|
$scope.alerts = [];
|
|
$scope.alerts.push({
|
|
"message": response
|
|
});
|
|
});
|
|
};
|
|
|
|
$scope.cancel = function() {
|
|
|
|
$scope.subnetworks = $filter('filter')($scope.subnetworks, {
|
|
valid: true
|
|
}, true);
|
|
$modalInstance.dismiss('cancel');
|
|
|
|
};
|
|
|
|
$scope.closeAlert = function() {
|
|
$scope.alerts = [];
|
|
};
|
|
|
|
$scope.addSubnetwork = function() {
|
|
$scope.subnetworks.push({
|
|
valid: false
|
|
});
|
|
allValid();
|
|
};
|
|
|
|
$scope.removeSubnetwork = function(index) {
|
|
dataService.deleteSubnet($scope.subnetworks[index].id).success(function(data) {
|
|
$scope.subnetworks.splice(index, 1);
|
|
}).error(function(response) {
|
|
$scope.alerts = [];
|
|
$scope.alerts.push({
|
|
"message": response
|
|
});
|
|
});
|
|
allValid();
|
|
};
|
|
|
|
$scope.$watch('subnetworks', function() {
|
|
if ($scope.subnetworks.length == 0) {
|
|
$scope.subnetworks.push({});
|
|
}
|
|
}, true);
|
|
|
|
};
|
|
}); |