#!/usr/bin/env python2
############################################################################
#
# Parse DSL link stats for TP-Link W9970 & generate RRD archives & graphs
#
############################################################################
#
# Copyright (C) 2015 Daniel O'Connor. 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.
#
# THIS SOFTWARE IS PROVIDED BY AUTHOR 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 AUTHOR 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.
#
############################################################################

import base64
import ConfigParser
import optparse
import os
import re
import requests
import rrdtool
import sys
import time
import urllib
from bs4 import BeautifulSoup

conf = ConfigParser.ConfigParser()
conf.add_section('global')
conf.set('global', 'username', 'admin')
conf.set('global', 'password', 'admin')
conf.set('global', 'name', '10.0.2.13')

conflist = ['adslstats.ini']
if ('HOME' in os.environ):
    conflist.append(os.path.expanduser('~/.adslstats.ini'))
conf.read(conflist)

usage = '''%prog [options]'''
opts = optparse.OptionParser(usage)
opts.add_option('-v', '--verbose', action="store_true", default=False,
                    help="Enable debug output")
opts.add_option('-g', '--graph', action="store_true", default=False,
                    help="Generate a graph")
opts.add_option('-u', '--update', action="store_true", default=False,
                    help="Update RRD (implies -d)")
opts.add_option('-m', '--munin', action="store", default=None,
                    help="Output munin data for ARG")
opts.add_option('-a', '--authname', action="store", default=conf.get('global', 'username'),
                    help="Username to login to modem")
opts.add_option('-p', '--password', action="store", default=conf.get('global', 'password'),
                    help="Password to login to modem")
opts.add_option('-n', '--name', action="store", default=conf.get('global', 'name'),
                    help="Hostname of modem")
opts.add_option('-b', '--base', action="store", default="/home/darius/projects/adslstats/adslstats",
                    help="Base directory for RRD & PNGs")

(options, args) = opts.parse_args()

statsurl = "http://%s/statsadsl.html" % (options.name)
rrdname = "%s.rrd" % (options.base)
graphbasename = options.base

matchnum = re.compile('([0-9]+(\.[0-9]+)?)')
statsdict = {
    3 : 'Status:',
    8 : 'SNR Margin (0.1 dB):',
    9 : 'Attenuation (0.1 dB):',
    14 : 'Rate (Kbps):',
}

class DSLStats(object):
    def __str__(self):
        s = "Line Rate - Up: %d kbits, Down %d kbits\n" % (self.upstream, self.downstream)
        if hasattr(self, 'upstreammax'):
            s += "Maximum Rate - Up: %d kbit, Down %s kbit\n" % (self.upstreammax, self.downstreammax)
        s += """Noise Margin - Up: %.1f dB, Down %.1f dB
Attenuation - Up: %.1f dB, Down %.1f dB""" % (self.nmup, self.nmdown,
                                              self.attenup, self.attendown)
        return s

def getstats():
    stats = DSLStats()
    parser = ConfigParser.ConfigParser()
    base = 'http://%s' % (conf.get('global', 'name'))
    # Gunk extracted from Chrome (what the page is requesting). Note it's sensitive to line ending type...
    # We could get more data, eg error rates..
    data = '[WAN_DSL_INTF_CFG#1,0,0,0,0,0#0,0,0,0,0,0]0,12\r\nstatus\r\nmodulationType\r\nX_TP_AdslModulationCfg\r\nupstreamCurrRate\r\ndownstreamCurrRate\r\nX_TP_AnnexType\r\nupstreamMaxRate\r\ndownstreamMaxRate\r\nupstreamNoiseMargin\r\ndownstreamNoiseMargin\r\nupstreamAttenuation\r\ndownstreamAttenuation\r\n[WAN_DSL_INTF_STATS_TOTAL#1,0,0,0,0,0#0,0,0,0,0,0]1,8\r\nATUCCRCErrors\r\nCRCErrors\r\nATUCFECErrors\r\nFECErrors\r\nSeverelyErroredSecs\r\nX_TP_US_SeverelyErroredSecs\r\nerroredSecs\r\nX_TP_US_ErroredSecs\r\n'
    cookies = {'Authorization' : 'Basic ' + base64.standard_b64encode(conf.get('global', 'username') + ':' + conf.get('global', 'password'))}
    headers = {'Referer' : base}
    r = requests.post(base + '/cgi?1&5' , data = data, headers = headers, cookies = cookies, stream = True)
    parser.readfp(r.raw)
    res = {}
    tmp = '1,0,0,0,0,0'
    if parser.get(tmp, 'status') == 'Up':
        stats.linkup = True
    else:
        stats.linkup = False
    stats.upstream = float(parser.get(tmp, 'upstreamCurrRate'))
    stats.downstream = float(parser.get(tmp, 'downstreamCurrRate'))
    stats.upstreammax = float(parser.get(tmp, 'upstreamMaxRate'))
    stats.downstreammax = float(parser.get(tmp, 'downstreamMaxRate'))
    stats.nmup = float(parser.get(tmp, 'upstreamNoiseMargin')) / 10.0
    stats.nmdown = float(parser.get(tmp, 'downstreamNoiseMargin')) / 10.0
    stats.attenup = float(parser.get(tmp, 'upstreamAttenuation')) / 10.0
    stats.attendown = float(parser.get(tmp, 'downstreamAttenuation')) / 10.0

    return stats

# Setup RRD
# We expect data to be logged every 5 minutes
# Average 12 5 minute points -> hourly stats (keep 168 - a weeks worth)
# Average 288 5 minute points -> daily stats (keep 1825 - 5 years worth)
# Detemine  minimum & maximum for an hour and keep a weeks worth.
def makerrd(filename):
    rrdtool.create(filename,
                   '--step', '300',
                   'DS:upstream:GAUGE:3600:32:150000',   # Upstream (kbits)
                   'DS:downstream:GAUGE:3600:32:150000', # Downstream (kbits)
                   'DS:upstreammax:GAUGE:3600:32:150000',   # Upstream maximum (kbits)
                   'DS:downstreammax:GAUGE:3600:32:150000', # Downstream maximum (kbits)
                   'DS:nmup:GAUGE:3600:0:100',          # Upstream Noise margin (dB)
                   'DS:nmdown:GAUGE:3600:0:100',        # Downstream Noise margin (dB)
                   'DS:attenup:GAUGE:3600:0:100',       # Upstream Attenuation (dB)
                   'DS:attendown:GAUGE:3600:0:100',     # Downstream Attenuation (dB)
                   'RRA:AVERAGE:0.1:12:168',
                   'RRA:AVERAGE:0.1:288:1825',
                   'RRA:MIN:0.1:12:168',
                   'RRA:MAX:0.1:12:168')

# Update the RRD (format stats as expected)
def updaterrd(filename, tstamp, stats):
    rrdtool.update(filename,
                   '%d:%d:%d:%d:%d:%f:%f:%f:%f' % (tstamp,
                                             stats.upstream,
                                             stats.downstream,
                                             stats.upstreammax,
                                             stats.downstreammax,
                                             stats.nmup,
                                             stats.nmdown,
                                             stats.attenup,
                                             stats.attendown))

# Open the URL and call the parser
def getdata():
    stats = getstats()
    return stats

# Generate a graph
def gengraph():

    linkargs = (
        '-a', 'SVG',
        '-X', '0',
        '-l', '0',
        '--vertical-label', 'kbit/sec',
        '--slope-mode',

        'DEF:upstream=%s:upstream:AVERAGE' % rrdname,
        'DEF:upstreammin=%s:upstream:MIN' % rrdname,
        'DEF:upstreammax=%s:upstream:MAX' % rrdname,

        'DEF:downstream=%s:downstream:AVERAGE' % rrdname,
        'DEF:downstreammin=%s:downstream:MIN' % rrdname,
        'DEF:downstreammax=%s:downstream:MAX' % rrdname,

        'CDEF:upstreamdif=upstreammax,upstreammin,-',
        'CDEF:downstreamdif=downstreammax,downstreammin,-',

        'DEF:maxupstream=%s:upstreammax:AVERAGE' % rrdname,
        'DEF:maxdownstream=%s:downstreammax:AVERAGE' % rrdname,

        'LINE0:upstreammin#000000:',
        'AREA:upstreamdif#00dc76::STACK',
        'LINE1:upstream#00ff00:Upstream',

        'LINE0:downstreammin#000000:',
        'AREA:downstreamdif#ff8686::STACK',
        'LINE1:downstream#ff0000:Downstream',

        'LINE1:maxupstream#0000ff:Upstream (maximum)',
        'LINE1:maxdownstream#000000:Downstream (maximum)'
    )

    signalargs = (
        '-a', 'SVG',
        '--vertical-label', 'dB',
        '--slope-mode',
        '-l', '0',

        'DEF:upstream=%s:upstream:AVERAGE' % rrdname,
        'DEF:downstream=%s:downstream:AVERAGE' % rrdname,

        'DEF:nmup_=%s:nmup:AVERAGE' % rrdname,
        'DEF:nmupmin_=%s:nmup:MIN' % rrdname,
        'DEF:nmupmax_=%s:nmup:MAX' % rrdname,

        'DEF:nmdown_=%s:nmdown:AVERAGE' % rrdname,
        'DEF:nmdownmin_=%s:nmdown:MIN' % rrdname,
        'DEF:nmdownmax_=%s:nmdown:MAX' % rrdname,

        'DEF:attenup=%s:attenup:AVERAGE' % rrdname,
        'DEF:attenupmin=%s:attenup:MIN' % rrdname,
        'DEF:attenupmax=%s:attenup:MAX' % rrdname,

        'DEF:attendown=%s:attendown:AVERAGE' % rrdname,
        'DEF:attendownmin=%s:attendown:MIN' % rrdname,
        'DEF:attendownmax=%s:attendown:MAX' % rrdname,

        'CDEF:nmup=nmup_,10,*',
        'CDEF:nmupmin=nmupmin_,10,*',
        'CDEF:nmupmax=nmupmax_,10,*',
        'CDEF:nmupdif=nmupmax,nmupmin,-',

        'CDEF:nmdown=nmdown_,10,*',
        'CDEF:nmdownmin=nmdownmin_,10,*',
        'CDEF:nmdownmax=nmdownmax_,10,*',
        'CDEF:nmdowndif=nmdownmax,nmdownmin,-',

        'CDEF:attenupdif=attenupmax,attenupmin,-',

        'CDEF:attendowndif=attendownmax,attendownmin,-',

        'LINE0:nmupmin#000000:',
        'AREA:nmupdif#5c5cff::STACK',
        'LINE1:nmup#0000ff:Noise Margin - Up (1/10 dB)',

        'LINE0:nmdownmin#000000:',
        'AREA:nmdowndif#009a00::STACK',
        'LINE1:nmdown#00ff00:Noise Margin - Down (1/10 dB)',

        'LINE0:attenupmin#000000:',
        'AREA:attenupdif#f98100::STACK',
        'LINE1:attenup#ff0000:Attenuation - Up',

        'LINE0:attendownmin#000000:',
        'AREA:attendowndif#aaaaaa::STACK',
        'LINE1:attendown#000000:Attenuation - Down')

    rrdtool.graph("%s-hour-link.svg" % (graphbasename),
                  '--width', '768',
                  '--height', '256',
                  '--start', 'end - 7d',
                  '--end', 'now',
                  *linkargs)

    rrdtool.graph("%s-daily-link.svg" % (graphbasename),
                  '--width', '768',
                  '--height', '256',
                  '--start', 'end - 365d',
                  '--end', 'now',
                  *linkargs)


    rrdtool.graph("%s-hour-signal.svg" % (graphbasename),
                  '--width', '768',
                  '--height', '256',
                  '--start', 'end - 7d',
                  '--end', 'now',
                  *signalargs)

    rrdtool.graph("%s-daily-signal.svg" % (graphbasename),
                  '--width', '768',
                  '--height', '256',
                  '--start', 'end - 365d',
                  '--end', 'now',
                  *signalargs)

if __name__ == "__main__":
    names = ['Noise Margin (up)', 'Noise Margin (down)', 'Attenuation (up)', 'Attenuation (down)']
    if options.munin != None:
        # Handle the wrapper passing us its $0 as our $1
        tmp = options.munin.split('_')
        if len(tmp) > 1:
            options.munin = tmp[-1]
        if options.munin not in ['signal', 'sync']:
            print "Unknown data type ", options.munin
            sys.exit(1)
        if len(args) > 0:
            if args[0] == 'config':
                if options.munin == 'signal':
                    print '''graph_category adsl
graph_title DSL Signal Quality
graph_args --base 1000 -l 0
graph_vlabel dB'''
                    for n in names:
                        name = n.translate(None, ' ()').lower()
                        print '''%s.label %s
%s.type GAUGE
%s.max 100
%s.min 0''' % (name, n, name, name, name)
                elif options.munin == 'sync':
                    print '''graph_category adsl
graph_title DSL Sync Speed
graph_args --base 1024 -l 0
graph_vlabel kbit/sec
up.label Up
up.type GAUGE
up.max 150000
up.min 0
down.label Down
down.type GAUGE
down.max 15000
down.min 0
upmax.label Up
upmax.type GAUGE
upmax.max 150000
upmax.min 0
downmax.label Down
downmax.type GAUGE
downmax.max 150000
downmax.min 0'''
            sys.exit(0)
    if options.update or options.munin:
        stats = getdata()
        if options.verbose:
            if stats == None:
                print "Modem is offline"
            else:
                print stats
    if (options.update or options.munin != None) and stats != None:
        if options.update:
            try:
                os.stat(rrdname)
            except OSError, e:
                if e.errno == 2:
                    print "rrd not found, creating.."
                    makerrd(rrdname)
            updaterrd(rrdname, int(time.time()), stats)
        if options.munin != None:
            if options.munin == 'signal':
                print '''noisemarginup.value %.1f
noisemargindown.value %.1f
attenuationup.value %.1f
attenuationdown.value %.1f''' % (stats.nmup, stats.nmdown, stats.attenup, stats.attendown)
            elif options.munin == 'sync':
                s = '''up.value %.1f
down.value %.1f\n''' % (stats.upstream, stats.downstream)
                if hasattr(stats, 'upstreammax'):
                    s += '''upmax.value %.1f
downmax.value %.1f''' % (stats.upstreammax, stats.downstreammax)
                print s
    if options.graph:
        gengraph()