def connect():

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

	s.connect((conf.hosts[0], conf.port))

	fr=s.makefile(mode='rb')

	fw=s.makefile(mode='wb')

	networkReader=NetworkReader(fr)

	networkReader.start()

	networkWriter=NetworkWriter(fw)

	networkWriter.start()

	incoming=networkReader.output # synchronized message queue

	outcoming=networkWriter.input

	return (s,incoming,outcoming)

def negotiate(incoming,outcoming):

	localTree=HashTree.fromFile(open(filename,mode="rb"))

	blocksToTransfer=[]

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

	# initialize session

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

	outcoming.put((jsonData,b""))

	# determine which blocks to send

	while len(nodeStack)>0:

		i=nodeStack.pop()

		jsonData={"command":"req", "index":i}

		outcoming.put((jsonData,b""))

		jsonData,binData=incoming.get(timeout=2)

		assert jsonData["index"]==i

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

		if localTree.store[i]!=binData:

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

				nodeStack.append(2*i+2)

				nodeStack.append(2*i+1)

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

	return blocksToTransfer

def sendData(outcoming,blocksToTransfer):

	print(blocksToTransfer)

	dataFile=open(filename,mode="rb")

		binData=dataFile.read(HashTree.BLOCK_SIZE)

		outcoming.put((jsonData,binData),timeout=2)

	jsonData={"command":"end"}

	outcoming.put((jsonData,b""),timeout=2)

	outcoming.put(None)

	print("closing...")

	dataFile.close()

if __name__=="__main__":

	sock,incoming,outcoming = connect()

	blocksToTransfer=negotiate(incoming,outcoming)

	sendData(outcoming,blocksToTransfer)

	sock.close()

	sys.exit(0)

import socket

from hashtree import HashTree

from networkers import NetworkReader,NetworkWriter

import collections

import sys

# debug copy default file

import shutil

origFilename=sys.argv[1]

filename=origFilename+"_"

shutil.copyfile(origFilename,filename)

localTree=HashTree.fromFile(open(filename,mode="rb"))

HOST = ''								 # Symbolic name meaning all available interfaces

PORT = 50009							# Arbitrary non-privileged port

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

s.bind((HOST, PORT))

s.listen(1)

conn, addr = s.accept()

print('Connected by', addr)

fr=conn.makefile(mode="rb")

fw=conn.makefile(mode="wb")

networkReader=NetworkReader(fr)

networkReader.start()

networkWriter=NetworkWriter(fw)

networkWriter.start()

blocksToTransfer=[]

nodeStack=collections.deque([0])

incoming=networkReader.output # synchronized message queue

outcoming=networkWriter.input

while True:

	jsonData,binData=incoming.get(timeout=2)

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

		assert jsonData["blockSize"]==localTree.BLOCK_SIZE

		assert jsonData["blockCount"]==localTree.leafCount

	elif jsonData["command"]=="req": # !! index out of range

		print("received request for node #{0}".format(jsonData["index"]))

		nodeHash=localTree.store[jsonData["index"]]

		jsonResponse={"command":"send", "index":jsonData["index"], "dataType":"hash"}

		binResponse=nodeHash

		outcoming.put((jsonResponse,binResponse),timeout=2)

	elif jsonData["command"]=="send" and jsonData["dataType"]=="data": # needlessly allow hashes and data in mixed order

		print("received data block #{0}: {1}...{2}".format(jsonData["index"],binData[:5],binData[-5:]))

		dataFile.write(binData)

		# never update the hash tree

	elif jsonData["command"]=="end":

		print("closing...")

		break

	else: pass # !! error

# fr.close()

# fw.close()

conn.close()

sys.exit(0)