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

golang学习网今天将给大家带来《使用 rdiff/bsdiff 以最佳时间/存储/加载方式从文件的原始版本 (v0.1) 转换为新版本 (v0.2)》，感兴趣的朋友请继续看下去吧！以下内容将会涉及到等等知识点，如果你是正在学习Golang或者已经是大佬级别了，都非常欢迎也希望大家都能给我建议评论哈~希望能帮助到大家！

以场景为例 我想在处理文件（photoshop/word/powerpoint 等（例如二进制数据））时创建备份，因此每次创建 v0.x 时我也会创建它的备份。 但是我想使用 rdiff 来执行此操作，这样我只需存储原始版本和当前版本之间的差异部分。

我正在使用此处找到的代码，我的代码（运行）如下

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 之间的图像进行测试）。因此，使用这种方法似乎也不值得。

注意。我也在 go 中使用了 bsdiff，这确实起到了作用（增量大约是实际文件大小的 0.5 倍），但是由于生成索引的排序算法，它非常慢。创建差异需要该索引。它的大小大约是原始文件的 10 倍，因此存储它也不是一个选择。

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

解决方案

最小化 delta 想法：

diffdata:=diff(decompress(oldimage),decompress(newimage))

（您需要快速的二进制差异算法）

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

（重新压缩算法要求：结果 new newimage 必须与 diff 之前相同）

这种方式也是处理zip文件的思路...

diff算法：bsdiff很慢并且需要大量内存，xdelta3（或hdiffpatch -s）在这里可能更合适，内存更少并且速度更快；

重新压缩：为了重新压缩速度和恢复，解压缩时可能需要保存一些元信息；

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《使用 rdiff/bsdiff 以最佳时间/存储/加载方式从文件的原始版本 (v0.1) 转换为新版本 (v0.2)》文章吧，也可关注golang学习网公众号了解相关技术文章。