abstract void removeDevice(String publicKey, Device device);
}
- private static class DeviceConfig extends AbstractDeviceListener {
+ private static final class DeviceConfig extends AbstractDeviceListener {
private final ConcurrentMap<PublicKey, Device> byPublicKey = new ConcurrentHashMap<>();
private final AuthorizedKeysDecoder keyDecoder = new AuthorizedKeysDecoder();
}
}
- private static class DeviceOp extends AbstractDeviceListener {
+ private static final class DeviceOp extends AbstractDeviceListener {
private final ConcurrentMap<String, Device> byPublicKey = new ConcurrentHashMap<>();
Device get(final PublicKey serverKey) {
}
}
- private static class GlobalConfig implements DataTreeChangeListener<Global> {
+ private static final class GlobalConfig implements DataTreeChangeListener<Global> {
private volatile Global current = null;
@Override
return rpcDefinition;
}
- private static class TopDOMRpcImplementation implements DOMRpcImplementation {
+ private static final class TopDOMRpcImplementation implements DOMRpcImplementation {
private volatile SettableFuture<Entry<DOMRpcIdentifier, NormalizedNode>> rpcInvokedFuture;
private volatile ListenableFuture<DOMRpcResult> returnFuture;
throw new IllegalStateException("Outbound writes to SSH should be done by SSH Write handler");
}
- private class SshUnsafe extends AbstractUnsafe {
+ private final class SshUnsafe extends AbstractUnsafe {
@Override
public void connect(final SocketAddress remoteAddress, final SocketAddress localAddress,
final ChannelPromise promise) {
doReturn(timeout).when(timer).newTimeout(any(), eq(100L), eq(TimeUnit.MILLISECONDS));
}
- private static class CloseDetector extends ChannelOutboundHandlerAdapter {
+ private static final class CloseDetector extends ChannelOutboundHandlerAdapter {
@Override
public void close(final ChannelHandlerContext ctx, final ChannelPromise promise) {
// Override needed so @Skip from superclass is not effective
}
}
- private static class TimeoutGuard implements Callable<Void> {
+ private static final class TimeoutGuard implements Callable<Void> {
@Override
public Void call() {
resultsLog.warn("Timeout for scale test reached after: {} ..aborting", STOPWATCH);
/**
* Responds to all operations except start-exi and counts all requests.
*/
- private static class TestingNetconfOperation implements NetconfOperation {
-
+ private static final class TestingNetconfOperation implements NetconfOperation {
private final AtomicLong counter = new AtomicLong();
@Override
/**
* Hardcoded operation service factory.
*/
- private static class TestingOperationServiceFactory implements NetconfOperationServiceFactory {
+ private static final class TestingOperationServiceFactory implements NetconfOperationServiceFactory {
private final NetconfOperation[] operations;
TestingOperationServiceFactory(final NetconfOperation... operations) {
Code Review / netconf.git / commitdiff