Jakarta Connectors

ResourceAdapter

Specification: Jakarta Connectors

Version: 2.1

Status: Final

Release: 17 April 2022
 package jakarta.resource.spi;

 import jakarta.resource.spi.work.WorkManager;

 public interface ResourceAdapter {

     void start(BootstrapContext) // startup notification
          throws ResourceAdapterInternalException;

     void stop(); // shutdown notification
     ... // other operations
 }

public interface BootstrapContext {

    WorkManager getWorkManager();
    ... // other operations
}
import jakarta.resource.spi.ResourceAdapterAssociation;
import jakarta.resource.spi.ManagedConnectionFactory;

public class ManagedConnectionFactoryImpl
         implements ManagedConnectionFactory,
         ResourceAdapterAssociation {

   ResourceAdapter getResourceAdapter();

   void setResourceAdapter(ResourceAdapter) throws ResourceException;

   ... // other methods
}
import jakarta.resource.spi.ActivationSpec;

// ActivationSpec interface extends ResourceAdapterAssociation interface.

public class ActivationSpecImpl implements ActivationSpec {

    ResourceAdapter getResourceAdapter();

    void setResourceAdapter(ResourceAdapter) throws ResourceException;

    ... // other methods
}
package com.xyz.adapter;

import jakarta.resource.spi.ResourceAdapter;
import jakarta.resource.spi.BootstrapContext;
import jakarta.resource.spi.work.*;

public class MyResourceAdapterImpl implements ResourceAdapter {

    void start(BootstrapContext serverCtx) {
        // 1. setup network endpoints
        ...

        // 2. get WorkManager reference
        WorkManager wm = serverCtx.getWorkManager();

       // 3. provide Work objects to WorkManager
       for (i = 0; i < 10; i++) {
           Work work = new MyWork(...);
           try {
               wm.startWork(work);
          } catch (WorkException we) {
              // handle the exception
          }
      }
   }

   void stop() {
       // release Work instances, do cleanup and return.
   }
}

public class MyWork implements Work {

    void release() {
        // set a flag to hint the Work instance to complete.
        // Note, the calling thread is different from
        // the active thread in which this instance is executing.
    }

    void run() {
        // do work (call application components, monitor
        // network ports, etc.).

    }
}
// obtain the initial JNDI Naming context
Context initctx = new InitialContext();

// perform JNDI lookup to obtain the connection factory
jakarta.resource.cci.ConnectionFactory cxf =
   (jakarta.resource.cci.ConnectionFactory)
      initctx.lookup(“java:comp/env/eis/MyEIS”);
 //recommended: connection handle creation, use and close
 Connection con = null;
 try {
     con = cf.getConnection();
    //use the con handle to interact with the EIS
 } finally {
    if (con != null){
        con.close();
    }
 }
public interface jakarta.resource.cci.ConnectionFactory extends java.io.Serializable,
                 jakarta.resource.Referenceable{

    public jakarta.resource.cci.Connection getConnection()
                throws jakarta.resource.ResourceException;
 ...
}

public interface jakarta.resource.cci.Connection {

    public void close() throws jakarta.resource.ResourceException;
    ...
}
public interface com.myeis.ConnectionFactory extends java.io.Serializable,
                 jakarta.resource.Referenceable {

    public com.myeis.Connection getConnection()
             throws com.myeis.ResourceException;
    ...
}

public interface com.myeis.Connection {

    public void close() throws com.myeis.ResourceException;
    ...
}
public interface jakarta.resource.spi.ConnectionManager
          extends java.io.Serializable {

    public Object allocateConnection( ManagedConnectionFactory mcf,
                  ConnectionRequestInfo cxRequestInfo)
                  throws ResourceException;
}

public interface jakarta.resource.spi.ConnectionRequestInfo {

    public boolean equals(Object other);

    public int hashCode();

}
public interface jakarta.resource.spi.ConnectionManager
       extends java.io.Serializable {

 public Object allocateConnection(ManagedConnectionFactory mcf,
                   ConnectionRequestInfo cxRequestInfo)
                   throws ResourceException;
}
public interface jakarta.resource.spi.ManagedConnectionFactory
       extends java.io.Serializable {

     public Object createConnectionFactory( ConnectionManager connectionManager)
                   throws ResourceException;

     public Object createConnectionFactory()
                   throws ResourceException;

     public ManagedConnection createManagedConnection(javax.security.auth.Subject subject,
                                                   ConnectionRequestInfo cxRequestInfo)
                                                   throws ResourceException;

     public ManagedConnection matchManagedConnections( java.util.Set connectionSet,
                                                       javax.security.auth.Subject subject,
                                                       ConnectionRequestInfo cxRequestInfo)
                                                       throws ResourceException;

    public boolean equals(Object other);

    public int hashCode();
}
import java.util.Set;

interface ValidatingManagedConnectionFactory {

 Set getInvalidConnections(Set connectionSet) throws ResourceException;

}
public interface jakarta.resource.spi.ManagedConnection {

 public Object getConnection( javax.security.auth.Subject subject,
                    ConnectionRequestInfo cxRequestInfo)
                    throws ResourceException;

 public void destroy() throws ResourceException;

 public void cleanup() throws ResourceException;

 // Methods for Connection and transaction event notifications

 public void addConnectionEventListener(ConnectionEventListener listener);

 public void removeConnectionEventListener(ConnectionEventListener listener);

 public ManagedConnectionMetaData getMetaData() throws ResourceException;

 // Additional methods - specified in the other sections

 ...

}
public interface jakarta.resource.spi.ConnectionEventListener {

 public void connectionClosed(ConnectionEvent event);

 public void connectionErrorOccurred(ConnectionEvent event);

 // Local Transaction Management related events

 public void localTransactionStarted(ConnectionEvent event);

 public void localTransactionCommitted(ConnectionEvent event);

 public void localTransactionRolledback(ConnectionEvent event);

}
public interface jakarta.resource.spi.ManagedConnectionFactory
            extends java.io.Serializable {

  public void setLogWriter(java.io.PrintWriter out)
                 throws ResourceException;

  public java.io.PrintWriter getLogWriter()
                 throws ResourceException;

 ...

}
public interface jakarta.resource.spi.ManagedConnection {

 public void setLogWriter(java.io.PrintWriter out)
                throws ResourceException;

 public java.io.PrintWriter getLogWriter()
                throws ResourceException;
 ...
}
// Application Client Code
// Create an instance of the ManagedConnectionFactory
// implementation class passing in initialization parameters
// (if any) for this instance

com.myeis.ManagedConnectionFactoryImpl mcf =
     new com.myeis.ManagedConnectionFactoryImpl(...);

// Set properties on the ManagedConnectionFactory instance
// Note: Properties are defined on the implementation class
// and not on the jakarta.resource.spi.ManagedConnectionFactory
// interface
mcf.setServerName(...);
mcf.setPortNumber(...);

// set remaining properties
...

// Get access to connection factory. The ConnectionFactory instance
// gets initialized with the default ConnectionManager provided
// by the resource adapter

jakarta.resource.cci.ConnectionFactory cxf =
    (jakarta.resource.cci.ConnectionFactory) mcf.createConnectionFactory();

// Get a connection using the ConnectionFactory instance
jakarta.resource.cci.Connection cx = cxf.getConnection(...);

// use connection to access the underlying EIS instance

...

// Close the connection
cx.close();
public interface jakarta.resource.spi.ManagedConnection {

 public XAResource getXAResource() throws ResourceException;

 public LocalTransaction getLocalTransaction()
             throws ResourceException;
 ...

}
public interface
javax.transaction.xa.XAResource {

 public void commit(Xid xid, boolean onePhase) throws XAException;

 public void end(Xid xid, int flags) throws XAException;

 public void forget(Xid xid) throws XAException;

 public int prepare(Xid xid) throws XAException;

 public Xid[] recover(int flag) throws XAException;

 public void rollback(Xid xid) throws XAException;

 public void start(Xid xid, int flags) throws XAException;

}
public interface
jakarta.resource.spi.LocalTransaction {

 public void begin() throws ResourceException;

 public void commit() throws ResourceException;

 public void rollback() throws ResourceException;

}
public interface
jakarta.resource.spi.ConnectionEventListener {

 // Local Transaction Management related events

 public void localTransactionStarted(ConnectionEvent event);

 public void localTransactionCommitted(ConnectionEvent event);

 public void localTransactionRolledback(ConnectionEvent event);
 ...

}
public interface
jakarta.resource.spi.ManagedConnection {

 public void associateConnection(Object connection) throws ResourceException;

 ...

}
 package jakarta.resource.spi;

 public interface TransactionSupport extends Serializable {

 public enum TransactionSupportLevel
 {NoTransaction, LocalTransaction, XATransaction}

 public TransactionSupportLevel getTransactionSupport();

 }
public interface
jakarta.resource.spi.BootstrapContext {

 TransactionSynchronizationRegistry getTransactionSynchronizationRegistry();

 ...

}
package jakarta.resource.spi;

import jakarta.resource.ResourceException;

interface LazyAssociatableConnectionManager {
   // application server

  void associateConnection( Object connection,
                            ManagedConnectionFactory mcf,
                            ConnectionRequestInfo info)
                            throws ResourceException;

 void inactiveConnectionClosed(Object connection, ManagedConnectionFactory mcf);

}

interface DissociatableManagedConnection {
// resource adapter

 void dissociateConnections() throws ResourceException;

}
package jakarta.resource.spi;

import jakarta.resource.ResourceException;
import javax.transaction.xa.Xid;

interface LazyEnlistableConnectionManager {
// application server

 void lazyEnlist(ManagedConnection) throws ResourceException;

}

interface LazyEnlistableManagedConnection {
// resource adapter
}
// Method in an application component

Context initctx = new InitialContext();

// perform JNDI lookup to obtain connection factory
jakarta.resource.cci.ConnectionFactory cxf =
 (jakarta.resource.cci.ConnectionFactory)initctx.lookup(“java:comp/env/eis/MyEIS”);

// Invoke factory to obtain a connection. The security
// information is not passed in the getConnection method

jakarta.resource.cci.Connection cx = cxf.getConnection();

...
// Method in an application component

Context initctx = new InitialContext();

// perform JNDI lookup to obtain connectionfactory
jakarta.resource.cci.ConnectionFactory cxf =
     (jakarta.resource.cci.ConnectionFactory)initctx.lookup(“java:comp/env/eis/MyEIS”);

// Invoke factory to obtain a connection

com.myeis.ConnectionSpecImpl properties = ..
// get a new ConnectionSpec
properties.setUserName(“...”);
properties.setPassword(“...”);

jakarta.resource.cci.Connection cx = cxf.getConnection(properties);

...
public interface java.security.Principal {

 public boolean equals(Object another);

 public String getName();

 public String toString();

 public int hashCode();

}
public interface jakarta.resource.spi.security.GenericCredential {

 public String getName();

 public String getMechType();

 public byte[] getCredentialData() throws jakarta.resource.spi.SecurityException;

 public boolean equals(Object another);

 public int hashCode();

}
public final class jakarta.resource.spi.security.PasswordCredential
  implements java.io.Serializable {

 public PasswordCredential(String userName, char[] password)  { ... }

 public String getUserName() { ... }

 public char[] getPassword() { ... }

 public ManagedConnectionFactory getManagedConnectionFactory() { ... }

 public void setManagedConnectionFactory( ManagedConnectionFactory mcf) { ... }

 public boolean equals(Object other) { ... }

 public int hashCode() { ... }

}
public interface jakarta.resource.spi.ConnectionManager
           extends java.io.Serializable {

 public Object allocateConnection( ManagedConnectionFactory mcf,
                                   ConnectionRequestInfo cxRequestInfo)
                                   throws ResourceException;

}
public interface jakarta.resource.spi.ManagedConnectionFactory
                 extends java.io.Serializable {

 public ManagedConnection createManagedConnection(
                          javax.security.auth.Subject subject,
                          ConnectionRequestInfo cxRequestInfo)
 ...
}
public interface jakarta.resource.spi.ManagedConnection {

 public Object getConnection(
                  javax.security.auth.Subject subject,
                  ConnectionRequestInfo cxRequestInfo)
                  throws ResourceException;
 ...
}
package jakarta.resource.spi.work;

import java.util.EventObject;
import java.util.EventListener;
import javax.transaction.xa.Xid;
import jakarta.resource.ResourceException;
import jakarta.resource.NotSupportedException;

public interface Work extends Runnable {
 void release();
}

public interface WorkManager {

 long IMMEDIATE = 0L; // immediate action
 long INDEFINITE = Long.MAX_VALUE; // no time constraint
 long UNKNOWN = -1; // indicates an unknown value.

 void doWork(Work work) throws WorkException; // startTimeout = INDEFINITE

 void doWork(Work work, long startTimeout, ExecutionContext ctx, WorkListener lsnr) throws WorkException;

 long startWork(Work work) throws WorkException; // startTimeout = INDEFINITE

 long startWork(Work work, long startTimeout, ExecutionContext ctx, WorkListener lsnr) throws WorkException;

 void scheduleWork(Work work) throws WorkException; // startTimeout = INDEFINITE

 void scheduleWork(Work work, long startTimeout, ExecutionContext ctx, WorkListener lsnr) throws WorkException;

}

public interface WorkListener extends EventListener {

 void workAccepted(WorkEvent e);

 void workRejected(WorkEvent e);

 void workStarted(WorkEvent e);

 void workCompleted(WorkEvent e);

}

public class WorkAdapter implements WorkListener {

 public void workAccepted(WorkEvent e) {}

 public void workRejected(WorkEvent e) {}

 public void workStarted(WorkEvent e) {}

 public void workCompleted(WorkEvent e) {}

}

public class WorkEvent extends EventObject {

 public static final int WORK_ACCEPTED = 1;
 public static final int WORK_REJECTED = 2;
 public static final int WORK_STARTED = 3;
 public static final int WORK_COMPLETED = 4;

 public WorkEvent(Object source, int type, Work work, WorkException exc) { ... }

 public WorkEvent(Object source, int type, Work work, WorkException exc, long startDuration) {
... }

 public int getType() { ... }

 public Work getWork() { ... }

 public long getStartDuration() { ... }

 public WorkException getException() { ... }

}

public class ExecutionContext {

 public void setXid(xid) { ... }

 public Xid getXid() { ... }

 public long getTransactionTimeout() { ... }

 public void setTransactionTimeout(long seconds)

 throws NotSupportedException { ... }

}

public class WorkException extends ResourceException {

 // Indicates an internal error condition.
 public static final String INTERNAL = "-1";

 // Undefined error code.
 public static final String UNDEFINED = "0";

 // Indicates start timeout expiration.
 public static final String START_TIMED_OUT = "1";

 // Indicates that concurrent work within a transaction is
 // disallowed.
 public static final String TX_CONCURRENT_WORK_DISALLOWED = "2";

 // Indicates a failure in recreating the specified transaction.
 public static final String TX_RECREATE_FAILED = "3";

 public WorkException() { ... }

 public WorkException(String message) { ...
 }

 public WorkException(Throwable cause) { ...
 }

 public WorkException(String message, Throwable cause) { ... }

 public String getMessage() { ... }

}

public class WorkRejectedException extends WorkException {

 public WorkRejectedException() { ... }

 public WorkRejectedException(String message)
{ ... }

 public WorkRejectedException(Throwable cause) { ... }

 public WorkRejectedException(String message, Throwable cause)
 { ... }

}

public class WorkCompletedException extends WorkException {

 public WorkCompletedException() { ... }

 public WorkCompletedException(String message) { ... }

 public WorkCompletedException(Throwable cause) { ... }

 public WorkCompletedException(String message, Throwable cause)
 { ... }

}

public class RetryableUnavailableException extends UnavailableException
             implements jakarta.resource.spi.RetryableException {

}
public interface Work extends Runnable {

 void release();

}
public interface WorkManager {

 long IMMEDIATE = 0L; // immediate action (as soon as possible)
 long INDEFINITE = Long.MAX_VALUE; // no time constraint
 long UNKNOWN = -1; // unknown start delay duration

 // startTimeout = INDEFINITE
 void doWork(Work work) throws WorkException;

 void doWork(Work work, long startTimeout, ExecutionContext, WorkListener) throws WorkException;

 // startTimeout = INDEFINITE
 long startWork(Work work) throws WorkException;

 long startWork(Work work, long startTimeout, ExecutionContext, WorkListener) throws WorkException;

 // startTimeout = INDEFINITE
 void scheduleWork(Work work) throws WorkException;

 void scheduleWork(Work work, long startTimeout, ExecutionContext, WorkListener) throws WorkException;

}
public interface WorkListener extends EventListener {

 void workAccepted(workEvent);

 void workRejected(WorkEvent);

 void workStarted(WorkEvent);

 void workCompleted(WorkEvent);

}
public class WorkEvent extends EventObject {

 public static final int WORK_ACCEPTED = 1;
 public static final int WORK_REJECTED = 2;
 public static final int WORK_STARTED = 3;
 public static final int WORK_COMPLETED = 4;

 public WorkEvent(Object source, int type, Work work, WorkException exc){ ... }

 public WorkEvent(Object source, int type, Work work, WorkException exc, long startDuration) {
 ...
 }

 public int getType() { ... }

 public Work getWork() { ... }

 public long getStartDuration() { ... }

 public WorkException getException() { ... }

}

public abstract class WorkAdapter implements WorkListener {

 public void workAccepted(WorkEvent e) {}

 public void workRejected(WorkEvent e) {}

 public void workStarted(WorkEvent e) {}

 public void workCompleted(WorkEvent e) {}
}
public class ExecutionContext \{

 public void setXid(xid) { ... }

 public Xid getXid() { ... }

 public long getTransactionTimeout() { ... }

 public void setTransactionTimeout(long seconds) throws NotSupportedException { ... }

}
package jakarta.resource.spi;

import java.util.Timer;
import jakarta.resource.spi.UnavailableException;

public interface BootstrapContext {

 ... // other methods

 // returns a new or an unshared instance
 Timer createTimer() throws UnavailableException;

}
package com.xyz.adapter;

import java.util.*;
import jakarta.resource.spi.*;
import jakarta.resource.spi.work.WorkManager;

// ResourceAdapter JavaBean
public class MyResourceAdapterImpl implements ResourceAdapter {

 BootstrapContext bootstrapCtx = null;

 public void start(BootstrapContext ctx) {
 bootstrapCtx = ctx;
 ... // other operations
 }

 ... // other methods
}

 { // sample resource adapter code snippet toshow Timer usage

 MyResourceAdapterImpl myRA = ... // getResourceAdapter JavaBean

 Timer timer = myRA.bootstrapCtx.createTimer(); // get a Timer instance

 WorkManager workManager = myRA.bootstrapCtx.getWorkManager();

 timer.schedule(
   new TimerTask () {
     public void run() {
        try {
            workManager.scheduleWork(new MyWork());
        } catch (WorkException we) {
            we.printStackTrace();
        }
     }
   }, 0, 1000); // one second interval

}
package jakarta.resource.spi.work;

import java.io.Serializable;

//Marker interface to indicate to the WorkManager that the
//Work may be distributed to a different WorkManager for execution

public interface DistributableWork extends Work, Serializable {

}
 _Work_ instances that may be distributed by
a _WorkManager_ must implement the _DistributableWork_ interface. A
_Work_ instance that implements the _DistributableWork_ interface must
not have any reference to local resource-adapter state. This allows the
_WorkManager_ to delegate processing of the _Work_ instance to a
different _WorkManager_ instance that is running in a different Java
virtual machine.
package jakarta.resource.spi.work;

//Marker interface to indicate that the WorkManager supports the
//distributed processing of Work instances

public interface DistributableWorkManager extends WorkManager {

}
 package jakarta.resource.spi.work;

 public interface WorkContextProvider extends Serializable {

 List<WorkContext> getWorkContexts();

 }

 public interface WorkContext extends Serializable{

 String getName();

 String getDescription();

 }

 public class TransactionContext extends ExecutionContext implements WorkContext {

 public TransactionContext(Xid xid) { ... }

 public TransactionContext( Xid xid, long timeout){ ... }

 public String getName(){
    return "TransactionContext";
 }

 // ... other methods

 }

 public abstract class SecurityContext implements WorkContext {

 public String getName(){
     return "SecurityContext";
 }

 // .... other SecurityContext related methods

 }

 public class WorkContextErrorCodes {

 // Indicates an unsuppored context type
 public static final String UNSUPPORTED_CONTEXT_TYPE = "1";

 // Indicates more than one contexts
 // of the same type passed in for Work
 public static final String DUPLICATE_CONTEXTS = "2";

 // Indicates failure in recreating the WorkContext
 public static final String CONTEXT_SETUP_FAILED = "3";

 // Indicates that the container cannot support
 // recreating the context
 public static final String CONTEXT_SETUP_UNSUPPORTED = "4";

 }

 public interface WorkContextLifecycleListener {

 // indicates that the WorkContext was set successfully
 void contextSetupComplete();

 // Indicates that the WorkContext setup failed
 void contextSetupFailed(String errorCode);

 }
 package jakarta.resource.spi.work;

 public interface WorkContext extends
Serializable{

 String getName();

 String getDescription();

 }
 package jakarta.resource.spi.work;

 public interface WorkContextProvider extends
Serializable {

 List<WorkContext> getWorkContexts();

 }
 public interface BootstrapContext {

 // ... other operations

 boolean isContextSupported( Class<? extends WorkContext> workContextClass);
 }
 public class WorkContextErrorCodes \{

 // Indicates an unsupported context type
 public static final String UNSUPPORTED_CONTEXT_TYPE = "1";

 // Indicates more than one contexts of the same type passed
 // in for Work
 public static final String DUPLICATE_CONTEXTS = "2";

 // Indicates failure in recreating the WorkContext
 public static final String CONTEXT_SETUP_FAILED = "3";

 // Indicates that the container cannot support recreating
 // the context
 public static final String CONTEXT_SETUP_UNSUPPORTED = "4";

 }
 public class TransactionContext extends ExecutionContext implements WorkContext {

 public TransactionContext(Xid xid) {..}

 public TransactionContext(Xid xid, long timeout) {..}

 public String getDescription() {
     return "Transaction Context";
 }

 public String getName() {
    return "TransactionContext";
 }

 }
 public class HintsContext implements WorkContext {

 protected String description = "Hints Context";
 protected String name = "HintsContext";

 public String getDescription() {
     return description;
 }

 public String getName() {
     return name;
 }

 public void setDescription(String description){
     this.description = description;
 }

 public void setName(String name){
     this.name = name;
 }

 Map<String, Serializable> hints = new HashMap<String, Serializable>();

 public void setHint(String hintName, Serializable value) {
     hints.put(hintName, value);
 }

 public Map<String, Serializable> getHints() {
     return hints;
 }

 }
 public interface WorkContextLifecycleListener {

 // Indicates that the WorkContext was set successfully
 void contextSetupComplete();

 // Indicates that the WorkContext setup failed
 void contextSetupFailed(String errorCode);

 }
 public class MyResourceAdapterImpl implements ResourceAdapter {

 ...

 public void start(BootstrapContext ctx) {
   bootstrapCtx = ctx;
 }

 ...

 {

 WorkManager workManager = myRA.bootstrapCtx.getWorkManager();
 workManager.scheduleWork(new MyWork());

 ...

 }

 }

 public class MyWork implements Work, WorkContextProvider {

 void release(){ ..}

 List<WorkContext> getWorkContexts() {

 TransactionContext txIn = new TransactionContext(xid);
 List<WorkContext> icList = new ArrayList<WorkContext>();
 icList.add(txIn);

 // Add additional WorkContexts
 return icList;

 }

 void run(){
 // Deliver message to MessageEndpoint;
 }

 }
package jakarta.resource.spi;

import java.beans.PropertyDescriptor;
import jakarta.resource.NotSupportedException;
import jakarta.resource.spi.endpoint.MessageEndpointFactory;

public interface ResourceAdapter {

 ... // other methods

 void endpointActivation(MessageEndpointFactory, ActivationSpec) throws ResourceException;

 void endpointDeactivation(MessageEndpointFactory, ActivationSpec);

 XAResource[] getXAResources(ActivationSpec[] specs) throws ResourceException;
}

public interface ActivationSpec { // JavaBean

 void validate() throws InvalidPropertyException;

}

public class InvalidPropertyException extends ResourceException {

 public InvalidPropertyException() { ... }

 public InvalidPropertyException(String message) { ... }

 public InvalidPropertyException(String message, String errorCode) { ... }

 public void setInvalidPropertyDescriptors( PropertyDescriptor[] invalidProperties) {
    ...
 }

 public PropertyDescriptor[] getInvalidPropertyDescriptors() {
    ...
 }
}

public class UnavailableException extends ResourceException {

 public UnavailableException() { ... }

 public UnavailableException(String message)
 { ... }

 public UnavailableException(Throwable cause)
 { ... }

 public UnavailableException(String message, Throwable cause) {
   ...
 }

}

public class RetryableUnavailableException extends UnavailableException
                implements jakarta.resource.spi.RetryableException {}
package jakarta.resource.spi.endpoint;

import java.lang.Exception;
import java.lang.Throwable;
import java.lang.NoSuchMethodException;
import javax.transaction.xa.XAResource;
import jakarta.resource.ResourceException;
import jakarta.resource.spi.UnavailableException;

public interface MessageEndpointFactory {

 MessageEndpoint createEndpoint(XAResource) throws UnavailableException;

 MessageEndpoint createEndpoint(XAResource, long) throws UnavailableException;

 String getActivationName();

 Class<?> getEndpointClass();

 boolean isDeliveryTransacted(java.lang.reflect.Method)
              throws NoSuchMethodException;
}

public interface MessageEndpoint {

 void beforeDelivery(java.lang.reflect.Method)
       throws NoSuchMethodException, ResourceException;

 void afterDelivery() throws ResourceException;

 void release();
}
<!-- message-driven bean deployment descriptor -->
 ...
 <activation-config>
   <activation-config-property>
     <activation-config-property-name>
     destinationType
   </activation-config-property-name>
   <activation-config-property-value>
     jakarta.jms.Topic
   </activation-config-property-value>
 </activation-config-property>
 <activation-config-property>
   <activation-config-property-name>
     SubscriptionDurability
   </activation-config-property-name>
   <activation-config-property-value>
     Durable
   </activation-config-property-value>
 </activation-config-property>
 <activation-config-property>
   <activation-config-property-name>
     MessageSelector
   </activation-config-property-name>
   <activation-config-property-value>
     JMSType = 'car' AND color = 'blue'
   </activation-config-property-value>
 </activation-config-property>
 ...
 </activation-config>
...
// Reader Thread(s)
{
 // 1. Strip off msg header and parse message description
 // 2. Choose a set of endpoints which match message description
 // 3. Place message in appropriate buffer queue
 // 4. Notify worker threads
}

// Worker Thread(s)
{
 // 1. Wake up on notification (message arrival)
 // 2. Pick up the message and locate the MessageEndpointFactory
 // associated with the subscription
 Message msg = ...;
 MessageEndpointFactory endpointFactory = ...;
 MyXAResource xaResource = ...; // for transacted delivery

 // 4. Obtain a message endpoint and narrow it to the
 // correct type.
 // ActivationSpec has endpoint message listener type
 // information.
 Object obj = endpointFactory.createEndpoint(xaResource);
 jakarta.jms.MessageListener endpoint = (jakarta.jms.MessageListener) obj;

 // 5. Link the XAResource with the endpoint. This allows the
 // XAResource object to know which endpoint/message delivery
 // is transacted when it receive transaction notifications.
 // This may be unnecessary depending on the implementation.
 xaResource.setEndpoint(endpoint);

 // Note: It may be possible to make the XAResource object
 // thread-safe/reentrant and reuse the same object for receiving
 // transaction notifications for different endpoints.
 // The XAResource object may use thread-local storage to
 // remember state, and thus avoid creating multiple
 // XAResource objects.

 // 6. Deliver the message.
 endpoint.onMessage(msg);

 // 7. Wait for notification of incoming messages
 // and repeat the above steps on message arrival.
}

package com.wombat.ra;

import javax.transaction.xa.*;

class MyXAResource implements javax.transaction.xa.XAResource {

 public void start(Xid xid) throws XAException {
 // Associate the message delivery with the transaction id.
 // That is, create the tuple (msg id, transaction id) in
 // memory.

 }

 public int prepare(Xid xid) throws XAException {
 // Forward the tuple (message id, transaction id) to the
 // message provider. The provider must persist this
 // information, which is used during crash recovery by the
 // application server. During crash recovery,
 // the application calls the message provider, via the
 // recover method on an XAResource object, queries for
 // a list of in-doubt transactions and completes them.
 // Upon successful completion, return "ready_to_commit"
 // vote, else return "rollback_only" vote.

 }

 public void commit(Xid xid, boolean onePhase)
      throws XAException {
 // forward the transaction ID to the message provider. This
 // serves as the acknowledgement that a message was
 // delivered.

 }

 public void rollback(Xid xid) throws XAException {
 // forward the transaction ID to the message provider. This
 // indicates to the provider that the message was not
 // delivered.
 }

 ...; // other methods
}
<?xml version="1.0" encoding="UTF-8"?>
<connector xmlns="http://java.sun.com/xml/ns/j2ee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.5">

 <display-name>Wombat-JMSAdapter</display-name>
 <vendor-name>Wombat Software Systems</vendor-name>
 <eis-type>JMS Provider</eis-type>
 <resourceadapter-version>1.0</resourceadapter-version>

 <resourceadapter>
   <resourceadapter-class>
     com.wombat.connector.jms.JMSAdapterImpl
   </resourceadapter-class>

   <!-- ResourceAdapter default configuration properties -->
   <config-property>
     <config-property-name>ServerName</config-property-name>
     <config-property-type>java.lang.String</config-property-type>
     <config-property-value>WombatServer</config-property-value>
   </config-property>
   <config-property>
     config-property-name>PortNumber</config-property-name>
     <config-property-type>java.lang.String</config-property-type>
     <config-property-value>1050</config-property-value>
   </config-property>
   <config-property>
     <config-property-name>OperationalMode</config-property-name>
     <config-property-type>java.lang.String</config-property-type>
     <config-property-value>Managed</config-property-value>
   </config-property>
   <config-property>
     <config-property-name>ContainerType</config-property-name>
     <config-property-type>java.lang.String</config-property-type>
     <config-property-value>EJB-WEB</config-property-value>
   </config-property>

   <outbound-resourceadapter>
    <connection-definition>
      <managedconnectionfactory-class>
         com.wombat.connector.jms.QueueManagedConnectionFactoryImpl
      </managedconnectionfactory-class>

      <!-- ManagedConnectionFactory default configuration properties -->
      <config-property>
        <config-property-name>ServerName</config-property-name>
        <config-property-type>java.lang.String</config-property-type>
        <config-property-value>
           WombatQueueServer
        </config-property-value>
      <config-property>
        <config-property-name>PortNumber</config-property-name>
        <config-property-type>java.lang.String</config-property-type>
        <config-property-value>1051</config-property-value>
      </config-property>

      <connectionfactory-interface>
        jakarta.jms.QueueConnectionFactory
      </connectionfactory-interface>
      <connectionfactory-impl-class>
        com.wombat.connector.jms.QueueConnectionFactoryImpl
      </connectionfactory-impl-class>

      <connection-interface>
        jakarta.jms.QueueConnection
      </connection-interface>
      <connection-impl-class>
        com.wombat.connector.jms.QueueConnectionImpl
      </connection-impl-class>
   </connection-definition>

   <connection-definition>
     <managedconnectionfactory-class>
       com.wombat.connector.jms.TopicManagedConnectionFactoryImpl
     </managedconnectionfactory-class>

     <!-- ManagedConnectionFactory default configuration properties -->
     <config-property>
       <config-property-name>ServerName</config-property-name>
       <config-property-type>java.lang.String</config-property-type>
       <config-property-value>
         WombatTopicServer
       </config-property-value>
     </config-property>
     <config-property>
       <config-property-name>PortNumber</config-property-name>
       <config-property-type>java.lang.String</config-property-type>
       <config-property-value>1052</config-property-value>
     </config-property>

     <connectionfactory-interface>
        jakarta.jms.TopicConnectionFactory
     </connectionfactory-interface>
     <connectionfactory-impl-class>
       com.wombat.connector.jms.TopicConnectionFactoryImpl
     </connectionfactory-impl-class>

     <connection-interface>
        jakarta.jms.TopicConnection
     </connection-interface>
     <connection-impl-class>
       com.wombat.connector.jms.TopicConnectionImpl
     </connection-impl-class>
  </connection-definition>

  <connection-definition>
    <managedconnectionfactory-class>
      com.wombat.connector.jms.ManagedConnectionFactoryImpl
    </managedconnectionfactory-class>
 <!--

 This ManagedConnectionFactory JavaBean
inherits the ResourceAdapter

 JavaBean configuration properties, and does
not override any

 of the global defaults.
 -->
    <connectionfactory-interface>
      jakarta.jms.ConnectionFactory
    </connectionfactory-interface>
    <connectionfactory-impl-class>
      com.wombat.connector.jms.ConnectionFactoryImpl
    </connectionfactory-impl-class>

    <connection-interface>
      jakarta.jms.Connection
    </connection-interface>
    <connection-impl-class>
      com.wombat.connector.jms.ConnectionImpl
    </connection-impl-class>
  </connection-definition>

  <transaction-support>XATransaction</transaction-support>
  <reauthentication-support>false</reauthentication-support>
 </outbound-resourceadapter>

 <inbound-resourceadapter>
    <messageadapter>
      <messagelistener>
        <messagelistener-type>
          jakarta.jms.MessageListener
        </messagelistener-type>
        <activationspec>
           <activationspec-class>
             com.wombat.connector.jms.ActivationSpecImpl
           </activationspec-class>
 <!--
 The endpoint deployer configures the
ActivationSpec JavaBean
 and may override some of the global defaults
inherited from
 the ResourceAdapter JavaBean. For example,
the ServerName
 and the PortNumber properties.
 -->

 <!-- required config property names for ActivationSpec -->
           <required-config-property>
            <config-property-name>Destination</config-property-name>
           </required-config-property>
        </activationspec>
      </messagelistener>
    </messageadapter>
  </inbound-resourceadapter>

  <adminobject>
    <adminobject-interface>jakarta.jms.Queue</adminobject-interface>
    <adminobject-class>
      com.wombat.connector.jms.QueueImp
    </adminobject-class>
  </adminobject>
  <adminobject>
    <adminobject-interface>jakarta.jms.Topic</adminobject-interface>
    <adminobject-class>
      com.wombat.connector.jms.TopicImpl
    </adminobject-class>
  </adminobject>
  <adminobject>
    <adminobject-interface>
      jakarta.jms.Destination
    </adminobject-interface>
    <adminobject-class>
      com.wombat.connector.jms.DestinationImpl
    </adminobject-class>
  </adminobject>
</resourceadapter>
</connector>
package com.wombat.connector.jms;

import java.io.Serializable;
import jakarta.resource.spi.ActivationSpec;
import jakarta.resource.spi.InvalidPropertyException;

public class ActivationSpecImpl implements
  ActivationSpec, Serializable {

  public setAcknowledgeMode(String mode) {
    ...
  }

  public String getAcknowledgeMode() { ... }

 public setSubscriptionDurability(String durability) { ... }

 public String getSubscriptionDurability() {
   ... }

 public setMessageSelector(String selector) { ... }

 public String getMessageSelector() { ... }

 public setDestinationType(String destType) { ... }

 public String getDestinationType() { ... }

 public setDestination(String dest) { ... }

 public String getDestination() { ... }

 public setSubscriptionName(String name) { ... }

 public String getSubscriptionName() { ... }

 public setClientId(String id) { ... }

 public String getClientId() { ... }

 public void validate() throws InvalidPropertyException { ... }

}
// get JNDI handle
Context jndiContext = new InitialContext();

// get connection factory
ConnectionFactory connectionFactory = (ConnectionFactory) jndiContext.lookup("QueueConnectionFactory");

// get connection from factory
Connection connection = connectionFactory.getConnection();

// get session from connection
Session session = connection.createSession(true, AUTO_ACKNOWLEDGE);

// get destination from JNDI
Queue stockQueue = (Queue) jndiContext.lookup("StockQueue");

// create a message producer
MessageProducer sender = session.createProducer(stockQueue);

// create a message
TextMessage message = session.createTextMessage();
message.setText(msgData);

// send the message
sender.send(message);
// get JNDI handle
Context jndiContext = new InitialContext();

// get connection factory
ConnectionFactory connectionFactory = (ConnectionFactory)
                   jndiContext.lookup("QueueConnectionFactory");

// get connection from factory
Connection connection = connectionFactory.getConnection();

// get session from connection
Session session = connection.createSession(true, AUTO_ACKNOWLEDGE);

// get destination from JNDI
Queue stockQueue = (Queue) jndiContext.lookup("StockQueue");

// create a message consumer
MessageConsumer receiver = session.createConsumer(stockQueue);

// enable connection to receive messages
connection.start();

// synchronously receive the message
TextMessage message = (TextMessage)receiver.receive(message);
<?xml version="1.0" encoding="UTF-8"?>
<connector xmlns="https://jakarta.ee/xml/ns/jakartaee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           version="2.0">
  <display-name>KangarooAdapter</display-name>
  <vendor-name>Kangaroo Software Inc.</vendor-name>
  <eis-type>JMS Provider</eis-type>
  <resourceadapter-version>1.0</resourceadapter-version>
  <resourceadapter-class>
    com.kangaroo.MyEISAdapterImpl
  </resourceadapter-class>

  <!-- ResourceAdapter default configuration properties -->
  <config-property>
    <description>URL for EIS instance</description>
    <config-property-name>EIS_URL</config-property-name>
    <config-property-type>java.lang.String</config-property-type>
    <config-property-value>TBD</config-property-value>
  </config-property>
  <outbound-resourceadapter>
    <connection-definition>
      <managedconnectionfactory-class>
        com.Kangaroo.MyManagedConnectionFactoryImpl
      </managedconnectionfactory-class>

      <!-- ManagedConnectionFactory default configuration properties -->
      <config-property>
        <config-property-name>PortNumber</config-property-name>
        <config-property-type>java.lang.String</config-property-type>
        <config-property-value>1051</config-property-value>
      </config-property>

      <connectionfactory-interface>
        jakarta.resource.cci.ConnectionFactory
      </connectionfactory-interface>
      <connectionfactory-impl-class>
        com.Kangaroo.MyConnectionFactoryImpl
      </connectionfactory-impl-class>

      <connection-interface>
        jakarta.resource.cci.Connection
      </connection-interface>
      <connection-impl-class>
        com.Kangaroo.MyConnectionImpl
      </connection-impl-class>
    </connection-definition>

    <transaction-support>NoTransaction</transaction-support>
    <reauthentication-support>false</reauthentication-support>
  </outbound-resourceadapter>

  <inbound-resourceadapter>
    <messageadapter>
      <messagelistener>
        <messagelistener-type>
          com.kangaroo.MessageListener
        </messagelistener-type>
        <activationspec>
          <activationspec-class>
            com.Kangaroo.MyEISActivationSpecImpl
          </activationspec-class>
          <required-config-property>
            <config-property-name>PortNumber</config-property-name>
          </required-config-property>
        </activationspec>
      </messagelistener>
    </messageadapter>
  </inbound-resourceadapter>
</resourceadapter>
</connector>
<?xml version="1.0" encoding="US-ASCII"?>

<!DOCTYPE ejb-jar PUBLIC ?-//Sun
Microsystems, Inc.//DTD

 Enterprise JavaBeans 2.1//EN?
?http://java.sun.com/dtd/ejb-jar_2_1.dtd?>

<ejb-jar>

 <display-name>Ejb1</display-name>

 <enterprise-beans>

 <message-driven>

 <display-name>EIS Receiver
Bean</display-name>

 <ejb-name>EISReceiver</ejb-name>

 <ejb-class>myapp.EISReceiverBean</ejb-class>

<messaging-type>com.kangaroo.MessageListener</messaging-type>

<transaction-type>Container</transaction-type>

 <activation-config>

 <activation-config-property>

 <activation-config-property-name>

 functionName

 </activation-config-property-name>

 <activation-config-property-value>

 CustomerChangeNotification

 </activation-config-property-value>

 </activation-config-property>

 <activation-config-property>

 <activation-config-property-name>

 CustomerName

 </activation-config-property-name>

 <activation-config-property-value>

 Wombat Systems

 </activation-config-property-value>

 </activation-config-property>

 </activation-config>

 </message-driven>

 </enterprise-beans>

</ejb-jar>
package com.wombat.ra;

import jakarta.ejb.MessageDrivenBean;
import javax.naming.InitialContext;

public class WombatMDB implements MessageDrivenBean,
                 WombatMessageListener {

  public static int CONV_START = 0;
  public static int CONV_CONTINUE = 1;
  public static int CONV_END = 2;

  private Context jndiContext = null;
  private ConvBeanHome chome = null;

  public void ejbCreate() {
    jndiContext = new InitialContext();
    chome = (ConvBeanHome)jndi.lookup("java:comp/env/ConvBeanHome");
  }

  ConvResponse onMessage(ConvRequest requestMsg) {
  // get conversation id and request type fromthe request
  // message
  int convId = ...;
  int type = ...;

  if (type == CONV_START) {
    // create entity Jakarta Enterprise Beans for holding the specific
    // conversation state
    ConvBean cbean = chome.create(convId);
  } else if (type == CONV_CONTINUE) {
    ConvBean cbean = chome.findByPrimaryKey(convId);

    // unmarshall Jakarta Enterprise Beans method parameters
    ...;

    // invoke Jakarta Enterprise Beans and return response
    Object resp = cbean.myBusinessMethod(params);
    ConvResponse cresp = Utility.convert(resp);
    return cresponse;
  } else if (type == CONV_END) {
    cbean.remove();
 }
 return null;
 }

 public void ejbRemove() {
   jndiContext = null;
   chome = null;
 }
}
package jakarta.resource.spi;

import javax.transaction.xa.Xid;
import javax.transaction.xa.XAException;
import jakarta.resource.spi.work.WorkManager;

public interface BootstrapContext {

 WorkManager getWorkManager();
 XATerminator getXATerminator();
 ... // other methods

}

public interface XATerminator {

 public void commit(Xid xid, boolean onePhase) throws XAException;
 public void forget(Xid xid) throws XAException;
 public int prepare(Xid xid) throws XAException;
 public Xid[] recover(int flag) throws XAException;
 public void rollback(Xid xid) throws XAException;
}
 package jakarta.resource.spi.work;

 import javax.security.auth.Subject;
 import javax.security.auth.callback.CallbackHandler;

 public abstract class SecurityContext implements WorkContext {

 public String getDescription() {
   return "Security Context";
 }

 public String getName() {
   return "SecurityContext";
 }

 public abstract void setupSecurityContext( CallbackHandler handler,
                                            Subject executionSubject,
                                            Subject serviceSubject);
}
 For setting the security context of a _Work_
instance, the application server calls the _setupSecurityContext_ method
of the _SecurityContext_ implementation provided by the resource
adapter. The following conditions are applicable to the application
server provider while calling the _setupSecurityContext_ method:
public class XMPPResourceAdapterImpl implements ResourceAdapter {

 ...

 public void start(BootstrapContext ctx) {
   bootstrapCtx = ctx;
 }
 ...

 {

   WorkManager workManager = myRA.bootstrapCtx.getWorkManager();
   workManager.scheduleWork(new XMPPMessageDeliveryWork());
   ...
 }

}

public class XMPPMessageDeliveryWork implements Work, WorkContextProvider {

  void release(){ ..}

  List<WorkContext> getWorkContexts() {
    List<WorkContext> l = new ArrayList<WorkContext>();
    SecurityContext scIn = new XMPPSecurityContext();
    l.add(scIn);
    return l;
  }

 void run(){
   // deliver "exchange message" from the user
   // to MessageEndpoint;
 }
}

public class XMPPSecurityContext extends SecurityContext {

 @Override
 public void setupSecurityContext(CallbackHandler handler,
                                  Subject executionSubject,
                                  Subject serviceSubject) {

   // Get username, password from client’s response
   // to XMPP register message
   // Note: PasswordValidationCallback usage is required
   // only if the RA requires authentication.
   PasswordValidationCallback pwdCallback = new PasswordValidationCallback( executionSubject, username, pwd);
   CallerPrincipalCallback cpCallback = new CallerPrincipalCallback(executionSubject, username);
   handler.handle(new Callback[] { pwdCallback, cpCallback });

   if (pwdCallback.getResult()) {
     return; // login success.
   } else {
     // login failure. Failure while setting Security Context
   }
 }
}
public interface jakarta.resource.cci.ConnectionFactory
          extends java.io.Serializable, jakarta.resource.Referenceable {

 public RecordFactory getRecordFactory() throws ResourceException;

 public Connection getConnection() throws ResourceException;

 public Connection getConnection(jakarta.resource.cci.ConnectionSpec properties)
                     throws ResourceException;

 public ResourceAdapterMetaData getMetaData() throws ResourceException;
}
public interface jakarta.resource.cci.ConnectionSpec {

}
public interface jakarta.resource.cci.Connection {

 public Interaction createInteraction() throws ResourceException;

 public ConnectionMetaData getMetaData() throws ResourceException;

 public ResultSetInfo getResultSetInfo() throws ResourceException;

 public LocalTransaction getLocalTransaction() throws ResourceException;

 public void close() throws ResourceException;

}
public interface jakarta.resource.cci.Interaction {

 public Connection getConnection();

 public void close() throws ResourceException;

 public boolean execute(InteractionSpec ispec, Record input, Record output) throws ResourceException;

 public Record execute(InteractionSpec ispec, Record input) throws ResourceException;
 ...
}
public interface jakarta.resource.cci.InteractionSpec extends java.io.Serializable {

 // Standard Interaction Verbs
 public static final int SYNC_SEND = 0;
 public static final int SYNC_SEND_RECEIVE = 1;
 public static final int SYNC_RECEIVE = 2;
}
public interface jakarta.resource.cci.LocalTransaction {

 public void begin() throws ResourceException;

 public void commit() throws ResourceException;

 public void rollback() throws ResourceException;

}
public interface jakarta.resource.cci.ConnectionMetaData {

 public String getEISProductName() throws ResourceException;

 public String getEISProductVersion() throws ResourceException;

 public String getUserName() throws ResourceException;

}
public interface jakarta.resource.cci.ResourceAdapterMetaData {

 public String getAdapterVersion();
 public String getAdapterVendorName();
 public String getAdapterName();
 public String getAdapterShortDescription();

 public String getSpecVersion();

 public String[] getInteractionSpecsSupported();

 public boolean supportsExecuteWithInputAndOutputRecord();

 public boolean supportsExecuteWithInputRecordOnly();

 public boolean supportsLocalTransactionDemarcation();

}
interface jakarta.resource.cci.MessageListener
{
 Record onMessage(Record inputData) throws ResourceException
}
public interface jakarta.resource.cci.Record extends java.lang.Cloneable,
                          java.io.Serializable {

 public String getRecordName();

 public void setRecordName(String name);

 public void setRecordShortDescription(String description);

 public String getRecordShortDescription();

 public boolean equals(Object other);

 public int hashCode();

 public Object clone() throws CloneNotSupportedException;

}
public interface jakarta.resource.cci.MappedRecord
   extends Record, Map, Serializable {

}
public interface jakarta.resource.cci.IndexedRecord extends Record, List, Serializable {

}
public interface jakarta.resource.cci.RecordFactory {

 public MappedRecord createMappedRecord(String recordName) throws ResourceException;

 public IndexedRecord createIndexedRecord(String recordName) throws ResourceException;

}
public interface jakarta.resource.cci.Streamable {

 public void read(InputStream istream) throws IOException;

 public void write(OutputStream ostream) throws IOException;

}
public interface jakarta.resource.cci.ResultSet extends Record, java.sql.ResultSet {

}
public interface
jakarta.resource.cci.ResultSetInfo {

 public boolean updatesAreDetected(int type) throws ResourceException;

 public boolean insertsAreDetected(int type) throws ResourceException;

 public boolean deletesAreDetected(int type) throws ResourceException;

 public boolean supportsResultSetType(int type) throws ResourceException;

 public boolean supportsResultTypeConcurrency(int type, int concurrency) throws ResourceException;

 public boolean ownUpdatesAreVisible(int type) throws ResourceException;

 public boolean ownInsertsAreVisible(int type) throws ResourceException;

 public boolean ownDeletesAreVisible(int type) throws ResourceException;

 public boolean othersUpdatesAreVisible(int type) throws ResourceException;

 public boolean othersInsertsAreVisible(int type) throws ResourceException;

 public boolean othersDeletesAreVisible(int type) throws ResourceException;

}
javax.naming.Context nc = new InitialContext();

jakarta.resource.cci.ConnectionFactory cf = (ConnectionFactory)nc.lookup( "java:comp/env/eis/ConnectionFactory");

jakarta.resource.cci.Connection cx = cf.getConnection();
com.wombat.cci.InteractionSpecImpl ixSpec = // ...

ixSpec.setFunctionName("<EIS_SPECIFIC_FUNCTION_NAME>");

ixSpec.setInteractionVerb(InteractionSpec.SYNC_SEND_RECEIVE);

...
jakarta.resource.cci.MappedRecord input =
 rf.createMappedRecord(“<NAME_OF_RECORD>”);
input.put(“<key: element1>", new String(“<VALUE>”));
input.put(“<key: element2>", ...);

...
jakarta.resource.cci.IndexedRecord output = rf.createIndexedRecord(“<NAME_OF_RECORD>”);
java.util.Iterator iterator = output.iterator();

while (iterator.hasNext()) {

 // Get a record element and extract value

}
com.wombat.cci.InteractionSpecImpl ixSpec = .. // get an InteractionSpec;

ixSpec.setFetchSize(20);
ixSpec.setResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE);
jakarta.resource.cci.ResultSet rs = (jakarta.resource.cci.ResultSet) ix.execute(ixSpec, input);
rs.beforeFirst();

while (rs.next()) {

 // get the column values for the current row using getXXX
 // method

}
rs.afterLast();

while (rs.previous()) {

 // get the column values for the current row using getXXX
 // method

}
public interface CustomerRecord extends jakarta.resource.cci.Record, jakarta.resource.cci.Streamable {

 public void setName(String name);
 public void setId(String custId);
 public void setAddress(String address);
 public String getName();
 public String getId();
 public String getAddress();
}
PurchaseOrderRecord purchaseOrder = ... // create an instance
purchaseOrder.setProductName(“...”);
purchaseOrder.setQuantity(“...”);
...
// Execute the Interaction
boolean ret = ix.execute(ixSpec, purchaseOrder, customer);

// Check the CustomerRecord
System.out.println( customer.getName() + ":" +
 customer.getId() + ":" +
 customer.getAddress());
 package jakarta.resource.spi;

 @Documented
 @Retention(RUNTIME)
 @Target(TYPE)
 public @interface Connector {

 String[] description() default {};
 String[] displayName() default {};
 String[] smallIcon() default {};
 String[] largeIcon() default {};
 String vendorName() default "";
 String eisType() default "";
 String version() default "";
 String[] licenseDescription() default {};
 boolean licenseRequired() default false;
 AuthenticationMechanism[] authMechanisms() default {};
 boolean reauthenticationSupport() default false;
 SecurityPermission[] securityPermissions() default {};
 TransactionSupport.TransactionSupportLevel transactionSupport()
 default TransactionSupport.TransactionSupportLevel.NoTransaction;

 Class<? extends WorkContext>[] requiredWorkContexts() default {};

 }
 The _transactionSupport_ annotation element
specifies the level of transaction support provided by the resource
adapter.
 @Connector( )
 public class MyResourceAdapter implements ResourceAdapter{

 // Define common configuration properties.
 ...
 }
 package jakarta.resource.spi;

 @Documented
 @Retention(RUNTIME)
 @Target(\{})

 public @interface AuthenticationMechanism {

 public enum CredentialInterface {
 PasswordCredential,
 GSSCredential,
 GenericCredential
 }

 String authMechanism() default "BasicPassword";
 String[] description() default {};
 CredentialInterface credentialInterface() default CredentialInterface.PasswordCredential;
 }
 package jakarta.resource.spi;

 @Documented
 @Retention(RUNTIME)
 @Target({})
 public @interface SecurityPermission {
 String[] description() default {};
 String permissionSpec() default "";

 }
 package jakarta.resource.spi;

 @Documented
 @Retention(RUNTIME)
 @Target({FIELD, METHOD})
 public @interface ConfigProperty {

 Class type() default Object.class;
 String[] description() default {};
 String defaultValue() default "";
 boolean ignore() default false;
 boolean supportsDynamicUpdates() default false;
 boolean confidential() default false;
 }
 package jakarta.resource.spi;

 @Documented
 @Retention(RUNTIME)
 @Target(TYPE)
 public @interface ConnectionDefinitions {
 ConnectionDefinition[] value();
 }
 package jakarta.resource.spi;

 @Documented
 @Retention(RUNTIME)
 @Target(TYPE)
 public @interface ConnectionDefinition {
 Class connectionFactory();
 Class connectionFactoryImpl();
 Class connection();
 Class connectionImpl();
 }
 @ConnectionDefinition(
   connectionFactory=com.wombat.ra.CF.class,
   connectionFactoryImpl= com.wombat.ra.CFImpl.class,
   connection=com.wombat.ra.Conn.class,
   connectionImpl=com.wombat.ra.ConnImpl.class)
 public class ManagedConnectionFactoryImpl implements ManagedConnectionFactory {
 ...
 }
 package jakarta.resource.spi;

 @Documented
 @Retention(RUNTIME)
 @Target(TYPE)
 public @interface Activation {
 Class [] messageListeners();
 }
 @Activation(messageListeners = {com.wombat.ra.MyMessageListener.class})
 public class MyActivationSpec implements ActivationSpec{

 //Use of Bean Validation annotations to express
 //validation requirements
 @Size(min=5, max=5)
 private int length;

 //... other methods
 //Use of validate() method is also allowed
 public void validate() throws InvalidPropertyException {
   //custom validation logic
 }
 }
 package jakarta.resource.spi;

 @Documented
 @Retention(RUNTIME)
 @Target(TYPE)
 public @interface AdministeredObject {
 Class[] adminObjectInterfaces() default {};
 }
 package jakarta.resource;

 import java.lang.annotation.Target;
 import java.lang.annotation.Retention;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.RetentionPolicy;

 @Documented
 @Target({ElementType.TYPE})
 @Retention(RetentionPolicy.RUNTIME)
 @Repeatable(ConnectionFactoryDefinitions.class)
 public @interface ConnectionFactoryDefinition {
   String name();
   String description() default "";
   String resourceAdapter();
   String interfaceName();
   TransactionSupport.TransactionSupportLevel transactionSupport() default TransactionSupport.TransactionSupportLevel.NoTransaction;

   int maxPoolSize() default -1;
   int minPoolSize() default -1;
   String[] properties() default \{};
 }
@ConnectionFactoryDefinition(name="java:comp/eis/MyEISCF",
  interfaceName="com.eis.ConnectionFactory",
   resourceAdapter="MyEISRA",
   transactionSupport= TransactionSupport.TransactionSupportLevel.XATransaction)
 @Stateless public class MySessionBean {

 @Resource(lookup = "java:comp/eis/MyEISCF") com.eis.ConnectionFactory myCF;

 ...

 }
 package jakarta.resource;

 import java.lang.annotation.Target;
 import java.lang.annotation.Retention;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.RetentionPolicy;

 @Documented
 @Target({ElementType.TYPE})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface ConnectionFactoryDefinitions {
   ConnectionFactoryDefinition[] value();
 }
 @ConnectionFactoryDefinitions({

    @ConnectionFactoryDefinition(name="java:comp/eis/MyXACF",
      interfaceName="com.eis.FooConnectionFactory",
      resourceAdapter="MyEISRA1",
      transactionSupport=XATransaction),

    @ConnectionFactoryDefinition(name="java:comp/eis/MyNoTXCF",
      interfaceName="com.eis.BarConnectionFactory",
      resourceAdapter="MyEISRA2",
      transactionSupport=NoTransaction)
 })
 @Stateless public class MySessionBean {

 @Resource(lookup = "java:comp/eis/MyXACF")
 com.eis.FooConnectionFactory xacf;

 ...

 @Resource(lookup = "java:comp/eis/MyNoTXCF")
 com.eis.BarConnectionFactory notxcf;
 ...
 }
 package jakarta.resource;

 import java.lang.annotation.Target;
 import java.lang.annotation.Retention;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.RetentionPolicy;

 @Documented
 @Target({ElementType.TYPE})
 @Retention(RetentionPolicy.RUNTIME)
 @Repeatable(AdministeredObjectDefinitions.class)
 public @interface AdministeredObjectDefinition {

   String name();
   String description() default "";
   String resourceAdapter();
   String className();
   String interfaceName() default “”;
   String[] properties() default {};
 }
 @AdministeredObjectDefinition (name="java:comp/eis/MyQueue",
              className="com.wombat.connector.jms.QueueImpl",
              resourceAdapter="#MyJMSRA")
 @Stateless public class MySessionBean {

 @Resource(lookup = "java:comp/eis/MyQueue") jakarta.jms.Queue myQ;
 ...
 }
 package jakarta.resource;

 import java.lang.annotation.Target;
 import java.lang.annotation.Retention;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.RetentionPolicy;

 @Documented
 @Target({ElementType.TYPE})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface AdministeredObjectDefinitions {

 AdministeredObjectDefinition[] value();

 }
 @AdministeredObjectDefinitions({
   @AdministeredObjectDefinition(name="java:comp/eis/MyQueue",
    className="com.wombat.connector.jms.QueueImpl",
    resourceAdapter="MyJMSRA"),

 @AdministeredObjectDefinition  (name="java:comp/eis/MyTopic",
    className="com.wombat.connector.jms.TopicImpl",
    resourceAdapter="MyJMSRA")
 })
 @Stateless
 public class MySessionBean {

 @Resource(lookup = "java:comp/eis/MyQueue")
 jakarta.jms.Queue myQ;

 ...

 @Resource(lookup = "java:comp/eis/MyTopic")
 jakarta.jms.Queue myT;

 ...
 }
_META-INF/ra.xml_
_ra.jar_
_cci.jar_
_win.dll_
_solaris.so_
// Application Component/Client Code obtain the initial JNDI context
Context initctx = new InitialContext();

// perform JNDI lookup to obtain connection factory
jakarta.resource.cci.ConnectionFactory cxf =
     (jakarta.resource.cci.ConnectionFactory)initctx.lookup(“java:comp/env/eis/MyEIS”);

jakarta.resource.cci.Connection cx = cxf.getConnection();
public interface jakarta.resource.Referenceable extends javax.naming.Referenceable {

 public void setReference(Reference ref);

}
// Deployment Code
// Create an instance of the ManagedConnectionFactory class
com.myeis.ManagedConnectionFactoryImpl mcf = new com.myeis.ManagedConnectionFactoryImpl();

// Set the properties of theManagedConnectionFactory instance
// Note: Properties are defined in theimplementation class and
// not in the
// jakarta.resource.spi.ManagedConnectionFactory interface

mcf.setServerName(“...”);
mcf.setPortNumber(“...”);
...
// Deployment Code
// In a managed environment, create a ConnectionManager specific to
// the application server. Note that in a non-managed environment,
// ConnectionManager will be specific to the resource adapter.

com.wombatserver.ConnectionManager cm = new com.wombatserver.ConnectionManager(...);

// Create an instance of a connection factory
Object cxf = mcf.createConnectionFactory(cm);

// Get the JNDI context
javax.naming.Context ctx = new javax.naming.InitialContext(env);

// Bind to the JNDI namespace specifying a factory name
ctx.bind("...", cxf);
public class com.myeis.ConnectionFactoryImpl implements
  jakarta.resource.Referenceable,
  java.io.Serializable,
   jakarta.resource.cci.ConnectionFactory {

 // Reference to this ConnectionFactory
 javax.naming.Reference reference;

 // setReference is called by the deployment code
 public void setReference(Reference ref) {
   reference = ref;
 }

 // getReference is called by the JNDI provider during
 // Context.bind

 public Reference getReference() throws NamingException {
   return reference;
 }
 ...
}
public class com.wombatserver.ApplicationServerJNDIHandler
  implements javax.naming.spi.ObjectFactory {

 // ...

 public Object getObjectInstance(Object obj, Name name, Context ctx, Hashtable env) throws Exception {

 javax.naming.Reference ref =  (javax.naming.Reference)obj;

 // Using the information carried by the Reference
 // instance,
 // (<referenceName, logicalName> in this example) lookup
 // a configured property set and then configure a
 // ManagedConnectionFactory instance with specified
 // properties.
{empty} ... // [implementation specific]
 //
 // For example, instantiation of the
 // ManagedConnectionFactory
 // class and invocation of its setter method
 // can be done using the Java Reflection
mechanism.

 jakarta.resource.spi.ManagedConnectionFactory mcf = ...

 // Create a Connection Manager instance specific to the
 // application server

 com.wombatserver.ConnectionManager cxManager = ...

 // Create a connection factory instance.
 // The ConnectionManager instance providedby the
 // application
 // server gets associated with the created
 // connection factory instance

 return mcf.createConnectionFactory(cxManager);
 }
 ...
}
// Deployment Code

javax.naming.Context ctx = new javax.naming.InitialContext(env);

// Create an instance of the connectionfactory
com.myeis.ConnectionFactoryImpl cf = new com.myeis.ConnectionFactoryImpl();

// Create a reference for the ConnectionFactory instance

javax.naming.Reference ref = new javax.naming.Reference(
 ConnectionFactoryImpl.class.getName(),
 new javax.naming.StringRefAddr( “<referenceName>”, “<logicalName>”),
 ApplicationServerJNDIHandler.class.getName(),
 null);

cf.setReference(ref);

// Bind to the JNDI namespace specifying aname for the connection
// factory
ctx.bind("...", cf);
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://www.w3.org/2001/XMLSchema"
            targetNamespace="https://jakarta.ee/xml/ns/jakartaee"
            xmlns:jakartaee="https://jakarta.ee/xml/ns/jakartaee"
            xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            elementFormDefault="qualified"
            attributeFormDefault="unqualified"
            version="2.0">
  <xsd:annotation>
    <xsd:documentation>

      Copyright (c) 2009, 2020 Oracle and/or its affiliates. All rights reserved.

      This program and the accompanying materials are made available under the
      terms of the Eclipse Public License v. 2.0, which is available at
      http://www.eclipse.org/legal/epl-2.0.

      This Source Code may also be made available under the following Secondary
      Licenses when the conditions for such availability set forth in the
      Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
      version 2 with the GNU Classpath Exception, which is available at
      https://www.gnu.org/software/classpath/license.html.

      SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0

    </xsd:documentation>
  </xsd:annotation>

  <xsd:annotation>
    <xsd:documentation>
      <![CDATA[
      This is the XML Schema for the Connectors 2.0 deployment
      descriptor.  The deployment descriptor must be named
      "META-INF/ra.xml" in the connector's rar file.  All connector
      deployment descriptors must indicate the connector resource
      adapter schema by using the Jakarta EE namespace:

      https://jakarta.ee/xml/ns/jakartaee

      and by indicating the version of the schema by
      using the version element as shown below:

      <connector xmlns="https://jakarta.ee/xml/ns/jakartaee"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
               https://jakarta.ee/xml/ns/jakartaee/connector_2_0.xsd"
      version="2.0">
      ...
      </connector>

      The instance documents may indicate the published version of
      the schema using the xsi:schemaLocation attribute for Jakarta EE
      namespace with the following location:

      https://jakarta.ee/xml/ns/jakartaee/connector_2_0.xsd

      ]]>
    </xsd:documentation>
  </xsd:annotation>

  <xsd:annotation>
    <xsd:documentation>

      The following conventions apply to all Jakarta EE
      deployment descriptor elements unless indicated otherwise.

      - In elements that specify a pathname to a file within the
      same JAR file, relative filenames (i.e., those not
      starting with "/") are considered relative to the root of
      the JAR file's namespace.  Absolute filenames (i.e., those
      starting with "/") also specify names in the root of the
      JAR file's namespace.  In general, relative names are
      preferred.  The exception is .war files where absolute
      names are preferred for consistency with the Servlet API.

    </xsd:documentation>
  </xsd:annotation>

  <xsd:include schemaLocation="jakartaee_9.xsd"/>

<!-- **************************************************** -->

  <xsd:element name="connector"
               type="jakartaee:connectorType">
    <xsd:annotation>
      <xsd:documentation>

        The connector element is the root element of the deployment
        descriptor for the resource adapter. This element includes
        general information - vendor name, resource adapter version,
        icon - about the resource adapter module. It also includes
        information specific to the implementation of the resource
        adapter library as specified through the element
        resourceadapter.

      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

<!-- **************************************************** -->

  <xsd:complexType name="activationspecType">
    <xsd:annotation>
      <xsd:documentation>

        The activationspecType specifies an activation
        specification.  The information includes fully qualified
        Java class name of an activation specification and a set of
        required configuration property names.

      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="activationspec-class"
                   type="jakartaee:fully-qualified-classType">
        <xsd:annotation>
          <xsd:documentation>
            <![CDATA[
            The element activationspec-class specifies the fully
            qualified Java class name of the activation
            specification class. This class must implement the
            jakarta.resource.spi.ActivationSpec interface. The
            implementation of this class is required to be a
            JavaBean.

            Example:
                      <activationspec-class>com.wombat.ActivationSpecImpl
                      </activationspec-class>

            ]]>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="required-config-property"
                   type="jakartaee:required-config-propertyType"
                   minOccurs="0"
                   maxOccurs="unbounded">
        <xsd:annotation>
          <xsd:documentation>

            The required-config-property element is deprecated since
            Connectors 1.6 specification. The resource adapter
            implementation is recommended to use the @NotNull
            Bean Validation annotation or its XML validation
            descriptor equivalent to indicate that a configuration
            property is required to be specified by the deployer.
            See the Jakarta Connectors specification for more information.

          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="config-property"
                   type="jakartaee:config-propertyType"
                   minOccurs="0"
                   maxOccurs="unbounded"/>
    </xsd:sequence>
    <xsd:attribute name="id"
                   type="xsd:ID"/>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="adminobjectType">
    <xsd:annotation>
      <xsd:documentation>

        The adminobjectType specifies information about an
        administered object.  Administered objects are specific to a
        messaging style or message provider.  This contains
        information on the Java type of the interface implemented by
        an administered object, its Java class name and its
        configuration properties.

      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="adminobject-interface"
                   type="jakartaee:fully-qualified-classType">
        <xsd:annotation>
          <xsd:documentation>
            <![CDATA[
            The element adminobject-interface specifies the
            fully qualified name of the Java type of the
            interface implemented by an administered object.

            Example:
                    <adminobject-interface>jakarta.jms.Destination
                    </adminobject-interface>

            ]]>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="adminobject-class"
                   type="jakartaee:fully-qualified-classType">
        <xsd:annotation>
          <xsd:documentation>
            <![CDATA[
            The element adminobject-class specifies the fully
            qualified Java class name of an administered object.

            Example:
                      <adminobject-class>com.wombat.DestinationImpl
                      </adminobject-class>

            ]]>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="config-property"
                   type="jakartaee:config-propertyType"
                   minOccurs="0"
                   maxOccurs="unbounded"/>
    </xsd:sequence>
    <xsd:attribute name="id"
                   type="xsd:ID"/>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="authentication-mechanismType">
    <xsd:annotation>
      <xsd:documentation>

        The authentication-mechanismType specifies an authentication
        mechanism supported by the resource adapter. Note that this
        support is for the resource adapter and not for the
        underlying EIS instance. The optional description specifies
        any resource adapter specific requirement for the support of
        security contract and authentication mechanism.

        Note that BasicPassword mechanism type should support the
        jakarta.resource.spi.security.PasswordCredential interface.
        The Kerbv5 mechanism type should support the
        org.ietf.jgss.GSSCredential interface or the deprecated
        jakarta.resource.spi.security.GenericCredential interface.

      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="description"
                   type="jakartaee:descriptionType"
                   minOccurs="0"
                   maxOccurs="unbounded"/>
      <xsd:element name="authentication-mechanism-type"
                   type="jakartaee:xsdStringType">
        <xsd:annotation>
          <xsd:documentation>
            <![CDATA[
            The element authentication-mechanism-type specifies
            type of an authentication mechanism.

            The example values are:

            <authentication-mechanism-type>BasicPassword
            </authentication-mechanism-type>

            <authentication-mechanism-type>Kerbv5
            </authentication-mechanism-type>

            Any additional security mechanisms are outside the
            scope of the Jakarta Connectors architecture specification.

            ]]>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="credential-interface"
                   type="jakartaee:credential-interfaceType"/>
    </xsd:sequence>
    <xsd:attribute name="id"
                   type="xsd:ID"/>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="config-property-nameType">
    <xsd:annotation>
      <xsd:documentation>
        <![CDATA[
        The config-property-nameType contains the name of a
        configuration property.

        The connector architecture defines a set of well-defined
        properties all of type java.lang.String. These are as
        follows.

        ServerName
        PortNumber
        UserName
        Password
        ConnectionURL

        A resource adapter provider can extend this property set to
        include properties specific to the resource adapter and its
        underlying EIS.

        Possible values include
                  ServerName
                  PortNumber
                  UserName
                  Password
                  ConnectionURL

        Example: <config-property-name>ServerName</config-property-name>

        ]]>
      </xsd:documentation>
    </xsd:annotation>
    <xsd:simpleContent>
      <xsd:restriction base="jakartaee:xsdStringType"/>
    </xsd:simpleContent>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="config-property-typeType">
    <xsd:annotation>
      <xsd:documentation>
        <![CDATA[
        The config-property-typeType contains the fully
        qualified Java type of a configuration property.

        The following are the legal values:
        java.lang.Boolean, java.lang.String, java.lang.Integer,
        java.lang.Double, java.lang.Byte, java.lang.Short,
        java.lang.Long, java.lang.Float, java.lang.Character

        Used in: config-property

        Example:
        <config-property-type>java.lang.String</config-property-type>

        ]]>
      </xsd:documentation>
    </xsd:annotation>
    <xsd:simpleContent>
      <xsd:restriction base="jakartaee:string">
        <xsd:enumeration value="java.lang.Boolean"/>
        <xsd:enumeration value="java.lang.String"/>
        <xsd:enumeration value="java.lang.Integer"/>
        <xsd:enumeration value="java.lang.Double"/>
        <xsd:enumeration value="java.lang.Byte"/>
        <xsd:enumeration value="java.lang.Short"/>
        <xsd:enumeration value="java.lang.Long"/>
        <xsd:enumeration value="java.lang.Float"/>
        <xsd:enumeration value="java.lang.Character"/>
      </xsd:restriction>
    </xsd:simpleContent>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="config-propertyType">
    <xsd:annotation>
      <xsd:documentation>

        The config-propertyType contains a declaration of a single
        configuration property that may be used for providing
        configuration information.

        The declaration consists of an optional description, name,
        type and an optional value of the configuration property. If
        the resource adapter provider does not specify a value than
        the deployer is responsible for providing a valid value for
        a configuration property.

        Any bounds or well-defined values of properties should be
        described in the description element.

      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="description"
                   type="jakartaee:descriptionType"
                   minOccurs="0"
                   maxOccurs="unbounded"/>
      <xsd:element name="config-property-name"
                   type="jakartaee:config-property-nameType"/>
      <xsd:element name="config-property-type"
                   type="jakartaee:config-property-typeType"/>
      <xsd:element name="config-property-value"
                   type="jakartaee:xsdStringType"
                   minOccurs="0">
        <xsd:annotation>
          <xsd:documentation>
            <![CDATA[
            The element config-property-value contains the value
            of a configuration entry. Note, it is possible for a
            resource adapter deployer to override this
            configuration information during deployment.

            Example:
            <config-property-value>WombatServer</config-property-value>

            ]]>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="config-property-ignore"
                   type="jakartaee:true-falseType"
                   minOccurs="0"
                   maxOccurs="1">
        <xsd:annotation>
          <xsd:documentation>

            The element config-property-ignore is used to specify
            whether the configuration tools must ignore considering the
            configuration property during auto-discovery of
            Configuration properties. See the Jakarta Connectors specification for
            more details. If unspecified, the container must not ignore
            the configuration property during auto-discovery.
            This element must be one of the following, "true" or "false".

          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="config-property-supports-dynamic-updates"
                   type="jakartaee:true-falseType"
                   minOccurs="0"
                   maxOccurs="1">
        <xsd:annotation>
          <xsd:documentation>

            The element config-property-supports-dynamic-updates is used to specify
            whether the configuration property allows its value to be updated, by
            application server's configuration tools, during the lifetime of
            the JavaBean instance. See the Jakarta Connectors specification for
            more details. If unspecified, the container must not dynamically
            reconfigure the property.
            This element must be one of the following, "true" or "false".

          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="config-property-confidential"
                   type="jakartaee:true-falseType"
                   minOccurs="0"
                   maxOccurs="1">
        <xsd:annotation>
          <xsd:documentation>

            The element config-property-confidential is used to specify
            whether the configuration property is confidential and
            recommends application server's configuration tools to use special
            visual aids for editing them. See the Jakarta Connectors specification for
            more details. If unspecified, the container must not treat the
            property as confidential.
            This element must be one of the following, "true" or "false".

          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
    </xsd:sequence>
    <xsd:attribute name="id"
                   type="xsd:ID"/>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="connection-definitionType">
    <xsd:annotation>
      <xsd:documentation>

        The connection-definitionType defines a set of connection
        interfaces and classes pertaining to a particular connection
        type. This also includes configurable properties for
        ManagedConnectionFactory instances that may be produced out
        of this set.

      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="managedconnectionfactory-class"
                   type="jakartaee:fully-qualified-classType">
        <xsd:annotation>
          <xsd:documentation>
            <![CDATA[
            The element managedconnectionfactory-class specifies
            the fully qualified name of the Java class that
            implements the
            jakarta.resource.spi.ManagedConnectionFactory interface.
            This Java class is provided as part of resource
            adapter's implementation of connector architecture
            specified contracts. The implementation of this
            class is required to be a JavaBean.

            Example:
            <managedconnectionfactory-class>
                      com.wombat.ManagedConnectionFactoryImpl
            </managedconnectionfactory-class>

            ]]>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="config-property"
                   type="jakartaee:config-propertyType"
                   minOccurs="0"
                   maxOccurs="unbounded"/>
      <xsd:element name="connectionfactory-interface"
                   type="jakartaee:fully-qualified-classType">
        <xsd:annotation>
          <xsd:documentation>
            <![CDATA[
            The element connectionfactory-interface specifies
            the fully qualified name of the ConnectionFactory
            interface supported by the resource adapter.

            Example:
            <connectionfactory-interface>com.wombat.ConnectionFactory
            </connectionfactory-interface>

            OR

            <connectionfactory-interface>jakarta.resource.cci.ConnectionFactory
            </connectionfactory-interface>

            ]]>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="connectionfactory-impl-class"
                   type="jakartaee:fully-qualified-classType">
        <xsd:annotation>
          <xsd:documentation>
            <![CDATA[
            The element connectionfactory-impl-class specifies
            the fully qualified name of the ConnectionFactory
            class that implements resource adapter
            specific ConnectionFactory interface.

            Example:

            <connectionfactory-impl-class>com.wombat.ConnectionFactoryImpl
            </connectionfactory-impl-class>

            ]]>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="connection-interface"
                   type="jakartaee:fully-qualified-classType">
        <xsd:annotation>
          <xsd:documentation>
            <![CDATA[
            The connection-interface element specifies the fully
            qualified name of the Connection interface supported
            by the resource adapter.

            Example:

                      <connection-interface>jakarta.resource.cci.Connection
                      </connection-interface>

            ]]>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="connection-impl-class"
                   type="jakartaee:fully-qualified-classType">
        <xsd:annotation>
          <xsd:documentation>
            <![CDATA[
            The connection-impl-classType specifies the fully
            qualified name of the Connection class that
            implements resource adapter specific Connection
            interface.  It is used by the connection-impl-class
            elements.

            Example:

                      <connection-impl-class>com.wombat.ConnectionImpl
                      </connection-impl-class>

            ]]>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
    </xsd:sequence>
    <xsd:attribute name="id"
                   type="xsd:ID"/>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="connectorType">
    <xsd:annotation>
      <xsd:documentation>

        The connectorType defines a resource adapter.

      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="module-name"
                   type="jakartaee:string"
                   minOccurs="0">
        <xsd:annotation>
          <xsd:documentation>

            The element module-name specifies the name of the
            resource adapter.

            If there is no module-name specified, the module-name
            is determined as defined in Section EE.8.1.1 and EE.8.1.2
            of the Java Platform, Enterprise Edition (Jakarta EE)
            Specification, version 6.

          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:group ref="jakartaee:descriptionGroup"/>
      <xsd:element name="vendor-name"
                   type="jakartaee:xsdStringType"
                   minOccurs="0">
        <xsd:annotation>
          <xsd:documentation>

            The element vendor-name specifies the name of
            resource adapter provider vendor.

            If there is no vendor-name specified, the application
            server must consider the default "" (empty string) as
            the name of the resource adapter provider vendor.

          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="eis-type"
                   type="jakartaee:xsdStringType"
                   minOccurs="0">
        <xsd:annotation>
          <xsd:documentation>

            The element eis-type contains information about the
            type of the EIS. For example, the type of an EIS can
            be product name of EIS independent of any version
            info.

            This helps in identifying EIS instances that can be
            used with this resource adapter.

            If there is no eis-type specified, the application
            server must consider the default "" (empty string) as
            the type of the EIS.

          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="resourceadapter-version"
                   type="jakartaee:xsdStringType"
                   minOccurs="0">
        <xsd:annotation>
          <xsd:documentation>

            The element resourceadapter-version specifies a string-based version
            of the resource adapter from the resource adapter
            provider.

            If there is no resourceadapter-version specified, the application
            server must consider the default "" (empty string) as
            the version of the resource adapter.

          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="license"
                   type="jakartaee:licenseType"
                   minOccurs="0"/>
      <xsd:element name="resourceadapter"
                   type="jakartaee:resourceadapterType"/>
      <xsd:element name="required-work-context"
                   type="jakartaee:fully-qualified-classType"
                   minOccurs="0"
                   maxOccurs="unbounded">
        <xsd:annotation>
          <xsd:documentation>

            The element required-work-context specifies a fully qualified class
            name that implements WorkContext interface, that the resource adapter
            requires the application server to support.

          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
    </xsd:sequence>
    <xsd:attribute name="version"
                   type="jakartaee:dewey-versionType"
                   fixed="2.0"
                   use="required">
      <xsd:annotation>
        <xsd:documentation>

          The version indicates the version of the schema to be used by the
          deployment tool. This element doesn't have a default, and the resource adapter
          developer/deployer is required to specify it. The element allows the deployment
          tool to choose which schema to validate the descriptor against.

        </xsd:documentation>
      </xsd:annotation>
    </xsd:attribute>
    <xsd:attribute name="metadata-complete"
                   type="xsd:boolean">
      <xsd:annotation>
        <xsd:documentation>

          The metadata-complete attribute defines whether the deployment
          descriptor for the resource adapter module is complete, or whether
          the class files available to the module and packaged with the resource
          adapter should be examined for annotations that specify deployment
          information.

          If metadata-complete is set to "true", the deployment tool of the
          application server must ignore any annotations that specify deployment
          information, which might be present in the class files of the
          application.If metadata-complete is not specified or is set to "false",
          the deployment tool must examine the class files of the application for
          annotations, as specified by this specification. If the
          deployment descriptor is not included or is included but not marked
          metadata-complete, the deployment tool will process annotations.

          Application servers must assume that metadata-complete is true for
          resource adapter modules with deployment descriptor version
          lower than 1.6.

        </xsd:documentation>
      </xsd:annotation>
    </xsd:attribute>
    <xsd:attribute name="id"
                   type="xsd:ID"/>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="credential-interfaceType">
    <xsd:annotation>
      <xsd:documentation>

        The credential-interfaceType specifies the
        interface that the resource adapter implementation
        supports for the representation of the
        credentials. This element(s) that use this type,
        i.e. credential-interface,  should be used by
        application server to find out the Credential
        interface it should use as part of the security
        contract.

        The possible values are:

        jakarta.resource.spi.security.PasswordCredential
        org.ietf.jgss.GSSCredential
        jakarta.resource.spi.security.GenericCredential

      </xsd:documentation>
    </xsd:annotation>
    <xsd:simpleContent>
      <xsd:restriction base="jakartaee:fully-qualified-classType">
        <xsd:enumeration value="jakarta.resource.spi.security.PasswordCredential"/>
        <xsd:enumeration value="org.ietf.jgss.GSSCredential"/>
        <xsd:enumeration value="jakarta.resource.spi.security.GenericCredential"/>
      </xsd:restriction>
    </xsd:simpleContent>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="inbound-resourceadapterType">
    <xsd:annotation>
      <xsd:documentation>

        The inbound-resourceadapterType specifies information
        about an inbound resource adapter. This contains information
        specific to the implementation of the resource adapter
        library as specified through the messageadapter element.

      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="messageadapter"
                   type="jakartaee:messageadapterType"
                   minOccurs="0">
        <xsd:unique name="messagelistener-type-uniqueness">
          <xsd:annotation>
            <xsd:documentation>

              The messagelistener-type element content must be
              unique in the messageadapter. Several messagelisteners
              can not use the same messagelistener-type.

            </xsd:documentation>
          </xsd:annotation>
          <xsd:selector xpath="jakartaee:messagelistener"/>
          <xsd:field xpath="jakartaee:messagelistener-type"/>
        </xsd:unique>
      </xsd:element>
    </xsd:sequence>
    <xsd:attribute name="id"
                   type="xsd:ID"/>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="licenseType">
    <xsd:annotation>
      <xsd:documentation>

        The licenseType specifies licensing requirements for the
        resource adapter module. This type specifies whether a
        license is required to deploy and use this resource adapter,
        and an optional description of the licensing terms
        (examples: duration of license, number of connection
        restrictions). It is used by the license element.

      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="description"
                   type="jakartaee:descriptionType"
                   minOccurs="0"
                   maxOccurs="unbounded"/>
      <xsd:element name="license-required"
                   type="jakartaee:true-falseType">
        <xsd:annotation>
          <xsd:documentation>

            The element license-required specifies whether a
            license is required to deploy and use the
            resource adapter. This element must be one of
            the following, "true" or "false".

          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
    </xsd:sequence>
    <xsd:attribute name="id"
                   type="xsd:ID"/>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="messageadapterType">
    <xsd:annotation>
      <xsd:documentation>

        The messageadapterType specifies information about the
        messaging capabilities of the resource adapter. This
        contains information specific to the implementation of the
        resource adapter library as specified through the
        messagelistener element.

      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="messagelistener"
                   type="jakartaee:messagelistenerType"
                   maxOccurs="unbounded"/>
    </xsd:sequence>
    <xsd:attribute name="id"
                   type="xsd:ID"/>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="messagelistenerType">
    <xsd:annotation>
      <xsd:documentation>

        The messagelistenerType specifies information about a
        specific message listener supported by the messaging
        resource adapter. It contains information on the Java type
        of the message listener interface and an activation
        specification.

      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="messagelistener-type"
                   type="jakartaee:fully-qualified-classType">
        <xsd:annotation>
          <xsd:documentation>
            <![CDATA[
            The element messagelistener-type specifies the fully
            qualified name of the Java type of a message
            listener interface.

            Example:

                    <messagelistener-type>jakarta.jms.MessageListener
                    </messagelistener-type>

            ]]>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="activationspec"
                   type="jakartaee:activationspecType"/>
    </xsd:sequence>
    <xsd:attribute name="id"
                   type="xsd:ID"/>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="outbound-resourceadapterType">
    <xsd:annotation>
      <xsd:documentation>

        The outbound-resourceadapterType specifies information about
        an outbound resource adapter. The information includes fully
        qualified names of classes/interfaces required as part of
        the connector architecture specified contracts for
        connection management, level of transaction support
        provided, one or more authentication mechanisms supported
        and additional required security permissions.

        If any of the outbound resource adapter elements (transaction-support,
        authentication-mechanism, reauthentication-support) is specified through
        this element or metadata annotations, and no  connection-definition is
        specified as part of this element or through annotations, the
        application server must consider this an error and fail deployment.

        If there is no authentication-mechanism specified as part of
        this element or metadata annotations, then the resource adapter does
        not support any standard security authentication mechanisms as
        part of security contract. The application server ignores the security
        part of the system contracts in this case.

        If there is no transaction-support specified as part of this element
        or metadata annotation, then the application server must consider that
        the resource adapter does not support either the resource manager local
        or Jakarta Transactions transactions and must consider the transaction support as
        NoTransaction. Note that resource adapters may specify the level of
        transaction support to be used at runtime for a ManagedConnectionFactory
        through the TransactionSupport interface.

        If there is no reauthentication-support specified as part of
        this element or metadata annotation, then the application server must consider
        that the resource adapter does not support re-authentication of
        ManagedConnections.

      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="connection-definition"
                   type="jakartaee:connection-definitionType"
                   maxOccurs="unbounded"
                   minOccurs="0"/>
      <xsd:element name="transaction-support"
                   type="jakartaee:transaction-supportType"
                   minOccurs="0"/>
      <xsd:element name="authentication-mechanism"
                   type="jakartaee:authentication-mechanismType"
                   minOccurs="0"
                   maxOccurs="unbounded"/>
      <xsd:element name="reauthentication-support"
                   type="jakartaee:true-falseType"
                   minOccurs="0">
        <xsd:annotation>
          <xsd:documentation>

                        The element reauthentication-support specifies
                        whether the resource adapter implementation supports
                        re-authentication of existing Managed- Connection
                        instance. Note that this information is for the
                        resource adapter implementation and not for the
                        underlying EIS instance. This element must have
                        either a "true" or "false" value.

          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
    </xsd:sequence>
    <xsd:attribute name="id"
                   type="xsd:ID"/>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="required-config-propertyType">
    <xsd:annotation>
      <xsd:documentation>
        <![CDATA[
        The required-config-propertyType contains a declaration
        of a single configuration property used for specifying a
        required configuration property name. It is used
        by required-config-property elements.

        Usage of this type is deprecated from Connectors 1.6 specification.
        Refer to required-config-property element for more information.

        Example:

        <required-config-property>
        <config-property-name>Destination</config-property-name>
        </required-config-property>

        ]]>
      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="description"
                   type="jakartaee:descriptionType"
                   minOccurs="0"
                   maxOccurs="unbounded"/>
      <xsd:element name="config-property-name"
                   type="jakartaee:config-property-nameType"/>
    </xsd:sequence>
    <xsd:attribute name="id"
                   type="xsd:ID"/>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="resourceadapterType">
    <xsd:annotation>
      <xsd:documentation>

        The resourceadapterType specifies information about the
        resource adapter. The information includes fully qualified
        resource adapter Java class name, configuration properties,
        information specific to the implementation of the resource
        adapter library as specified through the
        outbound-resourceadapter and inbound-resourceadapter
        elements, and an optional set of administered objects.

      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="resourceadapter-class"
                   type="jakartaee:fully-qualified-classType"
                   minOccurs="0">
        <xsd:annotation>
          <xsd:documentation>

            The element resourceadapter-class specifies the
            fully qualified name of a Java class that implements
            the jakarta.resource.spi.ResourceAdapter
            interface. This Java class is provided as part of
            resource adapter's implementation of connector
            architecture specified contracts. The implementation
            of this class is required to be a JavaBean.

          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
      <xsd:element name="config-property"
                   type="jakartaee:config-propertyType"
                   minOccurs="0"
                   maxOccurs="unbounded"/>
      <xsd:element name="outbound-resourceadapter"
                   type="jakartaee:outbound-resourceadapterType"
                   minOccurs="0">
        <xsd:unique name="connectionfactory-interface-uniqueness">
          <xsd:annotation>
            <xsd:documentation>

              The connectionfactory-interface element content
              must be unique in the outbound-resourceadapter.
              Multiple connection-definitions can not use the
              same connectionfactory-type.

            </xsd:documentation>
          </xsd:annotation>
          <xsd:selector xpath="jakartaee:connection-definition"/>
          <xsd:field xpath="jakartaee:connectionfactory-interface"/>
        </xsd:unique>
      </xsd:element>
      <xsd:element name="inbound-resourceadapter"
                   type="jakartaee:inbound-resourceadapterType"
                   minOccurs="0"/>
      <xsd:element name="adminobject"
                   type="jakartaee:adminobjectType"
                   minOccurs="0"
                   maxOccurs="unbounded">
        <xsd:unique name="adminobject-type-uniqueness">
          <xsd:annotation>
            <xsd:documentation>

              The adminobject-interface and adminobject-class element content must be
              unique in the resourceadapterType. Several admin objects
              can not use the same adminobject-interface and adminobject-class.

            </xsd:documentation>
          </xsd:annotation>
          <xsd:selector xpath="jakartaee:adminobject"/>
          <xsd:field xpath="jakartaee:adminobject-interface"/>
          <xsd:field xpath="jakartaee:adminobject-class"/>
        </xsd:unique>
      </xsd:element>
      <xsd:element name="security-permission"
                   type="jakartaee:security-permissionType"
                   minOccurs="0"
                   maxOccurs="unbounded"/>
    </xsd:sequence>
    <xsd:attribute name="id"
                   type="xsd:ID"/>
  </xsd:complexType>

<!-- **************************************************** -->

  <xsd:complexType name="security-permissionType">
    <xsd:annotation>
      <xsd:documentation>

        The security-permissionType specifies a security
        permission that is required by the resource adapter code.

        The security permission listed in the deployment descriptor
        are ones that are different from those required by the
        default permission set as specified in the connector
        specification. The optional description can mention specific
        reason that resource adapter requires a given security
        permission.

      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="description"
                   type="jakartaee:descriptionType"
                   minOccurs="0"
                   maxOccurs="unbounded"/>
      <xsd:element name="security-permission-spec"
                   type="jakartaee:xsdStringType">
        <xsd:annotation>
          <xsd:documentation>

            The element security-permission-spec specifies a security
            permission based on the Security policy file
            syntax. Refer to the following URL for Sun's
            implementation of the security permission
            specification:

            http://docs.oracle.com/javase/6/docs/technotes/guides/security/PolicyFiles.html

          </xsd:documentation>
        </xsd:annotation>
      </xsd:element>
    </xsd:sequence>
    <xsd:attribute name="id"
                   type="xsd:ID"/>
  </xsd:complexType>

</xsd:schema>
<security-permission-spec>

 grant {
 permission java.net.SocketPermission *, "resolve";
 };
</security-permission-spec>
<security-permission>
 <security-permission-spec>

 grant {

 permission java.io.FilePermission
"${user.home}${file.separator}trace{file.separator}-",
 "read,write,delete";
 };

 </security-permission-spec>

</security-permission>
// application code

...

WombatConnectionFactory wcf =  (WombatConnectionFactory) jndi.lookup("WombatConnectionFactory");
WombatConnection wc = wcf.getConnection(..);
doWork(wc); // calls into resource adapter code

// resource adapter implementation of WombatConnection

...

AccessController.doPrivileged(new
PrivilegedAction() {

 public Object run() {

 // privileged code goes here, for example:

 File file = File.createNewFile();

 writeTraceInfoToFile(file);

 return null; // nothing to return

 }

});

Description	Supported / NotSupported
TM does two-phase commit (2PC) on RMs that support two-phase commit (as defined in RM’s requirements for XAResource implementation in the subsection below) Examples of RM: Oracle and DB2 installations that support 2PC in their XAResource implementations.	Supported based on TM’s requirement to be Jakarta Transaction/JTS and X/Open compliant, and RM’s support for 2PC in the XAResource interface.
TM does one-phase commit (1PC) optimization on the only RM involved in a transaction. RM supports 2PC in its XAResource implementation (as defined in RM’s requirements for the XAResource implementation in the subsection below). Example of RM: DB2 installation that supports 2PC in its XAResource implementation.	Supported based on TM’s requirement to be Jakarta Transaction/JTS and X/Open compliant, and RM’s support for the XAResource interface. Note: This scenario will also work if TM does 2PC on RM.
TM does one-phase commit optimization on the only RM involved in a transaction. RM does not support 2PC but supports 1PC in its XAResource implementation. Example of RM: ERP system or mainframe TP system that does not support 2PC, but implements 1PC in its XAResource implementation as defined in the RM’s requirements for 1PC.	Supported by requiring that TM must support 1PC optimization. A successful transaction coordination of 1PC only RM comes as a result of required 1PC optimization for a TM. The rationale behind this requirement is that this scenario will be an important scenario to support for Jakarta Connectors.
TM does last-resource commit optimization across multiple RMs involved in a transaction—RMs that support 2PC (for example: Oracle and DB2) and a single RM that supports only 1PC (for example: an ERP system).	Out of the scope of the Jakarta Connectors specification
More than one RM that support only 1PC involved in a transaction with none or multiple 2PC enabled RMs	Out of the scope of the Jakarta Connectors specification

	Source managed transaction	No source managed transaction
Endpoint instance requires transacted message delivery	Use the source managed transaction. Ignore the XAResource instance supplied by the resource adapter, if any.	Start a new transaction. Notify the XAResource instance supplied by the resource adapter, if any.
Endpoint does not need transacted message delivery	Suspend the source managed transaction. Ignore the XAResource instance supplied by the resource adapter, if any.	No action. Ignore the XAResource instance supplied by the resource adapter, if any.

Property	Description
UserName	The name of the user establishing a connection to an EIS instance.
Password	The password for the user establishing a connection.

Deployment Descriptor	metadata-complete?	process annotations
Connector 1.5 ra.xml or earlier	Not applicable	No
Connector 1.6 ra.xml	True	No
Connector 1.6 ra.xml	False or Unspecified	Yes
No ra.xml bundled with the RAR module archive	Not Applicable	Yes

	LM	WM	MI	TI	CM	TM	SM	CCI
Outbound	?	?			+	+	+	?
Inbound	+	?	+	?
Bi-directional	+	?	+	?	+	+	+	?

Contents of RAR file	Requirements	Relative Location Within RAR File
Deployment Descriptor	Optional	META-INF/ra.xml
howto.html, image files, locale files, etc.	Optional	Arbitrary (that is, could be at root level or at a sub-level).
JAR files	Optional	Arbitrary
Platform-specific native libraries	Optional	Arbitrary

Property	Description
ServerName	Name of the server for the EIS instance.
PortNumber	Port number for establishing a connection to an EIS instance.
UserName	Name of the user establishing a connection to an EIS instance.
Password	Password for the user establishing a connection.
ConnectionURL	URL for the EIS instance to which it connects.

Security Permission	Default Policy	Notes
java.security.AllPermission	deny	Extreme care should be taken before granting this permission to a resource adapter. This permission should only be granted if the resource adapter code is completely trusted and when it is prohibitively cumbersome to add necessary permissions to the security policy.
java.awt.AWTPermission	deny *	A resource adapter must not use AWT code to interact with display or input devices.
java.io.FilePermission	grant read and write <pathname> deny rest	A java.io.FilePermission represents access to a file or directory. A FilePermission consists of a pathname and a set of actions valid for that pathname. A resource adapter is granted permission to read/write files as specified by the pathname , which is specific to a configured operational environment. It is important to consider the implications of granting Write permission for [ALL FILES] because this grants the resource adapter permissions to write to the entire file system. This can allow a malicious resource adapter to mangle system binaries for the JVM environment.
java.net.NetPermission	deny *
java.util.PropertyPermission	grant read (allows System.getProperty to be called) deny rest	Granting code permission to access certain system properties ( java.home ) can potentially give malevolent code sensitive information about the system environment, such as the Java installation directory.
java.lang.reflect.ReflectPermission	deny *
java.lang.RuntimePermission	deny *	By default, RuntimePermission is denied to the resource adapter code. A resource adapter should explicitly request LoadLibrary.{libraryName} to link a dynamic library. The libraryName represents a specific library. A resource adapter that manages threads must explicitly request permission to modifyThread through its deployment descriptor. A resource adapter should never be granted exitVM permission in a managed application server environment.
java.security.SecurityPermission	deny *
java.net.SocketPermission	grant connect * deny rest	This represents permission to access a network by way of sockets. A SocketPermission consists of a host specification and a set of actions specifying ways to connect to that host. A resource adapter is granted permission to connect to any host as indicated by the wildcard . A resource adapter may be granted permission to accept connections from other hosts by way of a “grant accept ”. This may be necessary for resource adapters that support inbound communication.
java.security.SerializablePermission	deny *	This ensures that a resource adapter cannot subclass ObjectOutputStream or ObjectInputStream to override the default serialization or deserialization of objects or to substitute one object for another during serialization or deserialization.

Method	Security Manager Method Called	Permission
java.net.Socket Socket(…)	checkConnect( host, port )	java.net.SocketPermission "host:port ", "connect"
java.net.InetAddress public String getHostName()	checkConnect( host, -1 )	java.net.SocketPermission " host ", " resolve "

Jakarta Connectors

Eclipse Foundation Specification License

Disclaimers

1. Jakarta Connectors, Version 2.1

2. Introduction

2.1. Overview

2.2. Scope

2.3. Target Audience

2.4. JDBC and Jakarta Connectors

2.5. Relationship With Other Integration Technologies (JBI and SCA)

2.6. Organization

2.7. Document Conventions

3. Overview

3.1. Definitions

3.1.1. Enterprise Information System (EIS)

3.1.2. Connector Architecture

3.1.3. EIS Resource

3.1.4. Resource Manager (RM)

3.1.5. Managed Environment

3.1.6. Non-Managed Environment

3.1.7. Connection

3.1.8. Application Component

3.1.9. Container

3.2. Rationale

3.2.1. System Contracts

3.2.2. Common Client Interface

3.3. Goals

4. Architecture of Jakarta Connectors

4.1. System Contracts

4.2. Client API

4.3. Requirements

4.4. Non-Managed Environment

4.5. Standalone Container Environment

5. Roles and Scenarios

5.1. Roles

5.1.1. Resource Adapter Provider

5.1.2. Application Server Vendor

5.1.3. Container Provider

5.1.4. Application Component Provider

5.1.5. Enterprise Tools Vendors

5.1.6. Application Assembler

5.1.7. Deployer

5.1.8. System Administrator

5.2. Scenario: Integrated Purchase Order System

5.2.1. Illustration of a Scenario Based on the Connector Architecture

5.3. Scenario: Business Integration

5.3.1. Connector Architecture Usage in Business Integration Scenario

6. Lifecycle Management

6.1. Overview

6.2. Goals

6.3. Lifecycle Management Model

6.3.1. ResourceAdapter JavaBean and Bootstrapping a Resource Adapter Instance

6.3.2. ManagedConnectionFactory JavaBean and Outbound Communication

6.3.3. ActivationSpec JavaBean and Inbound Communication

6.3.4. Resource Adapter Shutdown Procedure

6.3.4.1. Phase One

6.3.4.2. Phase Two

6.3.5. Requirements

6.3.6. Resource Adapter Implementation Guidelines

6.3.7. JavaBean Configuration and Deployment

6.3.7.1. ResourceAdapter JavaBean Instance Configuration

6.3.7.2. Resource Adapter Deployment

6.3.7.3. ManagedConnectionFactory JavaBean Instance Configuration

6.3.7.4. ActivationSpec JavaBean Instance Configuration

6.3.7.5. JavaBean Validation

6.3.7.6. Configuration Property Attributes

Dynamic Reconfigurable Configuration Properties

Confidential Properties

6.3.7.7. Resource Adapter Implementation Guidelines

6.3.8. Lifecycle Management in a Non-Managed Environment

6.3.9. A Sample Resource Adapter Implementation

7. Connection Management

7.1. Overview

7.2. Goals

7.3. Architecture: Connection Management

7.3.1. Overview: Managed Application Scenario

7.4. Application Programming Model

7.4.1. Managed Application Scenario

7.4.2. Non-Managed Application Scenario

7.4.3. Guidelines