001: /**
002: * JOnAS: Java(TM) Open Application Server
003: * Copyright (C) 1999 Bull S.A.
004: * Contact: jonas-team@objectweb.org
005: *
006: * This library is free software; you can redistribute it and/or
007: * modify it under the terms of the GNU Lesser General Public
008: * License as published by the Free Software Foundation; either
009: * version 2.1 of the License, or any later version.
010: *
011: * This library is distributed in the hope that it will be useful,
012: * but WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * Lesser General Public License for more details.
015: *
016: * You should have received a copy of the GNU Lesser General Public
017: * License along with this library; if not, write to the Free Software
018: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
019: * USA
020: *
021: * --------------------------------------------------------------------------
022: * $Id: JEntitySwitchRO.java 8034 2006-02-20 10:10:50Z durieuxp $
023: * --------------------------------------------------------------------------
024: */package org.objectweb.jonas_ejb.container;
025:
026: import javax.ejb.EJBException;
027: import javax.transaction.SystemException;
028: import javax.transaction.Transaction;
029:
030: import org.objectweb.jonas_ejb.deployment.api.EntityDesc;
031:
032: import org.objectweb.util.monolog.api.BasicLevel;
033:
034: /**
035: * ReadOnly lock policy : Instance are never written to database.
036: * They are regularly read from database if bean is shared.
037: * @author Philippe Durieux
038: */
039: public class JEntitySwitchRO extends JEntitySwitchCST {
040:
041: protected long nextRead;
042:
043: /**
044: * empty constructor. Object is initialized via init() because it is
045: * implemented differently according to jorm mappers.
046: */
047: public JEntitySwitchRO() {
048: lockpolicy = EntityDesc.LOCK_READ_ONLY;
049: }
050:
051: protected void initpolicy(JEntityFactory bf) {
052: lazyregister = true; // never write anyway.
053: }
054:
055: public void waitmyturn(Transaction tx) {
056: // No synchro for this policy.
057: }
058:
059: /**
060: * Map a context and its instance.
061: * @param tx - the Transaction object
062: * @param bctx - the JEntityContext to bind if not null
063: * @param forced - force to take this context. (case of create)
064: * @param holdit - increment count to hold it, a release will be called
065: * later.
066: * @return JEntityContext actually mapped
067: */
068: public synchronized JEntityContext mapICtx(Transaction tx,
069: JEntityContext bctx, boolean forced, boolean holdit,
070: boolean notused) {
071:
072: waitmyturn(tx);
073:
074: // Choose the context to use.
075: boolean newtrans = false;
076: JEntityContext jec = itContext;
077: if (forced) {
078: TraceEjb.context.log(BasicLevel.ERROR, ident
079: + "create cannot be called on read only bean");
080: throw new EJBException("Read Only bean");
081: } else {
082: if (jec != null) {
083: // Reuse the Context for this transaction.
084: // If a context was supplied, release it first.
085: if (bctx != null) {
086: if (TraceEjb.isDebugContext())
087: TraceEjb.context.log(BasicLevel.DEBUG, ident
088: + "a context was supplied!");
089: bf.releaseJContext(bctx, 2);
090: }
091: newtrans = true;
092: jec.reuseEntityContext(newtrans);
093: } else {
094: if (bctx != null) {
095: jec = bctx;
096: } else {
097: // no Context available : get one from the pool.
098: jec = (JEntityContext) bf.getJContext(this );
099: }
100: jec.initEntityContext(this );
101: jec.activate(true);
102: nextRead = System.currentTimeMillis() + readTimeout;
103: //TraceEjb.synchro.log(BasicLevel.WARN, "loading state " + nextRead);
104: itContext = jec; // after activate
105: newtrans = true;
106: }
107: }
108:
109: if (tx != null) {
110: if (holdit) {
111: // Not really used for RO
112: countIT++;
113: if (shared) {
114: if (System.currentTimeMillis() > nextRead) {
115: // may have been modified outside this server.
116: jec.activate(false);
117: nextRead = System.currentTimeMillis()
118: + readTimeout;
119: //TraceEjb.synchro.log(BasicLevel.WARN, "TX reloading state " + nextRead);
120: }
121: }
122: }
123: } else {
124: if (holdit) {
125: countIH++;
126: if (TraceEjb.isDebugSynchro())
127: TraceEjb.synchro.log(BasicLevel.DEBUG, ident
128: + "mapICtx IH count=" + countIH);
129: if (shared && countIH == 1) {
130: if (System.currentTimeMillis() > nextRead) {
131: // may have been modified outside this server.
132: jec.activate(false);
133: nextRead = System.currentTimeMillis()
134: + readTimeout;
135: //TraceEjb.synchro.log(BasicLevel.WARN, "HT reloading state " + nextRead);
136: }
137: }
138: }
139: }
140:
141: return jec;
142: }
143:
144: /**
145: * This transaction is now over. We can dispose of the instance for another
146: * transaction or discard it.
147: * @param tx the transaction object
148: * @param committed true if transaction was committed.
149: */
150: public synchronized void txCompleted(Transaction tx,
151: boolean committed) {
152: TraceEjb.context.log(BasicLevel.ERROR, ident
153: + "should not happen (RO)");
154: }
155:
156: }
|