import collections

import socket

import ssl

import logging as log

from datetime import datetime

import config as conf

import stats

from util import Progress

from hashtree import HashTree

from networkers import NetworkReader,NetworkWriter

class Connection:

	def __init__(self):

		sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)

		sslContext=ssl.create_default_context(cafile=conf.peers)

		sslContext.check_hostname=False

		sslContext.load_cert_chain(conf.certfile,conf.keyfile)

		self._socket=sslContext.wrap_socket(sock)

		self._socket.connect((conf.hosts[0], conf.port))

		fr=self._socket.makefile(mode="rb")

		fw=self._socket.makefile(mode="wb")

		self.incoming=NetworkReader(fr)

		self.outcoming=NetworkWriter(fw)

	def __enter__(self):

		return self.incoming,self.outcoming

	def __exit__(self, exc_type, exc_val, exc_tb):

		self._socket.shutdown(socket.SHUT_RDWR)

		self._socket.close()

class Client:

	def __init__(self,filename):

		self._incoming=None

		self._outcoming=None

		self._filename=filename

		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

	def sendData(self,blocksToTransfer):

		log.info(blocksToTransfer)

		dataFile=open(self._filename, mode="rb")

		i1=-1

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

		progress=Progress(len(blocksToTransfer))

		for (k,i2) in enumerate(blocksToTransfer):

			jsonData={"command":"send", "index":i2, "dataType":"data"}

			if i1+1!=i2:

				dataFile.seek(i2*HashTree.BLOCK_SIZE)

			binData=dataFile.read(HashTree.BLOCK_SIZE)

			log.info("block #{0}: {1}...{2}".format(i2,binData[:5],binData[-5:]))

			self._outcoming.writeMsg(jsonData,binData)

			stats.logTransferredBlock()

			jsonData,binData=self._incoming.readMsg()

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

			i1=i2

			progress.p(k)

		progress.done()

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

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

		dataFile.close()

	def pullData(self,blocksToTransfer):

		log.info(blocksToTransfer)

		dataFile=open(self._filename, mode="rb+")

		i1=-1

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

		progress=Progress(len(blocksToTransfer))

		for (k,i2) in enumerate(blocksToTransfer):

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

			jsonData,binData=self._incoming.readMsg()

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

			if i1+1!=i2:

				dataFile.seek(i2*HashTree.BLOCK_SIZE)

			dataFile.write(binData)

			log.info("block #{0}: {1}...{2}".format(i2,binData[:5],binData[-5:]))

			stats.logTransferredBlock()

			i1=i2

			progress.p(k)

		progress.done()

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

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

		dataFile.close()

	def setConnection(self,connection):

		(self._incoming,self._outcoming)=connection

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

import hashlib

import os

from datetime import datetime

from util import Progress

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)