QueueCapability.java

package org.opennaas.extensions.network.capability.queue;

import java.util.Hashtable;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.opennaas.core.resources.ActivatorException;
import org.opennaas.core.resources.IResource;
import org.opennaas.core.resources.IResourceIdentifier;
import org.opennaas.core.resources.IResourceManager;
import org.opennaas.core.resources.ResourceException;
import org.opennaas.core.resources.action.IAction;
import org.opennaas.core.resources.action.IActionSet;
import org.opennaas.core.resources.capability.AbstractCapability;
import org.opennaas.core.resources.capability.CapabilityException;
import org.opennaas.core.resources.descriptor.CapabilityDescriptor;
import org.opennaas.core.resources.protocol.ProtocolException;
import org.opennaas.core.resources.queue.QueueResponse;
import org.opennaas.extensions.network.model.NetworkModel;
import org.opennaas.extensions.network.model.domain.NetworkDomain;
import org.opennaas.extensions.network.model.topology.Device;
import org.opennaas.extensions.network.model.topology.NetworkElement;
import org.opennaas.extensions.queuemanager.IQueueManagerCapability;

/**
 * @author Jordi Puig
 */
public class QueueCapability extends AbstractCapability implements IQueueCapability {

	public final static String	CAPABILITY_TYPE				= "netqueue";

	public final static String	NETQUEUE_CAPABILITY_NAME	= CAPABILITY_TYPE;

	public final static String	QUEUE_CAPABILITY_NAME		= "queue";

	Log							log							= LogFactory.getLog(QueueCapability.class);

	private String				resourceId					= "";

	/**
	 * QueueCapability constructor
	 * 
	 * @param descriptor
	 * @param resourceId
	 */
	public QueueCapability(CapabilityDescriptor descriptor, String resourceId) {
		super(descriptor);
		this.resourceId = resourceId;
		log.debug("Built new queue capability");
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.opennaas.core.resources.capability.AbstractCapability#activate()
	 */
	@Override
	public void activate() throws CapabilityException {
		registerService(Activator.getContext(), CAPABILITY_TYPE, getResourceType(), getResourceName(), IQueueCapability.class.getName());
		super.activate();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.opennaas.core.resources.capability.AbstractCapability#deactivate()
	 */
	@Override
	public void deactivate() throws CapabilityException {
		registration.unregister();
		super.deactivate();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.opennaas.core.resources.capability.ICapability#getCapabilityName()
	 */
	@Override
	public String getCapabilityName() {
		return CAPABILITY_TYPE;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.opennaas.core.resources.capability.AbstractCapability#queueAction(org.opennaas.core.resources.action.IAction)
	 */
	@Override
	public void queueAction(IAction action) throws CapabilityException {
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.opennaas.core.resources.capability.AbstractCapability#getActionSet()
	 */
	@Override
	public IActionSet getActionSet() throws CapabilityException {
		throw new UnsupportedOperationException();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.opennaas.extensions.network.capability.queue.IQueueCapability#execute()
	 */
	@Override
	public Response execute() throws CapabilityException {
		log.info("Start of execute call");
		Response response = new Response();
		Map<String, QueueResponse> queueResponses = new Hashtable<String, QueueResponse>();
		NetworkModel model = (NetworkModel) resource.getModel();
		if (model.getNetworkElements() != null && !model.getNetworkElements().isEmpty()) {
			for (NetworkElement networkElement : model.getNetworkElements()) {
				// Only Device and NetworkDomain instances
				if (networkElement instanceof Device || networkElement instanceof NetworkDomain) {
					try {
						QueueResponse queueResponse = executeQueue(networkElement.getName());
						if (queueResponse != null) {
							queueResponses.put(networkElement.getName(), queueResponse);
						}
					} catch (CapabilityException e) {
						queueResponses.put(networkElement.getName(), new QueueResponse());
					}
				}
			}
		}
		log.info("End of execute call");
		response.setResponse(queueResponses);
		return response;
	}

	/**
	 * Execute the queue of the NetworkElement name
	 * 
	 * @param networkElementName
	 * 
	 * @return queue response
	 * @throws CapabilityException
	 */
	private QueueResponse executeQueue(String networkElementName) throws CapabilityException {
		QueueResponse queueResponse = null;
		try {
			IResource iResource = getResource(networkElementName);
			if (iResource != null) {

				IQueueManagerCapability queueCapability = (IQueueManagerCapability) iResource
						.getCapabilityByInterface(IQueueManagerCapability.class);
				if (queueCapability != null) {
					queueResponse = queueCapability.execute();
				}
			}
		} catch (ResourceException e) {
			throw new CapabilityException(e);
		} catch (ActivatorException e) {
			throw new CapabilityException(e);
		} catch (ProtocolException e) {
			throw new CapabilityException(e);
		}
		return queueResponse;
	}

	/**
	 * Get the resource from resourceManager.<br/>
	 * To get the resource the name must have the pattern resourceType:resourceName
	 * 
	 * @param networkElementName
	 *            the notworkElement name with pattern resourceType:resourceName
	 * @return IResource
	 * @throws ResourceException
	 * @throws ActivatorException
	 */
	private IResource getResource(String networkElementName) throws ResourceException, ActivatorException {
		IResource iResource = null;
		String[] aResourceName = getResourceTypeAndName(networkElementName);
		if (aResourceName.length > 1) {
			IResourceManager resourceManager = Activator.getResourceManagerService();
			IResourceIdentifier iResourceIdentifier = resourceManager
					.getIdentifierFromResourceName(aResourceName[0], aResourceName[1]);
			iResource = resourceManager.getResource(iResourceIdentifier);
		}
		return iResource;
	}

	/**
	 * Get the resource type and the resource name in a string array from pattern resourceType:resourceName
	 * 
	 * @param name
	 *            with pattern resourceType:resourceName
	 * @return string array
	 */
	private String[] getResourceTypeAndName(String name) {
		return name.split(":");
	}

}