static int create_and_configure_origin(
git_remote **out,
git_repository *repo,
const char *url,
const git_clone_options *options)
{
int error;
git_remote *origin = NULL;
const char *name;
name = options->remote_name ? options->remote_name : "origin";
if ((error = git_remote_create(&origin, repo, name, url)) < 0)
goto on_error;
if (options->ignore_cert_errors)
git_remote_check_cert(origin, 0);
if ((error = git_remote_set_callbacks(origin, &options->remote_callbacks)) < 0)
goto on_error;
if ((error = git_remote_save(origin)) < 0)
goto on_error;
*out = origin;
return 0;
on_error:
git_remote_free(origin);
return error;
}
int git_remote_create_with_fetchspec(git_remote **out, git_repository *repo, const char *name, const char *url, const char *fetch)
{
git_remote *remote = NULL;
int error;
if ((error = ensure_remote_name_is_valid(name)) < 0)
return error;
if ((error = ensure_remote_doesnot_exist(repo, name)) < 0)
return error;
if (create_internal(&remote, repo, name, url, fetch) < 0)
goto on_error;
if (git_remote_save(remote) < 0)
goto on_error;
*out = remote;
return 0;
on_error:
git_remote_free(remote);
return -1;
}
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/*");
}
int git_remote_create(git_remote **out, git_repository *repo, const char *name, const char *url)
{
git_buf buf = GIT_BUF_INIT;
git_remote *remote = NULL;
int error;
if ((error = ensure_remote_name_is_valid(name)) < 0)
return error;
if ((error = ensure_remote_doesnot_exist(repo, name)) < 0)
return error;
if (git_buf_printf(&buf, "+refs/heads/*:refs/remotes/%s/*", name) < 0)
return -1;
if (create_internal(&remote, repo, name, url, git_buf_cstr(&buf)) < 0)
goto on_error;
git_buf_free(&buf);
if (git_remote_save(remote) < 0)
goto on_error;
*out = remote;
return 0;
on_error:
git_buf_free(&buf);
git_remote_free(remote);
return -1;
}
/*
* call-seq:
* remote.save -> true
*
* Saves the remote data ( url, fetchspecs, ...) to the config
*
* One can't save a in-memory remote created with Remote.new.
* Doing so will result in an exception being raised.
*/
static VALUE rb_git_remote_save(VALUE self)
{
git_remote *remote;
Data_Get_Struct(self, git_remote, remote);
rugged_exception_check(
git_remote_save(remote)
);
return Qtrue;
}
PyObject *
Remote_save(Remote *self, PyObject *args)
{
int err;
err = git_remote_save(self->remote);
if (err == GIT_OK) {
Py_RETURN_NONE;
}
else {
return Error_set(err);
}
}
void test_refs_branches_remote__ambiguous_remote_returns_error(void)
{
git_remote *remote;
/* Create the remote */
cl_git_pass(git_remote_create(&remote, g_repo, "addtest", "http://github.com/libgit2/libgit2"));
/* Update the remote fetch spec */
cl_git_pass(git_remote_set_fetchspec(remote, "refs/heads/*:refs/remotes/test/*"));
cl_git_pass(git_remote_save(remote));
git_remote_free(remote);
cl_git_fail_with(git_branch_remote_name(NULL, 0, g_repo,
remote_tracking_branch_name), GIT_EAMBIGUOUS);
}
static int create_and_configure_origin(
git_remote **out,
git_repository *repo,
const char *url,
const git_clone_options *options)
{
int error;
git_remote *origin = NULL;
if ((error = git_remote_create(&origin, repo, options->remote_name, url)) < 0)
goto on_error;
git_remote_set_cred_acquire_cb(origin, options->cred_acquire_cb,
options->cred_acquire_payload);
git_remote_set_autotag(origin, options->remote_autotag);
/*
* Don't write FETCH_HEAD, we'll check out the remote tracking
* branch ourselves based on the server's default.
*/
git_remote_set_update_fetchhead(origin, 0);
if (options->remote_callbacks &&
(error = git_remote_set_callbacks(origin, options->remote_callbacks)) < 0)
goto on_error;
if (options->fetch_spec &&
(error = git_remote_set_fetchspec(origin, options->fetch_spec)) < 0)
goto on_error;
if (options->push_spec &&
(error = git_remote_set_pushspec(origin, options->push_spec)) < 0)
goto on_error;
if (options->pushurl &&
(error = git_remote_set_pushurl(origin, options->pushurl)) < 0)
goto on_error;
if ((error = git_remote_save(origin)) < 0)
goto on_error;
*out = origin;
return 0;
on_error:
git_remote_free(origin);
return error;
}
static int create_and_configure_origin(
git_remote **out,
git_repository *repo,
const char *url,
const git_clone_options *options)
{
int error;
git_remote *origin = NULL;
char buf[GIT_PATH_MAX];
git_remote_create_cb remote_create = options->remote_cb;
void *payload = options->remote_cb_payload;
/* If the path exists and is a dir, the url should be the absolute path */
if (git_path_root(url) < 0 && git_path_exists(url) && git_path_isdir(url)) {
if (p_realpath(url, buf) == NULL)
return -1;
url = buf;
}
if (!remote_create) {
remote_create = default_remote_create;
payload = (void *)&options->remote_callbacks;
}
if ((error = remote_create(&origin, repo, "origin", url, payload)) < 0)
goto on_error;
if ((error = git_remote_save(origin)) < 0)
goto on_error;
*out = origin;
return 0;
on_error:
git_remote_free(origin);
return error;
}
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;
}