public TypeSpec api(Service service) { ClassName apiName = (ClassName) javaGenerator.typeName(service.type()); if (!service.documentation().isEmpty()) { typeBuilder.addJavadoc("$L\n", service.documentation()); for (Rpc rpc : service.rpcs()) { ProtoType requestType = rpc.requestType(); TypeName requestJavaType = javaGenerator.typeName(requestType);
private static ImmutableMap<String, Service> buildServicesIndex(Iterable<ProtoFile> protoFiles) { ImmutableMap.Builder<String, Service> result = ImmutableMap.builder(); for (ProtoFile protoFile : protoFiles) { for (Service service : protoFile.services()) { result.put(service.type().toString(), service); } } return result.build(); }
service.link(linker); service.linkOptions(linker); service.validate(linker);
@Test public void rpcTypeImported() throws Exception { Schema schema = new RepoBuilder() .add("a.proto", "" + "package pa;\n" + "import \"b.proto\";\n" + "service Service {\n" + " rpc Call (pb.B) returns (pb.B);\n" + "}\n") .add("b.proto", "" + "package pb;\n" + "message B {\n" + "}\n") .schema(); Service service = schema.getService("pa.Service"); MessageType b = (MessageType) schema.getType("pb.B"); assertThat(service.rpcs().get(0).requestType()).isEqualTo(b.type()); assertThat(service.rpcs().get(0).responseType()).isEqualTo(b.type()); }
@Test public void excludeRpcExcludesTypes() throws Exception { Schema schema = new RepoBuilder() .add("service.proto", "" + "service ServiceA {\n" + " rpc CallB (MessageB) returns (MessageB);\n" + " rpc CallC (MessageC) returns (MessageC);\n" + "}\n" + "message MessageB {\n" + "}\n" + "message MessageC {\n" + "}\n") .schema(); Schema pruned = schema.prune(new IdentifierSet.Builder() .include("ServiceA") .exclude("ServiceA#CallC") .build()); assertThat(pruned.getType("MessageB")).isNotNull(); assertThat(pruned.getService("ServiceA").rpc("CallB")).isNotNull(); assertThat(pruned.getType("MessageC")).isNull(); assertThat(pruned.getService("ServiceA").rpc("CallC")).isNull(); }
Service retainAll(Schema schema, MarkSet markSet) { // If this service is not retained, prune it. if (!markSet.contains(protoType)) { return null; } ImmutableList.Builder<Rpc> retainedRpcs = ImmutableList.builder(); for (Rpc rpc : rpcs) { Rpc retainedRpc = rpc.retainAll(schema, markSet); if (retainedRpc != null && markSet.contains(ProtoMember.get(protoType, rpc.name()))) { retainedRpcs.add(retainedRpc); } } return new Service(protoType, location, documentation, name, retainedRpcs.build(), options.retainAll(schema, markSet)); }
public static InterfaceMetaInfo readFrom(ProtoFile protoFile, Service service) { String servicePath = OptionUtil.readStringOption(service.options(), SERVICE_PATH); String summary = OptionUtil.readSummary(service.documentation()); ProtoFileMetaInfo protoFileMetaInfo = ProtoFileMetaInfo.readFrom(protoFile); InterfaceMetaInfoBuilder builder = InterfaceMetaInfo.builder(); builder.servicePath(servicePath) .protoFileMetaInfo(protoFileMetaInfo) .summary(summary); return builder.build(); }
static ImmutableList<Service> fromElements(String packageName, ImmutableList<ServiceElement> elements) { ImmutableList.Builder<Service> services = ImmutableList.builder(); for (ServiceElement service : elements) { ProtoType protoType = ProtoType.get(packageName, service.name()); services.add(Service.fromElement(protoType, service)); } return services.build(); }
static ProtoFile get(ProtoFileElement protoFileElement) { String packageName = protoFileElement.packageName(); ImmutableList<Type> types = Type.fromElements(packageName, protoFileElement.types()); ImmutableList<Service> services = Service.fromElements(packageName, protoFileElement.services()); ImmutableList<Extend> wireExtends = Extend.fromElements(packageName, protoFileElement.extendDeclarations()); Options options = new Options(Options.FILE_OPTIONS, protoFileElement.options()); return new ProtoFile(protoFileElement.location(), protoFileElement.imports(), protoFileElement.publicImports(), packageName, types, services, wireExtends, options, protoFileElement.syntax()); }
public TypeSpec generateService(ProtoFile protoFile, Service service) { ClassName apiName = (ClassName) typeName(service.type()); TypeSpec.Builder typeBuilder = TypeSpec.interfaceBuilder(apiName.simpleName()); typeBuilder.addModifiers(PUBLIC); InterfaceMetaInfo interfaceMetaInfo = InterfaceMetaInfo.readFrom(protoFile, service); typeBuilder.addAnnotations(interfaceMetaInfo.generateAnnotations()); if (!service.documentation().isEmpty()) { typeBuilder.addJavadoc("$L\n", service.documentation()); } for (Rpc rpc : service.rpcs()) { ProtoType requestType = rpc.requestType(); TypeName requestJavaType = typeName(requestType); ProtoType responseType = rpc.responseType(); TypeName responseJavaType = typeName(responseType); MethodSpec.Builder rpcBuilder = MethodSpec.methodBuilder(rpc.name()); MethodMetaInfo methodMetaInfo = MethodMetaInfo.readFrom(rpc); rpcBuilder.addAnnotation(serviceAnnotation(rpc, apiName, interfaceMetaInfo)); rpcBuilder.addAnnotation(methodMetaInfo.generateRaptorMethod()); rpcBuilder.addModifiers(PUBLIC, ABSTRACT); rpcBuilder.returns(responseJavaType); ParameterSpec request = ParameterSpec.builder(requestJavaType, "request").build(); rpcBuilder.addParameter(request); if (!rpc.documentation().isEmpty()) { rpcBuilder.addJavadoc("$L\n", rpc.documentation()); } typeBuilder.addMethod(rpcBuilder.build()); } return typeBuilder.build(); }
public static JavaGenerator get(Schema schema) { Map<ProtoType, ClassName> nameToJavaName = new LinkedHashMap<>(BUILT_IN_TYPES_MAP); for (ProtoFile protoFile : schema.protoFiles()) { String javaPackage = javaPackage(protoFile); putAll(nameToJavaName, javaPackage, null, protoFile.types()); for (Service service : protoFile.services()) { ClassName className = ClassName.get(javaPackage, service.type().simpleName()); nameToJavaName.put(service.type(), className); } } return new JavaGenerator(schema, nameToJavaName, new Profile(), false, false, false); }
service.link(linker); service.linkOptions(linker); service.validate(linker);
/** * https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#paths-object * * @param protoFile * @param service * @return */ protected Paths getPath(ProtoFile protoFile, Service service) { Paths paths = new Paths(); String basePath = protoFile.packageName(); for (Rpc rpc : service.rpcs()) { String path = PathUtils.collectPath(basePath, rpc.name()); // TODO: 2018/5/23 处理path 相同,方法不同的问题, paths.addPathItem(path, getPathItem(rpc)); } return paths; }
@Test public void excludeTypeExcludesRpc() throws Exception { Schema schema = new RepoBuilder() .add("service.proto", "" + "service ServiceA {\n" + " rpc CallB (MessageB) returns (MessageB);\n" + " rpc CallC (MessageC) returns (MessageC);\n" + "}\n" + "message MessageB {\n" + "}\n" + "message MessageC {\n" + "}\n") .schema(); Schema pruned = schema.prune(new IdentifierSet.Builder() .include("ServiceA") .exclude("MessageC") .build()); assertThat(pruned.getType("MessageB")).isNotNull(); assertThat(pruned.getService("ServiceA").rpc("CallB")).isNotNull(); assertThat(pruned.getType("MessageC")).isNull(); assertThat(pruned.getService("ServiceA").rpc("CallC")).isNull(); }
static Service fromElement(ProtoType protoType, ServiceElement element) { ImmutableList<Rpc> rpcs = Rpc.fromElements(element.rpcs()); Options options = new Options(Options.SERVICE_OPTIONS, element.options()); return new Service(protoType, element.location(), element.documentation(), element.name(), rpcs, options); }