import static org.argeo.node.DataModelNamespace.CMS_DATA_MODEL_NAMESPACE;
-import java.io.IOException;
-import java.io.InputStream;
+import java.io.File;
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.ArrayList;
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 javax.security.auth.callback.CallbackHandler;
+import javax.transaction.UserTransaction;
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.apache.jackrabbit.core.RepositoryImpl;
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.argeo.node.security.CryptoKeyring;
+import org.argeo.node.security.Keyring;
+import org.argeo.osgi.useradmin.UserAdminConf;
+import org.argeo.util.LangUtils;
+import org.eclipse.equinox.http.jetty.JettyConfigurator;
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.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.cm.ManagedService;
+import org.osgi.service.useradmin.Group;
+import org.osgi.service.useradmin.Role;
+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 static String LEGACY_JCR_REPOSITORY_ALIAS =
+ // "argeo.jcr.repository.alias";
+
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 DataModels dataModels;
+ 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 final boolean cleanState;
- 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 NodeHttp nodeHttp;
- Dictionary<String, Object> nodeConfig = firstInitProperties.getNodeRepositoryConfig();
- // node repository is mandatory
- putFactoryDeployConfig(NodeConstants.NODE_REPOS_FACTORY_PID, nodeConfig);
+ // Readiness
+ private boolean nodeAvailable = false;
+ private boolean userAdminAvailable = false;
+ private boolean httpExpected = false;
+ private boolean httpAvailable = false;
- 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
+ nodeHttp = new NodeHttp(cleanState);
+ dataModels = new DataModels(bc);
+ 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;
- }
- }
- }
+ private void initTrackers() {
+ ServiceTracker<?, ?> httpSt = new ServiceTracker<NodeHttp, NodeHttp>(bc, NodeHttp.class, null) {
- 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);
+ @Override
+ public NodeHttp addingService(ServiceReference<NodeHttp> reference) {
+ httpAvailable = true;
+ checkReadiness();
+ return super.addingService(reference);
+ }
+ };
+ // httpSt.open();
+ KernelUtils.asyncOpen(httpSt);
+
+ ServiceTracker<?, ?> repoContextSt = new RepositoryContextStc();
+ // repoContextSt.open();
+ KernelUtils.asyncOpen(repoContextSt);
+
+ ServiceTracker<?, ?> userAdminSt = new ServiceTracker<UserAdmin, UserAdmin>(bc, UserAdmin.class, null) {
+ @Override
+ public UserAdmin addingService(ServiceReference<UserAdmin> reference) {
+ UserAdmin userAdmin = super.addingService(reference);
+ addStandardSystemRoles(userAdmin);
+ userAdminAvailable = true;
+ checkReadiness();
+ return userAdmin;
+ }
+ };
+ // userAdminSt.open();
+ KernelUtils.asyncOpen(userAdminSt);
+
+ ServiceTracker<?, ?> confAdminSt = new ServiceTracker<ConfigurationAdmin, ConfigurationAdmin>(bc,
+ ConfigurationAdmin.class, null) {
+ @Override
+ public ConfigurationAdmin addingService(ServiceReference<ConfigurationAdmin> reference) {
+ ConfigurationAdmin configurationAdmin = bc.getService(reference);
+ deployConfig = new DeployConfig(configurationAdmin, dataModels, cleanState);
+ httpExpected = deployConfig.getProps(KernelConstants.JETTY_FACTORY_PID, "default") != null;
+ try {
+ // Configuration[] configs = configurationAdmin
+ // .listConfigurations("(service.factoryPid=" +
+ // NodeConstants.NODE_REPOS_FACTORY_PID + ")");
+ // for (Configuration config : configs) {
+ // Object cn = config.getProperties().get(NodeConstants.CN);
+ // if (log.isDebugEnabled())
+ // log.debug("Standalone repo cn: " + cn);
+ // }
+ Configuration[] configs = configurationAdmin
+ .listConfigurations("(service.factoryPid=" + NodeConstants.NODE_USER_ADMIN_PID + ")");
+
+ boolean hasDomain = false;
+ for (Configuration config : configs) {
+ Object realm = config.getProperties().get(UserAdminConf.realm.name());
+ if (realm != null) {
+ log.debug("Found realm: " + realm);
+ hasDomain = true;
}
- 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
+ if (hasDomain) {
+ loadIpaJaasConfiguration();
}
+ } catch (Exception e) {
+ throw new CmsException("Cannot initialize config", e);
}
+ return super.addingService(reference);
}
+ };
+ // confAdminSt.open();
+ KernelUtils.asyncOpen(confAdminSt);
+ }
+
+ private void addStandardSystemRoles(UserAdmin userAdmin) {
+ // we assume UserTransaction is already available (TODO make it more robust)
+ UserTransaction userTransaction = bc.getService(bc.getServiceReference(UserTransaction.class));
+ try {
+ userTransaction.begin();
+ Role adminRole = userAdmin.getRole(NodeConstants.ROLE_ADMIN);
+ if (adminRole == null) {
+ adminRole = userAdmin.createRole(NodeConstants.ROLE_ADMIN, Role.GROUP);
+ }
+ if (userAdmin.getRole(NodeConstants.ROLE_USER_ADMIN) == null) {
+ Group userAdminRole = (Group) userAdmin.createRole(NodeConstants.ROLE_USER_ADMIN, Role.GROUP);
+ userAdminRole.addMember(adminRole);
+ }
+ userTransaction.commit();
} catch (Exception e) {
- log.error("Could not handle configuration event", e);
+ try {
+ userTransaction.rollback();
+ } catch (Exception e1) {
+ // silent
+ }
+ throw new CmsException("Cannot add standard system roles", 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 loadIpaJaasConfiguration() {
+ if (System.getProperty(KernelConstants.JAAS_CONFIG_PROP) == null) {
+ String jaasConfig = KernelConstants.JAAS_CONFIG_IPA;
+ URL url = getClass().getClassLoader().getResource(jaasConfig);
+ KernelUtils.setJaasConfiguration(url);
+ log.debug("Set IPA JAAS configuration.");
+ }
}
- 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);
- }
+ public void shutdown() {
+ if (nodeHttp != null)
+ nodeHttp.destroy();
- void saveDeployedConfigs() throws IOException {
- try (Writer writer = Files.newBufferedWriter(deployPath)) {
- new LdifWriter(writer).write(deployConfigs);
+ try {
+ JettyConfigurator.stopServer(KernelConstants.DEFAULT_JETTY_SERVER);
+ } catch (Exception e) {
+ log.error("Cannot stop default Jetty server.", e);
}
- }
- 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);
+ if (deployConfig != null) {
+ new Thread(() -> deployConfig.save(), "Save Argeo Deploy Config").start();
}
}
- 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);
+ /**
+ * Checks whether the deployment is available according to expectations, and
+ * mark it as available.
+ */
+ private synchronized void checkReadiness() {
+ if (isAvailable())
+ return;
+ if (nodeAvailable && userAdminAvailable && (httpExpected ? httpAvailable : true)) {
+ String data = KernelUtils.getFrameworkProp(KernelUtils.OSGI_INSTANCE_AREA);
+ String state = KernelUtils.getFrameworkProp(KernelUtils.OSGI_CONFIGURATION_AREA);
+ availableSince = System.currentTimeMillis();
+ long jvmUptime = ManagementFactory.getRuntimeMXBean().getUptime();
+ String jvmUptimeStr = " in " + (jvmUptime / 1000) + "." + (jvmUptime % 1000) + "s";
+ log.info("## ARGEO NODE AVAILABLE" + (log.isDebugEnabled() ? jvmUptimeStr : "") + " ##");
+ if (log.isDebugEnabled()) {
+ log.debug("## state: " + state);
+ if (data != null)
+ log.debug("## data: " + data);
+ }
+ long begin = bc.getService(bc.getServiceReference(NodeState.class)).getAvailableSince();
+ long initDuration = System.currentTimeMillis() - begin;
+ if (log.isTraceEnabled())
+ log.trace("Kernel initialization took " + initDuration + "ms");
+ tributeToFreeSoftware(initDuration);
}
}
- private LdapName serviceDn(String factoryPid, String cn) {
- 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);
+ final private void tributeToFreeSoftware(long initDuration) {
+ if (log.isTraceEnabled()) {
+ long ms = initDuration / 100;
+ log.trace("Spend " + ms + "ms" + " reflecting on the progress brought to mankind" + " by Free Software...");
+ long beginNano = System.nanoTime();
+ try {
+ Thread.sleep(ms, 0);
+ } catch (InterruptedException e) {
+ // silent
+ }
+ long durationNano = System.nanoTime() - beginNano;
+ final double M = 1000d * 1000d;
+ double sleepAccuracy = ((double) durationNano) / (ms * M);
+ log.trace("Sleep accuracy: " + String.format("%.2f", 100 - (sleepAccuracy * 100 - 100)) + " %");
}
}
throw new CmsException("Deployment is already available");
}
- availableSince = System.currentTimeMillis();
+ // home
+ prepareDataModel(NodeConstants.NODE, KernelUtils.openAdminSession(deployedNodeRepository));
+ }
- prepareDataModel(KernelUtils.openAdminSession(deployedNodeRepository));
+ private void prepareHomeRepository(RepositoryImpl deployedRepository) {
Hashtable<String, String> regProps = new Hashtable<String, String>();
- regProps.put(ArgeoJcrConstants.JCR_REPOSITORY_ALIAS, ArgeoJcrConstants.ALIAS_HOME);
- homeRepository = new HomeRepository(deployedNodeRepository);
+ regProps.put(NodeConstants.CN, NodeConstants.HOME);
+ // regProps.put(LEGACY_JCR_REPOSITORY_ALIAS, NodeConstants.HOME);
+ homeRepository = new HomeRepository(deployedRepository, false);
// register
bc.registerService(Repository.class, homeRepository, regProps);
+
+ new ServiceTracker<CallbackHandler, CallbackHandler>(bc, CallbackHandler.class, null) {
+
+ @Override
+ public CallbackHandler addingService(ServiceReference<CallbackHandler> reference) {
+ NodeKeyRing nodeKeyring = new NodeKeyRing(homeRepository);
+ CallbackHandler callbackHandler = bc.getService(reference);
+ nodeKeyring.setDefaultCallbackHandler(callbackHandler);
+ bc.registerService(LangUtils.names(Keyring.class, CryptoKeyring.class, ManagedService.class),
+ nodeKeyring, LangUtils.dico(Constants.SERVICE_PID, NodeConstants.NODE_KEYRING_PID));
+ return callbackHandler;
+ }
+
+ }.open();
}
/** Session is logged out. */
- private void prepareDataModel(Session adminSession) {
+ private void prepareDataModel(String cn, Session adminSession) {
try {
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;
+ if (NodeConstants.NODE.equals(cn))// process all data models
+ processWiring(cn, adminSession, wiring, processed);
+ else {
+ List<BundleCapability> capabilities = wiring.getCapabilities(CMS_DATA_MODEL_NAMESPACE);
+ for (BundleCapability capability : capabilities) {
+ String dataModelName = (String) capability.getAttributes().get(DataModelNamespace.NAME);
+ if (dataModelName.equals(cn))// process only own data model
+ processWiring(cn, adminSession, wiring, processed);
+ }
}
- processWiring(adminSession, wiring, processed);
}
} finally {
JcrUtils.logoutQuietly(adminSession);
}
}
- private void processWiring(Session adminSession, BundleWiring wiring, Set<String> processed) {
+ private void processWiring(String cn, Session adminSession, BundleWiring wiring, Set<String> processed) {
// recursively process requirements first
List<BundleWire> requiredWires = wiring.getRequiredWires(CMS_DATA_MODEL_NAMESPACE);
for (BundleWire wire : requiredWires) {
- processWiring(adminSession, wire.getProviderWiring(), processed);
- // registerCnd(adminSession, wire.getCapability(), processed);
+ processWiring(cn, adminSession, wire.getProviderWiring(), processed);
}
+
+ List<String> publishAsLocalRepo = new ArrayList<>();
List<BundleCapability> capabilities = wiring.getCapabilities(CMS_DATA_MODEL_NAMESPACE);
for (BundleCapability capability : capabilities) {
- registerCnd(adminSession, capability, processed);
+ boolean publish = registerDataModelCapability(cn, adminSession, capability, processed);
+ if (publish)
+ publishAsLocalRepo.add((String) capability.getAttributes().get(DataModelNamespace.NAME));
}
+ // Publish all at once, so that bundles with multiple CNDs are consistent
+ for (String dataModelName : publishAsLocalRepo)
+ publishLocalRepo(dataModelName, adminSession.getRepository());
}
- private void registerCnd(Session adminSession, BundleCapability capability, Set<String> processed) {
+ private boolean registerDataModelCapability(String cn, 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.NAME);
if (processed.contains(name)) {
if (log.isTraceEnabled())
log.trace("Data model " + name + " has already been processed");
- return;
+ return false;
}
- String path = attrs.get(DataModelNamespace.CAPABILITY_CND_ATTRIBUTE).toString();
- URL url = capability.getRevision().getBundle().getResource(path);
- try (Reader reader = new InputStreamReader(url.openStream())) {
- CndImporter.registerNodeTypes(reader, adminSession, true);
- processed.add(name);
- if (log.isDebugEnabled())
- log.debug("Registered CND " + url);
- } catch (Exception e) {
- throw new CmsException("Cannot import CND " + url, e);
+
+ // CND
+ String path = (String) attrs.get(DataModelNamespace.CND);
+ if (path != null) {
+ File dataModel = bc.getBundle().getDataFile("dataModels/" + path);
+ if (!dataModel.exists()) {
+ URL url = capability.getRevision().getBundle().getResource(path);
+ if (url == null)
+ throw new CmsException("No data model '" + name + "' found under path " + path);
+ try (Reader reader = new InputStreamReader(url.openStream())) {
+ CndImporter.registerNodeTypes(reader, adminSession, true);
+ processed.add(name);
+ dataModel.getParentFile().mkdirs();
+ dataModel.createNewFile();
+ if (log.isDebugEnabled())
+ log.debug("Registered CND " + url);
+ } catch (Exception e) {
+ 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 (KernelUtils.asBoolean((String) attrs.get(DataModelNamespace.ABSTRACT)))
+ return false;
+ // Non abstract
+ boolean isStandalone = deployConfig.isStandalone(name);
+ boolean publishLocalRepo;
+ if (isStandalone && name.equals(cn))// includes the node itself
+ publishLocalRepo = true;
+ else if (!isStandalone && cn.equals(NodeConstants.NODE))
+ publishLocalRepo = true;
+ else
+ publishLocalRepo = false;
+
+ return publishLocalRepo;
}
- // public void setDeployedNodeRepository(Repository deployedNodeRepository)
- // {
- // this.deployedNodeRepository = deployedNodeRepository;
- // }
+ private void publishLocalRepo(String dataModelName, Repository repository) {
+ Hashtable<String, Object> properties = new Hashtable<>();
+ // properties.put(LEGACY_JCR_REPOSITORY_ALIAS, name);
+ properties.put(NodeConstants.CN, dataModelName);
+ if (dataModelName.equals(NodeConstants.NODE))
+ properties.put(Constants.SERVICE_RANKING, Integer.MAX_VALUE);
+ LocalRepository localRepository = new LocalRepository(repository, dataModelName);
+ bc.registerService(Repository.class, localRepository, properties);
+ if (log.isTraceEnabled())
+ log.trace("Published data model " + dataModelName);
+ }
@Override
- public long getAvailableSince() {
+ public synchronized Long getAvailableSince() {
return availableSince;
}
- private class RepositoryContextStc implements ServiceTrackerCustomizer<RepositoryContext, RepositoryContext> {
+ public synchronized boolean isAvailable() {
+ return availableSince != null;
+ }
+
+ 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)) {
- 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);
+ RepositoryContext repoContext = bc.getService(reference);
+ String cn = (String) reference.getProperty(NodeConstants.CN);
+ if (cn != null) {
+ if (cn.equals(NodeConstants.NODE)) {
+ prepareNodeRepository(repoContext.getRepository());
+ // TODO separate home repository
+ prepareHomeRepository(repoContext.getRepository());
+ nodeAvailable = true;
+ checkReadiness();
+ } else {
+ prepareDataModel(cn, KernelUtils.openAdminSession(repoContext.getRepository()));
+ }
}
-
- return nodeRepo;
+ return repoContext;
}
@Override
projects / lgpl / argeo-commons.git / blobdiff