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 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()])