cxf-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ningji...@apache.org
Subject svn commit: r702420 [2/2] - in /cxf/trunk: api/ api/src/main/java/org/apache/cxf/jca/ api/src/main/java/org/apache/cxf/jca/outbound/ distribution/src/main/release/samples/integration/jca/outbound.was61/ distribution/src/main/release/samples/integration...
Date Tue, 07 Oct 2008 10:00:32 GMT
Added: cxf/trunk/integration/jca/src/main/java/org/apache/cxf/jca/outbound/ManagedConnectionFactoryImpl.java
URL: http://svn.apache.org/viewvc/cxf/trunk/integration/jca/src/main/java/org/apache/cxf/jca/outbound/ManagedConnectionFactoryImpl.java?rev=702420&view=auto
==============================================================================
--- cxf/trunk/integration/jca/src/main/java/org/apache/cxf/jca/outbound/ManagedConnectionFactoryImpl.java
(added)
+++ cxf/trunk/integration/jca/src/main/java/org/apache/cxf/jca/outbound/ManagedConnectionFactoryImpl.java
Tue Oct  7 03:00:21 2008
@@ -0,0 +1,199 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.cxf.jca.outbound;
+
+import java.io.PrintWriter;
+
+import java.util.Iterator;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.resource.ResourceException;
+import javax.resource.spi.ConnectionManager;
+import javax.resource.spi.ConnectionRequestInfo;
+import javax.resource.spi.ManagedConnection;
+import javax.resource.spi.ManagedConnectionFactory;
+import javax.resource.spi.ResourceAdapter;
+import javax.resource.spi.ResourceAdapterAssociation;
+import javax.resource.spi.work.WorkManager;
+import javax.security.auth.Subject;
+
+import org.apache.commons.lang.ObjectUtils;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.jca.core.logging.LoggerHelper;
+import org.apache.cxf.jca.cxf.ResourceAdapterImpl;
+
+public class ManagedConnectionFactoryImpl implements ManagedConnectionFactory, 
+    ResourceAdapterAssociation {
+
+    private static final long serialVersionUID = -5294527634981120642L;
+    private static final Logger LOG = LogUtils.getL7dLogger(ManagedConnectionFactoryImpl.class);
+    
+    private String busConfigURL;
+    private PrintWriter printWriter;
+    private ResourceAdapter resourceAdapter;
+    
+    private ConnectionManager defaultConnectionManager = 
+        new DefaultConnectionManager();
+
+    static {
+        // first use of log, default init if necessary
+        LoggerHelper.init();
+    }
+   
+    /* --------------------------------------------------------------------
+     *                           Bean Properties
+     */
+    public void setBusConfigURL(String busConfigURL) {
+        this.busConfigURL = busConfigURL;
+    }
+
+    public String getBusConfigURL() {
+        return busConfigURL;
+    }
+    
+  
+    /* --------------------------------------------------------------------
+     *                    ManagedConnectionFactory methods
+     */
+    public Object createConnectionFactory() throws ResourceException {
+        if (LOG.isLoggable(Level.FINER)) {
+            LOG.finer("Create connection factory for unmanaged connections");
+        }
+        return new ConnectionFactoryImpl(this, defaultConnectionManager);
+    }
+    
+    public Object createConnectionFactory(ConnectionManager connMgr) 
+        throws ResourceException {
+        if (LOG.isLoggable(Level.FINER)) {
+            LOG.finer("Create connection factory by app server connMgr " + connMgr);
+        }
+        return new ConnectionFactoryImpl(this, 
+                connMgr == null ? defaultConnectionManager : connMgr);
+    }
+
+    public ManagedConnection createManagedConnection(Subject subject, ConnectionRequestInfo
connReqInfo) 
+        throws ResourceException {
+        if (LOG.isLoggable(Level.FINER)) {
+            LOG.finer("Create managed connection subject=" + subject + "connReqInfo="
+                    + connReqInfo);
+        }
+        return new ManagedConnectionImpl(this, connReqInfo, subject);
+    }
+    
+    // hashCode method is required by JCA 1.5 because on properties
+    public int hashCode() {
+        int retval = 0;
+
+        if (busConfigURL != null) {
+            retval += busConfigURL.hashCode();
+        }
+        
+        return retval;
+    }
+    
+    // equals method is required by JCA 1.5 because on properties
+    public boolean equals(Object o) {
+        if (!this.getClass().isAssignableFrom(o.getClass())) {
+            return false;
+        }
+        
+        ManagedConnectionFactoryImpl that = (ManagedConnectionFactoryImpl)o;
+       
+        if (!ObjectUtils.equals(that.getBusConfigURL(), busConfigURL)) {
+            return false;
+        }
+        
+        return true;
+    }
+    
+    public PrintWriter getLogWriter() throws ResourceException {
+        return printWriter;
+    }
+
+    public void setLogWriter(final PrintWriter aPrintWriter) throws ResourceException {
+        if (aPrintWriter == null) {
+            throw new IllegalArgumentException("NULL_LOG_WRITER");
+        }
+
+        printWriter = aPrintWriter;
+        LoggerHelper.initializeLoggingOnWriter(printWriter);
+    }
+    
+    @SuppressWarnings("unchecked")
+    public ManagedConnection matchManagedConnections(Set mcs, Subject subject, 
+            ConnectionRequestInfo reqInfo) throws ResourceException {
+
+        if (LOG.isLoggable(Level.FINER)) {
+            LOG.finer("match connections: set=" + mcs + ", subject=" + subject
+                    + " reqInfo=" + reqInfo);
+        }
+
+        // find the first managed connection that matches the bus and request info
+        Iterator iter = mcs.iterator();
+        while (iter.hasNext()) {
+            Object obj = iter.next();
+            if (!(obj instanceof ManagedConnectionImpl)) {
+                continue;
+            }
+            
+            ManagedConnectionImpl mc = (ManagedConnectionImpl)obj;
+             
+            if (!ObjectUtils.equals(busConfigURL,
+                    mc.getManagedConnectionFactoryImpl().getBusConfigURL())) {
+                continue;
+            }
+            
+            if (!ObjectUtils.equals(reqInfo, mc.getRequestInfo())) {
+                continue;
+            }
+            
+            if (LOG.isLoggable(Level.FINER)) {
+                LOG.finer("found matched connection " + mc);
+            }
+            return mc;
+        }
+        return null;
+    }
+    
+    /* --------------------------------------------------------------------
+     *                      ResourceAdapterAssociation methods
+     */
+    public ResourceAdapter getResourceAdapter() {
+        return resourceAdapter;
+    }
+
+    public void setResourceAdapter(ResourceAdapter ra) throws ResourceException {
+        resourceAdapter = ra;
+    }
+
+    /* --------------------------------------------------------------------
+     *                      public methods
+     */
+    public WorkManager getWorkManager() {
+        if (resourceAdapter instanceof ResourceAdapterImpl) {
+            return ((ResourceAdapterImpl)resourceAdapter).getBootstrapContext()
+                .getWorkManager();
+        } else {
+            return null;
+        }
+    }
+
+}

Propchange: cxf/trunk/integration/jca/src/main/java/org/apache/cxf/jca/outbound/ManagedConnectionFactoryImpl.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: cxf/trunk/integration/jca/src/main/java/org/apache/cxf/jca/outbound/ManagedConnectionFactoryImpl.java
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Added: cxf/trunk/integration/jca/src/main/java/org/apache/cxf/jca/outbound/ManagedConnectionImpl.java
URL: http://svn.apache.org/viewvc/cxf/trunk/integration/jca/src/main/java/org/apache/cxf/jca/outbound/ManagedConnectionImpl.java?rev=702420&view=auto
==============================================================================
--- cxf/trunk/integration/jca/src/main/java/org/apache/cxf/jca/outbound/ManagedConnectionImpl.java
(added)
+++ cxf/trunk/integration/jca/src/main/java/org/apache/cxf/jca/outbound/ManagedConnectionImpl.java
Tue Oct  7 03:00:21 2008
@@ -0,0 +1,400 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.cxf.jca.outbound;
+
+import java.io.PrintWriter;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.resource.NotSupportedException;
+import javax.resource.ResourceException;
+import javax.resource.spi.ConnectionEvent;
+import javax.resource.spi.ConnectionEventListener;
+import javax.resource.spi.ConnectionRequestInfo;
+import javax.resource.spi.LocalTransaction;
+import javax.resource.spi.ManagedConnection;
+import javax.resource.spi.ManagedConnectionMetaData;
+import javax.security.auth.Subject;
+import javax.transaction.xa.XAResource;
+import javax.xml.ws.BindingProvider;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.bus.spring.SpringBusFactory;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.configuration.Configurer;
+import org.apache.cxf.frontend.ClientProxyFactoryBean;
+import org.apache.cxf.jaxws.EndpointUtils;
+import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
+import org.apache.cxf.jca.core.logging.LoggerHelper;
+
+/**
+ * Represents a "physical" connection to EIS, which provides access to target
+ * web service.  ManagedConnectionImpl creates connection handles for
+ * applications to use the connection backed by this object.
+ */
+public class ManagedConnectionImpl implements ManagedConnection {
+    private static final Logger LOG = LogUtils.getL7dLogger(ManagedConnectionImpl.class);
+    
+    private Set<ConnectionEventListener> listeners = 
+        Collections.synchronizedSet(new HashSet<ConnectionEventListener>());
+    
+    private Map<Object, Subject> handles = 
+        Collections.synchronizedMap(new HashMap<Object, Subject>());
+    private PrintWriter printWriter;
+    
+    private ManagedConnectionFactoryImpl mcf;
+    private ConnectionRequestInfo connReqInfo;
+    private boolean isClosed;
+    private Bus bus;
+    private Object associatedHandle;
+    
+    public ManagedConnectionImpl(ManagedConnectionFactoryImpl mcf,
+            ConnectionRequestInfo connReqInfo, Subject subject) {
+        this.mcf = mcf;
+        this.connReqInfo = connReqInfo;
+    }
+
+    /* -------------------------------------------------------------------
+     * ManagedConnection Methods
+     */
+    
+    public void addConnectionEventListener(ConnectionEventListener listener) {
+        if (LOG.isLoggable(Level.FINER)) {
+            LOG.finer("add listener : " + listener);
+        }
+        listeners.add(listener);
+    }
+
+    public void associateConnection(Object connection) throws ResourceException {
+        if (LOG.isLoggable(Level.FINER)) {
+            LOG.finer("associate handle : " + connection);
+        }
+        associatedHandle = connection;
+        // nothing needs to be done as app gets a copy of client proxy
+    }
+
+    public void cleanup() throws ResourceException {
+        if (LOG.isLoggable(Level.FINER)) {
+            LOG.finer("cleanup");
+        }
+        handles.clear();
+        isClosed = false;
+    }
+
+    public void destroy() throws ResourceException {
+        if (LOG.isLoggable(Level.FINER)) {
+            LOG.finer("destroy");
+        }
+        handles.clear();
+        isClosed = false;
+        bus = null;
+        connReqInfo = null;
+    }
+
+    public Object getConnection(Subject subject,
+            ConnectionRequestInfo cxRequestInfo) throws ResourceException {
+        if (LOG.isLoggable(Level.FINER)) {
+            LOG.finer("get handle for subject=" + subject + " cxRequestInfo="
+                    + cxRequestInfo);
+        }
+        
+        if (isClosed) {
+            throw new ResourceException("connection has been closed");
+        }
+        
+        // check request info
+        if (!connReqInfo.equals(cxRequestInfo)) {
+            throw new ResourceException("connection request info: " + cxRequestInfo
+                    + " does not match " + connReqInfo);
+        }
+        
+        CXFConnectionSpec spec = (CXFConnectionSpec)cxRequestInfo;
+
+        Object handle = createConnectionHandle(spec);
+        handles.put(handle, subject);
+        associatedHandle = handle;
+        return handle;
+        
+    }
+
+    public LocalTransaction getLocalTransaction() throws ResourceException {
+        throw new NotSupportedException("LocalTransaction is not supported.");
+    }
+
+    public PrintWriter getLogWriter() throws ResourceException {
+        return printWriter;
+    }
+
+    public ManagedConnectionMetaData getMetaData() throws ResourceException {
+        return new CXFManagedConnectionMetaData(getUserName());
+    }
+
+    public XAResource getXAResource() throws ResourceException {
+        throw new NotSupportedException("XAResource is not supported.");
+    }
+
+    public void removeConnectionEventListener(ConnectionEventListener listener) {
+        listeners.remove(listener);
+    }
+
+    public void setLogWriter(PrintWriter out) throws ResourceException {
+        printWriter = out;
+
+        if (printWriter != null) {
+            LoggerHelper.initializeLoggingOnWriter(printWriter);
+        }
+    }
+    
+    /* -------------------------------------------------------------------
+     * Public Methods
+     */
+
+    public ConnectionRequestInfo getRequestInfo() {
+        return connReqInfo;
+    }
+    
+    public ManagedConnectionFactoryImpl getManagedConnectionFactoryImpl() {
+        return mcf;
+    }
+    
+    /* -------------------------------------------------------------------
+     * Private Methods
+     */
+    
+    private void sendEvent(final ConnectionEvent coEvent) {
+        synchronized (listeners) {
+            Iterator<ConnectionEventListener> iterator = listeners.iterator();
+            while (iterator.hasNext()) {
+                sendEventToListener(iterator.next(), coEvent);
+            }
+        }
+    }
+
+    private void sendEventToListener(ConnectionEventListener listener, 
+            ConnectionEvent coEvent) {
+        if (coEvent.getId() == ConnectionEvent.CONNECTION_CLOSED) {
+            listener.connectionClosed(coEvent);
+        }
+
+        if (coEvent.getId() == ConnectionEvent.LOCAL_TRANSACTION_COMMITTED) {
+            listener.localTransactionCommitted(coEvent);
+        }
+
+        if (coEvent.getId() == ConnectionEvent.LOCAL_TRANSACTION_ROLLEDBACK) {
+            listener.localTransactionRolledback(coEvent);
+        }
+
+        if (coEvent.getId() == ConnectionEvent.LOCAL_TRANSACTION_STARTED) {
+            listener.localTransactionStarted(coEvent);
+        }
+
+        if (coEvent.getId() == ConnectionEvent.CONNECTION_ERROR_OCCURRED) {
+            listener.connectionErrorOccurred(coEvent);
+        }
+        
+    }
+    
+    private String getUserName() {
+        if (associatedHandle != null) {
+            Subject subject = handles.get(associatedHandle);
+            if (subject != null) {
+                return subject.toString();
+            }
+        } 
+        return null;
+        
+    }
+
+    private Object createConnectionHandle(final CXFConnectionSpec spec) {
+                                
+        Class<?> interfaces[] = {CXFConnection.class, BindingProvider.class, 
+                spec.getServiceClass()};
+
+        return Proxy.newProxyInstance(spec.getServiceClass().getClassLoader(), 
+                interfaces, new ConnectionInvocationHandler(
+                        createClientProxy(spec), spec));
+    }
+    
+    private Object createClientProxy(final CXFConnectionSpec spec) {
+        
+        validateConnectionSpec(spec);
+        ClientProxyFactoryBean factory = null;
+
+        if (EndpointUtils.hasWebServiceAnnotation(spec.getServiceClass())) {
+            factory = new JaxWsProxyFactoryBean();
+        } else {
+            factory = new ClientProxyFactoryBean();
+        }
+              
+        factory.setBus(getBus(spec.getBusConfigURL()));
+        factory.setServiceClass(spec.getServiceClass());
+        factory.getServiceFactory().setEndpointName(spec.getEndpointName());
+        factory.getServiceFactory().setServiceName(spec.getServiceName());
+        factory.getServiceFactory().setWsdlURL(spec.getWsdlURL());
+
+        if (spec.getAddress() != null) {
+            factory.setAddress(spec.getAddress());
+        }
+        
+        configureObject(spec.getEndpointName().toString() + ".jaxws-client.proxyFactory",
factory);
+
+        return factory.create();
+
+    }
+
+    private void validateConnectionSpec(CXFConnectionSpec spec) {
+        if (spec.getServiceClass() == null) {
+            throw new IllegalArgumentException("no serviceClass in connection spec");
+        }
+        
+        if (spec.getEndpointName() == null) {
+            throw new IllegalArgumentException("no endpointName in connection spec");
+        }
+        
+        if (spec.getServiceName() == null) {
+            throw new IllegalArgumentException("no serviceName in connection spec");
+        }
+        
+        if (spec.getWsdlURL() == null) {
+            throw new IllegalArgumentException("no wsdlURL in connection spec");
+        }
+    }
+
+    private void configureObject(String name, Object instance) {
+        Configurer configurer = bus.getExtension(Configurer.class);
+        if (null != configurer) {
+            configurer.configureBean(name, instance);
+        }
+    }
+    
+    private synchronized Bus getBus(URL busConfigLocation) {
+        if (bus == null) {
+            if (busConfigLocation != null) {
+                if (LOG.isLoggable(Level.FINE)) {
+                    LOG.fine("Create bus from location " + busConfigLocation);
+                }
+                bus = new SpringBusFactory().createBus(busConfigLocation);
+            } else if (mcf.getBusConfigURL() != null) {
+                
+                if (LOG.isLoggable(Level.FINE)) {
+                    LOG.fine("Create bus from URL " + mcf.getBusConfigURL());
+                }
+                
+                URL url = null;
+                try {
+                    url = new URL(mcf.getBusConfigURL());
+                } catch (MalformedURLException e) {
+                    LOG.warning("Malformed URL " + mcf.getBusConfigURL());
+                }
+
+                if (url != null) {
+                    bus = new SpringBusFactory().createBus(url);
+                }
+            } 
+            
+            if (bus == null) {
+                if (LOG.isLoggable(Level.FINE)) {
+                    LOG.fine("Create default bus");
+                }
+                bus = BusFactory.getDefaultBus();
+            }
+        }
+        return bus;
+    }
+
+    private class ConnectionInvocationHandler implements InvocationHandler {
+        private Object target;
+        private CXFConnectionSpec spec;
+        
+        ConnectionInvocationHandler(Object target, CXFConnectionSpec spec) {
+            this.target = target;
+            this.spec = spec;
+        }
+
+        public Object invoke(Object proxy, Method method, Object[] args)
+            throws Throwable {
+            
+            if (LOG.isLoggable(Level.FINEST)) {
+                LOG.finest("invoke connection spec:" + spec + " method=" + method);
+            }
+            
+            if ("hashCode".equals(method.getName()) || "equals".equals(method.getName()))
{
+                return method.invoke(Proxy.getInvocationHandler(proxy), args);
+                
+            }
+            
+            if ("toString".equals(method.getName())) {
+                return "ManagedConnection: " + spec;
+            }
+            
+            if (!handles.containsKey(proxy)) {
+                throw new IllegalArgumentException("Stale connection");
+            }
+            
+            if ("getService".equals(method.getName())) {
+                return handleGetServiceMethod(proxy, method, args);
+            } else if ("close".equals(method.getName())) {
+                return handleCloseMethod(proxy, method, args);
+
+            } else {
+                throw new IllegalArgumentException("Unhandled method " + method);
+            }
+        }
+
+        private Object handleGetServiceMethod(Object proxy, Method method,
+                Object[] args) {
+
+            if (!spec.getServiceClass().equals(args[0])) {
+                throw new IllegalArgumentException("serviceClass " 
+                        + args[0] + " does not match " + spec.getServiceClass());
+            }                                      
+                                                                          
+            return target;
+        }
+        
+        private Object handleCloseMethod(Object proxy, Method method,
+                Object[] args) {
+            
+            handles.remove(proxy);
+            associatedHandle = null;
+            if (handles.isEmpty()) {
+                isClosed = true;
+                ConnectionEvent event = new ConnectionEvent(ManagedConnectionImpl.this,
+                        ConnectionEvent.CONNECTION_CLOSED);
+                event.setConnectionHandle(proxy);
+                sendEvent(event);
+            }
+            
+            return null;
+        }
+    }
+   
+}

Propchange: cxf/trunk/integration/jca/src/main/java/org/apache/cxf/jca/outbound/ManagedConnectionImpl.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: cxf/trunk/integration/jca/src/main/java/org/apache/cxf/jca/outbound/ManagedConnectionImpl.java
------------------------------------------------------------------------------
    svn:keywords = Rev Date



Mime
View raw message