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

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