Java tutorial
/* * Copyright 2016-present Open Networking Laboratory * * 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 License at * * http://www.apache.org/licenses/LICENSE-2.0 * * 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. */ package org.onosproject.provider.netconf.device.impl; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.google.common.collect.ImmutableSet; import org.apache.commons.lang.StringUtils; import org.junit.Before; import org.junit.Test; import org.onlab.packet.ChassisId; import org.onlab.packet.IpAddress; import org.onosproject.cfg.ComponentConfigAdapter; import org.onosproject.core.ApplicationId; import org.onosproject.core.CoreService; import org.onosproject.core.DefaultApplicationId; import org.onosproject.incubator.net.config.basics.ConfigException; import org.onosproject.mastership.MastershipService; import org.onosproject.mastership.MastershipServiceAdapter; import org.onosproject.net.AbstractProjectableModel; import org.onosproject.net.Annotations; import org.onosproject.net.DefaultDevice; import org.onosproject.net.Device; import org.onosproject.net.DeviceId; import org.onosproject.net.config.Config; import org.onosproject.net.config.ConfigApplyDelegate; import org.onosproject.net.config.ConfigFactory; import org.onosproject.net.config.NetworkConfigEvent; import org.onosproject.net.config.NetworkConfigListener; import org.onosproject.net.config.NetworkConfigRegistry; import org.onosproject.net.config.NetworkConfigRegistryAdapter; import org.onosproject.net.config.basics.BasicDeviceConfig; import org.onosproject.net.device.DeviceDescription; import org.onosproject.net.device.DeviceDescriptionDiscovery; import org.onosproject.net.device.DeviceEvent; import org.onosproject.net.device.DeviceListener; import org.onosproject.net.device.DeviceProvider; import org.onosproject.net.device.DeviceProviderRegistry; import org.onosproject.net.device.DeviceProviderRegistryAdapter; import org.onosproject.net.device.DeviceProviderService; import org.onosproject.net.device.DeviceProviderServiceAdapter; import org.onosproject.net.device.DeviceService; import org.onosproject.net.device.DeviceServiceAdapter; import org.onosproject.net.device.DeviceStore; import org.onosproject.net.device.DeviceStoreAdapter; import org.onosproject.net.device.PortDescription; import org.onosproject.net.driver.AbstractHandlerBehaviour; import org.onosproject.net.driver.Behaviour; import org.onosproject.net.driver.Driver; import org.onosproject.net.driver.DriverAdapter; import org.onosproject.net.driver.DriverHandler; import org.onosproject.net.driver.DriverServiceAdapter; import org.onosproject.net.key.DeviceKeyAdminService; import org.onosproject.net.key.DeviceKeyAdminServiceAdapter; import org.onosproject.net.provider.ProviderId; import org.onosproject.netconf.NetconfController; import org.onosproject.netconf.NetconfDeviceListener; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.concurrent.CopyOnWriteArraySet; import static org.easymock.EasyMock.*; import static org.hamcrest.Matchers.is; import static org.junit.Assert.*; import static org.onlab.junit.TestTools.assertAfter; import static org.onosproject.provider.netconf.device.impl.NetconfDeviceProvider.APP_NAME; /** * Netconf device provider basic test. */ public class NetconfDeviceProviderTest { private final NetconfDeviceProvider provider = new NetconfDeviceProvider(); private final NetconfController controller = new MockNetconfController(); //Provider Mock private final DeviceProviderRegistry deviceRegistry = new MockDeviceProviderRegistry(); private final DeviceProviderService providerService = new MockDeviceProviderService(); private final DeviceService deviceService = new MockDeviceService(); private final MastershipService mastershipService = new MockMastershipService(); private final Driver driver = new MockDriver(); private final NetworkConfigRegistry cfgService = new MockNetworkConfigRegistry(); private final Set<ConfigFactory> cfgFactories = new HashSet<>(); private final DeviceKeyAdminService deviceKeyAdminService = new DeviceKeyAdminServiceAdapter(); private final DeviceStore deviceStore = new MockDeviceStore(); //Class for testing private final NetworkConfigEvent deviceAddedEvent = new NetworkConfigEvent(NetworkConfigEvent.Type.CONFIG_ADDED, DeviceId.deviceId(NETCONF_DEVICE_ID_STRING), NetconfDeviceConfig.class); private final NetconfDeviceConfig netconfDeviceConfig = new NetconfDeviceConfig(); private final NetconfDeviceConfig netconfDeviceConfigSshKey = new NetconfDeviceConfig(); private final NetconfDeviceConfig netconfDeviceConfigEmptyIpv4 = new NetconfDeviceConfig(); private final NetconfDeviceConfig netconfDeviceConfigEmptyIpv6 = new NetconfDeviceConfig(); private final NetworkConfigEvent deviceAddedEventOld = new NetworkConfigEvent( NetworkConfigEvent.Type.CONFIG_ADDED, null, NetconfProviderConfig.class); private final NetworkConfigEvent deviceAddedEventTranslated = new NetworkConfigEvent( NetworkConfigEvent.Type.CONFIG_ADDED, DeviceId.deviceId(NETCONF_DEVICE_ID_STRING_OLD), NetconfDeviceConfig.class); private final NetconfProviderConfig netconfProviderConfig = new MockNetconfProviderConfig(); private static final String NETCONF_DEVICE_ID_STRING = "netconf:1.1.1.1:830"; private static final String NETCONF_DEVICE_ID_STRING_OLD = "netconf:1.1.1.2:1"; private static final String NETCONF_DEVICE_ID_STRING_IPV6 = "netconf:2001:0db8:0000:0000:0000:ff00:0042:8329:830"; private static final String IP_STRING = "1.1.1.1"; private static final String IP_STRING_OLD = "1.1.1.2"; private static final String IP_STRING_IPV6 = "2001:0db8:0000:0000:0000:ff00:0042:8329"; private static final IpAddress IP = IpAddress.valueOf(IP_STRING); private static final IpAddress IP_OLD = IpAddress.valueOf(IP_STRING_OLD); private static final IpAddress IP_V6 = IpAddress.valueOf(IP_STRING_IPV6); private static final int PORT = 830; private static final String TEST = "test"; private static final int DELAY_DISCOVERY = 500; private static final int DELAY_DURATION_DISCOVERY = 1500; //Testing Files InputStream jsonStream = NetconfDeviceProviderTest.class.getResourceAsStream("/device.json"); InputStream jsonStreamSshKey = NetconfDeviceProviderTest.class.getResourceAsStream("/deviceSshKey.json"); //Provider related classes private CoreService coreService; private ApplicationId appId = new DefaultApplicationId(100, APP_NAME); private DeviceDescriptionDiscovery descriptionDiscovery = new TestDescription(); private Set<DeviceListener> deviceListeners = new HashSet<>(); private Set<NetworkConfigListener> netCfgListeners = new HashSet<>(); private HashMap<DeviceId, Device> devices = new HashMap<>(); //Controller related classes private Set<NetconfDeviceListener> netconfDeviceListeners = new CopyOnWriteArraySet<>(); private boolean available = false; private boolean firstRequest = true; @Before public void setUp() throws IOException { coreService = createMock(CoreService.class); expect(coreService.registerApplication(APP_NAME)).andReturn(appId).anyTimes(); replay(coreService); provider.coreService = coreService; provider.providerRegistry = deviceRegistry; provider.mastershipService = mastershipService; provider.deviceService = deviceService; provider.cfgService = cfgService; provider.controller = controller; provider.deviceKeyAdminService = deviceKeyAdminService; provider.componentConfigService = new ComponentConfigAdapter(); AbstractProjectableModel.setDriverService(null, new DriverServiceAdapter()); provider.activate(null); devices.clear(); available = false; firstRequest = true; DeviceId subject = DeviceId.deviceId(NETCONF_DEVICE_ID_STRING); DeviceId subjectIpv6 = DeviceId.deviceId(NETCONF_DEVICE_ID_STRING_IPV6); String key = "netconf"; ObjectMapper mapper = new ObjectMapper(); JsonNode jsonNode = mapper.readTree(jsonStream); ConfigApplyDelegate delegate = new MockDelegate(); netconfDeviceConfig.init(subject, key, jsonNode, mapper, delegate); JsonNode jsonNodesshKey = mapper.readTree(jsonStreamSshKey); netconfDeviceConfigSshKey.init(subject, key, jsonNodesshKey, mapper, delegate); JsonNode jsonNodeEmpty = mapper.createObjectNode(); netconfDeviceConfigEmptyIpv4.init(subject, key, jsonNodeEmpty, mapper, delegate); netconfDeviceConfigEmptyIpv6.init(subjectIpv6, key, jsonNodeEmpty, mapper, delegate); } @Test public void activate() throws Exception { assertTrue("Provider should be registered", deviceRegistry.getProviders().contains(provider.id())); assertEquals("Incorrect device service", deviceService, provider.deviceService); assertEquals("Incorrect provider service", providerService, provider.providerService); assertTrue("Incorrect config factories", cfgFactories.containsAll(provider.factories)); assertEquals("Device listener should be added", 1, deviceListeners.size()); assertFalse("Thread to connect device should be running", provider.executor.isShutdown() || provider.executor.isTerminated()); assertFalse("Scheduled task to update device should be running", provider.scheduledTask.isCancelled()); } @Test public void deactivate() throws Exception { provider.deactivate(); assertEquals("Device listener should be removed", 0, deviceListeners.size()); assertFalse("Provider should not be registered", deviceRegistry.getProviders().contains(provider)); assertTrue("Thread to connect device should be shutdown", provider.executor.isShutdown()); assertTrue("Scheduled task to update device should be shutdown", provider.scheduledTask.isCancelled()); assertNull("Provider service should be null", provider.providerService); assertTrue("Network config factories not removed", cfgFactories.isEmpty()); assertEquals("Controller listener should be removed", 0, netconfDeviceListeners.size()); } @Test public void configuration() { assertTrue("Configuration should be valid", netconfDeviceConfig.isValid()); assertThat(netconfDeviceConfig.ip(), is(IP)); assertThat(netconfDeviceConfig.port(), is(PORT)); assertThat(netconfDeviceConfig.username(), is(TEST)); assertThat(netconfDeviceConfig.password(), is(TEST)); assertThat(netconfDeviceConfigSshKey.sshKey(), is(TEST)); } @Test public void configurationDeviceIdIpv4() { assertTrue("Configuration should be valid", netconfDeviceConfigEmptyIpv4.isValid()); assertThat(netconfDeviceConfigEmptyIpv4.ip(), is(IP)); assertThat(netconfDeviceConfigEmptyIpv4.port(), is(PORT)); assertThat(netconfDeviceConfigEmptyIpv4.username(), is(StringUtils.EMPTY)); assertThat(netconfDeviceConfigEmptyIpv4.password(), is(StringUtils.EMPTY)); assertThat(netconfDeviceConfigEmptyIpv4.sshKey(), is(StringUtils.EMPTY)); } @Test public void configurationDeviceIdIpv6() { assertTrue("Configuration should be valid", netconfDeviceConfigEmptyIpv6.isValid()); assertThat(netconfDeviceConfigEmptyIpv6.ip(), is(IP_V6)); assertThat(netconfDeviceConfigEmptyIpv6.port(), is(PORT)); assertThat(netconfDeviceConfigEmptyIpv6.username(), is(StringUtils.EMPTY)); assertThat(netconfDeviceConfigEmptyIpv6.password(), is(StringUtils.EMPTY)); assertThat(netconfDeviceConfigEmptyIpv6.sshKey(), is(StringUtils.EMPTY)); } @Test public void addDeviceOld() { assertNotNull(providerService); assertTrue("Event should be relevant", provider.cfgListener.isRelevant(deviceAddedEvent)); assertTrue("Event should be relevant", provider.cfgListener.isRelevant(deviceAddedEventOld)); available = true; provider.cfgListener.event(deviceAddedEventOld); assertAfter(DELAY_DISCOVERY, DELAY_DURATION_DISCOVERY, () -> { assertEquals("Device should be added", 1, deviceStore.getDeviceCount()); assertTrue("Device incorrectly added" + NETCONF_DEVICE_ID_STRING_OLD, devices.containsKey(DeviceId.deviceId(NETCONF_DEVICE_ID_STRING_OLD))); }); devices.clear(); } @Test public void addDeviceNew() { assertNotNull(providerService); assertTrue("Event should be relevant", provider.cfgListener.isRelevant(deviceAddedEvent)); assertTrue("Event should be relevant", provider.cfgListener.isRelevant(deviceAddedEventOld)); available = true; provider.cfgListener.event(deviceAddedEvent); assertAfter(DELAY_DISCOVERY, DELAY_DURATION_DISCOVERY, () -> { assertEquals("Device should be added", 1, deviceStore.getDeviceCount()); assertTrue("Device incorrectly added" + NETCONF_DEVICE_ID_STRING, devices.containsKey(DeviceId.deviceId(NETCONF_DEVICE_ID_STRING))); }); devices.clear(); } //TODO: implement ports discovery and check updates of the device description //Mock classes private class MockNetconfController extends NetconfControllerAdapter { @Override public void addDeviceListener(NetconfDeviceListener listener) { if (!netconfDeviceListeners.contains(listener)) { netconfDeviceListeners.add(listener); } } @Override public void removeDeviceListener(NetconfDeviceListener listener) { netconfDeviceListeners.remove(listener); } } private class MockDeviceProviderRegistry extends DeviceProviderRegistryAdapter { Set<ProviderId> providers = new HashSet<>(); @Override public DeviceProviderService register(DeviceProvider provider) { providers.add(provider.id()); return providerService; } @Override public void unregister(DeviceProvider provider) { providers.remove(provider.id()); } @Override public Set<ProviderId> getProviders() { return providers; } } private class MockDeviceService extends DeviceServiceAdapter { @Override public void addListener(DeviceListener listener) { deviceListeners.add(listener); } @Override public void removeListener(DeviceListener listener) { deviceListeners.remove(listener); } } private class MockDeviceProviderService extends DeviceProviderServiceAdapter { @Override public void deviceConnected(DeviceId deviceId, DeviceDescription desc) { assertNotNull("DeviceId should be not null", deviceId); assertNotNull("DeviceDescription should be not null", desc); deviceStore.createOrUpdateDevice(ProviderId.NONE, deviceId, desc); } } private class MockDeviceStore extends DeviceStoreAdapter { @Override public DeviceEvent createOrUpdateDevice(ProviderId providerId, DeviceId deviceId, DeviceDescription desc) { devices.put(deviceId, new DefaultDevice(providerId, deviceId, desc.type(), desc.manufacturer(), desc.hwVersion(), desc.swVersion(), desc.serialNumber(), desc.chassisId(), desc.annotations())); return null; } @Override public Device getDevice(DeviceId deviceId) { return devices.get(deviceId); } @Override public int getDeviceCount() { return devices.size(); } } private class MockMastershipService extends MastershipServiceAdapter { @Override public boolean isLocalMaster(DeviceId deviceId) { return true; } } private class MockNetworkConfigRegistry extends NetworkConfigRegistryAdapter { NetconfDeviceConfig cfg = null; @Override public void registerConfigFactory(ConfigFactory configFactory) { cfgFactories.add(configFactory); } @Override public void unregisterConfigFactory(ConfigFactory configFactory) { cfgFactories.remove(configFactory); } @Override public void addListener(NetworkConfigListener listener) { netCfgListeners.add(listener); } @Override public void removeListener(NetworkConfigListener listener) { netCfgListeners.remove(listener); } @Override public <S, C extends Config<S>> C getConfig(S subject, Class<C> configClass) { if (available) { if (configClass.equals(NetconfProviderConfig.class)) { return (C) netconfProviderConfig; } DeviceId did = (DeviceId) subject; if (configClass.equals(NetconfDeviceConfig.class) && did.equals(DeviceId.deviceId(NETCONF_DEVICE_ID_STRING))) { return (C) netconfDeviceConfig; } else if (configClass.equals(NetconfDeviceConfig.class) && did.equals(DeviceId.deviceId(NETCONF_DEVICE_ID_STRING_OLD))) { if (firstRequest) { firstRequest = false; return null; } return (C) cfg; } else { return (C) new BasicDeviceConfig(); } } return null; } @Override public <S, C extends Config<S>> C applyConfig(S subject, Class<C> configClass, JsonNode json) { cfg = new NetconfDeviceConfig(); ObjectMapper mapper = new ObjectMapper(); cfg.init((DeviceId) subject, "netconf", mapper.createObjectNode(), mapper, null); cfg.setIp(json.get("ip").asText()).setPort(json.get("port").asInt()) .setUsername(json.get("username").asText()).setPassword(json.get("password").asText()) .setSshKey(json.get("sshkey").asText()); provider.cfgListener.event(deviceAddedEventTranslated); return (C) cfg; } @Override public <S, C extends Config<S>> Set<S> getSubjects(Class<S> subjectClass, Class<C> configClass) { Set<S> subjects = new HashSet<S>(); if (available) { if (cfg != null) { subjects.add((S) DeviceId.deviceId(NETCONF_DEVICE_ID_STRING_OLD)); } else { subjects.add((S) DeviceId.deviceId(NETCONF_DEVICE_ID_STRING)); } } return subjects; } } private class MockNetconfProviderConfig extends NetconfProviderConfig { protected NetconfDeviceAddress deviceInfo = new NetconfDeviceAddress(IP_OLD, 1, TEST, TEST); @Override public Set<NetconfProviderConfig.NetconfDeviceAddress> getDevicesAddresses() throws ConfigException { return ImmutableSet.of(deviceInfo); } } private class MockDevice extends DefaultDevice { public MockDevice(ProviderId providerId, DeviceId id, Type type, String manufacturer, String hwVersion, String swVersion, String serialNumber, ChassisId chassisId, Annotations... annotations) { super(providerId, id, type, manufacturer, hwVersion, swVersion, serialNumber, chassisId, annotations); } @Override protected Driver locateDriver() { return driver; } @Override public Driver driver() { return driver; } } private class MockDriver extends DriverAdapter { @Override public <T extends Behaviour> T createBehaviour(DriverHandler handler, Class<T> behaviourClass) { return (T) descriptionDiscovery; } } private class TestDescription extends AbstractHandlerBehaviour implements DeviceDescriptionDiscovery { List<PortDescription> portDescriptions = new ArrayList<>(); @Override public DeviceDescription discoverDeviceDetails() { return null; } @Override public List<PortDescription> discoverPortDetails() { return portDescriptions; } private void addDeviceDetails() { } private void addPortDesc(PortDescription portDescription) { portDescriptions.add(portDescription); } } private class MockDelegate implements ConfigApplyDelegate { @Override public void onApply(Config configFile) { } } }