import static org.argeo.node.DataModelNamespace.CMS_DATA_MODEL_NAMESPACE;
-import java.io.IOException;
-import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
-import java.io.Writer;
+import java.lang.management.ManagementFactory;
import java.net.URL;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Dictionary;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import java.util.SortedMap;
-import java.util.TreeMap;
import javax.jcr.Repository;
import javax.jcr.Session;
-import javax.naming.InvalidNameException;
-import javax.naming.directory.Attributes;
-import javax.naming.directory.BasicAttributes;
-import javax.naming.ldap.LdapName;
-import javax.naming.ldap.Rdn;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.jackrabbit.commons.cnd.CndImporter;
import org.apache.jackrabbit.core.RepositoryContext;
import org.argeo.cms.CmsException;
-import org.argeo.jcr.ArgeoJcrConstants;
import org.argeo.jcr.JcrUtils;
import org.argeo.node.DataModelNamespace;
import org.argeo.node.NodeConstants;
import org.argeo.node.NodeDeployment;
import org.argeo.node.NodeState;
-import org.argeo.util.naming.AttributesDictionary;
-import org.argeo.util.naming.LdifParser;
-import org.argeo.util.naming.LdifWriter;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
+import org.osgi.framework.Constants;
import org.osgi.framework.FrameworkUtil;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.wiring.BundleCapability;
import org.osgi.framework.wiring.BundleWire;
import org.osgi.framework.wiring.BundleWiring;
-import org.osgi.service.cm.Configuration;
import org.osgi.service.cm.ConfigurationAdmin;
-import org.osgi.service.cm.ConfigurationEvent;
-import org.osgi.service.cm.SynchronousConfigurationListener;
+import org.osgi.service.http.HttpService;
+import org.osgi.service.useradmin.UserAdmin;
import org.osgi.util.tracker.ServiceTracker;
-import org.osgi.util.tracker.ServiceTrackerCustomizer;
-public class CmsDeployment implements NodeDeployment, SynchronousConfigurationListener {
+public class CmsDeployment implements NodeDeployment {
private final Log log = LogFactory.getLog(getClass());
private final BundleContext bc = FrameworkUtil.getBundle(getClass()).getBundleContext();
- private Path deployPath = KernelUtils.getOsgiInstancePath(KernelConstants.DEPLOY_PATH);
- private SortedMap<LdapName, Attributes> deployConfigs = new TreeMap<>();
-
- // private Repository deployedNodeRepository;
+ private DeployConfig deployConfig;
private HomeRepository homeRepository;
private Long availableSince;
- public CmsDeployment() {
- ConfigurationAdmin configurationAdmin = bc.getService(bc.getServiceReference(ConfigurationAdmin.class));
- // FIXME no guarantee this is already available
- NodeState nodeState = bc.getService(bc.getServiceReference(NodeState.class));
- try {
- initDeployConfigs(configurationAdmin, nodeState);
- } catch (IOException e) {
- throw new CmsException("Could not init deploy configs", e);
- }
- bc.registerService(SynchronousConfigurationListener.class, this, null);
-
- new ServiceTracker<>(bc, RepositoryContext.class, new RepositoryContextStc()).open();
- }
-
- private void initDeployConfigs(ConfigurationAdmin configurationAdmin, NodeState nodeState) throws IOException {
- if (!Files.exists(deployPath)) {// first init
- Files.createDirectories(deployPath.getParent());
- Files.createFile(deployPath);
- FirstInitProperties firstInitProperties = new FirstInitProperties();
+ private final boolean cleanState;
+ // Readiness
+ private boolean nodeAvailable = false;
+ private boolean userAdminAvailable = false;
+ private boolean httpExpected = false;
+ private boolean httpAvailable = false;
- Dictionary<String, Object> nodeConfig = firstInitProperties.getNodeRepositoryConfig();
- // node repository is mandatory
- putFactoryDeployConfig(NodeConstants.NODE_REPOS_FACTORY_PID, nodeConfig);
-
- Dictionary<String, Object> webServerConfig = firstInitProperties.getHttpServerConfig();
- if (!webServerConfig.isEmpty())
- putFactoryDeployConfig(KernelConstants.JETTY_FACTORY_PID, webServerConfig);
+ public CmsDeployment() {
+ ServiceReference<NodeState> nodeStateSr = bc.getServiceReference(NodeState.class);
+ if (nodeStateSr == null)
+ throw new CmsException("No node state available");
- saveDeployedConfigs();
- }
+ NodeState nodeState = bc.getService(nodeStateSr);
+ cleanState = nodeState.isClean();
- try (InputStream in = Files.newInputStream(deployPath)) {
- deployConfigs = new LdifParser().read(in);
- }
- if (nodeState.isClean()) {
- for (LdapName dn : deployConfigs.keySet()) {
- Rdn lastRdn = dn.getRdn(dn.size() - 1);
- LdapName prefix = (LdapName) dn.getPrefix(dn.size() - 1);
- if (prefix.toString().equals(NodeConstants.DEPLOY_BASEDN)) {
- if (lastRdn.getType().equals(NodeConstants.CN)) {
- // service
- String pid = lastRdn.getValue().toString();
- Configuration conf = configurationAdmin.getConfiguration(pid);
- AttributesDictionary dico = new AttributesDictionary(deployConfigs.get(dn));
- conf.update(dico);
- } else {
- // service factory definition
- }
- } else {
- // service factory service
- Rdn beforeLastRdn = dn.getRdn(dn.size() - 2);
- assert beforeLastRdn.getType().equals(NodeConstants.OU);
- String factoryPid = beforeLastRdn.getValue().toString();
- Configuration conf = configurationAdmin.createFactoryConfiguration(factoryPid.toString(), null);
- AttributesDictionary dico = new AttributesDictionary(deployConfigs.get(dn));
- conf.update(dico);
- }
- }
- }
- // TODO check consistency if not clean
+ initTrackers();
}
- @Override
- public void configurationEvent(ConfigurationEvent event) {
- try {
- if (ConfigurationEvent.CM_UPDATED == event.getType()) {
- ConfigurationAdmin configurationAdmin = bc.getService(event.getReference());
- Configuration conf = configurationAdmin.getConfiguration(event.getPid(), null);
- LdapName serviceDn = null;
- String factoryPid = conf.getFactoryPid();
- if (factoryPid != null) {
- LdapName serviceFactoryDn = serviceFactoryDn(factoryPid);
- if (deployConfigs.containsKey(serviceFactoryDn)) {
- for (LdapName dn : deployConfigs.keySet()) {
- if (dn.startsWith(serviceFactoryDn)) {
- Rdn lastRdn = dn.getRdn(dn.size() - 1);
- assert lastRdn.getType().equals(NodeConstants.CN);
- Object value = conf.getProperties().get(lastRdn.getType());
- assert value != null;
- if (value.equals(lastRdn.getValue())) {
- serviceDn = dn;
- break;
- }
- }
- }
-
- Object cn = conf.getProperties().get(NodeConstants.CN);
- if (cn == null)
- throw new IllegalArgumentException("Properties must contain cn");
- if (serviceDn == null) {
- putFactoryDeployConfig(factoryPid, conf.getProperties());
- } else {
- Attributes attrs = deployConfigs.get(serviceDn);
- assert attrs != null;
- AttributesDictionary.copy(conf.getProperties(), attrs);
- }
- saveDeployedConfigs();
- if (log.isDebugEnabled())
- log.debug("Updated deploy config " + serviceDn(factoryPid, cn.toString()));
- } else {
- // ignore non config-registered service factories
- }
- } else {
- serviceDn = serviceDn(event.getPid());
- if (deployConfigs.containsKey(serviceDn)) {
- Attributes attrs = deployConfigs.get(serviceDn);
- assert attrs != null;
- AttributesDictionary.copy(conf.getProperties(), attrs);
- saveDeployedConfigs();
- if (log.isDebugEnabled())
- log.debug("Updated deploy config " + serviceDn);
- } else {
- // ignore non config-registered services
- }
- }
+ private void initTrackers() {
+ new PrepareHttpStc().open();
+ new RepositoryContextStc().open();
+ new ServiceTracker<UserAdmin, UserAdmin>(bc, UserAdmin.class, null) {
+ @Override
+ public UserAdmin addingService(ServiceReference<UserAdmin> reference) {
+ userAdminAvailable = true;
+ checkReadiness();
+ return super.addingService(reference);
}
- } catch (Exception e) {
- log.error("Could not handle configuration event", e);
- }
- }
-
- private void putFactoryDeployConfig(String factoryPid, Dictionary<String, Object> props) {
- Object cn = props.get(NodeConstants.CN);
- if (cn == null)
- throw new IllegalArgumentException("cn must be set in properties");
- LdapName serviceFactorydn = serviceFactoryDn(factoryPid);
- if (!deployConfigs.containsKey(serviceFactorydn))
- deployConfigs.put(serviceFactorydn, new BasicAttributes(NodeConstants.OU, factoryPid));
- LdapName serviceDn = serviceDn(factoryPid, cn.toString());
- Attributes attrs = new BasicAttributes();
- AttributesDictionary.copy(props, attrs);
- deployConfigs.put(serviceDn, attrs);
- }
-
- private void putDeployConfig(String servicePid, Dictionary<String, Object> props) {
- LdapName serviceDn = serviceDn(servicePid);
- Attributes attrs = new BasicAttributes(NodeConstants.CN, servicePid);
- AttributesDictionary.copy(props, attrs);
- deployConfigs.put(serviceDn, attrs);
- }
-
- void saveDeployedConfigs() throws IOException {
- try (Writer writer = Files.newBufferedWriter(deployPath)) {
- new LdifWriter(writer).write(deployConfigs);
- }
+ }.open();
+ new ServiceTracker<ConfigurationAdmin, ConfigurationAdmin>(bc, ConfigurationAdmin.class, null) {
+ @Override
+ public ConfigurationAdmin addingService(ServiceReference<ConfigurationAdmin> reference) {
+ ConfigurationAdmin configurationAdmin = bc.getService(reference);
+ deployConfig = new DeployConfig(configurationAdmin, cleanState);
+ httpExpected = deployConfig.getProps(KernelConstants.JETTY_FACTORY_PID, "default") != null;
+ return super.addingService(reference);
+ }
+ }.open();
}
- private LdapName serviceFactoryDn(String factoryPid) {
- try {
- return new LdapName(NodeConstants.OU + "=" + factoryPid + "," + NodeConstants.DEPLOY_BASEDN);
- } catch (InvalidNameException e) {
- throw new IllegalArgumentException("Cannot generate DN from " + factoryPid, e);
- }
+ public void shutdown() {
+ if (deployConfig != null)
+ deployConfig.save();
}
- private LdapName serviceDn(String servicePid) {
- try {
- return new LdapName(NodeConstants.CN + "=" + servicePid + "," + NodeConstants.DEPLOY_BASEDN);
- } catch (InvalidNameException e) {
- throw new IllegalArgumentException("Cannot generate DN from " + servicePid, e);
+ private void checkReadiness() {
+ if (nodeAvailable && userAdminAvailable && (httpExpected ? httpAvailable : true)) {
+ availableSince = System.currentTimeMillis();
+ long jvmUptime = ManagementFactory.getRuntimeMXBean().getUptime();
+ log.info("## ARGEO CMS AVAILABLE in " + (jvmUptime / 1000) + "." + (jvmUptime % 1000) + "s ##");
+ long begin = bc.getService(bc.getServiceReference(NodeState.class)).getAvailableSince();
+ long initDuration = System.currentTimeMillis() - begin;
+ if (log.isTraceEnabled())
+ log.trace("Kernel initialization took " + initDuration + "ms");
+ directorsCut(initDuration);
}
}
- private LdapName serviceDn(String factoryPid, String cn) {
+ final private void directorsCut(long initDuration) {
+ // final long ms = 128l + (long) (Math.random() * 128d);
+ long ms = initDuration / 100;
+ log.info("Spend " + ms + "ms" + " reflecting on the progress brought to mankind" + " by Free Software...");
+ long beginNano = System.nanoTime();
try {
- return (LdapName) serviceFactoryDn(factoryPid).add(new Rdn(NodeConstants.CN, cn));
- } catch (InvalidNameException e) {
- throw new IllegalArgumentException("Cannot generate DN from " + factoryPid + " and " + cn, e);
+ Thread.sleep(ms, 0);
+ } catch (InterruptedException e) {
+ // silent
}
+ long durationNano = System.nanoTime() - beginNano;
+ final double M = 1000d * 1000d;
+ double sleepAccuracy = ((double) durationNano) / (ms * M);
+ if (log.isDebugEnabled())
+ log.debug("Sleep accuracy: " + String.format("%.2f", 100 - (sleepAccuracy * 100 - 100)) + " %");
}
private void prepareNodeRepository(Repository deployedNodeRepository) {
throw new CmsException("Deployment is already available");
}
- availableSince = System.currentTimeMillis();
-
prepareDataModel(KernelUtils.openAdminSession(deployedNodeRepository));
Hashtable<String, String> regProps = new Hashtable<String, String>();
- regProps.put(ArgeoJcrConstants.JCR_REPOSITORY_ALIAS, ArgeoJcrConstants.ALIAS_HOME);
+ regProps.put(NodeConstants.CN, NodeConstants.ALIAS_HOME);
+ regProps.put(NodeConstants.JCR_REPOSITORY_ALIAS, NodeConstants.ALIAS_HOME);
homeRepository = new HomeRepository(deployedNodeRepository);
// register
bc.registerService(Repository.class, homeRepository, regProps);
Set<String> processed = new HashSet<String>();
bundles: for (Bundle bundle : bc.getBundles()) {
BundleWiring wiring = bundle.adapt(BundleWiring.class);
- if (wiring == null) {
- if (log.isTraceEnabled())
- log.error("No wiring for " + bundle.getSymbolicName());
+ if (wiring == null)
continue bundles;
- }
processWiring(adminSession, wiring, processed);
}
} finally {
private void registerCnd(Session adminSession, BundleCapability capability, Set<String> processed) {
Map<String, Object> attrs = capability.getAttributes();
- String name = attrs.get(DataModelNamespace.CAPABILITY_NAME_ATTRIBUTE).toString();
+ String name = (String) attrs.get(DataModelNamespace.CAPABILITY_NAME_ATTRIBUTE);
if (processed.contains(name)) {
if (log.isTraceEnabled())
log.trace("Data model " + name + " has already been processed");
return;
}
- String path = attrs.get(DataModelNamespace.CAPABILITY_CND_ATTRIBUTE).toString();
+ String path = (String) attrs.get(DataModelNamespace.CAPABILITY_CND_ATTRIBUTE);
URL url = capability.getRevision().getBundle().getResource(path);
try (Reader reader = new InputStreamReader(url.openStream())) {
CndImporter.registerNodeTypes(reader, adminSession, true);
throw new CmsException("Cannot import CND " + url, e);
}
- Hashtable<String, Object> properties = new Hashtable<>();
- properties.put(ArgeoJcrConstants.JCR_REPOSITORY_ALIAS, name);
- bc.registerService(Repository.class, adminSession.getRepository(), properties);
- if (log.isDebugEnabled())
- log.debug("Published data model " + name);
+ if (!asBoolean((String) attrs.get(DataModelNamespace.CAPABILITY_ABSTRACT_ATTRIBUTE))) {
+ Hashtable<String, Object> properties = new Hashtable<>();
+ properties.put(NodeConstants.JCR_REPOSITORY_ALIAS, name);
+ properties.put(NodeConstants.CN, name);
+ if (name.equals(NodeConstants.ALIAS_NODE))
+ properties.put(Constants.SERVICE_RANKING, Integer.MAX_VALUE);
+ LocalRepository localRepository = new LocalRepository(adminSession.getRepository(), capability);
+ bc.registerService(Repository.class, localRepository, properties);
+ if (log.isDebugEnabled())
+ log.debug("Published data model " + name);
+ }
}
- // public void setDeployedNodeRepository(Repository deployedNodeRepository)
- // {
- // this.deployedNodeRepository = deployedNodeRepository;
- // }
+ private boolean asBoolean(String value) {
+ if (value == null)
+ return false;
+ switch (value) {
+ case "true":
+ return true;
+ case "false":
+ return false;
+ default:
+ throw new CmsException("Unsupported value for attribute " + DataModelNamespace.CAPABILITY_ABSTRACT_ATTRIBUTE
+ + ": " + value);
+ }
+ }
@Override
- public long getAvailableSince() {
+ public Long getAvailableSince() {
return availableSince;
}
- private class RepositoryContextStc implements ServiceTrackerCustomizer<RepositoryContext, RepositoryContext> {
+ private class RepositoryContextStc extends ServiceTracker<RepositoryContext, RepositoryContext> {
+
+ public RepositoryContextStc() {
+ super(bc, RepositoryContext.class, null);
+ }
@Override
public RepositoryContext addingService(ServiceReference<RepositoryContext> reference) {
RepositoryContext nodeRepo = bc.getService(reference);
Object cn = reference.getProperty(NodeConstants.CN);
- if (cn != null && cn.equals(ArgeoJcrConstants.ALIAS_NODE)) {
+ if (cn != null && cn.equals(NodeConstants.ALIAS_NODE)) {
prepareNodeRepository(nodeRepo.getRepository());
- // nodeDeployment.setDeployedNodeRepository(nodeRepo.getRepository());
- // Dictionary<String, Object> props =
- // LangUtils.init(Constants.SERVICE_PID,
- // NodeConstants.NODE_DEPLOYMENT_PID);
- // props.put(NodeConstants.CN,
- // nodeRepo.getRootNodeId().toString());
- // register
- // bc.registerService(LangUtils.names(NodeDeployment.class,
- // ManagedService.class), nodeDeployment, props);
+ nodeAvailable = true;
+ checkReadiness();
}
-
return nodeRepo;
}
}
+ private class PrepareHttpStc extends ServiceTracker<HttpService, HttpService> {
+ private DataHttp dataHttp;
+ private NodeHttp nodeHttp;
+
+ public PrepareHttpStc() {
+ super(bc, HttpService.class, null);
+ }
+
+ @Override
+ public HttpService addingService(ServiceReference<HttpService> reference) {
+ HttpService httpService = addHttpService(reference);
+ return httpService;
+ }
+
+ @Override
+ public void removedService(ServiceReference<HttpService> reference, HttpService service) {
+ if (dataHttp != null)
+ dataHttp.destroy();
+ dataHttp = null;
+ if (nodeHttp != null)
+ nodeHttp.destroy();
+ nodeHttp = null;
+ }
+
+ private HttpService addHttpService(ServiceReference<HttpService> sr) {
+ HttpService httpService = bc.getService(sr);
+ // TODO find constants
+ Object httpPort = sr.getProperty("http.port");
+ Object httpsPort = sr.getProperty("https.port");
+ dataHttp = new DataHttp(httpService);
+ nodeHttp = new NodeHttp(httpService, bc);
+ log.info(httpPortsMsg(httpPort, httpsPort));
+ httpAvailable = true;
+ checkReadiness();
+ return httpService;
+ }
+
+ private String httpPortsMsg(Object httpPort, Object httpsPort) {
+ return "HTTP " + httpPort + (httpsPort != null ? " - HTTPS " + httpsPort : "");
+ }
+ }
+
}