import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collection;
import java.util.HashSet;
import java.util.Hashtable;
+import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.argeo.api.NodeConstants;
import org.argeo.api.NodeDeployment;
import org.argeo.api.NodeState;
+import org.argeo.api.NodeUtils;
import org.argeo.api.security.CryptoKeyring;
import org.argeo.api.security.Keyring;
import org.argeo.cms.ArgeoNames;
-import org.argeo.cms.CmsException;
import org.argeo.cms.internal.http.CmsRemotingServlet;
import org.argeo.cms.internal.http.CmsWebDavServlet;
import org.argeo.cms.internal.http.HttpUtils;
+import org.argeo.jcr.Jcr;
+import org.argeo.jcr.JcrException;
import org.argeo.jcr.JcrUtils;
+import org.argeo.naming.LdapAttrs;
import org.argeo.osgi.useradmin.UserAdminConf;
import org.argeo.util.LangUtils;
import org.eclipse.equinox.http.jetty.JettyConfigurator;
.listConfigurations("(service.factoryPid=" + NodeConstants.NODE_USER_ADMIN_PID + ")");
isClean = confs == null || confs.length == 0;
} catch (Exception e) {
- throw new CmsException("Cannot analize clean state", e);
+ throw new IllegalStateException("Cannot analyse clean state", e);
}
deployConfig = new DeployConfig(configurationAdmin, dataModels, isClean);
httpExpected = deployConfig.getProps(KernelConstants.JETTY_FACTORY_PID, "default") != null;
loadIpaJaasConfiguration();
}
} catch (Exception e) {
- throw new CmsException("Cannot initialize config", e);
+ throw new IllegalStateException("Cannot initialize config", e);
}
return super.addingService(reference);
}
} catch (Exception e1) {
// silent
}
- throw new CmsException("Cannot add standard system roles", e);
+ throw new IllegalStateException("Cannot add standard system roles", e);
}
}
}
}
- private void prepareNodeRepository(Repository deployedNodeRepository) {
+ private void prepareNodeRepository(Repository deployedNodeRepository, List<String> publishAsLocalRepo) {
if (availableSince != null) {
- throw new CmsException("Deployment is already available");
+ throw new IllegalStateException("Deployment is already available");
}
// home
- prepareDataModel(NodeConstants.NODE_REPOSITORY, deployedNodeRepository);
+ prepareDataModel(NodeConstants.NODE_REPOSITORY, deployedNodeRepository, publishAsLocalRepo);
+
+ // init from repository
+ Collection<ServiceReference<Repository>> initRepositorySr;
+ try {
+ initRepositorySr = bc.getServiceReferences(Repository.class,
+ "(" + NodeConstants.CN + "=" + NodeConstants.NODE_INIT + ")");
+ } catch (InvalidSyntaxException e1) {
+ throw new IllegalArgumentException(e1);
+ }
+ Iterator<ServiceReference<Repository>> it = initRepositorySr.iterator();
+ while (it.hasNext()) {
+ ServiceReference<Repository> sr = it.next();
+ Object labeledUri = sr.getProperties().get(LdapAttrs.labeledURI.name());
+ Repository initRepository = bc.getService(sr);
+ if (log.isDebugEnabled())
+ log.debug("Found init repository " + labeledUri + ", copying it...");
+ initFromRepository(deployedNodeRepository, initRepository);
+ log.info("Node repository initialised from " + labeledUri);
+ }
+ }
+
+ /** Init from a (typically remote) repository. */
+ private void initFromRepository(Repository deployedNodeRepository, Repository initRepository) {
+ Session initSession = null;
+ try {
+ initSession = initRepository.login();
+ workspaces: for (String workspaceName : initSession.getWorkspace().getAccessibleWorkspaceNames()) {
+ if ("security".equals(workspaceName))
+ continue workspaces;
+ Session targetSession = null;
+ Session sourceSession = null;
+ try {
+ try {
+ targetSession = NodeUtils.openDataAdminSession(deployedNodeRepository, workspaceName);
+ } catch (IllegalArgumentException e) {// no such workspace
+ Session adminSession = NodeUtils.openDataAdminSession(deployedNodeRepository, null);
+ try {
+ adminSession.getWorkspace().createWorkspace(workspaceName);
+ } finally {
+ Jcr.logout(adminSession);
+ }
+ targetSession = NodeUtils.openDataAdminSession(deployedNodeRepository, workspaceName);
+ }
+ sourceSession = initRepository.login(workspaceName);
+ JcrUtils.copy(sourceSession.getRootNode(), targetSession.getRootNode());
+ targetSession.save();
+ } finally {
+ Jcr.logout(sourceSession);
+ Jcr.logout(targetSession);
+ }
+ }
+ } catch (RepositoryException e) {
+ throw new JcrException(e);
+ } finally {
+ Jcr.logout(initSession);
+ }
}
private void prepareHomeRepository(RepositoryImpl deployedRepository) {
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));
+ nodeKeyring, LangUtils.dict(Constants.SERVICE_PID, NodeConstants.NODE_KEYRING_PID));
return callbackHandler;
}
}
/** Session is logged out. */
- private void prepareDataModel(String cn, Repository repository) {
+ private void prepareDataModel(String cn, Repository repository, List<String> publishAsLocalRepo) {
Session adminSession = KernelUtils.openAdminSession(repository);
try {
Set<String> processed = new HashSet<String>();
if (wiring == null)
continue bundles;
if (NodeConstants.NODE_REPOSITORY.equals(cn))// process all data models
- processWiring(cn, adminSession, wiring, processed, false);
+ processWiring(cn, adminSession, wiring, processed, false, publishAsLocalRepo);
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, false);
+ processWiring(cn, adminSession, wiring, processed, false, publishAsLocalRepo);
}
}
}
}
private void processWiring(String cn, Session adminSession, BundleWiring wiring, Set<String> processed,
- boolean importListedAbstractModels) {
+ boolean importListedAbstractModels, List<String> publishAsLocalRepo) {
// recursively process requirements first
List<BundleWire> requiredWires = wiring.getRequiredWires(CMS_DATA_MODEL_NAMESPACE);
for (BundleWire wire : requiredWires) {
- processWiring(cn, adminSession, wire.getProviderWiring(), processed, true);
+ processWiring(cn, adminSession, wire.getProviderWiring(), processed, true, publishAsLocalRepo);
}
- List<String> publishAsLocalRepo = new ArrayList<>();
List<BundleCapability> capabilities = wiring.getCapabilities(CMS_DATA_MODEL_NAMESPACE);
capabilities: for (BundleCapability capability : capabilities) {
if (!importListedAbstractModels
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 boolean registerDataModelCapability(String cn, Session adminSession, BundleCapability capability,
if (!dataModel.exists()) {
URL url = capability.getRevision().getBundle().getResource(path);
if (url == null)
- throw new CmsException("No data model '" + name + "' found under path " + path);
+ throw new IllegalArgumentException("No data model '" + name + "' found under path " + 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);
+ log.error("Cannot import CND " + url, e);
}
}
}
try {
tmpDir = Files.createTempDirectory("remoting_" + alias);
} catch (IOException e) {
- throw new CmsException("Cannot create temp directory for remoting servlet", e);
+ throw new RuntimeException("Cannot create temp directory for remoting servlet", e);
}
ip.put(HTTP_WHITEBOARD_SERVLET_INIT_PARAM_PREFIX + CmsRemotingServlet.INIT_PARAM_HOME, tmpDir.toString());
ip.put(HTTP_WHITEBOARD_SERVLET_INIT_PARAM_PREFIX + CmsRemotingServlet.INIT_PARAM_TMP_DIRECTORY,
RepositoryContext repoContext = bc.getService(reference);
String cn = (String) reference.getProperty(NodeConstants.CN);
if (cn != null) {
+ List<String> publishAsLocalRepo = new ArrayList<>();
if (cn.equals(NodeConstants.NODE_REPOSITORY)) {
- prepareNodeRepository(repoContext.getRepository());
+ prepareNodeRepository(repoContext.getRepository(), publishAsLocalRepo);
// TODO separate home repository
prepareHomeRepository(repoContext.getRepository());
registerRepositoryServlets(cn, repoContext.getRepository());
nodeAvailable = true;
checkReadiness();
} else {
- prepareDataModel(cn, repoContext.getRepository());
+ prepareDataModel(cn, repoContext.getRepository(), publishAsLocalRepo);
}
+ // Publish all at once, so that bundles with multiple CNDs are consistent
+ for (String dataModelName : publishAsLocalRepo)
+ publishLocalRepo(dataModelName, repoContext.getRepository());
}
return repoContext;
}
import java.io.IOException;
import java.net.InetAddress;
import java.net.URI;
+import java.net.URISyntaxException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.KeyStore;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Dictionary;
+import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
+import java.util.Map;
+import javax.jcr.Repository;
+import javax.jcr.RepositoryException;
+import javax.jcr.RepositoryFactory;
import javax.security.auth.x500.X500Principal;
import org.apache.commons.io.FileUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.argeo.api.NodeConstants;
-import org.argeo.cms.CmsException;
import org.argeo.cms.internal.http.InternalHttpConstants;
import org.argeo.cms.internal.jcr.RepoConf;
+import org.argeo.jackrabbit.client.ClientDavexRepositoryFactory;
+import org.argeo.jcr.JcrException;
+import org.argeo.naming.LdapAttrs;
import org.argeo.osgi.useradmin.UserAdminConf;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.Constants;
/**
* Interprets framework properties in order to generate the initial deploy
FileUtils.copyInputStreamToFile(InitUtils.class.getResourceAsStream(baseNodeRoleDn + ".ldif"),
nodeRolesFile);
} catch (IOException e) {
- throw new CmsException("Cannot copy demo resource", e);
+ throw new RuntimeException("Cannot copy demo resource", e);
}
// nodeRolesUri = nodeRolesFile.toURI().toString();
}
FileUtils.copyInputStreamToFile(InitUtils.class.getResourceAsStream(baseNodeTokensDn + ".ldif"),
nodeRolesFile);
} catch (IOException e) {
- throw new CmsException("Cannot copy demo resource", e);
+ throw new RuntimeException("Cannot copy demo resource", e);
}
// nodeRolesUri = nodeRolesFile.toURI().toString();
}
FileUtils.copyInputStreamToFile(
InitUtils.class.getResourceAsStream("example-ou=roles,ou=node.ldif"), systemRolesFile);
} catch (IOException e) {
- throw new CmsException("Cannot copy demo resources", e);
+ throw new RuntimeException("Cannot copy demo resources", e);
}
// userAdminUris = businessRolesFile.toURI().toString();
log.warn("## DEV Using dummy base DN " + demoBaseDn);
try {
u = new URI(uri);
if (u.getPath() == null)
- throw new CmsException("URI " + uri + " must have a path in order to determine base DN");
+ throw new IllegalArgumentException(
+ "URI " + uri + " must have a path in order to determine base DN");
if (u.getScheme() == null) {
if (uri.startsWith("/") || uri.startsWith("./") || uri.startsWith("../"))
u = new File(uri).getCanonicalFile().toURI();
// u = KernelUtils.getOsgiInstanceUri(KernelConstants.DIR_NODE + '/' + uri);
u = new URI(uri);
} else
- throw new CmsException("Cannot interpret " + uri + " as an uri");
+ throw new IllegalArgumentException("Cannot interpret " + uri + " as an uri");
} else if (u.getScheme().equals(UserAdminConf.SCHEME_FILE)) {
u = new File(u).getCanonicalFile().toURI();
}
} catch (Exception e) {
- throw new CmsException("Cannot interpret " + uri + " as an uri", e);
+ throw new RuntimeException("Cannot interpret " + uri + " as an uri", e);
}
Dictionary<String, Object> properties = UserAdminConf.uriAsProperties(u.toString());
res.add(properties);
* some files (typically LDIF, etc).
*/
static void prepareFirstInitInstanceArea() {
- String nodeInit = getFrameworkProp(NodeConstants.NODE_INIT);
- if (nodeInit == null)
- nodeInit = "../../init";
- if (nodeInit.startsWith("http")) {
- // remoteFirstInit(nodeInit);
- return;
- }
+ String nodeInits = getFrameworkProp(NodeConstants.NODE_INIT);
+ if (nodeInits == null)
+ nodeInits = "../../init";
- // TODO use java.nio.file
- File initDir;
- if (nodeInit.startsWith("."))
- initDir = KernelUtils.getExecutionDir(nodeInit);
- else
- initDir = new File(nodeInit);
- // TODO also uncompress archives
- if (initDir.exists())
- try {
- FileUtils.copyDirectory(initDir, KernelUtils.getOsgiInstanceDir(), new FileFilter() {
+ for (String nodeInit : nodeInits.split(",")) {
+
+ if (nodeInit.startsWith("http")) {
+ registerRemoteInit(nodeInit);
+ } else {
- @Override
- public boolean accept(File pathname) {
- if (pathname.getName().equals(".svn") || pathname.getName().equals(".git"))
- return false;
- return true;
+ // TODO use java.nio.file
+ File initDir;
+ if (nodeInit.startsWith("."))
+ initDir = KernelUtils.getExecutionDir(nodeInit);
+ else
+ initDir = new File(nodeInit);
+ // TODO also uncompress archives
+ if (initDir.exists())
+ try {
+ FileUtils.copyDirectory(initDir, KernelUtils.getOsgiInstanceDir(), new FileFilter() {
+
+ @Override
+ public boolean accept(File pathname) {
+ if (pathname.getName().equals(".svn") || pathname.getName().equals(".git"))
+ return false;
+ return true;
+ }
+ });
+ log.info("CMS initialized from " + initDir.getCanonicalPath());
+ } catch (IOException e) {
+ throw new RuntimeException("Cannot initialize from " + initDir, e);
}
- });
- log.info("CMS initialized from " + initDir.getCanonicalPath());
- } catch (IOException e) {
- throw new CmsException("Cannot initialize from " + initDir, e);
}
+ }
+ }
+
+ private static void registerRemoteInit(String uri) {
+ try {
+ BundleContext bundleContext = KernelUtils.getBundleContext();
+ Repository repository = createRemoteRepository(new URI(uri));
+ Hashtable<String, Object> properties = new Hashtable<>();
+ properties.put(NodeConstants.CN, NodeConstants.NODE_INIT);
+ properties.put(LdapAttrs.labeledURI.name(), uri);
+ properties.put(Constants.SERVICE_RANKING, -1000);
+ bundleContext.registerService(Repository.class, repository, properties);
+ } catch (RepositoryException e) {
+ throw new JcrException(e);
+ } catch (URISyntaxException e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ private static Repository createRemoteRepository(URI uri) throws RepositoryException {
+ RepositoryFactory repositoryFactory = new ClientDavexRepositoryFactory();
+ Map<String, String> params = new HashMap<String, String>();
+ params.put(ClientDavexRepositoryFactory.JACKRABBIT_DAVEX_URI, uri.toString());
+ // TODO make it configurable
+ params.put(ClientDavexRepositoryFactory.JACKRABBIT_REMOTE_DEFAULT_WORKSPACE, NodeConstants.SYS_WORKSPACE);
+ return repositoryFactory.getRepository(params);
}
private static void createSelfSignedKeyStore(Path keyStorePath, String keyStorePassword, String keyStoreType) {
log.error("Cannot create keystore " + keyStoreFile, e);
}
} else {
- throw new CmsException("Keystore " + keyStorePath + " already exists");
+ throw new IllegalStateException("Keystore " + keyStorePath + " already exists");
}
}
projects / lgpl / argeo-commons.git / commitdiff