Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • opentrafficshaper/opentrafficshaper
  • eezysol/opentrafficshaper
  • sudesh/opentrafficshaper
  • Yuriy/opentrafficshaper
  • nkukard/opentrafficshaper
  • fcardoso/opentrafficshaper
6 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 2759 additions and 441 deletions
opentrafficshaper/plugins/webserver/pages/static/logo-inverted-short.png 0 → 100644
View file @ efc9ebe1
opentrafficshaper/plugins/webserver/pages/static/logo-inverted-short.png

4.85 KiB

opentrafficshaper/plugins/webserver/pages/static/logo-inverted.png 0 → 100644
View file @ efc9ebe1
opentrafficshaper/plugins/webserver/pages/static/logo-inverted.png

5.59 KiB

opentrafficshaper/plugins/webserver/pages/static/logo.png 0 → 100644
View file @ efc9ebe1
opentrafficshaper/plugins/webserver/pages/static/logo.png

5.54 KiB

opentrafficshaper/plugins/webserver/pages/statistics.pm 0 → 100644
View file @ efc9ebe1
# OpenTrafficShaper webserver module: statistics page
# Copyright (C) 2007-2023, AllWorldIT
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
package opentrafficshaper::plugins::webserver::pages::statistics;
use strict;
use warnings;
# Exporter stuff
require Exporter;
our (@ISA,@EXPORT,@EXPORT_OK);
@ISA = qw(Exporter);
@EXPORT = qw(
);
@EXPORT_OK = qw(
);
use DateTime;
use HTML::Entities;
use HTTP::Status qw(
:constants
);
use JSON;
use URI;
use URI::Escape qw(
uri_escape
);
use awitpt::util qw(
parseURIQuery
isNumber
);
use opentrafficshaper::logger;
use opentrafficshaper::plugins;
use opentrafficshaper::plugins::configmanager qw(
getPoolByName
getInterfaceGroup
getInterfaceGroups
getInterface
getTrafficClass
getAllTrafficClasses
isTrafficClassIDValid
);
use opentrafficshaper::plugins::statistics::statistics;
# Graphs to display on pools stat page
sub POOL_GRAPHS {
{
3600 => 'Last Hour',
86400 => 'Last 24 Hours',
604800 => 'Last 7 Days',
2419200 => 'Last Month'
}
};
# Graphs by pool
sub byPool
{
my ($kernel,$system,$client_session_id,$request) = @_;
# Header
my $content = "";
# Check request
if ($request->method ne "GET") {
$content .=<<EOF;
<p class="info text-center">Invalid Method</p>
EOF
goto END;
}
# Parse GET data
my $queryParams = $request->uri->query_form_hash;
# We need our PID
if (!defined($queryParams->{'pool'})) {
$content .=<<EOF;
<p class="info text-center">No "pool" in Query String</p>
EOF
goto END;
}
# Check we have an interface group ID and pool name
my ($interfaceGroupID,$poolName) = split(/:/,$queryParams->{'pool'});
if (!defined($interfaceGroupID) || !defined($poolName)) {
$content .=<<EOF;
<p class="info text-center">Format of "pool" option is invalid, use InterfaceGroupID:PoolName</p>
EOF
goto END;
}
# Check if we get some data back when pulling in the pool from the backend
my $pool;
if (!defined($pool = getPoolByName($interfaceGroupID,$poolName))) {
$content .=<<EOF;
<p class="info text-center">Pool Not Found</p>
EOF
goto END;
}
# Header for the page
$content .= <<EOF;
<legend>
<a href="/limits/pool-list"><span class="glyphicon glyphicon-circle-arrow-left"></span></a>
Pool Stats View
</legend>
EOF
my $timespan = 900;
my $now = time();
my $startTimestamp = $now - $timespan;
# Menu setup
my $menu = [
{
'name' => 'Graphs',
'items' => [
{
'name' => 'Live',
'link' => sprintf("by-pool?pool=%s",uri_escape("$interfaceGroupID:$poolName"))
},
{
'name' => 'Historical',
'link' => sprintf("by-pool?pool=%s&static=1",uri_escape("$interfaceGroupID:$poolName"))
}
]
}
];
my $name = (defined($pool->{'FriendlyName'}) && $pool->{'FriendlyName'} ne "") ? $pool->{'FriendlyName'} :
$pool->{'Name'};
my $nameEncoded = encode_entities($name);
# Build content
$content .= <<EOF;
EOF
# Graphs to display
my @graphs = ();
# Check if we doing a static display or not
if (defined($queryParams->{'static'}) && $queryParams->{'static'}) {
# Loop with periods to display on this page
foreach my $period (sort { $a <=> $b } keys %{POOL_GRAPHS()}) {
my $canvasName = "flotCanvas$period";
my $graphName = POOL_GRAPHS()->{$period};
my $now = time();
my $startTimestamp = $now - $period;
$content .= <<EOF;
<h4 style="color: #8F8F8F;">Statistics: $nameEncoded - $graphName</h4>
<div id="$canvasName" class="flotCanvas poolCanvas" style="width: 800px; height: 240px" ></div>
EOF
# Static graphs
push(@graphs,{
'Type' => 'graph',
'Tag' => $canvasName,
'Title' => sprintf("Pool: %s",$pool->{'Name'}),
'Datasources' => [
{
'Type' => 'ajax',
'Subscriptions' => [
{
'Type' => 'pool',
'Data' => sprintf('%s:%s',$pool->{'InterfaceGroupID'},$pool->{'Name'}),
'StartTimestamp' => $startTimestamp,
'EndTimestamp' => $now
}
]
}
],
'XIdentifiers' => [
{ 'Name' => 'tx.cir', 'Label' => "TX Cir", 'Timespan' => $period },
{ 'Name' => 'tx.limit', 'Label' => "TX Limit", 'Timespan' => $period },
{ 'Name' => 'tx.rate', 'Label' => "TX Rate", 'Timespan' => $period },
{ 'Name' => 'rx.cir', 'Label' => "RX Cir", 'Timespan' => $period },
{ 'Name' => 'rx.limit', 'Label' => "RX Limit", 'Timespan' => $period },
{ 'Name' => 'rx.rate', 'Label' => "RX Rate", 'Timespan' => $period }
]
});
}
# Display live graph
} else {
my $canvasName = "flotCanvas";
$content .= <<EOF;
<h4 style="color: #8F8F8F;">Live Statistics: $nameEncoded</h4>
<div id="$canvasName" class="flotCanvas poolCanvas" style="width: 1000px; height: 400px" />
EOF
# Live graph
push(@graphs,{
'Type' => 'graph',
'Tag' => $canvasName,
'Title' => sprintf("Pool: %s",$pool->{'Name'}),
'Datasources' => [
{
'Type' => 'websocket',
'Subscriptions' => [
sprintf('pool=%s:%s',$pool->{'InterfaceGroupID'},$pool->{'Name'})
]
},
{
'Type' => 'ajax',
'Subscriptions' => [
{
'Type' => 'pool',
'Data' => sprintf('%s:%s',$pool->{'InterfaceGroupID'},$pool->{'Name'}),
'StartTimestamp' => $startTimestamp,
'EndTimestamp' => $now
}
]
}
],
'XIdentifiers' => [
{ 'Name' => 'tx.cir', 'Label' => "TX Cir", 'Timespan' => $timespan },
{ 'Name' => 'tx.limit', 'Label' => "TX Limit", 'Timespan' => $timespan },
{ 'Name' => 'tx.rate', 'Label' => "TX Rate", 'Timespan' => $timespan },
{ 'Name' => 'rx.cir', 'Label' => "RX Cir", 'Timespan' => $timespan },
{ 'Name' => 'rx.limit', 'Label' => "RX Limit", 'Timespan' => $timespan },
{ 'Name' => 'rx.rate', 'Label' => "RX Rate", 'Timespan' => $timespan }
]
});
}
# Build graphs
my $javascript = _buildGraphJavascript(\@graphs);
# Files loaded at end of HTML document
my @javascripts = (
'/static/flot/jquery.flot.min.js',
'/static/flot/jquery.flot.time.min.js',
'/static/flot/jquery.flot.pie.min.js',
'/static/flot/jquery.flot.resize.min.js',
'/static/js/flot-functions.js',
'/static/awit-flot-toolkit/js/jquery.flot.awitds.js',
'/static/awit-flot-toolkit/js/resize.js'
);
my @stylesheets = (
'/static/awit-flot-toolkit/css/awit-flot-toolkit.css'
);
END:
return (HTTP_OK,$content,{ 'menu' => $menu, 'javascripts' => \@javascripts, 'javascript' => $javascript });
}
# Graphs by class
sub byClass
{
my ($kernel,$system,$client_session_id,$request) = @_;
# Header
my $content = "";
# Check request
if ($request->method ne "GET") {
$content .=<<EOF;
<p class="info text-center">Invalid Method</p>
EOF
goto END;
}
# Parse GET data
my $queryParams = $request->uri->query_form_hash;
# We need our class definition
if (!defined($queryParams->{'class'})) {
$content .=<<EOF;
<p class="info text-center">No "class" in Query String</p>
EOF
goto END;
}
# Check we have an interface group ID and traffic class id
my ($interfaceGroupID,$trafficClassID) = split(/:/,$queryParams->{'class'});
if (!defined($interfaceGroupID) || !defined($trafficClassID)) {
$content .=<<EOF;
<p class="info text-center">Format of "class" option is invalid, use InterfaceGroupID:ClassID</p>
EOF
goto END;
}
# Check if we get some data back when pulling in the interface group from the backend
my $interfaceGroup;
if (!defined($interfaceGroup = getInterfaceGroup($interfaceGroupID))) {
$content .=<<EOF;
<p class="info text-center">Interface Group Not Found</p>
EOF
goto END;
}
# Check if we get some data back when pulling in the traffic class from the backend
my $trafficClass;
if (!defined($trafficClass = getTrafficClass($trafficClassID))) {
$content .=<<EOF;
<p class="info text-center">Traffic Class Not Found</p>
EOF
goto END;
}
# Header for the page
$content .= <<EOF;
<legend>
<a href="/statistics/igdashboard?interface-group=$interfaceGroupID">
<span class="glyphicon glyphicon-circle-arrow-left"></span>
</a>
Class Stats View
</legend>
EOF
# Menu setup
my $menu = [
{
'name' => 'Graphs',
'items' => [
{
'name' => 'Live',
'link' => sprintf("by-class?class=%s","$interfaceGroupID:$trafficClassID")
},
{
'name' => 'Historical',
'link' => sprintf("by-class?class=%s&static=1","$interfaceGroupID:$trafficClassID")
}
]
}
];
my $nameEncoded = encode_entities($trafficClass->{'Name'});
# Build content
$content .= <<EOF;
EOF
# Graphs to display
my @graphs = ();
# Check if we doing a static display or not
if (defined($queryParams->{'static'}) && $queryParams->{'static'}) {
# Loop with periods to display on this page
foreach my $period (sort { $a <=> $b } keys %{POOL_GRAPHS()}) {
my $canvasName = "flotCanvas$period";
my $graphName = POOL_GRAPHS()->{$period};
my $now = time();
my $startTimestamp = $now - $period;
$content .= <<EOF;
<h4 style="color: #8F8F8F;">Class Statistics: $nameEncoded - $graphName</h4>
<div id="$canvasName" class="flotCanvas poolCanvas" style="width: 800px; height: 240px" ></div>
EOF
# Static graphs
push(@graphs,{
'Type' => 'graph',
'Tag' => $canvasName,
'Title' => sprintf("Class: %s",$trafficClass->{'Name'}),
'Datasources' => [
{
'Type' => 'ajax',
'Subscriptions' => [
{
'Type' => 'class',
'Data' => sprintf('%s:%s',$interfaceGroupID,$trafficClassID),
'StartTimestamp' => $startTimestamp,
'EndTimestamp' => $now
}
]
}
],
'XIdentifiers' => [
{ 'Name' => 'tx.cir', 'Label' => "TX Cir", 'Timespan' => $period },
{ 'Name' => 'tx.limit', 'Label' => "TX Limit", 'Timespan' => $period },
{ 'Name' => 'tx.rate', 'Label' => "TX Rate", 'Timespan' => $period },
{ 'Name' => 'rx.cir', 'Label' => "RX Cir", 'Timespan' => $period },
{ 'Name' => 'rx.limit', 'Label' => "RX Limit", 'Timespan' => $period },
{ 'Name' => 'rx.rate', 'Label' => "RX Rate", 'Timespan' => $period }
]
});
}
# Display live graph
} else {
my $canvasName = "flotCanvas";
$content .= <<EOF;
<h4 style="color: #8F8F8F;">Live Statistics: $nameEncoded</h4>
<div id="$canvasName" class="flotCanvas poolCanvas" style="width: 1000px; height: 400px" />
EOF
# Live graph
push(@graphs,{
'Type' => 'graph',
'Tag' => $canvasName,
'Title' => sprintf("Class: %s",$trafficClass->{'Name'}),
'Datasources' => [
{
'Type' => 'websocket',
'Subscriptions' => [
sprintf('class=%s:%s',$interfaceGroupID,$trafficClassID)
]
}
],
'XIdentifiers' => [
{ 'Name' => 'tx.cir', 'Label' => "TX Cir", 'Timespan' => 900 },
{ 'Name' => 'tx.limit', 'Label' => "TX Limit", 'Timespan' => 900 },
{ 'Name' => 'tx.rate', 'Label' => "TX Rate", 'Timespan' => 900 },
{ 'Name' => 'rx.cir', 'Label' => "RX Cir", 'Timespan' => 900 },
{ 'Name' => 'rx.limit', 'Label' => "RX Limit", 'Timespan' => 900 },
{ 'Name' => 'rx.rate', 'Label' => "RX Rate", 'Timespan' => 900 }
]
});
}
# Build graphs
my $javascript = _buildGraphJavascript(\@graphs);
# Files loaded at end of HTML document
my @javascripts = (
'/static/flot/jquery.flot.min.js',
'/static/flot/jquery.flot.time.min.js',
'/static/flot/jquery.flot.pie.min.js',
'/static/flot/jquery.flot.resize.min.js',
'/static/js/flot-functions.js',
'/static/awit-flot-toolkit/js/jquery.flot.awitds.js',
'/static/awit-flot-toolkit/js/resize.js'
);
my @stylesheets = (
'/static/awit-flot-toolkit/css/awit-flot-toolkit.css'
);
END:
return (HTTP_OK,$content,{ 'menu' => $menu, 'javascripts' => \@javascripts, 'javascript' => $javascript });
}
# Dashboard display
sub dashboard
{
my ($kernel,$system,$client_session_id,$request) = @_;
# Header
my $content = <<EOF;
<legend>
Dashboard View
</legend>
EOF
# Build list of graphs for the left hand side
my @interfaceGroups = sort(getInterfaceGroups());
my @trafficClasses = sort(getAllTrafficClasses());
my $timespan = 900;
my $now = time();
my $startTimestamp = $now - $timespan;
my @graphs;
my $graphCounter = 0;
foreach my $interfaceGroupID (@interfaceGroups) {
my $interfaceGroup = getInterfaceGroup($interfaceGroupID);
push(@graphs,{
'.InterfaceGroup' => $interfaceGroup->{'ID'},
'Tag' => sprintf('tag%s',$graphCounter++),
'Type' => 'graph',
'Title' => sprintf("%s: Main",$interfaceGroup->{'Name'}),
'Datasources' => [
{
'Type' => 'websocket',
'Subscriptions' => [
sprintf('interface-group=%s',$interfaceGroupID),
]
},
{
'Type' => 'ajax',
'Subscriptions' => [
{
'Type' => 'interface-group',
'Data' => $interfaceGroupID,
'StartTimestamp' => $startTimestamp,
'EndTimestamp' => $now
}
]
}
],
'XIdentifiers' => [
{ 'Name' => 'tx.rate', 'Label' => "TX Rate", 'Timespan' => $timespan },
{ 'Name' => 'rx.rate', 'Label' => "RX Rate", 'Timespan' => $timespan }
]
});
}
foreach my $graph (@graphs) {
my $interfaceGroupEscaped = uri_escape($graph->{'.InterfaceGroup'});
$content .= <<EOF;
<div class="row">
<h4 class="text-center" style="color:#8f8f8f;">$graph->{'Title'}</h4>
<a href="/statistics/igdashboard?interface-group=$interfaceGroupEscaped">
<div id="$graph->{'Tag'}" class="flotCanvas poolCanvas"
style="width: 1000px; height: 250px; margin-left: auto; margin-right: auto;">
</div>
</a>
</div>
EOF
}
# Build graphs
my $javascript = _buildGraphJavascript(\@graphs);
# Files loaded at end of HTML document
my @javascripts = (
'/static/flot/jquery.flot.min.js',
'/static/flot/jquery.flot.time.min.js',
'/static/flot/jquery.flot.pie.min.js',
'/static/flot/jquery.flot.resize.min.js',
'/static/js/flot-functions.js',
'/static/awit-flot-toolkit/js/jquery.flot.awitds.js',
'/static/awit-flot-toolkit/js/resize.js'
);
my @stylesheets = (
'/static/awit-flot-toolkit/css/awit-flot-toolkit.css'
);
return (HTTP_OK,$content,{
'javascripts' => \@javascripts,
'javascript' => $javascript,
'stylesheets' => \@stylesheets
});
}
# Dashboard display for interface groups
sub igdashboard
{
my ($kernel,$system,$client_session_id,$request) = @_;
# Header
my $content = <<EOF;
<legend>
<a href="/statistics/dashboard"><span class="glyphicon glyphicon-circle-arrow-left"></span></a>
Interface Dashboard View
</legend>
EOF
# Get query params
my $queryParams = $request->uri->query_form_hash;
# We need our PID
if (!defined($queryParams->{'interface-group'})) {
$content .=<<EOF;
<p class="info text-center">No "interface-group" in Query String</p>
EOF
return (HTTP_TEMPORARY_REDIRECT,"/statistics");
}
my $interfaceGroup = getInterfaceGroup($queryParams->{'interface-group'});
if (!defined($interfaceGroup)) {
$content .=<<EOF;
<p class="info text-center">Invalid "interface-group" in Query String</p>
EOF
return (HTTP_TEMPORARY_REDIRECT,"/statistics");
}
# Left and right graphs are added to the main graph list
my @graphs = ();
# Left and right graphs
my @leftGraphs = ();
my @rightGraphs = ();
# Build list of graphs for the left hand side
my @trafficClasses = sort(getAllTrafficClasses());
my $timespan = 900;
my $now = time();
my $startTimestamp = $now - $timespan;
foreach my $trafficClassID (@trafficClasses) {
my $trafficClass = getTrafficClass($trafficClassID);
push(@leftGraphs,{
'Type' => 'graph',
'Title' => sprintf("%s: %s",$interfaceGroup->{'Name'},$trafficClass->{'Name'}),
'.URIData' => sprintf('%s:%s',$interfaceGroup->{'ID'},$trafficClassID),
'Datasources' => [
{
'Type' => 'websocket',
'Subscriptions' => [
sprintf('class=%s:%s',$interfaceGroup->{'ID'},$trafficClassID),
sprintf('counter=configmanager.classpoolmembers.%s',$trafficClassID)
]
},
{
'Type' => 'ajax',
'Subscriptions' => [
{
'Type' => 'class',
'Data' => sprintf('%s:%s',$interfaceGroup->{'ID'},$trafficClassID),
'StartTimestamp' => $startTimestamp,
'EndTimestamp' => $now
}
]
},
{
'Type' => 'ajax',
'Subscriptions' => [
{
'Type' => 'counter',
'Data' => sprintf('configmanager.classpoolmembers.%s',$trafficClassID),
'StartTimestamp' => $startTimestamp,
'EndTimestamp' => $now
}
]
}
],
'XIdentifiers' => [
{ 'Name' => 'tx.cir', 'Label' => "TX Cir", 'Timespan' => $timespan },
{ 'Name' => 'tx.limit', 'Label' => "TX Limit", 'Timespan' => $timespan },
{ 'Name' => 'tx.rate', 'Label' => "TX Rate", 'Timespan' => $timespan },
{ 'Name' => 'rx.cir', 'Label' => "RX Cir", 'Timespan' => $timespan },
{ 'Name' => 'rx.limit', 'Label' => "RX Limit", 'Timespan' => $timespan },
{ 'Name' => 'rx.rate', 'Label' => "RX Rate", 'Timespan' => $timespan }
],
'YIdentifiers' => [
{
'Name' => sprintf('configmanager.classpoolmembers.%s',$trafficClassID),
'Label' => "Pool Count",
'Timespan' => $timespan
},
]
});
}
# Pool distribution
my @dataSubscriptions = ();
my @xidentifiers = ();
foreach my $trafficClassID (@trafficClasses) {
my $trafficClass = getTrafficClass($trafficClassID);
push(@dataSubscriptions,sprintf('counter=configmanager.classpools.%s',$trafficClassID));
push(@xidentifiers,{
'Name' => sprintf('configmanager.classpools.%s',$trafficClassID),
'Label' => $trafficClass->{'Name'}
});
}
push(@rightGraphs,{
'Type' => 'pie',
'Title' => "Pool Distribution",
'Datasources' => [
{
'Type' => 'websocket',
'Subscriptions' => \@dataSubscriptions
}
],
'XIdentifiers' => \@xidentifiers
});
# Loop while we have graphs to output
my $graphCounter = 0;
while (@leftGraphs || @rightGraphs) {
# Layout Begin
$content .= <<EOF;
<div class="row">
EOF
# LHS - Begin
$content .= <<EOF;
<div class="col-md-8">
EOF
# Loop with 2 sets of normal graphs per row
for (my $row = 0; $row < 2; $row++) {
# LHS - Begin Row
$content .= <<EOF;
<div class="row">
<div class="col-xs-6">
EOF
# Graph 1
if (defined(my $graph = shift(@leftGraphs))) {
my $uriData = $graph->{'.URIData'};
# Assign this graph a tag
$graph->{'Tag'} = "tag".$graphCounter++;
$content .= <<EOF;
<h4 style="color:#8f8f8f;">$graph->{'Title'}</h4>
<a href="/statistics/by-class?class=$uriData">
<div id="$graph->{'Tag'}" class="flotCanvas dashboardCanvas"
style="width: 600px; height: 250px"></div>
</a>
EOF
push(@graphs,$graph);
}
# LHS - Spacer
$content .= <<EOF;
</div>
<div class="col-xs-6">
EOF
# Graph 2
if (defined(my $graph = shift(@leftGraphs))) {
my $uriData = $graph->{'.URIData'};
# Assign this graph a tag
$graph->{'Tag'} = "tag".$graphCounter++;
$content .= <<EOF;
<h4 style="color:#8f8f8f;">$graph->{'Title'}</h4>
<a href="/statistics/by-class?class=$uriData">
<div id="$graph->{'Tag'}" class="flotCanvas dashboardCanvas"
style="width: 600px; height: 250px"></div>
</a>
EOF
push(@graphs,$graph);
}
# LHS - End Row
$content .= <<EOF;
</div>
</div>
EOF
}
# LHS - End
$content .= <<EOF;
</div>
EOF
# RHS - Begin Row
$content .= <<EOF;
<div class="col-md-4">
EOF
# Graph
if (defined(my $graph = shift(@rightGraphs))) {
# Assign this graph a tag
$graph->{'Tag'} = "tag".$graphCounter++;
$content .= <<EOF;
<h4 style="color:#8f8f8f;">$graph->{'Title'}</h4>
<div id="$graph->{'Tag'}" class="flotCanvas dashboardCanvas" style="width: 600px; height: 340px"></div>
EOF
push(@graphs,$graph);
}
# RHS - End Row
$content .= <<EOF;
</div>
EOF
# Layout End
$content .= <<EOF;
</div>
EOF
}
# Build graphs
my $javascript = _buildGraphJavascript(\@graphs);
# Files loaded at end of HTML document
my @javascripts = (
'/static/flot/jquery.flot.min.js',
'/static/flot/jquery.flot.time.min.js',
'/static/flot/jquery.flot.pie.min.js',
'/static/flot/jquery.flot.resize.min.js',
'/static/js/flot-functions.js',
'/static/awit-flot-toolkit/js/jquery.flot.awitds.js',
'/static/awit-flot-toolkit/js/resize.js'
);
my @stylesheets = (
'/static/awit-flot-toolkit/css/awit-flot-toolkit.css'
);
END:
return (HTTP_OK,$content,{
'javascripts' => \@javascripts,
'javascript' => $javascript,
'stylesheets' => \@stylesheets
});
}
# Return data in json format
#
# Supported URLs:
#
# pool=<tag>:<interface-group-id>:<pool-name>
#
# class=<tag>:<interface-group-id>:<class-id>,...
#
# interface-group=<tag>:<interface-group>,...
#
# counter=<tag>:<counter>,...
#
# max=<max number of entries to return, default 100>
#
# key=<data key to return>
sub jsondata
{
my ($kernel,$system,$client_session_id,$request) = @_;
# Parse GET data
my $queryParams = $request->uri->query_form_hash;
my $rawData = { };
# Check for some things that apply to all types of data
my $startTimestamp;
my $endTimestamp;
if (defined($queryParams->{'start'})) {
$startTimestamp = isNumber($queryParams->{'start'});
}
if (defined($queryParams->{'end'})) {
$endTimestamp = isNumber($queryParams->{'end'});
}
# Process pools
if (defined($queryParams->{'pool'})) {
# Simple de-dupication
my %poolSpecs;
foreach my $poolSpec ($request->uri->query_param('pool')) {
$poolSpecs{$poolSpec} = 1;
}
# Then loop through the unique keys
foreach my $poolSpec (keys %poolSpecs) {
# Check we have a tag, interface group ID and pool name
my ($tag,$rawInterfaceGroupID,$rawPoolName) = split(/:/,$poolSpec);
if (!defined($tag)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Invalid format for pool specification '%s'",
$poolSpec
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Invalid format for pool specification '$poolSpec'"},
{ 'type' => 'json' });
}
if (!defined($rawInterfaceGroupID)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' has an invalid interface group ID '%s'",
$tag,
$poolSpec
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Tag '$tag' has invalid interface group ID '$rawPoolName'"},
{ 'type' => 'json' });
}
# Check if we can grab the interface group
my $interfaceGroup = getInterfaceGroup($rawInterfaceGroupID);
if (!defined($interfaceGroup)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' has an invalid interface group ID '%s'",
$tag,
$rawInterfaceGroupID
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Tag '$tag' has an invalid interface group ID ".
"'$rawInterfaceGroupID'"},
{ 'type' => 'json' });
}
if (!defined($rawPoolName)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' has an invalid pool name '%s'",
$tag,
$poolSpec
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Tag '$tag' has an invalid pool name '$rawPoolName'"},
{ 'type' => 'json' });
}
# Grab pool
my $pool = getPoolByName($rawInterfaceGroupID,$rawPoolName);
if (!defined($pool)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' has an invalid pool name '%s'",
$tag,
$rawPoolName
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Tag '$tag' has an invalid pool name '$rawPoolName'"},
{ 'type' => 'json' });
}
# Grab SID
my $sid = opentrafficshaper::plugins::statistics::getSIDFromPID($pool->{'ID'});
if (!defined($sid)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' stats data cannot be found for pool ".
"'%s'",
$tag,
$rawPoolName
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Tag '$tag' stats data cannot be found for pool '$rawPoolName'"},
{ 'type' => 'json' });
}
# Pull in stats data
my $statsData = opentrafficshaper::plugins::statistics::getStatsBySID($sid,undef,$startTimestamp,$endTimestamp);
# Loop with timestamps
foreach my $timestamp (sort keys %{$statsData}) {
# Grab the stat
my $tstat = $statsData->{$timestamp};
# Loop with its keys
foreach my $item (keys %{$tstat}) {
# Add the keys to the data to return
push(@{$rawData->{$tag}->{$item}->{'data'}},[
$timestamp,
$tstat->{$item}
]);
}
}
}
}
# Process classes
if (defined($queryParams->{'class'})) {
# Simple de-dupication
my %trafficClassIDSpecs;
foreach my $rawClassID ($request->uri->query_param('class')) {
$trafficClassIDSpecs{$rawClassID} = 1;
}
# Then loop through the unique keys
foreach my $trafficClassIDSpec (keys %trafficClassIDSpecs) {
# Check we have a tag, interface group ID and class
my ($tag,$rawInterfaceGroupID,$rawClassID) = split(/:/,$trafficClassIDSpec);
if (!defined($tag)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Invalid format for class ID specification '%s'",
$trafficClassIDSpec
);
return (HTTP_OK,{
'status' => 'fail',
'message' => "Invalid format for class ID specification '$trafficClassIDSpec'"
},
{ 'type' => 'json' }
);
}
if (!defined($rawInterfaceGroupID)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' has an invalid interface group ID '%s'",
$tag,
$trafficClassIDSpec
);
return (HTTP_OK,{
'status' => 'fail',
'message' => "Tag '$tag' has an invalid interface group ID '$trafficClassIDSpec'"
},
{ 'type' => 'json' }
);
}
if (!defined($rawClassID)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' has an invalid class ID '%s'",
$tag,
$trafficClassIDSpec
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Tag '$tag' has an invalid class ID '$trafficClassIDSpec'"},
{ 'type' => 'json' });
}
# Get more sane values...
my $interfaceGroup = getInterfaceGroup($rawInterfaceGroupID);
if (!defined($interfaceGroup)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' has a non-existent interface group ID ".
"'%s'",
$tag,
$rawInterfaceGroupID
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Tag '$tag' has a non-existent interface group ID ".
"'$rawInterfaceGroupID'"},
{ 'type' => 'json' });
}
my $trafficClassID = isTrafficClassIDValid($rawClassID);
if (!defined($trafficClassID)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' has a non-existent class ID '%s'",
$tag,
$rawClassID
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Tag '$tag' has a non-existent class ID '$rawClassID'"},
{ 'type' => 'json' });
}
# Grab data for each direction associated with a class ID on an inteface group
foreach my $direction ('Tx','Rx') {
# Grab stats ID
my $sid = opentrafficshaper::plugins::statistics::getSIDFromCID($interfaceGroup->{"${direction}Interface"},
$trafficClassID);
if (!defined($sid)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' stats data cannot be found for ".
"class ID '%s'",
$tag,
$trafficClassID
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Tag '$tag' stats data cannot be found for class ID "
."'$trafficClassID'"},
{ 'type' => 'json' });
}
# Pull in stats data, override direction used
my $statsData = opentrafficshaper::plugins::statistics::getStatsBySID(
$sid,
{ 'Direction' => lc($direction) },
$startTimestamp,
$endTimestamp
);
# Loop with timestamps
foreach my $timestamp (sort keys %{$statsData}) {
# Grab the stat
my $tstat = $statsData->{$timestamp};
# Loop with its keys
foreach my $item (keys %{$tstat}) {
# Add the keys to the data to return
push(@{$rawData->{$tag}->{$item}->{'data'}},[
$timestamp,
$tstat->{$item}
]);
}
}
}
}
}
# Process interface groups
if (defined($queryParams->{'interface-group'})) {
# Simple de-dupication
my %interfaceGroupIDSpecs;
foreach my $rawInterfaceGroupID ($request->uri->query_param('interface-group')) {
$interfaceGroupIDSpecs{$rawInterfaceGroupID} = 1;
}
# Then loop through the unique keys
foreach my $interfaceGroupIDSpec (keys %interfaceGroupIDSpecs) {
# Check we have a tag, interface group ID and class
my ($tag,$rawInterfaceGroupID) = split(/:/,$interfaceGroupIDSpec);
if (!defined($tag)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Invalid format for interface group ".
"specification '%s'",
$interfaceGroupIDSpec
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Invalid format for interface group specification ".
"'$interfaceGroupIDSpec'"},
{ 'type' => 'json' });
}
if (!defined($rawInterfaceGroupID)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' has an invalid interface group ID '%s'",
$tag,
$interfaceGroupIDSpec
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Tag '$tag' has an invalid interface group ID ".
"'$interfaceGroupIDSpec'"},
{ 'type' => 'json' });
}
my $interfaceGroupID = getInterfaceGroup($rawInterfaceGroupID);
if (!defined($interfaceGroupID)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' has a non-existent interface group ID ".
"'%s'",
$tag,
$rawInterfaceGroupID
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Tag '$tag' has a non-existent interface group ID ".
"'$rawInterfaceGroupID'"},
{ 'type' => 'json' });
}
# Loop with both directions
foreach my $direction ('Tx','Rx') {
# Grab stats ID
my $sid = opentrafficshaper::plugins::statistics::getSIDFromCID($interfaceGroupID->{"${direction}Interface"},0);
if (!defined($sid)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' stats data cannot be found for ".
"interface group ID '%s'",
$tag,
$rawInterfaceGroupID
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Tag '$tag' stats data cannot be found for interface group ".
"ID '$rawInterfaceGroupID'"},
{ 'type' => 'json' });
}
# Pull in stats data, override direction used
my $statsData = opentrafficshaper::plugins::statistics::getStatsBySID(
$sid,
{ 'Direction' => lc($direction) },
$startTimestamp,
$endTimestamp
);
# Loop with timestamps
foreach my $timestamp (sort keys %{$statsData}) {
# Grab the stat
my $tstat = $statsData->{$timestamp};
# Loop with its keys
foreach my $item (keys %{$tstat}) {
# Add the keys to the data to return
push(@{$rawData->{$tag}->{$item}->{'data'}},[
$timestamp,
$tstat->{$item}
]);
}
}
}
}
}
# If we need to return a counter, lets see what there is we can return...
if (defined($queryParams->{'counter'})) {
# Lets get unique counters as keys
my %counterSpecs;
foreach my $rawCounterSpec (@{$queryParams->{'counter'}->{'values'}}) {
$counterSpecs{$rawCounterSpec} = 1;
}
# Then loop through the unique keys
foreach my $counterSpec (keys %counterSpecs) {
# Check we have a tag and counter
my ($tag,$rawCounter) = split(/:/,$counterSpec);
if (!defined($tag)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Invalid format for counter specification '%s'",
$counterSpec
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Invalid format for counter specification '$counterSpec'"},
{ 'type' => 'json' });
}
if (!defined($rawCounter)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' has an invalid interface group ID '%s'",
$tag,
$counterSpec
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Tag '$tag' has an invalid interface group ID ".
"'$counterSpec'"},
{ 'type' => 'json' });
}
# Grab the SID
my $sid = opentrafficshaper::plugins::statistics::getSIDFromCounter($rawCounter);
if (!defined($sid)) {
$system->{'logger'}->log(LOG_INFO,"[WEBSERVER/PAGES/STATISTICS] Tag '%s' has a non-existent counter '%s'",
$tag,
$counterSpec
);
return (HTTP_OK,{'status' => 'fail', 'message' => "Tag '$tag' has a non-existent counter ".
"'$counterSpec'"},
{ 'type' => 'json' });
}
# Pull in stats data
my $statsData = opentrafficshaper::plugins::statistics::getStatsBasicBySID($sid,{ 'Name' => $rawCounter });
# Loop with timestamps
foreach my $timestamp (sort keys %{$statsData}) {
# Grab the stat
my $tstat = $statsData->{$timestamp};
# Loop with its keys
foreach my $item (keys %{$tstat}) {
# Add the keys to the data to return
push(@{$rawData->{$tag}->{$item}->{'data'}},[
$timestamp,
$tstat->{$item}
]);
}
}
}
}
return (HTTP_OK,{'status' => 'success', 'data' => $rawData},{ 'type' => 'json' });
}
# Function to build the javascript we need to display graphs in a canvas
sub _buildGraphJavascript
{
my $graphs = shift;
my $javascript = "";
foreach my $graph (@{$graphs}) {
my $encodedCanvasName = encode_entities($graph->{'Tag'});
# Items we going to need...
my @datasources = ();
my $axesIdentifiers = { 'X' => [ ], 'Y' => [ ] };
my @axesStrList;
# Loop with and build the JS for our datasources
foreach my $datasource (@{$graph->{'Datasources'}}) {
# Websocket based data
if ($datasource->{'Type'} eq "websocket") {
# Create Subscriptions
my @subscriptions;
foreach my $subscription (@{$datasource->{'Subscriptions'}}) {
my $encodedSubscription = encode_entities($subscription);
push(@subscriptions,"{ 'function': 'subscribe', args: ['$encodedCanvasName','$encodedSubscription'] }");
}
# Create subscription string
my $subscriptionStr = join(',',@subscriptions);
# Add datasource
push(@datasources,<<EOF);
{
type: 'websocket',
uri: 'ws://'+window.location.host+'/statistics/graphdata',
shared: true,
// Websocket specific
onconnect: [
$subscriptionStr
]
}
EOF
# JSON based data
} elsif ($datasource->{'Type'} eq "ajax") {
# Create Subscriptions
my @subscriptions;
foreach my $subscription (@{$datasource->{'Subscriptions'}}) {
my $encodedType = encode_entities($subscription->{'Type'});
my $encodedData = encode_entities($subscription->{'Data'});
# Data we nee dto pull
push(@subscriptions,sprintf(
"%s=%s:%s",
$encodedType,
$encodedCanvasName,
$encodedData
));
# Check if we have a start period
if (defined($subscription->{'StartTimestamp'})) {
push(@subscriptions,sprintf("start=%s",$subscription->{'StartTimestamp'}));
}
# Check if we have an end period
if (defined($subscription->{'EndTimestamp'})) {
push(@subscriptions,sprintf("end=%s",$subscription->{'EndTimestamp'}));
}
}
# Create subscription string
my $subscriptionStr = join('&',@subscriptions);
# Add datasource
push(@datasources,<<EOF);
{
type: 'ajax',
url: '///'+window.location.host+'/statistics/jsondata?$subscriptionStr'
}
EOF
}
}
# Loop with axes and build our axes structure
foreach my $axis (keys %{$axesIdentifiers}) {
foreach my $identifier (@{$graph->{"${axis}Identifiers"}}) {
# Our first identifier option is the label
my @options = (
sprintf("label: '%s'", encode_entities($identifier->{'Label'}))
);
# Set limiting factors if there are any
if (defined($identifier->{'Timespan'})) {
push(@options,sprintf("maxTimespan: %s",$identifier->{'Timespan'}));
}
if (defined($identifier->{'Count'})) {
push(@options,sprintf("maxCount: %s",$identifier->{'Count'}));
}
# Join everything up
my $optionsStr = join(' ,',@options);
# Add to axes
push(@{$axesIdentifiers->{$axis}},sprintf("'%s': { %s }",encode_entities($identifier->{'Name'}),$optionsStr));
}
push(@axesStrList,
sprintf("%saxis: { '%s': { %s } }",lc($axis),$encodedCanvasName,join(',',@{$axesIdentifiers->{$axis}}))
);
}
# Build final JS
my $datasourceStr = join(',',@datasources);
my $axesStr = join(',',@axesStrList);
$javascript .=<<EOF;
awit_flot_draw_$graph->{'Type'}({
id: '$encodedCanvasName',
awitds: {
sources: [
$datasourceStr
],
$axesStr
}
});
EOF
}
return $javascript;
}
1;
# vim: ts=4
opentrafficshaper/plugins/webserver/pages/users.pm deleted 100644 → 0
View file @ 265fccd6
# OpenTrafficShaper webserver module: users page
# Copyright (C) 2007-2013, AllWorldIT
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
package opentrafficshaper::plugins::webserver::pages::users;
use strict;
use warnings;
# Exporter stuff
require Exporter;
our (@ISA,@EXPORT,@EXPORT_OK);
@ISA = qw(Exporter);
@EXPORT = qw(
);
@EXPORT_OK = qw(
);
use DateTime;
# Sidebar menu options for this module
my $menu = {
'Users' => {
'Show Users' => '',
},
'Admin' => {
'Add User' => 'add',
},
};
# Default page/action
sub default
{
my ($globals,$module,$daction,$request) = @_;
# If we not passed default by the main app, just return
return if ($daction ne "default");
# Build content
my $content = "";
# Header
$content .=<<EOF;
<table class="table">
<legend>User List</legend>
<thead>
<tr>
<th>#</th>
<th>User</th>
<th>IP</th>
<th>Source</th>
<th>LastUpdate</th>
<th>Class</th>
<th>Group</th>
<th>Limits</th>
</tr>
</thead>
<tbody>
EOF
# Body
foreach my $userid (keys %{$globals->{'users'}}) {
my $user = $globals->{'users'}->{$userid};
# Make style a bit pretty
my $style = "";
if ($user->{'Status'} eq "offline") {
$style = "warning";
} elsif ($user->{'Status'} eq "new") {
$style = "info";
}
# Get a nice last update string
my $lastUpdate = DateTime->from_epoch( epoch => $user->{'LastUpdate'} )->iso8601();
my $limits = $user->{'TrafficLimitTx'} . "/" . $user->{'TrafficLimitRx'};
$content .=<<EOF;
<tr class="$style">
<td>X</td>
<td>$user->{'Username'}</td>
<td>$user->{'IP'}</td>
<td>$user->{'Source'}</td>
<td>$lastUpdate</td>
<td>$user->{'ClassID'}</td>
<td>$user->{'GroupID'}</td>
<td>$limits</td>
</tr>
EOF
}
# No results
if (keys %{$globals->{'users'}} < 1) {
$content .=<<EOF;
<tr class="info">
<td colspan="8"><p class="text-center">No Results</p></td>
</tr>
EOF
}
# Footer
$content .=<<EOF;
</tbody>
</table>
EOF
return (200,$content,$menu);
}
# Add action
sub add
{
my ($globals,$module,$daction,$request) = @_;
# Build content
my $content = "";
# Header
$content .=<<EOF;
<form class="form-horizontal" method="post">
<legend>Add Manual User</legend>
<div class="control-group">
<label class="control-label" for="inputUsername">Username</label>
<div class="controls">
<input name="inputUsername" type="text" placeholder="Username">
</div>
</div>
<div class="control-group">
<label class="control-label" for="inputIP">IP Address</label>
<div class="controls">
<input name="inputIP" type="text" placeholder="IP Address">
</div>
</div>
<div class="control-group">
<label class="control-label" for="inputLimitTx">Download Limit</label>
<div class="controls">
<div class="input-append">
<input name="inputLimitTx" type="text" class="span5" id="appendedInput" placeholder="TX Limit">
<span class="add-on">Kbps<span>
</div>
</div>
</div>
<div class="control-group">
<label class="control-label" for="inputLimitRx">Upload Limit</label>
<div class="controls">
<div class="input-append">
<input name="inputLimitRx" type="text" class="span5" id="appendedInput" placeholder="RX Limit">
<span class="add-on">Kbps<span>
</div>
</div>
</div>
<div class="control-group">
<div class="controls">
<button type="submit" class="btn btn-primary">Add</button>
<button type="submit" class="btn">Cancel</button>
</div>
</div>
</form>
EOF
return (200,$content,$menu);
}
1;
opentrafficshaper/plugins/webserver/snapins/websockets/statistics/statistics.pm 0 → 100644
View file @ efc9ebe1
# OpenTrafficShaper webserver module: statistics websockets
# Copyright (C) 2007-2023, AllWorldIT
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
package opentrafficshaper::plugins::webserver::snapins::websockets::statistics;
use strict;
use warnings;
# Exporter stuff
require Exporter;
our (@ISA,@EXPORT,@EXPORT_OK);
@ISA = qw(Exporter);
@EXPORT = qw(
);
@EXPORT_OK = qw(
);
use DateTime;
use HTTP::Status qw( :constants );
use JSON;
use POE;
use URI;
use awitpt::util qw(
parseKeyPairString
);
use opentrafficshaper::logger;
use opentrafficshaper::plugins::configmanager qw(
getPoolByName
getInterfaceGroup
isTrafficClassIDValid
);
use constant {
VERSION => '1.0.0'
};
# Plugin info
our $pluginInfo = {
Name => "Webserver/WebSockets/Statistics",
Version => VERSION,
Requires => ["webserver","statistics"],
Init => \&plugin_init,
};
# Logger
my $logger;
# Stats subscriptsions
my $subscribers = {}; # Connections subscribed, indexed by client_session_id then ssid
my $subscriberMap = {}; # Index of connections by ssid
# Initialize plugin
sub plugin_init
{
my $system = shift;
# Setup our environment
$logger = $system->{'logger'};
$logger->log(LOG_NOTICE,"[WEBSERVER] OpenTrafficShaper Snapin [WebSockets/Statistics] Module v%s - Copyright (c) 2013-2014".
", AllWorldIT",
VERSION
);
# Protocol conversion
opentrafficshaper::plugins::webserver::snapin_register('HTTP=>WebSocket','statistics','graphdata', {
'requires' => [ 'statistics' ],
'on_request' => \&graphdata_http2websocket,
}
);
# Live graphdata feed
opentrafficshaper::plugins::webserver::snapin_register('WebSocket','statistics','graphdata', {
'requires' => [ 'statistics' ],
'on_request' => \&graphdata_websocket_onrequest,
'on_disconnect' => \&graphdata_websocket_disconnect
}
);
# This is our session handling sending data to connections
POE::Session->create(
inline_states => {
_start => \&_session_start,
_stop => \&_session_stop,
'websocket.send' => \&_session_websocket_send,
}
);
return 1;
}
# Session initialization
sub _session_start
{
my ($kernel,$heap) = @_[KERNEL,HEAP];
# Set our alias
$kernel->alias_set("plugin.webserver.websockets.statistics");
$logger->log(LOG_DEBUG,"[WEBSERVER] Snapin/WebSockets/Statistics - Initialized");
}
# Session stop
sub _session_stop
{
my ($kernel,$heap) = @_[KERNEL,HEAP];
# Remove our alias
$kernel->alias_remove("plugin.webserver.websockets.statistics");
$subscribers = {};
$subscriberMap = {};
$logger->log(LOG_DEBUG,"[WEBSERVER] Snapin/WebSockets/Statistics - Shutdown");
$logger = undef;
}
# Send data to client
sub _session_websocket_send
{
my ($kernel,$heap,$statsData) = @_[KERNEL, HEAP, ARG0, ARG1];
# Loop with stats data
foreach my $ssid (keys %{$statsData}) {
my $ssidStat = $statsData->{$ssid};
# Check if we know about this SSID
if (!defined($subscriberMap->{$ssid})) {
$logger->log(LOG_ERR,"[WEBSERVER] Snapin/WebSockets/Statistics - Subscription inconsidency with SSID '$ssid'");
next;
}
# First stage, pull in the data items we want
my $rawData;
# Loop with timestamps
foreach my $timestamp (sort keys %{$ssidStat}) {
# Grab the stat
my $tstat = $ssidStat->{$timestamp};
# Loop with its keys
foreach my $item (keys %{$tstat}) {
# Add the keys to the data to return
push(@{$rawData->{$item}->{'data'}},[
$timestamp,
$tstat->{$item}
]);
}
}
my $socket = $subscriberMap->{$ssid}->{'Socket'};
my $tag = $subscriberMap->{$ssid}->{'Tag'};
$socket->put(_json_data({ $tag => $rawData }));
}
}
# HTTP to WebSocket
sub graphdata_websocket_disconnect
{
my ($kernel,$globals,$client_session_id) = @_;
$logger->log(LOG_INFO,"[WEBSERVER] Snapin/WebSockets/Statistics - Client '$client_session_id' disconnected");
# Loop with our clients' subscriber ID's
foreach my $ssid (keys %{$subscribers->{$client_session_id}}) {
# And unsubscribe them
opentrafficshaper::plugins::statistics::unsubscribe($ssid);
# Remove the ssid map
delete($subscriberMap->{$ssid});
}
# Remove the client
delete($subscribers->{$client_session_id});
}
# HTTP to WebSocket
sub graphdata_http2websocket
{
my ($kernel,$globals,$client_session_id,$request,$socket) = @_;
# Grab the query string
# my %queryForm = $request->uri->query_form();
# Check we have a user ID
# if (!defined($queryForm{'uid'})) {
# return (HTTP_BAD_REQUEST,"Request not valid","Request does not contain a 'uid' parameter");
# }
# my $uid = $queryForm{'uid'};
$logger->log(LOG_INFO,"[WEBSERVER] Snapin/WebSockets/Statistics - Accepting upgrade of HTTP to WebSocket");
# Subscribe to the stats for this user
# if (!defined($uSubscriptions->{$uid}) || !(keys %{$uSubscriptions->{$uid}})) {
# $logger->log(LOG_INFO,"[WEBSERVER] Snapin/WebSockets/Statistics - Subscribing to '$uid'");
# $kernel->post('statistics' => 'subscribe' => 'plugin.webserver.websockets.statistics' => 'websocket.send' => $uid);
# }
# Setup tracking of our client & user subscriptions
# $cSubscriptions->{$client_session_id}->{$uid} = $socket;
# $uSubscriptions->{$uid}->{$client_session_id} = $socket;
# And return...
return;
}
# Websocket data handler
sub graphdata_websocket_onrequest
{
my ($kernel,$globals,$client_session_id,$request,$socket) = @_;
my $logger = $globals->{'logger'};
# Parse the command we got...
if ($request->{'function'} eq "subscribe") {
# Grab the first parameter as our tag
my $tag = shift(@{$request->{'args'}});
if (!defined($tag) || ref($tag) ne "") {
return (
opentrafficshaper::plugins::webserver::WS_ERROR,
"The first parameter of 'subscribe' must be a text based tag"
);
}
# Pull off our datasets
my $datasets = { };
foreach my $arg (@{$request->{'args'}}) {
my ($item,$params) = split(/=/,$arg);
push(@{$datasets->{$item}},$params);
}
# Parse dataset data
my @sidList;
if (defined($datasets->{'pool'})) {
# Loop with pool specifications
foreach my $poolSpec (@{$datasets->{'pool'}}) {
# Split interface group id and pool name
my ($rawInterfaceGroupID,$rawPoolName) = split(/:/,$poolSpec);
if (!defined($rawInterfaceGroupID)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource for pool has invalid format '$poolSpec'"
);
}
if (!defined($rawPoolName)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource for pool has invalid format '$poolSpec'"
);
}
# Check if we can grab the interface group
my $interfaceGroup = getInterfaceGroup($rawInterfaceGroupID);
if (!defined($interfaceGroup)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource has invalid interface group '$rawInterfaceGroupID'"
);
}
# Check if the pool name exists
my $pool = getPoolByName($rawInterfaceGroupID,$rawPoolName);
if (!defined($pool)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource has invalid pool '$rawPoolName'"
);
}
# Check if we have a stats ID
my $sid = opentrafficshaper::plugins::statistics::getSIDFromPID($pool->{'ID'});
if (!defined($sid)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource stats for pool not found '$rawPoolName'"
);
}
# Add SID to SID list that we need to subscribe to
push(@sidList,{'SID' => $sid});
}
}
if (defined($datasets->{'class'})) {
# Loop with class specifications
foreach my $classIDSpec (@{$datasets->{'class'}}) {
# Check we have a tag, interface group ID and class ID
my ($rawInterfaceGroupID,$rawClassID) = split(/:/,$classIDSpec);
if (!defined($rawInterfaceGroupID)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource for class has invalid format '$classIDSpec'"
);
}
if (!defined($rawClassID)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource for class has invalid format '$classIDSpec'"
);
}
# Get more sane values...
my $interfaceGroup = getInterfaceGroup($rawInterfaceGroupID);
if (!defined($interfaceGroup)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource has invalid interface group '$rawInterfaceGroupID'"
);
}
my $classID = isTrafficClassIDValid($rawClassID);
if (!defined($classID)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource has invalid class '$rawClassID'"
);
}
# Loop with both directions
foreach my $direction ('Tx','Rx') {
my $interfaceDevice = $interfaceGroup->{"${direction}Interface"};
# Grab stats ID
my $sid = opentrafficshaper::plugins::statistics::getSIDFromCID($interfaceDevice,$classID);
if (!defined($sid)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource stats for class '$classID' on interface '$interfaceDevice' not found"
);
}
# Add SID to SID list that we need to subscribe to
push(@sidList,{'SID' => $sid, 'Conversions' => { 'Direction' => lc($direction) }});
}
}
}
if (defined($datasets->{'interface-group'})) {
# Loop with interface-group specifications
foreach my $interfaceGroupSpec (@{$datasets->{'interface-group'}}) {
# Check we have a tag, interface group ID and class ID
my ($rawInterfaceGroupID) = split(/:/,$interfaceGroupSpec);
if (!defined($rawInterfaceGroupID)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource for interface group has invalid format '$interfaceGroupSpec'"
);
}
# Get more sane values...
my $interfaceGroup = getInterfaceGroup($rawInterfaceGroupID);
if (!defined($interfaceGroup)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource has invalid interface group '$rawInterfaceGroupID'"
);
}
# Loop with both directions
foreach my $direction ('Tx','Rx') {
my $interfaceDevice = $interfaceGroup->{"${direction}Interface"};
# Grab stats ID using a small direction hack
my $sid = opentrafficshaper::plugins::statistics::getSIDFromCID($interfaceDevice,0);
if (!defined($sid)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource stats for interface '$interfaceDevice' not found"
);
}
# Add SID to SID list that we need to subscribe to
push(@sidList,{'SID' => $sid, 'Conversions' => { 'Direction' => lc($direction) }});
}
}
}
if (defined($datasets->{'counter'})) {
# Loop with counter specifications
foreach my $counterSpec (@{$datasets->{'counter'}}) {
# Check we have a tag and counter
my ($rawCounter) = split(/:/,$counterSpec);
if (!defined($rawCounter)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource for counter has invalid format '$counterSpec'"
);
}
# Grab the SID
my $sid = opentrafficshaper::plugins::statistics::getSIDFromCounter($rawCounter);
if (!defined($sid)) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Datasource stats for counter not found '$rawCounter'"
);
}
# Add SID to SID list that we need to subscribe to
push(@sidList,{'SID' => $sid, 'Conversions' => { 'Name' => $rawCounter }});
}
}
# No datasources?
if (!@sidList) {
return (
opentrafficshaper::plugins::webserver::WS_FAIL,
"Failed to identify any subscription requests"
);
}
# Loop wiht subscription list
foreach my $item (@sidList) {
my $ssid = opentrafficshaper::plugins::statistics::subscribe(
$item->{'SID'},
$item->{'Conversions'},
'plugin.webserver.websockets.statistics',
'websocket.send'
);
# Save this client and the streaming id (ssid) we got back
$subscriberMap->{$ssid} = $subscribers->{$client_session_id}->{$ssid} = {
'Tag' => $tag,
'SID' => $item->{'SID'},
'Socket' => $socket
};
}
return (opentrafficshaper::plugins::webserver::WS_OK,"Subscribed");
# No command at all
} else {
return (opentrafficshaper::plugins::webserver::WS_ERROR,"Function '$request->{'function'}' does not exist");
}
return (opentrafficshaper::plugins::webserver::WS_OK,"Function not found");
}
#
# Internal functions
#
# Return a json dataset
sub _json_data
{
my $data = shift;
# Build the structure we're going to encode
my $res;
$res->{'status'} = "success";
$res->{'data'} = $data;
# Use ID of 0 to signify out of band data
$res->{'id'} = -1;
return encode_json($res);
}
1;
# vim: ts=4
opentrafficshaper/plugins/webserver/webserver.pm
View file @ efc9ebe1
# OpenTrafficShaper webserver module
# Copyright (C) 2007-2013, AllWorldIT
#
# Copyright (C) 2007-2023, AllWorldIT
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
......@@ -21,18 +21,25 @@ package opentrafficshaper::plugins::webserver;
use strict;
use warnings;
use bytes;
use HTML::Entities;
use HTTP::Response;
use HTTP::Status qw(:constants :is status_message);
use POE qw(Component::Server::TCP Filter::HTTPD);
use HTTP::Status qw( :constants :is );
use JSON;
use POE qw( Component::Server::TCP );
use URI;
use opentrafficshaper::logger;
use opentrafficshaper::plugins;
use opentrafficshaper::POE::Filter::HybridHTTP;
# Pages (this is used a little below)
use opentrafficshaper::plugins::webserver::pages::static;
use opentrafficshaper::plugins::webserver::pages::index;
use opentrafficshaper::plugins::webserver::pages::users;
use opentrafficshaper::plugins::webserver::pages::limits;
use opentrafficshaper::plugins::webserver::pages::configmanager;
# Exporter stuff
......@@ -42,10 +49,16 @@ our (@ISA,@EXPORT,@EXPORT_OK);
@EXPORT = qw(
);
@EXPORT_OK = qw(
snapin_register
);
use constant {
VERSION => '0.0.1'
VERSION => '1.0.0',
# WebSocket return status
WS_OK => 0,
WS_ERROR => -1,
WS_FAIL => -2
};
......@@ -53,126 +66,253 @@ use constant {
our $pluginInfo = {
Name => "Webserver",
Version => VERSION,
Init => \&init,
Init => \&plugin_init,
Start => \&plugin_start,
};
# Copy of system globals
# Our globals
my $globals;
# Copy of system logger
my $logger;
# This is the mapping of our pages
my $pages = {
'index' => {
'_catchall' => \&opentrafficshaper::plugins::webserver::pages::index::_catchall,
},
'static' => {
'_catchall' => \&opentrafficshaper::plugins::webserver::pages::static::_catchall,
},
'users' => {
'default' => \&opentrafficshaper::plugins::webserver::pages::users::default,
'add' => \&opentrafficshaper::plugins::webserver::pages::users::add,
# Client connections open
#
# $globals->{'Connections'}
# Web resources
my $resources = {
# HTTP
'HTTP' => {
'index' => {
'_catchall' => \&opentrafficshaper::plugins::webserver::pages::index::_catchall,
},
'static' => {
'_catchall' => \&opentrafficshaper::plugins::webserver::pages::static::_catchall,
},
'limits' => {
'default' => \&opentrafficshaper::plugins::webserver::pages::limits::pool_list,
'pool-list' => \&opentrafficshaper::plugins::webserver::pages::limits::pool_list,
'pool-override-add' => \&opentrafficshaper::plugins::webserver::pages::limits::pool_override_addedit,
'pool-override-list' => \&opentrafficshaper::plugins::webserver::pages::limits::pool_override_list,
'pool-override-remove' => \&opentrafficshaper::plugins::webserver::pages::limits::pool_override_remove,
'pool-override-edit' => \&opentrafficshaper::plugins::webserver::pages::limits::pool_override_addedit,
'pool-add' => \&opentrafficshaper::plugins::webserver::pages::limits::pool_addedit,
'pool-list' => \&opentrafficshaper::plugins::webserver::pages::limits::pool_list,
'pool-remove' => \&opentrafficshaper::plugins::webserver::pages::limits::pool_remove,
'pool-edit' => \&opentrafficshaper::plugins::webserver::pages::limits::pool_addedit,
'poolmember-add' => \&opentrafficshaper::plugins::webserver::pages::limits::poolmember_addedit,
'poolmember-list' => \&opentrafficshaper::plugins::webserver::pages::limits::poolmember_list,
'poolmember-remove' => \&opentrafficshaper::plugins::webserver::pages::limits::poolmember_remove,
'poolmember-edit' => \&opentrafficshaper::plugins::webserver::pages::limits::poolmember_addedit,
'limit-add' => \&opentrafficshaper::plugins::webserver::pages::limits::limit_add
},
'configmanager' => {
'default' => \&opentrafficshaper::plugins::webserver::pages::configmanager::default,
'admin-config' => \&opentrafficshaper::plugins::webserver::pages::configmanager::admin_config,
},
},
};
# Add webserver snapin
sub snapin_register
{
my ($protocol,$module,$action,$data) = @_;
$logger->log(LOG_INFO,"[WEBSERVER] Registered snapin: protocol = %s, module = %s, action = %s",$protocol,$module,$action);
# Load resource
$resources->{$protocol}->{$module}->{$action} = $data;
}
# Initialize plugin
sub init
sub plugin_init
{
$globals = shift;
my $system = shift;
# Setup our environment
$logger = $globals->{'logger'};
$logger = $system->{'logger'};
$logger->log(LOG_NOTICE,"[WEBSERVER] OpenTrafficShaper Webserver Module v%s - Copyright (c) 2007-2023, AllWorldIT",VERSION);
# Initialize
$globals->{'Connections'} = { };
# Spawn a web server on port 8088 of all interfaces.
POE::Component::Server::TCP->new(
Alias => "plugin.webserver",
Port => 8088,
ClientFilter => 'POE::Filter::HTTPD',
Port => 8080,
# Handle session connections & disconnections
ClientConnected => \&server_client_connected,
ClientDisconnected => \&server_client_disconnected,
# Filter to handle HTTP
ClientFilter => 'opentrafficshaper::POE::Filter::HybridHTTP',
# Function to handle HTTP requests (as we passing through a filter)
ClientInput => \&handle_request
ClientInput => \&server_request,
# Setup the sever
Started => \&server_session_start,
Stopped => \&server_session_stop,
);
$logger->log(LOG_NOTICE,"[WEBSERVER] OpenTrafficShaper Webserver Module v".VERSION." - Copyright (c) 2013, AllWorldIT")
# Load statistics pages if the statistics module is enabled
if (isPluginLoaded('statistics')) {
# Check if we can actually load the pages
eval("use opentrafficshaper::plugins::webserver::pages::statistics");
if ($@) {
$logger->log(LOG_INFO,"[WEBSERVER] Failed to load statistics pages: %s",$@);
exit;
} else {
# Load resources
$resources->{'HTTP'}->{'statistics'} = {
'by-pool' => \&opentrafficshaper::plugins::webserver::pages::statistics::byPool,
'by-class' => \&opentrafficshaper::plugins::webserver::pages::statistics::byClass,
'jsondata' => \&opentrafficshaper::plugins::webserver::pages::statistics::jsondata,
'dashboard' => \&opentrafficshaper::plugins::webserver::pages::statistics::dashboard,
'igdashboard' => \&opentrafficshaper::plugins::webserver::pages::statistics::igdashboard
};
$logger->log(LOG_INFO,"[WEBSERVER] Loaded statistics pages as statistics module is loaded");
}
}
return 1;
}
sub handle_request
# Start the plugin
sub plugin_start
{
my ($kernel, $heap, $request) = @_[KERNEL, HEAP, ARG0];
$logger->log(LOG_INFO,"[WEBSERVER] Started");
}
# We going to init these as system so we know whats a parsing issue
my $module = "system";
my $action = "parse";
# This is our response
my $response;
# We may have a response from the filter indicating an error
if ($request->isa("HTTP::Response")) {
$heap->{client}->put($request);
goto END;
}
# Server session started
sub server_session_start
{
my $kernel = $_[KERNEL];
# We need to parse the URI nicely
my $requestURI = URI->new($request->uri);
$logger->log(LOG_DEBUG,"[WEBSERVER] Initialized");
}
# Split off the URL into a module and action
my (undef,$dmodule,$daction,@dparams) = split(/\//,$requestURI->path);
# If any is blank, set it to the default
$dmodule = "index" if (!defined($dmodule));
$daction = "default" if (!defined($daction));
# Sanitize
($module = $dmodule) =~ s/[^A-Za-z0-9]//g;
($action = $daction) =~ s/[^A-Za-z0-9]//g;
# If module name is sneaky? then just block it
if ($module ne $dmodule) {
$response = httpDisplayFault(HTTP_FORBIDDEN,"Method Not Allowed","The requested resource '".encode_entities($module)."' is not allowed.");
goto END;
# Server session stopped
sub server_session_stop
{
my $kernel = $_[KERNEL];
# Tear down data
$globals = undef;
$logger->log(LOG_DEBUG,"[WEBSERVER] Shutdown");
}
# Signal that the client has connected
sub server_client_connected
{
my ($kernel,$heap,$session,$request) = @_[KERNEL, HEAP, SESSION, ARG0];
my $client_session_id = $session->ID;
# Save our socket on the client
$globals->{'Connections'}->{$client_session_id}->{'Socket'} = $heap->{'client'};
$globals->{'Connections'}->{$client_session_id}->{'Protocol'} = 'HTTP';
}
# Signal that the client has disconnected
sub server_client_disconnected
{
my ($kernel,$heap,$session,$request) = @_[KERNEL, HEAP, SESSION, ARG0];
my $client_session_id = $session->ID;
my $client = $globals->{'Connections'}->{$client_session_id};
# Check if we have a disconnection function to call
if (
defined($client->{'Resource'}) &&
defined($client->{'Resource'}->{'Handler'}) &&
ref($client->{'Resource'}->{'Handler'}) eq 'HASH' &&
defined($client->{'Resource'}->{'Handler'}->{'on_disconnect'})
) {
# Call disconnection function
$client->{'Resource'}->{'Handler'}->{'on_disconnect'}
->($kernel,$globals,$client_session_id);
}
# This is the function we going to call
# If we have a function name, try use it
if (defined($pages->{$module})) {
# If there is no specific action for this use the catchall
if (!defined($pages->{$module}->{$action}) && defined($pages->{$module}->{'_catchall'})) {
$action = "_catchall";
# Remove client session
delete($globals->{'Connections'}->{$client_session_id});
}
# Handle the HTTP request
sub server_request
{
my ($kernel,$heap,$session,$request) = @_[KERNEL, HEAP, SESSION, ARG0];
my $client_session_id = $session->ID;
my $client = $globals->{'Connections'}->{$client_session_id};
# Our response back if one, and if we should just close the connection or not
my $response;
my $closeWhenDone = 0;
# Its HTTP
if ($client->{'Protocol'} eq "HTTP") {
# Check the protocol we're currently handling
# We may have a response from the filter indicating an error
if (ref($request) eq "HTTP::Response") {
$response = $request;
# Its a normal HTTP request
} elsif (ref($request) eq "HTTP::Request") {
$response = _server_request_http($kernel,$client_session_id,$request);
}
# Check if it exists first
if (defined($pages->{$module}->{$action})) {
my ($res,$content,$extra) = $pages->{$module}->{$action}->($globals,$module,$daction,$request);
# Module return undef if they don't want to handle the request
if (!defined($res)) {
$response = httpDisplayFault(HTTP_NOT_FOUND,"Resource Not found","The requested resource '".encode_entities($daction)."' cannot be found");
} elsif (ref($res) eq "HTTP::Response") {
$response = $res;
# TODO: This is a bit dirty
# Extra in this case is the sidebar menu items
} elsif ($res == HTTP_OK) {
$response = httpCreateResponse($module,$daction,$content,$extra);
# TODO - redirect?
# Extra in this case is the error description
} else {
httpDisplayFault($res,$content,$extra);
}
} else {
$response = httpDisplayFault(HTTP_NOT_FOUND,"Method Not found","The requested method '".encode_entities($action)."' cannot be found in '".encode_entities($module)."'");
# Support for HTTP/1.1 "Connection: close" header...
my $connection = $request->header('Connection');
if (defined($connection) && $connection eq "close") {
$closeWhenDone = 1;
}
}
if (!defined($response)) {
$response = httpDisplayFault(HTTP_NOT_FOUND,"Resource Not found","The requested resource '".encode_entities($module)."' cannot be found");
# Its a websocket
} elsif ($client->{'Protocol'} eq "WebSocket") {
$response = _server_request_websocket($kernel,$client_session_id,$request);
}
# If there is a response send it
if (defined($response)) {
$client->{'Socket'}->put($response);
}
END:
$logger->log(LOG_INFO,"[WEBSERVER] Access: ".$response->code." [$module/$action] - ".$request->method." ".$request->uri." ".$request->protocol);
$heap->{client}->put($response);
$kernel->yield("shutdown");
# Check if connection must be closed
if ($closeWhenDone) {
$kernel->yield("shutdown");
}
}
......@@ -180,30 +320,40 @@ END:
# Display fault
sub httpDisplayFault
{
my ($code,$msg,$description) = @_;
my ($code,$message,$description) = @_;
# Throw out message to client to authenticate first
my $headers = HTTP::Headers->new;
$headers->content_type("text/html");
my $resp = HTTP::Response->new(
$code,$msg,
my $response = HTTP::Response->new(
$code,$message,
$headers,
<<EOF);
<!DOCTYPE html>
<html>
<head>
<title>$code $msg</title>
<title>$code $message</title>
</head>
<body>
<h1>$msg</h1>
<h1>$message</h1>
<p>$description</p>
</body>
</html>
EOF
return $resp;
return $response;
}
# Do a redirect
sub httpRedirect
{
my $url = shift;
return HTTP::Response->new(HTTP_FOUND, 'Redirect', [Location => $url]);
}
......@@ -211,130 +361,532 @@ EOF
# Create a response object
sub httpCreateResponse
{
my ($module,$daction,$content,$menu) = @_;
my ($module,$content,$options) = @_;
# Throw out message to client to authenticate first
my $headers = HTTP::Headers->new;
$headers->content_type("text/html");
my $payload = "";
# Check if we have a specific return type, if not set default
if (!defined($options->{'type'})) {
$options->{'type'} = 'webpage';
}
# Check if we have a menu structure, if we do, display the sidebar
my $menuStr = "";
if (defined($menu)) {
$menuStr =<<EOF;
<div class="span1">
<div class="well sidebar-nav">
<ul class="nav nav-list">
# If we returning a webpage, handle it that way
if ($options->{'type'} eq 'webpage') {
# Set header
$headers->content_type("text/html");
# Bootstrap stuff
my $mainCols = 12;
# Check if we have a menu structure, if we do, display the sidebar
my $menuStr = "";
my $stylesheetsStr = "";
my $stylesheetStr = "";
my $javascriptStr = "";
my $versionStr = VERSION;
if (defined($options)) {
# Check if menu exists
if (my $menu = $options->{'menu'}) {
$menuStr =<<EOF;
<div class="col-md-2">
<ul class="nav nav-pills nav-stacked">
EOF
# Loop with sub menu sections
my @menuItems = ();
foreach my $section (@{$menu}) {
my $menuItem = "";
my $sectionName = encode_entities($section->{'name'});
$menuItem .=<<EOF;
<li class="active text-center"><a href="#">$sectionName</a></li>
EOF
# Loop with sub menu sections
foreach my $section (keys %{$menu}) {
# <li class="nav-header">Sidebar</li>
# <li class="active"><a href="#">Link</a></li>
# <li><a href="#">Link</a></li>
# <li class="nav-header">Sidebar</li>
# <li><a href="#">Link</a></li>
# Loop with menu items
foreach my $item (keys %{$menu->{$section}}) {
my $link = "/" . $module . "/" . $menu->{$section}->{$item};
# Sanitize slightly
$link =~ s,/+$,,;
# Build sections
# Loop with menu items
foreach my $item (@{$section->{'items'}}) {
my $itemName = encode_entities($item->{'name'});
# Sanitize link
my $itemLink = "/" . $module . "/" . $item->{'link'};
$itemLink =~ s,/+$,,;
# Build sections
$menuItem .=<<EOF;
<li class="text-center"><a href="$itemLink">$itemName</a></li>
EOF
}
# Add menu item
push(@menuItems,$menuItem);
}
# Join menu items
$menuStr .= join(<<EOF,@menuItems);
<hr />
EOF
$menuStr .=<<EOF;
<li class="nav-header">$section</li>
<li><a href="$link">$item</a></li>
</ul>
</div>
EOF
# Reduce number of main cols to make way for menu
$mainCols = 10;
}
}
$menuStr .=<<EOF;
</ul>
</div><!--/.well -->
</div><!--/span-->
EOF
}
# Check if we have a list of style assets
if (defined(my $stylesheets = $options->{'stylesheets'})) {
foreach my $script (@{$stylesheets}) {
$stylesheetsStr .=<<EOF;
<link href="$script" rel="stylesheet"></script>
EOF
}
}
# Check if stylesheet snippet exists
if (defined(my $stylesheet = $options->{'stylesheet'})) {
$stylesheetStr .=<<EOF;
$stylesheet
EOF
}
# Check if we have a list of javascript assets
if (defined(my $javascripts = $options->{'javascripts'})) {
foreach my $script (@{$javascripts}) {
$javascriptStr .=<<EOF;
<script type="text/javascript" src="$script"></script>
EOF
}
}
# Check if javascript snippet exists
if (defined(my $javascript = $options->{'javascript'})) {
$javascriptStr .=<<EOF;
<script type="text/javascript">
$javascript
</script>
EOF
}
}
# Build action response
my $resp = HTTP::Response->new(
HTTP_OK,"Ok",
$headers,
<<EOF);
# Create the payload we returning
$payload = <<EOF;
<!DOCTYPE html>
<html>
<head>
<title>OpenTrafficShaper - Enterprise Traffic Shaper</title>
<!-- Meta -->
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<!-- Assets -->
<link href="/static/jquery-ui/css/ui-lightness/jquery-ui.min.css" rel="stylesheet" media="screen">
<link href="/static/bootstrap/css/bootstrap.min.css" rel="stylesheet" media="screen">
<link href="/static/favicon.ico" rel="icon" />
<link href="/static/jquery-ui/css/ui-lightness/jquery-ui.min.css" rel="stylesheet" />
<link href="/static/bootstrap/css/bootstrap.min.css" rel="stylesheet" />
$stylesheetsStr
<style type="text/css">
body {
padding-top: 60px;
padding-bottom: 40px;
}
.sidebar-nav {
padding: 9px 0;
}
\@media (max-width: 980px) {
/* Enable use of floated navbar text */
.navbar-text.pull-right {
float: none;
padding-left: 5px;
padding-right: 5px;
}
padding-top: 50px;
}
$stylesheetStr
</style>
<!-- End Assets -->
<link href="/static/bootstrap/css/bootstrap-responsive.min.css" rel="stylesheet" media="screen">
</head>
<body>
<body>
<div class="navbar navbar-inverse navbar-fixed-top">
<div class="navbar-inner">
<div class="container-fluid">
<button type="button" class="btn btn-navbar" data-toggle="collapse" data-target=".nav-collapse">
<a class="navbar-brand" href="/">
<img src="/static/logo-inverted-short.png" alt="Open Traffic Shaper" width="100%" height="auto" />
</a>
<div class="container">
<div class="navbar-header">
<button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
<span class="icon-bar"></span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
</button>
<a class="brand" href="/">OpenTrafficShaper</a>
<div class="nav-collapse collapse">
<p class="navbar-text pull-right">Logged in as <a href="#" class="navbar-link">Username</a> </p>
<ul class="nav">
<li class="active"><a href="#">Home</a></li>
<li><a href="/users">Users</a></li>
</ul>
</div><!--/.nav-collapse -->
</div>
<div class="collapse navbar-collapse">
<ul class="nav navbar-nav">
<li class="active"><a href="/">Home</a></li>
<li><a href="/limits">Limits</a></li>
<li><a href="/configmanager">ConfigManager</a></li>
</ul>
</div>
</div>
</div>
<div class="container-fluid">
<div class="row-fluid">
$menuStr
<div class="span10">
$content
</div><!--/span-->
</div><!--/row-->
<hr>
<div style="padding: 15px 15px">
<div class="row">
$menuStr
<div class="col-md-$mainCols">
$content
</div>
</div>
</div>
<div style="padding: 0 15px">
<hr />
<footer>
<p class="muted">v$globals->{'version'} - Copyright &copy; 2013, <a href="http://www.allworldit.com">AllWorldIT</a></p>
<p class="muted">
v$versionStr - Copyright &copy; 2007-2023, <a href="http://www.allworldit.com">AllWorldIT</a>
</p>
</footer>
</div><!--/.fluid-container-->
</div>
</body>
<script type="text/javascript" src="/static/jquery/js/jquery.min.js"></script>
<script type="text/javascript" src="/static/jquery-ui/js/jquery-ui.min.js"></script>
<script type="text/javascript" src="/static/bootstrap/js/bootstrap.min.js"></script>
$javascriptStr
<!-- Javascript -->
<script src="/static/jquery/js/jquery.min.js"></script>
<script src="/static/jquery-ui/js/jquery-ui.min.js"></script>
<script src="/static/bootstrap/js/bootstrap.min.js"></script>
</body>
</html>
EOF
# Maybe we're json?
} elsif ($options->{'type'} eq 'json') {
# Set header
$headers->content_type("application/json");
$payload = encode_json($content);
}
# Build action response
my $resp = HTTP::Response->new(
HTTP_OK,"Ok",
$headers,
$payload
);
return $resp;
}
#
# Internals
#
# Handle the normal HTTP protocol
sub _server_request_http
{
my ($kernel,$client_session_id,$request) = @_;
my $conn = $globals->{'Connections'}->{$client_session_id};
my $protocol = "HTTP"; # By default we're HTTP
# Pull off connection attributes
my $header_connection;
if (my $h_connection = $request->header('Connection')) {
foreach my $param (split(/[ ,]+/,$h_connection)) {
$header_connection->{lc($param)} = 1;
}
# Identify and split off upgrades
if (defined($header_connection->{'upgrade'}) && (my $h_upgrade = $request->header('upgrade'))) {
$h_upgrade = lc($h_upgrade);
if ($h_upgrade eq "websocket") {
$protocol = "HTTP=>WebSocket";
}
}
}
# XXX: Check method & encoding, in all protocols??
if ($request->method eq "POST") {
# We currently only accept form data
if ($request->content_type ne "application/x-www-form-urlencoded") {
return httpDisplayFault(HTTP_FORBIDDEN,"Method Not Allowed","The requested method and content type is not allowed.");
}
}
# This is going to be our response back
my $response;
# Parse our protocol into a module & action
my ($handler,$module,$action) = _parse_http_resource($request,$protocol);
# Short circuit if we had an error
if (ref($handler) eq "HTTP::Response") {
# There is no module or action
$module = ""; $action = "";
# Set our response
$response = $handler;
goto END;
}
# Function we need to call
my $function = $handler;
# Check if we're a hash... override if we are
if (ref($handler) eq "HASH") {
$function = $handler->{'on_request'};
}
# If its something else, blow up
if (ref($function) ne "CODE") {
return httpDisplayFault(HTTP_INTERNAL_SERVER_ERROR,"Internal server error","Server configuration error");
}
$logger->log(LOG_DEBUG,"[WEBSERVER] Parsed HTTP request into: module='%s', action='%s'",$module,$action);
# Save what resource we just accessed
$globals->{'Connections'}->{$client_session_id}->{'Resource'} = {
'Module' => $module,
'Action' => $action,
'Handler' => $handler,
};
my $system = {
'logger' => $logger
};
# This is normal HTTP request
if ($protocol eq "HTTP") {
# Do the function call now
my ($res,$content,$extra) = $function->($kernel,$system,$client_session_id,$request);
# Module return undef if they don't want to handle the request
if (!defined($res)) {
$response = httpDisplayFault(HTTP_NOT_FOUND,"Resource Not found","The requested resource '$action' cannot be found");
} elsif (ref($res) eq "HTTP::Response") {
$response = $res;
# TODO: This is a bit dirty
# Extra in this case is the sidebar menu items
} elsif ($res == HTTP_OK) {
$response = httpCreateResponse($module,$content,$extra);
# The content in a redirect is the URL
} elsif ($res == HTTP_TEMPORARY_REDIRECT) {
$response = httpRedirect("//".$request->header('host')."/" . $content);
# Extra in this case is the error description
} else {
$response = httpDisplayFault($res,$content,$extra);
}
# Its a websocket upgrade request
} elsif ($protocol eq "HTTP=>WebSocket") {
# Make sure we have an upgrade path to WebSocket
my ($newHandler) = _parse_http_resource($request,"WebSocket");
if (!defined($newHandler)) {
return httpDisplayFault(HTTP_INTERNAL_SERVER_ERROR,"Internal server error","Cannot upgrade to websocket");
}
# Do the function call now
my ($res,$ret1,$ret2) = $function->($kernel,$globals,$client_session_id,$request,$conn->{'Socket'});
# If we have a response defined, we rejected the upgrade
if (defined($res)) {
$response = httpDisplayFault($res,$ret1,$ret2);
} else {
# Return our upgrade response
$response = _server_request_http_wsupgrade($request,$module,$action);
# Upgrade the protocol & handler
$globals->{'Connections'}->{$client_session_id}->{'Protocol'} = 'WebSocket';
$globals->{'Connections'}->{$client_session_id}->{'Resource'}->{'Handler'} = $newHandler;
}
}
END:
$logger->log(LOG_INFO,"[WEBSERVER] %s Request: %s [%s/%s] - %s %s %s",
$protocol,
$response->code,
$module,
$action,
encode_entities($request->method),
encode_entities($request->uri),
encode_entities($request->protocol)
);
return $response;
}
# Handle the websocket request
sub _server_request_websocket
{
my ($kernel,$client_session_id,$rawRequest) = @_;
my $conn = $globals->{'Connections'}->{$client_session_id};
my $handler = $conn->{'Resource'}->{'Handler'};
# Function we need to call
my $function = $handler;
# Check if we're a hash... override if we are
if (ref($handler) eq "HASH") {
$function = $handler->{'on_request'};
}
# If its something else, blow up
if (ref($function) ne "CODE") {
$logger->log(LOG_ERR,"[WEBSERVER] No 'on_request' handler for websocket");
return encode_json({'status' => "error", 'message' => "Internal server error"});
}
# Safely decode JSON
my $request;
eval { $request = decode_json($rawRequest); };
if ($@) {
# FIXME: NOTICE: Failed to decode JSON request '&#3;&#xFFFD; , may be disconnect from websocket?
$logger->log(LOG_NOTICE,"[WEBSERVER] Failed to decode JSON request '%s'",encode_entities($rawRequest));
return encode_json({'status' => "error", 'message' => "Failed to decode JSON"});
}
# Save the command id
my $rCode = $request->{'id'};
# Check the function and args are present
if (!defined($request->{'function'}) || !defined($request->{'args'})) {
return encode_json({
'status' => "error",
'message' => "Invalid format for JSON request, must have 'function' and 'args' properties"
});
}
# Check function is a string
if (!(ref($request->{'function'}) eq "" && length($request->{'function'}) > 0)) {
return encode_json({
'status' => "error",
'message' => "The 'function' property must contain a function name"
});
}
# And the args is an array ref
if (!ref($request->{'args'}) eq "ARRAY") {
return encode_json({
'status' => "error",
'message' => "The 'args' property must contain an array of arguments"
});
}
# Do the function call now
my ($res,$content,$extra) = $function->($kernel,$globals,$client_session_id,$request,$conn->{'Socket'});
$logger->log(LOG_INFO,"[WEBSERVER] %s Request [%s/%s]",
$conn->{'Protocol'},
$conn->{'Resource'}->{'Module'},
$conn->{'Resource'}->{'Action'},
);
# Check if its a success or failure
my $ret;
if ($res == WS_OK) {
$ret->{'status'} = "success";
$ret->{'data'} = $content;
} elsif ($res == WS_ERROR) {
$ret->{'status'} = "error";
$ret->{'message'} = $content;
} elsif ($res == WS_FAIL) {
$ret->{'status'} = "fail";
$ret->{'message'} = $content;
} else {
$ret->{'status'} = "error";
$ret->{'message'} = "Internal server error";
}
# Add ID if we have one
if (defined($request->{'id'})) {
$ret->{'id'} = $request->{'id'};
}
return encode_json($ret);
}
# Function to parse a HTTP resource
sub _parse_http_resource
{
my ($request,$protocol) = @_;
my $resource = $resources->{$protocol};
# No resource defined
if (!defined($resource)) {
return httpDisplayFault(HTTP_FORBIDDEN,"Protocol Not Available","The requested protocol is not available.");
}
# Split off the URL into a module and action
my (undef,$dmodule,$daction) = $request->uri->path_segments();
# If any is blank, set it to the default
$dmodule = "index" if (!defined($dmodule) || $dmodule eq "");
$daction = "default" if (!defined($daction) || $daction eq "");
# Sanitize
(my $module = $dmodule) =~ s/[^A-Za-z0-9]//g;
(my $action = $daction) =~ s/[^A-Za-z0-9\-]//g;
# If module name is sneaky? then just block it
if ($module ne $dmodule) {
return httpDisplayFault(HTTP_FORBIDDEN,"Method Not Allowed","The requested resource '$module' is not allowed.");
}
# If there is no resource to handle this return
if (!defined($resource->{$module})) {
return httpDisplayFault(HTTP_NOT_FOUND,"Resource Not found","The requested resource '$module' cannot be found");
}
# If there is no specific action for this use the catchall
if (!defined($resource->{$module}->{$action}) && defined($resource->{$module}->{'_catchall'})) {
$action = "_catchall";
}
# Check if it exists first
if (!defined($resource->{$module}->{$action})) {
return httpDisplayFault(HTTP_NOT_FOUND,"Method Not found","The requested method '$action' cannot be found in '$module'");
}
# This is the handler data, either a CODE ref or a HASH
my $handler = $resource->{$module}->{$action};
# Check if the destination is a hash containing stuff we can treat specially
if (ref($handler) eq "HASH") {
# If we have a list of requires, check them
if (defined($handler->{'requires'})) {
foreach my $require (@{$handler->{'requires'}}) {
if (!isPluginLoaded($require)) {
return httpDisplayFault(HTTP_NOT_IMPLEMENTED,"Method Not Available","The requested method '$action' in ".
"'$module' is not currently available");
}
}
}
}
return ($handler,$module,$action);
}
# Handle Websocket
sub _server_request_http_wsupgrade
{
my ($request,$module,$action) = @_;
my $response;
# Build handshake reply
my $headers = HTTP::Headers->new(
'Upgrade' => "websocket",
'Connection' => "upgrade",
);
# Build response switching protocols
$response = HTTP::Response->new(
HTTP_SWITCHING_PROTOCOLS,"Switching Protocols",
$headers
);
$logger->log(LOG_INFO,"[WEBSERVER] WebSocket Upgrade: %s [%s/%s] - %s %s %s",
$response->code,
$module,
$action,
encode_entities($request->method),
encode_entities($request->uri),
encode_entities($request->protocol)
);
return $response;
}
1;
# vim: ts=4
opentrafficshaper/utils.pm → opentrafficshaper/util.pm
View file @ efc9ebe1
# Utility functions
# Copyright (C) 2013, AllWorldIT
#
# OpenTrafficShaper utility functions
# Copyright (C) 2007-2023, AllWorldIT
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
......@@ -15,7 +15,7 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>.
package opentrafficshaper::utils;
package opentrafficshaper::util;
use strict;
use warnings;
......@@ -26,30 +26,56 @@ require Exporter;
our (@ISA,@EXPORT,@EXPORT_OK);
@ISA = qw(Exporter);
@EXPORT = qw(
prettyUndef
toHex
isIPv46
isIPv46CIDR
);
@EXPORT_OK = qw(
);
# Print a undef in a pretty fashion
sub prettyUndef
# Check if this is a valid IPv4 or IPv6 address
sub isIPv46
{
my $var = shift;
if (!defined($var)) {
return "-undef-";
} else {
return $var;
my ($rawIP) = @_;
my $ip = NetAddr::IP->new($rawIP);
if (!defined($ip)) {
return;
}
if ($ip->version == 4) {
if ($ip->masklen != 32) {
return;
}
return $ip->addr;
} elsif ($ip->version == 6) {
if ($ip->masklen != 128) {
return;
}
return $ip->short;
}
return;
}
# Return hex representation of a decimal
sub toHex
# Check if this is a valid IPv4 or IPv6 CIDR
sub isIPv46CIDR
{
my $decimal = shift;
return sprintf('%x',$decimal);
my ($rawIP) = @_;
my $ip = NetAddr::IP->new($rawIP);
if (!defined($ip)) {
return;
}
if ($ip->version() == 4) {
return $ip->network()->addr() . "/" . $ip->masklen();
} elsif ($ip->version == 6) {
return $ip->network()->short() . "/" . $ip->masklen();
}
return;
}
1;
# vim: ts=4
1;
\ No newline at end of file
opentrafficshaper/version.pm
View file @ efc9ebe1
# OpenTrafficShaper version package
# Copyright (C) 2007-2013, AllWorldIT
#
# Copyright (C) 2007-2023, AllWorldIT
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
......@@ -30,7 +30,7 @@ our (@ISA,@EXPORT,@EXPORT_OK);
use constant {
VERSION => "1.0.0",
VERSION => "2.0.4",
};
......
opentrafficshaperd
View file @ efc9ebe1
#!/usr/bin/perl
# Main OpenTrafficShaper program
# Copyright (C) 2007-2013, AllWorldIT
#
# Copyright (C) 2007-2023, AllWorldIT
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
......@@ -18,10 +18,16 @@
use strict;
use warnings;
use File::Basename qw(dirname);
# Set the dirs we look for library files in
use lib('/usr/local/lib/opentrafficshaper-1.0','/usr/lib/opentrafficshaper-1.0',
'/usr/lib64/opentrafficshaper-1.0','opentrafficshaper','awitpt');
use lib(dirname(__FILE__),dirname(__FILE__)."/awitpt/lib");
# Enable assertions
BEGIN {
package POE::Kernel;
use constant ASSERT_DEFAULT => 1;
}
# System stuff we need
use Config::IniFiles;
......@@ -33,6 +39,7 @@ use Time::HiRes qw(time);
# Our own stuff
use opentrafficshaper::version;
use opentrafficshaper::logger;
use opentrafficshaper::plugins qw( plugin_register );
# Main config
......@@ -44,17 +51,34 @@ my $logger = new opentrafficshaper::logger;
#
# MAIN
#
$logger->log(LOG_NOTICE,"[MAIN] OpenTrafficShaper v".VERSION." - Copyright (c) 2007-2013, AllWorldIT");
parseCfgCmdLine();
init();
$logger->log(LOG_NOTICE,"[MAIN] Starting...");
# Check if we must use a log file instead
if (defined($globals->{'config'}->{'log_file'})) {
$logger->open($globals->{'config'}->{'log_file'});
}
$logger->setLevel($globals->{'config'}->{'log_level'});
# Check if we need to go background
if (defined($globals->{'config'}->{'background'})) {
daemonize();
}
displayBanner();
init();
start();
$logger->log(LOG_NOTICE,"[MAIN] Entering RUNNING state");
POE::Kernel->run();
exit;
# Function to display banner
sub displayBanner
{
$logger->log(LOG_NOTICE,"[MAIN] OpenTrafficShaper v%s - Copyright (c) 2007-2023, AllWorldIT",VERSION);
}
# Function to parse our config and commandline
sub parseCfgCmdLine
......@@ -64,11 +88,10 @@ sub parseCfgCmdLine
my $cfg;
$cfg->{'config_file'} = "/etc/opentrafficshaper.conf";
# $cfg->{'timeout'} = 120;
# $cfg->{'background'} = "yes";
# $cfg->{'pid_file'} = "/var/run/opentrafficshaper/opentrafficshaperd.pid";
# $cfg->{'log_level'} = 2;
# $cfg->{'log_file'} = "/var/log/opentrafficshaper/opentrafficshaperd.log";
$cfg->{'background'} = "yes";
$cfg->{'pid_file'} = "/run/opentrafficshaper/opentrafficshaperd.pid";
$cfg->{'log_level'} = 2;
$cfg->{'log_file'} = "/var/log/opentrafficshaper/opentrafficshaperd.log";
# Parse command line params
my $cmdline;
......@@ -92,7 +115,7 @@ sub parseCfgCmdLine
# Check config file exists
if (! -f $cfg->{'config_file'}) {
die("No configuration file '".$cfg->{'config_file'}."' found!\n");
die("No configuration file '".$cfg->{'config_file'}."' found!");
}
# Use config file, ignore case
......@@ -100,20 +123,18 @@ sub parseCfgCmdLine
-file => $cfg->{'config_file'},
-nocase => 1
) or die "Failed to open config file '".$cfg->{'config_file'}."': $!";
my $inifileHandle = tied( %inifile );
# Copy config
my %config = %inifile;
# Pull in params for the server
my @server_params = (
'log_level',#'log_file',
# 'host',
# 'pid_file',
# 'user', 'group',
# 'timeout',
# 'background',
'log_level','log_file',
'pid_file',
'background',
);
foreach my $param (@server_params) {
$cfg->{$param} = $config{'server'}{$param} if (defined($config{'server'}{$param}));
$cfg->{$param} = $config{'system'}{$param} if (defined($config{'system'}{$param}));
}
# Override
......@@ -123,29 +144,20 @@ sub parseCfgCmdLine
}
# If we set on commandline for foreground, keep in foreground
if ($cmdline->{'fg'} || (defined($config{'server'}{'background'}) && $config{'server'}{'background'} eq "no" )) {
if ($cmdline->{'fg'} || (defined($config{'system'}{'background'}) && $config{'system'}{'background'} eq "no" )) {
$cfg->{'background'} = undef;
$cfg->{'log_file'} = undef;
} else {
$cfg->{'setsid'} = 1;
$cfg->{'pid_file'} = undef;
}
# Loop with logging detail
# if (defined($config{'server'}{'log_detail'})) {
# # Lets see what we have to enable
# foreach my $detail (split(/[,\s;]/,$config{'server'}{'log_detail'})) {
# $cfg->{'logging'}{$detail} = 1;
# }
# }
#
# System plugins
#
if (ref($config{'plugins'}{'load'}) eq "ARRAY") {
foreach my $plugin (@{$config{'plugins'}{'load'}}) {
$plugin =~ s/\s+//g;
# Skip comments
next if ($plugin =~ /^#/);
# Skip comments
next if ($plugin =~ /^#/);
push(@{$cfg->{'plugin_list'}},$plugin);
}
} elsif (defined($config{'plugins'}{'load'})) {
......@@ -157,10 +169,16 @@ sub parseCfgCmdLine
}
}
# Check if the user specified a cache_file in the config
# if (defined($config{'server'}{'cache_file'})) {
# $cfg->{'cache_file'} = $config{'server'}{'cache_file'};
# }
# We may have config file groups we want to remember for other plugins
foreach my $group ($inifileHandle->Groups()) {
# Loop with group members
foreach my $member ($inifileHandle->GroupMembers($group)) {
# Chop off group name and just get the member
my $cleanMember = substr($member,length($group)+1);
# Link the config...
$config{$group}->{$cleanMember} = $config{$member};
}
}
$globals->{'file.config'} = \%config;
$globals->{'config'} = $cfg;
......@@ -169,6 +187,7 @@ sub parseCfgCmdLine
# Display help
sub displayHelp {
displayBanner();
print(STDERR<<EOF);
......@@ -189,60 +208,53 @@ sub init
$globals->{'logger'} = $logger;
$globals->{'version'} = VERSION;
$logger->log(LOG_NOTICE,"[MAIN] Entering INITIALIZATION state");
# Setup master session
POE::Session->create(
inline_states => {
'_start' => \&main_session_start,
'_stop' => \&main_session_stop,
'main_SIGHUP' => \&main_signal_SIGHUP,
'main_SIGINT' => \&main_signal_SIGINT,
},
);
$logger->log(LOG_INFO,"[MAIN] Initializing plugins...");
# We need to set the plugins global variable
opentrafficshaper::plugins::init($globals);
# Core configuration manager
$logger->log(LOG_INFO,"[MAIN] Initializing config manager...");
my $res = eval("
use opentrafficshaper::plugins::configmanager;
plugin_register(\$globals,\"configmanager\",\$opentrafficshaper::plugins::configmanager::pluginInfo);
");
if ($@ || (defined($res) && $res != 0)) {
$logger->log(LOG_WARN,"[MAIN] Error loading config manager, things WILL BREAK! ($@)");
} else {
$logger->log(LOG_DEBUG,"[MAIN] Config manager initialized.");
}
plugin_register("configmanager",1);
# Load plugins
$logger->log(LOG_INFO,"[MAIN] Initializing plugins...");
foreach my $plugin (@{$globals->{'config'}->{'plugin_list'}}) {
# Load plugin
my $res = eval("
use opentrafficshaper::plugins::${plugin}::${plugin};
plugin_register(\$globals,\"${plugin}\",\$opentrafficshaper::plugins::${plugin}::pluginInfo);
");
if ($@ || (defined($res) && $res != 0)) {
$logger->log(LOG_WARN,"[MAIN] Error loading plugin '$plugin' ($@)");
} else {
$logger->log(LOG_DEBUG,"[MAIN] Plugin '$plugin' loaded.");
}
foreach my $pluginName (@{$globals->{'config'}->{'plugin_list'}}) {
plugin_register($pluginName,0);
}
$logger->log(LOG_INFO,"[MAIN] Plugins initialized.");
$logger->log(LOG_INFO,"[MAIN] Plugins initialized");
}
# Register plugin info
sub plugin_register {
my ($globals,$plugin,$info) = @_;
# Function to start things up
sub start
{
$logger->log(LOG_NOTICE,"[MAIN] Entering STARTING state");
# Loop with plugins and call the start function for those that exist
foreach my $pluginName (keys %{$globals->{'plugins'}})
{
my $plugin = $globals->{'plugins'}->{$pluginName};
# If no info, return
if (!defined($info)) {
$logger->log(LOG_WARN,"WARNING: Plugin info not found for plugin => $plugin\n");
return -1;
# Load the function up
my $callStart = $plugin->{'Start'};
if (defined($callStart)) {
$callStart->();
}
}
}
# Set real module name & save
$info->{'Plugin'} = $plugin;
push(@{$globals->{'plugins'}},$info);
# If we should, init the module
if (defined($info->{'Init'})) {
$info->{'Init'}($globals);
}
return 0;
}
# NK: Needs work
# Become daemon
sub daemonize {
chdir '/'
......@@ -251,20 +263,73 @@ sub daemonize {
open STDIN, '/dev/null'
or die "Can't read /dev/null: $!";
open STDOUT, '> /var/log/ppp-gatekeeper/stdout.log'
open STDOUT, '> /dev/null'
or die "Can't open stdout log: $!";
defined(my $pid = fork)
defined(my $pid = fork)
or die "Can't fork: $!";
exit if $pid;
# Write out our PID if we have a file to do it
if (defined($globals->{'config'}->{'pid_file'})) {
if (open(FH,"> ".$globals->{'config'}->{'pid_file'})) {
print(FH $$);
close(FH);
} else {
$logger->log(LOG_WARN,"[MAIN] Unable to write PID to '%s': %s",$globals->{'config'}->{'pid_file'},$!);
}
}
setsid
or die "Can't start a new session: $!";
open STDERR, '> /var/log/ppp-gatekeeper/stderr.log'
open STDERR, '> /dev/null'
or die "Can't open stderr log: $!";
}
# Function to fire up our main session
sub main_session_start
{
my $kernel = $_[KERNEL];
$kernel->alias_set('main');
# Register signal handlers
$kernel->sig('HUP', 'main_SIGHUP');
$kernel->sig('INT', 'main_SIGINT');
}
# Function to dispose of anything as a final stage to shutting down
sub main_session_stop
{
$logger->log(LOG_DEBUG,"[MAIN] Shutdown");
}
# Function to handle SIGHUP
sub main_signal_SIGHUP
{
my ($kernel,$signal_name) = @_[KERNEL,ARG0];
$logger->log(LOG_NOTICE,"[MAIN] Got SIGHUP");
$kernel->sig_handled();
}
# Function to handle SIGINT
sub main_signal_SIGINT
{
my ($kernel, $signal_name) = @_[KERNEL, ARG0];
$logger->log(LOG_NOTICE,"[MAIN] Got SIGINT, shutting down...");
$kernel->signal($kernel,'handle_SIGINT');
}
# vim: ts=4