}
}
- private Node getCreated(DataObjectModification<Node> mod) {
+ private static Node getCreated(DataObjectModification<Node> mod) {
if (mod.getModificationType() == ModificationType.WRITE && mod.getDataBefore() == null) {
return mod.getDataAfter();
}
return null;
}
- private Node getRemoved(DataObjectModification<Node> mod) {
+ private static Node getRemoved(DataObjectModification<Node> mod) {
if (mod.getModificationType() == ModificationType.DELETE) {
return mod.getDataBefore();
}
return null;
}
- private Node getUpdated(DataObjectModification<Node> mod) {
+ private static Node getUpdated(DataObjectModification<Node> mod) {
Node node = null;
switch (mod.getModificationType()) {
case SUBTREE_MODIFIED:
return node;
}
- private Node getOriginal(DataObjectModification<Node> mod) {
+ private static Node getOriginal(DataObjectModification<Node> mod) {
Node node = null;
switch (mod.getModificationType()) {
case SUBTREE_MODIFIED:
return node;
}
- private InstanceIdentifier<Node> getWildcardPath() {
- InstanceIdentifier<Node> path = InstanceIdentifier
- .create(NetworkTopology.class)
+ private static InstanceIdentifier<Node> getWildcardPath() {
+ return InstanceIdentifier.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID))
.child(Node.class);
- return path;
}
private Map<HwvtepConnectionInstance, Collection<DataTreeModification<Node>>> changesByConnectionInstance(
}
}
- private void connect(Collection<DataTreeModification<Node>> changes) {
+ private static void connect(Collection<DataTreeModification<Node>> changes) {
changes.forEach((change) -> {
InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
DataObjectModification<Node> mod = change.getRootNode();
});
}
- private void updated(Collection<DataTreeModification<Node>> changes) {
+ private static void updated(Collection<DataTreeModification<Node>> changes) {
changes.forEach((change) -> {
InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
DataObjectModification<Node> mod = change.getRootNode();
.child(Node.class);
}
- private Node getUpdated(DataObjectModification<Node> mod) {
+ private static Node getUpdated(DataObjectModification<Node> mod) {
Node node = null;
switch (mod.getModificationType()) {
case SUBTREE_MODIFIED:
}
return node;
}
-
-
}
});
}
- private List<Pair<HwvtepTransactionLogElement, Boolean>> mergeLogsByDate(
+ private
static List<Pair<HwvtepTransactionLogElement, Boolean>> mergeLogsByDate(
List<HwvtepTransactionLogElement> logs1,
List<HwvtepTransactionLogElement> logs2) {
}
@SuppressWarnings("checkstyle:RegexpSinglelineJava")
- private void print(InstanceIdentifier<Node> iid,
- HwvtepConnectionInstance connectionInstance) {
+ private static void print(InstanceIdentifier<Node> iid, HwvtepConnectionInstance connectionInstance) {
PrintStream printStream = System.out;
printStream.print("Printing for Node : ");
printStream.println(iid.firstKeyOf(Node.class).getNodeId().getValue());
}
- private void printEntry(PrintStream console, Map.Entry<Class<? extends Identifiable>,
+ private static void printEntry(PrintStream console, Map.Entry<Class<? extends Identifiable>,
Map<InstanceIdentifier, HwvtepDeviceInfo.DeviceData>> entry) {
Class<? extends Identifiable> cls = entry.getKey();
Map<InstanceIdentifier, HwvtepDeviceInfo.DeviceData> map = entry.getValue();
});
}
- private void printTable(PrintStream console, String clsName, HwvtepDeviceInfo.DeviceData deviceData) {
+ private static void printTable(PrintStream console, String clsName, HwvtepDeviceInfo.DeviceData deviceData) {
console.print(" ");
if (clsName.equals("LogicalSwitches")) {
printLogicalSwitches(console, deviceData);
console.println(deviceData.getUuid());
}
- private void printLogicalSwitches(PrintStream console, HwvtepDeviceInfo.DeviceData deviceData) {
+ private static void printLogicalSwitches(PrintStream console, HwvtepDeviceInfo.DeviceData deviceData) {
InstanceIdentifier<LogicalSwitches> ls = deviceData.getKey();
console.print(ls.firstKeyOf(LogicalSwitches.class).getHwvtepNodeName().getValue());
}
- private void printRemoteMcasts(PrintStream console, HwvtepDeviceInfo.DeviceData deviceData) {
+ private static void printRemoteMcasts(PrintStream console, HwvtepDeviceInfo.DeviceData deviceData) {
InstanceIdentifier<RemoteMcastMacs> remoteMcastMacsIid = deviceData.getKey();
String macAddress = remoteMcastMacsIid.firstKeyOf(RemoteMcastMacs.class).getMacEntryKey().getValue();
String logicalSwitchRef = remoteMcastMacsIid.firstKeyOf(RemoteMcastMacs.class).getLogicalSwitchRef().getValue()
console.print(macEntryDetails);
}
- private void printRemoteUcasts(PrintStream console, HwvtepDeviceInfo.DeviceData deviceData) {
+ private static void printRemoteUcasts(PrintStream console, HwvtepDeviceInfo.DeviceData deviceData) {
InstanceIdentifier<RemoteUcastMacs> remoteUcastMacsIid = deviceData.getKey();
String macAddress = remoteUcastMacsIid.firstKeyOf(RemoteUcastMacs.class).getMacEntryKey().getValue();
String logicalSwitchRef = remoteUcastMacsIid.firstKeyOf(RemoteUcastMacs.class).getLogicalSwitchRef().getValue()
console.print(macEntryDetails);
}
- private void printTerminationPoint(PrintStream console, HwvtepDeviceInfo.DeviceData deviceData) {
+ private static void printTerminationPoint(PrintStream console, HwvtepDeviceInfo.DeviceData deviceData) {
InstanceIdentifier<TerminationPoint> terminationPointIid = deviceData.getKey();
console.print(terminationPointIid.firstKeyOf(TerminationPoint.class).getTpId().getValue());
try {
}
}
- private void printNode(PrintStream console, HwvtepDeviceInfo.DeviceData deviceData) {
+ private static void printNode(PrintStream console, HwvtepDeviceInfo.DeviceData deviceData) {
InstanceIdentifier<Node> ls = deviceData.getKey();
console.print(ls.firstKeyOf(Node.class).getNodeId().getValue());
}
- private void printCommon(PrintStream console, HwvtepDeviceInfo.DeviceData deviceData) {
+ private static void printCommon(PrintStream console, HwvtepDeviceInfo.DeviceData deviceData) {
console.print(deviceData.getKey());
console.print(" ");
if (deviceData.getData() == null && deviceData.getStatus() != HwvtepDeviceInfo.DeviceDataStatus.IN_TRANSIT) {
console.println(deviceData.getUuid());
}
- private void printEntryUUID(PrintStream console, Map.Entry<Class<? extends Identifiable>, Map<UUID,
+ private static void printEntryUUID(PrintStream console, Map.Entry<Class<? extends Identifiable>, Map<UUID,
HwvtepDeviceInfo.DeviceData>> entry) {
Class<? extends Identifiable> cls = entry.getKey();
Map<UUID, HwvtepDeviceInfo.DeviceData> map = entry.getValue();
printTable(console, clsName, deviceData);
});
}
-
-
}
}
}
- private Node getCreated(DataObjectModification<Node> mod) {
+ private static Node getCreated(DataObjectModification<Node> mod) {
if (mod.getModificationType() == ModificationType.WRITE && mod.getDataBefore() == null) {
return mod.getDataAfter();
}
return null;
}
- private Node getRemoved(DataObjectModification<Node> mod) {
+ private static Node getRemoved(DataObjectModification<Node> mod) {
if (mod.getModificationType() == ModificationType.DELETE) {
return mod.getDataBefore();
}
}
- private void setDescription(final LogicalRouter logicalRouter, final LogicalRouters inputRouter) {
+ private static void setDescription(final LogicalRouter logicalRouter, final LogicalRouters inputRouter) {
if (inputRouter.getHwvtepNodeDescription() != null) {
logicalRouter.setDescription(inputRouter.getHwvtepNodeDescription());
} else {
}
}
- private void setName(final LogicalRouter logicalRouter, final LogicalRouters inputRouter,
+ private static void setName(final LogicalRouter logicalRouter, final LogicalRouters inputRouter,
final Optional<LogicalRouters> inputRouterOptional) {
if (inputRouter.getHwvtepNodeName() != null) {
logicalRouter.setName(inputRouter.getHwvtepNodeName().getValue());
});
}
- private Map<Long, UUID> excludeVlanBindings(final Set<UUID> deletedLsUuids, final PhysicalPort port) {
+ private static Map<Long, UUID> excludeVlanBindings(final Set<UUID> deletedLsUuids, final PhysicalPort port) {
return port.getVlanBindingsColumn().getData()
.entrySet().stream()
.peek(entry -> {
}
}
- private void setIpAddress(final McastMacsRemote mcastMacsRemote, final RemoteMcastMacs inputMac) {
+ private static void setIpAddress(final McastMacsRemote mcastMacsRemote, final RemoteMcastMacs inputMac) {
if (inputMac.getIpaddr() != null) {
mcastMacsRemote.setIpAddress(inputMac.getIpaddr().getIpv4Address().getValue());
}
}
- private void setMac(final McastMacsRemote mcastMacsRemote, final RemoteMcastMacs inputMac) {
+ private static void setMac(final McastMacsRemote mcastMacsRemote, final RemoteMcastMacs inputMac) {
if (inputMac.getMacEntryKey() != null) {
if (inputMac.getMacEntryKey().equals(HwvtepSouthboundConstants.UNKNOWN_DST_MAC)) {
mcastMacsRemote.setMac(HwvtepSouthboundConstants.UNKNOWN_DST_STRING);
&& Objects.equals(macs1.getLocatorSet(), macs2.getLocatorSet());
}
- private boolean compareLocatorSets(List<LocatorSet> locatorSet1, List<LocatorSet> locatorSet2) {
+ private static boolean compareLocatorSets(List<LocatorSet> locatorSet1, List<LocatorSet> locatorSet2) {
if (locatorSet1 == null) {
locatorSet1 = Collections.EMPTY_LIST;
}
return;
}
- private void setName(final PhysicalPort physicalPort, final HwvtepPhysicalPortAugmentation inputPhysicalPort) {
+ private static void setName(final PhysicalPort physicalPort,
+ final HwvtepPhysicalPortAugmentation inputPhysicalPort) {
if (inputPhysicalPort.getHwvtepNodeName() != null) {
physicalPort.setName(inputPhysicalPort.getHwvtepNodeName().getValue());
}
}
}
- private Map<InstanceIdentifier<Node>, PhysicalSwitchAugmentation> extractRemovedSwitches(
+ private static Map<InstanceIdentifier<Node>, PhysicalSwitchAugmentation> extractRemovedSwitches(
final Collection<DataTreeModification<Node>> changes, final Class<PhysicalSwitchAugmentation> class1) {
Map<InstanceIdentifier<Node>, PhysicalSwitchAugmentation> result = new HashMap<>();
if (changes != null && !changes.isEmpty()) {
private static final Logger LOG = LoggerFactory.getLogger(TransactCommandAggregator.class);
private final List<TransactCommand> commands = new ArrayList<>();
- private AtomicInteger retryCount = new AtomicInteger(HwvtepSouthboundConstants.CHAIN_RETRY_COUNT);
+ private final AtomicInteger retryCount = new AtomicInteger(HwvtepSouthboundConstants.CHAIN_RETRY_COUNT);
private final HwvtepOperationalState operationalState;
/* stores the modified and deleted data for each child type of each node id
Map<nodeid , Pair < updated, deleted >
}
}
- private boolean isMacOnlyUpdate(final Map<Class<? extends Identifiable>, List<Identifiable>> updatedData,
- final Map<Class<? extends Identifiable>, List<Identifiable>> deletedData) {
+ private static boolean isMacOnlyUpdate(final Map<Class<? extends Identifiable>, List<Identifiable>> updatedData,
+ final Map<Class<? extends Identifiable>, List<Identifiable>> deletedData) {
return updatedData.containsKey(RemoteUcastMacs.class) && updatedData.size() == 1
|| deletedData.containsKey(RemoteUcastMacs.class) && deletedData.size() == 1;
}
- private void extractDataChanged(final InstanceIdentifier<Node> key,
- final DataObjectModification<Node> mod,
- final Map<Class<? extends Identifiable>, List<Identifiable>> updatedData,
- final Map<Class<? extends Identifiable>, List<Identifiable>> deletedData) {
+ private static void extractDataChanged(final InstanceIdentifier<Node> key,
+ final DataObjectModification<Node> mod,
+ final Map<Class<? extends Identifiable>, List<Identifiable>> updatedData,
+ final Map<Class<? extends Identifiable>, List<Identifiable>> deletedData) {
extractDataChanged(mod.getModifiedChildren(), updatedData, deletedData);
DataObjectModification<HwvtepGlobalAugmentation> aug = mod.getModifiedAugmentation(
}
}
- private void extractDataChanged(final Collection<? extends DataObjectModification<? extends DataObject>> children,
- final Map<Class<? extends Identifiable>, List<Identifiable>> updatedData,
- final Map<Class<? extends Identifiable>, List<Identifiable>> deletedData) {
+ private static void extractDataChanged(
+ final Collection<? extends DataObjectModification<? extends DataObject>> children,
+ final Map<Class<? extends Identifiable>, List<Identifiable>> updatedData,
+ final Map<Class<? extends Identifiable>, List<Identifiable>> deletedData) {
if (children == null) {
return;
}
}
}
- private void addToUpdatedData(Map<Class<? extends Identifiable>, List<Identifiable>> updatedData,
- Class<? extends Identifiable> childClass, Identifiable identifiable) {
+ private static void addToUpdatedData(Map<Class<? extends Identifiable>, List<Identifiable>> updatedData,
+ Class<? extends Identifiable> childClass, Identifiable identifiable) {
updatedData.computeIfAbsent(childClass, (cls) -> new ArrayList<>());
updatedData.get(childClass).add(identifiable);
}
return connectionNode.build();
}
- private void setStaticRoutes(final LogicalRouter router, final LogicalRoutersBuilder lrBuilder) {
+ private static void setStaticRoutes(final LogicalRouter router, final LogicalRoutersBuilder lrBuilder) {
if (isRouterHasStaticRoutes(router)) {
List<StaticRoutes> routes = new ArrayList<>();
for (Entry<String, String> entry : router.getStaticRoutesColumn().getData().entrySet()) {
}
}
- private boolean isRouterHasStaticRoutes(final LogicalRouter router) {
+ private static boolean isRouterHasStaticRoutes(final LogicalRouter router) {
return router != null && router.getStaticRoutesColumn() != null
&& router.getStaticRoutesColumn().getData() != null
&& !router.getStaticRoutesColumn().getData().isEmpty();
}
}
- private boolean isRouterHasAcls(final LogicalRouter router) {
+ private static boolean isRouterHasAcls(final LogicalRouter router) {
return router != null && router.getAclBindingColumn() != null
&& router.getAclBindingColumn().getData() != null
&& !router.getAclBindingColumn().getData().isEmpty();
}
}
- private boolean isRouterHasSwitchBindings(final LogicalRouter router) {
+ private static boolean isRouterHasSwitchBindings(final LogicalRouter router) {
return router != null && router.getSwitchBindingColumn() != null
&& router.getSwitchBindingColumn().getData() != null
&& !router.getSwitchBindingColumn().getData().isEmpty();
return null;
}
- private MacAddress getMacAddress(String mac) {
+ private static MacAddress getMacAddress(String mac) {
if (mac.equals(HwvtepSouthboundConstants.UNKNOWN_DST_STRING)) {
return HwvtepSouthboundConstants.UNKNOWN_DST_MAC;
} else {
}
}
- private void setEncapsType(HwvtepPhysicalLocatorAugmentationBuilder tpAugmentationBuilder,
+ private static void setEncapsType(HwvtepPhysicalLocatorAugmentationBuilder tpAugmentationBuilder,
PhysicalLocator locator) {
String encapsType = locator.getEncapsulationTypeColumn().getData();
if (HwvtepSouthboundMapper.createEncapsulationType(encapsType) != null) {
}
}
- private void setDstIp(HwvtepPhysicalLocatorAugmentationBuilder tpAugmentationBuilder,
+ private static void setDstIp(HwvtepPhysicalLocatorAugmentationBuilder tpAugmentationBuilder,
PhysicalLocator locator) {
tpAugmentationBuilder.setDstIp(IpAddressBuilder.getDefaultInstance(locator.getDstIpColumn().getData()));
}
psAugmentationBuilder.setManagedBy(new HwvtepGlobalRef(connectionNodePath));
}
- private void setPhysicalSwitchId(PhysicalSwitchAugmentationBuilder psAugmentationBuilder,
+ private static void setPhysicalSwitchId(PhysicalSwitchAugmentationBuilder psAugmentationBuilder,
PhysicalSwitch phySwitch) {
if (phySwitch.getName() != null) {
psAugmentationBuilder.setHwvtepNodeName(new HwvtepNodeName(phySwitch.getName()));
}
}
- private void setManagementIps(PhysicalSwitchAugmentationBuilder psAugmentationBuilder,
+ private static void setManagementIps(PhysicalSwitchAugmentationBuilder psAugmentationBuilder,
PhysicalSwitch phySwitch) {
if (phySwitch.getManagementIpsColumn() != null && phySwitch.getManagementIpsColumn().getData() != null
&& !phySwitch.getManagementIpsColumn().getData().isEmpty()) {
return nodeKey.getNodeId();
}
- private <T extends DataObject> void deleteEntries(ReadWriteTransaction transaction,
+ private static <T extends DataObject> void deleteEntries(ReadWriteTransaction transaction,
List<InstanceIdentifier<T>> entryIids) {
for (InstanceIdentifier<T> entryIid : entryIids) {
transaction.delete(LogicalDatastoreType.OPERATIONAL, entryIid);
return result;
}
- private void setSwitchFaultStatus(PhysicalSwitchAugmentationBuilder psAugmentationBuilder,
+ private static void setSwitchFaultStatus(PhysicalSwitchAugmentationBuilder psAugmentationBuilder,
PhysicalSwitch phySwitch) {
if (phySwitch.getSwitchFaultStatusColumn() != null && phySwitch.getSwitchFaultStatusColumn().getData() != null
&& !phySwitch.getSwitchFaultStatusColumn().getData().isEmpty()) {
}
}
- private void setBfdLocalConfigs(TunnelsBuilder tunnelsBuilder, Tunnel tunnel) {
+ private static void setBfdLocalConfigs(TunnelsBuilder tunnelsBuilder, Tunnel tunnel) {
Map<String, String> localConfigs = tunnel.getBfdConfigLocalColumn().getData();
if (localConfigs != null && !localConfigs.isEmpty()) {
List<BfdLocalConfigs> localConfigsList = localConfigs.entrySet().stream().map(
}
}
- private void setBfdRemoteConfigs(TunnelsBuilder tunnelsBuilder, Tunnel tunnel) {
+ private static void setBfdRemoteConfigs(TunnelsBuilder tunnelsBuilder, Tunnel tunnel) {
Map<String, String> remoteConfigs = tunnel.getBfdConfigRemoteColumn().getData();
if (remoteConfigs != null && !remoteConfigs.isEmpty()) {
List<BfdRemoteConfigs> remoteConfigsList = remoteConfigs.entrySet().stream().map(
}
- private void setBfdParams(TunnelsBuilder tunnelsBuilder, Tunnel tunnel) {
+ private static void setBfdParams(TunnelsBuilder tunnelsBuilder, Tunnel tunnel) {
Map<String, String> params = tunnel.getBfdParamsColumn().getData();
if (params != null && !params.isEmpty()) {
List<BfdParams> paramsList = params.entrySet().stream().map(
}
}
- private void setBfdStatus(TunnelsBuilder tunnelsBuilder, Tunnel tunnel) {
+ private static void setBfdStatus(TunnelsBuilder tunnelsBuilder, Tunnel tunnel) {
Map<String, String> status = tunnel.getBfdStatusColumn().getData();
if (status != null && !status.isEmpty()) {
List<BfdStatus> statusList = status.entrySet().stream().map(
}
}
- private InstanceIdentifier getKey(InstanceIdentifier<Node> key, DataObjectModification<? extends DataObject> child,
- DataObject data) {
+ private static InstanceIdentifier getKey(InstanceIdentifier<Node> key,
+ DataObjectModification<? extends DataObject> child, DataObject data) {
Class<? extends DataObject> childClass = child.getDataType();
InstanceIdentifier instanceIdentifier = null;
if (LogicalSwitches.class == childClass) {
return (Class<? extends ChildOf<? super HwvtepGlobalAugmentation>>) cls;
}
- private InstanceIdentifier<Node> getWildcardPath() {
- InstanceIdentifier<Node> path = InstanceIdentifier
- .create(NetworkTopology.class)
+ private static InstanceIdentifier<Node> getWildcardPath() {
+ return InstanceIdentifier.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID))
.child(Node.class);
- return path;
}
}
}
- private InstanceIdentifier<Node> createInstanceIdentifier(final String nodeIdString) {
+ private static InstanceIdentifier<Node> createInstanceIdentifier(final String nodeIdString) {
NodeId nodeId = new NodeId(new Uri(nodeIdString));
NodeKey nodeKey = new NodeKey(nodeId);
TopologyKey topoKey = new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID);
private static final Logger LOG = LoggerFactory.getLogger(OvsdbOperGlobalListener.class);
private ListenerRegistration<OvsdbOperGlobalListener> registration;
- private DataBroker db;
+ private final DataBroker db;
private final OvsdbConnectionManager ovsdbConnectionManager;
private final TransactionInvoker txInvoker;
TIMEOUT_FTS.put(iid, ft);
}
- private Node getCreated(DataObjectModification<Node> mod) {
- if ((mod.getModificationType() == DataObjectModification.ModificationType.WRITE)
- && (mod.getDataBefore() == null)) {
+ private static Node getCreated(DataObjectModification<Node> mod) {
+ if (mod.getModificationType() == DataObjectModification.ModificationType.WRITE
+ && mod.getDataBefore() == null) {
return mod.getDataAfter();
}
return null;
}
- private Node getRemoved(DataObjectModification<Node> mod) {
+ private static Node getRemoved(DataObjectModification<Node> mod) {
if (mod.getModificationType() == DataObjectModification.ModificationType.DELETE) {
return mod.getDataBefore();
}
return null;
}
- private Node getUpdated(DataObjectModification<Node> mod) {
+ private static Node getUpdated(DataObjectModification<Node> mod) {
Node node = null;
switch (mod.getModificationType()) {
case SUBTREE_MODIFIED:
return node;
}
- private InstanceIdentifier<Node> getWildcardPath() {
- InstanceIdentifier<Node> path = InstanceIdentifier
- .create(NetworkTopology.class)
+ private static InstanceIdentifier<Node> getWildcardPath() {
+ return InstanceIdentifier.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
.child(Node.class);
- return path;
}
-
}
}
}
- private void initializeOvsdbTopology(final LogicalDatastoreType type) {
+ private static void initializeOvsdbTopology(final LogicalDatastoreType type) {
InstanceIdentifier<Topology> path = InstanceIdentifier
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID));
public void setBridgesReconciliationInclusionList(String bridgeListStr) {
if (bridgeListStr != null && !bridgeListStr.equals("")) {
- southboundProvider.setBridgesReconciliationInclusionList(getBridgesList(bridgeListStr));
+ SouthboundProvider.setBridgesReconciliationInclusionList(getBridgesList(bridgeListStr));
}
}
public void setBridgesReconciliationExclusionList(String bridgeListStr) {
if (bridgeListStr != null && !bridgeListStr.equals("")) {
- southboundProvider.setBridgesReconciliationExclusionList(getBridgesList(bridgeListStr));
+ SouthboundProvider.setBridgesReconciliationExclusionList(getBridgesList(bridgeListStr));
}
}
- private List<String> getBridgesList(final String bridgeListStr) {
+ private static List<String> getBridgesList(final String bridgeListStr) {
List<String> bridgeList = new ArrayList<>();
StringTokenizer tokenizer = new StringTokenizer(bridgeListStr, ",");
while (tokenizer.hasMoreTokens()) {
} else if (paramEntry.getKey().equalsIgnoreCase(BRIDGES_RECONCILIATION_INCLUSION_LIST_PARAM)) {
String bridgeListStr = (String)paramEntry.getValue();
if (bridgeListStr != null && !bridgeListStr.equals("")) {
- southboundProvider.setBridgesReconciliationInclusionList(getBridgesList(bridgeListStr));
+ SouthboundProvider.setBridgesReconciliationInclusionList(getBridgesList(bridgeListStr));
}
} else if (paramEntry.getKey().equalsIgnoreCase(BRIDGES_RECONCILIATION_EXCLUSION_LIST_PARAM)) {
String bridgeListStr = (String)paramEntry.getValue();
if (bridgeListStr != null && !bridgeListStr.equals("")) {
- southboundProvider.setBridgesReconciliationExclusionList(getBridgesList(bridgeListStr));
+ SouthboundProvider.setBridgesReconciliationExclusionList(getBridgesList(bridgeListStr));
}
}
}
TransactUtils.extractUpdated(events, OvsdbNodeAugmentation.class));
}
- private void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
- final Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> original,
- final Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> updated) {
+ private static void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
+ final Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> original,
+ final Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> updated) {
for (final Map.Entry<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> originalEntry :
original.entrySet()) {
}
}
- private void deleteAutoAttach(final TransactionBuilder transaction,
+ private static void deleteAutoAttach(final TransactionBuilder transaction,
final InstanceIdentifier<OvsdbNodeAugmentation> ovsdbNodeIid,
final Uuid autoattachUuid) {
}
}
- private void updateAutoAttach(final TransactionBuilder transaction, final BridgeOperationalState state,
+ private static void updateAutoAttach(final TransactionBuilder transaction, final BridgeOperationalState state,
final InstanceIdentifier<OvsdbNodeAugmentation> iid,
final OvsdbNodeAugmentation ovsdbNode) {
instanceIdentifierCodec);
}
- private void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
+ private static void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
final Map<InstanceIdentifier<QosEntries>, QosEntries> createdOrUpdated,
final InstanceIdentifierCodec instanceIdentifierCodec) {
for (Entry<InstanceIdentifier<QosEntries>, QosEntries> qosMapEntry: createdOrUpdated.entrySet()) {
TransactUtils.extractCreatedOrUpdated(modifications, Node.class), instanceIdentifierCodec);
}
- private void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
+ private static void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
final Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation>
createdTerminationPoints,
final Map<InstanceIdentifier<Node>, Node> nodes, final InstanceIdentifierCodec instanceIdentifierCodec) {
}
- private void createInterface(
+ private static void createInterface(
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
ovsInterface.setName(terminationPoint.getName());
}
}
- private void createPort(
+ private static void createPort(
final OvsdbTerminationPointAugmentation terminationPoint,
final Port port, final String interfaceUuid, final String opendaylightIid) {
createPortExternalIds(terminationPoint, port, opendaylightIid);
}
- private void createOfPort(
+ private static void createOfPort(
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
- private void createOfPortRequest(
+ private static void createOfPortRequest(
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
- private void createInterfaceOptions(
+ private static void createInterfaceOptions(
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
- private void createInterfaceExternalIds(
+ private static void createInterfaceExternalIds(
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
- private void createInterfaceOtherConfig(
+ private static void createInterfaceOtherConfig(
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
- private void createInterfaceLldp(
+ private static void createInterfaceLldp(
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
- private void createInterfaceBfd(final OvsdbTerminationPointAugmentation terminationPoint,
- final Interface ovsInterface) {
+ private static void createInterfaceBfd(final OvsdbTerminationPointAugmentation terminationPoint,
+ final Interface ovsInterface) {
try {
Map<InterfaceBfdKey, InterfaceBfd> interfaceBfdList = terminationPoint.getInterfaceBfd();
}
}
- private void createPortExternalIds(
- final OvsdbTerminationPointAugmentation terminationPoint,
+ private static void createPortExternalIds(final OvsdbTerminationPointAugmentation terminationPoint,
final Port port, final String opendaylightIid) {
// Set the iid external_id
}
}
- private void createPortVlanTag(
+ private static void createPortVlanTag(
final OvsdbTerminationPointAugmentation terminationPoint,
final Port port) {
}
}
- private void createPortVlanTrunk(
+ private static void createPortVlanTrunk(
final OvsdbTerminationPointAugmentation terminationPoint,
final Port port) {
}
}
- private void createPortVlanMode(
+ private static void createPortVlanMode(
final OvsdbTerminationPointAugmentation terminationPoint,
final Port port) {
if (terminationPoint.getVlanMode() != null) {
}
}
- private void createPortOtherConfig(
+ private static void createPortOtherConfig(
final OvsdbTerminationPointAugmentation terminationPoint,
final Port ovsPort) {
Map<PortOtherConfigsKey, PortOtherConfigs> portOtherConfigs =
}
}
- private LoadingCache<NodeKey, NodeConnectionMetadata> buildBridgeNodeCache() {
+ private static LoadingCache<NodeKey, NodeConnectionMetadata> buildBridgeNodeCache() {
return CacheBuilder.newBuilder()
.expireAfterWrite(BRIDGE_CACHE_TIMEOUT_IN_SECONDS, TimeUnit.SECONDS)
.build(new CacheLoader<NodeKey, NodeConnectionMetadata>() {
@SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
justification = "https://github.com/spotbugs/spotbugs/issues/811")
- private Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation>
+ private static Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation>
filterTerminationPointsForBridge(NodeKey nodeKey,
Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation>
terminationPoints) {
ovsdbNodeBuilder.setOpenvswitchExternalIds(externalIdsList);
}
- private void setInterfaceTypes(
+ private static void setInterfaceTypes(
OvsdbNodeAugmentationBuilder ovsdbNodeBuilder,
OpenVSwitch openVSwitch) {
try {
}
}
- private void setDataPathTypes(
- OvsdbNodeAugmentationBuilder ovsdbNodeBuilder,
- OpenVSwitch openVSwitch) {
+ private static void setDataPathTypes(OvsdbNodeAugmentationBuilder ovsdbNodeBuilder, OpenVSwitch openVSwitch) {
try {
Set<String> dptypes = openVSwitch.getDatapathTypesColumn()
.getData();
}
}
- private void setOvsVersion(OvsdbNodeAugmentationBuilder ovsdbNodeBuilder, OpenVSwitch openVSwitch) {
+ private static void setOvsVersion(OvsdbNodeAugmentationBuilder ovsdbNodeBuilder, OpenVSwitch openVSwitch) {
try {
ovsdbNodeBuilder.setOvsVersion(openVSwitch.getOvsVersionColumn().getData().iterator().next());
} catch (NoSuchElementException e) {
}
}
- private void setDbVersion(OvsdbNodeAugmentationBuilder ovsdbNodeBuilder, OpenVSwitch openVSwitch) {
+ private static void setDbVersion(OvsdbNodeAugmentationBuilder ovsdbNodeBuilder, OpenVSwitch openVSwitch) {
try {
ovsdbNodeBuilder.setDbVersion(openVSwitch.getDbVersionColumn().getData().iterator().next());
} catch (NoSuchElementException e) {
}
}
- private AutoattachKey getAutoAttachKeyToRemove(Node node, UUID autoAttachUuid) {
+ private static AutoattachKey getAutoAttachKeyToRemove(Node node, UUID autoAttachUuid) {
final Map<AutoattachKey, Autoattach> autoAttachList =
node.augmentation(OvsdbNodeAugmentation.class).getAutoattach();
if (autoAttachList == null || autoAttachList.isEmpty()) {
}
}
- private void setMappings(AutoattachBuilder autoAttachBuilder,
+ private static void setMappings(AutoattachBuilder autoAttachBuilder,
AutoAttach autoAttach) {
final Map<Long, Long> mappings = autoAttach.getMappingsColumn().getData();
final List<Mappings> mappingsList = new ArrayList<>();
public class OvsdbControllerRemovedCommand extends AbstractTransactionCommand {
private final InstanceIdentifierCodec instanceIdentifierCodec;
- private Map<UUID, Bridge> oldBridgeRows;
- private Map<UUID, Controller> removedControllerRows;
- private Map<UUID, Bridge> updatedBridgeRows;
+ private final Map<UUID, Bridge> oldBridgeRows;
+ private final Map<UUID, Controller> removedControllerRows;
+ private final Map<UUID, Bridge> updatedBridgeRows;
public OvsdbControllerRemovedCommand(InstanceIdentifierCodec instanceIdentifierCodec, OvsdbConnectionInstance key,
TableUpdates updates, DatabaseSchema dbSchema) {
}
}
- private void deleteControllers(ReadWriteTransaction transaction,
+ private static void deleteControllers(ReadWriteTransaction transaction,
List<InstanceIdentifier<ControllerEntry>> controllerEntryIids) {
for (InstanceIdentifier<ControllerEntry> controllerEntryIid: controllerEntryIids) {
transaction.delete(LogicalDatastoreType.OPERATIONAL, controllerEntryIid);
new Uri(SouthboundConstants.QOS_URI_PREFIX + "://" + qosUuid.toString())));
}
- private void updateIfIndex(final Interface interf,
+ private static void updateIfIndex(final Interface interf,
final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
Set<Long> ifIndexSet = null;
try {
}
}
- private void updateMac(final Interface interf,
- final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
+ private static void updateMac(final Interface interf,
+ final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
Set<String> macSet = null;
try {
if (interf.getMacColumn() != null) {
}
}
- private void updateMacInUse(final Interface interf,
- final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
+ private static void updateMacInUse(final Interface interf,
+ final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
Set<String> macInUseSet = null;
try {
if (interf.getMacInUseColumn() != null) {
}
}
- private void updateInterfaceLldp(final Interface interf,
+ private static void updateInterfaceLldp(final Interface interf,
final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
try {
}
}
- private void updateInterfaceBfdStatus(final Interface interf,
+ private static void updateInterfaceBfdStatus(final Interface interf,
final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
try {
}
}
- private void updateInterfaceBfd(final Interface interf,
+ private static void updateInterfaceBfd(final Interface interf,
final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
try {
}
}
- private void updateInterfacePolicing(final Interface interf,
+ private static void updateInterfacePolicing(final Interface interf,
final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
Long ingressPolicingRate = null;
}
}
- private void setOtherConfig(ReadWriteTransaction transaction,
+ private static void setOtherConfig(ReadWriteTransaction transaction,
QosEntriesBuilder qosEntryBuilder, Qos oldQos, Qos qos,
InstanceIdentifier<Node> nodeIId) {
Map<String, String> oldOtherConfigs = null;
}
}
- private void removeOldConfigs(ReadWriteTransaction transaction,
+ private static void removeOldConfigs(ReadWriteTransaction transaction,
QosEntriesBuilder qosEntryBuilder, Map<String, String> oldOtherConfigs,
Qos qos, InstanceIdentifier<Node> nodeIId) {
InstanceIdentifier<QosEntries> qosIId = nodeIId
}
}
- private void setNewOtherConfigs(QosEntriesBuilder qosEntryBuilder,
+ private static void setNewOtherConfigs(QosEntriesBuilder qosEntryBuilder,
Map<String, String> otherConfig) {
List<QosOtherConfig> otherConfigList = new ArrayList<>();
for (Entry<String, String> entry : otherConfig.entrySet()) {
qosEntryBuilder.setQosOtherConfig(otherConfigList);
}
- private void setExternalIds(ReadWriteTransaction transaction,
+ private static void setExternalIds(ReadWriteTransaction transaction,
QosEntriesBuilder qosEntryBuilder, Qos oldQos, Qos qos,
InstanceIdentifier<Node> nodeIId) {
Map<String, String> oldExternalIds = null;
}
}
- private void removeOldExternalIds(ReadWriteTransaction transaction,
+ private static void removeOldExternalIds(ReadWriteTransaction transaction,
QosEntriesBuilder qosEntryBuilder, Map<String, String> oldExternalIds,
Qos qos, InstanceIdentifier<Node> nodeIId) {
InstanceIdentifier<QosEntries> qosIId = nodeIId
}
}
- private void setNewExternalIds(QosEntriesBuilder qosEntryBuilder,
+ private static void setNewExternalIds(QosEntriesBuilder qosEntryBuilder,
Map<String, String> externalIds) {
List<QosExternalIds> externalIdsList = new ArrayList<>();
for (Entry<String, String> entry : externalIds.entrySet()) {
}
}
- private void removeOldQueues(ReadWriteTransaction transaction,
+ private static void removeOldQueues(ReadWriteTransaction transaction,
QosEntriesBuilder qosEntryBuilder, Map<Long, UUID> oldQueueList,
Qos qos, InstanceIdentifier<Node> nodeIId) {
InstanceIdentifier<QosEntries> qosIId = nodeIId
return SouthboundConstants.QUEUE_URI_PREFIX + "://" + queue.getUuid().toString();
}
- private void setOtherConfig(ReadWriteTransaction transaction,
+ private static void setOtherConfig(ReadWriteTransaction transaction,
QueuesBuilder queuesBuilder, Queue oldQueue, Queue queue,
InstanceIdentifier<Node> nodeIId) {
Map<String, String> oldOtherConfigs = null;
}
}
- private void removeOldConfigs(ReadWriteTransaction transaction,
+ private static void removeOldConfigs(ReadWriteTransaction transaction,
QueuesBuilder queuesBuilder, Map<String, String> oldOtherConfigs,
Queue queue, InstanceIdentifier<Node> nodeIId) {
InstanceIdentifier<Queues> queueIId = nodeIId
}
}
- private void setNewOtherConfigs(QueuesBuilder queuesBuilder,
+ private static void setNewOtherConfigs(QueuesBuilder queuesBuilder,
Map<String, String> otherConfig) {
List<QueuesOtherConfig> otherConfigList = new ArrayList<>();
for (Entry<String, String> entry : otherConfig.entrySet()) {
queuesBuilder.setQueuesOtherConfig(otherConfigList);
}
- private void setExternalIds(ReadWriteTransaction transaction,
+ private static void setExternalIds(ReadWriteTransaction transaction,
QueuesBuilder queuesBuilder, Queue oldQueue, Queue queue,
InstanceIdentifier<Node> nodeIId) {
Map<String, String> oldExternalIds = null;
}
}
- private void removeOldExternalIds(ReadWriteTransaction transaction,
+ private static void removeOldExternalIds(ReadWriteTransaction transaction,
QueuesBuilder queuesBuilder, Map<String, String> oldExternalIds,
Queue queue, InstanceIdentifier<Node> nodeIId) {
InstanceIdentifier<Queues> queueIId = nodeIId
}
}
- private void setNewExternalIds(QueuesBuilder queuesBuilder,
+ private static void setNewExternalIds(QueuesBuilder queuesBuilder,
Map<String, String> externalIds) {
List<QueuesExternalIds> externalIdsList = new ArrayList<>();
for (Entry<String, String> entry : externalIds.entrySet()) {
Mockito.verify(transaction).add(any(Operation.class));
}
- private Object setField(final String fieldName) throws Exception {
+ private static Object setField(final String fieldName) throws Exception {
Field field = Operations.class.getDeclaredField(fieldName);
field.setAccessible(true);
field.set(field.get(Operations.class), mock(Operations.class));
verify(transaction).add(any(Operation.class));
}
- private Object setField(final String fieldName) throws Exception {
+ private static Object setField(final String fieldName) throws Exception {
Field field = Operations.class.getDeclaredField(fieldName);
field.setAccessible(true);
field.set(field.get(Operations.class), mock(Operations.class));
instanceIdentifierCodec));
}
- private Object setField(final String fieldName) throws Exception {
+ private static Object setField(final String fieldName) throws Exception {
Field field = Operations.class.getDeclaredField(fieldName);
field.setAccessible(true);
field.set(field.get(Operations.class), mock(Operations.class));
.build();
}
- private Map<InstanceIdentifier<?>, DataObject> createExpectedConfigurationChanges(final Node bridgeNode) {
+ private static Map<InstanceIdentifier<?>, DataObject> createExpectedConfigurationChanges(final Node bridgeNode) {
OvsdbBridgeAugmentation ovsdbBridge = bridgeNode.augmentation(OvsdbBridgeAugmentation.class);
Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
return combinedOptions;
}
- private Option[] getOtherOptions() {
+ private static Option[] getOtherOptions() {
return new Option[] {
vmOption("-javaagent:../jars/org.jacoco.agent.jar=destfile=../../jacoco-it.exec"),
keepRuntimeFolder()
super.getLoggingOption());
}
- private Option[] getPropertiesOptions() {
+ private static Option[] getPropertiesOptions() {
Properties props = new Properties(System.getProperties());
String ipAddressStr = props.getProperty(SouthboundITConstants.SERVER_IPADDRESS,
SouthboundITConstants.DEFAULT_SERVER_IPADDRESS);
}
}
- private Boolean getOvsdbTopology() {
+ private static Boolean getOvsdbTopology() {
LOG.info("getOvsdbTopology: looking for {}...", SouthboundUtils.OVSDB_TOPOLOGY_ID.getValue());
Boolean found = false;
final TopologyId topologyId = SouthboundUtils.OVSDB_TOPOLOGY_ID;
topology);
}
- private Node connectOvsdbNode(final ConnectionInfo connectionInfo) throws InterruptedException {
+ private static Node connectOvsdbNode(final ConnectionInfo connectionInfo) throws InterruptedException {
final InstanceIdentifier<Node> iid = SouthboundUtils.createInstanceIdentifier(connectionInfo);
Assert.assertTrue(
mdsalUtils.put(LogicalDatastoreType.CONFIGURATION, iid, SouthboundUtils.createNode(connectionInfo)));
return node;
}
- private void waitForOperationalCreation(InstanceIdentifier<Node> iid) throws InterruptedException {
+ private static void waitForOperationalCreation(InstanceIdentifier<Node> iid) throws InterruptedException {
synchronized (OPERATIONAL_LISTENER) {
long start = System.currentTimeMillis();
LOG.info("Waiting for OPERATIONAL DataChanged creation on {}", iid);
}
}
- private void waitForOperationalUpdate(InstanceIdentifier<Node> iid) throws InterruptedException {
+ private static void waitForOperationalUpdate(InstanceIdentifier<Node> iid) throws InterruptedException {
synchronized (OPERATIONAL_LISTENER) {
long start = System.currentTimeMillis();
LOG.info("Waiting for OPERATIONAL DataChanged update on {}", iid);
}
}
- private List<ControllerEntry> createControllerEntry(String controllerTarget) {
+ private static List<ControllerEntry> createControllerEntry(String controllerTarget) {
List<ControllerEntry> controllerEntriesList = new ArrayList<>();
controllerEntriesList.add(new ControllerEntryBuilder()
.setTarget(new Uri(controllerTarget))
return protocolList;
}
- private OvsdbTerminationPointAugmentationBuilder createGenericOvsdbTerminationPointAugmentationBuilder() {
+ private static OvsdbTerminationPointAugmentationBuilder createGenericOvsdbTerminationPointAugmentationBuilder() {
OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointAugmentationBuilder =
new OvsdbTerminationPointAugmentationBuilder();
ovsdbTerminationPointAugmentationBuilder.setInterfaceType(
return ovsdbTerminationPointAugmentationBuilder;
}
- private OvsdbTerminationPointAugmentationBuilder createGenericDpdkOvsdbTerminationPointAugmentationBuilder(
+ private static OvsdbTerminationPointAugmentationBuilder createGenericDpdkOvsdbTerminationPointAugmentationBuilder(
final String portName) {
OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
createGenericOvsdbTerminationPointAugmentationBuilder();
return ovsdbTerminationBuilder;
}
- private OvsdbTerminationPointAugmentationBuilder createSpecificDpdkOvsdbTerminationPointAugmentationBuilder(
+ private static OvsdbTerminationPointAugmentationBuilder createSpecificDpdkOvsdbTerminationPointAugmentationBuilder(
String testPortname,Class<? extends InterfaceTypeBase> dpdkIfType) {
OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
createGenericOvsdbTerminationPointAugmentationBuilder();
return ovsdbTerminationBuilder;
}
- private boolean addTerminationPoint(final NodeId bridgeNodeId, final String portName,
- final OvsdbTerminationPointAugmentationBuilder
- ovsdbTerminationPointAugmentationBuilder)
+ private static boolean addTerminationPoint(final NodeId bridgeNodeId, final String portName,
+ final OvsdbTerminationPointAugmentationBuilder
+ ovsdbTerminationPointAugmentationBuilder)
throws InterruptedException {
InstanceIdentifier<Node> portIid = SouthboundMapper.createInstanceIdentifier(bridgeNodeId);
}
}
- private OvsdbNodeAugmentation getOvsdbNode(ConnectionInfo connectionInfo, LogicalDatastoreType store) {
+ private static OvsdbNodeAugmentation getOvsdbNode(ConnectionInfo connectionInfo, LogicalDatastoreType store) {
InstanceIdentifier<Node> nodeIid = SouthboundUtils.createInstanceIdentifier(connectionInfo);
Node node = mdsalUtils.read(store, nodeIid);
Assert.assertNotNull(node);
return ovsdbNodeAugmentation;
}
- private OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo) {
+ private static OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo) {
return getBridge(connectionInfo, SouthboundITConstants.BRIDGE_NAME);
}
* @param store defined by the <code>LogicalDatastoreType</code> enumeration
* @return <code>store</code> type data store contents
*/
- private OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName,
- LogicalDatastoreType store) {
+ private static OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName,
+ LogicalDatastoreType store) {
Node bridgeNode = getBridgeNode(connectionInfo, bridgeName, store);
Assert.assertNotNull(bridgeNode);
OvsdbBridgeAugmentation ovsdbBridgeAugmentation = bridgeNode.augmentation(OvsdbBridgeAugmentation.class);
* @see SouthboundIT#getBridge(ConnectionInfo, String, LogicalDatastoreType)
* @return <code>LogicalDatastoreType.OPERATIONAL</code> type data store contents
*/
- private OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName) {
+ private static OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName) {
return getBridge(connectionInfo, bridgeName, LogicalDatastoreType.OPERATIONAL);
}
* @param store defined by the <code>LogicalDatastoreType</code> enumeration
* @return <code>store</code> type data store contents
*/
- private Node getBridgeNode(ConnectionInfo connectionInfo, String bridgeName, LogicalDatastoreType store) {
+ private static Node getBridgeNode(ConnectionInfo connectionInfo, String bridgeName, LogicalDatastoreType store) {
InstanceIdentifier<Node> bridgeIid =
SouthboundUtils.createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName));
return mdsalUtils.read(store, bridgeIid);
* @param bridgeName the bridge name
* @return <code>LogicalDatastoreType.OPERATIONAL</code> type data store contents
*/
- private Node getBridgeNode(ConnectionInfo connectionInfo, String bridgeName) {
+ private static Node getBridgeNode(ConnectionInfo connectionInfo, String bridgeName) {
return getBridgeNode(connectionInfo, bridgeName, LogicalDatastoreType.OPERATIONAL);
}
* @param index the index we're interested in
* @return the augmentation (or {@code null} if none)
*/
- private OvsdbTerminationPointAugmentation getOvsdbTerminationPointAugmentation(
+ private static OvsdbTerminationPointAugmentation getOvsdbTerminationPointAugmentation(
ConnectionInfo connectionInfo, String bridgeName, LogicalDatastoreType store, int index) {
Map<TerminationPointKey, TerminationPoint> tpList = getBridgeNode(connectionInfo, bridgeName, store)
- .nonnullTerminationPoint();
+ .getTerminationPoint();
if (tpList == null) {
return null;
}
*
* @see <code>SouthboundIT.generatePortExternalIdsTestCases()</code> for specific test case information
*/
- private <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDTerminationPoint(
+ private static <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDTerminationPoint(
KeyValueBuilder<T> builder, String prefix, SouthboundTerminationPointHelper<I, T> helper)
throws InterruptedException {
final int terminationPointTestIndex = 0;
}
}
- private List<Set<Integer>> generateVlanSets() {
+ private static List<Set<Integer>> generateVlanSets() {
int min = 0;
int max = 4095;
return Lists.newArrayList(
Sets.newHashSet(min, max, min + 1, max - 1, (max - min) / 2));
}
- private List<Trunks> buildTrunkList(Set<Integer> trunkSet) {
+ private static List<Trunks> buildTrunkList(Set<Integer> trunkSet) {
List<Trunks> trunkList = new ArrayList<>();
for (Integer trunk : trunkSet) {
TrunksBuilder trunkBuilder = new TrunksBuilder();
Map<I, T> readValues(OvsdbBridgeAugmentation augmentation);
}
- private <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDBridge(String prefix,
+ private static <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDBridge(String prefix,
KeyValueBuilder<T> builder, SouthboundBridgeHelper<I, T> helper) throws InterruptedException {
ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portNumber);
// updateFromTestCases represent the original test case value. updateToTestCases represent the new value after
return null;
}
- private <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDQueue(
+ private static <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDQueue(
KeyValueBuilder<T> builder, String prefix, SouthboundQueueHelper<I, T> helper)
throws InterruptedException {
}
- private <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDQos(
+ private static <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDQos(
KeyValueBuilder<T> builder, String prefix, SouthboundQosHelper<I, T> helper)
throws InterruptedException {
return false;
}
- private List<BridgeExternalIds> setBridgeExternalIds() {
+ private static List<BridgeExternalIds> setBridgeExternalIds() {
List<BridgeExternalIds> externalIdsList = new ArrayList<>();
externalIdsList.add(new BridgeExternalIdsBuilder()
.setBridgeExternalIdKey(CREATED_BY)
Code Review / ovsdb.git / commitdiff