*/
package org.opendaylight.lispflowmapping.implementation;
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.lispflowmapping.implementation.config.ConfigIni;
-import org.opendaylight.lispflowmapping.implementation.mdsal.AuthenticationKeyDataListener;
+import org.opendaylight.lispflowmapping.config.ConfigIni;
import org.opendaylight.lispflowmapping.dsbackend.DataStoreBackEnd;
+import org.opendaylight.lispflowmapping.implementation.mdsal.AuthenticationKeyDataListener;
import org.opendaylight.lispflowmapping.implementation.mdsal.MappingDataListener;
import org.opendaylight.lispflowmapping.implementation.util.DSBEInputUtil;
import org.opendaylight.lispflowmapping.implementation.util.RPCInputConvertorUtil;
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
+import org.opendaylight.lispflowmapping.lisp.type.MappingData;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.SiteId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingOutputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingWithXtrIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingWithXtrIdOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingWithXtrIdOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.Futures;
-
/**
* Dispatcher of API calls that implements the RPC and Java APIs in mappingservice.yang and IMappingService
* respectively. It also coordinates and acts as container for all objects in charge of
private final DataBroker dataBroker;
private final NotificationPublishService notificationPublishService;
- private boolean overwritePolicy = ConfigIni.getInstance().mappingOverwriteIsSet();
+ private boolean mappingMergePolicy = ConfigIni.getInstance().mappingMergeIsSet();
private boolean notificationPolicy = ConfigIni.getInstance().smrIsSet();
private boolean iterateMask = true;
+ private boolean isMaster = false;
public MappingService(final DataBroker broker,
final NotificationPublishService notificationPublishService,
@Override
- public void setMappingOverwrite(boolean overwrite) {
- this.overwritePolicy = overwrite;
+ public void setMappingMerge(boolean mergeMapping) {
+ this.mappingMergePolicy = mergeMapping;
if (mappingSystem != null) {
- mappingSystem.setOverwritePolicy(overwrite);
- ConfigIni.getInstance().setMappingOverwrite(overwrite);
+ mappingSystem.setMappingMerge(mergeMapping);
+ ConfigIni.getInstance().setMappingMerge(mappingMergePolicy);
}
}
LOG.info("Mapping Service initializing...");
dsbe = new DataStoreBackEnd(dataBroker);
- mappingSystem = new MappingSystem(dao, iterateMask, notificationPolicy, overwritePolicy);
+ mappingSystem = new MappingSystem(dao, iterateMask, notificationPolicy, mappingMergePolicy);
mappingSystem.setDataStoreBackEnd(dsbe);
mappingSystem.initialize();
return Futures.immediateFuture(rpcResultBuilder.build());
}
+ @Override
+ public void addMapping(MappingOrigin origin, Eid key, SiteId siteId, MappingData mappingData) {
+ // SB registrations are first written to the MappingSystem and only afterwards are persisted to the datastore
+ if (origin.equals(MappingOrigin.Southbound)) {
+ // Store data first in MapCache and only afterwards persist to datastore. This should be used only for SB
+ // registrations
+ mappingSystem.addMapping(origin, key, mappingData);
+ dsbe.addMapping(DSBEInputUtil.toMapping(origin, key, siteId, mappingData));
+ if (mappingData.getXtrId() != null) {
+ dsbe.addXtrIdMapping(DSBEInputUtil.toXtrIdMapping(mappingData));
+ }
+ } else {
+ dsbe.addMapping(DSBEInputUtil.toMapping(origin, key, siteId, mappingData));
+ }
+ }
+
+ @Override
+ public void refreshMappingRegistration(Eid key, XtrId xtrId, Long timestamp) {
+ mappingSystem.refreshMappingRegistration(key, xtrId, timestamp);
+ }
+
@Override
public Future<RpcResult<GetKeyOutput>> getKey(GetKeyInput input) {
Preconditions.checkNotNull(input, "get-key RPC input must be not null!");
RpcResultBuilder<GetMappingOutput> rpcResultBuilder;
- MappingRecord reply = (MappingRecord) mappingSystem.getMapping(convertToBinaryIfNecessary(input.getEid()));
+ MappingData reply = mappingSystem.getMapping(convertToBinaryIfNecessary(input.getEid()));
if (reply == null) {
String message = "No mapping was found in the mapping database";
rpcResultBuilder = RpcResultBuilder.<GetMappingOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, NOT_FOUND_TAG, message);
} else {
- final MappingRecord convertedReply = convertFromBinaryIfNecessary(reply);
+ final MappingRecord convertedReply = convertFromBinaryIfNecessary(reply.getRecord());
rpcResultBuilder = RpcResultBuilder.success(new GetMappingOutputBuilder().setMappingRecord(convertedReply));
}
return Futures.immediateFuture(rpcResultBuilder.build());
}
+ @Override
+ public MappingData getMapping(MappingOrigin origin, Eid key) {
+ return mappingSystem.getMapping(origin, key);
+ }
+
+ @Override
+ public MappingData getMapping(Eid key) {
+ return mappingSystem.getMapping(key);
+ }
+
+ @Override
+ public MappingData getMapping(Eid srcKey, Eid dstKey) {
+ return mappingSystem.getMapping(srcKey, dstKey);
+ }
+
+ @Override
+ public Future<RpcResult<GetMappingWithXtrIdOutput>> getMappingWithXtrId(GetMappingWithXtrIdInput input) {
+ Preconditions.checkNotNull(input, "get-mapping RPC input must be not null!");
+ LOG.trace("RPC received to get the following mapping: " + input.toString());
+
+ RpcResultBuilder<GetMappingWithXtrIdOutput> rpcResultBuilder;
+
+ MappingData reply = mappingSystem.getMapping(null, convertToBinaryIfNecessary(input.getEid()),
+ input.getXtrId());
+
+ if (reply == null) {
+ String message = "No mapping was found in the mapping database";
+ rpcResultBuilder = RpcResultBuilder.<GetMappingWithXtrIdOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, NOT_FOUND_TAG, message);
+ } else {
+ final MappingRecord convertedReply = convertFromBinaryIfNecessary(reply.getRecord());
+ rpcResultBuilder = RpcResultBuilder.success(new GetMappingWithXtrIdOutputBuilder()
+ .setMappingRecord(convertedReply));
+ }
+
+ return Futures.immediateFuture(rpcResultBuilder.build());
+ }
+
@Override
public Future<RpcResult<Void>> removeKey(RemoveKeyInput input) {
Preconditions.checkNotNull(input, "remove-key RPC input must be not null!");
return Futures.immediateFuture(rpcResultBuilder.build());
}
+ @Override
+ public void removeMapping(MappingOrigin origin, Eid key) {
+ dsbe.removeMapping(DSBEInputUtil.toMapping(origin, key));
+ }
+
@Override
public Future<RpcResult<Void>> updateKey(UpdateKeyInput input) {
Preconditions.checkNotNull(input, "update-key RPC input must be not null!");
}
@Override
- public void addMapping(MappingOrigin origin, Eid key, SiteId siteId, Object data, boolean merge) {
- // SB registrations are first written to the MappingSystem and only afterwards are persisted to the datastore
- if (origin.equals(MappingOrigin.Southbound)) {
- // Store data first in MapCache and only afterwards persist to datastore. This should be used only for SB
- // registrations
- mappingSystem.addMapping(origin, key, data, merge);
- dsbe.addMapping(DSBEInputUtil.toMapping(origin, key, siteId, (MappingRecord) data));
- if (((MappingRecord) data).getXtrId() != null) {
- dsbe.addXtrIdMapping(DSBEInputUtil.toXtrIdMapping((MappingRecord) data));
- }
- } else {
- dsbe.addMapping(DSBEInputUtil.toMapping(origin, key, siteId, (MappingRecord) data));
- }
- }
-
- @Override
- public void updateMappingRegistration(MappingOrigin origin, Eid key, Long timestamp) {
- mappingSystem.updateMappingRegistration(origin, key, timestamp);
- }
+ public Future<RpcResult<Void>> removeAllOperationalContent() {
+ RpcResultBuilder<Void> rpcResultBuilder;
- @Override
- public Object getMapping(MappingOrigin origin, Eid key) {
- return mappingSystem.getMapping(origin, key);
- }
+ /*
+ * Since master nodes ignore datastore changes for southbound originated mappings, they need to be removed
+ * explicitly.
+ */
+ if (isMaster) {
+ mappingSystem.cleanSBMappings();
+ }
+ dsbe.removeAllOperationalDatastoreContent();
- @Override
- public Object getMapping(Eid key) {
- return mappingSystem.getMapping(key);
- }
+ rpcResultBuilder = RpcResultBuilder.success();
- @Override
- public Object getMapping(Eid srcKey, Eid dstKey) {
- return mappingSystem.getMapping(srcKey, dstKey);
+ return Futures.immediateFuture(rpcResultBuilder.build());
}
@Override
return mappingSystem.getWidestNegativePrefix(key);
}
- @Override
- public void removeMapping(MappingOrigin origin, Eid key) {
- dsbe.removeMapping(DSBEInputUtil.toMapping(origin, key));
- }
-
@Override
public void addAuthenticationKey(Eid key, MappingAuthkey authKey) {
dsbe.addAuthenticationKey(DSBEInputUtil.toAuthenticationKey(key, authKey));
mappingSystem.removeData(origin, key, subKey);
}
+ @Override
+ public Eid getParentPrefix(Eid key) {
+ return mappingSystem.getParentPrefix(key);
+ }
+
@Override
public String printMappings() {
return mappingSystem.printMappings();
}
+ @Override
+ public String printKeys() {
+ return mappingSystem.printKeys();
+ }
+
@Override
public void close() throws Exception {
LOG.info("Mapping Service is being destroyed!");
keyListener.closeDataChangeListener();
mappingListener.closeDataChangeListener();
+ mappingSystem.destroy();
}
@Override
convertedLocators = convertFromBinaryIfNecessary(originalLocators);
}
- if (LispAddressUtil.addressNeedsConversionFromBinary(originalRecord.getEid().getAddress()) ||
- (originalLocators != null && convertedLocators != null)) {
+ if (LispAddressUtil.addressNeedsConversionFromBinary(originalRecord.getEid().getAddress())
+ || (originalLocators != null && convertedLocators != null)) {
MappingRecordBuilder mrb = new MappingRecordBuilder(originalRecord);
mrb.setEid(LispAddressUtil.convertFromBinary(originalRecord.getEid()));
if (convertedLocators != null) {
}
return originalLocators;
}
+
+ @Override
+ public void setIsMaster(boolean isMaster) {
+ this.isMaster = isMaster;
+ mappingSystem.setIsMaster(isMaster);
+ }
+
+ @Override
+ public boolean isMaster() {
+ return isMaster;
+ }
}