^\..*

^certs/

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

from netnode import BaseConnection,NetNode

class Connection(BaseConnection):

	def __init__(self):

		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)

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

		self.createNetworkers()

class Client(NetNode):

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

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

		super().__init__(filename,treeFile)

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

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

			for i in range(conf.batchSize):

				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

import sys

import os.path

import logging as log

from argparse import ArgumentParser

from util import spawnDaemon

import config as conf

import stats

from hashtree import HashTree

from client import Client, Connection as ClientConnection

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)

	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.insert(0,args.host)

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

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

	with ClientConnection() as con:

		c.setConnection(con)

		blocksToTransfer=c.negotiate()

		c.sendData(blocksToTransfer)

	print()

	print(stats.report())

def pull(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

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

	with ClientConnection() as con:

		c.setConnection(con)

		blocksToTransfer=c.negotiate()

		c.pullData(blocksToTransfer)

	print()

	print(stats.report())

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:

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

parser=ArgumentParser()

subparsers=parser.add_subparsers()

pBuild=subparsers.add_parser("build")

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("-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",default="127.0.0.1")

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

pUpdate.add_argument("datafile")

pUpdate.set_defaults(func=pull)

pServe=subparsers.add_parser("serve")

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

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

pServe.add_argument("datafile")

pServe.set_defaults(func=serve)

args=parser.parse_args()

args.func(args)

#sudo losetup -f ext2.img

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

#sudo mkfs.ext2 /dev/mapper/ext2luks

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 ~/Projekty ~/temp/Projekty

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

sudo umount /dev/mapper/ext2luks

sudo cryptsetup close ext2luks

sudo losetup -d /dev/loop0