copyparty 1.12.2__py3-none-any.whl → 1.13.1__py3-none-any.whl

copyparty/httpcli.py

@@ -36,6 +36,7 @@ from .bos import bos
 from .star import StreamTar
 from .sutil import StreamArc, gfilter
 from .szip import StreamZip
+from .up2k import up2k_chunksize
 from .util import unquote  # type: ignore
 from .util import (
     APPLESAN_RE,
@@ -83,6 +84,9 @@ from .util import (
     sanitize_vpath,
     sendfile_kern,
     sendfile_py,
+    ub64dec,
+    ub64enc,
+    ujoin,
     undot,
     unescape_cookie,
     unquotep,
@@ -123,6 +127,7 @@ class HttpCli(object):
         self.ico = conn.ico  # mypy404
         self.thumbcli = conn.thumbcli  # mypy404
         self.u2fh = conn.u2fh  # mypy404
+        self.pipes = conn.pipes  # mypy404
         self.log_func = conn.log_func  # mypy404
         self.log_src = conn.log_src  # mypy404
         self.gen_fk = self._gen_fk if self.args.log_fk else gen_filekey
@@ -211,6 +216,13 @@ class HttpCli(object):
         ka["favico"] = self.args.favico
         ka["s_name"] = self.args.bname
         ka["s_doctitle"] = self.args.doctitle
+        ka["tcolor"] = self.vn.flags["tcolor"]
+
+        zso = self.vn.flags.get("html_head")
+        if zso:
+            ka["this"] = self
+            self._build_html_head(zso, ka)
+
         ka["html_head"] = self.html_head
         return tpl.render(**ka)  # type: ignore
 
@@ -358,6 +370,21 @@ class HttpCli(object):
         if "&" in self.req and "?" not in self.req:
             self.hint = "did you mean '?' instead of '&'"
 
+        if self.args.uqe and "/.uqe/" in self.req:
+            try:
+                vpath, query = self.req.split("?")[0].split("/.uqe/")
+                query = query.split("/")[0]  # discard trailing junk
+                # (usually a "filename" to trick discord into behaving)
+                query = ub64dec(query.encode("utf-8")).decode("utf-8", "replace")
+                if query.startswith("/"):
+                    self.req = "%s/?%s" % (vpath, query[1:])
+                else:
+                    self.req = "%s?%s" % (vpath, query)
+            except Exception as ex:
+                t = "bad uqe in request [%s]: %r" % (self.req, ex)
+                self.loud_reply(t, status=400)
+                return False
+
         # split req into vpath + uparam
         uparam = {}
         if "?" not in self.req:
@@ -424,7 +451,8 @@ class HttpCli(object):
             cookie_pw = ""
 
         if len(uparam) > 10 or len(cookies) > 50:
-            raise Pebkac(400, "u wot m8")
+            self.loud_reply("u wot m8", status=400)
+            return False
 
         self.uparam = uparam
         self.cookies = cookies
@@ -712,6 +740,31 @@ class HttpCli(object):
             or ("; Trident/" in self.ua and not k304)
         )
 
+    def _build_html_head(self, maybe_html , kv  )  :
+        html = str(maybe_html)
+        is_jinja = html[:2] in "%@%"
+        if is_jinja:
+            html = html.replace("%", "", 1)
+
+        if html.startswith("@"):
+            with open(html[1:], "rb") as f:
+                html = f.read().decode("utf-8")
+
+        if html.startswith("%"):
+            html = html[1:]
+            is_jinja = True
+
+        if is_jinja:
+            print("applying jinja")
+            with self.conn.hsrv.mutex:
+                if html not in self.conn.hsrv.j2:
+                    j2env = jinja2.Environment()
+                    tpl = j2env.from_string(html)
+                    self.conn.hsrv.j2[html] = tpl
+                html = self.conn.hsrv.j2[html].render(**kv)
+
+        self.html_head += html + "\n"
+
     def send_headers(
         self,
         length ,
@@ -2245,6 +2298,10 @@ class HttpCli(object):
     def handle_login(self)  :
         assert self.parser
         pwd = self.parser.require("cppwd", 64)
+        try:
+            uhash = self.parser.require("uhash", 256)
+        except:
+            uhash = ""
         self.parser.drop()
 
         self.out_headerlist = [
@@ -2257,6 +2314,11 @@ class HttpCli(object):
 
         dst += self.ourlq()
 
+        uhash = uhash.lstrip("#")
+        if uhash not in ("", "-"):
+            dst += "&" if "?" in dst else "?"
+            dst += "_=1#" + html_escape(uhash, True, True)
+
         msg = self.get_pwd_cookie(pwd)
         html = self.j2s("msg", h1=msg, h2='<a href="' + dst + '">ack</a>', redir=dst)
         self.reply(html.encode("utf-8"))
@@ -2925,17 +2987,42 @@ class HttpCli(object):
 
         return txt
 
-    def tx_file(self, req_path )  :
+    def tx_file(self, req_path , ptop  = None)  :
         status = 200
         logmsg = "{:4} {} ".format("", self.req)
         logtail = ""
 
+        if ptop is not None:
+            try:
+                dp, fn = os.path.split(req_path)
+                tnam = fn + ".PARTIAL"
+                if self.args.dotpart:
+                    tnam = "." + tnam
+                ap_data = os.path.join(dp, tnam)
+                st_data = bos.stat(ap_data)
+                if not st_data.st_size:
+                    raise Exception("partial is empty")
+                x = self.conn.hsrv.broker.ask("up2k.find_job_by_ap", ptop, req_path)
+                job = json.loads(x.get())
+                if not job:
+                    raise Exception("not found in registry")
+                self.pipes.set(req_path, job)
+            except Exception as ex:
+                self.log("will not pipe [%s]; %s" % (ap_data, ex), 6)
+                ptop = None
+
         #
         # if request is for foo.js, check if we have foo.js.gz
 
         file_ts = 0.0
         editions    = {}
         for ext in ("", ".gz"):
+            if ptop is not None:
+                sz = job["size"]
+                file_ts = job["lmod"]
+                editions["plain"] = (ap_data, sz)
+                break
+
             try:
                 fs_path = req_path + ext
                 st = bos.stat(fs_path)
@@ -3092,6 +3179,11 @@ class HttpCli(object):
             self.send_headers(length=upper - lower, status=status, mime=mime)
             return True
 
+        if ptop is not None:
+            return self.tx_pipe(
+                ptop, req_path, ap_data, job, lower, upper, status, mime, logmsg
+            )
+
         ret = True
         with open_func(*open_args) as f:
             self.send_headers(length=upper - lower, status=status, mime=mime)
@@ -3111,6 +3203,143 @@ class HttpCli(object):
 
         return ret
 
+    def tx_pipe(
+        self,
+        ptop ,
+        req_path ,
+        ap_data ,
+        job  ,
+        lower ,
+        upper ,
+        status ,
+        mime ,
+        logmsg ,
+    )  :
+        M = 1048576
+        self.send_headers(length=upper - lower, status=status, mime=mime)
+        wr_slp = self.args.s_wr_slp
+        wr_sz = self.args.s_wr_sz
+        file_size = job["size"]
+        chunk_size = up2k_chunksize(file_size)
+        num_need = -1
+        data_end = 0
+        remains = upper - lower
+        broken = False
+        spins = 0
+        tier = 0
+        tiers = ["uncapped", "reduced speed", "one byte per sec"]
+
+        while lower < upper and not broken:
+            with self.u2mutex:
+                job = self.pipes.get(req_path)
+                if not job:
+                    x = self.conn.hsrv.broker.ask("up2k.find_job_by_ap", ptop, req_path)
+                    job = json.loads(x.get())
+                    if job:
+                        self.pipes.set(req_path, job)
+
+            if not job:
+                t = "pipe: OK, upload has finished; yeeting remainder"
+                self.log(t, 2)
+                data_end = file_size
+                break
+
+            if num_need != len(job["need"]) and data_end - lower < 8 * M:
+                num_need = len(job["need"])
+                data_end = 0
+                for cid in job["hash"]:
+                    if cid in job["need"]:
+                        break
+                    data_end += chunk_size
+                t = "pipe: can stream %.2f MiB; requested range is %.2f to %.2f"
+                self.log(t % (data_end / M, lower / M, upper / M), 6)
+                with self.u2mutex:
+                    if data_end > self.u2fh.aps.get(ap_data, data_end):
+                        try:
+                            fhs = self.u2fh.cache[ap_data].all_fhs
+                            for fh in fhs:
+                                fh.flush()
+                            self.u2fh.aps[ap_data] = data_end
+                            self.log("pipe: flushed %d up2k-FDs" % (len(fhs),))
+                        except Exception as ex:
+                            self.log("pipe: u2fh flush failed: %r" % (ex,))
+
+            if lower >= data_end:
+                if data_end:
+                    t = "pipe: uploader is too slow; aborting download at %.2f MiB"
+                    self.log(t % (data_end / M))
+                    raise Pebkac(416, "uploader is too slow")
+
+                raise Pebkac(416, "no data available yet; please retry in a bit")
+
+            slack = data_end - lower
+            if slack >= 8 * M:
+                ntier = 0
+                winsz = M
+                bufsz = wr_sz
+                slp = wr_slp
+            else:
+                winsz = max(40, int(M * (slack / (12 * M))))
+                base_rate = M if not wr_slp else wr_sz / wr_slp
+                if winsz > base_rate:
+                    ntier = 0
+                    bufsz = wr_sz
+                    slp = wr_slp
+                elif winsz > 300:
+                    ntier = 1
+                    bufsz = winsz // 5
+                    slp = 0.2
+                else:
+                    ntier = 2
+                    bufsz = winsz = slp = 1
+
+            if tier != ntier:
+                tier = ntier
+                self.log("moved to tier %d (%s)" % (tier, tiers[tier]))
+
+            try:
+                with open(ap_data, "rb", self.args.iobuf) as f:
+                    f.seek(lower)
+                    page = f.read(min(winsz, data_end - lower, upper - lower))
+                if not page:
+                    raise Exception("got 0 bytes (EOF?)")
+            except Exception as ex:
+                self.log("pipe: read failed at %.2f MiB: %s" % (lower / M, ex), 3)
+                with self.u2mutex:
+                    self.pipes.c.pop(req_path, None)
+                spins += 1
+                if spins > 3:
+                    raise Pebkac(500, "file became unreadable")
+                time.sleep(2)
+                continue
+
+            spins = 0
+            pofs = 0
+            while pofs < len(page):
+                if slp:
+                    time.sleep(slp)
+
+                try:
+                    buf = page[pofs : pofs + bufsz]
+                    self.s.sendall(buf)
+                    zi = len(buf)
+                    remains -= zi
+                    lower += zi
+                    pofs += zi
+                except:
+                    broken = True
+                    break
+
+        if lower < upper and not broken:
+            with open(req_path, "rb") as f:
+                remains = sendfile_py(self.log, lower, upper, f, self.s, wr_sz, wr_slp)
+
+        spd = self._spd((upper - lower) - remains)
+        if self.do_log:
+            self.log("{},  {}".format(logmsg, spd))
+
+        return not broken
+
     def tx_zip(
         self,
         fmt ,
@@ -3311,7 +3540,6 @@ class HttpCli(object):
         targs = {
             "r": self.args.SR if self.is_vproxied else "",
             "ts": self.conn.hsrv.cachebuster(),
-            "html_head": self.html_head,
             "edit": "edit" in self.uparam,
             "title": html_escape(self.vpath, crlf=True),
             "lastmod": int(ts_md * 1000),
@@ -3322,6 +3550,13 @@ class HttpCli(object):
             "md": boundary,
             "arg_base": arg_base,
         }
+
+        zfv = self.vn.flags.get("html_head")
+        if zfv:
+            targs["this"] = self
+            self._build_html_head(zfv, targs)
+
+        targs["html_head"] = self.html_head
         zs = template.render(**targs).encode("utf-8", "replace")
         html = zs.split(boundary.encode("utf-8"))
         if len(html) != 2:
@@ -3437,8 +3672,6 @@ class HttpCli(object):
             self.reply(zb, mime="text/plain; charset=utf-8")
             return True
 
-        self.html_head += self.vn.flags.get("html_head", "")
-
         html = self.j2s(
             "splash",
             this=self,
@@ -3483,7 +3716,7 @@ class HttpCli(object):
         return True
 
     def set_cfg_reset(self)  :
-        for k in ("k304", "js", "idxh", "cppwd", "cppws"):
+        for k in ("k304", "js", "idxh", "dots", "cppwd", "cppws"):
             cookie = gencookie(k, "x", self.args.R, False)
             self.out_headerlist.append(("Set-Cookie", cookie))
 
@@ -3694,7 +3927,7 @@ class HttpCli(object):
         allvols = [x for x in allvols if "e2d" in x.flags]
 
         for vol in allvols:
-            cur = idx.get_cur(vol.realpath)
+            cur = idx.get_cur(vol)
             if not cur:
                 continue
 
@@ -3748,7 +3981,7 @@ class HttpCli(object):
         if not allvols:
             ret = [{"kinshi": 1}]
 
-        jtxt = '{"u":%s,"c":%s}' % (uret, json.dumps(ret, indent=0))
+        jtxt = '{"u":%s,"c":%s}' % (uret, json.dumps(ret, separators=(",\n", ": ")))
         zi = len(uret.split('\n"pd":')) - 1
         self.log("%s #%d+%d %.2fsec" % (lm, zi, len(ret), time.time() - t0))
         self.reply(jtxt.encode("utf-8", "replace"), mime="application/json")
@@ -3909,7 +4142,17 @@ class HttpCli(object):
         e2d = "e2d" in vn.flags
         e2t = "e2t" in vn.flags
 
-        self.html_head += vn.flags.get("html_head", "")
+        add_og = "og" in vn.flags
+        if add_og:
+            if "th" in self.uparam or "raw" in self.uparam:
+                og_ua = add_og = False
+            elif self.args.og_ua:
+                og_ua = add_og = self.args.og_ua.search(self.ua)
+            else:
+                og_ua = False
+                add_og = True
+            og_fn = ""
+
         if "b" in self.uparam:
             self.out_headers["X-Robots-Tag"] = "noindex, nofollow"
 
@@ -3917,13 +4160,15 @@ class HttpCli(object):
         is_dk = False
         fk_pass = False
         icur = None
-        if is_dir and (e2t or e2d):
+        if (e2t or e2d) and (is_dir or add_og):
             idx = self.conn.get_u2idx()
             if idx and hasattr(idx, "p_end"):
-                icur = idx.get_cur(dbv.realpath)
+                icur = idx.get_cur(dbv)
 
         th_fmt = self.uparam.get("th")
-        if self.can_read or (self.can_get and vn.flags.get("dk")):
+        if self.can_read or (
+            self.can_get and (vn.flags.get("dk") or "fk" not in vn.flags)
+        ):
             if th_fmt is not None:
                 nothumb = "dthumb" in dbv.flags
                 if is_dir:
@@ -3970,7 +4215,7 @@ class HttpCli(object):
         elif self.can_write and th_fmt is not None:
             return self.tx_svg("upload\nonly")
 
-        elif self.can_get and self.avn:
+        if not self.can_read and self.can_get and self.avn:
             axs = self.avn.axs
             if self.uname not in axs.uhtml:
                 pass
@@ -4016,6 +4261,17 @@ class HttpCli(object):
                     self.log(t % (correct, got, self.req, abspath), 6)
                     return self.tx_404()
 
+            if add_og:
+                if og_ua or self.host not in self.headers.get("referer", ""):
+                    self.vpath, og_fn = vsplit(self.vpath)
+                    vpath = self.vpath
+                    vn, rem = self.asrv.vfs.get(self.vpath, self.uname, False, False)
+                    abspath = vn.dcanonical(rem)
+                    dbv, vrem = vn.get_dbv(rem)
+                    is_dir = stat.S_ISDIR(st.st_mode)
+                    is_dk = True
+                    vpnodes.pop()
+
             if (
                 (abspath.endswith(".md") or self.can_delete)
                 and "nohtml" not in vn.flags
@@ -4027,7 +4283,10 @@ class HttpCli(object):
             ):
                 return self.tx_md(vn, abspath)
 
-            return self.tx_file(abspath)
+            if not add_og or not og_fn:
+                return self.tx_file(
+                    abspath, None if st.st_size or "nopipe" in vn.flags else vn.realpath
+                )
 
         elif is_dir and not self.can_read:
             if self._use_dirkey(abspath):
@@ -4074,7 +4333,11 @@ class HttpCli(object):
         is_ls = "ls" in self.uparam
         is_js = self.args.force_js or self.cookies.get("js") == "y"
 
-        if not is_ls and (self.ua.startswith("curl/") or self.ua.startswith("fetch")):
+        if (
+            not is_ls
+            and not add_og
+            and (self.ua.startswith("curl/") or self.ua.startswith("fetch"))
+        ):
             self.uparam["ls"] = "v"
             is_ls = True
 
@@ -4148,6 +4411,7 @@ class HttpCli(object):
             "dsort": vf["sort"],
             "dcrop": vf["crop"],
             "dth3x": vf["th3x"],
+            "dvol": self.args.au_vol,
             "themes": self.args.themes,
             "turbolvl": self.args.turbo,
             "u2j": self.args.u2j,
@@ -4199,7 +4463,7 @@ class HttpCli(object):
 
         for k in ["zip", "tar"]:
             v = self.uparam.get(k)
-            if v is not None:
+            if v is not None and (not add_og or not og_fn):
                 return self.tx_zip(k, v, self.vpath, vn, rem, [])
 
         fsroot, vfs_ls, vfs_virt = vn.ls(
@@ -4213,6 +4477,10 @@ class HttpCli(object):
         ls_names = [x[0] for x in vfs_ls]
         ls_names.extend(list(vfs_virt.keys()))
 
+        if add_og and og_fn and not self.can_read:
+            ls_names = [og_fn]
+            is_js = True
+
         # check for old versions of files,
         # [num-backups, most-recent, hist-path]
         hist     = {}
@@ -4274,12 +4542,14 @@ class HttpCli(object):
                     margin = "DIR"
                 elif add_dk:
                     zs = absreal(fspath)
-                    margin = '<a href="%s?k=%s&zip" rel="nofollow">zip</a>' % (
+                    margin = '<a href="%s?k=%s&zip=crc" rel="nofollow">zip</a>' % (
                         quotep(href),
                         self.gen_fk(2, self.args.dk_salt, zs, 0, 0)[:add_dk],
                     )
                 else:
-                    margin = '<a href="%s?zip" rel="nofollow">zip</a>' % (quotep(href),)
+                    margin = '<a href="%s?zip=crc" rel="nofollow">zip</a>' % (
+                        quotep(href),
+                    )
             elif fn in hist:
                 margin = '<a href="%s.hist/%s">#%s</a>' % (
                     base,
@@ -4423,6 +4693,9 @@ class HttpCli(object):
         else:
             taglist = list(tagset)
 
+        if not files and not dirs and not readme and not logues[0] and not logues[1]:
+            logues[1] = "this folder is empty"
+
         if is_ls:
             ls_ret["dirs"] = dirs
             ls_ret["files"] = files
@@ -4474,6 +4747,148 @@ class HttpCli(object):
         if "mth" in vn.flags:
             j2a["def_hcols"] = list(vn.flags["mth"])
 
+        if add_og and "raw" not in self.uparam:
+            j2a["this"] = self
+            cgv["og_fn"] = og_fn
+            if og_fn and vn.flags.get("og_tpl"):
+                tpl = vn.flags["og_tpl"]
+                if "EXT" in tpl:
+                    zs = og_fn.split(".")[-1].lower()
+                    tpl2 = tpl.replace("EXT", zs)
+                    if os.path.exists(tpl2):
+                        tpl = tpl2
+                with self.conn.hsrv.mutex:
+                    if tpl not in self.conn.hsrv.j2:
+                        tdir, tname = os.path.split(tpl)
+                        j2env = jinja2.Environment()
+                        j2env.loader = jinja2.FileSystemLoader(tdir)
+                        self.conn.hsrv.j2[tpl] = j2env.get_template(tname)
+            thumb = ""
+            is_pic = is_vid = is_au = False
+            covernames = self.args.th_coversd
+            for fn in ls_names:
+                if fn.lower() in covernames:
+                    thumb = fn
+                    break
+            if og_fn:
+                ext = og_fn.split(".")[-1].lower()
+                if ext in self.thumbcli.thumbable:
+                    is_pic = (
+                        ext in self.thumbcli.fmt_pil
+                        or ext in self.thumbcli.fmt_vips
+                        or ext in self.thumbcli.fmt_ffi
+                    )
+                    is_vid = ext in self.thumbcli.fmt_ffv
+                    is_au = ext in self.thumbcli.fmt_ffa
+                    if not thumb or not is_au:
+                        thumb = og_fn
+                file = next((x for x in files if x["name"] == og_fn), None)
+            else:
+                file = None
+
+            url_base = "%s://%s/%s" % (
+                "https" if self.is_https else "http",
+                self.host,
+                self.args.RS + quotep(vpath),
+            )
+            j2a["og_is_pic"] = is_pic
+            j2a["og_is_vid"] = is_vid
+            j2a["og_is_au"] = is_au
+            if thumb:
+                fmt = vn.flags.get("og_th", "j")
+                th_base = ujoin(url_base, quotep(thumb))
+                query = "th=%s&cache" % (fmt,)
+                query = ub64enc(query.encode("utf-8")).decode("utf-8")
+                # discord looks at file extension, not content-type...
+                query += "/a.jpg" if "j" in fmt else "/a.webp"
+                j2a["og_thumb"] = "%s/.uqe/%s" % (th_base, query)
+
+            j2a["og_fn"] = og_fn
+            j2a["og_file"] = file
+            if og_fn:
+                og_fn_q = quotep(og_fn)
+                query = ub64enc(b"raw").decode("utf-8")
+                if "." in og_fn:
+                    query += "/a.%s" % (og_fn.split(".")[-1])
+
+                j2a["og_url"] = ujoin(url_base, og_fn_q)
+                j2a["og_raw"] = j2a["og_url"] + "/.uqe/" + query
+            else:
+                j2a["og_url"] = j2a["og_raw"] = url_base
+
+            if not vn.flags.get("og_no_head"):
+                ogh = {"twitter:card": "summary"}
+
+                title = str(vn.flags.get("og_title") or "")
+
+                if thumb:
+                    ogh["og:image"] = j2a["og_thumb"]
+
+                zso = vn.flags.get("og_desc") or ""
+                if zso != "-":
+                    ogh["og:description"] = str(zso)
+
+                zs = vn.flags.get("og_site") or self.args.name
+                if zs not in ("", "-"):
+                    ogh["og:site_name"] = zs
+
+                tagmap = {}
+                if is_au:
+                    title = str(vn.flags.get("og_title_a") or "")
+                    ogh["og:type"] = "music.song"
+                    ogh["og:audio"] = j2a["og_raw"]
+                    tagmap = {
+                        "artist": "og:music:musician",
+                        "album": "og:music:album",
+                        ".dur": "og:music:duration",
+                    }
+                elif is_vid:
+                    title = str(vn.flags.get("og_title_v") or "")
+                    ogh["og:type"] = "video.other"
+                    ogh["og:video"] = j2a["og_raw"]
+                    tagmap = {
+                        "title": "og:title",
+                        ".dur": "og:video:duration",
+                    }
+                elif is_pic:
+                    title = str(vn.flags.get("og_title_i") or "")
+                    ogh["twitter:card"] = "summary_large_image"
+                    ogh["twitter:image"] = ogh["og:image"] = j2a["og_raw"]
+
+                try:
+                    for k, v in file["tags"].items():
+                        zs = "{{ %s }}" % (k,)
+                        title = title.replace(zs, str(v))
+                except:
+                    pass
+                title = re.sub(r"\{\{ [^}]+ \}\}", "", title)
+                while title.startswith(" - "):
+                    title = title[3:]
+                while title.endswith(" - "):
+                    title = title[:3]
+
+                if vn.flags.get("og_s_title") or not title:
+                    title = str(vn.flags.get("og_title") or "")
+
+                for tag, hname in tagmap.items():
+                    try:
+                        v = file["tags"][tag]
+                        if not v:
+                            continue
+                        ogh[hname] = int(v) if tag == ".dur" else v
+                    except:
+                        pass
+
+                ogh["og:title"] = title
+
+                oghs = [
+                    '\t<meta property="%s" content="%s">'
+                    % (k, html_escape(str(v), True, True))
+                    for k, v in ogh.items()
+                ]
+                zs = self.html_head + "\n%s\n" % ("\n".join(oghs),)
+                self.html_head = zs.replace("\n\n", "\n")
+
         html = self.j2s(tpl, **j2a)
         self.reply(html.encode("utf-8", "replace"))
         return True

copyparty/httpconn.py

@@ -52,6 +52,7 @@ class HttpConn(object):
         self.E  = self.args.E
         self.asrv  = hsrv.asrv  # mypy404
         self.u2fh  = hsrv.u2fh  # mypy404
+        self.pipes  = hsrv.pipes  # mypy404
         self.ipa_nm  = hsrv.ipa_nm
         self.xff_nm  = hsrv.xff_nm
         self.xff_lan  = hsrv.xff_lan  # type: ignore

copyparty/httpsrv.py

@@ -61,6 +61,7 @@ from .u2idx import U2idx
 from .util import (
     E_SCK,
     FHC,
+    CachedDict,
     Daemon,
     Garda,
     Magician,
@@ -126,6 +127,7 @@ class HttpSrv(object):
         self.t_periodic  = None
 
         self.u2fh = FHC()
+        self.pipes = CachedDict(0.2)
         self.metrics = Metrics(self)
         self.nreq = 0
         self.nsus = 0