private final Set<NetconfManagementSession> sessions = new HashSet<>();
private final NetconfOperationServiceFactory netconfOperationProvider;
private final Map<Uri, Capability> capabilities = new HashMap<>();
+ private final Map<String, Map<String, String>> mappedModulesToRevisionToSchema = Maps.newHashMap();
private final Set<MonitoringListener> listeners = Sets.newHashSet();
private volatile BaseNotificationPublisherRegistration notificationPublisher;
@Override
public synchronized String getSchemaForCapability(final String moduleName, final Optional<String> revision) {
- // FIXME not effective at all
-
- Map<String, Map<String, String>> mappedModulesToRevisionToSchema = Maps.newHashMap();
-
- final Collection<Capability> caps = capabilities.values();
-
- for (Capability cap : caps) {
- if (!cap.getModuleName().isPresent()
- || !cap.getRevision().isPresent()
- || !cap.getCapabilitySchema().isPresent()){
- continue;
- }
-
- final String currentModuleName = cap.getModuleName().get();
- Map<String, String> revisionMap = mappedModulesToRevisionToSchema.get(currentModuleName);
- if (revisionMap == null) {
- revisionMap = Maps.newHashMap();
- mappedModulesToRevisionToSchema.put(currentModuleName, revisionMap);
- }
-
- String currentRevision = cap.getRevision().get();
- revisionMap.put(currentRevision, cap.getCapabilitySchema().get());
- }
-
Map<String, String> revisionMapRequest = mappedModulesToRevisionToSchema.get(moduleName);
Preconditions.checkState(revisionMapRequest != null, "Capability for module %s not present, " + ""
- + "available modules : %s", moduleName, Collections2.transform(caps, CAPABILITY_TO_URI));
+ + "available modules : %s", moduleName, Collections2.transform(capabilities.values(), CAPABILITY_TO_URI));
if (revision.isPresent()) {
String schema = revisionMapRequest.get(revision.get());
}
}
+ private synchronized void updateCapabilityToSchemaMap(final Set<Capability> added, final Set<Capability> removed) {
+ for (final Capability cap : added) {
+ if (!isValidModuleCapability(cap)){
+ continue;
+ }
+
+ final String currentModuleName = cap.getModuleName().get();
+ Map<String, String> revisionMap = mappedModulesToRevisionToSchema.get(currentModuleName);
+ if (revisionMap == null) {
+ revisionMap = Maps.newHashMap();
+ mappedModulesToRevisionToSchema.put(currentModuleName, revisionMap);
+ }
+
+ final String currentRevision = cap.getRevision().get();
+ revisionMap.put(currentRevision, cap.getCapabilitySchema().get());
+ }
+ for (final Capability cap : removed) {
+ if (!isValidModuleCapability(cap)){
+ continue;
+ }
+ final Map<String, String> revisionMap = mappedModulesToRevisionToSchema.get(cap.getModuleName().get());
+ if (revisionMap != null) {
+ revisionMap.remove(cap.getRevision().get());
+ if (revisionMap.isEmpty()) {
+ mappedModulesToRevisionToSchema.remove(cap.getModuleName().get());
+ }
+ }
+ }
+ }
+
+ private boolean isValidModuleCapability(Capability cap) {
+ return cap.getModuleName().isPresent()
+ && cap.getRevision().isPresent()
+ && cap.getCapabilitySchema().isPresent();
+ }
+
@Override
public synchronized Capabilities getCapabilities() {
return new CapabilitiesBuilder().setCapability(Lists.newArrayList(capabilities.keySet())).build();
public void onCapabilitiesChanged(Set<Capability> added, Set<Capability> removed) {
onCapabilitiesAdded(added);
onCapabilitiesRemoved(removed);
+ updateCapabilityToSchemaMap(added, removed);
notifyListeners();
// publish notification to notification collector about changed capabilities
import com.google.common.base.Optional;
import java.net.URI;
import java.util.ArrayList;
-import java.util.Calendar;
+import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.Assert;
import org.junit.Before;
+import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.sessions.SessionBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.NetconfCapabilityChange;
+import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.Module;
public class NetconfMonitoringServiceImplTest {
private static final String TEST_MODULE_CONTENT = "content";
+ private static final String TEST_MODULE_CONTENT2 = "content2";
private static final String TEST_MODULE_REV = "1970-01-01";
+ private static final String TEST_MODULE_REV2 = "1970-01-02";
private static final Uri TEST_MODULE_NAMESPACE = new Uri("testModuleNamespace");
private static final String TEST_MODULE_NAME = "testModule";
- private static final Date TEST_MODULE_DATE;
+ private static Date TEST_MODULE_DATE;
+ private static Date TEST_MODULE_DATE2;
- static {
- Calendar calendar = Calendar.getInstance();
- calendar.set(1970, Calendar.JANUARY, 1);
- TEST_MODULE_DATE = calendar.getTime();
- }
+ private YangModuleCapability moduleCapability1;
+ private YangModuleCapability moduleCapability2;
private final Set<Capability> CAPABILITIES = new HashSet<>();
private NetconfMonitoringServiceImpl monitoringService;
-
@Mock
private Module moduleMock;
@Mock
+ private Module moduleMock2;
+ @Mock
private NetconfOperationServiceFactory operationServiceFactoryMock;
@Mock
private NetconfManagementSession sessionMock;
+ @BeforeClass
+ public static void suiteSetUp() throws Exception {
+ TEST_MODULE_DATE = SimpleDateFormatUtil.getRevisionFormat().parse(TEST_MODULE_REV);
+ TEST_MODULE_DATE2= SimpleDateFormatUtil.getRevisionFormat().parse(TEST_MODULE_REV2);
+ }
+
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
doReturn(new URI(TEST_MODULE_NAMESPACE.getValue())).when(moduleMock).getNamespace();
doReturn(TEST_MODULE_NAME).when(moduleMock).getName();
doReturn(TEST_MODULE_DATE).when(moduleMock).getRevision();
- doReturn(TEST_MODULE_NAME).when(moduleMock).getName();
+ moduleCapability1 = new YangModuleCapability(moduleMock, TEST_MODULE_CONTENT);
+
+ CAPABILITIES.add(moduleCapability1);
+
+ doReturn(new URI(TEST_MODULE_NAMESPACE.getValue())).when(moduleMock2).getNamespace();
+ doReturn(TEST_MODULE_NAME).when(moduleMock2).getName();
+ doReturn(TEST_MODULE_DATE2).when(moduleMock2).getRevision();
+ moduleCapability2 = new YangModuleCapability(moduleMock2, TEST_MODULE_CONTENT2);
- CAPABILITIES.add(new YangModuleCapability(moduleMock, TEST_MODULE_CONTENT));
doReturn(CAPABILITIES).when(operationServiceFactoryMock).getCapabilities();
doReturn(null).when(operationServiceFactoryMock).registerCapabilityListener(any(NetconfMonitoringServiceImpl.class));
monitoringService = new NetconfMonitoringServiceImpl(operationServiceFactoryMock);
- monitoringService.onCapabilitiesChanged(CAPABILITIES, new HashSet<Capability>());
+ monitoringService.onCapabilitiesChanged(CAPABILITIES, Collections.emptySet());
doReturn(new SessionBuilder().build()).when(sessionMock).toManagementSession();
}
@Test
public void testGetSchemaForCapability() throws Exception {
- String schema = monitoringService.getSchemaForCapability(TEST_MODULE_NAME, Optional.of(TEST_MODULE_REV));
+ //test multiple revisions of the same capability
+ monitoringService.onCapabilitiesChanged(Collections.singleton(moduleCapability2), Collections.emptySet());
+ final String schema = monitoringService.getSchemaForCapability(TEST_MODULE_NAME, Optional.of(TEST_MODULE_REV));
Assert.assertEquals(TEST_MODULE_CONTENT, schema);
-
+ final String schema2 = monitoringService.getSchemaForCapability(TEST_MODULE_NAME, Optional.of(TEST_MODULE_REV2));
+ Assert.assertEquals(TEST_MODULE_CONTENT2, schema2);
+ //remove one revision
+ monitoringService.onCapabilitiesChanged(Collections.emptySet(), Collections.singleton(moduleCapability1));
+ //only one revision present
+ final String schema3 = monitoringService.getSchemaForCapability(TEST_MODULE_NAME, Optional.absent());
+ Assert.assertEquals(TEST_MODULE_CONTENT2, schema3);
}
@Test