serverSoftReference, Logger logger) {
this.serverSoftReference = serverSoftReference;
- this.packetRegistry = serverSoftReference.get().getInitialPacketRegistry();
+ this.packetRegistry = serverSoftReference.get().getPacketRegistry();
this.logger = logger;
}
@@ -68,7 +68,7 @@ public void channelActive(ChannelHandlerContext ctx) {
NettyAttributes.setAttribute(ctx, NettyAttributes.CONNECTION_ATTRIBUTE_KEY, connection);
NettyAttributes.setAttribute(ctx, NettyAttributes.HANDLER_BOSS_ATTRIBUTE_KEY, this);
- this.serverSoftReference.get().onConnected(connection);
+ this.serverSoftReference.get().handleConnect(connection);
}
@Override
@@ -78,7 +78,7 @@ public void channelInactive(ChannelHandlerContext ctx) {
return;
}
new PreDisconnectionEvent(connection).callGlobally();
- this.serverSoftReference.get().onDisconnected(connection);
+ this.serverSoftReference.get().handleDisconnect(connection);
}
@Override
diff --git a/protocol/src/main/java/org/feathercore/protocol/netty/NettyServer.java b/protocol/src/main/java/org/feathercore/protocol/netty/NettyServer.java
index cba7ead..553f379 100644
--- a/protocol/src/main/java/org/feathercore/protocol/netty/NettyServer.java
+++ b/protocol/src/main/java/org/feathercore/protocol/netty/NettyServer.java
@@ -22,46 +22,50 @@
import io.netty.channel.ChannelFutureListener;
import lombok.NonNull;
import lombok.extern.log4j.Log4j2;
-import org.feathercore.protocol.server.BaseServer;
import org.feathercore.protocol.netty.channel.ChannelInitializer;
import org.feathercore.protocol.netty.util.SharedNettyResources;
+import org.feathercore.protocol.packet.Packet;
+import org.feathercore.protocol.server.AbstractServer;
import java.lang.ref.SoftReference;
+import java.net.SocketAddress;
/**
- * Created by k.shandurenko on 12/04/2019
+ * Netty-based {@link org.feathercore.protocol.server.Server} implementation.
+ *
+ * @param super-type of packets used by this server's protocol
*/
@Log4j2
-public abstract class NettyServer extends BaseServer {
+public abstract class NettyServer
extends AbstractServer
{
@NonNull private final SharedNettyResources sharedNettyResources;
protected Channel channel;
- public NettyServer(@NonNull final String host, final int port) {
- super(host, port);
- this.sharedNettyResources = SharedNettyResources.builder().build();
+ protected NettyServer(@NonNull final SocketAddress socketAddress,
+ @NonNull final SharedNettyResources sharedNettyResources) {
+ super(socketAddress);
+ this.sharedNettyResources = sharedNettyResources;
}
@Override
- public ChannelFuture start() {
+ protected ChannelFuture performStart() {
ServerBootstrap bootstrap = new ServerBootstrap()
.group(sharedNettyResources.getBossLoopGroup(), sharedNettyResources.getWorkerLoopGroup())
- .channel(sharedNettyResources.getServerChannelClass())
+ .channel(sharedNettyResources.getTransportType().getServerChannelClass())
.childHandler(new ChannelInitializer(new SoftReference<>(this), log));
- return bootstrap.bind(host, port).addListener((ChannelFutureListener) future -> {
+ return bootstrap.bind(address).addListener((ChannelFutureListener) future -> {
if (future.isSuccess()) {
channel = future.channel();
- log.info("BaseServer has been started on " + host + ":" + port);
+ log.info("Server has been started on " + address);
} else {
- log.warn("BaseServer could not bind to " + host + ":" + port, future.cause());
+ log.warn("Server could not bind to " + address, future.cause());
}
});
}
@Override
- public ChannelFuture stop() {
+ protected ChannelFuture performStop() {
return channel.close().syncUninterruptibly();
}
-
}
diff --git a/protocol/src/main/java/org/feathercore/protocol/netty/channel/ChannelInitializer.java b/protocol/src/main/java/org/feathercore/protocol/netty/channel/ChannelInitializer.java
index d00e1d1..6ecc6c1 100644
--- a/protocol/src/main/java/org/feathercore/protocol/netty/channel/ChannelInitializer.java
+++ b/protocol/src/main/java/org/feathercore/protocol/netty/channel/ChannelInitializer.java
@@ -21,12 +21,12 @@
import io.netty.handler.timeout.ReadTimeoutHandler;
import lombok.RequiredArgsConstructor;
import org.apache.logging.log4j.Logger;
-import org.feathercore.protocol.server.BaseServer;
import org.feathercore.protocol.netty.HandlerBoss;
import org.feathercore.protocol.netty.codec.InboundDecoder;
import org.feathercore.protocol.netty.codec.InboundPacketDecoder;
import org.feathercore.protocol.netty.codec.OutboundEncoder;
import org.feathercore.protocol.netty.codec.ServerPingAdapter;
+import org.feathercore.protocol.server.Server;
import java.lang.ref.SoftReference;
@@ -36,7 +36,7 @@
@RequiredArgsConstructor
public class ChannelInitializer extends io.netty.channel.ChannelInitializer {
- private final SoftReference serverSoftReference;
+ private final SoftReference serverSoftReference;
private final Logger logger;
@Override
diff --git a/protocol/src/main/java/org/feathercore/protocol/netty/util/AbstractSharedNettyResources.java b/protocol/src/main/java/org/feathercore/protocol/netty/util/AbstractSharedNettyResources.java
new file mode 100644
index 0000000..64ac261
--- /dev/null
+++ b/protocol/src/main/java/org/feathercore/protocol/netty/util/AbstractSharedNettyResources.java
@@ -0,0 +1,197 @@
+/*
+ * Copyright 2019 Feather Core
+ *
+ * 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 org.feathercore.protocol.netty.util;
+
+import io.netty.channel.EventLoopGroup;
+import io.netty.util.concurrent.Future;
+import lombok.*;
+import lombok.experimental.FieldDefaults;
+import lombok.experimental.NonFinal;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+@FieldDefaults(level = AccessLevel.PROTECTED, makeFinal = true)
+public abstract class AbstractSharedNettyResources implements SharedNettyResources {
+
+ @NonNull @Getter TransportType transportType;
+ boolean bossIsWorker;
+
+ @NonNull final Lock readLock, writeLock;
+ @NonNull final AtomicBoolean shutDown;
+
+ @NonFinal @Nullable volatile EventLoopGroup bossLoopGroup;
+ @NonFinal @Nullable volatile EventLoopGroup workerLoopGroup;
+
+ public AbstractSharedNettyResources(@NonNull final TransportType transportType, final boolean bossIsWorker) {
+ this.transportType = transportType;
+ this.bossIsWorker = bossIsWorker;
+
+ shutDown = new AtomicBoolean();
+ {
+ val lock = new ReentrantReadWriteLock();
+ readLock = lock.readLock();
+ writeLock = lock.writeLock();
+ }
+ }
+
+ /* *********************************************** Stateful data *********************************************** */
+
+ protected abstract EventLoopGroup newBossLoopGroup();
+
+ protected abstract EventLoopGroup newWorkerLoopGroup();
+
+ /**
+ * Asserts that this instance is not shut down.
+ *
+ * @throws IllegalStateException if this instance is already shut down
+ */
+ protected void assertNotShutDown() {
+ if (isShutDown()) {
+ throw new IllegalStateException("LoopGroupGracefully is already shut down.");
+ }
+ }
+
+ @Override
+ public boolean isInitialized() {
+ assertNotShutDown();
+
+ readLock.lock();
+ try {
+ return bossLoopGroup != null && workerLoopGroup != null;
+ } finally {
+ readLock.unlock();
+ }
+ }
+
+ @Override
+ public boolean isShutDown() {
+ return shutDown.get();
+ }
+
+ @SneakyThrows(InterruptedException.class)
+ protected void performLoopGroupsShutdownGracefully(final boolean await) {
+ readLock.lock();
+ try {
+ if (bossLoopGroup != null || workerLoopGroup != null) {
+ writeLock.lock();
+ try {
+ // used not to duplicate GETFIELD invocations and to omit potential null-checks
+ var loopGroup = bossLoopGroup;
+ @Nullable final Future bossShutDown;
+ /* Shutdown boss */
+ if (loopGroup != null) {
+ bossShutDown = loopGroup.shutdownGracefully();
+ bossLoopGroup = null;
+ } else {
+ bossShutDown = null;
+ }
+
+ loopGroup = workerLoopGroup;
+ @Nullable final Future workerShutDown;
+ if (loopGroup != null) {
+ /* Shutdown worker */
+ workerShutDown = loopGroup.shutdownGracefully().await();
+ workerLoopGroup = null;
+ } else {
+ workerShutDown = null;
+ }
+
+ if (await) {
+ if (bossShutDown != null) {
+ bossShutDown.await();
+ }
+ if (workerShutDown != null) {
+ workerShutDown.await();
+ }
+ }
+ } finally {
+ writeLock.unlock();
+ }
+ }
+ } finally {
+ readLock.unlock();
+ }
+ }
+
+ @Override
+ public void shutdownLoopGroupsGracefully(final boolean await) {
+ if (shutDown.compareAndSet(false, true)) {
+ performLoopGroupsShutdownGracefully(await);
+ } else {
+ throw new IllegalStateException("LoopGroupGracefully is already shut down.");
+ }
+ }
+
+ @Override
+ public boolean tryShutdownLoopGroupsGracefully(final boolean await) {
+ if (shutDown.compareAndSet(false, true)) {
+ performLoopGroupsShutdownGracefully(await);
+
+ return true;
+ }
+
+ return false;
+ }
+
+ @Override
+ @NotNull public EventLoopGroup getBossLoopGroup() {
+ assertNotShutDown();
+
+ readLock.lock();
+ try {
+ val loopGroup = bossLoopGroup;
+ if (loopGroup == null) {
+ writeLock.lock();
+ try {
+ return bossLoopGroup = newWorkerLoopGroup();
+ } finally {
+ writeLock.unlock();
+ }
+ }
+
+ return loopGroup;
+ } finally {
+ readLock.unlock();
+ }
+ }
+
+ @Override
+ @NotNull public EventLoopGroup getWorkerLoopGroup() {
+ assertNotShutDown();
+
+ readLock.lock();
+ try {
+ val loopGroup = workerLoopGroup;
+ if (loopGroup == null) {
+ writeLock.lock();
+ try {
+ return workerLoopGroup = newWorkerLoopGroup();
+ } finally {
+ writeLock.unlock();
+ }
+ }
+
+ return loopGroup;
+ } finally {
+ readLock.unlock();
+ }
+ }
+}
diff --git a/protocol/src/main/java/org/feathercore/protocol/netty/util/DefaultTransportType.java b/protocol/src/main/java/org/feathercore/protocol/netty/util/DefaultTransportType.java
new file mode 100644
index 0000000..8f58bd3
--- /dev/null
+++ b/protocol/src/main/java/org/feathercore/protocol/netty/util/DefaultTransportType.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2019 Feather Core
+ *
+ * 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 org.feathercore.protocol.netty.util;
+
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.ServerChannel;
+import io.netty.channel.epoll.Epoll;
+import io.netty.channel.epoll.EpollEventLoopGroup;
+import io.netty.channel.epoll.EpollServerSocketChannel;
+import io.netty.channel.epoll.EpollSocketChannel;
+import io.netty.channel.kqueue.KQueue;
+import io.netty.channel.kqueue.KQueueEventLoopGroup;
+import io.netty.channel.kqueue.KQueueServerSocketChannel;
+import io.netty.channel.kqueue.KQueueSocketChannel;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import lombok.*;
+import lombok.experimental.FieldDefaults;
+
+import java.util.concurrent.ThreadFactory;
+
+@Getter
+@RequiredArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+public enum DefaultTransportType implements TransportType {
+ EPOLL(EpollSocketChannel.class, EpollServerSocketChannel.class) {
+ @Override
+ public boolean isAvailable() {
+ return Epoll.isAvailable();
+ }
+
+ @Override
+ public EventLoopGroup newEventLoopGroup(final int threads, @NonNull final ThreadFactory threadFactory) {
+ return new EpollEventLoopGroup(threads, threadFactory);
+ }
+ },
+ KQUEUE(KQueueSocketChannel.class, KQueueServerSocketChannel.class) {
+ @Override
+ public boolean isAvailable() {
+ return KQueue.isAvailable();
+ }
+
+ @Override
+ public EventLoopGroup newEventLoopGroup(final int threads, @NonNull final ThreadFactory threadFactory) {
+ return new KQueueEventLoopGroup(threads, threadFactory);
+ }
+ },
+ NIO(NioSocketChannel.class, NioServerSocketChannel.class) {
+ @Override
+ public boolean isAvailable() {
+ return true;
+ }
+
+ @Override
+ public EventLoopGroup newEventLoopGroup(final int threads, @NonNull final ThreadFactory threadFactory) {
+ return new NioEventLoopGroup(threads, threadFactory);
+ }
+ };
+
+ Class socketChannelClass;
+ Class serverChannelClass;
+
+ public static TransportType getNative() {
+ for (val transportType : values()) {
+ if (transportType.isAvailable()) {
+ return transportType;
+ }
+ }
+
+ return getDefault();
+ }
+
+ public static TransportType getDefault() {
+ return NIO;
+ }
+}
diff --git a/protocol/src/main/java/org/feathercore/protocol/netty/util/SharedNettyResources.java b/protocol/src/main/java/org/feathercore/protocol/netty/util/SharedNettyResources.java
index 8093096..6620345 100644
--- a/protocol/src/main/java/org/feathercore/protocol/netty/util/SharedNettyResources.java
+++ b/protocol/src/main/java/org/feathercore/protocol/netty/util/SharedNettyResources.java
@@ -17,164 +17,32 @@
package org.feathercore.protocol.netty.util;
import io.netty.channel.EventLoopGroup;
-import io.netty.channel.ServerChannel;
-import io.netty.channel.socket.SocketChannel;
-import lombok.*;
-import lombok.experimental.FieldDefaults;
-import lombok.experimental.NonFinal;
-import org.feathercore.shared.util.NamedThreadFactory;
-import org.jetbrains.annotations.Nullable;
-
-import javax.annotation.Nonnegative;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.locks.ReadWriteLock;
-import java.util.function.Supplier;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static java.lang.Math.max;
+import org.jetbrains.annotations.NotNull;
/**
- * Created by k.shandurenko on 12/04/2019
+ * Holder of shared data used by Netty's basic elements.
*/
-@Value
-@Builder
-@FieldDefaults(level = AccessLevel.PROTECTED)
-@NonFinal
-public class SharedNettyResources {
-
- @NonNull protected final ReadWriteLock lock;
-
- boolean bossIsWorker;
- @Builder.Default boolean useNativeTransport = true;
- @Builder.Default @Nonnegative int bossThreads = 2, workerThreads = 0;
-
- @NonFinal @Nullable volatile EventLoopGroup bossLoopGroup, workerLoopGroup;
-
- @NonNull Supplier
- bossThreadFactorySupplier = () -> new NamedThreadFactory("Netty Boss Thread #", false),
- workerThreadFactorySupplier = () -> new NamedThreadFactory("Netty Worker Thread #", false);
+public interface SharedNettyResources {
- public boolean isInitialized() {
- lock.readLock().lock();
- try {
- return bossLoopGroup != null && workerLoopGroup != null;
- } finally {
- lock.readLock().unlock();
- }
- }
-
- @SneakyThrows(InterruptedException.class)
- public void shutdownLoopGroupsGracefully(final boolean await) {
- lock.readLock().lock();
- try {
- if (bossLoopGroup != null) {
- lock.writeLock().lock();
- try {
- if (await) {
- bossLoopGroup.shutdownGracefully().await();
- } else {
- bossLoopGroup.shutdownGracefully();
- }
-
- bossLoopGroup = null;
- } finally {
- lock.writeLock().unlock();
- }
- }
- if (workerLoopGroup != null) {
- lock.writeLock().lock();
- try {
- if (await) {
- workerLoopGroup.shutdownGracefully().await();
- }
- workerLoopGroup.shutdownGracefully();
+ boolean isInitialized();
- workerLoopGroup = null;
- } finally {
- lock.writeLock().unlock();
- }
- }
- } finally {
- lock.readLock().unlock();
- }
- }
+ boolean isShutDown();
- public void shutdownLoopGroupsGracefully() {
- shutdownLoopGroupsGracefully(false);
- }
+ @NotNull TransportType getTransportType();
- public EventLoopGroup getBossLoopGroup() {
- lock.readLock().lock();
- try {
- if (bossLoopGroup == null) {
- lock.writeLock().lock();
- try {
- bossLoopGroup = (useNativeTransport ? TransportType.getNative() : TransportType.getDefault())
- .newEventLoopGroup(bossThreads, bossThreadFactorySupplier.get());
- } finally {
- lock.writeLock().unlock();
- }
- }
+ @NotNull EventLoopGroup getBossLoopGroup();
- return bossLoopGroup;
- } finally {
- lock.readLock().unlock();
- }
- }
+ @NotNull EventLoopGroup getWorkerLoopGroup();
- public EventLoopGroup getWorkerLoopGroup() {
- lock.readLock().lock();
- try {
- if (workerLoopGroup == null) {
- lock.writeLock().lock();
- try {
- if (bossIsWorker) {
- workerLoopGroup = getWorkerLoopGroup();
- } else {
- workerLoopGroup = (useNativeTransport ? TransportType.getNative() : TransportType.getDefault())
- .newEventLoopGroup(max(1, workerThreads), workerThreadFactorySupplier.get());
- }
- } finally {
- lock.writeLock().unlock();
- }
- }
+ void shutdownLoopGroupsGracefully(final boolean await);
- return workerLoopGroup;
- } finally {
- lock.readLock().unlock();
- }
+ default void shutdownLoopGroupsGracefully() {
+ shutdownLoopGroupsGracefully(true);
}
- public Class getSocketChannelClass() {
- return (useNativeTransport ? TransportType.getNative() : TransportType.getDefault()).getSocketChannelClass();
- }
-
- public Class getServerChannelClass() {
- return (useNativeTransport ? TransportType.getNative() : TransportType.getDefault()).getServerChannelClass();
- }
-
- public static class SharedNettyResourcesBuilder {
-
- public SharedNettyResourcesBuilder bossThreads(@Nonnegative final int bossThreads) {
- checkArgument(bossThreads > 0, "There should be at least 1 boss thread");
-
- this.bossThreads = bossThreads;
-
- return this;
- }
-
- public SharedNettyResourcesBuilder workerThreads(@Nonnegative final int workerThreads) {
- checkArgument(workerThreads <= 0, "Number of worker threads cannot be negative");
-
- this.workerThreads = workerThreads;
-
- return this;
- }
-
- protected SharedNettyResourcesBuilder lock(@NonNull final ReadWriteLock lock) {
- this.lock = lock;
+ boolean tryShutdownLoopGroupsGracefully(final boolean await);
- return this;
- }
+ default boolean tryShutdownLoopGroupsGracefully() {
+ return tryShutdownLoopGroupsGracefully(true);
}
-}
\ No newline at end of file
+}
diff --git a/protocol/src/main/java/org/feathercore/protocol/netty/util/SimpleSharedNettyResources.java b/protocol/src/main/java/org/feathercore/protocol/netty/util/SimpleSharedNettyResources.java
new file mode 100644
index 0000000..1a9c01a
--- /dev/null
+++ b/protocol/src/main/java/org/feathercore/protocol/netty/util/SimpleSharedNettyResources.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2019 Feather Core
+ *
+ * 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 org.feathercore.protocol.netty.util;
+
+import io.netty.channel.EventLoopGroup;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.NonNull;
+import lombok.experimental.FieldDefaults;
+import lombok.experimental.NonFinal;
+import org.feathercore.shared.util.thread.ThreadFactories;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+@FieldDefaults(level = AccessLevel.PROTECTED, makeFinal = true)
+@NonFinal public class SimpleSharedNettyResources extends AbstractSharedNettyResources {
+
+ protected int bossThreads, workerThreads;
+
+ @Builder
+ public SimpleSharedNettyResources(@NonNull final TransportType transportType, final boolean bossIsWorker,
+ final int bossThreads, final int workerThreads) {
+ super(transportType, bossIsWorker);
+
+ checkArgument(bossThreads >= 0, "There should be at least 1 boss thread (or 0 for default)");
+ checkArgument(workerThreads >= 0, "There should be at least 1 worker thread (or 0 for default)");
+
+ this.bossThreads = bossThreads;
+ this.workerThreads = workerThreads;
+ }
+
+ public static SimpleSharedNettyResources createDefault() {
+ return SimpleSharedNettyResources.builder()
+ .transportType(DefaultTransportType.getNative())
+ .bossThreads(2)
+ .workerThreads(0)
+ .build();
+ }
+
+ @Override
+ protected EventLoopGroup newBossLoopGroup() {
+ return transportType.newEventLoopGroup(
+ bossThreads, ThreadFactories.createPaginated("Netty Worker Thread #", false)
+ );
+ }
+
+ @Override
+ protected EventLoopGroup newWorkerLoopGroup() {
+ return transportType.newEventLoopGroup(
+ workerThreads, ThreadFactories.createPaginated("Netty Worker Thread #", false)
+ );
+ }
+}
\ No newline at end of file
diff --git a/protocol/src/main/java/org/feathercore/protocol/netty/util/TransportType.java b/protocol/src/main/java/org/feathercore/protocol/netty/util/TransportType.java
index b2231ea..8a13336 100644
--- a/protocol/src/main/java/org/feathercore/protocol/netty/util/TransportType.java
+++ b/protocol/src/main/java/org/feathercore/protocol/netty/util/TransportType.java
@@ -18,81 +18,19 @@
import io.netty.channel.EventLoopGroup;
import io.netty.channel.ServerChannel;
-import io.netty.channel.epoll.Epoll;
-import io.netty.channel.epoll.EpollEventLoopGroup;
-import io.netty.channel.epoll.EpollServerSocketChannel;
-import io.netty.channel.epoll.EpollSocketChannel;
-import io.netty.channel.kqueue.KQueue;
-import io.netty.channel.kqueue.KQueueEventLoopGroup;
-import io.netty.channel.kqueue.KQueueServerSocketChannel;
-import io.netty.channel.kqueue.KQueueSocketChannel;
-import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
-import io.netty.channel.socket.nio.NioServerSocketChannel;
-import io.netty.channel.socket.nio.NioSocketChannel;
-import lombok.*;
-import lombok.experimental.FieldDefaults;
+import lombok.NonNull;
+import javax.annotation.Nonnegative;
import java.util.concurrent.ThreadFactory;
-@Getter
-@RequiredArgsConstructor
-@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
-public enum TransportType {
- EPOLL(EpollSocketChannel.class, EpollServerSocketChannel.class) {
- @Override
- public boolean isAvailable() {
- return Epoll.isAvailable();
- }
+public interface TransportType {
- @Override
- public EventLoopGroup newEventLoopGroup(final int threads, @NonNull final ThreadFactory threadFactory) {
- return new EpollEventLoopGroup(threads, threadFactory);
- }
- },
- KQUEUE(KQueueSocketChannel.class, KQueueServerSocketChannel.class) {
- @Override
- public boolean isAvailable() {
- return KQueue.isAvailable();
- }
+ boolean isAvailable();
- @Override
- public EventLoopGroup newEventLoopGroup(final int threads, @NonNull final ThreadFactory threadFactory) {
- return new KQueueEventLoopGroup(threads, threadFactory);
- }
- },
- NIO(NioSocketChannel.class, NioServerSocketChannel.class) {
- @Override
- public boolean isAvailable() {
- return true;
- }
+ EventLoopGroup newEventLoopGroup(@Nonnegative int threads, @NonNull ThreadFactory threadFactory);
- @Override
- public EventLoopGroup newEventLoopGroup(final int threads, @NonNull final ThreadFactory threadFactory) {
- return new NioEventLoopGroup(threads, threadFactory);
- }
- };
+ Class getSocketChannelClass();
- private static final TransportType[] TRANSPORT_TYPES = values();
-
- Class socketChannelClass;
- Class serverChannelClass;
-
- public abstract boolean isAvailable();
-
- public abstract EventLoopGroup newEventLoopGroup(int threads, @NonNull ThreadFactory threadFactory);
-
- public static TransportType getNative() {
- for (val transportType : TRANSPORT_TYPES) {
- if (transportType.isAvailable()) {
- return transportType;
- }
- }
-
- return getDefault();
- }
-
- public static TransportType getDefault() {
- return NIO;
- }
+ Class getServerChannelClass();
}
diff --git a/protocol/src/main/java/org/feathercore/protocol/packet/PacketType.java b/protocol/src/main/java/org/feathercore/protocol/packet/PacketType.java
index b7d0325..b765111 100644
--- a/protocol/src/main/java/org/feathercore/protocol/packet/PacketType.java
+++ b/protocol/src/main/java/org/feathercore/protocol/packet/PacketType.java
@@ -21,40 +21,121 @@
import lombok.Value;
import lombok.experimental.FieldDefaults;
import lombok.experimental.NonFinal;
+import lombok.val;
+import org.feathercore.protocol.annotation.PacketFactory;
+import org.feathercore.protocol.annotation.PacketId;
+import ru.progrm_jarvis.reflector.invoke.InvokeUtil;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Executable;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.Optional;
import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static com.google.common.base.Preconditions.checkArgument;
/**
* A value-class containing all data identifying packet type.
*
* @param type of packet
*/
-@Value
@NonFinal
+@Value(staticConstructor = "create")
@FieldDefaults(level = AccessLevel.PROTECTED, makeFinal = true)
public class PacketType
{
+ /**
+ * ID of the packet
+ */
int id;
- @NonNull Class
type;
- @NonNull Supplier
supplier;
-
- private PacketType(Class
type, Supplier
supplier) {
- try {
- this.id = type.getField("ID").getInt(null);
- } catch (IllegalAccessException | NoSuchFieldException e) {
- throw new RuntimeException(
- "Could not instantiate packet type, because there is not ID field in given packet class or it is "
- + "not accessible",
- e
+ /**
+ * Factory used for instantiation of packets
+ */
+ @NonNull Supplier
factory;
+
+ /**
+ * Creates a packet type from the given class using its meta-structure.
+ *
+ * This will look for constructors and methods annotated with {@link PacketFactory} which will be used as factories
+ * for the packets of given IDs.
+ *
+ * @param type class which should be analyzed to create packet type from it
+ * @param
type of the packet
+ * @return created packet type
+ *
+ * @throws IllegalArgumentException if the given class contains multiple methods annotated with {@link PacketFactory}
+ */
+ public static
PacketType
create(@NonNull final Class
type) {
+ {
+ @SuppressWarnings("unchecked") val optionalConstructor
+ = lookupPacketFactory(Arrays.stream((Constructor
[]) type.getDeclaredConstructors()));
+ if (optionalConstructor.isPresent()) {
+ val constructor = optionalConstructor.get();
+
+ return create(type, InvokeUtil.toSupplier(constructor));
+ }
+ }
+ {
+ val optionalMethod = lookupPacketFactory(
+ Arrays.stream(type.getDeclaredMethods())
+ .filter(method -> Modifier.isStatic(method.getModifiers()))
);
+ if (optionalMethod.isPresent()) {
+ val method = optionalMethod.get();
+
+ return create(type, InvokeUtil.toStaticSupplier(method));
+ }
}
- this.type = type;
- this.supplier = supplier;
+
+ throw new IllegalArgumentException(
+ "There should be a no-args method or constructor annotated with @PacketFactory"
+ );
}
+ /**
+ * Creates a packet-type for the given class or its sub-type using the given factory.
+ *
+ * This will try to use {@link PacketFactory} annotation on this class
+ * and {@link PacketId} on its static field or method to get the ID of the packet.
+ *
+ * @param type type of the packet whose type is being created
+ * @param factory factory to be used for instantiation of packets
+ * @param
exact type of packet
+ * @return created packet-type
+ */
public static
PacketType
create(@NonNull final Class
type,
- @NonNull final Supplier
supplier) {
- return new PacketType<>(type, supplier);
+ @NonNull final Supplier
factory) {
+ val packetIdAnnotation = type.getAnnotation(PacketId.class);
+ checkArgument(packetIdAnnotation != null, "Type should be annotated with @PacketId");
+
+ return create(packetIdAnnotation.value(), factory);
}
+ /**
+ * Finds an executable which may be used as a packet-type factory.
+ *
+ * @param possibleFactories array of elements some of which which may be packet factories
+ * @param exact type of passed executable
+ * @return {@link Optional} containing found factory (if there was only one found) or
+ * an empty one if there were no possible packet-factories in the given array
+ *
+ * @throws IllegalArgumentException if there is more than one possible packet-factory in the given array
+ */
+ private static Optional lookupPacketFactory(@NonNull final Stream possibleFactories) {
+ val factories = possibleFactories
+ .filter(possibleFactory -> possibleFactory.getParameterCount() == 0)
+ .filter(possibleFactory -> possibleFactory.isAnnotationPresent(PacketFactory.class))
+ .collect(Collectors.toList());
+
+ if (factories.isEmpty()) return Optional.empty();
+ checkArgument(
+ factories.size() == 1,
+ "There should only be one no-args method or constructor annotated with @PacketFactory"
+ );
+
+ return Optional.of(factories.get(0));
+ }
}
diff --git a/protocol/src/main/java/org/feathercore/protocol/registry/PacketRegistry.java b/protocol/src/main/java/org/feathercore/protocol/registry/PacketRegistry.java
index 45d6510..744b93f 100644
--- a/protocol/src/main/java/org/feathercore/protocol/registry/PacketRegistry.java
+++ b/protocol/src/main/java/org/feathercore/protocol/registry/PacketRegistry.java
@@ -54,7 +54,7 @@ public interface PacketRegistry {
default P createById(final int id) {
val type = getTypeById(id);
- return type == null ? null : type.getSupplier().get();
+ return type == null ? null : type.getFactory().get();
}
void handlePacket(@NotNull Connection connection, @NotNull Packet packet);
diff --git a/protocol/src/main/java/org/feathercore/protocol/registry/common/CommonHandshakePacketRegistry.java b/protocol/src/main/java/org/feathercore/protocol/registry/common/CommonHandshakePacketRegistry.java
index 4a95a96..f011417 100644
--- a/protocol/src/main/java/org/feathercore/protocol/registry/common/CommonHandshakePacketRegistry.java
+++ b/protocol/src/main/java/org/feathercore/protocol/registry/common/CommonHandshakePacketRegistry.java
@@ -32,6 +32,7 @@ public class CommonHandshakePacketRegistry {
@SuppressWarnings("unchecked")
public static PacketRegistry createNew() {
+ //noinspection RedundantCast this is a javac bug: cast is required
return ArrayBasedPacketRegistry.Builder.create()
.exceptionHandler((BiConsumer) (connection, throwable) ->
connection.disconnect())
diff --git a/protocol/src/main/java/org/feathercore/protocol/server/AbstractServer.java b/protocol/src/main/java/org/feathercore/protocol/server/AbstractServer.java
index f2c8d26..bc9944a 100644
--- a/protocol/src/main/java/org/feathercore/protocol/server/AbstractServer.java
+++ b/protocol/src/main/java/org/feathercore/protocol/server/AbstractServer.java
@@ -16,28 +16,56 @@
package org.feathercore.protocol.server;
+import lombok.AccessLevel;
+import lombok.Getter;
import lombok.NonNull;
-import org.feathercore.protocol.Connection;
-import org.feathercore.protocol.netty.NettyServer;
-import org.jetbrains.annotations.NotNull;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import lombok.experimental.NonFinal;
+import org.feathercore.protocol.packet.Packet;
+
+import java.net.SocketAddress;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicBoolean;
/**
- * Created by k.shandurenko on 16/04/2019
+ * Abstract base for a {@link Server implementation}.
+ *
+ * @param super-type of packets used by this server's protocol
*/
-public abstract class AbstractServer extends NettyServer {
+@RequiredArgsConstructor
+@FieldDefaults(level = AccessLevel.PROTECTED, makeFinal = true)
+public abstract class AbstractServer
implements Server
{
- public AbstractServer(final @NonNull String host, final int port) {
- super(host, port);
- }
+ @NonNull @Getter SocketAddress address;
+
+ @NonNull Object startStopMutex = new Object[0];
+ @NonNull @NonFinal volatile boolean running = false;
+
+ protected abstract Future performStart();
+
+ protected abstract Future performStop();
@Override
- public void onConnected(@NotNull final Connection connection) {
+ public Future start() {
+ synchronized (startStopMutex) {
+ if (running) throw new IllegalStateException("This server is already started");
+
+ running = true;
+ return performStart();
+ }
}
@Override
- public void onDisconnected(@NotNull final Connection connection) {
+ public Future stop() {
+ synchronized (startStopMutex) {
+ if (!running) throw new IllegalStateException("This server is not running");
- }
+ running = false;
+ return performStop();
+ }
+ }
}
diff --git a/protocol/src/main/java/org/feathercore/protocol/server/BaseServer.java b/protocol/src/main/java/org/feathercore/protocol/server/Server.java
similarity index 59%
rename from protocol/src/main/java/org/feathercore/protocol/server/BaseServer.java
rename to protocol/src/main/java/org/feathercore/protocol/server/Server.java
index 503f62b..009a76c 100644
--- a/protocol/src/main/java/org/feathercore/protocol/server/BaseServer.java
+++ b/protocol/src/main/java/org/feathercore/protocol/server/Server.java
@@ -16,35 +16,32 @@
package org.feathercore.protocol.server;
-import lombok.AccessLevel;
-import lombok.Getter;
import lombok.NonNull;
-import lombok.RequiredArgsConstructor;
import org.feathercore.protocol.Connection;
import org.feathercore.protocol.packet.Packet;
import org.feathercore.protocol.registry.PacketRegistry;
import org.jetbrains.annotations.NotNull;
+import java.net.SocketAddress;
+import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;
/**
- * Created by k.shandurenko on 16/04/2019
+ * Base for IO-server based on {@link PacketRegistry}.
+ *
+ * @param super-type of packets used by this server's protocol
*/
-@Getter
-@RequiredArgsConstructor(access = AccessLevel.PROTECTED)
-public abstract class BaseServer {
-
- @NonNull protected final String host;
- protected final int port;
+public interface Server
{
- public abstract Future start();
+ SocketAddress getAddress();
- public abstract Future stop();
+ Future start();
- public abstract void onConnected(@NotNull Connection connection);
+ Future stop();
- public abstract void onDisconnected(@NotNull Connection connection);
+ @NonNull PacketRegistry getPacketRegistry();
- public abstract @NonNull PacketRegistry getInitialPacketRegistry();
+ default void handleConnect(@NotNull final Connection connection) {}
+ default void handleDisconnect(@NotNull final Connection connection) {}
}
diff --git a/protocol/src/main/java/org/feathercore/protocol/server/CommonServer.java b/protocol/src/main/java/org/feathercore/protocol/server/SimpleMinecraftServer.java
similarity index 61%
rename from protocol/src/main/java/org/feathercore/protocol/server/CommonServer.java
rename to protocol/src/main/java/org/feathercore/protocol/server/SimpleMinecraftServer.java
index f0eb7e5..20cebaa 100644
--- a/protocol/src/main/java/org/feathercore/protocol/server/CommonServer.java
+++ b/protocol/src/main/java/org/feathercore/protocol/server/SimpleMinecraftServer.java
@@ -16,26 +16,26 @@
package org.feathercore.protocol.server;
+import lombok.Getter;
import lombok.NonNull;
import org.feathercore.protocol.minecraft.packet.MinecraftPacket;
-import org.feathercore.protocol.packet.Packet;
+import org.feathercore.protocol.netty.NettyServer;
+import org.feathercore.protocol.netty.util.SharedNettyResources;
import org.feathercore.protocol.registry.PacketRegistry;
import org.feathercore.protocol.registry.common.CommonHandshakePacketRegistry;
+import java.net.SocketAddress;
+
/**
* Created by k.shandurenko on 16/04/2019
*/
-public class CommonServer extends AbstractServer {
-
- private final PacketRegistry initialPacketRegistry = CommonHandshakePacketRegistry.createNew();
+@Deprecated
+public class SimpleMinecraftServer extends NettyServer {
- public CommonServer(final @NonNull String host, final int port) {
- super(host, port);
- }
+ @Getter private final PacketRegistry packetRegistry = CommonHandshakePacketRegistry.createNew();
- @Override
- public @NonNull PacketRegistry getInitialPacketRegistry() {
- return this.initialPacketRegistry;
+ public SimpleMinecraftServer(@NonNull final SocketAddress address,
+ @NonNull final SharedNettyResources sharedNettyResources) {
+ super(address, sharedNettyResources);
}
-
}
diff --git a/protocol/src/test/java/org/feathercore/protocol/packet/PacketTypeTest.java b/protocol/src/test/java/org/feathercore/protocol/packet/PacketTypeTest.java
new file mode 100644
index 0000000..078eb3d
--- /dev/null
+++ b/protocol/src/test/java/org/feathercore/protocol/packet/PacketTypeTest.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright 2019 Feather Core
+ *
+ * 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 org.feathercore.protocol.packet;
+
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.val;
+import lombok.var;
+import org.apache.commons.lang3.RandomUtils;
+import org.feathercore.protocol.annotation.PacketFactory;
+import org.feathercore.protocol.annotation.PacketId;
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class PacketTypeTest {
+
+ @Test
+ public void testCreateValidations() {
+ // test that there should be @PacketFactory
+ assertThrows(
+ IllegalArgumentException.class, () -> PacketType.create(PacketWithNoFactory.class)
+ );
+ // test that there should be only one @PacketFactory on static method
+ assertThrows(
+ IllegalArgumentException.class, () -> PacketType.create(PacketWithMultipleStaticMethodFactories.class)
+ );
+
+ }
+
+ @Test
+ public void testConstructorFactoryCreate() {
+ val packetType = PacketType.create(PacketWithConstructorFactory.class);
+
+ assertThat(packetType.getId(), is(PacketWithConstructorFactory.ID));
+
+ val attempts = RandomUtils.nextInt(8, 16 + 1);
+ for (var i = 0; i < attempts; i++) {
+ val instanceId = PacketWithConstructorFactory.nextInstanceTestId();
+ val packet = packetType.getFactory().get();
+ assertThat(packet, notNullValue());
+
+ assertThat(instanceId, is(packet.instanceId));
+ }
+ }
+
+ @Test
+ public void testStaticMethodFactoryCreate() {
+ val packetType = PacketType.create(PacketWithStaticMethodFactory.class);
+
+ assertThat(packetType.getId(), is(PacketWithStaticMethodFactory.ID));
+
+ val attempts = RandomUtils.nextInt(8, 16 + 1);
+ for (var i = 0; i < attempts; i++) {
+ val instanceId = PacketWithStaticMethodFactory.nextInstanceTestId();
+ val packet = packetType.getFactory().get();
+ assertThat(packet, notNullValue());
+
+ assertThat(instanceId, is(packet.instanceId));
+ }
+ }
+
+ @Test
+ public void testSupplierFactoryCreate() {
+ val instanceIdCounter = new AtomicInteger();
+ val packetType = PacketType.create(
+ PacketWithNoFactory.class, () -> new PacketWithNoFactory(instanceIdCounter.incrementAndGet())
+ );
+
+ assertThat(packetType.getId(), is(PacketWithNoFactory.ID));
+
+ val attempts = RandomUtils.nextInt(8, 16 + 1);
+ for (var i = 0; i < attempts; i++) {
+ val packet = packetType.getFactory().get();
+
+ assertThat(packet, notNullValue());
+ assertThat(packet.instanceId, is(instanceIdCounter.intValue()));
+ }
+ }
+
+ @RequiredArgsConstructor
+ @PacketId(PacketWithNoFactory.ID)
+ private static final class PacketWithNoFactory implements Packet {
+
+ private static final int ID = 0x10;
+
+ private final int instanceId;
+
+ @Override
+ public int getId() {
+ return ID;
+ }
+ }
+
+ @PacketId(PacketWithMultipleStaticMethodFactories.ID)
+ private static final class PacketWithMultipleStaticMethodFactories implements Packet {
+
+ private static final int ID = 0x20;
+
+ @Override
+ public int getId() {
+ return ID;
+ }
+
+ @PacketFactory
+ public static PacketWithMultipleStaticMethodFactories create1() {
+ return new PacketWithMultipleStaticMethodFactories();
+ }
+
+ @PacketFactory
+ public static PacketWithMultipleStaticMethodFactories create2() {
+ return new PacketWithMultipleStaticMethodFactories();
+ }
+ }
+
+ @PacketId(PacketWithConstructorFactory.ID)
+ @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+ public static final class PacketWithConstructorFactory implements Packet {
+
+ private static final ThreadLocal PACKET_TEST_ID_COUNTER = new ThreadLocal<>();
+ private static final int ID = 0x50;
+
+ private final int instanceId;
+
+ private static AtomicInteger instanceIdCounter() {
+ var counter = PACKET_TEST_ID_COUNTER.get();
+ if (counter == null) {
+ counter = new AtomicInteger();
+ PACKET_TEST_ID_COUNTER.set(counter);
+ }
+
+ return counter;
+ }
+
+ public static int nextInstanceTestId() {
+ return instanceIdCounter().intValue();
+ }
+
+ @PacketFactory
+ public PacketWithConstructorFactory() {
+ instanceId = instanceIdCounter().getAndIncrement();
+ }
+
+ @Override
+ public int getId() {
+ return ID;
+ }
+ }
+
+ @PacketId(PacketWithStaticMethodFactory.ID)
+ @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+ public static final class PacketWithStaticMethodFactory implements Packet {
+
+ private static final ThreadLocal PACKET_TEST_ID_COUNTER = new ThreadLocal<>();
+ private static final int ID = 0x60;
+
+ private final int instanceId;
+
+ private static AtomicInteger testIdCounter() {
+ var counter = PACKET_TEST_ID_COUNTER.get();
+ if (counter == null) {
+ counter = new AtomicInteger();
+ PACKET_TEST_ID_COUNTER.set(counter);
+ }
+
+ return counter;
+ }
+
+ public static int nextInstanceTestId() {
+ return testIdCounter().intValue();
+ }
+
+ @PacketFactory
+ public static PacketWithStaticMethodFactory create() {
+ return new PacketWithStaticMethodFactory(testIdCounter().getAndIncrement());
+ }
+
+ @Override
+ public int getId() {
+ return ID;
+ }
+ }
+}
\ No newline at end of file
diff --git a/server/pom.xml b/server/pom.xml
new file mode 100644
index 0000000..726661b
--- /dev/null
+++ b/server/pom.xml
@@ -0,0 +1,47 @@
+
+
+
+ 4.0.0
+
+ feather-core
+ org.feathercore
+ 1.0.0-SNAPSHOT
+
+
+ feathercore-server
+
+
+
+ ${project.parent.groupId}
+ feathercore-protocol
+
+
+ ${project.parent.groupId}
+ feathercore-module-api
+
+
+
+ org.projectlombok
+ lombok
+
+
+ org.jetbrains
+ annotations
+
+
+
\ No newline at end of file
diff --git a/server/src/main/java/AbstractFeatherServer.java b/server/src/main/java/AbstractFeatherServer.java
new file mode 100644
index 0000000..bafa873
--- /dev/null
+++ b/server/src/main/java/AbstractFeatherServer.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2019 Feather Core
+ *
+ * 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.
+ */
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import lombok.extern.log4j.Log4j2;
+import org.feathercore.protocol.packet.Packet;
+import org.feathercore.protocol.server.Server;
+import ru.feathercore.moduleapi.Module;
+import ru.feathercore.moduleapi.ModuleLoader;
+
+import javax.annotation.OverridingMethodsMustInvokeSuper;
+import java.util.concurrent.ExecutionException;
+
+/**
+ * Base for a regular feather-server implementation.
+ *
+ * @param super-type of packets used by the server's protocol
+ * @param super-type of modules which this server is able to load
+ */
+@Log4j2
+@RequiredArgsConstructor
+@FieldDefaults(level = AccessLevel.PROTECTED, makeFinal = true)
+public abstract class AbstractFeatherServer implements FeatherServer {
+
+ /**
+ * IO-server used by this feather-server
+ */
+ @NonNull @Getter Server ioServer;
+ /**
+ * Module-loader used by this server
+ */
+ @NonNull @Getter ModuleLoader moduleLoader;
+
+ @Override
+ @OverridingMethodsMustInvokeSuper
+ public void start() {
+ try {
+ ioServer.start().get();
+ } catch (final InterruptedException | ExecutionException e) {
+ log.error("An exception occurred while starting the IO-server", e);
+ }
+ }
+
+ @Override
+ @OverridingMethodsMustInvokeSuper
+ public void close() {
+ try {
+ moduleLoader.unloadAllModules();
+ } catch (final Throwable e) {
+ log.error("An exception occurred while unloading modules", e);
+ }
+ try {
+ ioServer.stop().get();
+ } catch (final Throwable e) {
+ log.error("An exception occurred while stopping the IO-server", e);
+ }
+ }
+}
diff --git a/server/src/main/java/FeatherServer.java b/server/src/main/java/FeatherServer.java
new file mode 100644
index 0000000..c5439cf
--- /dev/null
+++ b/server/src/main/java/FeatherServer.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2019 Feather Core
+ *
+ * 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.
+ */
+
+import org.feathercore.protocol.packet.Packet;
+import org.feathercore.protocol.server.Server;
+import ru.feathercore.moduleapi.Module;
+import ru.feathercore.moduleapi.ModuleLoader;
+
+/**
+ * feather-core server, core component of the whole project.
+ *
+ * @param super-type of packets used by the server's protocol
+ * @param super-type of modules which this server is able to load
+ */
+public interface FeatherServer extends AutoCloseable {
+
+ /**
+ * Gets the IO-server used by this feather-server.
+ *
+ * @return IO-server used by this feather-server
+ */
+ Server
getIoServer();
+
+ /**
+ * Gets the module-loader of this feather-server.
+ *
+ * @return module-loader of this feather-server
+ */
+ ModuleLoader getModuleLoader();
+
+ /**
+ * Starts this feather-server.
+ */
+ void start();
+
+ /**
+ * Shuts down this feather-server.
+ */
+ @Override
+ void close();
+}
diff --git a/server/src/main/java/SimpleMinecraftFeatherServer.java b/server/src/main/java/SimpleMinecraftFeatherServer.java
new file mode 100644
index 0000000..209787a
--- /dev/null
+++ b/server/src/main/java/SimpleMinecraftFeatherServer.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2019 Feather Core
+ *
+ * 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.
+ */
+
+import lombok.NonNull;
+import org.feathercore.protocol.minecraft.packet.MinecraftPacket;
+import org.feathercore.protocol.netty.util.SimpleSharedNettyResources;
+import org.feathercore.protocol.server.SimpleMinecraftServer;
+import ru.feathercore.moduleapi.Module;
+import ru.feathercore.moduleapi.SimpleModuleLoader;
+
+import java.net.SocketAddress;
+
+/**
+ * Simple feather-server for standard minecraft protocol.
+ *
+ * @param super-type of modules which this server is able to load
+ */
+public class SimpleMinecraftFeatherServer extends AbstractFeatherServer {
+
+ /**
+ * Creates new feather-server for standard minecraft protocol
+ *
+ * @param address address of this server used by IO-server
+ */
+ public SimpleMinecraftFeatherServer(@NonNull final SocketAddress address) {
+ super(
+ new SimpleMinecraftServer(address, SimpleSharedNettyResources.createDefault()),
+ SimpleModuleLoader.createConcurrent()
+ );
+ }
+}
diff --git a/shared/pom.xml b/shared/pom.xml
index 155b851..7993e47 100644
--- a/shared/pom.xml
+++ b/shared/pom.xml
@@ -26,6 +26,16 @@
feathercore-shared
+
+ ru.progrm-jarvis
+ java-commons
+
+
+
+ com.google.guava
+ guava
+
+
com.google.code.gson
gson
@@ -40,5 +50,14 @@
org.jetbrains
annotations
+
+
+ org.junit.jupiter
+ junit-jupiter-api
+
+
+ org.hamcrest
+ hamcrest-all
+
\ No newline at end of file
diff --git a/shared/src/main/java/org/feathercore/shared/object/ValueContainer.java b/shared/src/main/java/org/feathercore/shared/object/ValueContainer.java
deleted file mode 100644
index 454a99e..0000000
--- a/shared/src/main/java/org/feathercore/shared/object/ValueContainer.java
+++ /dev/null
@@ -1,229 +0,0 @@
-/*
- * Copyright 2019 Feather Core
- *
- * 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 org.feathercore.shared.object;
-
-import lombok.*;
-import lombok.experimental.Delegate;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.function.Supplier;
-
-/**
- * A value which may be present (which includes {@link null}) or not-present.
- *
- * This differs from {@link java.util.Optional} as presence of a {@link null} value
- * does not make this value container empty.
- */
-public interface ValueContainer extends Supplier {
-
- /**
- * Gets a value container being empty.
- *
- * @param type of value container
- * @return empty value container
- */
- @SuppressWarnings("unchecked")
- static ValueContainer empty() {
- return (ValueContainer) Empty.INSTANCE;
- }
-
- /**
- * Gets a non-empty value container containing {@link null}.
- *
- * @param type of value container
- * @return value container containing {@link null}
- */
- @SuppressWarnings("unchecked")
- static ValueContainer ofNull() {
- return (ValueContainer) OfNull.INSTANCE;
- }
-
- /**
- * Gets a non-empty value container containing the specified value.
- *
- * @param type of value container
- * @return non-empty value container containing the specified value
- */
- @SuppressWarnings("unchecked")
- static ValueContainer of(@Nullable final T value) {
- return value == null ? (ValueContainer) OfNull.INSTANCE : new Containing<>(value);
- }
-
- /**
- * Gets a value container containing the specified value or an empty one if the values is {@link null}.
- *
- * @param type of value container
- * @return non-empty value container containing the specified value
- * if it is not {@link null} and an empty one otherwise
- */
- @SuppressWarnings("unchecked")
- static ValueContainer nonnullOrEmpty(@Nullable final T value) {
- return value == null ? (ValueContainer) Empty.INSTANCE : new Containing<>(value);
- }
-
- /**
- * {@inheritDoc}
- *
- * @return {@inheritDoc}
- * @throws EmptyValueException if this value container is empty
- */
- @Override
- T get() throws EmptyValueException;
-
- /**
- * Checks whether the object is present ot not.
- *
- * @return {@link true} if the value is present (might be {@link null}) and {@link false} otherwise
- */
- boolean isPresent();
-
- /**
- * Gets the value if it is present otherwise using the specified one.
- *
- * @param value value to use if this value container is empty
- * @return this value container's value if it is not empty or the specified value otherwise
- */
- @Nullable default T orElse(@Nullable final T value) {
- return isPresent() ? get() : value;
- }
-
- /**
- * Gets the value if it is present otherwise using the one got from the specified supplier.
- *
- * @param valueSupplier supplier to be used for getting the value if this value container is empty
- * @return this value container's value if it is not empty or the one got from the supplier otherwise
- */
- @Nullable default T orElseGet(@NonNull final Supplier valueSupplier) {
- return isPresent() ? get() : valueSupplier.get();
- }
-
- /**
- * Gets the value if it is present otherwise throwing an exception.
- *
- * @param exceptionSupplier supplier to be used for getting the exception if this value container is empty
- * @param type of an exception thrown if this value container is empty
- * @return this value container's value if it is not empty
- * @throws X if this value container is empty
- */
- @Nullable default T orElseThrow(@NonNull final Supplier<@NotNull X> exceptionSupplier)
- throws X {
- if (isPresent()) {
- return get();
- }
-
- throw exceptionSupplier.get();
- }
-
- // use default equals and hashCode
- @NoArgsConstructor(access = AccessLevel.PRIVATE)
- final class Empty implements ValueContainer {
-
- private static final Empty INSTANCE = new Empty<>();
-
- @Override
- public T get() throws EmptyValueException {
- throw new EmptyValueException("There is no value associated with this value container");
- }
-
- @Override
- public boolean isPresent() {
- return false;
- }
-
- @Override
- public String toString() {
- return "Empty ValueContainer";
- }
- }
-
- // use default equals and hashCode
- @NoArgsConstructor(access = AccessLevel.PRIVATE)
- final class OfNull implements ValueContainer {
-
- private static final OfNull INSTANCE = new OfNull<>();
-
- @Override
- public T get() throws EmptyValueException {
- return null;
- }
-
- @Override
- public boolean isPresent() {
- return true;
- }
-
- @Override
- public String toString() {
- return "ValueContainer{null}";
- }
- }
-
- @Value
- @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
- class Containing implements ValueContainer {
-
- @NonNull private final T value;
-
- @Override
- public T get() throws EmptyValueException {
- return value;
- }
-
- @Override
- public boolean isPresent() {
- return true;
- }
- }
-
- @Value
- @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
- class Supplying implements ValueContainer {
-
- @NonNull @Delegate private final Supplier valueSupplier;
-
- @Override
- public boolean isPresent() {
- return true;
- }
- }
-
- /**
- * An exception thrown whenever {@link #get()} is called on an empty value container.
- */
- @NoArgsConstructor
- class EmptyValueException extends RuntimeException {
- //
- public EmptyValueException(final String message) {
- super(message);
- }
-
- public EmptyValueException(final String message, final Throwable cause) {
- super(message, cause);
- }
-
- public EmptyValueException(final Throwable cause) {
- super(cause);
- }
-
- public EmptyValueException(final String message, final Throwable cause, final boolean enableSuppression,
- final boolean writableStackTrace) {
- super(message, cause, enableSuppression, writableStackTrace);
- }
- //
- }
-}
diff --git a/shared/src/main/java/org/feathercore/shared/util/NamedThreadFactory.java b/shared/src/main/java/org/feathercore/shared/util/NamedThreadFactory.java
deleted file mode 100644
index acb3be4..0000000
--- a/shared/src/main/java/org/feathercore/shared/util/NamedThreadFactory.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright 2019 Feather Core
- *
- * 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 org.feathercore.shared.util;
-
-import lombok.*;
-import lombok.experimental.FieldDefaults;
-
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.atomic.AtomicInteger;
-
-/**
- * Created by k.shandurenko on 12/04/2019
- */
-@ToString
-@EqualsAndHashCode
-@RequiredArgsConstructor
-@FieldDefaults(level = AccessLevel.PROTECTED, makeFinal = true)
-public class NamedThreadFactory implements ThreadFactory {
-
- @NonNull String name;
- boolean daemon;
- @NonNull AtomicInteger counter = new AtomicInteger(1);
-
- @Override
- public Thread newThread(@NonNull final Runnable runnable) {
- val thread = new Thread(runnable);
- thread.setDaemon(daemon);
- thread.setName(name + counter.getAndIncrement());
-
- return thread;
- }
-}
\ No newline at end of file
diff --git a/shared/src/main/java/org/feathercore/shared/util/thread/ThreadFactories.java b/shared/src/main/java/org/feathercore/shared/util/thread/ThreadFactories.java
new file mode 100644
index 0000000..3fa7f9f
--- /dev/null
+++ b/shared/src/main/java/org/feathercore/shared/util/thread/ThreadFactories.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2019 Feather Core
+ *
+ * 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 org.feathercore.shared.util.thread;
+
+import lombok.NonNull;
+import lombok.experimental.UtilityClass;
+import lombok.val;
+
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Utility-methods used for creation of typical {@link ThreadFactory thread factories}.
+ *
+ * @author Dimasik
+ * @author PROgrammer_JARvis
+ */
+@UtilityClass
+public class ThreadFactories {
+
+ /**
+ * Creates a {@link ThreadFactory thread factory} which picks names of created threads using a counter.
+ *
+ * @param prefix prefix of the thread name
+ * @param suffix suffix of the thread name
+ * @param daemon daemon-flag of the thread
+ * @return created thread factory
+ *
+ * @see #createPaginated(String, boolean) simpler alternative
+ */
+ public ThreadFactory createPaginated(@NonNull final String prefix,
+ @NonNull final String suffix,
+ @NonNull final boolean daemon) {
+ // intialized here so that it gets captured by lambda
+ val counter = new AtomicInteger();
+
+ return (runnable) -> {
+ val thread = new Thread(runnable);
+ thread.setDaemon(daemon);
+ thread.setName(prefix + counter.getAndIncrement() + suffix);
+
+ return thread;
+ };
+ }
+
+ /**
+ * Creates a {@link ThreadFactory thread factory} which picks names of created threads using a counter.
+ *
+ * @param prefix prefix of the thread name
+ * @param daemon daemon-flag of the thread
+ * @return created thread factory
+ *
+ * @see #createPaginated(String, String, boolean) alternative method with richer naming control
+ */
+ public ThreadFactory createPaginated(@NonNull final String prefix,
+ @NonNull final boolean daemon) {
+ return createPaginated(prefix, "", daemon);
+ }
+}