blob: a8f0570017dfeb5e43453bc9023b75521cc88489 [file] [log] [blame]
/*
* Copyright 2014 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
ONOS network topology viewer - version 1.1
*/
(function (onos) {
'use strict';
// shorter names for library APIs
var d3u = onos.lib.d3util,
gly = onos.lib.glyphs;
// configuration data
var config = {
useLiveData: true,
fnTrace: true,
debugOn: false,
birdDim: 400,
options: {
showBackground: true
},
webSockUrl: '../ws/topology',
data: {
live: {
jsonUrl: '../rs/topology/graph',
detailPrefix: '../rs/topology/graph/',
detailSuffix: ''
},
fake: {
jsonUrl: 'json/network2.json',
detailPrefix: 'json/',
detailSuffix: '.json'
}
},
labels: {
imgPad: 16,
padLR: 4,
padTB: 3,
marginLR: 3,
marginTB: 2,
port: {
gap: 3,
width: 18,
height: 14
}
},
topo: {
linkBaseColor: '#666',
linkInColor: '#66f',
linkInWidth: 12,
linkOutColor: '#f00',
linkOutWidth: 10
},
icons: {
device: {
dim: 36,
rx: 4,
xoff: -20,
yoff: -18
},
host: {
defaultRadius: 9,
radius: {
endstation: 14,
bgpSpeaker: 14,
router: 14
}
}
},
force: {
note_for_links: 'link.type is used to differentiate',
linkDistance: {
direct: 100,
optical: 120,
hostLink: 3
},
linkStrength: {
direct: 1.0,
optical: 1.0,
hostLink: 1.0
},
note_for_nodes: 'node.class is used to differentiate',
charge: {
device: -8000,
host: -5000
}
},
// see below in creation of viewBox on main svg
logicalSize: 1000
};
// radio buttons
var layerButtons = [
{ text: 'All Layers', id: 'all', cb: showAllLayers },
{ text: 'Packet Only', id: 'pkt', cb: showPacketLayer },
{ text: 'Optical Only', id: 'opt', cb: showOpticalLayer }
],
layerBtnSet,
layerBtnDispatch = {
all: showAllLayers,
pkt: showPacketLayer,
opt: showOpticalLayer
};
// key bindings
var keyDispatch = {
// ==== "development mode" ====
//0: testMe,
//equals: injectStartupEvents,
//dash: injectTestEvent,
O: [toggleSummary, 'Toggle ONOS summary pane'],
I: [toggleInstances, 'Toggle ONOS instances pane'],
D: [toggleDetails, 'Disable / enable details pane'],
H: [toggleHosts, 'Toggle host visibility'],
M: [toggleOffline, 'Toggle offline visibility'],
B: [toggleBg, 'Toggle background image'],
P: togglePorts,
X: [toggleNodeLock, 'Lock / unlock node positions'],
Z: [toggleOblique, 'Toggle oblique view (Experimental)'],
L: [cycleLabels, 'Cycle device labels'],
U: [unpin, 'Unpin node (hover mouse over)'],
R: [resetPanZoom, 'Reset pan / zoom'],
V: [showRelatedIntentsAction, 'Show all related intents'],
rightArrow: [showNextIntentAction, 'Show next related intent'],
leftArrow: [showPrevIntentAction, 'Show previous related intent'],
W: [showSelectedIntentTrafficAction, 'Monitor traffic of selected intent'],
A: [showAllTrafficAction, 'Monitor all traffic'],
F: [showDeviceLinkFlowsAction, 'Show device link flows'],
E: [equalizeMasters, 'Equalize mastership roles'],
esc: handleEscape,
_helpFormat: [
['O', 'I', 'D', '-', 'H', 'M', 'B', 'P' ],
['X', 'Z', 'L', 'U', 'R' ],
['V', 'rightArrow', 'leftArrow', 'W', 'A', 'F', '-', 'E' ]
]
};
// mouse gestures
var gestures = [
['click', 'Select the item and show details'],
['shift-click', 'Toggle selection state'],
['drag', 'Reposition (and pin) device / host'],
['cmd-scroll', 'Zoom in / out'],
['cmd-drag', 'Pan']
];
// state variables
var network = {
view: null, // view token reference
nodes: [],
links: [],
lookup: {},
revLinkToKey: {}
},
scenario = {
evDir: 'json/ev/',
evScenario: '/scenario.json',
evPrefix: '/ev_',
evOnos: '_onos.json',
evUi: '_ui.json',
ctx: null,
params: {},
evNumber: 0,
view: null
},
webSock,
sid = 0,
deviceLabelCount = 3,
hostLabelCount = 2,
deviceLabelIndex = 0,
hostLabelIndex = 0,
selections = {},
selectOrder = [],
hovered = null,
summaryPane,
detailPane,
antTimer = null,
guiSuccessor = null,
onosInstances = {},
onosOrder = [],
oiBox,
oiShowMaster = false,
portLabelsOn = false,
cat7 = d3u.cat7(),
colorAffinity = false,
showHosts = false,
showOffline = true,
useDetails = true,
haveDetails = false,
nodeLock = false,
oblique = false;
// constants
var hoverModeNone = 0,
hoverModeAll = 1,
hoverModeFlows = 2,
hoverModeIntents = 3,
hoverMode = hoverModeNone;
// D3 selections
var svg,
panZoomContainer,
noDevices,
bgImg,
topoG,
nodeG,
linkG,
linkLabelG,
node,
link,
linkLabel,
mask;
// the projection for the map background
var geoMapProj;
// the zoom function
var zoom;
// ==============================
// For Debugging / Development
function fnTrace(msg, id) {
if (config.fnTrace) {
console.log('FN: ' + msg + ' [' + id + ']');
}
}
function evTrace(data) {
fnTrace(data.event, data.payload.id);
}
// ==============================
// Key Callbacks
function flash(txt) {
network.view.flash(txt);
}
function testMe(view) {
//view.alert('Theme is ' + view.getTheme());
//view.flash('This is some text');
cat7.testCard(svg);
}
function injectTestEvent(view) {
if (config.useLiveData) { return; }
var sc = scenario,
evn = ++sc.evNumber,
pfx = sc.evDir + sc.ctx + sc.evPrefix + evn,
onosUrl = pfx + sc.evOnos,
uiUrl = pfx + sc.evUi,
stack = [
{ url: onosUrl, cb: handleServerEvent },
{ url: uiUrl, cb: handleUiEvent }
];
recurseFetchEvent(stack, evn);
}
function recurseFetchEvent(stack, evn) {
var v = scenario.view,
frame;
if (stack.length === 0) {
v.alert('Oops!\n\nNo event #' + evn + ' found.');
return;
}
frame = stack.shift();
d3.json(frame.url, function (err, data) {
if (err) {
if (err.status === 404) {
// if we didn't find the data, try the next stack frame
recurseFetchEvent(stack, evn);
} else {
v.alert('non-404 error:\n\n' + frame.url + '\n\n' + err);
}
} else {
wsTrace('test', JSON.stringify(data));
frame.cb(data);
}
});
}
function handleUiEvent(data) {
scenario.view.alert('UI Tx: ' + data.event + '\n\n' +
JSON.stringify(data));
}
function injectStartupEvents(view) {
var last = scenario.params.lastAuto || 0;
if (config.useLiveData) { return; }
while (scenario.evNumber < last) {
injectTestEvent(view);
}
}
function toggleBg() {
var vis = bgImg.style('visibility');
bgImg.style('visibility', visVal(vis === 'hidden'));
}
function opacifyBg(b) {
bgImg.transition()
.duration(1000)
.attr('opacity', b ? 1 : 0);
}
function toggleNodeLock() {
nodeLock = !nodeLock;
flash('Node positions ' + (nodeLock ? 'locked' : 'unlocked'))
}
function toggleOblique() {
oblique = !oblique;
if (oblique) {
network.force.stop();
toObliqueView();
} else {
toNormalView();
}
}
function toggleHosts() {
showHosts = !showHosts;
updateHostVisibility();
flash('Hosts ' + visVal(showHosts));
}
function toggleOffline() {
showOffline = !showOffline;
updateOfflineVisibility();
flash('Offline devices ' + visVal(showOffline));
}
function cycleLabels() {
deviceLabelIndex = (deviceLabelIndex === 2)
? 0 : deviceLabelIndex + 1;
network.nodes.forEach(function (d) {
if (d.class === 'device') {
updateDeviceLabel(d);
}
});
}
function togglePorts(view) {
//view.alert('togglePorts() callback')
}
function unpin() {
if (hovered) {
sendUpdateMeta(hovered);
hovered.fixed = false;
hovered.el.classed('fixed', false);
fResume();
}
}
function handleEscape(view) {
if (oiShowMaster) {
cancelAffinity();
} else if (haveDetails) {
deselectAll();
} else if (oiBox.isVisible()) {
hideInstances();
} else if (summaryPane.isVisible()) {
cancelSummary();
stopAntTimer();
} else {
hoverMode = hoverModeNone;
}
}
function showNoDevs(b) {
noDevices.style('visibility', visVal(b));
}
// ==============================
// Oblique view ...
var obview = {
tt: -.7, // x skew y factor
xsk: -35, // x skew angle
ysc: 0.5, // y scale
pad: 50,
time: 1500,
fill: {
pkt: 'rgba(130,130,170,0.3)',
opt: 'rgba(170,130,170,0.3)'
},
id: function (tag) {
return 'obview-' + tag + 'Plane';
},
yt: function (h, dir) {
return h * obview.ysc * dir * 1.1;
},
obXform: function (h, dir) {
var yt = obview.yt(h, dir);
return scale(1, obview.ysc) + translate(0, yt) + skewX(obview.xsk);
},
noXform: function () {
return skewX(0) + translate(0,0) + scale(1,1);
},
xffn: null,
plane: {}
};
function toObliqueView() {
var box = nodeG.node().getBBox(),
ox, oy;
padBox(box, obview.pad);
ox = box.x + box.width / 2;
oy = box.y + box.height / 2;
// remember node lock state, then lock the nodes down
obview.nodeLock = nodeLock;
nodeLock = true;
opacifyBg(false);
insertPlanes(ox, oy);
obview.xffn = function (xy, dir) {
var yt = obview.yt(box.height, dir),
ax = xy.x - ox,
ay = xy.y - oy,
x = ax + ay * obview.tt,
y = ay * obview.ysc + obview.ysc * yt;
return {x: ox + x, y: oy + y};
};
showPlane('pkt', box, -1);
showPlane('opt', box, 1);
obTransitionNodes();
}
function toNormalView() {
obview.xffn = null;
hidePlane('pkt');
hidePlane('opt');
obTransitionNodes();
removePlanes();
// restore node lock state
nodeLock = obview.nodeLock;
opacifyBg(true);
}
function obTransitionNodes() {
var xffn = obview.xffn;
// return the direction for the node
// -1 for pkt layer, 1 for optical layer
function dir(d) {
return inLayer(d, 'pkt') ? -1 : 1;
}
if (xffn) {
network.nodes.forEach(function (d) {
var oldxy = {x: d.x, y: d.y},
coords = xffn(oldxy, dir(d));
d.oldxy = oldxy;
d.px = d.x = coords.x;
d.py = d.y = coords.y;
});
} else {
network.nodes.forEach(function (d) {
var old = d.oldxy || {x: d.x, y: d.y};
d.px = d.x = old.x;
d.py = d.y = old.y;
delete d.oldxy;
});
}
node.transition()
.duration(obview.time)
.attr(tickStuff.nodeAttr);
link.transition()
.duration(obview.time)
.attr(tickStuff.linkAttr);
linkLabel.transition()
.duration(obview.time)
.attr(tickStuff.linkLabelAttr);
}
function showPlane(tag, box, dir) {
var g = obview.plane[tag];
// set box origin at center..
box.x = -box.width/2;
box.y = -box.height/2;
g.select('rect')
.attr(box)
.attr('opacity', 0)
.transition()
.duration(obview.time)
.attr('opacity', 1)
.attr('transform', obview.obXform(box.height, dir));
}
function hidePlane(tag) {
var g = obview.plane[tag];
g.select('rect')
.transition()
.duration(obview.time)
.attr('opacity', 0)
.attr('transform', obview.noXform());
}
function insertPlanes(ox, oy) {
function ins(tag) {
var id = obview.id(tag),
g = panZoomContainer.insert('g', '#topo-G')
.attr('id', id)
.attr('transform', translate(ox,oy));
g.append('rect')
.attr('fill', obview.fill[tag])
.attr('opacity', 0);
obview.plane[tag] = g;
}
ins('opt');
ins('pkt');
}
function removePlanes() {
function rem(tag) {
var id = obview.id(tag);
panZoomContainer.select('#'+id)
.transition()
.duration(obview.time + 50)
.remove();
delete obview.plane[tag];
}
rem('opt');
rem('pkt');
}
function padBox(box, p) {
box.x -= p;
box.y -= p;
box.width += p*2;
box.height += p*2;
}
// ==============================
// Radio Button Callbacks
var layerLookup = {
host: {
endstation: 'pkt', // default, if host event does not define type
router: 'pkt',
bgpSpeaker: 'pkt'
},
device: {
switch: 'pkt',
roadm: 'opt'
},
link: {
hostLink: 'pkt',
direct: 'pkt',
indirect: '',
tunnel: '',
optical: 'opt'
}
};
function inLayer(d, layer) {
var type = d.class === 'link' ? d.type() : d.type,
look = layerLookup[d.class],
lyr = look && look[type];
return lyr === layer;
}
function unsuppressLayer(which) {
node.each(function (d) {
var node = d.el;
if (inLayer(d, which)) {
node.classed('suppressed', false);
}
});
link.each(function (d) {
var link = d.el;
if (inLayer(d, which)) {
link.classed('suppressed', false);
}
});
}
function suppressLayers(b) {
node.classed('suppressed', b);
link.classed('suppressed', b);
// d3.selectAll('svg .port').classed('inactive', false);
// d3.selectAll('svg .portText').classed('inactive', false);
}
function showAllLayers() {
suppressLayers(false);
}
function showPacketLayer() {
node.classed('suppressed', true);
link.classed('suppressed', true);
unsuppressLayer('pkt');
}
function showOpticalLayer() {
node.classed('suppressed', true);
link.classed('suppressed', true);
unsuppressLayer('opt');
}
function restoreLayerState() {
layerBtnDispatch[layerBtnSet.selected()]();
}
// ==============================
// Private functions
function safeId(s) {
return s.replace(/[^a-z0-9]/gi, '-');
}
// set the size of the given element to that of the view (reduced if padded)
function setSize(el, view, pad) {
var padding = pad ? pad * 2 : 0;
el.attr({
width: view.width() - padding,
height: view.height() - padding
});
}
function makeNodeKey(d, what) {
var port = what + 'Port';
return d[what] + '/' + d[port];
}
function makeLinkKey(d, flipped) {
var one = flipped ? makeNodeKey(d, 'dst') : makeNodeKey(d, 'src'),
two = flipped ? makeNodeKey(d, 'src') : makeNodeKey(d, 'dst');
return one + '-' + two;
}
function findLinkById(id) {
// check to see if this is a reverse lookup, else default to given id
var key = network.revLinkToKey[id] || id;
return key && network.lookup[key];
}
function findLink(linkData, op) {
var key = makeLinkKey(linkData),
keyrev = makeLinkKey(linkData, 1),
link = network.lookup[key],
linkRev = network.lookup[keyrev],
result = {},
ldata = link || linkRev,
rawLink;
if (op === 'add') {
if (link) {
// trying to add a link that we already know about
result.ldata = link;
result.badLogic = 'addLink: link already added';
} else if (linkRev) {
// we found the reverse of the link to be added
result.ldata = linkRev;
if (linkRev.fromTarget) {
result.badLogic = 'addLink: link already added';
}
}
} else if (op === 'update') {
if (!ldata) {
result.badLogic = 'updateLink: link not found';
} else {
rawLink = link ? ldata.fromSource : ldata.fromTarget;
result.updateWith = function (data) {
$.extend(rawLink, data);
restyleLinkElement(ldata);
}
}
} else if (op === 'remove') {
if (!ldata) {
result.badLogic = 'removeLink: link not found';
} else {
rawLink = link ? ldata.fromSource : ldata.fromTarget;
if (!rawLink) {
result.badLogic = 'removeLink: link not found';
} else {
result.removeRawLink = function () {
if (link) {
// remove fromSource
ldata.fromSource = null;
if (ldata.fromTarget) {
// promote target into source position
ldata.fromSource = ldata.fromTarget;
ldata.fromTarget = null;
ldata.key = keyrev;
delete network.lookup[key];
network.lookup[keyrev] = ldata;
delete network.revLinkToKey[keyrev];
}
} else {
// remove fromTarget
ldata.fromTarget = null;
delete network.revLinkToKey[keyrev];
}
if (ldata.fromSource) {
restyleLinkElement(ldata);
} else {
removeLinkElement(ldata);
}
}
}
}
}
return result;
}
function addLinkUpdate(ldata, link) {
// add link event, but we already have the reverse link installed
ldata.fromTarget = link;
network.revLinkToKey[link.id] = ldata.key;
restyleLinkElement(ldata);
}
var allLinkTypes = 'direct indirect optical tunnel',
defaultLinkType = 'direct';
function restyleLinkElement(ldata) {
// this fn's job is to look at raw links and decide what svg classes
// need to be applied to the line element in the DOM
var el = ldata.el,
type = ldata.type(),
lw = ldata.linkWidth(),
online = ldata.online();
el.classed('link', true);
el.classed('inactive', !online);
el.classed(allLinkTypes, false);
if (type) {
el.classed(type, true);
}
el.transition()
.duration(1000)
.attr('stroke-width', linkScale(lw))
.attr('stroke', config.topo.linkBaseColor);
}
// ==============================
// Event handlers for server-pushed events
function logicError(msg) {
// TODO, report logic error to server, via websock, so it can be logged
console.warn(msg);
}
var eventDispatch = {
addInstance: addInstance,
addDevice: addDevice,
addLink: addLink,
addHost: addHost,
updateInstance: updateInstance,
updateDevice: updateDevice,
updateLink: updateLink,
updateHost: updateHost,
removeInstance: removeInstance,
removeDevice: removeDevice,
removeLink: removeLink,
removeHost: removeHost,
showDetails: showDetails,
showSummary: showSummary,
showTraffic: showTraffic
};
function addInstance(data) {
evTrace(data);
var inst = data.payload,
id = inst.id;
if (onosInstances[id]) {
updateInstance(data);
return;
}
onosInstances[id] = inst;
onosOrder.push(inst);
updateInstances();
}
function addDevice(data) {
evTrace(data);
var device = data.payload,
id = device.id,
d;
showNoDevs(false);
if (network.lookup[id]) {
updateDevice(data);
return;
}
d = createDeviceNode(device);
network.nodes.push(d);
network.lookup[id] = d;
updateNodes();
fStart();
}
function addLink(data) {
evTrace(data);
var link = data.payload,
result = findLink(link, 'add'),
bad = result.badLogic,
d = result.ldata;
if (bad) {
logicError(bad + ': ' + link.id);
return;
}
if (d) {
// we already have a backing store link for src/dst nodes
addLinkUpdate(d, link);
return;
}
// no backing store link yet
d = createLink(link);
if (d) {
network.links.push(d);
network.lookup[d.key] = d;
updateLinks();
fStart();
}
}
function addHost(data) {
evTrace(data);
var host = data.payload,
id = host.id,
d,
lnk;
if (network.lookup[id]) {
logicError('Host already added: ' + id);
return;
}
d = createHostNode(host);
network.nodes.push(d);
network.lookup[host.id] = d;
updateNodes();
lnk = createHostLink(host);
if (lnk) {
d.linkData = lnk; // cache ref on its host
network.links.push(lnk);
network.lookup[d.ingress] = lnk;
network.lookup[d.egress] = lnk;
updateLinks();
}
fStart();
}
function updateInstance(data) {
evTrace(data);
var inst = data.payload,
id = inst.id,
d = onosInstances[id];
if (d) {
$.extend(d, inst);
updateInstances();
} else {
logicError('updateInstance lookup fail. ID = "' + id + '"');
}
}
function updateDevice(data) {
evTrace(data);
var device = data.payload,
id = device.id,
d = network.lookup[id],
wasOnline;
if (d) {
wasOnline = d.online;
$.extend(d, device);
if (positionNode(d, true)) {
sendUpdateMeta(d, true);
}
updateNodes();
if (wasOnline !== d.online) {
findAttachedLinks(d.id).forEach(restyleLinkElement);
updateOfflineVisibility(d);
}
} else {
logicError('updateDevice lookup fail. ID = "' + id + '"');
}
}
function updateLink(data) {
evTrace(data);
var link = data.payload,
result = findLink(link, 'update'),
bad = result.badLogic;
if (bad) {
logicError(bad + ': ' + link.id);
return;
}
result.updateWith(link);
}
function updateHost(data) {
evTrace(data);
var host = data.payload,
id = host.id,
d = network.lookup[id];
if (d) {
$.extend(d, host);
if (positionNode(d, true)) {
sendUpdateMeta(d, true);
}
updateNodes(d);
} else {
logicError('updateHost lookup fail. ID = "' + id + '"');
}
}
function removeInstance(data) {
evTrace(data);
var inst = data.payload,
id = inst.id,
d = onosInstances[id];
if (d) {
var idx = find(id, onosOrder);
if (idx >= 0) {
onosOrder.splice(idx, 1);
}
delete onosInstances[id];
updateInstances();
} else {
logicError('updateInstance lookup fail. ID = "' + id + '"');
}
}
function removeDevice(data) {
evTrace(data);
var device = data.payload,
id = device.id,
d = network.lookup[id];
if (d) {
removeDeviceElement(d);
} else {
logicError('removeDevice lookup fail. ID = "' + id + '"');
}
}
function removeLink(data) {
evTrace(data);
var link = data.payload,
result = findLink(link, 'remove'),
bad = result.badLogic;
if (bad) {
// may have already removed link, if attached to removed device
console.warn(bad + ': ' + link.id);
return;
}
result.removeRawLink();
}
function removeHost(data) {
evTrace(data);
var host = data.payload,
id = host.id,
d = network.lookup[id];
if (d) {
removeHostElement(d, true);
} else {
// may have already removed host, if attached to removed device
console.warn('removeHost lookup fail. ID = "' + id + '"');
}
}
// the following events are server responses to user actions
function showSummary(data) {
evTrace(data);
populateSummary(data.payload);
showSummaryPane();
}
function showDetails(data) {
evTrace(data);
haveDetails = true;
populateDetails(data.payload);
if (useDetails) {
showDetailPane();
}
}
function showTraffic(data) {
evTrace(data);
var paths = data.payload.paths,
hasTraffic = false;
// Revert any links hilighted previously.
link.style('stroke-width', null)
.classed('primary secondary animated optical', false);
// Remove all previous labels.
removeLinkLabels();
// Now hilight all links in the paths payload, and attach
// labels to them, if they are defined.
paths.forEach(function (p) {
var n = p.links.length,
i,
ldata;
hasTraffic = hasTraffic || p.traffic;
for (i=0; i<n; i++) {
ldata = findLinkById(p.links[i]);
if (ldata && ldata.el) {
ldata.el.classed(p.class, true);
ldata.label = p.labels[i];
}
}
});
updateLinks();
if (hasTraffic && !antTimer) {
startAntTimer();
} else if (!hasTraffic && antTimer) {
stopAntTimer();
}
}
// ...............................
function unknownEvent(data) {
console.warn('Unknown event type: "' + data.event + '"', data);
}
function handleServerEvent(data) {
var fn = eventDispatch[data.event] || unknownEvent;
fn(data);
}
// ==============================
// Out-going messages...
function nSel() {
return selectOrder.length;
}
function getSel(idx) {
return selections[selectOrder[idx]];
}
function allSelectionsClass(cls) {
for (var i=0, n=nSel(); i<n; i++) {
if (getSel(i).obj.class !== cls) {
return false;
}
}
return true;
}
function toggleInstances() {
if (!oiBox.isVisible()) {
showInstances();
} else {
hideInstances();
}
}
function showInstances() {
oiBox.show();
colorAffinity = true;
updateDeviceColors();
}
function hideInstances() {
oiBox.hide();
colorAffinity = false;
cancelAffinity();
updateDeviceColors();
}
function equalizeMasters() {
sendMessage('equalizeMasters');
flash('Equalizing master roles');
}
function toggleSummary() {
if (!summaryPane.isVisible()) {
requestSummary();
} else {
cancelSummary();
}
}
function requestSummary() {
sendMessage('requestSummary');
}
function cancelSummary() {
sendMessage('cancelSummary');
hideSummaryPane();
}
function toggleDetails() {
useDetails = !useDetails;
if (useDetails) {
flash('Enable details pane');
if (haveDetails) {
showDetailPane();
}
} else {
flash('Disable details pane');
hideDetailPane();
}
}
// encapsulate interaction between summary and details panes
function showSummaryPane() {
if (detailPane.isVisible()) {
detailPane.down(summaryPane.show);
} else {
summaryPane.show();
}
}
function hideSummaryPane() {
summaryPane.hide(function () {
if (detailPane.isVisible()) {
detailPane.up();
}
});
}
function showDetailPane() {
if (summaryPane.isVisible()) {
detailPane.down(detailPane.show);
} else {
detailPane.up(detailPane.show);
}
}
function hideDetailPane() {
detailPane.hide();
}
// request details for the selected element
// invoked from selection of a single node.
function requestDetails() {
var data = getSel(0).obj;
sendMessage('requestDetails', {
id: data.id,
class: data.class
});
}
function addHostIntentAction() {
sendMessage('addHostIntent', {
one: selectOrder[0],
two: selectOrder[1],
ids: selectOrder
});
flash('Host-to-Host flow added');
}
function addMultiSourceIntentAction() {
sendMessage('addMultiSourceIntent', {
src: selectOrder.slice(0, selectOrder.length - 1),
dst: selectOrder[selectOrder.length - 1],
ids: selectOrder
});
flash('Multi-Source flow added');
}
function cancelTraffic() {
sendMessage('cancelTraffic');
}
function requestTrafficForMode() {
if (hoverMode === hoverModeFlows) {
requestDeviceLinkFlows();
} else if (hoverMode === hoverModeIntents) {
requestRelatedIntents();
}
}
function showRelatedIntentsAction() {
hoverMode = hoverModeIntents;
requestRelatedIntents();
flash('Related Paths');
}
function requestRelatedIntents() {
function hoverValid() {
return hoverMode === hoverModeIntents &&
hovered &&
(hovered.class === 'host' || hovered.class === 'device');
}
if (validateSelectionContext()) {
sendMessage('requestRelatedIntents', {
ids: selectOrder,
hover: hoverValid() ? hovered.id : ''
});
}
}
function showNextIntentAction() {
hoverMode = hoverModeNone;
sendMessage('requestNextRelatedIntent');
flash('>');
}
function showPrevIntentAction() {
hoverMode = hoverModeNone;
sendMessage('requestPrevRelatedIntent');
flash('<');
}
function showSelectedIntentTrafficAction() {
hoverMode = hoverModeNone;
sendMessage('requestSelectedIntentTraffic');
flash('Traffic on Selected Path');
}
function showDeviceLinkFlowsAction() {
hoverMode = hoverModeFlows;
requestDeviceLinkFlows();
flash('Device Flows');
}
function requestDeviceLinkFlows() {
function hoverValid() {
return hoverMode === hoverModeFlows &&
hovered && (hovered.class === 'device');
}
if (validateSelectionContext()) {
sendMessage('requestDeviceLinkFlows', {
ids: selectOrder,
hover: hoverValid() ? hovered.id : ''
});
}
}
function showAllTrafficAction() {
hoverMode = hoverModeAll;
requestAllTraffic();
flash('All Traffic');
}
function requestAllTraffic() {
sendMessage('requestAllTraffic');
}
function validateSelectionContext() {
if (!hovered && nSel() === 0) {
cancelTraffic();
return false;
}
return true;
}
// ==============================
// onos instance panel functions
var instCfg = {
rectPad: 8,
nodeOx: 9,
nodeOy: 9,
nodeDim: 40,
birdOx: 19,
birdOy: 21,
birdDim: 21,
uiDy: 45,
titleDy: 30,
textYOff: 20,
textYSpc: 15
};
function viewBox(dim) {
return '0 0 ' + dim.w + ' ' + dim.h;
}
function instRectAttr(dim) {
var pad = instCfg.rectPad;
return {
x: pad,
y: pad,
width: dim.w - pad*2,
height: dim.h - pad*2,
rx: 6
};
}
function computeDim(self) {
var css = window.getComputedStyle(self);
return {
w: stripPx(css.width),
h: stripPx(css.height)
};
}
function updateInstances() {
var onoses = oiBox.el.selectAll('.onosInst')
.data(onosOrder, function (d) { return d.id; }),
instDim = {w:0,h:0},
c = instCfg;
function nSw(n) {
return '# Switches: ' + n;
}
// operate on existing onos instances if necessary
onoses.each(function (d) {
var el = d3.select(this),
svg = el.select('svg');
instDim = computeDim(this);
// update online state
el.classed('online', d.online);
// update ui-attached state
svg.select('use.uiBadge').remove();
if (d.uiAttached) {
attachUiBadge(svg);
}
function updAttr(id, value) {
svg.select('text.instLabel.'+id).text(value);
}
updAttr('ip', d.ip);
updAttr('ns', nSw(d.switches));
});
// operate on new onos instances
var entering = onoses.enter()
.append('div')
.attr('class', 'onosInst')
.classed('online', function (d) { return d.online; })
.on('click', clickInst);
entering.each(function (d) {
var el = d3.select(this),
rectAttr,
svg;
instDim = computeDim(this);
rectAttr = instRectAttr(instDim);
svg = el.append('svg').attr({
width: instDim.w,
height: instDim.h,
viewBox: viewBox(instDim)
});
svg.append('rect').attr(rectAttr);
appendBadge(svg, 14, 14, 28, '#bird');
if (d.uiAttached) {
attachUiBadge(svg);
}
var left = c.nodeOx + c.nodeDim,
len = rectAttr.width - left,
hlen = len / 2,
midline = hlen + left;
// title
svg.append('text')
.attr({
class: 'instTitle',
x: midline,
y: c.titleDy
})
.text(d.id);
// a couple of attributes
var ty = c.titleDy + c.textYOff;
function addAttr(id, label) {
svg.append('text').attr({
class: 'instLabel ' + id,
x: midline,
y: ty
}).text(label);
ty += c.textYSpc;
}
addAttr('ip', d.ip);
addAttr('ns', nSw(d.switches));
});
// operate on existing + new onoses here
// set the affinity colors...
onoses.each(function (d) {
var el = d3.select(this),
rect = el.select('svg').select('rect'),
col = instColor(d.id, d.online);
rect.style('fill', col);
});
// adjust the panel size appropriately...
oiBox.width(instDim.w * onosOrder.length);
oiBox.height(instDim.h);
// remove any outgoing instances
onoses.exit().remove();
}
function instColor(id, online) {
return cat7.get(id, !online, network.view.getTheme());
}
function clickInst(d) {
var el = d3.select(this),
aff = el.classed('affinity');
if (!aff) {
setAffinity(el, d);
} else {
cancelAffinity();
}
}
function setAffinity(el, d) {
d3.selectAll('.onosInst')
.classed('mastership', true)
.classed('affinity', false);
el.classed('affinity', true);
suppressLayers(true);
node.each(function (n) {
if (n.master === d.id) {
n.el.classed('suppressed', false);
}
});
oiShowMaster = true;
}
function cancelAffinity() {
d3.selectAll('.onosInst')
.classed('mastership affinity', false);
restoreLayerState();
oiShowMaster = false;
}
// TODO: these should be moved out to utility module.
function stripPx(s) {
return s.replace(/px$/,'');
}
function appendUse(svg, ox, oy, dim, iid, cls) {
var use = svg.append('use').attr({
transform: translate(ox,oy),
'xlink:href': iid,
width: dim,
height: dim
});
if (cls) {
use.classed(cls, true);
}
return use;
}
function appendGlyph(svg, ox, oy, dim, iid, cls) {
appendUse(svg, ox, oy, dim, iid, cls).classed('glyphIcon', true);
}
function appendBadge(svg, ox, oy, dim, iid, cls) {
appendUse(svg, ox, oy, dim, iid, cls).classed('badgeIcon', true);
}
function attachUiBadge(svg) {
appendBadge(svg, 12, instCfg.uiDy, 30, '#uiAttached', 'uiBadge');
}
function visVal(b) {
return b ? 'visible' : 'hidden';
}
// ==============================
// force layout modification functions
function translate(x, y) {
return 'translate(' + x + ',' + y + ')';
}
function scale(x,y) {
return 'scale(' + x + ',' + y + ')';
}
function skewX(x) {
return 'skewX(' + x + ')';
}
function rotate(deg) {
return 'rotate(' + deg + ')';
}
function missMsg(what, id) {
return '\n[' + what + '] "' + id + '" missing ';
}
function linkEndPoints(srcId, dstId) {
var srcNode = network.lookup[srcId],
dstNode = network.lookup[dstId],
sMiss = !srcNode ? missMsg('src', srcId) : '',
dMiss = !dstNode ? missMsg('dst', dstId) : '';
if (sMiss || dMiss) {
logicError('Node(s) not on map for link:\n' + sMiss + dMiss);
return null;
}
return {
source: srcNode,
target: dstNode,
x1: srcNode.x,
y1: srcNode.y,
x2: dstNode.x,
y2: dstNode.y
};
}
function createHostLink(host) {
var src = host.id,
dst = host.cp.device,
id = host.ingress,
lnk = linkEndPoints(src, dst);
if (!lnk) {
return null;
}
// Synthesize link ...
$.extend(lnk, {
key: id,
class: 'link',
type: function () { return 'hostLink'; },
online: function () {
// hostlink target is edge switch
return lnk.target.online;
},
linkWidth: function () { return 1; }
});
return lnk;
}
function createLink(link) {
var lnk = linkEndPoints(link.src, link.dst);
if (!lnk) {
return null;
}
$.extend(lnk, {
key: link.id,
class: 'link',
fromSource: link,
// functions to aggregate dual link state
type: function () {
var s = lnk.fromSource,
t = lnk.fromTarget;
return (s && s.type) || (t && t.type) || defaultLinkType;
},
online: function () {
var s = lnk.fromSource,
t = lnk.fromTarget,
both = lnk.source.online && lnk.target.online;
return both && ((s && s.online) || (t && t.online));
},
linkWidth: function () {
var s = lnk.fromSource,
t = lnk.fromTarget,
ws = (s && s.linkWidth) || 0,
wt = (t && t.linkWidth) || 0;
return Math.max(ws, wt);
}
});
return lnk;
}
function removeLinkLabels() {
network.links.forEach(function (d) {
d.label = '';
});
}
function showHostVis(el) {
el.style('visibility', visVal(showHosts));
}
var widthRatio = 1.4,
linkScale = d3.scale.linear()
.domain([1, 12])
.range([widthRatio, 12 * widthRatio])
.clamp(true);
function updateLinks() {
link = linkG.selectAll('.link')
.data(network.links, function (d) { return d.key; });
// operate on existing links, if necessary
// link .foo() .bar() ...
// operate on entering links:
var entering = link.enter()
.append('line')
.attr({
x1: function (d) { return d.x1; },
y1: function (d) { return d.y1; },
x2: function (d) { return d.x2; },
y2: function (d) { return d.y2; },
stroke: config.topo.linkInColor,
'stroke-width': config.topo.linkInWidth
});
// augment links
entering.each(function (d) {
var link = d3.select(this);
// provide ref to element selection from backing data....
d.el = link;
restyleLinkElement(d);
if (d.type() === 'hostLink') {
showHostVis(link);
}
});
// operate on both existing and new links, if necessary
//link .foo() .bar() ...
// apply or remove labels
var labelData = getLabelData();
applyLinkLabels(labelData);
// operate on exiting links:
link.exit()
.attr('stroke-dasharray', '3 3')
.style('opacity', 0.5)
.transition()
.duration(1500)
.attr({
'stroke-dasharray': '3 12',
stroke: config.topo.linkOutColor,
'stroke-width': config.topo.linkOutWidth
})
.style('opacity', 0.0)
.remove();
// NOTE: invoke a single tick to force the labels to position
// onto their links.
tick();
}
function getLabelData() {
// create the backing data for showing labels..
var data = [];
link.each(function (d) {
if (d.label) {
data.push({
id: 'lab-' + d.key,
key: d.key,
label: d.label,
ldata: d
});
}
});
return data;
}
var linkLabelOffset = '0.3em';
function applyLinkLabels(data) {
var entering;
linkLabel = linkLabelG.selectAll('.linkLabel')
.data(data, function (d) { return d.id; });
// for elements already existing, we need to update the text
// and adjust the rectangle size to fit
linkLabel.each(function (d) {
var el = d3.select(this),
rect = el.select('rect'),
text = el.select('text');
text.text(d.label);
rect.attr(rectAroundText(el));
});
entering = linkLabel.enter().append('g')
.classed('linkLabel', true)
.attr('id', function (d) { return d.id; });
entering.each(function (d) {
var el = d3.select(this),
rect,
text,
parms = {
x1: d.ldata.x1,
y1: d.ldata.y1,
x2: d.ldata.x2,
y2: d.ldata.y2
};
d.el = el;
rect = el.append('rect');
text = el.append('text').text(d.label);
rect.attr(rectAroundText(el));
text.attr('dy', linkLabelOffset);
el.attr('transform', transformLabel(parms));
});
// Remove any labels that are no longer required.
linkLabel.exit().remove();
}
function rectAroundText(el) {
var text = el.select('text'),
box = text.node().getBBox();
// translate the bbox so that it is centered on [x,y]
box.x = -box.width / 2;
box.y = -box.height / 2;
// add padding
box.x -= 1;
box.width += 2;
return box;
}
function transformLabel(p) {
var dx = p.x2 - p.x1,
dy = p.y2 - p.y1,
xMid = dx/2 + p.x1,
yMid = dy/2 + p.y1;
return translate(xMid, yMid);
}
function createDeviceNode(device) {
// start with the object as is
var node = device,
type = device.type,
svgCls = type ? 'node device ' + type : 'node device';
// Augment as needed...
node.class = 'device';
node.svgClass = device.online ? svgCls + ' online' : svgCls;
positionNode(node);
return node;
}
function createHostNode(host) {
// start with the object as is
var node = host;
// Augment as needed...
node.class = 'host';
if (!node.type) {
node.type = 'endstation';
}
node.svgClass = 'node host ' + node.type;
positionNode(node);
return node;
}
function positionNode(node, forUpdate) {
var meta = node.metaUi,
x = meta && meta.x,
y = meta && meta.y,
xy;
// If we have [x,y] already, use that...
if (x && y) {
node.fixed = true;
node.px = node.x = x;
node.py = node.y = y;
return;
}
var location = node.location;
if (location && location.type === 'latlng') {
var coord = geoMapProj([location.lng, location.lat]);
node.fixed = true;
node.px = node.x = coord[0];
node.py = node.y = coord[1];
return true;
}
// if this is a node update (not a node add).. skip randomizer
if (forUpdate) {
return;
}
// Note: Placing incoming unpinned nodes at exactly the same point
// (center of the view) causes them to explode outwards when
// the force layout kicks in. So, we spread them out a bit
// initially, to provide a more serene layout convergence.
// Additionally, if the node is a host, we place it near
// the device it is connected to.
function spread(s) {
return Math.floor((Math.random() * s) - s/2);
}
function randDim(dim) {
return dim / 2 + spread(dim * 0.7071);
}
function rand() {
return {
x: randDim(network.view.width()),
y: randDim(network.view.height())
};
}
function near(node) {
var min = 12,
dx = spread(12),
dy = spread(12);
return {
x: node.x + min + dx,
y: node.y + min + dy
};
}
function getDevice(cp) {
var d = network.lookup[cp.device];
return d || rand();
}
xy = (node.class === 'host') ? near(getDevice(node.cp)) : rand();
$.extend(node, xy);
}
function iconGlyphUrl(d) {
var which = d.type || 'unknown';
return '#' + which;
}
// returns the newly computed bounding box of the rectangle
function adjustRectToFitText(n) {
var text = n.select('text'),
box = text.node().getBBox(),
lab = config.labels;
text.attr('text-anchor', 'middle')
.attr('y', '-0.8em')
.attr('x', lab.imgPad/2);
// translate the bbox so that it is centered on [x,y]
box.x = -box.width / 2;
box.y = -box.height / 2;
// add padding
box.x -= (lab.padLR + lab.imgPad/2);
box.width += lab.padLR * 2 + lab.imgPad;
box.y -= lab.padTB;
box.height += lab.padTB * 2;
return box;
}
function mkSvgClass(d) {
return d.fixed ? d.svgClass + ' fixed' : d.svgClass;
}
function hostLabel(d) {
var idx = (hostLabelIndex < d.labels.length) ? hostLabelIndex : 0;
return d.labels[idx];
}
function deviceLabel(d) {
var idx = (deviceLabelIndex < d.labels.length) ? deviceLabelIndex : 0;
return d.labels[idx];
}
function trimLabel(label) {
return (label && label.trim()) || '';
}
function emptyBox() {
return {
x: -2,
y: -2,
width: 4,
height: 4
};
}
function updateDeviceLabel(d) {
var label = trimLabel(deviceLabel(d)),
noLabel = !label,
node = d.el,
box,
dx,
dy,
cfg = config.icons.device;
node.select('text')
.text(label)
.style('opacity', 0)
.transition()
.style('opacity', 1);
if (noLabel) {
box = emptyBox();
dx = -cfg.dim/2;
dy = -cfg.dim/2;
} else {
box = adjustRectToFitText(node);
dx = box.x + cfg.xoff;
dy = box.y + cfg.yoff;
}
node.select('rect')
.transition()
.attr(box);
node.select('g.deviceIcon')
.transition()
.attr('transform', translate(dx, dy));
}
function updateHostLabel(d) {
var label = trimLabel(hostLabel(d));
d.el.select('text').text(label);
}
function updateHostVisibility() {
var v = visVal(showHosts);
nodeG.selectAll('.host').style('visibility', v);
linkG.selectAll('.hostLink').style('visibility', v);
}
function findOfflineNodes() {
var a = [];
network.nodes.forEach(function (d) {
if (d.class === 'device' && !d.online) {
a.push(d);
}
});
return a;
}
function updateOfflineVisibility(dev) {
var so = showOffline,
sh = showHosts,
vb = 'visibility',
v, off, al, ah, db, b;
function updAtt(show) {
al.forEach(function (d) {
b = show && ((d.type() !== 'hostLink') || sh);
d.el.style(vb, visVal(b));
});
ah.forEach(function (d) {
b = show && sh;
d.el.style(vb, visVal(b));
});
}
if (dev) {
// updating a specific device that just toggled off/on-line
db = dev.online || so;
dev.el.style(vb, visVal(db));
al = findAttachedLinks(dev.id);
ah = findAttachedHosts(dev.id);
updAtt(db);
} else {
// updating all offline devices
v = visVal(so);
off = findOfflineNodes();
off.forEach(function (d) {
d.el.style(vb, v);
al = findAttachedLinks(d.id);
ah = findAttachedHosts(d.id);
updAtt(so);
});
}
}
function nodeMouseOver(d) {
if (hovered != d) {
hovered = d;
requestTrafficForMode();
}
}
function nodeMouseOut(d) {
if (hovered != null) {
hovered = null;
requestTrafficForMode();
}
}
function addHostIcon(node, radius, iid) {
var dim = radius * 1.5,
xlate = -dim / 2;
node.append('use').attr({
class: 'glyphIcon hostIcon',
transform: translate(xlate,xlate),
'xlink:href': iid,
width: dim,
height: dim
});
}
function updateNodes() {
node = nodeG.selectAll('.node')
.data(network.nodes, function (d) { return d.id; });
// operate on existing nodes...
node.filter('.device').each(function (d) {
var node = d.el;
node.classed('online', d.online);
updateDeviceLabel(d);
positionNode(d, true);
});
node.filter('.host').each(function (d) {
updateHostLabel(d);
positionNode(d, true);
});
// operate on entering nodes:
var entering = node.enter()
.append('g')
.attr({
id: function (d) { return safeId(d.id); },
class: mkSvgClass,
transform: function (d) { return translate(d.x, d.y); },
opacity: 0
})
.call(network.drag)
.on('mouseover', nodeMouseOver)
.on('mouseout', nodeMouseOut)
.transition()
.attr('opacity', 1);
// augment device nodes...
entering.filter('.device').each(function (d) {
var node = d3.select(this),
label = trimLabel(deviceLabel(d)),
noLabel = !label,
box;
// provide ref to element from backing data....
d.el = node;
node.append('rect').attr({ rx: 5, ry: 5 });
node.append('text').text(label).attr('dy', '1.1em');
box = adjustRectToFitText(node);
node.select('rect').attr(box);
addDeviceIcon(node, box, noLabel, iconGlyphUrl(d));
});
// augment host nodes...
entering.filter('.host').each(function (d) {
var node = d3.select(this),
cfg = config.icons.host,
r = cfg.radius[d.type] || cfg.defaultRadius,
textDy = r + 10,
iid = iconGlyphUrl(d);
// provide ref to element from backing data....
d.el = node;
showHostVis(node);
node.append('circle').attr('r', r);
if (iid) {
addHostIcon(node, r, iid);
}
node.append('text')
.text(hostLabel)
.attr('dy', textDy)
.attr('text-anchor', 'middle');
});
// operate on both existing and new nodes, if necessary
updateDeviceColors();
// operate on exiting nodes:
// Note that the node is removed after 2 seconds.
// Sub element animations should be shorter than 2 seconds.
var exiting = node.exit()
.transition()
.duration(2000)
.style('opacity', 0)
.remove();
// host node exits....
exiting.filter('.host').each(function (d) {
var node = d.el;
node.select('use')
.style('opacity', 0.5)
.transition()
.duration(800)
.style('opacity', 0);
node.select('text')
.style('opacity', 0.5)
.transition()
.duration(800)
.style('opacity', 0);
node.select('circle')
.style('stroke-fill', '#555')
.style('fill', '#888')
.style('opacity', 0.5)
.transition()
.duration(1500)
.attr('r', 0);
});
// device node exits....
exiting.filter('.device').each(function (d) {
var node = d.el;
node.select('use')
.style('opacity', 0.5)
.transition()
.duration(800)
.style('opacity', 0);
node.selectAll('rect')
.style('stroke-fill', '#555')
.style('fill', '#888')
.style('opacity', 0.5);
});
fResume();
}
var dCol = {
black: '#000',
paleblue: '#acf',
offwhite: '#ddd',
midgrey: '#888',
lightgrey: '#bbb',
orange: '#f90'
};
// note: these are the device icon colors without affinity
var dColTheme = {
light: {
online: {
glyph: dCol.black,
rect: dCol.paleblue
},
offline: {
glyph: dCol.midgrey,
rect: dCol.lightgrey
}
},
// TODO: theme
dark: {
online: {
glyph: dCol.black,
rect: dCol.paleblue
},
offline: {
glyph: dCol.midgrey,
rect: dCol.lightgrey
}
}
};
function devBaseColor(d) {
var t = network.view.getTheme(),
o = d.online ? 'online' : 'offline';
return dColTheme[t][o];
}
function setDeviceColor(d) {
var o = d.online,
s = d.el.classed('selected'),
c = devBaseColor(d),
a = instColor(d.master, o),
g, r,
icon = d.el.select('g.deviceIcon');
if (s) {
g = c.glyph;
r = dColTheme.sel;
} else if (colorAffinity) {
g = o ? a : c.glyph;
r = o ? dCol.offwhite : a;
} else {
g = c.glyph;
r = c.rect;
}
icon.select('use')
.style('fill', g);
icon.select('rect')
.style('fill', r);
}
function addDeviceIcon(node, box, noLabel, iid) {
var cfg = config.icons.device,
dx,
dy,
g;
if (noLabel) {
dx = -cfg.dim/2;
dy = -cfg.dim/2;
} else {
box = adjustRectToFitText(node);
dx = box.x + cfg.xoff;
dy = box.y + cfg.yoff;
}
g = node.append('g')
.attr('class', 'glyphIcon deviceIcon')
.attr('transform', translate(dx, dy));
g.append('rect').attr({
x: 0,
y: 0,
rx: cfg.rx,
width: cfg.dim,
height: cfg.dim
});
g.append('use').attr({
'xlink:href': iid,
width: cfg.dim,
height: cfg.dim
});
}
function find(key, array, tag) {
var _tag = tag || 'id',
idx, n, d;
for (idx = 0, n = array.length; idx < n; idx++) {
d = array[idx];
if (d[_tag] === key) {
return idx;
}
}
return -1;
}
function removeLinkElement(d) {
var idx = find(d.key, network.links, 'key'),
removed;
if (idx >=0) {
// remove from links array
removed = network.links.splice(idx, 1);
// remove from lookup cache
delete network.lookup[removed[0].key];
updateLinks();
fResume();
}
}
function removeHostElement(d, upd) {
var lu = network.lookup;
// first, remove associated hostLink...
removeLinkElement(d.linkData);
// remove hostLink bindings
delete lu[d.ingress];
delete lu[d.egress];
// remove from lookup cache
delete lu[d.id];
// remove from nodes array
var idx = find(d.id, network.nodes);
network.nodes.splice(idx, 1);
// remove from SVG
// NOTE: upd is false if we were called from removeDeviceElement()
if (upd) {
updateNodes();
fResume();
}
}
function removeDeviceElement(d) {
var id = d.id;
// first, remove associated hosts and links..
findAttachedHosts(id).forEach(removeHostElement);
findAttachedLinks(id).forEach(removeLinkElement);
// remove from lookup cache
delete network.lookup[id];
// remove from nodes array
var idx = find(id, network.nodes);
network.nodes.splice(idx, 1);
if (!network.nodes.length) {
showNoDevs(true);
}
// remove from SVG
updateNodes();
fResume();
}
function findAttachedHosts(devId) {
var hosts = [];
network.nodes.forEach(function (d) {
if (d.class === 'host' && d.cp.device === devId) {
hosts.push(d);
}
});
return hosts;
}
function findAttachedLinks(devId) {
var links = [];
network.links.forEach(function (d) {
if (d.source.id === devId || d.target.id === devId) {
links.push(d);
}
});
return links;
}
function fResume() {
if (!oblique) {
network.force.resume();
}
}
function fStart() {
if (!oblique) {
network.force.start();
}
}
var tickStuff = {
nodeAttr: {
transform: function (d) { return translate(d.x, d.y); }
},
linkAttr: {
x1: function (d) { return d.source.x; },
y1: function (d) { return d.source.y; },
x2: function (d) { return d.target.x; },
y2: function (d) { return d.target.y; }
},
linkLabelAttr: {
transform: function (d) {
var lnk = findLinkById(d.key);
if (lnk) {
var parms = {
x1: lnk.source.x,
y1: lnk.source.y,
x2: lnk.target.x,
y2: lnk.target.y
};
return transformLabel(parms);
}
}
}
};
function tick() {
node.attr(tickStuff.nodeAttr);
link.attr(tickStuff.linkAttr);
linkLabel.attr(tickStuff.linkLabelAttr);
}
// ==============================
// Web-Socket for live data
function findGuiSuccessor() {
var idx = -1;
onosOrder.forEach(function (d, i) {
if (d.uiAttached) {
idx = i;
}
});
for (var i = 0; i < onosOrder.length - 1; i++) {
var ni = (idx + 1 + i) % onosOrder.length;
if (onosOrder[ni].online) {
return onosOrder[ni].ip;
}
}
return null;
}
function webSockUrl() {
var url = document.location.toString()
.replace(/\#.*/, '')
.replace('http://', 'ws://')
.replace('https://', 'wss://')
.replace('index.html', config.webSockUrl);
if (guiSuccessor) {
url = url.replace(location.hostname, guiSuccessor);
}
return url;
}
webSock = {
ws : null,
retries: 0,
connect : function() {
webSock.ws = new WebSocket(webSockUrl());
webSock.ws.onopen = function() {
noWebSock(false);
requestSummary();
showInstances();
webSock.retries = 0;
};
webSock.ws.onmessage = function(m) {
if (m.data) {
wsTraceRx(m.data);
handleServerEvent(JSON.parse(m.data));
}
};
webSock.ws.onclose = function(m) {
webSock.ws = null;
guiSuccessor = findGuiSuccessor();
if (guiSuccessor && webSock.retries < onosOrder.length) {
webSock.retries++;
webSock.connect();
} else {
noWebSock(true);
}
};
},
send : function(text) {
if (text != null) {
webSock._send(text);
}
},
_send : function(message) {
if (webSock.ws) {
webSock.ws.send(message);
} else if (config.useLiveData) {
console.warn('no web socket open', message);
} else {
console.log('WS Send: ', message);
}
}
};
function noWebSock(b) {
mask.style('display',b ? 'block' : 'none');
}
function sendMessage(evType, payload) {
var p = payload || {},
toSend = {
event: evType,
sid: ++sid,
payload: p
},
asText = JSON.stringify(toSend);
wsTraceTx(asText);
webSock.send(asText);
// Temporary measure for debugging UI behavior ...
if (!config.useLiveData) {
handleTestSend(toSend);
}
}
function wsTraceTx(msg) {
wsTrace('tx', msg);
}
function wsTraceRx(msg) {
wsTrace('rx', msg);
}
function wsTrace(rxtx, msg) {
// console.log('[' + rxtx + '] ' + msg);
}
function handleTestSend(msg) { }
// ==============================
// Selection stuff
function selectObject(obj, el) {
var n,
ev = d3.event.sourceEvent;
// if the meta or alt key is pressed, we are panning/zooming, so ignore
if (ev.metaKey || ev.altKey) {
return;
}
if (el) {
n = d3.select(el);
} else {
node.each(function(d) {
if (d == obj) {
n = d3.select(el = this);
}
});
}
if (!n) return;
if (ev.shiftKey && n.classed('selected')) {
deselectObject(obj.id);
updateDetailPane();
return;
}
if (!ev.shiftKey) {
deselectAll();
}
selections[obj.id] = { obj: obj, el: el };
selectOrder.push(obj.id);
n.classed('selected', true);
updateDeviceColors(obj);
updateDetailPane();
}
function deselectObject(id) {
var obj = selections[id],
idx;
if (obj) {
d3.select(obj.el).classed('selected', false);
delete selections[id];
idx = $.inArray(id, selectOrder);
if (idx >= 0) {
selectOrder.splice(idx, 1);
}
updateDeviceColors(obj.obj);
}
}
function deselectAll() {
// deselect all nodes in the network...
node.classed('selected', false);
selections = {};
selectOrder = [];
updateDeviceColors();
updateDetailPane();
}
function updateDeviceColors(d) {
if (d) {
setDeviceColor(d);
} else {
node.filter('.device').each(function (d) {
setDeviceColor(d);
});
}
}
// update the state of the detail pane, based on current selections
function updateDetailPane() {
var nSel = selectOrder.length;
if (!nSel) {
emptySelect();
} else if (nSel === 1) {
singleSelect();
} else {
multiSelect();
}
}
function emptySelect() {
haveDetails = false;
hideDetailPane();
cancelTraffic();
}
function singleSelect() {
// NOTE: detail is shown from showDetails event callback
requestDetails();
cancelTraffic();
requestTrafficForMode();
}
function multiSelect() {
haveDetails = true;
populateMultiSelect();
cancelTraffic();
requestTrafficForMode();
}
function addSep(tbody) {
var tr = tbody.append('tr');
$('<hr>').appendTo(tr.append('td').attr('colspan', 2));
}
function addProp(tbody, label, value) {
var tr = tbody.append('tr');
tr.append('td')
.attr('class', 'label')
.text(label + ' :');
tr.append('td')
.attr('class', 'value')
.text(value);
}
function populateMultiSelect() {
detailPane.empty();
var title = detailPane.append('h3'),
table = detailPane.append('table'),
tbody = table.append('tbody');
title.text('Selected Nodes');
selectOrder.forEach(function (d, i) {
addProp(tbody, i+1, d);
});
addMultiSelectActions();
}
function populateSummary(data) {
summaryPane.empty();
var svg = summaryPane.append('svg'),
iid = iconGlyphUrl(data);
var title = summaryPane.append('h2'),
table = summaryPane.append('table'),
tbody = table.append('tbody');
appendGlyph(svg, 0, 0, 40, iid);
svg.append('use')
.attr({
class: 'birdBadge',
transform: translate(8,12),
'xlink:href': '#bird',
width: 24,
height: 24,
fill: '#fff'
});
title.text('ONOS Summary');
data.propOrder.forEach(function(p) {
if (p === '-') {
addSep(tbody);
} else {
addProp(tbody, p, data.props[p]);
}
});
}
function populateDetails(data) {
detailPane.empty();
var svg = detailPane.append('svg'),
iid = iconGlyphUrl(data);
var title = detailPane.append('h2'),
table = detailPane.append('table'),
tbody = table.append('tbody');
appendGlyph(svg, 0, 0, 40, iid);
title.text(data.id);
data.propOrder.forEach(function(p) {
if (p === '-') {
addSep(tbody);
} else {
addProp(tbody, p, data.props[p]);
}
});
addSingleSelectActions(data);
}
function addSingleSelectActions(data) {
detailPane.append('hr');
// always want to allow 'show traffic'
addAction(detailPane, 'Show Related Traffic', showRelatedIntentsAction);
if (data.type === 'switch') {
addAction(detailPane, 'Show Device Flows', showDeviceLinkFlowsAction);
}
}
function addMultiSelectActions() {
detailPane.append('hr');
// always want to allow 'show traffic'
addAction(detailPane, 'Show Related Traffic', showRelatedIntentsAction);
// if exactly two hosts are selected, also want 'add host intent'
if (nSel() === 2 && allSelectionsClass('host')) {
addAction(detailPane, 'Create Host-to-Host Flow', addHostIntentAction);
} else if (nSel() >= 2 && allSelectionsClass('host')) {
addAction(detailPane, 'Create Multi-Source Flow', addMultiSourceIntentAction);
}
}
function addAction(panel, text, cb) {
panel.append('div')
.classed('actionBtn', true)
.text(text)
.on('click', cb);
}
// === Pan and Zoom behaviors...
function panZoom(translate, scale) {
panZoomContainer.attr('transform',
'translate(' + translate + ')scale(' + scale + ')');
// keep the map lines constant width while zooming
bgImg.style('stroke-width', 2.0 / scale + 'px');
}
function resetPanZoom() {
panZoom([0,0], 1);
zoom.translate([0,0]).scale(1);
}
function setupPanZoom() {
function zoomed() {
var ev = d3.event.sourceEvent;
// pan/zoom active when meta or alt key is pressed...
if (ev.metaKey || ev.altKey) {
panZoom(d3.event.translate, d3.event.scale);
}
}
zoom = d3.behavior.zoom()
.translate([0, 0])
.scale(1)
.scaleExtent([0.25, 10])
.on("zoom", zoomed);
svg.call(zoom);
}
function setupNoDevices() {
var g = noDevices.append('g');
appendBadge(g, 0, 0, 100, '#bird', 'noDevsBird');
var text = g.append('text')
.text('No devices are connected')
.attr({ x: 120, y: 80});
}
function repositionNoDevices() {
var g = noDevices.select('g');
var box = g.node().getBBox();
box.x -= box.width/2;
box.y -= box.height/2;
g.attr('transform', translate(box.x, box.y));
}
// ==============================
// Test harness code
function prepareScenario(view, ctx, dbg) {
var sc = scenario,
urlSc = sc.evDir + ctx + sc.evScenario;
if (!ctx) {
view.alert("No scenario specified (null ctx)");
return;
}
sc.view = view;
sc.ctx = ctx;
sc.debug = dbg;
sc.evNumber = 0;
d3.json(urlSc, function(err, data) {
var p = data && data.params || {},
desc = data && data.description || null,
intro = data && data.title;
if (err) {
view.alert('No scenario found:\n\n' + urlSc + '\n\n' + err);
} else {
sc.params = p;
if (desc) {
intro += '\n\n ' + desc.join('\n ');
}
view.alert(intro);
}
});
}
function setupDefs(svg) {
var defs = svg.append('defs');
gly.loadDefs(defs);
d3u.loadGlow(defs);
}
function sendUpdateMeta(d, store) {
var metaUi = {},
ll;
if (store) {
ll = geoMapProj.invert([d.x, d.y]);
metaUi = {
x: d.x,
y: d.y,
lng: ll[0],
lat: ll[1]
};
}
d.metaUi = metaUi;
sendMessage('updateMeta', {
id: d.id,
'class': d.class,
memento: metaUi
});
}
// ==============================
// View life-cycle callbacks
function init(view, ctx, flags) {
var w = view.width(),
h = view.height(),
logSize = config.logicalSize,
fcfg = config.force;
// NOTE: view.$div is a D3 selection of the view's div
var viewBox = '0 0 ' + logSize + ' ' + logSize;
svg = view.$div.append('svg').attr('viewBox', viewBox);
setSize(svg, view);
// load glyphs, filters, and other definitions...
setupDefs(svg);
panZoomContainer = svg.append('g').attr('id', 'panZoomContainer');
setupPanZoom();
noDevices = svg.append('g')
.attr('class', 'noDevsLayer')
.attr('transform', translate(logSize/2, logSize/2));
setupNoDevices();
// group for the topology
topoG = panZoomContainer.append('g')
.attr('id', 'topo-G');
// subgroups for links, link labels, and nodes
linkG = topoG.append('g').attr('id', 'links');
linkLabelG = topoG.append('g').attr('id', 'linkLabels');
nodeG = topoG.append('g').attr('id', 'nodes');
// selection of links, linkLabels, and nodes
link = linkG.selectAll('.link');
linkLabel = linkLabelG.selectAll('.linkLabel');
node = nodeG.selectAll('.node');
function chrg(d) {
return fcfg.charge[d.class] || -12000;
}
function ldist(d) {
return fcfg.linkDistance[d.type] || 50;
}
function lstrg(d) {
// 0.0 - 1.0
return fcfg.linkStrength[d.type] || 1.0;
}
function selectCb(d, self) {
selectObject(d, self);
}
function atDragEnd(d, self) {
// once we've finished moving, pin the node in position
d.fixed = true;
d3.select(self).classed('fixed', true);
if (config.useLiveData) {
sendUpdateMeta(d, true);
} else {
console.log('Moving node ' + d.id + ' to [' + d.x + ',' + d.y + ']');
}
}
// predicate that indicates when dragging is active
function dragEnabled() {
var ev = d3.event.sourceEvent;
// nodeLock means we aren't allowing nodes to be dragged...
// meta or alt key pressed means we are zooming/panning...
return !nodeLock && !(ev.metaKey || ev.altKey);
}
// predicate that indicates when clicking is active
function clickEnabled() {
return true;
}
// set up the force layout
network.force = d3.layout.force()
.size([w, h])
.nodes(network.nodes)
.links(network.links)
.gravity(0.4)
.friction(0.7)
.charge(chrg)
.linkDistance(ldist)
.linkStrength(lstrg)
.on('tick', tick);
network.drag = d3u.createDragBehavior(network.force,
selectCb, atDragEnd, dragEnabled, clickEnabled);
// create mask layer for when we lose connection to server.
// TODO: this should be part of the framework
function para(sel, text) {
sel.append('p').text(text);
}
mask = view.$div.append('div').attr('id','topo-mask');
para(mask, 'Oops!');
para(mask, 'Web-socket connection to server closed...');
para(mask, 'Try refreshing the page.');
mask.append('svg')
.attr({
id: 'mask-bird',
width: w,
height: h
})
.append('g')
.attr('transform', birdTranslate(w, h))
.style('opacity', 0.3)
.append('use')
.attr({
'xlink:href': '#bird',
width: config.birdDim,
height: config.birdDim,
fill: '#111'
})
}
function load(view, ctx, flags) {
// resize, in case the window was resized while we were not loaded
resize(view, ctx, flags);
// cache the view token, so network topo functions can access it
network.view = view;
config.useLiveData = !flags.local;
if (!config.useLiveData) {
prepareScenario(view, ctx, flags.debug);
}
// set our radio buttons and key bindings
layerBtnSet = view.setRadio(layerButtons);
view.setKeys(keyDispatch);
view.setGestures(gestures);
// Load map data asynchronously; complete startup after that..
loadGeoJsonData();
}
function startAntTimer() {
// Note: disabled until traffic can be allotted to intents properly
if (false && !antTimer) {
var pulses = [5, 3, 1.2, 3],
pulse = 0;
antTimer = setInterval(function () {
pulse = pulse + 1;
pulse = pulse === pulses.length ? 0 : pulse;
d3.selectAll('.animated').style('stroke-width', pulses[pulse]);
}, 200);
}
}
function stopAntTimer() {
if (antTimer) {
clearInterval(antTimer);
antTimer = null;
}
}
function unload(view, ctx, flags) {
stopAntTimer();
}
var geoJsonUrl = 'continental_us.json',
geoJson;
function loadGeoJsonData() {
d3.json(geoJsonUrl, function (err, data) {
if (err) {
console.error('failed to load Map data', err);
} else {
geoJson = data;
loadGeoMap();
}
repositionNoDevices();
showNoDevs(true);
// finally, connect to the server...
if (config.useLiveData) {
webSock.connect();
}
});
}
function setProjForView(path, topoData) {
var dim = config.logicalSize;
// start with unit scale, no translation..
geoMapProj.scale(1).translate([0, 0]);
// figure out dimensions of map data..
var b = path.bounds(topoData),
x1 = b[0][0],
y1 = b[0][1],
x2 = b[1][0],
y2 = b[1][1],
dx = x2 - x1,
dy = y2 - y1,
x = (x1 + x2) / 2,
y = (y1 + y2) / 2;
// size map to 95% of minimum dimension to fill space..
var s = .95 / Math.min(dx / dim, dy / dim);
var t = [dim / 2 - s * x, dim / 2 - s * y];
// set new scale, translation on the projection..
geoMapProj.scale(s).translate(t);
}
function loadGeoMap() {
fnTrace('loadGeoMap', geoJsonUrl);
// extracts the topojson data into geocoordinate-based geometry
var topoData = topojson.feature(geoJson, geoJson.objects.states);
// see: http://bl.ocks.org/mbostock/4707858
geoMapProj = d3.geo.mercator();
var path = d3.geo.path().projection(geoMapProj);
setProjForView(path, topoData);
bgImg = panZoomContainer.insert("g", '#topo-G');
bgImg.attr('id', 'map').selectAll('path')
.data(topoData.features)
.enter()
.append('path')
.attr('d', path);
}
function resize(view, ctx, flags) {
var w = view.width(),
h = view.height();
setSize(svg, view);
d3.select('#mask-bird').attr({ width: w, height: h})
.select('g').attr('transform', birdTranslate(w, h));
}
function theme(view, ctx, flags) {
updateInstances();
updateDeviceColors();
}
function birdTranslate(w, h) {
var bdim = config.birdDim;
return 'translate('+((w-bdim)*.4)+','+((h-bdim)*.1)+')';
}
function isF(f) { return $.isFunction(f) ? f : null; }
function noop() {}
function augmentDetailPane() {
var dp = detailPane;
dp.ypos = { up: 64, down: 320, current: 320};
dp._move = function (y, cb) {
var endCb = isF(cb) || noop,
yp = dp.ypos;
if (yp.current !== y) {
yp.current = y;
dp.el.transition().duration(300)
.each('end', endCb)
.style('top', yp.current + 'px');
} else {
endCb();
}
};
dp.down = function (cb) { dp._move(dp.ypos.down, cb); };
dp.up = function (cb) { dp._move(dp.ypos.up, cb); };
}
// ==============================
// View registration
onos.ui.addView('topo', {
init: init,
load: load,
unload: unload,
resize: resize,
theme: theme
});
summaryPane = onos.ui.addFloatingPanel('topo-summary');
detailPane = onos.ui.addFloatingPanel('topo-detail');
augmentDetailPane();
oiBox = onos.ui.addFloatingPanel('topo-oibox', 'TL');
oiBox.width(20);
}(ONOS));