package net.floodlightcontroller.debugevent.web;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.floodlightcontroller.debugevent.IDebugEventService.DebugEventInfo;
import net.floodlightcontroller.debugevent.IDebugEventService.EventType;
import org.restlet.resource.Get;
import org.restlet.resource.Post;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Web interface for Debug Events
*
* @author Saurav
*/
public class DebugEventResource extends DebugEventResourceBase {
protected static Logger logger =
LoggerFactory.getLogger(DebugEventResource.class);
/**
* The output JSON model that contains the counter information
*/
public static class DebugEventInfoOutput {
protected class DEInfo {
private final boolean enabled;
private final int bufferCapacity;
private final EventType eventType;
private final String eventDesc;
private final String eventName;
private final String moduleName;
private final String[] metaData;
private final List<Map<String,String>> eventHistory;
DEInfo(DebugEventInfo dei) {
this.moduleName = dei.getEventInfo().getModuleName();
this.eventName = dei.getEventInfo().getEventName();
this.eventDesc = dei.getEventInfo().getEventDesc();
this.metaData = dei.getEventInfo().getMetaData();
this.enabled = dei.getEventInfo().isEnabled();
this.eventType = dei.getEventInfo().getEtype();
this.bufferCapacity = dei.getEventInfo().getBufferCapacity();
this.eventHistory = dei.getEvents();
}
public boolean isEnabled() {
return enabled;
}
public int getBufferCapacity() {
return bufferCapacity;
}
public String getEventDesc() {
return eventDesc;
}
public String getEventName() {
return eventName;
}
public String getModuleName() {
return moduleName;
}
public String[] getMetaData() {
return metaData;
}
public EventType getEventType() {
return eventType;
}
public List<Map<String,String>> getEventHistory() {
return eventHistory;
}
}
public Map<String, DEInfo> eventMap = null;
public List<String> names = null;
public String error = null;
DebugEventInfoOutput(boolean getList) {
if (!getList) {
eventMap = new HashMap<String, DEInfo>();
}
}
public Map<String, DEInfo> getEventMap() {
return eventMap;
}
public List<String> getNames() {
return names;
}
public String getError() {
return error;
}
}
public enum Option {
ALL, ONE_MODULE, ONE_MODULE_EVENT, ERROR_BAD_MODULE_NAME, ERROR_BAD_PARAM,
ERROR_BAD_MODULE_EVENT_NAME
}
public static class DebugEventPost {
public Boolean reset;
public Boolean getReset() {
return reset;
}
public void setReset(Boolean reset) {
this.reset = reset;
}
}
public static class ResetOutput {
String error = null;
public String getError() {
return error;
}
public void setError(String error) {
this.error = error;
}
}
/**
* Reset events
*
* If using curl:
* curl -X POST -d {\"reset\":true} -H "Content-Type: application/json" URL
* where URL must be in one of the following forms for resetting registered events:
* "http://{controller-hostname}:8080/wm/debugevent/
* "http://{controller-hostname}:8080/wm/debugevent/{param1}
* "http://{controller-hostname}:8080/wm/debugevent/{param1}/{param2}
*
* Not giving {param1} will reset all events
* {param1} can be 'all' or the name of a module. The former case will reset
* all events, while the latter will reset all events for the moduleName (if
* param2 is null).{param2} must be an eventName for the given moduleName to
* reset a specific event.
*/
@Post
public ResetOutput postHandler(DebugEventPost postData) {
ResetOutput output = new ResetOutput();
String param1 = (String)getRequestAttributes().get("param1");
String param2 = (String)getRequestAttributes().get("param2");
if (postData.getReset() != null && postData.getReset()) {
Option choice = Option.ERROR_BAD_PARAM;
if (param1 == null) {
param1 = "all";
choice = Option.ALL;
} else if (param1.equals("all")) {
choice = Option.ALL;
} else if (param2 == null) {
boolean isRegistered = debugEvent.containsModuleName(param1);
if (isRegistered) {
choice = Option.ONE_MODULE;
} else {
choice = Option.ERROR_BAD_MODULE_NAME;
}
} else {
// differentiate between disabled and non-existing events
boolean isRegistered = debugEvent.containsModuleEventName(param1, param2);
if (isRegistered) {
choice = Option.ONE_MODULE_EVENT;
} else {
choice = Option.ERROR_BAD_MODULE_EVENT_NAME;
}
}
switch (choice) {
case ALL:
debugEvent.resetAllEvents();
break;
case ONE_MODULE:
debugEvent.resetAllModuleEvents(param1);
break;
case ONE_MODULE_EVENT:
debugEvent.resetSingleEvent(param1, param2);
break;
case ERROR_BAD_MODULE_NAME:
output.error = "Module name has no corresponding registered events";
break;
case ERROR_BAD_MODULE_EVENT_NAME:
output.error = "Event not registered";
break;
case ERROR_BAD_PARAM:
output.error = "Bad param";
}
}
return output;
}
/**
* Return the debug event data for the get rest-api call
*
* URL must be in one of the following forms for retrieving a list
* moduleNames "http://{controller-hostname}:8080/wm/debugevent/
* counterNames "http://{controller-hostname}:8080/wm/debugevent/{moduleName}
*
* URL must be in one of the following forms for retrieving event data:
* "http://{controller-hostname}:8080/wm/debugevent/{param1}
* "http://{controller-hostname}:8080/wm/debugevent/{param1}/{param2}
*
* where {param1} must be one of (no quotes):
* null if nothing is given then by default the list
* of all moduleNames is returned for which
* events have been registered
* "all" can return value/info on all active events
* but is currently disallowed
* "{moduleName}" returns value/info on events for the specified module
* depending on the value of param2
* and {param2} must be one of (no quotes):
* null returns all eventNames registered for the
* given moduleName (in param1)
* "{eventName}" returns value/info for specific event if it is active.
*
*/
@Get("json")
public DebugEventInfoOutput handleEventInfoQuery() {
Option choice = Option.ERROR_BAD_PARAM;
DebugEventInfoOutput output;
String laststr = getQueryValue("last");
int last = Integer.MAX_VALUE;
try {
if (laststr != null)
last = Integer.valueOf(laststr);
if (last < 1) last = Integer.MAX_VALUE;
} catch (NumberFormatException e) {
output = new DebugEventInfoOutput(false);
output.error = "Expected an integer requesting last X events;" +
" received " + laststr;
return output;
}
String param1 = (String)getRequestAttributes().get("param1");
String param2 = (String)getRequestAttributes().get("param2");
if (param1 == null) {
output = new DebugEventInfoOutput(true);
return listEvents(output);
} else if (param1.equals("all")) {
output = new DebugEventInfoOutput(false);
//populateEvents(debugEvent.getAllEventHistory(), output);
output.error = "Cannot retrieve all events - please select a specific event";
return output;
}
if (param2 == null) {
output = new DebugEventInfoOutput(true);
boolean isRegistered = debugEvent.containsModuleName(param1);
if (isRegistered) {
return listEvents(param1, output);
} else {
choice = Option.ERROR_BAD_MODULE_NAME;
}
} else if (param2.equals("all")) {
output = new DebugEventInfoOutput(false);
//choice = Option.ONE_MODULE;
output.error = "Cannot retrieve all events - please select a specific event";
return output;
} else {
// differentiate between disabled and non-existing events
boolean isRegistered = debugEvent.containsModuleEventName(param1, param2);
if (isRegistered) {
choice = Option.ONE_MODULE_EVENT;
} else {
choice = Option.ERROR_BAD_MODULE_EVENT_NAME;
}
}
output = new DebugEventInfoOutput(false);
switch (choice) {
case ONE_MODULE:
populateEvents(debugEvent.getModuleEventHistory(param1), output);
break;
case ONE_MODULE_EVENT:
populateSingleEvent(debugEvent.getSingleEventHistory(param1, param2, last),
output);
break;
case ERROR_BAD_MODULE_NAME:
output.error = "Module name has no corresponding registered events";
break;
case ERROR_BAD_MODULE_EVENT_NAME:
output.error = "Event not registered";
break;
case ERROR_BAD_PARAM:
default:
output.error = "Bad param";
}
return output;
}
private DebugEventInfoOutput listEvents(DebugEventInfoOutput output) {
output.names = debugEvent.getModuleList();
return output;
}
private DebugEventInfoOutput listEvents(String moduleName,
DebugEventInfoOutput output) {
output.names = debugEvent.getModuleEventList(moduleName);
return output;
}
private void populateSingleEvent(DebugEventInfo singleEventHistory,
DebugEventInfoOutput output) {
if (singleEventHistory != null) {
output.eventMap.put(singleEventHistory.getEventInfo().getModuleEventName(),
output.new DEInfo(singleEventHistory));
}
}
private void populateEvents(List<DebugEventInfo> eventHistory,
DebugEventInfoOutput output) {
if (eventHistory != null) {
for (DebugEventInfo de : eventHistory)
populateSingleEvent(de, output);
}
}
}