org.argeo.cms/src/org/argeo/cms/internal/jcr/RepositoryBuilder.java

   1 package org.argeo.cms.internal.jcr;
   2
   3 import java.io.IOException;
   4 import java.io.InputStream;
   5 import java.net.URI;
   6 import java.net.URISyntaxException;
   7 import java.nio.file.Files;
   8 import java.nio.file.Path;
   9 import java.nio.file.Paths;
  10 import java.util.Dictionary;
  11 import java.util.Enumeration;
  12 import java.util.Properties;
  13 import java.util.UUID;
  14
  15 import javax.jcr.RepositoryException;
  16
  17 import org.apache.commons.logging.Log;
  18 import org.apache.commons.logging.LogFactory;
  19 import org.apache.jackrabbit.core.RepositoryContext;
  20 import org.apache.jackrabbit.core.RepositoryImpl;
  21 import org.apache.jackrabbit.core.cache.CacheManager;
  22 import org.apache.jackrabbit.core.config.RepositoryConfig;
  23 import org.apache.jackrabbit.core.config.RepositoryConfigurationParser;
  24 import org.argeo.cms.CmsException;
  25 import org.argeo.cms.internal.kernel.CmsPaths;
  26 import org.argeo.jcr.ArgeoJcrException;
  27 import org.argeo.node.NodeConstants;
  28 import org.xml.sax.InputSource;
  29
  30 /** Can interpret properties in order to create an actual JCR repository. */
  31 public class RepositoryBuilder {
  32         private final static Log log = LogFactory.getLog(RepositoryBuilder.class);
  33
  34         public RepositoryContext createRepositoryContext(Dictionary<String, ?> properties)
  35                         throws RepositoryException, IOException {
  36                 RepositoryConfig repositoryConfig = createRepositoryConfig(properties);
  37                 RepositoryContext repositoryContext = createJackrabbitRepository(repositoryConfig);
  38                 RepositoryImpl repository = repositoryContext.getRepository();
  39
  40                 // cache
  41                 Object maxCacheMbStr = prop(properties, RepoConf.maxCacheMB);
  42                 if (maxCacheMbStr != null) {
  43                         Integer maxCacheMB = Integer.parseInt(maxCacheMbStr.toString());
  44                         CacheManager cacheManager = repository.getCacheManager();
  45                         cacheManager.setMaxMemory(maxCacheMB * 1024l * 1024l);
  46                         cacheManager.setMaxMemoryPerCache((maxCacheMB / 4) * 1024l * 1024l);
  47                 }
  48
  49                 return repositoryContext;
  50         }
  51
  52         RepositoryConfig createRepositoryConfig(Dictionary<String, ?> properties) throws RepositoryException, IOException {
  53                 JackrabbitType type = JackrabbitType.valueOf(prop(properties, RepoConf.type).toString());
  54                 ClassLoader cl = getClass().getClassLoader();
  55                 final String base = "/org/argeo/cms/internal/jcr";
  56                 try (InputStream in = cl.getResourceAsStream(base + "/repository-" + type.name() + ".xml")) {
  57                         if (in == null)
  58                                 throw new ArgeoJcrException("Repository configuration not found");
  59                         InputSource config = new InputSource(in);
  60                         Properties jackrabbitVars = getConfigurationProperties(type, properties);
  61                         RepositoryConfig repositoryConfig = RepositoryConfig.create(config, jackrabbitVars);
  62                         return repositoryConfig;
  63                 }
  64         }
  65
  66         private Properties getConfigurationProperties(JackrabbitType type, Dictionary<String, ?> properties) {
  67                 Properties props = new Properties();
  68                 for (Enumeration<String> keys = properties.keys(); keys.hasMoreElements();) {
  69                         String key = keys.nextElement();
  70                         props.put(key, properties.get(key));
  71                 }
  72
  73                 // cluster id
  74                 // cf. https://wiki.apache.org/jackrabbit/Clustering
  75                 // TODO deal with multiple repos
  76                 String clusterId = System.getProperty("org.apache.jackrabbit.core.cluster.node_id");
  77                 String clusterIdProp = props.getProperty(RepoConf.clusterId.name());
  78                 if (clusterId != null) {
  79                         if (clusterIdProp != null)
  80                                 throw new CmsException("Cluster id defined as System properties and in deploy config");
  81                         props.put(RepoConf.clusterId.name(), clusterId);
  82                 } else {
  83                         clusterId = clusterIdProp;
  84                 }
  85
  86                 // home
  87                 String homeUri = props.getProperty(RepoConf.labeledUri.name());
  88                 Path homePath;
  89                 if (homeUri == null) {
  90                         String cn = props.getProperty(NodeConstants.CN);
  91                         assert cn != null;
  92                         if (clusterId != null) {
  93                                 homePath = CmsPaths.getRepoDirPath(cn + '/' + clusterId);
  94                         } else {
  95                                 homePath = CmsPaths.getRepoDirPath(cn);
  96                         }
  97                 } else {
  98                         try {
  99                                 URI uri = new URI(homeUri);
 100                                 String host = uri.getHost();
 101                                 if (host == null || host.trim().equals("")) {
 102                                         homePath = Paths.get(uri).toAbsolutePath();
 103                                 } else {
 104                                         // TODO remote at this stage?
 105                                         throw new IllegalArgumentException("Cannot manage repository path for host " + host);
 106                                 }
 107                         } catch (URISyntaxException e) {
 108                                 throw new CmsException("Invalid repository home URI", e);
 109                         }
 110                 }
 111                 // TODO use Jackrabbit API (?)
 112                 Path rootUuidPath = homePath.resolve("repository/meta/rootUUID");
 113                 try {
 114                         if (!Files.exists(rootUuidPath)) {
 115                                 Files.createDirectories(rootUuidPath.getParent());
 116                                 Files.write(rootUuidPath, UUID.randomUUID().toString().getBytes());
 117                         }
 118                         // File homeDir = homePath.toFile();
 119                         // homeDir.mkdirs();
 120                 } catch (IOException e) {
 121                         throw new CmsException("Cannot set up repository  home " + homePath, e);
 122                 }
 123                 // home cannot be overridden
 124                 props.put(RepositoryConfigurationParser.REPOSITORY_HOME_VARIABLE, homePath.toString());
 125
 126                 setProp(props, RepoConf.indexesBase, CmsPaths.getRepoIndexesBase().toString());
 127                 // common
 128                 setProp(props, RepoConf.defaultWorkspace);
 129                 setProp(props, RepoConf.maxPoolSize);
 130                 // Jackrabbit defaults
 131                 setProp(props, RepoConf.bundleCacheMB);
 132                 // See http://wiki.apache.org/jackrabbit/Search
 133                 setProp(props, RepoConf.extractorPoolSize);
 134                 setProp(props, RepoConf.searchCacheSize);
 135                 setProp(props, RepoConf.maxVolatileIndexSize);
 136
 137                 // specific
 138                 String dburl;
 139                 switch (type) {
 140                 case h2:
 141                         dburl = "jdbc:h2:" + homePath.toAbsolutePath() + "/h2/repository";
 142                         setProp(props, RepoConf.dburl, dburl);
 143                         setProp(props, RepoConf.dbuser, "sa");
 144                         setProp(props, RepoConf.dbpassword, "");
 145                         break;
 146                 case postgresql:
 147                 case postgresql_ds:
 148                 case postgresql_cluster:
 149                 case postgresql_cluster_ds:
 150                         dburl = "jdbc:postgresql://localhost/demo";
 151                         setProp(props, RepoConf.dburl, dburl);
 152                         setProp(props, RepoConf.dbuser, "argeo");
 153                         setProp(props, RepoConf.dbpassword, "argeo");
 154                         break;
 155                 case memory:
 156                         break;
 157                 case localfs:
 158                         break;
 159                 default:
 160                         throw new ArgeoJcrException("Unsupported node type " + type);
 161                 }
 162                 return props;
 163         }
 164
 165         private void setProp(Properties props, RepoConf key, String def) {
 166                 Object value = props.get(key.name());
 167                 if (value == null)
 168                         value = def;
 169                 if (value == null)
 170                         value = key.getDefault();
 171                 if (value != null)
 172                         props.put(key.name(), value.toString());
 173         }
 174
 175         private void setProp(Properties props, RepoConf key) {
 176                 setProp(props, key, null);
 177         }
 178
 179         private String prop(Dictionary<String, ?> properties, RepoConf key) {
 180                 Object value = properties.get(key.name());
 181                 if (value == null)
 182                         return key.getDefault() != null ? key.getDefault().toString() : null;
 183                 else
 184                         return value.toString();
 185         }
 186
 187         private RepositoryContext createJackrabbitRepository(RepositoryConfig repositoryConfig) throws RepositoryException {
 188                 ClassLoader currentContextCl = Thread.currentThread().getContextClassLoader();
 189                 Thread.currentThread().setContextClassLoader(RepositoryBuilder.class.getClassLoader());
 190                 try {
 191                         long begin = System.currentTimeMillis();
 192                         //
 193                         // Actual repository creation
 194                         //
 195                         RepositoryContext repositoryContext = RepositoryContext.create(repositoryConfig);
 196
 197                         double duration = ((double) (System.currentTimeMillis() - begin)) / 1000;
 198                         if (log.isDebugEnabled())
 199                                 log.debug(
 200                                                 "Created Jackrabbit repository in " + duration + " s, home: " + repositoryConfig.getHomeDir());
 201
 202                         return repositoryContext;
 203                 } finally {
 204                         Thread.currentThread().setContextClassLoader(currentContextCl);
 205                 }
 206         }
 207
 208 }