--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/dejsem.1.5/python/dejsem.pycharm/server.py Wed Nov 27 09:50:16 2019 +0100
@@ -0,0 +1,600 @@
+#!/usr/bin/python3
+# coding=utf8
+
+import os, sys, subprocess, random, string, traceback, urllib.parse
+from os.path import join
+from d import D
+from parms import Parms
+from node import Node
+
+
+# operace v nekonečném cyklu serveru:
+# - pro každý kanál v homedir je jedna instance Server
+# - každá instance má k dispozici 10 portů pro LISTEN
+# - číslování portů:
+# - 17CCP
+# - CC = číslo kanálu
+# - P = číslo portu v kanálu
+# - port 17xx0 je vyhrazen pro rychlé synchronní operace serveru - commands
+# - porty 17xx1-9 jsou pro long running tasks
+
+"""
+ server pro určitý uživatelský kanál
+ instance vytváří a spouští main.py
+"""
+class Server():
+
+ def __init__(self, d, chan):
+ self._baseid = "{}.server[{:02d}]".format(d.debid, chan)
+ self.d = D("{}".format(self._baseid))
+
+ Parms.clientMode = False
+ Parms.sslCert = join(Parms.sslPath, "srv.pem")
+ self.d.log("ssl path: {}".format(Parms.sslPath), sev=3)
+
+ self._chan = chan
+ self._homedir = join(Parms.srv_homedir, "{:02d}".format(self._chan))
+ os.chdir(self._homedir)
+ self.d.log("working dir={}, ls: {}".format(os.getcwd(), os.listdir(), sev=4))
+ os.umask(0o077)
+
+ self._filedir = join(self._homedir, Parms.filedir)
+
+ try:
+ self._node = Node(self.d, host='', chan=self._chan, conn=False, tryPort=False)
+ except Exception as e:
+ self.d.abend("creating network node", e)
+ sys.exit(1)
+ self.server()
+
+ def server(self):
+ # v této metodě server poslouchá na základním portu v kanálu (port 0);
+ # po připojení klienta alokuje socket a synchronně cyklicky volá metodu service() k provedení příkazu klienta;
+ # cyklus volání service() trvá dokud service() nevrátí False;
+ # smyslem cyklu před novým acceptem je dát možnost klientu provést rychlou dávku příkazů proveditelných okamžitě;
+ if not os.path.exists(Parms.clipfile):
+ os.system("touch " + Parms.clipfile)
+ if not os.path.exists(Parms.filedir):
+ os.mkdir(Parms.filedir)
+ while True:
+ try:
+ if self._node.acc(acc_TO=None):
+ while self.service(): pass
+ except KeyboardInterrupt:
+ self.d.log("accept: KeyboardInterrupt")
+ break
+ if self.d.ll(4): self.d.log("closing ssc...")
+ self._node.close_ssc()
+
+ def service(self):
+ # metoda synchronně ("blocking") dostává ze socketu příkaz klienta, provede ho
+ # a vrací true, když chce nechat socket otevřený a false, když se může socket zavřít;
+ # socket se nechává otevřený, když má smysl provádět danou operaci v dávce;
+ # je na klientu, aby dávka byla krátká a aby zavřel neprodleně
+ cmd = ""
+ try:
+ if self.d.ll(2): self.d.log("get command...")
+ random.getrandbits(16)
+ cmd = self._node.getcmd() # čtení osmi-znakového příkazu
+ if self.d.ll(5): self.d.log("cmd len={}".format(len(cmd)))
+ if not cmd: return False
+ if self.d.ll(3): self.d.log("cmd={}".format(cmd))
+ # názvy operací pull/push odpovídají pohledu klienta;
+ # operace jsou synchronní, blokují další příkazy v daném kanále a musí být v "lidském" měřítku krátké;
+ # dlouhé operace se zahajují příkazem LONGTASK, po němž se alokuje paralelní nit k provedení dlouhé operace (typicky přenosu dat);
+ if cmd == "PULLCLIP": # přenos posledního uloženého clipboardu na klienta
+ return self.cmd_pullclip()
+ elif cmd == "PULLHIST": # přenos přehledu uložených clipboard entries na klienta
+ return self.cmd_pullhist()
+ elif cmd == "PULLLIST": # přenos seznamu souborů v adresáři na klienta
+ return self.cmd_pulllist()
+ elif cmd == "PUSHCLIP": # příjem nového clipboardu k uložení na serveru
+ return self.cmd_pushclip()
+ elif cmd == "GETPEER": # předání uložené peer-adresy klientu
+ return self.cmd_getpeer()
+ elif cmd == "SETPEER": # příjem peer-adresy k uložení na serveru
+ return self.cmd_setpeer()
+ elif cmd == "MOVE": # přesun uloženého souboru/adresáře v rámci serveru
+ return self.cmd_move()
+ elif cmd == "EXPOSE": # vystavení souboru/adresáře na http-serveru - vrací se URI path
+ return self.cmd_expose()
+ elif cmd == "HIDE": # zakrytí souboru/adresáře pro http-server
+ return self.cmd_hide()
+ elif cmd == "DELETE": # rekurzivní výmaz souboru/adresáře na serveru
+ return self.cmd_delete()
+ elif cmd == "CREATDIR": # založení adresáře na serveru
+ return self.cmd_createdir()
+ elif cmd == "FREE": # předání informace o volném prostoru na serveru
+ return self.cmd_freespace()
+ elif cmd == "RECKON": # předání informace o velikost souboru/adresáře
+ return self.cmd_reckon()
+ elif cmd == "LONGTASK": # zahájení operace v jiném procesu na jiném portu
+ return self.cmd_longtask()
+ elif cmd == "HACK":
+ self.d.log("hack")
+ return False
+ else:
+ if self.d.ll(4): self.d.log("unknown command")
+ self._node.close_sc()
+ return False
+ except KeyboardInterrupt:
+ raise
+ except Exception as e:
+ # if self.d.ll(4): self.d.log("service {} aborted: {}: {}".format(cmd, e.__class__.__name__, str(e)))
+ if self.d.ll(4): self.d.log("service {} aborted: {}".format(cmd, e))
+ traceback.print_tb(sys.exc_info()[2])
+ self._node.close_sc()
+ return False
+
+ def cmd_longtask(self):
+ """
+ najde volný port 1-9, pošle ho klientovi, forkne se do paralelního procesu v němž
+ čeká na připojení klienta, čte příkaz k operaci a provádí operaci
+ - operace se nedávkují, na konci procesu se socket a serversocket zavírají a port uvolňuje
+ - ssc, port = self._node.bindtrynext(Parms.srvhost)
+ """
+ try:
+ longtaskNode = Node(self.d, host='', chan=self._chan, tryPort=True, conn=False)
+ except Node.AllPortsBusy:
+ self._node.sendport(0)
+ return False
+ self._node.sendport(longtaskNode.port)
+ self._node.close_sc()
+ if os.fork():
+ return False
+ # subprocess --------------
+ self._node = longtaskNode
+ self.d.debid = "{} long task[{:d}]".format(self._baseid, self._node.port)
+ random.seed() # je potřeba se odstřihnout od random-sekvence hlavního procesu
+ try:
+ if self._node.acc(acc_TO=Parms.long_run_accept_timeout):
+ while self.longserv(): pass # cykluj, dokud je longserv positivní
+ except Exception as e:
+ self.d.abendMsg("long task accept", e=e)
+ self._node.close_sc()
+ self._node.close_ssc()
+ os._exit(0)
+
+ def longserv(self):
+ cmd = self._node.getcmd()
+ if not cmd: return False
+ try:
+ if self.d.ll(4): self.d.log("longtask cmd: " + cmd)
+ # názvy operací pull/push odpovídají pohledu klienta
+ if cmd == "PUSHFILE": # rekurzivní příjem souboru/adresáře k uložení na serveru
+ return self.cmd_pushfile()
+ elif cmd == "PUSHFIEX": # rekurzivní příjem souboru/adresáře k vystavení na http serveru
+ return self.cmd_pushFileExpose()
+ elif cmd == "PUSHSTEX": # příjem streamu k vystavení na http serveru
+ return self.cmd_pushStreamExpose()
+ elif cmd == "PULLFILE": # rekurzivní odeslání obsahu souboru/adresáře
+ return self.cmd_pullfile()
+ elif cmd == "PULLCLIP": # využije se pro dávkovou synchronizaci historie clipboardu
+ return self.cmd_pullclip()
+ elif cmd == "PULLHIST": # využije se pro dávkovou synchronizaci historie clipboardu
+ return self.cmd_pullhist()
+ elif cmd == "ECHO":
+ return self.ee(cmd)
+ elif cmd == "ECHOECHO":
+ return self.ee(cmd)
+ elif cmd == "HACK":
+ return self.rand(6)
+ else:
+ return False
+ except Exception as e:
+ self.d.abendMsg("long task action {}".format(cmd), e=e)
+ return False
+
+ def rand(self, n):
+ for i in range(n):
+ self.d.log("{:04x}".format(random.getrandbits(16)))
+ return False
+
+ def ee(self, cmd):
+ self.d.log("ECHO.004: cmd={}".format(cmd))
+ while cmd == "ECHO____" or cmd == "ECHOECHO":
+ self.d.log("echoing...")
+ self._node.putstr("ECHO")
+ if cmd == "ECHOECHO": self.d.log("echo, got={}".format(self._node.getfn()))
+ self.d.log("waiting for cmd")
+ cmd = self._node.getcmd()
+ self.d.log("cmd got={}".format(cmd))
+ self.d.log("waiting for close")
+ self._node.get(1) # wait for other side close
+
+ def cmd_pullfile(self):
+ # operace download, v níž může klient dávkovat příkazy PULLFILE ke stažení objektů
+ cmd = "PULLFILE"
+ while cmd == "PULLFILE":
+ req = self.formpath(self._node.getfn())
+ if req:
+ fp = os.path.normpath(join(Parms.filedir, req))
+ if os.path.exists(fp):
+ prefix = os.path.dirname(fp)
+ if self.d.ll(3): self.d.log("pullfile request for '{}': starting...".format(fp))
+ self.pullfilerecurse(fp, prefix)
+ else:
+ if self.d.ll(3): self.d.log("pullfile request for '{}': not found".format(fp))
+ self._node.sendEOD() # end of recursive subtree of files
+ cmd = self._node.getcmd() # another PULLFILE is expected here
+ self._node.getcmd() # wait for other side close
+ return False # konec dávky
+
+ def pullfilerecurse(self, fp, prefix):
+ if os.path.isdir(fp):
+ for cwd, void, files in os.walk(fp, topdown=False):
+ for entry in files:
+ self.pullfilerecurse(join(cwd, entry), prefix)
+ self._node.putfileinfo(cwd, os.path.relpath(cwd, start=prefix))
+ else:
+ self._node.putfileinfo(fp, os.path.relpath(fp, start=prefix))
+ with open(fp, mode='rb') as f:
+ g = self._node.genput()
+ g.send(None)
+ data = f.read(Parms.bufSize)
+ while data:
+ try:
+ g.send(data)
+ data = f.read(Parms.bufSize)
+ except Exception:
+ break
+ g.close()
+ if self.d.ll(3): self.d.log("PULLFILE: entry {} sent".format(fp))
+
+ def cmd_pushfile(self):
+ # předpokládá se, že subadresáře, do nichž se přijímá, jsou vždycky writable, vznikly uploadem
+ if self.d.ll(4): self.d.log("push file start")
+ cmd = "PUSHFILE"
+ while cmd == "PUSHFILE":
+ req = self._node.getfn() # relativní cesta
+ while len(req) > 0: # rekurzivní načtení stromu - končí prázdným req
+ req = self.formpath(req)
+ uploadPath = join(Parms.filedir, req)
+ size = self._node.getnum()
+ timestamp = self._node.getnum()
+ if self.d.ll(4): self.d.log("push: req={} to=[{}, dir={}]...".format(req, uploadPath, size == -1))
+ if size < 0:
+ self._node.receive_dir(uploadPath, size, timestamp)
+ else:
+ self._node.receive_file(uploadPath, size, timestamp)
+ req = self._node.getfn()
+ cmd = self._node.getcmd() # PUSHFILE or BATCHEND is expected here
+ if self.d.ll(4): self.d.log("cmd_pushfile(), iterace v dávce, cmd={}".format(cmd))
+ self._node.putnum(0) # client awaits end of transfer confirmation
+ if self.d.ll(4): self.d.log("push file finished")
+ return False # konec dávky
+
+ def cmd_pushFileExpose(self):
+ """
+ Upload and Expose to HTTP
+ ● klient posílá na pozadí objekt, který se vystaví na http-serveru
+ ● objekt se ukládá do zvláštního adresáře self._exposed pod randomizovaným jménem
+ ● klientovi se posílá segment "path" z výsledného URL, URL si zkomletuje klient
+ ● metoda vrací False, protože se expose nedávkuje
+ :return: False
+ """
+ if self.d.ll(4): self.d.log("push and expose file start")
+ self.link_exposed()
+ req = self._node.getfn() # relativní cesta
+ if len(req) > 0:
+ stem, void, rest = self.formpath(req).partition('/')
+ exposedPath = self.randomize_path(stem, self._exposed)
+ while len(req) > 0: # rekurzivní načtení stromu - končí prázdným req
+ uploadPath = join(self._exposed, exposedPath)
+ void, void, rest = self.formpath(req).partition('/')
+ if rest: uploadPath = join(uploadPath, rest)
+ size = self._node.getnum()
+ timestamp = self._node.getnum()
+ if self.d.ll(4): self.d.log("push to '{}, dir={}'...".format(uploadPath, size == -1))
+ if size < 0:
+ self._node.receive_dir(uploadPath, size, timestamp)
+ else:
+ self._node.receive_file(uploadPath, size, timestamp)
+ req = self._node.getfn() # relativní cesta
+ self.d.log("{} uploaded".format(exposedPath))
+ self.expose_link(exposedPath)
+ if self.d.ll(4): self.d.log("push and expose file end")
+ else:
+ self.node.putnum(0)
+ return False # konec, expose se nedávkuje
+
+ def cmd_pushStreamExpose(self):
+ """
+ Upload and Expose to HTTP
+ ● klient posílá na pozadí stream, který se vystaví na http-serveru
+ ● stream se ukládá do zvláštního adresáře self._exposed pod randomizovaným jménem
+ ● klientovi se posílá segment "path" z výsledného URL, URL si zkomletuje klient
+ ● metoda vrací False, protože se expose nedávkuje
+ :return: False
+ """
+ if self.d.ll(4): self.d.log("push and expose stream start")
+ expName, origName = None, Node
+ mimeType = self._node.getstr()
+ size = self._node.getnum()
+ if size > 0:
+ self.link_exposed()
+ (type, suffix) = mimeType.split('/')
+ if not type or type == '*': type = "content"
+ expName = self.randomize_path(type, self._exposed)
+ if suffix and suffix != '*': expName += '.' + suffix
+ expPath = join(self._exposed, expName)
+ if self.d.ll(4): self.d.log("push stream to '{}'...".format(expPath))
+ self._node.receive_stream(expPath, size)
+ # subprocess.run(('touch', expPath))
+ self.expose_link(expName)
+ if self.d.ll(4): self.d.log("push stream to '{}' finished".format(expPath))
+ else:
+ """self.node.putnum(0)"""
+ return False # konec dávky
+
+ def cmd_pulllist(self):
+ req = self.formpath(self._node.getfn())
+ if req:
+ fp = os.path.normpath(join(Parms.filedir, req))
+ if self.d.ll(4): self.d.log("dir=" + fp)
+ if os.path.exists(fp) and os.access(fp, os.R_OK | os.X_OK):
+ if os.path.isdir(fp):
+ for entry in os.listdir(path=fp):
+ self._node.putfileinfo(join(fp, entry), entry)
+ else:
+ self._node.putfileinfo(fp, req)
+ self._node.putnum(0)
+ self._node.close_sc()
+ return False # konec dávky
+
+ def cmd_pullclip(self):
+ fn = self._node.getfn()
+ if fn == "":
+ fp = Parms.clipfile
+ else:
+ fp = Parms.histdir + "/" + fn
+ if self.d.ll(4):
+ self.d.log("clip fp={}".format(fp))
+ if os.path.exists(fp):
+ self._node.putnum(os.path.getsize(fp))
+ with open(fp, mode="rb") as f:
+ g = self._node.genput()
+ g.send(None)
+ data = f.read(Parms.bufSize)
+ while len(data) > 0:
+ try:
+ g.send(data)
+ data = f.read(Parms.bufSize)
+ except Exception:
+ break
+ g.close()
+ return True # případné dávkování
+
+ def cmd_pushclip(self):
+ with open(Parms.clipfile, mode='wb') as f:
+ for data in self._node.genget(size = -1):
+ f.write(data)
+ self._node.close_sc()
+ subprocess.call(("cp", "-a", Parms.clipfile, join(Parms.histdir, self.hist_fn())))
+ if self.d.ll(4): self.d.log("pushclip: {} bytes stored".format(os.path.getsize(Parms.clipfile)))
+ return False # konec dávky
+
+ def hist_fn(self): # random string file name
+ if not os.path.exists(Parms.histdir):
+ os.mkdir(Parms.histdir)
+ a = (string.digits + string.ascii_letters)
+ fn = ""
+ for i in list(range(5)):
+ fn += a[random.randint(0, 61)]
+ while os.path.exists(join(Parms.histdir, fn)):
+ fn = ""
+ for i in list(range(5)):
+ fn += a[random.randint(0, 61)]
+ return fn
+
+ def cmd_pullhist(self):
+ if os.path.exists(Parms.histdir) and os.path.isdir(Parms.histdir):
+ for entry in os.listdir(Parms.histdir):
+ p = join(Parms.histdir, entry)
+ self._node.putstr(entry)
+ sample = open(p, mode="rb").read(80) # pošli vzorek max.80 z každého entry
+ self._node.putnum(len(sample))
+ self._node.put(sample)
+ self._node.putnum(os.path.getsize(p))
+ self._node.putnum(int(os.path.getmtime(p)))
+ self._node.putnum(0) # konec streamu
+ return True
+
+ def cmd_expose(self):
+ """
+ Expose to HTTP
+ ● klient posílá jméno objektu na serveru, který se má vystavit na http-serveru
+ ● jméno je cesta relativní k self._filedir
+ ● objekt se symlinkuje ve zvláštním adresáři self._exposed randomizovaným jménem odvozeným ze jména objektu
+ ● klientovi se posílá segment "path" z výsledného URL, URL si zkompletuje klient
+ ● metoda vrací False, protože se expose nedávkuje
+ :return: False
+ """
+ fpath = join(self._filedir, self.formpath(self._node.getfn())) # node.getfn() je cesta relativně k self._filedir
+ self.link_exposed()
+ expName = self.randomize_path(os.path.basename(fpath), self._exposed)
+ expPath = join(self._exposed, expName)
+ subprocess.run(('ln', '-sfnr', fpath, expPath), check=True)
+ if self.d.ll(3): self.d.log("fn={}".format(expPath))
+ self.expose_link(expName)
+ return False # expose nemůže být v dávce, protože se klientovi posílá zpátky URI path
+
+ def cmd_hide(self):
+ fpath = self.formpath(self._node.getfn())
+ if self.d.ll(3): self.d.log("fn={}".format(fpath))
+ channel = "{:02d}".format(self._chan)
+ fpath = join(Parms.srv_homedir, channel, Parms.filedir, fpath)
+ subprocess.run(('chmod', '-R', 'o-rwx', fpath))
+ subprocess.run(('find', fpath, '-name', '.htaccess', '-exec', 'rm', '-f', '{}', '+'))
+ return True # případné dávkování
+
+ def cmd_getpeer(self): # atavismus z doby před použitím UDP broadcast
+ host = ""
+ port = 0
+ if len(self.peer) == 2:
+ host = "10.0.2.2" if self.peer[0] == "10.0.2.15" else str(self.peer[0])
+ port = self.peer[1]
+ self.peer = []
+ self._node.putstr(host)
+ self._node.putnum(port)
+ self._node.close_sc()
+ return False
+
+ def cmd_setpeer(self): # atavismus z doby před použitím UDP broadcast
+ self.peer = (str(self._node.getfn()), int(self._node.getnum()))
+ self._node.close_sc()
+ return False
+
+ def cmd_move(self):
+ orig = self.formpath(self._node.getfn())
+ target = self.formpath(self._node.getfn())
+ if orig and target:
+ if self.d.ll(4): self.d.log("performing mv -n {} {}".format(orig, target))
+ subprocess.call(["mv", "-n", join(Parms.filedir, orig), join(Parms.filedir, target)])
+ return True # případné dávkování
+
+ def cmd_delete(self):
+ req = self.formpath(self._node.getfn())
+ if req:
+ if self.d.ll(4): self.d.log("performing rm -rf {}".format(req))
+ subprocess.call(["rm", "-rf", join(Parms.filedir, req)])
+ return True # případné dávkování
+
+ def cmd_createdir(self):
+ req = self.formpath(self._node.getfn())
+ if req:
+ fp = join(Parms.filedir, req)
+ if self.d.ll(4): self.d.log("performing mkdir -p {}".format(fp))
+ subprocess.call(["mkdir", "-p", fp])
+ return True # případné dávkování
+
+ def cmd_freespace(self):
+ # df v Debianu 7.6 nemá parametr --output :-(
+ p = subprocess.Popen(["df", "--block-size=1", "."], stdout=subprocess.PIPE)
+ p.wait()
+ if p.returncode == 0:
+ free = int(p.stdout.readlines()[1].decode().split()[3])
+ else:
+ free = -1
+ self._node.putnum(free)
+ self._node.close_sc()
+ return True # případné dávkování
+
+ def cmd_reckon(self):
+ req = self.formpath(self._node.getfn())
+ self.sendobjectsize(join(Parms.filedir, req) if req else None)
+ return True # případné dávkování
+
+ def sendobjectsize(self, fp):
+ if not fp or not os.path.exists(fp):
+ size, fnum, dnum = (0, 0, 0)
+ elif os.path.isfile(fp):
+ size, fnum, dnum = (os.path.getsize(fp), 1, 0)
+ else:
+ size, fnum, dnum = self.dirsize(fp)
+ self._node.putnum(int(size))
+ self._node.putnum(int(fnum))
+ self._node.putnum(int(dnum))
+
+ def link_exposed(self):
+ """
+ ● založení adresáře pro vystavené objekty self._exposed podle Parms.exposed
+ ● adresář je symlinkován z http-serveru číslem kanálu
+ ● symlink z http-serveru musí vytvořit instalace nebo super-user
+ ● na http-serveru se při instalaci aplikace zakládá adresář pro tuto aplikaci se symlinky na exposed dirs jednotlivých kanálů
+ ● <http_server>/<appl_name>/<kanál> --> <appl_home>/<kanál>/<files>/<exposed>
+ ● <http_server>/<appl_name> musí mít povoleny symlinky a povolen( instalovat .htaccess s Options Indexes
+ ● http-server musí mít x-access po cestě <http_server>/<appl_name>/<kanál> --> <exposed>
+ ● výšeuvedené atributy se nemůže zařídit aplikace, musí být nastaveny při instalaci nebo administrátorem
+ """
+ self._exposed = join(self._filedir, Parms.exposed)
+ if not os.path.exists(self._exposed):
+ subprocess.run(('mkdir', '-pm771', self._exposed))
+ # os.mkdir(self._exposed, mode=0o771)
+ channel = "{:02d}".format(self._chan)
+ self._wwwhome = join(Parms.srv_wwwhomedir, channel)
+ if not os.path.exists(self._wwwhome):
+ subprocess.run(('ln', '-sfnr', self._exposed, self._wwwhome), check=True)
+
+ def expose_link(self, path):
+ """
+ ● fpath je cesta relativní k self._exposed
+ ● úkolem je zařídit read-access k filům, x-access k dirs, případně .htacess v kořenu stromu
+ """
+ orig = join(self._exposed, path)
+ self.d.log("orig={}".format(orig), sev=4)
+ try:
+ subprocess.run(('chmod', 'o+r', orig), check=True)
+ if os.path.isdir(orig):
+ self.expose_dir_tree(orig)
+ elif path.find('/') > 0:
+ self.expose_dir_path(path)
+ channel = "{:02d}".format(self._chan)
+ # uriPath = urllib.parse.quote(join(Parms.applName, channel, path))
+ uriPath = join(Parms.applName, channel, path)
+ self._node.putstr(uriPath) # pošli URL-path klientovi
+ self.d.log("uri path {} sent".format(uriPath), sev=3)
+ except Exception as e:
+ self.d.abend("exposing file to web server", e)
+
+ def expose_dir_path(self, rel_file_path):
+ """
+ po cestě k vystavenému souboru je potřeba nastavit x-access pro http-server
+ :param rel_file_path: cesta relativní k self._exposed
+ """
+ base = self._exposed
+ while rel_file_path:
+ subprocess.run(('chmod', 'o=x', base))
+ (subdir, sep, rel_file_path) = rel_file_path.partition('/')
+ base = join(base, subdir)
+
+ def expose_dir_tree(self, rel_dir_path):
+ """
+ do vystaveného stromu je třeba umístit .htaccess, po cestě nastavit x-access, ve stromu nastavit rx-access
+ :param rel_dir_path: cesta relativní k self._exposed
+ """
+ htaccess = join(rel_dir_path, ".htaccess")
+ with open(htaccess, mode="w") as f:
+ f.write("Options Indexes")
+ subprocess.run(('chmod', 'o+r', htaccess))
+ subprocess.run(('chmod', 'o+x', rel_dir_path))
+ subprocess.run(('chmod', '-R', 'o+r', rel_dir_path))
+ for (rel_dir_path, dirs, files) in os.walk(rel_dir_path):
+ for dir in dirs:
+ dpath = join(rel_dir_path, dir)
+ subprocess.run(('chmod', 'o+x', dpath))
+
+ def randomize_path(self, fn, dirname):
+ name, void, suff = os.path.basename(fn).rpartition(".")
+ expName = ""
+ while os.path.exists(join(dirname, expName)) or expName == "":
+ uniq = "{:04x}".format(random.getrandbits(16))
+ if name:
+ expName = name + "." + uniq + "." + suff
+ else:
+ expName = suff + "." + uniq
+ return expName
+
+ def dirsize(self, fp):
+ if self.d.ll(4): self.d.log("performing du -sb '{}'".format(fp))
+ try:
+ size = subprocess.check_output(["du", "-sb", fp])[:-1].decode().split("\t")[0]
+ fnum = len(subprocess.check_output(["find", fp, "-type", "f"]).split(b'\n'))-1
+ dnum = len(subprocess.check_output(["find", fp, "-type", "d"]).split(b'\n'))-1
+ except subprocess.CalledProcessError:
+ (size, fnum, dnum) = (-1, 0, 0)
+ if self.d.ll(5): self.d.log("size={}, type={}, fnum={}. type={}, dnum={}, type={}"
+ .format(size, type(size), fnum, type(fnum), dnum, type(dnum)))
+ return (size, fnum, dnum)
+
+ def close_sc(self):
+ self._node.close_sc()
+
+ def formpath(self, path):
+ """
+ - v žádném případě absolutní cesta
+ - vrací None, když path jde up from current
+ """
+ if path.startswith('/'): path = path[1:]
+ p = os.path.normpath(path)
+ return None if p == '..' or p.startswith('../') else p
\ No newline at end of file