Scheduling variants
===================

MoreBalance is able to use several algorithms in order to select the cluster
node for an incoming connection.

Algorithms:

Round robin scheduling:
	This is the most easy ones. The nodes are taken one by one, without any
	ability to influence the choices.

Traffic-based ports-separated scheduling:
	For each service (port), the network traffic is summed up so that nodes
	which had to handle large portions of data will get a lower priority.

Traffic-based ports-combined scheduling:
	If a node can't handle much traffic on either service, the sum of what it
	has to handle will be used for the priority calculation.

Explicit priorities:
	In case a node should get fewer connections at all, a priority factor can
	be used which applies to all other priority calculations for it.

Overrides:

Pattern matching:
	If a conversation starts with a special pattern, this can be used to
	determine the route of the connection.

Client-based selection:
	Once a client had a connection to a certain host, this host can be
	configured to be used for successive connections.

High availability:
	If a host is down or unreachable, it is excluded from the hosts to be
	considered for the outbound connection.

Connection types:

Connected mode (TCP):
	In this case, a separate connection to the target server is opened
	and all traffic is redirected between this connection and the original
	one from the client to MoreBalance.

Connectionless mode (UDP):
	Since connections do not exist, each datagram needs to include its
	origin data. This is then used to send answers to the sending
	hosts. Furthermore, receiving messages requires opening a port to
	the external world, which by convention is one above the sending port.

		TCP normal:

		client <-----> server/node

		TCP balanced:

		client <-----> morebalance <-----> server/node

		UDP normal:

		client   ---->
			   <----   server/node

		UDP balanced:

		client   ---->
			   <----   morebalance   ---->
								   <----   server/node

		UDP forwarding is not possible with fixed ports!
		As a convention, sending back datagrams happens to the port
		above the origin port. Also, the destination port is then
		locked for further services.