runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/maven/proxy/MavenProxyServiceImpl.java

   1 package org.argeo.slc.repo.maven.proxy;
   2
   3 import java.io.InputStream;
   4 import java.net.URL;
   5 import java.util.ArrayList;
   6 import java.util.List;
   7
   8 import javax.jcr.Binary;
   9 import javax.jcr.Node;
  10 import javax.jcr.NodeIterator;
  11 import javax.jcr.Property;
  12 import javax.jcr.Repository;
  13 import javax.jcr.RepositoryException;
  14 import javax.jcr.Session;
  15 import javax.jcr.nodetype.NodeType;
  16
  17 import org.apache.commons.io.IOUtils;
  18 import org.apache.commons.logging.Log;
  19 import org.apache.commons.logging.LogFactory;
  20 import org.argeo.jcr.ArgeoNames;
  21 import org.argeo.jcr.JcrUtils;
  22 import org.argeo.slc.SlcException;
  23 import org.argeo.slc.jcr.SlcNames;
  24 import org.argeo.slc.repo.RepoConstants;
  25 import org.sonatype.aether.repository.RemoteRepository;
  26
  27 /** Synchronizes the node repository with remote Maven repositories */
  28 public class MavenProxyServiceImpl implements MavenProxyService, ArgeoNames,
  29                 SlcNames {
  30         private final static Log log = LogFactory
  31                         .getLog(MavenProxyServiceImpl.class);
  32
  33         private Repository jcrRepository;
  34         private Session jcrAdminSession;
  35         private List<RemoteRepository> defaultRepositories = new ArrayList<RemoteRepository>();
  36
  37         public void init() {
  38                 try {
  39                         jcrAdminSession = jcrRepository.login();
  40
  41                         JcrUtils.mkdirs(jcrAdminSession, RepoConstants.ARTIFACTS_BASE_PATH);
  42                         Node proxiedRepositories = JcrUtils.mkdirs(jcrAdminSession,
  43                                         RepoConstants.PROXIED_REPOSITORIES);
  44                         for (RemoteRepository repository : defaultRepositories) {
  45                                 if (!proxiedRepositories.hasNode(repository.getId())) {
  46                                         Node proxiedRepository = proxiedRepositories
  47                                                         .addNode(repository.getId());
  48                                         proxiedRepository.setProperty(SLC_URL, repository.getUrl());
  49                                         proxiedRepository.setProperty(SLC_TYPE,
  50                                                         repository.getContentType());
  51                                 }
  52                         }
  53                         jcrAdminSession.save();
  54                 } catch (RepositoryException e) {
  55                         JcrUtils.discardQuietly(jcrAdminSession);
  56                         throw new SlcException("Cannot initialize Maven proxy", e);
  57                 }
  58         }
  59
  60         public void destroy() {
  61                 JcrUtils.logoutQuietly(jcrAdminSession);
  62         }
  63
  64         /**
  65          * Retrieve and add this file to the repository
  66          */
  67         public synchronized String proxyFile(String path) {
  68                 try {
  69                         Node node = null;
  70                         proxiedRepositories: for (NodeIterator nit = jcrAdminSession
  71                                         .getNode(RepoConstants.PROXIED_REPOSITORIES).getNodes(); nit
  72                                         .hasNext();) {
  73                                 Node proxiedRepository = nit.nextNode();
  74                                 String repoUrl = proxiedRepository.getProperty(SLC_URL)
  75                                                 .getString();
  76                                 String remoteUrl = repoUrl + path;
  77                                 if (log.isTraceEnabled())
  78                                         log.trace("remoteUrl=" + remoteUrl);
  79                                 InputStream in = null;
  80                                 try {
  81                                         URL u = new URL(remoteUrl);
  82                                         in = u.openStream();
  83                                         node = importFile(getNodePath(path), in);
  84                                         if (log.isDebugEnabled())
  85                                                 log.debug("Imported " + remoteUrl + " to " + node);
  86                                         break proxiedRepositories;
  87                                 } catch (Exception e) {
  88                                         if (log.isDebugEnabled())
  89                                                 log.debug("Cannot read " + remoteUrl + ", skipping... "
  90                                                                 + e.getMessage());
  91                                         // e.printStackTrace();
  92                                 } finally {
  93                                         IOUtils.closeQuietly(in);
  94                                 }
  95                         }
  96
  97                         if (node != null)
  98                                 return node.getIdentifier();
  99                         else {
 100                                 log.warn("Could not proxy " + path);
 101                                 return null;
 102                         }
 103                 } catch (RepositoryException e) {
 104                         throw new SlcException("Cannot proxy " + path, e);
 105                 }
 106         }
 107
 108         /** The JCR path where this file could be found */
 109         public String getNodePath(String path) {
 110                 return RepoConstants.ARTIFACTS_BASE_PATH + path;
 111         }
 112
 113         protected Node importFile(String nodePath, InputStream in) {
 114                 Binary binary = null;
 115                 try {
 116                         Node node = JcrUtils.mkdirs(jcrAdminSession, nodePath,
 117                                         NodeType.NT_FILE, NodeType.NT_FOLDER, false);
 118                         Node content = node.addNode(Node.JCR_CONTENT, NodeType.NT_RESOURCE);
 119                         binary = jcrAdminSession.getValueFactory().createBinary(in);
 120                         content.setProperty(Property.JCR_DATA, binary);
 121                         jcrAdminSession.save();
 122                         return node;
 123                 } catch (RepositoryException e) {
 124                         JcrUtils.discardQuietly(jcrAdminSession);
 125                         throw new SlcException("Cannot initialize Maven proxy", e);
 126                 } finally {
 127                         JcrUtils.closeQuietly(binary);
 128                 }
 129         }
 130
 131         public void setJcrRepository(Repository jcrRepository) {
 132                 this.jcrRepository = jcrRepository;
 133         }
 134
 135         public void setDefaultRepositories(
 136                         List<RemoteRepository> defaultRepositories) {
 137                 this.defaultRepositories = defaultRepositories;
 138         }
 139
 140 }