From 0ef25268fa8f64949d68c3eac355c3ce455857e2 Mon Sep 17 00:00:00 2001 From: lhchavez Date: Fri, 23 Dec 2016 19:46:55 -0800 Subject: [PATCH] Also add support for git_odb_writepack --- indexer.go | 32 +++++++---------------- odb.go | 77 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ wrapper.c | 22 +++++++++++++++- 3 files changed, 108 insertions(+), 23 deletions(-) diff --git a/indexer.go b/indexer.go index 80f34fe..6653628 100644 --- a/indexer.go +++ b/indexer.go @@ -16,19 +16,11 @@ import ( "unsafe" ) -//export indexerTransferProgress -func indexerTransferProgress(_stats *C.git_transfer_progress, ptr unsafe.Pointer) C.int { - callback, ok := pointerHandles.Get(ptr).(TransferProgressCallback) - if !ok { - return 0 - } - return C.int(callback(newTransferProgressFromC(_stats))) -} - type Indexer struct { - ptr *C.git_indexer - stats C.git_transfer_progress - callback unsafe.Pointer + ptr *C.git_indexer + stats C.git_transfer_progress + callbacks RemoteCallbacks + callbacksHandle unsafe.Pointer } func NewIndexer(packfilePath string, odb *Odb, callback TransferProgressCallback) (indexer *Indexer, err error) { @@ -42,15 +34,12 @@ func NewIndexer(packfilePath string, odb *Odb, callback TransferProgressCallback odbPtr = odb.ptr } - if callback != nil { - indexer.callback = pointerHandles.Track(callback) - } + indexer.callbacks.TransferProgressCallback = callback + indexer.callbacksHandle = pointerHandles.Track(&indexer.callbacks) - ret := C._go_git_indexer_new(&indexer.ptr, C.CString(packfilePath), 0, odbPtr, indexer.callback) + ret := C._go_git_indexer_new(&indexer.ptr, C.CString(packfilePath), 0, odbPtr, indexer.callbacksHandle) if ret < 0 { - if indexer.callback != nil { - pointerHandles.Untrack(indexer.callback) - } + pointerHandles.Untrack(indexer.callbacksHandle) return nil, MakeGitError(ret) } @@ -87,8 +76,7 @@ func (indexer *Indexer) Commit() (*Oid, error) { } func (indexer *Indexer) Free() { - if indexer.callback != nil { - pointerHandles.Untrack(indexer.callback) - } + pointerHandles.Untrack(indexer.callbacksHandle) + runtime.SetFinalizer(indexer, nil) C.git_indexer_free(indexer.ptr) } diff --git a/odb.go b/odb.go index 248cb55..74a09be 100644 --- a/odb.go +++ b/odb.go @@ -6,6 +6,10 @@ package git 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 ( @@ -229,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) } @@ -342,3 +370,52 @@ func (stream *OdbWriteStream) Free() { runtime.SetFinalizer(stream, nil) C.git_odb_stream_free(stream.ptr) } + +func odbWritepackTransferProgress(_stats *C.git_transfer_progress, ptr unsafe.Pointer) C.int { + callback, ok := pointerHandles.Get(ptr).(TransferProgressCallback) + if !ok { + return 0 + } + return C.int(callback(newTransferProgressFromC(_stats))) +} + +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/wrapper.c b/wrapper.c index d0ca4b6..dd35f88 100644 --- a/wrapper.c +++ b/wrapper.c @@ -174,9 +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)&indexerTransferProgress, progress_cb_payload); + return git_indexer_new(out, path, mode, odb, (git_transfer_progress_cb)transferProgressCallback, progress_cb_payload); } /* EOF */