Import-Package:\
-org.argeo.api,\
javax.jcr.nodetype,\
+org.apache.commons.logging,\
*
\ No newline at end of file
import javax.servlet.http.HttpServletResponse;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
/** Serialisable wrapper of a {@link Throwable}. */
public class CmsExceptionsChain {
- public final static Log log = LogFactory.getLog(CmsExceptionsChain.class);
+ public final static CmsLog log = CmsLog.getLog(CmsExceptionsChain.class);
private List<SystemException> exceptions = new ArrayList<>();
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsAuth;
import org.argeo.api.cms.CmsSessionId;
import org.argeo.cms.auth.RemoteAuthCallback;
import org.argeo.cms.auth.RemoteAuthCallbackHandler;
ServletHttpRequest request = new ServletHttpRequest(req);
ServletHttpResponse response = new ServletHttpResponse(resp);
try {
- lc = new LoginContext(NodeConstants.LOGIN_CONTEXT_USER, new RemoteAuthCallbackHandler(request, response) {
+ lc = new LoginContext(CmsAuth.LOGIN_CONTEXT_USER, new RemoteAuthCallbackHandler(request, response) {
public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {
for (Callback callback : callbacks) {
if (callback instanceof NameCallback && username != null)
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsAuth;
import org.argeo.api.cms.CmsSessionId;
import org.argeo.cms.auth.CurrentUser;
import org.argeo.cms.auth.RemoteAuthCallback;
ServletHttpResponse httpResponse = new ServletHttpResponse(response);
LoginContext lc = null;
try {
- lc = new LoginContext(NodeConstants.LOGIN_CONTEXT_USER,
+ lc = new LoginContext(CmsAuth.LOGIN_CONTEXT_USER,
new RemoteAuthCallbackHandler(httpRequest, httpResponse) {
public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {
for (Callback callback : callbacks) {
package org.argeo.cms.integration;
-import static org.argeo.api.NodeConstants.LOGIN_CONTEXT_USER;
-
import java.io.IOException;
import java.security.AccessControlContext;
import java.security.PrivilegedAction;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
+import org.argeo.api.cms.CmsAuth;
import org.argeo.cms.auth.RemoteAuthCallbackHandler;
import org.argeo.cms.auth.RemoteAuthUtils;
import org.argeo.cms.servlet.ServletHttpRequest;
if ((pathInfo != null && (servletPath + pathInfo).equals(loginPage)) || servletPath.contentEquals(loginServlet))
return true;
try {
- lc = new LoginContext(LOGIN_CONTEXT_USER, new RemoteAuthCallbackHandler(request, response));
+ lc = new LoginContext(CmsAuth.LOGIN_CONTEXT_USER, new RemoteAuthCallbackHandler(request, response));
lc.login();
} catch (LoginException e) {
lc = processUnauthorized(req, resp);
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsAuth;
import org.argeo.cms.CmsUserManager;
import org.argeo.cms.auth.RemoteAuthCallback;
import org.argeo.cms.auth.RemoteAuthCallbackHandler;
import org.argeo.cms.servlet.ServletHttpRequest;
import org.argeo.cms.servlet.ServletHttpResponse;
-import org.argeo.naming.NamingUtils;
+import org.argeo.util.naming.NamingUtils;
import org.osgi.service.useradmin.Authorization;
import com.fasterxml.jackson.core.JsonGenerator;
ServletHttpResponse response = new ServletHttpResponse(resp);
LoginContext lc = null;
try {
- lc = new LoginContext(NodeConstants.LOGIN_CONTEXT_USER, new RemoteAuthCallbackHandler(request, response) {
+ lc = new LoginContext(CmsAuth.LOGIN_CONTEXT_USER, new RemoteAuthCallbackHandler(request, response) {
public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {
for (Callback callback : callbacks) {
if (callback instanceof RemoteAuthCallback) {
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
import org.apache.jackrabbit.api.JackrabbitNode;
import org.apache.jackrabbit.api.JackrabbitValue;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.osgi.service.http.context.ServletContextHelper;
/** Access a JCR repository via web services. */
public class JcrReadServlet extends HttpServlet {
private static final long serialVersionUID = 6536175260540484539L;
- private final static Log log = LogFactory.getLog(JcrReadServlet.class);
+ private final static CmsLog log = CmsLog.getLog(JcrReadServlet.class);
protected final static String ACCEPT_HTTP_HEADER = "Accept";
protected final static String CONTENT_DISPOSITION_HTTP_HEADER = "Content-Disposition";
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
/** Access a JCR repository via web services. */
public class JcrWriteServlet extends JcrReadServlet {
private static final long serialVersionUID = 17272653843085492L;
- private final static Log log = LogFactory.getLog(JcrWriteServlet.class);
+ private final static CmsLog log = CmsLog.getLog(JcrWriteServlet.class);
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
import javax.websocket.server.ServerEndpointConfig;
import javax.websocket.server.ServerEndpointConfig.Configurator;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsAuth;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.auth.RemoteAuthCallbackHandler;
import org.argeo.cms.auth.RemoteAuthSession;
import org.argeo.cms.servlet.ServletHttpSession;
public class CmsWebSocketConfigurator extends Configurator {
public final static String WEBSOCKET_SUBJECT = "org.argeo.cms.websocket.subject";
- private final static Log log = LogFactory.getLog(CmsWebSocketConfigurator.class);
+ private final static CmsLog log = CmsLog.getLog(CmsWebSocketConfigurator.class);
final static String HEADER_WWW_AUTHENTICATE = "WWW-Authenticate";
@Override
rejectResponse(response, null);
}
try {
- LoginContext lc = new LoginContext(NodeConstants.LOGIN_CONTEXT_USER,
+ LoginContext lc = new LoginContext(CmsAuth.LOGIN_CONTEXT_USER,
new RemoteAuthCallbackHandler(httpSession));
lc.login();
if (log.isDebugEnabled())
import org.apache.commons.exec.Executor;
import org.apache.commons.exec.PumpStreamHandler;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
import org.apache.commons.vfs2.FileContent;
import org.apache.commons.vfs2.FileObject;
+import org.argeo.api.cms.CmsLog;
/**
* Runs an OS command and save its standard output as a file. Typically used for
* MySQL or OpenLDAP dumps.
*/
public class OsCallBackup extends AbstractAtomicBackup {
- private final static Log log = LogFactory.getLog(OsCallBackup.class);
+ private final static CmsLog log = CmsLog.getLog(OsCallBackup.class);
private String command;
private Map<String, String> variables = new HashMap<String, String>();
import java.util.SortedMap;
import java.util.TreeMap;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
import org.apache.commons.vfs2.FileObject;
import org.apache.commons.vfs2.FileSystemManager;
import org.apache.commons.vfs2.FileSystemOptions;
import org.apache.commons.vfs2.Selectors;
+import org.argeo.api.cms.CmsLog;
/** Simple backup purge which keeps backups only for a given number of days */
public class SimpleBackupPurge implements BackupPurge {
- private final static Log log = LogFactory.getLog(SimpleBackupPurge.class);
+ private final static CmsLog log = CmsLog.getLog(SimpleBackupPurge.class);
private Integer daysKept = 30;
import java.util.List;
import java.util.Map;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
import org.apache.commons.vfs2.FileObject;
import org.apache.commons.vfs2.FileSystemException;
import org.apache.commons.vfs2.FileSystemManager;
import org.apache.commons.vfs2.Selectors;
import org.apache.commons.vfs2.UserAuthenticator;
import org.apache.commons.vfs2.impl.DefaultFileSystemConfigBuilder;
+import org.argeo.api.cms.CmsLog;
import org.argeo.util.LangUtils;
/**
* remote and local data based on certain criteria.
*/
public class SystemBackup implements Runnable {
- private final static Log log = LogFactory.getLog(SystemBackup.class);
+ private final static CmsLog log = CmsLog.getLog(SystemBackup.class);
private FileSystemManager fileSystemManager;
private UserAuthenticator userAuthenticator = null;
import java.util.Scanner;
import java.util.Set;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
import org.apache.sshd.client.SshClient;
import org.apache.sshd.client.channel.ClientChannel;
import org.apache.sshd.client.channel.ClientChannelEvent;
import org.apache.sshd.client.subsystem.sftp.fs.SftpFileSystemProvider;
import org.apache.sshd.common.util.io.NoCloseInputStream;
import org.apache.sshd.common.util.io.NoCloseOutputStream;
+import org.argeo.api.cms.CmsLog;
@SuppressWarnings("restriction")
abstract class AbstractSsh {
- private final static Log log = LogFactory.getLog(AbstractSsh.class);
+ private final static CmsLog log = CmsLog.getLog(AbstractSsh.class);
private static SshClient sshClient;
private static SftpFileSystemProvider sftpFileSystemProvider;
import java.util.Scanner;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
import org.apache.sshd.agent.SshAgent;
import org.apache.sshd.agent.SshAgentFactory;
import org.apache.sshd.agent.local.LocalAgentFactory;
import org.apache.sshd.client.session.ClientSession;
import org.apache.sshd.client.subsystem.sftp.fs.SftpFileSystem;
import org.apache.sshd.client.subsystem.sftp.fs.SftpFileSystemProvider;
+import org.argeo.api.cms.CmsLog;
public class SshSync {
- private final static Log log = LogFactory.getLog(SshSync.class);
+ private final static CmsLog log = CmsLog.getLog(SshSync.class);
public static void main(String[] args) {
<classpathentry kind="con"
path="org.eclipse.pde.core.requiredPlugins" />
<classpathentry kind="con"
- path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8" />
+ path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11" />
<classpathentry kind="output" path="bin" />
</classpath>
\r
<reference id="userAdmin" interface="org.osgi.service.useradmin.UserAdmin" />\r
<reference id="userTransaction" interface="org.argeo.osgi.transaction.WorkTransaction" />\r
- <reference id="keyring" interface="org.argeo.api.security.CryptoKeyring" />\r
+ <reference id="keyring" interface="org.argeo.cms.security.CryptoKeyring" />\r
</beans:beans>\r
org.argeo.cms.ui.workbench.commands,\
org.argeo.eclipse.ui.specific,\
org.argeo.eclipse.spring,\
-org.argeo.api,\
*
import javax.security.auth.login.LoginContext;
import javax.security.auth.login.LoginException;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsAuth;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.CmsException;
import org.eclipse.rap.rwt.RWT;
import org.eclipse.rap.rwt.application.EntryPoint;
* unauthenticated access.
*/
public class AnonymousEntryPoint implements EntryPoint {
- private final static Log log = LogFactory.getLog(AnonymousEntryPoint.class);
+ private final static CmsLog log = CmsLog.getLog(AnonymousEntryPoint.class);
/**
* How many seconds to wait before invalidating the session if the user has
final LoginContext loginContext;
try {
- loginContext = new LoginContext(NodeConstants.LOGIN_CONTEXT_ANONYMOUS,
+ loginContext = new LoginContext(CmsAuth.LOGIN_CONTEXT_ANONYMOUS,
subject);
loginContext.login();
} catch (LoginException e1) {
import javax.security.auth.login.LoginException;
import javax.servlet.http.HttpServletRequest;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsAuth;
import org.argeo.api.cms.CmsImageManager;
+import org.argeo.api.cms.CmsLog;
import org.argeo.api.cms.CmsView;
import org.argeo.api.cms.UxContext;
import org.argeo.cms.CmsException;
import org.argeo.cms.swt.SimpleSwtUxContext;
import org.argeo.cms.swt.auth.CmsLogin;
import org.argeo.cms.swt.auth.CmsLoginShell;
-import org.argeo.eclipse.ui.specific.UiContext;
import org.eclipse.rap.rwt.RWT;
import org.eclipse.rap.rwt.application.EntryPoint;
import org.eclipse.swt.events.SelectionListener;
public class LoginEntryPoint implements EntryPoint, CmsView {
protected final static String HEADER_WWW_AUTHENTICATE = "WWW-Authenticate";
protected final static String HEADER_AUTHORIZATION = "Authorization";
- private final static Log log = LogFactory.getLog(LoginEntryPoint.class);
+ private final static CmsLog log = CmsLog.getLog(LoginEntryPoint.class);
private LoginContext loginContext;
private UxContext uxContext = null;
private String uid;
CmsSwtUtils.registerCmsView(loginShell.getShell(), this);
try {
// try pre-auth
- loginContext = new LoginContext(NodeConstants.LOGIN_CONTEXT_USER, loginShell);
+ loginContext = new LoginContext(CmsAuth.LOGIN_CONTEXT_USER, loginShell);
loginContext.login();
} catch (LoginException e) {
loginShell.createUi();
/** Eclipse rap specific action bar advisor */
public class RapActionBarAdvisor extends ActionBarAdvisor {
private final static String ID_BASE = SecureRapActivator.ID;
- // private final static Log log = LogFactory
+ // private final static CmsLog log = CmsLog
// .getLog(SecureActionBarAdvisor.class);
/** Null means anonymous */
import javax.security.auth.Subject;
import javax.security.auth.x500.X500Principal;
-import org.argeo.cms.CmsMsg;
import org.argeo.cms.auth.CurrentUser;
-import org.argeo.cms.ui.util.CmsUiUtils;
import org.eclipse.rap.rwt.RWT;
import org.eclipse.rap.rwt.client.service.JavaScriptExecutor;
-import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionListener;
-import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.PlatformUI;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-import org.argeo.cms.CmsMsg;
import org.argeo.cms.auth.CurrentUser;
-import org.argeo.cms.ui.util.CmsUiUtils;
import org.eclipse.rap.rwt.RWT;
import org.eclipse.rap.rwt.client.service.JavaScriptExecutor;
-import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionListener;
-import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.PlatformUI;
<classpathentry kind="con"
path="org.eclipse.pde.core.requiredPlugins" />
<classpathentry kind="con"
- path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8" />
+ path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11" />
<classpathentry kind="output" path="bin" />
</classpath>
\r
<!-- JCR -->\r
<reference id="repositoryFactory" interface="javax.jcr.RepositoryFactory" />\r
- <reference id="keyring" interface="org.argeo.api.security.CryptoKeyring" />\r
+ <reference id="keyring" interface="org.argeo.cms.security.CryptoKeyring" />\r
<list id="repositories" interface="javax.jcr.Repository"\r
cardinality="0..N">\r
<listener ref="repositoryRegister" bind-method="register"\r
<reference id="nodeRepository" interface="javax.jcr.Repository"\r
filter="(cn=ego)" />\r
\r
- <reference id="nodeInstance" interface="org.argeo.api.NodeInstance" />\r
+ <reference id="nodeInstance" interface="org.argeo.api.cms.CmsData" />\r
\r
<reference id="nodeFileSystemProvider" interface="java.nio.file.spi.FileSystemProvider"\r
filter="(service.pid=org.argeo.api.fsProvider)" />\r
<reference id="userTransaction" interface="org.argeo.osgi.transaction.WorkTransaction" />\r
\r
\r
- <reference id="secureLogger" interface="org.argeo.api.ArgeoLogger"\r
- cardinality="0..1" />\r
<reference id="defaultCallbackHandler" interface="javax.security.auth.callback.CallbackHandler" />\r
\r
</beans:beans>\r
import javax.security.auth.login.LoginContext;
import javax.security.auth.login.LoginException;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsAuth;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.CmsException;
/** Provides base method for executing code with system authorization. */
abstract class AbstractSystemExecution {
- private final static Log log = LogFactory.getLog(AbstractSystemExecution.class);
+ private final static CmsLog log = CmsLog.getLog(AbstractSystemExecution.class);
private final Subject subject = new Subject();
/** Authenticate the calling thread */
ClassLoader origClassLoader = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
try {
- LoginContext lc = new LoginContext(NodeConstants.LOGIN_CONTEXT_DATA_ADMIN, subject);
+ LoginContext lc = new LoginContext(CmsAuth.LOGIN_CONTEXT_DATA_ADMIN, subject);
lc.login();
} catch (LoginException e) {
throw new CmsException("Cannot login as system", e);
ClassLoader origClassLoader = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
try {
- LoginContext lc = new LoginContext(NodeConstants.LOGIN_CONTEXT_DATA_ADMIN, subject);
+ LoginContext lc = new LoginContext(CmsAuth.LOGIN_CONTEXT_DATA_ADMIN, subject);
lc.logout();
} catch (LoginException e) {
throw new CmsException("Cannot logout as system", e);
import javax.naming.InvalidNameException;
import javax.naming.ldap.LdapName;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.CmsException;
import org.argeo.osgi.transaction.WorkTransaction;
import org.osgi.service.useradmin.Role;
* is already registered.
*/
public class SimpleRoleRegistration implements Runnable {
- private final static Log log = LogFactory.getLog(SimpleRoleRegistration.class);
+ private final static CmsLog log = CmsLog.getLog(SimpleRoleRegistration.class);
private String role;
private List<String> roles = new ArrayList<String>();
package org.argeo.cms.spring.osgi;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
* {@link BundleContext}.
*/
public class OsgiModuleLabel {
- private final static Log log = LogFactory.getLog(OsgiModuleLabel.class);
+ private final static CmsLog log = CmsLog.getLog(OsgiModuleLabel.class);
private Bundle bundle;
import javax.security.auth.callback.NameCallback;
import javax.security.auth.callback.PasswordCallback;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jface.dialogs.IDialogConstants;
public abstract class AbstractLoginDialog extends TrayDialog implements CallbackHandler {
private static final long serialVersionUID = -8046708963512717709L;
- private final static Log log = LogFactory.getLog(AbstractLoginDialog.class);
+ private final static CmsLog log = CmsLog.getLog(AbstractLoginDialog.class);
private Thread modalContextThread = null;
boolean processCallbacks = false;
import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.callback.UnsupportedCallbackException;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.CmsException;
import org.eclipse.core.runtime.ILogListener;
import org.eclipse.core.runtime.IStatus;
/** The activator class controls the plug-in life cycle */
public class WorkbenchUiPlugin extends AbstractUIPlugin implements ILogListener {
- private final static Log log = LogFactory.getLog(WorkbenchUiPlugin.class);
+ private final static CmsLog log = CmsLog.getLog(WorkbenchUiPlugin.class);
// The plug-in ID
public final static String PLUGIN_ID = "org.argeo.cms.ui.workbench"; //$NON-NLS-1$
}
public void logging(IStatus status, String plugin) {
- Log pluginLog = LogFactory.getLog(plugin);
+ CmsLog pluginLog = CmsLog.getLog(plugin);
Integer severity = status.getSeverity();
if (severity == IStatus.ERROR)
pluginLog.error(status.getMessage(), status.getException());
import javax.security.auth.Subject;
import javax.security.auth.x500.X500Principal;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.api.security.CryptoKeyring;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.CmsException;
+import org.argeo.cms.security.CryptoKeyring;
import org.argeo.eclipse.ui.dialogs.ErrorFeedback;
import org.argeo.osgi.transaction.WorkTransaction;
import org.eclipse.core.commands.AbstractHandler;
/** Open the change password dialog */
public class OpenChangePasswordDialog extends AbstractHandler {
- private final static Log log = LogFactory.getLog(OpenChangePasswordDialog.class);
+ private final static CmsLog log = CmsLog.getLog(OpenChangePasswordDialog.class);
private UserAdmin userAdmin;
private WorkTransaction userTransaction;
private CryptoKeyring keyring = null;
import javax.jcr.Session;
import javax.jcr.SimpleCredentials;
-import org.argeo.api.NodeConstants;
-import org.argeo.api.security.Keyring;
+import org.argeo.api.cms.CmsConstants;
import org.argeo.cms.ArgeoNames;
import org.argeo.cms.ArgeoTypes;
import org.argeo.cms.jcr.CmsJcrUtils;
+import org.argeo.cms.security.Keyring;
import org.argeo.cms.ui.workbench.internal.WorkbenchConstants;
import org.argeo.cms.ui.workbench.util.CommandUtils;
import org.argeo.eclipse.ui.EclipseUiException;
String checkedUriStr = checkedUri.toString();
Hashtable<String, String> params = new Hashtable<String, String>();
- params.put(NodeConstants.LABELED_URI, checkedUriStr);
+ params.put(CmsConstants.LABELED_URI, checkedUriStr);
Repository repository = repositoryFactory.getRepository(params);
if (username.getText().trim().equals("")) {// anonymous
// FIXME make it more generic
/** Compute an approximative size for the selected node(s) */
public class GetNodeSize extends AbstractHandler {
- // private final static Log log = LogFactory.getLog(GetNodeSize.class);
+ // private final static CmsLog log = CmsLog.getLog(GetNodeSize.class);
public final static String ID = WorkbenchUiPlugin.PLUGIN_ID + ".getNodeSize";
/** Upload local file(s) under the currently selected node */
public class UploadFiles extends AbstractHandler {
- // private final static Log log = LogFactory.getLog(ImportFileSystem.class);
+ // private final static CmsLog log = CmsLog.getLog(ImportFileSystem.class);
public Object execute(ExecutionEvent event) throws ExecutionException {
import javax.jcr.query.Row;
import javax.jcr.query.RowIterator;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.eclipse.ui.EclipseUiException;
import org.argeo.eclipse.ui.GenericTableComparator;
import org.eclipse.core.runtime.IProgressMonitor;
/** Executes any JCR query. */
public abstract class AbstractJcrQueryEditor extends EditorPart {
- private final static Log log = LogFactory.getLog(AbstractJcrQueryEditor.class);
+ private final static CmsLog log = CmsLog.getLog(AbstractJcrQueryEditor.class);
protected String initialQuery;
protected String initialQueryType;
/** List all children of the current node */
public class ChildNodesPage extends FormPage {
- // private final static Log log = LogFactory.getLog(ChildNodesPage.class);
+ // private final static CmsLog log = CmsLog.getLog(ChildNodesPage.class);
private Node currentNode;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;
-import org.argeo.cms.ui.CmsConstants;
+import org.argeo.cms.ui.CmsUiConstants;
import org.argeo.cms.ui.workbench.internal.WorkbenchConstants;
import org.argeo.eclipse.ui.EclipseUiException;
import org.argeo.jcr.JcrUtils;
*/
public class GenericNodePage extends FormPage implements WorkbenchConstants {
- // private final static Log log = LogFactory.getLog(GenericNodePage.class);
+ // private final static CmsLog log = CmsLog.getLog(GenericNodePage.class);
// local constants
private final static String JCR_PROPERTY_NAME = "jcr:name";
// Utils
- protected DateFormat timeFormatter = new SimpleDateFormat(CmsConstants.DATE_TIME_FORMAT);
+ protected DateFormat timeFormatter = new SimpleDateFormat(CmsUiConstants.DATE_TIME_FORMAT);
// Main business Objects
private Node currentNode;
import javax.jcr.version.VersionIterator;
import javax.jcr.version.VersionManager;
-import org.argeo.cms.ui.CmsConstants;
+import org.argeo.cms.ui.CmsUiConstants;
import org.argeo.cms.ui.jcr.FullVersioningTreeContentProvider;
import org.argeo.cms.ui.jcr.JcrDClickListener;
import org.argeo.cms.ui.jcr.VersionLabelProvider;
* enable browsing
*/
public class NodeVersionHistoryPage extends FormPage implements WorkbenchConstants {
- // private final static Log log = LogFactory
+ // private final static CmsLog log = CmsLog
// .getLog(NodeVersionHistoryPage.class);
// Utils
- protected DateFormat timeFormatter = new SimpleDateFormat(CmsConstants.DATE_TIME_FORMAT);
+ protected DateFormat timeFormatter = new SimpleDateFormat(CmsUiConstants.DATE_TIME_FORMAT);
// business objects
private Node currentNode;
/** Manage transaction and part refresh while updating the security model */
public class PartStateChanged implements IPartListener, IStartup {
- // private final static Log log = LogFactory.getLog(PartStateChanged.class);
+ // private final static CmsLog log = CmsLog.getLog(PartStateChanged.class);
// private IContextActivation contextActivation;
@Override
import java.util.List;
import java.util.Map;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsConstants;
import org.argeo.cms.CmsException;
import org.argeo.osgi.transaction.WorkTransaction;
import org.argeo.osgi.useradmin.UserAdminConf;
if (onlyWritable && "true".equals(readOnly))
continue;
- if (baseDn.equalsIgnoreCase(NodeConstants.ROLES_BASEDN))
+ if (baseDn.equalsIgnoreCase(CmsConstants.ROLES_BASEDN))
continue;
dns.put(baseDn, uri);
}
import org.argeo.cms.ui.workbench.internal.useradmin.UserAdminWrapper;
import org.argeo.eclipse.ui.EclipseUiUtils;
import org.argeo.eclipse.ui.dialogs.ErrorFeedback;
-import org.argeo.naming.LdapAttrs;
import org.argeo.osgi.useradmin.UserAdminConf;
+import org.argeo.util.naming.LdapAttrs;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.argeo.cms.auth.UserAdminUtils;
import org.argeo.eclipse.ui.EclipseUiUtils;
import org.argeo.eclipse.ui.dialogs.ErrorFeedback;
-import org.argeo.naming.LdapAttrs;
import org.argeo.osgi.useradmin.UserAdminConf;
+import org.argeo.util.naming.LdapAttrs;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
/** Open a wizard that enables creation of a new user. */
public class NewUser extends AbstractHandler {
- // private final static Log log = LogFactory.getLog(NewUser.class);
+ // private final static CmsLog log = CmsLog.getLog(NewUser.class);
public final static String ID = WorkbenchUiPlugin.PLUGIN_ID + ".newUser";
/* DEPENDENCY INJECTION */
package org.argeo.cms.ui.workbench.internal.useradmin.parts;
-import static org.argeo.api.NodeInstance.WORKGROUP;
+import static org.argeo.api.cms.CmsData.WORKGROUP;
import static org.argeo.cms.auth.UserAdminUtils.setProperty;
-import static org.argeo.naming.LdapAttrs.businessCategory;
-import static org.argeo.naming.LdapAttrs.description;
+import static org.argeo.util.naming.LdapAttrs.businessCategory;
+import static org.argeo.util.naming.LdapAttrs.description;
import java.util.ArrayList;
import java.util.Iterator;
import javax.naming.InvalidNameException;
import javax.naming.ldap.LdapName;
-import org.argeo.api.NodeInstance;
+import org.argeo.api.cms.CmsData;
import org.argeo.cms.ArgeoNames;
import org.argeo.cms.CmsException;
import org.argeo.cms.auth.UserAdminUtils;
import org.argeo.eclipse.ui.EclipseUiUtils;
import org.argeo.eclipse.ui.parts.LdifUsersTable;
import org.argeo.jcr.JcrUtils;
-import org.argeo.naming.LdapAttrs;
import org.argeo.osgi.transaction.WorkTransaction;
+import org.argeo.util.naming.LdapAttrs;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.dialogs.MessageDialog;
final static String ID = "GroupEditor.mainPage";
private final UserEditor editor;
- private final NodeInstance nodeInstance;
+ private final CmsData nodeInstance;
private final UserAdminWrapper userAdminWrapper;
private final Session session;
public GroupMainPage(FormEditor editor, UserAdminWrapper userAdminWrapper, Repository repository,
- NodeInstance nodeInstance) {
+ CmsData nodeInstance) {
super(editor, ID, "Main");
try {
session = repository.login();
import java.util.ArrayList;
import java.util.List;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsConstants;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.ArgeoNames;
import org.argeo.cms.CmsException;
import org.argeo.cms.auth.CurrentUser;
import org.argeo.eclipse.ui.ColumnDefinition;
import org.argeo.eclipse.ui.EclipseUiUtils;
import org.argeo.eclipse.ui.parts.LdifUsersTable;
-import org.argeo.naming.LdapAttrs;
-import org.argeo.naming.LdapObjs;
+import org.argeo.util.naming.LdapAttrs;
+import org.argeo.util.naming.LdapObjs;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
/** List all groups with filter */
public class GroupsView extends ViewPart implements ArgeoNames {
- private final static Log log = LogFactory.getLog(GroupsView.class);
+ private final static CmsLog log = CmsLog.getLog(GroupsView.class);
public final static String ID = WorkbenchUiPlugin.PLUGIN_ID + ".groupsView";
/* DEPENDENCY INJECTION */
public MyUserTableViewer(Composite parent, int style) {
super(parent, style);
- showSystemRoles = CurrentUser.isInRole(NodeConstants.ROLE_ADMIN);
+ showSystemRoles = CurrentUser.isInRole(CmsConstants.ROLE_ADMIN);
}
protected void populateStaticFilters(Composite staticFilterCmp) {
staticFilterCmp.setLayout(new GridLayout());
final Button showSystemRoleBtn = new Button(staticFilterCmp, SWT.CHECK);
showSystemRoleBtn.setText("Show system roles");
- showSystemRoles = CurrentUser.isInRole(NodeConstants.ROLE_ADMIN);
+ showSystemRoles = CurrentUser.isInRole(CmsConstants.ROLE_ADMIN);
showSystemRoleBtn.setSelection(showSystemRoles);
showSystemRoleBtn.addSelectionListener(new SelectionAdapter() {
builder.append("(&(").append(LdapAttrs.objectClass.name()).append("=")
.append(LdapObjs.groupOfNames.name()).append(")");
if (!showSystemRoles)
- builder.append("(!(").append(LdapAttrs.DN).append("=*").append(NodeConstants.ROLES_BASEDN)
+ builder.append("(!(").append(LdapAttrs.DN).append("=*").append(CmsConstants.ROLES_BASEDN)
.append("))");
builder.append("(|");
builder.append(tmpBuilder.toString());
if (!showSystemRoles)
builder.append("(&(").append(LdapAttrs.objectClass.name()).append("=")
.append(LdapObjs.groupOfNames.name()).append(")(!(").append(LdapAttrs.DN).append("=*")
- .append(NodeConstants.ROLES_BASEDN).append(")))");
+ .append(CmsConstants.ROLES_BASEDN).append(")))");
else
builder.append("(").append(LdapAttrs.objectClass.name()).append("=")
.append(LdapObjs.groupOfNames.name()).append(")");
import java.util.List;
import java.util.Map;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsConstants;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.CmsException;
import org.argeo.cms.auth.CurrentUser;
import org.argeo.cms.auth.UserAdminUtils;
import org.argeo.eclipse.ui.ColumnDefinition;
import org.argeo.eclipse.ui.EclipseUiUtils;
import org.argeo.eclipse.ui.parts.LdifUsersTable;
-import org.argeo.naming.LdapAttrs;
-import org.argeo.naming.LdapObjs;
import org.argeo.osgi.transaction.WorkTransaction;
+import org.argeo.util.naming.LdapAttrs;
+import org.argeo.util.naming.LdapObjs;
import org.eclipse.jface.dialogs.IPageChangeProvider;
import org.eclipse.jface.dialogs.IPageChangedListener;
import org.eclipse.jface.dialogs.MessageDialog;
/** Wizard to update users */
public class UserBatchUpdateWizard extends Wizard {
- private final static Log log = LogFactory.getLog(UserBatchUpdateWizard.class);
+ private final static CmsLog log = CmsLog.getLog(UserBatchUpdateWizard.class);
private UserAdminWrapper userAdminWrapper;
// pages
columnDefs.add(new ColumnDefinition(new DomainNameLP(), "Domain", 200));
// Only show technical DN to admin
- if (CurrentUser.isInRole(NodeConstants.ROLE_ADMIN))
+ if (CurrentUser.isInRole(CmsConstants.ROLE_ADMIN))
columnDefs.add(new ColumnDefinition(new UserNameLP(), "Distinguished Name", 300));
userTableCmp = new ChooseUserTableViewer(pageCmp, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
columnDefs.add(new ColumnDefinition(new MailLP(), "E-mail", 150));
columnDefs.add(new ColumnDefinition(new DomainNameLP(), "Domain", 200));
// Only show technical DN to admin
- if (CurrentUser.isInRole(NodeConstants.ROLE_ADMIN))
+ if (CurrentUser.isInRole(CmsConstants.ROLE_ADMIN))
columnDefs.add(new ColumnDefinition(new UserNameLP(), "Distinguished Name", 300));
userTableCmp = new ChosenUsersTableViewer(pageCmp, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
userTableCmp.setLayoutData(EclipseUiUtils.fillAll());
import javax.jcr.Repository;
-import org.argeo.api.NodeInstance;
+import org.argeo.api.cms.CmsData;
import org.argeo.cms.CmsException;
import org.argeo.cms.ui.workbench.WorkbenchUiPlugin;
import org.argeo.cms.ui.workbench.internal.useradmin.UiUserAdminListener;
import org.argeo.cms.ui.workbench.internal.useradmin.UserAdminWrapper;
+import org.argeo.util.naming.LdapAttrs;
import org.argeo.cms.auth.UserAdminUtils;
-import org.argeo.naming.LdapAttrs;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
private Repository repository;
private UserAdminWrapper userAdminWrapper;
private UserAdmin userAdmin;
- private NodeInstance nodeInstance;
+ private CmsData nodeInstance;
// Context
private User user;
this.repository = repository;
}
- public void setNodeInstance(NodeInstance nodeInstance) {
+ public void setNodeInstance(CmsData nodeInstance) {
this.nodeInstance = nodeInstance;
}
package org.argeo.cms.ui.workbench.internal.useradmin.parts;
import static org.argeo.cms.auth.UserAdminUtils.getProperty;
-import static org.argeo.naming.LdapAttrs.cn;
-import static org.argeo.naming.LdapAttrs.givenName;
-import static org.argeo.naming.LdapAttrs.mail;
-import static org.argeo.naming.LdapAttrs.sn;
-import static org.argeo.naming.LdapAttrs.uid;
+import static org.argeo.util.naming.LdapAttrs.cn;
+import static org.argeo.util.naming.LdapAttrs.givenName;
+import static org.argeo.util.naming.LdapAttrs.mail;
+import static org.argeo.util.naming.LdapAttrs.sn;
+import static org.argeo.util.naming.LdapAttrs.uid;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsConstants;
import org.argeo.cms.ArgeoNames;
import org.argeo.cms.auth.CurrentUser;
import org.argeo.cms.ui.workbench.CmsWorkbenchStyles;
import org.argeo.eclipse.ui.ColumnDefinition;
import org.argeo.eclipse.ui.EclipseUiUtils;
import org.argeo.eclipse.ui.parts.LdifUsersTable;
-import org.argeo.naming.LdapAttrs;
+import org.argeo.util.naming.LdapAttrs;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.dialogs.MessageDialog;
staticFilterCmp.setLayout(new GridLayout());
showSystemRoleBtn = new Button(staticFilterCmp, SWT.CHECK);
showSystemRoleBtn.setText("Show system roles");
- boolean showSysRole = CurrentUser.isInRole(NodeConstants.ROLE_ADMIN);
+ boolean showSysRole = CurrentUser.isInRole(CmsConstants.ROLE_ADMIN);
showSystemRoleBtn.setSelection(showSysRole);
userFilter.setShowSystemRole(showSysRole);
showSystemRoleBtn.addSelectionListener(new SelectionAdapter() {
import java.util.ArrayList;
import java.util.List;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsConstants;
import org.argeo.cms.ArgeoNames;
import org.argeo.cms.CmsException;
import org.argeo.cms.auth.CurrentUser;
import org.argeo.eclipse.ui.ColumnDefinition;
import org.argeo.eclipse.ui.EclipseUiUtils;
import org.argeo.eclipse.ui.parts.LdifUsersTable;
-import org.argeo.naming.LdapAttrs;
-import org.argeo.naming.LdapObjs;
+import org.argeo.util.naming.LdapAttrs;
+import org.argeo.util.naming.LdapObjs;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
/** List all users with filter - based on Ldif userAdmin */
public class UsersView extends ViewPart implements ArgeoNames {
- // private final static Log log = LogFactory.getLog(UsersView.class);
+ // private final static CmsLog log = CmsLog.getLog(UsersView.class);
public final static String ID = WorkbenchUiPlugin.PLUGIN_ID + ".usersView";
columnDefs.add(new ColumnDefinition(new MailLP(), "E-mail", 150));
columnDefs.add(new ColumnDefinition(new DomainNameLP(), "Domain", 200));
// Only show technical DN to admin
- if (CurrentUser.isInRole(NodeConstants.ROLE_ADMIN))
+ if (CurrentUser.isInRole(CmsConstants.ROLE_ADMIN))
columnDefs.add(new ColumnDefinition(new UserNameLP(),
"Distinguished Name", 300));
package org.argeo.cms.ui.workbench.internal.useradmin.providers;
import org.argeo.cms.auth.UserAdminUtils;
-import org.argeo.naming.LdapAttrs;
+import org.argeo.util.naming.LdapAttrs;
import org.osgi.service.useradmin.User;
/** Simply declare a label provider that returns the common name of a user */
package org.argeo.cms.ui.workbench.internal.useradmin.providers;
import org.argeo.cms.auth.UserAdminUtils;
-import org.argeo.naming.LdapAttrs;
+import org.argeo.util.naming.LdapAttrs;
import org.osgi.service.useradmin.User;
/** Simply declare a label provider that returns the Primary Mail of a user */
package org.argeo.cms.ui.workbench.internal.useradmin.providers;
import org.argeo.cms.ui.workbench.internal.useradmin.SecurityAdminImages;
-import org.argeo.api.NodeConstants;
-import org.argeo.api.NodeInstance;
+import org.argeo.util.naming.LdapAttrs;
+import org.argeo.api.cms.CmsData;
+import org.argeo.api.cms.CmsConstants;
import org.argeo.cms.auth.UserAdminUtils;
-import org.argeo.naming.LdapAttrs;
import org.eclipse.swt.graphics.Image;
import org.osgi.service.useradmin.Role;
import org.osgi.service.useradmin.User;
public Image getImage(Object element) {
User user = (User) element;
String dn = user.getName();
- if (dn.endsWith(NodeConstants.ROLES_BASEDN))
+ if (dn.endsWith(CmsConstants.ROLES_BASEDN))
return SecurityAdminImages.ICON_ROLE;
else if (user.getType() == Role.GROUP) {
String businessCategory = UserAdminUtils.getProperty(user, LdapAttrs.businessCategory);
- if (businessCategory != null && businessCategory.equals(NodeInstance.WORKGROUP))
+ if (businessCategory != null && businessCategory.equals(CmsData.WORKGROUP))
return SecurityAdminImages.ICON_WORKGROUP;
return SecurityAdminImages.ICON_GROUP;
} else
import static org.argeo.eclipse.ui.EclipseUiUtils.notEmpty;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsConstants;
import org.argeo.cms.auth.UserAdminUtils;
-import org.argeo.naming.LdapAttrs;
+import org.argeo.util.naming.LdapAttrs;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.osgi.service.useradmin.User;
@Override
public boolean select(Viewer viewer, Object parentElement, Object element) {
User user = (User) element;
- if (!showSystemRole && user.getName().matches(".*(" + NodeConstants.ROLES_BASEDN + ")"))
+ if (!showSystemRole && user.getName().matches(".*(" + CmsConstants.ROLES_BASEDN + ")"))
// UserAdminUtils.getProperty(user, LdifName.dn.name())
// .toLowerCase().endsWith(AuthConstants.ROLES_BASEDN))
return false;
import java.util.HashMap;
import java.util.Map;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.CmsException;
import org.argeo.cms.ui.workbench.WorkbenchUiPlugin;
import org.argeo.osgi.transaction.WorkTransaction;
/** Observe and notify UI on UserTransaction state changes */
public class UserTransactionProvider extends AbstractSourceProvider {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(UserTransactionProvider.class);
public final static String TRANSACTION_STATE = WorkbenchUiPlugin.PLUGIN_ID
import javax.jcr.observation.EventListener;
import javax.jcr.observation.ObservationManager;
-import org.argeo.api.NodeConstants;
-import org.argeo.api.security.Keyring;
+import org.argeo.api.cms.CmsConstants;
+import org.argeo.cms.security.Keyring;
import org.argeo.cms.ui.jcr.DefaultRepositoryRegister;
import org.argeo.cms.ui.jcr.JcrBrowserUtils;
import org.argeo.cms.ui.jcr.JcrDClickListener;
top.setLayout(gl);
try {
- this.userSession = this.nodeRepository.login(NodeConstants.HOME_WORKSPACE);
+ this.userSession = this.nodeRepository.login(CmsConstants.HOME_WORKSPACE);
} catch (RepositoryException e) {
throw new EclipseUiException("Cannot open user session", e);
}
package org.argeo.cms.ui.workbench.legacy.rap;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.rap.rwt.RWT;
* </p>
*/
public class OpenFile extends AbstractHandler {
- private final static Log log = LogFactory.getLog(OpenFile.class);
+ private final static CmsLog log = CmsLog.getLog(OpenFile.class);
public final static String ID = SingleSourcingConstants.OPEN_FILE_CMD_ID;
public final static String PARAM_FILE_NAME = SingleSourcingConstants.PARAM_FILE_NAME;
import java.util.ArrayList;
-import org.argeo.api.ArgeoLogger;
+import org.argeo.cms.ArgeoLogger;
import org.argeo.cms.ui.workbench.WorkbenchUiPlugin;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.viewers.LabelProvider;
import java.util.LinkedList;
import java.util.List;
-import org.argeo.api.ArgeoLogListener;
+import org.argeo.cms.ArgeoLogListener;
import org.eclipse.jface.viewers.ILazyContentProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import java.util.ArrayList;
-import org.argeo.api.ArgeoLogListener;
-import org.argeo.api.ArgeoLogger;
+import org.argeo.cms.ArgeoLogListener;
+import org.argeo.cms.ArgeoLogger;
import org.argeo.cms.ui.workbench.WorkbenchUiPlugin;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.viewers.LabelProvider;
\r
import static java.text.MessageFormat.format;\r
\r
-import org.apache.commons.logging.Log;\r
-import org.apache.commons.logging.LogFactory;\r
+import org.argeo.api.cms.CmsLog;\r
import org.eclipse.core.runtime.Platform;\r
import org.osgi.framework.Bundle;\r
import org.osgi.framework.BundleContext;\r
\r
/** Tracks Spring application context published as services. */\r
class ApplicationContextTracker {\r
- private final static Log log = LogFactory\r
+ private final static CmsLog log = CmsLog\r
.getLog(ApplicationContextTracker.class);\r
\r
private static final String FILTER = "(&(objectClass=org.springframework.context.ApplicationContext)" //$NON-NLS-1$\r
package org.argeo.eclipse.spring;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.eclipse.ui.EclipseUiException;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
/** Allows to declare Eclipse commands as Spring beans */
public class SpringCommandHandler implements IHandler {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(SpringCommandHandler.class);
public void addHandlerListener(IHandlerListener handlerListener) {
<classpath>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>>>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11"/>>>
<classpathentry kind="output" path="target/classes"/>
</classpath>
+++ /dev/null
-#Thu Apr 14 17:49:18 CEST 2011
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.compliance=1.5
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.5
<reference id="repositoryFactory"\r
interface="javax.jcr.RepositoryFactory" />\r
<reference id="keyring"\r
- interface="org.argeo.api.security.CryptoKeyring" />\r
+ interface="org.argeo.cms.security.CryptoKeyring" />\r
</beans:beans>\r
org.argeo.eclipse.spring,\
org.argeo.slc.repo.core,\
org.argeo.cms.ui.util,\
+org.argeo.api.cms,\
*
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="output" path="target/classes"/>
</classpath>
+++ /dev/null
-#Wed Dec 08 08:27:02 CET 2010
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.compliance=1.5
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.5
+++ /dev/null
-#Wed Dec 08 08:27:02 CET 2010
-eclipse.preferences.version=1
-pluginProject.extensions=false
-resolve.requirebundle=false
filter="(cn=java)" />\r
\r
<reference id="repositoryFactory" interface="javax.jcr.RepositoryFactory" />\r
- <reference id="keyring" interface="org.argeo.api.security.CryptoKeyring" />\r
+ <reference id="keyring" interface="org.argeo.cms.security.CryptoKeyring" />\r
\r
<reference id="nodeRepository" interface="javax.jcr.Repository"\r
filter="(cn=ego)" />\r
javax.jcr.nodetype,\
javax.jcr.security,\
aQute.lib.*;resolution:=optional,\
+org.springframework.beans.factory,\
org.osgi.*;version=0.0.0,\
-org.argeo.api,\
*
\ No newline at end of file
import javax.jcr.Session;
import javax.jcr.security.Privilege;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.ui.workbench.util.PrivilegedJob;
import org.argeo.eclipse.ui.jcr.EclipseJcrMonitor;
import org.argeo.jcr.JcrMonitor;
* JavaRepoManager.
*/
public class CopyLocalJavaWorkspace extends AbstractHandler {
- private static final Log log = LogFactory
+ private static final CmsLog log = CmsLog
.getLog(CopyLocalJavaWorkspace.class);
public final static String ID = DistPlugin.PLUGIN_ID + ".copyLocalJavaWorkspace";
import javax.jcr.Session;
import javax.jcr.security.Privilege;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.api.security.Keyring;
+import org.argeo.api.cms.CmsLog;
+import org.argeo.cms.security.Keyring;
import org.argeo.cms.ui.workbench.util.PrivilegedJob;
import org.argeo.eclipse.ui.jcr.EclipseJcrMonitor;
import org.argeo.jcr.JcrMonitor;
/** Create a copy of the chosen workspace in a remote repository */
public class CopyWorkspace extends AbstractHandler {
- private static final Log log = LogFactory.getLog(CopyWorkspace.class);
+ private static final CmsLog log = CmsLog.getLog(CopyWorkspace.class);
public final static String ID = DistPlugin.PLUGIN_ID + ".copyWorkspace";
public final static String DEFAULT_LABEL = "Duplicate...";
package org.argeo.slc.client.ui.dist.commands;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.eclipse.ui.dialogs.ErrorFeedback;
import org.argeo.slc.client.ui.dist.DistPlugin;
import org.argeo.slc.client.ui.dist.utils.CommandHelpers;
/** Create a new empty workspace in the default local java repository */
public class CreateLocalJavaWorkspace extends AbstractHandler {
- private static final Log log = LogFactory
+ private static final CmsLog log = CmsLog
.getLog(CreateLocalJavaWorkspace.class);
// Exposes commands meta-info
import javax.jcr.Session;
import javax.jcr.security.Privilege;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.api.security.Keyring;
+import org.argeo.api.cms.CmsLog;
+import org.argeo.cms.security.Keyring;
import org.argeo.eclipse.ui.dialogs.ErrorFeedback;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcConstants;
/** Create a new empty workspace in a remote repository */
public class CreateWorkspace extends AbstractHandler {
- private static final Log log = LogFactory.getLog(CreateWorkspace.class);
+ private static final CmsLog log = CmsLog.getLog(CreateWorkspace.class);
// Exposes commands meta-info
public final static String ID = DistPlugin.PLUGIN_ID + ".createWorkspace";
/** Delete chosen artifacts from the current workspace */
public class DeleteArtifacts extends AbstractHandler {
- // private static final Log log = LogFactory.getLog(DeleteWorkspace.class);
+ // private static final CmsLog log = CmsLog.getLog(DeleteWorkspace.class);
public final static String ID = DistPlugin.PLUGIN_ID + ".deleteArtifacts";
public final static String DEFAULT_LABEL = "Delete selected items";
import javax.jcr.Session;
import javax.jcr.nodetype.NodeType;
-import org.argeo.api.security.Keyring;
+import org.argeo.cms.security.Keyring;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.client.ui.dist.DistPlugin;
* {@code NodeType.NT_UNSTRUCTURED}
*/
public class DeleteWorkspace extends AbstractHandler {
- // private static final Log log = LogFactory.getLog(DeleteWorkspace.class);
+ // private static final CmsLog log = CmsLog.getLog(DeleteWorkspace.class);
public final static String ID = DistPlugin.PLUGIN_ID + ".deleteWorkspace";
public final static String DEFAULT_LABEL = "Clear";
import javax.jcr.RepositoryFactory;
import javax.jcr.Session;
-import org.argeo.api.security.Keyring;
+import org.argeo.cms.security.Keyring;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.client.ui.dist.DistPlugin;
* definition of the fetch process parameters
*/
public class Fetch extends AbstractHandler {
- // private final static Log log = LogFactory.getLog(Fetch.class);
+ // private final static CmsLog log = CmsLog.getLog(Fetch.class);
public final static String ID = DistPlugin.PLUGIN_ID + ".fetch";
public final static String DEFAULT_LABEL = "Fetch...";
import javax.jcr.query.Query;
import javax.jcr.query.QueryResult;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.api.security.Keyring;
+import org.argeo.api.cms.CmsLog;
+import org.argeo.cms.security.Keyring;
import org.argeo.eclipse.ui.jcr.EclipseJcrMonitor;
import org.argeo.jcr.JcrMonitor;
import org.argeo.jcr.JcrUtils;
/** Merge two workspaces */
public class MergeWorkspaces extends AbstractHandler {
- private final static Log log = LogFactory.getLog(MergeWorkspaces.class);
+ private final static CmsLog log = CmsLog.getLog(MergeWorkspaces.class);
public final static String ID = DistPlugin.PLUGIN_ID + ".mergeWorkspaces";
public final static String DEFAULT_LABEL = "Merge";
import javax.jcr.query.QueryResult;
import javax.jcr.util.TraversingItemVisitor;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.api.security.Keyring;
+import org.argeo.api.cms.CmsLog;
+import org.argeo.cms.security.Keyring;
import org.argeo.eclipse.ui.jcr.EclipseJcrMonitor;
import org.argeo.jcr.JcrMonitor;
import org.argeo.jcr.JcrUtils;
/** Legacy - Make sure than Maven and OSGi metadata are consistent */
public class NormalizeDistribution extends AbstractHandler implements SlcNames {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(NormalizeDistribution.class);
public final static String ID = DistPlugin.PLUGIN_ID
import javax.jcr.query.QueryResult;
import javax.jcr.util.TraversingItemVisitor;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.api.security.Keyring;
+import org.argeo.api.cms.CmsLog;
+import org.argeo.cms.security.Keyring;
import org.argeo.eclipse.ui.jcr.EclipseJcrMonitor;
import org.argeo.jcr.JcrMonitor;
import org.argeo.jcr.JcrUtils;
* must sometimes be triggered manually
*/
public class NormalizeWorkspace extends AbstractHandler implements SlcNames {
- private final static Log log = LogFactory.getLog(NormalizeWorkspace.class);
+ private final static CmsLog log = CmsLog.getLog(NormalizeWorkspace.class);
public final static String ID = DistPlugin.PLUGIN_ID + ".normalizeWorkspace";
public final static ImageDescriptor DEFAULT_ICON = DistPlugin.getImageDescriptor("icons/normalize.gif");
/** Open a {@code GenerateBinariesWizard} wizard for the selected node */
public class OpenGenerateBinariesWizard extends AbstractHandler {
- // private static final Log log = LogFactory.getLog(DeleteWorkspace.class);
+ // private static final CmsLog log = CmsLog.getLog(DeleteWorkspace.class);
public final static String ID = DistPlugin.PLUGIN_ID
+ ".openGenerateBinariesWizard";
import javax.jcr.Session;
import javax.jcr.security.Privilege;
-import org.argeo.api.NodeConstants;
-import org.argeo.api.security.Keyring;
+import org.argeo.api.cms.CmsConstants;
+import org.argeo.cms.security.Keyring;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcConstants;
import org.argeo.slc.SlcException;
/** Publish the current workspace by giving READ_ONLY rights to anonymous */
public class PublishWorkspace extends AbstractHandler {
- // private static final Log log = LogFactory.getLog(PublishWorkspace.class);
+ // private static final CmsLog log = CmsLog.getLog(PublishWorkspace.class);
public final static String ID = DistPlugin.PLUGIN_ID + ".publishWorkspace";
public final static String DEFAULT_LABEL = "Make Public";
Session session = null;
try {
- nodeSession = nodeRepository.login(NodeConstants.HOME_WORKSPACE);
+ nodeSession = nodeRepository.login(CmsConstants.HOME_WORKSPACE);
Node repoNode = nodeSession.getNode(targetRepoPath);
Repository repository = RepoUtils.getRepository(repositoryFactory,
keyring, repoNode);
import javax.jcr.Repository;
import javax.jcr.RepositoryFactory;
-import org.argeo.api.security.Keyring;
import org.argeo.cms.ArgeoNames;
+import org.argeo.cms.security.Keyring;
import org.argeo.slc.SlcNames;
import org.argeo.slc.client.ui.dist.DistPlugin;
import org.argeo.slc.client.ui.dist.utils.CommandHelpers;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.eclipse.ui.dialogs.ErrorFeedback;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
/** <b>UNDER DEVELOPMENT</b>. Download and prepare an OSGi runtime */
public class RunInOsgi extends AbstractHandler implements SlcNames {
- private final static Log log = LogFactory.getLog(RunInOsgi.class);
+ private final static CmsLog log = CmsLog.getLog(RunInOsgi.class);
public final static String ID = DistPlugin.PLUGIN_ID + ".runInOsgi";
public final static String DEFAULT_LABEL = "Run in OSGi";
import javax.jcr.RepositoryException;
import javax.jcr.Session;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsConstants;
import org.argeo.cms.ArgeoTypes;
import org.argeo.cms.ui.workbench.util.CommandUtils;
import org.argeo.jcr.JcrUtils;
* the node Repository. It does not affect the repository instance
*/
public class UnregisterRemoteRepo extends AbstractHandler {
- // private static final Log log = LogFactory
+ // private static final CmsLog log = CmsLog
// .getLog(UnregisterRemoteRepo.class);
public final static String ID = DistPlugin.PLUGIN_ID + ".unregisterRemoteRepo";
return null;
try {
- session = nodeRepository.login(NodeConstants.HOME_WORKSPACE);
+ session = nodeRepository.login(CmsConstants.HOME_WORKSPACE);
Node rNode = session.getNode(repoPath);
if (rNode.isNodeType(ArgeoTypes.ARGEO_REMOTE_REPOSITORY)) {
import javax.jcr.RepositoryFactory;
import javax.jcr.Session;
-import org.argeo.api.security.Keyring;
+import org.argeo.cms.security.Keyring;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.repo.RepoUtils;
import javax.jcr.Session;
import javax.jcr.nodetype.NodeType;
-import org.argeo.api.NodeConstants;
-import org.argeo.api.security.Keyring;
+import org.argeo.api.cms.CmsConstants;
import org.argeo.cms.ArgeoNames;
import org.argeo.cms.ArgeoTypes;
import org.argeo.cms.jcr.CmsJcrUtils;
+import org.argeo.cms.security.Keyring;
import org.argeo.eclipse.ui.TreeParent;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
try {
if (nodeSession != null)
dispose();
- nodeSession = nodeRepository.login(NodeConstants.HOME_WORKSPACE);
+ nodeSession = nodeRepository.login(CmsConstants.HOME_WORKSPACE);
String reposPath = CmsJcrUtils.getUserHome(nodeSession).getPath() + RepoConstants.REPOSITORIES_BASE_PATH;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.SlcNames;
import org.argeo.slc.build.License;
/** Show details for a given bundle. */
public class BundleDetailPage extends FormPage implements SlcNames {
- private final static Log log = LogFactory.getLog(BundleDetailPage.class);
+ private final static CmsLog log = CmsLog.getLog(BundleDetailPage.class);
final static String PAGE_ID = "BundleDetailPage";
*/
public class DistWkspBrowserPage extends FormPage implements DistConstants,
RepoConstants {
- // private final static Log log = LogFactory
+ // private final static CmsLog log = CmsLog
// .getLog(ArtifactsBrowserPage.class);
final static String PAGE_ID = "artifactsBrowserPage";
/** Show all bundles contained in a given workspace as filter-able table */
public class DistWkspSearchPage extends FormPage implements SlcNames {
- // final private static Log log = LogFactory
+ // final private static CmsLog log = CmsLog
// .getLog(DistributionOverviewPage.class);
final static String PAGE_ID = "distributionOverviewPage";
import javax.jcr.RepositoryFactory;
import javax.jcr.Session;
-import org.argeo.api.security.Keyring;
+import org.argeo.cms.security.Keyring;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.SlcNames;
import javax.jcr.query.qom.Selector;
import javax.jcr.query.qom.StaticOperand;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.ui.workbench.util.CommandUtils;
import org.argeo.eclipse.ui.EclipseUiUtils;
import org.argeo.jcr.JcrUtils;
public class ModularDistVersionOverviewPage extends FormPage implements
SlcNames {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(ModularDistVersionOverviewPage.class);
final static String PAGE_ID = "ModularDistVersionOverviewPage";
import javax.jcr.RepositoryFactory;
import javax.jcr.Session;
-import org.argeo.api.NodeConstants;
-import org.argeo.api.security.Keyring;
+import org.argeo.api.cms.CmsConstants;
import org.argeo.cms.ArgeoNames;
import org.argeo.cms.jcr.CmsJcrUtils;
+import org.argeo.cms.security.Keyring;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.repo.RepoConstants;
* home Node or just an URI and a label if user is anonymous
*/
public class RepoElem extends DistParentElem {
- // private final static Log log = LogFactory.getLog(RepoElem.class);
+ // private final static CmsLog log = CmsLog.getLog(RepoElem.class);
private RepositoryFactory repositoryFactory;
private Keyring keyring;
try {
// FIXME make it more generic
- String defaultWorkspace = NodeConstants.SYS_WORKSPACE;
+ String defaultWorkspace = CmsConstants.SYS_WORKSPACE;
defaultSession = repository.login(credentials, defaultWorkspace);
refreshChildren();
} catch (RepositoryException e) {
protected Session repositoryLogin(String workspaceName) {
try {
if (workspaceName == null)
- workspaceName = NodeConstants.SYS_WORKSPACE;// FIXME make it more generic
+ workspaceName = CmsConstants.SYS_WORKSPACE;// FIXME make it more generic
return repository.login(credentials, workspaceName);
} catch (RepositoryException e) {
throw new SlcException("Cannot login repository " + label + " with credential " + credentials, e);
*/
public class ArtifactsTableConfigurer implements SlcNames, SlcTypes,
DistConstants {
- // private final static Log log = LogFactory
+ // private final static CmsLog log = CmsLog
// .getLog(ArtifactsTableConfigurer.class);
// Used in the comparator to be able to retrieve the value from a row
// knowing the corresponding column index.
import javax.jcr.Value;
import javax.jcr.ValueFormatException;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.eclipse.ui.GenericTableComparator;
import org.argeo.slc.SlcException;
import org.eclipse.jface.viewers.Viewer;
public class DistNodeViewerComparator extends GenericTableComparator {
private static final long serialVersionUID = -5966120108210992211L;
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(DistNodeViewerComparator.class);
// Jcr property type goes to 12
import javax.jcr.RepositoryException;
import javax.jcr.Value;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.SlcNames;
import org.argeo.slc.SlcTypes;
import org.argeo.slc.client.ui.dist.DistConstants;
public class DistUiHelpers implements DistConstants, SlcTypes, SlcNames {
- private final static Log log = LogFactory.getLog(DistUiHelpers.class);
+ private final static CmsLog log = CmsLog.getLog(DistUiHelpers.class);
private final static DateFormat df = new SimpleDateFormat(DATE_TIME_FORMAT);
/**
import javax.jcr.query.Row;
import javax.jcr.query.RowIterator;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.eclipse.ui.GenericTableComparator;
import org.argeo.slc.SlcException;
import org.argeo.slc.SlcTypes;
/** Factorizes useful methods to build a query view in a sashForm */
public abstract class AbstractQueryArtifactsView extends ViewPart implements
SlcTypes {
- private static final Log log = LogFactory
+ private static final CmsLog log = CmsLog
.getLog(AbstractQueryArtifactsView.class);
// shortcuts
*/
public class AnonymousDistributionsView extends ViewPart implements SlcNames,
ArgeoNames {
- // private final static Log log = LogFactory
+ // private final static CmsLog log = CmsLog
// .getLog(AnonymousDistributionsView.class);
public final static String ID = DistPlugin.PLUGIN_ID
+ ".anonymousDistributionsView";
public class ArtifactsBrowser extends ViewPart implements DistConstants,
RepoConstants {
- // private final static Log log = LogFactory.getLog(ArtifactsBrowser.class);
+ // private final static CmsLog log = CmsLog.getLog(ArtifactsBrowser.class);
public final static String ID = DistPlugin.PLUGIN_ID + ".artifactsBrowser";
/* DEPENDENCY INJECTION */
/** Query SLC Repo to get some artifacts given some predefined parameters */
public class QueryArtifactsForm extends AbstractQueryArtifactsView implements
SlcNames {
- // private static final Log log = LogFactory.getLog(QueryArtifactsForm.class);
+ // private static final CmsLog log = CmsLog.getLog(QueryArtifactsForm.class);
public static final String ID = DistPlugin.PLUGIN_ID + ".queryArtifactsForm";
// widgets
/** Query SLC Repo to get some artifacts given some predefined parameters */
public class QueryBundlesForm extends AbstractQueryArtifactsView implements
SlcNames, SlcTypes {
- // private static final Log log = LogFactory.getLog(QueryBundlesForm.class);
+ // private static final CmsLog log = CmsLog.getLog(QueryBundlesForm.class);
public static final String ID = DistPlugin.PLUGIN_ID + ".queryBundlesForm";
// widgets
import javax.jcr.RepositoryFactory;
import javax.jcr.Session;
-import org.argeo.api.security.Keyring;
import org.argeo.cms.ArgeoNames;
import org.argeo.cms.ArgeoTypes;
import org.argeo.cms.jcr.CmsJcrUtils;
+import org.argeo.cms.security.Keyring;
import org.argeo.cms.ui.workbench.util.PrivilegedJob;
import org.argeo.eclipse.ui.jcr.EclipseJcrMonitor;
import org.argeo.jcr.JcrMonitor;
* object.
*/
public class FetchWizard extends Wizard {
- // private final static Log log = LogFactory.getLog(FetchWizard.class);
+ // private final static CmsLog log = CmsLog.getLog(FetchWizard.class);
// Business objects
private Keyring keyring;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.ui.workbench.util.PrivilegedJob;
import org.argeo.eclipse.ui.jcr.EclipseJcrMonitor;
import org.argeo.jcr.JcrMonitor;
* artifacts for this group using a {@link GenerateBinaries} runnable
*/
public class GenerateBinariesWizard extends Wizard {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(GenerateBinariesWizard.class);
// Business objects
import javax.jcr.SimpleCredentials;
import javax.jcr.nodetype.NodeType;
-import org.argeo.api.NodeConstants;
-import org.argeo.api.security.Keyring;
+import org.argeo.api.cms.CmsConstants;
import org.argeo.cms.ArgeoNames;
import org.argeo.cms.ArgeoTypes;
import org.argeo.cms.jcr.CmsJcrUtils;
+import org.argeo.cms.security.Keyring;
import org.argeo.eclipse.ui.dialogs.ErrorFeedback;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
Session nodeSession = null;
try {
- nodeSession = nodeRepository.login(NodeConstants.HOME_WORKSPACE);
+ nodeSession = nodeRepository.login(CmsConstants.HOME_WORKSPACE);
String reposPath = CmsJcrUtils.getUserHome(nodeSession).getPath() + RepoConstants.REPOSITORIES_BASE_PATH;
Node repos = nodeSession.getNode(reposPath);
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="output" path="target/classes"/>
</classpath>
+++ /dev/null
-#Wed Aug 04 16:31:36 CEST 2010
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.5
-org.eclipse.jdt.core.compiler.debug.lineNumber=generate
-org.eclipse.jdt.core.compiler.debug.localVariable=generate
-org.eclipse.jdt.core.compiler.debug.sourceFile=generate
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.5
+++ /dev/null
-#Tue Jul 27 14:24:51 CEST 2010
-eclipse.preferences.version=1
-resolve.requirebundle=false
Bundle-Activator: org.argeo.slc.client.ui.ClientUiPlugin
Import-Package: org.argeo.eclipse.spring,\
-org.argeo.api,\
org.eclipse.core.runtime,\
org.osgi.*;version=0.0.0,\
*
import javax.jcr.Node;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.BasicNameVersion;
import org.argeo.slc.NameVersion;
import org.argeo.slc.SlcException;
/** Deletes one or many results */
public class UpdateModule extends AbstractHandler {
- private final static Log log = LogFactory.getLog(UpdateModule.class);
+ private final static CmsLog log = CmsLog.getLog(UpdateModule.class);
private ModulesManager modulesManager;
// FIXME why not use? org.eclipse.jface.viewers.DecoratingLabelProvider
- // private final static Log log = LogFactory
+ // private final static CmsLog log = CmsLog
// .getLog(ResultFailedDecorator.class);
private final static DateFormat dateFormat = new SimpleDateFormat(
import javax.jcr.RepositoryException;
import javax.jcr.Session;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsConstants;
import org.argeo.eclipse.ui.dialogs.ErrorFeedback;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
pushSession = new ServerPushSession();
pushSession.start();
try {
- homeSession = repository.login(NodeConstants.HOME_WORKSPACE);
+ homeSession = repository.login(CmsConstants.HOME_WORKSPACE);
agentSession = repository.login();
} catch (RepositoryException e1) {
throw new SlcException("Cannot log in to repository");
* and keeps a reference to its parent.
*/
public class ParentNodeFolder extends ResultParent {
- // private final static Log log = LogFactory.getLog(ParentNodeFolder.class);
+ // private final static CmsLog log = CmsLog.getLog(ParentNodeFolder.class);
private Node node = null;
/** Basic label provider for a tree of result */
public class ResultTreeLabelProvider extends LabelProvider {
- // private final static Log log = LogFactory
+ // private final static CmsLog log = CmsLog
// .getLog(ResultTreeLabelProvider.class);
@Override
import javax.jcr.query.Query;
import javax.jcr.query.QueryManager;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;
import org.argeo.eclipse.ui.jcr.DefaultNodeLabelProvider;
import org.argeo.eclipse.ui.jcr.NodeElementComparer;
/** JCR based view of the execution modules. */
public class JcrExecutionModulesView extends ViewPart implements SlcTypes, SlcNames {
- private final static Log log = LogFactory.getLog(JcrExecutionModulesView.class);
+ private final static CmsLog log = CmsLog.getLog(JcrExecutionModulesView.class);
public static final String ID = ClientUiPlugin.ID + ".jcrExecutionModulesView";
import javax.jcr.observation.ObservationManager;
import javax.jcr.query.Query;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsConstants;
import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
pushSession = new ServerPushSession();
pushSession.start();
try {
- session = repository.login(NodeConstants.HOME_WORKSPACE);
+ session = repository.login(CmsConstants.HOME_WORKSPACE);
} catch (RepositoryException re) {
throw new SlcException("Unable to log in Repository " + repository, re);
}
import javax.jcr.observation.EventListener;
import javax.jcr.observation.ObservationManager;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsConstants;
import org.argeo.cms.ui.workbench.util.CommandUtils;
import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;
import org.argeo.jcr.JcrUtils;
@Override
public void createPartControl(Composite parent) {
try {
- session = repository.login(NodeConstants.HOME_WORKSPACE);
+ session = repository.login(CmsConstants.HOME_WORKSPACE);
} catch (RepositoryException e1) {
throw new SlcException("Cannot log in to repository");
}
Import-Package: javax.jcr.nodetype,\
javax.jcr.security,\
-org.argeo.api,\
aQute.bnd.osgi,\
org.apache.tools.ant.*;resolution:="optional",\
junit.framework;resolution:="optional",\
additional.bundles = org.springframework.context,\
org.slf4j.api,\
- org.slf4j.commons.logging,\
- org.slf4j.log4j12,\
- org.apache.log4j,\
org.springframework.aop,\
org.springframework.aspects,\
org.springframework.beans,\
import java.util.Map;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.core.test.context.AbstractInternalSpringTestCase;
import org.springframework.core.io.Resource;
public class DefaultResourceSetTest extends AbstractInternalSpringTestCase {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(DefaultResourceSetTest.class);
public void testListResources() {
import junit.framework.TestCase;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.execution.ExecutionContext;
import org.argeo.slc.execution.ExecutionFlow;
import org.argeo.slc.runtime.test.SimpleTestResult;
public abstract class AbstractExecutionFlowTestCase extends TestCase {
- protected final Log log = LogFactory.getLog(getClass());
+ protected final CmsLog log = CmsLog.getLog(getClass());
protected void logException(Throwable ex) {
log.info("Got Exception of class " + ex.getClass().toString()
package org.argeo.slc.core.execution;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.springframework.beans.factory.InitializingBean;
public class ExceptionIfInitCalledTwice implements Runnable, InitializingBean {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(ExceptionIfInitCalledTwice.class);
private Boolean calledOnce = false;
package org.argeo.slc.core.execution.tasks;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.core.execution.AbstractExecutionFlowTestCase;
public class SystemCallTest extends AbstractExecutionFlowTestCase {
- private final static Log log = LogFactory.getLog(SystemCallTest.class);
+ private final static CmsLog log = CmsLog.getLog(SystemCallTest.class);
private final String defFile = "systemCall.xml";
import junit.framework.TestCase;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.springframework.beans.factory.BeanFactoryUtils;
import org.springframework.beans.factory.ListableBeanFactory;
/** Helper for tests using a Spring application context. */
public abstract class AbstractInternalSpringTestCase extends TestCase {
- protected final Log log = LogFactory.getLog(getClass());
+ protected final CmsLog log = CmsLog.getLog(getClass());
private ConfigurableApplicationContext context;
/**
import java.util.Map;
import java.util.Vector;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
import org.apache.tools.ant.BuildEvent;
import org.apache.tools.ant.BuildListener;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.ProjectHelper;
import org.apache.tools.ant.helper.ProjectHelper2;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.springframework.core.io.Resource;
public class AntRun implements Runnable {
- private final static Log log = LogFactory.getLog(AntRun.class);
+ private final static CmsLog log = CmsLog.getLog(AntRun.class);
private Resource buildFile;
private File baseDir;
import java.util.Date;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.attachment.Attachment;
import org.argeo.slc.attachment.AttachmentsStorage;
public class FileAttachmentsStorage implements AttachmentsStorage,
AttachmentUploader, InitializingBean {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(FileAttachmentsStorage.class);
private File attachmentsDirectory;
import java.util.StringTokenizer;
import java.util.TreeMap;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ResourceLoaderAware;
public class DefaultResourceSet implements ResourceLoaderAware,
InitializingBean, ResourceSet {
- private final static Log log = LogFactory.getLog(DefaultResourceSet.class);
+ private final static CmsLog log = CmsLog.getLog(DefaultResourceSet.class);
public final static String DEFAULT_EXCLUDES = "**/.svn/**";
private String base;
import java.util.Map;
import java.util.TreeMap;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.build.Distribution;
import org.argeo.slc.deploy.DeploymentData;
import org.argeo.slc.deploy.InstalledExecutables;
import org.argeo.slc.deploy.TargetData;
public class SimpleExecutables implements InstalledExecutables {
- private final static Log log = LogFactory.getLog(SimpleExecutables.class);
+ private final static CmsLog log = CmsLog.getLog(SimpleExecutables.class);
private String baseDir;
private Map<String, String> paths = new TreeMap<String, String>();
import java.io.IOException;
import org.apache.commons.io.FileUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.deploy.VersioningDriver;
* information if possible.
*/
public class VersionedDirSync implements Runnable {
- private final static Log log = LogFactory.getLog(VersionedDirSync.class);
+ private final static CmsLog log = CmsLog.getLog(VersionedDirSync.class);
private VersioningDriver versioningDriver;
private File dir;
import java.util.List;
import java.util.Map;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.springframework.beans.BeansException;
import org.springframework.beans.MutablePropertyValues;
public abstract class AbstractExecutionFlowGenerator implements
BeanFactoryPostProcessor, PriorityOrdered {
- private final Log log = LogFactory.getLog(getClass());
+ private final CmsLog log = CmsLog.getLog(getClass());
protected abstract Map<String, BeanDefinition> createExecutionFlowDefinitions(
ConfigurableListableBeanFactory beanFactory);
import java.util.TreeMap;
import java.util.TreeSet;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.execution.ExecutionFlow;
import org.argeo.slc.execution.ExecutionFlowDescriptor;
import org.argeo.slc.execution.ExecutionFlowDescriptorConverter;
/** Workaround for https://www.spartadn.com/bugzilla/show_bug.cgi?id=206 */
private final static String REF_VALUE_INTERNAL = "[internal]";
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(DefaultExecutionFlowDescriptorConverter.class);
private ApplicationContext applicationContext;
import java.util.ArrayList;
import java.util.List;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.execution.ExecutionSpecAttribute;
import org.argeo.slc.execution.RefSpecAttribute;
import org.argeo.slc.execution.RefValueChoice;
public class DefaultExecutionSpec extends org.argeo.slc.runtime.DefaultExecutionSpec
implements BeanNameAware, ApplicationContextAware, InitializingBean {
private static final long serialVersionUID = 5159882223926926539L;
- private final static Log log = LogFactory.getLog(DefaultExecutionSpec.class);
+ private final static CmsLog log = CmsLog.getLog(DefaultExecutionSpec.class);
private transient ApplicationContext applicationContext;
public DefaultExecutionSpec() {
package org.argeo.slc.core.execution;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.execution.ExecutionContext;
import org.argeo.slc.execution.ExecutionFlow;
import org.argeo.slc.execution.ExecutionStack;
@Aspect
/** Aspect intercepting calls on execution flows and contexts. */
public class ExecutionAspect {
- private final static Log log = LogFactory.getLog(ExecutionAspect.class);
+ private final static CmsLog log = CmsLog.getLog(ExecutionAspect.class);
private ExecutionStack executionStack;
private ExecutionContext executionContext;
import java.util.Map;
import java.util.Set;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.execution.ExecutionContext;
import org.argeo.slc.execution.ExecutionFlow;
public class ExecutionParameterPostProcessor extends
InstantiationAwareBeanPostProcessorAdapter {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(ExecutionParameterPostProcessor.class);
private ExecutionContext executionContext;
package org.argeo.slc.core.execution;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.UnsupportedException;
import org.argeo.slc.execution.ExecutionContext;
* reused across an execution.
*/
public class ExecutionScope implements Scope {
- private final static Log log = LogFactory.getLog(ExecutionScope.class);
+ private final static CmsLog log = CmsLog.getLog(ExecutionScope.class);
private final ThreadLocal<ExecutionStack> executionStack = new ThreadLocal<ExecutionStack>();
public final ThreadLocal<String> executionStackBeanName = new ThreadLocal<String>();
import java.util.Date;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.execution.ExecutionContext;
import org.springframework.core.io.FileSystemResource;
/** Implements write access to resources based on standard Java {@link File} */
public class FileExecutionResources implements ExecutionResources {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(FileExecutionResources.class);
protected final static String DEFAULT_EXECUTION_RESOURCES_DIRNAME = "executionResources";
public final static String DEFAULT_EXECUTION_RESOURCES_TMP_PATH = System
package org.argeo.slc.core.execution;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.runtime.InstantiationManager;
import org.springframework.beans.factory.FactoryBean;
public class ParameterRef implements FactoryBean<Object> {
- private final static Log log = LogFactory.getLog(ParameterRef.class);
+ private final static CmsLog log = CmsLog.getLog(ParameterRef.class);
private InstantiationManager instantiationManager;
private String name;
import java.util.HashMap;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.springframework.aop.scope.ScopedProxyUtils;
import org.springframework.beans.BeansException;
public class ExecutionFlowGenerator implements BeanFactoryPostProcessor,
Ordered {
- private final Log log = LogFactory.getLog(getClass());
+ private final CmsLog log = CmsLog.getLog(getClass());
/**
* Source providing a list of <code>RunnableCallFlowDescriptor</code>
import java.util.List;
import java.util.Map;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.execution.DefaultExecutionSpec;
import org.argeo.slc.execution.ExecutionContext;
*/
public class RunnableCallFlow implements ExecutionFlow, ApplicationContextAware {
- private final static Log log = LogFactory.getLog(RunnableCallFlow.class);
+ private final static CmsLog log = CmsLog.getLog(RunnableCallFlow.class);
/**
* Key in the execution context for the index of the call (e.g. 0 for the
import java.io.IOException;
import org.apache.commons.io.FileUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.springframework.core.io.Resource;
public class Echo implements Runnable {
- private final static Log defaultLog = LogFactory.getLog(Echo.class);
+ private final static CmsLog defaultLog = CmsLog.getLog(Echo.class);
private Resource writeTo = null;
- private Log log;
+ private CmsLog log;
private Object message;
public void run() {
}
}
- private Log log() {
+ private CmsLog log() {
return log != null ? log : defaultLog;
}
import org.apache.commons.exec.ShutdownHookProcessDestroyer;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.UnsupportedException;
import org.argeo.slc.core.execution.ExecutionResources;
public class SystemCall implements Runnable {
public final static String LOG_STDOUT = "System.out";
- private final Log log = LogFactory.getLog(getClass());
+ private final CmsLog log = CmsLog.getLog(getClass());
private String execDir;
package org.argeo.slc.core.execution.xml;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.execution.DefaultExecutionFlow;
import org.argeo.slc.execution.ExecutionFlow;
/** Publishes a {@link Runnable} as an {@link ExecutionFlow} */
public class AsFlowDecorator implements BeanDefinitionDecorator {
- private Log log = LogFactory.getLog(AsFlowDecorator.class);
+ private CmsLog log = CmsLog.getLog(AsFlowDecorator.class);
public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder bean,
ParserContext ctx) {
import java.util.ArrayList;
import java.util.List;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.execution.DefaultExecutionFlow;
import org.argeo.slc.execution.ExecutionFlow;
/** Interprets the <flow:flow> tag */
public class FlowBeanDefinitionParser extends
AbstractSingleBeanDefinitionParser {
- private Log log = LogFactory.getLog(FlowBeanDefinitionParser.class);
+ private CmsLog log = CmsLog.getLog(FlowBeanDefinitionParser.class);
/** Whether the user has already be warned on path attribute usage. */
private Boolean warnedAboutPathAttribute = false;
* converting it into bean definitions.
*/
public class NamespaceUtils {
- // private final static Log log = LogFactory.getLog(NamespaceUtils.class);
+ // private final static CmsLog log = CmsLog.getLog(NamespaceUtils.class);
/**
* Returns the value defined either: directly by the the 'value' attribute,
import java.util.List;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.core.execution.DefaultExecutionSpec;
import org.argeo.slc.execution.RefSpecAttribute;
import org.argeo.slc.execution.RefValueChoice;
/** Interprets the <flow:spec> tag */
public class SpecBeanDefinitionParser extends
AbstractSingleBeanDefinitionParser {
- private Log log = LogFactory.getLog(SpecBeanDefinitionParser.class);
+ private CmsLog log = CmsLog.getLog(SpecBeanDefinitionParser.class);
@Override
protected void doParse(Element element, ParserContext parserContext,
import java.util.Collection;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.eclipse.gemini.blueprint.context.BundleContextAware;
import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextEvent;
public class BundlesManager implements BundleContextAware, FrameworkListener,
InitializingBean, DisposableBean,
OsgiBundleApplicationContextListener<OsgiBundleApplicationContextEvent> {
- private final static Log log = LogFactory.getLog(BundlesManager.class);
+ private final static CmsLog log = CmsLog.getLog(BundlesManager.class);
private BundleContext bundleContext;
import java.util.jar.Manifest;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.osgi.framework.Constants;
/** <b>Experimental</b> */
public class FileSystemBundleRegister implements BundleRegister {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(FileSystemBundleRegister.class);
private Properties packagesBundles = null;
import java.util.Map;
import java.util.Properties;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
@SuppressWarnings(value = { "unchecked", "rawtypes" })
public class MultipleServiceExporterPostProcessor implements
ApplicationListener, Ordered {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(MultipleServiceExporterPostProcessor.class);
private List<Class> interfaces = new ArrayList<Class>();
package org.argeo.slc.osgi;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.core.execution.AbstractSpringExecutionModule;
import org.argeo.slc.execution.ExecutionContext;
@Deprecated
public class OsgiExecutionModule extends AbstractSpringExecutionModule {
- private final static Log log = LogFactory.getLog(OsgiExecutionModule.class);
+ private final static CmsLog log = CmsLog.getLog(OsgiExecutionModule.class);
public OsgiExecutionModule() {
log.error("######## ERROR - DEPRECATED APPROACH USED ########");
import javax.management.ObjectName;
import javax.management.StandardMBean;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.DefaultNameVersion;
import org.argeo.slc.NameVersion;
import org.argeo.slc.SlcException;
AbstractExecutionModulesManager implements
OsgiServiceLifecycleListener, BundleListener {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(OsgiExecutionModulesManager.class);
private BundlesManager bundlesManager;
import java.io.File;
import java.io.IOException;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.execution.FileExecutionResources;
import org.eclipse.gemini.blueprint.context.BundleContextAware;
/** Write access to resources in an OSGi context */
public class OsgiExecutionResources extends FileExecutionResources implements
BundleContextAware {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(OsgiExecutionResources.class);
private BundleContext bundleContext;
import java.util.SortedMap;
import java.util.TreeMap;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.DefaultNameVersion;
import org.argeo.slc.NameVersion;
import org.argeo.slc.SlcException;
public abstract class AbstractOsgiModularDistribution implements
ModularDistribution, BundleContextAware, InitializingBean {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(AbstractOsgiModularDistribution.class);
private BundleContext bundleContext;
import java.net.URL;
import java.util.SortedMap;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.NameVersion;
import org.argeo.slc.build.Distribution;
import org.argeo.slc.core.build.VersionedResourceDistribution;
public class OsgiRuntimeModularDistribution extends
AbstractOsgiModularDistribution implements ResourceLoaderAware {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(OsgiRuntimeModularDistribution.class);
private ResourceLoader resourceLoader;
import javax.security.auth.login.LoginContext;
import javax.security.auth.login.LoginException;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsAuth;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
/** Provides base method for executing code with system authorization. */
abstract class AbstractSystemExecution {
- private final static Log log = LogFactory.getLog(AbstractSystemExecution.class);
+ private final static CmsLog log = CmsLog.getLog(AbstractSystemExecution.class);
private final Subject subject = new Subject();
/** Authenticate the calling thread */
ClassLoader origClassLoader = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
try {
- LoginContext lc = new LoginContext(NodeConstants.LOGIN_CONTEXT_DATA_ADMIN, subject);
+ LoginContext lc = new LoginContext(CmsAuth.LOGIN_CONTEXT_DATA_ADMIN, subject);
lc.login();
} catch (LoginException e) {
throw new SlcException("Cannot login as system", e);
ClassLoader origClassLoader = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
try {
- LoginContext lc = new LoginContext(NodeConstants.LOGIN_CONTEXT_DATA_ADMIN, subject);
+ LoginContext lc = new LoginContext(CmsAuth.LOGIN_CONTEXT_DATA_ADMIN, subject);
lc.logout();
} catch (LoginException e) {
throw new SlcException("Cannot logout as system", e);
import javax.security.auth.login.LoginContext;
import javax.security.auth.login.LoginException;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsAuth;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
/** Provides base method for executing code with system authorization. */
abstract class AbstractSystemExecution {
- private final static Log log = LogFactory.getLog(AbstractSystemExecution.class);
+ private final static CmsLog log = CmsLog.getLog(AbstractSystemExecution.class);
private final Subject subject = new Subject();
/** Authenticate the calling thread */
ClassLoader origClassLoader = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
try {
- LoginContext lc = new LoginContext(NodeConstants.LOGIN_CONTEXT_DATA_ADMIN, subject);
+ LoginContext lc = new LoginContext(CmsAuth.LOGIN_CONTEXT_DATA_ADMIN, subject);
lc.login();
} catch (LoginException e) {
throw new SlcException("Cannot login as system", e);
ClassLoader origClassLoader = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
try {
- LoginContext lc = new LoginContext(NodeConstants.LOGIN_CONTEXT_DATA_ADMIN, subject);
+ LoginContext lc = new LoginContext(CmsAuth.LOGIN_CONTEXT_DATA_ADMIN, subject);
lc.logout();
} catch (LoginException e) {
throw new SlcException("Cannot logout as system", e);
import javax.naming.InvalidNameException;
import javax.naming.ldap.LdapName;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.osgi.transaction.WorkTransaction;
import org.argeo.slc.SlcException;
import org.osgi.service.useradmin.Role;
* is already registered.
*/
public class SimpleRoleRegistration implements Runnable {
- private final static Log log = LogFactory.getLog(SimpleRoleRegistration.class);
+ private final static CmsLog log = CmsLog.getLog(SimpleRoleRegistration.class);
private String role;
private List<String> roles = new ArrayList<String>();
package org.argeo.slc.spring.repo.osgi;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.springframework.beans.factory.BeanNameAware;
public class BndWrapper extends org.argeo.slc.repo.osgi.BndWrapper implements BeanNameAware {
- private final static Log log = LogFactory.getLog(BndWrapper.class);
+ private final static CmsLog log = CmsLog.getLog(BndWrapper.class);
@Override
public void setBeanName(String name) {
package org.argeo.slc.spring.repo.osgi;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.springframework.beans.factory.BeanNameAware;
public class MavenWrapper extends org.argeo.slc.repo.osgi.MavenWrapper implements BeanNameAware {
- private final static Log log = LogFactory.getLog(MavenWrapper.class);
+ private final static CmsLog log = CmsLog.getLog(MavenWrapper.class);
@Override
public void setBeanName(String name) {
package org.argeo.slc.spring.repo.osgi;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.springframework.beans.factory.BeanNameAware;
public class UriWrapper extends org.argeo.slc.repo.osgi.UriWrapper implements BeanNameAware {
- private final static Log log = LogFactory.getLog(UriWrapper.class);
+ private final static CmsLog log = CmsLog.getLog(UriWrapper.class);
@Override
public void setBeanName(String name) {
import java.util.List;
import java.util.Map;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.init.osgi.OsgiBoot;
import org.argeo.slc.SlcException;
import org.eclipse.core.runtime.adaptor.EclipseStarter;
@SuppressWarnings("restriction")
public abstract class AbstractOsgiRuntimeTestCase extends TestCase {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(AbstractOsgiRuntimeTestCase.class);
protected OsgiBoot osgiBoot = null;
import java.util.Map;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.springframework.beans.factory.BeanFactoryUtils;
import org.springframework.beans.factory.ListableBeanFactory;
/** Helper for tests using a Spring application co,text. */
public abstract class AbstractSpringTestCase extends TestCase {
- protected final Log log = LogFactory.getLog(getClass());
+ protected final CmsLog log = CmsLog.getLog(getClass());
private ConfigurableApplicationContext context;
/**
import java.io.InputStream;
import java.security.PrivilegedAction;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.UserAuthGSSAPIWithMIC;
public abstract class AbstractJschTask implements Runnable {
- private final Log log = LogFactory.getLog(getClass());
+ private final CmsLog log = CmsLog.getLog(getClass());
private SshTarget sshTarget;
}
private static class JschLogger implements Logger {
- private final Log log = LogFactory.getLog(JschLogger.class);
+ private final CmsLog log = CmsLog.getLog(JschLogger.class);
// TODO better support levels
@Override
package org.argeo.slc.jsch;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
/** Caches a JSCH session in the the ssh target. */
public class JschContextSession extends AbstractJschTask implements
InitializingBean, DisposableBean {
- private final static Log log = LogFactory.getLog(JschContextSession.class);
+ private final static CmsLog log = CmsLog.getLog(JschContextSession.class);
private Boolean autoconnect = false;
@Override
import org.apache.commons.exec.ExecuteStreamHandler;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.execution.ExecutionResources;
import org.argeo.slc.core.execution.tasks.SystemCall;
import com.jcraft.jsch.Session;
public class RemoteExec extends AbstractJschTask {
- private final static Log log = LogFactory.getLog(RemoteExec.class);
+ private final static CmsLog log = CmsLog.getLog(RemoteExec.class);
private Boolean failOnBadExitStatus = true;
import java.io.OutputStream;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.springframework.core.io.Resource;
import com.jcraft.jsch.Session;
public class ScpFrom extends AbstractJschTask {
- private final static Log log = LogFactory.getLog(ScpFrom.class);
+ private final static CmsLog log = CmsLog.getLog(ScpFrom.class);
private Resource localResource;
private String remotePath;
import java.util.List;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.Resource;
import com.jcraft.jsch.Session;
public class ScpTo extends AbstractJschTask {
- private final static Log log = LogFactory.getLog(ScpTo.class);
+ private final static CmsLog log = CmsLog.getLog(ScpTo.class);
private Resource localResource;
private String remotePath;
import java.io.PushbackInputStream;
import java.util.Arrays;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import com.jcraft.jsch.UserInfo;
private Boolean permissive = true;
private Boolean verbose = false;
- private final static Log log = LogFactory.getLog(SimpleUserInfo.class);
+ private final static CmsLog log = CmsLog.getLog(SimpleUserInfo.class);
protected String password;
protected char[] passwordSafe;
import java.util.Map;
import java.util.StringTokenizer;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.deploy.DigestCheck;
import org.argeo.slc.core.deploy.ResourceSet;
import com.jcraft.jsch.Session;
public class SshFilesDeployment extends AbstractJschTask implements Runnable {
- private final static Log log = LogFactory.getLog(SshFilesDeployment.class);
+ private final static CmsLog log = CmsLog.getLog(SshFilesDeployment.class);
private String targetBase = "";
private ResourceSet resourceSet;
/**
import java.io.OutputStreamWriter;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.springframework.core.io.Resource;
import org.springframework.util.StringUtils;
import com.jcraft.jsch.Session;
public class SshShell extends AbstractJschTask {
- private final static Log log = LogFactory.getLog(SshShell.class);
+ private final static CmsLog log = CmsLog.getLog(SshShell.class);
private Resource input;
@Override
import javax.jcr.SimpleCredentials;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
import org.apache.commons.vfs2.FileObject;
import org.apache.commons.vfs2.FileSelectInfo;
import org.apache.commons.vfs2.FileSelector;
import org.apache.commons.vfs2.FileSystemException;
import org.apache.commons.vfs2.FileSystemManager;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.jcr.CmsJcrUtils;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
/** Backups a JCR repository */
public class JcrRepositoryBackup implements Runnable {
- private final static Log log = LogFactory.getLog(JcrRepositoryBackup.class);
+ private final static CmsLog log = CmsLog.getLog(JcrRepositoryBackup.class);
private String sourceRepo;
private String sourceDatastore;
import org.apache.commons.exec.Executor;
import org.apache.commons.io.FileUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.execution.tasks.SystemCall;
/** Rebuild an SRPM in mock. (Historical) Replaces the build-mock.sh script. */
public class BuildInMock implements Runnable {
- private final static Log log = LogFactory.getLog(BuildInMock.class);
+ private final static CmsLog log = CmsLog.getLog(BuildInMock.class);
/** Mock flavour provided by the EPEL repository */
public final static String EPEL = "EPEL";
import org.apache.commons.exec.Executor;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.execution.tasks.SystemCall;
import org.springframework.core.io.Resource;
/** Generates an SRPM from a spec file */
public class CreateSrpm implements Runnable {
- private final static Log log = LogFactory.getLog(CreateSrpm.class);
+ private final static CmsLog log = CmsLog.getLog(CreateSrpm.class);
private File topdir;
import java.util.ArrayList;
import java.util.List;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.execution.tasks.SystemCall;
import org.springframework.core.io.Resource;
public class VBoxManager {
- private final static Log log = LogFactory.getLog(VBoxManager.class);
+ private final static CmsLog log = CmsLog.getLog(VBoxManager.class);
private VBoxMachine vm;
private String executable = "VBoxManage";
+++ /dev/null
-package org.argeo.slc.log4j;
-
-import java.util.Date;
-import java.util.concurrent.BlockingQueue;
-
-import org.apache.log4j.AppenderSkeleton;
-import org.apache.log4j.Level;
-import org.apache.log4j.Logger;
-import org.apache.log4j.spi.LoggingEvent;
-import org.argeo.slc.execution.ExecutionStep;
-import org.argeo.slc.runtime.ExecutionThread;
-import org.argeo.slc.runtime.ProcessThreadGroup;
-
-/** Not meant to be used directly in standard log4j config */
-public class SlcExecutionAppender extends AppenderSkeleton {
-
- private Boolean disabled = false;
-
- private String level = null;
-
- private Level log4jLevel = null;
-
- /** Marker to prevent stack overflow */
- private ThreadLocal<Boolean> dispatching = new ThreadLocal<Boolean>() {
-
- @Override
- protected Boolean initialValue() {
- return false;
- }
- };
-
- // private Layout layout = null;
- // private String pattern = "%m - %c%n";
- private Boolean onlyExecutionThread = false;
-
- public void init() {
- // if (layout != null)
- // setLayout(layout);
- // else
- // setLayout(new PatternLayout(pattern));
- Logger.getRootLogger().addAppender(this);
- }
-
- @Override
- protected void append(LoggingEvent event) {
- if (disabled)
- return;
-
- if (dispatching.get())
- return;
-
- if (level != null && !level.trim().equals("")) {
- if (log4jLevel == null || !log4jLevel.toString().equals(level))
- try {
- log4jLevel = Level.toLevel(level);
- } catch (Exception e) {
- System.err.println("Log4j level could not be set for level '" + level + "', resetting it to null.");
- e.printStackTrace();
- level = null;
- }
-
- if (log4jLevel != null && !event.getLevel().isGreaterOrEqual(log4jLevel)) {
- return;
- }
- }
-
- // Check whether we are within an executing process
- Thread currentThread = Thread.currentThread();
- if (currentThread.getThreadGroup() instanceof ProcessThreadGroup) {
- if (onlyExecutionThread && !(currentThread instanceof ExecutionThread))
- return;
-
- final String type;
- if (event.getLevel().equals(Level.ERROR) || event.getLevel().equals(Level.FATAL))
- type = ExecutionStep.ERROR;
- else if (event.getLevel().equals(Level.WARN))
- type = ExecutionStep.WARNING;
- else if (event.getLevel().equals(Level.INFO))
- type = ExecutionStep.INFO;
- else if (event.getLevel().equals(Level.DEBUG))
- type = ExecutionStep.DEBUG;
- else if (event.getLevel().equals(Level.TRACE))
- type = ExecutionStep.TRACE;
- else
- type = ExecutionStep.INFO;
-
- ExecutionStep step = new ExecutionStep(event.getLoggerName(), new Date(event.getTimeStamp()), type,
- event.getMessage().toString());
-
- try {
- dispatching.set(true);
- BlockingQueue<ExecutionStep> steps = ((ProcessThreadGroup) currentThread.getThreadGroup()).getSteps();
- if (steps.remainingCapacity() == 0) {
- stdOut("WARNING: execution steps queue is full, skipping step: " + step);
- // FIXME understand why it block indefinitely: the queue
- // should be emptied by the logging thread
- } else {
- steps.add(step);
- }
- } finally {
- dispatching.set(false);
- }
- }
- }
-
- public void destroy() throws Exception {
- Logger.getRootLogger().removeAppender(this);
- }
-
- public void close() {
- }
-
- public boolean requiresLayout() {
- return false;
- }
-
- // public void setLayout(Layout layout) {
- // this.layout = layout;
- // }
-
- /** For development purpose, since using regular logging is not easy here */
- static void stdOut(Object obj) {
- System.out.println(obj);
- }
-
- // public void setPattern(String pattern) {
- // this.pattern = pattern;
- // }
-
- public void setOnlyExecutionThread(Boolean onlyExecutionThread) {
- this.onlyExecutionThread = onlyExecutionThread;
- }
-
- public void setDisabled(Boolean disabled) {
- this.disabled = disabled;
- }
-
- public void setLevel(String level) {
- this.level = level;
- }
-
-}
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.execution.tasks.SystemCall;
// http://java.sun.com/developer/onlineTraining/JavaMail/contents.html#JavaMailUsage
// http://java.sun.com/products/javamail/FAQ.html#gmail
- private final static Log log = LogFactory.getLog(SendMail.class);
+ private final static CmsLog log = CmsLog.getLog(SendMail.class);
private String host;
private String from;
import java.io.File;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.build.Distribution;
import org.argeo.slc.deploy.DeployEnvironment;
import org.argeo.slc.deploy.TargetData;
public class HttpdApplicationDeployment implements Deployment {
- private static final Log log = LogFactory
+ private static final CmsLog log = CmsLog
.getLog(HttpdApplicationDeployment.class);
private HttpdApplicationTargetData targetData;
import java.io.InputStreamReader;
import java.util.Arrays;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.deploy.DeployedSystemManager;
public class HttpdServerManager implements DeployedSystemManager<HttpdServer> {
- private final static Log log = LogFactory.getLog(HttpdServerManager.class);
+ private final static CmsLog log = CmsLog.getLog(HttpdServerManager.class);
private HttpdServer httpdServer;
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.argeo.slc</groupId>
<artifactId>org.argeo.slc.runtime</artifactId>
<version>2.3-SNAPSHOT</version>
</dependency>
-
-
+
+
<dependency>
<groupId>org.argeo.slc</groupId>
<artifactId>org.argeo.slc.repo</artifactId>
<version>2.3-SNAPSHOT</version>
</dependency>
+
+ <dependency>
+ <groupId>org.argeo.commons</groupId>
+ <artifactId>org.argeo.api</artifactId>
+ <version>${version.argeo-commons}</version>
+ </dependency>
+
</dependencies>
</project>
\ No newline at end of file
import org.apache.commons.exec.Executor;
import org.apache.commons.io.FileUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.rpmfactory.RpmFactory;
import org.argeo.slc.runtime.tasks.SystemCall;
/** Build an RPM in mock. */
public class BuildInMock implements Runnable {
- private final static Log log = LogFactory.getLog(BuildInMock.class);
+ private final static CmsLog log = CmsLog.getLog(BuildInMock.class);
private final static String NOARCH = "noarch";
private String rpmPackage = null;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.rpmfactory.RpmFactory;
* consistent distributable set (typically to be used to generate an ISO).
*/
public class CreateRpmDistribution implements Runnable {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(CreateRpmDistribution.class);
private RpmFactory rpmFactory;
import org.apache.commons.exec.Executor;
import org.apache.commons.io.FileUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.rpmfactory.RpmFactory;
import org.argeo.slc.runtime.tasks.SystemCall;
/** Releases the content of staging to a public repository. */
public class ReleaseStaging implements Runnable {
- private final static Log log = LogFactory.getLog(ReleaseStaging.class);
+ private final static CmsLog log = CmsLog.getLog(ReleaseStaging.class);
private RpmFactory rpmFactory;
private Executor executor;
import javax.jcr.Session;
import org.apache.commons.io.FileUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcConstants;
import org.argeo.slc.SlcException;
* components performing the various actions related to RPM build.
*/
public class RpmFactoryImpl implements RpmFactory {
- private Log log = LogFactory.getLog(RpmFactoryImpl.class);
+ private CmsLog log = CmsLog.getLog(RpmFactoryImpl.class);
private Repository rpmRepository;
private Repository distRepository;
import javax.jcr.nodetype.NodeType;
import javax.jcr.security.AccessControlException;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.ArgeoNames;
import org.argeo.jcr.JcrUtils;
import org.argeo.jcr.proxy.AbstractUrlProxy;
/** Synchronises the node repository with remote Maven repositories */
public class RpmProxyServiceImpl extends AbstractUrlProxy implements
RpmProxyService, ArgeoNames, SlcNames {
- private final static Log log = LogFactory.getLog(RpmProxyServiceImpl.class);
+ private final static CmsLog log = CmsLog.getLog(RpmProxyServiceImpl.class);
private Set<RpmRepository> defaultRepositories = new HashSet<RpmRepository>();
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.LineIterator;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
/**
* packages.
*/
public class YumListParser implements RpmPackageSet {
- private final static Log log = LogFactory.getLog(YumListParser.class);
+ private final static CmsLog log = CmsLog.getLog(YumListParser.class);
private Set<String> installed = new TreeSet<String>();
/** Not installed but available */
javax.jcr.security,\
org.apache.jackrabbit.api,\
org.apache.jackrabbit.commons,\
-org.argeo.api,\
*
\ No newline at end of file
org.apache.jackrabbit.spi,\
org.apache.jackrabbit.spi.commons,\
org.slf4j.api,\
- org.slf4j.log4j12,\
- org.apache.log4j,\
- org.apache.commons.collections,\
+ org.apache.commons.collections,\
EDU.oswego.cs.dl.util.concurrent,\
org.apache.lucene,\
org.apache.tika.core,\
import javax.jcr.Node;
import javax.jcr.RepositoryException;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.SlcNames;
* itself if metadata node name is set to null)
*/
public class JcrMetadataWriter implements Runnable {
- private final static Log log = LogFactory.getLog(JcrMetadataWriter.class);
+ private final static CmsLog log = CmsLog.getLog(JcrMetadataWriter.class);
private Node baseNode;
private String metadataNodeName = SlcNames.SLC_METADATA;
try {
Node metadataNode;
if (metadataNodeName != null)
- metadataNode = baseNode.hasNode(metadataNodeName) ? baseNode
- .getNode(metadataNodeName) : baseNode
- .addNode(metadataNodeName);
+ metadataNode = baseNode.hasNode(metadataNodeName) ? baseNode.getNode(metadataNodeName)
+ : baseNode.addNode(metadataNodeName);
else
metadataNode = baseNode;
baseNode.getSession().save();
if (log.isDebugEnabled())
- log.debug("Wrote " + metadata.size() + " metadata entries to "
- + metadataNode);
+ log.debug("Wrote " + metadata.size() + " metadata entries to " + metadataNode);
} catch (RepositoryException e) {
throw new SlcException("Cannot write metadata to " + baseNode, e);
} finally {
import javax.jcr.query.Query;
import javax.jcr.query.QueryManager;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.SlcNames;
* {@link SlcTypes#SLC_TEST_RESULT}.
*/
public class JcrTestResult implements TestResult, SlcNames, AttachmentsEnabled {
- private final static Log log = LogFactory.getLog(JcrTestResult.class);
+ private final static CmsLog log = CmsLog.getLog(JcrTestResult.class);
/** Should only be set for an already existing result. */
private String uuid;
import javax.jcr.Session;
import javax.jcr.nodetype.NodeType;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.SlcNames;
* Synchronizes the local execution runtime with a JCR repository. For the time
* being the state is completely reset from one start to another.
*/
-public class JcrExecutionModulesListener implements ExecutionModulesListener,
- SlcNames {
+public class JcrExecutionModulesListener implements ExecutionModulesListener, SlcNames {
private final static String SLC_EXECUTION_MODULES_PROPERTY = "slc.executionModules";
- private final static Log log = LogFactory
- .getLog(JcrExecutionModulesListener.class);
+ private final static CmsLog log = CmsLog.getLog(JcrExecutionModulesListener.class);
private JcrAgent agent;
private ExecutionModulesManager modulesManager;
private Repository repository;
/**
- * We don't use a thread bound session because many different threads will
- * call this critical component and we don't want to login each time. We
- * therefore rather protect access to this session via synchronized.
+ * We don't use a thread bound session because many different threads will call
+ * this critical component and we don't want to login each time. We therefore
+ * rather protect access to this session via synchronized.
*/
private Session session;
if (modulesManager != null) {
Node agentNode = session.getNode(agent.getNodePath());
- List<ModuleDescriptor> moduleDescriptors = modulesManager
- .listModules();
+ List<ModuleDescriptor> moduleDescriptors = modulesManager.listModules();
// scan SLC-ExecutionModule metadata
for (ModuleDescriptor md : moduleDescriptors) {
- if (md.getMetadata().containsKey(
- ExecutionModuleDescriptor.SLC_EXECUTION_MODULE)) {
- String moduleNodeName = SlcJcrUtils
- .getModuleNodeName(md);
- Node moduleNode = agentNode.hasNode(moduleNodeName) ? agentNode
- .getNode(moduleNodeName) : agentNode
- .addNode(moduleNodeName);
+ if (md.getMetadata().containsKey(ExecutionModuleDescriptor.SLC_EXECUTION_MODULE)) {
+ String moduleNodeName = SlcJcrUtils.getModuleNodeName(md);
+ Node moduleNode = agentNode.hasNode(moduleNodeName) ? agentNode.getNode(moduleNodeName)
+ : agentNode.addNode(moduleNodeName);
moduleNode.addMixin(SlcTypes.SLC_EXECUTION_MODULE);
moduleNode.setProperty(SLC_NAME, md.getName());
moduleNode.setProperty(SLC_VERSION, md.getVersion());
- moduleNode.setProperty(Property.JCR_TITLE,
- md.getTitle());
- moduleNode.setProperty(Property.JCR_DESCRIPTION,
- md.getDescription());
+ moduleNode.setProperty(Property.JCR_TITLE, md.getTitle());
+ moduleNode.setProperty(Property.JCR_DESCRIPTION, md.getDescription());
moduleNode.setProperty(SLC_STARTED, md.getStarted());
}
}
// scan execution modules property
- String executionModules = System
- .getProperty(SLC_EXECUTION_MODULES_PROPERTY);
+ String executionModules = System.getProperty(SLC_EXECUTION_MODULES_PROPERTY);
if (executionModules != null) {
for (String executionModule : executionModules.split(",")) {
allModules: for (ModuleDescriptor md : moduleDescriptors) {
- String moduleNodeName = SlcJcrUtils
- .getModuleNodeName(md);
+ String moduleNodeName = SlcJcrUtils.getModuleNodeName(md);
if (md.getName().equals(executionModule)) {
- Node moduleNode = agentNode
- .hasNode(moduleNodeName) ? agentNode
- .getNode(moduleNodeName) : agentNode
- .addNode(moduleNodeName);
- moduleNode
- .addMixin(SlcTypes.SLC_EXECUTION_MODULE);
+ Node moduleNode = agentNode.hasNode(moduleNodeName) ? agentNode.getNode(moduleNodeName)
+ : agentNode.addNode(moduleNodeName);
+ moduleNode.addMixin(SlcTypes.SLC_EXECUTION_MODULE);
moduleNode.setProperty(SLC_NAME, md.getName());
- moduleNode.setProperty(SLC_VERSION,
- md.getVersion());
- moduleNode.setProperty(Property.JCR_TITLE,
- md.getTitle());
- moduleNode.setProperty(
- Property.JCR_DESCRIPTION,
- md.getDescription());
- moduleNode.setProperty(SLC_STARTED,
- md.getStarted());
+ moduleNode.setProperty(SLC_VERSION, md.getVersion());
+ moduleNode.setProperty(Property.JCR_TITLE, md.getTitle());
+ moduleNode.setProperty(Property.JCR_DESCRIPTION, md.getDescription());
+ moduleNode.setProperty(SLC_STARTED, md.getStarted());
break allModules;
}
}
* EXECUTION MODULES LISTENER
*/
- public synchronized void executionModuleAdded(
- ModuleDescriptor moduleDescriptor) {
+ public synchronized void executionModuleAdded(ModuleDescriptor moduleDescriptor) {
syncExecutionModule(moduleDescriptor);
}
protected void syncExecutionModule(ModuleDescriptor moduleDescriptor) {
try {
Node agentNode = session.getNode(agent.getNodePath());
- String moduleNodeName = SlcJcrUtils
- .getModuleNodeName(moduleDescriptor);
- Node moduleNode = agentNode.hasNode(moduleNodeName) ? agentNode
- .getNode(moduleNodeName) : agentNode
- .addNode(moduleNodeName);
+ String moduleNodeName = SlcJcrUtils.getModuleNodeName(moduleDescriptor);
+ Node moduleNode = agentNode.hasNode(moduleNodeName) ? agentNode.getNode(moduleNodeName)
+ : agentNode.addNode(moduleNodeName);
moduleNode.addMixin(SlcTypes.SLC_EXECUTION_MODULE);
moduleNode.setProperty(SLC_NAME, moduleDescriptor.getName());
moduleNode.setProperty(SLC_VERSION, moduleDescriptor.getVersion());
- moduleNode.setProperty(Property.JCR_TITLE,
- moduleDescriptor.getTitle());
- moduleNode.setProperty(Property.JCR_DESCRIPTION,
- moduleDescriptor.getDescription());
+ moduleNode.setProperty(Property.JCR_TITLE, moduleDescriptor.getTitle());
+ moduleNode.setProperty(Property.JCR_DESCRIPTION, moduleDescriptor.getDescription());
moduleNode.setProperty(SLC_STARTED, moduleDescriptor.getStarted());
session.save();
} catch (RepositoryException e) {
}
}
- public synchronized void executionModuleRemoved(
- ModuleDescriptor moduleDescriptor) {
+ public synchronized void executionModuleRemoved(ModuleDescriptor moduleDescriptor) {
try {
String moduleName = SlcJcrUtils.getModuleNodeName(moduleDescriptor);
Node agentNode = session.getNode(agent.getNodePath());
session.save();
} catch (RepositoryException e) {
JcrUtils.discardQuietly(session);
- throw new SlcException("Cannot remove module " + moduleDescriptor,
- e);
+ throw new SlcException("Cannot remove module " + moduleDescriptor, e);
}
}
- public synchronized void executionFlowAdded(ModuleDescriptor module,
- ExecutionFlowDescriptor efd) {
+ public synchronized void executionFlowAdded(ModuleDescriptor module, ExecutionFlowDescriptor efd) {
try {
Node agentNode = session.getNode(agent.getNodePath());
- Node moduleNode = agentNode.getNode(SlcJcrUtils
- .getModuleNodeName(module));
+ Node moduleNode = agentNode.getNode(SlcJcrUtils.getModuleNodeName(module));
String relativePath = getExecutionFlowRelativePath(efd);
@SuppressWarnings("unused")
Node flowNode = null;
if (!moduleNode.hasNode(relativePath)) {
- flowNode = createExecutionFlowNode(moduleNode, relativePath,
- efd);
+ flowNode = createExecutionFlowNode(moduleNode, relativePath, efd);
session.save();
} else {
flowNode = moduleNode.getNode(relativePath);
log.trace("Flow " + efd + " added to JCR");
} catch (RepositoryException e) {
JcrUtils.discardQuietly(session);
- throw new SlcException("Cannot add flow " + efd + " from module "
- + module, e);
+ throw new SlcException("Cannot add flow " + efd + " from module " + module, e);
}
}
- protected Node createExecutionFlowNode(Node moduleNode,
- String relativePath, ExecutionFlowDescriptor efd)
+ protected Node createExecutionFlowNode(Node moduleNode, String relativePath, ExecutionFlowDescriptor efd)
throws RepositoryException {
Node flowNode = null;
List<String> pathTokens = Arrays.asList(relativePath.split("/"));
if (names.hasNext())
currNode = currNode.addNode(name);
else
- flowNode = currNode.addNode(name,
- SlcTypes.SLC_EXECUTION_FLOW);
+ flowNode = currNode.addNode(name, SlcTypes.SLC_EXECUTION_FLOW);
}
}
flowNode.setProperty(SLC_NAME, efd.getName());
String endName = pathTokens.get(pathTokens.size() - 1);
flowNode.setProperty(Property.JCR_TITLE, endName);
- if (efd.getDescription() != null
- && !efd.getDescription().trim().equals("")) {
+ if (efd.getDescription() != null && !efd.getDescription().trim().equals("")) {
flowNode.setProperty(Property.JCR_DESCRIPTION, efd.getDescription());
} else {
flowNode.setProperty(Property.JCR_DESCRIPTION, endName);
mapExecutionSpec(flowNode, executionSpec);
} else {
// reference spec node
- Node executionSpecsNode = moduleNode.hasNode(SLC_EXECUTION_SPECS) ? moduleNode
- .getNode(SLC_EXECUTION_SPECS) : moduleNode
- .addNode(SLC_EXECUTION_SPECS);
- Node executionSpecNode = executionSpecsNode.addNode(esName,
- SlcTypes.SLC_EXECUTION_SPEC);
+ Node executionSpecsNode = moduleNode.hasNode(SLC_EXECUTION_SPECS) ? moduleNode.getNode(SLC_EXECUTION_SPECS)
+ : moduleNode.addNode(SLC_EXECUTION_SPECS);
+ Node executionSpecNode = executionSpecsNode.addNode(esName, SlcTypes.SLC_EXECUTION_SPEC);
executionSpecNode.setProperty(SLC_NAME, esName);
executionSpecNode.setProperty(Property.JCR_TITLE, esName);
- if (executionSpec.getDescription() != null
- && !executionSpec.getDescription().trim().equals(""))
- executionSpecNode.setProperty(Property.JCR_DESCRIPTION,
- executionSpec.getDescription());
+ if (executionSpec.getDescription() != null && !executionSpec.getDescription().trim().equals(""))
+ executionSpecNode.setProperty(Property.JCR_DESCRIPTION, executionSpec.getDescription());
mapExecutionSpec(executionSpecNode, executionSpec);
flowNode.setProperty(SLC_SPEC, executionSpecNode);
}
// flow values
for (String attr : efd.getValues().keySet()) {
- ExecutionSpecAttribute esa = executionSpec.getAttributes()
- .get(attr);
+ ExecutionSpecAttribute esa = executionSpec.getAttributes().get(attr);
if (esa instanceof PrimitiveSpecAttribute) {
PrimitiveSpecAttribute psa = (PrimitiveSpecAttribute) esa;
// if spec reference there will be no node at this stage
Node valueNode = JcrUtils.getOrAdd(flowNode, attr);
valueNode.setProperty(SLC_TYPE, psa.getType());
- SlcJcrUtils.setPrimitiveAsProperty(valueNode, SLC_VALUE,
- (PrimitiveValue) efd.getValues().get(attr));
+ SlcJcrUtils.setPrimitiveAsProperty(valueNode, SLC_VALUE, (PrimitiveValue) efd.getValues().get(attr));
}
}
}
/**
- * Base can be either an execution spec node, or an execution flow node (in
- * case the execution spec is internal)
+ * Base can be either an execution spec node, or an execution flow node (in case
+ * the execution spec is internal)
*/
- protected void mapExecutionSpec(Node baseNode, ExecutionSpec executionSpec)
- throws RepositoryException {
+ protected void mapExecutionSpec(Node baseNode, ExecutionSpec executionSpec) throws RepositoryException {
for (String attrName : executionSpec.getAttributes().keySet()) {
- ExecutionSpecAttribute esa = executionSpec.getAttributes().get(
- attrName);
+ ExecutionSpecAttribute esa = executionSpec.getAttributes().get(attrName);
Node attrNode = baseNode.addNode(attrName);
// booleans
attrNode.addMixin(SlcTypes.SLC_EXECUTION_SPEC_ATTRIBUTE);
index = count;
Node choiceNode = attrNode.addNode(choice.getName());
choiceNode.addMixin(NodeType.MIX_TITLE);
- choiceNode.setProperty(Property.JCR_TITLE,
- choice.getName());
- if (choice.getDescription() != null
- && !choice.getDescription().trim().equals(""))
- choiceNode.setProperty(Property.JCR_DESCRIPTION,
- choice.getDescription());
+ choiceNode.setProperty(Property.JCR_TITLE, choice.getName());
+ if (choice.getDescription() != null && !choice.getDescription().trim().equals(""))
+ choiceNode.setProperty(Property.JCR_DESCRIPTION, choice.getDescription());
count++;
}
}
}
- public synchronized void executionFlowRemoved(ModuleDescriptor module,
- ExecutionFlowDescriptor executionFlow) {
+ public synchronized void executionFlowRemoved(ModuleDescriptor module, ExecutionFlowDescriptor executionFlow) {
try {
Node agentNode = session.getNode(agent.getNodePath());
- Node moduleNode = agentNode.getNode(SlcJcrUtils
- .getModuleNodeName(module));
+ Node moduleNode = agentNode.getNode(SlcJcrUtils.getModuleNodeName(module));
String relativePath = getExecutionFlowRelativePath(executionFlow);
if (moduleNode.hasNode(relativePath))
moduleNode.getNode(relativePath).remove();
agentNode.getSession().save();
} catch (RepositoryException e) {
- throw new SlcException("Cannot remove flow " + executionFlow
- + " from module " + module, e);
+ throw new SlcException("Cannot remove flow " + executionFlow + " from module " + module, e);
}
}
*/
/** @return the relative path, never starts with '/' */
@SuppressWarnings("deprecation")
- protected String getExecutionFlowRelativePath(
- ExecutionFlowDescriptor executionFlow) {
- String relativePath = executionFlow.getPath() == null ? executionFlow
- .getName() : executionFlow.getPath() + '/'
- + executionFlow.getName();
+ protected String getExecutionFlowRelativePath(ExecutionFlowDescriptor executionFlow) {
+ String relativePath = executionFlow.getPath() == null ? executionFlow.getName()
+ : executionFlow.getPath() + '/' + executionFlow.getName();
// we assume that it is more than one char long
if (relativePath.charAt(0) == '/')
relativePath = relativePath.substring(1);
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.NameVersion;
import org.argeo.slc.SlcException;
/** Execution process implementation based on a JCR node. */
public class JcrExecutionProcess implements ExecutionProcess, SlcNames {
- private final static Log log = LogFactory.getLog(JcrExecutionProcess.class);
+ private final static CmsLog log = CmsLog.getLog(JcrExecutionProcess.class);
private final Node node;
private Long nextLogLine = 1l;
}
/**
- * Synchronized in order to make sure that there is no concurrent
- * modification of {@link #nextLogLine}.
+ * Synchronized in order to make sure that there is no concurrent modification
+ * of {@link #nextLogLine}.
*/
public synchronized void addSteps(List<ExecutionStep> steps) {
try {
// skip
continue steps;
- String relPath = SLC_LOG + '/'
- + step.getThread().replace('/', '_') + '/'
+ String relPath = SLC_LOG + '/' + step.getThread().replace('/', '_') + '/'
+ step.getLocation().replace('.', '/');
String path = node.getPath() + '/' + relPath;
// clean special character
path = path.replace('@', '_');
Node location = JcrUtils.mkdirs(node.getSession(), path);
- Node logEntry = location.addNode(Long.toString(nextLogLine),
- type);
+ Node logEntry = location.addNode(Long.toString(nextLogLine), type);
logEntry.setProperty(SLC_MESSAGE, step.getLog());
Calendar calendar = new GregorianCalendar();
calendar.setTime(step.getTimestamp());
Node realizedFlowNode = nit.nextNode();
if (realizedFlowNode.hasNode(SLC_ADDRESS)) {
- String flowPath = realizedFlowNode.getNode(SLC_ADDRESS)
- .getProperty(Property.JCR_PATH).getString();
- NameVersion moduleNameVersion = SlcJcrUtils
- .moduleNameVersion(flowPath);
- ((ProcessThread) Thread.currentThread())
- .getExecutionModulesManager().start(
- moduleNameVersion);
+ String flowPath = realizedFlowNode.getNode(SLC_ADDRESS).getProperty(Property.JCR_PATH).getString();
+ NameVersion moduleNameVersion = SlcJcrUtils.moduleNameVersion(flowPath);
+ ((ProcessThread) Thread.currentThread()).getExecutionModulesManager().start(moduleNameVersion);
}
- RealizedFlow realizedFlow = new JcrRealizedFlow(
- realizedFlowNode);
+ RealizedFlow realizedFlow = new JcrRealizedFlow(realizedFlowNode);
if (realizedFlow != null)
realizedFlows.add(realizedFlow);
}
try {
return node.getPath();
} catch (RepositoryException e) {
- throw new SlcException("Cannot get process node path for " + node,
- e);
+ throw new SlcException("Cannot get process node path for " + node, e);
}
}
try {
return node.getSession().getRepository();
} catch (RepositoryException e) {
- throw new SlcException("Cannot get process JCR repository for "
- + node, e);
+ throw new SlcException("Cannot get process JCR repository for " + node, e);
}
}
}
import javax.jcr.RepositoryException;
import javax.jcr.Session;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsConstants;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.SlcNames;
Session session = null;
if (getProcess() instanceof JcrExecutionProcess)
try {
- session = ((JcrExecutionProcess) getProcess()).getRepository().login(NodeConstants.HOME_WORKSPACE);
+ session = ((JcrExecutionProcess) getProcess()).getRepository().login(CmsConstants.HOME_WORKSPACE);
List<RealizedFlow> realizedFlows = getProcess().getRealizedFlows();
for (RealizedFlow realizedFlow : realizedFlows) {
javax.xml.parsers.*,\
javax.jcr.nodetype,\
org.osgi.*;version=0.0.0,\
-org.argeo.api,\
*
Require-Capability: cms.datamodel; filter:="(name=slc)"
import javax.jcr.RepositoryException;
import javax.jcr.nodetype.NodeType;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.SlcNames;
* files and other non artifact files).
*/
public class ArtifactIndexer implements NodeIndexer, SlcNames {
- private Log log = LogFactory.getLog(ArtifactIndexer.class);
+ private CmsLog log = CmsLog.getLog(ArtifactIndexer.class);
private Boolean force = false;
public Boolean support(String path) {
artifact = AetherUtils.convertPathToArtifact(relativePath, null);
// support() guarantees that artifact won't be null, no NPE check
fileNode.addMixin(SlcTypes.SLC_ARTIFACT);
- fileNode.setProperty(SlcNames.SLC_ARTIFACT_ID,
- artifact.getArtifactId());
+ fileNode.setProperty(SlcNames.SLC_ARTIFACT_ID, artifact.getArtifactId());
fileNode.setProperty(SlcNames.SLC_GROUP_ID, artifact.getGroupId());
- fileNode.setProperty(SlcNames.SLC_ARTIFACT_VERSION,
- artifact.getVersion());
- fileNode.setProperty(SlcNames.SLC_ARTIFACT_EXTENSION,
- artifact.getExtension());
+ fileNode.setProperty(SlcNames.SLC_ARTIFACT_VERSION, artifact.getVersion());
+ fileNode.setProperty(SlcNames.SLC_ARTIFACT_EXTENSION, artifact.getExtension());
// can be null but ok for JCR API
- fileNode.setProperty(SlcNames.SLC_ARTIFACT_CLASSIFIER,
- artifact.getClassifier());
+ fileNode.setProperty(SlcNames.SLC_ARTIFACT_CLASSIFIER, artifact.getClassifier());
JcrUtils.updateLastModified(fileNode);
// make sure there are checksums
String shaNodeName = fileNode.getName() + ".sha1";
if (!fileNode.getParent().hasNode(shaNodeName)) {
String sha = JcrUtils.checksumFile(fileNode, "SHA-1");
- JcrUtils.copyBytesAsFile(fileNode.getParent(), shaNodeName,
- sha.getBytes());
+ JcrUtils.copyBytesAsFile(fileNode.getParent(), shaNodeName, sha.getBytes());
}
String md5NodeName = fileNode.getName() + ".md5";
if (!fileNode.getParent().hasNode(md5NodeName)) {
String md5 = JcrUtils.checksumFile(fileNode, "MD5");
- JcrUtils.copyBytesAsFile(fileNode.getParent(), md5NodeName,
- md5.getBytes());
+ JcrUtils.copyBytesAsFile(fileNode.getParent(), md5NodeName, md5.getBytes());
}
// Create a default pom if none already exist
String fileNodeName = fileNode.getName();
String pomName = null;
if (fileNodeName.endsWith(".jar"))
- pomName = fileNodeName.substring(0, fileNodeName.length()
- - ".jar".length())
- + ".pom";
+ pomName = fileNodeName.substring(0, fileNodeName.length() - ".jar".length()) + ".pom";
if (pomName != null && !fileNode.getParent().hasNode(pomName)) {
String pom = generatePomForBundle(fileNode);
- Node pomNode = JcrUtils.copyBytesAsFile(fileNode.getParent(),
- pomName, pom.getBytes());
+ Node pomNode = JcrUtils.copyBytesAsFile(fileNode.getParent(), pomName, pom.getBytes());
// corresponding check sums
String sha = JcrUtils.checksumFile(pomNode, "SHA-1");
- JcrUtils.copyBytesAsFile(fileNode.getParent(), pomName
- + ".sha1", sha.getBytes());
+ JcrUtils.copyBytesAsFile(fileNode.getParent(), pomName + ".sha1", sha.getBytes());
String md5 = JcrUtils.checksumFile(fileNode, "MD5");
- JcrUtils.copyBytesAsFile(fileNode.getParent(),
- pomName + ".md5", md5.getBytes());
+ JcrUtils.copyBytesAsFile(fileNode.getParent(), pomName + ".md5", md5.getBytes());
}
// set higher levels
Node artifactVersionBase = fileNode.getParent();
- if (!artifactVersionBase
- .isNodeType(SlcTypes.SLC_ARTIFACT_VERSION_BASE)) {
- artifactVersionBase
- .addMixin(SlcTypes.SLC_ARTIFACT_VERSION_BASE);
- artifactVersionBase.setProperty(SlcNames.SLC_ARTIFACT_VERSION,
- artifact.getBaseVersion());
- artifactVersionBase.setProperty(SlcNames.SLC_ARTIFACT_ID,
- artifact.getArtifactId());
- artifactVersionBase.setProperty(SlcNames.SLC_GROUP_ID,
- artifact.getGroupId());
+ if (!artifactVersionBase.isNodeType(SlcTypes.SLC_ARTIFACT_VERSION_BASE)) {
+ artifactVersionBase.addMixin(SlcTypes.SLC_ARTIFACT_VERSION_BASE);
+ artifactVersionBase.setProperty(SlcNames.SLC_ARTIFACT_VERSION, artifact.getBaseVersion());
+ artifactVersionBase.setProperty(SlcNames.SLC_ARTIFACT_ID, artifact.getArtifactId());
+ artifactVersionBase.setProperty(SlcNames.SLC_GROUP_ID, artifact.getGroupId());
}
JcrUtils.updateLastModified(artifactVersionBase);
Node artifactBase = artifactVersionBase.getParent();
if (!artifactBase.isNodeType(SlcTypes.SLC_ARTIFACT_BASE)) {
artifactBase.addMixin(SlcTypes.SLC_ARTIFACT_BASE);
- artifactBase.setProperty(SlcNames.SLC_ARTIFACT_ID,
- artifact.getArtifactId());
- artifactBase.setProperty(SlcNames.SLC_GROUP_ID,
- artifact.getGroupId());
+ artifactBase.setProperty(SlcNames.SLC_ARTIFACT_ID, artifact.getArtifactId());
+ artifactBase.setProperty(SlcNames.SLC_GROUP_ID, artifact.getGroupId());
}
JcrUtils.updateLastModified(artifactBase);
// + " is also artifact base");
// }
groupBase.addMixin(SlcTypes.SLC_GROUP_BASE);
- groupBase.setProperty(SlcNames.SLC_GROUP_BASE_ID,
- artifact.getGroupId());
+ groupBase.setProperty(SlcNames.SLC_GROUP_BASE_ID, artifact.getGroupId());
}
- JcrUtils.updateLastModifiedAndParents(groupBase,
- RepoConstants.DEFAULT_ARTIFACTS_BASE_PATH);
+ JcrUtils.updateLastModifiedAndParents(groupBase, RepoConstants.DEFAULT_ARTIFACTS_BASE_PATH);
if (log.isTraceEnabled())
log.trace("Indexed artifact " + artifact + " on " + fileNode);
} catch (Exception e) {
- throw new SlcException("Cannot index artifact " + artifact
- + " metadata on node " + fileNode, e);
+ throw new SlcException("Cannot index artifact " + artifact + " metadata on node " + fileNode, e);
}
}
private String generatePomForBundle(Node n) throws RepositoryException {
StringBuffer p = new StringBuffer();
p.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
- p.append("<project xmlns=\"http://maven.apache.org/POM/4.0.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd\">\n");
+ p.append(
+ "<project xmlns=\"http://maven.apache.org/POM/4.0.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd\">\n");
p.append("<modelVersion>4.0.0</modelVersion>");
// Categorized name version
- p.append("<groupId>").append(JcrUtils.get(n, SLC_GROUP_ID))
- .append("</groupId>\n");
- p.append("<artifactId>").append(JcrUtils.get(n, SLC_ARTIFACT_ID))
- .append("</artifactId>\n");
- p.append("<version>").append(JcrUtils.get(n, SLC_ARTIFACT_VERSION))
- .append("</version>\n");
+ p.append("<groupId>").append(JcrUtils.get(n, SLC_GROUP_ID)).append("</groupId>\n");
+ p.append("<artifactId>").append(JcrUtils.get(n, SLC_ARTIFACT_ID)).append("</artifactId>\n");
+ p.append("<version>").append(JcrUtils.get(n, SLC_ARTIFACT_VERSION)).append("</version>\n");
// TODO make it more generic
p.append("<packaging>jar</packaging>\n");
if (n.hasProperty(SLC_ + Constants.BUNDLE_NAME))
- p.append("<name>")
- .append(JcrUtils.get(n, SLC_ + Constants.BUNDLE_NAME))
- .append("</name>\n");
+ p.append("<name>").append(JcrUtils.get(n, SLC_ + Constants.BUNDLE_NAME)).append("</name>\n");
if (n.hasProperty(SLC_ + Constants.BUNDLE_DESCRIPTION))
- p.append("<description>")
- .append(JcrUtils
- .get(n, SLC_ + Constants.BUNDLE_DESCRIPTION))
+ p.append("<description>").append(JcrUtils.get(n, SLC_ + Constants.BUNDLE_DESCRIPTION))
.append("</description>\n");
// Dependencies in case of a distribution
if (n.isNodeType(SlcTypes.SLC_MODULAR_DISTRIBUTION)) {
- p.append(getDependenciesSnippet(n.getNode(SlcNames.SLC_MODULES)
- .getNodes()));
- p.append(getDependencyManagementSnippet(n.getNode(
- SlcNames.SLC_MODULES).getNodes()));
+ p.append(getDependenciesSnippet(n.getNode(SlcNames.SLC_MODULES).getNodes()));
+ p.append(getDependencyManagementSnippet(n.getNode(SlcNames.SLC_MODULES).getNodes()));
}
p.append("</project>\n");
return p.toString();
}
- private String getDependenciesSnippet(NodeIterator nit)
- throws RepositoryException {
+ private String getDependenciesSnippet(NodeIterator nit) throws RepositoryException {
StringBuilder b = new StringBuilder();
b.append("<dependencies>\n");
while (nit.hasNext()) {
Node currModule = nit.nextNode();
if (currModule.isNodeType(SlcTypes.SLC_MODULE_COORDINATES)) {
- b.append(getDependencySnippet(
- currModule.getProperty(SlcNames.SLC_CATEGORY)
- .getString(),
- currModule.getProperty(SlcNames.SLC_NAME).getString(),
- null));
+ b.append(getDependencySnippet(currModule.getProperty(SlcNames.SLC_CATEGORY).getString(),
+ currModule.getProperty(SlcNames.SLC_NAME).getString(), null));
}
}
b.append("</dependencies>\n");
return b.toString();
}
- private String getDependencyManagementSnippet(NodeIterator nit)
- throws RepositoryException {
+ private String getDependencyManagementSnippet(NodeIterator nit) throws RepositoryException {
StringBuilder b = new StringBuilder();
b.append("<dependencyManagement>\n");
b.append("<dependencies>\n");
while (nit.hasNext()) {
Node currModule = nit.nextNode();
if (currModule.isNodeType(SlcTypes.SLC_MODULE_COORDINATES)) {
- b.append(getDependencySnippet(
- currModule.getProperty(SlcNames.SLC_CATEGORY)
- .getString(),
+ b.append(getDependencySnippet(currModule.getProperty(SlcNames.SLC_CATEGORY).getString(),
currModule.getProperty(SlcNames.SLC_NAME).getString(),
- currModule.getProperty(SlcNames.SLC_VERSION)
- .getString()));
+ currModule.getProperty(SlcNames.SLC_VERSION).getString()));
}
}
b.append("</dependencies>\n");
return b.toString();
}
- private String getDependencySnippet(String category, String name,
- String version) {
+ private String getDependencySnippet(String category, String name, String version) {
StringBuilder b = new StringBuilder();
b.append("<dependency>\n");
b.append("\t<groupId>").append(category).append("</groupId>\n");
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.SlcNames;
* from MANIFEST)
*/
public class JarFileIndexer implements NodeIndexer, SlcNames {
- private final static Log log = LogFactory.getLog(JarFileIndexer.class);
+ private final static CmsLog log = CmsLog.getLog(JarFileIndexer.class);
private Boolean force = false;
public Boolean support(String path) {
manifest.write(bo);
byte[] newManifest = bo.toByteArray();
if (fileNode.hasProperty(SLC_MANIFEST)) {
- byte[] storedManifest = JcrUtils.getBinaryAsBytes(fileNode
- .getProperty(SLC_MANIFEST));
+ byte[] storedManifest = JcrUtils.getBinaryAsBytes(fileNode.getProperty(SLC_MANIFEST));
if (Arrays.equals(newManifest, storedManifest)) {
if (log.isTraceEnabled())
- log.trace("Manifest not changed, doing nothing "
- + fileNode);
+ log.trace("Manifest not changed, doing nothing " + fileNode);
return;
}
}
}
- private void getI18nValues(Binary fileBinary, Attributes attrs)
- throws IOException {
+ private void getI18nValues(Binary fileBinary, Attributes attrs) throws IOException {
JarInputStream jarIn = null;
try {
jarIn = new JarInputStream(fileBinary.getStream());
browse: if (bundleLocalization != null) {
JarEntry entry = jarIn.getNextJarEntry();
while (entry != null) {
- if (entry.getName().equals(
- bundleLocalization + ".properties")) {
+ if (entry.getName().equals(bundleLocalization + ".properties")) {
jarEntry = entry;
// if(je.getSize() != -1){
}
}
} catch (RepositoryException e) {
- throw new SlcException(
- "Error while reading the jar binary content " + fileBinary,
- e);
+ throw new SlcException("Error while reading the jar binary content " + fileBinary, e);
} catch (IOException ioe) {
- throw new SlcException("unable to get internationalized values",
- ioe);
+ throw new SlcException("unable to get internationalized values", ioe);
} finally {
IOUtils.closeQuietly(jarIn);
}
}
- protected void addOsgiMetadata(Node fileNode, Attributes attrs)
- throws RepositoryException {
+ protected void addOsgiMetadata(Node fileNode, Attributes attrs) throws RepositoryException {
// TODO remove this ?
// Compulsory for the time being, because bundle artifact extends
addAttr(Constants.BUNDLE_LOCALIZATION, fileNode, attrs);
// required execution environment
- if (attrs.containsKey(new Name(
- Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT)))
- fileNode.setProperty(SlcNames.SLC_
- + Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT, attrs
- .getValue(Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT)
- .split(","));
+ if (attrs.containsKey(new Name(Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT)))
+ fileNode.setProperty(SlcNames.SLC_ + Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT,
+ attrs.getValue(Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT).split(","));
// bundle classpath
if (attrs.containsKey(new Name(Constants.BUNDLE_CLASSPATH)))
Version version = new Version(attrs.getValue(Constants.BUNDLE_VERSION));
fileNode.setProperty(SlcNames.SLC_BUNDLE_VERSION, version.toString());
cleanSubNodes(fileNode, SlcNames.SLC_ + Constants.BUNDLE_VERSION);
- Node bundleVersionNode = fileNode.addNode(SlcNames.SLC_
- + Constants.BUNDLE_VERSION, SlcTypes.SLC_OSGI_VERSION);
+ Node bundleVersionNode = fileNode.addNode(SlcNames.SLC_ + Constants.BUNDLE_VERSION, SlcTypes.SLC_OSGI_VERSION);
mapOsgiVersion(version, bundleVersionNode);
// fragment
if (attrs.containsKey(new Name(Constants.FRAGMENT_HOST))) {
String fragmentHost = attrs.getValue(Constants.FRAGMENT_HOST);
String[] tokens = fragmentHost.split(";");
- Node node = fileNode.addNode(SlcNames.SLC_
- + Constants.FRAGMENT_HOST, SlcTypes.SLC_FRAGMENT_HOST);
+ Node node = fileNode.addNode(SlcNames.SLC_ + Constants.FRAGMENT_HOST, SlcTypes.SLC_FRAGMENT_HOST);
node.setProperty(SlcNames.SLC_SYMBOLIC_NAME, tokens[0]);
for (int i = 1; i < tokens.length; i++) {
if (tokens[i].startsWith(Constants.BUNDLE_VERSION_ATTRIBUTE)) {
- node.setProperty(SlcNames.SLC_BUNDLE_VERSION,
- attributeValue(tokens[i]));
+ node.setProperty(SlcNames.SLC_BUNDLE_VERSION, attributeValue(tokens[i]));
}
}
}
List<String> packages = parseCommaSeparated(importPackages);
for (String pkg : packages) {
String[] tokens = pkg.split(";");
- Node node = fileNode.addNode(SlcNames.SLC_
- + Constants.IMPORT_PACKAGE,
- SlcTypes.SLC_IMPORTED_PACKAGE);
+ Node node = fileNode.addNode(SlcNames.SLC_ + Constants.IMPORT_PACKAGE, SlcTypes.SLC_IMPORTED_PACKAGE);
node.setProperty(SlcNames.SLC_NAME, tokens[0]);
for (int i = 1; i < tokens.length; i++) {
if (tokens[i].startsWith(Constants.VERSION_ATTRIBUTE)) {
- node.setProperty(SlcNames.SLC_VERSION,
- attributeValue(tokens[i]));
- } else if (tokens[i]
- .startsWith(Constants.RESOLUTION_DIRECTIVE)) {
- node.setProperty(
- SlcNames.SLC_OPTIONAL,
- directiveValue(tokens[i]).equals(
- Constants.RESOLUTION_OPTIONAL));
+ node.setProperty(SlcNames.SLC_VERSION, attributeValue(tokens[i]));
+ } else if (tokens[i].startsWith(Constants.RESOLUTION_DIRECTIVE)) {
+ node.setProperty(SlcNames.SLC_OPTIONAL,
+ directiveValue(tokens[i]).equals(Constants.RESOLUTION_OPTIONAL));
}
}
}
// dynamic import package
cleanSubNodes(fileNode, SlcNames.SLC_ + Constants.DYNAMICIMPORT_PACKAGE);
if (attrs.containsKey(new Name(Constants.DYNAMICIMPORT_PACKAGE))) {
- String importPackages = attrs
- .getValue(Constants.DYNAMICIMPORT_PACKAGE);
+ String importPackages = attrs.getValue(Constants.DYNAMICIMPORT_PACKAGE);
List<String> packages = parseCommaSeparated(importPackages);
for (String pkg : packages) {
String[] tokens = pkg.split(";");
- Node node = fileNode.addNode(SlcNames.SLC_
- + Constants.DYNAMICIMPORT_PACKAGE,
+ Node node = fileNode.addNode(SlcNames.SLC_ + Constants.DYNAMICIMPORT_PACKAGE,
SlcTypes.SLC_DYNAMIC_IMPORTED_PACKAGE);
node.setProperty(SlcNames.SLC_NAME, tokens[0]);
for (int i = 1; i < tokens.length; i++) {
if (tokens[i].startsWith(Constants.VERSION_ATTRIBUTE)) {
- node.setProperty(SlcNames.SLC_VERSION,
- attributeValue(tokens[i]));
+ node.setProperty(SlcNames.SLC_VERSION, attributeValue(tokens[i]));
}
}
}
List<String> packages = parseCommaSeparated(exportPackages);
for (String pkg : packages) {
String[] tokens = pkg.split(";");
- Node node = fileNode.addNode(SlcNames.SLC_
- + Constants.EXPORT_PACKAGE,
- SlcTypes.SLC_EXPORTED_PACKAGE);
+ Node node = fileNode.addNode(SlcNames.SLC_ + Constants.EXPORT_PACKAGE, SlcTypes.SLC_EXPORTED_PACKAGE);
node.setProperty(SlcNames.SLC_NAME, tokens[0]);
// TODO: are these cleans really necessary?
cleanSubNodes(node, SlcNames.SLC_USES);
for (int i = 1; i < tokens.length; i++) {
if (tokens[i].startsWith(Constants.VERSION_ATTRIBUTE)) {
String versionStr = attributeValue(tokens[i]);
- Node versionNode = node.addNode(SlcNames.SLC_VERSION,
- SlcTypes.SLC_OSGI_VERSION);
+ Node versionNode = node.addNode(SlcNames.SLC_VERSION, SlcTypes.SLC_OSGI_VERSION);
mapOsgiVersion(new Version(versionStr), versionNode);
} else if (tokens[i].startsWith(Constants.USES_DIRECTIVE)) {
String usedPackages = directiveValue(tokens[i]);
// log.debug("usedPackage='" +
// usedPackage +
// "'");
- Node usesNode = node.addNode(SlcNames.SLC_USES,
- SlcTypes.SLC_JAVA_PACKAGE);
+ Node usesNode = node.addNode(SlcNames.SLC_USES, SlcTypes.SLC_JAVA_PACKAGE);
usesNode.setProperty(SlcNames.SLC_NAME, usedPackage);
}
}
List<String> bundles = parseCommaSeparated(requireBundle);
for (String bundle : bundles) {
String[] tokens = bundle.split(";");
- Node node = fileNode.addNode(SlcNames.SLC_
- + Constants.REQUIRE_BUNDLE,
- SlcTypes.SLC_REQUIRED_BUNDLE);
+ Node node = fileNode.addNode(SlcNames.SLC_ + Constants.REQUIRE_BUNDLE, SlcTypes.SLC_REQUIRED_BUNDLE);
node.setProperty(SlcNames.SLC_SYMBOLIC_NAME, tokens[0]);
for (int i = 1; i < tokens.length; i++) {
- if (tokens[i]
- .startsWith(Constants.BUNDLE_VERSION_ATTRIBUTE)) {
- node.setProperty(SlcNames.SLC_BUNDLE_VERSION,
- attributeValue(tokens[i]));
- } else if (tokens[i]
- .startsWith(Constants.RESOLUTION_DIRECTIVE)) {
- node.setProperty(
- SlcNames.SLC_OPTIONAL,
- directiveValue(tokens[i]).equals(
- Constants.RESOLUTION_OPTIONAL));
+ if (tokens[i].startsWith(Constants.BUNDLE_VERSION_ATTRIBUTE)) {
+ node.setProperty(SlcNames.SLC_BUNDLE_VERSION, attributeValue(tokens[i]));
+ } else if (tokens[i].startsWith(Constants.RESOLUTION_DIRECTIVE)) {
+ node.setProperty(SlcNames.SLC_OPTIONAL,
+ directiveValue(tokens[i]).equals(Constants.RESOLUTION_OPTIONAL));
}
}
}
}
- private void addAttr(String key, Node node, Attributes attrs)
- throws RepositoryException {
+ private void addAttr(String key, Node node, Attributes attrs) throws RepositoryException {
addAttr(new Name(key), node, attrs);
}
- private void addAttr(Name key, Node node, Attributes attrs)
- throws RepositoryException {
+ private void addAttr(Name key, Node node, Attributes attrs) throws RepositoryException {
if (attrs.containsKey(key)) {
String value = attrs.getValue(key);
node.setProperty(SlcNames.SLC_ + key, value);
}
}
- private void cleanSubNodes(Node node, String name)
- throws RepositoryException {
+ private void cleanSubNodes(Node node, String name) throws RepositoryException {
if (node.hasNode(name)) {
NodeIterator nit = node.getNodes(name);
while (nit.hasNext())
return res;
}
- protected void mapOsgiVersion(Version version, Node versionNode)
- throws RepositoryException {
+ protected void mapOsgiVersion(Version version, Node versionNode) throws RepositoryException {
versionNode.setProperty(SlcNames.SLC_AS_STRING, version.toString());
versionNode.setProperty(SlcNames.SLC_MAJOR, version.getMajor());
versionNode.setProperty(SlcNames.SLC_MINOR, version.getMinor());
versionNode.setProperty(SlcNames.SLC_MICRO, version.getMicro());
if (!version.getQualifier().equals(""))
- versionNode.setProperty(SlcNames.SLC_QUALIFIER,
- version.getQualifier());
+ versionNode.setProperty(SlcNames.SLC_QUALIFIER, version.getQualifier());
}
public void setForce(Boolean force) {
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.CategoryNameVersion;
import org.argeo.slc.DefaultCategoryNameVersion;
* file contains a tag "dependencyManagement" that list all modules</li> </list>
*/
public class ModularDistributionIndexer implements NodeIndexer, SlcNames {
- private final static Log log = LogFactory.getLog(ModularDistributionIndexer.class);
+ private final static CmsLog log = CmsLog.getLog(ModularDistributionIndexer.class);
// Constants for csv indexing
private final static String INDEX_FILE_NAME = "modularDistribution.csv";
import javax.jcr.Session;
import org.apache.commons.io.FilenameUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.NameVersion;
import org.argeo.slc.SlcException;
* "...-sources.jar"
*/
public class PdeSourcesIndexer implements NodeIndexer {
- private Log log = LogFactory.getLog(PdeSourcesIndexer.class);
+ private CmsLog log = CmsLog.getLog(PdeSourcesIndexer.class);
private String artifactBasePath = RepoConstants.DEFAULT_ARTIFACTS_BASE_PATH;
package org.argeo.slc.repo;
-import org.argeo.api.NodeConstants;
+import org.argeo.api.cms.CmsConstants;
/** SLC repository constants */
public interface RepoConstants {
String SLC_CATEGORY_ID = "SLC-Category";
// TODO find a more generic way
- String DEFAULT_DEFAULT_WORKSPACE = NodeConstants.SYS_WORKSPACE;
+ String DEFAULT_DEFAULT_WORKSPACE = CmsConstants.SYS_WORKSPACE;
}
import javax.jcr.query.QueryResult;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.jcr.CmsJcrUtils;
import org.argeo.jcr.JcrMonitor;
import org.argeo.jcr.JcrUtils;
* we copy the content of the source workspace into the target one.
*/
public class RepoSync implements Runnable {
- private final static Log log = LogFactory.getLog(RepoSync.class);
+ private final static CmsLog log = CmsLog.getLog(RepoSync.class);
// Centralizes definition of workspaces that must be ignored by the sync.
private final static List<String> IGNORED_WKSP_LIST = Arrays.asList("security", "localrepo");
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.ArgeoNames;
import org.argeo.cms.ArgeoTypes;
import org.argeo.cms.jcr.CmsJcrUtils;
+import org.argeo.cms.security.Keyring;
import org.argeo.jcr.JcrMonitor;
import org.argeo.jcr.JcrUtils;
-import org.argeo.api.security.Keyring;
import org.argeo.slc.DefaultNameVersion;
import org.argeo.slc.NameVersion;
import org.argeo.slc.SlcException;
/** Utilities around repo */
public class RepoUtils implements ArgeoNames, SlcNames {
- private final static Log log = LogFactory.getLog(RepoUtils.class);
+ private final static CmsLog log = CmsLog.getLog(RepoUtils.class);
/** Packages a regular sources jar as PDE source. */
public static void packagesAsPdeSource(File sourceFile,
monitor.worked(1);
} catch (RepositoryException e) {
- throw new SlcException("Cannot copy " + fromNode + " to " + toNode,
- e);
+ throw new SlcException("Cannot copy " + fromNode + " to " + toNode, e);
}
}
import javax.jcr.RepositoryException;
import javax.jcr.Session;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcConstants;
import org.argeo.slc.SlcException;
/** Generic operations on a JCR-based repo. */
abstract class AbstractJcrRepoManager {
- private final static Log log = LogFactory
- .getLog(AbstractJcrRepoManager.class);
+ private final static CmsLog log = CmsLog.getLog(AbstractJcrRepoManager.class);
private String securityWorkspace = "security";
private Repository jcrRepository;
public void init() {
try {
adminSession = jcrRepository.login();
- String[] workspaceNames = adminSession.getWorkspace()
- .getAccessibleWorkspaceNames();
+ String[] workspaceNames = adminSession.getWorkspace().getAccessibleWorkspaceNames();
for (String workspaceName : workspaceNames) {
if (workspaceName.equals(securityWorkspace))
continue;
try {
try {
jcrRepository.login(workspaceName);
- throw new SlcException("Workspace " + workspaceName
- + " exists already.");
+ throw new SlcException("Workspace " + workspaceName + " exists already.");
} catch (NoSuchWorkspaceException e) {
// try to create workspace
adminSession.getWorkspace().createWorkspace(workspaceName);
workspaceInit(workspaceName);
}
} catch (RepositoryException e) {
- throw new SlcException("Cannot create workspace " + workspaceName,
- e);
+ throw new SlcException("Cannot create workspace " + workspaceName, e);
}
}
try {
workspaceAdminSession = jcrRepository.login(workspaceName);
workspaceSessions.put(workspaceName, adminSession);
- JcrUtils.addPrivilege(workspaceAdminSession, "/",
- SlcConstants.ROLE_SLC, "jcr:all");
- WorkspaceIndexer workspaceIndexer = new WorkspaceIndexer(
- workspaceAdminSession, nodeIndexers);
+ JcrUtils.addPrivilege(workspaceAdminSession, "/", SlcConstants.ROLE_SLC, "jcr:all");
+ WorkspaceIndexer workspaceIndexer = new WorkspaceIndexer(workspaceAdminSession, nodeIndexers);
workspaceIndexers.put(workspaceName, workspaceIndexer);
} catch (RepositoryException e) {
log.error("Cannot initialize workspace " + workspaceName, e);
import javax.jcr.RepositoryFactory;
import javax.jcr.Session;
-import org.argeo.api.security.Keyring;
+import org.argeo.cms.security.Keyring;
import org.argeo.slc.repo.RepoService;
import org.argeo.slc.repo.RepoUtils;
import javax.jcr.observation.EventIterator;
import javax.jcr.observation.EventListener;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.repo.NodeIndexer;
/** Maintains the metadata of a workspace, using listeners */
public class WorkspaceIndexer {
- private final static Log log = LogFactory.getLog(WorkspaceIndexer.class);
+ private final static CmsLog log = CmsLog.getLog(WorkspaceIndexer.class);
private final Session adminSession;
private IndexingListener artifactListener;
import java.util.regex.Pattern;
import org.apache.commons.io.FilenameUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.artifact.DefaultArtifact;
public static final Pattern SNAPSHOT_TIMESTAMP = Pattern
.compile("^(.*-)?([0-9]{8}.[0-9]{6}-[0-9]+)$");
- private final static Log log = LogFactory.getLog(AetherUtils.class);
+ private final static CmsLog log = CmsLog.getLog(AetherUtils.class);
/** Logs a dependency node and its transitive dependencies as a tree. */
public static void logDependencyNode(int depth,
import javax.jcr.RepositoryException;
import javax.jcr.Session;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrMonitor;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
* group.
*/
public class GenerateBinaries implements Runnable, SlcNames {
- private final static Log log = LogFactory.getLog(GenerateBinaries.class);
+ private final static CmsLog log = CmsLog.getLog(GenerateBinaries.class);
// Connection info
private Repository repository;
private List<String> excludedSuffixes = new ArrayList<String>();
// Indexes
- private Set<Artifact> binaries = new TreeSet<Artifact>(
- new ArtifactIdComparator());
- private Set<Artifact> sources = new TreeSet<Artifact>(
- new ArtifactIdComparator());
+ private Set<Artifact> binaries = new TreeSet<Artifact>(new ArtifactIdComparator());
+ private Set<Artifact> sources = new TreeSet<Artifact>(new ArtifactIdComparator());
// local cache
private ArtifactIndexer artifactIndexer = new ArtifactIndexer();
Session session = null;
try {
session = repository.login(credentials, workspace);
- Node groupNode = session.getNode(MavenConventionsUtils.groupPath(
- artifactBasePath, groupId));
+ Node groupNode = session.getNode(MavenConventionsUtils.groupPath(artifactBasePath, groupId));
internalPreProcessing(groupNode, null);
internalProcessing(groupNode, null);
} catch (Exception e) {
- throw new SlcException("Cannot normalize group " + groupId + " in "
- + workspace, e);
+ throw new SlcException("Cannot normalize group " + groupId + " in " + workspace, e);
} finally {
JcrUtils.logoutQuietly(session);
}
* Generates binaries-, sources- and sdk-version.pom artifacts for the given
* version (or the highest of all children version if none is precised).
*
- * By default, it includes each latest version of all artifact of this
- * group.
+ * By default, it includes each latest version of all artifact of this group.
*
* The 3 generated artifacts are then marked as modular distributions and
* indexed.
*/
- public static void processGroupNode(Node groupNode, String version,
- JcrMonitor monitor) throws RepositoryException {
+ public static void processGroupNode(Node groupNode, String version, JcrMonitor monitor) throws RepositoryException {
// TODO set artifactsBase based on group node
GenerateBinaries gb = new GenerateBinaries();
- String groupId = groupNode.getProperty(SlcNames.SLC_GROUP_BASE_ID)
- .getString();
+ String groupId = groupNode.getProperty(SlcNames.SLC_GROUP_BASE_ID).getString();
gb.setGroupId(groupId);
gb.setVersion(version);
// TODO use already done pre-processing
}
/** Only builds local indexes. Does not change anything in the local Session */
- public static GenerateBinaries preProcessGroupNode(Node groupNode,
- JcrMonitor monitor) throws RepositoryException {
+ public static GenerateBinaries preProcessGroupNode(Node groupNode, JcrMonitor monitor) throws RepositoryException {
// TODO set artifactsBase based on group node
GenerateBinaries gb = new GenerateBinaries();
- String groupId = groupNode.getProperty(SlcNames.SLC_GROUP_BASE_ID)
- .getString();
+ String groupId = groupNode.getProperty(SlcNames.SLC_GROUP_BASE_ID).getString();
gb.setGroupId(groupId);
// gb.setVersion(version);
// gb.setOverridePoms(overridePoms);
}
public Artifact getHighestArtifactVersion() throws RepositoryException {
- return allArtifactsHighestVersion == null ? null : RepoUtils
- .asArtifact(allArtifactsHighestVersion);
+ return allArtifactsHighestVersion == null ? null : RepoUtils.asArtifact(allArtifactsHighestVersion);
}
// //////////////////////////////////////
* Browse all children of a Node considered as a folder that follows Aether
* conventions i.e that has Aether's artifact base as children.
*
- * Each of such child contains a set of Aether artifact versions. This
- * methods build the binaries {@code Set<Artifact>} and other indexes. It
- * does not impact the
+ * Each of such child contains a set of Aether artifact versions. This methods
+ * build the binaries {@code Set<Artifact>} and other indexes. It does not
+ * impact the
*/
- protected void internalPreProcessing(Node groupNode, JcrMonitor monitor)
- throws RepositoryException {
+ protected void internalPreProcessing(Node groupNode, JcrMonitor monitor) throws RepositoryException {
if (monitor != null)
monitor.subTask("Pre processing group " + groupId);
// gathering latest versions of each artifact
allArtifactsHighestVersion = null;
- aBases: for (NodeIterator aBases = groupNode.getNodes(); aBases
- .hasNext();) {
+ aBases: for (NodeIterator aBases = groupNode.getNodes(); aBases.hasNext();) {
Node aBase = aBases.nextNode();
if (aBase.isNodeType(SlcTypes.SLC_ARTIFACT_BASE)) {
Node highestAVersion = getArtifactLatestVersion(aBase);
else {
// retrieve relevant child node
// Information is stored on the NT_FILE child node.
- for (NodeIterator files = highestAVersion.getNodes(); files
- .hasNext();) {
+ for (NodeIterator files = highestAVersion.getNodes(); files.hasNext();) {
Node file = files.nextNode();
if (file.isNodeType(SlcTypes.SLC_BUNDLE_ARTIFACT)) {
if (log.isDebugEnabled())
}
/** Does the real job : writes JCR META-DATA and generates binaries */
- protected void internalProcessing(Node groupNode, JcrMonitor monitor)
- throws RepositoryException {
+ protected void internalProcessing(Node groupNode, JcrMonitor monitor) throws RepositoryException {
if (monitor != null)
monitor.subTask("Processing group " + groupId);
// => the version can then be left empty
if (version == null || version.trim().equals(""))
if (allArtifactsHighestVersion != null)
- version = allArtifactsHighestVersion.getProperty(
- SLC_ARTIFACT_VERSION).getString();
+ version = allArtifactsHighestVersion.getProperty(SLC_ARTIFACT_VERSION).getString();
else
- throw new SlcException("Group version " + version
- + " is empty.");
+ throw new SlcException("Group version " + version + " is empty.");
// int bundleCount = symbolicNamesToNodes.size();
// int count = 1;
// }
// indexes
- Set<Artifact> indexes = new TreeSet<Artifact>(
- new ArtifactIdComparator());
+ Set<Artifact> indexes = new TreeSet<Artifact>(new ArtifactIdComparator());
Artifact indexArtifact;
- indexArtifact = writeIndex(session, RepoConstants.BINARIES_ARTIFACT_ID,
- binaries);
+ indexArtifact = writeIndex(session, RepoConstants.BINARIES_ARTIFACT_ID, binaries);
indexes.add(indexArtifact);
- indexArtifact = writeIndex(session, RepoConstants.SOURCES_ARTIFACT_ID,
- sources);
+ indexArtifact = writeIndex(session, RepoConstants.SOURCES_ARTIFACT_ID, sources);
indexes.add(indexArtifact);
// sdk
monitor.worked(1);
}
- protected void preProcessBundleArtifact(Node bundleNode)
- throws RepositoryException {
+ protected void preProcessBundleArtifact(Node bundleNode) throws RepositoryException {
String symbolicName = JcrUtils.get(bundleNode, SLC_SYMBOLIC_NAME);
// Sanity check.
// Manage source bundles
if (symbolicName.endsWith(".source")) {
// TODO make a shared node with classifier 'sources'?
- String bundleName = RepoUtils
- .extractBundleNameFromSourceName(symbolicName);
+ String bundleName = RepoUtils.extractBundleNameFromSourceName(symbolicName);
for (String excludedSuffix : excludedSuffixes) {
if (bundleName.endsWith(excludedSuffix))
return;// skip adding to sources
// Extra check. to remove
if (bundleNode.getSession().hasPendingChanges())
- throw new SlcException("Pending changes in the session, "
- + "this should not be true here.");
+ throw new SlcException("Pending changes in the session, " + "this should not be true here.");
}
// protected void processBundleArtifact(Node bundleNode)
// LOCAL WRITERS
//
- private Artifact writeIndex(Session session, String artifactId,
- Set<Artifact> artifacts) throws RepositoryException {
- Artifact artifact = new DefaultArtifact(groupId, artifactId, "pom",
- version);
- Artifact parentArtifact = parentPomCoordinates != null ? new DefaultArtifact(
- parentPomCoordinates) : null;
- String pom = MavenConventionsUtils.artifactsAsDependencyPom(artifact,
- artifacts, parentArtifact);
- Node node = RepoUtils.copyBytesAsArtifact(
- session.getNode(artifactBasePath), artifact, pom.getBytes());
+ private Artifact writeIndex(Session session, String artifactId, Set<Artifact> artifacts)
+ throws RepositoryException {
+ Artifact artifact = new DefaultArtifact(groupId, artifactId, "pom", version);
+ Artifact parentArtifact = parentPomCoordinates != null ? new DefaultArtifact(parentPomCoordinates) : null;
+ String pom = MavenConventionsUtils.artifactsAsDependencyPom(artifact, artifacts, parentArtifact);
+ Node node = RepoUtils.copyBytesAsArtifact(session.getNode(artifactBasePath), artifact, pom.getBytes());
artifactIndexer.index(node);
// TODO factorize
String pomSha = JcrUtils.checksumFile(node, "SHA-1");
- JcrUtils.copyBytesAsFile(node.getParent(), node.getName() + ".sha1",
- pomSha.getBytes());
+ JcrUtils.copyBytesAsFile(node.getParent(), node.getName() + ".sha1", pomSha.getBytes());
String pomMd5 = JcrUtils.checksumFile(node, "MD5");
- JcrUtils.copyBytesAsFile(node.getParent(), node.getName() + ".md5",
- pomMd5.getBytes());
+ JcrUtils.copyBytesAsFile(node.getParent(), node.getName() + ".md5", pomMd5.getBytes());
session.save();
return artifact;
}
private Node getArtifactLatestVersion(Node artifactBase) {
try {
Node highestAVersion = null;
- for (NodeIterator aVersions = artifactBase.getNodes(); aVersions
- .hasNext();) {
+ for (NodeIterator aVersions = artifactBase.getNodes(); aVersions.hasNext();) {
Node aVersion = aVersions.nextNode();
if (aVersion.isNodeType(SlcTypes.SLC_ARTIFACT_VERSION_BASE)) {
if (highestAVersion == null) {
if (currVersion.compareTo(currentHighestVersion) > 0) {
highestAVersion = aVersion;
}
- if (currVersion
- .compareTo(extractOsgiVersion(allArtifactsHighestVersion)) > 0) {
+ if (currVersion.compareTo(extractOsgiVersion(allArtifactsHighestVersion)) > 0) {
allArtifactsHighestVersion = aVersion;
}
}
}
return highestAVersion;
} catch (RepositoryException re) {
- throw new SlcException("Unable to get latest version for node "
- + artifactBase, re);
+ throw new SlcException("Unable to get latest version for node " + artifactBase, re);
}
}
- private Version extractOsgiVersion(Node artifactVersion)
- throws RepositoryException {
- String rawVersion = artifactVersion.getProperty(SLC_ARTIFACT_VERSION)
- .getString();
+ private Version extractOsgiVersion(Node artifactVersion) throws RepositoryException {
+ String rawVersion = artifactVersion.getProperty(SLC_ARTIFACT_VERSION).getString();
String cleanVersion = rawVersion.replace("-SNAPSHOT", ".SNAPSHOT");
Version osgiVersion = null;
// log invalid version value to enable tracking them
//
// // XML header
// p.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
- // p.append("<project xmlns=\"http://maven.apache.org/POM/4.0.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd\">\n");
+ // p.append("<project xmlns=\"http://maven.apache.org/POM/4.0.0\"
+ // xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"
+ // xsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0
+ // http://maven.apache.org/maven-v4_0_0.xsd\">\n");
// p.append("<modelVersion>4.0.0</modelVersion>");
//
// // Artifact
import javax.jcr.RepositoryException;
import javax.jcr.Session;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.SlcNames;
/** Create a distribution node from a set of artifacts */
public class IndexDistribution implements Runnable {
- private final static Log log = LogFactory.getLog(IndexDistribution.class);
+ private final static CmsLog log = CmsLog.getLog(IndexDistribution.class);
private Repository repository;
private String workspace;
import java.io.File;
import java.util.Set;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.eclipse.aether.artifact.Artifact;
/**
* based).
*/
public class MavenConventionsUtils {
- private final static Log log = LogFactory.getLog(MavenConventionsUtils.class);
+ private final static CmsLog log = CmsLog.getLog(MavenConventionsUtils.class);
/**
* Path to the file identified by this artifact <b>without</b> using Maven
import javax.jcr.security.AccessControlException;
import javax.jcr.security.Privilege;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.cms.ArgeoNames;
import org.argeo.jcr.JcrUtils;
import org.argeo.jcr.proxy.AbstractUrlProxy;
import org.eclipse.aether.repository.RemoteRepository;
/** Synchronises the node repository with remote Maven repositories */
-public class MavenProxyServiceImpl extends AbstractUrlProxy implements
- MavenProxyService, ArgeoNames, SlcNames {
- private final static Log log = LogFactory
- .getLog(MavenProxyServiceImpl.class);
+public class MavenProxyServiceImpl extends AbstractUrlProxy implements MavenProxyService, ArgeoNames, SlcNames {
+ private final static CmsLog log = CmsLog.getLog(MavenProxyServiceImpl.class);
private List<RemoteRepository> defaultRepositories = new ArrayList<RemoteRepository>();
/** Initialises the artifacts area. */
@Override
- protected void beforeInitSessionSave(Session session)
- throws RepositoryException {
+ protected void beforeInitSessionSave(Session session) throws RepositoryException {
JcrUtils.addPrivilege(session, "/", SlcConstants.USER_ANONYMOUS, Privilege.JCR_READ);
try {
- JcrUtils.addPrivilege(session, "/", SlcConstants.ROLE_SLC,
- Privilege.JCR_ALL);
+ JcrUtils.addPrivilege(session, "/", SlcConstants.ROLE_SLC, Privilege.JCR_ALL);
} catch (AccessControlException e) {
if (log.isTraceEnabled())
- log.trace("Cannot give jcr:all privileges to "
- + SlcConstants.ROLE_SLC);
+ log.trace("Cannot give jcr:all privileges to " + SlcConstants.ROLE_SLC);
}
JcrUtils.mkdirsSafe(session, RepoConstants.DEFAULT_ARTIFACTS_BASE_PATH);
- Node proxiedRepositories = JcrUtils.mkdirsSafe(session,
- RepoConstants.PROXIED_REPOSITORIES);
+ Node proxiedRepositories = JcrUtils.mkdirsSafe(session, RepoConstants.PROXIED_REPOSITORIES);
for (RemoteRepository repository : defaultRepositories) {
if (!proxiedRepositories.hasNode(repository.getId())) {
- Node proxiedRepository = proxiedRepositories.addNode(repository
- .getId());
+ Node proxiedRepository = proxiedRepositories.addNode(repository.getId());
proxiedRepository.addMixin(NodeType.MIX_REFERENCEABLE);
- JcrUtils.urlToAddressProperties(proxiedRepository,
- repository.getUrl());
+ JcrUtils.urlToAddressProperties(proxiedRepository, repository.getUrl());
// proxiedRepository.setProperty(SLC_URL, repository.getUrl());
- proxiedRepository.setProperty(SLC_TYPE,
- repository.getContentType());
+ proxiedRepository.setProperty(SLC_TYPE, repository.getContentType());
}
}
}
throw new SlcException("Session has pending changed");
Node node = null;
for (Node proxiedRepository : getBaseUrls(session)) {
- String baseUrl = JcrUtils
- .urlFromAddressProperties(proxiedRepository);
+ String baseUrl = JcrUtils.urlFromAddressProperties(proxiedRepository);
node = proxyUrl(session, baseUrl, path);
if (node != null) {
node.addMixin(SlcTypes.SLC_KNOWN_ORIGIN);
- Node origin = node
- .addNode(SLC_ORIGIN, SlcTypes.SLC_PROXIED);
+ Node origin = node.addNode(SLC_ORIGIN, SlcTypes.SLC_PROXIED);
origin.setProperty(SLC_PROXY, proxiedRepository);
JcrUtils.urlToAddressProperties(origin, baseUrl + path);
if (log.isDebugEnabled())
}
}
- protected synchronized List<Node> getBaseUrls(Session session)
- throws RepositoryException {
+ protected synchronized List<Node> getBaseUrls(Session session) throws RepositoryException {
List<Node> baseUrls = new ArrayList<Node>();
- for (NodeIterator nit = session.getNode(
- RepoConstants.PROXIED_REPOSITORIES).getNodes(); nit.hasNext();) {
+ for (NodeIterator nit = session.getNode(RepoConstants.PROXIED_REPOSITORIES).getNodes(); nit.hasNext();) {
Node proxiedRepository = nit.nextNode();
baseUrls.add(proxiedRepository);
}
return baseUrls;
}
- public void setDefaultRepositories(
- List<RemoteRepository> defaultRepositories) {
+ public void setDefaultRepositories(List<RemoteRepository> defaultRepositories) {
this.defaultRepositories = defaultRepositories;
}
}
import javax.jcr.query.qom.QueryObjectModelFactory;
import javax.jcr.query.qom.Selector;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.NameVersion;
import org.argeo.slc.SlcException;
*/
public class Migration_01_03 implements Runnable, SlcNames {
final String SPRING_SOURCE_PREFIX = "com.springsource";
- private final static Log log = LogFactory.getLog(Migration_01_03.class);
+ private final static CmsLog log = CmsLog.getLog(Migration_01_03.class);
private Repository repository;
private String sourceWorkspace;
private Session origSession;
private Session targetSession;
- private List<String> systemPackages = OsgiProfile.PROFILE_JAVA_SE_1_6
- .getSystemPackages();
+ private List<String> systemPackages = OsgiProfile.PROFILE_JAVA_SE_1_6.getSystemPackages();
private String artifactBasePath = "/";
private JarFileIndexer jarFileIndexer = new JarFileIndexer();
public void init() throws RepositoryException {
- origSession = JcrUtils.loginOrCreateWorkspace(repository,
- sourceWorkspace);
- targetSession = JcrUtils.loginOrCreateWorkspace(repository,
- targetWorkspace);
+ origSession = JcrUtils.loginOrCreateWorkspace(repository, sourceWorkspace);
+ targetSession = JcrUtils.loginOrCreateWorkspace(repository, targetWorkspace);
// works only in OSGi!!
// systemPackages = Arrays.asList(System.getProperty(
try {
// clear target
- NodeIterator nit = targetSession.getNode(artifactBasePath)
- .getNodes();
+ NodeIterator nit = targetSession.getNode(artifactBasePath).getNodes();
while (nit.hasNext()) {
Node node = nit.nextNode();
- if (node.isNodeType(NodeType.NT_FOLDER)
- || node.isNodeType(NodeType.NT_UNSTRUCTURED)) {
+ if (node.isNodeType(NodeType.NT_FOLDER) || node.isNodeType(NodeType.NT_UNSTRUCTURED)) {
node.remove();
node.getSession().save();
if (log.isDebugEnabled())
processOrigArtifactVersion(origArtifactNode);
}
} catch (Exception e) {
- throw new SlcException("Cannot perform v1.3 migration from "
- + sourceWorkspace + " to " + targetWorkspace, e);
+ throw new SlcException("Cannot perform v1.3 migration from " + sourceWorkspace + " to " + targetWorkspace,
+ e);
} finally {
JcrUtils.discardQuietly(targetSession);
}
}
- protected void processOrigArtifactVersion(Node origArtifactNode)
- throws RepositoryException, IOException {
+ protected void processOrigArtifactVersion(Node origArtifactNode) throws RepositoryException, IOException {
Artifact origArtifact = RepoUtils.asArtifact(origArtifactNode);
// skip eclipse artifacts
- if ((origArtifact.getGroupId().startsWith("org.eclipse") && !(origArtifact
- .getArtifactId().equals("org.eclipse.osgi")
- || origArtifact.getArtifactId().equals(
- "org.eclipse.osgi.source") || origArtifact
- .getArtifactId().startsWith("org.eclipse.rwt.widgets.upload")))
+ if ((origArtifact.getGroupId().startsWith("org.eclipse")
+ && !(origArtifact.getArtifactId().equals("org.eclipse.osgi")
+ || origArtifact.getArtifactId().equals("org.eclipse.osgi.source")
+ || origArtifact.getArtifactId().startsWith("org.eclipse.rwt.widgets.upload")))
|| origArtifact.getArtifactId().startsWith("com.ibm.icu")) {
if (log.isDebugEnabled())
log.debug("Skip " + origArtifact);
}
// skip SpringSource ActiveMQ
- if (origArtifact.getArtifactId().startsWith(
- "com.springsource.org.apache.activemq"))
+ if (origArtifact.getArtifactId().startsWith("com.springsource.org.apache.activemq"))
return;
- String origJarNodeName = MavenConventionsUtils
- .artifactFileName(origArtifact);
+ String origJarNodeName = MavenConventionsUtils.artifactFileName(origArtifact);
if (!origArtifactNode.hasNode(origJarNodeName))
- throw new SlcException("Cannot find jar node for "
- + origArtifactNode);
+ throw new SlcException("Cannot find jar node for " + origArtifactNode);
Node origJarNode = origArtifactNode.getNode(origJarNodeName);
// read MANIFEST
- Binary manifestBinary = origJarNode.getProperty(SLC_MANIFEST)
- .getBinary();
+ Binary manifestBinary = origJarNode.getProperty(SLC_MANIFEST).getBinary();
Manifest origManifest = new Manifest(manifestBinary.getStream());
JcrUtils.closeQuietly(manifestBinary);
Manifest targetManifest = new Manifest(origManifest);
// transform symbolic name
- String origSymbolicName = origManifest.getMainAttributes().getValue(
- Constants.BUNDLE_SYMBOLICNAME);
+ String origSymbolicName = origManifest.getMainAttributes().getValue(Constants.BUNDLE_SYMBOLICNAME);
final String targetSymbolicName;
if (symbolicNamesMapping.containsKey(origSymbolicName)) {
targetSymbolicName = symbolicNamesMapping.get(origSymbolicName);
} else if (origSymbolicName.startsWith(SPRING_SOURCE_PREFIX)
&& !origSymbolicName.equals(SPRING_SOURCE_PREFIX + ".json")) {
- targetSymbolicName = origSymbolicName
- .substring(SPRING_SOURCE_PREFIX.length() + 1);
+ targetSymbolicName = origSymbolicName.substring(SPRING_SOURCE_PREFIX.length() + 1);
} else {
targetSymbolicName = origSymbolicName;
}
if (!targetSymbolicName.equals(origSymbolicName)) {
- targetManifest.getMainAttributes().putValue(
- Constants.BUNDLE_SYMBOLICNAME, targetSymbolicName);
+ targetManifest.getMainAttributes().putValue(Constants.BUNDLE_SYMBOLICNAME, targetSymbolicName);
manifestModified = true;
if (log.isDebugEnabled())
- log.debug(Constants.BUNDLE_SYMBOLICNAME + " to "
- + targetSymbolicName + " \t\tfrom " + origSymbolicName);
+ log.debug(
+ Constants.BUNDLE_SYMBOLICNAME + " to " + targetSymbolicName + " \t\tfrom " + origSymbolicName);
}
// skip excluded bundles
return;
// check fragment host
- if (origManifest.getMainAttributes().containsKey(
- new Name(Constants.FRAGMENT_HOST))) {
- String origFragmentHost = origManifest.getMainAttributes()
- .getValue(Constants.FRAGMENT_HOST);
+ if (origManifest.getMainAttributes().containsKey(new Name(Constants.FRAGMENT_HOST))) {
+ String origFragmentHost = origManifest.getMainAttributes().getValue(Constants.FRAGMENT_HOST);
String targetFragmentHost;
if (symbolicNamesMapping.containsKey(origFragmentHost)) {
targetFragmentHost = symbolicNamesMapping.get(origFragmentHost);
} else if (origFragmentHost.startsWith(SPRING_SOURCE_PREFIX)
&& !origFragmentHost.equals(SPRING_SOURCE_PREFIX + ".json")) {
- targetFragmentHost = origFragmentHost
- .substring(SPRING_SOURCE_PREFIX.length() + 1);
- } else if (origFragmentHost
- .equals("org.argeo.dep.jacob;bundle-version=\"[1.14.3,1.14.4)\"")) {
+ targetFragmentHost = origFragmentHost.substring(SPRING_SOURCE_PREFIX.length() + 1);
+ } else if (origFragmentHost.equals("org.argeo.dep.jacob;bundle-version=\"[1.14.3,1.14.4)\"")) {
// this one for those who think I cannot be pragmatic - mbaudier
targetFragmentHost = "com.jacob;bundle-version=\"[1.14.3,1.14.4)\"";
} else {
}
if (!targetFragmentHost.equals(origFragmentHost)) {
- targetManifest.getMainAttributes().putValue(
- Constants.FRAGMENT_HOST, targetFragmentHost);
+ targetManifest.getMainAttributes().putValue(Constants.FRAGMENT_HOST, targetFragmentHost);
manifestModified = true;
if (log.isDebugEnabled())
- log.debug(Constants.FRAGMENT_HOST + " to "
- + targetFragmentHost + " from " + origFragmentHost);
+ log.debug(Constants.FRAGMENT_HOST + " to " + targetFragmentHost + " from " + origFragmentHost);
}
}
// javax with versions
StringBuffer targetImportPackages = new StringBuffer("");
- NodeIterator origImportPackages = origJarNode.getNodes(SLC_
- + Constants.IMPORT_PACKAGE);
+ NodeIterator origImportPackages = origJarNode.getNodes(SLC_ + Constants.IMPORT_PACKAGE);
Boolean importPackagesModified = false;
while (origImportPackages.hasNext()) {
Node importPackage = origImportPackages.nextNode();
String pkg = importPackage.getProperty(SLC_NAME).getString();
targetImportPackages.append(pkg);
if (importPackage.hasProperty(SLC_VERSION)) {
- String sourceVersion = importPackage.getProperty(SLC_VERSION)
- .getString();
+ String sourceVersion = importPackage.getProperty(SLC_VERSION).getString();
String targetVersion = sourceVersion;
if (systemPackages.contains(pkg)) {
- if (!(sourceVersion.trim().equals("0") || sourceVersion
- .trim().equals("0.0.0"))) {
+ if (!(sourceVersion.trim().equals("0") || sourceVersion.trim().equals("0.0.0"))) {
targetVersion = null;
importPackagesModified = true;
if (log.isDebugEnabled())
- log.debug(origSymbolicName
- + ": Nullify version of " + pkg + " from "
- + sourceVersion);
+ log.debug(origSymbolicName + ": Nullify version of " + pkg + " from " + sourceVersion);
}
}
if (targetVersion != null)
- targetImportPackages.append(";version=\"")
- .append(targetVersion).append("\"");
+ targetImportPackages.append(";version=\"").append(targetVersion).append("\"");
}
if (importPackage.hasProperty(SLC_OPTIONAL)) {
- Boolean optional = importPackage.getProperty(SLC_OPTIONAL)
- .getBoolean();
+ Boolean optional = importPackage.getProperty(SLC_OPTIONAL).getBoolean();
if (optional)
targetImportPackages.append(";resolution:=\"optional\"");
}
if (importPackagesModified) {
- targetManifest.getMainAttributes().putValue(
- Constants.IMPORT_PACKAGE, targetImportPackages.toString());
+ targetManifest.getMainAttributes().putValue(Constants.IMPORT_PACKAGE, targetImportPackages.toString());
manifestModified = true;
}
// target coordinates
final String targetGroupId;
- if (origArtifact.getArtifactId().startsWith(
- "org.eclipse.rwt.widgets.upload"))
+ if (origArtifact.getArtifactId().startsWith("org.eclipse.rwt.widgets.upload"))
targetGroupId = "org.argeo.tp.rap";
else if (origArtifact.getArtifactId().startsWith("org.polymap"))
targetGroupId = "org.argeo.tp.rap";
targetGroupId = "org.argeo.tp";
String targetArtifactId = targetSymbolicName.split(";")[0];
- Artifact targetArtifact = new DefaultArtifact(targetGroupId,
- targetArtifactId, "jar", origArtifact.getVersion());
- String targetParentPath = MavenConventionsUtils.artifactParentPath(
- artifactBasePath, targetArtifact);
- String targetFileName = MavenConventionsUtils
- .artifactFileName(targetArtifact);
+ Artifact targetArtifact = new DefaultArtifact(targetGroupId, targetArtifactId, "jar",
+ origArtifact.getVersion());
+ String targetParentPath = MavenConventionsUtils.artifactParentPath(artifactBasePath, targetArtifact);
+ String targetFileName = MavenConventionsUtils.artifactFileName(targetArtifact);
String targetJarPath = targetParentPath + '/' + targetFileName;
// copy
- Node targetParentNode = JcrUtils.mkfolders(targetSession,
- targetParentPath);
+ Node targetParentNode = JcrUtils.mkfolders(targetSession, targetParentPath);
targetSession.save();
if (manifestModified) {
- Binary origBinary = origJarNode.getNode(Node.JCR_CONTENT)
- .getProperty(Property.JCR_DATA).getBinary();
- byte[] targetJarBytes = RepoUtils.modifyManifest(
- origBinary.getStream(), targetManifest);
- JcrUtils.copyBytesAsFile(targetParentNode, targetFileName,
- targetJarBytes);
+ Binary origBinary = origJarNode.getNode(Node.JCR_CONTENT).getProperty(Property.JCR_DATA).getBinary();
+ byte[] targetJarBytes = RepoUtils.modifyManifest(origBinary.getStream(), targetManifest);
+ JcrUtils.copyBytesAsFile(targetParentNode, targetFileName, targetJarBytes);
JcrUtils.closeQuietly(origBinary);
} else {// just copy
- targetSession.getWorkspace().copy(sourceWorkspace,
- origJarNode.getPath(), targetJarPath);
+ targetSession.getWorkspace().copy(sourceWorkspace, origJarNode.getPath(), targetJarPath);
}
targetSession.save();
targetSession.save();
// sources
- Artifact origSourceArtifact = new DefaultArtifact(
- origArtifact.getGroupId(), origArtifact.getArtifactId()
- + ".source", "jar", origArtifact.getVersion());
- String origSourcePath = MavenConventionsUtils.artifactPath(
- artifactBasePath, origSourceArtifact);
+ Artifact origSourceArtifact = new DefaultArtifact(origArtifact.getGroupId(),
+ origArtifact.getArtifactId() + ".source", "jar", origArtifact.getVersion());
+ String origSourcePath = MavenConventionsUtils.artifactPath(artifactBasePath, origSourceArtifact);
if (origSession.itemExists(origSourcePath)) {
Node origSourceJarNode = origSession.getNode(origSourcePath);
- Artifact targetSourceArtifact = new DefaultArtifact(targetGroupId,
- targetArtifactId + ".source", "jar",
+ Artifact targetSourceArtifact = new DefaultArtifact(targetGroupId, targetArtifactId + ".source", "jar",
origArtifact.getVersion());
- String targetSourceParentPath = MavenConventionsUtils
- .artifactParentPath(artifactBasePath, targetSourceArtifact);
- String targetSourceFileName = MavenConventionsUtils
- .artifactFileName(targetSourceArtifact);
- String targetSourceJarPath = targetSourceParentPath + '/'
- + targetSourceFileName;
-
- Node targetSourceParentNode = JcrUtils.mkfolders(targetSession,
- targetSourceParentPath);
+ String targetSourceParentPath = MavenConventionsUtils.artifactParentPath(artifactBasePath,
+ targetSourceArtifact);
+ String targetSourceFileName = MavenConventionsUtils.artifactFileName(targetSourceArtifact);
+ String targetSourceJarPath = targetSourceParentPath + '/' + targetSourceFileName;
+
+ Node targetSourceParentNode = JcrUtils.mkfolders(targetSession, targetSourceParentPath);
targetSession.save();
if (!targetSymbolicName.equals(origSymbolicName)) {
- Binary origBinary = origSourceJarNode.getNode(Node.JCR_CONTENT)
- .getProperty(Property.JCR_DATA).getBinary();
- NameVersion targetNameVersion = RepoUtils
- .readNameVersion(targetManifest);
- byte[] targetJarBytes = RepoUtils.packageAsPdeSource(
- origBinary.getStream(), targetNameVersion);
- JcrUtils.copyBytesAsFile(targetSourceParentNode,
- targetSourceFileName, targetJarBytes);
+ Binary origBinary = origSourceJarNode.getNode(Node.JCR_CONTENT).getProperty(Property.JCR_DATA)
+ .getBinary();
+ NameVersion targetNameVersion = RepoUtils.readNameVersion(targetManifest);
+ byte[] targetJarBytes = RepoUtils.packageAsPdeSource(origBinary.getStream(), targetNameVersion);
+ JcrUtils.copyBytesAsFile(targetSourceParentNode, targetSourceFileName, targetJarBytes);
JcrUtils.closeQuietly(origBinary);
} else {// just copy
- targetSession.getWorkspace().copy(sourceWorkspace,
- origSourceJarNode.getPath(), targetSourceJarPath);
+ targetSession.getWorkspace().copy(sourceWorkspace, origSourceJarNode.getPath(), targetSourceJarPath);
}
targetSession.save();
// reindex
- Node targetSourceJarNode = targetSession
- .getNode(targetSourceJarPath);
+ Node targetSourceJarNode = targetSession.getNode(targetSourceJarPath);
artifactIndexer.index(targetSourceJarNode);
jarFileIndexer.index(targetSourceJarNode);
* UTILITIES
*/
- static NodeIterator listArtifactVersions(Session session)
- throws RepositoryException {
+ static NodeIterator listArtifactVersions(Session session) throws RepositoryException {
QueryManager queryManager = session.getWorkspace().getQueryManager();
QueryObjectModelFactory factory = queryManager.getQOMFactory();
final String artifactVersionsSelector = "artifactVersions";
- Selector source = factory.selector(SlcTypes.SLC_ARTIFACT_VERSION_BASE,
- artifactVersionsSelector);
+ Selector source = factory.selector(SlcTypes.SLC_ARTIFACT_VERSION_BASE, artifactVersionsSelector);
- Ordering orderByArtifactId = factory.ascending(factory.propertyValue(
- artifactVersionsSelector, SlcNames.SLC_ARTIFACT_ID));
+ Ordering orderByArtifactId = factory
+ .ascending(factory.propertyValue(artifactVersionsSelector, SlcNames.SLC_ARTIFACT_ID));
Ordering[] orderings = { orderByArtifactId };
- QueryObjectModel query = factory.createQuery(source, null, orderings,
- null);
+ QueryObjectModel query = factory.createQuery(source, null, orderings, null);
QueryResult result = query.execute();
return result.getNodes();
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.repo.OsgiFactory;
public class ArchiveSourcesProvider implements SourcesProvider {
- private final static Log log = LogFactory
- .getLog(ArchiveSourcesProvider.class);
+ private final static CmsLog log = CmsLog.getLog(ArchiveSourcesProvider.class);
private OsgiFactory osgiFactory;
private String uri;
log.debug("Wrapping " + uri);
Node distNode = osgiFactory.getDist(distSession, uri);
- zin = new ZipInputStream(distNode.getNode(Node.JCR_CONTENT)
- .getProperty(Property.JCR_DATA).getBinary().getStream());
+ zin = new ZipInputStream(
+ distNode.getNode(Node.JCR_CONTENT).getProperty(Property.JCR_DATA).getBinary().getStream());
// prepare
Set<String> directories = new TreeSet<String>();
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.CategoryNameVersion;
import org.argeo.slc.DefaultNameVersion;
* need further modification.
*/
public class ArchiveWrapper implements Runnable, ModuleSet, Distribution {
- private final static Log log = LogFactory.getLog(ArchiveWrapper.class);
+ private final static CmsLog log = CmsLog.getLog(ArchiveWrapper.class);
private OsgiFactory osgiFactory;
private String version;
import java.util.TreeMap;
import java.util.TreeSet;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.CategoryNameVersion;
import org.argeo.slc.ModuleSet;
import org.argeo.slc.NameVersion;
* A consistent and versioned OSGi distribution, which can be built and tested.
*/
public class ArgeoOsgiDistributionImpl extends ArtifactDistribution implements ArgeoOsgiDistribution {
- private final static Log log = LogFactory.getLog(ArgeoOsgiDistributionImpl.class);
+ private final static CmsLog log = CmsLog.getLog(ArgeoOsgiDistributionImpl.class);
private List<Object> modules = new ArrayList<Object>();
import java.util.jar.Manifest;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.CategoryNameVersion;
import org.argeo.slc.SlcException;
import org.argeo.slc.build.Distribution;
/** Utilities around the BND library, which manipulates OSGi metadata. */
public class BndWrapper implements Constants, CategoryNameVersion, Distribution {
- private final static Log log = LogFactory.getLog(BndWrapper.class);
+ private final static CmsLog log = CmsLog.getLog(BndWrapper.class);
private String groupId;
private String name;
import javax.jcr.Session;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.NameVersion;
import org.argeo.slc.SlcException;
*/
@Deprecated
public class ImportBundlesZip implements Runnable {
- private final static Log log = LogFactory.getLog(ImportBundlesZip.class);
+ private final static CmsLog log = CmsLog.getLog(ImportBundlesZip.class);
private Repository repository;
private String workspace;
private String groupId;
ZipEntry zipEntry = null;
entries: while ((zipEntry = zipIn.getNextEntry()) != null) {
String entryName = zipEntry.getName();
- if (!entryName.endsWith(".jar")
- || entryName.contains("feature"))
+ if (!entryName.endsWith(".jar") || entryName.contains("feature"))
continue entries;// skip
byte[] jarBytes = IOUtils.toByteArray(zipIn);
zipIn.closeEntry();
continue entries;
}
- String bundleName = RepoUtils
- .extractBundleNameFromSourceName(nv.getName());
+ String bundleName = RepoUtils.extractBundleNameFromSourceName(nv.getName());
// skip excluded bundles and their sources
if (excludedBundles.contains(bundleName))
continue entries;
// continue entries;
// }
- Artifact artifact = new DefaultArtifact(groupId, nv.getName(),
- "jar", nv.getVersion());
- Node artifactNode = RepoUtils.copyBytesAsArtifact(
- session.getNode(artifactBasePath), artifact, jarBytes);
+ Artifact artifact = new DefaultArtifact(groupId, nv.getName(), "jar", nv.getVersion());
+ Node artifactNode = RepoUtils.copyBytesAsArtifact(session.getNode(artifactBasePath), artifact,
+ jarBytes);
jarBytes = null;// superstition, in order to free memory
// indexes
log.debug("Imported " + entryName + " to " + artifactNode);
}
} catch (Exception e) {
- throw new SlcException("Cannot import zip " + zipFile + " to "
- + workspace, e);
+ throw new SlcException("Cannot import zip " + zipFile + " to " + workspace, e);
} finally {
IOUtils.closeQuietly(zipIn);
IOUtils.closeQuietly(jarIn);
import javax.jcr.Session;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.DefaultNameVersion;
import org.argeo.slc.SlcException;
* repositories.
*/
public class MavenWrapper extends BndWrapper implements Runnable {
- private final static Log log = LogFactory.getLog(MavenWrapper.class);
+ private final static CmsLog log = CmsLog.getLog(MavenWrapper.class);
private String sourceCoords;
import javax.jcr.Session;
import org.apache.commons.io.FilenameUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrMonitor;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
*/
@Deprecated
public class NormalizeGroup implements Runnable, SlcNames {
- private final static Log log = LogFactory.getLog(NormalizeGroup.class);
+ private final static CmsLog log = CmsLog.getLog(NormalizeGroup.class);
private Repository repository;
private String workspace;
// private JarFileIndexer jarFileIndexer = new JarFileIndexer();
/** TODO make it more generic */
- private List<String> systemPackages = OsgiProfile.PROFILE_JAVA_SE_1_6
- .getSystemPackages();
+ private List<String> systemPackages = OsgiProfile.PROFILE_JAVA_SE_1_6.getSystemPackages();
// indexes
private Map<String, String> packagesToSymbolicNames = new HashMap<String, String>();
private Map<String, Node> symbolicNamesToNodes = new HashMap<String, Node>();
- private Set<Artifact> binaries = new TreeSet<Artifact>(
- new ArtifactIdComparator());
- private Set<Artifact> sources = new TreeSet<Artifact>(
- new ArtifactIdComparator());
+ private Set<Artifact> binaries = new TreeSet<Artifact>(new ArtifactIdComparator());
+ private Set<Artifact> sources = new TreeSet<Artifact>(new ArtifactIdComparator());
public void run() {
Session session = null;
try {
session = repository.login(workspace);
- Node groupNode = session.getNode(MavenConventionsUtils.groupPath(
- artifactBasePath, groupId));
+ Node groupNode = session.getNode(MavenConventionsUtils.groupPath(artifactBasePath, groupId));
processGroupNode(groupNode, null);
} catch (Exception e) {
- throw new SlcException("Cannot normalize group " + groupId + " in "
- + workspace, e);
+ throw new SlcException("Cannot normalize group " + groupId + " in " + workspace, e);
} finally {
JcrUtils.logoutQuietly(session);
}
}
- public static void processGroupNode(Node groupNode, String version,
- Boolean overridePoms, JcrMonitor monitor)
+ public static void processGroupNode(Node groupNode, String version, Boolean overridePoms, JcrMonitor monitor)
throws RepositoryException {
// TODO set artifactsBase based on group node
NormalizeGroup ng = new NormalizeGroup();
- String groupId = groupNode.getProperty(SlcNames.SLC_GROUP_BASE_ID)
- .getString();
+ String groupId = groupNode.getProperty(SlcNames.SLC_GROUP_BASE_ID).getString();
ng.setGroupId(groupId);
ng.setVersion(version);
ng.setOverridePoms(overridePoms);
ng.processGroupNode(groupNode, monitor);
}
- protected void processGroupNode(Node groupNode, JcrMonitor monitor)
- throws RepositoryException {
+ protected void processGroupNode(Node groupNode, JcrMonitor monitor) throws RepositoryException {
if (monitor != null)
monitor.subTask("Group " + groupId);
Node allArtifactsHighestVersion = null;
Session session = groupNode.getSession();
- aBases: for (NodeIterator aBases = groupNode.getNodes(); aBases
- .hasNext();) {
+ aBases: for (NodeIterator aBases = groupNode.getNodes(); aBases.hasNext();) {
Node aBase = aBases.nextNode();
if (aBase.isNodeType(SlcTypes.SLC_ARTIFACT_BASE)) {
Node highestAVersion = null;
- for (NodeIterator aVersions = aBase.getNodes(); aVersions
- .hasNext();) {
+ for (NodeIterator aVersions = aBase.getNodes(); aVersions.hasNext();) {
Node aVersion = aVersions.nextNode();
if (aVersion.isNodeType(SlcTypes.SLC_ARTIFACT_VERSION_BASE)) {
if (highestAVersion == null) {
if (currVersion.compareTo(currentHighestVersion) > 0) {
highestAVersion = aVersion;
}
- if (currVersion
- .compareTo(extractOsgiVersion(allArtifactsHighestVersion)) > 0) {
+ if (currVersion.compareTo(extractOsgiVersion(allArtifactsHighestVersion)) > 0) {
allArtifactsHighestVersion = aVersion;
}
}
}
if (highestAVersion == null)
continue aBases;
- for (NodeIterator files = highestAVersion.getNodes(); files
- .hasNext();) {
+ for (NodeIterator files = highestAVersion.getNodes(); files.hasNext();) {
Node file = files.nextNode();
if (file.isNodeType(SlcTypes.SLC_BUNDLE_ARTIFACT)) {
preProcessBundleArtifact(file);
// => the version can then be left empty
if (version == null || version.trim().equals(""))
if (allArtifactsHighestVersion != null)
- version = allArtifactsHighestVersion.getProperty(
- SLC_ARTIFACT_VERSION).getString();
+ version = allArtifactsHighestVersion.getProperty(SLC_ARTIFACT_VERSION).getString();
else
version = "0.0";
// throw new SlcException("Group version " + version
processBundleArtifact(bundleNode);
bundleNode.getSession().save();
if (log.isDebugEnabled())
- log.debug(count + "/" + bundleCount + " Processed "
- + bundleNode.getName());
+ log.debug(count + "/" + bundleCount + " Processed " + bundleNode.getName());
count++;
}
// indexes
- Set<Artifact> indexes = new TreeSet<Artifact>(
- new ArtifactIdComparator());
- Artifact indexArtifact = writeIndex(session,
- RepoConstants.BINARIES_ARTIFACT_ID, binaries);
+ Set<Artifact> indexes = new TreeSet<Artifact>(new ArtifactIdComparator());
+ Artifact indexArtifact = writeIndex(session, RepoConstants.BINARIES_ARTIFACT_ID, binaries);
indexes.add(indexArtifact);
- indexArtifact = writeIndex(session, RepoConstants.SOURCES_ARTIFACT_ID,
- sources);
+ indexArtifact = writeIndex(session, RepoConstants.SOURCES_ARTIFACT_ID, sources);
indexes.add(indexArtifact);
// sdk
writeIndex(session, RepoConstants.SDK_ARTIFACT_ID, indexes);
monitor.worked(1);
}
- private Version extractOsgiVersion(Node artifactVersion)
- throws RepositoryException {
- String rawVersion = artifactVersion.getProperty(SLC_ARTIFACT_VERSION)
- .getString();
+ private Version extractOsgiVersion(Node artifactVersion) throws RepositoryException {
+ String rawVersion = artifactVersion.getProperty(SLC_ARTIFACT_VERSION).getString();
String cleanVersion = rawVersion.replace("-SNAPSHOT", ".SNAPSHOT");
Version osgiVersion = null;
// log invalid version value to enable tracking them
return tmpVersion;
}
- private Artifact writeIndex(Session session, String artifactId,
- Set<Artifact> artifacts) throws RepositoryException {
- Artifact artifact = new DefaultArtifact(groupId, artifactId, "pom",
- version);
- Artifact parentArtifact = parentPomCoordinates != null ? new DefaultArtifact(
- parentPomCoordinates) : null;
- String pom = MavenConventionsUtils.artifactsAsDependencyPom(artifact,
- artifacts, parentArtifact);
- Node node = RepoUtils.copyBytesAsArtifact(
- session.getNode(artifactBasePath), artifact, pom.getBytes());
+ private Artifact writeIndex(Session session, String artifactId, Set<Artifact> artifacts)
+ throws RepositoryException {
+ Artifact artifact = new DefaultArtifact(groupId, artifactId, "pom", version);
+ Artifact parentArtifact = parentPomCoordinates != null ? new DefaultArtifact(parentPomCoordinates) : null;
+ String pom = MavenConventionsUtils.artifactsAsDependencyPom(artifact, artifacts, parentArtifact);
+ Node node = RepoUtils.copyBytesAsArtifact(session.getNode(artifactBasePath), artifact, pom.getBytes());
artifactIndexer.index(node);
// TODO factorize
String pomSha = JcrUtils.checksumFile(node, "SHA-1");
- JcrUtils.copyBytesAsFile(node.getParent(), node.getName() + ".sha1",
- pomSha.getBytes());
+ JcrUtils.copyBytesAsFile(node.getParent(), node.getName() + ".sha1", pomSha.getBytes());
String pomMd5 = JcrUtils.checksumFile(node, "MD5");
- JcrUtils.copyBytesAsFile(node.getParent(), node.getName() + ".md5",
- pomMd5.getBytes());
+ JcrUtils.copyBytesAsFile(node.getParent(), node.getName() + ".md5", pomMd5.getBytes());
session.save();
return artifact;
}
- protected void preProcessBundleArtifact(Node bundleNode)
- throws RepositoryException {
+ protected void preProcessBundleArtifact(Node bundleNode) throws RepositoryException {
String symbolicName = JcrUtils.get(bundleNode, SLC_SYMBOLIC_NAME);
if (symbolicName.endsWith(".source")) {
// TODO make a shared node with classifier 'sources'?
- String bundleName = RepoUtils
- .extractBundleNameFromSourceName(symbolicName);
+ String bundleName = RepoUtils.extractBundleNameFromSourceName(symbolicName);
for (String excludedSuffix : excludedSuffixes) {
if (bundleName.endsWith(excludedSuffix))
return;// skip adding to sources
return;
}
- NodeIterator exportPackages = bundleNode.getNodes(SLC_
- + Constants.EXPORT_PACKAGE);
+ NodeIterator exportPackages = bundleNode.getNodes(SLC_ + Constants.EXPORT_PACKAGE);
while (exportPackages.hasNext()) {
Node exportPackage = exportPackages.nextNode();
String pkg = JcrUtils.get(exportPackage, SLC_NAME);
bundleNode.getSession().save();
}
- protected void processBundleArtifact(Node bundleNode)
- throws RepositoryException {
+ protected void processBundleArtifact(Node bundleNode) throws RepositoryException {
Node artifactFolder = bundleNode.getParent();
String baseName = FilenameUtils.getBaseName(bundleNode.getName());
return;// skip
String pom = generatePomForBundle(bundleNode);
- Node pomNode = JcrUtils.copyBytesAsFile(artifactFolder, pomName,
- pom.getBytes());
+ Node pomNode = JcrUtils.copyBytesAsFile(artifactFolder, pomName, pom.getBytes());
// checksum
String bundleSha = JcrUtils.checksumFile(bundleNode, "SHA-1");
- JcrUtils.copyBytesAsFile(artifactFolder,
- bundleNode.getName() + ".sha1", bundleSha.getBytes());
+ JcrUtils.copyBytesAsFile(artifactFolder, bundleNode.getName() + ".sha1", bundleSha.getBytes());
String pomSha = JcrUtils.checksumFile(pomNode, "SHA-1");
- JcrUtils.copyBytesAsFile(artifactFolder, pomNode.getName() + ".sha1",
- pomSha.getBytes());
+ JcrUtils.copyBytesAsFile(artifactFolder, pomNode.getName() + ".sha1", pomSha.getBytes());
}
private String generatePomForBundle(Node n) throws RepositoryException {
// XML header
p.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
- p.append("<project xmlns=\"http://maven.apache.org/POM/4.0.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd\">\n");
+ p.append(
+ "<project xmlns=\"http://maven.apache.org/POM/4.0.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd\">\n");
p.append("<modelVersion>4.0.0</modelVersion>");
// Artifact
- p.append("<groupId>").append(JcrUtils.get(n, SLC_GROUP_ID))
- .append("</groupId>\n");
- p.append("<artifactId>").append(JcrUtils.get(n, SLC_ARTIFACT_ID))
- .append("</artifactId>\n");
- p.append("<version>").append(JcrUtils.get(n, SLC_ARTIFACT_VERSION))
- .append("</version>\n");
+ p.append("<groupId>").append(JcrUtils.get(n, SLC_GROUP_ID)).append("</groupId>\n");
+ p.append("<artifactId>").append(JcrUtils.get(n, SLC_ARTIFACT_ID)).append("</artifactId>\n");
+ p.append("<version>").append(JcrUtils.get(n, SLC_ARTIFACT_VERSION)).append("</version>\n");
p.append("<packaging>pom</packaging>\n");
if (n.hasProperty(SLC_ + Constants.BUNDLE_NAME))
- p.append("<name>")
- .append(JcrUtils.get(n, SLC_ + Constants.BUNDLE_NAME))
- .append("</name>\n");
+ p.append("<name>").append(JcrUtils.get(n, SLC_ + Constants.BUNDLE_NAME)).append("</name>\n");
if (n.hasProperty(SLC_ + Constants.BUNDLE_DESCRIPTION))
- p.append("<description>")
- .append(JcrUtils
- .get(n, SLC_ + Constants.BUNDLE_DESCRIPTION))
+ p.append("<description>").append(JcrUtils.get(n, SLC_ + Constants.BUNDLE_DESCRIPTION))
.append("</description>\n");
// Dependencies
Set<String> dependenciesSymbolicNames = new TreeSet<String>();
Set<String> optionalSymbolicNames = new TreeSet<String>();
- NodeIterator importPackages = n.getNodes(SLC_
- + Constants.IMPORT_PACKAGE);
+ NodeIterator importPackages = n.getNodes(SLC_ + Constants.IMPORT_PACKAGE);
while (importPackages.hasNext()) {
Node importPackage = importPackages.nextNode();
String pkg = JcrUtils.get(importPackage, SLC_NAME);
if (packagesToSymbolicNames.containsKey(pkg)) {
- String dependencySymbolicName = packagesToSymbolicNames
- .get(pkg);
+ String dependencySymbolicName = packagesToSymbolicNames.get(pkg);
if (JcrUtils.check(importPackage, SLC_OPTIONAL))
optionalSymbolicNames.add(dependencySymbolicName);
else
dependenciesSymbolicNames.add(dependencySymbolicName);
} else {
- if (!JcrUtils.check(importPackage, SLC_OPTIONAL)
- && !systemPackages.contains(pkg))
+ if (!JcrUtils.check(importPackage, SLC_OPTIONAL) && !systemPackages.contains(pkg))
log.warn("No bundle found for pkg " + pkg);
}
}
if (n.hasNode(SLC_ + Constants.FRAGMENT_HOST)) {
- String fragmentHost = JcrUtils.get(
- n.getNode(SLC_ + Constants.FRAGMENT_HOST),
- SLC_SYMBOLIC_NAME);
+ String fragmentHost = JcrUtils.get(n.getNode(SLC_ + Constants.FRAGMENT_HOST), SLC_SYMBOLIC_NAME);
dependenciesSymbolicNames.add(fragmentHost);
}
List<Node> optionalDependencyNodes = new ArrayList<Node>();
for (String depSymbName : optionalSymbolicNames) {
if (symbolicNamesToNodes.containsKey(depSymbName))
- optionalDependencyNodes.add(symbolicNamesToNodes
- .get(depSymbName));
+ optionalDependencyNodes.add(symbolicNamesToNodes.get(depSymbName));
else
log.warn("Could not find node for " + depSymbName);
}
p.append("<dependencies>\n");
for (Node dependencyNode : dependencyNodes) {
p.append("<dependency>\n");
- p.append("\t<groupId>")
- .append(JcrUtils.get(dependencyNode, SLC_GROUP_ID))
- .append("</groupId>\n");
- p.append("\t<artifactId>")
- .append(JcrUtils.get(dependencyNode, SLC_ARTIFACT_ID))
- .append("</artifactId>\n");
+ p.append("\t<groupId>").append(JcrUtils.get(dependencyNode, SLC_GROUP_ID)).append("</groupId>\n");
+ p.append("\t<artifactId>").append(JcrUtils.get(dependencyNode, SLC_ARTIFACT_ID)).append("</artifactId>\n");
p.append("</dependency>\n");
}
p.append("<!-- OPTIONAL -->\n");
for (Node dependencyNode : optionalDependencyNodes) {
p.append("<dependency>\n");
- p.append("\t<groupId>")
- .append(JcrUtils.get(dependencyNode, SLC_GROUP_ID))
- .append("</groupId>\n");
- p.append("\t<artifactId>")
- .append(JcrUtils.get(dependencyNode, SLC_ARTIFACT_ID))
- .append("</artifactId>\n");
+ p.append("\t<groupId>").append(JcrUtils.get(dependencyNode, SLC_GROUP_ID)).append("</groupId>\n");
+ p.append("\t<artifactId>").append(JcrUtils.get(dependencyNode, SLC_ARTIFACT_ID)).append("</artifactId>\n");
p.append("\t<optional>true</optional>\n");
p.append("</dependency>\n");
}
p.append("<dependencies>\n");
p.append("<dependency>\n");
p.append("\t<groupId>").append(groupId).append("</groupId>\n");
- p.append("\t<artifactId>")
- .append(ownSymbolicName.endsWith(".source") ? RepoConstants.SOURCES_ARTIFACT_ID
- : RepoConstants.BINARIES_ARTIFACT_ID)
- .append("</artifactId>\n");
+ p.append("\t<artifactId>").append(ownSymbolicName.endsWith(".source") ? RepoConstants.SOURCES_ARTIFACT_ID
+ : RepoConstants.BINARIES_ARTIFACT_ID).append("</artifactId>\n");
p.append("\t<version>").append(version).append("</version>\n");
p.append("\t<type>pom</type>\n");
p.append("\t<scope>import</scope>\n");
import javax.jcr.security.Privilege;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcConstants;
import org.argeo.slc.SlcException;
/** Default implementation of {@link OsgiFactory}. */
public class OsgiFactoryImpl implements OsgiFactory, SlcNames {
- private final static Log log = LogFactory.getLog(OsgiFactoryImpl.class);
+ private final static CmsLog log = CmsLog.getLog(OsgiFactoryImpl.class);
private String workspace;
private Repository distRepository;
public class OsgiProfile {
public final static String PROP_SYSTEM_PACKAGES = "org.osgi.framework.system.packages";
- public final static OsgiProfile PROFILE_JAVA_SE_1_6 = new OsgiProfile(
- "JavaSE-1.6.profile");
+ public final static OsgiProfile PROFILE_JAVA_SE_1_6 = new OsgiProfile("JavaSE-1.6.profile");
private final URL url;
private final Properties properties;
}
public OsgiProfile(String name) {
- this(OsgiProfile.class.getClassLoader().getResource(
- '/'
- + OsgiProfile.class.getPackage().getName()
- .replace('.', '/') + '/' + name));
+ this(OsgiProfile.class.getClassLoader()
+ .getResource('/' + OsgiProfile.class.getPackage().getName().replace('.', '/') + '/' + name));
}
public List<String> getSystemPackages() {
- String[] splitted = properties.getProperty(PROP_SYSTEM_PACKAGES).split(
- ",");
+ String[] splitted = properties.getProperty(PROP_SYSTEM_PACKAGES).split(",");
List<String> res = new ArrayList<String>();
for (String pkg : splitted) {
res.add(pkg.trim());
import javax.jcr.RepositoryException;
import javax.jcr.Session;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.CategoryNameVersion;
import org.argeo.slc.NameVersion;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.artifact.DefaultArtifact;
-/** Executes the processes required so that all managed bundles are available. */
+/**
+ * Executes the processes required so that all managed bundles are available.
+ */
public class ProcessDistribution implements Runnable {
- private final static Log log = LogFactory.getLog(ProcessDistribution.class);
+ private final static CmsLog log = CmsLog.getLog(ProcessDistribution.class);
private ArgeoOsgiDistribution osgiDistribution;
private OsgiFactory osgiFactory;
Session javaSession = null;
try {
javaSession = osgiFactory.openJavaSession();
- for (Iterator<? extends NameVersion> it = osgiDistribution
- .nameVersions(); it.hasNext();)
+ for (Iterator<? extends NameVersion> it = osgiDistribution.nameVersions(); it.hasNext();)
processNameVersion(javaSession, it.next());
// Check sources
- for (Iterator<? extends NameVersion> it = osgiDistribution
- .nameVersions(); it.hasNext();) {
+ for (Iterator<? extends NameVersion> it = osgiDistribution.nameVersions(); it.hasNext();) {
CategoryNameVersion nv = (CategoryNameVersion) it.next();
- Artifact artifact = new DefaultArtifact(nv.getCategory(),
- nv.getName() + ".source", "jar", nv.getVersion());
+ Artifact artifact = new DefaultArtifact(nv.getCategory(), nv.getName() + ".source", "jar",
+ nv.getVersion());
String path = MavenConventionsUtils.artifactPath("/", artifact);
if (!javaSession.itemExists(path))
log.warn("No source available for " + nv);
// explicitly create the corresponding modular distribution as we
// have here all necessary info.
- ModularDistributionFactory mdf = new ModularDistributionFactory(
- osgiFactory, osgiDistribution);
+ ModularDistributionFactory mdf = new ModularDistributionFactory(osgiFactory, osgiDistribution);
mdf.run();
} catch (RepositoryException e) {
- throw new SlcException("Cannot process distribution "
- + osgiDistribution, e);
+ throw new SlcException("Cannot process distribution " + osgiDistribution, e);
} finally {
JcrUtils.logoutQuietly(javaSession);
}
}
- protected void processNameVersion(Session javaSession,
- NameVersion nameVersion) throws RepositoryException {
+ protected void processNameVersion(Session javaSession, NameVersion nameVersion) throws RepositoryException {
if (log.isTraceEnabled())
log.trace("Check " + nameVersion + "...");
if (!(nameVersion instanceof CategoryNameVersion))
throw new SlcException("Unsupported type " + nameVersion.getClass());
CategoryNameVersion nv = (CategoryNameVersion) nameVersion;
- Artifact artifact = new DefaultArtifact(nv.getCategory(), nv.getName(),
- "jar", nv.getVersion());
+ Artifact artifact = new DefaultArtifact(nv.getCategory(), nv.getName(), "jar", nv.getVersion());
String path = MavenConventionsUtils.artifactPath("/", artifact);
if (!javaSession.itemExists(path)) {
if (nv instanceof BndWrapper) {
/**
* Writes sources into a ZIP (or a JAR), under the same sirectory structure.
*
- * @param packages
- * the packages to import
- * @param out
- * the ZIP or JAR to write to
+ * @param packages the packages to import
+ * @param out the ZIP or JAR to write to
*/
public void writeSources(List<String> packages, ZipOutputStream zout);
}
import org.eclipse.aether.artifact.Artifact;
/**
- * An artifact whose identity is derived from another artifact. <em>Note:</em> Instances of this class are immutable and
- * the exposed mutators return new objects rather than changing the current instance.
+ * An artifact whose identity is derived from another artifact. <em>Note:</em>
+ * Instances of this class are immutable and the exposed mutators return new
+ * objects rather than changing the current instance.
*/
-final class SubArtifact
- extends AbstractArtifact
-{
-
- private final Artifact mainArtifact;
-
- private final String classifier;
-
- private final String extension;
-
- private final File file;
-
- private final Map<String, String> properties;
-
- /**
- * Creates a new sub artifact. The classifier and extension specified for this artifact may use the asterisk
- * character "*" to refer to the corresponding property of the main artifact. For instance, the classifier
- * "*-sources" can be used to refer to the source attachment of an artifact. Likewise, the extension "*.asc" can be
- * used to refer to the GPG signature of an artifact.
- *
- * @param mainArtifact The artifact from which to derive the identity, must not be {@code null}.
- * @param classifier The classifier for this artifact, may be {@code null} if none.
- * @param extension The extension for this artifact, may be {@code null} if none.
- */
- public SubArtifact( Artifact mainArtifact, String classifier, String extension )
- {
- this( mainArtifact, classifier, extension, (File) null );
- }
-
- /**
- * Creates a new sub artifact. The classifier and extension specified for this artifact may use the asterisk
- * character "*" to refer to the corresponding property of the main artifact. For instance, the classifier
- * "*-sources" can be used to refer to the source attachment of an artifact. Likewise, the extension "*.asc" can be
- * used to refer to the GPG signature of an artifact.
- *
- * @param mainArtifact The artifact from which to derive the identity, must not be {@code null}.
- * @param classifier The classifier for this artifact, may be {@code null} if none.
- * @param extension The extension for this artifact, may be {@code null} if none.
- * @param file The file for this artifact, may be {@code null} if unresolved.
- */
- public SubArtifact( Artifact mainArtifact, String classifier, String extension, File file )
- {
- this( mainArtifact, classifier, extension, null, file );
- }
-
- /**
- * Creates a new sub artifact. The classifier and extension specified for this artifact may use the asterisk
- * character "*" to refer to the corresponding property of the main artifact. For instance, the classifier
- * "*-sources" can be used to refer to the source attachment of an artifact. Likewise, the extension "*.asc" can be
- * used to refer to the GPG signature of an artifact.
- *
- * @param mainArtifact The artifact from which to derive the identity, must not be {@code null}.
- * @param classifier The classifier for this artifact, may be {@code null} if none.
- * @param extension The extension for this artifact, may be {@code null} if none.
- * @param properties The properties of the artifact, may be {@code null}.
- */
- public SubArtifact( Artifact mainArtifact, String classifier, String extension, Map<String, String> properties )
- {
- this( mainArtifact, classifier, extension, properties, null );
- }
-
- /**
- * Creates a new sub artifact. The classifier and extension specified for this artifact may use the asterisk
- * character "*" to refer to the corresponding property of the main artifact. For instance, the classifier
- * "*-sources" can be used to refer to the source attachment of an artifact. Likewise, the extension "*.asc" can be
- * used to refer to the GPG signature of an artifact.
- *
- * @param mainArtifact The artifact from which to derive the identity, must not be {@code null}.
- * @param classifier The classifier for this artifact, may be {@code null} if none.
- * @param extension The extension for this artifact, may be {@code null} if none.
- * @param properties The properties of the artifact, may be {@code null}.
- * @param file The file for this artifact, may be {@code null} if unresolved.
- */
- public SubArtifact( Artifact mainArtifact, String classifier, String extension, Map<String, String> properties,
- File file )
- {
- if ( mainArtifact == null )
- {
- throw new IllegalArgumentException( "no artifact specified" );
- }
- this.mainArtifact = mainArtifact;
- this.classifier = classifier;
- this.extension = extension;
- this.file = file;
- this.properties = copyProperties( properties );
- }
-
- private SubArtifact( Artifact mainArtifact, String classifier, String extension, File file,
- Map<String, String> properties )
- {
- // NOTE: This constructor assumes immutability of the provided properties, for internal use only
- this.mainArtifact = mainArtifact;
- this.classifier = classifier;
- this.extension = extension;
- this.file = file;
- this.properties = properties;
- }
-
- public String getGroupId()
- {
- return mainArtifact.getGroupId();
- }
-
- public String getArtifactId()
- {
- return mainArtifact.getArtifactId();
- }
-
- public String getVersion()
- {
- return mainArtifact.getVersion();
- }
-
- public String getBaseVersion()
- {
- return mainArtifact.getBaseVersion();
- }
-
- public boolean isSnapshot()
- {
- return mainArtifact.isSnapshot();
- }
-
- public String getClassifier()
- {
- return expand( classifier, mainArtifact.getClassifier() );
- }
-
- public String getExtension()
- {
- return expand( extension, mainArtifact.getExtension() );
- }
-
- public File getFile()
- {
- return file;
- }
-
- public Artifact setFile( File file )
- {
- if ( ( this.file == null ) ? file == null : this.file.equals( file ) )
- {
- return this;
- }
- return new SubArtifact( mainArtifact, classifier, extension, file, properties );
- }
-
- public Map<String, String> getProperties()
- {
- return properties;
- }
-
- public Artifact setProperties( Map<String, String> properties )
- {
- if ( this.properties.equals( properties ) || ( properties == null && this.properties.isEmpty() ) )
- {
- return this;
- }
- return new SubArtifact( mainArtifact, classifier, extension, properties, file );
- }
-
- private static String expand( String pattern, String replacement )
- {
- String result = "";
- if ( pattern != null )
- {
- result = pattern.replace( "*", replacement );
-
- if ( replacement.length() <= 0 )
- {
- if ( pattern.startsWith( "*" ) )
- {
- int i = 0;
- for ( ; i < result.length(); i++ )
- {
- char c = result.charAt( i );
- if ( c != '-' && c != '.' )
- {
- break;
- }
- }
- result = result.substring( i );
- }
- if ( pattern.endsWith( "*" ) )
- {
- int i = result.length() - 1;
- for ( ; i >= 0; i-- )
- {
- char c = result.charAt( i );
- if ( c != '-' && c != '.' )
- {
- break;
- }
- }
- result = result.substring( 0, i + 1 );
- }
- }
- }
- return result;
- }
+final class SubArtifact extends AbstractArtifact {
+
+ private final Artifact mainArtifact;
+
+ private final String classifier;
+
+ private final String extension;
+
+ private final File file;
+
+ private final Map<String, String> properties;
+
+ /**
+ * Creates a new sub artifact. The classifier and extension specified for this
+ * artifact may use the asterisk character "*" to refer to the corresponding
+ * property of the main artifact. For instance, the classifier "*-sources" can
+ * be used to refer to the source attachment of an artifact. Likewise, the
+ * extension "*.asc" can be used to refer to the GPG signature of an artifact.
+ *
+ * @param mainArtifact The artifact from which to derive the identity, must not
+ * be {@code null}.
+ * @param classifier The classifier for this artifact, may be {@code null} if
+ * none.
+ * @param extension The extension for this artifact, may be {@code null} if
+ * none.
+ */
+ public SubArtifact(Artifact mainArtifact, String classifier, String extension) {
+ this(mainArtifact, classifier, extension, (File) null);
+ }
+
+ /**
+ * Creates a new sub artifact. The classifier and extension specified for this
+ * artifact may use the asterisk character "*" to refer to the corresponding
+ * property of the main artifact. For instance, the classifier "*-sources" can
+ * be used to refer to the source attachment of an artifact. Likewise, the
+ * extension "*.asc" can be used to refer to the GPG signature of an artifact.
+ *
+ * @param mainArtifact The artifact from which to derive the identity, must not
+ * be {@code null}.
+ * @param classifier The classifier for this artifact, may be {@code null} if
+ * none.
+ * @param extension The extension for this artifact, may be {@code null} if
+ * none.
+ * @param file The file for this artifact, may be {@code null} if
+ * unresolved.
+ */
+ public SubArtifact(Artifact mainArtifact, String classifier, String extension, File file) {
+ this(mainArtifact, classifier, extension, null, file);
+ }
+
+ /**
+ * Creates a new sub artifact. The classifier and extension specified for this
+ * artifact may use the asterisk character "*" to refer to the corresponding
+ * property of the main artifact. For instance, the classifier "*-sources" can
+ * be used to refer to the source attachment of an artifact. Likewise, the
+ * extension "*.asc" can be used to refer to the GPG signature of an artifact.
+ *
+ * @param mainArtifact The artifact from which to derive the identity, must not
+ * be {@code null}.
+ * @param classifier The classifier for this artifact, may be {@code null} if
+ * none.
+ * @param extension The extension for this artifact, may be {@code null} if
+ * none.
+ * @param properties The properties of the artifact, may be {@code null}.
+ */
+ public SubArtifact(Artifact mainArtifact, String classifier, String extension, Map<String, String> properties) {
+ this(mainArtifact, classifier, extension, properties, null);
+ }
+
+ /**
+ * Creates a new sub artifact. The classifier and extension specified for this
+ * artifact may use the asterisk character "*" to refer to the corresponding
+ * property of the main artifact. For instance, the classifier "*-sources" can
+ * be used to refer to the source attachment of an artifact. Likewise, the
+ * extension "*.asc" can be used to refer to the GPG signature of an artifact.
+ *
+ * @param mainArtifact The artifact from which to derive the identity, must not
+ * be {@code null}.
+ * @param classifier The classifier for this artifact, may be {@code null} if
+ * none.
+ * @param extension The extension for this artifact, may be {@code null} if
+ * none.
+ * @param properties The properties of the artifact, may be {@code null}.
+ * @param file The file for this artifact, may be {@code null} if
+ * unresolved.
+ */
+ public SubArtifact(Artifact mainArtifact, String classifier, String extension, Map<String, String> properties,
+ File file) {
+ if (mainArtifact == null) {
+ throw new IllegalArgumentException("no artifact specified");
+ }
+ this.mainArtifact = mainArtifact;
+ this.classifier = classifier;
+ this.extension = extension;
+ this.file = file;
+ this.properties = copyProperties(properties);
+ }
+
+ private SubArtifact(Artifact mainArtifact, String classifier, String extension, File file,
+ Map<String, String> properties) {
+ // NOTE: This constructor assumes immutability of the provided properties, for
+ // internal use only
+ this.mainArtifact = mainArtifact;
+ this.classifier = classifier;
+ this.extension = extension;
+ this.file = file;
+ this.properties = properties;
+ }
+
+ public String getGroupId() {
+ return mainArtifact.getGroupId();
+ }
+
+ public String getArtifactId() {
+ return mainArtifact.getArtifactId();
+ }
+
+ public String getVersion() {
+ return mainArtifact.getVersion();
+ }
+
+ public String getBaseVersion() {
+ return mainArtifact.getBaseVersion();
+ }
+
+ public boolean isSnapshot() {
+ return mainArtifact.isSnapshot();
+ }
+
+ public String getClassifier() {
+ return expand(classifier, mainArtifact.getClassifier());
+ }
+
+ public String getExtension() {
+ return expand(extension, mainArtifact.getExtension());
+ }
+
+ public File getFile() {
+ return file;
+ }
+
+ public Artifact setFile(File file) {
+ if ((this.file == null) ? file == null : this.file.equals(file)) {
+ return this;
+ }
+ return new SubArtifact(mainArtifact, classifier, extension, file, properties);
+ }
+
+ public Map<String, String> getProperties() {
+ return properties;
+ }
+
+ public Artifact setProperties(Map<String, String> properties) {
+ if (this.properties.equals(properties) || (properties == null && this.properties.isEmpty())) {
+ return this;
+ }
+ return new SubArtifact(mainArtifact, classifier, extension, properties, file);
+ }
+
+ private static String expand(String pattern, String replacement) {
+ String result = "";
+ if (pattern != null) {
+ result = pattern.replace("*", replacement);
+
+ if (replacement.length() <= 0) {
+ if (pattern.startsWith("*")) {
+ int i = 0;
+ for (; i < result.length(); i++) {
+ char c = result.charAt(i);
+ if (c != '-' && c != '.') {
+ break;
+ }
+ }
+ result = result.substring(i);
+ }
+ if (pattern.endsWith("*")) {
+ int i = result.length() - 1;
+ for (; i >= 0; i--) {
+ char c = result.charAt(i);
+ if (c != '-' && c != '.') {
+ break;
+ }
+ }
+ result = result.substring(0, i + 1);
+ }
+ }
+ }
+ return result;
+ }
}
\ No newline at end of file
import javax.jcr.Session;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.DefaultNameVersion;
import org.argeo.slc.SlcException;
import aQute.bnd.osgi.Jar;
public class UriWrapper extends BndWrapper implements Runnable {
- private final static Log log = LogFactory.getLog(UriWrapper.class);
+ private final static CmsLog log = CmsLog.getLog(UriWrapper.class);
private String uri;
private String baseUri;
<artifactId>org.argeo.slc.api</artifactId>
<version>2.3-SNAPSHOT</version>
</dependency>
+
+ <dependency>
+ <groupId>org.argeo.commons</groupId>
+ <artifactId>org.argeo.api</artifactId>
+ <version>${version.argeo-commons}</version>
+ </dependency>
</dependencies>
</project>
\ No newline at end of file
import java.nio.file.Path;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.fs.BasicSyncFileVisitor;
/** Synchronises two directory structures. */
public class SyncFileVisitor extends BasicSyncFileVisitor {
- private final static Log log = LogFactory.getLog(SyncFileVisitor.class);
+ private final static CmsLog log = CmsLog.getLog(SyncFileVisitor.class);
public SyncFileVisitor(Path sourceBasePath, Path targetBasePath, boolean delete, boolean recursive) {
super(sourceBasePath, targetBasePath, delete, recursive);
import java.util.Map;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.execution.ExecutionContext;
import org.argeo.slc.execution.ExecutionFlow;
import org.argeo.slc.execution.ExecutionFlowDescriptorConverter;
/** Provides the base feature of an execution module manager. */
public abstract class AbstractExecutionModulesManager implements
ExecutionModulesManager {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(AbstractExecutionModulesManager.class);
// private List<FilteredNotifier> filteredNotifiers = Collections
/** Implements the base methods of an SLC agent. */
public class DefaultAgent implements SlcAgent {
- // private final static Log log = LogFactory.getLog(DefaultAgent.class);
+ // private final static CmsLog log = CmsLog.getLog(DefaultAgent.class);
/** UTF-8 charset for encoding. */
private final static String UTF8 = "UTF-8";
import java.util.List;
import java.util.Map;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.DefaultNameVersion;
import org.argeo.slc.NameVersion;
import org.argeo.slc.SlcException;
* Reference implementation of args to URIs algorithm.
*/
public class DefaultAgentCli implements SlcAgentCli {
- private final static Log log = LogFactory.getLog(DefaultAgentCli.class);
+ private final static CmsLog log = CmsLog.getLog(DefaultAgentCli.class);
private final static String UTF8 = "UTF-8";
private SlcAgent agent;
import java.util.List;
import java.util.Map;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.execution.ExecutionContext;
import org.argeo.slc.execution.ExecutionFlow;
/** Default implementation of an execution flow. */
public class DefaultExecutionFlow implements ExecutionFlow {
- private final static Log log = LogFactory.getLog(DefaultExecutionFlow.class);
+ private final static CmsLog log = CmsLog.getLog(DefaultExecutionFlow.class);
private final ExecutionSpec executionSpec;
private String name = null;
import java.util.Stack;
import java.util.UUID;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.execution.ExecutionFlow;
import org.argeo.slc.execution.ExecutionSpecAttribute;
/** Canonical implementation of an execution stack. */
public class DefaultExecutionStack implements ExecutionStack {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(DefaultExecutionStack.class);
private final Stack<ExecutionFlowRuntime> stack = new Stack<ExecutionFlowRuntime>();
import javax.security.auth.Subject;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.execution.ExecutionFlowDescriptor;
import org.argeo.slc.execution.ExecutionModulesManager;
import org.argeo.slc.execution.ExecutionStep;
/** Thread of a single execution */
public class ExecutionThread extends Thread {
public final static String SYSPROP_EXECUTION_AUTO_UPGRADE = "slc.execution.autoupgrade";
- private final static Log log = LogFactory.getLog(ExecutionThread.class);
+ private final static CmsLog log = CmsLog.getLog(ExecutionThread.class);
private ExecutionModulesManager executionModulesManager;
private final RealizedFlow realizedFlow;
import java.util.Stack;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.execution.ExecutionFlow;
import org.argeo.slc.execution.ExecutionSpecAttribute;
/** Manage parameters that need to be set during the instantiation of a flow */
public class InstantiationManager {
- private final static Log log = LogFactory
+ private final static CmsLog log = CmsLog
.getLog(InstantiationManager.class);
private ThreadLocal<Stack<ExecutionFlow>> flowStack = new ThreadLocal<Stack<ExecutionFlow>>();
import javax.security.auth.Subject;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.execution.ExecutionModulesManager;
import org.argeo.slc.execution.ExecutionProcess;
* sequential {@link ExecutionThread}s.
*/
public class ProcessThread extends Thread {
- private final static Log log = LogFactory.getLog(ProcessThread.class);
+ private final static CmsLog log = CmsLog.getLog(ProcessThread.class);
private final ExecutionModulesManager executionModulesManager;
private final ExecutionProcess process;
import java.nio.file.Path;
import org.apache.commons.io.FileUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
public class Echo implements Runnable {
- private final static Log defaultLog = LogFactory.getLog(Echo.class);
+ private final static CmsLog defaultLog = CmsLog.getLog(Echo.class);
private Path writeTo = null;
- private Log log;
+ private CmsLog log;
private Object message;
public void run() {
}
}
- private Log log() {
+ private CmsLog log() {
return log != null ? log : defaultLog;
}
import org.apache.commons.exec.ShutdownHookProcessDestroyer;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.UnsupportedException;
import org.argeo.slc.execution.ExecutionResources;
public class SystemCall implements Runnable {
public final static String LOG_STDOUT = "System.out";
- private final Log log = LogFactory.getLog(getClass());
+ private final CmsLog log = CmsLog.getLog(getClass());
private String execDir;
import java.util.Map;
import java.util.TreeMap;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.test.TestResult;
import org.argeo.slc.test.TestStatus;
import org.argeo.slc.test.context.ContextAware;
/** Utilities for comparing and synchronising contexts. */
public class ContextUtils {
- private final static Log log = LogFactory.getLog(ContextUtils.class);
+ private final static CmsLog log = CmsLog.getLog(ContextUtils.class);
public static void compareReachedExpected(ContextAware contextAware,
TestResult testResult) {
import java.util.UUID;
import java.util.Vector;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.argeo.api.cms.CmsLog;
import org.argeo.slc.SlcException;
import org.argeo.slc.test.TestResult;
import org.argeo.slc.test.TestResultPart;
* Basic implementation of a test result containing only a list of result parts.
*/
public class SimpleTestResult implements TestResult {
- private static Log log = LogFactory.getLog(SimpleTestResult.class);
+ private static CmsLog log = CmsLog.getLog(SimpleTestResult.class);
private String uuid;
private String currentTestRunUuid;
projects / gpl / argeo-slc.git / commitdiff