TEMP

acceptance-webapp/pom.xml

@@ -88,6 +88,13 @@
       <artifactId>validation-api</artifactId>
     </dependency>
     <!-- **************************************** -->
+    <!-- JGit -->
+    <!-- **************************************** -->
+    <dependency>
+      <groupId>org.eclipse.jgit</groupId>
+      <artifactId>org.eclipse.jgit</artifactId>
+    </dependency>
+    <!-- **************************************** -->
     <!-- Juzu -->
     <!-- **************************************** -->
     <dependency>
@@ -222,6 +229,14 @@
       <scope>runtime</scope>
     </dependency>
     <!-- **************************************** -->
+    <!-- JGit -->
+    <!-- **************************************** -->
+    <dependency>
+      <groupId>org.eclipse.jgit</groupId>
+      <artifactId>org.eclipse.jgit.java7</artifactId>
+      <scope>runtime</scope>
+    </dependency>
+    <!-- **************************************** -->
     <!-- Required by logback for colorized console on windows -->
     <!-- **************************************** -->
     <dependency>

acceptance-webapp/src/main/java/org/exoplatform/acceptance/model/vcs/VCSBranch.java

@@ -20,153 +20,24 @@
 
 import org.exoplatform.acceptance.model.StorableObject;
 
-import com.google.common.base.Objects;
 import javax.validation.constraints.NotNull;
+import org.springframework.data.mongodb.core.mapping.Document;
 
 /**
- *
+ * a VCS Branch
  */
-public class VCSBranch {
-
-  /**
-   * The name to humanly identify the credential
-   */
-  @NotNull
-  protected String name;
-
-  public VCSBranch(@NotNull String name) {
-    this.name = name;
-  }
+@Document(collection = "vcsbranches")
+public class VCSBranch extends StorableObject {
 
-  public String getName() {
-    return name;
+  public VCSBranch() {
+    super();
   }
 
-  public void setName(@NotNull String name) {
-    this.name = name;
-  }
-
-  /**
-   * Returns a string representation of the object. In general, the
-   * {@code toString} method returns a string that
-   * "textually represents" this object. The result should
-   * be a concise but informative representation that is easy for a
-   * person to read.
-   * It is recommended that all subclasses override this method.
-   * <p/>
-   * The {@code toString} method for class {@code Object}
-   * returns a string consisting of the name of the class of which the
-   * object is an instance, the at-sign character `{@code @}', and
-   * the unsigned hexadecimal representation of the hash code of the
-   * object. In other words, this method returns a string equal to the
-   * value of:
-   * <blockquote>
-   * <pre>
-   * getClass().getName() + '@' + Integer.toHexString(hashCode())
-   * </pre></blockquote>
-   *
-   * @return a string representation of the object.
-   */
-  @Override
-  public String toString() {
-    return Objects.toStringHelper(this).add("name", getName()).toString();
-  }
-
-  /**
-   * Indicates whether some other object is "equal to" this one.
-   * <p/>
-   * The {@code equals} method implements an equivalence relation
-   * on non-null object references:
-   * <ul>
-   * <li>It is <i>reflexive</i>: for any non-null reference value
-   * {@code x}, {@code x.equals(x)} should return
-   * {@code true}.
-   * <li>It is <i>symmetric</i>: for any non-null reference values
-   * {@code x} and {@code y}, {@code x.equals(y)}
-   * should return {@code true} if and only if
-   * {@code y.equals(x)} returns {@code true}.
-   * <li>It is <i>transitive</i>: for any non-null reference values
-   * {@code x}, {@code y}, and {@code z}, if
-   * {@code x.equals(y)} returns {@code true} and
-   * {@code y.equals(z)} returns {@code true}, then
-   * {@code x.equals(z)} should return {@code true}.
-   * <li>It is <i>consistent</i>: for any non-null reference values
-   * {@code x} and {@code y}, multiple invocations of
-   * {@code x.equals(y)} consistently return {@code true}
-   * or consistently return {@code false}, provided no
-   * information used in {@code equals} comparisons on the
-   * objects is modified.
-   * <li>For any non-null reference value {@code x},
-   * {@code x.equals(null)} should return {@code false}.
-   * </ul>
-   * <p/>
-   * The {@code equals} method for class {@code Object} implements
-   * the most discriminating possible equivalence relation on objects;
-   * that is, for any non-null reference values {@code x} and
-   * {@code y}, this method returns {@code true} if and only
-   * if {@code x} and {@code y} refer to the same object
-   * ({@code x == y} has the value {@code true}).
-   * <p/>
-   * Note that it is generally necessary to override the {@code hashCode}
-   * method whenever this method is overridden, so as to maintain the
-   * general contract for the {@code hashCode} method, which states
-   * that equal objects must have equal hash codes.
-   *
-   * @param obj the reference object with which to compare.
-   * @return {@code true} if this object is the same as the obj
-   * argument; {@code false} otherwise.
-   * @see #hashCode()
-   * @see java.util.HashMap
-   */
-  @Override
-  public boolean equals(Object obj) {
-    if (obj == null) {
-      return false;
-    }
-    if (getClass() != obj.getClass()) {
-      return false;
-    }
-    final StorableObject other = (StorableObject) obj;
-    return java.util.Objects.equals(this.getName(), other.getName());
+  public VCSBranch(@NotNull String name) {
+    super(name);
   }
 
-  /**
-   * Returns a hash code value for the object. This method is
-   * supported for the benefit of hash tables such as those provided by
-   * {@link java.util.HashMap}.
-   * <p/>
-   * The general contract of {@code hashCode} is:
-   * <ul>
-   * <li>Whenever it is invoked on the same object more than once during
-   * an execution of a Java application, the {@code hashCode} method
-   * must consistently return the same integer, provided no information
-   * used in {@code equals} comparisons on the object is modified.
-   * This integer need not remain consistent from one execution of an
-   * application to another execution of the same application.
-   * <li>If two objects are equal according to the {@code equals(Object)}
-   * method, then calling the {@code hashCode} method on each of
-   * the two objects must produce the same integer result.
-   * <li>It is <em>not</em> required that if two objects are unequal
-   * according to the {@link Object#equals(Object)}
-   * method, then calling the {@code hashCode} method on each of the
-   * two objects must produce distinct integer results.  However, the
-   * programmer should be aware that producing distinct integer results
-   * for unequal objects may improve the performance of hash tables.
-   * </ul>
-   * <p/>
-   * As much as is reasonably practical, the hashCode method defined by
-   * class {@code Object} does return distinct integers for distinct
-   * objects. (This is typically implemented by converting the internal
-   * address of the object into an integer, but this implementation
-   * technique is not required by the
-   * Java<font size="-2"><sup>TM</sup></font> programming language.)
-   *
-   * @return a hash code value for this object.
-   * @see Object#equals(Object)
-   * @see System#identityHashCode
-   */
-  @Override
-  public int hashCode() {
-    return java.util.Objects.hash(this.getName());
+  public VCSBranch(@NotNull String name, @NotNull String id) {
+    super(name, id);
   }
 }

acceptance-webapp/src/main/java/org/exoplatform/acceptance/model/vcs/VCSFileSet.java

@@ -20,40 +20,136 @@
 
 import com.google.common.base.Objects;
 import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 import javax.validation.constraints.NotNull;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.internal.storage.file.FileRepository;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.StoredConfig;
+import org.eclipse.jgit.transport.RefSpec;
+import org.eclipse.jgit.transport.TagOpt;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  *
  */
 public class VCSFileSet {
+  private static final Logger LOGGER = LoggerFactory.getLogger(VCSFileSet.class);
   /**
    * Local base directory where the clone is created
    */
-  @NotNull
   private File baseDir;
   /**
    * Identifier of the VCSRepository from which this local copy was created
    */
-  @NotNull
   private VCSRepository repository;
+  /**
+   * Offers a "GitPorcelain"-like API to interact with a git repository.
+   */
+  private Git git;
 
   public VCSFileSet(@NotNull File baseDir, @NotNull VCSRepository repository) {
     this.baseDir = baseDir;
     this.repository = repository;
+    initialize();
   }
 
   public File getBaseDir() {
     return baseDir;
   }
 
-  public void setBaseDir(File baseDir) {
-    this.baseDir = baseDir;
-  }
-
   public VCSRepository getRepository() {
     return repository;
   }
 
+  private void initialize() {
+    if (!baseDir.exists()) {
+      if (this.repository.getRemoteRepositories().size() > 0) {
+        LOGGER.debug("Cloning {} into {}", this.repository.getName(), baseDir);
+        // Clone the first remote
+        try {
+          git = Git.cloneRepository()
+              .setURI(this.repository.getRemoteRepositories().iterator().next().getUrl())
+              .setDirectory(baseDir)
+              .setBare(true)
+              .call();
+        } catch (GitAPIException e) {
+          LOGGER.warn("Error while cloning {} : {}", this.repository, e.getMessage());
+          return;
+        }
+        LOGGER.debug("{} cloned into {}", this.repository.getName());
+      }
+    } else {
+      try {
+        git = new Git(new FileRepository(baseDir));
+      } catch (IOException e) {
+        LOGGER.warn("Error while initializing {} : {}", this, e.getMessage());
+        return;
+      }
+    }
+    StoredConfig config = git.getRepository().getConfig();
+    config.unsetSection("remote", "origin");
+    try {
+      config.save();
+    } catch (IOException e) {
+      LOGGER.warn("Error while updating local repository config");
+    }
+    for (VCSCoordinates remote : this.repository.getRemoteRepositories()) {
+      config.setString("remote", remote.getName(), "url", remote.getUrl());
+      try {
+        config.save();
+      } catch (IOException e) {
+        LOGGER.warn("Error while updating local repository config");
+        continue;
+      }
+      // Fetch
+      try {
+        LOGGER.debug("Fetching {} into {}", remote.getName(), this.baseDir);
+        git.fetch()
+            .setRemote(remote.getName())
+            .setRefSpecs(new RefSpec("+refs/heads/*:refs/remotes/" + remote.getName() + "/*"))
+            .setRemoveDeletedRefs(true)
+            .setTagOpt(TagOpt.FETCH_TAGS)
+            .call();
+        LOGGER.debug("{} fetched into {}", remote.getName(), this.baseDir);
+      } catch (Exception e) {
+        LOGGER.warn("Error while fetching changes from remotes : {}", e.getMessage());
+      }
+
+    }
+  }
+
+  public List<VCSBranch> getBranches() {
+    List<VCSBranch> branches = new ArrayList<>();
+    try {
+      for (Ref ref : git.branchList().call()) {
+        branches.add(new VCSBranch(ref.getName().replaceAll("/refs/heads", "")));
+      }
+    } catch (GitAPIException e) {
+      LOGGER.warn("Error while getting branches on {} : {}", this, e.getMessage());
+      return Collections.emptyList();
+    }
+    return branches;
+  }
+
+  public List<VCSTag> getTags() {
+    List<VCSTag> tags = new ArrayList<>();
+    try {
+      for (Ref ref : git.tagList().call()) {
+        tags.add(new VCSTag(ref.getName().replaceAll("/refs/tags/", "")));
+      }
+    } catch (GitAPIException e) {
+      LOGGER.warn("Error while getting tags on {} : {}", this, e.getMessage());
+      return Collections.emptyList();
+    }
+    return tags;
+  }
+
   /**
    * Returns a string representation of the object. In general, the
    * {@code toString} method returns a string that

acceptance-webapp/src/main/java/org/exoplatform/acceptance/model/vcs/VCSTag.java

@@ -0,0 +1,24 @@
+package org.exoplatform.acceptance.model.vcs;
+
+import org.exoplatform.acceptance.model.StorableObject;
+
+import javax.validation.constraints.NotNull;
+import org.springframework.data.mongodb.core.mapping.Document;
+
+/**
+ * a VCS Tag
+ */
+@Document(collection = "vcstags")
+public class VCSTag extends StorableObject {
+  public VCSTag() {
+    super();
+  }
+
+  public VCSTag(@NotNull String name) {
+    super(name);
+  }
+
+  public VCSTag(@NotNull String name, @NotNull String id) {
+    super(name, id);
+  }
+}

acceptance-webapp/src/main/java/org/exoplatform/acceptance/service/ConfigurationService.java

@@ -94,8 +94,11 @@ public File getDataDir() {
     }
     File dataDir = new File(dataDirPath);
     if (!dataDir.exists()) {
-      boolean result = dataDir.mkdirs();
-      LOGGER.info("Data directory {} creation [{}]", dataDirPath, result ? "OK" : "KO");
+      if (dataDir.mkdirs()) {
+        LOGGER.info("Data directory {} creation [OK]");
+      } else {
+        LOGGER.error("Data directory {} creation [KO]");
+      }
     }
     return dataDir;
   }
@@ -106,8 +109,11 @@ public File getTmpDir() {
     }
     File tmpDir = new File(tmpDirPath);
     if (!tmpDir.exists()) {
-      boolean result = tmpDir.mkdirs();
-      LOGGER.info("Temporary directory {} creation [{}]", tmpDirPath, result ? "OK" : "KO");
+      if (tmpDir.mkdirs()) {
+        LOGGER.info("Temporary directory {} creation [OK]");
+      } else {
+        LOGGER.error("Temporary directory {} creation [KO]");
+      }
     }
     return tmpDir;
   }