archive-gh-me/onedev
1
0
Fork 0
mirror of https://github.com/theonedev/onedev.git synced 2025-12-08 18:26:30 +00:00
Code Issues Projects Releases Wiki Activity

Able to show commit without parents. Do not hold database connections for

Browse Source 
long operations
This commit is contained in:
robin shen 2017-07-10 15:22:20 +08:00
parent c60ee6c0c3
commit c6455c2939
15 changed files with 268 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/src/main/java/com/gitplex/server/git/GitPostReceiveCallback.java
View File

@ -108,7 +108,7 @@ public class GitPostReceiveCallback extends HttpServlet {
String branch = GitUtils.ref2branch(refName);
if (branch != null && project.getDefaultBranch() == null) {
RefUpdate refUpdate = project.updateRef("HEAD");
RefUpdate refUpdate = GitUtils.getRefUpdate(project.getRepository(), "HEAD");
GitUtils.linkRef(refUpdate, refName);
}

25
core/src/main/java/com/gitplex/server/git/GitUtils.java
View File

@ -25,6 +25,7 @@ import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.RefUpdate;
import org.eclipse.jgit.lib.Repository;
@ -36,6 +37,7 @@ import org.eclipse.jgit.revwalk.RevObject;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.revwalk.RevWalkUtils;
import org.eclipse.jgit.revwalk.filter.RevFilter;
import org.eclipse.jgit.treewalk.CanonicalTreeParser;
import org.eclipse.jgit.util.SystemReader;
import org.eclipse.jgit.util.io.NullOutputStream;
@ -76,11 +78,22 @@ public class GitUtils {
public static List<DiffEntry> diff(Repository repository, AnyObjectId oldRevId, AnyObjectId newRevId) {
List<DiffEntry> diffs = new ArrayList<>();
try (DiffFormatter diffFormatter = new DiffFormatter(NullOutputStream.INSTANCE);) {
try ( DiffFormatter diffFormatter = new DiffFormatter(NullOutputStream.INSTANCE);
RevWalk revWalk = new RevWalk(repository);
ObjectReader reader = repository.newObjectReader();) {
diffFormatter.setRepository(repository);
diffFormatter.setDetectRenames(true);
diffFormatter.setDiffComparator(RawTextComparator.DEFAULT);
for (DiffEntry entry: diffFormatter.scan(oldRevId, newRevId)) {
CanonicalTreeParser oldTreeParser = new CanonicalTreeParser();
if (!oldRevId.equals(ObjectId.zeroId()))
oldTreeParser.reset(reader, revWalk.parseCommit(oldRevId).getTree());
CanonicalTreeParser newTreeParser = new CanonicalTreeParser();
if (!newRevId.equals(ObjectId.zeroId()))
newTreeParser.reset(reader, revWalk.parseCommit(newRevId).getTree());
for (DiffEntry entry: diffFormatter.scan(oldTreeParser, newTreeParser)) {
if (!Objects.equal(entry.getOldPath(), entry.getNewPath())
|| !Objects.equal(entry.getOldMode(), entry.getNewMode())
|| entry.getOldId()==null || !entry.getOldId().isComplete()
@ -470,6 +483,14 @@ public class GitUtils {
return new File(gitDir, "objects").exists();
}
public static RefUpdate getRefUpdate(Repository repository, String refName) {
try {
return repository.updateRef(refName);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static void updateRef(RefUpdate refUpdate) {
try {
RefUpdate.Result result = refUpdate.forceUpdate();

2
core/src/main/java/com/gitplex/server/manager/impl/DefaultBatchWorkManager.java
View File

@ -77,7 +77,7 @@ public class DefaultBatchWorkManager implements BatchWorkManager, Runnable {
@Override
public void run() {
try {
worker.doWork(works.working);
worker.doWorks(works.working);
} catch (Exception e) {
logger.error("Error doing works", e);
} finally {

44
core/src/main/java/com/gitplex/server/manager/impl/DefaultCommitInfoManager.java
View File

@ -29,6 +29,7 @@ import org.apache.commons.lang3.SerializationUtils;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevObject;
import org.eclipse.jgit.revwalk.RevWalk;
@ -137,8 +138,8 @@ public class DefaultCommitInfoManager extends AbstractEnvironmentManager impleme
this.executorService = executorService;
}
private void doCollect(Project project, ObjectId commitId, boolean divide) {
Environment env = getEnv(project.getId().toString());
private void doCollect(Long projectId, Repository repository, ObjectId commitId, boolean divide) {
Environment env = getEnv(projectId.toString());
Store defaultStore = getStore(env, DEFAULT_STORE);
if (divide) {
@ -156,14 +157,14 @@ public class DefaultCommitInfoManager extends AbstractEnvironmentManager impleme
});
if (lastCommitId != null) {
try (RevWalk revWalk = new RevWalk(project.getRepository())) {
try (RevWalk revWalk = new RevWalk(repository)) {
if (GitUtils.parseCommit(revWalk, lastCommitId) != null)
revisions.add("^" + lastCommitId.name());
}
}
int count = 0;
for (String commitHash: new RevListCommand(project.getGitDir()).revisions(revisions).call()) {
for (String commitHash: new RevListCommand(repository.getDirectory()).revisions(revisions).call()) {
count++;
if (count > COLLECT_BATCH_SIZE) {
intermediateCommitIds.add(ObjectId.fromString(commitHash));
@ -172,10 +173,10 @@ public class DefaultCommitInfoManager extends AbstractEnvironmentManager impleme
}
for (int i=intermediateCommitIds.size()-1; i>=0; i--) {
doCollect(project, intermediateCommitIds.get(i), false);
doCollect(projectId, repository, intermediateCommitIds.get(i), false);
}
doCollect(project, commitId, false);
doCollect(projectId, repository, commitId, false);
} else {
Store commitsStore = getStore(env, COMMITS_STORE);
Store contributionsStore = getStore(env, CONTRIBUTIONS_STORE);
@ -243,7 +244,7 @@ public class DefaultCommitInfoManager extends AbstractEnvironmentManager impleme
if (lastCommitId != null)
revisions.add("^" + lastCommitId.name());
new LogCommand(project.getGitDir()) {
new LogCommand(repository.getDirectory()) {
@Override
protected void consume(LogCommit commit) {
@ -338,19 +339,19 @@ public class DefaultCommitInfoManager extends AbstractEnvironmentManager impleme
if (newCommitCount != prevCommitCount) {
bytes = SerializationUtils.serialize(newCommitCount);
defaultStore.put(txn, COMMIT_COUNT_KEY, new ArrayByteIterable(bytes));
commitCountCache.put(project.getId(), newCommitCount);
commitCountCache.put(projectId, newCommitCount);
}
if (!authors.equals(prevAuthors)) {
bytes = SerializationUtils.serialize((Serializable) authors);
defaultStore.put(txn, AUTHORS_KEY, new ArrayByteIterable(bytes));
authorsCache.remove(project.getId());
authorsCache.remove(projectId);
}
if (!committers.equals(prevCommitters)) {
bytes = SerializationUtils.serialize((Serializable) committers);
defaultStore.put(txn, COMMITTERS_KEY, new ArrayByteIterable(bytes));
committersCache.remove(project.getId());
committersCache.remove(projectId);
}
if (files.size() > MAX_COLLECTING_FILES) {
@ -361,7 +362,7 @@ public class DefaultCommitInfoManager extends AbstractEnvironmentManager impleme
}
bytes = SerializationUtils.serialize((Serializable) files);
defaultStore.put(txn, FILES_KEY, new ArrayByteIterable(bytes));
filesCache.remove(project.getId());
filesCache.remove(projectId);
bytes = new byte[20];
commitId.copyRawTo(bytes, 0);
@ -622,25 +623,34 @@ public class DefaultCommitInfoManager extends AbstractEnvironmentManager impleme
return new BatchWorker("project-" + projectId + "-collectCommitInfo") {
@Override
public void doWork(Collection<Prioritized> works) {
public void doWorks(Collection<Prioritized> works) {
AtomicReference<List<CollectingWork>> collectingWorksRef = new AtomicReference<>(null);
AtomicReference<String> projectNameRef = new AtomicReference<>(null);
AtomicReference<Repository> repositoryRef = new AtomicReference<>(null);
unitOfWork.call(new Callable<Void>() {
@Override
public Void call() throws Exception {
Project project = projectManager.load(projectId);
projectNameRef.set(project.getName());
repositoryRef.set(project.getRepository());
List<CollectingWork> collectingWorks = new ArrayList<>();
for (Object work: works)
collectingWorks.add((CollectingWork)work);
Collections.sort(collectingWorks, new CommitTimeComparator());
for (CollectingWork work: collectingWorks) {
logger.debug("Collecting commit information up to ref '{}' in project '{}'...",
work.getRefName(), project.getName());
doCollect(project, work.getCommit().copy(), true);
}
collectingWorksRef.set(collectingWorks);
return null;
}
});
for (CollectingWork work: collectingWorksRef.get()) {
logger.debug("Collecting commit information up to ref '{}' in project '{}'...",
work.getRefName(), projectNameRef.get());
doCollect(projectId, repositoryRef.get(), work.getCommit().copy(), true);
}
}
};

158
core/src/main/java/com/gitplex/server/manager/impl/DefaultPullRequestManager.java
View File

@ -17,6 +17,7 @@ import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
import javax.inject.Inject;
import javax.inject.Singleton;
@ -29,6 +30,7 @@ import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.RefUpdate;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
import org.hibernate.Query;
@ -263,7 +265,7 @@ public class DefaultPullRequestManager extends AbstractEntityManager<PullRequest
preview = new MergePreview(preview.getTargetHead(), preview.getRequestHead(),
preview.getMergeStrategy(), merged);
request.setLastMergePreview(preview);
RefUpdate refUpdate = targetProject.updateRef(request.getMergeRef());
RefUpdate refUpdate = GitUtils.getRefUpdate(targetProject.getRepository(), request.getMergeRef());
refUpdate.setNewObjectId(mergedId);
GitUtils.updateRef(refUpdate);
}
@ -272,7 +274,7 @@ public class DefaultPullRequestManager extends AbstractEntityManager<PullRequest
String targetRef = request.getTargetRef();
ObjectId targetHeadId = ObjectId.fromString(preview.getTargetHead());
RefUpdate refUpdate = targetProject.updateRef(targetRef);
RefUpdate refUpdate = GitUtils.getRefUpdate(targetProject.getRepository(), targetRef);
refUpdate.setRefLogIdent(committer);
refUpdate.setRefLogMessage("Pull request #" + request.getNumber(), true);
refUpdate.setExpectedOldObjectId(targetHeadId);
@ -339,11 +341,11 @@ public class DefaultPullRequestManager extends AbstractEntityManager<PullRequest
request.setNumber(getNextNumber(request.getTargetProject()));
dao.persist(request);
RefUpdate refUpdate = request.getTargetProject().updateRef(request.getBaseRef());
RefUpdate refUpdate = GitUtils.getRefUpdate(request.getTargetProject().getRepository(), request.getBaseRef());
refUpdate.setNewObjectId(ObjectId.fromString(request.getBaseCommitHash()));
GitUtils.updateRef(refUpdate);
refUpdate = request.getTargetProject().updateRef(request.getHeadRef());
refUpdate = GitUtils.getRefUpdate(request.getTargetProject().getRepository(), request.getHeadRef());
refUpdate.setNewObjectId(ObjectId.fromString(request.getHeadCommitHash()));
GitUtils.updateRef(refUpdate);
@ -398,7 +400,8 @@ public class DefaultPullRequestManager extends AbstractEntityManager<PullRequest
request.addUpdate(update);
pullRequestUpdateManager.save(update, true);
RefUpdate refUpdate = request.getTargetProject().updateRef(request.getHeadRef());
RefUpdate refUpdate = GitUtils.getRefUpdate(request.getTargetProject().getRepository(),
request.getHeadRef());
refUpdate.setNewObjectId(ObjectId.fromString(request.getHeadCommitHash()));
GitUtils.updateRef(refUpdate);
}
@ -454,6 +457,7 @@ public class DefaultPullRequestManager extends AbstractEntityManager<PullRequest
}
}
@Sessional
@Override
public MergePreview previewMerge(PullRequest request) {
if (request.getMergeStrategy() != MergeStrategy.DO_NOT_MERGE) {
@ -484,71 +488,93 @@ public class DefaultPullRequestManager extends AbstractEntityManager<PullRequest
private BatchWorker getMergePreviewer(PullRequest request) {
Long requestId = request.getId();
return new BatchWorker("request-" + requestId + "-previewMerge", 1) {
@Override
public void doWork(Collection<Prioritized> works) {
Preconditions.checkState(works.size() == 1);
unitOfWork.call(new Callable<Void>() {
@Override
public Void call() throws Exception {
PullRequest request = load(requestId);
try {
MergePreview preview = request.getLastMergePreview();
if (request.isOpen() && !request.isMergeIntoTarget() && (preview == null || preview.isObsolete(request))) {
logger.info("Calculating merge preview of pull request #{} in project '{}'...",
request.getNumber(), request.getTargetProject());
String requestHead = request.getHeadCommitHash();
String targetHead = request.getTarget().getObjectName();
Project targetProject = request.getTargetProject();
preview = new MergePreview(targetHead, requestHead, request.getMergeStrategy(), null);
request.setLastMergePreview(preview);
String mergeRef = request.getMergeRef();
ObjectId requestHeadId = ObjectId.fromString(requestHead);
ObjectId targetHeadId = ObjectId.fromString(targetHead);
if ((preview.getMergeStrategy() == MERGE_IF_NECESSARY)
&& GitUtils.isMergedInto(targetProject.getRepository(), targetHeadId, requestHeadId)) {
preview.setMerged(requestHead);
RefUpdate refUpdate = targetProject.updateRef(mergeRef);
refUpdate.setNewObjectId(ObjectId.fromString(requestHead));
GitUtils.updateRef(refUpdate);
} else {
PersonIdent user = new PersonIdent(GitPlex.NAME, "");
ObjectId merged;
if (preview.getMergeStrategy() == REBASE_MERGE) {
merged = GitUtils.rebase(targetProject.getRepository(), requestHeadId, targetHeadId, user);
} else if (preview.getMergeStrategy() == SQUASH_MERGE) {
merged = GitUtils.merge(targetProject.getRepository(),
requestHeadId, targetHeadId, true, user, request.getCommitMessage());
} else {
merged = GitUtils.merge(targetProject.getRepository(),
requestHeadId, targetHeadId, false, user, request.getCommitMessage());
}
if (merged != null) {
preview.setMerged(merged.name());
RefUpdate refUpdate = targetProject.updateRef(mergeRef);
refUpdate.setNewObjectId(merged);
GitUtils.updateRef(refUpdate);
} else {
RefUpdate refUpdate = targetProject.updateRef(mergeRef);
GitUtils.deleteRef(refUpdate);
}
}
dao.persist(request);
listenerRegistry.post(new PullRequestMergePreviewCalculated(request));
logger.info("Merge preview of pull request #{} in project '{}' is calculated.",
request.getNumber(), request.getTargetProject());
}
} catch (Exception e) {
logger.error("Error calculating pull request merge preview", e);
}
return null;
}
public void doWorks(Collection<Prioritized> works) {
try {
Preconditions.checkState(works.size() == 1);
});
AtomicReference<String> projectNameRef = new AtomicReference<>(null);
AtomicReference<Long> requestNumberRef = new AtomicReference<>(null);
AtomicReference<Repository> repositoryRef = new AtomicReference<>(null);
AtomicReference<String> mergeRefRef = new AtomicReference<>(null);
MergePreview mergePreview = unitOfWork.call(new Callable<MergePreview>() {
@Override
public MergePreview call() throws Exception {
PullRequest request = load(requestId);
Project targetProject = request.getTargetProject();
requestNumberRef.set(request.getNumber());
projectNameRef.set(targetProject.getName());
repositoryRef.set(targetProject.getRepository());
mergeRefRef.set(request.getMergeRef());
MergePreview mergePreview = request.getLastMergePreview();
if (request.isOpen()
&& !request.isMergeIntoTarget()
&& (mergePreview == null || mergePreview.isObsolete(request))) {
return new MergePreview(request.getTarget().getObjectName(),
request.getHeadCommitHash(), request.getMergeStrategy(), null);
} else {
return null;
}
}
});
if (mergePreview != null) {
logger.debug("Calculating merge preview of pull request #{} in project '{}'...",
requestNumberRef.get(), projectNameRef.get());
ObjectId targetHeadId = ObjectId.fromString(mergePreview.getTargetHead());
ObjectId requestHeadId = ObjectId.fromString(mergePreview.getRequestHead());
if ((mergePreview.getMergeStrategy() == MERGE_IF_NECESSARY)
&& GitUtils.isMergedInto(repositoryRef.get(), targetHeadId, requestHeadId)) {
mergePreview.setMerged(mergePreview.getRequestHead());
RefUpdate refUpdate = GitUtils.getRefUpdate(repositoryRef.get(), mergeRefRef.get());
refUpdate.setNewObjectId(requestHeadId);
GitUtils.updateRef(refUpdate);
} else {
PersonIdent user = new PersonIdent(GitPlex.NAME, "");
ObjectId merged;
if (mergePreview.getMergeStrategy() == REBASE_MERGE) {
merged = GitUtils.rebase(repositoryRef.get(), requestHeadId, targetHeadId, user);
} else if (mergePreview.getMergeStrategy() == SQUASH_MERGE) {
merged = GitUtils.merge(repositoryRef.get(),
requestHeadId, targetHeadId, true, user, request.getCommitMessage());
} else {
merged = GitUtils.merge(repositoryRef.get(), requestHeadId, targetHeadId, false, user,
request.getCommitMessage());
}
RefUpdate refUpdate = GitUtils.getRefUpdate(repositoryRef.get(), mergeRefRef.get());
if (merged != null) {
mergePreview.setMerged(merged.name());
refUpdate.setNewObjectId(merged);
GitUtils.updateRef(refUpdate);
} else {
GitUtils.deleteRef(refUpdate);
}
}
unitOfWork.call(new Callable<Void>() {
@Override
public Void call() throws Exception {
PullRequest request = load(requestId);
request.setLastMergePreview(mergePreview);
dao.persist(request);
listenerRegistry.post(new PullRequestMergePreviewCalculated(request));
return null;
}
});
}
} catch (Exception e) {
logger.error("Error calculating pull request merge preview", e);
}
}
};

6
core/src/main/java/com/gitplex/server/manager/impl/DefaultPullRequestUpdateManager.java
View File

@ -67,7 +67,8 @@ public class DefaultPullRequestUpdateManager extends AbstractEntityManager<PullR
.setRefSpecs(new RefSpec(GitUtils.branch2ref(request.getSourceBranch()) + ":" + update.getHeadRef()))
.call();
if (!request.getTargetProject().getObjectId(update.getHeadRef()).equals(updateHeadId)) {
RefUpdate refUpdate = request.getTargetProject().updateRef(update.getHeadRef());
RefUpdate refUpdate = GitUtils.getRefUpdate(request.getTargetProject().getRepository(),
update.getHeadRef());
refUpdate.setNewObjectId(updateHeadId);
GitUtils.updateRef(refUpdate);
}
@ -75,7 +76,8 @@ public class DefaultPullRequestUpdateManager extends AbstractEntityManager<PullR
Throwables.propagate(e);
}
} else {
RefUpdate refUpdate = request.getTargetProject().updateRef(update.getHeadRef());
RefUpdate refUpdate = GitUtils.getRefUpdate(request.getTargetProject().getRepository(),
update.getHeadRef());
refUpdate.setNewObjectId(updateHeadId);
GitUtils.updateRef(refUpdate);
}

10
core/src/main/java/com/gitplex/server/model/Project.java
View File

@ -365,7 +365,7 @@ public class Project extends AbstractEntity {
}
public void setDefaultBranch(String defaultBranchName) {
RefUpdate refUpdate = updateRef("HEAD");
RefUpdate refUpdate = GitUtils.getRefUpdate(getRepository(), "HEAD");
GitUtils.linkRef(refUpdate, GitUtils.branch2ref(defaultBranchName));
defaultBranchOptional = null;
}
@ -769,14 +769,6 @@ public class Project extends AbstractEntity {
return StringUtils.matchesQuery(name, queryTerm);
}
public RefUpdate updateRef(String refName) {
try {
return getRepository().updateRef(refName);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public List<BlobIdent> getChildren(BlobIdent blobIdent, BlobIdentFilter blobIdentFilter) {
Repository repository = getRepository();
try (RevWalk revWalk = new RevWalk(repository)) {

6
core/src/main/java/com/gitplex/server/model/PullRequest.java
View File

@ -523,9 +523,9 @@ public class PullRequest extends AbstractEntity {
* Delete refs of this pull request, without touching refs of its updates.
*/
public void deleteRefs() {
GitUtils.deleteRef(getTargetProject().updateRef(getBaseRef()));
GitUtils.deleteRef(getTargetProject().updateRef(getMergeRef()));
GitUtils.deleteRef(getTargetProject().updateRef(getHeadRef()));
GitUtils.deleteRef(GitUtils.getRefUpdate(getTargetProject().getRepository(), getBaseRef()));
GitUtils.deleteRef(GitUtils.getRefUpdate(getTargetProject().getRepository(), getMergeRef()));
GitUtils.deleteRef(GitUtils.getRefUpdate(getTargetProject().getRepository(), getHeadRef()));
}
public static class CriterionHelper {

2
core/src/main/java/com/gitplex/server/model/PullRequestUpdate.java
View File

@ -98,7 +98,7 @@ public class PullRequestUpdate extends AbstractEntity {
}
public void deleteRefs() {
GitUtils.deleteRef(getRequest().getTargetProject().updateRef(getHeadRef()));
GitUtils.deleteRef(GitUtils.getRefUpdate(getRequest().getTargetProject().getRepository(), getHeadRef()));
}
/**

2
core/src/main/java/com/gitplex/server/util/BatchWorker.java
View File

@ -49,5 +49,5 @@ public abstract class BatchWorker {
return new HashCodeBuilder(17, 37).append(id).toHashCode();
}
public abstract void doWork(Collection<Prioritized> works);
public abstract void doWorks(Collection<Prioritized> works);
}

53
search/src/main/java/com/gitplex/server/search/DefaultIndexManager.java
View File

@ -307,25 +307,49 @@ public class DefaultIndexManager implements IndexManager {
private BatchWorker getBatchWorker(Project project) {
Long projectId = project.getId();
return new BatchWorker("project-" + project.getForkRoot().getId() + "-indexBlob", 1) {
@Override
public void doWork(Collection<Prioritized> works) {
public void doWorks(Collection<Prioritized> works) {
Preconditions.checkState(works.size() == 1);
ObjectId commitId = ((IndexWork) works.iterator().next()).getCommitId();
AtomicReference<Repository> projectRepositoryRef = new AtomicReference<>(null);
AtomicReference<Repository> forkRootRepositoryRef = new AtomicReference<>(null);
AtomicReference<File> forkRootIndexDirRef = new AtomicReference<>(null);
AtomicReference<Long> forkRootIdRef = new AtomicReference<>(null);
AtomicReference<String> forkRootNameRef = new AtomicReference<>(null);
unitOfWork.call(new Callable<Void>() {
@Override
public Void call() throws Exception {
Project project = projectManager.load(projectId);
IndexWork indexWork = (IndexWork) works.iterator().next();
Project forkRoot = project.getForkRoot();
if (!forkRoot.equals(project) && !forkRoot.getRepository().hasObject(indexWork.getCommitId())) {
GitUtils.fetch(project.getRepository(), indexWork.getCommitId(), forkRoot.getRepository(),
null);
}
forkRootIdRef.set(forkRoot.getId());
forkRootNameRef.set(forkRoot.getName());
projectRepositoryRef.set(project.getRepository());
forkRootRepositoryRef.set(forkRoot.getRepository());
forkRootIndexDirRef.set(storageManager.getProjectIndexDir(forkRoot.getId()));
doIndex(forkRoot, indexWork.getCommitId());
return null;
}
});
if (!forkRootIdRef.get().equals(projectId) && !forkRootRepositoryRef.get().hasObject(commitId)) {
GitUtils.fetch(projectRepositoryRef.get(), commitId, forkRootRepositoryRef.get(), null);
}
doIndex(forkRootRepositoryRef.get(), forkRootIndexDirRef.get(), commitId, forkRootNameRef.get());
unitOfWork.call(new Callable<Void>() {
@Override
public Void call() throws Exception {
Project project = projectManager.load(projectId);
listenerRegistry.post(new CommitIndexed(project, commitId.copy()));
return null;
}
@ -335,9 +359,8 @@ public class DefaultIndexManager implements IndexManager {
};
}
private IndexResult doIndex(Project project, ObjectId commit) {
private IndexResult doIndex(Repository repository, File indexDir, ObjectId commit, String projectName) {
IndexResult indexResult;
File indexDir = storageManager.getProjectIndexDir(project.getId());
try (Directory directory = FSDirectory.open(indexDir)) {
if (DirectoryReader.indexExists(directory)) {
try (IndexReader reader = DirectoryReader.open(directory)) {
@ -346,9 +369,9 @@ public class DefaultIndexManager implements IndexManager {
return new IndexResult(0, 0);
} else {
try (IndexWriter writer = new IndexWriter(directory, newIndexWriterConfig())) {
logger.debug("Indexing commit (project: {}, commit: {})", project.getName(), commit.getName());
try {
indexResult = index(project.getRepository(), commit, writer, searcher);
logger.debug("Indexing commit (project: {}, commit: {})", projectName, commit.getName());
indexResult = index(repository, commit, writer, searcher);
writer.commit();
} catch (Exception e) {
writer.rollback();
@ -360,8 +383,8 @@ public class DefaultIndexManager implements IndexManager {
} else {
try (IndexWriter writer = new IndexWriter(directory, newIndexWriterConfig())) {
try {
logger.debug("Indexing commit (project: {}, commit: {})", project.getName(), commit.getName());
indexResult = index(project.getRepository(), commit, writer, null);
logger.debug("Indexing commit (project: {}, commit: {})", projectName, commit.getName());
indexResult = index(repository, commit, writer, null);
writer.commit();
} catch (Exception e) {
writer.rollback();
@ -373,8 +396,6 @@ public class DefaultIndexManager implements IndexManager {
throw new RuntimeException(e);
}
listenerRegistry.post(new CommitIndexed(project, commit.copy()));
return indexResult;
}

22
web/src/main/java/com/gitplex/server/web/component/diff/blob/text/TextDiffPanel.java
View File

@ -31,7 +31,7 @@ import org.apache.wicket.request.cycle.RequestCycle;
import org.apache.wicket.request.mapper.parameter.PageParameters;
import org.eclipse.jgit.diff.DiffEntry.ChangeType;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.lib.ObjectId;
import org.unbescape.html.HtmlEscape;
import org.unbescape.javascript.JavaScriptEscape;
@ -43,9 +43,9 @@ import com.gitplex.jsyntax.TokenUtils;
import com.gitplex.jsyntax.Tokenized;
import com.gitplex.server.GitPlex;
import com.gitplex.server.git.Blame;
import com.gitplex.server.git.BlameCommit;
import com.gitplex.server.git.BlobChange;
import com.gitplex.server.git.BlobIdent;
import com.gitplex.server.git.BlameCommit;
import com.gitplex.server.git.GitUtils;
import com.gitplex.server.git.command.BlameCommand;
import com.gitplex.server.manager.CodeCommentManager;
@ -452,12 +452,22 @@ public class TextDiffPanel extends Panel implements SourceAware {
appendEqual(builder, block, i, 0);
}
private RevCommit getOldCommit() {
return projectModel.getObject().getRevCommit(change.getOldBlobIdent().revision);
private ObjectId getOldCommit() {
String oldRev = change.getOldBlobIdent().revision;
if (oldRev.equals(ObjectId.zeroId().toString())) {
return ObjectId.zeroId();
} else {
return projectModel.getObject().getRevCommit(oldRev);
}
}
private RevCommit getNewCommit() {
return projectModel.getObject().getRevCommit(change.getNewBlobIdent().revision);
private ObjectId getNewCommit() {
String newRev = change.getNewBlobIdent().revision;
if (newRev.equals(ObjectId.zeroId().toString())) {
return ObjectId.zeroId();
} else {
return projectModel.getObject().getRevCommit(newRev);
}
}
@Override

38
web/src/main/java/com/gitplex/server/web/component/diff/revision/RevisionDiffPanel.java
View File

@ -53,7 +53,7 @@ import org.eclipse.jgit.diff.DiffEntry;
import org.eclipse.jgit.diff.DiffEntry.ChangeType;
import org.eclipse.jgit.lib.AnyObjectId;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.lib.ObjectId;
import com.gitplex.codeassist.InputCompletion;
import com.gitplex.codeassist.InputStatus;
@ -360,7 +360,7 @@ public class RevisionDiffPanel extends Panel {
protected Collection<CodeComment> load() {
if (markSupport != null && requestModel.getObject() != null) {
return GitPlex.getInstance(CodeCommentManager.class).findAll(requestModel.getObject(),
getOldCommit(), getNewCommit());
getOldCommitId(), getNewCommitId());
} else {
return new ArrayList<>();
}
@ -463,10 +463,12 @@ public class RevisionDiffPanel extends Panel {
Project project = projectModel.getObject();
IndexManager indexManager = GitPlex.getInstance(IndexManager.class);
RevCommit oldCommit = getOldCommit();
RevCommit newCommit = getNewCommit();
boolean oldCommitIndexed = indexManager.isIndexed(project, oldCommit);
boolean newCommitIndexed = indexManager.isIndexed(project, newCommit);
ObjectId oldCommit = getOldCommitId();
ObjectId newCommit = getNewCommitId();
boolean oldCommitIndexed = oldCommit.equals(ObjectId.zeroId())
|| indexManager.isIndexed(project, oldCommit);
boolean newCommitIndexed = newCommit.equals(ObjectId.zeroId())
|| indexManager.isIndexed(project, newCommit);
if (oldCommitIndexed && newCommitIndexed) {
setVisible(false);
} else {
@ -1197,12 +1199,20 @@ public class RevisionDiffPanel extends Panel {
return commentContainer;
}
private RevCommit getOldCommit() {
return projectModel.getObject().getRevCommit(oldRev);
private ObjectId getOldCommitId() {
if (oldRev.equals(ObjectId.zeroId().toString())) {
return ObjectId.zeroId();
} else {
return projectModel.getObject().getRevCommit(oldRev);
}
}
private RevCommit getNewCommit() {
return projectModel.getObject().getRevCommit(newRev);
private ObjectId getNewCommitId() {
if (newRev.equals(ObjectId.zeroId().toString())) {
return ObjectId.zeroId();
} else {
return projectModel.getObject().getRevCommit(newRev);
}
}
@Nullable
@ -1211,8 +1221,8 @@ public class RevisionDiffPanel extends Panel {
CodeComment comment = ((CommentSupport)markSupport).getOpenComment();
if (comment != null) {
String commit = comment.getCommentPos().getCommit();
String oldCommitHash = getOldCommit().name();
String newCommitHash = getNewCommit().name();
String oldCommitHash = getOldCommitId().name();
String newCommitHash = getNewCommitId().name();
if (commit.equals(oldCommitHash) || commit.equals(newCommitHash))
return comment;
}
@ -1226,8 +1236,8 @@ public class RevisionDiffPanel extends Panel {
MarkPos mark = markSupport.getMark();
if (mark != null) {
String commit = mark.getCommit();
String oldCommitHash = getOldCommit().name();
String newCommitHash = getNewCommit().name();
String oldCommitHash = getOldCommitId().name();
String newCommitHash = getNewCommitId().name();
if (commit.equals(oldCommitHash) || commit.equals(newCommitHash))
return mark;
}

33
web/src/main/java/com/gitplex/server/web/page/project/commit/CommitDetailPage.html
View File

@ -18,23 +18,7 @@
<span wicket:id="contributorAvatars"></span>
<span wicket:id="contribution"></span>
</div>
<div wicket:id="parents" class="parents pull-right">
<wicket:enclosure child="parent">
<div class="single">
<label>1 parent</label>
<a wicket:id="parent" class="parent hash"><span wicket:id="label"></span></a>
</div>
</wicket:enclosure>
<wicket:enclosure child="parents">
<div class="multiple">
<label wicket:id="count"></label>
<div wicket:id="parents" class="parent btn-group">
<a wicket:id="link" title="Show commit of this parent" class="commit btn btn-default btn-sm"><span wicket:id="label"></span></a>
<a wicket:id="diff" title="Compare with this parent" class="diff btn btn-default btn-sm"><i class="fa fa-ext fa-file-diff"></i></a>
</div>
</div>
</wicket:enclosure>
</div>
<div wicket:id="parents" class="parents pull-right"></div>
<div class="commit pull-right">
<span wicket:id="verificationStatus" class="verification-status"></span>
<span wicket:id="hash" class="hash"></span>
@ -49,4 +33,19 @@
<a wicket:id="link"><span wicket:id="label"></span></a>
</span>
</wicket:fragment>
<wicket:fragment wicket:id="multiParentsFrag">
<div class="multiple">
<label wicket:id="count"></label>
<div wicket:id="parents" class="parent btn-group">
<a wicket:id="link" title="Show commit of this parent" class="commit btn btn-default btn-sm"><span wicket:id="label"></span></a>
<a wicket:id="diff" title="Compare with this parent" class="diff btn btn-default btn-sm"><i class="fa fa-ext fa-file-diff"></i></a>
</div>
</div>
</wicket:fragment>
<wicket:fragment wicket:id="singleParentFrag">
<div class="single">
<label>1 parent</label>
<a wicket:id="parent" class="parent hash"><span wicket:id="label"></span></a>
</div>
</wicket:fragment>
</wicket:extend>

40
web/src/main/java/com/gitplex/server/web/page/project/commit/CommitDetailPage.java
View File

@ -91,7 +91,7 @@ public class CommitDetailPage extends ProjectPage implements CommentSupport {
private ObjectId resolvedCompareWith;
private RevisionDiffPanel revisionDiff;
private WebMarkupContainer revisionDiff;
public CommitDetailPage(PageParameters params) {
super(params);
@ -226,17 +226,15 @@ public class CommitDetailPage extends ProjectPage implements CommentSupport {
newParentsContainer(null);
if (getCommit().getParentCount() != 0) {
newRevisionDiff(null);
} else {
add(new WebMarkupContainer("revisionDiff").setVisible(false));
}
newRevisionDiff(null);
}
private void newParentsContainer(@Nullable AjaxRequestTarget target) {
WebMarkupContainer parentsContainer = new WebMarkupContainer("parents");
parentsContainer.setOutputMarkupId(true);
if (getParents().size() == 1) {
WebMarkupContainer parents;
if (getParents().size() == 0) {
parents = new WebMarkupContainer("parents");
} else if (getParents().size() == 1) {
parents = new Fragment("parents", "singleParentFrag", this);
RevCommit parent = getParents().get(0);
State newState = new State();
newState.revision = parent.name();
@ -245,12 +243,13 @@ public class CommitDetailPage extends ProjectPage implements CommentSupport {
Link<Void> link = new ViewStateAwarePageLink<Void>("parent", CommitDetailPage.class,
paramsOf(projectModel.getObject(), newState));
link.add(new Label("label", GitUtils.abbreviateSHA(parent.name())));
parentsContainer.add(link);
parentsContainer.add(new WebMarkupContainer("parents").setVisible(false));
parents.add(link);
parents.add(new WebMarkupContainer("parents").setVisible(false));
} else {
parentsContainer.add(new WebMarkupContainer("parent").setVisible(false));
parentsContainer.add(new Label("count", getParents().size() + " parents"));
parentsContainer.add(new ListView<RevCommit>("parents", new LoadableDetachableModel<List<RevCommit>>() {
parents = new Fragment("parents", "multiParentsFrag", this);
parents.add(new WebMarkupContainer("parent").setVisible(false));
parents.add(new Label("count", getParents().size() + " parents"));
parents.add(new ListView<RevCommit>("parents", new LoadableDetachableModel<List<RevCommit>>() {
@Override
protected List<RevCommit> load() {
@ -280,7 +279,7 @@ public class CommitDetailPage extends ProjectPage implements CommentSupport {
state.compareWith = item.getModelObject().name();
resolvedCompareWith = item.getModelObject().copy();
target.add(parentsContainer);
target.add(parents);
newRevisionDiff(target);
pushState(target);
}
@ -297,17 +296,20 @@ public class CommitDetailPage extends ProjectPage implements CommentSupport {
});
}
parents.setOutputMarkupId(true);
if (target != null) {
replace(parentsContainer);
target.add(parentsContainer);
replace(parents);
target.add(parents);
} else {
add(parentsContainer);
add(parents);
}
}
private ObjectId getCompareWith() {
List<RevCommit> parents = getParents();
if (resolvedCompareWith != null) {
if (parents.size() == 0) {
return ObjectId.zeroId();
} else if (resolvedCompareWith != null) {
if (parents.contains(resolvedCompareWith))
return resolvedCompareWith;
else