Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 1 | /* |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 2 | * Copyright 2021-present Open Networking Foundation |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 16 | |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 17 | package org.opencord.olt.impl; |
| 18 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 19 | import com.google.common.collect.ImmutableMap; |
Jonathan Hart | 4f178fa | 2020-02-03 10:46:01 -0800 | [diff] [blame] | 20 | import org.onlab.util.KryoNamespace; |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 21 | import org.onlab.util.Tools; |
| 22 | import org.onosproject.cfg.ComponentConfigService; |
| 23 | import org.onosproject.core.ApplicationId; |
| 24 | import org.onosproject.core.CoreService; |
| 25 | import org.onosproject.net.DeviceId; |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 26 | import org.onosproject.net.meter.Band; |
| 27 | import org.onosproject.net.meter.DefaultBand; |
| 28 | import org.onosproject.net.meter.DefaultMeterRequest; |
| 29 | import org.onosproject.net.meter.Meter; |
| 30 | import org.onosproject.net.meter.MeterContext; |
| 31 | import org.onosproject.net.meter.MeterEvent; |
| 32 | import org.onosproject.net.meter.MeterFailReason; |
| 33 | import org.onosproject.net.meter.MeterId; |
| 34 | import org.onosproject.net.meter.MeterKey; |
| 35 | import org.onosproject.net.meter.MeterListener; |
| 36 | import org.onosproject.net.meter.MeterRequest; |
| 37 | import org.onosproject.net.meter.MeterService; |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 38 | import org.onosproject.net.meter.MeterState; |
Jonathan Hart | 4f178fa | 2020-02-03 10:46:01 -0800 | [diff] [blame] | 39 | import org.onosproject.store.serializers.KryoNamespaces; |
Jonathan Hart | 4f178fa | 2020-02-03 10:46:01 -0800 | [diff] [blame] | 40 | import org.onosproject.store.service.Serializer; |
| 41 | import org.onosproject.store.service.StorageService; |
Gustavo Silva | 29fb20e | 2022-05-26 09:59:54 -0300 | [diff] [blame] | 42 | import org.opencord.olt.MeterData; |
| 43 | import org.opencord.olt.OltDeviceServiceInterface; |
| 44 | import org.opencord.olt.OltMeterServiceInterface; |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 45 | import org.opencord.sadis.BandwidthProfileInformation; |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 46 | import org.opencord.sadis.BaseInformationService; |
| 47 | import org.opencord.sadis.SadisService; |
| 48 | import org.opencord.sadis.SubscriberAndDeviceInformation; |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 49 | import org.osgi.service.component.ComponentContext; |
| 50 | import org.osgi.service.component.annotations.Activate; |
| 51 | import org.osgi.service.component.annotations.Component; |
| 52 | import org.osgi.service.component.annotations.Deactivate; |
| 53 | import org.osgi.service.component.annotations.Modified; |
| 54 | import org.osgi.service.component.annotations.Reference; |
| 55 | import org.osgi.service.component.annotations.ReferenceCardinality; |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 56 | import org.osgi.service.component.annotations.ReferencePolicy; |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 57 | import org.slf4j.Logger; |
| 58 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 59 | import java.util.ArrayList; |
| 60 | import java.util.Dictionary; |
| 61 | import java.util.HashMap; |
| 62 | import java.util.Iterator; |
| 63 | import java.util.LinkedList; |
| 64 | import java.util.List; |
| 65 | import java.util.Map; |
| 66 | import java.util.Properties; |
| 67 | import java.util.concurrent.CompletableFuture; |
| 68 | import java.util.concurrent.ExecutorService; |
| 69 | import java.util.concurrent.Executors; |
| 70 | import java.util.concurrent.atomic.AtomicBoolean; |
| 71 | import java.util.concurrent.atomic.AtomicInteger; |
| 72 | import java.util.concurrent.locks.Lock; |
| 73 | import java.util.concurrent.locks.ReentrantReadWriteLock; |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 74 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 75 | import static com.google.common.base.Strings.isNullOrEmpty; |
| 76 | import static org.onlab.util.Tools.get; |
| 77 | import static org.onlab.util.Tools.groupedThreads; |
| 78 | import static org.opencord.olt.impl.OsgiPropertyConstants.*; |
| 79 | import static org.slf4j.LoggerFactory.getLogger; |
| 80 | |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 81 | @Component(immediate = true, property = { |
| 82 | DELETE_METERS + ":Boolean=" + DELETE_METERS_DEFAULT, |
Andrea Campanella | 7e1eb71 | 2021-09-22 14:27:35 +0200 | [diff] [blame] | 83 | ZERO_REFERENCE_METER_COUNT + ":Integer=" + ZERO_REFERENCE_METER_COUNT_DEFAULT, |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 84 | }) |
| 85 | public class OltMeterService implements OltMeterServiceInterface { |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 86 | |
| 87 | @Reference(cardinality = ReferenceCardinality.MANDATORY) |
| 88 | protected CoreService coreService; |
| 89 | |
| 90 | @Reference(cardinality = ReferenceCardinality.MANDATORY) |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 91 | protected ComponentConfigService cfgService; |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 92 | |
Jonathan Hart | 4f178fa | 2020-02-03 10:46:01 -0800 | [diff] [blame] | 93 | @Reference(cardinality = ReferenceCardinality.MANDATORY) |
| 94 | protected StorageService storageService; |
| 95 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 96 | @Reference(cardinality = ReferenceCardinality.OPTIONAL, |
| 97 | bind = "bindSadisService", |
| 98 | unbind = "unbindSadisService", |
| 99 | policy = ReferencePolicy.DYNAMIC) |
| 100 | protected volatile SadisService sadisService; |
Andrea Campanella | 7e1eb71 | 2021-09-22 14:27:35 +0200 | [diff] [blame] | 101 | |
| 102 | @Reference(cardinality = ReferenceCardinality.MANDATORY) |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 103 | protected MeterService meterService; |
Andrea Campanella | 7e1eb71 | 2021-09-22 14:27:35 +0200 | [diff] [blame] | 104 | |
| 105 | @Reference(cardinality = ReferenceCardinality.MANDATORY) |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 106 | protected OltDeviceServiceInterface oltDeviceService; |
Andrea Campanella | 7e1eb71 | 2021-09-22 14:27:35 +0200 | [diff] [blame] | 107 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 108 | private final Logger log = getLogger(getClass()); |
| 109 | protected BaseInformationService<BandwidthProfileInformation> bpService; |
| 110 | private ApplicationId appId; |
| 111 | private static final String APP_NAME = "org.opencord.olt"; |
| 112 | private final ReentrantReadWriteLock programmedMeterLock = new ReentrantReadWriteLock(); |
| 113 | private final Lock programmedMeterWriteLock = programmedMeterLock.writeLock(); |
| 114 | private final Lock programmedMeterReadLock = programmedMeterLock.readLock(); |
| 115 | |
| 116 | /** |
| 117 | * Programmed Meters status map. |
| 118 | * Keeps track of which meter is programmed on which device for which BandwidthProfile. |
| 119 | * The String key is the BandwidthProfile |
| 120 | */ |
| 121 | protected Map<DeviceId, Map<String, MeterData>> programmedMeters; |
| 122 | |
| 123 | private final MeterListener meterListener = new InternalMeterListener(); |
| 124 | protected ExecutorService pendingRemovalMetersExecutor = |
| 125 | Executors.newFixedThreadPool(5, groupedThreads("onos/olt", |
| 126 | "pending-removal-meters-%d", log)); |
| 127 | |
| 128 | /** |
| 129 | * Map that contains a list of meters that needs to be removed. |
| 130 | * We wait to get 3 METER_REFERENCE_COUNT_ZERO events before removing the meter |
| 131 | * so that we're sure no flow is referencing it. |
| 132 | */ |
| 133 | protected Map<DeviceId, Map<MeterKey, AtomicInteger>> pendingRemoveMeters; |
| 134 | |
| 135 | /** |
| 136 | * Number of consecutive meter events with empty reference count |
| 137 | * after which a meter gets removed from the device. |
| 138 | */ |
| 139 | protected int zeroReferenceMeterCount = 3; |
Andrea Campanella | 7e1eb71 | 2021-09-22 14:27:35 +0200 | [diff] [blame] | 140 | |
Saurav Das | f62cea8 | 2020-08-26 17:43:04 -0700 | [diff] [blame] | 141 | /** |
| 142 | * Delete meters when reference count drops to zero. |
| 143 | */ |
| 144 | protected boolean deleteMeters = DELETE_METERS_DEFAULT; |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 145 | |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 146 | @Activate |
| 147 | public void activate(ComponentContext context) { |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 148 | appId = coreService.registerApplication(APP_NAME); |
Jonathan Hart | 4f178fa | 2020-02-03 10:46:01 -0800 | [diff] [blame] | 149 | modified(context); |
Jonathan Hart | 4f178fa | 2020-02-03 10:46:01 -0800 | [diff] [blame] | 150 | KryoNamespace serializer = KryoNamespace.newBuilder() |
| 151 | .register(KryoNamespaces.API) |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 152 | .register(List.class) |
| 153 | .register(MeterData.class) |
| 154 | .register(MeterState.class) |
Jonathan Hart | 4f178fa | 2020-02-03 10:46:01 -0800 | [diff] [blame] | 155 | .register(MeterKey.class) |
| 156 | .build(); |
| 157 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 158 | programmedMeters = storageService.<DeviceId, Map<String, MeterData>>consistentMapBuilder() |
| 159 | .withName("volt-programmed-meters") |
Ilayda Ozdemir | 90a9362 | 2021-02-25 09:40:58 +0000 | [diff] [blame] | 160 | .withSerializer(Serializer.using(serializer)) |
| 161 | .withApplicationId(appId) |
| 162 | .build().asJavaMap(); |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 163 | |
Ilayda Ozdemir | 90a9362 | 2021-02-25 09:40:58 +0000 | [diff] [blame] | 164 | pendingRemoveMeters = storageService.<DeviceId, Map<MeterKey, AtomicInteger>>consistentMapBuilder() |
| 165 | .withName("volt-pending-remove-meters") |
| 166 | .withSerializer(Serializer.using(serializer)) |
| 167 | .withApplicationId(appId) |
| 168 | .build().asJavaMap(); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 169 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 170 | cfgService.registerProperties(getClass()); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 171 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 172 | meterService.addListener(meterListener); |
| 173 | |
| 174 | log.info("Started"); |
| 175 | } |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 176 | |
| 177 | @Modified |
| 178 | public void modified(ComponentContext context) { |
| 179 | Dictionary<?, ?> properties = context != null ? context.getProperties() : new Properties(); |
| 180 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 181 | Boolean d = Tools.isPropertyEnabled(properties, DELETE_METERS); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 182 | if (d != null) { |
| 183 | deleteMeters = d; |
| 184 | } |
Andrea Campanella | 7e1eb71 | 2021-09-22 14:27:35 +0200 | [diff] [blame] | 185 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 186 | String zeroCount = get(properties, ZERO_REFERENCE_METER_COUNT); |
| 187 | int oldSubscriberProcessingThreads = zeroReferenceMeterCount; |
| 188 | zeroReferenceMeterCount = isNullOrEmpty(zeroCount) ? |
| 189 | oldSubscriberProcessingThreads : Integer.parseInt(zeroCount.trim()); |
Andrea Campanella | 7e1eb71 | 2021-09-22 14:27:35 +0200 | [diff] [blame] | 190 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 191 | log.info("Modified. Values = deleteMeters: {}, zeroReferenceMeterCount: {}", |
| 192 | deleteMeters, zeroReferenceMeterCount); |
| 193 | } |
| 194 | |
| 195 | @Deactivate |
| 196 | public void deactivate(ComponentContext context) { |
| 197 | cfgService.unregisterProperties(getClass(), false); |
| 198 | meterService.removeListener(meterListener); |
| 199 | log.info("Stopped"); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 200 | } |
| 201 | |
| 202 | @Override |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 203 | public Map<DeviceId, Map<String, MeterData>> getProgrammedMeters() { |
| 204 | try { |
| 205 | programmedMeterReadLock.lock(); |
| 206 | return ImmutableMap.copyOf(programmedMeters); |
| 207 | } finally { |
| 208 | programmedMeterReadLock.unlock(); |
| 209 | } |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 210 | } |
| 211 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 212 | /** |
| 213 | * Will create a meter if needed and return true once available. |
| 214 | * |
| 215 | * @param deviceId DeviceId |
| 216 | * @param bandwidthProfile Bandwidth Profile Id |
| 217 | * @return true |
| 218 | */ |
| 219 | @Override |
| 220 | public synchronized boolean createMeter(DeviceId deviceId, String bandwidthProfile) { |
| 221 | |
| 222 | // NOTE it is possible that hasMeterByBandwidthProfile returns false has the meter is in PENDING_ADD |
| 223 | // then a different thread changes the meter to ADDED |
| 224 | // and thus hasPendingMeterByBandwidthProfile return false as well and we install the meter a second time |
| 225 | // this causes an inconsistency between the existing meter and meterId stored in the map |
| 226 | |
| 227 | if (!hasMeterByBandwidthProfile(deviceId, bandwidthProfile)) { |
| 228 | // NOTE this is at trace level as it's constantly called by the queue processor |
| 229 | if (log.isTraceEnabled()) { |
| 230 | log.trace("Missing meter for BandwidthProfile {} on device {}", bandwidthProfile, deviceId); |
| 231 | } |
| 232 | |
| 233 | if (!hasPendingMeterByBandwidthProfile(deviceId, bandwidthProfile)) { |
| 234 | createMeterForBp(deviceId, bandwidthProfile); |
| 235 | } |
| 236 | if (log.isTraceEnabled()) { |
| 237 | log.trace("Meter is not yet available for {} on device {}", |
| 238 | bandwidthProfile, deviceId); |
| 239 | } |
| 240 | return false; |
| 241 | } |
| 242 | log.debug("Meter found for BandwidthProfile {} on device {}", bandwidthProfile, deviceId); |
| 243 | return true; |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | @Override |
Matteo Scandolo | 88df8ae | 2021-11-23 13:12:29 -0800 | [diff] [blame] | 247 | public boolean createMeters(DeviceId deviceId, SubscriberAndDeviceInformation si, String multicastServiceName) { |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 248 | // Each UniTagInformation has up to 4 meters, |
| 249 | // check and/or create all of them |
| 250 | AtomicBoolean waitingOnMeter = new AtomicBoolean(); |
| 251 | waitingOnMeter.set(false); |
| 252 | Map<String, List<String>> pendingMeters = new HashMap<>(); |
| 253 | si.uniTagList().forEach(uniTagInfo -> { |
| 254 | String serviceName = uniTagInfo.getServiceName(); |
Matteo Scandolo | 88df8ae | 2021-11-23 13:12:29 -0800 | [diff] [blame] | 255 | |
| 256 | if (multicastServiceName.equals(uniTagInfo.getServiceName())) { |
| 257 | log.debug("This is the multicast service ({}) for subscriber {} on {}, " + |
| 258 | "meters are not needed", |
| 259 | uniTagInfo.getServiceName(), si.id(), deviceId); |
| 260 | return; |
| 261 | } |
| 262 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 263 | pendingMeters.put(serviceName, new LinkedList<>()); |
| 264 | String usBp = uniTagInfo.getUpstreamBandwidthProfile(); |
| 265 | String dsBp = uniTagInfo.getDownstreamBandwidthProfile(); |
| 266 | String oltUBp = uniTagInfo.getDownstreamOltBandwidthProfile(); |
| 267 | String oltDsBp = uniTagInfo.getUpstreamOltBandwidthProfile(); |
| 268 | if (!createMeter(deviceId, usBp)) { |
| 269 | pendingMeters.get(serviceName).add(usBp); |
| 270 | waitingOnMeter.set(true); |
| 271 | } |
| 272 | if (!createMeter(deviceId, dsBp)) { |
| 273 | pendingMeters.get(serviceName).add(usBp); |
| 274 | waitingOnMeter.set(true); |
| 275 | } |
| 276 | if (!createMeter(deviceId, oltUBp)) { |
| 277 | pendingMeters.get(serviceName).add(usBp); |
| 278 | waitingOnMeter.set(true); |
| 279 | } |
| 280 | if (!createMeter(deviceId, oltDsBp)) { |
| 281 | pendingMeters.get(serviceName).add(usBp); |
| 282 | waitingOnMeter.set(true); |
| 283 | } |
| 284 | }); |
| 285 | if (waitingOnMeter.get()) { |
| 286 | if (log.isTraceEnabled()) { |
| 287 | log.trace("Meters {} on device {} are not " + |
| 288 | "installed yet (requested by subscriber {})", |
| 289 | pendingMeters, deviceId, si.id()); |
| 290 | } |
| 291 | return false; |
yasin sapli | b4b8ee1 | 2021-06-13 18:25:20 +0000 | [diff] [blame] | 292 | } |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 293 | return true; |
| 294 | } |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 295 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 296 | /** |
| 297 | * Returns true if a meter is present in the programmed meters map, only if status is ADDED. |
| 298 | * |
| 299 | * @param deviceId the DeviceId on which to look for the meter |
| 300 | * @param bandwidthProfile the Bandwidth profile associated with this meter |
| 301 | * @return true if the meter is found |
| 302 | */ |
| 303 | public boolean hasMeterByBandwidthProfile(DeviceId deviceId, String bandwidthProfile) { |
| 304 | try { |
| 305 | programmedMeterReadLock.lock(); |
| 306 | Map<String, MeterData> metersOnDevice = programmedMeters.get(deviceId); |
| 307 | if (metersOnDevice == null || metersOnDevice.isEmpty()) { |
| 308 | return false; |
| 309 | } |
| 310 | if (log.isTraceEnabled()) { |
| 311 | log.trace("added metersOnDevice {}: {}", deviceId, metersOnDevice); |
| 312 | } |
| 313 | return metersOnDevice.get(bandwidthProfile) != null && |
| 314 | metersOnDevice.get(bandwidthProfile).getMeterStatus().equals(MeterState.ADDED); |
| 315 | } finally { |
| 316 | programmedMeterReadLock.unlock(); |
| 317 | } |
| 318 | } |
| 319 | |
| 320 | public boolean hasPendingMeterByBandwidthProfile(DeviceId deviceId, String bandwidthProfile) { |
| 321 | try { |
| 322 | programmedMeterReadLock.lock(); |
| 323 | Map<String, MeterData> metersOnDevice = programmedMeters.get(deviceId); |
| 324 | if (metersOnDevice == null || metersOnDevice.isEmpty()) { |
| 325 | return false; |
| 326 | } |
| 327 | if (log.isTraceEnabled()) { |
| 328 | log.trace("pending metersOnDevice {}: {}", deviceId, metersOnDevice); |
| 329 | } |
| 330 | // NOTE that we check in order if the meter was ADDED and if it wasn't we check for PENDING_ADD |
| 331 | // it is possible that a different thread move the meter state from PENDING_ADD |
| 332 | // to ADDED between these two checks |
| 333 | // to avoid creating the meter twice we return true event if the meter is already added |
| 334 | return metersOnDevice.get(bandwidthProfile) != null && ( |
| 335 | metersOnDevice.get(bandwidthProfile).getMeterStatus().equals(MeterState.ADDED) || |
| 336 | metersOnDevice.get(bandwidthProfile).getMeterStatus().equals(MeterState.PENDING_ADD) |
| 337 | ); |
| 338 | |
| 339 | } finally { |
| 340 | programmedMeterReadLock.unlock(); |
| 341 | } |
| 342 | } |
| 343 | |
| 344 | public MeterId getMeterIdForBandwidthProfile(DeviceId deviceId, String bandwidthProfile) { |
| 345 | try { |
| 346 | programmedMeterReadLock.lock(); |
| 347 | Map<String, MeterData> metersOnDevice = programmedMeters.get(deviceId); |
| 348 | if (metersOnDevice == null || metersOnDevice.isEmpty()) { |
| 349 | return null; |
| 350 | } |
| 351 | MeterData meterData = metersOnDevice.get(bandwidthProfile); |
| 352 | if (meterData == null || meterData.getMeterStatus() != MeterState.ADDED) { |
| 353 | return null; |
| 354 | } |
| 355 | if (log.isTraceEnabled()) { |
| 356 | log.debug("Found meter {} on device {} for bandwidth profile {}", |
| 357 | meterData.getMeterId(), deviceId, bandwidthProfile); |
| 358 | } |
| 359 | return meterData.getMeterId(); |
| 360 | } finally { |
| 361 | programmedMeterReadLock.unlock(); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 362 | } |
| 363 | } |
| 364 | |
| 365 | @Override |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 366 | public void purgeDeviceMeters(DeviceId deviceId) { |
| 367 | log.debug("Purging meters on device {}", deviceId); |
| 368 | meterService.purgeMeters(deviceId); |
| 369 | |
| 370 | // after we purge the meters we also need to clear the map |
| 371 | try { |
| 372 | programmedMeterWriteLock.lock(); |
| 373 | programmedMeters.remove(deviceId); |
| 374 | } finally { |
| 375 | programmedMeterWriteLock.unlock(); |
| 376 | } |
| 377 | |
| 378 | // and clear the event count |
| 379 | // NOTE do we need a lock? |
| 380 | pendingRemoveMeters.remove(deviceId); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 381 | } |
| 382 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 383 | /** |
| 384 | * Creates of a meter for a given Bandwidth Profile on a given device. |
| 385 | * |
| 386 | * @param deviceId the DeviceId |
| 387 | * @param bandwidthProfile the BandwidthProfile ID |
| 388 | */ |
| 389 | public void createMeterForBp(DeviceId deviceId, String bandwidthProfile) { |
| 390 | // adding meter in pending state to the programmedMeter map |
| 391 | try { |
| 392 | programmedMeterWriteLock.lock(); |
| 393 | programmedMeters.compute(deviceId, (d, deviceMeters) -> { |
| 394 | |
| 395 | if (deviceMeters == null) { |
| 396 | deviceMeters = new HashMap<>(); |
| 397 | } |
| 398 | // NOTE that this method is only called after verifying a |
| 399 | // meter for this BP does not already exist |
| 400 | MeterData meterData = new MeterData( |
| 401 | null, |
| 402 | MeterState.PENDING_ADD, |
| 403 | bandwidthProfile |
| 404 | ); |
| 405 | deviceMeters.put(bandwidthProfile, meterData); |
| 406 | |
| 407 | return deviceMeters; |
| 408 | }); |
| 409 | } finally { |
| 410 | programmedMeterWriteLock.unlock(); |
| 411 | } |
| 412 | |
| 413 | BandwidthProfileInformation bpInfo = getBandwidthProfileInformation(bandwidthProfile); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 414 | if (bpInfo == null) { |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 415 | log.error("BandwidthProfile {} information not found in sadis", bandwidthProfile); |
| 416 | return; |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 417 | } |
| 418 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 419 | log.info("Creating meter for BandwidthProfile {} on device {}", bpInfo.id(), deviceId); |
| 420 | |
| 421 | if (log.isTraceEnabled()) { |
| 422 | log.trace("BandwidthProfile: {}", bpInfo); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 423 | } |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 424 | try { |
| 425 | List<Band> meterBands = createMeterBands(bpInfo); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 426 | |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 427 | log.info("Meter bands {} for bwp {}", meterBands, bpInfo); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 428 | |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 429 | CompletableFuture<Object> meterFuture = new CompletableFuture<>(); |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 430 | |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 431 | MeterRequest meterRequest = DefaultMeterRequest.builder() |
| 432 | .withBands(meterBands) |
| 433 | .withUnit(Meter.Unit.KB_PER_SEC) |
| 434 | .withContext(new MeterContext() { |
| 435 | @Override |
| 436 | public void onSuccess(MeterRequest op) { |
| 437 | log.info("Meter for BandwidthProfile {} is installed on the device {}", |
| 438 | bandwidthProfile, deviceId); |
| 439 | meterFuture.complete(null); |
| 440 | } |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 441 | |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 442 | @Override |
| 443 | public void onError(MeterRequest op, MeterFailReason reason) { |
| 444 | log.error("Failed installing meter on {} for {}", |
| 445 | deviceId, bandwidthProfile); |
| 446 | meterFuture.complete(reason); |
| 447 | } |
| 448 | }) |
| 449 | .forDevice(deviceId) |
| 450 | .fromApp(appId) |
| 451 | .burst() |
| 452 | .add(); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 453 | |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 454 | // creating the meter |
| 455 | Meter meter = meterService.submit(meterRequest); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 456 | |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 457 | // wait for the meter to be completed |
| 458 | meterFuture.thenAccept(error -> { |
| 459 | if (error != null) { |
| 460 | log.error("Cannot create meter, TODO address me"); |
| 461 | } |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 462 | |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 463 | // then update the map with the MeterId |
| 464 | try { |
| 465 | programmedMeterWriteLock.lock(); |
| 466 | programmedMeters.compute(deviceId, (d, entry) -> { |
| 467 | if (entry != null) { |
| 468 | entry.compute(bandwidthProfile, (bp, meterData) -> { |
| 469 | if (meterData != null) { |
| 470 | meterData.setMeterCellId(meter.meterCellId()); |
| 471 | meterData.setMeterStatus(MeterState.ADDED); |
| 472 | } |
| 473 | return meterData; |
| 474 | }); |
| 475 | } |
| 476 | return entry; |
| 477 | }); |
| 478 | } finally { |
| 479 | programmedMeterWriteLock.unlock(); |
| 480 | } |
| 481 | }); |
| 482 | } catch (Exception e) { |
| 483 | log.error("", e); |
| 484 | } |
Andrea Campanella | 600d2e2 | 2020-06-22 11:00:31 +0200 | [diff] [blame] | 485 | } |
| 486 | |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 487 | private List<Band> createMeterBands(BandwidthProfileInformation bpInfo) { |
| 488 | List<Band> meterBands = new ArrayList<>(); |
| 489 | |
Gamze Abaka | f46ab43 | 2021-03-03 10:51:17 +0000 | [diff] [blame] | 490 | // add cir |
| 491 | if (bpInfo.committedInformationRate() != 0) { |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 492 | meterBands.add(createMeterBand(bpInfo.committedInformationRate(), |
| 493 | bpInfo.committedBurstSize(), Band.Type.DROP, null)); |
Gamze Abaka | f46ab43 | 2021-03-03 10:51:17 +0000 | [diff] [blame] | 494 | } |
| 495 | |
| 496 | // check if both air and gir are set together in sadis |
| 497 | // if they are, set air to 0 |
| 498 | if (bpInfo.assuredInformationRate() != 0 && bpInfo.guaranteedInformationRate() != 0) { |
| 499 | bpInfo.setAssuredInformationRate(0); |
| 500 | } |
| 501 | |
| 502 | // add pir |
| 503 | long pir = bpInfo.peakInformationRate() != 0 ? bpInfo.peakInformationRate() : (bpInfo.exceededInformationRate() |
| 504 | + bpInfo.committedInformationRate() + bpInfo.guaranteedInformationRate() |
| 505 | + bpInfo.assuredInformationRate()); |
| 506 | |
| 507 | Long pbs = bpInfo.peakBurstSize() != null ? bpInfo.peakBurstSize() : |
| 508 | (bpInfo.exceededBurstSize() != null ? bpInfo.exceededBurstSize() : 0) + |
| 509 | (bpInfo.committedBurstSize() != null ? bpInfo.committedBurstSize() : 0); |
| 510 | |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 511 | meterBands.add(createMeterBand(pir, pbs, Band.Type.REMARK, (short) 1)); |
Gamze Abaka | f46ab43 | 2021-03-03 10:51:17 +0000 | [diff] [blame] | 512 | |
| 513 | // add gir |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 514 | //We can use DROP here because it GIr will never be equals to cir so rate will always be different. |
Gamze Abaka | f46ab43 | 2021-03-03 10:51:17 +0000 | [diff] [blame] | 515 | if (bpInfo.guaranteedInformationRate() != 0) { |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 516 | meterBands.add(createMeterBand(bpInfo.guaranteedInformationRate(), 0L, Band.Type.DROP, null)); |
Gamze Abaka | f46ab43 | 2021-03-03 10:51:17 +0000 | [diff] [blame] | 517 | } |
| 518 | |
| 519 | // add air |
| 520 | // air is used in place of gir only if gir is |
| 521 | // not present and air is not 0, see line 330. |
| 522 | // Included for backwards compatibility, will be removed in VOLTHA 2.9. |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 523 | // Using Band.Type.NONE is ok because this will be removed. |
Gamze Abaka | f46ab43 | 2021-03-03 10:51:17 +0000 | [diff] [blame] | 524 | if (bpInfo.assuredInformationRate() != 0) { |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 525 | meterBands.add(createMeterBand(bpInfo.assuredInformationRate(), 0L, Band.Type.DROP, null)); |
Gamze Abaka | f46ab43 | 2021-03-03 10:51:17 +0000 | [diff] [blame] | 526 | } |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 527 | |
| 528 | return meterBands; |
| 529 | } |
| 530 | |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 531 | private Band createMeterBand(long rate, Long burst, Band.Type type, Short precedence) { |
| 532 | Band.Builder bandBuilder = DefaultBand.builder() |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 533 | .withRate(rate) //already Kbps |
| 534 | .burstSize(burst) // already Kbits |
Andrea Campanella | 672485f | 2022-03-17 11:50:56 +0100 | [diff] [blame] | 535 | .ofType(type); // no matter |
| 536 | if (precedence != null) { |
| 537 | bandBuilder.dropPrecedence(precedence); |
| 538 | } |
| 539 | |
| 540 | return bandBuilder.build(); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 541 | } |
| 542 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 543 | private BandwidthProfileInformation getBandwidthProfileInformation(String bandwidthProfile) { |
| 544 | if (!checkSadisRunning()) { |
| 545 | return null; |
Andrea Campanella | 7e1eb71 | 2021-09-22 14:27:35 +0200 | [diff] [blame] | 546 | } |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 547 | if (bandwidthProfile == null) { |
| 548 | return null; |
| 549 | } |
| 550 | return bpService.get(bandwidthProfile); |
| 551 | } |
| 552 | |
| 553 | private boolean checkSadisRunning() { |
| 554 | if (bpService == null) { |
| 555 | log.warn("Sadis is not running"); |
| 556 | return false; |
| 557 | } |
| 558 | return true; |
Andrea Campanella | 7e1eb71 | 2021-09-22 14:27:35 +0200 | [diff] [blame] | 559 | } |
| 560 | |
Andrea Campanella | 600d2e2 | 2020-06-22 11:00:31 +0200 | [diff] [blame] | 561 | private class InternalMeterListener implements MeterListener { |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 562 | @Override |
| 563 | public void event(MeterEvent meterEvent) { |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 564 | pendingRemovalMetersExecutor.execute(() -> { |
| 565 | |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 566 | Meter meter = meterEvent.subject(); |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 567 | if (!appId.equals(meter.appId())) { |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 568 | return; |
| 569 | } |
Andrea Campanella | 7e1eb71 | 2021-09-22 14:27:35 +0200 | [diff] [blame] | 570 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 571 | if (log.isTraceEnabled()) { |
| 572 | log.trace("Received meter event {}", meterEvent); |
| 573 | } |
| 574 | MeterKey key = MeterKey.key(meter.deviceId(), meter.id()); |
| 575 | if (meterEvent.type().equals(MeterEvent.Type.METER_REFERENCE_COUNT_ZERO)) { |
| 576 | if (!oltDeviceService.isLocalLeader(meter.deviceId())) { |
| 577 | if (log.isTraceEnabled()) { |
| 578 | log.trace("ignoring meter event {} " + |
| 579 | "as not leader for {}", meterEvent, meter.deviceId()); |
| 580 | } |
| 581 | return; |
| 582 | } |
| 583 | log.info("Zero Count Reference event is received for meter {} on {}, " + |
| 584 | "incrementing counter", |
| 585 | meter.id(), meter.deviceId()); |
| 586 | incrementMeterCount(meter.deviceId(), key); |
| 587 | if (pendingRemoveMeters.get(meter.deviceId()) |
| 588 | .get(key).get() == zeroReferenceMeterCount) { |
| 589 | // only delete the meters if the app is configured to do so |
| 590 | if (deleteMeters) { |
| 591 | log.info("Meter {} on device {} is unused, removing it", meter.id(), meter.deviceId()); |
Andrea Campanella | 7e1eb71 | 2021-09-22 14:27:35 +0200 | [diff] [blame] | 592 | deleteMeter(meter.deviceId(), meter.id()); |
| 593 | } |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 594 | } |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 595 | } |
| 596 | |
| 597 | if (meterEvent.type().equals(MeterEvent.Type.METER_REMOVED)) { |
| 598 | removeMeterCount(meter, key); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 599 | } |
| 600 | }); |
| 601 | } |
| 602 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 603 | private void removeMeterCount(Meter meter, MeterKey key) { |
| 604 | pendingRemoveMeters.computeIfPresent(meter.deviceId(), |
| 605 | (id, meters) -> { |
| 606 | if (meters.get(key) == null) { |
| 607 | log.info("Meters is not pending " + |
| 608 | "{} on {}", key, id); |
| 609 | return meters; |
| 610 | } |
| 611 | meters.remove(key); |
| 612 | return meters; |
| 613 | }); |
| 614 | } |
| 615 | |
Andrea Campanella | 600d2e2 | 2020-06-22 11:00:31 +0200 | [diff] [blame] | 616 | private void incrementMeterCount(DeviceId deviceId, MeterKey key) { |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 617 | if (key == null) { |
| 618 | return; |
| 619 | } |
Andrea Campanella | 600d2e2 | 2020-06-22 11:00:31 +0200 | [diff] [blame] | 620 | pendingRemoveMeters.compute(deviceId, |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 621 | (id, meters) -> { |
| 622 | if (meters == null) { |
| 623 | meters = new HashMap<>(); |
Andrea Campanella | 600d2e2 | 2020-06-22 11:00:31 +0200 | [diff] [blame] | 624 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 625 | } |
| 626 | if (meters.get(key) == null) { |
| 627 | meters.put(key, new AtomicInteger(1)); |
| 628 | } |
| 629 | meters.get(key).addAndGet(1); |
| 630 | return meters; |
| 631 | }); |
| 632 | } |
| 633 | } |
| 634 | |
| 635 | private void deleteMeter(DeviceId deviceId, MeterId meterId) { |
| 636 | Meter meter = meterService.getMeter(deviceId, meterId); |
| 637 | if (meter != null) { |
| 638 | MeterRequest meterRequest = DefaultMeterRequest.builder() |
| 639 | .withBands(meter.bands()) |
| 640 | .withUnit(meter.unit()) |
| 641 | .forDevice(deviceId) |
| 642 | .fromApp(appId) |
| 643 | .burst() |
| 644 | .remove(); |
| 645 | |
| 646 | meterService.withdraw(meterRequest, meterId); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 647 | } |
| 648 | |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 649 | // remove the meter from local caching |
| 650 | try { |
| 651 | programmedMeterWriteLock.lock(); |
| 652 | programmedMeters.computeIfPresent(deviceId, (d, deviceMeters) -> { |
| 653 | Iterator<Map.Entry<String, MeterData>> iter = deviceMeters.entrySet().iterator(); |
| 654 | while (iter.hasNext()) { |
| 655 | Map.Entry<String, MeterData> entry = iter.next(); |
| 656 | if (entry.getValue().getMeterId().equals(meterId)) { |
| 657 | deviceMeters.remove(entry.getKey()); |
| 658 | } |
| 659 | } |
| 660 | return deviceMeters; |
| 661 | }); |
| 662 | } finally { |
| 663 | programmedMeterWriteLock.unlock(); |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 664 | } |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 665 | } |
Matteo Scandolo | aa2adde | 2021-09-13 12:45:32 -0700 | [diff] [blame] | 666 | |
| 667 | protected void bindSadisService(SadisService service) { |
| 668 | this.bpService = service.getBandwidthProfileService(); |
| 669 | log.info("Sadis service is loaded"); |
| 670 | } |
| 671 | |
| 672 | protected void unbindSadisService(SadisService service) { |
| 673 | this.bpService = null; |
| 674 | log.info("Sadis service is unloaded"); |
| 675 | } |
Andrea Campanella | cbbb795 | 2019-11-25 06:38:41 +0000 | [diff] [blame] | 676 | } |