[luci-app-bmx6]: Remove not used code. Fix luci dependency problem. Small changes.
Signed-off-by: Pau Escrich <p4u@dabax.net>
This commit is contained in:
Pau Escrich
parent
2bb7d479d3
commit
af2bc59a38
11 changed files with 3 additions and 1421 deletions
|
|
@ -20,7 +20,7 @@
|
||||||
include $(TOPDIR)/rules.mk
|
include $(TOPDIR)/rules.mk
|
||||||
|
|
||||||
PKG_NAME:=luci-app-bmx6
|
PKG_NAME:=luci-app-bmx6
|
||||||
PKG_RELEASE:=2
|
PKG_RELEASE:=3
|
||||||
|
|
||||||
PKG_BUILD_DIR := $(BUILD_DIR)/$(PKG_NAME)
|
PKG_BUILD_DIR := $(BUILD_DIR)/$(PKG_NAME)
|
||||||
|
|
||||||
|
|
@ -31,12 +31,12 @@ define Package/luci-app-bmx6
|
||||||
CATEGORY:=LuCI
|
CATEGORY:=LuCI
|
||||||
SUBMENU:=3. Applications
|
SUBMENU:=3. Applications
|
||||||
TITLE:= bmx6 configuration, status and visualization module
|
TITLE:= bmx6 configuration, status and visualization module
|
||||||
DEPENDS:=+luci-lib-json +luci-mod-admin-core +luci-lib-httpclient +bmx6
|
DEPENDS:=+luci-lib-json +luci-mod-admin-full +luci-lib-httpclient +bmx6
|
||||||
MAINTAINER:= Pau Escrich <p4u@dabax.net>
|
MAINTAINER:= Pau Escrich <p4u@dabax.net>
|
||||||
endef
|
endef
|
||||||
|
|
||||||
define Package/luci-app-bmx6/description
|
define Package/luci-app-bmx6/description
|
||||||
bmx6 web module for LuCi web interface
|
bmx6 web application (status and configuration) for LuCi web interface
|
||||||
endef
|
endef
|
||||||
|
|
||||||
define Package/luci-app-bmx6/conffiles
|
define Package/luci-app-bmx6/conffiles
|
||||||
|
|
|
||||||
|
|
@ -59,11 +59,6 @@ function index()
|
||||||
entry(place,call("action_status_j"),"Status",0)
|
entry(place,call("action_status_j"),"Status",0)
|
||||||
table.remove(place)
|
table.remove(place)
|
||||||
|
|
||||||
-- not visible
|
|
||||||
table.insert(place,"nodes_nojs")
|
|
||||||
entry(place, call("action_nodes"), nil)
|
|
||||||
table.remove(place)
|
|
||||||
|
|
||||||
--- nodes
|
--- nodes
|
||||||
table.insert(place,"Nodes")
|
table.insert(place,"Nodes")
|
||||||
entry(place,call("action_nodes_j"),"Nodes",1)
|
entry(place,call("action_nodes_j"),"Nodes",1)
|
||||||
|
|
@ -79,11 +74,6 @@ function index()
|
||||||
entry(place,call("action_tunnels_j"), "Tunnels", 3).leaf = true
|
entry(place,call("action_tunnels_j"), "Tunnels", 3).leaf = true
|
||||||
table.remove(place)
|
table.remove(place)
|
||||||
|
|
||||||
-- Gateways (deprecated)
|
|
||||||
--table.insert(place,"Gateways")
|
|
||||||
--entry(place,call("action_gateways_j"),"Gateways").leaf = true
|
|
||||||
--table.remove(place)
|
|
||||||
|
|
||||||
--- Chat
|
--- Chat
|
||||||
table.insert(place,"Chat")
|
table.insert(place,"Chat")
|
||||||
entry(place,call("action_chat"),"Chat",5)
|
entry(place,call("action_chat"),"Chat",5)
|
||||||
|
|
@ -131,52 +121,11 @@ function index()
|
||||||
|
|
||||||
end
|
end
|
||||||
|
|
||||||
function action_status()
|
|
||||||
local status = bmx6json.get("status").status or nil
|
|
||||||
local interfaces = bmx6json.get("interfaces").interfaces or nil
|
|
||||||
|
|
||||||
if status == nil or interfaces == nil then
|
|
||||||
luci.template.render("bmx6/error", {txt="Cannot fetch data from bmx6 json"})
|
|
||||||
else
|
|
||||||
luci.template.render("bmx6/status", {status=status,interfaces=interfaces})
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
function action_status_j()
|
function action_status_j()
|
||||||
luci.template.render("bmx6/status_j", {})
|
luci.template.render("bmx6/status_j", {})
|
||||||
end
|
end
|
||||||
|
|
||||||
|
|
||||||
function action_nodes()
|
|
||||||
local orig_list = bmx6json.get("originators").originators or nil
|
|
||||||
|
|
||||||
if orig_list == nil then
|
|
||||||
luci.template.render("bmx6/error", {txt="Cannot fetch data from bmx6 json"})
|
|
||||||
return nil
|
|
||||||
end
|
|
||||||
|
|
||||||
local originators = {}
|
|
||||||
local desc = nil
|
|
||||||
local orig = nil
|
|
||||||
local name = ""
|
|
||||||
local ipv4 = ""
|
|
||||||
|
|
||||||
for _,o in ipairs(orig_list) do
|
|
||||||
orig = bmx6json.get("originators/"..o.name) or {}
|
|
||||||
desc = bmx6json.get("descriptions/"..o.name) or {}
|
|
||||||
|
|
||||||
if string.find(o.name,'.') then
|
|
||||||
name = luci.util.split(o.name,'.')[1]
|
|
||||||
else
|
|
||||||
name = o.name
|
|
||||||
end
|
|
||||||
|
|
||||||
table.insert(originators,{name=name,orig=orig,desc=desc})
|
|
||||||
end
|
|
||||||
|
|
||||||
luci.template.render("bmx6/nodes", {originators=originators})
|
|
||||||
end
|
|
||||||
|
|
||||||
function action_nodes_j()
|
function action_nodes_j()
|
||||||
local http = require "luci.http"
|
local http = require "luci.http"
|
||||||
local link_non_js = "/cgi-bin/luci" .. http.getenv("PATH_INFO") .. '/nodes_nojs'
|
local link_non_js = "/cgi-bin/luci" .. http.getenv("PATH_INFO") .. '/nodes_nojs'
|
||||||
|
|
@ -192,7 +141,6 @@ function action_tunnels_j()
|
||||||
luci.template.render("bmx6/tunnels_j", {})
|
luci.template.render("bmx6/tunnels_j", {})
|
||||||
end
|
end
|
||||||
|
|
||||||
|
|
||||||
function action_links(host)
|
function action_links(host)
|
||||||
local links = bmx6json.get("links", host)
|
local links = bmx6json.get("links", host)
|
||||||
local devlinks = {}
|
local devlinks = {}
|
||||||
|
|
|
||||||
|
|
@ -1,59 +0,0 @@
|
||||||
<%+header%>
|
|
||||||
|
|
||||||
<style type="text/css">
|
|
||||||
table.int {
|
|
||||||
border-width: 2px;
|
|
||||||
border-spacing: ;
|
|
||||||
border-style: inset;
|
|
||||||
border-color: white;
|
|
||||||
border-collapse: collapse;
|
|
||||||
background-color: #dadbe6;
|
|
||||||
}
|
|
||||||
table.int tr {
|
|
||||||
border-width: 5px;
|
|
||||||
padding: 4px;
|
|
||||||
border-style: solid;
|
|
||||||
border-color: white;
|
|
||||||
background-color: #dadbe9;
|
|
||||||
}
|
|
||||||
table.int td {
|
|
||||||
border-width: 5px;
|
|
||||||
padding: 4px;
|
|
||||||
border-style: solid;
|
|
||||||
border-color: white;
|
|
||||||
background-color: #dadbe9;
|
|
||||||
text-align: center;
|
|
||||||
}
|
|
||||||
</style>
|
|
||||||
|
|
||||||
<h2><a id="content" name="content"><%:Interfaces%></a></h2>
|
|
||||||
Interfaces where bmx6 is running
|
|
||||||
<br />
|
|
||||||
<br />
|
|
||||||
<table class="int">
|
|
||||||
<tr>
|
|
||||||
<td><strong>Name</strong></td>
|
|
||||||
<td><strong>State</strong></td>
|
|
||||||
<td><strong>Type</strong></td>
|
|
||||||
<td><strong>Rate (Min/Max)</strong></td>
|
|
||||||
<td><strong>Local IP</strong></td>
|
|
||||||
<td><strong>Global IP</strong></td>
|
|
||||||
<td><strong>Multicast IP</strong></td>
|
|
||||||
<td><strong>Primary</strong></td>
|
|
||||||
</tr>
|
|
||||||
<% for i,v in ipairs(data) do %>
|
|
||||||
<tr>
|
|
||||||
<td><%=v.devName%></td>
|
|
||||||
<td><%=v.state%></td>
|
|
||||||
<td><%=v.type%></td>
|
|
||||||
<td><%=v.rateMin%>/<%=v.rateMax%></td>
|
|
||||||
<td><%=v.llocalIp%></td>
|
|
||||||
<td><%=v.globalIp%></td>
|
|
||||||
<td><%=v.multicastIp%></td>
|
|
||||||
<td><%=v.primary%></td>
|
|
||||||
</tr>
|
|
||||||
<%end%>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<br />
|
|
||||||
<%+footer%>
|
|
||||||
|
|
@ -1,89 +0,0 @@
|
||||||
<%+header%>
|
|
||||||
<style type="text/css">
|
|
||||||
|
|
||||||
table {
|
|
||||||
width:90%;
|
|
||||||
border-top:1px solid #e5eaf8;
|
|
||||||
border-right:1px solid #e5eaf8;
|
|
||||||
margin:1em auto;
|
|
||||||
border-collapse:collapse;
|
|
||||||
}
|
|
||||||
|
|
||||||
td {
|
|
||||||
color:#678197;
|
|
||||||
border-bottom:1px solid #e6eff8;
|
|
||||||
border-left:1px solid #e6eff8;
|
|
||||||
padding:.3em 1em;
|
|
||||||
text-align:center;
|
|
||||||
}
|
|
||||||
th {
|
|
||||||
background:#f4f9fe;
|
|
||||||
text-align:center;
|
|
||||||
font:bold 1.2em/2em "Century Gothic","Trebuchet MS",Arial,Helvetica,sans-serif;
|
|
||||||
color:#66a3d3;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#neighbour {
|
|
||||||
position:relative;
|
|
||||||
margin:5px;
|
|
||||||
}
|
|
||||||
|
|
||||||
#orig_id {
|
|
||||||
background-color: black;
|
|
||||||
color: white;
|
|
||||||
text-ident:10px;
|
|
||||||
}
|
|
||||||
</style>
|
|
||||||
|
|
||||||
<h2><a id="content" name="content"><%:Neighbours%></a></h2>
|
|
||||||
<table>
|
|
||||||
<tr>
|
|
||||||
<th scope="col">Name</th>
|
|
||||||
<th scope="col">IPv4</th>
|
|
||||||
<th scope="col">IPv6</th>
|
|
||||||
<th scope="col">Via Dev</th>
|
|
||||||
<th scope="col">Via IP</th>
|
|
||||||
<th scope="col">Routes</th>
|
|
||||||
<th scope="col">Metric</th>
|
|
||||||
<th scope="col">Last Desc</th>
|
|
||||||
<th scope="col">Last Ref</th>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<% for i,o in ipairs(originators) do %>
|
|
||||||
<tr>
|
|
||||||
<td><%=o.name%></td>
|
|
||||||
<td><a href="http://<%=o.ipv4%>"><%=o.ipv4%></a></td>
|
|
||||||
<td><a href="http://[<%=o.orig.primaryIp%>]"><%=o.orig.primaryIp%></a></td>
|
|
||||||
<td><%=o.orig.viaDev%></td>
|
|
||||||
<td><%=o.orig.viaIp%></td>
|
|
||||||
<td><%=o.orig.routes%></td>
|
|
||||||
<td><%=o.orig.metric%></td>
|
|
||||||
<td><%=o.orig.lastDesc%></td>
|
|
||||||
<td><%=o.orig.lastRef%></td>
|
|
||||||
</tr>
|
|
||||||
<%end%>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<table>
|
|
||||||
<tr>
|
|
||||||
<th scope="col">Node</th>
|
|
||||||
<th scope="col">Announced networks</th>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<% for i,o in ipairs(originators) do %>
|
|
||||||
<tr>
|
|
||||||
<td><%=o.name%></td>
|
|
||||||
<td style="text-align:left;">
|
|
||||||
<% if o.desc.DESC_ADV ~= nil then %>
|
|
||||||
<% for j,h in ipairs(o.desc.DESC_ADV.extensions[2].HNA6_EXTENSION) do %>
|
|
||||||
<%=h.address%>
|
|
||||||
<% end %>
|
|
||||||
<% end %>
|
|
||||||
</td>
|
|
||||||
</tr>
|
|
||||||
<% end %>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<br />
|
|
||||||
<%+footer%>
|
|
||||||
|
|
@ -1,188 +0,0 @@
|
||||||
<%+header%>
|
|
||||||
<script type="text/javascript">//<![CDATA[
|
|
||||||
|
|
||||||
var displayExtraInfo = function ( id ) {
|
|
||||||
|
|
||||||
document.getElementById('extra-info').innerHTML = document.getElementById(id).innerHTML;
|
|
||||||
}
|
|
||||||
XHR.poll(5, '/cgi-bin/bmx6-info', { '$neighbours': '' },
|
|
||||||
function(x, st)
|
|
||||||
{
|
|
||||||
var originators = st.neighbours[0].originators;
|
|
||||||
var descriptions = st.neighbours[1].descriptions;
|
|
||||||
|
|
||||||
var tb = document.getElementById('descriptions_table');
|
|
||||||
|
|
||||||
if ( originators.length != descriptions.length )
|
|
||||||
{
|
|
||||||
var tr = tb.insertRow(-1);
|
|
||||||
tr.className = 'cbi-section-table-row';
|
|
||||||
var td = tr.insertCell(-1);
|
|
||||||
td.colSpan = 7;
|
|
||||||
td.innerHTML = '<em><br /><%:Some problem with JSON: lenght of originators and descriptions different. %></em>';
|
|
||||||
td.innerHTML += '<em><%: Please perform a manually cache flush from a terminal: bmx6 -c --flushAll %></em>'
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( originators && descriptions && tb)
|
|
||||||
{
|
|
||||||
/* clear all rows */
|
|
||||||
while( tb.rows.length > 1 )
|
|
||||||
tb.deleteRow(1);
|
|
||||||
|
|
||||||
for( var i = 0; i < descriptions.length; i++ )
|
|
||||||
{
|
|
||||||
var tr = tb.insertRow(-1);
|
|
||||||
var nodename = descriptions[i].DESC_ADV.globalId.replace(/\.[^\.]+$/,"");
|
|
||||||
tr.className = 'cbi-section-table-row cbi-rowstyle-' + ((i % 2) + 1);
|
|
||||||
tr.insertCell(-1).innerHTML = '<a onclick="displayExtraInfo(\'ip-'+i+'\')"><img src=\"<%=resource%>/cbi/help.gif\" /></a>';
|
|
||||||
tr.insertCell(-1).innerHTML = nodename;
|
|
||||||
|
|
||||||
var extensions = descriptions[i].DESC_ADV.extensions;
|
|
||||||
|
|
||||||
//Looking for the extensions
|
|
||||||
var hna6 = [];
|
|
||||||
var tun4in6 = [];
|
|
||||||
var tun6 = [];
|
|
||||||
for( var e = 0; e < extensions.length; e++)
|
|
||||||
{
|
|
||||||
if( extensions[e].HNA6_EXTENSION )
|
|
||||||
{
|
|
||||||
hna6 = extensions[e].HNA6_EXTENSION;
|
|
||||||
}
|
|
||||||
if ( extensions[e].TUN4IN6_NET_EXTENSION )
|
|
||||||
{
|
|
||||||
tun4in6 = extensions[e].TUN4IN6_NET_EXTENSION;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
var gateways = '<ul>';
|
|
||||||
for ( var t = 0; t < tun4in6.length; t++)
|
|
||||||
{
|
|
||||||
if ( tun4in6[t].networklen == "32" )
|
|
||||||
gateways += '<li><a href="http://' + tun4in6[t].network + '">' + tun4in6[t].network + '</a></li>';
|
|
||||||
else
|
|
||||||
gateways += "<li>"+tun4in6[t].network+'/'+tun4in6[t].networklen + ' | ' + tun4in6[t].bandwidth+'</li>';
|
|
||||||
}
|
|
||||||
gateways += '</ul>';
|
|
||||||
|
|
||||||
//Adding HNAs with prefix=128 as main address
|
|
||||||
var ipstxt = '';
|
|
||||||
var address;
|
|
||||||
var first = 1;
|
|
||||||
var ipstxt_hidden = '<ul>';
|
|
||||||
var hna6list = '<ul>';
|
|
||||||
|
|
||||||
for( var e = 0; e < hna6.length; e++ )
|
|
||||||
{
|
|
||||||
address = hna6[e].address;
|
|
||||||
prefix = hna6[e].prefixlen;
|
|
||||||
if ( prefix == '128' )
|
|
||||||
{
|
|
||||||
if (first)
|
|
||||||
{
|
|
||||||
ipstxt += address;
|
|
||||||
ipstxt_hidden += '<li><a href="http://['+address+']" >'+address+"</a></li>";
|
|
||||||
first = 0;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
ipstxt_hidden += '<li><a href="http://['+address+']" >'+address+"</a></li>";
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
hna6list += '<li>'+address+'/'+prefix+'</li>';
|
|
||||||
}
|
|
||||||
}
|
|
||||||
hna6list += '</ul>';
|
|
||||||
ipstxt_hidden += '</ul>';
|
|
||||||
|
|
||||||
tr.insertCell(-1).innerHTML = ipstxt;
|
|
||||||
|
|
||||||
tr.insertCell(-1).innerHTML = originators[i].viaDev;
|
|
||||||
tr.insertCell(-1).innerHTML = originators[i].metric;
|
|
||||||
tr.insertCell(-1).innerHTML = originators[i].lastDesc;
|
|
||||||
tr.insertCell(-1).innerHTML = originators[i].lastRef;
|
|
||||||
tr.insertCell(-1).innerHTML = originators[i].blocked;
|
|
||||||
//tr.onclick = displayExtraInfo("ip-"+i);
|
|
||||||
|
|
||||||
extrainfo = '<div id="ip-'+ i +'" class="hideme">' + "<div class='inforow'><br /><br /><h4>" + nodename + '</h4></div>\n' + "<div class='inforow'><h5>Available IPs</h5>\n<p>" + ipstxt_hidden + "</p></div>\n" + "<div class='inforow'><h5>Gateways announced</h5>\n<p>" + gateways + "</p></div>\n" + "<div class='inforow'><h5>Networks announced</h5>\n<p>" + hna6list + "</p></div>\n";
|
|
||||||
|
|
||||||
extrainfo += "\n</div>";
|
|
||||||
|
|
||||||
tr.insertCell(-1).innerHTML = extrainfo;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
if( tb.rows.length == 1 )
|
|
||||||
{
|
|
||||||
var tr = tb.insertRow(-1);
|
|
||||||
tr.className = 'cbi-section-table-row';
|
|
||||||
|
|
||||||
var td = tr.insertCell(-1);
|
|
||||||
td.colSpan = 7;
|
|
||||||
td.innerHTML = '<em><br /><%:There are no nodes available.%></em>';
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
);
|
|
||||||
//]]></script>
|
|
||||||
|
|
||||||
<style>
|
|
||||||
|
|
||||||
div.hideme{
|
|
||||||
display: none;
|
|
||||||
}
|
|
||||||
|
|
||||||
div.info{
|
|
||||||
background: #FFF;
|
|
||||||
border: solid 1px;
|
|
||||||
height: 80px;
|
|
||||||
display: block;
|
|
||||||
overflow: auto;
|
|
||||||
text-align: center;
|
|
||||||
}
|
|
||||||
|
|
||||||
div.inforow{
|
|
||||||
text-align:center;
|
|
||||||
display:inline-block;
|
|
||||||
width:20%;
|
|
||||||
margin:5px;
|
|
||||||
vertical-align:top;
|
|
||||||
}
|
|
||||||
|
|
||||||
#extra-info ul { list-style: none outside none; margin-left: 0em; }
|
|
||||||
|
|
||||||
</style>
|
|
||||||
<div class="cbi-map">
|
|
||||||
|
|
||||||
<h2>Originators</h2>
|
|
||||||
<div class="cbi-map-descr"></div>
|
|
||||||
<div id="extra-info" class="info">
|
|
||||||
<br />
|
|
||||||
Click to the icon <img src="<%=resource%>/cbi/help.gif" /> to see individual node information
|
|
||||||
</div>
|
|
||||||
<fieldset class="cbi-section">
|
|
||||||
<legend><%:Mesh nodes%></legend>
|
|
||||||
<table class="cbi-section-table" id="descriptions_table">
|
|
||||||
<tr class="cbi-section-table-titles">
|
|
||||||
<th class="cbi-section-table-cell"></th>
|
|
||||||
<th class="cbi-section-table-cell"><%:Hostname%></th>
|
|
||||||
<th class="cbi-section-table-cell"><%:Primary IP%></th>
|
|
||||||
<th class="cbi-section-table-cell"><%:Via Device%></th>
|
|
||||||
<th class="cbi-section-table-cell"><%:Metric%></th>
|
|
||||||
<th class="cbi-section-table-cell"><%:Last Desc%></th>
|
|
||||||
<th class="cbi-section-table-cell"><%:Last Ref%></th>
|
|
||||||
<th class="cbi-section-table-cell"><%:Blocked%></th>
|
|
||||||
</tr>
|
|
||||||
<tr class="cbi-section-table-row">
|
|
||||||
<td colspan="8"><em><br /><%:Collecting data...%></em></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
</fieldset>
|
|
||||||
|
|
||||||
</div>
|
|
||||||
<a href="<%=link_non_js%>">Go to non JavaScript view</a>
|
|
||||||
|
|
||||||
|
|
||||||
<%+footer%>
|
|
||||||
|
|
||||||
|
|
@ -1,87 +0,0 @@
|
||||||
<%+header%>
|
|
||||||
<style type="text/css">
|
|
||||||
|
|
||||||
table {
|
|
||||||
width:90%;
|
|
||||||
border-top:1px solid #e5eaf8;
|
|
||||||
border-right:1px solid #e5eaf8;
|
|
||||||
margin:1em auto;
|
|
||||||
border-collapse:collapse;
|
|
||||||
}
|
|
||||||
|
|
||||||
td {
|
|
||||||
color:#678197;
|
|
||||||
border-bottom:1px solid #e6eff8;
|
|
||||||
border-left:1px solid #e6eff8;
|
|
||||||
padding:.3em 1em;
|
|
||||||
text-align:center;
|
|
||||||
}
|
|
||||||
th {
|
|
||||||
background:#f4f9fe;
|
|
||||||
text-align:center;
|
|
||||||
font:bold 1.2em/2em "Century Gothic","Trebuchet MS",Arial,Helvetica,sans-serif;
|
|
||||||
color:#66a3d3;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#neighbour {
|
|
||||||
position:relative;
|
|
||||||
margin:5px;
|
|
||||||
}
|
|
||||||
|
|
||||||
#orig_id {
|
|
||||||
background-color: black;
|
|
||||||
color: white;
|
|
||||||
text-ident:10px;
|
|
||||||
}
|
|
||||||
</style>
|
|
||||||
|
|
||||||
<h2><a id="content" name="content"><%:Nodes%></a></h2>
|
|
||||||
<table>
|
|
||||||
<tr>
|
|
||||||
<th scope="col">Name</th>
|
|
||||||
<th scope="col">IPv6</th>
|
|
||||||
<th scope="col">Via Dev</th>
|
|
||||||
<th scope="col">Via IP</th>
|
|
||||||
<th scope="col">Routes</th>
|
|
||||||
<th scope="col">Metric</th>
|
|
||||||
<th scope="col">Last Desc</th>
|
|
||||||
<th scope="col">Last Ref</th>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<% for i,o in ipairs(originators) do %>
|
|
||||||
<tr>
|
|
||||||
<td><%=o.name%></td>
|
|
||||||
<td><a href="http://[<%=o.orig.primaryIp%>]"><%=o.orig.primaryIp%></a></td>
|
|
||||||
<td><%=o.orig.viaDev%></td>
|
|
||||||
<td><%=o.orig.viaIp%></td>
|
|
||||||
<td><%=o.orig.routes%></td>
|
|
||||||
<td><%=o.orig.metric%></td>
|
|
||||||
<td><%=o.orig.lastDesc%></td>
|
|
||||||
<td><%=o.orig.lastRef%></td>
|
|
||||||
</tr>
|
|
||||||
<%end%>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<table>
|
|
||||||
<tr>
|
|
||||||
<th scope="col">Node</th>
|
|
||||||
<th scope="col">Announced networks</th>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<% for i,o in ipairs(originators) do %>
|
|
||||||
<tr>
|
|
||||||
<td><%=o.name%></td>
|
|
||||||
<td style="text-align:left;">
|
|
||||||
<% if o.desc.DESC_ADV ~= nil then %>
|
|
||||||
<% for j,h in ipairs(o.desc.DESC_ADV.extensions[2].HNA6_EXTENSION) do %>
|
|
||||||
<%=h.address%>
|
|
||||||
<% end %>
|
|
||||||
<% end %>
|
|
||||||
</td>
|
|
||||||
</tr>
|
|
||||||
<% end %>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<br />
|
|
||||||
<%+footer%>
|
|
||||||
|
|
@ -82,8 +82,6 @@
|
||||||
|
|
||||||
</div>
|
</div>
|
||||||
|
|
||||||
<a href="<%=link_non_js%>">Go to non JavaScript view</a>
|
|
||||||
|
|
||||||
<script type="text/javascript">//<![CDATA[
|
<script type="text/javascript">//<![CDATA[
|
||||||
var displayExtraInfo = function ( id ) {
|
var displayExtraInfo = function ( id ) {
|
||||||
document.getElementById('extra-info').innerHTML = document.getElementById(id).innerHTML;
|
document.getElementById('extra-info').innerHTML = document.getElementById(id).innerHTML;
|
||||||
|
|
|
||||||
|
|
@ -1,69 +0,0 @@
|
||||||
<%+header%>
|
|
||||||
<link rel="stylesheet" type="text/css" href="/luci-static/resources/bmx6/style.css" />
|
|
||||||
|
|
||||||
<img src="<%=resource%>/bmx6/bmx6logo.png" />
|
|
||||||
|
|
||||||
Bmx6 is a routing protocol for Linux based operating systems. Visit <a href="http://bmx6.net">bmx6.net</a> for more info.
|
|
||||||
|
|
||||||
<br />
|
|
||||||
<br />
|
|
||||||
|
|
||||||
<h2>Status of bmx6</h2>
|
|
||||||
|
|
||||||
<table>
|
|
||||||
<tr>
|
|
||||||
<th>Version</th>
|
|
||||||
<th>Compatibility</th>
|
|
||||||
<th>CodeVersion</th>
|
|
||||||
<th>Global Id</th>
|
|
||||||
<th>Primary Ip</th>
|
|
||||||
<th>Local Id</th>
|
|
||||||
<th>Uptime</th>
|
|
||||||
<th>CPU</th>
|
|
||||||
<th>Nodes</th>
|
|
||||||
</tr>
|
|
||||||
<tr>
|
|
||||||
<td><%=status.version%></td>
|
|
||||||
<td><%=status.compatibility%></td>
|
|
||||||
<td><%=status.codeVersion%></td>
|
|
||||||
<td><%=status.globalId%>/<%=status.rateMax%></td>
|
|
||||||
<td><%=status.primaryIp%></td>
|
|
||||||
<td><%=status.myLocalId%></td>
|
|
||||||
<td><%=status.uptime%></td>
|
|
||||||
<td><%=status.cpu%></td>
|
|
||||||
<td><%=status.nodes%></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<br />
|
|
||||||
<br />
|
|
||||||
|
|
||||||
<h2>Status of interfaces</h2>
|
|
||||||
<table>
|
|
||||||
<tr>
|
|
||||||
<th>Name</th>
|
|
||||||
<th>State</th>
|
|
||||||
<th>Type</th>
|
|
||||||
<th>Rate (Min/Max)</th>
|
|
||||||
<th>Local IP</th>
|
|
||||||
<th>Global IP</th>
|
|
||||||
<th>Multicast IP</th>
|
|
||||||
<th>Primary</th>
|
|
||||||
</tr>
|
|
||||||
<% for i,v in ipairs(interfaces) do %>
|
|
||||||
<tr>
|
|
||||||
<td><%=v.devName%></td>
|
|
||||||
<td><%=v.state%></td>
|
|
||||||
<td><%=v.type%></td>
|
|
||||||
<td><%=v.rateMin%>/<%=v.rateMax%></td>
|
|
||||||
<td><%=v.llocalIp%></td>
|
|
||||||
<td><%=v.globalIp%></td>
|
|
||||||
<td><%=v.multicastIp%></td>
|
|
||||||
<td><%=v.primary%></td>
|
|
||||||
</tr>
|
|
||||||
<%end%>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<br />
|
|
||||||
|
|
||||||
<%+footer%>
|
|
||||||
|
|
@ -1,7 +0,0 @@
|
||||||
<%+header%>
|
|
||||||
<h2><a id="content" name="content"><%:Wireless%></a></h2>
|
|
||||||
<br />
|
|
||||||
<h3>Wireless</h3>
|
|
||||||
<%=data%>
|
|
||||||
<br />
|
|
||||||
<%+footer%>
|
|
||||||
|
|
@ -1,599 +0,0 @@
|
||||||
/*
|
|
||||||
* Various algorithms and data structures, licensed under the MIT-license.
|
|
||||||
* (c) 2010 by Johann Philipp Strathausen <strathausen@gmail.com>
|
|
||||||
* http://strathausen.eu
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
Bellman-Ford
|
|
||||||
|
|
||||||
Path-finding algorithm, finds the shortest paths from one node to all nodes.
|
|
||||||
|
|
||||||
|
|
||||||
Complexity
|
|
||||||
|
|
||||||
O( |E| · |V| ), where E = edges and V = vertices (nodes)
|
|
||||||
|
|
||||||
|
|
||||||
Constraints
|
|
||||||
|
|
||||||
Can run on graphs with negative edge weights as long as they do not have
|
|
||||||
any negative weight cycles.
|
|
||||||
|
|
||||||
*/
|
|
||||||
function bellman_ford(g, source) {
|
|
||||||
|
|
||||||
/* STEP 1: initialisation */
|
|
||||||
for(var n in g.nodes)
|
|
||||||
g.nodes[n].distance = Infinity;
|
|
||||||
/* predecessors are implicitly null */
|
|
||||||
source.distance = 0;
|
|
||||||
|
|
||||||
step("Initially, all distances are infinite and all predecessors are null.");
|
|
||||||
|
|
||||||
/* STEP 2: relax each edge (this is at the heart of Bellman-Ford) */
|
|
||||||
/* repeat this for the number of nodes minus one */
|
|
||||||
for(var i = 1; i < g.nodes.length; i++)
|
|
||||||
/* for each edge */
|
|
||||||
for(var e in g.edges) {
|
|
||||||
var edge = g.edges[e];
|
|
||||||
if(edge.source.distance + edge.weight < edge.target.distance) {
|
|
||||||
step("Relax edge between " + edge.source.id + " and " + edge.target.id + ".");
|
|
||||||
edge.target.distance = edge.source.distance + edge.weight;
|
|
||||||
edge.target.predecessor = edge.source;
|
|
||||||
}
|
|
||||||
//Added by Jake Stothard (Needs to be tested)
|
|
||||||
if(!edge.style.directed) {
|
|
||||||
if(edge.target.distance + edge.weight < edge.source.distance) {
|
|
||||||
g.snapShot("Relax edge between "+edge.target.id+" and "+edge.source.id+".");
|
|
||||||
edge.source.distance = edge.target.distance + edge.weight;
|
|
||||||
edge.source.predecessor = edge.target;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
step("Ready.");
|
|
||||||
|
|
||||||
/* STEP 3: TODO Check for negative cycles */
|
|
||||||
/* For now we assume here that the graph does not contain any negative
|
|
||||||
weights cycles. (this is left as an excercise to the reader[tm]) */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
Path-finding algorithm Dijkstra
|
|
||||||
|
|
||||||
- worst-case running time is O((|E| + |V|) · log |V| ) thus better than
|
|
||||||
Bellman-Ford for sparse graphs (with less edges), but cannot handle
|
|
||||||
negative edge weights
|
|
||||||
*/
|
|
||||||
function dijkstra(g, source) {
|
|
||||||
|
|
||||||
/* initially, all distances are infinite and all predecessors are null */
|
|
||||||
for(var n in g.nodes)
|
|
||||||
g.nodes[n].distance = Infinity;
|
|
||||||
/* predecessors are implicitly null */
|
|
||||||
|
|
||||||
g.snapShot("Initially, all distances are infinite and all predecessors are null.");
|
|
||||||
|
|
||||||
source.distance = 0;
|
|
||||||
/* set of unoptimized nodes, sorted by their distance (but a Fibonacci heap
|
|
||||||
would be better) */
|
|
||||||
var q = new BinaryMinHeap(g.nodes, "distance");
|
|
||||||
|
|
||||||
/* pointer to the node in focus */
|
|
||||||
var node;
|
|
||||||
|
|
||||||
/* get the node with the smallest distance
|
|
||||||
as long as we have unoptimized nodes. q.min() can have O(log n). */
|
|
||||||
while(q.min() != undefined) {
|
|
||||||
/* remove the latest */
|
|
||||||
node = q.extractMin();
|
|
||||||
node.optimized = true;
|
|
||||||
|
|
||||||
/* no nodes accessible from this one, should not happen */
|
|
||||||
if(node.distance == Infinity)
|
|
||||||
throw "Orphaned node!";
|
|
||||||
|
|
||||||
/* for each neighbour of node */
|
|
||||||
for(e in node.edges) {
|
|
||||||
var other = (node == node.edges[e].target) ? node.edges[e].source : node.edges[e].target;
|
|
||||||
|
|
||||||
if(other.optimized)
|
|
||||||
continue;
|
|
||||||
|
|
||||||
/* look for an alternative route */
|
|
||||||
var alt = node.distance + node.edges[e].weight;
|
|
||||||
|
|
||||||
/* update distance and route if a better one has been found */
|
|
||||||
if (alt < other.distance) {
|
|
||||||
|
|
||||||
/* update distance of neighbour */
|
|
||||||
other.distance = alt;
|
|
||||||
|
|
||||||
/* update priority queue */
|
|
||||||
q.heapify();
|
|
||||||
|
|
||||||
/* update path */
|
|
||||||
other.predecessor = node;
|
|
||||||
g.snapShot("Enhancing node.")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* All-Pairs-Shortest-Paths */
|
|
||||||
/* Runs at worst in O(|V|³) and at best in Omega(|V|³) :-)
|
|
||||||
complexity Sigma(|V|²) */
|
|
||||||
/* This implementation is not yet ready for general use, but works with the
|
|
||||||
Dracula graph library. */
|
|
||||||
function floyd_warshall(g, source) {
|
|
||||||
|
|
||||||
/* Step 1: initialising empty path matrix (second dimension is implicit) */
|
|
||||||
var path = [];
|
|
||||||
var next = [];
|
|
||||||
var n = g.nodes.length;
|
|
||||||
|
|
||||||
/* construct path matrix, initialize with Infinity */
|
|
||||||
for(j in g.nodes) {
|
|
||||||
path[j] = [];
|
|
||||||
next[j] = [];
|
|
||||||
for(i in g.nodes)
|
|
||||||
path[j][i] = j == i ? 0 : Infinity;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* initialize path with edge weights */
|
|
||||||
for(e in g.edges)
|
|
||||||
path[g.edges[e].source.id][g.edges[e].target.id] = g.edges[e].weight;
|
|
||||||
|
|
||||||
/* Note: Usually, the initialisation is done by getting the edge weights
|
|
||||||
from a node matrix representation of the graph, not by iterating through
|
|
||||||
a list of edges as done here. */
|
|
||||||
|
|
||||||
/* Step 2: find best distances (the heart of Floyd-Warshall) */
|
|
||||||
for(k in g.nodes){
|
|
||||||
for(i in g.nodes) {
|
|
||||||
for(j in g.nodes)
|
|
||||||
if(path[i][j] > path[i][k] + path[k][j]) {
|
|
||||||
path[i][j] = path[i][k] + path[k][j];
|
|
||||||
/* Step 2.b: remember the path */
|
|
||||||
next[i][j] = k;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Step 3: Path reconstruction, get shortest path */
|
|
||||||
function getPath(i, j) {
|
|
||||||
if(path[i][j] == Infinity)
|
|
||||||
throw "There is no path.";
|
|
||||||
var intermediate = next[i][j];
|
|
||||||
if(intermediate == undefined)
|
|
||||||
return null;
|
|
||||||
else
|
|
||||||
return getPath(i, intermediate)
|
|
||||||
.concat([intermediate])
|
|
||||||
.concat(getPath(intermediate, j));
|
|
||||||
}
|
|
||||||
|
|
||||||
/* TODO use the knowledge, e.g. mark path in graph */
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
Ford-Fulkerson
|
|
||||||
|
|
||||||
Max-Flow-Min-Cut Algorithm finding the maximum flow through a directed
|
|
||||||
graph from source to sink.
|
|
||||||
|
|
||||||
|
|
||||||
Complexity
|
|
||||||
|
|
||||||
O(E * max(f)), max(f) being the maximum flow
|
|
||||||
|
|
||||||
|
|
||||||
Description
|
|
||||||
|
|
||||||
As long as there is an open path through the residual graph, send the
|
|
||||||
minimum of the residual capacities on the path.
|
|
||||||
|
|
||||||
|
|
||||||
Constraints
|
|
||||||
|
|
||||||
The algorithm works only if all weights are integers. Otherwise it is
|
|
||||||
possible that the Ford–Fulkerson algorithm will not converge to the maximum
|
|
||||||
value.
|
|
||||||
|
|
||||||
|
|
||||||
Input
|
|
||||||
|
|
||||||
g - Graph object
|
|
||||||
s - Source ID
|
|
||||||
t - Target (sink) ID
|
|
||||||
|
|
||||||
|
|
||||||
Output
|
|
||||||
|
|
||||||
Maximum flow from Source s to Target t
|
|
||||||
|
|
||||||
*/
|
|
||||||
/*
|
|
||||||
Edmonds-Karp
|
|
||||||
|
|
||||||
Max-Flow-Min-Cut Algorithm finding the maximum flow through a directed
|
|
||||||
graph from source to sink. An implementation of the Ford-Fulkerson
|
|
||||||
algorithm.
|
|
||||||
|
|
||||||
|
|
||||||
Complexity
|
|
||||||
|
|
||||||
O(|V|*|E|²)
|
|
||||||
|
|
||||||
|
|
||||||
Input
|
|
||||||
|
|
||||||
g - Graph object (with node and edge lists, capacity is a property of edge)
|
|
||||||
s - source ID
|
|
||||||
t - sink ID
|
|
||||||
|
|
||||||
*/
|
|
||||||
function edmonds_karp(g, s, t) {
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
A simple binary min-heap serving as a priority queue
|
|
||||||
- takes an array as the input, with elements having a key property
|
|
||||||
- elements will look like this:
|
|
||||||
{
|
|
||||||
key: "... key property ...",
|
|
||||||
value: "... element content ..."
|
|
||||||
}
|
|
||||||
- provides insert(), min(), extractMin() and heapify()
|
|
||||||
- example usage (e.g. via the Firebug or Chromium console):
|
|
||||||
var x = {foo: 20, hui: "bla"};
|
|
||||||
var a = new BinaryMinHeap([x,{foo:3},{foo:10},{foo:20},{foo:30},{foo:6},{foo:1},{foo:3}],"foo");
|
|
||||||
console.log(a.extractMin());
|
|
||||||
console.log(a.extractMin());
|
|
||||||
x.foo = 0; // update key
|
|
||||||
a.heapify(); // call this always after having a key updated
|
|
||||||
console.log(a.extractMin());
|
|
||||||
console.log(a.extractMin());
|
|
||||||
- can also be used on a simple array, like [9,7,8,5]
|
|
||||||
*/
|
|
||||||
function BinaryMinHeap(array, key) {
|
|
||||||
|
|
||||||
/* Binary tree stored in an array, no need for a complicated data structure */
|
|
||||||
var tree = [];
|
|
||||||
|
|
||||||
var key = key || 'key';
|
|
||||||
|
|
||||||
/* Calculate the index of the parent or a child */
|
|
||||||
var parent = function(index) { return Math.floor((index - 1)/2); };
|
|
||||||
var right = function(index) { return 2 * index + 2; };
|
|
||||||
var left = function(index) { return 2 * index + 1; };
|
|
||||||
|
|
||||||
/* Helper function to swap elements with their parent
|
|
||||||
as long as the parent is bigger */
|
|
||||||
function bubble_up(i) {
|
|
||||||
var p = parent(i);
|
|
||||||
while((p >= 0) && (tree[i][key] < tree[p][key])) {
|
|
||||||
/* swap with parent */
|
|
||||||
tree[i] = tree.splice(p, 1, tree[i])[0];
|
|
||||||
/* go up one level */
|
|
||||||
i = p;
|
|
||||||
p = parent(i);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Helper function to swap elements with the smaller of their children
|
|
||||||
as long as there is one */
|
|
||||||
function bubble_down(i) {
|
|
||||||
var l = left(i);
|
|
||||||
var r = right(i);
|
|
||||||
|
|
||||||
/* as long as there are smaller children */
|
|
||||||
while(tree[l] && (tree[i][key] > tree[l][key]) || tree[r] && (tree[i][key] > tree[r][key])) {
|
|
||||||
|
|
||||||
/* find smaller child */
|
|
||||||
var child = tree[l] ? tree[r] ? tree[l][key] > tree[r][key] ? r : l : l : l;
|
|
||||||
|
|
||||||
/* swap with smaller child with current element */
|
|
||||||
tree[i] = tree.splice(child, 1, tree[i])[0];
|
|
||||||
|
|
||||||
/* go up one level */
|
|
||||||
i = child;
|
|
||||||
l = left(i);
|
|
||||||
r = right(i);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Insert a new element with respect to the heap property
|
|
||||||
1. Insert the element at the end
|
|
||||||
2. Bubble it up until it is smaller than its parent */
|
|
||||||
this.insert = function(element) {
|
|
||||||
|
|
||||||
/* make sure there's a key property */
|
|
||||||
(element[key] == undefined) && (element = {key:element});
|
|
||||||
|
|
||||||
/* insert element at the end */
|
|
||||||
tree.push(element);
|
|
||||||
|
|
||||||
/* bubble up the element */
|
|
||||||
bubble_up(tree.length - 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Only show us the minimum */
|
|
||||||
this.min = function() {
|
|
||||||
return tree.length == 1 ? undefined : tree[0];
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Return and remove the minimum
|
|
||||||
1. Take the root as the minimum that we are looking for
|
|
||||||
2. Move the last element to the root (thereby deleting the root)
|
|
||||||
3. Compare the new root with both of its children, swap it with the
|
|
||||||
smaller child and then check again from there (bubble down)
|
|
||||||
*/
|
|
||||||
this.extractMin = function() {
|
|
||||||
var result = this.min();
|
|
||||||
|
|
||||||
/* move the last element to the root or empty the tree completely */
|
|
||||||
/* bubble down the new root if necessary */
|
|
||||||
(tree.length == 1) && (tree = []) || (tree[0] = tree.pop()) && bubble_down(0);
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* currently unused, TODO implement */
|
|
||||||
this.changeKey = function(index, key) {
|
|
||||||
throw "function not implemented";
|
|
||||||
}
|
|
||||||
|
|
||||||
this.heapify = function() {
|
|
||||||
for(var start = Math.floor((tree.length - 2) / 2); start >= 0; start--) {
|
|
||||||
bubble_down(start);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* insert the input elements one by one only when we don't have a key property (TODO can be done more elegant) */
|
|
||||||
for(i in (array || []))
|
|
||||||
this.insert(array[i]);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
Quick Sort:
|
|
||||||
1. Select some random value from the array, the median.
|
|
||||||
2. Divide the array in three smaller arrays according to the elements
|
|
||||||
being less, equal or greater than the median.
|
|
||||||
3. Recursively sort the array containg the elements less than the
|
|
||||||
median and the one containing elements greater than the median.
|
|
||||||
4. Concatenate the three arrays (less, equal and greater).
|
|
||||||
5. One or no element is always sorted.
|
|
||||||
TODO: This could be implemented more efficiently by using only one array object and several pointers.
|
|
||||||
*/
|
|
||||||
function quickSort(arr) {
|
|
||||||
/* recursion anchor: one element is always sorted */
|
|
||||||
if(arr.length <= 1) return arr;
|
|
||||||
/* randomly selecting some value */
|
|
||||||
var median = arr[Math.floor(Math.random() * arr.length)];
|
|
||||||
var arr1 = [], arr2 = [], arr3 = [];
|
|
||||||
for(var i in arr) {
|
|
||||||
arr[i] < median && arr1.push(arr[i]);
|
|
||||||
arr[i] == median && arr2.push(arr[i]);
|
|
||||||
arr[i] > median && arr3.push(arr[i]);
|
|
||||||
}
|
|
||||||
/* recursive sorting and assembling final result */
|
|
||||||
return quickSort(arr1).concat(arr2).concat(quickSort(arr3));
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
Selection Sort:
|
|
||||||
1. Select the minimum and remove it from the array
|
|
||||||
2. Sort the rest recursively
|
|
||||||
3. Return the minimum plus the sorted rest
|
|
||||||
4. An array with only one element is already sorted
|
|
||||||
*/
|
|
||||||
function selectionSort(arr) {
|
|
||||||
/* recursion anchor: one element is always sorted */
|
|
||||||
if(arr.length == 1) return arr;
|
|
||||||
var minimum = Infinity;
|
|
||||||
var index;
|
|
||||||
for(var i in arr) {
|
|
||||||
if(arr[i] < minimum) {
|
|
||||||
minimum = arr[i];
|
|
||||||
index = i; /* remember the minimum index for later removal */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/* remove the minimum */
|
|
||||||
arr.splice(index, 1);
|
|
||||||
/* assemble result and sort recursively (could be easily done iteratively as well)*/
|
|
||||||
return [minimum].concat(selectionSort(arr));
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
Merge Sort:
|
|
||||||
1. Cut the array in half
|
|
||||||
2. Sort each of them recursively
|
|
||||||
3. Merge the two sorted arrays
|
|
||||||
4. An array with only one element is considered sorted
|
|
||||||
|
|
||||||
*/
|
|
||||||
function mergeSort(arr) {
|
|
||||||
/* merges two sorted arrays into one sorted array */
|
|
||||||
function merge(a, b) {
|
|
||||||
/* result set */
|
|
||||||
var c = [];
|
|
||||||
/* as long as there are elements in the arrays to be merged */
|
|
||||||
while(a.length > 0 || b.length > 0){
|
|
||||||
/* are there elements to be merged, if yes, compare them and merge */
|
|
||||||
var n = a.length > 0 && b.length > 0 ? a[0] < b[0] ? a.shift() : b.shift() : b.length > 0 ? b.shift() : a.length > 0 ? a.shift() : null;
|
|
||||||
/* always push the smaller one onto the result set */
|
|
||||||
n != null && c.push(n);
|
|
||||||
}
|
|
||||||
return c;
|
|
||||||
}
|
|
||||||
/* this mergeSort implementation cuts the array in half, wich should be fine with randomized arrays, but introduces the risk of a worst-case scenario */
|
|
||||||
median = Math.floor(arr.length / 2);
|
|
||||||
var part1 = arr.slice(0, median); /* for some reason it doesn't work if inserted directly in the return statement (tried so with firefox) */
|
|
||||||
var part2 = arr.slice(median - arr.length);
|
|
||||||
return arr.length <= 1 ? arr : merge(
|
|
||||||
mergeSort(part1), /* first half */
|
|
||||||
mergeSort(part2) /* second half */
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Balanced Red-Black-Tree */
|
|
||||||
function RedBlackTree(arr) {
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
function BTree(arr) {
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
function NaryTree(n, arr) {
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Knuth-Morris-Pratt string matching algorithm - finds a pattern in a text.
|
|
||||||
* FIXME: Doesn't work correctly yet.
|
|
||||||
*/
|
|
||||||
function kmp(p, t) {
|
|
||||||
|
|
||||||
/**
|
|
||||||
* PREFIX, OVERLAP or FALIURE function for KMP. Computes how many iterations
|
|
||||||
* the algorithm can skip after a mismatch.
|
|
||||||
*
|
|
||||||
* @input p - pattern (string)
|
|
||||||
* @result array of skippable iterations
|
|
||||||
*/
|
|
||||||
function prefix(p) {
|
|
||||||
/* pi contains the computed skip marks */
|
|
||||||
var pi = [0], k = 0;
|
|
||||||
for(q = 1; q < p.length; q++) {
|
|
||||||
while(k > 0 && (p.charAt(k) != p.charAt(q)))
|
|
||||||
k = pi[k-1];
|
|
||||||
|
|
||||||
(p.charAt(k) == p.charAt(q)) && k++;
|
|
||||||
|
|
||||||
pi[q] = k;
|
|
||||||
}
|
|
||||||
return pi;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* The actual KMP algorithm starts here. */
|
|
||||||
|
|
||||||
var pi = prefix(p), q = 0, result = [];
|
|
||||||
|
|
||||||
for(var i = 0; i < t.length; i++) {
|
|
||||||
/* jump forward as long as the character doesn't match */
|
|
||||||
while((q > 0) && (p.charAt(q) != t.charAt(i)))
|
|
||||||
q = pi[q];
|
|
||||||
|
|
||||||
(p.charAt(q) == t.charAt(i)) && q++;
|
|
||||||
|
|
||||||
(q == p.length) && result.push(i - p.length) && (q = pi[q]);
|
|
||||||
}
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* step for algorithm visualisation */
|
|
||||||
function step(comment, funct) {
|
|
||||||
//wait for input
|
|
||||||
//display comment (before or after waiting)
|
|
||||||
// next.wait();
|
|
||||||
/* execute callback function */
|
|
||||||
funct();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Curry - Function currying
|
|
||||||
* Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com
|
|
||||||
* Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php)
|
|
||||||
* Date: 10/4/2008
|
|
||||||
*
|
|
||||||
* @author Ariel Flesler
|
|
||||||
* @version 1.0.1
|
|
||||||
*/
|
|
||||||
function curry( fn ){
|
|
||||||
return function(){
|
|
||||||
var args = curry.args(arguments),
|
|
||||||
master = arguments.callee,
|
|
||||||
self = this;
|
|
||||||
|
|
||||||
return args.length >= fn.length ? fn.apply(self,args) : function(){
|
|
||||||
return master.apply( self, args.concat(curry.args(arguments)) );
|
|
||||||
};
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
curry.args = function( args ){
|
|
||||||
return Array.prototype.slice.call(args);
|
|
||||||
};
|
|
||||||
|
|
||||||
Function.prototype.curry = function(){
|
|
||||||
return curry(this);
|
|
||||||
};
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Topological Sort
|
|
||||||
*
|
|
||||||
* Sort a directed graph based on incoming edges
|
|
||||||
*
|
|
||||||
* Coded by Jake Stothard
|
|
||||||
*/
|
|
||||||
function topological_sort(g) {
|
|
||||||
//Mark nodes as "deleted" instead of actually deleting them
|
|
||||||
//That way we don't have to copy g
|
|
||||||
|
|
||||||
for(i in g.nodes)
|
|
||||||
g.nodes[i].deleted = false;
|
|
||||||
|
|
||||||
var ret = topological_sort_helper(g);
|
|
||||||
|
|
||||||
//Cleanup: Remove the deleted property
|
|
||||||
for(i in g.nodes)
|
|
||||||
delete g.nodes[i].deleted
|
|
||||||
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
function topological_sort_helper(g) {
|
|
||||||
//Find node with no incoming edges
|
|
||||||
var node;
|
|
||||||
for(i in g.nodes) {
|
|
||||||
if(g.nodes[i].deleted)
|
|
||||||
continue; //Bad style, meh
|
|
||||||
|
|
||||||
var incoming = false;
|
|
||||||
for(j in g.nodes[i].edges) {
|
|
||||||
if(g.nodes[i].edges[j].target == g.nodes[i]
|
|
||||||
&& g.nodes[i].edges[j].source.deleted == false) {
|
|
||||||
incoming = true;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if(!incoming) {
|
|
||||||
node = g.nodes[i];
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Either unsortable or done. Either way, GTFO
|
|
||||||
if(node == undefined)
|
|
||||||
return [];
|
|
||||||
|
|
||||||
//"Delete" node from g
|
|
||||||
node.deleted = true;
|
|
||||||
|
|
||||||
var tail = topological_sort_helper(g);
|
|
||||||
|
|
||||||
tail.unshift(node);
|
|
||||||
|
|
||||||
return tail;
|
|
||||||
}
|
|
||||||
|
|
@ -1,266 +0,0 @@
|
||||||
// seedrandom.js
|
|
||||||
// Author: David Bau 3/11/2010
|
|
||||||
//
|
|
||||||
// Defines a method Math.seedrandom() that, when called, substitutes
|
|
||||||
// an explicitly seeded RC4-based algorithm for Math.random(). Also
|
|
||||||
// supports automatic seeding from local or network sources of entropy.
|
|
||||||
//
|
|
||||||
// Usage:
|
|
||||||
//
|
|
||||||
// <script src=http://davidbau.com/encode/seedrandom-min.js></script>
|
|
||||||
//
|
|
||||||
// Math.seedrandom('yipee'); Sets Math.random to a function that is
|
|
||||||
// initialized using the given explicit seed.
|
|
||||||
//
|
|
||||||
// Math.seedrandom(); Sets Math.random to a function that is
|
|
||||||
// seeded using the current time, dom state,
|
|
||||||
// and other accumulated local entropy.
|
|
||||||
// The generated seed string is returned.
|
|
||||||
//
|
|
||||||
// Math.seedrandom('yowza', true);
|
|
||||||
// Seeds using the given explicit seed mixed
|
|
||||||
// together with accumulated entropy.
|
|
||||||
//
|
|
||||||
// <script src="http://bit.ly/srandom-512"></script>
|
|
||||||
// Seeds using physical random bits downloaded
|
|
||||||
// from random.org.
|
|
||||||
//
|
|
||||||
// Examples:
|
|
||||||
//
|
|
||||||
// Math.seedrandom("hello"); // Use "hello" as the seed.
|
|
||||||
// document.write(Math.random()); // Always 0.5463663768140734
|
|
||||||
// document.write(Math.random()); // Always 0.43973793770592234
|
|
||||||
// var rng1 = Math.random; // Remember the current prng.
|
|
||||||
//
|
|
||||||
// var autoseed = Math.seedrandom(); // New prng with an automatic seed.
|
|
||||||
// document.write(Math.random()); // Pretty much unpredictable.
|
|
||||||
//
|
|
||||||
// Math.random = rng1; // Continue "hello" prng sequence.
|
|
||||||
// document.write(Math.random()); // Always 0.554769432473455
|
|
||||||
//
|
|
||||||
// Math.seedrandom(autoseed); // Restart at the previous seed.
|
|
||||||
// document.write(Math.random()); // Repeat the 'unpredictable' value.
|
|
||||||
//
|
|
||||||
// Notes:
|
|
||||||
//
|
|
||||||
// Each time seedrandom('arg') is called, entropy from the passed seed
|
|
||||||
// is accumulated in a pool to help generate future seeds for the
|
|
||||||
// zero-argument form of Math.seedrandom, so entropy can be injected over
|
|
||||||
// time by calling seedrandom with explicit data repeatedly.
|
|
||||||
//
|
|
||||||
// On speed - This javascript implementation of Math.random() is about
|
|
||||||
// 3-10x slower than the built-in Math.random() because it is not native
|
|
||||||
// code, but this is typically fast enough anyway. Seeding is more expensive,
|
|
||||||
// especially if you use auto-seeding. Some details (timings on Chrome 4):
|
|
||||||
//
|
|
||||||
// Our Math.random() - avg less than 0.002 milliseconds per call
|
|
||||||
// seedrandom('explicit') - avg less than 0.5 milliseconds per call
|
|
||||||
// seedrandom('explicit', true) - avg less than 2 milliseconds per call
|
|
||||||
// seedrandom() - avg about 38 milliseconds per call
|
|
||||||
//
|
|
||||||
// LICENSE (BSD):
|
|
||||||
//
|
|
||||||
// Copyright 2010 David Bau, all rights reserved.
|
|
||||||
//
|
|
||||||
// Redistribution and use in source and binary forms, with or without
|
|
||||||
// modification, are permitted provided that the following conditions are met:
|
|
||||||
//
|
|
||||||
// 1. Redistributions of source code must retain the above copyright
|
|
||||||
// notice, this list of conditions and the following disclaimer.
|
|
||||||
//
|
|
||||||
// 2. Redistributions in binary form must reproduce the above copyright
|
|
||||||
// notice, this list of conditions and the following disclaimer in the
|
|
||||||
// documentation and/or other materials provided with the distribution.
|
|
||||||
//
|
|
||||||
// 3. Neither the name of this module nor the names of its contributors may
|
|
||||||
// be used to endorse or promote products derived from this software
|
|
||||||
// without specific prior written permission.
|
|
||||||
//
|
|
||||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
||||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
||||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
||||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
||||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
||||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
||||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
||||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
||||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
||||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
||||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||||
//
|
|
||||||
/**
|
|
||||||
* All code is in an anonymous closure to keep the global namespace clean.
|
|
||||||
*
|
|
||||||
* @param {number=} overflow
|
|
||||||
* @param {number=} startdenom
|
|
||||||
*/
|
|
||||||
(function (pool, math, width, chunks, significance, overflow, startdenom) {
|
|
||||||
|
|
||||||
|
|
||||||
//
|
|
||||||
// seedrandom()
|
|
||||||
// This is the seedrandom function described above.
|
|
||||||
//
|
|
||||||
math['seedrandom'] = function seedrandom(seed, use_entropy) {
|
|
||||||
var key = [];
|
|
||||||
var arc4;
|
|
||||||
|
|
||||||
// Flatten the seed string or build one from local entropy if needed.
|
|
||||||
seed = mixkey(flatten(
|
|
||||||
use_entropy ? [seed, pool] :
|
|
||||||
arguments.length ? seed :
|
|
||||||
[new Date().getTime(), pool, window], 3), key);
|
|
||||||
|
|
||||||
// Use the seed to initialize an ARC4 generator.
|
|
||||||
arc4 = new ARC4(key);
|
|
||||||
|
|
||||||
// Mix the randomness into accumulated entropy.
|
|
||||||
mixkey(arc4.S, pool);
|
|
||||||
|
|
||||||
// Override Math.random
|
|
||||||
|
|
||||||
// This function returns a random double in [0, 1) that contains
|
|
||||||
// randomness in every bit of the mantissa of the IEEE 754 value.
|
|
||||||
|
|
||||||
math['random'] = function random() { // Closure to return a random double:
|
|
||||||
var n = arc4.g(chunks); // Start with a numerator n < 2 ^ 48
|
|
||||||
var d = startdenom; // and denominator d = 2 ^ 48.
|
|
||||||
var x = 0; // and no 'extra last byte'.
|
|
||||||
while (n < significance) { // Fill up all significant digits by
|
|
||||||
n = (n + x) * width; // shifting numerator and
|
|
||||||
d *= width; // denominator and generating a
|
|
||||||
x = arc4.g(1); // new least-significant-byte.
|
|
||||||
}
|
|
||||||
while (n >= overflow) { // To avoid rounding up, before adding
|
|
||||||
n /= 2; // last byte, shift everything
|
|
||||||
d /= 2; // right using integer math until
|
|
||||||
x >>>= 1; // we have exactly the desired bits.
|
|
||||||
}
|
|
||||||
return (n + x) / d; // Form the number within [0, 1).
|
|
||||||
};
|
|
||||||
|
|
||||||
// Return the seed that was used
|
|
||||||
return seed;
|
|
||||||
};
|
|
||||||
|
|
||||||
//
|
|
||||||
// ARC4
|
|
||||||
//
|
|
||||||
// An ARC4 implementation. The constructor takes a key in the form of
|
|
||||||
// an array of at most (width) integers that should be 0 <= x < (width).
|
|
||||||
//
|
|
||||||
// The g(count) method returns a pseudorandom integer that concatenates
|
|
||||||
// the next (count) outputs from ARC4. Its return value is a number x
|
|
||||||
// that is in the range 0 <= x < (width ^ count).
|
|
||||||
//
|
|
||||||
/** @constructor */
|
|
||||||
function ARC4(key) {
|
|
||||||
var t, u, me = this, keylen = key.length;
|
|
||||||
var i = 0, j = me.i = me.j = me.m = 0;
|
|
||||||
me.S = [];
|
|
||||||
me.c = [];
|
|
||||||
|
|
||||||
// The empty key [] is treated as [0].
|
|
||||||
if (!keylen) { key = [keylen++]; }
|
|
||||||
|
|
||||||
// Set up S using the standard key scheduling algorithm.
|
|
||||||
while (i < width) { me.S[i] = i++; }
|
|
||||||
for (i = 0; i < width; i++) {
|
|
||||||
t = me.S[i];
|
|
||||||
j = lowbits(j + t + key[i % keylen]);
|
|
||||||
u = me.S[j];
|
|
||||||
me.S[i] = u;
|
|
||||||
me.S[j] = t;
|
|
||||||
}
|
|
||||||
|
|
||||||
// The "g" method returns the next (count) outputs as one number.
|
|
||||||
me.g = function getnext(count) {
|
|
||||||
var s = me.S;
|
|
||||||
var i = lowbits(me.i + 1); var t = s[i];
|
|
||||||
var j = lowbits(me.j + t); var u = s[j];
|
|
||||||
s[i] = u;
|
|
||||||
s[j] = t;
|
|
||||||
var r = s[lowbits(t + u)];
|
|
||||||
while (--count) {
|
|
||||||
i = lowbits(i + 1); t = s[i];
|
|
||||||
j = lowbits(j + t); u = s[j];
|
|
||||||
s[i] = u;
|
|
||||||
s[j] = t;
|
|
||||||
r = r * width + s[lowbits(t + u)];
|
|
||||||
}
|
|
||||||
me.i = i;
|
|
||||||
me.j = j;
|
|
||||||
return r;
|
|
||||||
};
|
|
||||||
// For robust unpredictability discard an initial batch of values.
|
|
||||||
// See http://www.rsa.com/rsalabs/node.asp?id=2009
|
|
||||||
me.g(width);
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// flatten()
|
|
||||||
// Converts an object tree to nested arrays of strings.
|
|
||||||
//
|
|
||||||
/** @param {Object=} result
|
|
||||||
* @param {string=} prop */
|
|
||||||
function flatten(obj, depth, result, prop) {
|
|
||||||
result = [];
|
|
||||||
if (depth && typeof(obj) == 'object') {
|
|
||||||
for (prop in obj) {
|
|
||||||
if (prop.indexOf('S') < 5) { // Avoid FF3 bug (local/sessionStorage)
|
|
||||||
try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return result.length ? result : '' + obj;
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// mixkey()
|
|
||||||
// Mixes a string seed into a key that is an array of integers, and
|
|
||||||
// returns a shortened string seed that is equivalent to the result key.
|
|
||||||
//
|
|
||||||
/** @param {number=} smear
|
|
||||||
* @param {number=} j */
|
|
||||||
function mixkey(seed, key, smear, j) {
|
|
||||||
seed += ''; // Ensure the seed is a string
|
|
||||||
smear = 0;
|
|
||||||
for (j = 0; j < seed.length; j++) {
|
|
||||||
key[lowbits(j)] =
|
|
||||||
lowbits((smear ^= key[lowbits(j)] * 19) + seed.charCodeAt(j));
|
|
||||||
}
|
|
||||||
seed = '';
|
|
||||||
for (j in key) { seed += String.fromCharCode(key[j]); }
|
|
||||||
return seed;
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// lowbits()
|
|
||||||
// A quick "n mod width" for width a power of 2.
|
|
||||||
//
|
|
||||||
function lowbits(n) { return n & (width - 1); }
|
|
||||||
|
|
||||||
//
|
|
||||||
// The following constants are related to IEEE 754 limits.
|
|
||||||
//
|
|
||||||
startdenom = math.pow(width, chunks);
|
|
||||||
significance = math.pow(2, significance);
|
|
||||||
overflow = significance * 2;
|
|
||||||
|
|
||||||
//
|
|
||||||
// When seedrandom.js is loaded, we immediately mix a few bits
|
|
||||||
// from the built-in RNG into the entropy pool. Because we do
|
|
||||||
// not want to intefere with determinstic PRNG state later,
|
|
||||||
// seedrandom will not call math.random on its own again after
|
|
||||||
// initialization.
|
|
||||||
//
|
|
||||||
mixkey(math.random(), pool);
|
|
||||||
|
|
||||||
// End anonymous scope, and pass initial values.
|
|
||||||
})(
|
|
||||||
[], // pool: entropy pool starts empty
|
|
||||||
Math, // math: package containing random, pow, and seedrandom
|
|
||||||
256, // width: each RC4 output is 0 <= x < 256
|
|
||||||
6, // chunks: at least six RC4 outputs for each double
|
|
||||||
52 // significance: there are 52 significant digits in a double
|
|
||||||
);
|
|
||||||
Loading…
Reference in a new issue