Esempio n. 1
0
 def __init__(self, dirname, bootstrapPort):
     self.dirname = dirname
     self.commPort = getFreePort(5000)
     self.comm = ChunkSafeComm(self.commPort)
     self.comm.joinNetwork([("127.0.0.1", bootstrapPort)])
     self.name = hashlib.sha1(dirname).hexdigest() + ".tar.bz2"
     print self.name
Esempio n. 2
0
 def __init__(self,dirname,bootstrapPort):
     self.dirname = dirname
     self.commPort = getFreePort(5000)
     self.comm = ChunkSafeComm(self.commPort)
     self.comm.joinNetwork([("127.0.0.1",bootstrapPort)])
     self.name = hashlib.sha1(dirname).hexdigest() + ".tar.bz2"
     print self.name
Esempio n. 3
0
    def __init__(self,
                 udpPort,
                 backupDir=None,
                 storeDir=None,
                 backupTime=None,
                 bootstrapAddr=None,
                 bootstrapPort=None):
        # Set parameters
        self.commPort = udpPort
        self.address = socket.gethostbyname(socket.gethostname())
        if backupDir != None and storeDir != None:
            # New node - params specified on command line
            self.serverPort = udpPort + 500
            self.backupDir = backupDir
            self.storageDir = storeDir
            self.backupTime = backupTime
            print "Time: " + str(self.backupTime)
            self.saveParams()
        else:
            # Resuming node - load parameters
            try:
                self.loadParams()
            except IOError:
                print "Can't resume node, there is no saved state in this directory!"
                exit(1)

        # Create and store helper objects
        self.reactor = reactor
        dataStore = datastore.SQLiteDataStore(str(udpPort) + ".db")
        self.comm = ChunkSafeComm(self.commPort, dataStore)
        self.backup = BackupDir(self.backupDir, self.storageDir)
        self.server = ChunkServer(self.serverPort, self.reactor, os.getcwd())

        # Connect to the Entangled network
        if bootstrapAddr != None and bootstrapPort != None:
            self.comm.joinNetwork([(bootstrapAddr, bootstrapPort)])
        else:
            self.comm.joinNetwork(None)

        # Schedule the backup
        self.reactor.callLater(self.secsToBackup(), self.backUp, None)

        def sigHandler(signum, frame):
            self.reactor.callLater(0, self.backUp, None)

        signal.signal(signal.SIGUSR1, sigHandler)
Esempio n. 4
0
    def __init__(self, udpPort, backupDir=None, storeDir=None, backupTime=None, bootstrapAddr=None, bootstrapPort=None):
        # Set parameters
        self.commPort = udpPort
        self.address = socket.gethostbyname(socket.gethostname())
        if backupDir != None and storeDir != None:
            # New node - params specified on command line
            self.serverPort = udpPort + 500
            self.backupDir = backupDir
            self.storageDir = storeDir
            self.backupTime = backupTime
            print "Time: " + str(self.backupTime)
            self.saveParams()
        else:
            # Resuming node - load parameters
            try:
                self.loadParams()
            except IOError:
                print "Can't resume node, there is no saved state in this directory!"
                exit(1)

        # Create and store helper objects
        self.reactor = reactor
        dataStore = datastore.SQLiteDataStore(str(udpPort) + ".db")
        self.comm = ChunkSafeComm(self.commPort, dataStore)
        self.backup = BackupDir(self.backupDir, self.storageDir)
        self.server = ChunkServer(self.serverPort, self.reactor, os.getcwd())

        # Connect to the Entangled network
        if bootstrapAddr != None and bootstrapPort != None:
            self.comm.joinNetwork([(bootstrapAddr, bootstrapPort)])
        else:
            self.comm.joinNetwork(None)

        # Schedule the backup
        self.reactor.callLater(self.secsToBackup(), self.backUp, None)

        def sigHandler(signum, frame):
            self.reactor.callLater(0, self.backUp, None)

        signal.signal(signal.SIGUSR1, sigHandler)
Esempio n. 5
0
class ChunkSafeNode:
    def __init__(self, udpPort, backupDir=None, storeDir=None, backupTime=None, bootstrapAddr=None, bootstrapPort=None):
        # Set parameters
        self.commPort = udpPort
        self.address = socket.gethostbyname(socket.gethostname())
        if backupDir != None and storeDir != None:
            # New node - params specified on command line
            self.serverPort = udpPort + 500
            self.backupDir = backupDir
            self.storageDir = storeDir
            self.backupTime = backupTime
            print "Time: " + str(self.backupTime)
            self.saveParams()
        else:
            # Resuming node - load parameters
            try:
                self.loadParams()
            except IOError:
                print "Can't resume node, there is no saved state in this directory!"
                exit(1)

        # Create and store helper objects
        self.reactor = reactor
        dataStore = datastore.SQLiteDataStore(str(udpPort) + ".db")
        self.comm = ChunkSafeComm(self.commPort, dataStore)
        self.backup = BackupDir(self.backupDir, self.storageDir)
        self.server = ChunkServer(self.serverPort, self.reactor, os.getcwd())

        # Connect to the Entangled network
        if bootstrapAddr != None and bootstrapPort != None:
            self.comm.joinNetwork([(bootstrapAddr, bootstrapPort)])
        else:
            self.comm.joinNetwork(None)

        # Schedule the backup
        self.reactor.callLater(self.secsToBackup(), self.backUp, None)

        def sigHandler(signum, frame):
            self.reactor.callLater(0, self.backUp, None)

        signal.signal(signal.SIGUSR1, sigHandler)

    # Save a dict of params to a pickle file
    def saveParams(self):
        params = {}
        params["storageDir"] = self.storageDir
        params["backupDir"] = self.backupDir
        params["serverPort"] = self.serverPort
        params["backupTime"] = self.backupTime
        paramFile = open(str(self.commPort) + ".params", "wb")
        cPickle.dump(params, paramFile)
        paramFile.close()

    # Load the parameters from a saved file
    def loadParams(self):
        paramFile = open(str(self.commPort) + ".params", "rb")
        params = cPickle.load(paramFile)
        paramFile.close()
        self.storageDir = params["storageDir"]
        self.backupDir = params["backupDir"]
        self.serverPort = params["serverPort"]
        self.backupTime = params["backupTime"]

    # Number of seconds before the backup
    def secsToBackup(self):
        backupTime = datetime.time(*self.backupTime)
        now = datetime.datetime.now()
        then = datetime.datetime.combine(now.date(), backupTime)
        diff = (then - now).seconds
        if diff == 0:
            diff = 3600 * 24
        print "Backing up in " + str(diff) + " seconds"
        return diff

    def backUp(self, result):
        # benchmark line
        timer = [0]

        # benchmark line
        def startTimer(result):
            timer[0] = time.time()
            return result

        # benchmark line
        def stopTimer(result):
            timer[0] = time.time() - timer[0]
            print "it took %f seconds to negotiate a partner\n" % (timer[0])
            return result

        chunkfile = [None]

        # archives the chunkfile
        def archiveItem(result, item, storageDir):
            chunkfile[0] = item.archive(storageDir)
            # print "archiveItem: " + str(chunkfile)
            return chunkfile[0]

        # tells server to prepare file
        def allowTheSend(result):
            # print "allowTheSend: " + str(chunkfile)
            self.server.allowSend(result, chunkfile[0])
            return result

        # schedule after tells teh server to schedule the following procedure after it sends the file
        def scheduleAfter(result, method):
            self.server.scheduleAfterSend(chunkfile[0].getName(), method)
            return result

        def send(result):
            df = self.comm.sendChunk(result, self.address, self.serverPort, chunkfile[0])
            return df

        def printDone(result):
            # benchmark line
            print "Done sending"

        # sends text msg of notification of the backup's completion
        def sendText(result):
            a = Voice()
            a.login("salvo.program", "qwertyqwerty")
            a.send_sms(7327071629, "donebackup")

        # Schedule next backup
        self.reactor.callLater(self.secsToBackup(), self.backUp, None)

        self.backup.walkDir()
        backupDf = defer.Deferred()
        for item in self.backup.chunks():
            backupDf.addCallback(archiveItem, item, self.storageDir)
            backupDf.addCallback(startTimer)
            backupDf.addCallback(self.comm.findDestination)
            backupDf.addCallback(stopTimer)
            backupDf.addCallback(allowTheSend)
            backupDf.addCallback(scheduleAfter, item.dissolve)
            backupDf.addCallback(send)
        backupDf.addErrback(self.comm.printNum, "chunksafe36")
        backupDf.addCallback(sendText)
        backupDf.addCallback(printDone)
        # self.comm.storeHostContents(d.subdirs())
        backupDf.callback(None)
Esempio n. 6
0
class ChunkSafeNode:
    def __init__(self,
                 udpPort,
                 backupDir=None,
                 storeDir=None,
                 backupTime=None,
                 bootstrapAddr=None,
                 bootstrapPort=None):
        # Set parameters
        self.commPort = udpPort
        self.address = socket.gethostbyname(socket.gethostname())
        if backupDir != None and storeDir != None:
            # New node - params specified on command line
            self.serverPort = udpPort + 500
            self.backupDir = backupDir
            self.storageDir = storeDir
            self.backupTime = backupTime
            print "Time: " + str(self.backupTime)
            self.saveParams()
        else:
            # Resuming node - load parameters
            try:
                self.loadParams()
            except IOError:
                print "Can't resume node, there is no saved state in this directory!"
                exit(1)

        # Create and store helper objects
        self.reactor = reactor
        dataStore = datastore.SQLiteDataStore(str(udpPort) + ".db")
        self.comm = ChunkSafeComm(self.commPort, dataStore)
        self.backup = BackupDir(self.backupDir, self.storageDir)
        self.server = ChunkServer(self.serverPort, self.reactor, os.getcwd())

        # Connect to the Entangled network
        if bootstrapAddr != None and bootstrapPort != None:
            self.comm.joinNetwork([(bootstrapAddr, bootstrapPort)])
        else:
            self.comm.joinNetwork(None)

        # Schedule the backup
        self.reactor.callLater(self.secsToBackup(), self.backUp, None)

        def sigHandler(signum, frame):
            self.reactor.callLater(0, self.backUp, None)

        signal.signal(signal.SIGUSR1, sigHandler)

    # Save a dict of params to a pickle file
    def saveParams(self):
        params = {}
        params["storageDir"] = self.storageDir
        params["backupDir"] = self.backupDir
        params["serverPort"] = self.serverPort
        params["backupTime"] = self.backupTime
        paramFile = open(str(self.commPort) + ".params", "wb")
        cPickle.dump(params, paramFile)
        paramFile.close()

    # Load the parameters from a saved file
    def loadParams(self):
        paramFile = open(str(self.commPort) + ".params", "rb")
        params = cPickle.load(paramFile)
        paramFile.close()
        self.storageDir = params["storageDir"]
        self.backupDir = params["backupDir"]
        self.serverPort = params["serverPort"]
        self.backupTime = params["backupTime"]

    # Number of seconds before the backup
    def secsToBackup(self):
        backupTime = datetime.time(*self.backupTime)
        now = datetime.datetime.now()
        then = datetime.datetime.combine(now.date(), backupTime)
        diff = (then - now).seconds
        if diff == 0:
            diff = 3600 * 24
        print "Backing up in " + str(diff) + " seconds"
        return diff

    def backUp(self, result):
        #benchmark line
        timer = [0]

        #benchmark line
        def startTimer(result):
            timer[0] = time.time()
            return result

        #benchmark line
        def stopTimer(result):
            timer[0] = time.time() - timer[0]
            print "it took %f seconds to negotiate a partner\n" % (timer[0])
            return result

        chunkfile = [None]

        #archives the chunkfile
        def archiveItem(result, item, storageDir):
            chunkfile[0] = item.archive(storageDir)
            #print "archiveItem: " + str(chunkfile)
            return chunkfile[0]

        #tells server to prepare file
        def allowTheSend(result):
            #print "allowTheSend: " + str(chunkfile)
            self.server.allowSend(result, chunkfile[0])
            return result

        #schedule after tells teh server to schedule the following procedure after it sends the file
        def scheduleAfter(result, method):
            self.server.scheduleAfterSend(chunkfile[0].getName(), method)
            return result

        def send(result):
            df = self.comm.sendChunk(result, self.address, self.serverPort,
                                     chunkfile[0])
            return df

        def printDone(result):
            #benchmark line
            print "Done sending"

        #sends text msg of notification of the backup's completion
        def sendText(result):
            a = Voice()
            a.login("salvo.program", "qwertyqwerty")
            a.send_sms(7327071629, "donebackup")

        # Schedule next backup
        self.reactor.callLater(self.secsToBackup(), self.backUp, None)

        self.backup.walkDir()
        backupDf = defer.Deferred()
        for item in self.backup.chunks():
            backupDf.addCallback(archiveItem, item, self.storageDir)
            backupDf.addCallback(startTimer)
            backupDf.addCallback(self.comm.findDestination)
            backupDf.addCallback(stopTimer)
            backupDf.addCallback(allowTheSend)
            backupDf.addCallback(scheduleAfter, item.dissolve)
            backupDf.addCallback(send)
        backupDf.addErrback(self.comm.printNum, "chunksafe36")
        backupDf.addCallback(sendText)
        backupDf.addCallback(printDone)
        #self.comm.storeHostContents(d.subdirs())
        backupDf.callback(None)
Esempio n. 7
0
class ChunkReader:
    def __init__(self, dirname, bootstrapPort):
        self.dirname = dirname
        self.commPort = getFreePort(5000)
        self.comm = ChunkSafeComm(self.commPort)
        self.comm.joinNetwork([("127.0.0.1", bootstrapPort)])
        self.name = hashlib.sha1(dirname).hexdigest() + ".tar.bz2"
        print self.name

    def copyFile(self, fname, dest):
        hKey = hashlib.sha1(self.name).digest()

        def findContact(result):
            if type(result) == dict:
                id = result[hKey]
                print "asking for contact with id " + id
                contactDf = self.comm.findContact(id)
                return contactDf
            else:
                raise KeyError

        def connectToContact(result):
            servAddr = result.address
            servPort = result.port + 500
            print servAddr + ":" + str(servPort)
            fetcher = ChunkFetcher(servAddr, servPort)
            return fetcher.connect()

        # retrieveFile(Protocol)
        def retrieveChunk(result):
            result.getFile(self.name)
            return result.fileDf

        #pulls the file out of the tar
        def retrieveFile(result):
            print result
            self.tar = tarfile.open(self.name, 'r:bz2')
            if os.path.isdir(dest):
                destdir = dest
            else:
                destdir = os.path.dirname(dest)
            self.tar.extract(fname, destdir)

        #Deletes the tar after retrieval
        def cleanup(result):
            print "Cleaning Up"
            self.tar.close()
            os.remove(self.name)
            reactor.stop()

        #handles error
        def errorHandler(result):
            result.trap(KeyError)
            print "That directory was not found!"

        print hKey
        idDf = self.comm.iterativeFindValue(hKey)
        idDf.addCallback(findContact)
        idDf.addCallback(connectToContact)
        idDf.addCallback(retrieveChunk)
        idDf.addCallback(retrieveFile)
        idDf.addCallback(cleanup)
        idDf.addErrback(errorHandler)
        idDf.addErrback(self.comm.printNum, "retrieve17")
Esempio n. 8
0
class ChunkReader:
    def __init__(self,dirname,bootstrapPort):
        self.dirname = dirname
        self.commPort = getFreePort(5000)
        self.comm = ChunkSafeComm(self.commPort)
        self.comm.joinNetwork([("127.0.0.1",bootstrapPort)])
        self.name = hashlib.sha1(dirname).hexdigest() + ".tar.bz2"
        print self.name

    def copyFile(self,fname,dest):
        hKey = hashlib.sha1(self.name).digest()
        def findContact(result):
            if type(result) == dict:
                id = result[hKey]
                print "asking for contact with id " + id
                contactDf = self.comm.findContact(id)
                return contactDf
            else:
                raise KeyError
        
        def connectToContact(result):
            servAddr = result.address
            servPort = result.port + 500
            print servAddr + ":" + str(servPort)
            fetcher = ChunkFetcher(servAddr, servPort)
            return fetcher.connect()

        # retrieveFile(Protocol)
        def retrieveChunk(result):
            result.getFile(self.name)
            return result.fileDf

        #pulls the file out of the tar
        def retrieveFile(result):
            print result
            self.tar = tarfile.open(self.name, 'r:bz2')
            if os.path.isdir(dest):
                destdir = dest
            else:
                destdir = os.path.dirname(dest)
            self.tar.extract(fname,destdir)

        #Deletes the tar after retrieval
        def cleanup(result):
            print "Cleaning Up"
            self.tar.close()
            os.remove(self.name)
            reactor.stop()

        #handles error
        def errorHandler(result):
            result.trap(KeyError)
            print "That directory was not found!"

        print hKey
        idDf = self.comm.iterativeFindValue(hKey)
        idDf.addCallback(findContact)
        idDf.addCallback(connectToContact)
        idDf.addCallback(retrieveChunk)
        idDf.addCallback(retrieveFile)
        idDf.addCallback(cleanup)
        idDf.addErrback(errorHandler)
        idDf.addErrback(self.comm.printNum, "retrieve17")