void test_network_remoterename__renamed_name_is_persisted(void) { git_remote *renamed; git_repository *another_repo; cl_git_fail(git_remote_load(&renamed, _repo, "just/renamed")); cl_git_pass(git_remote_rename(_remote, "just/renamed", dont_call_me_cb, NULL)); cl_git_pass(git_repository_open(&another_repo, "testrepo.git")); cl_git_pass(git_remote_load(&renamed, _repo, "just/renamed")); git_remote_free(renamed); git_repository_free(another_repo); }
void test_network_remotes__save(void) { git_remote_free(_remote); /* Set up the remote and save it to config */ cl_git_pass(git_remote_new(&_remote, _repo, "upstream", "git://github.com/libgit2/libgit2", NULL)); cl_git_pass(git_remote_set_fetchspec(_remote, "refs/heads/*:refs/remotes/upstream/*")); cl_git_pass(git_remote_set_pushspec(_remote, "refs/heads/*:refs/heads/*")); cl_git_pass(git_remote_save(_remote)); git_remote_free(_remote); _remote = NULL; /* Load it from config and make sure everything matches */ cl_git_pass(git_remote_load(&_remote, _repo, "upstream")); _refspec = git_remote_fetchspec(_remote); cl_assert(_refspec != NULL); cl_assert_equal_s(git_refspec_src(_refspec), "refs/heads/*"); cl_assert_equal_s(git_refspec_dst(_refspec), "refs/remotes/upstream/*"); _refspec = git_remote_pushspec(_remote); cl_assert(_refspec != NULL); cl_assert_equal_s(git_refspec_src(_refspec), "refs/heads/*"); cl_assert_equal_s(git_refspec_dst(_refspec), "refs/heads/*"); }
static int use_remote(git_repository *repo, char *name) { git_remote *remote = NULL; int error; git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT; // Find the remote by name error = git_remote_load(&remote, repo, name); if (error < 0) { error = git_remote_create_inmemory(&remote, repo, NULL, name); if (error < 0) goto cleanup; } callbacks.credentials = cred_acquire_cb; git_remote_set_callbacks(remote, &callbacks); error = git_remote_connect(remote, GIT_DIRECTION_FETCH); if (error < 0) goto cleanup; error = git_remote_ls(remote, &show_ref__cb, NULL); cleanup: git_remote_free(remote); return error; }
void test_clone_nonetwork__custom_origin_name(void) { g_options.remote_name = "my_origin"; cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options)); cl_git_pass(git_remote_load(&g_remote, g_repo, "my_origin")); }
static void fetchhead_test_fetch(const char *fetchspec, const char *expected_fetchhead) { git_remote *remote; git_buf fetchhead_buf = GIT_BUF_INIT; int equals = 0; cl_git_pass(git_remote_load(&remote, g_repo, "origin")); git_remote_set_autotag(remote, GIT_REMOTE_DOWNLOAD_TAGS_AUTO); if(fetchspec != NULL) { git_remote_clear_refspecs(remote); git_remote_add_fetch(remote, fetchspec); } cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH)); cl_git_pass(git_remote_download(remote)); cl_git_pass(git_remote_update_tips(remote, NULL, NULL)); git_remote_disconnect(remote); git_remote_free(remote); cl_git_pass(git_futils_readbuffer(&fetchhead_buf, "./foo/.git/FETCH_HEAD")); equals = (strcmp(fetchhead_buf.ptr, expected_fetchhead) == 0); git_buf_free(&fetchhead_buf); cl_assert(equals); }
PyObject * Repository_remotes__get__(Repository *self) { git_strarray remotes; git_remote *remote = NULL; PyObject *py_list = NULL; PyObject *py_remote = NULL; size_t i; int err; git_remote_list(&remotes, self->repo); py_list = PyList_New(remotes.count); for (i=0; i < remotes.count; ++i) { err = git_remote_load(&remote, self->repo, remotes.strings[i]); if (err < 0) goto cleanup; py_remote = wrap_remote(remote, self); if (py_remote == NULL) goto cleanup; PyList_SetItem(py_list, i, py_remote); } git_strarray_free(&remotes); return (PyObject*) py_list; cleanup: git_strarray_free(&remotes); if (py_list) Py_DECREF(py_list); if (err < 0) return Error_set(err); return NULL; }
void test_online_fetch__doesnt_retrieve_a_pack_when_the_repository_is_up_to_date(void) { git_repository *_repository; bool invoked = false; git_remote *remote; git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT; git_clone_options opts = GIT_CLONE_OPTIONS_INIT; opts.bare = true; cl_git_pass(git_clone(&_repository, "https://github.com/libgit2/TestGitRepository.git", "./fetch/lg2", &opts)); git_repository_free(_repository); cl_git_pass(git_repository_open(&_repository, "./fetch/lg2")); cl_git_pass(git_remote_load(&remote, _repository, "origin")); cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH)); cl_assert_equal_i(false, invoked); callbacks.transfer_progress = &transferProgressCallback; callbacks.payload = &invoked; git_remote_set_callbacks(remote, &callbacks); cl_git_pass(git_remote_download(remote)); cl_assert_equal_i(false, invoked); cl_git_pass(git_remote_update_tips(remote, NULL, NULL)); git_remote_disconnect(remote); git_remote_free(remote); git_repository_free(_repository); }
static int remote_name(git_buf *buf, git_repository *repo, const char *canonical_branch_name) { git_strarray remote_list = {0}; size_t i; git_remote *remote; const git_refspec *fetchspec; int error = 0; char *remote_name = NULL; assert(buf && repo && canonical_branch_name); /* Verify that this is a remote branch */ if (!git_reference__is_remote(canonical_branch_name)) { giterr_set(GITERR_INVALID, "Reference '%s' is not a remote branch.", canonical_branch_name); error = GIT_ERROR; goto cleanup; } /* Get the remotes */ if ((error = git_remote_list(&remote_list, repo)) < 0) goto cleanup; /* Find matching remotes */ for (i = 0; i < remote_list.count; i++) { if ((error = git_remote_load(&remote, repo, remote_list.strings[i])) < 0) continue; fetchspec = git_remote__matching_dst_refspec(remote, canonical_branch_name); if (fetchspec) { /* If we have not already set out yet, then set * it to the matching remote name. Otherwise * multiple remotes match this reference, and it * is ambiguous. */ if (!remote_name) { remote_name = remote_list.strings[i]; } else { git_remote_free(remote); error = GIT_EAMBIGUOUS; goto cleanup; } } git_remote_free(remote); } if (remote_name) { git_buf_clear(buf); error = git_buf_puts(buf, remote_name); } else { error = GIT_ENOTFOUND; } cleanup: git_strarray_free(&remote_list); return error; }
void test_clone_nonetwork__custom_push_url(void) { const char *url = "http://example.com"; g_options.pushurl = url; cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options)); cl_git_pass(git_remote_load(&g_remote, g_repo, "origin")); cl_assert_equal_s(url, git_remote_pushurl(g_remote)); }
void test_network_remotes__initialize(void) { cl_fixture_sandbox("testrepo.git"); cl_git_pass(git_repository_open(&_repo, "testrepo.git")); cl_git_pass(git_remote_load(&_remote, _repo, "test")); _refspec = git_remote_fetchspec(_remote); cl_assert(_refspec != NULL); }
void test_network_remotes__add(void) { git_remote_free(_remote); cl_git_pass(git_remote_add(&_remote, _repo, "addtest", "http://github.com/libgit2/libgit2")); git_remote_free(_remote); cl_git_pass(git_remote_load(&_remote, _repo, "addtest")); _refspec = git_remote_fetchspec(_remote); cl_assert(!strcmp(git_refspec_src(_refspec), "refs/heads/*")); cl_assert(!strcmp(git_refspec_dst(_refspec), "refs/remotes/addtest/*")); }
int git_branch_upstream__name( git_buf *tracking_name, git_repository *repo, const char *canonical_branch_name) { const char *remote_name, *merge_name; git_buf buf = GIT_BUF_INIT; int error = -1; git_remote *remote = NULL; const git_refspec *refspec; assert(tracking_name && canonical_branch_name); if (!git_reference__is_branch(canonical_branch_name)) return not_a_local_branch(canonical_branch_name); if ((error = retrieve_upstream_configuration( &remote_name, repo, canonical_branch_name, "branch.%s.remote")) < 0) goto cleanup; if ((error = retrieve_upstream_configuration( &merge_name, repo, canonical_branch_name, "branch.%s.merge")) < 0) goto cleanup; if (!*remote_name || !*merge_name) { giterr_set(GITERR_REFERENCE, "branch '%s' does not have an upstream", canonical_branch_name); error = GIT_ENOTFOUND; goto cleanup; } if (strcmp(".", remote_name) != 0) { if ((error = git_remote_load(&remote, repo, remote_name)) < 0) goto cleanup; refspec = git_remote__matching_refspec(remote, merge_name); if (!refspec) { error = GIT_ENOTFOUND; goto cleanup; } if (git_refspec_transform_r(&buf, refspec, merge_name) < 0) goto cleanup; } else if (git_buf_sets(&buf, merge_name) < 0) goto cleanup; error = git_buf_set(tracking_name, git_buf_cstr(&buf), git_buf_len(&buf)); cleanup: git_remote_free(remote); git_buf_free(&buf); return error; }
void test_online_clone__network_bare(void) { git_remote *origin; g_options.bare = true; cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options)); cl_assert(git_repository_is_bare(g_repo)); cl_git_pass(git_remote_load(&origin, g_repo, "origin")); git_remote_free(origin); }
void test_network_remotes__missing_refspecs(void) { git_config *cfg; git_remote_free(_remote); cl_git_pass(git_repository_config(&cfg, _repo)); cl_git_pass(git_config_set_string(cfg, "remote.specless.url", "http://example.com")); cl_git_pass(git_remote_load(&_remote, _repo, "specless")); git_config_free(cfg); }
void test_submodule_add__url_relative(void) { git_submodule *sm; git_remote *remote; /* default remote url is https://github.com/libgit2/false.git */ g_repo = cl_git_sandbox_init("testrepo2"); /* make sure we don't default to origin - rename origin -> test_remote */ cl_git_pass(git_remote_load(&remote, g_repo, "origin")); cl_git_pass(git_remote_rename(remote, "test_remote", NULL, NULL)); cl_git_fail(git_remote_load(&remote, g_repo, "origin")); git_remote_free(remote); cl_git_pass( git_submodule_add_setup(&sm, g_repo, "../TestGitRepository", "TestGitRepository", 1) ); git_submodule_free(sm); assert_submodule_url("TestGitRepository", "https://github.com/libgit2/TestGitRepository"); }
void test_online_clone__network_full(void) { git_remote *origin; cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options)); cl_assert(!git_repository_is_bare(g_repo)); cl_git_pass(git_remote_load(&origin, g_repo, "origin")); cl_assert_equal_i(GIT_REMOTE_DOWNLOAD_TAGS_AUTO, origin->download_tags); git_remote_free(origin); }
void test_clone_nonetwork__custom_push_spec(void) { const git_refspec *actual_fs; const char *spec = "+refs/heads/master:refs/heads/foo"; g_options.push_spec = spec; cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options)); cl_git_pass(git_remote_load(&g_remote, g_repo, "origin")); actual_fs = git_remote_pushspec(g_remote); cl_assert_equal_s("refs/heads/master", git_refspec_src(actual_fs)); cl_assert_equal_s("refs/heads/foo", git_refspec_dst(actual_fs)); }
void test_network_createremotethenload__initialize(void) { cl_fixture_sandbox("testrepo.git"); cl_git_pass(git_repository_open(&_repo, "testrepo.git")); cl_git_pass(git_repository_config(&_config, _repo)); cl_git_pass(git_config_set_string(_config, "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*")); cl_git_pass(git_config_set_string(_config, "remote.origin.url", url)); git_config_free(_config); cl_git_pass(git_remote_load(&_remote, _repo, "origin")); }
int git_branch_tracking( git_reference **tracking_out, git_reference *branch) { const char *remote_name, *merge_name; git_buf buf = GIT_BUF_INIT; int error = -1; git_remote *remote = NULL; const git_refspec *refspec; assert(tracking_out && branch); if (!git_reference_is_branch(branch)) return not_a_local_branch(branch); if ((error = retrieve_tracking_configuration(&remote_name, branch, "branch.%s.remote")) < 0) goto cleanup; if ((error = retrieve_tracking_configuration(&merge_name, branch, "branch.%s.merge")) < 0) goto cleanup; if (strcmp(".", remote_name) != 0) { if ((error = git_remote_load(&remote, git_reference_owner(branch), remote_name)) < 0) goto cleanup; refspec = git_remote_fetchspec(remote); if (refspec == NULL || refspec->src == NULL || refspec->dst == NULL) { error = GIT_ENOTFOUND; goto cleanup; } if (git_refspec_transform_r(&buf, refspec, merge_name) < 0) goto cleanup; } else if (git_buf_sets(&buf, merge_name) < 0) goto cleanup; error = git_reference_lookup( tracking_out, git_reference_owner(branch), git_buf_cstr(&buf)); cleanup: git_remote_free(remote); git_buf_free(&buf); return error; }
void test_network_remoterename__renaming_a_remote_without_a_fetchrefspec_doesnt_create_one(void) { git_config *config; git_remote_free(_remote); cl_git_pass(git_repository_config__weakptr(&config, _repo)); cl_git_pass(git_config_delete(config, "remote.test.fetch")); cl_git_pass(git_remote_load(&_remote, _repo, "test")); assert_config_entry_existence(_repo, "remote.test.fetch", false); cl_git_pass(git_remote_rename(_remote, "just/renamed", dont_call_me_cb, NULL)); assert_config_entry_existence(_repo, "remote.just/renamed.fetch", false); }
void test_network_remoterename__renaming_a_remote_notifies_of_non_default_fetchrefspec(void) { git_config *config; char *expected_refspecs[] = { "+refs/*:refs/*", NULL }; git_remote_free(_remote); cl_git_pass(git_repository_config__weakptr(&config, _repo)); cl_git_pass(git_config_set_string(config, "remote.test.fetch", "+refs/*:refs/*")); cl_git_pass(git_remote_load(&_remote, _repo, "test")); cl_git_pass(git_remote_rename(_remote, "just/renamed", ensure_refspecs, &expected_refspecs)); assert_config_entry_value(_repo, "remote.just/renamed.fetch", "+refs/*:refs/*"); }
int NotesModel::push() { git_push *push; git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT; git_repository *repo = NULL; git_remote *remote = NULL; if (!QSettings().value("gitRemoteUrl").isValid()) return false; if (QSettings().value("gitRemoteUrl") == "") return false; try { //Open Repo e(git_repository_open(&repo, notesFolder().absolutePath().toUtf8().constData())); e(git_remote_load(&remote, repo, "upstream")); callbacks.credentials = cred_acquire_cb; e(git_remote_set_callbacks(remote, &callbacks)); e(git_remote_connect(remote, GIT_DIRECTION_PUSH)); int connected = git_remote_connected(remote); if (connected) { e(git_push_new(&push, remote)); e(git_push_add_refspec(push, "refs/heads/master:refs/heads/master")); e(git_push_finish(push)); e(git_push_unpack_ok(push)); e(git_push_status_foreach(push, &status_cb, NULL) < 0); git_push_free(push); } } catch (int error) { const git_error *err = giterr_last(); if (err != NULL) qDebug() << QString::number(err->klass) + "\t" + QString(err->message); emit this->error(QString(err->message)); giterr_clear(); git_remote_free(remote); git_repository_free(repo); } return true; }
PyObject * Remote_init(Remote *self, PyObject *args, PyObject *kwds) { Repository* py_repo = NULL; char *name = NULL; int err; if (!PyArg_ParseTuple(args, "O!s", &RepositoryType, &py_repo, &name)) return NULL; self->repo = py_repo; Py_INCREF(self->repo); err = git_remote_load(&self->remote, py_repo->repo, name); if (err < 0) return Error_set(err); return (PyObject*) self; }
/* * call-seq: * Remote.lookup(repository, name) -> remote or nil * * Return an existing remote with +name+ in +repository+: * - +name+: a valid remote name * * Returns a new Rugged::Remote object or +nil+ if the * remote doesn't exist * * Rugged::Remote.lookup(@repo, 'origin') #=> #<Rugged::Remote:0x00000001fbfa80> */ static VALUE rb_git_remote_lookup(VALUE klass, VALUE rb_repo, VALUE rb_name) { git_remote *remote; git_repository *repo; int error; Check_Type(rb_name, T_STRING); rugged_check_repo(rb_repo); Data_Get_Struct(rb_repo, git_repository, repo); error = git_remote_load(&remote, repo, StringValueCStr(rb_name)); if (error == GIT_ENOTFOUND) return Qnil; rugged_exception_check(error); return rugged_remote_new(klass, rb_repo, remote); }
void test_repo_init__extended_1(void) { git_reference *ref; git_remote *remote; struct stat st; git_repository_init_options opts; memset(&opts, 0, sizeof(opts)); opts.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_NO_DOTGIT_DIR; opts.mode = GIT_REPOSITORY_INIT_SHARED_GROUP; opts.workdir_path = "../c_wd"; opts.description = "Awesomest test repository evah"; opts.initial_head = "development"; opts.origin_url = "https://github.com/libgit2/libgit2.git"; cl_git_pass(git_repository_init_ext(&_repo, "root/b/c.git", &opts)); cl_assert(!git__suffixcmp(git_repository_workdir(_repo), "/c_wd/")); cl_assert(!git__suffixcmp(git_repository_path(_repo), "/c.git/")); cl_assert(git_path_isfile("root/b/c_wd/.git")); cl_assert(!git_repository_is_bare(_repo)); /* repo will not be counted as empty because we set head to "development" */ cl_assert(!git_repository_is_empty(_repo)); cl_git_pass(git_path_lstat(git_repository_path(_repo), &st)); cl_assert(S_ISDIR(st.st_mode)); cl_assert((S_ISGID & st.st_mode) == S_ISGID); cl_git_pass(git_reference_lookup(&ref, _repo, "HEAD")); cl_assert(git_reference_type(ref) == GIT_REF_SYMBOLIC); cl_assert_equal_s("refs/heads/development", git_reference_target(ref)); git_reference_free(ref); cl_git_pass(git_remote_load(&remote, _repo, "origin")); cl_assert_equal_s("origin", git_remote_name(remote)); cl_assert_equal_s(opts.origin_url, git_remote_url(remote)); git_remote_free(remote); git_repository_free(_repo); cl_fixture_cleanup("root"); }
int use_remote(git_repository *repo, char *name) { git_remote *remote = NULL; int error; // Find the remote by name error = git_remote_load(&remote, repo, name); if (error < GIT_SUCCESS) goto cleanup; error = git_remote_connect(remote, GIT_DIR_FETCH); if (error < GIT_SUCCESS) goto cleanup; error = git_remote_ls(remote, &show_ref__cb, NULL); cleanup: git_remote_free(remote); return error; }
static int ensure_remote_doesnot_exist(git_repository *repo, const char *name) { int error; git_remote *remote; error = git_remote_load(&remote, repo, name); if (error == GIT_ENOTFOUND) return 0; if (error < 0) return error; git_remote_free(remote); giterr_set( GITERR_CONFIG, "Remote '%s' already exists.", name); return GIT_EEXISTS; }
/* :nodoc: */ static VALUE rb_git_remote_each(VALUE klass, VALUE rb_repo) { git_repository *repo; git_strarray remotes; size_t i; int error = 0; int exception = 0; if (!rb_block_given_p()) return rb_funcall(klass, rb_intern("to_enum"), 2, CSTR2SYM("each"), rb_repo); rugged_check_repo(rb_repo); Data_Get_Struct(rb_repo, git_repository, repo); error = git_remote_list(&remotes, repo); rugged_exception_check(error); for (i = 0; !exception && !error && i < remotes.count; ++i) { git_remote *remote; error = git_remote_load(&remote, repo, remotes.strings[i]); if (!error) { rb_protect( rb_yield, rugged_remote_new(klass, rb_repo, remote), &exception); } } git_strarray_free(&remotes); if (exception) rb_jump_tag(exception); rugged_exception_check(error); return Qnil; }
int fetch(git_repository *repo, int argc, char **argv) { git_remote *remote = NULL; const git_transfer_progress *stats; struct dl_data data; git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT; #ifndef _WIN32 pthread_t worker; #endif argc = argc; // Figure out whether it's a named remote or a URL printf("Fetching %s for repo %p\n", argv[1], repo); if (git_remote_load(&remote, repo, argv[1]) < 0) { if (git_remote_create_inmemory(&remote, repo, NULL, argv[1]) < 0) return -1; } // Set up the callbacks (only update_tips for now) callbacks.update_tips = &update_cb; callbacks.progress = &progress_cb; git_remote_set_callbacks(remote, &callbacks); // Set up the information for the background worker thread data.remote = remote; data.ret = 0; data.finished = 0; stats = git_remote_stats(remote); #ifdef _WIN32 download(&data); #else pthread_create(&worker, NULL, download, &data); // Loop while the worker thread is still running. Here we show processed // and total objects in the pack and the amount of received // data. Most frontends will probably want to show a percentage and // the download rate. do { usleep(10000); if (stats->total_objects > 0) printf("Received %d/%d objects (%d) in %" PRIuZ " bytes\r", stats->received_objects, stats->total_objects, stats->indexed_objects, stats->received_bytes); } while (!data.finished); if (data.ret < 0) goto on_error; pthread_join(worker, NULL); #endif printf("\rReceived %d/%d objects in %zu bytes\n", stats->indexed_objects, stats->total_objects, stats->received_bytes); // Disconnect the underlying connection to prevent from idling. git_remote_disconnect(remote); // Update the references in the remote's namespace to point to the // right commits. This may be needed even if there was no packfile // to download, which can happen e.g. when the branches have been // changed but all the neede objects are available locally. if (git_remote_update_tips(remote) < 0) return -1; git_remote_free(remote); return 0; on_error: git_remote_free(remote); return -1; }
void test_network_remotes__loading_a_missing_remote_returns_ENOTFOUND(void) { cl_assert_equal_i(GIT_ENOTFOUND, git_remote_load(&_remote, _repo, "just-left-few-minutes-ago")); }