From 63116ea57e6920b25d7410eda2fc1c786be8a819 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Sat, 13 Dec 2014 00:25:11 +0100 Subject: [PATCH 1/2] Update to master This deprecates the Push struct in favour of Remote.Push() --- push.go | 11 +---------- push_test.go | 25 +++++++++++++++++++++---- remote.go | 37 +++++++++++++++++++++++++++++++++++++ vendor/libgit2 | 2 +- 4 files changed, 60 insertions(+), 15 deletions(-) diff --git a/push.go b/push.go index e6fe51f..ff96b08 100644 --- a/push.go +++ b/push.go @@ -31,6 +31,7 @@ func (p *Push) Free() { C.git_push_free(p.ptr) } +// This class is deprecated. Please use Remote.Push() instead func (remote *Remote) NewPush() (*Push, error) { runtime.LockOSThread() @@ -56,16 +57,6 @@ func (p *Push) Finish() error { return nil } -func (p *Push) UnpackOk() bool { - - ret := C.git_push_unpack_ok(p.ptr) - if ret == 0 { - return false - } - return true - -} - func (p *Push) UpdateTips(sig *Signature, msg string) error { var csig *C.git_signature = nil diff --git a/push_test.go b/push_test.go index 65f4dd2..3911875 100644 --- a/push_test.go +++ b/push_test.go @@ -48,10 +48,27 @@ func Test_Push_ToRemote(t *testing.T) { }) checkFatal(t, err) - if !push.UnpackOk() { - t.Fatalf("unable to unpack") - } - defer remote.Free() defer repo.Free() } + +func TestRemotePush(t *testing.T) { + repo := createBareTestRepo(t) + defer os.RemoveAll(repo.Path()) + localRepo := createTestRepo(t) + defer os.RemoveAll(localRepo.Workdir()) + + remote, err := localRepo.CreateRemote("test_push", repo.Path()) + checkFatal(t, err) + + seedTestRepo(t, localRepo) + + err = remote.Push([]string{"refs/heads/master"}, nil, nil, "") + checkFatal(t, err) + + _, err = localRepo.LookupReference("refs/remotes/test_push/master") + checkFatal(t, err) + + _, err = repo.LookupReference("refs/heads/master") + checkFatal(t, err) +} diff --git a/remote.go b/remote.go index 604ef40..021e207 100644 --- a/remote.go +++ b/remote.go @@ -650,3 +650,40 @@ func (o *Remote) Ls(filterRefs ...string) ([]RemoteHead, error) { return heads, nil } + +func (o *Remote) Push(refspecs []string, opts *PushOptions, sig *Signature, msg string) error { + var csig *C.git_signature = nil + if sig != nil { + csig = sig.toC() + defer C.free(unsafe.Pointer(csig)) + } + + var cmsg *C.char + if msg == "" { + cmsg = nil + } else { + cmsg = C.CString(msg) + defer C.free(unsafe.Pointer(cmsg)) + } + + var copts C.git_push_options + C.git_push_init_options(&copts, C.GIT_PUSH_OPTIONS_VERSION) + if opts != nil { + copts.version = C.uint(opts.Version) + copts.pb_parallelism = C.uint(opts.PbParallelism) + } + + crefspecs := C.git_strarray{} + crefspecs.count = C.size_t(len(refspecs)) + crefspecs.strings = makeCStringsFromStrings(refspecs) + defer freeStrarray(&crefspecs) + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + ret := C.git_remote_push(o.ptr, &crefspecs, &copts, csig, cmsg) + if ret < 0 { + return MakeGitError(ret) + } + return nil +} diff --git a/vendor/libgit2 b/vendor/libgit2 index 169497d..4eb97ef 160000 --- a/vendor/libgit2 +++ b/vendor/libgit2 @@ -1 +1 @@ -Subproject commit 169497d1e7c238d2925577d1af3dc03e9a507cd3 +Subproject commit 4eb97ef3bf18403fbce351ae4cac673655d2886a From 0202f152ac515aacf38b210df7d77ca82e146663 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Sat, 13 Dec 2014 01:23:40 +0100 Subject: [PATCH 2/2] Add the new callbacks for Remote.Push() This unifies the types with the Push struct, in preparation for its deletion. --- push.go | 11 ++++------- remote.go | 41 +++++++++++++++++++++++++++++++++++++++++ wrapper.c | 7 ++++++- 3 files changed, 51 insertions(+), 8 deletions(-) diff --git a/push.go b/push.go index ff96b08..f5299c4 100644 --- a/push.go +++ b/push.go @@ -146,17 +146,14 @@ type PushCallbacks struct { TransferProgress *PushTransferProgressCallback } -type PackbuilderProgressCallback func(stage int, current uint, total uint) int -type PushTransferProgressCallback func(current uint, total uint, bytes uint) int - //export packbuilderProgress func packbuilderProgress(stage C.int, current C.uint, total C.uint, data unsafe.Pointer) C.int { - return C.int((*(*PackbuilderProgressCallback)(data))(int(stage), uint(current), uint(total))) + return C.int((*(*PackbuilderProgressCallback)(data))(int32(stage), uint32(current), uint32(total))) } -//export pushTransferProgress -func pushTransferProgress(current C.uint, total C.uint, bytes C.size_t, data unsafe.Pointer) C.int { - return C.int((*(*PushTransferProgressCallback)(data))(uint(current), uint(total), uint(bytes))) +//export pushStructTransferProgress +func pushStructTransferProgress(current C.uint, total C.uint, bytes C.size_t, data unsafe.Pointer) C.int { + return C.int((*(*PushTransferProgressCallback)(data))(uint32(current), uint32(total), uint(bytes))) } func (p *Push) SetCallbacks(callbacks PushCallbacks) { diff --git a/remote.go b/remote.go index 021e207..563aba5 100644 --- a/remote.go +++ b/remote.go @@ -53,6 +53,9 @@ type CredentialsCallback func(url string, username_from_url string, allowed_type type TransferProgressCallback func(stats TransferProgress) ErrorCode type UpdateTipsCallback func(refname string, a *Oid, b *Oid) ErrorCode type CertificateCheckCallback func(cert *Certificate, valid bool, hostname string) ErrorCode +type PackbuilderProgressCallback func(stage int32, current, total uint32) ErrorCode +type PushTransferProgressCallback func(current, total uint32, bytes uint) ErrorCode +type PushUpdateReferenceCallback func(refname, status string) ErrorCode type RemoteCallbacks struct { SidebandProgressCallback TransportMessageCallback @@ -61,8 +64,12 @@ type RemoteCallbacks struct { TransferProgressCallback UpdateTipsCallback CertificateCheckCallback + PackProgressCallback PackbuilderProgressCallback + PushTransferProgressCallback + PushUpdateReferenceCallback } + type Remote struct { ptr *C.git_remote callbacks RemoteCallbacks @@ -216,6 +223,40 @@ func certificateCheckCallback(_cert *C.git_cert, _valid C.int, _host *C.char, da return int(callbacks.CertificateCheckCallback(&cert, valid, host)) } +//export packProgressCallback +func packProgressCallback(stage C.int, current, total C.uint, data unsafe.Pointer) int { + callbacks := (*RemoteCallbacks)(data) + + if callbacks.PackProgressCallback == nil { + return 0 + } + + return int(callbacks.PackProgressCallback(int32(stage), uint32(current), uint32(total))) +} + +//export pushTransferProgressCallback +func pushTransferProgressCallback(current, total C.uint, bytes C.size_t, data unsafe.Pointer) int { + callbacks := (*RemoteCallbacks)(data) + if callbacks.PushTransferProgressCallback == nil { + return 0 + } + + return int(callbacks.PushTransferProgressCallback(uint32(current), uint32(total), uint(bytes))) +} + +//export pushUpdateReferenceCallback +func pushUpdateReferenceCallback(refname, status *C.char, data unsafe.Pointer) int { + callbacks := (*RemoteCallbacks)(data) + + if callbacks.PushUpdateReferenceCallback == nil { + return 0 + } + + return int(callbacks.PushUpdateReferenceCallback(C.GoString(refname), C.GoString(status))) +} + + + func RemoteIsValidName(name string) bool { cname := C.CString(name) defer C.free(unsafe.Pointer(cname)) diff --git a/wrapper.c b/wrapper.c index 6e33fa2..7832d7f 100644 --- a/wrapper.c +++ b/wrapper.c @@ -71,12 +71,17 @@ void _go_git_setup_diff_notify_callbacks(git_diff_options *opts) { void _go_git_setup_callbacks(git_remote_callbacks *callbacks) { typedef int (*completion_cb)(git_remote_completion_type type, void *data); typedef int (*update_tips_cb)(const char *refname, const git_oid *a, const git_oid *b, void *data); + typedef (*push_update_reference_cb)(const char *refname, const char *status, void *data); + callbacks->sideband_progress = (git_transport_message_cb)sidebandProgressCallback; callbacks->completion = (completion_cb)completionCallback; callbacks->credentials = (git_cred_acquire_cb)credentialsCallback; callbacks->transfer_progress = (git_transfer_progress_cb)transferProgressCallback; callbacks->update_tips = (update_tips_cb)updateTipsCallback; callbacks->certificate_check = (git_transport_certificate_check_cb) certificateCheckCallback; + callbacks->pack_progress = (git_packbuilder_progress) packProgressCallback; + callbacks->push_transfer_progress = (git_push_transfer_progress) pushTransferProgressCallback; + callbacks->push_update_reference = (push_update_reference_cb) pushUpdateReferenceCallback; } typedef int (*status_foreach_cb)(const char *ref, const char *msg, void *data); @@ -88,7 +93,7 @@ int _go_git_push_status_foreach(git_push *push, void *data) int _go_git_push_set_callbacks(git_push *push, void *packbuilder_progress_data, void *transfer_progress_data) { - return git_push_set_callbacks(push, packbuilderProgress, packbuilder_progress_data, pushTransferProgress, transfer_progress_data); + return git_push_set_callbacks(push, packbuilderProgress, packbuilder_progress_data, pushStructTransferProgress, transfer_progress_data); } int _go_blob_chunk_cb(char *buffer, size_t maxLen, void *payload)