Also add support for git_odb_writepack

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)
 }

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)
+}

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 */