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 }