| /* |
| * Copyright 2015-present Open Networking Foundation |
| * |
| * 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.net.meter.impl; |
| |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableMap; |
| import com.google.common.collect.Lists; |
| import com.google.common.collect.Sets; |
| import org.easymock.EasyMock; |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.onlab.junit.TestTools; |
| import org.onlab.junit.TestUtils; |
| import org.onlab.packet.IpAddress; |
| import org.onlab.util.KryoNamespace; |
| import org.onosproject.TestApplicationId; |
| import org.onosproject.cfg.ComponentConfigAdapter; |
| import org.onosproject.cluster.ClusterServiceAdapter; |
| import org.onosproject.cluster.ControllerNode; |
| import org.onosproject.cluster.DefaultControllerNode; |
| import org.onosproject.cluster.NodeId; |
| import org.onosproject.common.event.impl.TestEventDispatcher; |
| import org.onosproject.mastership.MastershipServiceAdapter; |
| import org.onosproject.net.AnnotationKeys; |
| import org.onosproject.net.DefaultAnnotations; |
| import org.onosproject.net.DefaultDevice; |
| import org.onosproject.net.Device; |
| import org.onosproject.net.DeviceId; |
| import org.onosproject.net.MastershipRole; |
| import org.onosproject.net.behaviour.MeterQuery; |
| import org.onosproject.net.config.NetworkConfigService; |
| import org.onosproject.net.config.NetworkConfigServiceAdapter; |
| import org.onosproject.net.device.DeviceService; |
| import org.onosproject.net.device.DeviceServiceAdapter; |
| import org.onosproject.net.driver.AbstractHandlerBehaviour; |
| import org.onosproject.net.driver.DefaultDriver; |
| import org.onosproject.net.driver.DriverRegistry; |
| import org.onosproject.net.driver.impl.DriverManager; |
| import org.onosproject.net.driver.impl.DriverRegistryManager; |
| import org.onosproject.net.meter.Band; |
| import org.onosproject.net.meter.DefaultBand; |
| import org.onosproject.net.meter.DefaultMeter; |
| import org.onosproject.net.meter.DefaultMeterFeatures; |
| import org.onosproject.net.meter.DefaultMeterRequest; |
| import org.onosproject.net.meter.Meter; |
| import org.onosproject.net.meter.MeterCellId; |
| import org.onosproject.net.meter.MeterFeatures; |
| import org.onosproject.net.meter.MeterId; |
| import org.onosproject.net.meter.MeterOperation; |
| import org.onosproject.net.meter.MeterOperations; |
| import org.onosproject.net.meter.MeterProgrammable; |
| import org.onosproject.net.meter.MeterProvider; |
| import org.onosproject.net.meter.MeterProviderRegistry; |
| import org.onosproject.net.meter.MeterProviderService; |
| import org.onosproject.net.meter.MeterRequest; |
| import org.onosproject.net.meter.MeterScope; |
| import org.onosproject.net.meter.MeterService; |
| import org.onosproject.net.meter.MeterState; |
| import org.onosproject.net.pi.PiPipeconfServiceAdapter; |
| import org.onosproject.net.pi.model.PiMeterId; |
| import org.onosproject.net.pi.runtime.PiMeterCellId; |
| import org.onosproject.net.provider.AbstractProvider; |
| import org.onosproject.net.provider.ProviderId; |
| import org.onosproject.store.meter.impl.DistributedMeterStore; |
| import org.onosproject.store.service.Serializer; |
| import org.onosproject.store.service.TestStorageService; |
| import org.osgi.service.component.ComponentContext; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.Dictionary; |
| import java.util.Hashtable; |
| import java.util.concurrent.CompletableFuture; |
| |
| import static org.easymock.EasyMock.expect; |
| import static org.easymock.EasyMock.replay; |
| import static org.easymock.EasyMock.reset; |
| import static org.hamcrest.Matchers.is; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertThat; |
| import static org.junit.Assert.assertTrue; |
| import static org.onosproject.net.NetTestTools.APP_ID; |
| import static org.onosproject.net.NetTestTools.did; |
| import static org.onosproject.net.NetTestTools.injectEventDispatcher; |
| import static org.onosproject.net.OsgiPropertyConstants.MM_USER_DEFINED_INDEX; |
| |
| /** |
| * Meter manager tests. |
| */ |
| public class MeterManagerTest { |
| |
| // Test node id |
| private static final NodeId NID_LOCAL = new NodeId("local"); |
| |
| // Test ip address |
| private static final IpAddress LOCALHOST = IpAddress.valueOf("127.0.0.1"); |
| |
| private static final ProviderId PID = new ProviderId("of", "foo"); |
| |
| private static final ProviderId PROGRAMMABLE_PROVIDER = new ProviderId("foo", "foo"); |
| private static final DeviceId PROGRAMMABLE_DID = DeviceId.deviceId("test:002"); |
| |
| private static final DefaultAnnotations ANNOTATIONS = |
| DefaultAnnotations.builder().set(AnnotationKeys.DRIVER, "foo").build(); |
| |
| private static final Device PROGRAMMABLE_DEV = |
| new DefaultDevice(PROGRAMMABLE_PROVIDER, PROGRAMMABLE_DID, Device.Type.SWITCH, |
| "", "", "", "", null, ANNOTATIONS); |
| |
| private MeterService service; |
| |
| // Test Driver service used during the tests |
| private DriverManager driverService; |
| |
| // Test device service used during the tests |
| private DeviceService deviceService; |
| |
| // Test provider used during the tests |
| private TestProvider provider; |
| |
| // Meter manager |
| private MeterManager manager; |
| |
| // Meter provider registry |
| private MeterProviderRegistry registry; |
| |
| // Meter provider service |
| private MeterProviderService providerService; |
| |
| // Store under testing |
| private DistributedMeterStore meterStore; |
| |
| // Device ids used during the tests |
| private DeviceId did1 = did("1"); |
| private DeviceId did2 = did("2"); |
| |
| // Meter ids used during the tests |
| private MeterId mid1 = MeterId.meterId(1); |
| private MeterCellId cid0 = PiMeterCellId.ofIndirect(PiMeterId.of("foo"), 0L); |
| |
| // Bands used during the tests |
| private static Band b1 = DefaultBand.builder() |
| .ofType(Band.Type.DROP) |
| .withRate(500) |
| .build(); |
| |
| // Meters used during the tests |
| private Meter m1 = DefaultMeter.builder() |
| .forDevice(did1) |
| .fromApp(APP_ID) |
| .withId(mid1) |
| .withUnit(Meter.Unit.KB_PER_SEC) |
| .withBands(Collections.singletonList(b1)) |
| .build(); |
| private Meter m2 = DefaultMeter.builder() |
| .forDevice(did2) |
| .fromApp(APP_ID) |
| .withId(mid1) |
| .withUnit(Meter.Unit.KB_PER_SEC) |
| .withBands(Collections.singletonList(b1)) |
| .build(); |
| |
| private static Meter mProgrammable = DefaultMeter.builder() |
| .forDevice(PROGRAMMABLE_DID) |
| .fromApp(APP_ID) |
| .withId(MeterId.meterId(1)) |
| .withUnit(Meter.Unit.KB_PER_SEC) |
| .withBands(Collections.singletonList(b1)) |
| .build(); |
| private static Meter mProgrammable2 = DefaultMeter.builder() |
| .forDevice(PROGRAMMABLE_DID) |
| .fromApp(APP_ID) |
| .withId(MeterId.meterId(2)) |
| .withUnit(Meter.Unit.KB_PER_SEC) |
| .withBands(Collections.singletonList(b1)) |
| .build(); |
| |
| private static Meter mUserDefined = DefaultMeter.builder() |
| .forDevice(PROGRAMMABLE_DID) |
| .fromApp(APP_ID) |
| .withCellId(PiMeterCellId.ofIndirect(PiMeterId.of("foo"), 0L)) |
| .withUnit(Meter.Unit.KB_PER_SEC) |
| .withBands(Collections.singletonList(b1)) |
| .build(); |
| |
| // Meter requests used during the tests |
| private MeterRequest.Builder m1Request = DefaultMeterRequest.builder() |
| .forDevice(did1) |
| .fromApp(APP_ID) |
| .withUnit(Meter.Unit.KB_PER_SEC) |
| .withBands(Collections.singletonList(b1)); |
| private MeterRequest.Builder m2Request = DefaultMeterRequest.builder() |
| .forDevice(did2) |
| .fromApp(APP_ID) |
| .withUnit(Meter.Unit.KB_PER_SEC) |
| .withBands(Collections.singletonList(b1)); |
| |
| private MeterRequest.Builder mProgrammableRequest = DefaultMeterRequest.builder() |
| .forDevice(PROGRAMMABLE_DID) |
| .fromApp(APP_ID) |
| .withUnit(Meter.Unit.KB_PER_SEC) |
| .withBands(Collections.singletonList(b1)); |
| private MeterRequest.Builder mProgrammableRequest2 = DefaultMeterRequest.builder() |
| .forDevice(PROGRAMMABLE_DID) |
| .fromApp(APP_ID) |
| .withUnit(Meter.Unit.KB_PER_SEC) |
| .withBands(Collections.singletonList(b1)); |
| |
| private MeterRequest.Builder userDefinedRequest = DefaultMeterRequest.builder() |
| .forDevice(PROGRAMMABLE_DID) |
| .fromApp(APP_ID) |
| .withUnit(Meter.Unit.KB_PER_SEC) |
| .withBands(Collections.singletonList(b1)) |
| .withScope(MeterScope.of("foo")) |
| .withIndex(0L); |
| |
| // Meter features used during the tests |
| private MeterFeatures mef1 = DefaultMeterFeatures.builder().forDevice(did1) |
| .withMaxMeters(3L) |
| .withBandTypes(new HashSet<>()) |
| .withUnits(new HashSet<>()) |
| .hasStats(false) |
| .hasBurst(false) |
| .withMaxBands((byte) 0) |
| .withMaxColors((byte) 0) |
| .build(); |
| private MeterFeatures mef2 = DefaultMeterFeatures.builder().forDevice(did2) |
| .withMaxMeters(10L) |
| .withBandTypes(new HashSet<>()) |
| .withUnits(new HashSet<>()) |
| .hasStats(false) |
| .hasBurst(false) |
| .withMaxBands((byte) 0) |
| .withMaxColors((byte) 0) |
| .build(); |
| private MeterFeatures programmableMef1 = DefaultMeterFeatures.builder().forDevice(PROGRAMMABLE_DID) |
| .withStartIndex(1) |
| .withEndIndex(10L) |
| .withBandTypes(new HashSet<>()) |
| .withUnits(new HashSet<>()) |
| .hasStats(false) |
| .hasBurst(false) |
| .withMaxBands((byte) 0) |
| .withMaxColors((byte) 0) |
| .build(); |
| private MeterFeatures programmableMef2 = DefaultMeterFeatures.builder().forDevice(PROGRAMMABLE_DID) |
| .withStartIndex(0) |
| .withEndIndex(10L) |
| .withScope(MeterScope.of("foo")) |
| .withBandTypes(new HashSet<>()) |
| .withUnits(new HashSet<>()) |
| .hasStats(false) |
| .hasBurst(false) |
| .withMaxBands((byte) 0) |
| .withMaxColors((byte) 0) |
| .build(); |
| |
| private ComponentContext componentContext = EasyMock.createMock(ComponentContext.class); |
| |
| @Before |
| public void setup() { |
| //Init step for the deviceService |
| deviceService = new TestDeviceService(); |
| //Init step for the driver registry and driver service. |
| DriverRegistryManager driverRegistry = new DriverRegistryManager(); |
| driverService = new TestDriverManager(driverRegistry, deviceService, new NetworkConfigServiceAdapter()); |
| driverRegistry.addDriver(new DefaultDriver("foo", ImmutableList.of(), "", |
| "", "", |
| ImmutableMap.of(MeterProgrammable.class, |
| TestMeterProgrammable.class, MeterQuery.class, TestMeterQuery.class), |
| ImmutableMap.of())); |
| |
| // Init step for the store |
| meterStore = new DistributedMeterStore(); |
| // Let's initialize some internal services of the store |
| TestUtils.setField(meterStore, "storageService", new TestStorageService()); |
| TestUtils.setField(meterStore, "driverService", driverService); |
| |
| // Inject TestApplicationId into the DistributedMeterStore serializer |
| KryoNamespace.Builder testKryoBuilder = TestUtils.getField(meterStore, "APP_KRYO_BUILDER"); |
| testKryoBuilder.register(TestApplicationId.class); |
| Serializer testSerializer = Serializer.using(Lists.newArrayList(testKryoBuilder.build())); |
| TestUtils.setField(meterStore, "serializer", testSerializer); |
| |
| // Activate the store |
| meterStore.activate(); |
| // Init step for the manager |
| manager = new MeterManager(); |
| // Let's initialize some internal services of the manager |
| TestUtils.setField(manager, "store", meterStore); |
| injectEventDispatcher(manager, new TestEventDispatcher()); |
| manager.deviceService = deviceService; |
| manager.mastershipService = new TestMastershipService(); |
| manager.cfgService = new ComponentConfigAdapter(); |
| manager.clusterService = new TestClusterService(); |
| // Init the reference of the registry |
| registry = manager; |
| |
| manager.driverService = driverService; |
| |
| // Activate the manager |
| Dictionary<String, Object> cfgDict = new Hashtable<>(); |
| expect(componentContext.getProperties()).andReturn(cfgDict); |
| replay(componentContext); |
| manager.activate(componentContext); |
| |
| // Initialize the test provider |
| provider = new TestProvider(PID); |
| // Register the provider against the manager |
| providerService = registry.register(provider); |
| // Verify register |
| assertTrue("provider should be registered", |
| registry.getProviders().contains(provider.id())); |
| } |
| |
| @After |
| public void tearDown() { |
| // Unregister provider |
| registry.unregister(provider); |
| // Verify unregister |
| assertFalse("provider should not be registered", |
| registry.getProviders().contains(provider.id())); |
| // Deactivate manager |
| manager.deactivate(); |
| // Remove event dispatcher |
| injectEventDispatcher(manager, null); |
| // Deactivate store |
| meterStore.deactivate(); |
| } |
| |
| // Store meter features for all the devices |
| private void initMeterStore() { |
| meterStore.storeMeterFeatures(mef1); |
| meterStore.storeMeterFeatures(mef2); |
| meterStore.storeMeterFeatures(programmableMef1); |
| meterStore.storeMeterFeatures(programmableMef2); |
| } |
| |
| // Emulate metrics coming from the dataplane |
| private void pushMetrics(MeterOperation.Type type, Meter meter) { |
| if (type == MeterOperation.Type.ADD) { |
| ((DefaultMeter) meter).setState(MeterState.ADDED); |
| providerService.pushMeterMetrics(meter.deviceId(), Collections.singletonList(meter)); |
| } else { |
| providerService.pushMeterMetrics(meter.deviceId(), Collections.emptyList()); |
| } |
| } |
| |
| /** |
| * Verify enabling user defined index mode in meter service. |
| */ |
| @Test |
| public void testEnableUserDefinedIndex() { |
| reset(componentContext); |
| Dictionary<String, Object> cfgDict = new Hashtable<>(); |
| cfgDict.put(MM_USER_DEFINED_INDEX, true); |
| expect(componentContext.getProperties()).andReturn(cfgDict); |
| replay(componentContext); |
| |
| Object returnValue = TestUtils.callMethod(manager, "readComponentConfiguration", |
| ComponentContext.class, componentContext); |
| assertNull(returnValue); |
| assertTrue(manager.userDefinedIndex); |
| } |
| |
| /** |
| * Verify disabling user defined index mode in meter service. |
| */ |
| @Test |
| public void testDisableUserDefinedIndex() { |
| testEnableUserDefinedIndex(); |
| |
| reset(componentContext); |
| Dictionary<String, Object> cfgDict = new Hashtable<>(); |
| cfgDict.put(MM_USER_DEFINED_INDEX, false); |
| expect(componentContext.getProperties()).andReturn(cfgDict); |
| replay(componentContext); |
| |
| Object returnValue = TestUtils.callMethod(manager, "readComponentConfiguration", |
| ComponentContext.class, componentContext); |
| assertNull(returnValue); |
| assertFalse(manager.userDefinedIndex); |
| } |
| |
| /** |
| * Test add meter. |
| */ |
| @Test |
| public void testAdd() { |
| // Init store |
| initMeterStore(); |
| // Submit meter request |
| manager.submit(m1Request.add()); |
| // Verify add |
| assertEquals("The meter was not added", 1, manager.getAllMeters().size()); |
| assertEquals("The meter was not added", 1, manager.getMeters(did1).size()); |
| // Get Meter |
| Meter installingMeter = manager.getMeter(did1, mid1); |
| // Verify add of installingMeter and pending add state |
| assertThat(installingMeter, is(m1)); |
| // Verify pending add state |
| assertThat(installingMeter.state(), is(MeterState.PENDING_ADD)); |
| // Let's simulate a working data-plane |
| pushMetrics(MeterOperation.Type.ADD, installingMeter); |
| // Get meter |
| Meter installedMeter = manager.getMeter(did1, mid1); |
| // Verify installation |
| assertThat(installedMeter.state(), is(MeterState.ADDED)); |
| assertEquals("The meter was not installed", 1, manager.getAllMeters().size()); |
| assertEquals("The meter was not installed", 1, manager.getMeters(did1).size()); |
| } |
| |
| /** |
| * Test add meter with user defined index. |
| */ |
| @Test |
| public void testAddWithUserDefinedIndex() { |
| initMeterStore(); |
| testEnableUserDefinedIndex(); |
| |
| manager.submit(userDefinedRequest.add()); |
| assertEquals("The meter was not added", 1, manager.getAllMeters().size()); |
| assertEquals("The meter was not added", 1, manager.getMeters(PROGRAMMABLE_DID).size()); |
| Meter installingMeter = manager.getMeter(PROGRAMMABLE_DID, cid0); |
| assertThat(installingMeter, is(mUserDefined)); |
| assertThat(installingMeter.state(), is(MeterState.PENDING_ADD)); |
| |
| pushMetrics(MeterOperation.Type.ADD, installingMeter); |
| Meter installedMeter = manager.getMeter(PROGRAMMABLE_DID, cid0); |
| assertThat(installedMeter.state(), is(MeterState.ADDED)); |
| assertEquals("The meter was not installed", 1, manager.getAllMeters().size()); |
| assertEquals("The meter was not installed", 1, manager.getMeters(PROGRAMMABLE_DID).size()); |
| } |
| |
| /** |
| * Test wrong add meter. |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void testWrongAdd() { |
| initMeterStore(); |
| |
| manager.submit(userDefinedRequest.add()); |
| } |
| |
| /** |
| * Test wrong add meter in user defined index mode. |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void testWrongAddInUserDefinedIndexMode() { |
| initMeterStore(); |
| testEnableUserDefinedIndex(); |
| |
| manager.submit(m1Request.add()); |
| } |
| |
| /** |
| * Test remove meter. |
| */ |
| @Test |
| public void testRemove() { |
| // Init store |
| initMeterStore(); |
| // Submit meter request |
| manager.submit(m1Request.add()); |
| // Withdraw meter |
| manager.withdraw(m1Request.remove(), m1.id()); |
| // Get Meter |
| Meter withdrawingMeter = manager.getMeter(did1, mid1); |
| // Verify withdrawing |
| assertThat(withdrawingMeter.state(), is(MeterState.PENDING_REMOVE)); |
| assertEquals("The meter was not withdrawn", 1, manager.getAllMeters().size()); |
| assertEquals("The meter was not withdrawn", 1, manager.getMeters(did1).size()); |
| // Let's simulate a working data-plane |
| pushMetrics(MeterOperation.Type.REMOVE, withdrawingMeter); |
| // Verify withdrawn |
| assertNull(manager.getMeter(did1, mid1)); |
| assertEquals("The meter was not removed", 0, manager.getAllMeters().size()); |
| assertEquals("The meter was not removed", 0, manager.getMeters(did1).size()); |
| } |
| |
| /** |
| * Test remove meter in user defined index mode. |
| */ |
| @Test |
| public void testRemoveInUserDefinedIndexMode() { |
| initMeterStore(); |
| testEnableUserDefinedIndex(); |
| |
| manager.submit(userDefinedRequest.add()); |
| |
| manager.withdraw(userDefinedRequest.remove(), cid0); |
| Meter withdrawingMeter = manager.getMeter(PROGRAMMABLE_DID, cid0); |
| assertThat(withdrawingMeter.state(), is(MeterState.PENDING_REMOVE)); |
| assertEquals("The meter was not withdrawn", 1, manager.getAllMeters().size()); |
| assertEquals("The meter was not withdrawn", 1, manager.getMeters(PROGRAMMABLE_DID).size()); |
| |
| pushMetrics(MeterOperation.Type.REMOVE, withdrawingMeter); |
| assertNull(manager.getMeter(PROGRAMMABLE_DID, cid0)); |
| assertEquals("The meter was not removed", 0, manager.getAllMeters().size()); |
| assertEquals("The meter was not removed", 0, manager.getMeters(PROGRAMMABLE_DID).size()); |
| } |
| |
| /** |
| * Test add multiple devices. |
| */ |
| @Test |
| public void testAddMultipleDevice() { |
| // Init store |
| initMeterStore(); |
| // Submit meter 1 |
| manager.submit(m1Request.add()); |
| // Submit meter 2 |
| manager.submit(m2Request.add()); |
| // Verify add |
| assertEquals("The meter was not added", 2, manager.getAllMeters().size()); |
| assertEquals("The meter was not added", 1, manager.getMeters(did1).size()); |
| assertEquals("The meter was not added", 1, manager.getMeters(did2).size()); |
| // Get Meters |
| Meter installingMeter1 = manager.getMeter(did1, mid1); |
| Meter installingMeter2 = manager.getMeter(did2, mid1); |
| // Verify add of installingMeter |
| assertThat(installingMeter1, is(m1)); |
| assertThat(installingMeter2, is(m2)); |
| // Verify pending add state |
| assertThat(installingMeter1.state(), is(MeterState.PENDING_ADD)); |
| assertThat(installingMeter2.state(), is(MeterState.PENDING_ADD)); |
| // Let's simulate a working data-plane |
| pushMetrics(MeterOperation.Type.ADD, installingMeter1); |
| pushMetrics(MeterOperation.Type.ADD, installingMeter2); |
| // Get meter |
| Meter installedMeter1 = manager.getMeter(did1, mid1); |
| Meter installedMeter2 = manager.getMeter(did2, mid1); |
| // Verify installation |
| assertThat(installedMeter1.state(), is(MeterState.ADDED)); |
| assertThat(installedMeter2.state(), is(MeterState.ADDED)); |
| assertEquals("The meter was not installed", 2, manager.getAllMeters().size()); |
| assertEquals("The meter was not installed", 1, manager.getMeters(did1).size()); |
| assertEquals("The meter was not installed", 1, manager.getMeters(did2).size()); |
| } |
| |
| /** |
| * Test remove multiple devices. |
| */ |
| @Test |
| public void testRemoveMultipleDevice() { |
| // Init store |
| initMeterStore(); |
| // Submit meter 1 |
| manager.submit(m1Request.add()); |
| // Submit meter 2 |
| manager.submit(m2Request.add()); |
| // Withdraw meter |
| manager.withdraw(m1Request.remove(), m1.id()); |
| // Withdraw meter |
| manager.withdraw(m2Request.remove(), m2.id()); |
| // Get Meters |
| Meter withdrawingMeter1 = manager.getMeter(did1, mid1); |
| Meter withdrawingMeter2 = manager.getMeter(did2, mid1); |
| // Verify withdrawing |
| assertThat(withdrawingMeter1.state(), is(MeterState.PENDING_REMOVE)); |
| assertThat(withdrawingMeter2.state(), is(MeterState.PENDING_REMOVE)); |
| assertEquals("The meter was not withdrawn", 2, manager.getAllMeters().size()); |
| assertEquals("The meter was not withdrawn", 1, manager.getMeters(did1).size()); |
| assertEquals("The meter was not withdrawn", 1, manager.getMeters(did2).size()); |
| // Let's simulate a working data-plane |
| pushMetrics(MeterOperation.Type.REMOVE, withdrawingMeter1); |
| pushMetrics(MeterOperation.Type.REMOVE, withdrawingMeter2); |
| // Verify withdrawn |
| assertNull(manager.getMeter(did1, mid1)); |
| assertNull(manager.getMeter(did2, mid1)); |
| assertEquals("The meter was not removed", 0, manager.getAllMeters().size()); |
| assertEquals("The meter was not removed", 0, manager.getMeters(did1).size()); |
| assertEquals("The meter was not removed", 0, manager.getMeters(did2).size()); |
| } |
| |
| /** |
| * Test purge meter. |
| */ |
| @Test |
| public void testPurge() { |
| // Init store |
| initMeterStore(); |
| // Submit meter request |
| manager.submit(m1Request.add()); |
| // Verify submit |
| Meter submittingMeter = manager.getMeter(did1, mid1); |
| assertThat(submittingMeter.state(), is(MeterState.PENDING_ADD)); |
| assertEquals("The meter was not added", 1, manager.getAllMeters().size()); |
| assertEquals("The meter was not added", 1, manager.getMeters(did1).size()); |
| // Purge the meters |
| manager.purgeMeters(did1); |
| // Verify purge |
| assertNull(manager.getMeter(did1, mid1)); |
| assertEquals("The meter was not purged", 0, manager.getAllMeters().size()); |
| assertEquals("The meter was not purged", 0, manager.getMeters(did1).size()); |
| } |
| |
| /** |
| * Test submit for programmable devices. |
| */ |
| @Test |
| public void testAddFromMeterProgrammable() { |
| // Init store |
| initMeterStore(); |
| manager.submit(mProgrammableRequest.add()); |
| TestTools.assertAfter(500, () -> { |
| assertEquals("The meter was not added", 1, manager.getAllMeters().size()); |
| assertThat(manager.getMeter(PROGRAMMABLE_DID, MeterId.meterId(1)), is(mProgrammable)); |
| }); |
| } |
| |
| /** |
| * Test batch submission for meter programmable. |
| */ |
| @Test |
| public void testAddBatchFromMeterProgrammable() { |
| // Init store |
| initMeterStore(); |
| List<MeterOperation> operations = ImmutableList.of(new MeterOperation(mProgrammable, MeterOperation.Type.ADD)); |
| manager.defaultProvider().performMeterOperation(PROGRAMMABLE_DID, new MeterOperations(operations)); |
| TestTools.assertAfter(500, () -> { |
| assertEquals("The meter was not added", 1, meterOperations.size()); |
| assertEquals("Wrong Meter Operation", meterOperations.get(0).meter().id(), mProgrammable.id()); |
| }); |
| |
| } |
| |
| /** |
| * Verify get from meter programmable. |
| */ |
| @Test |
| public void testGetFromMeterProgrammable() { |
| // Init store |
| initMeterStore(); |
| MeterDriverProvider fallback = (MeterDriverProvider) manager.defaultProvider(); |
| testAddFromMeterProgrammable(); |
| fallback.init(manager.deviceService, fallback.meterProviderService, manager.mastershipService, 1); |
| TestTools.assertAfter(2000, () -> { |
| assertEquals("The meter was not added", 1, manager.getAllMeters().size()); |
| Meter m = manager.getMeters(PROGRAMMABLE_DID).iterator().next(); |
| assertEquals("incorrect state", MeterState.ADDED, m.state()); |
| }); |
| } |
| |
| /** |
| * Verify installation of missing meters when using meter programmable devices. |
| */ |
| @Test |
| public void testMissingFromMeterProgrammable() { |
| // Workaround when running the tests all together |
| meterOperations.clear(); |
| testGetFromMeterProgrammable(); |
| |
| assertThat(meterOperations.size(), is(1)); |
| manager.submit(mProgrammableRequest2.add()); |
| TestTools.assertAfter(500, () -> { |
| assertEquals("The meter was not added", 2, manager.getAllMeters().size()); |
| assertThat(manager.getMeter(PROGRAMMABLE_DID, MeterId.meterId(2)), is(mProgrammable2)); |
| assertThat(meterOperations.size(), is(2)); |
| assertThat(meterOperations.get(meterOperations.size() - 1), is(new MeterOperation(mProgrammable2, |
| MeterOperation.Type.ADD))); |
| }); |
| |
| TestTools.assertAfter(2000, () -> { |
| assertEquals("The meter was not added", 2, manager.getAllMeters().size()); |
| Meter pendingMeter = manager.getMeter(PROGRAMMABLE_DID, MeterId.meterId(2)); |
| assertThat(pendingMeter, is(mProgrammable2)); |
| assertEquals("incorrect state", MeterState.PENDING_ADD, pendingMeter.state()); |
| assertThat(meterOperations.size(), is(3)); |
| assertThat(meterOperations.get(meterOperations.size() - 1), is(new MeterOperation(mProgrammable2, |
| MeterOperation.Type.ADD))); |
| }); |
| } |
| |
| /** |
| * Verify removal of unknown meters when using meter programmable devices. |
| */ |
| @Test |
| public void testUnknownFromMeterProgrammable() { |
| meterOperations.clear(); |
| testGetFromMeterProgrammable(); |
| TestMeterProgrammable.unknownMeter = true; |
| |
| assertThat(meterOperations.size(), is(1)); |
| TestTools.assertAfter(2000, () -> { |
| assertEquals("The meter was not added", 1, manager.getAllMeters().size()); |
| Meter pendingMeter = manager.getMeter(PROGRAMMABLE_DID, MeterId.meterId(2)); |
| assertNull(pendingMeter); |
| assertThat(meterOperations.size(), is(2)); |
| assertThat(meterOperations.get(meterOperations.size() - 1), is(new MeterOperation(mProgrammable2, |
| MeterOperation.Type.REMOVE))); |
| }); |
| } |
| |
| /** |
| * Verify removal of meters when using meter programmable devices. |
| */ |
| @Test |
| public void testRemoveFromMeterProgrammable() { |
| testEnableUserDefinedIndex(); |
| initMeterStore(); |
| MeterDriverProvider fallback = (MeterDriverProvider) manager.defaultProvider(); |
| fallback.init(manager.deviceService, fallback.meterProviderService, manager.mastershipService, 1); |
| |
| manager.submit(mProgrammableRequest2.withIndex(2L).add()); |
| TestTools.assertAfter(500, () -> { |
| assertEquals("The meter was not added", 1, manager.getAllMeters().size()); |
| Meter pendingMeter = manager.getMeter(PROGRAMMABLE_DID, MeterId.meterId(2)); |
| assertThat(pendingMeter, is(mProgrammable2)); |
| assertEquals("incorrect state", MeterState.PENDING_ADD, pendingMeter.state()); |
| }); |
| |
| manager.withdraw(mProgrammableRequest2.remove(), MeterId.meterId(2)); |
| TestTools.assertAfter(500, () -> { |
| assertEquals("The meter was not withdrawn", 1, manager.getAllMeters().size()); |
| Meter pendingMeter = manager.getMeter(PROGRAMMABLE_DID, MeterId.meterId(2)); |
| assertThat(pendingMeter, is(mProgrammable2)); |
| assertEquals("incorrect state", MeterState.PENDING_REMOVE, pendingMeter.state()); |
| }); |
| |
| TestTools.assertAfter(2000, () -> { |
| assertEquals("The meter was not removed", 0, manager.getAllMeters().size()); |
| Meter pendingMeter = manager.getMeter(PROGRAMMABLE_DID, MeterId.meterId(2)); |
| assertNull(pendingMeter); |
| }); |
| } |
| |
| // Test cluster service |
| private final class TestClusterService extends ClusterServiceAdapter { |
| |
| private ControllerNode local = new DefaultControllerNode(NID_LOCAL, LOCALHOST); |
| |
| @Override |
| public ControllerNode getLocalNode() { |
| return local; |
| } |
| |
| @Override |
| public Set<ControllerNode> getNodes() { |
| return Sets.newHashSet(); |
| } |
| |
| } |
| |
| private static class TestDeviceService extends DeviceServiceAdapter { |
| @Override |
| public int getDeviceCount() { |
| return 1; |
| } |
| |
| @Override |
| public Iterable<Device> getDevices() { |
| return ImmutableList.of(PROGRAMMABLE_DEV); |
| } |
| |
| @Override |
| public Iterable<Device> getAvailableDevices() { |
| return getDevices(); |
| } |
| |
| @Override |
| public Device getDevice(DeviceId deviceId) { |
| return PROGRAMMABLE_DEV; |
| } |
| } |
| |
| private class TestDriverManager extends DriverManager { |
| TestDriverManager(DriverRegistry registry, DeviceService deviceService, |
| NetworkConfigService networkConfigService) { |
| this.registry = registry; |
| this.deviceService = deviceService; |
| this.networkConfigService = networkConfigService; |
| this.pipeconfService = new PiPipeconfServiceAdapter(); |
| activate(); |
| } |
| } |
| |
| public static class TestMeterQuery extends AbstractHandlerBehaviour |
| implements MeterQuery { |
| private static final long MAX_METER = 0x00000FFF; |
| |
| @Override |
| public long getMaxMeters() { |
| return MAX_METER; |
| } |
| } |
| |
| private static List<MeterOperation> meterOperations = new ArrayList<>(); |
| |
| public static class TestMeterProgrammable extends AbstractHandlerBehaviour |
| implements MeterProgrammable { |
| |
| private static boolean unknownMeter; |
| |
| @Override |
| public CompletableFuture<Boolean> performMeterOperation(MeterOperation meterOp) { |
| return CompletableFuture.completedFuture(meterOperations.add(meterOp)); |
| } |
| |
| @Override |
| public CompletableFuture<Collection<Meter>> getMeters() { |
| //ADD METER |
| Collection<Meter> meters = Lists.newArrayList(); |
| DefaultMeter mProgrammableAdded = (DefaultMeter) mProgrammable; |
| mProgrammableAdded.setState(MeterState.ADDED); |
| meters.add(mProgrammableAdded); |
| if (unknownMeter) { |
| DefaultMeter mProgrammable2Added = (DefaultMeter) mProgrammable2; |
| mProgrammable2Added.setState(MeterState.ADDED); |
| meters.add(mProgrammable2Added); |
| } |
| return CompletableFuture.completedFuture(meters); |
| } |
| |
| @Override |
| public CompletableFuture<Collection<MeterFeatures>> getMeterFeatures() { |
| //Currently unused. |
| return CompletableFuture.completedFuture(Collections.emptySet()); |
| } |
| } |
| |
| private class TestProvider extends AbstractProvider implements MeterProvider { |
| |
| protected TestProvider(ProviderId id) { |
| super(PID); |
| } |
| |
| @Override |
| public void performMeterOperation(DeviceId deviceId, MeterOperations meterOps) { |
| //Currently unused. |
| } |
| |
| @Override |
| public void performMeterOperation(DeviceId deviceId, MeterOperation meterOp) { |
| //Currently unused |
| } |
| } |
| |
| // Test mastership service |
| private final class TestMastershipService extends MastershipServiceAdapter { |
| @Override |
| public NodeId getMasterFor(DeviceId deviceId) { |
| return NID_LOCAL; |
| } |
| |
| @Override |
| public MastershipRole getLocalRole(DeviceId deviceId) { |
| return MastershipRole.MASTER; |
| } |
| } |
| |
| } |