/* ONF SampleTap Software License
Copyright ©2014 Open Networking Foundation
This ONF SampleTap software is 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 original
license at http://www.apache.org/licenses/LICENSE-2.0 and also in
the main directory of the source distribution.
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.
End of ONF SampleTap Software License
*/
package org.opendaylight.controller.samples.onftappingapp;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.UnknownHostException;
import javax.transaction.NotSupportedException;
import org.slf4j.Marker;
import org.slf4j.MarkerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.PropertyConfigurator;
import com.mongodb.BasicDBObject;
import com.mongodb.BasicDBObjectBuilder;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;
import org.bson.types.ObjectId;
import org.opendaylight.controller.forwardingrulesmanager.FlowEntry;
import org.opendaylight.controller.forwardingrulesmanager.IForwardingRulesManager;
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.core.NodeConnector;
import org.opendaylight.controller.sal.core.UpdateType;
import org.opendaylight.controller.sal.reader.NodeDescription;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.controller.samples.onftappingapp.internal.ONFTappingAppImpl;
public class TappingApp {
private static Logger logger = LoggerFactory.getLogger(ONFTappingAppImpl.class);
// We use fatal in our application so get a marker for FATAL
static Marker fatal = MarkerFactory.getMarker("FATAL");
// Application global variables
private static Properties applicationProps = new Properties(System.getProperties());
private static String mongoDBUsername = "";
private static String mongoDBPassword = "";
private static String wwwRootdir = "";
private final String appName;
private final String hostname;
private final String version = "1.0";
private boolean captureARP = false;
private static int mongoDBPort = 27017; // Default MongoDB Port
private MongoClient mongoClient; // Our MongoDB (Client) Connector
private static DB database; // Our handle to MongoDB database
// Instantiate the class that implements the application logic for pushing flows into ODL
private TappingAppLogic tappingAppLogic = new TappingAppLogic(this);
private ONFTappingAppImpl onfTappingAppImpl = null;
// A Map<DataPathDescString, OPFSwitch> of unassigned OPF switches
Map<String, OPFSwitch> unassignedOPFSwitchMap = new HashMap<String, OPFSwitch>();
// A Map<DataPathDescString, OPFSwitch> of assigned OPF switches
Map<String, OPFSwitch> assignedOPFSwitchMap = new HashMap<String, OPFSwitch>();
// The ruleDB is a Map of Nodes to an ArrayList of FlowEntries. The index into the list is the port number
private Map<Node, List<FlowEntry>> rulesDB = new HashMap<Node, List<FlowEntry>>();
// Return codes from the programming of the perHost rules into the switch
public enum RulesProgrammingReturnCode {
SUCCESS, FAILED_FEW_SWITCHES, FAILED_ALL_SWITCHES, FAILED_WRONG_PARAMS
}
// Constructor
public TappingApp(String appName, String hostname, ONFTappingAppImpl onfTappingAppImpl) throws DBAuthenticationException, DatabaseConnectException {
this.appName = appName;
this.hostname = hostname;
this.onfTappingAppImpl = onfTappingAppImpl;
// Configure the logging system
PropertyConfigurator.configure("log4j.properties");
BasicConfigurator.configure();
// Announce that the application has been launched
logger.info("Tapping App: " + this.getName() + " version: " + this.getVersion());
// Load application configuration from the configuration file in CLASSPATH
try {
loadConfigurationFromFile();
} catch (IOException e) {
logger.error(fatal, "Unable to load ONS Tapping Application configuration file");
logger.debug("Exception:", e);
return;
}
// Set the mongo DB port if it is specified in the configuration file
if (System.getProperties().containsKey("MongoDBPort"))
setMongoDBPort(Integer.getInteger("MongoDBPort"));
try {
// MongoDB username and password are loaded from the application's configuration file
connectToDatabase(mongoDBUsername, mongoDBPassword);
} catch (DBAuthenticationException authException) {
logger.error("Unable to connect to database " + authException.toString());
throw authException;
} catch (DatabaseConnectException dbException) {
logger.error("Unable to connect to database " + dbException.toString());
throw dbException;
}
// TODO - remove after integration
//this.purgeObjectModelFromDatabase();
// TODO - remove after integration
// Make stuff up for the GUI integration
// makeFakeOPFSwitches();
}
// Class destructor - call on shutdown
public void close() {
try {
saveConfigurationToFile();
} catch (IOException e) {
logger.error("Unable to save ONS Tapping Application configuration file");
logger.debug("Exception:", e);
}
}
public static int getMongoDBPort() {
return mongoDBPort;
}
public void setMongoDBPort(int i_mongoDBPort) {
mongoDBPort = i_mongoDBPort;
}
public static DB getDatabase() {
return database;
}
// Getters and setters
public String getName() {
return appName;
}
public String getHostname() {
return hostname;
}
public String getVersion() {
return version;
}
public boolean getCaptureARP() {
return captureARP;
}
public void setCaptureARP(boolean captureARP) {
this.captureARP = captureARP;
logger.info("ARP Capture was " + (captureARP ? "Enabled" : "Disabled"));
}
public static String getWwwRootdir() {
return wwwRootdir;
}
private void loadConfigurationFromFile() throws IOException {
// now load properties from last invocation
FileInputStream in = new FileInputStream("ONSTappingApp.config");
applicationProps.load(in);
in.close();
// Store the application properties in the system properties
System.setProperties(applicationProps);
mongoDBUsername = applicationProps.getProperty("MongoDBUsername");
mongoDBPassword = applicationProps.getProperty("MongoDBPassword");
wwwRootdir = applicationProps.getProperty("www-rootdir");
logger.info("MongoDB credentials: username '" + mongoDBUsername + "' password '" + mongoDBPassword + "'");
logger.info("WWW Root Dir: " + wwwRootdir);
}
// Store the application properties to the configuration file
private static void saveConfigurationToFile() throws IOException {
FileOutputStream out = new FileOutputStream("ONSTappingApp.config");
Properties properties = new Properties();
properties.setProperty("MongoDBUsername", mongoDBUsername);
properties.setProperty("MongoDBPassword", mongoDBPassword);
String mongoPort = Integer.toString(TappingApp.getMongoDBPort());
properties.setProperty("MongoDBPort", mongoPort);
properties.store(out, "Settings for the ONS Tapping Application");
out.close();
}
public void connectToDatabase(String dbUsername, String dbPassword) throws DatabaseConnectException, DBAuthenticationException {
try {
mongoClient = new MongoClient("localhost", mongoDBPort);
database = mongoClient.getDB(DatabaseNames.getDatabaseName());
// If the username and password are set then authenticate against the DB
if (dbUsername.isEmpty() || dbPassword.isEmpty()) {
logger.info("MongoDB username or password are not set, so database authentication is not used");
}
else {
boolean auth = database.authenticate(dbUsername, dbPassword.toCharArray());
if (!auth) {
throw new DBAuthenticationException();
}
}
logger.info("Connected to configuration database " + database.toString());
} catch (UnknownHostException e) {
logger.error("Error while connecting to Database", e);
throw new DatabaseConnectException();
}
}
public void purgeObjectModelFromDatabase() {
DBCollection tpTable = database.getCollection(DatabaseNames.getTapPolicyTableName());
tpTable.drop();
DBCollection mcTable = database.getCollection(DatabaseNames.getMatchCriteriaTableName());
mcTable.drop();
DBCollection seTable = database.getCollection(DatabaseNames.getSwitchEntryTableName());
seTable.drop();
DBCollection nhsTable = database.getCollection(DatabaseNames.getNextHopSwitchTableName());
nhsTable.drop();
DBCollection pcTable = database.getCollection(DatabaseNames.getPortChainTableName());
pcTable.drop();
DBCollection cdTable = database.getCollection(DatabaseNames.getCaptureDevTableName());
cdTable.drop();
DBCollection logTable = database.getCollection(DatabaseNames.getLoggerTableName());
logTable.drop();
}
// Return a list containing all the Tap Policies by loading them from the database
public List<TapPolicy> getAllTapPolicies() {
DBCollection tpTable = database.getCollection(DatabaseNames.getTapPolicyTableName());
DBCursor cursor = tpTable.find();
List<TapPolicy> tapPolicyList = new ArrayList<TapPolicy>(cursor.size());
try {
while(cursor.hasNext()) {
// Get the object from the database
DBObject tapPolicyObj = cursor.next();
// Construct a new tap policy from the DBobject and add it to list
tapPolicyList.add(new TapPolicy(tapPolicyObj));
}
} catch (NotFoundException e) {
logger.error("Object referenced by Tap Policy cannot be found", e);
} finally {
cursor.close();
}
return tapPolicyList;
}
// // Return a list containing all the Match Criteria by loading them from the database
public List<MatchCriteria> getAllMatchCriteria() {
DBCollection mcTable = database.getCollection(DatabaseNames.getMatchCriteriaTableName());
DBCursor cursor = mcTable.find();
List<MatchCriteria> matchCriteriaList = new ArrayList<MatchCriteria>(cursor.size());
try {
while(cursor.hasNext()) {
DBObject matchCriteriaObj = cursor.next();
MatchCriteria matchCriteria = new MatchCriteria(matchCriteriaObj);
matchCriteriaList.add(matchCriteria);
}
} finally {
cursor.close();
}
return matchCriteriaList;
}
// Return a list containing all the SwitchEntries
public List<SwitchEntry> getAllSwitchEntries() {
DBCollection seTable = database.getCollection(DatabaseNames.getSwitchEntryTableName());
DBCursor cursor = seTable.find();
List<SwitchEntry> switchEntryList = new ArrayList<SwitchEntry>(cursor.size());
try {
while(cursor.hasNext()) {
DBObject switchEntryObj = cursor.next();
SwitchEntry switchEntry = new SwitchEntry(switchEntryObj, this);
// Add the new SwitchEntry to the list
switchEntryList.add(switchEntry);
}
} finally {
cursor.close();
}
return switchEntryList;
}
private void makeFakeOPFSwitches() {
OPFSwitch opfSwitch1 = new OPFSwitch();
opfSwitch1.setIPAddress("10.2.34.2");
opfSwitch1.setDescription("Fake Switch 1");
opfSwitch1.setMACAddress("aa:bb:cc:dd:ee:11");
opfSwitch1.setMFRDescription("WTL Fake Switch");
opfSwitch1.setHardwareDesc("Fake hardware");
opfSwitch1.setSoftwareDesc("Fake software");
opfSwitch1.setSerialNumber("ABCDEFG");
opfSwitch1.setDataPathDesc("FGHD-JIVS-6DF1S-KLSAQ");
// Simulate a 24 port switch
List<PortDescription> fakePortDescList1 = new ArrayList<PortDescription>();
for (int port = 0; port < 24; port++) {
fakePortDescList1.add(new PortDescription("Port " + port, "11:22:33:44:aa:bb", port));
}
opfSwitch1.setPortDescList(fakePortDescList1);
// Add the OPFSwitch to the map
unassignedOPFSwitchMap.put(opfSwitch1.getDataPathDesc(), opfSwitch1);
OPFSwitch opfSwitch2 = new OPFSwitch();
//ObjectId oid2 = new ObjectId();
//opfSwitch2.setObjectId(oid2.toString());
opfSwitch2.setIPAddress("10.2.15.143");
opfSwitch2.setDescription("Fake Switch 2");
opfSwitch2.setMACAddress("aa:bb:11:22:f4:1c");
opfSwitch2.setMFRDescription("WTL Fake Switch");
opfSwitch2.setHardwareDesc("Fake hardware");
opfSwitch2.setSoftwareDesc("Fake software");
opfSwitch2.setSerialNumber("ZXCVBNK");
opfSwitch2.setDataPathDesc("JDSS-IODS-8FD8D-LKODQ");
// Simulate a 24 port switch
List<PortDescription> fakePortDescList2 = new ArrayList<PortDescription>();
for (int port = 0; port < 24; port++) {
fakePortDescList2.add(new PortDescription("Port " + port, "bb:1c:f3:ac:12:ea", port));
}
opfSwitch2.setPortDescList(fakePortDescList2);
// Add the OPF Switch to the map
unassignedOPFSwitchMap.put(opfSwitch2.getDataPathDesc(), opfSwitch2);
}
// Return a list containing all the unassigned OPFSwitch objects
public List<OPFSwitch> getAllUnassignedSwitchEntries() {
logger.info("Getting App Unassigned Switch Entries");
logger.info("Unassigned Map " + this.unassignedOPFSwitchMap);
logger.info("Assigned Map " + this.assignedOPFSwitchMap);
// Clone the Map into a list
List<OPFSwitch> unassignedOPFSwitchList = new ArrayList<OPFSwitch>(unassignedOPFSwitchMap.values());
return unassignedOPFSwitchList;
}
// Return a list containing all the NextHopSwitches
public List<NextHopSwitch> getAllNextHopSwitches() {
DBCollection nhsTable = database.getCollection(DatabaseNames.getNextHopSwitchTableName());
DBCursor cursor = nhsTable.find();
List<NextHopSwitch> nextHopSwitchList = new ArrayList<NextHopSwitch>(cursor.size());
try {
while(cursor.hasNext()) {
DBObject nhsObj = cursor.next();
NextHopSwitch nhs = new NextHopSwitch(nhsObj);
// Add the new SwitchEntry to the list
nextHopSwitchList.add(nhs);
}
} finally {
cursor.close();
}
return nextHopSwitchList;
}
// Return a list containing all the Port Chain objects
public List<PortChain> getAllPortChains() {
DBCollection pcTable = database.getCollection(DatabaseNames.getPortChainTableName());
DBCursor cursor = pcTable.find();
List<PortChain> portChainList = new ArrayList<PortChain>(cursor.size());
try {
while(cursor.hasNext()) {
DBObject portChainObj = cursor.next();
// Construct a new port chain from the DB object
PortChain portChain = new PortChain(portChainObj);
// Add the new port chain to the list
portChainList.add(portChain);
}
} finally {
cursor.close();
}
return portChainList;
}
// Return a list containing all the Capture Devices
public List<CaptureDev> getAllCaptureDevices() {
DBCollection pcTable = database.getCollection(DatabaseNames.getCaptureDevTableName());
DBCursor cursor = pcTable.find();
List<CaptureDev> captureDevList = new ArrayList<CaptureDev>(cursor.size());
while(cursor.hasNext()) {
DBObject captureDevObj = cursor.next();
// Construct a new CaptureDev from the document
CaptureDev captureDev = new CaptureDev(captureDevObj);
// Add it to the list
captureDevList.add(captureDev);
}
return captureDevList;
}
// Returns a summary list of the Tap Policies that have been defined
public List<TapPolicySummary> getTapPolicySummaries() {
List<TapPolicySummary> summaryList = new ArrayList<TapPolicySummary>();
DBCollection table = database.getCollection(DatabaseNames.getTapPolicyTableName());
// Run a query to look for all the Tap Policies
DBCursor cursor = table.find();
while (cursor.hasNext()) {
DBObject doc = cursor.next();
TapPolicySummary summary = new TapPolicySummary((String) doc.get("_id").toString(), (String) doc.get("name"), (String) doc.get("description"), (Boolean) doc.get("enabled"));
summaryList.add(summary);
}
return summaryList;
}
public void assignSwitch(String OPFSwitchId, String switchEntryId) throws NotFoundException, OPFSwitchNotFoundException, OPFSwitchIsAssignedException {
// Look for the OPF Switch in the assigned list
OPFSwitch opfSwitch = getAssignedOPFSwitchById(OPFSwitchId);
if (opfSwitch != null)
throw new OPFSwitchIsAssignedException();
// Look for the OPF Switch in the unassigned list
opfSwitch = getUnAssignedOPFSwitchById(OPFSwitchId);
if (opfSwitch == null)
throw new OPFSwitchNotFoundException();
// We found it. Does it think it is already assigned?
if (opfSwitch.getAssigned() == true) {
// This OPFSwitch is already assigned
throw new OPFSwitchIsAssignedException();
}
// Look for the SwitchEntry by id
SwitchEntry switchEntry = getSwitchEntryById(switchEntryId);
logger.info("SwitchEntry " + switchEntry);
// Finally, we can assign the OPF switch to the switch entry
switchEntry.assignOPFSwitch(opfSwitch);
// Update the database
modifySwitchEntry(switchEntryId, switchEntry);
// Move the OPFSwitch from the unassigned to the assigned map
assignOPFSwitch(OPFSwitchId, opfSwitch);
logger.info("Assigned OPFSwitch " + opfSwitch.getSerialNumber() + " at IP address " + opfSwitch.getIPAddressStr() + " to SwitchEntry with ID " + switchEntryId);
// Send the flows to the switch
// TODO need to look up the node here so we can send the flows
//this.switchChanged(UpdateType.CHANGED, node);
}
// Move the OPFSwitch from the unassigned to the assigned map
private void assignOPFSwitch(String OPFSwitchId, OPFSwitch opfSwitch) {
logger.info("Assigning OPF Switch " + opfSwitch);
this.unassignedOPFSwitchMap.remove(OPFSwitchId);
this.assignedOPFSwitchMap.put(OPFSwitchId, opfSwitch);
}
// Move the OPFSwitch from the assigned to the unassigned map
private void unassignOPFSwitch(String OPFSwitchId, OPFSwitch opfSwitch) {
logger.info("Unassigning OPF Switch " + opfSwitch);
this.assignedOPFSwitchMap.remove(OPFSwitchId);
this.unassignedOPFSwitchMap.put(OPFSwitchId, opfSwitch);
}
public void unassignSwitch(String OPFSwitchId, String switchEntryId) throws NotFoundException, OPFSwitchNotFoundException, OPFSwitchIsNotAssignedException {
// Look for the OPF Switch in the unassigned list
OPFSwitch opfSwitch = getUnAssignedOPFSwitchById(OPFSwitchId);
if (opfSwitch != null)
throw new OPFSwitchIsNotAssignedException();
// Look for the OPF Switch in the assigned list
opfSwitch = getAssignedOPFSwitchById(OPFSwitchId);
if (opfSwitch == null)
throw new OPFSwitchNotFoundException();
// We found it. Does it think it is already unassigned?
if (opfSwitch.getAssigned() == false) {
// This OPFSwitch is already assigned
throw new OPFSwitchIsNotAssignedException();
}
// Move the OPFSwitch from the assigned to the unassigned map
unassignOPFSwitch(OPFSwitchId, opfSwitch);
// Look for the SwitchEntry by id
SwitchEntry switchEntry = getSwitchEntryById(switchEntryId);
// Finally, we can un-assign the OPF switch from the switch entry
switchEntry.unassignOPFSwitch(opfSwitch);
// Update the database
modifySwitchEntry(switchEntryId, switchEntry);
logger.info("Unassigned OPFSwitch " + opfSwitch.getSerialNumber() + " at IP address " + opfSwitch.getIPAddressStr() + " from " + switchEntryId);
}
// Add a new policy to the system.
public void addTapPolicy(TapPolicy tapPolicy) throws DuplicateEntryException {
// Check whether there is an existing policy with the same name
if (tapPolicyExistsByName(tapPolicy.getName()))
throw new DuplicateEntryException();
// Get the tap policy table
DBCollection table = database.getCollection(DatabaseNames.getTapPolicyTableName());
// Create a document containing the new tap policy
BasicDBObject document = tapPolicy.getAsDocument();
// Add the new tap policy document to the tap policy table
table.insert(document);
// Get the object ID from mongo and update it in the tap policy object
ObjectId objectId = document.getObjectId("_id");
tapPolicy.setObjectId(objectId.toString());
logger.info("Added tap policy " + tapPolicy.getName() + " object ID " + tapPolicy.getObjectId());
// Notify the application that the tap policy changed
// tappingAppLogic.NotifyConfigChange(DBTableChangeEnum.TAP_POLICY, tapPolicy.getObjectId());
}
// Delete the TapPolicy with the specified objectId
public void deleteTapPolicy(String objectId) throws NotFoundException {
DBCollection table = database.getCollection(DatabaseNames.getTapPolicyTableName());
// Create a query to look for the existing TapPolicy by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(objectId));
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
// We are deleting this tapPolicy, so remove references to other objects
TapPolicy.removeObjectReferences(dbObj);
// Remove the TapPolicy from the database
table.remove(searchQuery);
logger.info("Removed tap policy " + (String) dbObj.get("name"));
// Notify the application that the tap policy changed
// TODO - add objectID
// tappingAppLogic.NotifyConfigChange(DBTableChangeEnum.TAP_POLICY);
}
// Return true if the database contains a TapPolicy with the specified name
private boolean tapPolicyExistsByName(String name) {
DBCollection table = database.getCollection(DatabaseNames.getTapPolicyTableName());
// Run a query to look for the TapPolicy name
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("name", name);
DBObject dbObj = table.findOne(searchQuery);
return (dbObj != null) ? true : false;
}
public void modifyTapPolicy(final String tapPolicyId, TapPolicy tapPolicy) throws NotFoundException {
DBCollection table = database.getCollection(DatabaseNames.getTapPolicyTableName());
// Create a query to look for the existing TapPolicy by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(tapPolicyId));
// Check whether the policy exists
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
// Create a document containing the new tap policy
BasicDBObject newDocument = tapPolicy.getAsDocument();
BasicDBObject updateObj = new BasicDBObject();
updateObj.put("$set", newDocument);
// Update the document in the database
table.update(searchQuery, updateObj);
logger.info("Updated tap policy id " + tapPolicyId);
}
// Add a new match criteria to the system
public void addMatchCriteria(MatchCriteria matchCriteria) throws DuplicateEntryException {
// Check whether there is an existing match criteria with the same name
if (matchCriteriaExistsByName(matchCriteria.getName()))
throw new DuplicateEntryException();
// Get the match criteria table
DBCollection table = database.getCollection(DatabaseNames.getMatchCriteriaTableName());
// Create a document containing the new match criteria
BasicDBObject document = matchCriteria.getAsDocument();
// Add the new tap policy document to the MatchCriteria table
table.insert(document);
// Get the object ID from mongo and update it in the MatchCriteria object
ObjectId objectId = document.getObjectId("_id");
matchCriteria.setObjectId(objectId.toString());
logger.info("Added match criteria " + matchCriteria.getName() + " object ID " + matchCriteria.getObjectId());
// tappingAppLogic.NotifyConfigChange(DBTableChangeEnum.MATCH_CRITERIA, matchCriteria.getObjectId());
}
private boolean matchCriteriaExistsByName(String name) {
DBCollection table = database.getCollection(DatabaseNames.getMatchCriteriaTableName());
// Run a query to look for the Match Criteria name
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("name", name);
DBObject dbObj = table.findOne(searchQuery);
return (dbObj != null) ? true : false;
}
public void deleteMatchCriteria(final String objectId) throws NotFoundException, ObjectInUseException {
DBCollection table = database.getCollection(DatabaseNames.getMatchCriteriaTableName());
// Create a query to look for the existing TapPolicy by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(objectId));
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
if ((long) dbObj.get("refCount") != 0) {
throw new ObjectInUseException();
}
// Remove the Match Criteria from the database
table.remove(searchQuery);
logger.info("Removed match criteria " + (String) dbObj.get("name"));
}
public void modifyMatchCriteria(final String matchCriteriaId, MatchCriteria matchCriteria) throws NotFoundException {
DBCollection table = database.getCollection(DatabaseNames.getMatchCriteriaTableName());
logger.info("Match Criteria enabled " + matchCriteria.getEnabled());
// Create a query to look for the existing TapPolicy by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(matchCriteriaId));
// Check whether the policy exists
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
// Create a document containing the new tap policy
BasicDBObject newDocument = matchCriteria.getAsDocument();
BasicDBObject updateObj = new BasicDBObject();
updateObj.put("$set", newDocument);
// Update the document in the database
table.update(searchQuery, updateObj);
logger.info("Updated match criteria id " + matchCriteriaId);
}
public void addSwitchEntry(SwitchEntry switchEntry) throws DuplicateEntryException, NotSupportedException {
// We aren't supporting this mode yet
if (switchEntry.getTappingMode() == TappingModeEnum.NORMAL) {
throw new NotSupportedException("Normal Mode is not suppored");
}
// Check whether there is an existing switch entry with the same name
if (switchEntryExistsByName(switchEntry.getName()))
throw new DuplicateEntryException();
// Get the match criteria table
DBCollection table = database.getCollection(DatabaseNames.getSwitchEntryTableName());
// Create a document containing the new match criteria
BasicDBObject document = switchEntry.getAsDocument();
// Add the new tap policy document to the tap policy table
table.insert(document);
// Get the object ID from mongo and update it in the switch entry object
ObjectId objectId = document.getObjectId("_id");
switchEntry.setObjectId(objectId.toString());
logger.info("Added Switch Entry " + switchEntry.getName() + " object ID " + switchEntry.getObjectId());
}
public void modifySwitchEntry(final String switchEntryId, SwitchEntry switchEntry) throws NotFoundException {
DBCollection table = database.getCollection(DatabaseNames.getSwitchEntryTableName());
// Create a query to look for the existing SwitchEntry by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(switchEntryId));
// Check whether the switchEntry exists
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
// Create a document containing the new switch Entry
BasicDBObject newDocument = switchEntry.getAsDocument();
BasicDBObject updateObj = new BasicDBObject();
updateObj.put("$set", newDocument);
// Update the document in the database
table.update(searchQuery, updateObj);
logger.info("Updated SwitchEntry id " + switchEntryId);
}
// Delete the SwitchEntry with the specified objectId
public void deleteSwitchEntry(String objectId) throws NotFoundException, ObjectInUseException {
DBCollection table = database.getCollection(DatabaseNames.getSwitchEntryTableName());
// Create a query to look for the existing SwitchEntry by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(objectId));
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
if ((long) dbObj.get("refCount") != 0) {
throw new ObjectInUseException();
}
// Get the existing portChain
String switchName = (String) dbObj.get("name");
// Remove the PortChain from the database
table.remove(searchQuery);
logger.info("Removed switch " + switchName);
// Notify the application that the port chaun changed
// TODO - add objectID
// tappingAppLogic.NotifyConfigChange(DBTableChangeEnum.SWITCH_ENTRY);
}
private boolean switchEntryExistsByName(String switchName) {
DBCollection table = database.getCollection(DatabaseNames.getSwitchEntryTableName());
// Run a query to look for the SwitchEntry name
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("name", switchName);
DBObject dbObj = table.findOne(searchQuery);
return (dbObj != null) ? true : false;
}
public SwitchEntry findSwitchByDataPathId(final String switchId) throws NotFoundException {
DBCollection table = database.getCollection(DatabaseNames.getSwitchEntryTableName());
// Create a query to look for the existing SwitchEntry by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("OPFSwitchDatapath", switchId);
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
SwitchEntry switchEntry = null;
switchEntry = new SwitchEntry(dbObj, this);
return switchEntry;
}
public void addNextHopSwitch(NextHopSwitch nextHopSwitch) throws DuplicateEntryException {
// Check whether there is an existing next hop switch with the same name
if (nextHopSwitchExistsByName(nextHopSwitch.getName()))
throw new DuplicateEntryException();
// Get the match criteria table
DBCollection table = database.getCollection(DatabaseNames.getNextHopSwitchTableName());
// Create a document containing the new match criteria
BasicDBObject document = nextHopSwitch.getAsDocument();
// Add the new tap policy document to the tap policy table
table.insert(document);
// Get the object ID from mongo and update it in the switch entry object
ObjectId objectId = document.getObjectId("_id");
nextHopSwitch.setObjectId(objectId.toString());
logger.info("Added Next Hop Switch " + nextHopSwitch.getName() + " object ID " + nextHopSwitch.getObjectId());
}
public void modifyNextHopSwitch(final String nhsId, NextHopSwitch nextHopSwitch) throws NotFoundException {
DBCollection table = database.getCollection(DatabaseNames.getNextHopSwitchTableName());
// Create a query to look for the existing NextHopSwitch by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(nhsId));
// Check whether the nextHopSwitch exists
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
// Create a document containing the new nextHopSwitch
BasicDBObject newDocument = nextHopSwitch.getAsDocument();
BasicDBObject updateObj = new BasicDBObject();
updateObj.put("$set", newDocument);
// Update the document in the database
table.update(searchQuery, updateObj);
logger.info("Updated NextHopSwitch id " + nhsId);
}
// Delete the NextHopSwitch with the specified objectId
public void deleteNextHopSwitch(String objectId) throws NotFoundException {
DBCollection table = database.getCollection(DatabaseNames.getNextHopSwitchTableName());
// Create a query to look for the existing NextHopSwitch by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(objectId));
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
// Get the existing nextHopSwitch name
String nhsName = (String) dbObj.get("name");
// Remove the nextHopSwitch from the database
table.remove(searchQuery);
logger.info("Removed Next Hop Switch " + nhsName);
// Notify the application that the capture device changed
// TODO - add objectID
// tappingAppLogic.NotifyConfigChange(DBTableChangeEnum.NEXT_HOP_SWITCH;
}
private boolean nextHopSwitchExistsByName(String switchName) {
DBCollection table = database.getCollection(DatabaseNames.getSwitchEntryTableName());
// Run a query to look for the SwitchEntry name
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("name", switchName);
DBObject dbObj = table.findOne(searchQuery);
return (dbObj != null) ? true : false;
}
public void addCaptureDevice(CaptureDev captureDev) throws DuplicateEntryException {
// Check whether there is an existing capture device with the same name
if (captureDeviceExistsByName(captureDev.getName()))
throw new DuplicateEntryException();
// Get the match criteria table
DBCollection table = database.getCollection(DatabaseNames.getCaptureDevTableName());
// Create a document containing the new match criteria
BasicDBObject document = captureDev.getAsDocument();
// Add the new tap policy document to the tap policy table
table.insert(document);
// Get the object ID from mongo and update it in the switch entry object
ObjectId objectId = document.getObjectId("_id");
captureDev.setObjectId(objectId.toString());
logger.info("Added Next Hop Switch " + captureDev.getName() + " object ID " + captureDev.getObjectId());
}
private boolean captureDeviceExistsByName(String name) {
DBCollection table = database.getCollection(DatabaseNames.getCaptureDevTableName());
// Run a query to look for the SwitchEntry name
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("name", name);
DBObject dbObj = table.findOne(searchQuery);
return (dbObj != null) ? true : false;
}
public void modifyCaptureDev(final String captureDevId, CaptureDev captureDev) throws NotFoundException {
DBCollection table = database.getCollection(DatabaseNames.getCaptureDevTableName());
// Create a query to look for the existing CaptureDev by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(captureDevId));
// Check whether the CaptureDev exists
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
// Create a document containing the new switch Entry
BasicDBObject newDocument = captureDev.getAsDocument();
BasicDBObject updateObj = new BasicDBObject();
updateObj.put("$set", newDocument);
// Update the document in the database
table.update(searchQuery, updateObj);
logger.info("Updated CaptureDev id " + captureDevId);
}
// Delete the CaptureDev with the specified objectId
public void deleteCaptureDev(String objectId) throws NotFoundException, ObjectInUseException {
DBCollection table = database.getCollection(DatabaseNames.getCaptureDevTableName());
// Create a query to look for the existing CaptureDev by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(objectId));
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
if ((long) dbObj.get("refCount") != 0) {
throw new ObjectInUseException();
}
// Get the existing captureDev
String captureDevName = (String) dbObj.get("name");
// Remove the captureDev from the database
table.remove(searchQuery);
logger.info("Removed Capture Device " + captureDevName);
// Notify the application that the capture device changed
// TODO - add objectID
// tappingAppLogic.NotifyConfigChange(DBTableChangeEnum.CAPTURE_DEVICE);
}
public void addPortChain(PortChain portChain) throws DuplicateEntryException {
// Check whether there is an existing port chain with the same name
if (portChainExistsByName(portChain.getName()))
throw new DuplicateEntryException();
// Get the match criteria table
DBCollection table = database.getCollection(DatabaseNames.getPortChainTableName());
// Create a document containing the new match criteria
BasicDBObject document = portChain.getAsDocument();
// Add the new tap policy document to the tap policy table
table.insert(document);
// Get the object ID from mongo and update it in the switch entry object
ObjectId objectId = document.getObjectId("_id");
portChain.setObjectId(objectId.toString());
logger.info("Added Port Chain " + portChain.getName() + " object ID " + portChain.getObjectId());
}
private boolean portChainExistsByName(String name) {
DBCollection table = database.getCollection(DatabaseNames.getPortChainTableName());
// Run a query to look for the PortChain name
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("name", name);
DBObject dbObj = table.findOne(searchQuery);
return (dbObj != null) ? true : false;
}
public void modifyPortChain(final String portChainId, PortChain portChain) throws NotFoundException {
DBCollection table = database.getCollection(DatabaseNames.getPortChainTableName());
// Create a query to look for the existing PortChain by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(portChainId));
// Check whether the PortChain exists
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
// Create a document containing the new portChain
BasicDBObject newDocument = portChain.getAsDocument();
BasicDBObject updateObj = new BasicDBObject();
updateObj.put("$set", newDocument);
// Update the document in the database
table.update(searchQuery, updateObj);
logger.info("Updated PortChain ID " + portChainId);
}
// Delete the PortChain with the specified objectId
public void deletePortChain(String objectId) throws NotFoundException, ObjectInUseException {
DBCollection table = database.getCollection(DatabaseNames.getPortChainTableName());
// Create a query to look for the existing TapPolicy by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(objectId));
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
if ((long) dbObj.get("refCount") != 0) {
throw new ObjectInUseException();
}
// Get the existing PortChain
String portChainName = (String) dbObj.get("name");
// Remove the PortChain from the database
table.remove(searchQuery);
logger.info("Removed Port Chain " + portChainName);
// Notify the application that the port chaun changed
// TODO - add objectID
// tappingAppLogic.NotifyConfigChange(DBTableChangeEnum.PORT_CHAIN);
}
public List<LoggedMessage> loadLoggedMessagesFromDatabase() {
DBCollection logTable = database.getCollection(DatabaseNames.getLoggerTableName());
DBCursor cursor = logTable.find();
List<LoggedMessage> loggedMessageList = processLogMessageCursor(cursor);
cursor.close();
return loggedMessageList;
}
public List<LoggedMessage> loadLoggedMessagesFromDatabase(final Date startDate, final Date endDate) {
DBCollection logTable = database.getCollection(DatabaseNames.getLoggerTableName());
// Create a query to look for log entries after the start date
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("timestamp", BasicDBObjectBuilder.start("$gte", startDate).add("$lte", endDate).get());
DBCursor cursor = logTable.find(searchQuery);
List<LoggedMessage> loggedMessageList = processLogMessageCursor(cursor);
cursor.close();
return loggedMessageList;
}
public List<LoggedMessage> loadLoggedMessagesFromDatabase(final Date startDate) {
DBCollection logTable = database.getCollection(DatabaseNames.getLoggerTableName());
// Create a query to look for log entries after the start date
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("timestamp", new BasicDBObject("$gte", startDate));
DBCursor cursor = logTable.find(searchQuery);
List<LoggedMessage> loggedMessageList = processLogMessageCursor(cursor);
cursor.close();
return loggedMessageList;
}
private List<LoggedMessage> processLogMessageCursor(DBCursor cursor) {
List<LoggedMessage> loggedMessageList = new ArrayList<LoggedMessage>(cursor.size());
while(cursor.hasNext()) {
DBObject logObj = cursor.next();
LoggedMessage logMsg = new LoggedMessage();
ObjectId oid = (ObjectId) logObj.get("_id");
logMsg.setObjectId(oid.toString());
logMsg.setTimestamp((Date) logObj.get("timestamp"));
logMsg.setLogLevel(LoggingLevelEnum.getEnum((String) logObj.get("level")));
logMsg.setThreadId((String) logObj.get("thread"));
logMsg.setMessage((String) logObj.get("message"));
logMsg.setFileName((String) logObj.get("fileName"));
logMsg.setMethodName((String) logObj.get("method"));
logMsg.setLineNumber(Integer.parseInt((String) logObj.get("lineNumber")));
// get these fields from the "host" sub-document
DBObject hostObj = (DBObject) logObj.get("host");
logMsg.setHostname((String) hostObj.get("name"));
logMsg.setHostIP((String) hostObj.get("ip"));
// Add the message to the list
loggedMessageList.add(logMsg);
}
return loggedMessageList;
}
public List<PortStatus> getPortStatus(String switchId) {
// Get the switch info from ODL
SwitchInfo switchInfo = getSwitchInfo(switchId);
List<PortStatus> portStatusList = new ArrayList<PortStatus>(switchInfo.numPorts);
for (int port = 0; port < switchInfo.numPorts; port++) {
LinkStateEnum portState = switchInfo.portStateList.get(port);
boolean live = ((port % 3 == 0) ? true : false);
boolean blocked = ((port % 10 == 0) ? true : false);
PortTypeEnum type = PortTypeEnum.NETWORK_DEVICE;
if (port == 22) type = PortTypeEnum.CAPTURE_DEVICE;
if ((port == 10) || (port == 11)) type = PortTypeEnum.PORT_CHAIN;
portStatusList.add(new PortStatus(port, type, portState, blocked, live));
}
return portStatusList;
}
public List<PortStatistics> getPortStatistics(String switchId) {
// Get the switch statistics from ODL
SwitchInfo switchInfo = getSwitchInfo(switchId);
List<PortStatistics> portStatisticsList = new ArrayList<PortStatistics>(switchInfo.numPorts);
for (int port = 0; port < switchInfo.numPorts; port++) {
PortStatistics portStatistics = switchInfo.portStatisticsList.get(port);
portStatisticsList.add(portStatistics);
}
return portStatisticsList;
}
private SwitchInfo getSwitchInfo(String switchId) {
// Note switch ID is not used yet. Eventually plumb this into ODL
SwitchInfo switchInfo = new SwitchInfo();
return switchInfo;
}
public TapPolicy getTapPolicyById(String tapPolicyId) throws NotFoundException {
DBCollection table = database.getCollection(DatabaseNames.getTapPolicyTableName());
// Create a query to look for the existing TapPolicy by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(tapPolicyId));
// Check whether the policy exists
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
// Construct a new tap policy from the DBobject and add it to list
TapPolicy tapPolicy = new TapPolicy(dbObj);
return tapPolicy;
}
public MatchCriteria getMatchCriteriaById(String matchCriteriaId) throws NotFoundException {
DBCollection table = database.getCollection(DatabaseNames.getMatchCriteriaTableName());
// Create a query to look for the existing MatchCriteria by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(matchCriteriaId));
// Check whether the policy exists
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
// Construct a new match criteria from the DBobject and add it to list
MatchCriteria matchCriteria = new MatchCriteria(dbObj);
return matchCriteria;
}
public SwitchEntry getSwitchEntryById(String switchId) throws NotFoundException {
DBCollection table = database.getCollection(DatabaseNames.getSwitchEntryTableName());
// Create a query to look for the existing SwitchEntry by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(switchId));
// Check whether the policy exists
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
// Construct a new switch entry from the DBobject and return it
SwitchEntry switchEntry = new SwitchEntry(dbObj, this);
logger.info("SwitchEntry " + switchEntry);
return switchEntry;
}
public PortChain getPortChainById(String portChainId) throws NotFoundException {
DBCollection table = database.getCollection(DatabaseNames.getPortChainTableName());
// Create a query to look for the existing PortChain by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(portChainId));
// Check whether the port chain exists
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
// Construct a new port chain from the DBobject and return it
PortChain portChain = new PortChain(dbObj);
return portChain;
}
public static CaptureDev getCaptureDevById(String captureDevId) throws NotFoundException {
DBCollection table = database.getCollection(DatabaseNames.getCaptureDevTableName());
// Create a query to look for the existing CaptureDev by ID
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("_id", new ObjectId(captureDevId));
// Check whether the captureDev exists
DBObject dbObj = table.findOne(searchQuery);
if (dbObj == null)
throw new NotFoundException();
// Construct a caprture dev from the DBobject and return it
CaptureDev captureDev = new CaptureDev(dbObj);
return captureDev;
}
public OPFSwitch getUnAssignedOPFSwitchById(String oPFSwitchDataPath) {
OPFSwitch opfSwitch = unassignedOPFSwitchMap.get(oPFSwitchDataPath);
return opfSwitch;
}
public OPFSwitch getAssignedOPFSwitchById(String oPFSwitchDataPath) {
OPFSwitch opfSwitch = assignedOPFSwitchMap.get(oPFSwitchDataPath);
return opfSwitch;
}
private void runGetAllObjectsUnitTest() {
List<TapPolicy> tapPolicyList = this.getAllTapPolicies();
for(TapPolicy tp : tapPolicyList) {
logger.info(tp.toString());
System.out.println(tp.toString());
}
List<MatchCriteria> matchCriteriaList = this.getAllMatchCriteria();
for(MatchCriteria mc : matchCriteriaList) {
logger.info(mc.toString());
System.out.println(mc.toString());
}
List<SwitchEntry> switchEntryList = this.getAllSwitchEntries();
for(SwitchEntry se : switchEntryList) {
logger.info(se.toString());
System.out.println(se.toString());
}
List<NextHopSwitch> nextHopSwitchList = this.getAllNextHopSwitches();
for(NextHopSwitch nhs : nextHopSwitchList) {
logger.info(nhs.toString());
System.out.println(nhs.toString());
}
List<CaptureDev> captureDevList = this.getAllCaptureDevices();
for(CaptureDev cd : captureDevList) {
logger.info(cd.toString());
System.out.println(cd.toString());
}
List<PortChain> portChains = this.getAllPortChains();
for (PortChain pc : portChains) {
logger.info(pc.toString());
}
}
private void runLogMessageUnitTest() {
List<LoggedMessage> logMessages = this.loadLoggedMessagesFromDatabase();
for(LoggedMessage lm : logMessages) {
logger.info("Log Message " + lm);
System.out.println("Log Messsage " + lm);
}
}
// Called from ODL when a switch is added/modified/removed
public void switchChanged(UpdateType type, Node node) {
logger.info("TappingApp::switchChanged");
this.tappingAppLogic.switchChanged(type, node);
}
public List<TapPolicy> getTapPoliciesForSwitch(SwitchEntry switchEntry) {
DBCollection table = database.getCollection(DatabaseNames.getTapPolicyTableName());
List<TapPolicy> tapPoliciesForSwitch = new ArrayList<TapPolicy>();
logger.info("Searching for Tap Policies for switch with ID " + switchEntry.getObjectId());
BasicDBObject searchQuery = new BasicDBObject();
ObjectId switchId = new ObjectId(switchEntry.getObjectId());
searchQuery.put("switchAndPort.switchEntryId", switchId);
DBCursor cursor = table.find(searchQuery);
logger.info("Query result set contains "+ cursor.count() + "Tap Policies");
try {
while(cursor.hasNext()) {
TapPolicy tapPolicy;
try {
tapPolicy = new TapPolicy(cursor.next());
tapPoliciesForSwitch.add(tapPolicy);
logger.info("Tap Policy " + tapPolicy);
} catch (NotFoundException e) {
logger.warn("Cannot find tap policy");
}
}
} finally {
cursor.close();
}
return tapPoliciesForSwitch;
}
// A new switch connected to ODL. We add it to the list of unassigned switches
public OPFSwitch createOPFSwitch(Node node) {
logger.info("TappingAppLogic::createOPFSwitch");
final String switchId = node.getNodeIDString();
// Get the OPFSwith populated with values from the Node/NodeDescriptor
OPFSwitch opfSwitch = null;
try {
opfSwitch = this.getOPFSwitchFromNode(node);
} catch (InternalError e) {
logger.warn("Unable to get information about OPFSwitch from the Node");
return opfSwitch;
}
if (opfSwitch != null) {
// TODO -get this somehow
opfSwitch.setIPAddress("127.0.0.1");
opfSwitch.setDataPathDesc(switchId);
// Simulate a 24 port switch
List<PortDescription> fakePortDescList = new ArrayList<PortDescription>();
for (int port = 0; port < 24; port++) {
fakePortDescList.add(new PortDescription("Port " + port, "11:22:33:44:aa:bb", port));
}
opfSwitch.setPortDescList(fakePortDescList);
logger.info("Adding ONF Switch entry to unassignedOPFSwitchMap " + opfSwitch);
logger.info("Map Key is " + opfSwitch.getDataPathDesc());
// Add the OPFSwitch to the map
this.unassignedOPFSwitchMap.put(opfSwitch.getDataPathDesc(), opfSwitch);
List<OPFSwitch> foo = this.getAllUnassignedSwitchEntries();
logger.info("Added switch " + switchId + " to the unrecognied switch list");
logger.info("Unassigned Map " + unassignedOPFSwitchMap);
logger.info("Unassigned list " + foo);
}
return opfSwitch;
}
public void removeOPFSwitch(Node node) {
final String switchId = node.getNodeIDString();
logger.info("Removing OPF switch ID " + switchId);
// Look for the switch in the unassigned Map
OPFSwitch opfSwitch = this.unassignedOPFSwitchMap.get(switchId);
if (opfSwitch != null) {
this.unassignedOPFSwitchMap.remove(switchId);
logger.info("Removed unassigned OPF Switch " + switchId);
}
else {
// Look for the switch in the assigned Map
opfSwitch = this.assignedOPFSwitchMap.get(switchId);
if (opfSwitch != null) {
this.assignedOPFSwitchMap.remove(switchId);
}
else {
logger.warn("Attempt to remove nonexistent OPF Switch " + switchId);
}
}
}
// // Temporary code just until we can hook up the GUI
// public void bindSwitchEntryToOPF(String opfSwitchId) throws InternalError {
//
// SwitchEntry switchEntry = null;
// try {
// switchEntry = findSwitchByDataPathId(opfSwitchId);
// } catch (NotFoundException e) {
// logger.info("Can't find switch with ID " + opfSwitchId);
// }
//
// if (switchEntry == null ) {
// logger.info("Creating new SwitchEntry");
//
// SwitchEntry newSwitchEntry = new SwitchEntry();
// newSwitchEntry.setName("OVS Switch 1: br_int");
// newSwitchEntry.setTappingMode(TappingModeEnum.TAPAGGR);
//
// // Add the new switch entry to the system
// try {
// this.addSwitchEntry(newSwitchEntry);
// } catch (DuplicateEntryException e1) {
// logger.error("Internal Error: Duplicate SwitchEntry", e1);
// throw new InternalError("Internal Error: Duplicate SwitchEntry but can't find it");
// }
//
// logger.info("SwitchEntry Added " + newSwitchEntry);
//
// // Assign the OPF Switch to the new SwitchEntry
// try {
// this.assignSwitch(opfSwitchId, newSwitchEntry.getObjectId());
// } catch (NotFoundException e) {
// logger.error("SwitchEntry Not Found", e);
// } catch (OPFSwitchNotFoundException e) {
// logger.error("OPF Switch Not Found, e");
// } catch (OPFSwitchIsAssignedException e) {
// logger.error("OPFSwitch is already assigned", e);
// }
//
// // this.tappingAppLogic.createDemoObjects(newSwitchEntry);
// }
// }
// Return an OPFSwitch object populated with values from the NodeDescriptor
public OPFSwitch getOPFSwitchFromNode(Node node) throws InternalError {
if (this.onfTappingAppImpl.getStatisticsManager() == null) {
logger.warn("ONFTappingAppImpl.StatisticsManager is null");
throw new InternalError();
}
NodeDescription nodeDesc = this.onfTappingAppImpl.getStatisticsManager().getNodeDescription(node);
if (nodeDesc == null){
logger.warn("Node Description is null");
throw new InternalError();
}
else
logger.info("NodeDesc " + nodeDesc);
return new OPFSwitch(nodeDesc, node.getNodeIDString());
}
// Check the assigned and unassigned switch maps
public OPFSwitch getOPFSwitchById(String opfSwitchId) {
// See if we have an existing entry for this OPF Switch
OPFSwitch opfSwitch = this.getAssignedOPFSwitchById(opfSwitchId);
if (opfSwitch == null)
opfSwitch = this.getUnAssignedOPFSwitchById(opfSwitchId);
return opfSwitch;
}
// Add the FlowRules to the ruleMap (in-memory database).
// Rules are installed into the switch by InstallSwitchRules
public void installFlowRules(List<FlowEntry> flowRules, Node node) {
// Add the rules to the rule map (key is the node)
this.rulesDB.put(node, flowRules);
Set<Node> switchesToProgram = new HashSet<Node>();
// Add the switch to the set of switches to program
switchesToProgram.add(node);
// And now send them to the switch
this.pushFlowRulesToSwitch(switchesToProgram);
}
// Routine that fetches the switch rules from the rulesDB and installs them into
// the switch hardware. The one having the same match rules will be
// overwritten silently.
//
// @return a return code to indicate the result of programming the switch
private RulesProgrammingReturnCode pushFlowRulesToSwitch(Set<Node> switchesToProgram) {
logger.info("pushFlowRulesToSwitch");
if (switchesToProgram == null) {
logger.info("No switches to program");
logger.info("Leaving installSwitchRules. Return code is: " + RulesProgrammingReturnCode.FAILED_WRONG_PARAMS);
return RulesProgrammingReturnCode.FAILED_WRONG_PARAMS;
}
// Get the Forwarding Rules Manager from ODL (via the Impl)
IForwardingRulesManager forwardinRulesMgr = this.onfTappingAppImpl.getForwardingRulesManager();
if (forwardinRulesMgr == null) {
logger.warn("Cannot install flow ... Fowarding Rules Mananger is null");
return RulesProgrammingReturnCode.FAILED_ALL_SWITCHES;
}
RulesProgrammingReturnCode returnCode = RulesProgrammingReturnCode.SUCCESS;
// Now program every switch
logger.info("Inside pushFlowRulesToSwitch. There are " + switchesToProgram.size() + " switches to program");
// Program each switch ...
for (Node swId : switchesToProgram) {
List<FlowEntry> flowEntryList = this.rulesDB.get(swId);
if (flowEntryList == null) {
logger.info("Flow entry list is null");
continue;
}
logger.info("Inside installSwitchRules. There are " + flowEntryList.size() + " flows");
for (FlowEntry flowEntry : flowEntryList) {
if (flowEntry != null) {
logger.info("Installing flowEntry " + flowEntry.toString());
// Populate the Policy field now
logger.info("Installing flow " + flowEntry + " using the ForwardingManager");
Status poStatus = forwardinRulesMgr.modifyOrAddFlowEntry(flowEntry);
logger.info("FowardingManager returned " + poStatus);
if (!poStatus.isSuccess()) {
logger.error("Failed to install policy: "
+ flowEntry.getGroupName() + " ("
+ poStatus.getDescription() + ")");
returnCode = RulesProgrammingReturnCode.FAILED_FEW_SWITCHES;
// Remove the entry from the DB, it was not installed!
this.rulesDB.remove(swId);
} else {
logger.debug("Successfully installed policy "
+ flowEntry.toString() + " on switch " + swId);
}
} else {
logger.error("Cannot find a policy for SW:({}))", swId);
}
}
}
logger.info("Leaving installSwitchRules. Return code is: " + returnCode);
return returnCode;
}
// Get the set of NodeConnectors for a node (requires acces to the SwitchManager
public Set<NodeConnector> getODLNodeConnectors(Node node) {
// Get the set of nodeConnectors
Set<NodeConnector> ports = this.onfTappingAppImpl.getSwitchManager().getNodeConnectors(node);
Iterator<NodeConnector> portIt = ports.iterator();
// List<NodeConnector> portsArray = new ArrayList<NodeConnector>();
while (portIt.hasNext()) {
logger.info("NodeConnector " + portIt.next());
//portsArray.add(portIt.next());
}
return ports;
//return this.onfTappingAppImpl.getSwitchManager().getNodeConnectors(node);
// .getPhysicalNodeConnectors(node);
}
}