def start(application, apps=[]):
"start a twisted instance"
dispatcher = Dispatcher(apps) # we only want one instance
# attach the service to its parent application
resource = EvokeResource()
resource.evokeDispatcher = dispatcher
# serve gzipped content if we can..
if has_gzip:
resource = EncodingResourceWrapper(resource, [GzipEncoderFactory()])
# set up our server
fileServer = server.Site(resource)
# use long session
fileServer.sessionFactory = LongSession
# start the service
port = int(list(dispatcher.apps.values())[0]['Config'].port)
evokeService = internet.TCPServer(port, fileServer)
evokeService.setServiceParent(application)
# logging
# create log dir if necessary
try:
os.mkdir('logs')
except OSError:
pass
logfile = DailyLogFile("twistd.log", "logs")
application.setComponent(ILogObserver, FileLogObserver(logfile).emit)
def start(application, apps=[]):
"start a twisted instance"
dispatcher = Dispatcher(apps) # we only want one instance
# attach the service to its parent application
resource = EvokeResource()
resource.evokeDispatcher = dispatcher
# serve gzipped content if we can..
if has_gzip:
resource = EncodingResourceWrapper(resource, [GzipEncoderFactory()])
# this assumes that this is a single apps
# multiserve having been deprecated
Session = list(dispatcher.apps.values())[0]['Session']
# set up our server
fileServer = EvokeSite(resource, Session, requestFactory=EvokeRequest)
# start the service
port = int(list(dispatcher.apps.values())[0]['Config'].port)
evokeService = internet.TCPServer(port, fileServer)
evokeService.setServiceParent(application)
# logging
# create log dir if necessary
try:
# os.mkdir('../logs')
os.mkdir('logs')
except OSError:
pass
# logfile = DailyLogFile("twistd.log", "../logs")
logfile = DailyLogFile("twistd.log", "logs")
application.setComponent(ILogObserver, FileLogObserver(logfile).emit)
def __init__(self):
Resource.__init__(self)
self.putChild(b"status", Status())
self.putChild(b"follow", Follow())
self.putChild(b"delay", Delay())
self.putChild(b"partial", Partial())
self.putChild(b"drop", Drop())
self.putChild(b"raw", Raw())
self.putChild(b"echo", Echo())
self.putChild(b"payload", PayloadResource())
self.putChild(
b"xpayload", EncodingResourceWrapper(
PayloadResource(), [
GzipEncoderFactory()]))
try:
from tests import tests_datadir
self.putChild(
b"files",
File(
os.path.join(
tests_datadir,
'test_site/files/')))
except Exception:
pass
self.putChild(b"redirect-to", RedirectTo())
def run(port):
resourceDaak = ResourceDaak()
wrappedDaak = EncodingResourceWrapper(resourceDaak, [GzipEncoderFactory()])
site = Daak(wrappedDaak)
reactor.listenTCP(port, site)
# log.msg("daak server run listen to port '" + str(port) + "'." )
reactor.run()
def serve():
port = 8000
webdir = File(SERVE_DIR)
webdir.contentTypes['.wasm'] = 'application/wasm'
wrapped = EncodingResourceWrapper(webdir, [GzipEncoderFactory()])
print("Serving at http://localhost:8000")
reactor.listenTCP(port, Site(wrapped))
reactor.run()
def __init__(self, session, path=""):
BaseController.__init__(self, path=path, session=session)
self.putChild("web", WebController(session))
api_controller_instance = EncodingResourceWrapper(
rest_api_controller.ApiController(session, resource_prefix='/api'),
[GzipEncoderFactory()])
self.putChild("api", api_controller_instance)
recordings_controller_instance = EncodingResourceWrapper(
rest_recordings_controller.RESTRecordingsController(),
[GzipEncoderFactory()])
self.putChild(RECORDINGS_ENDPOINT_PATH, recordings_controller_instance)
self.putChild(RECORDING_ENDPOINT_PATH,
static.File(RECORDINGS_ROOT_PATH))
timer_controller_instance = EncodingResourceWrapper(
rest_timer_controller.RESTTimerController(session=session),
[GzipEncoderFactory()])
self.putChild("timers", timer_controller_instance)
services_controller_instance = EncodingResourceWrapper(
rest_services_controller.RESTServicesController(),
[GzipEncoderFactory()])
self.putChild("services", services_controller_instance)
event_controller_instance = EncodingResourceWrapper(
rest_current_event_controller.RESTCurrentEventController(
session=session), [GzipEncoderFactory()])
self.putChild("current_event", event_controller_instance)
self.putChild("file", fs_access.RestrictedFilesystemAccessController())
self.putChild("grab", grabScreenshot(session))
if TOW_FRONTEND:
self.putChild("ajax", AjaxController(session))
self.putChild('favicon.ico', static.File(FAVICON_PATH))
self.putChild('favicon.png', static.File(FAVICON_PATH))
for shortcut in ('js', 'css', 'static', 'images', 'fonts'):
self.putChild(shortcut,
static.File('/'.join((PUBLIC_PATH, shortcut))))
self.putChild("transcoding", TranscodingController())
if PICON_PATH:
self.putChild("picon", static.File(PICON_PATH))
def getService(self):
page = BasicLogin(factory=self)
root = StaticNoDirListing(self.staticdir)
root.createErrorPages(self)
root.putChild("", RedirectCustomHeaders("/index.html", factory=self))
root.putChild("index.html", page)
wrapped = EncodingResourceWrapper(root, [GzipEncoderFactory()])
site = Site(wrapped)
return internet.TCPServer(self.port, site, interface=self.listen_addr)
def __init__(self, master):
self.authorized = {}
index = IndexResource()
robot = RobotResource()
listjs = ListResource()
status = StatusResource()
pack = PackResource()
packs = PacksTxtResource()
index.factory = robot.factory = listjs.factory = status.factory = pack.factory = self
self.master = index.master = robot.master = listjs.master = status.master = pack.master = packs.master = master
Site.__init__(self, EncodingResourceWrapper(index, [GzipEncoderFactory()]))
index.putChild("robots.txt", robot) # No reason to bother gzipping this
index.putChild("list.js", EncodingResourceWrapper(listjs, [GzipEncoderFactory()]))
index.putChild("status", EncodingResourceWrapper(status, [GzipEncoderFactory()]))
index.putChild("pack", EncodingResourceWrapper(pack, [GzipEncoderFactory()]))
index.putChild("packs.txt", EncodingResourceWrapper(packs, [GzipEncoderFactory()]))
def __init__(self, port=80, switchboard=None):
self.port = port
canarytoken_page = CanarytokenPage()
canarytoken_page.init(switchboard=switchboard)
wrapped = EncodingResourceWrapper(canarytoken_page,
[GzipEncoderFactory()])
site = server.Site(wrapped)
self.service = internet.TCPServer(self.port, site)
return None
def __init__(self):
Resource.__init__(self)
self.putChild(b"status", Status())
self.putChild(b"follow", Follow())
self.putChild(b"delay", Delay())
self.putChild(b"partial", Partial())
self.putChild(b"drop", Drop())
self.putChild(b"raw", Raw())
self.putChild(b"echo", Echo())
self.putChild(b"payload", PayloadResource())
self.putChild(b"xpayload", EncodingResourceWrapper(PayloadResource(), [GzipEncoderFactory()]))
def __init__(self, original_children):
Resource.__init__(self)
try:
from twisted.web.server import GzipEncoderFactory
from twisted.web.resource import EncodingResourceWrapper
for path, child in original_children.items():
self.putChild(
path, EncodingResourceWrapper(child,
[GzipEncoderFactory()]))
except ImportError:
pass
def __init__(self, port=80):
self.port = port
root = Resource()
root.putChild("", Redirect("generate"))
root.putChild("generate", GeneratorPage())
root.putChild("manage", ManagePage())
root.putChild("download", DownloadPage())
wrapped = EncodingResourceWrapper(root, [GzipEncoderFactory()])
site = server.Site(wrapped)
self.service = internet.TCPServer(self.port, site)
return None
def EncodingJSONRPCServer(server):
"""
Return wrapped JSON-RPC server that supports HTTP compression (currently
gzip).
@type server: t.w.r.Resource
@param server: Instance of JSONRPCServer
@rtype: t.w.r.EncodingResourceWrapper
@return: Wrapper that implements HTTP compression
"""
from twisted.web.resource import EncodingResourceWrapper
from twisted.web.server import GzipEncoderFactory
return EncodingResourceWrapper(server, [GzipEncoderFactory()])
def __init__(self):
Resource.__init__(self)
self.putChild("status", Status())
self.putChild("follow", Follow())
self.putChild("delay", Delay())
self.putChild("partial", Partial())
self.putChild("drop", Drop())
self.putChild("raw", Raw())
self.putChild("echo", Echo())
if six.PY2 and twisted_version > (12, 3, 0):
from twisted.web.test.test_webclient import PayloadResource
from twisted.web.server import GzipEncoderFactory
from twisted.web.resource import EncodingResourceWrapper
self.putChild('payload', PayloadResource())
self.putChild("xpayload", EncodingResourceWrapper(PayloadResource(), [GzipEncoderFactory()]))
def encoderForRequest(self, request):
"""
Check the request path if the extension allows the file to be
send compressed. If so use GzipEncoderFactory which may compress
the file contents if the client supports it.
"""
try:
(trunk, ext) = os.path.splitext(request.path)
ext_normalised = ext.lower()[1:]
if ext_normalised in self.gzip_allowed:
# print("{!r}: we want GZIP!".format(ext_normalised))
return GzipEncoderFactory.encoderForRequest(self, request)
# else:
# print("{!r}: we do not want GZIP!".format(ext_normalised))
except Exception as exc:
print exc
def __init__(self, port=80):
self.port = port
root = Resource()
root.putChild("", Redirect("generate"))
root.putChild("generate", GeneratorPage())
root.putChild("manage", ManagePage())
root.putChild("download", DownloadPage())
root.putChild("settings", SettingsPage())
root.putChild("history", HistoryPage())
root.putChild("resources", LimitedFile("/srv/templates/static"))
wrapped = EncodingResourceWrapper(root, [GzipEncoderFactory()])
site = server.Site(wrapped)
if settings.DEBUG:
site.displayTracebacks = settings.DEBUG
else:
site.displayTracebacks = False
self.service = internet.TCPServer(self.port, site)
return None
def getChild(self, path, request):
if path in self.children:
return self.children[path]
return EncodingResourceWrapper(self, [GzipEncoderFactory()])
class JSONResource(Resource):
protocolName = 'jsonrpc'
protocolVersion = '2.0'
protocolContentType = 'text/json'
protocolErrorName = 'JSONRPCError'
isLeaf = True
def __init__(self, logger=None):
Resource.__init__(self)
self._methods = {}
self._methods_with_requests = []
self.logger = logger
self.initMethods()
# by default do not use compression
self._gzipEncoderFactory = None
self.encoder = self.get_encoder()
assert IEncoder.providedBy(self.encoder), 'encoder does not provide IEncoder (no encoder available)'
def getCompressLevel(self):
return self._gzipEncoderFactory.compressLevel
def setCompressLevel(self, value):
self._gzipEncoderFactory.compressLevel = value
compressLevel = property(getCompressLevel, setCompressLevel)
def getUseCompression(self):
if self._gzipEncoderFactory:
return True
return False
def setUseCompression(self, value):
if value:
self._gzipEncoderFactory = GzipEncoderFactory()
else:
self._gzipEncoderFactory = None
useCompression = property(getUseCompression, setUseCompression)
def get_encoder(self):
return JSONEncoder()
def initMethods(self):
"""
override this to auto register your methods
make use of self.add_method(name,method)
for example:
self.add_method('echo',self.echo)
"""
pass
def add_method(self, name, method, with_request=False):
"""
This can called to register class methods or external function to be called by rpc clients
:param name string name that clients will call to reach this method
:param method a method or function that will be called when clients call name method
"""
#override any name that already here
self._methods[name] = method
if with_request:
if name not in self._methods_with_requests:
self._methods_with_requests.append(name)
else:
# if i am updating remove
if name in self._methods_with_requests:
self._methods_with_requests.remove(name)
def remove_method(self, name):
if name in self._methods:
del self._methods[name]
if name in self._methods_with_requests:
self._methods_with_requests.remove(name)
def list_methods(self):
return list(self._methods)
def has_method(self, name):
return name in self._methods
def get_method(self, name):
if name in self._methods:
return self._methods[name]
return None
def requestAborted(self, err, deferred, request):
"""
The client has disconnected while call is running if more cleanup needed,
inherit this method
"""
deferred.cancel()
# log this if possible
if self.logger:
self.logger('call cancelled: %s:%s > %s ' %
(request.client.host, request.client.port, err.getErrorMessage()))
def response(self, callID, result, error=None, version=None):
if version is None:
version = self.protocolVersion
if version == '2.0':
message = dict(id=callID, result=result)
message[self.protocolName] = version
if error:
message['error'] = error
else:
message = dict(version=self.protocolVersion, id=callID, result=result, error=error)
return self.encoder.encode(message)
def error(self, callID, code, message, data=None, version=None):
if version is None:
version = self.protocolVersion
error_message = dict(code=code,
message=message,
data=data
)
return self.response(callID, None, error=error_message, version=version)
def render(self, request):
request.content.seek(0, 0)
content = request.content.read()
d = defer.maybeDeferred(self.process, content, request)
request.notifyFinish().addErrback(self.requestAborted, d, request)
d.addCallback(self.processSuccess, request)
d.addErrback(self.processError, request)
return server.NOT_DONE_YET
def process(self, data, request):
try:
decodedData = self.encoder.decode(data)
except Exception as exception:
return self.error(0, ERROR_CODE_INVALID_JSON_PARSE_TEXT, 'invalid protocol %s:, %s' %
(self.protocolContentType, str(exception))
)
if not isinstance(decodedData, dict):
return self.error(0, ERROR_CODE_INVALID_JSON_PARSE_TEXT, "invalid protocol waiting "
"<type 'dict'> received %s" % type(decodedData))
# define the version
if self.protocolName in decodedData:
version = decodedData[self.protocolName]
else:
version = '1.0'
callID = decodedData.get('id', 0)
methodName = decodedData.get('method', None)
params = decodedData.get('params', [])
if not isinstance(params, (list, tuple)):
return self.error(callID, ERROR_CODE_INVALID_PARAMETERS, 'protocol params must be list or tuple')
method = self.get_method(methodName)
if not method:
return self.error(callID, ERROR_CODE_METHOD_NOT_FOUND, 'method "%s" does not exist' % methodName)
if methodName in self._methods_with_requests:
d = defer.maybeDeferred(method, request, *params)
else:
d = defer.maybeDeferred(method, *params)
d.addCallback(self._execMethodSuccess, callID, version)
d.addErrback(self._execMethodError, callID, version)
return d
def processSuccess(self, result, request):
if not request._disconnected:
request.setResponseCode(200)
request.setHeader("content-type", self.protocolContentType)
if self._gzipEncoderFactory:
gzipEncoder = self._gzipEncoderFactory.encoderForRequest(request)
else:
gzipEncoder = None
if gzipEncoder:
request.write(gzipEncoder.encode(result))
request.write(gzipEncoder.finish())
else:
request.setHeader("content-length", str(len(result)))
request.write(result)
request.finish()
def processError(self, failure, request):
"""
in normal situations this errBack will never happen,
in this situation i do know where the problem occurred
"""
if not request._disconnected:
# try to be json even here
result = self.error(None, ERROR_CODE_SERVER_ERROR, failure.getErrorMessage())
request.setResponseCode(500)
request.setHeader("content-type", self.protocolContentType)
request.setHeader("content-length", str(len(result)))
request.write(result)
request.finish()
def _execMethodSuccess(self, result, callID, version):
return self.response(callID, result, version=version)
def _execMethodError(self, failure, callID, version):
return self.error(callID, ERROR_CODE_SERVER_ERROR, failure.getErrorMessage(), version=version)
def setUseCompression(self, value):
if value:
self._gzipEncoderFactory = GzipEncoderFactory()
else:
self._gzipEncoderFactory = None
from twisted.web.server import Site, GzipEncoderFactory
from twisted.web.resource import Resource, EncodingResourceWrapper
from twisted.internet import reactor
class Daak(Resource):
isLeaf = True
def render_GET(self, request):
return "<html>Hello, world!</html>"
def render_POST(self, request):
return '<html><body>You submitted: %s</body></html>' % (cgi.escape(
request.args["the-field"][0]), )
resourceDaak = Daak()
wrappedDaak = EncodingResourceWrapper(resourceDaak, [GzipEncoderFactory()])
site = Site(wrappedDaak)
reactor.listenTCP(5000, site)
reactor.run()
class JSONResource(Resource):
protocolName = 'jsonrpc'
protocolVersion = '2.0'
protocolContentType = 'text/json'
protocolErrorName = 'JSONRPCError'
isLeaf = True
def __init__(self, logger=None):
Resource.__init__(self)
self._methods = {}
self._methods_with_requests = []
self.logger = logger
self.initMethods()
# by default do not use compression
self._gzipEncoderFactory = None
self.encoder = self.get_encoder()
assert IEncoder.providedBy(
self.encoder
), 'encoder does not provide IEncoder (no encoder available)'
def getCompressLevel(self):
return self._gzipEncoderFactory.compressLevel
def setCompressLevel(self, value):
self._gzipEncoderFactory.compressLevel = value
compressLevel = property(getCompressLevel, setCompressLevel)
def getUseCompression(self):
if self._gzipEncoderFactory:
return True
return False
def setUseCompression(self, value):
if value:
self._gzipEncoderFactory = GzipEncoderFactory()
else:
self._gzipEncoderFactory = None
useCompression = property(getUseCompression, setUseCompression)
def get_encoder(self):
return JSONEncoder()
def initMethods(self):
"""
override this to auto register your methods
make use of self.add_method(name,method)
for example:
self.add_method('echo',self.echo)
"""
pass
def add_method(self, name, method, with_request=False):
"""
This can called to register class methods or external function to be called by rpc clients
:param name string name that clients will call to reach this method
:param method a method or function that will be called when clients call name method
"""
#override any name that already here
self._methods[name] = method
if with_request:
if name not in self._methods_with_requests:
self._methods_with_requests.append(name)
else:
# if i am updating remove
if name in self._methods_with_requests:
self._methods_with_requests.remove(name)
def remove_method(self, name):
if name in self._methods:
del self._methods[name]
if name in self._methods_with_requests:
self._methods_with_requests.remove(name)
def list_methods(self):
return list(self._methods)
def has_method(self, name):
return name in self._methods
def get_method(self, name):
if name in self._methods:
return self._methods[name]
return None
def requestAborted(self, err, deferred, request):
"""
The client has disconnected while call is running if more cleanup needed,
inherit this method
"""
deferred.cancel()
# log this if possible
if self.logger:
self.logger('call cancelled: %s:%s > %s ' %
(request.client.host, request.client.port,
err.getErrorMessage()))
def response(self, callID, result, error=None, version=None):
if version is None:
version = self.protocolVersion
if version == '2.0':
message = dict(id=callID, result=result)
message[self.protocolName] = version
if error:
message['error'] = error
else:
message = dict(version=self.protocolVersion,
id=callID,
result=result,
error=error)
return self.encoder.encode(message)
def error(self, callID, code, message, data=None, version=None):
if version is None:
version = self.protocolVersion
error_message = dict(code=code, message=message, data=data)
return self.response(callID,
None,
error=error_message,
version=version)
def render(self, request):
request.content.seek(0, 0)
content = request.content.read()
d = defer.maybeDeferred(self.process, content, request)
request.notifyFinish().addErrback(self.requestAborted, d, request)
d.addCallback(self.processSuccess, request)
d.addErrback(self.processError, request)
return server.NOT_DONE_YET
def process(self, data, request):
try:
decodedData = self.encoder.decode(data)
except Exception as exception:
return self.error(
0, ERROR_CODE_INVALID_JSON_PARSE_TEXT,
'invalid protocol %s:, %s' %
(self.protocolContentType, str(exception)))
if not isinstance(decodedData, dict):
return self.error(
0, ERROR_CODE_INVALID_JSON_PARSE_TEXT,
"invalid protocol waiting "
"<type 'dict'> received %s" % type(decodedData))
# define the version
if self.protocolName in decodedData:
version = decodedData[self.protocolName]
else:
version = '1.0'
callID = decodedData.get('id', 0)
methodName = decodedData.get('method', None)
params = decodedData.get('params', [])
if not isinstance(params, (list, tuple)):
return self.error(callID, ERROR_CODE_INVALID_PARAMETERS,
'protocol params must be list or tuple')
method = self.get_method(methodName)
if not method:
return self.error(callID, ERROR_CODE_METHOD_NOT_FOUND,
'method "%s" does not exist' % methodName)
if methodName in self._methods_with_requests:
d = defer.maybeDeferred(method, request, *params)
else:
d = defer.maybeDeferred(method, *params)
d.addCallback(self._execMethodSuccess, callID, version)
d.addErrback(self._execMethodError, callID, version)
return d
def processSuccess(self, result, request):
if not request._disconnected:
request.setResponseCode(200)
request.setHeader("content-type", self.protocolContentType)
if self._gzipEncoderFactory:
gzipEncoder = self._gzipEncoderFactory.encoderForRequest(
request)
else:
gzipEncoder = None
if gzipEncoder:
request.write(gzipEncoder.encode(result))
request.write(gzipEncoder.finish())
else:
request.setHeader("content-length", str(len(result)))
request.write(result)
request.finish()
def processError(self, failure, request):
"""
in normal situations this errBack will never happen,
in this situation i do know where the problem occurred
"""
if not request._disconnected:
# try to be json even here
result = self.error(None, ERROR_CODE_SERVER_ERROR,
failure.getErrorMessage())
request.setResponseCode(500)
request.setHeader("content-type", self.protocolContentType)
request.setHeader("content-length", str(len(result)))
request.write(result)
request.finish()
def _execMethodSuccess(self, result, callID, version):
return self.response(callID, result, version=version)
def _execMethodError(self, failure, callID, version):
return self.error(callID,
ERROR_CODE_SERVER_ERROR,
failure.getErrorMessage(),
version=version)
def getChild(self, path, request):
return EncodingResourceWrapper(self, [GzipEncoderFactory()])
def getChild(self, path, request):
request.postpath = []
if self.master.config["web_function"] != "ddl":
self.brief = "DDL Disabled"
self.detail = "The owner of this txoffer instance has chosen to disable DDL. Use XDCC or pester them to turn it back on."
return self
try:
number = int(path)
except:
self.brief = "Invalid Pack Number"
self.detail = "Given pack number \"{}\" is not a valid integer".format(path)
return self
if number not in self.master.packs:
self.brief = "No Such Pack"
self.detail = "Could not find a pack with number \"{:d}\".".format(number)
return self
if not os.path.isfile(self.master.packs[number]):
self.brief = "Pack #{:d} Deleted".format(number)
self.detail = "{} no longer exists.".format(os.path.basename(self.master.packs[number]))
return self
if self.master.config["proxy_header"] is not None:
host = request.getHeader(self.master.config["proxy_header"])
else:
host = request.getClientIP()
if host in self.factory.authorized and number in self.factory.authorized[host]:
if self.master.config["log_requests"]:
log.msg("Serving: {} - {}".format(host, os.path.basename(self.master.packs[number])), system="WEB")
self.factory.authorized[host].remove(number)
request.notifyFinish().addBoth(self.factory.done, host, number)
r = EncodingResourceWrapper(File(self.master.packs[number]), [GzipEncoderFactory()])
return ThrottledResource(r, self.master.downloads[host][number], limit=self.master.config["throttle"])
elif host in self.master.downloads and number in self.master.downloads[host]:
request.redirect("/")
self.type = self.types.REDIRECT
return self
else:
try:
position = list(self.master.queue).index((self.factory, host, number)) + 1
element = QueueElement(self.master, os.path.basename(self.master.packs[number]), position)
request.write("<!doctype html>\n")
d = flatten(request, element, request.write)
d.addCallback(lambda _: request.finish())
d.addErrback(request.processingFailed)
self.type = self.types.QUEUE
return self
except ValueError:
self.master.queue.append((self.factory, host, number))
self.master.checkQueue()
request.redirect("/pack/{:d}/{}".format(number, os.path.basename(self.master.packs[number])))
self.type = self.types.REDIRECT
return self
def buildSite(ack, staticPath):
state = WebSocketState(ack)
websocket = WebSocketResource(state.factory)
static = EncodingResourceWrapper(File(staticPath), [GzipEncoderFactory()])
static.putChild(b'spam', websocket)
return Site(static)
def gz_wrap(r):
return EncodingResourceWrapper(r, [GzipEncoderFactory()])
def setUseCompression(self, value):
if value:
self._gzipEncoderFactory = GzipEncoderFactory()
else:
self._gzipEncoderFactory = None
def getChild(self, path, request):
child = static.File.getChild(self, path, request)
return EncodingResourceWrapper(child, [GzipEncoderFactory()])
def encoderForRequest(self, request):
if request.postpath[0].startswith("stream.m3u8"):
return GzipEncoderFactory.encoderForRequest(self, request)
from twisted.web import static, resource
import qwebirc.util as util
# TODO: fix GZIP
# from adminengine import AdminEngineAction
# import pprint
try:
from twisted.web.server import GzipEncoderFactory
GZIP_ENCODER = GzipEncoderFactory()
except ImportError:
GZIP_ENCODER = None
# TODO, cache gzip stuff
cache = {}
def clear_cache():
global cache
cache = {}
class StaticEngine(static.File):
isLeaf = False
hit = util.HitCounter()
def __init__(self, *args, **kwargs):
static.File.__init__(self, *args, **kwargs)
def render(self, request):
self.hit(request)
# temporarily disabled -- seems to eat big pages
# if GZIP_ENCODER:
def putGZChild(self, path, child):
child.isGZ = True
self.putChild(six.ensure_binary(path),
EncodingResourceWrapper(child, [GzipEncoderFactory()]))
def getChild(self, path, request):
if self.isGZ:
return EncodingResourceWrapper(self.__class__(self.session, path),
[GzipEncoderFactory()])
else:
return self.__class__(self.session, path)
def gzip_wrapper(page):
return EncodingResourceWrapper(page, [GzipEncoderFactory()])
