codex-storage
/
deluge
mirror of https://github.com/codex-storage/deluge.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
deluge/plugins/WebUi/deluge_webserver.py

307 lines
8.8 KiB
Python
Raw Blame History

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# deluge_webserver.py
#
# Copyright (C) Martijn Voncken 2007 <mvoncken@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.
import webserver_common as ws
from webserver_framework import *
import webpy022 as web
from webpy022.http import seeother, url
import base64
from operator import attrgetter
import os
#routing:
urls = (
"/login", "login",
"/index", "index",
"/torrent/info/(.*)", "torrent_info",
"/torrent/pause", "torrent_pause",
"/torrent/reannounce/(.*)", "torrent_reannounce",
"/torrent/add", "torrent_add",
"/torrent/delete/(.*)", "torrent_delete",
"/torrent/queue/up/(.*)", "torrent_queue_up",
"/torrent/queue/down/(.*)", "torrent_queue_down",
"/pause_all", "pause_all",
"/resume_all", "resume_all",
"/refresh/set", "refresh_set",
"/refresh/(.*)", "refresh",
"/config", "config",
"/home", "home",
"/about", "about",
"/logout", "logout",
#remote-api:
"/remote/torrent/add(.*)", "remote_torrent_add",
#static:
"/static/(.*)", "static",
"/template/static/(.*)", "template_static",
#"/downloads/(.*)","downloads" disabled until it can handle large downloads
#default-pages
"/", "home",
"", "home"
)
#/routing
#pages:
class login:
@deluge_page_noauth
def GET(self, name):
vars = web.input(error = None)
return ws.render.login(vars.error)
def POST(self):
vars = web.input(pwd = None, redir = None)
if check_pwd(vars.pwd):
#start new session
start_session()
do_redirect()
elif vars.redir:
seeother(url('/login', error=1, redir=vars.redir))
else:
seeother('/login?error=1')
class index:
"page containing the torrent list."
@deluge_page
@auto_refreshed
def GET(self, name):
vars = web.input(sort=None, order=None)
status_rows = [get_torrent_status(torrent_id)
for torrent_id in ws.proxy.get_session_state()]
#sorting:
if vars.sort:
status_rows.sort(key=attrgetter(vars.sort))
if vars.order == 'up':
status_rows = reversed(status_rows)
setcookie("order", vars.order)
setcookie("sort", vars.sort)
return ws.render.index(status_rows)
class torrent_info:
@deluge_page
@auto_refreshed
def GET(self, torrent_id):
return ws.render.torrent_info(get_torrent_status(torrent_id))
class torrent_pause:
@check_session
def POST(self, name):
vars = web.input(stop = None, start = None, redir = None)
if vars.stop:
ws.proxy.pause_torrent([vars.stop])
elif vars.start:
ws.proxy.resume_torrent([vars.start])
do_redirect()
class torrent_reannounce:
@check_session
def POST(self, torrent_id):
ws.proxy.force_reannounce([torrent_id])
do_redirect()
class torrent_add:
@deluge_page
def GET(self, name):
return ws.render.torrent_add()
@check_session
def POST(self, name):
vars = web.input(url = None, torrent = {})
if vars.url and vars.torrent.filename:
error_page(_("Choose an url or a torrent, not both."))
if vars.url:
ws.proxy.add_torrent_url(vars.url)
do_redirect()
elif vars.torrent.filename:
data = vars.torrent.file.read()
data_b64 = base64.b64encode(data)
#b64 because of strange bug-reports related to binary data
ws.proxy.add_torrent_filecontent(vars.torrent.filename, data_b64)
do_redirect()
else:
error_page(_("no data."))
class remote_torrent_add:
"""
For use in remote scripts etc.
POST pwd and torrent
"""
@remote
def POST(self, name):
vars = web.input(pwd = None, torrent = {})
if not check_pwd(vars.pwd):
return 'error:wrong password'
data_b64 = base64.b64encode(vars.torrent.file.read())
ws.proxy.add_torrent_filecontent(vars.torrent.filename, data_b64)
return 'ok'
class torrent_delete:
@deluge_page
def GET(self, torrent_id):
return ws.render.torrent_delete(get_torrent_status(torrent_id))
@check_session
def POST(self, torrent_id):
vars = web.input(data_also = None, torrent_also = None)
data_also = bool(vars.data_also)
torrent_also = bool(vars.torrent_also)
ws.proxy.remove_torrent(torrent_id, data_also, torrent_also)
do_redirect()
class torrent_queue_up:
@check_session
def POST(self, torrent_id):
ws.proxy.queue_up(torrent_id)
do_redirect()
class torrent_queue_down:
@check_session
def POST(self, torrent_id):
ws.proxy.queue_down(torrent_id)
do_redirect()
class pause_all:
@check_session
def POST(self, name):
ws.proxy.pause_torrent(ws.proxy.get_session_state())
do_redirect()
class resume_all:
@check_session
def POST(self, name):
ws.proxy.resume_torrent(ws.proxy.get_session_state())
do_redirect()
class refresh:
@check_session
def POST(self, name):
auto_refresh = {'off': '0', 'on': '1'}[name]
setcookie('auto_refresh', auto_refresh)
if not getcookie('auto_refresh_secs'):
setcookie('auto_refresh_secs', 10)
do_redirect()
class refresh_set:
@deluge_page
def GET(self, name):
return ws.render.refresh_form()
@check_session
def POST(self, name):
vars = web.input(refresh = 0)
refresh = int(vars.refresh)
if refresh > 0:
setcookie('auto_refresh', '1')
setcookie('auto_refresh_secs', str(refresh))
do_redirect()
else:
error_page(_('refresh must be > 0'))
class config:
"""core config
TODO:good validation.
"""
cfg_form = web.form.Form(
web.form.Dropdown('max_download', ws.SPEED_VALUES,
description=_('Download Speed Limit'),
post='%s Kib/sec' % ws.proxy.get_config_value('max_download_speed')
)
,web.form.Dropdown('max_upload', ws.SPEED_VALUES,
description=_('Upload Speed Limit'),
post='%s Kib/sec' % ws.proxy.get_config_value('max_upload_speed')
)
)
@deluge_page
def GET(self, name):
return ws.render.config(self.cfg_form())
def POST(self, name):
vars = web.input(max_download=None, max_upload=None)
#self.config.set("max_download_speed", float(str_bwdown))
raise NotImplementedError('todo')
class home:
@check_session
def GET(self, name):
do_redirect()
class about:
@deluge_page_noauth
def GET(self, name):
return ws.render.about()
class logout:
@check_session
def POST(self, name):
end_session()
seeother('/login')
class static(static_handler):
base_dir = os.path.join(os.path.dirname(__file__), 'static')
class template_static(static_handler):
def get_base_dir(self):
return os.path.join(os.path.dirname(__file__),
'templates/%s/static' % ws.config.get('template'))
class downloads(static_handler):
def GET(self, name):
self.base_dir = ws.proxy.get_config_value('default_download_path')
if not ws.config.get('share_downloads'):
raise Exception('Access to downloads is forbidden.')
return static_handler.GET(self, name)
#/pages
def WebServer():
return create_webserver(urls, globals())
def run():
server = WebServer()
try:
server.start()
except KeyboardInterrupt:
server.stop()
if __name__ == "__main__":
run()
Reference in New Issue View Git Blame Copy Permalink