From: Sanjay Dalal Date: Thu, 13 Aug 2009 17:15:35 +0000 (+0000) Subject: NOJIRA checking in stuff before sandbox move X-Git-Url: https://git.aero2k.de/?a=commitdiff_plain;h=542a8a4f1994d1f6ec24fe6828046e6a89f7bfde;p=tmp%2Fjakarta-migration.git NOJIRA checking in stuff before sandbox move A sanjay/prototypes/restws/HelloWorldDocService/nbactions.xml M sanjay/prototypes/restws/HelloWorldDocService/pom.all.xml A sanjay/prototypes/restws/HelloWorldDocService/nb-configuration.xml M sanjay/prototypes/restws/HelloWorldDocService/pom.xml A sanjay/prototypes/restws/HelloWorldDocService/README.txt M sanjay/prototypes/jaxrs-prototype/jaxrs-nuxeo-service/pom.xml M sanjay/prototypes/jaxrs-prototype/jaxrs-nuxeo-javaapi-service/pom.xml A sanjay/nuxeo A sanjay/nuxeo/NuxeoApp.java A sanjay/nuxeo/ConnectionListener.java A sanjay/nuxeo/LoginHandler.java A sanjay/nuxeo/DefaultLoginHandler.java A sanjay/nuxeo/NuxeoClient.java --- diff --git a/sandbox/sanjay/nuxeo/ConnectionListener.java b/sandbox/sanjay/nuxeo/ConnectionListener.java new file mode 100644 index 000000000..080cfef50 --- /dev/null +++ b/sandbox/sanjay/nuxeo/ConnectionListener.java @@ -0,0 +1,51 @@ +/* + * (C) Copyright 2006-2007 Nuxeo SAS (http://nuxeo.com/) and contributors. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public License + * (LGPL) version 2.1 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Contributors: + * bstefanescu + * + * $Id$ + */ + +package org.collectionspace.services.nuxeo; + +/** + * Listen to connection events + * + * @author Bogdan Stefanescu + * + */ +public interface ConnectionListener { + + /** + * The client connected to a server. + * + * @param client the client + */ + void connected(NuxeoClient client); + + /** + * The client disconnected. + * + * @param client the client + */ + void disconnected(NuxeoClient client); + + /** + * The client authentication failed against the remote server. + * + * @param client the client + */ + boolean authenticationFailed(NuxeoClient client); + +} diff --git a/sandbox/sanjay/nuxeo/DefaultLoginHandler.java b/sandbox/sanjay/nuxeo/DefaultLoginHandler.java new file mode 100644 index 000000000..2b1331132 --- /dev/null +++ b/sandbox/sanjay/nuxeo/DefaultLoginHandler.java @@ -0,0 +1,96 @@ +/* + * (C) Copyright 2006-2007 Nuxeo SAS (http://nuxeo.com/) and contributors. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public License + * (LGPL) version 2.1 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Contributors: + * bstefanescu + * + * $Id$ + */ + +package org.collectionspace.services.nuxeo; + +import javax.security.auth.login.LoginContext; +import javax.security.auth.login.LoginException; + +import org.nuxeo.runtime.api.Framework; + +/** + * @author Bogdan Stefanescu + * + */ +public class DefaultLoginHandler implements LoginHandler { + + private LoginContext lc; + + private String username; + private char[] password; + + public DefaultLoginHandler() { + } + + public DefaultLoginHandler(String username, String password) { + this(username, password.toCharArray()); + } + + public DefaultLoginHandler(String username, char[] password) { + this.username = username; + this.password = password; + } + + public void setUsername(String username) { + this.username = username; + } + + public void setPassword(char[] password) { + this.password = password; + } + + public void setPassword(String password) { + this.password = password.toCharArray(); + } + + public char[] getPassword() { + return password; + } + + public String getUsername() { + return username; + } + + public synchronized LoginContext getLoginContext() { + return lc; + } + + public synchronized LoginContext login() throws LoginException { + if (username == null) { + lc = Framework.login(); + } else { + lc = Framework.login(username, password); + } + return lc; + } + + public synchronized void logout() throws LoginException { + if (lc != null) { + lc.logout(); + } + } + + public synchronized void retryLogin() throws LoginException { + if (lc != null) { + lc.logout(); + } + login(); + } + +} diff --git a/sandbox/sanjay/nuxeo/LoginHandler.java b/sandbox/sanjay/nuxeo/LoginHandler.java new file mode 100644 index 000000000..57cb85332 --- /dev/null +++ b/sandbox/sanjay/nuxeo/LoginHandler.java @@ -0,0 +1,40 @@ +/* + * (C) Copyright 2006-2007 Nuxeo SAS (http://nuxeo.com/) and contributors. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public License + * (LGPL) version 2.1 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Contributors: + * bstefanescu + * + * $Id$ + */ + +package org.collectionspace.services.nuxeo; + +import javax.security.auth.login.LoginContext; +import javax.security.auth.login.LoginException; + +/** + * Manages user login and current user session. + * + * @author Bogdan Stefanescu + */ +public interface LoginHandler { + + LoginContext login() throws LoginException; + + void logout() throws LoginException; + + LoginContext getLoginContext(); + + void retryLogin() throws LoginException; + +} diff --git a/sandbox/sanjay/nuxeo/NuxeoApp.java b/sandbox/sanjay/nuxeo/NuxeoApp.java new file mode 100644 index 000000000..6295b8217 --- /dev/null +++ b/sandbox/sanjay/nuxeo/NuxeoApp.java @@ -0,0 +1,176 @@ +/* + * (C) Copyright 2006-2008 Nuxeo SAS (http://nuxeo.com/) and contributors. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public License + * (LGPL) version 2.1 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Contributors: + * bstefanescu + */ +package org.collectionspace.services.nuxeo; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.StringTokenizer; + +import org.nuxeo.common.Environment; +import org.nuxeo.osgi.BundleFile; +import org.nuxeo.osgi.BundleImpl; +import org.nuxeo.osgi.DirectoryBundleFile; +import org.nuxeo.osgi.JarBundleFile; +import org.nuxeo.osgi.OSGiAdapter; +import org.osgi.framework.BundleException; + +/** + * Nuxeo Runtime launcher. + * + * This launcher assume all bundles are already on the classpath. + * + * + * @author Bogdan Stefanescu + * + */ +public class NuxeoApp { + + protected OSGiAdapter osgi; + protected final ClassLoader loader; + protected final Environment env; + + public static ClassLoader getDefaultClassLoader() { + ClassLoader cl = Thread.currentThread().getContextClassLoader(); + return cl == null ? NuxeoApp.class.getClassLoader() : cl; + } + + public NuxeoApp() { + this (new File("."), getDefaultClassLoader()); + } + + public NuxeoApp(File home) { + this (home, getDefaultClassLoader()); + } + + public NuxeoApp(File home, ClassLoader loader) { + this.loader = loader; + env = new Environment(home); + } + + public Environment getEnvironment() { + return this.env; + } + + public synchronized void deployBundles(Collection files) throws BundleException, IOException { + if (!isStarted()) { + throw new IllegalStateException("Framework not started"); + } + for (File file : files) { + deployBundle(file); + } + } + + public synchronized void deployBundle(File file) throws BundleException, IOException { + if (!isStarted()) { + throw new IllegalStateException("Framework not started"); + } + BundleFile bf = file.isDirectory() ? new DirectoryBundleFile(file) : new JarBundleFile(file); + osgi.install(new BundleImpl(osgi, bf, loader)); + System.out.println(">>>NuxeoApp:deployed bundle: " + file.getName()); + } + + public synchronized void start() { + if (osgi != null) { + //throw new IllegalStateException("Nuxeo Runtime already started"); + //sd: why throw exception? + return; + } + osgi = new OSGiAdapter(env.getHome(), env.getData(), env.getProperties()); + } + + public synchronized boolean isStarted() { + return osgi != null; + } + + public synchronized OSGiAdapter getOsgi() { + return osgi; + } + + + public synchronized void shutdown() throws IOException { + if (osgi == null) { + throw new IllegalStateException("Nuxeo Runtime not started"); + } + osgi.shutdown(); + osgi = null; + } + + public static Collection getBundleFiles(File baseDir, String bundles, String delim) throws IOException { + LinkedHashSet result = new LinkedHashSet(); + StringTokenizer tokenizer = new StringTokenizer(bundles, delim == null ? " \t\n\r\f" : delim); + while (tokenizer.hasMoreTokens()) { + String tok = tokenizer.nextToken(); + List files = expandFiles(baseDir, tok); + for (File file : files) { + result.add(file.getCanonicalFile()); + } + } + return result; + } + + public static List expandFiles(File baseDir, String line) { + int p = line.lastIndexOf("/"); + String fileName = null; + if (p > -1) { + fileName = line.substring(p+1); + baseDir = new File(baseDir, line.substring(0, p)); + } else { + fileName = line; + } + p = fileName.indexOf("*"); + if (p == -1) { + return Collections.singletonList(new File(baseDir, fileName)); + } else if (fileName.length() == 0) { + return Arrays.asList(baseDir.listFiles()); + } else if (p == 0) { + String suffix= fileName.substring(p+1); + ArrayList result = new ArrayList(); + for (String name : baseDir.list()) { + if (name.endsWith(suffix)) { + result.add(new File(baseDir, name)); + } + } + return result; + } else if (p == fileName.length()-1) { + String prefix= fileName.substring(0, p); + ArrayList result = new ArrayList(); + for (String name : baseDir.list()) { + if (name.startsWith(prefix)) { + result.add(new File(baseDir, name)); + } + } + return result; + } else { + String prefix= fileName.substring(0, p); + String suffix= fileName.substring(p+1); + ArrayList result = new ArrayList(); + for (String name : baseDir.list()) { + if (name.startsWith(prefix) && name.endsWith(suffix)) { + result.add(new File(baseDir, name)); + } + } + return result; + } + } + +} diff --git a/sandbox/sanjay/nuxeo/NuxeoClient.java b/sandbox/sanjay/nuxeo/NuxeoClient.java new file mode 100644 index 000000000..c2458b926 --- /dev/null +++ b/sandbox/sanjay/nuxeo/NuxeoClient.java @@ -0,0 +1,409 @@ +/* + * (C) Copyright 2006-2007 Nuxeo SAS (http://nuxeo.com/) and contributors. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public License + * (LGPL) version 2.1 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Contributors: + * bstefanescu + * + * $Id$ + */ +package org.collectionspace.services.nuxeo; + +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Vector; + +import javax.security.auth.login.AppConfigurationEntry; +import javax.security.auth.login.LoginException; + +import org.jboss.remoting.InvokerLocator; +import org.nuxeo.common.collections.ListenerList; +import org.nuxeo.ecm.core.api.repository.Repository; +import org.nuxeo.ecm.core.api.repository.RepositoryInstance; +import org.nuxeo.ecm.core.api.repository.RepositoryInstanceHandler; +import org.nuxeo.ecm.core.api.repository.RepositoryManager; +import org.nuxeo.ecm.core.schema.SchemaManager; +import org.nuxeo.ecm.core.schema.SchemaManagerImpl; +import org.nuxeo.ecm.core.schema.TypeProvider; +import org.nuxeo.runtime.api.Framework; +import org.nuxeo.runtime.api.ServiceDescriptor; +import org.nuxeo.runtime.api.ServiceManager; +import org.nuxeo.runtime.api.login.LoginComponent; +import org.nuxeo.runtime.api.login.LoginService; +import org.nuxeo.runtime.api.login.SecurityDomain; +import org.nuxeo.runtime.config.AutoConfigurationService; +import org.nuxeo.runtime.remoting.RemotingService; +import org.nuxeo.runtime.services.streaming.StreamingService; + +/** + * @author Bogdan Stefanescu + * + */ +public final class NuxeoClient { + + private LoginHandler loginHandler; + private final List repositoryInstances; + private final ListenerList connectionListeners; + private InvokerLocator locator; + private String serverName; + private final AutoConfigurationService cfg; + private RepositoryManager repositoryMgr; + private boolean multiThreadedLogin = false; + private static final NuxeoClient instance = new NuxeoClient(); + + private NuxeoClient() { + connectionListeners = new ListenerList(); + cfg = new AutoConfigurationService(); + loginHandler = loginHandler == null ? new DefaultLoginHandler() : loginHandler; + repositoryInstances = new Vector(); + } + + public static NuxeoClient getInstance() { + return instance; + } + + public void setMultiThreadedLogin(boolean useMultiThreadedLogin) { + multiThreadedLogin = useMultiThreadedLogin; + } + + public boolean getMultiThreadedLogin() { + return multiThreadedLogin; + } + + public synchronized void connect(String locator) throws Exception { + if(this.locator != null){ + throw new IllegalStateException("Client is already connected"); + } + doConnect(AutoConfigurationService.createLocator(locator)); + } + + public synchronized void connect(InvokerLocator locator) throws Exception { + if(this.locator != null){ + throw new IllegalStateException("Client is already connected"); + } + doConnect(locator); + } + + public synchronized void connect(String host, int port) throws Exception { + if(locator != null){ + throw new IllegalStateException("Client is already connected"); + } + doConnect(AutoConfigurationService.createLocator(host, port)); + } + + public synchronized void forceConnect(InvokerLocator locator) throws Exception { + if(this.locator != null){ + disconnect(); + } + doConnect(locator); + } + + public synchronized void forceConnect(String locator) throws Exception { + if(this.locator != null){ + disconnect(); + } + doConnect(AutoConfigurationService.createLocator(locator)); + } + + public synchronized void forceConnect(String host, int port) throws Exception { + if(locator != null){ + disconnect(); + } + doConnect(AutoConfigurationService.createLocator(host, port)); + } + + public synchronized void tryConnect(String host, int port) throws Exception { + if(locator != null){ + return; // do nothing + } + doConnect(AutoConfigurationService.createLocator(host, port)); + } + + public synchronized void tryConnect(String url) throws Exception { + if(locator != null){ + return; // do nothing + } + doConnect(AutoConfigurationService.createLocator(url)); + } + + public synchronized void tryConnect(InvokerLocator locator) throws Exception { + if(this.locator != null){ + return; // do nothing + } + doConnect(locator); + } + + private void doConnect(InvokerLocator locator) throws Exception { + this.locator = locator; + try{ + cfg.load(locator); + // FIXME TODO workaround to work with nxruntime core 1.3.3 -------------- + String newPort = Framework.getProperty("org.nuxeo.runtime.1.3.3.streaming.port"); + System.out.println(">>>NuxeoClient:newPort=" + newPort);//sd + if(newPort != null){ + StreamingService streamingService = (StreamingService) Framework.getRuntime().getComponent( + StreamingService.NAME); + // streaming config + String oldLocator = streamingService.getServerLocator(); + int p = oldLocator.lastIndexOf(':'); + if(p > -1){ + String withoutPort = oldLocator.substring(0, p); + String serverLocator = withoutPort + ":" + newPort; + streamingService.stopManager(); + streamingService.setServerLocator(serverLocator); + streamingService.setServer(false); + streamingService.startManager(); + } + } + System.out.println(">>>NuxeoClient:pre schemaRemotingWorkaround");//sd + // FIXME TODO workaround for remote services ------------------------------- + schemaRemotingWorkaround(locator.getHost()); + System.out.println(">>>NuxeoClient:post schemaRemotingWorkaround");//sd + + + // workaround for client login configuration - we need to make it not multi threaded + // TODO put an option for this in NuxeoClient + if(!multiThreadedLogin){ + LoginService ls = Framework.getService(LoginService.class); + SecurityDomain sysDomain = ls.getSecurityDomain(LoginComponent.SYSTEM_LOGIN); + SecurityDomain clientDomain = ls.getSecurityDomain(LoginComponent.CLIENT_LOGIN); + adaptClientSecurityDomain(sysDomain); + adaptClientSecurityDomain(clientDomain); + } + // ---------------- + login(); + System.out.println("NuxeoClient: login"); + }catch(Exception e){ + this.locator = null; + throw e; + } + fireConnected(this); + } + + public static void adaptClientSecurityDomain(SecurityDomain sd) { + AppConfigurationEntry[] entries = sd.getAppConfigurationEntries(); + if(entries != null){ + for(int i = 0; i < entries.length; i++){ + AppConfigurationEntry entry = entries[i]; + if("org.jboss.security.ClientLoginModule".equals(entry.getLoginModuleName())){ + Map opts = entry.getOptions(); + Map newOpts = new HashMap(opts); + newOpts.put("multi-threaded", "false"); + entries[i] = new AppConfigurationEntry(entry.getLoginModuleName(), + entry.getControlFlag(), entry.getOptions()); + } + } + } + } + + /** + * Workaround for being able to load schemas from remote + * TODO integrate this in core + * FIXME integrate this in core + */ + private static void schemaRemotingWorkaround(String host) throws Exception { + ServiceManager serviceManager = Framework.getLocalService(ServiceManager.class); + ServiceDescriptor sd = new ServiceDescriptor(TypeProvider.class, "core"); + sd.setLocator("%TypeProviderBean"); + serviceManager.registerService(sd); + TypeProvider typeProvider = Framework.getService(TypeProvider.class); + SchemaManager schemaMgr = Framework.getLocalService(SchemaManager.class); + ((SchemaManagerImpl) schemaMgr).importTypes(typeProvider); + } + + public synchronized void disconnect() throws Exception { + if(locator == null){ + throw new IllegalStateException("Client is not connected"); + } + doDisconnect(); + } + + public synchronized void tryDisconnect() throws Exception { + if(locator == null){ + return; // do nothing + } + doDisconnect(); + } + + private void doDisconnect() throws Exception { + locator = null; + serverName = null; + // close repository sessions if any + Iterator it = repositoryInstances.iterator(); + while(it.hasNext()){ + RepositoryInstance repo = it.next(); + try{ + repo.close(); + }catch(Exception e){ + e.printStackTrace(); + } + it.remove(); + } + // logout + logout(); + repositoryMgr = null; + fireDisconnected(this); + } + + public synchronized void reconnect() throws Exception { + if(locator == null){ + throw new IllegalStateException("Client is not connected"); + } + InvokerLocator locator = this.locator; + disconnect(); + connect(locator); + } + + public AutoConfigurationService getConfigurationService() { + return cfg; + } + + public synchronized String getServerName() { + if(locator == null){ + throw new IllegalStateException("Client is not connected"); + } + if(serverName == null){ + if(cfg == null){ // compatibility + serverName = RemotingService.ping(locator.getHost(), locator.getPort()); + }else{ + serverName = cfg.getServerConfiguration().getProductInfo(); + } + } + return serverName; + } + + public synchronized boolean isConnected() { + return locator != null; + } + + public String getServerHost() { + if(locator == null){ + throw new IllegalStateException("Client is not connected"); + } + return locator.getHost(); + } + + public int getServerPort() { + if(locator == null){ + throw new IllegalStateException("Client is not connected"); + } + return locator.getPort(); + } + + public InvokerLocator getLocator() { + return locator; + } + + public synchronized LoginHandler getLoginHandler() { + return loginHandler; + } + + public synchronized void setLoginHandler(LoginHandler loginHandler) { + this.loginHandler = loginHandler; + } + + public synchronized void login() throws LoginException { + if(loginHandler != null){ + loginHandler.login(); + } + } + + public synchronized void logout() throws LoginException { + if(loginHandler != null){ + loginHandler.logout(); + } + } + + public RepositoryManager getRepositoryManager() throws Exception { + if(repositoryMgr == null){ + repositoryMgr = Framework.getService(RepositoryManager.class); + } + return repositoryMgr; + } + + /** + * Gets the repositories available on the connected server. + * + * @return the repositories + */ + public Repository[] getRepositories() throws Exception { + Collection repos = getRepositoryManager().getRepositories(); + return repos.toArray(new Repository[repos.size()]); + } + + public Repository getDefaultRepository() throws Exception { + return getRepositoryManager().getDefaultRepository(); + } + + public Repository getRepository(String name) throws Exception { + return getRepositoryManager().getRepository(name); + } + + public RepositoryInstance openRepository() throws Exception { + Repository repository = getRepositoryManager().getDefaultRepository(); + RepositoryInstance repo = newRepositoryInstance(repository); + repositoryInstances.add(repo); + return repo; + } + + public RepositoryInstance openRepository(String name) throws Exception { + Repository repository = getRepositoryManager().getRepository(name); + RepositoryInstance repo = newRepositoryInstance(repository); + repositoryInstances.add(repo); + return repo; + } + + public void releaseRepository(RepositoryInstance repo) throws Exception { + try{ + repo.close(); + }finally{ + repositoryInstances.remove(repo); + } + } + + public RepositoryInstance[] getRepositoryInstances() { + return repositoryInstances.toArray(new RepositoryInstance[repositoryInstances.size()]); + } + + public static RepositoryInstance newRepositoryInstance(Repository repository) { + ClassLoader cl = Thread.currentThread().getContextClassLoader(); + if(cl == null){ + cl = NuxeoClient.class.getClassLoader(); + } + return new RepositoryInstanceHandler(repository).getProxy(); + } + + public void addConnectionListener(ConnectionListener listener) { + connectionListeners.add(listener); + } + + public void removeConnectionListener(ConnectionListener listener) { + connectionListeners.remove(listener); + } + + private void fireDisconnected(NuxeoClient client) { + Object[] listeners = connectionListeners.getListeners(); + for(Object listener : listeners){ + ((ConnectionListener) listener).disconnected(client); + } + } + + private void fireConnected(NuxeoClient client) { + Object[] listeners = connectionListeners.getListeners(); + for(Object listener : listeners){ + ((ConnectionListener) listener).connected(client); + } + } +} diff --git a/sandbox/sanjay/prototypes/jaxrs-prototype/jaxrs-nuxeo-javaapi-service/pom.xml b/sandbox/sanjay/prototypes/jaxrs-prototype/jaxrs-nuxeo-javaapi-service/pom.xml index 8f903d3b1..6c25b5405 100644 --- a/sandbox/sanjay/prototypes/jaxrs-prototype/jaxrs-nuxeo-javaapi-service/pom.xml +++ b/sandbox/sanjay/prototypes/jaxrs-prototype/jaxrs-nuxeo-javaapi-service/pom.xml @@ -24,10 +24,7 @@ http://repo1.maven.org/maven2/ - - cspace.local.jboss.client - ${jboss.client.dir} - + jboss jboss repo @@ -39,14 +36,6 @@ http://svn.codehaus.org/mojo/trunk/mojo/jboss-maven-plugin - - cspace.local.nuxeo - ${nuxeo.local.repo.dir} - - - cspace.local.nuxeo.client - ${nuxeo.local.repo.client.dir} - + + + default + 8 + 80 + false + + diff --git a/sandbox/sanjay/prototypes/restws/HelloWorldDocService/nbactions.xml b/sandbox/sanjay/prototypes/restws/HelloWorldDocService/nbactions.xml new file mode 100644 index 000000000..9d30c239a --- /dev/null +++ b/sandbox/sanjay/prototypes/restws/HelloWorldDocService/nbactions.xml @@ -0,0 +1,74 @@ + + + + test + + * + + + test + + + + build + + * + + + install + + + + clean + + * + + + clean + + + + rebuild + + * + + + clean + install + + + true + + + + run + + war + ear + ejb + + + package + + + + true + + + + debug + + war + ear + ejb + + + package + + + + true + true + + + diff --git a/sandbox/sanjay/prototypes/restws/HelloWorldDocService/pom.all.xml b/sandbox/sanjay/prototypes/restws/HelloWorldDocService/pom.all.xml index 5aa2f743c..e00b239d6 100644 --- a/sandbox/sanjay/prototypes/restws/HelloWorldDocService/pom.all.xml +++ b/sandbox/sanjay/prototypes/restws/HelloWorldDocService/pom.all.xml @@ -34,10 +34,6 @@ mojo repo http://svn.codehaus.org/mojo/trunk/mojo/jboss-maven-plugin - - cspace.local.nuxeo - ${nuxeo.local.repo.dir} - public http://maven.nuxeo.org/public diff --git a/sandbox/sanjay/prototypes/restws/HelloWorldDocService/pom.xml b/sandbox/sanjay/prototypes/restws/HelloWorldDocService/pom.xml index 41b3e6279..8f611c947 100644 --- a/sandbox/sanjay/prototypes/restws/HelloWorldDocService/pom.xml +++ b/sandbox/sanjay/prototypes/restws/HelloWorldDocService/pom.xml @@ -40,15 +40,7 @@ Public online Restlet repository http://maven.restlet.org - - - cspace.local.nuxeo - ${nuxeo.local.repo.dir} - - - cspace.local.nuxeo.client - ${nuxeo.local.repo.client.dir} - + public http://maven.nuxeo.org/public