algorithm - 使用rdiff/bsdiff以最佳时间/存储/加载方式从文件的原始版本(v0.1)转到新版本(v0.2)

Question

采取方案
我想在处理文件(photoshop / word / powerpoint等(例如二进制数据))的过程中创建备份，因此每次创建v0.x时，我也会创建一个备份。
但是我想使用rdiff做到这一点，因此我只需要存储原始版本和当前版本之间的差异。

我是using the code found here，我的代码(运行)如下

package main

import (
    "bufio"
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "os"

    "github.com/jbreiding/rsync-go"
)

var originalFile string
var newFile string
var patchFile string
var signatureFile string
var appliedFile string

func openFile(path string) ([]byte, error) {
    data, err := ioutil.ReadFile(path)
    if err != nil {
        fmt.Println("File reading error", err)
    }
    return data, err
}

func writeFile(path string, data []byte) error {
    err := ioutil.WriteFile(path, data, 0644)
    return err
}

func main() {
    originalFile = "./profile-shot.jpg"
    newFile = "./profile-shot-to.jpg"
    patchFile = "./profile-shot.patch"
    signatureFile = "./profile-shot.sig"
    appliedFile = "./profile-shot-applied.jpg"

    //create a signature based on the original file
    originalFileReader, _ := os.Open(originalFile)
    defer originalFileReader.Close()

    rs := &rsync.RSync{}

    //take a signature of the new
    //apply it to the original
    //get a delta
    //apply the delta to the original
    //get the new??

    // 1. prepare a signature
    sig := make([]rsync.BlockHash, 0, 10)
    writeSignature := func(bl rsync.BlockHash) error {
        sig = append(sig, bl)
        return nil
    }

    //2. take the new file
    newFileReader, _ := os.Open(newFile)

    //3. create the signature
    rs.CreateSignature(originalFileReader, writeSignature)
    sigBytes, err := json.Marshal(sig)
    if err != nil {
        fmt.Println("error ", err)
    } else {
        writeFile(signatureFile, sigBytes)
    }

    opsOut := make(chan rsync.Operation)

    dataWriter := bufio.NewWriter(&dataBuffer)
    //4. specify a write operation for the delta
    writeOperation := func(op rsync.Operation) error {
        opsOut <- op
        data, err := json.Marshal(op.Data)
        if err != nil {
            fmt.Println("error ", err)
        }
        if _, err := dataWriter.Write(data); err != nil {
            fmt.Println("error writing data ", err)
        }
        return nil
    }
    var dataBuffer bytes.Buffer
    go func() {
        defer close(opsOut)
        //5. in a routine, create a delta from the new image and the signature of the original
        err := rs.CreateDelta(newFileReader, sig, writeOperation)
        fmt.Println("err creating delta ", err)
        writeFile(patchFile, dataBuffer.Bytes())
        fmt.Println("length of signature ", len(sig))
        //now we have written the patch to file, we can open the applied file and write the data from the patch to it, by passing the struct(s) to a new opsOut channel, and calling apply delta using that channel
    }()

    // saving the applied delta resulting file
    newFileWriter, err := os.OpenFile(appliedFile, os.O_RDWR|os.O_CREATE, 0600)
    if err != nil {
        fmt.Println("error source writer ", err)
    }
    originalFileReader.Seek(0, os.SEEK_SET)
    //6. apply the delta
    rs.ApplyDelta(newFileWriter, originalFileReader, opsOut)
}

以上基本上做了我认为对rdiff的期望。

读取原始文件(v0.1)

从此文件创建签名(v0.1 sig)

创建一个增量，该增量基于新的文件(v0.x)和签名

将增量应用到v0.1，您将获得v0.x

然后的问题是，实际上，我很可能备份了v0.1以及每个后续版本的所有签名，而 而不是拥有了每个完整版本的备份(这毫无意义)。

但是，以上要求新版本创建增量，而不是原始版本。因此，实际上我不能倒退，因为当我需要增量而不需要较新版本以及我尝试使用rsync获得的新版本时，就无法创建增量。

我意识到解决方案是存储增量，但是到目前为止(使用图像)增量与文件本身一样大(我正在使用20MB到100MB之间的图像进行测试)。因此，使用这种方法似乎也不值得。

注意。我也一直在使用 bsdiff in Go，它确实可以解决问题(增量大约是实际文件大小的0.5倍)，但是由于排序算法会生成索引，因此速度非常慢。创建差异需要此索引。它大约是原始文件大小的10倍，因此也不可以选择存储。

任何有关最佳方法的想法，将不胜感激。

Answer 1

最小化增量想法:

diffData:=diff(decompress(oldImage),decompress(newImage))   

(您需要一个快速的二进制差异算法)

newImage:=recompress(patch(decompress(oldImage),diffData))   

(重新压缩算法要求:结果new newImage必须与diff之前的相同)
这种方式也是处理zip文件的想法...
差异算法:bsdiff速度慢且需要较大的内存，此处xdelta3(或HDiffPatch -s)可能更合适，内存较少且速度较快；
重新压缩:为了重新压缩速度和恢复，在解压缩时可能需要保存一些元信息；