116 lines
3.5 KiB
Python
116 lines
3.5 KiB
Python
##
|
|
# Copyright 2007 Steve 'Tarka' Smith (tarka@internode.on.net)
|
|
# Distributed under the same terms as Deluge
|
|
##
|
|
|
|
plugin_name = "Blocklist Importer"
|
|
plugin_author = "Steve 'Tarka' Smith"
|
|
plugin_version = "0.3"
|
|
plugin_description = """
|
|
Downloads and import PeerGuardian blocklists.
|
|
|
|
It can parse uncompressed text-format list, and Gzip P2B version 1 and
|
|
2. It does not currently support 7zip encoded lists unfortunately.
|
|
It is suggested these are downloaded an unpacked via a cron script.
|
|
"""
|
|
|
|
def deluge_init(deluge_path):
|
|
global path
|
|
path = deluge_path
|
|
|
|
def enable(core, interface):
|
|
global path
|
|
return BlocklistImport(path, core, interface)
|
|
|
|
#################### The plugin itself ####################
|
|
|
|
import urllib, deluge.common, deluge.pref
|
|
from peerguardian import PGReader, PGException
|
|
from text import TextReader
|
|
from ui import GTKConfig, GTKProgress
|
|
|
|
# List of formats supported. This is used to generate the UI list and
|
|
# specify the reader class
|
|
readers = {'p2bgz':("PeerGuardian P2B (GZip)", PGReader),
|
|
'text':("PeerGuardian Text", TextReader)}
|
|
|
|
class BlocklistImport:
|
|
|
|
def __init__(self, path, core, interface):
|
|
print "Loading blocklist plugin ..."
|
|
# Save the path, interface, and core so they can be used later
|
|
self.path = path
|
|
self.core = core
|
|
self.interface = interface
|
|
self.gtkconf = GTKConfig(self)
|
|
self.gtkprog = GTKProgress(self)
|
|
self.cancelled = False
|
|
|
|
self.blockfile = deluge.common.CONFIG_DIR + "/blocklist.cache"
|
|
|
|
conffile = deluge.common.CONFIG_DIR + "/blocklist.conf"
|
|
self.config = deluge.pref.Preferences(filename=conffile,
|
|
global_defaults=False)
|
|
self.config.load()
|
|
|
|
if not self.config.has_key('url'):
|
|
self.configure()
|
|
else:
|
|
self.loadlist(fetch=self.config.get('load_on_start'))
|
|
|
|
|
|
def _download_update(self, curr, chunksize, size):
|
|
incs = float(size) / float(chunksize)
|
|
self.gtkprog.download_prog(curr/incs)
|
|
|
|
def loadlist(self, fetch=False):
|
|
# FIXME
|
|
self.gtkprog.start()
|
|
|
|
# Attempt initial import
|
|
if fetch:
|
|
print "Fetching",self.config.get('url')
|
|
self.gtkprog.start_download()
|
|
filename, headers = urllib.urlretrieve(self.config.get('url'),
|
|
filename=self.blockfile,
|
|
reporthook=self._download_update)
|
|
|
|
self.gtkprog.start_import()
|
|
|
|
self.core.reset_ip_filter()
|
|
#reader = PGReader(self.blockfile)
|
|
ltype = self.config.get('listtype')
|
|
print "importing with",ltype
|
|
reader = readers[ltype][1](self.blockfile)
|
|
|
|
ips = reader.next()
|
|
while ips and not self.cancelled:
|
|
self.core.add_range_to_ip_filter(*ips)
|
|
self.gtkprog.import_prog()
|
|
ips = reader.next()
|
|
|
|
reader.close()
|
|
self.gtkprog.end_import()
|
|
|
|
self.gtkprog.stop()
|
|
|
|
def configure(self):
|
|
self.gtkconf.start()
|
|
|
|
def setconfig(self, url, load_on_start, listtype):
|
|
self.config.set('url', url)
|
|
self.config.set('load_on_start', load_on_start)
|
|
self.config.set('listtype', listtype)
|
|
self.config.save()
|
|
|
|
self.loadlist(fetch=True)
|
|
|
|
def disable(self):
|
|
self.core.reset_ip_filter()
|
|
|
|
def unload(self):
|
|
self.core.reset_ip_filter()
|
|
|
|
def update(self):
|
|
pass
|