github.com/lfch/etcd-io/tests/v3@v3.0.0-20221004140520-eac99acd3e9d/functional/tester/case_network_delay.go (about)

     1  // Copyright 2018 The etcd Authors
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package tester
    16  
    17  import (
    18  	"time"
    19  
    20  	"github.com/lfch/etcd-io/tests/v3/functional/rpcpb"
    21  
    22  	"go.uber.org/zap"
    23  )
    24  
    25  const (
    26  	// Wait more when it recovers from slow network, because network layer
    27  	// needs extra time to propagate traffic control (tc command) change.
    28  	// Otherwise, we get different hash values from the previous revision.
    29  	// For more detail, please see https://github.com/etcd-io/etcd/issues/5121.
    30  	waitRecover = 5 * time.Second
    31  )
    32  
    33  func inject_DELAY_PEER_PORT_TX_RX(clus *Cluster, idx int) error {
    34  	clus.lg.Info(
    35  		"injecting delay latency",
    36  		zap.Duration("latency", time.Duration(clus.Tester.UpdatedDelayLatencyMs)*time.Millisecond),
    37  		zap.Duration("latency-rv", time.Duration(clus.Tester.DelayLatencyMsRv)*time.Millisecond),
    38  		zap.String("endpoint", clus.Members[idx].EtcdClientEndpoint),
    39  	)
    40  	return clus.sendOp(idx, rpcpb.Operation_DELAY_PEER_PORT_TX_RX)
    41  }
    42  
    43  func recover_DELAY_PEER_PORT_TX_RX(clus *Cluster, idx int) error {
    44  	err := clus.sendOp(idx, rpcpb.Operation_UNDELAY_PEER_PORT_TX_RX)
    45  	time.Sleep(waitRecover)
    46  	return err
    47  }
    48  
    49  func new_Case_DELAY_PEER_PORT_TX_RX_ONE_FOLLOWER(clus *Cluster, random bool) Case {
    50  	cc := caseByFunc{
    51  		rpcpbCase:     rpcpb.Case_DELAY_PEER_PORT_TX_RX_ONE_FOLLOWER,
    52  		injectMember:  inject_DELAY_PEER_PORT_TX_RX,
    53  		recoverMember: recover_DELAY_PEER_PORT_TX_RX,
    54  	}
    55  	clus.Tester.UpdatedDelayLatencyMs = clus.Tester.DelayLatencyMs
    56  	if random {
    57  		clus.UpdateDelayLatencyMs()
    58  		cc.rpcpbCase = rpcpb.Case_RANDOM_DELAY_PEER_PORT_TX_RX_ONE_FOLLOWER
    59  	}
    60  	c := &caseFollower{cc, -1, -1}
    61  	return &caseDelay{
    62  		Case:          c,
    63  		delayDuration: clus.GetCaseDelayDuration(),
    64  	}
    65  }
    66  
    67  func new_Case_DELAY_PEER_PORT_TX_RX_ONE_FOLLOWER_UNTIL_TRIGGER_SNAPSHOT(clus *Cluster, random bool) Case {
    68  	cc := caseByFunc{
    69  		rpcpbCase:     rpcpb.Case_DELAY_PEER_PORT_TX_RX_ONE_FOLLOWER_UNTIL_TRIGGER_SNAPSHOT,
    70  		injectMember:  inject_DELAY_PEER_PORT_TX_RX,
    71  		recoverMember: recover_DELAY_PEER_PORT_TX_RX,
    72  	}
    73  	clus.Tester.UpdatedDelayLatencyMs = clus.Tester.DelayLatencyMs
    74  	if random {
    75  		clus.UpdateDelayLatencyMs()
    76  		cc.rpcpbCase = rpcpb.Case_RANDOM_DELAY_PEER_PORT_TX_RX_ONE_FOLLOWER_UNTIL_TRIGGER_SNAPSHOT
    77  	}
    78  	c := &caseFollower{cc, -1, -1}
    79  	return &caseUntilSnapshot{
    80  		rpcpbCase: cc.rpcpbCase,
    81  		Case:      c,
    82  	}
    83  }
    84  
    85  func new_Case_DELAY_PEER_PORT_TX_RX_LEADER(clus *Cluster, random bool) Case {
    86  	cc := caseByFunc{
    87  		rpcpbCase:     rpcpb.Case_DELAY_PEER_PORT_TX_RX_LEADER,
    88  		injectMember:  inject_DELAY_PEER_PORT_TX_RX,
    89  		recoverMember: recover_DELAY_PEER_PORT_TX_RX,
    90  	}
    91  	clus.Tester.UpdatedDelayLatencyMs = clus.Tester.DelayLatencyMs
    92  	if random {
    93  		clus.UpdateDelayLatencyMs()
    94  		cc.rpcpbCase = rpcpb.Case_RANDOM_DELAY_PEER_PORT_TX_RX_LEADER
    95  	}
    96  	c := &caseLeader{cc, -1, -1}
    97  	return &caseDelay{
    98  		Case:          c,
    99  		delayDuration: clus.GetCaseDelayDuration(),
   100  	}
   101  }
   102  
   103  func new_Case_DELAY_PEER_PORT_TX_RX_LEADER_UNTIL_TRIGGER_SNAPSHOT(clus *Cluster, random bool) Case {
   104  	cc := caseByFunc{
   105  		rpcpbCase:     rpcpb.Case_DELAY_PEER_PORT_TX_RX_LEADER_UNTIL_TRIGGER_SNAPSHOT,
   106  		injectMember:  inject_DELAY_PEER_PORT_TX_RX,
   107  		recoverMember: recover_DELAY_PEER_PORT_TX_RX,
   108  	}
   109  	clus.Tester.UpdatedDelayLatencyMs = clus.Tester.DelayLatencyMs
   110  	if random {
   111  		clus.UpdateDelayLatencyMs()
   112  		cc.rpcpbCase = rpcpb.Case_RANDOM_DELAY_PEER_PORT_TX_RX_LEADER_UNTIL_TRIGGER_SNAPSHOT
   113  	}
   114  	c := &caseLeader{cc, -1, -1}
   115  	return &caseUntilSnapshot{
   116  		rpcpbCase: cc.rpcpbCase,
   117  		Case:      c,
   118  	}
   119  }
   120  
   121  func new_Case_DELAY_PEER_PORT_TX_RX_QUORUM(clus *Cluster, random bool) Case {
   122  	c := &caseQuorum{
   123  		caseByFunc: caseByFunc{
   124  			rpcpbCase:     rpcpb.Case_DELAY_PEER_PORT_TX_RX_QUORUM,
   125  			injectMember:  inject_DELAY_PEER_PORT_TX_RX,
   126  			recoverMember: recover_DELAY_PEER_PORT_TX_RX,
   127  		},
   128  		injected: make(map[int]struct{}),
   129  	}
   130  	clus.Tester.UpdatedDelayLatencyMs = clus.Tester.DelayLatencyMs
   131  	if random {
   132  		clus.UpdateDelayLatencyMs()
   133  		c.rpcpbCase = rpcpb.Case_RANDOM_DELAY_PEER_PORT_TX_RX_QUORUM
   134  	}
   135  	return &caseDelay{
   136  		Case:          c,
   137  		delayDuration: clus.GetCaseDelayDuration(),
   138  	}
   139  }
   140  
   141  func new_Case_DELAY_PEER_PORT_TX_RX_ALL(clus *Cluster, random bool) Case {
   142  	c := &caseAll{
   143  		rpcpbCase:     rpcpb.Case_DELAY_PEER_PORT_TX_RX_ALL,
   144  		injectMember:  inject_DELAY_PEER_PORT_TX_RX,
   145  		recoverMember: recover_DELAY_PEER_PORT_TX_RX,
   146  	}
   147  	clus.Tester.UpdatedDelayLatencyMs = clus.Tester.DelayLatencyMs
   148  	if random {
   149  		clus.UpdateDelayLatencyMs()
   150  		c.rpcpbCase = rpcpb.Case_RANDOM_DELAY_PEER_PORT_TX_RX_ALL
   151  	}
   152  	return &caseDelay{
   153  		Case:          c,
   154  		delayDuration: clus.GetCaseDelayDuration(),
   155  	}
   156  }