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

		self._localTree=HashTree.fromFile(self._filename)

	## 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):

		localTree=self._localTree

		blocksToTransfer=[]

		nodeStack=collections.deque([0]) # root

		# initialize session

		jsonData={"command":"init", "blockSize":localTree.BLOCK_SIZE, "blockCount":localTree.leafCount, "version":conf.version}

		self._outcoming.writeMsg(jsonData)

		jsonData,binData=self._incoming.readMsg()

		assert jsonData["command"]=="ack"

		# determine which blocks to send

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

		progress=Progress(localTree.leafCount)

		while len(nodeStack)>0:

			indices=[]

				indices.append(nodeStack.pop())

				if len(nodeStack)==0: break

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

			jsonData,binData=self._incoming.readMsg()

			assert jsonData["index"]==indices

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

			stats.logExchangedNode(len(indices))

			frontier=[]

			for (j,i) in enumerate(indices):

				(j1,j2)=[HashTree.HASH_LEN*ji for ji in (j,j+1)]

				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()

		return blocksToTransfer

import os

import logging as log

from logging.handlers import TimedRotatingFileHandler

logger=log.getLogger()

logger.setLevel(log.INFO)

formatter=log.Formatter("%(asctime)s %(levelname)s: %(message)s",datefmt="%Y-%m-%d %H:%M:%S")

handler=TimedRotatingFileHandler("/var/log/morevna/mor.log",when="midnight",backupCount=9)

handler.setFormatter(formatter)

logger.addHandler(handler)

version=0

hosts=["127.0.0.1"]

port=9901

directory=os.path.join(os.path.dirname(__file__),"..")

certfile=os.path.join(directory,"certs/cert.pem")

keyfile=os.path.join(directory,"certs/key.pem")

peers=os.path.join(directory,"certs/peers.pem")

class HashTree:

	HASH_LEN=16 # bytes

	BLOCK_SIZE=4096 # bytes

	## Prepares a tree containing leafCount leaves.

	def __init__(self,leafCount):

		self.store=[b""]*(leafCount*2-1)

		self.leafStart=leafCount-1

		self.leafCount=leafCount

		self._index=self.leafStart

	@classmethod

	def fromFile(cls,filename):

		with open(filename,"rb") as f:

			stat=os.fstat(f.fileno())

			size=stat.st_size # !! symlinks

			leafCount=(size-1)//HashTree.BLOCK_SIZE+1 # number of leaf blocks

			res=cls(leafCount)

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

			progress=Progress(leafCount)

			for i in range(leafCount):

				data=f.read(HashTree.BLOCK_SIZE)

				progress.p(i)

			progress.done()

		res.buildTree()

		return res

	@classmethod

	def load(cls,filename):

		with open(filename,"rb") as f:

			stat=os.fstat(f.fileno())

			size=stat.st_size

			nodeCount=size//HashTree.HASH_LEN

			res=cls((nodeCount+1)//2)

			for i in range(nodeCount):

				res.store[i]=f.read(HashTree.HASH_LEN)

		return res

	def save(self,filename):

		with open(filename,"wb") as f:

			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):

		self.store[self._index]=h

		self._index+=1

	## Updates a hash stored in the leaf.

	def updateLeaf(self,index,h):

		if index<self.leafStart: raise IndexError()

		self.store[index]=h

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

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

	def updateNode(self,index):

		while index>=0:

			index=(index-1)//2

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

	def buildTree(self):

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

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

		for i in range(self.leafStart-1,-1,-1):

			progress.p(i)

		progress.done()

if __name__=="__main__":

	f1=HashTree.fromFile(open("serverFile.txt",mode='rb'))

	f2=HashTree.fromFile(open("clientFile.txt",mode='rb'))

	for i,(h1,h2) in enumerate(zip(f1.store,f2.store)):

		print("{0:2}".format(i),h1.hex(),h2.hex(),h1==h2)