From db6e8f1eafce0379f93b54ac41ec148205431601 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 7 May 2020 15:39:25 -0400 Subject: [PATCH 001/273] skip rpc tasks --- ci/travis.sh | 0 gradlew | 0 settings.gradle | 3 ++- 3 files changed, 2 insertions(+), 1 deletion(-) mode change 100755 => 100644 ci/travis.sh mode change 100755 => 100644 gradlew diff --git a/ci/travis.sh b/ci/travis.sh old mode 100755 new mode 100644 diff --git a/gradlew b/gradlew old mode 100755 new mode 100644 diff --git a/settings.gradle b/settings.gradle index 7300d08f..6ae40a2d 100644 --- a/settings.gradle +++ b/settings.gradle @@ -7,12 +7,13 @@ rootProject.name = 'rsocket-rpc-java' include 'rsocket-ipc-core' include 'rsocket-ipc-graphql' include 'rsocket-ipc-jackson' +/* include 'rsocket-ipc-protobuf' include 'rsocket-rpc-core' include 'rsocket-rpc-metrics-idl' include 'rsocket-rpc-protobuf' include 'rsocket-rpc-protobuf-idl' - +*/ gradleEnterprise { From 212caabe4c5ceded0ee87cd0508b73d34b5c4eda Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 7 May 2020 15:51:41 -0400 Subject: [PATCH 002/273] rsocket update --- rsocket-ipc-graphql/bin/test/schema.graphqls | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 rsocket-ipc-graphql/bin/test/schema.graphqls diff --git a/rsocket-ipc-graphql/bin/test/schema.graphqls b/rsocket-ipc-graphql/bin/test/schema.graphqls new file mode 100644 index 00000000..b69429c7 --- /dev/null +++ b/rsocket-ipc-graphql/bin/test/schema.graphqls @@ -0,0 +1,16 @@ +type Query { + bookById(id: ID): Book +} + +type Book { + id: ID + name: String + pageCount: Int + author: Author +} + +type Author { + id: ID + firstName: String + lastName: String +} \ No newline at end of file From a7043f3a5c4382622d2b3542d7a3c6304a228ee2 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 May 2020 16:48:21 -0400 Subject: [PATCH 003/273] metadata add --- jitpack.yml | 0 .../ipc/decoders/MetadataDecoderLFP.java | 82 +++++++++ .../rsocket/ipc/decoders/MetadataWriter.java | 153 ++++++++++++++++ .../ipc/encoders/MetadataEncoderLFP.java | 80 +++++++++ .../rsocket/ipc/encoders/MetadataReader.java | 139 +++++++++++++++ .../io/rsocket/ipc/mimetype/MimeType.java | 94 ++++++++++ .../io/rsocket/ipc/mimetype/MimeTypes.java | 19 ++ .../io/rsocket/ipc/util/MetadataUtils.java | 168 ++++++++++++++++++ 8 files changed, 735 insertions(+) create mode 100644 jitpack.yml create mode 100644 rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java create mode 100644 rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java create mode 100644 rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataEncoderLFP.java create mode 100644 rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataReader.java create mode 100644 rsocket-ipc-core/src/main/java/io/rsocket/ipc/mimetype/MimeType.java create mode 100644 rsocket-ipc-core/src/main/java/io/rsocket/ipc/mimetype/MimeTypes.java create mode 100644 rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/MetadataUtils.java diff --git a/jitpack.yml b/jitpack.yml new file mode 100644 index 00000000..e69de29b diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java new file mode 100644 index 00000000..31d403ed --- /dev/null +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java @@ -0,0 +1,82 @@ +package io.rsocket.ipc.decoders; + +import java.util.Arrays; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Objects; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import io.netty.buffer.ByteBuf; +import io.opentracing.SpanContext; +import io.opentracing.Tracer; +import io.rsocket.Payload; +import io.rsocket.ipc.MetadataDecoder; +import io.rsocket.ipc.encoders.MetadataReader; +import io.rsocket.ipc.mimetype.MimeTypes; +import io.rsocket.ipc.tracing.Tracing; +import io.rsocket.ipc.util.MetadataUtils.DisposableAddList; +import reactor.core.Disposable; + +public class MetadataDecoderLFP implements MetadataDecoder { + + public static interface Interceptor extends Consumer { + }; + + private final Tracer tracer; + private final DisposableAddList interceptors = DisposableAddList.create(); + + public MetadataDecoderLFP(MetadataDecoderLFP.Interceptor... interceptors) { + this((Tracer) null, interceptors); + } + + public MetadataDecoderLFP(Tracer tracer, MetadataDecoderLFP.Interceptor... interceptors) { + this.tracer = tracer; + if (interceptors != null) + Arrays.asList(interceptors).stream().filter(Objects::nonNull).forEach(v -> this.addInterceptor(v)); + } + + public Disposable addInterceptor(MetadataDecoderLFP.Interceptor interceptor) { + Objects.requireNonNull(interceptor); + return interceptors.disposableAdd(interceptor); + } + + @Override + public final RESULT decode(Payload payload, Handler transformer) throws Exception { + ByteBuf metadata = payload.sliceMetadata(); + // i think that we can retain reader slices bc we slice the data from the + // payload + MetadataReader metadataReader = new MetadataReader(metadata, true); + interceptors.forEach(v -> v.accept(metadataReader)); + return decode(payload.sliceData(), metadataReader, metadata, transformer); + } + + protected RESULT decode(ByteBuf data, MetadataReader metadataReader, ByteBuf metadata, + Handler transformer) throws Exception { + String route = getRoute(metadataReader); + SpanContext context = readTracingSpanContext(metadataReader); + RESULT result = transformer.handleAndReply(data, metadata, route, context); + return result; + } + + private String getRoute(MetadataReader metadataReader) { + Stream stream = Stream.empty(); + stream = Stream.concat(stream, metadataReader.streamStrings(MimeTypes.MIME_TYPE_SERVICE)); + stream = Stream.concat(stream, metadataReader.streamStrings(MimeTypes.MIME_TYPE_METHOD)); + String route = stream.collect(Collectors.joining(".")); + return route; + } + + private SpanContext readTracingSpanContext(MetadataReader metadataReader) { + if (tracer == null) + return null; + Map tracerMetadata = new LinkedHashMap<>(); + metadataReader.streamEntriesNonEmpty(MimeTypes.MIME_TYPE_TRACER) + .forEach(ent -> tracerMetadata.computeIfAbsent(ent.getKey(), nil -> ent.getValue())); + if (tracerMetadata.isEmpty()) + return null; + return Tracing.deserializeTracingMetadata(tracer, tracerMetadata); + } + +} diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java new file mode 100644 index 00000000..d46496b7 --- /dev/null +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java @@ -0,0 +1,153 @@ +package io.rsocket.ipc.decoders; + +import java.util.AbstractMap.SimpleImmutableEntry; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Objects; +import java.util.Optional; +import java.util.PrimitiveIterator.OfInt; +import java.util.function.Function; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +import io.netty.buffer.ByteBuf; +import io.netty.buffer.ByteBufAllocator; +import io.netty.buffer.CompositeByteBuf; +import io.rsocket.ipc.mimetype.MimeType; +import io.rsocket.ipc.util.MetadataUtils; +import io.rsocket.metadata.CompositeMetadataFlyweight; +import io.rsocket.metadata.WellKnownMimeType; + +public class MetadataWriter { + + private final ByteBufAllocator allocator; + private CompositeByteBuf _compositeByteBuf; + + public MetadataWriter() { + this(null, null); + } + + public MetadataWriter(ByteBufAllocator allocator, ByteBuf source) { + this.allocator = allocator != null ? allocator : ByteBufAllocator.DEFAULT; + if (source instanceof CompositeByteBuf) + this._compositeByteBuf = (CompositeByteBuf) source; + else if (source != null && source.readableBytes() != 0) { + throw new IllegalArgumentException("MetadataWriter requires a CompositeByteBuf or an empty source ByteBuf"); + } + } + + public CompositeByteBuf getCompositeByteBuf() { + if (_compositeByteBuf != null) + return _compositeByteBuf; + synchronized (this) { + if (_compositeByteBuf == null) + _compositeByteBuf = this.allocator.compositeBuffer(); + } + return _compositeByteBuf; + } + + public void writeString(MimeType mimeType, String... values) { + write(mimeType, values == null ? Stream.empty() : Arrays.asList(values).stream(), + s -> s.map(MetadataUtils::byteBufFromString)); + } + + public void writeEntries(MimeType mimeType, String... keyValueEntries) { + Map> parameterMap; + if (keyValueEntries == null || keyValueEntries.length == 0) + parameterMap = Collections.emptyMap(); + else { + parameterMap = new LinkedHashMap<>(); + OfInt iter = IntStream.range(0, keyValueEntries.length).iterator(); + String key = null; + while (iter.hasNext()) { + int index = iter.nextInt(); + boolean even = index % 2 == 0; + boolean end = !iter.hasNext(); + String str = keyValueEntries[index]; + if (!even || end) { + String value = !even ? str : null; + parameterMap.computeIfAbsent(key, nil -> new ArrayList<>()).add(value); + } else + key = str; + + } + } + writeEntries(mimeType, parameterMap); + } + + public void writeEntries(MimeType mimeType, Map> parameterMap) { + if (parameterMap == null || parameterMap.isEmpty()) + return; + Stream>> streams = parameterMap.entrySet().stream().map(ent -> { + Iterable value = ent.getValue(); + if (value == null) + return Stream.empty(); + Stream> stream = MetadataUtils.stream(value.iterator()) + .map(v -> new SimpleImmutableEntry<>(ent.getKey(), v)); + return stream; + }); + writeEntries(mimeType, MetadataUtils.flatMap(streams)); + } + + public void writeEntries(MimeType mimeType, Stream> stream) { + if (stream == null) + return; + stream = stream.filter(Objects::nonNull); + stream = stream.filter(e -> MetadataUtils.nonEmpty(e.getKey())); + stream = stream.map(e -> { + if (e.getValue() != null) + return e; + return new SimpleImmutableEntry<>(e.getKey(), ""); + }); + write(mimeType, stream, s -> { + String query = encodeQueryString(s); + return Stream.of(MetadataUtils.byteBufFromString(query)); + }); + } + + public void write(MimeType mimeType, Stream valueStream, Function, Stream> encoder) { + Objects.requireNonNull(mimeType); + Objects.requireNonNull(valueStream); + Objects.requireNonNull(encoder); + Stream stream = encoder.apply(valueStream); + if (stream == null) + return; + Optional wellKnownMimeTypeOp = mimeType.getWellKnownMimeType(); + stream.forEach(bb -> { + if (wellKnownMimeTypeOp.isPresent()) + CompositeMetadataFlyweight.encodeAndAddMetadata(getCompositeByteBuf(), allocator, + wellKnownMimeTypeOp.get(), bb); + else + CompositeMetadataFlyweight.encodeAndAddMetadata(getCompositeByteBuf(), allocator, mimeType.getString(), + bb); + }); + + } + + private static String encodeQueryString(Stream> entryStream) { + if (entryStream == null) + return ""; + entryStream = entryStream.filter(Objects::nonNull); + entryStream = entryStream.filter(e -> !MetadataUtils.isNullOrEmpty(e.getKey())); + entryStream = entryStream.map(e -> { + String value = e.getValue(); + if (value != null) + return e; + return new SimpleImmutableEntry<>(e.getKey(), ""); + }); + StringBuilder sb = new StringBuilder(); + entryStream.forEach(ent -> { + if (sb.length() > 0) + sb.append("&"); + sb.append(String.format("%s=%s", MetadataUtils.urlEncode(ent.getKey()), + MetadataUtils.urlEncode(ent.getValue()))); + }); + return sb.toString(); + } + +} diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataEncoderLFP.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataEncoderLFP.java new file mode 100644 index 00000000..3cd2a3e6 --- /dev/null +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataEncoderLFP.java @@ -0,0 +1,80 @@ +package io.rsocket.ipc.encoders; + +import java.util.Arrays; +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Objects; +import java.util.function.Consumer; +import java.util.stream.Stream; + +import io.netty.buffer.ByteBuf; +import io.netty.buffer.ByteBufAllocator; +import io.opentracing.SpanContext; +import io.rsocket.ipc.MetadataEncoder; +import io.rsocket.ipc.decoders.MetadataWriter; +import io.rsocket.ipc.mimetype.MimeTypes; +import io.rsocket.ipc.util.MetadataUtils; +import io.rsocket.ipc.util.MetadataUtils.DisposableAddList; +import reactor.core.Disposable; + +public class MetadataEncoderLFP implements MetadataEncoder { + + public static interface Interceptor extends Consumer { + }; + + private final ByteBufAllocator allocator; + private final DisposableAddList interceptors = DisposableAddList.create(); + + public MetadataEncoderLFP(MetadataEncoderLFP.Interceptor... interceptors) { + this(ByteBufAllocator.DEFAULT, interceptors); + } + + public MetadataEncoderLFP(ByteBufAllocator allocator, MetadataEncoderLFP.Interceptor... interceptors) { + this.allocator = Objects.requireNonNull(allocator); + if (interceptors != null) + Arrays.asList(interceptors).stream().filter(Objects::nonNull).forEach(v -> this.addInterceptor(v)); + } + + public Disposable addInterceptor(MetadataEncoderLFP.Interceptor interceptor) { + Objects.requireNonNull(interceptor); + return interceptors.disposableAdd(interceptor); + } + + @Override + public final ByteBuf encode(ByteBuf metadata, SpanContext spanContext, String service, String... parts) { + MetadataWriter metadataWriter = new MetadataWriter(this.allocator, metadata); + this.writeMetadata(metadataWriter, spanContext, service, parts); + return metadataWriter.getCompositeByteBuf(); + } + + protected void writeMetadata(MetadataWriter metadataWriter, SpanContext spanContext, String service, + String... parts) { + interceptors.forEach(interceptor -> interceptor.accept(metadataWriter)); + writeRoutingInfo(metadataWriter, service, parts); + writeTracingSpanContext(metadataWriter, spanContext); + } + + private void writeRoutingInfo(MetadataWriter metadataWriter, String service, String... parts) { + metadataWriter.writeString(MimeTypes.MIME_TYPE_SERVICE, service); + Stream methodsStream = parts == null ? Stream.empty() + : Arrays.asList(parts).stream().filter(MetadataUtils::nonEmpty); + methodsStream.forEach(v -> { + metadataWriter.writeString(MimeTypes.MIME_TYPE_METHOD, v); + }); + } + + private void writeTracingSpanContext(MetadataWriter metadataWriter, SpanContext spanContext) { + if (spanContext == null) + return; + Iterable> items = spanContext.baggageItems(); + if (items == null) + return; + Map> paramMap = new LinkedHashMap<>(); + for (Entry ent : items) + paramMap.computeIfAbsent(ent.getKey(), nil -> new LinkedHashSet<>()).add(ent.getValue()); + metadataWriter.writeEntries(MimeTypes.MIME_TYPE_TRACER, paramMap); + } +} diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataReader.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataReader.java new file mode 100644 index 00000000..a112c8fa --- /dev/null +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataReader.java @@ -0,0 +1,139 @@ +package io.rsocket.ipc.encoders; + +import java.util.AbstractMap.SimpleImmutableEntry; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Objects; +import java.util.Optional; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import io.netty.buffer.ByteBuf; +import io.rsocket.ipc.mimetype.MimeType; +import io.rsocket.ipc.mimetype.MimeTypes; +import io.rsocket.ipc.util.MetadataUtils; +import io.rsocket.metadata.CompositeMetadata; + +public class MetadataReader { + + private final CompositeMetadata compositeMetadata; + + public MetadataReader(ByteBuf source) { + this(source, false); + } + + public MetadataReader(ByteBuf source, boolean retainSlices) { + Objects.requireNonNull(source); + this.compositeMetadata = new CompositeMetadata(source, retainSlices); + } + + public boolean containsString(MimeType mimeType, String value) { + return containsString(mimeType, value, false, -1); + } + + public boolean containsStringSecure(MimeType mimeType, String value) { + Objects.requireNonNull(mimeType); + MetadataUtils.requireNonEmpty(value); + return containsString(mimeType, value, false, 1); + } + + public boolean containsString(MimeType mimeType, String value, boolean ignoreCase, int maxCandidates) { + Stream stream = streamStrings(mimeType); + if (maxCandidates != -1)// ex: limit password candidates + stream = stream.limit(maxCandidates); + stream = stream.filter(v -> MetadataUtils.equals(v, value, ignoreCase)); + return stream.findFirst().isPresent(); + } + + public boolean containsEntry(MimeType mimeType, String key, String value) { + return containsEntry(mimeType, key, value, false, -1); + } + + public boolean containsEntry(MimeType mimeType, String key, String value, boolean ignoreCase, int maxCandidates) { + Stream>> stream = streamEntries(mimeType) + .filter(e -> MetadataUtils.equals(e.getKey(), key, ignoreCase)); + if (maxCandidates != -1)// ex: limit password candidates + stream = stream.limit(maxCandidates); + stream = stream.filter(e -> MetadataUtils.equals(e.getValue().orElse(null), value, ignoreCase)); + return stream.findFirst().isPresent(); + } + + public Stream streamStrings(MimeType mimeType) { + return stream(toTest -> Objects.equals(toTest, mimeType), bb -> { + return Stream.of(MetadataUtils.byteBufToString(bb)); + }); + } + + public Stream streamStringsNonEmpty(MimeType mimeType) { + return streamStrings(mimeType).filter(v -> !MetadataUtils.isNullOrEmpty(v)); + } + + public Stream>> streamEntries(MimeType mimeType) { + return stream(toTest -> Objects.equals(toTest, mimeType), bb -> { + return parseQueryString(MetadataUtils.byteBufToString(bb)); + }); + } + + public Map>> getEntries(MimeType mimeType) { + Map>> map = new LinkedHashMap<>(); + streamEntries(mimeType) + .forEach(e -> map.computeIfAbsent(e.getKey(), nil -> new ArrayList<>()).add(e.getValue())); + return map; + } + + public Stream> streamEntriesNonEmpty(MimeType mimeType) { + return streamEntries(mimeType).filter(e -> e.getValue().isPresent()) + .map(e -> new SimpleImmutableEntry<>(e.getKey(), e.getValue().get())) + .filter(e -> !MetadataUtils.isNullOrEmpty(e.getValue())).map(v -> v); + } + + public Map> getEntriesNonEmpty(MimeType mimeType) { + Map> map = new LinkedHashMap<>(); + streamEntriesNonEmpty(mimeType) + .forEach(e -> map.computeIfAbsent(e.getKey(), nil -> new ArrayList<>()).add(e.getValue())); + return map; + } + + public Stream stream(Predicate mimeTypePredicate, Function> decoder) { + Objects.requireNonNull(mimeTypePredicate); + Objects.requireNonNull(decoder); + Stream> streams = this.getCompositeMetadata().stream().filter(e -> { + if (MetadataUtils.isNullOrEmpty(e.getMimeType())) + return false; + MimeType mimteType = MimeTypes.create(e.getMimeType()); + return mimeTypePredicate.test(mimteType); + }).map(e -> e.getContent()).map(decoder); + return MetadataUtils.flatMap(streams); + } + + public CompositeMetadata getCompositeMetadata() { + return compositeMetadata; + } + + private static Stream>> parseQueryString(String query) { + if (MetadataUtils.isNullOrEmpty(query)) + return Stream.empty(); + while (query.startsWith("?")) + query = query.substring(1); + if (MetadataUtils.isNullOrEmpty(query)) + return Stream.empty(); + return Arrays.stream(query.split("&")).map(p -> splitQueryParameter(p)); + } + + private static Entry> splitQueryParameter(String parameter) { + List keyValue = Arrays.stream(parameter.split("=")).map(MetadataUtils::urlDecode).limit(2) + .collect(Collectors.toList()); + if (keyValue.size() == 2) { + return new SimpleImmutableEntry<>(keyValue.get(0), Optional.of(keyValue.get(1))); + } else { + return new SimpleImmutableEntry<>(keyValue.get(0), Optional.empty()); + } + } + +} diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/mimetype/MimeType.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/mimetype/MimeType.java new file mode 100644 index 00000000..06238bb2 --- /dev/null +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/mimetype/MimeType.java @@ -0,0 +1,94 @@ +package io.rsocket.ipc.mimetype; + +import java.util.Objects; +import java.util.Optional; +import java.util.function.Supplier; + +import io.rsocket.ipc.util.MetadataUtils; +import io.rsocket.metadata.WellKnownMimeType; + +public interface MimeType { + + String getString(); + + Optional getWellKnownMimeType(); + + static class Impl implements MimeType { + + private final String mimeTypeFallback; + private final Supplier wellKnownMimeTypeSupplier; + + public Impl(WellKnownMimeType wellKnownMimeType) { + Objects.requireNonNull(wellKnownMimeType); + this.wellKnownMimeTypeSupplier = () -> wellKnownMimeType; + this.mimeTypeFallback = null; + } + + public Impl(String mimeType) { + MetadataUtils.requireNonEmpty(mimeType); + this.wellKnownMimeTypeSupplier = new Supplier() { + + private Optional parsed; + + @Override + public WellKnownMimeType get() { + if (parsed == null) + synchronized (this) { + if (parsed == null) + parsed = MetadataUtils.parseWellKnownMimeType(mimeType); + } + return parsed.orElse(null); + } + }; + this.mimeTypeFallback = mimeType; + } + + @Override + public String getString() { + Optional wkmtOp = getWellKnownMimeType(); + if (wkmtOp.isPresent()) + return wkmtOp.get().getString(); + // shouldn't happen, but maybe some weird overriding + return MetadataUtils.requireNonEmpty(mimeTypeFallback); + } + + @Override + public Optional getWellKnownMimeType() { + return Optional.ofNullable(wellKnownMimeTypeSupplier.get()); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + String strValue = getString().toLowerCase(); + result = prime * result + ((strValue == null) ? 0 : strValue.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (!(obj instanceof MimeType)) + return false; + String strValue = this.getString().toLowerCase(); + String strValueOther = ((MimeType) obj).getString(); + if (strValueOther != null) + strValueOther = strValueOther.toLowerCase(); + return Objects.equals(strValue, strValueOther); + } + + @Override + public String toString() { + WellKnownMimeType wellKnownMimeType = getWellKnownMimeType().orElse(null); + String result = "Impl [wellKnownMimeType=" + wellKnownMimeType + ", mimeTypeFallback=" + mimeTypeFallback + + "]"; + return result; + } + + } + +} diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/mimetype/MimeTypes.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/mimetype/MimeTypes.java new file mode 100644 index 00000000..4d526932 --- /dev/null +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/mimetype/MimeTypes.java @@ -0,0 +1,19 @@ +package io.rsocket.ipc.mimetype; + +import io.rsocket.metadata.WellKnownMimeType; + +public class MimeTypes { + + public static final MimeType MIME_TYPE_SERVICE = MimeTypes.create(WellKnownMimeType.MESSAGE_RSOCKET_ROUTING); + public static final MimeType MIME_TYPE_METHOD = MimeTypes.create(MIME_TYPE_SERVICE.getString() + "/method"); + public static final MimeType MIME_TYPE_TRACER = MimeTypes.create("message/x.rsocket.ipc.tracer.v0"); + + public static MimeType create(String mimeType) { + return new MimeType.Impl(mimeType); + } + + public static MimeType create(WellKnownMimeType wellKnownMimeType) { + return new MimeType.Impl(wellKnownMimeType); + } + +} diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/MetadataUtils.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/MetadataUtils.java new file mode 100644 index 00000000..d915841e --- /dev/null +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/MetadataUtils.java @@ -0,0 +1,168 @@ +package io.rsocket.ipc.util; + +import java.io.UnsupportedEncodingException; +import java.net.URLDecoder; +import java.net.URLEncoder; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.Spliterators.AbstractSpliterator; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Consumer; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import io.rsocket.metadata.WellKnownMimeType; +import reactor.core.Disposable; +import reactor.core.Disposables; + +public class MetadataUtils { + public static final Charset CHARSET = StandardCharsets.UTF_8; + + public static Stream stream(Iterator iterator) { + if (iterator == null) + return Stream.empty(); + return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED), false); + } + + public static Stream flatMap(Stream> streams) { + if (streams == null) + return Stream.empty(); + Iterator> iter = streams.iterator(); + Spliterator spliterator = new AbstractSpliterator(Long.MAX_VALUE, Spliterator.ORDERED) { + + private Iterator currentIterator; + + @Override + public boolean tryAdvance(Consumer action) { + synchronized (iter) { + while (true) { + if (currentIterator != null && currentIterator.hasNext()) { + action.accept(currentIterator.next()); + return true; + } + if (iter.hasNext()) { + Stream nextStream = iter.next(); + currentIterator = nextStream == null ? null : nextStream.iterator(); + } else + break; + } + } + return false; + } + + }; + return StreamSupport.stream(spliterator, false); + } + + public static String mimeTypeToString(WellKnownMimeType wellKnownMimeType) { + return wellKnownMimeType == null ? null : wellKnownMimeType.getString(); + } + + public static String byteBufToString(ByteBuf byteBuf) { + return Objects.requireNonNull(byteBuf).toString(CHARSET); + } + + public static ByteBuf byteBufFromString(String str) { + return Unpooled.wrappedBuffer(Objects.requireNonNull(str).getBytes(CHARSET)); + } + + public static boolean equals(String value1, String value2, boolean ignoreCase) { + if (Objects.equals(value1, value2)) + return true; + if (!ignoreCase || value1 == null || value2 == null) + return false; + return value1.equalsIgnoreCase(value2); + } + + public static String urlDecode(String str) { + try { + return URLDecoder.decode(str, MetadataUtils.CHARSET.name()); + } catch (UnsupportedEncodingException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + } + + public static String urlEncode(String str) { + try { + return URLEncoder.encode(str, MetadataUtils.CHARSET.name()); + } catch (UnsupportedEncodingException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + } + + public static boolean isNullOrEmpty(String str) { + return str == null || str.isEmpty(); + } + + public static boolean nonEmpty(String str) { + return !isNullOrEmpty(str); + } + + public static X requireNonEmpty(X charSequence) { + Objects.requireNonNull(charSequence); + if (charSequence.length() <= 0) + throw new IllegalArgumentException(); + return charSequence; + } + + private static final AtomicReference> WellKnownMimeType_FROM_STRING_CACHE_REF = new AtomicReference<>(); + + public static Optional parseWellKnownMimeType(String mimeType) { + if (MetadataUtils.isNullOrEmpty(mimeType)) + return Optional.empty(); + if (WellKnownMimeType_FROM_STRING_CACHE_REF.get() == null) + synchronized (WellKnownMimeType_FROM_STRING_CACHE_REF) { + if (WellKnownMimeType_FROM_STRING_CACHE_REF.get() == null) { + Map map = new HashMap<>(); + for (WellKnownMimeType wkmt : WellKnownMimeType.values()) { + for (String str : Arrays.asList(wkmt.getString(), wkmt.name())) { + map.put(str, wkmt); + map.put(str.toUpperCase(), wkmt); + map.put(str.toLowerCase(), wkmt); + } + } + WellKnownMimeType_FROM_STRING_CACHE_REF.set(map); + } + } + WellKnownMimeType result = null; + if (result == null) + result = WellKnownMimeType_FROM_STRING_CACHE_REF.get().get(mimeType); + if (result == null) + result = WellKnownMimeType_FROM_STRING_CACHE_REF.get().get(mimeType.toUpperCase()); + if (result == null) + result = WellKnownMimeType_FROM_STRING_CACHE_REF.get().get(mimeType.toLowerCase()); + return Optional.ofNullable(result); + } + + public static class DisposableAddList extends CopyOnWriteArrayList { + + private static final long serialVersionUID = 1L; + + public static DisposableAddList create() { + return new DisposableAddList(); + } + + public Disposable disposableAdd(X value) { + Disposable disposable = Disposables.composite(() -> { + this.removeIf(v -> v == value); + }); + this.add(value); + return disposable; + } + } +} From d709d7838690c4bbb27d2340d83017aae2c2f555 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 May 2020 16:57:26 -0400 Subject: [PATCH 004/273] Update jitpack.yml --- jitpack.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/jitpack.yml b/jitpack.yml index e69de29b..88424566 100644 --- a/jitpack.yml +++ b/jitpack.yml @@ -0,0 +1,3 @@ +install: + - echo "Running a custom install command" + - ./gradlew clean build publishToMavenLocal -x test -x verifyGoogleJavaFormat \ No newline at end of file From e108fe5c6df4dfc0e4a91f599ab7abc503688321 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 May 2020 16:59:02 -0400 Subject: [PATCH 005/273] a --- jitpack.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/jitpack.yml b/jitpack.yml index 88424566..4724ca7d 100644 --- a/jitpack.yml +++ b/jitpack.yml @@ -1,3 +1,2 @@ install: - - echo "Running a custom install command" - ./gradlew clean build publishToMavenLocal -x test -x verifyGoogleJavaFormat \ No newline at end of file From 21ab3f8a761e5e80a7dc8640bdb27069b06bd626 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 May 2020 17:00:06 -0400 Subject: [PATCH 006/273] a --- jitpack.yml => jitpack.yml.bak | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename jitpack.yml => jitpack.yml.bak (100%) diff --git a/jitpack.yml b/jitpack.yml.bak similarity index 100% rename from jitpack.yml rename to jitpack.yml.bak From 5ccca68e50e788ffdc35696366b27d0b44a4f8c0 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 May 2020 17:05:17 -0400 Subject: [PATCH 007/273] line endings --- .gitattributes | 1 + 1 file changed, 1 insertion(+) create mode 100644 .gitattributes diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..0b9c73ac --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +text=auto eol=lf \ No newline at end of file From 9156d18d13e34b6d56d07edc95e26cb28ddeddee Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 May 2020 17:06:23 -0400 Subject: [PATCH 008/273] bat --- gradlew.bat | 200 ++++++++++++++++++++++++++-------------------------- 1 file changed, 100 insertions(+), 100 deletions(-) diff --git a/gradlew.bat b/gradlew.bat index 24467a14..9618d8d9 100644 --- a/gradlew.bat +++ b/gradlew.bat @@ -1,100 +1,100 @@ -@rem -@rem Copyright 2015 the original author or authors. -@rem -@rem Licensed under the Apache License, Version 2.0 (the "License"); -@rem you may not use this file except in compliance with the License. -@rem You may obtain a copy of the License at -@rem -@rem https://www.apache.org/licenses/LICENSE-2.0 -@rem -@rem Unless required by applicable law or agreed to in writing, software -@rem distributed under the License is distributed on an "AS IS" BASIS, -@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -@rem See the License for the specific language governing permissions and -@rem limitations under the License. -@rem - -@if "%DEBUG%" == "" @echo off -@rem ########################################################################## -@rem -@rem Gradle startup script for Windows -@rem -@rem ########################################################################## - -@rem Set local scope for the variables with windows NT shell -if "%OS%"=="Windows_NT" setlocal - -set DIRNAME=%~dp0 -if "%DIRNAME%" == "" set DIRNAME=. -set APP_BASE_NAME=%~n0 -set APP_HOME=%DIRNAME% - -@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" - -@rem Find java.exe -if defined JAVA_HOME goto findJavaFromJavaHome - -set JAVA_EXE=java.exe -%JAVA_EXE% -version >NUL 2>&1 -if "%ERRORLEVEL%" == "0" goto init - -echo. -echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. -echo. -echo Please set the JAVA_HOME variable in your environment to match the -echo location of your Java installation. - -goto fail - -:findJavaFromJavaHome -set JAVA_HOME=%JAVA_HOME:"=% -set JAVA_EXE=%JAVA_HOME%/bin/java.exe - -if exist "%JAVA_EXE%" goto init - -echo. -echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% -echo. -echo Please set the JAVA_HOME variable in your environment to match the -echo location of your Java installation. - -goto fail - -:init -@rem Get command-line arguments, handling Windows variants - -if not "%OS%" == "Windows_NT" goto win9xME_args - -:win9xME_args -@rem Slurp the command line arguments. -set CMD_LINE_ARGS= -set _SKIP=2 - -:win9xME_args_slurp -if "x%~1" == "x" goto execute - -set CMD_LINE_ARGS=%* - -:execute -@rem Setup the command line - -set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar - -@rem Execute Gradle -"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% - -:end -@rem End local scope for the variables with windows NT shell -if "%ERRORLEVEL%"=="0" goto mainEnd - -:fail -rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of -rem the _cmd.exe /c_ return code! -if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 -exit /b 1 - -:mainEnd -if "%OS%"=="Windows_NT" endlocal - -:omega +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto init + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto init + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:init +@rem Get command-line arguments, handling Windows variants + +if not "%OS%" == "Windows_NT" goto win9xME_args + +:win9xME_args +@rem Slurp the command line arguments. +set CMD_LINE_ARGS= +set _SKIP=2 + +:win9xME_args_slurp +if "x%~1" == "x" goto execute + +set CMD_LINE_ARGS=%* + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega From 662de07627defd90b88e073df9ef822de9c91f7f Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 May 2020 17:08:10 -0400 Subject: [PATCH 009/273] jitpack --- jitpack.yml | 2 ++ jitpack.yml.bak | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 jitpack.yml diff --git a/jitpack.yml b/jitpack.yml new file mode 100644 index 00000000..54d89ebf --- /dev/null +++ b/jitpack.yml @@ -0,0 +1,2 @@ +install: + - ./gradlew clean -x test -x verifyGoogleJavaFormat build publishToMavenLocal \ No newline at end of file diff --git a/jitpack.yml.bak b/jitpack.yml.bak index 4724ca7d..54d89ebf 100644 --- a/jitpack.yml.bak +++ b/jitpack.yml.bak @@ -1,2 +1,2 @@ install: - - ./gradlew clean build publishToMavenLocal -x test -x verifyGoogleJavaFormat \ No newline at end of file + - ./gradlew clean -x test -x verifyGoogleJavaFormat build publishToMavenLocal \ No newline at end of file From fce8df84e87d4c043d55a31e3c04767fb0cc0119 Mon Sep 17 00:00:00 2001 From: regbo Date: Fri, 8 May 2020 17:09:49 -0400 Subject: [PATCH 010/273] permissions --- jitpack.yml | 0 jitpack.yml.bak | 0 2 files changed, 0 insertions(+), 0 deletions(-) mode change 100644 => 100755 jitpack.yml mode change 100644 => 100755 jitpack.yml.bak diff --git a/jitpack.yml b/jitpack.yml old mode 100644 new mode 100755 diff --git a/jitpack.yml.bak b/jitpack.yml.bak old mode 100644 new mode 100755 From 51dc6ffed4b7ce033d24657b0aedf86bbad9057d Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 May 2020 17:11:48 -0400 Subject: [PATCH 011/273] command --- jitpack.yml | 2 +- jitpack.yml.bak | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) mode change 100755 => 100644 jitpack.yml mode change 100755 => 100644 jitpack.yml.bak diff --git a/jitpack.yml b/jitpack.yml old mode 100755 new mode 100644 index 54d89ebf..0929ebf1 --- a/jitpack.yml +++ b/jitpack.yml @@ -1,2 +1,2 @@ install: - - ./gradlew clean -x test -x verifyGoogleJavaFormat build publishToMavenLocal \ No newline at end of file + - .clean build publishToMavenLocal -x test -x verifyGoogleJavaFormat \ No newline at end of file diff --git a/jitpack.yml.bak b/jitpack.yml.bak old mode 100755 new mode 100644 index 54d89ebf..0929ebf1 --- a/jitpack.yml.bak +++ b/jitpack.yml.bak @@ -1,2 +1,2 @@ install: - - ./gradlew clean -x test -x verifyGoogleJavaFormat build publishToMavenLocal \ No newline at end of file + - .clean build publishToMavenLocal -x test -x verifyGoogleJavaFormat \ No newline at end of file From f560f133566982bc03de61a502a3057deb28b757 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 May 2020 17:12:39 -0400 Subject: [PATCH 012/273] perms --- gradlew | 0 1 file changed, 0 insertions(+), 0 deletions(-) mode change 100644 => 100755 gradlew diff --git a/gradlew b/gradlew old mode 100644 new mode 100755 From 5c8a006f4b6082008a32b832878568c453df88b2 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 May 2020 17:14:11 -0400 Subject: [PATCH 013/273] command mod --- jitpack.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/jitpack.yml b/jitpack.yml index 0929ebf1..c8c3b229 100644 --- a/jitpack.yml +++ b/jitpack.yml @@ -1,2 +1,2 @@ install: - - .clean build publishToMavenLocal -x test -x verifyGoogleJavaFormat \ No newline at end of file + - ./gradlew .clean build publishToMavenLocal -x test -x verifyGoogleJavaFormat \ No newline at end of file From 6835e1fffdf6af069e1611ef201238387d484ae3 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 May 2020 17:16:36 -0400 Subject: [PATCH 014/273] Update jitpack.yml --- jitpack.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/jitpack.yml b/jitpack.yml index c8c3b229..46aaa280 100644 --- a/jitpack.yml +++ b/jitpack.yml @@ -1,2 +1,2 @@ install: - - ./gradlew .clean build publishToMavenLocal -x test -x verifyGoogleJavaFormat \ No newline at end of file + - ./gradlew clean build publishToMavenLocal -x test -x verifyGoogleJavaFormat \ No newline at end of file From af33d6cc72c6e069724d530232b1ccda1758572a Mon Sep 17 00:00:00 2001 From: regbo Date: Fri, 8 May 2020 17:21:54 -0400 Subject: [PATCH 015/273] Update README.md --- README.md | 88 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) diff --git a/README.md b/README.md index 880cae8f..1a3a03d4 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,91 @@ +# Updated RSocket IPC Metadata Handling + +This is intended to be used as an add on to the IPC module of rsocket/rsocket-rpc-java found here: https://github.com/rsocket/rsocket-rpc-java + +The rsocket/rsocket-rpc-java project uses an outdated version of RSocket and doesn't work well with CompositeMetadata. It uses custom parsing and encoding of metadata content to route messages. + +This project provides drop in (see note) replacement MetadataDecoder and MetadataEncoder classes. + +**NOTE:** + +*Because rsocket-rpc-java isn't on maven, I'm using a fork of the project that can be accessed from jitpack. (the original rsocket-rpc-java fails on jitback because of protobuf requirements) That fork can be found here: https://github.com/regbo/lfp-rsocket-rpc-java* + +The two classes at work are MetadataDecoderLFP and MetadataEncoderLFP. They use MetadataWriter and MetadataReader classes to allow for custom serialization of metadata content. + +Out of the box they support the service/method/trace requirements of rsocket/rsocket-rpc-java but also allow for custom interceptors. + +For example, we can use the following code to require a password on all requests: + +```java +MetadataDecoderLFP decoder = new MetadataDecoderLFP(); +RequestHandlingRSocket requestHandler = new RequestHandlingRSocket(decoder); +{// start server + SocketAcceptor socketAcceptor = (setup, client) -> Mono.just(requestHandler); + RSocketServer.create(socketAcceptor).interceptors(ir -> { + }).errorConsumer(t -> { + java.util.logging.Logger.getLogger("[server]").log(Level.SEVERE, "uncaught error", t); + }).bind(TcpServerTransport.create("localhost", 7000)).block(); +} +decoder.addInterceptor(reader -> { + boolean match = reader.containsString(MimeTypes.create("password"), "thisIsACoolPassWord!"); + if (!match) + throw new IllegalArgumentException("not authorized"); +}); +``` +If we try to access the server, we will receive the following: + +``` +SEVERE: uncaught error +java.lang.IllegalArgumentException: not authorized + at com.lfp.rsocket.ipc.metadata.IntegrationTest.lambda$13(IntegrationTest.java:116) +``` + +We can then modify the client to add the password, and everything works fine: + +```java +MetadataEncoderLFP encoder = new MetadataEncoderLFP(); +RSocket rsocket; +{// start client + rsocket = RSocketConnector.create().connect(TcpClientTransport.create("localhost", 7000)).block(); +} +encoder.addInterceptor( + writer -> writer.writeString(MimeTypes.create("password"), "thisIsACoolPassWord!")); +``` +As a bonus, the writers and readers can handle Multimap values, by encoding the content as a url query. (EX: "key=val1&key=val2&neat=wow") + +To illustrate this we can look at how tracing is handled, which requires a multimap of key value pairs to be stored in metadata. + +Here's how it's encoded: + +```java +private void appendTracing(MetadataWriter metadataWriter, SpanContext spanContext) { + if (spanContext == null) + return; + Iterable> items = spanContext.baggageItems(); + if (items == null) + return; + Map> paramMap = new LinkedHashMap<>(); + for (Entry ent : items) + paramMap.computeIfAbsent(ent.getKey(), nil -> new LinkedHashSet<>()).add(ent.getValue()); + metadataWriter.writeEntries(MimeTypes.MIME_TYPE_TRACER, paramMap); +} +``` +Here's how it's decoded: + +```java +private SpanContext getTracingSpanContext(MetadataReader metadataReader) { + if (tracer == null) + return null; + Map tracerMetadata = new LinkedHashMap<>(); + metadataReader.streamEntriesNonEmpty(MimeTypes.MIME_TYPE_TRACER) + .forEach(ent -> tracerMetadata.computeIfAbsent(ent.getKey(), nil -> ent.getValue())); + if (tracerMetadata.isEmpty()) + return null; + return Tracing.deserializeTracingMetadata(tracer, tracerMetadata); +} +``` + + # RSocket RPC - Java [![Build Status](https://travis-ci.org/rsocket/rsocket-rpc-java.svg?branch=master)](https://travis-ci.org/rsocket/rsocket-rpc-java) From 54079c3bebf4d3e003fc62501c5b55d99e51fbc1 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 May 2020 17:23:22 -0400 Subject: [PATCH 016/273] readme --- README.md | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 1a3a03d4..ad28fadc 100644 --- a/README.md +++ b/README.md @@ -4,11 +4,7 @@ This is intended to be used as an add on to the IPC module of rsocket/rsocket-rp The rsocket/rsocket-rpc-java project uses an outdated version of RSocket and doesn't work well with CompositeMetadata. It uses custom parsing and encoding of metadata content to route messages. -This project provides drop in (see note) replacement MetadataDecoder and MetadataEncoder classes. - -**NOTE:** - -*Because rsocket-rpc-java isn't on maven, I'm using a fork of the project that can be accessed from jitpack. (the original rsocket-rpc-java fails on jitback because of protobuf requirements) That fork can be found here: https://github.com/regbo/lfp-rsocket-rpc-java* +This project provides drop in (assuming RSocket RC1.7 and up) replacement MetadataDecoder and MetadataEncoder classes. The two classes at work are MetadataDecoderLFP and MetadataEncoderLFP. They use MetadataWriter and MetadataReader classes to allow for custom serialization of metadata content. @@ -104,7 +100,7 @@ The standard [RSocket](http://rsocket.io) RPC Java implementation. 2. Run the following Gradle command to build the project: $ ./gradlew clean build - + ## What Next? * [Motivation](./docs/motivation.md) From e9bad1e2b27e816d11b48224fd6b73915edbe640 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 May 2020 17:33:41 -0400 Subject: [PATCH 017/273] modify decoder --- rsocket-ipc-core/bin/.gitignore | 2 + .../ipc/decoders/MetadataDecoderLFP.java | 39 ++++++++++++------- rsocket-ipc-graphql/bin/.gitignore | 2 + rsocket-ipc-jackson/bin/.gitignore | 1 + 4 files changed, 30 insertions(+), 14 deletions(-) create mode 100644 rsocket-ipc-core/bin/.gitignore create mode 100644 rsocket-ipc-graphql/bin/.gitignore create mode 100644 rsocket-ipc-jackson/bin/.gitignore diff --git a/rsocket-ipc-core/bin/.gitignore b/rsocket-ipc-core/bin/.gitignore new file mode 100644 index 00000000..7eed456b --- /dev/null +++ b/rsocket-ipc-core/bin/.gitignore @@ -0,0 +1,2 @@ +/main/ +/test/ diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java index 31d403ed..1ebaa168 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java @@ -11,7 +11,6 @@ import io.netty.buffer.ByteBuf; import io.opentracing.SpanContext; import io.opentracing.Tracer; -import io.rsocket.Payload; import io.rsocket.ipc.MetadataDecoder; import io.rsocket.ipc.encoders.MetadataReader; import io.rsocket.ipc.mimetype.MimeTypes; @@ -43,21 +42,33 @@ public Disposable addInterceptor(MetadataDecoderLFP.Interceptor interceptor) { } @Override - public final RESULT decode(Payload payload, Handler transformer) throws Exception { - ByteBuf metadata = payload.sliceMetadata(); - // i think that we can retain reader slices bc we slice the data from the - // payload - MetadataReader metadataReader = new MetadataReader(metadata, true); + public Metadata decode(ByteBuf metadataByteBuf) throws Exception { + MetadataReader metadataReader = new MetadataReader(metadataByteBuf, true); interceptors.forEach(v -> v.accept(metadataReader)); - return decode(payload.sliceData(), metadataReader, metadata, transformer); - } - - protected RESULT decode(ByteBuf data, MetadataReader metadataReader, ByteBuf metadata, - Handler transformer) throws Exception { String route = getRoute(metadataReader); - SpanContext context = readTracingSpanContext(metadataReader); - RESULT result = transformer.handleAndReply(data, metadata, route, context); - return result; + SpanContext spanContext = readTracingSpanContext(metadataReader); + return new Metadata() { + + @Override + public ByteBuf metadata() { + return metadataByteBuf; + } + + @Override + public String route() { + return route; + } + + @Override + public SpanContext spanContext() { + return spanContext; + } + + @Override + public boolean isComposite() { + return true; + } + }; } private String getRoute(MetadataReader metadataReader) { diff --git a/rsocket-ipc-graphql/bin/.gitignore b/rsocket-ipc-graphql/bin/.gitignore new file mode 100644 index 00000000..7eed456b --- /dev/null +++ b/rsocket-ipc-graphql/bin/.gitignore @@ -0,0 +1,2 @@ +/main/ +/test/ diff --git a/rsocket-ipc-jackson/bin/.gitignore b/rsocket-ipc-jackson/bin/.gitignore new file mode 100644 index 00000000..ddf9c656 --- /dev/null +++ b/rsocket-ipc-jackson/bin/.gitignore @@ -0,0 +1 @@ +/main/ From b9a274b26db80b244b52aa523db5f340675faf7f Mon Sep 17 00:00:00 2001 From: regbo Date: Fri, 8 May 2020 17:26:37 -0400 Subject: [PATCH 018/273] Delete gradlew.bat --- gradlew.bat | 100 ---------------------------------------------------- 1 file changed, 100 deletions(-) delete mode 100644 gradlew.bat diff --git a/gradlew.bat b/gradlew.bat deleted file mode 100644 index 9618d8d9..00000000 --- a/gradlew.bat +++ /dev/null @@ -1,100 +0,0 @@ -@rem -@rem Copyright 2015 the original author or authors. -@rem -@rem Licensed under the Apache License, Version 2.0 (the "License"); -@rem you may not use this file except in compliance with the License. -@rem You may obtain a copy of the License at -@rem -@rem https://www.apache.org/licenses/LICENSE-2.0 -@rem -@rem Unless required by applicable law or agreed to in writing, software -@rem distributed under the License is distributed on an "AS IS" BASIS, -@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -@rem See the License for the specific language governing permissions and -@rem limitations under the License. -@rem - -@if "%DEBUG%" == "" @echo off -@rem ########################################################################## -@rem -@rem Gradle startup script for Windows -@rem -@rem ########################################################################## - -@rem Set local scope for the variables with windows NT shell -if "%OS%"=="Windows_NT" setlocal - -set DIRNAME=%~dp0 -if "%DIRNAME%" == "" set DIRNAME=. -set APP_BASE_NAME=%~n0 -set APP_HOME=%DIRNAME% - -@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" - -@rem Find java.exe -if defined JAVA_HOME goto findJavaFromJavaHome - -set JAVA_EXE=java.exe -%JAVA_EXE% -version >NUL 2>&1 -if "%ERRORLEVEL%" == "0" goto init - -echo. -echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. -echo. -echo Please set the JAVA_HOME variable in your environment to match the -echo location of your Java installation. - -goto fail - -:findJavaFromJavaHome -set JAVA_HOME=%JAVA_HOME:"=% -set JAVA_EXE=%JAVA_HOME%/bin/java.exe - -if exist "%JAVA_EXE%" goto init - -echo. -echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% -echo. -echo Please set the JAVA_HOME variable in your environment to match the -echo location of your Java installation. - -goto fail - -:init -@rem Get command-line arguments, handling Windows variants - -if not "%OS%" == "Windows_NT" goto win9xME_args - -:win9xME_args -@rem Slurp the command line arguments. -set CMD_LINE_ARGS= -set _SKIP=2 - -:win9xME_args_slurp -if "x%~1" == "x" goto execute - -set CMD_LINE_ARGS=%* - -:execute -@rem Setup the command line - -set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar - -@rem Execute Gradle -"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% - -:end -@rem End local scope for the variables with windows NT shell -if "%ERRORLEVEL%"=="0" goto mainEnd - -:fail -rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of -rem the _cmd.exe /c_ return code! -if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 -exit /b 1 - -:mainEnd -if "%OS%"=="Windows_NT" endlocal - -:omega From 861432c63e34d3931ea9a0c1119080a85854c1a9 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 May 2020 17:39:52 -0400 Subject: [PATCH 019/273] testing add --- .../java/io/rsocket/ipc/IntegrationTest.java | 205 ++++++++++-------- 1 file changed, 110 insertions(+), 95 deletions(-) diff --git a/rsocket-ipc-core/src/test/java/io/rsocket/ipc/IntegrationTest.java b/rsocket-ipc-core/src/test/java/io/rsocket/ipc/IntegrationTest.java index cfaa410b..e20a84d1 100644 --- a/rsocket-ipc-core/src/test/java/io/rsocket/ipc/IntegrationTest.java +++ b/rsocket-ipc-core/src/test/java/io/rsocket/ipc/IntegrationTest.java @@ -18,113 +18,128 @@ import io.netty.buffer.ByteBufAllocator; import io.rsocket.RSocket; import io.rsocket.RSocketFactory; +import io.rsocket.SocketAcceptor; +import io.rsocket.core.RSocketConnector; +import io.rsocket.core.RSocketServer; import io.rsocket.ipc.decoders.CompositeMetadataDecoder; +import io.rsocket.ipc.decoders.MetadataDecoderLFP; import io.rsocket.ipc.encoders.DefaultMetadataEncoder; +import io.rsocket.ipc.encoders.MetadataEncoderLFP; import io.rsocket.ipc.marshallers.Primitives; import io.rsocket.ipc.marshallers.Strings; +import io.rsocket.ipc.mimetype.MimeTypes; import io.rsocket.transport.local.LocalClientTransport; import io.rsocket.transport.local.LocalServerTransport; +import io.rsocket.transport.netty.client.TcpClientTransport; +import io.rsocket.transport.netty.server.TcpServerTransport; + import java.util.concurrent.atomic.AtomicBoolean; +import java.util.logging.Level; + import org.junit.Assert; import org.junit.Test; + +import reactor.core.Disposable; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; import reactor.test.StepVerifier; public class IntegrationTest { - @Test - public void test() { - RequestHandlingRSocket requestHandler = - new RequestHandlingRSocket(new CompositeMetadataDecoder()); - - RSocketFactory.receive() - .acceptor((setup, sendingSocket) -> Mono.just(requestHandler)) - .transport(LocalServerTransport.create("test-local-server")) - .start() - .block(); - - RSocket rsocket = - RSocketFactory.connect() - .transport(LocalClientTransport.create("test-local-server")) - .start() - .block(); - - AtomicBoolean ff = new AtomicBoolean(); - - IPCRSocket service = - Server.service("HelloService") - .noMeterRegistry() - .noTracer() - .marshall(Strings.marshaller()) - .unmarshall(Strings.unmarshaller()) - .requestResponse("hello", (s, byteBuf) -> Mono.just("Hello -> " + s)) - .requestResponse("goodbye", (s, byteBuf) -> Mono.just("Goodbye -> " + s)) - .requestResponse( - "count", - Primitives.intMarshaller(), - (charSequence, byteBuf) -> Mono.just(charSequence.length())) - .requestResponse( - "increment", - Primitives.intUnmarshaller(), - Primitives.intMarshaller(), - (integer, byteBuf) -> Mono.just(integer + 1)) - .requestStream( - "helloStream", (s, byteBuf) -> Flux.range(1, 10).map(i -> i + " - Hello -> " + s)) - .requestStream( - "toString", - Primitives.longUnmarshaller(), - (aLong, byteBuf) -> Flux.just(String.valueOf(aLong))) - .fireAndForget( - "ff", - (s, byteBuf) -> { - ff.set(true); - return Mono.empty(); - }) - .requestChannel("helloChannel", (s, publisher, byteBuf) -> Flux.just("Hello -> " + s)) - .toIPCRSocket(); - - requestHandler.withEndpoint(service); - - Client helloService = - Client.service("HelloService") - .rsocket(rsocket) - .customMetadataEncoder(new DefaultMetadataEncoder(ByteBufAllocator.DEFAULT)) - .noMeterRegistry() - .noTracer() - .marshall(Strings.marshaller()) - .unmarshall(Strings.unmarshaller()); - - String r1 = helloService.requestResponse("hello").apply("Alice").block(); - Assert.assertEquals("Hello -> Alice", r1); - - String r2 = helloService.requestResponse("goodbye").apply("Bob").block(); - Assert.assertEquals("Goodbye -> Bob", r2); - - StepVerifier.create(helloService.requestStream("helloStream").apply("Carol")) - .expectNextCount(10) - .expectComplete() - .verify(); - - helloService.fireAndForget("ff").apply("boom").block(); - Assert.assertTrue(ff.get()); - - String r3 = helloService.requestChannel("helloChannel").apply(Mono.just("Eve")).blockLast(); - Assert.assertEquals("Hello -> Eve", r3); - - int count = - helloService.requestResponse("count", Primitives.intUnmarshaller()).apply("hello").block(); - Assert.assertEquals(5, count); - - long l = System.currentTimeMillis(); - String toString = - helloService.requestStream("toString", Primitives.longMarshaller()).apply(l).blockLast(); - Assert.assertEquals(String.valueOf(l), toString); - - Integer increment = - helloService - .requestResponse("increment", Primitives.intMarshaller(), Primitives.intUnmarshaller()) - .apply(1) - .block(); - Assert.assertEquals(2, increment.intValue()); - } + @Test + public void test() { + MetadataDecoderLFP decoder = new MetadataDecoderLFP(); + RequestHandlingRSocket requestHandler = new RequestHandlingRSocket(decoder); + {// start server + SocketAcceptor socketAcceptor = (setup, client) -> Mono.just(requestHandler); + RSocketServer.create(socketAcceptor).interceptors(ir -> { + }).errorConsumer(t -> { + java.util.logging.Logger.getLogger("[server]").log(Level.SEVERE, "uncaught error", t); + }).bind(TcpServerTransport.create("localhost", 7000)).block(); + } + MetadataEncoderLFP encoder = new MetadataEncoderLFP(); + RSocket rsocket; + {// start client + rsocket = RSocketConnector.create().connect(TcpClientTransport.create("localhost", 7000)).block(); + } + AtomicBoolean ff = new AtomicBoolean(); + + IPCRSocket service = Server.service("HelloService").noMeterRegistry().noTracer().marshall(Strings.marshaller()) + .unmarshall(Strings.unmarshaller()).requestResponse("hello", (s, byteBuf) -> Mono.just("Hello -> " + s)) + .requestResponse("goodbye", (s, byteBuf) -> Mono.just("Goodbye -> " + s)) + .requestResponse("count", Primitives.intMarshaller(), + (charSequence, byteBuf) -> Mono.just(charSequence.length())) + .requestResponse("increment", Primitives.intUnmarshaller(), Primitives.intMarshaller(), + (integer, byteBuf) -> Mono.just(integer + 1)) + .requestStream("helloStream", (s, byteBuf) -> Flux.range(1, 10).map(i -> i + " - Hello -> " + s)) + .requestStream("toString", Primitives.longUnmarshaller(), + (aLong, byteBuf) -> Flux.just(String.valueOf(aLong))) + .fireAndForget("ff", (s, byteBuf) -> { + ff.set(true); + return Mono.empty(); + }).requestChannel("helloChannel", (s, publisher, byteBuf) -> Flux.just("Hello -> " + s)).toIPCRSocket(); + + requestHandler.withEndpoint(service); + + Client helloService = Client.service("HelloService").rsocket(rsocket) + .customMetadataEncoder(new DefaultMetadataEncoder(ByteBufAllocator.DEFAULT)).noMeterRegistry() + .noTracer().marshall(Strings.marshaller()).unmarshall(Strings.unmarshaller()); + + String r1 = helloService.requestResponse("hello").apply("Alice").block(); + Assert.assertEquals("Hello -> Alice", r1); + + String r2 = helloService.requestResponse("goodbye").apply("Bob").block(); + Assert.assertEquals("Goodbye -> Bob", r2); + + StepVerifier.create(helloService.requestStream("helloStream").apply("Carol")).expectNextCount(10) + .expectComplete().verify(); + + helloService.fireAndForget("ff").apply("boom").block(); + Assert.assertTrue(ff.get()); + + String r3 = helloService.requestChannel("helloChannel").apply(Mono.just("Eve")).blockLast(); + Assert.assertEquals("Hello -> Eve", r3); + + int count = helloService.requestResponse("count", Primitives.intUnmarshaller()).apply("hello").block(); + Assert.assertEquals(5, count); + + long l = System.currentTimeMillis(); + String toString = helloService.requestStream("toString", Primitives.longMarshaller()).apply(l).blockLast(); + Assert.assertEquals(String.valueOf(l), toString); + + Integer increment = helloService + .requestResponse("increment", Primitives.intMarshaller(), Primitives.intUnmarshaller()).apply(1) + .block(); + Assert.assertEquals(2, increment.intValue()); + Disposable encoderPasswordDisposable = null; + for (int i = 0; i < 3; i++) { + if (i == 1) { + encoderPasswordDisposable = encoder.addInterceptor(writer -> { + // writer.writeString(MimeTypes.create("password"), "AAAAAAAAAAAA"); + writer.writeString(MimeTypes.create("password"), "thisIsACoolPassWord!"); + }); + decoder.addInterceptor(reader -> { + boolean match = reader.containsStringSecure(MimeTypes.create("password"), "thisIsACoolPassWord!"); + if (!match) + throw new IllegalArgumentException("not authorized"); + }); + } + boolean shouldFail; + if (i == 2) { + shouldFail = true; + encoderPasswordDisposable.dispose(); + } else + shouldFail = false; + boolean failed; + try { + Integer incrementMetadata = helloService + .requestResponse("increment", Primitives.intMarshaller(), Primitives.intUnmarshaller()).apply(1) + .block(); + Assert.assertEquals(2, incrementMetadata.intValue()); + failed = false; + } catch (Exception e) { + failed = true; + } + Assert.assertEquals(failed, shouldFail); + } + } } From a983693cdd8fbfb57e4c90dd433e7f5e83ed4d14 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Sat, 9 May 2020 15:11:32 -0400 Subject: [PATCH 020/273] settings for jitpack --- jitpack.yml | 2 +- settings.gradle | 3 +-- settings.jitpack.gradle | 24 ++++++++++++++++++++++++ 3 files changed, 26 insertions(+), 3 deletions(-) create mode 100644 settings.jitpack.gradle diff --git a/jitpack.yml b/jitpack.yml index 46aaa280..ed646932 100644 --- a/jitpack.yml +++ b/jitpack.yml @@ -1,2 +1,2 @@ install: - - ./gradlew clean build publishToMavenLocal -x test -x verifyGoogleJavaFormat \ No newline at end of file + - ./gradlew clean build publishToMavenLocal -x test -x verifyGoogleJavaFormat --settings-file settings.jitpack.gradle \ No newline at end of file diff --git a/settings.gradle b/settings.gradle index 6ae40a2d..7300d08f 100644 --- a/settings.gradle +++ b/settings.gradle @@ -7,13 +7,12 @@ rootProject.name = 'rsocket-rpc-java' include 'rsocket-ipc-core' include 'rsocket-ipc-graphql' include 'rsocket-ipc-jackson' -/* include 'rsocket-ipc-protobuf' include 'rsocket-rpc-core' include 'rsocket-rpc-metrics-idl' include 'rsocket-rpc-protobuf' include 'rsocket-rpc-protobuf-idl' -*/ + gradleEnterprise { diff --git a/settings.jitpack.gradle b/settings.jitpack.gradle new file mode 100644 index 00000000..6ae40a2d --- /dev/null +++ b/settings.jitpack.gradle @@ -0,0 +1,24 @@ +plugins { + id 'com.gradle.enterprise' version '3.1' +} + +rootProject.name = 'rsocket-rpc-java' + +include 'rsocket-ipc-core' +include 'rsocket-ipc-graphql' +include 'rsocket-ipc-jackson' +/* +include 'rsocket-ipc-protobuf' +include 'rsocket-rpc-core' +include 'rsocket-rpc-metrics-idl' +include 'rsocket-rpc-protobuf' +include 'rsocket-rpc-protobuf-idl' +*/ + + +gradleEnterprise { + buildScan { + termsOfServiceUrl = 'https://gradle.com/terms-of-service' + termsOfServiceAgree = 'yes' + } +} \ No newline at end of file From 066b856b1bb2d7788ea2eadd1a903abfe7f53513 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Sat, 9 May 2020 18:29:48 -0400 Subject: [PATCH 021/273] url decoder update --- .../rsocket/ipc/decoders/MetadataWriter.java | 23 +-------- .../rsocket/ipc/encoders/MetadataReader.java | 24 +--------- .../io/rsocket/ipc/util/MetadataUtils.java | 47 +++++++++++++++++++ 3 files changed, 49 insertions(+), 45 deletions(-) diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java index d46496b7..b1583c4b 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java @@ -105,7 +105,7 @@ public void writeEntries(MimeType mimeType, Stream(e.getKey(), ""); }); write(mimeType, stream, s -> { - String query = encodeQueryString(s); + String query = MetadataUtils.encodeEntries(s); return Stream.of(MetadataUtils.byteBufFromString(query)); }); } @@ -129,25 +129,4 @@ public void write(MimeType mimeType, Stream valueStream, Function> entryStream) { - if (entryStream == null) - return ""; - entryStream = entryStream.filter(Objects::nonNull); - entryStream = entryStream.filter(e -> !MetadataUtils.isNullOrEmpty(e.getKey())); - entryStream = entryStream.map(e -> { - String value = e.getValue(); - if (value != null) - return e; - return new SimpleImmutableEntry<>(e.getKey(), ""); - }); - StringBuilder sb = new StringBuilder(); - entryStream.forEach(ent -> { - if (sb.length() > 0) - sb.append("&"); - sb.append(String.format("%s=%s", MetadataUtils.urlEncode(ent.getKey()), - MetadataUtils.urlEncode(ent.getValue()))); - }); - return sb.toString(); - } - } diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataReader.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataReader.java index a112c8fa..28bea678 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataReader.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataReader.java @@ -2,7 +2,6 @@ import java.util.AbstractMap.SimpleImmutableEntry; import java.util.ArrayList; -import java.util.Arrays; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; @@ -11,7 +10,6 @@ import java.util.Optional; import java.util.function.Function; import java.util.function.Predicate; -import java.util.stream.Collectors; import java.util.stream.Stream; import io.netty.buffer.ByteBuf; @@ -76,7 +74,7 @@ public Stream streamStringsNonEmpty(MimeType mimeType) { public Stream>> streamEntries(MimeType mimeType) { return stream(toTest -> Objects.equals(toTest, mimeType), bb -> { - return parseQueryString(MetadataUtils.byteBufToString(bb)); + return MetadataUtils.decodeEntries(MetadataUtils.byteBufToString(bb)); }); } @@ -116,24 +114,4 @@ public CompositeMetadata getCompositeMetadata() { return compositeMetadata; } - private static Stream>> parseQueryString(String query) { - if (MetadataUtils.isNullOrEmpty(query)) - return Stream.empty(); - while (query.startsWith("?")) - query = query.substring(1); - if (MetadataUtils.isNullOrEmpty(query)) - return Stream.empty(); - return Arrays.stream(query.split("&")).map(p -> splitQueryParameter(p)); - } - - private static Entry> splitQueryParameter(String parameter) { - List keyValue = Arrays.stream(parameter.split("=")).map(MetadataUtils::urlDecode).limit(2) - .collect(Collectors.toList()); - if (keyValue.size() == 2) { - return new SimpleImmutableEntry<>(keyValue.get(0), Optional.of(keyValue.get(1))); - } else { - return new SimpleImmutableEntry<>(keyValue.get(0), Optional.empty()); - } - } - } diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/MetadataUtils.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/MetadataUtils.java index d915841e..97e545ec 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/MetadataUtils.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/MetadataUtils.java @@ -5,10 +5,15 @@ import java.net.URLEncoder; import java.nio.charset.Charset; import java.nio.charset.StandardCharsets; +import java.util.AbstractMap.SimpleImmutableEntry; +import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.Objects; import java.util.Optional; import java.util.Spliterator; @@ -17,11 +22,13 @@ import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.atomic.AtomicReference; import java.util.function.Consumer; +import java.util.stream.Collectors; import java.util.stream.Stream; import java.util.stream.StreamSupport; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; +import io.rsocket.ipc.mimetype.MimeType; import io.rsocket.metadata.WellKnownMimeType; import reactor.core.Disposable; import reactor.core.Disposables; @@ -149,6 +156,46 @@ public static Optional parseWellKnownMimeType(String mimeType return Optional.ofNullable(result); } + public static String encodeEntries(Stream> entryStream) { + if (entryStream == null) + return ""; + entryStream = entryStream.filter(Objects::nonNull); + entryStream = entryStream.filter(e -> !MetadataUtils.isNullOrEmpty(e.getKey())); + entryStream = entryStream.map(e -> { + String value = e.getValue(); + if (value != null) + return e; + return new SimpleImmutableEntry<>(e.getKey(), ""); + }); + StringBuilder sb = new StringBuilder(); + entryStream.forEach(ent -> { + if (sb.length() > 0) + sb.append("&"); + sb.append(String.format("%s=%s", MetadataUtils.urlEncode(ent.getKey()), + MetadataUtils.urlEncode(ent.getValue()))); + }); + return sb.toString(); + } + + public static Stream>> decodeEntries(String value) { + if (MetadataUtils.isNullOrEmpty(value)) + return Stream.empty(); + while (value.startsWith("?")) + value = value.substring(1); + if (MetadataUtils.isNullOrEmpty(value)) + return Stream.empty(); + return Arrays.stream(value.split("&")).map(parameter -> { + List keyValue = Arrays.stream(parameter.split("=")).map(MetadataUtils::urlDecode).limit(2) + .collect(Collectors.toList()); + Entry> result; + if (keyValue.size() == 2) + result = new SimpleImmutableEntry<>(keyValue.get(0), Optional.of(keyValue.get(1))); + else + result = new SimpleImmutableEntry<>(keyValue.get(0), Optional.empty()); + return result; + }); + } + public static class DisposableAddList extends CopyOnWriteArrayList { private static final long serialVersionUID = 1L; From 65d81d799ed387ac1774902aa6f052526e75e011 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 01:10:40 -0400 Subject: [PATCH 022/273] ipcutils --- .../ipc/decoders/MetadataDecoderLFP.java | 2 +- .../rsocket/ipc/decoders/MetadataWriter.java | 14 ++++---- .../ipc/encoders/MetadataEncoderLFP.java | 6 ++-- .../rsocket/ipc/encoders/MetadataReader.java | 31 ++++++++-------- .../io/rsocket/ipc/mimetype/MimeType.java | 8 ++--- .../{MetadataUtils.java => IPCUtils.java} | 22 +++++------- .../java/io/rsocket/ipc/IntegrationTest.java | 36 ++++++++++++++++--- 7 files changed, 71 insertions(+), 48 deletions(-) rename rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/{MetadataUtils.java => IPCUtils.java} (91%) diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java index 1ebaa168..808be5f5 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java @@ -15,7 +15,7 @@ import io.rsocket.ipc.encoders.MetadataReader; import io.rsocket.ipc.mimetype.MimeTypes; import io.rsocket.ipc.tracing.Tracing; -import io.rsocket.ipc.util.MetadataUtils.DisposableAddList; +import io.rsocket.ipc.util.IPCUtils.DisposableAddList; import reactor.core.Disposable; public class MetadataDecoderLFP implements MetadataDecoder { diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java index b1583c4b..cfecf693 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java @@ -19,7 +19,7 @@ import io.netty.buffer.ByteBufAllocator; import io.netty.buffer.CompositeByteBuf; import io.rsocket.ipc.mimetype.MimeType; -import io.rsocket.ipc.util.MetadataUtils; +import io.rsocket.ipc.util.IPCUtils; import io.rsocket.metadata.CompositeMetadataFlyweight; import io.rsocket.metadata.WellKnownMimeType; @@ -53,7 +53,7 @@ public CompositeByteBuf getCompositeByteBuf() { public void writeString(MimeType mimeType, String... values) { write(mimeType, values == null ? Stream.empty() : Arrays.asList(values).stream(), - s -> s.map(MetadataUtils::byteBufFromString)); + s -> s.map(IPCUtils::byteBufFromString)); } public void writeEntries(MimeType mimeType, String... keyValueEntries) { @@ -87,26 +87,26 @@ public void writeEntries(MimeType mimeType, Map value = ent.getValue(); if (value == null) return Stream.empty(); - Stream> stream = MetadataUtils.stream(value.iterator()) + Stream> stream = IPCUtils.stream(value.iterator()) .map(v -> new SimpleImmutableEntry<>(ent.getKey(), v)); return stream; }); - writeEntries(mimeType, MetadataUtils.flatMap(streams)); + writeEntries(mimeType, IPCUtils.flatMap(streams)); } public void writeEntries(MimeType mimeType, Stream> stream) { if (stream == null) return; stream = stream.filter(Objects::nonNull); - stream = stream.filter(e -> MetadataUtils.nonEmpty(e.getKey())); + stream = stream.filter(e -> IPCUtils.nonEmpty(e.getKey())); stream = stream.map(e -> { if (e.getValue() != null) return e; return new SimpleImmutableEntry<>(e.getKey(), ""); }); write(mimeType, stream, s -> { - String query = MetadataUtils.encodeEntries(s); - return Stream.of(MetadataUtils.byteBufFromString(query)); + String query = IPCUtils.encodeEntries(s); + return Stream.of(IPCUtils.byteBufFromString(query)); }); } diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataEncoderLFP.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataEncoderLFP.java index 3cd2a3e6..64122b00 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataEncoderLFP.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataEncoderLFP.java @@ -16,8 +16,8 @@ import io.rsocket.ipc.MetadataEncoder; import io.rsocket.ipc.decoders.MetadataWriter; import io.rsocket.ipc.mimetype.MimeTypes; -import io.rsocket.ipc.util.MetadataUtils; -import io.rsocket.ipc.util.MetadataUtils.DisposableAddList; +import io.rsocket.ipc.util.IPCUtils; +import io.rsocket.ipc.util.IPCUtils.DisposableAddList; import reactor.core.Disposable; public class MetadataEncoderLFP implements MetadataEncoder { @@ -60,7 +60,7 @@ protected void writeMetadata(MetadataWriter metadataWriter, SpanContext spanCont private void writeRoutingInfo(MetadataWriter metadataWriter, String service, String... parts) { metadataWriter.writeString(MimeTypes.MIME_TYPE_SERVICE, service); Stream methodsStream = parts == null ? Stream.empty() - : Arrays.asList(parts).stream().filter(MetadataUtils::nonEmpty); + : Arrays.asList(parts).stream().filter(IPCUtils::nonEmpty); methodsStream.forEach(v -> { metadataWriter.writeString(MimeTypes.MIME_TYPE_METHOD, v); }); diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataReader.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataReader.java index 28bea678..0ef54539 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataReader.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/encoders/MetadataReader.java @@ -15,7 +15,7 @@ import io.netty.buffer.ByteBuf; import io.rsocket.ipc.mimetype.MimeType; import io.rsocket.ipc.mimetype.MimeTypes; -import io.rsocket.ipc.util.MetadataUtils; +import io.rsocket.ipc.util.IPCUtils; import io.rsocket.metadata.CompositeMetadata; public class MetadataReader { @@ -37,7 +37,7 @@ public boolean containsString(MimeType mimeType, String value) { public boolean containsStringSecure(MimeType mimeType, String value) { Objects.requireNonNull(mimeType); - MetadataUtils.requireNonEmpty(value); + IPCUtils.requireNonEmpty(value); return containsString(mimeType, value, false, 1); } @@ -45,7 +45,7 @@ public boolean containsString(MimeType mimeType, String value, boolean ignoreCas Stream stream = streamStrings(mimeType); if (maxCandidates != -1)// ex: limit password candidates stream = stream.limit(maxCandidates); - stream = stream.filter(v -> MetadataUtils.equals(v, value, ignoreCase)); + stream = stream.filter(v -> IPCUtils.equals(v, value, ignoreCase)); return stream.findFirst().isPresent(); } @@ -55,26 +55,26 @@ public boolean containsEntry(MimeType mimeType, String key, String value) { public boolean containsEntry(MimeType mimeType, String key, String value, boolean ignoreCase, int maxCandidates) { Stream>> stream = streamEntries(mimeType) - .filter(e -> MetadataUtils.equals(e.getKey(), key, ignoreCase)); + .filter(e -> IPCUtils.equals(e.getKey(), key, ignoreCase)); if (maxCandidates != -1)// ex: limit password candidates stream = stream.limit(maxCandidates); - stream = stream.filter(e -> MetadataUtils.equals(e.getValue().orElse(null), value, ignoreCase)); + stream = stream.filter(e -> IPCUtils.equals(e.getValue().orElse(null), value, ignoreCase)); return stream.findFirst().isPresent(); } public Stream streamStrings(MimeType mimeType) { - return stream(toTest -> Objects.equals(toTest, mimeType), bb -> { - return Stream.of(MetadataUtils.byteBufToString(bb)); + return stream(toTest -> Objects.equals(toTest, mimeType), e -> { + return Stream.of(IPCUtils.byteBufToString(e.getContent())); }); } public Stream streamStringsNonEmpty(MimeType mimeType) { - return streamStrings(mimeType).filter(v -> !MetadataUtils.isNullOrEmpty(v)); + return streamStrings(mimeType).filter(v -> !IPCUtils.isNullOrEmpty(v)); } public Stream>> streamEntries(MimeType mimeType) { - return stream(toTest -> Objects.equals(toTest, mimeType), bb -> { - return MetadataUtils.decodeEntries(MetadataUtils.byteBufToString(bb)); + return stream(toTest -> Objects.equals(toTest, mimeType), e -> { + return IPCUtils.decodeEntries(IPCUtils.byteBufToString(e.getContent())); }); } @@ -88,7 +88,7 @@ public Map>> getEntries(MimeType mimeType) { public Stream> streamEntriesNonEmpty(MimeType mimeType) { return streamEntries(mimeType).filter(e -> e.getValue().isPresent()) .map(e -> new SimpleImmutableEntry<>(e.getKey(), e.getValue().get())) - .filter(e -> !MetadataUtils.isNullOrEmpty(e.getValue())).map(v -> v); + .filter(e -> !IPCUtils.isNullOrEmpty(e.getValue())).map(v -> v); } public Map> getEntriesNonEmpty(MimeType mimeType) { @@ -98,16 +98,17 @@ public Map> getEntriesNonEmpty(MimeType mimeType) { return map; } - public Stream stream(Predicate mimeTypePredicate, Function> decoder) { + public Stream stream(Predicate mimeTypePredicate, + Function> decoder) { Objects.requireNonNull(mimeTypePredicate); Objects.requireNonNull(decoder); Stream> streams = this.getCompositeMetadata().stream().filter(e -> { - if (MetadataUtils.isNullOrEmpty(e.getMimeType())) + if (IPCUtils.isNullOrEmpty(e.getMimeType())) return false; MimeType mimteType = MimeTypes.create(e.getMimeType()); return mimeTypePredicate.test(mimteType); - }).map(e -> e.getContent()).map(decoder); - return MetadataUtils.flatMap(streams); + }).map(decoder); + return IPCUtils.flatMap(streams); } public CompositeMetadata getCompositeMetadata() { diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/mimetype/MimeType.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/mimetype/MimeType.java index 06238bb2..b3ae2070 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/mimetype/MimeType.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/mimetype/MimeType.java @@ -4,7 +4,7 @@ import java.util.Optional; import java.util.function.Supplier; -import io.rsocket.ipc.util.MetadataUtils; +import io.rsocket.ipc.util.IPCUtils; import io.rsocket.metadata.WellKnownMimeType; public interface MimeType { @@ -25,7 +25,7 @@ public Impl(WellKnownMimeType wellKnownMimeType) { } public Impl(String mimeType) { - MetadataUtils.requireNonEmpty(mimeType); + IPCUtils.requireNonEmpty(mimeType); this.wellKnownMimeTypeSupplier = new Supplier() { private Optional parsed; @@ -35,7 +35,7 @@ public WellKnownMimeType get() { if (parsed == null) synchronized (this) { if (parsed == null) - parsed = MetadataUtils.parseWellKnownMimeType(mimeType); + parsed = IPCUtils.parseWellKnownMimeType(mimeType); } return parsed.orElse(null); } @@ -49,7 +49,7 @@ public String getString() { if (wkmtOp.isPresent()) return wkmtOp.get().getString(); // shouldn't happen, but maybe some weird overriding - return MetadataUtils.requireNonEmpty(mimeTypeFallback); + return IPCUtils.requireNonEmpty(mimeTypeFallback); } @Override diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/MetadataUtils.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java similarity index 91% rename from rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/MetadataUtils.java rename to rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java index 97e545ec..00d02dbb 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/MetadataUtils.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java @@ -6,11 +6,9 @@ import java.nio.charset.Charset; import java.nio.charset.StandardCharsets; import java.util.AbstractMap.SimpleImmutableEntry; -import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.Iterator; -import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; @@ -28,12 +26,11 @@ import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; -import io.rsocket.ipc.mimetype.MimeType; import io.rsocket.metadata.WellKnownMimeType; import reactor.core.Disposable; import reactor.core.Disposables; -public class MetadataUtils { +public class IPCUtils { public static final Charset CHARSET = StandardCharsets.UTF_8; public static Stream stream(Iterator iterator) { @@ -94,7 +91,7 @@ public static boolean equals(String value1, String value2, boolean ignoreCase) { public static String urlDecode(String str) { try { - return URLDecoder.decode(str, MetadataUtils.CHARSET.name()); + return URLDecoder.decode(str, IPCUtils.CHARSET.name()); } catch (UnsupportedEncodingException e) { throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) ? java.lang.RuntimeException.class.cast(e) @@ -104,7 +101,7 @@ public static String urlDecode(String str) { public static String urlEncode(String str) { try { - return URLEncoder.encode(str, MetadataUtils.CHARSET.name()); + return URLEncoder.encode(str, IPCUtils.CHARSET.name()); } catch (UnsupportedEncodingException e) { throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) ? java.lang.RuntimeException.class.cast(e) @@ -130,7 +127,7 @@ public static X requireNonEmpty(X charSequence) { private static final AtomicReference> WellKnownMimeType_FROM_STRING_CACHE_REF = new AtomicReference<>(); public static Optional parseWellKnownMimeType(String mimeType) { - if (MetadataUtils.isNullOrEmpty(mimeType)) + if (IPCUtils.isNullOrEmpty(mimeType)) return Optional.empty(); if (WellKnownMimeType_FROM_STRING_CACHE_REF.get() == null) synchronized (WellKnownMimeType_FROM_STRING_CACHE_REF) { @@ -160,7 +157,7 @@ public static String encodeEntries(Stream> entry if (entryStream == null) return ""; entryStream = entryStream.filter(Objects::nonNull); - entryStream = entryStream.filter(e -> !MetadataUtils.isNullOrEmpty(e.getKey())); + entryStream = entryStream.filter(e -> !IPCUtils.isNullOrEmpty(e.getKey())); entryStream = entryStream.map(e -> { String value = e.getValue(); if (value != null) @@ -171,21 +168,20 @@ public static String encodeEntries(Stream> entry entryStream.forEach(ent -> { if (sb.length() > 0) sb.append("&"); - sb.append(String.format("%s=%s", MetadataUtils.urlEncode(ent.getKey()), - MetadataUtils.urlEncode(ent.getValue()))); + sb.append(String.format("%s=%s", IPCUtils.urlEncode(ent.getKey()), IPCUtils.urlEncode(ent.getValue()))); }); return sb.toString(); } public static Stream>> decodeEntries(String value) { - if (MetadataUtils.isNullOrEmpty(value)) + if (IPCUtils.isNullOrEmpty(value)) return Stream.empty(); while (value.startsWith("?")) value = value.substring(1); - if (MetadataUtils.isNullOrEmpty(value)) + if (IPCUtils.isNullOrEmpty(value)) return Stream.empty(); return Arrays.stream(value.split("&")).map(parameter -> { - List keyValue = Arrays.stream(parameter.split("=")).map(MetadataUtils::urlDecode).limit(2) + List keyValue = Arrays.stream(parameter.split("=")).map(IPCUtils::urlDecode).limit(2) .collect(Collectors.toList()); Entry> result; if (keyValue.size() == 2) diff --git a/rsocket-ipc-core/src/test/java/io/rsocket/ipc/IntegrationTest.java b/rsocket-ipc-core/src/test/java/io/rsocket/ipc/IntegrationTest.java index e20a84d1..4ca5bcec 100644 --- a/rsocket-ipc-core/src/test/java/io/rsocket/ipc/IntegrationTest.java +++ b/rsocket-ipc-core/src/test/java/io/rsocket/ipc/IntegrationTest.java @@ -25,6 +25,7 @@ import io.rsocket.ipc.decoders.MetadataDecoderLFP; import io.rsocket.ipc.encoders.DefaultMetadataEncoder; import io.rsocket.ipc.encoders.MetadataEncoderLFP; +import io.rsocket.ipc.encoders.MetadataReader; import io.rsocket.ipc.marshallers.Primitives; import io.rsocket.ipc.marshallers.Strings; import io.rsocket.ipc.mimetype.MimeTypes; @@ -33,8 +34,11 @@ import io.rsocket.transport.netty.client.TcpClientTransport; import io.rsocket.transport.netty.server.TcpServerTransport; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; import java.util.concurrent.atomic.AtomicBoolean; import java.util.logging.Level; +import java.util.stream.Stream; import org.junit.Assert; import org.junit.Test; @@ -48,6 +52,7 @@ public class IntegrationTest { @Test public void test() { MetadataDecoderLFP decoder = new MetadataDecoderLFP(); + MetadataEncoderLFP encoder = new MetadataEncoderLFP(); RequestHandlingRSocket requestHandler = new RequestHandlingRSocket(decoder); {// start server SocketAcceptor socketAcceptor = (setup, client) -> Mono.just(requestHandler); @@ -56,7 +61,6 @@ public void test() { java.util.logging.Logger.getLogger("[server]").log(Level.SEVERE, "uncaught error", t); }).bind(TcpServerTransport.create("localhost", 7000)).block(); } - MetadataEncoderLFP encoder = new MetadataEncoderLFP(); RSocket rsocket; {// start client rsocket = RSocketConnector.create().connect(TcpClientTransport.create("localhost", 7000)).block(); @@ -64,8 +68,16 @@ public void test() { AtomicBoolean ff = new AtomicBoolean(); IPCRSocket service = Server.service("HelloService").noMeterRegistry().noTracer().marshall(Strings.marshaller()) - .unmarshall(Strings.unmarshaller()).requestResponse("hello", (s, byteBuf) -> Mono.just("Hello -> " + s)) - .requestResponse("goodbye", (s, byteBuf) -> Mono.just("Goodbye -> " + s)) + .unmarshall(Strings.unmarshaller()).requestResponse("hello", (s, byteBuf) -> { + MetadataReader reader = new MetadataReader(byteBuf, false); + Stream vals = reader.stream(v -> true, e -> Arrays.asList( + String.format("%s - %s", e.getMimeType(), e.getContent().toString(StandardCharsets.UTF_8))) + .stream()); + vals.forEach(v -> { + System.out.println(v); + }); + return Mono.just("Hello -> " + s); + }).requestResponse("goodbye", (s, byteBuf) -> Mono.just("Goodbye -> " + s)) .requestResponse("count", Primitives.intMarshaller(), (charSequence, byteBuf) -> Mono.just(charSequence.length())) .requestResponse("increment", Primitives.intUnmarshaller(), Primitives.intMarshaller(), @@ -81,8 +93,8 @@ public void test() { requestHandler.withEndpoint(service); Client helloService = Client.service("HelloService").rsocket(rsocket) - .customMetadataEncoder(new DefaultMetadataEncoder(ByteBufAllocator.DEFAULT)).noMeterRegistry() - .noTracer().marshall(Strings.marshaller()).unmarshall(Strings.unmarshaller()); + .customMetadataEncoder(encoder).noMeterRegistry().noTracer().marshall(Strings.marshaller()) + .unmarshall(Strings.unmarshaller()); String r1 = helloService.requestResponse("hello").apply("Alice").block(); Assert.assertEquals("Hello -> Alice", r1); @@ -94,6 +106,16 @@ public void test() { .expectComplete().verify(); helloService.fireAndForget("ff").apply("boom").block(); + int maxSeconds = 10; + for (int i = 0; i < maxSeconds && !ff.get(); i++) { + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + } Assert.assertTrue(ff.get()); String r3 = helloService.requestChannel("helloChannel").apply(Mono.just("Eve")).blockLast(); @@ -142,4 +164,8 @@ public void test() { Assert.assertEquals(failed, shouldFail); } } + + public static void main(String[] args) { + new IntegrationTest().test(); + } } From e2684ae4762e73fb50c60fab0b33a262685eae7b Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 01:59:15 -0400 Subject: [PATCH 023/273] adding reflection --- rsocket-ipc-gson/bin/.gitignore | 1 + rsocket-ipc-gson/build.gradle | 24 ++++++ .../ipc/marshallers/GsonMarshaller.java | 47 +++++++++++ .../ipc/marshallers/GsonUnmarshaller.java | 77 +++++++++++++++++++ rsocket-ipc-protobuf/bin/.gitignore | 1 + rsocket-ipc-reflection-client/bin/.gitignore | 1 + rsocket-ipc-reflection-client/build.gradle | 25 ++++++ .../ipc/marshallers/GsonMarshaller.java | 47 +++++++++++ .../ipc/marshallers/GsonUnmarshaller.java | 77 +++++++++++++++++++ rsocket-ipc-reflection/bin/.gitignore | 1 + rsocket-ipc-reflection/build.gradle | 24 ++++++ .../ipc/marshallers/GsonMarshaller.java | 47 +++++++++++ .../ipc/marshallers/GsonUnmarshaller.java | 77 +++++++++++++++++++ rsocket-rpc-core/bin/.gitignore | 2 + settings.gradle | 3 + settings.jitpack.gradle | 4 +- 16 files changed, 457 insertions(+), 1 deletion(-) create mode 100644 rsocket-ipc-gson/bin/.gitignore create mode 100644 rsocket-ipc-gson/build.gradle create mode 100644 rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java create mode 100644 rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java create mode 100644 rsocket-ipc-protobuf/bin/.gitignore create mode 100644 rsocket-ipc-reflection-client/bin/.gitignore create mode 100644 rsocket-ipc-reflection-client/build.gradle create mode 100644 rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java create mode 100644 rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java create mode 100644 rsocket-ipc-reflection/bin/.gitignore create mode 100644 rsocket-ipc-reflection/build.gradle create mode 100644 rsocket-ipc-reflection/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java create mode 100644 rsocket-ipc-reflection/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java create mode 100644 rsocket-rpc-core/bin/.gitignore diff --git a/rsocket-ipc-gson/bin/.gitignore b/rsocket-ipc-gson/bin/.gitignore new file mode 100644 index 00000000..ddf9c656 --- /dev/null +++ b/rsocket-ipc-gson/bin/.gitignore @@ -0,0 +1 @@ +/main/ diff --git a/rsocket-ipc-gson/build.gradle b/rsocket-ipc-gson/build.gradle new file mode 100644 index 00000000..da6814ef --- /dev/null +++ b/rsocket-ipc-gson/build.gradle @@ -0,0 +1,24 @@ +description = 'RSocket IPC Gson Support' + +dependencies { + api project (':rsocket-ipc-core') + + implementation 'com.google.code.gson:gson:2.8.6' + + testImplementation 'io.opentracing.brave:brave-opentracing' + testImplementation 'junit:junit' + testImplementation 'org.junit.jupiter:junit-jupiter-engine' + testImplementation 'org.junit.vintage:junit-vintage-engine' + + testImplementation 'javax.inject:javax.inject' + testImplementation 'io.projectreactor:reactor-test' + testImplementation 'com.google.protobuf:protobuf-java' + testImplementation 'org.hdrhistogram:HdrHistogram' + testImplementation 'org.apache.logging.log4j:log4j-api' + testImplementation 'org.apache.logging.log4j:log4j-core' + testImplementation 'org.apache.logging.log4j:log4j-slf4j-impl' + testImplementation 'io.rsocket:rsocket-transport-netty' + testImplementation 'io.rsocket:rsocket-transport-local' + testImplementation 'org.mockito:mockito-core' + testImplementation 'io.zipkin.reporter2:zipkin-sender-okhttp3' +} \ No newline at end of file diff --git a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java new file mode 100644 index 00000000..5501040e --- /dev/null +++ b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java @@ -0,0 +1,47 @@ +package io.rsocket.ipc.marshallers; + +import java.io.IOException; +import java.io.OutputStreamWriter; +import java.util.Objects; + +import com.google.gson.Gson; + +import io.netty.buffer.ByteBuf; +import io.netty.buffer.ByteBufAllocator; +import io.netty.buffer.ByteBufOutputStream; +import io.rsocket.ipc.Marshaller; + +public class GsonMarshaller implements Marshaller { + + private Gson gson; + private ByteBufAllocator allocator; + + public GsonMarshaller(Gson gson) { + this(gson, ByteBufAllocator.DEFAULT); + } + + public GsonMarshaller(Gson gson, ByteBufAllocator allocator) { + this.gson = Objects.requireNonNull(gson); + this.allocator = Objects.requireNonNull(allocator); + } + + @Override + public ByteBuf apply(Object object) { + ByteBuf buffer = allocator.buffer(); + try (ByteBufOutputStream os = new ByteBufOutputStream(buffer); + OutputStreamWriter writer = new OutputStreamWriter(os);) { + gson.toJson(object, writer); + writer.flush(); + } catch (IOException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + return buffer; + } + + public Gson getGson() { + return gson; + } + +} diff --git a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java new file mode 100644 index 00000000..292c3177 --- /dev/null +++ b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java @@ -0,0 +1,77 @@ +package io.rsocket.ipc.marshallers; + +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.lang.reflect.Type; +import java.util.Objects; + +import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.reflect.TypeToken; + +import io.netty.buffer.ByteBuf; +import io.netty.buffer.ByteBufInputStream; +import io.rsocket.ipc.Unmarshaller; + +public class GsonUnmarshaller implements Unmarshaller { + + public static Object[] apply(Gson gson, Type[] types, boolean releaseOnParse, ByteBuf byteBuf) { + Objects.requireNonNull(types); + if (types.length == 0) + throw new IllegalArgumentException("unmarshall types are required"); + if (types.length == 1 && !isArray(types[0])) + return new Object[] { new GsonUnmarshaller<>(gson, types[0], releaseOnParse).apply(byteBuf) }; + JsonArray jarr = new GsonUnmarshaller<>(gson, JsonArray.class, releaseOnParse).apply(byteBuf); + Object[] result = new Object[jarr.size()]; + for (int i = 0; i < jarr.size(); i++) { + Type type = types == null || types.length <= i ? null : types[i]; + if (type == null) + type = Object.class; + result[i] = gson.fromJson(jarr.get(i), type); + } + return result; + + }; + + private Gson gson; + private Type type; + private boolean releaseOnParse; + + public GsonUnmarshaller(Gson gson, Class classType, boolean releaseOnParse) { + this(gson, (Type) classType, releaseOnParse); + } + + public GsonUnmarshaller(Gson gson, TypeToken typeToken, boolean releaseOnParse) { + this(gson, typeToken == null ? null : typeToken.getType(), releaseOnParse); + } + + protected GsonUnmarshaller(Gson gson, Type type, boolean releaseOnParse) { + this.gson = Objects.requireNonNull(gson); + this.type = Objects.requireNonNull(type); + this.releaseOnParse = releaseOnParse; + } + + @Override + public X apply(ByteBuf byteBuf) { + try (InputStream is = new ByteBufInputStream(byteBuf, releaseOnParse); + InputStreamReader reader = new InputStreamReader(is);) { + return gson.fromJson(reader, type); + } catch (IOException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + } + + public Gson getGson() { + return gson; + } + + private static boolean isArray(Type type) { + if (!(type instanceof Class)) + return false; + boolean result = ((Class) type).isArray(); + return result; + } +} diff --git a/rsocket-ipc-protobuf/bin/.gitignore b/rsocket-ipc-protobuf/bin/.gitignore new file mode 100644 index 00000000..ddf9c656 --- /dev/null +++ b/rsocket-ipc-protobuf/bin/.gitignore @@ -0,0 +1 @@ +/main/ diff --git a/rsocket-ipc-reflection-client/bin/.gitignore b/rsocket-ipc-reflection-client/bin/.gitignore new file mode 100644 index 00000000..ddf9c656 --- /dev/null +++ b/rsocket-ipc-reflection-client/bin/.gitignore @@ -0,0 +1 @@ +/main/ diff --git a/rsocket-ipc-reflection-client/build.gradle b/rsocket-ipc-reflection-client/build.gradle new file mode 100644 index 00000000..d70fbd64 --- /dev/null +++ b/rsocket-ipc-reflection-client/build.gradle @@ -0,0 +1,25 @@ +description = 'RSocket IPC Reflection Mapping Client Support' + +dependencies { + api project (':rsocket-ipc-core') + + implementation ':rsocket-ipc-reflection' + implementation 'org.javassist:javassist:3.27.0-GA' + + testImplementation 'io.opentracing.brave:brave-opentracing' + testImplementation 'junit:junit' + testImplementation 'org.junit.jupiter:junit-jupiter-engine' + testImplementation 'org.junit.vintage:junit-vintage-engine' + + testImplementation 'javax.inject:javax.inject' + testImplementation 'io.projectreactor:reactor-test' + testImplementation 'com.google.protobuf:protobuf-java' + testImplementation 'org.hdrhistogram:HdrHistogram' + testImplementation 'org.apache.logging.log4j:log4j-api' + testImplementation 'org.apache.logging.log4j:log4j-core' + testImplementation 'org.apache.logging.log4j:log4j-slf4j-impl' + testImplementation 'io.rsocket:rsocket-transport-netty' + testImplementation 'io.rsocket:rsocket-transport-local' + testImplementation 'org.mockito:mockito-core' + testImplementation 'io.zipkin.reporter2:zipkin-sender-okhttp3' +} \ No newline at end of file diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java new file mode 100644 index 00000000..5501040e --- /dev/null +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java @@ -0,0 +1,47 @@ +package io.rsocket.ipc.marshallers; + +import java.io.IOException; +import java.io.OutputStreamWriter; +import java.util.Objects; + +import com.google.gson.Gson; + +import io.netty.buffer.ByteBuf; +import io.netty.buffer.ByteBufAllocator; +import io.netty.buffer.ByteBufOutputStream; +import io.rsocket.ipc.Marshaller; + +public class GsonMarshaller implements Marshaller { + + private Gson gson; + private ByteBufAllocator allocator; + + public GsonMarshaller(Gson gson) { + this(gson, ByteBufAllocator.DEFAULT); + } + + public GsonMarshaller(Gson gson, ByteBufAllocator allocator) { + this.gson = Objects.requireNonNull(gson); + this.allocator = Objects.requireNonNull(allocator); + } + + @Override + public ByteBuf apply(Object object) { + ByteBuf buffer = allocator.buffer(); + try (ByteBufOutputStream os = new ByteBufOutputStream(buffer); + OutputStreamWriter writer = new OutputStreamWriter(os);) { + gson.toJson(object, writer); + writer.flush(); + } catch (IOException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + return buffer; + } + + public Gson getGson() { + return gson; + } + +} diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java new file mode 100644 index 00000000..292c3177 --- /dev/null +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java @@ -0,0 +1,77 @@ +package io.rsocket.ipc.marshallers; + +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.lang.reflect.Type; +import java.util.Objects; + +import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.reflect.TypeToken; + +import io.netty.buffer.ByteBuf; +import io.netty.buffer.ByteBufInputStream; +import io.rsocket.ipc.Unmarshaller; + +public class GsonUnmarshaller implements Unmarshaller { + + public static Object[] apply(Gson gson, Type[] types, boolean releaseOnParse, ByteBuf byteBuf) { + Objects.requireNonNull(types); + if (types.length == 0) + throw new IllegalArgumentException("unmarshall types are required"); + if (types.length == 1 && !isArray(types[0])) + return new Object[] { new GsonUnmarshaller<>(gson, types[0], releaseOnParse).apply(byteBuf) }; + JsonArray jarr = new GsonUnmarshaller<>(gson, JsonArray.class, releaseOnParse).apply(byteBuf); + Object[] result = new Object[jarr.size()]; + for (int i = 0; i < jarr.size(); i++) { + Type type = types == null || types.length <= i ? null : types[i]; + if (type == null) + type = Object.class; + result[i] = gson.fromJson(jarr.get(i), type); + } + return result; + + }; + + private Gson gson; + private Type type; + private boolean releaseOnParse; + + public GsonUnmarshaller(Gson gson, Class classType, boolean releaseOnParse) { + this(gson, (Type) classType, releaseOnParse); + } + + public GsonUnmarshaller(Gson gson, TypeToken typeToken, boolean releaseOnParse) { + this(gson, typeToken == null ? null : typeToken.getType(), releaseOnParse); + } + + protected GsonUnmarshaller(Gson gson, Type type, boolean releaseOnParse) { + this.gson = Objects.requireNonNull(gson); + this.type = Objects.requireNonNull(type); + this.releaseOnParse = releaseOnParse; + } + + @Override + public X apply(ByteBuf byteBuf) { + try (InputStream is = new ByteBufInputStream(byteBuf, releaseOnParse); + InputStreamReader reader = new InputStreamReader(is);) { + return gson.fromJson(reader, type); + } catch (IOException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + } + + public Gson getGson() { + return gson; + } + + private static boolean isArray(Type type) { + if (!(type instanceof Class)) + return false; + boolean result = ((Class) type).isArray(); + return result; + } +} diff --git a/rsocket-ipc-reflection/bin/.gitignore b/rsocket-ipc-reflection/bin/.gitignore new file mode 100644 index 00000000..ddf9c656 --- /dev/null +++ b/rsocket-ipc-reflection/bin/.gitignore @@ -0,0 +1 @@ +/main/ diff --git a/rsocket-ipc-reflection/build.gradle b/rsocket-ipc-reflection/build.gradle new file mode 100644 index 00000000..d05c5fea --- /dev/null +++ b/rsocket-ipc-reflection/build.gradle @@ -0,0 +1,24 @@ +description = 'RSocket IPC Reflection Mapping Support' + +dependencies { + api project (':rsocket-ipc-core') + + implementation 'net.oneandone.reflections8:reflections8:0.11.7' + + testImplementation 'io.opentracing.brave:brave-opentracing' + testImplementation 'junit:junit' + testImplementation 'org.junit.jupiter:junit-jupiter-engine' + testImplementation 'org.junit.vintage:junit-vintage-engine' + + testImplementation 'javax.inject:javax.inject' + testImplementation 'io.projectreactor:reactor-test' + testImplementation 'com.google.protobuf:protobuf-java' + testImplementation 'org.hdrhistogram:HdrHistogram' + testImplementation 'org.apache.logging.log4j:log4j-api' + testImplementation 'org.apache.logging.log4j:log4j-core' + testImplementation 'org.apache.logging.log4j:log4j-slf4j-impl' + testImplementation 'io.rsocket:rsocket-transport-netty' + testImplementation 'io.rsocket:rsocket-transport-local' + testImplementation 'org.mockito:mockito-core' + testImplementation 'io.zipkin.reporter2:zipkin-sender-okhttp3' +} \ No newline at end of file diff --git a/rsocket-ipc-reflection/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java b/rsocket-ipc-reflection/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java new file mode 100644 index 00000000..5501040e --- /dev/null +++ b/rsocket-ipc-reflection/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java @@ -0,0 +1,47 @@ +package io.rsocket.ipc.marshallers; + +import java.io.IOException; +import java.io.OutputStreamWriter; +import java.util.Objects; + +import com.google.gson.Gson; + +import io.netty.buffer.ByteBuf; +import io.netty.buffer.ByteBufAllocator; +import io.netty.buffer.ByteBufOutputStream; +import io.rsocket.ipc.Marshaller; + +public class GsonMarshaller implements Marshaller { + + private Gson gson; + private ByteBufAllocator allocator; + + public GsonMarshaller(Gson gson) { + this(gson, ByteBufAllocator.DEFAULT); + } + + public GsonMarshaller(Gson gson, ByteBufAllocator allocator) { + this.gson = Objects.requireNonNull(gson); + this.allocator = Objects.requireNonNull(allocator); + } + + @Override + public ByteBuf apply(Object object) { + ByteBuf buffer = allocator.buffer(); + try (ByteBufOutputStream os = new ByteBufOutputStream(buffer); + OutputStreamWriter writer = new OutputStreamWriter(os);) { + gson.toJson(object, writer); + writer.flush(); + } catch (IOException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + return buffer; + } + + public Gson getGson() { + return gson; + } + +} diff --git a/rsocket-ipc-reflection/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-reflection/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java new file mode 100644 index 00000000..292c3177 --- /dev/null +++ b/rsocket-ipc-reflection/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java @@ -0,0 +1,77 @@ +package io.rsocket.ipc.marshallers; + +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.lang.reflect.Type; +import java.util.Objects; + +import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.reflect.TypeToken; + +import io.netty.buffer.ByteBuf; +import io.netty.buffer.ByteBufInputStream; +import io.rsocket.ipc.Unmarshaller; + +public class GsonUnmarshaller implements Unmarshaller { + + public static Object[] apply(Gson gson, Type[] types, boolean releaseOnParse, ByteBuf byteBuf) { + Objects.requireNonNull(types); + if (types.length == 0) + throw new IllegalArgumentException("unmarshall types are required"); + if (types.length == 1 && !isArray(types[0])) + return new Object[] { new GsonUnmarshaller<>(gson, types[0], releaseOnParse).apply(byteBuf) }; + JsonArray jarr = new GsonUnmarshaller<>(gson, JsonArray.class, releaseOnParse).apply(byteBuf); + Object[] result = new Object[jarr.size()]; + for (int i = 0; i < jarr.size(); i++) { + Type type = types == null || types.length <= i ? null : types[i]; + if (type == null) + type = Object.class; + result[i] = gson.fromJson(jarr.get(i), type); + } + return result; + + }; + + private Gson gson; + private Type type; + private boolean releaseOnParse; + + public GsonUnmarshaller(Gson gson, Class classType, boolean releaseOnParse) { + this(gson, (Type) classType, releaseOnParse); + } + + public GsonUnmarshaller(Gson gson, TypeToken typeToken, boolean releaseOnParse) { + this(gson, typeToken == null ? null : typeToken.getType(), releaseOnParse); + } + + protected GsonUnmarshaller(Gson gson, Type type, boolean releaseOnParse) { + this.gson = Objects.requireNonNull(gson); + this.type = Objects.requireNonNull(type); + this.releaseOnParse = releaseOnParse; + } + + @Override + public X apply(ByteBuf byteBuf) { + try (InputStream is = new ByteBufInputStream(byteBuf, releaseOnParse); + InputStreamReader reader = new InputStreamReader(is);) { + return gson.fromJson(reader, type); + } catch (IOException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + } + + public Gson getGson() { + return gson; + } + + private static boolean isArray(Type type) { + if (!(type instanceof Class)) + return false; + boolean result = ((Class) type).isArray(); + return result; + } +} diff --git a/rsocket-rpc-core/bin/.gitignore b/rsocket-rpc-core/bin/.gitignore new file mode 100644 index 00000000..7eed456b --- /dev/null +++ b/rsocket-rpc-core/bin/.gitignore @@ -0,0 +1,2 @@ +/main/ +/test/ diff --git a/settings.gradle b/settings.gradle index 7300d08f..a4ded94f 100644 --- a/settings.gradle +++ b/settings.gradle @@ -12,6 +12,9 @@ include 'rsocket-rpc-core' include 'rsocket-rpc-metrics-idl' include 'rsocket-rpc-protobuf' include 'rsocket-rpc-protobuf-idl' +include 'rsocket-ipc-gson' +include 'rsocket-ipc-reflection' +include 'rsocket-ipc-reflection-client' diff --git a/settings.jitpack.gradle b/settings.jitpack.gradle index 6ae40a2d..95844c57 100644 --- a/settings.jitpack.gradle +++ b/settings.jitpack.gradle @@ -14,7 +14,9 @@ include 'rsocket-rpc-metrics-idl' include 'rsocket-rpc-protobuf' include 'rsocket-rpc-protobuf-idl' */ - +include 'rsocket-ipc-gson' +include 'rsocket-ipc-reflection' +include 'rsocket-ipc-reflection-client' gradleEnterprise { buildScan { From e4fb594c28905a5d5fa650c3f717e8dfc5895600 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 02:28:48 -0400 Subject: [PATCH 024/273] update builds --- rsocket-ipc-reflection-client/build.gradle | 3 +- .../java/io/rsocket/ipc/marshallers/A.java | 7 + .../bin/.gitignore | 0 .../build.gradle | 0 .../ipc/reflection/MethodMapUtils.java | 176 ++++++++++++++++++ .../ipc/reflection/PublisherConverter.java | 165 ++++++++++++++++ .../ipc/reflection/PublisherConverters.java | 52 ++++++ rsocket-ipc-reflection-server/bin/.gitignore | 1 + rsocket-ipc-reflection-server/build.gradle | 22 +++ .../java/io/rsocket/ipc/marshallers/A.java | 7 + .../ipc/marshallers/GsonMarshaller.java | 0 .../ipc/marshallers/GsonUnmarshaller.java | 0 settings.gradle | 4 +- settings.jitpack.gradle | 3 +- 14 files changed, 435 insertions(+), 5 deletions(-) create mode 100644 rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/A.java rename {rsocket-ipc-reflection => rsocket-ipc-reflection-core}/bin/.gitignore (100%) rename {rsocket-ipc-reflection => rsocket-ipc-reflection-core}/build.gradle (100%) create mode 100644 rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/MethodMapUtils.java create mode 100644 rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/PublisherConverter.java create mode 100644 rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/PublisherConverters.java create mode 100644 rsocket-ipc-reflection-server/bin/.gitignore create mode 100644 rsocket-ipc-reflection-server/build.gradle create mode 100644 rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/A.java rename {rsocket-ipc-reflection => rsocket-ipc-reflection-server}/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java (100%) rename {rsocket-ipc-reflection => rsocket-ipc-reflection-server}/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java (100%) diff --git a/rsocket-ipc-reflection-client/build.gradle b/rsocket-ipc-reflection-client/build.gradle index d70fbd64..d7d09ac7 100644 --- a/rsocket-ipc-reflection-client/build.gradle +++ b/rsocket-ipc-reflection-client/build.gradle @@ -1,9 +1,8 @@ description = 'RSocket IPC Reflection Mapping Client Support' dependencies { - api project (':rsocket-ipc-core') + api project (':rsocket-ipc-reflection-core') - implementation ':rsocket-ipc-reflection' implementation 'org.javassist:javassist:3.27.0-GA' testImplementation 'io.opentracing.brave:brave-opentracing' diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/A.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/A.java new file mode 100644 index 00000000..76538d3d --- /dev/null +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/A.java @@ -0,0 +1,7 @@ +package io.rsocket.ipc.marshallers; + +public class A { + public static void main(String[] args) { + MethodMapUtils all = MethodMapUtils.class; + } +} diff --git a/rsocket-ipc-reflection/bin/.gitignore b/rsocket-ipc-reflection-core/bin/.gitignore similarity index 100% rename from rsocket-ipc-reflection/bin/.gitignore rename to rsocket-ipc-reflection-core/bin/.gitignore diff --git a/rsocket-ipc-reflection/build.gradle b/rsocket-ipc-reflection-core/build.gradle similarity index 100% rename from rsocket-ipc-reflection/build.gradle rename to rsocket-ipc-reflection-core/build.gradle diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/MethodMapUtils.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/MethodMapUtils.java new file mode 100644 index 00000000..ab63cdc7 --- /dev/null +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/MethodMapUtils.java @@ -0,0 +1,176 @@ +package io.rsocket.ipc.reflection; + +import java.lang.reflect.Method; +import java.lang.reflect.Type; +import java.util.AbstractMap.SimpleImmutableEntry; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.function.Function; +import java.util.stream.Stream; + +import org.reflections8.ReflectionUtils; + +import io.rsocket.ipc.util.IPCUtils; +import javassist.Modifier; + +public class MethodMapUtils { + private static final Class THIS_CLASS = new Object() { + }.getClass().getEnclosingClass(); + private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(THIS_CLASS); + + private static final Map, Class> PRIMITIVES_TO_WRAPPERS = getPrimitivesToWrappers(); + + private static Map, Class> getPrimitivesToWrappers() { + Map, Class> map = new HashMap<>(); + map.put(boolean.class, Boolean.class); + map.put(byte.class, Byte.class); + map.put(char.class, Character.class); + map.put(double.class, Double.class); + map.put(float.class, Float.class); + map.put(int.class, Integer.class); + map.put(long.class, Long.class); + map.put(short.class, Short.class); + map.put(void.class, Void.class); + return Collections.unmodifiableMap(map); + } + + private static final Map, Class> WRAPPERS_TO_PRIMITIVES = getWrappersToPrimitives(); + + private static Map, Class> getWrappersToPrimitives() { + Map, Class> map = new HashMap<>(); + PRIMITIVES_TO_WRAPPERS.entrySet().forEach(e -> map.put(e.getValue(), e.getKey())); + return Collections.unmodifiableMap(map); + } + + @SuppressWarnings("unchecked") + public static Map getMappedMethods(Class classType, boolean includeVariations) { + Objects.requireNonNull(classType); + Map> lookup = new LinkedHashMap<>(); + { + Set methods = ReflectionUtils.getAllMethods(classType, m -> Modifier.isPublic(m.getModifiers()), + m -> !Modifier.isStatic(m.getModifiers())); + methods.stream().flatMap( + m -> getMethodSignatures(m, includeVariations).stream().map(v -> new SimpleImmutableEntry<>(v, m))) + .forEach(ent -> { + Method candidateMethod = ent.getValue(); + List methodList = lookup.computeIfAbsent(ent.getKey(), nil -> new ArrayList<>()); + for (int i = 0; i < methodList.size(); i++) { + Method currentMethod = methodList.get(i); + if (isOverridingMethod(currentMethod, candidateMethod)) { + methodList.set(i, candidateMethod); + return; + } + if (isOverridingMethod(candidateMethod, currentMethod)) + return; + } + methodList.add(candidateMethod); + }); + } + Map result = new LinkedHashMap<>(); + for (Entry> ent : lookup.entrySet()) { + String key = ent.getKey(); + List methods = ent.getValue(); + if (methods.size() > 1) { + logger.warn("multiple methods match signature, skipping:{}", key); + continue; + } + result.put(key, methods.get(0)); + } + return result; + } + + public static boolean compatibleMethods(Method method1, Method method2) { + return isOverridingMethod(method1, method2) || isOverridingMethod(method2, method1); + } + + private static boolean isOverridingMethod(Method parentCandidate, Method childCandidate) { + if (Objects.equals(parentCandidate, childCandidate)) + return true; + if (!parentCandidate.getName().equals(childCandidate.getName())) + return false; + if (parentCandidate.getParameterCount() != childCandidate.getParameterCount()) + return false; + if (!parentCandidate.getDeclaringClass().isAssignableFrom(childCandidate.getDeclaringClass())) + return false; + Function restrictionLevel = m -> { + int modifiers = m.getModifiers(); + if (Modifier.isPrivate(modifiers)) + return 0; + if (Modifier.isProtected(modifiers)) + return 2; + if (Modifier.isPublic(modifiers)) + return 3; + return 1;// package level + }; + if (restrictionLevel.apply(childCandidate) < restrictionLevel.apply(parentCandidate)) + return false; + Class[] parentPts = parentCandidate.getParameterTypes(); + Class[] childPts = childCandidate.getParameterTypes(); + for (int i = 0; i < parentPts.length; i++) { + Class parentPt = parentPts[i]; + Class childPt = childPts[i]; + if (!parentPt.isAssignableFrom(childPt)) + return false; + } + return true; + } + + private static Set getMethodSignatures(Method method, boolean includeVariations) { + Set methodSignatures = new LinkedHashSet<>(); + if (includeVariations) + methodSignatures.add(method.getName()); + Class[] parameterTypes = method.getParameterTypes(); + List options = includeVariations ? Arrays.asList(false, true) : Arrays.asList(false); + for (boolean lowercase : options) { + for (boolean simpleName : options) { + for (boolean disableParameterTypes : options) { + for (boolean unwrapPrimitives : options) { + Stream> stream = Stream.empty(); + stream = Stream.concat(stream, Stream.of(new SimpleImmutableEntry<>("n", method.getName()))); + if (!disableParameterTypes) { + for (Class pt : parameterTypes) { + if (unwrapPrimitives) { + Class primType = WRAPPERS_TO_PRIMITIVES.get(pt); + pt = primType != null ? primType : pt; + } + stream = Stream.concat(stream, Stream.of(new SimpleImmutableEntry<>("at", + simpleName ? pt.getSimpleName() : pt.getName()))); + } + } + if (lowercase) + stream = stream.map(e -> new SimpleImmutableEntry<>(e.getKey().toLowerCase(), + e.getValue().toLowerCase())); + methodSignatures.add(IPCUtils.encodeEntries(stream)); + } + } + } + } + return methodSignatures; + } + + public static Optional getRequestChannelParameterType(Method method) { + if (method.getParameterCount() != 1) + return Optional.empty(); + Optional> payloadConverter = PublisherConverters.lookup(method.getParameterTypes()[0]); + if (!payloadConverter.isPresent()) + return Optional.empty(); + if (!PublisherConverters.lookup(method.getReturnType()).isPresent()) + return Optional.empty(); + Type type = method.getGenericParameterTypes()[0]; + Optional typeArgument = payloadConverter.get().getTypeArgument(type); + if (!typeArgument.isPresent()) + return Optional.empty(); + return Optional.of(typeArgument.get()); + } + +} diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/PublisherConverter.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/PublisherConverter.java new file mode 100644 index 00000000..b8aae4fa --- /dev/null +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/PublisherConverter.java @@ -0,0 +1,165 @@ +package io.rsocket.ipc.reflection; + +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.util.Collections; +import java.util.Iterator; +import java.util.Optional; +import java.util.stream.Stream; + +import org.reactivestreams.Publisher; + +import io.rsocket.ipc.util.IPCUtils; +import reactor.core.publisher.Flux; + +@SuppressWarnings("unchecked") +public interface PublisherConverter { + + static PublisherConverter> direct() { + return new Abs>() { + + @Override + protected Publisher toPublisherInternal(Publisher input) { + return input; + } + + @Override + public Publisher fromPublisher(Publisher publisher) { + return publisher != null ? publisher : Flux.empty(); + } + + @Override + public Class> getConvertType() { + return (Class>) Publisher.class; + } + + public int priority() { + return 0; + } + }; + } + + static PublisherConverter> stream() { + return new Abs>() { + + @Override + protected Publisher toPublisherInternal(Stream input) { + return Flux.fromStream(input); + } + + @Override + public Stream fromPublisher(Publisher publisher) { + if (publisher == null) + return Stream.empty(); + return Flux.from(publisher).toStream(); + } + + @Override + public Class> getConvertType() { + return (Class>) Stream.class; + } + + public int priority() { + return 1; + } + }; + } + + static PublisherConverter> iterator() { + return new Abs>() { + + @Override + protected Publisher toPublisherInternal(Iterator input) { + return Flux.fromStream(IPCUtils.stream(input)); + } + + @Override + public Iterator fromPublisher(Publisher publisher) { + if (publisher == null) + return Collections.emptyIterator(); + return Flux.from(publisher).toStream().iterator(); + } + + @Override + public Class> getConvertType() { + return (Class>) Iterator.class; + } + + public int priority() { + return 2; + } + }; + } + + static PublisherConverter> iterable() { + return new Abs>() { + + @Override + protected Publisher toPublisherInternal(Iterable input) { + return Flux.fromStream(IPCUtils.stream(input.iterator())); + } + + @Override + public Iterable fromPublisher(Publisher publisher) { + if (publisher == null) + return Collections.emptyList(); + Flux cachedFlux = Flux.from(publisher).cache(); + Iterable ible = () -> { + Iterator iter = (Iterator) cachedFlux.toStream().iterator(); + return iter; + }; + return ible != null ? ible : Collections.emptyList(); + } + + @Override + public Class> getConvertType() { + return (Class>) Iterable.class; + } + + }; + } + + Publisher toPublisher(X input); + + X fromPublisher(Publisher publisher); + + Class getConvertType(); + + default int priority() { + return Integer.MAX_VALUE; + } + + default boolean appliesTo(Class classType) { + return getConvertType().isAssignableFrom(classType); + } + + default Optional getTypeArgument(Type type) { + if (type == null) + return Optional.empty(); + if (type instanceof ParameterizedType) { + ParameterizedType pt = (ParameterizedType) type; + Type[] actualTypeArguments = pt.getActualTypeArguments(); + if (actualTypeArguments != null && actualTypeArguments.length == 1) + return Optional.of(actualTypeArguments[0]); + } + if (!(type instanceof Class)) + return Optional.empty(); + Class superClass = ((Class) type).getSuperclass(); + if (superClass != null && !this.getConvertType().isAssignableFrom(superClass)) + return Optional.empty(); + return getTypeArgument(superClass); + } + + static abstract class Abs implements PublisherConverter { + + @Override + public Publisher toPublisher(X input) { + if (input == null) + return Flux.empty(); + return toPublisherInternal(input); + } + + protected abstract Publisher toPublisherInternal(X input); + + } +} diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/PublisherConverters.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/PublisherConverters.java new file mode 100644 index 00000000..19d1e7b6 --- /dev/null +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/PublisherConverters.java @@ -0,0 +1,52 @@ +package io.rsocket.ipc.reflection; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import org.reflections8.ReflectionUtils; + +public class PublisherConverters { + + private static final Map, List>> DEFAULT_CONVERTER_METHODS = new ConcurrentHashMap<>( + 1); + + public static Optional> lookup(Class classType) { + if (classType == null) + return Optional.empty(); + Stream> publisherConverterStream = DEFAULT_CONVERTER_METHODS + .computeIfAbsent(Optional.empty(), nil -> loadDefaultConverters()).stream(); + Optional> op = publisherConverterStream.filter(v -> v.appliesTo(classType)).findFirst() + .map(v -> v); + return op; + } + + @SuppressWarnings("unchecked") + private static List> loadDefaultConverters() { + Set methods = ReflectionUtils.getAllMethods(PublisherConverter.class, + m -> Modifier.isStatic(m.getModifiers()), m -> Modifier.isPublic(m.getModifiers()), + m -> m.getParameterCount() == 0, m -> PublisherConverter.class.isAssignableFrom(m.getReturnType())); + Stream> stream = methods.stream().map(v -> { + try { + return v.invoke(null); + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + }).map(v -> (PublisherConverter) v); + stream = stream.sorted(Comparator.comparing(v -> v.priority())); + return Collections.unmodifiableList(stream.collect(Collectors.toList())); + + } + +} diff --git a/rsocket-ipc-reflection-server/bin/.gitignore b/rsocket-ipc-reflection-server/bin/.gitignore new file mode 100644 index 00000000..ddf9c656 --- /dev/null +++ b/rsocket-ipc-reflection-server/bin/.gitignore @@ -0,0 +1 @@ +/main/ diff --git a/rsocket-ipc-reflection-server/build.gradle b/rsocket-ipc-reflection-server/build.gradle new file mode 100644 index 00000000..4f68cb04 --- /dev/null +++ b/rsocket-ipc-reflection-server/build.gradle @@ -0,0 +1,22 @@ +description = 'RSocket IPC Reflection Mapping Client Support' + +dependencies { + api project (':rsocket-ipc-reflection-core') + + testImplementation 'io.opentracing.brave:brave-opentracing' + testImplementation 'junit:junit' + testImplementation 'org.junit.jupiter:junit-jupiter-engine' + testImplementation 'org.junit.vintage:junit-vintage-engine' + + testImplementation 'javax.inject:javax.inject' + testImplementation 'io.projectreactor:reactor-test' + testImplementation 'com.google.protobuf:protobuf-java' + testImplementation 'org.hdrhistogram:HdrHistogram' + testImplementation 'org.apache.logging.log4j:log4j-api' + testImplementation 'org.apache.logging.log4j:log4j-core' + testImplementation 'org.apache.logging.log4j:log4j-slf4j-impl' + testImplementation 'io.rsocket:rsocket-transport-netty' + testImplementation 'io.rsocket:rsocket-transport-local' + testImplementation 'org.mockito:mockito-core' + testImplementation 'io.zipkin.reporter2:zipkin-sender-okhttp3' +} \ No newline at end of file diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/A.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/A.java new file mode 100644 index 00000000..76538d3d --- /dev/null +++ b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/A.java @@ -0,0 +1,7 @@ +package io.rsocket.ipc.marshallers; + +public class A { + public static void main(String[] args) { + MethodMapUtils all = MethodMapUtils.class; + } +} diff --git a/rsocket-ipc-reflection/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java similarity index 100% rename from rsocket-ipc-reflection/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java rename to rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java diff --git a/rsocket-ipc-reflection/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java similarity index 100% rename from rsocket-ipc-reflection/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java rename to rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java diff --git a/settings.gradle b/settings.gradle index a4ded94f..b93c65d3 100644 --- a/settings.gradle +++ b/settings.gradle @@ -13,9 +13,9 @@ include 'rsocket-rpc-metrics-idl' include 'rsocket-rpc-protobuf' include 'rsocket-rpc-protobuf-idl' include 'rsocket-ipc-gson' -include 'rsocket-ipc-reflection' +include 'rsocket-ipc-reflection-core' include 'rsocket-ipc-reflection-client' - +include 'rsocket-ipc-reflection-server' gradleEnterprise { diff --git a/settings.jitpack.gradle b/settings.jitpack.gradle index 95844c57..f4eaadfa 100644 --- a/settings.jitpack.gradle +++ b/settings.jitpack.gradle @@ -15,8 +15,9 @@ include 'rsocket-rpc-protobuf' include 'rsocket-rpc-protobuf-idl' */ include 'rsocket-ipc-gson' -include 'rsocket-ipc-reflection' +include 'rsocket-ipc-reflection-core' include 'rsocket-ipc-reflection-client' +include 'rsocket-ipc-reflection-server' gradleEnterprise { buildScan { From 6b50cafdaf9da665f0eca9f4fb5b50d302ca55b6 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 02:36:19 -0400 Subject: [PATCH 025/273] add subprojects --- .../java/io/rsocket/ipc/marshallers/A.java | 7 - .../ipc/marshallers/GsonMarshaller.java | 47 ----- .../ipc/marshallers/GsonUnmarshaller.java | 77 -------- .../reflection/client/RSocketIPCClients.java | 169 ++++++++++++++++++ .../reflection/{ => core}/MethodMapUtils.java | 2 +- .../{ => core}/PublisherConverter.java | 2 +- .../{ => core}/PublisherConverters.java | 2 +- .../java/io/rsocket/ipc/marshallers/A.java | 7 - .../ipc/marshallers/GsonMarshaller.java | 47 ----- .../ipc/marshallers/GsonUnmarshaller.java | 77 -------- .../RequestHandlingRSocketReflection.java | 151 ++++++++++++++++ 11 files changed, 323 insertions(+), 265 deletions(-) delete mode 100644 rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/A.java delete mode 100644 rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java delete mode 100644 rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java create mode 100644 rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java rename rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/{ => core}/MethodMapUtils.java (99%) rename rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/{ => core}/PublisherConverter.java (99%) rename rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/{ => core}/PublisherConverters.java (98%) delete mode 100644 rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/A.java delete mode 100644 rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java delete mode 100644 rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java create mode 100644 rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/A.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/A.java deleted file mode 100644 index 76538d3d..00000000 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/A.java +++ /dev/null @@ -1,7 +0,0 @@ -package io.rsocket.ipc.marshallers; - -public class A { - public static void main(String[] args) { - MethodMapUtils all = MethodMapUtils.class; - } -} diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java deleted file mode 100644 index 5501040e..00000000 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.rsocket.ipc.marshallers; - -import java.io.IOException; -import java.io.OutputStreamWriter; -import java.util.Objects; - -import com.google.gson.Gson; - -import io.netty.buffer.ByteBuf; -import io.netty.buffer.ByteBufAllocator; -import io.netty.buffer.ByteBufOutputStream; -import io.rsocket.ipc.Marshaller; - -public class GsonMarshaller implements Marshaller { - - private Gson gson; - private ByteBufAllocator allocator; - - public GsonMarshaller(Gson gson) { - this(gson, ByteBufAllocator.DEFAULT); - } - - public GsonMarshaller(Gson gson, ByteBufAllocator allocator) { - this.gson = Objects.requireNonNull(gson); - this.allocator = Objects.requireNonNull(allocator); - } - - @Override - public ByteBuf apply(Object object) { - ByteBuf buffer = allocator.buffer(); - try (ByteBufOutputStream os = new ByteBufOutputStream(buffer); - OutputStreamWriter writer = new OutputStreamWriter(os);) { - gson.toJson(object, writer); - writer.flush(); - } catch (IOException e) { - throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) - ? java.lang.RuntimeException.class.cast(e) - : new java.lang.RuntimeException(e); - } - return buffer; - } - - public Gson getGson() { - return gson; - } - -} diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java deleted file mode 100644 index 292c3177..00000000 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java +++ /dev/null @@ -1,77 +0,0 @@ -package io.rsocket.ipc.marshallers; - -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.lang.reflect.Type; -import java.util.Objects; - -import com.google.gson.Gson; -import com.google.gson.JsonArray; -import com.google.gson.reflect.TypeToken; - -import io.netty.buffer.ByteBuf; -import io.netty.buffer.ByteBufInputStream; -import io.rsocket.ipc.Unmarshaller; - -public class GsonUnmarshaller implements Unmarshaller { - - public static Object[] apply(Gson gson, Type[] types, boolean releaseOnParse, ByteBuf byteBuf) { - Objects.requireNonNull(types); - if (types.length == 0) - throw new IllegalArgumentException("unmarshall types are required"); - if (types.length == 1 && !isArray(types[0])) - return new Object[] { new GsonUnmarshaller<>(gson, types[0], releaseOnParse).apply(byteBuf) }; - JsonArray jarr = new GsonUnmarshaller<>(gson, JsonArray.class, releaseOnParse).apply(byteBuf); - Object[] result = new Object[jarr.size()]; - for (int i = 0; i < jarr.size(); i++) { - Type type = types == null || types.length <= i ? null : types[i]; - if (type == null) - type = Object.class; - result[i] = gson.fromJson(jarr.get(i), type); - } - return result; - - }; - - private Gson gson; - private Type type; - private boolean releaseOnParse; - - public GsonUnmarshaller(Gson gson, Class classType, boolean releaseOnParse) { - this(gson, (Type) classType, releaseOnParse); - } - - public GsonUnmarshaller(Gson gson, TypeToken typeToken, boolean releaseOnParse) { - this(gson, typeToken == null ? null : typeToken.getType(), releaseOnParse); - } - - protected GsonUnmarshaller(Gson gson, Type type, boolean releaseOnParse) { - this.gson = Objects.requireNonNull(gson); - this.type = Objects.requireNonNull(type); - this.releaseOnParse = releaseOnParse; - } - - @Override - public X apply(ByteBuf byteBuf) { - try (InputStream is = new ByteBufInputStream(byteBuf, releaseOnParse); - InputStreamReader reader = new InputStreamReader(is);) { - return gson.fromJson(reader, type); - } catch (IOException e) { - throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) - ? java.lang.RuntimeException.class.cast(e) - : new java.lang.RuntimeException(e); - } - } - - public Gson getGson() { - return gson; - } - - private static boolean isArray(Type type) { - if (!(type instanceof Class)) - return false; - boolean result = ((Class) type).isArray(); - return result; - } -} diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java new file mode 100644 index 00000000..8efb065c --- /dev/null +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java @@ -0,0 +1,169 @@ +package io.rsocket.ipc.reflection.client; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.lang.reflect.Type; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Objects; +import java.util.Optional; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.BiFunction; +import java.util.stream.Stream; + +import org.reactivestreams.Publisher; +import org.reflections8.ReflectionUtils; + +import io.netty.buffer.ByteBuf; +import io.rsocket.RSocket; +import io.rsocket.ipc.Client; +import io.rsocket.ipc.Marshaller; +import io.rsocket.ipc.encoders.MetadataEncoderLFP; +import io.rsocket.ipc.marshallers.Bytes; +import io.rsocket.ipc.reflection.core.MethodMapUtils; +import io.rsocket.ipc.reflection.core.PublisherConverter; +import io.rsocket.ipc.reflection.core.PublisherConverters; +import javassist.util.proxy.MethodHandler; +import javassist.util.proxy.ProxyFactory; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +public class RSocketIPCClients { + + public static X create(Mono rSocketMono, Class serviceType, Marshaller marshaller, + BiFunction returnDeserializer) { + try { + return createInternal(rSocketMono, serviceType, marshaller, returnDeserializer); + } catch (NoSuchMethodException | IllegalArgumentException | InstantiationException | IllegalAccessException + | InvocationTargetException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + } + + @SuppressWarnings("unchecked") + protected static X createInternal(Mono rSocketMono, Class serviceType, + Marshaller marshaller, BiFunction returnDeserializer) + throws NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, + InvocationTargetException { + Objects.requireNonNull(rSocketMono); + Objects.requireNonNull(serviceType); + Objects.requireNonNull(marshaller); + Objects.requireNonNull(returnDeserializer); + Map mappedMethods = MethodMapUtils.getMappedMethods(serviceType, false); + Map> methodHandlerCache = new ConcurrentHashMap<>(); + return (X) proxyFactory(serviceType).create(new Class[] {}, new Object[] {}, new MethodHandler() { + + @Override + public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable { + Optional mhOp = methodHandlerCache.computeIfAbsent(thisMethod, nil -> { + Entry entry = mappedMethods.entrySet().stream() + .filter(ent -> MethodMapUtils.compatibleMethods(thisMethod, ent.getValue())).findFirst() + .orElse(null); + if (entry == null) + return Optional.empty(); + return Optional.of(createMethodHandler(rSocketMono, serviceType, entry.getKey(), marshaller, + returnDeserializer, thisMethod)); + }); + if (!mhOp.isPresent()) + throw new NoSuchMethodException(String.format( + "could not map method in service. serviceType:%s method:%s", serviceType, thisMethod)); + return mhOp.get().invoke(self, thisMethod, proceed, args); + } + + }); + } + + private static MethodHandler createMethodHandler(Mono rSocketMono, Class serviceType, String route, + Marshaller marshaller, BiFunction returnDeserializer, Method method) { + return new MethodHandler() { + + @Override + public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable { + Client client = Client.service(serviceType.getName()).rsocket(rSocketMono.block()) + .customMetadataEncoder(new MetadataEncoderLFP()).noMeterRegistry().noTracer() + .marshall(marshaller).unmarshall(Bytes.byteBufUnmarshaller()); + return RSocketIPCClients.invoke(client, route, returnDeserializer, method, args); + } + }; + } + + @SuppressWarnings("unchecked") + private static Object invoke(Client client, String route, + BiFunction returnDeserializer, Method method, Object[] args) { + Optional> returnPublisherConverterOp = PublisherConverters.lookup(method.getReturnType()); + if (MethodMapUtils.getRequestChannelParameterType(method).isPresent()) { + Flux responsePublisher = client.requestChannel(route).apply((Publisher) args[0]); + return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), + responsePublisher); + } + if (method.getReturnType().equals(Void.TYPE)) + return client.fireAndForget(route).apply(args).block(); + if (returnPublisherConverterOp.isPresent() && !Mono.class.isAssignableFrom(method.getReturnType())) { + Flux responsePublisher = client.requestStream(route).apply(args); + return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), + responsePublisher); + } + Mono response = client.requestResponse(route).apply(args); + if (returnPublisherConverterOp.isPresent()) + return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), response); + ByteBuf bb = response.block(); + return returnDeserializer.apply(method.getReturnType(), bb); + } + + private static Object returnFromResponsePublisher(Method method, + BiFunction returnDeserializer, PublisherConverter returnPublisherConverter, + Publisher responsePublisher) { + Type typeArgument = returnPublisherConverter.getTypeArgument(method.getGenericReturnType()) + .orElse(Object.class); + Flux resultPublisher = Flux.from(responsePublisher).map(v -> { + Object deserialized = returnDeserializer.apply(typeArgument, v); + return deserialized; + }); + Object result = returnPublisherConverter.fromPublisher(resultPublisher); + return result; + } + + @SuppressWarnings("unchecked") + private static ProxyFactory proxyFactory(Class classType, Class... additionalInterfaces) { + ProxyFactory factory = new ProxyFactory(); + List> classTypes = new ArrayList<>(); + if (classType.isInterface()) + classTypes.add(classType); + else + factory.setSuperclass(classType); + classTypes.addAll(ReflectionUtils.getAllSuperTypes(classType)); + ensureInterfaces(factory, classTypes, additionalInterfaces); + return factory; + } + + private static void ensureInterfaces(ProxyFactory factory, Iterable> classTypes, + Class... additionalInterfaces) { + if (factory == null) + return; + List> setInterfaces = new ArrayList<>(2); + {// current + Class[] arr = factory.getInterfaces(); + if (arr != null) + Arrays.asList(arr).forEach(v -> setInterfaces.add(v)); + } + {// iterable + if (classTypes != null) + classTypes.forEach(v -> setInterfaces.add(v)); + } + {// array + if (additionalInterfaces != null) + Arrays.asList(additionalInterfaces).forEach(v -> setInterfaces.add(v)); + } + Stream> ifaceStream = setInterfaces.stream(); + ifaceStream = ifaceStream.distinct().filter(Objects::nonNull).filter(Class::isInterface).filter(v -> { + return !javassist.util.proxy.ProxyObject.class.isAssignableFrom(v); + }); + factory.setInterfaces(ifaceStream.toArray(Class[]::new)); + } + +} diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/MethodMapUtils.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java similarity index 99% rename from rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/MethodMapUtils.java rename to rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java index ab63cdc7..f12dc764 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/MethodMapUtils.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java @@ -1,4 +1,4 @@ -package io.rsocket.ipc.reflection; +package io.rsocket.ipc.reflection.core; import java.lang.reflect.Method; import java.lang.reflect.Type; diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/PublisherConverter.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java similarity index 99% rename from rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/PublisherConverter.java rename to rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java index b8aae4fa..d8c96022 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/PublisherConverter.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java @@ -1,4 +1,4 @@ -package io.rsocket.ipc.reflection; +package io.rsocket.ipc.reflection.core; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/PublisherConverters.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java similarity index 98% rename from rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/PublisherConverters.java rename to rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java index 19d1e7b6..7798d43d 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/PublisherConverters.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java @@ -1,4 +1,4 @@ -package io.rsocket.ipc.reflection; +package io.rsocket.ipc.reflection.core; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/A.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/A.java deleted file mode 100644 index 76538d3d..00000000 --- a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/A.java +++ /dev/null @@ -1,7 +0,0 @@ -package io.rsocket.ipc.marshallers; - -public class A { - public static void main(String[] args) { - MethodMapUtils all = MethodMapUtils.class; - } -} diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java deleted file mode 100644 index 5501040e..00000000 --- a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.rsocket.ipc.marshallers; - -import java.io.IOException; -import java.io.OutputStreamWriter; -import java.util.Objects; - -import com.google.gson.Gson; - -import io.netty.buffer.ByteBuf; -import io.netty.buffer.ByteBufAllocator; -import io.netty.buffer.ByteBufOutputStream; -import io.rsocket.ipc.Marshaller; - -public class GsonMarshaller implements Marshaller { - - private Gson gson; - private ByteBufAllocator allocator; - - public GsonMarshaller(Gson gson) { - this(gson, ByteBufAllocator.DEFAULT); - } - - public GsonMarshaller(Gson gson, ByteBufAllocator allocator) { - this.gson = Objects.requireNonNull(gson); - this.allocator = Objects.requireNonNull(allocator); - } - - @Override - public ByteBuf apply(Object object) { - ByteBuf buffer = allocator.buffer(); - try (ByteBufOutputStream os = new ByteBufOutputStream(buffer); - OutputStreamWriter writer = new OutputStreamWriter(os);) { - gson.toJson(object, writer); - writer.flush(); - } catch (IOException e) { - throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) - ? java.lang.RuntimeException.class.cast(e) - : new java.lang.RuntimeException(e); - } - return buffer; - } - - public Gson getGson() { - return gson; - } - -} diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java deleted file mode 100644 index 292c3177..00000000 --- a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java +++ /dev/null @@ -1,77 +0,0 @@ -package io.rsocket.ipc.marshallers; - -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.lang.reflect.Type; -import java.util.Objects; - -import com.google.gson.Gson; -import com.google.gson.JsonArray; -import com.google.gson.reflect.TypeToken; - -import io.netty.buffer.ByteBuf; -import io.netty.buffer.ByteBufInputStream; -import io.rsocket.ipc.Unmarshaller; - -public class GsonUnmarshaller implements Unmarshaller { - - public static Object[] apply(Gson gson, Type[] types, boolean releaseOnParse, ByteBuf byteBuf) { - Objects.requireNonNull(types); - if (types.length == 0) - throw new IllegalArgumentException("unmarshall types are required"); - if (types.length == 1 && !isArray(types[0])) - return new Object[] { new GsonUnmarshaller<>(gson, types[0], releaseOnParse).apply(byteBuf) }; - JsonArray jarr = new GsonUnmarshaller<>(gson, JsonArray.class, releaseOnParse).apply(byteBuf); - Object[] result = new Object[jarr.size()]; - for (int i = 0; i < jarr.size(); i++) { - Type type = types == null || types.length <= i ? null : types[i]; - if (type == null) - type = Object.class; - result[i] = gson.fromJson(jarr.get(i), type); - } - return result; - - }; - - private Gson gson; - private Type type; - private boolean releaseOnParse; - - public GsonUnmarshaller(Gson gson, Class classType, boolean releaseOnParse) { - this(gson, (Type) classType, releaseOnParse); - } - - public GsonUnmarshaller(Gson gson, TypeToken typeToken, boolean releaseOnParse) { - this(gson, typeToken == null ? null : typeToken.getType(), releaseOnParse); - } - - protected GsonUnmarshaller(Gson gson, Type type, boolean releaseOnParse) { - this.gson = Objects.requireNonNull(gson); - this.type = Objects.requireNonNull(type); - this.releaseOnParse = releaseOnParse; - } - - @Override - public X apply(ByteBuf byteBuf) { - try (InputStream is = new ByteBufInputStream(byteBuf, releaseOnParse); - InputStreamReader reader = new InputStreamReader(is);) { - return gson.fromJson(reader, type); - } catch (IOException e) { - throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) - ? java.lang.RuntimeException.class.cast(e) - : new java.lang.RuntimeException(e); - } - } - - public Gson getGson() { - return gson; - } - - private static boolean isArray(Type type) { - if (!(type instanceof Class)) - return false; - boolean result = ((Class) type).isArray(); - return result; - } -} diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java new file mode 100644 index 00000000..48c34f37 --- /dev/null +++ b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java @@ -0,0 +1,151 @@ +package io.rsocket.ipc.reflection.server; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.lang.reflect.Type; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.function.Function; + +import io.netty.buffer.ByteBuf; +import io.opentracing.Tracer; +import io.rsocket.ipc.Marshaller; +import io.rsocket.ipc.MetadataDecoder; +import io.rsocket.ipc.RequestHandlingRSocket; +import io.rsocket.ipc.Server; +import io.rsocket.ipc.Server.H; +import io.rsocket.ipc.Unmarshaller; +import io.rsocket.ipc.marshallers.Bytes; +import io.rsocket.ipc.reflection.core.MethodMapUtils; +import io.rsocket.ipc.reflection.core.PublisherConverter; +import io.rsocket.ipc.reflection.core.PublisherConverters; +import io.rsocket.ipc.util.TriFunction; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +public class RequestHandlingRSocketReflection extends RequestHandlingRSocket { + private static final Class THIS_CLASS = new Object() { + }.getClass().getEnclosingClass(); + private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(THIS_CLASS); + + public RequestHandlingRSocketReflection() { + super(); + } + + public RequestHandlingRSocketReflection(MetadataDecoder decoder) { + super(decoder); + } + + public RequestHandlingRSocketReflection(Tracer tracer) { + super(tracer); + } + + public void register(Class serviceType, S service, Marshaller resultMarshaller, + Unmarshaller unmarshaller) { + register(serviceType, service, resultMarshaller, (paramTypes, bb, md) -> unmarshaller.apply(bb)); + } + + public void register(Class serviceType, S service, Marshaller resultMarshaller, + Function> argumentDeserializer) { + register(serviceType, service, resultMarshaller, + (paramTypes, bb, md) -> argumentDeserializer.apply(paramTypes).apply(bb)); + } + + public void register(Class serviceType, S service, Marshaller resultMarshaller, + TriFunction argumentDeserializer) { + Objects.requireNonNull(serviceType); + Objects.requireNonNull(service); + Objects.requireNonNull(resultMarshaller); + Objects.requireNonNull(argumentDeserializer); + Map methods = MethodMapUtils.getMappedMethods(serviceType, true); + Set serviceNameTracker = new HashSet<>(); + for (boolean lowercase : Arrays.asList(false, true)) { + for (boolean simpleName : Arrays.asList(false, true)) { + String serviceName = simpleName ? serviceType.getSimpleName() : serviceType.getName(); + serviceName = lowercase ? serviceName.toLowerCase() : serviceName; + if (!serviceNameTracker.add(serviceName)) + continue; + register(service, serviceName, resultMarshaller, argumentDeserializer, methods); + } + } + } + + private void register(S service, String serviceName, Marshaller resultMarshaller, + TriFunction argumentDeserializer, Map methodMapping) { + H serviceBuilder = Server.service(serviceName).noMeterRegistry().noTracer() + .marshall(resultMarshaller).unmarshall(Bytes.byteBufUnmarshaller()); + methodMapping.entrySet().forEach(ent -> { + String route = ent.getKey(); + logger.debug("registering request handler. serviceName:{} route:{}", serviceName, route); + register(service, route, argumentDeserializer, ent.getValue(), serviceBuilder); + }); + this.withEndpoint(serviceBuilder.toIPCRSocket()); + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + private static void register(S service, String route, + TriFunction argumentDeserializer, Method method, + H serviceBuilder) { + if (registerRequestChannel(service, route, argumentDeserializer, method, serviceBuilder)) + return; + if (method.getReturnType().equals(Void.TYPE)) { + serviceBuilder.fireAndForget(route, (data, md) -> { + invoke(service, method, argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); + return Mono.empty(); + }); + return; + } + Optional returnPublisherConverter = PublisherConverters.lookup(method.getReturnType()) + .map(v -> v); + if (returnPublisherConverter.isPresent() && !Mono.class.isAssignableFrom(method.getReturnType())) { + serviceBuilder.requestStream(route, (data, md) -> { + Object result = invoke(service, method, + argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); + return Flux.from(returnPublisherConverter.get().toPublisher(result)); + }); + return; + } + serviceBuilder.requestResponse(route, (data, md) -> { + Object result = invoke(service, method, + argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); + if (returnPublisherConverter.isPresent()) + return Mono.from(returnPublisherConverter.get().toPublisher(result)); + return Mono.just(result); + }); + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + private static boolean registerRequestChannel(S service, String route, + TriFunction argumentDeserializer, Method method, + H serviceBuilder) { + Optional requestChannelParameterType = MethodMapUtils.getRequestChannelParameterType(method); + if (!requestChannelParameterType.isPresent()) + return false; + PublisherConverter returnPublisherConverter = PublisherConverters.lookup(method.getReturnType()).get(); + Type[] typeArguments = new Type[] { requestChannelParameterType.get() }; + serviceBuilder.requestChannel(route, (first, publisher, md) -> { + Flux deserializedPublisher = Flux.from(publisher).map(bb -> { + Object[] payload = argumentDeserializer.apply(typeArguments, bb, md); + return payload[0]; + }); + Object result = invoke(service, method, new Object[] { deserializedPublisher }); + return Flux.from(returnPublisherConverter.toPublisher(result)); + }); + return true; + } + + private static Object invoke(S serivce, Method method, Object[] arguments) { + try { + return method.invoke(serivce, arguments); + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + } + +} From 705a0a0d649a033dd6e9f3b9f084671b11965b0f Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 02:43:40 -0400 Subject: [PATCH 026/273] logger and class type --- .../io/rsocket/ipc/reflection/core/MethodMapUtils.java | 5 +++-- .../ipc/reflection/core/PublisherConverter.java | 10 +++++----- .../server/RequestHandlingRSocketReflection.java | 7 +++++-- 3 files changed, 13 insertions(+), 9 deletions(-) diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java index f12dc764..ca79d733 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java @@ -16,6 +16,7 @@ import java.util.Optional; import java.util.Set; import java.util.function.Function; +import java.util.logging.Logger; import java.util.stream.Stream; import org.reflections8.ReflectionUtils; @@ -26,7 +27,7 @@ public class MethodMapUtils { private static final Class THIS_CLASS = new Object() { }.getClass().getEnclosingClass(); - private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(THIS_CLASS); + private static final Logger logger = java.util.logging.Logger.getLogger(THIS_CLASS.getName()); private static final Map, Class> PRIMITIVES_TO_WRAPPERS = getPrimitivesToWrappers(); @@ -81,7 +82,7 @@ public static Map getMappedMethods(Class classType, boolean i String key = ent.getKey(); List methods = ent.getValue(); if (methods.size() > 1) { - logger.warn("multiple methods match signature, skipping:{}", key); + logger.warning(String.format("multiple methods match signature, skipping:%s", key)); continue; } result.put(key, methods.get(0)); diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java index d8c96022..5f3a38d8 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java @@ -12,7 +12,7 @@ import io.rsocket.ipc.util.IPCUtils; import reactor.core.publisher.Flux; -@SuppressWarnings("unchecked") +@SuppressWarnings({ "unchecked", "rawtypes" }) public interface PublisherConverter { static PublisherConverter> direct() { @@ -30,7 +30,7 @@ public Publisher fromPublisher(Publisher publisher) { @Override public Class> getConvertType() { - return (Class>) Publisher.class; + return (Class) Publisher.class; } public int priority() { @@ -56,7 +56,7 @@ public Stream fromPublisher(Publisher publisher) { @Override public Class> getConvertType() { - return (Class>) Stream.class; + return (Class) Stream.class; } public int priority() { @@ -82,7 +82,7 @@ public Iterator fromPublisher(Publisher publisher) { @Override public Class> getConvertType() { - return (Class>) Iterator.class; + return (Class) Iterator.class; } public int priority() { @@ -113,7 +113,7 @@ public Iterable fromPublisher(Publisher publisher) { @Override public Class> getConvertType() { - return (Class>) Iterable.class; + return (Class) Iterable.class; } }; diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java index 48c34f37..d7b169be 100644 --- a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java +++ b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java @@ -10,6 +10,8 @@ import java.util.Optional; import java.util.Set; import java.util.function.Function; +import java.util.logging.Level; +import java.util.logging.Logger; import io.netty.buffer.ByteBuf; import io.opentracing.Tracer; @@ -30,7 +32,7 @@ public class RequestHandlingRSocketReflection extends RequestHandlingRSocket { private static final Class THIS_CLASS = new Object() { }.getClass().getEnclosingClass(); - private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(THIS_CLASS); + private static final Logger logger = java.util.logging.Logger.getLogger(THIS_CLASS.getName()); public RequestHandlingRSocketReflection() { super(); @@ -80,7 +82,8 @@ private void register(S service, String serviceName, Marshaller resu .marshall(resultMarshaller).unmarshall(Bytes.byteBufUnmarshaller()); methodMapping.entrySet().forEach(ent -> { String route = ent.getKey(); - logger.debug("registering request handler. serviceName:{} route:{}", serviceName, route); + logger.log(Level.FINE, + String.format("registering request handler. serviceName:%s route:%s", serviceName, route)); register(service, route, argumentDeserializer, ent.getValue(), serviceBuilder); }); this.withEndpoint(serviceBuilder.toIPCRSocket()); From ec9f6d173f6fce6913809e0e57c1336a4ac1e9cf Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 02:53:16 -0400 Subject: [PATCH 027/273] adjusting dependencies --- rsocket-ipc-reflection-client/build.gradle | 3 +- ...ketIPCClients.java => RSocketClients.java} | 29 ++++++++++--------- rsocket-ipc-reflection-core/build.gradle | 3 +- rsocket-ipc-reflection-server/build.gradle | 2 +- 4 files changed, 20 insertions(+), 17 deletions(-) rename rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/{RSocketIPCClients.java => RSocketClients.java} (87%) diff --git a/rsocket-ipc-reflection-client/build.gradle b/rsocket-ipc-reflection-client/build.gradle index d7d09ac7..3c497c8f 100644 --- a/rsocket-ipc-reflection-client/build.gradle +++ b/rsocket-ipc-reflection-client/build.gradle @@ -1,8 +1,9 @@ description = 'RSocket IPC Reflection Mapping Client Support' dependencies { - api project (':rsocket-ipc-reflection-core') + api project (':rsocket-ipc-core') + implementation ':rsocket-ipc-reflection-core' implementation 'org.javassist:javassist:3.27.0-GA' testImplementation 'io.opentracing.brave:brave-opentracing' diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketClients.java similarity index 87% rename from rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java rename to rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketClients.java index 8efb065c..65f35dfe 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketClients.java @@ -21,7 +21,7 @@ import io.rsocket.RSocket; import io.rsocket.ipc.Client; import io.rsocket.ipc.Marshaller; -import io.rsocket.ipc.encoders.MetadataEncoderLFP; +import io.rsocket.ipc.MetadataEncoder; import io.rsocket.ipc.marshallers.Bytes; import io.rsocket.ipc.reflection.core.MethodMapUtils; import io.rsocket.ipc.reflection.core.PublisherConverter; @@ -31,12 +31,12 @@ import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; -public class RSocketIPCClients { +public class RSocketClients { - public static X create(Mono rSocketMono, Class serviceType, Marshaller marshaller, - BiFunction returnDeserializer) { + public static X create(Mono rSocketMono, Class serviceType, MetadataEncoder metadataEncoder, + Marshaller marshaller, BiFunction returnDeserializer) { try { - return createInternal(rSocketMono, serviceType, marshaller, returnDeserializer); + return createInternal(rSocketMono, serviceType, metadataEncoder, marshaller, returnDeserializer); } catch (NoSuchMethodException | IllegalArgumentException | InstantiationException | IllegalAccessException | InvocationTargetException e) { throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) @@ -47,9 +47,9 @@ public static X create(Mono rSocketMono, Class serviceType, Mars @SuppressWarnings("unchecked") protected static X createInternal(Mono rSocketMono, Class serviceType, - Marshaller marshaller, BiFunction returnDeserializer) - throws NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, - InvocationTargetException { + MetadataEncoder metadataEncoder, Marshaller marshaller, + BiFunction returnDeserializer) throws NoSuchMethodException, + IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException { Objects.requireNonNull(rSocketMono); Objects.requireNonNull(serviceType); Objects.requireNonNull(marshaller); @@ -66,8 +66,8 @@ public Object invoke(Object self, Method thisMethod, Method proceed, Object[] ar .orElse(null); if (entry == null) return Optional.empty(); - return Optional.of(createMethodHandler(rSocketMono, serviceType, entry.getKey(), marshaller, - returnDeserializer, thisMethod)); + return Optional.of(createMethodHandler(rSocketMono, serviceType, entry.getKey(), metadataEncoder, + marshaller, returnDeserializer, thisMethod)); }); if (!mhOp.isPresent()) throw new NoSuchMethodException(String.format( @@ -79,15 +79,16 @@ public Object invoke(Object self, Method thisMethod, Method proceed, Object[] ar } private static MethodHandler createMethodHandler(Mono rSocketMono, Class serviceType, String route, - Marshaller marshaller, BiFunction returnDeserializer, Method method) { + MetadataEncoder metadataEncoder, Marshaller marshaller, + BiFunction returnDeserializer, Method method) { return new MethodHandler() { @Override public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable { Client client = Client.service(serviceType.getName()).rsocket(rSocketMono.block()) - .customMetadataEncoder(new MetadataEncoderLFP()).noMeterRegistry().noTracer() - .marshall(marshaller).unmarshall(Bytes.byteBufUnmarshaller()); - return RSocketIPCClients.invoke(client, route, returnDeserializer, method, args); + .customMetadataEncoder(metadataEncoder).noMeterRegistry().noTracer().marshall(marshaller) + .unmarshall(Bytes.byteBufUnmarshaller()); + return RSocketClients.invoke(client, route, returnDeserializer, method, args); } }; } diff --git a/rsocket-ipc-reflection-core/build.gradle b/rsocket-ipc-reflection-core/build.gradle index d05c5fea..d7e7e923 100644 --- a/rsocket-ipc-reflection-core/build.gradle +++ b/rsocket-ipc-reflection-core/build.gradle @@ -1,8 +1,9 @@ description = 'RSocket IPC Reflection Mapping Support' dependencies { - api project (':rsocket-ipc-core') + api project (':rsocket-ipc-core') + implementation ':rsocket-ipc-reflection-core' implementation 'net.oneandone.reflections8:reflections8:0.11.7' testImplementation 'io.opentracing.brave:brave-opentracing' diff --git a/rsocket-ipc-reflection-server/build.gradle b/rsocket-ipc-reflection-server/build.gradle index 4f68cb04..d6763ea7 100644 --- a/rsocket-ipc-reflection-server/build.gradle +++ b/rsocket-ipc-reflection-server/build.gradle @@ -1,7 +1,7 @@ description = 'RSocket IPC Reflection Mapping Client Support' dependencies { - api project (':rsocket-ipc-reflection-core') + api project (':rsocket-ipc-core') testImplementation 'io.opentracing.brave:brave-opentracing' testImplementation 'junit:junit' From c341e11fd3c99d3973221c1879343e6fbc992211 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 03:20:39 -0400 Subject: [PATCH 028/273] compiles --- rsocket-ipc-reflection-client/build.gradle | 5 ++--- rsocket-ipc-reflection-client/settings.gradle | 2 ++ .../client/{RSocketClients.java => RSocketIPCClients.java} | 4 ++-- rsocket-ipc-reflection-core/build.gradle | 7 +++---- rsocket-ipc-reflection-server/build.gradle | 2 +- rsocket-ipc-reflection-server/settings.gradle | 2 ++ 6 files changed, 12 insertions(+), 10 deletions(-) create mode 100644 rsocket-ipc-reflection-client/settings.gradle rename rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/{RSocketClients.java => RSocketIPCClients.java} (98%) create mode 100644 rsocket-ipc-reflection-server/settings.gradle diff --git a/rsocket-ipc-reflection-client/build.gradle b/rsocket-ipc-reflection-client/build.gradle index 3c497c8f..95cf8e75 100644 --- a/rsocket-ipc-reflection-client/build.gradle +++ b/rsocket-ipc-reflection-client/build.gradle @@ -2,8 +2,7 @@ description = 'RSocket IPC Reflection Mapping Client Support' dependencies { api project (':rsocket-ipc-core') - - implementation ':rsocket-ipc-reflection-core' + implementation project(":rsocket-ipc-reflection-core") implementation 'org.javassist:javassist:3.27.0-GA' testImplementation 'io.opentracing.brave:brave-opentracing' @@ -13,7 +12,7 @@ dependencies { testImplementation 'javax.inject:javax.inject' testImplementation 'io.projectreactor:reactor-test' - testImplementation 'com.google.protobuf:protobuf-java' + testImplementation 'com.google.protobuf:prorsocket-ipc-reflection-clienttobuf-java' testImplementation 'org.hdrhistogram:HdrHistogram' testImplementation 'org.apache.logging.log4j:log4j-api' testImplementation 'org.apache.logging.log4j:log4j-core' diff --git a/rsocket-ipc-reflection-client/settings.gradle b/rsocket-ipc-reflection-client/settings.gradle new file mode 100644 index 00000000..ee02bc0d --- /dev/null +++ b/rsocket-ipc-reflection-client/settings.gradle @@ -0,0 +1,2 @@ +include ":rsocket-ipc-reflection-core" +project(":rsocket-ipc-reflection-core").projectDir = file("../rsocket-ipc-reflection-core") \ No newline at end of file diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java similarity index 98% rename from rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketClients.java rename to rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java index 65f35dfe..ba1f93ae 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketClients.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java @@ -31,7 +31,7 @@ import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; -public class RSocketClients { +public class RSocketIPCClients { public static X create(Mono rSocketMono, Class serviceType, MetadataEncoder metadataEncoder, Marshaller marshaller, BiFunction returnDeserializer) { @@ -88,7 +88,7 @@ public Object invoke(Object self, Method thisMethod, Method proceed, Object[] ar Client client = Client.service(serviceType.getName()).rsocket(rSocketMono.block()) .customMetadataEncoder(metadataEncoder).noMeterRegistry().noTracer().marshall(marshaller) .unmarshall(Bytes.byteBufUnmarshaller()); - return RSocketClients.invoke(client, route, returnDeserializer, method, args); + return RSocketIPCClients.invoke(client, route, returnDeserializer, method, args); } }; } diff --git a/rsocket-ipc-reflection-core/build.gradle b/rsocket-ipc-reflection-core/build.gradle index d7e7e923..55b9bf84 100644 --- a/rsocket-ipc-reflection-core/build.gradle +++ b/rsocket-ipc-reflection-core/build.gradle @@ -1,10 +1,9 @@ description = 'RSocket IPC Reflection Mapping Support' -dependencies { - api project (':rsocket-ipc-core') - implementation ':rsocket-ipc-reflection-core' - implementation 'net.oneandone.reflections8:reflections8:0.11.7' +dependencies { + api project (':rsocket-ipc-core') + compile 'net.oneandone.reflections8:reflections8:0.11.7' testImplementation 'io.opentracing.brave:brave-opentracing' testImplementation 'junit:junit' diff --git a/rsocket-ipc-reflection-server/build.gradle b/rsocket-ipc-reflection-server/build.gradle index d6763ea7..bb378315 100644 --- a/rsocket-ipc-reflection-server/build.gradle +++ b/rsocket-ipc-reflection-server/build.gradle @@ -2,7 +2,7 @@ description = 'RSocket IPC Reflection Mapping Client Support' dependencies { api project (':rsocket-ipc-core') - + implementation project(":rsocket-ipc-reflection-core") testImplementation 'io.opentracing.brave:brave-opentracing' testImplementation 'junit:junit' testImplementation 'org.junit.jupiter:junit-jupiter-engine' diff --git a/rsocket-ipc-reflection-server/settings.gradle b/rsocket-ipc-reflection-server/settings.gradle new file mode 100644 index 00000000..ee02bc0d --- /dev/null +++ b/rsocket-ipc-reflection-server/settings.gradle @@ -0,0 +1,2 @@ +include ":rsocket-ipc-reflection-core" +project(":rsocket-ipc-reflection-core").projectDir = file("../rsocket-ipc-reflection-core") \ No newline at end of file From 596e7d2bb41dabc8c70b63eedeabc27157188b6a Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 03:22:14 -0400 Subject: [PATCH 029/273] remove settings files --- rsocket-ipc-reflection-client/settings.gradle | 2 -- rsocket-ipc-reflection-server/settings.gradle | 2 -- 2 files changed, 4 deletions(-) delete mode 100644 rsocket-ipc-reflection-client/settings.gradle delete mode 100644 rsocket-ipc-reflection-server/settings.gradle diff --git a/rsocket-ipc-reflection-client/settings.gradle b/rsocket-ipc-reflection-client/settings.gradle deleted file mode 100644 index ee02bc0d..00000000 --- a/rsocket-ipc-reflection-client/settings.gradle +++ /dev/null @@ -1,2 +0,0 @@ -include ":rsocket-ipc-reflection-core" -project(":rsocket-ipc-reflection-core").projectDir = file("../rsocket-ipc-reflection-core") \ No newline at end of file diff --git a/rsocket-ipc-reflection-server/settings.gradle b/rsocket-ipc-reflection-server/settings.gradle deleted file mode 100644 index ee02bc0d..00000000 --- a/rsocket-ipc-reflection-server/settings.gradle +++ /dev/null @@ -1,2 +0,0 @@ -include ":rsocket-ipc-reflection-core" -project(":rsocket-ipc-reflection-core").projectDir = file("../rsocket-ipc-reflection-core") \ No newline at end of file From ed27510f8cf755d73e610f85a6e39f078398e507 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 09:00:37 -0400 Subject: [PATCH 030/273] refractor --- eclipse-clear.sh | 2 + rsocket-ipc-reflection-client/bin/.gitignore | 1 + rsocket-ipc-reflection-client/build.gradle | 4 +- .../ipc/reflection/client/IPCInvoker.java | 9 ++ .../reflection/client/RSocketIPCClients.java | 97 +++++++++++-------- rsocket-ipc-reflection-core/bin/.gitignore | 1 + .../ipc/reflection/core/MethodMapUtils.java | 42 +++++++- .../reflection/core/PublisherConverter.java | 17 +--- rsocket-ipc-reflection-server/bin/.gitignore | 2 + rsocket-ipc-reflection-server/build.gradle | 3 +- .../RequestHandlingRSocketReflection.java | 2 +- rsocket-ipc-reflection-test/bin/.gitignore | 3 + rsocket-ipc-reflection-test/build.gradle | 26 +++++ .../io/rsocket/ipc/reflection/ClientTest.java | 56 +++++++++++ .../io/rsocket/ipc/reflection/ServerTest.java | 46 +++++++++ .../ipc/reflection/TestServiceChannel.java | 50 ++++++++++ settings.gradle | 2 +- settings.jitpack.gradle | 1 + 18 files changed, 300 insertions(+), 64 deletions(-) create mode 100644 eclipse-clear.sh create mode 100644 rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/IPCInvoker.java create mode 100644 rsocket-ipc-reflection-test/bin/.gitignore create mode 100644 rsocket-ipc-reflection-test/build.gradle create mode 100644 rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java create mode 100644 rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java create mode 100644 rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/TestServiceChannel.java diff --git a/eclipse-clear.sh b/eclipse-clear.sh new file mode 100644 index 00000000..c7229942 --- /dev/null +++ b/eclipse-clear.sh @@ -0,0 +1,2 @@ +find . -name "*.project" -type f -delete +find . -name "*.settings" -type d -print0 | xargs -0 /bin/rm -rf \ No newline at end of file diff --git a/rsocket-ipc-reflection-client/bin/.gitignore b/rsocket-ipc-reflection-client/bin/.gitignore index ddf9c656..d97dd0c1 100644 --- a/rsocket-ipc-reflection-client/bin/.gitignore +++ b/rsocket-ipc-reflection-client/bin/.gitignore @@ -1 +1,2 @@ /main/ +/default/ diff --git a/rsocket-ipc-reflection-client/build.gradle b/rsocket-ipc-reflection-client/build.gradle index 95cf8e75..fa39da66 100644 --- a/rsocket-ipc-reflection-client/build.gradle +++ b/rsocket-ipc-reflection-client/build.gradle @@ -2,9 +2,9 @@ description = 'RSocket IPC Reflection Mapping Client Support' dependencies { api project (':rsocket-ipc-core') - implementation project(":rsocket-ipc-reflection-core") + implementation project (':rsocket-ipc-reflection-core') implementation 'org.javassist:javassist:3.27.0-GA' - + testImplementation 'io.opentracing.brave:brave-opentracing' testImplementation 'junit:junit' testImplementation 'org.junit.jupiter:junit-jupiter-engine' diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/IPCInvoker.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/IPCInvoker.java new file mode 100644 index 00000000..eb0c7513 --- /dev/null +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/IPCInvoker.java @@ -0,0 +1,9 @@ +package io.rsocket.ipc.reflection.client; + +import io.rsocket.RSocket; +import reactor.core.publisher.Mono; + +public interface IPCInvoker { + + public Object invoke(Mono rSocketMono, Object[] args) throws Throwable; +} diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java index ba1f93ae..bef8f4e8 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java @@ -12,6 +12,7 @@ import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; import java.util.function.BiFunction; +import java.util.function.Function; import java.util.stream.Stream; import org.reactivestreams.Publisher; @@ -55,76 +56,86 @@ protected static X createInternal(Mono rSocketMono, Class servic Objects.requireNonNull(marshaller); Objects.requireNonNull(returnDeserializer); Map mappedMethods = MethodMapUtils.getMappedMethods(serviceType, false); - Map> methodHandlerCache = new ConcurrentHashMap<>(); + Map> ipcInvokerCache = new ConcurrentHashMap<>(); return (X) proxyFactory(serviceType).create(new Class[] {}, new Object[] {}, new MethodHandler() { @Override public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable { - Optional mhOp = methodHandlerCache.computeIfAbsent(thisMethod, nil -> { + Optional ipcInvokerOp = ipcInvokerCache.computeIfAbsent(thisMethod, nil -> { Entry entry = mappedMethods.entrySet().stream() .filter(ent -> MethodMapUtils.compatibleMethods(thisMethod, ent.getValue())).findFirst() .orElse(null); if (entry == null) return Optional.empty(); - return Optional.of(createMethodHandler(rSocketMono, serviceType, entry.getKey(), metadataEncoder, - marshaller, returnDeserializer, thisMethod)); + return Optional.of(createIPCInvoker(serviceType, entry.getKey(), metadataEncoder, marshaller, + returnDeserializer, thisMethod)); }); - if (!mhOp.isPresent()) + if (!ipcInvokerOp.isPresent()) throw new NoSuchMethodException(String.format( "could not map method in service. serviceType:%s method:%s", serviceType, thisMethod)); - return mhOp.get().invoke(self, thisMethod, proceed, args); + return ipcInvokerOp.get().invoke(rSocketMono, args); } }); } - private static MethodHandler createMethodHandler(Mono rSocketMono, Class serviceType, String route, - MetadataEncoder metadataEncoder, Marshaller marshaller, - BiFunction returnDeserializer, Method method) { - return new MethodHandler() { - - @Override - public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable { - Client client = Client.service(serviceType.getName()).rsocket(rSocketMono.block()) - .customMetadataEncoder(metadataEncoder).noMeterRegistry().noTracer().marshall(marshaller) - .unmarshall(Bytes.byteBufUnmarshaller()); - return RSocketIPCClients.invoke(client, route, returnDeserializer, method, args); - } - }; - } - @SuppressWarnings("unchecked") - private static Object invoke(Client client, String route, - BiFunction returnDeserializer, Method method, Object[] args) { + private static IPCInvoker createIPCInvoker(Class serviceType, String route, MetadataEncoder metadataEncoder, + Marshaller marshaller, BiFunction returnDeserializer, Method method) { + Function, Client> clientSupplier = rSocketMono -> { + Client client = Client.service(serviceType.getName()).rsocket(rSocketMono.block()) + .customMetadataEncoder(metadataEncoder).noMeterRegistry().noTracer().marshall(marshaller) + .unmarshall(Bytes.byteBufUnmarshaller()); + return client; + }; Optional> returnPublisherConverterOp = PublisherConverters.lookup(method.getReturnType()); if (MethodMapUtils.getRequestChannelParameterType(method).isPresent()) { - Flux responsePublisher = client.requestChannel(route).apply((Publisher) args[0]); - return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), - responsePublisher); - } - if (method.getReturnType().equals(Void.TYPE)) - return client.fireAndForget(route).apply(args).block(); - if (returnPublisherConverterOp.isPresent() && !Mono.class.isAssignableFrom(method.getReturnType())) { - Flux responsePublisher = client.requestStream(route).apply(args); - return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), - responsePublisher); + return (rSocketMono, args) -> { + Flux responsePublisher = clientSupplier.apply(rSocketMono).requestChannel(route) + .apply((Publisher) args[0]); + return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), + responsePublisher); + }; } - Mono response = client.requestResponse(route).apply(args); - if (returnPublisherConverterOp.isPresent()) - return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), response); - ByteBuf bb = response.block(); - return returnDeserializer.apply(method.getReturnType(), bb); + if (MethodMapUtils.isFireAndForget(method)) + return (rSocketMono, args) -> { + Mono result = clientSupplier.apply(rSocketMono).fireAndForget(route).apply(args); + if (Mono.class.isAssignableFrom(method.getReturnType())) + return result; + return null; + }; + if (returnPublisherConverterOp.isPresent() && !Mono.class.isAssignableFrom(method.getReturnType())) + return (rSocketMono, args) -> { + Flux responsePublisher = clientSupplier.apply(rSocketMono).requestStream(route).apply(args); + return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), + responsePublisher); + }; + return (rSocketMono, args) -> { + Mono responsePublisher = clientSupplier.apply(rSocketMono).requestResponse(route).apply(args); + if (returnPublisherConverterOp.isPresent()) + return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), + responsePublisher); + ByteBuf bb = responsePublisher.block(); + return returnDeserializer.apply(method.getReturnType(), bb); + }; } private static Object returnFromResponsePublisher(Method method, BiFunction returnDeserializer, PublisherConverter returnPublisherConverter, Publisher responsePublisher) { - Type typeArgument = returnPublisherConverter.getTypeArgument(method.getGenericReturnType()) + Type typeArgument = returnPublisherConverter.getPublisherTypeArgument(method.getGenericReturnType()) .orElse(Object.class); - Flux resultPublisher = Flux.from(responsePublisher).map(v -> { - Object deserialized = returnDeserializer.apply(typeArgument, v); - return deserialized; - }); + Publisher resultPublisher; + if (Mono.class.isAssignableFrom(method.getReturnType())) + resultPublisher = Mono.from(responsePublisher).map(v -> { + Object deserialized = returnDeserializer.apply(typeArgument, v); + return deserialized; + }); + else + resultPublisher = Flux.from(responsePublisher).map(v -> { + Object deserialized = returnDeserializer.apply(typeArgument, v); + return deserialized; + }); Object result = returnPublisherConverter.fromPublisher(resultPublisher); return result; } diff --git a/rsocket-ipc-reflection-core/bin/.gitignore b/rsocket-ipc-reflection-core/bin/.gitignore index ddf9c656..d97dd0c1 100644 --- a/rsocket-ipc-reflection-core/bin/.gitignore +++ b/rsocket-ipc-reflection-core/bin/.gitignore @@ -1 +1,2 @@ /main/ +/default/ diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java index ca79d733..a9219414 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java @@ -1,6 +1,7 @@ package io.rsocket.ipc.reflection.core; import java.lang.reflect.Method; +import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.AbstractMap.SimpleImmutableEntry; import java.util.ArrayList; @@ -23,6 +24,7 @@ import io.rsocket.ipc.util.IPCUtils; import javassist.Modifier; +import reactor.core.publisher.Mono; public class MethodMapUtils { private static final Class THIS_CLASS = new Object() { @@ -160,6 +162,8 @@ private static Set getMethodSignatures(Method method, boolean includeVar } public static Optional getRequestChannelParameterType(Method method) { + if (method == null) + return Optional.empty(); if (method.getParameterCount() != 1) return Optional.empty(); Optional> payloadConverter = PublisherConverters.lookup(method.getParameterTypes()[0]); @@ -168,10 +172,46 @@ public static Optional getRequestChannelParameterType(Method method) { if (!PublisherConverters.lookup(method.getReturnType()).isPresent()) return Optional.empty(); Type type = method.getGenericParameterTypes()[0]; - Optional typeArgument = payloadConverter.get().getTypeArgument(type); + Optional typeArgument = payloadConverter.get().getPublisherTypeArgument(type); if (!typeArgument.isPresent()) return Optional.empty(); return Optional.of(typeArgument.get()); } + public static boolean isFireAndForget(Method method) { + if (method == null) + return false; + if (method.getReturnType().equals(Void.TYPE)) + return true; + if (!Mono.class.isAssignableFrom(method.getReturnType())) + return false; + Type typeArgument = getPublisherTypeArgument(Mono.class, method.getGenericReturnType()).orElse(null); + if (typeArgument == null) + return false; + if (typeArgument.equals(Void.TYPE)) + return true; + if (typeArgument.equals(Void.class)) + return true; + if (typeArgument.equals(void.class)) + return true; + return false; + } + + public static Optional getPublisherTypeArgument(Class superClassLimit, Type type) { + if (type == null) + return Optional.empty(); + if (type instanceof ParameterizedType) { + ParameterizedType pt = (ParameterizedType) type; + Type[] actualTypeArguments = pt.getActualTypeArguments(); + if (actualTypeArguments != null && actualTypeArguments.length == 1) + return Optional.of(actualTypeArguments[0]); + } + if (!(type instanceof Class)) + return Optional.empty(); + Class superClass = ((Class) type).getSuperclass(); + if (superClass != null && superClassLimit != null && !superClassLimit.isAssignableFrom(superClass)) + return Optional.empty(); + return getPublisherTypeArgument(superClassLimit, superClass); + } + } diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java index 5f3a38d8..ada52330 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java @@ -133,21 +133,8 @@ default boolean appliesTo(Class classType) { return getConvertType().isAssignableFrom(classType); } - default Optional getTypeArgument(Type type) { - if (type == null) - return Optional.empty(); - if (type instanceof ParameterizedType) { - ParameterizedType pt = (ParameterizedType) type; - Type[] actualTypeArguments = pt.getActualTypeArguments(); - if (actualTypeArguments != null && actualTypeArguments.length == 1) - return Optional.of(actualTypeArguments[0]); - } - if (!(type instanceof Class)) - return Optional.empty(); - Class superClass = ((Class) type).getSuperclass(); - if (superClass != null && !this.getConvertType().isAssignableFrom(superClass)) - return Optional.empty(); - return getTypeArgument(superClass); + default Optional getPublisherTypeArgument(Type type) { + return MethodMapUtils.getPublisherTypeArgument(this.getConvertType(), type); } static abstract class Abs implements PublisherConverter { diff --git a/rsocket-ipc-reflection-server/bin/.gitignore b/rsocket-ipc-reflection-server/bin/.gitignore index ddf9c656..1522af6d 100644 --- a/rsocket-ipc-reflection-server/bin/.gitignore +++ b/rsocket-ipc-reflection-server/bin/.gitignore @@ -1 +1,3 @@ /main/ +/default/ +/test/ diff --git a/rsocket-ipc-reflection-server/build.gradle b/rsocket-ipc-reflection-server/build.gradle index bb378315..c3238981 100644 --- a/rsocket-ipc-reflection-server/build.gradle +++ b/rsocket-ipc-reflection-server/build.gradle @@ -2,7 +2,8 @@ description = 'RSocket IPC Reflection Mapping Client Support' dependencies { api project (':rsocket-ipc-core') - implementation project(":rsocket-ipc-reflection-core") + implementation project (":rsocket-ipc-reflection-core") + testImplementation 'io.opentracing.brave:brave-opentracing' testImplementation 'junit:junit' testImplementation 'org.junit.jupiter:junit-jupiter-engine' diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java index d7b169be..00a9d04a 100644 --- a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java +++ b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java @@ -95,7 +95,7 @@ private static void register(S service, String route, H serviceBuilder) { if (registerRequestChannel(service, route, argumentDeserializer, method, serviceBuilder)) return; - if (method.getReturnType().equals(Void.TYPE)) { + if (MethodMapUtils.isFireAndForget(method)) { serviceBuilder.fireAndForget(route, (data, md) -> { invoke(service, method, argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); return Mono.empty(); diff --git a/rsocket-ipc-reflection-test/bin/.gitignore b/rsocket-ipc-reflection-test/bin/.gitignore new file mode 100644 index 00000000..1522af6d --- /dev/null +++ b/rsocket-ipc-reflection-test/bin/.gitignore @@ -0,0 +1,3 @@ +/main/ +/default/ +/test/ diff --git a/rsocket-ipc-reflection-test/build.gradle b/rsocket-ipc-reflection-test/build.gradle new file mode 100644 index 00000000..e7c1db37 --- /dev/null +++ b/rsocket-ipc-reflection-test/build.gradle @@ -0,0 +1,26 @@ +description = 'RSocket IPC Reflection Mapping Client Support' + +dependencies { + api project (':rsocket-ipc-core') + implementation project (':rsocket-ipc-reflection-client') + implementation project (':rsocket-ipc-reflection-server') + implementation project (':rsocket-ipc-gson') + implementation 'io.rsocket:rsocket-transport-netty' + + testImplementation 'io.opentracing.brave:brave-opentracing' + testImplementation 'junit:junit' + testImplementation 'org.junit.jupiter:junit-jupiter-engine' + testImplementation 'org.junit.vintage:junit-vintage-engine' + + testImplementation 'javax.inject:javax.inject' + testImplementation 'io.projectreactor:reactor-test' + testImplementation 'com.google.protobuf:prorsocket-ipc-reflection-clienttobuf-java' + testImplementation 'org.hdrhistogram:HdrHistogram' + testImplementation 'org.apache.logging.log4j:log4j-api' + testImplementation 'org.apache.logging.log4j:log4j-core' + testImplementation 'org.apache.logging.log4j:log4j-slf4j-impl' + testImplementation 'io.rsocket:rsocket-transport-netty' + testImplementation 'io.rsocket:rsocket-transport-local' + testImplementation 'org.mockito:mockito-core' + testImplementation 'io.zipkin.reporter2:zipkin-sender-okhttp3' +} \ No newline at end of file diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java new file mode 100644 index 00000000..6de96d4a --- /dev/null +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java @@ -0,0 +1,56 @@ +package io.rsocket.ipc.reflection; + +import java.lang.reflect.Type; +import java.nio.charset.StandardCharsets; +import java.time.Duration; +import java.util.Arrays; +import java.util.Date; +import java.util.function.BiFunction; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +import com.google.gson.Gson; + +import io.netty.buffer.ByteBuf; +import io.rsocket.RSocket; +import io.rsocket.core.RSocketConnector; +import io.rsocket.ipc.encoders.MetadataEncoderLFP; +import io.rsocket.ipc.marshallers.GsonMarshaller; +import io.rsocket.ipc.marshallers.GsonUnmarshaller; +import io.rsocket.ipc.reflection.client.RSocketIPCClients; +import io.rsocket.transport.netty.client.TcpClientTransport; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +public class ClientTest { + + public static void main(String[] args) { + com.google.gson.Gson gson = new Gson(); + RSocket rsocket = RSocketConnector.create().connect(TcpClientTransport.create("localhost", 7000)).block(); + GsonMarshaller marshaller = new GsonMarshaller(gson); + BiFunction deserializer = (t, bb) -> { + Object result = GsonUnmarshaller.apply(gson, new Type[] { t }, true, bb)[0]; + return result; + }; + TestServiceChannel client = RSocketIPCClients.create(Mono.just(rsocket), TestServiceChannel.class, + new MetadataEncoderLFP(), v -> { + ByteBuf bb = marshaller.apply(v); + System.out.println(bb.toString(StandardCharsets.UTF_8)); + return bb; + }, deserializer); + System.out.println(client.addMono(69, 420).block()); + System.out.println(client.add(69, 420)); + client.intFlux(IntStream.range(0, 20).toArray()).toStream().forEach(v -> { + System.out.println(v); + }); + Stream res = client.cool(Arrays.asList(new Date(), new Date(0l)), "sup"); + res.forEach(v -> { + System.out.println(v); + }); + + Flux resp = client.channel(Flux.range(0, 10).map(i -> new Date()).delayElements(Duration.ofSeconds(1))); + resp.toStream().forEach(v -> { + System.out.println(v); + }); + } +} diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java new file mode 100644 index 00000000..c5296c12 --- /dev/null +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java @@ -0,0 +1,46 @@ +package io.rsocket.ipc.reflection; + +import java.util.logging.Level; + +import com.google.gson.Gson; + +import io.rsocket.SocketAcceptor; +import io.rsocket.core.RSocketServer; +import io.rsocket.ipc.decoders.MetadataDecoderLFP; +import io.rsocket.ipc.marshallers.GsonMarshaller; +import io.rsocket.ipc.marshallers.GsonUnmarshaller; +import io.rsocket.ipc.reflection.server.RequestHandlingRSocketReflection; +import io.rsocket.transport.netty.server.TcpServerTransport; +import reactor.core.publisher.Mono; + +public class ServerTest { + private static final Class THIS_CLASS = new Object() { + }.getClass().getEnclosingClass(); + private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(THIS_CLASS); + + public static void main(String[] args) throws InterruptedException { + Class classType = TestServiceChannel.class; + TestServiceChannel service = new TestServiceChannel() { + }; + MetadataDecoderLFP decoder = new MetadataDecoderLFP(); + RequestHandlingRSocketReflection requestHandler; + { + requestHandler = new RequestHandlingRSocketReflection(new MetadataDecoderLFP()); + SocketAcceptor socketAcceptor = (setup, client) -> Mono.just(requestHandler); + RSocketServer.create(socketAcceptor).interceptors(ir -> { + }).errorConsumer(t -> { + java.util.logging.Logger.getLogger("[server]").log(Level.SEVERE, "uncaught error", t); + }).bind(TcpServerTransport.create("localhost", 7000)).block(); + } + boolean releaseOnParse = true; + Gson gson = new Gson(); + requestHandler.register(classType, service, new GsonMarshaller(gson), (pt, bb, md) -> { + return GsonUnmarshaller.apply(gson, pt, true, bb); + }); + System.out.println("started"); + while (true) { + Thread.sleep(1000); + } + } + +} diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/TestServiceChannel.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/TestServiceChannel.java new file mode 100644 index 00000000..c2026345 --- /dev/null +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/TestServiceChannel.java @@ -0,0 +1,50 @@ +package io.rsocket.ipc.reflection; + +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +public interface TestServiceChannel { + + default Flux channel(Flux flux) { + return flux.map(d -> "the date is:" + d); + } + + default void msg(String msg) { + System.out.println("msg:" + msg); + } + + default Stream stream(String msg, Date date) { + return IntStream.range(0, 10).mapToObj(v -> v).map(v -> v + "- " + msg + " - " + date); + } + + default int add(int... args) { + int res = 0; + for (int arg : args) + res += arg; + return res; + } + + default Flux intFlux(int... args) { + List argList = new ArrayList<>(); + for (int val : args) + argList.add(val); + return Flux.fromIterable(argList); + } + + default Mono addMono(int... args) { + int res = 0; + for (int arg : args) + res += arg; + return Mono.just(res); + } + + default Stream cool(List vals, String msg) { + return vals.stream().map(v -> msg + " " + v); + } +} diff --git a/settings.gradle b/settings.gradle index b93c65d3..7f607dfd 100644 --- a/settings.gradle +++ b/settings.gradle @@ -16,7 +16,7 @@ include 'rsocket-ipc-gson' include 'rsocket-ipc-reflection-core' include 'rsocket-ipc-reflection-client' include 'rsocket-ipc-reflection-server' - +include 'rsocket-ipc-reflection-test' gradleEnterprise { buildScan { diff --git a/settings.jitpack.gradle b/settings.jitpack.gradle index f4eaadfa..ae708431 100644 --- a/settings.jitpack.gradle +++ b/settings.jitpack.gradle @@ -18,6 +18,7 @@ include 'rsocket-ipc-gson' include 'rsocket-ipc-reflection-core' include 'rsocket-ipc-reflection-client' include 'rsocket-ipc-reflection-server' +include 'rsocket-ipc-reflection-test' gradleEnterprise { buildScan { From 1d8741a99def174a0ee6980ae0450a9c4d75a215 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 09:05:12 -0400 Subject: [PATCH 031/273] gson update --- rsocket-ipc-gson/build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rsocket-ipc-gson/build.gradle b/rsocket-ipc-gson/build.gradle index da6814ef..c20600db 100644 --- a/rsocket-ipc-gson/build.gradle +++ b/rsocket-ipc-gson/build.gradle @@ -3,7 +3,7 @@ description = 'RSocket IPC Gson Support' dependencies { api project (':rsocket-ipc-core') - implementation 'com.google.code.gson:gson:2.8.6' + compile 'com.google.code.gson:gson:2.8.6' testImplementation 'io.opentracing.brave:brave-opentracing' testImplementation 'junit:junit' From de3990c68a3225e0e4e453d2f5818109bc0a4845 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 13:38:32 -0400 Subject: [PATCH 032/273] default methods --- .../io/rsocket/ipc/reflection/client/RSocketIPCClients.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java index bef8f4e8..d6d7b836 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java @@ -61,6 +61,8 @@ protected static X createInternal(Mono rSocketMono, Class servic @Override public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable { + if (thisMethod.isDefault() && proceed != null) + return proceed.invoke(self, args); Optional ipcInvokerOp = ipcInvokerCache.computeIfAbsent(thisMethod, nil -> { Entry entry = mappedMethods.entrySet().stream() .filter(ent -> MethodMapUtils.compatibleMethods(thisMethod, ent.getValue())).findFirst() From c3ddfbbd5ab02d700d407984430c45f4a6790216 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 14:11:22 -0400 Subject: [PATCH 033/273] Update GsonUnmarshaller.java --- .../rsocket/ipc/marshallers/GsonUnmarshaller.java | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java index 292c3177..8b00444e 100644 --- a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java +++ b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java @@ -18,9 +18,9 @@ public class GsonUnmarshaller implements Unmarshaller { public static Object[] apply(Gson gson, Type[] types, boolean releaseOnParse, ByteBuf byteBuf) { Objects.requireNonNull(types); - if (types.length == 0) + if (types == null || types.length == 0) throw new IllegalArgumentException("unmarshall types are required"); - if (types.length == 1 && !isArray(types[0])) + if (types.length == 1) return new Object[] { new GsonUnmarshaller<>(gson, types[0], releaseOnParse).apply(byteBuf) }; JsonArray jarr = new GsonUnmarshaller<>(gson, JsonArray.class, releaseOnParse).apply(byteBuf); Object[] result = new Object[jarr.size()]; @@ -34,6 +34,10 @@ public static Object[] apply(Gson gson, Type[] types, boolean releaseOnParse, By }; + public static Object apply(Gson gson, Type type, boolean releaseOnParse, ByteBuf byteBuf) { + return new GsonUnmarshaller<>(gson, type, releaseOnParse).apply(byteBuf); + } + private Gson gson; private Type type; private boolean releaseOnParse; @@ -68,10 +72,4 @@ public Gson getGson() { return gson; } - private static boolean isArray(Type type) { - if (!(type instanceof Class)) - return false; - boolean result = ((Class) type).isArray(); - return result; - } } From b4b494896b1abb20ad6c2fa62afe9328cb2b3149 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 15:19:43 -0400 Subject: [PATCH 034/273] gson marshall updates --- .../ipc/marshallers/GsonUnmarshaller.java | 70 +++++++++---------- .../io/rsocket/ipc/reflection/ClientTest.java | 4 +- .../io/rsocket/ipc/reflection/ServerTest.java | 4 +- 3 files changed, 39 insertions(+), 39 deletions(-) diff --git a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java index 8b00444e..2fbb5b3b 100644 --- a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java +++ b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java @@ -5,6 +5,7 @@ import java.io.InputStreamReader; import java.lang.reflect.Type; import java.util.Objects; +import java.util.function.Function; import com.google.gson.Gson; import com.google.gson.JsonArray; @@ -16,48 +17,51 @@ public class GsonUnmarshaller implements Unmarshaller { - public static Object[] apply(Gson gson, Type[] types, boolean releaseOnParse, ByteBuf byteBuf) { - Objects.requireNonNull(types); - if (types == null || types.length == 0) - throw new IllegalArgumentException("unmarshall types are required"); - if (types.length == 1) - return new Object[] { new GsonUnmarshaller<>(gson, types[0], releaseOnParse).apply(byteBuf) }; - JsonArray jarr = new GsonUnmarshaller<>(gson, JsonArray.class, releaseOnParse).apply(byteBuf); - Object[] result = new Object[jarr.size()]; - for (int i = 0; i < jarr.size(); i++) { - Type type = types == null || types.length <= i ? null : types[i]; - if (type == null) - type = Object.class; - result[i] = gson.fromJson(jarr.get(i), type); - } - return result; - - }; - - public static Object apply(Gson gson, Type type, boolean releaseOnParse, ByteBuf byteBuf) { - return new GsonUnmarshaller<>(gson, type, releaseOnParse).apply(byteBuf); + public static GsonUnmarshaller create(Gson gson, TypeToken typeToken, boolean releaseOnParse) { + return create(gson, typeToken == null ? null : typeToken.getType(), releaseOnParse); } - private Gson gson; - private Type type; - private boolean releaseOnParse; + public static GsonUnmarshaller create(Gson gson, Class classType, boolean releaseOnParse) { + return create(gson, (Type) classType, releaseOnParse); + } - public GsonUnmarshaller(Gson gson, Class classType, boolean releaseOnParse) { - this(gson, (Type) classType, releaseOnParse); + public static GsonUnmarshaller create(Gson gson, Type type, boolean releaseOnParse) { + Objects.requireNonNull(gson); + Objects.requireNonNull(type); + return new GsonUnmarshaller<>(bb -> parseUnchecked(gson, type, bb, releaseOnParse)); } - public GsonUnmarshaller(Gson gson, TypeToken typeToken, boolean releaseOnParse) { - this(gson, typeToken == null ? null : typeToken.getType(), releaseOnParse); + public static GsonUnmarshaller create(Gson gson, Type[] types, boolean releaseOnParse) { + Objects.requireNonNull(gson); + Objects.requireNonNull(types); + return new GsonUnmarshaller<>(bb -> { + JsonArray jarr = parseUnchecked(gson, JsonArray.class, bb, releaseOnParse); + Object[] result = new Object[jarr.size()]; + for (int i = 0; i < jarr.size(); i++) { + Type type = types == null || types.length <= i ? null : types[i]; + if (type == null) + type = Object.class; + result[i] = gson.fromJson(jarr.get(i), type); + } + return result; + }); } - protected GsonUnmarshaller(Gson gson, Type type, boolean releaseOnParse) { - this.gson = Objects.requireNonNull(gson); - this.type = Objects.requireNonNull(type); - this.releaseOnParse = releaseOnParse; + private final Function parser; + + protected GsonUnmarshaller(Function parser) { + this.parser = Objects.requireNonNull(parser); } @Override public X apply(ByteBuf byteBuf) { + return parser.apply(byteBuf); + } + + private static Y parseUnchecked(Gson gson, Type type, ByteBuf byteBuf, boolean releaseOnParse) { + Objects.requireNonNull(gson); + Objects.requireNonNull(byteBuf); + type = type != null ? type : Object.class; try (InputStream is = new ByteBufInputStream(byteBuf, releaseOnParse); InputStreamReader reader = new InputStreamReader(is);) { return gson.fromJson(reader, type); @@ -68,8 +72,4 @@ public X apply(ByteBuf byteBuf) { } } - public Gson getGson() { - return gson; - } - } diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java index 6de96d4a..1d1352cc 100644 --- a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java @@ -10,6 +10,7 @@ import java.util.stream.Stream; import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; import io.netty.buffer.ByteBuf; import io.rsocket.RSocket; @@ -29,8 +30,7 @@ public static void main(String[] args) { RSocket rsocket = RSocketConnector.create().connect(TcpClientTransport.create("localhost", 7000)).block(); GsonMarshaller marshaller = new GsonMarshaller(gson); BiFunction deserializer = (t, bb) -> { - Object result = GsonUnmarshaller.apply(gson, new Type[] { t }, true, bb)[0]; - return result; + return GsonUnmarshaller.create(gson, t, false).apply(bb); }; TestServiceChannel client = RSocketIPCClients.create(Mono.just(rsocket), TestServiceChannel.class, new MetadataEncoderLFP(), v -> { diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java index c5296c12..62b50d26 100644 --- a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java @@ -34,8 +34,8 @@ public static void main(String[] args) throws InterruptedException { } boolean releaseOnParse = true; Gson gson = new Gson(); - requestHandler.register(classType, service, new GsonMarshaller(gson), (pt, bb, md) -> { - return GsonUnmarshaller.apply(gson, pt, true, bb); + requestHandler.register(classType, service, new GsonMarshaller(gson), (types, bb, md) -> { + return GsonUnmarshaller.create(gson, types, true).apply(bb); }); System.out.println("started"); while (true) { From 0b464613b9603c3907b76459dbef8bf478404f73 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 15:36:20 -0400 Subject: [PATCH 035/273] Update GsonUnmarshaller.java --- .../ipc/marshallers/GsonUnmarshaller.java | 34 ++++++++++++------- 1 file changed, 22 insertions(+), 12 deletions(-) diff --git a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java index 2fbb5b3b..e0429a46 100644 --- a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java +++ b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java @@ -31,20 +31,30 @@ public static GsonUnmarshaller create(Gson gson, Type type, boolean relea return new GsonUnmarshaller<>(bb -> parseUnchecked(gson, type, bb, releaseOnParse)); } - public static GsonUnmarshaller create(Gson gson, Type[] types, boolean releaseOnParse) { + public static GsonUnmarshaller create(Gson gson, Type[] types, boolean directOnSingleType, + boolean releaseOnParse) { Objects.requireNonNull(gson); Objects.requireNonNull(types); - return new GsonUnmarshaller<>(bb -> { - JsonArray jarr = parseUnchecked(gson, JsonArray.class, bb, releaseOnParse); - Object[] result = new Object[jarr.size()]; - for (int i = 0; i < jarr.size(); i++) { - Type type = types == null || types.length <= i ? null : types[i]; - if (type == null) - type = Object.class; - result[i] = gson.fromJson(jarr.get(i), type); - } - return result; - }); + if (types.length == 0) + throw new IllegalArgumentException("types are required"); + for (Type type : types) + Objects.requireNonNull(type); + Function parser; + if (directOnSingleType && types.length == 1) + parser = bb -> parseUnchecked(gson, types[0], bb, releaseOnParse); + else + parser = bb -> { + JsonArray jarr = parseUnchecked(gson, JsonArray.class, bb, releaseOnParse); + Object[] result = new Object[jarr.size()]; + for (int i = 0; i < jarr.size(); i++) { + Type type = types == null || types.length <= i ? null : types[i]; + if (type == null) + type = Object.class; + result[i] = gson.fromJson(jarr.get(i), type); + } + return result; + }; + return new GsonUnmarshaller<>(parser); } private final Function parser; From 92a8caa61397a32cf29ce20c95d22714a9b3795a Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 15:39:22 -0400 Subject: [PATCH 036/273] test --- .../src/main/java/io/rsocket/ipc/reflection/ServerTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java index 62b50d26..9e4481e5 100644 --- a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java @@ -35,7 +35,7 @@ public static void main(String[] args) throws InterruptedException { boolean releaseOnParse = true; Gson gson = new Gson(); requestHandler.register(classType, service, new GsonMarshaller(gson), (types, bb, md) -> { - return GsonUnmarshaller.create(gson, types, true).apply(bb); + return GsonUnmarshaller.create(gson, types, true, true).apply(bb); }); System.out.println("started"); while (true) { From 2ca7276b164616af0127d18b23fd1be18700d6cc Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 16:25:47 -0400 Subject: [PATCH 037/273] Argument serialization fix --- .../ipc/marshallers/GsonUnmarshaller.java | 29 +++---- .../reflection/client/RSocketIPCClients.java | 25 +++--- .../RequestHandlingRSocketReflection.java | 9 +-- .../io/rsocket/ipc/reflection/ServerTest.java | 5 +- .../ipc/reflection/TestServiceChannel.java | 76 ++++++++++++------- 5 files changed, 79 insertions(+), 65 deletions(-) diff --git a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java index e0429a46..8b2b1b1f 100644 --- a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java +++ b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java @@ -31,29 +31,24 @@ public static GsonUnmarshaller create(Gson gson, Type type, boolean relea return new GsonUnmarshaller<>(bb -> parseUnchecked(gson, type, bb, releaseOnParse)); } - public static GsonUnmarshaller create(Gson gson, Type[] types, boolean directOnSingleType, - boolean releaseOnParse) { + public static GsonUnmarshaller create(Gson gson, Type[] types, boolean releaseOnParse) { Objects.requireNonNull(gson); Objects.requireNonNull(types); if (types.length == 0) throw new IllegalArgumentException("types are required"); for (Type type : types) Objects.requireNonNull(type); - Function parser; - if (directOnSingleType && types.length == 1) - parser = bb -> parseUnchecked(gson, types[0], bb, releaseOnParse); - else - parser = bb -> { - JsonArray jarr = parseUnchecked(gson, JsonArray.class, bb, releaseOnParse); - Object[] result = new Object[jarr.size()]; - for (int i = 0; i < jarr.size(); i++) { - Type type = types == null || types.length <= i ? null : types[i]; - if (type == null) - type = Object.class; - result[i] = gson.fromJson(jarr.get(i), type); - } - return result; - }; + Function parser = bb -> { + JsonArray jarr = parseUnchecked(gson, JsonArray.class, bb, releaseOnParse); + Object[] result = new Object[jarr.size()]; + for (int i = 0; i < jarr.size(); i++) { + Type type = types == null || types.length <= i ? null : types[i]; + if (type == null) + type = Object.class; + result[i] = gson.fromJson(jarr.get(i), type); + } + return result; + }; return new GsonUnmarshaller<>(parser); } diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java index d6d7b836..229a79ce 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java @@ -35,9 +35,9 @@ public class RSocketIPCClients { public static X create(Mono rSocketMono, Class serviceType, MetadataEncoder metadataEncoder, - Marshaller marshaller, BiFunction returnDeserializer) { + Marshaller argumentMarshaller, BiFunction returnDeserializer) { try { - return createInternal(rSocketMono, serviceType, metadataEncoder, marshaller, returnDeserializer); + return createInternal(rSocketMono, serviceType, metadataEncoder, argumentMarshaller, returnDeserializer); } catch (NoSuchMethodException | IllegalArgumentException | InstantiationException | IllegalAccessException | InvocationTargetException e) { throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) @@ -48,12 +48,12 @@ public static X create(Mono rSocketMono, Class serviceType, Meta @SuppressWarnings("unchecked") protected static X createInternal(Mono rSocketMono, Class serviceType, - MetadataEncoder metadataEncoder, Marshaller marshaller, + MetadataEncoder metadataEncoder, Marshaller argumentMarshaller, BiFunction returnDeserializer) throws NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException { Objects.requireNonNull(rSocketMono); Objects.requireNonNull(serviceType); - Objects.requireNonNull(marshaller); + Objects.requireNonNull(argumentMarshaller); Objects.requireNonNull(returnDeserializer); Map mappedMethods = MethodMapUtils.getMappedMethods(serviceType, false); Map> ipcInvokerCache = new ConcurrentHashMap<>(); @@ -69,8 +69,8 @@ public Object invoke(Object self, Method thisMethod, Method proceed, Object[] ar .orElse(null); if (entry == null) return Optional.empty(); - return Optional.of(createIPCInvoker(serviceType, entry.getKey(), metadataEncoder, marshaller, - returnDeserializer, thisMethod)); + return Optional.of(createIPCInvoker(serviceType, entry.getKey(), metadataEncoder, + argumentMarshaller, returnDeserializer, thisMethod)); }); if (!ipcInvokerOp.isPresent()) throw new NoSuchMethodException(String.format( @@ -83,18 +83,21 @@ public Object invoke(Object self, Method thisMethod, Method proceed, Object[] ar @SuppressWarnings("unchecked") private static IPCInvoker createIPCInvoker(Class serviceType, String route, MetadataEncoder metadataEncoder, - Marshaller marshaller, BiFunction returnDeserializer, Method method) { - Function, Client> clientSupplier = rSocketMono -> { - Client client = Client.service(serviceType.getName()).rsocket(rSocketMono.block()) - .customMetadataEncoder(metadataEncoder).noMeterRegistry().noTracer().marshall(marshaller) + Marshaller argumentMarshaller, BiFunction returnDeserializer, + Method method) { + Function, Client> clientSupplier = rSocketMono -> { + Client client = Client.service(serviceType.getName()).rsocket(rSocketMono.block()) + .customMetadataEncoder(metadataEncoder).noMeterRegistry().noTracer().marshall(argumentMarshaller) .unmarshall(Bytes.byteBufUnmarshaller()); return client; }; Optional> returnPublisherConverterOp = PublisherConverters.lookup(method.getReturnType()); if (MethodMapUtils.getRequestChannelParameterType(method).isPresent()) { return (rSocketMono, args) -> { + Publisher objPublisher = (Publisher) args[0]; + Flux argArrayPublisher = Flux.from(objPublisher).map(v -> new Object[] { v }); Flux responsePublisher = clientSupplier.apply(rSocketMono).requestChannel(route) - .apply((Publisher) args[0]); + .apply(argArrayPublisher); return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), responsePublisher); }; diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java index 00a9d04a..308aef0f 100644 --- a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java +++ b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java @@ -131,11 +131,10 @@ private static boolean registerRequestChannel(S service, String route, PublisherConverter returnPublisherConverter = PublisherConverters.lookup(method.getReturnType()).get(); Type[] typeArguments = new Type[] { requestChannelParameterType.get() }; serviceBuilder.requestChannel(route, (first, publisher, md) -> { - Flux deserializedPublisher = Flux.from(publisher).map(bb -> { - Object[] payload = argumentDeserializer.apply(typeArguments, bb, md); - return payload[0]; - }); - Object result = invoke(service, method, new Object[] { deserializedPublisher }); + Flux argArrayPublisher = Flux.from(publisher) + .map(bb -> argumentDeserializer.apply(typeArguments, bb, md)); + Flux objPublisher = argArrayPublisher.map(arr -> arr[0]); + Object result = invoke(service, method, new Object[] { objPublisher }); return Flux.from(returnPublisherConverter.toPublisher(result)); }); return true; diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java index 9e4481e5..58d4648e 100644 --- a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java @@ -20,8 +20,7 @@ public class ServerTest { public static void main(String[] args) throws InterruptedException { Class classType = TestServiceChannel.class; - TestServiceChannel service = new TestServiceChannel() { - }; + TestServiceChannel service = new TestServiceChannel.Impl(); MetadataDecoderLFP decoder = new MetadataDecoderLFP(); RequestHandlingRSocketReflection requestHandler; { @@ -35,7 +34,7 @@ public static void main(String[] args) throws InterruptedException { boolean releaseOnParse = true; Gson gson = new Gson(); requestHandler.register(classType, service, new GsonMarshaller(gson), (types, bb, md) -> { - return GsonUnmarshaller.create(gson, types, true, true).apply(bb); + return GsonUnmarshaller.create(gson, types, true).apply(bb); }); System.out.println("started"); while (true) { diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/TestServiceChannel.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/TestServiceChannel.java index c2026345..7e82e29e 100644 --- a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/TestServiceChannel.java +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/TestServiceChannel.java @@ -11,40 +11,58 @@ public interface TestServiceChannel { - default Flux channel(Flux flux) { - return flux.map(d -> "the date is:" + d); - } + Flux channel(Flux flux); - default void msg(String msg) { - System.out.println("msg:" + msg); - } + void msg(String msg); - default Stream stream(String msg, Date date) { - return IntStream.range(0, 10).mapToObj(v -> v).map(v -> v + "- " + msg + " - " + date); - } + Stream stream(String msg, Date date); - default int add(int... args) { - int res = 0; - for (int arg : args) - res += arg; - return res; - } + int add(int... args); - default Flux intFlux(int... args) { - List argList = new ArrayList<>(); - for (int val : args) - argList.add(val); - return Flux.fromIterable(argList); - } + Flux intFlux(int... args); - default Mono addMono(int... args) { - int res = 0; - for (int arg : args) - res += arg; - return Mono.just(res); - } + Mono addMono(int... args); + + Stream cool(List vals, String msg); + + public static class Impl implements TestServiceChannel { + + public Flux channel(Flux flux) { + return flux.map(d -> "the date is:" + d); + } + + public void msg(String msg) { + System.out.println("msg:" + msg); + } + + public Stream stream(String msg, Date date) { + return IntStream.range(0, 10).mapToObj(v -> v).map(v -> v + "- " + msg + " - " + date); + } + + public int add(int... args) { + int res = 0; + for (int arg : args) + res += arg; + return res; + } + + public Flux intFlux(int... args) { + List argList = new ArrayList<>(); + for (int val : args) + argList.add(val); + return Flux.fromIterable(argList); + } + + public Mono addMono(int... args) { + int res = 0; + for (int arg : args) + res += arg; + return Mono.just(res); + } + + public Stream cool(List vals, String msg) { + return vals.stream().map(v -> msg + " " + v); + } - default Stream cool(List vals, String msg) { - return vals.stream().map(v -> msg + " " + v); } } From b46b6e9d1587e0587cc84c6c03d1e5ac90dc2069 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 16:36:25 -0400 Subject: [PATCH 038/273] marshall updates --- .../ipc/marshallers/GsonMarshaller.java | 18 +++++++++++------- .../io/rsocket/ipc/reflection/ClientTest.java | 3 +-- .../io/rsocket/ipc/reflection/ServerTest.java | 2 +- 3 files changed, 13 insertions(+), 10 deletions(-) diff --git a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java index 5501040e..c995b311 100644 --- a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java +++ b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonMarshaller.java @@ -11,22 +11,26 @@ import io.netty.buffer.ByteBufOutputStream; import io.rsocket.ipc.Marshaller; -public class GsonMarshaller implements Marshaller { +public class GsonMarshaller implements Marshaller { - private Gson gson; - private ByteBufAllocator allocator; + public static GsonMarshaller create(Gson gson) { + return create(gson, ByteBufAllocator.DEFAULT); + } - public GsonMarshaller(Gson gson) { - this(gson, ByteBufAllocator.DEFAULT); + public static GsonMarshaller create(Gson gson, ByteBufAllocator allocator) { + return new GsonMarshaller<>(gson, allocator); } - public GsonMarshaller(Gson gson, ByteBufAllocator allocator) { + private Gson gson; + private ByteBufAllocator allocator; + + protected GsonMarshaller(Gson gson, ByteBufAllocator allocator) { this.gson = Objects.requireNonNull(gson); this.allocator = Objects.requireNonNull(allocator); } @Override - public ByteBuf apply(Object object) { + public ByteBuf apply(X object) { ByteBuf buffer = allocator.buffer(); try (ByteBufOutputStream os = new ByteBufOutputStream(buffer); OutputStreamWriter writer = new OutputStreamWriter(os);) { diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java index 1d1352cc..ed9b4b86 100644 --- a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java @@ -28,13 +28,12 @@ public class ClientTest { public static void main(String[] args) { com.google.gson.Gson gson = new Gson(); RSocket rsocket = RSocketConnector.create().connect(TcpClientTransport.create("localhost", 7000)).block(); - GsonMarshaller marshaller = new GsonMarshaller(gson); BiFunction deserializer = (t, bb) -> { return GsonUnmarshaller.create(gson, t, false).apply(bb); }; TestServiceChannel client = RSocketIPCClients.create(Mono.just(rsocket), TestServiceChannel.class, new MetadataEncoderLFP(), v -> { - ByteBuf bb = marshaller.apply(v); + ByteBuf bb = GsonMarshaller.create(gson).apply(v); System.out.println(bb.toString(StandardCharsets.UTF_8)); return bb; }, deserializer); diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java index 58d4648e..7d566536 100644 --- a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java @@ -33,7 +33,7 @@ public static void main(String[] args) throws InterruptedException { } boolean releaseOnParse = true; Gson gson = new Gson(); - requestHandler.register(classType, service, new GsonMarshaller(gson), (types, bb, md) -> { + requestHandler.register(classType, service, GsonMarshaller.create(gson), (types, bb, md) -> { return GsonUnmarshaller.create(gson, types, true).apply(bb); }); System.out.println("started"); From 705f72093145907c49e0f4f28991b5572962428f Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 18:09:25 -0400 Subject: [PATCH 039/273] elastic to stream --- eclipse-clear.sh | 2 -- .../rsocket/ipc/reflection/core/PublisherConverter.java | 8 +++++--- 2 files changed, 5 insertions(+), 5 deletions(-) delete mode 100644 eclipse-clear.sh diff --git a/eclipse-clear.sh b/eclipse-clear.sh deleted file mode 100644 index c7229942..00000000 --- a/eclipse-clear.sh +++ /dev/null @@ -1,2 +0,0 @@ -find . -name "*.project" -type f -delete -find . -name "*.settings" -type d -print0 | xargs -0 /bin/rm -rf \ No newline at end of file diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java index ada52330..c9b0bd3e 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java @@ -11,6 +11,7 @@ import io.rsocket.ipc.util.IPCUtils; import reactor.core.publisher.Flux; +import reactor.core.scheduler.Schedulers; @SuppressWarnings({ "unchecked", "rawtypes" }) public interface PublisherConverter { @@ -51,7 +52,7 @@ protected Publisher toPublisherInternal(Stream input) { public Stream fromPublisher(Publisher publisher) { if (publisher == null) return Stream.empty(); - return Flux.from(publisher).toStream(); + return Flux.from(publisher).subscribeOn(Schedulers.elastic()).toStream(); } @Override @@ -77,7 +78,7 @@ protected Publisher toPublisherInternal(Iterator input) { public Iterator fromPublisher(Publisher publisher) { if (publisher == null) return Collections.emptyIterator(); - return Flux.from(publisher).toStream().iterator(); + return Flux.from(publisher).subscribeOn(Schedulers.elastic()).toStream().iterator(); } @Override @@ -105,7 +106,8 @@ public Iterable fromPublisher(Publisher publisher) { return Collections.emptyList(); Flux cachedFlux = Flux.from(publisher).cache(); Iterable ible = () -> { - Iterator iter = (Iterator) cachedFlux.toStream().iterator(); + Iterator iter = (Iterator) cachedFlux.subscribeOn(Schedulers.elastic()).toStream() + .iterator(); return iter; }; return ible != null ? ible : Collections.emptyList(); From de2e0bfc5744506870e564183f1e8694198fa8a2 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 18:16:04 -0400 Subject: [PATCH 040/273] Update PublisherConverter.java --- .../io/rsocket/ipc/reflection/core/PublisherConverter.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java index c9b0bd3e..6ee52508 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java @@ -71,7 +71,7 @@ static PublisherConverter> iterator() { @Override protected Publisher toPublisherInternal(Iterator input) { - return Flux.fromStream(IPCUtils.stream(input)); + return Flux.fromStream(IPCUtils.stream(input)).subscribeOn(Schedulers.elastic()); } @Override @@ -97,7 +97,7 @@ static PublisherConverter> iterable() { @Override protected Publisher toPublisherInternal(Iterable input) { - return Flux.fromStream(IPCUtils.stream(input.iterator())); + return Flux.fromStream(IPCUtils.stream(input.iterator())).subscribeOn(Schedulers.elastic()); } @Override @@ -110,7 +110,7 @@ public Iterable fromPublisher(Publisher publisher) { .iterator(); return iter; }; - return ible != null ? ible : Collections.emptyList(); + return ible; } @Override From d69bcacd43cac114eb81d6db8a5465f7d78a363a Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 23:08:00 -0400 Subject: [PATCH 041/273] Update PublisherConverter.java --- .../rsocket/ipc/reflection/core/PublisherConverter.java | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java index 6ee52508..7de60c08 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverter.java @@ -45,14 +45,14 @@ static PublisherConverter> stream() { @Override protected Publisher toPublisherInternal(Stream input) { - return Flux.fromStream(input); + return Flux.fromStream(input).subscribeOn(Schedulers.elastic()); } @Override public Stream fromPublisher(Publisher publisher) { if (publisher == null) return Stream.empty(); - return Flux.from(publisher).subscribeOn(Schedulers.elastic()).toStream(); + return Flux.from(publisher).toStream(); } @Override @@ -78,7 +78,7 @@ protected Publisher toPublisherInternal(Iterator input) { public Iterator fromPublisher(Publisher publisher) { if (publisher == null) return Collections.emptyIterator(); - return Flux.from(publisher).subscribeOn(Schedulers.elastic()).toStream().iterator(); + return Flux.from(publisher).toStream().iterator(); } @Override @@ -106,8 +106,7 @@ public Iterable fromPublisher(Publisher publisher) { return Collections.emptyList(); Flux cachedFlux = Flux.from(publisher).cache(); Iterable ible = () -> { - Iterator iter = (Iterator) cachedFlux.subscribeOn(Schedulers.elastic()).toStream() - .iterator(); + Iterator iter = (Iterator) cachedFlux.toStream().iterator(); return iter; }; return ible; From 7772d62a3b4fe00e2f84dc928590536484d59860 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 May 2020 23:53:25 -0400 Subject: [PATCH 042/273] disable retain slices --- .../main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java index 808be5f5..d85b9872 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataDecoderLFP.java @@ -43,7 +43,7 @@ public Disposable addInterceptor(MetadataDecoderLFP.Interceptor interceptor) { @Override public Metadata decode(ByteBuf metadataByteBuf) throws Exception { - MetadataReader metadataReader = new MetadataReader(metadataByteBuf, true); + MetadataReader metadataReader = new MetadataReader(metadataByteBuf, false); interceptors.forEach(v -> v.accept(metadataReader)); String route = getRoute(metadataReader); SpanContext spanContext = readTracingSpanContext(metadataReader); From 2c5171522746850a7879289fba7def3654d2d1b5 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 13 May 2020 00:37:16 -0400 Subject: [PATCH 043/273] defer wrapping --- .../RequestHandlingRSocketReflection.java | 41 ++++++++++++------- 1 file changed, 26 insertions(+), 15 deletions(-) diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java index 308aef0f..b84e56d6 100644 --- a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java +++ b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java @@ -97,8 +97,11 @@ private static void register(S service, String route, return; if (MethodMapUtils.isFireAndForget(method)) { serviceBuilder.fireAndForget(route, (data, md) -> { - invoke(service, method, argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); - return Mono.empty(); + Mono> mono = Mono.fromSupplier(() -> { + invoke(service, method, argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); + return Optional.empty(); + }); + return mono.filter(Optional::isPresent).map(Optional::get); }); return; } @@ -106,18 +109,24 @@ private static void register(S service, String route, .map(v -> v); if (returnPublisherConverter.isPresent() && !Mono.class.isAssignableFrom(method.getReturnType())) { serviceBuilder.requestStream(route, (data, md) -> { - Object result = invoke(service, method, - argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); - return Flux.from(returnPublisherConverter.get().toPublisher(result)); + return Flux.defer(() -> { + Object result = invoke(service, method, + argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); + return returnPublisherConverter.get().toPublisher(result); + }); }); return; } serviceBuilder.requestResponse(route, (data, md) -> { - Object result = invoke(service, method, - argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); - if (returnPublisherConverter.isPresent()) - return Mono.from(returnPublisherConverter.get().toPublisher(result)); - return Mono.just(result); + Mono> wrapped = Mono.fromSupplier(() -> { + Object result = invoke(service, method, + argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); + if (returnPublisherConverter.isPresent()) + return Mono.from(returnPublisherConverter.get().toPublisher(result)); + return Mono.just(result); + }); + Mono result = wrapped.flatMap(v -> v); + return result; }); } @@ -131,11 +140,13 @@ private static boolean registerRequestChannel(S service, String route, PublisherConverter returnPublisherConverter = PublisherConverters.lookup(method.getReturnType()).get(); Type[] typeArguments = new Type[] { requestChannelParameterType.get() }; serviceBuilder.requestChannel(route, (first, publisher, md) -> { - Flux argArrayPublisher = Flux.from(publisher) - .map(bb -> argumentDeserializer.apply(typeArguments, bb, md)); - Flux objPublisher = argArrayPublisher.map(arr -> arr[0]); - Object result = invoke(service, method, new Object[] { objPublisher }); - return Flux.from(returnPublisherConverter.toPublisher(result)); + return Flux.defer(() -> { + Flux argArrayPublisher = Flux.from(publisher) + .map(bb -> argumentDeserializer.apply(typeArguments, bb, md)); + Flux objPublisher = argArrayPublisher.map(arr -> arr[0]); + Object result = invoke(service, method, new Object[] { objPublisher }); + return returnPublisherConverter.toPublisher(result); + }); }); return true; } From f260894cfab7ee3e256abcc6ba4cd7c62fa475c4 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 13 May 2020 08:36:40 -0400 Subject: [PATCH 044/273] Update RequestHandlingRSocketReflection.java --- .../RequestHandlingRSocketReflection.java | 51 +++++++++++++++---- 1 file changed, 40 insertions(+), 11 deletions(-) diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java index b84e56d6..4c13a2dd 100644 --- a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java +++ b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java @@ -10,9 +10,12 @@ import java.util.Optional; import java.util.Set; import java.util.function.Function; +import java.util.function.Supplier; import java.util.logging.Level; import java.util.logging.Logger; +import org.reactivestreams.Publisher; + import io.netty.buffer.ByteBuf; import io.opentracing.Tracer; import io.rsocket.ipc.Marshaller; @@ -28,22 +31,27 @@ import io.rsocket.ipc.util.TriFunction; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; +import reactor.core.scheduler.Scheduler; public class RequestHandlingRSocketReflection extends RequestHandlingRSocket { private static final Class THIS_CLASS = new Object() { }.getClass().getEnclosingClass(); private static final Logger logger = java.util.logging.Logger.getLogger(THIS_CLASS.getName()); + private final Scheduler subscribeOnScheduler; - public RequestHandlingRSocketReflection() { + public RequestHandlingRSocketReflection(Scheduler subscribeOnScheduler) { super(); + this.subscribeOnScheduler = subscribeOnScheduler; } - public RequestHandlingRSocketReflection(MetadataDecoder decoder) { + public RequestHandlingRSocketReflection(Scheduler subscribeOnScheduler, MetadataDecoder decoder) { super(decoder); + this.subscribeOnScheduler = subscribeOnScheduler; } - public RequestHandlingRSocketReflection(Tracer tracer) { + public RequestHandlingRSocketReflection(Scheduler subscribeOnScheduler, Tracer tracer) { super(tracer); + this.subscribeOnScheduler = subscribeOnScheduler; } public void register(Class serviceType, S service, Marshaller resultMarshaller, @@ -89,19 +97,24 @@ private void register(S service, String serviceName, Marshaller resu this.withEndpoint(serviceBuilder.toIPCRSocket()); } + protected Mono toMono(Supplier object) { + // TODO Auto-generated method stub + return null; + } + @SuppressWarnings({ "unchecked", "rawtypes" }) - private static void register(S service, String route, + private void register(S service, String route, TriFunction argumentDeserializer, Method method, H serviceBuilder) { if (registerRequestChannel(service, route, argumentDeserializer, method, serviceBuilder)) return; if (MethodMapUtils.isFireAndForget(method)) { serviceBuilder.fireAndForget(route, (data, md) -> { - Mono> mono = Mono.fromSupplier(() -> { + Mono> mono = asMono(() -> { invoke(service, method, argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); - return Optional.empty(); + return Mono.empty(); }); - return mono.filter(Optional::isPresent).map(Optional::get); + return mono.flatMap(v -> v); }); return; } @@ -109,7 +122,7 @@ private static void register(S service, String route, .map(v -> v); if (returnPublisherConverter.isPresent() && !Mono.class.isAssignableFrom(method.getReturnType())) { serviceBuilder.requestStream(route, (data, md) -> { - return Flux.defer(() -> { + return asFlux(() -> { Object result = invoke(service, method, argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); return returnPublisherConverter.get().toPublisher(result); @@ -118,7 +131,7 @@ private static void register(S service, String route, return; } serviceBuilder.requestResponse(route, (data, md) -> { - Mono> wrapped = Mono.fromSupplier(() -> { + Mono> wrapped = asMono(() -> { Object result = invoke(service, method, argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); if (returnPublisherConverter.isPresent()) @@ -131,7 +144,7 @@ private static void register(S service, String route, } @SuppressWarnings({ "rawtypes", "unchecked" }) - private static boolean registerRequestChannel(S service, String route, + private boolean registerRequestChannel(S service, String route, TriFunction argumentDeserializer, Method method, H serviceBuilder) { Optional requestChannelParameterType = MethodMapUtils.getRequestChannelParameterType(method); @@ -140,7 +153,7 @@ private static boolean registerRequestChannel(S service, String route, PublisherConverter returnPublisherConverter = PublisherConverters.lookup(method.getReturnType()).get(); Type[] typeArguments = new Type[] { requestChannelParameterType.get() }; serviceBuilder.requestChannel(route, (first, publisher, md) -> { - return Flux.defer(() -> { + return asFlux(() -> { Flux argArrayPublisher = Flux.from(publisher) .map(bb -> argumentDeserializer.apply(typeArguments, bb, md)); Flux objPublisher = argArrayPublisher.map(arr -> arr[0]); @@ -151,6 +164,22 @@ private static boolean registerRequestChannel(S service, String route, return true; } + protected Flux asFlux(Supplier> supplier) { + Objects.requireNonNull(supplier); + Flux result = Flux.defer(supplier); + if (this.subscribeOnScheduler != null) + result = result.subscribeOn(this.subscribeOnScheduler); + return result; + } + + protected Mono asMono(Supplier supplier) { + Objects.requireNonNull(supplier); + Mono result = Mono.fromSupplier(supplier); + if (this.subscribeOnScheduler != null) + result = result.subscribeOn(this.subscribeOnScheduler); + return result; + } + private static Object invoke(S serivce, Method method, Object[] arguments) { try { return method.invoke(serivce, arguments); From 0f500e1e2c186a471bb34af823d276dd43ed7af0 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 13 May 2020 08:37:30 -0400 Subject: [PATCH 045/273] Update ServerTest.java --- .../src/main/java/io/rsocket/ipc/reflection/ServerTest.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java index 7d566536..490ff435 100644 --- a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java @@ -12,6 +12,7 @@ import io.rsocket.ipc.reflection.server.RequestHandlingRSocketReflection; import io.rsocket.transport.netty.server.TcpServerTransport; import reactor.core.publisher.Mono; +import reactor.core.scheduler.Schedulers; public class ServerTest { private static final Class THIS_CLASS = new Object() { @@ -24,7 +25,7 @@ public static void main(String[] args) throws InterruptedException { MetadataDecoderLFP decoder = new MetadataDecoderLFP(); RequestHandlingRSocketReflection requestHandler; { - requestHandler = new RequestHandlingRSocketReflection(new MetadataDecoderLFP()); + requestHandler = new RequestHandlingRSocketReflection(Schedulers.elastic(), new MetadataDecoderLFP()); SocketAcceptor socketAcceptor = (setup, client) -> Mono.just(requestHandler); RSocketServer.create(socketAcceptor).interceptors(ir -> { }).errorConsumer(t -> { From edbe5a23e496f0b9d1235e7710a2b99ac4fbb3ff Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 13 May 2020 08:45:01 -0400 Subject: [PATCH 046/273] Update RequestHandlingRSocketReflection.java --- .../reflection/server/RequestHandlingRSocketReflection.java | 5 ----- 1 file changed, 5 deletions(-) diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java index 4c13a2dd..3a310827 100644 --- a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java +++ b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java @@ -97,11 +97,6 @@ private void register(S service, String serviceName, Marshaller resu this.withEndpoint(serviceBuilder.toIPCRSocket()); } - protected Mono toMono(Supplier object) { - // TODO Auto-generated method stub - return null; - } - @SuppressWarnings({ "unchecked", "rawtypes" }) private void register(S service, String route, TriFunction argumentDeserializer, Method method, From d7a389669faafc9cf2519c6b536018fc1126e43a Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 13 May 2020 08:49:23 -0400 Subject: [PATCH 047/273] Check refcnt --- .../java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java index 8b2b1b1f..a209b21b 100644 --- a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java +++ b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java @@ -67,13 +67,15 @@ private static Y parseUnchecked(Gson gson, Type type, ByteBuf byteBuf, boole Objects.requireNonNull(gson); Objects.requireNonNull(byteBuf); type = type != null ? type : Object.class; - try (InputStream is = new ByteBufInputStream(byteBuf, releaseOnParse); - InputStreamReader reader = new InputStreamReader(is);) { + try (InputStream is = new ByteBufInputStream(byteBuf); InputStreamReader reader = new InputStreamReader(is);) { return gson.fromJson(reader, type); } catch (IOException e) { throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) ? java.lang.RuntimeException.class.cast(e) : new java.lang.RuntimeException(e); + } finally { + if (releaseOnParse && byteBuf.refCnt() > 0) + byteBuf.release(); } } From 9f3304486e8040fa18f4d26de6596494435f2bba Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 13 May 2020 09:23:52 -0400 Subject: [PATCH 048/273] Parse outside of subscribe on --- .../RequestHandlingRSocketReflection.java | 26 ++++++++++--------- 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java index 3a310827..56de6a62 100644 --- a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java +++ b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java @@ -105,11 +105,12 @@ private void register(S service, String route, return; if (MethodMapUtils.isFireAndForget(method)) { serviceBuilder.fireAndForget(route, (data, md) -> { - Mono> mono = asMono(() -> { - invoke(service, method, argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); + Object[] arguments = argumentDeserializer.apply(method.getGenericParameterTypes(), data, md); + Mono> wrappedMono = asMono(() -> { + invoke(service, method, arguments); return Mono.empty(); }); - return mono.flatMap(v -> v); + return wrappedMono.flatMap(v -> v); }); return; } @@ -117,24 +118,23 @@ private void register(S service, String route, .map(v -> v); if (returnPublisherConverter.isPresent() && !Mono.class.isAssignableFrom(method.getReturnType())) { serviceBuilder.requestStream(route, (data, md) -> { + Object[] arguments = argumentDeserializer.apply(method.getGenericParameterTypes(), data, md); return asFlux(() -> { - Object result = invoke(service, method, - argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); + Object result = invoke(service, method, arguments); return returnPublisherConverter.get().toPublisher(result); }); }); return; } serviceBuilder.requestResponse(route, (data, md) -> { - Mono> wrapped = asMono(() -> { - Object result = invoke(service, method, - argumentDeserializer.apply(method.getGenericParameterTypes(), data, md)); + Object[] arguments = argumentDeserializer.apply(method.getGenericParameterTypes(), data, md); + Mono> wrappedMono = asMono(() -> { + Object result = invoke(service, method, arguments); if (returnPublisherConverter.isPresent()) return Mono.from(returnPublisherConverter.get().toPublisher(result)); return Mono.just(result); }); - Mono result = wrapped.flatMap(v -> v); - return result; + return wrappedMono.flatMap(v -> v); }); } @@ -149,8 +149,10 @@ private boolean registerRequestChannel(S service, String route, Type[] typeArguments = new Type[] { requestChannelParameterType.get() }; serviceBuilder.requestChannel(route, (first, publisher, md) -> { return asFlux(() -> { - Flux argArrayPublisher = Flux.from(publisher) - .map(bb -> argumentDeserializer.apply(typeArguments, bb, md)); + Flux argArrayPublisher = Flux.from(publisher).map(bb -> { + Object[] argArray = argumentDeserializer.apply(typeArguments, bb, md); + return argArray; + }); Flux objPublisher = argArrayPublisher.map(arr -> arr[0]); Object result = invoke(service, method, new Object[] { objPublisher }); return returnPublisherConverter.toPublisher(result); From 273f000ea27c7f37b3d4f0f5930c24e53f793f02 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 13 May 2020 10:02:38 -0400 Subject: [PATCH 049/273] make rsocket mono a supplier --- .../ipc/reflection/client/IPCInvoker.java | 3 +- .../reflection/client/RSocketIPCClients.java | 75 ++++++++++++++++--- 2 files changed, 65 insertions(+), 13 deletions(-) diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/IPCInvoker.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/IPCInvoker.java index eb0c7513..50aede24 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/IPCInvoker.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/IPCInvoker.java @@ -1,9 +1,8 @@ package io.rsocket.ipc.reflection.client; import io.rsocket.RSocket; -import reactor.core.publisher.Mono; public interface IPCInvoker { - public Object invoke(Mono rSocketMono, Object[] args) throws Throwable; + public Object invoke(RSocket rSocket, Object[] args) throws Throwable; } diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java index 229a79ce..75242e1b 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java @@ -3,16 +3,23 @@ import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Type; +import java.time.Duration; import java.util.ArrayList; import java.util.Arrays; +import java.util.Date; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Objects; import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; import java.util.function.BiFunction; import java.util.function.Function; +import java.util.function.Supplier; +import java.util.logging.Logger; import java.util.stream.Stream; import org.reactivestreams.Publisher; @@ -33,6 +40,10 @@ import reactor.core.publisher.Mono; public class RSocketIPCClients { + private static final Class THIS_CLASS = new Object() { + }.getClass().getEnclosingClass(); + private static final Logger logger = java.util.logging.Logger.getLogger(THIS_CLASS.getName()); + protected static final Duration RSOCKET_SUPPLIER_WARN_DURATION = Duration.ofSeconds(10); public static X create(Mono rSocketMono, Class serviceType, MetadataEncoder metadataEncoder, Marshaller argumentMarshaller, BiFunction returnDeserializer) { @@ -57,6 +68,7 @@ protected static X createInternal(Mono rSocketMono, Class servic Objects.requireNonNull(returnDeserializer); Map mappedMethods = MethodMapUtils.getMappedMethods(serviceType, false); Map> ipcInvokerCache = new ConcurrentHashMap<>(); + Supplier rSocketSupplier = asRSocketSupplier(rSocketMono); return (X) proxyFactory(serviceType).create(new Class[] {}, new Object[] {}, new MethodHandler() { @Override @@ -75,48 +87,89 @@ public Object invoke(Object self, Method thisMethod, Method proceed, Object[] ar if (!ipcInvokerOp.isPresent()) throw new NoSuchMethodException(String.format( "could not map method in service. serviceType:%s method:%s", serviceType, thisMethod)); - return ipcInvokerOp.get().invoke(rSocketMono, args); + return ipcInvokerOp.get().invoke(rSocketSupplier.get(), args); } }); } + private static Supplier asRSocketSupplier(Mono rSocketMono) { + AtomicReference rSocketRef = new AtomicReference<>(); + CountDownLatch rSocketLatch = new CountDownLatch(1); + return new Supplier() { + + @Override + public RSocket get() { + if (rSocketRef.get() == null) + synchronized (rSocketRef) { + if (rSocketRef.get() == null) { + rSocketMono.subscribe(rs -> { + rSocketRef.set(rs); + if (rSocketLatch.getCount() > 0) + rSocketLatch.countDown(); + }); + rSocketLatchAwait(); + } + } + return rSocketRef.get(); + } + + private void rSocketLatchAwait() { + Date startAt = new Date(); + boolean success = false; + while (!success) { + try { + success = rSocketLatch.await(RSOCKET_SUPPLIER_WARN_DURATION.toMillis(), TimeUnit.MILLISECONDS); + } catch (InterruptedException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + if (!success) { + Duration elapsed = Duration.ofMillis(new Date().getTime() - startAt.getTime()); + logger.warning(String.format("awaiting rsocket. elapsed:%s", elapsed.toMillis())); + } + } + } + }; + } + @SuppressWarnings("unchecked") private static IPCInvoker createIPCInvoker(Class serviceType, String route, MetadataEncoder metadataEncoder, Marshaller argumentMarshaller, BiFunction returnDeserializer, Method method) { - Function, Client> clientSupplier = rSocketMono -> { - Client client = Client.service(serviceType.getName()).rsocket(rSocketMono.block()) + Function> clientSupplier = rSocket -> { + Client client = Client.service(serviceType.getName()).rsocket(rSocket) .customMetadataEncoder(metadataEncoder).noMeterRegistry().noTracer().marshall(argumentMarshaller) .unmarshall(Bytes.byteBufUnmarshaller()); return client; }; Optional> returnPublisherConverterOp = PublisherConverters.lookup(method.getReturnType()); if (MethodMapUtils.getRequestChannelParameterType(method).isPresent()) { - return (rSocketMono, args) -> { + return (rSocket, args) -> { Publisher objPublisher = (Publisher) args[0]; Flux argArrayPublisher = Flux.from(objPublisher).map(v -> new Object[] { v }); - Flux responsePublisher = clientSupplier.apply(rSocketMono).requestChannel(route) + Flux responsePublisher = clientSupplier.apply(rSocket).requestChannel(route) .apply(argArrayPublisher); return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), responsePublisher); }; } if (MethodMapUtils.isFireAndForget(method)) - return (rSocketMono, args) -> { - Mono result = clientSupplier.apply(rSocketMono).fireAndForget(route).apply(args); + return (rSocket, args) -> { + Mono result = clientSupplier.apply(rSocket).fireAndForget(route).apply(args); if (Mono.class.isAssignableFrom(method.getReturnType())) return result; return null; }; if (returnPublisherConverterOp.isPresent() && !Mono.class.isAssignableFrom(method.getReturnType())) - return (rSocketMono, args) -> { - Flux responsePublisher = clientSupplier.apply(rSocketMono).requestStream(route).apply(args); + return (rSocket, args) -> { + Flux responsePublisher = clientSupplier.apply(rSocket).requestStream(route).apply(args); return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), responsePublisher); }; - return (rSocketMono, args) -> { - Mono responsePublisher = clientSupplier.apply(rSocketMono).requestResponse(route).apply(args); + return (rSocket, args) -> { + Mono responsePublisher = clientSupplier.apply(rSocket).requestResponse(route).apply(args); if (returnPublisherConverterOp.isPresent()) return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), responsePublisher); From 491aafee266e758aa66d4510f353d79bcfdff4e0 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 13 May 2020 10:24:31 -0400 Subject: [PATCH 050/273] make client rsocket lazy --- .../ipc/reflection/client/IPCInvoker.java | 4 +- .../ipc/reflection/client/LazyRSocket.java | 87 +++++++++++++++++++ .../reflection/client/RSocketIPCClients.java | 84 ++++-------------- 3 files changed, 104 insertions(+), 71 deletions(-) create mode 100644 rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/IPCInvoker.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/IPCInvoker.java index 50aede24..82848bfe 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/IPCInvoker.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/IPCInvoker.java @@ -1,8 +1,6 @@ package io.rsocket.ipc.reflection.client; -import io.rsocket.RSocket; - public interface IPCInvoker { - public Object invoke(RSocket rSocket, Object[] args) throws Throwable; + public Object invoke(Object[] args) throws Throwable; } diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java new file mode 100644 index 00000000..1bd0d876 --- /dev/null +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java @@ -0,0 +1,87 @@ +package io.rsocket.ipc.reflection.client; + +import java.util.Objects; +import java.util.function.Supplier; + +import org.reactivestreams.Publisher; + +import io.rsocket.Payload; +import io.rsocket.RSocket; +import io.rsocket.ResponderRSocket; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +public abstract class LazyRSocket implements ResponderRSocket { + + public static LazyRSocket create(Mono rsocketMono) { + Objects.requireNonNull(rsocketMono); + return create(() -> rsocketMono.block()); + } + + public static LazyRSocket create(Supplier rsocketSupplier) { + Objects.requireNonNull(rsocketSupplier); + return new LazyRSocket() { + + @Override + protected RSocket getRSocket() { + return rsocketSupplier.get(); + } + }; + } + + protected abstract RSocket getRSocket(); + + @Override + public Mono fireAndForget(Payload payload) { + return getRSocket().fireAndForget(payload); + } + + @Override + public Mono requestResponse(Payload payload) { + return getRSocket().requestResponse(payload); + } + + @Override + public Flux requestStream(Payload payload) { + return getRSocket().requestStream(payload); + } + + @Override + public Flux requestChannel(Publisher payloads) { + return getRSocket().requestChannel(payloads); + } + + @Override + public Flux requestChannel(Payload payload, Publisher payloads) { + RSocket rSocket = getRSocket(); + if (rSocket instanceof ResponderRSocket) + return ((ResponderRSocket) rSocket).requestChannel(payload, payloads); + return rSocket.requestChannel(payloads); + } + + @Override + public Mono metadataPush(Payload payload) { + return getRSocket().metadataPush(payload); + } + + @Override + public double availability() { + return getRSocket().availability(); + } + + @Override + public Mono onClose() { + return getRSocket().onClose(); + } + + @Override + public void dispose() { + getRSocket().dispose(); + } + + @Override + public boolean isDisposed() { + return getRSocket().isDisposed(); + } + +} diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java index 75242e1b..bb342135 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java @@ -6,19 +6,13 @@ import java.time.Duration; import java.util.ArrayList; import java.util.Arrays; -import java.util.Date; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Objects; import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicReference; import java.util.function.BiFunction; -import java.util.function.Function; -import java.util.function.Supplier; import java.util.logging.Logger; import java.util.stream.Stream; @@ -67,8 +61,10 @@ protected static X createInternal(Mono rSocketMono, Class servic Objects.requireNonNull(argumentMarshaller); Objects.requireNonNull(returnDeserializer); Map mappedMethods = MethodMapUtils.getMappedMethods(serviceType, false); + Client client = Client.service(serviceType.getName()) + .rsocket(LazyRSocket.create(rSocketMono)).customMetadataEncoder(metadataEncoder).noMeterRegistry() + .noTracer().marshall(argumentMarshaller).unmarshall(Bytes.byteBufUnmarshaller()); Map> ipcInvokerCache = new ConcurrentHashMap<>(); - Supplier rSocketSupplier = asRSocketSupplier(rSocketMono); return (X) proxyFactory(serviceType).create(new Class[] {}, new Object[] {}, new MethodHandler() { @Override @@ -81,95 +77,47 @@ public Object invoke(Object self, Method thisMethod, Method proceed, Object[] ar .orElse(null); if (entry == null) return Optional.empty(); - return Optional.of(createIPCInvoker(serviceType, entry.getKey(), metadataEncoder, + return Optional.of(createIPCInvoker(client, serviceType, entry.getKey(), metadataEncoder, argumentMarshaller, returnDeserializer, thisMethod)); }); if (!ipcInvokerOp.isPresent()) throw new NoSuchMethodException(String.format( "could not map method in service. serviceType:%s method:%s", serviceType, thisMethod)); - return ipcInvokerOp.get().invoke(rSocketSupplier.get(), args); + return ipcInvokerOp.get().invoke(args); } }); } - private static Supplier asRSocketSupplier(Mono rSocketMono) { - AtomicReference rSocketRef = new AtomicReference<>(); - CountDownLatch rSocketLatch = new CountDownLatch(1); - return new Supplier() { - - @Override - public RSocket get() { - if (rSocketRef.get() == null) - synchronized (rSocketRef) { - if (rSocketRef.get() == null) { - rSocketMono.subscribe(rs -> { - rSocketRef.set(rs); - if (rSocketLatch.getCount() > 0) - rSocketLatch.countDown(); - }); - rSocketLatchAwait(); - } - } - return rSocketRef.get(); - } - - private void rSocketLatchAwait() { - Date startAt = new Date(); - boolean success = false; - while (!success) { - try { - success = rSocketLatch.await(RSOCKET_SUPPLIER_WARN_DURATION.toMillis(), TimeUnit.MILLISECONDS); - } catch (InterruptedException e) { - throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) - ? java.lang.RuntimeException.class.cast(e) - : new java.lang.RuntimeException(e); - } - if (!success) { - Duration elapsed = Duration.ofMillis(new Date().getTime() - startAt.getTime()); - logger.warning(String.format("awaiting rsocket. elapsed:%s", elapsed.toMillis())); - } - } - } - }; - } - @SuppressWarnings("unchecked") - private static IPCInvoker createIPCInvoker(Class serviceType, String route, MetadataEncoder metadataEncoder, - Marshaller argumentMarshaller, BiFunction returnDeserializer, - Method method) { - Function> clientSupplier = rSocket -> { - Client client = Client.service(serviceType.getName()).rsocket(rSocket) - .customMetadataEncoder(metadataEncoder).noMeterRegistry().noTracer().marshall(argumentMarshaller) - .unmarshall(Bytes.byteBufUnmarshaller()); - return client; - }; + private static IPCInvoker createIPCInvoker(Client client, Class serviceType, String route, + MetadataEncoder metadataEncoder, Marshaller argumentMarshaller, + BiFunction returnDeserializer, Method method) { Optional> returnPublisherConverterOp = PublisherConverters.lookup(method.getReturnType()); if (MethodMapUtils.getRequestChannelParameterType(method).isPresent()) { - return (rSocket, args) -> { + return (args) -> { Publisher objPublisher = (Publisher) args[0]; Flux argArrayPublisher = Flux.from(objPublisher).map(v -> new Object[] { v }); - Flux responsePublisher = clientSupplier.apply(rSocket).requestChannel(route) - .apply(argArrayPublisher); + Flux responsePublisher = client.requestChannel(route).apply(argArrayPublisher); return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), responsePublisher); }; } if (MethodMapUtils.isFireAndForget(method)) - return (rSocket, args) -> { - Mono result = clientSupplier.apply(rSocket).fireAndForget(route).apply(args); + return (args) -> { + Mono result = client.fireAndForget(route).apply(args); if (Mono.class.isAssignableFrom(method.getReturnType())) return result; return null; }; if (returnPublisherConverterOp.isPresent() && !Mono.class.isAssignableFrom(method.getReturnType())) - return (rSocket, args) -> { - Flux responsePublisher = clientSupplier.apply(rSocket).requestStream(route).apply(args); + return (args) -> { + Flux responsePublisher = client.requestStream(route).apply(args); return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), responsePublisher); }; - return (rSocket, args) -> { - Mono responsePublisher = clientSupplier.apply(rSocket).requestResponse(route).apply(args); + return (args) -> { + Mono responsePublisher = client.requestResponse(route).apply(args); if (returnPublisherConverterOp.isPresent()) return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), responsePublisher); From ed379db5cfd821b570eef6c8df2d40ddcf0dd536 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 13 May 2020 10:45:10 -0400 Subject: [PATCH 051/273] disable releasing during unmarshall --- publishToMavenLocal.sh | 1 + .../ipc/marshallers/GsonUnmarshaller.java | 23 ++++++++++--------- .../io/rsocket/ipc/reflection/ClientTest.java | 2 +- .../io/rsocket/ipc/reflection/ServerTest.java | 2 +- 4 files changed, 15 insertions(+), 13 deletions(-) create mode 100644 publishToMavenLocal.sh diff --git a/publishToMavenLocal.sh b/publishToMavenLocal.sh new file mode 100644 index 00000000..94f58256 --- /dev/null +++ b/publishToMavenLocal.sh @@ -0,0 +1 @@ +./gradlew build publishToMavenLocal -x test -x verifyGoogleJavaFormat -c settings.jitpack.gradle diff --git a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java index a209b21b..357fccba 100644 --- a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java +++ b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java @@ -17,21 +17,21 @@ public class GsonUnmarshaller implements Unmarshaller { - public static GsonUnmarshaller create(Gson gson, TypeToken typeToken, boolean releaseOnParse) { - return create(gson, typeToken == null ? null : typeToken.getType(), releaseOnParse); + public static GsonUnmarshaller create(Gson gson, TypeToken typeToken) { + return create(gson, typeToken == null ? null : typeToken.getType()); } - public static GsonUnmarshaller create(Gson gson, Class classType, boolean releaseOnParse) { - return create(gson, (Type) classType, releaseOnParse); + public static GsonUnmarshaller create(Gson gson, Class classType) { + return create(gson, (Type) classType); } - public static GsonUnmarshaller create(Gson gson, Type type, boolean releaseOnParse) { + public static GsonUnmarshaller create(Gson gson, Type type) { Objects.requireNonNull(gson); Objects.requireNonNull(type); - return new GsonUnmarshaller<>(bb -> parseUnchecked(gson, type, bb, releaseOnParse)); + return new GsonUnmarshaller<>(bb -> parseUnchecked(gson, type, bb)); } - public static GsonUnmarshaller create(Gson gson, Type[] types, boolean releaseOnParse) { + public static GsonUnmarshaller create(Gson gson, Type[] types) { Objects.requireNonNull(gson); Objects.requireNonNull(types); if (types.length == 0) @@ -39,7 +39,7 @@ public static GsonUnmarshaller create(Gson gson, Type[] types, boolean for (Type type : types) Objects.requireNonNull(type); Function parser = bb -> { - JsonArray jarr = parseUnchecked(gson, JsonArray.class, bb, releaseOnParse); + JsonArray jarr = parseUnchecked(gson, JsonArray.class, bb); Object[] result = new Object[jarr.size()]; for (int i = 0; i < jarr.size(); i++) { Type type = types == null || types.length <= i ? null : types[i]; @@ -63,7 +63,7 @@ public X apply(ByteBuf byteBuf) { return parser.apply(byteBuf); } - private static Y parseUnchecked(Gson gson, Type type, ByteBuf byteBuf, boolean releaseOnParse) { + private static Y parseUnchecked(Gson gson, Type type, ByteBuf byteBuf) { Objects.requireNonNull(gson); Objects.requireNonNull(byteBuf); type = type != null ? type : Object.class; @@ -74,8 +74,9 @@ private static Y parseUnchecked(Gson gson, Type type, ByteBuf byteBuf, boole ? java.lang.RuntimeException.class.cast(e) : new java.lang.RuntimeException(e); } finally { - if (releaseOnParse && byteBuf.refCnt() > 0) - byteBuf.release(); + // DO NOT RELEASE THE PAYLOAD, I BELIEVE THAT THIS BREAKDS RSOCKET RPC JAVA + // if (releaseOnParse && byteBuf.refCnt() > 0) + // byteBuf.release(); } } diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java index ed9b4b86..32688e13 100644 --- a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java @@ -29,7 +29,7 @@ public static void main(String[] args) { com.google.gson.Gson gson = new Gson(); RSocket rsocket = RSocketConnector.create().connect(TcpClientTransport.create("localhost", 7000)).block(); BiFunction deserializer = (t, bb) -> { - return GsonUnmarshaller.create(gson, t, false).apply(bb); + return GsonUnmarshaller.create(gson, t).apply(bb); }; TestServiceChannel client = RSocketIPCClients.create(Mono.just(rsocket), TestServiceChannel.class, new MetadataEncoderLFP(), v -> { diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java index 490ff435..80d46beb 100644 --- a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java @@ -35,7 +35,7 @@ public static void main(String[] args) throws InterruptedException { boolean releaseOnParse = true; Gson gson = new Gson(); requestHandler.register(classType, service, GsonMarshaller.create(gson), (types, bb, md) -> { - return GsonUnmarshaller.create(gson, types, true).apply(bb); + return GsonUnmarshaller.create(gson, types).apply(bb); }); System.out.println("started"); while (true) { From 2e01aacce565d4f6329f7e560c8bd4578bad6c93 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 13 May 2020 16:52:34 -0400 Subject: [PATCH 052/273] remeved all reference count manipulation minus metadata on channels --- publishToMavenLocal.sh | 4 +- .../java/io/rsocket/ipc/util/IPCUtils.java | 50 +++++++++++++++ .../ipc/marshallers/GsonUnmarshaller.java | 25 +++++--- .../reflection/client/RSocketIPCClients.java | 8 +-- .../RequestHandlingRSocketReflection.java | 62 +++++++++++++------ 5 files changed, 117 insertions(+), 32 deletions(-) diff --git a/publishToMavenLocal.sh b/publishToMavenLocal.sh index 94f58256..f3edca34 100644 --- a/publishToMavenLocal.sh +++ b/publishToMavenLocal.sh @@ -1 +1,3 @@ -./gradlew build publishToMavenLocal -x test -x verifyGoogleJavaFormat -c settings.jitpack.gradle +NOW=$(date +%s) +echo "versionSuffix: -$NOW" +./gradlew build publishToMavenLocal -x test -x verifyGoogleJavaFormat -c settings.jitpack.gradle -PversionSuffix="-$NOW" "$@" diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java index 00d02dbb..58a5d978 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java @@ -20,12 +20,14 @@ import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.atomic.AtomicReference; import java.util.function.Consumer; +import java.util.function.Supplier; import java.util.stream.Collectors; import java.util.stream.Stream; import java.util.stream.StreamSupport; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; +import io.netty.util.ReferenceCounted; import io.rsocket.metadata.WellKnownMimeType; import reactor.core.Disposable; import reactor.core.Disposables; @@ -33,6 +35,53 @@ public class IPCUtils { public static final Charset CHARSET = StandardCharsets.UTF_8; + public static X releaseOnError(Supplier supplier, ReferenceCounted referenceCounted) { + return releaseOnError(supplier, referenceCounted, false); + } + + public static X releaseOnError(Supplier supplier, ReferenceCounted referenceCounted, + boolean releaseOnZeroRefCnt) { + Objects.requireNonNull(referenceCounted); + return onError(supplier, () -> { + if (releaseOnZeroRefCnt || referenceCounted.refCnt() > 0) + referenceCounted.release(); + }); + } + + public static X onError(Supplier supplier, Runnable callback) { + Objects.requireNonNull(supplier); + try { + return supplier.get(); + } catch (Throwable t) { + callback.run(); + throw java.lang.RuntimeException.class.isAssignableFrom(t.getClass()) + ? java.lang.RuntimeException.class.cast(t) + : new java.lang.RuntimeException(t); + } + } + + public static X releaseOnFinally(Supplier supplier, ReferenceCounted referenceCounted) { + return releaseOnError(supplier, referenceCounted, false); + } + + public static X releaseOnFinally(Supplier supplier, ReferenceCounted referenceCounted, + boolean releaseOnZeroRefCnt) { + Objects.requireNonNull(referenceCounted); + return onFinally(supplier, () -> { + if (releaseOnZeroRefCnt || referenceCounted.refCnt() > 0) + referenceCounted.release(); + }); + } + + public static X onFinally(Supplier supplier, Runnable callback) { + Objects.requireNonNull(supplier); + try { + return supplier.get(); + } finally { + callback.run(); + } + } + public static Stream stream(Iterator iterator) { if (iterator == null) return Stream.empty(); @@ -208,4 +257,5 @@ public Disposable disposableAdd(X value) { return disposable; } } + } diff --git a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java index 357fccba..cde83bb0 100644 --- a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java +++ b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java @@ -1,11 +1,13 @@ package io.rsocket.ipc.marshallers; +import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.lang.reflect.Type; import java.util.Objects; import java.util.function.Function; +import java.util.function.Supplier; import com.google.gson.Gson; import com.google.gson.JsonArray; @@ -28,7 +30,7 @@ public static GsonUnmarshaller create(Gson gson, Class classType) { public static GsonUnmarshaller create(Gson gson, Type type) { Objects.requireNonNull(gson); Objects.requireNonNull(type); - return new GsonUnmarshaller<>(bb -> parseUnchecked(gson, type, bb)); + return new GsonUnmarshaller<>(isSupplier -> parseUnchecked(gson, type, isSupplier)); } public static GsonUnmarshaller create(Gson gson, Type[] types) { @@ -38,8 +40,8 @@ public static GsonUnmarshaller create(Gson gson, Type[] types) { throw new IllegalArgumentException("types are required"); for (Type type : types) Objects.requireNonNull(type); - Function parser = bb -> { - JsonArray jarr = parseUnchecked(gson, JsonArray.class, bb); + Function, Object[]> parser = isSupplier -> { + JsonArray jarr = parseUnchecked(gson, JsonArray.class, isSupplier); Object[] result = new Object[jarr.size()]; for (int i = 0; i < jarr.size(); i++) { Type type = types == null || types.length <= i ? null : types[i]; @@ -52,22 +54,27 @@ public static GsonUnmarshaller create(Gson gson, Type[] types) { return new GsonUnmarshaller<>(parser); } - private final Function parser; + private final Function, X> parser; - protected GsonUnmarshaller(Function parser) { + protected GsonUnmarshaller(Function, X> parser) { this.parser = Objects.requireNonNull(parser); } @Override public X apply(ByteBuf byteBuf) { - return parser.apply(byteBuf); + return parser.apply(() -> new ByteBufInputStream(byteBuf)); } - private static Y parseUnchecked(Gson gson, Type type, ByteBuf byteBuf) { + public X apply(byte[] byteArray) { + Objects.requireNonNull(byteArray); + return parser.apply(() -> new ByteArrayInputStream(byteArray)); + } + + private static Y parseUnchecked(Gson gson, Type type, Supplier inputStreamSupplier) { Objects.requireNonNull(gson); - Objects.requireNonNull(byteBuf); + Objects.requireNonNull(inputStreamSupplier); type = type != null ? type : Object.class; - try (InputStream is = new ByteBufInputStream(byteBuf); InputStreamReader reader = new InputStreamReader(is);) { + try (InputStream is = inputStreamSupplier.get(); InputStreamReader reader = new InputStreamReader(is);) { return gson.fromJson(reader, type); } catch (IOException e) { throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java index bb342135..e4cc8060 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java @@ -133,13 +133,13 @@ private static Object returnFromResponsePublisher(Method method, .orElse(Object.class); Publisher resultPublisher; if (Mono.class.isAssignableFrom(method.getReturnType())) - resultPublisher = Mono.from(responsePublisher).map(v -> { - Object deserialized = returnDeserializer.apply(typeArgument, v); + resultPublisher = Mono.from(responsePublisher).map(bb -> { + Object deserialized = returnDeserializer.apply(typeArgument, bb); return deserialized; }); else - resultPublisher = Flux.from(responsePublisher).map(v -> { - Object deserialized = returnDeserializer.apply(typeArgument, v); + resultPublisher = Flux.from(responsePublisher).map(bb -> { + Object deserialized = returnDeserializer.apply(typeArgument, bb); return deserialized; }); Object result = returnPublisherConverter.fromPublisher(resultPublisher); diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java index 56de6a62..bf89eb02 100644 --- a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java +++ b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java @@ -9,6 +9,7 @@ import java.util.Objects; import java.util.Optional; import java.util.Set; +import java.util.concurrent.atomic.AtomicReference; import java.util.function.Function; import java.util.function.Supplier; import java.util.logging.Level; @@ -28,6 +29,7 @@ import io.rsocket.ipc.reflection.core.MethodMapUtils; import io.rsocket.ipc.reflection.core.PublisherConverter; import io.rsocket.ipc.reflection.core.PublisherConverters; +import io.rsocket.ipc.util.IPCUtils; import io.rsocket.ipc.util.TriFunction; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; @@ -86,13 +88,17 @@ public void register(Class serviceType, S service, Marshaller res private void register(S service, String serviceName, Marshaller resultMarshaller, TriFunction argumentDeserializer, Map methodMapping) { + // wrap the deserializer so that it counts down references + TriFunction releasingArgumentDeserializer = (types, data, md) -> { + return IPCUtils.releaseOnFinally(() -> argumentDeserializer.apply(types, data, md), data); + }; H serviceBuilder = Server.service(serviceName).noMeterRegistry().noTracer() .marshall(resultMarshaller).unmarshall(Bytes.byteBufUnmarshaller()); methodMapping.entrySet().forEach(ent -> { String route = ent.getKey(); logger.log(Level.FINE, String.format("registering request handler. serviceName:%s route:%s", serviceName, route)); - register(service, route, argumentDeserializer, ent.getValue(), serviceBuilder); + register(service, route, releasingArgumentDeserializer, ent.getValue(), serviceBuilder); }); this.withEndpoint(serviceBuilder.toIPCRSocket()); } @@ -109,7 +115,7 @@ private void register(S service, String route, Mono> wrappedMono = asMono(() -> { invoke(service, method, arguments); return Mono.empty(); - }); + }, this.subscribeOnScheduler); return wrappedMono.flatMap(v -> v); }); return; @@ -122,7 +128,7 @@ private void register(S service, String route, return asFlux(() -> { Object result = invoke(service, method, arguments); return returnPublisherConverter.get().toPublisher(result); - }); + }, this.subscribeOnScheduler); }); return; } @@ -133,7 +139,7 @@ private void register(S service, String route, if (returnPublisherConverter.isPresent()) return Mono.from(returnPublisherConverter.get().toPublisher(result)); return Mono.just(result); - }); + }, this.subscribeOnScheduler); return wrappedMono.flatMap(v -> v); }); } @@ -148,32 +154,39 @@ private boolean registerRequestChannel(S service, String route, PublisherConverter returnPublisherConverter = PublisherConverters.lookup(method.getReturnType()).get(); Type[] typeArguments = new Type[] { requestChannelParameterType.get() }; serviceBuilder.requestChannel(route, (first, publisher, md) -> { - return asFlux(() -> { + md.retain(); + Runnable mdRelease = () -> { + if (md.refCnt() > 0) + md.release(); + }; + return IPCUtils.onError(() -> { Flux argArrayPublisher = Flux.from(publisher).map(bb -> { Object[] argArray = argumentDeserializer.apply(typeArguments, bb, md); return argArray; }); Flux objPublisher = argArrayPublisher.map(arr -> arr[0]); - Object result = invoke(service, method, new Object[] { objPublisher }); - return returnPublisherConverter.toPublisher(result); - }); + return asFlux(() -> { + Object result = invoke(service, method, new Object[] { objPublisher }); + return returnPublisherConverter.toPublisher(result); + }, this.subscribeOnScheduler).doOnTerminate(mdRelease); + }, mdRelease); }); return true; } - protected Flux asFlux(Supplier> supplier) { - Objects.requireNonNull(supplier); - Flux result = Flux.defer(supplier); - if (this.subscribeOnScheduler != null) - result = result.subscribeOn(this.subscribeOnScheduler); + private static Flux asFlux(Supplier> supplier, Scheduler scheduler) { + Supplier> memoizedSupplier = memoized(supplier); + Flux result = Flux.defer(memoizedSupplier); + if (scheduler != null) + result = result.subscribeOn(scheduler); return result; } - protected Mono asMono(Supplier supplier) { - Objects.requireNonNull(supplier); - Mono result = Mono.fromSupplier(supplier); - if (this.subscribeOnScheduler != null) - result = result.subscribeOn(this.subscribeOnScheduler); + private static Mono asMono(Supplier supplier, Scheduler scheduler) { + Supplier memoizedSupplier = memoized(supplier); + Mono result = Mono.fromSupplier(memoizedSupplier); + if (scheduler != null) + result = result.subscribeOn(scheduler); return result; } @@ -187,4 +200,17 @@ private static Object invoke(S serivce, Method method, Object[] arguments) { } } + private static Supplier memoized(Supplier supplier) { + Objects.requireNonNull(supplier); + AtomicReference> ref = new AtomicReference<>(); + return () -> { + if (ref.get() == null) + synchronized (ref) { + if (ref.get() == null) + ref.set(Optional.ofNullable(supplier.get())); + } + return ref.get().orElse(null); + }; + } + } From f3f074ae6bba1f5a6b3c9a268888c96bc0352fe3 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 13 May 2020 19:13:57 -0400 Subject: [PATCH 053/273] reader --- .../ipc/marshallers/GsonUnmarshaller.java | 27 ++++++------------- 1 file changed, 8 insertions(+), 19 deletions(-) diff --git a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java index cde83bb0..d19403d6 100644 --- a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java +++ b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java @@ -1,13 +1,11 @@ package io.rsocket.ipc.marshallers; -import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.lang.reflect.Type; import java.util.Objects; import java.util.function.Function; -import java.util.function.Supplier; import com.google.gson.Gson; import com.google.gson.JsonArray; @@ -40,8 +38,8 @@ public static GsonUnmarshaller create(Gson gson, Type[] types) { throw new IllegalArgumentException("types are required"); for (Type type : types) Objects.requireNonNull(type); - Function, Object[]> parser = isSupplier -> { - JsonArray jarr = parseUnchecked(gson, JsonArray.class, isSupplier); + Function parser = bb -> { + JsonArray jarr = parseUnchecked(gson, JsonArray.class, bb); Object[] result = new Object[jarr.size()]; for (int i = 0; i < jarr.size(); i++) { Type type = types == null || types.length <= i ? null : types[i]; @@ -54,36 +52,27 @@ public static GsonUnmarshaller create(Gson gson, Type[] types) { return new GsonUnmarshaller<>(parser); } - private final Function, X> parser; + private final Function parser; - protected GsonUnmarshaller(Function, X> parser) { + protected GsonUnmarshaller(Function parser) { this.parser = Objects.requireNonNull(parser); } @Override public X apply(ByteBuf byteBuf) { - return parser.apply(() -> new ByteBufInputStream(byteBuf)); + return parser.apply(byteBuf); } - public X apply(byte[] byteArray) { - Objects.requireNonNull(byteArray); - return parser.apply(() -> new ByteArrayInputStream(byteArray)); - } - - private static Y parseUnchecked(Gson gson, Type type, Supplier inputStreamSupplier) { + private static Y parseUnchecked(Gson gson, Type type, ByteBuf byteBuf) { Objects.requireNonNull(gson); - Objects.requireNonNull(inputStreamSupplier); + Objects.requireNonNull(byteBuf); type = type != null ? type : Object.class; - try (InputStream is = inputStreamSupplier.get(); InputStreamReader reader = new InputStreamReader(is);) { + try (InputStream is = new ByteBufInputStream(byteBuf); InputStreamReader reader = new InputStreamReader(is);) { return gson.fromJson(reader, type); } catch (IOException e) { throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) ? java.lang.RuntimeException.class.cast(e) : new java.lang.RuntimeException(e); - } finally { - // DO NOT RELEASE THE PAYLOAD, I BELIEVE THAT THIS BREAKDS RSOCKET RPC JAVA - // if (releaseOnParse && byteBuf.refCnt() > 0) - // byteBuf.release(); } } From 680cafdf927b79dbb43ec7dd4517d712b3685309 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 13 May 2020 21:28:58 -0400 Subject: [PATCH 054/273] per route marshall/unmarshall --- .../java/io/rsocket/ipc/util/IPCUtils.java | 35 --- .../java/io/rsocket/ipc/MultiServiceTest.java | 171 +++++++++++++++ .../reflection/client/RSocketIPCClients.java | 81 ++++--- .../RequestHandlingRSocketReflection.java | 203 ++++++++++-------- .../io/rsocket/ipc/reflection/ClientTest.java | 1 - .../io/rsocket/ipc/reflection/ServerTest.java | 2 +- 6 files changed, 343 insertions(+), 150 deletions(-) create mode 100644 rsocket-ipc-core/src/test/java/io/rsocket/ipc/MultiServiceTest.java diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java index 58a5d978..13d46906 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java @@ -35,19 +35,6 @@ public class IPCUtils { public static final Charset CHARSET = StandardCharsets.UTF_8; - public static X releaseOnError(Supplier supplier, ReferenceCounted referenceCounted) { - return releaseOnError(supplier, referenceCounted, false); - } - - public static X releaseOnError(Supplier supplier, ReferenceCounted referenceCounted, - boolean releaseOnZeroRefCnt) { - Objects.requireNonNull(referenceCounted); - return onError(supplier, () -> { - if (releaseOnZeroRefCnt || referenceCounted.refCnt() > 0) - referenceCounted.release(); - }); - } - public static X onError(Supplier supplier, Runnable callback) { Objects.requireNonNull(supplier); try { @@ -60,28 +47,6 @@ public static X onError(Supplier supplier, Runnable callback) { } } - public static X releaseOnFinally(Supplier supplier, ReferenceCounted referenceCounted) { - return releaseOnError(supplier, referenceCounted, false); - } - - public static X releaseOnFinally(Supplier supplier, ReferenceCounted referenceCounted, - boolean releaseOnZeroRefCnt) { - Objects.requireNonNull(referenceCounted); - return onFinally(supplier, () -> { - if (releaseOnZeroRefCnt || referenceCounted.refCnt() > 0) - referenceCounted.release(); - }); - } - - public static X onFinally(Supplier supplier, Runnable callback) { - Objects.requireNonNull(supplier); - try { - return supplier.get(); - } finally { - callback.run(); - } - } - public static Stream stream(Iterator iterator) { if (iterator == null) return Stream.empty(); diff --git a/rsocket-ipc-core/src/test/java/io/rsocket/ipc/MultiServiceTest.java b/rsocket-ipc-core/src/test/java/io/rsocket/ipc/MultiServiceTest.java new file mode 100644 index 00000000..2469f365 --- /dev/null +++ b/rsocket-ipc-core/src/test/java/io/rsocket/ipc/MultiServiceTest.java @@ -0,0 +1,171 @@ +/* + * Copyright 2019 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.rsocket.ipc; + +import io.netty.buffer.ByteBufAllocator; +import io.rsocket.RSocket; +import io.rsocket.RSocketFactory; +import io.rsocket.SocketAcceptor; +import io.rsocket.core.RSocketConnector; +import io.rsocket.core.RSocketServer; +import io.rsocket.ipc.decoders.CompositeMetadataDecoder; +import io.rsocket.ipc.decoders.MetadataDecoderLFP; +import io.rsocket.ipc.encoders.DefaultMetadataEncoder; +import io.rsocket.ipc.encoders.MetadataEncoderLFP; +import io.rsocket.ipc.encoders.MetadataReader; +import io.rsocket.ipc.marshallers.Primitives; +import io.rsocket.ipc.marshallers.Strings; +import io.rsocket.ipc.mimetype.MimeTypes; +import io.rsocket.transport.local.LocalClientTransport; +import io.rsocket.transport.local.LocalServerTransport; +import io.rsocket.transport.netty.client.TcpClientTransport; +import io.rsocket.transport.netty.server.TcpServerTransport; + +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.logging.Level; +import java.util.stream.Stream; + +import org.junit.Assert; +import org.junit.Test; + +import reactor.core.Disposable; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; +import reactor.test.StepVerifier; + +public class MultiServiceTest { + @Test + public void test() { + MetadataDecoderLFP decoder = new MetadataDecoderLFP(); + MetadataEncoderLFP encoder = new MetadataEncoderLFP(); + RequestHandlingRSocket requestHandler = new RequestHandlingRSocket(decoder); + {// start server + SocketAcceptor socketAcceptor = (setup, client) -> Mono.just(requestHandler); + RSocketServer.create(socketAcceptor).interceptors(ir -> { + }).errorConsumer(t -> { + java.util.logging.Logger.getLogger("[server]").log(Level.SEVERE, "uncaught error", t); + }).bind(TcpServerTransport.create("localhost", 7000)).block(); + } + RSocket rsocket; + {// start client + rsocket = RSocketConnector.create().connect(TcpClientTransport.create("localhost", 7000)).block(); + } + AtomicBoolean ff = new AtomicBoolean(); + + IPCRSocket service = Server.service("HelloService").noMeterRegistry().noTracer().marshall(Strings.marshaller()) + .unmarshall(Strings.unmarshaller()).requestResponse("hello", (s, byteBuf) -> { + MetadataReader reader = new MetadataReader(byteBuf, false); + Stream vals = reader.stream(v -> true, e -> Arrays.asList( + String.format("%s - %s", e.getMimeType(), e.getContent().toString(StandardCharsets.UTF_8))) + .stream()); + vals.forEach(v -> { + System.out.println(v); + }); + return Mono.just("Hello -> " + s); + }).requestResponse("goodbye", (s, byteBuf) -> Mono.just("Goodbye -> " + s)) + .requestResponse("count", Primitives.intMarshaller(), + (charSequence, byteBuf) -> Mono.just(charSequence.length())) + .requestResponse("increment", Primitives.intUnmarshaller(), Primitives.intMarshaller(), + (integer, byteBuf) -> Mono.just(integer + 1)) + .requestStream("helloStream", (s, byteBuf) -> Flux.range(1, 10).map(i -> i + " - Hello -> " + s)) + .requestStream("toString", Primitives.longUnmarshaller(), + (aLong, byteBuf) -> Flux.just(String.valueOf(aLong))) + .fireAndForget("ff", (s, byteBuf) -> { + ff.set(true); + return Mono.empty(); + }).requestChannel("helloChannel", (s, publisher, byteBuf) -> Flux.just("Hello -> " + s)).toIPCRSocket(); + + requestHandler.withEndpoint(service); + + Client helloService = Client.service("HelloService").rsocket(rsocket) + .customMetadataEncoder(encoder).noMeterRegistry().noTracer().marshall(Strings.marshaller()) + .unmarshall(Strings.unmarshaller()); + + String r1 = helloService.requestResponse("hello").apply("Alice").block(); + Assert.assertEquals("Hello -> Alice", r1); + + String r2 = helloService.requestResponse("goodbye").apply("Bob").block(); + Assert.assertEquals("Goodbye -> Bob", r2); + + StepVerifier.create(helloService.requestStream("helloStream").apply("Carol")).expectNextCount(10) + .expectComplete().verify(); + + helloService.fireAndForget("ff").apply("boom").block(); + int maxSeconds = 10; + for (int i = 0; i < maxSeconds && !ff.get(); i++) { + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + } + Assert.assertTrue(ff.get()); + + String r3 = helloService.requestChannel("helloChannel").apply(Mono.just("Eve")).blockLast(); + Assert.assertEquals("Hello -> Eve", r3); + + int count = helloService.requestResponse("count", Primitives.intUnmarshaller()).apply("hello").block(); + Assert.assertEquals(5, count); + + long l = System.currentTimeMillis(); + String toString = helloService.requestStream("toString", Primitives.longMarshaller()).apply(l).blockLast(); + Assert.assertEquals(String.valueOf(l), toString); + + Integer increment = helloService + .requestResponse("increment", Primitives.intMarshaller(), Primitives.intUnmarshaller()).apply(1) + .block(); + Assert.assertEquals(2, increment.intValue()); + Disposable encoderPasswordDisposable = null; + for (int i = 0; i < 3; i++) { + if (i == 1) { + encoderPasswordDisposable = encoder.addInterceptor(writer -> { + // writer.writeString(MimeTypes.create("password"), "AAAAAAAAAAAA"); + writer.writeString(MimeTypes.create("password"), "thisIsACoolPassWord!"); + }); + decoder.addInterceptor(reader -> { + boolean match = reader.containsStringSecure(MimeTypes.create("password"), "thisIsACoolPassWord!"); + if (!match) + throw new IllegalArgumentException("not authorized"); + }); + } + boolean shouldFail; + if (i == 2) { + shouldFail = true; + encoderPasswordDisposable.dispose(); + } else + shouldFail = false; + boolean failed; + try { + Integer incrementMetadata = helloService + .requestResponse("increment", Primitives.intMarshaller(), Primitives.intUnmarshaller()).apply(1) + .block(); + Assert.assertEquals(2, incrementMetadata.intValue()); + failed = false; + } catch (Exception e) { + failed = true; + } + Assert.assertEquals(failed, shouldFail); + } + } + + public static void main(String[] args) { + new MultiServiceTest().test(); + } +} diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java index e4cc8060..5b20ac08 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java @@ -22,8 +22,10 @@ import io.netty.buffer.ByteBuf; import io.rsocket.RSocket; import io.rsocket.ipc.Client; +import io.rsocket.ipc.Client.U; import io.rsocket.ipc.Marshaller; import io.rsocket.ipc.MetadataEncoder; +import io.rsocket.ipc.Unmarshaller; import io.rsocket.ipc.marshallers.Bytes; import io.rsocket.ipc.reflection.core.MethodMapUtils; import io.rsocket.ipc.reflection.core.PublisherConverter; @@ -61,9 +63,6 @@ protected static X createInternal(Mono rSocketMono, Class servic Objects.requireNonNull(argumentMarshaller); Objects.requireNonNull(returnDeserializer); Map mappedMethods = MethodMapUtils.getMappedMethods(serviceType, false); - Client client = Client.service(serviceType.getName()) - .rsocket(LazyRSocket.create(rSocketMono)).customMetadataEncoder(metadataEncoder).noMeterRegistry() - .noTracer().marshall(argumentMarshaller).unmarshall(Bytes.byteBufUnmarshaller()); Map> ipcInvokerCache = new ConcurrentHashMap<>(); return (X) proxyFactory(serviceType).create(new Class[] {}, new Object[] {}, new MethodHandler() { @@ -77,8 +76,12 @@ public Object invoke(Object self, Method thisMethod, Method proceed, Object[] ar .orElse(null); if (entry == null) return Optional.empty(); - return Optional.of(createIPCInvoker(client, serviceType, entry.getKey(), metadataEncoder, - argumentMarshaller, returnDeserializer, thisMethod)); + U clientBuilder = Client.service(serviceType.getName()) + .rsocket(LazyRSocket.create(rSocketMono)).customMetadataEncoder(metadataEncoder) + .noMeterRegistry().noTracer().marshall(argumentMarshaller); + String route = entry.getKey(); + return Optional.of( + createIPCInvoker(metadataEncoder, returnDeserializer, thisMethod, route, clientBuilder)); }); if (!ipcInvokerOp.isPresent()) throw new NoSuchMethodException(String.format( @@ -90,42 +93,67 @@ public Object invoke(Object self, Method thisMethod, Method proceed, Object[] ar } @SuppressWarnings("unchecked") - private static IPCInvoker createIPCInvoker(Client client, Class serviceType, String route, - MetadataEncoder metadataEncoder, Marshaller argumentMarshaller, - BiFunction returnDeserializer, Method method) { + private static IPCInvoker createIPCInvoker(MetadataEncoder metadataEncoder, + BiFunction returnDeserializer, Method method, String route, + U clientBuilder) { Optional> returnPublisherConverterOp = PublisherConverters.lookup(method.getReturnType()); + Type unmarshallerType; + if (returnPublisherConverterOp.isPresent()) + unmarshallerType = returnPublisherConverterOp.get().getPublisherTypeArgument(method.getGenericReturnType()) + .orElse(Object.class); + else + unmarshallerType = method.getGenericReturnType(); if (MethodMapUtils.getRequestChannelParameterType(method).isPresent()) { return (args) -> { Publisher objPublisher = (Publisher) args[0]; Flux argArrayPublisher = Flux.from(objPublisher).map(v -> new Object[] { v }); - Flux responsePublisher = client.requestChannel(route).apply(argArrayPublisher); - return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), - responsePublisher); + Flux responsePublisher = clientBuilder + .unmarshall(createUnmarshaller(unmarshallerType, returnDeserializer)).requestChannel(route) + .apply(argArrayPublisher); + return returnMap(method, returnPublisherConverterOp, responsePublisher); }; } if (MethodMapUtils.isFireAndForget(method)) return (args) -> { - Mono result = client.fireAndForget(route).apply(args); - if (Mono.class.isAssignableFrom(method.getReturnType())) - return result; - return null; + Mono result = clientBuilder.unmarshall(Bytes.byteBufUnmarshaller()).fireAndForget(route) + .apply(args); + return returnMap(method, returnPublisherConverterOp, result); }; if (returnPublisherConverterOp.isPresent() && !Mono.class.isAssignableFrom(method.getReturnType())) return (args) -> { - Flux responsePublisher = client.requestStream(route).apply(args); - return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), - responsePublisher); + Flux responsePublisher = clientBuilder + .unmarshall(createUnmarshaller(unmarshallerType, returnDeserializer)).requestStream(route) + .apply(args); + return returnMap(method, returnPublisherConverterOp, responsePublisher); }; return (args) -> { - Mono responsePublisher = client.requestResponse(route).apply(args); - if (returnPublisherConverterOp.isPresent()) - return returnFromResponsePublisher(method, returnDeserializer, returnPublisherConverterOp.get(), - responsePublisher); - ByteBuf bb = responsePublisher.block(); - return returnDeserializer.apply(method.getReturnType(), bb); + Mono responsePublisher = clientBuilder + .unmarshall(createUnmarshaller(unmarshallerType, returnDeserializer)).requestResponse(route) + .apply(args); + return returnMap(method, returnPublisherConverterOp, responsePublisher); }; } + private static Object returnMap(Method method, Optional> returnPublisherConverterOp, + Publisher responsePublisher) { + if (!returnPublisherConverterOp.isPresent()) + return returnMapPublisher(method, responsePublisher); + Object result = returnPublisherConverterOp.get().fromPublisher(responsePublisher); + if (result instanceof Publisher) + return returnMapPublisher(method, (Publisher) result); + return result; + } + + private static Object returnMapPublisher(Method method, Publisher responsePublisher) { + if (Flux.class.isAssignableFrom(method.getReturnType())) + return Flux.from(responsePublisher); + if (Mono.class.isAssignableFrom(method.getReturnType())) + return Mono.from(responsePublisher); + if (responsePublisher instanceof Mono) + return ((Mono) responsePublisher).block(); + return responsePublisher; + } + private static Object returnFromResponsePublisher(Method method, BiFunction returnDeserializer, PublisherConverter returnPublisherConverter, Publisher responsePublisher) { @@ -146,6 +174,11 @@ private static Object returnFromResponsePublisher(Method method, return result; } + private static Unmarshaller createUnmarshaller(Type unmarshallerType, + BiFunction returnDeserializer) { + return bb -> returnDeserializer.apply(unmarshallerType, bb); + } + @SuppressWarnings("unchecked") private static ProxyFactory proxyFactory(Class classType, Class... additionalInterfaces) { ProxyFactory factory = new ProxyFactory(); diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java index bf89eb02..94446a07 100644 --- a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java +++ b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java @@ -6,11 +6,12 @@ import java.util.Arrays; import java.util.HashSet; import java.util.Map; +import java.util.Map.Entry; import java.util.Objects; import java.util.Optional; import java.util.Set; import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Function; +import java.util.function.BiFunction; import java.util.function.Supplier; import java.util.logging.Level; import java.util.logging.Logger; @@ -19,18 +20,17 @@ import io.netty.buffer.ByteBuf; import io.opentracing.Tracer; +import io.rsocket.ipc.IPCRSocket; import io.rsocket.ipc.Marshaller; import io.rsocket.ipc.MetadataDecoder; import io.rsocket.ipc.RequestHandlingRSocket; import io.rsocket.ipc.Server; -import io.rsocket.ipc.Server.H; +import io.rsocket.ipc.Server.U; import io.rsocket.ipc.Unmarshaller; -import io.rsocket.ipc.marshallers.Bytes; import io.rsocket.ipc.reflection.core.MethodMapUtils; import io.rsocket.ipc.reflection.core.PublisherConverter; import io.rsocket.ipc.reflection.core.PublisherConverters; import io.rsocket.ipc.util.IPCUtils; -import io.rsocket.ipc.util.TriFunction; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; import reactor.core.scheduler.Scheduler; @@ -58,22 +58,16 @@ public RequestHandlingRSocketReflection(Scheduler subscribeOnScheduler, Tracer t public void register(Class serviceType, S service, Marshaller resultMarshaller, Unmarshaller unmarshaller) { - register(serviceType, service, resultMarshaller, (paramTypes, bb, md) -> unmarshaller.apply(bb)); + register(serviceType, service, resultMarshaller, (paramTypes, bb) -> unmarshaller.apply(bb)); } public void register(Class serviceType, S service, Marshaller resultMarshaller, - Function> argumentDeserializer) { - register(serviceType, service, resultMarshaller, - (paramTypes, bb, md) -> argumentDeserializer.apply(paramTypes).apply(bb)); - } - - public void register(Class serviceType, S service, Marshaller resultMarshaller, - TriFunction argumentDeserializer) { + BiFunction argumentUnmarshaller) { Objects.requireNonNull(serviceType); Objects.requireNonNull(service); Objects.requireNonNull(resultMarshaller); - Objects.requireNonNull(argumentDeserializer); - Map methods = MethodMapUtils.getMappedMethods(serviceType, true); + Objects.requireNonNull(argumentUnmarshaller); + Map methodMapping = MethodMapUtils.getMappedMethods(serviceType, true); Set serviceNameTracker = new HashSet<>(); for (boolean lowercase : Arrays.asList(false, true)) { for (boolean simpleName : Arrays.asList(false, true)) { @@ -81,99 +75,130 @@ public void register(Class serviceType, S service, Marshaller res serviceName = lowercase ? serviceName.toLowerCase() : serviceName; if (!serviceNameTracker.add(serviceName)) continue; - register(service, serviceName, resultMarshaller, argumentDeserializer, methods); + for (Entry ent : methodMapping.entrySet()) { + String route = ent.getKey(); + Method method = ent.getValue(); + logger.log(Level.INFO, + String.format("registering request handler. route:%s.%s", serviceName, route)); + register(service, argumentUnmarshaller, createServiceBuilder(serviceName, resultMarshaller), route, + method); + } } } } - private void register(S service, String serviceName, Marshaller resultMarshaller, - TriFunction argumentDeserializer, Map methodMapping) { - // wrap the deserializer so that it counts down references - TriFunction releasingArgumentDeserializer = (types, data, md) -> { - return IPCUtils.releaseOnFinally(() -> argumentDeserializer.apply(types, data, md), data); - }; - H serviceBuilder = Server.service(serviceName).noMeterRegistry().noTracer() - .marshall(resultMarshaller).unmarshall(Bytes.byteBufUnmarshaller()); - methodMapping.entrySet().forEach(ent -> { - String route = ent.getKey(); - logger.log(Level.FINE, - String.format("registering request handler. serviceName:%s route:%s", serviceName, route)); - register(service, route, releasingArgumentDeserializer, ent.getValue(), serviceBuilder); - }); - this.withEndpoint(serviceBuilder.toIPCRSocket()); - } - - @SuppressWarnings({ "unchecked", "rawtypes" }) - private void register(S service, String route, - TriFunction argumentDeserializer, Method method, - H serviceBuilder) { - if (registerRequestChannel(service, route, argumentDeserializer, method, serviceBuilder)) + private void register(S service, BiFunction argumentUnmarshaller, + U serviceBuilder, String route, Method method) { + if (registerRequestChannel(service, argumentUnmarshaller, serviceBuilder, route, method)) return; - if (MethodMapUtils.isFireAndForget(method)) { - serviceBuilder.fireAndForget(route, (data, md) -> { - Object[] arguments = argumentDeserializer.apply(method.getGenericParameterTypes(), data, md); - Mono> wrappedMono = asMono(() -> { - invoke(service, method, arguments); - return Mono.empty(); - }, this.subscribeOnScheduler); - return wrappedMono.flatMap(v -> v); - }); + if (registerFireAndForget(service, argumentUnmarshaller, serviceBuilder, route, method)) return; - } - Optional returnPublisherConverter = PublisherConverters.lookup(method.getReturnType()) - .map(v -> v); - if (returnPublisherConverter.isPresent() && !Mono.class.isAssignableFrom(method.getReturnType())) { - serviceBuilder.requestStream(route, (data, md) -> { - Object[] arguments = argumentDeserializer.apply(method.getGenericParameterTypes(), data, md); - return asFlux(() -> { - Object result = invoke(service, method, arguments); - return returnPublisherConverter.get().toPublisher(result); - }, this.subscribeOnScheduler); - }); + Optional> returnPublisherConverter = PublisherConverters.lookup(method.getReturnType()); + if (registerRequestStream(service, argumentUnmarshaller, serviceBuilder, route, method, + returnPublisherConverter)) return; - } - serviceBuilder.requestResponse(route, (data, md) -> { - Object[] arguments = argumentDeserializer.apply(method.getGenericParameterTypes(), data, md); - Mono> wrappedMono = asMono(() -> { - Object result = invoke(service, method, arguments); - if (returnPublisherConverter.isPresent()) - return Mono.from(returnPublisherConverter.get().toPublisher(result)); - return Mono.just(result); - }, this.subscribeOnScheduler); - return wrappedMono.flatMap(v -> v); - }); + if (registerRequestResponse(service, argumentUnmarshaller, serviceBuilder, route, method, + returnPublisherConverter)) + return; + String errorMessage = String.format("unable to map method. serviceInstanceType:%s methodRoute:%s method:%s", + service.getClass().getName(), route, method); + throw new IllegalArgumentException(errorMessage); } @SuppressWarnings({ "rawtypes", "unchecked" }) - private boolean registerRequestChannel(S service, String route, - TriFunction argumentDeserializer, Method method, - H serviceBuilder) { + private boolean registerRequestChannel(S service, BiFunction argumentUnmarshaller, + U serviceBuilder, String route, Method method) { Optional requestChannelParameterType = MethodMapUtils.getRequestChannelParameterType(method); if (!requestChannelParameterType.isPresent()) return false; PublisherConverter returnPublisherConverter = PublisherConverters.lookup(method.getReturnType()).get(); Type[] typeArguments = new Type[] { requestChannelParameterType.get() }; - serviceBuilder.requestChannel(route, (first, publisher, md) -> { - md.retain(); - Runnable mdRelease = () -> { - if (md.refCnt() > 0) - md.release(); - }; - return IPCUtils.onError(() -> { - Flux argArrayPublisher = Flux.from(publisher).map(bb -> { - Object[] argArray = argumentDeserializer.apply(typeArguments, bb, md); - return argArray; - }); - Flux objPublisher = argArrayPublisher.map(arr -> arr[0]); - return asFlux(() -> { - Object result = invoke(service, method, new Object[] { objPublisher }); - return returnPublisherConverter.toPublisher(result); - }, this.subscribeOnScheduler).doOnTerminate(mdRelease); - }, mdRelease); - }); + IPCRSocket ipcrSocket = serviceBuilder.unmarshall(createUnmarshaller(typeArguments, argumentUnmarshaller)) + .requestChannel(route, (first, publisher, md) -> { + md.retain(); + Runnable mdRelease = () -> { + if (md.refCnt() > 0) + md.release(); + }; + return IPCUtils.onError(() -> { + return asFlux(() -> { + Object result = invoke(service, method, new Object[] { publisher }); + return returnPublisherConverter.toPublisher(result); + }, this.subscribeOnScheduler).doOnTerminate(mdRelease); + }, mdRelease); + }).toIPCRSocket(); + this.withEndpoint(ipcrSocket); return true; } + private boolean registerFireAndForget(S service, BiFunction argumentUnmarshaller, + U serviceBuilder, String route, Method method) { + if (!MethodMapUtils.isFireAndForget(method)) + return false; + IPCRSocket ipcrSocket = serviceBuilder + .unmarshall(createUnmarshaller(method.getGenericParameterTypes(), argumentUnmarshaller)) + .fireAndForget(route, (data, md) -> { + Mono> wrappedMono = asMono(() -> { + invoke(service, method, data); + return Mono.empty(); + }, this.subscribeOnScheduler); + return wrappedMono.flatMap(v -> v); + }).toIPCRSocket(); + this.withEndpoint(ipcrSocket); + return true; + + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + private boolean registerRequestStream(S service, BiFunction argumentUnmarshaller, + U serviceBuilder, String route, Method method, + Optional> returnPublisherConverter) { + if (!returnPublisherConverter.isPresent()) + return false; + if (Mono.class.isAssignableFrom(method.getReturnType())) + return false; + PublisherConverter publisherConverter = returnPublisherConverter.get(); + IPCRSocket ipcrSocket = serviceBuilder + .unmarshall(createUnmarshaller(method.getGenericParameterTypes(), argumentUnmarshaller)) + .requestStream(route, (data, md) -> { + return asFlux(() -> { + Object result = invoke(service, method, data); + return publisherConverter.toPublisher(result); + }, this.subscribeOnScheduler); + }).toIPCRSocket(); + this.withEndpoint(ipcrSocket); + return true; + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + private boolean registerRequestResponse(S service, BiFunction argumentUnmarshaller, + U serviceBuilder, String route, Method method, + Optional> returnPublisherConverter) { + PublisherConverter publisherConverter = returnPublisherConverter.orElse(null); + IPCRSocket ipcrSocket = serviceBuilder + .unmarshall(createUnmarshaller(method.getGenericParameterTypes(), argumentUnmarshaller)) + .requestResponse(route, (data, md) -> { + Mono> wrappedMono = asMono(() -> { + Object result = invoke(service, method, data); + if (publisherConverter != null) + return Mono.from(publisherConverter.toPublisher(result)); + return Mono.just(result); + }, this.subscribeOnScheduler); + return wrappedMono.flatMap(v -> v); + }).toIPCRSocket(); + this.withEndpoint(ipcrSocket); + return true; + } + + private static U createServiceBuilder(String serviceName, Marshaller resultMarshaller) { + return Server.service(serviceName).noMeterRegistry().noTracer().marshall(resultMarshaller); + } + + private static Unmarshaller createUnmarshaller(Type[] typeArguments, + BiFunction argumentDeserializer) { + return bb -> argumentDeserializer.apply(typeArguments, bb); + } + private static Flux asFlux(Supplier> supplier, Scheduler scheduler) { Supplier> memoizedSupplier = memoized(supplier); Flux result = Flux.defer(memoizedSupplier); diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java index 32688e13..112f2562 100644 --- a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java @@ -10,7 +10,6 @@ import java.util.stream.Stream; import com.google.gson.Gson; -import com.google.gson.reflect.TypeToken; import io.netty.buffer.ByteBuf; import io.rsocket.RSocket; diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java index 80d46beb..f83771a6 100644 --- a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java @@ -34,7 +34,7 @@ public static void main(String[] args) throws InterruptedException { } boolean releaseOnParse = true; Gson gson = new Gson(); - requestHandler.register(classType, service, GsonMarshaller.create(gson), (types, bb, md) -> { + requestHandler.register(classType, service, GsonMarshaller.create(gson), (types, bb) -> { return GsonUnmarshaller.create(gson, types).apply(bb); }); System.out.println("started"); From 1a4f08db5dfbae1c85c4a4761ddba0420bbe11d7 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 13 May 2020 21:37:28 -0400 Subject: [PATCH 055/273] channel arg mapping --- .../reflection/server/RequestHandlingRSocketReflection.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java index 94446a07..c84c200e 100644 --- a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java +++ b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java @@ -115,6 +115,7 @@ private boolean registerRequestChannel(S service, BiFunction { + Flux argFlux = Flux.from(publisher).map(args -> args[0]); md.retain(); Runnable mdRelease = () -> { if (md.refCnt() > 0) @@ -122,7 +123,7 @@ private boolean registerRequestChannel(S service, BiFunction { return asFlux(() -> { - Object result = invoke(service, method, new Object[] { publisher }); + Object result = invoke(service, method, new Object[] { argFlux }); return returnPublisherConverter.toPublisher(result); }, this.subscribeOnScheduler).doOnTerminate(mdRelease); }, mdRelease); From c4f8a49b0e59023195b2ab3930b67adcebf9597e Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 22 May 2020 08:51:35 -0400 Subject: [PATCH 056/273] Update LazyRSocket.java --- .../ipc/reflection/client/LazyRSocket.java | 26 ++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java index 1bd0d876..4f9473cc 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java @@ -1,6 +1,9 @@ package io.rsocket.ipc.reflection.client; import java.util.Objects; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.atomic.AtomicReference; import java.util.function.Supplier; import org.reactivestreams.Publisher; @@ -15,7 +18,28 @@ public abstract class LazyRSocket implements ResponderRSocket { public static LazyRSocket create(Mono rsocketMono) { Objects.requireNonNull(rsocketMono); - return create(() -> rsocketMono.block()); + AtomicReference> futureRef = new AtomicReference<>(new CompletableFuture<>()); + rsocketMono.subscribe(v -> { + if (!futureRef.get().isDone()) { + synchronized (futureRef) { + if (!futureRef.get().isDone()) { + futureRef.get().complete(v); + return; + } + } + } + futureRef.set(CompletableFuture.completedFuture(v)); + }); + Supplier rSocketSupplier = () -> { + try { + return futureRef.get().get(); + } catch (InterruptedException | ExecutionException e) { + throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) + ? java.lang.RuntimeException.class.cast(e) + : new java.lang.RuntimeException(e); + } + }; + return create(rSocketSupplier); } public static LazyRSocket create(Supplier rsocketSupplier) { From ca34db5fd5a41f5f0da67398c60f9ad989fe2743 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 22 May 2020 09:14:19 -0400 Subject: [PATCH 057/273] Update LazyRSocket.java --- .../java/io/rsocket/ipc/reflection/client/LazyRSocket.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java index 4f9473cc..5f75d3e7 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java @@ -13,13 +13,14 @@ import io.rsocket.ResponderRSocket; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; +import reactor.core.scheduler.Schedulers; public abstract class LazyRSocket implements ResponderRSocket { public static LazyRSocket create(Mono rsocketMono) { Objects.requireNonNull(rsocketMono); AtomicReference> futureRef = new AtomicReference<>(new CompletableFuture<>()); - rsocketMono.subscribe(v -> { + rsocketMono.subscribeOn(Schedulers.elastic()).subscribe(v -> { if (!futureRef.get().isDone()) { synchronized (futureRef) { if (!futureRef.get().isDone()) { From 4049c057efcc684a1f6c7e71adbd7f9b164789c3 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 22 May 2020 10:46:06 -0400 Subject: [PATCH 058/273] Update GsonUnmarshaller.java --- .../main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java index d19403d6..903c77d8 100644 --- a/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java +++ b/rsocket-ipc-gson/src/main/java/io/rsocket/ipc/marshallers/GsonUnmarshaller.java @@ -34,8 +34,6 @@ public static GsonUnmarshaller create(Gson gson, Type type) { public static GsonUnmarshaller create(Gson gson, Type[] types) { Objects.requireNonNull(gson); Objects.requireNonNull(types); - if (types.length == 0) - throw new IllegalArgumentException("types are required"); for (Type type : types) Objects.requireNonNull(type); Function parser = bb -> { From 09c22a3c956db601de9bb9319bb4c87fc90b4031 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 22 May 2020 13:59:51 -0400 Subject: [PATCH 059/273] Transition to supplier --- .../ipc/reflection/client/LazyRSocket.java | 30 ------------------- .../reflection/client/RSocketIPCClients.java | 12 ++++---- 2 files changed, 7 insertions(+), 35 deletions(-) diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java index 5f75d3e7..e02597f9 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java @@ -1,9 +1,6 @@ package io.rsocket.ipc.reflection.client; import java.util.Objects; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.atomic.AtomicReference; import java.util.function.Supplier; import org.reactivestreams.Publisher; @@ -13,36 +10,9 @@ import io.rsocket.ResponderRSocket; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; -import reactor.core.scheduler.Schedulers; public abstract class LazyRSocket implements ResponderRSocket { - public static LazyRSocket create(Mono rsocketMono) { - Objects.requireNonNull(rsocketMono); - AtomicReference> futureRef = new AtomicReference<>(new CompletableFuture<>()); - rsocketMono.subscribeOn(Schedulers.elastic()).subscribe(v -> { - if (!futureRef.get().isDone()) { - synchronized (futureRef) { - if (!futureRef.get().isDone()) { - futureRef.get().complete(v); - return; - } - } - } - futureRef.set(CompletableFuture.completedFuture(v)); - }); - Supplier rSocketSupplier = () -> { - try { - return futureRef.get().get(); - } catch (InterruptedException | ExecutionException e) { - throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) - ? java.lang.RuntimeException.class.cast(e) - : new java.lang.RuntimeException(e); - } - }; - return create(rSocketSupplier); - } - public static LazyRSocket create(Supplier rsocketSupplier) { Objects.requireNonNull(rsocketSupplier); return new LazyRSocket() { diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java index 5b20ac08..1edddb26 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java @@ -13,6 +13,7 @@ import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; import java.util.function.BiFunction; +import java.util.function.Supplier; import java.util.logging.Logger; import java.util.stream.Stream; @@ -41,10 +42,11 @@ public class RSocketIPCClients { private static final Logger logger = java.util.logging.Logger.getLogger(THIS_CLASS.getName()); protected static final Duration RSOCKET_SUPPLIER_WARN_DURATION = Duration.ofSeconds(10); - public static X create(Mono rSocketMono, Class serviceType, MetadataEncoder metadataEncoder, + public static X create(Supplier rSocketSupplier, Class serviceType, MetadataEncoder metadataEncoder, Marshaller argumentMarshaller, BiFunction returnDeserializer) { try { - return createInternal(rSocketMono, serviceType, metadataEncoder, argumentMarshaller, returnDeserializer); + return createInternal(rSocketSupplier, serviceType, metadataEncoder, argumentMarshaller, + returnDeserializer); } catch (NoSuchMethodException | IllegalArgumentException | InstantiationException | IllegalAccessException | InvocationTargetException e) { throw java.lang.RuntimeException.class.isAssignableFrom(e.getClass()) @@ -54,11 +56,11 @@ public static X create(Mono rSocketMono, Class serviceType, Meta } @SuppressWarnings("unchecked") - protected static X createInternal(Mono rSocketMono, Class serviceType, + protected static X createInternal(Supplier rSocketSupplier, Class serviceType, MetadataEncoder metadataEncoder, Marshaller argumentMarshaller, BiFunction returnDeserializer) throws NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException { - Objects.requireNonNull(rSocketMono); + Objects.requireNonNull(rSocketSupplier); Objects.requireNonNull(serviceType); Objects.requireNonNull(argumentMarshaller); Objects.requireNonNull(returnDeserializer); @@ -77,7 +79,7 @@ public Object invoke(Object self, Method thisMethod, Method proceed, Object[] ar if (entry == null) return Optional.empty(); U clientBuilder = Client.service(serviceType.getName()) - .rsocket(LazyRSocket.create(rSocketMono)).customMetadataEncoder(metadataEncoder) + .rsocket(LazyRSocket.create(rSocketSupplier)).customMetadataEncoder(metadataEncoder) .noMeterRegistry().noTracer().marshall(argumentMarshaller); String route = entry.getKey(); return Optional.of( From 2a34538f0b088d24f124d0908669ae84b7aace53 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 22 May 2020 14:09:02 -0400 Subject: [PATCH 060/273] Supplier fix --- .../src/main/java/io/rsocket/ipc/reflection/ClientTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java index 112f2562..1dedd35a 100644 --- a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ClientTest.java @@ -30,7 +30,7 @@ public static void main(String[] args) { BiFunction deserializer = (t, bb) -> { return GsonUnmarshaller.create(gson, t).apply(bb); }; - TestServiceChannel client = RSocketIPCClients.create(Mono.just(rsocket), TestServiceChannel.class, + TestServiceChannel client = RSocketIPCClients.create(() -> rsocket, TestServiceChannel.class, new MetadataEncoderLFP(), v -> { ByteBuf bb = GsonMarshaller.create(gson).apply(v); System.out.println(bb.toString(StandardCharsets.UTF_8)); From 24ee802b2b795437d27f0e30ecd7812feac3bc6d Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 28 May 2020 09:15:51 -0400 Subject: [PATCH 061/273] scheduler --- .../server/RequestHandlingRSocketReflection.java | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java index c84c200e..904cb7a6 100644 --- a/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java +++ b/rsocket-ipc-reflection-server/src/main/java/io/rsocket/ipc/reflection/server/RequestHandlingRSocketReflection.java @@ -39,7 +39,7 @@ public class RequestHandlingRSocketReflection extends RequestHandlingRSocket { private static final Class THIS_CLASS = new Object() { }.getClass().getEnclosingClass(); private static final Logger logger = java.util.logging.Logger.getLogger(THIS_CLASS.getName()); - private final Scheduler subscribeOnScheduler; + private Scheduler subscribeOnScheduler; public RequestHandlingRSocketReflection(Scheduler subscribeOnScheduler) { super(); @@ -191,6 +191,14 @@ private boolean registerRequestResponse(S service, BiFunction U createServiceBuilder(String serviceName, Marshaller resultMarshaller) { return Server.service(serviceName).noMeterRegistry().noTracer().marshall(resultMarshaller); } From d95ef489e2fa922aa352e6390ac44db7940e700b Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 31 Jul 2020 14:12:39 -0400 Subject: [PATCH 062/273] reflections update --- .gitignore | 1 + rsocket-ipc-core/bin/.gitignore | 1 + rsocket-ipc-graphql/bin/.gitignore | 1 + rsocket-ipc-gson/bin/.gitignore | 1 + rsocket-ipc-jackson/bin/.gitignore | 1 + rsocket-ipc-protobuf/bin/.gitignore | 1 + rsocket-ipc-reflection-client/bin/.gitignore | 1 + .../io/rsocket/ipc/reflection/client/RSocketIPCClients.java | 2 +- rsocket-ipc-reflection-core/bin/.gitignore | 1 + rsocket-ipc-reflection-core/build.gradle | 2 +- .../java/io/rsocket/ipc/reflection/core/MethodMapUtils.java | 2 +- .../io/rsocket/ipc/reflection/core/PublisherConverters.java | 2 +- rsocket-ipc-reflection-server/bin/.gitignore | 1 + rsocket-ipc-reflection-test/bin/.gitignore | 1 + rsocket-rpc-core/bin/.gitignore | 1 + 15 files changed, 15 insertions(+), 4 deletions(-) diff --git a/.gitignore b/.gitignore index 910aecda..f6343015 100644 --- a/.gitignore +++ b/.gitignore @@ -253,3 +253,4 @@ generated/ .settings # End of https://www.gitignore.io/api/node,java,macos,linux,cmake,gradle,intellij+all +.flattened-pom.xml \ No newline at end of file diff --git a/rsocket-ipc-core/bin/.gitignore b/rsocket-ipc-core/bin/.gitignore index 7eed456b..3c7975f9 100644 --- a/rsocket-ipc-core/bin/.gitignore +++ b/rsocket-ipc-core/bin/.gitignore @@ -1,2 +1,3 @@ /main/ /test/ +.flattened-pom.xml \ No newline at end of file diff --git a/rsocket-ipc-graphql/bin/.gitignore b/rsocket-ipc-graphql/bin/.gitignore index 7eed456b..3c7975f9 100644 --- a/rsocket-ipc-graphql/bin/.gitignore +++ b/rsocket-ipc-graphql/bin/.gitignore @@ -1,2 +1,3 @@ /main/ /test/ +.flattened-pom.xml \ No newline at end of file diff --git a/rsocket-ipc-gson/bin/.gitignore b/rsocket-ipc-gson/bin/.gitignore index ddf9c656..510c24de 100644 --- a/rsocket-ipc-gson/bin/.gitignore +++ b/rsocket-ipc-gson/bin/.gitignore @@ -1 +1,2 @@ /main/ +.flattened-pom.xml \ No newline at end of file diff --git a/rsocket-ipc-jackson/bin/.gitignore b/rsocket-ipc-jackson/bin/.gitignore index ddf9c656..510c24de 100644 --- a/rsocket-ipc-jackson/bin/.gitignore +++ b/rsocket-ipc-jackson/bin/.gitignore @@ -1 +1,2 @@ /main/ +.flattened-pom.xml \ No newline at end of file diff --git a/rsocket-ipc-protobuf/bin/.gitignore b/rsocket-ipc-protobuf/bin/.gitignore index ddf9c656..510c24de 100644 --- a/rsocket-ipc-protobuf/bin/.gitignore +++ b/rsocket-ipc-protobuf/bin/.gitignore @@ -1 +1,2 @@ /main/ +.flattened-pom.xml \ No newline at end of file diff --git a/rsocket-ipc-reflection-client/bin/.gitignore b/rsocket-ipc-reflection-client/bin/.gitignore index d97dd0c1..ae4dd600 100644 --- a/rsocket-ipc-reflection-client/bin/.gitignore +++ b/rsocket-ipc-reflection-client/bin/.gitignore @@ -1,2 +1,3 @@ /main/ /default/ +.flattened-pom.xml \ No newline at end of file diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java index 1edddb26..751e2f69 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java @@ -18,7 +18,7 @@ import java.util.stream.Stream; import org.reactivestreams.Publisher; -import org.reflections8.ReflectionUtils; +import org.reflections.ReflectionUtils; import io.netty.buffer.ByteBuf; import io.rsocket.RSocket; diff --git a/rsocket-ipc-reflection-core/bin/.gitignore b/rsocket-ipc-reflection-core/bin/.gitignore index d97dd0c1..ae4dd600 100644 --- a/rsocket-ipc-reflection-core/bin/.gitignore +++ b/rsocket-ipc-reflection-core/bin/.gitignore @@ -1,2 +1,3 @@ /main/ /default/ +.flattened-pom.xml \ No newline at end of file diff --git a/rsocket-ipc-reflection-core/build.gradle b/rsocket-ipc-reflection-core/build.gradle index 55b9bf84..77141a00 100644 --- a/rsocket-ipc-reflection-core/build.gradle +++ b/rsocket-ipc-reflection-core/build.gradle @@ -3,7 +3,7 @@ description = 'RSocket IPC Reflection Mapping Support' dependencies { api project (':rsocket-ipc-core') - compile 'net.oneandone.reflections8:reflections8:0.11.7' + compile 'net.oneandone.reflections8:reflections:0.9.12' testImplementation 'io.opentracing.brave:brave-opentracing' testImplementation 'junit:junit' diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java index a9219414..eade0b76 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java @@ -20,7 +20,7 @@ import java.util.logging.Logger; import java.util.stream.Stream; -import org.reflections8.ReflectionUtils; +import org.reflections.ReflectionUtils; import io.rsocket.ipc.util.IPCUtils; import javassist.Modifier; diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java index 7798d43d..29cd49be 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java @@ -13,7 +13,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import org.reflections8.ReflectionUtils; +import org.reflections.ReflectionUtils; public class PublisherConverters { diff --git a/rsocket-ipc-reflection-server/bin/.gitignore b/rsocket-ipc-reflection-server/bin/.gitignore index 1522af6d..f3c1854e 100644 --- a/rsocket-ipc-reflection-server/bin/.gitignore +++ b/rsocket-ipc-reflection-server/bin/.gitignore @@ -1,3 +1,4 @@ /main/ /default/ /test/ +.flattened-pom.xml \ No newline at end of file diff --git a/rsocket-ipc-reflection-test/bin/.gitignore b/rsocket-ipc-reflection-test/bin/.gitignore index 1522af6d..f3c1854e 100644 --- a/rsocket-ipc-reflection-test/bin/.gitignore +++ b/rsocket-ipc-reflection-test/bin/.gitignore @@ -1,3 +1,4 @@ /main/ /default/ /test/ +.flattened-pom.xml \ No newline at end of file diff --git a/rsocket-rpc-core/bin/.gitignore b/rsocket-rpc-core/bin/.gitignore index 7eed456b..3c7975f9 100644 --- a/rsocket-rpc-core/bin/.gitignore +++ b/rsocket-rpc-core/bin/.gitignore @@ -1,2 +1,3 @@ /main/ /test/ +.flattened-pom.xml \ No newline at end of file From 7f9afd27b3fbfd4d8c64ee1c165e4023fff52e0f Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 31 Jul 2020 14:16:36 -0400 Subject: [PATCH 063/273] reflections --- rsocket-ipc-reflection-core/build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rsocket-ipc-reflection-core/build.gradle b/rsocket-ipc-reflection-core/build.gradle index 77141a00..4ad44857 100644 --- a/rsocket-ipc-reflection-core/build.gradle +++ b/rsocket-ipc-reflection-core/build.gradle @@ -3,7 +3,7 @@ description = 'RSocket IPC Reflection Mapping Support' dependencies { api project (':rsocket-ipc-core') - compile 'net.oneandone.reflections8:reflections:0.9.12' + compile 'org.reflections:reflections:0.9.12' testImplementation 'io.opentracing.brave:brave-opentracing' testImplementation 'junit:junit' From e2d435ec8dfa52bf4637f949639dd3e652b05b76 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 20 Aug 2020 15:30:52 -0400 Subject: [PATCH 064/273] Auto JGit Commit 8/20/20 - 3:30 PM --- gradle.properties | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/gradle.properties b/gradle.properties index 6673a727..caad14d8 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,8 +1,8 @@ group=io.rsocket.rpc version=0.3.0 -reactorBomVersion=Dysprosium-SR7 -rsocketVersion=1.0.0 +reactorBomVersion=Dysprosium-RELEASE +rsocketVersion=1.0.2 graphqlVersion=11.0 protobufVersion=3.7.1 log4jVersion=2.12.1 From 9a6e0cad5e7488e5793b22e04f22ddc54a44811c Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 22 Sep 2020 07:56:58 -0400 Subject: [PATCH 065/273] reflections8 --- .../io/rsocket/ipc/reflection/client/RSocketIPCClients.java | 2 +- .../java/io/rsocket/ipc/reflection/core/MethodMapUtils.java | 2 +- .../io/rsocket/ipc/reflection/core/PublisherConverters.java | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java index 751e2f69..1edddb26 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java @@ -18,7 +18,7 @@ import java.util.stream.Stream; import org.reactivestreams.Publisher; -import org.reflections.ReflectionUtils; +import org.reflections8.ReflectionUtils; import io.netty.buffer.ByteBuf; import io.rsocket.RSocket; diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java index eade0b76..a9219414 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java @@ -20,7 +20,7 @@ import java.util.logging.Logger; import java.util.stream.Stream; -import org.reflections.ReflectionUtils; +import org.reflections8.ReflectionUtils; import io.rsocket.ipc.util.IPCUtils; import javassist.Modifier; diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java index 29cd49be..7798d43d 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java @@ -13,7 +13,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import org.reflections.ReflectionUtils; +import org.reflections8.ReflectionUtils; public class PublisherConverters { From f518de7fdbf5323ebf8d01317791f1c8f2449fd1 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 22 Sep 2020 08:08:08 -0400 Subject: [PATCH 066/273] nevermind --- .../io/rsocket/ipc/reflection/client/RSocketIPCClients.java | 2 +- .../java/io/rsocket/ipc/reflection/core/MethodMapUtils.java | 2 +- .../io/rsocket/ipc/reflection/core/PublisherConverters.java | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java index 1edddb26..751e2f69 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java @@ -18,7 +18,7 @@ import java.util.stream.Stream; import org.reactivestreams.Publisher; -import org.reflections8.ReflectionUtils; +import org.reflections.ReflectionUtils; import io.netty.buffer.ByteBuf; import io.rsocket.RSocket; diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java index a9219414..eade0b76 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java @@ -20,7 +20,7 @@ import java.util.logging.Logger; import java.util.stream.Stream; -import org.reflections8.ReflectionUtils; +import org.reflections.ReflectionUtils; import io.rsocket.ipc.util.IPCUtils; import javassist.Modifier; diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java index 7798d43d..29cd49be 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java @@ -13,7 +13,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import org.reflections8.ReflectionUtils; +import org.reflections.ReflectionUtils; public class PublisherConverters { From b3c03a9a18b04b1e0203907b8258d975756200fd Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 22 Sep 2020 08:18:50 -0400 Subject: [PATCH 067/273] remove error consumer --- .../src/main/java/io/rsocket/ipc/reflection/ServerTest.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java index f83771a6..96477656 100644 --- a/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java +++ b/rsocket-ipc-reflection-test/src/main/java/io/rsocket/ipc/reflection/ServerTest.java @@ -28,8 +28,6 @@ public static void main(String[] args) throws InterruptedException { requestHandler = new RequestHandlingRSocketReflection(Schedulers.elastic(), new MetadataDecoderLFP()); SocketAcceptor socketAcceptor = (setup, client) -> Mono.just(requestHandler); RSocketServer.create(socketAcceptor).interceptors(ir -> { - }).errorConsumer(t -> { - java.util.logging.Logger.getLogger("[server]").log(Level.SEVERE, "uncaught error", t); }).bind(TcpServerTransport.create("localhost", 7000)).block(); } boolean releaseOnParse = true; From 6631a79bfe3c45047d3af27f0626c2466cd763fb Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 22 Sep 2020 08:51:44 -0400 Subject: [PATCH 068/273] reflections8 again --- .../io/rsocket/ipc/reflection/client/RSocketIPCClients.java | 2 +- rsocket-ipc-reflection-core/build.gradle | 2 +- .../java/io/rsocket/ipc/reflection/core/MethodMapUtils.java | 2 +- .../io/rsocket/ipc/reflection/core/PublisherConverters.java | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java index 751e2f69..1edddb26 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/RSocketIPCClients.java @@ -18,7 +18,7 @@ import java.util.stream.Stream; import org.reactivestreams.Publisher; -import org.reflections.ReflectionUtils; +import org.reflections8.ReflectionUtils; import io.netty.buffer.ByteBuf; import io.rsocket.RSocket; diff --git a/rsocket-ipc-reflection-core/build.gradle b/rsocket-ipc-reflection-core/build.gradle index 4ad44857..55b9bf84 100644 --- a/rsocket-ipc-reflection-core/build.gradle +++ b/rsocket-ipc-reflection-core/build.gradle @@ -3,7 +3,7 @@ description = 'RSocket IPC Reflection Mapping Support' dependencies { api project (':rsocket-ipc-core') - compile 'org.reflections:reflections:0.9.12' + compile 'net.oneandone.reflections8:reflections8:0.11.7' testImplementation 'io.opentracing.brave:brave-opentracing' testImplementation 'junit:junit' diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java index eade0b76..a9219414 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/MethodMapUtils.java @@ -20,7 +20,7 @@ import java.util.logging.Logger; import java.util.stream.Stream; -import org.reflections.ReflectionUtils; +import org.reflections8.ReflectionUtils; import io.rsocket.ipc.util.IPCUtils; import javassist.Modifier; diff --git a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java index 29cd49be..7798d43d 100644 --- a/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java +++ b/rsocket-ipc-reflection-core/src/main/java/io/rsocket/ipc/reflection/core/PublisherConverters.java @@ -13,7 +13,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import org.reflections.ReflectionUtils; +import org.reflections8.ReflectionUtils; public class PublisherConverters { From f8c1fba8def9667f1c0cd054f9f5bc6f93ed433d Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 22 Sep 2020 18:42:34 -0400 Subject: [PATCH 069/273] Auto JGit Commit 9/22/20 - 6:42 PM From 8eefc91bf925882a7e4aa46a83d24211f2ef8ee1 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 1 Oct 2020 17:37:47 -0400 Subject: [PATCH 070/273] bump reactor --- gradle.properties | 2 +- publishToMavenLocal.sh | 2 +- .../src/test/java/io/rsocket/ipc/IntegrationTest.java | 2 -- .../src/test/java/io/rsocket/ipc/MultiServiceTest.java | 2 -- 4 files changed, 2 insertions(+), 6 deletions(-) diff --git a/gradle.properties b/gradle.properties index caad14d8..ada4e35c 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,7 +1,7 @@ group=io.rsocket.rpc version=0.3.0 -reactorBomVersion=Dysprosium-RELEASE +reactorBomVersion=Dysprosium-SR11 rsocketVersion=1.0.2 graphqlVersion=11.0 protobufVersion=3.7.1 diff --git a/publishToMavenLocal.sh b/publishToMavenLocal.sh index f3edca34..acd4d90a 100644 --- a/publishToMavenLocal.sh +++ b/publishToMavenLocal.sh @@ -1,3 +1,3 @@ NOW=$(date +%s) echo "versionSuffix: -$NOW" -./gradlew build publishToMavenLocal -x test -x verifyGoogleJavaFormat -c settings.jitpack.gradle -PversionSuffix="-$NOW" "$@" +./gradlew build publishToMavenLocal -x test -x javadoc -x verifyGoogleJavaFormat -c settings.jitpack.gradle -PversionSuffix="-$NOW" "$@" diff --git a/rsocket-ipc-core/src/test/java/io/rsocket/ipc/IntegrationTest.java b/rsocket-ipc-core/src/test/java/io/rsocket/ipc/IntegrationTest.java index 4ca5bcec..3f52477d 100644 --- a/rsocket-ipc-core/src/test/java/io/rsocket/ipc/IntegrationTest.java +++ b/rsocket-ipc-core/src/test/java/io/rsocket/ipc/IntegrationTest.java @@ -57,8 +57,6 @@ public void test() { {// start server SocketAcceptor socketAcceptor = (setup, client) -> Mono.just(requestHandler); RSocketServer.create(socketAcceptor).interceptors(ir -> { - }).errorConsumer(t -> { - java.util.logging.Logger.getLogger("[server]").log(Level.SEVERE, "uncaught error", t); }).bind(TcpServerTransport.create("localhost", 7000)).block(); } RSocket rsocket; diff --git a/rsocket-ipc-core/src/test/java/io/rsocket/ipc/MultiServiceTest.java b/rsocket-ipc-core/src/test/java/io/rsocket/ipc/MultiServiceTest.java index 2469f365..a09a09d7 100644 --- a/rsocket-ipc-core/src/test/java/io/rsocket/ipc/MultiServiceTest.java +++ b/rsocket-ipc-core/src/test/java/io/rsocket/ipc/MultiServiceTest.java @@ -57,8 +57,6 @@ public void test() { {// start server SocketAcceptor socketAcceptor = (setup, client) -> Mono.just(requestHandler); RSocketServer.create(socketAcceptor).interceptors(ir -> { - }).errorConsumer(t -> { - java.util.logging.Logger.getLogger("[server]").log(Level.SEVERE, "uncaught error", t); }).bind(TcpServerTransport.create("localhost", 7000)).block(); } RSocket rsocket; From 3199a7d8fa38291f425856a3bca5371d1ddd0e73 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Sat, 3 Oct 2020 02:31:29 -0400 Subject: [PATCH 071/273] Auto JGit Commit 10/3/20 - 2:31 AM From b726706b8026e32313827ea609b0a114f150d925 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 5 Oct 2020 17:07:31 -0400 Subject: [PATCH 072/273] Auto JGit Commit 10/5/20 - 5:07 PM From 8b54cd8c5b8f0778a2c5d5bff5ee34d2e485b3a4 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 6 Oct 2020 14:48:53 -0400 Subject: [PATCH 073/273] Auto JGit Commit 10/6/20 - 2:48 PM From 2ce8ea3b2f92241cd0bf0c100ffa0dcda87bc258 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 12 Oct 2020 16:58:30 -0400 Subject: [PATCH 074/273] Auto JGit Commit 10/12/20 - 4:58 PM From af13587fcac837f6c2cf8772bd4f325820e665a9 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 12 Oct 2020 17:20:08 -0400 Subject: [PATCH 075/273] Auto JGit Commit 10/12/20 - 5:20 PM From af2c732bc981424d43f1d6ebdb9b77ed2e98bcea Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 12 Oct 2020 17:59:45 -0400 Subject: [PATCH 076/273] Auto JGit Commit 10/12/20 - 5:59 PM From e0c853e7ac36317c6bf8902f6198d61e4ac52a95 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 13 Oct 2020 09:30:47 -0400 Subject: [PATCH 077/273] Auto JGit Commit 10/13/20 - 9:30 AM From 368b49d1a38e09448e9c98b795e6013eefbf0fb7 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 15 Oct 2020 23:22:59 -0400 Subject: [PATCH 078/273] Auto JGit Commit 10/15/20 - 11:22 PM From ed4a505ee627aa471d14d7f6f1e312651e92dc1c Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 2 Nov 2020 17:28:19 -0500 Subject: [PATCH 079/273] Auto JGit Commit 11/2/20 - 5:28 PM From d9cccb533b6b313aaabf8fdb5b52768ab9f1de1d Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 25 Nov 2020 17:39:33 -0500 Subject: [PATCH 080/273] Auto JGit Commit 11/25/20 - 5:39 PM From 0cacbdeb8006e45953dd3edb201d83d28e356fdc Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 4 Dec 2020 13:21:42 -0500 Subject: [PATCH 081/273] Auto JGit Commit 12/4/20 - 1:21 PM From 7a30b803fd6851476027a53d6f79c06e21c71909 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 10 Dec 2020 12:57:30 -0500 Subject: [PATCH 082/273] Auto JGit Commit 12/10/20 - 12:57 PM From 67120bc464b61a22771507ee45e69f70865526b6 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 22 Dec 2020 01:26:18 -0500 Subject: [PATCH 083/273] Auto JGit Commit 12/22/20 - 1:26 AM From 88afe25b43f53fcfa1b65d5c4554f3125c6525b6 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 31 Dec 2020 13:03:59 -0500 Subject: [PATCH 084/273] Auto JGit Commit 12/31/20 - 1:03 PM From e2ecfbbe92e5402b6038ec9e9cccc51b6a38edef Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 4 Jan 2021 18:26:22 -0500 Subject: [PATCH 085/273] Auto JGit Commit 1/4/21 - 6:26 PM From 6c64c1a9cb8478a5314d9bed7ba0268e3eb297d2 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 5 Jan 2021 18:30:27 -0500 Subject: [PATCH 086/273] Auto JGit Commit 1/5/21 - 6:30 PM From ae0080ac8563712f624eef88868a30bcfafc6740 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 6 Jan 2021 17:14:51 -0500 Subject: [PATCH 087/273] Auto JGit Commit 1/6/21 - 5:14 PM From b3380ae4c913097e008784de3cf9dbff7ecba800 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 14 Jan 2021 16:20:37 -0500 Subject: [PATCH 088/273] Auto JGit Commit 1/14/21 - 4:20 PM From 90bf4184b89330fdd52d6245630e6c28d1d620d6 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 14 Jan 2021 16:51:15 -0500 Subject: [PATCH 089/273] Auto JGit Commit 1/14/21 - 4:51 PM From 24eaed5b2d888dff6138087828e3e3e4fbf0e502 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 21 Jan 2021 18:39:40 -0500 Subject: [PATCH 090/273] Auto JGit Commit 1/21/21 - 6:39 PM From 5f3d2b5dc5ecbe14c5116d1d19a026de20deedb8 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 26 Jan 2021 18:29:45 -0500 Subject: [PATCH 091/273] Auto JGit Commit 1/26/21 - 6:29 PM --- rsocket-ipc-graphql/bin/test/schema.graphqls | 30 ++++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/rsocket-ipc-graphql/bin/test/schema.graphqls b/rsocket-ipc-graphql/bin/test/schema.graphqls index b69429c7..8875bafe 100644 --- a/rsocket-ipc-graphql/bin/test/schema.graphqls +++ b/rsocket-ipc-graphql/bin/test/schema.graphqls @@ -1,16 +1,16 @@ -type Query { - bookById(id: ID): Book -} - -type Book { - id: ID - name: String - pageCount: Int - author: Author -} - -type Author { - id: ID - firstName: String - lastName: String +type Query { + bookById(id: ID): Book +} + +type Book { + id: ID + name: String + pageCount: Int + author: Author +} + +type Author { + id: ID + firstName: String + lastName: String } \ No newline at end of file From 27339d64cf297deb1b935f76044db47e165c698c Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 29 Jan 2021 05:59:01 -0500 Subject: [PATCH 092/273] Auto JGit Commit 1/29/21 - 5:59 AM From 15c57d08c20eec7af6e3b6b235c8c3a7d3b8bde1 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 2 Feb 2021 18:35:44 -0500 Subject: [PATCH 093/273] Auto JGit Commit 2/2/21 - 6:35 PM From b4c7d291d10f6666a1cec329414e5f3b3e32edf8 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 4 Feb 2021 18:48:07 -0500 Subject: [PATCH 094/273] Auto JGit Commit 2/4/21 - 6:48 PM From 1aaf4e2041bc297755813322d468622ed4a9537f Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 5 Feb 2021 18:50:47 -0500 Subject: [PATCH 095/273] Auto JGit Commit 2/5/21 - 6:50 PM From 51c2dc4522048d0b180f6f3fb6a9cba37341bae3 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 8 Feb 2021 18:39:14 -0500 Subject: [PATCH 096/273] Auto JGit Commit 2/8/21 - 6:39 PM From bb10c813b5370954c151d1845af92086305122c8 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Sat, 13 Feb 2021 09:37:01 -0500 Subject: [PATCH 097/273] Auto JGit Commit 2/13/21 - 9:36 AM From 63710cacd320750d14ce726cc6d0a2669b0e141c Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 15 Feb 2021 14:25:02 -0500 Subject: [PATCH 098/273] Auto JGit Commit 2/15/21 - 2:24 PM From 3ea45dac48b6f6cc28d1f1279c3e7b65d8e8df18 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 18 Feb 2021 00:52:38 -0500 Subject: [PATCH 099/273] Auto JGit Commit 2/18/21 - 12:52 AM From 35bbb3fb37211ced3d17ca19d076948b743a1e5e Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 22 Feb 2021 18:47:48 -0500 Subject: [PATCH 100/273] Auto JGit Commit 2/22/21 - 6:47 PM From fb4e0ff118436f3ec7028b59d1fc980ceae0d7d3 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 22 Feb 2021 21:46:39 -0500 Subject: [PATCH 101/273] Auto JGit Commit 2/22/21 - 9:46 PM From 168b3361519f3cb603f7125ab6a88b3dd06465c7 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 22 Feb 2021 23:30:57 -0500 Subject: [PATCH 102/273] Auto JGit Commit 2/22/21 - 11:30 PM From f570c5d8f6366f2c991aeee7ebdec6b900386f54 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 24 Feb 2021 00:16:14 -0500 Subject: [PATCH 103/273] Auto JGit Commit 2/24/21 - 12:16 AM From 82cbf603cca0c7dad8336cc82910fc3899751439 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 24 Feb 2021 00:32:33 -0500 Subject: [PATCH 104/273] Auto JGit Commit 2/24/21 - 12:32 AM From 4bca009a830bd47e3ac2f29d3a9ea64b1d33b5a1 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 24 Feb 2021 23:36:02 -0500 Subject: [PATCH 105/273] Auto JGit Commit 2/24/21 - 11:35 PM From 653021ea4f60e0138368f59f74c368ea0ebac55a Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 25 Feb 2021 18:55:12 -0500 Subject: [PATCH 106/273] Auto JGit Commit 2/25/21 - 6:55 PM From b4c35338560ddec37a2bc000b0ad6c8ac982fb0a Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 26 Feb 2021 00:16:10 -0500 Subject: [PATCH 107/273] Auto JGit Commit 2/26/21 - 12:16 AM From 6a2c6a84c22c18155ff7b5c60578735091f17a3d Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 26 Feb 2021 17:59:29 -0500 Subject: [PATCH 108/273] Auto JGit Commit 2/26/21 - 5:59 PM From fa1b9c6ac9cc62792181bc672ca4170bd6cf2a3d Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 1 Mar 2021 14:09:38 -0500 Subject: [PATCH 109/273] Auto JGit Commit 3/1/21 - 2:09 PM From d26f7ab1ddff9511942c5cd9f134d907488fc186 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 3 Mar 2021 22:32:24 -0500 Subject: [PATCH 110/273] Auto JGit Commit 3/3/21 - 10:32 PM From d56c884bfacc028f88883db417906e84906daa8b Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Sat, 6 Mar 2021 16:49:14 -0500 Subject: [PATCH 111/273] Auto JGit Commit 3/6/21 - 4:49 PM From 5e03d8ad77ef15cc03ac038360c55d023986162c Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 8 Mar 2021 09:52:18 -0500 Subject: [PATCH 112/273] Auto JGit Commit 3/8/21 - 9:52 AM From 400bd2bd99f84508ee97b7b25da79274322c3414 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 8 Mar 2021 13:07:59 -0500 Subject: [PATCH 113/273] Auto JGit Commit 3/8/21 - 1:07 PM From 5e77ec904b66e88177878be5621a8d55b8be3656 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 12 Mar 2021 14:45:30 -0500 Subject: [PATCH 114/273] Auto JGit Commit 3/12/21 - 2:45 PM From 6a14910061dff4b767ad06568d84cb85ec787de1 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 15 Mar 2021 06:01:31 -0400 Subject: [PATCH 115/273] Auto JGit Commit 3/15/21 - 6:01 AM From fab6c6483d6af1797a75411e32e8b6283aef8784 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 15 Mar 2021 16:22:54 -0400 Subject: [PATCH 116/273] Auto JGit Commit 3/15/21 - 4:22 PM From 04ae401064777a0c9ba7a361aeafbccbb321088a Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 15 Mar 2021 17:18:49 -0400 Subject: [PATCH 117/273] Auto JGit Commit 3/15/21 - 5:18 PM From 9d09a6f74aca5caf53007cb2c832d58a1ab4fbe9 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 16 Mar 2021 16:46:08 -0400 Subject: [PATCH 118/273] Auto JGit Commit 3/16/21 - 4:46 PM From c892163c44b4c6c1caf7745b6253aa4c466922ab Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 17 Mar 2021 19:26:29 -0400 Subject: [PATCH 119/273] Auto JGit Commit 3/17/21 - 7:26 PM From 56f117b403cc3853d0053983716613d6ec480c27 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 18 Mar 2021 16:57:14 -0400 Subject: [PATCH 120/273] Auto JGit Commit 3/18/21 - 4:57 PM From 954571bb95610dd738af164598a99163c193b45a Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 22 Mar 2021 11:24:43 -0400 Subject: [PATCH 121/273] Auto JGit Commit 3/22/21 - 11:24 AM From 0c965d0c88c54c4f13c07a88b675a5c2090e16c1 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 23 Mar 2021 13:04:59 -0400 Subject: [PATCH 122/273] Auto JGit Commit 3/23/21 - 1:04 PM From 6875b900a8e738a3a17e1e843811a56d767365e7 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 24 Mar 2021 19:25:28 -0400 Subject: [PATCH 123/273] Auto JGit Commit 3/24/21 - 7:25 PM From b973f7c9c9d3ee7f7b6f51a2930a70f12a891711 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 25 Mar 2021 12:44:26 -0400 Subject: [PATCH 124/273] Auto JGit Commit 3/25/21 - 12:44 PM From 9ca3d178174400ae2c17e404d0dea6f0ab1ae597 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 25 Mar 2021 21:39:42 -0400 Subject: [PATCH 125/273] Auto JGit Commit 3/25/21 - 9:39 PM From e821392e2e3bae1f8d070eac6f291e5a8e2a2826 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 29 Mar 2021 17:10:54 -0400 Subject: [PATCH 126/273] Auto JGit Commit 3/29/21 - 5:10 PM From 0e4c857d93dc3d75f85527694e51536e7d485a8e Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 5 Apr 2021 16:58:58 -0400 Subject: [PATCH 127/273] Auto JGit Commit 4/5/21 - 4:58 PM From 76768dc327978805e3f802adc11e2b9052d3d201 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 8 Apr 2021 01:45:32 -0400 Subject: [PATCH 128/273] Auto JGit Commit 4/8/21 - 1:45 AM From dfe37f386b31af01f7a965a18361a5ebb24b51b6 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 13 Apr 2021 16:55:51 -0400 Subject: [PATCH 129/273] Auto JGit Commit 4/13/21 - 4:55 PM From c0f396fb1ed287f212fe8f1bfab4e7080495ba6f Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 15 Apr 2021 19:14:39 -0400 Subject: [PATCH 130/273] Auto JGit Commit 4/15/21 - 7:14 PM From 1b9757ef5dfd22afb74f6b8e5321e9d9afb82dce Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 16 Apr 2021 17:48:23 -0400 Subject: [PATCH 131/273] Auto JGit Commit 4/16/21 - 5:48 PM From b7570f5b6e4a4d43a315e5e338a3dfd3c59eb38b Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 19 Apr 2021 00:00:24 -0400 Subject: [PATCH 132/273] Auto JGit Commit 4/19/21 - 12:00 AM From d70a82214840cd01b47f5b28f028d6edecb700cc Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 19 Apr 2021 23:46:41 -0400 Subject: [PATCH 133/273] Auto JGit Commit 4/19/21 - 11:46 PM From 1f659bb26c75baf7a6e6a784384a209739a416dd Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 20 Apr 2021 16:52:02 -0400 Subject: [PATCH 134/273] Auto JGit Commit 4/20/21 - 4:51 PM From c4735ce645adba66611bb2f44eaf26494ee21afa Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 22 Apr 2021 00:31:29 -0400 Subject: [PATCH 135/273] Auto JGit Commit 4/22/21 - 12:31 AM From 09849b757f79faac28f776d9a4ab2ef1016d57c0 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 22 Apr 2021 13:23:43 -0400 Subject: [PATCH 136/273] Auto JGit Commit 4/22/21 - 1:23 PM From 99dd6cfb57675fb5d5096667dc5ff58a3bc99f9d Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 26 Apr 2021 23:07:48 -0400 Subject: [PATCH 137/273] Auto JGit Commit 4/26/21 - 11:07 PM From 5e15d4bae8cb86d6feb10b07e99504baf34867db Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 29 Apr 2021 13:31:27 -0400 Subject: [PATCH 138/273] Auto JGit Commit 4/29/21 - 1:31 PM From fe4ca4dfe0a953c0452f185ed4ae448ee6d4985f Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 29 Apr 2021 15:43:21 -0400 Subject: [PATCH 139/273] Auto JGit Commit 4/29/21 - 3:43 PM From 897d0cce63dcd504814973570987f69dae99199e Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 3 May 2021 18:14:16 -0400 Subject: [PATCH 140/273] script --- publishToMavenLocal.ps1 | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 publishToMavenLocal.ps1 diff --git a/publishToMavenLocal.ps1 b/publishToMavenLocal.ps1 new file mode 100644 index 00000000..708abdcf --- /dev/null +++ b/publishToMavenLocal.ps1 @@ -0,0 +1,4 @@ +$NOW=[Math]::Round((Get-Date).ToFileTime() / 10000000 - 11644473600) +echo "versionSuffix: -$NOW" +echo "args: $args" +./gradlew build publishToMavenLocal -x test -x javadoc -x verifyGoogleJavaFormat -c settings.jitpack.gradle -PversionSuffix="-$NOW" "$args" From 04bee746c7faf22ffdcb0ca793332365098186b0 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 3 May 2021 18:22:50 -0400 Subject: [PATCH 141/273] lazy --- .../java/io/rsocket/ipc/decoders/MetadataWriter.java | 6 +++--- .../io/rsocket/ipc/reflection/client/LazyRSocket.java | 11 +---------- 2 files changed, 4 insertions(+), 13 deletions(-) diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java index cfecf693..bb8e05da 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/decoders/MetadataWriter.java @@ -20,7 +20,7 @@ import io.netty.buffer.CompositeByteBuf; import io.rsocket.ipc.mimetype.MimeType; import io.rsocket.ipc.util.IPCUtils; -import io.rsocket.metadata.CompositeMetadataFlyweight; +import io.rsocket.metadata.CompositeMetadataCodec; import io.rsocket.metadata.WellKnownMimeType; public class MetadataWriter { @@ -120,10 +120,10 @@ public void write(MimeType mimeType, Stream valueStream, Function wellKnownMimeTypeOp = mimeType.getWellKnownMimeType(); stream.forEach(bb -> { if (wellKnownMimeTypeOp.isPresent()) - CompositeMetadataFlyweight.encodeAndAddMetadata(getCompositeByteBuf(), allocator, + CompositeMetadataCodec.encodeAndAddMetadata(getCompositeByteBuf(), allocator, wellKnownMimeTypeOp.get(), bb); else - CompositeMetadataFlyweight.encodeAndAddMetadata(getCompositeByteBuf(), allocator, mimeType.getString(), + CompositeMetadataCodec.encodeAndAddMetadata(getCompositeByteBuf(), allocator, mimeType.getString(), bb); }); diff --git a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java index e02597f9..182fb229 100644 --- a/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java +++ b/rsocket-ipc-reflection-client/src/main/java/io/rsocket/ipc/reflection/client/LazyRSocket.java @@ -7,11 +7,10 @@ import io.rsocket.Payload; import io.rsocket.RSocket; -import io.rsocket.ResponderRSocket; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; -public abstract class LazyRSocket implements ResponderRSocket { +public abstract class LazyRSocket implements RSocket { public static LazyRSocket create(Supplier rsocketSupplier) { Objects.requireNonNull(rsocketSupplier); @@ -46,14 +45,6 @@ public Flux requestChannel(Publisher payloads) { return getRSocket().requestChannel(payloads); } - @Override - public Flux requestChannel(Payload payload, Publisher payloads) { - RSocket rSocket = getRSocket(); - if (rSocket instanceof ResponderRSocket) - return ((ResponderRSocket) rSocket).requestChannel(payload, payloads); - return rSocket.requestChannel(payloads); - } - @Override public Mono metadataPush(Payload payload) { return getRSocket().metadataPush(payload); From ece92085207d41c8a21814f4261b47c19d1159a4 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 4 May 2021 01:47:54 -0400 Subject: [PATCH 142/273] Auto JGit Commit 5/4/21 - 1:47 AM From 2f2abf0f42a45b0acb84bfeb5db1d7d364663e4d Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 5 May 2021 17:06:07 -0400 Subject: [PATCH 143/273] Auto JGit Commit 5/5/21 - 5:06 PM From 55fd85796fad85b3ce774668009bb099838fa10c Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 12 May 2021 18:45:34 -0400 Subject: [PATCH 144/273] Auto JGit Commit 5/12/21 - 6:45 PM From eb9050f594fac4a2e93369c8d4aa88e22e6c758c Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 13 May 2021 17:04:26 -0400 Subject: [PATCH 145/273] Auto JGit Commit 5/13/21 - 5:04 PM From f3dda100900470572f206e76abb511b997044c5c Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 19 May 2021 01:01:27 -0400 Subject: [PATCH 146/273] Auto JGit Commit 5/19/21 - 1:01 AM From b1cac77ec851f8179a3a8164ddca5b824cfe6b7d Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 20 May 2021 16:08:59 -0400 Subject: [PATCH 147/273] Auto JGit Commit 5/20/21 - 4:08 PM From e71a4f55b67816e834b654ed155e7947fa3ba190 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 26 May 2021 00:11:33 -0400 Subject: [PATCH 148/273] Auto JGit Commit 5/26/21 - 12:11 AM From 8925a79876857363a08fe7632aefa8263aec6ee1 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 28 May 2021 00:54:42 -0400 Subject: [PATCH 149/273] Auto JGit Commit 5/28/21 - 12:54 AM From 53dafa010b8736411de31a246ce39108109a0501 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 28 May 2021 18:30:48 -0400 Subject: [PATCH 150/273] Auto JGit Commit 5/28/21 - 6:30 PM From a2e8c78f5580cf77f75e76d01713824c4b5563bd Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 28 May 2021 18:32:29 -0400 Subject: [PATCH 151/273] Auto JGit Commit 5/28/21 - 6:32 PM From de08e50adb33d871d42a3465fd431c03030e95fd Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 3 Jun 2021 18:25:47 -0400 Subject: [PATCH 152/273] Auto JGit Commit 6/3/21 - 6:25 PM From 58ac502232c1af64ace807fd525ecc8086c00145 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 3 Jun 2021 22:38:29 -0400 Subject: [PATCH 153/273] Auto JGit Commit 6/3/21 - 10:38 PM From 3bfcf05573095fd4226d15d89151a7bafecb30a0 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 4 Jun 2021 17:06:24 -0400 Subject: [PATCH 154/273] Auto JGit Commit 6/4/21 - 5:06 PM From 06519aa09ad0fe1baa0e4d2279eead975869ace5 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 7 Jun 2021 22:37:36 -0400 Subject: [PATCH 155/273] Auto JGit Commit 6/7/21 - 10:37 PM From 8c2f50b956dc2f466de54784daab2ac307ee2190 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 10 Jun 2021 17:02:09 -0400 Subject: [PATCH 156/273] Auto JGit Commit 6/10/21 - 5:02 PM From e3b8d7c819d8ebac2f804a15ba70e1d8221ee529 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 10 Jun 2021 17:12:36 -0400 Subject: [PATCH 157/273] Auto JGit Commit 6/10/21 - 5:12 PM From 60a94c6829f29ac128721af944d0993694a653de Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 11 Jun 2021 17:03:42 -0400 Subject: [PATCH 158/273] Auto JGit Commit 6/11/21 - 5:03 PM From b2f2e887c1b902c9b5ab21e6b208350cdee8d011 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 17 Jun 2021 09:00:36 -0400 Subject: [PATCH 159/273] Auto JGit Commit 6/17/21 - 9:00 AM From ea10aff12860505d4401f26235c13f31806aab98 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 25 Jun 2021 16:41:47 -0400 Subject: [PATCH 160/273] Auto JGit Commit 6/25/21 - 4:41 PM From e61a0294d430ef68be262e1eb63182590950dd85 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 29 Jun 2021 15:36:10 -0400 Subject: [PATCH 161/273] Auto JGit Commit 6/29/21 - 3:36 PM From 2fd060de4bfa490a9280587defb587a587d8cf8b Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 7 Jul 2021 16:14:24 -0400 Subject: [PATCH 162/273] Auto JGit Commit 7/7/21 - 4:14 PM From 82b68551b4c67191434b7f6f4b1270f6949eec0f Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 20 Jul 2021 18:24:25 -0400 Subject: [PATCH 163/273] Auto JGit Commit 7/20/21 - 6:24 PM From 17a016fbc4a0a59cc1acf3c1556ccb38e35c1c90 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 27 Jul 2021 16:40:53 -0400 Subject: [PATCH 164/273] Auto JGit Commit 7/27/21 - 4:40 PM From bf72cb9105a19825ac365ef499d54dc67a5d0bfd Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 28 Jul 2021 19:11:07 -0400 Subject: [PATCH 165/273] Auto JGit Commit 7/28/21 - 7:11 PM From 91599727ad4ab17e9279ead28d83e0043d5e559a Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 25 Aug 2021 17:49:43 -0400 Subject: [PATCH 166/273] Auto JGit Commit 8/25/21 - 5:49 PM From 21561d252312fa146eda1583ddcf47ae90277427 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 1 Sep 2021 00:18:13 -0400 Subject: [PATCH 167/273] Auto JGit Commit 9/1/21 - 12:18 AM From 18c8bfacc3c84d380ca723475a486e891c95c580 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 1 Sep 2021 07:49:59 -0400 Subject: [PATCH 168/273] Auto JGit Commit 9/1/21 - 7:49 AM From cbd74335449fa6444f97de6966934134829d91db Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 1 Sep 2021 14:17:05 -0400 Subject: [PATCH 169/273] Auto JGit Commit 9/1/21 - 2:16 PM From 77ef0d8d52aa876f107ac2a519b234ba7df21c20 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 2 Sep 2021 17:03:38 -0400 Subject: [PATCH 170/273] Auto JGit Commit 9/2/21 - 5:03 PM From 1c887a1fc6a3307d3c0f509d05f9b6a887141a73 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 8 Sep 2021 18:46:38 -0400 Subject: [PATCH 171/273] Auto JGit Commit 9/8/21 - 6:46 PM From f207a9309f4b9475ad846dd09e4ad1de4c9f0bee Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 9 Sep 2021 14:09:57 -0400 Subject: [PATCH 172/273] Auto JGit Commit 9/9/21 - 2:09 PM From df116f233defef7f7c24ee3b6271b3a8900779d6 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 14 Sep 2021 18:57:13 -0400 Subject: [PATCH 173/273] Auto JGit Commit 9/14/21 - 6:57 PM From 920756598e1bf1b0a571b003da96172bf75d924b Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 17 Sep 2021 16:25:56 -0400 Subject: [PATCH 174/273] Auto JGit Commit 9/17/21 - 4:25 PM From 7f660014c48e9c99bb1e3a52b2517cd2e4123680 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 20 Sep 2021 18:40:02 -0400 Subject: [PATCH 175/273] Auto JGit Commit 9/20/21 - 6:40 PM From c82a9fd7d68d94c606795371d3608817efb29be5 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 21 Sep 2021 20:29:44 -0400 Subject: [PATCH 176/273] Auto JGit Commit 9/21/21 - 8:29 PM From d45827fe93480a23d25e2cbcea3b541efee64626 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 24 Sep 2021 17:41:27 -0400 Subject: [PATCH 177/273] Auto JGit Commit 9/24/21 - 5:41 PM From 8e03e13c8fc1c18b6f90e2b1994d2f8ef6a84ade Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 24 Sep 2021 17:44:50 -0400 Subject: [PATCH 178/273] Auto JGit Commit 9/24/21 - 5:44 PM From fd93ad973e6bf40676f2c839a4568e27bc305f58 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 27 Sep 2021 18:44:21 -0400 Subject: [PATCH 179/273] Auto JGit Commit 9/27/21 - 6:44 PM From e7e009eabf91ecd5c2553e807657daeb2550dac6 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 28 Sep 2021 19:08:07 -0400 Subject: [PATCH 180/273] Auto JGit Commit 9/28/21 - 7:07 PM From fcd30d7bfdec33463e4956a5e990f11398cd99b6 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 29 Sep 2021 04:01:50 -0400 Subject: [PATCH 181/273] Auto JGit Commit 9/29/21 - 4:01 AM From 14a26c7e28233ea1da1bcad967f83a6de2394a16 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 1 Oct 2021 15:23:49 -0400 Subject: [PATCH 182/273] Auto JGit Commit 10/1/21 - 3:23 PM From 8b3e4f023baa854f575eabee11f750a9c893b0ca Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 4 Oct 2021 00:21:21 -0400 Subject: [PATCH 183/273] Auto JGit Commit 10/4/21 - 12:21 AM From 71645546011d10b2cbb24d9aa368a46398babdfd Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 4 Oct 2021 12:18:25 -0400 Subject: [PATCH 184/273] Auto JGit Commit 10/4/21 - 12:18 PM From 2cffab4505887a72e346feaa08bfbec4b17a3e11 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 6 Oct 2021 13:32:23 -0400 Subject: [PATCH 185/273] Auto JGit Commit 10/6/21 - 1:32 PM From dca4f7374f6e04939b9962fb34e1dfbc2ad6f92e Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 Oct 2021 16:12:41 -0400 Subject: [PATCH 186/273] Auto JGit Commit 10/8/21 - 4:12 PM From 752df3b80adc5a93ad8f747dea1059e00b615f63 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 11 Oct 2021 20:25:51 -0400 Subject: [PATCH 187/273] Auto JGit Commit 10/11/21 - 8:25 PM From 50f0bed05944edf09c6524470030106bb1d65759 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 12 Oct 2021 18:45:29 -0400 Subject: [PATCH 188/273] Auto JGit Commit 10/12/21 - 6:45 PM From 538a6ff5c2c82d933341c3e354e1d2ccfeb361c7 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 15 Oct 2021 17:26:23 -0400 Subject: [PATCH 189/273] Auto JGit Commit 10/15/21 - 5:26 PM From 1bc036d54fcd63665a87b9cc5d2b0514181186d2 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 18 Oct 2021 23:45:23 -0400 Subject: [PATCH 190/273] Auto JGit Commit 10/18/21 - 11:45 PM From 9fb1d258ea484346025f747aa3ee82b04901ee08 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 19 Oct 2021 20:12:48 -0400 Subject: [PATCH 191/273] Auto JGit Commit 10/19/21 - 8:12 PM From b5191a94e62d14cb2d08626de0ecdd90f3f368c5 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 4 Nov 2021 02:28:38 -0400 Subject: [PATCH 192/273] Auto JGit Commit 11/4/21 - 2:28 AM From 11c719de8b6659189afb7bdaf04fef155d83d3e9 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 10 Nov 2021 19:40:38 -0500 Subject: [PATCH 193/273] Auto JGit Commit 11/10/21 - 7:40 PM From 78fbab632f063268cd544510d4e7b5820d9492a8 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 12 Nov 2021 01:17:20 -0500 Subject: [PATCH 194/273] Auto JGit Commit 11/12/21 - 1:17 AM From 20e48462a33b7cdcb6e97f45f16f4b49febb236f Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 12 Nov 2021 17:32:10 -0500 Subject: [PATCH 195/273] Auto JGit Commit 11/12/21 - 5:32 PM From c112e602d5ee911bbe97ed3bdff1f2389c9d2505 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 18 Nov 2021 01:51:41 -0500 Subject: [PATCH 196/273] Auto JGit Commit 11/18/21 - 1:51 AM From 18d93793b124a27b2c6ef70a1d5f3dbd07b9dc60 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 23 Nov 2021 18:17:44 -0500 Subject: [PATCH 197/273] Auto JGit Commit 11/23/21 - 6:17 PM --- .../src/main/java/io/rsocket/ipc/util/IPCUtils.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java index 13d46906..2b19b96d 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java @@ -1,6 +1,6 @@ package io.rsocket.ipc.util; -import java.io.UnsupportedEncodingException; +import com.lfp.joe.core.lots.AbstractLot; import java.io.UnsupportedEncodingException; import java.net.URLDecoder; import java.net.URLEncoder; import java.nio.charset.Charset; @@ -16,7 +16,7 @@ import java.util.Optional; import java.util.Spliterator; import java.util.Spliterators; -import java.util.Spliterators.AbstractSpliterator; +import java.util.Spliterators.AbstractLot; import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.atomic.AtomicReference; import java.util.function.Consumer; @@ -57,7 +57,7 @@ public static Stream flatMap(Stream> streams) { if (streams == null) return Stream.empty(); Iterator> iter = streams.iterator(); - Spliterator spliterator = new AbstractSpliterator(Long.MAX_VALUE, Spliterator.ORDERED) { + Spliterator spliterator = new AbstractLot(Long.MAX_VALUE, Spliterator.ORDERED) { private Iterator currentIterator; From 54bea81192c02998988040c0fc7abbdf5fb3da43 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 24 Nov 2021 05:08:41 -0500 Subject: [PATCH 198/273] Auto JGit Commit 11/24/21 - 5:08 AM From 5ea10d8dc76bee9479e62bbc8b0b9bfb98bcfc0f Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 24 Nov 2021 12:40:25 -0500 Subject: [PATCH 199/273] Auto JGit Commit 11/24/21 - 12:40 PM From 74ee2fae1fa7ffa7b780c1230183692774a97b2c Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 30 Nov 2021 21:08:49 -0500 Subject: [PATCH 200/273] Auto JGit Commit 11/30/21 - 9:08 PM From 761830fdcca8e84ffd9ceccaa291c6a218191043 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 2 Dec 2021 00:01:28 -0500 Subject: [PATCH 201/273] Auto JGit Commit 12/2/21 - 12:01 AM From 5e986860f123a2ad5f749f414c0dea67209448ba Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 3 Dec 2021 01:34:44 -0500 Subject: [PATCH 202/273] Auto JGit Commit 12/3/21 - 1:34 AM From d48696cca56c686492752eb74283ce63db66eb88 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 6 Dec 2021 18:37:10 -0500 Subject: [PATCH 203/273] Auto JGit Commit 12/6/21 - 6:37 PM From aa84f6dd45ee804e6bbc8ea597499a0ae1b0a93e Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 9 Dec 2021 00:23:37 -0500 Subject: [PATCH 204/273] Auto JGit Commit 12/9/21 - 12:23 AM From 8c9bd3d84fea405fd4a01f130415e127c47f33cf Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 10 Dec 2021 18:47:34 -0500 Subject: [PATCH 205/273] Auto JGit Commit 12/10/21 - 6:47 PM From 5bdbf121b9bead70898d226f89dc592337a03531 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 4 Jan 2022 19:01:05 -0500 Subject: [PATCH 206/273] Auto JGit Commit 1/4/22 - 7:01 PM From cf290c2f0a71e326578ab236a2853ce5c5686227 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 5 Jan 2022 01:13:01 -0500 Subject: [PATCH 207/273] Auto JGit Commit 1/5/22 - 1:13 AM From ce5e94a38f0926eab935c9db5f5f92d870124d43 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 6 Jan 2022 12:56:08 -0500 Subject: [PATCH 208/273] Auto JGit Commit 1/6/22 - 12:55 PM From c440a840fd5acbf575e672e292ea90effd1a5847 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 7 Jan 2022 18:37:39 -0500 Subject: [PATCH 209/273] Auto JGit Commit 1/7/22 - 6:37 PM From 25dfac52a45c918384ec37fe36cfd7ea92d9079a Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 10 Jan 2022 15:06:56 -0500 Subject: [PATCH 210/273] Auto JGit Commit 1/10/22 - 3:06 PM From 7d84b1465660c8cd4092ee16a040c5b294e4de85 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 11 Jan 2022 01:22:32 -0500 Subject: [PATCH 211/273] Auto JGit Commit 1/11/22 - 1:22 AM From 168fb1a8fd814228fe077a9f097e3bc9d04d3baf Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 24 Jan 2022 11:46:30 -0500 Subject: [PATCH 212/273] Auto JGit Commit 1/24/22 - 11:46 AM From 0c4215a09256e794fce44d7023fd56441f925501 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 28 Jan 2022 18:20:21 -0500 Subject: [PATCH 213/273] Auto JGit Commit 1/28/22 - 6:20 PM From 22187f46c147e8c83daa004922b6867775eb3a97 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 9 Feb 2022 19:36:33 -0500 Subject: [PATCH 214/273] Auto JGit Commit 2/9/22 - 7:36 PM From a9bc3b5f3e81fac21e13ae288403d4be0e54f597 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 15 Feb 2022 17:22:41 -0500 Subject: [PATCH 215/273] Auto JGit Commit 2/15/22 - 5:22 PM From 66e6623b948b8973edde90e79423a6f0092c33c1 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 16 Feb 2022 16:49:40 -0500 Subject: [PATCH 216/273] Auto JGit Commit 2/16/22 - 4:49 PM From 13233a6680f8ee2c404aac611965a322d5acacf6 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 17 Feb 2022 23:39:14 -0500 Subject: [PATCH 217/273] Auto JGit Commit 2/17/22 - 11:39 PM From 28549820bffb3ecfe3056e68128879df52775e41 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 18 Feb 2022 14:02:33 -0500 Subject: [PATCH 218/273] Auto JGit Commit 2/18/22 - 2:02 PM From 79015a28e1e93976cd4fd1638a6b7de909c7c2e5 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 23 Feb 2022 18:28:45 -0500 Subject: [PATCH 219/273] Auto JGit Commit 2/23/22 - 6:28 PM --- .../src/main/java/io/rsocket/ipc/util/IPCUtils.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java index 2b19b96d..54841c2a 100644 --- a/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java +++ b/rsocket-ipc-core/src/main/java/io/rsocket/ipc/util/IPCUtils.java @@ -1,6 +1,6 @@ package io.rsocket.ipc.util; -import com.lfp.joe.core.lots.AbstractLot; import java.io.UnsupportedEncodingException; +import com.lfp.joe.core.lot.AbstractLot; import java.io.UnsupportedEncodingException; import java.net.URLDecoder; import java.net.URLEncoder; import java.nio.charset.Charset; From a183284920b878cce875b0e31995184c279f248a Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 25 Feb 2022 17:03:56 -0500 Subject: [PATCH 220/273] Auto JGit Commit 2/25/22 - 5:03 PM From 0fe4b97e3ddb7de92536bd9b68ad57bf347a5585 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 28 Feb 2022 18:20:39 -0500 Subject: [PATCH 221/273] Auto JGit Commit 2/28/22 - 6:20 PM From e066b64ac93bee17ebebf099221fbd538f159381 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 10 Mar 2022 19:08:18 -0500 Subject: [PATCH 222/273] Auto JGit Commit 3/10/22 - 7:08 PM From 71646144159a46c4e309d084f86b7f81dcc78d8e Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 16 Mar 2022 19:16:23 -0400 Subject: [PATCH 223/273] Auto JGit Commit 3/16/22 - 7:16 PM From aa5b2ac83ae9583b07f300132341c2b494080a9d Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 17 Mar 2022 04:28:07 -0400 Subject: [PATCH 224/273] Auto JGit Commit 3/17/22 - 4:28 AM From 6d4c825bbc6395170726afdfecdbe57ec09ebe9e Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 17 Mar 2022 19:20:14 -0400 Subject: [PATCH 225/273] Auto JGit Commit 3/17/22 - 7:20 PM From 4423f4ad0fd9221c22bcded423be76f79e4e5723 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 21 Mar 2022 13:32:37 -0400 Subject: [PATCH 226/273] Auto JGit Commit 3/21/22 - 1:32 PM From e2be5647c9b2c6a80e076c76aa79892949b7c01c Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 23 Mar 2022 00:37:10 -0400 Subject: [PATCH 227/273] Auto JGit Commit 3/23/22 - 12:37 AM From df8f8538d8d8b14ec94cd6bac4057ec4fff3eb0f Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 29 Mar 2022 09:03:37 -0400 Subject: [PATCH 228/273] Auto JGit Commit 3/29/22 - 9:03 AM From 43c2b371ee6f22d4d7cb022a70123a81a360bacc Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 31 Mar 2022 12:33:45 -0400 Subject: [PATCH 229/273] Auto JGit Commit 3/31/22 - 12:33 PM From a701fe33e056d68580a27905174fb99e97bac857 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Sat, 2 Apr 2022 20:26:00 -0400 Subject: [PATCH 230/273] Auto JGit Commit 4/2/22 - 8:25 PM From 348050ee359d3179874ea3d9285167e72ea90aef Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 15 Apr 2022 02:34:29 -0400 Subject: [PATCH 231/273] Auto JGit Commit 4/15/22 - 2:34 AM From eec51c00d218fad84b0c96cb5a091ae415aa357d Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Sun, 17 Apr 2022 03:00:00 -0400 Subject: [PATCH 232/273] Auto JGit Commit 4/17/22 - 2:59 AM From 3562e202d4a3f1f17d1af29f4cf63c8d3aa657a2 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Sun, 8 May 2022 14:29:54 -0400 Subject: [PATCH 233/273] Auto JGit Commit 5/8/22 - 2:29 PM From ccaa6fed03edb3839116e240f9dd21494a1015d3 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 9 May 2022 17:28:37 -0400 Subject: [PATCH 234/273] Auto JGit Commit 5/9/22 - 5:28 PM From 949a0c43491f2bbd3c5df409ab2a7381031c5370 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 25 May 2022 20:12:35 -0400 Subject: [PATCH 235/273] Auto JGit Commit 5/25/22 - 8:12 PM From 8b0da5e6ff853ba56092a5fcf2f96429f81b55f2 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 26 May 2022 13:09:17 -0400 Subject: [PATCH 236/273] Auto JGit Commit 5/26/22 - 1:09 PM From ea2e70032ee32625170571bb1e7bf2213f21369d Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 6 Jun 2022 11:08:40 -0400 Subject: [PATCH 237/273] Auto JGit Commit 6/6/22 - 11:08 AM From e5b56719d12866e89648925652bea92947b60503 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 6 Jun 2022 11:19:32 -0400 Subject: [PATCH 238/273] Auto JGit Commit 6/6/22 - 11:19 AM From 1b210c52f473ee94060e354acfdbd48a5267714e Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 16 Jun 2022 18:29:14 -0400 Subject: [PATCH 239/273] Auto JGit Commit 6/16/22 - 6:29 PM From 3f6b6fb44f9dea3e7903e995c858f4f5e6a65bad Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 21 Jun 2022 18:12:11 -0400 Subject: [PATCH 240/273] Auto JGit Commit 6/21/22 - 6:12 PM From 44f917d0b47b7a5aa112af1b514a91102ddd9c9f Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 22 Jun 2022 17:11:35 -0400 Subject: [PATCH 241/273] Auto JGit Commit 6/22/22 - 5:11 PM From cd66a97e0b340b71031d6fce36d608fd880ddea8 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 23 Jun 2022 17:50:30 -0400 Subject: [PATCH 242/273] Auto JGit Commit 6/23/22 - 5:50 PM From 539a31a54055b2d90c075ef51869c89408c79d53 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 29 Jun 2022 14:12:50 -0400 Subject: [PATCH 243/273] Auto JGit Commit 6/29/22 - 2:12 PM From 7e54956cfe7a7c074961e03c1148df0dd14e3054 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 30 Jun 2022 18:36:51 -0400 Subject: [PATCH 244/273] Auto JGit Commit 6/30/22 - 6:36 PM From 7ad8f748037b3a6b3de77219226ebfc523df538f Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 1 Jul 2022 15:08:31 -0400 Subject: [PATCH 245/273] Auto JGit Commit 7/1/22 - 3:08 PM From 1620840a7673faac79e70ef5388a3735bcf3f5b1 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 6 Jul 2022 04:43:39 -0400 Subject: [PATCH 246/273] Auto JGit Commit 7/6/22 - 4:43 AM From dd0f12d2a483336d82f75de46ddb8554597c52d2 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 8 Jul 2022 05:28:13 -0400 Subject: [PATCH 247/273] Auto JGit Commit 7/8/22 - 5:28 AM From 86071b11630dde51e5257268d5363f410c139299 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 14 Jul 2022 13:44:33 -0400 Subject: [PATCH 248/273] Auto JGit Commit 7/14/22 - 1:44 PM From 5a7331eb5650156259291b2c536876b18cd74fd1 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 28 Jul 2022 20:29:21 -0400 Subject: [PATCH 249/273] Auto JGit Commit 7/28/22 - 8:29 PM From e10492bfaff133e35674d08ba38ecaae7b371167 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 29 Jul 2022 19:10:11 -0400 Subject: [PATCH 250/273] Auto JGit Commit 7/29/22 - 7:10 PM From 7975e92b29da9920d983127c5d73748bd770cfff Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 15 Aug 2022 17:11:29 -0400 Subject: [PATCH 251/273] Auto JGit Commit 8/15/22 - 5:11 PM From 8dc8a5c7f0f8be135e796f35cec51602ab85919e Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 18 Aug 2022 02:59:44 -0400 Subject: [PATCH 252/273] Auto JGit Commit 8/18/22 - 2:59 AM From ec29dff4f908a462e62d3d07a81a99f8c045b0b5 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 25 Aug 2022 22:07:14 -0400 Subject: [PATCH 253/273] Auto JGit Commit 8/25/22 - 10:07 PM From b0e91eb9e69b8d05dfd0f29182396d4c6c295720 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 5 Sep 2022 05:13:10 -0400 Subject: [PATCH 254/273] Auto JGit Commit 9/5/22 - 5:13 AM From c752a9bf2cfaf36312e2451793bbaa14981bab8f Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Wed, 7 Sep 2022 19:10:27 -0400 Subject: [PATCH 255/273] Auto JGit Commit 9/7/22 - 7:10 PM From c2d848e2579d4da6ad4a49631d2d0ce370cfdf51 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 9 Sep 2022 17:29:32 -0400 Subject: [PATCH 256/273] Auto JGit Commit 9/9/22 - 5:29 PM From f19ef130a2adf5b8cca8c85f899911dde8c6a781 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 13 Sep 2022 12:51:21 -0400 Subject: [PATCH 257/273] Auto JGit Commit 9/13/22 - 12:51 PM From 5b330b124948609e06d0def6db31c89e88779fe3 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 19 Sep 2022 12:36:15 -0400 Subject: [PATCH 258/273] Auto JGit Commit 9/19/22 - 12:36 PM From a32fbe8e61f95d50837a8df336b585d322f40f61 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 19 Sep 2022 13:24:52 -0400 Subject: [PATCH 259/273] Auto JGit Commit 9/19/22 - 1:24 PM From 8b9a422d2b251f95b0db5977064fb8837ee1b07d Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 27 Sep 2022 02:28:52 -0400 Subject: [PATCH 260/273] Auto JGit Commit 9/27/22 - 2:28 AM From f71e66f5161cb8b88ca424e4b983818214f6e9e4 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 27 Sep 2022 15:13:53 -0400 Subject: [PATCH 261/273] Auto JGit Commit 9/27/22 - 3:13 PM From c08373a4bd23e346b3a5514b9003a14a0b3f61d2 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 30 Sep 2022 05:03:45 -0400 Subject: [PATCH 262/273] Auto JGit Commit 9/30/22 - 5:03 AM From 61e51d7a3b3acab9432750f782f8b9a96f4632e6 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 30 Sep 2022 19:45:18 -0400 Subject: [PATCH 263/273] Auto JGit Commit 9/30/22 - 7:45 PM From c74197345a94d6c4f948e16c64cd831efe28ab90 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 3 Oct 2022 11:25:17 -0400 Subject: [PATCH 264/273] Auto JGit Commit 10/3/22 - 11:25 AM From ec024ee7c855ea9fcaca9da585729f873cb9d1e5 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 4 Oct 2022 17:59:35 -0400 Subject: [PATCH 265/273] Auto JGit Commit 10/4/22 - 5:59 PM From d81ee053c8a5c08e0ed2af269976180ae5a902cf Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 6 Oct 2022 19:37:25 -0400 Subject: [PATCH 266/273] Auto JGit Commit 10/6/22 - 7:37 PM From 1f4633a3ffb72b45bbd4856c573927556e7ea0e4 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Thu, 6 Oct 2022 19:40:00 -0400 Subject: [PATCH 267/273] Auto JGit Commit 10/6/22 - 7:39 PM From 1be97a8918263ec0ff486b3eefe8fff0c275d5d4 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Fri, 7 Oct 2022 10:35:27 -0400 Subject: [PATCH 268/273] Auto JGit Commit 10/7/22 - 10:35 AM From dff9fcd66b1c0de00a6a7738001ea65eaf85f063 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 11 Oct 2022 11:49:40 -0400 Subject: [PATCH 269/273] Auto JGit Commit 10/11/22 - 11:49 AM From a1cd87dda62a1caf2c5bd12d1e10e532d950e3f7 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 8 Nov 2022 02:16:37 -0500 Subject: [PATCH 270/273] Auto JGit Commit 11/8/22 - 2:16 AM From 7023451a9d7ac83214896d2af147648f986f3998 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 29 Nov 2022 01:41:08 -0500 Subject: [PATCH 271/273] Auto JGit Commit 11/29/22 - 1:40 AM --- .gitignore | 5 ++++- rsocket-ipc-core/bin/.gitignore | 5 ++++- rsocket-ipc-graphql/bin/.gitignore | 5 ++++- rsocket-ipc-gson/bin/.gitignore | 5 ++++- rsocket-ipc-jackson/bin/.gitignore | 5 ++++- rsocket-ipc-protobuf/bin/.gitignore | 5 ++++- rsocket-ipc-reflection-client/bin/.gitignore | 5 ++++- rsocket-ipc-reflection-core/bin/.gitignore | 5 ++++- rsocket-ipc-reflection-server/bin/.gitignore | 5 ++++- rsocket-ipc-reflection-test/bin/.gitignore | 5 ++++- rsocket-rpc-core/bin/.gitignore | 5 ++++- 11 files changed, 44 insertions(+), 11 deletions(-) diff --git a/.gitignore b/.gitignore index f6343015..2c7d0b0b 100644 --- a/.gitignore +++ b/.gitignore @@ -253,4 +253,7 @@ generated/ .settings # End of https://www.gitignore.io/api/node,java,macos,linux,cmake,gradle,intellij+all -.flattened-pom.xml \ No newline at end of file +.flattened-pom.xml + + +.factorypath diff --git a/rsocket-ipc-core/bin/.gitignore b/rsocket-ipc-core/bin/.gitignore index 3c7975f9..4d76ae8a 100644 --- a/rsocket-ipc-core/bin/.gitignore +++ b/rsocket-ipc-core/bin/.gitignore @@ -1,3 +1,6 @@ /main/ /test/ -.flattened-pom.xml \ No newline at end of file +.flattened-pom.xml + + +.factorypath diff --git a/rsocket-ipc-graphql/bin/.gitignore b/rsocket-ipc-graphql/bin/.gitignore index 3c7975f9..4d76ae8a 100644 --- a/rsocket-ipc-graphql/bin/.gitignore +++ b/rsocket-ipc-graphql/bin/.gitignore @@ -1,3 +1,6 @@ /main/ /test/ -.flattened-pom.xml \ No newline at end of file +.flattened-pom.xml + + +.factorypath diff --git a/rsocket-ipc-gson/bin/.gitignore b/rsocket-ipc-gson/bin/.gitignore index 510c24de..5f6586cc 100644 --- a/rsocket-ipc-gson/bin/.gitignore +++ b/rsocket-ipc-gson/bin/.gitignore @@ -1,2 +1,5 @@ /main/ -.flattened-pom.xml \ No newline at end of file +.flattened-pom.xml + + +.factorypath diff --git a/rsocket-ipc-jackson/bin/.gitignore b/rsocket-ipc-jackson/bin/.gitignore index 510c24de..5f6586cc 100644 --- a/rsocket-ipc-jackson/bin/.gitignore +++ b/rsocket-ipc-jackson/bin/.gitignore @@ -1,2 +1,5 @@ /main/ -.flattened-pom.xml \ No newline at end of file +.flattened-pom.xml + + +.factorypath diff --git a/rsocket-ipc-protobuf/bin/.gitignore b/rsocket-ipc-protobuf/bin/.gitignore index 510c24de..5f6586cc 100644 --- a/rsocket-ipc-protobuf/bin/.gitignore +++ b/rsocket-ipc-protobuf/bin/.gitignore @@ -1,2 +1,5 @@ /main/ -.flattened-pom.xml \ No newline at end of file +.flattened-pom.xml + + +.factorypath diff --git a/rsocket-ipc-reflection-client/bin/.gitignore b/rsocket-ipc-reflection-client/bin/.gitignore index ae4dd600..36f4c3cc 100644 --- a/rsocket-ipc-reflection-client/bin/.gitignore +++ b/rsocket-ipc-reflection-client/bin/.gitignore @@ -1,3 +1,6 @@ /main/ /default/ -.flattened-pom.xml \ No newline at end of file +.flattened-pom.xml + + +.factorypath diff --git a/rsocket-ipc-reflection-core/bin/.gitignore b/rsocket-ipc-reflection-core/bin/.gitignore index ae4dd600..36f4c3cc 100644 --- a/rsocket-ipc-reflection-core/bin/.gitignore +++ b/rsocket-ipc-reflection-core/bin/.gitignore @@ -1,3 +1,6 @@ /main/ /default/ -.flattened-pom.xml \ No newline at end of file +.flattened-pom.xml + + +.factorypath diff --git a/rsocket-ipc-reflection-server/bin/.gitignore b/rsocket-ipc-reflection-server/bin/.gitignore index f3c1854e..252a2016 100644 --- a/rsocket-ipc-reflection-server/bin/.gitignore +++ b/rsocket-ipc-reflection-server/bin/.gitignore @@ -1,4 +1,7 @@ /main/ /default/ /test/ -.flattened-pom.xml \ No newline at end of file +.flattened-pom.xml + + +.factorypath diff --git a/rsocket-ipc-reflection-test/bin/.gitignore b/rsocket-ipc-reflection-test/bin/.gitignore index f3c1854e..252a2016 100644 --- a/rsocket-ipc-reflection-test/bin/.gitignore +++ b/rsocket-ipc-reflection-test/bin/.gitignore @@ -1,4 +1,7 @@ /main/ /default/ /test/ -.flattened-pom.xml \ No newline at end of file +.flattened-pom.xml + + +.factorypath diff --git a/rsocket-rpc-core/bin/.gitignore b/rsocket-rpc-core/bin/.gitignore index 3c7975f9..4d76ae8a 100644 --- a/rsocket-rpc-core/bin/.gitignore +++ b/rsocket-rpc-core/bin/.gitignore @@ -1,3 +1,6 @@ /main/ /test/ -.flattened-pom.xml \ No newline at end of file +.flattened-pom.xml + + +.factorypath From f51027a765d227bfc4eb5e2230ad6d7373bde558 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Tue, 29 Nov 2022 03:12:07 -0500 Subject: [PATCH 272/273] Auto JGit Commit 11/29/22 - 3:11 AM From 38d3f7f72c9c9b6c837899db3a7773ef1a8c4da4 Mon Sep 17 00:00:00 2001 From: reggie pierce Date: Mon, 19 Dec 2022 17:10:54 -0500 Subject: [PATCH 273/273] Auto JGit Commit 12/19/22 - 5:10 PM