package org.opendaylight.controller.cluster.datastore.jmx.mbeans.shard;
+import akka.actor.ActorRef;
+import akka.pattern.Patterns;
+import akka.util.Timeout;
+import com.google.common.base.Joiner;
+import com.google.common.base.Joiner.MapJoiner;
+import com.google.common.base.Stopwatch;
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
+import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
+import javax.annotation.Nullable;
+import org.opendaylight.controller.cluster.datastore.Shard;
+import org.opendaylight.controller.cluster.raft.base.messages.InitiateCaptureSnapshot;
+import org.opendaylight.controller.cluster.raft.client.messages.FollowerInfo;
+import org.opendaylight.controller.cluster.raft.client.messages.GetOnDemandRaftState;
+import org.opendaylight.controller.cluster.raft.client.messages.OnDemandRaftState;
import org.opendaylight.controller.md.sal.common.util.jmx.AbstractMXBean;
-import org.opendaylight.controller.md.sal.common.util.jmx.QueuedNotificationManagerMXBeanImpl;
-import org.opendaylight.controller.md.sal.common.util.jmx.ThreadExecutorStats;
-import org.opendaylight.controller.md.sal.common.util.jmx.ThreadExecutorStatsMXBeanImpl;
-import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
-import org.opendaylight.yangtools.util.concurrent.ListenerNotificationQueueStats;
-import org.opendaylight.yangtools.util.concurrent.QueuedNotificationManager;
+import scala.concurrent.Await;
/**
* Maintains statistics for a shard.
* @author Basheeruddin syedbahm@cisco.com
*/
public class ShardStats extends AbstractMXBean implements ShardStatsMXBean {
- public static String JMX_CATEGORY_SHARD = "Shards";
+ public static final String JMX_CATEGORY_SHARD = "Shards";
- private final AtomicLong committedTransactionsCount = new AtomicLong();
+ private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
- private final AtomicLong readOnlyTransactionCount = new AtomicLong();
+ private static final Cache<String, OnDemandRaftState> ONDEMAND_RAFT_STATE_CACHE =
+ CacheBuilder.newBuilder().expireAfterWrite(2, TimeUnit.SECONDS).build();
- private final AtomicLong writeOnlyTransactionCount = new AtomicLong();
+ private static final MapJoiner MAP_JOINER = Joiner.on(", ").withKeyValueSeparator(": ");
- private final AtomicLong readWriteTransactionCount = new AtomicLong();
+ private long committedTransactionsCount;
- private String leader;
+ private long readOnlyTransactionCount;
- private String raftState;
+ private long writeOnlyTransactionCount;
- private volatile long lastLogTerm = -1L;
+ private long readWriteTransactionCount;
- private volatile long lastLogIndex = -1L;
+ private long lastCommittedTransactionTime;
- private volatile long currentTerm = -1L;
+ private long failedTransactionsCount;
- private volatile long commitIndex = -1L;
-
- private volatile long lastApplied = -1L;
+ private final AtomicLong failedReadTransactionsCount = new AtomicLong();
- private volatile long lastCommittedTransactionTime;
+ private long abortTransactionsCount;
- private final AtomicLong failedTransactionsCount = new AtomicLong();
+ private boolean followerInitialSyncStatus = false;
- private final AtomicLong failedReadTransactionsCount = new AtomicLong();
+ private final Shard shard;
- private final AtomicLong abortTransactionsCount = new AtomicLong();
+ private String statRetrievalError;
- private ThreadExecutorStatsMXBeanImpl notificationExecutorStatsBean;
+ private String statRetrievalTime;
- private QueuedNotificationManagerMXBeanImpl notificationManagerStatsBean;
+ private long leadershipChangeCount;
- private volatile long dataSize = 0;
+ private long lastLeadershipChangeTime;
- private final SimpleDateFormat sdf =
- new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
-
- public ShardStats(final String shardName, final String mxBeanType) {
+ public ShardStats(final String shardName, final String mxBeanType, @Nullable final Shard shard) {
super(shardName, mxBeanType, JMX_CATEGORY_SHARD);
+ this.shard = shard;
}
- public void setNotificationManager(final QueuedNotificationManager<?, ?> manager) {
- this.notificationManagerStatsBean = new QueuedNotificationManagerMXBeanImpl(manager,
- "notification-manager", getMBeanType(), getMBeanCategory());
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ private OnDemandRaftState getOnDemandRaftState() {
+ String name = getShardName();
+ OnDemandRaftState state = ONDEMAND_RAFT_STATE_CACHE.getIfPresent(name);
+ if (state == null) {
+ statRetrievalError = null;
+ statRetrievalTime = null;
+
+ if (shard != null) {
+ Timeout timeout = new Timeout(10, TimeUnit.SECONDS);
+ try {
+ Stopwatch timer = Stopwatch.createStarted();
- this.notificationExecutorStatsBean = ThreadExecutorStatsMXBeanImpl.create(manager.getExecutor());
+ state = (OnDemandRaftState) Await.result(Patterns.ask(shard.getSelf(),
+ GetOnDemandRaftState.INSTANCE, timeout), timeout.duration());
+
+ statRetrievalTime = timer.stop().toString();
+ ONDEMAND_RAFT_STATE_CACHE.put(name, state);
+ } catch (Exception e) {
+ statRetrievalError = e.toString();
+ }
+ }
+
+ state = state != null ? state : OnDemandRaftState.builder().build();
+ }
+
+ return state;
}
@Override
@Override
public long getCommittedTransactionsCount() {
- return committedTransactionsCount.get();
+ return committedTransactionsCount;
}
@Override
public String getLeader() {
- return leader;
+ return getOnDemandRaftState().getLeader();
}
@Override
public String getRaftState() {
- return raftState;
+ return getOnDemandRaftState().getRaftState();
}
@Override
public long getReadOnlyTransactionCount() {
- return readOnlyTransactionCount.get();
+ return readOnlyTransactionCount;
}
@Override
public long getWriteOnlyTransactionCount() {
- return writeOnlyTransactionCount.get();
+ return writeOnlyTransactionCount;
}
@Override
public long getReadWriteTransactionCount() {
- return readWriteTransactionCount.get();
+ return readWriteTransactionCount;
}
@Override
public long getLastLogIndex() {
- return lastLogIndex;
+ return getOnDemandRaftState().getLastLogIndex();
}
@Override
public long getLastLogTerm() {
- return lastLogTerm;
+ return getOnDemandRaftState().getLastLogTerm();
}
@Override
public long getCurrentTerm() {
- return currentTerm;
+ return getOnDemandRaftState().getCurrentTerm();
}
@Override
public long getCommitIndex() {
- return commitIndex;
+ return getOnDemandRaftState().getCommitIndex();
}
@Override
public long getLastApplied() {
- return lastApplied;
+ return getOnDemandRaftState().getLastApplied();
}
@Override
- public String getLastCommittedTransactionTime() {
+ public long getLastIndex() {
+ return getOnDemandRaftState().getLastIndex();
+ }
+
+ @Override
+ public long getLastTerm() {
+ return getOnDemandRaftState().getLastTerm();
+ }
+
+ @Override
+ public long getSnapshotIndex() {
+ return getOnDemandRaftState().getSnapshotIndex();
+ }
+
+ @Override
+ public long getSnapshotTerm() {
+ return getOnDemandRaftState().getSnapshotTerm();
+ }
+
+ @Override
+ public long getReplicatedToAllIndex() {
+ return getOnDemandRaftState().getReplicatedToAllIndex();
+ }
+
+ @Override
+ public String getVotedFor() {
+ return getOnDemandRaftState().getVotedFor();
+ }
+
+ @Override
+ public boolean isVoting() {
+ return getOnDemandRaftState().isVoting();
+ }
- return sdf.format(new Date(lastCommittedTransactionTime));
+ @Override
+ public String getPeerVotingStates() {
+ return MAP_JOINER.join(getOnDemandRaftState().getPeerVotingStates());
+ }
+
+ @Override
+ public boolean isSnapshotCaptureInitiated() {
+ return getOnDemandRaftState().isSnapshotCaptureInitiated();
+ }
+
+ @Override
+ public String getLastCommittedTransactionTime() {
+ synchronized (DATE_FORMAT) {
+ return DATE_FORMAT.format(new Date(lastCommittedTransactionTime));
+ }
}
@Override
public long getFailedTransactionsCount() {
- return failedTransactionsCount.get();
+ return failedTransactionsCount;
}
@Override
@Override
public long getAbortTransactionsCount() {
- return abortTransactionsCount.get();
+ return abortTransactionsCount;
}
public long incrementCommittedTransactionCount() {
- return committedTransactionsCount.incrementAndGet();
+ return ++committedTransactionsCount;
}
public long incrementReadOnlyTransactionCount() {
- return readOnlyTransactionCount.incrementAndGet();
+ return ++readOnlyTransactionCount;
}
public long incrementWriteOnlyTransactionCount() {
- return writeOnlyTransactionCount.incrementAndGet();
+ return ++writeOnlyTransactionCount;
}
public long incrementReadWriteTransactionCount() {
- return readWriteTransactionCount.incrementAndGet();
+ return ++readWriteTransactionCount;
}
public long incrementFailedTransactionsCount() {
- return failedTransactionsCount.incrementAndGet();
+ return ++failedTransactionsCount;
}
public long incrementFailedReadTransactionsCount() {
return failedReadTransactionsCount.incrementAndGet();
}
- public long incrementAbortTransactionsCount ()
- {
- return abortTransactionsCount.incrementAndGet();
+ public long incrementAbortTransactionsCount() {
+ return ++abortTransactionsCount;
}
- public void setLeader(final String leader) {
- this.leader = leader;
+ public void setLastCommittedTransactionTime(final long lastCommittedTransactionTime) {
+ this.lastCommittedTransactionTime = lastCommittedTransactionTime;
}
- public void setRaftState(final String raftState) {
- this.raftState = raftState;
+ @Override
+ public long getInMemoryJournalDataSize() {
+ return getOnDemandRaftState().getInMemoryJournalDataSize();
}
- public void setLastLogTerm(final long lastLogTerm) {
- this.lastLogTerm = lastLogTerm;
+ @Override
+ public long getInMemoryJournalLogSize() {
+ return getOnDemandRaftState().getInMemoryJournalLogSize();
}
- public void setLastLogIndex(final long lastLogIndex) {
- this.lastLogIndex = lastLogIndex;
- }
+ /**
+ * Resets the counters related to transactions.
+ */
+ @Override
+ public void resetTransactionCounters() {
+ committedTransactionsCount = 0;
- public void setCurrentTerm(final long currentTerm) {
- this.currentTerm = currentTerm;
- }
+ readOnlyTransactionCount = 0;
- public void setCommitIndex(final long commitIndex) {
- this.commitIndex = commitIndex;
- }
+ writeOnlyTransactionCount = 0;
- public void setLastApplied(final long lastApplied) {
- this.lastApplied = lastApplied;
- }
+ readWriteTransactionCount = 0;
+
+ lastCommittedTransactionTime = 0;
+
+ failedTransactionsCount = 0;
+
+ failedReadTransactionsCount.set(0);
+
+ abortTransactionsCount = 0;
- public void setLastCommittedTransactionTime(final long lastCommittedTransactionTime) {
- this.lastCommittedTransactionTime = lastCommittedTransactionTime;
}
- public void setInMemoryJournalDataSize(long dataSize){
- this.dataSize = dataSize;
+ public void setFollowerInitialSyncStatus(boolean followerInitialSyncStatus) {
+ this.followerInitialSyncStatus = followerInitialSyncStatus;
}
@Override
- public long getInMemoryJournalDataSize(){
- return dataSize;
+ public boolean getFollowerInitialSyncStatus() {
+ return followerInitialSyncStatus;
}
@Override
- public ThreadExecutorStats getDataStoreExecutorStats() {
- // FIXME: this particular thing does not work, as it really is DS-specific
- return null;
+ public List<FollowerInfo> getFollowerInfo() {
+ return getOnDemandRaftState().getFollowerInfoList();
}
@Override
- public ThreadExecutorStats getNotificationMgrExecutorStats() {
- return notificationExecutorStatsBean.toThreadExecutorStats();
+ public String getPeerAddresses() {
+ return MAP_JOINER.join(getOnDemandRaftState().getPeerAddresses());
}
@Override
- public List<ListenerNotificationQueueStats> getCurrentNotificationMgrListenerQueueStats() {
- return notificationManagerStatsBean.getCurrentListenerQueueStats();
+ public String getStatRetrievalTime() {
+ getOnDemandRaftState();
+ return statRetrievalTime;
}
@Override
- public int getMaxNotificationMgrListenerQueueSize() {
- return notificationManagerStatsBean.getMaxListenerQueueSize();
+ public String getStatRetrievalError() {
+ getOnDemandRaftState();
+ return statRetrievalError;
}
- /**
- * resets the counters related to transactions
- */
@Override
- public void resetTransactionCounters(){
- committedTransactionsCount.set(0);
-
- readOnlyTransactionCount.set(0);
-
- writeOnlyTransactionCount.set(0);
-
- readWriteTransactionCount.set(0);
-
- lastCommittedTransactionTime = 0;
+ public long getLeadershipChangeCount() {
+ return leadershipChangeCount;
+ }
- failedTransactionsCount.set(0);
+ public void incrementLeadershipChangeCount() {
+ leadershipChangeCount++;
+ lastLeadershipChangeTime = System.currentTimeMillis();
+ }
- failedReadTransactionsCount.set(0);
+ @Override
+ public String getLastLeadershipChangeTime() {
+ synchronized (DATE_FORMAT) {
+ return DATE_FORMAT.format(new Date(lastLeadershipChangeTime));
+ }
+ }
- abortTransactionsCount.set(0);
+ @Override
+ public int getPendingTxCommitQueueSize() {
+ return shard != null ? shard.getPendingTxCommitQueueSize() : -1;
+ }
+ @Override
+ public int getTxCohortCacheSize() {
+ return shard != null ? shard.getCohortCacheSize() : -1;
}
- public void setDataStore(final InMemoryDOMDataStore store) {
- setNotificationManager(store.getDataChangeListenerNotificationManager());
+ @Override
+ public void captureSnapshot() {
+ if (shard != null) {
+ shard.getSelf().tell(new InitiateCaptureSnapshot(), ActorRef.noSender());
+ }
}
}
Code Review / controller.git / blobdiff