*/
public final class EventsTimeCounter {
- private static Map<String, Map<String, EventTimeCounter>> devicesEvents = new HashMap<>();
+ private static final Map<String, Map<String, EventTimeCounter>> DEVICES_EVENTS = new HashMap<>();
+
+ private EventsTimeCounter() {
+ // Hiding implicit constructor
+ }
public static void markStart(final EventIdentifier eventIdentifier) {
Map<String, EventTimeCounter> deviceEvents = getOrCreateCountersForDevice(eventIdentifier.getDeviceId());
}
private static Map<String, EventTimeCounter> getOrCreateCountersForDevice(final String deviceId) {
- Map<String, EventTimeCounter> lookup = devicesEvents.get(deviceId);
+ Map<String, EventTimeCounter> lookup = DEVICES_EVENTS.get(deviceId);
if (null == lookup) {
- lookup = new HashMap<String, EventTimeCounter>();
- devicesEvents.put(deviceId, lookup);
+ lookup = new HashMap<>();
+ DEVICES_EVENTS.put(deviceId, lookup);
}
return lookup;
public static List<String> provideTimes() {
List<String> dump = new ArrayList<>();
- for (Map.Entry<String, Map<String, EventTimeCounter>> deviceEntry : devicesEvents.entrySet()) {
+ for (Map.Entry<String, Map<String, EventTimeCounter>> deviceEntry : DEVICES_EVENTS.entrySet()) {
Map<String, EventTimeCounter> eventsMap = deviceEntry.getValue();
dump.add("================================================");
dump.add(String.format("DEVICE : %s", deviceEntry.getKey()));
}
public static void resetAllCounters() {
- devicesEvents = new HashMap<>();
+ DEVICES_EVENTS.clear();
}
*/
public class SessionStatistics {
- private static final Map<String, Map<ConnectionStatus, EventCounter>> sessionEvents = new HashMap<>();
+ private static final Map<String, Map<ConnectionStatus, EventCounter>> SESSION_EVENTS = new HashMap<>();
public static void countEvent(final String sessionId, final ConnectionStatus connectionStatus) {
Map<ConnectionStatus, EventCounter> sessionsConnectionEvents = getConnectionEvents(sessionId);
}
private static Map<ConnectionStatus, EventCounter> getConnectionEvents(final String sessionId) {
- Map<ConnectionStatus, EventCounter> sessionConnectionEvents = sessionEvents.get(sessionId);
+ Map<ConnectionStatus, EventCounter> sessionConnectionEvents = SESSION_EVENTS.get(sessionId);
if (null == sessionConnectionEvents) {
sessionConnectionEvents = new HashMap<>();
- sessionEvents.put(sessionId, sessionConnectionEvents);
+ SESSION_EVENTS.put(sessionId, sessionConnectionEvents);
}
return sessionConnectionEvents;
}
public static List<String> provideStatistics() {
List<String> dump = new ArrayList<>();
- for (Map.Entry<String, Map<ConnectionStatus, EventCounter>> sessionEntries : sessionEvents.entrySet()) {
+ for (Map.Entry<String, Map<ConnectionStatus, EventCounter>> sessionEntries : SESSION_EVENTS.entrySet()) {
Map<ConnectionStatus, EventCounter> sessionEvents = sessionEntries.getValue();
dump.add(String.format("SESSION : %s", sessionEntries.getKey()));
for (Map.Entry<ConnectionStatus, EventCounter> sessionEvent : sessionEvents.entrySet()) {
}
private static final class EventCounter {
- private final AtomicLongFieldUpdater<EventCounter> UPDATER = AtomicLongFieldUpdater.newUpdater(EventCounter.class, "count");
+ private final AtomicLongFieldUpdater<EventCounter> updater = AtomicLongFieldUpdater.newUpdater(EventCounter.class, "count");
private volatile long count;
public long getCount() {
}
public void increment() {
- count = UPDATER.incrementAndGet(this);
+ count = updater.incrementAndGet(this);
}
}
public static void resetAllCounters() {
- sessionEvents.clear();
+ SESSION_EVENTS.clear();
}
}
*/
package org.opendaylight.openflowplugin.impl.statistics.services;
-import com.google.common.base.Function;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestFlowCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.flow._case.MultipartRequestFlowBuilder;
-import org.opendaylight.yangtools.yang.common.RpcResult;
public class AllFlowsInTableService extends AbstractCompatibleStatService<GetAllFlowStatisticsFromFlowTableInput,
GetAllFlowStatisticsFromFlowTableOutput, FlowsStatisticsUpdate> {
private final ConvertorExecutor convertorExecutor;
- private Function<? super RpcResult<List<MultipartReply>>, FlowsStatisticsUpdate> transformer;
public AllFlowsInTableService(final RequestContextStack requestContextStack, final DeviceContext deviceContext, AtomicLong compatibilityXidSeed, ConvertorExecutor convertorExecutor) {
super(requestContextStack, deviceContext, compatibilityXidSeed);
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyAggregateCase;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* @author joe
*/
public class OpendaylightFlowStatisticsServiceImpl implements OpendaylightFlowStatisticsService, Delegator<OpendaylightFlowStatisticsService> {
- private static final Logger LOG = LoggerFactory.getLogger(OpendaylightFlowStatisticsServiceImpl.class);
-
private final Function<RpcResult<List<MultipartReply>>, RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput>> matchingConvertor =
new Function<RpcResult<List<MultipartReply>>, RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput>>() {
@Override
BigInteger datapathId = deviceInfo.getDatapathId();
// TODO: connection cookie from connection distinguisher
- // packetReceivedBuilder.setConnectionCookie(new ConnectionCookie(input.getCookie().longValue()));
-
packetReceivedBuilder.setPayload(input.getData());
// get the Cookie if it exists
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.SendBarrierInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* provides barrier message chaining and factory methods
*/
public final class BarrierUtil {
- private static final Logger LOG = LoggerFactory.getLogger(BarrierUtil.class);
-
private BarrierUtil() {
throw new IllegalStateException("This class should not be instantiated.");