txhttputil 1.4.9__py3-none-any.whl

txhttputil/site/SiteUtil.py

@@ -0,0 +1,157 @@
+# Copyright (c) 2016-2026 Flying Ion Pty Ltd
+#
+# This software is open source; the MIT license applies.
+# See LICENSE for the full license text.
+#
+# Website : https://flyingion.com
+# Support : contact@flyingion.com
+
+import logging
+import platform
+from typing import Optional
+
+from twisted.internet import reactor
+from twisted.internet._sslverify import trustRootFromCertificates
+from twisted.web import server
+from txhttputil.login_page.LoginElement import LoginElement
+from txhttputil.site.AuthCredentials import (
+    AllowAllAuthCredentials,
+    AuthCredentials,
+)
+from txhttputil.site.AuthSessionWrapper import FormBasedAuthSessionWrapper
+from txhttputil.site.FileUploadRequest import FileUploadRequest
+from txhttputil.site.RedirectToHttpsResource import RedirectToHttpsResource
+from txhttputil.util.PemUtil import (
+    parseTrustRootFromBundle,
+    parsePemBundleForServer,
+    parsePemBundleForTrustedPeers,
+    parseDiffieHellmanParameter,
+)
+from txhttputil.util.SslUtil import (
+    buildCertificateOptionsForTwisted,
+)
+
+from txwebsocket.txws import WebSocketUpgradeHTTPChannel
+
+logger = logging.getLogger(__name__)
+
+
+def setupSite(
+    name: str,
+    rootResource,
+    portNum: int = 8000,
+    credentialChecker: AuthCredentials = AllowAllAuthCredentials(),
+    enableLogin=True,
+    SiteProtocol=WebSocketUpgradeHTTPChannel,
+    redirectFromHttpPort: Optional[int] = None,
+    enableSsl: Optional[bool] = False,
+    sslEnableMutualTLS: Optional[bool] = False,
+    sslBundleFilePath: Optional[str] = None,
+    sslMutualTLSCertificateAuthorityBundleFilePath: Optional[str] = None,
+    sslMutualTLSTrustedPeerCertificateBundleFilePath: Optional[str] = None,
+    dhParamPemFilePath: Optional[str] = None,
+):
+    """Setup Site
+    Sets up the web site to listen for connections and serve the site.
+    Supports customisation of resources based on user details
+
+    @return: Port object
+    """
+    assert (
+        not sslEnableMutualTLS or enableSsl and sslEnableMutualTLS
+    ), "Mutual TLS only works if the server is using TLS"
+
+    logMsg = f"setting up http server '{name}' on port {portNum}, "
+    logMsg += f"with ssl '{'on' if enableSsl else 'off'}', "
+    if enableSsl:
+        logMsg += f"with ssl PEM bundle from '{sslBundleFilePath}', "
+        logMsg += f"with mTLS '{'on' if sslEnableMutualTLS else 'off'}', "
+        if sslEnableMutualTLS:
+            logMsg += (
+                f"with mTLS CA bundle from"
+                f" '{sslMutualTLSCertificateAuthorityBundleFilePath}', "
+            )
+            logMsg += (
+                f"with mTLS trusted peer bundle from"
+                f" '{sslMutualTLSTrustedPeerCertificateBundleFilePath}', "
+            )
+            logMsg += (
+                f"with Diffie-Hellman parameter from '{dhParamPemFilePath}'"
+            )
+
+    logger.info(logMsg)
+    if redirectFromHttpPort is not None:
+        setupSite(
+            name="%s https redirect" % name,
+            rootResource=RedirectToHttpsResource(portNum),
+            portNum=redirectFromHttpPort,
+            enableLogin=False,
+        )
+
+    LoginElement.siteName = name
+
+    if enableLogin:
+        protectedResource = FormBasedAuthSessionWrapper(
+            rootResource, credentialChecker
+        )
+    else:
+        logger.critical("Resource protection disabled NO LOGIN REQUIRED")
+        protectedResource = rootResource
+
+    site = server.Site(protectedResource)
+    site.protocol = SiteProtocol
+    site.requestFactory = FileUploadRequest
+
+    if enableSsl:
+        proto = "https"
+
+        trustedCertificateAuthorities = None
+        if sslEnableMutualTLS:
+            trustedCertificateAuthorities = parseTrustRootFromBundle(
+                sslMutualTLSCertificateAuthorityBundleFilePath
+            )
+            trustedCertificateAuthorities = trustRootFromCertificates(
+                trustedCertificateAuthorities
+            )
+
+        privateKeyWithFullChain = parsePemBundleForServer(sslBundleFilePath)
+
+        trustedPeerCertificates = None
+        if sslMutualTLSTrustedPeerCertificateBundleFilePath is not None:
+            trustedPeerCertificates = parsePemBundleForTrustedPeers(
+                sslMutualTLSTrustedPeerCertificateBundleFilePath
+            )
+
+        dhParameters = None
+        if dhParamPemFilePath is not None:
+            dhParameters = parseDiffieHellmanParameter(dhParamPemFilePath)
+
+        contextFactory = buildCertificateOptionsForTwisted(
+            privateKeyWithFullChain,
+            trustRoot=trustedCertificateAuthorities,
+            trustedPeerCertificates=trustedPeerCertificates,
+            dhParameters=dhParameters,
+        )
+        sitePort = reactor.listenSSL(portNum, site, contextFactory)
+
+    else:
+        proto = "http"
+        sitePort = reactor.listenTCP(portNum, site)
+
+    if platform.system() == "Linux":
+        import subprocess
+
+        ip = (
+            subprocess.getoutput("/sbin/ifconfig").split("\n")[1].split()[1][5:]
+        )
+    else:
+        ip = "0.0.0.0"
+
+    logger.info(
+        "%s is alive and listening on %s://%s:%s",
+        name,
+        proto,
+        ip,
+        sitePort.port,
+    )
+    return sitePort

txhttputil/site/StaticFileResource.py

@@ -0,0 +1,163 @@
+# Copyright (c) 2016-2026 Flying Ion Pty Ltd
+#
+# This software is open source; the MIT license applies.
+# See LICENSE for the full license text.
+#
+# Website : https://flyingion.com
+# Support : contact@flyingion.com
+
+import logging
+import mimetypes
+import os
+from collections import namedtuple
+from datetime import date, timedelta
+from time import mktime
+from urllib.request import pathname2url
+from wsgiref.handlers import format_date_time
+
+from filetype import filetype
+from twisted.internet.task import cooperate
+from twisted.web.server import NOT_DONE_YET
+from txhttputil.site.BasicResource import BasicResource
+from txhttputil.util.DeferUtil import deferToThreadWrap
+
+logger = logging.getLogger(__name__)
+
+FileData = namedtuple("FileData", ["fobj", "size", "cacheControl", "expires"])
+
+
+class StaticFileResource(BasicResource):
+    """ """
+
+    isLeaf = True
+
+    __STATIC_MIME_TYPES = [
+        (".js.map", "application/json"),
+        (".css.map", "application/json"),
+        (".js", "application/javascript"),
+    ]
+
+    def __init__(
+        self, filePath: str, expireMinutes: int = 30, chunkSize: int = 128000, allowedIpsList=None
+    ):
+        BasicResource.__init__(self, allowedIpsList)
+        self._filePath = filePath
+        self.cancelDownload = False
+        self.expireMinutes = expireMinutes
+        self.chunkSize = chunkSize
+
+        # Set the MIME Type
+        for extension, mimetype in self.__STATIC_MIME_TYPES:
+            if filePath.endswith(extension):
+                self._mimetype = mimetype
+                return
+
+        fileTypeGuess = filetype.guess(filePath)
+        if fileTypeGuess:
+            self._mimetype = fileTypeGuess.mime
+
+        else:
+            self._mimetype = mimetypes.guess_type(
+                pathname2url(filePath), strict=False
+            )[0]
+
+            if self._mimetype is None:
+                # fallback to arbitrary binary data
+                self._mimetype = "application/octet-stream"
+
+        assert self._mimetype, "Unknown mime type for: %s" % filePath
+
+    def render_GET(self, request):
+        request.responseHeaders.setRawHeaders(b"content-type", [self._mimetype])
+        return self.serveStaticFileWithCache(request)
+
+    def serveStaticFileWithCache(self, request):
+        """Resource Create And Serve Static File
+
+        This should probably be a class now.
+
+        """
+
+        d = self.loadFileInThread(request)
+        d.addCallback(self._setHeaders, request)
+        d.addCallback(self._writeData, request)
+        d.addErrback(self._fileFailed, request)
+
+        request.notifyFinish().addErrback(self._closedError)
+
+        return NOT_DONE_YET
+
+    @deferToThreadWrap
+    def loadFileInThread(self, request):
+        requestPath = request.path
+        if not self._filePath or not os.path.exists(self._filePath):
+            raise Exception(
+                "File %s doesn't exist for resource %s"
+                % (self._filePath, requestPath)
+            )
+
+        size = os.stat(self._filePath).st_size
+        fobj = open(self._filePath, "rb")
+
+        expiry = (date.today() + timedelta(self.expireMinutes)).timetuple()
+        expiresTime = format_date_time(mktime(expiry))
+
+        cacheControl = (
+            b"max-age=" + str(self.expireMinutes * 60).encode()
+        )  # In Seconds
+        cacheControl += b", private"
+
+        return FileData(
+            fobj=fobj, size=size, cacheControl=cacheControl, expires=expiresTime
+        )
+
+    def _setHeaders(self, fileData, request):
+        # DISABLED
+        # Cache control is disabled for gziped resources as they are chunk-encoded
+        # request.setHeader("Cache-Control", fileData.cacheControl)
+        # request.setHeader("Expires", fileData.expires)
+        request.setHeader(b"Content-Length", str(fileData.size))
+        return fileData
+
+    def _writeData(self, fileData, request):
+        def writer():
+            try:
+                data = fileData.fobj.read(self.chunkSize)
+                while data and not self.cancelDownload:
+                    request.write(data)
+                    yield None  # Yield to the reactor for a bit
+                    data = fileData.fobj.read(self.chunkSize)
+                    yield None  # Allow any "NotifyFinish" updates
+
+                if not self.cancelDownload:
+                    request.finish()
+
+                fileData.fobj.close()
+
+            except Exception as e:
+                logger.error(
+                    "An error occured loading and sending the file"
+                    " data for file %s for resource %s",
+                    self._filePath,
+                    request.path,
+                )
+                logger.exception(e)
+
+        return cooperate(writer())
+
+    def _fileFailed(self, failure, request):
+        self.cancelDownload = True
+        request.setResponseCode(404)
+        logger.error(str(failure.value))
+        request.finish()
+
+        logger.error(
+            "Failed to send file %s for resource %s",
+            self._filePath,
+            request.path,
+        )
+        logger.exception(failure.value)
+
+    def _closedError(self, failure):
+        self.cancelDownload = True
+        logger.error("Got closedError %s" % failure)

txhttputil/site/__init__.py

@@ -0,0 +1,8 @@
+# Copyright (c) 2016-2026 Flying Ion Pty Ltd
+#
+# This software is open source; the MIT license applies.
+# See LICENSE for the full license text.
+#
+# Website : https://flyingion.com
+# Support : contact@flyingion.com
+

txhttputil/util/DeferUtil.py

@@ -0,0 +1,54 @@
+# Copyright (c) 2016-2026 Flying Ion Pty Ltd
+#
+# This software is open source; the MIT license applies.
+# See LICENSE for the full license text.
+#
+# Website : https://flyingion.com
+# Support : contact@flyingion.com
+
+import logging
+
+from twisted.internet.defer import maybeDeferred
+from twisted.internet.threads import deferToThread
+
+logger = logging.getLogger()
+
+__author__ = 'Flying Ion Pty Ltd'
+
+
+def vortexLogFailure(failure, loggerArg, consumeError=False, successValue=True):
+    try:
+        if not hasattr(failure, '_vortexLogged'):
+            if failure.getTraceback():
+                loggerArg.error(failure.getTraceback())
+            failure._vortexFailureLogged = True
+        return successValue if consumeError else failure
+    except Exception as e:
+        logger.exception(e)
+
+
+def printFailure(failure):
+    vortexLogFailure(failure, logger)
+    return failure
+
+
+def deferToThreadWrap(funcToWrap):
+    def func(*args, **kwargs):
+        d = deferToThread(funcToWrap, *args, **kwargs)
+        d.addErrback(printFailure)
+        return d
+
+    return func
+
+
+def maybeDeferredWrap(funcToWrap):
+    """ Maybe Deferred Wrap
+
+    A decorator that ensures a function will return a deferred.
+
+    """
+
+    def func(*args, **kwargs):
+        return maybeDeferred(funcToWrap, *args, **kwargs)
+
+    return func

txhttputil/util/ModuleUtil.py

@@ -0,0 +1,23 @@
+# Copyright (c) 2016-2026 Flying Ion Pty Ltd
+#
+# This software is open source; the MIT license applies.
+# See LICENSE for the full license text.
+#
+# Website : https://flyingion.com
+# Support : contact@flyingion.com
+
+def filterModules(name_:str, file_: str) -> [str]:
+    import os.path
+
+    for module in os.listdir(os.path.dirname(file_)):
+        modName, modExt = module.rsplit('.', 1) if '.' in module else [module, '']
+        if modExt not in ('py', 'pyc'):
+            continue
+
+        if modName == '__init__':
+            continue
+
+        if modName.endswith("Test"):
+            continue
+
+        yield '%s.%s' % (name_, module.rsplit('.', 1)[0])