github.com/pingcap/chaos@v0.0.0-20190710112158-c86faf4b3719/pkg/model/register.go (about)

     1  package model
     2  
     3  import (
     4  	"encoding/json"
     5  
     6  	"github.com/pingcap/chaos/pkg/core"
     7  	"github.com/pingcap/chaos/pkg/history"
     8  )
     9  
    10  // Op is an operation.
    11  type Op bool
    12  
    13  const (
    14  	// RegisterRead a register
    15  	RegisterRead Op = false
    16  	// RegisterWrite a register
    17  	RegisterWrite Op = true
    18  )
    19  
    20  // RegisterRequest is the request that is issued to a register.
    21  type RegisterRequest struct {
    22  	Op    Op
    23  	Value int
    24  }
    25  
    26  // RegisterResponse is the response returned by a register.
    27  type RegisterResponse struct {
    28  	Unknown bool
    29  	Value   int
    30  }
    31  
    32  var _ core.UnknownResponse = (*RegisterResponse)(nil)
    33  
    34  // IsUnknown implements UnknownResponse interface
    35  func (r RegisterResponse) IsUnknown() bool {
    36  	return r.Unknown
    37  }
    38  
    39  type register struct {
    40  	perparedState *int
    41  }
    42  
    43  func (r *register) Prepare(state interface{}) {
    44  	s := state.(int)
    45  	r.perparedState = &s
    46  }
    47  
    48  func (r *register) Init() interface{} {
    49  	if r.perparedState != nil {
    50  		return *r.perparedState
    51  	}
    52  	return 0
    53  }
    54  
    55  func (*register) Step(state interface{}, input interface{}, output interface{}) (bool, interface{}) {
    56  	st := state.(int)
    57  	inp := input.(RegisterRequest)
    58  	out := output.(RegisterResponse)
    59  
    60  	// read
    61  	if inp.Op == RegisterRead {
    62  		ok := out.Value == st || out.Unknown
    63  		return ok, st
    64  	}
    65  
    66  	// write
    67  	return true, inp.Value
    68  }
    69  
    70  func (*register) Equal(state1, state2 interface{}) bool {
    71  	st1 := state1.(int)
    72  	st2 := state2.(int)
    73  	return st1 == st2
    74  }
    75  
    76  func (*register) Name() string {
    77  	return "register"
    78  }
    79  
    80  // RegisterModel returns a read/write register model
    81  func RegisterModel() core.Model {
    82  	return &register{}
    83  }
    84  
    85  type registerParser struct {
    86  }
    87  
    88  func (p registerParser) OnRequest(data json.RawMessage) (interface{}, error) {
    89  	r := RegisterRequest{}
    90  	err := json.Unmarshal(data, &r)
    91  	return r, err
    92  }
    93  
    94  func (p registerParser) OnResponse(data json.RawMessage) (interface{}, error) {
    95  	r := RegisterResponse{}
    96  	err := json.Unmarshal(data, &r)
    97  	if r.Unknown {
    98  		return nil, err
    99  	}
   100  	return r, nil
   101  }
   102  
   103  func (p registerParser) OnNoopResponse() interface{} {
   104  	return RegisterResponse{Unknown: true}
   105  }
   106  
   107  func (p registerParser) OnState(data json.RawMessage) (interface{}, error) {
   108  	var state int
   109  	err := json.Unmarshal(data, &state)
   110  	if err != nil {
   111  		return nil, err
   112  	}
   113  	return state, nil
   114  }
   115  
   116  // RegisterParser parses Register history.
   117  func RegisterParser() history.RecordParser {
   118  	return registerParser{}
   119  }