transactInvokers.put(dbSchema, new TransactInvokerImpl(this,dbSchema));
}
} catch (InterruptedException | ExecutionException e) {
- LOG.warn("Exception attempting to createTransactionInvokers {}: {}",connectionInfo,e);
+ LOG.warn("Exception attempting to createTransactionInvokers {}", connectionInfo, e);
}
}
}
}
}
} catch (CandidateAlreadyRegisteredException e) {
- LOG.warn("OVSDB entity {} was already registered for {} ownership", candidateEntity, e);
+ LOG.warn("OVSDB entity {} was already registered for ownership", candidateEntity, e);
}
}
LOG.trace("Registering on path: {}", treeId);
registration = db.registerDataTreeChangeListener(treeId, HwvtepDataChangeListener.this);
} catch (final Exception e) {
- LOG.warn("HwvtepDataChangeListener registration failed");
+ LOG.warn("HwvtepDataChangeListener registration failed", e);
//TODO: Should we throw an exception here?
}
}
}
} catch (CandidateAlreadyRegisteredException e) {
LOG.warn("HWVTEP Southbound Provider instance entity {} was already "
- + "registered for {} ownership", instanceEntity, e);
+ + "registered for ownership", instanceEntity, e);
}
}
transaction.cancel();
}
} catch (Exception e) {
- LOG.error("Error initializing hwvtep topology {}",e);
+ LOG.error("Error initializing hwvtep topology", e);
}
}
}
}
} catch (Exception e) {
- LOG.warn("Failure to delete ovsdbNode {}", e);
+ LOG.warn("Failure to delete ovsdbNode", e);
}
}
try {
super.setup();
} catch (Exception e) {
- e.printStackTrace();
+ LOG.warn("Failed to setup test", e);
+ fail("Failed to setup test: " + e);
}
//dataBroker = getSession().getSALService(DataBroker.class);
Thread.sleep(3000);
try {
portNumber = Integer.parseInt(portStr);
} catch (NumberFormatException e) {
- fail("Invalid port number " + portStr + System.lineSeparator() + usage());
+ fail("Invalid port number " + portStr + System.lineSeparator() + usage() + e);
}
connectionType = bundleContext.getProperty(CONNECTION_TYPE);
try {
result = monitor.get();
} catch (InterruptedException | ExecutionException e) {
+ LOG.warn("Failed to monitor {}", dbSchema, e);
return null;
}
return transformingCallback(result, dbSchema);
try {
result = monitor.get();
} catch (InterruptedException | ExecutionException e) {
+ LOG.warn("Failed to monitor {}", dbSchema, e);
return null;
}
return transformingCallback(result, dbSchema);
try {
result = cancelMonitor.get();
} catch (InterruptedException | ExecutionException e) {
- LOG.error("Exception when canceling monitor handler {}", handler.getId());
+ LOG.error("Exception when canceling monitor handler {}", handler.getId(), e);
}
if (result == null) {
sfuture.set(schema);
}
} catch (Exception e) {
+ LOG.warn("Failed to populate schema {}:{}", dbNames, schema, e);
sfuture.setException(e);
}
return null;
method.setAccessible(true);
method.invoke(TyperUtils.class, schema, from, to);
} catch (NoSuchMethodException e) {
- LOG.error("Can't find TyperUtils::checkVersion(), TyperUtilsTest::callCheckVersion() may be obsolete");
+ LOG.error("Can't find TyperUtils::checkVersion(), TyperUtilsTest::callCheckVersion() may be obsolete", e);
} catch (IllegalAccessException e) {
LOG.error("Error invoking TyperUtils::checkVersion(), please check TyperUtilsTest::callCheckVersion()", e);
} catch (InvocationTargetException e) {
try {
super.setup();
} catch (Exception e) {
- e.printStackTrace();
+ LOG.warn("Failed to setup test", e);
+ fail("Failed to setup test: " + e);
}
getProperties();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
- e.printStackTrace();
+ LOG.warn("Interrupted while waiting for provider context", e);
}
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
- e.printStackTrace();
+ LOG.warn("Interrupted while waiting for other provider", e);
}
return providerContext;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
- e.printStackTrace();
+ LOG.warn("Interrupted while waiting for {}", NETVIRT_TOPOLOGY_ID, e);
}
}
}
commitFuture.checkedGet(); // TODO: Make it async (See bug 1362)
LOG.debug("Transaction success for write of Flow {}", flowBuilder.getFlowName());
} catch (Exception e) {
- LOG.error(e.getMessage(), e);
+ LOG.error("Failed to write flow {}", flowBuilder.getFlowName(), e);
modification.cancel();
}
}
commitFuture.get(); // TODO: Make it async (See bug 1362)
LOG.debug("Transaction success for deletion of Flow {}", flowBuilder.getFlowName());
} catch (Exception e) {
- LOG.error(e.getMessage(), e);
+ LOG.error("Failed to remove flow {}", flowBuilder.getFlowName(), e);
modification.cancel();
}
}
return data.get();
}
} catch (InterruptedException|ExecutionException e) {
- LOG.error(e.getMessage(), e);
+ LOG.error("Failed to get flow {}", flowBuilder.getFlowName(), e);
}
LOG.debug("Cannot find data for Flow {}", flowBuilder.getFlowName());
return data.get();
}
} catch (InterruptedException|ExecutionException e) {
- LOG.error(e.getMessage(), e);
+ LOG.error("Failed to get openflow node {}", nodeId, e);
}
LOG.debug("Cannot find data for Node {}", nodeId);
programLocalBridgeRules(node, dpid, segmentationId, attachedMac, localPort);
}
} catch (Exception e) {
- LOG.error("Exception in programming Local Rules for " + intf + " on " + node, e);
+ LOG.error("Exception in programming Local Rules for {} on {}", intf, node, e);
}
}
programLocalSecurityGroupRules(attachedMac, node, intf, dpid, localPort, segmentationId, false);
}
} catch (Exception e) {
- LOG.error("Exception in removing Local Rules for " + intf + " on " + node, e);
+ LOG.error("Exception in removing Local Rules for {} on {}", intf, node, e);
}
}
}
}
} catch (Exception e) {
- LOG.trace("", e);
+ LOG.warn("Failed to program tunnel rules, node {}, intf {}", node, intf, e);
}
}
}
}
} catch (Exception e) {
- LOG.error("", e);
+ LOG.error("Failed to remove tunnel rules, node {}, intf {}", node, intf, e);
}
}
MdsalHelper.createOvsdbInterfaceType(intf.getInterfaceType()),
src, dst);
} catch (Exception e) {
- LOG.error(e.getMessage(), e);
+ LOG.error("handleInterfaceDelete: failed to delete tunnel port", e);
}
} else if (phyIfName.contains(intf.getName())) {
deletePhysicalPort(srcNode, intf.getName());
return data.get();
}
} catch (InterruptedException|ExecutionException e) {
- LOG.error(e.getMessage(), e);
+ LOG.error("Failed to get group {}", groupBuilder.getGroupName(), e);
}
- LOG.debug("Cannot find data for Group " + groupBuilder.getGroupName());
+ LOG.debug("Cannot find data for Group {}", groupBuilder.getGroupName());
return null;
}
CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
try {
commitFuture.get(); // TODO: Make it async (See bug 1362)
- LOG.debug("Transaction success for write of Group " + groupBuilder.getGroupName());
+ LOG.debug("Transaction success for write of Group {}", groupBuilder.getGroupName());
} catch (InterruptedException|ExecutionException e) {
- LOG.error(e.getMessage(), e);
+ LOG.error("Failed to write group {}", groupBuilder.getGroupName(), e);
}
}
}
try {
commitFuture.get(); // TODO: Make it async (See bug 1362)
- LOG.debug("Transaction success for deletion of Group " + groupBuilder.getGroupName());
+ LOG.debug("Transaction success for deletion of Group {}", groupBuilder.getGroupName());
} catch (InterruptedException|ExecutionException e) {
- LOG.error(e.getMessage(), e);
+ LOG.error("Failed to remove group {}", groupBuilder.getGroupName(), e);
}
}
}
CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
try {
commitFuture.get(); // TODO: Make it async (See bug 1362)
- LOG.debug("Transaction success for write of Flow " + flowBuilder.getFlowName());
+ LOG.debug("Transaction success for write of Flow {}", flowBuilder.getFlowName());
} catch (InterruptedException|ExecutionException e) {
- LOG.error(e.getMessage(), e);
+ LOG.error("Failed to write flows {}", flowBuilder.getFlowName(), e);
}
}
}
return;
}
} catch (UnknownHostException e) {
- LOG.warn("Invalid IP address {}", ipaddress);
+ LOG.warn("Invalid IP address {}", ipaddress, e);
return;
}
}
Constants.PROTO_VM_IP_MAC_MATCH_PRIORITY,write);
}
} catch(UnknownHostException e) {
- LOG.warn("Invalid IP address {}", srcAddress.getIpAddress());
+ LOG.warn("Invalid IP address {}", srcAddress.getIpAddress(), e);
}
}
}
return;
}
} catch(UnknownHostException e) {
- LOG.warn("Invalid IP address {}", ipaddress);
+ LOG.warn("Invalid IP address {}", ipaddress, e);
return;
}
}
LOG.info("Registering Data Change Listener for NetvirtSfc AccessList configuration.");
listenerRegistration = db.registerDataTreeChangeListener(treeId, this);
} catch (final Exception e) {
- LOG.warn("Netvirt AccessList DataChange listener registration fail!");
+ LOG.warn("Netvirt AccessList DataChange listener registration fail!", e);
throw new IllegalStateException("NetvirtSfcAccessListListener startup fail! System needs restart.", e);
}
}
LOG.info("Registering Data Change Listener for NetvirtSfc Classifier configuration.");
listenerRegistration = db.registerDataTreeChangeListener(treeId, this);
} catch (final Exception e) {
- LOG.warn("Netvirt Classifier DataChange listener registration fail!");
+ LOG.warn("Netvirt Classifier DataChange listener registration fail!", e);
throw new IllegalStateException("NetvirtSfcClassifierListener startup fail! System needs restart.", e);
}
}
try {
listenerRegistration.close();
} catch (final Exception e) {
- LOG.warn("Error to stop Netvirt Classifier DataChange listener: {}", e.getMessage());
+ LOG.warn("Error to stop Netvirt Classifier DataChange listener", e);
}
listenerRegistration = null;
}
LOG.info("Registering Data Change Listener for NetvirtSfc RenderedServicePath configuration.");
listenerRegistration = db.registerDataTreeChangeListener(treeId, this);
} catch (final Exception e) {
- LOG.warn("Netvirt RenderedServicePath DataChange listener registration failed!");
+ LOG.warn("Netvirt RenderedServicePath DataChange listener registration failed!", e);
throw new IllegalStateException("RspListener startup failed! System needs restart.", e);
}
}
commitFuture.get(); // TODO: Make it async (See bug 1362)
LOG.debug("Transaction success for deletion of Flow {}", path);
} catch (Exception e) {
- LOG.error(e.getMessage(), e);
+ LOG.error("Failed to remove flow {}", path, e);
modification.cancel();
}
}
Thread.sleep(1000);
super.setup();
} catch (Exception e) {
- e.printStackTrace();
+ LOG.warn("Failed to setup test", e);
+ fail("Failed to setup test: " + e);
}
getProperties();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
- e.printStackTrace();
+ LOG.warn("Interrupted while waiting for provider context", e);
}
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
- e.printStackTrace();
+ LOG.warn("Interrupted while waiting for other provider", e);
}
return providerContext;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
- e.printStackTrace();
+ LOG.warn("Interrupted while waiting for {}", NETVIRT_TOPOLOGY_ID, e);
}
}
}
try {
listener.close();
} catch (Exception ex) {
- LOG.warn("Failed to close registration {}, iid {}", listener, ex);
+ LOG.warn("Failed to close registration {}", listener, ex);
}
}
LOG.info("waitList size {}", waitList.size());
Node ovsdbNode = southbound.readOvsdbNode(bridgeNode);
if (ovsdbNode == null) {
//this should never happen
- LOG.error("createLocalNetwork could not find ovsdbNode from bridge node " + bridgeNode);
+ LOG.error("createLocalNetwork could not find ovsdbNode from bridge node {}", bridgeNode);
return false;
}
if (network.getProviderNetworkType().equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VLAN)) {
try {
isCreated = createBridges(bridgeNode, ovsdbNode, network);
} catch (Exception e) {
- LOG.error("Error creating internal vlan net network " + bridgeNode, e);
+ LOG.error("Error creating internal vlan net network {}--{}", bridgeNode, network, e);
}
} else {
isCreated = true;
try {
isCreated = createBridges(bridgeNode, ovsdbNode, network);
} catch (Exception e) {
- LOG.error("Error creating internal vxlan/gre net network " + bridgeNode, e);
+ LOG.error("Error creating internal vxlan/gre net network {}--{}", bridgeNode, network, e);
}
} else {
isCreated = true;
return addressString;
}
} catch (UnknownHostException e) {
- LOG.error("Host {} is invalid", addressString);
+ LOG.error("Host {} is invalid", addressString, e);
}
}
return addressString;
}
} catch (UnknownHostException e) {
- LOG.error("Host {} is invalid", addressString);
+ LOG.error("Host {} is invalid", addressString, e);
}
}
openFlowPort = Short.parseShort(portString);
} catch (NumberFormatException e) {
LOG.warn("Invalid port:{}, use default({})", portString,
- openFlowPort);
+ openFlowPort, e);
}
}
return openFlowPort;
}
if (status.isSuccess()) {
- LOG.debug("ProgramStaticArp {} for mac:{} addr:{} dpid:{} segOrOfPort:{} action:{}",
+ LOG.debug("programStaticRuleStage2 {} for mac:{} addr:{} dpid:{} segOrOfPort:{} action:{}",
arpProvider == null ? "skipped" : "programmed",
macAddress, address, dpid, segOrOfPort, action);
} else {
- LOG.error("ProgramStaticArp failed for mac:{} addr:{} dpid:{} segOrOfPort:{} action:{} status:{}",
+ LOG.error("programStaticRuleStage2 failed for mac:{} addr:{} dpid:{} segOrOfPort:{} action:{} status:{}",
macAddress, address, dpid, segOrOfPort, action, status);
}
return status;
}
if (status.isSuccess()) {
- LOG.debug("ProgramRouterInterface {} for mac:{} addr:{}/{} node:{} srcTunId:{} destTunId:{} action:{}",
+ LOG.debug("programRouterInterfaceStage2 {} for mac:{} addr:{}/{} node:{} srcTunId:{} destTunId:{} action:{}",
routingProvider == null ? "skipped" : "programmed",
macAddress, address, mask, node.getNodeId().getValue(), sourceSegmentationId, destinationSegmentationId,
actionForNode);
} else {
- LOG.error("ProgramRouterInterface failed for mac:{} addr:{}/{} node:{} srcTunId:{} destTunId:{} action:{} status:{}",
+ LOG.error("programRouterInterfaceStage2 failed for mac:{} addr:{}/{} node:{} srcTunId:{} destTunId:{} action:{} status:{}",
macAddress, address, mask, node.getNodeId().getValue(), sourceSegmentationId, destinationSegmentationId,
actionForNode, status);
}
}
}
} catch (InterruptedException | ExecutionException e) {
- LOG.warn("Exception attempting to createTransactionInvokers {}: {}",connectionInfo,e);
+ LOG.warn("Exception attempting to createTransactionInvokers {}", connectionInfo, e);
}
}
}
ovs.getExternalIdsColumn().getData());
transaction.add(mutate);
} catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB Node external IDs");
+ LOG.warn("Incomplete OVSDB Node external IDs", e);
}
protocols = bridge.getProtocolsColumn().getData();
} catch (SchemaVersionMismatchException e) {
// We don't care about the exception stack trace here
- LOG.warn("protocols not supported by this version of ovsdb: {}", e.getMessage());
+ LOG.warn("protocols not supported by this version of ovsdb", e);
}
List<ProtocolEntry> protocolList = new ArrayList<>();
if (protocols != null && protocols.size() > 0) {
transaction.cancel();
}
} catch (Exception e) {
- LOG.error("Error initializing ovsdb topology {}",e);
+ LOG.error("Error initializing ovsdb topology", e);
}
}
try {
bridge.setOtherConfig(ImmutableMap.copyOf(otherConfigMap));
} catch (NullPointerException e) {
- LOG.warn("Incomplete bridge other config");
+ LOG.warn("Incomplete bridge other config", e);
}
}
}
ovs.getExternalIdsColumn().getData());
transaction.add(mutate);
} catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB Node external IDs");
+ LOG.warn("Incomplete OVSDB Node external IDs", e);
}
try {
qos.setExternalIds(ImmutableMap.copyOf(externalIdsMap));
} catch (NullPointerException e) {
- LOG.warn("Incomplete Qos external IDs");
+ LOG.warn("Incomplete Qos external IDs", e);
}
List<QosOtherConfig> otherConfigs = qosEntry.getQosOtherConfig();
try {
queue.setExternalIds(ImmutableMap.copyOf(externalIdsMap));
} catch (NullPointerException e) {
- LOG.warn("Incomplete Queue external IDs");
+ LOG.warn("Incomplete Queue external IDs", e);
}
List<QueuesOtherConfig> otherConfigs = queueEntry.getQueuesOtherConfig();
try {
ovsInterface.setOptions(ImmutableMap.copyOf(optionsMap));
} catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB interface options");
+ LOG.warn("Incomplete OVSDB interface options", e);
}
}
}
try {
ovsInterface.setExternalIds(ImmutableMap.copyOf(externalIdsMap));
} catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB interface external_ids");
+ LOG.warn("Incomplete OVSDB interface external_ids", e);
}
}
}
try {
ovsInterface.setLldp(ImmutableMap.copyOf(interfaceLldpMap));
} catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB interface lldp");
+ LOG.warn("Incomplete OVSDB interface lldp", e);
}
}
} catch (SchemaVersionMismatchException e) {
- LOG.debug("lldp column for Interface Table unsupported for this version of ovsdb schema. {}", e.getMessage());
+ LOG.debug("lldp column for Interface Table unsupported for this version of ovsdb schema", e);
}
}
try {
port.setExternalIds(ImmutableMap.copyOf(externalIdsMap));
} catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB port external_ids");
+ LOG.warn("Incomplete OVSDB port external_ids", e);
}
}
}
try {
ovsInterface.setOptions(ImmutableMap.copyOf(optionsMap));
} catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB interface options");
+ LOG.warn("Incomplete OVSDB interface options", e);
}
}
}
try {
ovsInterface.setExternalIds(ImmutableMap.copyOf(externalIdsMap));
} catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB interface external_ids");
+ LOG.warn("Incomplete OVSDB interface external_ids", e);
}
}
}
try {
ovsInterface.setLldp(ImmutableMap.copyOf(interfaceLldpMap));
} catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB interface lldp");
+ LOG.warn("Incomplete OVSDB interface lldp", e);
}
}
} catch (SchemaVersionMismatchException e) {
- LOG.debug("lldp column for Interface Table unsupported for this version of ovsdb schema. {}", e.getMessage());
+ LOG.debug("lldp column for Interface Table unsupported for this version of ovsdb schema", e);
}
}
try {
port.setExternalIds(ImmutableMap.copyOf(externalIdsMap));
} catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB port external_ids");
+ LOG.warn("Incomplete OVSDB port external_ids", e);
}
}
}
}
}
} catch (Exception e) {
- LOG.warn("Error getting local ip address {}", e);
+ LOG.warn("Error getting local ip address", e);
}
}
}
}
}
} catch (Exception e) {
- LOG.warn("Failure to delete ovsdbNode {}",e);
+ LOG.warn("Failure to delete ovsdbNode", e);
}
}
ovsdbTerminationPointBuilder.setInterfaceLldp(interfaceLldpList);
}
} catch (SchemaVersionMismatchException e) {
+ // We don't care about the exception stack trace here
LOG.debug("lldp column for Interface Table unsupported for this version of ovsdb schema. {}", e.getMessage());
}
}
queuesBuilder.setQueueUuid(new Uuid(entry.getKey().toString()));
Collection<Long> dscp = queue.getDscpColumn().getData();
if (!dscp.isEmpty()) {
- try {
- queuesBuilder.setDscp(new Short(dscp.iterator().next().toString()));
- } catch (NumberFormatException e) {
- queuesBuilder.setDscp(new Short("0"));
- }
+ queuesBuilder.setDscp(dscp.iterator().next().shortValue());
}
setOtherConfig(transaction, queuesBuilder, oldQueue, queue, nodeIId);
setExternalIds(transaction, queuesBuilder, oldQueue, queue, nodeIId);
try {
super.setup();
} catch (Exception e) {
- e.printStackTrace();
+ LOG.warn("Failed to setup test", e);
}
//dataBroker = getSession().getSALService(DataBroker.class);
Thread.sleep(3000);
return data.get();
}
} catch (InterruptedException|ExecutionException e) {
- LOG.error(e.getMessage(), e);
+ LOG.error("Failed to get flow {}", flowBuilder.getFlowName(), e);
}
LOG.info("Cannot find data for Flow {} in {}", flowBuilder.getFlowName(), store);
try {
inetAddress = InetAddress.getByName(addressStr);
} catch (UnknownHostException e) {
- LOG.warn("Could not allocate InetAddress");
+ LOG.warn("Could not allocate InetAddress", e);
}
IpAddress address = SouthboundMapper.createIpAddress(inetAddress);