{

	"hosts": ["127.0.0.1"],

	"port": 9901,

}

		try:

			self._socket.connect((host,port))

		except (ConnectionRefusedError,OSError) as e:

			log.exception(e)

			print("Couldn't connect to {0}:{1}".format(host,port))

			raise FailedConnection()

		except ssl.SSLError as e:

			log.exception(e)

			print("Error creating SSL connection to {0}:{1}".format(host,port))

			raise FailedConnection()

		self.createNetworkers()

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

class Client(NetNode):

	def __init__(self,filename,treeFile=""):

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

		super().__init__(filename,treeFile)

	def init(self,action):

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

		self._outcoming.writeMsg(jsonData)

		jsonData,binData=self._incoming.readMsg()

		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:

			raise IncompatibleException("Incompatible server version. Consider upgrading it.")

	## 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._tree

		blocksToTransfer=[]

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

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

		size=stats.formatBytes(len(blocksToTransfer)*self._tree.BLOCK_SIZE)

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

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

			indices=[]

			blocks=[]

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

				i2=blocksToTransfer[k+j]

				if i1+1!=i2:

					dataFile.seek(i2*HashTree.BLOCK_SIZE)

				block=dataFile.read(HashTree.BLOCK_SIZE)

				indices.append(i2)

				blocks.append(block)

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

				i1=i2

				progress.p(k+j)

			if indices: self._sendData(indices,blocks)

		progress.done()

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

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

		dataFile.close()

	def pullData(self,blocksToTransfer,ignoreLock=False):

		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)

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

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

		progress=Progress(len(blocksToTransfer))

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

			jsonData,binData=self._incoming.readMsg()

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

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

				block=binData[j*HashTree.BLOCK_SIZE:(j+1)*HashTree.BLOCK_SIZE]

				dataFile.writeAt(i,block)

				if self._treeFile:

					self._newLeaves[i+self._tree.leafStart]=hashBlock(block)

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

				stats.logTransferredBlock()

				progress.p(k+j)

		progress.done()

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

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

		dataFile.close()

		self._unlock()

		if self._treeFile:

			self._updateTree()

	def _sendData(self,indices,blocks):

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

		binData=b"".join(blocks)

		self._outcoming.writeMsg(jsonData,binData)

		stats.logTransferredBlock(len(indices))

		jsonData,binData=self._incoming.readMsg()

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

	def setConnection(self,connection):

		(self._incoming,self._outcoming)=connection

import os

import json

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)

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

configFile=os.path.join(directory,"config.json")

conf=dict()

if os.path.isfile(configFile):

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

version=[0,1,0]

lowestCompatible=[0,1,0] # tuple is more fitting but json conversion transforms it into a list anyway

hosts=conf.get("hosts",["127.0.0.1"])

port=conf.get("port",9901)

import os

import shutil

import hashlib

import multiprocessing

from logging import FileHandler

from unittest import TestCase

import config

from hashtree import HashTree

from client import Client, Connection as ClientConnection, DeniedConnection

from server import Miniserver

from . import RedirectedOutput

config.logger.removeHandler(config.handler)

handler=FileHandler("/tmp/morevna.log")

handler.setFormatter(config.formatter)

config.logger.addHandler(handler)

dataDir=os.path.join(config.directory,"src/tests/data")

filename=os.path.join(dataDir,"test.img")

def compareFiles(f1,f2):

	with open(f1,mode="rb") as f:

		h2=hashlib.sha256(f.read()).hexdigest()

	with open(f2,mode="rb") as f:

		h=hashlib.sha256(f.read()).hexdigest()

	return (h,h2)

class TestMorevna(RedirectedOutput,TestCase):

	_stdout=None

	def setUp(self):

		src=os.path.join(dataDir,"test1.img")

		shutil.copyfile(src,filename)

	@classmethod

	def tearDownClass(cls):

		super().tearDownClass()

		os.remove(filename)

	def test_build(self):

		treeFile=os.path.join(dataDir,"test.bin")

		refFile=os.path.join(dataDir,"test1.bin")

		tree=HashTree.fromFile(os.path.join(dataDir,"test1.img"))

		tree.save(treeFile)

		self.assertEqual(*compareFiles(refFile,treeFile))

		os.remove(treeFile)

	def test_push(self):

		config.port+=1

		ms=Miniserver(filename)

		p=multiprocessing.Process(target=ms.serve)

		p.start()

		for clientFile in ("test2.img","test3.img","test4.img"):

			clientFile=os.path.join(dataDir,clientFile)

			c=Client(clientFile)

			with ClientConnection("127.0.0.1",config.port) as con:

				c.setConnection(con)

				c.init("push")