opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/MockRaftActorContext.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.controller.cluster.raft;
  10
  11 import akka.actor.ActorRef;
  12 import akka.actor.ActorSelection;
  13 import akka.actor.ActorSystem;
  14 import akka.actor.Props;
  15 import akka.japi.Procedure;
  16 import com.google.common.base.Preconditions;
  17 import com.google.common.base.Supplier;
  18 import com.google.protobuf.GeneratedMessage;
  19 import java.io.Serializable;
  20 import java.util.ArrayList;
  21 import java.util.Collection;
  22 import java.util.HashMap;
  23 import java.util.Map;
  24 import org.opendaylight.controller.cluster.DataPersistenceProvider;
  25 import org.opendaylight.controller.cluster.NonPersistentDataProvider;
  26 import org.opendaylight.controller.cluster.raft.policy.DefaultRaftPolicy;
  27 import org.opendaylight.controller.cluster.raft.policy.RaftPolicy;
  28 import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload;
  29 import org.opendaylight.controller.protobuff.messages.cluster.raft.AppendEntriesMessages;
  30 import org.opendaylight.controller.protobuff.messages.cluster.raft.test.MockPayloadMessages;
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33
  34 public class MockRaftActorContext implements RaftActorContext {
  35
  36     private String id;
  37     private ActorSystem system;
  38     private ActorRef actor;
  39     private long index = 0;
  40     private long lastApplied = 0;
  41     private final ElectionTerm electionTerm;
  42     private ReplicatedLog replicatedLog;
  43     private Map<String, String> peerAddresses = new HashMap<>();
  44     private ConfigParams configParams;
  45     private boolean snapshotCaptureInitiated;
  46     private SnapshotManager snapshotManager;
  47     private DataPersistenceProvider persistenceProvider = new NonPersistentDataProvider();
  48     private short payloadVersion;
  49     private RaftPolicy raftPolicy = DefaultRaftPolicy.INSTANCE;
  50
  51     public MockRaftActorContext(){
  52         electionTerm = new ElectionTerm() {
  53             private long currentTerm = 1;
  54             private String votedFor = "";
  55
  56             @Override
  57             public long getCurrentTerm() {
  58                 return currentTerm;
  59             }
  60
  61             @Override
  62             public String getVotedFor() {
  63                 return votedFor;
  64             }
  65
  66             @Override
  67             public void update(long currentTerm, String votedFor){
  68                 this.currentTerm = currentTerm;
  69                 this.votedFor = votedFor;
  70
  71                 // TODO : Write to some persistent state
  72             }
  73
  74             @Override public void updateAndPersist(long currentTerm,
  75                 String votedFor) {
  76                 update(currentTerm, votedFor);
  77             }
  78         };
  79
  80         configParams = new DefaultConfigParamsImpl();
  81     }
  82
  83     public MockRaftActorContext(String id, ActorSystem system, ActorRef actor){
  84         this();
  85         this.id = id;
  86         this.system = system;
  87         this.actor = actor;
  88
  89         initReplicatedLog();
  90     }
  91
  92
  93     public void initReplicatedLog(){
  94         this.replicatedLog = new SimpleReplicatedLog();
  95         long term = getTermInformation().getCurrentTerm();
  96         this.replicatedLog.append(new MockReplicatedLogEntry(term, 0, new MockPayload("1")));
  97         this.replicatedLog.append(new MockReplicatedLogEntry(term, 1, new MockPayload("2")));
  98     }
  99
 100     @Override public ActorRef actorOf(Props props) {
 101         return system.actorOf(props);
 102     }
 103
 104     @Override public ActorSelection actorSelection(String path) {
 105         return system.actorSelection(path);
 106     }
 107
 108     @Override public String getId() {
 109         return id;
 110     }
 111
 112     @Override public ActorRef getActor() {
 113         return actor;
 114     }
 115
 116     @Override public ElectionTerm getTermInformation() {
 117         return electionTerm;
 118     }
 119
 120     public void setIndex(long index){
 121         this.index = index;
 122     }
 123
 124     @Override public long getCommitIndex() {
 125         return index;
 126     }
 127
 128     @Override public void setCommitIndex(long commitIndex) {
 129         this.index = commitIndex;
 130     }
 131
 132     @Override public void setLastApplied(long lastApplied){
 133         this.lastApplied = lastApplied;
 134     }
 135
 136     @Override public long getLastApplied() {
 137         return lastApplied;
 138     }
 139
 140     @Override
 141     // FIXME : A lot of tests try to manipulate the replicated log by setting it using this method
 142     // This is OK to do if the underlyingActor is not RafActor or a derived class. If not then you should not
 143     // used this way to manipulate the log because the RaftActor actually has a field replicatedLog
 144     // which it creates internally and sets on the RaftActorContext
 145     // The only right way to manipulate the replicated log therefore is to get it from either the RaftActor
 146     // or the RaftActorContext and modify the entries in there instead of trying to replace it by using this setter
 147     // Simple assertion that will fail if you do so
 148     // ReplicatedLog log = new ReplicatedLogImpl();
 149     // raftActor.underlyingActor().getRaftActorContext().setReplicatedLog(log);
 150     // assertEquals(log, raftActor.underlyingActor().getReplicatedLog())
 151     public void setReplicatedLog(ReplicatedLog replicatedLog) {
 152         this.replicatedLog = replicatedLog;
 153     }
 154
 155     @Override public ReplicatedLog getReplicatedLog() {
 156         return replicatedLog;
 157     }
 158
 159     @Override public ActorSystem getActorSystem() {
 160         return this.system;
 161     }
 162
 163     @Override public Logger getLogger() {
 164         return LoggerFactory.getLogger(getClass());
 165     }
 166
 167     @Override
 168     public Collection<String> getPeerIds() {
 169         return peerAddresses.keySet();
 170     }
 171
 172     @Override
 173     public Collection<PeerInfo> getPeers() {
 174         Collection<PeerInfo> peers = new ArrayList<>();
 175         for(Map.Entry<String, String> p: peerAddresses.entrySet()) {
 176             peers.add(new PeerInfo(p.getKey(), p.getValue(), VotingState.VOTING));
 177         }
 178
 179         return peers;
 180     }
 181
 182     @Override public String getPeerAddress(String peerId) {
 183         return peerAddresses.get(peerId);
 184     }
 185
 186     @Override
 187     public PeerInfo getPeerInfo(String peerId) {
 188         return new PeerInfo(peerId, peerAddresses.get(peerId), VotingState.VOTING);
 189     }
 190
 191     @Override public void addToPeers(String name, String address, VotingState votingState) {
 192         peerAddresses.put(name, address);
 193     }
 194
 195     @Override public void removePeer(String name) {
 196         peerAddresses.remove(name);
 197     }
 198
 199     @Override public ActorSelection getPeerActorSelection(String peerId) {
 200         String peerAddress = getPeerAddress(peerId);
 201         if(peerAddress != null){
 202             return actorSelection(peerAddress);
 203         }
 204         return null;
 205     }
 206
 207     @Override public void setPeerAddress(String peerId, String peerAddress) {
 208         Preconditions.checkState(peerAddresses.containsKey(peerId));
 209         peerAddresses.put(peerId, peerAddress);
 210     }
 211
 212     public void setPeerAddresses(Map<String, String> peerAddresses) {
 213         this.peerAddresses = peerAddresses;
 214     }
 215
 216     @Override
 217     public ConfigParams getConfigParams() {
 218         return configParams;
 219     }
 220
 221     @Override
 222     public SnapshotManager getSnapshotManager() {
 223         if(this.snapshotManager == null){
 224             this.snapshotManager = new SnapshotManager(this, getLogger());
 225             this.snapshotManager.setCreateSnapshotCallable(NoopProcedure.<Void>instance());
 226         }
 227         return this.snapshotManager;
 228     }
 229
 230     public void setConfigParams(ConfigParams configParams) {
 231         this.configParams = configParams;
 232     }
 233
 234     @Override
 235     public long getTotalMemory() {
 236         return Runtime.getRuntime().totalMemory();
 237     }
 238
 239     @Override
 240     public void setTotalMemoryRetriever(Supplier<Long> retriever) {
 241     }
 242
 243     @Override
 244     public boolean hasFollowers() {
 245         return getPeerIds().size() > 0;
 246     }
 247
 248     @Override
 249     public DataPersistenceProvider getPersistenceProvider() {
 250         return persistenceProvider;
 251     }
 252
 253     public void setPersistenceProvider(DataPersistenceProvider persistenceProvider) {
 254         this.persistenceProvider = persistenceProvider;
 255     }
 256
 257     @Override
 258     public short getPayloadVersion() {
 259         return payloadVersion;
 260     }
 261
 262     @Override
 263     public RaftPolicy getRaftPolicy() {
 264         return this.raftPolicy;
 265     }
 266
 267     public void setRaftPolicy(RaftPolicy raftPolicy){
 268         this.raftPolicy = raftPolicy;
 269     }
 270
 271     public void setPayloadVersion(short payloadVersion) {
 272         this.payloadVersion = payloadVersion;
 273     }
 274
 275     public static class SimpleReplicatedLog extends AbstractReplicatedLogImpl {
 276         @Override
 277         public void appendAndPersist(
 278             ReplicatedLogEntry replicatedLogEntry) {
 279             append(replicatedLogEntry);
 280         }
 281
 282         @Override
 283         public int dataSize() {
 284             return -1;
 285         }
 286
 287         @Override
 288         public void captureSnapshotIfReady(ReplicatedLogEntry replicatedLogEntry) {
 289         }
 290
 291         @Override public void removeFromAndPersist(long index) {
 292             removeFrom(index);
 293         }
 294
 295         @Override
 296         public void appendAndPersist(ReplicatedLogEntry replicatedLogEntry, Procedure<ReplicatedLogEntry> callback) {
 297             append(replicatedLogEntry);
 298
 299             if(callback != null) {
 300                 try {
 301                     callback.apply(replicatedLogEntry);
 302                 } catch (Exception e) {
 303                     e.printStackTrace();
 304                 }
 305             }
 306         }
 307     }
 308
 309     public static class MockPayload extends Payload implements Serializable {
 310         private static final long serialVersionUID = 3121380393130864247L;
 311         private String value = "";
 312         private int size;
 313
 314         public MockPayload() {
 315         }
 316
 317         public MockPayload(String s) {
 318             this.value = s;
 319             size = value.length();
 320         }
 321
 322         public MockPayload(String s, int size) {
 323             this(s);
 324             this.size = size;
 325         }
 326
 327         @Override public Map<GeneratedMessage.GeneratedExtension<?, ?>, String> encode() {
 328             Map<GeneratedMessage.GeneratedExtension<?, ?>, String> map = new HashMap<>();
 329             map.put(MockPayloadMessages.value, value);
 330             return map;
 331         }
 332
 333         @Override public Payload decode(
 334             AppendEntriesMessages.AppendEntries.ReplicatedLogEntry.Payload payloadProtoBuff) {
 335             String value = payloadProtoBuff.getExtension(MockPayloadMessages.value);
 336             this.value = value;
 337             return this;
 338         }
 339
 340         @Override
 341         public int size() {
 342             return size;
 343         }
 344
 345         @Override public String getClientPayloadClassName() {
 346             return MockPayload.class.getName();
 347         }
 348
 349         @Override
 350         public String toString() {
 351             return value;
 352         }
 353
 354         @Override
 355         public int hashCode() {
 356             final int prime = 31;
 357             int result = 1;
 358             result = prime * result + ((value == null) ? 0 : value.hashCode());
 359             return result;
 360         }
 361
 362         @Override
 363         public boolean equals(Object obj) {
 364             if (this == obj) {
 365                 return true;
 366             }
 367             if (obj == null) {
 368                 return false;
 369             }
 370             if (getClass() != obj.getClass()) {
 371                 return false;
 372             }
 373             MockPayload other = (MockPayload) obj;
 374             if (value == null) {
 375                 if (other.value != null) {
 376                     return false;
 377                 }
 378             } else if (!value.equals(other.value)) {
 379                 return false;
 380             }
 381             return true;
 382         }
 383     }
 384
 385     public static class MockReplicatedLogEntry implements ReplicatedLogEntry, Serializable {
 386         private static final long serialVersionUID = 1L;
 387
 388         private final long term;
 389         private final long index;
 390         private final Payload data;
 391
 392         public MockReplicatedLogEntry(long term, long index, Payload data){
 393
 394             this.term = term;
 395             this.index = index;
 396             this.data = data;
 397         }
 398
 399         @Override public Payload getData() {
 400             return data;
 401         }
 402
 403         @Override public long getTerm() {
 404             return term;
 405         }
 406
 407         @Override public long getIndex() {
 408             return index;
 409         }
 410
 411         @Override
 412         public int size() {
 413             return getData().size();
 414         }
 415
 416         @Override
 417         public int hashCode() {
 418             final int prime = 31;
 419             int result = 1;
 420             result = prime * result + ((data == null) ? 0 : data.hashCode());
 421             result = prime * result + (int) (index ^ (index >>> 32));
 422             result = prime * result + (int) (term ^ (term >>> 32));
 423             return result;
 424         }
 425
 426         @Override
 427         public boolean equals(Object obj) {
 428             if (this == obj) {
 429                 return true;
 430             }
 431             if (obj == null) {
 432                 return false;
 433             }
 434             if (getClass() != obj.getClass()) {
 435                 return false;
 436             }
 437             MockReplicatedLogEntry other = (MockReplicatedLogEntry) obj;
 438             if (data == null) {
 439                 if (other.data != null) {
 440                     return false;
 441                 }
 442             } else if (!data.equals(other.data)) {
 443                 return false;
 444             }
 445             if (index != other.index) {
 446                 return false;
 447             }
 448             if (term != other.term) {
 449                 return false;
 450             }
 451             return true;
 452         }
 453
 454         @Override
 455         public String toString() {
 456             StringBuilder builder = new StringBuilder();
 457             builder.append("MockReplicatedLogEntry [term=").append(term).append(", index=").append(index)
 458                     .append(", data=").append(data).append("]");
 459             return builder.toString();
 460         }
 461     }
 462
 463     public static class MockReplicatedLogBuilder {
 464         private final ReplicatedLog mockLog = new SimpleReplicatedLog();
 465
 466         public  MockReplicatedLogBuilder createEntries(int start, int end, int term) {
 467             for (int i=start; i<end; i++) {
 468                 this.mockLog.append(new ReplicatedLogImplEntry(i, term, new MockRaftActorContext.MockPayload(Integer.toString(i))));
 469             }
 470             return this;
 471         }
 472
 473         public  MockReplicatedLogBuilder addEntry(int index, int term, MockPayload payload) {
 474             this.mockLog.append(new ReplicatedLogImplEntry(index, term, payload));
 475             return this;
 476         }
 477
 478         public ReplicatedLog build() {
 479             return this.mockLog;
 480         }
 481     }
 482 }