// methods
public bool Equals(ConnectionId other)
{
if (other == null)
{
return(false);
}
return
(_serverId.Equals(other._serverId) &&
_localValue == other._localValue);
}
private List <ServerId> GetNearServers(ServerId server)
{
var ret = new List <ServerId>();
int pos = _map.Map.FindIndex(x => x.ServerId.Equals(server));
int index = (pos + 1) % _map.Map.Count;
for (int i = 0; i < _configuration.CountReplics - 1; i++)
{
while (pos != index)
{
var s = _map.Map[index].ServerId;
if (!ret.Contains(s) && !server.Equals(s))
{
ret.Add(s);
index = ++index % _map.Map.Count;
break;
}
index = ++index % _map.Map.Count;
}
if (pos == index && ret.Count != _configuration.CountReplics)
{
return(null);
}
}
return(ret);
}
private void ProcessData(InnerData data)
{
_lock.EnterReadLock();
bool exit = _isStart;
_lock.ExitReadLock();
if (!exit)
{
return;
}
data.Transaction.OperationName = OperationName.RestoreUpdate;
data.Transaction.OperationType = OperationType.Async;
var result = WriterNet.ProcessSync(_remote, data);
if (result is FailNetResult)
{
Logger.Logger.Instance.InfoFormat("Servers {0} unavailable in recover process", _remote);
_asyncTaskModule.DeleteTask(AsyncTasksNames.RestoreLocal);
_reader.Stop();
_lock.EnterWriteLock();
_isStart = false;
_lock.ExitWriteLock();
}
else if (!_local.Equals(_remote))
{
_db.Delete(data);
}
}
public void HandleEvent(object sender, IEvent evt)
{
switch (evt)
{
case SessionChannelSwitchEvent _:
case SessionPingEvent _:
case SessionResumeEvent _:
case SessionSuspendEvent _:
GetSession(evt.SessionId, session => session?.HandleEvent(sender, evt));
break;
case SessionCreatedEvent sce:
if (ServerId.Equals(sce.ServerId)) // we created the session
{
break;
}
lock (Sync)
Users.GetUser(sce.UserId, user => {
if (user != null) // if we get here and there's no user we've either hit a race condition or we're out of sync somehow
{
Sessions.Add(new Session(sce.ServerId, sce.SessionId, sce.IsSecure, sce.LastPing, user, sce.IsConnected, null, sce.RemoteAddress));
}
});
break;
case SessionDestroyEvent sde:
GetSession(sde.SessionId, session => {
Sessions.Remove(session);
session.HandleEvent(sender, sde);
});
break;
}
}
public int CompareTo(MatchInfoId other)
{
if (ServerId.Equals(other.ServerId))
{
return(EndTime.CompareTo(other.EndTime));
}
return(string.Compare(ServerId, other.ServerId, StringComparison.Ordinal));
}
/// <summary>
/// Message from servers? indicates that he sent all data
/// </summary>
/// <param name="server"></param>
public void LastMessageIncome(ServerId server)
{
Logger.Logger.Instance.Debug("last message income", "restore");
if (server.Equals(_remoteServer))
{
StartNextServer();
}
}
/// <summary>
/// Message from server, indicates that he is alive and sending data
/// </summary>
/// <param name="server"></param>
public void PeriodMessageIncome(ServerId server)
{
//Logger.Logger.Instance.Debug("period messge income", "restore");
if (server.Equals(_remoteServer))
{
_asyncTaskModule.RestartTask(AsyncTasksNames.RestoreRemote);
}
}
public void ProxyDistributorModule_TransactionDestination_CreateTransAndGetDestination()
{
var model = new DistributorSystemModel();
var server1 = new ServerId("localhost", 1);
var server2 = new ServerId("localhost", 2);
model.AddServer(server1);
model.AddServer(server2);
const string hash = "123";
var res1 = model.CreateTransaction(hash);
Assert.IsNotNull(res1);
var res2 = model.GetDestination(res1.UserTransaction);
Assert.IsTrue(server1.Equals(res2));
var res3 = model.CreateTransaction(hash);
Assert.IsNotNull(res3);
var res4 = model.GetDestination(res3.UserTransaction);
Assert.IsTrue(server2.Equals(res4));
model.ServerNotAvailable(server1);
var res5 = model.CreateTransaction(hash);
Assert.IsNotNull(res5);
var res6 = model.GetDestination(res5.UserTransaction);
Assert.IsTrue(server2.Equals(res6));
model.ServerNotAvailable(server2);
var res7 = model.CreateTransaction(hash);
Assert.AreEqual(Errors.NotAvailableServersInSystem + "; ", res7.ErrorDescription);
}
public override bool Equals(object obj)
{
var tableToObj = obj as DerivativeTable;
if (tableToObj == null)
{
return(false);
}
return(ServerId.Equals(tableToObj.ServerId) &&
Database.Equals(tableToObj.Database) &&
Schema.Equals(tableToObj.Schema) &&
Table.Equals(tableToObj.Table));
}
public bool Equals(Player other)
{
return(ServerId.Equals(other.ServerId) && PlayerId.Equals(other.PlayerId));
}
