proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/gateway-component/src/main/java/org/jetlinks/community/gateway/external/DefaultMessagingManager.java
|
DefaultMessagingManager
|
subscribe
|
class DefaultMessagingManager implements MessagingManager, BeanPostProcessor {
private final Map<String, SubscriptionProvider> subProvider = new ConcurrentHashMap<>();
private final static PathMatcher matcher = new AntPathMatcher();
@Override
public Flux<Message> subscribe(SubscribeRequest request) {<FILL_FUNCTION_BODY>}
public void register(SubscriptionProvider provider) {
for (String pattern : provider.getTopicPattern()) {
subProvider.put(pattern, provider);
}
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof SubscriptionProvider) {
register(((SubscriptionProvider) bean));
}
return bean;
}
}
|
return Flux.defer(() -> {
for (Map.Entry<String, SubscriptionProvider> entry : subProvider.entrySet()) {
if (matcher.match(entry.getKey(), request.getTopic())) {
return entry.getValue()
.subscribe(request)
.map(v -> {
if (v instanceof Message) {
return ((Message) v);
}
return Message.success(request.getId(), request.getTopic(), v);
});
}
}
return Flux.error(new UnsupportedOperationException("不支持的topic"));
});
| 198
| 154
| 352
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/gateway-component/src/main/java/org/jetlinks/community/gateway/external/dashboard/DashBoardSubscriptionProvider.java
|
DashBoardSubscriptionProvider
|
subscribe
|
class DashBoardSubscriptionProvider implements SubscriptionProvider {
private final DashboardManager dashboardManager;
public DashBoardSubscriptionProvider(DashboardManager dashboardManager) {
this.dashboardManager = dashboardManager;
}
@Override
public String id() {
return "dashboard";
}
@Override
public String name() {
return "仪表盘";
}
@Override
public String[] getTopicPattern() {
return new String[]{"/dashboard/**"};
}
@Override
public Flux<Message> subscribe(SubscribeRequest request) {<FILL_FUNCTION_BODY>}
}
|
return Flux.defer(() -> {
try {
Map<String, String> variables = TopicUtils.getPathVariables(
"/dashboard/{dashboard}/{object}/{measurement}/{dimension}", request.getTopic());
return dashboardManager.getDashboard(variables.get("dashboard"))
.flatMap(dashboard -> dashboard.getObject(variables.get("object")))
.flatMap(object -> object.getMeasurement(variables.get("measurement")))
.flatMap(measurement -> measurement.getDimension(variables.get("dimension")))
.flatMapMany(dimension -> dimension.getValue(MeasurementParameter.of(request.getParameter())))
.map(val -> Message.success(request.getId(), request.getTopic(), val));
} catch (Exception e) {
return Flux.error(new IllegalArgumentException("topic格式错误,正确格式:/dashboard/{dashboard}/{object}/{measurement}/{dimension}", e));
}
});
| 171
| 265
| 436
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/gateway-component/src/main/java/org/jetlinks/community/gateway/external/socket/WebSocketMessagingHandler.java
|
WebSocketMessagingHandler
|
handle
|
class WebSocketMessagingHandler implements WebSocketHandler {
private final MessagingManager messagingManager;
private final UserTokenManager userTokenManager;
private final ReactiveAuthenticationManager authenticationManager;
// /messaging/{token}
@Override
@Nonnull
public Mono<Void> handle(@Nonnull WebSocketSession session) {<FILL_FUNCTION_BODY>}
}
|
String[] path = session.getHandshakeInfo().getUri().getPath().split("[/]");
if (path.length == 0) {
return session.send(Mono.just(session.textMessage(JSON.toJSONString(
Message.error("auth", null, "错误的请求")
)))).then(session.close(CloseStatus.BAD_DATA));
}
String token = path[path.length - 1];
Map<String, Disposable> subs = new ConcurrentHashMap<>();
return userTokenManager.getByToken(token)
.map(UserToken::getUserId)
.flatMap(authenticationManager::getByUserId)
.switchIfEmpty(session
.send(Mono.just(session.textMessage(JSON.toJSONString(
Message.authError()
))))
.then(session.close(CloseStatus.BAD_DATA))
.then(Mono.empty()))
.flatMap(auth -> session
.receive()
.doOnNext(message -> {
try {
if (message.getType() == WebSocketMessage.Type.PONG) {
return;
}
if (message.getType() == WebSocketMessage.Type.PING) {
session
.send(Mono.just(session.pongMessage(DataBufferFactory::allocateBuffer)))
.subscribe();
return;
}
MessagingRequest request = JSON.parseObject(message.getPayloadAsText(), MessagingRequest.class);
if (request == null) {
return;
}
if (request.getType() == MessagingRequest.Type.ping) {
session
.send(Mono.just(session.textMessage(JSON.toJSONString(
Message.pong(request.getId())
))))
.subscribe();
return;
}
if (StringUtils.isEmpty(request.getId())) {
session
.send(Mono.just(session.textMessage(JSON.toJSONString(
Message.error(request.getType().name(), null, "id不能为空")
)))).subscribe();
return;
}
if (request.getType() == MessagingRequest.Type.sub) {
//重复订阅
Disposable old = subs.get(request.getId());
if (old != null && !old.isDisposed()) {
return;
}
Map<String, String> context = new HashMap<>();
context.put("userId", auth.getUser().getId());
context.put("userName", auth.getUser().getName());
Disposable sub = messagingManager
.subscribe(SubscribeRequest.of(request, auth))
.doOnEach(ReactiveLogger.onError(err -> log.error("{}", err.getMessage(), err)))
.onErrorResume(err -> Mono.just(Message.error(request.getId(), request.getTopic(), err)))
.map(msg -> session.textMessage(JSON.toJSONString(msg)))
.doOnComplete(() -> {
log.debug("complete subscription:{}", request.getTopic());
subs.remove(request.getId());
Mono.just(session.textMessage(JSON.toJSONString(Message.complete(request.getId()))))
.as(session::send)
.subscribe();
})
.doOnCancel(() -> {
log.debug("cancel subscription:{}", request.getTopic());
subs.remove(request.getId());
})
.transform(session::send)
.subscriberContext(ReactiveLogger.start(context))
.subscriberContext(Context.of(Authentication.class, auth))
.subscribe();
if (!sub.isDisposed()) {
subs.put(request.getId(), sub);
}
} else if (request.getType() == MessagingRequest.Type.unsub) {
Optional.ofNullable(subs.remove(request.getId()))
.ifPresent(Disposable::dispose);
} else {
session.send(Mono.just(session.textMessage(JSON.toJSONString(
Message.error(request.getId(), request.getTopic(), "不支持的类型:" + request.getType())
)))).subscribe();
}
} catch (Exception e) {
log.warn(e.getMessage(), e);
session.send(Mono.just(session.textMessage(JSON.toJSONString(
Message.error("illegal_argument", null, "消息格式错误")
)))).subscribe();
}
})
.then())
.doFinally(r -> {
subs.values().forEach(Disposable::dispose);
subs.clear();
});
| 102
| 1,190
| 1,292
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/gateway-component/src/main/java/org/jetlinks/community/gateway/external/socket/WebSocketMessagingHandlerConfiguration.java
|
WebSocketMessagingHandlerConfiguration
|
webSocketMessagingHandlerMapping
|
class WebSocketMessagingHandlerConfiguration {
@Bean
public HandlerMapping webSocketMessagingHandlerMapping(MessagingManager messagingManager,
UserTokenManager userTokenManager,
ReactiveAuthenticationManager authenticationManager) {<FILL_FUNCTION_BODY>}
@Bean
@ConditionalOnMissingBean
public WebSocketHandlerAdapter webSocketHandlerAdapter() {
return new WebSocketHandlerAdapter();
}
}
|
WebSocketMessagingHandler messagingHandler=new WebSocketMessagingHandler(
messagingManager,
userTokenManager,
authenticationManager
);
final Map<String, WebSocketHandler> map = new HashMap<>(1);
map.put("/messaging/**", messagingHandler);
final SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();
mapping.setOrder(Ordered.HIGHEST_PRECEDENCE);
mapping.setUrlMap(map);
return mapping;
| 113
| 130
| 243
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/gateway-component/src/main/java/org/jetlinks/community/gateway/monitor/GatewayMonitors.java
|
GatewayMonitors
|
doGetDeviceGatewayMonitor
|
class GatewayMonitors {
private static final List<DeviceGatewayMonitorSupplier> deviceGatewayMonitorSuppliers = new CopyOnWriteArrayList<>();
static final NoneDeviceGatewayMonitor nonDevice = new NoneDeviceGatewayMonitor();
static {
}
public static void register(DeviceGatewayMonitorSupplier supplier) {
deviceGatewayMonitorSuppliers.add(supplier);
}
private static DeviceGatewayMonitor doGetDeviceGatewayMonitor(String id, String... tags) {<FILL_FUNCTION_BODY>}
public static DeviceGatewayMonitor getDeviceGatewayMonitor(String id, String... tags) {
return new LazyDeviceGatewayMonitor(() -> doGetDeviceGatewayMonitor(id, tags));
}
}
|
List<DeviceGatewayMonitor> all = deviceGatewayMonitorSuppliers.stream()
.map(supplier -> supplier.getDeviceGatewayMonitor(id, tags))
.filter(Objects::nonNull)
.collect(Collectors.toList());
if (all.isEmpty()) {
return nonDevice;
}
if (all.size() == 1) {
return all.get(0);
}
CompositeDeviceGatewayMonitor monitor = new CompositeDeviceGatewayMonitor();
monitor.add(all);
return monitor;
| 204
| 145
| 349
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/gateway-component/src/main/java/org/jetlinks/community/gateway/monitor/LazyDeviceGatewayMonitor.java
|
LazyDeviceGatewayMonitor
|
getTarget
|
class LazyDeviceGatewayMonitor implements DeviceGatewayMonitor {
private volatile DeviceGatewayMonitor target;
private Supplier<DeviceGatewayMonitor> monitorSupplier;
public LazyDeviceGatewayMonitor(Supplier<DeviceGatewayMonitor> monitorSupplier) {
this.monitorSupplier = monitorSupplier;
}
public DeviceGatewayMonitor getTarget() {<FILL_FUNCTION_BODY>}
@Override
public void totalConnection(long total) {
getTarget().totalConnection(total);
}
@Override
public void connected() {
getTarget().connected();
}
@Override
public void rejected() {
getTarget().rejected();
}
@Override
public void disconnected() {
getTarget().disconnected();
}
@Override
public void receivedMessage() {
getTarget().receivedMessage();
}
@Override
public void sentMessage() {
getTarget().sentMessage();
}
}
|
if (target == null) {
target = monitorSupplier.get();
}
return target;
| 259
| 30
| 289
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/gateway-component/src/main/java/org/jetlinks/community/gateway/monitor/measurements/DeviceGatewayMeasurement.java
|
HistoryDimension
|
getValue
|
class HistoryDimension implements MeasurementDimension {
@Override
public DimensionDefinition getDefinition() {
return CommonDimensionDefinition.history;
}
@Override
public DataType getValueType() {
return new IntType();
}
@Override
public ConfigMetadata getParams() {
return historyConfigMetadata;
}
@Override
public boolean isRealTime() {
return false;
}
@Override
public Flux<SimpleMeasurementValue> getValue(MeasurementParameter parameter) {<FILL_FUNCTION_BODY>}
}
|
return QueryParamEntity.newQuery()
.where("target", type)
.is("name", parameter.getString("gatewayId").orElse(null))
.doPaging(0, parameter.getInt("limit").orElse(1))
.between("timestamp",
parameter.getDate("from").orElseGet(() -> Date.from(LocalDateTime.now().plusDays(-1).atZone(ZoneId.systemDefault()).toInstant())),
parameter.getDate("to").orElseGet(Date::new)
)
.execute(timeSeriesManager.getService(GatewayTimeSeriesMetric.deviceGatewayMetric())::query)
.map(data -> SimpleMeasurementValue.of(
data.getInt(property).orElse(0),
data.getTimestamp()))
.sort(MeasurementValue.sort());
| 151
| 216
| 367
|
<methods>public void <init>(org.jetlinks.community.dashboard.MeasurementDefinition) ,public org.jetlinks.community.dashboard.supports.StaticMeasurement addDimension(org.jetlinks.community.dashboard.MeasurementDimension) ,public Mono<org.jetlinks.community.dashboard.MeasurementDimension> getDimension(java.lang.String) ,public Flux<org.jetlinks.community.dashboard.MeasurementDimension> getDimensions() <variables>private org.jetlinks.community.dashboard.MeasurementDefinition definition,private Map<java.lang.String,org.jetlinks.community.dashboard.MeasurementDimension> dimensions
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/gateway-component/src/main/java/org/jetlinks/community/gateway/spring/ProxyMessageListener.java
|
ProxyMessageListener
|
onMessage
|
class ProxyMessageListener implements MessageListener {
private final Class<?> paramType;
private final Object target;
private final ResolvableType resolvableType;
private final Method method;
private final BiFunction<Object, Object, Object> proxy;
private volatile Decoder<?> decoder;
@SuppressWarnings("all")
ProxyMessageListener(Object target, Method method) {
this.target = target;
this.method = method;
Class<?>[] parameterTypes = method.getParameterTypes();
if (parameterTypes.length > 1) {
throw new UnsupportedOperationException("unsupported method [" + method + "] parameter");
}
if (parameterTypes.length == 1) {
paramType = parameterTypes[0];
} else {
paramType = Void.class;
}
Class<?> targetType = ClassUtils.getUserClass(target);
StringJoiner code = new StringJoiner("\n");
code.add("public Object apply(Object target,Object param){");
code.add(targetType.getName() + " _target = (" + targetType.getName() + ")target;");
String invokeCode;
if (paramType != Void.class) {
code.add(paramType.getName() + " _param = (" + paramType.getName() + ")param;");
invokeCode = " _target." + method.getName() + "(_param);";
} else {
invokeCode = " _target." + method.getName() + "();";
}
if (method.getReturnType() != Void.TYPE) {
code.add("return " + invokeCode);
} else {
code.add(invokeCode)
.add("return null;");
}
code.add("}");
this.resolvableType = ResolvableType.forMethodParameter(method, 0, targetType);
this.proxy = Proxy.create(BiFunction.class)
.addMethod(code.toString())
.newInstance();
}
Object convert(TopicPayload message) {
if (Payload.class.isAssignableFrom(paramType)) {
return message;
}
try {
Payload payload = message.getPayload();
Object decodedPayload;
if (payload instanceof NativePayload) {
decodedPayload = ((NativePayload<?>) payload).getNativeObject();
} else {
if (decoder == null) {
decoder = Codecs.lookup(resolvableType);
}
decodedPayload = decoder.decode(message);
}
if (paramType.isInstance(decodedPayload)) {
return decodedPayload;
}
return FastBeanCopier.DEFAULT_CONVERT.convert(decodedPayload, paramType, resolvableType.resolveGenerics());
} finally {
message.release();
}
}
@Override
public Mono<Void> onMessage(TopicPayload message) {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return ClassUtils.getUserClass(target).getSimpleName() + "." + method.getName();
}
}
|
try {
boolean paramVoid = paramType == Void.class;
try {
Object val = proxy.apply(target, paramVoid ? null : convert(message));
if (val instanceof Publisher) {
return Mono.from((Publisher<?>) val).then();
}
return Mono.empty();
} finally {
if (paramVoid) {
message.release();
}
}
} catch (Throwable e) {
log.error("invoke event listener [{}] error", toString(), e);
}
return Mono.empty();
| 813
| 152
| 965
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/gateway-component/src/main/java/org/jetlinks/community/gateway/spring/SpringMessageBroker.java
|
SpringMessageBroker
|
postProcessAfterInitialization
|
class SpringMessageBroker implements BeanPostProcessor {
private final EventBus eventBus;
private final Environment environment;
@Override
public Object postProcessAfterInitialization(@Nonnull Object bean, @Nonnull String beanName) throws BeansException {<FILL_FUNCTION_BODY>}
protected String convertTopic(String topic) {
if (!topic.contains("${")) {
return topic;
}
return TemplateParser.parse(topic, template -> {
String[] arr = template.split(":", 2);
String property = environment.getProperty(arr[0], arr.length > 1 ? arr[1] : "");
if (StringUtils.isEmpty(property)) {
throw new IllegalArgumentException("Parse topic [" + template + "] error, can not get property : " + arr[0]);
}
return property;
});
}
}
|
Class<?> type = ClassUtils.getUserClass(bean);
ReflectionUtils.doWithMethods(type, method -> {
AnnotationAttributes subscribes = AnnotatedElementUtils.getMergedAnnotationAttributes(method, Subscribe.class);
if (CollectionUtils.isEmpty(subscribes)) {
return;
}
String id = subscribes.getString("id");
if (!StringUtils.hasText(id)) {
id = type.getSimpleName().concat(".").concat(method.getName());
}
String traceName = "/java/" + type.getSimpleName() + "/" + method.getName();
String callName = type.getSimpleName() + "." + method.getName();
Subscription subscription = Subscription
.builder()
.subscriberId("spring:" + id)
.topics(Arrays.stream(subscribes.getStringArray("value"))
.map(this::convertTopic)
.collect(Collectors.toList()))
.priority(subscribes.getNumber("priority"))
.features((Subscription.Feature[]) subscribes.get("features"))
.build();
ProxyMessageListener listener = new ProxyMessageListener(bean, method);
Consumer<Throwable> logError = error -> log.error("handle[{}] event message error : {}", listener, error.getLocalizedMessage(), error);
MonoTracer<Void> tracer = MonoTracer.create(traceName);
eventBus
.subscribe(subscription, msg -> {
try {
return listener
.onMessage(msg)
.as(tracer)
.doOnError(logError)
.checkpoint(callName);
} catch (Throwable e) {
logError.accept(e);
}
return Mono.empty();
});
});
return bean;
| 220
| 473
| 693
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/gateway-component/src/main/java/org/jetlinks/community/gateway/supports/DefaultDeviceGatewayManager.java
|
DefaultDeviceGatewayManager
|
doReload
|
class DefaultDeviceGatewayManager implements DeviceGatewayManager {
private final DeviceGatewayPropertiesManager propertiesManager;
private final Map<String, DeviceGatewayProvider> providers = new ConcurrentHashMap<>();
private final ReactiveCacheContainer<String, DeviceGateway> store = ReactiveCacheContainer.create();
private final Map<String, ChannelProvider> channels = new ConcurrentHashMap<>();
public void addChannelProvider(ChannelProvider provider) {
channels.put(provider.getChannel(), provider);
}
public void addGatewayProvider(DeviceGatewayProvider provider) {
providers.put(provider.getId(), provider);
}
public DefaultDeviceGatewayManager(DeviceGatewayPropertiesManager propertiesManager) {
this.propertiesManager = propertiesManager;
}
private Mono<DeviceGateway> doGetGateway(String id) {
if (null == id) {
return Mono.empty();
}
return store
.computeIfAbsent(id, this::createGateway);
}
protected Mono<DeviceGateway> createGateway(String id) {
return propertiesManager
.getProperties(id)
.switchIfEmpty(Mono.error(() -> new UnsupportedOperationException("网关配置[" + id + "]不存在")))
.flatMap(properties -> getProviderNow(properties.getProvider()).createDeviceGateway(properties));
}
public Mono<Void> doShutdown(String gatewayId) {
return Mono.justOrEmpty(store.remove(gatewayId))
.flatMap(DeviceGateway::shutdown)
.doOnSuccess(nil -> log.debug("shutdown device gateway {}", gatewayId))
.doOnError(err -> log.error("shutdown device gateway {} error", gatewayId, err));
}
@Override
public Mono<Void> shutdown(String gatewayId) {
return doShutdown(gatewayId);
}
public Mono<Void> doStart(String id) {
return this
.getGateway(id)
.flatMap(DeviceGateway::startup)
.doOnSuccess(nil -> log.debug("started device gateway {}", id))
.doOnError(err -> log.error("start device gateway {} error", id, err));
}
@Override
public Mono<Void> start(String gatewayId) {
return this
.doStart(gatewayId);
}
@Override
public Mono<DeviceGateway> getGateway(String id) {
return doGetGateway(id);
}
@Override
public Mono<Void> reload(String gatewayId) {
return this
.doReload(gatewayId);
}
private Mono<Void> doReload(String gatewayId) {<FILL_FUNCTION_BODY>}
@Override
public List<DeviceGatewayProvider> getProviders() {
return providers
.values()
.stream()
.sorted(Comparator.comparingInt(DeviceGatewayProvider::getOrder))
.collect(Collectors.toList());
}
@Override
public Optional<DeviceGatewayProvider> getProvider(String provider) {
return Optional.ofNullable(providers.get(provider));
}
public DeviceGatewayProvider getProviderNow(String provider) {
return DeviceGatewayProviders.getProviderNow(provider);
}
@Override
public Mono<ChannelInfo> getChannel(String channel, String channelId) {
if (!StringUtils.hasText(channel) || !StringUtils.hasText(channel)) {
return Mono.empty();
}
return Mono.justOrEmpty(channels.get(channel))
.flatMap(provider -> provider.getChannelInfo(channelId));
}
}
|
return propertiesManager
.getProperties(gatewayId)
.flatMap(prop -> {
DeviceGatewayProvider provider = this.getProviderNow(prop.getProvider());
return store
.compute(gatewayId, (id, gateway) -> {
if (gateway != null) {
log.debug("reload device gateway {} {}:{}", prop.getName(), prop.getProvider(), prop.getId());
return provider
.reloadDeviceGateway(gateway, prop)
.cast(DeviceGateway.class);
}
log.debug("create device gateway {} {}:{}", prop.getName(), prop.getProvider(), prop.getId());
return provider
.createDeviceGateway(prop)
.flatMap(newer -> newer.startup().thenReturn(newer));
});
})
.then();
| 991
| 217
| 1,208
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/gateway-component/src/main/java/org/jetlinks/community/gateway/supports/DeviceGatewayProviders.java
|
DeviceGatewayProviders
|
getProviderNow
|
class DeviceGatewayProviders {
private static final Map<String, DeviceGatewayProvider> providers = new ConcurrentHashMap<>();
public static void register(DeviceGatewayProvider provider) {
providers.put(provider.getId(), provider);
}
public static Optional<DeviceGatewayProvider> getProvider(String provider) {
return Optional.ofNullable(providers.get(provider));
}
public static DeviceGatewayProvider getProviderNow(String provider) {<FILL_FUNCTION_BODY>}
public static List<DeviceGatewayProvider> getAll() {
return new ArrayList<>(providers.values());
}
}
|
DeviceGatewayProvider gatewayProvider = providers.get(provider);
if (null == gatewayProvider) {
throw new I18nSupportException("error.unsupported_device_gateway_provider", provider);
}
return gatewayProvider;
| 167
| 63
| 230
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/io-component/src/main/java/org/jetlinks/community/io/excel/AbstractImporter.java
|
AbstractImporter
|
doImport
|
class AbstractImporter<T> {
protected final FileManager fileManager;
protected final WebClient client;
protected abstract Mono<Void> handleData(Flux<T> data);
protected abstract T newInstance();
protected void customImport(ImportHelper<T> helper) {
}
/**
* 写出导入结果文件
*
* @param fileUrl 原始导入文件地址
* @param format 原始导入文件格式
* @param buffer 结果文件流
* @return 导入结果信息
*/
protected Mono<ImportResult<T>> writeDetailFile(String fileUrl, String format, Flux<DataBuffer> buffer) {
return fileManager
.saveFile(getResultFileName(fileUrl, format), buffer, FileOption.tempFile)
.map(ImportResult::of);
}
public Flux<ImportResult<T>> doImport(String fileUrl, String format) {<FILL_FUNCTION_BODY>}
public Flux<ImportResult<T>> doImport(String fileUrl) {
return doImport(fileUrl, FileUtils.getExtension(fileUrl));
}
protected String getResultFileName(String sourceFileUrl, String format) {
return "导入结果_" + LocalDateTime
.now()
.format(DateTimeFormatter.ofPattern("yyyy_MM_dd_HH_mm_ss")) + "." + format;
}
public enum ImportResultType {
//数据
data,
//详情文件
detailFile
}
@Getter
@Setter
public static class ImportResult<T> {
@Schema(description = "导入结果类型")
private ImportResultType type;
@Schema(description = "行号,从数据的第一行为0开始")
private long row;
@Schema(description = "数据")
private T data;
@Schema(description = "是否成功")
private boolean success;
@Schema(description = "错误消息")
private String message;
@Schema(description = "导入结果详情文件地址")
private String detailFile;
public static <T> ImportResult<T> of(ImportHelper.Importing<T> importing) {
ImportResult<T> result = new ImportResult<>();
result.type = ImportResultType.data;
result.row = importing.getRow();
result.success = importing.isSuccess();
result.message = importing.getErrorMessage();
result.data = importing.getTarget();
return result;
}
public static <T> ImportResult<T> of(FileInfo fileInfo) {
ImportResult<T> result = new ImportResult<>();
result.type = ImportResultType.detailFile;
result.detailFile = fileInfo.getAccessUrl();
return result;
}
}
@SuppressWarnings("all")
protected Mono<InputStream> getInputStream(String fileUrl) {
return FileUtils.readInputStream(client, fileUrl);
}
}
|
ImportHelper<T> importHelper = new ImportHelper<>(this::newInstance, this::handleData);
customImport(importHelper);
//导入JSON
if (FORMAT_JSON.equalsIgnoreCase(format)) {
return importHelper
.doImportJson(
FileUtils.readDataBuffer(client, fileUrl),
ImportResult::of,
buf -> writeDetailFile(fileUrl, format, buf));
}
//导入EXCEL
return this
.getInputStream(fileUrl)
.flatMapMany(stream -> importHelper
.doImport(stream, format, ImportResult::of,
buf -> writeDetailFile(fileUrl, format, buf)));
| 770
| 174
| 944
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/io-component/src/main/java/org/jetlinks/community/io/excel/DefaultImportExportService.java
|
DefaultImportExportService
|
getInputStream
|
class DefaultImportExportService implements ImportExportService {
private WebClient client;
private final FileManager fileManager;
public DefaultImportExportService(WebClient.Builder builder,
FileManager fileManager) {
client = builder.build();
this.fileManager = fileManager;
}
public <T> Flux<RowResult<T>> doImport(Class<T> clazz, String fileUrl) {
return getInputStream(fileUrl)
.flatMapMany(inputStream -> ExcelReadDataListener.of(inputStream, clazz));
}
@Override
public <T> Flux<RowResult<T>> doImport(Class<T> clazz, InputStream stream) {
return ExcelReadDataListener.of(stream, clazz);
}
@Override
public <T> Flux<T> readData(String fileUrl, String fileId, RowWrapper<T> wrapper) {
if (!StringUtils.isNullOrEmpty(fileUrl)) {
return getInputStream(fileUrl)
.flatMapMany(inputStream -> read(inputStream, FileUtils.getExtension(fileUrl), wrapper));
} else {
return Mono
.zip(fileManager
.read(fileId)
.as(DataBufferUtils::join)
.map(DataBuffer::asInputStream),
fileManager.getFile(fileId))
.flatMapMany(t2 -> read(t2.getT1(), t2.getT2().getExtension(), wrapper));
}
}
public Mono<InputStream> getInputStream(String fileUrl) {<FILL_FUNCTION_BODY>}
}
|
return Mono.defer(() -> {
if (fileUrl.startsWith("http")) {
return client
.get()
.uri(fileUrl)
.accept(MediaType.APPLICATION_OCTET_STREAM)
.exchangeToMono(clientResponse -> clientResponse.bodyToMono(Resource.class))
.flatMap(resource -> Mono.fromCallable(resource::getInputStream));
} else {
return Mono.fromCallable(() -> new FileInputStream(fileUrl));
}
});
| 407
| 144
| 551
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/io-component/src/main/java/org/jetlinks/community/io/excel/converter/ArrayConverter.java
|
ArrayConverter
|
convertForRead
|
class ArrayConverter implements ConverterExcelOption{
private boolean array;
private Class<?> elementType;
private ConverterExcelOption converter;
@Override
public Object convertForWrite(Object val, ExcelHeader header) {
return String.join(",",
ConverterUtils.convertToList(val, v -> {
if (converter == null) {
return String.valueOf(v);
}
return String.valueOf(converter.convertForWrite(v, header));
}));
}
@Override
public Object convertForRead(Object cell, ExcelHeader header) {<FILL_FUNCTION_BODY>}
}
|
List<Object> list = ConverterUtils
.convertToList(cell, val -> {
if (converter != null) {
val = converter.convertForRead(val, header);
}
if (elementType.isInstance(val)) {
return val;
}
return FastBeanCopier.DEFAULT_CONVERT
.convert(val, elementType, FastBeanCopier.EMPTY_CLASS_ARRAY);
});
if (array) {
return list.toArray();
}
return list;
| 171
| 144
| 315
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/io-component/src/main/java/org/jetlinks/community/io/excel/converter/DateConverter.java
|
DateConverter
|
cell
|
class DateConverter implements ConverterExcelOption, CellOption {
private final String format;
private final Class<?> javaType;
@Override
public Object convertForWrite(Object val, ExcelHeader header) {
return new DateTime(CastUtils.castDate(val)).toString(format);
}
@Override
public Object convertForRead(Object val, ExcelHeader header) {
if (null == val) {
return null;
}
if (javaType.isInstance(val)) {
return val;
}
Date date = CastUtils.castDate(val);
if (javaType == Long.class || javaType == long.class) {
return date.getTime();
}
if (javaType == LocalDateTime.class) {
return java.time.LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
}
if (javaType == LocalDate.class) {
return java.time.LocalDateTime
.ofInstant(date.toInstant(), ZoneId.systemDefault())
.toLocalDate();
}
return date;
}
@Override
public void cell(org.apache.poi.ss.usermodel.Cell poiCell, WritableCell cell) {<FILL_FUNCTION_BODY>}
}
|
CellStyle style = poiCell.getCellStyle();
if (style == null) {
style = poiCell.getRow()
.getSheet()
.getWorkbook()
.createCellStyle();
poiCell.setCellStyle(style);
}
DataFormat dataFormat = poiCell
.getRow()
.getSheet()
.getWorkbook()
.createDataFormat();
style.setDataFormat(dataFormat.getFormat(format));
| 332
| 128
| 460
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/io-component/src/main/java/org/jetlinks/community/io/excel/converter/EnumConverter.java
|
EnumConverter
|
convertForWrite
|
class EnumConverter implements ConverterExcelOption {
@SuppressWarnings("all")
private final Class<? extends Enum> type;
@Override
public Object convertForWrite(Object val, ExcelHeader header) {<FILL_FUNCTION_BODY>}
@Override
@SuppressWarnings("all")
public Object convertForRead(Object val, ExcelHeader header) {
if (val == null) {
return null;
}
if (EnumDict.class.isAssignableFrom(type)) {
Locale locale = LocaleUtils.current();
return EnumDict
.find((Class) type, e -> {
return e.eq(val) || Objects.equals(val, e.getI18nMessage(locale));
})
.orElse(null);
}
return Enum.valueOf(type, String.valueOf(val));
}
}
|
if (val instanceof EnumDict) {
return ((EnumDict<?>) val).getI18nMessage(LocaleUtils.current());
}
if (val instanceof Enum) {
return ((Enum<?>) val).name();
}
return val;
| 236
| 76
| 312
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/io-component/src/main/java/org/jetlinks/community/io/excel/easyexcel/ExcelReadDataListener.java
|
ExcelReadDataListener
|
of
|
class ExcelReadDataListener<T> extends AnalysisEventListener<T> {
private FluxSink<RowResult<T>> sink;
public ExcelReadDataListener(FluxSink<RowResult<T>> sink) {
this.sink = sink;
}
public static <T> Flux<RowResult<T>> of(InputStream fileInputStream, Class<T> clazz) {<FILL_FUNCTION_BODY>}
@Override
public void onException(Exception exception, AnalysisContext context) {
sink.error(exception);
}
/**
* 这个每一条数据解析都会来调用
*/
@Override
public void invoke(T data, AnalysisContext analysisContext) {
RowResult<T> result=new RowResult<>();
result.setResult(data);
result.setRowIndex(analysisContext.readRowHolder().getRowIndex());
sink.next(result);
}
@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
sink.complete();
}
@Override
public boolean hasNext(AnalysisContext context) {
return !sink.isCancelled();
}
}
|
return Flux.create(sink -> {
EasyExcel.read(fileInputStream, clazz, new ExcelReadDataListener<>(sink)).sheet().doRead();
});
| 301
| 48
| 349
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/io-component/src/main/java/org/jetlinks/community/io/file/FileEntity.java
|
FileEntity
|
of
|
class FileEntity extends GenericEntity<String> implements RecordCreationEntity {
@Column(nullable = false)
private String name;
@Column(nullable = false)
private String extension;
@Column(nullable = false)
private Long length;
@Column(nullable = false, length = 32)
private String md5;
@Column(nullable = false, length = 64)
private String sha256;
@Column(nullable = false)
@DefaultValue(generator = Generators.CURRENT_TIME)
private Long createTime;
@Column(length = 64)
private String creatorId;
@Column(length = 64, nullable = false)
private String serverNodeId;
@Column(length = 512, nullable = false)
private String storagePath;
@Column
@EnumCodec(toMask = true)
@ColumnType(jdbcType = JDBCType.BIGINT, javaType = Long.class)
private FileOption[] options;
@Column
@JsonCodec
@ColumnType(jdbcType = JDBCType.LONGVARCHAR, javaType = String.class)
private Map<String, Object> others;
public FileInfo toInfo() {
return copyTo(new FileInfo());
}
public static FileEntity of(FileInfo fileInfo,String storagePath,String serverNodeId) {<FILL_FUNCTION_BODY>}
}
|
FileEntity fileEntity = new FileEntity().copyFrom(fileInfo);
fileEntity.setStoragePath(storagePath);
fileEntity.setServerNodeId(serverNodeId);
return fileEntity;
| 380
| 52
| 432
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/io-component/src/main/java/org/jetlinks/community/io/file/FileInfo.java
|
FileInfo
|
hasOption
|
class FileInfo {
public static final String OTHER_ACCESS_KEY = "accessKey";
private String id;
private String name;
private String extension;
private long length;
private String md5;
private String sha256;
private long createTime;
private String creatorId;
private FileOption[] options;
private Map<String, Object> others;
private String accessUrl;
public void withBasePath(String apiBashPath) {
if (!apiBashPath.endsWith("/")) {
apiBashPath = apiBashPath + "/";
}
accessUrl = apiBashPath + "file/" + id + "." + extension + "?accessKey=" + accessKey().orElse("");
}
public MediaType mediaType() {
return FileUtils.getMediaTypeByExtension(extension);
}
public boolean hasOption(FileOption option) {<FILL_FUNCTION_BODY>}
public FileInfo withFileName(String fileName) {
name = fileName;
extension = FilenameUtils.getExtension(fileName);
return this;
}
public synchronized FileInfo withOther(String key, Object value) {
if (others == null) {
others = new HashMap<>();
}
others.put(key, value);
return this;
}
public FileInfo withAccessKey(String accessKey) {
withOther(OTHER_ACCESS_KEY, accessKey);
return this;
}
public Optional<String> accessKey() {
return Optional
.ofNullable(others)
.map(map -> map.get(OTHER_ACCESS_KEY))
.map(String::valueOf)
.filter(StringUtils::hasText);
}
}
|
if (options == null) {
return false;
}
for (FileOption fileOption : options) {
if (fileOption == option) {
return true;
}
}
return false;
| 467
| 58
| 525
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/io-component/src/main/java/org/jetlinks/community/io/file/FileManagerStorageService.java
|
FileManagerStorageService
|
saveFile
|
class FileManagerStorageService implements FileStorageService {
private final FileManager fileManager;
@Override
public Mono<String> saveFile(FilePart filePart) {
return fileManager
.saveFile(filePart, FileOption.publicAccess)
.map(FileInfo::getAccessUrl);
}
@Override
public Mono<String> saveFile(InputStream inputStream, String fileType) {<FILL_FUNCTION_BODY>}
}
|
return fileManager
.saveFile(IDGenerator.RANDOM.generate() + "." + fileType,
DataBufferUtils
.readInputStream(
() -> inputStream,
DefaultDataBufferFactory.sharedInstance,
64 * 1024)
.subscribeOn(Schedulers.boundedElastic()),
FileOption.publicAccess)
.map(FileInfo::getAccessUrl);
| 118
| 104
| 222
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/io-component/src/main/java/org/jetlinks/community/io/file/web/FileManagerController.java
|
FileManagerController
|
read
|
class FileManagerController {
private final FileManager fileManager;
@PostMapping("/upload")
@Authorize(merge = false)
@Operation(summary = "上传文件")
public Mono<FileInfo> upload(@RequestPart("file") Mono<FilePart> partMono) {
return partMono.flatMap(fileManager::saveFile);
}
@GetMapping("/{fileId}")
@Authorize(ignore = true)
@Operation(summary = "获取文件")
public Mono<Void> read(@PathVariable String fileId,
ServerWebExchange exchange) {<FILL_FUNCTION_BODY>}
@DeleteMapping("/{fileId}")
@DeleteAction
@Operation(summary = "删除文件")
public Mono<Integer> delete(@PathVariable String fileId) {
return fileManager
.delete(fileId);
}
}
|
if (fileId.contains(".")) {
fileId = fileId.substring(0, fileId.indexOf("."));
}
return exchange
.getResponse()
.writeWith(fileManager
.read(fileId, ctx -> {
Mono<Void> before;
//不是公开访问则需要登陆或者使用accessKey
if (!ctx.info().hasOption(FileOption.publicAccess)) {
String key = exchange.getRequest().getQueryParams().getFirst("accessKey");
//请求参数没有accessKey则校验当前用户是否登陆
if (!StringUtils.hasText(key)) {
before = Authentication
.currentReactive()
.switchIfEmpty(Mono.error(AccessDenyException::new))
.then();
} else {
//校验accessKey
if (ctx.info().accessKey().map(key::equalsIgnoreCase).orElse(false)) {
before = Mono.empty();
} else {
before = Mono.error(AccessDenyException::new);
}
}
} else {
before = Mono.empty();
}
return before.then(
Mono.fromRunnable(() -> {
List<HttpRange> ranges = exchange
.getRequest()
.getHeaders()
.getRange();
long position = 0;
if (ranges.size() != 0) {
position = ranges.get(0).getRangeStart(ctx.info().getLength());
}
ctx.position(position);
MediaType mediaType = ctx.info().mediaType();
exchange.getResponse().getHeaders().setContentType(mediaType);
exchange.getResponse().getHeaders().setContentLength(ctx.info().getLength());
exchange.getResponse().getHeaders().add("file-md5", ctx.info().getMd5());
exchange.getResponse().getHeaders().add("file-sha256", ctx.info().getSha256());
//文件流时下载文件
if (mediaType.includes(MediaType.APPLICATION_OCTET_STREAM)) {
exchange.getResponse().getHeaders().setContentDisposition(
ContentDisposition
.builder("attachment")
.filename(ctx.info().getName(), StandardCharsets.UTF_8)
.build()
);
}
})
);
}));
| 229
| 618
| 847
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/io-component/src/main/java/org/jetlinks/community/io/utils/FileUtils.java
|
FileUtils
|
dataBufferToInputStream
|
class FileUtils {
public static String getExtension(String url) {
url = HttpUtils.urlDecode(url);
if (url.contains("?")) {
url = url.substring(0, url.lastIndexOf("?"));
}
if (url.contains("#")) {
url = url.substring(0, url.lastIndexOf("#"));
}
return FilenameUtils.getExtension(url);
}
public static String getFileName(String url) {
url = HttpUtils.urlDecode(url);
if (url.contains("?")) {
url = url.substring(0, url.lastIndexOf("?"));
}
if (url.contains("#")) {
url = url.substring(0, url.lastIndexOf("#"));
}
return url.substring(url.lastIndexOf("/") + 1);
}
public static MediaType getMediaTypeByName(String name) {
return getMediaTypeByExtension(FilenameUtils.getExtension(name));
}
/**
* 根据文件拓展名获取MediaType
*
* @param extension extension
* @return MediaType
*/
public static MediaType getMediaTypeByExtension(String extension) {
if (!StringUtils.hasText(extension)) {
return MediaType.APPLICATION_OCTET_STREAM;
}
switch (extension.toLowerCase()) {
case "jpg":
case "jpeg":
return MediaType.IMAGE_JPEG;
case "png":
return MediaType.IMAGE_PNG;
case "gif":
return MediaType.IMAGE_GIF;
case "svg":
return MediaType.parseMediaType("image/svg+xml");
case "tiff":
case "tif":
return MediaType.parseMediaType("image/tiff");
case "webp":
return MediaType.parseMediaType("image/webp");
case "mp4":
return MediaType.parseMediaType("video/mp4");
case "flv":
return MediaType.parseMediaType("video/x-flv");
case "text":
case "txt":
return MediaType.TEXT_PLAIN;
case "html":
return MediaType.TEXT_HTML;
case "md":
return MediaType.TEXT_MARKDOWN;
case "css":
return MediaType.parseMediaType("text/css");
case "js":
return MediaType.parseMediaType("text/javascript");
case "xml":
return MediaType.TEXT_XML;
case "json":
return MediaType.APPLICATION_JSON;
case "pdf":
return MediaType.APPLICATION_PDF;
default:
return MediaType.APPLICATION_OCTET_STREAM;
}
}
public static Mono<InputStream> dataBufferToInputStream(Flux<DataBuffer> dataBufferFlux) {<FILL_FUNCTION_BODY>}
public static Flux<DataBuffer> readDataBuffer(WebClient client,
String fileUrl) {
if (fileUrl.startsWith("http")) {
return client
.get()
.uri(fileUrl)
.accept(MediaType.APPLICATION_OCTET_STREAM)
.retrieve()
.bodyToFlux(DataBuffer.class);
} else {
return DataBufferUtils.readInputStream(
() -> Files.newInputStream(Paths.get(fileUrl)),
new NettyDataBufferFactory(ByteBufAllocator.DEFAULT),
256 * 1024);
}
}
public static Mono<InputStream> readInputStream(WebClient client,
String fileUrl) {
return Mono.defer(() -> {
if (fileUrl.startsWith("http")) {
return client
.get()
.uri(fileUrl)
.accept(MediaType.APPLICATION_OCTET_STREAM)
.exchangeToMono(clientResponse -> clientResponse.bodyToMono(Resource.class))
.flatMap(resource -> Mono.fromCallable(resource::getInputStream));
} else {
return Mono.fromCallable(() -> new FileInputStream(fileUrl));
}
});
}
}
|
NettyDataBufferFactory factory = new NettyDataBufferFactory(ByteBufAllocator.DEFAULT);
return DataBufferUtils
.join(dataBufferFlux
.map(buffer -> {
if (buffer instanceof NettyDataBuffer) {
return buffer;
}
try {
return factory.wrap(buffer.asByteBuffer());
} finally {
DataBufferUtils.release(buffer);
}
}))
.map(buffer -> buffer.asInputStream(true));
| 1,091
| 126
| 1,217
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/logging-component/src/main/java/org/jetlinks/community/logging/access/AccessLoggingTranslator.java
|
AccessLoggingTranslator
|
translate
|
class AccessLoggingTranslator {
private final ApplicationEventPublisher eventPublisher;
private final LoggingProperties properties;
public AccessLoggingTranslator(ApplicationEventPublisher eventPublisher, LoggingProperties properties) {
this.eventPublisher = eventPublisher;
this.properties = properties;
}
@EventListener
public void translate(AccessLoggerAfterEvent event) {<FILL_FUNCTION_BODY>}
}
|
for (String pathExclude : properties.getAccess().getPathExcludes()) {
if (TopicUtils.match(pathExclude, event.getLogger().getUrl())) {
return;
}
}
eventPublisher.publishEvent(SerializableAccessLog.of(event.getLogger()));
| 113
| 78
| 191
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/logging-component/src/main/java/org/jetlinks/community/logging/access/SerializableAccessLog.java
|
SerializableAccessLog
|
of
|
class SerializableAccessLog implements Serializable {
/**
* 日志id
*/
@Schema(description = "日志ID")
private String id;
/**
* 访问的操作
*
* @see AccessLogger#value()
*/
@Schema(description = "操作")
private String action;
/**
* 描述
*
* @see AccessLogger#describe()
*/
@Schema(description = "描述")
private String describe;
/**
* 访问对应的java方法
*/
@Schema(description = "请求方法名")
private String method;
/**
* 访问对应的java类
*/
@Schema(description = "请求类")
private String target;
/**
* 请求的参数,参数为java方法的参数而不是http参数,key为参数名,value为参数值.
*/
@Schema(description = "请求参数")
private Map<String, Object> parameters;
/**
* 请求者ip地址
*/
@Schema(description = "请求中IP")
private String ip;
/**
* 请求的url地址
*/
@Schema(description = "请求地址")
private String url;
/**
* http 请求头集合
*/
@Schema(description = "请求头")
private Map<String, String> httpHeaders = new HashMap<>();
@Schema(description = "上下文")
private Map<String, String> context = new HashMap<>();
/**
* http 请求方法, GET,POST...
*/
@Schema(description = "请求方法")
private String httpMethod;
/**
* 响应结果,方法的返回值
*/
//private Object response;
/**
* 请求时间戳
*
* @see System#currentTimeMillis()
*/
@Schema(description = "请求时间")
private long requestTime;
/**
* 响应时间戳
*
* @see System#currentTimeMillis()
*/
@Schema(description = "响应时间")
private long responseTime;
/**
* 异常信息,请求对应方法抛出的异常
*/
@Schema(description = "异常栈信息")
private String exception;
public static SerializableAccessLog of(AccessLoggerInfo info) {<FILL_FUNCTION_BODY>}
}
|
SerializableAccessLog accessLog = FastBeanCopier.copy(info, new SerializableAccessLog(), "parameters", "method", "target", "exception");
accessLog.setMethod(info.getMethod().getName());
accessLog.setTarget(info.getTarget().getName());
//移除敏感请求头
accessLog.getHttpHeaders().remove("X_Access_Token");
accessLog.getHttpHeaders().remove(HttpHeaders.AUTHORIZATION);
accessLog.setException(info.getException() == null ? ""
: StringUtils.throwable2String(info.getException()));
Map<String, Object> newParameter = info.getParameters()
.entrySet()
.stream()
.collect(Collectors.toMap(Map.Entry::getKey, e -> {
Object value = e.getValue();
if (value instanceof FilePart) {
return ("file:") + ((FilePart) value).filename();
}
String className = value.getClass().getName();
if (className.startsWith("org.springframework")) {
return className;
}
return JSON.toJSONString(value);
}));
accessLog.setParameters(newParameter);
return accessLog;
| 628
| 305
| 933
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/logging-component/src/main/java/org/jetlinks/community/logging/event/handler/SystemLoggerEventHandler.java
|
SystemLoggerEventHandler
|
acceptAccessLoggerInfo
|
class SystemLoggerEventHandler {
private final EventBus eventBus;
private final ElasticSearchService elasticSearchService;
public SystemLoggerEventHandler(ElasticSearchService elasticSearchService,
ElasticSearchIndexManager indexManager,
EventBus eventBus) {
this.elasticSearchService = elasticSearchService;
this.eventBus = eventBus;
indexManager.putIndex(
new DefaultElasticSearchIndexMetadata(LoggerIndexProvider.SYSTEM.getIndex())
.addProperty("createTime", new DateTimeType())
.addProperty("name", new StringType())
.addProperty("level", new StringType())
.addProperty("message", new StringType())
.addProperty("className",new StringType())
.addProperty("exceptionStack",new StringType())
.addProperty("methodName",new StringType())
.addProperty("threadId",new StringType())
.addProperty("threadName",new StringType())
.addProperty("id",new StringType())
.addProperty("context", new ObjectType()
.addProperty("requestId",new StringType())
.addProperty("server",new StringType()))
).subscribe();
}
@EventListener
public void acceptAccessLoggerInfo(SerializableSystemLog info) {<FILL_FUNCTION_BODY>}
}
|
eventBus
.publish("/logging/system/" + info.getName().replace(".", "/") + "/" + (info.getLevel().toLowerCase()), info)
.subscribe();
elasticSearchService.commit(LoggerIndexProvider.SYSTEM, Mono.just(info))
.subscribe();
| 322
| 75
| 397
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/logging-component/src/main/java/org/jetlinks/community/logging/logback/SystemLoggingAppender.java
|
SystemLoggingAppender
|
append
|
class SystemLoggingAppender extends UnsynchronizedAppenderBase<ILoggingEvent> {
public static ApplicationEventPublisher publisher;
public static final Map<String, String> staticContext = new ConcurrentHashMap<>();
@Override
protected void append(ILoggingEvent event) {<FILL_FUNCTION_BODY>}
}
|
if (publisher == null) {
return;
}
StackTraceElement element = event.getCallerData()[0];
IThrowableProxy proxies = event.getThrowableProxy();
String message = event.getFormattedMessage();
String stack;
StringJoiner joiner = new StringJoiner("\n", message + "\n[", "]");
Queue<IThrowableProxy> queue = new LinkedList<>();
queue.add(proxies);
while (queue.size() > 0) {
IThrowableProxy proxy = queue.poll();
if(proxy==null){
break;
}
int commonFrames = proxy.getCommonFrames();
StackTraceElementProxy[] stepArray = proxy.getStackTraceElementProxyArray();
StringBuilder stringBuilder = new StringBuilder();
ThrowableProxyUtil.subjoinFirstLine(stringBuilder, proxy);
joiner.add(stringBuilder);
for (int i = 0; i < stepArray.length - commonFrames; i++) {
StringBuilder sb = new StringBuilder();
sb.append(CoreConstants.TAB);
ThrowableProxyUtil.subjoinSTEP(sb, stepArray[i]);
joiner.add(sb);
}
queue.addAll(Arrays.asList(proxy.getSuppressed()));
}
stack = joiner.toString();
try {
String gitLocation = null;
String mavenModule = null;
try {
Class<?> clazz = Class.forName(element.getClassName());
ModuleUtils.ModuleInfo moduleInfo = ModuleUtils.getModuleByClass(clazz);
if (!StringUtils.isEmpty(moduleInfo.getGitRepository())) {
StringBuilder javaSb = new StringBuilder();
javaSb.append(moduleInfo.getGitLocation());
javaSb.append("src/main/java/");
javaSb.append((ClassUtils.getPackageName(Class.forName(element.getClassName())).replace(".", "/")));
javaSb.append("/");
javaSb.append(Class.forName(element.getClassName()).getSimpleName());
javaSb.append(".java#L");
javaSb.append(element.getLineNumber());
gitLocation = javaSb.toString();
}
mavenModule = moduleInfo.getArtifactId();
} catch (Exception ignore) {
}
Map<String, String> context = new HashMap<>(staticContext);
Map<String, String> mdc = MDC.getCopyOfContextMap();
if (mdc != null) {
context.putAll(mdc);
}
SerializableSystemLog info = SerializableSystemLog.builder()
.id(IDGenerator.SNOW_FLAKE_STRING.generate())
.mavenModule(mavenModule)
.context(context)
.name(event.getLoggerName())
.level(event.getLevel().levelStr)
.className(element.getClassName())
.methodName(element.getMethodName())
.lineNumber(element.getLineNumber())
.exceptionStack(stack)
.java(gitLocation)
.threadName(event.getThreadName())
.createTime(event.getTimeStamp())
.message(message)
.threadId(String.valueOf(Thread.currentThread().getId()))
.build();
try {
publisher.publishEvent(info);
} catch (Exception ignore) {
}
} catch (Exception e) {
log.error("组装系统日志错误", e);
}
| 87
| 898
| 985
|
<methods>public void <init>() ,public void addFilter(Filter<ch.qos.logback.classic.spi.ILoggingEvent>) ,public void clearAllFilters() ,public void doAppend(ch.qos.logback.classic.spi.ILoggingEvent) ,public List<Filter<ch.qos.logback.classic.spi.ILoggingEvent>> getCopyOfAttachedFiltersList() ,public ch.qos.logback.core.spi.FilterReply getFilterChainDecision(ch.qos.logback.classic.spi.ILoggingEvent) ,public java.lang.String getName() ,public boolean isStarted() ,public void setName(java.lang.String) ,public void start() ,public void stop() ,public java.lang.String toString() <variables>static final int ALLOWED_REPEATS,private int exceptionCount,private FilterAttachableImpl<ch.qos.logback.classic.spi.ILoggingEvent> fai,private ThreadLocal<java.lang.Boolean> guard,protected java.lang.String name,protected boolean started,private int statusRepeatCount
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/http-component/src/main/java/org/jetlinks/community/network/http/DefaultHttpRequestMessage.java
|
DefaultHttpRequestMessage
|
setBody
|
class DefaultHttpRequestMessage implements HttpRequestMessage {
//消息体
private ByteBuf payload;
private String url;
//请求方法
private HttpMethod method;
//请求头
private List<Header> headers = new ArrayList<>();
//参数
private Map<String, String> queryParameters = new HashMap<>();
//请求类型
private MediaType contentType;
private MultiPart multiPart;
@Override
public Optional<MultiPart> multiPart() {
return Optional
.ofNullable(multiPart)
.filter(part -> part.getParts().size() > 0);
}
public void setBody(Object body) {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return print();
}
}
|
if (body instanceof ByteBuf) {
setPayload(((ByteBuf) body));
} else if (body instanceof String) {
setPayload(Unpooled.wrappedBuffer(((String) body).getBytes()));
} else if (body instanceof byte[]) {
setPayload(Unpooled.wrappedBuffer(((byte[]) body)));
} else if (MediaType.APPLICATION_JSON.includes(getContentType())) {
setPayload(Unpooled.wrappedBuffer(JSON.toJSONBytes(body)));
} else if (MediaType.APPLICATION_FORM_URLENCODED.includes(getContentType()) && body instanceof Map) {
setPayload(Unpooled.wrappedBuffer(HttpUtils.createEncodedUrlParams(((Map<?, ?>) body)).getBytes()));
} else if (body != null) {
setPayload(Unpooled.wrappedBuffer(JSON.toJSONBytes(body)));
} else {
setPayload(Unpooled.EMPTY_BUFFER);
}
| 207
| 261
| 468
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/http-component/src/main/java/org/jetlinks/community/network/http/VertxWebUtils.java
|
VertxWebUtils
|
getIpAddr
|
class VertxWebUtils {
static final String[] ipHeaders = {
"X-Forwarded-For",
"X-Real-IP",
"Proxy-Client-IP",
"WL-Proxy-Client-IP"
};
/**
* 获取请求客户端的真实ip地址
*
* @param request 请求对象
* @return ip地址
*/
public static String getIpAddr(HttpServerRequest request) {<FILL_FUNCTION_BODY>}
}
|
for (String ipHeader : ipHeaders) {
String ip = request.getHeader(ipHeader);
if (!StringUtils.isEmpty(ip) && !ip.contains("unknown")) {
return ip;
}
}
return Optional.ofNullable(request.remoteAddress())
.map(SocketAddress::host)
.orElse("unknown");
| 131
| 91
| 222
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/http-component/src/main/java/org/jetlinks/community/network/http/device/AsyncHttpExchangeMessage.java
|
AsyncHttpExchangeMessage
|
print
|
class AsyncHttpExchangeMessage implements HttpExchangeMessage {
private static final AtomicReferenceFieldUpdater<AsyncHttpExchangeMessage, Boolean>
RESPONDED = AtomicReferenceFieldUpdater.newUpdater(AsyncHttpExchangeMessage.class, Boolean.class, "responded");
private final HttpExchange exchange;
private volatile Boolean responded = false;
public AsyncHttpExchangeMessage(HttpExchange exchange) {
this.exchange = exchange;
}
@Nonnull
@Override
public Mono<Void> response(@Nonnull HttpResponseMessage message) {
return Mono
.defer(() -> {
if (!RESPONDED.getAndSet(this, true) && !exchange.isClosed()) {
if (log.isDebugEnabled()) {
log.debug("响应HTTP请求:\n{}", message.print());
}
return exchange.response(message);
}
return Mono.empty();
});
}
@Override
public Mono<ByteBuf> payload() {
return exchange
.request()
.getBody();
}
@Nonnull
@Override
public String getUrl() {
return exchange.request().getUrl();
}
@Nonnull
@Override
public HttpMethod getMethod() {
return exchange.request().getMethod();
}
@Nullable
@Override
public MediaType getContentType() {
return exchange.request().getContentType();
}
@Nonnull
@Override
public List<Header> getHeaders() {
return exchange.request().getHeaders();
}
@Nullable
@Override
public Map<String, String> getQueryParameters() {
return exchange.request().getQueryParameters();
}
@Override
public Mono<MultiPart> multiPartAsync() {
return exchange.request().multiPart();
}
@Override
@Deprecated
@Nonnull
public Optional<MultiPart> multiPart() {
//log.warn("该方法已过时,请使用multiPartAsync()方法替代");
return Optional.ofNullable(
multiPartAsync()
.toFuture()
.getNow(null)
);
}
@Nonnull
@Override
public ByteBuf getPayload() {
//log.warn("该方法已过时,请使用payload()方法替代");
return payload()
.toFuture()
.getNow(Unpooled.EMPTY_BUFFER);
}
@Override
public String toString() {
return print();
}
@Override
public String print() {<FILL_FUNCTION_BODY>}
}
|
StringBuilder builder = new StringBuilder();
builder.append(getMethod()).append(" ").append(getPath());
if (!CollectionUtils.isEmpty(getQueryParameters())) {
builder.append("?")
.append(getQueryParameters()
.entrySet().stream()
.map(e -> e.getKey().concat("=").concat(e.getValue()))
.collect(Collectors.joining("&")))
.append("\n");
} else {
builder.append("\n");
}
for (Header header : getHeaders()) {
builder
.append(header.getName()).append(": ").append(String.join(",", header.getValue()))
.append("\n");
}
if (MultiPart.isMultiPart(getContentType())) {
MultiPart multiPart = multiPartAsync()
.toFuture()
.getNow(null);
builder.append("\n");
if (multiPart != null) {
builder.append("\n");
for (Part part : multiPart.getParts()) {
builder.append(part).append("\n");
}
} else {
builder.append("\n")
.append("<unread multiPart>\n");
}
} else if (getMethod() != HttpMethod.GET && getMethod() != HttpMethod.DELETE) {
ByteBuf payload = payload().toFuture().getNow(null);
if (payload == null) {
return builder.append("\n")
.append("<unread payload>\n")
.toString();
}
if(payload.refCnt()==0){
return builder.append("\n")
.append("<payload released>\n")
.toString();
}
if (payload.readableBytes() == 0) {
return builder.toString();
}
builder.append("\n");
if (ByteBufUtil.isText(payload, StandardCharsets.UTF_8)) {
builder.append(payload.toString(StandardCharsets.UTF_8));
} else {
ByteBufUtil.appendPrettyHexDump(builder, payload);
}
}
return builder.toString();
| 689
| 549
| 1,238
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/http-component/src/main/java/org/jetlinks/community/network/http/device/HttpDeviceSession.java
|
HttpDeviceSession
|
send
|
class HttpDeviceSession implements DeviceSession {
private final DeviceOperator operator;
private final InetSocketAddress address;
@Setter
private WebSocketExchange websocket;
private long lastPingTime = System.currentTimeMillis();
//默认永不超时
private long keepAliveTimeOutMs = -1;
public HttpDeviceSession(DeviceOperator deviceOperator, InetSocketAddress address) {
this.operator = deviceOperator;
this.address = address;
}
@Override
public String getId() {
return operator.getDeviceId();
}
@Override
public String getDeviceId() {
return operator.getDeviceId();
}
@Nullable
@Override
public DeviceOperator getOperator() {
return operator;
}
@Override
public long lastPingTime() {
return lastPingTime;
}
@Override
public long connectTime() {
return lastPingTime;
}
@Override
public Mono<Boolean> send(EncodedMessage encodedMessage) {<FILL_FUNCTION_BODY>}
@Override
public Transport getTransport() {
return DefaultTransport.HTTP;
}
@Override
public Optional<InetSocketAddress> getClientAddress() {
return Optional.ofNullable(address);
}
@Override
public void close() {
}
@Override
public void setKeepAliveTimeout(Duration timeout) {
keepAliveTimeOutMs = timeout.toMillis();
}
@Override
public void ping() {
lastPingTime = System.currentTimeMillis();
}
@Override
public boolean isAlive() {
return keepAliveTimeOutMs <= 0
|| System.currentTimeMillis() - lastPingTime < keepAliveTimeOutMs;
}
@Override
public void onClose(Runnable call) {
}
}
|
if(websocket==null){
return Reactors.ALWAYS_FALSE;
}
if (encodedMessage instanceof WebSocketMessage) {
return websocket
.send(((WebSocketMessage) encodedMessage))
.thenReturn(true);
} else {
return websocket
.send(DefaultWebSocketMessage.of(WebSocketMessage.Type.TEXT, encodedMessage.getPayload()))
.thenReturn(true);
}
| 494
| 116
| 610
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/http-component/src/main/java/org/jetlinks/community/network/http/device/HttpServerDeviceGatewayProvider.java
|
HttpServerDeviceGatewayProvider
|
reloadDeviceGateway
|
class HttpServerDeviceGatewayProvider implements DeviceGatewayProvider {
private final NetworkManager networkManager;
private final DeviceRegistry registry;
private final DeviceSessionManager sessionManager;
private final DecodedClientMessageHandler clientMessageHandler;
private final ProtocolSupports protocolSupports;
public HttpServerDeviceGatewayProvider(NetworkManager networkManager,
DeviceRegistry registry,
DeviceSessionManager sessionManager,
DecodedClientMessageHandler clientMessageHandler,
ProtocolSupports protocolSupports) {
this.networkManager = networkManager;
this.registry = registry;
this.sessionManager = sessionManager;
this.clientMessageHandler = clientMessageHandler;
this.protocolSupports = protocolSupports;
}
@Override
public String getId() {
return "http-server-gateway";
}
@Override
public String getName() {
return "HTTP 推送接入";
}
@Override
public Transport getTransport() {
return DefaultTransport.HTTP;
}
@Override
public Mono<DeviceGateway> createDeviceGateway(DeviceGatewayProperties properties) {
return networkManager
.<HttpServer>getNetwork(DefaultNetworkType.HTTP_SERVER, properties.getChannelId())
.map(server -> {
String protocol = properties.getProtocol();
return new HttpServerDeviceGateway(properties.getId(),
server,
Mono.defer(()->protocolSupports.getProtocol(protocol)),
sessionManager,
registry,
clientMessageHandler);
});
}
@Override
public Mono<? extends DeviceGateway> reloadDeviceGateway(DeviceGateway gateway,
DeviceGatewayProperties properties) {<FILL_FUNCTION_BODY>}
@Getter
@Setter
public static class RouteConfig {
private String url;
private String protocol;
}
}
|
HttpServerDeviceGateway deviceGateway = ((HttpServerDeviceGateway) gateway);
String networkId = properties.getChannelId();
//网络组件发生了变化
if(!Objects.equals(networkId, deviceGateway.httpServer.getId())){
return gateway
.shutdown()
.then(this
.createDeviceGateway(properties)
.flatMap(gate -> gate.startup().thenReturn(gate)));
}
//更新协议包
deviceGateway.setProtocol(protocolSupports.getProtocol(properties.getProtocol()));
return deviceGateway
.reload()
.thenReturn(deviceGateway);
| 495
| 170
| 665
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/http-component/src/main/java/org/jetlinks/community/network/http/device/HttpServerExchangeMessage.java
|
HttpServerExchangeMessage
|
response
|
class HttpServerExchangeMessage implements HttpExchangeMessage {
AtomicReference<Boolean> responded = new AtomicReference<>(false);
MultiPart multiPart;
public HttpServerExchangeMessage(HttpExchange exchange,
ByteBuf payload,
MultiPart multiPart) {
this.exchange = exchange;
this.payload = payload;
this.multiPart = multiPart;
}
private final HttpExchange exchange;
private final ByteBuf payload;
@Nonnull
@Override
public Mono<Void> response(@Nonnull HttpResponseMessage message) {<FILL_FUNCTION_BODY>}
@Override
public Optional<MultiPart> multiPart() {
return Optional
.ofNullable(multiPart)
.filter(part -> part.getParts().size() > 0);
}
@Nonnull
@Override
public String getUrl() {
return exchange.request().getUrl();
}
@Nonnull
@Override
public HttpMethod getMethod() {
return exchange.request().getMethod();
}
@Nullable
@Override
public MediaType getContentType() {
return exchange.request().getContentType();
}
@Nonnull
@Override
public List<Header> getHeaders() {
return exchange.request().getHeaders();
}
@Nullable
@Override
public Map<String, String> getQueryParameters() {
return exchange.request().getQueryParameters();
}
@Nonnull
@Override
public ByteBuf getPayload() {
return payload;
}
@Override
public String toString() {
return print();
}
}
|
return Mono
.defer(() -> {
if (!responded.getAndSet(true) && !exchange.isClosed()) {
if (log.isDebugEnabled()) {
log.debug("响应HTTP请求:\n{}", message.print());
}
return exchange.response(message);
}
return Mono.empty();
});
| 430
| 95
| 525
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/http-component/src/main/java/org/jetlinks/community/network/http/device/WebSocketDeviceSession.java
|
WebSocketDeviceSession
|
copy
|
class WebSocketDeviceSession implements DeviceSession {
@Getter
@Setter
private volatile DeviceOperator operator;
@Setter
private WebSocketExchange exchange;
private final long connectTime = System.currentTimeMillis();
private Duration keepAliveTimeout;
public WebSocketDeviceSession(DeviceOperator device, WebSocketExchange exchange) {
this.operator = device;
this.exchange = exchange;
}
@Override
public String getId() {
return getDeviceId();
}
@Override
public String getDeviceId() {
return operator == null ? "unknown" : operator.getDeviceId();
}
@Override
public long lastPingTime() {
return exchange.getLastKeepAliveTime();
}
@Override
public long connectTime() {
return connectTime;
}
@Override
public Mono<Boolean> send(EncodedMessage encodedMessage) {
if (encodedMessage instanceof WebSocketMessage) {
return exchange
.send(((WebSocketMessage) encodedMessage))
.thenReturn(true);
} else {
return exchange
.send(DefaultWebSocketMessage.of(WebSocketMessage.Type.TEXT, encodedMessage.getPayload()))
.thenReturn(true);
}
}
@Override
public Transport getTransport() {
return DefaultTransport.WebSocket;
}
@Override
public void close() {
exchange.close()
.subscribe();
}
@Override
public void ping() {
}
@Override
public boolean isAlive() {
return exchange.isAlive();
}
@Override
public void onClose(Runnable call) {
exchange.closeHandler(call);
}
public InetSocketAddress getAddress() {
return exchange.getRemoteAddress().orElse(null);
}
@Override
public void setKeepAliveTimeout(Duration timeout) {
keepAliveTimeout = timeout;
exchange.setKeepAliveTimeout(timeout);
}
@Override
public Duration getKeepAliveTimeout() {
return keepAliveTimeout;
}
public WebSocketDeviceSession copy() {<FILL_FUNCTION_BODY>}
}
|
WebSocketDeviceSession session = new WebSocketDeviceSession(operator, exchange);
session.setKeepAliveTimeout(keepAliveTimeout);
return session;
| 577
| 42
| 619
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/http-component/src/main/java/org/jetlinks/community/network/http/server/vertx/DefaultHttpServerProvider.java
|
DefaultHttpServerProvider
|
initServer
|
class DefaultHttpServerProvider implements NetworkProvider<HttpServerConfig> {
private final CertificateManager certificateManager;
private final Vertx vertx;
@Getter
@Setter
private HttpServerOptions template = new HttpServerOptions();
public DefaultHttpServerProvider(CertificateManager certificateManager, Vertx vertx) {
this.certificateManager = certificateManager;
this.vertx = vertx;
template.setHandle100ContinueAutomatically(true);
}
@Nonnull
@Override
@Generated
public NetworkType getType() {
return DefaultNetworkType.HTTP_SERVER;
}
@Nonnull
@Override
public Mono<Network> createNetwork(@Nonnull HttpServerConfig config) {
VertxHttpServer server = new VertxHttpServer(config);
return initServer(server, config);
}
@Override
public Mono<Network> reload(@Nonnull Network network, @Nonnull HttpServerConfig config) {
VertxHttpServer server = ((VertxHttpServer) network);
return initServer(server, config);
}
protected HttpServer createHttpServer(HttpServerOptions options) {
return vertx.createHttpServer(options);
}
@Nullable
@Override
@Generated
public ConfigMetadata getConfigMetadata() {
return new DefaultConfigMetadata()
.add("id", "id", "", new StringType())
.add("host", "本地地址", "", new StringType())
.add("port", "本地端口", "", new IntType())
.add("publicHost", "公网地址", "", new StringType())
.add("publicPort", "公网端口", "", new IntType())
.add("certId", "证书id", "", new StringType())
.add("secure", "开启TSL", "", new BooleanType())
.add("httpHeaders", "请求头", "", new ObjectType());
}
@Nonnull
@Override
public Mono<HttpServerConfig> createConfig(@Nonnull NetworkProperties properties) {
return Mono.defer(() -> {
HttpServerConfig config = FastBeanCopier.copy(properties.getConfigurations(), new HttpServerConfig());
config.setId(properties.getId());
config.validate();
return Mono.just(config);
})
.as(LocaleUtils::transform);
}
private Mono<Network> initServer(VertxHttpServer server, HttpServerConfig config) {<FILL_FUNCTION_BODY>}
private Mono<HttpServerOptions> convert(HttpServerConfig config) {
HttpServerOptions options = new HttpServerOptions(template);
options.setHost(config.getHost());
options.setPort(config.getPort());
if (config.isSecure()) {
options.setSsl(true);
return certificateManager
.getCertificate(config.getCertId())
.map(VertxKeyCertTrustOptions::new)
.doOnNext(options::setKeyCertOptions)
.doOnNext(options::setTrustOptions)
.thenReturn(options);
}
return Mono.just(options);
}
@Override
public boolean isReusable() {
return true;
}
}
|
int numberOfInstance = Math.max(1, config.getInstance());
List<HttpServer> instances = new ArrayList<>(numberOfInstance);
return convert(config)
.map(options -> {
//利用多线程处理请求
for (int i = 0; i < numberOfInstance; i++) {
instances.add(createHttpServer(options));
}
server.setBindAddress(new InetSocketAddress(config.getHost(), config.getPort()));
server.setHttpServers(instances);
for (HttpServer httpServer : instances) {
vertx.nettyEventLoopGroup()
.execute(()->{
httpServer.listen(result -> {
if (result.succeeded()) {
log.debug("startup http server on [{}]", server.getBindAddress());
} else {
server.setLastError(result.cause().getMessage());
log.warn("startup http server on [{}] failed", server.getBindAddress(), result.cause());
}
});
});
}
return server;
});
| 822
| 272
| 1,094
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/http-component/src/main/java/org/jetlinks/community/network/http/server/vertx/VertxHttpServer.java
|
VertxHttpServer
|
createRoute
|
class VertxHttpServer implements HttpServer {
private Collection<io.vertx.core.http.HttpServer> httpServers;
private HttpServerConfig config;
private String id;
private final Topic<FluxSink<HttpExchange>> route = Topic.createRoot();
private final Topic<FluxSink<WebSocketExchange>> websocketRoute = Topic.createRoot();
@Getter
@Setter
private String lastError;
@Setter(AccessLevel.PACKAGE)
private InetSocketAddress bindAddress;
public VertxHttpServer(HttpServerConfig config) {
this.config = config;
this.id = config.getId();
}
@Override
public InetSocketAddress getBindAddress() {
return bindAddress;
}
public void setHttpServers(Collection<io.vertx.core.http.HttpServer> httpServers) {
if (isAlive()) {
shutdown();
}
this.httpServers = httpServers;
for (io.vertx.core.http.HttpServer server : this.httpServers) {
server
.webSocketHandler(socket -> {
socket.exceptionHandler(err -> {
log.error(err.getMessage(), err);
});
String url = socket.path();
if (url.endsWith("/")) {
url = url.substring(0, url.length() - 1);
}
VertxWebSocketExchange exchange = new VertxWebSocketExchange(socket);
websocketRoute
.findTopic("/ws" + url)
.flatMapIterable(Topic::getSubscribers)
.doOnNext(sink -> sink.next(exchange))
.switchIfEmpty(Mono.fromRunnable(() -> {
log.warn("http server no handler for:[{}://{}{}]", socket.scheme(), socket.host(), socket.path());
socket.reject(404);
}))
.subscribe();
})
.requestHandler(request -> {
request.exceptionHandler(err -> {
log.error(err.getMessage(), err);
});
VertxHttpExchange exchange = new VertxHttpExchange(request, config);
String url = exchange.getUrl();
if (url.endsWith("/")) {
url = url.substring(0, url.length() - 1);
}
route.findTopic("/" + exchange.request().getMethod().name().toLowerCase() + url)
.flatMapIterable(Topic::getSubscribers)
.doOnNext(sink -> sink.next(exchange))
.switchIfEmpty(Mono.fromRunnable(() -> {
log.warn("http server no handler for:[{} {}://{}{}]", request.method(), request.scheme(), request.host(), request.path());
request.response()
.setStatusCode(HttpStatus.NOT_FOUND.value())
.end();
}))
.subscribe();
});
server.exceptionHandler(err -> log.error(err.getMessage(), err));
}
}
@Override
public Flux<HttpExchange> handleRequest() {
return handleRequest("*", "/**");
}
@Override
public Flux<WebSocketExchange> handleWebsocket(String urlPattern) {
return createRoute(websocketRoute, "ws", urlPattern);
}
@Override
public Flux<HttpExchange> handleRequest(String method, String... urlPatterns) {
return createRoute(route, method, urlPatterns);
}
private <T> Flux<T> createRoute(Topic<FluxSink<T>> root, String prefix, String... urlPatterns) {<FILL_FUNCTION_BODY>}
@Override
@Generated
public String getId() {
return id;
}
@Override
@Generated
public NetworkType getType() {
return DefaultNetworkType.HTTP_SERVER;
}
@Override
public void shutdown() {
if (httpServers != null) {
for (io.vertx.core.http.HttpServer httpServer : httpServers) {
httpServer.close(res -> {
if (res.failed()) {
log.error(res.cause().getMessage(), res.cause());
} else {
log.debug("http server [{}] closed", httpServer.actualPort());
}
});
}
httpServers.clear();
httpServers = null;
}
}
@Override
public boolean isAlive() {
return httpServers != null && !httpServers.isEmpty();
}
@Override
public boolean isAutoReload() {
return false;
}
}
|
return Flux.create(sink -> {
Disposable.Composite disposable = Disposables.composite();
for (String urlPattern : urlPatterns) {
String pattern = Stream
.of(urlPattern.split("/"))
.map(str -> {
//处理路径变量,如: /devices/{id}
if (str.startsWith("{") && str.endsWith("}")) {
return "*";
}
return str;
})
.collect(Collectors.joining("/"));
if (pattern.endsWith("/")) {
pattern = pattern.substring(0, pattern.length() - 1);
}
if (!pattern.startsWith("/")) {
pattern = "/".concat(pattern);
}
pattern = "/" + prefix + pattern;
log.debug("handle http request : {}", pattern);
Topic<FluxSink<T>> sub = root.append(pattern);
sub.subscribe(sink);
disposable.add(() -> sub.unsubscribe(sink));
}
sink.onDispose(disposable);
});
| 1,233
| 286
| 1,519
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/http-component/src/main/java/org/jetlinks/community/network/http/server/vertx/VertxWebSocketExchange.java
|
VertxWebSocketExchange
|
send
|
class VertxWebSocketExchange implements WebSocketExchange {
private final ServerWebSocket serverWebSocket;
private final InetSocketAddress address;
private final Sinks.Many<WebSocketMessage> sink = Reactors.createMany();
private final Map<String, Object> attributes = new ConcurrentHashMap<>();
private long keepAliveTimeOutMs = Duration.ofHours(1).toMillis();
private long lastKeepAliveTime = System.currentTimeMillis();
private final List<Runnable> closeHandler = new CopyOnWriteArrayList<>();
@Getter
private final String id;
public VertxWebSocketExchange(ServerWebSocket serverWebSocket) {
this.serverWebSocket = serverWebSocket;
doReceived();
SocketAddress socketAddress = serverWebSocket.remoteAddress();
address = new InetSocketAddress(socketAddress.host(), socketAddress.port());
this.id = IDGenerator.RANDOM.generate();
}
@Override
public Optional<InetSocketAddress> getRemoteAddress() {
return Optional.of(address);
}
private void doReceived() {
serverWebSocket
.textMessageHandler(text -> handle(textMessage(text)))
.binaryMessageHandler(msg -> handle(binaryMessage(msg.getByteBuf())))
.pongHandler(buf -> handle(pongMessage(buf.getByteBuf())))
.closeHandler((nil) -> doClose())
.exceptionHandler(err -> {
if (err instanceof HttpClosedException) {
return;
}
log.error(err.getMessage(), err);
})
;
}
private void doClose() {
sink.emitComplete(Reactors.emitFailureHandler());
for (Runnable runnable : closeHandler) {
runnable.run();
}
closeHandler.clear();
}
private void handle(WebSocketMessage message) {
this.lastKeepAliveTime = System.currentTimeMillis();
if (sink.currentSubscriberCount() > 0) {
sink.emitNext(WebSocketSessionMessageWrapper.of(message, this), Reactors.emitFailureHandler());
} else {
log.warn("websocket client[{}] session no handler", address);
}
}
@Override
public String getUri() {
return serverWebSocket.uri();
}
@Override
@Nonnull
public List<Header> getHeaders() {
return serverWebSocket
.headers()
.entries()
.stream()
.map(entry -> {
Header header = new Header();
header.setName(entry.getKey());
header.setValue(new String[]{entry.getValue()});
return header;
}).collect(Collectors.toList());
}
@Override
public Optional<Header> getHeader(String s) {
return Optional.ofNullable(serverWebSocket.headers().getAll(s))
.map(list -> new Header(s, list.toArray(new String[0])))
;
}
@Override
public Mono<Void> close() {
if (serverWebSocket.isClosed()) {
return Mono.empty();
}
return Mono.fromRunnable(serverWebSocket::close);
}
@Override
public Mono<Void> close(int i) {
return close(i, "Closed");
}
@Override
public Mono<Void> close(int status, String reason) {
if (serverWebSocket.isClosed()) {
return Mono.empty();
}
return Mono.defer(() -> {
short code = WebSocketCloseStatus.isValidStatusCode(status) ? (short) status : (short) WebSocketCloseStatus.BAD_GATEWAY.code();
return Mono.fromCompletionStage(serverWebSocket
.close(code, reason)
.toCompletionStage());
});
}
@Override
public Map<String, Object> getAttributes() {
return attributes;
}
@Override
public Optional<Object> getAttribute(String s) {
return Optional.ofNullable(attributes.get(s));
}
@Override
public void setAttribute(String s, Object o) {
attributes.put(s, o);
}
@Override
public Flux<WebSocketMessage> receive() {
return sink.asFlux();
}
@Override
public Mono<Void> send(WebSocketMessage webSocketMessage) {<FILL_FUNCTION_BODY>}
protected Mono<Void> doWrite(Consumer<Handler<AsyncResult<Void>>> handler) {
this.lastKeepAliveTime = System.currentTimeMillis();
return Mono.<Void>create(sink -> {
try {
handler.accept(result -> {
if (result.succeeded()) {
sink.success();
} else {
sink.error(result.cause());
}
});
} catch (Throwable e) {
sink.error(e);
}
});
}
@Override
public WebSocketMessage textMessage(String s) {
return DefaultWebSocketMessage.of(WebSocketMessage.Type.TEXT, Unpooled.wrappedBuffer(s.getBytes()));
}
@Override
public WebSocketMessage binaryMessage(ByteBuf byteBuf) {
return DefaultWebSocketMessage.of(WebSocketMessage.Type.BINARY, byteBuf);
}
@Override
public WebSocketMessage pingMessage(ByteBuf byteBuf) {
return DefaultWebSocketMessage.of(WebSocketMessage.Type.PING, byteBuf);
}
@Override
public WebSocketMessage pongMessage(ByteBuf byteBuf) {
return DefaultWebSocketMessage.of(WebSocketMessage.Type.PONG, byteBuf);
}
@Override
public boolean isAlive() {
return !serverWebSocket.isClosed() &&
(
keepAliveTimeOutMs <= 0 || System.currentTimeMillis() - lastKeepAliveTime < keepAliveTimeOutMs
);
}
@Override
public void setKeepAliveTimeout(Duration duration) {
this.keepAliveTimeOutMs = duration.toMillis();
this.lastKeepAliveTime = System.currentTimeMillis();
}
@Override
public void closeHandler(Runnable handler) {
closeHandler.add(handler);
}
@Override
public long getLastKeepAliveTime() {
return lastKeepAliveTime;
}
}
|
ByteBuf payload = webSocketMessage.getPayload();
return this
.doWrite(handler -> {
switch (webSocketMessage.getType()) {
case TEXT:
serverWebSocket.writeTextMessage(webSocketMessage.payloadAsString(), handler);
return;
case BINARY:
serverWebSocket.writeBinaryMessage(Buffer.buffer(payload), handler);
return;
case PING:
serverWebSocket.writePing(Buffer.buffer(payload));
handler.handle(Future.succeededFuture());
return;
}
throw new UnsupportedOperationException("unsupported message type" + webSocketMessage.getType());
})
.doAfterTerminate(() -> ReferenceCountUtil.safeRelease(payload));
| 1,695
| 192
| 1,887
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/mqtt-component/src/main/java/org/jetlinks/community/network/mqtt/client/MqttClientProvider.java
|
MqttClientProvider
|
convert
|
class MqttClientProvider implements NetworkProvider<MqttClientProperties> {
private final Vertx vertx;
private final CertificateManager certificateManager;
private final Environment environment;
@Getter
@Setter
private MqttClientOptions template = new MqttClientOptions();
public MqttClientProvider(CertificateManager certificateManager,
Vertx vertx,
Environment environment) {
this.vertx = vertx;
this.certificateManager = certificateManager;
this.environment = environment;
template.setTcpKeepAlive(true);
// options.setReconnectAttempts(10);
template.setAutoKeepAlive(true);
template.setKeepAliveInterval(180);
}
@Nonnull
@Override
public NetworkType getType() {
return DefaultNetworkType.MQTT_CLIENT;
}
@Nonnull
@Override
public Mono<Network> createNetwork(@Nonnull MqttClientProperties properties) {
VertxMqttClient mqttClient = new VertxMqttClient(properties.getId());
return initMqttClient(mqttClient, properties);
}
@Override
public Mono<Network> reload(@Nonnull Network network, @Nonnull MqttClientProperties properties) {
VertxMqttClient mqttClient = ((VertxMqttClient) network);
if (mqttClient.isLoading()) {
return Mono.just(mqttClient);
}
return initMqttClient(mqttClient, properties);
}
public Mono<Network> initMqttClient(VertxMqttClient mqttClient, MqttClientProperties properties) {
return convert(properties)
.map(options -> {
mqttClient.setTopicPrefix(properties.getTopicPrefix());
mqttClient.setLoading(true);
MqttClient client = MqttClient.create(vertx, options);
mqttClient.setClient(client);
client.connect(properties.getRemotePort(), properties.getRemoteHost(), result -> {
mqttClient.setLoading(false);
if (!result.succeeded()) {
log.warn("connect mqtt [{}@{}:{}] error",
properties.getClientId(),
properties.getRemoteHost(),
properties.getRemotePort(),
result.cause());
} else {
log.debug("connect mqtt [{}] success", properties.getId());
}
});
return mqttClient;
});
}
@Nullable
@Override
public ConfigMetadata getConfigMetadata() {
return new DefaultConfigMetadata()
.add("id", "id", "", new StringType())
.add("remoteHost", "远程地址", "", new StringType())
.add("remotePort", "远程地址", "", new IntType())
.add("certId", "证书id", "", new StringType())
.add("secure", "开启TSL", "", new BooleanType())
.add("clientId", "客户端ID", "", new BooleanType())
.add("username", "用户名", "", new BooleanType())
.add("password", "密码", "", new BooleanType());
}
@Nonnull
@Override
public Mono<MqttClientProperties> createConfig(@Nonnull NetworkProperties properties) {
return Mono
.defer(() -> {
MqttClientProperties config = FastBeanCopier.copy(properties.getConfigurations(), new MqttClientProperties());
config.setId(properties.getId());
config.validate();
return Mono.just(config);
})
.as(LocaleUtils::transform);
}
private Mono<MqttClientOptions> convert(MqttClientProperties config) {<FILL_FUNCTION_BODY>}
@Override
public boolean isReusable() {
return true;
}
}
|
MqttClientOptions options = FastBeanCopier.copy(config, new MqttClientOptions(template));
String clientId = String.valueOf(config.getClientId());
String username = config.getUsername();
String password = config.getPassword();
options.setClientId(clientId);
options.setPassword(password);
options.setUsername(username);
if (config.isSecure()) {
options.setSsl(true);
return certificateManager
.getCertificate(config.getCertId())
.map(VertxKeyCertTrustOptions::new)
.doOnNext(options::setKeyCertOptions)
.doOnNext(options::setTrustOptions)
.thenReturn(options);
}
return Mono.just(options);
| 1,009
| 207
| 1,216
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/mqtt-component/src/main/java/org/jetlinks/community/network/mqtt/gateway/device/MqttClientDeviceGateway.java
|
MqttClientDeviceGateway
|
reload
|
class MqttClientDeviceGateway extends AbstractDeviceGateway {
final MqttClient mqttClient;
private final DeviceRegistry registry;
private Mono<ProtocolSupport> protocol;
private Mono<DeviceMessageCodec> codecMono;
private final DeviceGatewayHelper helper;
private final Map<RouteKey, Tuple2<Integer, Disposable>> routes = new ConcurrentHashMap<>();
public MqttClientDeviceGateway(String id,
MqttClient mqttClient,
DeviceRegistry registry,
Mono<ProtocolSupport> protocol,
DeviceSessionManager sessionManager,
DecodedClientMessageHandler clientMessageHandler) {
super(id);
this.mqttClient = Objects.requireNonNull(mqttClient, "mqttClient");
this.registry = Objects.requireNonNull(registry, "registry");
setProtocol(protocol);
this.helper = new DeviceGatewayHelper(registry, sessionManager, clientMessageHandler);
}
protected Mono<ProtocolSupport> getProtocol() {
return protocol;
}
public void setProtocol(Mono<ProtocolSupport> protocol) {
this.protocol = Objects.requireNonNull(protocol, "protocol");
this.codecMono = protocol.flatMap(p -> p.getMessageCodec(getTransport()));
}
protected Mono<Void> reload() {<FILL_FUNCTION_BODY>}
protected void doReloadRoute(List<MqttRoute> routes) {
Map<RouteKey, Tuple2<Integer, Disposable>> readyToRemove = new HashMap<>(this.routes);
for (MqttRoute route : routes) {
//不是上行topic,不订阅
if (!route.isUpstream()) {
continue;
}
String topic = convertToMqttTopic(route.getTopic());
RouteKey key = RouteKey.of(topic, route.getQos());
readyToRemove.remove(key);
//尝试更新订阅
this.routes.compute(key, (_key, old) -> {
if (old != null) {
//QoS没变，不用重新订阅
if (old.getT1().equals(_key.qos)) {
return old;
} else {
old.getT2().dispose();
}
}
return Tuples.of(_key.qos, doSubscribe(_key.topic, _key.qos));
});
}
//取消订阅协议包里没有的topic信息
for (Map.Entry<RouteKey, Tuple2<Integer, Disposable>> value : readyToRemove.entrySet()) {
this.routes.remove(value.getKey());
value.getValue().getT2().dispose();
}
}
protected static String convertToMqttTopic(String topic) {
return TopicUtils.convertToMqttTopic(topic);
}
public Transport getTransport() {
return DefaultTransport.MQTT;
}
protected Disposable doSubscribe(String topic, int qos) {
return mqttClient
.subscribe(Collections.singletonList(topic), qos)
.filter(msg -> isStarted())
.flatMap(mqttMessage -> codecMono
.flatMapMany(codec -> codec
.decode(FromDeviceMessageContext.of(
new UnknownDeviceMqttClientSession(getId(), mqttClient, monitor),
mqttMessage,
registry,
msg -> handleMessage(mqttMessage, msg).then())))
.cast(DeviceMessage.class)
.concatMap(message -> handleMessage(mqttMessage, message))
.subscribeOn(Schedulers.parallel())
.onErrorResume((err) -> {
log.error("handle mqtt client message error:{}", mqttMessage, err);
return Mono.empty();
}), Integer.MAX_VALUE)
.contextWrite(ReactiveLogger.start("gatewayId", getId()))
.subscribe();
}
private Mono<Void> handleMessage(MqttMessage mqttMessage, DeviceMessage message) {
monitor.receivedMessage();
return helper
.handleDeviceMessage(message,
device -> createDeviceSession(device, mqttClient),
ignore -> {
},
() -> log.warn("can not get device info from message:{},{}", mqttMessage.print(), message)
)
.then();
}
@AllArgsConstructor(staticName = "of")
@EqualsAndHashCode(exclude = "qos")
private static class RouteKey {
private String topic;
private int qos;
}
private MqttClientSession createDeviceSession(DeviceOperator device, MqttClient client) {
return new MqttClientSession(device.getDeviceId(), device, client, monitor);
}
@Override
protected Mono<Void> doShutdown() {
for (Tuple2<Integer, Disposable> value : routes.values()) {
value.getT2().dispose();
}
routes.clear();
return Mono.empty();
}
@Override
protected Mono<Void> doStartup() {
return reload();
}
}
|
return this
.getProtocol()
.flatMap(support -> support
.getRoutes(DefaultTransport.MQTT)
.filter(MqttRoute.class::isInstance)
.cast(MqttRoute.class)
.collectList()
.doOnEach(ReactiveLogger
.onNext(routes -> {
//协议包里没有配置Mqtt Topic信息
if (CollectionUtils.isEmpty(routes)) {
log.warn("The protocol [{}] is not configured with topics information", support.getId());
}
}))
.doOnNext(this::doReloadRoute))
.then();
| 1,359
| 168
| 1,527
|
<methods>public void <init>(java.lang.String) ,public final void doOnShutdown(reactor.core.Disposable) ,public final void doOnStateChange(BiConsumer<org.jetlinks.community.gateway.GatewayState,org.jetlinks.community.gateway.GatewayState>) ,public final java.lang.String getId() ,public final org.jetlinks.community.gateway.GatewayState getState() ,public final boolean isAlive() ,public Flux<org.jetlinks.core.message.Message> onMessage() ,public final Mono<java.lang.Void> pause() ,public final Mono<java.lang.Void> shutdown() ,public final synchronized Mono<java.lang.Void> startup() <variables>private static final AtomicReferenceFieldUpdater<org.jetlinks.community.gateway.AbstractDeviceGateway,org.jetlinks.community.gateway.GatewayState> STATE,private final non-sealed java.lang.String id,protected final non-sealed org.jetlinks.community.gateway.monitor.DeviceGatewayMonitor monitor,private volatile org.jetlinks.community.gateway.GatewayState state,private final List<BiConsumer<org.jetlinks.community.gateway.GatewayState,org.jetlinks.community.gateway.GatewayState>> stateListener
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/mqtt-component/src/main/java/org/jetlinks/community/network/mqtt/gateway/device/MqttClientDeviceGatewayProvider.java
|
MqttClientDeviceGatewayProvider
|
createDeviceGateway
|
class MqttClientDeviceGatewayProvider implements DeviceGatewayProvider {
private final NetworkManager networkManager;
private final DeviceRegistry registry;
private final DeviceSessionManager sessionManager;
private final DecodedClientMessageHandler clientMessageHandler;
private final ProtocolSupports protocolSupports;
public MqttClientDeviceGatewayProvider(NetworkManager networkManager,
DeviceRegistry registry,
DeviceSessionManager sessionManager,
DecodedClientMessageHandler clientMessageHandler,
ProtocolSupports protocolSupports) {
this.networkManager = networkManager;
this.registry = registry;
this.sessionManager = sessionManager;
this.clientMessageHandler = clientMessageHandler;
this.protocolSupports = protocolSupports;
}
@Override
public String getId() {
return "mqtt-client-gateway";
}
@Override
public String getName() {
return "MQTT Broker接入";
}
public NetworkType getNetworkType() {
return DefaultNetworkType.MQTT_CLIENT;
}
public Transport getTransport() {
return DefaultTransport.MQTT;
}
@Override
public Mono<DeviceGateway> createDeviceGateway(DeviceGatewayProperties properties) {<FILL_FUNCTION_BODY>}
@Override
public Mono<? extends DeviceGateway> reloadDeviceGateway(DeviceGateway gateway, DeviceGatewayProperties properties) {
MqttClientDeviceGateway deviceGateway = ((MqttClientDeviceGateway) gateway);
String networkId = properties.getChannelId();
//网络组件发生了变化
if (!Objects.equals(networkId, deviceGateway.mqttClient.getId())) {
return gateway
.shutdown()
.then(this
.createDeviceGateway(properties)
.flatMap(gate -> gate.startup().thenReturn(gate)));
}
//更新协议包
deviceGateway.setProtocol(protocolSupports.getProtocol(properties.getProtocol()));
return deviceGateway
.reload()
.thenReturn(deviceGateway);
}
}
|
return networkManager
.<MqttClient>getNetwork(getNetworkType(), properties.getChannelId())
.map(mqttClient -> {
String protocol = properties.getProtocol();
return new MqttClientDeviceGateway(properties.getId(),
mqttClient,
registry,
Mono.defer(() -> protocolSupports.getProtocol(protocol)),
sessionManager,
clientMessageHandler
);
});
| 554
| 123
| 677
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/mqtt-component/src/main/java/org/jetlinks/community/network/mqtt/gateway/device/MqttServerDeviceGatewayProvider.java
|
MqttServerDeviceGatewayProvider
|
createDeviceGateway
|
class MqttServerDeviceGatewayProvider implements DeviceGatewayProvider {
private final NetworkManager networkManager;
private final DeviceRegistry registry;
private final DeviceSessionManager sessionManager;
private final DecodedClientMessageHandler messageHandler;
private final ProtocolSupports protocolSupports;
public MqttServerDeviceGatewayProvider(NetworkManager networkManager,
DeviceRegistry registry,
DeviceSessionManager sessionManager,
DecodedClientMessageHandler messageHandler,
ProtocolSupports protocolSupports) {
this.networkManager = networkManager;
this.registry = registry;
this.sessionManager = sessionManager;
this.messageHandler = messageHandler;
this.protocolSupports = protocolSupports;
}
@Override
public String getId() {
return "mqtt-server-gateway";
}
@Override
public String getName() {
return "MQTT直连接入";
}
public NetworkType getNetworkType() {
return DefaultNetworkType.MQTT_SERVER;
}
public Transport getTransport() {
return DefaultTransport.MQTT;
}
@Override
public int getOrder() {
return 0;
}
@Override
public Mono<DeviceGateway> createDeviceGateway(DeviceGatewayProperties properties) {<FILL_FUNCTION_BODY>}
@Override
public Mono<? extends DeviceGateway> reloadDeviceGateway(DeviceGateway gateway,
DeviceGatewayProperties properties) {
MqttServerDeviceGateway deviceGateway = ((MqttServerDeviceGateway) gateway);
String networkId = properties.getChannelId();
//网络组件发生了变化
if (!Objects.equals(networkId, deviceGateway.getMqttServer().getId())) {
return gateway
.shutdown()
.then(this
.createDeviceGateway(properties)
.flatMap(gate -> gate.startup().thenReturn(gate)));
}
return Mono.just(gateway);
}
}
|
return networkManager
.<MqttServer>getNetwork(getNetworkType(), properties.getChannelId())
.map(mqttServer -> new MqttServerDeviceGateway(
properties.getId(),
registry,
sessionManager,
mqttServer,
messageHandler,
Mono.empty()
));
| 535
| 90
| 625
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/mqtt-component/src/main/java/org/jetlinks/community/network/mqtt/gateway/device/session/MqttClientSession.java
|
MqttClientSession
|
isAlive
|
class MqttClientSession implements DeviceSession {
@Getter
private final String id;
@Getter
private final DeviceOperator operator;
@Getter
@Setter
private MqttClient client;
private final long connectTime = System.currentTimeMillis();
private long lastPingTime = System.currentTimeMillis();
private long keepAliveTimeout = -1;
private final DeviceGatewayMonitor monitor;
public MqttClientSession(String id,
DeviceOperator operator,
MqttClient client,
DeviceGatewayMonitor monitor) {
this.id = id;
this.operator = operator;
this.client = client;
this.monitor = monitor;
}
@Override
public String getDeviceId() {
return operator.getDeviceId();
}
@Override
public long lastPingTime() {
return lastPingTime;
}
@Override
public long connectTime() {
return connectTime;
}
@Override
public Mono<Boolean> send(EncodedMessage encodedMessage) {
if (encodedMessage instanceof MqttMessage) {
monitor.sentMessage();
return client
.publish(((MqttMessage) encodedMessage))
.thenReturn(true)
;
}
return Mono.error(new UnsupportedOperationException("unsupported message type:" + encodedMessage.getClass()));
}
@Override
public Transport getTransport() {
return DefaultTransport.MQTT;
}
@Override
public void close() {
}
@Override
public void ping() {
lastPingTime = System.currentTimeMillis();
}
@Override
public boolean isAlive() {<FILL_FUNCTION_BODY>}
@Override
public void onClose(Runnable call) {
}
@Override
public void setKeepAliveTimeout(Duration timeout) {
this.keepAliveTimeout = timeout.toMillis();
}
@Override
public String toString() {
return "MqttClientSession{" +
"id=" + id + ",device=" + getDeviceId() +
'}';
}
}
|
return client.isAlive() &&
(keepAliveTimeout <= 0 || System.currentTimeMillis() - lastPingTime < keepAliveTimeout);
| 570
| 40
| 610
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/mqtt-component/src/main/java/org/jetlinks/community/network/mqtt/gateway/device/session/MqttConnectionSession.java
|
MqttConnectionSession
|
replaceWith
|
class MqttConnectionSession implements DeviceSession, ReplaceableDeviceSession {
@Getter
@Generated
private final String id;
@Getter
@Generated
private final DeviceOperator operator;
@Getter
@Generated
private final Transport transport;
@Getter
@Generated
private MqttConnection connection;
private final DeviceGatewayMonitor monitor;
private final long connectTime = System.currentTimeMillis();
public MqttConnectionSession(String id,
DeviceOperator operator,
Transport transport,
MqttConnection connection,
DeviceGatewayMonitor monitor) {
this.id = id;
this.operator = operator;
this.transport = transport;
this.connection = connection;
this.monitor = monitor;
}
@Override
public String getDeviceId() {
return id;
}
@Override
public long lastPingTime() {
return connection.getLastPingTime();
}
@Override
public long connectTime() {
return connectTime;
}
@Override
public Mono<Boolean> send(EncodedMessage encodedMessage) {
return Mono.defer(() -> connection.publish(((MqttMessage) encodedMessage)))
.doOnSuccess(nil -> monitor.sentMessage())
.thenReturn(true);
}
@Override
public void close() {
connection.close().subscribe();
}
@Override
public void ping() {
connection.keepAlive();
}
@Override
public void setKeepAliveTimeout(Duration timeout) {
connection.setKeepAliveTimeout(timeout);
}
@Override
public boolean isAlive() {
return connection.isAlive();
}
@Override
public void onClose(Runnable call) {
connection.onClose(c -> call.run());
}
@Override
public Optional<InetSocketAddress> getClientAddress() {
return Optional.ofNullable(connection.getClientAddress());
}
@Override
public void replaceWith(DeviceSession session) {<FILL_FUNCTION_BODY>}
@Override
public boolean isChanged(DeviceSession another) {
if (another.isWrapFrom(MqttConnectionSession.class)) {
return !this
.connection
.equals(another.unwrap(MqttConnectionSession.class).getConnection());
}
return true;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MqttConnectionSession that = (MqttConnectionSession) o;
return Objects.equals(connection, that.connection);
}
@Override
public int hashCode() {
return Objects.hash(connection);
}
}
|
if (session instanceof MqttConnectionSession) {
MqttConnectionSession connectionSession = ((MqttConnectionSession) session);
if (!this.connection.equals(connectionSession.connection)) {
this.connection.close().subscribe();
}
this.connection = connectionSession.connection;
}
| 739
| 78
| 817
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/mqtt-component/src/main/java/org/jetlinks/community/network/mqtt/gateway/device/session/UnknownDeviceMqttClientSession.java
|
UnknownDeviceMqttClientSession
|
send
|
class UnknownDeviceMqttClientSession implements DeviceSession {
@Getter
private final String id;
private final MqttClient client;
private final DeviceGatewayMonitor monitor;
private Duration keepAliveTimeout;
public UnknownDeviceMqttClientSession(String id,
MqttClient client,
DeviceGatewayMonitor monitor) {
this.id = id;
this.client = client;
this.monitor=monitor;
}
@Override
public String getDeviceId() {
return null;
}
@Override
public DeviceOperator getOperator() {
return null;
}
@Override
public long lastPingTime() {
return 0;
}
@Override
public long connectTime() {
return 0;
}
@Override
public void setKeepAliveTimeout(Duration keepAliveTimeout) {
this.keepAliveTimeout = keepAliveTimeout;
}
@Override
public Duration getKeepAliveTimeout() {
return keepAliveTimeout;
}
@Override
public Mono<Boolean> send(EncodedMessage encodedMessage) {<FILL_FUNCTION_BODY>}
@Override
public Transport getTransport() {
return DefaultTransport.MQTT;
}
@Override
public void close() {
}
@Override
public void ping() {
}
@Override
public boolean isAlive() {
return client.isAlive();
}
@Override
public void onClose(Runnable call) {
}
}
|
if (encodedMessage instanceof MqttMessage) {
return client
.publish(((MqttMessage) encodedMessage))
.doOnSuccess(ignore->monitor.sentMessage())
.thenReturn(true);
}
return Mono.error(new UnsupportedOperationException("unsupported message type:" + encodedMessage.getClass()));
| 415
| 88
| 503
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/mqtt-component/src/main/java/org/jetlinks/community/network/mqtt/server/vertx/DefaultVertxMqttServerProvider.java
|
DefaultVertxMqttServerProvider
|
getConfigMetadata
|
class DefaultVertxMqttServerProvider implements NetworkProvider<VertxMqttServerProperties> {
private final CertificateManager certificateManager;
private final Vertx vertx;
@Getter
@Setter
private MqttServerOptions template = new MqttServerOptions();
public DefaultVertxMqttServerProvider(CertificateManager certificateManager, Vertx vertx) {
this.certificateManager = certificateManager;
this.vertx = vertx;
template.setTcpKeepAlive(true);
}
@Nonnull
@Override
public NetworkType getType() {
return DefaultNetworkType.MQTT_SERVER;
}
@Nonnull
@Override
public Mono<Network> createNetwork(@Nonnull VertxMqttServerProperties properties) {
VertxMqttServer server = new VertxMqttServer(properties.getId());
return initServer(server, properties);
}
private Mono<Network> initServer(VertxMqttServer server, VertxMqttServerProperties properties) {
int numberOfInstance = Math.max(1, properties.getInstance());
return convert(properties)
.map(options -> {
List<MqttServer> instances = new ArrayList<>(numberOfInstance);
for (int i = 0; i < numberOfInstance; i++) {
MqttServer mqttServer = MqttServer.create(vertx, options);
instances.add(mqttServer);
}
server.setBind(new InetSocketAddress(options.getHost(), options.getPort()));
server.setMqttServer(instances);
for (MqttServer instance : instances) {
vertx.nettyEventLoopGroup()
.execute(()->{
instance.listen(result -> {
if (result.succeeded()) {
log.debug("startup mqtt server [{}] on port :{} ", properties.getId(), result
.result()
.actualPort());
} else {
server.setLastError(result.cause().getMessage());
log.warn("startup mqtt server [{}] error ", properties.getId(), result.cause());
}
});
});
}
return server;
});
}
@Override
public Mono<Network> reload(@Nonnull Network network, @Nonnull VertxMqttServerProperties properties) {
log.debug("reload mqtt server[{}]", properties.getId());
return initServer((VertxMqttServer) network, properties);
}
@Nullable
@Override
public ConfigMetadata getConfigMetadata() {<FILL_FUNCTION_BODY>}
@Nonnull
@Override
public Mono<VertxMqttServerProperties> createConfig(@Nonnull NetworkProperties properties) {
return Mono.defer(() -> {
VertxMqttServerProperties config = FastBeanCopier.copy(properties.getConfigurations(), new VertxMqttServerProperties());
config.setId(properties.getId());
config.validate();
return Mono.just(config);
})
.as(LocaleUtils::transform);
}
private Mono<MqttServerOptions> convert(VertxMqttServerProperties properties) {
//MqttServerOptions options = FastBeanCopier.copy(properties, new MqttServerOptions());
MqttServerOptions options = new MqttServerOptions(template);
options.setPort(properties.getPort());
options.setHost(properties.getHost());
options.setMaxMessageSize(properties.getMaxMessageSize());
if (properties.isSecure()) {
options.setSsl(true);
return certificateManager
.getCertificate(properties.getCertId())
.map(VertxKeyCertTrustOptions::new)
.doOnNext(options::setKeyCertOptions)
.doOnNext(options::setTrustOptions)
.thenReturn(options);
}
return Mono.just(options);
}
@Override
public boolean isReusable() {
return true;
}
}
|
return new DefaultConfigMetadata()
.add("id", "id", "", new StringType())
.add("host", "本地地址", "", new StringType())
.add("port", "本地端口", "", new IntType())
.add("publicHost", "公网地址", "", new StringType())
.add("publicPort", "公网端口", "", new IntType())
.add("certId", "证书id", "", new StringType())
.add("secure", "开启TSL", "", new BooleanType())
.add("secure", "开启TSL", "", new BooleanType())
.add("maxMessageSize", "最大消息长度", "", new StringType());
| 1,048
| 170
| 1,218
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/mqtt-component/src/main/java/org/jetlinks/community/network/mqtt/server/vertx/VertxMqttConnection.java
|
VertxMqttAuth
|
equals
|
class VertxMqttAuth implements MqttAuth {
@Override
public String getUsername() {
return endpoint.auth().getUsername();
}
@Override
public String getPassword() {
return endpoint.auth().getPassword();
}
}
private int nextMessageId() {
this.messageIdCounter = ((this.messageIdCounter % 65535) != 0) ? this.messageIdCounter + 1 : 1;
return this.messageIdCounter;
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>
|
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
VertxMqttConnection that = (VertxMqttConnection) o;
return Objects.equals(endpoint, that.endpoint);
| 158
| 72
| 230
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/mqtt-component/src/main/java/org/jetlinks/community/network/mqtt/server/vertx/VertxMqttServer.java
|
VertxMqttServer
|
setMqttServer
|
class VertxMqttServer implements MqttServer {
private final Sinks.Many<MqttConnection> sink = Reactors.createMany(5 * 1024, false);
private final Map<String, List<Sinks.Many<MqttConnection>>> sinks =
new NonBlockingHashMap<>();
private Collection<io.vertx.mqtt.MqttServer> mqttServer;
private final String id;
@Getter
@Setter
private String lastError;
@Setter(AccessLevel.PACKAGE)
private InetSocketAddress bind;
public VertxMqttServer(String id) {
this.id = id;
}
public void setMqttServer(Collection<io.vertx.mqtt.MqttServer> mqttServer) {<FILL_FUNCTION_BODY>}
private boolean emitNext(Sinks.Many<MqttConnection> sink, VertxMqttConnection connection){
if (sink.currentSubscriberCount() <= 0) {
return false;
}
try{
sink.emitNext(connection,Reactors.emitFailureHandler());
return true;
}catch (Throwable ignore){}
return false;
}
private void handleConnection(VertxMqttConnection connection) {
boolean anyHandled = emitNext(sink, connection);
for (List<Sinks.Many<MqttConnection>> value : sinks.values()) {
if (value.size() == 0) {
continue;
}
Sinks.Many<MqttConnection> sink = value.get(ThreadLocalRandom.current().nextInt(value.size()));
if (emitNext(sink, connection)) {
anyHandled = true;
}
}
if (!anyHandled) {
connection.reject(MqttConnectReturnCode.CONNECTION_REFUSED_SERVER_UNAVAILABLE);
}
}
@Override
public Flux<MqttConnection> handleConnection() {
return sink.asFlux();
}
@Override
public Flux<MqttConnection> handleConnection(String holder) {
List<Sinks.Many<MqttConnection>> sinks = this
.sinks
.computeIfAbsent(holder, ignore -> new CopyOnWriteArrayList<>());
Sinks.Many<MqttConnection> sink = Reactors.createMany(Integer.MAX_VALUE,true);
sinks.add(sink);
return sink
.asFlux()
.doOnCancel(() -> sinks.remove(sink));
}
@Override
public boolean isAlive() {
return mqttServer != null && !mqttServer.isEmpty();
}
@Override
public boolean isAutoReload() {
return false;
}
@Override
public String getId() {
return id;
}
@Override
public NetworkType getType() {
return DefaultNetworkType.MQTT_SERVER;
}
@Override
public void shutdown() {
if (mqttServer != null) {
for (io.vertx.mqtt.MqttServer server : mqttServer) {
server.close(res -> {
if (res.failed()) {
log.error(res.cause().getMessage(), res.cause());
} else {
log.debug("mqtt server [{}] closed", server.actualPort());
}
});
}
mqttServer.clear();
}
}
@Override
public InetSocketAddress getBindAddress() {
return bind;
}
}
|
if (this.mqttServer != null && !this.mqttServer.isEmpty()) {
shutdown();
}
this.mqttServer = mqttServer;
for (io.vertx.mqtt.MqttServer server : this.mqttServer) {
server
.exceptionHandler(error -> {
log.error(error.getMessage(), error);
})
.endpointHandler(endpoint -> {
handleConnection(new VertxMqttConnection(endpoint));
});
}
| 947
| 139
| 1,086
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/network-core/src/main/java/org/jetlinks/community/network/DefaultNetworkManager.java
|
DefaultNetworkManager
|
getNetwork
|
class DefaultNetworkManager implements NetworkManager, BeanPostProcessor, CommandLineRunner {
private final NetworkConfigManager configManager;
private final Map<String, ReactiveCacheContainer<String, Network>> store = new ConcurrentHashMap<>();
private final Map<String, NetworkProvider<Object>> providerSupport = new ConcurrentHashMap<>();
public DefaultNetworkManager(NetworkConfigManager configManager) {
this.configManager = configManager;
}
protected void checkNetwork() {
Flux.fromIterable(store.values())
.flatMapIterable(ReactiveCacheContainer::valuesNow)
.filter(i -> !i.isAlive())
.flatMap(network -> {
NetworkProvider<Object> provider = providerSupport.get(network.getType().getId());
if (provider == null || !network.isAutoReload()) {
return Mono.empty();
}
return configManager
.getConfig(network.getType(), network.getId())
.filter(NetworkProperties::isEnabled)
.flatMap(provider::createConfig)
.flatMap(conf -> this.createOrUpdate(provider, network.getId(), conf))
.onErrorResume((err) -> {
log.warn("reload network [{}] error", network, err);
return Mono.empty();
});
})
.subscribe(net -> log.info("reloaded network :{}", net));
}
private ReactiveCacheContainer<String, Network> getNetworkStore(String type) {
return store.computeIfAbsent(type, _id -> ReactiveCacheContainer.create());
}
private ReactiveCacheContainer<String, Network> getNetworkStore(NetworkType type) {
return getNetworkStore(type.getId());
}
private <T extends Network> Mono<T> getNetwork(String type, String id) {<FILL_FUNCTION_BODY>}
@Override
public <T extends Network> Mono<T> getNetwork(NetworkType type, String id) {
return getNetwork(type.getId(), id);
}
@Override
public Flux<Network> getNetworks() {
return Flux.fromIterable(store.values())
.flatMapIterable(ReactiveCacheContainer::valuesNow);
}
public Mono<Network> createOrUpdate(NetworkProvider<Object> provider, String id, Object properties) {
ReactiveCacheContainer<String, Network> networkStore = getNetworkStore(provider.getType());
return networkStore.compute(id, (key, network) -> {
if (network == null) {
return provider.createNetwork(properties);
}
return provider.reload(network, properties);
});
}
public Mono<Network> doCreate(NetworkProvider<Object> provider, String id, Object properties) {
return provider.createNetwork(properties);
}
private Mono<Network> handleConfig(NetworkType type,
String id,
Function3<NetworkProvider<Object>, String, Object, Mono<Network>> handler) {
@SuppressWarnings("all")
NetworkProvider<Object> networkProvider = (NetworkProvider) this
.getProvider(type.getId())
.orElseThrow(() -> new UnsupportedOperationException("不支持的类型:" + type.getName()));
return configManager
.getConfig(type, id)
.filter(NetworkProperties::isEnabled)
.flatMap(networkProvider::createConfig)
.flatMap(config -> handler.apply(networkProvider, id, config));
}
public void register(NetworkProvider<Object> provider) {
this.providerSupport.put(provider.getType().getId(), provider);
}
@Override
public Object postProcessAfterInitialization(@Nonnull Object bean, @Nonnull String beanName) throws BeansException {
if (bean instanceof NetworkProvider) {
register(((NetworkProvider) bean));
}
return bean;
}
@Override
public List<NetworkProvider<?>> getProviders() {
return new ArrayList<>(providerSupport.values());
}
@Override
public Optional<NetworkProvider<?>> getProvider(String type) {
return Optional.ofNullable(providerSupport.get(type));
}
private Mono<Void> doReload(String type, String id) {
return handleConfig(NetworkType.of(type), id, this::createOrUpdate)
.then();
// Optional.ofNullable(getNetworkStore(type).getNow(id))
// .ifPresent(Network::shutdown);
//
// return this
// .getNetwork(type, id)
// .then();
}
public Mono<Void> doShutdown(String type, String id) {
return Mono
.justOrEmpty(getNetworkStore(type).getNow(id))
.doOnNext(Network::shutdown)
.then();
}
public Mono<Void> doDestroy(String type, String id) {
return Mono
.justOrEmpty(getNetworkStore(type).remove(id))
.doOnNext(Network::shutdown)
.then();
}
@Override
public Mono<Void> reload(NetworkType type, String id) {
return doReload(type.getId(), id);
}
@Override
public Mono<Void> shutdown(NetworkType type, String id) {
return this
.doShutdown(type.getId(), id)
.then();
}
@Override
public Mono<Void> destroy(NetworkType type, String id) {
return this
.doDestroy(type.getId(), id)
.then();
}
@Override
public void run(String... args) {
//定时检查网络组件状态
Flux.interval(Duration.ofSeconds(10))
.subscribe(t -> this.checkNetwork());
}
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Generated
public static class Synchronization implements Serializable {
private NetworkType type;
private String id;
}
}
|
ReactiveCacheContainer<String, Network> networkMap = getNetworkStore(type);
return networkMap
.computeIfAbsent(id, (key) -> handleConfig(NetworkType.of(type), key, this::doCreate))
.map(n -> (T) n);
| 1,546
| 73
| 1,619
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/network-core/src/main/java/org/jetlinks/community/network/resource/DefaultNetworkResourceUser.java
|
DefaultNetworkResourceUser
|
getUsedResources
|
class DefaultNetworkResourceUser implements NetworkResourceUser {
private final NetworkConfigManager configManager;
private final NetworkManager networkManager;
@Override
public Flux<NetworkResource> getUsedResources() {<FILL_FUNCTION_BODY>}
}
|
return configManager
.getAllConfigs()
.flatMap(conf -> networkManager
.getProvider(conf.getType())
.map(provider -> provider
.createConfig(conf)
.onErrorResume(err -> Mono.empty()))
.orElse(Mono.empty()))
.filter(ServerNetworkConfig.class::isInstance)
.cast(ServerNetworkConfig.class)
.groupBy(ServerNetworkConfig::getHost)
.flatMap(group -> {
String host = group.key();
NetworkResource resource = NetworkResource.of(host);
return group
.doOnNext(conf -> resource.withPorts(conf.getTransport(), Collections.singletonList(conf.getPort())))
.then(Mono.just(resource));
});
| 64
| 206
| 270
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/network-core/src/main/java/org/jetlinks/community/network/resource/NetworkResource.java
|
NetworkResource
|
of
|
class NetworkResource implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 网卡Host信息,如: 192.168.1.10
*/
private String host;
/**
* 说明
*/
private String description;
/**
* 端口信息,key为协议,如TCP,UDP.
*/
private Map<NetworkTransport, Set<Integer>> ports = new HashMap<>();
public boolean hostIsBindAll() {
return "0.0.0.0".equals(host)
|| "::".equals(host)
|| "0:0:0:0:0:0:0:0".equals(host);
}
public List<PortInfo> getPortList() {
List<PortInfo> portList = new ArrayList<>();
Map<Integer, List<NetworkTransport>> ports = new HashMap<>();
for (Map.Entry<NetworkTransport, Set<Integer>> entry : this.ports.entrySet()) {
for (Integer port : entry.getValue()) {
ports.computeIfAbsent(port, (ignore) -> new ArrayList<>())
.add(entry.getKey());
}
}
ports.forEach(((port, transports) -> portList.add(PortInfo.of(port, transports))));
portList.sort(Comparator.comparing(PortInfo::getPort));
return portList;
}
public static NetworkResource of(String host, Integer... ports) {<FILL_FUNCTION_BODY>}
/**
* 判断是否为相同的host
*
* @param host Host
* @return 是否相同
*/
public boolean isSameHost(String host) {
//更好的相同host判断逻辑?
return Objects.equals(host, this.host);
}
/**
* 判断当前资源是否包含有指定的网络端口
*
* @param protocol 协议
* @param port 端口号
* @return 是否包含端口号
*/
public boolean containsPort(NetworkTransport protocol, int port) {
return ports != null && ports.getOrDefault(protocol, Collections.emptySet()).contains(port);
}
public Set<Integer> getPorts(NetworkTransport protocol) {
return ports.getOrDefault(protocol, Collections.emptySet());
}
public Set<Integer> tcpPorts() {
return getPorts(NetworkTransport.TCP);
}
public Set<Integer> udpPorts() {
return getPorts(NetworkTransport.UDP);
}
public void removePorts(Map<NetworkTransport, ? extends Collection<Integer>> ports) {
if (ports == null) {
return;
}
ports.forEach(this::removePorts);
}
public void removePorts(NetworkTransport protocol, Collection<Integer> ports) {
if (null != this.ports) {
this.ports.compute(protocol, (key, old) -> {
if (old == null) {
return null;
}
Set<Integer> newPorts = new TreeSet<>(old);
ports.forEach(newPorts::remove);
return newPorts;
});
}
}
public void addPorts(NetworkTransport transport, Collection<Integer> ports) {
this.ports.computeIfAbsent(transport, ignore -> new TreeSet<>())
.addAll(ports);
}
public NetworkResource withPorts(NetworkTransport transport, Collection<Integer> ports) {
addPorts(transport, ports);
return this;
}
public NetworkResource retainPorts(Map<NetworkTransport, ? extends Collection<Integer>> ports) {
if (ports == null) {
return this;
}
ports.forEach(this::retainPorts);
return this;
}
public void retainPorts(NetworkTransport protocol, Collection<Integer> ports) {
if (null != this.ports) {
this.ports.compute(protocol, (key, old) -> {
if (old == null) {
return new TreeSet<>(ports);
}
Set<Integer> newPorts = new TreeSet<>(old);
newPorts.retainAll(ports);
return newPorts;
});
}
}
public NetworkResource copy() {
NetworkResource resource = new NetworkResource();
resource.setDescription(description);
resource.setHost(host);
resource.setPorts(new ConcurrentHashMap<>());
if (this.ports != null) {
for (Map.Entry<NetworkTransport, Set<Integer>> entry : this.ports.entrySet()) {
resource.getPorts().put(entry.getKey(), new TreeSet<>(entry.getValue()));
}
}
return resource;
}
@Getter
@Setter
@AllArgsConstructor(staticName = "of")
@NoArgsConstructor
public static class PortInfo {
private int port;
private List<NetworkTransport> transports;
}
}
|
NetworkResource resource = new NetworkResource();
resource.setHost(host);
if (ports != null && ports.length > 0) {
resource.withPorts(NetworkTransport.TCP, Arrays.asList(ports));
}
return resource;
| 1,287
| 68
| 1,355
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/network-core/src/main/java/org/jetlinks/community/network/resource/cluster/AbstractNetworkResourceManager.java
|
AbstractNetworkResourceManager
|
getAliveResources
|
class AbstractNetworkResourceManager implements NetworkResourceManager {
private final List<NetworkResourceUser> resourceUsers;
public AbstractNetworkResourceManager(List<NetworkResourceUser> resourceUser) {
this.resourceUsers = resourceUser;
}
@Override
public final Flux<NetworkResource> getAliveResources() {<FILL_FUNCTION_BODY>}
public final Flux<NetworkResource> getLocalUsedResources() {
return Flux
.fromIterable(resourceUsers)
.flatMap(NetworkResourceUser::getUsedResources);
}
public abstract Flux<NetworkResource> getLocalAllResources();
}
|
Mono<Map<String, List<NetworkResource>>> usedMapping = this
.getLocalUsedResources()
.collect(Collectors.groupingBy(NetworkResource::getHost))
.cache();
return this
.getLocalAllResources()
.map(NetworkResource::copy)
.flatMap(resource -> usedMapping
.map(usedMap -> {
List<NetworkResource> usedList = usedMap.get(resource.getHost());
if (CollectionUtils.isNotEmpty(usedList)) {
for (NetworkResource used : usedList) {
resource.removePorts(used.getPorts());
}
}
return resource;
}));
| 158
| 172
| 330
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/network-core/src/main/java/org/jetlinks/community/network/resource/cluster/NetworkResourceProperties.java
|
NetworkResourceProperties
|
parseResources
|
class NetworkResourceProperties {
private List<String> resources = new ArrayList<>();
public List<NetworkResource> parseResources() {<FILL_FUNCTION_BODY>}
private List<Integer> getPorts(String port) {
String[] ports = port.split("-");
if (ports.length == 1) {
return Collections.singletonList(Integer.parseInt(ports[0]));
}
int startWith = Integer.parseInt(ports[0]);
int endWith = Integer.parseInt(ports[1]);
if (startWith > endWith) {
int temp = startWith;
startWith = endWith;
endWith = temp;
}
List<Integer> arr = new ArrayList<>(endWith - startWith);
for (int i = startWith; i <= endWith; i++) {
arr.add(i);
}
return arr;
}
}
|
Map<String, NetworkResource> info = new LinkedHashMap<>();
for (String resource : resources) {
NetworkTransport protocol = null;
if (resource.contains("/")) {
protocol = NetworkTransport.valueOf(resource
.substring(resource.indexOf("/") + 1)
.toUpperCase(Locale.ROOT));
resource = resource.substring(0, resource.indexOf("/"));
}
String[] hostAndPort = resource.split(":");
//只指定端口
if (hostAndPort.length == 1) {
hostAndPort = Arrays.copyOf(hostAndPort, 2);
hostAndPort[1] = hostAndPort[0];
hostAndPort[0] = "0.0.0.0";
}
String host = hostAndPort[0];
String port = hostAndPort[1];
NetworkResource res = info.computeIfAbsent(host, hst -> new NetworkResource());
res.setHost(host);
//未指定时则同时支持UDP和TCP
if (protocol == null) {
List<Integer> ports = getPorts(port);
res.addPorts(NetworkTransport.UDP, ports);
res.addPorts(NetworkTransport.TCP, ports);
} else {
res.addPorts(protocol, getPorts(port));
}
}
return new ArrayList<>(info.values());
| 233
| 363
| 596
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/network-core/src/main/java/org/jetlinks/community/network/security/DefaultCertificate.java
|
DefaultCertificate
|
initPfxKey
|
class DefaultCertificate implements Certificate {
@Getter
private final String id;
@Getter
private final String name;
private KeyStoreHelper keyHelper;
private KeyStoreHelper trustHelper;
private static final X509Certificate[] EMPTY = new X509Certificate[0];
public DefaultCertificate(String id, String name) {
this.id = id;
this.name = name;
}
public DefaultCertificate initPfxKey(byte[] keys, String password) {<FILL_FUNCTION_BODY>}
public DefaultCertificate initPfxTrust(byte[] keys, String password) {
PfxOptions options = new PfxOptions();
options.setValue(Buffer.buffer(keys));
options.setPassword(password);
trustHelper = KeyStoreHelper.create((TrustOptions) options);
return this;
}
public DefaultCertificate initJksKey(byte[] keys, String password) {
JksOptions options = new JksOptions();
options.setValue(Buffer.buffer(keys));
options.setPassword(password);
keyHelper = KeyStoreHelper.create((KeyCertOptions) options);
return this;
}
public DefaultCertificate initJksTrust(byte[] keys, String password) {
JksOptions options = new JksOptions();
options.setValue(Buffer.buffer(keys));
options.setPassword(password);
trustHelper = KeyStoreHelper.create((TrustOptions) options);
return this;
}
public DefaultCertificate initPemKey(List<byte[]> keys, List<byte[]> cert) {
PemKeyCertOptions options = new PemKeyCertOptions();
keys.stream().map(Buffer::buffer).forEach(options::addKeyValue);
cert.stream().map(Buffer::buffer).forEach(options::addCertValue);
keyHelper = KeyStoreHelper.create(options);
return this;
}
public DefaultCertificate initPemTrust(List<byte[]> cert) {
PemTrustOptions options = new PemTrustOptions();
cert.stream().map(Buffer::buffer).forEach(options::addCertValue);
trustHelper = KeyStoreHelper.create(options);
return this;
}
protected KeyStoreHelper checkKeyStore(KeyStoreHelper helper) {
Assert.notNull(helper, "key store not init");
return helper;
}
@SneakyThrows
public DefaultCertificate initKey(KeyStore keyStore, String password) {
keyHelper = new KeyStoreHelper(keyStore, password);
return this;
}
@SneakyThrows
public DefaultCertificate initTrust(KeyStore keyStore, String password) {
trustHelper = new KeyStoreHelper(keyStore, password);
return this;
}
@Override
@SneakyThrows
public KeyManagerFactory getKeyManagerFactory() {
return keyHelper == null ? null : keyHelper.getKeyMgrFactory();
}
@Override
@SneakyThrows
public TrustManagerFactory getTrustManagerFactory() {
return trustHelper == null ? null : trustHelper.getTrustMgrFactory();
}
@Override
public X509KeyManager getX509KeyManager(String serverName) {
return keyHelper == null ? null : keyHelper.getKeyMgr(serverName);
}
@Override
public X509KeyManager[] getX509KeyManagers() {
return keyHelper == null ? new X509KeyManager[0] : keyHelper.getKeyMgrs();
}
@Override
public X509Certificate[] getCertificateChain(String serverName) {
return getX509KeyManager(serverName).getCertificateChain(null);
}
@Override
@SneakyThrows
public X509Certificate[] getTrustCerts() {
if (trustHelper == null) {
return EMPTY;
}
return Arrays.stream(trustHelper
.getTrustMgrs())
.filter(X509TrustManager.class::isInstance)
.map(X509TrustManager.class::cast)
.map(X509TrustManager::getAcceptedIssuers)
.flatMap(Stream::of)
.toArray(X509Certificate[]::new);
}
@Override
public TrustManager[] getTrustManager(String serverName) {
return checkKeyStore(trustHelper).getTrustMgr(serverName);
}
}
|
PfxOptions options = new PfxOptions();
options.setValue(Buffer.buffer(keys));
options.setPassword(password);
keyHelper = KeyStoreHelper.create((KeyCertOptions) options);
return this;
| 1,162
| 59
| 1,221
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/network-core/src/main/java/org/jetlinks/community/network/utils/BytesUtils.java
|
BytesUtils
|
lowBytesToInt
|
class BytesUtils {
/**
* 高位字节数组转int,低字节在前.
* -------------------------------------------
* | 0-7位 | 8-16位 | 17-23位 | 24-31位 |
* -------------------------------------------
*
* @param src 字节数组
* @return int值
*/
public static int highBytesToInt(byte[] src) {
return highBytesToInt(src, 0, src.length);
}
/**
* 高位字节数组转long,低字节在前.
* -------------------------------------------
* | 0-7位 | 8-16位 | 17-23位 | 24-31位 |
* -------------------------------------------
*
* @param src 字节数组
* @return int值
*/
public static int highBytesToInt(byte[] src, int offset, int len) {
int n = 0;
len = Math.min(len, 4);
for (int i = 0; i < len; i++) {
int left = i * 8;
n += ((src[i + offset] & 0xFF) << left);
}
return n;
}
public static long highBytesToLong(byte[] src, int offset, int len) {
long n = 0;
len = Math.min(Math.min(len, src.length), 8);
for (int i = 0; i < len; i++) {
int left = i * 8;
n += ((long)(src[i + offset] & 0xFF) << left);
}
return n;
}
/**
* 低位字节数组转int,低字节在后.
* -------------------------------------------
* | 31-24位 | 23-17位 | 16-8位 | 7-0位 |
* -------------------------------------------
*
* @param src 字节数组
* @return int值
*/
public static int lowBytesToInt(byte[] src, int offset, int len) {<FILL_FUNCTION_BODY>}
/**
* 低位字节数组转long,低字节在后.
* -------------------------------------------
* | 31-24位 | 23-17位 | 16-8位 | 7-0位 |
* -------------------------------------------
*
* @param src 字节数组
* @return int值
*/
public static long lowBytesToLong(byte[] src, int offset, int len) {
long n = 0;
len = Math.min(len, 4);
for (int i = 0; i < len; i++) {
int left = i * 8;
n += ((long)(src[offset + len - i - 1] & 0xFF) << left);
}
return n;
}
/**
* 低位字节数组转int,低字节在后
* -------------------------------------------
* | 31-24位 | 23-17位 | 16-8位 | 7-0位 |
* -------------------------------------------
*
* @param src 字节数组
* @return int值
*/
public static int lowBytesToInt(byte[] src) {
return lowBytesToInt(src, 0, src.length);
}
/**
* int转高位字节数组,低字节在前
* -------------------------------------------
* | 0-7位 | 8-16位 | 17-23位 | 24-31位 |
* -------------------------------------------
*
* @param src 字节数组
* @return bytes 值
*/
public static byte[] toHighBytes(byte[] target, long src, int offset, int len) {
for (int i = 0; i < len; i++) {
target[offset + i] = (byte) (src >> (i * 8) & 0xff);
}
return target;
}
/**
* int转高位字节数组,低字节在前
* -------------------------------------------
* | 0-7位 | 8-16位 | 17-23位 | 24-31位 |
* -------------------------------------------
*
* @param src 字节数组
* @return bytes 值
*/
public static byte[] toHighBytes(int src) {
return toHighBytes(new byte[4], src, 0, 4);
}
/**
* 转低位字节数组, 低字节在后
* --------------------------------------------
* | 31-24位 | 23-17位 | 16-8位 | 7-0位 |
* --------------------------------------------
*
* @param src 字节数组
* @return int值
*/
public static byte[] toLowBytes(byte[] target, long src, int offset, int len) {
for (int i = 0; i < len; i++) {
target[offset + len - i - 1] = (byte) (src >> (i * 8) & 0xff);
}
return target;
}
/**
* int转低位字节数组, 低字节在后
* --------------------------------------------
* | 31-24位 | 23-17位 | 16-8位 | 7-0位 |
* --------------------------------------------
*
* @param src 字节数组
* @return int值
*/
public static byte[] toLowBytes(int src) {
return toLowBytes(new byte[4], src, 0, 4);
}
public static byte[] toLowBytes(long src) {
return toLowBytes(new byte[8], src, 0, 8);
}
}
|
int n = 0;
len = Math.min(len, 4);
for (int i = 0; i < len; i++) {
int left = i * 8;
n += ((src[offset + len - i - 1] & 0xFF) << left);
}
return n;
| 1,530
| 83
| 1,613
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/tcp-component/src/main/java/org/jetlinks/community/network/tcp/TcpMessage.java
|
TcpMessage
|
toString
|
class TcpMessage implements EncodedMessage {
private ByteBuf payload;
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
StringBuilder builder = new StringBuilder();
if (ByteBufUtil.isText(payload, StandardCharsets.UTF_8)) {
builder.append(payloadAsString());
} else {
ByteBufUtil.appendPrettyHexDump(builder, payload);
}
return builder.toString();
| 46
| 82
| 128
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/tcp-component/src/main/java/org/jetlinks/community/network/tcp/client/VertxTcpClient.java
|
VertxTcpClient
|
shutdown
|
class VertxTcpClient implements TcpClient {
public volatile NetClient client;
public NetSocket socket;
volatile PayloadParser payloadParser;
@Getter
private final String id;
@Setter
private long keepAliveTimeoutMs = Duration.ofMinutes(10).toMillis();
private volatile long lastKeepAliveTime = System.currentTimeMillis();
private final List<Runnable> disconnectListener = new CopyOnWriteArrayList<>();
private final Sinks.Many<TcpMessage> sink = Reactors.createMany();
private final boolean serverClient;
@Override
public void keepAlive() {
lastKeepAliveTime = System.currentTimeMillis();
}
@Override
public void setKeepAliveTimeout(Duration timeout) {
keepAliveTimeoutMs = timeout.toMillis();
}
@Override
public void reset() {
if (null != payloadParser) {
payloadParser.reset();
}
}
@Override
public InetSocketAddress address() {
return getRemoteAddress();
}
@Override
public Mono<Void> sendMessage(EncodedMessage message) {
return Mono
.<Void>create((sink) -> {
if (socket == null) {
sink.error(new SocketException("socket closed"));
return;
}
ByteBuf buf = message.getPayload();
Buffer buffer = Buffer.buffer(buf);
int len = buffer.length();
socket.write(buffer, r -> {
ReferenceCountUtil.safeRelease(buf);
if (r.succeeded()) {
keepAlive();
sink.success();
} else {
sink.error(r.cause());
}
});
});
}
@Override
public Flux<EncodedMessage> receiveMessage() {
return this
.subscribe()
.cast(EncodedMessage.class);
}
@Override
public void disconnect() {
shutdown();
}
@Override
public boolean isAlive() {
return socket != null && (keepAliveTimeoutMs < 0 || System.currentTimeMillis() - lastKeepAliveTime < keepAliveTimeoutMs);
}
@Override
public boolean isAutoReload() {
return true;
}
public VertxTcpClient(String id) {
this.id = id;
this.serverClient = true;
}
protected void received(TcpMessage message) {
sink.emitNext(message,Reactors.RETRY_NON_SERIALIZED);
}
@Override
public Flux<TcpMessage> subscribe() {
return sink.asFlux();
}
private void execute(Runnable runnable) {
try {
runnable.run();
} catch (Exception e) {
log.warn("close tcp client error", e);
}
}
@Override
public InetSocketAddress getRemoteAddress() {
if (null == socket) {
return null;
}
SocketAddress socketAddress = socket.remoteAddress();
return InetSocketAddress.createUnresolved(socketAddress.host(), socketAddress.port());
}
@Override
public NetworkType getType() {
return DefaultNetworkType.TCP_CLIENT;
}
@Override
public void shutdown() {<FILL_FUNCTION_BODY>}
public void setClient(NetClient client) {
if (this.client != null && this.client != client) {
this.client.close();
}
keepAlive();
this.client = client;
}
public void setRecordParser(PayloadParser payloadParser) {
synchronized (this) {
if (null != this.payloadParser && this.payloadParser != payloadParser) {
this.payloadParser.close();
}
this.payloadParser = payloadParser;
this.payloadParser
.handlePayload()
.subscribe(buffer -> received(new TcpMessage(buffer.getByteBuf())));
}
}
public void setSocket(NetSocket socket) {
synchronized (this) {
Objects.requireNonNull(payloadParser);
if (this.socket != null && this.socket != socket) {
this.socket.close();
}
this.socket = socket
.closeHandler(v -> shutdown())
.handler(buffer -> {
if (log.isDebugEnabled()) {
log.debug("handle tcp client[{}] payload:[{}]",
socket.remoteAddress(),
Hex.encodeHexString(buffer.getBytes()));
}
keepAlive();
payloadParser.handle(buffer);
if (this.socket != socket) {
log.warn("tcp client [{}] memory leak ", socket.remoteAddress());
socket.close();
}
});
}
}
@Override
public Mono<Boolean> send(TcpMessage message) {
return sendMessage(message)
.thenReturn(true);
}
@Override
public void onDisconnect(Runnable disconnected) {
disconnectListener.add(disconnected);
}
}
|
if (socket == null) {
return;
}
log.debug("tcp client [{}] disconnect", getId());
synchronized (this) {
if (null != client) {
execute(client::close);
client = null;
}
if (null != socket) {
execute(socket::close);
this.socket = null;
}
if (null != payloadParser) {
execute(payloadParser::close);
payloadParser = null;
}
}
for (Runnable runnable : disconnectListener) {
execute(runnable);
}
disconnectListener.clear();
if (serverClient) {
sink.tryEmitComplete();
}
| 1,343
| 186
| 1,529
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/tcp-component/src/main/java/org/jetlinks/community/network/tcp/gateway/device/TcpDeviceSession.java
|
TcpDeviceSession
|
equals
|
class TcpDeviceSession implements DeviceSession {
@Getter
@Setter
private DeviceOperator operator;
@Setter
private TcpClient client;
@Getter
private final Transport transport;
private long lastPingTime = System.currentTimeMillis();
private final long connectTime = System.currentTimeMillis();
private final DeviceGatewayMonitor monitor;
TcpDeviceSession(DeviceOperator operator,
TcpClient client,
Transport transport,
DeviceGatewayMonitor monitor) {
this.operator = operator;
this.client = client;
this.transport = transport;
this.monitor=monitor;
}
@Override
public String getId() {
return getDeviceId();
}
@Override
public String getDeviceId() {
return operator.getDeviceId();
}
@Override
public long lastPingTime() {
return lastPingTime;
}
@Override
public long connectTime() {
return connectTime;
}
@Override
public Mono<Boolean> send(EncodedMessage encodedMessage) {
monitor.sentMessage();
return client.send(new TcpMessage(encodedMessage.getPayload()));
}
@Override
public void close() {
client.shutdown();
}
@Override
public void ping() {
lastPingTime = System.currentTimeMillis();
client.keepAlive();
}
@Override
public void setKeepAliveTimeout(Duration timeout) {
client.setKeepAliveTimeout(timeout);
}
@Override
public boolean isAlive() {
return client.isAlive();
}
@Override
public Optional<InetSocketAddress> getClientAddress() {
return Optional.ofNullable(client.getRemoteAddress());
}
@Override
public void onClose(Runnable call) {
client.onDisconnect(call);
}
@Override
public boolean isChanged(DeviceSession another) {
if (another.isWrapFrom(TcpDeviceSession.class)) {
return !this
.client
.equals(another.unwrap(TcpDeviceSession.class).client);
}
return true;
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return Objects.hash(client);
}
}
|
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
TcpDeviceSession session = (TcpDeviceSession) o;
return Objects.equals(client, session.client);
| 631
| 65
| 696
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/tcp-component/src/main/java/org/jetlinks/community/network/tcp/gateway/device/TcpServerDeviceGateway.java
|
TcpConnection
|
checkLegality
|
class TcpConnection implements DeviceGatewayContext {
final TcpClient client;
final AtomicReference<DeviceSession> sessionRef = new AtomicReference<>();
final InetSocketAddress address;
Disposable legalityChecker;
TcpConnection(TcpClient client) {
this.client = client;
this.address = client.getRemoteAddress();
monitor.totalConnection(counter.sum());
client.onDisconnect(() -> {
counter.decrement();
monitor.disconnected();
monitor.totalConnection(counter.sum());
//check session
DeviceSession session = sessionRef.get();
if (session.getDeviceId() != null) {
sessionManager
.getSession(session.getDeviceId())
.subscribe();
}
});
monitor.connected();
sessionRef.set(new UnknownTcpDeviceSession(client.getId(), client, DefaultTransport.TCP, monitor));
legalityChecker = Schedulers
.parallel()
.schedule(this::checkLegality, connectCheckTimeout.toMillis(), TimeUnit.MILLISECONDS);
}
public void checkLegality() {<FILL_FUNCTION_BODY>}
Mono<Void> accept() {
return getProtocol()
.flatMap(protocol -> protocol.onClientConnect(DefaultTransport.TCP, client, this))
.then(
client
.subscribe()
.filter(tcp -> started.get())
.concatMap(this::handleTcpMessage)
.onErrorResume((err) -> {
log.error(err.getMessage(), err);
client.shutdown();
return Mono.empty();
})
.then()
)
.doOnCancel(client::shutdown);
}
Mono<Void> handleTcpMessage(TcpMessage message) {
return getProtocol()
.flatMap(pt -> pt.getMessageCodec(DefaultTransport.TCP))
.flatMapMany(codec -> codec.decode(FromDeviceMessageContext.of(
sessionRef.get(), message, registry, msg -> handleDeviceMessage(msg).then())))
.cast(DeviceMessage.class)
.concatMap(msg -> this
.handleDeviceMessage(msg)
.as(MonoTracer.create(
DeviceTracer.SpanName.decode(msg.getDeviceId()),
(span, _msg) -> span.setAttributeLazy(DeviceTracer.SpanKey.message, _msg::toString))))
.onErrorResume((err) -> {
log.error("Handle TCP[{}] message failed:\n{}",
address,
message
, err);
return Mono.fromRunnable(client::reset);
})
.subscribeOn(Schedulers.parallel())
.then();
}
Mono<DeviceMessage> handleDeviceMessage(DeviceMessage message) {
Disposable checker = legalityChecker;
if (checker != null) {
checker.dispose();
legalityChecker = null;
}
monitor.receivedMessage();
return helper
.handleDeviceMessage(
message,
device -> new TcpDeviceSession(device, client,DefaultTransport.TCP, monitor),
session -> {
TcpDeviceSession deviceSession = session.unwrap(TcpDeviceSession.class);
deviceSession.setClient(client);
sessionRef.set(deviceSession);
},
() -> log.warn("TCP{}: The device[{}] in the message body does not exist:{}", address, message.getDeviceId(), message)
)
.thenReturn(message);
}
@Override
public Mono<DeviceOperator> getDevice(String deviceId) {
return registry.getDevice(deviceId);
}
@Override
public Mono<DeviceProductOperator> getProduct(String productId) {
return registry.getProduct(productId);
}
@Override
public Mono<Void> onMessage(DeviceMessage message) {
return handleDeviceMessage(message).then();
}
}
|
//超过时间还未获取到任何设备则认为连接不合法，自动断开连接
if ((sessionRef.get() instanceof UnknownTcpDeviceSession)) {
log.info("tcp [{}] connection is illegal, close it.", address);
try {
client.disconnect();
} catch (Throwable ignore) {
}
}
| 1,035
| 87
| 1,122
|
<methods>public void <init>(java.lang.String) ,public final void doOnShutdown(reactor.core.Disposable) ,public final void doOnStateChange(BiConsumer<org.jetlinks.community.gateway.GatewayState,org.jetlinks.community.gateway.GatewayState>) ,public final java.lang.String getId() ,public final org.jetlinks.community.gateway.GatewayState getState() ,public final boolean isAlive() ,public Flux<org.jetlinks.core.message.Message> onMessage() ,public final Mono<java.lang.Void> pause() ,public final Mono<java.lang.Void> shutdown() ,public final synchronized Mono<java.lang.Void> startup() <variables>private static final AtomicReferenceFieldUpdater<org.jetlinks.community.gateway.AbstractDeviceGateway,org.jetlinks.community.gateway.GatewayState> STATE,private final non-sealed java.lang.String id,protected final non-sealed org.jetlinks.community.gateway.monitor.DeviceGatewayMonitor monitor,private volatile org.jetlinks.community.gateway.GatewayState state,private final List<BiConsumer<org.jetlinks.community.gateway.GatewayState,org.jetlinks.community.gateway.GatewayState>> stateListener
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/tcp-component/src/main/java/org/jetlinks/community/network/tcp/gateway/device/TcpServerDeviceGatewayProvider.java
|
TcpServerDeviceGatewayProvider
|
createDeviceGateway
|
class TcpServerDeviceGatewayProvider implements DeviceGatewayProvider {
private final NetworkManager networkManager;
private final DeviceRegistry registry;
private final DeviceSessionManager sessionManager;
private final DecodedClientMessageHandler messageHandler;
private final ProtocolSupports protocolSupports;
public TcpServerDeviceGatewayProvider(NetworkManager networkManager,
DeviceRegistry registry,
DeviceSessionManager sessionManager,
DecodedClientMessageHandler messageHandler,
ProtocolSupports protocolSupports) {
this.networkManager = networkManager;
this.registry = registry;
this.sessionManager = sessionManager;
this.messageHandler = messageHandler;
this.protocolSupports = protocolSupports;
}
@Override
public String getId() {
return "tcp-server-gateway";
}
@Override
public String getName() {
return "TCP 透传接入";
}
public NetworkType getNetworkType() {
return DefaultNetworkType.TCP_SERVER;
}
public Transport getTransport() {
return DefaultTransport.TCP;
}
@Override
public Mono<DeviceGateway> createDeviceGateway(DeviceGatewayProperties properties) {<FILL_FUNCTION_BODY>}
@Override
public Mono<? extends DeviceGateway> reloadDeviceGateway(DeviceGateway gateway,
DeviceGatewayProperties properties) {
TcpServerDeviceGateway deviceGateway = ((TcpServerDeviceGateway) gateway);
//网络组件发生变化
if (!Objects.equals(deviceGateway.tcpServer.getId(), properties.getChannelId())) {
return gateway
.shutdown()
.then(this.createDeviceGateway(properties))
.flatMap(newer -> newer.startup().thenReturn(newer));
}
//更新协议
String protocol = properties.getProtocol();
deviceGateway.protocol = Mono.defer(() -> protocolSupports.getProtocol(protocol));
return Mono.just(gateway);
}
}
|
return networkManager
.<TcpServer>getNetwork(getNetworkType(), properties.getChannelId())
.map(mqttServer -> {
String protocol = properties.getProtocol();
Assert.hasText(protocol, "protocol can not be empty");
return new TcpServerDeviceGateway(
properties.getId(),
Mono.defer(() -> protocolSupports.getProtocol(protocol)),
registry,
messageHandler,
sessionManager,
mqttServer
);
});
| 531
| 132
| 663
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/tcp-component/src/main/java/org/jetlinks/community/network/tcp/parser/DefaultPayloadParserBuilder.java
|
DefaultPayloadParserBuilder
|
postProcessAfterInitialization
|
class DefaultPayloadParserBuilder implements PayloadParserBuilder, BeanPostProcessor {
private final Map<PayloadParserType, PayloadParserBuilderStrategy> strategyMap = new ConcurrentHashMap<>();
public DefaultPayloadParserBuilder(){
register(new FixLengthPayloadParserBuilder());
register(new DelimitedPayloadParserBuilder());
register(new ScriptPayloadParserBuilder());
register(new DirectPayloadParserBuilder());
register(new LengthFieldPayloadParserBuilder());
}
@Override
public Supplier<PayloadParser> build(PayloadParserType type, ValueObject configuration) {
return Optional.ofNullable(strategyMap.get(type))
.map(builder -> builder.buildLazy(configuration))
.orElseThrow(() -> new UnsupportedOperationException("unsupported parser:" + type));
}
public void register(PayloadParserBuilderStrategy strategy) {
strategyMap.put(strategy.getType(), strategy);
}
@Override
public Object postProcessAfterInitialization(@Nonnull Object bean,@Nonnull String beanName) throws BeansException {<FILL_FUNCTION_BODY>}
}
|
if (bean instanceof PayloadParserBuilderStrategy) {
register(((PayloadParserBuilderStrategy) bean));
}
return bean;
| 284
| 37
| 321
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/tcp-component/src/main/java/org/jetlinks/community/network/tcp/parser/LengthFieldPayloadParserBuilder.java
|
LengthFieldPayloadParserBuilder
|
buildLazy
|
class LengthFieldPayloadParserBuilder implements PayloadParserBuilderStrategy {
@Override
public PayloadParserType getType() {
return PayloadParserType.LENGTH_FIELD;
}
@Override
@SneakyThrows
public Supplier<PayloadParser> buildLazy(ValueObject config) {<FILL_FUNCTION_BODY>}
}
|
//偏移量
int offset = config.getInt("offset")
.orElse(0);
//包长度
int len = config.getInt("length")
.orElseGet(() -> config
.getInt("to")
.orElse(4) - offset);
//是否为小端模式
boolean le = config.getBoolean("little")
.orElse(false);
int initLength = offset + len;
Function<Buffer, Integer> lengthParser;
switch (len) {
case 1:
lengthParser = buffer -> (int) buffer.getUnsignedByte(offset);
break;
case 2:
lengthParser =
le ? buffer -> buffer.getUnsignedShortLE(offset)
: buffer -> buffer.getUnsignedShort(offset);
break;
case 3:
lengthParser =
le ? buffer -> buffer.getUnsignedMediumLE(offset)
: buffer -> (int) buffer.getUnsignedMedium(offset);
break;
case 4:
lengthParser =
le ? buffer -> buffer.getIntLE(offset)
: buffer -> (int) buffer.getInt(offset);
break;
case 8:
lengthParser =
le ? buffer -> (int) buffer.getLongLE(offset)
: buffer -> (int) buffer.getLong(offset);
break;
default:
throw new IllegalArgumentException("illegal length:" + len);
}
return () -> new PipePayloadParser()
//先读取初始长度
.fixed(initLength)
.handler((buffer, parser) -> {
//获取长度字段，然后读取接下来的长度
int next = lengthParser.apply(buffer);
parser.result(buffer)
.fixed(next);
})
.handler((buffer, parser) -> parser
.result(buffer)
.complete());
| 93
| 506
| 599
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/tcp-component/src/main/java/org/jetlinks/community/network/tcp/parser/strateies/DelimitedPayloadParserBuilder.java
|
DelimitedPayloadParserBuilder
|
createParser
|
class DelimitedPayloadParserBuilder extends VertxPayloadParserBuilder {
@Override
public PayloadParserType getType() {
return PayloadParserType.DELIMITED;
}
@Override
@SneakyThrows
protected Supplier<RecordParser> createParser(ValueObject config) {<FILL_FUNCTION_BODY>}
}
|
String delimited = config
.getString("delimited")
.map(String::trim)
.orElseThrow(() -> new IllegalArgumentException("delimited can not be null"));
if (delimited.startsWith("0x")) {
byte[] hex = Hex.decodeHex(delimited.substring(2));
return () -> RecordParser
.newDelimited(Buffer.buffer(hex));
}
return () -> RecordParser.newDelimited(StringEscapeUtils.unescapeJava(delimited));
| 95
| 145
| 240
|
<methods>public non-sealed void <init>() ,public Supplier<org.jetlinks.community.network.tcp.parser.PayloadParser> buildLazy(org.jetlinks.community.ValueObject) ,public abstract org.jetlinks.community.network.tcp.parser.PayloadParserType getType() <variables>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/tcp-component/src/main/java/org/jetlinks/community/network/tcp/parser/strateies/FixLengthPayloadParserBuilder.java
|
FixLengthPayloadParserBuilder
|
createParser
|
class FixLengthPayloadParserBuilder extends VertxPayloadParserBuilder {
@Override
public PayloadParserType getType() {
return PayloadParserType.FIXED_LENGTH;
}
@Override
protected Supplier<RecordParser> createParser(ValueObject config) {<FILL_FUNCTION_BODY>}
}
|
int size = config.getInt("size")
.orElseThrow(() -> new IllegalArgumentException("size can not be null"));
return () -> RecordParser.newFixed(size);
| 87
| 50
| 137
|
<methods>public non-sealed void <init>() ,public Supplier<org.jetlinks.community.network.tcp.parser.PayloadParser> buildLazy(org.jetlinks.community.ValueObject) ,public abstract org.jetlinks.community.network.tcp.parser.PayloadParserType getType() <variables>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/tcp-component/src/main/java/org/jetlinks/community/network/tcp/parser/strateies/PipePayloadParser.java
|
PipePayloadParser
|
complete
|
class PipePayloadParser implements PayloadParser {
private final static AtomicIntegerFieldUpdater<PipePayloadParser> CURRENT_PIPE =
AtomicIntegerFieldUpdater.newUpdater(PipePayloadParser.class, "currentPipe");
private final Sinks.Many<Buffer> sink = Reactors.createMany();
private final List<BiConsumer<Buffer, PipePayloadParser>> pipe = new CopyOnWriteArrayList<>();
private final List<Buffer> result = new CopyOnWriteArrayList<>();
private volatile RecordParser recordParser;
private Function<Buffer, Buffer> directMapper;
private Consumer<RecordParser> firstInit;
private volatile int currentPipe;
public Buffer newBuffer() {
return Buffer.buffer();
}
public PipePayloadParser result(String buffer) {
return result(Buffer.buffer(buffer));
}
public PipePayloadParser result(byte[] buffer) {
return result(Buffer.buffer(buffer));
}
// public PipePayloadParser handler(Consumer<Buffer> handler) {
//
// return handler((payloadParser, buffer) -> handler.accept(buffer));
// }
public PipePayloadParser handler(BiConsumer<Buffer, PipePayloadParser> handler) {
pipe.add(handler);
return this;
}
public PipePayloadParser delimited(String delimited) {
if (recordParser == null) {
setParser(RecordParser.newDelimited(delimited));
firstInit = (parser -> parser.delimitedMode(delimited));
return this;
}
recordParser.delimitedMode(delimited);
return this;
}
public PipePayloadParser fixed(int size) {
if (size == 0) {
complete();
return this;
}
if (recordParser == null) {
setParser(RecordParser.newFixed(size));
firstInit = (parser -> parser.fixedSizeMode(size));
return this;
}
recordParser.fixedSizeMode(size);
return this;
}
public PipePayloadParser direct(Function<Buffer, Buffer> mapper) {
this.directMapper = mapper;
return this;
}
private BiConsumer<Buffer, PipePayloadParser> getNextHandler() {
int i = CURRENT_PIPE.getAndIncrement(this);
if (i < pipe.size()) {
return pipe.get(i);
}
CURRENT_PIPE.set(this, 0);
return pipe.get(0);
}
private void setParser(RecordParser parser) {
this.recordParser = parser;
this.recordParser.handler(buffer -> getNextHandler().accept(buffer, this));
}
public PipePayloadParser complete() {<FILL_FUNCTION_BODY>}
public PipePayloadParser result(Buffer buffer) {
this.result.add(buffer);
return this;
}
@Override
public synchronized void handle(Buffer buffer) {
if (recordParser == null && directMapper == null) {
log.error("record parser not init");
return;
}
if (recordParser != null) {
recordParser.handle(buffer);
return;
}
Buffer buf = directMapper.apply(buffer);
if (null != buf) {
sink.emitNext(buf, Reactors.emitFailureHandler());
}
}
@Override
public Flux<Buffer> handlePayload() {
return sink.asFlux();
}
@Override
public void reset() {
this.result.clear();
complete();
}
@Override
public void close() {
sink.tryEmitComplete();
CURRENT_PIPE.set(this, 0);
this.result.clear();
}
}
|
CURRENT_PIPE.set(this, 0);
if (recordParser != null) {
firstInit.accept(recordParser);
}
if (!this.result.isEmpty()) {
Buffer buffer = Buffer.buffer();
for (Buffer buf : this.result) {
buffer.appendBuffer(buf);
}
this.result.clear();
sink.emitNext(buffer, Reactors.emitFailureHandler());
}
return this;
| 1,010
| 122
| 1,132
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/tcp-component/src/main/java/org/jetlinks/community/network/tcp/parser/strateies/ScriptPayloadParserBuilder.java
|
ScriptPayloadParserBuilder
|
buildLazy
|
class ScriptPayloadParserBuilder implements PayloadParserBuilderStrategy {
@Override
public PayloadParserType getType() {
return PayloadParserType.SCRIPT;
}
@Override
@SneakyThrows
public Supplier<PayloadParser> buildLazy(ValueObject config) {<FILL_FUNCTION_BODY>}
}
|
String script = config.getString("script")
.orElseThrow(() -> new IllegalArgumentException("script不能为空"));
String lang = config.getString("lang")
.orElse("js");
CompiledScript compiledScript = Scripts
.getFactory(lang)
.compile(Script.of("tcp-network-payload-parser", script));
return () -> {
PipePayloadParser parser = new PipePayloadParser();
Map<String, Object> ctx = new HashMap<>();
ctx.put("parser", parser);
compiledScript.call(ctx);
return parser;
};
| 88
| 160
| 248
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/tcp-component/src/main/java/org/jetlinks/community/network/tcp/parser/strateies/VertxPayloadParserBuilder.java
|
RecordPayloadParser
|
reset
|
class RecordPayloadParser implements PayloadParser {
private final Supplier<RecordParser> recordParserSupplier;
private final Sinks.Many<Buffer> sink = Reactors.createMany();
private RecordParser recordParser;
public RecordPayloadParser(Supplier<RecordParser> recordParserSupplier) {
this.recordParserSupplier = recordParserSupplier;
reset();
}
@Override
public void handle(Buffer buffer) {
recordParser.handle(buffer);
}
@Override
public Flux<Buffer> handlePayload() {
return sink.asFlux();
}
@Override
public void close() {
sink.emitComplete(Reactors.emitFailureHandler());
}
@Override
public void reset() {<FILL_FUNCTION_BODY>}
}
|
this.recordParser = recordParserSupplier.get();
this.recordParser.handler(payload -> {
sink.emitNext(payload, Reactors.emitFailureHandler());
});
| 210
| 51
| 261
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/tcp-component/src/main/java/org/jetlinks/community/network/tcp/server/DefaultTcpServerProvider.java
|
DefaultTcpServerProvider
|
getConfigMetadata
|
class DefaultTcpServerProvider implements NetworkProvider<TcpServerProperties> {
private final CertificateManager certificateManager;
private final Vertx vertx;
private final PayloadParserBuilder payloadParserBuilder;
@Getter
@Setter
private NetServerOptions template = new NetServerOptions();
public DefaultTcpServerProvider(CertificateManager certificateManager, Vertx vertx, PayloadParserBuilder payloadParserBuilder) {
this.certificateManager = certificateManager;
this.vertx = vertx;
this.payloadParserBuilder = payloadParserBuilder;
template.setTcpKeepAlive(true);
}
@Nonnull
@Override
public NetworkType getType() {
return DefaultNetworkType.TCP_SERVER;
}
@Nonnull
@Override
public Mono<Network> createNetwork(@Nonnull TcpServerProperties properties) {
VertxTcpServer tcpServer = new VertxTcpServer(properties.getId());
return initTcpServer(tcpServer, properties);
}
private Mono<Network> initTcpServer(VertxTcpServer tcpServer, TcpServerProperties properties) {
return convert(properties)
.map(options -> {
int instance = Math.max(2, properties.getInstance());
List<NetServer> instances = new ArrayList<>(instance);
for (int i = 0; i < instance; i++) {
instances.add(vertx.createNetServer(options));
}
Supplier<PayloadParser> parserSupplier= payloadParserBuilder.build(properties.getParserType(), properties);
parserSupplier.get();
tcpServer.setParserSupplier(parserSupplier);
tcpServer.setServer(instances);
tcpServer.setKeepAliveTimeout(properties.getLong("keepAliveTimeout", Duration
.ofMinutes(10)
.toMillis()));
tcpServer.setBind(new InetSocketAddress(properties.getHost(), properties.getPort()));
for (NetServer netServer : instances) {
vertx.nettyEventLoopGroup()
.execute(()->{
netServer.listen(properties.createSocketAddress(), result -> {
if (result.succeeded()) {
log.info("tcp server startup on {}", result.result().actualPort());
} else {
tcpServer.setLastError(result.cause().getMessage());
log.error("startup tcp server error", result.cause());
}
});
});
}
return tcpServer;
});
}
@Override
public Mono<Network> reload(@Nonnull Network network, @Nonnull TcpServerProperties properties) {
VertxTcpServer tcpServer = ((VertxTcpServer) network);
tcpServer.shutdown();
return initTcpServer(tcpServer, properties);
}
@Nullable
@Override
public ConfigMetadata getConfigMetadata() {<FILL_FUNCTION_BODY>}
@Nonnull
@Override
public Mono<TcpServerProperties> createConfig(@Nonnull NetworkProperties properties) {
return Mono.fromSupplier(() -> {
TcpServerProperties config = FastBeanCopier.copy(properties.getConfigurations(), new TcpServerProperties());
config.setId(properties.getId());
config.validate();
return config;
})
.as(LocaleUtils::transform);
}
private Mono<NetServerOptions> convert(TcpServerProperties properties) {
NetServerOptions options = new NetServerOptions(template);
options.setPort(properties.getPort());
options.setHost(properties.getHost());
if (properties.isSecure()) {
options.setSsl(true);
return certificateManager
.getCertificate(properties.getCertId())
.map(VertxKeyCertTrustOptions::new)
.doOnNext(options::setKeyCertOptions)
.doOnNext(options::setTrustOptions)
.thenReturn(options);
}
return Mono.just(options);
}
}
|
return new DefaultConfigMetadata()
.add("host", "本地地址", "", new StringType())
.add("port", "本地端口", "", new IntType())
.add("publicHost", "公网地址", "", new StringType())
.add("publicPort", "公网端口", "", new IntType())
.add("certId", "CA证书", "", new StringType().expand("selector", "cert"))
.add("secure", "开启TSL", "", new BooleanType())
.add("parserType", "解析器类型", "", new ObjectType())
.add("parserConfiguration", "配置解析器", "", new ObjectType());
| 1,031
| 162
| 1,193
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/network-component/tcp-component/src/main/java/org/jetlinks/community/network/tcp/server/VertxTcpServer.java
|
VertxTcpServer
|
acceptTcpConnection
|
class VertxTcpServer implements TcpServer {
Collection<NetServer> tcpServers;
private Supplier<PayloadParser> parserSupplier;
@Setter
private long keepAliveTimeout = Duration.ofMinutes(10).toMillis();
@Getter
private final String id;
private final Sinks.Many<TcpClient> sink = Reactors.createMany(Integer.MAX_VALUE,false);
@Getter
@Setter
private String lastError;
@Setter(AccessLevel.PACKAGE)
private InetSocketAddress bind;
public VertxTcpServer(String id) {
this.id = id;
}
@Override
public Flux<TcpClient> handleConnection() {
return sink.asFlux();
}
private void execute(Runnable runnable) {
try {
runnable.run();
} catch (Exception e) {
log.warn("close tcp server error", e);
}
}
@Override
public InetSocketAddress getBindAddress() {
return bind;
}
public void setParserSupplier(Supplier<PayloadParser> parserSupplier) {
this.parserSupplier = parserSupplier;
}
public void setServer(Collection<NetServer> servers) {
if (this.tcpServers != null && !this.tcpServers.isEmpty()) {
shutdown();
}
this.tcpServers = servers;
for (NetServer tcpServer : this.tcpServers) {
tcpServer.connectHandler(this::acceptTcpConnection);
}
}
protected void acceptTcpConnection(NetSocket socket) {<FILL_FUNCTION_BODY>}
@Override
public NetworkType getType() {
return DefaultNetworkType.TCP_SERVER;
}
@Override
public void shutdown() {
if (null != tcpServers) {
log.debug("close tcp server :[{}]", id);
for (NetServer tcpServer : tcpServers) {
execute(tcpServer::close);
}
tcpServers = null;
}
}
@Override
public boolean isAlive() {
return tcpServers != null;
}
@Override
public boolean isAutoReload() {
return false;
}
}
|
if (sink.currentSubscriberCount() == 0) {
log.warn("not handler for tcp client[{}]", socket.remoteAddress());
socket.close();
return;
}
VertxTcpClient client = new VertxTcpClient(id + "_" + socket.remoteAddress());
client.setKeepAliveTimeoutMs(keepAliveTimeout);
try {
socket.exceptionHandler(err -> {
log.error("tcp server client [{}] error", socket.remoteAddress(), err);
});
client.setRecordParser(parserSupplier.get());
client.setSocket(socket);
sink.emitNext(client, Reactors.emitFailureHandler());
log.debug("accept tcp client [{}] connection", socket.remoteAddress());
} catch (Exception e) {
log.error("create tcp server client error", e);
client.shutdown();
}
| 621
| 230
| 851
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/AbstractNotifier.java
|
AbstractNotifier
|
send
|
class AbstractNotifier<T extends Template> implements Notifier<T> {
private final TemplateManager templateManager;
@Override
@Nonnull
public Mono<Void> send(@Nonnull String templateId, @Nonnull Values context) {<FILL_FUNCTION_BODY>}
}
|
return templateManager
.getTemplate(getType(), templateId)
.switchIfEmpty(Mono.error(new UnsupportedOperationException("模版不存在:" + templateId)))
.flatMap(tem -> send((T) tem, context));
| 78
| 65
| 143
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/DefaultNotifierManager.java
|
DefaultNotifierManager
|
run
|
class DefaultNotifierManager implements NotifierManager, BeanPostProcessor, CommandLineRunner {
private final Map<String, Map<String, NotifierProvider>> providers = new ConcurrentHashMap<>();
private Map<String, Notifier> notifiers = new ConcurrentHashMap<>();
private NotifyConfigManager configManager;
private EventBus eventBus;
public DefaultNotifierManager(EventBus eventBus, NotifyConfigManager manager) {
this.configManager = manager;
this.eventBus = eventBus;
}
protected Mono<NotifierProperties> getProperties(NotifyType notifyType,
String id) {
return configManager.getNotifyConfig(notifyType, id);
}
public Mono<Void> reload(String id) {
return this
.doReload(id)
.then(eventBus.publish("/_sys/notifier/reload", id))
.then();
}
private Mono<String> doReload(String id) {
log.debug("reload notifer config {}",id);
return Mono
.justOrEmpty(notifiers.remove(id))
.flatMap(Notifier::close)
.thenReturn(id);
}
@Nonnull
public Mono<Notifier> createNotifier(NotifierProperties properties) {
return Mono
.justOrEmpty(providers.get(properties.getType()))
.switchIfEmpty(Mono.error(() -> new UnsupportedOperationException("不支持的通知类型:" + properties.getType())))
.flatMap(map -> Mono.justOrEmpty(map.get(properties.getProvider())))
.switchIfEmpty(Mono.error(() -> new UnsupportedOperationException("不支持的服务商:" + properties.getProvider())))
.flatMap(notifierProvider -> notifierProvider.createNotifier(properties))
//转成代理,把通知事件发送到消息网关中.
.map(notifier -> new NotifierEventDispatcher<>(eventBus, notifier))
.flatMap(notifier -> Mono.justOrEmpty(notifiers.put(properties.getId(), notifier))
.flatMap(Notifier::close)//如果存在旧的通知器则关掉之
.thenReturn(notifier));
}
@Override
@Nonnull
public Mono<Notifier> getNotifier(@Nonnull NotifyType type,
@Nonnull String id) {
return Mono
.justOrEmpty(notifiers.get(id))
.switchIfEmpty(Mono.defer(() -> this.getProperties(type, id).flatMap(this::createNotifier)));
}
public void registerProvider(NotifierProvider provider) {
providers.computeIfAbsent(provider.getType().getId(), ignore -> new ConcurrentHashMap<>())
.put(provider.getProvider().getId(), provider);
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof NotifierProvider) {
registerProvider(((NotifierProvider) bean));
}
return bean;
}
@Override
public void run(String... args) throws Exception {<FILL_FUNCTION_BODY>}
}
|
eventBus
.subscribe(
Subscription.builder()
.subscriberId("notifier-loader")
.topics("/_sys/notifier/reload")
.justBroker()
.build(),
String.class
)
.flatMap(id -> this
.doReload(id)
.onErrorResume(err -> {
log.error("reload notifer config error", err);
return Mono.empty();
}))
.subscribe();
| 817
| 132
| 949
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/NotifierEventDispatcher.java
|
NotifierEventDispatcher
|
onEvent
|
class NotifierEventDispatcher<T extends Template> extends NotifierProxy<T> {
private final EventBus eventBus;
public NotifierEventDispatcher(EventBus eventBus, Notifier<T> target) {
super(target);
this.eventBus = eventBus;
}
@Override
protected Mono<Void> onEvent(NotifierEvent event) {<FILL_FUNCTION_BODY>}
}
|
// /notify/{notifierId}/success
return eventBus
.publish(String.join("/", "/notify", event.getNotifierId(), event.isSuccess() ? "success" : "error"), event.toSerializable())
.then();
| 111
| 65
| 176
|
<methods>public non-sealed void <init>() ,public Mono<java.lang.Void> close() ,public java.lang.String getNotifierId() ,public org.jetlinks.community.notify.Provider getProvider() ,public org.jetlinks.community.notify.NotifyType getType() ,public boolean isWrapperFor(Class<?>) ,public Mono<java.lang.Void> send(java.lang.String, org.jetlinks.core.Values) ,public Mono<java.lang.Void> send(T, org.jetlinks.core.Values) ,public R unwrap(Class<R>) <variables>private final non-sealed Notifier<T> target
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/NotifierProxy.java
|
NotifierProxy
|
onSuccess
|
class NotifierProxy<T extends Template> implements Notifier<T> {
private final Notifier<T> target;
@Override
public String getNotifierId() {
return target.getNotifierId();
}
@Nonnull
@Override
public NotifyType getType() {
return target.getType();
}
@Nonnull
@Override
public Provider getProvider() {
return target.getProvider();
}
@Override
public <R> R unwrap(Class<R> type) {
return target.unwrap(type);
}
@Override
public boolean isWrapperFor(Class<?> type) {
return target.isWrapperFor(type);
}
@Nonnull
@Override
public Mono<Void> send(@Nonnull String templateId, Values context) {
return target
.send(templateId, context)
.then(Mono.defer(() -> onSuccess(templateId, context)))
.onErrorResume(err -> onError(templateId, context, err).then(Mono.error(err)));
}
@Nonnull
@Override
public Mono<Void> send(@Nonnull T template, @Nonnull Values context) {
return target
.send(template, context)
.then(Mono.defer(() -> onSuccess(template, context)))
.onErrorResume(err -> onError(template, context, err).then(Mono.error(err)));
}
protected Mono<Void> onError(T template, Values ctx, Throwable error) {
return onEvent(NotifierEvent.builder()
.cause(error)
.context(ctx.getAllValues())
.notifierId(getNotifierId())
.notifyType(getType())
.provider(getProvider())
.template(template)
.build());
}
protected Mono<Void> onError(String templateId, Values ctx, Throwable error) {
return onEvent(NotifierEvent.builder()
.cause(error)
.context(ctx.getAllValues())
.notifierId(getNotifierId())
.notifyType(getType())
.provider(getProvider())
.templateId(templateId)
.build());
}
protected Mono<Void> onSuccess(String templateId, Values ctx) {
return onEvent(NotifierEvent.builder()
.success(true)
.context(ctx.getAllValues())
.notifierId(getNotifierId())
.notifyType(getType())
.provider(getProvider())
.templateId(templateId)
.build());
}
protected Mono<Void> onSuccess(T template, Values ctx) {<FILL_FUNCTION_BODY>}
protected abstract Mono<Void> onEvent(NotifierEvent event);
@Nonnull
@Override
public Mono<Void> close() {
return target.close();
}
}
|
return onEvent(NotifierEvent.builder()
.success(true)
.context(ctx.getAllValues())
.notifierId(getNotifierId())
.notifyType(getType())
.provider(getProvider())
.template(template)
.build());
| 773
| 74
| 847
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/StaticTemplateManager.java
|
StaticTemplateManager
|
postProcessAfterInitialization
|
class StaticTemplateManager extends AbstractTemplateManager implements BeanPostProcessor {
private StaticNotifyProperties properties;
public StaticTemplateManager(StaticNotifyProperties properties) {
this.properties = properties;
}
public void register(TemplateProvider provider) {
super.register(provider);
}
@Override
protected Mono<TemplateProperties> getProperties(NotifyType type, String id) {
return Mono.justOrEmpty(properties.getTemplateProperties(type, id));
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {<FILL_FUNCTION_BODY>}
}
|
if(bean instanceof TemplateProvider){
register(((TemplateProvider) bean));
}
return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
| 167
| 48
| 215
|
<methods>public non-sealed void <init>() ,public Mono<? extends org.jetlinks.community.notify.template.Template> createTemplate(org.jetlinks.community.notify.NotifyType, org.jetlinks.community.notify.template.TemplateProperties) ,public Mono<? extends org.jetlinks.community.notify.template.Template> getTemplate(org.jetlinks.community.notify.NotifyType, java.lang.String) ,public Mono<java.lang.Void> reload(java.lang.String) <variables>protected final Map<java.lang.String,Map<java.lang.String,org.jetlinks.community.notify.template.TemplateProvider>> providers,protected final Map<java.lang.String,org.jetlinks.community.notify.template.Template> templates
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/configuration/CompositeNotifyConfigManager.java
|
CompositeNotifyConfigManager
|
getNotifyConfig
|
class CompositeNotifyConfigManager implements NotifyConfigManager {
private final List<NotifyConfigManager> managers;
@Nonnull
@Override
public Mono<NotifierProperties> getNotifyConfig(@Nonnull NotifyType notifyType,
@Nonnull String configId) {<FILL_FUNCTION_BODY>}
}
|
Mono<NotifierProperties> mono = null;
for (NotifyConfigManager manager : managers) {
if (mono == null) {
mono = manager.getNotifyConfig(notifyType, configId);
} else {
mono = mono.switchIfEmpty(manager.getNotifyConfig(notifyType, configId));
}
}
return mono == null ? Mono.empty() : mono;
| 85
| 111
| 196
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/configuration/CompositeTemplateManager.java
|
CompositeTemplateManager
|
doWith
|
class CompositeTemplateManager implements TemplateManager {
private final List<TemplateManager> managers;
private <T> Mono<T> doWith(Function<TemplateManager, Mono<T>> executor) {<FILL_FUNCTION_BODY>}
@Nonnull
@Override
public Mono<? extends Template> getTemplate(@Nonnull NotifyType type, @Nonnull String id) {
return this
.doWith(manager -> manager
.getTemplate(type, id)
.onErrorResume(UnsupportedOperationException.class, err -> Mono.empty()))
.switchIfEmpty(Mono.error(() -> new UnsupportedOperationException("通知类型不支持:" + type.getId())));
}
@Nonnull
@Override
public Mono<? extends Template> createTemplate(@Nonnull NotifyType type, @Nonnull TemplateProperties properties) {
return this
.doWith(manager -> manager
.createTemplate(type, properties)
.onErrorResume(UnsupportedOperationException.class, err -> Mono.empty()))
.switchIfEmpty(Mono.error(() -> new UnsupportedOperationException("通知类型不支持:" + type.getId())));
}
@Nonnull
@Override
public Mono<Void> reload(String templateId) {
return doWith(manager -> manager.reload(templateId));
}
}
|
Mono<T> mono = null;
for (TemplateManager manager : managers) {
if (mono == null) {
mono = executor.apply(manager);
} else {
mono = mono.switchIfEmpty(executor.apply(manager));
}
}
return mono == null ? Mono.empty() : mono;
| 349
| 98
| 447
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/configuration/StaticNotifyProperties.java
|
StaticNotifyProperties
|
getTemplateProperties
|
class StaticNotifyProperties {
private Map<String, List<NotifierProperties>> configs = new ConcurrentHashMap<>();
private Map<String, List<TemplateProperties>> templates = new ConcurrentHashMap<>();
public Optional<NotifierProperties> getNotifierProperties(NotifyType type,String id){
List<NotifierProperties> properties= configs.get(type.getId());
if(properties == null){
return Optional.empty();
}
return properties
.stream()
.filter(prop-> {
prop.setType(type.getId());
return Objects.equals(id,prop.getId());
})
.findAny();
}
public Optional<TemplateProperties> getTemplateProperties(NotifyType type,String id){<FILL_FUNCTION_BODY>}
@Setter
@Getter
public static class ObjectTemplateProperties extends TemplateProperties{
private Map<String,Object> templateObject;
public void setTemplateObject(Map<String, Object> templateObject) {
this.templateObject = templateObject;
this.setTemplate(templateObject);
}
}
}
|
List<TemplateProperties> properties= templates.get(type.getId());
if(properties==null){
return Optional.empty();
}
return properties
.stream()
.filter(prop-> {
prop.setType(type.getId());
return Objects.equals(id,prop.getId());
})
.findAny();
| 285
| 90
| 375
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/event/NotifierEvent.java
|
NotifierEvent
|
toSerializable
|
class NotifierEvent {
private boolean success;
@Nullable
private Throwable cause;
@Nonnull
private String notifierId;
@Nonnull
private NotifyType notifyType;
@Nonnull
private Provider provider;
@Nullable
private String templateId;
@Nullable
private Template template;
@Nonnull
private Map<String, Object> context;
public SerializableNotifierEvent toSerializable() {<FILL_FUNCTION_BODY>}
}
|
return SerializableNotifierEvent.builder()
.success(success)
.notifierId(notifierId)
.notifyType(notifyType.getId())
.provider(provider.getId())
.templateId(templateId)
.template(template)
.context(context)
.cause(cause != null ? StringUtils.throwable2String(cause) : "")
.errorType(cause != null ? cause.getClass().getName() : null)
.build();
| 136
| 124
| 260
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/rule/NotifierTaskExecutorProvider.java
|
NotifierTaskExecutor
|
createProperties
|
class NotifierTaskExecutor extends FunctionTaskExecutor {
private RuleNotifierProperties properties;
public NotifierTaskExecutor(ExecutionContext context) {
super("消息通知", context);
this.properties = createProperties();
}
@Override
protected Publisher<RuleData> apply(RuleData input) {
return notifierManager
.getNotifier(properties.getNotifyType(), properties.getNotifierId())
.switchIfEmpty(Mono.fromRunnable(() -> {
context.getLogger().warn("通知配置[{}-{}]不存在", properties.getNotifyType(), properties.getNotifierId());
}))
.flatMap(notifier -> notifier.send(properties.getTemplateId(), Values.of(properties.createVariables(input))))
.doOnError(err -> {
context.getLogger().error("发送[{}]通知[{}-{}]失败",
properties.getNotifyType().getName(),
properties.getNotifierId(),
properties.getTemplateId(), err);
})
.doOnSuccess(ignore -> {
context.getLogger().info("发送[{}]通知[{}-{}]完成",
properties.getNotifyType().getName(),
properties.getNotifierId(),
properties.getTemplateId());
}).thenReturn(context.newRuleData(input));
}
@Override
public void reload() {
this.properties = createProperties();
}
RuleNotifierProperties createProperties() {<FILL_FUNCTION_BODY>}
}
|
RuleNotifierProperties properties = FastBeanCopier.copy(context
.getJob()
.getConfiguration(), RuleNotifierProperties.class);
properties.initVariable();
properties.validate();
return properties;
| 392
| 59
| 451
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/rule/RuleNotifierProperties.java
|
RuleNotifierProperties
|
initVariable
|
class RuleNotifierProperties {
private DefaultNotifyType notifyType;
private String notifierId;
private String templateId;
private Map<String, Object> variables;
public void initVariable() {<FILL_FUNCTION_BODY>}
public Map<String, Object> createVariables(RuleData data) {
Map<String, Object> vars = RuleDataHelper.toContextMap(data);
if (MapUtils.isNotEmpty(variables)) {
vars.putAll(VariableSource.wrap(variables,vars));
}
return vars;
}
private VariableSource transformToVariables(String key,
Object value) {
VariableSource source = VariableSource.of(value);
if (source.getSource() == VariableSource.Source.upper
&& Objects.equals(source.getUpperKey(), key)) {
//上游的key与参数key相同了,可能导致无法获取到上游变量
log.warn("The upper key [{}] is the same as the parameter key,", key);
}
return source;
}
public void validate() {
Assert.notNull(notifyType, "notifyType can not be null");
Assert.hasText(notifierId, "notifierId can not be empty");
Assert.hasText(templateId, "templateId can not be empty");
}
}
|
if (MapUtils.isNotEmpty(variables)) {
for (Map.Entry<String, Object> entry : variables.entrySet()) {
Object value = entry.getValue();
if (value instanceof Collection) {
List<VariableSource> sourceList = ((Collection<?>) value)
.stream()
.map(obj -> transformToVariables(entry.getKey(), obj))
.collect(Collectors.toList());
entry.setValue(sourceList);
} else {
VariableSource source = transformToVariables(entry.getKey(), value);
entry.setValue(source);
}
}
}
| 350
| 162
| 512
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/template/AbstractTemplate.java
|
AbstractTemplate
|
addVariable
|
class AbstractTemplate<Self extends AbstractTemplate<Self>> implements Template {
private Map<String, VariableDefinition> variables;
@Getter
private String configId;
public AbstractTemplate() {
}
public Self with(TemplateProperties properties) {
if (this.variables == null) {
this.variables = new LinkedHashMap<>();
}
FastBeanCopier.copy(properties.getTemplate(), this);
this.configId = properties.getConfigId();
//内置变量
for (VariableDefinition variable : getEmbeddedVariables()) {
this.variables.put(variable.getId(), variable);
}
//动态配置的变量
if (null != properties.getVariableDefinitions()) {
for (VariableDefinition embeddedVariable : properties.getVariableDefinitions()) {
this.variables.put(embeddedVariable.getId(), embeddedVariable);
}
}
return toSelf();
}
@SuppressWarnings("all")
protected Self toSelf() {
return (Self) this;
}
protected void addVariable(String key, String name, String... descriptions) {
addVariable(
VariableDefinition
.builder()
.id(key)
.name(name)
.description(String.join("", descriptions))
.build()
);
}
protected synchronized void addVariable(VariableDefinition def) {<FILL_FUNCTION_BODY>}
//获取单个变量信息
public final Optional<VariableDefinition> getVariable(String key) {
return Optional.ofNullable(this.getVariables().get(key));
}
@Override
@Nonnull
public final Map<String, VariableDefinition> getVariables() {
return this.variables == null ? Collections.emptyMap() : Collections.unmodifiableMap(this.variables);
}
@Nonnull
protected List<VariableDefinition> getEmbeddedVariables() {
return Collections.emptyList();
}
public Self validate() {
ValidatorUtils.tryValidate(this);
return toSelf();
}
public Map<String,Object> toMap(){
return (JSONObject)JSON.toJSON(this);
}
}
|
if (null == variables) {
variables = new HashMap<>();
}
variables.put(def.getId(), def);
| 574
| 36
| 610
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/template/AbstractTemplateManager.java
|
AbstractTemplateManager
|
createTemplate
|
class AbstractTemplateManager implements TemplateManager {
protected final Map<String, Map<String, TemplateProvider>> providers = new ConcurrentHashMap<>();
protected final Map<String, Template> templates = new ConcurrentHashMap<>();
protected abstract Mono<TemplateProperties> getProperties(NotifyType type, String id);
protected void register(TemplateProvider provider) {
providers.computeIfAbsent(provider.getType().getId(), ignore -> new ConcurrentHashMap<>())
.put(provider.getProvider().getId(), provider);
}
@Override
@Nonnull
public Mono<? extends Template> createTemplate(@Nonnull NotifyType type, @Nonnull TemplateProperties prop) {<FILL_FUNCTION_BODY>}
@Nonnull
@Override
public Mono<? extends Template> getTemplate(@Nonnull NotifyType type, @Nonnull String id) {
return Mono.justOrEmpty(templates.get(id))
.switchIfEmpty(Mono.defer(() -> this
.getProperties(type, id)
.flatMap(prop -> this.createTemplate(type, prop))
.doOnNext(template -> templates.put(id, template))
.switchIfEmpty(Mono.error(() -> new UnsupportedOperationException("通知类型不支持:" + type.getId())))
));
}
@Override
@Nonnull
public Mono<Void> reload(String templateId) {
return doReload(templateId)
.then();
}
private Mono<String> doReload(String templateId) {
log.debug("reload notify template {}",templateId);
return Mono.justOrEmpty(templates.remove(templateId))
.thenReturn(templateId);
}
}
|
return Mono.justOrEmpty(providers.get(type.getId()))
.switchIfEmpty(Mono.error(() -> new UnsupportedOperationException("不支持的通知类型:" + prop.getType())))
.flatMap(map -> Mono
.justOrEmpty(map.get(prop.getProvider()))
.switchIfEmpty(Mono.error(() -> new UnsupportedOperationException("不支持的服务商:" + prop.getProvider())))
.flatMap(provider -> provider.createTemplate(prop)));
| 447
| 131
| 578
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/template/TemplateUtils.java
|
TemplateUtils
|
getVariables
|
class TemplateUtils {
public static Set<String> getVariables(String templateText) {
return getVariables(templateText, "${", "}");
}
public static Set<String> getVariables(String templateText, String suffix, String prefix) {<FILL_FUNCTION_BODY>}
public static String simpleRender(String templateText,
Map<String, Object> context) {
return simpleRender(templateText, context, var -> null);
}
public static String simpleRender(String templateText,
Map<String, Object> context,
Function<String, VariableDefinition> variables) {
return TemplateParser
.parse(templateText, varName -> {
//html ?
if (varName.contains("<")) {
varName = Jsoup
.parse(varName)
.text();
}
VariableDefinition def = variables.apply(varName);
Object value = VariableSource.resolveValue(varName, context);
if (def != null) {
return def.convertValue(value);
}
//没有定义变量,也没有值,应该报错?
if (null == value) {
return "";
}
return String.valueOf(value);
});
}
}
|
final Set<String> variable = new LinkedHashSet<>();
TemplateParser parser = new TemplateParser();
parser.setTemplate(templateText);
parser.setPrepareStartSymbol(suffix.toCharArray());
parser.setPrepareEndSymbol(prefix.toCharArray());
parser.parse(varName -> {
//html ?
if (varName.contains("<")) {
varName = Jsoup
.parse(varName)
.text();
}
variable.add(varName);
return "";
});
return variable;
| 322
| 148
| 470
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-core/src/main/java/org/jetlinks/community/notify/template/VariableDefinition.java
|
VariableDefinition
|
convertValue
|
class VariableDefinition {
@Schema(description = "变量标识")
@NotBlank
private String id;
@Schema(description = "变量名称")
private String name;
@Schema(description = "说明")
private String description;
/**
* @see DataType#getId()
* @see org.jetlinks.core.metadata.types.DoubleType
* @see DateTimeType
* @see org.jetlinks.core.metadata.types.FileType
*/
@Schema(description = "类型")
private String type;
@Schema(description = "是否必选")
private boolean required;
/**
* @see Variable.FileFormat
*/
@Schema(description = "格式")
private String format;
@Schema(description = "其他配置")
private Map<String, Object> expands;
@Schema(description = "默认值")
private String defaultValue;
public static VariableDefinitionBuilder builder() {
return new VariableDefinitionBuilder();
}
public String convertValue(Object value) {<FILL_FUNCTION_BODY>}
private DataType lookupType() {
DataType dataType = Optional
.ofNullable(DataTypes.lookup(type))
.map(Supplier::get)
.orElse(StringType.GLOBAL);
if (dataType instanceof AbstractType) {
((AbstractType<?>) dataType).expands(expands);
if (StringUtils.hasText(format)) {
((AbstractType<?>) dataType).expand(ConfigMetadataConstants.format, format);
}
}
return dataType;
}
public static class VariableDefinitionBuilder {
private @NotBlank String id;
private String name;
private String description;
private String type;
private boolean required;
private String format;
private final Map<String, Object> expands = new HashMap<>();
private String defaultValue;
VariableDefinitionBuilder() {
}
public VariableDefinitionBuilder id(@NotBlank String id) {
this.id = id;
return this;
}
public VariableDefinitionBuilder name(String name) {
this.name = name;
return this;
}
public VariableDefinitionBuilder description(String description) {
this.description = description;
return this;
}
public VariableDefinitionBuilder type(String type) {
this.type = type;
return this;
}
public VariableDefinitionBuilder type(DataType type) {
this.type = type.getType();
return expands(type.getExpands());
}
public VariableDefinitionBuilder required(boolean required) {
this.required = required;
return this;
}
public VariableDefinitionBuilder format(String format) {
this.format = format;
return this;
}
public VariableDefinitionBuilder expands(Map<String, Object> expands) {
if (expands == null) {
return this;
}
this.expands.putAll(expands);
return this;
}
public VariableDefinitionBuilder expand(ConfigKey<String> key, Object value) {
this.expands.put(key.getKey(), value);
return this;
}
public VariableDefinitionBuilder expand(String key, Object value) {
this.expands.put(key, value);
return this;
}
public VariableDefinitionBuilder defaultValue(String defaultValue) {
this.defaultValue = defaultValue;
return this;
}
public VariableDefinition build() {
return new VariableDefinition(id, name, description, type, required, format, expands, defaultValue);
}
public String toString() {
return "VariableDefinition.VariableDefinitionBuilder(id=" + this.id + ", name=" + this.name + ", description=" + this.description + ", type=" + this.type + ", required=" + this.required + ", format=" + this.format + ", expands=" + this.expands + ", defaultValue=" + this.defaultValue + ")";
}
}
}
|
if (value == null) {
value = defaultValue;
}
//必填
if (this.required && value == null) {
throw new ValidationException(id, "error.template_var_required", this.getId(), this.getName());
}
DataType dataType = lookupType();
String fmt = format;
Object val = value;
//为null时返回空字符
if (val == null) {
return "";
}
//日期格式
if (dataType instanceof DateTimeType) {
Date date = ((DateTimeType) dataType).convert(val);
if ("timestamp".equals(fmt)) {
return String.valueOf(date.getTime());
}
if (fmt == null) {
fmt = "yyyy-MM-dd HH:mm:ss";
}
return DateFormatter.toString(date, fmt);
}
//其他格式
if (dataType instanceof Converter) {
val = ((Converter<?>) dataType).convert(val);
}
if (StringUtils.hasText(fmt) && fmt.contains("%")) {
if (val instanceof Number) {
val = ((Number) val).doubleValue();
}
return String.format(fmt, val);
}
return String.valueOf(val);
| 1,059
| 336
| 1,395
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-dingtalk/src/main/java/org/jetlinks/community/notify/dingtalk/corp/DingTalkMessageTemplate.java
|
DingTalkMessageTemplate
|
createUserIdList
|
class DingTalkMessageTemplate extends AbstractTemplate<DingTalkMessageTemplate> {
public static final String USER_ID_LIST_KEY = "userIdList";
public static final String DEPARTMENT_ID_LIST_KEY = "departmentIdList";
/**
* 应用ID
*/
@NotBlank
private String agentId;
/**
* 接收者的userid列表，最大用户列表长度100。
*/
private String userIdList;
/**
* 接收者的部门id列表，最大列表长度20。
* <p>
* 接收者是部门ID时，包括子部门下的所有用户。
*/
private String departmentIdList;
/**
* 是否发送给企业全部用户。
* <p>
* 说明 当设置为false时必须指定userid_list或dept_id_list其中一个参数的值。
*/
private boolean toAllUser;
@NotBlank
private String message;
@Nonnull
@Override
protected List<VariableDefinition> getEmbeddedVariables() {
if (toAllUser || StringUtils.hasText(userIdList) || StringUtils.hasText(departmentIdList)) {
return Collections.emptyList();
}
List<VariableDefinition> variables = new ArrayList<>(2);
variables.add(
VariableDefinition
.builder()
.id(USER_ID_LIST_KEY)
.name("收信人")
.expand(NotifyVariableBusinessConstant.businessId,
NotifyVariableBusinessConstant.NotifyVariableBusinessTypes.userType)
.type(StringType.ID)
.build()
);
variables.add(
VariableDefinition
.builder()
.id(DEPARTMENT_ID_LIST_KEY)
.name("收信人部门")
.expand(NotifyVariableBusinessConstant.businessId,
NotifyVariableBusinessConstant.NotifyVariableBusinessTypes.orgType)
.type(StringType.ID)
.build()
);
return variables;
}
@SneakyThrows
public Mono<BodyInserters.FormInserter<String>> createFormInserter(BodyInserters.FormInserter<String> inserter,
Values context,
ConfigKey<String> relationPropertyPath) {
return this.createUserIdList(context, relationPropertyPath)
.map(userIdList -> {
inserter.with("agent_id", this.getAgentId())
.with("to_all_user", String.valueOf(toAllUser))
.with("msg", this.createMessage(context));
if (StringUtils.hasText(userIdList)) {
inserter.with("userid_list", userIdList);
}
String deptIdList = this.createDepartmentIdList(context);
if (StringUtils.hasText(deptIdList)) {
inserter.with("dept_id_list", deptIdList);
}
return inserter;
});
}
public Mono<UriComponentsBuilder> createUriParameter(UriComponentsBuilder builder,
Values context,
ConfigKey<String> relationPropertyPath) {
return this.createUserIdList(context, relationPropertyPath)
.map(userIdList -> {
builder.queryParam("agent_id", this.getAgentId())
.queryParam("to_all_user", String.valueOf(toAllUser))
.queryParam("msg", this.createMessage(context));
if (StringUtils.hasText(userIdList)) {
builder.queryParam("userid_list", userIdList);
}
String deptIdList = this.createDepartmentIdList(context);
if (StringUtils.hasText(deptIdList)) {
builder.queryParam("dept_id_list", deptIdList);
}
return builder;
});
}
public Mono<String> createUserIdList(Values context, ConfigKey<String> relationPropertyPath) {<FILL_FUNCTION_BODY>}
public String createDepartmentIdList(Values context) {
return get(this.getDepartmentIdList(), DEPARTMENT_ID_LIST_KEY, context.getAllValues());
}
public String createMessage(Values context) {
JSONObject json = new JSONObject();
json.put("msgtype", "text");
json.put("text", Collections.singletonMap("content", render(message, context.getAllValues())));
return json.toJSONString();
}
}
|
return VariableSource
.resolveValue(USER_ID_LIST_KEY, context.getAllValues(), relationPropertyPath)
.map(String::valueOf)
.filter(StringUtils::hasText)
.defaultIfEmpty(userIdList == null ? "" : userIdList)
.collect(Collectors.joining(","));
| 1,177
| 86
| 1,263
|
<methods>public void <init>() ,public final Optional<org.jetlinks.community.notify.template.VariableDefinition> getVariable(java.lang.String) ,public final Map<java.lang.String,org.jetlinks.community.notify.template.VariableDefinition> getVariables() ,public Map<java.lang.String,java.lang.Object> toMap() ,public org.jetlinks.community.notify.dingtalk.corp.DingTalkMessageTemplate validate() ,public org.jetlinks.community.notify.dingtalk.corp.DingTalkMessageTemplate with(org.jetlinks.community.notify.template.TemplateProperties) <variables>private java.lang.String configId,private Map<java.lang.String,org.jetlinks.community.notify.template.VariableDefinition> variables
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-dingtalk/src/main/java/org/jetlinks/community/notify/dingtalk/corp/DingTalkNotifier.java
|
DingTalkNotifier
|
filter
|
class DingTalkNotifier extends AbstractNotifier<DingTalkMessageTemplate> implements CommandSupport, ExchangeFilterFunction {
private final WebClient client;
private final DingTalkProperties properties;
private volatile Mono<String> token;
@Getter
private final String notifierId;
public DingTalkNotifier(String id, WebClient.Builder client, DingTalkProperties properties, TemplateManager templateManager) {
super(templateManager);
this.client = client
.clone()
.baseUrl("https://oapi.dingtalk.com")
.filter(this)
.build();
this.properties = properties;
this.notifierId = id;
}
@Nonnull
@Override
public NotifyType getType() {
return DefaultNotifyType.dingTalk;
}
@Nonnull
@Override
public Provider getProvider() {
return DingTalkProvider.dingTalkMessage;
}
@Nonnull
@Override
public Mono<Void> send(@Nonnull DingTalkMessageTemplate template, @Nonnull Values context) {
// 关系对象属性
String thirdPartyType = getType().getId() + "_" + getProvider().getId();
String thirdPartyProvider = getNotifierId();
ConfigKey<String> relationPropertyPath = RelationConstants.UserProperty.thirdParty(thirdPartyType, thirdPartyProvider);
return template
.createFormInserter(BodyInserters.fromFormData(new LinkedMultiValueMap<>()), context, relationPropertyPath)
.flatMap(formInserter -> client
.post()
.uri("/topapi/message/corpconversation/asyncsend_v2")
.contentType(MediaType.APPLICATION_FORM_URLENCODED)
.body(formInserter)
.retrieve()
.bodyToMono(ApiResponse.class))
.then();
}
public Mono<AccessTokenResponse> getUserAccessToken(String code) {
return execute(new GetUserAccessTokenRequest(properties.getAppKey(), properties.getAppSecret(), code));
}
private Mono<String> getToken() {
if (token == null) {
synchronized (this) {
if (token == null) {
token = this
.requestToken()
.cache(val -> Duration.ofSeconds(Math.max(3600, val.getExpiresIn()) - 60),
err -> Duration.ZERO,
() -> Duration.ZERO)
.doOnNext(AccessTokenResponse::assertSuccess)
.map(AccessTokenResponse::getAccessToken);
}
}
}
return token;
}
private Mono<AccessTokenResponse> requestToken() {
return execute(new GetAccessTokenRequest(properties.getAppKey(), properties.getAppSecret()));
}
@Nonnull
@Override
public Mono<Void> close() {
return Mono.empty();
}
@Nonnull
@Override
public <R> R execute(@Nonnull Command<R> command) {
if (command instanceof ApiRequest) {
return ((ApiRequest<R>) command).execute(client);
}
throw new UnsupportedOperationException();
}
@Override
@Nonnull
public Mono<ClientResponse> filter(@Nonnull ClientRequest request, @Nonnull ExchangeFunction next) {<FILL_FUNCTION_BODY>}
}
|
if (request.url().getPath().endsWith("gettoken")) {
return next.exchange(request);
}
//自动填充access_token
return this
.getToken()
.flatMap(token -> next
.exchange(
ClientRequest
.from(request)
.url(UriComponentsBuilder
.fromUri(request.url())
.queryParam("access_token", token)
.build()
.toUri())
.build()
));
| 892
| 131
| 1,023
|
<methods>public non-sealed void <init>() ,public Mono<java.lang.Void> send(java.lang.String, org.jetlinks.core.Values) <variables>private final non-sealed org.jetlinks.community.notify.template.TemplateManager templateManager
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-dingtalk/src/main/java/org/jetlinks/community/notify/dingtalk/corp/DingTalkNotifierProvider.java
|
DingTalkNotifierProvider
|
createNotifier
|
class DingTalkNotifierProvider implements NotifierProvider, TemplateProvider {
private final WebClient.Builder clientBuilder;
private final TemplateManager templateManager;
public DingTalkNotifierProvider(TemplateManager templateManager, WebClient.Builder builder) {
this.templateManager = templateManager;
this.clientBuilder =builder;
}
public static final DefaultConfigMetadata notifierConfig = new DefaultConfigMetadata("通知配置", "")
.add("appKey", "appKey", "", new StringType().expand(ConfigMetadataConstants.required.value(true)))
.add("appSecret", "appSecret", "", new StringType());
public static final DefaultConfigMetadata templateConfig = new DefaultConfigMetadata("模版配置", "")
.add("agentId", "应用ID", "", new StringType().expand(ConfigMetadataConstants.required.value(true)))
.add("userIdList", "收信人ID", "与部门ID不能同时为空", new StringType())
.add("departmentIdList", "收信部门ID", "与收信人ID不能同时为空", new StringType())
.add("toAllUser", "全部用户", "推送到全部用户", new BooleanType())
.add("message", "内容", "最大不超过500字", new StringType().expand(ConfigMetadataConstants.maxLength.value(500L)));
@Nonnull
@Override
public NotifyType getType() {
return DefaultNotifyType.dingTalk;
}
@Nonnull
@Override
public Provider getProvider() {
return DingTalkProvider.dingTalkMessage;
}
@Override
public Mono<DingTalkMessageTemplate> createTemplate(TemplateProperties properties) {
return Mono.fromSupplier(() -> new DingTalkMessageTemplate().with(properties).validate())
.as(LocaleUtils::transform);
}
@Nonnull
@Override
public Mono<DingTalkNotifier> createNotifier(@Nonnull NotifierProperties properties) {<FILL_FUNCTION_BODY>}
@Override
public ConfigMetadata getNotifierConfigMetadata() {
return notifierConfig;
}
@Override
public ConfigMetadata getTemplateConfigMetadata() {
return templateConfig;
}
}
|
return Mono.defer(() -> {
DingTalkProperties dingTalkProperties = FastBeanCopier.copy(properties.getConfiguration(), new DingTalkProperties());
return Mono
.just(new DingTalkNotifier(
properties.getId(), clientBuilder, ValidatorUtils.tryValidate(dingTalkProperties), templateManager))
.as(LocaleUtils::transform);
})
.as(LocaleUtils::transform);
| 567
| 116
| 683
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-dingtalk/src/main/java/org/jetlinks/community/notify/dingtalk/corp/request/GetAccessTokenRequest.java
|
GetAccessTokenRequest
|
execute
|
class GetAccessTokenRequest extends ApiRequest<Mono<AccessTokenResponse>> {
private final String appKey;
private final String appSecret;
@Override
public Mono<AccessTokenResponse> execute(WebClient client) {<FILL_FUNCTION_BODY>}
}
|
return client
.get()
.uri("gettoken", uri -> uri
.queryParam("appkey", appKey)
.queryParam("appsecret", appSecret)
.build())
.retrieve()
.bodyToMono(AccessTokenResponse.class);
| 74
| 73
| 147
|
<methods>public non-sealed void <init>() ,public abstract Mono<org.jetlinks.community.notify.dingtalk.corp.response.AccessTokenResponse> execute(org.springframework.web.reactive.function.client.WebClient) <variables>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-dingtalk/src/main/java/org/jetlinks/community/notify/dingtalk/corp/request/GetDepartmentRequest.java
|
GetDepartmentRequest
|
doRequest
|
class GetDepartmentRequest extends ApiRequest<Flux<CorpDepartment>> {
private final String departmentId;
private final boolean fetchChild;
public GetDepartmentRequest() {
this(null, true);
}
public GetDepartmentRequest(boolean fetchChild) {
this(null, fetchChild);
}
@Override
public Flux<CorpDepartment> execute(WebClient client) {
return this
.doRequest(departmentId, client)
.flatMapIterable(Response::getResult);
}
private Flux<Response> doRequest(String departmentId, WebClient client) {<FILL_FUNCTION_BODY>}
@Getter
@Setter
public static class Response extends ApiResponse {
@JsonProperty
@JsonAlias("result")
private List<CorpDepartment> result;
public List<CorpDepartment> getResult() {
return result == null ? Collections.emptyList() : result;
}
}
}
|
return client
.post()
.uri("/topapi/v2/department/listsub")
.contentType(MediaType.APPLICATION_FORM_URLENCODED)
.body(StringUtils.hasText(departmentId)
? BodyInserters.fromFormData("dept_id", departmentId)
: BodyInserters.empty())
.retrieve()
.bodyToMono(Response.class)
.flatMapMany(response -> {
response.assertSuccess();
//获取下级部门
if (fetchChild && CollectionUtils.isNotEmpty(response.getResult())) {
return Flux
.concat(Mono.just(response),
Flux.fromIterable(response.getResult())
.filter(dep -> StringUtils.hasText(dep.getId()))
.flatMap(dep -> doRequest(dep.getId(), client)));
}
return Mono.just(response);
})
;
| 262
| 247
| 509
|
<methods>public non-sealed void <init>() ,public abstract Flux<org.jetlinks.community.notify.dingtalk.corp.CorpDepartment> execute(org.springframework.web.reactive.function.client.WebClient) <variables>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-dingtalk/src/main/java/org/jetlinks/community/notify/dingtalk/corp/request/GetUserAccessTokenRequest.java
|
GetUserAccessTokenRequest
|
execute
|
class GetUserAccessTokenRequest extends ApiRequest<Mono<AccessTokenResponse>> {
private final String appKey;
private final String appSecret;
private final String code;
@Override
public Mono<AccessTokenResponse> execute(WebClient client) {<FILL_FUNCTION_BODY>}
}
|
Map<String, Object> body = new HashMap<>();
body.put("clientId", appKey);
body.put("clientSecret", appSecret);
body.put("code", code);
body.put("grantType", "authorization_code");
return client
.post()
.uri("https://api.dingtalk.com/v1.0/oauth2/userAccessToken")
.bodyValue(body)
.retrieve()
.bodyToMono(AccessTokenResponse.class);
| 83
| 135
| 218
|
<methods>public non-sealed void <init>() ,public abstract Mono<org.jetlinks.community.notify.dingtalk.corp.response.AccessTokenResponse> execute(org.springframework.web.reactive.function.client.WebClient) <variables>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-dingtalk/src/main/java/org/jetlinks/community/notify/dingtalk/corp/request/GetUserIdByUnionIdRequest.java
|
GetUserIdByUnionIdRequest
|
doRequest
|
class GetUserIdByUnionIdRequest extends ApiRequest<Mono<GetUserIdByUnionIdRequest.UserUnionInfoResponse>> {
private final String unionId;
@Override
public Mono<UserUnionInfoResponse> execute(WebClient client) {
return doRequest(client);
}
private Mono<UserUnionInfoResponse> doRequest(WebClient client) {<FILL_FUNCTION_BODY>}
@Getter
@Setter
public static class UserUnionInfoResponse extends ApiResponse {
@JsonProperty
@JsonAlias("result")
private Result result;
@Getter
@Setter
public static class Result {
@JsonProperty
@JsonAlias("contact_type")
private int contactType;
@JsonProperty
@JsonAlias("userid")
private String userId;
}
}
}
|
Map<String, Object> body = new HashMap<>();
body.put("unionid", unionId);
return client
.post()
.uri("/topapi/user/getbyunionid")
.bodyValue(body)
.retrieve()
.bodyToMono(UserUnionInfoResponse.class)
.doOnNext(rep -> {
if (rep.getResult() == null) {
throw new BusinessException(rep.getErrorMessage());
}
});
| 232
| 128
| 360
|
<methods>public non-sealed void <init>() ,public abstract Mono<org.jetlinks.community.notify.dingtalk.corp.request.GetUserIdByUnionIdRequest.UserUnionInfoResponse> execute(org.springframework.web.reactive.function.client.WebClient) <variables>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-dingtalk/src/main/java/org/jetlinks/community/notify/dingtalk/corp/request/GetUserInfoRequest.java
|
GetUserInfoRequest
|
doRequest
|
class GetUserInfoRequest extends ApiRequest<Mono<GetUserInfoRequest.UserInfoResponse>> {
private final String accessToken;
@Override
public Mono<UserInfoResponse> execute(WebClient client) {
return doRequest(client);
}
private Mono<UserInfoResponse> doRequest(WebClient client) {<FILL_FUNCTION_BODY>}
@Getter
@Setter
public static class UserInfoResponse extends ApiResponse {
@JsonAlias("unionid")
@JsonProperty
private String unionId;
@JsonAlias("avatar_url")
@JsonProperty
private String avatarUrl;
@JsonAlias("nick")
@JsonProperty
private String nick;
}
}
|
return client
.get()
.uri("https://api.dingtalk.com/v1.0/contact/users/{unionId}", "me")
.header("x-acs-dingtalk-access-token", accessToken)
.retrieve()
.bodyToMono(UserInfoResponse.class)
.doOnNext(rep -> {
if (rep.getUnionId() == null) {
throw new BusinessException(rep.getErrorMessage());
}
});
| 199
| 127
| 326
|
<methods>public non-sealed void <init>() ,public abstract Mono<org.jetlinks.community.notify.dingtalk.corp.request.GetUserInfoRequest.UserInfoResponse> execute(org.springframework.web.reactive.function.client.WebClient) <variables>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-dingtalk/src/main/java/org/jetlinks/community/notify/dingtalk/corp/request/GetUserRequest.java
|
GetUserRequest
|
doRequest
|
class GetUserRequest extends ApiRequest<Flux<CorpUser>> {
private final String departmentId;
@Override
public Flux<CorpUser> execute(WebClient client) {
return this
.doRequest(0, client)
.flatMapIterable(Response::getList);
}
private Flux<Response> doRequest(int pageIndex, WebClient client) {<FILL_FUNCTION_BODY>}
@Getter
@Setter
public static class Response extends ApiResponse {
@JsonProperty
@JsonAlias("has_more")
private boolean hasMore;
@JsonProperty
@JsonAlias("next_cursor")
private int nextCursor;
@JsonProperty
@JsonAlias("result")
private Result result;
public List<CorpUser> getList() {
return result == null ? Collections.emptyList() : result.list;
}
@Getter
@Setter
public static class Result {
@JsonProperty
@JsonAlias("has_more")
private boolean hasMore;
@JsonProperty
@JsonAlias("list")
private List<CorpUser> list;
public List<CorpUser> getList() {
return list == null ? Collections.emptyList() : list;
}
}
}
}
|
return client
.post()
.uri("/topapi/user/listsimple")
.contentType(MediaType.APPLICATION_FORM_URLENCODED)
.body(BodyInserters
.fromFormData("dept_id", departmentId)
.with("cursor", String.valueOf(pageIndex))
.with("size", "100")
)
.retrieve()
.bodyToMono(Response.class)
.flatMapMany(response -> {
//下一页
if (response.hasMore && response.nextCursor > 0) {
return Flux
.concat(
Mono.just(response),
doRequest(response.nextCursor, client)
);
}
return Mono.just(response);
});
| 346
| 204
| 550
|
<methods>public non-sealed void <init>() ,public abstract Flux<org.jetlinks.community.notify.dingtalk.corp.CorpUser> execute(org.springframework.web.reactive.function.client.WebClient) <variables>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-dingtalk/src/main/java/org/jetlinks/community/notify/dingtalk/corp/response/ApiResponse.java
|
ApiResponse
|
assertSuccess
|
class ApiResponse {
@JsonProperty
@JsonAlias("request_id")
private String requestId;
@JsonProperty
@JsonAlias("errcode")
private int errorCode;
@JsonProperty
@JsonAlias("errmsg")
private String errorMessage;
public boolean isSuccess() {
return errorCode == 0;
}
public void assertSuccess() {<FILL_FUNCTION_BODY>}
}
|
if (!isSuccess()) {
throw new BusinessException("error.dingtalk_api_request_error", 500, errorMessage);
}
| 119
| 40
| 159
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-dingtalk/src/main/java/org/jetlinks/community/notify/dingtalk/robot/DingTalkRobotWebHookNotifier.java
|
DingTalkRobotWebHookNotifier
|
send
|
class DingTalkRobotWebHookNotifier extends AbstractNotifier<DingTalkWebHookTemplate> {
@Getter
private final String notifierId;
private final String url;
private final WebClient client;
public DingTalkRobotWebHookNotifier(String notifierId,
TemplateManager templateManager,
String url,
WebClient client) {
super(templateManager);
this.notifierId = notifierId;
this.url = url;
this.client = client;
}
@Nonnull
@Override
public NotifyType getType() {
return DefaultNotifyType.dingTalk;
}
@Nonnull
@Override
public Provider getProvider() {
return DingTalkProvider.dingTalkRobotWebHook;
}
@Nonnull
@Override
public Mono<Void> send(@Nonnull DingTalkWebHookTemplate template,
@Nonnull Values context) {<FILL_FUNCTION_BODY>}
public static String translateMessage(String message) {
if (message != null && message.contains("keywords not in content")) {
return "error.ding_webhook_keywords_not_in_content";
}
if (message != null && message.contains("not in whitelist")) {
return "error.ding_ip_not_in_whitelist";
}
if (message != null && message.contains("token is not exist")) {
return "error.ding_token_error";
}
return "error.ding_webhook_arg_error";
}
@Nonnull
@Override
public Mono<Void> close() {
return Mono.empty();
}
}
|
return client
.post()
.uri(url)
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(template.toJson(context.getAllValues()))
.retrieve()
.bodyToMono(String.class)
.doOnNext(str -> {
JSONObject response = JSON.parseObject(str);
if (0 != response.getIntValue("errcode")) {
throw new IllegalArgumentException(translateMessage(response.getString("errmsg")));
}
})
.then();
| 447
| 139
| 586
|
<methods>public non-sealed void <init>() ,public Mono<java.lang.Void> send(java.lang.String, org.jetlinks.core.Values) <variables>private final non-sealed org.jetlinks.community.notify.template.TemplateManager templateManager
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-dingtalk/src/main/java/org/jetlinks/community/notify/dingtalk/robot/DingTalkRobotWebHookNotifierProvider.java
|
DingTalkRobotWebHookNotifierProvider
|
createNotifier
|
class DingTalkRobotWebHookNotifierProvider implements NotifierProvider, TemplateProvider {
private final WebClient client;
private final TemplateManager templateManager;
public DingTalkRobotWebHookNotifierProvider(TemplateManager templateManager, WebClient.Builder builder) {
this.templateManager = templateManager;
this.client = builder.build();
}
public static final DefaultConfigMetadata notifierConfig = new DefaultConfigMetadata("通知配置", "")
.add("url", "Webhook", "", new StringType().expand(ConfigMetadataConstants.required.value(true)));
public static final DefaultConfigMetadata templateConfig = new DefaultConfigMetadata("模版配置", "")
.add("messageType", "消息类型", "", new EnumType()
.addElement(EnumType.Element.of("text", "text"))
.addElement(EnumType.Element.of("link", "link"))
.addElement(EnumType.Element.of("markdown", "markdown"))
.expand(ConfigMetadataConstants.required.value(true)))
.add("text", "文本消息", "", new ObjectType()
.addProperty("content", "文本内容", StringType.GLOBAL))
.add("link", "连接消息", "", new ObjectType()
.addProperty("title", "标题", StringType.GLOBAL)
.addProperty("picUrl", "图片地址", new FileType())
.addProperty("text", "正文", StringType.GLOBAL)
.addProperty("messageUrl", "消息连接", StringType.GLOBAL)
)
.add("markdown", "markdown消息", "推送到全部用户", new ObjectType()
.addProperty("title", "标题", StringType.GLOBAL)
.addProperty("text", "正文", StringType.GLOBAL)
)
.add("at", "At", "At指定的人", new ObjectType()
.addProperty("atMobiles", "按手机号码at", new ArrayType().elementType(StringType.GLOBAL))
.addProperty("atUserIds", "按用户IDat", new ArrayType().elementType(StringType.GLOBAL))
.addProperty("atAll", "是否at全员", BooleanType.GLOBAL)
);
@Nonnull
@Override
public NotifyType getType() {
return DefaultNotifyType.dingTalk;
}
@Nonnull
@Override
public Provider getProvider() {
return DingTalkProvider.dingTalkRobotWebHook;
}
@Override
public Mono<DingTalkWebHookTemplate> createTemplate(TemplateProperties properties) {
return Mono.fromSupplier(() -> new DingTalkWebHookTemplate().with(properties).validate())
.as(LocaleUtils::transform);
}
@Nonnull
@Override
public Mono<DingTalkRobotWebHookNotifier> createNotifier(@Nonnull NotifierProperties properties) {<FILL_FUNCTION_BODY>}
@Override
public ConfigMetadata getNotifierConfigMetadata() {
return notifierConfig;
}
@Override
public ConfigMetadata getTemplateConfigMetadata() {
return templateConfig;
}
}
|
return Mono.fromSupplier(() -> {
String url = properties
.getString("url")
.filter(StringUtils::hasText)
.orElseThrow(() -> new IllegalArgumentException("url can not be null"));
return new DingTalkRobotWebHookNotifier(
properties.getId(), templateManager, url, client
);
})
.as(LocaleUtils::transform);
| 804
| 104
| 908
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-dingtalk/src/main/java/org/jetlinks/community/notify/dingtalk/robot/DingTalkWebHookTemplate.java
|
At
|
toJson
|
class At {
private List<String> atMobiles;
private List<String> atUserIds;
private boolean atAll;
public At render(Template template, Map<String, Object> context) {
return new At(template.render(atMobiles, context),
template.render(atUserIds, context),
atAll);
}
public JSONObject toJson() {<FILL_FUNCTION_BODY>}
}
|
JSONObject json = new JSONObject();
json.put("atMobiles", atMobiles);
json.put("atUserIds", atUserIds);
json.put("isAtAll", atAll);
return json;
| 115
| 61
| 176
|
<methods>public void <init>() ,public final Optional<org.jetlinks.community.notify.template.VariableDefinition> getVariable(java.lang.String) ,public final Map<java.lang.String,org.jetlinks.community.notify.template.VariableDefinition> getVariables() ,public Map<java.lang.String,java.lang.Object> toMap() ,public org.jetlinks.community.notify.dingtalk.robot.DingTalkWebHookTemplate validate() ,public org.jetlinks.community.notify.dingtalk.robot.DingTalkWebHookTemplate with(org.jetlinks.community.notify.template.TemplateProperties) <variables>private java.lang.String configId,private Map<java.lang.String,org.jetlinks.community.notify.template.VariableDefinition> variables
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-dingtalk/src/main/java/org/jetlinks/community/notify/dingtalk/web/DingTalkCorpNotifierController.java
|
DingTalkCorpNotifierController
|
getDepartmentUsers
|
class DingTalkCorpNotifierController {
private final NotifierManager notifierManager;
private final NotifyConfigManager notifyConfigManager;
private final UserBindService userBindService;
@GetMapping("/{configId}/departments")
@Operation(summary = "获取企业部门信息")
public Flux<CorpDepartment> getDepartments(@PathVariable String configId,
@RequestParam(defaultValue = "false") boolean fetchChild) {
return notifierManager
.getNotifier(DefaultNotifyType.dingTalk, configId)
.map(notifier -> notifier.unwrap(CommandSupport.class))
.flatMapMany(support -> support.execute(new GetDepartmentRequest(fetchChild)));
}
@GetMapping("/{configId}/departments/tree")
@Operation(summary = "获取全部企业部门信息(树结构)")
public Flux<CorpDepartment> getDepartments(@PathVariable String configId) {
return this
.getDepartments(configId, true)
.collectList()
.flatMapIterable(CorpDepartment::toTree);
}
@GetMapping("/{configId}/{departmentId}/users")
@Operation(summary = "获取企业部门下人员信息")
public Flux<CorpUser> getDepartmentUsers(@PathVariable String configId,
@PathVariable String departmentId) {
return notifierManager
.getNotifier(DefaultNotifyType.dingTalk, configId)
.map(notifier -> notifier.unwrap(CommandSupport.class))
.flatMapMany(support -> support.execute(new GetUserRequest(departmentId)));
}
@GetMapping("/{configId}/users")
@Operation(summary = "获取企业部门下全部人员信息")
public Flux<CorpUser> getDepartmentUsers(@PathVariable String configId) {<FILL_FUNCTION_BODY>}
@GetMapping(value = "/{configId}/oauth2/binding-user-url")
@Operation(summary = "生成企业用户Oauth2绑定授权url")
public Mono<String> getUserBindingUrl(@RequestParam(value = "authCode") String redirectUri,
@PathVariable String configId) {
return Authentication
.currentReactive()
.switchIfEmpty(Mono.error(UnAuthorizedException::new))
.flatMap(authentication -> notifyConfigManager
.getNotifyConfig(DefaultNotifyType.dingTalk, configId)
.map(properties -> UriComponentsBuilder
.fromUriString("https://login.dingtalk.com/oauth2/auth")
.queryParam("redirect_uri", HttpUtils.urlEncode(redirectUri))
.queryParam("response_type", "code")
.queryParam("client_id", DingTalkProperties
.of(properties)
.getAppKey())
.queryParam("scope", "openid")
.queryParam("state", configId)
.queryParam("prompt", "consent")
.build()
.toString())
);
}
@GetMapping(value = "/oauth2/user-bind-code")
@Operation(summary = "获取oauth2授权的用户绑定码")
public Mono<String> getOauth2UserBindCode(@RequestParam(value = "authCode") String authCode,
@RequestParam(value = "configId") String configId) {
return Authentication
.currentReactive()
.switchIfEmpty(Mono.error(UnAuthorizedException::new))
.flatMap(authentication -> notifierManager
.getNotifier(DefaultNotifyType.dingTalk, configId)
.map(notifier -> notifier.unwrap(DingTalkNotifier.class))
.flatMap(dingTalkNotifier -> dingTalkNotifier
.getUserAccessToken(authCode)
.flatMap(accessTokenRep -> dingTalkNotifier.execute(new GetUserInfoRequest(accessTokenRep.getAccessToken())))
.flatMap(userInfoResponse -> dingTalkNotifier
.execute(new GetUserIdByUnionIdRequest(userInfoResponse.getUnionId()))
.flatMap(rep -> userBindService
.generateBindCode(new UserBindService
.UserInfo(userInfoResponse.getUnionId(),
userInfoResponse.getAvatarUrl(),
userInfoResponse.getNick(),
rep.getResult().getUserId(),
authentication.getUser().getId())))
)
)) ;
}
}
|
return notifierManager
.getNotifier(DefaultNotifyType.dingTalk, configId)
.map(notifier -> notifier.unwrap(CommandSupport.class))
.flatMapMany(support -> support
.execute(new GetDepartmentRequest(true))
.flatMap(department -> support.execute(new GetUserRequest(department.getId())))
)
;
| 1,164
| 105
| 1,269
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-email/src/main/java/org/jetlinks/community/notify/email/embedded/DefaultEmailProperties.java
|
ConfigProperty
|
createJavaMailProperties
|
class ConfigProperty {
private String name;
private String value;
private String description;
}
public Properties createJavaMailProperties() {<FILL_FUNCTION_BODY>
|
Properties properties = new Properties();
if (this.properties != null) {
for (ConfigProperty property : this.properties) {
properties.put(property.getName(), property.getValue());
}
}
if(ssl){
properties.putIfAbsent("mail.smtp.auth","true");
properties.putIfAbsent("mail.smtp.ssl.enable","true");
}
return properties;
| 51
| 109
| 160
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-email/src/main/java/org/jetlinks/community/notify/email/embedded/EmailTemplate.java
|
Attachment
|
getEmbeddedVariables
|
class Attachment {
public static final String LOCATION_KEY = "location";
private String name;
private String location;
public static String locationKey(int index) {
return "_attach_location_" + index;
}
}
@Nonnull
@Override
protected List<VariableDefinition> getEmbeddedVariables() {<FILL_FUNCTION_BODY>
|
List<VariableDefinition> variables = new ArrayList<>();
if (CollectionUtils.isEmpty(sendTo)) {
variables.add(
VariableDefinition
.builder()
.id(SEND_TO_KEY)
.name("收件人")
.expand(NotifyVariableBusinessConstant.businessId,
NotifyVariableBusinessConstant.NotifyVariableBusinessTypes.userType)
.required(true)
.type(ArrayType.ID)
.build()
);
}
List<Attachment> attachments = getAttachments();
if (!CollectionUtils.isEmpty(attachments)) {
int index = 0;
for (Attachment attachment : attachments) {
index++;
if (StringUtils.isNotEmpty(attachment.getName())
&& StringUtils.isEmpty(attachment.getLocation())) {
variables.add(
VariableDefinition
.builder()
.id(locationKey(index))
.name(attachment.getName())
.type(FileType.ID)
.description(attachment.getName())
.format(Variable.FileFormat.any)
.required(true)
.build()
);
}
}
}
return variables;
| 105
| 307
| 412
|
<methods>public void <init>() ,public final Optional<org.jetlinks.community.notify.template.VariableDefinition> getVariable(java.lang.String) ,public final Map<java.lang.String,org.jetlinks.community.notify.template.VariableDefinition> getVariables() ,public Map<java.lang.String,java.lang.Object> toMap() ,public org.jetlinks.community.notify.email.embedded.EmailTemplate validate() ,public org.jetlinks.community.notify.email.embedded.EmailTemplate with(org.jetlinks.community.notify.template.TemplateProperties) <variables>private java.lang.String configId,private Map<java.lang.String,org.jetlinks.community.notify.template.VariableDefinition> variables
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-sms/src/main/java/org/jetlinks/community/notify/sms/aliyun/AliyunSmsNotifier.java
|
AliyunSmsNotifier
|
getSmsSigns
|
class AliyunSmsNotifier extends AbstractNotifier<AliyunSmsTemplate> {
private final IAcsClient client;
private final int connectTimeout = 1000;
private final int readTimeout = 5000;
@Getter
private String notifierId;
private String domain = "dysmsapi.aliyuncs.com";
private String regionId = "cn-hangzhou";
public AliyunSmsNotifier(NotifierProperties profile, TemplateManager templateManager) {
super(templateManager);
regionId = profile
.getString("regionId")
.orElseThrow(() -> new IllegalArgumentException("[regionId]不能为空"));
String accessKeyId = profile
.getString("accessKeyId")
.orElseThrow(() -> new IllegalArgumentException("[accessKeyId]不能为空"));
String secret = profile
.getString("secret")
.orElseThrow(() -> new IllegalArgumentException("[secret]不能为空"));
this.domain = profile.getString("domain", this.domain);
DefaultProfile defaultProfile = DefaultProfile.getProfile(
regionId,
accessKeyId,
secret
);
this.client = new DefaultAcsClient(defaultProfile);
this.notifierId = profile.getId();
}
public AliyunSmsNotifier(IClientProfile profile, TemplateManager templateManager) {
this(new DefaultAcsClient(profile), templateManager);
}
public AliyunSmsNotifier(IAcsClient client, TemplateManager templateManager) {
super(templateManager);
this.client = client;
}
@Override
@Nonnull
public NotifyType getType() {
return DefaultNotifyType.sms;
}
@Nonnull
@Override
public Provider getProvider() {
return SmsProvider.aliyunSms;
}
@Override
@Nonnull
public Mono<Void> send(@Nonnull AliyunSmsTemplate template, @Nonnull Values context) {
Map<String, Object> ctx = context.getAllValues();
return template
.getPhoneNumber(ctx)
.collect(Collectors.joining(","))
.filter(StringUtils::hasText)
.flatMap(phoneNumber -> {
try {
CommonRequest request = new CommonRequest();
request.setSysMethod(MethodType.POST);
request.setSysDomain(domain);
request.setSysVersion("2017-05-25");
request.setSysAction("SendSms");
request.setSysConnectTimeout(connectTimeout);
request.setSysReadTimeout(readTimeout);
request.putQueryParameter("RegionId", regionId);
request.putQueryParameter("PhoneNumbers", phoneNumber);
request.putQueryParameter("SignName", template.getSignName(ctx));
request.putQueryParameter("TemplateCode", template.getCode(ctx));
request.putQueryParameter("TemplateParam", template.createTtsParam(ctx));
CommonResponse response = client.getCommonResponse(request);
log.info("发送短信通知完成 {}:{}", response.getHttpResponse().getStatus(), response.getData());
JSONObject json = JSON.parseObject(response.getData());
if (!"ok".equalsIgnoreCase(json.getString("Code"))) {
return Mono.error(new BusinessException(json.getString("Message"), json.getString("Code")));
}
} catch (Exception e) {
return Mono.error(e);
}
return Mono.empty();
})
.doOnEach(ReactiveLogger.onError(err -> {
log.info("发送短信通知失败", err);
}))
.subscribeOn(Schedulers.boundedElastic())
.then();
}
@Override
@Nonnull
public Mono<Void> close() {
return Mono.fromRunnable(client::shutdown);
}
/**
* @return 阿里云短信扩展信息
*/
public Mono<AliyunSmsExpansion> getSmsExpansion() {
return Mono
.zip(
getSmsSigns()
.collectList(),
getSmsTemplates()
.collectList(),
AliyunSmsExpansion::of
)
.subscribeOn(Schedulers.boundedElastic());
}
/**
* @return 短信签名集合
*/
public Flux<SmsSign> getSmsSigns() {<FILL_FUNCTION_BODY>}
/**
* @return 短信模板集合
*/
public Flux<SmsTemplate> getSmsTemplates() {
return doQuerySmsTemplates(new AtomicInteger(0), 50)
.flatMapIterable(Function.identity())
.map(SmsTemplate::of)
.as(FluxTracer.create("/aliyun/sms/template"))
.onErrorResume(err -> Mono.empty());
}
public Flux<List<QuerySmsSignListResponse.QuerySmsSignDTO>> doQuerySmsSigns(AtomicInteger pageIndex, int pageSize) {
QuerySmsSignListRequest request = new QuerySmsSignListRequest();
request.setPageSize(pageSize);
request.setPageIndex(pageIndex.incrementAndGet());
return Mono
.fromCallable(() -> client.getAcsResponse(request).getSmsSignList())
.expand(dtos -> {
if (dtos.size() == pageSize){
return doQuerySmsSigns(pageIndex, pageSize);
}
return Flux.empty();
});
}
public Flux<List<QuerySmsTemplateListResponse.SmsStatsResultDTO>> doQuerySmsTemplates(AtomicInteger pageIndex, int pageSize) {
QuerySmsTemplateListRequest request = new QuerySmsTemplateListRequest();
request.setPageSize(pageSize);
request.setPageIndex(pageIndex.incrementAndGet());
return Mono
.fromCallable(() -> client.getAcsResponse(request).getSmsTemplateList())
.expand(dtos -> {
if (dtos.size() == pageSize){
return doQuerySmsTemplates(pageIndex, pageSize);
}
return Flux.empty();
});
}
}
|
return doQuerySmsSigns(new AtomicInteger(0), 50)
.flatMapIterable(Function.identity())
.map(SmsSign::of)
.as(FluxTracer.create("/aliyun/sms/sign"))
.onErrorResume(err -> Mono.empty());
| 1,634
| 84
| 1,718
|
<methods>public non-sealed void <init>() ,public Mono<java.lang.Void> send(java.lang.String, org.jetlinks.core.Values) <variables>private final non-sealed org.jetlinks.community.notify.template.TemplateManager templateManager
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-components/notify-component/notify-sms/src/main/java/org/jetlinks/community/notify/sms/aliyun/AliyunSmsTemplate.java
|
AliyunSmsTemplate
|
getEmbeddedVariables
|
class AliyunSmsTemplate extends AbstractTemplate<AliyunSmsTemplate> {
public static final String PHONE_NUMBER_KEY = "phoneNumber";
//签名名称
@NotBlank(message = "[signName]不能为空")
private String signName;
//模版编码
@NotBlank(message = "[code]不能为空")
private String code;
//为空时,则表示从变量中传入
// @NotBlank(message = "[phoneNumber]不能为空")
private String phoneNumber;
private Map<String, String> param;
public String getCode(Map<String, Object> ctx) {
//code不支持变量
return getCode();
}
public Flux<String> getPhoneNumber(Map<String, Object> ctx) {
if (StringUtils.hasText(this.getPhoneNumber())) {
return Flux.just(this.getPhoneNumber());
}
//如果没有指定固定值,则从上下文中获取
return RelationUtils
.resolve(PHONE_NUMBER_KEY, ctx, RelationConstants.UserProperty.telephone)
.map(String::valueOf);
}
public String getSignName(Map<String, Object> ctx) {
//签名不支持变量
return getSignName();
}
public String createTtsParam(Map<String, Object> ctx) {
Map<String, VariableDefinition> variables = getVariables();
return JSON.toJSONString(Maps.filterEntries(
renderMap(ctx),
e -> variables.containsKey(e.getKey())));
}
@Override
@Nonnull
protected List<VariableDefinition> getEmbeddedVariables() {<FILL_FUNCTION_BODY>}
}
|
//指定了固定的收信人
if (StringUtils.hasText(phoneNumber)) {
return Collections.emptyList();
}
return Collections.singletonList(
VariableDefinition
.builder()
.id(PHONE_NUMBER_KEY)
.name("收信人")
.description("收信人手机号码")
.expand(NotifyVariableBusinessConstant.businessId,
NotifyVariableBusinessConstant.NotifyVariableBusinessTypes.userType)
.type(StringType.ID)
.required(true)
.build()
);
| 459
| 150
| 609
|
<methods>public void <init>() ,public final Optional<org.jetlinks.community.notify.template.VariableDefinition> getVariable(java.lang.String) ,public final Map<java.lang.String,org.jetlinks.community.notify.template.VariableDefinition> getVariables() ,public Map<java.lang.String,java.lang.Object> toMap() ,public org.jetlinks.community.notify.sms.aliyun.AliyunSmsTemplate validate() ,public org.jetlinks.community.notify.sms.aliyun.AliyunSmsTemplate with(org.jetlinks.community.notify.template.TemplateProperties) <variables>private java.lang.String configId,private Map<java.lang.String,org.jetlinks.community.notify.template.VariableDefinition> variables
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.