void test_network_remote_remotes__parsing(void) { git_remote *_remote2 = NULL; cl_assert_equal_s(git_remote_name(_remote), "test"); cl_assert_equal_s(git_remote_url(_remote), "git://github.com/libgit2/libgit2"); cl_assert(git_remote_pushurl(_remote) == NULL); cl_assert_equal_s(git_remote__urlfordirection(_remote, GIT_DIRECTION_FETCH), "git://github.com/libgit2/libgit2"); cl_assert_equal_s(git_remote__urlfordirection(_remote, GIT_DIRECTION_PUSH), "git://github.com/libgit2/libgit2"); cl_git_pass(git_remote_lookup(&_remote2, _repo, "test_with_pushurl")); cl_assert_equal_s(git_remote_name(_remote2), "test_with_pushurl"); cl_assert_equal_s(git_remote_url(_remote2), "git://github.com/libgit2/fetchlibgit2"); cl_assert_equal_s(git_remote_pushurl(_remote2), "git://github.com/libgit2/pushlibgit2"); cl_assert_equal_s(git_remote__urlfordirection(_remote2, GIT_DIRECTION_FETCH), "git://github.com/libgit2/fetchlibgit2"); cl_assert_equal_s(git_remote__urlfordirection(_remote2, GIT_DIRECTION_PUSH), "git://github.com/libgit2/pushlibgit2"); git_remote_free(_remote2); }
static int clone_local_into(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, int link, const git_signature *signature) { int error, flags; git_repository *src; git_buf src_odb = GIT_BUF_INIT, dst_odb = GIT_BUF_INIT, src_path = GIT_BUF_INIT; git_buf reflog_message = GIT_BUF_INIT; assert(repo && remote); if (!git_repository_is_empty(repo)) { giterr_set(GITERR_INVALID, "the repository is not empty"); return -1; } /* * Let's figure out what path we should use for the source * repo, if it's not rooted, the path should be relative to * the repository's worktree/gitdir. */ if ((error = git_path_from_url_or_path(&src_path, git_remote_url(remote))) < 0) return error; /* Copy .git/objects/ from the source to the target */ if ((error = git_repository_open(&src, git_buf_cstr(&src_path))) < 0) { git_buf_free(&src_path); return error; } git_buf_joinpath(&src_odb, git_repository_path(src), GIT_OBJECTS_DIR); git_buf_joinpath(&dst_odb, git_repository_path(repo), GIT_OBJECTS_DIR); if (git_buf_oom(&src_odb) || git_buf_oom(&dst_odb)) { error = -1; goto cleanup; } flags = 0; if (can_link(git_repository_path(src), git_repository_path(repo), link)) flags |= GIT_CPDIR_LINK_FILES; if ((error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb), flags, GIT_OBJECT_DIR_MODE)) < 0) goto cleanup; git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); if ((error = git_remote_fetch(remote, signature, git_buf_cstr(&reflog_message))) != 0) goto cleanup; error = checkout_branch(repo, remote, co_opts, branch, signature, git_buf_cstr(&reflog_message)); cleanup: git_buf_free(&reflog_message); git_buf_free(&src_path); git_buf_free(&src_odb); git_buf_free(&dst_odb); git_repository_free(src); return error; }
void test_network_remote_local__fetch_default_reflog_message(void) { char *refspec_strings[] = { "master:remotes/sloppy/master", }; git_strarray array = { refspec_strings, 1, }; git_reflog *log; const git_reflog_entry *entry; char expected_reflog_msg[1024]; connect_to_local_repository(cl_fixture("testrepo.git")); cl_git_pass(git_remote_fetch(remote, &array, NULL, NULL)); cl_git_pass(git_reflog_read(&log, repo, "refs/remotes/sloppy/master")); cl_assert_equal_i(1, git_reflog_entrycount(log)); entry = git_reflog_entry_byindex(log, 0); cl_assert_equal_s("*****@*****.**", git_reflog_entry_committer(entry)->email); sprintf(expected_reflog_msg, "fetch %s", git_remote_url(remote)); cl_assert_equal_s(expected_reflog_msg, git_reflog_entry_message(entry)); git_reflog_free(log); }
void test_clone_local__git_style_unc_paths(void) { #ifdef GIT_WIN32 git_repository *repo; git_remote *remote; git_clone_options opts = GIT_CLONE_OPTIONS_INIT; git_buf git_unc = GIT_BUF_INIT; /* we use a fixture path because it needs to exist for us to want to clone */ const char *path = cl_fixture("testrepo.git"); cl_git_pass(git_style_unc_path(&git_unc, "localhost", path)); cl_git_pass(git_clone(&repo, git_unc.ptr, "./clone.git", &opts)); cl_git_pass(git_remote_lookup(&remote, repo, "origin")); cl_assert_equal_s(git_unc.ptr, git_remote_url(remote)); git_remote_free(remote); git_repository_free(repo); git_buf_free(&git_unc); cl_git_pass(git_futils_rmdir_r("./clone.git", NULL, GIT_RMDIR_REMOVE_FILES)); #endif }
emacs_value egit_remote_url(emacs_env *env, emacs_value _remote) { EGIT_ASSERT_REMOTE(_remote); git_remote *remote = EGIT_EXTRACT(_remote); const char *url = git_remote_url(remote); return EM_STRING(url); }
/* * call-seq: * remote.url() -> string * * Returns the remote's url * remote.url #=> "git://github.com/libgit2/rugged.git" */ static VALUE rb_git_remote_url(VALUE self) { git_remote *remote; Data_Get_Struct(self, git_remote, remote); return rb_str_new_utf8(git_remote_url(remote)); }
/** * ggit_remote_get_url: * @remote: GgitRemote. * * Gets the remote's url. * * Returns: (transfer none) (nullable): the url of @remote or %NULL. */ const gchar * ggit_remote_get_url (GgitRemote *remote) { g_return_val_if_fail (GGIT_IS_REMOTE (remote), NULL); return git_remote_url (_ggit_native_get (remote)); }
static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch_options *opts, const git_checkout_options *co_opts, const char *branch) { int error; git_buf reflog_message = GIT_BUF_INIT; git_fetch_options fetch_opts; git_remote *remote; assert(repo && _remote); if (!git_repository_is_empty(repo)) { git_error_set(GIT_ERROR_INVALID, "the repository is not empty"); return -1; } if ((error = git_remote_dup(&remote, _remote)) < 0) return error; memcpy(&fetch_opts, opts, sizeof(git_fetch_options)); fetch_opts.update_fetchhead = 0; fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL; git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); if ((error = git_remote_fetch(remote, NULL, &fetch_opts, git_buf_cstr(&reflog_message))) != 0) goto cleanup; error = checkout_branch(repo, remote, co_opts, branch, git_buf_cstr(&reflog_message)); cleanup: git_remote_free(remote); git_buf_dispose(&reflog_message); return error; }
void test_remote_insteadof__url_insteadof_not_applicable(void) { cl_git_pass(git_repository_open(&g_repo, cl_fixture(REPO_PATH))); cl_git_pass(git_remote_lookup(&g_remote, g_repo, REMOTE_ORIGIN)); cl_assert_equal_s( git_remote_url(g_remote), "https://github.com/libgit2/false.git"); }
void test_remote_insteadof__url_insteadof_applicable(void) { cl_git_pass(git_repository_open(&g_repo, cl_fixture(REPO_PATH))); cl_git_pass(git_remote_lookup(&g_remote, g_repo, REMOTE_INSTEADOF)); cl_assert_equal_s( git_remote_url(g_remote), "http://github.com/libgit2/libgit2"); }
PyObject * Remote_url__get__(Remote *self) { const char *url; url = git_remote_url(self->remote); if (!url) Py_RETURN_NONE; return to_unicode(url, NULL, NULL); }
void test_remote_insteadof__anonymous_remote(void) { cl_git_pass(git_repository_open(&g_repo, cl_fixture(REPO_PATH))); cl_git_pass(git_remote_create_anonymous(&g_remote, g_repo, "http://example.com/libgit2/libgit2")); cl_assert_equal_s( git_remote_url(g_remote), "http://github.com/libgit2/libgit2"); cl_assert_equal_p(git_remote_pushurl(g_remote), NULL); }
void test_network_remote_remotes__dup(void) { git_strarray array; git_remote *dup; cl_git_pass(git_remote_dup(&dup, _remote)); cl_assert_equal_s(git_remote_name(dup), git_remote_name(_remote)); cl_assert_equal_s(git_remote_url(dup), git_remote_url(_remote)); cl_assert_equal_s(git_remote_pushurl(dup), git_remote_pushurl(_remote)); cl_git_pass(git_remote_get_fetch_refspecs(&array, _remote)); cl_assert_equal_i(1, (int)array.count); cl_assert_equal_s("+refs/heads/*:refs/remotes/test/*", array.strings[0]); git_strarray_free(&array); cl_git_pass(git_remote_get_push_refspecs(&array, _remote)); cl_assert_equal_i(0, (int)array.count); git_strarray_free(&array); git_remote_free(dup); }
/** * Get the remote's url * * @param repo S4 class git_repository * @param remote Character vector with name of remote. NA values are * ok and give NA values as result at corresponding index in url * vector * @return Character vector with url for each remote */ SEXP git2r_remote_url(SEXP repo, SEXP remote) { int err = GIT_OK; SEXP url; size_t len; size_t i = 0; git_remote *tmp_remote; git_repository *repository = NULL; if (git2r_arg_check_string_vec(remote)) git2r_error(__func__, NULL, "'remote'", git2r_err_string_vec_arg); repository = git2r_repository_open(repo); if (!repository) git2r_error(__func__, NULL, git2r_err_invalid_repository, NULL); len = LENGTH(remote); PROTECT(url = allocVector(STRSXP, len)); for (; i < len; i++) { if (NA_STRING == STRING_ELT(remote, i)) { SET_STRING_ELT(url, i, NA_STRING); } else { err = git_remote_lookup( &tmp_remote, repository, CHAR(STRING_ELT(remote, i))); if (err) goto cleanup; SET_STRING_ELT(url, i, mkChar(git_remote_url(tmp_remote))); git_remote_free(tmp_remote); } } cleanup: if (repository) git_repository_free(repository); UNPROTECT(1); if (err) git2r_error(__func__, giterr_last(), NULL, NULL); return url; }
void test_repo_init__extended_1(void) { git_reference *ref; git_remote *remote; struct stat st; git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; 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)); if (cl_is_chmod_supported()) cl_assert((S_ISGID & st.st_mode) == S_ISGID); else cl_assert((S_ISGID & st.st_mode) == 0); 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_symbolic_target(ref)); git_reference_free(ref); cl_git_pass(git_remote_lookup(&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"); }
/* * $ git remote add addtest http://github.com/libgit2/libgit2 * * $ cat .git/config * [...] * [remote "addtest"] * url = http://github.com/libgit2/libgit2 * fetch = +refs/heads/\*:refs/remotes/addtest/\* */ void test_network_remote_remotes__add(void) { git_remote_free(_remote); _remote = NULL; cl_git_pass(git_remote_create(&_remote, _repo, "addtest", "http://github.com/libgit2/libgit2")); cl_assert_equal_i(GIT_REMOTE_DOWNLOAD_TAGS_AUTO, git_remote_autotag(_remote)); git_remote_free(_remote); _remote = NULL; cl_git_pass(git_remote_lookup(&_remote, _repo, "addtest")); cl_assert_equal_i(GIT_REMOTE_DOWNLOAD_TAGS_AUTO, git_remote_autotag(_remote)); _refspec = git_vector_get(&_remote->refspecs, 0); cl_assert_equal_s("refs/heads/*", git_refspec_src(_refspec)); cl_assert(git_refspec_force(_refspec) == 1); cl_assert_equal_s("refs/remotes/addtest/*", git_refspec_dst(_refspec)); cl_assert_equal_s(git_remote_url(_remote), "http://github.com/libgit2/libgit2"); }
static int clone_into(git_repository *repo, git_remote *_remote, const git_checkout_options *co_opts, const char *branch, const git_signature *signature) { int error; git_buf reflog_message = GIT_BUF_INIT; git_remote *remote; const git_remote_callbacks *callbacks; assert(repo && _remote); if (!git_repository_is_empty(repo)) { giterr_set(GITERR_INVALID, "the repository is not empty"); return -1; } if ((error = git_remote_dup(&remote, _remote)) < 0) return error; callbacks = git_remote_get_callbacks(_remote); if (!giterr__check_version(callbacks, 1, "git_remote_callbacks") && (error = git_remote_set_callbacks(remote, callbacks)) < 0) goto cleanup; if ((error = git_remote_add_fetch(remote, "refs/tags/*:refs/tags/*")) < 0) goto cleanup; git_remote_set_update_fetchhead(remote, 0); git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); if ((error = git_remote_fetch(remote, signature, git_buf_cstr(&reflog_message))) != 0) goto cleanup; error = checkout_branch(repo, remote, co_opts, branch, signature, git_buf_cstr(&reflog_message)); cleanup: git_remote_free(remote); git_buf_free(&reflog_message); return error; }
void test_network_createremotethenload__parsing(void) { cl_assert(!strcmp(git_remote_name(_remote), "origin")); cl_assert(!strcmp(git_remote_url(_remote), url)); }
void Gitarre::onPushAction () { Repository *repo = Repos[RepoView->currentIndex().row()]; // TODO: Add remote selection git_remote *remote = repo->GetRemote(0); struct git_remote_callbacks cb = { 1, Gitarre::sRProgressCb, Gitarre::sRCompletionCb, Gitarre::sRCredentialsCb, Gitarre::sRTransferProgressCb, Gitarre::sRUpdateTipsCb, (void *)this }; git_remote_set_callbacks (remote, &cb); // fix git protocol address const char *url = git_remote_url (remote); if (!strncmp (url, "git@", 4)) { int len = strlen (url) - 4; char *_url = (char *) malloc (len + 9); strcpy (_url, "https://"); strncpy (_url + 8, url + 4, len); _url [len + 8] = 0; char *sc = strrchr (_url, ':'); if (sc) *sc = '/'; git_remote_set_url (remote, _url); } StatusLabel->show(); StatusLabel->setText ("Connecting to remote..."); StatusProgress->show(); StatusProgress->setRange (0,0); git_remote_connect (remote, GIT_DIRECTION_PUSH); if (git_remote_connected (remote)) { git_push *push; git_push_new (&push, remote); git_push_add_refspec (push, "refs/heads/master:refs/heads/master"); git_push_set_callbacks (push, Gitarre::sPPackbuilderProgressCb, (void *)this, Gitarre::sPTransferProgressCb, (void *)this); git_push_finish (push); if (git_push_unpack_ok (push)) { git_push_status_foreach (push, Gitarre::sPStatusForeachCb, (void *)this); git_push_update_tips (push); } git_push_free (push); git_remote_disconnect (remote); git_remote_free (remote); } else { const git_error *error = giterr_last (); if (error->message) QMessageBox::warning(this, "Connect to remote", QString ("Failed to connect to ") + git_remote_url (remote) + " :\n" + error->message); else QMessageBox::warning(this, "Connect to remote", QString ("Failed to connect to ") + git_remote_url (remote)); } StatusLabel->hide(); StatusProgress->hide(); }
PyObject * Remote_url__get__(Remote *self) { return PyUnicode_FromString(git_remote_url(self->remote)); }
void test_network_remotes__parsing(void) { cl_assert_equal_s(git_remote_name(_remote), "test"); cl_assert_equal_s(git_remote_url(_remote), "git://github.com/libgit2/libgit2"); }
void test_network_remotes__parsing(void) { cl_assert(!strcmp(git_remote_name(remote), "test")); cl_assert(!strcmp(git_remote_url(remote), "git://github.com/libgit2/libgit2")); }
int NotesModel::pull() { git_repository *repo = NULL; git_remote *remote = NULL; git_merge_head *merge_head = NULL; if (!QSettings().value("gitRemoteUrl").isValid()) { qDebug() << "gitRemoteUrl setting invalid"; return false; } if (QSettings().value("gitRemoteUrl") == "") return false; try { //Open Repo e(git_repository_open(&repo, notesFolder().absolutePath().toUtf8().constData())); //List repository and add one from Settings if none exists or doesn t have same URI than settings git_strarray remotes = {0}; git_remote_list(&remotes, repo); if (remotes.count >= 1) { for (size_t i = 0; i < remotes.count; i++) { e(git_remote_load(&remote, repo, remotes.strings[i])); qDebug() << git_remote_url(remote); if (QSettings().value("gitRemoteUrl").isValid() && git_remote_url(remote)) { if (strcmp(git_remote_url(remote),QSettings().value("gitRemoteUrl").toString().toUtf8().constData()) != 0) { e(git_remote_delete(remote)); e(git_remote_create(&remote, repo, "upstream", QSettings().value("gitRemoteUrl").toString().toUtf8().constData())); e(git_remote_save(remote)); } } } } else if (remotes.count == 0) { e(git_remote_create(&remote, repo, "upstream", QSettings().value("gitRemoteUrl").toString().toUtf8().constData())); e(git_remote_save(remote)); } e(git_remote_load(&remote, repo, "upstream")); git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT; callbacks.credentials = cred_acquire_cb; e(git_remote_set_callbacks(remote, &callbacks)); e(git_remote_connect(remote, GIT_DIRECTION_FETCH)); int connected = git_remote_connected(remote); if (connected) e(git_remote_fetch(remote, NULL, NULL)); git_checkout_options checkout_opt = GIT_CHECKOUT_OPTIONS_INIT; checkout_opt.checkout_strategy = GIT_CHECKOUT_FORCE; checkout_opt.file_mode = 0644; git_merge_options merge_opt = GIT_MERGE_OPTIONS_INIT; merge_opt.file_favor = GIT_MERGE_FILE_FAVOR_UNION; const git_remote_head **head = NULL; size_t size = 0; e(git_remote_ls(&head, &size, remote)); if (size <= 0) e(-1); git_oid oid = head[0]->oid; e(git_merge_head_from_fetchhead(&merge_head, repo, "master", git_remote_url(remote), &oid)); e(git_merge(repo, (const git_merge_head **)(&merge_head), 1, &merge_opt, &checkout_opt)); //TRY TO COMMIT /* Create signature */ git_signature *me = NULL; e(git_signature_now(&me, "sparkleNotes", "*****@*****.**")); //Tree Lookup git_object *tree_obj; e(git_revparse_single(&tree_obj, repo, "HEAD^{tree}")); // Get parent commit git_oid parentCommitId; git_commit *parent; git_oid remoteParentCommitId; git_commit *remoteParent; e(git_reference_name_to_id( &parentCommitId, repo, "ORIG_HEAD" )); e(git_commit_lookup( &parent, repo, &parentCommitId )); e(git_reference_name_to_id( &remoteParentCommitId, repo, "MERGE_HEAD" )); e(git_commit_lookup( &remoteParent, repo, &remoteParentCommitId )); if (remoteParent == parent) { //Same commit ... nothing to merge e(git_repository_state_cleanup(repo)); git_merge_head_free(merge_head); git_remote_free(remote); git_repository_free(repo); return false; } const git_commit *parents [2] = { parent, remoteParent }; git_oid new_commit_id; e(git_commit_create( &new_commit_id, repo, "HEAD", /* name of ref to update */ me, /* author */ me, /* committer */ "UTF-8", /* message encoding */ "Merge remote upstream/master", /* message */ (git_tree *) tree_obj, /* root tree */ 2, /* parent count */ parents)); /* parents */ git_merge_head_free(merge_head); git_remote_free(remote); e(git_repository_state_cleanup(repo)); git_repository_free(repo); } 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_merge_head_free(merge_head); git_remote_free(remote); git_repository_free(repo); } return true; }
static int handle(KDriver const *driver, KImplementation const *impl, int requested) { char const *url = k_dictionary_get(k_implementation_get_values(impl), "href"); char const *tag = k_dictionary_get(k_implementation_get_values(impl), "tag"); char const *path = k_dictionary_get(k_implementation_get_meta(impl), "name"); git_repository* repo = NULL; git_remote* origin = NULL; if (git_repository_open(&repo, path) == GIT_OK) { if (git_remote_load(&origin, repo, "origin") != GIT_OK) { git_repository_free(repo); return -1; } if (strcmp(url, git_remote_url(origin)) != 0) { giterr_set_str(GITERR_INVALID, "different origin"); git_repository_free(repo); return -1; } } else { if (git_repository_init(&repo, path, 0) != GIT_OK) { return -1; } if (git_remote_create(&origin, repo, "origin", url) != GIT_OK) { git_repository_free(repo); return -1; } } git_remote_set_update_fetchhead(origin, 0); git_remote_set_cred_acquire_cb(origin, cred_acquire, NULL); if (git_remote_connect(origin, GIT_DIRECTION_FETCH) != GIT_OK) { git_remote_free(origin); git_repository_free(repo); return -1; } if (git_remote_download(origin, transfer_progress, NULL) != GIT_OK) { git_remote_free(origin); git_repository_free(repo); return -1; } if (git_remote_update_tips(origin) != GIT_OK) { git_remote_free(origin); git_repository_free(repo); return -1; } git_object* object = NULL; if (git_revparse_single(&object, repo, tag) != GIT_OK) { git_remote_free(origin); git_repository_free(repo); return -1; } if (git_repository_set_head_detached(repo, git_object_id(object)) != GIT_OK) { git_object_free(object); git_remote_free(origin); git_repository_free(repo); return -1; } git_checkout_opts checkout_opts = GIT_CHECKOUT_OPTS_INIT; checkout_opts.version = GIT_CHECKOUT_OPTS_VERSION; checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE; checkout_opts.progress_cb = checkout_progress; checkout_opts.progress_payload = NULL; if (git_checkout_tree(repo, object, &checkout_opts) != GIT_OK) { git_object_free(object); git_remote_free(origin); git_repository_free(repo); return -1; } git_object_free(object); git_remote_free(origin); git_repository_free(repo); return 0; }
void download(KImplementation const *impl, int requested, KError *error, void *ctx) { KDictionary const *values = k_implementation_get_values(impl); char const *href = k_dictionary_lookup(values, "href"); char const *tag = k_dictionary_lookup(values, "tag"); char const *path = k_implementation_get_name(impl); git_repository *repo = NULL; git_remote *origin = NULL; git_object *object = NULL; struct progress_data progress_data = {{0}}; git_checkout_opts checkout_opts = GIT_CHECKOUT_OPTS_INIT; checkout_opts.version = GIT_CHECKOUT_OPTS_VERSION; checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE; checkout_opts.progress_cb = checkout_progress; checkout_opts.progress_payload = &progress_data; if (git_repository_open(&repo, path) == GIT_OK) { if (git_remote_load(&origin, repo, "origin") != GIT_OK) { k_error_set(error, giterr_last()->message); goto repository_free; } if (strcmp(git_remote_url(origin), href) != 0) { k_error_set(error, "different origin"); goto remote_free; } } else { if (git_repository_init(&repo, path, 0) != GIT_OK) { k_error_set(error, giterr_last()->message); return; } if (git_remote_create(&origin, repo, "origin", href) != GIT_OK) { k_error_set(error, giterr_last()->message); goto repository_free; } } git_remote_set_update_fetchhead(origin, 0); git_remote_set_cred_acquire_cb(origin, cred_acquire, NULL); if (git_remote_connect(origin, GIT_DIRECTION_FETCH) != GIT_OK) { k_error_set(error, giterr_last()->message); goto remote_free; } if (git_remote_download(origin, fetch_progress, &progress_data) != GIT_OK) { k_error_set(error, giterr_last()->message); goto remote_disconnect; } if (git_remote_update_tips(origin) != GIT_OK) { k_error_set(error, giterr_last()->message); goto remote_disconnect; } if (git_revparse_single(&object, repo, tag) != GIT_OK) { k_error_set(error, giterr_last()->message); goto remote_disconnect; } if (git_repository_set_head_detached(repo, git_object_id(object)) != GIT_OK) { k_error_set(error, giterr_last()->message); goto remote_disconnect; } if (git_checkout_tree(repo, object, &checkout_opts) != GIT_OK) { k_error_set(error, giterr_last()->message); } remote_disconnect: git_remote_disconnect(origin); remote_free: git_remote_free(origin); repository_free: git_repository_free(repo); }
void test_network_createremotethenload__parsing(void) { cl_assert_equal_s(git_remote_name(_remote), "origin"); cl_assert_equal_s(git_remote_url(_remote), url); }
#include "test_lib.h" #include "test_helpers.h" #include <git2.h> #include <posix.h> BEGIN_TEST(remotes0, "remote parsing works") git_remote *remote; git_repository *repo; git_config *cfg; must_pass(git_repository_open(&repo, REPOSITORY_FOLDER)); must_pass(git_repository_config(&cfg, repo, NULL, NULL)); must_pass(git_remote_get(&remote, cfg, "test")); must_be_true(!strcmp(git_remote_name(remote), "test")); must_be_true(!strcmp(git_remote_url(remote), "git://github.com/libgit2/libgit2")); git_remote_free(remote); git_config_free(cfg); git_repository_free(repo); END_TEST BEGIN_TEST(refspec0, "remote with refspec works") git_remote *remote; git_repository *repo; git_config *cfg; const git_refspec *refspec = NULL; must_pass(git_repository_open(&repo, REPOSITORY_FOLDER)); must_pass(git_repository_config(&cfg, repo, NULL, NULL)); must_pass(git_remote_get(&remote, cfg, "test"));
static int clone_local_into(git_repository *repo, git_remote *remote, const git_fetch_options *fetch_opts, const git_checkout_options *co_opts, const char *branch, int link) { int error, flags; git_repository *src; git_buf src_odb = GIT_BUF_INIT, dst_odb = GIT_BUF_INIT, src_path = GIT_BUF_INIT; git_buf reflog_message = GIT_BUF_INIT; assert(repo && remote); if (!git_repository_is_empty(repo)) { git_error_set(GIT_ERROR_INVALID, "the repository is not empty"); return -1; } /* * Let's figure out what path we should use for the source * repo, if it's not rooted, the path should be relative to * the repository's worktree/gitdir. */ if ((error = git_path_from_url_or_path(&src_path, git_remote_url(remote))) < 0) return error; /* Copy .git/objects/ from the source to the target */ if ((error = git_repository_open(&src, git_buf_cstr(&src_path))) < 0) { git_buf_dispose(&src_path); return error; } if (git_repository_item_path(&src_odb, src, GIT_REPOSITORY_ITEM_OBJECTS) < 0 || git_repository_item_path(&dst_odb, repo, GIT_REPOSITORY_ITEM_OBJECTS) < 0) { error = -1; goto cleanup; } flags = 0; if (can_link(git_repository_path(src), git_repository_path(repo), link)) flags |= GIT_CPDIR_LINK_FILES; error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb), flags, GIT_OBJECT_DIR_MODE); /* * can_link() doesn't catch all variations, so if we hit an * error and did want to link, let's try again without trying * to link. */ if (error < 0 && link) { flags &= ~GIT_CPDIR_LINK_FILES; error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb), flags, GIT_OBJECT_DIR_MODE); } if (error < 0) goto cleanup; git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); if ((error = git_remote_fetch(remote, NULL, fetch_opts, git_buf_cstr(&reflog_message))) != 0) goto cleanup; error = checkout_branch(repo, remote, co_opts, branch, git_buf_cstr(&reflog_message)); cleanup: git_buf_dispose(&reflog_message); git_buf_dispose(&src_path); git_buf_dispose(&src_odb); git_buf_dispose(&dst_odb); git_repository_free(src); return error; }