org.argeo.slc.repo/src/org/argeo/slc/repo/maven/MavenProxyServiceImpl.java

   1 package org.argeo.slc.repo.maven;
   2
   3 import java.util.ArrayList;
   4 import java.util.List;
   5
   6 import javax.jcr.Node;
   7 import javax.jcr.NodeIterator;
   8 import javax.jcr.RepositoryException;
   9 import javax.jcr.Session;
  10 import javax.jcr.nodetype.NodeType;
  11 import javax.jcr.security.AccessControlException;
  12 import javax.jcr.security.Privilege;
  13
  14 import org.apache.commons.logging.Log;
  15 import org.apache.commons.logging.LogFactory;
  16 import org.argeo.cms.ArgeoNames;
  17 import org.argeo.jcr.JcrUtils;
  18 import org.argeo.jcr.proxy.AbstractUrlProxy;
  19 import org.argeo.slc.SlcConstants;
  20 import org.argeo.slc.SlcException;
  21 import org.argeo.slc.SlcNames;
  22 import org.argeo.slc.SlcTypes;
  23 import org.argeo.slc.repo.MavenProxyService;
  24 import org.argeo.slc.repo.RepoConstants;
  25 import org.eclipse.aether.repository.RemoteRepository;
  26
  27 /** Synchronises the node repository with remote Maven repositories */
  28 public class MavenProxyServiceImpl extends AbstractUrlProxy implements
  29                 MavenProxyService, ArgeoNames, SlcNames {
  30         private final static Log log = LogFactory
  31                         .getLog(MavenProxyServiceImpl.class);
  32
  33         private List<RemoteRepository> defaultRepositories = new ArrayList<RemoteRepository>();
  34
  35         /** Initialises the artifacts area. */
  36         @Override
  37         protected void beforeInitSessionSave(Session session)
  38                         throws RepositoryException {
  39                 JcrUtils.addPrivilege(session, "/", SlcConstants.USER_ANONYMOUS, Privilege.JCR_READ);
  40                 try {
  41                         JcrUtils.addPrivilege(session, "/", SlcConstants.ROLE_SLC,
  42                                         Privilege.JCR_ALL);
  43                 } catch (AccessControlException e) {
  44                         if (log.isTraceEnabled())
  45                                 log.trace("Cannot give jcr:all privileges to "
  46                                                 + SlcConstants.ROLE_SLC);
  47                 }
  48
  49                 JcrUtils.mkdirsSafe(session, RepoConstants.DEFAULT_ARTIFACTS_BASE_PATH);
  50                 Node proxiedRepositories = JcrUtils.mkdirsSafe(session,
  51                                 RepoConstants.PROXIED_REPOSITORIES);
  52                 for (RemoteRepository repository : defaultRepositories) {
  53                         if (!proxiedRepositories.hasNode(repository.getId())) {
  54                                 Node proxiedRepository = proxiedRepositories.addNode(repository
  55                                                 .getId());
  56                                 proxiedRepository.addMixin(NodeType.MIX_REFERENCEABLE);
  57                                 JcrUtils.urlToAddressProperties(proxiedRepository,
  58                                                 repository.getUrl());
  59                                 // proxiedRepository.setProperty(SLC_URL, repository.getUrl());
  60                                 proxiedRepository.setProperty(SLC_TYPE,
  61                                                 repository.getContentType());
  62                         }
  63                 }
  64         }
  65
  66         /**
  67          * Retrieve and add this file to the repository
  68          */
  69         @Override
  70         protected Node retrieve(Session session, String path) {
  71                 try {
  72                         if (session.hasPendingChanges())
  73                                 throw new SlcException("Session has pending changed");
  74                         Node node = null;
  75                         for (Node proxiedRepository : getBaseUrls(session)) {
  76                                 String baseUrl = JcrUtils
  77                                                 .urlFromAddressProperties(proxiedRepository);
  78                                 node = proxyUrl(session, baseUrl, path);
  79                                 if (node != null) {
  80                                         node.addMixin(SlcTypes.SLC_KNOWN_ORIGIN);
  81                                         Node origin = node
  82                                                         .addNode(SLC_ORIGIN, SlcTypes.SLC_PROXIED);
  83                                         origin.setProperty(SLC_PROXY, proxiedRepository);
  84                                         JcrUtils.urlToAddressProperties(origin, baseUrl + path);
  85                                         if (log.isDebugEnabled())
  86                                                 log.debug("Imported " + baseUrl + path + " to " + node);
  87                                         return node;
  88                                 }
  89                         }
  90                         if (log.isDebugEnabled())
  91                                 log.warn("No proxy found for " + path);
  92                         return null;
  93                 } catch (Exception e) {
  94                         throw new SlcException("Cannot proxy " + path, e);
  95                 }
  96         }
  97
  98         protected synchronized List<Node> getBaseUrls(Session session)
  99                         throws RepositoryException {
 100                 List<Node> baseUrls = new ArrayList<Node>();
 101                 for (NodeIterator nit = session.getNode(
 102                                 RepoConstants.PROXIED_REPOSITORIES).getNodes(); nit.hasNext();) {
 103                         Node proxiedRepository = nit.nextNode();
 104                         baseUrls.add(proxiedRepository);
 105                 }
 106                 return baseUrls;
 107         }
 108
 109         public void setDefaultRepositories(
 110                         List<RemoteRepository> defaultRepositories) {
 111                 this.defaultRepositories = defaultRepositories;
 112         }
 113 }