90 lines
3.0 KiB
Markdown
90 lines
3.0 KiB
Markdown
# bsdiff for Go
|
|
|
|
This wrapper implementation for Golang reuses the existing
|
|
C version of bsdiff as provided by @mendsley and wraps it
|
|
into a Go package, abstracting away all the cgo work that
|
|
would need to be done otherwise.
|
|
|
|
## Installation
|
|
|
|
The library and the helper binaries `go-bsdiff` and `go-bspatch` can be installed like this:
|
|
|
|
go get -v github.com/icedream/go-bsdiff/...
|
|
|
|
## Usage in application code
|
|
|
|
For exact documentation of the library check out [GoDoc](https://godoc.org/github.com/icedream/go-bsdiff).
|
|
|
|
Library functionality is provided both as a package `bsdiff` containing both
|
|
methods `Diff` and `Patch`, or as subpackages `diff` and `patch` which each
|
|
only link the wanted functionality.
|
|
|
|
Below example will generate a patch and apply it again in one go. This code
|
|
is not safe against errors but it shows how to use the provided routines:
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"os"
|
|
"github.com/icedream/go-bsdiff"
|
|
// Or use the subpackages to only link what you need:
|
|
//"github.com/icedream/go-bsdiff/diff"
|
|
//"github.com/icedream/go-bsdiff/patch"
|
|
)
|
|
|
|
const (
|
|
oldFilePath = "your_old_file.dat"
|
|
newFilePath = "your_new_file.dat"
|
|
patchFilePath = "the_generated.patch"
|
|
)
|
|
|
|
func generatePatch() error {
|
|
oldFile, _ := os.Open(oldFilePath)
|
|
defer oldFile.Close()
|
|
newFile, _ := os.Open(newFilePath)
|
|
defer newFile.Close()
|
|
patchFile, _ := os.Create(patchFilePath)
|
|
defer patchFile.Close()
|
|
|
|
return bsdiff.Diff(oldFile, newFile, patchFile)
|
|
}
|
|
|
|
func applyPatch() error {
|
|
oldFile, _ := os.Open(oldFilePath)
|
|
defer oldFile.Close()
|
|
newFile, _ := os.Create(newFilePath)
|
|
defer newFile.Close()
|
|
patchFile, _ := os.Open(patchFilePath)
|
|
defer patchFile.Close()
|
|
|
|
return bsdiff.Patch(oldFile, newFile, patchFile)
|
|
}
|
|
|
|
func main() {
|
|
generatePatch()
|
|
applyPatch()
|
|
}
|
|
```
|
|
|
|
## Usage of the tools
|
|
|
|
The tools `go-bsdiff` and `go-bspatch` both provide a `--help` flag to print
|
|
out all information but in their simplest form, they can be used like this:
|
|
|
|
```sh
|
|
# Creates a patch file $the_generated with differences from
|
|
# $your_old_file to $your_new_file.
|
|
go-bsdiff "$your_old_file" "$your_new_file" "$the_generated"
|
|
|
|
# Applies a patch file $the_generated on "your_old_file
|
|
# and saves the new file to $your_new_file.
|
|
go-bspatch "$your_old_file" "$your_new_file" "$the_generated"
|
|
```
|
|
|
|
## Motivation
|
|
|
|
There is [a Go implementation of an older version of bsdiff called binarydist](https://github.com/kr/binarydist). The original bsdiff tool has since been updated so patches generating using the original tool are no longer compatible with the Go implementation. I don't know what the changes between the versions are and unfortunately I don't have the time to search for these changes and port them over as a pull request, otherwise I'd have done that instead.
|
|
|
|
Additionally, @mendsley has already done the extra work of rewriting the code to be embeddable in any application code as a library. So why not make use of cgo, which I was going to look into in more detail at some point anyways?
|