| /* |
| * Copyright 2018-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.openstackvtap.impl; |
| |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.Maps; |
| import com.google.common.collect.Sets; |
| import org.apache.felix.scr.annotations.Activate; |
| import org.apache.felix.scr.annotations.Component; |
| import org.apache.felix.scr.annotations.Deactivate; |
| import org.apache.felix.scr.annotations.Reference; |
| import org.apache.felix.scr.annotations.ReferenceCardinality; |
| import org.apache.felix.scr.annotations.Service; |
| import org.onlab.util.KryoNamespace; |
| import org.onosproject.net.DefaultAnnotations; |
| import org.onosproject.net.DeviceId; |
| import org.onosproject.net.SparseAnnotations; |
| import org.onosproject.openstackvtap.api.OpenstackVtap; |
| import org.onosproject.openstackvtap.api.OpenstackVtap.Type; |
| import org.onosproject.openstackvtap.api.OpenstackVtapEvent; |
| import org.onosproject.openstackvtap.api.OpenstackVtapId; |
| import org.onosproject.openstackvtap.api.OpenstackVtapNetwork; |
| import org.onosproject.openstackvtap.api.OpenstackVtapStore; |
| import org.onosproject.openstackvtap.api.OpenstackVtapStoreDelegate; |
| import org.onosproject.store.AbstractStore; |
| import org.onosproject.store.serializers.KryoNamespaces; |
| import org.onosproject.store.service.ConsistentMap; |
| import org.onosproject.store.service.DistributedPrimitive.Status; |
| import org.onosproject.store.service.MapEvent; |
| import org.onosproject.store.service.MapEventListener; |
| import org.onosproject.store.service.Serializer; |
| import org.onosproject.store.service.StorageService; |
| import org.onosproject.store.service.Versioned; |
| import org.slf4j.Logger; |
| |
| import java.util.Comparator; |
| import java.util.Map; |
| import java.util.Objects; |
| import java.util.Set; |
| import java.util.UUID; |
| import java.util.concurrent.ScheduledExecutorService; |
| import java.util.function.Consumer; |
| import java.util.stream.Collectors; |
| |
| import static java.util.concurrent.Executors.newSingleThreadScheduledExecutor; |
| import static org.onlab.util.Tools.groupedThreads; |
| import static org.onosproject.net.DefaultAnnotations.merge; |
| import static org.onosproject.store.service.Versioned.valueOrNull; |
| import static org.slf4j.LoggerFactory.getLogger; |
| |
| /** |
| * Manages the inventory of openstack vtap and openstack vtap network using a {@code ConsistentMap}. |
| */ |
| @Component(immediate = true) |
| @Service |
| public class DistributedOpenstackVtapStore |
| extends AbstractStore<OpenstackVtapEvent, OpenstackVtapStoreDelegate> |
| implements OpenstackVtapStore { |
| |
| private final Logger log = getLogger(getClass()); |
| |
| @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) |
| protected StorageService storageService; |
| |
| private ConsistentMap<OpenstackVtapId, DefaultOpenstackVtap> vtapConsistentMap; |
| private MapEventListener<OpenstackVtapId, DefaultOpenstackVtap> vtapListener = |
| new VtapEventListener(); |
| private Map<OpenstackVtapId, DefaultOpenstackVtap> vtapMap; |
| |
| private ConsistentMap<Integer, DefaultOpenstackVtapNetwork> vtapNetworkConsistentMap; |
| private MapEventListener<Integer, DefaultOpenstackVtapNetwork> vtapNetworkListener = |
| new VtapNetworkEventListener(); |
| private Map<Integer, DefaultOpenstackVtapNetwork> vtapNetworkMap; |
| |
| private ConsistentMap<Integer, Set<DeviceId>> vtapNetworkDevicesConsistentMap; |
| |
| private static final Serializer SERIALIZER = Serializer |
| .using(new KryoNamespace.Builder().register(KryoNamespaces.API) |
| .register(OpenstackVtapId.class) |
| .register(UUID.class) |
| .register(DefaultOpenstackVtap.class) |
| .register(Type.class) |
| .register(DefaultOpenstackVtapCriterion.class) |
| .register(DefaultOpenstackVtapNetwork.class) |
| .register(OpenstackVtapNetwork.Mode.class) |
| .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID) |
| .build()); |
| |
| private Map<DeviceId, Set<OpenstackVtapId>> |
| vtapIdsByTxDeviceId = Maps.newConcurrentMap(); |
| private Map<DeviceId, Set<OpenstackVtapId>> |
| vtapIdsByRxDeviceId = Maps.newConcurrentMap(); |
| |
| private ScheduledExecutorService eventExecutor; |
| private Consumer<Status> vtapStatusListener; |
| |
| private static final String ERR_NOT_FOUND = "ID {} does not exist"; |
| private static final String ERR_DUPLICATE = "ID {} already exists"; |
| |
| @Activate |
| public void activate() { |
| eventExecutor = newSingleThreadScheduledExecutor( |
| groupedThreads(this.getClass().getSimpleName(), "event-handler", log)); |
| |
| // vtap network data |
| vtapNetworkConsistentMap = storageService.<Integer, DefaultOpenstackVtapNetwork> |
| consistentMapBuilder() |
| .withName("vtapNetworkMap") |
| .withSerializer(SERIALIZER) |
| .build(); |
| vtapNetworkMap = vtapNetworkConsistentMap.asJavaMap(); |
| vtapNetworkConsistentMap.addListener(vtapNetworkListener); |
| |
| // vtap network devices data |
| vtapNetworkDevicesConsistentMap = storageService.<Integer, Set<DeviceId>> |
| consistentMapBuilder() |
| .withName("vtapNetworkDevicesMap") |
| .withSerializer(SERIALIZER) |
| .build(); |
| |
| // vtap data |
| vtapConsistentMap = storageService.<OpenstackVtapId, DefaultOpenstackVtap> |
| consistentMapBuilder() |
| .withName("vtapMap") |
| .withSerializer(SERIALIZER) |
| .build(); |
| vtapMap = vtapConsistentMap.asJavaMap(); |
| vtapConsistentMap.addListener(vtapListener); |
| |
| // initialize vtap data |
| vtapStatusListener = status -> { |
| if (status == Status.ACTIVE) { |
| eventExecutor.execute(this::loadVtapIds); |
| } |
| }; |
| vtapConsistentMap.addStatusChangeListener(vtapStatusListener); |
| |
| log.info("Started"); |
| } |
| |
| @Deactivate |
| public void deactivate() { |
| vtapConsistentMap.removeStatusChangeListener(vtapStatusListener); |
| vtapConsistentMap.removeListener(vtapListener); |
| vtapNetworkConsistentMap.removeListener(vtapNetworkListener); |
| |
| eventExecutor.shutdown(); |
| |
| log.info("Stopped"); |
| } |
| |
| private boolean shouldUpdateVtapNetwork(DefaultOpenstackVtapNetwork existing, |
| OpenstackVtapNetwork description) { |
| if (existing == null) { |
| return true; |
| } |
| |
| if (!Objects.equals(existing.mode(), description.mode()) || |
| !Objects.equals(existing.networkId(), description.networkId()) || |
| !Objects.equals(existing.serverIp(), description.serverIp())) { |
| return true; |
| } |
| |
| // check to see if any of the annotations provided by description |
| // differ from those in the existing vtap network |
| return description.annotations().keys().stream() |
| .anyMatch(k -> !Objects.equals(description.annotations().value(k), |
| existing.annotations().value(k))); |
| } |
| |
| private OpenstackVtapNetwork createOrUpdateVtapNetwork(boolean update, |
| Integer key, |
| OpenstackVtapNetwork description) { |
| DefaultOpenstackVtapNetwork result = |
| vtapNetworkMap.compute(key, (id, existing) -> { |
| // Check create or update validity |
| if (update && existing == null) { |
| return null; |
| } else if (!update && existing != null) { |
| return existing; |
| } |
| |
| if (shouldUpdateVtapNetwork(existing, description)) { |
| // Replace or add annotations |
| final SparseAnnotations annotations; |
| if (existing != null) { |
| annotations = merge((DefaultAnnotations) existing.annotations(), |
| (SparseAnnotations) description.annotations()); |
| } else { |
| annotations = (SparseAnnotations) description.annotations(); |
| } |
| |
| return DefaultOpenstackVtapNetwork.builder(description) |
| .annotations(annotations) |
| .build(); |
| } |
| return existing; |
| }); |
| return result; |
| } |
| |
| @Override |
| public OpenstackVtapNetwork createVtapNetwork(Integer key, OpenstackVtapNetwork description) { |
| if (getVtapNetwork(key) == null) { |
| OpenstackVtapNetwork vtapNetwork = createOrUpdateVtapNetwork(false, key, description); |
| if (Objects.equals(vtapNetwork, description)) { |
| return vtapNetwork; |
| } |
| } |
| log.error(ERR_DUPLICATE, key); |
| return null; |
| } |
| |
| @Override |
| public OpenstackVtapNetwork updateVtapNetwork(Integer key, OpenstackVtapNetwork description) { |
| OpenstackVtapNetwork vtapNetwork = createOrUpdateVtapNetwork(true, key, description); |
| if (vtapNetwork == null) { |
| log.error(ERR_NOT_FOUND, key); |
| } |
| return vtapNetwork; |
| } |
| |
| @Override |
| public OpenstackVtapNetwork removeVtapNetwork(Integer key) { |
| return vtapNetworkMap.remove(key); |
| } |
| |
| @Override |
| public void clearVtapNetworks() { |
| vtapNetworkMap.clear(); |
| } |
| |
| @Override |
| public int getVtapNetworkCount() { |
| return vtapNetworkMap.size(); |
| } |
| |
| @Override |
| public OpenstackVtapNetwork getVtapNetwork(Integer key) { |
| return vtapNetworkMap.get(key); |
| } |
| |
| @Override |
| public boolean addDeviceToVtapNetwork(Integer key, DeviceId deviceId) { |
| Versioned<Set<DeviceId>> result = |
| vtapNetworkDevicesConsistentMap.compute(key, (id, existing) -> { |
| // Add deviceId to deviceIds |
| if (existing == null) { |
| return Sets.newHashSet(deviceId); |
| } else if (!existing.contains(deviceId)) { |
| Set<DeviceId> deviceIds = Sets.newHashSet(existing); |
| deviceIds.add(deviceId); |
| return deviceIds; |
| } else { |
| return existing; |
| } |
| }); |
| return Objects.nonNull(valueOrNull(result)); |
| } |
| |
| @Override |
| public boolean removeDeviceFromVtapNetwork(Integer key, DeviceId deviceId) { |
| Versioned<Set<DeviceId>> result = |
| vtapNetworkDevicesConsistentMap.compute(key, (id, existing) -> { |
| // Remove deviceId from deviceIds |
| if (existing != null && existing.contains(deviceId)) { |
| Set<DeviceId> deviceIds = Sets.newHashSet(existing); |
| deviceIds.remove(deviceId); |
| return deviceIds; |
| } else { |
| return existing; |
| } |
| }); |
| return Objects.nonNull(valueOrNull(result)); |
| } |
| |
| @Override |
| public Set<DeviceId> getVtapNetworkDevices(Integer key) { |
| return valueOrNull(vtapNetworkDevicesConsistentMap.get(key)); |
| } |
| |
| private boolean shouldUpdateVtap(DefaultOpenstackVtap existing, |
| OpenstackVtap description, |
| boolean replaceDevices) { |
| if (existing == null) { |
| return true; |
| } |
| |
| if (!Objects.equals(existing.type(), description.type()) || |
| !Objects.equals(existing.vtapCriterion(), description.vtapCriterion())) { |
| return true; |
| } |
| |
| if (replaceDevices) { |
| if (!Objects.equals(description.txDeviceIds(), existing.txDeviceIds()) || |
| !Objects.equals(description.rxDeviceIds(), existing.rxDeviceIds())) { |
| return true; |
| } |
| } else { |
| if (!existing.txDeviceIds().containsAll(description.txDeviceIds()) || |
| !existing.rxDeviceIds().containsAll(description.rxDeviceIds())) { |
| return true; |
| } |
| } |
| |
| // check to see if any of the annotations provided by description |
| // differ from those in the existing vtap |
| return description.annotations().keys().stream() |
| .anyMatch(k -> !Objects.equals(description.annotations().value(k), |
| existing.annotations().value(k))); |
| } |
| |
| private OpenstackVtap createOrUpdateVtap(boolean update, |
| OpenstackVtap description, |
| boolean replaceDevices) { |
| DefaultOpenstackVtap result = |
| vtapMap.compute(description.id(), (id, existing) -> { |
| // Check create or update validity |
| if (update && existing == null) { |
| return null; |
| } else if (!update && existing != null) { |
| return existing; |
| } |
| |
| if (shouldUpdateVtap(existing, description, replaceDevices)) { |
| // Replace or add devices |
| final Set<DeviceId> txDeviceIds; |
| if (existing == null || replaceDevices) { |
| txDeviceIds = description.txDeviceIds(); |
| } else { |
| txDeviceIds = Sets.newHashSet(existing.txDeviceIds()); |
| txDeviceIds.addAll(description.txDeviceIds()); |
| } |
| |
| final Set<DeviceId> rxDeviceIds; |
| if (existing == null || replaceDevices) { |
| rxDeviceIds = description.rxDeviceIds(); |
| } else { |
| rxDeviceIds = Sets.newHashSet(existing.rxDeviceIds()); |
| rxDeviceIds.addAll(description.rxDeviceIds()); |
| } |
| |
| // Replace or add annotations |
| final SparseAnnotations annotations; |
| if (existing != null) { |
| annotations = merge((DefaultAnnotations) existing.annotations(), |
| (SparseAnnotations) description.annotations()); |
| } else { |
| annotations = (SparseAnnotations) description.annotations(); |
| } |
| |
| return DefaultOpenstackVtap.builder(description) |
| .txDeviceIds(txDeviceIds) |
| .rxDeviceIds(rxDeviceIds) |
| .annotations(annotations) |
| .build(); |
| } |
| return existing; |
| }); |
| return result; |
| } |
| |
| @Override |
| public OpenstackVtap createVtap(OpenstackVtap description) { |
| if (getVtap(description.id()) == null) { |
| OpenstackVtap vtap = createOrUpdateVtap(false, description, true); |
| if (Objects.equals(vtap, description)) { |
| return vtap; |
| } |
| } |
| log.error(ERR_DUPLICATE, description.id()); |
| return null; |
| } |
| |
| @Override |
| public OpenstackVtap updateVtap(OpenstackVtap description, boolean replaceDevices) { |
| OpenstackVtap vtap = createOrUpdateVtap(true, description, replaceDevices); |
| if (vtap == null) { |
| log.error(ERR_NOT_FOUND, description.id()); |
| } |
| return vtap; |
| } |
| |
| @Override |
| public OpenstackVtap removeVtap(OpenstackVtapId vtapId) { |
| return vtapMap.remove(vtapId); |
| } |
| |
| @Override |
| public void clearVtaps() { |
| vtapMap.clear(); |
| } |
| |
| @Override |
| public int getVtapCount(Type type) { |
| return (int) vtapMap.values().parallelStream() |
| .filter(vtap -> vtap.type().isValid(type)) |
| .count(); |
| } |
| |
| @Override |
| public Set<OpenstackVtap> getVtaps(Type type) { |
| return ImmutableSet.copyOf( |
| vtapMap.values().parallelStream() |
| .filter(vtap -> vtap.type().isValid(type)) |
| .collect(Collectors.toSet())); |
| } |
| |
| @Override |
| public OpenstackVtap getVtap(OpenstackVtapId vtapId) { |
| return vtapMap.get(vtapId); |
| } |
| |
| @Override |
| public boolean addDeviceToVtap(OpenstackVtapId vtapId, Type type, DeviceId deviceId) { |
| OpenstackVtap result = |
| vtapMap.compute(vtapId, (id, existing) -> { |
| if (existing == null) { |
| return null; |
| } |
| |
| // Check type validate |
| if (!existing.type().isValid(type)) { |
| log.error("Not valid OpenstackVtap type {} for requested type {}", existing.type(), type); |
| return existing; |
| } |
| |
| // Add deviceId to txDeviceIds |
| final Set<DeviceId> txDeviceIds; |
| if (existing.type().isValid(Type.VTAP_TX) && |
| (type.isValid(Type.VTAP_TX) || type == Type.VTAP_ANY) && |
| !existing.txDeviceIds().contains(deviceId)) { |
| txDeviceIds = Sets.newHashSet(existing.txDeviceIds()); |
| txDeviceIds.add(deviceId); |
| } else { |
| txDeviceIds = null; |
| } |
| |
| // Add deviceId to rxDeviceIds |
| final Set<DeviceId> rxDeviceIds; |
| if (existing.type().isValid(Type.VTAP_RX) && |
| (type.isValid(Type.VTAP_RX) || type == Type.VTAP_ANY) && |
| !existing.rxDeviceIds().contains(deviceId)) { |
| rxDeviceIds = Sets.newHashSet(existing.rxDeviceIds()); |
| rxDeviceIds.add(deviceId); |
| } else { |
| rxDeviceIds = null; |
| } |
| |
| if (txDeviceIds != null || rxDeviceIds != null) { |
| return DefaultOpenstackVtap.builder() |
| .id(id) |
| .type(existing.type()) |
| .vtapCriterion(existing.vtapCriterion()) |
| .txDeviceIds(txDeviceIds != null ? txDeviceIds : existing.txDeviceIds()) |
| .rxDeviceIds(rxDeviceIds != null ? rxDeviceIds : existing.rxDeviceIds()) |
| .annotations(existing.annotations()) |
| .build(); |
| } else { |
| return existing; |
| } |
| }); |
| return Objects.nonNull(result); |
| } |
| |
| @Override |
| public boolean removeDeviceFromVtap(OpenstackVtapId vtapId, OpenstackVtap.Type type, DeviceId deviceId) { |
| OpenstackVtap result = |
| vtapMap.compute(vtapId, (id, existing) -> { |
| if (existing == null) { |
| return null; |
| } |
| |
| // Check type validate |
| if (!existing.type().isValid(type)) { |
| log.error("Not valid OpenstackVtap type {} for requested type {}", |
| existing.type(), type); |
| return existing; |
| } |
| |
| // Remove deviceId from txDeviceIds |
| final Set<DeviceId> txDeviceIds; |
| if (existing.type().isValid(Type.VTAP_TX) && |
| (type.isValid(Type.VTAP_TX) || type == Type.VTAP_ANY) && |
| existing.txDeviceIds().contains(deviceId)) { |
| txDeviceIds = Sets.newHashSet(existing.txDeviceIds()); |
| txDeviceIds.remove(deviceId); |
| } else { |
| txDeviceIds = null; |
| } |
| |
| // Remove deviceId from rxDeviceIds |
| final Set<DeviceId> rxDeviceIds; |
| if (existing.type().isValid(Type.VTAP_RX) && |
| (type.isValid(Type.VTAP_RX) || type == Type.VTAP_ANY) && |
| existing.rxDeviceIds().contains(deviceId)) { |
| rxDeviceIds = Sets.newHashSet(existing.rxDeviceIds()); |
| rxDeviceIds.remove(deviceId); |
| } else { |
| rxDeviceIds = null; |
| } |
| |
| if (txDeviceIds != null || rxDeviceIds != null) { |
| return DefaultOpenstackVtap.builder() |
| .id(id) |
| .type(existing.type()) |
| .vtapCriterion(existing.vtapCriterion()) |
| .txDeviceIds(txDeviceIds != null ? txDeviceIds : existing.txDeviceIds()) |
| .rxDeviceIds(rxDeviceIds != null ? rxDeviceIds : existing.rxDeviceIds()) |
| .annotations(existing.annotations()) |
| .build(); |
| } else { |
| return existing; |
| } |
| }); |
| return Objects.nonNull(result); |
| } |
| |
| @Override |
| public Set<OpenstackVtap> getVtapsByDeviceId(DeviceId deviceId) { |
| Set<OpenstackVtapId> vtapIds = Sets.newHashSet(); |
| Set<OpenstackVtapId> txIds = vtapIdsByTxDeviceId.get(deviceId); |
| if (txIds != null) { |
| vtapIds.addAll(txIds); |
| } |
| Set<OpenstackVtapId> rxIds = vtapIdsByRxDeviceId.get(deviceId); |
| if (rxIds != null) { |
| vtapIds.addAll(rxIds); |
| } |
| return ImmutableSet.copyOf( |
| vtapIds.parallelStream() |
| .map(vtapId -> vtapMap.get(vtapId)) |
| .filter(Objects::nonNull) |
| .collect(Collectors.toSet())); |
| } |
| |
| private class VtapComparator implements Comparator<OpenstackVtap> { |
| @Override |
| public int compare(OpenstackVtap v1, OpenstackVtap v2) { |
| int diff = (v2.type().compareTo(v1.type())); |
| if (diff == 0) { |
| return (v2.vtapCriterion().ipProtocol() - v1.vtapCriterion().ipProtocol()); |
| } |
| return diff; |
| } |
| } |
| |
| private void loadVtapIds() { |
| vtapIdsByTxDeviceId.clear(); |
| vtapIdsByRxDeviceId.clear(); |
| vtapMap.values().forEach(vtap -> refreshDeviceIdsByVtap(null, vtap)); |
| } |
| |
| private static Set<OpenstackVtapId> addVTapIds(OpenstackVtapId vtapId) { |
| Set<OpenstackVtapId> vtapIds = Sets.newConcurrentHashSet(); |
| vtapIds.add(vtapId); |
| return vtapIds; |
| } |
| |
| private static Set<OpenstackVtapId> updateVTapIds(Set<OpenstackVtapId> existingVtapIds, |
| OpenstackVtapId vtapId) { |
| existingVtapIds.add(vtapId); |
| return existingVtapIds; |
| } |
| |
| private static Set<OpenstackVtapId> removeVTapIds(Set<OpenstackVtapId> existingVtapIds, |
| OpenstackVtapId vtapId) { |
| existingVtapIds.remove(vtapId); |
| if (existingVtapIds.isEmpty()) { |
| return null; |
| } |
| return existingVtapIds; |
| } |
| |
| private void updateVTapIdFromTxDeviceId(OpenstackVtapId vtapId, DeviceId deviceId) { |
| vtapIdsByTxDeviceId.compute(deviceId, (k, v) -> v == null ? |
| addVTapIds(vtapId) : updateVTapIds(v, vtapId)); |
| } |
| |
| private void removeVTapIdFromTxDeviceId(OpenstackVtapId vtapId, DeviceId deviceId) { |
| vtapIdsByTxDeviceId.computeIfPresent(deviceId, (k, v) -> removeVTapIds(v, vtapId)); |
| } |
| |
| private void updateVTapIdFromRxDeviceId(OpenstackVtapId vtapId, DeviceId deviceId) { |
| vtapIdsByRxDeviceId.compute(deviceId, (k, v) -> v == null ? |
| addVTapIds(vtapId) : updateVTapIds(v, vtapId)); |
| } |
| |
| private void removeVTapIdFromRxDeviceId(OpenstackVtapId vtapId, DeviceId deviceId) { |
| vtapIdsByRxDeviceId.computeIfPresent(deviceId, (k, v) -> removeVTapIds(v, vtapId)); |
| } |
| |
| private void refreshDeviceIdsByVtap(OpenstackVtap newOpenstackVtap, |
| OpenstackVtap oldOpenstackVtap) { |
| if (Objects.equals(newOpenstackVtap, oldOpenstackVtap)) { |
| return; |
| } |
| |
| if (oldOpenstackVtap != null) { |
| Set<DeviceId> removeDeviceIds; |
| |
| // Remove TX vtap |
| removeDeviceIds = (newOpenstackVtap != null) ? |
| Sets.difference(oldOpenstackVtap.txDeviceIds(), |
| newOpenstackVtap.txDeviceIds()) : oldOpenstackVtap.txDeviceIds(); |
| removeDeviceIds.forEach(id -> removeVTapIdFromTxDeviceId(oldOpenstackVtap.id(), id)); |
| |
| // Remove RX vtap |
| removeDeviceIds = (newOpenstackVtap != null) ? |
| Sets.difference(oldOpenstackVtap.rxDeviceIds(), |
| newOpenstackVtap.rxDeviceIds()) : oldOpenstackVtap.rxDeviceIds(); |
| removeDeviceIds.forEach(id -> removeVTapIdFromRxDeviceId(oldOpenstackVtap.id(), id)); |
| } |
| |
| if (newOpenstackVtap != null) { |
| Set<DeviceId> addDeviceIds; |
| |
| // Add TX vtap |
| addDeviceIds = (oldOpenstackVtap != null) ? |
| Sets.difference(newOpenstackVtap.txDeviceIds(), |
| oldOpenstackVtap.txDeviceIds()) : newOpenstackVtap.txDeviceIds(); |
| addDeviceIds.forEach(id -> updateVTapIdFromTxDeviceId(newOpenstackVtap.id(), id)); |
| |
| // Add RX vtap |
| addDeviceIds = (oldOpenstackVtap != null) ? |
| Sets.difference(newOpenstackVtap.rxDeviceIds(), |
| oldOpenstackVtap.rxDeviceIds()) : newOpenstackVtap.rxDeviceIds(); |
| addDeviceIds.forEach(id -> updateVTapIdFromRxDeviceId(newOpenstackVtap.id(), id)); |
| } |
| } |
| |
| private class VtapEventListener |
| implements MapEventListener<OpenstackVtapId, DefaultOpenstackVtap> { |
| @Override |
| public void event(MapEvent<OpenstackVtapId, DefaultOpenstackVtap> event) { |
| DefaultOpenstackVtap newValue = |
| event.newValue() != null ? event.newValue().value() : null; |
| DefaultOpenstackVtap oldValue = |
| event.oldValue() != null ? event.oldValue().value() : null; |
| |
| log.trace("VtapEventListener {}: {} -> {}", event.type(), oldValue, newValue); |
| switch (event.type()) { |
| case INSERT: |
| refreshDeviceIdsByVtap(newValue, oldValue); |
| notifyDelegate(new OpenstackVtapEvent( |
| OpenstackVtapEvent.Type.VTAP_ADDED, newValue, null)); |
| break; |
| |
| case UPDATE: |
| refreshDeviceIdsByVtap(newValue, oldValue); |
| notifyDelegate(new OpenstackVtapEvent( |
| OpenstackVtapEvent.Type.VTAP_UPDATED, newValue, oldValue)); |
| break; |
| |
| case REMOVE: |
| refreshDeviceIdsByVtap(newValue, oldValue); |
| notifyDelegate(new OpenstackVtapEvent( |
| OpenstackVtapEvent.Type.VTAP_REMOVED, null, oldValue)); |
| break; |
| |
| default: |
| log.warn("Unknown map event type: {}", event.type()); |
| } |
| } |
| } |
| |
| private class VtapNetworkEventListener |
| implements MapEventListener<Integer, DefaultOpenstackVtapNetwork> { |
| @Override |
| public void event(MapEvent<Integer, DefaultOpenstackVtapNetwork> event) { |
| DefaultOpenstackVtapNetwork newValue = |
| event.newValue() != null ? event.newValue().value() : null; |
| DefaultOpenstackVtapNetwork oldValue = |
| event.oldValue() != null ? event.oldValue().value() : null; |
| |
| log.trace("VtapNetworkEventListener {}: {} -> {}", event.type(), oldValue, newValue); |
| switch (event.type()) { |
| case INSERT: |
| notifyDelegate(new OpenstackVtapEvent( |
| OpenstackVtapEvent.Type.VTAP_NETWORK_ADDED, newValue, null)); |
| break; |
| |
| case UPDATE: |
| notifyDelegate(new OpenstackVtapEvent( |
| OpenstackVtapEvent.Type.VTAP_NETWORK_UPDATED, newValue, oldValue)); |
| break; |
| |
| case REMOVE: |
| notifyDelegate(new OpenstackVtapEvent( |
| OpenstackVtapEvent.Type.VTAP_NETWORK_REMOVED, null, oldValue)); |
| break; |
| |
| default: |
| log.warn("Unknown map event type: {}", event.type()); |
| } |
| } |
| } |
| |
| } |