oh wait, I realize I commited more than I wanted to...
I am working on the interfaces but at this point just wanted to commit the
comments...
sorry this will not compile...
mmmm
marcf
|-----Original Message-----
|From: [EMAIL PROTECTED]
|[mailto:[EMAIL PROTECTED]]On Behalf Of
|[EMAIL PROTECTED]
|Sent: Wednesday, June 27, 2001 1:38 AM
|To: [EMAIL PROTECTED]
|Subject: [JBoss-dev] CVS update: jboss/src/main/org/jboss/ejb/plugins
|AbstractInstanceCache.java
|
|
| User: mnf999
| Date: 01/06/26 22:37:43
|
| Modified: src/main/org/jboss/ejb/plugins AbstractInstanceCache.java
| Log:
| mmmm FIXMES in the AbstractInstanceCache...
|
| we need to fix this poopoo
|
| Revision Changes Path
| 1.12 +292 -276
|jboss/src/main/org/jboss/ejb/plugins/AbstractInstanceCache.java
|
| Index: AbstractInstanceCache.java
| ===================================================================
| RCS file:
|/cvsroot/jboss/jboss/src/main/org/jboss/ejb/plugins/AbstractInstanc
|eCache.java,v
| retrieving revision 1.11
| retrieving revision 1.12
| diff -u -r1.11 -r1.12
| --- AbstractInstanceCache.java 2001/06/18 20:01:23 1.11
| +++ AbstractInstanceCache.java 2001/06/27 05:37:43 1.12
| @@ -1,9 +1,9 @@
| /*
| - * JBoss, the OpenSource EJB server
| - *
| - * Distributable under LGPL license.
| - * See terms of license at gnu.org.
| - */
| +* JBoss, the OpenSource EJB server
| +*
| +* Distributable under LGPL license.
| +* See terms of license at gnu.org.
| +*/
|
| package org.jboss.ejb.plugins;
|
| @@ -47,24 +47,32 @@
| import org.jboss.monitor.MetricsConstants;
|
| /**
| - * Base class for caches of entity and stateful beans. <p>
| - * It manages the cache entries through a {@link CachePolicy} object;
| - * the implementation of the cache policy object must respect
|the following
| - * requirements:
| - * <ul>
| - * <li> Have a public constructor that takes a single argument of type
| - * AbstractInstanceCache.class or a subclass
| - * </ul>
| - *
| - * @author <a href="mailto:[EMAIL PROTECTED]";>Simone Bordet</a>
| - * @author <a href="[EMAIL PROTECTED]">Bill Burke</a>
| - * @version $Revision: 1.11 $
| - */
| +* Base class for caches of entity and stateful beans. <p>
| +* It manages the cache entries through a {@link CachePolicy} object;
| +* the implementation of the cache policy object must respect
|the following
| +* requirements:
| +* <ul>
| +* <li> Have a public constructor that takes a single argument of type
| +* AbstractInstanceCache.class or a subclass
| +* </ul>
| +*
| +*
| +* @author <a href="mailto:[EMAIL PROTECTED]";>Simone Bordet</a>
| +* @author <a href="[EMAIL PROTECTED]">Bill Burke</a>
| +* @author <a href="mailto:[EMAIL PROTECTED]";>Marc Fleury</a>
| +*
| +*
| +* Revisions:
| +*
| +* 20010626 marc fleury: Cache should be working with the
|MethodInvocation
| +*
| +* @version $Revision: 1.12 $
| +*/
| public abstract class AbstractInstanceCache
| - implements InstanceCache, XmlLoadable, Monitorable, MetricsConstants
| +implements InstanceCache, XmlLoadable, Monitorable, MetricsConstants
| {
| // Constants -----------------------------------------------------
| -
| +
| // Attributes ----------------------------------------------------
| /* The object that is delegated to implement the desired
|caching policy */
| private CachePolicy m_cache;
| @@ -85,11 +93,11 @@
| private Topic m_jmsTopic;
| private TopicSession m_jmsSession;
| private TopicPublisher m_jmsPublisher;
| -
| +
| // Static --------------------------------------------------------
| -
| +
| // Constructors --------------------------------------------------
| -
| +
| // Monitorable implementation ------------------------------------
| public void sample(Object s)
| {
| @@ -104,16 +112,16 @@
| }
| }
| }
| -
| +
| // Public --------------------------------------------------------
| public void setJMSMonitoringEnabled(boolean enable)
|{m_jmsMonitoring = enable;}
| public boolean isJMSMonitoringEnabled() {return m_jmsMonitoring;}
| -
| +
| public void sendMessage(Message message)
| {
| try
| {
| - message.setJMSType(BEANCACHE_METRICS);
| + message.setJMSType(BEANCACHE_METRICS);
| message.setJMSExpiration(5000);
| message.setLongProperty(TIME,
|System.currentTimeMillis());
| m_jmsPublisher.publish(m_jmsTopic, message);
| @@ -142,22 +150,26 @@
| }
| return message;
| }
| -
| +
| /* From InstanceCache interface */
| public EnterpriseContext get(Object id)
| - throws RemoteException, NoSuchObjectException
| + throws RemoteException, NoSuchObjectException
| {
| if (id == null) throw new
|IllegalArgumentException("Can't get an object with a null key");
| -
| +
| EnterpriseContext ctx = null;
| +
| synchronized (getCacheLock())
| {
| ctx = (EnterpriseContext)getCache().get(id);
| if (ctx == null)
| {
| // Here I block if the bean is
|passivating now
| +
| + // FIXME marcf: I am REALLY against
|locking on passivation, we are locking the
| + // whole cache for the passivation
|of one guy. it doesn't make sense!!!!!!!!
| ctx = unschedulePassivation(id);
| -
| +
| // Already passivated ?
| if (ctx == null)
| {
| @@ -165,6 +177,9 @@
| {
| ctx = acquireContext();
| setKey(id, ctx);
| + //FIXME marcf: in
|the case of session we are saying that the WHOLE
| + // cache will be
|locked (see synchronized statement) until this guy completes
| + // DO YOU SEE IT?
|THE *WHOLE* APP LOCKED ON A ACTIVATION??? WTF?
| activate(ctx);
| logActivation(id);
| insert(ctx);
| @@ -182,13 +197,14 @@
| }
| }
| if (ctx == null) throw new
|NoSuchObjectException("Can't find bean with id = " + id);
| +
| return ctx;
| }
| /* From InstanceCache interface */
| public void insert(EnterpriseContext ctx)
| {
| if (ctx == null) throw new
|IllegalArgumentException("Can't insert a null object in the cache");
| -
| +
| CachePolicy cache = getCache();
| synchronized (getCacheLock())
| {
| @@ -196,7 +212,7 @@
| // key, then the context is passivated and
|I will insert in cache a meaningless
| // context.
| Object key = getKey(ctx);
| -
| +
| if (cache.peek(key) == null)
| {
| cache.insert(key, ctx);
| @@ -214,7 +230,7 @@
| public void release(EnterpriseContext ctx)
| {
| if (ctx == null) throw new
|IllegalArgumentException("Can't release a null object");
| -
| +
| // Here I remove the bean; call to remove(id) is wrong
| // cause will remove also the cache lock that is needed
| // by the passivation, that eventually will remove it.
| @@ -237,7 +253,7 @@
| public void remove(Object id)
| {
| if (id == null) throw new
|IllegalArgumentException("Can't remove an object using a null key");
| -
| +
| synchronized (getCacheLock())
| {
| if (getCache().peek(id) != null)
| @@ -247,19 +263,19 @@
| }
| removeLock(id);
| }
| -
| +
| public boolean isActive(Object id)
| {
| // Check whether an object with the given id is
|available in the cache
| return getCache().peek(id) != null;
| }
| /**
| - * Creates (if necessary) and returns an object used as
|mutex to sync passivation
| - * activity with other activities, in particular incoming
|invoking calls. <br>
| - * The mutex is automatically removed when the
|corrispondent id is removed from
| - * the cache, either by passivation or by removal.
| - * This method must be synchronized with its dual, {@link
|#removeLock}.
| - */
| + * Creates (if necessary) and returns an object used as
|mutex to sync passivation
| + * activity with other activities, in particular incoming
|invoking calls. <br>
| + * The mutex is automatically removed when the corrispondent
|id is removed from
| + * the cache, either by passivation or by removal.
| + * This method must be synchronized with its dual, {@link
|#removeLock}.
| + */
| public synchronized Sync getLock(Object id)
| {
| Sync mutex = (Sync)m_lockMap.get(id);
| @@ -271,22 +287,22 @@
| return mutex;
| }
| /**
| - * Removes the mutex associated with the given id.
| - * This method must be synchronized with its dual, {@link #getLock}.
| - */
| + * Removes the mutex associated with the given id.
| + * This method must be synchronized with its dual, {@link #getLock}.
| + */
| protected synchronized void removeLock(Object id)
| {
| Object mutex = m_lockMap.get(id);
| if (mutex != null)
| {
| - if (mutex instanceof BeanSemaphore)
| - {
| - ((BeanSemaphore)mutex).invalidate();
| - }
| - m_lockMap.remove(id);
| + if (mutex instanceof BeanSemaphore)
| + {
| + ((BeanSemaphore)mutex).invalidate();
| + }
| + m_lockMap.remove(id);
| }
| }
| -
| +
| // XmlLoadable implementation
|----------------------------------------------
| public void importXml(Element element) throws DeploymentException
| {
| @@ -302,7 +318,7 @@
| {
| throw new DeploymentException("Can't create
|cache policy", x);
| }
| -
| +
| Element policyConf =
|MetaData.getOptionalChild(element, "cache-policy-conf");
| if (policyConf != null)
| {
| @@ -319,7 +335,7 @@
| }
| }
| }
| -
| +
| /* From Service interface*/
| public void init() throws Exception
| {
| @@ -328,16 +344,16 @@
| String threadName = "Passivator Thread for " +
|getContainer().getBeanMetaData().getEjbName();
| ClassLoader cl = getContainer().getClassLoader();
| m_passivator = new PassivatorQueue(threadName, cl);
| -
| +
| if (isJMSMonitoringEnabled())
| {
| // Setup JMS for cache monitoring
| Context namingContext = new InitialContext();
| Object factoryRef =
|namingContext.lookup("TopicConnectionFactory");
| TopicConnectionFactory factory =
|(TopicConnectionFactory)PortableRemoteObject.narrow(factoryRef,
|TopicConnectionFactory.class);
| -
| +
| m_jmsConnection = factory.createTopicConnection();
| -
| +
| Object topicRef =
|namingContext.lookup("topic/metrics");
| m_jmsTopic =
|(Topic)PortableRemoteObject.narrow(topicRef, Topic.class);
| m_jmsSession =
|m_jmsConnection.createTopicSession(false, Session.DUPS_OK_ACKNOWLEDGE);
| @@ -349,7 +365,7 @@
| {
| getCache().start();
| m_passivator.start();
| -
| +
| if (isJMSMonitoringEnabled())
| {
| m_jmsConnection.start();
| @@ -363,9 +379,9 @@
| {
| getCache().stop();
| }
| -
| +
| if (m_passivator != null) {m_passivator.stop();}
| -
| +
| if (isJMSMonitoringEnabled() && m_jmsConnection != null)
| {
| try
| @@ -388,32 +404,32 @@
| catch (JMSException ignored) {}
| }
| }
| -
| +
| // Y overrides ---------------------------------------------------
| -
| +
| // Package protected ---------------------------------------------
| -
| +
| // Protected -----------------------------------------------------
| /**
| - * Schedules the given EnterpriseContext for passivation
| - * @see PassivationHelper#schedule
| - */
| + * Schedules the given EnterpriseContext for passivation
| + * @see PassivationHelper#schedule
| + */
| protected void schedulePassivation(EnterpriseContext ctx)
| {
| m_passivationHelper.schedule(ctx);
| logPassivationScheduled(getKey(ctx));
| }
| /**
| - * Tries to unschedule the given EnterpriseContext for
|passivation; returns
| - * the unscheduled context if it wasn't passivated yet, null if the
| - * passivation already happened.
| - * @see PassivationHelper#unschedule
| - */
| + * Tries to unschedule the given EnterpriseContext for
|passivation; returns
| + * the unscheduled context if it wasn't passivated yet, null if the
| + * passivation already happened.
| + * @see PassivationHelper#unschedule
| + */
| protected EnterpriseContext unschedulePassivation(Object id)
| {
| return m_passivationHelper.unschedule(id);
| }
| -
| +
| protected void logActivation(Object id)
| {
| m_buffer.setLength(0);
| @@ -422,7 +438,7 @@
| m_buffer.append(" with id = ");
| m_buffer.append(id);
| Logger.debug(m_buffer.toString());
| -
| +
| if (isJMSMonitoringEnabled())
| {
| // Prepare JMS message
| @@ -435,12 +451,12 @@
| {
| Logger.exception(x);
| }
| -
| +
| // Send JMS Message
| sendMessage(message);
| }
| }
| -
| +
| protected void logPassivationScheduled(Object id)
| {
| m_buffer.setLength(0);
| @@ -449,7 +465,7 @@
| m_buffer.append(" with id = ");
| m_buffer.append(id);
| Logger.debug(m_buffer.toString());
| -
| +
| if (isJMSMonitoringEnabled())
| {
| // Prepare JMS message
| @@ -463,12 +479,12 @@
| {
| Logger.exception(x);
| }
| -
| +
| // Send JMS Message
| sendMessage(message);
| }
| }
| -
| +
| protected void logPassivation(Object id)
| {
| m_buffer.setLength(0);
| @@ -477,7 +493,7 @@
| m_buffer.append(" with id = ");
| m_buffer.append(id);
| Logger.debug(m_buffer.toString());
| -
| +
| if (isJMSMonitoringEnabled())
| {
| // Prepare JMS message
| @@ -491,12 +507,12 @@
| {
| Logger.exception(x);
| }
| -
| +
| // Send JMS Message
| sendMessage(message);
| }
| }
| -
| +
| protected void logPassivationPostponed(Object id)
| {
| m_buffer.setLength(0);
| @@ -505,7 +521,7 @@
| m_buffer.append(" with id = ");
| m_buffer.append(id);
| Logger.debug(m_buffer.toString());
| -
| +
| if (isJMSMonitoringEnabled())
| {
| // Prepare JMS message
| @@ -519,86 +535,86 @@
| {
| Logger.exception(x);
| }
| -
| +
| // Send JMS Message
| sendMessage(message);
| }
| }
| -
| +
| /**
| - * Returns the container for this cache.
| - */
| + * Returns the container for this cache.
| + */
| protected abstract Container getContainer();
| /**
| - * Returns the cache policy used for this cache.
| - */
| + * Returns the cache policy used for this cache.
| + */
| protected CachePolicy getCache() {return m_cache;}
| /**
| - * Returns the mutex used to sync access to the cache policy object
| - */
| + * Returns the mutex used to sync access to the cache policy object
| + */
| public Object getCacheLock()
| {
| return m_cacheLock;
| }
| /**
| - * Passivates the given EnterpriseContext
| - */
| + * Passivates the given EnterpriseContext
| + */
| protected abstract void passivate(EnterpriseContext ctx)
|throws RemoteException;
| /**
| - * Activates the given EnterpriseContext
| - */
| + * Activates the given EnterpriseContext
| + */
| protected abstract void activate(EnterpriseContext ctx)
|throws RemoteException;
| /**
| - * Acquires an EnterpriseContext from the pool
| - */
| + * Acquires an EnterpriseContext from the pool
| + */
| protected abstract EnterpriseContext acquireContext()
|throws Exception;
| /**
| - * Frees the given EnterpriseContext to the pool
| - */
| + * Frees the given EnterpriseContext to the pool
| + */
| protected abstract void freeContext(EnterpriseContext ctx);
| /**
| - * Returns the key used by the cache to map the given context
| - */
| + * Returns the key used by the cache to map the given context
| + */
| protected abstract Object getKey(EnterpriseContext ctx);
| /**
| - * Sets the given id as key for the given context
| - */
| + * Sets the given id as key for the given context
| + */
| protected abstract void setKey(Object id, EnterpriseContext ctx);
| /**
| - * Returns whether the given context can be passivated or not
| - *
| - */
| + * Returns whether the given context can be passivated or not
| + *
| + */
| protected abstract boolean canPassivate(EnterpriseContext ctx);
| -
| +
| // Private -------------------------------------------------------
| -
| +
| // Inner classes -------------------------------------------------
| /**
| - * Helper class that schedules, unschedules, and executes
|the passivation jobs.
| - */
| + * Helper class that schedules, unschedules, and executes
|the passivation jobs.
| + */
| protected class PassivationHelper
| {
| /* The map that holds the passivation jobs posted */
| private Map m_passivationJobs;
| -
| +
| protected PassivationHelper()
| {
| m_passivationJobs =
|Collections.synchronizedMap(new HashMap());
| }
| -
| +
| /**
| - * Creates and schedules a {@link PassivationJob}
|for passivation
| - */
| + * Creates and schedules a {@link PassivationJob}
|for passivation
| + */
| protected void schedule(EnterpriseContext bean)
| {
| // Register only once the job to be able to
|unschedule its passivation
| Object key = getKey(bean);
| if (m_passivationJobs.get(key) == null)
| {
| - // (Bill Burke) We can't rely on
|the EnterpriseContext to provide PassivationJob
| - // with a valid key because it may
|get freed to the InstancePool, then
| - // reused before the PassivationJob
|executes.
| - //
| + // (Bill Burke) We can't rely on
|the EnterpriseContext to provide PassivationJob
| + // with a valid key because it may
|get freed to the InstancePool, then
| + // reused before the PassivationJob
|executes.
| + //
| PassivationJob job = new
|PassivationJob(bean, key)
| {
| public void execute()
|throws Exception
| @@ -606,101 +622,101 @@
| EnterpriseContext
|ctx = this.getEnterpriseContext();
| if (ctx.getId() == null)
| {
| - // If this
|happens, then a passivation request for this bean was issued
| - // but not yet
|executed, and in the meanwhile the bean has been removed.
| - return;
| + // If this
|happens, then a passivation request for this bean was issued
| + // but not
|yet executed, and in the meanwhile the bean has been removed.
| + return;
| }
| -
| +
| Object id = this.getKey();
| -
| +
| /**
| - * Synchronization
|/ Passivation explanations:
| - * The instance
|interceptor (II) first acquires the Sync object associated
| - * with the given
|id, then asks to the instance cache (IC) for an enterprise
| - * context.
| - * The IC, if the
|context is not present, activates it and returns it.
| - * If the context
|is not in the IC then or it has already been
| - * passivated, or
|it is scheduled for passivation. If the latter is true,
| - * then the job is
|canceled and passivation does not occur, and the context
| - * is reinserted in the IC.
| - * This activity
|synchronizes in the following order the following objects:
| - * 1) the Sync
|object associated to the context's id via getLock(id)
| - * 2) the cache
|lock object via getCacheLock()
| - * 3) the
|passivation job, since cancel() is synchronized.
| - * To avoid
|deadlock, here we MUST acquire these resources in the same
| - * exact order.
| - */
| + * Synchronization /
|Passivation explanations:
| + * The instance
|interceptor (II) first acquires the Sync object associated
| + * with the given
|id, then asks to the instance cache (IC) for an enterprise
| + * context.
| + * The IC, if the
|context is not present, activates it and returns it.
| + * If the context is
|not in the IC then or it has already been
| + * passivated, or it
|is scheduled for passivation. If the latter is true,
| + * then the job is
|canceled and passivation does not occur, and the context
| + * is reinserted in the IC.
| + * This activity
|synchronizes in the following order the following objects:
| + * 1) the Sync
|object associated to the context's id via getLock(id)
| + * 2) the cache lock
|object via getCacheLock()
| + * 3) the
|passivation job, since cancel() is synchronized.
| + * To avoid
|deadlock, here we MUST acquire these resources in the same
| + * exact order.
| + */
| Sync mutex =
|(Sync)getLock(id);
| -
| +
| try
| {
| mutex.acquire();
| -
| +
|
|synchronized (getCacheLock())
| {
| - // This
|is absolutely fundamental: the job must be removed from
| - // the
|map in every case. If it remains there, the call to
| - //
|PassivationHelper.unschedule() will cause the corrispondent
| - //
|context to be reinserted in the cache, and if then is passivated
| - // we
|have a context without meaning in the cache
| -
|m_passivationJobs.remove(id);
| -
| -
|synchronized (this)
| - {
| - if
|(ctx instanceof EntityEnterpriseContext)
| - {
| -
|// Verify that this ctx hasn't already
| -
|// been freed and re-used by another thread.
| -
|if (!((EntityEnterpriseContext)ctx).getCacheKey().equals(id))
| - {
| -
|// ctx has been freed then re-used in another thread.
| -
|return;
| - }
| - }
| - if
|(!canPassivate(ctx))
| + //
|This is absolutely fundamental: the job must be removed from
| + //
|the map in every case. If it remains there, the call to
| + //
|PassivationHelper.unschedule() will cause the corrispondent
| + //
|context to be reinserted in the cache, and if then is passivated
| + //
|we have a context without meaning in the cache
| +
|m_passivationJobs.remove(id);
| +
| +
|synchronized (this)
| {
| -
|// This check is done because there could have been
| -
|// a request for passivation of this bean, but before
| -
|// being passivated it got a request and has already
| -
|// been inserted in the cache by the cache
| -
|if (getCache().peek(id) == null)
| - {
| -
|getCache().insert(id, ctx);
| - }
| -
| -
|logPassivationPostponed(id);
| -
| - return;
| - }
| - else
| - {
| -
|if (!isCancelled())
| - {
| - try
| +
|if (ctx instanceof EntityEnterpriseContext)
| + {
| +
| // Verify that this ctx hasn't already
| +
| // been freed and re-used by another thread.
| +
| if (!((EntityEnterpriseContext)ctx).getCacheKey().equals(id))
| +
| {
| +
| // ctx has been freed then re-used in another thread.
| +
| return;
| +
| }
| + }
| +
|if (!canPassivate(ctx))
| {
| -
| // If the next call throws RemoteException we reinsert
| -
| // the bean in the cache; every successive passivation
| -
| // attempt will fail. The other policy would have been
| -
| // to remove it, but then clients unexpectedly won't
| -
| // find it anymore. On the other hand, on the server
| -
| // log it is possible to see that passivation for the
| -
| // bean failed, and fix it. See EJB 1.1, 6.4.1
| -
| passivate(ctx);
| -
| executed();
| -
| removeLock(id);
| -
| freeContext(ctx);
| -
| -
| logPassivation(id);
| +
| // This check is done because there could have been
| +
| // a request for passivation of this bean, but before
| +
| // being passivated it got a request and has already
| +
| // been inserted in the cache by the cache
| +
| if (getCache().peek(id) == null)
| +
| {
| +
| getCache().insert(id, ctx);
| +
| }
| +
| +
| logPassivationPostponed(id);
| +
| +
| return;
| }
| -
|catch (RemoteException x)
| + else
| {
| -
| // Can't passivate this bean, reinsert it in the cache
| -
| getCache().insert(id, ctx);
| -
| throw x;
| +
| if (!isCancelled())
| +
| {
| +
| try
| +
| {
| +
| // If the next call throws RemoteException
|we reinsert
| +
| // the bean in the cache; every successive
|passivation
| +
| // attempt will fail. The other policy
|would have been
| +
| // to remove it, but then clients unexpectedly won't
| +
| // find it anymore. On the other hand, on the server
| +
| // log it is possible to see that
|passivation for the
| +
| // bean failed, and fix it. See EJB 1.1, 6.4.1
| +
| passivate(ctx);
| +
| executed();
| +
| removeLock(id);
| +
| freeContext(ctx);
| +
|
| +
| logPassivation(id);
| +
| }
| +
| catch (RemoteException x)
| +
| {
| +
| // Can't passivate this bean, reinsert it
|in the cache
| +
| getCache().insert(id, ctx);
| +
| throw x;
| +
| }
| +
| }
| }
| - }
| }
| - }
| }
| }
| catch
|(InterruptedException ignored) {}
| @@ -710,7 +726,7 @@
| }
| }
| };
| -
| +
| // This method is entered only by
|one thread at a time, since the only caller
| // call it only after having sync
|on the cache lock via getCacheLock().
| // However, enforce this sync'ing
|on the passivation job's map
| @@ -720,7 +736,7 @@
| {
| // Register job
|
|m_passivationJobs.put(key, job);
| -
| +
| // Schedule the job
|for passivation
| m_passivator.putJob(job);
| }
| @@ -735,15 +751,15 @@
| }
| }
| /**
| - * Tries to unschedule a job paired with the given
|context's id
| - * @return null if the bean has been passivated, the context
| - * paired with the given id otherwise
| - */
| + * Tries to unschedule a job paired with the given
|context's id
| + * @return null if the bean has been passivated, the context
| + * paired with the given id otherwise
| + */
| protected EnterpriseContext unschedule(Object id)
| {
| // I chose not to remove canceled job here
|becauses multiple
| // unscheduling requests can arrive. This
|way all will be served
| -
| +
| // Is the passivation job for id still to
|be executed ?
| PassivationJob job =
|(PassivationJob)m_passivationJobs.get(id);
| if (job != null)
| @@ -768,75 +784,75 @@
| }
|
| /**
| - * Abstract class for passivation jobs.
| - * Subclasses should implement {@link #execute} synchronizing
|it in some way because
| - * the execute method is normally called in the passivation thread,
| - * while the cancel method is normally called from another thread.
| - * To avoid that subclasses override methods of this class without
| - * make them synchronized (except execute of course), they're
|declared final.
| - */
| +* Abstract class for passivation jobs.
| +* Subclasses should implement {@link #execute} synchronizing it
|in some way because
| +* the execute method is normally called in the passivation thread,
| +* while the cancel method is normally called from another thread.
| +* To avoid that subclasses override methods of this class without
| +* make them synchronized (except execute of course), they're
|declared final.
| +*/
| abstract class PassivationJob implements Executable
| {
| private EnterpriseContext m_context;
| private Object m_key;
| private boolean m_cancelled;
| private boolean m_executed;
| -
| +
| PassivationJob(EnterpriseContext ctx, Object key)
| {
| m_context = ctx;
| m_key = key;
| }
| -
| +
| public abstract void execute() throws Exception;
| -
| - /**
| - * (Bill Burke) We can't rely on the EnterpriseContext to
|provide PassivationJob
| - * with a valid key because it may get freed to the
|InstancePool, then
| - * reused before the PassivationJob executes.
| - */
| - final Object getKey()
| - {
| - return m_key;
| +
| + /**
| + * (Bill Burke) We can't rely on the EnterpriseContext to
|provide PassivationJob
| + * with a valid key because it may get freed to the
|InstancePool, then
| + * reused before the PassivationJob executes.
| + */
| + final Object getKey()
| + {
| + return m_key;
| }
| /**
| - * Returns the EnterpriseContext associated with this
|passivation job,
| - * so the bean that will be passivated.
| - * No need to synchronize access to this method, since the returned
| - * reference is immutable
| - */
| + * Returns the EnterpriseContext associated with this
|passivation job,
| + * so the bean that will be passivated.
| + * No need to synchronize access to this method, since the returned
| + * reference is immutable
| + */
| final EnterpriseContext getEnterpriseContext()
| {
| return m_context;
| }
| /**
| - * Mark this job for cancellation.
| - * @see #isCancelled
| - */
| + * Mark this job for cancellation.
| + * @see #isCancelled
| + */
| final synchronized void cancel()
| {
| m_cancelled = true;
| }
| /**
| - * Returns whether this job has been marked for cancellation
| - * @see #cancel
| - */
| + * Returns whether this job has been marked for cancellation
| + * @see #cancel
| + */
| final synchronized boolean isCancelled()
| {
| return m_cancelled;
| }
| /**
| - * Mark this job as executed
| - * @see #isExecuted
| - */
| + * Mark this job as executed
| + * @see #isExecuted
| + */
| final synchronized void executed()
| {
| m_executed = true;
| }
| /**
| - * Returns whether this job has been executed
| - * @see #executed
| - */
| + * Returns whether this job has been executed
| + * @see #executed
| + */
| final synchronized boolean isExecuted()
| {
| return m_executed;
| @@ -846,24 +862,24 @@
| class PassivatorQueue extends WorkerQueue
| {
| /**
| - * Used for debug purposes, holds the scheduled passivation jobs
| - */
| -// private Map m_map = new HashMap();
| -
| + * Used for debug purposes, holds the scheduled passivation jobs
| + */
| + // private Map m_map = new HashMap();
| +
| /**
| - * Creates a new passivator queue with default thread name of
| - * "Passivator Thread".
| - */
| + * Creates a new passivator queue with default thread name of
| + * "Passivator Thread".
| + */
| PassivatorQueue()
| {
| this("Passivator Thread", null);
| }
| /**
| - * Creates a new passivator queue with the given thread
|name and given
| - * context class loader. <br>
| - * @param threadName the name of the passivator thread
| - * @param cl the context class loader; if null the context
|class loader is not set.
| - */
| + * Creates a new passivator queue with the given thread name
|and given
| + * context class loader. <br>
| + * @param threadName the name of the passivator thread
| + * @param cl the context class loader; if null the context
|class loader is not set.
| + */
| PassivatorQueue(String threadName, ClassLoader cl)
| {
| super(threadName);
| @@ -873,43 +889,43 @@
| }
| }
| /**
| - * Overridden for debug purposes
| - *//*
| + * Overridden for debug purposes
| + *//*
| protected Executable getJobImpl() throws InterruptedException
| {
| - PassivationJob j = (PassivationJob)super.getJobImpl();
| - EnterpriseContext ctx = j.getEnterpriseContext();
| - Object id = ctx.getId();
| - m_map.remove(id);
| - return j;
| + PassivationJob j = (PassivationJob)super.getJobImpl();
| + EnterpriseContext ctx = j.getEnterpriseContext();
| + Object id = ctx.getId();
| + m_map.remove(id);
| + return j;
| }
| */
| /**
| - * Overridden for debug purposes
| - *//*
| + * Overridden for debug purposes
| + *//*
| protected void putJobImpl(Executable job)
| {
| - PassivationJob j = (PassivationJob)job;
| - EnterpriseContext ctx = j.getEnterpriseContext();
| - Object id = ctx.getId();
| - if (m_map.get(id) != null)
| - {
| - // Here is a bug, job requests are
|scheduled only once per bean.
| - System.err.println("DUPLICATE PASSIVATION
|JOB INSERTION FOR ID = " + ctx.getId());
| - System.err.println("CTX isLocked: " +
|ctx.isLocked());
| - System.err.println("CTX transaction: " +
|ctx.getTransaction());
| - throw new IllegalStateException();
| - }
| - else
| - {
| - m_map.put(id, job);
| - }
| - super.putJobImpl(job);
| + PassivationJob j = (PassivationJob)job;
| + EnterpriseContext ctx = j.getEnterpriseContext();
| + Object id = ctx.getId();
| + if (m_map.get(id) != null)
| + {
| + // Here is a bug, job requests are scheduled only once per bean.
| + System.err.println("DUPLICATE PASSIVATION JOB INSERTION FOR
|ID = " + ctx.getId());
| + System.err.println("CTX isLocked: " + ctx.isLocked());
| + System.err.println("CTX transaction: " + ctx.getTransaction());
| + throw new IllegalStateException();
| + }
| + else
| + {
| + m_map.put(id, job);
| + }
| + super.putJobImpl(job);
| }
| */
| /**
| - * Logs exceptions thrown during job execution.
| - */
| + * Logs exceptions thrown during job execution.
| + */
| protected void logJobException(Exception x)
| {
| // Log system exceptions
|
|
|
|
|_______________________________________________
|Jboss-development mailing list
|[EMAIL PROTECTED]
|http://lists.sourceforge.net/lists/listinfo/jboss-development
_______________________________________________
Jboss-development mailing list
[EMAIL PROTECTED]
http://lists.sourceforge.net/lists/listinfo/jboss-development
