001: /*
002: * JBoss, Home of Professional Open Source.
003: * Copyright 2006, Red Hat Middleware LLC, and individual contributors
004: * as indicated by the @author tags. See the copyright.txt file in the
005: * distribution for a full listing of individual contributors.
006: *
007: * This is free software; you can redistribute it and/or modify it
008: * under the terms of the GNU Lesser General Public License as
009: * published by the Free Software Foundation; either version 2.1 of
010: * the License, or (at your option) any later version.
011: *
012: * This software is distributed in the hope that it will be useful,
013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
015: * Lesser General Public License for more details.
016: *
017: * You should have received a copy of the GNU Lesser General Public
018: * License along with this software; if not, write to the Free
019: * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
020: * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
021: */
022: package org.jboss.test.cluster.ds;
023:
024: import java.io.Serializable;
025: import java.util.Collection;
026: import java.util.Iterator;
027: import javax.management.Notification;
028: import javax.naming.InitialContext;
029:
030: import org.jboss.ha.framework.interfaces.DistributedState;
031: import org.jboss.ha.framework.interfaces.DistributedState.DSListenerEx;
032: import org.jboss.ha.framework.interfaces.HAPartition;
033: import org.jboss.logging.Logger;
034: import org.jboss.mx.util.JBossNotificationBroadcasterSupport;
035:
036: /** Tests of the DistributedState service
037:
038: @author <a href="mailto:Scott.Stark@jboss.org">Scott Stark</a>.
039: @version $Revision: 57896 $
040: */
041: public class DistributedStateUser extends
042: JBossNotificationBroadcasterSupport implements
043: IDistributedState, DSListenerEx {
044: protected static Logger log = Logger
045: .getLogger(DistributedStateUser.class);
046:
047: protected DistributedState entryMap;
048: protected String category;
049: protected String partitionName;
050: protected long sequence;
051:
052: public String getPartitionName() {
053: return partitionName;
054: }
055:
056: public void setPartitionName(String partitionName) {
057: this .partitionName = partitionName;
058: }
059:
060: public String getCategory() {
061: return category;
062: }
063:
064: public void setCategory(String category) {
065: this .category = category;
066: }
067:
068: public void start() throws Exception {
069: // Lookup the parition
070: InitialContext ctx = new InitialContext();
071: String jndiName = "/HAPartition/" + partitionName;
072: HAPartition partition = (HAPartition) ctx.lookup(jndiName);
073: this .entryMap = partition.getDistributedStateService();
074: log.debug("Obtained DistributedState from partition="
075: + partitionName);
076: entryMap.registerDSListenerEx(category, this );
077: }
078:
079: public void stop() {
080: entryMap.unregisterDSListenerEx(category, this );
081: flush();
082: }
083:
084: public Serializable get(Serializable key) {
085: Serializable value = entryMap.get(category, key);
086: log.debug("Get: " + key + ", value: " + value);
087: return value;
088: }
089:
090: public void put(Serializable key, Serializable value)
091: throws Exception {
092: entryMap.set(category, key, value, false);
093: log.debug("Put: " + key + ", value: " + value);
094: }
095:
096: public void remove(Serializable key) throws Exception {
097: Object value = entryMap.remove(category, key, false);
098: log.debug("Removed: " + key + ", value: " + value);
099: }
100:
101: public Collection listAllCategories() {
102: // return results as a vector to avoid hashmap.keyset serialization error
103: Collection cats = entryMap.getAllCategories();
104: if (cats == null || cats.isEmpty()) {
105: return new java.util.Vector();
106: }
107: java.util.Vector vcats = new java.util.Vector();
108: java.util.Iterator iter = cats.iterator();
109: while (iter.hasNext())
110: vcats.add(iter.next());
111: return vcats;
112: }
113:
114: public Collection listAllKeys(String category) {
115: // return results as a vector to avoid hashmap.keyset serialization error
116: Collection keys = entryMap.getAllKeys(category);
117: if (keys == null || keys.isEmpty()) {
118: return new java.util.Vector();
119: }
120: java.util.Vector vkeys = new java.util.Vector();
121: java.util.Iterator iter = keys.iterator();
122: while (iter.hasNext())
123: vkeys.add(iter.next());
124: return vkeys;
125: }
126:
127: public Collection listAllValues(String category) {
128: // return results as a vector to avoid hashmap.keyset serialization error
129: Collection vals = entryMap.getAllKeys(category);
130: if (vals == null || vals.isEmpty()) {
131: return new java.util.Vector();
132: }
133: java.util.Vector vvals = new java.util.Vector();
134: java.util.Iterator iter = vals.iterator();
135: while (iter.hasNext())
136: vvals.add(iter.next());
137: return vvals;
138: }
139:
140: /** Remove all entries from the cache.
141: */
142: public void flush() {
143: Collection keys = entryMap.getAllKeys(category);
144: if (keys == null)
145: return;
146: // Notify the entries of their removal
147: Iterator iter = keys.iterator();
148: while (iter.hasNext()) {
149: Serializable key = (Serializable) iter.next();
150: try {
151: entryMap.remove(category, key);
152: } catch (Exception e) {
153: log.debug("Failed to remove: " + key, e);
154: }
155: }
156: }
157:
158: public int size() {
159: return entryMap.getAllKeys(category).size();
160: }
161:
162: public void valueHasChanged(String category, Serializable key,
163: Serializable value, boolean locallyModified) {
164: NotifyData data = new NotifyData();
165: data.category = category;
166: data.key = key;
167: data.value = value;
168: data.locallyModified = locallyModified;
169: String address = System.getProperty("jboss.bind.address");
170: long id = nextSequence();
171: Notification msg = new Notification("valueHasChanged", this ,
172: id, address);
173: msg.setUserData(data);
174: log.debug("valueHasChanged, " + msg);
175: super .sendNotification(msg);
176: }
177:
178: public void keyHasBeenRemoved(String category, Serializable key,
179: Serializable previousContent, boolean locallyModified) {
180: NotifyData data = new NotifyData();
181: data.category = category;
182: data.key = key;
183: data.value = previousContent;
184: data.locallyModified = locallyModified;
185: String address = System.getProperty("jboss.bind.address");
186: long id = nextSequence();
187: Notification msg = new Notification("keyHasBeenRemoved", this ,
188: id, address);
189: msg.setUserData(data);
190: log.debug("keyHasBeenRemoved, " + msg);
191: super .sendNotification(msg);
192: }
193:
194: private synchronized long nextSequence() {
195: return sequence++;
196: }
197: }
|