vpp.register.controller('TableController', ['$scope', '$rootScope','$filter', 'dataService', 'toastService', 'bdmInterfaceService',
function ($scope, $rootScope, filter, dataService, toastService, bdmInterfaceService) {
+ $scope.interfaceList = [];
+ $scope.unassignedInterfaceList = [];
+ $scope.assignedInterfaces = [];
+
var vm = this;
- vm.rowCollection = dataService.tableContent;
- vm.displayedCollection = [].concat(vm.rowCollection);
vm.updateAssignment = function(receivedInterface) {
- console.log(receivedInterface);
- var interf = _.find(dataService.interfaces, {name: receivedInterface.name, 'vppName': receivedInterface.vppName});
if (receivedInterface.assigned){
- interf.assigned = true;
- interf.vbd = dataService.selectedBd.name;
- receivedInterface.vbd = dataService.selectedBd.name;
+ receivedInterface.vbdName = $scope.selectedBd['topology-id'];
+ vm.assignInterface($scope.selectedBd, receivedInterface);
- vm.assignInterface(interf);
} else {
- var vbdName = receivedInterface.vbd,
- vppName = receivedInterface.vppName;
-
- interf.assigned = false;
- interf.vbd = '';
- receivedInterface.vbd = '';
-
- vm.unassignInterface(interf, vbdName, vppName);
+ vm.unassignInterface(receivedInterface);
}
- //dataService.buildTableContent();
- var previouslyChangedInterface = _.find(dataService.changedInterfaces, {name: interf.name, 'vppName': interf.vppName});
- if (!previouslyChangedInterface) {
- dataService.changedInterfaces.push(interf);
- }
- console.log(dataService.changedInterfaces);
- dataService.injectBridgeDomainsTopoElements();
-
};
- vm.assignInterface = function(interface) {
- var interfaceObject = bdmInterfaceService.createObj(interface.name, interface.name);
+ vm.assignInterface = function(bridgeDomain, interface) {
+ var interfaceObject = bdmInterfaceService.createObj(interface['tp-id'], interface['tp-id']);
var successCallback = function() {
toastService.showToast('Interface assigned');
+ $scope.assignedInterfaces.push(interface);
+
+ $scope.$emit('INTERFACE_CHANGED', interface);
};
var errorCallback = function() {
toastService.showToast('Unable to assign interface');
};
- bdmInterfaceService.add(interfaceObject, interface.vbd, interface.vppName, successCallback, errorCallback);
+ bdmInterfaceService.add(interfaceObject, bridgeDomain['topology-id'], interface.vppName, successCallback, errorCallback);
};
- vm.unassignInterface = function(interface, vbdname, vppName) {
- var interfaceObject = bdmInterfaceService.createObj(interface.name, interface.name);
+ vm.unassignInterface = function(interface) {
+ var interfaceObject = bdmInterfaceService.createObj(interface['tp-id'], interface['tp-id']);
var successCallback = function() {
toastService.showToast('Interface unassigned');
+ $scope.assignedInterfaces.splice($scope.assignedInterfaces.indexOf(interface), 1);
+ interface.vbdName = '';
+
+ $scope.$emit('INTERFACE_CHANGED', interface);
};
var errorCallback = function() {
toastService.showToast('Unable to unassign interface');
};
- bdmInterfaceService.delete(interfaceObject, vbdname, vppName, successCallback, errorCallback);
+ bdmInterfaceService.delete(interfaceObject, interface.vbdName, interface.vppName, successCallback, errorCallback);
};
- }]);
- vpp.register.controller('BridgeDomainsController', ['$scope', '$rootScope','$filter', 'dataService', 'bdmBridgeDomainService', 'toastService', '$mdDialog','bdmInterfaceService',
- function($scope, $rootScope, $filter, dataService, bdmBridgeDomainService, toastService, $mdDialog,bdmInterfaceService) {
+ $scope.$on('BUILD_INTERFACES_TABLE', function(event) {
+ $scope.interfaceList = [];
+ $scope.unassignedInterfaceList = [];
+ $scope.assignedInterfaces = $scope.getAssignedInterfaces();
- console.log('Bridge Domains Controller executed.');
+ $scope.assignedInterfacesFlat = [];
- $scope.dataService = dataService;
- $scope.bridgedomains = dataService.bridgedomains;
- $scope.selectedBd = dataService.selectedBd;
+ var getAssignedInterfacesFlat = function() {
+ var keys = Object.keys($scope.assignedInterfaces);
- dataService.nextApp.container(document.getElementById('bridge-domains-next-app'));
- dataService.bridgeDomainsTopo.attach(dataService.nextApp);
+ if(keys.length) {
+ keys.forEach(function (k) {
+ if($scope.assignedInterfaces[k]) {
+ $scope.assignedInterfaces[k].forEach(function(ai) {
+ checkAndPushIntoArray($scope.assignedInterfacesFlat, ai);
+ });
+ }
+ });
+ }
+ };
- if (!dataService.bridgedomainsLoaded) {
- dataService.generateInterfaces();
- bdmBridgeDomainService.get(function(data) {
- //success callback
- angular.copy(data['network-topology'].topology, dataService.bridgedomains);
- dataService.bridgedomainsLoaded = true;
- console.log('Loaded BridgeDomains:');
- console.log(dataService.bridgedomains);
- dataService.buildAssignedInterfaces();
- }, function(data,status) {
- //error callback
- console.log(status);
+ var checkAndPushIntoArray = function(array, item) {
+ var check = array.some(function(i) {
+ return i['tp-id'] === item['tp-id'] && i.vppName === item.vppName;
+ });
+
+ if(!check) {
+ array.push(item);
+ }
+ };
+
+ getAssignedInterfacesFlat();
+
+ dataService.vpps.forEach(function(vpp){
+ vpp.interfaces.forEach(function(interface){
+ var interfaceObject = bdmInterfaceService.createObj(interface.name, interface.name);
+
+ var check = $scope.assignedInterfacesFlat.some(function (ai) {
+ return interfaceObject['tp-id'] === ai['tp-id'] && vpp.name === ai.vppName;
+ });
+
+ if(!check) {
+ interfaceObject.vppName = vpp.name;
+ checkAndPushIntoArray($scope.unassignedInterfaceList, interfaceObject);
+ }
+ });
});
- }
- dataService.bridgeDomainsTopo.on('clickNode',function(topo,node) {
- console.log(node);
+ if($scope.selectedBd) {
+ $scope.interfaceList = $scope.assignedInterfaces[$scope.selectedBd['topology-id']] ? $scope.assignedInterfaces[$scope.selectedBd['topology-id']].concat($scope.unassignedInterfaceList) : $scope.unassignedInterfaceList;
+ }
+
+ $scope.interfaceDisplayList = [].concat($scope.interfaceList);
+ });
+
+ $scope.$on('INIT_INTERFACES_TABLE', function(event) {
+ $scope.interfaceList = [];
+ $scope.unassignedInterfaceList = [];
+ $scope.assignedInterfaces = [];
+ $scope.assignedInterfacesFlat = [];
});
- $scope.reload = function() {
- dataService.selectedBd.name = '';
- dataService.changedInterfaces.length = 0;
- dataService.originalAssignments.length = 0;
- dataService.interfaces.length = 0;
- dataService.tableContent.length = 0;
- dataService.bridgeDomainsTopo.clear();
- dataService.injectedInterfaces.length = 0;
- dataService.generateInterfaces();
+
+
+ }]);
+
+ vpp.register.controller('BridgeDomainsController', ['$scope', '$rootScope','$filter', 'dataService', 'bdmBridgeDomainService', 'toastService', '$mdDialog', 'bdmTunnelService',
+ function($scope, $rootScope, $filter, dataService, bdmBridgeDomainService, toastService, $mdDialog, bdmTunnelService) {
+ $scope.bridgeDomainList = [];
+ $scope.showOverlay = true;
+
+ $scope.loadBridgeDomains = function(bridgeDomain, successCallback) {
bdmBridgeDomainService.get(function(data) {
- //success callback
- angular.copy(data['network-topology'].topology, dataService.bridgedomains);
- dataService.bridgedomainsLoaded = true;
- console.log('Loaded BridgeDomains:');
- console.log(dataService.bridgedomains);
- dataService.buildAssignedInterfaces();
+ $scope.bridgeDomainList = data;
+
+ if(bridgeDomain) {
+ $scope.selectedBd = $scope.bridgeDomainList.filter(function(bd) {
+ return bd['topology-id'] === bridgeDomain['topology-id'];
+ })[0];
+
+ $scope.showTopology($scope.selectedBd);
+ }
+
+ successCallback();
+
}, function(data,status) {
//error callback
console.log(status);
});
};
- $scope.bdChanged = function() {
- dataService.buildTableContent();
+ $scope.getInterfacesForBridgeDomain = function(bridgeDomain) {
+ var interfaceList = [];
+
+ if(bridgeDomain.node) {
+ bridgeDomain.node.forEach(function (n) {
+ if (n['termination-point']) {
+ n['termination-point'].forEach(function (tp) {
+ tp.vppName = n['node-id'];
+ tp.vbdName = bridgeDomain['topology-id'];
+ tp.assigned = true;
+
+ interfaceList.push(tp);
+ });
+ }
+ });
+ }
+
+ return interfaceList;
+ };
+
+ $scope.getAssignedInterfaces = function() {
+ var interfaces = [];
+
+ $scope.bridgeDomainList.forEach(function(bd) {
+ var bdCopy = {};
+ angular.copy(bd, bdCopy);
+
+ interfaces[bdCopy['topology-id']] = $scope.getInterfacesForBridgeDomain(bdCopy);
+ });
+
+ return interfaces;
};
$scope.addBd = function() {
$mdDialog.cancel();
};
- vm.isDone = function(status) {
+ vm.isDone = function(status, bridgeDomain) {
vm.waiting = false;
if (status === 'success') {
- dataService.bridgedomains.push(vm.bd);
- dataService.selectedBd.name = vm.bd.name;
- $scope.reload();
+ $scope.reload(bridgeDomain);
vm.close();
}
};
bdmBridgeDomainService.add(obj,
function(data) {
- vm.isDone('success');
+ vm.isDone('success', obj);
},
function() {
vm.isDone('failed');
})
};
+ $scope.removeBd = function() {
+ if($scope.selectedBd['topology-id']) {
+ var successCallback = function(success) {
+ $scope.selectedBd = null;
+ $scope.loadBridgeDomains(null, function() {
+ $scope.$broadcast('INIT_INTERFACES_TABLE');
+ $scope.clearTopologies();
+ });
- /* FIXME: remove after testing */
- $scope.deploy = function() {
- var successfulRequestsRequired = dataService.changedInterfaces.length;
- var successfulRequests = 0;
+ };
+ bdmBridgeDomainService.remove($scope.selectedBd['topology-id'], function(){successCallback(true)}, function(){successCallback(false)});
+ }
+ };
- console.log('Removing previous assignments...');
- _.forEach(dataService.changedInterfaces, function(interf) {
+ $scope.bdChanged = function() {
+ $scope.loadBridgeDomains($scope.selectedBd, function() {
+ $scope.$broadcast('BUILD_INTERFACES_TABLE');
- //Check if previously assigned.. then DELETE
- //....
- var previousAssignment = _.find(dataService.originalAssignments, {
- 'vbridge-topology:user-interface': interf.name,
- vppName: interf.vppName
- });
+ $scope.showTopology($scope.selectedBd);
+ });
- if (previousAssignment) {
- successfulRequestsRequired++;
- bdmInterfaceService.delete(
- {
- "tp-id":previousAssignment['tp-id'],
- "vbridge-topology:user-interface": previousAssignment['vbridge-topology:user-interface']
- },
- previousAssignment.vbd,
- previousAssignment.vppName,
- function() {
- //success callback
- console.log('Removed previous assignment:',previousAssignment);
- successfulRequests++;
-
- if (successfulRequests >= successfulRequestsRequired) {
- toastService.showToast('Deployed! Bridge Domain Validated.');
- dataService.changedInterfaces.length = 0;
- console.log('Changed interfaces tracker has been reset.');
- $scope.reload();
- }
- },
- function() {
- //error callback
- console.error('ERROR removing assignment:',previousAssignment);
+ };
+
+ nx.graphic.Icons.registerIcon("bd", "src/app/vpp/assets/images/bd1.svg", 45, 45);
+ nx.graphic.Icons.registerIcon("interf", "src/app/vpp/assets/images/interf.svg", 45, 45);
+
+ $scope.showOverlayTopology = function(bridgeDomain) {
+ var bdCopy = {};
+ angular.copy(bridgeDomain, bdCopy);
+
+ $scope.bridgeDomainsTopo = new nx.graphic.Topology({
+ adaptive: true,
+ scalable: true,
+ theme: 'blue',
+ enableGradualScaling: true,
+ nodeConfig: {
+ color: '#414040',
+ label: 'model.label',
+ scale: 'model.scale',
+ iconType: function (vertex) {
+ var type = vertex.get().type;
+ if (type === 'bd') {
+ return 'bd'
+ } else {
+ return 'interf';
}
- )
- }
- if (interf.assigned) {
- //Send PUT to correct vBD
- bdmInterfaceService.add(
- {
- "tp-id":interf.vppName+'-'+interf.name,
- "vbridge-topology:user-interface": interf.name
- },
- interf.vbd,
- interf.vppName,
- function() {
- //success callback
- console.log('Added assignment:',interf);
- successfulRequests++;
-
- if (successfulRequests >= successfulRequestsRequired) {
- toastService.showToast('Deployed! Bridge Domain Validated.');
- dataService.changedInterfaces.length = 0;
- console.log('Changed interfaces tracker has been reset.')
- $scope.reload();
- }
- },
- function() {
- //error callback
- console.error('ERROR adding assignment:',interf);
+ }
+ },
+ linkConfig: {
+ label: 'model.label',
+ linkType: 'parallel',
+ color: function (link) {
+ if (link.getData().type === 'tunnel') {
+ return '#00FF00';
+ } else {
+ return '#ffffff';
}
- )
- } else {
- successfulRequests++;
+ },
+ width: function (link) {
+ if (link.getData().type === 'tunnel') {
+ return 5;
+ }
+ }
+ },
+ showIcon: true,
+ dataProcessor: 'force',
+ autoLayout: true,
+ enableSmartNode: false,
+ tooltipManagerConfig: {
+ nodeTooltipContentClass: 'TooltipNode',
+ linkTooltipContentClass: 'TooltipLink'
}
});
+
+ $scope.overlayNextApp = new nx.ui.Application;
+
+ var bdNode = {
+ "data": bdCopy,
+ "type": "bd",
+ "label": bdCopy['topology-id']
+ };
+
+ var nodes = [].concat(bdNode);
+ var links = [];
+
+ _.forEach($scope.getInterfacesForBridgeDomain(bdCopy), function(tp, index){
+ var ifNode = {
+ "data": tp,
+ "type": "interf",
+ "label": tp['tp-id']
+ };
+ nodes.push(ifNode);
+ links.push({source: 0, target: nodes.length-1});
+ });
+
+
+ $scope.bridgeDomainsTopo.data({
+ nodes: nodes,
+ links: links
+ });
+
+ $scope.overlayNextApp.container(document.getElementById('overlay-next-app'));
+ $scope.bridgeDomainsTopo.attach($scope.overlayNextApp);
};
- $scope.removeBd = function() {
- if(dataService.selectedBd.name) {
- var successCallback = function(success) {
- if (success) {
- console.log($scope.bridgedomains);
- _.remove($scope.bridgedomains, {
- name: $scope.selectedBd.name
- });
- toastService.showToast('Bridge Domain Removed!');
- $scope.selectedBd.name = '';
- dataService.clearTopology();
- dataService.tableContent.length = 0;
- $scope.reload();
- } else {
- toastService.showToast('Error removing Bridge Domain!');
- }
+ $scope.fillOverlayTopology = function(bridgeDomain) {
+ var bdCopy = {};
+ angular.copy(bridgeDomain, bdCopy);
+
+ var bdNode = {
+ "data": bdCopy,
+ "type": "bd",
+ "label": bdCopy['topology-id']
+ };
+
+ var nodes = [].concat(bdNode);
+ var links = [];
+
+ _.forEach($scope.getInterfacesForBridgeDomain(bdCopy), function(tp, index){
+ var ifNode = {
+ "data": tp,
+ "type": "interf",
+ "label": tp['tp-id']
};
- bdmBridgeDomainService.remove(dataService.selectedBd.name, function(){successCallback(true)}, function(){successCallback(false)});
+ nodes.push(ifNode);
+ links.push({source: 0, target: nodes.length-1});
+ });
+
+
+ $scope.bridgeDomainsTopo.data({
+ nodes: nodes,
+ links: links
+ });
+
+ };
+
+ $scope.showUnderTopology = function(bridgeDomain) {
+ //var bdCopy = {};
+ //angular.copy(bridgeDomain, bdCopy);
+
+ $scope.underlayTopo = new nx.graphic.Topology({
+ adaptive: true,
+ scalable: true,
+ theme:'blue',
+ enableGradualScaling:true,
+ nodeConfig: {
+ color: '#414040',
+ label: 'model.label',
+ scale: 'model.scale',
+ iconType: function(vertex) {
+ var type = vertex.get().type;
+ if (type === 'bd') {
+ return 'bd';
+ } else if (type==='vpp') {
+ return 'switch';
+ } else {
+ return 'interf';
+ }
+ }
+ },
+ linkConfig: {
+ label: 'model.label',
+ linkType: 'parallel',
+ color: function(link) {
+ if (link.getData().type === 'tunnel') {
+ return '#00FF00';
+ } else {
+ return '#ffffff';
+ }
+ },
+ width: function(link) {
+ if (link.getData().type === 'tunnel') {
+ return 5;
+ }
+ }
+ },
+ showIcon: true,
+ enableSmartNode: false
+ });
+
+ $scope.underlayNextApp = new nx.ui.Application;
+
+ $scope.fillUnderlayTopology(bridgeDomain);
+
+ $scope.underlayNextApp.container(document.getElementById('underlay-next-app'));
+ $scope.underlayTopo.attach($scope.underlayNextApp);
+ };
+
+ $scope.fillUnderlayTopology = function(bridgeDomain) {
+ var bdCopy = {};
+ angular.copy(bridgeDomain, bdCopy);
+
+ var nodes = [];
+ var links = [];
+
+ _.forEach(bdCopy.node, function(node, index){
+ var i = index + 1;
+
+ nodes.push({
+ label: node['node-id'],
+ x: (-1+(2*(i%2)))*((i+1)/2 * 500),
+ y: 700,
+ scale: 1.25,
+ type: 'vpp'
+ });
+
+
+ bdmTunnelService.get(
+ bdCopy['topology-id'],
+ function(data) {
+ //success
+ console.log(data);
+
+ var link = data;
+ var sourceNode = link[0].source['source-node'];
+ var targetNode = link[0].destination['dest-node'];
+
+ links.push({
+ source: _.findIndex(nodes, {label: sourceNode, type: 'vpp'}),
+ target: _.findIndex(nodes, {label: targetNode, type: 'vpp'}),
+ type: 'tunnel'
+ });
+
+ $scope.underlayTopo.data({
+ nodes: nodes,
+ links: links
+ });
+
+ }, function(res) {
+ $scope.underlayTopo.data({
+ nodes: nodes,
+ links: links
+ });
+ });
+ });
+
+
+ $scope.underlayTopo.data({
+ nodes: nodes,
+ links: links
+ });
+ };
+
+ $scope.reload = function(bridgeDomain) {
+ $scope.loadBridgeDomains(bridgeDomain, function() {
+ $scope.$broadcast('BUILD_INTERFACES_TABLE');
+
+ $scope.showTopology($scope.selectedBd);
+ });
+
+ };
+
+ $scope.toggleUnderlay = function() {
+ $scope.showOverlay = !$scope.showOverlay;
+
+ $scope.reload($scope.selectedBd);
+ };
+
+ $scope.showTopology = function(bridgeDomain) {
+ if($scope.showOverlay) {
+ if(!$scope.bridgeDomainsTopo) {
+ $scope.showOverlayTopology(bridgeDomain);
+ }
+ else {
+ $scope.fillOverlayTopology(bridgeDomain);
+ }
+ } else {
+ if(!$scope.underlayTopo) {
+ $scope.showUnderTopology(bridgeDomain);
+ }
+ else {
+ $scope.fillUnderlayTopology(bridgeDomain);
+ }
+ }
+ };
+
+ $scope.clearTopologies = function() {
+ if($scope.bridgeDomainsTopo) {
+ $scope.bridgeDomainsTopo.data({
+ nodes: [],
+ links: []
+ });
}
+
+ if($scope.bridgeDomainsTopo) {
+ $scope.underlayTopo.data({
+ nodes: [],
+ links: []
+ });
+ }
};
- window.addEventListener('resize', function () {
- dataService.bridgeDomainsTopo.adaptToContainer();
+ $scope.$on('INTERFACE_CHANGED', function(event, data) {
+ bdmBridgeDomainService.getOne($scope.selectedBd['topology-id'],
+ function(bdData) {
+ $scope.fillOverlayTopology(bdData);
+ },
+ function() {
+ console.log('error getting vbd');
+ });
});
- }]);
+ $scope.loadBridgeDomains(null, function() {});
+ }]);
});
\ No newline at end of file
}
});
- vpp.register.service('dataService', ['$timeout', function($timeout) {
+ vpp.register.service('dataService', ['$timeout', 'bdmTunnelService',function($timeout, bdmTunnelService) {
var self = this;
- nx.graphic.Icons.registerIcon("bd", "src/app/vpp/assets/images/bd1.svg", 45, 45);
- nx.graphic.Icons.registerIcon("interf", "src/app/vpp/assets/images/interf.svg", 45, 45);
-
- this.bridgeDomainsTopo = new nx.graphic.Topology({
- adaptive: true,
- scalable: true,
- theme:'blue',
- enableGradualScaling:true,
- nodeConfig: {
- color: '#414040',
- label: 'model.label',
- scale: 'model.scale',
- iconType: function(vertex) {
- var type = vertex.get().type;
- if (type === 'bd') {
- return 'bd'
- } else {
- return 'interf';
- }
- }
- },
- linkConfig: {
- label: 'model.label',
- linkType: 'parallel',
- color: function(link) {
- if (link.getData().type === 'tunnel') {
- return '#00FF00';
- } else {
- return '#ffffff';
- }
- },
- width: function(link) {
- if (link.getData().type === 'tunnel') {
- return 5;
- }
- }
- },
- showIcon: true,
- dataProcessor: 'force',
- autoLayout: true,
- enableSmartNode: false,
- tooltipManagerConfig: {
- nodeTooltipContentClass: 'TooltipNode',
- linkTooltipContentClass: 'TooltipLink'
- }
- });
- this.nextApp = new nx.ui.Application;
- this.bridgedomainsLoaded = false;
-
this.vpps = [];
- this.tableContent = [];
- this.originalAssignments = [];
this.interfaces = [];
- this.injectedInterfaces = [];
- this.bridgedomains = [];
- this.changedInterfaces = [];
this.selectedBd = {
name: ''
};
- this.generateInterfaces = function() {
- self.interfaces.length = 0;
- _.forEach(this.vpps, function(vpp) {
- _.forEach(vpp.interfaces, function(interf) {
- interf.vppName = vpp.name;
- interf.label = vpp.name+'/'+interf.name;
- interf.scale = 0.5;
- self.interfaces.push(interf);
- });
- });
- console.log(this.interfaces);
- };
-
- this.buildAssignedInterfaces = function() {
- this.originalAssignments.length = 0;
- _.forEach(this.bridgedomains, function(bd){
- var bdName = bd['topology-id'];
- var nodes = bd.node;
- if (nodes) {
- _.forEach(nodes, function(vpp) {
- var vppName = vpp['node-id'];
- var tps = vpp['termination-point'];
- if (tps) {
- _.forEach(tps, function(tp) {
- tp.vppName = vppName;
- tp.vbd = bdName;
- self.originalAssignments.push(tp);
- })
- }
- })
- }
- });
-
- console.log('Assigned Interfaces: ');
- console.log(this.originalAssignments);
- };
-
- this.buildTableContent = function() {
- this.tableContent.length = 0;
- angular.copy(this.interfaces,this.tableContent);
-
-
- //Makes assignements based on previously changed interfaces, or assignments retrieved from ODL
- _.forEach(this.tableContent, function(interf) {
- var matchedChangedInterface = _.find(self.changedInterfaces, {
- name: interf.name,
- vppName: interf.vppName
- });
-
- var matchedOriginalAssignment = _.find(self.originalAssignments, {
- 'vbridge-topology:user-interface': interf.name,
- vppName: interf.vppName
- });
-
- if (matchedChangedInterface) {
- interf.assigned = matchedChangedInterface.assigned;
- interf.vbd = matchedChangedInterface.vbd;
- } else if (matchedOriginalAssignment) {
- interf.assigned = true;
- interf.vbd = matchedOriginalAssignment.vbd;
- } else {
- interf.assigned = false;
- interf.vbd = '';
- }
- });
-
- _.remove(self.tableContent, function(interf){
- var isAssigned = interf.assigned === true;
- var isNotCorrectBd = !(interf.vbd === self.selectedBd.name);
- return(isAssigned && isNotCorrectBd);
- });
-
- //_.forEach(this.originalAssignments, function(origAssignment) {
- // if (origAssignment.vbd === self.selectedBd.name) {
- // var matchedInterface = _.find(self.tableContent, {
- // name: origAssignment['vbridge-topology:user-interface'],
- // vppName: origAssignment.vppName
- // });
- // if (matchedInterface) {
- // matchedInterface.assigned = true;
- // matchedInterface.vbd = origAssignment.vbd;
- // } else {
- // console.error('Interface "'+origAssignment['vbridge-topology:user-interface']+'" on VPP "'+origAssignment.vppName+'" in vBD "'+origAssignment.vbd+'" was not found at mount point!');
- // }
- // } else {
- // _.remove(self.tableContent, {
- // name: origAssignment['vbridge-topology:user-interface'],
- // vppName: origAssignment.vppName
- // });
- // }
- //});
- //
- //_.forEach(this.changedInterfaces, function(changedInterface) {
- //
- // var matchedInterface = _.find(self.tableContent, {
- // name: changedInterface.name,
- // vppName: changedInterface.vppName
- // });
- //
- // if (matchedInterface) {
- // if (changedInterface.assigned) {
- // if (changedInterface.vbd === self.selectedBd.name) {
- // matchedInterface.assigned = true;
- // matchedInterface.vbd = changedInterface.vbd;
- // }
- // else {
- // _.remove(self.tableContent, {
- // name: changedInterface.name,
- // vppName: changedInterface.vppName
- // });
- // }
- // } else {
- // matchedInterface.assigned = false;
- // matchedInterface.vbd = '';
- // }
- // }
- //});
-
- //..
-
- //_.remove(self.tableContent, {
- // name: origAssignment['vbridge-topology:user-interface'],
- // vppName: origAssignment.vppName
- //});
-
- this.injectBridgeDomainsTopoElements();
-
- };
-
-
- this.clearTopology = function() {
- this.bridgeDomainsTopo.clear();
- this.injectedInterfaces.length = 0;
-
- };
-
- //this.generateUnassignedInterfaces = function() {
- // this.unassignedInterfaces.length = 0;
- // for (var x=0; x<this.interfaces.length; x++) {
- // if (!this.interfaces[x]['v3po:l2']['bridge-domain']) {
- // this.unassignedInterfaces.push(this.interfaces[x]);
- // }
- // }
- //};
- this.setData = function() {
-
- for (var x=0; x<this.tableContent.length; x++) {
- if (this.tableContent[x].assigned) {
- this.bridgeDomainsTopo.addNode(this.tableContent[x]);
- this.injectedInterfaces.push(this.tableContent[x]);
- }
- }
-
- var nodes = [{
- name : this.selectedBd.name,
- label: this.selectedBd.name,
- type:'bd',
- x: 0,
- y: 0,
- scale: 1
- }].concat(this.injectedInterfaces);
-
- var links = [];
- for (var x=1; x<nodes.length; x++){
- links.push({'source':0, 'target': x});
- }
-
- var topoData = {
- nodes: nodes,
- links: links
- };
-
- this.bridgeDomainsTopo.data(topoData);
- };
-
- this.injectBridgeDomainsTopoElements = function() {
- this.clearTopology();
- this.setData();
- self.bridgeDomainsTopo.adaptToContainer();
- };
}]);
Code Review / honeycomb.git / commitdiff