ONOS-685: Network Configuration Manager support for Segment Routing application
Change-Id: Ia15bfd24559dd5542633c8b76d500b2d31362340
diff --git a/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/NetworkConfig.java b/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/NetworkConfig.java
new file mode 100644
index 0000000..6ae0779
--- /dev/null
+++ b/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/NetworkConfig.java
@@ -0,0 +1,336 @@
+package org.onosproject.segmentrouting.config;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.onosproject.net.DeviceId;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.JsonNode;
+
+/**
+ * Public class corresponding to JSON described data model. Defines the network
+ * configuration at startup.
+ */
+public class NetworkConfig {
+ protected static final Logger log = LoggerFactory.getLogger(NetworkConfig.class);
+
+ @SuppressWarnings("unused")
+ private String comment;
+
+ private Boolean restrictSwitches;
+ private Boolean restrictLinks;
+ private List<SwitchConfig> switches;
+ private List<LinkConfig> links;
+
+ /**
+ * Default constructor.
+ */
+ public NetworkConfig() {
+ switches = new ArrayList<SwitchConfig>();
+ links = new ArrayList<LinkConfig>();
+ }
+
+ @JsonProperty("comment")
+ public void setComment(String c) {
+ log.trace("NetworkConfig: comment={}", c);
+ comment = c;
+ }
+
+ @JsonProperty("restrictSwitches")
+ public void setRestrictSwitches(boolean rs) {
+ log.trace("NetworkConfig: restrictSwitches={}", rs);
+ restrictSwitches = rs;
+ }
+
+ /**
+ * Returns default restrict configuration for switches.
+ *
+ * @return boolean
+ */
+ public Boolean getRestrictSwitches() {
+ return restrictSwitches;
+ }
+
+ @JsonProperty("restrictLinks")
+ public void setRestrictLinks(boolean rl) {
+ log.trace("NetworkConfig: restrictLinks={}", rl);
+ restrictLinks = rl;
+ }
+
+ /**
+ * Returns default restrict configuration for links.
+ *
+ * @return boolean
+ */
+ public Boolean getRestrictLinks() {
+ return restrictLinks;
+ }
+
+ /**
+ * Returns configuration for switches.
+ *
+ * @return list of switch configuration
+ */
+ public List<SwitchConfig> getSwitchConfig() {
+ return switches;
+ }
+
+ @JsonProperty("switchConfig")
+ public void setSwitchConfig(List<SwitchConfig> switches2) {
+ log.trace("NetworkConfig: switchConfig={}", switches2);
+ this.switches = switches2;
+ }
+
+ /**
+ * Java class corresponding to JSON described switch
+ * configuration data model.
+ */
+ public static class SwitchConfig {
+ protected String nodeDpid;
+ protected String name;
+ protected String type;
+ protected boolean allowed;
+ protected double latitude;
+ protected double longitude;
+ protected Map<String, JsonNode> params;
+ protected Map<String, String> publishAttributes;
+ protected DeviceId dpid;
+
+ /**
+ * Returns the configured "name" of a switch.
+ *
+ * @return string
+ */
+ public String getName() {
+ return name;
+ }
+
+ @JsonProperty("name")
+ public void setName(String name) {
+ log.trace("SwitchConfig: name={}", name);
+ this.name = name;
+ }
+
+ /**
+ * Returns the data plane identifier of a switch.
+ *
+ * @return ONOS device identifier
+ */
+ public DeviceId getDpid() {
+ return dpid;
+ }
+
+ public void setDpid(DeviceId dpid) {
+ this.dpid = dpid;
+ this.nodeDpid = dpid.toString();
+ }
+
+ /**
+ * Returns the data plane identifier of a switch.
+ *
+ * @return string
+ */
+ public String getNodeDpid() {
+ return nodeDpid;
+ }
+
+ // mapper sets both DeviceId and string fields for dpid
+ @JsonProperty("nodeDpid")
+ public void setNodeDpid(String nodeDpid) {
+ log.trace("SwitchConfig: nodeDpid={}", nodeDpid);
+ this.nodeDpid = nodeDpid;
+ this.dpid = DeviceId.deviceId(nodeDpid);
+ }
+
+ /**
+ * Returns the type of a switch.
+ *
+ * @return string
+ */
+ public String getType() {
+ return type;
+ }
+
+ @JsonProperty("type")
+ public void setType(String type) {
+ log.trace("SwitchConfig: type={}", type);
+ this.type = type;
+ }
+
+ /**
+ * Returns the latitude of a switch.
+ *
+ * @return double
+ */
+ public double getLatitude() {
+ return latitude;
+ }
+
+ @JsonProperty("latitude")
+ public void setLatitude(double latitude) {
+ log.trace("SwitchConfig: latitude={}", latitude);
+ this.latitude = latitude;
+ }
+
+ /**
+ * Returns the longitude of a switch.
+ *
+ * @return double
+ */
+ public double getLongitude() {
+ return longitude;
+ }
+
+ @JsonProperty("longitude")
+ public void setLongitude(double longitude) {
+ log.trace("SwitchConfig: longitude={}", longitude);
+ this.longitude = longitude;
+ }
+
+ /**
+ * Returns the allowed flag for a switch.
+ *
+ * @return boolean
+ */
+ public boolean isAllowed() {
+ return allowed;
+ }
+
+ @JsonProperty("allowed")
+ public void setAllowed(boolean allowed) {
+ this.allowed = allowed;
+ }
+
+ /**
+ * Returns the additional configured parameters of a switch.
+ *
+ * @return key value map
+ */
+ public Map<String, JsonNode> getParams() {
+ return params;
+ }
+
+ @JsonProperty("params")
+ public void setParams(Map<String, JsonNode> params) {
+ this.params = params;
+ }
+
+ /**
+ * Reserved for future use.
+ *
+ * @return key value map
+ */
+ public Map<String, String> getPublishAttributes() {
+ return publishAttributes;
+ }
+
+ @JsonProperty("publishAttributes")
+ public void setPublishAttributes(Map<String, String> publishAttributes) {
+ this.publishAttributes = publishAttributes;
+ }
+
+ }
+
+ @JsonProperty("linkConfig")
+ public void setLinkConfig(List<LinkConfig> links2) {
+ this.links = links2;
+ }
+
+ /**
+ * Reserved for future use.
+ *
+ * @return list of configured link configuration
+ */
+ public List<LinkConfig> getLinkConfig() {
+ return links;
+ }
+
+ /**
+ * Reserved for future use.
+ */
+ public static class LinkConfig {
+ protected String type;
+ protected Boolean allowed;
+ protected DeviceId dpid1;
+ protected DeviceId dpid2;
+ protected String nodeDpid1;
+ protected String nodeDpid2;
+ protected Map<String, JsonNode> params;
+ protected Map<String, String> publishAttributes;
+
+ public String getType() {
+ return type;
+ }
+
+ public void setType(String type) {
+ this.type = type;
+ }
+
+ public Boolean isAllowed() {
+ return allowed;
+ }
+
+ public void setAllowed(Boolean allowed) {
+ this.allowed = allowed;
+ }
+
+ public String getNodeDpid1() {
+ return nodeDpid1;
+ }
+
+ // mapper sets both long and string fields for dpid
+ public void setNodeDpid1(String nodeDpid1) {
+ this.nodeDpid1 = nodeDpid1;
+ this.dpid1 = DeviceId.deviceId(nodeDpid1);
+ }
+
+ public String getNodeDpid2() {
+ return nodeDpid2;
+ }
+
+ // mapper sets both long and string fields for dpid
+ public void setNodeDpid2(String nodeDpid2) {
+ this.nodeDpid2 = nodeDpid2;
+ this.dpid2 = DeviceId.deviceId(nodeDpid2);
+ }
+
+ public DeviceId getDpid1() {
+ return dpid1;
+ }
+
+ public void setDpid1(DeviceId dpid1) {
+ this.dpid1 = dpid1;
+ this.nodeDpid1 = dpid1.toString();
+ }
+
+ public DeviceId getDpid2() {
+ return dpid2;
+ }
+
+ public void setDpid2(DeviceId dpid2) {
+ this.dpid2 = dpid2;
+ this.nodeDpid2 = dpid2.toString();
+ }
+
+ public Map<String, JsonNode> getParams() {
+ return params;
+ }
+
+ public void setParams(Map<String, JsonNode> params) {
+ this.params = params;
+ }
+
+ public Map<String, String> getPublishAttributes() {
+ return publishAttributes;
+ }
+
+ public void setPublishAttributes(Map<String, String> publishAttributes) {
+ this.publishAttributes = publishAttributes;
+ }
+ }
+}
+
diff --git a/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/NetworkConfigException.java b/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/NetworkConfigException.java
new file mode 100644
index 0000000..9194221
--- /dev/null
+++ b/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/NetworkConfigException.java
@@ -0,0 +1,200 @@
+package org.onosproject.segmentrouting.config;
+
+import org.onosproject.net.DeviceId;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * NetworkConfigExceptions specifies a set of unchecked runtime exceptions that
+ * can be thrown by the {@link NetworkConfigManager}. It indicates errors that
+ * must be fixed in the config file before controller execution can proceed.
+ */
+public class NetworkConfigException extends RuntimeException {
+
+ private static final long serialVersionUID = 4959684709803000652L;
+ protected static final Logger log = LoggerFactory
+ .getLogger(NetworkConfigException.class);
+
+ /**
+ * Exception for duplicate device identifier configuration.
+ */
+ public static class DuplicateDpid extends RuntimeException {
+ private static final long serialVersionUID = 5491113234592145335L;
+
+ public DuplicateDpid(DeviceId dpid) {
+ super();
+ log.error("Duplicate dpid found in switch-config Dpid:{}",
+ dpid);
+ }
+ }
+
+ /**
+ * Exception for duplicate device name configuration.
+ */
+ public static class DuplicateName extends RuntimeException {
+ private static final long serialVersionUID = -4090171438031376129L;
+
+ public DuplicateName(String name) {
+ super();
+ log.error("Duplicate name found in switch-config name:{}", name);
+ }
+ }
+
+ /**
+ * Exception for unspecified device identifier for a switch.
+ */
+ public static class DpidNotSpecified extends RuntimeException {
+ private static final long serialVersionUID = -8494418855597117254L;
+
+ public DpidNotSpecified(String name) {
+ super();
+ log.error("Dpid not specified for switch-config name:{}", name);
+ }
+ }
+
+ /**
+ * Exception for unspecified device name for a switch.
+ */
+ public static class NameNotSpecified extends RuntimeException {
+ private static final long serialVersionUID = -3518881744110422891L;
+
+ public NameNotSpecified(DeviceId dpid) {
+ super();
+ log.error("Name not specified for switch-config dpid:{}",
+ dpid);
+ }
+ }
+
+ /**
+ * Exception for unspecified device type for a switch.
+ */
+ public static class SwitchTypeNotSpecified extends RuntimeException {
+ private static final long serialVersionUID = 2527453336226053753L;
+
+ public SwitchTypeNotSpecified(DeviceId dpid) {
+ super();
+ log.error("Switch type not specified for switch-config dpid:{}",
+ dpid);
+ }
+ }
+
+ /**
+ * Exception for unknown device type configured for a switch.
+ */
+ public static class UnknownSwitchType extends RuntimeException {
+ private static final long serialVersionUID = 7758418165512249170L;
+
+ public UnknownSwitchType(String type, String name) {
+ super();
+ log.error("Unknown switch type {} for switch name:{}", type, name);
+ }
+ }
+
+ /**
+ * Exception for missing required parameter configuration for a switch.
+ */
+ public static class ParamsNotSpecified extends RuntimeException {
+ private static final long serialVersionUID = 6247582323691265513L;
+
+ public ParamsNotSpecified(String name) {
+ super();
+ log.error("Params required - not specified for switch:{}", name);
+ }
+ }
+
+ /**
+ * Reserved for future use.
+ */
+ public static class LinkTypeNotSpecified extends RuntimeException {
+ private static final long serialVersionUID = -2089470389588542215L;
+
+ public LinkTypeNotSpecified(String dpid1, String dpid2) {
+ super();
+ log.error("Link type not specified for link-config between "
+ + "dpid1:{} and dpid2:{}", dpid1, dpid2);
+ }
+ }
+
+ /**
+ * Reserved for future use.
+ */
+ public static class LinkDpidNotSpecified extends RuntimeException {
+ private static final long serialVersionUID = -5701825916378616004L;
+
+ public LinkDpidNotSpecified(String dpid1, String dpid2) {
+ super();
+ if (dpid1 == null) {
+ log.error("nodeDpid1 not specified for link-config ");
+ }
+ if (dpid2 == null) {
+ log.error("nodeDpid2 not specified for link-config ");
+ }
+ }
+ }
+
+ /**
+ * Reserved for future use.
+ */
+ public static class LinkForUnknownSwitchConfig extends RuntimeException {
+ private static final long serialVersionUID = -2910458439881964094L;
+
+ public LinkForUnknownSwitchConfig(String dpid) {
+ super();
+ log.error("Link configuration was specified for a switch-dpid {} "
+ + "that has not been configured", dpid);
+ }
+ }
+
+ /**
+ * Reserved for future use.
+ */
+ public static class UnknownLinkType extends RuntimeException {
+ private static final long serialVersionUID = -5505376193106542305L;
+
+ public UnknownLinkType(String linktype, String dpid1, String dpid2) {
+ super();
+ log.error("unknown link type {} for links between dpid1:{} "
+ + "and dpid2:{}", linktype, dpid1, dpid2);
+ }
+ }
+
+ /**
+ * Exception for generic configuration errors.
+ */
+ public static class ErrorConfig extends RuntimeException {
+ private static final long serialVersionUID = -2827406314700193147L;
+
+ public ErrorConfig(String errorMsg) {
+ super();
+ log.error(errorMsg);
+ }
+
+ }
+
+ /**
+ * Reserved for future use.
+ */
+ public static class SwitchDpidNotConverted extends RuntimeException {
+ private static final long serialVersionUID = 5640347104590170426L;
+
+ public SwitchDpidNotConverted(String name) {
+ super();
+ log.error("Switch dpid specified as a HexString {} does not match "
+ + "with long value", name);
+ }
+ }
+
+ /**
+ * Reserved for future use.
+ */
+ public static class LinkDpidNotConverted extends RuntimeException {
+ private static final long serialVersionUID = 2397245646094080774L;
+
+ public LinkDpidNotConverted(String dpid1, String dpid2) {
+ log.error("Dpids expressed as HexStrings for links between dpid1:{} "
+ + "and dpid2:{} do not match with long values", dpid1, dpid2);
+ }
+ }
+
+}
+
diff --git a/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/NetworkConfigManager.java b/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/NetworkConfigManager.java
new file mode 100644
index 0000000..44e4f1c
--- /dev/null
+++ b/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/NetworkConfigManager.java
@@ -0,0 +1,323 @@
+package org.onosproject.segmentrouting.config;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Link;
+import org.onosproject.segmentrouting.config.NetworkConfig.LinkConfig;
+import org.onosproject.segmentrouting.config.NetworkConfig.SwitchConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * NetworkConfigManager manages all network configuration for switches, links
+ * and any other state that needs to be configured for correct network
+ * operation.
+ *
+ */
+public class NetworkConfigManager implements NetworkConfigService {
+ protected static final Logger log = LoggerFactory
+ .getLogger(NetworkConfigManager.class);
+ private static final String CONFIG_DIR = "../config";
+ private static final String DEFAULT_CONFIG_FILE = "segmentrouting.conf";
+ private final String configFileName = DEFAULT_CONFIG_FILE;
+ /**
+ * JSON Config file needs to use one of the following types for defining the
+ * kind of switch or link it wishes to configure.
+ */
+ public static final String SEGMENT_ROUTER = "Router_SR";
+
+ public static final String PKT_LINK = "pktLink";
+
+ NetworkConfig networkConfig;
+ private ConcurrentMap<DeviceId, SwitchConfig> configuredSwitches;
+ private ConcurrentMap<Link, LinkConfig> configuredLinks;
+ private Map<String, DeviceId> nameToDpid;
+
+ @Override
+ public SwitchConfigStatus checkSwitchConfig(DeviceId dpid) {
+ SwitchConfig swc = configuredSwitches.get(dpid);
+ if (networkConfig.getRestrictSwitches()) {
+ // default deny behavior
+ if (swc == null) {
+ // switch is not configured - we deny this switch
+ return new SwitchConfigStatus(NetworkConfigState.DENY, null,
+ "Switch not configured, in network denying switches by default.");
+ }
+ if (swc.isAllowed()) {
+ // switch is allowed in config, return configured attributes
+ return new SwitchConfigStatus(NetworkConfigState.ACCEPT_ADD, swc);
+ } else {
+ // switch has been configured off (administratively down)
+ return new SwitchConfigStatus(NetworkConfigState.DENY, null,
+ "Switch configured down (allowed=false).");
+ }
+ } else {
+ // default allow behavior
+ if (swc == null) {
+ // no config to add
+ return new SwitchConfigStatus(NetworkConfigState.ACCEPT, null);
+ }
+ if (swc.isAllowed()) {
+ // switch is allowed in config, return configured attributes
+ return new SwitchConfigStatus(NetworkConfigState.ACCEPT_ADD, swc);
+ } else {
+ // switch has been configured off (administratively down)
+ return new SwitchConfigStatus(NetworkConfigState.DENY, null,
+ "Switch configured down (allowed=false).");
+ }
+ }
+
+ }
+
+ @Override
+ public LinkConfigStatus checkLinkConfig(Link linkTuple) {
+ LinkConfig lkc = getConfiguredLink(linkTuple);
+ // links are always disallowed if any one of the nodes that make up the
+ // link are disallowed
+ DeviceId linkNode1 = linkTuple.src().deviceId();
+ SwitchConfigStatus scs1 = checkSwitchConfig(linkNode1);
+ if (scs1.getConfigState() == NetworkConfigState.DENY) {
+ return new LinkConfigStatus(NetworkConfigState.DENY, null,
+ "Link-node: " + linkNode1 + " denied by config: " + scs1.getMsg());
+ }
+ DeviceId linkNode2 = linkTuple.dst().deviceId();
+ SwitchConfigStatus scs2 = checkSwitchConfig(linkNode2);
+ if (scs2.getConfigState() == NetworkConfigState.DENY) {
+ return new LinkConfigStatus(NetworkConfigState.DENY, null,
+ "Link-node: " + linkNode2 + " denied by config: " + scs2.getMsg());
+ }
+ if (networkConfig.getRestrictLinks()) {
+ // default deny behavior
+ if (lkc == null) {
+ // link is not configured - we deny this link
+ return new LinkConfigStatus(NetworkConfigState.DENY, null,
+ "Link not configured, in network denying links by default.");
+ }
+ if (lkc.isAllowed()) {
+ // link is allowed in config, return configured attributes
+ return new LinkConfigStatus(NetworkConfigState.ACCEPT_ADD, lkc);
+ } else {
+ // link has been configured off (administratively down)
+ return new LinkConfigStatus(NetworkConfigState.DENY, null,
+ "Link configured down (allowed=false).");
+ }
+ } else {
+ // default allow behavior
+ if (lkc == null) {
+ // no config to add
+ return new LinkConfigStatus(NetworkConfigState.ACCEPT, null);
+ }
+ if (lkc.isAllowed()) {
+ // link is allowed in config, return configured attributes
+ return new LinkConfigStatus(NetworkConfigState.ACCEPT_ADD, lkc);
+ } else {
+ // link has been configured off (administratively down)
+ return new LinkConfigStatus(NetworkConfigState.DENY, null,
+ "Link configured down (allowed=false).");
+ }
+ }
+
+ }
+
+ @Override
+ public List<SwitchConfig> getConfiguredAllowedSwitches() {
+ List<SwitchConfig> allowed = new ArrayList<SwitchConfig>();
+ for (SwitchConfig swc : configuredSwitches.values()) {
+ if (swc.isAllowed()) {
+ allowed.add(swc);
+ }
+ }
+ return allowed;
+ }
+
+ @Override
+ public List<LinkConfig> getConfiguredAllowedLinks() {
+ List<LinkConfig> allowed = new ArrayList<LinkConfig>();
+ for (LinkConfig lkc : configuredLinks.values()) {
+ if (lkc.isAllowed()) {
+ allowed.add(lkc);
+ }
+ }
+ return allowed;
+ }
+
+ @Override
+ public DeviceId getDpidForName(String name) {
+ if (nameToDpid.get(name) != null) {
+ return nameToDpid.get(name);
+ }
+ return null;
+ }
+
+ // **************
+ // Private methods
+ // **************
+
+ private void loadNetworkConfig() {
+ File configFile = new File(CONFIG_DIR, configFileName);
+ ObjectMapper mapper = new ObjectMapper();
+ networkConfig = new NetworkConfig();
+
+ try {
+ networkConfig = mapper.readValue(configFile,
+ NetworkConfig.class);
+ } catch (JsonParseException e) {
+ String err = String.format("JsonParseException while loading network "
+ + "config from file: %s: %s", configFileName,
+ e.getMessage());
+ throw new NetworkConfigException.ErrorConfig(err);
+ } catch (JsonMappingException e) {
+ String err = String.format(
+ "JsonMappingException while loading network config "
+ + "from file: %s: %s",
+ configFileName,
+ e.getMessage());
+ throw new NetworkConfigException.ErrorConfig(err);
+ } catch (IOException e) {
+ String err = String.format("IOException while loading network config "
+ + "from file: %s %s", configFileName, e.getMessage());
+ throw new NetworkConfigException.ErrorConfig(err);
+ }
+
+ log.info("Network config specifies: {} switches and {} links",
+ (networkConfig.getRestrictSwitches())
+ ? networkConfig.getSwitchConfig().size() : "default allow",
+ (networkConfig.getRestrictLinks())
+ ? networkConfig.getLinkConfig().size() : "default allow");
+ }
+
+ private void parseNetworkConfig() {
+ List<SwitchConfig> swConfList = networkConfig.getSwitchConfig();
+ List<LinkConfig> lkConfList = networkConfig.getLinkConfig();
+ validateSwitchConfig(swConfList);
+ createTypeSpecificSwitchConfig(swConfList);
+ validateLinkConfig(lkConfList);
+ createTypeSpecificLinkConfig(lkConfList);
+ // TODO validate reachability matrix 'names' for configured dpids
+ }
+
+ private void createTypeSpecificSwitchConfig(List<SwitchConfig> swConfList) {
+ for (SwitchConfig swc : swConfList) {
+ nameToDpid.put(swc.getName(), swc.getDpid());
+ String swtype = swc.getType();
+ switch (swtype) {
+ case SEGMENT_ROUTER:
+ SwitchConfig sr = new SegmentRouterConfig(swc);
+ configuredSwitches.put(sr.getDpid(), sr);
+ break;
+ default:
+ throw new NetworkConfigException.UnknownSwitchType(swtype,
+ swc.getName());
+ }
+ }
+ }
+
+ private void createTypeSpecificLinkConfig(List<LinkConfig> lkConfList) {
+ for (LinkConfig lkc : lkConfList) {
+ String lktype = lkc.getType();
+ switch (lktype) {
+ case PKT_LINK:
+ PktLinkConfig pk = new PktLinkConfig(lkc);
+ for (Link lt : pk.getLinkTupleList()) {
+ configuredLinks.put(lt, pk);
+ }
+ break;
+ default:
+ throw new NetworkConfigException.UnknownLinkType(lktype,
+ lkc.getNodeDpid1(), lkc.getNodeDpid2());
+ }
+ }
+ }
+
+ private void validateSwitchConfig(List<SwitchConfig> swConfList) {
+ Set<DeviceId> swDpids = new HashSet<DeviceId>();
+ Set<String> swNames = new HashSet<String>();
+ for (SwitchConfig swc : swConfList) {
+ if (swc.getNodeDpid() == null || swc.getDpid() == null) {
+ throw new NetworkConfigException.DpidNotSpecified(swc.getName());
+ }
+ // ensure both String and DeviceId values of dpid are set
+ if (!swc.getDpid().equals(DeviceId.deviceId(swc.getNodeDpid()))) {
+ throw new NetworkConfigException.SwitchDpidNotConverted(
+ swc.getName());
+ }
+ if (swc.getName() == null) {
+ throw new NetworkConfigException.NameNotSpecified(swc.getDpid());
+ }
+ if (swc.getType() == null) {
+ throw new NetworkConfigException.SwitchTypeNotSpecified(
+ swc.getDpid());
+ }
+ if (!swDpids.add(swc.getDpid())) {
+ throw new NetworkConfigException.DuplicateDpid(swc.getDpid());
+ }
+ if (!swNames.add(swc.getName())) {
+ throw new NetworkConfigException.DuplicateName(swc.getName());
+ }
+ // TODO Add more validations
+ }
+ }
+
+ private void validateLinkConfig(List<LinkConfig> lkConfList) {
+ for (LinkConfig lkc : lkConfList) {
+ if (lkc.getNodeDpid1() == null || lkc.getNodeDpid2() == null) {
+ throw new NetworkConfigException.LinkDpidNotSpecified(
+ lkc.getNodeDpid1(), lkc.getNodeDpid2());
+ }
+ // ensure both String and Long values are set
+ if (!lkc.getDpid1().equals(DeviceId.deviceId(lkc.getNodeDpid1())) ||
+ !lkc.getDpid2().equals(DeviceId.deviceId(lkc.getNodeDpid2()))) {
+ throw new NetworkConfigException.LinkDpidNotConverted(
+ lkc.getNodeDpid1(), lkc.getNodeDpid2());
+ }
+ if (lkc.getType() == null) {
+ throw new NetworkConfigException.LinkTypeNotSpecified(
+ lkc.getNodeDpid1(), lkc.getNodeDpid2());
+ }
+ if (configuredSwitches.get(lkc.getDpid1()) == null) {
+ throw new NetworkConfigException.LinkForUnknownSwitchConfig(
+ lkc.getNodeDpid1());
+ }
+ if (configuredSwitches.get(lkc.getDpid2()) == null) {
+ throw new NetworkConfigException.LinkForUnknownSwitchConfig(
+ lkc.getNodeDpid2());
+ }
+ // TODO add more validations
+ }
+
+ }
+
+ private LinkConfig getConfiguredLink(Link linkTuple) {
+ LinkConfig lkc = null;
+ // first try the unidirectional link with the ports assigned
+ lkc = configuredLinks.get(linkTuple);
+ return lkc;
+ }
+
+
+ /**
+ * Initializes the network configuration manager module by
+ * loading and parsing the network configuration file.
+ */
+ public void init() {
+ loadNetworkConfig();
+ configuredSwitches = new ConcurrentHashMap<DeviceId, SwitchConfig>();
+ configuredLinks = new ConcurrentHashMap<Link, LinkConfig>();
+ nameToDpid = new HashMap<String, DeviceId>();
+ parseNetworkConfig();
+ }
+}
diff --git a/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/NetworkConfigService.java b/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/NetworkConfigService.java
new file mode 100644
index 0000000..722d50c
--- /dev/null
+++ b/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/NetworkConfigService.java
@@ -0,0 +1,253 @@
+package org.onosproject.segmentrouting.config;
+
+import java.util.List;
+
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Link;
+import org.onosproject.segmentrouting.config.NetworkConfig.LinkConfig;
+import org.onosproject.segmentrouting.config.NetworkConfig.SwitchConfig;
+
+/**
+ * Exposes methods to retrieve network configuration.
+ *
+ * TODO: currently only startup-configuration is exposed and such configuration
+ * cannot be changed at runtime. Need to add runtime support for changes to
+ * configuration (via REST/CLI) in future releases.
+ *
+ * TODO: return immutable objects or defensive copies of network config so that
+ * users of this API do not inadvertently or maliciously change network config.
+ */
+public interface NetworkConfigService {
+
+ /**
+ * Suggests the action to be taken by the caller given the configuration
+ * associated with the queried network-object (eg. switch, link etc.).
+ */
+ public enum NetworkConfigState {
+ /**
+ * Associated network object has been configured to not be allowed in
+ * the network.
+ */
+ DENY,
+
+ /**
+ * Associated network object has been configured to be allowed in the
+ * network.
+ */
+ ACCEPT,
+
+ /**
+ * Associated network object has been configured to be allowed in the
+ * network. In addition, there are configured parameters that should be
+ * added to the object.
+ */
+ ACCEPT_ADD,
+ }
+
+ /**
+ * Returns the configuration outcome (accept, deny etc.), and any configured
+ * parameters to the caller, in response to a query for the configuration
+ * associated with a switch.
+ */
+ public class SwitchConfigStatus {
+ private NetworkConfigState configState;
+ private SwitchConfig switchConfig;
+ private String msg;
+
+ SwitchConfigStatus(NetworkConfigState configState,
+ SwitchConfig switchConfig, String msg) {
+ this.configState = configState;
+ this.switchConfig = switchConfig;
+ this.msg = msg;
+ }
+
+ SwitchConfigStatus(NetworkConfigState configState,
+ SwitchConfig switchConfig) {
+ this.configState = configState;
+ this.switchConfig = switchConfig;
+ this.msg = "";
+ }
+
+ /**
+ * Returns the configuration state for the switch.
+ *
+ * @return non-null NetworkConfigState
+ */
+ public NetworkConfigState getConfigState() {
+ return configState;
+ }
+
+ /**
+ * Returns the switch configuration, which may be null if no
+ * configuration exists, or if the configuration state disallows the
+ * switch.
+ *
+ * @return SwitchConfig, the switch configuration, or null
+ */
+ public SwitchConfig getSwitchConfig() {
+ return switchConfig;
+ }
+
+ /**
+ * User readable string typically used to specify the reason why a
+ * switch is being disallowed.
+ *
+ * @return A non-null but possibly empty String
+ */
+ public String getMsg() {
+ return msg;
+ }
+
+ }
+
+ /**
+ * Reserved for future use.
+ *
+ * Returns the configuration outcome (accept, deny etc.), and any configured
+ * parameters to the caller, in response to a query for the configuration
+ * associated with a link.
+ */
+ public class LinkConfigStatus {
+ private NetworkConfigState configState;
+ private LinkConfig linkConfig;
+ private String msg;
+
+ LinkConfigStatus(NetworkConfigState configState,
+ LinkConfig linkConfig, String msg) {
+ this.configState = configState;
+ this.linkConfig = linkConfig;
+ this.msg = msg;
+ }
+
+ LinkConfigStatus(NetworkConfigState configState,
+ LinkConfig linkConfig) {
+ this.configState = configState;
+ this.linkConfig = linkConfig;
+ this.msg = "";
+ }
+
+ /**
+ * Returns the configuration state for the link.
+ *
+ * @return non-null NetworkConfigState
+ */
+ public NetworkConfigState getConfigState() {
+ return configState;
+ }
+
+ /**
+ * Returns the link configuration, which may be null if no configuration
+ * exists, or if the configuration state disallows the link.
+ *
+ * @return SwitchConfig, the switch configuration, or null
+ */
+ public LinkConfig getLinkConfig() {
+ return linkConfig;
+ }
+
+ /**
+ * User readable string typically used to specify the reason why a link
+ * is being disallowed.
+ *
+ * @return msg A non-null but possibly empty String
+ */
+ public String getMsg() {
+ return msg;
+ }
+
+ }
+
+ /**
+ * Checks the switch configuration (if any) associated with the 'dpid'.
+ * Determines if the switch should be allowed or denied according to
+ * configuration rules.
+ *
+ * The method always returns a non-null SwitchConfigStatus. The enclosed
+ * ConfigState contains the result of the check. The enclosed SwitchConfig
+ * may or may not be null, depending on the outcome of the check.
+ *
+ * @param dpid device id of the switch to be queried
+ * @return SwitchConfigStatus with outcome of check and associated config.
+ */
+ public SwitchConfigStatus checkSwitchConfig(DeviceId dpid);
+
+ /**
+ * Reserved for future use.
+ *
+ * Checks the link configuration (if any) associated with the 'link'.
+ * Determines if the link should be allowed or denied according to
+ * configuration rules. Note that the 'link' is a unidirectional link which
+ * checked against configuration that is typically defined for a
+ * bidirectional link. The caller may make a second call if it wishes to
+ * check the 'reverse' direction.
+ *
+ * Also note that the configuration may not specify ports for a given
+ * bidirectional link. In such cases, the configuration applies to all links
+ * between the two switches. This method will check the given 'link' against
+ * such configuration.
+
+ * The method always returns a non-null LinkConfigStatus. The enclosed
+ * ConfigState contains the result of the check. The enclosed LinkConfig may
+ * or may not be null, depending on the outcome of the check.
+ *
+ * @param linkTuple unidirectional link to be queried
+ * @return LinkConfigStatus with outcome of check and associated config.
+ */
+ public LinkConfigStatus checkLinkConfig(Link linkTuple);
+
+ /**
+ * Retrieves a list of switches that have been configured, and have been
+ * determined to be 'allowed' in the network, according to configuration
+ * rules.
+ *
+ * Note that it is possible that there are other switches that are allowed
+ * in the network that have NOT been configured. Such switches will not be a
+ * part of the returned list.
+ *
+ * Also note that it is possible that some switches will not be discovered
+ * and the only way the controller can know about these switches is via
+ * configuration. Such switches will be included in this list. It is up to
+ * the caller to determine which SwitchConfig applies to non-discovered
+ * switches.
+ *
+ * @return a non-null List of SwitchConfig which may be empty
+ */
+ public List<SwitchConfig> getConfiguredAllowedSwitches();
+
+ /**
+ * Reserved for future use.
+ *
+ * Retrieves a list of links that have been configured, and have been
+ * determined to be 'allowed' in the network, according to configuration
+ * rules.
+ *
+ * Note that it is possible that there are other links that are allowed in
+ * the network that have NOT been configured. Such links will not be a part
+ * of the returned list.
+ *
+ * Also note that it is possible that some links will not be discovered and
+ * the only way the controller can know about these links is via
+ * configuration. Such links will be included in this list. It is up to the
+ * caller to determine which LinkConfig applies to non-discovered links.
+ *
+ * In addition, note that the LinkConfig applies to the configured
+ * bi-directional link, which may or may not have declared ports. The
+ * associated unidirectional LinkTuple can be retrieved from the
+ * getLinkTupleList() method in the LinkConfig object.
+ *
+ * @return a non-null List of LinkConfig which may be empty
+ */
+ public List<LinkConfig> getConfiguredAllowedLinks();
+
+ /**
+ * Retrieves the Dpid associated with a 'name' for a configured switch
+ * object. This method does not check of the switches are 'allowed' by
+ * config.
+ *
+ * @param name device name
+ * @return the Dpid corresponding to a given 'name', or null if no
+ * configured switch was found for the given 'name'.
+ */
+ public DeviceId getDpidForName(String name);
+
+}
diff --git a/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/PktLinkConfig.java b/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/PktLinkConfig.java
new file mode 100644
index 0000000..c66ac3c
--- /dev/null
+++ b/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/PktLinkConfig.java
@@ -0,0 +1,144 @@
+package org.onosproject.segmentrouting.config;
+
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.onosproject.net.Link;
+import org.onosproject.segmentrouting.config.NetworkConfig.LinkConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+/**
+ * Reserved for future use.
+ * Configuration for a link between two packet-switches.
+ */
+public class PktLinkConfig extends LinkConfig {
+ protected static final Logger log = LoggerFactory
+ .getLogger(PktLinkConfig.class);
+ private int port1;
+ private int port2;
+ private String nodeName1;
+ private String nodeName2;
+ private List<Link> linkTupleList;
+
+ public PktLinkConfig(LinkConfig lkc) {
+ nodeDpid1 = lkc.getNodeDpid1();
+ nodeDpid2 = lkc.getNodeDpid2();
+ dpid1 = lkc.getDpid1();
+ dpid2 = lkc.getDpid2();
+ type = lkc.getType();
+ allowed = lkc.isAllowed();
+ params = lkc.getParams();
+ publishAttributes = new ConcurrentHashMap<String, String>();
+ parseParams();
+ validateParams();
+ setPublishAttributes();
+ }
+
+ // ********************
+ // Packet Link Configuration
+ // ********************
+
+ public int getPort1() {
+ return port1;
+ }
+
+ public void setPort1(int port1) {
+ this.port1 = port1;
+ }
+
+ public int getPort2() {
+ return port2;
+ }
+
+ public void setPort2(int port2) {
+ this.port2 = port2;
+ }
+
+ public String getNodeName1() {
+ return nodeName1;
+ }
+
+ public void setNodeName1(String nodeName1) {
+ this.nodeName1 = nodeName1;
+ }
+
+ public String getNodeName2() {
+ return nodeName2;
+ }
+
+ public void setNodeName2(String nodeName2) {
+ this.nodeName2 = nodeName2;
+ }
+
+ /**
+ * Returns the two unidirectional links corresponding to the packet-link
+ * configuration. It is possible that the ports in the LinkTuple have
+ * portnumber '0', implying that the configuration applies to all links
+ * between the two switches.
+ *
+ * @return a list of LinkTuple with exactly 2 unidirectional links
+ */
+ public List<Link> getLinkTupleList() {
+ return linkTupleList;
+ }
+
+ private void setPublishAttributes() {
+
+ }
+
+ private void parseParams() {
+ if (params == null) {
+ throw new PktLinkParamsNotSpecified(nodeDpid1, nodeDpid2);
+ }
+ Set<Entry<String, JsonNode>> m = params.entrySet();
+ for (Entry<String, JsonNode> e : m) {
+ String key = e.getKey();
+ JsonNode j = e.getValue();
+ if (key.equals("nodeName1")) {
+ setNodeName1(j.asText());
+ } else if (key.equals("nodeName2")) {
+ setNodeName2(j.asText());
+ } else if (key.equals("port1")) {
+ setPort1(j.asInt());
+ } else if (key.equals("port2")) {
+ setPort2(j.asInt());
+ } else {
+ throw new UnknownPktLinkConfig(key, nodeDpid1, nodeDpid2);
+ }
+ }
+ }
+
+ private void validateParams() {
+ // TODO - wrong-names, duplicate links,
+ // duplicate use of port, is switch-allowed for which link is allowed?
+ // valid port numbers
+ }
+
+ public static class PktLinkParamsNotSpecified extends RuntimeException {
+ private static final long serialVersionUID = 6247582323691265513L;
+
+ public PktLinkParamsNotSpecified(String dpidA, String dpidB) {
+ super();
+ log.error("Params required for packet link - not specified "
+ + "for link between switch1:{} and switch2:{}",
+ dpidA, dpidB);
+ }
+ }
+
+ public static class UnknownPktLinkConfig extends RuntimeException {
+ private static final long serialVersionUID = -5750132094884129179L;
+
+ public UnknownPktLinkConfig(String key, String dpidA, String dpidB) {
+ super();
+ log.error("Unknown packet-link config {} for link between"
+ + " dpid1: {} and dpid2: {}", key,
+ dpidA, dpidB);
+ }
+ }
+
+}
diff --git a/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/SegmentRouterConfig.java b/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/SegmentRouterConfig.java
new file mode 100644
index 0000000..4775c77
--- /dev/null
+++ b/apps/segmentrouting/src/main/java/org/onosproject/segmentrouting/config/SegmentRouterConfig.java
@@ -0,0 +1,430 @@
+package org.onosproject.segmentrouting.config;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.onosproject.net.DeviceId;
+import org.onosproject.segmentrouting.config.NetworkConfig.SwitchConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * Manages additional configuration for switches configured as Segment Routers.
+ */
+public class SegmentRouterConfig extends SwitchConfig {
+ protected static final Logger log = LoggerFactory
+ .getLogger(SegmentRouterConfig.class);
+ private String routerIp;
+ private String routerMac;
+ private int nodeSid;
+ private boolean isEdgeRouter;
+ private List<AdjacencySid> adjacencySids;
+ private List<Subnet> subnets;
+
+ public static final String ROUTER_IP = "routerIp";
+ public static final String ROUTER_MAC = "routerMac";
+ public static final String NODE_SID = "nodeSid";
+ public static final String ADJACENCY_SIDS = "adjacencySids";
+ public static final String SUBNETS = "subnets";
+ public static final String ISEDGE = "isEdgeRouter";
+ private static final int SRGB_MAX = 1000;
+
+ /**
+ * Parses and validates the additional configuration parameters applicable
+ * to segment routers.
+ *
+ * @param swc switch configuration
+ */
+ public SegmentRouterConfig(SwitchConfig swc) {
+ this.setName(swc.getName());
+ this.setDpid(swc.getDpid());
+ this.setType(swc.getType());
+ this.setLatitude(swc.getLatitude());
+ this.setLongitude(swc.getLongitude());
+ this.setParams(swc.getParams());
+ this.setAllowed(swc.isAllowed());
+ publishAttributes = new ConcurrentHashMap<String, String>();
+ adjacencySids = new ArrayList<AdjacencySid>();
+ subnets = new ArrayList<Subnet>();
+ parseParams();
+ validateParams();
+ setPublishAttributes();
+ }
+
+ /**
+ * Returns the configured segment router IP address.
+ *
+ * @return ip address in string format
+ */
+ public String getRouterIp() {
+ return routerIp;
+ }
+
+ public void setRouterIp(String routerIp) {
+ this.routerIp = routerIp;
+ }
+
+ /**
+ * Returns the configured segment router mac address.
+ *
+ * @return mac address in string format
+ */
+ public String getRouterMac() {
+ return routerMac;
+ }
+
+ public void setRouterMac(String routerMac) {
+ this.routerMac = routerMac;
+ }
+
+ /**
+ * Returns the configured sID for a segment router.
+ *
+ * @return segment identifier
+ */
+ public int getNodeSid() {
+ return nodeSid;
+ }
+
+ public void setNodeSid(int nodeSid) {
+ this.nodeSid = nodeSid;
+ }
+
+ /**
+ * Returns the flag that indicates the configured segment router
+ * is edge or backbone router.
+ *
+ * @return boolean
+ */
+ public boolean isEdgeRouter() {
+ return isEdgeRouter;
+ }
+
+ public void setIsEdgeRouter(boolean isEdge) {
+ this.isEdgeRouter = isEdge;
+ }
+
+ /**
+ * Class representing segment router adjacency identifier.
+ */
+ public static class AdjacencySid {
+ private int adjSid;
+ private List<Integer> ports;
+
+ public AdjacencySid(int adjSid, List<Integer> ports) {
+ this.ports = ports;
+ this.adjSid = adjSid;
+ }
+
+ /**
+ * Returns the list of ports part of a segment
+ * router adjacency identifier.
+ *
+ * @return list of integers
+ */
+ public List<Integer> getPorts() {
+ return ports;
+ }
+
+ public void setPorts(List<Integer> ports) {
+ this.ports = ports;
+ }
+
+ /**
+ * Returns the configured adjacency id of a segment router.
+ *
+ * @return integer
+ */
+ public int getAdjSid() {
+ return adjSid;
+ }
+
+ public void setAdjSid(int adjSid) {
+ this.adjSid = adjSid;
+ }
+ }
+
+ /**
+ * Returns the configured adjacent segment IDs for a segment router.
+ *
+ * @return list of adjacency identifier
+ */
+ public List<AdjacencySid> getAdjacencySids() {
+ return adjacencySids;
+ }
+
+ public void setAdjacencySids(List<AdjacencySid> adjacencySids) {
+ this.adjacencySids = adjacencySids;
+ }
+
+ /**
+ * Class representing a subnet attached to a segment router.
+ */
+ public static class Subnet {
+ private int portNo;
+ private String subnetIp;
+
+ public Subnet(int portNo, String subnetIp) {
+ this.portNo = portNo;
+ this.subnetIp = subnetIp;
+ }
+
+ /**
+ * Returns the port number of segment router on
+ * which subnet is attached.
+ *
+ * @return integer
+ */
+ public int getPortNo() {
+ return portNo;
+ }
+
+ public void setPortNo(int portNo) {
+ this.portNo = portNo;
+ }
+
+ /**
+ * Returns the configured subnet address.
+ *
+ * @return subnet ip address in string format
+ */
+ public String getSubnetIp() {
+ return subnetIp;
+ }
+
+ public void setSubnetIp(String subnetIp) {
+ this.subnetIp = subnetIp;
+ }
+ }
+
+ /**
+ * Returns the configured subnets for a segment router.
+ *
+ * @return list of subnets
+ */
+ public List<Subnet> getSubnets() {
+ return subnets;
+ }
+
+ public void setSubnets(List<Subnet> subnets) {
+ this.subnets = subnets;
+ }
+
+ // ********************
+ // Helper methods
+ // ********************
+
+ private void parseParams() {
+ if (params == null) {
+ throw new NetworkConfigException.ParamsNotSpecified(name);
+ }
+
+ Set<Entry<String, JsonNode>> m = params.entrySet();
+ for (Entry<String, JsonNode> e : m) {
+ String key = e.getKey();
+ JsonNode j = e.getValue();
+ if (key.equals("routerIp")) {
+ setRouterIp(j.asText());
+ } else if (key.equals("routerMac")) {
+ setRouterMac(j.asText());
+ } else if (key.equals("nodeSid")) {
+ setNodeSid(j.asInt());
+ } else if (key.equals("isEdgeRouter")) {
+ setIsEdgeRouter(j.asBoolean());
+ } else if (key.equals("adjacencySids") || key.equals("subnets")) {
+ getInnerParams(j, key);
+ } else {
+ throw new UnknownSegmentRouterConfig(key, dpid);
+ }
+ }
+ }
+
+ private void getInnerParams(JsonNode j, String innerParam) {
+ Iterator<JsonNode> innerList = j.elements();
+ while (innerList.hasNext()) {
+ Iterator<Entry<String, JsonNode>> f = innerList.next().fields();
+ int portNo = -1;
+ int adjSid = -1;
+ String subnetIp = null;
+ List<Integer> ports = null;
+ while (f.hasNext()) {
+ Entry<String, JsonNode> fe = f.next();
+ if (fe.getKey().equals("portNo")) {
+ portNo = fe.getValue().asInt();
+ } else if (fe.getKey().equals("adjSid")) {
+ adjSid = fe.getValue().asInt();
+ } else if (fe.getKey().equals("subnetIp")) {
+ subnetIp = fe.getValue().asText();
+ } else if (fe.getKey().equals("ports")) {
+ if (fe.getValue().isArray()) {
+ Iterator<JsonNode> i = fe.getValue().elements();
+ ports = new ArrayList<Integer>();
+ while (i.hasNext()) {
+ ports.add(i.next().asInt());
+ }
+ }
+ } else {
+ throw new UnknownSegmentRouterConfig(fe.getKey(), dpid);
+ }
+ }
+ if (innerParam.equals("adjacencySids")) {
+ AdjacencySid ads = new AdjacencySid(adjSid, ports);
+ adjacencySids.add(ads);
+ } else {
+ Subnet sip = new Subnet(portNo, subnetIp);
+ subnets.add(sip);
+ }
+ }
+ }
+
+ private void validateParams() {
+ if (routerIp == null) {
+ throw new IpNotSpecified(dpid);
+ }
+ if (routerMac == null) {
+ throw new MacNotSpecified(dpid);
+ }
+ if (isEdgeRouter && subnets.isEmpty()) {
+ throw new SubnetNotSpecifiedInEdgeRouter(dpid);
+ }
+ if (!isEdgeRouter && !subnets.isEmpty()) {
+ throw new SubnetSpecifiedInBackboneRouter(dpid);
+ }
+ if (nodeSid > SRGB_MAX) {
+ throw new NodeLabelNotInSRGB(nodeSid, dpid);
+ }
+ for (AdjacencySid as : adjacencySids) {
+ int label = as.getAdjSid();
+ List<Integer> plist = as.getPorts();
+ if (label <= SRGB_MAX) {
+ throw new AdjacencyLabelInSRGB(label, dpid);
+ }
+ if (plist.size() <= 1) {
+ throw new AdjacencyLabelNotEnoughPorts(label, dpid);
+ }
+ }
+
+
+ // TODO more validations
+ }
+
+ /**
+ * Setting publishAttributes implies that this is the configuration that
+ * will be added to Topology.Switch object before it is published on the
+ * channel to other controller instances.
+ */
+ private void setPublishAttributes() {
+ publishAttributes.put(ROUTER_IP, routerIp);
+ publishAttributes.put(ROUTER_MAC, routerMac);
+ publishAttributes.put(NODE_SID, String.valueOf(nodeSid));
+ publishAttributes.put(ISEDGE, String.valueOf(isEdgeRouter));
+ ObjectMapper mapper = new ObjectMapper();
+ try {
+ publishAttributes.put(ADJACENCY_SIDS,
+ mapper.writeValueAsString(adjacencySids));
+ publishAttributes.put(SUBNETS,
+ mapper.writeValueAsString(subnets));
+ } catch (JsonProcessingException e) {
+ log.error("Error while writing SR config: {}", e.getCause());
+ } catch (IOException e) {
+ log.error("Error while writing SR config: {}", e.getCause());
+ }
+ }
+
+ // ********************
+ // Exceptions
+ // ********************
+
+ public static class IpNotSpecified extends RuntimeException {
+ private static final long serialVersionUID = -3001502553646331686L;
+
+ public IpNotSpecified(DeviceId dpid) {
+ super();
+ log.error("Router IP address not specified for SR config dpid:{}",
+ dpid);
+ }
+ }
+
+ public static class MacNotSpecified extends RuntimeException {
+ private static final long serialVersionUID = -5850132094884129179L;
+
+ public MacNotSpecified(DeviceId dpid) {
+ super();
+ log.error("Router Mac address not specified for SR config dpid:{}",
+ dpid);
+ }
+ }
+
+ public static class UnknownSegmentRouterConfig extends RuntimeException {
+ private static final long serialVersionUID = -5750132094884129179L;
+
+ public UnknownSegmentRouterConfig(String key, DeviceId dpid) {
+ super();
+ log.error("Unknown Segment Router config {} in dpid: {}", key,
+ dpid);
+ }
+ }
+
+ public static class SubnetNotSpecifiedInEdgeRouter extends RuntimeException {
+ private static final long serialVersionUID = -5855458472668581268L;
+
+ public SubnetNotSpecifiedInEdgeRouter(DeviceId dpid) {
+ super();
+ log.error("Subnet was not specified for edge router in dpid: {}",
+ dpid);
+ }
+ }
+
+ public static class SubnetSpecifiedInBackboneRouter extends RuntimeException {
+ private static final long serialVersionUID = 1L;
+
+ public SubnetSpecifiedInBackboneRouter(DeviceId dpid) {
+ super();
+ log.error("Subnet was specified in backbone router in dpid: {}",
+ dpid);
+ }
+ }
+
+ public static class NodeLabelNotInSRGB extends RuntimeException {
+ private static final long serialVersionUID = -8482670903748519526L;
+
+ public NodeLabelNotInSRGB(int label, DeviceId dpid) {
+ super();
+ log.error("Node sif {} specified in not in global label-base "
+ + "in dpid: {}", label,
+ dpid);
+ }
+ }
+
+ public static class AdjacencyLabelInSRGB extends RuntimeException {
+ private static final long serialVersionUID = -8482670903748519526L;
+
+ public AdjacencyLabelInSRGB(int label, DeviceId dpid) {
+ super();
+ log.error("Adjaceny label {} specified from global label-base "
+ + "in dpid: {}", label,
+ dpid);
+ }
+ }
+
+ public static class AdjacencyLabelNotEnoughPorts extends RuntimeException {
+ private static final long serialVersionUID = -8482670903748519526L;
+
+ public AdjacencyLabelNotEnoughPorts(int label, DeviceId dpid) {
+ super();
+ log.error("Adjaceny label {} must be specified for at least 2 ports. "
+ + "Adjacency labels for single ports are auto-generated "
+ + "in dpid: {}", label,
+ dpid);
+ }
+ }
+}