• Home
• me.reactiv.fabric-java-sdk
• fabric-java-sdk
• 1.0
• source code
• DevopsGrpc.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.hyperledger.protos.DevopsGrpc Maven / Gradle / Ivy

package org.hyperledger.protos;

import static io.grpc.stub.ClientCalls.asyncUnaryCall;
import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ClientCalls.blockingUnaryCall;
import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
import static io.grpc.stub.ClientCalls.futureUnaryCall;
import static io.grpc.MethodDescriptor.generateFullMethodName;
import static io.grpc.stub.ServerCalls.asyncUnaryCall;
import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;

/**
 * 
 * Interface exported by the server.
 * 
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 0.15.0)",
    comments = "Source: devops.proto")
public class DevopsGrpc {

  private DevopsGrpc() {}

  public static final String SERVICE_NAME = "protos.Devops";

  // Static method descriptors that strictly reflect the proto.
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor METHOD_LOGIN =
      io.grpc.MethodDescriptor.create(
          io.grpc.MethodDescriptor.MethodType.UNARY,
          generateFullMethodName(
              "protos.Devops", "Login"),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.DevopsOuterClass.Secret.getDefaultInstance()),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.Fabric.Response.getDefaultInstance()));
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor METHOD_BUILD =
      io.grpc.MethodDescriptor.create(
          io.grpc.MethodDescriptor.MethodType.UNARY,
          generateFullMethodName(
              "protos.Devops", "Build"),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.Chaincode.ChaincodeSpec.getDefaultInstance()),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.Chaincode.ChaincodeDeploymentSpec.getDefaultInstance()));
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor METHOD_DEPLOY =
      io.grpc.MethodDescriptor.create(
          io.grpc.MethodDescriptor.MethodType.UNARY,
          generateFullMethodName(
              "protos.Devops", "Deploy"),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.Chaincode.ChaincodeSpec.getDefaultInstance()),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.Chaincode.ChaincodeDeploymentSpec.getDefaultInstance()));
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor METHOD_INVOKE =
      io.grpc.MethodDescriptor.create(
          io.grpc.MethodDescriptor.MethodType.UNARY,
          generateFullMethodName(
              "protos.Devops", "Invoke"),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec.getDefaultInstance()),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.Fabric.Response.getDefaultInstance()));
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor METHOD_QUERY =
      io.grpc.MethodDescriptor.create(
          io.grpc.MethodDescriptor.MethodType.UNARY,
          generateFullMethodName(
              "protos.Devops", "Query"),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec.getDefaultInstance()),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.Fabric.Response.getDefaultInstance()));
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor METHOD_EXP_GET_APPLICATION_TCERT =
      io.grpc.MethodDescriptor.create(
          io.grpc.MethodDescriptor.MethodType.UNARY,
          generateFullMethodName(
              "protos.Devops", "EXP_GetApplicationTCert"),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.DevopsOuterClass.Secret.getDefaultInstance()),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.Fabric.Response.getDefaultInstance()));
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor METHOD_EXP_PREPARE_FOR_TX =
      io.grpc.MethodDescriptor.create(
          io.grpc.MethodDescriptor.MethodType.UNARY,
          generateFullMethodName(
              "protos.Devops", "EXP_PrepareForTx"),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.DevopsOuterClass.Secret.getDefaultInstance()),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.Fabric.Response.getDefaultInstance()));
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor METHOD_EXP_PRODUCE_SIGMA =
      io.grpc.MethodDescriptor.create(
          io.grpc.MethodDescriptor.MethodType.UNARY,
          generateFullMethodName(
              "protos.Devops", "EXP_ProduceSigma"),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.DevopsOuterClass.SigmaInput.getDefaultInstance()),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.Fabric.Response.getDefaultInstance()));
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor METHOD_EXP_EXECUTE_WITH_BINDING =
      io.grpc.MethodDescriptor.create(
          io.grpc.MethodDescriptor.MethodType.UNARY,
          generateFullMethodName(
              "protos.Devops", "EXP_ExecuteWithBinding"),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.DevopsOuterClass.ExecuteWithBinding.getDefaultInstance()),
          io.grpc.protobuf.ProtoUtils.marshaller(org.hyperledger.protos.Fabric.Response.getDefaultInstance()));

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static DevopsStub newStub(io.grpc.Channel channel) {
    return new DevopsStub(channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static DevopsBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    return new DevopsBlockingStub(channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
   */
  public static DevopsFutureStub newFutureStub(
      io.grpc.Channel channel) {
    return new DevopsFutureStub(channel);
  }

  /**
   * 
   * Interface exported by the server.
   * 
   */
  @java.lang.Deprecated public static interface Devops {

    /**
     * 
     * Log in - passed Secret object and returns Response object, where
     * msg is the security context to be used in subsequent invocations
     * 
     */
    public void login(org.hyperledger.protos.DevopsOuterClass.Secret request,
        io.grpc.stub.StreamObserver responseObserver);

    /**
     * 
     * Build the chaincode package.
     * 
     */
    public void build(org.hyperledger.protos.Chaincode.ChaincodeSpec request,
        io.grpc.stub.StreamObserver responseObserver);

    /**
     * 
     * Deploy the chaincode package to the chain.
     * 
     */
    public void deploy(org.hyperledger.protos.Chaincode.ChaincodeSpec request,
        io.grpc.stub.StreamObserver responseObserver);

    /**
     * 
     * Invoke chaincode.
     * 
     */
    public void invoke(org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec request,
        io.grpc.stub.StreamObserver responseObserver);

    /**
     * 
     * Query chaincode.
     * 
     */
    public void query(org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec request,
        io.grpc.stub.StreamObserver responseObserver);

    /**
     * 
     * Retrieve a TCert.
     * 
     */
    public void eXPGetApplicationTCert(org.hyperledger.protos.DevopsOuterClass.Secret request,
        io.grpc.stub.StreamObserver responseObserver);

    /**
     * 
     * Prepare for performing a TX, which will return a binding that can later be used to sign and then execute a transaction.
     * 
     */
    public void eXPPrepareForTx(org.hyperledger.protos.DevopsOuterClass.Secret request,
        io.grpc.stub.StreamObserver responseObserver);

    /**
     * 
     * Prepare for performing a TX, which will return a binding that can later be used to sign and then execute a transaction.
     * 
     */
    public void eXPProduceSigma(org.hyperledger.protos.DevopsOuterClass.SigmaInput request,
        io.grpc.stub.StreamObserver responseObserver);

    /**
     * 
     * Execute a transaction with a specific binding
     * 
     */
    public void eXPExecuteWithBinding(org.hyperledger.protos.DevopsOuterClass.ExecuteWithBinding request,
        io.grpc.stub.StreamObserver responseObserver);
  }

  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1469")
  public static abstract class DevopsImplBase implements Devops, io.grpc.BindableService {

    @java.lang.Override
    public void login(org.hyperledger.protos.DevopsOuterClass.Secret request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_LOGIN, responseObserver);
    }

    @java.lang.Override
    public void build(org.hyperledger.protos.Chaincode.ChaincodeSpec request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_BUILD, responseObserver);
    }

    @java.lang.Override
    public void deploy(org.hyperledger.protos.Chaincode.ChaincodeSpec request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_DEPLOY, responseObserver);
    }

    @java.lang.Override
    public void invoke(org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_INVOKE, responseObserver);
    }

    @java.lang.Override
    public void query(org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_QUERY, responseObserver);
    }

    @java.lang.Override
    public void eXPGetApplicationTCert(org.hyperledger.protos.DevopsOuterClass.Secret request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_EXP_GET_APPLICATION_TCERT, responseObserver);
    }

    @java.lang.Override
    public void eXPPrepareForTx(org.hyperledger.protos.DevopsOuterClass.Secret request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_EXP_PREPARE_FOR_TX, responseObserver);
    }

    @java.lang.Override
    public void eXPProduceSigma(org.hyperledger.protos.DevopsOuterClass.SigmaInput request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_EXP_PRODUCE_SIGMA, responseObserver);
    }

    @java.lang.Override
    public void eXPExecuteWithBinding(org.hyperledger.protos.DevopsOuterClass.ExecuteWithBinding request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_EXP_EXECUTE_WITH_BINDING, responseObserver);
    }

    @java.lang.Override public io.grpc.ServerServiceDefinition bindService() {
      return DevopsGrpc.bindService(this);
    }
  }

  /**
   * 
   * Interface exported by the server.
   * 
   */
  @java.lang.Deprecated public static interface DevopsBlockingClient {

    /**
     * 
     * Log in - passed Secret object and returns Response object, where
     * msg is the security context to be used in subsequent invocations
     * 
     */
    public org.hyperledger.protos.Fabric.Response login(org.hyperledger.protos.DevopsOuterClass.Secret request);

    /**
     * 
     * Build the chaincode package.
     * 
     */
    public org.hyperledger.protos.Chaincode.ChaincodeDeploymentSpec build(org.hyperledger.protos.Chaincode.ChaincodeSpec request);

    /**
     * 
     * Deploy the chaincode package to the chain.
     * 
     */
    public org.hyperledger.protos.Chaincode.ChaincodeDeploymentSpec deploy(org.hyperledger.protos.Chaincode.ChaincodeSpec request);

    /**
     * 
     * Invoke chaincode.
     * 
     */
    public org.hyperledger.protos.Fabric.Response invoke(org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec request);

    /**
     * 
     * Query chaincode.
     * 
     */
    public org.hyperledger.protos.Fabric.Response query(org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec request);

    /**
     * 
     * Retrieve a TCert.
     * 
     */
    public org.hyperledger.protos.Fabric.Response eXPGetApplicationTCert(org.hyperledger.protos.DevopsOuterClass.Secret request);

    /**
     * 
     * Prepare for performing a TX, which will return a binding that can later be used to sign and then execute a transaction.
     * 
     */
    public org.hyperledger.protos.Fabric.Response eXPPrepareForTx(org.hyperledger.protos.DevopsOuterClass.Secret request);

    /**
     * 
     * Prepare for performing a TX, which will return a binding that can later be used to sign and then execute a transaction.
     * 
     */
    public org.hyperledger.protos.Fabric.Response eXPProduceSigma(org.hyperledger.protos.DevopsOuterClass.SigmaInput request);

    /**
     * 
     * Execute a transaction with a specific binding
     * 
     */
    public org.hyperledger.protos.Fabric.Response eXPExecuteWithBinding(org.hyperledger.protos.DevopsOuterClass.ExecuteWithBinding request);
  }

  /**
   * 
   * Interface exported by the server.
   * 
   */
  @java.lang.Deprecated public static interface DevopsFutureClient {

    /**
     * 
     * Log in - passed Secret object and returns Response object, where
     * msg is the security context to be used in subsequent invocations
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture login(
        org.hyperledger.protos.DevopsOuterClass.Secret request);

    /**
     * 
     * Build the chaincode package.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture build(
        org.hyperledger.protos.Chaincode.ChaincodeSpec request);

    /**
     * 
     * Deploy the chaincode package to the chain.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deploy(
        org.hyperledger.protos.Chaincode.ChaincodeSpec request);

    /**
     * 
     * Invoke chaincode.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture invoke(
        org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec request);

    /**
     * 
     * Query chaincode.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture query(
        org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec request);

    /**
     * 
     * Retrieve a TCert.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture eXPGetApplicationTCert(
        org.hyperledger.protos.DevopsOuterClass.Secret request);

    /**
     * 
     * Prepare for performing a TX, which will return a binding that can later be used to sign and then execute a transaction.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture eXPPrepareForTx(
        org.hyperledger.protos.DevopsOuterClass.Secret request);

    /**
     * 
     * Prepare for performing a TX, which will return a binding that can later be used to sign and then execute a transaction.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture eXPProduceSigma(
        org.hyperledger.protos.DevopsOuterClass.SigmaInput request);

    /**
     * 
     * Execute a transaction with a specific binding
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture eXPExecuteWithBinding(
        org.hyperledger.protos.DevopsOuterClass.ExecuteWithBinding request);
  }

  public static class DevopsStub extends io.grpc.stub.AbstractStub
      implements Devops {
    private DevopsStub(io.grpc.Channel channel) {
      super(channel);
    }

    private DevopsStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected DevopsStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new DevopsStub(channel, callOptions);
    }

    @java.lang.Override
    public void login(org.hyperledger.protos.DevopsOuterClass.Secret request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_LOGIN, getCallOptions()), request, responseObserver);
    }

    @java.lang.Override
    public void build(org.hyperledger.protos.Chaincode.ChaincodeSpec request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_BUILD, getCallOptions()), request, responseObserver);
    }

    @java.lang.Override
    public void deploy(org.hyperledger.protos.Chaincode.ChaincodeSpec request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_DEPLOY, getCallOptions()), request, responseObserver);
    }

    @java.lang.Override
    public void invoke(org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_INVOKE, getCallOptions()), request, responseObserver);
    }

    @java.lang.Override
    public void query(org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_QUERY, getCallOptions()), request, responseObserver);
    }

    @java.lang.Override
    public void eXPGetApplicationTCert(org.hyperledger.protos.DevopsOuterClass.Secret request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_EXP_GET_APPLICATION_TCERT, getCallOptions()), request, responseObserver);
    }

    @java.lang.Override
    public void eXPPrepareForTx(org.hyperledger.protos.DevopsOuterClass.Secret request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_EXP_PREPARE_FOR_TX, getCallOptions()), request, responseObserver);
    }

    @java.lang.Override
    public void eXPProduceSigma(org.hyperledger.protos.DevopsOuterClass.SigmaInput request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_EXP_PRODUCE_SIGMA, getCallOptions()), request, responseObserver);
    }

    @java.lang.Override
    public void eXPExecuteWithBinding(org.hyperledger.protos.DevopsOuterClass.ExecuteWithBinding request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_EXP_EXECUTE_WITH_BINDING, getCallOptions()), request, responseObserver);
    }
  }

  public static class DevopsBlockingStub extends io.grpc.stub.AbstractStub
      implements DevopsBlockingClient {
    private DevopsBlockingStub(io.grpc.Channel channel) {
      super(channel);
    }

    private DevopsBlockingStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected DevopsBlockingStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new DevopsBlockingStub(channel, callOptions);
    }

    @java.lang.Override
    public org.hyperledger.protos.Fabric.Response login(org.hyperledger.protos.DevopsOuterClass.Secret request) {
      return blockingUnaryCall(
          getChannel(), METHOD_LOGIN, getCallOptions(), request);
    }

    @java.lang.Override
    public org.hyperledger.protos.Chaincode.ChaincodeDeploymentSpec build(org.hyperledger.protos.Chaincode.ChaincodeSpec request) {
      return blockingUnaryCall(
          getChannel(), METHOD_BUILD, getCallOptions(), request);
    }

    @java.lang.Override
    public org.hyperledger.protos.Chaincode.ChaincodeDeploymentSpec deploy(org.hyperledger.protos.Chaincode.ChaincodeSpec request) {
      return blockingUnaryCall(
          getChannel(), METHOD_DEPLOY, getCallOptions(), request);
    }

    @java.lang.Override
    public org.hyperledger.protos.Fabric.Response invoke(org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec request) {
      return blockingUnaryCall(
          getChannel(), METHOD_INVOKE, getCallOptions(), request);
    }

    @java.lang.Override
    public org.hyperledger.protos.Fabric.Response query(org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec request) {
      return blockingUnaryCall(
          getChannel(), METHOD_QUERY, getCallOptions(), request);
    }

    @java.lang.Override
    public org.hyperledger.protos.Fabric.Response eXPGetApplicationTCert(org.hyperledger.protos.DevopsOuterClass.Secret request) {
      return blockingUnaryCall(
          getChannel(), METHOD_EXP_GET_APPLICATION_TCERT, getCallOptions(), request);
    }

    @java.lang.Override
    public org.hyperledger.protos.Fabric.Response eXPPrepareForTx(org.hyperledger.protos.DevopsOuterClass.Secret request) {
      return blockingUnaryCall(
          getChannel(), METHOD_EXP_PREPARE_FOR_TX, getCallOptions(), request);
    }

    @java.lang.Override
    public org.hyperledger.protos.Fabric.Response eXPProduceSigma(org.hyperledger.protos.DevopsOuterClass.SigmaInput request) {
      return blockingUnaryCall(
          getChannel(), METHOD_EXP_PRODUCE_SIGMA, getCallOptions(), request);
    }

    @java.lang.Override
    public org.hyperledger.protos.Fabric.Response eXPExecuteWithBinding(org.hyperledger.protos.DevopsOuterClass.ExecuteWithBinding request) {
      return blockingUnaryCall(
          getChannel(), METHOD_EXP_EXECUTE_WITH_BINDING, getCallOptions(), request);
    }
  }

  public static class DevopsFutureStub extends io.grpc.stub.AbstractStub
      implements DevopsFutureClient {
    private DevopsFutureStub(io.grpc.Channel channel) {
      super(channel);
    }

    private DevopsFutureStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected DevopsFutureStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new DevopsFutureStub(channel, callOptions);
    }

    @java.lang.Override
    public com.google.common.util.concurrent.ListenableFuture login(
        org.hyperledger.protos.DevopsOuterClass.Secret request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_LOGIN, getCallOptions()), request);
    }

    @java.lang.Override
    public com.google.common.util.concurrent.ListenableFuture build(
        org.hyperledger.protos.Chaincode.ChaincodeSpec request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_BUILD, getCallOptions()), request);
    }

    @java.lang.Override
    public com.google.common.util.concurrent.ListenableFuture deploy(
        org.hyperledger.protos.Chaincode.ChaincodeSpec request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_DEPLOY, getCallOptions()), request);
    }

    @java.lang.Override
    public com.google.common.util.concurrent.ListenableFuture invoke(
        org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_INVOKE, getCallOptions()), request);
    }

    @java.lang.Override
    public com.google.common.util.concurrent.ListenableFuture query(
        org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_QUERY, getCallOptions()), request);
    }

    @java.lang.Override
    public com.google.common.util.concurrent.ListenableFuture eXPGetApplicationTCert(
        org.hyperledger.protos.DevopsOuterClass.Secret request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_EXP_GET_APPLICATION_TCERT, getCallOptions()), request);
    }

    @java.lang.Override
    public com.google.common.util.concurrent.ListenableFuture eXPPrepareForTx(
        org.hyperledger.protos.DevopsOuterClass.Secret request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_EXP_PREPARE_FOR_TX, getCallOptions()), request);
    }

    @java.lang.Override
    public com.google.common.util.concurrent.ListenableFuture eXPProduceSigma(
        org.hyperledger.protos.DevopsOuterClass.SigmaInput request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_EXP_PRODUCE_SIGMA, getCallOptions()), request);
    }

    @java.lang.Override
    public com.google.common.util.concurrent.ListenableFuture eXPExecuteWithBinding(
        org.hyperledger.protos.DevopsOuterClass.ExecuteWithBinding request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_EXP_EXECUTE_WITH_BINDING, getCallOptions()), request);
    }
  }

  @java.lang.Deprecated public static abstract class AbstractDevops extends DevopsImplBase {}

  private static final int METHODID_LOGIN = 0;
  private static final int METHODID_BUILD = 1;
  private static final int METHODID_DEPLOY = 2;
  private static final int METHODID_INVOKE = 3;
  private static final int METHODID_QUERY = 4;
  private static final int METHODID_EXP_GET_APPLICATION_TCERT = 5;
  private static final int METHODID_EXP_PREPARE_FOR_TX = 6;
  private static final int METHODID_EXP_PRODUCE_SIGMA = 7;
  private static final int METHODID_EXP_EXECUTE_WITH_BINDING = 8;

  private static class MethodHandlers implements
      io.grpc.stub.ServerCalls.UnaryMethod,
      io.grpc.stub.ServerCalls.ServerStreamingMethod,
      io.grpc.stub.ServerCalls.ClientStreamingMethod,
      io.grpc.stub.ServerCalls.BidiStreamingMethod {
    private final Devops serviceImpl;
    private final int methodId;

    public MethodHandlers(Devops serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) {
      switch (methodId) {
        case METHODID_LOGIN:
          serviceImpl.login((org.hyperledger.protos.DevopsOuterClass.Secret) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_BUILD:
          serviceImpl.build((org.hyperledger.protos.Chaincode.ChaincodeSpec) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DEPLOY:
          serviceImpl.deploy((org.hyperledger.protos.Chaincode.ChaincodeSpec) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_INVOKE:
          serviceImpl.invoke((org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_QUERY:
          serviceImpl.query((org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_EXP_GET_APPLICATION_TCERT:
          serviceImpl.eXPGetApplicationTCert((org.hyperledger.protos.DevopsOuterClass.Secret) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_EXP_PREPARE_FOR_TX:
          serviceImpl.eXPPrepareForTx((org.hyperledger.protos.DevopsOuterClass.Secret) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_EXP_PRODUCE_SIGMA:
          serviceImpl.eXPProduceSigma((org.hyperledger.protos.DevopsOuterClass.SigmaInput) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_EXP_EXECUTE_WITH_BINDING:
          serviceImpl.eXPExecuteWithBinding((org.hyperledger.protos.DevopsOuterClass.ExecuteWithBinding) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver invoke(
        io.grpc.stub.StreamObserver responseObserver) {
      switch (methodId) {
        default:
          throw new AssertionError();
      }
    }
  }

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    return new io.grpc.ServiceDescriptor(SERVICE_NAME,
        METHOD_LOGIN,
        METHOD_BUILD,
        METHOD_DEPLOY,
        METHOD_INVOKE,
        METHOD_QUERY,
        METHOD_EXP_GET_APPLICATION_TCERT,
        METHOD_EXP_PREPARE_FOR_TX,
        METHOD_EXP_PRODUCE_SIGMA,
        METHOD_EXP_EXECUTE_WITH_BINDING);
  }

  @java.lang.Deprecated public static io.grpc.ServerServiceDefinition bindService(
      final Devops serviceImpl) {
    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
        .addMethod(
          METHOD_LOGIN,
          asyncUnaryCall(
            new MethodHandlers<
              org.hyperledger.protos.DevopsOuterClass.Secret,
              org.hyperledger.protos.Fabric.Response>(
                serviceImpl, METHODID_LOGIN)))
        .addMethod(
          METHOD_BUILD,
          asyncUnaryCall(
            new MethodHandlers<
              org.hyperledger.protos.Chaincode.ChaincodeSpec,
              org.hyperledger.protos.Chaincode.ChaincodeDeploymentSpec>(
                serviceImpl, METHODID_BUILD)))
        .addMethod(
          METHOD_DEPLOY,
          asyncUnaryCall(
            new MethodHandlers<
              org.hyperledger.protos.Chaincode.ChaincodeSpec,
              org.hyperledger.protos.Chaincode.ChaincodeDeploymentSpec>(
                serviceImpl, METHODID_DEPLOY)))
        .addMethod(
          METHOD_INVOKE,
          asyncUnaryCall(
            new MethodHandlers<
              org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec,
              org.hyperledger.protos.Fabric.Response>(
                serviceImpl, METHODID_INVOKE)))
        .addMethod(
          METHOD_QUERY,
          asyncUnaryCall(
            new MethodHandlers<
              org.hyperledger.protos.Chaincode.ChaincodeInvocationSpec,
              org.hyperledger.protos.Fabric.Response>(
                serviceImpl, METHODID_QUERY)))
        .addMethod(
          METHOD_EXP_GET_APPLICATION_TCERT,
          asyncUnaryCall(
            new MethodHandlers<
              org.hyperledger.protos.DevopsOuterClass.Secret,
              org.hyperledger.protos.Fabric.Response>(
                serviceImpl, METHODID_EXP_GET_APPLICATION_TCERT)))
        .addMethod(
          METHOD_EXP_PREPARE_FOR_TX,
          asyncUnaryCall(
            new MethodHandlers<
              org.hyperledger.protos.DevopsOuterClass.Secret,
              org.hyperledger.protos.Fabric.Response>(
                serviceImpl, METHODID_EXP_PREPARE_FOR_TX)))
        .addMethod(
          METHOD_EXP_PRODUCE_SIGMA,
          asyncUnaryCall(
            new MethodHandlers<
              org.hyperledger.protos.DevopsOuterClass.SigmaInput,
              org.hyperledger.protos.Fabric.Response>(
                serviceImpl, METHODID_EXP_PRODUCE_SIGMA)))
        .addMethod(
          METHOD_EXP_EXECUTE_WITH_BINDING,
          asyncUnaryCall(
            new MethodHandlers<
              org.hyperledger.protos.DevopsOuterClass.ExecuteWithBinding,
              org.hyperledger.protos.Fabric.Response>(
                serviceImpl, METHODID_EXP_EXECUTE_WITH_BINDING)))
        .build();
  }
}