d3adspace / skylla

Powerful and robust packet event driven network framework built on top of netty and nio that offers rapid custom binary protocol development.

skylla

A simple network framework based on packet events. First taken as a PROC we decided to publish this and develop some more features in the future in order to provider a lightweight but powerful framework for little network applications that want to outsource their network handling parts.

Skylla uses constrictor networking utils.

Installation / Usage

Build from Source

• Install Maven
• Clone this repo
• Instal: mvn clean install

Maven Repository

Maven dependencies

Repositories:

<repositories>
  <!-- Klauke Enterprises Releases -->
  <repository>
    <id>klauke-enterprises-maven-releases</id>
    <name>Klauke Enterprises Maven Releases</name>
    <url>https://repository.klauke-enterprises.com/repository/maven-releases/</url>
  </repository>
</repositories>

Dependencies:

<dependency>
  <groupId>de.d3adspace.skylla</groupId>
  <artifactId>skylla-client</artifactId>
  <version>4.0.0</version>
  <scope>compile</scope>
</dependency>

<dependency>
  <groupId>de.d3adspace.skylla</groupId>
  <artifactId>skylla-server</artifactId>
  <version>4.0.0</version>
  <scope>compile</scope>
</dependency>

Example

Server and Client instantiation

public class ServerExample {
  public static void main(String[] args) {
    
    // The shared protocol
    Protocol protocol = Protocol.newBuilder()
      .withPacket(ChatPacket.class)
      .build();
    
    
    // Server
    ExampleServerListener exampleServerListener = ExampleServerListener.create();
    SkyllaServer server = NettySkyllaServer.newBuilder()
      .withServerHost("localhost")
      .withServerPort(8080)
      .withProtocol(protocol)
      .withListener(exampleServerListener)
      .build();

    server.start();

    // Client
    ExampleClientListener exampleClientListener = ExampleClientListener.create();
    SkyllaClient client = NettySkyllaClient.newBuilder()
      .withServerHost("localhost")
      .withServerPort(8080)
      .withProtocol(protocol)
      .withListener(exampleClientListener)
      .build();

    client.connect();
      
    ChatPacket chatPacket = ChatPacket.of("Client", "Hey Server!");
    client.sendPacket(chatPacket);
  }
  
  public static final class ExampleClientListener {
    private static final FluentLogger logger = FluentLogger.forEnclosingClass();
  
    private ExampleClientListener() {
    }

    private ExampleClientListener create() {
      return new ExampleClientListener();
    }   

    @PacketListener
    public void onChatPacket(PacketContext packetContext, ChatPacket chatPacket) {
      logger.atInfo().log("%s: %s", chatPacket.getName(), chatPacket.getMessage());
    }
  }

  public static final class ExampleServerListener {
    private static final FluentLogger logger = FluentLogger.forEnclosingClass();
  
    private ExampleServerListener() {
    }

    private ExampleServerListener create() {
      return new ExampleServerListener();
    }   

    @PacketListener
    public void onChatPacket(PacketContext packetContext, ChatPacket chatPacket) {
      ChatPacket answer = ChatPacket.of("Server", "Hey Client!");
      packetContext.resume(answer);
    }
  }
}

Packet definition

@PacketMeta(id = 1)
public final class ChatPacket implements Packet {
  private String name;
  private String message;

  public ChatPacket() {
  }

  private ChatPacket(String name, String message) {
    this.name = name;
    this.message = message;
  }

  public static ChatPacket of(String name, String message) {
    Preconditions.checkNotNull(name);
    Preconditions.checkNotNull(message);

    return new ChatPacket(name, message);
  }

  @Override
  public void read(SkyllaBuffer buffer) {
    name = buffer.readString();
    message = buffer.readString();
  }

  @Override
  public void write(SkyllaBuffer buffer) {
    buffer.writeString(name);
    buffer.writeString(message);
  }

  public String getMessage() {
    return message;
  }

  public String getName() {
    return name;
  }
}

skylla's Issues

Migrate to gradle

Client kann nicht über externe IP verbinden

Hey, ich wollte fragen, ob es gewollt ist, dass der Client nicht über die externe IP vom Server verbinden kann?