diff --git a/indexer.go b/indexer.go new file mode 100644 index 0000000..de486e3 --- /dev/null +++ b/indexer.go @@ -0,0 +1,92 @@ +package git + +/* +#include + +extern const git_oid * git_indexer_hash(const git_indexer *idx); +extern int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_transfer_progress *stats); +extern int git_indexer_commit(git_indexer *idx, git_transfer_progress *stats); +extern int _go_git_indexer_new(git_indexer **out, const char *path, unsigned int mode, git_odb *odb, void *progress_cb_payload); +extern void git_indexer_free(git_indexer *idx); +*/ +import "C" +import ( + "reflect" + "runtime" + "unsafe" +) + +// Indexer can post-process packfiles and create an .idx file for efficient +// lookup. +type Indexer struct { + ptr *C.git_indexer + stats C.git_transfer_progress + callbacks RemoteCallbacks + callbacksHandle unsafe.Pointer +} + +// NewIndexer creates a new indexer instance. +func NewIndexer(packfilePath string, odb *Odb, callback TransferProgressCallback) (indexer *Indexer, err error) { + indexer = new(Indexer) + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + var odbPtr *C.git_odb = nil + if odb != nil { + odbPtr = odb.ptr + } + + indexer.callbacks.TransferProgressCallback = callback + indexer.callbacksHandle = pointerHandles.Track(&indexer.callbacks) + + ret := C._go_git_indexer_new(&indexer.ptr, C.CString(packfilePath), 0, odbPtr, indexer.callbacksHandle) + if ret < 0 { + pointerHandles.Untrack(indexer.callbacksHandle) + return nil, MakeGitError(ret) + } + + runtime.SetFinalizer(indexer, (*Indexer).Free) + return indexer, nil +} + +// Write adds data to the indexer. +func (indexer *Indexer) Write(data []byte) (int, error) { + header := (*reflect.SliceHeader)(unsafe.Pointer(&data)) + ptr := unsafe.Pointer(header.Data) + size := C.size_t(header.Len) + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + ret := C.git_indexer_append(indexer.ptr, ptr, size, &indexer.stats) + if ret < 0 { + return 0, MakeGitError(ret) + } + + return len(data), nil +} + +// Commit finalizes the pack and index. It resolves any pending deltas and +// writes out the index file. +// +// It also returns the packfile's hash. A packfile's name is derived from the +// sorted hashing of all object names. +func (indexer *Indexer) Commit() (*Oid, error) { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + ret := C.git_indexer_commit(indexer.ptr, &indexer.stats) + if ret < 0 { + return nil, MakeGitError(ret) + } + + return newOidFromC(C.git_indexer_hash(indexer.ptr)), nil +} + +// Free frees the indexer and its resources. +func (indexer *Indexer) Free() { + pointerHandles.Untrack(indexer.callbacksHandle) + runtime.SetFinalizer(indexer, nil) + C.git_indexer_free(indexer.ptr) +} diff --git a/odb.go b/odb.go index 28bfad6..f6584ce 100644 --- a/odb.go +++ b/odb.go @@ -3,8 +3,13 @@ package git /* #include +extern int git_odb_backend_one_pack(git_odb_backend **out, const char *index_file); extern int _go_git_odb_foreach(git_odb *db, void *payload); extern void _go_git_odb_backend_free(git_odb_backend *backend); +extern int _go_git_odb_write_pack(git_odb_writepack **out, git_odb *db, void *progress_payload); +extern int _go_git_odb_writepack_append(git_odb_writepack *writepack, const void *, size_t, git_transfer_progress *); +extern int _go_git_odb_writepack_commit(git_odb_writepack *writepack, git_transfer_progress *); +extern void _go_git_odb_writepack_free(git_odb_writepack *writepack); */ import "C" import ( @@ -41,8 +46,19 @@ func NewOdbBackendFromC(ptr *C.git_odb_backend) (backend *OdbBackend) { return backend } -func (v *Odb) AddBackend(backend *OdbBackend, priority int) (err error) { +func (v *Odb) AddAlternate(backend *OdbBackend, priority int) (err error) { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + ret := C.git_odb_add_alternate(v.ptr, backend.ptr, C.int(priority)) + if ret < 0 { + backend.Free() + return MakeGitError(ret) + } + return nil +} + +func (v *Odb) AddBackend(backend *OdbBackend, priority int) (err error) { runtime.LockOSThread() defer runtime.UnlockOSThread() @@ -54,12 +70,24 @@ func (v *Odb) AddBackend(backend *OdbBackend, priority int) (err error) { return nil } +func NewOdbBackendOnePack(packfileIndexPath string) (backend *OdbBackend, err error) { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + var odbOnePack *C.git_odb_backend = nil + ret := C.git_odb_backend_one_pack(&odbOnePack, C.CString(packfileIndexPath)) + if ret < 0 { + return nil, MakeGitError(ret) + } + return NewOdbBackendFromC(odbOnePack), nil +} + func (v *Odb) ReadHeader(oid *Oid) (uint64, ObjectType, error) { runtime.LockOSThread() defer runtime.UnlockOSThread() - + var sz C.size_t - var cotype C.git_otype + var cotype C.git_otype ret := C.git_odb_read_header(&sz, &cotype, v.ptr, oid.toC()) if ret < 0 { @@ -68,7 +96,7 @@ func (v *Odb) ReadHeader(oid *Oid) (uint64, ObjectType, error) { return uint64(sz), ObjectType(cotype), nil } - + func (v *Odb) Exists(oid *Oid) bool { ret := C.git_odb_exists(v.ptr, oid.toC()) return ret != 0 @@ -205,6 +233,30 @@ func (v *Odb) NewWriteStream(size int64, otype ObjectType) (*OdbWriteStream, err return stream, nil } +// NewWritePack opens a stream for writing a pack file to the ODB. If the ODB +// layer understands pack files, then the given packfile will likely be +// streamed directly to disk (and a corresponding index created). If the ODB +// layer does not understand pack files, the objects will be stored in whatever +// format the ODB layer uses. +func (v *Odb) NewWritePack(callback TransferProgressCallback) (*OdbWritepack, error) { + writepack := new(OdbWritepack) + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + writepack.callbacks.TransferProgressCallback = callback + writepack.callbacksHandle = pointerHandles.Track(&writepack.callbacks) + + ret := C._go_git_odb_write_pack(&writepack.ptr, v.ptr, writepack.callbacksHandle) + if ret < 0 { + pointerHandles.Untrack(writepack.callbacksHandle) + return nil, MakeGitError(ret) + } + + runtime.SetFinalizer(writepack, (*OdbWritepack).Free) + return writepack, nil +} + func (v *OdbBackend) Free() { C._go_git_odb_backend_free(v.ptr) } @@ -318,3 +370,45 @@ func (stream *OdbWriteStream) Free() { runtime.SetFinalizer(stream, nil) C.git_odb_stream_free(stream.ptr) } + +// OdbWritepack is a stream to write a packfile to the ODB. +type OdbWritepack struct { + ptr *C.git_odb_writepack + stats C.git_transfer_progress + callbacks RemoteCallbacks + callbacksHandle unsafe.Pointer +} + +func (writepack *OdbWritepack) Write(data []byte) (int, error) { + header := (*reflect.SliceHeader)(unsafe.Pointer(&data)) + ptr := unsafe.Pointer(header.Data) + size := C.size_t(header.Len) + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + ret := C._go_git_odb_writepack_append(writepack.ptr, ptr, size, &writepack.stats) + if ret < 0 { + return 0, MakeGitError(ret) + } + + return len(data), nil +} + +func (writepack *OdbWritepack) Commit() error { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + ret := C._go_git_odb_writepack_commit(writepack.ptr, &writepack.stats) + if ret < 0 { + return MakeGitError(ret) + } + + return nil +} + +func (writepack *OdbWritepack) Free() { + pointerHandles.Untrack(writepack.callbacksHandle) + runtime.SetFinalizer(writepack, nil) + C._go_git_odb_writepack_free(writepack.ptr) +} diff --git a/vendor/libgit2 b/vendor/libgit2 index ee89941..ae5838f 160000 --- a/vendor/libgit2 +++ b/vendor/libgit2 @@ -1 +1 @@ -Subproject commit ee89941fa2b861332defb5e3a8ce12c23c496ed7 +Subproject commit ae5838f118a4819e608990a815bf8fc482be5772 diff --git a/wrapper.c b/wrapper.c index 7407611..dd35f88 100644 --- a/wrapper.c +++ b/wrapper.c @@ -174,4 +174,29 @@ void _go_git_writestream_free(git_writestream *stream) stream->free(stream); } +int _go_git_odb_write_pack(git_odb_writepack **out, git_odb *db, void *progress_payload) +{ + return git_odb_write_pack(out, db, (git_transfer_progress_cb)transferProgressCallback, progress_payload); +} + +int _go_git_odb_writepack_append(git_odb_writepack *writepack, const void *data, size_t size, git_transfer_progress *stats) +{ + return writepack->append(writepack, data, size, stats); +} + +int _go_git_odb_writepack_commit(git_odb_writepack *writepack, git_transfer_progress *stats) +{ + return writepack->commit(writepack, stats); +} + +void _go_git_odb_writepack_free(git_odb_writepack *writepack) +{ + writepack->free(writepack); +} + +int _go_git_indexer_new(git_indexer **out, const char *path, unsigned int mode, git_odb *odb, void *progress_cb_payload) +{ + return git_indexer_new(out, path, mode, odb, (git_transfer_progress_cb)transferProgressCallback, progress_cb_payload); +} + /* EOF */