Attachment 14609 Details for Bug 74066 – Repro case

Repro case

AttributePairStorageMultiplexer.java (text/plain), 9.08 KB, created by Johan Walles

on 2004-09-17 08:41:36 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Johan Walles

Created: 2004-09-17 08:41:36 EDT

Size: 9.08 KB

patch

obsolete

>/*
> * Created on 2004-jul-02
> */
>package com.jrockit.console.attribute.storage;
>
>import java.io.*;
>
>import java.util.*;
>import java.util.HashMap;
>import java.util.Map;
>
>import com.jrockit.console.attribute.AttributeSubscription;
>import com.jrockit.console.persistence.ColumnIdentifier;
>import com.jrockit.console.persistence.PairStorage;
>import com.jrockit.console.util.PreferencesKeys;
>
>/**
> * This class multiplexes between AttributeSubscriptions and PairStorages. The
> * subscriptions are provided by the console to the PersistingAttributeStorage.
> * They are grouped together by what machine / port they belong to.
> * 
> * Each group has one PairStorage associated to it.
> * 
> * @author johan
> */
>public class AttributePairStorageMultiplexer
>{
>	/**
>	 * Our singleton instance.
>	 */
>	private static AttributePairStorageMultiplexer m_defaultMultiplexer;
>
>	/**
>	 * The conversion map. Keys are attribute group names and values are PairStorages.
>	 * 
>	 * @see #getGroupName(AttributeSubscription)
>	 */
>	private Map<String, PairStorage> m_group2pairStorage;
>	
>	/**
>	 * Who's keeping a certain PairStorage open?
>	 */
>	private Map<PairStorage, Set<AttributeSubscription>> m_pairStorageUsers;
>	
>	/**
>	 * Who do the groups consist of?
>	 */
>	private Map<String, Set<AttributeSubscription>> m_groupMembers;
>	
>	/**
>	 * This is a singleton, users aren't allowed to instantiate.
>	 * 
>	 * @see #getDefaultMultiplexer()
>	 */
>	private AttributePairStorageMultiplexer()
>	{
>		m_group2pairStorage = new HashMap<String, PairStorage>();
>		m_pairStorageUsers = new HashMap<PairStorage, Set<AttributeSubscription>>();
>		m_groupMembers = new HashMap<String, Set<AttributeSubscription>>();
>	}
>	
>	/**
>	 * @return the AttributePairStorageMultiplexer singleton.
>	 */
>	public synchronized static AttributePairStorageMultiplexer getDefaultMultiplexer()
>	{
>		if (m_defaultMultiplexer == null)
>		{
>			m_defaultMultiplexer = new AttributePairStorageMultiplexer();
>		}
>
>		return m_defaultMultiplexer;
>	}
>
>	/**
>	 * @param attributeSubscription The AttributeSubscription to find the
>	 * PairStorage for.
>	 * 
>	 * @return the PairStorage associated with this AttributeSubscription.
>	 */
>	public synchronized PairStorage getPairStorage(AttributeSubscription attributeSubscription)
>	{
>		// If this attributeSubscription already has a PairStorage, return that.
>		PairStorage pairStorage = m_group2pairStorage.get(getGroupName(attributeSubscription));
>		if (pairStorage != null && m_pairStorageUsers.get(pairStorage).contains(attributeSubscription)) {
>			return pairStorage;
>		}
>		
>		// If this attributeSubscription hasn't been registered previously, we don't want to do this.
>		if (!m_groupMembers.containsKey(getGroupName(attributeSubscription))) {
>			throw new IllegalStateException(attributeSubscription + " must be registered through willWantPairStorage()");
>		}
>		if (!m_groupMembers.get(getGroupName(attributeSubscription)).contains(attributeSubscription)) {
>			throw new IllegalStateException(attributeSubscription + " must be registered through willWantPairStorage()");
>		}
>		
>		// If this attributeSubscription's group has a PairStorage, close that.
>		if (pairStorage != null) {
>			pairStorage.close();
>			m_group2pairStorage.remove(getGroupName(attributeSubscription));
>			m_pairStorageUsers.remove(pairStorage);
>			pairStorage = null;
>		}
>		
>		// Invariant: This subscription is registered but doesn't have a PairStorage
>		
>		try
>		{
>			// Open a new PairStorage for this attributeSubscription and
>			// everything in its group
>			File dataDirectory = getDataDirectory();
>			
>			if (dataDirectory == null) {
>				// FIXME: Handle this some other way
>				System.err.println("Unable to open persistence directory");
>				System.exit(1);
>			}
>			
>			pairStorage = new PairStorage(
>					dataDirectory,
>					"jrconsole",
>					getColumnIdentifiers(getGroupName(attributeSubscription)),
>					'\t',
>					"csv");
>		}
>		catch (FileNotFoundException e)
>		{
>			// FIXME: Handle this some better way
>			e.printStackTrace();
>			System.exit(1);
>		}
>		
>		// Remember the new PairStorage
>		m_group2pairStorage.put(getGroupName(attributeSubscription), pairStorage);
>		Set<AttributeSubscription> users = new HashSet<AttributeSubscription>();
>		m_pairStorageUsers.put(pairStorage, users);
>		for (AttributeSubscription user : m_groupMembers.get(getGroupName(attributeSubscription))) {
>			users.add(user);
>		}
>		
>		return pairStorage;
>	}
>
>	/**
>	 * Fetch the group name from an AttributeSubscription.
>	 */
>	private static String getGroupName(AttributeSubscription attributeSubscription)
>	{
>		return attributeSubscription.getRJMXConnectorModel().getCompactName();
>	}
>
>	/**
>	 * Convert the aspects with the given group name into a ColumnIdentifier
>	 * array.
>	 */
>	private ColumnIdentifier[] getColumnIdentifiers(String aspectGroupName)
>	{
>		ArrayList <ColumnIdentifier> columnIdentifiers = new ArrayList<ColumnIdentifier>(5);
>		
>		for (AttributeSubscription subscription : m_groupMembers.get(aspectGroupName)) {
>			columnIdentifiers.add(subscription2columnIdentifier(subscription));
>		}
>		
>		return columnIdentifiers.toArray(new ColumnIdentifier[0]);
>	}
>	
>	/**
>	 * Create a ColumnIdentifier from an AttributeSubscription.
>	 * 
>	 * @param attributeSubscription
>	 *            The AttributeSubscription to turn into a column identifier.
>	 * 
>	 * @return A column identifier for the AttributeSubscription.
>	 */
>	private static ColumnIdentifier subscription2columnIdentifier(
>			AttributeSubscription attributeSubscription)
>	{
>		String censoredName = attributeSubscription.getName().replace(' ', '-');
>
>		return new ColumnIdentifier(censoredName, attributeSubscription.getDescription());
>	}
>
>	/**
>	 * Convert a subscription group name into a File representing a directory
>	 * where to store data about that subscription group.
>	 * <p>
>	 * Create the directory if it doesn't exist.
>	 * 
>	 * @return null if the directory doesn't exist and can't be created
>	 */
>	private static File getDataDirectory()
>	{
>		String settingsDirectory = System.getProperty(
>				PreferencesKeys.PROPERTY_PERSISTENCE_PATH,
>				PreferencesKeys.DEFAULT_PERSISTENCE_PATH);
>
>		File returnMe = new File(settingsDirectory);
>
>		if (returnMe.exists() && !returnMe.isDirectory())
>		{
>			// A file is in the way for our directory
>			return null;
>		}
>
>		if (!returnMe.exists() && !returnMe.mkdirs())
>		{
>			// Can't create the requested directory
>			return null;
>		}
>
>		return returnMe;
>	}
>
>	/**
>	 * @param attribute The attribute to get a ColumnIdentifier for.
>	 * 
>	 * @return a ColumnIdentifier matching the given AttributeSubscription.
>	 * 
>	 * @throws IllegalStateException
>	 *             if no PairStorage is associated with that aspect.
>	 */
>	public synchronized ColumnIdentifier getColumnIdentifier(AttributeSubscription attribute)
>	{
>		if (getPairStorage(attribute) == null) {
>			throw new IllegalStateException("That subscription hasn't been registered using willWantPairStorage()");
>		}
>		
>		return getColumnIdentifier(attribute);
>	}
>	
>	/**
>	 * Close the association between this aspect and the on disk backing
>	 * storage.
>	 * 
>	 * @param attribute The connection to close.
>	 */
>	public synchronized void close(AttributeSubscription attribute)
>	{
>		PairStorage pairStorage = getPairStorage(attribute);
>		
>		Set<AttributeSubscription> users = m_pairStorageUsers.get(pairStorage);
>		
>		if (users == null || !users.contains(attribute)) {
>			throw new IllegalArgumentException(attribute + " doesn't have a PairStorage open");
>		}
>		
>		// This attribute doesn't want the PairStorage any more
>		users.remove(attribute);
>		
>		// Unless anybody else is interested...
>		if (users.isEmpty()) {
>			// ... close it and forget about it
>			pairStorage.close();
>			m_pairStorageUsers.remove(pairStorage);
>		}
>		
>		Set<AttributeSubscription> members = m_groupMembers.get(getGroupName(attribute));
>		assert(members != null);
>		members.remove(attribute);
>		if (members.isEmpty()) {
>			m_groupMembers.remove(getGroupName(attribute));
>		}
>	}
>
>	/**
>	 * This method registers that the persistence layer will be required to
>	 * handle a certain Aspect.
>	 * 
>	 * @param subscription The subscription that will want to talk to a PairStorage.
>	 */
>	public synchronized void willWantPairStorage(AttributeSubscription subscription)
>	{
>		String groupName = getGroupName(subscription);
>		
>		// FIXME: Update m_groupMembers
>		if (m_groupMembers.get(groupName).contains(subscription)) {
>			// Already registered, our work here is done			
>			return;
>		}
>		m_groupMembers.get(groupName).add(subscription);
>		
>		// FIXME: Update m_group2pairStorage
>		// FIXME: If this group has a non-null PairStorage, close it and
>		// forget about it
>		if (m_group2pairStorage.get(groupName)
>		
>		// FIXME: Update m_pairStorageUsers
>		
>		
>		if (m_group2pairStorage.containsKey(groupName))
>		{
>			// Already registered, do nothing
>			return;
>		}
>		
>		// If other subscriptions in the same group actually have a PairStorage
>		// associated with them...
>		PairStorage pairStorage = m_group2pairStorage.get(groupName);
>		if (pairStorage != null)
>		{
>			// ... close that PairStorage and forget about it
>			pairStorage.close();
>			m_group2pairStorage.remove(groupName);
>		}
>		
>		// Invariant: The subscription isn't in our map
>		
>		// Mark this group as not yet having a PairStorage
>		m_group2pairStorage.put(groupName, null);
>	}
>}

Actions: View

Attachments on bug 74066: 14575 | 14609