import threading

from hashtree import HashTree

def timeF(f):

	f()

def fullRead():

		while block:

def selectedRead():

	with open("/home/laman/blocks.txt") as f:

		for i2 in blocks:

			if i1+1!=i2:

				f.seek(i2*HashTree.BLOCK_SIZE)

def lessSelectedRead():

	with open("/home/laman/blocks.txt") as f:

		for i2 in blocks:

			if i2<=i1+8:

			else:

				f.seek(i2*HashTree.BLOCK_SIZE)

def shortSockets():

	def _server():

		serverSock.listen(1)

		for i in range(10000):

			sock, address = serverSock.accept()

			with sock.makefile(mode="rb") as fr, sock.makefile(mode="wb") as fw:

				fr.readline()

			sock.shutdown(socket.SHUT_RDWR)

			sock.close()

		serverSock.close()

	def _client():

		for i in range(10000):

			sock.connect(("127.0.0.1", 12329))

			with sock.makefile(mode="rb") as fr, sock.makefile(mode="wb") as fw:

				fw.write(b"x"*4096+b"\n")

				fw.flush()

			sock.shutdown(socket.SHUT_RDWR)

			sock.close()

	s.start()

	c.start()

	s.join()

	c.join()

def longSockets():

	def _server():

		serverSock.listen(1)

		sock, address = serverSock.accept()

		with sock.makefile(mode="rb") as fr, sock.makefile(mode="wb") as fw:

			for i in range(10000):

				fr.readline()

		sock.shutdown(socket.SHUT_RDWR)

		sock.close()

		serverSock.close()

	def _client():

		sock.connect(("127.0.0.1", 12330))

		with sock.makefile(mode="rb") as fr, sock.makefile(mode="wb") as fw:

			for i in range(10000):

					fw.write(b"x"*4096+b"\n")

					fw.flush()

		sock.shutdown(socket.SHUT_RDWR)

		sock.close()

	s.start()

	c.start()

	s.join()

	c.join()

# timeF(fullRead) # 85.40341448783875 s

from datetime import datetime

import config as conf

import status

import stats

from util import Progress

from datafile import DataFile

class DeniedConnection(Exception): pass

class Connection(BaseConnection):

		super().__init__()

		try:

			log.exception(e)

			raise FailedConnection()

		except ssl.SSLError as e:

			log.exception(e)

			raise FailedConnection()

		self.createNetworkers()

		print("Connected to {0}".format(host))

class Client(NetNode):

		print(datetime.now(), "initializing...")

		self._outcoming.writeMsg(jsonData)

		if jsonData["command"]=="deny":

			if jsonData["status"]==status.incompatible.version:

				raise DeniedConnection("Incompatible client version. Consider upgrading it.")

			raise DeniedConnection()

		assert jsonData["command"]=="init"

		if jsonData["version"]<conf.lowestCompatible:

	## Asks server for node hashes to determine which are to be transferred.

	#

	# Uses a binary HashTree, where item at k is hash of items at 2k+1, 2k+2.

	#

	# Requests nodes in order of a batch DFS. Needs stack of size O(treeDepth*batchSize). Nodes in each tree level are accessed in order.

	def negotiate(self):

		# determine which blocks to send

		print(datetime.now(), "negotiating:")

		while len(nodeStack)>0:

			for i in range(conf.batchSize.hash):

				indices.append(nodeStack.pop())

				if len(nodeStack)==0: break

			self._outcoming.writeMsg({"command":"req", "index":indices, "dataType":"hash"})

			assert jsonData["index"]==indices

			assert jsonData["dataType"]=="hash"

			stats.logExchangedNode(len(indices))

				if localTree.store[i]!=binData[j1:j2]:

					# ie. 0-6 nodes, 7-14 leaves. 2*6+2<15

					if 2*i+2<len(localTree.store): # inner node

						frontier.append(2*i+1)

						frontier.append(2*i+2)

					else:

						blocksToTransfer.append(i-localTree.leafStart) # leaf

						progress.p(i-localTree.leafStart)

			nodeStack.extend(reversed(frontier))

		progress.done()

		print(datetime.now(), "{0} to transfer".format(size))

		return blocksToTransfer

		log.info(blocksToTransfer)

		print(datetime.now(), "sending data:")

		progress=Progress(len(blocksToTransfer))

			for j in range(conf.batchSize.data):

				if k+j>=len(blocksToTransfer): break

				indices.append(i)

				blocks.append(block)

				progress.p(k+j)

		progress.done()

		log.info("closing session...")

		dataFile.close()

		if not ignoreLock:

			try:

				self._lock()

			except LockedException:

				print("The file is locked. Either (a) there's another pull going on (then wait or kill it), or (b) a previous pull ended prematurely and the file is probably corrupt (then repeat pull with -f for force).")

				return

		log.info(blocksToTransfer)

		print(datetime.now(), "receiving data:")

			self._outcoming.writeMsg({"command":"req", "index":indices, "dataType":"data"})

			assert jsonData["command"]=="send" and jsonData["index"]==indices and jsonData["dataType"]=="data", jsonData

				if self._treeFile:

				stats.logTransferredBlock()

				progress.p(k+j)

		progress.done()

		self._outcoming.writeMsg({"command":"end"})

		dataFile.close()

		self._unlock()

		if self._treeFile:

			self._updateTree()

		stats.logTransferredBlock(len(indices))

		assert jsonData["command"]=="ack" and jsonData["index"]==indices, jsonData

conf = dict()

if os.path.isfile(configFile):

	with open(configFile) as f: conf = json.load(f)

logFile = conf.get("logFile", "/var/log/morevna/mor.log")

logger.setLevel(log.INFO)

handler = TimedRotatingFileHandler(logFile, when="midnight", backupCount=9)

handler.setFormatter(formatter)

logger.addHandler(handler)

class batchSize:

from hashtree import HashTree

class DataFile:

	@staticmethod

		if i!=self._lastIndex+1:

			self._f.seek(i*BLOCK_SIZE)

		self._f.write(blockData)

		if i!=self._lastIndex+1:

			self._f.seek(i*BLOCK_SIZE)

		return self._f.read(byteCount)

	def close(self):

		self._f.close()

def hashBlock(data):

	return hashlib.sha256(data).digest()[-HashTree.HASH_LEN:]

class HashTree:

	## Prepares a tree containing leafCount leaves.

	@classmethod

			print(datetime.now(), "hashing file:")

			for i in range(leafCount):

				res.insertLeaf(hashBlock(data))

				progress.p(i)

			progress.done()

		res.buildTree()

		return res

	@classmethod

			for i in range(nodeCount):

		return res

			for h in self.store:

				f.write(h)

	## Inserts a leaf at the first empty position.

	#

	#	Useful and used only during the tree construction.

	def insertLeaf(self,h):

	## Updates a hash stored in the leaf.

		if index<self.leafStart: raise IndexError()

		self.updateNode((index-1)//2)

	## Updates the node at index and all its ancestors.

		while index>=0:

	## Fast construction of the tree over the leaves. O(n).

	def buildTree(self):

		print(datetime.now(), "building tree:")

		progress=Progress(-1, self.leafStart-1)

			progress.p(i)

		progress.done()

	## Update faster than repeated insertLeaf.

			if len(queue)==0 or queue[-1]!=parentK:

				queue.append(parentK)

		while len(queue)>0:

			if (len(queue)==0 or queue[0]!=parentK) and k!=0:

				queue.appendleft(parentK)

from client import Client, Connection as ClientConnection, FailedConnection, DeniedConnection, IncompatibleException

from server import Miniserver

def _checkFile(f):

	if not os.path.isfile(f):

		sys.exit(1)

def buildTree(args):

	_checkFile(args.datafile)

	if os.path.isfile(args.treefile):

		if dataMod<treeMod and not args.force:

			print("tree file is up to date")

			return

	tree.save(args.treefile)

def push(args):

	_checkFile(args.datafile)

	if args.tree:

		_checkFile(args.tree)

	for h in conf.hosts:

		stats.reset()

		try:

			with ClientConnection(*host) as con:

				c.setConnection(con)

				c.init("push")

				c.sendData(blocksToTransfer)

			print()

			print(stats.report())

			print()

		except FailedConnection: pass

		except DeniedConnection as e:

		except IncompatibleException as e: print(e)

def pull(args):

	_checkFile(args.datafile)

	if args.tree:

		_checkFile(args.tree)

	try:

		with ClientConnection(*host) as con:

			c.setConnection(con)

			c.init("pull")

		print()

		print(stats.report())

	except FailedConnection: pass

	except DeniedConnection as e:

		print("Server {0}:{1} denied connection.".format(*host))

		print(e)

def serve(args):

	_checkFile(args.datafile)

	if args.tree:

		_checkFile(args.tree)

	try:

		spawnDaemon(s.serve)

	except Exception as e: