001package hapi.services.tiller; 002 003import static io.grpc.stub.ClientCalls.asyncUnaryCall; 004import static io.grpc.stub.ClientCalls.asyncServerStreamingCall; 005import static io.grpc.stub.ClientCalls.asyncClientStreamingCall; 006import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall; 007import static io.grpc.stub.ClientCalls.blockingUnaryCall; 008import static io.grpc.stub.ClientCalls.blockingServerStreamingCall; 009import static io.grpc.stub.ClientCalls.futureUnaryCall; 010import static io.grpc.MethodDescriptor.generateFullMethodName; 011import static io.grpc.stub.ServerCalls.asyncUnaryCall; 012import static io.grpc.stub.ServerCalls.asyncServerStreamingCall; 013import static io.grpc.stub.ServerCalls.asyncClientStreamingCall; 014import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall; 015import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall; 016import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall; 017 018/** 019 * <pre> 020 * ReleaseService is the service that a helm application uses to mutate, 021 * query, and manage releases. 022 * Release: A named installation composed of a chart and 023 * config. At any given time a release has one 024 * chart and one config. 025 * Config: A config is a YAML file that supplies values 026 * to the parametrizable templates of a chart. 027 * Chart: A chart is a helm package that contains 028 * metadata, a default config, zero or more 029 * optionally parameterizable templates, and 030 * zero or more charts (dependencies). 031 * </pre> 032 */ 033@javax.annotation.Generated( 034 value = "by gRPC proto compiler (version 1.3.0)", 035 comments = "Source: hapi/services/tiller.proto") 036public final class ReleaseServiceGrpc { 037 038 private ReleaseServiceGrpc() {} 039 040 public static final String SERVICE_NAME = "hapi.services.tiller.ReleaseService"; 041 042 // Static method descriptors that strictly reflect the proto. 043 @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901") 044 public static final io.grpc.MethodDescriptor<hapi.services.tiller.Tiller.ListReleasesRequest, 045 hapi.services.tiller.Tiller.ListReleasesResponse> METHOD_LIST_RELEASES = 046 io.grpc.MethodDescriptor.create( 047 io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING, 048 generateFullMethodName( 049 "hapi.services.tiller.ReleaseService", "ListReleases"), 050 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.ListReleasesRequest.getDefaultInstance()), 051 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.ListReleasesResponse.getDefaultInstance())); 052 @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901") 053 public static final io.grpc.MethodDescriptor<hapi.services.tiller.Tiller.GetReleaseStatusRequest, 054 hapi.services.tiller.Tiller.GetReleaseStatusResponse> METHOD_GET_RELEASE_STATUS = 055 io.grpc.MethodDescriptor.create( 056 io.grpc.MethodDescriptor.MethodType.UNARY, 057 generateFullMethodName( 058 "hapi.services.tiller.ReleaseService", "GetReleaseStatus"), 059 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.GetReleaseStatusRequest.getDefaultInstance()), 060 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.GetReleaseStatusResponse.getDefaultInstance())); 061 @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901") 062 public static final io.grpc.MethodDescriptor<hapi.services.tiller.Tiller.GetReleaseContentRequest, 063 hapi.services.tiller.Tiller.GetReleaseContentResponse> METHOD_GET_RELEASE_CONTENT = 064 io.grpc.MethodDescriptor.create( 065 io.grpc.MethodDescriptor.MethodType.UNARY, 066 generateFullMethodName( 067 "hapi.services.tiller.ReleaseService", "GetReleaseContent"), 068 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.GetReleaseContentRequest.getDefaultInstance()), 069 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.GetReleaseContentResponse.getDefaultInstance())); 070 @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901") 071 public static final io.grpc.MethodDescriptor<hapi.services.tiller.Tiller.UpdateReleaseRequest, 072 hapi.services.tiller.Tiller.UpdateReleaseResponse> METHOD_UPDATE_RELEASE = 073 io.grpc.MethodDescriptor.create( 074 io.grpc.MethodDescriptor.MethodType.UNARY, 075 generateFullMethodName( 076 "hapi.services.tiller.ReleaseService", "UpdateRelease"), 077 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.UpdateReleaseRequest.getDefaultInstance()), 078 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.UpdateReleaseResponse.getDefaultInstance())); 079 @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901") 080 public static final io.grpc.MethodDescriptor<hapi.services.tiller.Tiller.InstallReleaseRequest, 081 hapi.services.tiller.Tiller.InstallReleaseResponse> METHOD_INSTALL_RELEASE = 082 io.grpc.MethodDescriptor.create( 083 io.grpc.MethodDescriptor.MethodType.UNARY, 084 generateFullMethodName( 085 "hapi.services.tiller.ReleaseService", "InstallRelease"), 086 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.InstallReleaseRequest.getDefaultInstance()), 087 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.InstallReleaseResponse.getDefaultInstance())); 088 @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901") 089 public static final io.grpc.MethodDescriptor<hapi.services.tiller.Tiller.UninstallReleaseRequest, 090 hapi.services.tiller.Tiller.UninstallReleaseResponse> METHOD_UNINSTALL_RELEASE = 091 io.grpc.MethodDescriptor.create( 092 io.grpc.MethodDescriptor.MethodType.UNARY, 093 generateFullMethodName( 094 "hapi.services.tiller.ReleaseService", "UninstallRelease"), 095 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.UninstallReleaseRequest.getDefaultInstance()), 096 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.UninstallReleaseResponse.getDefaultInstance())); 097 @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901") 098 public static final io.grpc.MethodDescriptor<hapi.services.tiller.Tiller.GetVersionRequest, 099 hapi.services.tiller.Tiller.GetVersionResponse> METHOD_GET_VERSION = 100 io.grpc.MethodDescriptor.create( 101 io.grpc.MethodDescriptor.MethodType.UNARY, 102 generateFullMethodName( 103 "hapi.services.tiller.ReleaseService", "GetVersion"), 104 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.GetVersionRequest.getDefaultInstance()), 105 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.GetVersionResponse.getDefaultInstance())); 106 @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901") 107 public static final io.grpc.MethodDescriptor<hapi.services.tiller.Tiller.RollbackReleaseRequest, 108 hapi.services.tiller.Tiller.RollbackReleaseResponse> METHOD_ROLLBACK_RELEASE = 109 io.grpc.MethodDescriptor.create( 110 io.grpc.MethodDescriptor.MethodType.UNARY, 111 generateFullMethodName( 112 "hapi.services.tiller.ReleaseService", "RollbackRelease"), 113 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.RollbackReleaseRequest.getDefaultInstance()), 114 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.RollbackReleaseResponse.getDefaultInstance())); 115 @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901") 116 public static final io.grpc.MethodDescriptor<hapi.services.tiller.Tiller.GetHistoryRequest, 117 hapi.services.tiller.Tiller.GetHistoryResponse> METHOD_GET_HISTORY = 118 io.grpc.MethodDescriptor.create( 119 io.grpc.MethodDescriptor.MethodType.UNARY, 120 generateFullMethodName( 121 "hapi.services.tiller.ReleaseService", "GetHistory"), 122 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.GetHistoryRequest.getDefaultInstance()), 123 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.GetHistoryResponse.getDefaultInstance())); 124 @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901") 125 public static final io.grpc.MethodDescriptor<hapi.services.tiller.Tiller.TestReleaseRequest, 126 hapi.services.tiller.Tiller.TestReleaseResponse> METHOD_RUN_RELEASE_TEST = 127 io.grpc.MethodDescriptor.create( 128 io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING, 129 generateFullMethodName( 130 "hapi.services.tiller.ReleaseService", "RunReleaseTest"), 131 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.TestReleaseRequest.getDefaultInstance()), 132 io.grpc.protobuf.ProtoUtils.marshaller(hapi.services.tiller.Tiller.TestReleaseResponse.getDefaultInstance())); 133 134 /** 135 * Creates a new async stub that supports all call types for the service 136 */ 137 public static ReleaseServiceStub newStub(io.grpc.Channel channel) { 138 return new ReleaseServiceStub(channel); 139 } 140 141 /** 142 * Creates a new blocking-style stub that supports unary and streaming output calls on the service 143 */ 144 public static ReleaseServiceBlockingStub newBlockingStub( 145 io.grpc.Channel channel) { 146 return new ReleaseServiceBlockingStub(channel); 147 } 148 149 /** 150 * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service 151 */ 152 public static ReleaseServiceFutureStub newFutureStub( 153 io.grpc.Channel channel) { 154 return new ReleaseServiceFutureStub(channel); 155 } 156 157 /** 158 * <pre> 159 * ReleaseService is the service that a helm application uses to mutate, 160 * query, and manage releases. 161 * Release: A named installation composed of a chart and 162 * config. At any given time a release has one 163 * chart and one config. 164 * Config: A config is a YAML file that supplies values 165 * to the parametrizable templates of a chart. 166 * Chart: A chart is a helm package that contains 167 * metadata, a default config, zero or more 168 * optionally parameterizable templates, and 169 * zero or more charts (dependencies). 170 * </pre> 171 */ 172 public static abstract class ReleaseServiceImplBase implements io.grpc.BindableService { 173 174 /** 175 * <pre> 176 * ListReleases retrieves release history. 177 * TODO: Allow filtering the set of releases by 178 * release status. By default, ListAllReleases returns the releases who 179 * current status is "Active". 180 * </pre> 181 */ 182 public void listReleases(hapi.services.tiller.Tiller.ListReleasesRequest request, 183 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.ListReleasesResponse> responseObserver) { 184 asyncUnimplementedUnaryCall(METHOD_LIST_RELEASES, responseObserver); 185 } 186 187 /** 188 * <pre> 189 * GetReleasesStatus retrieves status information for the specified release. 190 * </pre> 191 */ 192 public void getReleaseStatus(hapi.services.tiller.Tiller.GetReleaseStatusRequest request, 193 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.GetReleaseStatusResponse> responseObserver) { 194 asyncUnimplementedUnaryCall(METHOD_GET_RELEASE_STATUS, responseObserver); 195 } 196 197 /** 198 * <pre> 199 * GetReleaseContent retrieves the release content (chart + value) for the specified release. 200 * </pre> 201 */ 202 public void getReleaseContent(hapi.services.tiller.Tiller.GetReleaseContentRequest request, 203 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.GetReleaseContentResponse> responseObserver) { 204 asyncUnimplementedUnaryCall(METHOD_GET_RELEASE_CONTENT, responseObserver); 205 } 206 207 /** 208 * <pre> 209 * UpdateRelease updates release content. 210 * </pre> 211 */ 212 public void updateRelease(hapi.services.tiller.Tiller.UpdateReleaseRequest request, 213 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.UpdateReleaseResponse> responseObserver) { 214 asyncUnimplementedUnaryCall(METHOD_UPDATE_RELEASE, responseObserver); 215 } 216 217 /** 218 * <pre> 219 * InstallRelease requests installation of a chart as a new release. 220 * </pre> 221 */ 222 public void installRelease(hapi.services.tiller.Tiller.InstallReleaseRequest request, 223 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.InstallReleaseResponse> responseObserver) { 224 asyncUnimplementedUnaryCall(METHOD_INSTALL_RELEASE, responseObserver); 225 } 226 227 /** 228 * <pre> 229 * UninstallRelease requests deletion of a named release. 230 * </pre> 231 */ 232 public void uninstallRelease(hapi.services.tiller.Tiller.UninstallReleaseRequest request, 233 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.UninstallReleaseResponse> responseObserver) { 234 asyncUnimplementedUnaryCall(METHOD_UNINSTALL_RELEASE, responseObserver); 235 } 236 237 /** 238 * <pre> 239 * GetVersion returns the current version of the server. 240 * </pre> 241 */ 242 public void getVersion(hapi.services.tiller.Tiller.GetVersionRequest request, 243 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.GetVersionResponse> responseObserver) { 244 asyncUnimplementedUnaryCall(METHOD_GET_VERSION, responseObserver); 245 } 246 247 /** 248 * <pre> 249 * RollbackRelease rolls back a release to a previous version. 250 * </pre> 251 */ 252 public void rollbackRelease(hapi.services.tiller.Tiller.RollbackReleaseRequest request, 253 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.RollbackReleaseResponse> responseObserver) { 254 asyncUnimplementedUnaryCall(METHOD_ROLLBACK_RELEASE, responseObserver); 255 } 256 257 /** 258 * <pre> 259 * ReleaseHistory retrieves a releasse's history. 260 * </pre> 261 */ 262 public void getHistory(hapi.services.tiller.Tiller.GetHistoryRequest request, 263 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.GetHistoryResponse> responseObserver) { 264 asyncUnimplementedUnaryCall(METHOD_GET_HISTORY, responseObserver); 265 } 266 267 /** 268 * <pre> 269 * RunReleaseTest executes the tests defined of a named release 270 * </pre> 271 */ 272 public void runReleaseTest(hapi.services.tiller.Tiller.TestReleaseRequest request, 273 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.TestReleaseResponse> responseObserver) { 274 asyncUnimplementedUnaryCall(METHOD_RUN_RELEASE_TEST, responseObserver); 275 } 276 277 @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { 278 return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) 279 .addMethod( 280 METHOD_LIST_RELEASES, 281 asyncServerStreamingCall( 282 new MethodHandlers< 283 hapi.services.tiller.Tiller.ListReleasesRequest, 284 hapi.services.tiller.Tiller.ListReleasesResponse>( 285 this, METHODID_LIST_RELEASES))) 286 .addMethod( 287 METHOD_GET_RELEASE_STATUS, 288 asyncUnaryCall( 289 new MethodHandlers< 290 hapi.services.tiller.Tiller.GetReleaseStatusRequest, 291 hapi.services.tiller.Tiller.GetReleaseStatusResponse>( 292 this, METHODID_GET_RELEASE_STATUS))) 293 .addMethod( 294 METHOD_GET_RELEASE_CONTENT, 295 asyncUnaryCall( 296 new MethodHandlers< 297 hapi.services.tiller.Tiller.GetReleaseContentRequest, 298 hapi.services.tiller.Tiller.GetReleaseContentResponse>( 299 this, METHODID_GET_RELEASE_CONTENT))) 300 .addMethod( 301 METHOD_UPDATE_RELEASE, 302 asyncUnaryCall( 303 new MethodHandlers< 304 hapi.services.tiller.Tiller.UpdateReleaseRequest, 305 hapi.services.tiller.Tiller.UpdateReleaseResponse>( 306 this, METHODID_UPDATE_RELEASE))) 307 .addMethod( 308 METHOD_INSTALL_RELEASE, 309 asyncUnaryCall( 310 new MethodHandlers< 311 hapi.services.tiller.Tiller.InstallReleaseRequest, 312 hapi.services.tiller.Tiller.InstallReleaseResponse>( 313 this, METHODID_INSTALL_RELEASE))) 314 .addMethod( 315 METHOD_UNINSTALL_RELEASE, 316 asyncUnaryCall( 317 new MethodHandlers< 318 hapi.services.tiller.Tiller.UninstallReleaseRequest, 319 hapi.services.tiller.Tiller.UninstallReleaseResponse>( 320 this, METHODID_UNINSTALL_RELEASE))) 321 .addMethod( 322 METHOD_GET_VERSION, 323 asyncUnaryCall( 324 new MethodHandlers< 325 hapi.services.tiller.Tiller.GetVersionRequest, 326 hapi.services.tiller.Tiller.GetVersionResponse>( 327 this, METHODID_GET_VERSION))) 328 .addMethod( 329 METHOD_ROLLBACK_RELEASE, 330 asyncUnaryCall( 331 new MethodHandlers< 332 hapi.services.tiller.Tiller.RollbackReleaseRequest, 333 hapi.services.tiller.Tiller.RollbackReleaseResponse>( 334 this, METHODID_ROLLBACK_RELEASE))) 335 .addMethod( 336 METHOD_GET_HISTORY, 337 asyncUnaryCall( 338 new MethodHandlers< 339 hapi.services.tiller.Tiller.GetHistoryRequest, 340 hapi.services.tiller.Tiller.GetHistoryResponse>( 341 this, METHODID_GET_HISTORY))) 342 .addMethod( 343 METHOD_RUN_RELEASE_TEST, 344 asyncServerStreamingCall( 345 new MethodHandlers< 346 hapi.services.tiller.Tiller.TestReleaseRequest, 347 hapi.services.tiller.Tiller.TestReleaseResponse>( 348 this, METHODID_RUN_RELEASE_TEST))) 349 .build(); 350 } 351 } 352 353 /** 354 * <pre> 355 * ReleaseService is the service that a helm application uses to mutate, 356 * query, and manage releases. 357 * Release: A named installation composed of a chart and 358 * config. At any given time a release has one 359 * chart and one config. 360 * Config: A config is a YAML file that supplies values 361 * to the parametrizable templates of a chart. 362 * Chart: A chart is a helm package that contains 363 * metadata, a default config, zero or more 364 * optionally parameterizable templates, and 365 * zero or more charts (dependencies). 366 * </pre> 367 */ 368 public static final class ReleaseServiceStub extends io.grpc.stub.AbstractStub<ReleaseServiceStub> { 369 private ReleaseServiceStub(io.grpc.Channel channel) { 370 super(channel); 371 } 372 373 private ReleaseServiceStub(io.grpc.Channel channel, 374 io.grpc.CallOptions callOptions) { 375 super(channel, callOptions); 376 } 377 378 @java.lang.Override 379 protected ReleaseServiceStub build(io.grpc.Channel channel, 380 io.grpc.CallOptions callOptions) { 381 return new ReleaseServiceStub(channel, callOptions); 382 } 383 384 /** 385 * <pre> 386 * ListReleases retrieves release history. 387 * TODO: Allow filtering the set of releases by 388 * release status. By default, ListAllReleases returns the releases who 389 * current status is "Active". 390 * </pre> 391 */ 392 public void listReleases(hapi.services.tiller.Tiller.ListReleasesRequest request, 393 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.ListReleasesResponse> responseObserver) { 394 asyncServerStreamingCall( 395 getChannel().newCall(METHOD_LIST_RELEASES, getCallOptions()), request, responseObserver); 396 } 397 398 /** 399 * <pre> 400 * GetReleasesStatus retrieves status information for the specified release. 401 * </pre> 402 */ 403 public void getReleaseStatus(hapi.services.tiller.Tiller.GetReleaseStatusRequest request, 404 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.GetReleaseStatusResponse> responseObserver) { 405 asyncUnaryCall( 406 getChannel().newCall(METHOD_GET_RELEASE_STATUS, getCallOptions()), request, responseObserver); 407 } 408 409 /** 410 * <pre> 411 * GetReleaseContent retrieves the release content (chart + value) for the specified release. 412 * </pre> 413 */ 414 public void getReleaseContent(hapi.services.tiller.Tiller.GetReleaseContentRequest request, 415 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.GetReleaseContentResponse> responseObserver) { 416 asyncUnaryCall( 417 getChannel().newCall(METHOD_GET_RELEASE_CONTENT, getCallOptions()), request, responseObserver); 418 } 419 420 /** 421 * <pre> 422 * UpdateRelease updates release content. 423 * </pre> 424 */ 425 public void updateRelease(hapi.services.tiller.Tiller.UpdateReleaseRequest request, 426 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.UpdateReleaseResponse> responseObserver) { 427 asyncUnaryCall( 428 getChannel().newCall(METHOD_UPDATE_RELEASE, getCallOptions()), request, responseObserver); 429 } 430 431 /** 432 * <pre> 433 * InstallRelease requests installation of a chart as a new release. 434 * </pre> 435 */ 436 public void installRelease(hapi.services.tiller.Tiller.InstallReleaseRequest request, 437 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.InstallReleaseResponse> responseObserver) { 438 asyncUnaryCall( 439 getChannel().newCall(METHOD_INSTALL_RELEASE, getCallOptions()), request, responseObserver); 440 } 441 442 /** 443 * <pre> 444 * UninstallRelease requests deletion of a named release. 445 * </pre> 446 */ 447 public void uninstallRelease(hapi.services.tiller.Tiller.UninstallReleaseRequest request, 448 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.UninstallReleaseResponse> responseObserver) { 449 asyncUnaryCall( 450 getChannel().newCall(METHOD_UNINSTALL_RELEASE, getCallOptions()), request, responseObserver); 451 } 452 453 /** 454 * <pre> 455 * GetVersion returns the current version of the server. 456 * </pre> 457 */ 458 public void getVersion(hapi.services.tiller.Tiller.GetVersionRequest request, 459 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.GetVersionResponse> responseObserver) { 460 asyncUnaryCall( 461 getChannel().newCall(METHOD_GET_VERSION, getCallOptions()), request, responseObserver); 462 } 463 464 /** 465 * <pre> 466 * RollbackRelease rolls back a release to a previous version. 467 * </pre> 468 */ 469 public void rollbackRelease(hapi.services.tiller.Tiller.RollbackReleaseRequest request, 470 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.RollbackReleaseResponse> responseObserver) { 471 asyncUnaryCall( 472 getChannel().newCall(METHOD_ROLLBACK_RELEASE, getCallOptions()), request, responseObserver); 473 } 474 475 /** 476 * <pre> 477 * ReleaseHistory retrieves a releasse's history. 478 * </pre> 479 */ 480 public void getHistory(hapi.services.tiller.Tiller.GetHistoryRequest request, 481 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.GetHistoryResponse> responseObserver) { 482 asyncUnaryCall( 483 getChannel().newCall(METHOD_GET_HISTORY, getCallOptions()), request, responseObserver); 484 } 485 486 /** 487 * <pre> 488 * RunReleaseTest executes the tests defined of a named release 489 * </pre> 490 */ 491 public void runReleaseTest(hapi.services.tiller.Tiller.TestReleaseRequest request, 492 io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.TestReleaseResponse> responseObserver) { 493 asyncServerStreamingCall( 494 getChannel().newCall(METHOD_RUN_RELEASE_TEST, getCallOptions()), request, responseObserver); 495 } 496 } 497 498 /** 499 * <pre> 500 * ReleaseService is the service that a helm application uses to mutate, 501 * query, and manage releases. 502 * Release: A named installation composed of a chart and 503 * config. At any given time a release has one 504 * chart and one config. 505 * Config: A config is a YAML file that supplies values 506 * to the parametrizable templates of a chart. 507 * Chart: A chart is a helm package that contains 508 * metadata, a default config, zero or more 509 * optionally parameterizable templates, and 510 * zero or more charts (dependencies). 511 * </pre> 512 */ 513 public static final class ReleaseServiceBlockingStub extends io.grpc.stub.AbstractStub<ReleaseServiceBlockingStub> { 514 private ReleaseServiceBlockingStub(io.grpc.Channel channel) { 515 super(channel); 516 } 517 518 private ReleaseServiceBlockingStub(io.grpc.Channel channel, 519 io.grpc.CallOptions callOptions) { 520 super(channel, callOptions); 521 } 522 523 @java.lang.Override 524 protected ReleaseServiceBlockingStub build(io.grpc.Channel channel, 525 io.grpc.CallOptions callOptions) { 526 return new ReleaseServiceBlockingStub(channel, callOptions); 527 } 528 529 /** 530 * <pre> 531 * ListReleases retrieves release history. 532 * TODO: Allow filtering the set of releases by 533 * release status. By default, ListAllReleases returns the releases who 534 * current status is "Active". 535 * </pre> 536 */ 537 public java.util.Iterator<hapi.services.tiller.Tiller.ListReleasesResponse> listReleases( 538 hapi.services.tiller.Tiller.ListReleasesRequest request) { 539 return blockingServerStreamingCall( 540 getChannel(), METHOD_LIST_RELEASES, getCallOptions(), request); 541 } 542 543 /** 544 * <pre> 545 * GetReleasesStatus retrieves status information for the specified release. 546 * </pre> 547 */ 548 public hapi.services.tiller.Tiller.GetReleaseStatusResponse getReleaseStatus(hapi.services.tiller.Tiller.GetReleaseStatusRequest request) { 549 return blockingUnaryCall( 550 getChannel(), METHOD_GET_RELEASE_STATUS, getCallOptions(), request); 551 } 552 553 /** 554 * <pre> 555 * GetReleaseContent retrieves the release content (chart + value) for the specified release. 556 * </pre> 557 */ 558 public hapi.services.tiller.Tiller.GetReleaseContentResponse getReleaseContent(hapi.services.tiller.Tiller.GetReleaseContentRequest request) { 559 return blockingUnaryCall( 560 getChannel(), METHOD_GET_RELEASE_CONTENT, getCallOptions(), request); 561 } 562 563 /** 564 * <pre> 565 * UpdateRelease updates release content. 566 * </pre> 567 */ 568 public hapi.services.tiller.Tiller.UpdateReleaseResponse updateRelease(hapi.services.tiller.Tiller.UpdateReleaseRequest request) { 569 return blockingUnaryCall( 570 getChannel(), METHOD_UPDATE_RELEASE, getCallOptions(), request); 571 } 572 573 /** 574 * <pre> 575 * InstallRelease requests installation of a chart as a new release. 576 * </pre> 577 */ 578 public hapi.services.tiller.Tiller.InstallReleaseResponse installRelease(hapi.services.tiller.Tiller.InstallReleaseRequest request) { 579 return blockingUnaryCall( 580 getChannel(), METHOD_INSTALL_RELEASE, getCallOptions(), request); 581 } 582 583 /** 584 * <pre> 585 * UninstallRelease requests deletion of a named release. 586 * </pre> 587 */ 588 public hapi.services.tiller.Tiller.UninstallReleaseResponse uninstallRelease(hapi.services.tiller.Tiller.UninstallReleaseRequest request) { 589 return blockingUnaryCall( 590 getChannel(), METHOD_UNINSTALL_RELEASE, getCallOptions(), request); 591 } 592 593 /** 594 * <pre> 595 * GetVersion returns the current version of the server. 596 * </pre> 597 */ 598 public hapi.services.tiller.Tiller.GetVersionResponse getVersion(hapi.services.tiller.Tiller.GetVersionRequest request) { 599 return blockingUnaryCall( 600 getChannel(), METHOD_GET_VERSION, getCallOptions(), request); 601 } 602 603 /** 604 * <pre> 605 * RollbackRelease rolls back a release to a previous version. 606 * </pre> 607 */ 608 public hapi.services.tiller.Tiller.RollbackReleaseResponse rollbackRelease(hapi.services.tiller.Tiller.RollbackReleaseRequest request) { 609 return blockingUnaryCall( 610 getChannel(), METHOD_ROLLBACK_RELEASE, getCallOptions(), request); 611 } 612 613 /** 614 * <pre> 615 * ReleaseHistory retrieves a releasse's history. 616 * </pre> 617 */ 618 public hapi.services.tiller.Tiller.GetHistoryResponse getHistory(hapi.services.tiller.Tiller.GetHistoryRequest request) { 619 return blockingUnaryCall( 620 getChannel(), METHOD_GET_HISTORY, getCallOptions(), request); 621 } 622 623 /** 624 * <pre> 625 * RunReleaseTest executes the tests defined of a named release 626 * </pre> 627 */ 628 public java.util.Iterator<hapi.services.tiller.Tiller.TestReleaseResponse> runReleaseTest( 629 hapi.services.tiller.Tiller.TestReleaseRequest request) { 630 return blockingServerStreamingCall( 631 getChannel(), METHOD_RUN_RELEASE_TEST, getCallOptions(), request); 632 } 633 } 634 635 /** 636 * <pre> 637 * ReleaseService is the service that a helm application uses to mutate, 638 * query, and manage releases. 639 * Release: A named installation composed of a chart and 640 * config. At any given time a release has one 641 * chart and one config. 642 * Config: A config is a YAML file that supplies values 643 * to the parametrizable templates of a chart. 644 * Chart: A chart is a helm package that contains 645 * metadata, a default config, zero or more 646 * optionally parameterizable templates, and 647 * zero or more charts (dependencies). 648 * </pre> 649 */ 650 public static final class ReleaseServiceFutureStub extends io.grpc.stub.AbstractStub<ReleaseServiceFutureStub> { 651 private ReleaseServiceFutureStub(io.grpc.Channel channel) { 652 super(channel); 653 } 654 655 private ReleaseServiceFutureStub(io.grpc.Channel channel, 656 io.grpc.CallOptions callOptions) { 657 super(channel, callOptions); 658 } 659 660 @java.lang.Override 661 protected ReleaseServiceFutureStub build(io.grpc.Channel channel, 662 io.grpc.CallOptions callOptions) { 663 return new ReleaseServiceFutureStub(channel, callOptions); 664 } 665 666 /** 667 * <pre> 668 * GetReleasesStatus retrieves status information for the specified release. 669 * </pre> 670 */ 671 public com.google.common.util.concurrent.ListenableFuture<hapi.services.tiller.Tiller.GetReleaseStatusResponse> getReleaseStatus( 672 hapi.services.tiller.Tiller.GetReleaseStatusRequest request) { 673 return futureUnaryCall( 674 getChannel().newCall(METHOD_GET_RELEASE_STATUS, getCallOptions()), request); 675 } 676 677 /** 678 * <pre> 679 * GetReleaseContent retrieves the release content (chart + value) for the specified release. 680 * </pre> 681 */ 682 public com.google.common.util.concurrent.ListenableFuture<hapi.services.tiller.Tiller.GetReleaseContentResponse> getReleaseContent( 683 hapi.services.tiller.Tiller.GetReleaseContentRequest request) { 684 return futureUnaryCall( 685 getChannel().newCall(METHOD_GET_RELEASE_CONTENT, getCallOptions()), request); 686 } 687 688 /** 689 * <pre> 690 * UpdateRelease updates release content. 691 * </pre> 692 */ 693 public com.google.common.util.concurrent.ListenableFuture<hapi.services.tiller.Tiller.UpdateReleaseResponse> updateRelease( 694 hapi.services.tiller.Tiller.UpdateReleaseRequest request) { 695 return futureUnaryCall( 696 getChannel().newCall(METHOD_UPDATE_RELEASE, getCallOptions()), request); 697 } 698 699 /** 700 * <pre> 701 * InstallRelease requests installation of a chart as a new release. 702 * </pre> 703 */ 704 public com.google.common.util.concurrent.ListenableFuture<hapi.services.tiller.Tiller.InstallReleaseResponse> installRelease( 705 hapi.services.tiller.Tiller.InstallReleaseRequest request) { 706 return futureUnaryCall( 707 getChannel().newCall(METHOD_INSTALL_RELEASE, getCallOptions()), request); 708 } 709 710 /** 711 * <pre> 712 * UninstallRelease requests deletion of a named release. 713 * </pre> 714 */ 715 public com.google.common.util.concurrent.ListenableFuture<hapi.services.tiller.Tiller.UninstallReleaseResponse> uninstallRelease( 716 hapi.services.tiller.Tiller.UninstallReleaseRequest request) { 717 return futureUnaryCall( 718 getChannel().newCall(METHOD_UNINSTALL_RELEASE, getCallOptions()), request); 719 } 720 721 /** 722 * <pre> 723 * GetVersion returns the current version of the server. 724 * </pre> 725 */ 726 public com.google.common.util.concurrent.ListenableFuture<hapi.services.tiller.Tiller.GetVersionResponse> getVersion( 727 hapi.services.tiller.Tiller.GetVersionRequest request) { 728 return futureUnaryCall( 729 getChannel().newCall(METHOD_GET_VERSION, getCallOptions()), request); 730 } 731 732 /** 733 * <pre> 734 * RollbackRelease rolls back a release to a previous version. 735 * </pre> 736 */ 737 public com.google.common.util.concurrent.ListenableFuture<hapi.services.tiller.Tiller.RollbackReleaseResponse> rollbackRelease( 738 hapi.services.tiller.Tiller.RollbackReleaseRequest request) { 739 return futureUnaryCall( 740 getChannel().newCall(METHOD_ROLLBACK_RELEASE, getCallOptions()), request); 741 } 742 743 /** 744 * <pre> 745 * ReleaseHistory retrieves a releasse's history. 746 * </pre> 747 */ 748 public com.google.common.util.concurrent.ListenableFuture<hapi.services.tiller.Tiller.GetHistoryResponse> getHistory( 749 hapi.services.tiller.Tiller.GetHistoryRequest request) { 750 return futureUnaryCall( 751 getChannel().newCall(METHOD_GET_HISTORY, getCallOptions()), request); 752 } 753 } 754 755 private static final int METHODID_LIST_RELEASES = 0; 756 private static final int METHODID_GET_RELEASE_STATUS = 1; 757 private static final int METHODID_GET_RELEASE_CONTENT = 2; 758 private static final int METHODID_UPDATE_RELEASE = 3; 759 private static final int METHODID_INSTALL_RELEASE = 4; 760 private static final int METHODID_UNINSTALL_RELEASE = 5; 761 private static final int METHODID_GET_VERSION = 6; 762 private static final int METHODID_ROLLBACK_RELEASE = 7; 763 private static final int METHODID_GET_HISTORY = 8; 764 private static final int METHODID_RUN_RELEASE_TEST = 9; 765 766 private static final class MethodHandlers<Req, Resp> implements 767 io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>, 768 io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>, 769 io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>, 770 io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> { 771 private final ReleaseServiceImplBase serviceImpl; 772 private final int methodId; 773 774 MethodHandlers(ReleaseServiceImplBase serviceImpl, int methodId) { 775 this.serviceImpl = serviceImpl; 776 this.methodId = methodId; 777 } 778 779 @java.lang.Override 780 @java.lang.SuppressWarnings("unchecked") 781 public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) { 782 switch (methodId) { 783 case METHODID_LIST_RELEASES: 784 serviceImpl.listReleases((hapi.services.tiller.Tiller.ListReleasesRequest) request, 785 (io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.ListReleasesResponse>) responseObserver); 786 break; 787 case METHODID_GET_RELEASE_STATUS: 788 serviceImpl.getReleaseStatus((hapi.services.tiller.Tiller.GetReleaseStatusRequest) request, 789 (io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.GetReleaseStatusResponse>) responseObserver); 790 break; 791 case METHODID_GET_RELEASE_CONTENT: 792 serviceImpl.getReleaseContent((hapi.services.tiller.Tiller.GetReleaseContentRequest) request, 793 (io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.GetReleaseContentResponse>) responseObserver); 794 break; 795 case METHODID_UPDATE_RELEASE: 796 serviceImpl.updateRelease((hapi.services.tiller.Tiller.UpdateReleaseRequest) request, 797 (io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.UpdateReleaseResponse>) responseObserver); 798 break; 799 case METHODID_INSTALL_RELEASE: 800 serviceImpl.installRelease((hapi.services.tiller.Tiller.InstallReleaseRequest) request, 801 (io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.InstallReleaseResponse>) responseObserver); 802 break; 803 case METHODID_UNINSTALL_RELEASE: 804 serviceImpl.uninstallRelease((hapi.services.tiller.Tiller.UninstallReleaseRequest) request, 805 (io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.UninstallReleaseResponse>) responseObserver); 806 break; 807 case METHODID_GET_VERSION: 808 serviceImpl.getVersion((hapi.services.tiller.Tiller.GetVersionRequest) request, 809 (io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.GetVersionResponse>) responseObserver); 810 break; 811 case METHODID_ROLLBACK_RELEASE: 812 serviceImpl.rollbackRelease((hapi.services.tiller.Tiller.RollbackReleaseRequest) request, 813 (io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.RollbackReleaseResponse>) responseObserver); 814 break; 815 case METHODID_GET_HISTORY: 816 serviceImpl.getHistory((hapi.services.tiller.Tiller.GetHistoryRequest) request, 817 (io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.GetHistoryResponse>) responseObserver); 818 break; 819 case METHODID_RUN_RELEASE_TEST: 820 serviceImpl.runReleaseTest((hapi.services.tiller.Tiller.TestReleaseRequest) request, 821 (io.grpc.stub.StreamObserver<hapi.services.tiller.Tiller.TestReleaseResponse>) responseObserver); 822 break; 823 default: 824 throw new AssertionError(); 825 } 826 } 827 828 @java.lang.Override 829 @java.lang.SuppressWarnings("unchecked") 830 public io.grpc.stub.StreamObserver<Req> invoke( 831 io.grpc.stub.StreamObserver<Resp> responseObserver) { 832 switch (methodId) { 833 default: 834 throw new AssertionError(); 835 } 836 } 837 } 838 839 private static final class ReleaseServiceDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier { 840 @java.lang.Override 841 public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() { 842 return hapi.services.tiller.Tiller.getDescriptor(); 843 } 844 } 845 846 private static volatile io.grpc.ServiceDescriptor serviceDescriptor; 847 848 public static io.grpc.ServiceDescriptor getServiceDescriptor() { 849 io.grpc.ServiceDescriptor result = serviceDescriptor; 850 if (result == null) { 851 synchronized (ReleaseServiceGrpc.class) { 852 result = serviceDescriptor; 853 if (result == null) { 854 serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) 855 .setSchemaDescriptor(new ReleaseServiceDescriptorSupplier()) 856 .addMethod(METHOD_LIST_RELEASES) 857 .addMethod(METHOD_GET_RELEASE_STATUS) 858 .addMethod(METHOD_GET_RELEASE_CONTENT) 859 .addMethod(METHOD_UPDATE_RELEASE) 860 .addMethod(METHOD_INSTALL_RELEASE) 861 .addMethod(METHOD_UNINSTALL_RELEASE) 862 .addMethod(METHOD_GET_VERSION) 863 .addMethod(METHOD_ROLLBACK_RELEASE) 864 .addMethod(METHOD_GET_HISTORY) 865 .addMethod(METHOD_RUN_RELEASE_TEST) 866 .build(); 867 } 868 } 869 } 870 return result; 871 } 872}