import ssl

import logging as log

from datetime import datetime

import config as conf

import status

import stats

from util import Progress

from hashtree import HashTree,hashBlock

from netnode import BaseConnection,NetNode,FailedConnection,LockedException,IncompatibleException

from datafile import DataFile

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

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

		self._socket=sslContext.wrap_socket(sock)

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

		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=[]

			for i in range(conf.batchSize.hash):

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

import sys

import os.path

import logging as log

from argparse import ArgumentParser

from util import spawnDaemon, splitHost

import config as conf

import stats

from hashtree import HashTree

from client import Client, Connection as ClientConnection, FailedConnection, DeniedConnection, IncompatibleException

from server import Miniserver

def _checkFile(f):

	if not os.path.isfile(f):

		print("invalid file specified:",f,file=sys.stderr)

		sys.exit(1)

def buildTree(args):

	_checkFile(args.datafile)

	if os.path.isfile(args.treefile):

		treeMod=os.stat(args.treefile).st_mtime

		dataMod=os.stat(args.datafile).st_mtime

		if dataMod<treeMod and not args.force:

			print("tree file is up to date")

			return

	tree=HashTree.fromFile(args.datafile)

	tree.save(args.treefile)

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

	for h in conf.hosts:

		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

		except DeniedConnection as e:

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

			print(e)

		except IncompatibleException as e: print(e)

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

	except DeniedConnection as e:

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

		print(e)

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

	try:

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

		spawnDaemon(s.serve)

	except Exception as e:

		log.exception("exception: %s",e)

		print("Failed to start:\n  ",e)

parser=ArgumentParser()

subparsers=parser.add_subparsers()

pBuild=subparsers.add_parser("build")

pBuild.add_argument("-f","--force",action="store_true",help="force tree rebuild")

pBuild.add_argument("treefile", help="stored hash tree location")

pBuild.add_argument("datafile")

pBuild.set_defaults(func=buildTree)

pUpdate=subparsers.add_parser("push")

pUpdate.add_argument("-p","--port",type=int)

pUpdate.add_argument("--host")

pUpdate.add_argument("-t","--tree",help="stored hash tree location")

pUpdate.add_argument("datafile")

pUpdate.set_defaults(func=push)

pUpdate=subparsers.add_parser("pull")

pUpdate.add_argument("-p","--port",type=int)

pUpdate.add_argument("--host")

pUpdate.add_argument("-t","--tree",help="stored hash tree location")

pUpdate.add_argument("-f","--force",action="store_true",help="ignore lock file")

pUpdate.add_argument("datafile")

pUpdate.set_defaults(func=pull)

pServe=subparsers.add_parser("serve")

pServe.add_argument("-p","--port",type=int)

pServe.add_argument("--host")

pServe.add_argument("-t","--tree",help="stored hash tree location")

pServe.add_argument("datafile")

pServe.set_defaults(func=serve)

args=parser.parse_args()

try: args.func(args)

#!/bin/bash

# setup encrypted container

#sudo losetup -f ext2.img

#sudo cryptsetup open --type=luks /dev/loop0 ext2luks

#sudo mkfs.ext2 /dev/mapper/ext2luks

# generate certificate

# openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes -subj "/CN=name"

set -e

DIRNAME=`dirname $0`

rsync -av 19x19.cz:letsencrypt.tar.xz.gpg ~/Projekty/

rsync -av 19x19.cz:/home/laman/projekty/laman/db_backup/ ~/Programy/db_backup/

rsync -av 19x19.cz:/home/laman/projekty/gkul/db_backup/ ~/Programy/db_backup/

find ~/Programy/db_backup/ -mtime +30 -type f -delete

sudo losetup -f ~/ext2.img

sudo cryptsetup open --type=luks /dev/loop0 ext2luks

sudo mount /dev/mapper/ext2luks ~/temp

sudo rdiff-backup -v 5 ~/Dokumenty ~/temp/Dokumenty

sudo rdiff-backup -v 5 ~/Obrázky ~/temp/Obrázky

sudo umount /dev/mapper/ext2luks

sudo cryptsetup close ext2luks

sudo losetup -d /dev/loop0

echo

python $DIRNAME/morevna.py build ~/ext2.bin ~/ext2.img

python $DIRNAME/morevna.py push --tree ~/ext2.bin ~/ext2.img

class Stats:

	def __init__(self):

		self.received=0

		self.sent=0

		self.exchangedNodes=0

		self.transferredBlocks=0

stats=Stats()

def logReceived(data):

	stats.received+=len(data)

def logSent(data):

	stats.sent+=len(data)

def logExchangedNode(k=1):

	stats.exchangedNodes+=k

def logTransferredBlock(k=1):

	stats.transferredBlocks+=k

def reset():

	global stats

	stats=Stats()

def report():

	return """received {rf} ({r:,} B)

sent {sf} ({s:,} B)

exchanged {nodes:,} hash tree nodes

def formatBytes(x):

	exts=["B","kiB","MiB","GiB","TiB","PiB"]

	i=0

	while x>1024:

		x/=1024

		i+=1

	if x>=100: x=round(x)

	elif x>=10: x=round(x,1)

	else: x=round(x,2)

	return "{0} {1}".format(x,exts[i])