# Protocol #

Nodes communicate by exchanging messages through network sockets. Basic message format is simple:

		json-length: ABC

		bin-length: DEF

		{... JSON payload ...}

		... binary payload ...

`ABC` is the JSON payload length (decimal integer), `DEF` is the binary payload length. JSON payload always contains a "command" field.

The client sends a request (a message) and the server answers with a response (another message).

## Commands ##

### <a name="init"></a>init ###

Initiates communication between the client and the server. Checks that the nodes can meaningfully talk to each other.

#### Params ####

- {push, pull} action: what the client desires to do

- (str) filename: name of the file to be synchronized

- (int) blockSize

- (int) blockCount

#### Responses ####

- [init](#r-init)

- [deny](#deny)

### <a name="req"></a>req ###

Requests hashes or a data chunk from the server.

#### Params ####

- {push} (optional) action: unlocks the server's dirty lock

#### Responses ####

- end

## Responses ##

### <a name="r-init"></a>init ###

See [the init command](#init). If the client doesn't like server's protocol version, it is free to [end](#end) the connection.

#### Params ####

### <a name="deny"></a>deny ###

The server refuses connection. It might be busy, corrupted or incompatible.

#### Params ####

- (int) retry: suggested delay in seconds before another attempt at connection

- (str) msg

### <a name="ack"></a>ack ###

Everything is alright, but the server has nothing better to say.

### <a name="err"></a>err ###

Something bad happened.

#### Params ####

- (str) msg

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,hashBlock

class DeniedConnection(Exception): pass

class Connection(BaseConnection):

	def __init__(self,host,port):

		super().__init__()

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

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

		sslContext.check_hostname=False

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

			raise DeniedConnection()

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

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

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)

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

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

batchSize=conf.get("batchSize",256)

		host=splitHost(h,conf.port)

		stats.reset()

		try:

			with ClientConnection(*host) as con:

				c.setConnection(con)

				c.init("push")

				blocksToTransfer=c.negotiate()

				c.sendData(blocksToTransfer)

			print()

			print(stats.report())

			print()

		except FailedConnection: pass

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

def pull(args):

	_checkFile(args.datafile)

	if args.tree:

		_checkFile(args.tree)

	if args.host: conf.hosts=[args.host]

	if args.port: conf.port=args.port

	c=Client(args.datafile,args.tree)

	host=splitHost(conf.hosts[0],conf.port)

	try:

		with ClientConnection(*host) as con:

			c.setConnection(con)

			c.init("pull")

			blocksToTransfer=c.negotiate()

			c.pullData(blocksToTransfer,args.force)

		print()

		print(stats.report())

	except FailedConnection: pass

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

def serve(args):

	_checkFile(args.datafile)

	if args.tree:

		_checkFile(args.tree)

	if args.host: conf.hosts.insert(0,args.host)

	if args.port: conf.port=args.port

	s=Miniserver(args.datafile,args.tree)

	try:

		spawnDaemon(s.serve)

	except Exception as e:

import logging as log

import config as conf

from networkers import NetworkReader,NetworkWriter

from hashtree import HashTree

lockFile=os.path.join(conf.directory,"dirty.lock")

class FailedConnection(Exception): pass

class LockedException(Exception): pass

class BaseConnection: # abstract

	def __init__(self):

		self._socket=None

		self.incoming=None

		self.outcoming=None

	def createNetworkers(self):

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

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

import socket

import ssl

import multiprocessing

import logging as log

from hashtree import hashBlock

from netnode import BaseConnection,NetNode

import config as conf

class Connection(BaseConnection):

	def __init__(self,serverSocket,sslContext):

		super().__init__()

		sock, address = serverSocket.accept()

		self._socket=sslContext.wrap_socket(sock,server_side=True)

		log.info('Connected by {0}'.format(address))

		self.createNetworkers()

		self._ss = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

		self._ss.bind(("", conf.port))

		self._ss.listen(1)

	def serve(self):

		p=None

		with self._ss:

			while True:

				connection=Connection(self._ss,self._ssl)

				if p and p.is_alive():

					with connection as c:

						c[0].readMsg()

					continue

				p=multiprocessing.Process(target=Server.run,args=(connection,self._filename,self._treeFile))

				p.start()

class Server(NetNode):

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

		super().__init__(filename,treeFile)

		(self._incoming,self._outcoming)=connection

		self.BLOCK_SIZE=self._tree.BLOCK_SIZE

	def serve(self):

		try:

			while self._serveOne(): pass

		except (AssertionError,ConnectionResetError) as e:

			log.warning(e)

	def _serveOne(self):

		jsonData,binData=self._incoming.readMsg()

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

			if jsonData["blockSize"]!=self.BLOCK_SIZE or jsonData["blockCount"]!=self._tree.leafCount:

			if jsonData["action"]=="pull" and self.isLocked():

			if jsonData["action"]=="push" and not self.isLocked():

				self._lock()

			self._outcoming.writeMsg({"command":"init", "version":conf.version})

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

			if jsonData["dataType"]=="data":

				self._outcoming.writeMsg(*self._requestData(jsonData["index"]))

			else:

				self._outcoming.writeMsg(*self._requestHash(jsonData["index"]))

		elif jsonData["command"]=="send" and jsonData["dataType"]=="data":