public ProxyAsync(IProxyConnection proxyConnection, Uri url)
{
this.asyncinterval = ProxySettings.GetAsyncInterval();
this.timeout = ProxySettings.GetTimeout();
this.pc = proxyConnection;
this.cancelTokenSrc = new CancellationTokenSource();
this.url = url;
}
/// <summary>
/// Prunes the collections list and initializes new connections
/// </summary>
private void PruneConnections(object state)
{
try
{
if (!_listening)
{
return;
}
Queue <IProxyConnection> connectionsToStart = new Queue <IProxyConnection>();
lock (_lockConnections)
{
IProxyConnection conn;
int counter = 0;
//first clear dead connections
while (counter < _connections.Count)
{
conn = _connections.Dequeue();
if (conn.Closed && _connections.Count >= _connectionLimit)
{
//call connection stop just in case we have a lingering thread
//this should set the _stop flag to true and end any async operations
conn.Stop();
}
else //if the connection is not closed put it back at the end of the queue
{
_connections.Enqueue(conn);
counter++; //update the counter to show this connection was processed
}
}
//if the number is still high clear connections that are not busy
//find connections that idle and drop them starting with the oldest in the list
counter = 0;
while (_connections.Count >= _connectionLimit && counter < _connections.Count)
{
conn = _connections.Dequeue();
if (!conn.IsBusy)
{
conn.Stop();
HttpServerConsole.Instance.WriteLine(LogMessageType.Warning,
"Max clients exceeded. Idle connection was dropped");
}
else
{
//put the connection back to the end of the queue
_connections.Enqueue(conn);
counter++;
}
}
//lastly if the number is still high forcefully kill the oldest connections until we get below the limit
//this should be a rare situation and something may be wrong with the connection, a very slow client
while (_connections.Count >= _connectionLimit)
{
conn = _connections.Dequeue();
conn.Stop();
HttpServerConsole.Instance.WriteLine(LogMessageType.Error,
"Max clients exceeded. Older connections were dropped");
}
//now that we ensured there's room dequeue any pending connections and start them
while (_connections.Count < _connectionLimit && _clientQueue.Count > 0)
{
TcpClientInfo clientInfo = _clientQueue.Dequeue();
if (clientInfo.Client.Connected)
{
// Create the new connection
conn = GetConnection(clientInfo);
// Add the connection to list of connections
_connections.Enqueue(conn);
//adding the connection to a separate collection in order to
//start it outside the lock
connectionsToStart.Enqueue(conn);
}
}
} //end critical section
//start connections
while (connectionsToStart.Count > 0 && _listening)
{
IProxyConnection conn = connectionsToStart.Dequeue();
conn.Start();
}
}
catch (Exception ex)
{
SdkSettings.Instance.Logger.Log(TraceLevel.Error, "BaseProxy.PruneConnections: Caught exception: {0}", ex.ToString());
}
}
public bool TryRemoveConnection(IProxyConnection connection)
{
Tuple<int, int> result;
return EntityIDMapping.TryRemove(connection, out result);
}
/// <summary>
/// Get the minecraft protocol server of a given minecraft server.
/// </summary>
/// <param name="proxyConnection"> The connection this server relates to. </param>
/// <param name="serverEndPoint"> The current version of the Remote server info. </param>
public void GetServerVersion(IProxyConnection proxyConnection, RemoteServerInfo serverEndPoint)
{
var args = new PluginResultEventArgs<RemoteServerInfo>(serverEndPoint, proxyConnection);
PluginManager.TriggerPlugin.GetServerVersion(args);
args.EnsureSuccess ();
if (serverEndPoint.MinecraftVersion == 0)
{
//Look up configuration
ProxyConfigurationSection settings = ProxyConfigurationSection.Settings;
IEnumerable<ServerElement> serverList =
settings.Server.OfType<ServerElement> ().Where(
m => m.EndPoint == serverEndPoint.EndPoint.ToString ());
ServerElement server = serverList.FirstOrDefault ();
if (server != null) serverEndPoint.MinecraftVersion = server.MinecraftVersion;
//Use default
else serverEndPoint.MinecraftVersion = ProtocolInformation.MaxSupportedServerVersion;
}
}
/// <summary>
/// Returns true if the online mode is enabled for a specific user or not.
/// </summary>
/// <param name="proxyConnection"> The proxy connection which should be checked </param>
/// <returns> true if the online mode is enabled, otherwise false. </returns>
public bool OnlineModeEnabled(IProxyConnection proxyConnection)
{
var args = new PluginResultEventArgs<bool?>(null, proxyConnection);
PluginManager.TriggerPlugin.IsOnlineModeEnabled(args);
if (args.Result == null)
return OnlineMode;
return (bool) args.Result;
}
/// <summary>
/// Get a new server end point for a given proxy connection to.
/// </summary>
/// <param name="proxyConnection"> The proxy connection which need a new server connection. </param>
/// <returns> A RemoteServerInfo object which contains important information about the new backend server. </returns>
public RemoteServerInfo GetServerEndPoint(IProxyConnection proxyConnection)
{
ProxyConfigurationSection settings = ProxyConfigurationSection.Settings;
IOrderedEnumerable<ServerElement> server =
settings.Server.OfType<ServerElement> ().Where(
m => m.IsDefault || (!string.IsNullOrEmpty(m.DnsName) && proxyConnection.Host.StartsWith(m.DnsName)))
.OrderBy(m => m.IsDefault);
ServerElement possibleResult = server.FirstOrDefault ();
RemoteServerInfo result = possibleResult == null
? null
: new RemoteServerInfo(possibleResult.Name,
Extensions.ParseEndPoint(possibleResult.EndPoint),
possibleResult.MinecraftVersion)
{
KickMessage = possibleResult.KickMessage
};
var args = new PluginResultEventArgs<RemoteServerInfo>(result, proxyConnection);
PluginManager.TriggerPlugin.OnPlayerServerSelection(args);
args.EnsureSuccess ();
return args.Result;
}
public ProxyTerminal()
{
this.pc = new ProxyConnection();
}
/// <summary>
/// Create a new instance of the UserEventArgs class with the specific connection
/// </summary>
/// <param name="connection"> The connection this event data belongs to </param>
public UserEventArgs(IProxyConnection connection)
{
Connection = connection;
}
protected override IProxyConnection GetConnection(TcpClientInfo clientInfo)
{
_currentConnection = new MockProxyConnection(clientInfo.Client, clientInfo.IsSecure, _trafficDataStore, "Mock request", _mockSite);
return(_currentConnection);
}
/// <summary>
/// Creates a new instance of the <see cref="PacketReceivedEventArgs" /> class
/// </summary>
/// <param name="packet"> The packet which should be redirected </param>
/// <param name="connection"> The connection this packet belongs to </param>
public PacketReceivedEventArgs(Packet packet, IProxyConnection connection)
{
Packet = packet;
Connection = connection;
}
