Class ProxyClient

java.lang.Object
arc.net.Connection
arc.net.Client
com.xpdustry.claj.api.net.ProxyClient
All Implemented Interfaces:
arc.net.EndPoint, Runnable
Direct Known Subclasses:
ClajProxy
public abstract class ProxyClient extends arc.net.Client
A client that act like a server. Discovery is not supported for now (i don't have the use).
The proxy doesn't do all the job:
- Packet reception must be done manually.
- Notifying methods must be called (conConnected(int, long), conDisconnected(int, DcReason), conReceived(int, Object) and conIdle(int)).
- Packet making methods must be defined (makeConWrapPacket(int, Object, boolean) and makeConClosePacket(int, DcReason)).

  • Field Details

    • defaultTimeout

      public static int defaultTimeout

    • pingTime

      public static int pingTime
      Delay between pings.

    • connectTimeout

      protected int connectTimeout

    • connectHost

      protected InetAddress connectHost

    • connectTcpPort

      protected int connectTcpPort

    • connectUdpPort

      protected int connectUdpPort

    • connectionsMap

      protected final arc.struct.IntMap<VirtualConnection> connectionsMap

    • connections

      protected final arc.struct.Seq<VirtualConnection> connections

    • conListener

      protected arc.net.NetListener conListener

    • shutdown

      protected volatile boolean shutdown

    • starting

      protected volatile boolean starting

    • connecting

      protected volatile boolean connecting

    • closing

      protected volatile boolean closing

    • receiver

      protected com.xpdustry.claj.common.net.ClientReceiver receiver

    • lastPing

      protected long lastPing

    • errorHandler

      protected arc.func.Cons<Throwable> errorHandler

    • writeBufferThreshold

      protected int writeBufferThreshold
      Packet queue to avoid a buffer overflow.

    • forceTcp

      public boolean forceTcp
      Whether to force using the tcp connection when sending trough udp to the server.
      The server will then send it via udp to the real client.
      This can fix some udp packet loss issues, at the cost of increased tcp band for things initially designed to be less important.

    • broadcastSupported

      public boolean broadcastSupported
      As packet broadcasting is not a protocol breaking change, some servers may not support it.
      Server version should be checked and this field set to false if not supported.
      This field is reset before connecting and after closing the proxy.

  • Constructor Details

    • ProxyClient

      public ProxyClient(int writeBufferSize, int objectBufferSize, arc.net.NetSerializer serialization)

  • Method Details

    • connect

      public void connect(String host, int port) throws IOException
      Connect used defaultTimeout and same port for TCP and UDP.
      This also ensures that the client is running before connection.
      Throws:
      IOException

    • connect

      public void connect(int timeout, InetAddress host, int tcpPort, int udpPort) throws IOException
      Overrides:
      connect in class arc.net.Client
      Throws:
      IOException

    • update

      public void update(int timeout) throws IOException
      Specified by:
      update in interface arc.net.EndPoint
      Overrides:
      update in class arc.net.Client
      Throws:
      IOException

    • updateIdle

      public void updateIdle()
      Tries to mimic connection idling.

    • updatePing

      public void updatePing()

    • run

      public void run()
      Specified by:
      run in interface arc.net.EndPoint
      Specified by:
      run in interface Runnable
      Overrides:
      run in class arc.net.Client

    • start

      public void start()
      Specified by:
      start in interface arc.net.EndPoint
      Overrides:
      start in class arc.net.Client

    • stop

      public void stop()
      Specified by:
      stop in interface arc.net.EndPoint
      Overrides:
      stop in class arc.net.Client

    • isRunning

      public boolean isRunning()

    • isConnecting

      public boolean isConnecting()

    • close

      public void close(arc.net.DcReason reason)
      Overrides:
      close in class arc.net.Connection

    • closeAllConnections

      public void closeAllConnections(arc.net.DcReason reason)

    • addConnection

      protected void addConnection(VirtualConnection con)

    • removeConnection

      protected void removeConnection(VirtualConnection con)

    • clearConnections

      protected void clearConnections()

    • getConnection

      public VirtualConnection getConnection(int id)

    • getInternalConnections

      protected arc.struct.Seq<VirtualConnection> getInternalConnections()

    • getConnections

      public Iterable<VirtualConnection> getConnections()

    • eachConnections

      public void eachConnections(arc.func.Cons<VirtualConnection> consumer)

    • broadcast

      public int broadcast(Object object, boolean tcp)
      Send an object to every clients connected to the room.
      This is an optimization method to avoid the host from sending the same packet to every virtual clients, as the server will do it to the real ones instead. So, using this will save bandwidth.

    • broadcastImpl

      protected int broadcastImpl(Object object, boolean tcp)
      Doesn't checks for availability.

    • send

      public int send(Object object)

    • send

      public int send(Object object, boolean tcp)

    • send

      public int send(VirtualConnection con, Object object, boolean tcp)

    • close

      protected void close(int conId, arc.net.DcReason reason)
      Can be used notify the server to close the connection when not created by the proxy.
      This will not trigger callbacks.

    • close

      public void close(VirtualConnection con, arc.net.DcReason reason)

    • closeQuietly

      public void closeQuietly(VirtualConnection con, arc.net.DcReason reason)
      Close connection without notify the server.

    • conConnected

      protected VirtualConnection conConnected(int conId, long addressHash)
      Returns:
      never null.

    • conDisconnected

      protected VirtualConnection conDisconnected(int conId, arc.net.DcReason reason)

    • conReceived

      protected VirtualConnection conReceived(int conId, Object object)

    • conIdle

      protected VirtualConnection conIdle(int conId)

    • makeBroadcastWrapPacket

      protected abstract Object makeBroadcastWrapPacket(Object object, boolean tcp)

    • makeBroadcastClosePacket

      protected abstract Object makeBroadcastClosePacket(arc.net.DcReason reason)

    • makeConWrapPacket

      protected abstract Object makeConWrapPacket(int conId, Object object, boolean tcp)

    • makeConClosePacket

      protected abstract Object makeConClosePacket(int conId, arc.net.DcReason reason)

    • sendTCP

      public int sendTCP(Object object)
      Because all VirtualConnections shares the same tcp buffer, it can be filled quickly.
      This will slow down sends when the write buffer reaches a threshold.
      Overrides:
      sendTCP in class arc.net.Connection