From 6ed2af75871b7daae24752e6f90d28a6464cddb7 Mon Sep 17 00:00:00 2001 From: sodaRyCN <757083350@qq.com> Date: Fri, 12 Apr 2024 17:39:39 +0800 Subject: [PATCH 1/4] own --- eventmesh-admin-server/.gitignore | 42 +++++++++++++++ eventmesh-admin-server/build.gradle | 10 ++++ eventmesh-admin-server/gradle.properties | 17 ++++++ .../apache/eventmesh/admin/server/Admin.java | 24 +++++++++ .../eventmesh/admin/server/AdminServer.java | 42 +++++++++++++++ .../admin/server/ComponentLifeCycle.java | 6 +++ .../eventmesh/admin/server/HeartBeat.java | 12 +++++ .../eventmesh/admin/server/task/Job.java | 8 +++ .../eventmesh/admin/server/task/JobState.java | 10 ++++ .../eventmesh/admin/server/task/JobType.java | 7 +++ .../eventmesh/admin/server/task/Position.java | 5 ++ .../eventmesh/admin/server/task/Task.java | 17 ++++++ .../eventmesh/admin/server/web/Request.java | 22 ++++++++ .../eventmesh/admin/server/web/Response.java | 33 ++++++++++++ .../admin/server/web/ServerController.java | 9 ++++ .../src/main/resources/application.properties | 1 + .../eventmesh/common/utils/PagedList.java | 52 +++++++++++++++++++ settings.gradle | 1 + 18 files changed, 318 insertions(+) create mode 100644 eventmesh-admin-server/.gitignore create mode 100644 eventmesh-admin-server/build.gradle create mode 100644 eventmesh-admin-server/gradle.properties create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/Admin.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminServer.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/ComponentLifeCycle.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/HeartBeat.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/Job.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/JobState.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/JobType.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/Position.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/Task.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/Request.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/Response.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/ServerController.java create mode 100644 eventmesh-admin-server/src/main/resources/application.properties create mode 100644 eventmesh-common/src/main/java/org/apache/eventmesh/common/utils/PagedList.java diff --git a/eventmesh-admin-server/.gitignore b/eventmesh-admin-server/.gitignore new file mode 100644 index 0000000000..b63da4551b --- /dev/null +++ b/eventmesh-admin-server/.gitignore @@ -0,0 +1,42 @@ +.gradle +build/ +!gradle/wrapper/gradle-wrapper.jar +!**/src/main/**/build/ +!**/src/test/**/build/ + +### IntelliJ IDEA ### +.idea/modules.xml +.idea/jarRepositories.xml +.idea/compiler.xml +.idea/libraries/ +*.iws +*.iml +*.ipr +out/ +!**/src/main/**/out/ +!**/src/test/**/out/ + +### Eclipse ### +.apt_generated +.classpath +.factorypath +.project +.settings +.springBeans +.sts4-cache +bin/ +!**/src/main/**/bin/ +!**/src/test/**/bin/ + +### NetBeans ### +/nbproject/private/ +/nbbuild/ +/dist/ +/nbdist/ +/.nb-gradle/ + +### VS Code ### +.vscode/ + +### Mac OS ### +.DS_Store \ No newline at end of file diff --git a/eventmesh-admin-server/build.gradle b/eventmesh-admin-server/build.gradle new file mode 100644 index 0000000000..668f3ed4a2 --- /dev/null +++ b/eventmesh-admin-server/build.gradle @@ -0,0 +1,10 @@ +dependencies { + implementation 'org.springframework.boot:spring-boot-starter-web' + implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:3.0.3' + compileOnly 'org.projectlombok:lombok' + runtimeOnly 'com.mysql:mysql-connector-j' + annotationProcessor 'org.projectlombok:lombok' + testImplementation 'org.springframework.boot:spring-boot-starter-test' + testImplementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter-test:3.0.3' +} + diff --git a/eventmesh-admin-server/gradle.properties b/eventmesh-admin-server/gradle.properties new file mode 100644 index 0000000000..4b0f7e904e --- /dev/null +++ b/eventmesh-admin-server/gradle.properties @@ -0,0 +1,17 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed with +# this work for additional information regarding copyright ownership. +# The ASF licenses this file to You under the Apache License, Version 2.0 +# (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +spring_boot_version=2.5.9 \ No newline at end of file diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/Admin.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/Admin.java new file mode 100644 index 0000000000..1090f7b592 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/Admin.java @@ -0,0 +1,24 @@ +package com.apache.eventmesh.admin.server; + +import org.apache.eventmesh.common.utils.PagedList; + +import com.apache.eventmesh.admin.server.task.Task; + +public interface Admin extends ComponentLifeCycle{ + /** + * support for web or ops + **/ + boolean createOrUpdateTask(Task task); + boolean deleteTask(Long id); + Task getTask(Long id); + // paged list + PagedList getTaskPaged(Task task); + + /** + * support for task + */ + void reportHeartbeat(HeartBeat heartBeat); + + + +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminServer.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminServer.java new file mode 100644 index 0000000000..e1b0f0a8c3 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminServer.java @@ -0,0 +1,42 @@ +package com.apache.eventmesh.admin.server; + +import org.apache.eventmesh.common.utils.PagedList; + +import com.apache.eventmesh.admin.server.task.Task; + +public class AdminServer implements Admin { + @Override + public boolean createOrUpdateTask(Task task) { + return false; + } + + @Override + public boolean deleteTask(Long id) { + return false; + } + + @Override + public Task getTask(Long id) { + return null; + } + + @Override + public PagedList getTaskPaged(Task task) { + return null; + } + + @Override + public void reportHeartbeat(HeartBeat heartBeat) { + + } + + @Override + public void start() { + + } + + @Override + public void destroy() { + + } +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/ComponentLifeCycle.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/ComponentLifeCycle.java new file mode 100644 index 0000000000..76abd005be --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/ComponentLifeCycle.java @@ -0,0 +1,6 @@ +package com.apache.eventmesh.admin.server; + +public interface ComponentLifeCycle { + void start(); + void destroy(); +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/HeartBeat.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/HeartBeat.java new file mode 100644 index 0000000000..b8a28c4bd3 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/HeartBeat.java @@ -0,0 +1,12 @@ +package com.apache.eventmesh.admin.server; + +import com.apache.eventmesh.admin.server.task.JobState; +import com.apache.eventmesh.admin.server.task.Position; + +public class HeartBeat { + private String address; + private String reportedTimeStamp; + private String jobID; + private Position position; + private JobState state; +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/Job.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/Job.java new file mode 100644 index 0000000000..1fe5b08976 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/Job.java @@ -0,0 +1,8 @@ +package com.apache.eventmesh.admin.server.task; + +public class Job { + private long id; + private long taskID; + private JobType type; + private JobState state; +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/JobState.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/JobState.java new file mode 100644 index 0000000000..845d91c4a3 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/JobState.java @@ -0,0 +1,10 @@ +package com.apache.eventmesh.admin.server.task; + +public enum JobState { + INIT, + STARaTED, + PAUSE, + COMPLETE, + DELETE, + FAIL +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/JobType.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/JobType.java new file mode 100644 index 0000000000..b694803988 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/JobType.java @@ -0,0 +1,7 @@ +package com.apache.eventmesh.admin.server.task; + +public enum JobType { + FULL, + INCREASE, + STRUCT_SYNC +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/Position.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/Position.java new file mode 100644 index 0000000000..491f796a9b --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/Position.java @@ -0,0 +1,5 @@ +package com.apache.eventmesh.admin.server.task; + +public class Position { + +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/Task.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/Task.java new file mode 100644 index 0000000000..4f6cb7cfe9 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/task/Task.java @@ -0,0 +1,17 @@ +package com.apache.eventmesh.admin.server.task; + +// task : job = 1 : m +public class Task { + private long id; + private String name; + private String desc; + private String uid; + private String sourceUser; + private String sourcePasswd; + private String targetUser; + private String targetPasswd; + private int sourceType; + private int targetType; + + +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/Request.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/Request.java new file mode 100644 index 0000000000..d36c292d6f --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/Request.java @@ -0,0 +1,22 @@ +package com.apache.eventmesh.admin.server.web; + +public class Request { + private String uid; + private T data; + + public String getUid() { + return uid; + } + + public void setUid(String uid) { + this.uid = uid; + } + + public T getData() { + return data; + } + + public void setData(T data) { + this.data = data; + } +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/Response.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/Response.java new file mode 100644 index 0000000000..4502ad792b --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/Response.java @@ -0,0 +1,33 @@ +package com.apache.eventmesh.admin.server.web; + +public class Response { + private boolean success; + + private String desc; + + private T data; + + public boolean isSuccess() { + return success; + } + + public void setSuccess(boolean success) { + this.success = success; + } + + public String getDesc() { + return desc; + } + + public void setDesc(String desc) { + this.desc = desc; + } + + public T getData() { + return data; + } + + public void setData(T data) { + this.data = data; + } +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/ServerController.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/ServerController.java new file mode 100644 index 0000000000..6f6e5fc7cb --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/ServerController.java @@ -0,0 +1,9 @@ +package com.apache.eventmesh.admin.server.web; + +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@RequestMapping("/eventmesh/admin") +public class ServerController { +} diff --git a/eventmesh-admin-server/src/main/resources/application.properties b/eventmesh-admin-server/src/main/resources/application.properties new file mode 100644 index 0000000000..2109a440d8 --- /dev/null +++ b/eventmesh-admin-server/src/main/resources/application.properties @@ -0,0 +1 @@ +spring.application.name=demo diff --git a/eventmesh-common/src/main/java/org/apache/eventmesh/common/utils/PagedList.java b/eventmesh-common/src/main/java/org/apache/eventmesh/common/utils/PagedList.java new file mode 100644 index 0000000000..0046764ada --- /dev/null +++ b/eventmesh-common/src/main/java/org/apache/eventmesh/common/utils/PagedList.java @@ -0,0 +1,52 @@ +package org.apache.eventmesh.common.utils; + +import java.util.List; + +public class PagedList { + private int totalSize; + private int totalPage; + private int size; + private int page; + + private List data; + + public int getTotalSize() { + return totalSize; + } + + public void setTotalSize(int totalSize) { + this.totalSize = totalSize; + } + + public int getTotalPage() { + return totalPage; + } + + public void setTotalPage(int totalPage) { + this.totalPage = totalPage; + } + + public int getSize() { + return size; + } + + public void setSize(int size) { + this.size = size; + } + + public int getPage() { + return page; + } + + public void setPage(int page) { + this.page = page; + } + + public List getData() { + return data; + } + + public void setData(List data) { + this.data = data; + } +} diff --git a/settings.gradle b/settings.gradle index 645e6fb365..6162f91f7a 100644 --- a/settings.gradle +++ b/settings.gradle @@ -126,3 +126,4 @@ include 'eventmesh-webhook:eventmesh-webhook-receive' include 'eventmesh-retry' include 'eventmesh-retry:eventmesh-retry-api' include 'eventmesh-retry:eventmesh-retry-rocketmq' +include 'eventmesh-admin-server' From d180cadbc78d2cab031ec3b52d2d00d0767067b3 Mon Sep 17 00:00:00 2001 From: sodaRyCN <757083350@qq.com> Date: Tue, 16 Apr 2024 18:58:31 +0800 Subject: [PATCH 2/4] dependency --- eventmesh-admin-server/build.gradle | 14 +++++++++----- eventmesh-admin-server/gradle.properties | 4 +++- .../src/main/resources/application.properties | 6 +++++- 3 files changed, 17 insertions(+), 7 deletions(-) diff --git a/eventmesh-admin-server/build.gradle b/eventmesh-admin-server/build.gradle index 668f3ed4a2..187fb85601 100644 --- a/eventmesh-admin-server/build.gradle +++ b/eventmesh-admin-server/build.gradle @@ -1,10 +1,14 @@ dependencies { - implementation 'org.springframework.boot:spring-boot-starter-web' - implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:3.0.3' + implementation project(":eventmesh-common") + implementation project(':eventmesh-meta:eventmesh-meta-api') + implementation project(":eventmesh-meta:eventmesh-meta-nacos") + implementation "org.springframework.boot:spring-boot-starter-web:$spring_boot_version" + implementation "org.mybatis.spring.boot:mybatis-spring-boot-starter:$mybatis_starter_version" + // https://mvnrepository.com/artifact/com.alibaba/druid-spring-boot-starter + implementation group: 'com.alibaba', name: 'druid-spring-boot-starter', version:"$druid_starter_version" compileOnly 'org.projectlombok:lombok' - runtimeOnly 'com.mysql:mysql-connector-j' annotationProcessor 'org.projectlombok:lombok' - testImplementation 'org.springframework.boot:spring-boot-starter-test' - testImplementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter-test:3.0.3' + testImplementation "org.springframework.boot:spring-boot-starter-test:$spring_boot_version" + testImplementation "org.mybatis.spring.boot:mybatis-spring-boot-starter-test:$mybatis_starter_version" } diff --git a/eventmesh-admin-server/gradle.properties b/eventmesh-admin-server/gradle.properties index 4b0f7e904e..6a6ea40fd1 100644 --- a/eventmesh-admin-server/gradle.properties +++ b/eventmesh-admin-server/gradle.properties @@ -14,4 +14,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # -spring_boot_version=2.5.9 \ No newline at end of file +spring_boot_version=2.5.9 +mybatis_starter_version=2.3.2 +druid_starter_version=1.2.22 \ No newline at end of file diff --git a/eventmesh-admin-server/src/main/resources/application.properties b/eventmesh-admin-server/src/main/resources/application.properties index 2109a440d8..ff5104c387 100644 --- a/eventmesh-admin-server/src/main/resources/application.properties +++ b/eventmesh-admin-server/src/main/resources/application.properties @@ -1 +1,5 @@ -spring.application.name=demo +spring.datasource.url=jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false +spring.datasource.username=sodafang +spring.datasource.password=asdfasdf +spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver +mybatis.mapper-locations=classpath:mapper/*.xml \ No newline at end of file From 4d811a464e5282cbd3503cc9546244453f7c2776 Mon Sep 17 00:00:00 2001 From: sodaRyCN <757083350@qq.com> Date: Thu, 18 Apr 2024 16:24:26 +0800 Subject: [PATCH 3/4] finish registry --- build.gradle | 3 + eventmesh-admin-server/build.gradle | 16 +- eventmesh-admin-server/gradle.properties | 5 +- .../admin/server/AdminException.java | 11 + .../eventmesh/admin/server/AdminServer.java | 17 +- .../registry/AbstractRegistryListener.java | 14 ++ .../EventMeshAdminServerConfiguration.java | 32 +++ .../EventMeshAdminServerRegisterInfo.java | 14 ++ .../registry/NacosDiscoveryService.java | 197 ++++++++++++++++++ .../registry/NacosRegistryConfiguration.java | 59 ++++++ .../admin/server/registry/Registry.java | 70 +++++++ .../server/registry/RegistryListener.java | 5 + .../server/registry/RegistryService.java | 20 ++ ...mesh.admin.server.registry.RegistryService | 16 ++ .../src/main/resources/application.properties | 5 - .../src/main/resources/application.yaml | 8 + .../eventmesh/spi/EventMeshExtensionType.java | 1 + 17 files changed, 476 insertions(+), 17 deletions(-) create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminException.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/AbstractRegistryListener.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/EventMeshAdminServerConfiguration.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/EventMeshAdminServerRegisterInfo.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/NacosDiscoveryService.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/NacosRegistryConfiguration.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/Registry.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/RegistryListener.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/RegistryService.java create mode 100644 eventmesh-admin-server/src/main/resources/META-INF.eventmesh/com.apache.eventmesh.admin.server.registry.RegistryService delete mode 100644 eventmesh-admin-server/src/main/resources/application.properties create mode 100644 eventmesh-admin-server/src/main/resources/application.yaml diff --git a/build.gradle b/build.gradle index ec8bc4a458..98619ed846 100644 --- a/build.gradle +++ b/build.gradle @@ -574,6 +574,9 @@ subprojects { dependency "software.amazon.awssdk:s3:2.20.29" dependency "com.github.rholder:guava-retrying:2.0.0" + dependency "org.mybatis.spring.boot:mybatis-spring-boot-starter:2.3.2" + dependency "com.alibaba:druid-spring-boot-starter:1.2.22" + dependency "org.springframework.boot:spring-boot-starter-jetty:2.7.10" } } } diff --git a/eventmesh-admin-server/build.gradle b/eventmesh-admin-server/build.gradle index 187fb85601..63ed5a4568 100644 --- a/eventmesh-admin-server/build.gradle +++ b/eventmesh-admin-server/build.gradle @@ -1,14 +1,16 @@ dependencies { + implementation project(":eventmesh-spi") implementation project(":eventmesh-common") - implementation project(':eventmesh-meta:eventmesh-meta-api') - implementation project(":eventmesh-meta:eventmesh-meta-nacos") - implementation "org.springframework.boot:spring-boot-starter-web:$spring_boot_version" - implementation "org.mybatis.spring.boot:mybatis-spring-boot-starter:$mybatis_starter_version" + implementation "com.alibaba.nacos:nacos-client" + implementation ("org.springframework.boot:spring-boot-starter-web") { + exclude group: "org.springframework.boot" ,module: "spring-boot-starter-tomcat" + } + implementation 'org.springframework.boot:spring-boot-starter-jetty' + + implementation "org.mybatis.spring.boot:mybatis-spring-boot-starter" // https://mvnrepository.com/artifact/com.alibaba/druid-spring-boot-starter - implementation group: 'com.alibaba', name: 'druid-spring-boot-starter', version:"$druid_starter_version" + implementation "com.alibaba:druid-spring-boot-starter" compileOnly 'org.projectlombok:lombok' annotationProcessor 'org.projectlombok:lombok' - testImplementation "org.springframework.boot:spring-boot-starter-test:$spring_boot_version" - testImplementation "org.mybatis.spring.boot:mybatis-spring-boot-starter-test:$mybatis_starter_version" } diff --git a/eventmesh-admin-server/gradle.properties b/eventmesh-admin-server/gradle.properties index 6a6ea40fd1..a9fd83fea0 100644 --- a/eventmesh-admin-server/gradle.properties +++ b/eventmesh-admin-server/gradle.properties @@ -13,7 +13,4 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. -# -spring_boot_version=2.5.9 -mybatis_starter_version=2.3.2 -druid_starter_version=1.2.22 \ No newline at end of file +# \ No newline at end of file diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminException.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminException.java new file mode 100644 index 0000000000..eca5eeb0df --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminException.java @@ -0,0 +1,11 @@ +package com.apache.eventmesh.admin.server; + +public class AdminException extends RuntimeException { + public AdminException(String message) { + super(message); + } + + public AdminException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminServer.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminServer.java index e1b0f0a8c3..a00182361a 100644 --- a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminServer.java +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminServer.java @@ -1,10 +1,23 @@ package com.apache.eventmesh.admin.server; +import com.apache.eventmesh.admin.server.registry.EventMeshAdminServerRegisterInfo; +import com.apache.eventmesh.admin.server.registry.RegistryService; import org.apache.eventmesh.common.utils.PagedList; import com.apache.eventmesh.admin.server.task.Task; public class AdminServer implements Admin { + + private RegistryService registryService; + + private EventMeshAdminServerRegisterInfo registerInfo; + + public AdminServer(RegistryService registryService, EventMeshAdminServerRegisterInfo registerInfo) { + this.registryService = registryService; + this.registerInfo = registerInfo; + } + + public static final String ConfigurationKey = "admin-server"; @Override public boolean createOrUpdateTask(Task task) { return false; @@ -33,10 +46,12 @@ public void reportHeartbeat(HeartBeat heartBeat) { @Override public void start() { + registryService.register(registerInfo); } @Override public void destroy() { - + registryService.unRegister(registerInfo); + registryService.shutdown(); } } diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/AbstractRegistryListener.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/AbstractRegistryListener.java new file mode 100644 index 0000000000..cdcc169790 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/AbstractRegistryListener.java @@ -0,0 +1,14 @@ +package com.apache.eventmesh.admin.server.registry; + +public abstract class AbstractRegistryListener implements RegistryListener { + protected abstract boolean checkType(Object data); + @Override + @SuppressWarnings("unchecked") + public void onChange(Object data) { + if (!checkType(data)) { + return; + } + process((T)data); + } + protected abstract void process(T data); +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/EventMeshAdminServerConfiguration.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/EventMeshAdminServerConfiguration.java new file mode 100644 index 0000000000..dc436b28de --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/EventMeshAdminServerConfiguration.java @@ -0,0 +1,32 @@ +package com.apache.eventmesh.admin.server.registry; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; +import org.apache.eventmesh.common.config.CommonConfiguration; +import org.apache.eventmesh.common.config.Config; +import org.apache.eventmesh.common.config.ConfigFiled; + +@Data +@NoArgsConstructor +@EqualsAndHashCode(callSuper = true) +@Config(prefix = "eventMesh.admin") +public class EventMeshAdminServerConfiguration extends CommonConfiguration { + @ConfigFiled(field = "server.http.port") + private int eventMeshHttpServerPort = 10000; + + @ConfigFiled(field = "server.gRPC.port") + private int eventMeshGrpcServerPort = 10000; + + @ConfigFiled(field = "registry.plugin.server-addr", notEmpty = true) + private String registryCenterAddr = ""; + + @ConfigFiled(field = "registry.plugin.type", notEmpty = true) + private String eventMeshRegistryPluginType = "nacos"; + + @ConfigFiled(field = "registry.plugin.username") + private String eventMeshRegistryPluginUsername = ""; + + @ConfigFiled(field = "registry.plugin.password") + private String eventMeshRegistryPluginPassword = ""; +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/EventMeshAdminServerRegisterInfo.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/EventMeshAdminServerRegisterInfo.java new file mode 100644 index 0000000000..c51ae64178 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/EventMeshAdminServerRegisterInfo.java @@ -0,0 +1,14 @@ +package com.apache.eventmesh.admin.server.registry; + +import lombok.Data; + +import java.util.Map; + +@Data +public class EventMeshAdminServerRegisterInfo { + private String eventMeshClusterName; + private String eventMeshName; + private String address; + + private Map metadata; +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/NacosDiscoveryService.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/NacosDiscoveryService.java new file mode 100644 index 0000000000..cd4fb11032 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/NacosDiscoveryService.java @@ -0,0 +1,197 @@ +package com.apache.eventmesh.admin.server.registry; + +import com.alibaba.nacos.api.NacosFactory; +import com.alibaba.nacos.api.PropertyKeyConst; +import com.alibaba.nacos.api.exception.NacosException; +import com.alibaba.nacos.api.naming.NamingService; +import com.alibaba.nacos.api.naming.listener.Event; +import com.alibaba.nacos.api.naming.listener.EventListener; +import com.alibaba.nacos.api.naming.pojo.Instance; +import com.alibaba.nacos.api.naming.pojo.ServiceInfo; +import com.alibaba.nacos.client.naming.utils.UtilAndComs; +import com.apache.eventmesh.admin.server.AdminException; +import com.apache.eventmesh.admin.server.AdminServer; +import lombok.extern.slf4j.Slf4j; +import org.apache.eventmesh.common.config.CommonConfiguration; +import org.apache.eventmesh.common.config.ConfigService; +import org.apache.eventmesh.common.utils.ConfigurationContextUtil; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; +import java.util.stream.Collectors; + +@Slf4j +public class NacosDiscoveryService implements RegistryService { + private final AtomicBoolean initFlag = new AtomicBoolean(false); + + private EventMeshAdminServerConfiguration adminConf; + + private NacosRegistryConfiguration nacosConf; + + private NamingService namingService; + + private final Map> listeners = new HashMap<>(); + + private final Lock lock = new ReentrantLock(); + private static final String GROUP_NAME = "admin"; + + @Override + public void init() throws AdminException { + if (!initFlag.compareAndSet(false, true)) { + return; + } + CommonConfiguration configuration = ConfigurationContextUtil.get(AdminServer.ConfigurationKey); + if (!(configuration instanceof EventMeshAdminServerConfiguration)) { + throw new AdminException("registry config instance is null or not match type"); + } + + adminConf = (EventMeshAdminServerConfiguration)configuration; + NacosRegistryConfiguration nacosConf = ConfigService.getInstance().buildConfigInstance(NacosRegistryConfiguration.class); + if (nacosConf != null) { + this.nacosConf = nacosConf; + } + Properties properties = buildProperties(); + // registry + try { + this.namingService = NacosFactory.createNamingService(properties); + } catch (NacosException e) { + log.error("[NacosRegistryService][start] error", e); + throw new AdminException(e.getMessage()); + } + } + + private Properties buildProperties() { + Properties properties = new Properties(); + properties.setProperty(PropertyKeyConst.SERVER_ADDR, adminConf.getRegistryCenterAddr()); + properties.setProperty(PropertyKeyConst.USERNAME, adminConf.getEventMeshRegistryPluginUsername()); + properties.setProperty(PropertyKeyConst.PASSWORD, adminConf.getEventMeshRegistryPluginPassword()); + if (nacosConf == null) { + return properties; + } + String endpoint = nacosConf.getEndpoint(); + if (Objects.nonNull(endpoint) && endpoint.contains(":")) { + int index = endpoint.indexOf(":"); + properties.put(PropertyKeyConst.ENDPOINT, endpoint.substring(0, index)); + properties.put(PropertyKeyConst.ENDPOINT_PORT, endpoint.substring(index + 1)); + } else { + Optional.ofNullable(endpoint).ifPresent(value -> properties.put(PropertyKeyConst.ENDPOINT, endpoint)); + String endpointPort = nacosConf.getEndpointPort(); + Optional.ofNullable(endpointPort).ifPresent(value -> properties.put(PropertyKeyConst.ENDPOINT_PORT, endpointPort)); + } + String accessKey = nacosConf.getAccessKey(); + Optional.ofNullable(accessKey).ifPresent(value -> properties.put(PropertyKeyConst.ACCESS_KEY, accessKey)); + String secretKey = nacosConf.getSecretKey(); + Optional.ofNullable(secretKey).ifPresent(value -> properties.put(PropertyKeyConst.SECRET_KEY, secretKey)); + String clusterName = nacosConf.getClusterName(); + Optional.ofNullable(clusterName).ifPresent(value -> properties.put(PropertyKeyConst.CLUSTER_NAME, clusterName)); + String logFileName = nacosConf.getLogFileName(); + Optional.ofNullable(logFileName).ifPresent(value -> properties.put(UtilAndComs.NACOS_NAMING_LOG_NAME, logFileName)); + String logLevel = nacosConf.getLogLevel(); + Optional.ofNullable(logLevel).ifPresent(value -> properties.put(UtilAndComs.NACOS_NAMING_LOG_LEVEL, logLevel)); + Integer pollingThreadCount = nacosConf.getPollingThreadCount(); + Optional.ofNullable(pollingThreadCount).ifPresent(value -> properties.put(PropertyKeyConst.NAMING_POLLING_THREAD_COUNT, pollingThreadCount)); + String namespace = nacosConf.getNamespace(); + Optional.ofNullable(namespace).ifPresent(value -> properties.put(PropertyKeyConst.NAMESPACE, namespace)); + return properties; + } + + @Override + public void shutdown() throws AdminException { + if (this.namingService != null) { + try { + namingService.shutDown(); + } catch (NacosException e) { + log.warn("shutdown nacos naming service fail", e); + } + } + } + + @Override + public void subscribe(RegistryListener listener, String serviceName) { + lock.lock(); + try { + ServiceInfo serviceInfo = ServiceInfo.fromKey(serviceName); + Map eventListenerMap = listeners.computeIfAbsent(serviceName, k -> new HashMap<>()); + if (eventListenerMap.containsKey(listener)) { + log.warn("already use same listener subscribe service name {}" ,serviceName); + return; + } + EventListener eventListener = listener::onChange; + List clusters ; + if (serviceInfo.getClusters() == null || serviceInfo.getClusters().isEmpty()) { + clusters = new ArrayList<>(); + } else { + clusters = Arrays.stream(serviceInfo.getClusters().split(",")).collect(Collectors.toList()); + } + namingService.subscribe(serviceInfo.getName(),serviceInfo.getGroupName(), clusters, eventListener); + eventListenerMap.put(listener, eventListener); + } catch (Exception e) { + log.error("subscribe service name {} fail", serviceName, e); + } finally { + lock.unlock(); + } + } + + @Override + public void unsubscribe(RegistryListener registryListener, String serviceName) { + lock.lock(); + try { + ServiceInfo serviceInfo = ServiceInfo.fromKey(serviceName); + Map map = listeners.get(serviceName); + if (map == null) { + return; + } + List clusters ; + if (serviceInfo.getClusters() == null || serviceInfo.getClusters().isEmpty()) { + clusters = new ArrayList<>(); + } else { + clusters = Arrays.stream(serviceInfo.getClusters().split(",")).collect(Collectors.toList()); + } + EventListener eventListener = map.get(registryListener); + namingService.unsubscribe(serviceInfo.getName(), serviceInfo.getGroupName(), clusters, eventListener); + map.remove(registryListener); + } catch (Exception e) { + log.error("unsubscribe service name {} fail", serviceName, e); + } finally { + lock.unlock(); + } + } + + @Override + public boolean register(EventMeshAdminServerRegisterInfo eventMeshRegisterInfo) throws AdminException { + try { + String[] ipPort = eventMeshRegisterInfo.getAddress().split(":"); + if (ipPort.length < 2) { + return false; + } + Instance instance = new Instance(); + instance.setClusterName(eventMeshRegisterInfo.getEventMeshClusterName()); + instance.setEnabled(true); + instance.setEphemeral(true); + instance.setHealthy(true); + instance.setWeight(1.0); + instance.setIp(ipPort[0]); + instance.setPort(Integer.parseInt(ipPort[1])); + instance.setMetadata(eventMeshRegisterInfo.getMetadata()); + namingService.registerInstance(eventMeshRegisterInfo.getEventMeshName(), GROUP_NAME, instance); + return true; + } catch (Exception e) { + log.error("register instance service {} group {} cluster {} fail", eventMeshRegisterInfo.getEventMeshName(), GROUP_NAME, eventMeshRegisterInfo.getEventMeshClusterName(), e); + return false; + } + } + + @Override + public boolean unRegister(EventMeshAdminServerRegisterInfo eventMeshRegisterInfo) throws AdminException { + try { + namingService.registerInstance(eventMeshRegisterInfo.getEventMeshName(), GROUP_NAME, new Instance()); + return true; + } catch (Exception e) { + log.error("register instance service {} group {} cluster {} fail", eventMeshRegisterInfo.getEventMeshName(), GROUP_NAME, eventMeshRegisterInfo.getEventMeshClusterName(), e); + return false; + } + } +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/NacosRegistryConfiguration.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/NacosRegistryConfiguration.java new file mode 100644 index 0000000000..45932e9fd4 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/NacosRegistryConfiguration.java @@ -0,0 +1,59 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.apache.eventmesh.admin.server.registry; + +import com.alibaba.nacos.api.PropertyKeyConst; +import com.alibaba.nacos.client.naming.utils.UtilAndComs; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.apache.eventmesh.common.config.Config; +import org.apache.eventmesh.common.config.ConfigFiled; + +@Data +@NoArgsConstructor +@Config(prefix = "eventMesh.registry.nacos") +public class NacosRegistryConfiguration { + + @ConfigFiled(field = PropertyKeyConst.ENDPOINT) + private String endpoint; + + @ConfigFiled(field = PropertyKeyConst.ENDPOINT_PORT) + private String endpointPort; + + @ConfigFiled(field = PropertyKeyConst.ACCESS_KEY) + private String accessKey; + + @ConfigFiled(field = PropertyKeyConst.SECRET_KEY) + private String secretKey; + + @ConfigFiled(field = PropertyKeyConst.CLUSTER_NAME) + private String clusterName; + + @ConfigFiled(field = PropertyKeyConst.NAMESPACE) + private String namespace; + + @ConfigFiled(field = PropertyKeyConst.NAMING_POLLING_THREAD_COUNT) + private Integer pollingThreadCount = Runtime.getRuntime().availableProcessors() / 2 + 1; + + @ConfigFiled(field = UtilAndComs.NACOS_NAMING_LOG_NAME) + private String logFileName; + + @ConfigFiled(field = UtilAndComs.NACOS_NAMING_LOG_LEVEL) + private String logLevel; + +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/Registry.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/Registry.java new file mode 100644 index 0000000000..771b45f2e8 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/Registry.java @@ -0,0 +1,70 @@ +package com.apache.eventmesh.admin.server.registry; + +import com.apache.eventmesh.admin.server.AdminException; +import lombok.extern.slf4j.Slf4j; +import org.apache.eventmesh.spi.EventMeshExtensionFactory; + +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.atomic.AtomicBoolean; + +@Slf4j +public class Registry implements RegistryService { + private static final Map META_CACHE = new HashMap<>(16); + private RegistryService registryService; + + private final AtomicBoolean initFlag = new AtomicBoolean(false); + private final AtomicBoolean shutdownFlag = new AtomicBoolean(false); + + public static Registry getInstance(String registryPluginType) { + return META_CACHE.computeIfAbsent(registryPluginType, Registry::registryBuilder); + } + + private static Registry registryBuilder(String registryPluginType) { + RegistryService registryServiceExt = EventMeshExtensionFactory.getExtension(RegistryService.class, registryPluginType); + if (registryServiceExt == null) { + String errorMsg = "can't load the metaService plugin, please check."; + log.error(errorMsg); + throw new RuntimeException(errorMsg); + } + Registry metaStorage = new Registry(); + metaStorage.registryService = registryServiceExt; + + return metaStorage; + } + + @Override + public void init() throws AdminException { + if (initFlag.compareAndSet(false, true)) { + return; + } + this.registryService.init(); + } + + @Override + public void shutdown() throws AdminException { + if (shutdownFlag.compareAndSet(false, true)) { + this.registryService.shutdown(); + } + } + + @Override + public void subscribe(RegistryListener registryListener, String serviceName) { + this.registryService.subscribe(registryListener, serviceName); + } + + @Override + public void unsubscribe(RegistryListener registryListener, String serviceName) { + this.registryService.unsubscribe(registryListener, serviceName); + } + + @Override + public boolean register(EventMeshAdminServerRegisterInfo eventMeshRegisterInfo) throws AdminException { + return this.registryService.register(eventMeshRegisterInfo); + } + + @Override + public boolean unRegister(EventMeshAdminServerRegisterInfo eventMeshUnRegisterInfo) throws AdminException { + return this.registryService.unRegister(eventMeshUnRegisterInfo); + } +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/RegistryListener.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/RegistryListener.java new file mode 100644 index 0000000000..2d339497f5 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/RegistryListener.java @@ -0,0 +1,5 @@ +package com.apache.eventmesh.admin.server.registry; + +public interface RegistryListener { + void onChange(Object data); +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/RegistryService.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/RegistryService.java new file mode 100644 index 0000000000..0cddd009a0 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/registry/RegistryService.java @@ -0,0 +1,20 @@ +package com.apache.eventmesh.admin.server.registry; + +import com.apache.eventmesh.admin.server.AdminException; +import org.apache.eventmesh.spi.EventMeshExtensionType; +import org.apache.eventmesh.spi.EventMeshSPI; + +@EventMeshSPI(eventMeshExtensionType = EventMeshExtensionType.REGISTRY) +public interface RegistryService { + void init() throws AdminException; + + void shutdown() throws AdminException; + + void subscribe(RegistryListener registryListener, String serviceName); + + void unsubscribe(RegistryListener registryListener, String serviceName); + + boolean register(EventMeshAdminServerRegisterInfo eventMeshRegisterInfo) throws AdminException; + + boolean unRegister(EventMeshAdminServerRegisterInfo eventMeshUnRegisterInfo) throws AdminException; +} diff --git a/eventmesh-admin-server/src/main/resources/META-INF.eventmesh/com.apache.eventmesh.admin.server.registry.RegistryService b/eventmesh-admin-server/src/main/resources/META-INF.eventmesh/com.apache.eventmesh.admin.server.registry.RegistryService new file mode 100644 index 0000000000..656fec8f37 --- /dev/null +++ b/eventmesh-admin-server/src/main/resources/META-INF.eventmesh/com.apache.eventmesh.admin.server.registry.RegistryService @@ -0,0 +1,16 @@ +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed with +# this work for additional information regarding copyright ownership. +# The ASF licenses this file to You under the Apache License, Version 2.0 +# (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +nacos=com.apache.eventmesh.admin.server.registry.NacosDiscoveryService \ No newline at end of file diff --git a/eventmesh-admin-server/src/main/resources/application.properties b/eventmesh-admin-server/src/main/resources/application.properties deleted file mode 100644 index ff5104c387..0000000000 --- a/eventmesh-admin-server/src/main/resources/application.properties +++ /dev/null @@ -1,5 +0,0 @@ -spring.datasource.url=jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false -spring.datasource.username=sodafang -spring.datasource.password=asdfasdf -spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver -mybatis.mapper-locations=classpath:mapper/*.xml \ No newline at end of file diff --git a/eventmesh-admin-server/src/main/resources/application.yaml b/eventmesh-admin-server/src/main/resources/application.yaml new file mode 100644 index 0000000000..aa72432b64 --- /dev/null +++ b/eventmesh-admin-server/src/main/resources/application.yaml @@ -0,0 +1,8 @@ +spring: + datasource: + url: jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false + username: sodafang + password: asdfasdf + driver-class-name: com.mysql.cj.jdbc.Driver +mybatis: + mapper-locations: classpath:mapper/*.xml \ No newline at end of file diff --git a/eventmesh-spi/src/main/java/org/apache/eventmesh/spi/EventMeshExtensionType.java b/eventmesh-spi/src/main/java/org/apache/eventmesh/spi/EventMeshExtensionType.java index f76379f9e8..8de4e1ecfd 100644 --- a/eventmesh-spi/src/main/java/org/apache/eventmesh/spi/EventMeshExtensionType.java +++ b/eventmesh-spi/src/main/java/org/apache/eventmesh/spi/EventMeshExtensionType.java @@ -26,6 +26,7 @@ public enum EventMeshExtensionType { CONNECTOR("connector"), STORAGE("storage"), META("metaStorage"), + REGISTRY("registryCenter"), SECURITY("security"), PROTOCOL("protocol"), METRICS("metrics"), From 94872acc9976820c1026b0b0109afe889574b9cd Mon Sep 17 00:00:00 2001 From: sodaRyCN <757083350@qq.com> Date: Fri, 19 Apr 2024 09:58:02 +0800 Subject: [PATCH 4/4] init --- build.gradle | 7 +- eventmesh-admin-server/build.gradle | 11 +- .../eventmesh/admin/server/AdminServer.java | 3 +- .../eventmesh/admin/server/HeartBeat.java | 2 + .../admin/server/web/GrpcServer.java | 19 + ...{ServerController.java => HttpServer.java} | 2 +- .../generated/AdminBiStreamServiceGrpc.java | 263 ++++++ .../web/generated/AdminServiceGrpc.java | 279 ++++++ .../common/grpc/EventMeshAdminService.java | 77 ++ .../eventmesh/common/grpc/Metadata.java | 841 ++++++++++++++++++ .../common/grpc/MetadataOrBuilder.java | 53 ++ .../apache/eventmesh/common/grpc/Payload.java | 793 +++++++++++++++++ .../common/grpc/PayloadOrBuilder.java | 37 + 13 files changed, 2381 insertions(+), 6 deletions(-) create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/GrpcServer.java rename eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/{ServerController.java => HttpServer.java} (87%) create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/generated/AdminBiStreamServiceGrpc.java create mode 100644 eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/generated/AdminServiceGrpc.java create mode 100644 eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/EventMeshAdminService.java create mode 100644 eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/Metadata.java create mode 100644 eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/MetadataOrBuilder.java create mode 100644 eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/Payload.java create mode 100644 eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/PayloadOrBuilder.java diff --git a/build.gradle b/build.gradle index 98619ed846..f55ef5acfe 100644 --- a/build.gradle +++ b/build.gradle @@ -529,7 +529,7 @@ subprojects { dependency "com.mebigfatguy.fb-contrib:fb-contrib:7.6.0" dependency "com.jayway.jsonpath:json-path:2.7.0" - dependency "org.springframework.boot:spring-boot-starter-web:2.7.10" + dependency "org.springframework.boot:spring-boot-starter-web:2.7.12" dependency "io.openmessaging:registry-server:0.0.1" dependency "org.junit.jupiter:junit-jupiter:5.6.0" @@ -574,9 +574,12 @@ subprojects { dependency "software.amazon.awssdk:s3:2.20.29" dependency "com.github.rholder:guava-retrying:2.0.0" - dependency "org.mybatis.spring.boot:mybatis-spring-boot-starter:2.3.2" + dependency "org.mybatis.spring.boot:mybatis-spring-boot-starter:2.3.1" dependency "com.alibaba:druid-spring-boot-starter:1.2.22" dependency "org.springframework.boot:spring-boot-starter-jetty:2.7.10" + + dependency "com.mysql:mysql-connector-j:8.0.33" + } } } diff --git a/eventmesh-admin-server/build.gradle b/eventmesh-admin-server/build.gradle index 63ed5a4568..9d8e2b99f1 100644 --- a/eventmesh-admin-server/build.gradle +++ b/eventmesh-admin-server/build.gradle @@ -3,14 +3,23 @@ dependencies { implementation project(":eventmesh-common") implementation "com.alibaba.nacos:nacos-client" implementation ("org.springframework.boot:spring-boot-starter-web") { - exclude group: "org.springframework.boot" ,module: "spring-boot-starter-tomcat" + exclude group: "org.springframework.boot", module: "spring-boot-starter-tomcat" } implementation 'org.springframework.boot:spring-boot-starter-jetty' + implementation "io.grpc:grpc-core" + implementation "io.grpc:grpc-protobuf" + implementation "io.grpc:grpc-stub" + implementation "org.mybatis.spring.boot:mybatis-spring-boot-starter" // https://mvnrepository.com/artifact/com.alibaba/druid-spring-boot-starter implementation "com.alibaba:druid-spring-boot-starter" + runtimeOnly 'com.mysql:mysql-connector-j' compileOnly 'org.projectlombok:lombok' annotationProcessor 'org.projectlombok:lombok' } +configurations.implementation { + exclude group: "org.springframework.boot", module: "spring-boot-starter-logging" +} + diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminServer.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminServer.java index a00182361a..cdffdd21a1 100644 --- a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminServer.java +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/AdminServer.java @@ -2,9 +2,8 @@ import com.apache.eventmesh.admin.server.registry.EventMeshAdminServerRegisterInfo; import com.apache.eventmesh.admin.server.registry.RegistryService; -import org.apache.eventmesh.common.utils.PagedList; - import com.apache.eventmesh.admin.server.task.Task; +import org.apache.eventmesh.common.utils.PagedList; public class AdminServer implements Admin { diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/HeartBeat.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/HeartBeat.java index b8a28c4bd3..568b7ff312 100644 --- a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/HeartBeat.java +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/HeartBeat.java @@ -2,7 +2,9 @@ import com.apache.eventmesh.admin.server.task.JobState; import com.apache.eventmesh.admin.server.task.Position; +import lombok.Data; +@Data public class HeartBeat { private String address; private String reportedTimeStamp; diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/GrpcServer.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/GrpcServer.java new file mode 100644 index 0000000000..f237b8f779 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/GrpcServer.java @@ -0,0 +1,19 @@ +package com.apache.eventmesh.admin.server.web; + +import com.apache.eventmesh.admin.server.ComponentLifeCycle; +import com.apache.eventmesh.admin.server.web.generated.AdminBiStreamServiceGrpc; +import org.springframework.stereotype.Controller; + +@Controller +public class GrpcServer extends AdminBiStreamServiceGrpc.AdminBiStreamServiceImplBase implements ComponentLifeCycle { + + @Override + public void start() { + + } + + @Override + public void destroy() { + + } +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/ServerController.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/HttpServer.java similarity index 87% rename from eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/ServerController.java rename to eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/HttpServer.java index 6f6e5fc7cb..681d613f32 100644 --- a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/ServerController.java +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/HttpServer.java @@ -5,5 +5,5 @@ @RestController @RequestMapping("/eventmesh/admin") -public class ServerController { +public class HttpServer { } diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/generated/AdminBiStreamServiceGrpc.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/generated/AdminBiStreamServiceGrpc.java new file mode 100644 index 0000000000..2a10de9aca --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/generated/AdminBiStreamServiceGrpc.java @@ -0,0 +1,263 @@ +package com.apache.eventmesh.admin.server.web.generated; + +import org.apache.eventmesh.common.grpc.EventMeshAdminService; +import org.apache.eventmesh.common.grpc.Payload; + +import static io.grpc.MethodDescriptor.generateFullMethodName; + +/** + */ +@javax.annotation.Generated( + value = "by gRPC proto compiler (version 1.40.0)", + comments = "Source: event_mesh_admin_service.proto") +@io.grpc.stub.annotations.GrpcGenerated +public final class AdminBiStreamServiceGrpc { + + private AdminBiStreamServiceGrpc() {} + + public static final String SERVICE_NAME = "AdminBiStreamService"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor getInvokeBiStreamMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "invokeBiStream", + requestType = Payload.class, + responseType = Payload.class, + methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) + public static io.grpc.MethodDescriptor getInvokeBiStreamMethod() { + io.grpc.MethodDescriptor getInvokeBiStreamMethod; + if ((getInvokeBiStreamMethod = AdminBiStreamServiceGrpc.getInvokeBiStreamMethod) == null) { + synchronized (AdminBiStreamServiceGrpc.class) { + if ((getInvokeBiStreamMethod = AdminBiStreamServiceGrpc.getInvokeBiStreamMethod) == null) { + AdminBiStreamServiceGrpc.getInvokeBiStreamMethod = getInvokeBiStreamMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "invokeBiStream")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + Payload.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + Payload.getDefaultInstance())) + .setSchemaDescriptor(new AdminBiStreamServiceMethodDescriptorSupplier("invokeBiStream")) + .build(); + } + } + } + return getInvokeBiStreamMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static AdminBiStreamServiceStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @Override + public AdminBiStreamServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new AdminBiStreamServiceStub(channel, callOptions); + } + }; + return AdminBiStreamServiceStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static AdminBiStreamServiceBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @Override + public AdminBiStreamServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new AdminBiStreamServiceBlockingStub(channel, callOptions); + } + }; + return AdminBiStreamServiceBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static AdminBiStreamServiceFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @Override + public AdminBiStreamServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new AdminBiStreamServiceFutureStub(channel, callOptions); + } + }; + return AdminBiStreamServiceFutureStub.newStub(factory, channel); + } + + /** + */ + public static abstract class AdminBiStreamServiceImplBase implements io.grpc.BindableService { + + /** + */ + public io.grpc.stub.StreamObserver invokeBiStream( + io.grpc.stub.StreamObserver responseObserver) { + return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getInvokeBiStreamMethod(), responseObserver); + } + + @Override public final io.grpc.ServerServiceDefinition bindService() { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getInvokeBiStreamMethod(), + io.grpc.stub.ServerCalls.asyncBidiStreamingCall( + new MethodHandlers< + Payload, + Payload>( + this, METHODID_INVOKE_BI_STREAM))) + .build(); + } + } + + /** + */ + public static final class AdminBiStreamServiceStub extends io.grpc.stub.AbstractAsyncStub { + private AdminBiStreamServiceStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @Override + protected AdminBiStreamServiceStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new AdminBiStreamServiceStub(channel, callOptions); + } + + /** + */ + public io.grpc.stub.StreamObserver invokeBiStream( + io.grpc.stub.StreamObserver responseObserver) { + return io.grpc.stub.ClientCalls.asyncBidiStreamingCall( + getChannel().newCall(getInvokeBiStreamMethod(), getCallOptions()), responseObserver); + } + } + + /** + */ + public static final class AdminBiStreamServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub { + private AdminBiStreamServiceBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @Override + protected AdminBiStreamServiceBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new AdminBiStreamServiceBlockingStub(channel, callOptions); + } + } + + /** + */ + public static final class AdminBiStreamServiceFutureStub extends io.grpc.stub.AbstractFutureStub { + private AdminBiStreamServiceFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @Override + protected AdminBiStreamServiceFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new AdminBiStreamServiceFutureStub(channel, callOptions); + } + } + + private static final int METHODID_INVOKE_BI_STREAM = 0; + + private static final class MethodHandlers implements + io.grpc.stub.ServerCalls.UnaryMethod, + io.grpc.stub.ServerCalls.ServerStreamingMethod, + io.grpc.stub.ServerCalls.ClientStreamingMethod, + io.grpc.stub.ServerCalls.BidiStreamingMethod { + private final AdminBiStreamServiceImplBase serviceImpl; + private final int methodId; + + MethodHandlers(AdminBiStreamServiceImplBase serviceImpl, int methodId) { + this.serviceImpl = serviceImpl; + this.methodId = methodId; + } + + @Override + @SuppressWarnings("unchecked") + public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + default: + throw new AssertionError(); + } + } + + @Override + @SuppressWarnings("unchecked") + public io.grpc.stub.StreamObserver invoke( + io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + case METHODID_INVOKE_BI_STREAM: + return (io.grpc.stub.StreamObserver) serviceImpl.invokeBiStream( + (io.grpc.stub.StreamObserver) responseObserver); + default: + throw new AssertionError(); + } + } + } + + private static abstract class AdminBiStreamServiceBaseDescriptorSupplier + implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier { + AdminBiStreamServiceBaseDescriptorSupplier() {} + + @Override + public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() { + return EventMeshAdminService.getDescriptor(); + } + + @Override + public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() { + return getFileDescriptor().findServiceByName("AdminBiStreamService"); + } + } + + private static final class AdminBiStreamServiceFileDescriptorSupplier + extends AdminBiStreamServiceBaseDescriptorSupplier { + AdminBiStreamServiceFileDescriptorSupplier() {} + } + + private static final class AdminBiStreamServiceMethodDescriptorSupplier + extends AdminBiStreamServiceBaseDescriptorSupplier + implements io.grpc.protobuf.ProtoMethodDescriptorSupplier { + private final String methodName; + + AdminBiStreamServiceMethodDescriptorSupplier(String methodName) { + this.methodName = methodName; + } + + @Override + public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() { + return getServiceDescriptor().findMethodByName(methodName); + } + } + + private static volatile io.grpc.ServiceDescriptor serviceDescriptor; + + public static io.grpc.ServiceDescriptor getServiceDescriptor() { + io.grpc.ServiceDescriptor result = serviceDescriptor; + if (result == null) { + synchronized (AdminBiStreamServiceGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .setSchemaDescriptor(new AdminBiStreamServiceFileDescriptorSupplier()) + .addMethod(getInvokeBiStreamMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/generated/AdminServiceGrpc.java b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/generated/AdminServiceGrpc.java new file mode 100644 index 0000000000..61b418e900 --- /dev/null +++ b/eventmesh-admin-server/src/main/java/com/apache/eventmesh/admin/server/web/generated/AdminServiceGrpc.java @@ -0,0 +1,279 @@ +package com.apache.eventmesh.admin.server.web.generated; + +import org.apache.eventmesh.common.grpc.EventMeshAdminService; +import org.apache.eventmesh.common.grpc.Payload; + +import static io.grpc.MethodDescriptor.generateFullMethodName; + +/** + */ +@javax.annotation.Generated( + value = "by gRPC proto compiler (version 1.40.0)", + comments = "Source: event_mesh_admin_service.proto") +@io.grpc.stub.annotations.GrpcGenerated +public final class AdminServiceGrpc { + + private AdminServiceGrpc() {} + + public static final String SERVICE_NAME = "AdminService"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor getInvokeMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "invoke", + requestType = Payload.class, + responseType = Payload.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getInvokeMethod() { + io.grpc.MethodDescriptor getInvokeMethod; + if ((getInvokeMethod = AdminServiceGrpc.getInvokeMethod) == null) { + synchronized (AdminServiceGrpc.class) { + if ((getInvokeMethod = AdminServiceGrpc.getInvokeMethod) == null) { + AdminServiceGrpc.getInvokeMethod = getInvokeMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "invoke")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + Payload.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + Payload.getDefaultInstance())) + .setSchemaDescriptor(new AdminServiceMethodDescriptorSupplier("invoke")) + .build(); + } + } + } + return getInvokeMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static AdminServiceStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @Override + public AdminServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new AdminServiceStub(channel, callOptions); + } + }; + return AdminServiceStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static AdminServiceBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @Override + public AdminServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new AdminServiceBlockingStub(channel, callOptions); + } + }; + return AdminServiceBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static AdminServiceFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @Override + public AdminServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new AdminServiceFutureStub(channel, callOptions); + } + }; + return AdminServiceFutureStub.newStub(factory, channel); + } + + /** + */ + public static abstract class AdminServiceImplBase implements io.grpc.BindableService { + + /** + */ + public void invoke(Payload request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getInvokeMethod(), responseObserver); + } + + @Override public final io.grpc.ServerServiceDefinition bindService() { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getInvokeMethod(), + io.grpc.stub.ServerCalls.asyncUnaryCall( + new MethodHandlers< + Payload, + Payload>( + this, METHODID_INVOKE))) + .build(); + } + } + + /** + */ + public static final class AdminServiceStub extends io.grpc.stub.AbstractAsyncStub { + private AdminServiceStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @Override + protected AdminServiceStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new AdminServiceStub(channel, callOptions); + } + + /** + */ + public void invoke(Payload request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ClientCalls.asyncUnaryCall( + getChannel().newCall(getInvokeMethod(), getCallOptions()), request, responseObserver); + } + } + + /** + */ + public static final class AdminServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub { + private AdminServiceBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @Override + protected AdminServiceBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new AdminServiceBlockingStub(channel, callOptions); + } + + /** + */ + public Payload invoke(Payload request) { + return io.grpc.stub.ClientCalls.blockingUnaryCall( + getChannel(), getInvokeMethod(), getCallOptions(), request); + } + } + + /** + */ + public static final class AdminServiceFutureStub extends io.grpc.stub.AbstractFutureStub { + private AdminServiceFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @Override + protected AdminServiceFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new AdminServiceFutureStub(channel, callOptions); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture invoke( + Payload request) { + return io.grpc.stub.ClientCalls.futureUnaryCall( + getChannel().newCall(getInvokeMethod(), getCallOptions()), request); + } + } + + private static final int METHODID_INVOKE = 0; + + private static final class MethodHandlers implements + io.grpc.stub.ServerCalls.UnaryMethod, + io.grpc.stub.ServerCalls.ServerStreamingMethod, + io.grpc.stub.ServerCalls.ClientStreamingMethod, + io.grpc.stub.ServerCalls.BidiStreamingMethod { + private final AdminServiceImplBase serviceImpl; + private final int methodId; + + MethodHandlers(AdminServiceImplBase serviceImpl, int methodId) { + this.serviceImpl = serviceImpl; + this.methodId = methodId; + } + + @Override + @SuppressWarnings("unchecked") + public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + case METHODID_INVOKE: + serviceImpl.invoke((Payload) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + default: + throw new AssertionError(); + } + } + + @Override + @SuppressWarnings("unchecked") + public io.grpc.stub.StreamObserver invoke( + io.grpc.stub.StreamObserver responseObserver) { + switch (methodId) { + default: + throw new AssertionError(); + } + } + } + + private static abstract class AdminServiceBaseDescriptorSupplier + implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier { + AdminServiceBaseDescriptorSupplier() {} + + @Override + public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() { + return EventMeshAdminService.getDescriptor(); + } + + @Override + public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() { + return getFileDescriptor().findServiceByName("AdminService"); + } + } + + private static final class AdminServiceFileDescriptorSupplier + extends AdminServiceBaseDescriptorSupplier { + AdminServiceFileDescriptorSupplier() {} + } + + private static final class AdminServiceMethodDescriptorSupplier + extends AdminServiceBaseDescriptorSupplier + implements io.grpc.protobuf.ProtoMethodDescriptorSupplier { + private final String methodName; + + AdminServiceMethodDescriptorSupplier(String methodName) { + this.methodName = methodName; + } + + @Override + public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() { + return getServiceDescriptor().findMethodByName(methodName); + } + } + + private static volatile io.grpc.ServiceDescriptor serviceDescriptor; + + public static io.grpc.ServiceDescriptor getServiceDescriptor() { + io.grpc.ServiceDescriptor result = serviceDescriptor; + if (result == null) { + synchronized (AdminServiceGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .setSchemaDescriptor(new AdminServiceFileDescriptorSupplier()) + .addMethod(getInvokeMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/EventMeshAdminService.java b/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/EventMeshAdminService.java new file mode 100644 index 0000000000..3c2e81217c --- /dev/null +++ b/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/EventMeshAdminService.java @@ -0,0 +1,77 @@ +package org.apache.eventmesh.common.grpc;// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: event_mesh_admin_service.proto + +public final class EventMeshAdminService { + private EventMeshAdminService() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + static final com.google.protobuf.Descriptors.Descriptor + internal_static_Metadata_descriptor; + static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Metadata_fieldAccessorTable; + static final com.google.protobuf.Descriptors.Descriptor + internal_static_Metadata_HeadersEntry_descriptor; + static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Metadata_HeadersEntry_fieldAccessorTable; + static final com.google.protobuf.Descriptors.Descriptor + internal_static_Payload_descriptor; + static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Payload_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + String[] descriptorData = { + "\n\036event_mesh_admin_service.proto\032\031google" + + "/protobuf/any.proto\"q\n\010Metadata\022\014\n\004type\030" + + "\003 \001(\t\022\'\n\007headers\030\007 \003(\0132\026.Metadata.Header" + + "sEntry\032.\n\014HeadersEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005v" + + "alue\030\002 \001(\t:\0028\001\"J\n\007Payload\022\033\n\010metadata\030\002 " + + "\001(\0132\t.Metadata\022\"\n\004body\030\003 \001(\0132\024.google.pr" + + "otobuf.Any2B\n\024AdminBiStreamService\022*\n\016in" + + "vokeBiStream\022\010.Payload\032\010.Payload\"\000(\0010\00124" + + "\n\014AdminService\022$\n\014invokeStream\022\010.Payload" + + "\032\010.Payload\"\000B\002P\001b\006proto3" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.google.protobuf.AnyProto.getDescriptor(), + }); + internal_static_Metadata_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Metadata_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Metadata_descriptor, + new String[] { "Type", "Headers", }); + internal_static_Metadata_HeadersEntry_descriptor = + internal_static_Metadata_descriptor.getNestedTypes().get(0); + internal_static_Metadata_HeadersEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Metadata_HeadersEntry_descriptor, + new String[] { "Key", "Value", }); + internal_static_Payload_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_Payload_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Payload_descriptor, + new String[] { "Metadata", "Body", }); + com.google.protobuf.AnyProto.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/Metadata.java b/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/Metadata.java new file mode 100644 index 0000000000..6361ee252b --- /dev/null +++ b/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/Metadata.java @@ -0,0 +1,841 @@ +package org.apache.eventmesh.common.grpc;// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: event_mesh_admin_service.proto + +/** + * Protobuf type {@code Metadata} + */ +public final class Metadata extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Metadata) + MetadataOrBuilder { +private static final long serialVersionUID = 0L; + // Use Metadata.newBuilder() to construct. + private Metadata(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Metadata() { + type_ = ""; + } + + @Override + @SuppressWarnings({"unused"}) + protected Object newInstance( + UnusedPrivateParameter unused) { + return new Metadata(); + } + + @Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Metadata( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 26: { + String s = input.readStringRequireUtf8(); + + type_ = s; + break; + } + case 58: { + if (!((mutable_bitField0_ & 0x00000001) != 0)) { + headers_ = com.google.protobuf.MapField.newMapField( + HeadersDefaultEntryHolder.defaultEntry); + mutable_bitField0_ |= 0x00000001; + } + com.google.protobuf.MapEntry + headers__ = input.readMessage( + HeadersDefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry); + headers_.getMutableMap().put( + headers__.getKey(), headers__.getValue()); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return EventMeshAdminService.internal_static_Metadata_descriptor; + } + + @SuppressWarnings({"rawtypes"}) + @Override + protected com.google.protobuf.MapField internalGetMapField( + int number) { + switch (number) { + case 7: + return internalGetHeaders(); + default: + throw new RuntimeException( + "Invalid map field number: " + number); + } + } + @Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return EventMeshAdminService.internal_static_Metadata_fieldAccessorTable + .ensureFieldAccessorsInitialized( + Metadata.class, Builder.class); + } + + public static final int TYPE_FIELD_NUMBER = 3; + private volatile Object type_; + /** + * string type = 3; + * @return The type. + */ + @Override + public String getType() { + Object ref = type_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + type_ = s; + return s; + } + } + /** + * string type = 3; + * @return The bytes for type. + */ + @Override + public com.google.protobuf.ByteString + getTypeBytes() { + Object ref = type_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + type_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int HEADERS_FIELD_NUMBER = 7; + private static final class HeadersDefaultEntryHolder { + static final com.google.protobuf.MapEntry< + String, String> defaultEntry = + com.google.protobuf.MapEntry + .newDefaultInstance( + EventMeshAdminService.internal_static_Metadata_HeadersEntry_descriptor, + com.google.protobuf.WireFormat.FieldType.STRING, + "", + com.google.protobuf.WireFormat.FieldType.STRING, + ""); + } + private com.google.protobuf.MapField< + String, String> headers_; + private com.google.protobuf.MapField + internalGetHeaders() { + if (headers_ == null) { + return com.google.protobuf.MapField.emptyMapField( + HeadersDefaultEntryHolder.defaultEntry); + } + return headers_; + } + + public int getHeadersCount() { + return internalGetHeaders().getMap().size(); + } + /** + * map<string, string> headers = 7; + */ + + @Override + public boolean containsHeaders( + String key) { + if (key == null) { throw new NullPointerException(); } + return internalGetHeaders().getMap().containsKey(key); + } + /** + * Use {@link #getHeadersMap()} instead. + */ + @Override + @Deprecated + public java.util.Map getHeaders() { + return getHeadersMap(); + } + /** + * map<string, string> headers = 7; + */ + @Override + + public java.util.Map getHeadersMap() { + return internalGetHeaders().getMap(); + } + /** + * map<string, string> headers = 7; + */ + @Override + + public String getHeadersOrDefault( + String key, + String defaultValue) { + if (key == null) { throw new NullPointerException(); } + java.util.Map map = + internalGetHeaders().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<string, string> headers = 7; + */ + @Override + + public String getHeadersOrThrow( + String key) { + if (key == null) { throw new NullPointerException(); } + java.util.Map map = + internalGetHeaders().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + private byte memoizedIsInitialized = -1; + @Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getTypeBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, type_); + } + com.google.protobuf.GeneratedMessageV3 + .serializeStringMapTo( + output, + internalGetHeaders(), + HeadersDefaultEntryHolder.defaultEntry, + 7); + unknownFields.writeTo(output); + } + + @Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getTypeBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, type_); + } + for (java.util.Map.Entry entry + : internalGetHeaders().getMap().entrySet()) { + com.google.protobuf.MapEntry + headers__ = HeadersDefaultEntryHolder.defaultEntry.newBuilderForType() + .setKey(entry.getKey()) + .setValue(entry.getValue()) + .build(); + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, headers__); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof Metadata)) { + return super.equals(obj); + } + Metadata other = (Metadata) obj; + + if (!getType() + .equals(other.getType())) return false; + if (!internalGetHeaders().equals( + other.internalGetHeaders())) return false; + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + getType().hashCode(); + if (!internalGetHeaders().getMap().isEmpty()) { + hash = (37 * hash) + HEADERS_FIELD_NUMBER; + hash = (53 * hash) + internalGetHeaders().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static Metadata parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static Metadata parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static Metadata parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static Metadata parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static Metadata parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static Metadata parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static Metadata parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static Metadata parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static Metadata parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static Metadata parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static Metadata parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static Metadata parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(Metadata prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Metadata} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Metadata) + MetadataOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return EventMeshAdminService.internal_static_Metadata_descriptor; + } + + @SuppressWarnings({"rawtypes"}) + protected com.google.protobuf.MapField internalGetMapField( + int number) { + switch (number) { + case 7: + return internalGetHeaders(); + default: + throw new RuntimeException( + "Invalid map field number: " + number); + } + } + @SuppressWarnings({"rawtypes"}) + protected com.google.protobuf.MapField internalGetMutableMapField( + int number) { + switch (number) { + case 7: + return internalGetMutableHeaders(); + default: + throw new RuntimeException( + "Invalid map field number: " + number); + } + } + @Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return EventMeshAdminService.internal_static_Metadata_fieldAccessorTable + .ensureFieldAccessorsInitialized( + Metadata.class, Builder.class); + } + + // Construct using Metadata.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @Override + public Builder clear() { + super.clear(); + type_ = ""; + + internalGetMutableHeaders().clear(); + return this; + } + + @Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return EventMeshAdminService.internal_static_Metadata_descriptor; + } + + @Override + public Metadata getDefaultInstanceForType() { + return Metadata.getDefaultInstance(); + } + + @Override + public Metadata build() { + Metadata result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @Override + public Metadata buildPartial() { + Metadata result = new Metadata(this); + int from_bitField0_ = bitField0_; + result.type_ = type_; + result.headers_ = internalGetHeaders(); + result.headers_.makeImmutable(); + onBuilt(); + return result; + } + + @Override + public Builder clone() { + return super.clone(); + } + @Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return super.setField(field, value); + } + @Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return super.setRepeatedField(field, index, value); + } + @Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return super.addRepeatedField(field, value); + } + @Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof Metadata) { + return mergeFrom((Metadata)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(Metadata other) { + if (other == Metadata.getDefaultInstance()) return this; + if (!other.getType().isEmpty()) { + type_ = other.type_; + onChanged(); + } + internalGetMutableHeaders().mergeFrom( + other.internalGetHeaders()); + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @Override + public final boolean isInitialized() { + return true; + } + + @Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Metadata parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (Metadata) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private Object type_ = ""; + /** + * string type = 3; + * @return The type. + */ + public String getType() { + Object ref = type_; + if (!(ref instanceof String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + type_ = s; + return s; + } else { + return (String) ref; + } + } + /** + * string type = 3; + * @return The bytes for type. + */ + public com.google.protobuf.ByteString + getTypeBytes() { + Object ref = type_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + type_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string type = 3; + * @param value The type to set. + * @return This builder for chaining. + */ + public Builder setType( + String value) { + if (value == null) { + throw new NullPointerException(); + } + + type_ = value; + onChanged(); + return this; + } + /** + * string type = 3; + * @return This builder for chaining. + */ + public Builder clearType() { + + type_ = getDefaultInstance().getType(); + onChanged(); + return this; + } + /** + * string type = 3; + * @param value The bytes for type to set. + * @return This builder for chaining. + */ + public Builder setTypeBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + type_ = value; + onChanged(); + return this; + } + + private com.google.protobuf.MapField< + String, String> headers_; + private com.google.protobuf.MapField + internalGetHeaders() { + if (headers_ == null) { + return com.google.protobuf.MapField.emptyMapField( + HeadersDefaultEntryHolder.defaultEntry); + } + return headers_; + } + private com.google.protobuf.MapField + internalGetMutableHeaders() { + onChanged();; + if (headers_ == null) { + headers_ = com.google.protobuf.MapField.newMapField( + HeadersDefaultEntryHolder.defaultEntry); + } + if (!headers_.isMutable()) { + headers_ = headers_.copy(); + } + return headers_; + } + + public int getHeadersCount() { + return internalGetHeaders().getMap().size(); + } + /** + * map<string, string> headers = 7; + */ + + @Override + public boolean containsHeaders( + String key) { + if (key == null) { throw new NullPointerException(); } + return internalGetHeaders().getMap().containsKey(key); + } + /** + * Use {@link #getHeadersMap()} instead. + */ + @Override + @Deprecated + public java.util.Map getHeaders() { + return getHeadersMap(); + } + /** + * map<string, string> headers = 7; + */ + @Override + + public java.util.Map getHeadersMap() { + return internalGetHeaders().getMap(); + } + /** + * map<string, string> headers = 7; + */ + @Override + + public String getHeadersOrDefault( + String key, + String defaultValue) { + if (key == null) { throw new NullPointerException(); } + java.util.Map map = + internalGetHeaders().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<string, string> headers = 7; + */ + @Override + + public String getHeadersOrThrow( + String key) { + if (key == null) { throw new NullPointerException(); } + java.util.Map map = + internalGetHeaders().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public Builder clearHeaders() { + internalGetMutableHeaders().getMutableMap() + .clear(); + return this; + } + /** + * map<string, string> headers = 7; + */ + + public Builder removeHeaders( + String key) { + if (key == null) { throw new NullPointerException(); } + internalGetMutableHeaders().getMutableMap() + .remove(key); + return this; + } + /** + * Use alternate mutation accessors instead. + */ + @Deprecated + public java.util.Map + getMutableHeaders() { + return internalGetMutableHeaders().getMutableMap(); + } + /** + * map<string, string> headers = 7; + */ + public Builder putHeaders( + String key, + String value) { + if (key == null) { throw new NullPointerException(); } + if (value == null) { throw new NullPointerException(); } + internalGetMutableHeaders().getMutableMap() + .put(key, value); + return this; + } + /** + * map<string, string> headers = 7; + */ + + public Builder putAllHeaders( + java.util.Map values) { + internalGetMutableHeaders().getMutableMap() + .putAll(values); + return this; + } + @Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Metadata) + } + + // @@protoc_insertion_point(class_scope:Metadata) + private static final Metadata DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new Metadata(); + } + + public static Metadata getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @Override + public Metadata parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Metadata(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @Override + public Metadata getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + +} + diff --git a/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/MetadataOrBuilder.java b/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/MetadataOrBuilder.java new file mode 100644 index 0000000000..efed0c02a6 --- /dev/null +++ b/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/MetadataOrBuilder.java @@ -0,0 +1,53 @@ +package org.apache.eventmesh.common.grpc;// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: event_mesh_admin_service.proto + +public interface MetadataOrBuilder extends + // @@protoc_insertion_point(interface_extends:Metadata) + com.google.protobuf.MessageOrBuilder { + + /** + * string type = 3; + * @return The type. + */ + String getType(); + /** + * string type = 3; + * @return The bytes for type. + */ + com.google.protobuf.ByteString + getTypeBytes(); + + /** + * map<string, string> headers = 7; + */ + int getHeadersCount(); + /** + * map<string, string> headers = 7; + */ + boolean containsHeaders( + String key); + /** + * Use {@link #getHeadersMap()} instead. + */ + @Deprecated + java.util.Map + getHeaders(); + /** + * map<string, string> headers = 7; + */ + java.util.Map + getHeadersMap(); + /** + * map<string, string> headers = 7; + */ + + String getHeadersOrDefault( + String key, + String defaultValue); + /** + * map<string, string> headers = 7; + */ + + String getHeadersOrThrow( + String key); +} diff --git a/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/Payload.java b/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/Payload.java new file mode 100644 index 0000000000..a23fcc9781 --- /dev/null +++ b/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/Payload.java @@ -0,0 +1,793 @@ +package org.apache.eventmesh.common.grpc;// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: event_mesh_admin_service.proto + +/** + * Protobuf type {@code Payload} + */ +public final class Payload extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Payload) + PayloadOrBuilder { +private static final long serialVersionUID = 0L; + // Use Payload.newBuilder() to construct. + private Payload(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Payload() { + } + + @Override + @SuppressWarnings({"unused"}) + protected Object newInstance( + UnusedPrivateParameter unused) { + return new Payload(); + } + + @Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Payload( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new NullPointerException(); + } + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 18: { + Metadata.Builder subBuilder = null; + if (metadata_ != null) { + subBuilder = metadata_.toBuilder(); + } + metadata_ = input.readMessage(Metadata.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(metadata_); + metadata_ = subBuilder.buildPartial(); + } + + break; + } + case 26: { + com.google.protobuf.Any.Builder subBuilder = null; + if (body_ != null) { + subBuilder = body_.toBuilder(); + } + body_ = input.readMessage(com.google.protobuf.Any.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(body_); + body_ = subBuilder.buildPartial(); + } + + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return EventMeshAdminService.internal_static_Payload_descriptor; + } + + @Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return EventMeshAdminService.internal_static_Payload_fieldAccessorTable + .ensureFieldAccessorsInitialized( + Payload.class, Builder.class); + } + + public static final int METADATA_FIELD_NUMBER = 2; + private Metadata metadata_; + /** + * .Metadata metadata = 2; + * @return Whether the metadata field is set. + */ + @Override + public boolean hasMetadata() { + return metadata_ != null; + } + /** + * .Metadata metadata = 2; + * @return The metadata. + */ + @Override + public Metadata getMetadata() { + return metadata_ == null ? Metadata.getDefaultInstance() : metadata_; + } + /** + * .Metadata metadata = 2; + */ + @Override + public MetadataOrBuilder getMetadataOrBuilder() { + return getMetadata(); + } + + public static final int BODY_FIELD_NUMBER = 3; + private com.google.protobuf.Any body_; + /** + * .google.protobuf.Any body = 3; + * @return Whether the body field is set. + */ + @Override + public boolean hasBody() { + return body_ != null; + } + /** + * .google.protobuf.Any body = 3; + * @return The body. + */ + @Override + public com.google.protobuf.Any getBody() { + return body_ == null ? com.google.protobuf.Any.getDefaultInstance() : body_; + } + /** + * .google.protobuf.Any body = 3; + */ + @Override + public com.google.protobuf.AnyOrBuilder getBodyOrBuilder() { + return getBody(); + } + + private byte memoizedIsInitialized = -1; + @Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (metadata_ != null) { + output.writeMessage(2, getMetadata()); + } + if (body_ != null) { + output.writeMessage(3, getBody()); + } + unknownFields.writeTo(output); + } + + @Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (metadata_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getMetadata()); + } + if (body_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, getBody()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof Payload)) { + return super.equals(obj); + } + Payload other = (Payload) obj; + + if (hasMetadata() != other.hasMetadata()) return false; + if (hasMetadata()) { + if (!getMetadata() + .equals(other.getMetadata())) return false; + } + if (hasBody() != other.hasBody()) return false; + if (hasBody()) { + if (!getBody() + .equals(other.getBody())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasMetadata()) { + hash = (37 * hash) + METADATA_FIELD_NUMBER; + hash = (53 * hash) + getMetadata().hashCode(); + } + if (hasBody()) { + hash = (37 * hash) + BODY_FIELD_NUMBER; + hash = (53 * hash) + getBody().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static Payload parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static Payload parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static Payload parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static Payload parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static Payload parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static Payload parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static Payload parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static Payload parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static Payload parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static Payload parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static Payload parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static Payload parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(Payload prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Payload} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Payload) + PayloadOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return EventMeshAdminService.internal_static_Payload_descriptor; + } + + @Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return EventMeshAdminService.internal_static_Payload_fieldAccessorTable + .ensureFieldAccessorsInitialized( + Payload.class, Builder.class); + } + + // Construct using Payload.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @Override + public Builder clear() { + super.clear(); + if (metadataBuilder_ == null) { + metadata_ = null; + } else { + metadata_ = null; + metadataBuilder_ = null; + } + if (bodyBuilder_ == null) { + body_ = null; + } else { + body_ = null; + bodyBuilder_ = null; + } + return this; + } + + @Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return EventMeshAdminService.internal_static_Payload_descriptor; + } + + @Override + public Payload getDefaultInstanceForType() { + return Payload.getDefaultInstance(); + } + + @Override + public Payload build() { + Payload result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @Override + public Payload buildPartial() { + Payload result = new Payload(this); + if (metadataBuilder_ == null) { + result.metadata_ = metadata_; + } else { + result.metadata_ = metadataBuilder_.build(); + } + if (bodyBuilder_ == null) { + result.body_ = body_; + } else { + result.body_ = bodyBuilder_.build(); + } + onBuilt(); + return result; + } + + @Override + public Builder clone() { + return super.clone(); + } + @Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return super.setField(field, value); + } + @Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return super.setRepeatedField(field, index, value); + } + @Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return super.addRepeatedField(field, value); + } + @Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof Payload) { + return mergeFrom((Payload)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(Payload other) { + if (other == Payload.getDefaultInstance()) return this; + if (other.hasMetadata()) { + mergeMetadata(other.getMetadata()); + } + if (other.hasBody()) { + mergeBody(other.getBody()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @Override + public final boolean isInitialized() { + return true; + } + + @Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Payload parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (Payload) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private Metadata metadata_; + private com.google.protobuf.SingleFieldBuilderV3< + Metadata, Metadata.Builder, MetadataOrBuilder> metadataBuilder_; + /** + * .Metadata metadata = 2; + * @return Whether the metadata field is set. + */ + public boolean hasMetadata() { + return metadataBuilder_ != null || metadata_ != null; + } + /** + * .Metadata metadata = 2; + * @return The metadata. + */ + public Metadata getMetadata() { + if (metadataBuilder_ == null) { + return metadata_ == null ? Metadata.getDefaultInstance() : metadata_; + } else { + return metadataBuilder_.getMessage(); + } + } + /** + * .Metadata metadata = 2; + */ + public Builder setMetadata(Metadata value) { + if (metadataBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + metadata_ = value; + onChanged(); + } else { + metadataBuilder_.setMessage(value); + } + + return this; + } + /** + * .Metadata metadata = 2; + */ + public Builder setMetadata( + Metadata.Builder builderForValue) { + if (metadataBuilder_ == null) { + metadata_ = builderForValue.build(); + onChanged(); + } else { + metadataBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .Metadata metadata = 2; + */ + public Builder mergeMetadata(Metadata value) { + if (metadataBuilder_ == null) { + if (metadata_ != null) { + metadata_ = + Metadata.newBuilder(metadata_).mergeFrom(value).buildPartial(); + } else { + metadata_ = value; + } + onChanged(); + } else { + metadataBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .Metadata metadata = 2; + */ + public Builder clearMetadata() { + if (metadataBuilder_ == null) { + metadata_ = null; + onChanged(); + } else { + metadata_ = null; + metadataBuilder_ = null; + } + + return this; + } + /** + * .Metadata metadata = 2; + */ + public Metadata.Builder getMetadataBuilder() { + + onChanged(); + return getMetadataFieldBuilder().getBuilder(); + } + /** + * .Metadata metadata = 2; + */ + public MetadataOrBuilder getMetadataOrBuilder() { + if (metadataBuilder_ != null) { + return metadataBuilder_.getMessageOrBuilder(); + } else { + return metadata_ == null ? + Metadata.getDefaultInstance() : metadata_; + } + } + /** + * .Metadata metadata = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + Metadata, Metadata.Builder, MetadataOrBuilder> + getMetadataFieldBuilder() { + if (metadataBuilder_ == null) { + metadataBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + Metadata, Metadata.Builder, MetadataOrBuilder>( + getMetadata(), + getParentForChildren(), + isClean()); + metadata_ = null; + } + return metadataBuilder_; + } + + private com.google.protobuf.Any body_; + private com.google.protobuf.SingleFieldBuilderV3< + com.google.protobuf.Any, com.google.protobuf.Any.Builder, com.google.protobuf.AnyOrBuilder> bodyBuilder_; + /** + * .google.protobuf.Any body = 3; + * @return Whether the body field is set. + */ + public boolean hasBody() { + return bodyBuilder_ != null || body_ != null; + } + /** + * .google.protobuf.Any body = 3; + * @return The body. + */ + public com.google.protobuf.Any getBody() { + if (bodyBuilder_ == null) { + return body_ == null ? com.google.protobuf.Any.getDefaultInstance() : body_; + } else { + return bodyBuilder_.getMessage(); + } + } + /** + * .google.protobuf.Any body = 3; + */ + public Builder setBody(com.google.protobuf.Any value) { + if (bodyBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + body_ = value; + onChanged(); + } else { + bodyBuilder_.setMessage(value); + } + + return this; + } + /** + * .google.protobuf.Any body = 3; + */ + public Builder setBody( + com.google.protobuf.Any.Builder builderForValue) { + if (bodyBuilder_ == null) { + body_ = builderForValue.build(); + onChanged(); + } else { + bodyBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .google.protobuf.Any body = 3; + */ + public Builder mergeBody(com.google.protobuf.Any value) { + if (bodyBuilder_ == null) { + if (body_ != null) { + body_ = + com.google.protobuf.Any.newBuilder(body_).mergeFrom(value).buildPartial(); + } else { + body_ = value; + } + onChanged(); + } else { + bodyBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .google.protobuf.Any body = 3; + */ + public Builder clearBody() { + if (bodyBuilder_ == null) { + body_ = null; + onChanged(); + } else { + body_ = null; + bodyBuilder_ = null; + } + + return this; + } + /** + * .google.protobuf.Any body = 3; + */ + public com.google.protobuf.Any.Builder getBodyBuilder() { + + onChanged(); + return getBodyFieldBuilder().getBuilder(); + } + /** + * .google.protobuf.Any body = 3; + */ + public com.google.protobuf.AnyOrBuilder getBodyOrBuilder() { + if (bodyBuilder_ != null) { + return bodyBuilder_.getMessageOrBuilder(); + } else { + return body_ == null ? + com.google.protobuf.Any.getDefaultInstance() : body_; + } + } + /** + * .google.protobuf.Any body = 3; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.google.protobuf.Any, com.google.protobuf.Any.Builder, com.google.protobuf.AnyOrBuilder> + getBodyFieldBuilder() { + if (bodyBuilder_ == null) { + bodyBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.google.protobuf.Any, com.google.protobuf.Any.Builder, com.google.protobuf.AnyOrBuilder>( + getBody(), + getParentForChildren(), + isClean()); + body_ = null; + } + return bodyBuilder_; + } + @Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Payload) + } + + // @@protoc_insertion_point(class_scope:Payload) + private static final Payload DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new Payload(); + } + + public static Payload getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @Override + public Payload parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Payload(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @Override + public Payload getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + +} + diff --git a/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/PayloadOrBuilder.java b/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/PayloadOrBuilder.java new file mode 100644 index 0000000000..77c9680200 --- /dev/null +++ b/eventmesh-common/src/main/java/org/apache/eventmesh/common/grpc/PayloadOrBuilder.java @@ -0,0 +1,37 @@ +package org.apache.eventmesh.common.grpc;// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: event_mesh_admin_service.proto + +public interface PayloadOrBuilder extends + // @@protoc_insertion_point(interface_extends:Payload) + com.google.protobuf.MessageOrBuilder { + + /** + * .Metadata metadata = 2; + * @return Whether the metadata field is set. + */ + boolean hasMetadata(); + /** + * .Metadata metadata = 2; + * @return The metadata. + */ + Metadata getMetadata(); + /** + * .Metadata metadata = 2; + */ + MetadataOrBuilder getMetadataOrBuilder(); + + /** + * .google.protobuf.Any body = 3; + * @return Whether the body field is set. + */ + boolean hasBody(); + /** + * .google.protobuf.Any body = 3; + * @return The body. + */ + com.google.protobuf.Any getBody(); + /** + * .google.protobuf.Any body = 3; + */ + com.google.protobuf.AnyOrBuilder getBodyOrBuilder(); +}