<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE ejb-jar PUBLIC "-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN" "http://java.sun.com/dtd/ejb-jar_2_0.dtd">
<!--

    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.

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

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

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

-->

<ejb-jar>
  <display-name>status6ejb</display-name>
  <enterprise-beans>
    <session>
      <ejb-name>bmsamplebean3</ejb-name>
      <home>com.sun.s1asdev.jdbc.transactions.test1.ejb.bmsample3home</home>
      <remote>com.sun.s1asdev.jdbc.transactions.test1.ejb.bmsample3</remote>
      <ejb-class>com.sun.s1asdev.jdbc.transactions.test1.ejb.bmsamplebean3</ejb-class>
      <session-type>Stateful</session-type>
      <transaction-type>Container</transaction-type>
      <resource-ref>
        <description>oraclethird</description>
        <res-ref-name>jdbc/oraclethird</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
      </resource-ref>
   </session>
  </enterprise-beans>
 <enterprise-beans>
    <session>
      <ejb-name>bmsamplebean4</ejb-name>
      <home>com.sun.s1asdev.jdbc.transactions.test1.ejb.bmsample4home</home>
      <remote>com.sun.s1asdev.jdbc.transactions.test1.ejb.bmsample4</remote>
      <ejb-class>com.sun.s1asdev.jdbc.transactions.test1.ejb.bmsamplebean4</ejb-class>
      <session-type>Stateful</session-type>
      <transaction-type>Bean</transaction-type>
      <resource-ref>
        <description>oracleds2</description>
        <res-ref-name>jdbc/oracleds2</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
      </resource-ref>
   </session>
  </enterprise-beans>

 <assembly-descriptor>
    <container-transaction>
      <description>This value was set as a default by Forte For Java.</description>
      <method>
        <ejb-name>bmsamplebean3</ejb-name>
        <method-name>*</method-name>
      </method>
      <trans-attribute>Required</trans-attribute>
    </container-transaction>
    <container-transaction>
      <description>This value was set as a default by Forte For Java.</description>
      <method>
        <ejb-name>bmsamplebean4</ejb-name>
        <method-name>*</method-name>
      </method>
      <trans-attribute>Mandatory</trans-attribute>
    </container-transaction>
  </assembly-descriptor>

</ejb-jar>
