www.ironjacamar.orgCommunity Documentation
Table of Contents
List of Tables
datasource
elementsxa-datasource
elementsTable of Contents
The goal of the IronJacamar project is to provide an implementation of the Java Connector Architecture 1.7 specification.
The specification can be found here: http://www.jcp.org/en/jsr/detail?id=322.
The IronJacamar project is licensed under the GNU LESSER GENERAL PUBLIC LICENSE 2.1 (LGPL 2.1) license.
The Java EE Connector Architecture container can be viewed as a foundation inside an application server as it provides connectivity to the other containers such that they can communicate with EISes. Iron is often used as foundation in building houses too.
The Jacamar bird family which lives in Central and South America are glossy elegant birds with long bills and tails. Why we picked the Jacamar family is left as an exercise for the reader :)
This section contains the highlights of the IronJacamar releases. A full description of each release can be found through our issue tracking system at http://issues.jboss.org/browse/JBJCA.
Highlights as compared to IronJacamar 1.0:
Highlights as compared to previous Java EE Connector Architecture containers inside JBoss Application Server:
Jesper Pedersen acts as the lead for the IronJacamar project. He can be reached at jesper (dot) pedersen (at) ironjacamar (dot) org.
Jeff Zhang is a core developer on the IronJacamar project. He can be reached at jeff (dot) zhang (at) ironjacamar (dot) org.
Stefano Maestri is a core developer on the IronJacamar project. He can be reached at stefano (dot) maestri (at) ironjacamar (dot) org.
Lin Gao is a core developer on the IronJacamar project. He can be reached at lin (dot) gao (at) ironjacamar (dot) org.
Vladimir Rastseluev is a core developer on the IronJacamar project. He can be reached at vrastseluev (at) ironjacamar (dot) org.
Dimitris Andreadis is an advocate for the IronJacamar project. He can be reached at dimitris (at) ironjacamar (dot) org.
Johnaton Lee helps out in the IronJacamar community with identifying issues, and fixing them. He can be reached at johnathonlee (at) ironjacamar (dot) org.
Tyronne Wickramarathne helps out in the IronJacamar community with identifying issues, and fixing them. He can be reached at tyronne (at) ironjacamar (dot) org.
Adrian Brock, Carlo de Wolf, Gurkan Erdogdu, Bruno Georges, Paul Gier, Jason Greene, Stefan Guilhen, Jonathan Halliday, Søren Hilmer, Ales Justin, Vicky Kak, Aslak Knutsen, Sacha Labourey, Mark Little, Alexey Loubyansky, Patrick MacDonald, Scott Marlow, Shelly McGowan, Andrig Miller, Marcus Moyses, Weston Price, Andrew Lee Rubinger, Heiko Rupp, Anil Saldhana, Scott Stark, Clebert Suconic, Andy Taylor, Vladimir Vasilev, Jeremy Whiting, Yang Yong and Leslie York.
Copyright © 2013 Red Hat, Inc. and others.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA").
An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Table of Contents
The Java Connector Architecture (JCA) defines a standard architecture for connecting the Java EE platform to heterogeneous Enterprise Information Systems (EIS). Examples of EISs include Enterprise Resource Planning (ERP), mainframe transaction processing (TP), databases and messaging systems.
The connector architecture defines a set of scalable, secure, and transactional mechanisms that enable the integration of EISs with application servers and enterprise applications.
The connector architecture also defines a Common Client Interface (CCI) for EIS access. The CCI defines a client API for interacting with heterogeneous EISs.
The connector architecture enables an EIS vendor to provide a standard resource adapter for its EIS. A resource adapter is a system-level software driver that is used by a Java application to connect to an EIS. The resource adapter plugs into an application server and provides connectivity between the EIS, the application server, and the enterprise application. The resource adapter serves as a protocol adapter that allows any arbitrary EIS communication protocol to be used for connectivity. An application server vendor extends its system once to support the connector architecture and is then assured of seamless connectivity to multiple EISs. Likewise, an EIS vendor provides one standard resource adapter which has the capability to plug in to any application server that supports the connector architecture.
The Java Connector Architecture 1.7 specification adds the following areas:
The deployment annotations are only meant for developer usage, and should not be used in test or production environments.
The IronJacamar standalone and embedded distributions doesn't support these annotations.
The Java Connector Architecture 1.6 specification adds the following major areas:
The Java EE Connector Architecture features three different types of resource adapters
For more information about Java EE Connector Architecture see the specification.
The Java Connector Architecture specification consists of a number of outbound components:
The application uses the
The resource adapter contains
IronJacamar - the application server - contains
The Java Connector Architecture specification consists of a number of inbound components:
The application uses the
The resource adapter contains
IronJacamar - the application server - contains
Table of Contents
The official IronJacamar project page is http://www.ironjacamar.org/ where you can download the software.
The download location is: http://www.ironjacamar.org/downloads/
Each release is labelled with a version number and an identifier.
ironjacamar-<major>.<minor>.<patch>.<identifier>
where
An example
ironjacamar-1.1.0.Final.tar.gz
which is a stable release of the project.
The IronJacamar distribution is deployed to the JBoss Nexus repository.
Repository: http://repository.jboss.org/nexus/content/groups/public/
Group id: org.jboss.ironjacamar
Table 2.1. Maven artifacts
Artifact | Description |
---|---|
ironjacamar-arquillian-embedded | The Arquillian extension for the embedded module |
ironjacamar-arquillian-embedded-byteman | The Arquillian/Byteman extension for the embedded module |
ironjacamar-as | WildFly integration tools |
ironjacamar-codegenerator | The code generator |
ironjacamar-common-api | The API for the common module |
ironjacamar-common-impl | The implementation for the common module |
ironjacamar-common-spi | The SPI for the common module |
ironjacamar-core-api | The API / SPI for the core module |
ironjacamar-core-impl | The implementation for the core module |
ironjacamar-depchain | The dependency chain for the IronJacamar container |
ironjacamar-deployers-common | The common classes for the deployer chains |
ironjacamar-deployers-fungal | The deployers for the Fungal kernel based setup |
ironjacamar-embedded | The embedded module |
ironjacamar-jdbc | The core library for the JDBC resource adapters |
ironjacamar-spec-api | The Java EE Connector Architecture 1.7 API |
ironjacamar-test-eis | The Enterprise Information System test server |
ironjacamar-validator | The validator module |
ironjacamar-validator-ant | The Apache Ant tasks for the validator module |
ironjacamar-validator-cli | The command line interface for the validator module |
jdbc-local | A JDBC resource adapter backing standard datasources |
jdbc-xa | A JDBC resource adapter backing XA datasources |
If you want to experiment with the latest developments you may checkout the latest code from Git. Be aware that the information provided in this manual might then not be accurate.
The Git repository is located at:
http://github.com/ironjacamar/ironjacamar
You can find additional information about this in the developer guide.
Table of Contents
Once you have downloaded the distribution you need to install it in a location of your choice.
Extract the distribution using
tar xzf ironjacamar-1.1.0.Final.tar.gz
The distribution will be located in a directory named
ironjacamar-1.1.0.Final
Extract the distribution using
unzip ironjacamar-1.1.0.Final.zip
or any program capable of handling Zip archives such as WinZip and WinRar.
The distribution will be located in a directory named
ironjacamar-1.1.0.Final
The IronJacamar container has the following directory structure:
The IronJacamar provides the Java EE Connector Architecture (JCA) container for WildFly 8 and future versions.
The container can be updated in WildFly by using the
as-upgrader.sh
script in the doc/as
directory.
This will allow an easy installation of IronJacamar patch releases to fix bugs
in the application server environment.
The script can be used, like:
./as-upgrader.sh 1.1.0.Final /path/to/wildfly/installation
where 1.1.0.Final
is the version identifier of the IronJacamar container
and the path points to the top-level directory of the WildFly installation.
You can also use 1.1.1-SNAPSHOT
in order to upgrade to a patch snapshot build.
You can get an overview of all IronJacamar releases by searching our Nexus repository.
Table of Contents
The configuration for the IronJacamar container is mainly located under the config/
directory.
The IronJacamar server can be configured by including an ironjacamar.properties
file
next to the ironjacamar-sjc.jar
in the bin/
directory.
This file will allow to override the core options given to the kernel environment, if multiple instances of the IronJacamar container are going to run on the same machine, and network interface.
The options available
Table 4.1. IronJacamar options
Property | Type | Description |
---|---|---|
name | String | The name of the IronJacamar configuration |
management | boolean | Should management be enabled |
parallel.deploy | boolean | Should parallel deployment be enabled |
remote.access | boolean | Should remote access be enabled |
remote.port | int | The port for remote access |
remote.jmx.access | boolean | Should remote access via JMX be enabled |
use.platform.mbeanserver | boolean | Should the platform MBeanServer be used for management |
bean.management | boolean | Should management for all beans be enabled |
An example of an ironjacamar.properties
file:
remote.access=true remote.port=1302
IronJacamar features a connection pool implementation, which keeps track of connection allocations, and their release in order to provide feedback if a connection is obtained, but never released by the application. This will cause leaks, and lead to applications not being able to obtain any connections.
The leak detector pool provides a stack trace of the leaked connection allocation either during shutdown of the pool, or once the pool is flush using a flush strategy which kills all active connections.
The leak detector pool is configured using the ironjacamar.mcp
system
property with a value of
org.jboss.jca.core.connectionmanager.pool.mcp.LeakDumperManagedConnectionPool
This configuration applies to all connection pools used by IronJacamar.
The system property ironjacamar.leaklog
can be used
to have the leaks dumped out into a special file separate from the logging
setup.
An example
-Dironjacamar.mcp=org.jboss.jca.core.connectionmanager.pool.mcp.LeakDumperManagedConnectionPool -Dironjacamar.leaklog=leaks.txt
IronJacamar doesn't allow to obtain a connection once a transaction is in
MARKED_FOR_ROLLBACK
mode. This allows the container to fail
eagerly, since any work after that point is wasted anyway.
However, certain applications depends on getting a connection to perform work.
IronJacamar has a system property called ironjacamar.allow_marked_for_rollback
which can be set to true
to enable this scenario.
IronJacamar records transaction enlistment traces in order to help to locate error situations
that happens during enlistment of XAResource
instances.
This has a performance overhead of course, so in certain situations you may want to disable these traces.
IronJacamar has a system property called ironjacamar.disable_enlistment_trace
which can be set to true
which does this.
IronJacamar calls transaction.enlistResource(xaResource)
for the ManagedConnection
when it is enlisting in the transaction.
IronJacamar will also call transaction.delistResource(xaResource, flag)
once the
ManagedConnection
should be disassociated with the transaction. This typically happens
on the transaction boundary (beforeCompletion
) before the connection is returned to
the pool (afterCompletion
). This is done as part of the transaction specification contract.
However, in certain scenarios you may want to disable this call, as other Synchronization
objects may still want the connection enlisted in the transaction, and hence it depends on the
ordering of these objects.
IronJacamar has a system property called ironjacamar.no_delist_resource
which is a ','
separated list of pool names where delistResource
shouldn't be called. Disabling the delistResource
call for all pools can be done
by defining ironjacamar.no_delist_resource_all
.
delistResource
call it is up to the resource manager and transaction
manager to make sure that the connection is delisted from the transaction in all cases.
The IronJacamar container uses JBoss Logging framework as the implementation.
The configuration is done in the
config/logging.properties
file.
Consult the JBoss Logging documentation on how the service can be configured.
The IronJacamar container uses Narayana its transaction implementation.
The configuration is done in the
config/transaction.xml
file.
Consult the Narayana documentation on how the service can be configured.
The IronJacamar deployer is configured in the
config/bootstrap/jca.xml
file.
The configuration of the resource adapter deployer chain is handled
by a org.jboss.jca.deployers.fungal.RAConfiguration
bean.
<bean name="RAConfiguration"
class="org.jboss.jca.deployers.fungal.RAConfiguration">
<property name="ArchiveValidation">true</property>
<property name="ArchiveValidationFailOnWarn">false</property>
<property name="ArchiveValidationFailOnError">true</property>
<property name="BeanValidation">true</property>
<property name="PrintStream">
<inject bean="JBossStdioContext" property="Out"/>
</property>
<property name="DefaultBootstrapContext">
<inject bean="DefaultBootstrapContext"/>
</property>
<property name="JndiStrategy"><inject bean="JndiStrategy"/></property>
<property name="TransactionManager">
<inject bean="RealTransactionManager"/>
</property>
<property name="MetadataRepository"><inject bean="MDR"/></property>
</bean>
Table 4.2. Resource adapter deployer configuration
Property | Type | Description |
---|---|---|
ArchiveValidation | boolean |
Toggle archive validation for the deployment units.
Default: |
ArchiveValidationFailOnWarn | boolean |
Should an archive validation warning report fail the deployment.
Default: |
ArchiveValidationFailOnError | boolean |
Should an archive validation error report fail the deployment.
Default: |
BeanValidation | boolean |
Toggle bean validation (JSR-303) for the deployment units.
Default: |
DefaultBootstrapContext | org.jboss.jca.core.api.bootstrap.CloneableBootstrapContext | Specifies the default bootstrap context for resource adapters |
BootstrapContexts | Map<String, org.jboss.jca.core.api.bootstrap.CloneableBootstrapContext> |
Bootstrap context map (unique name to a cloneable bootstrap context) which allows
developers to bind (through ironjacamar.xml ) their resource adapter to
a specific bootstrap context instance.
|
PrintStream | java.io.PrintStream |
Specifies which print stream that should be used to handle the LogWriter s
|
MetadataRepository | org.jboss.jca.core.spi.mdr.MetadataRepository | The metadata repository |
ResourceAdapterRepository | org.jboss.jca.core.spi.rar.ResourceAdapterRepository | The resource adapter repository |
ScopeDeployment | boolean |
Should each deployment be scoped (isolated) from the container. This feature allows
deployment of libraries of a different version than used in the container environment.
Default: |
JndiStrategy | org.jboss.jca.core.spi.naming.JndiStrategy |
Specifies the JNDI strategy policy for binding the connection factories into
the naming environment
The JNDI strategies are located in the
|
The initial deployer for resource adapter archives is handled
by a org.jboss.jca.deployers.fungal.RADeployer
bean.
<bean name="RADeployer"
interface="com.github.fungal.spi.deployers.Deployer"
class="org.jboss.jca.deployers.fungal.RADeployer">
<property name="Configuration"><inject bean="RAConfiguration"/></property>
<depends>BeanValidation</depends>
<depends>JBossStdioContextSelector</depends>
</bean>
This deployer will register the resource adapters with the metadata repository in the system.
Table 4.3. Resource adapter deployer
Property | Type | Description |
---|---|---|
Configuration | org.jboss.jca.deployers.fungal.RAConfiguration | The configuration for the deployer |
The deployer for deploying our -ra.xml
deployment descriptor is handled
by a org.jboss.jca.deployers.fungal.RaXmlDeployer
bean.
The deployment descriptor is defined by the resource-adapters-1_0.xsd
and
resource-adapters-1_1.xsd
schemas.
<bean name="RaXmlDeployer"
interface="com.github.fungal.spi.deployers.Deployer"
class="org.jboss.jca.deployers.fungal.RaXmlDeployer">
<property name="Configuration"><inject bean="DeployerConfiguration"/></property>
<property name="Kernel"><inject bean="Kernel"/></property>
<depends>BeanValidation</depends>
<depends>JBossStdioContextSelector</depends>
</bean>
This deployer will activate resource adapters based on the deployment information.
Table 4.4. Resource adapter metadata deployer
Property | Type | Description |
---|---|---|
Configuration | org.jboss.jca.deployers.fungal.RAConfiguration | The configuration for the deployer |
The deployer chain features an activator for resource adapter archives is handled
by the org.jboss.jca.deployers.fungal.RAActivator
bean.
<bean name="RAActivator"
class="org.jboss.jca.deployers.fungal.RAActivator">
<property name="Configuration"><inject bean="RAConfiguration"/></property>
<property name="Kernel"><inject bean="Kernel"/></property>
<property name="ExcludeArchives">
<set elementClass="java.lang.String">
<value>jdbc-local.rar</value>
<value>jdbc-xa.rar</value>
</set>
</property>
<depends>BeanValidation</depends>
<depends>JBossStdioContextSelector</depends>
</bean>
This activator will activate any resource adapters which hasn't been activated yet unless they are in the excluded list.
Table 4.5. Resource adapter activator
Property | Type | Description |
---|---|---|
Configuration | org.jboss.jca.deployers.fungal.RAConfiguration | The configuration for the deployer |
Enabled | boolean |
Should the activator be enabled. Default is true
|
Kernel | com.github.fungal.api.Kernel | The kernel instance |
ExcludeArchives | java.util.Set | A set of resource adapter archives which should be excluded from activation |
IronJacamar features a standard work manager on its default setup using one thread pool for
short running jobs, and one thread pool for long running jobs identified by the
HintsContext.LONGRUNNING_HINT
with a value of true
.
The configuration of the work manager and the necessary components can be viewed in the jca.xml
file.
A distributed work manager is a work manager instance, which is able to reschedule work execution on another work manager instance on the network.
The distributed work manager has three additional components
to control the distribution process.
Supported policies
org.jboss.jca.core.workmanager.policy.Never
Never the distribute the Work
instance to another node.
org.jboss.jca.core.workmanager.policy.Always
Always the distribute the Work
instance to another node.
org.jboss.jca.core.workmanager.policy.WaterMark
Distribute the Work
instance to another node based on how many
free worker threads the current node has available.
Supported selectors
org.jboss.jca.core.workmanager.selector.FirstAvailable
Select the first available node in the list
org.jboss.jca.core.workmanager.selector.PingTime
Select the node with the lowest ping time
org.jboss.jca.core.workmanager.selector.MaxFreeThreads
Select the node with highest number of free worker threads
Supported transports
org.jboss.jca.core.workmanager.transport.remote.socket.SocketTransport
Communication based on java.net.Socket
, and hence TCP/IP
org.jboss.jca.core.workmanager.transport.remote.jgroups.JGroupsTransport
Communication based on the JGroups framework, and hence UDP (by default)
Below is an example of a socket based configuration where two instances localhost:1299
and
localhost:1300
communicates, taken from the IronJacamar test suite.
<deployment>
<!-- DistributedWorkManagerThreadGroupSocket -->
<bean name="DistributedWorkManagerThreadGroupSocket"
class="java.lang.ThreadGroup">
<constructor>
<parameter>dwm</parameter>
</constructor>
<ignoreStop/>
<ignoreDestroy/>
</bean>
<!-- DistributedWorkManagerThreadFactorySocket -->
<bean name="DistributedWorkManagerThreadFactorySocket"
interface="java.util.concurrent.ThreadFactory"
class="org.jboss.threads.JBossThreadFactory">
<constructor>
<parameter><inject bean="DistributedWorkManagerThreadGroupSocket"/></parameter>
<parameter>false</parameter>
<parameter>5</parameter>
<parameter>work</parameter>
<parameter><null/></parameter>
<parameter><null/></parameter>
</constructor>
</bean>
<!-- DistributedWorkManagerShortRunningThreadPoolSocket -->
<bean name="DistributedWorkManagerShortRunningThreadPoolSocket"
class="org.jboss.threads.QueueExecutor">
<constructor>
<!-- Core threads -->
<parameter>20</parameter>
<!-- Max threads -->
<parameter>100</parameter>
<!-- 60 seconds keepalive -->
<parameter>60</parameter>
<parameter><inject bean="KeepAliveTimeUnit"/></parameter>
<!-- Queue size -->
<parameter>1024</parameter>
<!-- Thread factory -->
<parameter><inject bean="DistributedWorkManagerThreadFactorySocket"/></parameter>
<!-- Blocking -->
<parameter>true</parameter>
<!-- Handoff executor -->
<parameter><inject bean="RejectingExecutor"/></parameter>
</constructor>
<destroy method="shutdown"/>
</bean>
<!-- DistributedWorkManagerPolicySocket -->
<bean name="DistributedWorkManagerPolicySocket"
class="org.jboss.jca.core.workmanager.policy.Always">
</bean>
<!-- DistributedWorkManagerSelectorSocket -->
<bean name="DistributedWorkManagerSelectorSocket"
class="org.jboss.jca.core.workmanager.selector.FirstAvailable">
</bean>
<!-- DistributedWorkManagerTransportSocket -->
<bean name="DistributedWorkManagerTransportSocket"
class="org.jboss.jca.core.workmanager.transport.remote.socket.SocketTransport">
<!-- The id -->
<property name="Id">1</property>
<!-- The executor -->
<property name="ExecutorService">
<inject bean="Kernel" property="ExecutorService"/>
</property>
<!-- The host -->
<property name="Host">127.0.0.1</property>
<!-- The port -->
<property name="Port">1299</property>
<!-- The peers -->
<property name="Peers">
<set class="java.util.HashSet"
elementClass="java.lang.String">
<value>localhost:1300</value>
</set>
</property>
<start method="startup"/>
<stop method="shutdown"/>
</bean>
<!-- DistributedWorkManagerSocket -->
<bean name="DistributedWorkManagerSocket"
interface="org.jboss.jca.core.api.workmanager.DistributedWorkManager"
class="org.jboss.jca.core.workmanager.DistributedWorkManagerImpl">
<!-- The name -->
<property name="Name">DWM-Socket</property>
<!-- The short running thread pool -->
<property name="ShortRunningThreadPool">
<inject bean="DistributedWorkManagerShortRunningThreadPoolSocket"/>
</property>
<!-- The XA terminator -->
<property name="XATerminator">
<inject bean="TransactionIntegration" property="XATerminator"/>
</property>
<!-- The callback security module -->
<property name="CallbackSecurity">
<inject bean="Callback"/>
</property>
<!-- The policy -->
<property name="Policy">
<inject bean="DistributedWorkManagerPolicySocket"/>
</property>
<!-- The selector -->
<property name="Selector">
<inject bean="DistributedWorkManagerSelectorSocket"/>
</property>
<!-- The transport -->
<property name="Transport">
<inject bean="DistributedWorkManagerTransportSocket"/>
</property>
<!-- <destroy method="shutdown"/> -->
</bean>
<!-- DistributedBootstrapContextSocket -->
<bean name="DistributedBootstrapContextSocket"
interface="org.jboss.jca.core.api.bootstrap.CloneableBootstrapContext"
class="org.jboss.jca.core.bootstrapcontext.BaseCloneableBootstrapContext">
<property name="Name">DWMBC-Socket</property>
<property name="TransactionSynchronizationRegistry">
<inject bean="TransactionSynchronizationRegistry"/>
</property>
<property name="WorkManagerName">
<inject bean="DistributedWorkManagerSocket" property="Name"/>
</property>
<property name="XATerminator">
<inject bean="TransactionIntegration" property="XATerminator"/>
</property>
</bean>
</deployment>
The Java EE Connector Architecture 1.6 specification allows units of
javax.resource.spi.Work
to be executed in a specific security context.
This is done through the use of Java Authentication Service Provider Interface for Containers (JSR-196)
call backs using the javax.security.auth.callback.Callback
interface.
The support is activated by letting the work instance implement the
javax.resource.spi.work.WorkContextProvider
interface and returning an instance of javax.resource.spi.work.SecurityContext
.
The security callback is configured through the >workmanager<
element for the
deployment, either in ironjacamar.xml
or in the -ra.xml
file. See the schema
definitions for further details.
There is support for creating a basic security domain which can provide
a javax.security.auth.Subject
instance to deployments that
are using <security-domain>
or
<security-domain-and-application>
in their setup.
A security domain can be configured through
<!-- SubjectFactory -->
<bean name="DefaultSecurityDomain"
interface="org.jboss.security.SubjectFactory"
class="org.jboss.jca.core.security.DefaultSubjectFactory">
<property name="SecurityDomain">DefaultSecurityDomain</property>
<property name="UserName">user</property>
<property name="Password">password</property>
</bean>
beans.
The IronJacamar project can deploy datasources using the datasources-1_0.xsd
,
datasources-1_1.xsd
or datasources-1_2.xsd
schemas.
The configuration is done in the
config/bootstrap/ds.xml
file.
Table 4.6. DsXmlDeployer
Property | Type | Description |
---|---|---|
JDBCLocal | String |
The name of the jdbc-local.rar deployment
|
JDBCXA | String |
The name of the jdbc-xa.rar deployment
|
TransactionManager | javax.transaction.TransactionManager | The transaction manager |
MetadataRepository | org.jboss.jca.core.spi.mdr.MetadataRepository | The metadata repository |
Kernel | com.github.fungal.api.Kernel | The kernel |
The datasource deployer can be removed from the environment by removing the ds.xml
file in
config/bootstrap/
as well as the reference in config/bootstrap/bootstrap.xml
to the file.
Furthermore all jdbc-*.rar
files in the system/
directory should be removed too.
The IronJacamar project features a web server which is used to serve web archive deployments. More information about Jetty can be found at the homepage.
The configuration is done in the
system/web.xml
file.
<bean name="WebServer" class="org.jboss.jca.web.WebServer">
<property name="Host">${iron.jacamar.bindaddress:localhost}</property>
<property name="Port">8080</property>
<property name="ExecutorService"><inject bean="Kernel" property="ExecutorService"/></property>
</bean>
Table 4.7. Web server
Property | Type | Description |
---|---|---|
Host | String |
Set the bind address for the web server
Default: |
Port | int |
Set the port for the web server
Default: |
AcceptQueueSize | int |
Set the accept queue size for the Jetty connector
Default: |
ExecutorService | java.util.concurrent.ExecutorService |
The thread pool for the web server
Default: The kernel thread pool |
The web server can be removed from the environment by removing the web.xml
file in
system/
Furthermore all .war
files in the same directory should be removed too.
All the Jetty libraries can be removed by deleting the
lib/jetty
directory.
Table of Contents
The IronJacamar distribution contains a deploy/ directory where all deployments should be deployed to.
A resource adapter archive is a structured Java Archive (JAR) file, which bundles all Java classes in JAR files, and optionally contains metadata, resources and native libraries.
A resource adapter archive name ends in the .rar
extension.
An example of a resource adapter archive could look like
[jpederse@localhost]$ jar tf ra.rar META-INF/ra.xml readme.html ra.jar images/icon.jpg win.dll linux.so
See the Java EE Connector Architecture 1.7 specification chapter 20 for further requirements.
Resource adapters (.rar) are deployed by copying the resource adapter into the
deploy/
directory
cp example.rar ironjacamar-1.1.0.Final/deploy
on a Un*x based system or
copy example.rar ironjacamar-1.1.0.Final\deploy
on Windows.
The resource adapter can be configured and activated through a META-INF/ironjacamar.xml
file in the archive. The format of the XML document is defined by the ironjacamar_1_0.xsd
or
ironjacamar_1_1.xsd
schemas.
A resource adapter can also be configured and activated through deployment of a -ra.xml
file in the deploy/
directory - f.ex. deploy/example-ra.xml
. The format of the XML
document is defined by the resource-adapters_1_0.xsd
or resource-adapters_1_1.xsd
schemas - f.ex
<resource-adapters>
<resource-adapter>
<archive>example.rar</archive>
<connection-definitions>
<connection-definition jndi-name="java:/eis/example" class-name="com.example.ra.MCF"/>
</connection-definitions>
</resource-adapter>
</resource-adapters>
to bind the connection factory from com.example.ra.MCF
under java:/eis/example
.
See the schema appendix for additional details about the format.
Alternative the resource adapter deployments will be picked up by the RAActivator
bean which bind a single connection factory under
java:/eis/<deploymentName>
- f.ex. java:/eis/example
and a single admin object under
java:/eis/ao/<deploymentName>
- f.ex. java:/eis/ao/example
.
A resource adapter can be configured using two different ways
META-INF/ironjacamar.xml
for internal configuration-ra.xml
for external configurationto the resource adapter archive. Both formats share the same layout to ease configuration - only the top-level elements differ.
Table 5.1. Main elements
Element | Desciption |
---|---|
bean-validation-groups | Specifies bean validation group that should be used |
bootstrap-context | Specifies the unique name of the bootstrap context that should be used |
config-property | The config-property specifies resource adapter configuration properties. |
transaction-support | Define the type of transaction supported by this resource adapter. Valid values are: NoTransaction, LocalTransaction, XATransaction |
connection-definitions | Specifies the connection definitions |
admin-objects | Specifies the administration objects |
Table 5.2. Bean validation groups elements
Element | Desciption |
---|---|
bean-validation-group | Specifies the fully qualified class name for a bean validation group that should be used for validation |
Table 5.3. Connection definition / admin object attributes
Attribute | Desciption |
---|---|
class-name | Specifies the the fully qualified class name of a managed connection factory or admin object |
jndi-name | Specifies the JNDI name |
enabled | Should the object in question be activated |
use-java-context | Specifies if a java:/ JNDI context should be used |
pool-name | Specifies the pool name for the object |
use-ccm | Enable the cache connection manager |
sharable | Defines the connection as sharable (lazy association) (1.1) |
enlistment | Defines if the connection should use lazy enlistment if supported (1.1) |
Table 5.4. Connection definition elements
Element | Desciption |
---|---|
config-property | The config-property specifies managed connection factory configuration properties. |
pool | Specifies pooling settings |
xa-pool | Specifies XA pooling settings |
security | Specifies security settings |
timeout | Specifies time out settings |
validation | Specifies validation settings |
recovery | Specifies the XA recovery settings |
Table 5.5. Pool elements
Element | Desciption |
---|---|
min-pool-size | The min-pool-size element indicates the minimum number of connections a pool should hold. These are not created until a Subject is known from a request for a connection. This default to 0 |
initial-pool-size | The initial-pool-size element indicates the initial number of connections a pool should hold. These are not created until a Subject is known from a request for a connection. This default to 0 (1.1) |
max-pool-size | The max-pool-size element indicates the maximum number of connections for a pool. No more than max-pool-size connections will be created in each sub-pool. This defaults to 20. |
prefill | Whether to attempt to prefill the connection pool. Default is false |
use-strict-min | Specifies if the min-pool-size should be considered strictly. Default false |
flush-strategy |
Specifies how the pool should be flush in case of an error.
Valid values are: FailingConnectionOnly (default), InvalidIdleConnections (1.1),
IdleConnections , Gracefully (1.1), EntirePool ,
AllInvalidIdleConnections (1.1), AllIdleConnections (1.1),
AllGracefully (1.1), AllConnections (1.1)
|
capacity | Specifies the capacity policies (1.1) |
Table 5.6. XA pool elements
Element | Desciption |
---|---|
min-pool-size | The min-pool-size element indicates the minimum number of connections a pool should hold. These are not created until a Subject is known from a request for a connection. This default to 0 |
initial-pool-size | The initial-pool-size element indicates the initial number of connections a pool should hold. These are not created until a Subject is known from a request for a connection. This default to 0 (1.1) |
max-pool-size | The max-pool-size element indicates the maximum number of connections for a pool. No more than max-pool-size connections will be created in each sub-pool. This defaults to 20. |
prefill | Whether to attempt to prefill the connection pool. Default is false |
use-strict-min | Specifies if the min-pool-size should be considered strictly. Default false |
flush-strategy |
Specifies how the pool should be flush in case of an error.
Valid values are: FailingConnectionOnly (default), InvalidIdleConnections (1.1),
IdleConnections , Gracefully (1.1), EntirePool ,
AllInvalidIdleConnections (1.1), AllIdleConnections (1.1),
AllGracefully (1.1), AllConnections (1.1)
|
capacity | Specifies the capacity policies (1.1) |
is-same-rm-override | The is-same-rm-override element allows one to unconditionally set whether the javax.transaction.xa.XAResource.isSameRM(XAResource) returns true or false |
interleaving | An element to enable interleaving for XA connection factories |
no-tx-separate-pools | Oracle does not like XA connections getting used both inside and outside a JTA transaction. To workaround the problem you can create separate sub-pools for the different contexts |
pad-xid | Should the Xid be padded |
wrap-xa-resource | Should the XAResource instances be wrapped in an org.jboss.jca.core.spi.transaction.xa.XAResourceWrapper instance |
Table 5.7. Security elements
Element | Desciption |
---|---|
application | Indicates that application supplied parameters (such as from getConnection(user, pw)) are used to distinguish connections in the pool. |
security-domain | Indicates Subject (from security domain) are used to distinguish connections in the pool. The content of the security-domain is the name of the JAAS security manager that will handle authentication. This name correlates to the JAAS login-config.xml descriptor application-policy/name attribute. |
security-domain-and-application | Indicates that either application supplied parameters (such as from getConnection(user, pw)) or Subject (from security domain) are used to distinguish connections in the pool. The content of the security-domain is the name of the JAAS security manager that will handle authentication. This name correlates to the JAAS login-config.xml descriptor application-policy/name attribute. |
Table 5.8. Time out elements
Element | Desciption |
---|---|
blocking-timeout-millis | The blocking-timeout-millis element indicates the maximum time in milliseconds to block while waiting for a connection before throwing an exception. Note that this blocks only while waiting for a permit for a connection, and will never throw an exception if creating a new connection takes an inordinately long time. The default is 30000 (30 seconds). |
idle-timeout-minutes | The idle-timeout-minutes elements indicates the maximum time in minutes a connection may be idle before being closed. The actual maximum time depends also on the IdleRemover scan time, which is 1/2 the smallest idle-timeout-minutes of any pool. |
allocation-retry | The allocation retry element indicates the number of times that allocating a connection should be tried before throwing an exception. The default is 0. |
allocation-retry-wait-millis | The allocation retry wait millis element indicates the time in milliseconds to wait between retrying to allocate a connection. The default is 5000 (5 seconds). |
xa-resource-timeout | Passed to XAResource.setTransactionTimeout(). Default is zero which does not invoke the setter. Specified in seconds |
Table 5.9. Validation elements
Element | Desciption |
---|---|
background-validation | An element to specify that connections should be validated on a background thread versus being validated prior to use |
background-validation-millis | The background-validation-millis element specifies the amount of time, in milliseconds, that background validation will run. |
use-fast-fail | Whether fail a connection allocation on the first connection if it is invalid (true) or keep trying until the pool is exhausted of all potential connections (false). Default is false |
Table 5.10. Admin object elements
Element | Desciption |
---|---|
config-property | Specifies an administration object configuration property. |
Table 5.11. Recovery elements
Element | Desciption |
---|---|
recover-credential | Specifies the user name / password pair or security domain that should be used for recovery. |
recover-plugin | Specifies an implementation of the org.jboss.jca.core.spi.recovery.RecoveryPlugin class. |
The deployment schemas are defined in doc/ironjacamar_1_0.xsd
, doc/ironjacamar_1_1.xsd
,
doc/resource-adapters_1_0.xsd
and doc/resource-adapters_1_1.xsd
.
A resource adapter can make use of a couple of Java EE Connector Architecture extensions in the IronJacamar container in order to improve the integration.
The extensions include
org.jboss.jca.core.spi.recovery.RecoveryPlugin
: Plugin to provide feedback
to the recovery module inside IronJacamar.
org.jboss.jca.core.spi.statistics.Statistics
: Plugin to identify a resource
adapter component (ResourceAdapter
, ManagedConnectionFactory
and
admin object) that provides statistics.
The following sections will describe these extensions points.
The IronJacamar recovery extension allows the resource adapter deployment to give feedback
to the container if a ManagedConnection
can be used for recovery. This extension
is used as part of XA recovery in the environment, and should therefore be implemented by all
resource adapters capable of working in an XATransaction
semantics.
The interface org.jboss.core.spi.recovery.RecoveryPlugin
located in the
ironjacamar-core-api
artifact makes up the SPI for the extension.
The interface contains two methods that should be implemented in a resource adapter specific manner.
The method
public boolean isValid(Object c) throws ResourceException;
will return true
if the connection can be used for recovery.
The method
public void close(Object c) throws ResourceException;
will close a connection that was used for recovery.
The recovery extension is activated by adding a recovery element to the deployment
<recovery> <recovery-plugin>com.mycompany.myproject.RecoveryPluginImpl</recovery-plugin> </recovery>
The following recovery plugins are provided by IronJacamar
org.jboss.jca.core.recovery.DefaultRecoveryPlugin
: Default recovery plugin
that tries to call a close()
method on the underlying object
org.jboss.jca.core.recovery.ConfigurableRecoveryPlugin
: A recovery plugin
where the results of the isValid
and close
can be specified
org.jboss.jca.core.recovery.ValidatingManagedConnectionFactoryRecoveryPlugin
:
A recovery plugin that uses the javax.resource.spi.ValidatingManagedConnectionFactory
interface to verify the connection
The IronJacamar statistics extension allows a resource adapter to expose statistics to
the container and hence to the environment where IronJacamar is running. Statistics can
be enabled for ResourceAdapter
, ManagedConnectionFactory
and
admin object instances.
The extension include two interfaces org.jboss.core.spi.statistics.Statistics
and org.jboss.core.spi.statistics.StatisticsPlugin
. Both these interfaces are
located in the ironjacamar-core-api
artifact.
The Statistics
interface will mark a resource adapter component as statistics capable
and return the statistics plugin implementation instance.
The StatisticsPlugin
interface contains methods to expose and describe each statistic
that the plugin makes available. This information will then be made available to the environment
where the IronJacamar container is running using the environment's prefered mechanism.
Resource adapter deployments has the following core statistics values
Table 5.12. Core statistics
Name | Desciption |
---|---|
ActiveCount | The number of active connections. Each of the connections is either in use by an application or available in the pool |
AvailableCount | The number of available connections in the pool |
AverageBlockingTime | The average time spent blocking on obtaining an exclusive lock on the pool. The value is in milliseconds |
AverageCreationTime | The average time spent creating a connection. The value is in milliseconds |
AverageGetTime | The average time spent obtaining a connection. The value is in milliseconds |
BlockingFailureCount | The number of times where there was a time out getting an exclusive lock on the pool |
CreatedCount | The number of connections created |
DestroyedCount | The number of connections destroyed |
IdleCount | The number of connections currently idle |
InUseCount | The number of connections currently in use |
MaxCreationTime | The maximum time it took to create a connection. The value is in milliseconds |
MaxGetTime | The maximum time it took to obtain a connection. The value is in milliseconds |
MaxUsedCount | The maximum number of connections used |
MaxWaitCount | The maximum number of requests waiting for a connection at the same time |
MaxWaitTime | The maximum time spent waiting for an exclusive lock on the pool |
TimedOut | The number of timed out connections |
TotalBlockingTime | The total time spent waiting for an exclusive lock on the pool. The value is in milliseconds |
TotalCreationTime | The total time spent creating connections. The value is in milliseconds |
TotalGetTime | The total time spent obtaining connections. The value is in milliseconds |
WaitCount | The number of requests that had to wait for a connection |
Datasources (-ds.xml) are deployed by copying the definition into the
deploy/
directory
cp postgres-xa-ds.xml ironjacamar-1.1.0.Final/deploy
on a Un*x based system or
copy postgres-xa-ds.xml ironjacamar-1.1.0.Final\deploy
on Windows.
You will need to install the database JDBC driver into the lib/
directory.
You can find examples of datasource definitions in the doc/datasources
directory
and the schemas: doc/datasources_1_0.xsd
, doc/datasources_1_1.xsd
and
doc/datasources_1_1.xsd
.
Datasource descriptors are divided into
<datasource>
for a standard datasource<xa-datasource>
for an XA capable datasourcedefinitions.
A datasource descriptor supports the following parameters.
Table 5.13. Common datasource attributes
Attribute | Desciption |
---|---|
jndi-name | Specifies the JNDI name for the datasource |
pool-name | Specifies the pool name for the datasource used for management |
enabled | Specifies if the datasource should be enabled |
use-java-context | Setting this to false will bind the DataSource into global JNDI |
spy |
Enable spy functionality on the JDBC layer - e.g. log all JDBC traffic to the datasource.
The logging category jboss.jdbc.spy must be enabled too.
|
use-ccm | Enable the cached connection manager |
jta |
Enable JTA integration (only <datasource> )
|
Table 5.14. datasource
elements
Element | Desciption |
---|---|
connection-url | The JDBC driver connection URL |
driver-class | The fully qualifed name of the JDBC driver class |
datasource-class | The fully qualifed name of the JDBC datasource class |
driver |
An unique name for the JDBC driver specified in the drivers section. Or the name of the .jar file if deployed as standalone deployment This element is mandatory when deploying in WildFly |
connection-property | The connection-property element allows you to pass in arbitrary connection properties to the Driver.connect(url, props) method. Each connection-property specifies a string name/value pair with the property name coming from the name attribute and the value coming from the element content |
new-connection-sql | Specify an SQL statement to execute whenever a connection is added to the connection pool |
transaction-isolation | Set java.sql.Connection transaction isolation level to use. The constants defined by transaction-isolation-values are the possible transaction isolation levels and include: TRANSACTION_READ_UNCOMMITTED TRANSACTION_READ_COMMITTED TRANSACTION_REPEATABLE_READ TRANSACTION_SERIALIZABLE TRANSACTION_NONE |
url-delimiter | Specifies the delimeter for URLs in connection-url for HA datasources |
url-selector-strategy-class-name | A class that implements org.jboss.jca.adapters.jdbc.spi.URLSelectorStrategy |
pool | Specifies the pooling settings |
security | Specifies the security settings |
validation | Specifies the validation settings |
timeout | Specifies the time out settings |
statement | Specifies the statement settings |
Table 5.15. xa-datasource
elements
Element | Desciption |
---|---|
xa-datasource-property | Specifies a property to assign to the XADataSource implementation class. Each property is identified by the name attribute and the property value is given by the xa-datasource-property element content. The property is mapped onto the XADataSource implementation by looking for a JavaBeans style getter method for the property name. If found, the value of the property is set using the JavaBeans setter with the element text translated to the true property type using the java.beans.PropertyEditor for the type |
xa-datasource-class | The fully qualifed name of the javax.sql.XADataSource implementation class |
driver |
An unique name for the JDBC driver specified in the drivers section. Or the name of the .jar file if deployed as standalone deployment. This element is mandatory when deploying in WildFly |
url-delimiter | Specifies the delimeter for URLs in the connection url for HA datasources |
url-property | Specifies the property for the URL property in the xa-datasource-property values (1.2) |
url-selector-strategy-class-name | A class that implements org.jboss.jca.adapters.jdbc.spi.URLXASelectorStrategy |
new-connection-sql | Specifies an SQL statement to execute whenever a connection is added to the connection pool |
transaction-isolation | Set java.sql.Connection transaction isolation level to use. The constants defined by transaction-isolation-values are the possible transaction isolation levels and include: TRANSACTION_READ_UNCOMMITTED TRANSACTION_READ_COMMITTED TRANSACTION_REPEATABLE_READ TRANSACTION_SERIALIZABLE TRANSACTION_NONE |
xa-pool | Specifies the pooling settings |
security | Specifies the security settings |
validation | Specifies the validation settings |
timeout | Specifies the time out settings |
statement | Specifies the statement settings |
recovery | Specifies the recovery settings |
Table 5.16. Pool settings
Element | Desciption |
---|---|
min-pool-size | The min-pool-size element indicates the minimum number of connections a pool should hold. These are not created until a Subject is known from a request for a connection. This default to 0 |
initial-pool-size | The initial-pool-size element indicates the initial number of connections a pool should hold. These are not created until a Subject is known from a request for a connection. This default to 0 (1.2) |
max-pool-size | The max-pool-size element indicates the maximum number of connections for a pool. No more connections will be created in each sub-pool. This defaults to 20 |
prefill | Whether to attempt to prefill the connection pool. Empty element denotes a true value. Default is false |
use-strict-min | Define if the min-pool-size should be considered a strictly. Default false |
flush-strategy |
Specifies how the pool should be flush in case of an error.
Valid values are: FailingConnectionOnly (default), InvalidIdleConnections (1.2),
IdleConnections , Gracefully (1.2), EntirePool ,
AllInvalidIdleConnections (1.2), AllIdleConnections (1.2),
AllGracefully (1.2), AllConnections (1.2)
|
allow-multiple-users | Specifies if multiple users will access the datasource through the getConnection(user, password) method and hence if the internal pool type should account for that (1.1) |
capacity | Specifies the capacity policies (1.2) |
connection-listener | An org.jboss.jca.adapters.jdbc.spi.listener.ConnectionListener that provides a possible to listen for connection activation and passivation in order to perform actions before the connection is returned to the application or returned to the pool (1.2) |
Table 5.17. XA pool settings
Element | Desciption |
---|---|
min-pool-size | The min-pool-size element indicates the minimum number of connections a pool should hold. These are not created until a Subject is known from a request for a connection. This default to 0 |
initial-pool-size | The initial-pool-size element indicates the initial number of connections a pool should hold. These are not created until a Subject is known from a request for a connection. This default to 0 (1.2) |
max-pool-size | The max-pool-size element indicates the maximum number of connections for a pool. No more connections will be created in each sub-pool. This defaults to 20 |
prefill | Whether to attempt to prefill the connection pool. Empty element denotes a true value. Default is false |
use-strict-min | Define if the min-pool-size should be considered a strictly. Default false |
flush-strategy |
Specifies how the pool should be flush in case of an error.
Valid values are: FailingConnectionOnly (default), InvalidIdleConnections (1.2),
IdleConnections , Gracefully (1.2), EntirePool ,
AllInvalidIdleConnections (1.2), AllIdleConnections (1.2),
AllGracefully (1.2), AllConnections (1.2)
|
allow-multiple-users | Specifies if multiple users will access the datasource through the getConnection(user, password) method and hence if the internal pool type should account for that (1.1) |
capacity | Specifies the capacity policies (1.2) |
connection-listener | An org.jboss.jca.adapters.jdbc.spi.listener.ConnectionListener that provides a possible to listen for connection activation and passivation in order to perform actions before the connection is returned to the application or returned to the pool (1.2) |
is-same-rm-override | The is-same-rm-override element allows one to unconditionally set whether the javax.transaction.xa.XAResource.isSameRM(XAResource) returns true or false |
interleaving | An element to enable interleaving for XA connection factories |
no-tx-separate-pools | Oracle does not like XA connections getting used both inside and outside a JTA transaction. To workaround the problem you can create separate sub-pools for the different contexts |
pad-xid | Should the Xid be padded |
wrap-xa-resource | Should the XAResource instances be wrapped in an org.jboss.jca.core.spi.transaction.xa.XAResourceWrapper instance |
Table 5.18. Security settings
Element | Desciption |
---|---|
user-name | Specify the username used when creating a new connection. |
password | Specify the password used when creating a new connection. |
security-domain | Indicates Subject (from security domain) are used to distinguish connections in the pool. The content of the security-domain is the name of the JAAS security manager that will handle authentication. This name correlates to the JAAS login-config.xml descriptor application-policy/name attribute. |
reauth-plugin | Defines a reauthentication plugin that can be used for reauthentication of physical connections. |
Table 5.19. Validation settings
Element | Desciption |
---|---|
valid-connection-checker | An org.jboss.jca.adapters.jdbc.spi.ValidConnectionChecker that provides a SQLException isValidConnection(Connection e) method to validate is a connection is valid. An exception means the connection is destroyed. This overrides the check-valid-connection-sql when present |
check-valid-connection-sql | Specify an SQL statement to check validity of a pool connection. This may be called when managed connection is taken from pool for use. |
validate-on-match | The validate-on-match element indicates whether or not connection level validation should be done when a connection factory attempts to match a managed connection for a given set. This is typically exclusive to the use of background validation |
background-validation | An element to specify that connections should be validated on a background thread versus being validated prior to use |
background-validation-millis | The background-validation-millis element specifies the amount of time, in milliseconds, that background validation will run |
use-fast-fail | Whether fail a connection allocation on the first connection if it is invalid (true) or keep trying until the pool is exhausted of all potential connections (false) default false |
stale-connection-checker | An org.jboss.jca.adapters.jdbc.spi.StaleConnectionChecker that provides a boolean isStaleConnection(SQLException e) method which if it it returns true will wrap the exception in an org.jboss.jca.adapters.jdbc.StaleConnectionException which is a subclass of SQLException |
exception-sorter | An org.jboss.jca.adapters.jdbc.spi.ExceptionSorter that provides a boolean isExceptionFatal(SQLException e) method to validate is an exception should be broadcast to all javax.resource.spi.ConnectionEventListener as a connectionErrorOccurred message |
Table 5.20. Time out settings
Element | Desciption |
---|---|
blocking-timeout-millis | The blocking-timeout-millis element indicates the maximum time in milliseconds to block while waiting for a connection before throwing an exception. Note that this blocks only while waiting for a permit for a connection, and will never throw an exception if creating a new connection takes an inordinately long time. The default is 30000 (30 seconds). |
idle-timeout-minutes | The idle-timeout-minutes elements indicates the maximum time in minutes a connection may be idle before being closed. The actual maximum time depends also on the IdleRemover scan time, which is 1/2 the smallest idle-timeout-minutes of any pool. |
set-tx-query-timeout | Whether to set the query timeout based on the time remaining until transaction timeout, any configured query timeout will be used if there is no transaction. The default is false |
query-timeout | Any configured query timeout in seconds The default is no timeout |
use-try-lock | Any configured timeout for internal locks on the resource adapter objects in seconds The default is a 60 second timeout |
allocation-retry | The allocation retry element indicates the number of times that allocating a connection should be tried before throwing an exception. The default is 0. |
allocation-retry-wait-millis | The allocation retry wait millis element indicates the time in milliseconds to wait between retrying to allocate a connection. The default is 5000 (5 seconds). |
xa-resource-timeout | Passed to XAResource.setTransactionTimeout() Default is zero which does not invoke the setter. In seconds |
Table 5.21. Statement settings
Element | Desciption |
---|---|
track-statements |
Whether to check for unclosed statements when a connection is returned
to the pool and result sets are closed when a statement is closed/return
to the prepared statement cache. valid values are: false - do not track statements
and results; true - track statements and result sets and warn when they are
not closed; nowarn - track statements but do no warn about them being unclosed
(the default)
|
prepared-statement-cache-size | The number of prepared statements per connection in an LRU cache |
share-prepared-statements | Whether to share prepare statements, i.e. whether asking for same statement twice without closing uses the same underlying prepared statement. The default is false |
Table 5.22. Recovery elements
Element | Desciption |
---|---|
recover-credential | Specifies the user name / password pair or security domain that should be used for recovery. |
recover-plugin | Specifies an implementation of the org.jboss.jca.core.spi.recovery.RecoveryPlugin class. |
Table 5.23. Driver attributes
Attribute | Desciption |
---|---|
name | An unique name for the JDBC driver |
module |
The module definition for the JDBC driver. The format of a module inside
WildFly 8+ is The format for IronJacamar Standalone/Embedded is the name of the .jar file |
major-version | The major version of the driver |
minor-version | The minor version of the driver |
Table 5.24. Driver elements
Element | Desciption |
---|---|
driver-class | The fully qualified class name of the driver class |
datasource-class | The fully qualified class name of the datasource class |
xa-datasource-class | The fully qualified class name of the XA datasource class |
The datasource deployment schema is defined in doc/datasources_1_0.xsd
and doc/datasources_1_1.xsd
.
The datasource deployments can make use of a couple of extensions in the JDBC resource adapter to improve the connection validation and checking if an exception should reestablish the connection in question.
The extensions include
org.jboss.jca.adapters.jdbc.spi.ExceptionSorter
: Plugin to check if a
SQLException
is fatal for the connection on which it was thrown.
org.jboss.jca.adapters.jdbc.spi.StaleConnection
: Plugin to wrap stale
SQLException
's in a org.jboss.jca.adapters.jdbc.StaleConnectionException
.
org.jboss.jca.adapters.jdbc.spi.ValidConnection
: Plugin to Check if a connection is
valid for use by the application.
Configuration of the extensions are done by using
<exception-sorter>
tag for an ExceptionSorter
<stale-connection-checker>
tag for a StaleConnection
<valid-connection-checker>
tag for a ValidConnection
IronJacamar features implementations of these extensions for a couple of popular databases. Contributions in this area are most welcome either generic solutions or for a specific database.
Informix:
org.jboss.jca.adapters.jdbc.extensions.informix.InformixExceptionSorter
Microsoft SQLServer:
org.jboss.jca.adapters.jdbc.extensions.mssql.MSSQLValidConnectionChecker
PostgreSQL:
org.jboss.jca.adapters.jdbc.extensions.postgres.PostgreSQLExceptionSorter
org.jboss.jca.adapters.jdbc.extensions.postgres.PostgreSQLValidConnectionChecker
MySQL:
org.jboss.jca.adapters.jdbc.extensions.mysql.MySQLExceptionSorter
org.jboss.jca.adapters.jdbc.extensions.mysql.MySQLReplicationValidConnectionChecker
org.jboss.jca.adapters.jdbc.extensions.mysql.MySQLValidConnectionChecker
IBM DB2:
org.jboss.jca.adapters.jdbc.extensions.db2.DB2ExceptionSorter
org.jboss.jca.adapters.jdbc.extensions.db2.DB2StaleConnectionChecker
org.jboss.jca.adapters.jdbc.extensions.db2.DB2ValidConnectionChecker
Generic:
org.jboss.jca.adapters.jdbc.extensions.novendor.NullExceptionSorter
org.jboss.jca.adapters.jdbc.extensions.novendor.NullStaleConnectionChecker
org.jboss.jca.adapters.jdbc.extensions.novendor.NullValidConnectionChecker
org.jboss.jca.adapters.jdbc.extensions.novendor.JDBC4ValidConnectionChecker
Sybase:
org.jboss.jca.adapters.jdbc.extensions.sybase.SybaseExceptionSorter
org.jboss.jca.adapters.jdbc.extensions.sybase.SybaseValidConnectionChecker
Oracle:
org.jboss.jca.adapters.jdbc.extensions.oracle.OracleExceptionSorter
org.jboss.jca.adapters.jdbc.extensions.oracle.OracleStaleConnectionChecker
org.jboss.jca.adapters.jdbc.extensions.oracle.OracleValidConnectionChecker
Datasources has the following core statistics values
Table 5.25. Core statistics
Name | Desciption |
---|---|
ActiveCount | The number of active connections. Each of the connections is either in use by an application or available in the pool |
AvailableCount | The number of available connections in the pool |
AverageBlockingTime | The average time spent blocking on obtaining an exclusive lock on the pool. The value is in milliseconds |
AverageCreationTime | The average time spent creating a connection. The value is in milliseconds |
AverageGetTime | The average time spent obtaining a connection. The value is in milliseconds |
BlockingFailureCount | The number of times where there was a time out getting an exclusive lock on the pool |
CreatedCount | The number of connections created |
DestroyedCount | The number of connections destroyed |
IdleCount | The number of connections currently idle |
InUseCount | The number of connections currently in use |
MaxCreationTime | The maximum time it took to create a connection. The value is in milliseconds |
MaxGetTime | The maximum time it took to obtain a connection. The value is in milliseconds |
MaxUsedCount | The maximum number of connections used |
MaxWaitCount | The maximum number of requests waiting for a connection at the same time |
MaxWaitTime | The maximum time spent waiting for an exclusive lock on the pool |
TimedOut | The number of timed out connections |
TotalBlockingTime | The total time spent waiting for an exclusive lock on the pool. The value is in milliseconds |
TotalCreationTime | The total time spent creating connections. The value is in milliseconds |
TotalGetTime | The total time spent obtaining connections. The value is in milliseconds |
WaitCount | The number of requests that had to wait for a connection |
Datasources has the following JDBC statistics values
Table 5.26. JDBC statistics
Name | Desciption |
---|---|
PreparedStatementCacheAccessCount | The number of times that the statement cache was accessed |
PreparedStatementCacheAddCount | The number of statements added to the statement cache |
PreparedStatementCacheCurrentSize | The number of prepared and callable statements currently cached in the statement cache |
PreparedStatementCacheDeleteCount | The number of statements discarded from the cache |
PreparedStatementCacheHitCount | The number of times that statements from the cache were used |
PreparedStatementCacheMissCount | The number of times that a statement request could not be satisfied with a statement from the cache |
This section will provide an overview of general deployment settings that are shared between resource adapter activations, and datasource deployments.
The flush strategy option for the connection pool defines how the pool should be flushed in case there is an error on a connection belonging to the pool.
In all cases the connection with the error is destroyed, and the pool is scheduled for prefill if supported.
Table 5.27. Flush strategies
Name | Desciption |
---|---|
FailingConnectionOnly | Only the connection with the error is destroyed. This is the default strategy. |
InvalidIdleConnections |
All idle connections are checked if they are invalid, based on the
javax.resource.spi.ValidatingManagedConnectionFactory
return value.
|
IdleConnections | All idle connections are destroyed. |
Gracefully | All idle connections are destroyed, and all active connections will be destroyed upon return to the pool. |
EntirePool | All connections are destroyed, including current active connections. |
AllInvalidIdleConnections |
Like InvalidIdleConnections , but across
all credentials for the pool if supported.
|
AllIdleConnections |
Like IdleConnections , but across
all credentials for the pool if supported.
|
AllGracefully |
Like Gracefully , but across
all credentials for the pool if supported.
|
AllConnections |
Like EntirePool , but across
all credentials for the pool if supported.
|
The policy for creating and destroying physical connections for a pool can be controlled by specifying which policy that should be used.
The default policies are only to create one connection per request, and to destroy all connections timed out when the idle timeout is scheduled.
The following increment policies are supported.
The org.jboss.jca.core.connectionmanager.pool.capacity.MaxPoolSizeIncrementer
policy
will fill the pool to its max size for each request.
This policy is useful when you want to keep the maximum number of connections available all the time.
The org.jboss.jca.core.connectionmanager.pool.capacity.SizeIncrementer
policy
will fill the pool by the specified number of connections for each request.
Table 5.28. Size policy properties
Name | Desciption |
---|---|
Size | The number of connections that should be created |
This policy is useful when you want to increment with an additional number of connections per request in anticipation that the next request will also need a connection.
This is the default increment policy with a value of 1.
The org.jboss.jca.core.connectionmanager.pool.capacity.WatermarkIncrementer
policy
will fill the pool to the specified number of connections for each request.
Table 5.29. Watermark policy properties
Name | Desciption |
---|---|
Watermark | The watermark level for the number of connections |
This policy is useful when you want to keep a specified number of connections in the pool at all time.
The following decrement policies are supported.
The org.jboss.jca.core.connectionmanager.pool.capacity.MinPoolSizeDecrementer
policy
will decrement the pool to its min size for each request.
This policy is useful when you want to limit the number of connections after each idle timeout request.
The org.jboss.jca.core.connectionmanager.pool.capacity.SizeDecrementer
policy
will decrement the pool by the specified number of connections for each idle timeout request.
Table 5.30. Size policy properties
Name | Desciption |
---|---|
Size | The number of connections that should be created |
This policy is useful when you want to decrement an additional number of connections per idle timeout request in anticipation that the pool usage will lower over time.
The org.jboss.jca.core.connectionmanager.pool.capacity.TimedOutDecrementer
policy
will removed all connections that have timed out from the pool for each idle timeout request.
This policy is the default decrement policy.
The org.jboss.jca.core.connectionmanager.pool.capacity.WatermarkDecrementer
policy
will decrement the pool to the specified number of connections for each idle timeout request.
Table 5.31. Watermark policy properties
Name | Desciption |
---|---|
Watermark | The watermark level for the number of connections |
This policy is useful when you want to keep a specified number of connections in the pool at all time.
Table of Contents
The IronJacamar container is started by entering the bin/ directory
cd ironjacamar-1.1.0.Final/bin
and executing
./run.sh
on a Un*x based system or
run.bat
on Windows.
The command takes an optional -b argument to define the binding address of the naming server
./run.sh -b 192.168.0.199
Once the container has started you should see a log entry like
13:33:10,999 INFO [Main] Server started in 941ms
in the console where the command was executed.
After the container has started you can browse to
http://localhost:8080
to view the project documentation and use the administration console.
The IronJacamar container is stopped by pressing the Ctrl-C
keys.
Once the container has stopped you should see a log entry like
13:35:06,752 INFO [Main] Server stopped in 29ms
in the console where the container was running.
Alternative the container can be stopped through the command line interface.
The IronJacamar container can be controlled by a command line interface.
If you are accessing a remote container you can use the -h
option to
specify the host name.
You can deploy a resource adapter archive (.rar) using
java -jar fungal-cli.jar deploy <file>
where file
specifies the resource adapter archive.
You can undeploy a resource adapter archive (.rar) using
java -jar fungal-cli.jar undeploy <file>
where file
specifies the resource adapter archive.
The IronJacamar container can be controlled by Apache Ant tasks.
The IronJacamar container can be started by the Apache Ant task org.jboss.jca.sjc.ant.Start
which takes a
home
attribute to specify the home directory of the installation.
The IronJacamar container can be stopped by the Apache Ant task org.jboss.jca.sjc.ant.Stop
which takes a
home
attribute to specify the home directory of the installation.
Deployments to the IronJacamar container can be done by the Apache Ant task org.jboss.jca.sjc.ant.Deploy
which takes a
file
attribute to specify the file that should be deployed. The task takes optional host
and port
attributes in order to specify the host and port where the IronJacamar container is located.
Undeploying from the IronJacamar container can be done by the Apache Ant task org.jboss.jca.sjc.ant.Undeploy
which takes a
file
attribute to specify the file that should be undeployed. The task takes optional host
and port
attributes in order to specify the host and port where the IronJacamar container is located.
The IronJacamar container can be controlled by Apache Maven mojos.
The IronJacamar container can be started by the Apache Maven mojo org.jboss.jca.sjc.maven.Start
which takes a
home
element to specify the home directory of the installation.
The IronJacamar container can be stopped by the Apache Maven mojo org.jboss.jca.sjc.maven.Stop
which takes a
home
element to specify the home directory of the installation.
Deployments to the IronJacamar container can be done by the Apache Maven mojo org.jboss.jca.sjc.maven.Deploy
which takes a
file
element to specify the file that should be deployed. The mojo takes optional host
and port
elements in order to specify the host and port where the IronJacamar container is located.
Undeploying from the IronJacamar container can be done by the Apache Maven mojo org.jboss.jca.sjc.maven.Undeploy
which takes a
file
element to specify the file that should be undeployed. The mojo takes optional host
and port
elements in order to specify the host and port where the IronJacamar container is located.
Table of Contents
The IronJacamar container features a validator which checks resource adapter archives against the Java Connector Architecture (JCA) specification.
The validator is doing a static analysis of the resource adapter classes and checks them against the rules defined in the validator.
The validator is used in the deployer chain of the JCA container, and is available as a standalone tool, as an Apache Ant task and as a Apache Maven plugin too.
The validator works by scanning the resource adapter in question and output a report which lists which rules have been violated.
An example could be
Severity: ERROR Section: 19.4.2 Description: A ResourceAdapter must implement a "public int hashCode()" method. Code: com.mycompany.myproject.ResourceAdapterImpl Severity: ERROR Section: 19.4.2 Description: A ResourceAdapter must implement a "public boolean equals(Object)" method. Code: com.mycompany.myproject.ResourceAdapterImpl
which means that com.mycompany.myproject.ResourceAdapterImpl
is missing
an equals
and hashCode
implementation.
Table 7.1. Validator report
Key | Desciption |
---|---|
Severity |
Specifies the severity of the rule.
|
Section | A reference to a section in the Java Connector Architecture specification where the requirement is defined. |
Descrption | A short description of the rule. |
Code | The class which triggered the rule. |
The validator can be run on the command line by
cd doc/validator ./validator.sh <file>
The reports will be generated into the current directory under the name of
<file>.log
.
The validator integrates with Apache Ant such that you can generate the reports directly from your build environment before deploying the resoruce adapter into the IronJacamar container.
First you have to define the taskdef
for the task
<taskdef name="validator" classname="org.jboss.jca.validator.ant.ValidatorTask" classpathref="ironjacamar.lib.path.id"/>
See the Apache Ant documentation for additional instructions on installation.
The validator integrates with Apache Maven such that you can generate the reports directly from your build environment before deploying the resoruce adapter into the IronJacamar container.
To be able to use the validator plugin in your Maven project, you will have to add the following plugin declaration in the pom.xml of your project:
<build>
<plugins>
<plugin>
<groupId>org.jboss.ironjacamar</groupId>
<artifactId>ironjacamar-validator-maven</artifactId>
<!-- The version of the plugin you want to use -->
<version>1.1.0.Final</version>
<executions>
<execution>
<goals>
<goal>validate</goal>
</goals>
</execution>
</executions>
<configuration>
<!-- output directory-->
<outputDir>.</outputDir>
<!-- rar filename -->
<rarFile>/path/to/myresourceadapter.rar</rarFile>
<!-- optional classpath
<classpath>
<param>classpath1</param>
<param>classpath2</param>
</classpath>
-->
</configuration>
</plugin>
</plugins>
</build>
See the Apache Maven documentation for additional instructions on installation.
Once you have configured your project's pom.xml to include the validator-maven plugin, as explained earlier, you can generate the report by running the package goal on your project.
mvn clean package
Table 7.3. Apache Maven: validator
Key | Value |
---|---|
rarFile | The resource adapter file |
outputDir | The directory where the reports should be generated |
classpath | A classpath to resolve additional dependencies against |
Table of Contents
The IronJacamar project includes a resource adapter code generator which can generate a complete code skeleton that will help developers get started with their development tasks.
The code generator will generate a resource adapter code skeleton based on the user input. The code generator supports
The code generator can be run on the command line by
./codegenerator.sh
from the doc/codegenerator
directory.
The code generator supports the following arguments
Table 8.1. Code generator arguments
Argument | Desciption |
---|---|
-o | Specifies the output directory for the code skeleton. |
The developer must then answer various questions regarding the properties of the resource adapter.
This section describes the questions that are asked in order to generate the code.
Table 8.2. Developer input
Question | Spec | Desciption | Type |
---|---|---|---|
Profile version (1.7/1.6/1.5/1.0) | All | Defines which Java EE Connector Architecture specification that the resource adapter should target | |
Type (O/Outbound/I/Inbound/B/Bidirectional) | JCA 1.5+ | Defines if the resource adapter should contain outbound communication., inbound communication or both | |
Package name | All | The package name of the resource adapter | |
Transaction support (N/NoTransaction/L/LocalTransaction/X/XATransaction) | All | The transaction support level | |
Reauthentication (Y/Yes/N/No) | All | If the resource adapter supports reauthentication | |
Use annotations (Y/Yes/N/No) | JCA 1.6+ |
Should annotations be used for specifying the structure. If 'No' is selected a META-INF/ra.xml
is generated
| |
Include a ResourceAdapter (Y/Yes/N/No) | JCA 1.5+ | Should an instance of a resource adapter class be included in the archive | Outbound |
Resource adapter class name | JCA 1.5+ | The class name of the resource adapter | Outbound or Bidirectional |
Should the resource adapter class be Serializable (Y/Yes/N/No) | JCA 1.5+ | Should the resource adapter class be serializable | Outbound |
Managed connection factory class name | All | The class name of the managed connection factory | Outbound or Bidirectional |
Managed connection class name | All | The class name of the managed connection | Outbound or Bidirectional |
Connection interface class name | All | The class name of the connection interface | Outbound or Bidirectional |
Connection implementation class name | All | The class name of the connection implementation | Outbound or Bidirectional |
Connection factory interface class name | All | The class name of the connection factory interface | Outbound or Bidirectional |
Connection factory implementation class name | All | The class name of the connection factory implementation | Outbound or Bidirectional |
Resource adapter config properties | All | Include a configuration properties in the resource adapter instance | Outbound or Bidirectional |
Managed connection factory config properties | All | Include a configuration properties in the managed connection factory instance | Outbound or Bidirectional |
Use ResourceAdapterAssociation (Y/Yes/N/No) | All | Associate the managed connection factory instance with the resource adapter instance | Outbound or Bidirectional |
Use CCI (Y/Yes/N/No) | All | Use the Common Client Interface for the connection / connection factory in the 'Outbound' part of the resource adapter | Outbound or Bidirectional |
MessageListener interface name | JCA 1.5+ | The name of the message listener interface for the activation | Inbound or Bidirectional |
ActivationSpec class name | JCA 1.5+ | The class name of the activation specification instance | Inbound or Bidirectional |
ActivationSpec config properties | JCA 1.5+ | Include configuration properties in the activation specification instance | Inbound or Bidirectional |
Activation class name | JCA 1.5+ | The class name of the activation instance | Inbound or Bidirectional |
Add methods to connection interface (Y/Yes/N/No) [N]: | All | Use for add methods to connection interface | Outbound or Bidirectional |
Include an admin object (Y/Yes/N/No) | JCA 1.5+ | Should an admin object be added to the project | |
Use ResourceAdapterAssociation on admin object(Y/Yes/N/No) | JCA 1.5 | Associate the admin object instance with the resource adapter instance | |
Admin object interface name | JCA 1.5+ | The interface name of the admin object | |
Admin object class name | JCA 1.5+ | The class name of the admin object | |
Admin object config properties | JCA 1.5 | Include a configuration properties in the admin object instance | |
Generate a MBean class (Y/Yes/N/No) | All | Generate a MBean for the resource adapter | |
Integrate EIS test server (Y/Yes/N/No) | All | Should the IronJacamar test EIS server be integrated | |
Use JBoss Logging (Y/Yes/N/No) [N]: | All | Use JBoss Logging instead of Java Util Logging | |
Build environment [A/Ant/I/Ant+Ivy/M/Maven/G/Gradle] | All | Type of build environment |
The generated code will consist of the classes making up the resource adapter and a test suite environment based on the embedded distribution.
The following targets are supported in the Apache Ant build environment
Table 8.3. Apache Ant build environment
Target | Desciption |
---|---|
compile | Compiles all the files |
rar | Builds the resource adapter archive |
prepare-test | Prepares the test environment |
test | Executes the tests |
docs | Generates the documentation |
The following targets are supported in the Apache Ant + Ivy build environment
Table 8.4. Apache Ant + Ivy build environment
Target | Desciption |
---|---|
compile | Compiles all the files |
rar | Builds the resource adapter archive |
prepare-test | Prepares the test environment |
test | Executes the tests |
docs | Generates the documentation |
Table of Contents
The IronJacamar Eclipse plugin features development tools used for developing resource adapter applications for the IronJacamar standalone distribution, WildFly or JBoss Enterprise Application Platform 6+.
The plugin allows you to
The plugin is installed by
cp ironjacamar-eclipse.jar $ECLIPSE_HOME/plugins
on Un*x systems, or by
copy ironjacamar-eclipse.jar %ECLIPSE_HOME%\plugins
on Windows.
Open "Window->Preferences" and select the IronJacamar category.
The IronJacamar home setting must point to the root directory of the IronJacamar installation, like
/opt/ironjacamar-1.1.0.Beta1
in order to configure the plugin.
The IronJacamar Eclipse plugin can deploy to a remote IronJacamar instance, by specifying the host and port settings.
The IronJacamar Eclipse plugin provides a menu with validation and deployment functionality.
A new IronJacamar project can be created by selecting File->New->Project... and go to the IronJacamar category.
Choose "IronJacamar 1.1 project" and follow the instructions to generate your resource adapter.
Sepcify the project name and package name for the project. You can also select the JCA specification version, the type of the resource adapter (Outbound/Inbound/Bidirectional), the transaction support level, if the resource adapter will support reauthentication and if annotations used be used for a JCA 1.6+ based resource adapter.
You can choose to include a ResourceAdapter
class if the JCA profile version is 1.5, 1.6 or 1.7
If the project is Outbound or Bidirectional then you can fill in the information for the outbound components.
If the project is Inbound or Bidirectional then you can fill in the information for the message listener and activation specification components.
This wizard will let you choose the build environment to use for your project. Currently IronJacamar supports the Apache Ant, Apache Ant + Apache Ivy or Maven build environments. If Apache Ant is selected, all library files will be copied from your IronJacamar installation.
Please make sure you have installed the Eclipse M2E plugin if you select Apache Maven as your build environment.
The IronJacamar project can be validated by selecting it, and the Validate command in the toolbar will now be enabled. Click on the command to validate your project.
Another way to validate the IronJacamar project is to right click on the project, and select IronJacamar->Validate.
The IronJacamar Eclipse plugin provides a way to deploy files to an IronJacamar server.
Before any deploy operation, the IronJacamar server needs to be started, otherwise it will lead to an error dialog. Please refer to this for detail on how to start the IronJacamar server
Select the IronJacamar project you just created. The Deploy drop down command in the toolbar will be enabled. Click on the command and select 'Deploy rar'.
Another way to deploy the RAR file is to right click on the project, and select IronJacamar->Deploy->Deploy rar from context menu
The command will build the RAR file first if it doesn't exist, then try to connect the IronJacamar server to deploy it.
Select the IronJacamar project you just created. The Deploy drop down command in the toolbar will be enabled. Click on the command and select 'Deploy -ra.xml'.
Another way to generate the -ra.xml file is to right click on the project, and select IronJacamar->Deploy->Deploy -ra.xml from context menu.
The command will build the RAR file first if it does not exist, then pop up a wizard to generate the -ra.xml according to the RAR file.
There is a wizard page for each ManagedConnectionFactory if the resource adapter is outbound or bidirectional.
The ManagedConnectionFactory can be activated by selecting the 'Activate' checkbox.
There is a wizard page for each AdminObject if the resource adapter includes one or more instances.
The AdminObject can be activated by selecting the 'Activate' checkbox.
There is a miscellaneous page also.
If the Deploy RAR first option is selected, the plugin will try to deploy the RAR file to the IronJacamar server first, then deploy the generated -ra.xml file.
Table of Contents
The IronJacamar distribution features a resource adapter information tool, that can provide the important information about the resource adapter and a sample deployment descriptor.
The information about the resource adapter is generated using the following command:
./rar-info.sh myeis.rar
where the report will be located in myeis-report.txt
. The tool can take an optional
-classpath
parameter such that additional external dependencies can be resolved against
the resource adapter.
The report will contain information about
MANIFEST.MF
file
The tool (rar-info.sh
) is located in the doc/as/
directory of the
distribution.
The IronJacamar distribution features a migration tool, that can convert the deployment format used in JBoss Application Server prior to version 7, and JBoss Enterprise Application Platform versions prior to version 6.
Since there are different formats (XSDs) to deploy datasources and a resource adapters the tool can convert to both these formats.
The tool (converter.sh
) is located in the doc/as/
directory of the
distribution.
A resource adapter deployment is converted using the following command:
./converter.sh -ra old-ds.xml new-ra.xml
which will convert the file old-ds.xml
to new-ra.xml
. The content of
new-ra.xml
can then be copied into the resource-adapters
subsystem
in WildFly or used directly in the IronJacamar/Standalone distribution.
The resource adapter converter tool can also convert the Oracle WebLogic weblogic-ra.xml
files
to the IronJacamar format.
The following command line can be used:
./converter.sh -ra --weblogic weblogic-ra.xml new-ra.xml
to get a best effort convertion of the Oracle WebLogic deployment file.
A data source deployment is converted using the following command:
./converter.sh -ds old-ds.xml new-ds.xml
which will convert the file old-ds.xml
to new-ds.xml
. The content of
new-ds.xml
can then be copied into the datasources
subsystem
in WildFly or used directly in the IronJacamar/Standalone distribution.
Table of Contents
The IronJacamar embedded configuration provides a way of running a JCA container in-VM.
The configuration is useful when you want a
Especially the ability to unit test your resource adapter archives before deploying them into a testing or a production environment will benefit developers.
In order to enhance the experience with working with the embedded configuration the container integrates with the ShrinkWrap and Arquillian frameworks.
You will need all the JAR files located in the
$IRON_JACAMAR_HOME/bin $IRON_JACAMAR_HOME/lib $IRON_JACAMAR_HOME/lib/embedded
directories on your application class loader - f.ex.
java -classpath allthejarfiles.jar yourapp
in order to use the embedded configuration.
If you want integration with the Arquillian framework you need to add the JAR files located in the
$IRON_JACAMAR_HOME/lib/embedded/arquillian
directory as well.
The Arquillian/Byteman integration is located in the
$IRON_JACAMAR_HOME/lib/embedded/arquillian/byteman
directory.
Furthermore you will need to configure Java Naming and Directory Interface (JNDI) and logging using for example property files.
Sample jndi.properties
file:
java.naming.factory.initial=org.jnp.interfaces.LocalOnlyContextFactory java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces
Sample logging.properties
file:
# Additional logger names to configure (root logger is always configured) loggers=org.jboss.jca,org.jboss,org.jnp,com.arjuna # Root logger level logger.level=${iron.jacamar.log.level:INFO} logger.handlers=CONSOLE, FILE # org.jboss.jca logger.org.jboss.jca.level=DEBUG # org.jboss logger.org.jboss.level=INFO # org.jnp logger.org.jnp.level=INFO # com.arjuna logger.com.arjuna.level=INFO # Console handler configuration handler.CONSOLE=org.jboss.logmanager.handlers.ConsoleHandler handler.CONSOLE.properties=autoFlush handler.CONSOLE.level=${iron.jacamar.log.console.level:INFO} handler.CONSOLE.autoFlush=true handler.CONSOLE.formatter=PATTERN # File handler configuration handler.FILE=org.jboss.logmanager.handlers.FileHandler handler.FILE.level=${iron.jacamar.log.file.level:DEBUG} handler.FILE.properties=autoFlush,fileName handler.FILE.autoFlush=true handler.FILE.fileName=${test.dir}/embedded/test.log handler.FILE.formatter=PATTERN # Formatter pattern configuration formatter.PATTERN=org.jboss.logmanager.formatters.PatternFormatter formatter.PATTERN.properties=pattern formatter.PATTERN.pattern=%d{HH:mm:ss,SSS} %-5p [%c{1}] %m%n
These files needs to be available to the application classloader.
The IronJacamar code generator will generate a test suite based on the Arquillian functionality, so that setup can be used as a starting point for your own integration.
The setup will also show you how to use dependencies from the JBoss Nexus Maven repository instead if you choose the Maven or Ant+Ivy based build environment.
jdbc-local.rar
for <datasource>
support, or jdbc-xa.rar
for <xa-datasource>
support. Both archives can be found in the
system/
directory.IronJacamar Embedded supports both a simple and an advanced usage model, using pre-assembled resource adapter archives (.rar) or dynamic resource adapter archives based on ShrinkWrap.
The embedded environment supports registering resource adapters and datasources in the platform
MBeanServer
by setting the system property
ironjacamar.embedded.management
to true
before starting the environment.
The IronJacamar Embedded container environment supports the following open source testing projects:
These extensions allow the developer to use the embedded platform with greater ease as there doesn't have to be a physical representation of the resource adapter archive located to the disk.
The Arquillian integration furthermore allows the developer to leave all the embedded container setup to the integration layer instead.
See the Arquillian and ShrinkWrap web sites for a detailed description of the projects and additional documentation.
The code sample below shows an usage of deploying a ShrinkWrap resource adapter archive into the IronJacamar Embedded environment using Arquillian.
/*
* IronJacamar, a Java EE Connector Architecture implementation
* Copyright 2012, Red Hat Inc, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.jca.arquillian.unit;
import org.jboss.jca.arquillian.embedded.Configuration;
import org.jboss.jca.arquillian.rars.simple.TestConnection;
import org.jboss.jca.arquillian.rars.simple.TestConnectionFactory;
import java.util.UUID;
import javax.annotation.Resource;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.logging.Logger;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.jboss.shrinkwrap.api.spec.ResourceAdapterArchive;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.assertNotNull;
/**
* Unit test for Arquillian integration
*
* @author <a href="mailto:jesper.pedersen@ironjacamar.org">Jesper Pedersen</a>
*/
@RunWith(Arquillian.class)
@Configuration(autoActivate = true)
public class ArquillianTestCase
{
// --------------------------------------------------------------------------------||
// Class Members ------------------------------------------------------------------||
// --------------------------------------------------------------------------------||
private static Logger log = Logger.getLogger(ArquillianTestCase.class);
private static String deploymentName = "ArquillianTest";
/**
* Define the deployment
* @return The deployment archive
*/
@Deployment
public static ResourceAdapterArchive createDeployment()
{
ResourceAdapterArchive raa =
ShrinkWrap.create(ResourceAdapterArchive.class, deploymentName + ".rar");
JavaArchive ja = ShrinkWrap.create(JavaArchive.class, UUID.randomUUID().toString() + ".jar");
ja.addPackage(TestConnection.class.getPackage());
raa.addAsLibrary(ja);
raa.addAsManifestResource("simple.rar/META-INF/ra.xml", "ra.xml");
return raa;
}
//-------------------------------------------------------------------------------------||
// Tests ------------------------------------------------------------------------------||
//-------------------------------------------------------------------------------------||
@Resource(mappedName = "java:/eis/ArquillianTest")
private TestConnectionFactory connectionFactory;
/**
* Basic
* @exception Throwable Thrown if case of an error
*/
@Test
public void testBasic() throws Throwable
{
assertNotNull(connectionFactory);
TestConnection c = connectionFactory.getConnection();
assertNotNull(c);
c.callMe();
c.close();
}
}
The class makes use of the org.jboss.jca.embedded.arquillian.Configuration
annotation
in order to specify that the deployed archive should be auto activated through the RAActivator
bean.
ResourceAdapterArchive
must end with the
.rar
extension.The code sample below shows how to use Arquillian to deploy a ShrinkWrap resource adapter archive and activate the resource adapter using the ShrinkWrap/Descriptors API.
This example uses the org.jboss.jca.embedded.arquillian.Configuration
annotation
to explicit say not to auto activate the resource adapter archive.
/*
* IronJacamar, a Java EE Connector Architecture implementation
* Copyright 2012, Red Hat Inc, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.jca.embedded.unit;
import org.jboss.jca.arquillian.embedded.Configuration;
import org.jboss.jca.embedded.dsl.resourceadapters11.api.ConnectionDefinitionsType;
import org.jboss.jca.embedded.dsl.resourceadapters11.api.ResourceAdapterType;
import org.jboss.jca.embedded.dsl.resourceadapters11.api.ResourceAdaptersDescriptor;
import org.jboss.jca.embedded.rars.simple.TestConnection;
import org.jboss.jca.embedded.rars.simple.TestConnectionFactory;
import org.jboss.jca.embedded.rars.simple.TestConnectionFactoryImpl;
import org.jboss.jca.embedded.rars.simple.TestConnectionImpl;
import org.jboss.jca.embedded.rars.simple.TestManagedConnectionFactory;
import org.jboss.jca.embedded.rars.simple.TestResourceAdapter;
import java.util.UUID;
import javax.annotation.Resource;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.logging.Logger;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.asset.StringAsset;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.jboss.shrinkwrap.api.spec.ResourceAdapterArchive;
import org.jboss.shrinkwrap.descriptor.api.Descriptors;
import org.jboss.shrinkwrap.descriptor.api.connector15.ConnectorDescriptor;
import org.jboss.shrinkwrap.descriptor.api.connector15.OutboundResourceadapterType;
import org.jboss.shrinkwrap.descriptor.api.connector15.ResourceadapterType;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.assertNotNull;
/**
* Unit test for ShrinkWrap/Descriptors integration
*
* @author <a href="mailto:jesper.pedersen@ironjacamar.org">Jesper Pedersen</a>
*/
@RunWith(Arquillian.class)
@Configuration(autoActivate = false)
public class ShrinkWrapDescriptorsTestCase
{
// --------------------------------------------------------------------------------||
// Class Members ------------------------------------------------------------------||
// --------------------------------------------------------------------------------||
private static Logger log = Logger.getLogger(ShrinkWrapDescriptorsTestCase.class);
private static String deploymentName = "sd.rar";
/**
* Define the resource adapter archive
* @return The archive
*/
@Deployment(order = 1)
public static ResourceAdapterArchive createArchive()
{
ConnectorDescriptor raXml = Descriptors.create(ConnectorDescriptor.class, "ra.xml")
.version("1.5");
ResourceadapterType rt = raXml.getOrCreateResourceadapter()
.resourceadapterClass(TestResourceAdapter.class.getName());
OutboundResourceadapterType ort = rt.getOrCreateOutboundResourceadapter()
.transactionSupport("NoTransaction").reauthenticationSupport(false);
org.jboss.shrinkwrap.descriptor.api.connector15.ConnectionDefinitionType cdt =
ort.createConnectionDefinition()
.managedconnectionfactoryClass(TestManagedConnectionFactory.class.getName())
.connectionfactoryInterface(TestConnectionFactory.class.getName())
.connectionfactoryImplClass(TestConnectionFactoryImpl.class.getName())
.connectionInterface(TestConnection.class.getName())
.connectionImplClass(TestConnectionImpl.class.getName());
ResourceAdapterArchive raa =
ShrinkWrap.create(ResourceAdapterArchive.class, deploymentName);
JavaArchive ja = ShrinkWrap.create(JavaArchive.class, UUID.randomUUID().toString() + ".jar");
ja.addPackage(TestConnection.class.getPackage());
raa.addAsLibrary(ja);
raa.addAsManifestResource(new StringAsset(raXml.exportAsString()), "ra.xml");
return raa;
}
/**
* Define the deployment descriptor
* @return The descriptor
*/
@Deployment(order = 2)
public static ResourceAdaptersDescriptor createDeployment()
{
ResourceAdaptersDescriptor dashRaXml = Descriptors.create(ResourceAdaptersDescriptor.class, "sd-ra.xml");
ResourceAdapterType rt = dashRaXml.createResourceAdapter().archive(deploymentName);
ConnectionDefinitionsType cdst = rt.getOrCreateConnectionDefinitions();
org.jboss.jca.embedded.dsl.resourceadapters11.api.ConnectionDefinitionType cdt =
cdst.createConnectionDefinition()
.className(TestManagedConnectionFactory.class.getName())
.jndiName("java:/eis/TestConnectionFactory").poolName("TestConnectionFactory");
return dashRaXml;
}
//-------------------------------------------------------------------------------------||
// Tests ------------------------------------------------------------------------------||
//-------------------------------------------------------------------------------------||
@Resource(mappedName = "java:/eis/TestConnectionFactory")
private TestConnectionFactory connectionFactory;
/**
* Basic
* @exception Throwable Thrown if case of an error
*/
@Test
public void testBasic() throws Throwable
{
assertNotNull(connectionFactory);
TestConnection c = connectionFactory.getConnection();
assertNotNull(c);
c.callMe();
c.close();
}
}
The code sample below shows how to use Arquillian to deploy a ShrinkWrap resource adapter archive
and change the allocateConnection
of org.jboss.jca.core.connectionmanager.AbstractConnectionManager
to throw a ResourceException
when the method is called.
The framework used to provide this functionality is called Byteman, which allows developers to change behavior of a method to for example throw an exception. This is called fault injection and can be used to increase code coverage of your project.
/*
* IronJacamar, a Java EE Connector Architecture implementation
* Copyright 2012, Red Hat Inc, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.jca.arquillian.unit;
import org.jboss.jca.arquillian.embedded.Configuration;
import org.jboss.jca.arquillian.rars.simple.TestConnection;
import org.jboss.jca.arquillian.rars.simple.TestConnectionFactory;
import org.jboss.jca.embedded.dsl.InputStreamDescriptor;
import java.util.UUID;
import javax.annotation.Resource;
import javax.resource.ResourceException;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.extension.byteman.api.BMRule;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.logging.Logger;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.jboss.shrinkwrap.api.spec.ResourceAdapterArchive;
import org.jboss.shrinkwrap.descriptor.api.Descriptor;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.fail;
/**
* Unit test for Byteman integration
*
* @author <a href="mailto:jesper.pedersen@ironjacamar.org">Jesper Pedersen</a>
*/
@RunWith(Arquillian.class)
@Configuration(autoActivate = false)
public class BytemanBMTestCase
{
// --------------------------------------------------------------------------------||
// Class Members ------------------------------------------------------------------||
// --------------------------------------------------------------------------------||
private static Logger log = Logger.getLogger(BytemanBMTestCase.class);
/**
* Define the deployment
* @return The deployment archive
*/
@Deployment(order = 1)
public static ResourceAdapterArchive createDeployment()
{
ResourceAdapterArchive raa =
ShrinkWrap.create(ResourceAdapterArchive.class, "byteman.rar");
JavaArchive ja = ShrinkWrap.create(JavaArchive.class, UUID.randomUUID().toString() + ".jar");
ja.addPackage(TestConnection.class.getPackage());
raa.addAsLibrary(ja);
raa.addAsManifestResource("simple.rar/META-INF/ra.xml", "ra.xml");
return raa;
}
/**
* Define the activation
* @return The deployment archive
*/
@Deployment(order = 2)
public static Descriptor createDescriptor()
{
ClassLoader cl = BytemanBMTestCase.class.getClassLoader();
InputStreamDescriptor isd = new InputStreamDescriptor("byteman-ra.xml",
cl.getResourceAsStream("byteman-ra.xml"));
return isd;
}
//-------------------------------------------------------------------------------------||
// Tests ------------------------------------------------------------------------------||
//-------------------------------------------------------------------------------------||
@Resource(mappedName = "java:/eis/BytemanTest")
private TestConnectionFactory connectionFactory;
/**
* Byteman
* @exception Throwable Thrown if case of an error
*/
@Test
@BMRule(name = "Throw exception on allocateConnection",
targetClass = "org.jboss.jca.core.connectionmanager.AbstractConnectionManager",
targetMethod = "allocateConnection",
action = "throw new javax.resource.ResourceException()")
public void testByteman() throws Throwable
{
assertNotNull(connectionFactory);
TestConnection c = null;
try
{
c = connectionFactory.getConnection();
fail("Got a connection");
}
catch (ResourceException re)
{
// Ok
}
catch (Throwable t)
{
fail(t.getMessage());
throw t;
}
finally
{
if (c != null)
c.close();
}
}
}
See the Byteman web site for a detailed description of the project and additional documentation.
The Arquillian integration allows the internally used org.jboss.jca.embedded.Embedded
or
javax.naming.Context
instances to be injected into the test case using
import org.jboss.jca.embedded.Embedded;
import javax.naming.Context;
import org.jboss.arquillian.test.api.ArquillianResource;
@RunWith(Arquillian.class)
public class ResourceProviderTestCase
{
@ArquillianResource
private Embedded embedded;
@ArquillianResource
private Context context;
This will allow direct access to the APIs inside the test case.
The code sample below shows how to use Arquillian to deploy a ShrinkWrap resource adapter archive and inject the IronJacamar metadata repository into the test case such that assertions can be made.
The IronJacamar container features various components that makes up the entire Java EE Connector Architecture
container. The available list of components can be viewed in the configuration of the container or through
the management console under the Kernel
category.
/*/*
* IronJacamar, a Java EE Connector Architecture implementation
* Copyright 2011, Red Hat Inc, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.jca.arquillian.unit;
import org.jboss.jca.arquillian.embedded.Configuration;
import org.jboss.jca.arquillian.embedded.Inject;
import org.jboss.jca.arquillian.rars.simple.TestConnection;
import org.jboss.jca.arquillian.rars.simple.TestConnectionFactory;
import org.jboss.jca.core.spi.mdr.MetadataRepository;
import java.util.UUID;
import javax.annotation.Resource;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.logging.Logger;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.jboss.shrinkwrap.api.spec.ResourceAdapterArchive;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
/**
* Unit test for Arquillian integration and injecting
*
* @author <a href="mailto:jesper.pedersen@ironjacamar.org">Jesper Pedersen</a>
*/
@RunWith(Arquillian.class)
@Configuration(autoActivate = true)
public class InjectTestCase
{
// --------------------------------------------------------------------------------||
// Class Members ------------------------------------------------------------------||
// --------------------------------------------------------------------------------||
private static Logger log = Logger.getLogger(InjectTestCase.class);
/**
* Define the deployment
* @return The deployment archive
*/
@Deployment
public static ResourceAdapterArchive createDeployment()
{
ResourceAdapterArchive raa =
ShrinkWrap.create(ResourceAdapterArchive.class, "ArquillianTest.rar");
JavaArchive ja = ShrinkWrap.create(JavaArchive.class, UUID.randomUUID().toString() + ".jar");
ja.addPackage(TestConnection.class.getPackage());
raa.addAsLibrary(ja);
raa.addAsManifestResource("simple.rar/META-INF/ra.xml", "ra.xml");
return raa;
}
//-------------------------------------------------------------------------------------||
// Tests ------------------------------------------------------------------------------||
//-------------------------------------------------------------------------------------||
@Resource(mappedName = "java:/eis/ArquillianTest")
private TestConnectionFactory connectionFactory;
@Inject(name = "MDR")
private MetadataRepository mdr;
/**
* Basic
* @exception Throwable Thrown if case of an error
*/
@Test
public void testBasic() throws Throwable
{
assertNotNull(connectionFactory);
assertNotNull(mdr);
assertNotNull(mdr.getResourceAdapters());
assertTrue(mdr.getResourceAdapters().size() == 1);
}
}
The code sample below shows an advanced usage of deploying a ShrinkWrap resource adapter archive into the IronJacamar Embedded environment.
/*
* IronJacamar, a Java EE Connector Architecture implementation
* Copyright 2012, Red Hat Inc, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.jca.embedded.unit;
import org.jboss.jca.embedded.Embedded;
import org.jboss.jca.embedded.EmbeddedFactory;
import org.jboss.jca.embedded.rars.simple.TestConnection;
import org.jboss.jca.embedded.rars.simple.TestConnectionFactory;
import java.util.UUID;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import org.jboss.logging.Logger;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.jboss.shrinkwrap.api.spec.ResourceAdapterArchive;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
/**
* Test cases for deploying resource adapter archives (.RAR)
* using ShrinkWrap
*
* @author <a href="mailto:jesper.pedersen@ironjacamar.org">Jesper Pedersen</a>
*/
public class ShrinkWrapTestCase
{
// --------------------------------------------------------------------------------||
// Class Members ------------------------------------------------------------------||
// --------------------------------------------------------------------------------||
private static Logger log = Logger.getLogger(ShrinkWrapTestCase.class);
private static final String JNDI_PREFIX = "java:/eis/";
/*
* Embedded
*/
private static Embedded embedded;
// --------------------------------------------------------------------------------||
// Tests --------------------------------------------------------------------------||
// --------------------------------------------------------------------------------||
/**
* Basic ShrinkWrap ResourceAdapterArchive test case
* @exception Throwable Thrown if case of an error
*/
@Test
public void testBasic() throws Throwable
{
Context context = null;
String name = UUID.randomUUID().toString();
ResourceAdapterArchive raa =
ShrinkWrap.create(ResourceAdapterArchive.class, name + ".rar");
JavaArchive ja = ShrinkWrap.create(JavaArchive.class, UUID.randomUUID().toString() + ".jar");
ja.addPackage(TestConnection.class.getPackage());
raa.addAsLibrary(ja);
raa.addAsManifestResource("simple.rar/META-INF/ra.xml", "ra.xml");
try
{
embedded.deploy(raa);
context = new InitialContext();
TestConnectionFactory tcf = (TestConnectionFactory)context.lookup(JNDI_PREFIX + name);
assertNotNull(tcf);
TestConnection tc = tcf.getConnection();
tc.callMe();
tc.close();
}
catch (Exception t)
{
log.error(t.getMessage(), t);
fail(t.getMessage());
}
finally
{
if (context != null)
{
try
{
context.close();
}
catch (NamingException ne)
{
// Ignore
}
}
embedded.undeploy(raa);
}
}
// --------------------------------------------------------------------------------||
// Lifecycle Methods --------------------------------------------------------------||
// --------------------------------------------------------------------------------||
/**
* Lifecycle start, before the suite is executed
* @throws Throwable throwable exception
*/
@BeforeClass
public static void beforeClass() throws Throwable
{
// Create and set an embedded JCA instance
embedded = EmbeddedFactory.create();
// Startup
embedded.startup();
}
/**
* Lifecycle stop, after the suite is executed
* @throws Throwable throwable exception
*/
@AfterClass
public static void afterClass() throws Throwable
{
// Shutdown embedded
embedded.shutdown();
// Set embedded to null
embedded = null;
}
}
ResourceAdapterArchive
must end with the
.rar
extension.The code sample below shows a simple usage of deploying a pre-assembled resource adapter archive into the IronJacamar Embedded environment.
import org.jboss.jca.embedded.Embedded;
import org.jboss.jca.embedded.EmbeddedFactory;
import java.net.URL;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
public class MyTestCase
{
/** Embedded */
private static Embedded embedded;
/** JNDI prefix */
private static final String JNDI_PREFIX = "java:/eis/";
/**
* Simple test to verify deployment of myresourceadapter.rar
* @throws Throwable throwable exception
*/
@Test
public void testDeployment() throws Throwable
{
URL archive = MyTestCase.class.getResource("myresourceadapter.rar");
Context context = null;
try
{
embedded.deploy(archive);
context = new InitialContext();
Object o = context.lookup(JNDI_PREFIX + "myresourceadapter");
assertNotNull(o);
}
catch (Throwable t)
{
fail(t.getMessage());
}
finally
{
embedded.undeploy(archive);
if (context != null)
{
try
{
context.close();
}
catch (NamingException ne)
{
// Ignore
}
}
}
}
@BeforeClass
public static void beforeClass() throws Throwable
{
// Create an embedded JCA instance
embedded = EmbeddedFactory.create();
// Startup
embedded.startup();
}
@AfterClass
public static void afterClass() throws Throwable
{
// Shutdown
embedded.shutdown();
}
}
.rar
extension
- either representing a file or a directory.See the IronJacamar Embedded API documentation for additional functionality.
IronJacamar features a bean called RAActivator
which will automatic
create a JNDI binding for connection factories and administration objects. However,
sometimes it is of benefit to define these bindings in a -ra.xml
file, and therefore
RAActivator
has to be disabled during that deployment phase.
This done by using the following code snippet
import org.jboss.jca.deployers.fungal.RAActivator;
// Disable RAActivator
RAActivator raa = embedded.lookup("RAActivator", RAActivator.class);
if (raa == null)
throw new IllegalStateException("RAActivator not defined");
raa.setEnabled(false);
embedded.deploy("myrar.rar");
embedded.deploy("myrar-ra.xml");
raa.setEnabled(true);
which disables the bean, does the deployments and then reenables the bean again.
Table of Contents
Testing an Enterprise Information System can be a complex task, as their installation can quite complex and specific to a certain platform architecture.
As Java developers, and resource adapter developers in particularly, we are interested in a setup that will allow us to test the resource adapter against the EIS with as little difficulty as possible.
Having access to a component that easy integrates into our testing environment, and acts as the EIS in question is of benefit.
The IronJacamar EIS test server provides a framework for emulating an Enterprise Information System such that no installation is needed.
The EIS test server contains the following interface
/*
* IronJacamar, a Java EE Connector Architecture implementation
* Copyright 2012, Red Hat Inc, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.jca.test.eis;
import java.io.InputStream;
import java.io.OutputStream;
/**
* This interface represents a session between a resource adapter
* and an Enterprise Information System
*
* Once the <code>handle</code> method returns the socket where
* the communication takes place is closed
*
* @author <a href="mailto:jesper.pedersen@ironjacamar.org">Jesper Pedersen</a>
*/
public interface Handler
{
/**
* Handle an interaction with a client
* @param is The input stream
* @param os The output stream
*/
public void handle(InputStream is, OutputStream os);
}
which represents a session between the resource adapter and the EIS.
The java.io.InputStream
is the incoming communication coming from the resource adapter, and
the java.io.OutputStream
is the EIS' response to the request.
Once the method returns the socket between the resource adapter and the EIS is closed.
This means that the implementation of the Handler
interface will represent the binary
protocol between the resource adapter and the EIS. To the resource adapter it will look as it is
communicating with the real Enterprise Information System installation.
The Apache Ant tasks for starting and stopping the EIS test server are defined as the following
<taskdef name="start" classname="org.jboss.jca.test.eis.ant.Start" classpathref="main.lib.path.id"/> <taskdef name="stop" classname="org.jboss.jca.test.eis.ant.Stop" classpathref="main.lib.path.id"/>
where main.lib.path.id
contains the ironjacamar-test-eis.jar
file.
The start
task is used, like
<start host="localhost" port="1400" handler="org.jboss.jca.test.eis.EchoHandler"> <classpath> <pathelement location="${build.eis.dir}/test"/> </classpath> </start>
which starts the EIS test server on localhost
using port 1400
with an
implementation of the Handler
interface of org.jboss.jca.test.eis.EchoHandler
and a classpath of ${build.eis.dir}/test
.
The stop
task is used, like
<stop host="localhost" port="1400"/>
which stops the EIS test server on localhost
using port 1400
.
Between the start
and stop
tasks the resource adapters unit tests
can be executed.
The Apache Maven mojos for starting and stopping the EIS test server are defined as the following
<build> <plugins> <plugin> <groupId>org.jboss.ironjacamar</groupId> <artifactId>ironjacamar-test-eis</artifactId> <!-- The version of the plugin you want to use --> <version>1.1.0.Final</version> <executions> <execution> <goals> <goal>start</goal> </goals> </execution> </executions> <configuration> <host>localhost</host> <port>1400</port> <handler>org.jboss.jca.test.eis.EchoHandler</handler> <classpath> <param>target/test-classes</param> </classpath> </configuration> </plugin> <plugin> <groupId>org.jboss.ironjacamar</groupId> <artifactId>ironjacamar-test-eis</artifactId> <!-- The version of the plugin you want to use --> <version>1.1.0.Final</version> <executions> <execution> <goals> <goal>stop</goal> </goals> </execution> </executions> <configuration> <host>localhost</host> <port>1400</port> </configuration> </plugin> </plugins> </build>
The start
mojo will run in the process-test-classes
phase, and the
stop
mojo will run in the test
phase.
The website contains the latest information about the project and links to important information.
The website is located at http://www.ironjacamar.org/
The user forum is where we discuss matters about the usage of the IronJacamar project.
Our forum is located at http://community.jboss.org/en/ironjacamar
The developer forum is where we discuss the implementation of the IronJacamar project. This means the internals of the project and not how the project is used.
User questions doesn't belong here - they should go in the user forum instead.
The forum is located at http://community.jboss.org/en/ironjacamar/dev
We are using JIRA to manage our issues in the project.
These are divided into the following categories
For all of these you should post your request to our user forum first.
The rest of the categories are for team use only.
Our issue tracking system located at http://issues.jboss.org/browse/JBJCA
Table of Contents
If you think you have found a bug you should verify this by posting to our forum first.
Our forum is located at http://community.jboss.org/en/ironjacamar
You can also search our issue tracking system located at http://issues.jboss.org/browse/JBJCA
So you have found an area where you are missing a feature and would like to submit a patch for it, great !
There are a couple of steps to get a feature included
First, you should create a new thread in our development forum where you describe the feature, its design and implementation.
Once there is an agreement on the feature and the design you should proceed with creating the patch.
To maximize your chances of getting the feature in the official build as soon as possible make sure that you run through the following steps:
ant clean test ant clean checkstyle ant clean findbugs ant clean jacoco
All these should show that,
when done, create a JIRA task (Feature Request) in our JIRA environment and attach the unified diff formatted patch. See the developer guide for additional details.
Happy Coding !
We can't cover every single issue in this guide, so feel free to drop by our forums to see if a solution has already been provided. Otherwise feel free to ask your question there.
Our forum is located at http://community.jboss.org/en/ironjacamar
Table of Contents
All the IronJacamar schemas are deployed under http://www.ironjacamar.org/schema/.
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:javaee="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
elementFormDefault="qualified"
attributeFormDefault="unqualified"
version="1.7">
<xsd:annotation>
<xsd:documentation>
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
Copyright (c) 2009-2013 Oracle and/or its affiliates. All rights reserved.
The contents of this file are subject to the terms of either the GNU
General Public License Version 2 only ("GPL") or the Common Development
and Distribution License("CDDL") (collectively, the "License"). You
may not use this file except in compliance with the License. You can
obtain a copy of the License at
https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
or packager/legal/LICENSE.txt. See the License for the specific
language governing permissions and limitations under the License.
When distributing the software, include this License Header Notice in each
file and include the License file at packager/legal/LICENSE.txt.
GPL Classpath Exception:
Oracle designates this particular file as subject to the "Classpath"
exception as provided by Oracle in the GPL Version 2 section of the License
file that accompanied this code.
Modifications:
If applicable, add the following below the License Header, with the fields
enclosed by brackets [] replaced by your own identifying information:
"Portions Copyright [year] [name of copyright owner]"
Contributor(s):
If you wish your version of this file to be governed by only the CDDL or
only the GPL Version 2, indicate your decision by adding "[Contributor]
elects to include this software in this distribution under the [CDDL or GPL
Version 2] license." If you don't indicate a single choice of license, a
recipient has the option to distribute your version of this file under
either the CDDL, the GPL Version 2 or to extend the choice of license to
its licensees as provided above. However, if you add GPL Version 2 code
and therefore, elected the GPL Version 2 license, then the option applies
only if the new code is made subject to such option by the copyright
holder.
</xsd:documentation>
</xsd:annotation>
<xsd:annotation>
<xsd:documentation>
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
Copyright 2003-2013 Sun Microsystems, Inc. All rights reserved.
The contents of this file are subject to the terms of either the
GNU General Public License Version 2 only ("GPL") or the Common
Development and Distribution License("CDDL") (collectively, the
"License"). You may not use this file except in compliance with
the License. You can obtain a copy of the License at
https://glassfish.dev.java.net/public/CDDL+GPL.html or
glassfish/bootstrap/legal/LICENSE.txt. See the License for the
specific language governing permissions and limitations under the
License.
When distributing the software, include this License Header
Notice in each file and include the License file at
glassfish/bootstrap/legal/LICENSE.txt. Sun designates this
particular file as subject to the "Classpath" exception as
provided by Sun in the GPL Version 2 section of the License file
that accompanied this code. If applicable, add the following
below the License Header, with the fields enclosed by brackets []
replaced by your own identifying information:
"Portions Copyrighted [year] [name of copyright owner]"
Contributor(s):
If you wish your version of this file to be governed by only the
CDDL or only the GPL Version 2, indicate your decision by adding
"[Contributor] elects to include this software in this
distribution under the [CDDL or GPL Version 2] license." If you
don't indicate a single choice of license, a recipient has the
option to distribute your version of this file under either the
CDDL, the GPL Version 2 or to extend the choice of license to its
licensees as provided above. However, if you add GPL Version 2
code and therefore, elected the GPL Version 2 license, then the
option applies only if the new code is made subject to such
option by the copyright holder.
</xsd:documentation>
</xsd:annotation>
<xsd:annotation>
<xsd:documentation>
<![CDATA[[
This is the XML Schema for the Connector 1.7 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 Java EE namespace:
http://xmlns.jcp.org/xml/ns/javaee
and by indicating the version of the schema by
using the version element as shown below:
<connector xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/connector_1_7.xsd"
version="1.7">
...
</connector>
The instance documents may indicate the published version of
the schema using the xsi:schemaLocation attribute for Java EE
namespace with the following location:
http://xmlns.jcp.org/xml/ns/javaee/connector_1_7.xsd
]]>
</xsd:documentation>
</xsd:annotation>
<xsd:annotation>
<xsd:documentation>
The following conventions apply to all Java 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="javaee_7.xsd"/>
<!-- **************************************************** -->
<xsd:element name="connector"
type="javaee: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="javaee: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
javax.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="javaee: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 Connectors specification for more information.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="config-property"
type="javaee: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="javaee: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>javax.jms.Destination
</adminobject-interface>
]]>
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="adminobject-class"
type="javaee: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="javaee: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
javax.resource.spi.security.PasswordCredential interface.
The Kerbv5 mechanism type should support the
org.ietf.jgss.GSSCredential interface or the deprecated
javax.resource.spi.security.GenericCredential interface.
</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element name="description"
type="javaee:descriptionType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="authentication-mechanism-type"
type="javaee: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 Connector architecture specification.
]]>
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="credential-interface"
type="javaee: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="javaee: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="javaee: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="javaee:descriptionType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="config-property-name"
type="javaee:config-property-nameType"/>
<xsd:element name="config-property-type"
type="javaee:config-property-typeType"/>
<xsd:element name="config-property-value"
type="javaee: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="javaee: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 Connector 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="javaee: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 Connector 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="javaee: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 Connector 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="javaee:fully-qualified-classType">
<xsd:annotation>
<xsd:documentation>
<![CDATA[[
The element managedconnectionfactory-class specifies
the fully qualified name of the Java class that
implements the
javax.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="javaee:config-propertyType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="connectionfactory-interface"
type="javaee: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>javax.resource.cci.ConnectionFactory
</connectionfactory-interface>
]]>
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="connectionfactory-impl-class"
type="javaee: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="javaee: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>javax.resource.cci.Connection
</connection-interface>
]]>
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="connection-impl-class"
type="javaee: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="javaee: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 (Java EE)
Specification, version 6.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:group ref="javaee:descriptionGroup"/>
<xsd:element name="vendor-name"
type="javaee: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="javaee: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="javaee: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="javaee:licenseType"
minOccurs="0"/>
<xsd:element name="resourceadapter"
type="javaee:resourceadapterType"/>
<xsd:element name="required-work-context"
type="javaee: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="javaee:dewey-versionType"
fixed="1.7"
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:
javax.resource.spi.security.PasswordCredential
org.ietf.jgss.GSSCredential
javax.resource.spi.security.GenericCredential
</xsd:documentation>
</xsd:annotation>
<xsd:simpleContent>
<xsd:restriction base="javaee:fully-qualified-classType">
<xsd:enumeration value="javax.resource.spi.security.PasswordCredential"/>
<xsd:enumeration value="org.ietf.jgss.GSSCredential"/>
<xsd:enumeration value="javax.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="javaee: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="javaee:messagelistener"/>
<xsd:field xpath="javaee: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="javaee:descriptionType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="license-required"
type="javaee: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="javaee: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="javaee: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>javax.jms.MessageListener
</messagelistener-type>
]]>
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="activationspec"
type="javaee: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 JTA 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="javaee:connection-definitionType"
maxOccurs="unbounded"
minOccurs="0"/>
<xsd:element name="transaction-support"
type="javaee:transaction-supportType"
minOccurs="0"/>
<xsd:element name="authentication-mechanism"
type="javaee:authentication-mechanismType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="reauthentication-support"
type="javaee: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="javaee:descriptionType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="config-property-name"
type="javaee: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="javaee: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 javax.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="javaee:config-propertyType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="outbound-resourceadapter"
type="javaee: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="javaee:connection-definition"/>
<xsd:field xpath="javaee:connectionfactory-interface"/>
</xsd:unique>
</xsd:element>
<xsd:element name="inbound-resourceadapter"
type="javaee:inbound-resourceadapterType"
minOccurs="0"/>
<xsd:element name="adminobject"
type="javaee: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="javaee:adminobject"/>
<xsd:field xpath="javaee:adminobject-interface"/>
<xsd:field xpath="javaee:adminobject-class"/>
</xsd:unique>
</xsd:element>
<xsd:element name="security-permission"
type="javaee: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="javaee:descriptionType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="security-permission-spec"
type="javaee: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>
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://java.sun.com/xml/ns/javaee"
xmlns:javaee="http://java.sun.com/xml/ns/javaee"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
elementFormDefault="qualified"
attributeFormDefault="unqualified"
version="1.6">
<xsd:annotation>
<xsd:documentation>
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
Copyright 2003-2009 Sun Microsystems, Inc. All rights reserved.
The contents of this file are subject to the terms of either the
GNU General Public License Version 2 only ("GPL") or the Common
Development and Distribution License("CDDL") (collectively, the
"License"). You may not use this file except in compliance with
the License. You can obtain a copy of the License at
https://glassfish.dev.java.net/public/CDDL+GPL.html or
glassfish/bootstrap/legal/LICENSE.txt. See the License for the
specific language governing permissions and limitations under the
License.
When distributing the software, include this License Header
Notice in each file and include the License file at
glassfish/bootstrap/legal/LICENSE.txt. Sun designates this
particular file as subject to the "Classpath" exception as
provided by Sun in the GPL Version 2 section of the License file
that accompanied this code. If applicable, add the following
below the License Header, with the fields enclosed by brackets []
replaced by your own identifying information:
"Portions Copyrighted [year] [name of copyright owner]"
Contributor(s):
If you wish your version of this file to be governed by only the
CDDL or only the GPL Version 2, indicate your decision by adding
"[Contributor] elects to include this software in this
distribution under the [CDDL or GPL Version 2] license." If you
don't indicate a single choice of license, a recipient has the
option to distribute your version of this file under either the
CDDL, the GPL Version 2 or to extend the choice of license to its
licensees as provided above. However, if you add GPL Version 2
code and therefore, elected the GPL Version 2 license, then the
option applies only if the new code is made subject to such
option by the copyright holder.
</xsd:documentation>
</xsd:annotation>
<xsd:annotation>
<xsd:documentation>
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
Copyright 2003-2009 Sun Microsystems, Inc. All rights reserved.
The contents of this file are subject to the terms of either the
GNU General Public License Version 2 only ("GPL") or the Common
Development and Distribution License("CDDL") (collectively, the
"License"). You may not use this file except in compliance with
the License. You can obtain a copy of the License at
https://glassfish.dev.java.net/public/CDDL+GPL.html or
glassfish/bootstrap/legal/LICENSE.txt. See the License for the
specific language governing permissions and limitations under the
License.
When distributing the software, include this License Header
Notice in each file and include the License file at
glassfish/bootstrap/legal/LICENSE.txt. Sun designates this
particular file as subject to the "Classpath" exception as
provided by Sun in the GPL Version 2 section of the License file
that accompanied this code. If applicable, add the following
below the License Header, with the fields enclosed by brackets []
replaced by your own identifying information:
"Portions Copyrighted [year] [name of copyright owner]"
Contributor(s):
If you wish your version of this file to be governed by only the
CDDL or only the GPL Version 2, indicate your decision by adding
"[Contributor] elects to include this software in this
distribution under the [CDDL or GPL Version 2] license." If you
don't indicate a single choice of license, a recipient has the
option to distribute your version of this file under either the
CDDL, the GPL Version 2 or to extend the choice of license to its
licensees as provided above. However, if you add GPL Version 2
code and therefore, elected the GPL Version 2 license, then the
option applies only if the new code is made subject to such
option by the copyright holder.
</xsd:documentation>
</xsd:annotation>
<xsd:annotation>
<xsd:documentation>
<![CDATA[[
This is the XML Schema for the Connector 1.6 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 Java EE namespace:
http://java.sun.com/xml/ns/javaee
and by indicating the version of the schema by
using the version element as shown below:
<connector xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/connector_1_6.xsd"
version="1.6">
...
</connector>
The instance documents may indicate the published version of
the schema using the xsi:schemaLocation attribute for Java EE
namespace with the following location:
http://java.sun.com/xml/ns/javaee/connector_1_6.xsd
]]>
</xsd:documentation>
</xsd:annotation>
<xsd:annotation>
<xsd:documentation>
The following conventions apply to all Java 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="javaee_6.xsd"/>
<!-- **************************************************** -->
<xsd:element name="connector"
type="javaee: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="javaee: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
javax.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="javaee: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 Connectors specification for more information.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="config-property"
type="javaee: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="javaee: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>javax.jms.Destination
</adminobject-interface>
]]>
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="adminobject-class"
type="javaee: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="javaee: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
javax.resource.spi.security.PasswordCredential interface.
The Kerbv5 mechanism type should support the
org.ietf.jgss.GSSCredential interface or the deprecated
javax.resource.spi.security.GenericCredential interface.
</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element name="description"
type="javaee:descriptionType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="authentication-mechanism-type"
type="javaee: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 Connector architecture specification.
]]>
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="credential-interface"
type="javaee: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="javaee: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="javaee: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="javaee:descriptionType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="config-property-name"
type="javaee:config-property-nameType"/>
<xsd:element name="config-property-type"
type="javaee:config-property-typeType"/>
<xsd:element name="config-property-value"
type="javaee: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="javaee: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 Connector 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="javaee: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 Connector 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="javaee: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 Connector 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="javaee:fully-qualified-classType">
<xsd:annotation>
<xsd:documentation>
<![CDATA[[
The element managedconnectionfactory-class specifies
the fully qualified name of the Java class that
implements the
javax.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="javaee:config-propertyType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="connectionfactory-interface"
type="javaee: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>javax.resource.cci.ConnectionFactory
</connectionfactory-interface>
]]>
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="connectionfactory-impl-class"
type="javaee: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="javaee: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>javax.resource.cci.Connection
</connection-interface>
]]>
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="connection-impl-class"
type="javaee: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="javaee: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 (Java EE)
Specification, version 6.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:group ref="javaee:descriptionGroup"/>
<xsd:element name="vendor-name"
type="javaee: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="javaee: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="javaee: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="javaee:licenseType"
minOccurs="0"/>
<xsd:element name="resourceadapter"
type="javaee:resourceadapterType"/>
<xsd:element name="required-work-context"
type="javaee: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="javaee:dewey-versionType"
fixed="1.6"
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:
javax.resource.spi.security.PasswordCredential
org.ietf.jgss.GSSCredential
javax.resource.spi.security.GenericCredential
</xsd:documentation>
</xsd:annotation>
<xsd:simpleContent>
<xsd:restriction base="javaee:fully-qualified-classType">
<xsd:enumeration value="javax.resource.spi.security.PasswordCredential"/>
<xsd:enumeration value="org.ietf.jgss.GSSCredential"/>
<xsd:enumeration value="javax.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="javaee: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="javaee:messagelistener"/>
<xsd:field xpath="javaee: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="javaee:descriptionType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="license-required"
type="javaee: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="javaee: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="javaee: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>javax.jms.MessageListener
</messagelistener-type>
]]>
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="activationspec"
type="javaee: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 JTA 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="javaee:connection-definitionType"
maxOccurs="unbounded"
minOccurs="0"/>
<xsd:element name="transaction-support"
type="javaee:transaction-supportType"
minOccurs="0"/>
<xsd:element name="authentication-mechanism"
type="javaee:authentication-mechanismType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="reauthentication-support"
type="javaee: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="javaee:descriptionType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="config-property-name"
type="javaee: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="javaee: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 javax.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="javaee:config-propertyType"
minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="outbound-resourceadapter"
type="javaee: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="javaee:connection-definition"/>
<xsd:field xpath="javaee:connectionfactory-interface"/>
</xsd:unique>
</xsd:element>
<xsd:element name="inbound-resourceadapter"
type="javaee:inbound-resourceadapterType"
minOccurs="0"/>
<xsd:element name="adminobject"
type="javaee: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="javaee:adminobject"/>
<xsd:field xpath="javaee:adminobject-interface"/>
<xsd:field xpath="javaee:adminobject-class"/>
</xsd:unique>
</xsd:element>
<xsd:element name="security-permission"
<