Java tutorial
/* license-start * * Copyright (C) 2008 - 2013 Crispico, <http://www.crispico.com/>. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation version 3. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details, at <http://www.gnu.org/licenses/>. * * Contributors: * Crispico - Initial API and implementation * * license-end */ package org.flowerplatform.web.git.history.remote; import java.io.File; import java.io.IOException; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Map.Entry; import org.apache.commons.lang3.StringEscapeUtils; import org.eclipse.core.resources.IResource; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.Path; import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.PersonIdent; import org.eclipse.jgit.lib.Ref; import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.RepositoryCache; import org.eclipse.jgit.lib.RepositoryCache.FileKey; import org.eclipse.jgit.lib.RepositoryState; import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.revwalk.RevSort; import org.eclipse.jgit.revwalk.RevWalk; import org.eclipse.jgit.revwalk.RevWalkUtils; import org.eclipse.jgit.treewalk.TreeWalk; import org.eclipse.jgit.treewalk.filter.AndTreeFilter; import org.eclipse.jgit.treewalk.filter.PathFilterGroup; import org.eclipse.jgit.treewalk.filter.TreeFilter; import org.eclipse.jgit.util.FS; import org.flowerplatform.common.CommonPlugin; import org.flowerplatform.communication.CommunicationPlugin; import org.flowerplatform.communication.channel.CommunicationChannel; import org.flowerplatform.communication.channel.ICommunicationChannelLifecycleListener; import org.flowerplatform.communication.command.DisplaySimpleMessageClientCommand; import org.flowerplatform.communication.stateful_service.IStatefulClientLocalState; import org.flowerplatform.communication.stateful_service.IStatefulServiceMXBean; import org.flowerplatform.communication.stateful_service.RegularStatefulService; import org.flowerplatform.communication.stateful_service.RemoteInvocation; import org.flowerplatform.communication.stateful_service.StatefulServiceInvocationContext; import org.flowerplatform.communication.tree.NodeInfo; import org.flowerplatform.communication.tree.remote.GenericTreeStatefulService; import org.flowerplatform.communication.tree.remote.PathFragment; import org.flowerplatform.web.git.GitNodeType; import org.flowerplatform.web.git.GitPlugin; import org.flowerplatform.web.git.GitService; import org.flowerplatform.web.git.GitUtils; import org.flowerplatform.web.git.explorer.entity.RefNode; import org.flowerplatform.web.git.history.internal.FileDiff; import org.flowerplatform.web.git.history.internal.WebCommit; import org.flowerplatform.web.git.history.internal.WebCommitList; import org.flowerplatform.web.git.history.internal.WebCommitPlotRenderer; import org.flowerplatform.web.git.history.internal.WebWalk; import org.flowerplatform.web.git.history.remote.dto.HistoryEntryDto; import org.flowerplatform.web.git.history.remote.dto.HistoryFileDiffEntryDto; import org.flowerplatform.web.git.history.remote.dto.HistoryViewInfoDto; import org.flowerplatform.web.git.remote.dto.CommitDto; /** * @author Cristina Constantinescu */ @SuppressWarnings({ "restriction", "rawtypes", "unchecked" }) public class GitHistoryStatefulService extends RegularStatefulService<CommunicationChannel, HistoryViewInfoDto> implements IStatefulServiceMXBean, ICommunicationChannelLifecycleListener { public static final String SERVICE_ID = "GitHistoryStatefulService"; private static final String STATEFUL_CLIENT_ID = "Git History"; public GitHistoryStatefulService() { super(); clients = new HashMap<CommunicationChannel, HistoryViewInfoDto>(); } /////////////////////////////////////////////////////////////// // JMX Methods /////////////////////////////////////////////////////////////// public Collection<String> getStatefulClientIdsForCommunicationChannel( CommunicationChannel communicationChannel) { return Collections.singleton(STATEFUL_CLIENT_ID); } /////////////////////////////////////////////////////////////// // Normal methods /////////////////////////////////////////////////////////////// @Override protected String getStatefulServiceId() { return SERVICE_ID; } public static GitHistoryStatefulService getInstance() { return (GitHistoryStatefulService) CommunicationPlugin.getInstance().getServiceRegistry() .getService(SERVICE_ID); } @Override protected HistoryViewInfoDto getDataFromStatefulClientLocalState(StatefulServiceInvocationContext context, IStatefulClientLocalState statefulClientLocalState) { // channel destroyed if (statefulClientLocalState == null) { return null; } return ((GitHistoryStatefulClientLocalState) statefulClientLocalState).getInfo(); } @Override public void communicationChannelCreated(CommunicationChannel webCommunicationChannel) { // do nothing } @Override public void communicationChannelDestroyed(CommunicationChannel webCommunicationChannel) { unsubscribe(new StatefulServiceInvocationContext(webCommunicationChannel, null, null), null); } private WebWalk getWebWalk(CommunicationChannel channel, HistoryViewInfoDto info) throws IOException { configObjectInfo(channel, info); // if (!info.getIsResource()) { String path = null; if (info.getFile() != null) { IPath workdirPath = new Path(info.getRepository().getWorkTree().getPath()); int segmentCount = workdirPath.segmentCount(); IPath filePath = null; if (info.getFilter() == HistoryViewInfoDto.SHOWALLFOLDER) { filePath = new Path(info.getFile().getParentFile().getPath()); } else /* if (showAllFilter == ShowFilter.SHOWALLRESOURCE) */ { filePath = new Path(info.getFile().getPath()); } if (filePath != null) { path = filePath.removeFirstSegments(segmentCount).setDevice(null).toString(); } } WebWalk walk = new WebWalk(info.getRepository()); setupWalk(walk, info.getRepository(), path); info.setPath(path); return walk; // } else { // RepositoryMapping mapping = RepositoryMapping.getMapping(info.getResource()); // // String path = null; // if (info.getFilter() == HistoryViewInfoDto.SHOWALLFOLDER) { // // if the resource's parent is the workspace root, we will // // get nonsense from map.getRepoRelativePath(), so we // // check here and use the project instead // if (info.getResource().getParent() instanceof IWorkspaceRoot) { // path = mapping.getRepoRelativePath(info.getResource().getProject()); // } else { // path = mapping.getRepoRelativePath(info.getResource().getParent()); // } // } else if (info.getFilter() == HistoryViewInfoDto.SHOWALLPROJECT) { // path = mapping.getRepoRelativePath(info.getResource().getProject()); // } else if (info.getFilter() == HistoryViewInfoDto.SHOWALLREPO) { // // nothing // } else /* if (showAllFilter == ShowFilter.SHOWALLRESOURCE) */{ // path = mapping.getRepoRelativePath(info.getResource()); // } // // WebWalk walk = new WebWalk(info.getRepository()); // setupWalk(walk, info.getRepository(), path); // // info.setPath(path); // // return walk; // } } private void setupWalk(WebWalk walk, Repository repo, String path) throws IOException { walk.addAdditionalRefs(repo.getRefDatabase().getAdditionalRefs()); walk.addAdditionalRefs(repo.getRefDatabase().getRefs(Constants.R_NOTES).values()); walk.sort(RevSort.COMMIT_TIME_DESC, true); walk.sort(RevSort.BOUNDARY, true); walk.setRetainBody(false); setWalkStartPoints(walk, repo, walk.parseCommit(repo.resolve(Constants.HEAD))); createFileWalker(walk, repo, path); } private TreeWalk createFileWalker(RevWalk walk, Repository db, String path) { TreeWalk fileWalker = new TreeWalk(db); fileWalker.setRecursive(true); fileWalker.setFilter(TreeFilter.ANY_DIFF); if (path == null || path.isEmpty()) { walk.setTreeFilter(TreeFilter.ALL); } else { List<String> stringPaths = new ArrayList<String>(1); stringPaths.add(path); walk.setTreeFilter( AndTreeFilter.create(PathFilterGroup.createFromStrings(stringPaths), TreeFilter.ANY_DIFF)); } return fileWalker; } private String getCommitMessage(Repository repo, HistoryEntryDto entry, RevCommit commit) throws IOException { DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); int maxBranches = 20; StringBuilder d = new StringBuilder(); d.append("<p>"); d.append(GitPlugin.getInstance().getMessage("git.history.commitMessage.commit")); d.append(" "); d.append(commit.getId().name()); d.append("<br>"); PersonIdent author = commit.getAuthorIdent(); if (author != null) { d.append(GitPlugin.getInstance().getMessage("git.history.commitMessage.author")); d.append(": "); d.append(author.getName()); d.append(" <"); d.append(author.getEmailAddress()); d.append("> "); d.append(fmt.format(author.getWhen())); d.append("<br>"); } PersonIdent committer = commit.getCommitterIdent(); if (committer != null) { d.append(GitPlugin.getInstance().getMessage("git.history.commitMessage.committer")); d.append(": "); d.append(committer.getName()); d.append(" <"); d.append(committer.getEmailAddress()); d.append("> "); d.append(fmt.format(committer.getWhen())); d.append("<br>"); } for (CommitDto parent : entry.getCommitMessage().getParents()) { d.append(GitPlugin.getInstance().getMessage("git.history.commitMessage.parent")); d.append(": "); d.append(String.format("<u><a href=''>%s</a></u>", parent.getId())); d.append(" ("); d.append(parent.getLabel()); d.append(")"); d.append("<br>"); } for (CommitDto child : entry.getCommitMessage().getChildren()) { d.append(GitPlugin.getInstance().getMessage("git.history.commitMessage.child")); d.append(": "); d.append(String.format("<u><a href=''>%s</a></u>", child.getId())); d.append(" ("); d.append(child.getLabel()); d.append(")"); d.append("<br>"); } List<Ref> branches = getBranches(commit, getBranches(repo), repo); if (!branches.isEmpty()) { d.append(GitPlugin.getInstance().getMessage("git.history.commitMessage.branches")); d.append(": "); int count = 0; for (Iterator<Ref> i = branches.iterator(); i.hasNext();) { Ref head = i.next(); d.append(formatHeadRef(head)); if (i.hasNext()) { if (count++ <= maxBranches) { d.append(", "); } else { d.append(GitPlugin.getInstance().getMessage("git.history.commitMessage.author", new Object[] { Integer.valueOf(branches.size() - maxBranches) })); break; } } } d.append("<br>"); } String tagsString = getTagsString(repo, commit); if (tagsString.length() > 0) { d.append(GitPlugin.getInstance().getMessage("git.history.commitMessage.tags")); d.append(": "); d.append(tagsString); d.append("<br>"); } d.append("<br>"); d.append(String.format("<b>%s</b>", StringEscapeUtils.escapeHtml3(commit.getFullMessage()).replaceAll("\n", "<br>"))); d.append("</p>"); return d.toString(); } // private List<RefNode> getRefNodes(RevCommit commit, Repository repo, String refPrefix) { // List<Ref> availableBranches = new ArrayList<Ref>(); // List<RefNode> nodes = new ArrayList<RefNode>(); // try { // Map<String, Ref> branches = repo.getRefDatabase().getRefs(refPrefix); // for (Ref branch : branches.values()) { // if (branch.getLeaf().getObjectId().equals(commit.getId())) // availableBranches.add(branch); // } // RepositoryNode repoNode = new RepositoryNode(null, repo); // for (Ref ref : availableBranches) // nodes.add(new RefNode(repoNode, repo, ref)); // // } catch (IOException e) { // // ignore here // } // return nodes; // } private List<Ref> getBranches(RevCommit commit, Collection<Ref> allRefs, Repository db) throws MissingObjectException, IncorrectObjectTypeException, IOException { RevWalk revWalk = new RevWalk(db); try { revWalk.setRetainBody(false); return RevWalkUtils.findBranchesReachableFrom(commit, revWalk, allRefs); } finally { revWalk.dispose(); } } private List<Ref> getBranches(Repository repo) throws IOException { List<Ref> ref = new ArrayList<Ref>(); ref.addAll(repo.getRefDatabase().getRefs(Constants.R_HEADS).values()); ref.addAll(repo.getRefDatabase().getRefs(Constants.R_REMOTES).values()); return ref; } private String formatHeadRef(Ref ref) { String name = ref.getName(); if (name.startsWith(Constants.R_HEADS)) { return name.substring(Constants.R_HEADS.length()); } else if (name.startsWith(Constants.R_REMOTES)) { return name.substring(Constants.R_REMOTES.length()); } return name; } private String getTagsString(Repository repo, RevCommit commit) { StringBuilder sb = new StringBuilder(); Map<String, Ref> tagsMap = repo.getTags(); for (Entry<String, Ref> tagEntry : tagsMap.entrySet()) { ObjectId target = tagEntry.getValue().getPeeledObjectId(); if (target == null) { target = tagEntry.getValue().getObjectId(); } if (target != null && target.equals(commit)) { if (sb.length() > 0) { sb.append(", "); } sb.append(tagEntry.getKey()); } } return sb.toString(); } private String getInfo(HistoryViewInfoDto objectInfo) { String repositoryName = GitPlugin.getInstance().getUtils().getRepositoryName(objectInfo.getRepository()); if (objectInfo.getResource() == null && objectInfo.getFile() == null) { return GitPlugin.getInstance().getMessage("git.history.repo.pattern", new Object[] { repositoryName }); } else if (objectInfo.getResource() != null) { String type; switch (objectInfo.getResource().getType()) { case IResource.PROJECT: type = GitPlugin.getInstance().getMessage("git.history.projectType"); break; case IResource.FILE: type = GitPlugin.getInstance().getMessage("git.history.fileType"); break; default: type = GitPlugin.getInstance().getMessage("git.history.folderType"); break; } String path = objectInfo.getResource().getFullPath().makeRelative().toString(); if (objectInfo.getResource().getType() == IResource.FOLDER) { path = path + '/'; } return GitPlugin.getInstance().getMessage("git.history.file.pattern", new Object[] { type, path, repositoryName }); } else { // single file from Repository String path; String type; if (objectInfo.getFile().isDirectory()) { type = GitPlugin.getInstance().getMessage("git.history.folderType"); path = objectInfo.getFile().getPath(); } else { type = GitPlugin.getInstance().getMessage("git.history.fileType"); path = objectInfo.getFile().getPath(); } String repoPath = objectInfo.getRepository().getDirectory().getPath(); path = path.substring(path.indexOf(repoPath) + repoPath.length()); return GitPlugin.getInstance().getMessage("git.history.file.pattern", new Object[] { type, path, repositoryName }); } } private void setWalkStartPoints(RevWalk walk, Repository repo, AnyObjectId headId) throws IOException { markStartAllRefs(repo, walk, Constants.R_HEADS); markStartAllRefs(repo, walk, Constants.R_REMOTES); markStartAllRefs(repo, walk, Constants.R_TAGS); markStartAdditionalRefs(repo, walk); markUninteresting(repo, walk, Constants.R_NOTES); walk.markStart(walk.parseCommit(headId)); } private void markStartAllRefs(Repository repo, RevWalk walk, String prefix) throws IOException, MissingObjectException, IncorrectObjectTypeException { for (Entry<String, Ref> refEntry : repo.getRefDatabase().getRefs(prefix).entrySet()) { Ref ref = refEntry.getValue(); if (ref.isSymbolic()) continue; markStartRef(repo, walk, ref); } } private void markStartAdditionalRefs(Repository repo, RevWalk walk) throws IOException { List<Ref> additionalRefs = repo.getRefDatabase().getAdditionalRefs(); for (Ref ref : additionalRefs) markStartRef(repo, walk, ref); } private void markStartRef(Repository repo, RevWalk walk, Ref ref) throws IOException, IncorrectObjectTypeException { try { Object refTarget = walk.parseAny(ref.getLeaf().getObjectId()); if (refTarget instanceof RevCommit) walk.markStart((RevCommit) refTarget); } catch (MissingObjectException e) { // If there is a ref which points to Nirvana then we should simply // ignore this ref. We should not let a corrupt ref cause that the // history view is not filled at all } } private void markUninteresting(Repository repo, RevWalk walk, String prefix) throws IOException, MissingObjectException, IncorrectObjectTypeException { for (Entry<String, Ref> refEntry : repo.getRefDatabase().getRefs(prefix).entrySet()) { Ref ref = refEntry.getValue(); if (ref.isSymbolic()) continue; Object refTarget = walk.parseAny(ref.getLeaf().getObjectId()); if (refTarget instanceof RevCommit) walk.markUninteresting((RevCommit) refTarget); } } private void configObjectInfo(CommunicationChannel channel, HistoryViewInfoDto info) throws IOException { if (info.getIsResource()) { // IResource resource = ResourcesPlugin.getWorkspace().getRoot().findMember((String) info.getSelectedObject()); // RepositoryMapping mapping = RepositoryMapping.getMapping(resource); // // if (mapping == null) { // throw new IOException(); // } // info.setResource1(resource); // info.setRepository1(GitPlugin.getInstance().getGitUtils().getRepository(mapping)); } else { Object node = GenericTreeStatefulService.getNodeByPathFor((List<PathFragment>) info.getSelectedObject(), null); GenericTreeStatefulService service = GenericTreeStatefulService .getServiceFromPathWithRoot((List<PathFragment>) info.getSelectedObject()); NodeInfo nodeInfo = service.getVisibleNodes().get(node); Repository repository = GitService.getInstance().getRepository(nodeInfo); if (GitNodeType.NODE_TYPE_FILE.equals(nodeInfo.getPathFragment().getType()) || GitNodeType.NODE_TYPE_WDIR.equals(nodeInfo.getPathFragment().getType())) { repository = GitPlugin.getInstance().getUtils().getRepository((File) node); } else if (node instanceof RefNode) { // create working directory for local branch File mainRepoFile = repository.getDirectory().getParentFile(); String branchName = ((RefNode) node).getRef().getName().substring(Constants.R_HEADS.length()); File wdirFile = new File(mainRepoFile.getParentFile(), GitUtils.WORKING_DIRECTORY_PREFIX + branchName); repository = GitPlugin.getInstance().getUtils().getRepository(wdirFile); } else { throw new IOException(); } if (repository == null) { throw new IOException(); } info.setFile1(null); info.setRepository1(repository); } } private String mergeStatus(Repository repository) { String message = null; try { Ref head = repository.getRef(Constants.HEAD); if (head == null || !head.isSymbolic()) { message = GitPlugin.getInstance().getMessage("git.merge.headIsNoBranch"); } else if (!repository.getRepositoryState().equals(RepositoryState.SAFE)) message = GitPlugin.getInstance().getMessage("git.merge.wrongRepositoryState", repository.getRepositoryState()); } catch (IOException e) { message = e.getMessage(); } return message; } /////////////////////////////////////////////////////////////// // @RemoteInvocation methods /////////////////////////////////////////////////////////////// @RemoteInvocation public void subscribe(StatefulServiceInvocationContext context, IStatefulClientLocalState statefulClientLocalState) { super.subscribe(context, statefulClientLocalState); //invokeClientMethod(context.getCommunicationChannel(), context.getStatefulClientId(), "refresh", new Object[] {((GitHistoryStatefulClientLocalState) statefulClientLocalState).getInfo()}); } @RemoteInvocation public HistoryViewInfoDto getObjectInfo(StatefulServiceInvocationContext context, HistoryViewInfoDto info) { try { configObjectInfo(context.getCommunicationChannel(), info); info.setRepositoryLocation(info.getRepository().getDirectory().getAbsolutePath()); info.setInfo(getInfo(info)); return info; } catch (IOException e) { return null; } } @RemoteInvocation public List<Object> getLogEntries(StatefulServiceInvocationContext context, HistoryViewInfoDto info) { try { WebWalk walk = getWebWalk(context.getCommunicationChannel(), info); WebCommitList loadedCommits = new WebCommitList(); loadedCommits.source(walk); loadedCommits.fillTo(10000); WebCommit[] commitsAsArray = new WebCommit[loadedCommits.size()]; loadedCommits.toArray(commitsAsArray); List<HistoryEntryDto> result = new ArrayList<HistoryEntryDto>(); for (WebCommit commit : commitsAsArray) { commit.parseBody(); HistoryEntryDto entry = new HistoryEntryDto(); entry.setId(commit.getId().name()); entry.setShortId(commit.getId().abbreviate(7).name()); entry.setMessage(commit.getShortMessage()); PersonIdent person = commit.getAuthorIdent(); entry.setAuthor(person.getName()); entry.setAuthorEmail(person.getEmailAddress()); entry.setAuthoredDate(person.getWhen()); person = commit.getCommitterIdent(); entry.setCommitter(person.getName()); entry.setCommitterEmail(person.getEmailAddress()); entry.setCommitteredDate(person.getWhen()); WebCommitPlotRenderer renderer = new WebCommitPlotRenderer(commit); renderer.paint(); entry.setSpecialMessage(renderer.getSpecialMessage()); entry.setDrawings(renderer.getDrawings()); for (int i = 0; i < commit.getParentCount(); i++) { WebCommit p = (WebCommit) commit.getParent(i); p.parseBody(); CommitDto parent = new CommitDto(); parent.setId(p.getId().name()); parent.setLabel(p.getShortMessage()); entry.getCommitMessage().getParents().add(parent); } for (int i = 0; i < commit.getChildCount(); i++) { WebCommit p = (WebCommit) commit.getChild(i); p.parseBody(); CommitDto child = new CommitDto(); child.setId(p.getId().name()); child.setLabel(p.getShortMessage()); entry.getCommitMessage().getChildren().add(child); } result.add(entry); } walk.dispose(); return Arrays.asList(new Object[] { result, info }); } catch (IOException e) { return null; } } @RemoteInvocation public List<HistoryFileDiffEntryDto> getCommitFileDiffs(StatefulServiceInvocationContext context, HistoryEntryDto entry, HistoryViewInfoDto info) { List<HistoryFileDiffEntryDto> entries = new ArrayList<HistoryFileDiffEntryDto>(); try { Repository repo = RepositoryCache .open(FileKey.exact(new File(info.getRepositoryLocation()), FS.DETECTED)); RevWalk walk = new RevWalk(repo); RevCommit commit = walk.parseCommit(repo.resolve(entry.getId())); for (RevCommit parent : commit.getParents()) { walk.parseBody(parent); } FileDiff[] fileDiffs = FileDiff.compute(createFileWalker(new WebWalk(repo), repo, info.getPath()), commit, TreeFilter.ALL); for (FileDiff fd : fileDiffs) { HistoryFileDiffEntryDto fileEntry = new HistoryFileDiffEntryDto(); fileEntry.setFile(fd.getLabel(fd)); //fileEntry.setImage(GitPlugin.getInstance().getGitUtils().getImageURL(fd.getImageDescriptor(fd))); entries.add(fileEntry); } walk.dispose(); } catch (Exception e) { context.getCommunicationChannel().sendCommandWithPush( new DisplaySimpleMessageClientCommand(CommonPlugin.getInstance().getMessage("error"), e.getMessage(), DisplaySimpleMessageClientCommand.ICON_ERROR)); return null; } return entries; } @RemoteInvocation public String getCommitMessage(StatefulServiceInvocationContext context, HistoryEntryDto entry, String repositoryLocation) { try { Repository repo = RepositoryCache.open(FileKey.exact(new File(repositoryLocation), FS.DETECTED)); ; RevCommit commit = new RevWalk(repo).parseCommit(repo.resolve(entry.getId())); return getCommitMessage(repo, entry, commit); } catch (Exception e) { context.getCommunicationChannel().sendCommandWithPush( new DisplaySimpleMessageClientCommand(CommonPlugin.getInstance().getMessage("error"), e.getMessage(), DisplaySimpleMessageClientCommand.ICON_ERROR)); return null; } } // @RemoteInvocation // public boolean checkout(StatefulServiceInvocationContext context, HistoryEntryDto entry, String repositoryLocation) { // try { // Repository repo = RepositoryCache.open(FileKey.exact(new File(repositoryLocation), FS.DETECTED));; // RevCommit commit = new RevWalk(repo).parseCommit(repo.resolve(entry.getId())); // // List<RefNode> nodes = getRefNodes(commit, repo, Constants.R_HEADS); // // String target; // if (nodes.isEmpty()) // target = commit.name(); // else { // target = nodes.get(0).getObject().getName(); // } // // return new CheckoutOperation(repo, target, context.getCommunicationChannel()).execute(); // // } catch (Exception e) { // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // e.getMessage(), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } // } // // @RemoteInvocation // public boolean cherryPick(StatefulServiceInvocationContext context, HistoryEntryDto entry, String repositoryLocation) { // WebProgressMonitor monitor = ProgressMonitorStatefulService.getInstance(). // createProgressMonitor(GitPlugin.getInstance().getMessage("git.cherryPick.monitor.title", new Object[] {entry.getShortId()})); // // try { // Repository repo = RepositoryCache.open(FileKey.exact(new File(repositoryLocation), FS.DETECTED));; // RevCommit commit = new RevWalk(repo).parseCommit(repo.resolve(entry.getId())); // // CherryPickCommand command = new Git(repo).cherryPick().include(commit.getId()); // CherryPickResult result = (CherryPickResult) GitPlugin.getInstance().getGitUtils().runGitCommandInUserRepoConfig(repo, command); // // ProjectUtil.refreshValidProjects( // ProjectUtil.getValidOpenProjects(repo), // new SubProgressMonitor(monitor, 1)); // // RevCommit newHead = result.getNewHead(); // if (newHead != null && result.getCherryPickedRefs().isEmpty()) { // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // GitPlugin.getInstance().getMessage("git.cherryPick.noCherryPickPerformed.title"), // GitPlugin.getInstance().getMessage("git.cherryPick.noCherryPickPerformed.message"), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } // if (newHead == null) { // CherryPickStatus status = result.getStatus(); // switch (status) { // case CONFLICTING: // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // GitPlugin.getInstance().getMessage("git.cherryPick.cherryPickConflicts.title"), // GitPlugin.getInstance().getMessage("git.cherryPick.cherryPickConflicts.message"), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // case FAILED: // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // GitPlugin.getInstance().getMessage("git.cherryPick.cherryPickFailed.message"), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // case OK: // break; // } // } // return true; // } catch (Exception e) { // logger.debug(CommonPlugin.getInstance().getMessage("error"), e); // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // e.getMessage(), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } finally { // monitor.done(); // } // } // // @RemoteInvocation // public boolean revert(StatefulServiceInvocationContext context, HistoryEntryDto entry, String repositoryLocation) { // WebProgressMonitor monitor = ProgressMonitorStatefulService.getInstance(). // createProgressMonitor(GitPlugin.getInstance().getMessage("git.revert.monitor.title", new Object[] {entry.getShortId()})); // // try { // Repository repo = RepositoryCache.open(FileKey.exact(new File(repositoryLocation), FS.DETECTED));; // RevCommit commit = new RevWalk(repo).parseCommit(repo.resolve(entry.getId())); // // RevertCommand command = new Git(repo).revert().include(commit); // RevCommit newHead = (RevCommit) GitPlugin.getInstance().getGitUtils().runGitCommandInUserRepoConfig(repo, command); // // ProjectUtil.refreshValidProjects( // ProjectUtil.getValidOpenProjects(repo), // new SubProgressMonitor(monitor, 1)); // // List<Ref> revertedRefs = command.getRevertedRefs(); // if (newHead != null && revertedRefs.isEmpty()) { // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // GitPlugin.getInstance().getMessage("git.revert.noRevert.title"), // GitPlugin.getInstance().getMessage("git.revert.alreadyReverted.message"), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } // if (newHead == null) { // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // GitPlugin.getInstance().getMessage("git.revert.failed"), // command.getFailingResult().toString(), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } // return true; // } catch (Exception e) { // logger.debug(CommonPlugin.getInstance().getMessage("error"), e); // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // e.getMessage(), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } finally { // monitor.done(); // } // } // // @RemoteInvocation // public CreateBranchPageDto populate_createBranchPage(StatefulServiceInvocationContext context, HistoryEntryDto entry, String repositoryLocation) { // try { // Repository repo = RepositoryCache.open(FileKey.exact(new File(repositoryLocation), FS.DETECTED));; // RevCommit commit = new RevWalk(repo).parseCommit(repo.resolve(entry.getId())); // // if (repo.isBare()) { // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // GitPlugin.getInstance().getMessage("git.repo.bare"), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return null; // } // // CreateBranchPageDto result = new CreateBranchPageDto(); // result.setPrefixName(Constants.R_HEADS); // result.getRefs().add(new GitRef(commit.getId().getName(), entry.getShortId())); // // return result; // } catch (IOException e) { // logger.debug(CommonPlugin.getInstance().getMessage("error"), e); // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // GitPlugin.getInstance().getMessage("git.page.populate.error"), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return null; // } // } // // @RemoteInvocation // public boolean createBranch(StatefulServiceInvocationContext context, HistoryEntryDto entry, String repositoryLocation, String name, GitRef baseOn, boolean checkout) { // try { // Repository repo = RepositoryCache.open(FileKey.exact(new File(repositoryLocation), FS.DETECTED));; // // Git git = new Git(repo); // // Ref newBranch = git.branchCreate(). // setName(name). // setStartPoint(baseOn.getName()). // setUpstreamMode(SetupUpstreamMode.TRACK). // call(); // // // notify clients about changes // RepositoryTreeNode parent = new LocalNode(new BranchesNode(new RepositoryNode(null, repo), repo), repo); // RepositoryTreeNode newNode = new RefNode(parent, repo, newBranch); // if (checkout) { // return new CheckoutOperation(repo, ((Ref)newNode.getObject()).getName(), context.getCommunicationChannel()).execute(); // } else { // GitRepositoriesTreeStatefulService.getInstance().dispatchContentUpdate(parent); // } // // return true; // } catch (Exception e) { // logger.debug(CommonPlugin.getInstance().getMessage("error"), e); // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // e.getMessage(), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } // } // // @RemoteInvocation // public ConfigTagPageDto populate_createTagPage(StatefulServiceInvocationContext context, HistoryEntryDto entry, String repositoryLocation) { // try { // Repository repo = RepositoryCache.open(FileKey.exact(new File(repositoryLocation), FS.DETECTED));; // RevCommit revCommit = new RevWalk(repo).parseCommit(repo.resolve(entry.getId())); // // List<RevCommit> revCommits = new ArrayList<RevCommit>(); // revCommits.add(revCommit); // // List<CommitDto> commits = new ArrayList<CommitDto>(); // for (RevCommit commit : revCommits) { // CommitDto commitDto = new CommitDto(); // commitDto.setId(commit.name()); // commitDto.setShortId(commit.abbreviate(7).name()); // commitDto.setLabel(commit.abbreviate(7).name() + ": " + commit.getShortMessage()); // commits.add(commitDto); // } // // ConfigTagPageDto result = new ConfigTagPageDto(); // result.setCommits(commits); // result.setAddEmptyLine(false); // result.setInitialSelectedIndex(0); // // return result; // } catch (IOException e) { // logger.debug(CommonPlugin.getInstance().getMessage("error"), e); // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // GitPlugin.getInstance().getMessage("git.page.populate.error"), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return null; // } // } // // @RemoteInvocation // public boolean createTag(StatefulServiceInvocationContext context, HistoryEntryDto entry, String repositoryLocation, String name, String message, CommitDto commit) { // try { // Repository repo = RepositoryCache.open(FileKey.exact(new File(repositoryLocation), FS.DETECTED));; // Git git = new Git(repo); // // TagCommand tag = git.tag().setName(name).setMessage(message); // if (commit != null) { // ObjectId objectId = repo.resolve(commit.getId()); // RevCommit revCommit = new RevWalk(repo).lookupCommit(objectId); // // tag.setObjectId(revCommit); // } // tag.call(); // // RepositoryTreeNode parent = new TagsNode(new RepositoryNode(null, repo), repo); // GitRepositoriesTreeStatefulService.getInstance().dispatchContentUpdate(parent); // // return true; // } catch (GitAPIException e) { // logger.debug(CommonPlugin.getInstance().getMessage("error"), e); // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // e.getMessage(), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } catch (IOException e1) { // logger.debug(CommonPlugin.getInstance().getMessage("error"), e1); // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // GitPlugin.getInstance().getMessage("git.createTagPage.error"), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } // } // // @RemoteInvocation // public boolean reset(StatefulServiceInvocationContext context, HistoryEntryDto entry, String repositoryLocation, int resetType) { // try { // Repository repo = RepositoryCache.open(FileKey.exact(new File(repositoryLocation), FS.DETECTED));; // RevCommit revCommit = new RevWalk(repo).parseCommit(repo.resolve(entry.getId())); // // ResetType type; // switch (resetType) { // case 0: // type = ResetType.SOFT; // break; // case 1: // type = ResetType.MIXED; // break; // default: // type = ResetType.HARD; // } // // new ResetOperation(repo, revCommit.getName(), type).execute(); // // return true; // } catch (Exception e) { // logger.debug(CommonPlugin.getInstance().getMessage("error"), e); // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // e.getMessage(), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } // } // // @RemoteInvocation // public ConfigFetchPushPageDto populate_pushCommitPage(StatefulServiceInvocationContext context, String repositoryLocation) { // try { // Repository repo = RepositoryCache.open(FileKey.exact(new File(repositoryLocation), FS.DETECTED));; // // return GitPlugin.getInstance().getGitUtils().getConfigFetchPushPageDto(repo, false); // } catch (Exception e) { // logger.debug(CommonPlugin.getInstance().getMessage("error"), e); // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // e.getMessage(), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return null; // } // } // // @RemoteInvocation // public boolean pushCommit(StatefulServiceInvocationContext context, HistoryEntryDto entry, String repositoryLocation, RemoteConfig pushConfig, String target, boolean isForceUpdate) { // GitService.tlCommand.set((InvokeServiceMethodServerCommand) context.getCommand()); // // WebProgressMonitor monitor = ProgressMonitorStatefulService.getInstance(). // createProgressMonitor(GitPlugin.getInstance().getMessage("git.push.monitor.title")); // // try { // Repository repo = RepositoryCache.open(FileKey.exact(new File(repositoryLocation), FS.DETECTED));; // RevCommit revCommit = new RevWalk(repo).parseCommit(repo.resolve(entry.getId())); // // // RefSpec refSpec = new RefSpec(). // setSourceDestination(revCommit.name(), target). // setForceUpdate(isForceUpdate); // // org.eclipse.jgit.transport.RemoteConfig remoteConfig = null; // List<org.eclipse.jgit.transport.RemoteConfig> remotes = org.eclipse.jgit.transport.RemoteConfig.getAllRemoteConfigs(repo.getConfig()); // for (org.eclipse.jgit.transport.RemoteConfig remote : remotes) { // if (remote.getName().equals(pushConfig.getRemoteName())) { // remoteConfig = remote; // break; // } // } // List<RefSpec> fetchSpecs = remoteConfig != null ? remoteConfig.getFetchRefSpecs() : null; // // Collection<RemoteRefUpdate> remoteRefUpdates = Transport // .findRemoteRefUpdatesFor(repo, // Collections.singleton(refSpec), fetchSpecs); // // EclipseGitProgressTransformer gitMonitor = new EclipseGitProgressTransformer(monitor); // Transport transport = Transport.open(repo, new URIish(pushConfig.getPushUri()).toPrivateString()); // transport.setCredentialsProvider(new GitUsernamePasswordCredentialsProvider()); // PushResult result = transport.push(gitMonitor, remoteRefUpdates); // // context.getCommunicationChannel().sendObject(new OpenOperationResultWindowClientCommand( // GitPlugin.getInstance().getMessage("git.push.result"), // GitPlugin.getInstance().getGitUtils().handlePushResult(result))); // // return true; // } catch (Exception e) { // if (GitPlugin.getInstance().getGitUtils().isAuthentificationException(e)) { // GitService.getInstance().openLoginWindow(); // return true; // } // logger.debug(CommonPlugin.getInstance().getMessage("error"), e); // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // e.getMessage(), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } finally { // monitor.done(); // } // } // // @RemoteInvocation // public boolean merge(StatefulServiceInvocationContext context, HistoryEntryDto entry, String repositoryLocation) { // try { // Repository repo = RepositoryCache.open(FileKey.exact(new File(repositoryLocation), FS.DETECTED)); // RevCommit commit = new RevWalk(repo).parseCommit(repo.resolve(entry.getId())); // // String status = mergeStatus(repo); // if (status != null) { // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // status, // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } // // List<RefNode> nodes = getRefNodes(commit, repo, Constants.R_HEADS); // // String target; // if (nodes.isEmpty()) // target = commit.name(); // else { // target = nodes.get(0).getObject().getName(); // } // // MergeOperation op = new MergeOperation(repo, target, false, context.getCommunicationChannel()); // // return op.execute(); // } catch (Exception e) { // logger.debug(CommonPlugin.getInstance().getMessage("error"), e); // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // e.getMessage(), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } // } // // @RemoteInvocation // public boolean rebase(StatefulServiceInvocationContext context, HistoryEntryDto entry, String repositoryLocation) { // try { // Repository repo = RepositoryCache.open(FileKey.exact(new File(repositoryLocation), FS.DETECTED)); // // if (!repo.getFullBranch().startsWith(Constants.R_HEADS)) { // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // GitPlugin.getInstance().getMessage("git.rebase.noLocalBranch"), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } // // String currentBranch = repo.getBranch(); // RevCommit commit = new RevWalk(repo).parseCommit(repo.resolve(entry.getId())); // // Ref ref; // List<RefNode> nodes = getRefNodes(commit, repo, Constants.R_HEADS); // if (nodes.size() == 0) // ref = new ObjectIdRef.Unpeeled(Storage.LOOSE, commit.getName(), commit); // else if (nodes.size() == 1) // ref = nodes.get(0).getObject(); // else { // BranchConfig branchConfig = new BranchConfig(repo.getConfig(), currentBranch); // String trackingBranch = branchConfig.getTrackingBranch(); // Ref remoteRef = null; // // for (int i = 0; i < nodes.size(); i++) { // Ref obj = nodes.get(i).getObject(); // if (trackingBranch != null && trackingBranch.equals(obj.getName())) { // ref = obj; // break; // } // if (obj.getName().startsWith(Constants.R_REMOTES)) { // remoteRef = obj; // } // } // // if (remoteRef != null) { // ref = remoteRef; // } else { // // We tried to pick a nice ref, just pick the first then // ref = nodes.get(0).getObject(); // } // } // // RebaseOperation op = new RebaseOperation(repo, ref.getName()); // op.execute(); // // context.getCommunicationChannel().sendObject(new OpenOperationResultWindowClientCommand( // GitPlugin.getInstance().getMessage("git.rebase.result"), // op.handleRebaseResult())); // // return true; // } catch (Exception e) { // logger.debug(CommonPlugin.getInstance().getMessage("error"), e); // context.getCommunicationChannel().sendObject( // new DisplaySimpleMessageClientCommand( // CommonPlugin.getInstance().getMessage("error"), // e.getMessage(), // DisplaySimpleMessageClientCommand.ICON_ERROR)); // return false; // } // } }