2
0
mirror of https://github.com/munin-monitoring/contrib.git synced 2018-11-08 00:59:34 +01:00
contrib-munin/plugins/torrent/deluge_
2018-03-27 05:04:12 +02:00

401 lines
13 KiB
Python
Executable File

#! /usr/bin/env python2
"""=cut
=head1 NAME
deluge_ - Munin wildcard plugin to monitor Deluge torrent client
=head1 REQUIREMENTS
- Python2.5+ (Deluge itself won't work with python3)
- Deluge
This plugin also uses
- deluge.ui.client
- deluge.log
- twisted
These modules are required by Deluge itself.
=head1 INSTALLATION
This plugin has 3 modes :
- connections : monitors the number of connections
- bandwidth : monitors the bandwidth (up, up overhead, down, down overhead)
- states : monitors the torrents' states
To use one of these modes, link the this plugin as 'deluge_<mode>'
For example :
ln -s /path/to/deluge_ /etc/munin/plugins/deluge_connections
=head1 CONFIGURATION
Use your "/etc/munin/plugin-conf.d/munin-node" to configure this plugin.
You must at least add :
[deluge_*]
user <user_with_access_to_deluge>
env.HOME <path_to_deluge_user_home>
By default, this plugin will try to access the deluge daemon with the following
settings :
host 127.0.0.1
port 58846
no username
no password
You can change these settings in "plugin-conf.d/munin-node" :
[deluge_*]
user <user_with_access_to_deluge>
env.HOME <path_to_deluge_user_home>
env.host 127.0.0.1
env.port 58846
env.username user
env.password pass
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.
=head1 INTERPRETATION
=head2 connections
In the "connections" mode, this plugin shows a graph with the number of
connections
=head2 bandwidth
In the "bandwidth" mode, this plugin show graphs for the download and upload
bandwidths.
Each of them has "payload" and "overhead" value.
- with positive values : the upload values
- with negative values : the download values
=head2 states
In the "states" mode, this plugin shows the number of torrents in each state :
Downloading, Seeding, Paused, Error, Queued, Checking, Other
=head1 MAGIC MARKERS
#%# family=auto
#%# capabilities=autoconf suggest
=head1 VERSION
1.0.0
=head1 AUTHOR
Neraud (https://github.com/Neraud)
=head1 LICENSE
GPLv2
=cut"""
from __future__ import print_function
import logging
import os
import string
import sys
try:
from deluge.log import setupLogger
from deluge.ui.client import client
from twisted.internet import reactor, defer
setupLogger()
except (ImportError, NameError):
successful_import = False
else:
successful_import = True
plugin_version = "1.0.0"
log = logging.getLogger("delugeStats")
log.setLevel(logging.WARNING)
conf = {
'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 = {
'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'
}
torrent_states = ["Downloading",
"Seeding",
"Paused",
"Error",
"Queued",
"Checking",
"Other"]
modes = ["bandwidth", "connections", "states"]
class StatClient:
def __init__(self, conf, mode):
self.conf = conf
self.mode = mode
self.connected = False
def end_session(self, msg):
log.debug("end_session : %s", msg)
if self.connected:
log.debug("Disconnecting")
client.disconnect()
reactor.stop()
def fetch_info(self):
log.debug("Connecting to %s:%d ...",
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 on_connect_success(self, result):
log.debug("Connection was successful")
self.connected = True
if self.mode == "connections":
log.debug("Calling get_num_connections")
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")
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.on_session_state,
self.end_session,
errbackArgs=("get_session_state failed"))
def on_num_connections(self, num_connections):
log.debug("Got num_connections from the daemon : %s", num_connections)
print("{0}.value {1}".format(
names_for_munin["numConnections"], num_connections))
self.end_session("Done")
def on_bandwidth(self, values):
log.debug("Got bandwidth info from the daemon : %s", values)
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(
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.end_session("Done")
def on_session_state(self, torrent_ids):
log.debug("Got session state from the daemon")
self.states = {}
for state_name in torrent_states:
self.states[state_name] = 0
deferred_list = []
for torrent_id in torrent_ids:
log.debug(" - TorrentId : %s", 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(deferred_list).addCallback(
self.on_all_torrent_info_fetched)
def on_one_torrent_info_failed(self, torrent_id):
log.debug("Failed fetching torrent info %s", torrent_id)
self.state["Error"] = self.state["Error"] + 1
def on_one_torrent_info(self, value, torrent_id):
log.debug("Got torrent info : %s -> %s", torrent_id, value)
state = value.get("state", "Error")
if state not in self.states:
log.warn("State '%s' is unknown !", state)
state = "Other"
self.states[state] += 1
def on_all_torrent_info_fetched(self, res):
log.debug("on_all_torrent_info_fetched : %s", 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 get_mode():
script_name = os.path.basename(sys.argv[0])
mode = script_name[string.rindex(script_name, '_') + 1:]
log.debug("Mode : %s", mode)
if mode not in modes:
log.error("Unknown mode '%s'", mode)
log.info("Available modes are : %s", modes)
sys.exit(1)
return mode
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 filetransfer")
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 payloadDownloadRate overheadDownloadRate payloadUploadRate "
"overheadUploadRate")
print("graph_args --base 1024 -r")
print("graph_vlabel bytes/s : down(-) and up(+)")
print("graph_scale yes")
print("graph_info This graph shows the bandwidth used by Deluge Torrent")
print("graph_category filetransfer")
print("graph_period second")
print("payloadDownloadRate.label payload")
print("payloadDownloadRate.draw AREA")
print("payloadDownloadRate.min 0")
print("payloadDownloadRate.graph no")
print("payloadDownloadRate.info Bandwidth used to download / upload torrents")
print("overheadDownloadRate.label overhead")
print("overheadDownloadRate.draw STACK")
print("overheadDownloadRate.min 0")
print("overheadDownloadRate.graph no")
print("overheadDownloadRate.info Bandwidth 'lost' due to overhead while downloading and "
"uploading torrents")
print("payloadUploadRate.label payload")
print("payloadUploadRate.draw AREA")
print("payloadUploadRate.min 0")
print("payloadUploadRate.negative payloadDownloadRate")
print("payloadUploadRate.info Bandwidth used to upload torrents")
print("overheadUploadRate.label overhead")
print("overheadUploadRate.draw STACK")
print("overheadUploadRate.min 0")
print("overheadUploadRate.negative overheadDownloadRate")
print("overheadUploadRate.info Bandwidth 'lost' due to overhead while downloading and "
"uploading torrents")
elif mode == "states":
print("graph_title Torrents states")
graph_order = " ".join(
[names_for_munin["state.{}".format(name)] for name in torrent_states])
print("graph_order " + graph_order)
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 filetransfer")
print("graph_period second")
for state_name in torrent_states:
print(names_for_munin["state." +
state_name] + ".label " + state_name)
print(names_for_munin["state." + state_name] + ".draw AREASTACK")
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 fetch_info(mode):
if not successful_import:
print('Missing imports, cannot run !', file=sys.stderr)
sys.exit(1)
log.debug("Launching tests")
c = StatClient(conf, mode)
c.fetch_info()
# Parse arguments
if len(sys.argv) > 1:
action = sys.argv[1]
if action == "config":
print_config(get_mode())
sys.exit(0)
elif action == "autoconf":
if not successful_import:
print('no (required modules not found)')
sys.exit(0)
print('yes')
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))
sys.exit(0)
elif action:
log.warn("Unknown argument '%s'", action)
sys.exit(1)
else:
fetch_info(get_mode())
else:
fetch_info(get_mode())