mirror of
https://github.com/martinvonz/jj.git
synced 2024-10-23 15:00:17 +00:00
60fae3114e
It seems better to have the caller pass the transaction description when we finish the transaction than when we start it. That way we have all the information we want to include more readily available.
219 lines
8.7 KiB
Rust
219 lines
8.7 KiB
Rust
// Copyright 2020 The Jujutsu Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
use std::path::Path;
|
|
|
|
use itertools::Itertools;
|
|
use jj_lib::repo::{Repo, StoreFactories};
|
|
use jj_lib::workspace::{default_working_copy_factories, Workspace};
|
|
use test_case::test_case;
|
|
use testutils::{create_random_commit, load_repo_at_head, TestRepoBackend, TestWorkspace};
|
|
|
|
fn copy_directory(src: &Path, dst: &Path) {
|
|
std::fs::create_dir(dst).ok();
|
|
for entry in std::fs::read_dir(src).unwrap() {
|
|
let child_src = entry.unwrap().path();
|
|
let base_name = child_src.file_name().unwrap();
|
|
let child_dst = dst.join(base_name);
|
|
if child_src.is_dir() {
|
|
copy_directory(&child_src, &child_dst)
|
|
} else {
|
|
std::fs::copy(&child_src, &child_dst).unwrap();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn merge_directories(left: &Path, base: &Path, right: &Path, output: &Path) {
|
|
std::fs::create_dir(output).unwrap();
|
|
let mut sub_dirs = vec![];
|
|
// Walk the left side and copy to the output
|
|
if left.exists() {
|
|
for entry in std::fs::read_dir(left).unwrap() {
|
|
let path = entry.unwrap().path();
|
|
let base_name = path.file_name().unwrap();
|
|
let child_left = left.join(base_name);
|
|
let child_output = output.join(base_name);
|
|
if child_left.is_dir() {
|
|
sub_dirs.push(base_name.to_os_string());
|
|
} else {
|
|
std::fs::copy(&child_left, child_output).unwrap();
|
|
}
|
|
}
|
|
}
|
|
// Walk the base and find files removed in the right side, then remove them in
|
|
// the output
|
|
if base.exists() {
|
|
for entry in std::fs::read_dir(base).unwrap() {
|
|
let path = entry.unwrap().path();
|
|
let base_name = path.file_name().unwrap();
|
|
let child_base = base.join(base_name);
|
|
let child_right = right.join(base_name);
|
|
let child_output = output.join(base_name);
|
|
if child_base.is_dir() {
|
|
sub_dirs.push(base_name.to_os_string());
|
|
} else if !child_right.exists() {
|
|
std::fs::remove_file(child_output).ok();
|
|
}
|
|
}
|
|
}
|
|
// Walk the right side and find files added in the right side, then add them in
|
|
// the output
|
|
if right.exists() {
|
|
for entry in std::fs::read_dir(right).unwrap() {
|
|
let path = entry.unwrap().path();
|
|
let base_name = path.file_name().unwrap();
|
|
let child_base = base.join(base_name);
|
|
let child_right = right.join(base_name);
|
|
let child_output = output.join(base_name);
|
|
if child_right.is_dir() {
|
|
sub_dirs.push(base_name.to_os_string());
|
|
} else if !child_base.exists() {
|
|
// This overwrites the left side if that's been written. That's fine, since the
|
|
// point of the test is that it should be okay for either side to win.
|
|
std::fs::copy(&child_right, child_output).unwrap();
|
|
}
|
|
}
|
|
}
|
|
// Do the merge in subdirectories
|
|
for base_name in sub_dirs.iter().sorted().dedup() {
|
|
let child_base = base.join(base_name);
|
|
let child_right = right.join(base_name);
|
|
let child_left = left.join(base_name);
|
|
let child_output = output.join(base_name);
|
|
merge_directories(&child_left, &child_base, &child_right, &child_output);
|
|
}
|
|
}
|
|
|
|
#[test_case(TestRepoBackend::Local; "local backend")]
|
|
#[test_case(TestRepoBackend::Git; "git backend")]
|
|
fn test_bad_locking_children(backend: TestRepoBackend) {
|
|
// Test that two new commits created on separate machines are both visible (not
|
|
// lost due to lack of locking)
|
|
let settings = testutils::user_settings();
|
|
let test_workspace = TestWorkspace::init_with_backend(&settings, backend);
|
|
let repo = &test_workspace.repo;
|
|
let workspace_root = test_workspace.workspace.workspace_root();
|
|
|
|
let mut tx = repo.start_transaction(&settings);
|
|
let initial = create_random_commit(tx.mut_repo(), &settings)
|
|
.set_parents(vec![repo.store().root_commit_id().clone()])
|
|
.write()
|
|
.unwrap();
|
|
tx.commit("test");
|
|
|
|
// Simulate a write of a commit that happens on one machine
|
|
let machine1_root = test_workspace.root_dir().join("machine1");
|
|
copy_directory(workspace_root, &machine1_root);
|
|
let machine1_workspace = Workspace::load(
|
|
&settings,
|
|
&machine1_root,
|
|
&StoreFactories::default(),
|
|
&default_working_copy_factories(),
|
|
)
|
|
.unwrap();
|
|
let machine1_repo = machine1_workspace
|
|
.repo_loader()
|
|
.load_at_head(&settings)
|
|
.unwrap();
|
|
let mut machine1_tx = machine1_repo.start_transaction(&settings);
|
|
let child1 = create_random_commit(machine1_tx.mut_repo(), &settings)
|
|
.set_parents(vec![initial.id().clone()])
|
|
.write()
|
|
.unwrap();
|
|
machine1_tx.commit("test");
|
|
|
|
// Simulate a write of a commit that happens on another machine
|
|
let machine2_root = test_workspace.root_dir().join("machine2");
|
|
copy_directory(workspace_root, &machine2_root);
|
|
let machine2_workspace = Workspace::load(
|
|
&settings,
|
|
&machine2_root,
|
|
&StoreFactories::default(),
|
|
&default_working_copy_factories(),
|
|
)
|
|
.unwrap();
|
|
let machine2_repo = machine2_workspace
|
|
.repo_loader()
|
|
.load_at_head(&settings)
|
|
.unwrap();
|
|
let mut machine2_tx = machine2_repo.start_transaction(&settings);
|
|
let child2 = create_random_commit(machine2_tx.mut_repo(), &settings)
|
|
.set_parents(vec![initial.id().clone()])
|
|
.write()
|
|
.unwrap();
|
|
machine2_tx.commit("test");
|
|
|
|
// Simulate that the distributed file system now has received the changes from
|
|
// both machines
|
|
let merged_path = test_workspace.root_dir().join("merged");
|
|
merge_directories(&machine1_root, workspace_root, &machine2_root, &merged_path);
|
|
let merged_workspace = Workspace::load(
|
|
&settings,
|
|
&merged_path,
|
|
&StoreFactories::default(),
|
|
&default_working_copy_factories(),
|
|
)
|
|
.unwrap();
|
|
let merged_repo = merged_workspace
|
|
.repo_loader()
|
|
.load_at_head(&settings)
|
|
.unwrap();
|
|
assert!(merged_repo.view().heads().contains(child1.id()));
|
|
assert!(merged_repo.view().heads().contains(child2.id()));
|
|
let op_id = merged_repo.op_id().clone();
|
|
let op = merged_repo.op_store().read_operation(&op_id).unwrap();
|
|
assert_eq!(op.parents.len(), 2);
|
|
}
|
|
|
|
#[test_case(TestRepoBackend::Local ; "local backend")]
|
|
#[test_case(TestRepoBackend::Git ; "git backend")]
|
|
fn test_bad_locking_interrupted(backend: TestRepoBackend) {
|
|
// Test that an interrupted update of the op-heads resulting in on op-head
|
|
// that's a descendant of the other is resolved without creating a new
|
|
// operation.
|
|
let settings = testutils::user_settings();
|
|
let test_workspace = TestWorkspace::init_with_backend(&settings, backend);
|
|
let repo = &test_workspace.repo;
|
|
|
|
let mut tx = repo.start_transaction(&settings);
|
|
let initial = create_random_commit(tx.mut_repo(), &settings)
|
|
.set_parents(vec![repo.store().root_commit_id().clone()])
|
|
.write()
|
|
.unwrap();
|
|
let repo = tx.commit("test");
|
|
|
|
// Simulate a crash that resulted in the old op-head left in place. We simulate
|
|
// it somewhat hackily by copying the .jj/op_heads/ directory before the
|
|
// operation and then copying that back afterwards, leaving the existing
|
|
// op-head(s) in place.
|
|
let op_heads_dir = repo.repo_path().join("op_heads");
|
|
let backup_path = test_workspace.root_dir().join("backup");
|
|
copy_directory(&op_heads_dir, &backup_path);
|
|
let mut tx = repo.start_transaction(&settings);
|
|
create_random_commit(tx.mut_repo(), &settings)
|
|
.set_parents(vec![initial.id().clone()])
|
|
.write()
|
|
.unwrap();
|
|
let op_id = tx.commit("test").operation().id().clone();
|
|
|
|
copy_directory(&backup_path, &op_heads_dir);
|
|
// Reload the repo and check that only the new head is present.
|
|
let reloaded_repo = load_repo_at_head(&settings, repo.repo_path());
|
|
assert_eq!(reloaded_repo.op_id(), &op_id);
|
|
// Reload once more to make sure that the .jj/op_heads/ directory was updated
|
|
// correctly.
|
|
let reloaded_repo = load_repo_at_head(&settings, repo.repo_path());
|
|
assert_eq!(reloaded_repo.op_id(), &op_id);
|
|
}
|