From 49adfe5e7c97bb6dcdc773ef76fe3cab56096544 Mon Sep 17 00:00:00 2001 From: Lachlan Roberts Date: Fri, 3 Jun 2022 12:32:36 +1000 Subject: [PATCH] Issue #6328 - renaming and javadoc from review Signed-off-by: Lachlan Roberts --- .../messages/AbstractMessageSink.java | 8 +- .../messages/ByteArrayMessageSink.java | 12 +-- .../messages/ByteBufferMessageSink.java | 14 ++-- .../messages/DispatchedMessageSink.java | 8 +- .../messages/InputStreamMessageSink.java | 8 +- .../messages/PartialByteArrayMessageSink.java | 8 +- .../PartialByteBufferMessageSink.java | 8 +- .../messages/PartialStringMessageSink.java | 18 ++--- .../internal/messages/ReaderMessageSink.java | 8 +- .../internal/messages/StringMessageSink.java | 10 +-- .../util/AbstractJettyMethodHandle.java | 55 -------------- ...odHandle.java => BindingMethodHolder.java} | 12 +-- .../core/internal/util/InvokerUtils.java | 10 +-- .../core/internal/util/JettyMethodHandle.java | 46 ------------ .../core/internal/util/MethodHolder.java | 73 +++++++++++++++++++ ...andle.java => NonBindingMethodHolder.java} | 18 +++-- .../util/PartialStringMessageSinkTest.java | 3 +- ...a => JavaxMessagePartialMethodHolder.java} | 14 ++-- ...ava => JavaxMessageWholeMethodHolder.java} | 14 ++-- .../common/JavaxWebSocketFrameHandler.java | 38 +++++----- .../JavaxWebSocketFrameHandlerFactory.java | 36 ++++----- .../common/JavaxWebSocketMessageMetadata.java | 14 ++-- .../messages/AbstractDecodedMessageSink.java | 20 ++--- .../messages/DecodedBinaryMessageSink.java | 23 +++--- .../DecodedBinaryStreamMessageSink.java | 23 +++--- .../messages/DecodedTextMessageSink.java | 23 +++--- .../DecodedTextStreamMessageSink.java | 23 +++--- .../DecodedBinaryMessageSinkTest.java | 6 +- .../DecodedBinaryStreamMessageSinkTest.java | 6 +- .../messages/DecodedTextMessageSinkTest.java | 6 +- .../DecodedTextStreamMessageSinkTest.java | 6 +- .../util/InvokerUtilsStaticParamsTest.java | 30 ++++---- .../tests/coders/DecoderTextStreamTest.java | 4 +- .../common/JettyWebSocketFrameHandler.java | 26 +++---- .../JettyWebSocketFrameHandlerFactory.java | 22 +++--- 35 files changed, 301 insertions(+), 352 deletions(-) delete mode 100644 jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/AbstractJettyMethodHandle.java rename jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/{BindingJettyMethodHandle.java => BindingMethodHolder.java} (81%) delete mode 100644 jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/JettyMethodHandle.java create mode 100644 jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/MethodHolder.java rename jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/{NonBindingJettyMethodHandle.java => NonBindingMethodHolder.java} (86%) rename jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/{JavaxMessagePartialMethodHandle.java => JavaxMessagePartialMethodHolder.java} (81%) rename jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/{JavaxMessageWholeMethodHandle.java => JavaxMessageWholeMethodHolder.java} (80%) diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/AbstractMessageSink.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/AbstractMessageSink.java index d48bd80c9278..4b75de38ae8d 100644 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/AbstractMessageSink.java +++ b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/AbstractMessageSink.java @@ -16,16 +16,16 @@ import java.util.Objects; import org.eclipse.jetty.websocket.core.CoreSession; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; public abstract class AbstractMessageSink implements MessageSink { protected final CoreSession session; - protected final JettyMethodHandle methodHandle; + protected final MethodHolder methodHolder; - public AbstractMessageSink(CoreSession session, JettyMethodHandle methodHandle) + public AbstractMessageSink(CoreSession session, MethodHolder methodHolder) { this.session = Objects.requireNonNull(session, "CoreSession"); - this.methodHandle = Objects.requireNonNull(methodHandle, "MethodHandle"); + this.methodHolder = Objects.requireNonNull(methodHolder, "MethodHandle"); } } diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/ByteArrayMessageSink.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/ByteArrayMessageSink.java index a12dd92c501b..c49ef1f187f9 100644 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/ByteArrayMessageSink.java +++ b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/ByteArrayMessageSink.java @@ -21,16 +21,16 @@ import org.eclipse.jetty.websocket.core.CoreSession; import org.eclipse.jetty.websocket.core.Frame; import org.eclipse.jetty.websocket.core.exception.MessageTooLargeException; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; public class ByteArrayMessageSink extends AbstractMessageSink { private static final byte[] EMPTY_BUFFER = new byte[0]; private ByteBufferCallbackAccumulator out; - public ByteArrayMessageSink(CoreSession session, JettyMethodHandle methodHandle) + public ByteArrayMessageSink(CoreSession session, MethodHolder methodHolder) { - super(session, methodHandle); + super(session, methodHolder); } @Override @@ -52,10 +52,10 @@ public void accept(Frame frame, Callback callback) if (frame.hasPayload()) { byte[] buf = BufferUtil.toArray(frame.getPayload()); - methodHandle.invoke(buf, 0, buf.length); + methodHolder.invoke(buf, 0, buf.length); } else - methodHandle.invoke(EMPTY_BUFFER, 0, 0); + methodHolder.invoke(EMPTY_BUFFER, 0, 0); callback.succeeded(); session.demand(1); @@ -76,7 +76,7 @@ public void accept(Frame frame, Callback callback) if (frame.isFin()) { byte[] buf = out.takeByteArray(); - methodHandle.invoke(buf, 0, buf.length); + methodHolder.invoke(buf, 0, buf.length); } session.demand(1); diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/ByteBufferMessageSink.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/ByteBufferMessageSink.java index a17e90516660..a297509a7111 100644 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/ByteBufferMessageSink.java +++ b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/ByteBufferMessageSink.java @@ -23,21 +23,21 @@ import org.eclipse.jetty.websocket.core.CoreSession; import org.eclipse.jetty.websocket.core.Frame; import org.eclipse.jetty.websocket.core.exception.MessageTooLargeException; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; public class ByteBufferMessageSink extends AbstractMessageSink { private ByteBufferCallbackAccumulator out; - public ByteBufferMessageSink(CoreSession session, JettyMethodHandle methodHandle) + public ByteBufferMessageSink(CoreSession session, MethodHolder methodHolder) { - super(session, methodHandle); + super(session, methodHolder); } @Deprecated public ByteBufferMessageSink(CoreSession session, MethodHandle methodHandle) { - this(session, JettyMethodHandle.from(methodHandle)); + this(session, MethodHolder.from(methodHandle)); } @Override @@ -57,9 +57,9 @@ public void accept(Frame frame, Callback callback) if (frame.isFin() && (out == null)) { if (frame.hasPayload()) - methodHandle.invoke(frame.getPayload()); + methodHolder.invoke(frame.getPayload()); else - methodHandle.invoke(BufferUtil.EMPTY_BUFFER); + methodHolder.invoke(BufferUtil.EMPTY_BUFFER); callback.succeeded(); session.demand(1); @@ -85,7 +85,7 @@ public void accept(Frame frame, Callback callback) try { - methodHandle.invoke(buffer); + methodHolder.invoke(buffer); } finally { diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/DispatchedMessageSink.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/DispatchedMessageSink.java index 908099bcb5c6..5927776020c4 100644 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/DispatchedMessageSink.java +++ b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/DispatchedMessageSink.java @@ -21,7 +21,7 @@ import org.eclipse.jetty.util.IO; import org.eclipse.jetty.websocket.core.CoreSession; import org.eclipse.jetty.websocket.core.Frame; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; /** * Centralized logic for Dispatched Message Handling. @@ -98,9 +98,9 @@ public abstract class DispatchedMessageSink extends AbstractMessageSink private MessageSink typeSink; private final Executor executor; - public DispatchedMessageSink(CoreSession session, JettyMethodHandle methodHandle) + public DispatchedMessageSink(CoreSession session, MethodHolder methodHolder) { - super(session, methodHandle); + super(session, methodHolder); executor = session.getWebSocketComponents().getExecutor(); } @@ -119,7 +119,7 @@ public void accept(Frame frame, final Callback callback) { try { - methodHandle.invoke(typeSink); + methodHolder.invoke(typeSink); if (typeSink instanceof Closeable) IO.close((Closeable)typeSink); diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/InputStreamMessageSink.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/InputStreamMessageSink.java index 8bd4ac6962b5..72acf4613b21 100644 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/InputStreamMessageSink.java +++ b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/InputStreamMessageSink.java @@ -17,19 +17,19 @@ import org.eclipse.jetty.websocket.core.CoreSession; import org.eclipse.jetty.websocket.core.Frame; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; public class InputStreamMessageSink extends DispatchedMessageSink { - public InputStreamMessageSink(CoreSession session, JettyMethodHandle methodHandle) + public InputStreamMessageSink(CoreSession session, MethodHolder methodHolder) { - super(session, methodHandle); + super(session, methodHolder); } @Deprecated public InputStreamMessageSink(CoreSession session, MethodHandle methodHandle) { - this(session, JettyMethodHandle.from(methodHandle)); + this(session, MethodHolder.from(methodHandle)); } @Override diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/PartialByteArrayMessageSink.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/PartialByteArrayMessageSink.java index 03177379d997..a214bdd8ea14 100644 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/PartialByteArrayMessageSink.java +++ b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/PartialByteArrayMessageSink.java @@ -17,15 +17,15 @@ import org.eclipse.jetty.util.Callback; import org.eclipse.jetty.websocket.core.CoreSession; import org.eclipse.jetty.websocket.core.Frame; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; public class PartialByteArrayMessageSink extends AbstractMessageSink { private static final byte[] EMPTY_BUFFER = new byte[0]; - public PartialByteArrayMessageSink(CoreSession session, JettyMethodHandle methodHandle) + public PartialByteArrayMessageSink(CoreSession session, MethodHolder methodHolder) { - super(session, methodHandle); + super(session, methodHolder); } @Override @@ -36,7 +36,7 @@ public void accept(Frame frame, Callback callback) if (frame.hasPayload() || frame.isFin()) { byte[] buffer = frame.hasPayload() ? BufferUtil.toArray(frame.getPayload()) : EMPTY_BUFFER; - methodHandle.invoke(buffer, frame.isFin()); + methodHolder.invoke(buffer, frame.isFin()); } callback.succeeded(); diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/PartialByteBufferMessageSink.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/PartialByteBufferMessageSink.java index 8dc96df74bf3..01985ab3612d 100644 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/PartialByteBufferMessageSink.java +++ b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/PartialByteBufferMessageSink.java @@ -16,13 +16,13 @@ import org.eclipse.jetty.util.Callback; import org.eclipse.jetty.websocket.core.CoreSession; import org.eclipse.jetty.websocket.core.Frame; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; public class PartialByteBufferMessageSink extends AbstractMessageSink { - public PartialByteBufferMessageSink(CoreSession session, JettyMethodHandle methodHandle) + public PartialByteBufferMessageSink(CoreSession session, MethodHolder methodHolder) { - super(session, methodHandle); + super(session, methodHolder); } @Override @@ -31,7 +31,7 @@ public void accept(Frame frame, Callback callback) try { if (frame.hasPayload() || frame.isFin()) - methodHandle.invoke(frame.getPayload(), frame.isFin()); + methodHolder.invoke(frame.getPayload(), frame.isFin()); callback.succeeded(); session.demand(1); diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/PartialStringMessageSink.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/PartialStringMessageSink.java index a05613af2ad9..bfc8d973aa03 100644 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/PartialStringMessageSink.java +++ b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/PartialStringMessageSink.java @@ -13,27 +13,19 @@ package org.eclipse.jetty.websocket.core.internal.messages; -import java.lang.invoke.MethodHandle; - import org.eclipse.jetty.util.Callback; import org.eclipse.jetty.util.Utf8StringBuilder; import org.eclipse.jetty.websocket.core.CoreSession; import org.eclipse.jetty.websocket.core.Frame; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; public class PartialStringMessageSink extends AbstractMessageSink { private Utf8StringBuilder out; - public PartialStringMessageSink(CoreSession session, JettyMethodHandle methodHandle) - { - super(session, methodHandle); - } - - @Deprecated - public PartialStringMessageSink(CoreSession session, MethodHandle methodHandle) + public PartialStringMessageSink(CoreSession session, MethodHolder methodHolder) { - this(session, JettyMethodHandle.from(methodHandle)); + super(session, methodHolder); } @Override @@ -47,12 +39,12 @@ public void accept(Frame frame, Callback callback) out.append(frame.getPayload()); if (frame.isFin()) { - methodHandle.invoke(out.toString(), true); + methodHolder.invoke(out.toString(), true); out = null; } else { - methodHandle.invoke(out.takePartialString(), false); + methodHolder.invoke(out.takePartialString(), false); } callback.succeeded(); diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/ReaderMessageSink.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/ReaderMessageSink.java index 2627eb899945..f98855495843 100644 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/ReaderMessageSink.java +++ b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/ReaderMessageSink.java @@ -17,19 +17,19 @@ import org.eclipse.jetty.websocket.core.CoreSession; import org.eclipse.jetty.websocket.core.Frame; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; public class ReaderMessageSink extends DispatchedMessageSink { - public ReaderMessageSink(CoreSession session, JettyMethodHandle methodHandle) + public ReaderMessageSink(CoreSession session, MethodHolder methodHolder) { - super(session, methodHandle); + super(session, methodHolder); } @Deprecated public ReaderMessageSink(CoreSession session, MethodHandle methodHandle) { - this(session, JettyMethodHandle.from(methodHandle)); + this(session, MethodHolder.from(methodHandle)); } @Override diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/StringMessageSink.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/StringMessageSink.java index d0fbba9ece8e..a66249ab21cf 100644 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/StringMessageSink.java +++ b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/messages/StringMessageSink.java @@ -20,23 +20,23 @@ import org.eclipse.jetty.websocket.core.CoreSession; import org.eclipse.jetty.websocket.core.Frame; import org.eclipse.jetty.websocket.core.exception.MessageTooLargeException; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; public class StringMessageSink extends AbstractMessageSink { private Utf8StringBuilder out; private int size; - public StringMessageSink(CoreSession session, JettyMethodHandle methodHandle) + public StringMessageSink(CoreSession session, MethodHolder methodHolder) { - super(session, methodHandle); + super(session, methodHolder); this.size = 0; } @Deprecated public StringMessageSink(CoreSession session, MethodHandle methodHandle) { - this(session, JettyMethodHandle.from(methodHandle)); + this(session, MethodHolder.from(methodHandle)); } @Override @@ -57,7 +57,7 @@ public void accept(Frame frame, Callback callback) out.append(frame.getPayload()); if (frame.isFin()) - methodHandle.invoke(out.toString()); + methodHolder.invoke(out.toString()); callback.succeeded(); session.demand(1); diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/AbstractJettyMethodHandle.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/AbstractJettyMethodHandle.java deleted file mode 100644 index 69c70f1fa56f..000000000000 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/AbstractJettyMethodHandle.java +++ /dev/null @@ -1,55 +0,0 @@ -// -// ======================================================================== -// Copyright (c) 1995-2022 Mort Bay Consulting Pty Ltd and others. -// -// This program and the accompanying materials are made available under the -// terms of the Eclipse Public License v. 2.0 which is available at -// https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0 -// which is available at https://www.apache.org/licenses/LICENSE-2.0. -// -// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 -// ======================================================================== -// - -package org.eclipse.jetty.websocket.core.internal.util; - -import java.lang.invoke.MethodHandle; - -public abstract class AbstractJettyMethodHandle implements JettyMethodHandle -{ - @Override - public JettyMethodHandle bindTo(Object arg) - { - throw new UnsupportedOperationException(); - } - - @Override - public JettyMethodHandle bindTo(Object arg, int idx) - { - throw new UnsupportedOperationException(); - } - - @Override - public JettyMethodHandle filterReturnValue(MethodHandle filter) - { - throw new UnsupportedOperationException(); - } - - @Override - public JettyMethodHandle changeReturnType(Class objectClass) - { - throw new UnsupportedOperationException(); - } - - @Override - public Class parameterType(int idx) - { - throw new UnsupportedOperationException(); - } - - @Override - public Class returnType() - { - throw new UnsupportedOperationException(); - } -} diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/BindingJettyMethodHandle.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/BindingMethodHolder.java similarity index 81% rename from jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/BindingJettyMethodHandle.java rename to jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/BindingMethodHolder.java index 17f1a9529043..f032965eca76 100644 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/BindingJettyMethodHandle.java +++ b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/BindingMethodHolder.java @@ -16,11 +16,11 @@ import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; -class BindingJettyMethodHandle implements JettyMethodHandle +class BindingMethodHolder implements MethodHolder { public MethodHandle _methodHandle; - BindingJettyMethodHandle(MethodHandle methodHandle) + public BindingMethodHolder(MethodHandle methodHandle) { _methodHandle = methodHandle; } @@ -32,28 +32,28 @@ public Object invoke(Object... args) throws Throwable } @Override - public BindingJettyMethodHandle bindTo(Object arg) + public BindingMethodHolder bindTo(Object arg) { _methodHandle = _methodHandle.bindTo(arg); return this; } @Override - public JettyMethodHandle bindTo(Object arg, int idx) + public MethodHolder bindTo(Object arg, int idx) { _methodHandle = MethodHandles.insertArguments(_methodHandle, idx, arg); return this; } @Override - public BindingJettyMethodHandle filterReturnValue(MethodHandle filter) + public BindingMethodHolder filterReturnValue(MethodHandle filter) { _methodHandle = MethodHandles.filterReturnValue(_methodHandle, filter); return this; } @Override - public BindingJettyMethodHandle changeReturnType(Class objectClass) + public BindingMethodHolder changeReturnType(Class objectClass) { _methodHandle = _methodHandle.asType(_methodHandle.type().changeReturnType(objectClass)); return this; diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/InvokerUtils.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/InvokerUtils.java index 868688b58a48..a0937263e3df 100644 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/InvokerUtils.java +++ b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/InvokerUtils.java @@ -139,15 +139,15 @@ public Arg getParamArg(Method method, Class paramType, int idx) /** * Bind optional arguments to provided method handle * - * @param methodHandle the method handle to bind to + * @param methodHolder the method handle to bind to * @param objs the list of optional objects to bind to. - * @return the bound MethodHandle, or null if the provided {@code methodHandle} was null. + * @return the bound MethodHandle, or null if the provided {@code methodHolder} was null. */ - public static JettyMethodHandle bindTo(JettyMethodHandle methodHandle, Object... objs) + public static MethodHolder bindTo(MethodHolder methodHolder, Object... objs) { - if (methodHandle == null) + if (methodHolder == null) return null; - JettyMethodHandle ret = methodHandle; + MethodHolder ret = methodHolder; for (Object obj : objs) { if (ret.parameterType(0).isAssignableFrom(obj.getClass())) diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/JettyMethodHandle.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/JettyMethodHandle.java deleted file mode 100644 index 7c76b41fb78b..000000000000 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/JettyMethodHandle.java +++ /dev/null @@ -1,46 +0,0 @@ -// -// ======================================================================== -// Copyright (c) 1995-2022 Mort Bay Consulting Pty Ltd and others. -// -// This program and the accompanying materials are made available under the -// terms of the Eclipse Public License v. 2.0 which is available at -// https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0 -// which is available at https://www.apache.org/licenses/LICENSE-2.0. -// -// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 -// ======================================================================== -// - -package org.eclipse.jetty.websocket.core.internal.util; - -import java.lang.invoke.MethodHandle; - -/** - * Jetty interface for managing {@link MethodHandle}s. - * - * This differs from {@link MethodHandle}s that any calls the methods such as {@link #bindTo(Object)} - * will change the instance of {@link JettyMethodHandle} it is called on. - */ -public interface JettyMethodHandle -{ - static JettyMethodHandle from(MethodHandle methodHandle) - { - if (methodHandle == null) - return null; - return new NonBindingJettyMethodHandle(methodHandle); - } - - Object invoke(Object... args) throws Throwable; - - JettyMethodHandle bindTo(Object arg); - - JettyMethodHandle bindTo(Object arg, int idx); - - JettyMethodHandle filterReturnValue(MethodHandle filter); - - JettyMethodHandle changeReturnType(Class objectClass); - - Class parameterType(int idx); - - Class returnType(); -} diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/MethodHolder.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/MethodHolder.java new file mode 100644 index 000000000000..b9e0f68aaae4 --- /dev/null +++ b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/MethodHolder.java @@ -0,0 +1,73 @@ +// +// ======================================================================== +// Copyright (c) 1995-2022 Mort Bay Consulting Pty Ltd and others. +// +// This program and the accompanying materials are made available under the +// terms of the Eclipse Public License v. 2.0 which is available at +// https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0 +// which is available at https://www.apache.org/licenses/LICENSE-2.0. +// +// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 +// ======================================================================== +// + +package org.eclipse.jetty.websocket.core.internal.util; + +import java.lang.invoke.MethodHandle; + +/** + * An interface for managing invocations of methods whose arguments may need to be augmented, by + * binding in certain parameters ahead of time. + * + * This differs from {@link MethodHandle}s that any calls the methods such as {@link #bindTo(Object)} + * will change the instance of {@link MethodHolder} it is called on. + * + * Implementations of this may not be thread safe, so the caller must use some external mutual exclusion + * unless they are using a specific implementation known to be thread-safe. + */ +public interface MethodHolder +{ + static MethodHolder from(MethodHandle methodHandle) + { + return from(methodHandle, false); + } + + static MethodHolder from(MethodHandle methodHandle, boolean binding) + { + if (methodHandle == null) + return null; + return binding ? new BindingMethodHolder(methodHandle) : new NonBindingMethodHolder(methodHandle); + } + + Object invoke(Object... args) throws Throwable; + + default MethodHolder bindTo(Object arg) + { + throw new UnsupportedOperationException(); + } + + default MethodHolder bindTo(Object arg, int idx) + { + throw new UnsupportedOperationException(); + } + + default MethodHolder filterReturnValue(MethodHandle filter) + { + throw new UnsupportedOperationException(); + } + + default MethodHolder changeReturnType(Class objectClass) + { + throw new UnsupportedOperationException(); + } + + default Class parameterType(int idx) + { + throw new UnsupportedOperationException(); + } + + default Class returnType() + { + throw new UnsupportedOperationException(); + } +} diff --git a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/NonBindingJettyMethodHandle.java b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/NonBindingMethodHolder.java similarity index 86% rename from jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/NonBindingJettyMethodHandle.java rename to jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/NonBindingMethodHolder.java index 5fb45d04d3a4..5bd8a8982958 100644 --- a/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/NonBindingJettyMethodHandle.java +++ b/jetty-websocket/websocket-core-common/src/main/java/org/eclipse/jetty/websocket/core/internal/util/NonBindingMethodHolder.java @@ -17,7 +17,11 @@ import java.lang.invoke.WrongMethodTypeException; import java.util.Objects; -class NonBindingJettyMethodHandle implements JettyMethodHandle +/** + * This implementation of {@link MethodHolder} is not thread safe. + * Mutual exclusion should be used when calling {@link #invoke(Object...)}. + */ +class NonBindingMethodHolder implements MethodHolder { private final MethodHandle _methodHandle; private final Object[] _parameters; @@ -26,7 +30,7 @@ class NonBindingJettyMethodHandle implements JettyMethodHandle private Class _returnType; private MethodHandle _returnFilter; - public NonBindingJettyMethodHandle(MethodHandle methodHandle) + public NonBindingMethodHolder(MethodHandle methodHandle) { _methodHandle = Objects.requireNonNull(methodHandle); _numParams = methodHandle.type().parameterCount(); @@ -61,7 +65,7 @@ public Object invoke(Object... args) throws Throwable } @Override - public JettyMethodHandle bindTo(Object arg, int idx) + public MethodHolder bindTo(Object arg, int idx) { int internalIndex = getInternalIndex(idx); _parameters[internalIndex] = arg; @@ -70,13 +74,13 @@ public JettyMethodHandle bindTo(Object arg, int idx) } @Override - public JettyMethodHandle bindTo(Object arg) + public MethodHolder bindTo(Object arg) { return bindTo(arg, 0); } @SuppressWarnings({"UnusedReturnValue", "SameParameterValue"}) - private JettyMethodHandle insertArguments(boolean bind, int idx, Object... args) + private MethodHolder insertArguments(boolean bind, int idx, Object... args) { int index = 0; int argsIndex = 0; @@ -106,14 +110,14 @@ private JettyMethodHandle insertArguments(boolean bind, int idx, Object... args) } @Override - public JettyMethodHandle filterReturnValue(MethodHandle filter) + public MethodHolder filterReturnValue(MethodHandle filter) { _returnFilter = filter; return this; } @Override - public JettyMethodHandle changeReturnType(Class objectClass) + public MethodHolder changeReturnType(Class objectClass) { _returnType = objectClass; return this; diff --git a/jetty-websocket/websocket-core-tests/src/test/java/org/eclipse/jetty/websocket/core/util/PartialStringMessageSinkTest.java b/jetty-websocket/websocket-core-tests/src/test/java/org/eclipse/jetty/websocket/core/util/PartialStringMessageSinkTest.java index 59709316e2fd..7cba2955d104 100644 --- a/jetty-websocket/websocket-core-tests/src/test/java/org/eclipse/jetty/websocket/core/util/PartialStringMessageSinkTest.java +++ b/jetty-websocket/websocket-core-tests/src/test/java/org/eclipse/jetty/websocket/core/util/PartialStringMessageSinkTest.java @@ -30,6 +30,7 @@ import org.eclipse.jetty.websocket.core.Frame; import org.eclipse.jetty.websocket.core.OpCode; import org.eclipse.jetty.websocket.core.internal.messages.PartialStringMessageSink; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -48,7 +49,7 @@ public class PartialStringMessageSinkTest @BeforeEach public void before() throws Exception { - messageSink = new PartialStringMessageSink(coreSession, endpoint.getMethodHandle()); + messageSink = new PartialStringMessageSink(coreSession, MethodHolder.from(endpoint.getMethodHandle())); } @Test diff --git a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxMessagePartialMethodHandle.java b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxMessagePartialMethodHolder.java similarity index 81% rename from jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxMessagePartialMethodHandle.java rename to jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxMessagePartialMethodHolder.java index 56fefb6233bb..b32877ebd710 100644 --- a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxMessagePartialMethodHandle.java +++ b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxMessagePartialMethodHolder.java @@ -17,13 +17,13 @@ import java.lang.invoke.WrongMethodTypeException; import javax.websocket.MessageHandler; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; -class JavaxMessagePartialMethodHandle implements JettyMethodHandle +class JavaxMessagePartialMethodHolder implements MethodHolder { private final MessageHandler.Partial _messageHandler; - public JavaxMessagePartialMethodHandle(MessageHandler.Partial messageHandler) + public JavaxMessagePartialMethodHolder(MessageHandler.Partial messageHandler) { _messageHandler = messageHandler; } @@ -39,25 +39,25 @@ public Object invoke(Object... args) throws Throwable } @Override - public JettyMethodHandle bindTo(Object arg) + public MethodHolder bindTo(Object arg) { throw new UnsupportedOperationException(); } @Override - public JettyMethodHandle bindTo(Object arg, int idx) + public MethodHolder bindTo(Object arg, int idx) { throw new UnsupportedOperationException(); } @Override - public JettyMethodHandle filterReturnValue(MethodHandle filter) + public MethodHolder filterReturnValue(MethodHandle filter) { throw new UnsupportedOperationException(); } @Override - public JettyMethodHandle changeReturnType(Class objectClass) + public MethodHolder changeReturnType(Class objectClass) { throw new UnsupportedOperationException(); } diff --git a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxMessageWholeMethodHandle.java b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxMessageWholeMethodHolder.java similarity index 80% rename from jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxMessageWholeMethodHandle.java rename to jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxMessageWholeMethodHolder.java index 0489a07e3bd4..0bccdca8eb73 100644 --- a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxMessageWholeMethodHandle.java +++ b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxMessageWholeMethodHolder.java @@ -17,13 +17,13 @@ import java.lang.invoke.WrongMethodTypeException; import javax.websocket.MessageHandler; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; -class JavaxMessageWholeMethodHandle implements JettyMethodHandle +class JavaxMessageWholeMethodHolder implements MethodHolder { private final MessageHandler.Whole _messageHandler; - public JavaxMessageWholeMethodHandle(MessageHandler.Whole messageHandler) + public JavaxMessageWholeMethodHolder(MessageHandler.Whole messageHandler) { _messageHandler = messageHandler; } @@ -39,25 +39,25 @@ public Object invoke(Object... args) throws Throwable } @Override - public JettyMethodHandle bindTo(Object arg) + public MethodHolder bindTo(Object arg) { throw new UnsupportedOperationException(); } @Override - public JettyMethodHandle bindTo(Object arg, int idx) + public MethodHolder bindTo(Object arg, int idx) { throw new UnsupportedOperationException(); } @Override - public JettyMethodHandle filterReturnValue(MethodHandle filter) + public MethodHolder filterReturnValue(MethodHandle filter) { throw new UnsupportedOperationException(); } @Override - public JettyMethodHandle changeReturnType(Class objectClass) + public MethodHolder changeReturnType(Class objectClass) { throw new UnsupportedOperationException(); } diff --git a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxWebSocketFrameHandler.java b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxWebSocketFrameHandler.java index 6d5a36e0b522..a674f2a507df 100644 --- a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxWebSocketFrameHandler.java +++ b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxWebSocketFrameHandler.java @@ -43,7 +43,7 @@ import org.eclipse.jetty.websocket.core.internal.messages.PartialByteBufferMessageSink; import org.eclipse.jetty.websocket.core.internal.messages.PartialStringMessageSink; import org.eclipse.jetty.websocket.core.internal.util.InvokerUtils; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.javax.common.decoders.AvailableDecoders; import org.eclipse.jetty.websocket.javax.common.decoders.RegisteredDecoder; import org.eclipse.jetty.websocket.javax.common.messages.DecodedBinaryMessageSink; @@ -61,10 +61,10 @@ public class JavaxWebSocketFrameHandler implements FrameHandler private final Object endpointInstance; private final AtomicBoolean closeNotified = new AtomicBoolean(); - private JettyMethodHandle openHandle; - private JettyMethodHandle closeHandle; - private JettyMethodHandle errorHandle; - private JettyMethodHandle pongHandle; + private MethodHolder openHandle; + private MethodHolder closeHandle; + private MethodHolder errorHandle; + private MethodHolder pongHandle; private JavaxWebSocketMessageMetadata textMetadata; private JavaxWebSocketMessageMetadata binaryMetadata; private final UpgradeRequest upgradeRequest; @@ -80,10 +80,10 @@ public class JavaxWebSocketFrameHandler implements FrameHandler public JavaxWebSocketFrameHandler(JavaxWebSocketContainer container, UpgradeRequest upgradeRequest, Object endpointInstance, - JettyMethodHandle openHandle, JettyMethodHandle closeHandle, JettyMethodHandle errorHandle, + MethodHolder openHandle, MethodHolder closeHandle, MethodHolder errorHandle, JavaxWebSocketMessageMetadata textMetadata, JavaxWebSocketMessageMetadata binaryMetadata, - JettyMethodHandle pongHandle, + MethodHolder pongHandle, EndpointConfig endpointConfig) { this.logger = LoggerFactory.getLogger(endpointInstance.getClass()); @@ -146,10 +146,10 @@ public void onOpen(CoreSession coreSession, Callback callback) if (actualTextMetadata.isMaxMessageSizeSet()) session.setMaxTextMessageBufferSize(actualTextMetadata.getMaxMessageSize()); - JettyMethodHandle methodHandle = actualTextMetadata.getMethodHandle(); - methodHandle = InvokerUtils.bindTo(methodHandle, endpointInstance, endpointConfig, session); - methodHandle = JavaxWebSocketFrameHandlerFactory.wrapNonVoidReturnType(methodHandle, session); - actualTextMetadata.setMethodHandle(methodHandle); + MethodHolder methodHolder = actualTextMetadata.getMethodHolder(); + methodHolder = InvokerUtils.bindTo(methodHolder, endpointInstance, endpointConfig, session); + methodHolder = JavaxWebSocketFrameHandlerFactory.wrapNonVoidReturnType(methodHolder, session); + actualTextMetadata.setMethodHolder(methodHolder); textSink = JavaxWebSocketFrameHandlerFactory.createMessageSink(session, actualTextMetadata); textMetadata = actualTextMetadata; @@ -161,10 +161,10 @@ public void onOpen(CoreSession coreSession, Callback callback) if (actualBinaryMetadata.isMaxMessageSizeSet()) session.setMaxBinaryMessageBufferSize(actualBinaryMetadata.getMaxMessageSize()); - JettyMethodHandle methodHandle = actualBinaryMetadata.getMethodHandle(); - methodHandle = InvokerUtils.bindTo(methodHandle, endpointInstance, endpointConfig, session); - methodHandle = JavaxWebSocketFrameHandlerFactory.wrapNonVoidReturnType(methodHandle, session); - actualBinaryMetadata.setMethodHandle(methodHandle); + MethodHolder methodHolder = actualBinaryMetadata.getMethodHolder(); + methodHolder = InvokerUtils.bindTo(methodHolder, endpointInstance, endpointConfig, session); + methodHolder = JavaxWebSocketFrameHandlerFactory.wrapNonVoidReturnType(methodHolder, session); + actualBinaryMetadata.setMethodHolder(methodHolder); binarySink = JavaxWebSocketFrameHandlerFactory.createMessageSink(session, actualBinaryMetadata); binaryMetadata = actualBinaryMetadata; @@ -352,7 +352,7 @@ public JavaxWebSocketMessageMetadata getTextMetadata() public void addMessageHandler(Class clazz, MessageHandler.Partial handler) { JavaxWebSocketMessageMetadata metadata = new JavaxWebSocketMessageMetadata(); - metadata.setMethodHandle(new JavaxMessagePartialMethodHandle<>(handler)); + metadata.setMethodHolder(new JavaxMessagePartialMethodHolder<>(handler)); byte basicType; // MessageHandler.Partial has no decoder support! if (byte[].class.isAssignableFrom(clazz)) @@ -383,12 +383,12 @@ else if (String.class.isAssignableFrom(clazz)) public void addMessageHandler(Class clazz, MessageHandler.Whole handler) { - JettyMethodHandle methodHandle = new JavaxMessageWholeMethodHandle<>(handler); + MethodHolder methodHolder = new JavaxMessageWholeMethodHolder<>(handler); if (PongMessage.class.isAssignableFrom(clazz)) { assertBasicTypeNotRegistered(OpCode.PONG, handler); - this.pongHandle = methodHandle; + this.pongHandle = methodHolder; registerMessageHandler(OpCode.PONG, clazz, handler, null); return; } @@ -400,7 +400,7 @@ public void addMessageHandler(Class clazz, MessageHandler.Whole handle // Create the message metadata specific to the MessageHandler type. JavaxWebSocketMessageMetadata metadata = new JavaxWebSocketMessageMetadata(); - metadata.setMethodHandle(methodHandle); + metadata.setMethodHolder(methodHolder); byte basicType; if (registeredDecoder.implementsInterface(Decoder.Binary.class)) { diff --git a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxWebSocketFrameHandlerFactory.java b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxWebSocketFrameHandlerFactory.java index e031a5323dfb..90145ef6e900 100644 --- a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxWebSocketFrameHandlerFactory.java +++ b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxWebSocketFrameHandlerFactory.java @@ -46,7 +46,7 @@ import org.eclipse.jetty.websocket.core.internal.messages.PartialByteBufferMessageSink; import org.eclipse.jetty.websocket.core.internal.messages.PartialStringMessageSink; import org.eclipse.jetty.websocket.core.internal.util.InvokerUtils; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.core.internal.util.ReflectUtils; import org.eclipse.jetty.websocket.javax.common.decoders.RegisteredDecoder; import org.eclipse.jetty.websocket.javax.common.messages.AbstractDecodedMessageSink; @@ -136,10 +136,10 @@ public JavaxWebSocketFrameHandler newJavaxWebSocketFrameHandler(Object endpointI if (metadata == null) return null; - JettyMethodHandle openHandle = JettyMethodHandle.from(metadata.getOpenHandle()); - JettyMethodHandle closeHandle = JettyMethodHandle.from(metadata.getCloseHandle()); - JettyMethodHandle errorHandle = JettyMethodHandle.from(metadata.getErrorHandle()); - JettyMethodHandle pongHandle = JettyMethodHandle.from(metadata.getPongHandle()); + MethodHolder openHandle = MethodHolder.from(metadata.getOpenHandle()); + MethodHolder closeHandle = MethodHolder.from(metadata.getCloseHandle()); + MethodHolder errorHandle = MethodHolder.from(metadata.getErrorHandle()); + MethodHolder pongHandle = MethodHolder.from(metadata.getPongHandle()); JavaxWebSocketMessageMetadata textMetadata = JavaxWebSocketMessageMetadata.copyOf(metadata.getTextMetadata()); JavaxWebSocketMessageMetadata binaryMetadata = JavaxWebSocketMessageMetadata.copyOf(metadata.getBinaryMetadata()); @@ -157,9 +157,9 @@ public JavaxWebSocketFrameHandler newJavaxWebSocketFrameHandler(Object endpointI pongHandle = bindTemplateVariables(pongHandle, namedVariables, pathParams); if (textMetadata != null) - textMetadata.setMethodHandle(bindTemplateVariables(textMetadata.getMethodHandle(), namedVariables, pathParams)); + textMetadata.setMethodHolder(bindTemplateVariables(textMetadata.getMethodHolder(), namedVariables, pathParams)); if (binaryMetadata != null) - binaryMetadata.setMethodHandle(bindTemplateVariables(binaryMetadata.getMethodHandle(), namedVariables, pathParams)); + binaryMetadata.setMethodHolder(bindTemplateVariables(binaryMetadata.getMethodHolder(), namedVariables, pathParams)); } openHandle = InvokerUtils.bindTo(openHandle, endpoint); @@ -191,15 +191,15 @@ public static MessageSink createMessageSink(JavaxWebSocketSession session, Javax if (AbstractDecodedMessageSink.class.isAssignableFrom(msgMetadata.getSinkClass())) { MethodHandle ctorHandle = lookup.findConstructor(msgMetadata.getSinkClass(), - MethodType.methodType(void.class, CoreSession.class, JettyMethodHandle.class, List.class)); + MethodType.methodType(void.class, CoreSession.class, MethodHolder.class, List.class)); List registeredDecoders = msgMetadata.getRegisteredDecoders(); - return (MessageSink)ctorHandle.invoke(session.getCoreSession(), msgMetadata.getMethodHandle(), registeredDecoders); + return (MessageSink)ctorHandle.invoke(session.getCoreSession(), msgMetadata.getMethodHolder(), registeredDecoders); } else { MethodHandle ctorHandle = lookup.findConstructor(msgMetadata.getSinkClass(), - MethodType.methodType(void.class, CoreSession.class, JettyMethodHandle.class)); - return (MessageSink)ctorHandle.invoke(session.getCoreSession(), msgMetadata.getMethodHandle()); + MethodType.methodType(void.class, CoreSession.class, MethodHolder.class)); + return (MessageSink)ctorHandle.invoke(session.getCoreSession(), msgMetadata.getMethodHolder()); } } catch (NoSuchMethodException e) @@ -220,7 +220,7 @@ public static MessageSink createMessageSink(JavaxWebSocketSession session, Javax } } - public static JettyMethodHandle wrapNonVoidReturnType(JettyMethodHandle handle, JavaxWebSocketSession session) + public static MethodHolder wrapNonVoidReturnType(MethodHolder handle, JavaxWebSocketSession session) { if (handle == null) return null; @@ -361,7 +361,7 @@ private boolean matchOnMessage(Method onMsg, JavaxWebSocketFrameHandlerMetadata if (methodHandle != null) { msgMetadata.setSinkClass(PartialStringMessageSink.class); - msgMetadata.setMethodHandle(JettyMethodHandle.from(methodHandle)); + msgMetadata.setMethodHolder(MethodHolder.from(methodHandle)); metadata.setTextMetadata(msgMetadata, onMsg); return true; } @@ -371,7 +371,7 @@ private boolean matchOnMessage(Method onMsg, JavaxWebSocketFrameHandlerMetadata if (methodHandle != null) { msgMetadata.setSinkClass(PartialByteBufferMessageSink.class); - msgMetadata.setMethodHandle(JettyMethodHandle.from(methodHandle)); + msgMetadata.setMethodHolder(MethodHolder.from(methodHandle)); metadata.setBinaryMetadata(msgMetadata, onMsg); return true; } @@ -381,7 +381,7 @@ private boolean matchOnMessage(Method onMsg, JavaxWebSocketFrameHandlerMetadata if (methodHandle != null) { msgMetadata.setSinkClass(PartialByteArrayMessageSink.class); - msgMetadata.setMethodHandle(JettyMethodHandle.from(methodHandle)); + msgMetadata.setMethodHolder(MethodHolder.from(methodHandle)); metadata.setBinaryMetadata(msgMetadata, onMsg); return true; } @@ -424,7 +424,7 @@ private boolean matchDecoders(Method onMsg, JavaxWebSocketFrameHandlerMetadata m objectType = decoder.objectType; } MethodHandle methodHandle = getMethodHandle.apply(getArgsFor(objectType)); - msgMetadata.setMethodHandle(JettyMethodHandle.from(methodHandle)); + msgMetadata.setMethodHolder(MethodHolder.from(methodHandle)); // Set the sinkClass and then set the MessageMetadata on the FrameHandlerMetadata if (interfaceType.equals(Decoder.Text.class)) @@ -509,7 +509,7 @@ private void assertSignatureValid(Class endpointClass, Method method, Class templateValues) + public static MethodHolder bindTemplateVariables(MethodHolder target, String[] namedVariables, Map templateValues) { if (target == null) { @@ -518,7 +518,7 @@ public static JettyMethodHandle bindTemplateVariables(JettyMethodHandle target, final int IDX = 1; - JettyMethodHandle retHandle = target; + MethodHolder retHandle = target; if ((templateValues == null) || (templateValues.isEmpty())) { diff --git a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxWebSocketMessageMetadata.java b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxWebSocketMessageMetadata.java index 4246bd58b1b6..340600220529 100644 --- a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxWebSocketMessageMetadata.java +++ b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/JavaxWebSocketMessageMetadata.java @@ -16,12 +16,12 @@ import java.util.List; import org.eclipse.jetty.websocket.core.internal.messages.MessageSink; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.javax.common.decoders.RegisteredDecoder; public class JavaxWebSocketMessageMetadata { - private JettyMethodHandle methodHandle; + private MethodHolder methodHolder; private Class sinkClass; private List registeredDecoders; @@ -34,7 +34,7 @@ public static JavaxWebSocketMessageMetadata copyOf(JavaxWebSocketMessageMetadata return null; JavaxWebSocketMessageMetadata copy = new JavaxWebSocketMessageMetadata(); - copy.methodHandle = metadata.methodHandle; + copy.methodHolder = metadata.methodHolder; copy.sinkClass = metadata.sinkClass; copy.registeredDecoders = metadata.registeredDecoders; copy.maxMessageSize = metadata.maxMessageSize; @@ -58,14 +58,14 @@ public void setMaxMessageSize(int maxMessageSize) this.maxMessageSizeSet = true; } - public JettyMethodHandle getMethodHandle() + public MethodHolder getMethodHolder() { - return methodHandle; + return methodHolder; } - public void setMethodHandle(JettyMethodHandle methodHandle) + public void setMethodHolder(MethodHolder methodHolder) { - this.methodHandle = methodHandle; + this.methodHolder = methodHolder; } public Class getSinkClass() diff --git a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/AbstractDecodedMessageSink.java b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/AbstractDecodedMessageSink.java index cbc62f2e1c35..9e169bafb393 100644 --- a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/AbstractDecodedMessageSink.java +++ b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/AbstractDecodedMessageSink.java @@ -23,7 +23,7 @@ import org.eclipse.jetty.websocket.core.Frame; import org.eclipse.jetty.websocket.core.exception.CloseException; import org.eclipse.jetty.websocket.core.internal.messages.MessageSink; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.javax.common.decoders.RegisteredDecoder; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -32,12 +32,12 @@ public abstract class AbstractDecodedMessageSink implements MessageSink { private static final Logger LOG = LoggerFactory.getLogger(AbstractDecodedMessageSink.class); - private final JettyMethodHandle _methodHandle; + private final MethodHolder _methodHolder; private final MessageSink _messageSink; - public AbstractDecodedMessageSink(CoreSession coreSession, JettyMethodHandle methodHandle) + public AbstractDecodedMessageSink(CoreSession coreSession, MethodHolder methodHolder) { - _methodHandle = methodHandle; + _methodHolder = methodHolder; try { @@ -58,7 +58,7 @@ void invoke(Object message) { try { - _methodHandle.invoke(message); + _methodHolder.invoke(message); } catch (Throwable t) { @@ -67,7 +67,7 @@ void invoke(Object message) } /** - * @return a message sink which will first decode the message then pass it to {@link #_methodHandle}. + * @return a message sink which will first decode the message then pass it to {@link #_methodHolder}. * @throws Exception for any error in creating the message sink. */ abstract MessageSink newMessageSink(CoreSession coreSession) throws Exception; @@ -84,9 +84,9 @@ public abstract static class Basic extends AbstractDecodedMes { protected final List _decoders; - public Basic(CoreSession coreSession, JettyMethodHandle methodHandle, List decoders) + public Basic(CoreSession coreSession, MethodHolder methodHolder, List decoders) { - super(coreSession, methodHandle); + super(coreSession, methodHolder); if (decoders.isEmpty()) throw new IllegalArgumentException("Require at least one decoder for " + this.getClass()); _decoders = decoders.stream() @@ -99,9 +99,9 @@ public abstract static class Stream extends AbstractDecodedMe { protected final T _decoder; - public Stream(CoreSession coreSession, JettyMethodHandle methodHandle, List decoders) + public Stream(CoreSession coreSession, MethodHolder methodHolder, List decoders) { - super(coreSession, methodHandle); + super(coreSession, methodHolder); if (decoders.size() != 1) throw new IllegalArgumentException("Require exactly one decoder for " + this.getClass()); _decoder = decoders.get(0).getInstance(); diff --git a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryMessageSink.java b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryMessageSink.java index 6da85197f6cf..4b14d2c27a16 100644 --- a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryMessageSink.java +++ b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryMessageSink.java @@ -24,8 +24,7 @@ import org.eclipse.jetty.websocket.core.exception.CloseException; import org.eclipse.jetty.websocket.core.internal.messages.ByteBufferMessageSink; import org.eclipse.jetty.websocket.core.internal.messages.MessageSink; -import org.eclipse.jetty.websocket.core.internal.util.AbstractJettyMethodHandle; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.javax.common.decoders.RegisteredDecoder; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -34,27 +33,23 @@ public class DecodedBinaryMessageSink extends AbstractDecodedMessageSink.Basi { private static final Logger LOG = LoggerFactory.getLogger(DecodedBinaryMessageSink.class); - public DecodedBinaryMessageSink(CoreSession session, JettyMethodHandle methodHandle, List decoders) + public DecodedBinaryMessageSink(CoreSession session, MethodHolder methodHolder, List decoders) { - super(session, methodHandle, decoders); + super(session, methodHolder, decoders); } @Override MessageSink newMessageSink(CoreSession coreSession) throws Exception { - JettyMethodHandle methodHandle = new AbstractJettyMethodHandle() + MethodHolder methodHolder = args -> { - @Override - public Object invoke(Object... args) - { - if (args.length != 1) - throw new WrongMethodTypeException(String.format("Expected %s params but had %s", 1, args.length)); - onWholeMessage((ByteBuffer)args[0]); - return null; - } + if (args.length != 1) + throw new WrongMethodTypeException(String.format("Expected %s params but had %s", 1, args.length)); + onWholeMessage((ByteBuffer)args[0]); + return null; }; - return new ByteBufferMessageSink(coreSession, methodHandle); + return new ByteBufferMessageSink(coreSession, methodHolder); } public void onWholeMessage(ByteBuffer wholeMessage) diff --git a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryStreamMessageSink.java b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryStreamMessageSink.java index 0262ad771ed1..eab8711a1de0 100644 --- a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryStreamMessageSink.java +++ b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryStreamMessageSink.java @@ -25,33 +25,28 @@ import org.eclipse.jetty.websocket.core.exception.CloseException; import org.eclipse.jetty.websocket.core.internal.messages.InputStreamMessageSink; import org.eclipse.jetty.websocket.core.internal.messages.MessageSink; -import org.eclipse.jetty.websocket.core.internal.util.AbstractJettyMethodHandle; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.javax.common.decoders.RegisteredDecoder; public class DecodedBinaryStreamMessageSink extends AbstractDecodedMessageSink.Stream> { - public DecodedBinaryStreamMessageSink(CoreSession session, JettyMethodHandle methodHandle, List decoders) + public DecodedBinaryStreamMessageSink(CoreSession session, MethodHolder methodHolder, List decoders) { - super(session, methodHandle, decoders); + super(session, methodHolder, decoders); } @Override MessageSink newMessageSink(CoreSession coreSession) { - JettyMethodHandle methodHandle = new AbstractJettyMethodHandle() + MethodHolder methodHolder = args -> { - @Override - public Object invoke(Object... args) - { - if (args.length != 1) - throw new WrongMethodTypeException(String.format("Expected %s params but had %s", 1, args.length)); - onStreamStart((InputStream)args[0]); - return null; - } + if (args.length != 1) + throw new WrongMethodTypeException(String.format("Expected %s params but had %s", 1, args.length)); + onStreamStart((InputStream)args[0]); + return null; }; - return new InputStreamMessageSink(coreSession, methodHandle); + return new InputStreamMessageSink(coreSession, methodHolder); } public void onStreamStart(InputStream stream) diff --git a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextMessageSink.java b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextMessageSink.java index c138e10cf74c..120b6b1a978e 100644 --- a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextMessageSink.java +++ b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextMessageSink.java @@ -23,8 +23,7 @@ import org.eclipse.jetty.websocket.core.exception.CloseException; import org.eclipse.jetty.websocket.core.internal.messages.MessageSink; import org.eclipse.jetty.websocket.core.internal.messages.StringMessageSink; -import org.eclipse.jetty.websocket.core.internal.util.AbstractJettyMethodHandle; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.javax.common.decoders.RegisteredDecoder; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -33,27 +32,23 @@ public class DecodedTextMessageSink extends AbstractDecodedMessageSink.Basic< { private static final Logger LOG = LoggerFactory.getLogger(DecodedTextMessageSink.class); - public DecodedTextMessageSink(CoreSession session, JettyMethodHandle methodHandle, List decoders) + public DecodedTextMessageSink(CoreSession session, MethodHolder methodHolder, List decoders) { - super(session, methodHandle, decoders); + super(session, methodHolder, decoders); } @Override MessageSink newMessageSink(CoreSession coreSession) { - JettyMethodHandle methodHandle = new AbstractJettyMethodHandle() + MethodHolder methodHolder = args -> { - @Override - public Object invoke(Object... args) - { - if (args.length != 1) - throw new WrongMethodTypeException(String.format("Expected %s params but had %s", 1, args.length)); - onMessage((String)args[0]); - return null; - } + if (args.length != 1) + throw new WrongMethodTypeException(String.format("Expected %s params but had %s", 1, args.length)); + onMessage((String)args[0]); + return null; }; - return new StringMessageSink(coreSession, methodHandle); + return new StringMessageSink(coreSession, methodHolder); } public void onMessage(String wholeMessage) diff --git a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextStreamMessageSink.java b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextStreamMessageSink.java index 079ccba1c95e..7076aecb403f 100644 --- a/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextStreamMessageSink.java +++ b/jetty-websocket/websocket-javax-common/src/main/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextStreamMessageSink.java @@ -25,33 +25,28 @@ import org.eclipse.jetty.websocket.core.exception.CloseException; import org.eclipse.jetty.websocket.core.internal.messages.MessageSink; import org.eclipse.jetty.websocket.core.internal.messages.ReaderMessageSink; -import org.eclipse.jetty.websocket.core.internal.util.AbstractJettyMethodHandle; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.javax.common.decoders.RegisteredDecoder; public class DecodedTextStreamMessageSink extends AbstractDecodedMessageSink.Stream> { - public DecodedTextStreamMessageSink(CoreSession session, JettyMethodHandle methodHandle, List decoders) + public DecodedTextStreamMessageSink(CoreSession session, MethodHolder methodHolder, List decoders) { - super(session, methodHandle, decoders); + super(session, methodHolder, decoders); } @Override MessageSink newMessageSink(CoreSession coreSession) { - JettyMethodHandle methodHandle = new AbstractJettyMethodHandle() + MethodHolder methodHolder = args -> { - @Override - public Object invoke(Object... args) - { - if (args.length != 1) - throw new WrongMethodTypeException(String.format("Expected %s params but had %s", 1, args.length)); - onStreamStart((Reader)args[0]); - return null; - } + if (args.length != 1) + throw new WrongMethodTypeException(String.format("Expected %s params but had %s", 1, args.length)); + onStreamStart((Reader)args[0]); + return null; }; - return new ReaderMessageSink(coreSession, methodHandle); + return new ReaderMessageSink(coreSession, methodHolder); } public void onStreamStart(Reader reader) diff --git a/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryMessageSinkTest.java b/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryMessageSinkTest.java index 14a1ccde945c..80d3e8aee8fb 100644 --- a/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryMessageSinkTest.java +++ b/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryMessageSinkTest.java @@ -29,7 +29,7 @@ import org.eclipse.jetty.util.FutureCallback; import org.eclipse.jetty.websocket.core.Frame; import org.eclipse.jetty.websocket.core.OpCode; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.javax.common.AbstractSessionTest; import org.eclipse.jetty.websocket.javax.common.decoders.RegisteredDecoder; import org.junit.jupiter.api.Test; @@ -48,7 +48,7 @@ public void testCalendar1Frame() throws Exception DecodedCalendarCopy copy = new DecodedCalendarCopy(copyFuture); MethodHandle copyHandle = getAcceptHandle(copy, Calendar.class); List decoders = toRegisteredDecoderList(GmtDecoder.class, Calendar.class); - DecodedBinaryMessageSink sink = new DecodedBinaryMessageSink<>(AbstractSessionTest.session.getCoreSession(), JettyMethodHandle.from(copyHandle), decoders); + DecodedBinaryMessageSink sink = new DecodedBinaryMessageSink<>(AbstractSessionTest.session.getCoreSession(), MethodHolder.from(copyHandle), decoders); FutureCallback finCallback = new FutureCallback(); ByteBuffer data = ByteBuffer.allocate(16); @@ -71,7 +71,7 @@ public void testCalendar3Frames() throws Exception DecodedCalendarCopy copy = new DecodedCalendarCopy(copyFuture); MethodHandle copyHandle = getAcceptHandle(copy, Calendar.class); List decoders = toRegisteredDecoderList(GmtDecoder.class, Calendar.class); - DecodedBinaryMessageSink sink = new DecodedBinaryMessageSink<>(AbstractSessionTest.session.getCoreSession(), JettyMethodHandle.from(copyHandle), decoders); + DecodedBinaryMessageSink sink = new DecodedBinaryMessageSink<>(AbstractSessionTest.session.getCoreSession(), MethodHolder.from(copyHandle), decoders); FutureCallback callback1 = new FutureCallback(); FutureCallback callback2 = new FutureCallback(); diff --git a/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryStreamMessageSinkTest.java b/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryStreamMessageSinkTest.java index 5ff072d15a63..cd31bdb6e039 100644 --- a/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryStreamMessageSinkTest.java +++ b/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedBinaryStreamMessageSinkTest.java @@ -32,7 +32,7 @@ import org.eclipse.jetty.util.FutureCallback; import org.eclipse.jetty.websocket.core.Frame; import org.eclipse.jetty.websocket.core.OpCode; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.javax.common.decoders.RegisteredDecoder; import org.junit.jupiter.api.Test; @@ -50,7 +50,7 @@ public void testCalendar1Frame() throws Exception DecodedCalendarCopy copy = new DecodedCalendarCopy(copyFuture); MethodHandle copyHandle = getAcceptHandle(copy, Calendar.class); List decoders = toRegisteredDecoderList(GmtDecoder.class, Calendar.class); - DecodedBinaryStreamMessageSink sink = new DecodedBinaryStreamMessageSink<>(session.getCoreSession(), JettyMethodHandle.from(copyHandle), decoders); + DecodedBinaryStreamMessageSink sink = new DecodedBinaryStreamMessageSink<>(session.getCoreSession(), MethodHolder.from(copyHandle), decoders); FutureCallback finCallback = new FutureCallback(); ByteBuffer data = ByteBuffer.allocate(16); @@ -73,7 +73,7 @@ public void testCalendar3Frames() throws Exception DecodedCalendarCopy copy = new DecodedCalendarCopy(copyFuture); MethodHandle copyHandle = getAcceptHandle(copy, Calendar.class); List decoders = toRegisteredDecoderList(GmtDecoder.class, Calendar.class); - DecodedBinaryStreamMessageSink sink = new DecodedBinaryStreamMessageSink<>(session.getCoreSession(), JettyMethodHandle.from(copyHandle), decoders); + DecodedBinaryStreamMessageSink sink = new DecodedBinaryStreamMessageSink<>(session.getCoreSession(), MethodHolder.from(copyHandle), decoders); FutureCallback callback1 = new FutureCallback(); FutureCallback callback2 = new FutureCallback(); diff --git a/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextMessageSinkTest.java b/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextMessageSinkTest.java index f7f9b9894021..9777e3732725 100644 --- a/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextMessageSinkTest.java +++ b/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextMessageSinkTest.java @@ -30,7 +30,7 @@ import org.eclipse.jetty.util.FutureCallback; import org.eclipse.jetty.websocket.core.Frame; import org.eclipse.jetty.websocket.core.OpCode; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.javax.common.decoders.RegisteredDecoder; import org.junit.jupiter.api.Test; @@ -48,7 +48,7 @@ public void testDate1Frame() throws Exception DecodedDateCopy copy = new DecodedDateCopy(copyFuture); MethodHandle copyHandle = getAcceptHandle(copy, Date.class); List decoders = toRegisteredDecoderList(GmtDecoder.class, Calendar.class); - DecodedTextMessageSink sink = new DecodedTextMessageSink<>(session.getCoreSession(), JettyMethodHandle.from(copyHandle), decoders); + DecodedTextMessageSink sink = new DecodedTextMessageSink<>(session.getCoreSession(), MethodHolder.from(copyHandle), decoders); FutureCallback finCallback = new FutureCallback(); sink.accept(new Frame(OpCode.TEXT).setPayload("2018.02.13").setFin(true), finCallback); @@ -66,7 +66,7 @@ public void testDate3Frames() throws Exception DecodedDateCopy copy = new DecodedDateCopy(copyFuture); MethodHandle copyHandle = getAcceptHandle(copy, Date.class); List decoders = toRegisteredDecoderList(GmtDecoder.class, Calendar.class); - DecodedTextMessageSink sink = new DecodedTextMessageSink<>(session.getCoreSession(), JettyMethodHandle.from(copyHandle), decoders); + DecodedTextMessageSink sink = new DecodedTextMessageSink<>(session.getCoreSession(), MethodHolder.from(copyHandle), decoders); FutureCallback callback1 = new FutureCallback(); FutureCallback callback2 = new FutureCallback(); diff --git a/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextStreamMessageSinkTest.java b/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextStreamMessageSinkTest.java index 6f1b3ed34057..f60b99cf3a6f 100644 --- a/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextStreamMessageSinkTest.java +++ b/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/messages/DecodedTextStreamMessageSinkTest.java @@ -33,7 +33,7 @@ import org.eclipse.jetty.util.IO; import org.eclipse.jetty.websocket.core.Frame; import org.eclipse.jetty.websocket.core.OpCode; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.javax.common.decoders.RegisteredDecoder; import org.junit.jupiter.api.Test; @@ -51,7 +51,7 @@ public void testDate1Frame() throws Exception DecodedDateCopy copy = new DecodedDateCopy(copyFuture); MethodHandle copyHandle = getAcceptHandle(copy, Date.class); List decoders = toRegisteredDecoderList(GmtDecoder.class, Calendar.class); - DecodedTextStreamMessageSink sink = new DecodedTextStreamMessageSink<>(session.getCoreSession(), JettyMethodHandle.from(copyHandle), decoders); + DecodedTextStreamMessageSink sink = new DecodedTextStreamMessageSink<>(session.getCoreSession(), MethodHolder.from(copyHandle), decoders); FutureCallback finCallback = new FutureCallback(); sink.accept(new Frame(OpCode.TEXT).setPayload("2018.02.13").setFin(true), finCallback); @@ -69,7 +69,7 @@ public void testDate3Frames() throws Exception DecodedDateCopy copy = new DecodedDateCopy(copyFuture); MethodHandle copyHandle = getAcceptHandle(copy, Date.class); List decoders = toRegisteredDecoderList(GmtDecoder.class, Calendar.class); - DecodedTextStreamMessageSink sink = new DecodedTextStreamMessageSink<>(session.getCoreSession(), JettyMethodHandle.from(copyHandle), decoders); + DecodedTextStreamMessageSink sink = new DecodedTextStreamMessageSink<>(session.getCoreSession(), MethodHolder.from(copyHandle), decoders); FutureCallback callback1 = new FutureCallback(); FutureCallback callback2 = new FutureCallback(); diff --git a/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/util/InvokerUtilsStaticParamsTest.java b/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/util/InvokerUtilsStaticParamsTest.java index 407d83877fa2..7df3f5f9c34a 100644 --- a/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/util/InvokerUtilsStaticParamsTest.java +++ b/jetty-websocket/websocket-javax-common/src/test/java/org/eclipse/jetty/websocket/javax/common/util/InvokerUtilsStaticParamsTest.java @@ -22,7 +22,7 @@ import org.eclipse.jetty.util.annotation.Name; import org.eclipse.jetty.websocket.core.internal.util.InvokerUtils; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.core.internal.util.ReflectUtils; import org.eclipse.jetty.websocket.javax.common.JavaxWebSocketFrameHandlerFactory; import org.junit.jupiter.api.Test; @@ -58,10 +58,10 @@ public String onColorMessage(Session session, String message, @Name("color") Str private static MethodHandles.Lookup lookup = MethodHandles.lookup(); - private JettyMethodHandle getMethodHandle(Method method, String[] namedVariables, InvokerUtils.Arg... args) + private MethodHolder getMethodHolder(Method method, String[] namedVariables, InvokerUtils.Arg... args) { MethodHandle methodHandle = InvokerUtils.mutatedInvoker(lookup, Foo.class, method, new NameParamIdentifier(), namedVariables, args); - return JettyMethodHandle.from(methodHandle); + return MethodHolder.from(methodHandle); } @Test @@ -77,21 +77,21 @@ public void testOnlyParamString() throws Throwable // Raw Calling Args - none specified // Get basic method handle (without a instance to call against) - this is what the metadata stores - JettyMethodHandle methodHandle = getMethodHandle(method, namedVariables); + MethodHolder methodHolder = getMethodHolder(method, namedVariables); // Some point later an actual instance is needed, which has static named parameters Map templateValues = new HashMap<>(); templateValues.put("fruit", "pear"); // Bind the static values, in same order as declared - methodHandle = JavaxWebSocketFrameHandlerFactory.bindTemplateVariables(methodHandle, namedVariables, templateValues); + methodHolder = JavaxWebSocketFrameHandlerFactory.bindTemplateVariables(methodHolder, namedVariables, templateValues); // Assign an instance to call. Foo foo = new Foo(); - methodHandle = methodHandle.bindTo(foo); + methodHolder = methodHolder.bindTo(foo); // Call method against instance - String result = (String)methodHandle.invoke(); + String result = (String)methodHolder.invoke(); assertThat("Result", result, is("onFruit('pear')")); } @@ -106,21 +106,21 @@ public void testOnlyParamInt() throws Throwable }; // Get basic method handle (without a instance to call against) - this is what the metadata stores - JettyMethodHandle methodHandle = getMethodHandle(method, namedVariables); + MethodHolder methodHolder = getMethodHolder(method, namedVariables); // Some point later an actual instance is needed, which has static named parameters Map templateValues = new HashMap<>(); templateValues.put("count", "2222"); // Bind the static values for the variables, in same order as the variables were declared - methodHandle = JavaxWebSocketFrameHandlerFactory.bindTemplateVariables(methodHandle, namedVariables, templateValues); + methodHolder = JavaxWebSocketFrameHandlerFactory.bindTemplateVariables(methodHolder, namedVariables, templateValues); // Assign an instance to call. Foo foo = new Foo(); - methodHandle = methodHandle.bindTo(foo); + methodHolder = methodHolder.bindTo(foo); // Call method against instance - String result = (String)methodHandle.invoke(); + String result = (String)methodHolder.invoke(); assertThat("Result", result, is("onCount(2222)")); } @@ -137,21 +137,21 @@ public void testLabeledParamStringInt() throws Throwable final InvokerUtils.Arg ARG_LABEL = new InvokerUtils.Arg(String.class).required(); // Get basic method handle (without a instance to call against) - this is what the metadata stores - JettyMethodHandle methodHandle = getMethodHandle(method, namedVariables, ARG_LABEL); + MethodHolder methodHolder = getMethodHolder(method, namedVariables, ARG_LABEL); // Some point later an actual instance is needed, which has static named parameters Map templateValues = new HashMap<>(); templateValues.put("count", "444"); // Bind the static values for the variables, in same order as the variables were declared - methodHandle = JavaxWebSocketFrameHandlerFactory.bindTemplateVariables(methodHandle, namedVariables, templateValues); + methodHolder = JavaxWebSocketFrameHandlerFactory.bindTemplateVariables(methodHolder, namedVariables, templateValues); // Assign an instance to call. Foo foo = new Foo(); - methodHandle = methodHandle.bindTo(foo); + methodHolder = methodHolder.bindTo(foo); // Call method against instance - String result = (String)methodHandle.invoke("cherry"); + String result = (String)methodHolder.invoke("cherry"); assertThat("Result", result, is("onLabeledCount('cherry', 444)")); } } diff --git a/jetty-websocket/websocket-javax-tests/src/test/java/org/eclipse/jetty/websocket/javax/tests/coders/DecoderTextStreamTest.java b/jetty-websocket/websocket-javax-tests/src/test/java/org/eclipse/jetty/websocket/javax/tests/coders/DecoderTextStreamTest.java index 43960fd3361d..f139a915ee66 100644 --- a/jetty-websocket/websocket-javax-tests/src/test/java/org/eclipse/jetty/websocket/javax/tests/coders/DecoderTextStreamTest.java +++ b/jetty-websocket/websocket-javax-tests/src/test/java/org/eclipse/jetty/websocket/javax/tests/coders/DecoderTextStreamTest.java @@ -29,7 +29,7 @@ import org.eclipse.jetty.util.FutureCallback; import org.eclipse.jetty.websocket.core.Frame; import org.eclipse.jetty.websocket.core.WebSocketComponents; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.javax.common.decoders.RegisteredDecoder; import org.eclipse.jetty.websocket.javax.common.messages.DecodedTextStreamMessageSink; import org.eclipse.jetty.websocket.javax.tests.FunctionMethod; @@ -81,7 +81,7 @@ public void testQuotesDecodedReaderMessageSink() throws Exception }); List decoders = toRegisteredDecoderList(QuotesDecoder.class, Quotes.class); - DecodedTextStreamMessageSink sink = new DecodedTextStreamMessageSink<>(session.getCoreSession(), JettyMethodHandle.from(quoteHandle), decoders); + DecodedTextStreamMessageSink sink = new DecodedTextStreamMessageSink<>(session.getCoreSession(), MethodHolder.from(quoteHandle), decoders); List callbacks = new ArrayList<>(); FutureCallback finCallback = null; diff --git a/jetty-websocket/websocket-jetty-common/src/main/java/org/eclipse/jetty/websocket/common/JettyWebSocketFrameHandler.java b/jetty-websocket/websocket-jetty-common/src/main/java/org/eclipse/jetty/websocket/common/JettyWebSocketFrameHandler.java index 3387dbf19562..fb9801e10f53 100644 --- a/jetty-websocket/websocket-jetty-common/src/main/java/org/eclipse/jetty/websocket/common/JettyWebSocketFrameHandler.java +++ b/jetty-websocket/websocket-jetty-common/src/main/java/org/eclipse/jetty/websocket/common/JettyWebSocketFrameHandler.java @@ -42,7 +42,7 @@ import org.eclipse.jetty.websocket.core.exception.WebSocketTimeoutException; import org.eclipse.jetty.websocket.core.internal.messages.MessageSink; import org.eclipse.jetty.websocket.core.internal.util.InvokerUtils; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -62,16 +62,16 @@ private enum SuspendState private final Object endpointInstance; private final BatchMode batchMode; private final AtomicBoolean closeNotified = new AtomicBoolean(); - private JettyMethodHandle openHandle; - private JettyMethodHandle closeHandle; - private JettyMethodHandle errorHandle; - private JettyMethodHandle textHandle; + private MethodHolder openHandle; + private MethodHolder closeHandle; + private MethodHolder errorHandle; + private MethodHolder textHandle; private final Class textSinkClass; - private JettyMethodHandle binaryHandle; + private MethodHolder binaryHandle; private final Class binarySinkClass; - private JettyMethodHandle frameHandle; - private JettyMethodHandle pingHandle; - private JettyMethodHandle pongHandle; + private MethodHolder frameHandle; + private MethodHolder pingHandle; + private MethodHolder pongHandle; private UpgradeRequest upgradeRequest; private UpgradeResponse upgradeResponse; @@ -86,12 +86,12 @@ private enum SuspendState public JettyWebSocketFrameHandler(WebSocketContainer container, Object endpointInstance, - JettyMethodHandle openHandle, JettyMethodHandle closeHandle, JettyMethodHandle errorHandle, - JettyMethodHandle textHandle, JettyMethodHandle binaryHandle, + MethodHolder openHandle, MethodHolder closeHandle, MethodHolder errorHandle, + MethodHolder textHandle, MethodHolder binaryHandle, Class textSinkClass, Class binarySinkClass, - JettyMethodHandle frameHandle, - JettyMethodHandle pingHandle, JettyMethodHandle pongHandle, + MethodHolder frameHandle, + MethodHolder pingHandle, MethodHolder pongHandle, BatchMode batchMode, Configuration.Customizer customizer) { diff --git a/jetty-websocket/websocket-jetty-common/src/main/java/org/eclipse/jetty/websocket/common/JettyWebSocketFrameHandlerFactory.java b/jetty-websocket/websocket-jetty-common/src/main/java/org/eclipse/jetty/websocket/common/JettyWebSocketFrameHandlerFactory.java index e1b390da2bcf..a236368b1847 100644 --- a/jetty-websocket/websocket-jetty-common/src/main/java/org/eclipse/jetty/websocket/common/JettyWebSocketFrameHandlerFactory.java +++ b/jetty-websocket/websocket-jetty-common/src/main/java/org/eclipse/jetty/websocket/common/JettyWebSocketFrameHandlerFactory.java @@ -58,7 +58,7 @@ import org.eclipse.jetty.websocket.core.internal.messages.ReaderMessageSink; import org.eclipse.jetty.websocket.core.internal.messages.StringMessageSink; import org.eclipse.jetty.websocket.core.internal.util.InvokerUtils; -import org.eclipse.jetty.websocket.core.internal.util.JettyMethodHandle; +import org.eclipse.jetty.websocket.core.internal.util.MethodHolder; import org.eclipse.jetty.websocket.core.internal.util.ReflectUtils; /** @@ -172,16 +172,16 @@ public JettyWebSocketFrameHandler newJettyFrameHandler(Object endpointInstance) { JettyWebSocketFrameHandlerMetadata metadata = getMetadata(endpointInstance.getClass()); - final JettyMethodHandle openHandle = InvokerUtils.bindTo(JettyMethodHandle.from(metadata.getOpenHandle()), endpointInstance); - final JettyMethodHandle closeHandle = InvokerUtils.bindTo(JettyMethodHandle.from(metadata.getCloseHandle()), endpointInstance); - final JettyMethodHandle errorHandle = InvokerUtils.bindTo(JettyMethodHandle.from(metadata.getErrorHandle()), endpointInstance); - final JettyMethodHandle textHandle = InvokerUtils.bindTo(JettyMethodHandle.from(metadata.getTextHandle()), endpointInstance); - final JettyMethodHandle binaryHandle = InvokerUtils.bindTo(JettyMethodHandle.from(metadata.getBinaryHandle()), endpointInstance); + final MethodHolder openHandle = InvokerUtils.bindTo(MethodHolder.from(metadata.getOpenHandle()), endpointInstance); + final MethodHolder closeHandle = InvokerUtils.bindTo(MethodHolder.from(metadata.getCloseHandle()), endpointInstance); + final MethodHolder errorHandle = InvokerUtils.bindTo(MethodHolder.from(metadata.getErrorHandle()), endpointInstance); + final MethodHolder textHandle = InvokerUtils.bindTo(MethodHolder.from(metadata.getTextHandle()), endpointInstance); + final MethodHolder binaryHandle = InvokerUtils.bindTo(MethodHolder.from(metadata.getBinaryHandle()), endpointInstance); final Class textSinkClass = metadata.getTextSink(); final Class binarySinkClass = metadata.getBinarySink(); - final JettyMethodHandle frameHandle = InvokerUtils.bindTo(JettyMethodHandle.from(metadata.getFrameHandle()), endpointInstance); - final JettyMethodHandle pingHandle = InvokerUtils.bindTo(JettyMethodHandle.from(metadata.getPingHandle()), endpointInstance); - final JettyMethodHandle pongHandle = InvokerUtils.bindTo(JettyMethodHandle.from(metadata.getPongHandle()), endpointInstance); + final MethodHolder frameHandle = InvokerUtils.bindTo(MethodHolder.from(metadata.getFrameHandle()), endpointInstance); + final MethodHolder pingHandle = InvokerUtils.bindTo(MethodHolder.from(metadata.getPingHandle()), endpointInstance); + final MethodHolder pongHandle = InvokerUtils.bindTo(MethodHolder.from(metadata.getPongHandle()), endpointInstance); BatchMode batchMode = metadata.getBatchMode(); // Decorate the endpointInstance while we are still upgrading for access to things like HttpSession. @@ -198,7 +198,7 @@ public JettyWebSocketFrameHandler newJettyFrameHandler(Object endpointInstance) metadata); } - public static MessageSink createMessageSink(JettyMethodHandle msgHandle, Class sinkClass, Executor executor, WebSocketSession session) + public static MessageSink createMessageSink(MethodHolder msgHandle, Class sinkClass, Executor executor, WebSocketSession session) { if (msgHandle == null) return null; @@ -209,7 +209,7 @@ public static MessageSink createMessageSink(JettyMethodHandle msgHandle, Class