• Home
• org.alluxio
• alluxio-shaded-client
• 307
• source code
• FileSystemMasterClientServiceGrpc.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.

alluxio.grpc.FileSystemMasterClientServiceGrpc Maven / Gradle / Ivy

package alluxio.grpc;

import static alluxio.shaded.client.io.grpc.MethodDescriptor.generateFullMethodName;

/**
 * 
 **
 * This interface contains file system master service endpoints for Alluxio clients.
 * 
 */
@alluxio.shaded.client.javax.annotation.Generated(
    value = "by gRPC proto alluxio.shaded.client.com.iler (version 1.54.1)",
    alluxio.shaded.client.com.ents = "Source: grpc/file_system_master.proto")
@alluxio.shaded.client.io.grpc.stub.annotations.GrpcGenerated
public final class FileSystemMasterClientServiceGrpc {

  private FileSystemMasterClientServiceGrpc() {}

  public static final String SERVICE_NAME = "alluxio.grpc.file.FileSystemMasterClientService";

  // Static method descriptors that strictly reflect the proto.
  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getCheckAccessMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "CheckAccess",
      requestType = alluxio.grpc.CheckAccessPRequest.class,
      responseType = alluxio.grpc.CheckAccessPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getCheckAccessMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getCheckAccessMethod;
    if ((getCheckAccessMethod = FileSystemMasterClientServiceGrpc.getCheckAccessMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getCheckAccessMethod = FileSystemMasterClientServiceGrpc.getCheckAccessMethod) == null) {
          FileSystemMasterClientServiceGrpc.getCheckAccessMethod = getCheckAccessMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CheckAccess"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.CheckAccessPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.CheckAccessPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("CheckAccess"))
              .build();
        }
      }
    }
    return getCheckAccessMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getCheckConsistencyMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "CheckConsistency",
      requestType = alluxio.grpc.CheckConsistencyPRequest.class,
      responseType = alluxio.grpc.CheckConsistencyPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getCheckConsistencyMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getCheckConsistencyMethod;
    if ((getCheckConsistencyMethod = FileSystemMasterClientServiceGrpc.getCheckConsistencyMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getCheckConsistencyMethod = FileSystemMasterClientServiceGrpc.getCheckConsistencyMethod) == null) {
          FileSystemMasterClientServiceGrpc.getCheckConsistencyMethod = getCheckConsistencyMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CheckConsistency"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.CheckConsistencyPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.CheckConsistencyPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("CheckConsistency"))
              .build();
        }
      }
    }
    return getCheckConsistencyMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getExistsMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Exists",
      requestType = alluxio.grpc.ExistsPRequest.class,
      responseType = alluxio.grpc.ExistsPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getExistsMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getExistsMethod;
    if ((getExistsMethod = FileSystemMasterClientServiceGrpc.getExistsMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getExistsMethod = FileSystemMasterClientServiceGrpc.getExistsMethod) == null) {
          FileSystemMasterClientServiceGrpc.getExistsMethod = getExistsMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Exists"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.ExistsPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.ExistsPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("Exists"))
              .build();
        }
      }
    }
    return getExistsMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getCompleteFileMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "CompleteFile",
      requestType = alluxio.grpc.CompleteFilePRequest.class,
      responseType = alluxio.grpc.CompleteFilePResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getCompleteFileMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getCompleteFileMethod;
    if ((getCompleteFileMethod = FileSystemMasterClientServiceGrpc.getCompleteFileMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getCompleteFileMethod = FileSystemMasterClientServiceGrpc.getCompleteFileMethod) == null) {
          FileSystemMasterClientServiceGrpc.getCompleteFileMethod = getCompleteFileMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CompleteFile"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.CompleteFilePRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.CompleteFilePResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("CompleteFile"))
              .build();
        }
      }
    }
    return getCompleteFileMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getCreateDirectoryMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "CreateDirectory",
      requestType = alluxio.grpc.CreateDirectoryPRequest.class,
      responseType = alluxio.grpc.CreateDirectoryPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getCreateDirectoryMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getCreateDirectoryMethod;
    if ((getCreateDirectoryMethod = FileSystemMasterClientServiceGrpc.getCreateDirectoryMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getCreateDirectoryMethod = FileSystemMasterClientServiceGrpc.getCreateDirectoryMethod) == null) {
          FileSystemMasterClientServiceGrpc.getCreateDirectoryMethod = getCreateDirectoryMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CreateDirectory"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.CreateDirectoryPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.CreateDirectoryPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("CreateDirectory"))
              .build();
        }
      }
    }
    return getCreateDirectoryMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getCreateFileMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "CreateFile",
      requestType = alluxio.grpc.CreateFilePRequest.class,
      responseType = alluxio.grpc.CreateFilePResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getCreateFileMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getCreateFileMethod;
    if ((getCreateFileMethod = FileSystemMasterClientServiceGrpc.getCreateFileMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getCreateFileMethod = FileSystemMasterClientServiceGrpc.getCreateFileMethod) == null) {
          FileSystemMasterClientServiceGrpc.getCreateFileMethod = getCreateFileMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CreateFile"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.CreateFilePRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.CreateFilePResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("CreateFile"))
              .build();
        }
      }
    }
    return getCreateFileMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getFreeMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Free",
      requestType = alluxio.grpc.FreePRequest.class,
      responseType = alluxio.grpc.FreePResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getFreeMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getFreeMethod;
    if ((getFreeMethod = FileSystemMasterClientServiceGrpc.getFreeMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getFreeMethod = FileSystemMasterClientServiceGrpc.getFreeMethod) == null) {
          FileSystemMasterClientServiceGrpc.getFreeMethod = getFreeMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Free"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.FreePRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.FreePResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("Free"))
              .build();
        }
      }
    }
    return getFreeMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getGetFilePathMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetFilePath",
      requestType = alluxio.grpc.GetFilePathPRequest.class,
      responseType = alluxio.grpc.GetFilePathPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getGetFilePathMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getGetFilePathMethod;
    if ((getGetFilePathMethod = FileSystemMasterClientServiceGrpc.getGetFilePathMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getGetFilePathMethod = FileSystemMasterClientServiceGrpc.getGetFilePathMethod) == null) {
          FileSystemMasterClientServiceGrpc.getGetFilePathMethod = getGetFilePathMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetFilePath"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.GetFilePathPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.GetFilePathPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("GetFilePath"))
              .build();
        }
      }
    }
    return getGetFilePathMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getGetMountTableMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetMountTable",
      requestType = alluxio.grpc.GetMountTablePRequest.class,
      responseType = alluxio.grpc.GetMountTablePResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getGetMountTableMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getGetMountTableMethod;
    if ((getGetMountTableMethod = FileSystemMasterClientServiceGrpc.getGetMountTableMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getGetMountTableMethod = FileSystemMasterClientServiceGrpc.getGetMountTableMethod) == null) {
          FileSystemMasterClientServiceGrpc.getGetMountTableMethod = getGetMountTableMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetMountTable"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.GetMountTablePRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.GetMountTablePResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("GetMountTable"))
              .build();
        }
      }
    }
    return getGetMountTableMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getGetNewBlockIdForFileMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetNewBlockIdForFile",
      requestType = alluxio.grpc.GetNewBlockIdForFilePRequest.class,
      responseType = alluxio.grpc.GetNewBlockIdForFilePResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getGetNewBlockIdForFileMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getGetNewBlockIdForFileMethod;
    if ((getGetNewBlockIdForFileMethod = FileSystemMasterClientServiceGrpc.getGetNewBlockIdForFileMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getGetNewBlockIdForFileMethod = FileSystemMasterClientServiceGrpc.getGetNewBlockIdForFileMethod) == null) {
          FileSystemMasterClientServiceGrpc.getGetNewBlockIdForFileMethod = getGetNewBlockIdForFileMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetNewBlockIdForFile"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.GetNewBlockIdForFilePRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.GetNewBlockIdForFilePResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("GetNewBlockIdForFile"))
              .build();
        }
      }
    }
    return getGetNewBlockIdForFileMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getGetStatusMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetStatus",
      requestType = alluxio.grpc.GetStatusPRequest.class,
      responseType = alluxio.grpc.GetStatusPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getGetStatusMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getGetStatusMethod;
    if ((getGetStatusMethod = FileSystemMasterClientServiceGrpc.getGetStatusMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getGetStatusMethod = FileSystemMasterClientServiceGrpc.getGetStatusMethod) == null) {
          FileSystemMasterClientServiceGrpc.getGetStatusMethod = getGetStatusMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetStatus"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.GetStatusPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.GetStatusPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("GetStatus"))
              .build();
        }
      }
    }
    return getGetStatusMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getListStatusMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListStatus",
      requestType = alluxio.grpc.ListStatusPRequest.class,
      responseType = alluxio.grpc.ListStatusPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getListStatusMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getListStatusMethod;
    if ((getListStatusMethod = FileSystemMasterClientServiceGrpc.getListStatusMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getListStatusMethod = FileSystemMasterClientServiceGrpc.getListStatusMethod) == null) {
          FileSystemMasterClientServiceGrpc.getListStatusMethod = getListStatusMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListStatus"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.ListStatusPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.ListStatusPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("ListStatus"))
              .build();
        }
      }
    }
    return getListStatusMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getListStatusPartialMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListStatusPartial",
      requestType = alluxio.grpc.ListStatusPartialPRequest.class,
      responseType = alluxio.grpc.ListStatusPartialPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getListStatusPartialMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getListStatusPartialMethod;
    if ((getListStatusPartialMethod = FileSystemMasterClientServiceGrpc.getListStatusPartialMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getListStatusPartialMethod = FileSystemMasterClientServiceGrpc.getListStatusPartialMethod) == null) {
          FileSystemMasterClientServiceGrpc.getListStatusPartialMethod = getListStatusPartialMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListStatusPartial"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.ListStatusPartialPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.ListStatusPartialPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("ListStatusPartial"))
              .build();
        }
      }
    }
    return getListStatusPartialMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getMountMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Mount",
      requestType = alluxio.grpc.MountPRequest.class,
      responseType = alluxio.grpc.MountPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getMountMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getMountMethod;
    if ((getMountMethod = FileSystemMasterClientServiceGrpc.getMountMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getMountMethod = FileSystemMasterClientServiceGrpc.getMountMethod) == null) {
          FileSystemMasterClientServiceGrpc.getMountMethod = getMountMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Mount"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.MountPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.MountPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("Mount"))
              .build();
        }
      }
    }
    return getMountMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getRemoveMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Remove",
      requestType = alluxio.grpc.DeletePRequest.class,
      responseType = alluxio.grpc.DeletePResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getRemoveMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getRemoveMethod;
    if ((getRemoveMethod = FileSystemMasterClientServiceGrpc.getRemoveMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getRemoveMethod = FileSystemMasterClientServiceGrpc.getRemoveMethod) == null) {
          FileSystemMasterClientServiceGrpc.getRemoveMethod = getRemoveMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Remove"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.DeletePRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.DeletePResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("Remove"))
              .build();
        }
      }
    }
    return getRemoveMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getRenameMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Rename",
      requestType = alluxio.grpc.RenamePRequest.class,
      responseType = alluxio.grpc.RenamePResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getRenameMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getRenameMethod;
    if ((getRenameMethod = FileSystemMasterClientServiceGrpc.getRenameMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getRenameMethod = FileSystemMasterClientServiceGrpc.getRenameMethod) == null) {
          FileSystemMasterClientServiceGrpc.getRenameMethod = getRenameMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Rename"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.RenamePRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.RenamePResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("Rename"))
              .build();
        }
      }
    }
    return getRenameMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getReverseResolveMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ReverseResolve",
      requestType = alluxio.grpc.ReverseResolvePRequest.class,
      responseType = alluxio.grpc.ReverseResolvePResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getReverseResolveMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getReverseResolveMethod;
    if ((getReverseResolveMethod = FileSystemMasterClientServiceGrpc.getReverseResolveMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getReverseResolveMethod = FileSystemMasterClientServiceGrpc.getReverseResolveMethod) == null) {
          FileSystemMasterClientServiceGrpc.getReverseResolveMethod = getReverseResolveMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ReverseResolve"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.ReverseResolvePRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.ReverseResolvePResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("ReverseResolve"))
              .build();
        }
      }
    }
    return getReverseResolveMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getGetMountIdMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetMountId",
      requestType = alluxio.grpc.GetMountIdPRequest.class,
      responseType = alluxio.grpc.GetMountIdPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getGetMountIdMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getGetMountIdMethod;
    if ((getGetMountIdMethod = FileSystemMasterClientServiceGrpc.getGetMountIdMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getGetMountIdMethod = FileSystemMasterClientServiceGrpc.getGetMountIdMethod) == null) {
          FileSystemMasterClientServiceGrpc.getGetMountIdMethod = getGetMountIdMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetMountId"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.GetMountIdPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.GetMountIdPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("GetMountId"))
              .build();
        }
      }
    }
    return getGetMountIdMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getScheduleAsyncPersistenceMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ScheduleAsyncPersistence",
      requestType = alluxio.grpc.ScheduleAsyncPersistencePRequest.class,
      responseType = alluxio.grpc.ScheduleAsyncPersistencePResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getScheduleAsyncPersistenceMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getScheduleAsyncPersistenceMethod;
    if ((getScheduleAsyncPersistenceMethod = FileSystemMasterClientServiceGrpc.getScheduleAsyncPersistenceMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getScheduleAsyncPersistenceMethod = FileSystemMasterClientServiceGrpc.getScheduleAsyncPersistenceMethod) == null) {
          FileSystemMasterClientServiceGrpc.getScheduleAsyncPersistenceMethod = getScheduleAsyncPersistenceMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ScheduleAsyncPersistence"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.ScheduleAsyncPersistencePRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.ScheduleAsyncPersistencePResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("ScheduleAsyncPersistence"))
              .build();
        }
      }
    }
    return getScheduleAsyncPersistenceMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getSetAclMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SetAcl",
      requestType = alluxio.grpc.SetAclPRequest.class,
      responseType = alluxio.grpc.SetAclPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getSetAclMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getSetAclMethod;
    if ((getSetAclMethod = FileSystemMasterClientServiceGrpc.getSetAclMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getSetAclMethod = FileSystemMasterClientServiceGrpc.getSetAclMethod) == null) {
          FileSystemMasterClientServiceGrpc.getSetAclMethod = getSetAclMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetAcl"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.SetAclPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.SetAclPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("SetAcl"))
              .build();
        }
      }
    }
    return getSetAclMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getSetAttributeMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SetAttribute",
      requestType = alluxio.grpc.SetAttributePRequest.class,
      responseType = alluxio.grpc.SetAttributePResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getSetAttributeMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getSetAttributeMethod;
    if ((getSetAttributeMethod = FileSystemMasterClientServiceGrpc.getSetAttributeMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getSetAttributeMethod = FileSystemMasterClientServiceGrpc.getSetAttributeMethod) == null) {
          FileSystemMasterClientServiceGrpc.getSetAttributeMethod = getSetAttributeMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetAttribute"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.SetAttributePRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.SetAttributePResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("SetAttribute"))
              .build();
        }
      }
    }
    return getSetAttributeMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getUnmountMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Unmount",
      requestType = alluxio.grpc.UnmountPRequest.class,
      responseType = alluxio.grpc.UnmountPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getUnmountMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getUnmountMethod;
    if ((getUnmountMethod = FileSystemMasterClientServiceGrpc.getUnmountMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getUnmountMethod = FileSystemMasterClientServiceGrpc.getUnmountMethod) == null) {
          FileSystemMasterClientServiceGrpc.getUnmountMethod = getUnmountMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Unmount"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.UnmountPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.UnmountPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("Unmount"))
              .build();
        }
      }
    }
    return getUnmountMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getUpdateMountMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "UpdateMount",
      requestType = alluxio.grpc.UpdateMountPRequest.class,
      responseType = alluxio.grpc.UpdateMountPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getUpdateMountMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getUpdateMountMethod;
    if ((getUpdateMountMethod = FileSystemMasterClientServiceGrpc.getUpdateMountMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getUpdateMountMethod = FileSystemMasterClientServiceGrpc.getUpdateMountMethod) == null) {
          FileSystemMasterClientServiceGrpc.getUpdateMountMethod = getUpdateMountMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UpdateMount"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.UpdateMountPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.UpdateMountPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("UpdateMount"))
              .build();
        }
      }
    }
    return getUpdateMountMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getUpdateUfsModeMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "UpdateUfsMode",
      requestType = alluxio.grpc.UpdateUfsModePRequest.class,
      responseType = alluxio.grpc.UpdateUfsModePResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getUpdateUfsModeMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getUpdateUfsModeMethod;
    if ((getUpdateUfsModeMethod = FileSystemMasterClientServiceGrpc.getUpdateUfsModeMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getUpdateUfsModeMethod = FileSystemMasterClientServiceGrpc.getUpdateUfsModeMethod) == null) {
          FileSystemMasterClientServiceGrpc.getUpdateUfsModeMethod = getUpdateUfsModeMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UpdateUfsMode"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.UpdateUfsModePRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.UpdateUfsModePResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("UpdateUfsMode"))
              .build();
        }
      }
    }
    return getUpdateUfsModeMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getGetStateLockHoldersMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetStateLockHolders",
      requestType = alluxio.grpc.GetStateLockHoldersPRequest.class,
      responseType = alluxio.grpc.GetStateLockHoldersPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getGetStateLockHoldersMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getGetStateLockHoldersMethod;
    if ((getGetStateLockHoldersMethod = FileSystemMasterClientServiceGrpc.getGetStateLockHoldersMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getGetStateLockHoldersMethod = FileSystemMasterClientServiceGrpc.getGetStateLockHoldersMethod) == null) {
          FileSystemMasterClientServiceGrpc.getGetStateLockHoldersMethod = getGetStateLockHoldersMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetStateLockHolders"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.GetStateLockHoldersPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.GetStateLockHoldersPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("GetStateLockHolders"))
              .build();
        }
      }
    }
    return getGetStateLockHoldersMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getNeedsSyncMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "NeedsSync",
      requestType = alluxio.grpc.NeedsSyncRequest.class,
      responseType = alluxio.grpc.NeedsSyncResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getNeedsSyncMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getNeedsSyncMethod;
    if ((getNeedsSyncMethod = FileSystemMasterClientServiceGrpc.getNeedsSyncMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getNeedsSyncMethod = FileSystemMasterClientServiceGrpc.getNeedsSyncMethod) == null) {
          FileSystemMasterClientServiceGrpc.getNeedsSyncMethod = getNeedsSyncMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "NeedsSync"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.NeedsSyncRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.NeedsSyncResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("NeedsSync"))
              .build();
        }
      }
    }
    return getNeedsSyncMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getSubmitJobMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "submitJob",
      requestType = alluxio.grpc.SubmitJobPRequest.class,
      responseType = alluxio.grpc.SubmitJobPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getSubmitJobMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getSubmitJobMethod;
    if ((getSubmitJobMethod = FileSystemMasterClientServiceGrpc.getSubmitJobMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getSubmitJobMethod = FileSystemMasterClientServiceGrpc.getSubmitJobMethod) == null) {
          FileSystemMasterClientServiceGrpc.getSubmitJobMethod = getSubmitJobMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "submitJob"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.SubmitJobPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.SubmitJobPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("submitJob"))
              .build();
        }
      }
    }
    return getSubmitJobMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getStopJobMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "StopJob",
      requestType = alluxio.grpc.StopJobPRequest.class,
      responseType = alluxio.grpc.StopJobPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getStopJobMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getStopJobMethod;
    if ((getStopJobMethod = FileSystemMasterClientServiceGrpc.getStopJobMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getStopJobMethod = FileSystemMasterClientServiceGrpc.getStopJobMethod) == null) {
          FileSystemMasterClientServiceGrpc.getStopJobMethod = getStopJobMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StopJob"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.StopJobPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.StopJobPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("StopJob"))
              .build();
        }
      }
    }
    return getStopJobMethod;
  }

  private static volatile alluxio.shaded.client.io.grpc.MethodDescriptor getGetJobProgressMethod;

  @alluxio.shaded.client.io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetJobProgress",
      requestType = alluxio.grpc.GetJobProgressPRequest.class,
      responseType = alluxio.grpc.GetJobProgressPResponse.class,
      methodType = alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
  public static alluxio.shaded.client.io.grpc.MethodDescriptor getGetJobProgressMethod() {
    alluxio.shaded.client.io.grpc.MethodDescriptor getGetJobProgressMethod;
    if ((getGetJobProgressMethod = FileSystemMasterClientServiceGrpc.getGetJobProgressMethod) == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        if ((getGetJobProgressMethod = FileSystemMasterClientServiceGrpc.getGetJobProgressMethod) == null) {
          FileSystemMasterClientServiceGrpc.getGetJobProgressMethod = getGetJobProgressMethod =
              alluxio.shaded.client.io.grpc.MethodDescriptor.newBuilder()
              .setType(alluxio.shaded.client.io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetJobProgress"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.GetJobProgressPRequest.getDefaultInstance()))
              .setResponseMarshaller(alluxio.shaded.client.io.grpc.protobuf.ProtoUtils.marshaller(
                  alluxio.grpc.GetJobProgressPResponse.getDefaultInstance()))
              .setSchemaDescriptor(new FileSystemMasterClientServiceMethodDescriptorSupplier("GetJobProgress"))
              .build();
        }
      }
    }
    return getGetJobProgressMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static FileSystemMasterClientServiceStub newStub(alluxio.shaded.client.io.grpc.Channel channel) {
    alluxio.shaded.client.io.grpc.stub.AbstractStub.StubFactory factory =
      new alluxio.shaded.client.io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
        public FileSystemMasterClientServiceStub newStub(alluxio.shaded.client.io.grpc.Channel channel, alluxio.shaded.client.io.grpc.CallOptions callOptions) {
          return new FileSystemMasterClientServiceStub(channel, callOptions);
        }
      };
    return FileSystemMasterClientServiceStub.newStub(factory, channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static FileSystemMasterClientServiceBlockingStub newBlockingStub(
      alluxio.shaded.client.io.grpc.Channel channel) {
    alluxio.shaded.client.io.grpc.stub.AbstractStub.StubFactory factory =
      new alluxio.shaded.client.io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
        public FileSystemMasterClientServiceBlockingStub newStub(alluxio.shaded.client.io.grpc.Channel channel, alluxio.shaded.client.io.grpc.CallOptions callOptions) {
          return new FileSystemMasterClientServiceBlockingStub(channel, callOptions);
        }
      };
    return FileSystemMasterClientServiceBlockingStub.newStub(factory, channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static FileSystemMasterClientServiceFutureStub newFutureStub(
      alluxio.shaded.client.io.grpc.Channel channel) {
    alluxio.shaded.client.io.grpc.stub.AbstractStub.StubFactory factory =
      new alluxio.shaded.client.io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
        public FileSystemMasterClientServiceFutureStub newStub(alluxio.shaded.client.io.grpc.Channel channel, alluxio.shaded.client.io.grpc.CallOptions callOptions) {
          return new FileSystemMasterClientServiceFutureStub(channel, callOptions);
        }
      };
    return FileSystemMasterClientServiceFutureStub.newStub(factory, channel);
  }

  /**
   * 
   **
   * This interface contains file system master service endpoints for Alluxio clients.
   * 
   */
  public interface AsyncService {

    /**
     * 
     **
     * Checks access to path.
     * 
     */
    default void checkAccess(alluxio.grpc.CheckAccessPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCheckAccessMethod(), responseObserver);
    }

    /**
     * 
     **
     * Checks the consistency of the files and directores with the path as the root of the subtree
     * 
     */
    default void checkConsistency(alluxio.grpc.CheckConsistencyPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCheckConsistencyMethod(), responseObserver);
    }

    /**
     * 
     **
     * Checks the existence of the file or directory.
     * 
     */
    default void exists(alluxio.grpc.ExistsPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getExistsMethod(), responseObserver);
    }

    /**
     * 
     **
     * Marks a file as alluxio.shaded.client.com.leted.
     * 
     */
    default void alluxio.shaded.client.com.leteFile(alluxio.grpc.CompleteFilePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCompleteFileMethod(), responseObserver);
    }

    /**
     * 
     **
     * Creates a directory.
     * 
     */
    default void createDirectory(alluxio.grpc.CreateDirectoryPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCreateDirectoryMethod(), responseObserver);
    }

    /**
     * 
     **
     * Creates a file.
     * 
     */
    default void createFile(alluxio.grpc.CreateFilePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCreateFileMethod(), responseObserver);
    }

    /**
     * 
     **
     * Frees the given file or directory from Alluxio.
     * 
     */
    default void free(alluxio.grpc.FreePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getFreeMethod(), responseObserver);
    }

    /**
     * 
     **
     * Returns the file path of a file id
     * 
     */
    default void getFilePath(alluxio.grpc.GetFilePathPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetFilePathMethod(), responseObserver);
    }

    /**
     * 
     **
     * Returns a map from each Alluxio path to information of corresponding mount point
     * 
     */
    default void getMountTable(alluxio.grpc.GetMountTablePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetMountTableMethod(), responseObserver);
    }

    /**
     * 
     **
     * Generates a new block id for the given file.
     * 
     */
    default void getNewBlockIdForFile(alluxio.grpc.GetNewBlockIdForFilePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetNewBlockIdForFileMethod(), responseObserver);
    }

    /**
     * 
     **
     * Returns the status of the file or directory.
     * 
     */
    default void getStatus(alluxio.grpc.GetStatusPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetStatusMethod(), responseObserver);
    }

    /**
     * 
     **
     * If the path points to a file, the method returns a singleton with its file information.
     * If the path points to a directory, the method returns a list with file information for the
     * directory contents.
     * 
     */
    default void listStatus(alluxio.grpc.ListStatusPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListStatusMethod(), responseObserver);
    }

    /**
     * 
     **
     * If the path points to a file, the method returns a singleton with its file information.
     * If the path points to a directory, the method returns a list with file information for the
     * directory contents. This operation takes additional options for partial listing of files.
     * 
     */
    default void listStatusPartial(alluxio.grpc.ListStatusPartialPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListStatusPartialMethod(), responseObserver);
    }

    /**
     * 
     **
     * Creates a new "mount point", mounts the given UFS path in the Alluxio namespace at the given
     * path. The path should not exist and should not be nested under any existing mount point.
     * 
     */
    default void mount(alluxio.grpc.MountPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getMountMethod(), responseObserver);
    }

    /**
     * 
     **
     * Deletes a file or a directory and returns whether the remove operation succeeded.
     * 
     */
    default void remove(alluxio.grpc.DeletePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRemoveMethod(), responseObserver);
    }

    /**
     * 
     **
     * Renames a file or a directory.
     * 
     */
    default void rename(alluxio.grpc.RenamePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRenameMethod(), responseObserver);
    }

    /**
     * 
     **
     * Reverse resolve a ufs path.
     * 
     */
    default void reverseResolve(alluxio.grpc.ReverseResolvePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getReverseResolveMethod(), responseObserver);
    }

    /**
     * 
     **
     * Reverse resolve a ufs path and get mount id.
     * 
     */
    default void getMountId(alluxio.grpc.GetMountIdPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetMountIdMethod(), responseObserver);
    }

    /**
     * 
     **
     * Schedules async persistence.
     * 
     */
    default void scheduleAsyncPersistence(alluxio.grpc.ScheduleAsyncPersistencePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getScheduleAsyncPersistenceMethod(), responseObserver);
    }

    /**
     * 
     **
     * Sets ACL for the path.
     * 
     */
    default void setAcl(alluxio.grpc.SetAclPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetAclMethod(), responseObserver);
    }

    /**
     * 
     **
     * Sets file or directory attributes.
     * 
     */
    default void setAttribute(alluxio.grpc.SetAttributePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetAttributeMethod(), responseObserver);
    }

    /**
     * 
     **
     * Deletes an existing "mount point", voiding the Alluxio namespace at the given path. The path
     * should correspond to an existing mount point. Any files in its subtree that are backed by UFS
     * will be persisted before they are removed from the Alluxio namespace.
     * 
     */
    default void unmount(alluxio.grpc.UnmountPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnmountMethod(), responseObserver);
    }

    /**
     * 
     **
     * Updates an existing "mount point", changing its mount properties
     * 
     */
    default void updateMount(alluxio.grpc.UpdateMountPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUpdateMountMethod(), responseObserver);
    }

    /**
     * 
     **
     * Updates the ufs mode for a ufs path under one or more mount points.
     * 
     */
    default void updateUfsMode(alluxio.grpc.UpdateUfsModePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUpdateUfsModeMethod(), responseObserver);
    }

    /**
     */
    default void getStateLockHolders(alluxio.grpc.GetStateLockHoldersPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetStateLockHoldersMethod(), responseObserver);
    }

    /**
     */
    default void needsSync(alluxio.grpc.NeedsSyncRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getNeedsSyncMethod(), responseObserver);
    }

    /**
     * 
     **
     * Load a directory into Alluxio.
     * 
     */
    default void submitJob(alluxio.grpc.SubmitJobPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSubmitJobMethod(), responseObserver);
    }

    /**
     */
    default void stopJob(alluxio.grpc.StopJobPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStopJobMethod(), responseObserver);
    }

    /**
     */
    default void getJobProgress(alluxio.grpc.GetJobProgressPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetJobProgressMethod(), responseObserver);
    }
  }

  /**
   * Base class for the server implementation of the service FileSystemMasterClientService.
   * 
   **
   * This interface contains file system master service endpoints for Alluxio clients.
   * 
   */
  public static abstract class FileSystemMasterClientServiceImplBase
      implements alluxio.shaded.client.io.grpc.BindableService, AsyncService {

    @java.lang.Override public final alluxio.shaded.client.io.grpc.ServerServiceDefinition bindService() {
      return FileSystemMasterClientServiceGrpc.bindService(this);
    }
  }

  /**
   * A stub to allow clients to do asynchronous rpc calls to service FileSystemMasterClientService.
   * 
   **
   * This interface contains file system master service endpoints for Alluxio clients.
   * 
   */
  public static final class FileSystemMasterClientServiceStub
      extends alluxio.shaded.client.io.grpc.stub.AbstractAsyncStub {
    private FileSystemMasterClientServiceStub(
        alluxio.shaded.client.io.grpc.Channel channel, alluxio.shaded.client.io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     * 
     **
     * Checks access to path.
     * 
     */
    public void checkAccess(alluxio.grpc.CheckAccessPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getCheckAccessMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Checks the consistency of the files and directores with the path as the root of the subtree
     * 
     */
    public void checkConsistency(alluxio.grpc.CheckConsistencyPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getCheckConsistencyMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Checks the existence of the file or directory.
     * 
     */
    public void exists(alluxio.grpc.ExistsPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getExistsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Marks a file as alluxio.shaded.client.com.leted.
     * 
     */
    public void alluxio.shaded.client.com.leteFile(alluxio.grpc.CompleteFilePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getCompleteFileMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Creates a directory.
     * 
     */
    public void createDirectory(alluxio.grpc.CreateDirectoryPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getCreateDirectoryMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Creates a file.
     * 
     */
    public void createFile(alluxio.grpc.CreateFilePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getCreateFileMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Frees the given file or directory from Alluxio.
     * 
     */
    public void free(alluxio.grpc.FreePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getFreeMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Returns the file path of a file id
     * 
     */
    public void getFilePath(alluxio.grpc.GetFilePathPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetFilePathMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Returns a map from each Alluxio path to information of corresponding mount point
     * 
     */
    public void getMountTable(alluxio.grpc.GetMountTablePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetMountTableMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Generates a new block id for the given file.
     * 
     */
    public void getNewBlockIdForFile(alluxio.grpc.GetNewBlockIdForFilePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetNewBlockIdForFileMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Returns the status of the file or directory.
     * 
     */
    public void getStatus(alluxio.grpc.GetStatusPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetStatusMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * If the path points to a file, the method returns a singleton with its file information.
     * If the path points to a directory, the method returns a list with file information for the
     * directory contents.
     * 
     */
    public void listStatus(alluxio.grpc.ListStatusPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncServerStreamingCall(
          getChannel().newCall(getListStatusMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * If the path points to a file, the method returns a singleton with its file information.
     * If the path points to a directory, the method returns a list with file information for the
     * directory contents. This operation takes additional options for partial listing of files.
     * 
     */
    public void listStatusPartial(alluxio.grpc.ListStatusPartialPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListStatusPartialMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Creates a new "mount point", mounts the given UFS path in the Alluxio namespace at the given
     * path. The path should not exist and should not be nested under any existing mount point.
     * 
     */
    public void mount(alluxio.grpc.MountPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getMountMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Deletes a file or a directory and returns whether the remove operation succeeded.
     * 
     */
    public void remove(alluxio.grpc.DeletePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRemoveMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Renames a file or a directory.
     * 
     */
    public void rename(alluxio.grpc.RenamePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRenameMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Reverse resolve a ufs path.
     * 
     */
    public void reverseResolve(alluxio.grpc.ReverseResolvePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getReverseResolveMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Reverse resolve a ufs path and get mount id.
     * 
     */
    public void getMountId(alluxio.grpc.GetMountIdPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetMountIdMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Schedules async persistence.
     * 
     */
    public void scheduleAsyncPersistence(alluxio.grpc.ScheduleAsyncPersistencePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getScheduleAsyncPersistenceMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Sets ACL for the path.
     * 
     */
    public void setAcl(alluxio.grpc.SetAclPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetAclMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Sets file or directory attributes.
     * 
     */
    public void setAttribute(alluxio.grpc.SetAttributePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetAttributeMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Deletes an existing "mount point", voiding the Alluxio namespace at the given path. The path
     * should correspond to an existing mount point. Any files in its subtree that are backed by UFS
     * will be persisted before they are removed from the Alluxio namespace.
     * 
     */
    public void unmount(alluxio.grpc.UnmountPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUnmountMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Updates an existing "mount point", changing its mount properties
     * 
     */
    public void updateMount(alluxio.grpc.UpdateMountPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUpdateMountMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Updates the ufs mode for a ufs path under one or more mount points.
     * 
     */
    public void updateUfsMode(alluxio.grpc.UpdateUfsModePRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUpdateUfsModeMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getStateLockHolders(alluxio.grpc.GetStateLockHoldersPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetStateLockHoldersMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void needsSync(alluxio.grpc.NeedsSyncRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getNeedsSyncMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     **
     * Load a directory into Alluxio.
     * 
     */
    public void submitJob(alluxio.grpc.SubmitJobPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSubmitJobMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void stopJob(alluxio.grpc.StopJobPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getStopJobMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getJobProgress(alluxio.grpc.GetJobProgressPRequest request,
        alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      alluxio.shaded.client.io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetJobProgressMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   * A stub to allow clients to do synchronous rpc calls to service FileSystemMasterClientService.
   * 
   **
   * This interface contains file system master service endpoints for Alluxio clients.
   * 
   */
  public static final class FileSystemMasterClientServiceBlockingStub
      extends alluxio.shaded.client.io.grpc.stub.AbstractBlockingStub {
    private FileSystemMasterClientServiceBlockingStub(
        alluxio.shaded.client.io.grpc.Channel channel, alluxio.shaded.client.io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     * 
     **
     * Checks access to path.
     * 
     */
    public alluxio.grpc.CheckAccessPResponse checkAccess(alluxio.grpc.CheckAccessPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getCheckAccessMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Checks the consistency of the files and directores with the path as the root of the subtree
     * 
     */
    public alluxio.grpc.CheckConsistencyPResponse checkConsistency(alluxio.grpc.CheckConsistencyPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getCheckConsistencyMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Checks the existence of the file or directory.
     * 
     */
    public alluxio.grpc.ExistsPResponse exists(alluxio.grpc.ExistsPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getExistsMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Marks a file as alluxio.shaded.client.com.leted.
     * 
     */
    public alluxio.grpc.CompleteFilePResponse alluxio.shaded.client.com.leteFile(alluxio.grpc.CompleteFilePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getCompleteFileMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Creates a directory.
     * 
     */
    public alluxio.grpc.CreateDirectoryPResponse createDirectory(alluxio.grpc.CreateDirectoryPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getCreateDirectoryMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Creates a file.
     * 
     */
    public alluxio.grpc.CreateFilePResponse createFile(alluxio.grpc.CreateFilePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getCreateFileMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Frees the given file or directory from Alluxio.
     * 
     */
    public alluxio.grpc.FreePResponse free(alluxio.grpc.FreePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getFreeMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Returns the file path of a file id
     * 
     */
    public alluxio.grpc.GetFilePathPResponse getFilePath(alluxio.grpc.GetFilePathPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetFilePathMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Returns a map from each Alluxio path to information of corresponding mount point
     * 
     */
    public alluxio.grpc.GetMountTablePResponse getMountTable(alluxio.grpc.GetMountTablePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetMountTableMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Generates a new block id for the given file.
     * 
     */
    public alluxio.grpc.GetNewBlockIdForFilePResponse getNewBlockIdForFile(alluxio.grpc.GetNewBlockIdForFilePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetNewBlockIdForFileMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Returns the status of the file or directory.
     * 
     */
    public alluxio.grpc.GetStatusPResponse getStatus(alluxio.grpc.GetStatusPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetStatusMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * If the path points to a file, the method returns a singleton with its file information.
     * If the path points to a directory, the method returns a list with file information for the
     * directory contents.
     * 
     */
    public java.util.Iterator listStatus(
        alluxio.grpc.ListStatusPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingServerStreamingCall(
          getChannel(), getListStatusMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * If the path points to a file, the method returns a singleton with its file information.
     * If the path points to a directory, the method returns a list with file information for the
     * directory contents. This operation takes additional options for partial listing of files.
     * 
     */
    public alluxio.grpc.ListStatusPartialPResponse listStatusPartial(alluxio.grpc.ListStatusPartialPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListStatusPartialMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Creates a new "mount point", mounts the given UFS path in the Alluxio namespace at the given
     * path. The path should not exist and should not be nested under any existing mount point.
     * 
     */
    public alluxio.grpc.MountPResponse mount(alluxio.grpc.MountPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getMountMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Deletes a file or a directory and returns whether the remove operation succeeded.
     * 
     */
    public alluxio.grpc.DeletePResponse remove(alluxio.grpc.DeletePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRemoveMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Renames a file or a directory.
     * 
     */
    public alluxio.grpc.RenamePResponse rename(alluxio.grpc.RenamePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRenameMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Reverse resolve a ufs path.
     * 
     */
    public alluxio.grpc.ReverseResolvePResponse reverseResolve(alluxio.grpc.ReverseResolvePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getReverseResolveMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Reverse resolve a ufs path and get mount id.
     * 
     */
    public alluxio.grpc.GetMountIdPResponse getMountId(alluxio.grpc.GetMountIdPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetMountIdMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Schedules async persistence.
     * 
     */
    public alluxio.grpc.ScheduleAsyncPersistencePResponse scheduleAsyncPersistence(alluxio.grpc.ScheduleAsyncPersistencePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getScheduleAsyncPersistenceMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Sets ACL for the path.
     * 
     */
    public alluxio.grpc.SetAclPResponse setAcl(alluxio.grpc.SetAclPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetAclMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Sets file or directory attributes.
     * 
     */
    public alluxio.grpc.SetAttributePResponse setAttribute(alluxio.grpc.SetAttributePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetAttributeMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Deletes an existing "mount point", voiding the Alluxio namespace at the given path. The path
     * should correspond to an existing mount point. Any files in its subtree that are backed by UFS
     * will be persisted before they are removed from the Alluxio namespace.
     * 
     */
    public alluxio.grpc.UnmountPResponse unmount(alluxio.grpc.UnmountPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUnmountMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Updates an existing "mount point", changing its mount properties
     * 
     */
    public alluxio.grpc.UpdateMountPResponse updateMount(alluxio.grpc.UpdateMountPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUpdateMountMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Updates the ufs mode for a ufs path under one or more mount points.
     * 
     */
    public alluxio.grpc.UpdateUfsModePResponse updateUfsMode(alluxio.grpc.UpdateUfsModePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUpdateUfsModeMethod(), getCallOptions(), request);
    }

    /**
     */
    public alluxio.grpc.GetStateLockHoldersPResponse getStateLockHolders(alluxio.grpc.GetStateLockHoldersPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetStateLockHoldersMethod(), getCallOptions(), request);
    }

    /**
     */
    public alluxio.grpc.NeedsSyncResponse needsSync(alluxio.grpc.NeedsSyncRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getNeedsSyncMethod(), getCallOptions(), request);
    }

    /**
     * 
     **
     * Load a directory into Alluxio.
     * 
     */
    public alluxio.grpc.SubmitJobPResponse submitJob(alluxio.grpc.SubmitJobPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSubmitJobMethod(), getCallOptions(), request);
    }

    /**
     */
    public alluxio.grpc.StopJobPResponse stopJob(alluxio.grpc.StopJobPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getStopJobMethod(), getCallOptions(), request);
    }

    /**
     */
    public alluxio.grpc.GetJobProgressPResponse getJobProgress(alluxio.grpc.GetJobProgressPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetJobProgressMethod(), getCallOptions(), request);
    }
  }

  /**
   * A stub to allow clients to do ListenableFuture-style rpc calls to service FileSystemMasterClientService.
   * 
   **
   * This interface contains file system master service endpoints for Alluxio clients.
   * 
   */
  public static final class FileSystemMasterClientServiceFutureStub
      extends alluxio.shaded.client.io.grpc.stub.AbstractFutureStub {
    private FileSystemMasterClientServiceFutureStub(
        alluxio.shaded.client.io.grpc.Channel channel, alluxio.shaded.client.io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     * 
     **
     * Checks access to path.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture checkAccess(
        alluxio.grpc.CheckAccessPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getCheckAccessMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Checks the consistency of the files and directores with the path as the root of the subtree
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture checkConsistency(
        alluxio.grpc.CheckConsistencyPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getCheckConsistencyMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Checks the existence of the file or directory.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture exists(
        alluxio.grpc.ExistsPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getExistsMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Marks a file as alluxio.shaded.client.com.leted.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture alluxio.shaded.client.com.leteFile(
        alluxio.grpc.CompleteFilePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getCompleteFileMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Creates a directory.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture createDirectory(
        alluxio.grpc.CreateDirectoryPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getCreateDirectoryMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Creates a file.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture createFile(
        alluxio.grpc.CreateFilePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getCreateFileMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Frees the given file or directory from Alluxio.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture free(
        alluxio.grpc.FreePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getFreeMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Returns the file path of a file id
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture getFilePath(
        alluxio.grpc.GetFilePathPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetFilePathMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Returns a map from each Alluxio path to information of corresponding mount point
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture getMountTable(
        alluxio.grpc.GetMountTablePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetMountTableMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Generates a new block id for the given file.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture getNewBlockIdForFile(
        alluxio.grpc.GetNewBlockIdForFilePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetNewBlockIdForFileMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Returns the status of the file or directory.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture getStatus(
        alluxio.grpc.GetStatusPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetStatusMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * If the path points to a file, the method returns a singleton with its file information.
     * If the path points to a directory, the method returns a list with file information for the
     * directory contents. This operation takes additional options for partial listing of files.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture listStatusPartial(
        alluxio.grpc.ListStatusPartialPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListStatusPartialMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Creates a new "mount point", mounts the given UFS path in the Alluxio namespace at the given
     * path. The path should not exist and should not be nested under any existing mount point.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture mount(
        alluxio.grpc.MountPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getMountMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Deletes a file or a directory and returns whether the remove operation succeeded.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture remove(
        alluxio.grpc.DeletePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRemoveMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Renames a file or a directory.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture rename(
        alluxio.grpc.RenamePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRenameMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Reverse resolve a ufs path.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture reverseResolve(
        alluxio.grpc.ReverseResolvePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getReverseResolveMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Reverse resolve a ufs path and get mount id.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture getMountId(
        alluxio.grpc.GetMountIdPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetMountIdMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Schedules async persistence.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture scheduleAsyncPersistence(
        alluxio.grpc.ScheduleAsyncPersistencePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getScheduleAsyncPersistenceMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Sets ACL for the path.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture setAcl(
        alluxio.grpc.SetAclPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSetAclMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Sets file or directory attributes.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture setAttribute(
        alluxio.grpc.SetAttributePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSetAttributeMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Deletes an existing "mount point", voiding the Alluxio namespace at the given path. The path
     * should correspond to an existing mount point. Any files in its subtree that are backed by UFS
     * will be persisted before they are removed from the Alluxio namespace.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture unmount(
        alluxio.grpc.UnmountPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUnmountMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Updates an existing "mount point", changing its mount properties
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture updateMount(
        alluxio.grpc.UpdateMountPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUpdateMountMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Updates the ufs mode for a ufs path under one or more mount points.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture updateUfsMode(
        alluxio.grpc.UpdateUfsModePRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUpdateUfsModeMethod(), getCallOptions()), request);
    }

    /**
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture getStateLockHolders(
        alluxio.grpc.GetStateLockHoldersPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetStateLockHoldersMethod(), getCallOptions()), request);
    }

    /**
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture needsSync(
        alluxio.grpc.NeedsSyncRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getNeedsSyncMethod(), getCallOptions()), request);
    }

    /**
     * 
     **
     * Load a directory into Alluxio.
     * 
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture submitJob(
        alluxio.grpc.SubmitJobPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSubmitJobMethod(), getCallOptions()), request);
    }

    /**
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture stopJob(
        alluxio.grpc.StopJobPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getStopJobMethod(), getCallOptions()), request);
    }

    /**
     */
    public alluxio.shaded.client.com.google.alluxio.shaded.client.com.on.util.concurrent.ListenableFuture getJobProgress(
        alluxio.grpc.GetJobProgressPRequest request) {
      return alluxio.shaded.client.io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetJobProgressMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_CHECK_ACCESS = 0;
  private static final int METHODID_CHECK_CONSISTENCY = 1;
  private static final int METHODID_EXISTS = 2;
  private static final int METHODID_COMPLETE_FILE = 3;
  private static final int METHODID_CREATE_DIRECTORY = 4;
  private static final int METHODID_CREATE_FILE = 5;
  private static final int METHODID_FREE = 6;
  private static final int METHODID_GET_FILE_PATH = 7;
  private static final int METHODID_GET_MOUNT_TABLE = 8;
  private static final int METHODID_GET_NEW_BLOCK_ID_FOR_FILE = 9;
  private static final int METHODID_GET_STATUS = 10;
  private static final int METHODID_LIST_STATUS = 11;
  private static final int METHODID_LIST_STATUS_PARTIAL = 12;
  private static final int METHODID_MOUNT = 13;
  private static final int METHODID_REMOVE = 14;
  private static final int METHODID_RENAME = 15;
  private static final int METHODID_REVERSE_RESOLVE = 16;
  private static final int METHODID_GET_MOUNT_ID = 17;
  private static final int METHODID_SCHEDULE_ASYNC_PERSISTENCE = 18;
  private static final int METHODID_SET_ACL = 19;
  private static final int METHODID_SET_ATTRIBUTE = 20;
  private static final int METHODID_UNMOUNT = 21;
  private static final int METHODID_UPDATE_MOUNT = 22;
  private static final int METHODID_UPDATE_UFS_MODE = 23;
  private static final int METHODID_GET_STATE_LOCK_HOLDERS = 24;
  private static final int METHODID_NEEDS_SYNC = 25;
  private static final int METHODID_SUBMIT_JOB = 26;
  private static final int METHODID_STOP_JOB = 27;
  private static final int METHODID_GET_JOB_PROGRESS = 28;

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

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

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public void invoke(Req request, alluxio.shaded.client.io.grpc.stub.StreamObserver responseObserver) {
      switch (methodId) {
        case METHODID_CHECK_ACCESS:
          serviceImpl.checkAccess((alluxio.grpc.CheckAccessPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_CHECK_CONSISTENCY:
          serviceImpl.checkConsistency((alluxio.grpc.CheckConsistencyPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_EXISTS:
          serviceImpl.exists((alluxio.grpc.ExistsPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_COMPLETE_FILE:
          serviceImpl.alluxio.shaded.client.com.leteFile((alluxio.grpc.CompleteFilePRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_CREATE_DIRECTORY:
          serviceImpl.createDirectory((alluxio.grpc.CreateDirectoryPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_CREATE_FILE:
          serviceImpl.createFile((alluxio.grpc.CreateFilePRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_FREE:
          serviceImpl.free((alluxio.grpc.FreePRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_FILE_PATH:
          serviceImpl.getFilePath((alluxio.grpc.GetFilePathPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_MOUNT_TABLE:
          serviceImpl.getMountTable((alluxio.grpc.GetMountTablePRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_NEW_BLOCK_ID_FOR_FILE:
          serviceImpl.getNewBlockIdForFile((alluxio.grpc.GetNewBlockIdForFilePRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_STATUS:
          serviceImpl.getStatus((alluxio.grpc.GetStatusPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_STATUS:
          serviceImpl.listStatus((alluxio.grpc.ListStatusPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_STATUS_PARTIAL:
          serviceImpl.listStatusPartial((alluxio.grpc.ListStatusPartialPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_MOUNT:
          serviceImpl.mount((alluxio.grpc.MountPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_REMOVE:
          serviceImpl.remove((alluxio.grpc.DeletePRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_RENAME:
          serviceImpl.rename((alluxio.grpc.RenamePRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_REVERSE_RESOLVE:
          serviceImpl.reverseResolve((alluxio.grpc.ReverseResolvePRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_MOUNT_ID:
          serviceImpl.getMountId((alluxio.grpc.GetMountIdPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_SCHEDULE_ASYNC_PERSISTENCE:
          serviceImpl.scheduleAsyncPersistence((alluxio.grpc.ScheduleAsyncPersistencePRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_SET_ACL:
          serviceImpl.setAcl((alluxio.grpc.SetAclPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_SET_ATTRIBUTE:
          serviceImpl.setAttribute((alluxio.grpc.SetAttributePRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_UNMOUNT:
          serviceImpl.unmount((alluxio.grpc.UnmountPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_UPDATE_MOUNT:
          serviceImpl.updateMount((alluxio.grpc.UpdateMountPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_UPDATE_UFS_MODE:
          serviceImpl.updateUfsMode((alluxio.grpc.UpdateUfsModePRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_STATE_LOCK_HOLDERS:
          serviceImpl.getStateLockHolders((alluxio.grpc.GetStateLockHoldersPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_NEEDS_SYNC:
          serviceImpl.needsSync((alluxio.grpc.NeedsSyncRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_SUBMIT_JOB:
          serviceImpl.submitJob((alluxio.grpc.SubmitJobPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_STOP_JOB:
          serviceImpl.stopJob((alluxio.grpc.StopJobPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_JOB_PROGRESS:
          serviceImpl.getJobProgress((alluxio.grpc.GetJobProgressPRequest) request,
              (alluxio.shaded.client.io.grpc.stub.StreamObserver) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

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

  public static final alluxio.shaded.client.io.grpc.ServerServiceDefinition bindService(AsyncService service) {
    return alluxio.shaded.client.io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
        .addMethod(
          getCheckAccessMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.CheckAccessPRequest,
              alluxio.grpc.CheckAccessPResponse>(
                service, METHODID_CHECK_ACCESS)))
        .addMethod(
          getCheckConsistencyMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.CheckConsistencyPRequest,
              alluxio.grpc.CheckConsistencyPResponse>(
                service, METHODID_CHECK_CONSISTENCY)))
        .addMethod(
          getExistsMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.ExistsPRequest,
              alluxio.grpc.ExistsPResponse>(
                service, METHODID_EXISTS)))
        .addMethod(
          getCompleteFileMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.CompleteFilePRequest,
              alluxio.grpc.CompleteFilePResponse>(
                service, METHODID_COMPLETE_FILE)))
        .addMethod(
          getCreateDirectoryMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.CreateDirectoryPRequest,
              alluxio.grpc.CreateDirectoryPResponse>(
                service, METHODID_CREATE_DIRECTORY)))
        .addMethod(
          getCreateFileMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.CreateFilePRequest,
              alluxio.grpc.CreateFilePResponse>(
                service, METHODID_CREATE_FILE)))
        .addMethod(
          getFreeMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.FreePRequest,
              alluxio.grpc.FreePResponse>(
                service, METHODID_FREE)))
        .addMethod(
          getGetFilePathMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.GetFilePathPRequest,
              alluxio.grpc.GetFilePathPResponse>(
                service, METHODID_GET_FILE_PATH)))
        .addMethod(
          getGetMountTableMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.GetMountTablePRequest,
              alluxio.grpc.GetMountTablePResponse>(
                service, METHODID_GET_MOUNT_TABLE)))
        .addMethod(
          getGetNewBlockIdForFileMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.GetNewBlockIdForFilePRequest,
              alluxio.grpc.GetNewBlockIdForFilePResponse>(
                service, METHODID_GET_NEW_BLOCK_ID_FOR_FILE)))
        .addMethod(
          getGetStatusMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.GetStatusPRequest,
              alluxio.grpc.GetStatusPResponse>(
                service, METHODID_GET_STATUS)))
        .addMethod(
          getListStatusMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncServerStreamingCall(
            new MethodHandlers<
              alluxio.grpc.ListStatusPRequest,
              alluxio.grpc.ListStatusPResponse>(
                service, METHODID_LIST_STATUS)))
        .addMethod(
          getListStatusPartialMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.ListStatusPartialPRequest,
              alluxio.grpc.ListStatusPartialPResponse>(
                service, METHODID_LIST_STATUS_PARTIAL)))
        .addMethod(
          getMountMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.MountPRequest,
              alluxio.grpc.MountPResponse>(
                service, METHODID_MOUNT)))
        .addMethod(
          getRemoveMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.DeletePRequest,
              alluxio.grpc.DeletePResponse>(
                service, METHODID_REMOVE)))
        .addMethod(
          getRenameMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.RenamePRequest,
              alluxio.grpc.RenamePResponse>(
                service, METHODID_RENAME)))
        .addMethod(
          getReverseResolveMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.ReverseResolvePRequest,
              alluxio.grpc.ReverseResolvePResponse>(
                service, METHODID_REVERSE_RESOLVE)))
        .addMethod(
          getGetMountIdMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.GetMountIdPRequest,
              alluxio.grpc.GetMountIdPResponse>(
                service, METHODID_GET_MOUNT_ID)))
        .addMethod(
          getScheduleAsyncPersistenceMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.ScheduleAsyncPersistencePRequest,
              alluxio.grpc.ScheduleAsyncPersistencePResponse>(
                service, METHODID_SCHEDULE_ASYNC_PERSISTENCE)))
        .addMethod(
          getSetAclMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.SetAclPRequest,
              alluxio.grpc.SetAclPResponse>(
                service, METHODID_SET_ACL)))
        .addMethod(
          getSetAttributeMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.SetAttributePRequest,
              alluxio.grpc.SetAttributePResponse>(
                service, METHODID_SET_ATTRIBUTE)))
        .addMethod(
          getUnmountMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.UnmountPRequest,
              alluxio.grpc.UnmountPResponse>(
                service, METHODID_UNMOUNT)))
        .addMethod(
          getUpdateMountMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.UpdateMountPRequest,
              alluxio.grpc.UpdateMountPResponse>(
                service, METHODID_UPDATE_MOUNT)))
        .addMethod(
          getUpdateUfsModeMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.UpdateUfsModePRequest,
              alluxio.grpc.UpdateUfsModePResponse>(
                service, METHODID_UPDATE_UFS_MODE)))
        .addMethod(
          getGetStateLockHoldersMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.GetStateLockHoldersPRequest,
              alluxio.grpc.GetStateLockHoldersPResponse>(
                service, METHODID_GET_STATE_LOCK_HOLDERS)))
        .addMethod(
          getNeedsSyncMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.NeedsSyncRequest,
              alluxio.grpc.NeedsSyncResponse>(
                service, METHODID_NEEDS_SYNC)))
        .addMethod(
          getSubmitJobMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.SubmitJobPRequest,
              alluxio.grpc.SubmitJobPResponse>(
                service, METHODID_SUBMIT_JOB)))
        .addMethod(
          getStopJobMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.StopJobPRequest,
              alluxio.grpc.StopJobPResponse>(
                service, METHODID_STOP_JOB)))
        .addMethod(
          getGetJobProgressMethod(),
          alluxio.shaded.client.io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              alluxio.grpc.GetJobProgressPRequest,
              alluxio.grpc.GetJobProgressPResponse>(
                service, METHODID_GET_JOB_PROGRESS)))
        .build();
  }

  private static abstract class FileSystemMasterClientServiceBaseDescriptorSupplier
      implements alluxio.shaded.client.io.grpc.protobuf.ProtoFileDescriptorSupplier, alluxio.shaded.client.io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    FileSystemMasterClientServiceBaseDescriptorSupplier() {}

    @java.lang.Override
    public alluxio.shaded.client.com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return alluxio.grpc.FileSystemMasterProto.getDescriptor();
    }

    @java.lang.Override
    public alluxio.shaded.client.com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("FileSystemMasterClientService");
    }
  }

  private static final class FileSystemMasterClientServiceFileDescriptorSupplier
      extends FileSystemMasterClientServiceBaseDescriptorSupplier {
    FileSystemMasterClientServiceFileDescriptorSupplier() {}
  }

  private static final class FileSystemMasterClientServiceMethodDescriptorSupplier
      extends FileSystemMasterClientServiceBaseDescriptorSupplier
      implements alluxio.shaded.client.io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    FileSystemMasterClientServiceMethodDescriptorSupplier(String methodName) {
      this.methodName = methodName;
    }

    @java.lang.Override
    public alluxio.shaded.client.com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile alluxio.shaded.client.io.grpc.ServiceDescriptor serviceDescriptor;

  public static alluxio.shaded.client.io.grpc.ServiceDescriptor getServiceDescriptor() {
    alluxio.shaded.client.io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (FileSystemMasterClientServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = alluxio.shaded.client.io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new FileSystemMasterClientServiceFileDescriptorSupplier())
              .addMethod(getCheckAccessMethod())
              .addMethod(getCheckConsistencyMethod())
              .addMethod(getExistsMethod())
              .addMethod(getCompleteFileMethod())
              .addMethod(getCreateDirectoryMethod())
              .addMethod(getCreateFileMethod())
              .addMethod(getFreeMethod())
              .addMethod(getGetFilePathMethod())
              .addMethod(getGetMountTableMethod())
              .addMethod(getGetNewBlockIdForFileMethod())
              .addMethod(getGetStatusMethod())
              .addMethod(getListStatusMethod())
              .addMethod(getListStatusPartialMethod())
              .addMethod(getMountMethod())
              .addMethod(getRemoveMethod())
              .addMethod(getRenameMethod())
              .addMethod(getReverseResolveMethod())
              .addMethod(getGetMountIdMethod())
              .addMethod(getScheduleAsyncPersistenceMethod())
              .addMethod(getSetAclMethod())
              .addMethod(getSetAttributeMethod())
              .addMethod(getUnmountMethod())
              .addMethod(getUpdateMountMethod())
              .addMethod(getUpdateUfsModeMethod())
              .addMethod(getGetStateLockHoldersMethod())
              .addMethod(getNeedsSyncMethod())
              .addMethod(getSubmitJobMethod())
              .addMethod(getStopJobMethod())
              .addMethod(getGetJobProgressMethod())
              .build();
        }
      }
    }
    return result;
  }
}