[jboss-cvs] JBossCache/old/src/org/jboss/cache/aop/statetransfer ...
Ben Wang
bwang at jboss.com
Tue Oct 31 03:01:16 EST 2006
User: bwang
Date: 06/10/31 03:01:16
Added: old/src/org/jboss/cache/aop/statetransfer
PojoStateTransferGenerator_200.java
PojoStateTransferIntegrator_200.java
PojoStateTransferFactory.java
PojoStateTransferManager.java
Log:
Deprecated files moved to old dir.
Revision Changes Path
1.1 date: 2006/10/31 08:01:16; author: bwang; state: Exp;JBossCache/old/src/org/jboss/cache/aop/statetransfer/PojoStateTransferGenerator_200.java
Index: PojoStateTransferGenerator_200.java
===================================================================
/*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.aop.statetransfer;
import java.io.ObjectOutputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.jboss.cache.DataNode;
import org.jboss.cache.Fqn;
import org.jboss.cache.TreeCache;
import org.jboss.cache.aop.InternalDelegate;
import org.jboss.cache.aop.util.ObjectUtil;
import org.jboss.cache.loader.NodeData;
import org.jboss.cache.statetransfer.DefaultStateTransferGenerator;
class PojoStateTransferGenerator_200 extends DefaultStateTransferGenerator
{
protected PojoStateTransferGenerator_200(TreeCache cache)
{
super(cache);
}
/**
* Marshalls associated state as one NodeData object. Associated state is
* internal reference counting mechanism for pojo cache.
*
*
* Internal reference map representing associated state contains children
* nodes without any descendants. Each child has a key (name) and only one value in its
* map stored under key (name).
*
* For each node in the internal reference map that is associated with parameter
* fqn we create an entry in NodeData's attributes along with its value and marshall only
* one NodeData instance to stream.
*
*
*/
protected void marshallAssociatedState(Fqn fqn, ObjectOutputStream out)
throws Exception
{
if (fqn == null
|| fqn.size() == 0
|| fqn.isChildOf(InternalDelegate.JBOSS_INTERNAL))
return;
DataNode refMapNode = getTreeCache().get(InternalDelegate.JBOSS_INTERNAL_MAP);
Map children = null;
if (refMapNode != null && (children = refMapNode.getChildren()) != null) {
String targetFqn = ObjectUtil.getIndirectFqn(fqn.toString());
Map.Entry entry;
String key;
DataNode value;
Fqn mapFqn = new Fqn(InternalDelegate.JBOSS_INTERNAL_MAP);
Map attrs = new HashMap();
NodeData nd = new NodeData(mapFqn, attrs);
for (Iterator iter = children.entrySet().iterator(); iter.hasNext();)
{
entry = (Map.Entry) iter.next();
key = (String) entry.getKey();
if (key.startsWith(targetFqn))
{
value = (DataNode) entry.getValue();
attrs.put(key, value.get(key));
}
}
out.writeObject(nd);
}
}
}
1.1 date: 2006/10/31 08:01:16; author: bwang; state: Exp;JBossCache/old/src/org/jboss/cache/aop/statetransfer/PojoStateTransferIntegrator_200.java
Index: PojoStateTransferIntegrator_200.java
===================================================================
/*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.aop.statetransfer;
import java.io.ObjectInputStream;
import java.util.Iterator;
import java.util.Map;
import org.jboss.cache.DataNode;
import org.jboss.cache.Fqn;
import org.jboss.cache.TreeCache;
import org.jboss.cache.TreeNode;
import org.jboss.cache.aop.InternalDelegate;
import org.jboss.cache.factories.NodeFactory;
import org.jboss.cache.loader.NodeData;
import org.jboss.cache.statetransfer.DefaultStateTransferIntegrator;
class PojoStateTransferIntegrator_200 extends DefaultStateTransferIntegrator
{
public PojoStateTransferIntegrator_200(Fqn targetFqn, TreeCache cache)
{
super(targetFqn, cache);
}
/**
*
* Integrates associated state previously written to stream as one NodeData
* object. Associated state is internal reference counting mechanism for pojo cache.
*
*
*
*/
protected void integrateAssociatedState(ObjectInputStream in) throws Exception
{
NodeData nd = (NodeData) in.readObject();
if (nd != null && !nd.isMarker())
{
TreeCache cache = getCache();
DataNode refMapNode = cache.get(InternalDelegate.JBOSS_INTERNAL_MAP);
NodeFactory factory = getFactory();
Map attrs = nd.getAttributes();
for (Iterator iter = attrs.keySet().iterator(); iter.hasNext();)
{
Object attr = iter.next();
TreeNode target = refMapNode.getChild(attr);
if (target == null)
{
// Create the node
Fqn fqn = new Fqn(InternalDelegate.JBOSS_INTERNAL_MAP, attr);
target = factory.createDataNode(getNodeType(), attr, fqn, refMapNode, null, true, cache);
refMapNode.addChild(attr, target);
}
target.put(attr, attrs.get(attr));
}
if (log.isTraceEnabled())
log.trace("associated state successfully integrated for " + getTargetFqn());
}
}
}
1.1 date: 2006/10/31 08:01:16; author: bwang; state: Exp;JBossCache/old/src/org/jboss/cache/aop/statetransfer/PojoStateTransferFactory.java
Index: PojoStateTransferFactory.java
===================================================================
/*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.aop.statetransfer;
import java.io.IOException;
import java.io.ObjectInputStream;
import org.jboss.cache.Fqn;
import org.jboss.cache.TreeCache;
import org.jboss.cache.Version;
import org.jboss.cache.statetransfer.StateTransferGenerator;
import org.jboss.cache.statetransfer.StateTransferIntegrator;
/**
* Factory class able to create {@link StateTransferGenerator} and
* {@link StateTransferIntegrator} instances.
*
* @author <a href="brian.stansberry at jboss.com">Brian Stansberry</a>
* @version $Revision: 1.1 $
*/
public abstract class PojoStateTransferFactory
{
private static final short RV_200 = Version.getVersionShort("2.0.0");
/**
* Gets the StateTransferGenerator able to handle the given cache instance.
*
* @param cache the cache
*
* @return the {@link StateTransferGenerator}
*
* @throws IllegalStateException if the cache's ReplicationVersion is < 2.0.0
*/
public static StateTransferGenerator
getStateTransferGenerator(TreeCache cache)
{
short version = cache.getConfiguration().getReplicationVersion();
// Compiler won't let me use a switch
if (version < RV_200 && version > 0) // <= 0 is actually a version > 15.31.63
throw new IllegalStateException("State transfer with cache replication version < 2.0.0 not supported");
else
return new PojoStateTransferGenerator_200(cache); // current default
}
public static StateTransferIntegrator getStateTransferIntegrator(ObjectInputStream in, Fqn fqn, TreeCache treeCache)
throws Exception
{
short version = 0;
try
{
version = in.readShort();
}
catch (IOException io)
{
// something is wrong with this stream, close it
try
{
in.close();
}
catch (IOException ignored)
{
}
throw new IllegalStateException("Stream corrupted ", io);
}
// Compiler won't let me use a switch
if (version < RV_200 && version > 0) // <= 0 is actually a version > 15.31.63
throw new IllegalStateException("State transfer with cache replication version < 2.0.0 not supported");
else
return new PojoStateTransferIntegrator_200(fqn, treeCache); // current default
}
}
1.1 date: 2006/10/31 08:01:16; author: bwang; state: Exp;JBossCache/old/src/org/jboss/cache/aop/statetransfer/PojoStateTransferManager.java
Index: PojoStateTransferManager.java
===================================================================
package org.jboss.cache.aop.statetransfer;
import java.io.ObjectInputStream;
import java.util.Iterator;
import java.util.Map;
import org.jboss.cache.CacheException;
import org.jboss.cache.DataNode;
import org.jboss.cache.Fqn;
import org.jboss.cache.TreeCache;
import org.jboss.cache.aop.InternalDelegate;
import org.jboss.cache.aop.util.ObjectUtil;
import org.jboss.cache.statetransfer.StateTransferGenerator;
import org.jboss.cache.statetransfer.StateTransferIntegrator;
import org.jboss.cache.statetransfer.StateTransferManager;
public class PojoStateTransferManager extends StateTransferManager
{
public PojoStateTransferManager(TreeCache cache)
{
super(cache);
}
protected StateTransferGenerator getStateTransferGenerator()
{
return PojoStateTransferFactory.getStateTransferGenerator(getTreeCache());
}
protected StateTransferIntegrator getStateTransferIntegrator(ObjectInputStream istream, Fqn fqn) throws Exception
{
return PojoStateTransferFactory.getStateTransferIntegrator(istream, fqn, getTreeCache());
}
/**
* Overrides the superclass version by additionally acquiring locks
* on the internal reference map nodes used for tracking shared objects.
*/
protected void acquireLocksForStateTransfer(DataNode root,
Object lockOwner,
long timeout,
boolean force)
throws Exception
{
super.acquireLocksForStateTransfer(root, lockOwner, timeout, true, force);
Fqn fqn = root.getFqn();
if (fqn.size() > 0 &&
!fqn.isChildOf(InternalDelegate.JBOSS_INTERNAL))
{
DataNode refMapNode = getTreeCache().get(InternalDelegate.JBOSS_INTERNAL_MAP);
if (refMapNode != null)
{
// Lock the internal map node but not its children to
// prevent the addition of other children
super.acquireLocksForStateTransfer(refMapNode, lockOwner, timeout,
false, force);
// Walk through the children, and lock any whose name starts
// with the string version of our root node's Fqn
Map children = refMapNode.getChildren();
if (children != null)
{
String targetFqn = ObjectUtil.getIndirectFqn(fqn);
Map.Entry entry;
for (Iterator iter = children.entrySet().iterator();
iter.hasNext();)
{
entry = (Map.Entry) iter.next();
if (((String) entry.getKey()).startsWith(targetFqn))
{
super.acquireLocksForStateTransfer((DataNode) entry.getValue(),
lockOwner, timeout,
false, force);
}
}
}
}
}
}
/**
* Overrides the superclass version by additionally releasing locks
* on the internal reference map nodes used for tracking shared objects.
*/
protected void releaseStateTransferLocks(DataNode root, Object lockOwner)
{
boolean releaseInternal = true;
try
{
super.releaseStateTransferLocks(root, lockOwner, true);
Fqn fqn = root.getFqn();
releaseInternal = (fqn.size() > 0 &&
!fqn.isChildOf(InternalDelegate.JBOSS_INTERNAL));
}
finally
{
if (releaseInternal)
{
try
{
DataNode refMapNode = getTreeCache().get(InternalDelegate.JBOSS_INTERNAL_MAP);
if (refMapNode != null)
{
// Rather than going to the effort of identifying which
// child nodes we locked before, just release all children
super.releaseStateTransferLocks(refMapNode, lockOwner, true);
}
}
catch (CacheException ce)
{
log.error("Caught exception releasing locks on internal RefMap", ce);
}
}
}
}
}
More information about the jboss-cvs-commits
mailing list