#!/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