Mirrors/Munin-Contrib
1
0
Fork 0
mirror of https://github.com/munin-monitoring/contrib.git synced 2025-07-26 10:58:12 +00:00
Code Issues Releases Wiki Activity

Format code according to PEP0008

Browse source
This commit is contained in:
Neraud 2017-07-18 07:36:17 +02:00
parent 0f88253361
commit 5fd233c510
1 changed files with 303 additions and 263 deletions
Download patch file Download diff file Expand all files Collapse all files

486
plugins/torrent/deluge_
View file

@ -13,24 +13,24 @@
# #
# Use your "/etc/munin/plugin-conf.d/munin-node" to configure this plugin. # Use your "/etc/munin/plugin-conf.d/munin-node" to configure this plugin.
# You must at least add : # You must at least add :
# [deluge_*] # [deluge_*]
# user <user_with_access_to_deluge> # user <user_with_access_to_deluge>
# env.HOME <path_to_deluge_user_home> # env.HOME <path_to_deluge_user_home>
# #
# By default, this plugin will try to access the deluge daemon with the following configuration : # By default, this plugin will try to access the deluge daemon with the following configuration :
# host 127.0.0.1 # host 127.0.0.1
# port 58846 # port 58846
# no username # no username
# no password # no password
# #
# You can change these settings in "plugin-conf.d/munin-node" : # You can change these settings in "plugin-conf.d/munin-node" :
# [deluge_*] # [deluge_*]
# user <user_with_access_to_deluge> # user <user_with_access_to_deluge>
# env.HOME <path_to_deluge_user_home> # env.HOME <path_to_deluge_user_home>
# env.host 127.0.0.1 # env.host 127.0.0.1
# env.port 58846 # env.port 58846
# env.username user # env.username user
# env.password pass # env.password pass
# #
# By default, deluge configuration files will be searched under $XDG_CONFIG_HOME, which is by default set to $HOME/.config # By default, deluge configuration files will be searched under $XDG_CONFIG_HOME, which is by default set to $HOME/.config
# Setting env.HOME allows this default to work. However, you can also explicitly set the env.XDG_CONFIG_HOME if needed. # Setting env.HOME allows this default to work. However, you can also explicitly set the env.XDG_CONFIG_HOME if needed.
@ -38,267 +38,307 @@
# Written by : Neraud # Written by : Neraud
# #
# Markers for munin : # Markers for munin :
#%# family=auto # %# family=auto
#%# capabilities=autoconf suggest # %# capabilities=autoconf suggest
########################################## ##########################################
import logging, commands, sys, os, string import commands
from twisted.internet import reactor, defer
from deluge.ui.client import client
from deluge.log import setupLogger 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() setupLogger()
plugin_version = "1.0.0" plugin_version = "1.0.0"
# create logger
log = logging.getLogger("delugeStats") log = logging.getLogger("delugeStats")
log.setLevel(logging.WARNING) log.setLevel(logging.WARNING)
# Deluge daemon Confs
conf = { conf = {
'host' : os.getenv('host', '127.0.0.1'), 'host': os.getenv('host', '127.0.0.1'),
'port' : int(os.getenv('port', '58846')), 'port': int(os.getenv('port', '58846')),
'username' : os.getenv('username', ''), 'username': os.getenv('username', ''),
'password' : os.getenv('password', '') 'password': os.getenv('password', '')
} }
# names for munin : names_for_munin = {
namesForMunin = { 'numConnections': 'numConnections',
'numConnections' : 'numConnections', 'payloadUploadRate': 'payloadUploadRate',
'payloadUploadRate' : 'payloadUploadRate', 'overheadUploadRate': 'overheadUploadRate',
'overheadUploadRate' : 'overheadUploadRate', 'payloadDownloadRate': 'payloadDownloadRate',
'payloadDownloadRate' : 'payloadDownloadRate', 'overheadDownloadRate': 'overheadDownloadRate',
'overheadDownloadRate' : 'overheadDownloadRate', 'state.Seeding': 'seeding',
'state.Seeding' : 'seeding', 'state.Downloading': 'downloading',
'state.Downloading' : 'downloading', 'state.Paused': 'paused',
'state.Paused' : 'paused', 'state.Error': 'error',
'state.Error' : 'error', 'state.Queued': 'queued',
'state.Queued' : 'queued', 'state.Checking': 'checking',
'state.Checking' : 'checking', 'state.Other': 'other'
'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: class StatClient:
def __init__(self, conf, mode) : def __init__(self, conf, mode):
self.conf = conf self.conf = conf
self.mode = mode self.mode = mode
self.connected = False self.connected = False
def endSession(self, msg): def end_session(self, msg):
log.debug("endSession : {0}".format(msg)) log.debug("end_session : {0}".format(msg))
if self.connected: if self.connected:
log.debug("Disconnecting") log.debug("Disconnecting")
client.disconnect() client.disconnect()
reactor.stop() reactor.stop()
def fetchInfo(self): def fetch_info(self):
log.debug("Connecting to {0}:{1} ...".format(self.conf['host'], self.conf['port'])) log.debug("Connecting to {0}:{1} ...".format(
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.")) self.conf['host'], self.conf['port']))
reactor.run() 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") log.debug("Connection was successful")
self.connected = True self.connected = True
if self.mode == "connections" : if self.mode == "connections":
log.debug("Calling get_num_connections") log.debug("Calling get_num_connections")
client.core.get_num_connections().addCallbacks(self.onNumConnections, self.endSession, errbackArgs=("get_num_connections failed")) client.core.get_num_connections().addCallbacks(
elif self.mode == "bandwidth" : self.on_num_connections,
log.debug("Calling get_session_status") self.end_session, errbackArgs=("get_num_connections failed"))
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 == "bandwidth":
elif self.mode == "states" : log.debug("Calling get_session_status")
log.debug("Calling get_session_state") interesting_status = [
client.core.get_session_state().addCallbacks(self.onSessionState, self.endSession, errbackArgs=("get_session_state failed")) '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.on_session_state,
self.end_session,
errbackArgs=("get_session_state failed"))
def onNumConnections(self, num_connections): def on_num_connections(self, num_connections):
log.debug("Got num_connections from the daemon : {0}".format(str(num_connections))) log.debug("Got num_connections from the daemon : {0}".format(
print "{0}.value {1}".format(namesForMunin["numConnections"], num_connections) str(num_connections)))
self.endSession("Done") print "{0}.value {1}".format(
names_for_munin["numConnections"], num_connections)
self.end_session("Done")
def onBandwidth(self, values): def on_bandwidth(self, values):
log.debug("Got bandwith info from the daemon : {0}".format(str(values))) log.debug(
"Got bandwidth info from the daemon : {0}".format(str(values)))
downloadRate = values['download_rate'] download_rate = values['download_rate']
payloadDownloadRate = values['payload_download_rate'] payload_download_rate = values['payload_download_rate']
overheadDownloadRate = downloadRate - payloadDownloadRate overhead_download_rate = download_rate - payload_download_rate
uploadRate = values['upload_rate'] upload_rate = values['upload_rate']
payloadUploadRate = values['payload_upload_rate'] payload_upload_rate = values['payload_upload_rate']
overheadUploadRate = uploadRate - payloadUploadRate overhead_upload_rate = upload_rate - payload_upload_rate
print "{0}.value {1}".format(namesForMunin["payloadDownloadRate"], payloadDownloadRate) print "{0}.value {1}".format(
print "{0}.value {1}".format(namesForMunin["overheadDownloadRate"], overheadDownloadRate) names_for_munin["payloadDownloadRate"], payload_download_rate)
print "{0}.value {1}".format(namesForMunin["payloadUploadRate"], payloadUploadRate) print "{0}.value {1}".format(
print "{0}.value {1}".format(namesForMunin["overheadUploadRate"], overheadUploadRate) 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") log.debug("Got session state from the daemon")
self.states = { } self.states = {}
for stateName in torrentStates : for state_name in torrent_states:
self.states[stateName] = 0 self.states[state_name] = 0
#self.states={'Seeding': 0, 'Downloading': 0, 'Paused': 0, 'Error': 0, 'Queued': 0, 'Checking': 0, 'Other' : 0}
deferredList = [] deferred_list = []
for torrentId in torrentIds: for torrent_id in torrent_ids:
log.debug(" - TorrentId : {0}".format(torrentId)) log.debug(" - TorrentId : {0}".format(torrent_id))
d = client.core.get_torrent_status(torrentId, ['state']) d = client.core.get_torrent_status(torrent_id, ['state'])
d.addCallback(self.onOneTorrentInfo, torrentId) d.addCallback(self.on_one_torrent_info, torrent_id)
d.addErrback(self.onOneTorrentInfoFailed, torrentId) d.addErrback(self.on_one_torrent_info_failed, torrent_id)
deferredList.append(d) 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): def on_one_torrent_info_failed(self, torrent_id):
log.debug("Failed fetching torrent info {0}".format(torrentId)) log.debug("Failed fetching torrent info {0}".format(torrent_id))
self.state["Error"] = self.state["Error"] + 1; self.state["Error"] = self.state["Error"] + 1
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):
log.warn("State '{0}' is unknown !".format(state))
state = "Other"
self.states[state] = self.states[state] + 1
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(
names_for_munin["state." + state], self.states[state])
self.end_session("Done")
def onOneTorrentInfo(self, value, torrentId): def get_mode():
log.debug("Got torrent info : {0} -> {1}".format(torrentId, value)) script_name = list(os.path.split(sys.argv[0]))[1]
if 'state' in value: mode = script_name[string.rindex(script_name, '_') + 1:]
state = value['state']
else:
state = "Error"
if not (state in self.states) : log.debug("Mode : {0}".format(str(mode)))
log.warn("State '{0}' is unknown !".format(state))
state = "Other"
self.states[state] = self.states[state] + 1 if not mode in modes:
log.error("Unknown mode '{0}'".format(mode))
log.info("Available modes are : {0}".format(str(modes)))
sys.exit(1)
def onAllTorrentInfoFetched(self, res): return mode
log.debug("onAllTorrentInfoFetched : {0}".format(str(self.states)))
for state in self.states:
print "{0}.value {1}".format(namesForMunin["state." + state], self.states[state])
self.endSession("Done")
def getMode() : def print_config(mode):
scriptName = list(os.path.split(sys.argv[0]))[1] if mode == "connections":
mode = scriptName[string.rindex(scriptName,'_')+1:] 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(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")
print("graph_vlabel octet/s : down(+) and up(-)")
print("graph_scale yes")
print("graph_info This graph shows the bandwidth used by Deluge Torrent")
print("graph_category deluge")
print("graph_period second")
log.debug("Mode : {0}".format(str(mode))) print("payloadUploadRate.label payload")
print("payloadUploadRate.draw AREA")
print("payloadUploadRate.min 0")
# print("payloadUploadRate.info Bandwidth used to upload torrents")
if not mode in modes : print("payloadDownloadRate.label payload")
log.error("Unknown mode '{0}'".format(mode)) print("payloadDownloadRate.draw AREA")
log.info("Available modes are : {0}".format(str(modes))) print("payloadDownloadRate.min 0")
sys.exit(1) print("payloadDownloadRate.negative payloadUploadRate")
print("payloadDownloadRate.info Bandwidth used to download / upload torrents")
return 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")
def printConfig(mode) : print("overheadDownloadRate.label overhead")
if mode == "connections" : print("overheadDownloadRate.draw STACK")
print("graph_title Number of connections") print("overheadDownloadRate.min 0")
print("graph_args --base 1000 -l 0") print("overheadDownloadRate.negative overheadUploadRate")
print("graph_vlabel connections") print("overheadDownloadRate.info Bandwidth 'lost' due to overhead while downloading and uploading torrents")
print("graph_scale yes") elif mode == "states":
print("graph_category deluge") print("graph_title Torrents states")
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_title Bandwidth usage")
print("graph_order payloadUploadRate payloadDownloadRate overheadUploadRate overheadDownloadRate")
print("graph_args --base 1024 -r")
print("graph_vlabel octet/s : down(+) and up(-)")
print("graph_scale yes")
print("graph_info This graph shows the bandwidth used by Deluge Torrent")
print("graph_category deluge")
print("graph_period second")
print("payloadUploadRate.label payload") graph_order = ""
print("payloadUploadRate.draw AREA") for state_name in torrent_states:
print("payloadUploadRate.min 0") graph_order += names_for_munin["state." + state_name] + " "
#print("payloadUploadRate.info Bandwidth used to upload torrents")
print("payloadDownloadRate.label payload") print("graph_order " + graph_order)
print("payloadDownloadRate.draw AREA") print("graph_args --base 1000 -r --lower-limit 0")
print("payloadDownloadRate.min 0") print("graph_vlabel number of torrents")
print("payloadDownloadRate.negative payloadUploadRate") print("graph_scale yes")
print("payloadDownloadRate.info Bandwidth used to download / upload torrents") print("graph_info This graph shows the states of the torrents in Deluge Torrent")
print("graph_category deluge")
print("graph_period second")
print("overheadUploadRate.label overhead") first = True
print("overheadUploadRate.draw STACK") for state_name in torrent_states:
print("overheadUploadRate.min 0") print(names_for_munin["state." +
#print("overheadUploadRate.info Bandwidth 'lost' due to overhead while downloading and uploading torrents") state_name] + ".label " + state_name)
if first:
print("overheadDownloadRate.label overhead") first = False
print("overheadDownloadRate.draw STACK") print(names_for_munin["state." + state_name] + ".draw AREA")
print("overheadDownloadRate.min 0") else:
print("overheadDownloadRate.negative overheadUploadRate") print(names_for_munin["state." + state_name] + ".draw STACK")
print("overheadDownloadRate.info Bandwidth 'lost' due to overhead while downloading and uploading torrents") print(names_for_munin["state." + state_name] + ".type GAUGE")
elif mode == "states" : print(names_for_munin["state." + state_name] + ".min 0")
print("graph_title Torrents states") print(names_for_munin["state." + state_name] +
".info Number of torrents in the '" + state_name + "' state")
graphOrder = ""
for stateName in torrentStates :
graphOrder += namesForMunin["state." + stateName] + " "
print("graph_order " + graphOrder)
print("graph_args --base 1000 -r --lower-limit 0")
print("graph_vlabel number of torrents")
print("graph_scale yes")
print("graph_info This graph shows the states of the torrents in Deluge Torrent")
print("graph_category deluge")
print("graph_period second")
first = True
for stateName in torrentStates :
print(namesForMunin["state." + stateName ] + ".label " + stateName)
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")
def fetchInfo(mode) : def fetch_info(mode):
log.debug("Launching tests") log.debug("Launching tests")
c = StatClient(conf, mode) c = StatClient(conf, mode)
c.fetchInfo() c.fetch_info()
# Parse arguments # Parse arguments
if len(sys.argv) > 1 : if len(sys.argv) > 1:
action = sys.argv[1] action = sys.argv[1]
if action == "config" : if action == "config":
printConfig(getMode()) print_config(get_mode())
sys.exit(0) sys.exit(0)
elif action == "autoconf" : elif action == "autoconf":
status, output = commands.getstatusoutput('which deluged') status, output = commands.getstatusoutput('which deluged')
if status == 0 : if status == 0:
print('yes') print('yes')
sys.exit(0) sys.exit(0)
else : else:
print('no (deluged not found)') print('no (deluged not found)')
sys.exit(1) sys.exit(1)
elif action == "suggest" : elif action == "suggest":
for mode in modes : for mode in modes:
print(mode) print(mode)
sys.exit(0) sys.exit(0)
elif action == "version" : elif action == "version":
print('Deluge Torrent Munin plugin, version {0}'.format(plugin_version)) print('Deluge Torrent Munin plugin, version {0}'.format(
sys.exit(0) plugin_version))
elif action != "" : sys.exit(0)
log.warn("Unknown argument '{0}'".format(action)) elif action != "":
sys.exit(1) log.warn("Unknown argument '{0}'".format(action))
else : sys.exit(1)
fetchInfo(getMode()) else:
else : fetch_info(get_mode())
fetchInfo(getMode()) else:
fetch_info(get_mode())