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