[stajistics] push by troy.kin...@gmail.com - Created a FastPutsTableMap implementation of Map which is optimized fo... on 2011-06-19 20:24 GMT

[staji...@googlecode.com]

Revision: 97cbc6d35fd7
Author: troy.k...@gmail.com
Date: Sun Jun 19 13:23:35 2011
Log: Created a FastPutsTableMap implementation of Map which is
optimized for small data sets allowing lower storage costs and faster put
speeds at the expense of O(n) gets. Created an MXBean friendly String-based
open type StatsKey format. Created a JMX client: StatsManagementFactory.
http://code.google.com/p/stajistics/source/detail?r=97cbc6d35fd7

Added:

/stajistics-core/src/main/java/org/stajistics/management/MalformedOpenTypeStatsKeyException.java

/stajistics-core/src/main/java/org/stajistics/management/StatsKeyOpenTypeConverter.java

/stajistics-core/src/main/java/org/stajistics/management/StatsManagementFactory.java
/stajistics-core/src/main/java/org/stajistics/util/FastPutsTableMap.java

/stajistics-core/src/main/java/org/stajistics/util/xml/AbstractXMLBindingManager.java

/stajistics-core/src/main/java/org/stajistics/util/xml/XMLBindingManager.java

/stajistics-core/src/test/java/org/stajistics/management/AbstractJMXTestCase.java

/stajistics-core/src/test/java/org/stajistics/management/DefaultStatsMXBeanRegistrarTest.java

/stajistics-core/src/test/java/org/stajistics/management/StatsKeyOpenTypeConverterTest.java

/stajistics-core/src/test/java/org/stajistics/management/StatsMXBeanUtilTest.java

/stajistics-core/src/test/java/org/stajistics/management/StatsManagementFactoryRemoteTest.java

/stajistics-core/src/test/java/org/stajistics/management/StatsManagementFactoryTest.java

/stajistics-core/src/test/java/org/stajistics/util/FastPutsTableMapTest.java

/stajistics-core/src/test/java/org/stajistics/util/xml/AbstractXMLBindingManagerTest.java

/stajistics-core/src/test/java/org/stajistics/util/xml/testBinding/ObjectFactory.java

/stajistics-core/src/test/java/org/stajistics/util/xml/testBinding/TestBinding.java
Deleted:

/stajistics-core/src/main/java/org/stajistics/util/AbstractXMLBindingManager.java
/stajistics-core/src/main/java/org/stajistics/util/XMLBindingManager.java

/stajistics-core/src/test/java/org/stajistics/management/AbstractMXBeanTestCase.java

/stajistics-core/src/test/java/org/stajistics/management/DefaultStatsMXBeanRegistratTest.java

/stajistics-core/src/test/java/org/stajistics/util/AbstractXMLBindingManagerTest.java

/stajistics-core/src/test/java/org/stajistics/util/testbinding/ObjectFactory.java

/stajistics-core/src/test/java/org/stajistics/util/testbinding/TestBinding.java
Modified:
/stajistics-core/src/main/java/org/stajistics/DefaultStatsKeyBuilder.java
/stajistics-core/src/main/java/org/stajistics/StatsKey.java
/stajistics-core/src/main/java/org/stajistics/StatsKeyMatcher.java
/stajistics-core/src/main/java/org/stajistics/Util.java

/stajistics-core/src/main/java/org/stajistics/configuration/xml/binding/XMLConfigBindingManager.java

/stajistics-core/src/main/java/org/stajistics/data/AbstractDataContainer.java
/stajistics-core/src/main/java/org/stajistics/data/DefaultDataSet.java
/stajistics-core/src/main/java/org/stajistics/data/DefaultMetaData.java

/stajistics-core/src/main/java/org/stajistics/management/DefaultStatsMXBeanRegistrar.java

/stajistics-core/src/main/java/org/stajistics/management/StatsMXBeanRegistrar.java

/stajistics-core/src/main/java/org/stajistics/management/StatsMXBeanUtil.java

/stajistics-core/src/main/java/org/stajistics/management/StatsManagementEventHandler.java

/stajistics-core/src/main/java/org/stajistics/management/beans/DefaultStatsConfigManagerMXBean.java

/stajistics-core/src/main/java/org/stajistics/management/beans/DefaultStatsSessionManagerMXBean.java

/stajistics-core/src/main/java/org/stajistics/management/beans/StatsConfigManagerMXBean.java

/stajistics-core/src/main/java/org/stajistics/management/beans/StatsSessionMXBean.java

/stajistics-core/src/main/java/org/stajistics/management/beans/StatsSessionManagerMXBean.java

/stajistics-core/src/main/java/org/stajistics/session/AbstractStatsSession.java

/stajistics-core/src/main/java/org/stajistics/session/DefaultSessionManager.java

/stajistics-core/src/main/java/org/stajistics/session/StatsSessionManager.java

/stajistics-core/src/test/java/org/stajistics/DefaultStatsKeyBuilderTest.java

/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsConfigMXBeanTest.java

/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsConfigManagerMXBeanTest.java

/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsManagerMXBeanTest.java

/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsSessionMXBeanTest.java

/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsSessionManagerMXBeanTest.java

=======================================
--- /dev/null
+++
/stajistics-core/src/main/java/org/stajistics/management/MalformedOpenTypeStatsKeyException.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,26 @@
+package org.stajistics.management;
+
+/**
+ *
+ *
+ * @author The Stajistics Project
+ */
+public class MalformedOpenTypeStatsKeyException extends RuntimeException {
+
+ public MalformedOpenTypeStatsKeyException() {
+ super();
+ }
+
+ public MalformedOpenTypeStatsKeyException(String message, Throwable
cause) {
+ super(message, cause);
+ }
+
+ public MalformedOpenTypeStatsKeyException(String message) {
+ super(message);
+ }
+
+ public MalformedOpenTypeStatsKeyException(Throwable cause) {
+ super(cause);
+ }
+
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/main/java/org/stajistics/management/StatsKeyOpenTypeConverter.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,187 @@
+package org.stajistics.management;
+
+import org.stajistics.DefaultStatsKeyFactory;
+import org.stajistics.StatsKey;
+import org.stajistics.StatsKeyBuilder;
+import org.stajistics.StatsKeyFactory;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ *
+ *
+ * @author The Stajistics Project
+ */
+public class StatsKeyOpenTypeConverter {
+
+ private static final String KEY_ATTRS_DELIMITER = ":";
+ private static final String ATTR_NAME_VALUE_PAIR_DELIMITER = "&";
+ private static final String ATTR_NAME_VALUE_DELIMITER = "=";
+
+ private static final String ATTR_PREFIX_BOOLEAN = "b_";
+ private static final String ATTR_PREFIX_INTEGER = "i_";
+ private static final String ATTR_PREFIX_LONG = "l_";
+
+ private static final Pattern KEY_ATTRS_SPLITTER =
Pattern.compile("(?<!\\\\)[:]");
+ private static final Pattern ATTR_NAME_VALUE_PAIR_SPLITTER =
Pattern.compile("(?<!\\\\)[&]");
+ private static final Pattern ATTR_NAME_VALUE_SPLITTER =
Pattern.compile("(?<!\\\\)[=]");
+
+ private static final Pattern KEY_ATTRS_UNESCAPE =
Pattern.compile("\\\\:");
+ private static final Pattern ATTR_NAME_VALUE_PAIR_UNESCAPE =
Pattern.compile("\\\\&");
+ private static final Pattern ATTR_NAME_VALUE_UNESCAPE =
Pattern.compile("\\\\=");
+
+ public Set<String> toOpenType(final Set<StatsKey> keys) {
+ Set<String> result = new HashSet<String>(keys.size());
+
+ for (StatsKey key : keys) {
+ result.add(toOpenType(key));
+ }
+
+ return Collections.unmodifiableSet(result);
+ }
+
+ public String toOpenType(final StatsKey key) {
+ StringBuilder buf = new StringBuilder(key.getName().length() +
(key.getAttributeCount() * 10));
+
+ String keyName = key.getName();
+
+ buf.append(escapePart(keyName));
+
+ if (key.getAttributeCount() > 0) {
+
+ buf.append(KEY_ATTRS_DELIMITER);
+
+ for (Map.Entry<String, Object> entry :
key.getAttributes().entrySet()) {
+ Object value = entry.getValue();
+ Class<?> valueClass = value.getClass();
+
+ String strValue = value.toString();
+
+ if (valueClass == Boolean.class) {
+ Boolean b = (Boolean) value;
+ strValue = ATTR_PREFIX_BOOLEAN + (b ? 't' : 'f');
+ } else if (valueClass == Integer.class) {
+ strValue = ATTR_PREFIX_INTEGER + strValue;
+ } else if (valueClass == Long.class) {
+ strValue = ATTR_PREFIX_LONG + strValue;
+ }
+
+ buf.append(escapePart(entry.getKey()));
+ buf.append(ATTR_NAME_VALUE_DELIMITER);
+ buf.append(escapePart(strValue));
+ buf.append(ATTR_NAME_VALUE_PAIR_DELIMITER);
+ }
+
+ if (buf.charAt(buf.length() - 1) ==
ATTR_NAME_VALUE_PAIR_DELIMITER.charAt(0)) {
+ buf.setLength(buf.length() - 1);
+ }
+ }
+
+ return buf.toString();
+ }
+
+ public Set<StatsKey> fromOpenType(final Set<String> keys) {
+ StatsKeyFactory factory = createStatsKeyFactory();
+ Set<StatsKey> result = new HashSet<StatsKey>();
+
+ for (String key : keys) {
+ result.add(fromOpenType(key, factory));
+ }
+
+ return Collections.unmodifiableSet(result);
+ }
+
+ public StatsKey fromOpenType(final String openTypeKey) {
+ StatsKeyFactory factory = createStatsKeyFactory();
+ return fromOpenType(openTypeKey, factory);
+ }
+
+ protected StatsKey fromOpenType(final String openTypeKey, final
StatsKeyFactory factory) {
+ String[] parts = KEY_ATTRS_SPLITTER.split(openTypeKey, 2);
+ if (parts.length > 2) {
+ throw new MalformedOpenTypeStatsKeyException(openTypeKey);
+ }
+
+ StatsKeyBuilder builder =
factory.createKeyBuilder(unescapePart(parts[0]));
+
+ if (parts.length > 1) {
+ String attributes = unescapeKeyAttrDelimiter(parts[1]);
+ String[] nameValuePairParts =
ATTR_NAME_VALUE_PAIR_SPLITTER.split(attributes);
+ for (String nameValuePair : nameValuePairParts) {
+ nameValuePair =
unescapeAttrNameValuePairDelimiter(nameValuePair);
+ String[] nameValueParts =
ATTR_NAME_VALUE_SPLITTER.split(nameValuePair);
+ if (nameValueParts.length != 2) {
+ throw new
MalformedOpenTypeStatsKeyException(openTypeKey);
+ }
+
+ final String name =
unescapeAttrNameValueDelimiter(nameValueParts[0]);
+ final String strValue =
unescapeAttrNameValueDelimiter(nameValueParts[1]);
+
+ if (strValue.startsWith(ATTR_PREFIX_BOOLEAN)) {
+ Boolean value =
strValue.substring(ATTR_PREFIX_BOOLEAN.length()).equals("t");
+ builder.withAttribute(name, value);
+
+ } else if (strValue.startsWith(ATTR_PREFIX_INTEGER)) {
+ Integer value =
Integer.parseInt(strValue.substring(ATTR_PREFIX_INTEGER.length()));
+ builder.withAttribute(name, value);
+
+ } else if (strValue.startsWith(ATTR_PREFIX_LONG)) {
+ Long value =
Long.parseLong(strValue.substring(ATTR_PREFIX_LONG.length()));
+ builder.withAttribute(name, value);
+
+ } else {
+ builder.withAttribute(name, strValue);
+ }
+ }
+ }
+
+ return builder.newKey();
+ }
+
+ private String escapePart(String part) {
+ Matcher m = KEY_ATTRS_SPLITTER.matcher(part);
+ part = m.replaceAll("\\\\:");
+
+ m = ATTR_NAME_VALUE_PAIR_SPLITTER.matcher(part);
+ part = m.replaceAll("\\\\&");
+
+ m = ATTR_NAME_VALUE_SPLITTER.matcher(part);
+ part = m.replaceAll("\\\\=");
+
+ return part;
+ }
+
+ private String unescapePart(String part) {
+ part = unescapeKeyAttrDelimiter(part);
+ part = unescapeAttrNameValuePairDelimiter(part);
+ part = unescapeAttrNameValueDelimiter(part);
+ return part;
+ }
+
+ private String unescapeKeyAttrDelimiter(String part) {
+ Matcher m = KEY_ATTRS_UNESCAPE.matcher(part);
+ part = m.replaceAll(KEY_ATTRS_DELIMITER);
+ return part;
+ }
+
+ private String unescapeAttrNameValuePairDelimiter(String part) {
+ Matcher m = ATTR_NAME_VALUE_PAIR_UNESCAPE.matcher(part);
+ part = m.replaceAll(ATTR_NAME_VALUE_PAIR_DELIMITER);
+ return part;
+ }
+
+ private String unescapeAttrNameValueDelimiter(String part) {
+ Matcher m = ATTR_NAME_VALUE_UNESCAPE.matcher(part);
+ part = m.replaceAll(ATTR_NAME_VALUE_DELIMITER);
+ return part;
+ }
+
+ protected StatsKeyFactory createStatsKeyFactory() {
+ return new DefaultStatsKeyFactory();
+ }
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/main/java/org/stajistics/management/StatsManagementFactory.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,215 @@
+package org.stajistics.management;
+
+import org.stajistics.StatsKey;
+import org.stajistics.management.beans.StatsConfigManagerMXBean;
+import org.stajistics.management.beans.StatsManagerMXBean;
+import org.stajistics.management.beans.StatsSessionManagerMXBean;
+
+import javax.management.JMX;
+import javax.management.MBeanServerConnection;
+import javax.management.MalformedObjectNameException;
+import javax.management.ObjectName;
+import javax.management.remote.JMXConnector;
+import javax.management.remote.JMXConnectorFactory;
+import javax.management.remote.JMXServiceURL;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import static org.stajistics.management.StatsMXBeanUtil.*;
+
+/**
+ *
+ *
+ * @author The Stajistics Project
+ */
+public class StatsManagementFactory {
+
+ private final MBeanServerConnection mBeanServerConnection;
+
+ /**
+ *
+ * @param mBeanServerConnection
+ */
+ public StatsManagementFactory(final MBeanServerConnection
mBeanServerConnection) {
+ if (mBeanServerConnection == null) {
+ throw new NullPointerException("null mBeanServerConnection");
+ }
+ this.mBeanServerConnection = mBeanServerConnection;
+ }
+
+ /**
+ *
+ * @param serviceURL
+ * @return
+ * @throws IOException
+ */
+ public static StatsManagementFactory forURL(final String serviceURL)
throws IOException {
+ JMXServiceURL u = new JMXServiceURL(serviceURL);
+ JMXConnector connector = JMXConnectorFactory.connect(u, null);
+ MBeanServerConnection connection =
connector.getMBeanServerConnection();
+
+ return new StatsManagementFactory(connection);
+ }
+
+ public MBeanServerConnection getMBeanServerConnection() {
+ return mBeanServerConnection;
+ }
+
+ /**
+ *
+ * @return
+ * @throws IOException
+ * @throws MalformedObjectNameException
+ */
+ public Set<String> getNamespaces() throws IOException,
MalformedObjectNameException {
+ Set<ObjectName> objectNames = getStatsManagerObjectNames();
+ Set<String> namespaces = new HashSet<String>(objectNames.size());
+
+ for (ObjectName objectName : objectNames) {
+ String namespace =
objectName.getKeyProperty(OBJECT_NAME_ATTR_NAMESPACE);
+ namespaces.add(namespace);
+ }
+
+ return Collections.unmodifiableSet(namespaces);
+ }
+
+ /**
+ *
+ * @return
+ * @throws IOException
+ * @throws MalformedObjectNameException
+ */
+ public Set<ObjectName> getStatsManagerObjectNames() throws
IOException, MalformedObjectNameException {
+ ObjectName objectName = new
ObjectName(getStatsManagerObjectNameString("*", false));
+ return getObjectNames(objectName);
+ }
+
+ /**
+ *
+ * @return
+ * @throws IOException
+ * @throws MalformedObjectNameException
+ */
+ public Set<ObjectName> getSessionManagerObjectNames() throws
IOException, MalformedObjectNameException {
+ ObjectName objectName = new
ObjectName(getSessionManagerObjectNameString("*", false));
+ return getObjectNames(objectName);
+ }
+
+ /**
+ *
+ * @return
+ * @throws IOException
+ * @throws MalformedObjectNameException
+ */
+ public Set<ObjectName> getConfigManagerObjectNames() throws
MalformedObjectNameException, IOException {
+ ObjectName objectName = new
ObjectName(getConfigManagerObjectNameString("*", false));
+ return getObjectNames(objectName);
+ }
+
+ /**
+ *
+ * @param namespace
+ * @return
+ * @throws MalformedObjectNameException
+ */
+ public StatsManagerMXBean getStatsManagerMXBean(final String
namespace) throws MalformedObjectNameException {
+ return newProxy(getStatsManagerObjectName(namespace),
StatsManagerMXBean.class);
+ }
+
+ /**
+ *
+ * @param namespace
+ * @return
+ * @throws MalformedObjectNameException
+ */
+ public StatsSessionManagerMXBean getSessionManagerMXBean(final String
namespace) throws MalformedObjectNameException {
+ return newProxy(getSessionManagerObjectName(namespace),
StatsSessionManagerMXBean.class);
+ }
+
+ /**
+ *
+ * @param namespace
+ * @return
+ * @throws MalformedObjectNameException
+ */
+ public StatsConfigManagerMXBean getConfigManagerMXBean(final String
namespace) throws MalformedObjectNameException {
+ return newProxy(getConfigManagerObjectName(namespace),
StatsConfigManagerMXBean.class);
+ }
+
+
+ /**
+ *
+ * @return
+ * @throws IOException
+ * @throws MalformedObjectNameException
+ */
+ public Set<StatsManagerMXBean> getStatsManagerMXBeans() throws
IOException, MalformedObjectNameException {
+ return newProxies(getStatsManagerObjectNames(),
StatsManagerMXBean.class);
+ }
+
+ /**
+ *
+ * @return
+ * @throws MalformedObjectNameException
+ * @throws IOException
+ */
+ public Set<StatsSessionManagerMXBean> getSessionManagerMXBeans()
throws MalformedObjectNameException, IOException {
+ return newProxies(getSessionManagerObjectNames(),
StatsSessionManagerMXBean.class);
+ }
+
+ /**
+ *
+ * @param namespace
+ * @return
+ * @throws MalformedObjectNameException
+ */
+ public Set<StatsKey> getKeys(final String namespace) throws
MalformedObjectNameException {
+ StatsSessionManagerMXBean sessionMXBean =
getSessionManagerMXBean(namespace);
+ Set<String> openKeys = sessionMXBean.statsKeys();
+ StatsKeyOpenTypeConverter converter = new
StatsKeyOpenTypeConverter();
+ return converter.fromOpenType(openKeys);
+ }
+
+
+ /**
+ *
+ * @param objectName
+ * @return
+ * @throws IOException
+ */
+ protected Set<ObjectName> getObjectNames(final ObjectName objectName)
throws IOException {
+ Set<ObjectName> objectNames =
mBeanServerConnection.queryNames(objectName, null);
+ return Collections.unmodifiableSet(objectNames);
+ }
+
+ /**
+ *
+ * @param <T>
+ * @param objectName
+ * @param interfaceClass
+ * @return
+ */
+ protected <T> T newProxy(final ObjectName objectName, final Class<T>
interfaceClass) {
+ T proxy = JMX.newMXBeanProxy(mBeanServerConnection, objectName,
interfaceClass);
+ return proxy;
+ }
+
+ /**
+ *
+ * @param <T>
+ * @param objectNames
+ * @param interfaceClass
+ * @return
+ */
+ protected <T> Set<T> newProxies(final Set<ObjectName> objectNames,
final Class<T> interfaceClass) {
+ Set<T> proxies = new HashSet<T>(objectNames.size());
+
+ for (ObjectName objectName : objectNames) {
+ proxies.add(newProxy(objectName, interfaceClass));
+ }
+
+ return Collections.unmodifiableSet(proxies);
+ }
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/main/java/org/stajistics/util/FastPutsTableMap.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,189 @@
+package org.stajistics.util;
+
+import java.util.*;
+
+/**
+ * Optimised for very small data sets, allowing compact size and fast puts
at the expense of O(n) lookups. This implementation
+ * may store duplicate entries for the same key. TODO: explain more.
+ *
+ * @author The Stajistics Project
+ */
+public class FastPutsTableMap<K,V> extends AbstractMap<K,V> {
+
+ private static final int UNKNOWN_SIZE = 0; // Zero so that the size is
unknown after deserialization
+
+ protected final ArrayList<Entry<K,V>> entries;
+ protected transient int size = UNKNOWN_SIZE;
+ protected transient Set<Entry<K,V>> entrySet = null;
+
+ public FastPutsTableMap() {
+ this(4);
+ }
+
+ public FastPutsTableMap(final int initialCapacity) {
+ entries = new ArrayList<Entry<K,V>>(initialCapacity);
+ }
+
+ public FastPutsTableMap(final Map<K,V> map) {
+ this(map.size());
+ putAll(map);
+ }
+
+ public void compact() {
+
+ // Iterate forwards looking for duplicate entries and deleting the
old ones
+ Entry<K,V> e;
+ Entry<K,V> possibleDup;
+ for (final Iterator<Entry<K,V>> itr = entries.iterator();
itr.hasNext(); ) {
+ e = itr.next();
+ possibleDup = getEntry(e.getKey()); // Returns the newest entry
+ if (possibleDup != null && e != possibleDup) {
+ itr.remove();
+ }
+ }
+
+ size = entries.size(); // We now know the size
+
+ // Compact the underlying array
+ entries.trimToSize();
+ }
+
+ @Override
+ public int size() {
+ if (entries.isEmpty()) {
+ return 0;
+ }
+
+ if (size > 0) {
+ return size;
+ }
+
+ compact();
+ return size;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return entries.isEmpty();
+ }
+
+ @Override
+ public boolean containsValue(final Object aValue) {
+ V value;
+ if (aValue == null) {
+ for (int i = entries.size() - 1; i >= 0; i--) {
+ value = entries.get(i).getValue();
+ if (value == null) {
+ return true;
+ }
+ }
+ } else {
+ for (int i = entries.size() - 1; i >= 0; i--) {
+ value = entries.get(i).getValue();
+ if (aValue.equals(value)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public boolean containsKey(final Object key) {
+ return getEntry(key) != null;
+ }
+
+ @Override
+ public V get(final Object key) {
+ Entry<K,V> e = getEntry(key);
+ if (e != null) {
+ return e.getValue();
+ }
+ return null;
+ }
+
+ protected Entry<K,V> getEntry(final Object key) {
+ Entry<K,V> e;
+
+ // Search in reverse so we find the most up to date value in the
event of duplicates
+ for (int i = entries.size() - 1; i >= 0; i--) {
+ e = entries.get(i);
+ if (e.getKey().equals(key)) {
+ return e;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Note: contract broken! Always returns null.
+ */
+ @Override
+ public V put(final K key, final V value) {
+ if (key == null) {
+ throw new NullPointerException("key");
+ }
+ entries.add(new SimpleEntry<K,V>(key, value));
+ size = UNKNOWN_SIZE;
+ return null;
+ }
+
+ @Override
+ public void putAll(final Map<? extends K, ? extends V> map) {
+ for (Entry<? extends K, ? extends V> entry : map.entrySet()) {
+ put(entry.getKey(), entry.getValue());
+ }
+ }
+
+ @Override
+ public V remove(final Object key) {
+ if (key == null) {
+ return null;
+ }
+
+ Entry<K,V> e;
+ V value = null;
+
+ // Search in reverse so we find the most up to date value in the
event of duplicates
+ ListIterator<Entry<K,V>> itr =
entries.listIterator(entries.size());
+ while (itr.hasPrevious()) {
+ e = itr.previous();
+ if (e.getKey().equals(key)) {
+ if (value == null) {
+ value = e.getValue(); // Keep the newest value
+ }
+ itr.remove();
+ size = UNKNOWN_SIZE;
+ // Keep searching for duplicates
+ }
+ }
+
+ return value;
+ }
+
+ @Override
+ public void clear() {
+ entries.clear();
+ size = 0;
+ }
+
+ @Override
+ public Set<Entry<K, V>> entrySet() {
+ if (entrySet == null) {
+ entrySet = new AbstractSet<Entry<K,V>>() {
+ @Override
+ public Iterator<Entry<K, V>> iterator() {
+ compact();
+ return entries.iterator();
+ }
+
+ @Override
+ public int size() {
+ return FastPutsTableMap.this.size();
+ }
+ };
+ }
+
+ return entrySet;
+ }
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/main/java/org/stajistics/util/xml/AbstractXMLBindingManager.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,115 @@
+package org.stajistics.util.xml;
+
+import javax.xml.bind.*;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+import java.io.*;
+
+/**
+ * @author The Stajistics Project
+ */
+public abstract class AbstractXMLBindingManager<T> implements
XMLBindingManager<T> {
+
+ protected String encoding = DEFAULT_ENCODING;
+
+ protected abstract Class<T> getRootElementType();
+
+ public String getEncoding() {
+ return encoding;
+ }
+
+ public void setEncoding(final String encoding) {
+ if (encoding == null) {
+ throw new NullPointerException("encoding");
+ }
+
+ this.encoding = encoding;
+ }
+
+ public T unmarshal(final String in) {
+ return unmarshal(new StringReader(in));
+ }
+
+ public T unmarshal(final File in) {
+ StreamSource src = new StreamSource(in);
+ try {
+ return unmarshal(src);
+ } catch (JAXBException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public T unmarshal(final Reader in) {
+ StreamSource src = new StreamSource(in);
+ try {
+ return unmarshal(src);
+ } catch (JAXBException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public T unmarshal(final InputStream in) {
+ StreamSource src = new StreamSource(in);
+ try {
+ return unmarshal(src);
+ } catch (JAXBException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public String marshal(final T binding) {
+ StringWriter out = new StringWriter(4 * 1024);
+ marshal(binding, out);
+ return out.toString();
+ }
+
+ public void marshal(final T binding,
+ final OutputStream out) {
+ StreamResult result = new StreamResult(out);
+ try {
+ marshal(binding, result);
+ } catch (JAXBException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public void marshal(final T binding,
+ final Writer out) {
+ StreamResult result = new StreamResult(out);
+ try {
+ marshal(binding, result);
+ } catch (JAXBException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public void marshal(final T binding,
+ final File out) {
+ StreamResult result = new StreamResult(out);
+ try {
+ marshal(binding, result);
+ } catch (JAXBException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ protected JAXBContext getJAXBContext() throws JAXBException {
+ return
JAXBContext.newInstance(getRootElementType().getPackage().getName());
+ }
+
+ protected T unmarshal(final StreamSource source) throws JAXBException {
+ Unmarshaller unmarshaller = getJAXBContext().createUnmarshaller();
+ JAXBElement<T> root = unmarshaller.unmarshal(source,
getRootElementType());
+ T result = root.getValue();
+ return result;
+ }
+
+ protected void marshal(final T binding,
+ final StreamResult out) throws JAXBException {
+ Marshaller marshaller = getJAXBContext().createMarshaller();
+ marshaller.setProperty(Marshaller.JAXB_ENCODING, encoding);
+
+ marshaller.marshal(binding, out);
+ }
+
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/main/java/org/stajistics/util/xml/XMLBindingManager.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,46 @@
+/* Copyright 2009 - 2010 The Stajistics Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.stajistics.util.xml;
+
+import java.io.*;
+
+/**
+ * @author The Stajistics Project
+ */
+public interface XMLBindingManager<T> {
+
+ public static final String DEFAULT_ENCODING = "UTF-8";
+
+ String getEncoding();
+
+ void setEncoding(String encoding);
+
+ T unmarshal(String in);
+
+ T unmarshal(File in);
+
+ T unmarshal(Reader in);
+
+ T unmarshal(InputStream in);
+
+ String marshal(T binding);
+
+ void marshal(T binding, OutputStream out);
+
+ void marshal(T binding, Writer out);
+
+ void marshal(T binding, File out);
+
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/test/java/org/stajistics/management/AbstractJMXTestCase.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,129 @@
+/* Copyright 2009 - 2010 The Stajistics Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.stajistics.management;
+
+import org.junit.After;
+import org.junit.Before;
+import org.stajistics.AbstractStajisticsTestCase;
+
+import javax.management.*;
+import javax.management.remote.*;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.rmi.RemoteException;
+import java.rmi.registry.LocateRegistry;
+import java.rmi.registry.Registry;
+
+/**
+ * Thanks to Eamonn McManus for the MBean testing strategy:
+ *
http://weblogs.java.net/blog/emcmanus/archive/2006/07/unit_testing_re.html
+ *
+ * @author The Stajistics Project
+ */
+public abstract class AbstractJMXTestCase extends
AbstractStajisticsTestCase {
+
+ private static final Registry rmiRegistry;
+ static {
+ try {
+ rmiRegistry = LocateRegistry.createRegistry(getPort());
+ } catch (RemoteException e) {
+ throw new ExceptionInInitializerError(e);
+ }
+ }
+
+ private MBeanServer mBeanServer = null;
+ private JMXConnector connector = null;
+ private JMXConnectorServer connectorServer = null;
+ private MBeanServerConnection mBeanServerConnection = null;
+
+ @Before
+ public void setUpMBeanServerConnection() throws Exception {
+
+ mBeanServer = MBeanServerFactory.newMBeanServer();
+
+ JMXServiceURL url = getJMXServiceURL();
+ connectorServer =
JMXConnectorServerFactory.newJMXConnectorServer(url, null, mBeanServer);
+ connectorServer.start();
+
+ JMXServiceURL addr = connectorServer.getAddress();
+ connector = JMXConnectorFactory.connect(addr);
+ mBeanServerConnection = connector.getMBeanServerConnection();
+ }
+
+ @After
+ public void tearDownMBeanServerConnection() throws Exception {
+
+ if (connector != null) {
+ try {
+ connector.close();
+ } catch (IOException ioe) {}
+ }
+
+ if (connectorServer != null) {
+ try {
+ connectorServer.stop();
+ } catch (IOException ioe) {}
+ }
+
+ mBeanServer = null;
+ connector = null;
+ connectorServer = null;
+ mBeanServerConnection = null;
+ }
+
+ protected MBeanServer getMBeanServer() {
+ if (mBeanServer == null) {
+ throw new RuntimeException("MBeanServer not initialized");
+ }
+
+ return mBeanServer;
+ }
+
+ protected MBeanServerConnection getMBeanServerConnection() {
+ if (mBeanServerConnection == null) {
+ throw new RuntimeException("MBeanServerConnection not
initialized");
+ }
+
+ return mBeanServerConnection;
+ }
+
+ protected <T> T registerMBean(final T mBean,
+ final ObjectName name,
+ final Class<T> mBeanInterfaceClass)
throws Exception {
+
+ // Register with the local server
+ mBeanServer.registerMBean(mBean, name);
+
+ // Create a proxy to the remote MBean
+ T remoteMBean = JMX.newMBeanProxy(mBeanServerConnection,
+ name,
+ mBeanInterfaceClass);
+
+ return remoteMBean;
+ }
+
+ protected static int getPort() {
+ return Integer.getInteger(AbstractJMXTestCase.class.getName()
+ ".rmiPort", 2099);
+ }
+
+ protected String getServiceURL() {
+ return "service:jmx:rmi:///jndi/rmi://127.0.0.1:" + getPort()
+ "/unitTestServer";
+ }
+
+ protected JMXServiceURL getJMXServiceURL() throws
MalformedURLException {
+ JMXServiceURL url = new JMXServiceURL(getServiceURL());
+ return url;
+ }
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/test/java/org/stajistics/management/DefaultStatsMXBeanRegistrarTest.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,315 @@
+/* Copyright 2009 - 2010 The Stajistics Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.stajistics.management;
+
+import org.jmock.Expectations;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.stajistics.AbstractStajisticsTestCase;
+import org.stajistics.StatsKey;
+import org.stajistics.StatsManager;
+import org.stajistics.configuration.StatsConfig;
+import org.stajistics.configuration.StatsConfigBuilderFactory;
+import org.stajistics.configuration.StatsConfigManager;
+import org.stajistics.management.beans.*;
+import org.stajistics.session.StatsSession;
+import org.stajistics.session.StatsSessionManager;
+
+import javax.management.MBeanServer;
+import javax.management.MBeanServerFactory;
+import javax.management.ObjectName;
+
+import static org.junit.Assert.*;
+import static org.stajistics.TestUtil.buildStatsKeyExpectations;
+import static org.stajistics.management.StatsMXBeanUtil.*;
+
+/**
+ *
+ *
+ *
+ * @author The Stajistics Project
+ */
+public class DefaultStatsMXBeanRegistrarTest extends
AbstractStajisticsTestCase {
+
+ private static final String NAMESPACE = "ns";
+
+ private static final String NORMAL = "normal";
+
+ private StatsKey mockKey;
+ private StatsMXBeanFactory mockMBeanFactory;
+ private StatsManager mockStatsManager;
+ private StatsSessionManager mockSessionManager;
+ private StatsConfigManager mockConfigManager;
+
+ private MBeanServer mBeanServer;
+
+ private DefaultStatsMXBeanRegistrar mxBeanRegistrar;
+
+ @Before
+ public void setUp() {
+ mockKey = mockery.mock(StatsKey.class);
+ mockStatsManager = mockery.mock(StatsManager.class);
+ mockSessionManager = mockery.mock(StatsSessionManager.class);
+ mockConfigManager = mockery.mock(StatsConfigManager.class);
+ mockMBeanFactory = mockery.mock(StatsMXBeanFactory.class);
+
+ mBeanServer = MBeanServerFactory.newMBeanServer();
+
+ mxBeanRegistrar = new DefaultStatsMXBeanRegistrar(NAMESPACE,
mockMBeanFactory, mBeanServer);
+
+ mockery.checking(new Expectations() {{
+ allowing(mockStatsManager).getNamespace();
+ will(returnValue(NAMESPACE));
+ }});
+ }
+
+ @After
+ public void tearDown() {
+ mxBeanRegistrar = null;
+ }
+
+ @Test
+ public void testConstructWithNullNamespace() {
+ try {
+ new DefaultStatsMXBeanRegistrar(null, mockMBeanFactory,
MBeanServerFactory.newMBeanServer());
+ } catch (NullPointerException npe) {
+ assertEquals("namespace", npe.getMessage());
+ }
+ }
+
+ @Test
+ public void testConstructWithEmptyNamespace() {
+ try {
+ new DefaultStatsMXBeanRegistrar("", mockMBeanFactory,
MBeanServerFactory.newMBeanServer());
+ } catch (IllegalArgumentException e) {
+ assertEquals("empty namespace", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testConstructWithNullMBeanFactory() {
+ try {
+ new DefaultStatsMXBeanRegistrar(NAMESPACE, null,
MBeanServerFactory.newMBeanServer());
+ } catch (NullPointerException npe) {
+ assertEquals("mBeanFactory", npe.getMessage());
+ }
+ }
+
+ @Test
+ public void testConstructWithNullMBeanServer() {
+ try {
+ new DefaultStatsMXBeanRegistrar(NAMESPACE, mockMBeanFactory,
null);
+ } catch (NullPointerException npe) {
+ assertEquals("mBeanServer", npe.getMessage());
+ }
+ }
+
+ @Test
+ public void testGetMBeanServer() {
+ assertSame(mBeanServer, mxBeanRegistrar.getMBeanServer());
+ }
+
+ @Test
+ public void testRegisterManagerMBean() throws Exception {
+
+ final StatsManagerMXBean mockManagerMBean =
mockery.mock(StatsManagerMXBean.class);
+
+ mockery.checking(new Expectations() {{
+ one(mockMBeanFactory).createManagerMBean(mockStatsManager);
+ will(returnValue(mockManagerMBean));
+ }});
+
+ ObjectName objectName = new ObjectName(buildManagerName(NAMESPACE,
MANAGER_NAME_STATS, true));
+
+ assertTrue(mBeanServer.queryMBeans(objectName, null).isEmpty());
+ mxBeanRegistrar.registerStatsManagerMXBean(mockStatsManager);
+ assertEquals(1, mBeanServer.queryMBeans(objectName, null).size());
+ }
+
+ @Test
+ public void testUnregisterManagerMBean() throws Exception {
+ ObjectName objectName = new
ObjectName(buildManagerName(NAMESPACE,MANAGER_NAME_STATS, true));
+
+ final StatsManagerMXBean mockManagerMBean =
mockery.mock(StatsManagerMXBean.class);
+
+ mBeanServer.registerMBean(mockManagerMBean, objectName);
+
+ mxBeanRegistrar.unregisterStatsManagerMXBean(mockStatsManager);
+ assertTrue(mBeanServer.queryMBeans(objectName, null).isEmpty());
+ }
+
+ @Test
+ public void testRegisterSessionManagerMBean() throws Exception {
+
+ final StatsSessionManagerMXBean mockSessionManagerMBean =
mockery.mock(StatsSessionManagerMXBean.class);
+
+ mockery.checking(new Expectations() {{
+
one(mockMBeanFactory).createSessionManagerMBean(with(mockSessionManager));
+ will(returnValue(mockSessionManagerMBean));
+ }});
+
+ ObjectName objectName = new ObjectName(buildManagerName(NAMESPACE,
MANAGER_NAME_SESSION, true));
+ assertTrue(mBeanServer.queryMBeans(objectName, null).isEmpty());
+ mxBeanRegistrar.registerSessionManagerMXBean(mockSessionManager);
+ assertEquals(1, mBeanServer.queryMBeans(objectName, null).size());
+ }
+
+ @Test
+ public void testUnregisterSessionManagerMBean() throws Exception {
+ ObjectName objectName = new ObjectName(buildManagerName(NAMESPACE,
MANAGER_NAME_SESSION, true));
+ final StatsSessionManagerMXBean mockSessionManagerMBean =
mockery.mock(StatsSessionManagerMXBean.class);
+
+ mBeanServer.registerMBean(mockSessionManagerMBean, objectName);
+
+ mxBeanRegistrar.unregisterSessionManagerMXBean();
+ assertTrue(mBeanServer.queryMBeans(objectName, null).isEmpty());
+ }
+
+ @Test
+ public void testRegisterConfigManagerMBean() throws Exception {
+
+ final StatsConfigManagerMXBean mockConfigManagerMBean =
mockery.mock(StatsConfigManagerMXBean.class);
+
+ mockery.checking(new Expectations() {{
+
one(mockMBeanFactory).createConfigManagerMBean(mockConfigManager);
+ will(returnValue(mockConfigManagerMBean));
+ }});
+
+ ObjectName objectName = new
ObjectName(buildManagerName(NAMESPACE,MANAGER_NAME_CONFIG, true));
+ assertTrue(mBeanServer.queryMBeans(objectName, null).isEmpty());
+ mxBeanRegistrar.registerConfigManagerMXBean(mockConfigManager);
+ assertEquals(1, mBeanServer.queryMBeans(objectName, null).size());
+ }
+
+ @Test
+ public void testUnregisterConfigManagerMBean() throws Exception {
+ ObjectName objectName = new ObjectName(buildManagerName(NAMESPACE,
MANAGER_NAME_CONFIG, true));
+ final StatsConfigManagerMXBean mockConfigManagerMBean =
mockery.mock(StatsConfigManagerMXBean.class);
+
+ mBeanServer.registerMBean(mockConfigManagerMBean, objectName);
+
+ mxBeanRegistrar.unregisterConfigManagerMXBean();
+ assertTrue(mBeanServer.queryMBeans(objectName, null).isEmpty());
+ }
+
+ @Test
+ public void testRegisterConfigMBean() throws Exception {
+
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL);
+
+ final StatsConfig mockConfig = mockery.mock(StatsConfig.class);
+ final StatsConfigBuilderFactory mockConfigBuilderFactory =
mockery.mock(StatsConfigBuilderFactory.class);
+ final StatsConfigMXBean mockConfigMBean =
mockery.mock(StatsConfigMXBean.class);
+
+ mockery.checking(new Expectations() {{
+ allowing(mockStatsManager).getConfigBuilderFactory();
will(returnValue(mockConfigBuilderFactory));
+ one(mockMBeanFactory).createConfigMBean(NAMESPACE, mockKey,
mockConfig); will(returnValue(mockConfigMBean));
+ ignoring(mockConfig);
+ }});
+
+ ObjectName name = new ObjectName(buildKeyName(NAMESPACE, mockKey,
TYPE_KEYS, SUBTYPE_CONFIG, true));
+
+ assertTrue(mBeanServer.queryMBeans(name, null).isEmpty());
+ mxBeanRegistrar.registerConfigMXBean(mockKey, mockConfig);
+ assertEquals(1, mBeanServer.queryMBeans(name, null).size());
+ }
+
+ @Test
+ public void testUnregisterConfigMBeanIfNecessary() throws Exception {
+
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL);
+
+ final StatsConfig mockConfig = mockery.mock(StatsConfig.class);
+ final StatsConfigMXBean mockConfigMbean =
mockery.mock(StatsConfigMXBean.class);
+
+ mockery.checking(new Expectations() {{
+ ignoring(mockConfig);
+ }});
+
+ ObjectName name = new ObjectName(buildKeyName(NAMESPACE, mockKey,
TYPE_KEYS, SUBTYPE_CONFIG, true));
+
+ mBeanServer.registerMBean(mockConfigMbean, name);
+
+ mxBeanRegistrar.unregisterConfigMXBeanIfNecessary(mockKey);
+ assertTrue(mBeanServer.queryMBeans(name, null).isEmpty());
+ }
+
+ @Test
+ public void testUnregisterConfigMBeanIfNotNecessary() throws Exception
{
+
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL);
+
+ ObjectName name = new ObjectName(buildKeyName(NAMESPACE, mockKey,
TYPE_KEYS, SUBTYPE_SESSION, true));
+
+ mxBeanRegistrar.unregisterConfigMXBeanIfNecessary(mockKey);
+ assertTrue(mBeanServer.queryMBeans(name, null).isEmpty());
+ }
+
+ @Test
+ public void testRegisterSessionMBean() throws Exception {
+
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL);
+
+ final StatsSession mockSession = mockery.mock(StatsSession.class);
+ final StatsSessionMXBean mockSessionMBean =
mockery.mock(StatsSessionMXBean.class);
+
+ mockery.checking(new Expectations() {{
+ allowing(mockStatsManager).getSessionManager();
will(returnValue(mockSessionManager));
+ one(mockMBeanFactory).createSessionMBean(NAMESPACE,
mockSession); will(returnValue(mockSessionMBean));
+ allowing(mockSession).getKey(); will(returnValue(mockKey));
+ ignoring(mockSession);
+ }});
+
+ ObjectName name = new ObjectName(buildKeyName(NAMESPACE, mockKey,
TYPE_KEYS, SUBTYPE_SESSION, true));
+
+ assertTrue(mBeanServer.queryMBeans(name, null).isEmpty());
+ mxBeanRegistrar.registerSessionMXBean(mockSession);
+ assertEquals(1, mBeanServer.queryMBeans(name, null).size());
+ }
+
+ @Test
+ public void testUnregisterSessionMBeanIfNecessary() throws Exception {
+
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL);
+
+ final StatsSession mockSession = mockery.mock(StatsSession.class);
+ final StatsSessionMXBean mockSessionMBean =
mockery.mock(StatsSessionMXBean.class);
+
+ mockery.checking(new Expectations() {{
+ allowing(mockSession).getKey(); will(returnValue(mockKey));
+ ignoring(mockSession);
+ }});
+
+ ObjectName name = new ObjectName(buildKeyName(NAMESPACE, mockKey,
TYPE_KEYS, SUBTYPE_SESSION, true));
+
+ mBeanServer.registerMBean(mockSessionMBean, name);
+
+ mxBeanRegistrar.unregisterSessionMXBeanIfNecessary(mockKey);
+ assertTrue(mBeanServer.queryMBeans(name, null).isEmpty());
+ }
+
+ @Test
+ public void testUnregisterSessionMBeanIfNotNecessary() throws
Exception {
+
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL);
+
+ ObjectName name = new ObjectName(buildKeyName(NAMESPACE, mockKey,
TYPE_KEYS, SUBTYPE_SESSION, true));
+
+ mxBeanRegistrar.unregisterSessionMXBeanIfNecessary(mockKey);
+ assertTrue(mBeanServer.queryMBeans(name, null).isEmpty());
+ }
+
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/test/java/org/stajistics/management/StatsKeyOpenTypeConverterTest.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,135 @@
+package org.stajistics.management;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.stajistics.AbstractStajisticsTestCase;
+import org.stajistics.DefaultStatsKey;
+import org.stajistics.SimpleStatsKey;
+import org.stajistics.StatsKey;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ *
+ *
+ * @author The Stajistics Projcet
+ */
+public class StatsKeyOpenTypeConverterTest extends
AbstractStajisticsTestCase {
+
+ private StatsKeyOpenTypeConverter converter;
+
+ @Before
+ public void setUp() {
+ converter = new StatsKeyOpenTypeConverter();
+ }
+
+ @Test
+ public void testConvertSimpleKey() {
+ StatsKey key = new SimpleStatsKey("test", null);
+ String openKey = converter.toOpenType(key);
+ assertEquals("test", openKey);
+
+ assertConvertUnconvertSame(key);
+ }
+
+ @Test
+ public void testConvertKeyWithStringAttribute() {
+ StatsKey key = new DefaultStatsKey("test", null,
Collections.<String,Object>singletonMap("attr", "value"));
+ String openKey = converter.toOpenType(key);
+ assertEquals("test:attr=value", openKey);
+
+ assertConvertUnconvertSame(key);
+ }
+
+ @Test
+ public void testConvertKeyWithStringAttributes() {
+ Map<String,Object> attributes = new LinkedHashMap<String,Object>();
+ attributes.put("attr1", "one");
+ attributes.put("attr2", "two");
+
+ StatsKey key = new DefaultStatsKey("test", null, attributes);
+ String openKey = converter.toOpenType(key);
+ assertEquals("test:attr1=one&attr2=two", openKey);
+
+ assertConvertUnconvertSame(key);
+ }
+
+ @Test
+ public void testConvertKeyWithBooleanAttribute() {
+ StatsKey key = new DefaultStatsKey("test", null,
Collections.<String,Object>singletonMap("cool", true));
+ String openKey = converter.toOpenType(key);
+ assertEquals("test:cool=b_t", openKey);
+
+ assertConvertUnconvertSame(key);
+ }
+
+ @Test
+ public void testConvertKeyWithIntegerAttribute() {
+ StatsKey key = new DefaultStatsKey("test", null,
Collections.<String,Object>singletonMap("cats", 3));
+ String openKey = converter.toOpenType(key);
+ assertEquals("test:cats=i_3", openKey);
+
+ assertConvertUnconvertSame(key);
+ }
+
+ @Test
+ public void testConvertKeyWithLongAttribute() {
+ StatsKey key = new DefaultStatsKey("test", null,
Collections.<String,Object>singletonMap("id", 42L));
+ String openKey = converter.toOpenType(key);
+ assertEquals("test:id=l_42", openKey);
+
+ assertConvertUnconvertSame(key);
+ }
+
+ @Test
+ public void testConvertKeyWithMixedAttributes() {
+ Map<String,Object> attributes = new LinkedHashMap<String,Object>();
+ attributes.put("attr1", "one");
+ attributes.put("attr2", true);
+ attributes.put("attr3", 44);
+ attributes.put("attr4", 66L);
+
+ StatsKey key = new DefaultStatsKey("test", null, attributes);
+ String openKey = converter.toOpenType(key);
+ assertEquals("test:attr1=one&attr2=b_t&attr3=i_44&attr4=l_66",
openKey);
+
+ assertConvertUnconvertSame(key);
+ }
+
+ @Test
+ public void testConvertKeyWithKeyNameEscapes() {
+ StatsKey key = new SimpleStatsKey("the:crazy&character=test",
null);
+ String openKey = converter.toOpenType(key);
+ assertEquals("the\\:crazy\\&character\\=test", openKey);
+
+ assertConvertUnconvertSame(key);
+ }
+
+ @Test
+ public void testConvertKeyWithAttrNameEscapes() {
+ StatsKey key = new DefaultStatsKey("test", null,
Collections.<String,Object>singletonMap("the:crazy&funky=name", "value"));
+ String openKey = converter.toOpenType(key);
+ assertEquals("test:the\\:crazy\\&funky\\=name=value", openKey);
+
+ assertConvertUnconvertSame(key);
+ }
+
+ @Test
+ public void testConvertKeyWithAttrValueEscapes() {
+ StatsKey key = new DefaultStatsKey("test", null,
Collections.<String,Object>singletonMap("name", "the:crazy&funky=value"));
+ String openKey = converter.toOpenType(key);
+ assertEquals("test:name=the\\:crazy\\&funky\\=value", openKey);
+
+ assertConvertUnconvertSame(key);
+ }
+
+ private void assertConvertUnconvertSame(final StatsKey key) {
+ String openTypeKey = converter.toOpenType(key);
+ StatsKey key2 = converter.fromOpenType(openTypeKey);
+ assertEquals(key, key2);
+ }
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/test/java/org/stajistics/management/StatsMXBeanUtilTest.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,224 @@
+package org.stajistics.management;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.stajistics.AbstractStajisticsTestCase;
+import org.stajistics.StatsKey;
+
+import javax.management.MalformedObjectNameException;
+import javax.management.ObjectName;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.stajistics.TestUtil.buildStatsKeyExpectations;
+import static org.stajistics.management.StatsMXBeanUtil.buildKeyName;
+
+/**
+ *
+ *
+ * @author The Stajistics Project
+ */
+public class StatsMXBeanUtilTest extends AbstractStajisticsTestCase {
+
+ private static final String NAMESPACE = "ns";
+
+ private static final String TYPE_TEST = "test";
+ private static final String SUBTYPE_TEST = "test";
+
+ private static final String NORMAL = "normal";
+
+ private StatsKey mockKey;
+
+ @Before
+ public void setUp() {
+ mockKey = mockery.mock(StatsKey.class);
+ }
+
+ @Test
+ public void testBuildNameDomain() {
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL);
+ String name = StatsMXBeanUtil.buildKeyName(NAMESPACE, mockKey,
TYPE_TEST, SUBTYPE_TEST, true);
+ assertTrue(name.startsWith(StatsMXBeanUtil.STAJISTICS_DOMAIN));
+ }
+
+ /* NORMAL */
+
+ @Test
+ public void testBuildNameNormal() {
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL);
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropNameValNormal() {
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL, NORMAL,
NORMAL);
+ assertValidObjectName();
+ }
+
+ /* QUESTION MARK */
+
+ @Test
+ public void testBuildNameWithQuestion() {
+ buildStatsKeyExpectations(mockery, mockKey, "with?question");
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropNameWithQuestion() {
+ buildStatsKeyExpectations(mockery, mockKey,
NORMAL, "with?question", NORMAL);
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropValWithQuestion() {
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with?question");
+ assertValidObjectName();
+ }
+
+ /* ASTERISK */
+
+ @Test
+ public void testBuildNameWithAsterisk() {
+ buildStatsKeyExpectations(mockery, mockKey, "with*asterisk");
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropNameWithAsterisk() {
+ buildStatsKeyExpectations(mockery, mockKey,
NORMAL, "with*asterisk", NORMAL);
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropValWithAsterisk() {
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with*asterisk");
+ assertValidObjectName();
+ }
+
+ /* DOUBLE QUOTES */
+
+ @Test
+ public void testBuildNameWithQuote() {
+ buildStatsKeyExpectations(mockery, mockKey, "with\"quote");
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNameWithTwoQuotes() {
+ buildStatsKeyExpectations(mockery, mockKey, "with\"two\"quotes");
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNameWithThreeQuotes() {
+ buildStatsKeyExpectations(mockery,
mockKey, "with\"three\"awesome\"quotes");
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNameWithEscapedQuote() {
+ buildStatsKeyExpectations(mockery,
mockKey, "with\\\"escaped_quote");
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropNameWithQuote() {
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL, "with\"quote",
NORMAL);
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropNameWithTwoQuotes() {
+ buildStatsKeyExpectations(mockery, mockKey,
NORMAL, "with\"two\"quotes", NORMAL);
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropNameWithThreeQuotes() {
+ buildStatsKeyExpectations(mockery, mockKey,
NORMAL, "with\"three\"awesome\"quotes", NORMAL);
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropNameWithEscapedQuote() {
+ buildStatsKeyExpectations(mockery, mockKey,
NORMAL, "with\\\"escaped_quote", NORMAL);
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropValWithQuote() {
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with\"quote");
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropValWithTwoQuotes() {
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with\"two\"quotes");
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropValWithThreeQuotes() {
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with\"three\"awesome\"quotes");
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropValWithEscapedQuote() {
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with\\\"escaped_quote");
+ assertValidObjectName();
+ }
+
+ /* EQUALS */
+
+ @Test
+ public void testBuildNameWithEquals() {
+ buildStatsKeyExpectations(mockery, mockKey, "with=equals");
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropNameWithEquals() {
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL, "with=equals",
NORMAL);
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropValWithEquals() {
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with=equals");
+ assertValidObjectName();
+ }
+
+ /* COMMA */
+
+ @Test
+ public void testBuildNameWithComma() {
+ buildStatsKeyExpectations(mockery, mockKey, "with,comma");
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropNameWithComma() {
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL, "with,comma",
NORMAL);
+ assertValidObjectName();
+ }
+
+ @Test
+ public void testBuildNamePropValWithComma() {
+ buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with,comma");
+ assertValidObjectName();
+ }
+
+ /* ASSERTIONS */
+
+ private void assertValidObjectName() {
+
+ String name = buildKeyName(NAMESPACE, mockKey, TYPE_TEST,
SUBTYPE_TEST, true);
+
+ try {
+ new ObjectName(name);
+ } catch (MalformedObjectNameException e) {
+ fail(e.toString());
+ }
+ }
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/test/java/org/stajistics/management/StatsManagementFactoryRemoteTest.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,16 @@
+package org.stajistics.management;
+
+/**
+ * This simply repeats the tests in {@link StatsManagementFactoryTest}
except
+ * it constructs the connection using {@link
StatsManagementFactory#forURL(String)}.
+ *
+ * @author The Stajistics Project
+ */
+public class StatsManagementFactoryRemoteTest extends
StatsManagementFactoryTest {
+
+ @Override
+ protected StatsManagementFactory createStatsManagementFactory() throws
Exception {
+ return StatsManagementFactory.forURL(getServiceURL());
+ }
+
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/test/java/org/stajistics/management/StatsManagementFactoryTest.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,91 @@
+package org.stajistics.management;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.stajistics.DefaultStatsManager;
+import org.stajistics.StatsKey;
+import org.stajistics.StatsManager;
+import org.stajistics.management.beans.DefaultStatsManagerMXBean;
+import org.stajistics.management.beans.DefaultStatsSessionManagerMXBean;
+import org.stajistics.management.beans.StatsManagerMXBean;
+import org.stajistics.management.beans.StatsSessionManagerMXBean;
+import org.stajistics.session.StatsSessionManager;
+
+import javax.management.ObjectName;
+import java.util.Set;
+
+import static org.junit.Assert.*;
+
+/**
+ *
+ *
+ * @author The Stajistics Project
+ */
+public class StatsManagementFactoryTest extends AbstractJMXTestCase {
+
+ private StatsManagementFactory factory;
+
+ @Before
+ public void setUp() throws Exception {
+ factory = createStatsManagementFactory();
+ }
+
+ protected StatsManagementFactory createStatsManagementFactory() throws
Exception {
+ return new StatsManagementFactory(getMBeanServerConnection());
+ }
+
+ @Test
+ public void testGetNamespaces() throws Exception {
+ ObjectName objectName =
StatsMXBeanUtil.getStatsManagerObjectName("test");
+ registerStatsManagerMXBean(objectName);
+
+ Set<String> namespaces = factory.getNamespaces();
+
+ assertNotNull(namespaces);
+ assertFalse(namespaces.isEmpty());
+ assertEquals(1, namespaces.size());
+ assertEquals("test", namespaces.iterator().next());
+ }
+
+ @Test
+ public void testGetStatsManagerObjectNames() throws Exception {
+ ObjectName objectName =
StatsMXBeanUtil.getStatsManagerObjectName("test");
+ registerStatsManagerMXBean(objectName);
+
+ Set<ObjectName> objectNames = factory.getStatsManagerObjectNames();
+
+ assertNotNull(objectNames);
+ assertFalse(objectNames.isEmpty());
+ assertEquals(1, objectNames.size());
+ assertEquals(objectName, objectNames.iterator().next());
+ }
+
+ @Test
+ public void testGetKeys() throws Exception {
+ StatsManager statsManager =
registerStatsManagerMXBean(StatsMXBeanUtil.getStatsManagerObjectName("test"));
+
registerSessionManagerMXBean(StatsMXBeanUtil.getSessionManagerObjectName("test"),
+ statsManager.getSessionManager());
+
+ final StatsKey key =
statsManager.getKeyFactory().createKey("testKey");
+ statsManager.getSessionManager().getOrCreateSession(key);
+
+ Set<StatsKey> keys = factory.getKeys("test");
+
+ assertNotNull(keys);
+ assertFalse(keys.isEmpty());
+ assertEquals(1, keys.size());
+ assertEquals(key, keys.iterator().next());
+ }
+
+ private StatsManager registerStatsManagerMXBean(ObjectName objectName)
throws Exception {
+ StatsManager statsManager = new
DefaultStatsManager.Builder().newManager();
+ StatsManagerMXBean mBean = new
DefaultStatsManagerMXBean(statsManager);
+ mBean = registerMBean(mBean, objectName, StatsManagerMXBean.class);
+ return statsManager;
+ }
+
+ private void registerSessionManagerMXBean(ObjectName objectName,
StatsSessionManager sessionManager) throws Exception {
+ StatsSessionManagerMXBean mBean = new
DefaultStatsSessionManagerMXBean(sessionManager);
+ mBean = registerMBean(mBean, objectName,
StatsSessionManagerMXBean.class);
+ }
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/test/java/org/stajistics/util/FastPutsTableMapTest.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,131 @@
+package org.stajistics.util;
+
+import org.junit.Test;
+import org.stajistics.AbstractStajisticsTestCase;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ *
+ *
+ * @author The Stajistics Project
+ */
+@SuppressWarnings({"unchecked","rawtypes"})
+public class FastPutsTableMapTest extends AbstractStajisticsTestCase {
+
+ @Test
+ public void testConstruct() {
+ FastPutsTableMap m = new FastPutsTableMap();
+ assertContents(Collections.emptyMap(), m);
+ }
+
+ @Test
+ public void testConstructWithMap() {
+
+ Map m1 = new HashMap();
+ m1.put("one", 1);
+ m1.put("two", 2);
+
+ FastPutsTableMap m2 = new FastPutsTableMap(m1);
+
+ assertContents(m1, m2);
+ }
+
+ @Test
+ public void testSizeWithDuplicates() {
+ FastPutsTableMap m = new FastPutsTableMap();
+ m.put("one", 1);
+ m.put("one", -1);
+ m.put("two", 2);
+
+ assertEquals(2, m.size());
+ }
+
+ @Test
+ public void testSizeAfterPuts() {
+ FastPutsTableMap m = new FastPutsTableMap();
+ m.put("one", 1);
+ assertEquals(1, m.size());
+ m.put("two", 2);
+ assertEquals(2, m.size());
+ m.put("three", 3);
+ assertEquals(3, m.size());
+ }
+
+ @Test
+ public void testSizeAfterRemove() {
+ FastPutsTableMap m = new FastPutsTableMap();
+ m.put("one", 1);
+ m.put("two", 2);
+ m.remove("one");
+
+ assertEquals(1, m.size());
+ }
+
+ @Test
+ public void testGetWithDuplicates() {
+ FastPutsTableMap m = new FastPutsTableMap();
+ m.put("one", 1);
+ m.put("one", -1);
+ m.put("two", 2);
+
+ assertEquals(-1, m.get("one"));
+ assertEquals(2, m.get("two"));
+ }
+
+ @Test
+ public void testCompact() {
+ FastPutsTableMap m = new FastPutsTableMap();
+ m.put("one", 1);
+ m.put("one", -1);
+ m.put("two", 2);
+
+ assertEquals(3, m.entries.size());
+
+ m.compact();
+
+ assertEquals(2, m.entries.size());
+
+ Map expectedContents = new HashMap();
+ expectedContents.put("one", -1);
+ expectedContents.put("two", 2);
+
+ assertContents(expectedContents, m);
+ }
+
+ @Test
+ public void testRemove() {
+ FastPutsTableMap m = new FastPutsTableMap();
+ m.put("one", 1);
+ m.put("one", -1);
+ m.put("two", 2);
+
+ m.remove("one");
+
+ assertEquals(1, m.entries.size()); // Ensure duplicates removed
+ assertContents(Collections.singletonMap("two", 2), m);
+ }
+
+ private void assertContents(final Map expectedContents, final
FastPutsTableMap fastPutsTableMap) {
+ assertEquals(expectedContents.isEmpty(),
fastPutsTableMap.isEmpty());
+ assertEquals(expectedContents.size(), fastPutsTableMap.size());
+
+ assertEquals(expectedContents.isEmpty(),
fastPutsTableMap.entrySet().isEmpty());
+ assertEquals(expectedContents.size(),
fastPutsTableMap.entrySet().size());
+
+ assertEquals(expectedContents.isEmpty(),
fastPutsTableMap.keySet().isEmpty());
+ assertEquals(expectedContents.size(),
fastPutsTableMap.keySet().size());
+
+ assertEquals(expectedContents.isEmpty(),
fastPutsTableMap.values().isEmpty());
+ assertEquals(expectedContents.size(),
fastPutsTableMap.values().size());
+
+ for (Map.Entry e : (Set<Map.Entry>) expectedContents.entrySet()) {
+ assertEquals(e.getValue(), fastPutsTableMap.get(e.getKey()));
+ }
+ }
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/test/java/org/stajistics/util/xml/AbstractXMLBindingManagerTest.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,129 @@
+/* Copyright 2009 - 2010 The Stajistics Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.stajistics.util.xml;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.stajistics.util.xml.testBinding.TestBinding;
+
+import java.io.*;
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author The Stajistics Project
+ */
+public class AbstractXMLBindingManagerTest {
+
+ private static final String TEST_XML = "<?xml version=\"1.0\"
encoding=\"UTF-8\" standalone=\"yes\"?>" +
+ "<testBinding><message>%message%</message></testBinding>";
+
+ private AbstractXMLBindingManager<TestBinding> manager;
+
+ @Before
+ public void setUp() {
+ manager = new AbstractXMLBindingManager<TestBinding>() {
+ @Override
+ protected Class<TestBinding> getRootElementType() {
+ return TestBinding.class;
+ }
+ };
+ }
+
+ private String testXML(final String message) {
+ return TEST_XML.replaceAll("%message%", message);
+ }
+
+ @Test
+ public void testUnmarshalWithString() {
+ TestBinding b = manager.unmarshal(testXML("aString"));
+ assertEquals(new TestBinding("aString"), b);
+ }
+
+ @Test
+ public void testUnmarshalWithReader() {
+ TestBinding b = manager.unmarshal(new
StringReader(testXML("aReader")));
+ assertEquals(new TestBinding("aReader"), b);
+ }
+
+ @Test
+ public void testUnmarshalWithInputStream() throws
UnsupportedEncodingException {
+ byte[] bytes =
testXML("anInputStream").getBytes(XMLBindingManager.DEFAULT_ENCODING);
+ TestBinding b = manager.unmarshal(new ByteArrayInputStream(bytes));
+ assertEquals(new TestBinding("anInputStream"), b);
+ }
+
+ @Test
+ public void testUnmarshalWithFile() throws IOException {
+ File f = File.createTempFile(TestBinding.class.getSimpleName(),
+ getClass().getSimpleName());
+ try {
+ FileWriter fw = new FileWriter(f);
+ fw.write(testXML("aFile"));
+ fw.close();
+
+ TestBinding b = manager.unmarshal(f);
+ assertEquals(new TestBinding("aFile"), b);
+ } finally {
+ if (f != null) {
+ f.delete();
+ }
+ }
+ }
+
+ @Test
+ public void testMarshalWithString() {
+ String xml = manager.marshal(new TestBinding("aString"));
+ assertEquals(testXML("aString"), xml);
+ }
+
+ @Test
+ public void testMarshalWithReader() {
+ StringWriter out = new StringWriter();
+ manager.marshal(new TestBinding("aReader"), out);
+ assertEquals(testXML("aReader"), out.toString());
+ }
+
+ @Test
+ public void testMarshalWithOutputStream() throws
UnsupportedEncodingException {
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ manager.marshal(new TestBinding("anOutputStream"), out);
+
assertTrue(Arrays.equals(testXML("anOutputStream").getBytes(XMLBindingManager.DEFAULT_ENCODING),
+ out.toByteArray()));
+ }
+
+ /*@Test
+ public void testMarshalWithFile() throws IOException {
+ File f = File.createTempFile(TestBinding.class.getSimpleName(),
+ getClass().getSimpleName());
+ try {
+ manager.marshal(new TestBinding("aFile"));
+ final String xml = testXML("aFile");
+
+ FileReader fr = new FileReader(f);
+ char[] buf = new char[xml.length()];
+ fr.read(buf);
+ fr.close();
+
+ assertEquals(xml, new String(buf));
+ } finally {
+ if (f != null) {
+ f.delete();
+ }
+ }
+ }*/
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/test/java/org/stajistics/util/xml/testBinding/ObjectFactory.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,29 @@
+/* Copyright 2009 - 2010 The Stajistics Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.stajistics.util.xml.testBinding;
+
+import javax.xml.bind.annotation.XmlRegistry;
+
+/**
+ * @author The Stajistics Project
+ */
+@XmlRegistry
+class ObjectFactory {
+
+ public TestBinding createTestBinding() {
+ return new TestBinding();
+ }
+
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/test/java/org/stajistics/util/xml/testBinding/TestBinding.java
Sun Jun 19 13:23:35 2011
@@ -0,0 +1,51 @@
+/* Copyright 2009 - 2010 The Stajistics Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.stajistics.util.xml.testBinding;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+
+/**
+ * @author The Stajistics Project
+ */
+@XmlRootElement(name = "testBinding")
+@XmlAccessorType(XmlAccessType.FIELD)
+public class TestBinding {
+
+ @XmlElement(name = "message", required = true)
+ private String message;
+
+ public TestBinding() {}
+
+ public TestBinding(final String message) {
+ setMessage(message);
+ }
+
+ public String getMessage() {
+ return message;
+ }
+
+ public void setMessage(String message) {
+ this.message = message;
+ }
+
+ @Override
+ public boolean equals(final Object other) {
+ return (other instanceof TestBinding) &&
+ ((TestBinding)other).getMessage().equals(message);
+ }
+}
=======================================
---
/stajistics-core/src/main/java/org/stajistics/util/AbstractXMLBindingManager.java
Wed Jun 15 16:30:39 2011
+++ /dev/null
@@ -1,126 +0,0 @@
-package org.stajistics.util;
-
-import java.io.File;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.io.Reader;
-import java.io.StringReader;
-import java.io.StringWriter;
-import java.io.Writer;
-
-import javax.xml.bind.JAXBContext;
-import javax.xml.bind.JAXBElement;
-import javax.xml.bind.JAXBException;
-import javax.xml.bind.Marshaller;
-import javax.xml.bind.Unmarshaller;
-import javax.xml.transform.stream.StreamResult;
-import javax.xml.transform.stream.StreamSource;
-
-/**
- * @author The Stajistics Project
- */
-public abstract class AbstractXMLBindingManager<T> implements
XMLBindingManager<T> {
-
- protected String encoding = DEFAULT_ENCODING;
-
- protected abstract Class<T> getRootElementType();
-
- public String getEncoding() {
- return encoding;
- }
-
- public void setEncoding(final String encoding) {
- if (encoding == null) {
- throw new NullPointerException("encoding");
- }
-
- this.encoding = encoding;
- }
-
- public T unmarshal(final String in) {
- return unmarshal(new StringReader(in));
- }
-
- public T unmarshal(final File in) {
- StreamSource src = new StreamSource(in);
- try {
- return unmarshal(src);
- } catch (JAXBException e) {
- throw new RuntimeException(e);
- }
- }
-
- public T unmarshal(final Reader in) {
- StreamSource src = new StreamSource(in);
- try {
- return unmarshal(src);
- } catch (JAXBException e) {
- throw new RuntimeException(e);
- }
- }
-
- public T unmarshal(final InputStream in) {
- StreamSource src = new StreamSource(in);
- try {
- return unmarshal(src);
- } catch (JAXBException e) {
- throw new RuntimeException(e);
- }
- }
-
- public String marshal(final T binding) {
- StringWriter out = new StringWriter(4 * 1024);
- marshal(binding, out);
- return out.toString();
- }
-
- public void marshal(final T binding,
- final OutputStream out) {
- StreamResult result = new StreamResult(out);
- try {
- marshal(binding, result);
- } catch (JAXBException e) {
- throw new RuntimeException(e);
- }
- }
-
- public void marshal(final T binding,
- final Writer out) {
- StreamResult result = new StreamResult(out);
- try {
- marshal(binding, result);
- } catch (JAXBException e) {
- throw new RuntimeException(e);
- }
- }
-
- public void marshal(final T binding,
- final File out) {
- StreamResult result = new StreamResult(out);
- try {
- marshal(binding, result);
- } catch (JAXBException e) {
- throw new RuntimeException(e);
- }
- }
-
- protected JAXBContext getJAXBContext() throws JAXBException {
- return
JAXBContext.newInstance(getRootElementType().getPackage().getName());
- }
-
- protected T unmarshal(final StreamSource source) throws JAXBException {
- Unmarshaller unmarshaller = getJAXBContext().createUnmarshaller();
- JAXBElement<T> root = unmarshaller.unmarshal(source,
getRootElementType());
- T result = root.getValue();
- return result;
- }
-
- protected void marshal(final T binding,
- final StreamResult out) throws JAXBException {
- Marshaller marshaller = getJAXBContext().createMarshaller();
- marshaller.setProperty(Marshaller.JAXB_ENCODING, encoding);
-
- marshaller.marshal(binding, out);
- }
-
-}
=======================================
---
/stajistics-core/src/main/java/org/stajistics/util/XMLBindingManager.java
Wed Jun 2 21:28:40 2010
+++ /dev/null
@@ -1,46 +0,0 @@
-/* Copyright 2009 - 2010 The Stajistics Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.stajistics.util;
-
-import java.io.*;
-
-/**
- * @author The Stajistics Project
- */
-public interface XMLBindingManager<T> {
-
- public static final String DEFAULT_ENCODING = "UTF-8";
-
- String getEncoding();
-
- void setEncoding(String encoding);
-
- T unmarshal(String in);
-
- T unmarshal(File in);
-
- T unmarshal(Reader in);
-
- T unmarshal(InputStream in);
-
- String marshal(T binding);
-
- void marshal(T binding, OutputStream out);
-
- void marshal(T binding, Writer out);
-
- void marshal(T binding, File out);
-
-}
=======================================
---
/stajistics-core/src/test/java/org/stajistics/management/AbstractMXBeanTestCase.java
Wed Jun 15 16:30:39 2011
+++ /dev/null
@@ -1,105 +0,0 @@
-/* Copyright 2009 - 2010 The Stajistics Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.stajistics.management;
-
-import org.junit.After;
-import org.junit.Before;
-import org.stajistics.AbstractStajisticsTestCase;
-
-import javax.management.*;
-import javax.management.remote.*;
-import java.io.IOException;
-
-/**
- * Thanks to Eamonn McManus for the MBean testing strategy:
- *
http://weblogs.java.net/blog/emcmanus/archive/2006/07/unit_testing_re.html
- *
- * @author The Stajistics Project
- */
-public abstract class AbstractMXBeanTestCase extends
AbstractStajisticsTestCase {
-
- private MBeanServer mBeanServer = null;
- private JMXConnector connector = null;
- private JMXConnectorServer connectorServer = null;
- private MBeanServerConnection mBeanServerConnection = null;
-
- protected MBeanServer getMBeanServer() {
- if (mBeanServer == null) {
- throw new RuntimeException("MBeanServer not initialized");
- }
-
- return mBeanServer;
- }
-
- protected MBeanServerConnection getMBeanServerConnection() {
- if (mBeanServerConnection == null) {
- throw new RuntimeException("MBeanServerConnection not
initialized");
- }
-
- return mBeanServerConnection;
- }
-
- protected <T> T registerMBean(final T mBean,
- final ObjectName name,
- final Class<T> mBeanInterfaceClass)
throws Exception {
-
- // Register with the local server
- mBeanServer.registerMBean(mBean, name);
-
- // Create a proxy to the remote MBean
- T remoteMBean = JMX.newMBeanProxy(mBeanServerConnection,
- name,
- mBeanInterfaceClass);
-
- return remoteMBean;
- }
-
- @Before
- public void setUpMBeanServerConnection() throws Exception {
-
- mBeanServer = MBeanServerFactory.newMBeanServer();
-
- JMXServiceURL url = new JMXServiceURL("service:jmx:rmi://");
- connectorServer =
JMXConnectorServerFactory.newJMXConnectorServer(url, null, mBeanServer);
- connectorServer.start();
-
- JMXConnector connector = null;
- JMXServiceURL addr = connectorServer.getAddress();
- connector = JMXConnectorFactory.connect(addr);
- mBeanServerConnection = connector.getMBeanServerConnection();
- }
-
- @After
- public void tearDownMBeanServerConnection() throws Exception {
-
- if (connector != null) {
- try {
- connector.close();
- } catch (IOException ioe) {}
- }
-
- if (connectorServer != null) {
- try {
- connectorServer.stop();
- } catch (IOException ioe) {}
- }
-
- mBeanServer = null;
- connector = null;
- connectorServer = null;
- mBeanServerConnection = null;
- }
-
-}
=======================================
---
/stajistics-core/src/test/java/org/stajistics/management/DefaultStatsMXBeanRegistratTest.java
Wed Jun 15 16:30:39 2011
+++ /dev/null
@@ -1,493 +0,0 @@
-/* Copyright 2009 - 2010 The Stajistics Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.stajistics.management;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.stajistics.TestUtil.buildStatsKeyExpectations;
-import static
org.stajistics.management.StatsMXBeanUtil.MANAGER_NAME_CONFIG;
-import static
org.stajistics.management.StatsMXBeanUtil.MANAGER_NAME_SESSION;
-import static org.stajistics.management.StatsMXBeanUtil.MANAGER_NAME_STATS;
-import static org.stajistics.management.StatsMXBeanUtil.SUBTYPE_CONFIG;
-import static org.stajistics.management.StatsMXBeanUtil.SUBTYPE_SESSION;
-import static org.stajistics.management.StatsMXBeanUtil.TYPE_KEYS;
-import static org.stajistics.management.StatsMXBeanUtil.buildManagerName;
-import static org.stajistics.management.StatsMXBeanUtil.buildName;
-
-import javax.management.MBeanServer;
-import javax.management.MBeanServerFactory;
-import javax.management.MalformedObjectNameException;
-import javax.management.ObjectName;
-
-import org.jmock.Expectations;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.stajistics.AbstractStajisticsTestCase;
-import org.stajistics.StatsKey;
-import org.stajistics.StatsManager;
-import org.stajistics.configuration.StatsConfig;
-import org.stajistics.configuration.StatsConfigBuilderFactory;
-import org.stajistics.configuration.StatsConfigManager;
-import org.stajistics.management.beans.StatsConfigMXBean;
-import org.stajistics.management.beans.StatsConfigManagerMXBean;
-import org.stajistics.management.beans.StatsManagerMXBean;
-import org.stajistics.management.beans.StatsSessionMXBean;
-import org.stajistics.management.beans.StatsSessionManagerMXBean;
-import org.stajistics.session.StatsSession;
-import org.stajistics.session.StatsSessionManager;
-
-/**
- *
- *
- *
- * @author The Stajistics Project
- */
-public class DefaultStatsMXBeanRegistratTest extends
AbstractStajisticsTestCase {
-
- private static final String NAMESPACE = "ns";
-
- private static final String TYPE_TEST = "test";
- private static final String SUBTYPE_TEST = "test";
-
- private static final String NORMAL = "normal";
-
- private StatsKey mockKey;
- private StatsMXBeanFactory mockMBeanFactory;
- private StatsManager mockStatsManager;
- private StatsSessionManager mockSessionManager;
- private StatsConfigManager mockConfigManager;
-
- private MBeanServer mBeanServer;
-
- private DefaultStatsMXBeanRegistrar mxBeanRegistrar;
-
- @Before
- public void setUp() {
- mockKey = mockery.mock(StatsKey.class);
- mockStatsManager = mockery.mock(StatsManager.class);
- mockSessionManager = mockery.mock(StatsSessionManager.class);
- mockConfigManager = mockery.mock(StatsConfigManager.class);
- mockMBeanFactory = mockery.mock(StatsMXBeanFactory.class);
-
- mBeanServer = MBeanServerFactory.newMBeanServer();
-
- mxBeanRegistrar = new DefaultStatsMXBeanRegistrar(NAMESPACE,
mockMBeanFactory, mBeanServer);
-
- mockery.checking(new Expectations() {{
- allowing(mockStatsManager).getNamespace();
- will(returnValue(NAMESPACE));
- }});
- }
-
- @After
- public void tearDown() {
- mxBeanRegistrar = null;
- }
-
- @Test
- public void testConstructWithNullNamespace() {
- try {
- new DefaultStatsMXBeanRegistrar(null, mockMBeanFactory,
MBeanServerFactory.newMBeanServer());
- } catch (NullPointerException npe) {
- assertEquals("namespace", npe.getMessage());
- }
- }
-
- @Test
- public void testConstructWithEmptyNamespace() {
- try {
- new DefaultStatsMXBeanRegistrar("", mockMBeanFactory,
MBeanServerFactory.newMBeanServer());
- } catch (IllegalArgumentException e) {
- assertEquals("empty namespace", e.getMessage());
- }
- }
-
- @Test
- public void testConstructWithNullMBeanFactory() {
- try {
- new DefaultStatsMXBeanRegistrar(NAMESPACE, null,
MBeanServerFactory.newMBeanServer());
- } catch (NullPointerException npe) {
- assertEquals("mBeanFactory", npe.getMessage());
- }
- }
-
- @Test
- public void testConstructWithNullMBeanServer() {
- try {
- new DefaultStatsMXBeanRegistrar(NAMESPACE, mockMBeanFactory,
null);
- } catch (NullPointerException npe) {
- assertEquals("mBeanServer", npe.getMessage());
- }
- }
-
- @Test
- public void testGetMBeanServer() {
- assertSame(mBeanServer, mxBeanRegistrar.getMBeanServer());
- }
-
- @Test
- public void testBuildNameDomain() {
- buildStatsKeyExpectations(mockery, mockKey, NORMAL);
- String name = StatsMXBeanUtil.buildName(NAMESPACE, mockKey,
TYPE_TEST, SUBTYPE_TEST, true);
- assertTrue(name.startsWith(StatsMXBeanUtil.STAJISTICS_DOMAIN));
- }
-
- @Test
- public void testBuildNameNormal() {
- buildStatsKeyExpectations(mockery, mockKey, NORMAL);
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNameWithQuestion() {
- buildStatsKeyExpectations(mockery, mockKey, "with?question");
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNameWithAsterisk() {
- buildStatsKeyExpectations(mockery, mockKey, "with*asterisk");
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNameWithQuote() {
- buildStatsKeyExpectations(mockery, mockKey, "with\"quote");
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNameWithTwoQuotes() {
- buildStatsKeyExpectations(mockery, mockKey, "with\"two\"quotes");
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNameWithThreeQuotes() {
- buildStatsKeyExpectations(mockery,
mockKey, "with\"three\"awesome\"quotes");
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNameWithEquals() {
- buildStatsKeyExpectations(mockery, mockKey, "with=equals");
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNameWithComma() {
- buildStatsKeyExpectations(mockery, mockKey, "with,comma");
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNamePropNameValNormal() {
- buildStatsKeyExpectations(mockery, mockKey, NORMAL, NORMAL,
NORMAL);
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNamePropNameWithQuestion() {
- buildStatsKeyExpectations(mockery, mockKey,
NORMAL, "with?question", NORMAL);
- assertInvalidObjectName();
- }
-
- @Test
- public void testBuildNamePropNameWithAsterisk() {
- buildStatsKeyExpectations(mockery, mockKey,
NORMAL, "with*asterisk", NORMAL);
- assertInvalidObjectName();
- }
-
- /*
- * Hmm. This invalid(?) name is permitted by new ObjectName(name);
- * TODO: need to manually invalidate property names of this type?
- *
- @Test
- public void testBuildNamePropNameWithQuote() {
- buildExpectations(NORMAL, "with\"quote", NORMAL);
- assertInvalidObjectName();
- }
- */
-
- @Test
- public void testBuildNamePropNameWithEquals() {
- buildStatsKeyExpectations(mockery, mockKey, NORMAL, "with=equals",
NORMAL);
- assertInvalidObjectName();
- }
-
- @Test
- public void testBuildNamePropNameWithComma() {
- buildStatsKeyExpectations(mockery, mockKey, NORMAL, "with,comma",
NORMAL);
- assertInvalidObjectName();
- }
-
- @Test
- public void testBuildNamePropValWithQuestion() {
- buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with?question");
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNamePropValWithAsterisk() {
- buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with*asterisk");
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNamePropValWithQuote() {
- buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with\"quote");
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNamePropValWithTwoQuotes() {
- buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with\"two\"quotes");
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNamePropValWithThreeQuotes() {
- buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with\"three\"awesome\"quotes");
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNamePropValWithEquals() {
- buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with=equals");
- assertValidObjectName();
- }
-
- @Test
- public void testBuildNamePropValWithComma() {
- buildStatsKeyExpectations(mockery, mockKey, NORMAL,
NORMAL, "with,comma");
- assertValidObjectName();
- }
-
- @Test
- public void testRegisterManagerMBean() throws Exception {
-
- final StatsManagerMXBean mockManagerMBean =
mockery.mock(StatsManagerMXBean.class);
-
- mockery.checking(new Expectations() {{
- one(mockMBeanFactory).createManagerMBean(mockStatsManager);
- will(returnValue(mockManagerMBean));
- }});
-
- ObjectName objectName = new ObjectName(buildManagerName(NAMESPACE,
MANAGER_NAME_STATS));
-
- assertTrue(mBeanServer.queryMBeans(objectName, null).isEmpty());
- mxBeanRegistrar.registerManagerMXBean(mockStatsManager);
- assertEquals(1, mBeanServer.queryMBeans(objectName, null).size());
- }
-
- @Test
- public void testUnregisterManagerMBean() throws Exception {
- ObjectName objectName = new
ObjectName(buildManagerName(NAMESPACE,MANAGER_NAME_STATS));
-
- final StatsManagerMXBean mockManagerMBean =
mockery.mock(StatsManagerMXBean.class);
-
- mBeanServer.registerMBean(mockManagerMBean, objectName);
-
- mxBeanRegistrar.unregisterManagerMXBean(mockStatsManager);
- assertTrue(mBeanServer.queryMBeans(objectName, null).isEmpty());
- }
-
- @Test
- public void testRegisterSessionManagerMBean() throws Exception {
-
- final StatsSessionManagerMXBean mockSessionManagerMBean =
mockery.mock(StatsSessionManagerMXBean.class);
-
- mockery.checking(new Expectations() {{
-
one(mockMBeanFactory).createSessionManagerMBean(with(mockSessionManager));
- will(returnValue(mockSessionManagerMBean));
- }});
-
- ObjectName objectName = new ObjectName(buildManagerName(NAMESPACE,
MANAGER_NAME_SESSION));
- assertTrue(mBeanServer.queryMBeans(objectName, null).isEmpty());
- mxBeanRegistrar.registerSessionManagerMXBean(mockSessionManager);
- assertEquals(1, mBeanServer.queryMBeans(objectName, null).size());
- }
-
- @Test
- public void testUnregisterSessionManagerMBean() throws Exception {
- ObjectName objectName = new ObjectName(buildManagerName(NAMESPACE,
MANAGER_NAME_SESSION));
- final StatsSessionManagerMXBean mockSessionManagerMBean =
mockery.mock(StatsSessionManagerMXBean.class);
-
- mBeanServer.registerMBean(mockSessionManagerMBean, objectName);
-
- mxBeanRegistrar.unregisterSessionManagerMXBean();
- assertTrue(mBeanServer.queryMBeans(objectName, null).isEmpty());
- }
-
- @Test
- public void testRegisterConfigManagerMBean() throws Exception {
-
- final StatsConfigManagerMXBean mockConfigManagerMBean =
mockery.mock(StatsConfigManagerMXBean.class);
-
- mockery.checking(new Expectations() {{
-
one(mockMBeanFactory).createConfigManagerMBean(mockConfigManager);
- will(returnValue(mockConfigManagerMBean));
- }});
-
- ObjectName objectName = new
ObjectName(buildManagerName(NAMESPACE,MANAGER_NAME_CONFIG));
- assertTrue(mBeanServer.queryMBeans(objectName, null).isEmpty());
- mxBeanRegistrar.registerConfigManagerMXBean(mockConfigManager);
- assertEquals(1, mBeanServer.queryMBeans(objectName, null).size());
- }
-
- @Test
- public void testUnregisterConfigManagerMBean() throws Exception {
- ObjectName objectName = new ObjectName(buildManagerName(NAMESPACE,
MANAGER_NAME_CONFIG));
- final StatsConfigManagerMXBean mockConfigManagerMBean =
mockery.mock(StatsConfigManagerMXBean.class);
-
- mBeanServer.registerMBean(mockConfigManagerMBean, objectName);
-
- mxBeanRegistrar.unregisterConfigManagerMXBean();
- assertTrue(mBeanServer.queryMBeans(objectName, null).isEmpty());
- }
-
- @Test
- public void testRegisterConfigMBean() throws Exception {
-
- buildStatsKeyExpectations(mockery, mockKey, NORMAL);
-
- final StatsConfig mockConfig = mockery.mock(StatsConfig.class);
- final StatsConfigBuilderFactory mockConfigBuilderFactory =
mockery.mock(StatsConfigBuilderFactory.class);
- final StatsConfigMXBean mockConfigMBean =
mockery.mock(StatsConfigMXBean.class);
-
- mockery.checking(new Expectations() {{
- allowing(mockStatsManager).getConfigBuilderFactory();
will(returnValue(mockConfigBuilderFactory));
- one(mockMBeanFactory).createConfigMBean(NAMESPACE, mockKey,
mockConfig); will(returnValue(mockConfigMBean));
- ignoring(mockConfig);
- }});
-
- ObjectName name = new ObjectName(buildName(NAMESPACE, mockKey,
TYPE_KEYS, SUBTYPE_CONFIG, false));
-
- assertTrue(mBeanServer.queryMBeans(name, null).isEmpty());
- mxBeanRegistrar.registerConfigMXBean(mockKey, mockConfig);
- assertEquals(1, mBeanServer.queryMBeans(name, null).size());
- }
-
- @Test
- public void testUnregisterConfigMBeanIfNecessary() throws Exception {
-
- buildStatsKeyExpectations(mockery, mockKey, NORMAL);
-
- final StatsConfig mockConfig = mockery.mock(StatsConfig.class);
- final StatsConfigMXBean mockConfigMbean =
mockery.mock(StatsConfigMXBean.class);
-
- mockery.checking(new Expectations() {{
- ignoring(mockConfig);
- }});
-
- ObjectName name = new ObjectName(buildName(NAMESPACE, mockKey,
TYPE_KEYS, SUBTYPE_CONFIG, false));
-
- mBeanServer.registerMBean(mockConfigMbean, name);
-
- mxBeanRegistrar.unregisterConfigMXBeanIfNecessary(mockKey);
- assertTrue(mBeanServer.queryMBeans(name, null).isEmpty());
- }
-
- @Test
- public void testUnregisterConfigMBeanIfNotNecessary() throws Exception
{
-
- buildStatsKeyExpectations(mockery, mockKey, NORMAL);
-
- ObjectName name = new ObjectName(buildName(NAMESPACE, mockKey,
TYPE_KEYS, SUBTYPE_SESSION, false));
-
- mxBeanRegistrar.unregisterConfigMXBeanIfNecessary(mockKey);
- assertTrue(mBeanServer.queryMBeans(name, null).isEmpty());
- }
-
- @Test
- public void testRegisterSessionMBean() throws Exception {
-
- buildStatsKeyExpectations(mockery, mockKey, NORMAL);
-
- final StatsSession mockSession = mockery.mock(StatsSession.class);
- final StatsSessionMXBean mockSessionMBean =
mockery.mock(StatsSessionMXBean.class);
-
- mockery.checking(new Expectations() {{
- allowing(mockStatsManager).getSessionManager();
will(returnValue(mockSessionManager));
- one(mockMBeanFactory).createSessionMBean(NAMESPACE,
mockSession); will(returnValue(mockSessionMBean));
- allowing(mockSession).getKey(); will(returnValue(mockKey));
- ignoring(mockSession);
- }});
-
- ObjectName name = new ObjectName(buildName(NAMESPACE, mockKey,
TYPE_KEYS, SUBTYPE_SESSION, false));
-
- assertTrue(mBeanServer.queryMBeans(name, null).isEmpty());
- mxBeanRegistrar.registerSessionMXBean(mockSession);
- assertEquals(1, mBeanServer.queryMBeans(name, null).size());
- }
-
- @Test
- public void testUnregisterSessionMBeanIfNecessary() throws Exception {
-
- buildStatsKeyExpectations(mockery, mockKey, NORMAL);
-
- final StatsSession mockSession = mockery.mock(StatsSession.class);
- final StatsSessionMXBean mockSessionMBean =
mockery.mock(StatsSessionMXBean.class);
-
- mockery.checking(new Expectations() {{
- allowing(mockSession).getKey(); will(returnValue(mockKey));
- ignoring(mockSession);
- }});
-
- ObjectName name = new ObjectName(buildName(NAMESPACE, mockKey,
TYPE_KEYS, SUBTYPE_SESSION, false));
-
- mBeanServer.registerMBean(mockSessionMBean, name);
-
- mxBeanRegistrar.unregisterSessionMXBeanIfNecessary(mockKey);
- assertTrue(mBeanServer.queryMBeans(name, null).isEmpty());
- }
-
- @Test
- public void testUnregisterSessionMBeanIfNotNecessary() throws
Exception {
-
- buildStatsKeyExpectations(mockery, mockKey, NORMAL);
-
- ObjectName name = new ObjectName(buildName(NAMESPACE, mockKey,
TYPE_KEYS, SUBTYPE_SESSION, false));
-
- mxBeanRegistrar.unregisterSessionMXBeanIfNecessary(mockKey);
- assertTrue(mBeanServer.queryMBeans(name, null).isEmpty());
- }
-
- private void assertValidObjectName() {
-
- String name = buildName(NAMESPACE, mockKey, TYPE_TEST,
SUBTYPE_TEST, true);
-
- try {
- new ObjectName(name);
- } catch (MalformedObjectNameException e) {
- fail(e.toString());
- }
- }
-
- private void assertInvalidObjectName() {
- String name = buildName(NAMESPACE, mockKey, TYPE_TEST,
SUBTYPE_TEST, true);
-
- try {
- new ObjectName(name);
- fail("Malformed name is accepted: " + name);
-
- } catch (MalformedObjectNameException e) {
- // Expected
- }
- }
-}
=======================================
---
/stajistics-core/src/test/java/org/stajistics/util/AbstractXMLBindingManagerTest.java
Wed Jun 2 21:28:40 2010
+++ /dev/null
@@ -1,129 +0,0 @@
-/* Copyright 2009 - 2010 The Stajistics Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.stajistics.util;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.stajistics.util.testbinding.TestBinding;
-
-import java.io.*;
-import java.util.Arrays;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-/**
- * @author The Stajistics Project
- */
-public class AbstractXMLBindingManagerTest {
-
- private static final String TEST_XML = "<?xml version=\"1.0\"
encoding=\"UTF-8\" standalone=\"yes\"?>" +
- "<testBinding><message>%message%</message></testBinding>";
-
- private AbstractXMLBindingManager<TestBinding> manager;
-
- @Before
- public void setUp() {
- manager = new AbstractXMLBindingManager<TestBinding>() {
- @Override
- protected Class<TestBinding> getRootElementType() {
- return TestBinding.class;
- }
- };
- }
-
- private String testXML(final String message) {
- return TEST_XML.replaceAll("%message%", message);
- }
-
- @Test
- public void testUnmarshalWithString() {
- TestBinding b = manager.unmarshal(testXML("aString"));
- assertEquals(new TestBinding("aString"), b);
- }
-
- @Test
- public void testUnmarshalWithReader() {
- TestBinding b = manager.unmarshal(new
StringReader(testXML("aReader")));
- assertEquals(new TestBinding("aReader"), b);
- }
-
- @Test
- public void testUnmarshalWithInputStream() throws
UnsupportedEncodingException {
- byte[] bytes =
testXML("anInputStream").getBytes(XMLBindingManager.DEFAULT_ENCODING);
- TestBinding b = manager.unmarshal(new ByteArrayInputStream(bytes));
- assertEquals(new TestBinding("anInputStream"), b);
- }
-
- @Test
- public void testUnmarshalWithFile() throws IOException {
- File f = File.createTempFile(TestBinding.class.getSimpleName(),
- getClass().getSimpleName());
- try {
- FileWriter fw = new FileWriter(f);
- fw.write(testXML("aFile"));
- fw.close();
-
- TestBinding b = manager.unmarshal(f);
- assertEquals(new TestBinding("aFile"), b);
- } finally {
- if (f != null) {
- f.delete();
- }
- }
- }
-
- @Test
- public void testMarshalWithString() {
- String xml = manager.marshal(new TestBinding("aString"));
- assertEquals(testXML("aString"), xml);
- }
-
- @Test
- public void testMarshalWithReader() {
- StringWriter out = new StringWriter();
- manager.marshal(new TestBinding("aReader"), out);
- assertEquals(testXML("aReader"), out.toString());
- }
-
- @Test
- public void testMarshalWithOutputStream() throws
UnsupportedEncodingException {
- ByteArrayOutputStream out = new ByteArrayOutputStream();
- manager.marshal(new TestBinding("anOutputStream"), out);
-
assertTrue(Arrays.equals(testXML("anOutputStream").getBytes(XMLBindingManager.DEFAULT_ENCODING),
- out.toByteArray()));
- }
-
- /*@Test
- public void testMarshalWithFile() throws IOException {
- File f = File.createTempFile(TestBinding.class.getSimpleName(),
- getClass().getSimpleName());
- try {
- manager.marshal(new TestBinding("aFile"));
- final String xml = testXML("aFile");
-
- FileReader fr = new FileReader(f);
- char[] buf = new char[xml.length()];
- fr.read(buf);
- fr.close();
-
- assertEquals(xml, new String(buf));
- } finally {
- if (f != null) {
- f.delete();
- }
- }
- }*/
-}
=======================================
---
/stajistics-core/src/test/java/org/stajistics/util/testbinding/ObjectFactory.java
Wed Jun 2 21:28:40 2010
+++ /dev/null
@@ -1,29 +0,0 @@
-/* Copyright 2009 - 2010 The Stajistics Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.stajistics.util.testbinding;
-
-import javax.xml.bind.annotation.XmlRegistry;
-
-/**
- * @author The Stajistics Project
- */
-@XmlRegistry
-class ObjectFactory {
-
- public TestBinding createTestBinding() {
- return new TestBinding();
- }
-
-}
=======================================
---
/stajistics-core/src/test/java/org/stajistics/util/testbinding/TestBinding.java
Wed Jun 2 21:28:40 2010
+++ /dev/null
@@ -1,51 +0,0 @@
-/* Copyright 2009 - 2010 The Stajistics Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.stajistics.util.testbinding;
-
-import javax.xml.bind.annotation.XmlAccessType;
-import javax.xml.bind.annotation.XmlAccessorType;
-import javax.xml.bind.annotation.XmlElement;
-import javax.xml.bind.annotation.XmlRootElement;
-
-/**
- * @author The Stajistics Project
- */
-@XmlRootElement(name = "testBinding")
-@XmlAccessorType(XmlAccessType.FIELD)
-public class TestBinding {
-
- @XmlElement(name = "message", required = true)
- private String message;
-
- public TestBinding() {}
-
- public TestBinding(final String message) {
- setMessage(message);
- }
-
- public String getMessage() {
- return message;
- }
-
- public void setMessage(String message) {
- this.message = message;
- }
-
- @Override
- public boolean equals(final Object other) {
- return (other instanceof TestBinding) &&
- ((TestBinding)other).getMessage().equals(message);
- }
-}
=======================================
---
/stajistics-core/src/main/java/org/stajistics/DefaultStatsKeyBuilder.java
Thu Feb 25 15:34:31 2010
+++
/stajistics-core/src/main/java/org/stajistics/DefaultStatsKeyBuilder.java
Sun Jun 19 13:23:35 2011
@@ -14,7 +14,8 @@
*/
package org.stajistics;

-import java.util.LinkedHashMap;
+import org.stajistics.util.FastPutsTableMap;
+
import java.util.Map;

/**
@@ -75,9 +76,11 @@
this.name = template.getName();
this.keyFactory = keyFactory;

- Map<String,Object> attrs = template.getAttributes();
- if (attrs != null && !attrs.isEmpty()) {
- attributes = new LinkedHashMap<String,Object>(attrs);
+ if (template.getAttributeCount() > 0) {
+ Map<String,Object> attrs = template.getAttributes();
+ if (attrs != null && !attrs.isEmpty()) {
+ attributes = new FastPutsTableMap<String,Object>(attrs);
+ }
}
}

@@ -140,10 +143,6 @@
if (name == null) {
throw new NullPointerException("name");
}
-
- if (!Util.isValidKeyAttributeName(name)) {
- throw new IllegalArgumentException("invalid attribute name: "
+ name);
- }

if (value == null) {
throw new NullPointerException("value for name: " + name);
@@ -154,7 +153,7 @@
firstAttrName = name;
firstAttrValue = value;
} else {
- attributes = new LinkedHashMap<String,Object>(8);
+ attributes = new FastPutsTableMap<String,Object>();
attributes.put(firstAttrName, firstAttrValue);
firstAttrName = null;
firstAttrValue = null;
=======================================
--- /stajistics-core/src/main/java/org/stajistics/StatsKey.java Mon May 31
20:44:40 2010
+++ /stajistics-core/src/main/java/org/stajistics/StatsKey.java Sun Jun 19
13:23:35 2011
@@ -91,7 +91,6 @@
* </blockquote>
* </p>
*
- * <p>TODO: Attribute naming restrictions/caveats</p>
* </dd>
*
* @see Stats
=======================================
--- /stajistics-core/src/main/java/org/stajistics/StatsKeyMatcher.java Wed
Jun 2 21:28:40 2010
+++ /stajistics-core/src/main/java/org/stajistics/StatsKeyMatcher.java Sun
Jun 19 13:23:35 2011
@@ -261,6 +261,16 @@
}
return Collections.unmodifiableCollection(filteredList);
}
+
+ public Set<StatsKey> filterCopy(final Set<StatsKey> keys) {
+ Set<StatsKey> filteredSet = new HashSet<StatsKey>(keys.size());
+ for (StatsKey key : keys) {
+ if (matches(key)) {
+ filteredSet.add(key);
+ }
+ }
+ return Collections.unmodifiableSet(filteredSet);
+ }

public <T> void filter(final Map<StatsKey,T> map) {
Iterator<Map.Entry<StatsKey,T>> itr = map.entrySet().iterator();
=======================================
--- /stajistics-core/src/main/java/org/stajistics/Util.java Mon May 31
20:44:40 2010
+++ /stajistics-core/src/main/java/org/stajistics/Util.java Sun Jun 19
13:23:35 2011
@@ -23,34 +23,6 @@
public final class Util {

private Util() {}
-
- public static boolean isValidKeyAttributeName(final String name) {
- if (name.length() == 0) {
- return false;
- }
-
- if (name.indexOf(',') > -1) {
- return false;
- }
-
- if (name.indexOf('=') > -1) {
- return false;
- }
-
- if (name.indexOf(':') > -1) {
- return false;
- }
-
- if (name.indexOf('*') > -1) {
- return false;
- }
-
- if (name.indexOf('?') > -1) {
- return false;
- }
-
- return true;
- }

public static boolean equalsNullAware(final Object obj1, final Object
obj2) {
if (obj1 == null) {
=======================================
---
/stajistics-core/src/main/java/org/stajistics/configuration/xml/binding/XMLConfigBindingManager.java
Wed Jun 2 21:28:40 2010
+++
/stajistics-core/src/main/java/org/stajistics/configuration/xml/binding/XMLConfigBindingManager.java
Sun Jun 19 13:23:35 2011
@@ -14,7 +14,7 @@
*/
package org.stajistics.configuration.xml.binding;

-import org.stajistics.util.AbstractXMLBindingManager;
+import org.stajistics.util.xml.AbstractXMLBindingManager;

/**
* @author The Stajistics Project
=======================================
---
/stajistics-core/src/main/java/org/stajistics/data/AbstractDataContainer.java
Wed Jun 15 10:23:52 2011
+++
/stajistics-core/src/main/java/org/stajistics/data/AbstractDataContainer.java
Sun Jun 19 13:23:35 2011
@@ -14,7 +14,6 @@
*/
package org.stajistics.data;

-import java.util.HashMap;
import java.util.Map;
import java.util.Set;

@@ -26,10 +25,13 @@
*/
public abstract class AbstractDataContainer implements DataContainer {

- private final Map<String,Object> dataMap = createDataMap();
-
- protected Map<String,Object> createDataMap() {
- return new HashMap<String,Object>();
+ private final Map<String,Object> dataMap;
+
+ protected AbstractDataContainer(final Map<String,Object> dataMap) {
+ if (dataMap == null) {
+ throw new NullPointerException("dataMap");
+ }
+ this.dataMap = dataMap;
}

@Override
=======================================
--- /stajistics-core/src/main/java/org/stajistics/data/DefaultDataSet.java
Wed Jun 15 10:23:52 2011
+++ /stajistics-core/src/main/java/org/stajistics/data/DefaultDataSet.java
Sun Jun 19 13:23:35 2011
@@ -14,6 +14,9 @@
*/
package org.stajistics.data;

+import java.util.HashMap;
+import java.util.Map;
+

/**
*
@@ -30,6 +33,13 @@

public DefaultDataSet(final long collectionTimeStamp,
final boolean drainedSession) {
+ this(collectionTimeStamp, drainedSession, new
HashMap<String,Object>());
+ }
+
+ public DefaultDataSet(final long collectionTimeStamp,
+ final boolean drainedSession,
+ final Map<String,Object> dataMap) {
+ super(dataMap);
this.collectionTimeStamp = collectionTimeStamp;
this.drainedSession = drainedSession;
}
@@ -48,11 +58,15 @@
public boolean hasMetaData() {
return metaData != null && !metaData.isEmpty();
}
+
+ protected Map<String,Object> createMetaDataMap() {
+ return new HashMap<String,Object>();
+ }

@Override
public MetaData getMetaData() {
if (metaData == null) {
- metaData = new DefaultMetaData();
+ metaData = new DefaultMetaData(createMetaDataMap());
}
return metaData;
}
=======================================
--- /stajistics-core/src/main/java/org/stajistics/data/DefaultMetaData.java
Wed Jun 15 10:23:52 2011
+++ /stajistics-core/src/main/java/org/stajistics/data/DefaultMetaData.java
Sun Jun 19 13:23:35 2011
@@ -14,6 +14,8 @@
*/
package org.stajistics.data;

+import java.util.Map;
+

/**
*
@@ -21,6 +23,8 @@
*/
class DefaultMetaData extends AbstractDataContainer implements MetaData {

- DefaultMetaData() {}
+ DefaultMetaData(final Map<String,Object> dataMap) {
+ super(dataMap);
+ }

}
=======================================
---
/stajistics-core/src/main/java/org/stajistics/management/DefaultStatsMXBeanRegistrar.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/main/java/org/stajistics/management/DefaultStatsMXBeanRegistrar.java
Sun Jun 19 13:23:35 2011
@@ -14,37 +14,25 @@
*/
package org.stajistics.management;

-import static
org.stajistics.management.StatsMXBeanUtil.MANAGER_NAME_CONFIG;
-import static
org.stajistics.management.StatsMXBeanUtil.MANAGER_NAME_SESSION;
-import static org.stajistics.management.StatsMXBeanUtil.MANAGER_NAME_STATS;
-import static org.stajistics.management.StatsMXBeanUtil.SUBTYPE_CONFIG;
-import static org.stajistics.management.StatsMXBeanUtil.SUBTYPE_SESSION;
-import static org.stajistics.management.StatsMXBeanUtil.TYPE_KEYS;
-import static org.stajistics.management.StatsMXBeanUtil.buildManagerName;
-import static org.stajistics.management.StatsMXBeanUtil.buildName;
-
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.Serializable;
-import java.lang.management.ManagementFactory;
-
-import javax.management.MBeanServer;
-import javax.management.ObjectName;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.stajistics.StatsKey;
import org.stajistics.StatsManager;
import org.stajistics.configuration.StatsConfig;
import org.stajistics.configuration.StatsConfigManager;
-import org.stajistics.management.beans.StatsConfigMXBean;
-import org.stajistics.management.beans.StatsConfigManagerMXBean;
-import org.stajistics.management.beans.StatsManagerMXBean;
-import org.stajistics.management.beans.StatsSessionMXBean;
-import org.stajistics.management.beans.StatsSessionManagerMXBean;
+import org.stajistics.management.beans.*;
import org.stajistics.session.StatsSession;
import org.stajistics.session.StatsSessionManager;

+import javax.management.MBeanServer;
+import javax.management.ObjectName;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.Serializable;
+import java.lang.management.ManagementFactory;
+
+import static org.stajistics.management.StatsMXBeanUtil.*;
+
/**
*
*
@@ -102,86 +90,72 @@
public MBeanServer getMBeanServer() {
return mBeanServer;
}
-
-

@Override
- public void registerManagerMXBean(final StatsManager statsManager) {
-
- String name = buildManagerName(statsManager.getNamespace(),
MANAGER_NAME_STATS);
+ public void registerStatsManagerMXBean(final StatsManager
statsManager) {
+ assert statsManager.getNamespace().equals(namespace);

try {
StatsManagerMXBean statsManagerMBean =
mBeanFactory.createManagerMBean(statsManager);

- ObjectName objectName = new ObjectName(name);
-
+ ObjectName objectName = getStatsManagerObjectName(namespace);
registerMBean(statsManagerMBean, objectName);

logRegistrationSuccess(true, StatsManagerMXBean.class, null,
objectName);

} catch (Exception e) {
- logRegistrationFailure(true, StatsManagerMXBean.class, null,
name, e);
+ logRegistrationFailure(true, StatsManagerMXBean.class, null,
getStatsManagerObjectNameString(namespace, true), e);

throw new StatsManagementException(e);
}
}

@Override
- public void unregisterManagerMXBean(StatsManager statsManager) {
-
- String name = buildManagerName(statsManager.getNamespace(),
MANAGER_NAME_STATS);
+ public void unregisterStatsManagerMXBean(final StatsManager
statsManager) {
+ assert statsManager.getNamespace().equals(namespace);

try {
- ObjectName objectName = new ObjectName(name) ;
+ ObjectName objectName = getStatsManagerObjectName(namespace);
mBeanServer.unregisterMBean(objectName);

logRegistrationSuccess(false, StatsManagerMXBean.class, null,
objectName);

} catch (Exception e) {
- logRegistrationFailure(false, StatsManagerMXBean.class, null,
name, e);
+ logRegistrationFailure(false, StatsManagerMXBean.class, null,
getStatsManagerObjectNameString(namespace, true), e);

throw new StatsManagementException(e);
}
-
}

@Override
public void registerSessionManagerMXBean(final StatsSessionManager
sessionManager) {
-
- String name = buildManagerName(namespace, MANAGER_NAME_SESSION);
-
try {
StatsSessionManagerMXBean statsSessionManagerMBean =
mBeanFactory.createSessionManagerMBean(sessionManager);

- ObjectName objectName = new ObjectName(name);
-
+ ObjectName objectName = getSessionManagerObjectName(namespace);
registerMBean(statsSessionManagerMBean, objectName);

logRegistrationSuccess(true, StatsSessionManagerMXBean.class,
null, objectName);

} catch (Exception e) {
- logRegistrationFailure(true, StatsSessionManagerMXBean.class,
null, name, e);
+ logRegistrationFailure(true, StatsSessionManagerMXBean.class,
null, getSessionManagerObjectNameString(namespace, true), e);

throw new StatsManagementException(e);
}
-
}

@Override
public void unregisterSessionManagerMXBean() {
-
- String name = buildManagerName(namespace, MANAGER_NAME_SESSION);
-
try {
- ObjectName objectName = new ObjectName(name);
+ ObjectName objectName = getSessionManagerObjectName(namespace);
mBeanServer.unregisterMBean(objectName);

logRegistrationSuccess(false, StatsSessionManagerMXBean.class,
null, objectName);

} catch (Exception e) {
- logRegistrationFailure(false, StatsSessionManagerMXBean.class,
null, name, e);
+ logRegistrationFailure(false, StatsSessionManagerMXBean.class,
null, getSessionManagerObjectNameString(namespace, true), e);

throw new StatsManagementException(e);
}
@@ -189,19 +163,17 @@

@Override
public void registerConfigManagerMXBean(final StatsConfigManager
configManager) {
- String name = buildManagerName(namespace, MANAGER_NAME_CONFIG);
try {
StatsConfigManagerMXBean statsConfigManagerMBean =
mBeanFactory.createConfigManagerMBean(configManager);

- ObjectName objectName = new ObjectName(name);
-
+ ObjectName objectName = getConfigManagerObjectName(namespace);
registerMBean(statsConfigManagerMBean, objectName);

logRegistrationSuccess(true, StatsConfigManagerMXBean.class,
null, objectName);

} catch (Exception e) {
- logRegistrationFailure(true, StatsConfigManagerMXBean.class,
null, name, e);
+ logRegistrationFailure(true, StatsConfigManagerMXBean.class,
null, getConfigManagerObjectNameString(namespace, true), e);

throw new StatsManagementException(e);
}
@@ -209,16 +181,14 @@

@Override
public void unregisterConfigManagerMXBean() {
- String name = buildManagerName(namespace, MANAGER_NAME_CONFIG);
-
try {
- ObjectName objectName = new ObjectName(name);
+ ObjectName objectName = getConfigManagerObjectName(namespace);
mBeanServer.unregisterMBean(objectName);

logRegistrationSuccess(false, StatsConfigManagerMXBean.class,
null, objectName);

} catch (Exception e) {
- logRegistrationFailure(false, StatsConfigManagerMXBean.class,
null, name, e);
+ logRegistrationFailure(false, StatsConfigManagerMXBean.class,
null, getConfigManagerObjectNameString(namespace, true), e);

throw new StatsManagementException(e);
}
@@ -226,20 +196,17 @@

@Override
public void registerConfigMXBean(final StatsKey key,
- final StatsConfig config) {
-
- String name = buildName(namespace, key, TYPE_KEYS, SUBTYPE_CONFIG,
false);
-
+ final StatsConfig config) {
try {
StatsConfigMXBean configMBean =
mBeanFactory.createConfigMBean(namespace, key, config);
- ObjectName objectName = new ObjectName(name);
-
+
+ ObjectName objectName = getConfigObjectName(namespace, key);
registerMBean(configMBean, objectName);

logRegistrationSuccess(true, StatsConfigMXBean.class, key,
objectName);

} catch (Exception e) {
- logRegistrationFailure(true, StatsConfigMXBean.class, key,
name, e);
+ logRegistrationFailure(true, StatsConfigMXBean.class, key,
getConfigObjectNameString(namespace, key, true), e);

throw new StatsManagementException(e);
}
@@ -247,11 +214,8 @@

@Override
public void unregisterConfigMXBeanIfNecessary(final StatsKey key) {
-
- String name = buildName(namespace, key, TYPE_KEYS, SUBTYPE_CONFIG,
false);
-
try {
- ObjectName objectName = new ObjectName(name);
+ ObjectName objectName = getConfigObjectName(namespace, key);
if (mBeanServer.isRegistered(objectName)) {
mBeanServer.unregisterMBean(objectName);

@@ -259,7 +223,7 @@
}

} catch (Exception e) {
- logRegistrationFailure(false, StatsConfigMXBean.class, key,
name, e);
+ logRegistrationFailure(false, StatsConfigMXBean.class, key,
getConfigObjectNameString(namespace, key, true), e);

throw new StatsManagementException(e);
}
@@ -267,20 +231,17 @@

@Override
public void registerSessionMXBean(final StatsSession session) {
-
- String name = buildName(namespace, session.getKey(), TYPE_KEYS,
SUBTYPE_SESSION, true);
-
try {
StatsSessionMXBean sessionMBean =
mBeanFactory.createSessionMBean(namespace,

session);

- ObjectName objectName = new ObjectName(name);
+ ObjectName objectName = getSessionObjectName(namespace,
session.getKey());
registerMBean(sessionMBean, objectName);

logRegistrationSuccess(true, StatsSessionMXBean.class,
session.getKey(), objectName);

} catch (Exception e) {
- logRegistrationFailure(true, StatsSessionMXBean.class,
session.getKey(), name, e);
+ logRegistrationFailure(true, StatsSessionMXBean.class,
session.getKey(), getSessionObjectNameString(namespace, session.getKey(),
true), e);

throw new StatsManagementException(e);
}
@@ -288,11 +249,8 @@

@Override
public void unregisterSessionMXBeanIfNecessary(final StatsKey key) {
-
- String name = buildName(namespace, key, TYPE_KEYS,
SUBTYPE_SESSION, true);
-
try {
- ObjectName objectName = new ObjectName(name);
+ ObjectName objectName = getSessionObjectName(namespace, key);
if (mBeanServer.isRegistered(objectName)) {
mBeanServer.unregisterMBean(objectName);

@@ -300,7 +258,7 @@
}

} catch (Exception e) {
- logRegistrationFailure(false, StatsSessionMXBean.class, key,
name, e);
+ logRegistrationFailure(false, StatsSessionMXBean.class, key,
getSessionObjectNameString(namespace, key, true), e);

throw new StatsManagementException(e);
}
=======================================
---
/stajistics-core/src/main/java/org/stajistics/management/StatsMXBeanRegistrar.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/main/java/org/stajistics/management/StatsMXBeanRegistrar.java
Sun Jun 19 13:23:35 2011
@@ -14,8 +14,6 @@
*/
package org.stajistics.management;

-import javax.management.MBeanServer;
-
import org.stajistics.StatsKey;
import org.stajistics.StatsManager;
import org.stajistics.configuration.StatsConfig;
@@ -23,6 +21,8 @@
import org.stajistics.session.StatsSession;
import org.stajistics.session.StatsSessionManager;

+import javax.management.MBeanServer;
+
/**
*
*
@@ -35,9 +35,9 @@

MBeanServer getMBeanServer();

- void registerManagerMXBean(StatsManager statsManager);
-
- void unregisterManagerMXBean(StatsManager statsManager);
+ void registerStatsManagerMXBean(StatsManager statsManager);
+
+ void unregisterStatsManagerMXBean(StatsManager statsManager);

void registerConfigManagerMXBean(StatsConfigManager configManager);

=======================================
---
/stajistics-core/src/main/java/org/stajistics/management/StatsMXBeanUtil.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/main/java/org/stajistics/management/StatsMXBeanUtil.java
Sun Jun 19 13:23:35 2011
@@ -1,15 +1,10 @@
package org.stajistics.management;

-import static org.stajistics.management.StatsMXBeanUtil.STAJISTICS_DOMAIN;
-import static org.stajistics.management.StatsMXBeanUtil.TYPE_MANAGER;
-
+import org.stajistics.StatsKey;
+
+import javax.management.MalformedObjectNameException;
+import javax.management.ObjectName;
import java.util.Map;
-import java.util.regex.Pattern;
-
-import javax.management.ObjectName;
-
-import org.stajistics.StatsKey;
-import org.stajistics.StatsManager;

/**
*
@@ -20,6 +15,11 @@

public static final String STAJISTICS_DOMAIN =
org.stajistics.Stats.class.getPackage().getName();

+ public static final String OBJECT_NAME_ATTR_NAMESPACE = "namespace";
+ public static final String OBJECT_NAME_ATTR_NAME = "name";
+ public static final String OBJECT_NAME_ATTR_TYPE = "type";
+ public static final String OBJECT_NAME_ATTR_SUB_TYPE = "subtype";
+
public static final String TYPE_MANAGER = "manager";
public static final String TYPE_KEYS = "keys";

@@ -31,57 +31,191 @@
public static final String MANAGER_NAME_SESSION = "SessionManager";
public static final String MANAGER_NAME_SNAPSHOT = "SnapshotManager";

- public static final Pattern NAMESPACE_EXTRACTOR_PATTERN =
Pattern.compile(".*\\[(.*)\\]");
-
private StatsMXBeanUtil() {}

- public static String buildManagerName(final String namespace,
- final String managerName) {
- StringBuilder buf = new StringBuilder(128);
- buf.append(STAJISTICS_DOMAIN);
-
- buf.append(":namespace=");
- buf.append(namespace);
-
- buf.append(",type=");
- buf.append(TYPE_MANAGER);
-
- buf.append(",name=");
- buf.append(managerName);
-
- return buf.toString();
+ /**
+ *
+ * @param namespace
+ * @return
+ */
+ public static String getStatsManagerObjectNameString(final String
namespace, final boolean quote) {
+ return buildManagerName(namespace, MANAGER_NAME_STATS, quote);
+ }
+
+ /**
+ *
+ * @param namespace
+ * @return
+ * @throws MalformedObjectNameException
+ */
+ public static ObjectName getStatsManagerObjectName(final String
namespace) throws MalformedObjectNameException {
+ ObjectName objectName = new
ObjectName(getStatsManagerObjectNameString(namespace, true));
+ return objectName;
+ }
+
+ /**
+ *
+ * @param namespace
+ * @return
+ */
+ public static String getSessionManagerObjectNameString(final String
namespace, final boolean quote) {
+ return buildManagerName(namespace, MANAGER_NAME_SESSION, quote);
+ }
+
+ /**
+ *
+ * @param namespace
+ * @return
+ * @throws MalformedObjectNameException
+ */
+ public static ObjectName getSessionManagerObjectName(final String
namespace) throws MalformedObjectNameException {
+ ObjectName objectName = new
ObjectName(getSessionManagerObjectNameString(namespace, true));
+ return objectName;
+ }
+
+ /**
+ *
+ * @param namespace
+ * @return
+ */
+ public static String getConfigManagerObjectNameString(final String
namespace, final boolean quote) {
+ return buildManagerName(namespace, MANAGER_NAME_CONFIG, quote);
}

- public static String buildName(final String namespace,
- final StatsKey key,
- final String type,
- final String subtype,
- final boolean includeAttributes) {
-
- StringBuilder buf = new StringBuilder(128);
-
+ /**
+ *
+ * @param namespace
+ * @return
+ * @throws MalformedObjectNameException
+ */
+ public static ObjectName getConfigManagerObjectName(final String
namespace) throws MalformedObjectNameException {
+ ObjectName objectName = new
ObjectName(getConfigManagerObjectNameString(namespace, true));
+ return objectName;
+ }
+
+ /**
+ *
+ * @param namespace
+ * @param key
+ * @return
+ */
+ public static String getSessionObjectNameString(final String
namespace, final StatsKey key, final boolean quote) {
+ return buildKeyName(namespace, key, TYPE_KEYS, SUBTYPE_SESSION,
quote);
+ }
+
+ /**
+ *
+ * @param namespace
+ * @param key
+ * @return
+ * @throws MalformedObjectNameException
+ */
+ public static ObjectName getSessionObjectName(final String namespace,
final StatsKey key) throws MalformedObjectNameException {
+ ObjectName objectName = new
ObjectName(getSessionObjectNameString(namespace, key, true));
+ return objectName;
+ }
+
+ /**
+ *
+ * @param namespace
+ * @param key
+ * @return
+ */
+ public static String getConfigObjectNameString(final String namespace,
final StatsKey key, final boolean quote) {
+ return buildKeyName(namespace, key, TYPE_KEYS, SUBTYPE_CONFIG,
quote);
+ }
+
+ /**
+ *
+ * @param namespace
+ * @param key
+ * @return
+ * @throws MalformedObjectNameException
+ */
+ public static ObjectName getConfigObjectName(final String namespace,
final StatsKey key) throws MalformedObjectNameException {
+ ObjectName objectName = new
ObjectName(getConfigObjectNameString(namespace, key, true));
+ return objectName;
+ }
+
+ private static void appendAttr(final StringBuilder buf,
+ final String key,
+ final String value,
+ final boolean quote) {
+ boolean first = key.equals(OBJECT_NAME_ATTR_NAMESPACE);
+ if (first) {
+ buf.append(':');
+ } else {
+ buf.append(',');
+ }
+
+ if (quote && valueNeedsQuotes(key)) {
+ buf.append(ObjectName.quote(key));
+ } else {
+ buf.append(key);
+ }
+ buf.append('=');
+
+ if (quote && valueNeedsQuotes(value)) {
+ buf.append(ObjectName.quote(value));
+ } else {
+ buf.append(value);
+ }
+ }
+
+ public static boolean valueNeedsQuotes(final String value) {
+ final int len = value.length();
+ for (int i = 0; i < len; i++) {
+ char c = value.charAt(i);
+ switch (c) {
+ case '\n':
+ case '\\':
+ case '"':
+ case '*':
+ case '?':
+ case ',':
+ case '=':
+ case ':':
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ protected static String buildManagerName(final String namespace,
+ final String managerName,
+ final boolean quote) {
+ StringBuilder buf = new StringBuilder(128);
buf.append(STAJISTICS_DOMAIN);

- buf.append(":namespace=");
- buf.append(namespace);
-
- buf.append(",type=");
- buf.append(type);
-
- buf.append(",name=");
- buf.append(ObjectName.quote(key.getName()));
-
+ appendAttr(buf, OBJECT_NAME_ATTR_NAMESPACE, namespace, quote);
+ appendAttr(buf, OBJECT_NAME_ATTR_TYPE, TYPE_MANAGER, quote);
+ appendAttr(buf, OBJECT_NAME_ATTR_NAME, managerName, quote);
+
+ return buf.toString();
+ }
+
+ protected static String buildKeyName(final String namespace,
+ final StatsKey key,
+ final String type,
+ final String subtype,
+ final boolean quote) {
+
+ StringBuilder buf = new StringBuilder(128);
+ buf.append(STAJISTICS_DOMAIN);
+
+ appendAttr(buf, OBJECT_NAME_ATTR_NAMESPACE, namespace, quote);
+ appendAttr(buf, OBJECT_NAME_ATTR_TYPE, type, quote);
+ appendAttr(buf, OBJECT_NAME_ATTR_NAME, key.getName(), quote);
+
+ boolean includeAttributes = subtype.equals(SUBTYPE_SESSION); //
Session beans are StatsKey-unique
if (includeAttributes) {
for (Map.Entry<String,Object> entry :
key.getAttributes().entrySet()) {
- buf.append(',');
- buf.append(entry.getKey());
- buf.append('=');
- buf.append(ObjectName.quote(entry.getValue().toString()));
+ appendAttr(buf, entry.getKey(),
entry.getValue().toString(), quote);
}
}

- buf.append(",subtype=");
- buf.append(subtype);
+ appendAttr(buf, OBJECT_NAME_ATTR_SUB_TYPE, subtype, quote);

return buf.toString();
}
=======================================
---
/stajistics-core/src/main/java/org/stajistics/management/StatsManagementEventHandler.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/main/java/org/stajistics/management/StatsManagementEventHandler.java
Sun Jun 19 13:23:35 2011
@@ -16,7 +16,6 @@

import org.stajistics.StatsKey;
import org.stajistics.StatsManager;
-import org.stajistics.StatsManagerRegistry;
import org.stajistics.configuration.StatsConfig;
import org.stajistics.configuration.StatsConfigManager;
import org.stajistics.event.EventHandler;
@@ -48,11 +47,11 @@
final Object target) {
switch (eventType) {
case STATS_MANAGER_INITIALIZED:
-
mxBeanRegistrar.registerManagerMXBean((StatsManager)target);
+
mxBeanRegistrar.registerStatsManagerMXBean((StatsManager)target);
break;

case STATS_MANAGER_SHUTTING_DOWN:
-
mxBeanRegistrar.unregisterManagerMXBean((StatsManager)target);
+
mxBeanRegistrar.unregisterStatsManagerMXBean((StatsManager)target);
break;

case CONFIG_MANAGER_INITIALIZED:
=======================================
---
/stajistics-core/src/main/java/org/stajistics/management/beans/DefaultStatsConfigManagerMXBean.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/main/java/org/stajistics/management/beans/DefaultStatsConfigManagerMXBean.java
Sun Jun 19 13:23:35 2011
@@ -16,7 +16,7 @@

import org.stajistics.configuration.StatsConfigManager;

-import java.io.IOException;
+import java.util.Set;

/**
*
@@ -37,12 +37,18 @@
}

@Override
- public String getImplementation() throws IOException {
+ public String getImplementation() {
return configManager.getClass().getName();
}

@Override
- public int getConfigCount() throws IOException {
+ public int getConfigCount() {
return configManager.getConfigCount();
}
-}
+
+ @Override
+ public Set<String> keyNames() {
+ return configManager.getKeyNames();
+ }
+
+}
=======================================
---
/stajistics-core/src/main/java/org/stajistics/management/beans/DefaultStatsSessionManagerMXBean.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/main/java/org/stajistics/management/beans/DefaultStatsSessionManagerMXBean.java
Sun Jun 19 13:23:35 2011
@@ -16,10 +16,12 @@

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import org.stajistics.StatsKeyMatcher;
+import org.stajistics.management.StatsKeyOpenTypeConverter;
import org.stajistics.session.StatsSession;
import org.stajistics.session.StatsSessionManager;

-import java.io.IOException;
+import java.util.Set;

/**
*
@@ -44,17 +46,17 @@
}

@Override
- public String getImplementation() throws IOException {
+ public String getImplementation() {
return sessionManager.getClass().getName();
}

@Override
- public int getSessionCount() throws IOException {
- return sessionManager.getSessions().size();
+ public int getSessionCount() {
+ return sessionManager.getSessionCount();
}

@Override
- public void dumpAllSessions() throws IOException {
+ public void dumpAllSessions() {
if (sessionLogger.isInfoEnabled()) {
for (StatsSession session : sessionManager.getSessions()) {
sessionLogger.info(session.toString());
@@ -63,13 +65,26 @@
}

@Override
- public void clearAllSessions() throws IOException {
+ public void clearAllSessions() {
sessionManager.clearAllSessions();
}

@Override
- public void destroyAllSessions() throws IOException {
+ public void destroyAllSessions() {
sessionManager.clear();
}
+
+ @Override
+ public Set<String> statsKeys() {
+ StatsKeyOpenTypeConverter converter = new
StatsKeyOpenTypeConverter();
+ return converter.toOpenType(sessionManager.getKeys());
+ }
+
+ @Override
+ public Set<String> subKeys(final String keyName) {
+ StatsKeyOpenTypeConverter converter = new
StatsKeyOpenTypeConverter();
+ StatsKeyMatcher matcher = StatsKeyMatcher.nameEquals(keyName);
+ return converter.toOpenType(sessionManager.getKeys(matcher));
+ }

}
=======================================
---
/stajistics-core/src/main/java/org/stajistics/management/beans/StatsConfigManagerMXBean.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/main/java/org/stajistics/management/beans/StatsConfigManagerMXBean.java
Sun Jun 19 13:23:35 2011
@@ -15,7 +15,7 @@
package org.stajistics.management.beans;

import javax.management.MXBean;
-import java.io.IOException;
+import java.util.Set;

/**
*
@@ -26,7 +26,10 @@
@MXBean
public interface StatsConfigManagerMXBean {

- String getImplementation() throws IOException;
-
- int getConfigCount() throws IOException;
-}
+ String getImplementation();
+
+ int getConfigCount();
+
+ // Not an attribute
+ Set<String> keyNames();
+}
=======================================
---
/stajistics-core/src/main/java/org/stajistics/management/beans/StatsSessionMXBean.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/main/java/org/stajistics/management/beans/StatsSessionMXBean.java
Sun Jun 19 13:23:35 2011
@@ -24,7 +24,5 @@
*/
@MXBean
public interface StatsSessionMXBean {
-
-
-
-}
+ // Implementations are dynamic
+}
=======================================
---
/stajistics-core/src/main/java/org/stajistics/management/beans/StatsSessionManagerMXBean.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/main/java/org/stajistics/management/beans/StatsSessionManagerMXBean.java
Sun Jun 19 13:23:35 2011
@@ -15,7 +15,7 @@
package org.stajistics.management.beans;

import javax.management.MXBean;
-import java.io.IOException;
+import java.util.Set;

/**
*
@@ -26,14 +26,17 @@
@MXBean
public interface StatsSessionManagerMXBean {

- String getImplementation() throws IOException;
-
- int getSessionCount() throws IOException;
-
- void dumpAllSessions() throws IOException;
-
- void clearAllSessions() throws IOException;
-
- void destroyAllSessions() throws IOException;
-
-}
+ String getImplementation();
+
+ int getSessionCount();
+
+ void dumpAllSessions();
+
+ void clearAllSessions();
+
+ void destroyAllSessions();
+
+ Set<String> statsKeys();
+
+ Set<String> subKeys(String keyName);
+}
=======================================
---
/stajistics-core/src/main/java/org/stajistics/session/AbstractStatsSession.java
Wed Jun 15 10:23:52 2011
+++
/stajistics-core/src/main/java/org/stajistics/session/AbstractStatsSession.java
Sun Jun 19 13:23:35 2011
@@ -22,14 +22,12 @@
import org.stajistics.data.DefaultDataSet;
import org.stajistics.event.EventManager;
import org.stajistics.session.recorder.DataRecorder;
+import org.stajistics.util.FastPutsTableMap;
import org.stajistics.util.Misc;

import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Locale;
+import java.util.*;

/**
*
@@ -162,8 +160,24 @@
return null;
}

- protected DataSet createDataSet(boolean drainedSession) {
- DataSet dataSet = new DefaultDataSet(System.currentTimeMillis(),
drainedSession);
+ /**
+ * A factory method for creating a DataSet instance that will be
populated with this session's data.
+ * @param drainedSession
+ * @return
+ */
+ protected DataSet createDataSet(final boolean drainedSession) {
+
+ final int estimatedSize = 10 + (dataRecorders.length * 4);
+
+ DataSet dataSet = new DefaultDataSet(System.currentTimeMillis(),
+ drainedSession,
+ new
FastPutsTableMap<String,Object>(estimatedSize)) {
+ @Override
+ protected Map<String, Object> createMetaDataMap() {
+ return new FastPutsTableMap<String,Object>(8);
+ }
+ };
+
return dataSet;
}

=======================================
---
/stajistics-core/src/main/java/org/stajistics/session/DefaultSessionManager.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/main/java/org/stajistics/session/DefaultSessionManager.java
Sun Jun 19 13:23:35 2011
@@ -90,6 +90,11 @@
public Set<StatsKey> getKeys() {
return Collections.unmodifiableSet(sessionMap.keySet());
}
+
+ @Override
+ public Set<StatsKey> getKeys(final StatsKeyMatcher keyMatcher) {
+ return keyMatcher.filterCopy(sessionMap.keySet());
+ }

@Override
public Collection<StatsSession> getSessions() {
=======================================
---
/stajistics-core/src/main/java/org/stajistics/session/StatsSessionManager.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/main/java/org/stajistics/session/StatsSessionManager.java
Sun Jun 19 13:23:35 2011
@@ -43,6 +43,15 @@
*/
Set<StatsKey> getKeys();

+ /**
+ * Get the Set of matching {@link StatsKey}s that are associated with
the
+ * {@link StatsSession}s being managed. The passed <tt>keyMatcher</tt>
is used to
+ * select the desired keys.
+ * @param keyMatcher The key matcher with which to filter results.
+ * @return A Set of {@link StatsKey}s, or an empty Set if there are
none.
+ */
+ Set<StatsKey> getKeys(StatsKeyMatcher keyMatcher);
+
/**
* Get all {@link StatsSession}s being managed.
*
=======================================
---
/stajistics-core/src/test/java/org/stajistics/DefaultStatsKeyBuilderTest.java
Wed Jun 2 21:28:40 2010
+++
/stajistics-core/src/test/java/org/stajistics/DefaultStatsKeyBuilderTest.java
Sun Jun 19 13:23:35 2011
@@ -334,33 +334,6 @@
assertEquals("name", npe.getMessage());
}
}
-
- @Test
- public void testPutAttributeWithInvalidName() {
-
- String[] invalidNames = { "*", "?", ",", "=", ":",
- "a*", "a?", "a,", "a=", "a:",
- "*a", "?a", ",a", "=a", ":a",
- "*a*", "?a?", ",a,", "=a=", ":a:",
- "a*a", "a?a", "a,a", "a=a", "a:a" };
-
- for (String invalidName : invalidNames) {
- resetMockery();
- setUp();
-
- buildStatsKeyExpectations(mockery,
mockKey, "test", "existing", "attribute");
- buildStatsKeyBuildCopyExpectations();
-
- try {
- mockKey.buildCopy()
- .withAttribute(invalidName, "value");
- fail("Allowed withAttribute with invalid name: '" +
invalidName + "'");
-
- } catch (IllegalArgumentException iae) {
- // expected
- }
- }
- }

@Test
public void testPutAttributeWithNullStringValue() {
=======================================
---
/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsConfigMXBeanTest.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsConfigMXBeanTest.java
Sun Jun 19 13:23:35 2011
@@ -14,11 +14,6 @@
*/
package org.stajistics.management.beans;

-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-import javax.management.ObjectName;
-
import org.jmock.Expectations;
import org.junit.After;
import org.junit.Before;
@@ -30,7 +25,12 @@
import org.stajistics.configuration.StatsConfigBuilder;
import org.stajistics.configuration.StatsConfigBuilderFactory;
import org.stajistics.configuration.StatsConfigManager;
-import org.stajistics.management.AbstractMXBeanTestCase;
+import org.stajistics.management.AbstractJMXTestCase;
+
+import javax.management.ObjectName;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;

/**
*
@@ -38,7 +38,7 @@
*
* @author The Stajistics Project
*/
-public class DefaultStatsConfigMXBeanTest extends AbstractMXBeanTestCase {
+public class DefaultStatsConfigMXBeanTest extends AbstractJMXTestCase {

private static final String NAMESPACE = "ns";

=======================================
---
/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsConfigManagerMXBeanTest.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsConfigManagerMXBeanTest.java
Sun Jun 19 13:23:35 2011
@@ -18,9 +18,7 @@
import org.junit.Before;
import org.junit.Test;
import org.stajistics.configuration.StatsConfigManager;
-import org.stajistics.management.AbstractMXBeanTestCase;
-import org.stajistics.management.beans.DefaultStatsConfigManagerMXBean;
-import org.stajistics.management.beans.StatsConfigManagerMXBean;
+import org.stajistics.management.AbstractJMXTestCase;

import javax.management.ObjectName;

@@ -32,7 +30,7 @@
*
* @author The Stajistics Project
*/
-public class DefaultStatsConfigManagerMXBeanTest extends
AbstractMXBeanTestCase {
+public class DefaultStatsConfigManagerMXBeanTest extends
AbstractJMXTestCase {

protected StatsConfigManager mockConfigManager;

=======================================
---
/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsManagerMXBeanTest.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsManagerMXBeanTest.java
Sun Jun 19 13:23:35 2011
@@ -18,10 +18,7 @@
import org.junit.Before;
import org.junit.Test;
import org.stajistics.StatsManager;
-import org.stajistics.configuration.StatsConfigBuilder;
-import org.stajistics.management.AbstractMXBeanTestCase;
-import org.stajistics.management.beans.DefaultStatsManagerMXBean;
-import org.stajistics.management.beans.StatsManagerMXBean;
+import org.stajistics.management.AbstractJMXTestCase;

import javax.management.ObjectName;

@@ -30,7 +27,7 @@
/**
* @author The Stajistics Project
*/
-public class DefaultStatsManagerMXBeanTest extends AbstractMXBeanTestCase {
+public class DefaultStatsManagerMXBeanTest extends AbstractJMXTestCase {

protected StatsManager mockManager = null;

=======================================
---
/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsSessionMXBeanTest.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsSessionMXBeanTest.java
Sun Jun 19 13:23:35 2011
@@ -14,13 +14,6 @@
*/
package org.stajistics.management.beans;

-import static org.junit.Assert.assertEquals;
-
-import java.util.Collections;
-import java.util.HashSet;
-
-import javax.management.ObjectName;
-
import org.jmock.Expectations;
import org.junit.After;
import org.junit.Before;
@@ -29,17 +22,23 @@
import org.stajistics.StatsManager;
import org.stajistics.StatsManagerRegistry;
import org.stajistics.data.DataSet;
-import org.stajistics.management.AbstractMXBeanTestCase;
+import org.stajistics.management.AbstractJMXTestCase;
import org.stajistics.session.StatsSession;
import org.stajistics.session.StatsSessionManager;

+import javax.management.ObjectName;
+import java.util.Collections;
+import java.util.HashSet;
+
+import static org.junit.Assert.assertEquals;
+
/**
*
*
*
* @author The Stajistics Project
*/
-public class DefaultStatsSessionMXBeanTest extends AbstractMXBeanTestCase {
+public class DefaultStatsSessionMXBeanTest extends AbstractJMXTestCase {

private static final String NAMESPACE = "ns";

=======================================
---
/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsSessionManagerMXBeanTest.java
Wed Jun 15 16:30:39 2011
+++
/stajistics-core/src/test/java/org/stajistics/management/beans/DefaultStatsSessionManagerMXBeanTest.java
Sun Jun 19 13:23:35 2011
@@ -14,11 +14,10 @@
*/
package org.stajistics.management.beans;

+import org.jmock.Expectations;
import org.junit.Before;
import org.junit.Test;
-import org.stajistics.management.AbstractMXBeanTestCase;
-import org.stajistics.management.beans.DefaultStatsSessionManagerMXBean;
-import org.stajistics.management.beans.StatsSessionManagerMXBean;
+import org.stajistics.management.AbstractJMXTestCase;
import org.stajistics.session.StatsSessionManager;

import javax.management.ObjectName;
@@ -31,7 +30,7 @@
*
* @author The Stajistics Project
*/
-public class DefaultStatsSessionManagerMXBeanTest extends
AbstractMXBeanTestCase {
+public class DefaultStatsSessionManagerMXBeanTest extends
AbstractJMXTestCase {

protected StatsSessionManager mockSessionManager;

@@ -55,7 +54,8 @@
assertEquals(mockSessionManager.getClass().getName(),
mBean.getImplementation());
}
-/* TODO: this fails
+
+
@Test
public void testGetSessionCount() throws Exception {

@@ -63,14 +63,15 @@
one(mockSessionManager).getSessionCount();
will(returnValue(42));
}});

- StatsSessionManagerMBean mBean =
createSessionManagerMBean(mockSessionManager);
- ObjectName name = new ObjectName(getClass().getName()
+ ":name=test");
-
- mBean = registerMBean(mBean, name,
StatsSessionManagerMBean.class);
+ StatsSessionManagerMXBean mBean =
createSessionManagerMBean(mockSessionManager);
+ //ObjectName name = new ObjectName(getClass().getName()
+ ":name=test");
+
+ // Don't register because it screws up on serialization of
Mockery.. what to do?
+ //mBean = registerMBean(mBean, name,
StatsSessionManagerMXBean.class);

assertEquals(42, mBean.getSessionCount());

mockery.assertIsSatisfied();
}
- */
-}
+
+}