Public Git Hosting - EMFCompare2.git/blob - plugins/org.eclipse.emf.compare.ide.ui.tests.git.framework/src/org/eclipse/emf/compare/ide/ui/tests/git/framework/internal/statements/InternalGitTestSupport.java

1 /*******************************************************************************

4 * are made available under the terms of the Eclipse Public License v1.0

5 * which accompanies this distribution, and is available at

6 * http://www.eclipse.org/legal/epl-v10.html

8 * Contributors:

9 * Obeo - initial API and implementation

10 *******************************************************************************/

package org.eclipse.emf.compare.ide.ui.tests.git.framework.internal.statements;

13 import java.io.BufferedOutputStream;

14 import java.io.File;

15 import java.io.FileOutputStream;

16 import java.io.IOException;

17 import java.io.InputStream;

import java.lang.reflect.InvocationTargetException;

import java.nio.file.Files;

20 import java.util.ArrayList;

21 import java.util.Arrays;

22 import java.util.Collection;

23 import java.util.Comparator;

24 import java.util.List;

import java.util.stream.Stream;

import java.util.zip.ZipEntry;

import java.util.zip.ZipInputStream;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IProjectDescription;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.IWorkspaceRoot;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.runtime.Path;

import org.eclipse.egit.core.Activator;

import org.eclipse.egit.core.op.ConnectProviderOperation;

import org.eclipse.egit.core.op.DisconnectProviderOperation;

import org.eclipse.egit.core.project.RepositoryFinder;

import org.eclipse.egit.core.project.RepositoryMapping;

import org.eclipse.jgit.lib.Repository;

import org.eclipse.ui.dialogs.IOverwriteQuery;

import org.eclipse.ui.wizards.datatransfer.FileSystemStructureProvider;

import org.eclipse.ui.wizards.datatransfer.ImportOperation;

48 /**

49 * This class contains utility methods to perform git tests. Those methods are internal and are not intended

50 * to be used by clients.

51 *

52 * @author <a href="mailto:mathieu.cartaud@obeo.fr">Mathieu Cartaud</a>

53 */

54 @SuppressWarnings({"restriction" })

55 public class InternalGitTestSupport {

57 /** The prefix of Git branches. */

        private static final String GIT_BRANCH_PREFIX = "refs/heads/"; //$NON-NLS-1$

60 /** Name of the Eclipse metadata folder. */

        private static final String METADATA_FOLDER = ".metadata"; //$NON-NLS-1$

63 /** Name of the git metadata folder. */

        private static final String GIT_FOLDER = ".git"; //$NON-NLS-1$

66 /** Size of the buffer to read/write data. */

67 private static final int BUFFER_SIZE = 4096;

69 /** The JGit repository. */

70 protected Repository repository;

72 /** The list of projects in the repository. */

73 protected IProject[] projects;

75 /** The list of JGit disposers. */

76 protected ArrayList<Runnable> disposers;

78 /** Query used to specify if the projects import must override existing projects. */

        private IOverwriteQuery overwriteQuery = new IOverwriteQuery() {

80 public String queryOverwrite(String file) {

81 return ALL;

82 }

83 };

85 /**

86 * Adapt the given <code>branch</code> name to be in a correct format for Git or return it directly if it

87 * is already the case.

88 *

89 * @param branch

90 * The branch name we want to normalize

91 * @return the branch in Git format

92 */

93 protected static String normalizeBranch(String branch) {

                if (branch.startsWith(GIT_BRANCH_PREFIX)) {

95 return branch;

96 } else {

97 return GIT_BRANCH_PREFIX + branch;

98 }

99 }

100

101 /**

102 * Perform all loading actions (unzip the archive, connect the git repository to JGit, import the

103 * contained projects in the workspace and connect them through JGit).

104 *

105 * @param clazz

106 * The test class

107 * @param path

108 * The path of the archive containing the Git repository

109 * @throws Exception

110 * If something goes wrong during unzip or import steps

111 */

        protected void createRepositoryFromPath(Class<?> clazz, String path) throws Exception {

                final IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();

114 // Delete all projects that can remain in the workspace : prevent errors dues to wrong cleanup of

115 // other tests

                root.delete(true, new NullProgressMonitor());

117 IPath location = root.getLocation();

                List<String> extractedPaths = extractArchive(clazz, path, root);

119 for (String extractedPath : extractedPaths) {

                        File extractedFile = new File(extractedPath);

                        if (!extractedFile.getPath().contains(File.separatorChar + METADATA_FOLDER + File.separatorChar)

122 && !extractedFile.getPath()

                                                        .contains(File.separatorChar + GIT_FOLDER + File.separatorChar)) {

                                if (".project".equals(extractedFile.getName())) { //$NON-NLS-1$

125 importProject(extractedFile);

126 }

127 }

128 }

                connectRepository(new File(location.toString()));

                List<IProject> existingProjects = Arrays.asList(root.getProjects());

                List<IProject> connectedProjects = new ArrayList<>();

132 for (IProject project : existingProjects) {

                        RepositoryFinder finder = new RepositoryFinder(project);

                        finder.setFindInChildren(false);

                        Collection<RepositoryMapping> repos = finder.find(new NullProgressMonitor());

                        if (!repos.isEmpty()) {

137 connect(project);

138 connectedProjects.add(project);

139 }

140 }

                projects = connectedProjects.toArray(new IProject[connectedProjects.size()]);

142 }

143

144 /**

145 * Connect a project to the Git repository.

146 *

147 * @param project

148 * The project to connect

149 * @throws CoreException

150 * Thrown if the project cannot be connected to the workspace

151 * @throws InterruptedException

152 * Thrown if the operation is interrupted

153 */

        private void connect(IProject project) throws CoreException, InterruptedException {

                ConnectProviderOperation op = new ConnectProviderOperation(project, repository.getDirectory());

                op.execute(null);

157 }

158

159 /**

160 * Connect the Git repository to JGit.

161 *

162 * @param file

163 * The path to the root of the repository

164 * @throws IOException

165 * If their is a problem during the connection to JGit

166 */

        private void connectRepository(File file) throws IOException {

168 File gitDir = findGitDir(file);

                this.repository = Activator.getDefault().getRepositoryCache().lookupRepository(gitDir);

                this.disposers = new ArrayList<Runnable>();

171 }

172

173 /**

174 * Find the ".git" folder in the repository.

175 *

176 * @param file

177 * The path of the root of the unziped files

178 * @return The path to the .git folder

179 */

180 private File findGitDir(File file) {

                File[] listFiles = file.listFiles();

                if (listFiles != null) {

183 for (File child : listFiles) {

                                if (child.isDirectory() && child.getName().equals(".git")) { //$NON-NLS-1$

185 return child;

                                } else if (child.isDirectory()) {

187 File findGitDir = findGitDir(child);

                                        if (findGitDir != null) {

189 return findGitDir;

190 }

191 }

192 }

193 }

194 return null;

195 }

196

197 /**

198 * Import the project located in the given path into the test workspace.

199 *

200 * @param file

201 * The path to the .project file

202 * @throws InvocationTargetException

203 * Thrown if an error happen during the import of the project

204 * @throws InterruptedException

205 * Thrown if the import operation is interrupted

206 * @throws CoreException

207 * Thrown if the project cannot be created in the workspace

208 */

209 private void importProject(File file)

210 throws InvocationTargetException, InterruptedException, CoreException {

211 IProjectDescription description = ResourcesPlugin.getWorkspace()

                                .loadProjectDescription(new Path(file.getAbsolutePath()));

                IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(description.getName());

                project.create(description, new NullProgressMonitor());

                project.open(new NullProgressMonitor());

216

                ImportOperation importOperation = new ImportOperation(project.getFullPath(), file.getParentFile(),

218 FileSystemStructureProvider.INSTANCE, overwriteQuery);

                importOperation.setCreateContainerStructure(false);

                importOperation.run(new NullProgressMonitor());

221 }

222

223 /**

224 * Extract the zip file into the given workspace.

225 *

226 * @param clazz

227 * The test class

228 * @param path

229 * The path to the archive (relative to the test class)

230 * @param root

231 * The root of the test workspace

232 * @return The list of files extracted from this archive. Does not include folders.

233 * @throws IOException

234 * Thrown if the zip extraction goes wrong

235 */

        private List<String> extractArchive(Class<?> clazz, String path, IWorkspaceRoot root) throws IOException {

                List<String> extractedPaths = new ArrayList<>();

                try (InputStream resourceAsStream = clazz.getResourceAsStream(path);

                                ZipInputStream zipIn = new ZipInputStream(resourceAsStream);) {

240 ZipEntry entry = null;

                        while ((entry = zipIn.getNextEntry()) != null) {

                                String filePath = root.getLocation() + File.separator + entry.getName();

                                if (!entry.isDirectory()) {

244 extractFile(zipIn, filePath);

245 extractedPaths.add(filePath);

246 } else {

                                        File dir = new File(filePath);

248 dir.mkdir();

249 }

250 zipIn.closeEntry();

251 }

252 }

253 return extractedPaths;

254 }

255

256 /**

257 * Extract the given input stream to the given location.

258 *

259 * @param zipIn

260 * The zip input stream

261 * @param filePath

262 * The destination path for the extraction

263 * @throws IOException

264 * Thrown if something happen during the extraction

265 */

        private void extractFile(ZipInputStream zipIn, String filePath) throws IOException {

                File file = new File(filePath);

                file.getParentFile().mkdirs();

                try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));) {

                        byte[] bytesIn = new byte[BUFFER_SIZE];

271 int read = 0;

                        while ((read = zipIn.read(bytesIn)) != -1) {

                                bos.write(bytesIn, 0, read);

274 }

275 }

276 }

277

278 /**

279 * Clean all possibly remaining elements to start the test in a clean state.

280 *

281 * @throws CoreException

282 * Thrown if a project cannot be deleted

283 * @throws IOException

284 * Thrown if a file cannot be deleted

285 */

        protected void setup() throws CoreException, IOException {

                final IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();

                IProject[] unknownProjects = workspaceRoot.getProjects();

                if (unknownProjects != null && unknownProjects.length > 0) {

290 for (IProject iProject : unknownProjects) {

                                iProject.delete(true, new NullProgressMonitor());

292 }

293 }

                Activator.getDefault().getRepositoryCache().clear();

295

                File file = new File(workspaceRoot.getLocation().toOSString());

                File[] listFiles = file.listFiles();

                if (listFiles != null) {

299 for (File child : listFiles) {

                                if (!child.getName().equals(METADATA_FOLDER)) {

                                        try (Stream<java.nio.file.Path> walk = Files.walk(child.toPath())) {

                                                walk.sorted(Comparator.reverseOrder()).map(java.nio.file.Path::toFile)

                                                                .forEach(File::delete);

304 }

305 }

306 }

307 }

308 }

309

310 /**

311 * Clear workspace and repository for next tests.

312 *

313 * @throws CoreException

314 * Thrown if a project cannot be deleted

315 * @throws IOException

316 * Thrown if a file cannot be deleted

317 */

        protected void tearDown() throws CoreException, IOException {

                if (disposers != null) {

320 for (Runnable disposer : disposers) {

321 disposer.run();

322 }

323 disposers.clear();

324 }

325

                Activator.getDefault().getRepositoryCache().clear();

327

                if (projects != null) {

                        List<IProject> disconnectMe = new ArrayList<>();

330 for (IProject iProject : projects) {

331 disconnectMe.add(iProject);

332 }

                        new DisconnectProviderOperation(disconnectMe).execute(null);

334

335 // Delete sub-projects first

                        List<IProject> allProjects = new ArrayList<>(

                                        Arrays.asList(ResourcesPlugin.getWorkspace().getRoot().getProjects()));

                        allProjects.sort((p1, p2) -> p2.getLocation().toString().compareTo(p1.getLocation().toString()));

339

340 for (IProject iProject : allProjects) {

                                if (iProject.isAccessible()) {

                                        iProject.delete(true, new NullProgressMonitor());

343 }

344 }

                        ResourcesPlugin.getWorkspace().getRoot().refreshLocal(IResource.DEPTH_INFINITE,

346 new NullProgressMonitor());

347 }

348

                File file = new File(ResourcesPlugin.getWorkspace().getRoot().getLocation().toOSString());

                File[] listFiles = file.listFiles();

                if (listFiles != null) {

352 for (File child : listFiles) {

                                if (!child.getName().equals(METADATA_FOLDER)) {

                                        try (Stream<java.nio.file.Path> walk = Files.walk(child.toPath())) {

                                                walk.sorted(Comparator.reverseOrder()).map(java.nio.file.Path::toFile)

                                                                .forEach(File::delete);

357 }

358 }

359 }

360 }

361 }

362

363 }