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_Cluster_MemberAdd_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 241 var protoReq etcdserverpb.MemberAddRequest 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.MemberAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 249 return msg, metadata, err 250 251} 252 253func 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) { 254 var protoReq etcdserverpb.MemberRemoveRequest 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.MemberRemove(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 262 return msg, metadata, err 263 264} 265 266func 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) { 267 var protoReq etcdserverpb.MemberUpdateRequest 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.MemberUpdate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 275 return msg, metadata, err 276 277} 278 279func 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) { 280 var protoReq etcdserverpb.MemberListRequest 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.MemberList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 288 return msg, metadata, err 289 290} 291 292func 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) { 293 var protoReq etcdserverpb.AlarmRequest 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.Alarm(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 301 return msg, metadata, err 302 303} 304 305func 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) { 306 var protoReq etcdserverpb.StatusRequest 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.Status(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 314 return msg, metadata, err 315 316} 317 318func 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) { 319 var protoReq etcdserverpb.DefragmentRequest 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.Defragment(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 327 return msg, metadata, err 328 329} 330 331func 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) { 332 var protoReq etcdserverpb.HashRequest 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.Hash(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 340 return msg, metadata, err 341 342} 343 344func 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) { 345 var protoReq etcdserverpb.SnapshotRequest 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 stream, err := client.Snapshot(ctx, &protoReq) 353 if err != nil { 354 return nil, metadata, err 355 } 356 header, err := stream.Header() 357 if err != nil { 358 return nil, metadata, err 359 } 360 metadata.HeaderMD = header 361 return stream, metadata, nil 362 363} 364 365func 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) { 366 var protoReq etcdserverpb.AuthEnableRequest 367 var metadata runtime.ServerMetadata 368 369 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 370 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 371 } 372 373 msg, err := client.AuthEnable(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 374 return msg, metadata, err 375 376} 377 378func 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) { 379 var protoReq etcdserverpb.AuthDisableRequest 380 var metadata runtime.ServerMetadata 381 382 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 383 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 384 } 385 386 msg, err := client.AuthDisable(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 387 return msg, metadata, err 388 389} 390 391func 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) { 392 var protoReq etcdserverpb.AuthenticateRequest 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.Authenticate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 400 return msg, metadata, err 401 402} 403 404func 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) { 405 var protoReq etcdserverpb.AuthUserAddRequest 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.UserAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 413 return msg, metadata, err 414 415} 416 417func 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) { 418 var protoReq etcdserverpb.AuthUserGetRequest 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.UserGet(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 426 return msg, metadata, err 427 428} 429 430func 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) { 431 var protoReq etcdserverpb.AuthUserListRequest 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.UserList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 439 return msg, metadata, err 440 441} 442 443func 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) { 444 var protoReq etcdserverpb.AuthUserDeleteRequest 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.UserDelete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 452 return msg, metadata, err 453 454} 455 456func 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) { 457 var protoReq etcdserverpb.AuthUserChangePasswordRequest 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.UserChangePassword(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 465 return msg, metadata, err 466 467} 468 469func 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) { 470 var protoReq etcdserverpb.AuthUserGrantRoleRequest 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.UserGrantRole(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 478 return msg, metadata, err 479 480} 481 482func 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) { 483 var protoReq etcdserverpb.AuthUserRevokeRoleRequest 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.UserRevokeRole(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 491 return msg, metadata, err 492 493} 494 495func 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) { 496 var protoReq etcdserverpb.AuthRoleAddRequest 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.RoleAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 504 return msg, metadata, err 505 506} 507 508func 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) { 509 var protoReq etcdserverpb.AuthRoleGetRequest 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.RoleGet(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 517 return msg, metadata, err 518 519} 520 521func 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) { 522 var protoReq etcdserverpb.AuthRoleListRequest 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.RoleList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 530 return msg, metadata, err 531 532} 533 534func 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) { 535 var protoReq etcdserverpb.AuthRoleDeleteRequest 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.RoleDelete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 543 return msg, metadata, err 544 545} 546 547func 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) { 548 var protoReq etcdserverpb.AuthRoleGrantPermissionRequest 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.RoleGrantPermission(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 556 return msg, metadata, err 557 558} 559 560func 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) { 561 var protoReq etcdserverpb.AuthRoleRevokePermissionRequest 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.RoleRevokePermission(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 569 return msg, metadata, err 570 571} 572 573// RegisterKVHandlerFromEndpoint is same as RegisterKVHandler but 574// automatically dials to "endpoint" and closes the connection when "ctx" gets done. 575func RegisterKVHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 576 conn, err := grpc.Dial(endpoint, opts...) 577 if err != nil { 578 return err 579 } 580 defer func() { 581 if err != nil { 582 if cerr := conn.Close(); cerr != nil { 583 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 584 } 585 return 586 } 587 go func() { 588 <-ctx.Done() 589 if cerr := conn.Close(); cerr != nil { 590 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 591 } 592 }() 593 }() 594 595 return RegisterKVHandler(ctx, mux, conn) 596} 597 598// RegisterKVHandler registers the http handlers for service KV to "mux". 599// The handlers forward requests to the grpc endpoint over "conn". 600func RegisterKVHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 601 return RegisterKVHandlerClient(ctx, mux, etcdserverpb.NewKVClient(conn)) 602} 603 604// RegisterKVHandler registers the http handlers for service KV to "mux". 605// The handlers forward requests to the grpc endpoint over the given implementation of "KVClient". 606// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "KVClient" 607// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 608// "KVClient" to call the correct interceptors. 609func RegisterKVHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.KVClient) error { 610 611 mux.Handle("POST", pattern_KV_Range_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 612 ctx, cancel := context.WithCancel(ctx) 613 defer cancel() 614 if cn, ok := w.(http.CloseNotifier); ok { 615 go func(done <-chan struct{}, closed <-chan bool) { 616 select { 617 case <-done: 618 case <-closed: 619 cancel() 620 } 621 }(ctx.Done(), cn.CloseNotify()) 622 } 623 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 624 rctx, err := runtime.AnnotateContext(ctx, mux, req) 625 if err != nil { 626 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 627 return 628 } 629 resp, md, err := request_KV_Range_0(rctx, inboundMarshaler, client, req, pathParams) 630 ctx = runtime.NewServerMetadataContext(ctx, md) 631 if err != nil { 632 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 633 return 634 } 635 636 forward_KV_Range_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 637 638 }) 639 640 mux.Handle("POST", pattern_KV_Put_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 641 ctx, cancel := context.WithCancel(ctx) 642 defer cancel() 643 if cn, ok := w.(http.CloseNotifier); ok { 644 go func(done <-chan struct{}, closed <-chan bool) { 645 select { 646 case <-done: 647 case <-closed: 648 cancel() 649 } 650 }(ctx.Done(), cn.CloseNotify()) 651 } 652 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 653 rctx, err := runtime.AnnotateContext(ctx, mux, req) 654 if err != nil { 655 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 656 return 657 } 658 resp, md, err := request_KV_Put_0(rctx, inboundMarshaler, client, req, pathParams) 659 ctx = runtime.NewServerMetadataContext(ctx, md) 660 if err != nil { 661 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 662 return 663 } 664 665 forward_KV_Put_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 666 667 }) 668 669 mux.Handle("POST", pattern_KV_DeleteRange_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 670 ctx, cancel := context.WithCancel(ctx) 671 defer cancel() 672 if cn, ok := w.(http.CloseNotifier); ok { 673 go func(done <-chan struct{}, closed <-chan bool) { 674 select { 675 case <-done: 676 case <-closed: 677 cancel() 678 } 679 }(ctx.Done(), cn.CloseNotify()) 680 } 681 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 682 rctx, err := runtime.AnnotateContext(ctx, mux, req) 683 if err != nil { 684 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 685 return 686 } 687 resp, md, err := request_KV_DeleteRange_0(rctx, inboundMarshaler, client, req, pathParams) 688 ctx = runtime.NewServerMetadataContext(ctx, md) 689 if err != nil { 690 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 691 return 692 } 693 694 forward_KV_DeleteRange_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 695 696 }) 697 698 mux.Handle("POST", pattern_KV_Txn_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 699 ctx, cancel := context.WithCancel(ctx) 700 defer cancel() 701 if cn, ok := w.(http.CloseNotifier); ok { 702 go func(done <-chan struct{}, closed <-chan bool) { 703 select { 704 case <-done: 705 case <-closed: 706 cancel() 707 } 708 }(ctx.Done(), cn.CloseNotify()) 709 } 710 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 711 rctx, err := runtime.AnnotateContext(ctx, mux, req) 712 if err != nil { 713 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 714 return 715 } 716 resp, md, err := request_KV_Txn_0(rctx, inboundMarshaler, client, req, pathParams) 717 ctx = runtime.NewServerMetadataContext(ctx, md) 718 if err != nil { 719 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 720 return 721 } 722 723 forward_KV_Txn_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 724 725 }) 726 727 mux.Handle("POST", pattern_KV_Compact_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 728 ctx, cancel := context.WithCancel(ctx) 729 defer cancel() 730 if cn, ok := w.(http.CloseNotifier); ok { 731 go func(done <-chan struct{}, closed <-chan bool) { 732 select { 733 case <-done: 734 case <-closed: 735 cancel() 736 } 737 }(ctx.Done(), cn.CloseNotify()) 738 } 739 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 740 rctx, err := runtime.AnnotateContext(ctx, mux, req) 741 if err != nil { 742 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 743 return 744 } 745 resp, md, err := request_KV_Compact_0(rctx, inboundMarshaler, client, req, pathParams) 746 ctx = runtime.NewServerMetadataContext(ctx, md) 747 if err != nil { 748 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 749 return 750 } 751 752 forward_KV_Compact_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 753 754 }) 755 756 return nil 757} 758 759var ( 760 pattern_KV_Range_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "range"}, "")) 761 762 pattern_KV_Put_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "put"}, "")) 763 764 pattern_KV_DeleteRange_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "deleterange"}, "")) 765 766 pattern_KV_Txn_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "txn"}, "")) 767 768 pattern_KV_Compact_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "kv", "compaction"}, "")) 769) 770 771var ( 772 forward_KV_Range_0 = runtime.ForwardResponseMessage 773 774 forward_KV_Put_0 = runtime.ForwardResponseMessage 775 776 forward_KV_DeleteRange_0 = runtime.ForwardResponseMessage 777 778 forward_KV_Txn_0 = runtime.ForwardResponseMessage 779 780 forward_KV_Compact_0 = runtime.ForwardResponseMessage 781) 782 783// RegisterWatchHandlerFromEndpoint is same as RegisterWatchHandler but 784// automatically dials to "endpoint" and closes the connection when "ctx" gets done. 785func RegisterWatchHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 786 conn, err := grpc.Dial(endpoint, opts...) 787 if err != nil { 788 return err 789 } 790 defer func() { 791 if err != nil { 792 if cerr := conn.Close(); cerr != nil { 793 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 794 } 795 return 796 } 797 go func() { 798 <-ctx.Done() 799 if cerr := conn.Close(); cerr != nil { 800 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 801 } 802 }() 803 }() 804 805 return RegisterWatchHandler(ctx, mux, conn) 806} 807 808// RegisterWatchHandler registers the http handlers for service Watch to "mux". 809// The handlers forward requests to the grpc endpoint over "conn". 810func RegisterWatchHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 811 return RegisterWatchHandlerClient(ctx, mux, etcdserverpb.NewWatchClient(conn)) 812} 813 814// RegisterWatchHandler registers the http handlers for service Watch to "mux". 815// The handlers forward requests to the grpc endpoint over the given implementation of "WatchClient". 816// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "WatchClient" 817// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 818// "WatchClient" to call the correct interceptors. 819func RegisterWatchHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.WatchClient) error { 820 821 mux.Handle("POST", pattern_Watch_Watch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 822 ctx, cancel := context.WithCancel(ctx) 823 defer cancel() 824 if cn, ok := w.(http.CloseNotifier); ok { 825 go func(done <-chan struct{}, closed <-chan bool) { 826 select { 827 case <-done: 828 case <-closed: 829 cancel() 830 } 831 }(ctx.Done(), cn.CloseNotify()) 832 } 833 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 834 rctx, err := runtime.AnnotateContext(ctx, mux, req) 835 if err != nil { 836 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 837 return 838 } 839 resp, md, err := request_Watch_Watch_0(rctx, inboundMarshaler, client, req, pathParams) 840 ctx = runtime.NewServerMetadataContext(ctx, md) 841 if err != nil { 842 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 843 return 844 } 845 846 forward_Watch_Watch_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 847 848 }) 849 850 return nil 851} 852 853var ( 854 pattern_Watch_Watch_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v3alpha", "watch"}, "")) 855) 856 857var ( 858 forward_Watch_Watch_0 = runtime.ForwardResponseStream 859) 860 861// RegisterLeaseHandlerFromEndpoint is same as RegisterLeaseHandler but 862// automatically dials to "endpoint" and closes the connection when "ctx" gets done. 863func RegisterLeaseHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 864 conn, err := grpc.Dial(endpoint, opts...) 865 if err != nil { 866 return err 867 } 868 defer func() { 869 if err != nil { 870 if cerr := conn.Close(); cerr != nil { 871 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 872 } 873 return 874 } 875 go func() { 876 <-ctx.Done() 877 if cerr := conn.Close(); cerr != nil { 878 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 879 } 880 }() 881 }() 882 883 return RegisterLeaseHandler(ctx, mux, conn) 884} 885 886// RegisterLeaseHandler registers the http handlers for service Lease to "mux". 887// The handlers forward requests to the grpc endpoint over "conn". 888func RegisterLeaseHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 889 return RegisterLeaseHandlerClient(ctx, mux, etcdserverpb.NewLeaseClient(conn)) 890} 891 892// RegisterLeaseHandler registers the http handlers for service Lease to "mux". 893// The handlers forward requests to the grpc endpoint over the given implementation of "LeaseClient". 894// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "LeaseClient" 895// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 896// "LeaseClient" to call the correct interceptors. 897func RegisterLeaseHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.LeaseClient) error { 898 899 mux.Handle("POST", pattern_Lease_LeaseGrant_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 900 ctx, cancel := context.WithCancel(ctx) 901 defer cancel() 902 if cn, ok := w.(http.CloseNotifier); ok { 903 go func(done <-chan struct{}, closed <-chan bool) { 904 select { 905 case <-done: 906 case <-closed: 907 cancel() 908 } 909 }(ctx.Done(), cn.CloseNotify()) 910 } 911 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 912 rctx, err := runtime.AnnotateContext(ctx, mux, req) 913 if err != nil { 914 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 915 return 916 } 917 resp, md, err := request_Lease_LeaseGrant_0(rctx, inboundMarshaler, client, req, pathParams) 918 ctx = runtime.NewServerMetadataContext(ctx, md) 919 if err != nil { 920 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 921 return 922 } 923 924 forward_Lease_LeaseGrant_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 925 926 }) 927 928 mux.Handle("POST", pattern_Lease_LeaseRevoke_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 929 ctx, cancel := context.WithCancel(ctx) 930 defer cancel() 931 if cn, ok := w.(http.CloseNotifier); ok { 932 go func(done <-chan struct{}, closed <-chan bool) { 933 select { 934 case <-done: 935 case <-closed: 936 cancel() 937 } 938 }(ctx.Done(), cn.CloseNotify()) 939 } 940 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 941 rctx, err := runtime.AnnotateContext(ctx, mux, req) 942 if err != nil { 943 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 944 return 945 } 946 resp, md, err := request_Lease_LeaseRevoke_0(rctx, inboundMarshaler, client, req, pathParams) 947 ctx = runtime.NewServerMetadataContext(ctx, md) 948 if err != nil { 949 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 950 return 951 } 952 953 forward_Lease_LeaseRevoke_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 954 955 }) 956 957 mux.Handle("POST", pattern_Lease_LeaseKeepAlive_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 958 ctx, cancel := context.WithCancel(ctx) 959 defer cancel() 960 if cn, ok := w.(http.CloseNotifier); ok { 961 go func(done <-chan struct{}, closed <-chan bool) { 962 select { 963 case <-done: 964 case <-closed: 965 cancel() 966 } 967 }(ctx.Done(), cn.CloseNotify()) 968 } 969 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 970 rctx, err := runtime.AnnotateContext(ctx, mux, req) 971 if err != nil { 972 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 973 return 974 } 975 resp, md, err := request_Lease_LeaseKeepAlive_0(rctx, inboundMarshaler, client, req, pathParams) 976 ctx = runtime.NewServerMetadataContext(ctx, md) 977 if err != nil { 978 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 979 return 980 } 981 982 forward_Lease_LeaseKeepAlive_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 983 984 }) 985 986 mux.Handle("POST", pattern_Lease_LeaseTimeToLive_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 987 ctx, cancel := context.WithCancel(ctx) 988 defer cancel() 989 if cn, ok := w.(http.CloseNotifier); ok { 990 go func(done <-chan struct{}, closed <-chan bool) { 991 select { 992 case <-done: 993 case <-closed: 994 cancel() 995 } 996 }(ctx.Done(), cn.CloseNotify()) 997 } 998 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 999 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1000 if err != nil { 1001 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1002 return 1003 } 1004 resp, md, err := request_Lease_LeaseTimeToLive_0(rctx, inboundMarshaler, client, req, pathParams) 1005 ctx = runtime.NewServerMetadataContext(ctx, md) 1006 if err != nil { 1007 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1008 return 1009 } 1010 1011 forward_Lease_LeaseTimeToLive_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1012 1013 }) 1014 1015 return nil 1016} 1017 1018var ( 1019 pattern_Lease_LeaseGrant_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "lease", "grant"}, "")) 1020 1021 pattern_Lease_LeaseRevoke_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "kv", "lease", "revoke"}, "")) 1022 1023 pattern_Lease_LeaseKeepAlive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "lease", "keepalive"}, "")) 1024 1025 pattern_Lease_LeaseTimeToLive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "kv", "lease", "timetolive"}, "")) 1026) 1027 1028var ( 1029 forward_Lease_LeaseGrant_0 = runtime.ForwardResponseMessage 1030 1031 forward_Lease_LeaseRevoke_0 = runtime.ForwardResponseMessage 1032 1033 forward_Lease_LeaseKeepAlive_0 = runtime.ForwardResponseStream 1034 1035 forward_Lease_LeaseTimeToLive_0 = runtime.ForwardResponseMessage 1036) 1037 1038// RegisterClusterHandlerFromEndpoint is same as RegisterClusterHandler but 1039// automatically dials to "endpoint" and closes the connection when "ctx" gets done. 1040func RegisterClusterHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 1041 conn, err := grpc.Dial(endpoint, opts...) 1042 if err != nil { 1043 return err 1044 } 1045 defer func() { 1046 if err != nil { 1047 if cerr := conn.Close(); cerr != nil { 1048 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 1049 } 1050 return 1051 } 1052 go func() { 1053 <-ctx.Done() 1054 if cerr := conn.Close(); cerr != nil { 1055 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 1056 } 1057 }() 1058 }() 1059 1060 return RegisterClusterHandler(ctx, mux, conn) 1061} 1062 1063// RegisterClusterHandler registers the http handlers for service Cluster to "mux". 1064// The handlers forward requests to the grpc endpoint over "conn". 1065func RegisterClusterHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 1066 return RegisterClusterHandlerClient(ctx, mux, etcdserverpb.NewClusterClient(conn)) 1067} 1068 1069// RegisterClusterHandler registers the http handlers for service Cluster to "mux". 1070// The handlers forward requests to the grpc endpoint over the given implementation of "ClusterClient". 1071// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ClusterClient" 1072// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 1073// "ClusterClient" to call the correct interceptors. 1074func RegisterClusterHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.ClusterClient) error { 1075 1076 mux.Handle("POST", pattern_Cluster_MemberAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1077 ctx, cancel := context.WithCancel(ctx) 1078 defer cancel() 1079 if cn, ok := w.(http.CloseNotifier); ok { 1080 go func(done <-chan struct{}, closed <-chan bool) { 1081 select { 1082 case <-done: 1083 case <-closed: 1084 cancel() 1085 } 1086 }(ctx.Done(), cn.CloseNotify()) 1087 } 1088 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1089 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1090 if err != nil { 1091 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1092 return 1093 } 1094 resp, md, err := request_Cluster_MemberAdd_0(rctx, inboundMarshaler, client, req, pathParams) 1095 ctx = runtime.NewServerMetadataContext(ctx, md) 1096 if err != nil { 1097 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1098 return 1099 } 1100 1101 forward_Cluster_MemberAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1102 1103 }) 1104 1105 mux.Handle("POST", pattern_Cluster_MemberRemove_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1106 ctx, cancel := context.WithCancel(ctx) 1107 defer cancel() 1108 if cn, ok := w.(http.CloseNotifier); ok { 1109 go func(done <-chan struct{}, closed <-chan bool) { 1110 select { 1111 case <-done: 1112 case <-closed: 1113 cancel() 1114 } 1115 }(ctx.Done(), cn.CloseNotify()) 1116 } 1117 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1118 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1119 if err != nil { 1120 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1121 return 1122 } 1123 resp, md, err := request_Cluster_MemberRemove_0(rctx, inboundMarshaler, client, req, pathParams) 1124 ctx = runtime.NewServerMetadataContext(ctx, md) 1125 if err != nil { 1126 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1127 return 1128 } 1129 1130 forward_Cluster_MemberRemove_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1131 1132 }) 1133 1134 mux.Handle("POST", pattern_Cluster_MemberUpdate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1135 ctx, cancel := context.WithCancel(ctx) 1136 defer cancel() 1137 if cn, ok := w.(http.CloseNotifier); ok { 1138 go func(done <-chan struct{}, closed <-chan bool) { 1139 select { 1140 case <-done: 1141 case <-closed: 1142 cancel() 1143 } 1144 }(ctx.Done(), cn.CloseNotify()) 1145 } 1146 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1147 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1148 if err != nil { 1149 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1150 return 1151 } 1152 resp, md, err := request_Cluster_MemberUpdate_0(rctx, inboundMarshaler, client, req, pathParams) 1153 ctx = runtime.NewServerMetadataContext(ctx, md) 1154 if err != nil { 1155 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1156 return 1157 } 1158 1159 forward_Cluster_MemberUpdate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1160 1161 }) 1162 1163 mux.Handle("POST", pattern_Cluster_MemberList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1164 ctx, cancel := context.WithCancel(ctx) 1165 defer cancel() 1166 if cn, ok := w.(http.CloseNotifier); ok { 1167 go func(done <-chan struct{}, closed <-chan bool) { 1168 select { 1169 case <-done: 1170 case <-closed: 1171 cancel() 1172 } 1173 }(ctx.Done(), cn.CloseNotify()) 1174 } 1175 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1176 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1177 if err != nil { 1178 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1179 return 1180 } 1181 resp, md, err := request_Cluster_MemberList_0(rctx, inboundMarshaler, client, req, pathParams) 1182 ctx = runtime.NewServerMetadataContext(ctx, md) 1183 if err != nil { 1184 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1185 return 1186 } 1187 1188 forward_Cluster_MemberList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1189 1190 }) 1191 1192 return nil 1193} 1194 1195var ( 1196 pattern_Cluster_MemberAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "cluster", "member", "add"}, "")) 1197 1198 pattern_Cluster_MemberRemove_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "cluster", "member", "remove"}, "")) 1199 1200 pattern_Cluster_MemberUpdate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "cluster", "member", "update"}, "")) 1201 1202 pattern_Cluster_MemberList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "cluster", "member", "list"}, "")) 1203) 1204 1205var ( 1206 forward_Cluster_MemberAdd_0 = runtime.ForwardResponseMessage 1207 1208 forward_Cluster_MemberRemove_0 = runtime.ForwardResponseMessage 1209 1210 forward_Cluster_MemberUpdate_0 = runtime.ForwardResponseMessage 1211 1212 forward_Cluster_MemberList_0 = runtime.ForwardResponseMessage 1213) 1214 1215// RegisterMaintenanceHandlerFromEndpoint is same as RegisterMaintenanceHandler but 1216// automatically dials to "endpoint" and closes the connection when "ctx" gets done. 1217func RegisterMaintenanceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 1218 conn, err := grpc.Dial(endpoint, opts...) 1219 if err != nil { 1220 return err 1221 } 1222 defer func() { 1223 if err != nil { 1224 if cerr := conn.Close(); cerr != nil { 1225 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 1226 } 1227 return 1228 } 1229 go func() { 1230 <-ctx.Done() 1231 if cerr := conn.Close(); cerr != nil { 1232 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 1233 } 1234 }() 1235 }() 1236 1237 return RegisterMaintenanceHandler(ctx, mux, conn) 1238} 1239 1240// RegisterMaintenanceHandler registers the http handlers for service Maintenance to "mux". 1241// The handlers forward requests to the grpc endpoint over "conn". 1242func RegisterMaintenanceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 1243 return RegisterMaintenanceHandlerClient(ctx, mux, etcdserverpb.NewMaintenanceClient(conn)) 1244} 1245 1246// RegisterMaintenanceHandler registers the http handlers for service Maintenance to "mux". 1247// The handlers forward requests to the grpc endpoint over the given implementation of "MaintenanceClient". 1248// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "MaintenanceClient" 1249// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 1250// "MaintenanceClient" to call the correct interceptors. 1251func RegisterMaintenanceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.MaintenanceClient) error { 1252 1253 mux.Handle("POST", pattern_Maintenance_Alarm_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1254 ctx, cancel := context.WithCancel(ctx) 1255 defer cancel() 1256 if cn, ok := w.(http.CloseNotifier); ok { 1257 go func(done <-chan struct{}, closed <-chan bool) { 1258 select { 1259 case <-done: 1260 case <-closed: 1261 cancel() 1262 } 1263 }(ctx.Done(), cn.CloseNotify()) 1264 } 1265 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1266 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1267 if err != nil { 1268 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1269 return 1270 } 1271 resp, md, err := request_Maintenance_Alarm_0(rctx, inboundMarshaler, client, req, pathParams) 1272 ctx = runtime.NewServerMetadataContext(ctx, md) 1273 if err != nil { 1274 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1275 return 1276 } 1277 1278 forward_Maintenance_Alarm_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1279 1280 }) 1281 1282 mux.Handle("POST", pattern_Maintenance_Status_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1283 ctx, cancel := context.WithCancel(ctx) 1284 defer cancel() 1285 if cn, ok := w.(http.CloseNotifier); ok { 1286 go func(done <-chan struct{}, closed <-chan bool) { 1287 select { 1288 case <-done: 1289 case <-closed: 1290 cancel() 1291 } 1292 }(ctx.Done(), cn.CloseNotify()) 1293 } 1294 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1295 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1296 if err != nil { 1297 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1298 return 1299 } 1300 resp, md, err := request_Maintenance_Status_0(rctx, inboundMarshaler, client, req, pathParams) 1301 ctx = runtime.NewServerMetadataContext(ctx, md) 1302 if err != nil { 1303 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1304 return 1305 } 1306 1307 forward_Maintenance_Status_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1308 1309 }) 1310 1311 mux.Handle("POST", pattern_Maintenance_Defragment_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1312 ctx, cancel := context.WithCancel(ctx) 1313 defer cancel() 1314 if cn, ok := w.(http.CloseNotifier); ok { 1315 go func(done <-chan struct{}, closed <-chan bool) { 1316 select { 1317 case <-done: 1318 case <-closed: 1319 cancel() 1320 } 1321 }(ctx.Done(), cn.CloseNotify()) 1322 } 1323 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1324 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1325 if err != nil { 1326 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1327 return 1328 } 1329 resp, md, err := request_Maintenance_Defragment_0(rctx, inboundMarshaler, client, req, pathParams) 1330 ctx = runtime.NewServerMetadataContext(ctx, md) 1331 if err != nil { 1332 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1333 return 1334 } 1335 1336 forward_Maintenance_Defragment_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1337 1338 }) 1339 1340 mux.Handle("POST", pattern_Maintenance_Hash_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1341 ctx, cancel := context.WithCancel(ctx) 1342 defer cancel() 1343 if cn, ok := w.(http.CloseNotifier); ok { 1344 go func(done <-chan struct{}, closed <-chan bool) { 1345 select { 1346 case <-done: 1347 case <-closed: 1348 cancel() 1349 } 1350 }(ctx.Done(), cn.CloseNotify()) 1351 } 1352 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1353 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1354 if err != nil { 1355 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1356 return 1357 } 1358 resp, md, err := request_Maintenance_Hash_0(rctx, inboundMarshaler, client, req, pathParams) 1359 ctx = runtime.NewServerMetadataContext(ctx, md) 1360 if err != nil { 1361 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1362 return 1363 } 1364 1365 forward_Maintenance_Hash_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1366 1367 }) 1368 1369 mux.Handle("POST", pattern_Maintenance_Snapshot_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1370 ctx, cancel := context.WithCancel(ctx) 1371 defer cancel() 1372 if cn, ok := w.(http.CloseNotifier); ok { 1373 go func(done <-chan struct{}, closed <-chan bool) { 1374 select { 1375 case <-done: 1376 case <-closed: 1377 cancel() 1378 } 1379 }(ctx.Done(), cn.CloseNotify()) 1380 } 1381 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1382 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1383 if err != nil { 1384 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1385 return 1386 } 1387 resp, md, err := request_Maintenance_Snapshot_0(rctx, inboundMarshaler, client, req, pathParams) 1388 ctx = runtime.NewServerMetadataContext(ctx, md) 1389 if err != nil { 1390 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1391 return 1392 } 1393 1394 forward_Maintenance_Snapshot_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1395 1396 }) 1397 1398 return nil 1399} 1400 1401var ( 1402 pattern_Maintenance_Alarm_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "alarm"}, "")) 1403 1404 pattern_Maintenance_Status_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "status"}, "")) 1405 1406 pattern_Maintenance_Defragment_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "defragment"}, "")) 1407 1408 pattern_Maintenance_Hash_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "hash"}, "")) 1409 1410 pattern_Maintenance_Snapshot_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "maintenance", "snapshot"}, "")) 1411) 1412 1413var ( 1414 forward_Maintenance_Alarm_0 = runtime.ForwardResponseMessage 1415 1416 forward_Maintenance_Status_0 = runtime.ForwardResponseMessage 1417 1418 forward_Maintenance_Defragment_0 = runtime.ForwardResponseMessage 1419 1420 forward_Maintenance_Hash_0 = runtime.ForwardResponseMessage 1421 1422 forward_Maintenance_Snapshot_0 = runtime.ForwardResponseStream 1423) 1424 1425// RegisterAuthHandlerFromEndpoint is same as RegisterAuthHandler but 1426// automatically dials to "endpoint" and closes the connection when "ctx" gets done. 1427func RegisterAuthHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 1428 conn, err := grpc.Dial(endpoint, opts...) 1429 if err != nil { 1430 return err 1431 } 1432 defer func() { 1433 if err != nil { 1434 if cerr := conn.Close(); cerr != nil { 1435 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 1436 } 1437 return 1438 } 1439 go func() { 1440 <-ctx.Done() 1441 if cerr := conn.Close(); cerr != nil { 1442 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 1443 } 1444 }() 1445 }() 1446 1447 return RegisterAuthHandler(ctx, mux, conn) 1448} 1449 1450// RegisterAuthHandler registers the http handlers for service Auth to "mux". 1451// The handlers forward requests to the grpc endpoint over "conn". 1452func RegisterAuthHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 1453 return RegisterAuthHandlerClient(ctx, mux, etcdserverpb.NewAuthClient(conn)) 1454} 1455 1456// RegisterAuthHandler registers the http handlers for service Auth to "mux". 1457// The handlers forward requests to the grpc endpoint over the given implementation of "AuthClient". 1458// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AuthClient" 1459// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 1460// "AuthClient" to call the correct interceptors. 1461func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.AuthClient) error { 1462 1463 mux.Handle("POST", pattern_Auth_AuthEnable_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1464 ctx, cancel := context.WithCancel(ctx) 1465 defer cancel() 1466 if cn, ok := w.(http.CloseNotifier); ok { 1467 go func(done <-chan struct{}, closed <-chan bool) { 1468 select { 1469 case <-done: 1470 case <-closed: 1471 cancel() 1472 } 1473 }(ctx.Done(), cn.CloseNotify()) 1474 } 1475 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1476 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1477 if err != nil { 1478 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1479 return 1480 } 1481 resp, md, err := request_Auth_AuthEnable_0(rctx, inboundMarshaler, client, req, pathParams) 1482 ctx = runtime.NewServerMetadataContext(ctx, md) 1483 if err != nil { 1484 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1485 return 1486 } 1487 1488 forward_Auth_AuthEnable_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1489 1490 }) 1491 1492 mux.Handle("POST", pattern_Auth_AuthDisable_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1493 ctx, cancel := context.WithCancel(ctx) 1494 defer cancel() 1495 if cn, ok := w.(http.CloseNotifier); ok { 1496 go func(done <-chan struct{}, closed <-chan bool) { 1497 select { 1498 case <-done: 1499 case <-closed: 1500 cancel() 1501 } 1502 }(ctx.Done(), cn.CloseNotify()) 1503 } 1504 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1505 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1506 if err != nil { 1507 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1508 return 1509 } 1510 resp, md, err := request_Auth_AuthDisable_0(rctx, inboundMarshaler, client, req, pathParams) 1511 ctx = runtime.NewServerMetadataContext(ctx, md) 1512 if err != nil { 1513 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1514 return 1515 } 1516 1517 forward_Auth_AuthDisable_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1518 1519 }) 1520 1521 mux.Handle("POST", pattern_Auth_Authenticate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1522 ctx, cancel := context.WithCancel(ctx) 1523 defer cancel() 1524 if cn, ok := w.(http.CloseNotifier); ok { 1525 go func(done <-chan struct{}, closed <-chan bool) { 1526 select { 1527 case <-done: 1528 case <-closed: 1529 cancel() 1530 } 1531 }(ctx.Done(), cn.CloseNotify()) 1532 } 1533 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1534 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1535 if err != nil { 1536 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1537 return 1538 } 1539 resp, md, err := request_Auth_Authenticate_0(rctx, inboundMarshaler, client, req, pathParams) 1540 ctx = runtime.NewServerMetadataContext(ctx, md) 1541 if err != nil { 1542 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1543 return 1544 } 1545 1546 forward_Auth_Authenticate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1547 1548 }) 1549 1550 mux.Handle("POST", pattern_Auth_UserAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1551 ctx, cancel := context.WithCancel(ctx) 1552 defer cancel() 1553 if cn, ok := w.(http.CloseNotifier); ok { 1554 go func(done <-chan struct{}, closed <-chan bool) { 1555 select { 1556 case <-done: 1557 case <-closed: 1558 cancel() 1559 } 1560 }(ctx.Done(), cn.CloseNotify()) 1561 } 1562 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1563 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1564 if err != nil { 1565 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1566 return 1567 } 1568 resp, md, err := request_Auth_UserAdd_0(rctx, inboundMarshaler, client, req, pathParams) 1569 ctx = runtime.NewServerMetadataContext(ctx, md) 1570 if err != nil { 1571 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1572 return 1573 } 1574 1575 forward_Auth_UserAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1576 1577 }) 1578 1579 mux.Handle("POST", pattern_Auth_UserGet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1580 ctx, cancel := context.WithCancel(ctx) 1581 defer cancel() 1582 if cn, ok := w.(http.CloseNotifier); ok { 1583 go func(done <-chan struct{}, closed <-chan bool) { 1584 select { 1585 case <-done: 1586 case <-closed: 1587 cancel() 1588 } 1589 }(ctx.Done(), cn.CloseNotify()) 1590 } 1591 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1592 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1593 if err != nil { 1594 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1595 return 1596 } 1597 resp, md, err := request_Auth_UserGet_0(rctx, inboundMarshaler, client, req, pathParams) 1598 ctx = runtime.NewServerMetadataContext(ctx, md) 1599 if err != nil { 1600 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1601 return 1602 } 1603 1604 forward_Auth_UserGet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1605 1606 }) 1607 1608 mux.Handle("POST", pattern_Auth_UserList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1609 ctx, cancel := context.WithCancel(ctx) 1610 defer cancel() 1611 if cn, ok := w.(http.CloseNotifier); ok { 1612 go func(done <-chan struct{}, closed <-chan bool) { 1613 select { 1614 case <-done: 1615 case <-closed: 1616 cancel() 1617 } 1618 }(ctx.Done(), cn.CloseNotify()) 1619 } 1620 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1621 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1622 if err != nil { 1623 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1624 return 1625 } 1626 resp, md, err := request_Auth_UserList_0(rctx, inboundMarshaler, client, req, pathParams) 1627 ctx = runtime.NewServerMetadataContext(ctx, md) 1628 if err != nil { 1629 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1630 return 1631 } 1632 1633 forward_Auth_UserList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1634 1635 }) 1636 1637 mux.Handle("POST", pattern_Auth_UserDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1638 ctx, cancel := context.WithCancel(ctx) 1639 defer cancel() 1640 if cn, ok := w.(http.CloseNotifier); ok { 1641 go func(done <-chan struct{}, closed <-chan bool) { 1642 select { 1643 case <-done: 1644 case <-closed: 1645 cancel() 1646 } 1647 }(ctx.Done(), cn.CloseNotify()) 1648 } 1649 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1650 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1651 if err != nil { 1652 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1653 return 1654 } 1655 resp, md, err := request_Auth_UserDelete_0(rctx, inboundMarshaler, client, req, pathParams) 1656 ctx = runtime.NewServerMetadataContext(ctx, md) 1657 if err != nil { 1658 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1659 return 1660 } 1661 1662 forward_Auth_UserDelete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1663 1664 }) 1665 1666 mux.Handle("POST", pattern_Auth_UserChangePassword_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1667 ctx, cancel := context.WithCancel(ctx) 1668 defer cancel() 1669 if cn, ok := w.(http.CloseNotifier); ok { 1670 go func(done <-chan struct{}, closed <-chan bool) { 1671 select { 1672 case <-done: 1673 case <-closed: 1674 cancel() 1675 } 1676 }(ctx.Done(), cn.CloseNotify()) 1677 } 1678 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1679 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1680 if err != nil { 1681 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1682 return 1683 } 1684 resp, md, err := request_Auth_UserChangePassword_0(rctx, inboundMarshaler, client, req, pathParams) 1685 ctx = runtime.NewServerMetadataContext(ctx, md) 1686 if err != nil { 1687 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1688 return 1689 } 1690 1691 forward_Auth_UserChangePassword_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1692 1693 }) 1694 1695 mux.Handle("POST", pattern_Auth_UserGrantRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1696 ctx, cancel := context.WithCancel(ctx) 1697 defer cancel() 1698 if cn, ok := w.(http.CloseNotifier); ok { 1699 go func(done <-chan struct{}, closed <-chan bool) { 1700 select { 1701 case <-done: 1702 case <-closed: 1703 cancel() 1704 } 1705 }(ctx.Done(), cn.CloseNotify()) 1706 } 1707 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1708 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1709 if err != nil { 1710 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1711 return 1712 } 1713 resp, md, err := request_Auth_UserGrantRole_0(rctx, inboundMarshaler, client, req, pathParams) 1714 ctx = runtime.NewServerMetadataContext(ctx, md) 1715 if err != nil { 1716 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1717 return 1718 } 1719 1720 forward_Auth_UserGrantRole_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1721 1722 }) 1723 1724 mux.Handle("POST", pattern_Auth_UserRevokeRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1725 ctx, cancel := context.WithCancel(ctx) 1726 defer cancel() 1727 if cn, ok := w.(http.CloseNotifier); ok { 1728 go func(done <-chan struct{}, closed <-chan bool) { 1729 select { 1730 case <-done: 1731 case <-closed: 1732 cancel() 1733 } 1734 }(ctx.Done(), cn.CloseNotify()) 1735 } 1736 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1737 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1738 if err != nil { 1739 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1740 return 1741 } 1742 resp, md, err := request_Auth_UserRevokeRole_0(rctx, inboundMarshaler, client, req, pathParams) 1743 ctx = runtime.NewServerMetadataContext(ctx, md) 1744 if err != nil { 1745 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1746 return 1747 } 1748 1749 forward_Auth_UserRevokeRole_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1750 1751 }) 1752 1753 mux.Handle("POST", pattern_Auth_RoleAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1754 ctx, cancel := context.WithCancel(ctx) 1755 defer cancel() 1756 if cn, ok := w.(http.CloseNotifier); ok { 1757 go func(done <-chan struct{}, closed <-chan bool) { 1758 select { 1759 case <-done: 1760 case <-closed: 1761 cancel() 1762 } 1763 }(ctx.Done(), cn.CloseNotify()) 1764 } 1765 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1766 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1767 if err != nil { 1768 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1769 return 1770 } 1771 resp, md, err := request_Auth_RoleAdd_0(rctx, inboundMarshaler, client, req, pathParams) 1772 ctx = runtime.NewServerMetadataContext(ctx, md) 1773 if err != nil { 1774 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1775 return 1776 } 1777 1778 forward_Auth_RoleAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1779 1780 }) 1781 1782 mux.Handle("POST", pattern_Auth_RoleGet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1783 ctx, cancel := context.WithCancel(ctx) 1784 defer cancel() 1785 if cn, ok := w.(http.CloseNotifier); ok { 1786 go func(done <-chan struct{}, closed <-chan bool) { 1787 select { 1788 case <-done: 1789 case <-closed: 1790 cancel() 1791 } 1792 }(ctx.Done(), cn.CloseNotify()) 1793 } 1794 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1795 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1796 if err != nil { 1797 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1798 return 1799 } 1800 resp, md, err := request_Auth_RoleGet_0(rctx, inboundMarshaler, client, req, pathParams) 1801 ctx = runtime.NewServerMetadataContext(ctx, md) 1802 if err != nil { 1803 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1804 return 1805 } 1806 1807 forward_Auth_RoleGet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1808 1809 }) 1810 1811 mux.Handle("POST", pattern_Auth_RoleList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1812 ctx, cancel := context.WithCancel(ctx) 1813 defer cancel() 1814 if cn, ok := w.(http.CloseNotifier); ok { 1815 go func(done <-chan struct{}, closed <-chan bool) { 1816 select { 1817 case <-done: 1818 case <-closed: 1819 cancel() 1820 } 1821 }(ctx.Done(), cn.CloseNotify()) 1822 } 1823 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1824 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1825 if err != nil { 1826 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1827 return 1828 } 1829 resp, md, err := request_Auth_RoleList_0(rctx, inboundMarshaler, client, req, pathParams) 1830 ctx = runtime.NewServerMetadataContext(ctx, md) 1831 if err != nil { 1832 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1833 return 1834 } 1835 1836 forward_Auth_RoleList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1837 1838 }) 1839 1840 mux.Handle("POST", pattern_Auth_RoleDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1841 ctx, cancel := context.WithCancel(ctx) 1842 defer cancel() 1843 if cn, ok := w.(http.CloseNotifier); ok { 1844 go func(done <-chan struct{}, closed <-chan bool) { 1845 select { 1846 case <-done: 1847 case <-closed: 1848 cancel() 1849 } 1850 }(ctx.Done(), cn.CloseNotify()) 1851 } 1852 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1853 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1854 if err != nil { 1855 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1856 return 1857 } 1858 resp, md, err := request_Auth_RoleDelete_0(rctx, inboundMarshaler, client, req, pathParams) 1859 ctx = runtime.NewServerMetadataContext(ctx, md) 1860 if err != nil { 1861 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1862 return 1863 } 1864 1865 forward_Auth_RoleDelete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1866 1867 }) 1868 1869 mux.Handle("POST", pattern_Auth_RoleGrantPermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1870 ctx, cancel := context.WithCancel(ctx) 1871 defer cancel() 1872 if cn, ok := w.(http.CloseNotifier); ok { 1873 go func(done <-chan struct{}, closed <-chan bool) { 1874 select { 1875 case <-done: 1876 case <-closed: 1877 cancel() 1878 } 1879 }(ctx.Done(), cn.CloseNotify()) 1880 } 1881 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1882 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1883 if err != nil { 1884 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1885 return 1886 } 1887 resp, md, err := request_Auth_RoleGrantPermission_0(rctx, inboundMarshaler, client, req, pathParams) 1888 ctx = runtime.NewServerMetadataContext(ctx, md) 1889 if err != nil { 1890 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1891 return 1892 } 1893 1894 forward_Auth_RoleGrantPermission_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1895 1896 }) 1897 1898 mux.Handle("POST", pattern_Auth_RoleRevokePermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1899 ctx, cancel := context.WithCancel(ctx) 1900 defer cancel() 1901 if cn, ok := w.(http.CloseNotifier); ok { 1902 go func(done <-chan struct{}, closed <-chan bool) { 1903 select { 1904 case <-done: 1905 case <-closed: 1906 cancel() 1907 } 1908 }(ctx.Done(), cn.CloseNotify()) 1909 } 1910 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1911 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1912 if err != nil { 1913 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1914 return 1915 } 1916 resp, md, err := request_Auth_RoleRevokePermission_0(rctx, inboundMarshaler, client, req, pathParams) 1917 ctx = runtime.NewServerMetadataContext(ctx, md) 1918 if err != nil { 1919 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1920 return 1921 } 1922 1923 forward_Auth_RoleRevokePermission_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1924 1925 }) 1926 1927 return nil 1928} 1929 1930var ( 1931 pattern_Auth_AuthEnable_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "auth", "enable"}, "")) 1932 1933 pattern_Auth_AuthDisable_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "auth", "disable"}, "")) 1934 1935 pattern_Auth_Authenticate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "auth", "authenticate"}, "")) 1936 1937 pattern_Auth_UserAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "add"}, "")) 1938 1939 pattern_Auth_UserGet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "get"}, "")) 1940 1941 pattern_Auth_UserList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "list"}, "")) 1942 1943 pattern_Auth_UserDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "delete"}, "")) 1944 1945 pattern_Auth_UserChangePassword_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "changepw"}, "")) 1946 1947 pattern_Auth_UserGrantRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "grant"}, "")) 1948 1949 pattern_Auth_UserRevokeRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "user", "revoke"}, "")) 1950 1951 pattern_Auth_RoleAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "add"}, "")) 1952 1953 pattern_Auth_RoleGet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "get"}, "")) 1954 1955 pattern_Auth_RoleList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "list"}, "")) 1956 1957 pattern_Auth_RoleDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "delete"}, "")) 1958 1959 pattern_Auth_RoleGrantPermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "grant"}, "")) 1960 1961 pattern_Auth_RoleRevokePermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3alpha", "auth", "role", "revoke"}, "")) 1962) 1963 1964var ( 1965 forward_Auth_AuthEnable_0 = runtime.ForwardResponseMessage 1966 1967 forward_Auth_AuthDisable_0 = runtime.ForwardResponseMessage 1968 1969 forward_Auth_Authenticate_0 = runtime.ForwardResponseMessage 1970 1971 forward_Auth_UserAdd_0 = runtime.ForwardResponseMessage 1972 1973 forward_Auth_UserGet_0 = runtime.ForwardResponseMessage 1974 1975 forward_Auth_UserList_0 = runtime.ForwardResponseMessage 1976 1977 forward_Auth_UserDelete_0 = runtime.ForwardResponseMessage 1978 1979 forward_Auth_UserChangePassword_0 = runtime.ForwardResponseMessage 1980 1981 forward_Auth_UserGrantRole_0 = runtime.ForwardResponseMessage 1982 1983 forward_Auth_UserRevokeRole_0 = runtime.ForwardResponseMessage 1984 1985 forward_Auth_RoleAdd_0 = runtime.ForwardResponseMessage 1986 1987 forward_Auth_RoleGet_0 = runtime.ForwardResponseMessage 1988 1989 forward_Auth_RoleList_0 = runtime.ForwardResponseMessage 1990 1991 forward_Auth_RoleDelete_0 = runtime.ForwardResponseMessage 1992 1993 forward_Auth_RoleGrantPermission_0 = runtime.ForwardResponseMessage 1994 1995 forward_Auth_RoleRevokePermission_0 = runtime.ForwardResponseMessage 1996) 1997