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