文件增量同步实验[python]

果断代码~

import hashlib   
import os

#salder32, calder32 = [], []
#A, B = [], []

MOD_ALDER32 = 65521
chunksize = 32
# What the client should do
def alder32(data, start, offset):
    if start < 0: return 0L
    ret, a, b = 0L, 1L, 0L

    for d in data[start:start+offset]:
        a = (a + ord(d)) % MOD_ALDER32
        b = (b + a) % MOD_ALDER32
   
    return (b << 16) | a
def init_salder32(sfile):
    nchunk = len(sfile) / chunksize
    if len(sfile) % chunksize:
        nchunk += 1
   
    global salder32
    salder32 = []  

    for i in range(0, nchunk):
        v = alder32(sfile, i*chunksize, chunksize)
        salder32.append(v)
def init_calder32(cfile):
    global calder32
    A, B, calder32 = [], [], []

    if len(cfile) == 0: return
    A.append(1L)
    B.append(0L)

    for d in cfile[0:chunksize]:
       A[0] = (A[0] + ord(d)) % MOD_ALDER32
       B[0] = (B[0] + A[0]) % MOD_ALDER32
   
    calder32.append((B[0]<<16 | A[0]))

    n = len(cfile) – chunksize
   
    for i in range(1, n+1):
        A.append((A[i-1] – ord(cfile[i-1]) + ord(cfile[i+chunksize-1])) % MOD_ALDER32)
        B.append((B[i-1] – chunksize * ord(cfile[i-1]) + A[i] – 1) % MOD_ALDER32)
        calder32.append((B[i]<<16 | A[i]))

    k = n + 1 if n >= 0 else 1

    for i in range(k, len(cfile)):
        calder32.append(0L)
def read_file(path):
    content = \’\’
    try:
        f = file(path, \’r\’)
        content = f.read()
        f.close()

    except Exception, e:
        print str(e)

    return content   
def md5(data, start, offset):
    data = data[start:start+offset]
    return hashlib.md5(data).hexdigest()
def pre_work(sfile, cfile):
    global sadler32, calder32, DATA, INDEX
    DATA, INDEX = [], []

    ls, lc = len(salder32), len(calder32)
    data, find = \’\’, False
    i, k, prej = 0, 0, 0
   
    while i < lc:   
        cv = calder32[i]
       
        for j in range(k, ls):
            sv = salder32[j]  
            if sv != cv: continue
            if md5(sfile, j*chunksize, chunksize) == md5(cfile, i, chunksize):
                find = True
                break
       
        if not find:
            data += cfile[i]
            i = i + 1
        else:
            DATA.append(data)
            INDEX.append(j – prej)             
            data, find = \’\’, False
            i = i + chunksize
            k = j + 1
            prej = j

    DATA.append(data)
# What the server should do
def sync_file(sfile, DATA, INDEX):
    ret, k = \’\’, 0
    ret += str(DATA[0])
    for i in range(0, len(INDEX)):
        k += INDEX[i]
        ret += sfile[k*chunksize:(k+1)*chunksize]
        ret += str(DATA[i+1])
    return ret
# A simple test for the functions above
def main():
    spath = \’/home/beanuser/python script/sfile.txt\’
    cpath = \’/home/beanuser/python script/cfile.txt\’
   
    sfile = read_file(spath)
    global salder32
    init_salder32(sfile)
    print \’server alder32 array:\’
    for v in salder32:
        print \’%ld\’ % v

    cfile = read_file(cpath)
    global calder32
    init_calder32(cfile)
    print \’client alder32 array:\’
    for v in calder32:
        print \’%ld\’ % v

    global DATA, INDEX
    pre_work(sfile, cfile)
    print \’DATA array[%d]:\’ % len(DATA)
    for d in DATA:
        print d
    print \’INDEX array[%d]:\’ % len(INDEX)
    for i in INDEX:
        print i

    print \’EDITED FILE:\’
    print sync_file(sfile, DATA, INDEX)
if __name__ == “__main__”:
    main()