github.com/emate/nomad@v0.8.2-wo-binpacking/nomad/client_rpc_test.go (about) 1 package nomad 2 3 import ( 4 "net" 5 "testing" 6 7 "github.com/hashicorp/nomad/client" 8 "github.com/hashicorp/nomad/client/config" 9 "github.com/hashicorp/nomad/helper/uuid" 10 "github.com/hashicorp/nomad/nomad/structs" 11 "github.com/hashicorp/nomad/testutil" 12 "github.com/stretchr/testify/require" 13 ) 14 15 type namedConnWrapper struct { 16 net.Conn 17 name string 18 } 19 20 type namedAddr string 21 22 func (n namedAddr) String() string { return string(n) } 23 func (n namedAddr) Network() string { return string(n) } 24 25 func (n namedConnWrapper) LocalAddr() net.Addr { 26 return namedAddr(n.name) 27 } 28 29 func TestServer_removeNodeConn_differentAddrs(t *testing.T) { 30 t.Parallel() 31 require := require.New(t) 32 s1 := TestServer(t, nil) 33 defer s1.Shutdown() 34 testutil.WaitForLeader(t, s1.RPC) 35 36 p1, p2 := net.Pipe() 37 w1 := namedConnWrapper{ 38 Conn: p1, 39 name: "a", 40 } 41 w2 := namedConnWrapper{ 42 Conn: p2, 43 name: "b", 44 } 45 46 // Add the connections 47 nodeID := uuid.Generate() 48 ctx1 := &RPCContext{ 49 Conn: w1, 50 NodeID: nodeID, 51 } 52 ctx2 := &RPCContext{ 53 Conn: w2, 54 NodeID: nodeID, 55 } 56 57 s1.addNodeConn(ctx1) 58 s1.addNodeConn(ctx2) 59 require.Len(s1.connectedNodes(), 1) 60 require.Len(s1.nodeConns[nodeID], 2) 61 62 // Check that the value is the second conn. 63 state, ok := s1.getNodeConn(nodeID) 64 require.True(ok) 65 require.Equal(state.Ctx.Conn.LocalAddr().String(), w2.name) 66 67 // Delete the first 68 s1.removeNodeConn(ctx1) 69 require.Len(s1.connectedNodes(), 1) 70 require.Len(s1.nodeConns[nodeID], 1) 71 72 // Check that the value is the second conn. 73 state, ok = s1.getNodeConn(nodeID) 74 require.True(ok) 75 require.Equal(state.Ctx.Conn.LocalAddr().String(), w2.name) 76 77 // Delete the second 78 s1.removeNodeConn(ctx2) 79 require.Len(s1.connectedNodes(), 0) 80 81 _, ok = s1.getNodeConn(nodeID) 82 require.False(ok) 83 } 84 85 func TestServerWithNodeConn_NoPath(t *testing.T) { 86 t.Parallel() 87 require := require.New(t) 88 s1 := TestServer(t, nil) 89 defer s1.Shutdown() 90 s2 := TestServer(t, func(c *Config) { 91 c.DevDisableBootstrap = true 92 }) 93 defer s2.Shutdown() 94 TestJoin(t, s1, s2) 95 testutil.WaitForLeader(t, s1.RPC) 96 testutil.WaitForLeader(t, s2.RPC) 97 98 nodeID := uuid.Generate() 99 srv, err := s1.serverWithNodeConn(nodeID, s1.Region()) 100 require.Nil(srv) 101 require.EqualError(err, structs.ErrNoNodeConn.Error()) 102 } 103 104 func TestServerWithNodeConn_NoPath_Region(t *testing.T) { 105 t.Parallel() 106 require := require.New(t) 107 s1 := TestServer(t, nil) 108 defer s1.Shutdown() 109 testutil.WaitForLeader(t, s1.RPC) 110 111 nodeID := uuid.Generate() 112 srv, err := s1.serverWithNodeConn(nodeID, "fake-region") 113 require.Nil(srv) 114 require.EqualError(err, structs.ErrNoRegionPath.Error()) 115 } 116 117 func TestServerWithNodeConn_Path(t *testing.T) { 118 t.Parallel() 119 require := require.New(t) 120 s1 := TestServer(t, nil) 121 defer s1.Shutdown() 122 s2 := TestServer(t, func(c *Config) { 123 c.DevDisableBootstrap = true 124 }) 125 defer s2.Shutdown() 126 TestJoin(t, s1, s2) 127 testutil.WaitForLeader(t, s1.RPC) 128 testutil.WaitForLeader(t, s2.RPC) 129 130 // Create a fake connection for the node on server 2 131 nodeID := uuid.Generate() 132 s2.addNodeConn(&RPCContext{ 133 NodeID: nodeID, 134 }) 135 136 srv, err := s1.serverWithNodeConn(nodeID, s1.Region()) 137 require.NotNil(srv) 138 require.Equal(srv.Addr.String(), s2.config.RPCAddr.String()) 139 require.Nil(err) 140 } 141 142 func TestServerWithNodeConn_Path_Region(t *testing.T) { 143 t.Parallel() 144 require := require.New(t) 145 s1 := TestServer(t, nil) 146 defer s1.Shutdown() 147 s2 := TestServer(t, func(c *Config) { 148 c.Region = "two" 149 }) 150 defer s2.Shutdown() 151 TestJoin(t, s1, s2) 152 testutil.WaitForLeader(t, s1.RPC) 153 testutil.WaitForLeader(t, s2.RPC) 154 155 // Create a fake connection for the node on server 2 156 nodeID := uuid.Generate() 157 s2.addNodeConn(&RPCContext{ 158 NodeID: nodeID, 159 }) 160 161 srv, err := s1.serverWithNodeConn(nodeID, s2.Region()) 162 require.NotNil(srv) 163 require.Equal(srv.Addr.String(), s2.config.RPCAddr.String()) 164 require.Nil(err) 165 } 166 167 func TestServerWithNodeConn_Path_Newest(t *testing.T) { 168 t.Parallel() 169 require := require.New(t) 170 s1 := TestServer(t, nil) 171 defer s1.Shutdown() 172 s2 := TestServer(t, func(c *Config) { 173 c.DevDisableBootstrap = true 174 }) 175 defer s2.Shutdown() 176 s3 := TestServer(t, func(c *Config) { 177 c.DevDisableBootstrap = true 178 }) 179 defer s3.Shutdown() 180 TestJoin(t, s1, s2, s3) 181 testutil.WaitForLeader(t, s1.RPC) 182 testutil.WaitForLeader(t, s2.RPC) 183 testutil.WaitForLeader(t, s3.RPC) 184 185 // Create a fake connection for the node on server 2 and 3 186 nodeID := uuid.Generate() 187 s2.addNodeConn(&RPCContext{ 188 NodeID: nodeID, 189 }) 190 s3.addNodeConn(&RPCContext{ 191 NodeID: nodeID, 192 }) 193 194 srv, err := s1.serverWithNodeConn(nodeID, s1.Region()) 195 require.NotNil(srv) 196 require.Equal(srv.Addr.String(), s3.config.RPCAddr.String()) 197 require.Nil(err) 198 } 199 200 func TestServerWithNodeConn_PathAndErr(t *testing.T) { 201 t.Parallel() 202 require := require.New(t) 203 s1 := TestServer(t, nil) 204 defer s1.Shutdown() 205 s2 := TestServer(t, func(c *Config) { 206 c.DevDisableBootstrap = true 207 }) 208 defer s2.Shutdown() 209 s3 := TestServer(t, func(c *Config) { 210 c.DevDisableBootstrap = true 211 }) 212 defer s3.Shutdown() 213 TestJoin(t, s1, s2, s3) 214 testutil.WaitForLeader(t, s1.RPC) 215 testutil.WaitForLeader(t, s2.RPC) 216 testutil.WaitForLeader(t, s3.RPC) 217 218 // Create a fake connection for the node on server 2 219 nodeID := uuid.Generate() 220 s2.addNodeConn(&RPCContext{ 221 NodeID: nodeID, 222 }) 223 224 // Shutdown the RPC layer for server 3 225 s3.rpcListener.Close() 226 227 srv, err := s1.serverWithNodeConn(nodeID, s1.Region()) 228 require.NotNil(srv) 229 require.Equal(srv.Addr.String(), s2.config.RPCAddr.String()) 230 require.Nil(err) 231 } 232 233 func TestServerWithNodeConn_NoPathAndErr(t *testing.T) { 234 t.Parallel() 235 require := require.New(t) 236 s1 := TestServer(t, nil) 237 defer s1.Shutdown() 238 s2 := TestServer(t, func(c *Config) { 239 c.DevDisableBootstrap = true 240 }) 241 defer s2.Shutdown() 242 s3 := TestServer(t, func(c *Config) { 243 c.DevDisableBootstrap = true 244 }) 245 defer s3.Shutdown() 246 TestJoin(t, s1, s2, s3) 247 testutil.WaitForLeader(t, s1.RPC) 248 testutil.WaitForLeader(t, s2.RPC) 249 testutil.WaitForLeader(t, s3.RPC) 250 251 // Shutdown the RPC layer for server 3 252 s3.rpcListener.Close() 253 254 srv, err := s1.serverWithNodeConn(uuid.Generate(), s1.Region()) 255 require.Nil(srv) 256 require.NotNil(err) 257 require.Contains(err.Error(), "failed querying") 258 } 259 260 func TestNodeStreamingRpc_badEndpoint(t *testing.T) { 261 t.Parallel() 262 require := require.New(t) 263 s1 := TestServer(t, nil) 264 defer s1.Shutdown() 265 testutil.WaitForLeader(t, s1.RPC) 266 267 c := client.TestClient(t, func(c *config.Config) { 268 c.Servers = []string{s1.config.RPCAddr.String()} 269 }) 270 defer c.Shutdown() 271 272 // Wait for the client to connect 273 testutil.WaitForResult(func() (bool, error) { 274 nodes := s1.connectedNodes() 275 return len(nodes) == 1, nil 276 }, func(err error) { 277 t.Fatalf("should have a clients") 278 }) 279 280 state, ok := s1.getNodeConn(c.NodeID()) 281 require.True(ok) 282 283 conn, err := NodeStreamingRpc(state.Session, "Bogus") 284 require.Nil(conn) 285 require.NotNil(err) 286 require.Contains(err.Error(), "Bogus") 287 require.True(structs.IsErrUnknownMethod(err)) 288 }