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 com.google.common.base.Preconditions;
  16 import com.google.protobuf.GeneratedMessage;
  17 import java.io.Serializable;
  18 import java.util.HashMap;
  19 import java.util.Map;
  20 import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload;
  21 import org.opendaylight.controller.protobuff.messages.cluster.raft.AppendEntriesMessages;
  22 import org.opendaylight.controller.protobuff.messages.cluster.raft.test.MockPayloadMessages;
  23 import org.slf4j.Logger;
  24 import org.slf4j.LoggerFactory;
  25
  26 public class MockRaftActorContext implements RaftActorContext {
  27
  28     private String id;
  29     private ActorSystem system;
  30     private ActorRef actor;
  31     private long index = 0;
  32     private long lastApplied = 0;
  33     private final ElectionTerm electionTerm;
  34     private ReplicatedLog replicatedLog;
  35     private Map<String, String> peerAddresses = new HashMap<>();
  36     private ConfigParams configParams;
  37     private boolean snapshotCaptureInitiated;
  38     private SnapshotManager snapshotManager;
  39
  40     public MockRaftActorContext(){
  41         electionTerm = new ElectionTerm() {
  42             private long currentTerm = 1;
  43             private String votedFor = "";
  44
  45             @Override
  46             public long getCurrentTerm() {
  47                 return currentTerm;
  48             }
  49
  50             @Override
  51             public String getVotedFor() {
  52                 return votedFor;
  53             }
  54
  55             @Override
  56             public void update(long currentTerm, String votedFor){
  57                 this.currentTerm = currentTerm;
  58                 this.votedFor = votedFor;
  59
  60                 // TODO : Write to some persistent state
  61             }
  62
  63             @Override public void updateAndPersist(long currentTerm,
  64                 String votedFor) {
  65                 update(currentTerm, votedFor);
  66             }
  67         };
  68
  69         configParams = new DefaultConfigParamsImpl();
  70     }
  71
  72     public MockRaftActorContext(String id, ActorSystem system, ActorRef actor){
  73         this();
  74         this.id = id;
  75         this.system = system;
  76         this.actor = actor;
  77
  78         initReplicatedLog();
  79     }
  80
  81
  82     public void initReplicatedLog(){
  83         this.replicatedLog = new SimpleReplicatedLog();
  84         long term = getTermInformation().getCurrentTerm();
  85         this.replicatedLog.append(new MockReplicatedLogEntry(term, 0, new MockPayload("1")));
  86         this.replicatedLog.append(new MockReplicatedLogEntry(term, 1, new MockPayload("2")));
  87     }
  88
  89     @Override public ActorRef actorOf(Props props) {
  90         return system.actorOf(props);
  91     }
  92
  93     @Override public ActorSelection actorSelection(String path) {
  94         return system.actorSelection(path);
  95     }
  96
  97     @Override public String getId() {
  98         return id;
  99     }
 100
 101     @Override public ActorRef getActor() {
 102         return actor;
 103     }
 104
 105     @Override public ElectionTerm getTermInformation() {
 106         return electionTerm;
 107     }
 108
 109     public void setIndex(long index){
 110         this.index = index;
 111     }
 112
 113     @Override public long getCommitIndex() {
 114         return index;
 115     }
 116
 117     @Override public void setCommitIndex(long commitIndex) {
 118         this.index = commitIndex;
 119     }
 120
 121     @Override public void setLastApplied(long lastApplied){
 122         this.lastApplied = lastApplied;
 123     }
 124
 125     @Override public long getLastApplied() {
 126         return lastApplied;
 127     }
 128
 129     @Override
 130     // FIXME : A lot of tests try to manipulate the replicated log by setting it using this method
 131     // This is OK to do if the underlyingActor is not RafActor or a derived class. If not then you should not
 132     // used this way to manipulate the log because the RaftActor actually has a field replicatedLog
 133     // which it creates internally and sets on the RaftActorContext
 134     // The only right way to manipulate the replicated log therefore is to get it from either the RaftActor
 135     // or the RaftActorContext and modify the entries in there instead of trying to replace it by using this setter
 136     // Simple assertion that will fail if you do so
 137     // ReplicatedLog log = new ReplicatedLogImpl();
 138     // raftActor.underlyingActor().getRaftActorContext().setReplicatedLog(log);
 139     // assertEquals(log, raftActor.underlyingActor().getReplicatedLog())
 140     public void setReplicatedLog(ReplicatedLog replicatedLog) {
 141         this.replicatedLog = replicatedLog;
 142     }
 143
 144     @Override public ReplicatedLog getReplicatedLog() {
 145         return replicatedLog;
 146     }
 147
 148     @Override public ActorSystem getActorSystem() {
 149         return this.system;
 150     }
 151
 152     @Override public Logger getLogger() {
 153         return LoggerFactory.getLogger(getClass());
 154     }
 155
 156     @Override public Map<String, String> getPeerAddresses() {
 157         return peerAddresses;
 158     }
 159
 160     @Override public String getPeerAddress(String peerId) {
 161         return peerAddresses.get(peerId);
 162     }
 163
 164     @Override public void addToPeers(String name, String address) {
 165         peerAddresses.put(name, address);
 166     }
 167
 168     @Override public void removePeer(String name) {
 169         peerAddresses.remove(name);
 170     }
 171
 172     @Override public ActorSelection getPeerActorSelection(String peerId) {
 173         String peerAddress = getPeerAddress(peerId);
 174         if(peerAddress != null){
 175             return actorSelection(peerAddress);
 176         }
 177         return null;
 178     }
 179
 180     @Override public void setPeerAddress(String peerId, String peerAddress) {
 181         Preconditions.checkState(peerAddresses.containsKey(peerId));
 182         peerAddresses.put(peerId, peerAddress);
 183     }
 184
 185     public void setPeerAddresses(Map<String, String> peerAddresses) {
 186         this.peerAddresses = peerAddresses;
 187     }
 188
 189     @Override
 190     public ConfigParams getConfigParams() {
 191         return configParams;
 192     }
 193
 194     @Override
 195     public SnapshotManager getSnapshotManager() {
 196         if(this.snapshotManager == null){
 197             this.snapshotManager = new SnapshotManager(this, getLogger());
 198         }
 199         return this.snapshotManager;
 200     }
 201
 202     public void setConfigParams(ConfigParams configParams) {
 203         this.configParams = configParams;
 204     }
 205
 206     public static class SimpleReplicatedLog extends AbstractReplicatedLogImpl {
 207         @Override public void appendAndPersist(
 208             ReplicatedLogEntry replicatedLogEntry) {
 209             append(replicatedLogEntry);
 210         }
 211
 212         @Override
 213         public int dataSize() {
 214             return -1;
 215         }
 216
 217         @Override public void removeFromAndPersist(long index) {
 218             removeFrom(index);
 219         }
 220     }
 221
 222     public static class MockPayload extends Payload implements Serializable {
 223         private static final long serialVersionUID = 3121380393130864247L;
 224         private String value = "";
 225         private int size;
 226
 227         public MockPayload() {
 228         }
 229
 230         public MockPayload(String s) {
 231             this.value = s;
 232             size = value.length();
 233         }
 234
 235         public MockPayload(String s, int size) {
 236             this(s);
 237             this.size = size;
 238         }
 239
 240         @Override public  Map<GeneratedMessage.GeneratedExtension, String> encode() {
 241             Map<GeneratedMessage.GeneratedExtension, String> map = new HashMap<GeneratedMessage.GeneratedExtension, String>();
 242             map.put(MockPayloadMessages.value, value);
 243             return map;
 244         }
 245
 246         @Override public Payload decode(
 247             AppendEntriesMessages.AppendEntries.ReplicatedLogEntry.Payload payloadProtoBuff) {
 248             String value = payloadProtoBuff.getExtension(MockPayloadMessages.value);
 249             this.value = value;
 250             return this;
 251         }
 252
 253         @Override
 254         public int size() {
 255             return size;
 256         }
 257
 258         @Override public String getClientPayloadClassName() {
 259             return MockPayload.class.getName();
 260         }
 261
 262         @Override
 263         public String toString() {
 264             return value;
 265         }
 266
 267         @Override
 268         public int hashCode() {
 269             final int prime = 31;
 270             int result = 1;
 271             result = prime * result + ((value == null) ? 0 : value.hashCode());
 272             return result;
 273         }
 274
 275         @Override
 276         public boolean equals(Object obj) {
 277             if (this == obj) {
 278                 return true;
 279             }
 280             if (obj == null) {
 281                 return false;
 282             }
 283             if (getClass() != obj.getClass()) {
 284                 return false;
 285             }
 286             MockPayload other = (MockPayload) obj;
 287             if (value == null) {
 288                 if (other.value != null) {
 289                     return false;
 290                 }
 291             } else if (!value.equals(other.value)) {
 292                 return false;
 293             }
 294             return true;
 295         }
 296     }
 297
 298     public static class MockReplicatedLogEntry implements ReplicatedLogEntry, Serializable {
 299         private static final long serialVersionUID = 1L;
 300
 301         private final long term;
 302         private final long index;
 303         private final Payload data;
 304
 305         public MockReplicatedLogEntry(long term, long index, Payload data){
 306
 307             this.term = term;
 308             this.index = index;
 309             this.data = data;
 310         }
 311
 312         @Override public Payload getData() {
 313             return data;
 314         }
 315
 316         @Override public long getTerm() {
 317             return term;
 318         }
 319
 320         @Override public long getIndex() {
 321             return index;
 322         }
 323
 324         @Override
 325         public int size() {
 326             return getData().size();
 327         }
 328
 329         @Override
 330         public int hashCode() {
 331             final int prime = 31;
 332             int result = 1;
 333             result = prime * result + ((data == null) ? 0 : data.hashCode());
 334             result = prime * result + (int) (index ^ (index >>> 32));
 335             result = prime * result + (int) (term ^ (term >>> 32));
 336             return result;
 337         }
 338
 339         @Override
 340         public boolean equals(Object obj) {
 341             if (this == obj) {
 342                 return true;
 343             }
 344             if (obj == null) {
 345                 return false;
 346             }
 347             if (getClass() != obj.getClass()) {
 348                 return false;
 349             }
 350             MockReplicatedLogEntry other = (MockReplicatedLogEntry) obj;
 351             if (data == null) {
 352                 if (other.data != null) {
 353                     return false;
 354                 }
 355             } else if (!data.equals(other.data)) {
 356                 return false;
 357             }
 358             if (index != other.index) {
 359                 return false;
 360             }
 361             if (term != other.term) {
 362                 return false;
 363             }
 364             return true;
 365         }
 366
 367         @Override
 368         public String toString() {
 369             StringBuilder builder = new StringBuilder();
 370             builder.append("MockReplicatedLogEntry [term=").append(term).append(", index=").append(index)
 371                     .append(", data=").append(data).append("]");
 372             return builder.toString();
 373         }
 374     }
 375
 376     public static class MockReplicatedLogBuilder {
 377         private final ReplicatedLog mockLog = new SimpleReplicatedLog();
 378
 379         public  MockReplicatedLogBuilder createEntries(int start, int end, int term) {
 380             for (int i=start; i<end; i++) {
 381                 this.mockLog.append(new ReplicatedLogImplEntry(i, term, new MockRaftActorContext.MockPayload("foo" + i)));
 382             }
 383             return this;
 384         }
 385
 386         public  MockReplicatedLogBuilder addEntry(int index, int term, MockPayload payload) {
 387             this.mockLog.append(new ReplicatedLogImplEntry(index, term, payload));
 388             return this;
 389         }
 390
 391         public ReplicatedLog build() {
 392             return this.mockLog;
 393         }
 394     }
 395 }