import static com.google.common.base.Preconditions.checkNotNull;
+import com.google.common.base.Function;
+import com.google.common.base.Stopwatch;
+import com.google.common.collect.Collections2;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
-
+import javax.annotation.Nonnull;
import javax.annotation.concurrent.Immutable;
import javax.management.MBeanServerConnection;
-
import org.opendaylight.controller.config.api.ConflictingVersionException;
import org.opendaylight.controller.config.persist.api.ConfigPusher;
import org.opendaylight.controller.config.persist.api.ConfigSnapshotHolder;
import org.w3c.dom.Element;
import org.xml.sax.SAXException;
-import com.google.common.base.Function;
-import com.google.common.base.Stopwatch;
-import com.google.common.collect.Collections2;
-
@Immutable
public class ConfigPusherImpl implements ConfigPusher {
- private static final Logger logger = LoggerFactory.getLogger(ConfigPusherImpl.class);
+ private static final Logger LOG = LoggerFactory.getLogger(ConfigPusherImpl.class);
private final long maxWaitForCapabilitiesMillis;
private final long conflictingVersionTimeoutMillis;
* it is good idea to perform garbage collection to prune
* any garbage we have accumulated during startup.
*/
- logger.debug("Running post-initialization garbage collection...");
+ LOG.debug("Running post-initialization garbage collection...");
System.gc();
- logger.debug("Post-initialization garbage collection completed.");
- logger.debug("ConfigPusher has pushed configs {}, gc completed", configs);
+ LOG.debug("Post-initialization garbage collection completed.");
+ LOG.debug("ConfigPusher has pushed configs {}, gc completed", configs);
}
catch (NetconfDocumentedException e) {
- logger.error("Error pushing configs {}",configs);
+ LOG.error("Error pushing configs {}",configs);
throw new IllegalStateException(e);
}
}
}
public void pushConfigs(List<? extends ConfigSnapshotHolder> configs) throws InterruptedException {
- logger.debug("Requested to push configs {}", configs);
+ LOG.debug("Requested to push configs {}", configs);
this.queue.put(configs);
}
private LinkedHashMap<? extends ConfigSnapshotHolder, EditAndCommitResponse> internalPushConfigs(List<? extends ConfigSnapshotHolder> configs) throws NetconfDocumentedException {
- logger.debug("Last config snapshots to be pushed to netconf: {}", configs);
+ LOG.debug("Last config snapshots to be pushed to netconf: {}", configs);
LinkedHashMap<ConfigSnapshotHolder, EditAndCommitResponse> result = new LinkedHashMap<>();
// start pushing snapshots:
for (ConfigSnapshotHolder configSnapshotHolder : configs) {
if(configSnapshotHolder != null) {
EditAndCommitResponse editAndCommitResponseWithRetries = pushConfigWithConflictingVersionRetries(configSnapshotHolder);
- logger.debug("Config snapshot pushed successfully: {}, result: {}", configSnapshotHolder, result);
+ LOG.debug("Config snapshot pushed successfully: {}, result: {}", configSnapshotHolder, result);
result.put(configSnapshotHolder, editAndCommitResponseWithRetries);
}
}
- logger.debug("All configuration snapshots have been pushed successfully.");
+ LOG.debug("All configuration snapshots have been pushed successfully.");
return result;
}
return pushConfig(configSnapshotHolder, operationService);
} catch (ConflictingVersionException e) {
lastException = e;
- logger.debug("Conflicting version detected, will retry after timeout");
+ LOG.debug("Conflicting version detected, will retry after timeout");
sleep();
}
} while (stopwatch.elapsed(TimeUnit.MILLISECONDS) < conflictingVersionTimeoutMillis);
try {
return getOperationService(expectedCapabilities, idForReporting);
} catch (NotEnoughCapabilitiesException e) {
- logger.debug("Not enough capabilities: " + e.toString());
+ LOG.debug("Not enough capabilities: {}", e.toString());
lastException = e;
sleep();
}
return serviceCandidate;
} else {
serviceCandidate.close();
- logger.trace("Netconf server did not provide required capabilities for {} " +
+ LOG.trace("Netconf server did not provide required capabilities for {} ", idForReporting,
"Expected but not found: {}, all expected {}, current {}",
- idForReporting, notFoundDiff, expectedCapabilities, serviceCandidate.getCapabilities()
+ notFoundDiff, expectedCapabilities, serviceCandidate.getCapabilities()
);
throw new NotEnoughCapabilitiesException("Not enough capabilities for " + idForReporting + ". Expected but not found: " + notFoundDiff);
}
private static Set<String> computeNotFoundCapabilities(Set<String> expectedCapabilities, NetconfOperationService serviceCandidate) {
Collection<String> actual = Collections2.transform(serviceCandidate.getCapabilities(), new Function<Capability, String>() {
@Override
- public String apply(Capability input) {
+ public String apply(@Nonnull final Capability input) {
return input.getCapabilityUri();
}
});
} catch (SAXException | IOException e) {
throw new IllegalStateException("Cannot parse " + configSnapshotHolder);
}
- logger.trace("Pushing last configuration to netconf: {}", configSnapshotHolder);
+ LOG.trace("Pushing last configuration to netconf: {}", configSnapshotHolder);
Stopwatch stopwatch = new Stopwatch().start();
NetconfMessage editConfigMessage = createEditConfigMessage(xmlToBePersisted);
Document commitResponseMessage = sendRequestGetResponseCheckIsOK(getCommitMessage(), operationService,
"commit", configSnapshotHolder.toString());
- if (logger.isTraceEnabled()) {
+ if (LOG.isTraceEnabled()) {
StringBuilder response = new StringBuilder("editConfig response = {");
response.append(XmlUtil.toString(editResponseMessage));
response.append("}");
response.append("commit response = {");
response.append(XmlUtil.toString(commitResponseMessage));
response.append("}");
- logger.trace("Last configuration loaded successfully");
- logger.trace("Detailed message {}", response);
- logger.trace("Total time spent {} ms", stopwatch.elapsed(TimeUnit.MILLISECONDS));
+ LOG.trace("Last configuration loaded successfully");
+ LOG.trace("Detailed message {}", response);
+ LOG.trace("Total time spent {} ms", stopwatch.elapsed(TimeUnit.MILLISECONDS));
}
return new EditAndCommitResponse(editResponseMessage, commitResponseMessage);
}