package org.opennaas.extensions.genericnetwork.capability.nettopology;
/*
* #%L
* OpenNaaS :: Generic Network
* %%
* Copyright (C) 2007 - 2014 FundaciĆ³ Privada i2CAT, Internet i InnovaciĆ³ a Catalunya
* %%
* 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.
* #L%
*/
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.opennaas.core.resources.ActivatorException;
import org.opennaas.core.resources.action.ActionException;
import org.opennaas.core.resources.action.ActionResponse;
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.descriptor.ResourceDescriptorConstants;
import org.opennaas.core.resources.protocol.IProtocolManager;
import org.opennaas.core.resources.protocol.IProtocolSessionManager;
import org.opennaas.core.resources.protocol.ProtocolException;
import org.opennaas.extensions.genericnetwork.Activator;
import org.opennaas.extensions.genericnetwork.model.GenericNetworkModel;
import org.opennaas.extensions.genericnetwork.model.topology.Topology;
/**
* {@link INetTopologyCapability} implementation based on the resource model
*
* @author Julio Carlos Barrera
* @author Isart Canyameres Gimenez (i2cat)
*
*/
public class NetTopologyCapability extends AbstractCapability implements INetTopologyCapability {
public static final String CAPABILITY_TYPE = "nettopology";
public static final String TOPOLOGY_FILE = "topology.file.path";
private Log log = LogFactory.getLog(NetTopologyCapability.class);
private String resourceId = "";
public NetTopologyCapability(CapabilityDescriptor descriptor, String resourceId) {
super(descriptor);
this.resourceId = resourceId;
log.debug("Built new Network Topology Capability");
}
@Override
public String getCapabilityName() {
return CAPABILITY_TYPE;
}
@Override
public void activate() throws CapabilityException {
// FIXME cannot access resource model in activate() method,
// resource model is initialized in the bootstrapper which is executed afterwards.
// loadTopology();
registerService(Activator.getContext(), CAPABILITY_TYPE, getResourceType(), getResourceName(), INetTopologyCapability.class.getName());
super.activate();
}
@Override
public void deactivate() throws CapabilityException {
unregisterService();
// FIXME cannot access resource model in deactivate() method,
// resource model is reseted in revert bootstrap which has been already executed.
// clearTopology();
super.deactivate();
}
@Override
public void queueAction(IAction action) throws CapabilityException {
throw new UnsupportedOperationException("Not Implemented. This capability is not using the queue.");
}
@Override
public IActionSet getActionSet() throws CapabilityException {
String name = this.descriptor.getPropertyValue(ResourceDescriptorConstants.ACTION_NAME);
String version = this.descriptor.getPropertyValue(ResourceDescriptorConstants.ACTION_VERSION);
try {
return Activator.getActionSetService(NetTopologyCapability.CAPABILITY_TYPE, name, version);
} catch (ActivatorException e) {
throw new CapabilityException(e);
}
}
@Override
public Topology getTopology() throws CapabilityException {
return ((GenericNetworkModel) resource.getModel()).getTopology();
}
/**
* Load topology in the resource model.
*
* @throws CapabilityException
*/
public void loadTopology() throws CapabilityException {
// FIXME coupling capability with action implementation (read from file).
// To fix that, configurable drivers are required :S
String filepath = getCapabilityDescriptor().getPropertyValue(TOPOLOGY_FILE);
IAction action = createActionAndCheckParams(NetTopologyActionSet.LOAD_TOPOLOGY, filepath);
ActionResponse response = executeAction(action);
if (!response.getStatus().equals(ActionResponse.STATUS.OK))
throw new ActionException(response.toString());
}
private void clearTopology() throws CapabilityException {
((GenericNetworkModel) resource.getModel()).setTopology(null);
}
private ActionResponse executeAction(IAction action) throws CapabilityException {
try {
IProtocolManager protocolManager = getProtocolManagerService();
IProtocolSessionManager protocolSessionManager = protocolManager.getProtocolSessionManager(this.resourceId);
ActionResponse response = action.execute(protocolSessionManager);
return response;
} catch (ProtocolException pe) {
log.error("Error getting protocol session - " + pe.getMessage());
throw new CapabilityException(pe);
} catch (ActivatorException ae) {
String errorMsg = "Error getting protocol manager - " + ae.getMessage();
log.error(errorMsg);
throw new CapabilityException(errorMsg, ae);
}
}
private IProtocolManager getProtocolManagerService() throws ActivatorException {
return Activator.getProtocolManagerService();
}
}