public Ip getSffIp(ServiceFunctionForwarder serviceFunctionForwarder) { if (serviceFunctionForwarder != null && serviceFunctionForwarder.getSffDataPlaneLocator() != null && serviceFunctionForwarder.getSffDataPlaneLocator().get(0) != null && serviceFunctionForwarder.getSffDataPlaneLocator().get(0).getDataPlaneLocator() != null) { return (Ip)serviceFunctionForwarder.getSffDataPlaneLocator().get(0) .getDataPlaneLocator().getLocatorType(); } else { LOG.info("getSffIp: ServiceFunctionForwarder is null"); return null; } }
public void addServiceFunctionForwarder(ServiceFunctionForwarder sff) { InstanceIdentifier<ServiceFunctionForwarder> sffIid = getSFFPath(sff.getKey()); LOG.info("Write Service Function Forwarder {} to config data store at {}",sff, sffIid); mdsalPutWrapper(LogicalDatastoreType.CONFIGURATION, sffIid, sff); }
@Override protected void setRestUriList(DataObject dataObject) { ServiceFunctionForwarder obj = (ServiceFunctionForwarder) dataObject; if (obj.getRestUri() != null) { SffName sffName = obj.getName(); if (sffName != null) { String restUri = obj.getRestUri().getValue() + SFF_REST_URI + sffName.getValue(); this.restUriList = new ArrayList<>(); this.restUriList.add(restUri); LOG.info("SFF will be send to REST URI {}", restUri); } } else { this.restUriList = null; } }
ServiceFunctionForwarderKey sffKey = new ServiceFunctionForwarderKey(sffName); ServiceFunctionForwarder sff = sfcMdsalHelper.readServiceFunctionForwarder(sffKey); if (sff != null) { List<ServiceFunctionDictionary> sfDictionary = sff.getServiceFunctionDictionary(); if (sfDictionary != null) { ServiceFunctionDictionary matchingSfd = null; for (ServiceFunctionDictionary sfd : sfDictionary) { if (sfd.getName().equals(sfKey.getName())) { matchingSfd = sfd; break; ServiceFunctionForwarderBuilder sffBuilder = new ServiceFunctionForwarderBuilder(sff); LOG.info("Remove the SF {} from SFF {} dictionary and update in data store.", sfKey .getName(), sffName); sfcMdsalHelper.addServiceFunctionForwarder(sffBuilder.build());
SffOvsBridgeAugmentation sffOvsBrAug = sff.getAugmentation(SffOvsBridgeAugmentation.class); if (sffOvsBrAug != null) { sffOvsBrAugBuilder = new SffOvsBridgeAugmentationBuilder(sffOvsBrAug); sffOvsBrAugBuilder.setOvsBridge(ovsBrBuilder.build()); ServiceFunctionForwarderBuilder sffBuilder = new ServiceFunctionForwarderBuilder(sff); sffBuilder.addAugmentation(SffOvsBridgeAugmentation.class, sffOvsBrAugBuilder.build()); return sffBuilder.build();
@Override public String exportJsonNameOnly(DataObject dataObject) { String ret = null; if (dataObject instanceof ServiceFunctionForwarder) { ServiceFunctionForwarder obj = (ServiceFunctionForwarder) dataObject; ObjectNode node = mapper.createObjectNode(); node.put(_NAME, obj.getName().getValue()); ArrayNode sffArray = mapper.createArrayNode(); sffArray.add(node); ret = "{\"" + _SERVICE_FUNCTION_FORWARDER + "\":" + sffArray.toString() + "}"; } else { throw new IllegalArgumentException("Argument is not an instance of ServiceFunctionForwarder"); } return ret; }
public static final InstanceIdentifier<ServiceFunctionForwarder> createServiceFunctionForwarderPath (String name) { ServiceFunctionForwarderKey serviceFunctionForwarderKey = new ServiceFunctionForwarderKey(name); return InstanceIdentifier.builder(ServiceFunctionForwarders.class) .child(ServiceFunctionForwarder.class, serviceFunctionForwarderKey) .build(); }
public String getSystemId (ServiceFunctionForwarder serviceFunctionForwarder) { String systemId = ""; List<ExternalIds> externalIds = serviceFunctionForwarder.getAugmentation(ServiceFunctionForwarder1.class).getOvs().getExternalIds(); for (ExternalIds externalId : externalIds) { if (externalId.getName().equals("system-id")) { systemId = externalId.getValue(); } } logger.trace("\nOVSSFC {}\n system-id: {}", Thread.currentThread().getStackTrace()[1], systemId); return systemId; } }
public ServiceFunctionForwarder getExistingSFF(String ipAddress) { ServiceFunctionForwarders existingSffs = mdsalUtils.read(LogicalDatastoreType.CONFIGURATION, sffIid); if (existingSffs != null && existingSffs.getServiceFunctionForwarder() != null && !existingSffs.getServiceFunctionForwarder().isEmpty()) { List<ServiceFunctionForwarder> existingSffList = existingSffs.getServiceFunctionForwarder(); for (ServiceFunctionForwarder sff : existingSffList) { if (sff.getIpMgmtAddress().getIpv4Address().equals(new Ipv4Address(ipAddress))) { return sff; } } } return null; }
public ServiceFunctionForwarder updateLispData(ServiceFunctionForwarder serviceFunctionForwarder) { List<SffDataPlaneLocator> locations = serviceFunctionForwarder.getSffDataPlaneLocator(); Lisp lispLocation = getLispLocationFromSff(locations); if (lispLocation != null) { return updateLispData(lispLocation, serviceFunctionForwarder); } else { return serviceFunctionForwarder; } }
/** * This method deletes a SFF from the datastore * <p> * * @param serviceFunctionForwarderName SFF name * @return true if SF was deleted, false otherwise */ public static boolean deleteServiceFunctionForwarder(SffName serviceFunctionForwarderName) { boolean ret = false; printTraceStart(LOG); ServiceFunctionForwarderKey serviceFunctionForwarderKey = new ServiceFunctionForwarderKey(serviceFunctionForwarderName); InstanceIdentifier<ServiceFunctionForwarder> sffEntryIID = InstanceIdentifier.builder(ServiceFunctionForwarders.class) .child(ServiceFunctionForwarder.class, serviceFunctionForwarderKey) .build(); if (SfcDataStoreAPI.deleteTransactionAPI(sffEntryIID, LogicalDatastoreType.CONFIGURATION)) { ret = true; } else { LOG.error("Could not delete SFF: {}", serviceFunctionForwarderName); } printTraceStop(LOG); return ret; }
public static void lispUpdateServiceFunctionForwarder(ServiceFunctionForwarder sff) { LOG.debug("\n####### Start: {}", Thread.currentThread().getStackTrace()[1]); if (OpendaylightSfc.getOpendaylightSfcObj().getDataProvider() != null) { sff = LispUpdater.getLispUpdaterObj().updateLispData(sff); InstanceIdentifier<ServiceFunctionForwarder> sffEntryIID = InstanceIdentifier.builder(ServiceFunctionForwarders.class) .child(ServiceFunctionForwarder.class, sff.getKey()).build(); WriteTransaction writeTx = OpendaylightSfc.getOpendaylightSfcObj().getDataProvider().newWriteOnlyTransaction(); writeTx.merge(LogicalDatastoreType.CONFIGURATION, sffEntryIID, sff, true); writeTx.submit(); } LOG.debug("\n########## Stop: {}", Thread.currentThread().getStackTrace()[1]); }
public boolean containsLispAddress(ServiceFunctionForwarder serviceFunctionForwarder) { List<SffDataPlaneLocator> locations = serviceFunctionForwarder.getSffDataPlaneLocator(); for (SffDataPlaneLocator location : locations) { if (location.getDataPlaneLocator().getLocatorType() instanceof Lisp) { return true; } } return false; }
/** * This method reads a SFF from the datastore * <p> * * @param serviceFunctionForwarderName SFF name * @return SF object or null if not found */ public static ServiceFunctionForwarder readServiceFunctionForwarder(SffName serviceFunctionForwarderName) { printTraceStart(LOG); ServiceFunctionForwarder sff; InstanceIdentifier<ServiceFunctionForwarder> sffIID; ServiceFunctionForwarderKey serviceFunctionForwarderKey = new ServiceFunctionForwarderKey(serviceFunctionForwarderName); sffIID = InstanceIdentifier.builder(ServiceFunctionForwarders.class) .child(ServiceFunctionForwarder.class, serviceFunctionForwarderKey) .build(); sff = SfcDataStoreAPI.readTransactionAPI(sffIID, LogicalDatastoreType.CONFIGURATION); printTraceStop(LOG); return sff; }
/** * This method creates a SFF in the data store * <p> * * @param sff SFF object * @return true if SFF was created, false otherwise */ public static boolean putServiceFunctionForwarder(ServiceFunctionForwarder sff) { boolean ret; printTraceStart(LOG); InstanceIdentifier<ServiceFunctionForwarder> sffEntryIID = InstanceIdentifier .builder(ServiceFunctionForwarders.class).child(ServiceFunctionForwarder.class, sff.getKey()).build(); ret = SfcDataStoreAPI.writePutTransactionAPI(sffEntryIID, sff, LogicalDatastoreType.CONFIGURATION); printTraceStop(LOG); return ret; }
/** * @param sff ServiceFunctionForwarder Object * @param executor ExecutorService Object */ static void addOvsdbAugmentations(ServiceFunctionForwarder sff, ExecutorService executor) { OvsdbBridgeAugmentation ovsdbBridge = SfcSffToOvsMappingAPI.buildOvsdbBridgeAugmentation(sff, executor); if (ovsdbBridge != null) { // put Bridge SfcOvsUtil.putOvsdbBridge(ovsdbBridge, executor); // put Termination Points SfcOvsUtil.putOvsdbTerminationPoints(ovsdbBridge, sff.getSffDataPlaneLocator(), executor); } } }
/** * This method searches for a data plane locator of a given name within a SFF * <p> * * @param sffName SFF name * @param sffLocatorName SFF data plane locator name * @return SffDataPlaneLocator object or null if not found */ public static SffDataPlaneLocator readServiceFunctionForwarderDataPlaneLocator(SffName sffName, SffDataPlaneLocatorName sffLocatorName) { ServiceFunctionForwarder serviceFunctionForwarder = readServiceFunctionForwarder(sffName); if (serviceFunctionForwarder != null) { List<SffDataPlaneLocator> sffDataPlaneLocatorList = serviceFunctionForwarder.getSffDataPlaneLocator(); for (SffDataPlaneLocator sffDataPlaneLocator : sffDataPlaneLocatorList) { if (sffDataPlaneLocator.getName().equals(sffLocatorName)) { return sffDataPlaneLocator; } } } else { LOG.error("{}: Failed to read SFF: {}", Thread.currentThread().getStackTrace()[1], sffName); } return null; }
private static void createHopBuilderInternal(int serviceIndex, RenderedServicePathHopBuilder renderedServicePathHopBuilder, short posIndex, ServiceFunction serviceFunction) { SffName serviceFunctionForwarderName = serviceFunction.getSfDataPlaneLocator().get(0).getServiceFunctionForwarder(); ServiceFunctionForwarder serviceFunctionForwarder = SfcProviderServiceForwarderAPI.readServiceFunctionForwarder(serviceFunctionForwarderName); if (serviceFunctionForwarder != null && serviceFunctionForwarder.getSffDataPlaneLocator() != null && serviceFunctionForwarder.getSffDataPlaneLocator().get(0) != null) { renderedServicePathHopBuilder .setServiceFunctionForwarderLocator(serviceFunctionForwarder.getSffDataPlaneLocator().get(0).getName()); } renderedServicePathHopBuilder.setHopNumber(posIndex) .setServiceIndex((short) serviceIndex) .setServiceFunctionForwarder(serviceFunctionForwarderName); }
/** * This gets VxlanDataLocator * * @param sff - Service Function Forwarder * @return Ip */ public static Ip getSffVxlanDataLocator(ServiceFunctionForwarder sff) { List<SffDataPlaneLocator> dplList = sff.getSffDataPlaneLocator(); for (SffDataPlaneLocator dpl: dplList) { if (dpl.getDataPlaneLocator() != null && dpl.getDataPlaneLocator().getTransport() == VxlanGpe.class) { return (Ip) dpl.getDataPlaneLocator().getLocatorType(); } } return null; }
private ServiceFunctionForwarder findSffByIp(ServiceFunctionForwarders sffs, final IpAddress remoteIp) { List<ServiceFunctionForwarder> serviceFunctionForwarders = sffs.getServiceFunctionForwarder(); if (serviceFunctionForwarders != null && !serviceFunctionForwarders.isEmpty()) for (ServiceFunctionForwarder sff : serviceFunctionForwarders) { List<SffDataPlaneLocator> sffDataPlaneLocator = sff.getSffDataPlaneLocator(); for (SffDataPlaneLocator sffLocator : sffDataPlaneLocator) { LocatorType locatorType = sffLocator.getDataPlaneLocator().getLocatorType(); if (locatorType instanceof Ip) { Ip ip = (Ip) locatorType; if (ip.getIp().equals(remoteIp)) { return sff; } } } } return null; } }