Remove broken blocklist plugin
This commit is contained in:
Andrew Resch
parent
f68d4a7896
commit
8d27c4e349
|
|
@ -1,66 +0,0 @@
|
|||
#
|
||||
# blocklist/__init__.py
|
||||
#
|
||||
# Copyright (C) 2007 Andrew Resch ('andar') <andrewresch@gmail.com>
|
||||
# Copyright (C) 2008 Mark Stahler ('kramed') <markstahler@gmail.com>
|
||||
|
||||
#
|
||||
# Deluge is free software.
|
||||
#
|
||||
# You may redistribute it and/or modify it under the terms of the
|
||||
# GNU General Public License, as published by the Free Software
|
||||
# Foundation; either version 2 of the License, or (at your option)
|
||||
# any later version.
|
||||
#
|
||||
# deluge is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
# See the GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with deluge. If not, write to:
|
||||
# The Free Software Foundation, Inc.,
|
||||
# 51 Franklin Street, Fifth Floor
|
||||
# Boston, MA 02110-1301, USA.
|
||||
#
|
||||
# In addition, as a special exception, the copyright holders give
|
||||
# permission to link the code of portions of this program with the OpenSSL
|
||||
# library.
|
||||
# You must obey the GNU General Public License in all respects for all of
|
||||
# the code used other than OpenSSL. If you modify file(s) with this
|
||||
# exception, you may extend this exception to your version of the file(s),
|
||||
# but you are not obligated to do so. If you do not wish to do so, delete
|
||||
# this exception statement from your version. If you delete this exception
|
||||
# statement from all source files in the program, then also delete it here.
|
||||
|
||||
from deluge.log import LOG as log
|
||||
|
||||
from deluge.plugins.init import PluginBase
|
||||
|
||||
class CorePlugin(PluginBase):
|
||||
def __init__(self, plugin_api, plugin_name):
|
||||
# Load the Core portion of the plugin
|
||||
try:
|
||||
from core import Core
|
||||
self.plugin = Core(plugin_api, plugin_name)
|
||||
except Exception, e:
|
||||
log.debug("Did not load a Core plugin: %s", e)
|
||||
|
||||
class GtkUIPlugin(PluginBase):
|
||||
def __init__(self, plugin_api, plugin_name):
|
||||
# Load the GtkUI portion of the plugin
|
||||
try:
|
||||
from gtkui import GtkUI
|
||||
self.plugin = GtkUI(plugin_api, plugin_name)
|
||||
except Exception, e:
|
||||
log.debug("Did not load a GtkUI plugin: %s", e)
|
||||
|
||||
class WebUIPlugin(PluginBase):
|
||||
def __init__(self, plugin_api, plugin_name):
|
||||
# Load the GtkUI portion of the plugin
|
||||
try:
|
||||
from webui import WebUI
|
||||
self.plugin = WebUI(plugin_api, plugin_name)
|
||||
except Exception, e:
|
||||
log.debug("Did not load a WebUI plugin: %s", e)
|
||||
|
||||
|
|
@ -1,130 +0,0 @@
|
|||
#
|
||||
# blocklist/core.py
|
||||
#
|
||||
# Copyright (C) 2007 Andrew Resch ('andar') <andrewresch@gmail.com>
|
||||
# Copyright (C) 2008 Mark Stahler ('kramed') <markstahler@gmail.com>
|
||||
|
||||
#
|
||||
# Deluge is free software.
|
||||
#
|
||||
# You may redistribute it and/or modify it under the terms of the
|
||||
# GNU General Public License, as published by the Free Software
|
||||
# Foundation; either version 2 of the License, or (at your option)
|
||||
# any later version.
|
||||
#
|
||||
# deluge is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
# See the GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with deluge. If not, write to:
|
||||
# The Free Software Foundation, Inc.,
|
||||
# 51 Franklin Street, Fifth Floor
|
||||
# Boston, MA 02110-1301, USA.
|
||||
#
|
||||
# In addition, as a special exception, the copyright holders give
|
||||
# permission to link the code of portions of this program with the OpenSSL
|
||||
# library.
|
||||
# You must obey the GNU General Public License in all respects for all of
|
||||
# the code used other than OpenSSL. If you modify file(s) with this
|
||||
# exception, you may extend this exception to your version of the file(s),
|
||||
# but you are not obligated to do so. If you do not wish to do so, delete
|
||||
# this exception statement from your version. If you delete this exception
|
||||
# statement from all source files in the program, then also delete it here.
|
||||
|
||||
from torrentblocklist import TorrentBlockList
|
||||
from deluge.log import LOG as log
|
||||
from deluge.plugins.corepluginbase import CorePluginBase
|
||||
|
||||
class Core(CorePluginBase):
|
||||
def enable(self):
|
||||
self.blocklist = TorrentBlockList(self.plugin)
|
||||
self.plugin.register_hook("post_session_load", self._post_session_load)
|
||||
log.debug('Blocklist: Plugin enabled..')
|
||||
|
||||
def disable(self):
|
||||
log.debug('Blocklist: Plugin disabled')
|
||||
self.plugin.deregister_hook("post_session_load", self._post_session_load)
|
||||
self.plugin.reset_ip_filter()
|
||||
# Delete the blocklist object
|
||||
del self.blocklist
|
||||
self.blocklist = None
|
||||
|
||||
def update(self):
|
||||
pass
|
||||
|
||||
## Hooks for core ##
|
||||
def _post_session_load(self):
|
||||
log.info('Blocklist: Session load hook caught')
|
||||
if self.blocklist.load_on_start == True:
|
||||
# Wait until an idle time to load block list
|
||||
import gobject
|
||||
gobject.idle_add(self.blocklist.import_list)
|
||||
|
||||
## Callbacks
|
||||
def register_import_hook(self):
|
||||
self.plugin.register_hook("post_session_load", self._post_session_load)
|
||||
return False
|
||||
|
||||
# Exported functions for ui
|
||||
def export_critical_setting(self):
|
||||
if self.blocklist.old_url != self.blocklist.url or self.blocklist.old_listtype != self.blocklist.listtype:
|
||||
log.info('Blocklist: Critical setting changed')
|
||||
self.blocklist.download()
|
||||
self.blocklist.import_list()
|
||||
self.blocklist.return_count() # Return count after import
|
||||
|
||||
# New settings are now old settings
|
||||
self.blocklist.old_url = self.blocklist.url
|
||||
self.blocklist.old_listtype = self.blocklist.listtype
|
||||
|
||||
def export_count_ips(self):
|
||||
log.debug('Blocklist: Count IPs imported into blocklist')
|
||||
return self.blocklist.return_count()
|
||||
|
||||
def export_import_list(self):
|
||||
log.debug('Blocklist: Import started from GTK UI')
|
||||
self.blocklist.import_list()
|
||||
|
||||
def export_download_list(self):
|
||||
log.debug('Blocklist: Download started from GTK UI')
|
||||
force_check = True
|
||||
self.blocklist.check_update(force_check)
|
||||
# Initialize download attempt
|
||||
self.blocklist.attempt = 0
|
||||
|
||||
if self.blocklist.fetch == True:
|
||||
self.blocklist.download()
|
||||
|
||||
|
||||
def export_set_options(self, settings):
|
||||
log.debug("Blocklist: Set Options")
|
||||
self.blocklist.set_options(settings)
|
||||
|
||||
def export_get_options(self):
|
||||
log.debug("Blocklist: Get Options")
|
||||
settings_dict = {
|
||||
"url": self.blocklist.url,
|
||||
"listtype": self.blocklist.listtype,
|
||||
"check_after_days": self.blocklist.check_after_days,
|
||||
"load_on_start":self.blocklist.load_on_start,
|
||||
"try_times": self.blocklist.try_times,
|
||||
"timeout": self.blocklist.timeout
|
||||
}
|
||||
log.info(settings_dict)
|
||||
return settings_dict
|
||||
|
||||
def export_get_config_value(self, key):
|
||||
log.debug("Blocklist: Get configuration setting")
|
||||
return self.blocklist.get_config_value(key)
|
||||
|
||||
def export_set_config_value(self, key):
|
||||
log.debug("Blocklist: Set configuration setting")
|
||||
return self.blocklist.set_config_value(key)
|
||||
|
||||
def export_get_formats(self):
|
||||
log.debug('Blocklist: Get Reader Formats')
|
||||
return self.blocklist.return_formats()
|
||||
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 705 B |
Binary file not shown.
|
Before Width: | Height: | Size: 926 B |
Binary file not shown.
|
Before Width: | Height: | Size: 1.2 KiB |
|
|
@ -1,324 +0,0 @@
|
|||
#
|
||||
# blocklist/gtkui.py
|
||||
#
|
||||
# Copyright (C) 2007 Andrew Resch ('andar') <andrewresch@gmail.com>
|
||||
# Copyright (C) 2008 Mark Stahler ('kramed') <markstahler@gmail.com>
|
||||
|
||||
#
|
||||
# Deluge is free software.
|
||||
#
|
||||
# You may redistribute it and/or modify it under the terms of the
|
||||
# GNU General Public License, as published by the Free Software
|
||||
# Foundation; either version 2 of the License, or (at your option)
|
||||
# any later version.
|
||||
#
|
||||
# deluge is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
# See the GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with deluge. If not, write to:
|
||||
# The Free Software Foundation, Inc.,
|
||||
# 51 Franklin Street, Fifth Floor
|
||||
# Boston, MA 02110-1301, USA.
|
||||
#
|
||||
# In addition, as a special exception, the copyright holders give
|
||||
# permission to link the code of portions of this program with the OpenSSL
|
||||
# library.
|
||||
# You must obey the GNU General Public License in all respects for all of
|
||||
# the code used other than OpenSSL. If you modify file(s) with this
|
||||
# exception, you may extend this exception to your version of the file(s),
|
||||
# but you are not obligated to do so. If you do not wish to do so, delete
|
||||
# this exception statement from your version. If you delete this exception
|
||||
# statement from all source files in the program, then also delete it here.
|
||||
|
||||
import os
|
||||
import pkg_resources # access plugin egg
|
||||
from deluge.log import LOG as log
|
||||
import deluge.component # for systray
|
||||
import ui
|
||||
import gtk, gobject
|
||||
|
||||
FORMATS = {
|
||||
'gzmule': ["Emule IP list (GZip)", None],
|
||||
'spzip': ["SafePeer Text (Zipped)", None],
|
||||
'pgtext': ["PeerGuardian Text (Uncompressed)", None],
|
||||
'p2bgz': ["PeerGuardian P2B (GZip)", None]
|
||||
}
|
||||
|
||||
class GtkUI(ui.UI):
|
||||
def __init__(self, plugin_api, plugin_name):
|
||||
log.debug("Calling UI init")
|
||||
# Call UI constructor
|
||||
ui.UI.__init__(self, plugin_api, plugin_name)
|
||||
log.debug("Blocklist GtkUI plugin initalized..")
|
||||
|
||||
def enable(self):
|
||||
self.plugin.register_hook("on_apply_prefs", self.apply_prefs)
|
||||
|
||||
# Import File Format Readers from TorrentBlocklist
|
||||
#ui.client.block_list_get_formats(self.callback_load_formats) # cant marshal classobj objects - wtf
|
||||
|
||||
# Update Blocked IP status bar number - BETTER METHOD TO FOLLOW
|
||||
# emit a blocklsit import signal
|
||||
gobject.timeout_add(5000, self.get_ip_count)
|
||||
gobject.timeout_add(10000, self.get_ip_count)
|
||||
gobject.timeout_add(20000, self.get_ip_count)
|
||||
|
||||
self.load_interface()
|
||||
|
||||
def disable(self):
|
||||
deluge.component.get("StatusBar").remove_item(self.blocklist_status)
|
||||
self.plugin.deregister_hook("on_apply_prefs", self.apply_prefs)
|
||||
self.plugin.remove_preferences_page("Blocklist")
|
||||
|
||||
def get_pixmap(self, fname):
|
||||
"""Returns a pixmap file included with plugin"""
|
||||
return pkg_resources.resource_filename("blocklist", os.path.join("data", fname))
|
||||
|
||||
def add_status_icon(self, ip_count):
|
||||
try:
|
||||
deluge.component.get("StatusBar").remove_item(self.blocklist_status)
|
||||
except:
|
||||
pass
|
||||
# self, image=None, stock=None, text=None, callback=None
|
||||
self.blocklist_status = deluge.component.get("StatusBar").add_item(self.get_pixmap("blocklist16.png"), None, str(ip_count) + " Blocked IP Ranges ", None)
|
||||
|
||||
def get_ip_count(self):
|
||||
ui.client.block_list_count_ips(self.add_status_icon)
|
||||
return False
|
||||
|
||||
def start_import(self, widget, data=None):
|
||||
ui.client.block_list_import_list(None)
|
||||
log.debug('Blocklist: Import button')
|
||||
gobject.timeout_add(20000, self.get_ip_count)
|
||||
|
||||
def download_list(self, widget, data=None):
|
||||
self.apply_prefs()
|
||||
ui.client.block_list_download_list(None)
|
||||
log.debug('Blocklist: Download button')
|
||||
|
||||
def unload_interface(self):
|
||||
self.plugin.remove_preferences_page("Blocklist")
|
||||
|
||||
# def get_active_text(combobox):
|
||||
# model = combobox.get_model()
|
||||
# active = combobox.get_active()
|
||||
# if active < 0:
|
||||
# return None
|
||||
# return model[active][0]
|
||||
|
||||
def load_interface(self):
|
||||
log.debug("Beginning gtk pane initialization")
|
||||
self.blocklist_pref_page = gtk.VBox(False, 3)
|
||||
self.blocklist_pref_page.set_spacing(6)
|
||||
|
||||
label = gtk.Label()
|
||||
label.set_markup('<b>' + 'General' + '</b>')
|
||||
|
||||
frame = gtk.Frame()
|
||||
frame.set_shadow_type(gtk.SHADOW_NONE)
|
||||
|
||||
alignment = gtk.Alignment(0.5, 0.5, 1, 1)
|
||||
alignment.set_padding(8, 5, 5, 5)
|
||||
|
||||
table = gtk.Table(8, 2, False)
|
||||
table.set_col_spacings(8)
|
||||
table.set_row_spacings(10)
|
||||
|
||||
# First row
|
||||
label0 = gtk.Label()
|
||||
label0.set_text('Blocklist Type')
|
||||
|
||||
ls = gtk.ListStore(gobject.TYPE_STRING, # Long name
|
||||
gobject.TYPE_STRING) # Short name
|
||||
|
||||
self.listtype = gtk.ComboBox(model=ls)
|
||||
cell = gtk.CellRendererText()
|
||||
cell.set_property('xpad', 5) # padding for status text
|
||||
self.listtype.pack_start(cell, False)
|
||||
self.listtype.add_attribute(cell, 'text', 0)
|
||||
|
||||
for k in FORMATS.keys():
|
||||
i = ls.append([FORMATS[k][0], k])
|
||||
FORMATS[k][1] = ls.get_path(i)
|
||||
|
||||
self.listtype.set_active(0)
|
||||
|
||||
table.attach(label0, 0, 1, 0 , 1)
|
||||
table.attach(self.listtype, 1, 2, 0, 1)
|
||||
|
||||
# Second row
|
||||
label1 = gtk.Label()
|
||||
label1.set_text('Blocklist URL')
|
||||
|
||||
self.url = gtk.Entry()
|
||||
|
||||
table.attach(label1, 0, 1, 1, 2)
|
||||
table.attach(self.url, 1, 2, 1, 2)
|
||||
|
||||
# Third row
|
||||
label2 = gtk.Label()
|
||||
label2.set_text('Check for a new blocklist every')
|
||||
|
||||
self.check_after_days = gtk.SpinButton(None, 1.0, 0)
|
||||
self.check_after_days.set_increments(1, 3)
|
||||
self.check_after_days.set_range(-1, 14)
|
||||
|
||||
label3 = gtk.Label()
|
||||
label3.set_text('days')
|
||||
|
||||
hbox = gtk.HBox(False, 3)
|
||||
hbox.pack_start(label2, False, True)
|
||||
hbox.pack_start(self.check_after_days, False, False, 4)
|
||||
hbox.pack_start(label3)
|
||||
|
||||
alignment.add(table)
|
||||
table.attach(hbox, 0, 2, 2, 3)
|
||||
|
||||
# Fourth row
|
||||
label4 = gtk.Label()
|
||||
label4.set_text('Timeout to download new blocklist')
|
||||
|
||||
self.timeout = gtk.SpinButton(None, 5.0, 0)
|
||||
self.timeout.set_increments(5, 20)
|
||||
self.timeout.set_range(15, 360)
|
||||
|
||||
label5 = gtk.Label()
|
||||
label5.set_text('seconds')
|
||||
|
||||
hbox1 = gtk.HBox(False, 3)
|
||||
hbox1.pack_start(label4, False, True)
|
||||
hbox1.pack_start(self.timeout)
|
||||
hbox1.pack_start(label5, False, True)
|
||||
|
||||
table.attach(hbox1, 0, 2, 3, 4)
|
||||
|
||||
# Fifth row
|
||||
label5 = gtk.Label()
|
||||
label5.set_text('Times to attempt download of new list')
|
||||
|
||||
self.try_times = gtk.SpinButton(None, 1.0, 0)
|
||||
self.try_times.set_increments(1, 2)
|
||||
self.try_times.set_range(1, 5)
|
||||
|
||||
hbox2 = gtk.HBox(False, 3)
|
||||
hbox2.pack_start(label5, False, True)
|
||||
hbox2.pack_start(self.try_times)
|
||||
|
||||
table.attach(hbox2, 0, 2, 4, 5)
|
||||
|
||||
# sixth row
|
||||
self.load_on_start = gtk.CheckButton('Import blocklist on daemon startup')
|
||||
table.attach(self.load_on_start, 0, 2, 5, 6)
|
||||
|
||||
# download new list button
|
||||
download_button = gtk.Button("_Download Blocklist", None, True)
|
||||
download_button.connect("clicked", self.download_list, None)
|
||||
|
||||
pixbuf = gtk.gdk.pixbuf_new_from_file(self.get_pixmap("blocklist_download24.png"))
|
||||
image = gtk.image_new_from_pixbuf(pixbuf)
|
||||
download_button.set_image(image)
|
||||
table.attach(download_button, 0, 2, 6, 7)
|
||||
|
||||
# import button (Check and possibly download)
|
||||
import_button = gtk.Button("_Import Blocklist", None, True)
|
||||
import_button.connect("clicked", self.start_import, None)
|
||||
|
||||
pixbuf = gtk.gdk.pixbuf_new_from_file(self.get_pixmap("blocklist_import24.png"))
|
||||
image = gtk.image_new_from_pixbuf(pixbuf)
|
||||
import_button.set_image(image)
|
||||
|
||||
table.attach(import_button, 0, 2, 7, 8)
|
||||
|
||||
|
||||
# finish frame
|
||||
frame.set_label_widget(label)
|
||||
frame.add(alignment)
|
||||
|
||||
self.blocklist_pref_page.pack_start(frame)
|
||||
|
||||
# Add preferences page to preferences page
|
||||
log.debug('Adding Blocklist Preferences page')
|
||||
self.plugin.add_preferences_page("Blocklist", self.blocklist_pref_page)
|
||||
|
||||
# Load settings from config and fill widgets with settings
|
||||
log.debug('Starting to load blocklist preferences')
|
||||
self.fetch_prefs()
|
||||
log.debug('Finished loading blocklist preferences')
|
||||
|
||||
|
||||
def fetch_prefs(self): # Fetch settings dictionary from plugin core and pass it to GTK ui settings
|
||||
log.info('Blocklist: Fetching and loading Preferences via GTK ui')
|
||||
ui.client.block_list_get_options(self.callback_load_prefs)
|
||||
|
||||
def apply_prefs(self):
|
||||
log.info('Blocklist: Preferences saved via Gtk ui')
|
||||
settings_dict = {
|
||||
"url": self.url.get_text(),
|
||||
"listtype": self.get_ltype(),
|
||||
"check_after_days": self.check_after_days.get_value_as_int(),
|
||||
"load_on_start":self.load_on_start.get_active(),
|
||||
"try_times": self.try_times.get_value_as_int(),
|
||||
"timeout": self.timeout.get_value_as_int()
|
||||
}
|
||||
ui.client.block_list_set_options(None, settings_dict)
|
||||
# Needs to go in another thread or wait until window is closed
|
||||
#gobject.idle_add(self.call_critical_setting)
|
||||
|
||||
def call_critical_setting(self):
|
||||
ui.client.block_list_critical_setting(None) # This checks to see if url or listtype changed, if so download & import
|
||||
self.get_ip_count()
|
||||
|
||||
# GTK Gui Callback functions
|
||||
def callback_load_prefs(self, dict):
|
||||
log.info('Blocklist: Callback Load Prefs GTK ui')
|
||||
self.settings_url(dict['url'])
|
||||
self.settings_listtype(dict['listtype'])
|
||||
self.settings_load(dict['load_on_start'])
|
||||
self.settings_check_after_days(dict['check_after_days'])
|
||||
self.settings_timeout(dict['timeout'])
|
||||
self.settings_try_times(dict['try_times'])
|
||||
|
||||
# Specific function to return proper listtype so we can save and open it again
|
||||
def get_ltype(self):
|
||||
ls = self.listtype.get_model()
|
||||
log.debug(ls)
|
||||
ltype = ls[self.listtype.get_active()][1]
|
||||
log.debug(ltype)
|
||||
return ltype
|
||||
|
||||
# Settings functions
|
||||
def settings_listtype(self, setting):
|
||||
log.debug('Blocklist: listtype')
|
||||
path = FORMATS[setting][1]
|
||||
i = self.listtype.get_model().get_iter(path)
|
||||
self.listtype.set_active_iter(i)
|
||||
|
||||
def settings_url(self, setting):
|
||||
log.debug('Blocklist: url')
|
||||
self.url.set_text(setting)
|
||||
|
||||
def settings_check_after_days(self, setting):
|
||||
log.debug('Blocklist: days')
|
||||
self.check_after_days.set_value(setting)
|
||||
|
||||
def settings_load(self, setting):
|
||||
log.debug('Blocklist: load_on_start')
|
||||
log.info(setting)
|
||||
if setting == True or setting == "True":
|
||||
setting = 1
|
||||
else:
|
||||
setting = 0
|
||||
self.load_on_start.set_active(setting)
|
||||
|
||||
def settings_timeout(self, setting):
|
||||
log.debug('Blocklist: timeout')
|
||||
self.timeout.set_value(setting)
|
||||
|
||||
def settings_try_times(self, setting):
|
||||
log.debug('Blocklist: try times')
|
||||
self.try_times.set_value(setting)
|
||||
|
||||
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
##
|
||||
# Copyright 2007 Steve 'Tarka' Smith (tarka@internode.on.net)
|
||||
# Distributed under the same terms as Deluge
|
||||
##
|
||||
|
||||
from exceptions import Exception
|
||||
from struct import unpack
|
||||
import gzip, socket
|
||||
|
||||
class PGException(Exception):
|
||||
pass
|
||||
|
||||
# Incrementally reads PeerGuardian blocklists v1 and v2.
|
||||
# See http://wiki.phoenixlabs.org/wiki/P2B_Format
|
||||
class PGReader:
|
||||
|
||||
def __init__(self, filename):
|
||||
print "PGReader loading",filename
|
||||
|
||||
try:
|
||||
self.fd = gzip.open(filename, "rb")
|
||||
except IOError, e:
|
||||
print 'Blocklist: PGReader: Incorrect file type or list is corrupt'
|
||||
|
||||
# 4 bytes, should be 0xffffffff
|
||||
buf = self.fd.read(4)
|
||||
hdr = unpack("l", buf)[0]
|
||||
if hdr != -1:
|
||||
print "LEADER IS",hdr
|
||||
raise PGException(_("Invalid leader") + " %d"%hdr)
|
||||
|
||||
magic = self.fd.read(3)
|
||||
if magic != "P2B":
|
||||
raise PGException(_("Invalid magic code"))
|
||||
|
||||
buf = self.fd.read(1)
|
||||
ver = ord(buf)
|
||||
if ver != 1 and ver != 2:
|
||||
raise PGException(_("Invalid version") + " %d" % ver)
|
||||
|
||||
|
||||
def next(self):
|
||||
|
||||
# Skip over the string
|
||||
buf = -1
|
||||
while buf != 0:
|
||||
buf = self.fd.read(1)
|
||||
if buf == "": # EOF
|
||||
return False
|
||||
buf = ord(buf)
|
||||
|
||||
buf = self.fd.read(4)
|
||||
start = socket.inet_ntoa(buf)
|
||||
|
||||
buf = self.fd.read(4)
|
||||
end = socket.inet_ntoa(buf)
|
||||
|
||||
return (start, end)
|
||||
|
||||
def close(self):
|
||||
self.fd.close()
|
||||
|
|
@ -1,142 +0,0 @@
|
|||
##
|
||||
# Copyright 2007 Steve 'Tarka' Smith (tarka@internode.on.net)
|
||||
# Distributed under the same terms as Deluge
|
||||
##
|
||||
|
||||
|
||||
from exceptions import Exception
|
||||
import re, gzip, os
|
||||
from socket import inet_aton
|
||||
from struct import unpack
|
||||
from zipfile import ZipFile
|
||||
|
||||
class TextException(Exception):
|
||||
pass
|
||||
|
||||
class FormatException(TextException):
|
||||
pass
|
||||
|
||||
class TextBase:
|
||||
|
||||
def __init__(self, fd, regexp):
|
||||
print "TextBase loading"
|
||||
self.count = 0
|
||||
self.fd = fd
|
||||
self.re = re.compile(regexp)
|
||||
|
||||
def next(self):
|
||||
self.count += 1
|
||||
|
||||
txt = self.fd.readline()
|
||||
if txt == "":
|
||||
return False
|
||||
|
||||
match = self.re.search(txt)
|
||||
if not match:
|
||||
print 'Blocklist: TextBase: Wrong file type or corrupted blocklist file.'
|
||||
|
||||
try:
|
||||
g = match.groups()
|
||||
except AttributeError:
|
||||
pass
|
||||
else:
|
||||
start = ".".join(g[0:4])
|
||||
end = ".".join(g[4:8])
|
||||
|
||||
return (start, end)
|
||||
|
||||
def close(self):
|
||||
self.fd.close()
|
||||
|
||||
|
||||
# This reads PeerGuardian text-formatted block-lists
|
||||
class PGTextReader(TextBase):
|
||||
|
||||
def __init__(self, fd):
|
||||
print "PGTextReader loading"
|
||||
regexp = ':(\d+)\.(\d+)\.(\d+)\.(\d+)-(\d+)\.(\d+)\.(\d+)\.(\d+)\s*$'
|
||||
TextBase.__init__(self, fd, regexp)
|
||||
|
||||
|
||||
# This reads uncompressed PG text list
|
||||
class TextReader(PGTextReader):
|
||||
|
||||
def __init__(self, filename):
|
||||
print "TextReader loading",filename
|
||||
try:
|
||||
PGTextReader.__init__(self, open(filename, 'r'))
|
||||
except:
|
||||
print 'Wrong file type or corrupted blocklist file.'
|
||||
|
||||
|
||||
# Reads Emule style blocklists (aka nipfilter)
|
||||
class MuleReader(TextBase):
|
||||
|
||||
def __init__(self, fd):
|
||||
print "MuleReader loading"
|
||||
regexp = '0*(\d+)\.0*(\d+)\.0*(\d+)\.0*(\d+)\s*-\s*0*(\d+)\.0*(\d+)\.0*(\d+)\.0*(\d+)\s*,'
|
||||
TextBase.__init__(self, fd, regexp)
|
||||
|
||||
class GZMuleReader(MuleReader):
|
||||
|
||||
def __init__(self, filename):
|
||||
print "GZMuleReader loading",filename
|
||||
try:
|
||||
MuleReader.__init__(self, gzip.open(filename, "r"))
|
||||
except:
|
||||
print 'Wrong file type or corrupted blocklist file.'
|
||||
|
||||
|
||||
# Reads zip files from SafePeer style files
|
||||
class PGZip(TextBase):
|
||||
|
||||
def __init__(self, filename):
|
||||
# Open zip and extract first file
|
||||
try:
|
||||
self.zfd = ZipFile(filename, 'r')
|
||||
except:
|
||||
print 'Blocklist: PGZip: Wrong file type or corrupted blocklist file.'
|
||||
else:
|
||||
self.files = self.zfd.namelist()
|
||||
self.opennext()
|
||||
|
||||
def opennext(self):
|
||||
self.tmp = os.tmpfile()
|
||||
f = self.files.pop()
|
||||
print "Loading file",f
|
||||
self.tmp.write(self.zfd.read(f))
|
||||
self.tmp.seek(0)
|
||||
self.reader = PGTextReader(self.tmp)
|
||||
|
||||
def next(self):
|
||||
try:
|
||||
ret = self.reader.next()
|
||||
if ret == False:
|
||||
# This bit is repeated below and could be moved into a
|
||||
# new procedure. However I'm not clear on how this
|
||||
# would effect tail recursion, so it remains
|
||||
# broken-out for now.
|
||||
if len(self.files) > 0:
|
||||
self.opennext()
|
||||
return self.next()
|
||||
else:
|
||||
# End of zip
|
||||
return False
|
||||
return ret
|
||||
|
||||
except FormatException, e:
|
||||
print 'Blocklist: PGZip: Got format exception for zipfile: '
|
||||
# Just skip
|
||||
if len(self.files) > 0:
|
||||
self.opennext()
|
||||
return self.next()
|
||||
else:
|
||||
return False
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
def close(self):
|
||||
try:
|
||||
self.zfd.close()
|
||||
except AttributeError:
|
||||
pass
|
||||
|
|
@ -1,386 +0,0 @@
|
|||
#
|
||||
# blocklist/blocklist.py
|
||||
#
|
||||
# Copyright (C) 2007 Andrew Resch ('andar') <andrewresch@gmail.com>
|
||||
# Copyright (C) 2008 Mark Stahler ('kramed') <markstahler@gmail.com>
|
||||
|
||||
# a snip or two used from johhnyg
|
||||
|
||||
#
|
||||
# Deluge is free software.
|
||||
#
|
||||
# You may redistribute it and/or modify it under the terms of the
|
||||
# GNU General Public License, as published by the Free Software
|
||||
# Foundation; either version 2 of the License, or (at your option)
|
||||
# any later version.
|
||||
#
|
||||
# deluge is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
# See the GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with deluge. If not, write to:
|
||||
# The Free Software Foundation, Inc.,
|
||||
# 51 Franklin Street, Fifth Floor
|
||||
# Boston, MA 02110-1301, USA.
|
||||
#
|
||||
# In addition, as a special exception, the copyright holders give
|
||||
# permission to link the code of portions of this program with the OpenSSL
|
||||
# library.
|
||||
# You must obey the GNU General Public License in all respects for all of
|
||||
# the code used other than OpenSSL. If you modify file(s) with this
|
||||
# exception, you may extend this exception to your version of the file(s),
|
||||
# but you are not obligated to do so. If you do not wish to do so, delete
|
||||
# this exception statement from your version. If you delete this exception
|
||||
# statement from all source files in the program, then also delete it here.
|
||||
|
||||
# TODO:
|
||||
# - ZERO connections until after import
|
||||
# - download timeouts / retries
|
||||
|
||||
import urllib2, httplib, socket, os, datetime, sys
|
||||
import deluge.common
|
||||
import deluge.component # for libtorrent session reference to change connection number
|
||||
import deluge.configmanager # used to retrieve max_global_connections
|
||||
from deluge.log import LOG as log
|
||||
#import ui # added by Mark for pausing torrents
|
||||
from peerguardian import PGReader, PGException
|
||||
from text import TextReader, GZMuleReader, PGZip
|
||||
|
||||
BLOCKLIST_PREFS = {
|
||||
"url": "http://www.bluetack.co.uk/config/pipfilter.dat.gz",
|
||||
"load_on_start": False,
|
||||
"check_after_days": 2,
|
||||
"listtype": "gzmule",
|
||||
"timeout": 180,
|
||||
"try_times": 3
|
||||
}
|
||||
|
||||
BACKUP_PREFS = {
|
||||
"url": "http://www.bluetack.co.uk/config/pipfilter.dat.gz",
|
||||
"listtype": "gzmule",
|
||||
}
|
||||
|
||||
FORMATS = {
|
||||
'gzmule': ["Emule IP list (GZip)", GZMuleReader, None],
|
||||
'spzip': ["SafePeer Text (Zipped)", PGZip, None],
|
||||
'pgtext': ["PeerGuardian Text (Uncompressed)", TextReader, None],
|
||||
'p2bgz': ["PeerGuardian P2B (GZip)", PGReader, None]
|
||||
}
|
||||
|
||||
class HTTPConnection(httplib.HTTPConnection):
|
||||
"""A customized HTTPConnection allowing a per-connection timeout, specified at construction."""
|
||||
|
||||
def __init__(self, host, port=None, strict=None, timeout=None):
|
||||
httplib.HTTPConnection.__init__(self, host, port, strict)
|
||||
self.timeout = timeout
|
||||
|
||||
def connect(self):
|
||||
"""Override HTTPConnection.connect to connect to host/port specified in __init__."""
|
||||
|
||||
msg = "getaddrinfo returns an empty list"
|
||||
for res in socket.getaddrinfo(self.host, self.port, 0, socket.SOCK_STREAM):
|
||||
af, socktype, proto, canonname, sa = res
|
||||
try:
|
||||
self.sock = socket.socket(af, socktype, proto)
|
||||
if self.timeout:
|
||||
self.sock.settimeout(self.timeout)
|
||||
self.sock.connect(sa)
|
||||
except socket.error, msg:
|
||||
if self.sock:
|
||||
self.sock.close()
|
||||
self.sock = None
|
||||
continue
|
||||
break
|
||||
if not self.sock:
|
||||
raise socket.error, msg
|
||||
|
||||
|
||||
class HTTPHandler(urllib2.HTTPHandler):
|
||||
"""A customized HTTPHandler which times out connection after the duration specified at construction."""
|
||||
|
||||
def __init__(self, timeout=None):
|
||||
urllib2.HTTPHandler.__init__(self)
|
||||
self.timeout = timeout
|
||||
|
||||
def http_open(self, req):
|
||||
"""Override http_open."""
|
||||
|
||||
def makeConnection(host, port=None, strict=None):
|
||||
return HTTPConnection(host, port, strict, timeout = self.timeout)
|
||||
|
||||
#print "HTTPHandler opening", req.get_full_url()
|
||||
return self.do_open(makeConnection, req)
|
||||
|
||||
|
||||
class TorrentBlockList:
|
||||
def __init__(self, coreplugin):
|
||||
self.plugin = coreplugin # reference from plugin core
|
||||
log.info('Blocklist: TorrentBlockList instantiated')
|
||||
self.config = deluge.configmanager.ConfigManager("blocklist.conf", BLOCKLIST_PREFS)
|
||||
self.curr = 0
|
||||
self.load_options()
|
||||
|
||||
# Make sure we have a current block list file locally
|
||||
self.fetch = False
|
||||
self.local_blocklist = deluge.configmanager.get_config_dir("blocklist.cache")
|
||||
|
||||
# Check list for modifications from online version
|
||||
self.check_update()
|
||||
|
||||
if self.fetch == True:
|
||||
self.download()
|
||||
|
||||
log.debug('Blocklist: TorrentBlockList Constructor finished')
|
||||
|
||||
|
||||
def load_options(self):
|
||||
# Fill variables with settings from block list configuration file
|
||||
self.url = self.config['url']
|
||||
self.listtype = self.config['listtype']
|
||||
self.check_after_days = self.config['check_after_days']
|
||||
self.load_on_start = self.config['load_on_start']
|
||||
self.timeout = self.config['timeout']
|
||||
self.try_times = self.config['try_times']
|
||||
|
||||
self.old_url = self.url
|
||||
self.old_listtype = self.listtype
|
||||
|
||||
socket.setdefaulttimeout(self.timeout)
|
||||
|
||||
def set_options(self, options):
|
||||
log.info('Blocklist: Options saved...')
|
||||
self.config.set('url', options['url'])
|
||||
self.config.set('check_after_days', options['check_after_days'])
|
||||
self.config.set('load_on_start', options['load_on_start'])
|
||||
self.config.set('listtype', options['listtype'])
|
||||
self.config.set('timeout', options['timeout'])
|
||||
self.config.set('try_times', options['try_times'])
|
||||
# Save settings to disk
|
||||
self.config.save()
|
||||
# Load newly set options to core plugin
|
||||
self.load_options()
|
||||
|
||||
def check_update(self, force_check=False):
|
||||
log.info('Blocklist: Checking for updates')
|
||||
|
||||
try:
|
||||
# Check current block lists time stamp and decide if it needs to be replaced
|
||||
list_stats = os.stat(self.local_blocklist)
|
||||
list_time = datetime.datetime.fromtimestamp(list_stats.st_mtime)
|
||||
list_size = list_stats.st_size
|
||||
current_time = datetime.datetime.today()
|
||||
|
||||
except:
|
||||
self.fetch = True
|
||||
return
|
||||
|
||||
# If local blocklist file exists but nothing is in it
|
||||
if list_size == 0:
|
||||
self.fetch = True
|
||||
return
|
||||
|
||||
if current_time >= (list_time + datetime.timedelta(self.check_after_days)):
|
||||
check_newer = True
|
||||
log.debug('Blocklist: List may need to be replaced')
|
||||
else:
|
||||
check_newer = False
|
||||
|
||||
# If the program decides it is time to get a new list
|
||||
if check_newer == True or force_check == True:
|
||||
log.debug('Blocklist: Attempting check')
|
||||
|
||||
j = 0 # counter for loop
|
||||
|
||||
while j < self.try_times:
|
||||
# Get current online block lists time stamp and compare it with current
|
||||
try:
|
||||
http_handler = HTTPHandler(timeout = self.timeout)
|
||||
opener = urllib2.build_opener(http_handler)
|
||||
request = urllib2.Request(self.url)
|
||||
|
||||
try:
|
||||
new_listinfo = opener.open(request) # Can Raise URLError
|
||||
header = new_listinfo.info()
|
||||
remote_size = int(header['content-length'])
|
||||
remote_time = datetime.datetime.strptime(header['last-modified'],"%a, %d %b %Y %H:%M:%S GMT")
|
||||
remote_type = header['content-type']
|
||||
|
||||
except URLError, e:
|
||||
log.warning("Blocklist: Requesnt online blocklist info failed")
|
||||
j += 1
|
||||
break
|
||||
|
||||
except Exception, e:
|
||||
log.warning(e)
|
||||
# HANDLE EXCEPTOIN
|
||||
j = self.try_times
|
||||
break
|
||||
|
||||
log.debug(self.listtype)
|
||||
|
||||
# check expected list type
|
||||
if self.listtype == "spzip":
|
||||
list_type = "application/zip"
|
||||
elif self.listtype == "gzmule" or self.listtype == "p2bgz":
|
||||
list_type = "application/x-gzip"
|
||||
else:
|
||||
list_type = "text/html"
|
||||
|
||||
# Print remote file information and local
|
||||
log.debug('Blocklist: remote')
|
||||
log.debug(remote_type)
|
||||
log.debug(remote_time)
|
||||
log.debug(remote_size)
|
||||
log.debug('Blocklist: local')
|
||||
log.debug(list_type)
|
||||
log.debug(list_time)
|
||||
log.debug(list_size)
|
||||
|
||||
# Compare MIME types of local and remote list
|
||||
if list_type == remote_type:
|
||||
log.info('Blocklist: Remote and Local have the same list type')
|
||||
# Compare last modified times and decide to download a new list or not
|
||||
if list_time < remote_time or list_size != remote_size:
|
||||
self.fetch = True
|
||||
log.info('Blocklist: Local blocklist list is out of date')
|
||||
|
||||
else:
|
||||
self.fetch = False
|
||||
log.info('Blocklist: Local block list is up to date')
|
||||
|
||||
return
|
||||
|
||||
j+=1
|
||||
log.debug('Blocklist: TRY AGAIN FOO')
|
||||
|
||||
# Connection can't be made to check remote time stamps
|
||||
except: # && urllib2.URLError
|
||||
log.debug('Blocklist: Connection to remote server timed out')
|
||||
self.fetch = False
|
||||
j+=1
|
||||
|
||||
else:
|
||||
log.info('Blocklist: Not enough time has passed to check for a new list')
|
||||
return
|
||||
|
||||
def download(self):
|
||||
log.info('Blocklist: Beginning download')
|
||||
|
||||
i = 0
|
||||
success = False
|
||||
|
||||
while i < self.try_times or success == False:
|
||||
# Download a new block list
|
||||
try:
|
||||
log.info('Blocklist: Downloading new list...')
|
||||
http_handler = HTTPHandler(timeout = self.timeout)
|
||||
opener = urllib2.build_opener(http_handler)
|
||||
request = urllib2.Request(self.url)
|
||||
new_list = opener.open(request)
|
||||
|
||||
file = open(deluge.configmanager.get_config_dir("blocklist.cache"), 'w')
|
||||
log.info('Blocklist: Writing blocklist to disk')
|
||||
|
||||
# Write new blocklist to disk
|
||||
while 1:
|
||||
data = new_list.read()
|
||||
if not len(data):
|
||||
break
|
||||
file.write(data)
|
||||
file.close()
|
||||
|
||||
except OSError, e:
|
||||
log.debug('Blocklist: Unable to write blocklist file')
|
||||
return
|
||||
|
||||
except:
|
||||
if i > self.try_times:
|
||||
log.warning('Blocklist: All download attempts failed')
|
||||
return
|
||||
|
||||
else:
|
||||
log.warning('Blocklist: Try list download again')
|
||||
i += 1
|
||||
|
||||
# CHECKSUM
|
||||
success = True
|
||||
break
|
||||
# end while loop
|
||||
|
||||
log.info('Blocklist: List downloaded sucessfully')
|
||||
# Download completed
|
||||
|
||||
def import_list(self):
|
||||
log.info('Blocklist: Importing list...')
|
||||
# During import, disable remote connections by setting max to 0
|
||||
deluge.component.get("Core").session.set_max_connections(0)
|
||||
|
||||
#TODO: Dont need try anymore
|
||||
try:
|
||||
self.plugin.reset_ip_filter()
|
||||
self.curr = 0
|
||||
log.info('Blocklist: IP Filter reset')
|
||||
except:
|
||||
log.debug('Blocklist: Reset filter failed')
|
||||
pass
|
||||
|
||||
# Instantiate format class that will read the lists file format
|
||||
try:
|
||||
log.info('Blocklist: ' + str(self.listtype))
|
||||
read_list = FORMATS[self.listtype][1](self.local_blocklist)
|
||||
|
||||
except:
|
||||
log.warning('Blocklist: Error: Format read error')
|
||||
self.reset_critical_settings()
|
||||
|
||||
try:
|
||||
ips = read_list.next()
|
||||
|
||||
while ips:
|
||||
self.plugin.block_ip_range(ips)
|
||||
ips = read_list.next()
|
||||
self.curr += 1
|
||||
# Progress measurement here
|
||||
|
||||
log.info(self.curr)
|
||||
|
||||
except IOError, e:
|
||||
log.debug('Blocklist: Problem with list, re-download')
|
||||
return
|
||||
|
||||
# If experiencing an unrecoverable error, reset critical settings (url, listtype)
|
||||
if self.curr == 0:
|
||||
log.warning("Blocklist: Improper list read")
|
||||
self.reset_critical_settings()
|
||||
|
||||
else: # Sucessful import
|
||||
deluge.component.get("Core").session.set_max_connections(deluge.configmanager.ConfigManager("core.conf")["max_connections_global"])
|
||||
log.info('Blocklist: Import completed sucessfully')
|
||||
|
||||
def reset_critical_settings(self):
|
||||
log.info('Blocklist: URL and List type reset')
|
||||
reset_url = BACKUP_PREFS["url"]
|
||||
reset_listtype = BACKUP_PREFS["listtype"]
|
||||
|
||||
log.info(reset_url)
|
||||
log.info(reset_listtype)
|
||||
|
||||
self.config.set('url', reset_url)
|
||||
self.config.set('listtype', reset_listtype)
|
||||
self.config.save()
|
||||
|
||||
self.load_options()
|
||||
log.info(self.url)
|
||||
log.info(self.listtype)
|
||||
self.download()
|
||||
self.import_list()
|
||||
|
||||
def return_count(self):
|
||||
return self.curr
|
||||
|
||||
def get_config_value(self, key): # url, check_after_days, listtype
|
||||
val = self.config[key]
|
||||
log.debug('Blocklist: Get_config_val')
|
||||
return val
|
||||
|
|
@ -1,53 +0,0 @@
|
|||
#
|
||||
# blocklist/ui.py
|
||||
#
|
||||
# Copyright (C) 2007 Andrew Resch ('andar') <andrewresch@gmail.com>
|
||||
# Copyright (C) 2008 Mark Stahler ('kramed') <markstahler@gmail.com>
|
||||
|
||||
#
|
||||
# Deluge is free software.
|
||||
#
|
||||
# You may redistribute it and/or modify it under the terms of the
|
||||
# GNU General Public License, as published by the Free Software
|
||||
# Foundation; either version 2 of the License, or (at your option)
|
||||
# any later version.
|
||||
#
|
||||
# deluge is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
# See the GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with deluge. If not, write to:
|
||||
# The Free Software Foundation, Inc.,
|
||||
# 51 Franklin Street, Fifth Floor
|
||||
# Boston, MA 02110-1301, USA.
|
||||
#
|
||||
# In addition, as a special exception, the copyright holders give
|
||||
# permission to link the code of portions of this program with the OpenSSL
|
||||
# library.
|
||||
# You must obey the GNU General Public License in all respects for all of
|
||||
# the code used other than OpenSSL. If you modify file(s) with this
|
||||
# exception, you may extend this exception to your version of the file(s),
|
||||
# but you are not obligated to do so. If you do not wish to do so, delete
|
||||
# this exception statement from your version. If you delete this exception
|
||||
# statement from all source files in the program, then also delete it here.
|
||||
|
||||
import gettext
|
||||
import locale
|
||||
import pkg_resources
|
||||
import deluge.component
|
||||
from deluge.ui.client import aclient as client
|
||||
from deluge.log import LOG as log
|
||||
|
||||
class UI:
|
||||
def __init__(self, plugin_api, plugin_name):
|
||||
self.plugin = plugin_api
|
||||
|
||||
def enable(self):
|
||||
pass
|
||||
|
||||
def disable(self):
|
||||
pass
|
||||
|
||||
|
||||
|
|
@ -1,91 +0,0 @@
|
|||
#
|
||||
# blocklist/webui.py
|
||||
#
|
||||
# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
|
||||
|
||||
#
|
||||
# Deluge is free software.
|
||||
#
|
||||
# You may redistribute it and/or modify it under the terms of the
|
||||
# GNU General Public License, as published by the Free Software
|
||||
# Foundation; either version 2 of the License, or (at your option)
|
||||
# any later version.
|
||||
#
|
||||
# deluge is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
# See the GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with deluge. If not, write to:
|
||||
# The Free Software Foundation, Inc.,
|
||||
# 51 Franklin Street, Fifth Floor
|
||||
# Boston, MA 02110-1301, USA.
|
||||
#
|
||||
# In addition, as a special exception, the copyright holders give
|
||||
# permission to link the code of portions of this program with the OpenSSL
|
||||
# library.
|
||||
# You must obey the GNU General Public License in all respects for all of
|
||||
# the code used other than OpenSSL. If you modify file(s) with this
|
||||
# exception, you may extend this exception to your version of the file(s),
|
||||
# but you are not obligated to do so. If you do not wish to do so, delete
|
||||
# this exception statement from your version. If you delete this exception
|
||||
# statement from all source files in the program, then also delete it here.
|
||||
|
||||
import os
|
||||
from deluge.log import LOG as log
|
||||
from deluge.ui.client import sclient
|
||||
from deluge import component
|
||||
import ui
|
||||
|
||||
import deluge.ui.webui.lib.newforms_plus as forms
|
||||
|
||||
config_page_manager = component.get("ConfigPageManager")
|
||||
|
||||
FORMAT_LIST = [
|
||||
('gzmule',_("Emule IP list (GZip)")),
|
||||
('spzip',_("SafePeer Text (Zipped)")),
|
||||
('pgtext',_("PeerGuardian Text (Uncompressed)")),
|
||||
('p2bgz',_("PeerGuardian P2B (GZip)"))
|
||||
]
|
||||
|
||||
class BlockListCfgForm(forms.Form):
|
||||
"""
|
||||
a config form based on django forms.
|
||||
see webui.lib.newforms_plus, config_forms, etc.
|
||||
"""
|
||||
#meta:
|
||||
title = _("BlockList")
|
||||
|
||||
#load/save:
|
||||
def initial_data(self):
|
||||
return sclient.block_list_get_options()
|
||||
|
||||
def save(self, data):
|
||||
sclient.block_list_set_options(dict(data))
|
||||
|
||||
#input fields :
|
||||
listtype = forms.ChoiceField(FORMAT_LIST)
|
||||
url = forms.URLField(label=_("Url"))
|
||||
check_after_days = forms.IntegerField(label=_("Check for a blocklist every (days)"), min_value=-1, max_value=14)
|
||||
timeout = forms.IntegerField(label=_("Timeout (seconds)"), min_value=15, max_value=360)
|
||||
try_times = forms.IntegerField(label=_("Times to attemptdownload of new list"), min_value=1, max_value=5)
|
||||
load_on_start = forms.CheckBox(_('Import blocklist on daemon startup'))
|
||||
|
||||
class WebUI(ui.UI):
|
||||
def __init__(self, plugin_api, plugin_name):
|
||||
log.debug("Calling UI init")
|
||||
# Call UI constructor
|
||||
ui.UI.__init__(self, plugin_api, plugin_name)
|
||||
log.debug("Blocklist WebUI plugin initalized..")
|
||||
|
||||
def enable(self):
|
||||
config_page_manager.register('plugins','blocklist',BlockListCfgForm)
|
||||
|
||||
def disable(self):
|
||||
config_page_manager.unregister('blocklist')
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,56 +0,0 @@
|
|||
# setup.py
|
||||
#
|
||||
# Copyright (C) 2007 Andrew Resch ('andar') <andrewresch@gmail.com>
|
||||
# Copyright (C) 2008 Mark Stahler ('kramed') <markstahler@gmail.com>
|
||||
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2, or (at your option)
|
||||
# any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program. If not, write to:
|
||||
# The Free Software Foundation, Inc.,
|
||||
# 51 Franklin Street, Fifth Floor
|
||||
# Boston, MA 02110-1301, USA.
|
||||
#
|
||||
# In addition, as a special exception, the copyright holders give
|
||||
# permission to link the code of portions of this program with the OpenSSL
|
||||
# library.
|
||||
# You must obey the GNU General Public License in all respects for all of
|
||||
# the code used other than OpenSSL. If you modify file(s) with this
|
||||
# exception, you may extend this exception to your version of the file(s),
|
||||
# but you are not obligated to do so. If you do not wish to do so, delete
|
||||
# this exception statement from your version. If you delete this exception
|
||||
# statement from all source files in the program, then also delete it here.
|
||||
|
||||
"""
|
||||
Download and import IP Blocklists
|
||||
"""
|
||||
|
||||
from setuptools import setup
|
||||
|
||||
__author__ = "Mark Stahler"
|
||||
|
||||
setup(
|
||||
name="Block List",
|
||||
version="1.0",
|
||||
description=__doc__,
|
||||
author=__author__,
|
||||
packages=["blocklist"],
|
||||
package_data = {"blocklist": ["data/*"]},
|
||||
entry_points="""
|
||||
[deluge.plugin.core]
|
||||
Blocklist = blocklist:CorePlugin
|
||||
[deluge.plugin.gtkui]
|
||||
Blocklist = blocklist:GtkUIPlugin
|
||||
[deluge.plugin.webui]
|
||||
Blocklist = blocklist:WebUIPlugin
|
||||
"""
|
||||
)
|
||||
Loading…
Reference in New Issue