static void
reset_commit_to_repair (SeafRepo *repo, SeafCommit *parent, char *new_root_id)
{
SeafCommit *new_commit = NULL;
new_commit = seaf_commit_new (NULL, repo->id, new_root_id,
parent->creator_name, parent->creator_id,
"Repaired by system", 0);
if (!new_commit) {
seaf_warning ("Out of memory, stop to run fsck for repo %.8s.\n",
repo->id);
return;
}
new_commit->parent_id = g_strdup (parent->commit_id);
seaf_repo_to_commit (repo, new_commit);
new_commit->repaired = TRUE;
seaf_message ("Update repo %.8s status to commit %.8s.\n",
repo->id, new_commit->commit_id);
seaf_branch_set_commit (repo->head, new_commit->commit_id);
if (seaf_branch_manager_add_branch (seaf->branch_mgr, repo->head) < 0) {
seaf_warning ("Update head of repo %.8s to commit %.8s failed, "
"recover failed.\n", repo->id, new_commit->commit_id);
} else {
seaf_commit_manager_add_commit (seaf->commit_mgr, new_commit);
}
seaf_commit_unref (new_commit);
}
static int
do_create_virtual_repo (SeafRepoManager *mgr,
SeafRepo *origin_repo,
const char *repo_id,
const char *repo_name,
const char *repo_desc,
const char *root_id,
const char *user,
const char *passwd,
GError **error)
{
SeafRepo *repo = NULL;
SeafCommit *commit = NULL;
SeafBranch *master = NULL;
int ret = 0;
repo = seaf_repo_new (repo_id, repo_name, repo_desc);
repo->no_local_history = TRUE;
if (passwd != NULL && passwd[0] != '\0') {
repo->encrypted = TRUE;
repo->enc_version = origin_repo->enc_version;
seafile_generate_magic (repo->enc_version, repo_id, passwd, repo->magic);
if (repo->enc_version == 2)
memcpy (repo->random_key, origin_repo->random_key, 96);
}
/* Virtual repos share fs and block store with origin repo and
* have the same version as the origin.
*/
repo->version = origin_repo->version;
memcpy (repo->store_id, origin_repo->id, 36);
commit = seaf_commit_new (NULL, repo->id,
root_id, /* root id */
user, /* creator */
EMPTY_SHA1, /* creator id */
repo_desc, /* description */
0); /* ctime */
seaf_repo_to_commit (repo, commit);
if (seaf_commit_manager_add_commit (seaf->commit_mgr, commit) < 0) {
seaf_warning ("Failed to add commit.\n");
g_set_error (error, SEAFILE_DOMAIN, SEAF_ERR_GENERAL,
"Failed to add commit");
ret = -1;
goto out;
}
master = seaf_branch_new ("master", repo->id, commit->commit_id);
if (seaf_branch_manager_add_branch (seaf->branch_mgr, master) < 0) {
seaf_warning ("Failed to add branch.\n");
g_set_error (error, SEAFILE_DOMAIN, SEAF_ERR_GENERAL,
"Failed to add branch");
ret = -1;
goto out;
}
if (seaf_repo_set_head (repo, master) < 0) {
seaf_warning ("Failed to set repo head.\n");
g_set_error (error, SEAFILE_DOMAIN, SEAF_ERR_GENERAL,
"Failed to set repo head.");
ret = -1;
goto out;
}
if (seaf_repo_manager_add_repo (mgr, repo) < 0) {
seaf_warning ("Failed to add repo.\n");
g_set_error (error, SEAFILE_DOMAIN, SEAF_ERR_GENERAL,
"Failed to add repo.");
ret = -1;
goto out;
}
out:
if (repo)
seaf_repo_unref (repo);
if (commit)
seaf_commit_unref (commit);
if (master)
seaf_branch_unref (master);
return ret;
}
static int
fast_forward_or_merge (const char *repo_id,
SeafCommit *base,
SeafCommit *new_commit)
{
#define MAX_RETRY_COUNT 3
SeafRepo *repo = NULL;
SeafCommit *current_head = NULL, *merged_commit = NULL;
int retry_cnt = 0;
int ret = 0;
repo = seaf_repo_manager_get_repo (seaf->repo_mgr, repo_id);
if (!repo) {
seaf_warning ("Repo %s doesn't exist.\n", repo_id);
ret = -1;
goto out;
}
retry:
current_head = seaf_commit_manager_get_commit (seaf->commit_mgr,
repo->id, repo->version,
repo->head->commit_id);
if (!current_head) {
seaf_warning ("Failed to find head commit of %s.\n", repo_id);
ret = -1;
goto out;
}
/* Merge if base and head are not the same. */
if (strcmp (base->commit_id, current_head->commit_id) != 0) {
MergeOptions opt;
const char *roots[3];
char *desc = NULL;
memset (&opt, 0, sizeof(opt));
opt.n_ways = 3;
memcpy (opt.remote_repo_id, repo_id, 36);
memcpy (opt.remote_head, new_commit->commit_id, 40);
opt.do_merge = TRUE;
roots[0] = base->root_id; /* base */
roots[1] = current_head->root_id; /* head */
roots[2] = new_commit->root_id; /* remote */
if (seaf_merge_trees (repo->store_id, repo->version, 3, roots, &opt) < 0) {
seaf_warning ("Failed to merge.\n");
ret = -1;
goto out;
}
if (!opt.conflict)
desc = g_strdup("Auto merge by system");
else {
desc = gen_merge_description (repo,
opt.merged_tree_root,
current_head->root_id,
new_commit->root_id);
if (!desc)
desc = g_strdup("Auto merge by system");
}
merged_commit = seaf_commit_new(NULL, repo->id, opt.merged_tree_root,
new_commit->creator_name, EMPTY_SHA1,
desc,
0);
g_free (desc);
merged_commit->parent_id = g_strdup (current_head->commit_id);
merged_commit->second_parent_id = g_strdup (new_commit->commit_id);
merged_commit->new_merge = TRUE;
if (opt.conflict)
merged_commit->conflict = TRUE;
seaf_repo_to_commit (repo, merged_commit);
if (seaf_commit_manager_add_commit (seaf->commit_mgr, merged_commit) < 0) {
seaf_warning ("Failed to add commit.\n");
ret = -1;
goto out;
}
} else {
seaf_commit_ref (new_commit);
merged_commit = new_commit;
}
seaf_branch_set_commit(repo->head, merged_commit->commit_id);
if (seaf_branch_manager_test_and_update_branch(seaf->branch_mgr,
repo->head,
current_head->commit_id) < 0)
{
seaf_repo_unref (repo);
repo = NULL;
seaf_commit_unref (current_head);
current_head = NULL;
seaf_commit_unref (merged_commit);
merged_commit = NULL;
repo = seaf_repo_manager_get_repo (seaf->repo_mgr, repo_id);
if (!repo) {
seaf_warning ("Repo %s doesn't exist.\n", repo_id);
ret = -1;
goto out;
}
if (++retry_cnt <= MAX_RETRY_COUNT) {
seaf_message ("Concurrent branch update, retry.\n");
/* Sleep random time between 100 and 1000 millisecs. */
USLEEP (g_random_int_range(1, 11) * 100 * 1000);
goto retry;
} else {
seaf_warning ("Stop retrying.\n");
ret = -1;
goto out;
}
}
out:
seaf_commit_unref (current_head);
seaf_commit_unref (merged_commit);
seaf_repo_unref (repo);
return ret;
}
static void
enable_sync_repo (const char *repo_id)
{
SeafRepo *repo = NULL;
SeafCommit *parent_commit = NULL;
SeafCommit *new_commit = NULL;
gboolean exists;
if (!is_uuid_valid (repo_id)) {
seaf_warning ("Invalid repo id %s.\n", repo_id);
return;
}
exists = seaf_repo_manager_repo_exists (seaf->repo_mgr, repo_id);
if (!exists) {
seaf_warning ("Repo %.8s doesn't exist.\n", repo_id);
return;
}
repo = seaf_repo_manager_get_repo (seaf->repo_mgr, repo_id);
if (!repo)
return;
if (!repo->repaired) {
seaf_repo_unref (repo);
return;
}
seaf_message ("Enabling sync repo %s.\n", repo_id);
parent_commit = seaf_commit_manager_get_commit_compatible (seaf->commit_mgr,
repo_id,
repo->head->commit_id);
if (!parent_commit) {
seaf_warning ("Commit %s:%s is missing\n",
repo_id, repo->head->commit_id);
goto out;
}
new_commit = seaf_commit_new (NULL, repo_id, parent_commit->root_id,
parent_commit->creator_name,
parent_commit->creator_id,
"Enable sync repo", 0);
if (!new_commit) {
seaf_warning ("Out of memory when create commit.\n");
goto out;
}
new_commit->parent_id = g_strdup (parent_commit->commit_id);
seaf_repo_to_commit (repo, new_commit);
new_commit->repaired = FALSE;
if (seaf_commit_manager_add_commit (seaf->commit_mgr,
new_commit) < 0) {
seaf_warning ("Failed to save commit %.8s for repo %.8s.\n",
new_commit->commit_id, repo_id);
goto out;
}
seaf_branch_set_commit (repo->head, new_commit->commit_id);
if (seaf_branch_manager_update_branch (seaf->branch_mgr,
repo->head) < 0) {
seaf_warning ("Failed to update head commit %.8s to repo %.8s.\n",
new_commit->commit_id, repo_id);
} else {
seaf_message ("Enable sync repo %.8s success.\n",
repo_id);
}
out:
if (parent_commit)
seaf_commit_unref (parent_commit);
if (new_commit)
seaf_commit_unref (new_commit);
if (repo)
seaf_repo_unref (repo);
}
static int
do_real_merge (SeafRepo *repo,
SeafBranch *head_branch,
SeafCommit *head,
SeafBranch *remote_branch,
SeafCommit *remote,
SeafCommit *common,
gboolean recover_merge,
char **error)
{
struct merge_options opts;
char index_path[SEAF_PATH_MAX];
struct index_state istate;
char *root_id = NULL;
SeafCommit *merged;
int ret = 0, clean;
memset (&istate, 0, sizeof(istate));
snprintf (index_path, SEAF_PATH_MAX, "%s/%s", repo->manager->index_dir, repo->id);
if (read_index_from (&istate, index_path) < 0) {
g_warning ("Failed to load index.\n");
*error = g_strdup ("Internal error.\n");
return -1;
}
init_merge_options (&opts);
opts.index = &istate;
opts.worktree = repo->worktree;
opts.ancestor = "common ancestor";
opts.branch1 = seaf->session->base.user_name;
opts.branch2 = remote->creator_name;
opts.remote_head = remote->commit_id;
opts.recover_merge = recover_merge;
if (repo->encrypted) {
opts.crypt = seafile_crypt_new (repo->enc_version,
repo->enc_key,
repo->enc_iv);
}
ret = merge_recursive (&opts,
head->root_id, remote->root_id, common->root_id,
&clean, &root_id);
if (ret < 0)
goto out;
if (update_index (&istate, index_path) < 0) {
*error = g_strdup ("Internal error.\n");
ret = -1;
goto out;
}
if (clean) {
merged = seaf_commit_new (NULL,
repo->id,
root_id,
repo->email ? repo->email
: seaf->session->base.user_name,
seaf->session->base.id,
"Auto merge by seafile system",
0);
merged->parent_id = g_strdup(head->commit_id);
merged->second_parent_id = g_strdup(remote->commit_id);
seaf_repo_to_commit (repo, merged);
if (seaf_commit_manager_add_commit (seaf->commit_mgr, merged) < 0) {
seaf_commit_unref (merged);
*error = g_strdup ("Internal error.\n");
ret = -1;
goto out;
}
seaf_branch_set_commit (head_branch, merged->commit_id);
seaf_branch_manager_update_branch (seaf->branch_mgr, head_branch);
g_debug ("Auto merged.\n");
seaf_commit_unref (merged);
} else {
ret = -1;
g_debug ("Auto merge failed.\n");
}
out:
if (root_id)
g_free (root_id);
g_free (opts.crypt);
clear_merge_options (&opts);
discard_index (&istate);
return ret;
}