Provide a way to remove old commits #619

minwoox · 2021-07-16T13:38:22Z

Motivation:
Central Dogma uses jGit to store data. Due to the nature of Git that stores unlimited history,
Central Dogma will eventually get in trouble managing disk usage.
We can handle this by maintaining the primary and secondary Git repositories internally.
This works in this way:

Commits are pushed to the primary Git repository.
If the number of commits exceeds the threshold (minRetentionCommits), then the secondary Git repository is created.
Commits are pushed to both primary and secondary Git repositories.
If the secondary Git repository has the number of commits more than the threshold;
- The secondary Git repository is promoted to the primary Git repository.
- The primary Git repository is removed completely.
- Another secondary Git repository is created.
Back to the third.

Modifications:

Add CreateRollingRepositoryCommand that creates the rolling repository by the CommitRetentionManagementPlugin.
Add GitRepositoryV2 that manages the rolling jGit repositories.
- The name of internal repositories will be: foo_0000000000, foo_0000000001, foo_0000000002 and so on
  - So that we can only store the suffix of the primary repo to maintain the repository. (i.e. We don't have to maintain the directory information of the secondary repo.)
  - RepositoryMetadataDatabase has the suffix in its file database.
- GitRepository is not removed for the migration test.
Add InternalRepository that has jGit repository and CommitIdDatabase.
What happens if the revision of an operation(such as diff, watch, history, etc.) is lower than the firstRevision of the current primary repo?
- If Revision.INIT(1) is used, the firstRevision is used instead.
  - e.g. diff(INIT, new Revision(100) ...) is equals to diff(new Revision(firstRevisionNumber), new Revision(100) ...)
- If the Revision between Revision.INIT(1) and the firstRevision is used, a RevisionNotFoundException is raised.
  - except watch and findLatestRevision.

Result:

Close Provide a way to remove the old commits #575
A repository now removes the commits that are older than minRetentionCommits while keeping the commits made in the recent minRetentionDay.

Todo:

Provide a way to set minRetentionCommits and minRetentionDay for each repository.
Unused internal repositories are removed by purging service.
Support mirroring from CD to external Git.

Motivation: Central Dogma uses jGit to store data. Due to the nature of Git that stores unlimited history, Central Dogma will eventually get in trouble managing disk usage. We can handle this by maintaing the primary and secondary Git repository internally. This works in this way: 1 Commits are pushed to the primary Git repository. 2 If the number of commits exceed the threshold (`minRetentionCommits`), then the secondary Git repository is created. 3 Commits are pushed to the both primary and secondary Git repositories. 4 If the secondary Git repository has the number of commits more than the threshold; - The secondary Git repository is promoted to the primary Git repository. - The primary Git repository is removed completely. - Another secondary Git repository is created. 5 Back to 3. Modifications: - TBD Result: - Close 575 - TBD Todo: - Provide a way to set `minRetentionCommits` and `minRetentionDay` for each repository. - Support mirroring from CD to external Git.

codecov · 2021-07-16T13:53:25Z

Codecov Report

Merging #619 (958e7a9) into master (d596a34) will decrease coverage by 2.47%.
The diff coverage is 70.35%.

❗ Current head 958e7a9 differs from pull request most recent head a40a22d. Consider uploading reports for the commit a40a22d to get more accurate results

@@             Coverage Diff              @@
##             master     #619      +/-   ##
============================================
- Coverage     69.91%   67.43%   -2.48%     
- Complexity     3305     3434     +129     
============================================
  Files           333      340       +7     
  Lines         13135    14323    +1188     
  Branches       1427     1611     +184     
============================================
+ Hits           9183     9659     +476     
- Misses         3079     3727     +648     
- Partials        873      937      +64

Impacted Files	Coverage Δ
...ecorp/centraldogma/server/CentralDogmaBuilder.java	`53.12% <0.00%> (-0.85%)`	⬇️
...orp/centraldogma/server/CommitRetentionConfig.java	`0.00% <0.00%> (ø)`
.../linecorp/centraldogma/server/command/Command.java	`74.35% <0.00%> (-13.52%)`	⬇️
...server/command/CreateRollingRepositoryCommand.java	`0.00% <0.00%> (ø)`
...ogma/server/command/StandaloneCommandExecutor.java	`83.87% <0.00%> (-3.53%)`	⬇️
...internal/storage/DirectoryBasedStorageManager.java	`63.31% <ø> (ø)`
...ver/internal/storage/repository/CacheableCall.java	`65.21% <ø> (ø)`
...internal/storage/repository/RepositoryWrapper.java	`28.57% <0.00%> (-2.68%)`	⬇️
...rage/repository/git/CacheableCompareTreesCall.java	`51.51% <ø> (ø)`
...raldogma/server/storage/repository/Repository.java	`72.11% <ø> (+9.18%)`	⬆️
... and 23 more

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update d596a34...a40a22d. Read the comment docs.

minwoox · 2021-09-13T09:14:53Z

I think this is ready. Please, review this PR when you have time. 😄

...linecorp/centraldogma/server/internal/storage/repository/git/RepositoryMetadataDatabase.java

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

...ain/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepository.java

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

...a/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryManager.java

server/src/main/java/com/linecorp/centraldogma/server/CommitRetentionConfig.java

minwoox

@ikhoon All fixed. PTAL. 😉

server/src/main/java/com/linecorp/centraldogma/server/CommitRetentionConfig.java

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

…itory by the leader

jrhee17

I haven't looked through everything, but looks awesome! 👍 Let me keep taking a look, but only nits for now 🙏

jrhee17 · 2022-01-05T01:12:52Z

...corp/centraldogma/server/internal/storage/repository/git/RepositoryMetadataDatabaseTest.java

+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class RepositoryMetadataDatabaseTest {


optional; I think it might useful and trivial to add a test where we can verify RepositoryMetadataDatabase also reads the file correctly.

@Test void writeAndRead() throws Exception { final RepositoryMetadataDatabase other = new RepositoryMetadataDatabase( db.getRootDir(), false); assertThat(other.primaryRepoDir().getName()).isEqualTo(db.primaryRepoDir().getName()); }

Thanks for the test. 🙇

jrhee17 · 2022-01-05T03:00:24Z

.../java/com/linecorp/centraldogma/server/internal/storage/repository/git/CommitIdDatabase.java

+        if (!(firstRevision.major() <= revision.major() && revision.major() <= headRevision.major())) {
+            throw new RevisionNotFoundException(
+                    "revision: " + revision +
+                    " (expected: " + firstRevision.major() + " <= revision <= " + headRevision.major() + ")");


Suggested change

" (expected: " + firstRevision.major() + " <= revision <= " + headRevision.major() + ")");

" (expected: " + firstRevision.major() + " <= revision <= " + headRevision.major() + ')');

jrhee17 · 2022-01-05T04:37:01Z

.../java/com/linecorp/centraldogma/server/internal/storage/repository/git/CommitIdDatabase.java

@@ -185,23 +223,24 @@ private synchronized void put(Revision revision, ObjectId commitId, boolean safe
        buf.flip();

        // Append a record to the file.


Suggested change

// Append a record to the file.

// Append or overwrite a record in the file.

jrhee17 · 2022-01-05T08:42:30Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+        requireNonNull(rollingRepositoryInitialRevision, "rollingRepositoryInitialRevision");
+        checkState(shouldCreateRollingRepository(rollingRepositoryInitialRevision,
+                                                 minRetentionCommits, minRetentionDays) ==
+                   rollingRepositoryInitialRevision, "aaa");


lol 😝 aaa

jrhee17 · 2022-01-05T09:12:11Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+                    // so we should catch up.
+                    final RevisionRange revisionRange = new RevisionRange(
+                            rollingRepositoryInitialRevision.forward(1), headRevision);
+                    final List<Commit> commits = primaryRepo.listCommits(ALL_PATH, MAX_MAX_COMMITS,


Q) I'm not sure how realistic/unrealistic the magic number 1000 is, but is it safe to say this won't be exceeded?
I'm asking because it seems like this implementation can break if secondaryRepo.HEAD != primaryRepo.HEAD (no problem if this isn't realistic)

I guess an alternative may be to allow partial secondaryRepo states.
This might also allow shorter write lock durations at the cost of additional complexity.

(or maybe we can just set an arbitrarily high value 🤔 )

On second thought, I realized that we're only catching up revisions between the previous HEAD revision to the current HEAD revision. I guess this scenario isn't really realistic at least with the current specification 😅 feel free to ignore

jrhee17 · 2022-01-05T09:14:50Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+                                      Revision rollingRepositoryInitialRevision) {
+        writeLock();
+        try {
+            logger.info("Promoting the secondary repository in {}/{}.", parent.name(), originalRepoName);


Q) What do you think of validating secondaryRepo.HEAD == primaryRepo.HEAD here? (inside the write lock)

That's a good suggestion. 👍

ikhoon · 2022-01-05T09:28:39Z

server/src/main/java/com/linecorp/centraldogma/server/CentralDogmaBuilder.java

+     * For example, when {@code minRetentionCommits} is set to 2000 and {@code minRetentionDays} is set to 14,
+     * the commits that are created more than 2000 are not removed until 14 days have passed. Set 0 to retain
+     * all commits.


I'm a bit confused with the policy when both minRetentionCommits and minRetentionDays are set.

the commits that are created more than 2000 are not removed until 14 days have passed.

IIUC, if commits seem not to be removed in 14 days even if the number of commits exceeds 2000.
2000 minRetentionCommits with 14 minRetentionDays sounds like Central Dogma allows 2000 commits for 14 days.
If commits are created more than 2000 in 14 days, some old commits need to be removed. Although the old commits were less than 14 days old.

ikhoon · 2022-01-05T14:12:41Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+        this.author = author;
+    }
+
+    private static boolean isEmpty(File dir) throws IOException {


nit: Move this method below the constructors?

ikhoon · 2022-01-07T14:53:33Z

...orp/centraldogma/server/internal/storage/repository/git/CommitRetentionManagementPlugin.java

+                    context.commandExecutor().execute(
+                            Command.createRollingRepository(project.name(), repo.name(), revision,
+                                                            config.minRetentionCommits(),
+                                                            config.minRetentionDays()));


Call .join() for synchronous executions?

ikhoon · 2022-01-07T14:56:27Z

...orp/centraldogma/server/internal/storage/repository/git/CommitRetentionManagementPlugin.java

+        final ProjectManager pm = context.projectManager();
+        for (Project project : pm.list().values()) {
+            for (Repository repo : project.repos().list().values()) {
+                final Revision revision = repo.shouldCreateRollingRepository(config.minRetentionCommits(),


Check stopping for each repo so that a job successfully stops in gracefully shutting down time?

ikhoon · 2022-01-07T15:15:30Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+        }
+    }
+
+    private GitRepositoryV2(Project parent, File repoDir, Executor repositoryWorker,


Could you leave a Javadoc or comment about the difference of the two constructors? :-)

ikhoon · 2022-01-07T15:27:41Z

...ava/com/linecorp/centraldogma/server/internal/storage/repository/git/InternalRepository.java

+        }
+    }
+
+    static InternalRepository of(Project parent, String originalRepoName, File repoDir,


To rhyme with open?

Suggested change

static InternalRepository of(Project parent, String originalRepoName, File repoDir,

static InternalRepository create(Project parent, String originalRepoName, File repoDir,

ikhoon · 2022-01-08T05:34:28Z

.../java/com/linecorp/centraldogma/server/internal/storage/repository/git/CommitIdDatabase.java

-                        throw new StorageException("found more than one parent: " +
-                                                   gitRepo.getDirectory());
-                }
+            rebuild(gitRepo, revWalk, headRevision, revCommit, true);


findFirstRevisionOrRebuild()?

ikhoon · 2022-01-08T06:22:56Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+            }
+        }
+
+        // Create a new instance only when necessary.


nit: I guess most requests are sent with Revision.HEAD.

Revision headRevision = this.headRevision; if (headRevision.major() == major) { return headRevision; }

ikhoon · 2022-01-08T07:57:05Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+        if (secondaryRepo != null) {
+            promoteSecondaryRepo(secondaryRepo, rollingRepositoryInitialRevision);
+        } else {
+            createSecondaryRepo(rollingRepositoryInitialRevision);
+        }


As per SPR, how about removing createSecondaryRepo() in promoteSecondaryRepo()?

Suggested change

if (secondaryRepo != null) {

promoteSecondaryRepo(secondaryRepo, rollingRepositoryInitialRevision);

} else {

createSecondaryRepo(rollingRepositoryInitialRevision);

}

if (secondaryRepo != null) {

promoteSecondaryRepo(secondaryRepo, rollingRepositoryInitialRevision);

}

createSecondaryRepo(rollingRepositoryInitialRevision);

That's a good suggestion. 👍

ks-yim · 2022-01-09T16:19:52Z

I am just asking out of curiosity 😅.

I thought of a very naive approach of doing something jGit equivalent for git rebase -i HEAD~N to rewrite commit history via fixup or squash when I first looked at the issue.

Rolling repository is awesome but at the same time looks relatively complicated compared to the rebase option.
What would be the benefit of rolling repo strategy assuming that we can do the same thing with rebase?

Maybe rewriting thousands of commit history could be too heavy or rebase doesn't give us a desired result at all?

jrhee17 · 2022-01-11T06:31:59Z

@minwoox is away for a while, so leaving my guess/analysis 😅 Feel free to correct me

I thought of a very naive approach of doing something jGit equivalent for git rebase -i HEAD~N to rewrite commit history via fixup or squash when I first looked at the issue.

From what I understand, this is what we're trying to do. We're trying to squash commits between INIT~HEAD^N.

Rolling repository is awesome but at the same time looks relatively complicated compared to the rebase option.
What would be the benefit of rolling repo strategy assuming that we can do the same thing with rebase?

My guess is so that we can make the switch atomically. If any of the intermediate steps fails while squashing (which I think would involve multiple IOs to disk) the repository may result in a corrupt state.

jrhee17 · 2022-01-11T06:43:02Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+
+        final InternalRepository repo = secondaryRepo != null ? secondaryRepo : primaryRepo;
+        if (exceedsMinRetention(repo, headRevision, minRetentionCommits, minRetentionDays)) {
+            return headRevision;


The {@link Repository} retains at least the number of {@code minRetentionCommits} when more than
* {@code minRetentionCommits} are made.

Q) From the javadocs, I guessed minRetentionCommits will be retained, but it seems like all commits up to headRevision will be squashed. Is my understanding correct?

but it seems like all commits up to headRevision will be squashed

The returned headRevision will be used as the initial revision for creating the secondary repository. So it's not squashed. Did this what you mean?

jrhee17 · 2022-01-11T06:47:25Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+                                     author, summary, detail, markup, applyingChanges, false);
+            this.headRevision = res.revision;
+            final InternalRepository secondaryRepo = this.secondaryRepo;
+            if (secondaryRepo != null) {


I still think it's possible that primaryRepo.HEAD can diverge from secondaryRepo.HEAD since the two calls to commit aren't transactional.
What do you think of adding the following condition to prevent further divergence?

Suggested change

if (secondaryRepo != null) {

if (secondaryRepo != null && Objects.equals(primaryRepo.headRevision(), secondaryRepo.headRevision())) {

since the two calls to commit aren't transactional.

We acquired writeLock before committing so I think it's transactional and it shouldn't diverge.
Let me add an assertion for that. 😉

jrhee17 · 2022-01-11T06:49:03Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+                    // so we should catch up.
+                    final RevisionRange revisionRange = new RevisionRange(
+                            rollingRepositoryInitialRevision.forward(1), headRevision);
+                    final List<Commit> commits = primaryRepo.listCommits(ALL_PATH, MAX_MAX_COMMITS,


On second thought, I realized that we're only catching up revisions between the previous HEAD revision to the current HEAD revision. I guess this scenario isn't really realistic at least with the current specification 😅 feel free to ignore

ks-yim · 2022-01-14T05:47:15Z

@jrhee17 Thanks for the reply!!

I thought we could just do something like..:

Git.wrap(jGitRepository).rebase().setUpstream("HEAD~2000").runInteractively(new InteractiveHandler() {
    @Override
    public void prepareSteps(List<RebaseTodoLine> steps) {
        if (steps.size() <= 2000) {
            return;
        }
        for (int i = 0; i < 1000; i++) {
            try {
                steps.get(i).setAction(Action.SQUASH);
            } catch (IllegalTodoFileModification e) {
                // exception handling..
            }
        }
    }

    @Override
    public String modifyCommitMessage(String commit) {
        return commit;
    }
})

My guess is so that we can make the switch atomically. If any of the intermediate steps fails while squashing (which I think would involve multiple IOs to disk) the repository may result in a corrupt state.

I am not sure if I am getting it correctly, but agree that there seems to be no easy way to handle IO errors or merge conflict with the rebase option (though I doubt squashing will cause conflict).

ikhoon · 2022-01-18T07:33:50Z

Git.wrap(jGitRepository).rebase().setUpstream("HEAD~2000")

If a repository has a long history, it would not release a write lock for a long time. The long lock causes to block threads waiting for the lock.
So we decided to avoid manipulating the working repository.
We tried to apply Git GC periodically, but it was reverted. #615
There is a mega repo in Central Dogma of LINE that has over 380k commits.
IIRC, it took almost 10 minutes to run Git GC on the repository.

minwoox · 2022-01-19T01:29:53Z

That's a good question, @ks-yim and Thanks @jrhee17 and @ikhoon for the answer. 😄

There's another reason that I didn't use squash because it modifies the Git Hashes that we are internally using for revision mapping.
Let's look at the following example:

1th commit(hash: foo) -> 2nd commit(hash: bar) -> 3rd commit(hash: baz)

If we squash 1th and 2nd then the commits will be:

1th and 2nd commit(hash: fooX) -> 3rd commit(hash: bazX)
                                             This one is also changed.

The hashes of all commits after the squash point are changed so I can't just do the squash. 😄

ks-yim · 2022-01-19T02:19:15Z

Thanks for the detailed comments!!
There's a lot of heavy lifting done for users under the hood in CD 👍!

minwoox · 2022-02-23T07:47:15Z

I'm a bit confused with the policy when both minRetentionCommits and minRetentionDays are set.

Had a chat with @ikhoon and we decided to keep the current behavior. 😄

minwoox

Address all comments, PTAL. 🙇

minwoox · 2022-02-15T05:03:17Z

...corp/centraldogma/server/internal/storage/repository/git/RepositoryMetadataDatabaseTest.java

+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class RepositoryMetadataDatabaseTest {


Thanks for the test. 🙇

minwoox · 2022-02-15T05:10:13Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+                                     author, summary, detail, markup, applyingChanges, false);
+            this.headRevision = res.revision;
+            final InternalRepository secondaryRepo = this.secondaryRepo;
+            if (secondaryRepo != null) {


since the two calls to commit aren't transactional.

We acquired writeLock before committing so I think it's transactional and it shouldn't diverge.
Let me add an assertion for that. 😉

minwoox · 2022-02-15T05:19:02Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+
+        final InternalRepository repo = secondaryRepo != null ? secondaryRepo : primaryRepo;
+        if (exceedsMinRetention(repo, headRevision, minRetentionCommits, minRetentionDays)) {
+            return headRevision;


but it seems like all commits up to headRevision will be squashed

The returned headRevision will be used as the initial revision for creating the secondary repository. So it's not squashed. Did this what you mean?

minwoox · 2022-02-15T05:19:14Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+        requireNonNull(rollingRepositoryInitialRevision, "rollingRepositoryInitialRevision");
+        checkState(shouldCreateRollingRepository(rollingRepositoryInitialRevision,
+                                                 minRetentionCommits, minRetentionDays) ==
+                   rollingRepositoryInitialRevision, "aaa");


minwoox · 2022-02-15T05:20:30Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+        if (secondaryRepo != null) {
+            promoteSecondaryRepo(secondaryRepo, rollingRepositoryInitialRevision);
+        } else {
+            createSecondaryRepo(rollingRepositoryInitialRevision);
+        }


That's a good suggestion. 👍

minwoox · 2022-02-15T05:22:14Z

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java

+                                      Revision rollingRepositoryInitialRevision) {
+        writeLock();
+        try {
+            logger.info("Promoting the secondary repository in {}/{}.", parent.name(), originalRepoName);


That's a good suggestion. 👍

minwoox · 2022-02-23T13:56:46Z

https://github.com/line/centraldogma/runs/5300517235?check_suite_focus=true#step:5:659

It seems like the cache of the build exists and isn't cleaned somehow. 😓
Let me close this PR and send it again.

minwoox added breaking change improvement new feature labels Jul 16, 2021

minwoox added this to the 0.52.0 milestone Jul 16, 2021

minwoox modified the milestones: 0.52.0, 0.52.1, 0.52.2 Aug 24, 2021

minwoox added 2 commits September 11, 2021 01:06

WIP

9d5e250

Add tests

c0bafb3

minwoox marked this pull request as ready for review September 13, 2021 09:14

minwoox requested review from ikhoon and trustin as code owners September 13, 2021 09:14

Fix test

2f8e107

minwoox force-pushed the GitV2 branch from 4a7c1f7 to 2f8e107 Compare September 14, 2021 05:15

Close repo in test

96fd44c

ikhoon reviewed Sep 17, 2021

View reviewed changes

Address comments by @ikhoon

e0a78f8

minwoox commented Sep 24, 2021

View reviewed changes

ikhoon reviewed Oct 4, 2021

View reviewed changes

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java Outdated Show resolved Hide resolved

...n/java/com/linecorp/centraldogma/server/internal/storage/repository/git/GitRepositoryV2.java Show resolved Hide resolved

ikhoon modified the milestones: 0.52.2, 0.53.0 Oct 8, 2021

ikhoon modified the milestones: 0.53.0, 0.54.0 Dec 3, 2021

Merge branch 'master' into GitV2

d241167

minwoox requested a review from jrhee17 as a code owner December 23, 2021 07:41

WIP

1c5185a

minwoox added 2 commits January 3, 2022 16:05

Introduce CreateRollingRepository command to create the rolling repos…

7b21b1a

…itory by the leader

Fix NonNullByDefault

958e7a9

jrhee17 reviewed Jan 5, 2022

View reviewed changes

ikhoon reviewed Jan 5, 2022

View reviewed changes

ikhoon reviewed Jan 8, 2022

View reviewed changes

jrhee17 reviewed Jan 11, 2022

View reviewed changes

ikhoon modified the milestones: 0.54.0, 0.55.0 Jan 28, 2022

minwoox added 2 commits February 21, 2022 17:25

WIP

cd622e4

Address the comment by @jrhee17 and @ikhoon

9fef35d

minwoox commented Feb 23, 2022

View reviewed changes

Remove unused import

a40a22d

minwoox modified the milestones: 0.55.0, 0.55.1 Feb 23, 2022

minwoox closed this Feb 23, 2022

jrhee17 modified the milestones: 0.56.0, 0.56.1 Mar 29, 2022

minwoox removed this from the 0.56.0 milestone Jul 6, 2022

	" (expected: " + firstRevision.major() + " <= revision <= " + headRevision.major() + ")");
	" (expected: " + firstRevision.major() + " <= revision <= " + headRevision.major() + ')');

		@@ -185,23 +223,24 @@ private synchronized void put(Revision revision, ObjectId commitId, boolean safe
		buf.flip();

		// Append a record to the file.

	// Append a record to the file.
	// Append or overwrite a record in the file.

	static InternalRepository of(Project parent, String originalRepoName, File repoDir,
	static InternalRepository create(Project parent, String originalRepoName, File repoDir,

	if (secondaryRepo != null) {
	if (secondaryRepo != null && Objects.equals(primaryRepo.headRevision(), secondaryRepo.headRevision())) {

Provide a way to remove old commits #619

Provide a way to remove old commits #619

Conversation

minwoox commented Jul 16, 2021 • edited Loading

codecov bot commented Jul 16, 2021 • edited Loading

Codecov Report

minwoox commented Sep 13, 2021

minwoox left a comment

Choose a reason for hiding this comment

jrhee17 left a comment • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ks-yim commented Jan 9, 2022

jrhee17 commented Jan 11, 2022

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ks-yim commented Jan 14, 2022 • edited Loading

ikhoon commented Jan 18, 2022 • edited Loading

minwoox commented Jan 19, 2022

ks-yim commented Jan 19, 2022

minwoox commented Feb 23, 2022

minwoox left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

minwoox commented Feb 23, 2022

minwoox commented Jul 16, 2021 •

edited

Loading

codecov bot commented Jul 16, 2021 •

edited

Loading

jrhee17 left a comment •

edited

Loading

ks-yim commented Jan 14, 2022 •

edited

Loading

ikhoon commented Jan 18, 2022 •

edited

Loading