mirror of
https://github.com/munin-monitoring/contrib.git
synced 2025-07-25 18:38:30 +00:00
Format code according to PEP0008
This commit is contained in:
Neraud
parent
0f88253361
commit
5fd233c510
1 changed files with 303 additions and 263 deletions
|
|
@ -38,60 +38,68 @@
|
|||
# Written by : Neraud
|
||||
#
|
||||
# Markers for munin :
|
||||
#%# family=auto
|
||||
#%# capabilities=autoconf suggest
|
||||
# %# family=auto
|
||||
# %# capabilities=autoconf suggest
|
||||
##########################################
|
||||
|
||||
|
||||
import logging, commands, sys, os, string
|
||||
from twisted.internet import reactor, defer
|
||||
from deluge.ui.client import client
|
||||
import commands
|
||||
from deluge.log import setupLogger
|
||||
from deluge.ui.client import client
|
||||
import logging
|
||||
import os
|
||||
import string
|
||||
import sys
|
||||
from twisted.internet import reactor, defer
|
||||
setupLogger()
|
||||
|
||||
plugin_version = "1.0.0"
|
||||
|
||||
# create logger
|
||||
log = logging.getLogger("delugeStats")
|
||||
log.setLevel(logging.WARNING)
|
||||
|
||||
# Deluge daemon Confs
|
||||
conf = {
|
||||
'host' : os.getenv('host', '127.0.0.1'),
|
||||
'port' : int(os.getenv('port', '58846')),
|
||||
'username' : os.getenv('username', ''),
|
||||
'password' : os.getenv('password', '')
|
||||
'host': os.getenv('host', '127.0.0.1'),
|
||||
'port': int(os.getenv('port', '58846')),
|
||||
'username': os.getenv('username', ''),
|
||||
'password': os.getenv('password', '')
|
||||
}
|
||||
|
||||
# names for munin :
|
||||
namesForMunin = {
|
||||
'numConnections' : 'numConnections',
|
||||
'payloadUploadRate' : 'payloadUploadRate',
|
||||
'overheadUploadRate' : 'overheadUploadRate',
|
||||
'payloadDownloadRate' : 'payloadDownloadRate',
|
||||
'overheadDownloadRate' : 'overheadDownloadRate',
|
||||
'state.Seeding' : 'seeding',
|
||||
'state.Downloading' : 'downloading',
|
||||
'state.Paused' : 'paused',
|
||||
'state.Error' : 'error',
|
||||
'state.Queued' : 'queued',
|
||||
'state.Checking' : 'checking',
|
||||
'state.Other' : 'other'
|
||||
names_for_munin = {
|
||||
'numConnections': 'numConnections',
|
||||
'payloadUploadRate': 'payloadUploadRate',
|
||||
'overheadUploadRate': 'overheadUploadRate',
|
||||
'payloadDownloadRate': 'payloadDownloadRate',
|
||||
'overheadDownloadRate': 'overheadDownloadRate',
|
||||
'state.Seeding': 'seeding',
|
||||
'state.Downloading': 'downloading',
|
||||
'state.Paused': 'paused',
|
||||
'state.Error': 'error',
|
||||
'state.Queued': 'queued',
|
||||
'state.Checking': 'checking',
|
||||
'state.Other': 'other'
|
||||
}
|
||||
|
||||
torrentStates = [ "Downloading", "Seeding", "Paused", "Error", "Queued", "Checking", "Other" ]
|
||||
torrent_states = ["Downloading",
|
||||
"Seeding",
|
||||
"Paused",
|
||||
"Error",
|
||||
"Queued",
|
||||
"Checking",
|
||||
"Other"]
|
||||
|
||||
modes = ["bandwidth", "connections", "states"]
|
||||
|
||||
modes = [ "bandwidth", "connections", "states" ]
|
||||
|
||||
class StatClient:
|
||||
|
||||
def __init__(self, conf, mode) :
|
||||
def __init__(self, conf, mode):
|
||||
self.conf = conf
|
||||
self.mode = mode
|
||||
self.connected = False
|
||||
|
||||
def endSession(self, msg):
|
||||
log.debug("endSession : {0}".format(msg))
|
||||
def end_session(self, msg):
|
||||
log.debug("end_session : {0}".format(msg))
|
||||
|
||||
if self.connected:
|
||||
log.debug("Disconnecting")
|
||||
|
|
@ -99,117 +107,146 @@ class StatClient:
|
|||
|
||||
reactor.stop()
|
||||
|
||||
def fetchInfo(self):
|
||||
log.debug("Connecting to {0}:{1} ...".format(self.conf['host'], self.conf['port']))
|
||||
client.connect(self.conf['host'], self.conf['port'], self.conf['username'], self.conf['password']).addCallbacks(self.onConnectSuccess, self.endSession, errbackArgs=("Connection failed: check settings and try again."))
|
||||
def fetch_info(self):
|
||||
log.debug("Connecting to {0}:{1} ...".format(
|
||||
self.conf['host'], self.conf['port']))
|
||||
client.connect(
|
||||
self.conf['host'],
|
||||
self.conf['port'],
|
||||
self.conf['username'],
|
||||
self.conf['password']).addCallbacks(
|
||||
self.on_connect_success,
|
||||
self.end_session,
|
||||
errbackArgs=("Connection failed: check settings and try again."))
|
||||
reactor.run()
|
||||
|
||||
def onConnectSuccess(self, result):
|
||||
def on_connect_success(self, result):
|
||||
log.debug("Connection was successful")
|
||||
self.connected = True
|
||||
|
||||
if self.mode == "connections" :
|
||||
if self.mode == "connections":
|
||||
log.debug("Calling get_num_connections")
|
||||
client.core.get_num_connections().addCallbacks(self.onNumConnections, self.endSession, errbackArgs=("get_num_connections failed"))
|
||||
elif self.mode == "bandwidth" :
|
||||
client.core.get_num_connections().addCallbacks(
|
||||
self.on_num_connections,
|
||||
self.end_session, errbackArgs=("get_num_connections failed"))
|
||||
elif self.mode == "bandwidth":
|
||||
log.debug("Calling get_session_status")
|
||||
client.core.get_session_status(['upload_rate', 'payload_upload_rate', 'download_rate', 'payload_download_rate']).addCallbacks(self.onBandwidth, self.endSession, errbackArgs=("get_session_status faileds"))
|
||||
elif self.mode == "states" :
|
||||
interesting_status = [
|
||||
'upload_rate', 'payload_upload_rate',
|
||||
'download_rate', 'payload_download_rate']
|
||||
client.core.get_session_status(interesting_status).addCallbacks(
|
||||
self.on_bandwidth,
|
||||
self.end_session,
|
||||
errbackArgs=("get_session_status failed"))
|
||||
elif self.mode == "states":
|
||||
log.debug("Calling get_session_state")
|
||||
client.core.get_session_state().addCallbacks(self.onSessionState, self.endSession, errbackArgs=("get_session_state failed"))
|
||||
client.core.get_session_state().addCallbacks(
|
||||
self.on_session_state,
|
||||
self.end_session,
|
||||
errbackArgs=("get_session_state failed"))
|
||||
|
||||
def onNumConnections(self, num_connections):
|
||||
log.debug("Got num_connections from the daemon : {0}".format(str(num_connections)))
|
||||
print "{0}.value {1}".format(namesForMunin["numConnections"], num_connections)
|
||||
self.endSession("Done")
|
||||
def on_num_connections(self, num_connections):
|
||||
log.debug("Got num_connections from the daemon : {0}".format(
|
||||
str(num_connections)))
|
||||
print "{0}.value {1}".format(
|
||||
names_for_munin["numConnections"], num_connections)
|
||||
self.end_session("Done")
|
||||
|
||||
def onBandwidth(self, values):
|
||||
log.debug("Got bandwith info from the daemon : {0}".format(str(values)))
|
||||
def on_bandwidth(self, values):
|
||||
log.debug(
|
||||
"Got bandwidth info from the daemon : {0}".format(str(values)))
|
||||
|
||||
downloadRate = values['download_rate']
|
||||
payloadDownloadRate = values['payload_download_rate']
|
||||
overheadDownloadRate = downloadRate - payloadDownloadRate
|
||||
uploadRate = values['upload_rate']
|
||||
payloadUploadRate = values['payload_upload_rate']
|
||||
overheadUploadRate = uploadRate - payloadUploadRate
|
||||
download_rate = values['download_rate']
|
||||
payload_download_rate = values['payload_download_rate']
|
||||
overhead_download_rate = download_rate - payload_download_rate
|
||||
upload_rate = values['upload_rate']
|
||||
payload_upload_rate = values['payload_upload_rate']
|
||||
overhead_upload_rate = upload_rate - payload_upload_rate
|
||||
|
||||
print "{0}.value {1}".format(namesForMunin["payloadDownloadRate"], payloadDownloadRate)
|
||||
print "{0}.value {1}".format(namesForMunin["overheadDownloadRate"], overheadDownloadRate)
|
||||
print "{0}.value {1}".format(namesForMunin["payloadUploadRate"], payloadUploadRate)
|
||||
print "{0}.value {1}".format(namesForMunin["overheadUploadRate"], overheadUploadRate)
|
||||
print "{0}.value {1}".format(
|
||||
names_for_munin["payloadDownloadRate"], payload_download_rate)
|
||||
print "{0}.value {1}".format(
|
||||
names_for_munin["overheadDownloadRate"], overhead_download_rate)
|
||||
print "{0}.value {1}".format(
|
||||
names_for_munin["payloadUploadRate"], payload_upload_rate)
|
||||
print "{0}.value {1}".format(
|
||||
names_for_munin["overheadUploadRate"], overhead_upload_rate)
|
||||
|
||||
self.endSession("Done")
|
||||
self.end_session("Done")
|
||||
|
||||
def onSessionState(self, torrentIds):
|
||||
def on_session_state(self, torrent_ids):
|
||||
log.debug("Got session state from the daemon")
|
||||
|
||||
self.states = { }
|
||||
for stateName in torrentStates :
|
||||
self.states[stateName] = 0
|
||||
#self.states={'Seeding': 0, 'Downloading': 0, 'Paused': 0, 'Error': 0, 'Queued': 0, 'Checking': 0, 'Other' : 0}
|
||||
self.states = {}
|
||||
for state_name in torrent_states:
|
||||
self.states[state_name] = 0
|
||||
|
||||
deferredList = []
|
||||
for torrentId in torrentIds:
|
||||
log.debug(" - TorrentId : {0}".format(torrentId))
|
||||
d = client.core.get_torrent_status(torrentId, ['state'])
|
||||
d.addCallback(self.onOneTorrentInfo, torrentId)
|
||||
d.addErrback(self.onOneTorrentInfoFailed, torrentId)
|
||||
deferredList.append(d)
|
||||
deferred_list = []
|
||||
for torrent_id in torrent_ids:
|
||||
log.debug(" - TorrentId : {0}".format(torrent_id))
|
||||
d = client.core.get_torrent_status(torrent_id, ['state'])
|
||||
d.addCallback(self.on_one_torrent_info, torrent_id)
|
||||
d.addErrback(self.on_one_torrent_info_failed, torrent_id)
|
||||
deferred_list.append(d)
|
||||
|
||||
defer.DeferredList(deferredList).addCallback(self.onAllTorrentInfoFetched)
|
||||
defer.DeferredList(deferred_list).addCallback(
|
||||
self.on_all_torrent_info_fetched)
|
||||
|
||||
def onOneTorrentInfoFailed(self, torrentId):
|
||||
log.debug("Failed fetching torrent info {0}".format(torrentId))
|
||||
self.state["Error"] = self.state["Error"] + 1;
|
||||
def on_one_torrent_info_failed(self, torrent_id):
|
||||
log.debug("Failed fetching torrent info {0}".format(torrent_id))
|
||||
self.state["Error"] = self.state["Error"] + 1
|
||||
|
||||
|
||||
def onOneTorrentInfo(self, value, torrentId):
|
||||
log.debug("Got torrent info : {0} -> {1}".format(torrentId, value))
|
||||
def on_one_torrent_info(self, value, torrent_id):
|
||||
log.debug("Got torrent info : {0} -> {1}".format(torrent_id, value))
|
||||
if 'state' in value:
|
||||
state = value['state']
|
||||
else:
|
||||
state = "Error"
|
||||
|
||||
if not (state in self.states) :
|
||||
if not (state in self.states):
|
||||
log.warn("State '{0}' is unknown !".format(state))
|
||||
state = "Other"
|
||||
|
||||
self.states[state] = self.states[state] + 1
|
||||
|
||||
def onAllTorrentInfoFetched(self, res):
|
||||
log.debug("onAllTorrentInfoFetched : {0}".format(str(self.states)))
|
||||
def on_all_torrent_info_fetched(self, res):
|
||||
log.debug("on_all_torrent_info_fetched : {0}".format(str(self.states)))
|
||||
|
||||
for state in self.states:
|
||||
print "{0}.value {1}".format(namesForMunin["state." + state], self.states[state])
|
||||
print "{0}.value {1}".format(
|
||||
names_for_munin["state." + state], self.states[state])
|
||||
|
||||
self.endSession("Done")
|
||||
self.end_session("Done")
|
||||
|
||||
|
||||
def getMode() :
|
||||
scriptName = list(os.path.split(sys.argv[0]))[1]
|
||||
mode = scriptName[string.rindex(scriptName,'_')+1:]
|
||||
def get_mode():
|
||||
script_name = list(os.path.split(sys.argv[0]))[1]
|
||||
mode = script_name[string.rindex(script_name, '_') + 1:]
|
||||
|
||||
log.debug("Mode : {0}".format(str(mode)))
|
||||
|
||||
if not mode in modes :
|
||||
if not mode in modes:
|
||||
log.error("Unknown mode '{0}'".format(mode))
|
||||
log.info("Available modes are : {0}".format(str(modes)))
|
||||
sys.exit(1)
|
||||
|
||||
return mode
|
||||
|
||||
def printConfig(mode) :
|
||||
if mode == "connections" :
|
||||
|
||||
def print_config(mode):
|
||||
if mode == "connections":
|
||||
print("graph_title Number of connections")
|
||||
print("graph_args --base 1000 -l 0")
|
||||
print("graph_vlabel connections")
|
||||
print("graph_scale yes")
|
||||
print("graph_category deluge")
|
||||
print("graph_info This graph shows the number of connections used by Deluge Torrent")
|
||||
print(namesForMunin["numConnections"] + ".label connections")
|
||||
print(namesForMunin["numConnections"] + ".min 0")
|
||||
print(namesForMunin["numConnections"] + ".info The number of connections used by Deluge Torrent")
|
||||
elif mode == "bandwidth" :
|
||||
print(
|
||||
"graph_info This graph shows the number of connections used by Deluge Torrent")
|
||||
print(names_for_munin["numConnections"] + ".label connections")
|
||||
print(names_for_munin["numConnections"] + ".min 0")
|
||||
print(names_for_munin["numConnections"] +
|
||||
".info The number of connections used by Deluge Torrent")
|
||||
elif mode == "bandwidth":
|
||||
print("graph_title Bandwidth usage")
|
||||
print("graph_order payloadUploadRate payloadDownloadRate overheadUploadRate overheadDownloadRate")
|
||||
print("graph_args --base 1024 -r")
|
||||
|
|
@ -222,7 +259,7 @@ def printConfig(mode) :
|
|||
print("payloadUploadRate.label payload")
|
||||
print("payloadUploadRate.draw AREA")
|
||||
print("payloadUploadRate.min 0")
|
||||
#print("payloadUploadRate.info Bandwidth used to upload torrents")
|
||||
# print("payloadUploadRate.info Bandwidth used to upload torrents")
|
||||
|
||||
print("payloadDownloadRate.label payload")
|
||||
print("payloadDownloadRate.draw AREA")
|
||||
|
|
@ -233,21 +270,21 @@ def printConfig(mode) :
|
|||
print("overheadUploadRate.label overhead")
|
||||
print("overheadUploadRate.draw STACK")
|
||||
print("overheadUploadRate.min 0")
|
||||
#print("overheadUploadRate.info Bandwidth 'lost' due to overhead while downloading and uploading torrents")
|
||||
# print("overheadUploadRate.info Bandwidth 'lost' due to overhead while downloading and uploading torrents")
|
||||
|
||||
print("overheadDownloadRate.label overhead")
|
||||
print("overheadDownloadRate.draw STACK")
|
||||
print("overheadDownloadRate.min 0")
|
||||
print("overheadDownloadRate.negative overheadUploadRate")
|
||||
print("overheadDownloadRate.info Bandwidth 'lost' due to overhead while downloading and uploading torrents")
|
||||
elif mode == "states" :
|
||||
elif mode == "states":
|
||||
print("graph_title Torrents states")
|
||||
|
||||
graphOrder = ""
|
||||
for stateName in torrentStates :
|
||||
graphOrder += namesForMunin["state." + stateName] + " "
|
||||
graph_order = ""
|
||||
for state_name in torrent_states:
|
||||
graph_order += names_for_munin["state." + state_name] + " "
|
||||
|
||||
print("graph_order " + graphOrder)
|
||||
print("graph_order " + graph_order)
|
||||
print("graph_args --base 1000 -r --lower-limit 0")
|
||||
print("graph_vlabel number of torrents")
|
||||
print("graph_scale yes")
|
||||
|
|
@ -256,49 +293,52 @@ def printConfig(mode) :
|
|||
print("graph_period second")
|
||||
|
||||
first = True
|
||||
for stateName in torrentStates :
|
||||
print(namesForMunin["state." + stateName ] + ".label " + stateName)
|
||||
if first :
|
||||
for state_name in torrent_states:
|
||||
print(names_for_munin["state." +
|
||||
state_name] + ".label " + state_name)
|
||||
if first:
|
||||
first = False
|
||||
print(namesForMunin["state." + stateName ] + ".draw AREA")
|
||||
else :
|
||||
print(namesForMunin["state." + stateName ] + ".draw STACK")
|
||||
print(namesForMunin["state." + stateName ] + ".type GAUGE")
|
||||
print(namesForMunin["state." + stateName ] + ".min 0")
|
||||
print(namesForMunin["state." + stateName ] + ".info Number of torrents in the '" + stateName + "' state")
|
||||
print(names_for_munin["state." + state_name] + ".draw AREA")
|
||||
else:
|
||||
print(names_for_munin["state." + state_name] + ".draw STACK")
|
||||
print(names_for_munin["state." + state_name] + ".type GAUGE")
|
||||
print(names_for_munin["state." + state_name] + ".min 0")
|
||||
print(names_for_munin["state." + state_name] +
|
||||
".info Number of torrents in the '" + state_name + "' state")
|
||||
|
||||
|
||||
def fetchInfo(mode) :
|
||||
def fetch_info(mode):
|
||||
log.debug("Launching tests")
|
||||
c = StatClient(conf, mode)
|
||||
c.fetchInfo()
|
||||
c.fetch_info()
|
||||
|
||||
|
||||
# Parse arguments
|
||||
if len(sys.argv) > 1 :
|
||||
if len(sys.argv) > 1:
|
||||
action = sys.argv[1]
|
||||
if action == "config" :
|
||||
printConfig(getMode())
|
||||
if action == "config":
|
||||
print_config(get_mode())
|
||||
sys.exit(0)
|
||||
elif action == "autoconf" :
|
||||
elif action == "autoconf":
|
||||
status, output = commands.getstatusoutput('which deluged')
|
||||
if status == 0 :
|
||||
if status == 0:
|
||||
print('yes')
|
||||
sys.exit(0)
|
||||
else :
|
||||
else:
|
||||
print('no (deluged not found)')
|
||||
sys.exit(1)
|
||||
elif action == "suggest" :
|
||||
for mode in modes :
|
||||
elif action == "suggest":
|
||||
for mode in modes:
|
||||
print(mode)
|
||||
sys.exit(0)
|
||||
elif action == "version" :
|
||||
print('Deluge Torrent Munin plugin, version {0}'.format(plugin_version))
|
||||
elif action == "version":
|
||||
print('Deluge Torrent Munin plugin, version {0}'.format(
|
||||
plugin_version))
|
||||
sys.exit(0)
|
||||
elif action != "" :
|
||||
elif action != "":
|
||||
log.warn("Unknown argument '{0}'".format(action))
|
||||
sys.exit(1)
|
||||
else :
|
||||
fetchInfo(getMode())
|
||||
else :
|
||||
fetchInfo(getMode())
|
||||
else:
|
||||
fetch_info(get_mode())
|
||||
else:
|
||||
fetch_info(get_mode())
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue