1// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. 2// source: etcdserver/etcdserverpb/rpc.proto 3 4/* 5Package etcdserverpb is a reverse proxy. 6 7It translates gRPC into RESTful JSON APIs. 8*/ 9package gw 10 11import ( 12 "github.com/coreos/etcd/etcdserver/etcdserverpb" 13 "io" 14 "net/http" 15 16 "github.com/golang/protobuf/proto" 17 "github.com/grpc-ecosystem/grpc-gateway/runtime" 18 "github.com/grpc-ecosystem/grpc-gateway/utilities" 19 "golang.org/x/net/context" 20 "google.golang.org/grpc" 21 "google.golang.org/grpc/codes" 22 "google.golang.org/grpc/grpclog" 23 "google.golang.org/grpc/status" 24) 25 26var _ codes.Code 27var _ io.Reader 28var _ status.Status 29var _ = runtime.String 30var _ = utilities.NewDoubleArray 31 32func request_KV_Range_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 33 var protoReq etcdserverpb.RangeRequest 34 var metadata runtime.ServerMetadata 35 36 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 37 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 38 } 39 40 msg, err := client.Range(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 41 return msg, metadata, err 42 43} 44 45func request_KV_Put_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 46 var protoReq etcdserverpb.PutRequest 47 var metadata runtime.ServerMetadata 48 49 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 50 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 51 } 52 53 msg, err := client.Put(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 54 return msg, metadata, err 55 56} 57 58func request_KV_DeleteRange_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 59 var protoReq etcdserverpb.DeleteRangeRequest 60 var metadata runtime.ServerMetadata 61 62 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 63 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 64 } 65 66 msg, err := client.DeleteRange(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 67 return msg, metadata, err 68 69} 70 71func request_KV_Txn_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 72 var protoReq etcdserverpb.TxnRequest 73 var metadata runtime.ServerMetadata 74 75 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 76 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 77 } 78 79 msg, err := client.Txn(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 80 return msg, metadata, err 81 82} 83 84func request_KV_Compact_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 85 var protoReq etcdserverpb.CompactionRequest 86 var metadata runtime.ServerMetadata 87 88 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 89 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 90 } 91 92 msg, err := client.Compact(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 93 return msg, metadata, err 94 95} 96 97func request_Watch_Watch_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.WatchClient, req *http.Request, pathParams map[string]string) (etcdserverpb.Watch_WatchClient, runtime.ServerMetadata, error) { 98 var metadata runtime.ServerMetadata 99 stream, err := client.Watch(ctx) 100 if err != nil { 101 grpclog.Printf("Failed to start streaming: %v", err) 102 return nil, metadata, err 103 } 104 dec := marshaler.NewDecoder(req.Body) 105 handleSend := func() error { 106 var protoReq etcdserverpb.WatchRequest 107 err = dec.Decode(&protoReq) 108 if err == io.EOF { 109 return err 110 } 111 if err != nil { 112 grpclog.Printf("Failed to decode request: %v", err) 113 return err 114 } 115 if err = stream.Send(&protoReq); err != nil { 116 grpclog.Printf("Failed to send request: %v", err) 117 return err 118 } 119 return nil 120 } 121 if err := handleSend(); err != nil { 122 if cerr := stream.CloseSend(); cerr != nil { 123 grpclog.Printf("Failed to terminate client stream: %v", cerr) 124 } 125 if err == io.EOF { 126 return stream, metadata, nil 127 } 128 return nil, metadata, err 129 } 130 go func() { 131 for { 132 if err := handleSend(); err != nil { 133 break 134 } 135 } 136 if err := stream.CloseSend(); err != nil { 137 grpclog.Printf("Failed to terminate client stream: %v", err) 138 } 139 }() 140 header, err := stream.Header() 141 if err != nil { 142 grpclog.Printf("Failed to get header from client: %v", err) 143 return nil, metadata, err 144 } 145 metadata.HeaderMD = header 146 return stream, metadata, nil 147} 148 149func request_Lease_LeaseGrant_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.LeaseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 150 var protoReq etcdserverpb.LeaseGrantRequest 151 var metadata runtime.ServerMetadata 152 153 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 154 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 155 } 156 157 msg, err := client.LeaseGrant(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 158 return msg, metadata, err 159 160} 161 162func request_Lease_LeaseRevoke_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.LeaseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 163 var protoReq etcdserverpb.LeaseRevokeRequest 164 var metadata runtime.ServerMetadata 165 166 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 167 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 168 } 169 170 msg, err := client.LeaseRevoke(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 171 return msg, metadata, err 172 173} 174 175func request_Lease_LeaseKeepAlive_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.LeaseClient, req *http.Request, pathParams map[string]string) (etcdserverpb.Lease_LeaseKeepAliveClient, runtime.ServerMetadata, error) { 176 var metadata runtime.ServerMetadata 177 stream, err := client.LeaseKeepAlive(ctx) 178 if err != nil { 179 grpclog.Printf("Failed to start streaming: %v", err) 180 return nil, metadata, err 181 } 182 dec := marshaler.NewDecoder(req.Body) 183 handleSend := func() error { 184 var protoReq etcdserverpb.LeaseKeepAliveRequest 185 err = dec.Decode(&protoReq) 186 if err == io.EOF { 187 return err 188 } 189 if err != nil { 190 grpclog.Printf("Failed to decode request: %v", err) 191 return err 192 } 193 if err = stream.Send(&protoReq); err != nil { 194 grpclog.Printf("Failed to send request: %v", err) 195 return err 196 } 197 return nil 198 } 199 if err := handleSend(); err != nil { 200 if cerr := stream.CloseSend(); cerr != nil { 201 grpclog.Printf("Failed to terminate client stream: %v", cerr) 202 } 203 if err == io.EOF { 204 return stream, metadata, nil 205 } 206 return nil, metadata, err 207 } 208 go func() { 209 for { 210 if err := handleSend(); err != nil { 211 break 212 } 213 } 214 if err := stream.CloseSend(); err != nil { 215 grpclog.Printf("Failed to terminate client stream: %v", err) 216 } 217 }() 218 header, err := stream.Header() 219 if err != nil { 220 grpclog.Printf("Failed to get header from client: %v", err) 221 return nil, metadata, err 222 } 223 metadata.HeaderMD = header 224 return stream, metadata, nil 225} 226 227func request_Lease_LeaseTimeToLive_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.LeaseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 228 var protoReq etcdserverpb.LeaseTimeToLiveRequest 229 var metadata runtime.ServerMetadata 230 231 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 232 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 233 } 234 235 msg, err := client.LeaseTimeToLive(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 236 return msg, metadata, err 237 238} 239 240func request_Lease_LeaseLeases_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.LeaseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 241 var protoReq etcdserverpb.LeaseLeasesRequest 242 var metadata runtime.ServerMetadata 243 244 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 245 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 246 } 247 248 msg, err := client.LeaseLeases(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 249 return msg, metadata, err 250 251} 252 253func request_Cluster_MemberAdd_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 254 var protoReq etcdserverpb.MemberAddRequest 255 var metadata runtime.ServerMetadata 256 257 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 258 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 259 } 260 261 msg, err := client.MemberAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 262 return msg, metadata, err 263 264} 265 266func request_Cluster_MemberRemove_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 267 var protoReq etcdserverpb.MemberRemoveRequest 268 var metadata runtime.ServerMetadata 269 270 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 271 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 272 } 273 274 msg, err := client.MemberRemove(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 275 return msg, metadata, err 276 277} 278 279func request_Cluster_MemberUpdate_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 280 var protoReq etcdserverpb.MemberUpdateRequest 281 var metadata runtime.ServerMetadata 282 283 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 284 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 285 } 286 287 msg, err := client.MemberUpdate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 288 return msg, metadata, err 289 290} 291 292func request_Cluster_MemberList_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 293 var protoReq etcdserverpb.MemberListRequest 294 var metadata runtime.ServerMetadata 295 296 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 297 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 298 } 299 300 msg, err := client.MemberList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 301 return msg, metadata, err 302 303} 304 305func request_Maintenance_Alarm_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 306 var protoReq etcdserverpb.AlarmRequest 307 var metadata runtime.ServerMetadata 308 309 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 310 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 311 } 312 313 msg, err := client.Alarm(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 314 return msg, metadata, err 315 316} 317 318func request_Maintenance_Status_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 319 var protoReq etcdserverpb.StatusRequest 320 var metadata runtime.ServerMetadata 321 322 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 323 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 324 } 325 326 msg, err := client.Status(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 327 return msg, metadata, err 328 329} 330 331func request_Maintenance_Defragment_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 332 var protoReq etcdserverpb.DefragmentRequest 333 var metadata runtime.ServerMetadata 334 335 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 336 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 337 } 338 339 msg, err := client.Defragment(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 340 return msg, metadata, err 341 342} 343 344func request_Maintenance_Hash_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 345 var protoReq etcdserverpb.HashRequest 346 var metadata runtime.ServerMetadata 347 348 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 349 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 350 } 351 352 msg, err := client.Hash(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 353 return msg, metadata, err 354 355} 356 357func request_Maintenance_HashKV_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 358 var protoReq etcdserverpb.HashKVRequest 359 var metadata runtime.ServerMetadata 360 361 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 362 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 363 } 364 365 msg, err := client.HashKV(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 366 return msg, metadata, err 367 368} 369 370func request_Maintenance_Snapshot_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (etcdserverpb.Maintenance_SnapshotClient, runtime.ServerMetadata, error) { 371 var protoReq etcdserverpb.SnapshotRequest 372 var metadata runtime.ServerMetadata 373 374 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 375 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 376 } 377 378 stream, err := client.Snapshot(ctx, &protoReq) 379 if err != nil { 380 return nil, metadata, err 381 } 382 header, err := stream.Header() 383 if err != nil { 384 return nil, metadata, err 385 } 386 metadata.HeaderMD = header 387 return stream, metadata, nil 388 389} 390 391func request_Maintenance_MoveLeader_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 392 var protoReq etcdserverpb.MoveLeaderRequest 393 var metadata runtime.ServerMetadata 394 395 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 396 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 397 } 398 399 msg, err := client.MoveLeader(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 400 return msg, metadata, err 401 402} 403 404func request_Auth_AuthEnable_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 405 var protoReq etcdserverpb.AuthEnableRequest 406 var metadata runtime.ServerMetadata 407 408 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 409 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 410 } 411 412 msg, err := client.AuthEnable(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 413 return msg, metadata, err 414 415} 416 417func request_Auth_AuthDisable_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 418 var protoReq etcdserverpb.AuthDisableRequest 419 var metadata runtime.ServerMetadata 420 421 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 422 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 423 } 424 425 msg, err := client.AuthDisable(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 426 return msg, metadata, err 427 428} 429 430func request_Auth_Authenticate_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 431 var protoReq etcdserverpb.AuthenticateRequest 432 var metadata runtime.ServerMetadata 433 434 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 435 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 436 } 437 438 msg, err := client.Authenticate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 439 return msg, metadata, err 440 441} 442 443func request_Auth_UserAdd_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 444 var protoReq etcdserverpb.AuthUserAddRequest 445 var metadata runtime.ServerMetadata 446 447 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 448 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 449 } 450 451 msg, err := client.UserAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 452 return msg, metadata, err 453 454} 455 456func request_Auth_UserGet_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 457 var protoReq etcdserverpb.AuthUserGetRequest 458 var metadata runtime.ServerMetadata 459 460 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 461 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 462 } 463 464 msg, err := client.UserGet(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 465 return msg, metadata, err 466 467} 468 469func request_Auth_UserList_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 470 var protoReq etcdserverpb.AuthUserListRequest 471 var metadata runtime.ServerMetadata 472 473 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 474 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 475 } 476 477 msg, err := client.UserList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 478 return msg, metadata, err 479 480} 481 482func request_Auth_UserDelete_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 483 var protoReq etcdserverpb.AuthUserDeleteRequest 484 var metadata runtime.ServerMetadata 485 486 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 487 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 488 } 489 490 msg, err := client.UserDelete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 491 return msg, metadata, err 492 493} 494 495func request_Auth_UserChangePassword_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 496 var protoReq etcdserverpb.AuthUserChangePasswordRequest 497 var metadata runtime.ServerMetadata 498 499 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 500 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 501 } 502 503 msg, err := client.UserChangePassword(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 504 return msg, metadata, err 505 506} 507 508func request_Auth_UserGrantRole_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 509 var protoReq etcdserverpb.AuthUserGrantRoleRequest 510 var metadata runtime.ServerMetadata 511 512 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 513 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 514 } 515 516 msg, err := client.UserGrantRole(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 517 return msg, metadata, err 518 519} 520 521func request_Auth_UserRevokeRole_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 522 var protoReq etcdserverpb.AuthUserRevokeRoleRequest 523 var metadata runtime.ServerMetadata 524 525 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 526 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 527 } 528 529 msg, err := client.UserRevokeRole(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 530 return msg, metadata, err 531 532} 533 534func request_Auth_RoleAdd_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 535 var protoReq etcdserverpb.AuthRoleAddRequest 536 var metadata runtime.ServerMetadata 537 538 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 539 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 540 } 541 542 msg, err := client.RoleAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 543 return msg, metadata, err 544 545} 546 547func request_Auth_RoleGet_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 548 var protoReq etcdserverpb.AuthRoleGetRequest 549 var metadata runtime.ServerMetadata 550 551 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 552 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 553 } 554 555 msg, err := client.RoleGet(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 556 return msg, metadata, err 557 558} 559 560func request_Auth_RoleList_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 561 var protoReq etcdserverpb.AuthRoleListRequest 562 var metadata runtime.ServerMetadata 563 564 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 565 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 566 } 567 568 msg, err := client.RoleList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 569 return msg, metadata, err 570 571} 572 573func request_Auth_RoleDelete_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 574 var protoReq etcdserverpb.AuthRoleDeleteRequest 575 var metadata runtime.ServerMetadata 576 577 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 578 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 579 } 580 581 msg, err := client.RoleDelete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 582 return msg, metadata, err 583 584} 585 586func request_Auth_RoleGrantPermission_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 587 var protoReq etcdserverpb.AuthRoleGrantPermissionRequest 588 var metadata runtime.ServerMetadata 589 590 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 591 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 592 } 593 594 msg, err := client.RoleGrantPermission(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 595 return msg, metadata, err 596 597} 598 599func request_Auth_RoleRevokePermission_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 600 var protoReq etcdserverpb.AuthRoleRevokePermissionRequest 601 var metadata runtime.ServerMetadata 602 603 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 604 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 605 } 606 607 msg, err := client.RoleRevokePermission(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 608 return msg, metadata, err 609 610} 611 612// RegisterKVHandlerFromEndpoint is same as RegisterKVHandler but 613// automatically dials to "endpoint" and closes the connection when "ctx" gets done. 614func RegisterKVHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 615 conn, err := grpc.Dial(endpoint, opts...) 616 if err != nil { 617 return err 618 } 619 defer func() { 620 if err != nil { 621 if cerr := conn.Close(); cerr != nil { 622 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 623 } 624 return 625 } 626 go func() { 627 <-ctx.Done() 628 if cerr := conn.Close(); cerr != nil { 629 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 630 } 631 }() 632 }() 633 634 return RegisterKVHandler(ctx, mux, conn) 635} 636 637// RegisterKVHandler registers the http handlers for service KV to "mux". 638// The handlers forward requests to the grpc endpoint over "conn". 639func RegisterKVHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 640 return RegisterKVHandlerClient(ctx, mux, etcdserverpb.NewKVClient(conn)) 641} 642 643// RegisterKVHandler registers the http handlers for service KV to "mux". 644// The handlers forward requests to the grpc endpoint over the given implementation of "KVClient". 645// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "KVClient" 646// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 647// "KVClient" to call the correct interceptors. 648func RegisterKVHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.KVClient) error { 649 650 mux.Handle("POST", pattern_KV_Range_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 651 ctx, cancel := context.WithCancel(req.Context()) 652 defer cancel() 653 if cn, ok := w.(http.CloseNotifier); ok { 654 go func(done <-chan struct{}, closed <-chan bool) { 655 select { 656 case <-done: 657 case <-closed: 658 cancel() 659 } 660 }(ctx.Done(), cn.CloseNotify()) 661 } 662 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 663 rctx, err := runtime.AnnotateContext(ctx, mux, req) 664 if err != nil { 665 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 666 return 667 } 668 resp, md, err := request_KV_Range_0(rctx, inboundMarshaler, client, req, pathParams) 669 ctx = runtime.NewServerMetadataContext(ctx, md) 670 if err != nil { 671 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 672 return 673 } 674 675 forward_KV_Range_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 676 677 }) 678 679 mux.Handle("POST", pattern_KV_Put_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 680 ctx, cancel := context.WithCancel(req.Context()) 681 defer cancel() 682 if cn, ok := w.(http.CloseNotifier); ok { 683 go func(done <-chan struct{}, closed <-chan bool) { 684 select { 685 case <-done: 686 case <-closed: 687 cancel() 688 } 689 }(ctx.Done(), cn.CloseNotify()) 690 } 691 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 692 rctx, err := runtime.AnnotateContext(ctx, mux, req) 693 if err != nil { 694 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 695 return 696 } 697 resp, md, err := request_KV_Put_0(rctx, inboundMarshaler, client, req, pathParams) 698 ctx = runtime.NewServerMetadataContext(ctx, md) 699 if err != nil { 700 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 701 return 702 } 703 704 forward_KV_Put_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 705 706 }) 707 708 mux.Handle("POST", pattern_KV_DeleteRange_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 709 ctx, cancel := context.WithCancel(req.Context()) 710 defer cancel() 711 if cn, ok := w.(http.CloseNotifier); ok { 712 go func(done <-chan struct{}, closed <-chan bool) { 713 select { 714 case <-done: 715 case <-closed: 716 cancel() 717 } 718 }(ctx.Done(), cn.CloseNotify()) 719 } 720 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 721 rctx, err := runtime.AnnotateContext(ctx, mux, req) 722 if err != nil { 723 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 724 return 725 } 726 resp, md, err := request_KV_DeleteRange_0(rctx, inboundMarshaler, client, req, pathParams) 727 ctx = runtime.NewServerMetadataContext(ctx, md) 728 if err != nil { 729 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 730 return 731 } 732 733 forward_KV_DeleteRange_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 734 735 }) 736 737 mux.Handle("POST", pattern_KV_Txn_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 738 ctx, cancel := context.WithCancel(req.Context()) 739 defer cancel() 740 if cn, ok := w.(http.CloseNotifier); ok { 741 go func(done <-chan struct{}, closed <-chan bool) { 742 select { 743 case <-done: 744 case <-closed: 745 cancel() 746 } 747 }(ctx.Done(), cn.CloseNotify()) 748 } 749 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 750 rctx, err := runtime.AnnotateContext(ctx, mux, req) 751 if err != nil { 752 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 753 return 754 } 755 resp, md, err := request_KV_Txn_0(rctx, inboundMarshaler, client, req, pathParams) 756 ctx = runtime.NewServerMetadataContext(ctx, md) 757 if err != nil { 758 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 759 return 760 } 761 762 forward_KV_Txn_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 763 764 }) 765 766 mux.Handle("POST", pattern_KV_Compact_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 767 ctx, cancel := context.WithCancel(req.Context()) 768 defer cancel() 769 if cn, ok := w.(http.CloseNotifier); ok { 770 go func(done <-chan struct{}, closed <-chan bool) { 771 select { 772 case <-done: 773 case <-closed: 774 cancel() 775 } 776 }(ctx.Done(), cn.CloseNotify()) 777 } 778 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 779 rctx, err := runtime.AnnotateContext(ctx, mux, req) 780 if err != nil { 781 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 782 return 783 } 784 resp, md, err := request_KV_Compact_0(rctx, inboundMarshaler, client, req, pathParams) 785 ctx = runtime.NewServerMetadataContext(ctx, md) 786 if err != nil { 787 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 788 return 789 } 790 791 forward_KV_Compact_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 792 793 }) 794 795 return nil 796} 797 798var ( 799 pattern_KV_Range_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "kv", "range"}, "")) 800 801 pattern_KV_Put_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "kv", "put"}, "")) 802 803 pattern_KV_DeleteRange_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "kv", "deleterange"}, "")) 804 805 pattern_KV_Txn_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "kv", "txn"}, "")) 806 807 pattern_KV_Compact_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "kv", "compaction"}, "")) 808) 809 810var ( 811 forward_KV_Range_0 = runtime.ForwardResponseMessage 812 813 forward_KV_Put_0 = runtime.ForwardResponseMessage 814 815 forward_KV_DeleteRange_0 = runtime.ForwardResponseMessage 816 817 forward_KV_Txn_0 = runtime.ForwardResponseMessage 818 819 forward_KV_Compact_0 = runtime.ForwardResponseMessage 820) 821 822// RegisterWatchHandlerFromEndpoint is same as RegisterWatchHandler but 823// automatically dials to "endpoint" and closes the connection when "ctx" gets done. 824func RegisterWatchHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 825 conn, err := grpc.Dial(endpoint, opts...) 826 if err != nil { 827 return err 828 } 829 defer func() { 830 if err != nil { 831 if cerr := conn.Close(); cerr != nil { 832 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 833 } 834 return 835 } 836 go func() { 837 <-ctx.Done() 838 if cerr := conn.Close(); cerr != nil { 839 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 840 } 841 }() 842 }() 843 844 return RegisterWatchHandler(ctx, mux, conn) 845} 846 847// RegisterWatchHandler registers the http handlers for service Watch to "mux". 848// The handlers forward requests to the grpc endpoint over "conn". 849func RegisterWatchHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 850 return RegisterWatchHandlerClient(ctx, mux, etcdserverpb.NewWatchClient(conn)) 851} 852 853// RegisterWatchHandler registers the http handlers for service Watch to "mux". 854// The handlers forward requests to the grpc endpoint over the given implementation of "WatchClient". 855// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "WatchClient" 856// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 857// "WatchClient" to call the correct interceptors. 858func RegisterWatchHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.WatchClient) error { 859 860 mux.Handle("POST", pattern_Watch_Watch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 861 ctx, cancel := context.WithCancel(req.Context()) 862 defer cancel() 863 if cn, ok := w.(http.CloseNotifier); ok { 864 go func(done <-chan struct{}, closed <-chan bool) { 865 select { 866 case <-done: 867 case <-closed: 868 cancel() 869 } 870 }(ctx.Done(), cn.CloseNotify()) 871 } 872 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 873 rctx, err := runtime.AnnotateContext(ctx, mux, req) 874 if err != nil { 875 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 876 return 877 } 878 resp, md, err := request_Watch_Watch_0(rctx, inboundMarshaler, client, req, pathParams) 879 ctx = runtime.NewServerMetadataContext(ctx, md) 880 if err != nil { 881 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 882 return 883 } 884 885 forward_Watch_Watch_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 886 887 }) 888 889 return nil 890} 891 892var ( 893 pattern_Watch_Watch_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v3beta", "watch"}, "")) 894) 895 896var ( 897 forward_Watch_Watch_0 = runtime.ForwardResponseStream 898) 899 900// RegisterLeaseHandlerFromEndpoint is same as RegisterLeaseHandler but 901// automatically dials to "endpoint" and closes the connection when "ctx" gets done. 902func RegisterLeaseHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 903 conn, err := grpc.Dial(endpoint, opts...) 904 if err != nil { 905 return err 906 } 907 defer func() { 908 if err != nil { 909 if cerr := conn.Close(); cerr != nil { 910 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 911 } 912 return 913 } 914 go func() { 915 <-ctx.Done() 916 if cerr := conn.Close(); cerr != nil { 917 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 918 } 919 }() 920 }() 921 922 return RegisterLeaseHandler(ctx, mux, conn) 923} 924 925// RegisterLeaseHandler registers the http handlers for service Lease to "mux". 926// The handlers forward requests to the grpc endpoint over "conn". 927func RegisterLeaseHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 928 return RegisterLeaseHandlerClient(ctx, mux, etcdserverpb.NewLeaseClient(conn)) 929} 930 931// RegisterLeaseHandler registers the http handlers for service Lease to "mux". 932// The handlers forward requests to the grpc endpoint over the given implementation of "LeaseClient". 933// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "LeaseClient" 934// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 935// "LeaseClient" to call the correct interceptors. 936func RegisterLeaseHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.LeaseClient) error { 937 938 mux.Handle("POST", pattern_Lease_LeaseGrant_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 939 ctx, cancel := context.WithCancel(req.Context()) 940 defer cancel() 941 if cn, ok := w.(http.CloseNotifier); ok { 942 go func(done <-chan struct{}, closed <-chan bool) { 943 select { 944 case <-done: 945 case <-closed: 946 cancel() 947 } 948 }(ctx.Done(), cn.CloseNotify()) 949 } 950 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 951 rctx, err := runtime.AnnotateContext(ctx, mux, req) 952 if err != nil { 953 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 954 return 955 } 956 resp, md, err := request_Lease_LeaseGrant_0(rctx, inboundMarshaler, client, req, pathParams) 957 ctx = runtime.NewServerMetadataContext(ctx, md) 958 if err != nil { 959 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 960 return 961 } 962 963 forward_Lease_LeaseGrant_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 964 965 }) 966 967 mux.Handle("POST", pattern_Lease_LeaseRevoke_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 968 ctx, cancel := context.WithCancel(req.Context()) 969 defer cancel() 970 if cn, ok := w.(http.CloseNotifier); ok { 971 go func(done <-chan struct{}, closed <-chan bool) { 972 select { 973 case <-done: 974 case <-closed: 975 cancel() 976 } 977 }(ctx.Done(), cn.CloseNotify()) 978 } 979 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 980 rctx, err := runtime.AnnotateContext(ctx, mux, req) 981 if err != nil { 982 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 983 return 984 } 985 resp, md, err := request_Lease_LeaseRevoke_0(rctx, inboundMarshaler, client, req, pathParams) 986 ctx = runtime.NewServerMetadataContext(ctx, md) 987 if err != nil { 988 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 989 return 990 } 991 992 forward_Lease_LeaseRevoke_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 993 994 }) 995 996 mux.Handle("POST", pattern_Lease_LeaseKeepAlive_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 997 ctx, cancel := context.WithCancel(req.Context()) 998 defer cancel() 999 if cn, ok := w.(http.CloseNotifier); ok { 1000 go func(done <-chan struct{}, closed <-chan bool) { 1001 select { 1002 case <-done: 1003 case <-closed: 1004 cancel() 1005 } 1006 }(ctx.Done(), cn.CloseNotify()) 1007 } 1008 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1009 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1010 if err != nil { 1011 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1012 return 1013 } 1014 resp, md, err := request_Lease_LeaseKeepAlive_0(rctx, inboundMarshaler, client, req, pathParams) 1015 ctx = runtime.NewServerMetadataContext(ctx, md) 1016 if err != nil { 1017 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1018 return 1019 } 1020 1021 forward_Lease_LeaseKeepAlive_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1022 1023 }) 1024 1025 mux.Handle("POST", pattern_Lease_LeaseTimeToLive_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1026 ctx, cancel := context.WithCancel(req.Context()) 1027 defer cancel() 1028 if cn, ok := w.(http.CloseNotifier); ok { 1029 go func(done <-chan struct{}, closed <-chan bool) { 1030 select { 1031 case <-done: 1032 case <-closed: 1033 cancel() 1034 } 1035 }(ctx.Done(), cn.CloseNotify()) 1036 } 1037 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1038 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1039 if err != nil { 1040 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1041 return 1042 } 1043 resp, md, err := request_Lease_LeaseTimeToLive_0(rctx, inboundMarshaler, client, req, pathParams) 1044 ctx = runtime.NewServerMetadataContext(ctx, md) 1045 if err != nil { 1046 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1047 return 1048 } 1049 1050 forward_Lease_LeaseTimeToLive_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1051 1052 }) 1053 1054 mux.Handle("POST", pattern_Lease_LeaseLeases_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1055 ctx, cancel := context.WithCancel(req.Context()) 1056 defer cancel() 1057 if cn, ok := w.(http.CloseNotifier); ok { 1058 go func(done <-chan struct{}, closed <-chan bool) { 1059 select { 1060 case <-done: 1061 case <-closed: 1062 cancel() 1063 } 1064 }(ctx.Done(), cn.CloseNotify()) 1065 } 1066 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1067 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1068 if err != nil { 1069 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1070 return 1071 } 1072 resp, md, err := request_Lease_LeaseLeases_0(rctx, inboundMarshaler, client, req, pathParams) 1073 ctx = runtime.NewServerMetadataContext(ctx, md) 1074 if err != nil { 1075 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1076 return 1077 } 1078 1079 forward_Lease_LeaseLeases_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1080 1081 }) 1082 1083 return nil 1084} 1085 1086var ( 1087 pattern_Lease_LeaseGrant_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "lease", "grant"}, "")) 1088 1089 pattern_Lease_LeaseRevoke_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "kv", "lease", "revoke"}, "")) 1090 1091 pattern_Lease_LeaseKeepAlive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "lease", "keepalive"}, "")) 1092 1093 pattern_Lease_LeaseTimeToLive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "kv", "lease", "timetolive"}, "")) 1094 1095 pattern_Lease_LeaseLeases_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "kv", "lease", "leases"}, "")) 1096) 1097 1098var ( 1099 forward_Lease_LeaseGrant_0 = runtime.ForwardResponseMessage 1100 1101 forward_Lease_LeaseRevoke_0 = runtime.ForwardResponseMessage 1102 1103 forward_Lease_LeaseKeepAlive_0 = runtime.ForwardResponseStream 1104 1105 forward_Lease_LeaseTimeToLive_0 = runtime.ForwardResponseMessage 1106 1107 forward_Lease_LeaseLeases_0 = runtime.ForwardResponseMessage 1108) 1109 1110// RegisterClusterHandlerFromEndpoint is same as RegisterClusterHandler but 1111// automatically dials to "endpoint" and closes the connection when "ctx" gets done. 1112func RegisterClusterHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 1113 conn, err := grpc.Dial(endpoint, opts...) 1114 if err != nil { 1115 return err 1116 } 1117 defer func() { 1118 if err != nil { 1119 if cerr := conn.Close(); cerr != nil { 1120 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 1121 } 1122 return 1123 } 1124 go func() { 1125 <-ctx.Done() 1126 if cerr := conn.Close(); cerr != nil { 1127 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 1128 } 1129 }() 1130 }() 1131 1132 return RegisterClusterHandler(ctx, mux, conn) 1133} 1134 1135// RegisterClusterHandler registers the http handlers for service Cluster to "mux". 1136// The handlers forward requests to the grpc endpoint over "conn". 1137func RegisterClusterHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 1138 return RegisterClusterHandlerClient(ctx, mux, etcdserverpb.NewClusterClient(conn)) 1139} 1140 1141// RegisterClusterHandler registers the http handlers for service Cluster to "mux". 1142// The handlers forward requests to the grpc endpoint over the given implementation of "ClusterClient". 1143// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ClusterClient" 1144// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 1145// "ClusterClient" to call the correct interceptors. 1146func RegisterClusterHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.ClusterClient) error { 1147 1148 mux.Handle("POST", pattern_Cluster_MemberAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1149 ctx, cancel := context.WithCancel(req.Context()) 1150 defer cancel() 1151 if cn, ok := w.(http.CloseNotifier); ok { 1152 go func(done <-chan struct{}, closed <-chan bool) { 1153 select { 1154 case <-done: 1155 case <-closed: 1156 cancel() 1157 } 1158 }(ctx.Done(), cn.CloseNotify()) 1159 } 1160 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1161 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1162 if err != nil { 1163 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1164 return 1165 } 1166 resp, md, err := request_Cluster_MemberAdd_0(rctx, inboundMarshaler, client, req, pathParams) 1167 ctx = runtime.NewServerMetadataContext(ctx, md) 1168 if err != nil { 1169 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1170 return 1171 } 1172 1173 forward_Cluster_MemberAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1174 1175 }) 1176 1177 mux.Handle("POST", pattern_Cluster_MemberRemove_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1178 ctx, cancel := context.WithCancel(req.Context()) 1179 defer cancel() 1180 if cn, ok := w.(http.CloseNotifier); ok { 1181 go func(done <-chan struct{}, closed <-chan bool) { 1182 select { 1183 case <-done: 1184 case <-closed: 1185 cancel() 1186 } 1187 }(ctx.Done(), cn.CloseNotify()) 1188 } 1189 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1190 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1191 if err != nil { 1192 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1193 return 1194 } 1195 resp, md, err := request_Cluster_MemberRemove_0(rctx, inboundMarshaler, client, req, pathParams) 1196 ctx = runtime.NewServerMetadataContext(ctx, md) 1197 if err != nil { 1198 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1199 return 1200 } 1201 1202 forward_Cluster_MemberRemove_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1203 1204 }) 1205 1206 mux.Handle("POST", pattern_Cluster_MemberUpdate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1207 ctx, cancel := context.WithCancel(req.Context()) 1208 defer cancel() 1209 if cn, ok := w.(http.CloseNotifier); ok { 1210 go func(done <-chan struct{}, closed <-chan bool) { 1211 select { 1212 case <-done: 1213 case <-closed: 1214 cancel() 1215 } 1216 }(ctx.Done(), cn.CloseNotify()) 1217 } 1218 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1219 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1220 if err != nil { 1221 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1222 return 1223 } 1224 resp, md, err := request_Cluster_MemberUpdate_0(rctx, inboundMarshaler, client, req, pathParams) 1225 ctx = runtime.NewServerMetadataContext(ctx, md) 1226 if err != nil { 1227 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1228 return 1229 } 1230 1231 forward_Cluster_MemberUpdate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1232 1233 }) 1234 1235 mux.Handle("POST", pattern_Cluster_MemberList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1236 ctx, cancel := context.WithCancel(req.Context()) 1237 defer cancel() 1238 if cn, ok := w.(http.CloseNotifier); ok { 1239 go func(done <-chan struct{}, closed <-chan bool) { 1240 select { 1241 case <-done: 1242 case <-closed: 1243 cancel() 1244 } 1245 }(ctx.Done(), cn.CloseNotify()) 1246 } 1247 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1248 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1249 if err != nil { 1250 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1251 return 1252 } 1253 resp, md, err := request_Cluster_MemberList_0(rctx, inboundMarshaler, client, req, pathParams) 1254 ctx = runtime.NewServerMetadataContext(ctx, md) 1255 if err != nil { 1256 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1257 return 1258 } 1259 1260 forward_Cluster_MemberList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1261 1262 }) 1263 1264 return nil 1265} 1266 1267var ( 1268 pattern_Cluster_MemberAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "cluster", "member", "add"}, "")) 1269 1270 pattern_Cluster_MemberRemove_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "cluster", "member", "remove"}, "")) 1271 1272 pattern_Cluster_MemberUpdate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "cluster", "member", "update"}, "")) 1273 1274 pattern_Cluster_MemberList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "cluster", "member", "list"}, "")) 1275) 1276 1277var ( 1278 forward_Cluster_MemberAdd_0 = runtime.ForwardResponseMessage 1279 1280 forward_Cluster_MemberRemove_0 = runtime.ForwardResponseMessage 1281 1282 forward_Cluster_MemberUpdate_0 = runtime.ForwardResponseMessage 1283 1284 forward_Cluster_MemberList_0 = runtime.ForwardResponseMessage 1285) 1286 1287// RegisterMaintenanceHandlerFromEndpoint is same as RegisterMaintenanceHandler but 1288// automatically dials to "endpoint" and closes the connection when "ctx" gets done. 1289func RegisterMaintenanceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 1290 conn, err := grpc.Dial(endpoint, opts...) 1291 if err != nil { 1292 return err 1293 } 1294 defer func() { 1295 if err != nil { 1296 if cerr := conn.Close(); cerr != nil { 1297 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 1298 } 1299 return 1300 } 1301 go func() { 1302 <-ctx.Done() 1303 if cerr := conn.Close(); cerr != nil { 1304 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 1305 } 1306 }() 1307 }() 1308 1309 return RegisterMaintenanceHandler(ctx, mux, conn) 1310} 1311 1312// RegisterMaintenanceHandler registers the http handlers for service Maintenance to "mux". 1313// The handlers forward requests to the grpc endpoint over "conn". 1314func RegisterMaintenanceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 1315 return RegisterMaintenanceHandlerClient(ctx, mux, etcdserverpb.NewMaintenanceClient(conn)) 1316} 1317 1318// RegisterMaintenanceHandler registers the http handlers for service Maintenance to "mux". 1319// The handlers forward requests to the grpc endpoint over the given implementation of "MaintenanceClient". 1320// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "MaintenanceClient" 1321// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 1322// "MaintenanceClient" to call the correct interceptors. 1323func RegisterMaintenanceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.MaintenanceClient) error { 1324 1325 mux.Handle("POST", pattern_Maintenance_Alarm_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1326 ctx, cancel := context.WithCancel(req.Context()) 1327 defer cancel() 1328 if cn, ok := w.(http.CloseNotifier); ok { 1329 go func(done <-chan struct{}, closed <-chan bool) { 1330 select { 1331 case <-done: 1332 case <-closed: 1333 cancel() 1334 } 1335 }(ctx.Done(), cn.CloseNotify()) 1336 } 1337 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1338 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1339 if err != nil { 1340 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1341 return 1342 } 1343 resp, md, err := request_Maintenance_Alarm_0(rctx, inboundMarshaler, client, req, pathParams) 1344 ctx = runtime.NewServerMetadataContext(ctx, md) 1345 if err != nil { 1346 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1347 return 1348 } 1349 1350 forward_Maintenance_Alarm_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1351 1352 }) 1353 1354 mux.Handle("POST", pattern_Maintenance_Status_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1355 ctx, cancel := context.WithCancel(req.Context()) 1356 defer cancel() 1357 if cn, ok := w.(http.CloseNotifier); ok { 1358 go func(done <-chan struct{}, closed <-chan bool) { 1359 select { 1360 case <-done: 1361 case <-closed: 1362 cancel() 1363 } 1364 }(ctx.Done(), cn.CloseNotify()) 1365 } 1366 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1367 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1368 if err != nil { 1369 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1370 return 1371 } 1372 resp, md, err := request_Maintenance_Status_0(rctx, inboundMarshaler, client, req, pathParams) 1373 ctx = runtime.NewServerMetadataContext(ctx, md) 1374 if err != nil { 1375 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1376 return 1377 } 1378 1379 forward_Maintenance_Status_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1380 1381 }) 1382 1383 mux.Handle("POST", pattern_Maintenance_Defragment_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1384 ctx, cancel := context.WithCancel(req.Context()) 1385 defer cancel() 1386 if cn, ok := w.(http.CloseNotifier); ok { 1387 go func(done <-chan struct{}, closed <-chan bool) { 1388 select { 1389 case <-done: 1390 case <-closed: 1391 cancel() 1392 } 1393 }(ctx.Done(), cn.CloseNotify()) 1394 } 1395 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1396 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1397 if err != nil { 1398 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1399 return 1400 } 1401 resp, md, err := request_Maintenance_Defragment_0(rctx, inboundMarshaler, client, req, pathParams) 1402 ctx = runtime.NewServerMetadataContext(ctx, md) 1403 if err != nil { 1404 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1405 return 1406 } 1407 1408 forward_Maintenance_Defragment_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1409 1410 }) 1411 1412 mux.Handle("POST", pattern_Maintenance_Hash_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1413 ctx, cancel := context.WithCancel(req.Context()) 1414 defer cancel() 1415 if cn, ok := w.(http.CloseNotifier); ok { 1416 go func(done <-chan struct{}, closed <-chan bool) { 1417 select { 1418 case <-done: 1419 case <-closed: 1420 cancel() 1421 } 1422 }(ctx.Done(), cn.CloseNotify()) 1423 } 1424 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1425 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1426 if err != nil { 1427 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1428 return 1429 } 1430 resp, md, err := request_Maintenance_Hash_0(rctx, inboundMarshaler, client, req, pathParams) 1431 ctx = runtime.NewServerMetadataContext(ctx, md) 1432 if err != nil { 1433 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1434 return 1435 } 1436 1437 forward_Maintenance_Hash_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1438 1439 }) 1440 1441 mux.Handle("POST", pattern_Maintenance_HashKV_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1442 ctx, cancel := context.WithCancel(req.Context()) 1443 defer cancel() 1444 if cn, ok := w.(http.CloseNotifier); ok { 1445 go func(done <-chan struct{}, closed <-chan bool) { 1446 select { 1447 case <-done: 1448 case <-closed: 1449 cancel() 1450 } 1451 }(ctx.Done(), cn.CloseNotify()) 1452 } 1453 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1454 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1455 if err != nil { 1456 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1457 return 1458 } 1459 resp, md, err := request_Maintenance_HashKV_0(rctx, inboundMarshaler, client, req, pathParams) 1460 ctx = runtime.NewServerMetadataContext(ctx, md) 1461 if err != nil { 1462 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1463 return 1464 } 1465 1466 forward_Maintenance_HashKV_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1467 1468 }) 1469 1470 mux.Handle("POST", pattern_Maintenance_Snapshot_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1471 ctx, cancel := context.WithCancel(req.Context()) 1472 defer cancel() 1473 if cn, ok := w.(http.CloseNotifier); ok { 1474 go func(done <-chan struct{}, closed <-chan bool) { 1475 select { 1476 case <-done: 1477 case <-closed: 1478 cancel() 1479 } 1480 }(ctx.Done(), cn.CloseNotify()) 1481 } 1482 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1483 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1484 if err != nil { 1485 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1486 return 1487 } 1488 resp, md, err := request_Maintenance_Snapshot_0(rctx, inboundMarshaler, client, req, pathParams) 1489 ctx = runtime.NewServerMetadataContext(ctx, md) 1490 if err != nil { 1491 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1492 return 1493 } 1494 1495 forward_Maintenance_Snapshot_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1496 1497 }) 1498 1499 mux.Handle("POST", pattern_Maintenance_MoveLeader_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1500 ctx, cancel := context.WithCancel(req.Context()) 1501 defer cancel() 1502 if cn, ok := w.(http.CloseNotifier); ok { 1503 go func(done <-chan struct{}, closed <-chan bool) { 1504 select { 1505 case <-done: 1506 case <-closed: 1507 cancel() 1508 } 1509 }(ctx.Done(), cn.CloseNotify()) 1510 } 1511 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1512 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1513 if err != nil { 1514 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1515 return 1516 } 1517 resp, md, err := request_Maintenance_MoveLeader_0(rctx, inboundMarshaler, client, req, pathParams) 1518 ctx = runtime.NewServerMetadataContext(ctx, md) 1519 if err != nil { 1520 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1521 return 1522 } 1523 1524 forward_Maintenance_MoveLeader_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1525 1526 }) 1527 1528 return nil 1529} 1530 1531var ( 1532 pattern_Maintenance_Alarm_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "maintenance", "alarm"}, "")) 1533 1534 pattern_Maintenance_Status_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "maintenance", "status"}, "")) 1535 1536 pattern_Maintenance_Defragment_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "maintenance", "defragment"}, "")) 1537 1538 pattern_Maintenance_Hash_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "maintenance", "hash"}, "")) 1539 1540 pattern_Maintenance_HashKV_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "maintenance", "hash"}, "")) 1541 1542 pattern_Maintenance_Snapshot_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "maintenance", "snapshot"}, "")) 1543 1544 pattern_Maintenance_MoveLeader_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "maintenance", "transfer-leadership"}, "")) 1545) 1546 1547var ( 1548 forward_Maintenance_Alarm_0 = runtime.ForwardResponseMessage 1549 1550 forward_Maintenance_Status_0 = runtime.ForwardResponseMessage 1551 1552 forward_Maintenance_Defragment_0 = runtime.ForwardResponseMessage 1553 1554 forward_Maintenance_Hash_0 = runtime.ForwardResponseMessage 1555 1556 forward_Maintenance_HashKV_0 = runtime.ForwardResponseMessage 1557 1558 forward_Maintenance_Snapshot_0 = runtime.ForwardResponseStream 1559 1560 forward_Maintenance_MoveLeader_0 = runtime.ForwardResponseMessage 1561) 1562 1563// RegisterAuthHandlerFromEndpoint is same as RegisterAuthHandler but 1564// automatically dials to "endpoint" and closes the connection when "ctx" gets done. 1565func RegisterAuthHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 1566 conn, err := grpc.Dial(endpoint, opts...) 1567 if err != nil { 1568 return err 1569 } 1570 defer func() { 1571 if err != nil { 1572 if cerr := conn.Close(); cerr != nil { 1573 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 1574 } 1575 return 1576 } 1577 go func() { 1578 <-ctx.Done() 1579 if cerr := conn.Close(); cerr != nil { 1580 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 1581 } 1582 }() 1583 }() 1584 1585 return RegisterAuthHandler(ctx, mux, conn) 1586} 1587 1588// RegisterAuthHandler registers the http handlers for service Auth to "mux". 1589// The handlers forward requests to the grpc endpoint over "conn". 1590func RegisterAuthHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 1591 return RegisterAuthHandlerClient(ctx, mux, etcdserverpb.NewAuthClient(conn)) 1592} 1593 1594// RegisterAuthHandler registers the http handlers for service Auth to "mux". 1595// The handlers forward requests to the grpc endpoint over the given implementation of "AuthClient". 1596// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AuthClient" 1597// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 1598// "AuthClient" to call the correct interceptors. 1599func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.AuthClient) error { 1600 1601 mux.Handle("POST", pattern_Auth_AuthEnable_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1602 ctx, cancel := context.WithCancel(req.Context()) 1603 defer cancel() 1604 if cn, ok := w.(http.CloseNotifier); ok { 1605 go func(done <-chan struct{}, closed <-chan bool) { 1606 select { 1607 case <-done: 1608 case <-closed: 1609 cancel() 1610 } 1611 }(ctx.Done(), cn.CloseNotify()) 1612 } 1613 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1614 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1615 if err != nil { 1616 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1617 return 1618 } 1619 resp, md, err := request_Auth_AuthEnable_0(rctx, inboundMarshaler, client, req, pathParams) 1620 ctx = runtime.NewServerMetadataContext(ctx, md) 1621 if err != nil { 1622 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1623 return 1624 } 1625 1626 forward_Auth_AuthEnable_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1627 1628 }) 1629 1630 mux.Handle("POST", pattern_Auth_AuthDisable_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1631 ctx, cancel := context.WithCancel(req.Context()) 1632 defer cancel() 1633 if cn, ok := w.(http.CloseNotifier); ok { 1634 go func(done <-chan struct{}, closed <-chan bool) { 1635 select { 1636 case <-done: 1637 case <-closed: 1638 cancel() 1639 } 1640 }(ctx.Done(), cn.CloseNotify()) 1641 } 1642 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1643 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1644 if err != nil { 1645 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1646 return 1647 } 1648 resp, md, err := request_Auth_AuthDisable_0(rctx, inboundMarshaler, client, req, pathParams) 1649 ctx = runtime.NewServerMetadataContext(ctx, md) 1650 if err != nil { 1651 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1652 return 1653 } 1654 1655 forward_Auth_AuthDisable_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1656 1657 }) 1658 1659 mux.Handle("POST", pattern_Auth_Authenticate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1660 ctx, cancel := context.WithCancel(req.Context()) 1661 defer cancel() 1662 if cn, ok := w.(http.CloseNotifier); ok { 1663 go func(done <-chan struct{}, closed <-chan bool) { 1664 select { 1665 case <-done: 1666 case <-closed: 1667 cancel() 1668 } 1669 }(ctx.Done(), cn.CloseNotify()) 1670 } 1671 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1672 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1673 if err != nil { 1674 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1675 return 1676 } 1677 resp, md, err := request_Auth_Authenticate_0(rctx, inboundMarshaler, client, req, pathParams) 1678 ctx = runtime.NewServerMetadataContext(ctx, md) 1679 if err != nil { 1680 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1681 return 1682 } 1683 1684 forward_Auth_Authenticate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1685 1686 }) 1687 1688 mux.Handle("POST", pattern_Auth_UserAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1689 ctx, cancel := context.WithCancel(req.Context()) 1690 defer cancel() 1691 if cn, ok := w.(http.CloseNotifier); ok { 1692 go func(done <-chan struct{}, closed <-chan bool) { 1693 select { 1694 case <-done: 1695 case <-closed: 1696 cancel() 1697 } 1698 }(ctx.Done(), cn.CloseNotify()) 1699 } 1700 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1701 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1702 if err != nil { 1703 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1704 return 1705 } 1706 resp, md, err := request_Auth_UserAdd_0(rctx, inboundMarshaler, client, req, pathParams) 1707 ctx = runtime.NewServerMetadataContext(ctx, md) 1708 if err != nil { 1709 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1710 return 1711 } 1712 1713 forward_Auth_UserAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1714 1715 }) 1716 1717 mux.Handle("POST", pattern_Auth_UserGet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1718 ctx, cancel := context.WithCancel(req.Context()) 1719 defer cancel() 1720 if cn, ok := w.(http.CloseNotifier); ok { 1721 go func(done <-chan struct{}, closed <-chan bool) { 1722 select { 1723 case <-done: 1724 case <-closed: 1725 cancel() 1726 } 1727 }(ctx.Done(), cn.CloseNotify()) 1728 } 1729 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1730 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1731 if err != nil { 1732 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1733 return 1734 } 1735 resp, md, err := request_Auth_UserGet_0(rctx, inboundMarshaler, client, req, pathParams) 1736 ctx = runtime.NewServerMetadataContext(ctx, md) 1737 if err != nil { 1738 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1739 return 1740 } 1741 1742 forward_Auth_UserGet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1743 1744 }) 1745 1746 mux.Handle("POST", pattern_Auth_UserList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1747 ctx, cancel := context.WithCancel(req.Context()) 1748 defer cancel() 1749 if cn, ok := w.(http.CloseNotifier); ok { 1750 go func(done <-chan struct{}, closed <-chan bool) { 1751 select { 1752 case <-done: 1753 case <-closed: 1754 cancel() 1755 } 1756 }(ctx.Done(), cn.CloseNotify()) 1757 } 1758 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1759 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1760 if err != nil { 1761 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1762 return 1763 } 1764 resp, md, err := request_Auth_UserList_0(rctx, inboundMarshaler, client, req, pathParams) 1765 ctx = runtime.NewServerMetadataContext(ctx, md) 1766 if err != nil { 1767 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1768 return 1769 } 1770 1771 forward_Auth_UserList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1772 1773 }) 1774 1775 mux.Handle("POST", pattern_Auth_UserDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1776 ctx, cancel := context.WithCancel(req.Context()) 1777 defer cancel() 1778 if cn, ok := w.(http.CloseNotifier); ok { 1779 go func(done <-chan struct{}, closed <-chan bool) { 1780 select { 1781 case <-done: 1782 case <-closed: 1783 cancel() 1784 } 1785 }(ctx.Done(), cn.CloseNotify()) 1786 } 1787 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1788 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1789 if err != nil { 1790 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1791 return 1792 } 1793 resp, md, err := request_Auth_UserDelete_0(rctx, inboundMarshaler, client, req, pathParams) 1794 ctx = runtime.NewServerMetadataContext(ctx, md) 1795 if err != nil { 1796 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1797 return 1798 } 1799 1800 forward_Auth_UserDelete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1801 1802 }) 1803 1804 mux.Handle("POST", pattern_Auth_UserChangePassword_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1805 ctx, cancel := context.WithCancel(req.Context()) 1806 defer cancel() 1807 if cn, ok := w.(http.CloseNotifier); ok { 1808 go func(done <-chan struct{}, closed <-chan bool) { 1809 select { 1810 case <-done: 1811 case <-closed: 1812 cancel() 1813 } 1814 }(ctx.Done(), cn.CloseNotify()) 1815 } 1816 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1817 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1818 if err != nil { 1819 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1820 return 1821 } 1822 resp, md, err := request_Auth_UserChangePassword_0(rctx, inboundMarshaler, client, req, pathParams) 1823 ctx = runtime.NewServerMetadataContext(ctx, md) 1824 if err != nil { 1825 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1826 return 1827 } 1828 1829 forward_Auth_UserChangePassword_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1830 1831 }) 1832 1833 mux.Handle("POST", pattern_Auth_UserGrantRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1834 ctx, cancel := context.WithCancel(req.Context()) 1835 defer cancel() 1836 if cn, ok := w.(http.CloseNotifier); ok { 1837 go func(done <-chan struct{}, closed <-chan bool) { 1838 select { 1839 case <-done: 1840 case <-closed: 1841 cancel() 1842 } 1843 }(ctx.Done(), cn.CloseNotify()) 1844 } 1845 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1846 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1847 if err != nil { 1848 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1849 return 1850 } 1851 resp, md, err := request_Auth_UserGrantRole_0(rctx, inboundMarshaler, client, req, pathParams) 1852 ctx = runtime.NewServerMetadataContext(ctx, md) 1853 if err != nil { 1854 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1855 return 1856 } 1857 1858 forward_Auth_UserGrantRole_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1859 1860 }) 1861 1862 mux.Handle("POST", pattern_Auth_UserRevokeRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1863 ctx, cancel := context.WithCancel(req.Context()) 1864 defer cancel() 1865 if cn, ok := w.(http.CloseNotifier); ok { 1866 go func(done <-chan struct{}, closed <-chan bool) { 1867 select { 1868 case <-done: 1869 case <-closed: 1870 cancel() 1871 } 1872 }(ctx.Done(), cn.CloseNotify()) 1873 } 1874 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1875 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1876 if err != nil { 1877 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1878 return 1879 } 1880 resp, md, err := request_Auth_UserRevokeRole_0(rctx, inboundMarshaler, client, req, pathParams) 1881 ctx = runtime.NewServerMetadataContext(ctx, md) 1882 if err != nil { 1883 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1884 return 1885 } 1886 1887 forward_Auth_UserRevokeRole_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1888 1889 }) 1890 1891 mux.Handle("POST", pattern_Auth_RoleAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1892 ctx, cancel := context.WithCancel(req.Context()) 1893 defer cancel() 1894 if cn, ok := w.(http.CloseNotifier); ok { 1895 go func(done <-chan struct{}, closed <-chan bool) { 1896 select { 1897 case <-done: 1898 case <-closed: 1899 cancel() 1900 } 1901 }(ctx.Done(), cn.CloseNotify()) 1902 } 1903 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1904 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1905 if err != nil { 1906 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1907 return 1908 } 1909 resp, md, err := request_Auth_RoleAdd_0(rctx, inboundMarshaler, client, req, pathParams) 1910 ctx = runtime.NewServerMetadataContext(ctx, md) 1911 if err != nil { 1912 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1913 return 1914 } 1915 1916 forward_Auth_RoleAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1917 1918 }) 1919 1920 mux.Handle("POST", pattern_Auth_RoleGet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1921 ctx, cancel := context.WithCancel(req.Context()) 1922 defer cancel() 1923 if cn, ok := w.(http.CloseNotifier); ok { 1924 go func(done <-chan struct{}, closed <-chan bool) { 1925 select { 1926 case <-done: 1927 case <-closed: 1928 cancel() 1929 } 1930 }(ctx.Done(), cn.CloseNotify()) 1931 } 1932 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1933 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1934 if err != nil { 1935 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1936 return 1937 } 1938 resp, md, err := request_Auth_RoleGet_0(rctx, inboundMarshaler, client, req, pathParams) 1939 ctx = runtime.NewServerMetadataContext(ctx, md) 1940 if err != nil { 1941 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1942 return 1943 } 1944 1945 forward_Auth_RoleGet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1946 1947 }) 1948 1949 mux.Handle("POST", pattern_Auth_RoleList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1950 ctx, cancel := context.WithCancel(req.Context()) 1951 defer cancel() 1952 if cn, ok := w.(http.CloseNotifier); ok { 1953 go func(done <-chan struct{}, closed <-chan bool) { 1954 select { 1955 case <-done: 1956 case <-closed: 1957 cancel() 1958 } 1959 }(ctx.Done(), cn.CloseNotify()) 1960 } 1961 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1962 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1963 if err != nil { 1964 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1965 return 1966 } 1967 resp, md, err := request_Auth_RoleList_0(rctx, inboundMarshaler, client, req, pathParams) 1968 ctx = runtime.NewServerMetadataContext(ctx, md) 1969 if err != nil { 1970 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1971 return 1972 } 1973 1974 forward_Auth_RoleList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1975 1976 }) 1977 1978 mux.Handle("POST", pattern_Auth_RoleDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1979 ctx, cancel := context.WithCancel(req.Context()) 1980 defer cancel() 1981 if cn, ok := w.(http.CloseNotifier); ok { 1982 go func(done <-chan struct{}, closed <-chan bool) { 1983 select { 1984 case <-done: 1985 case <-closed: 1986 cancel() 1987 } 1988 }(ctx.Done(), cn.CloseNotify()) 1989 } 1990 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1991 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1992 if err != nil { 1993 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1994 return 1995 } 1996 resp, md, err := request_Auth_RoleDelete_0(rctx, inboundMarshaler, client, req, pathParams) 1997 ctx = runtime.NewServerMetadataContext(ctx, md) 1998 if err != nil { 1999 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 2000 return 2001 } 2002 2003 forward_Auth_RoleDelete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 2004 2005 }) 2006 2007 mux.Handle("POST", pattern_Auth_RoleGrantPermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 2008 ctx, cancel := context.WithCancel(req.Context()) 2009 defer cancel() 2010 if cn, ok := w.(http.CloseNotifier); ok { 2011 go func(done <-chan struct{}, closed <-chan bool) { 2012 select { 2013 case <-done: 2014 case <-closed: 2015 cancel() 2016 } 2017 }(ctx.Done(), cn.CloseNotify()) 2018 } 2019 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 2020 rctx, err := runtime.AnnotateContext(ctx, mux, req) 2021 if err != nil { 2022 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 2023 return 2024 } 2025 resp, md, err := request_Auth_RoleGrantPermission_0(rctx, inboundMarshaler, client, req, pathParams) 2026 ctx = runtime.NewServerMetadataContext(ctx, md) 2027 if err != nil { 2028 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 2029 return 2030 } 2031 2032 forward_Auth_RoleGrantPermission_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 2033 2034 }) 2035 2036 mux.Handle("POST", pattern_Auth_RoleRevokePermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 2037 ctx, cancel := context.WithCancel(req.Context()) 2038 defer cancel() 2039 if cn, ok := w.(http.CloseNotifier); ok { 2040 go func(done <-chan struct{}, closed <-chan bool) { 2041 select { 2042 case <-done: 2043 case <-closed: 2044 cancel() 2045 } 2046 }(ctx.Done(), cn.CloseNotify()) 2047 } 2048 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 2049 rctx, err := runtime.AnnotateContext(ctx, mux, req) 2050 if err != nil { 2051 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 2052 return 2053 } 2054 resp, md, err := request_Auth_RoleRevokePermission_0(rctx, inboundMarshaler, client, req, pathParams) 2055 ctx = runtime.NewServerMetadataContext(ctx, md) 2056 if err != nil { 2057 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 2058 return 2059 } 2060 2061 forward_Auth_RoleRevokePermission_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 2062 2063 }) 2064 2065 return nil 2066} 2067 2068var ( 2069 pattern_Auth_AuthEnable_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "auth", "enable"}, "")) 2070 2071 pattern_Auth_AuthDisable_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "auth", "disable"}, "")) 2072 2073 pattern_Auth_Authenticate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3beta", "auth", "authenticate"}, "")) 2074 2075 pattern_Auth_UserAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "user", "add"}, "")) 2076 2077 pattern_Auth_UserGet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "user", "get"}, "")) 2078 2079 pattern_Auth_UserList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "user", "list"}, "")) 2080 2081 pattern_Auth_UserDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "user", "delete"}, "")) 2082 2083 pattern_Auth_UserChangePassword_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "user", "changepw"}, "")) 2084 2085 pattern_Auth_UserGrantRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "user", "grant"}, "")) 2086 2087 pattern_Auth_UserRevokeRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "user", "revoke"}, "")) 2088 2089 pattern_Auth_RoleAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "role", "add"}, "")) 2090 2091 pattern_Auth_RoleGet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "role", "get"}, "")) 2092 2093 pattern_Auth_RoleList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "role", "list"}, "")) 2094 2095 pattern_Auth_RoleDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "role", "delete"}, "")) 2096 2097 pattern_Auth_RoleGrantPermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "role", "grant"}, "")) 2098 2099 pattern_Auth_RoleRevokePermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3beta", "auth", "role", "revoke"}, "")) 2100) 2101 2102var ( 2103 forward_Auth_AuthEnable_0 = runtime.ForwardResponseMessage 2104 2105 forward_Auth_AuthDisable_0 = runtime.ForwardResponseMessage 2106 2107 forward_Auth_Authenticate_0 = runtime.ForwardResponseMessage 2108 2109 forward_Auth_UserAdd_0 = runtime.ForwardResponseMessage 2110 2111 forward_Auth_UserGet_0 = runtime.ForwardResponseMessage 2112 2113 forward_Auth_UserList_0 = runtime.ForwardResponseMessage 2114 2115 forward_Auth_UserDelete_0 = runtime.ForwardResponseMessage 2116 2117 forward_Auth_UserChangePassword_0 = runtime.ForwardResponseMessage 2118 2119 forward_Auth_UserGrantRole_0 = runtime.ForwardResponseMessage 2120 2121 forward_Auth_UserRevokeRole_0 = runtime.ForwardResponseMessage 2122 2123 forward_Auth_RoleAdd_0 = runtime.ForwardResponseMessage 2124 2125 forward_Auth_RoleGet_0 = runtime.ForwardResponseMessage 2126 2127 forward_Auth_RoleList_0 = runtime.ForwardResponseMessage 2128 2129 forward_Auth_RoleDelete_0 = runtime.ForwardResponseMessage 2130 2131 forward_Auth_RoleGrantPermission_0 = runtime.ForwardResponseMessage 2132 2133 forward_Auth_RoleRevokePermission_0 = runtime.ForwardResponseMessage 2134) 2135