public static List<FileDescriptorSet> resolveServices(Channel channel) {
    ServerReflectionClient serverReflectionClient = ServerReflectionClient.create(channel);
    try {
        List<String> services = serverReflectionClient.listServices().get();
        if (isEmpty(services)) {
            logger.info("Can't find services by channel {}", channel);
            return emptyList();
        }
        return services.stream().map(serviceName -> {
            ListenableFuture<FileDescriptorSet> future = serverReflectionClient.lookupService(serviceName);
            try {
                return future.get();
            } catch (InterruptedException | ExecutionException e) {
                logger.error("Get {} fileDescriptor occurs error", serviceName, e);
                return null;
            }
        }).filter(Objects::nonNull).collect(toList());
    } catch (Throwable t) {
        logger.error("Exception resolve service", t);
        throw new RuntimeException(t);
    }
}
 

public static FileDescriptorSet resolveService(Channel channel, String serviceName) {
    ServerReflectionClient reflectionClient = ServerReflectionClient.create(channel);
    try {
        List<String> serviceNames = reflectionClient.listServices().get();
        if (!serviceNames.contains(serviceName)) {
            throw Status.NOT_FOUND.withDescription(
                    String.format("Remote server does not have service %s. Services: %s", serviceName, serviceNames))
                    .asRuntimeException();
        }

        return reflectionClient.lookupService(serviceName).get();
    } catch (InterruptedException | ExecutionException e) {
        logger.error("Resolve services get error", e);
        throw new RuntimeException(e);
    }
}
 

/**
 * Creates a resolver which searches the supplied {@link FileDescriptorSet}.
 */
public static ServiceResolver fromFileDescriptorSet(FileDescriptorSet descriptorSet) {
    ImmutableMap<String, FileDescriptorProto> descriptorProtoIndex =
            computeDescriptorProtoIndex(descriptorSet);
    Map<String, FileDescriptor> descriptorCache = new HashMap<>();

    ImmutableList.Builder<FileDescriptor> result = ImmutableList.builder();
    for (FileDescriptorProto descriptorProto : descriptorSet.getFileList()) {
        try {
            result.add(descriptorFromProto(descriptorProto, descriptorProtoIndex, descriptorCache));
        } catch (DescriptorValidationException e) {
            logger.warn("Skipped descriptor " + descriptorProto.getName() + " due to error", e);
        }
    }
    return new ServiceResolver(result.build());
}
 

private void processDependencies(FileDescriptorProto fileDescriptor) {
    logger.debug("Processing deps of descriptor: " + fileDescriptor.getName());
    fileDescriptor.getDependencyList().forEach(dep -> {
        if (!resolvedDescriptors.containsKey(dep) && !requestedDescriptors.contains(dep)) {
            requestedDescriptors.add(dep);
            ++outstandingRequests;
            requestStream.onNext(requestForDescriptor(dep));
        }
    });

    --outstandingRequests;
    if (outstandingRequests == 0) {
        logger.debug("Retrieved service definition for [{}] by reflection", serviceName);
        resultFuture.set(FileDescriptorSet.newBuilder()
                .addAllFile(resolvedDescriptors.values())
                .build());
        requestStream.onCompleted();
    }
}
 

/** Creates a resolver which searches the supplied {@link FileDescriptorSet}. */
public static ServiceResolver fromFileDescriptorSet(FileDescriptorSet descriptorSet) {
  ImmutableMap<String, FileDescriptorProto> descriptorProtoIndex =
      computeDescriptorProtoIndex(descriptorSet);
  Map<String, FileDescriptor> descriptorCache = new HashMap<>();

  ImmutableList.Builder<FileDescriptor> result = ImmutableList.builder();
  for (FileDescriptorProto descriptorProto : descriptorSet.getFileList()) {
    try {
      result.add(descriptorFromProto(descriptorProto, descriptorProtoIndex, descriptorCache));
    } catch (DescriptorValidationException e) {
      logger.warn("Skipped descriptor " + descriptorProto.getName() + " due to error", e);
      continue;
    }
  }
  return new ServiceResolver(result.build());
}
 

private void processDependencies(FileDescriptorProto fileDescriptor) {
  logger.debug("Processing deps of descriptor: " + fileDescriptor.getName());
  fileDescriptor.getDependencyList().forEach(dep -> {
    if (!resolvedDescriptors.containsKey(dep) && !requestedDescriptors.contains(dep)) {
      requestedDescriptors.add(dep);
      ++outstandingRequests;
      requestStream.onNext(requestForDescriptor(dep));
    }
  });

  --outstandingRequests;
  if (outstandingRequests == 0) {
    logger.debug("Retrieved service definition for [{}] by reflection", serviceName);
    resultFuture.set(FileDescriptorSet.newBuilder()
        .addAllFile(resolvedDescriptors.values())
        .build());
    requestStream.onCompleted();
  }
}
 

public static List<FileDescriptorSet> resolveServices(Channel channel) {
    ServerReflectionClient serverReflectionClient = ServerReflectionClient.create(channel);
    try {
        List<String> services = serverReflectionClient.listServices().get();
        if (isEmpty(services)) {
            logger.info("Can't find services by channel {}", channel);
            return emptyList();
        }
        return services.stream().map(serviceName -> {
            ListenableFuture<FileDescriptorSet> future = serverReflectionClient.lookupService(serviceName);
            try {
                return future.get();
            } catch (InterruptedException | ExecutionException e) {
                logger.error("Get {} fileDescriptor occurs error", serviceName, e);
                return null;
            }
        }).filter(Objects::nonNull).collect(toList());
    } catch (Throwable t) {
        logger.error("Exception resolve service", t);
        throw new RuntimeException(t);
    }
}
 

public static FileDescriptorSet resolveService(Channel channel, String serviceName) {
    ServerReflectionClient reflectionClient = ServerReflectionClient.create(channel);
    try {
        List<String> serviceNames = reflectionClient.listServices().get();
        if (!serviceNames.contains(serviceName)) {
            throw Status.NOT_FOUND.withDescription(
                    String.format("Remote server does not have service %s. Services: %s", serviceName, serviceNames))
                    .asRuntimeException();
        }

        return reflectionClient.lookupService(serviceName).get();
    } catch (InterruptedException | ExecutionException e) {
        logger.error("Resolve services get error", e);
        throw new RuntimeException(e);
    }
}
 

/**
 * Creates a resolver which searches the supplied {@link FileDescriptorSet}.
 */
public static ServiceResolver fromFileDescriptorSet(FileDescriptorSet descriptorSet) {
    ImmutableMap<String, FileDescriptorProto> descriptorProtoIndex =
            computeDescriptorProtoIndex(descriptorSet);
    Map<String, FileDescriptor> descriptorCache = new HashMap<>();

    ImmutableList.Builder<FileDescriptor> result = ImmutableList.builder();
    for (FileDescriptorProto descriptorProto : descriptorSet.getFileList()) {
        try {
            result.add(descriptorFromProto(descriptorProto, descriptorProtoIndex, descriptorCache));
        } catch (DescriptorValidationException e) {
            logger.warn("Skipped descriptor " + descriptorProto.getName() + " due to error", e);
        }
    }
    return new ServiceResolver(result.build());
}
 

private void processDependencies(FileDescriptorProto fileDescriptor) {
    logger.debug("Processing deps of descriptor: " + fileDescriptor.getName());
    fileDescriptor.getDependencyList().forEach(dep -> {
        if (!resolvedDescriptors.containsKey(dep) && !requestedDescriptors.contains(dep)) {
            requestedDescriptors.add(dep);
            ++outstandingRequests;
            requestStream.onNext(requestForDescriptor(dep));
        }
    });

    --outstandingRequests;
    if (outstandingRequests == 0) {
        logger.debug("Retrieved service definition for [{}] by reflection", serviceName);
        resultFuture.set(FileDescriptorSet.newBuilder()
                .addAllFile(resolvedDescriptors.values())
                .build());
        requestStream.onCompleted();
    }
}
 

void loadProtos(RpcApp app, String proto) {

        if (isEmpty(proto)) {
            log.info("no dynamic proto resource need to load");
            return;
        }

        if (!proto.endsWith("/")) proto = proto + "/";

        try {
            InputStream basein = RpcMetas.class.getResourceAsStream("descriptor.proto.pb");
            FileDescriptorSet baseSet = FileDescriptorSet.parseFrom(basein);
            basein.close();
            FileDescriptor base = FileDescriptor.buildFrom(baseSet.getFile(0), new FileDescriptor[]{});

            List<String> files = getProtoFiles(proto);
            for (String file : files) {
                loadProtoFile(app, base, proto + file);
            }
        } catch (Exception e) {
            log.error("load dynamic proto resource failed", e);
        }
    }
 

/**
 * Encodes the data portion of an ExecutionResult as ByteString.
 *
 * <p>The FileDescriptorSet must contain a message with the name "{operationName}Response". This
 * message will be populated with data from the execution result and encoded as a ByteString.
 */
public static ByteString encodeResponse(
    String operationName, FileDescriptorSet fileDescriptorSet, ExecutionResult executionResult) {
  try {
    // TODO: Support multiple FileDescriptors in FileDescriptorSet
    FileDescriptor fileDescriptor =
        FileDescriptor.buildFrom(fileDescriptorSet.getFileList().get(0), new FileDescriptor[] {});

    Descriptor messageType = fileDescriptor.findMessageTypeByName(operationName + "Response");

    Message message = DynamicMessage.parseFrom(messageType, ByteString.EMPTY);
    Message responseData = QueryResponseToProto.buildMessage(message, executionResult.getData());

    return responseData.toByteString();
  } catch (DescriptorValidationException | InvalidProtocolBufferException e) {
    e.printStackTrace();
    throw new RuntimeException(e);
  }
}
 

public void generateFile(String protoPath) {
  try {
    if (pojoTypes == null) {
      pojoTypes = Maps.newHashMap();
    }
  } finally {
    if (!new File(protoPath).exists()) {
      logger.warn("protoPath:" + protoPath
          + " not exist, it may be in the third party jars, so it can't be generate");
      return;
    }
    FileDescriptorSet fileDescriptorSet = commondProtoc.invoke(protoPath);
    for (FileDescriptorProto fdp : fileDescriptorSet.getFileList()) {
      Pair<String, String> packageClassName = this.packageClassName(fdp.getOptions());
      if (packageClassName == null) {
        continue;
      }
      ProtocolStringList dependencyList = fdp.getDependencyList();
      for (Iterator<String> it = dependencyList.iterator(); it.hasNext();) {
        String dependencyPath = discoveryRoot + "/" + it.next();
        generateFile(dependencyPath);
      }
      doPrint(fdp, packageClassName.getLeft(), packageClassName.getRight());
    }
  }
}
 

/**
 * Creates a model from a normalized service config, rather than from descriptor and .yaml files.
 */
public static Model create(Service normalizedConfig) {
  FileDescriptorSet regeneratedDescriptor = DescriptorGenerator.generate(normalizedConfig);
  Model model = create(regeneratedDescriptor);

  // Configured with a stripped Service
  Service.Builder builder = normalizedConfig.toBuilder();
  ImmutableList.Builder<Api> strippedApis = ImmutableList.builder();
  for (Api api : normalizedConfig.getApisList()) {
    strippedApis.add(
        Api.newBuilder().setName(api.getName()).setVersion(api.getVersion()).build());
  }
  // NOTE: Documentation may still contain text from the original protos.
  builder.clearEnums();
  builder.clearTypes();
  builder.clearApis();
  builder.addAllApis(strippedApis.build());
  ConfigSource strippedConfig = ConfigSource.newBuilder(builder.build()).build();

  model.setConfigSources(ImmutableList.of(strippedConfig));

  return model;
}
 

private FileDescriptorSet parseFileDescriptors(
    ToolOptions options, ModelBuildOverrides registry, DiagCollector diagCollector) {
  String fileDescriptor = options.get(ToolOptions.DESCRIPTOR_SET);
  if (!Strings.isNullOrEmpty(fileDescriptor)) {
    try {
      return parseFileAsDescriptorSet(FileWrapper.from(fileDescriptor), registry, diagCollector);
    } catch (IOException ex) {
      diagCollector.addDiag(
          Diag.error(
              SimpleLocation.TOPLEVEL,
              "Cannot read FileDescriptorSet file '%s': %s",
              fileDescriptor,
              ex.getMessage()));
      return null;
    }
  } else {
    return parseFileAsDescriptorSet(
        options.get(ToolOptions.DESCRIPTOR_SET_CONTENTS), registry, diagCollector);
  }
}
 

private FileDescriptorSet parseFileAsDescriptorSet(
    FileWrapper inputFile, ModelBuildOverrides registry, DiagCollector diagCollector) {
  ByteString extensionFile = inputFile.getFileContents();
  try {
    return FileDescriptorSet.parseFrom(extensionFile, registry.getPlatformExtensions());
  } catch (InvalidProtocolBufferException e) {

    diagCollector.addDiag(
        Diag.error(
            SimpleLocation.TOPLEVEL,
            "Cannot read file descriptor file '%s': %s",
            inputFile.getFilename(),
            e.getMessage()));
    return null;
  }
}
 

@Test
public void resolvesWithErrors() {
  // Modify the descriptor injecting some errors.
  FileDescriptorSet.Builder builder = descriptors.toBuilder();
  builder
      .getFileBuilder(0)
      .getMessageTypeBuilder(0)
      .getFieldBuilder(1) // required N n
      .setTypeName("undef_N");
  builder
      .getFileBuilder(0)
      .getMessageTypeBuilder(0)
      .getFieldBuilder(2) // optional E e
      .setTypeName("undef_E");
  Model testApi = Model.create(builder.build());
  testApi.registerProcessor(new Resolver());
  Truth.assertThat(testApi.establishStage(Resolved.KEY)).isFalse();
  Truth.assertThat(testApi.getDiagReporter().getDiagCollector().getErrorCount()).isEqualTo(2);
  assertThat(testApi.getDiagReporter().getDiagCollector().getDiags().get(0).toString())
      .contains("undef_N");
  assertThat(testApi.getDiagReporter().getDiagCollector().getDiags().get(1).toString())
      .contains("undef_E");
}
 

@Override
protected Map<String, String> getDocStringsFromFiles(Map<String, byte[]> files) {
    return files.entrySet().stream()
                .flatMap(entry -> {
                    try {
                        final FileDescriptorSet descriptors = FileDescriptorSet.parseFrom(entry.getValue());
                        return descriptors.getFileList().stream();
                    } catch (IOException e) {
                        logger.info("Could not parse file at '{}', skipping. " +
                                    "Is the file a protobuf descriptor file?",
                                    entry.getKey());
                        return Stream.empty();
                    }
                })
                .flatMap(f -> parseFile(f).entrySet().stream())
                .collect(toImmutableMap(Entry::getKey, Entry::getValue, (entry, unused) -> entry));
}
 

@RequestMapping("/register")
public Result<Object> registerServices(RegisterParam registerParam) {

    List<FileDescriptorSet> fileDescriptorSets = registerByIpAndPort(registerParam.getHost(), registerParam.getPort());
    if (CollectionUtils.isEmpty(fileDescriptorSets)) {
        return error("no services find");
    }
    List<String> serviceNames = getServiceNames(fileDescriptorSets);
    List<ServiceConfig> serviceConfigs = serviceNames.stream()
            .map(name -> new ServiceConfig(name, registerParam.getHostAndPortText()))
            .peek(ServiceConfigManager::addServiceConfig)
            .collect(toList());
    return Result.success(serviceConfigs);
}
 

public CallResults invokeMethod(GrpcMethodDefinition definition, Channel channel, CallOptions callOptions,
        List<String> requestJsonTexts) {
    FileDescriptorSet fileDescriptorSet = GrpcReflectionUtils.resolveService(channel, definition.getFullServiceName());
    if (fileDescriptorSet == null) {
        return null;
    }
    ServiceResolver serviceResolver = ServiceResolver.fromFileDescriptorSet(fileDescriptorSet);
    MethodDescriptor methodDescriptor = serviceResolver.resolveServiceMethod(definition);
    TypeRegistry registry = TypeRegistry.newBuilder().add(serviceResolver.listMessageTypes()).build();
    List<DynamicMessage> requestMessages = GrpcReflectionUtils.parseToMessages(registry, methodDescriptor.getInputType(),
            requestJsonTexts);
    CallResults results = new CallResults();
    StreamObserver<DynamicMessage> streamObserver = MessageWriter.newInstance(registry, results);
    CallParams callParams = CallParams.builder()
            .methodDescriptor(methodDescriptor)
            .channel(channel)
            .callOptions(callOptions)
            .requests(requestMessages)
            .responseObserver(streamObserver)
            .build();
    try {
        grpcClientService.call(callParams).get();
    } catch (InterruptedException | ExecutionException e) {
        throw new RuntimeException("Caught exception while waiting for rpc", e);
    }
    return results;
}
 

/**
 * Returns a map from descriptor proto name as found inside the descriptors to protos.
 */
private static ImmutableMap<String, FileDescriptorProto> computeDescriptorProtoIndex(
        FileDescriptorSet fileDescriptorSet) {
    ImmutableMap.Builder<String, FileDescriptorProto> resultBuilder = ImmutableMap.builder();
    for (FileDescriptorProto descriptorProto : fileDescriptorSet.getFileList()) {
        resultBuilder.put(descriptorProto.getName(), descriptorProto);
    }
    return resultBuilder.build();
}
 

/**
 * Returns a {@link FileDescriptorSet} containing all the transitive dependencies of the supplied
 * service, as provided by the remote server.
 */
public ListenableFuture<FileDescriptorSet> lookupService(String serviceName) {
    LookupServiceHandler rpcHandler = new LookupServiceHandler(serviceName);
    StreamObserver<ServerReflectionRequest> requestStream = ServerReflectionGrpc.newStub(channel)
            .withDeadlineAfter(LOOKUP_RPC_DEADLINE_MS, TimeUnit.MILLISECONDS)
            .serverReflectionInfo(rpcHandler);
    return rpcHandler.start(requestStream);
}
 

ListenableFuture<FileDescriptorSet> start(
        StreamObserver<ServerReflectionRequest> requestStream) {
    this.requestStream = requestStream;
    requestStream.onNext(requestForSymbol(serviceName));
    ++outstandingRequests;
    return resultFuture;
}
 

private static <M extends Message> ProtobufSerializerSnapshot createSnapshot(Class<M> type) {
  Descriptor messageDescriptor = ProtobufReflectionUtil.protobufDescriptor(type);
  FileDescriptorSet dependencies =
      ProtobufReflectionUtil.protoFileDescriptorSet(messageDescriptor);

  return ProtobufSerializerSnapshot.newBuilder()
      .setMessageName(messageDescriptor.getFullName())
      .setGeneratedJavaName(type.getName())
      .setDescriptorSet(dependencies)
      .build();
}
 

static FileDescriptorSet protoFileDescriptorSet(Descriptor descriptor) {
  Set<FileDescriptor> descriptors = new HashSet<>();
  descriptors.add(descriptor.getFile());
  addDependenciesRecursively(descriptors, descriptor.getFile());

  Builder fileDescriptorSet = FileDescriptorSet.newBuilder();
  for (FileDescriptor d : descriptors) {
    fileDescriptorSet.addFile(d.toProto());
  }
  return fileDescriptorSet.build();
}
 

/**
 * Returns a map from descriptor proto name as found inside the descriptors to protos.
 */
private static ImmutableMap<String, FileDescriptorProto> computeDescriptorProtoIndex(
    FileDescriptorSet fileDescriptorSet) {
  ImmutableMap.Builder<String, FileDescriptorProto> resultBuilder = ImmutableMap.builder();
  for (FileDescriptorProto descriptorProto : fileDescriptorSet.getFileList()) {
    resultBuilder.put(descriptorProto.getName(), descriptorProto);
  }
  return resultBuilder.build();
}
 

/**
 * Returns a {@link FileDescriptorSet} containing all the transitive dependencies of the supplied
 * service, as provided by the remote server.
 */
public ListenableFuture<FileDescriptorSet> lookupService(String serviceName) {
  LookupServiceHandler rpcHandler = new LookupServiceHandler(serviceName);
  StreamObserver<ServerReflectionRequest> requestStream = ServerReflectionGrpc.newStub(channel)
      .withDeadlineAfter(LOOKUP_RPC_DEADLINE_MS, TimeUnit.MILLISECONDS)
      .serverReflectionInfo(rpcHandler);
  return rpcHandler.start(requestStream);
}
 

ListenableFuture<FileDescriptorSet> start(
    StreamObserver<ServerReflectionRequest> requestStream) {
  this.requestStream = requestStream;
  requestStream.onNext(requestForSymbol(serviceName));
  ++outstandingRequests;
  return resultFuture;
}
 

@SneakyThrows
private void fetchServiceDefinition(FluxSink<String> sink, GrpcRequestContainer request, ProtoMethodName protoMethod) {
	ManagedChannel channel = createChannel(request);
	FileDescriptorSet descriptorSet = fetchServiceDescriptionViaReflection(channel, protoMethod);
	String protoContent = toProto(descriptorSet);
	sink.next(protoContent);
	sink.complete();
}
 

private String toProto(FileDescriptorSet descriptorSet) {
	ProtoDescriptorSerializer serializer = new ProtoDescriptorSerializer();
	List<FileContent> files = serializer.descriptorToString(descriptorSet);
	return files.stream()
		.map((FileContent f) ->  "/* Filename: " + f.getFileName() + " */\n" +f.getContents())
		.collect(Collectors.joining("\n---\n"));
}