}
} catch (InterruptedException | ExecutionException e) {
readOpStatus.set(FlowCounter.OperationStatus.FAILURE.status());
- LOG.error("Error {}", e);
+ LOG.error("Error", e);
}
}
}
return Collections.emptySet();
}
} catch (InterruptedException | ExecutionException e) {
- LOG.error("Failed to read connected nodes {}", e);
+ LOG.error("Failed to read connected nodes", e);
}
return nodeIds;
}
} catch (MalformedObjectNameException | InstanceAlreadyExistsException | MBeanRegistrationException
| NotCompliantMBeanException e) {
rpcResultBuilder = RpcResultBuilder.failed();
- LOG.warn("Exception occurred: {} ", e);
+ LOG.warn("Exception occurred", e);
}
return Futures.immediateFuture(rpcResultBuilder.build());
}
@Override
public void onFailure(Throwable throwable) {
- LOG.error("Table addition Failed. Error: {}", throwable);
+ LOG.error("Table addition Failed.", throwable);
if (failedWrites.incrementAndGet() == totalTables) {
writeOpStatus.set(FlowCounter.OperationStatus.FAILURE.status());
}
public boolean isEntityOwned(final String nodeId) {
EntityOwnershipState state = ownershipStateCache.get(nodeId);
if (state == null) {
- LOG.debug("The ownership state for node {} is not cached. Retrieving from the EOS Datastore");
+ LOG.debug("The ownership state for node {} is not cached. Retrieving from the EOS Datastore", nodeId);
Optional<EntityOwnershipState> status = getCurrentOwnershipStatus(nodeId);
if (status.isPresent()) {
state = status.get();
@Override
public void onFailure(Throwable throwable) {
- LOG.error("Stale Flow creation failed {}", throwable);
+ LOG.error("Stale Flow creation failed", throwable);
}
}, MoreExecutors.directExecutor());
@Override
public void onFailure(Throwable throwable) {
- LOG.debug("Stale entity removal failed {}", throwable);
+ LOG.debug("Stale entity removal failed", throwable);
}
}, MoreExecutors.directExecutor());
}
@Override
public void onFailure(Throwable throwable) {
- LOG.error("Stale Group creation failed {}", throwable);
+ LOG.error("Stale Group creation failed", throwable);
}
}, MoreExecutors.directExecutor());
@Override
public void onFailure(Throwable throwable) {
- LOG.error("Stale Meter creation failed {}", throwable);
+ LOG.error("Stale Meter creation failed", throwable);
}
}, MoreExecutors.directExecutor());
}
return true;
}
} catch (ParseException e) {
- LOG.warn("Timestamp parsing error {}", e);
+ LOG.warn("Timestamp parsing error", e);
}
LOG.debug("Fresh operational not present: {}", nodeId.getValue());
return false;
dataBroker.registerDataTreeChangeListener(dtiToNodeConnectorState,
NodeConnectorInventoryEventTranslator.this));
} catch (Exception e) {
- LOG.error("DataTreeChangeListeners registration failed: {}", e);
+ LOG.error("DataTreeChangeListeners registration failed", e);
throw new IllegalStateException("NodeConnectorInventoryEventTranslator startup failed!", e);
}
LOG.info("NodeConnectorInventoryEventTranslator has started.");
listenerRegistration = looper.loopUntilNoException(
() -> dataBroker.registerDataTreeChangeListener(identifier, DefaultConfigPusher.this));
} catch (Exception e) {
- LOG.error("DataTreeChangeListener registration failed: {}", e);
+ LOG.error("DataTreeChangeListener registration failed", e);
throw new IllegalStateException("DefaultConfigPusher startup failed!", e);
}
LOG.info("DefaultConfigPusher has started.");
try {
ethPkt.deserialize(payload, 0, payload.length * NetUtils.NUM_BITS_IN_A_BYTE);
} catch (PacketException e) {
- LOG.warn("Failed to decode LLDP packet {}", e);
+ LOG.warn("Failed to decode LLDP packet", e);
return nodeConnectorRef;
}
LOG.error("getLong", new BufferException("Container is too small for the number of requested bits"));
}
if (numBits > data.length * NetUtils.NUM_BITS_IN_A_BYTE) {
- try {
- throw new BufferException("Trying to read more bits than contained in the data buffer");
- } catch (final BufferException e) {
- LOG.error("", e);
- }
+ LOG.error("getLong", new BufferException("Trying to read more bits than contained in the data buffer"));
}
int startOffset = data.length * NetUtils.NUM_BITS_IN_A_BYTE - numBits;
try {
try {
ip = InetAddress.getByAddress(NetUtils.intToByteArray4(address));
} catch (final UnknownHostException e) {
- LOG.error("", e);
+ LOG.error("Failed to convert {}", address, e);
}
return ip;
}
try {
return InetAddress.getByAddress(address);
} catch (final UnknownHostException e) {
- LOG.error("", e);
+ LOG.error("Failed to convert {}", address, e);
}
return null;
}
try {
address = InetAddress.getByName(addressString);
} catch (final UnknownHostException e) {
- LOG.error("", e);
+ LOG.error("Failed to convert {}", addressString, e);
}
return address;
}
callback = null;
}
} else {
- LOG.warn("Ignoring failure {} for completed message", cause);
+ LOG.warn("Ignoring failure for completed message", cause);
}
}
| NotCompliantMBeanException
| MBeanRegistrationException
| InstanceAlreadyExistsException e) {
- LOG.warn("Error registering MBean {}", e);
+ LOG.warn("Error registering MBean {}", beanName, e);
}
}
} catch (InstanceNotFoundException
| MBeanRegistrationException
| MalformedObjectNameException e) {
- LOG.warn("Error unregistering MBean {}", e);
+ LOG.warn("Error unregistering MBean {}", beanName, e);
}
}
}
@Override
public void onFailure(final Throwable throwable) {
- LOG.info("onFailure - getGenerationIdFromDevice RPC error {}", throwable);
+ LOG.info("onFailure - getGenerationIdFromDevice RPC error", throwable);
finalFuture.setException(new ExecutionException(throwable));
}
}, MoreExecutors.directExecutor());
@Override
public void onFailure(final Throwable throwable) {
- LOG.warn("Failure multipart response for Experimenter-Mp request. Exception: {}", throwable);
+ LOG.warn("Failure multipart response for Experimenter-Mp request", throwable);
finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed()
.withError(ErrorType.RPC, "Future error", throwable).build());
}
@Override
public void onFailure(final Throwable throwable) {
- LOG.error("Failure multipart response for table features request. Exception: {}", throwable);
+ LOG.error("Failure multipart response for table features request", throwable);
finalFuture.set(RpcResultBuilder.<UpdateTableOutput>failed()
.withError(ErrorType.RPC, "Future error", throwable).build());
}
@Override
public void onFailure(final Throwable throwable) {
- LOG.warn("Failure multipart response for Experimenter-Mp request. Exception: {}", throwable);
+ LOG.warn("Failure multipart response for Experimenter-Mp request", throwable);
future.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed()
.withError(ErrorType.RPC, "Future error", throwable).build());
}
@Override
public void onFailure(Throwable throwable) {
- LOG.error("Failure multipart response for table features request. Exception: {}", throwable);
+ LOG.error("Failure multipart response for table features request", throwable);
finalFuture.set(RpcResultBuilder.<UpdateTableOutput>failed()
.withError(ErrorType.RPC, "Future error", throwable).build());
}
}
}
} catch (RuntimeException ex) {
- LOG.error("Error {}", ex);
+ LOG.error("Error", ex);
return false;
}
if (scenarioHandler.isFinishedOK()) {
}
}
} catch (InterruptedException ex) {
- LOG.error("Error {}", ex);
+ LOG.error("Error", ex);
} finally {
LOG.debug("listening client shutting down");
try {
bossGroup.shutdownGracefully().get();
LOG.debug("listening client shutdown succesful");
} catch (InterruptedException | ExecutionException e) {
- LOG.error("Error {}", e);
+ LOG.error("Error", e);
}
}
scenarioDone.set(true);
WaitForMessageEvent event = (WaitForMessageEvent) peek;
event.setHeaderReceived(ofMsg.poll(2000, TimeUnit.MILLISECONDS));
} catch (InterruptedException e) {
- LOG.error("Error {}", e);
+ LOG.error("Error", e);
break;
}
} else if (peek instanceof SendEvent) {
try {
sleep(sleepBetweenTries);
} catch (InterruptedException e) {
- LOG.error("Error {}", e);
+ LOG.error("Error", e);
}
}
LOG.debug("Scenario finished");
}
}
} catch (InterruptedException ex) {
- LOG.error("Error {}", ex);
+ LOG.error("Error", ex);
} finally {
LOG.debug("shutting down");
try {
group.shutdownGracefully().get();
LOG.debug("shutdown succesful");
} catch (InterruptedException | ExecutionException e) {
- LOG.error("Error {}", e);
+ LOG.error("Error", e);
}
}
scenarioDone.set(true);
LOG.debug("Sleeping");
return true;
} catch (InterruptedException e) {
- LOG.error("Error {}", e);
+ LOG.error("Error", e);
}
return false;
}
}
}
} catch (InterruptedException ex) {
- LOG.error("Error {}", ex);
+ LOG.error("Error", ex);
} finally {
LOG.debug("shutting down");
try {
group.shutdownGracefully().get();
LOG.debug("shutdown succesful");
} catch (InterruptedException | ExecutionException e) {
- LOG.error("Error {}", e);
+ LOG.error("Error", e);
}
}
scenarioDone.set(true);
@Override
public void onFailure(Throwable throwable) {
- LOG.error("Status of Group Data Loaded Transaction : failure. Reason : {}", throwable);
+ LOG.error("Status of Group Data Loaded Transaction : failure.", throwable);
ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
}
}, MoreExecutors.directExecutor());
@Override
public void onFailure(Throwable throwable) {
- LOG.error("Status of Group Data Loaded Transaction : failure. Reason : {}", throwable);
+ LOG.error("Status of Group Data Loaded Transaction : failure.", throwable);
ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
}
}, MoreExecutors.directExecutor());
*/
package org.opendaylight.openflowplugin.test;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.List;
import org.eclipse.osgi.framework.console.CommandInterpreter;
import org.eclipse.osgi.framework.console.CommandProvider;
}
+ @SuppressFBWarnings("SLF4J_SIGN_ONLY_FORMAT")
public void _flowStats(CommandInterpreter ci) {
int flowCount = 0;
int flowStatsCount = 0;
@Override
public void onFailure(final Throwable throwable) {
- LOG.error("Status of Group Data Loaded Transaction : failure. Reason : {}", throwable);
+ LOG.error("Status of Group Data Loaded Transaction : failure.", throwable);
ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
}
}, MoreExecutors.directExecutor());
@Override
public void onFailure(final Throwable throwable) {
- LOG.error("Status of Group Data Loaded Transaction : failure. Reason : {}", throwable);
+ LOG.error("Status of Group Data Loaded Transaction : failure.", throwable);
ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
}
}, MoreExecutors.directExecutor());
*/
package org.opendaylight.openflowplugin.test;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.FlowTopologyDiscoveryListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkDiscovered;
private static final class TopologyEventListener implements FlowTopologyDiscoveryListener {
@Override
+ @SuppressFBWarnings("SLF4J_SIGN_ONLY_FORMAT")
public void onLinkDiscovered(LinkDiscovered notification) {
LOG.debug("-------------------------------------------");
LOG.debug("LinkDiscovered notification ........");
}
@Override
+ @SuppressFBWarnings("SLF4J_SIGN_ONLY_FORMAT")
public void onLinkOverutilized(LinkOverutilized notification) {
LOG.debug("-------------------------------------------");
LOG.debug("LinkOverutilized notification ........");
}
@Override
+ @SuppressFBWarnings("SLF4J_SIGN_ONLY_FORMAT")
public void onLinkRemoved(LinkRemoved notification) {
LOG.debug("-------------------------------------------");
LOG.debug("LinkRemoved notification ........");
}
@Override
+ @SuppressFBWarnings("SLF4J_SIGN_ONLY_FORMAT")
public void onLinkUtilizationNormal(LinkUtilizationNormal notification) {
LOG.debug("-------------------------------------------");
LOG.debug("LinkUtilizationNormal notification ........");
Code Review / openflowplugin.git / commitdiff