internal void ResetPeer(MessageSession session, ResetPeerMessage msg)
{
_serverMapLock.DoWrite(() =>
{
if (!_serverMap.ContainsKey(session))
return;
var server = _serverMap[session];
Logger.Write("Disconnected: [{0}] {1}:{2}", server.Name, server.Host, server.Port);
_serverMap.Remove(session);
});
_interChatLock.DoWrite(() =>
{
if (!_interChatUserMap.ContainsKey(session))
return;
var userName = _interChatUserMap[session];
Logger.Write("Disconnected: InterChat [{0}]", userName);
_interChatUserMap.Remove(session);
BroadcastChatMsgWithNoLock("system", userName + "께서 접속을 종료하였습니다.");
BroadcastCommandMsgWithNoLock(InterChatCommandType.InformLogoutUser, userName);
});
}
internal void RegisterServer(MessageSession session, ServerMsg msg)
{
_serverMapLock.DoWrite(() =>
{
_serverMap.Add(session, msg);
Logger.Write("Connected: [{0}] {1}:{2}", msg.Name, msg.Host, msg.Port);
});
}
internal bool Add(int sessionId, MessageSession session)
{
_lock.DoWrite(() =>
{
_sessionMap.Add(sessionId, session);
_idMap.Add(session, sessionId);
});
return(true);
}
public bool Add(string name, int entityId)
{
return(_lock.DoWrite(() =>
{
if (_cacheMap.ContainsKey(name))
{
return false;
}
_cacheMap.Add(name, entityId);
return true;
}));
}
private InterChatUser FindOrCreateUserWithLock(string userName)
{
return _userMapLock.DoWrite(() =>
{
if (!_userMap.ContainsKey(userName))
_userMap.Add(userName, new InterChatUser {Name = userName});
return _userMap[userName];
});
}
public bool TryAddChainedHeader(ChainedHeader chainedHeader)
{
return(totalWorkLock.DoWrite(() =>
{
if (this.chainedHeaders.TryAdd(chainedHeader.Hash, chainedHeader))
{
List <ChainedHeader> headersAtTotalWork;
if (!chainedHeadersByTotalWork.TryGetValue(chainedHeader.TotalWork, out headersAtTotalWork))
{
headersAtTotalWork = new List <ChainedHeader>();
chainedHeadersByTotalWork.Add(chainedHeader.TotalWork, headersAtTotalWork);
}
headersAtTotalWork.Add(chainedHeader);
return true;
}
else
{
return false;
}
}));
}
internal void BroadcastChatMsgWithNoLock(string userName, string message)
{
var msg = new InterChatMsg
{
Name = userName,
Message = message,
Ticks = DateTime.Now.Ticks
};
_interChatMessageLock.DoWrite(() =>
{
_lastMessages.Enqueue(msg);
while (_lastMessages.Count > PreserveMessageCount)
_lastMessages.Dequeue();
});
foreach (var eachSession in _interChatUserMap.Keys)
eachSession.Send(msg);
}
private void CheckAndDisconnect<T>(ReaderWriterLockSlim locker, Dictionary<MessageSession, T> sessionMap)
{
const int tolerantInterval = 3 * 60 * 1000;
var removalSessions = locker.DoWrite(() =>
sessionMap.Keys.Where(e => (DateTime.Now - e.LastReceiveTime).TotalMilliseconds >= tolerantInterval)
.ToArray());
foreach (var session in removalSessions)
ResetPeer(session, new ResetPeerMessage());
// 해당 연결을 모두 제거한다.
foreach (var session in removalSessions)
{
try
{
session.Dispose();
}
catch
{
}
}
}
public void AddBlock(ChainedHeader chainedHeader, IEnumerable <BlockTx> blockTxes, CancellationToken cancelToken = default(CancellationToken))
{
var confirmedTxes = ImmutableDictionary.CreateBuilder <UInt256, UnconfirmedTx>();
updateLock.DoWrite(() =>
{
using (var handle = storageManager.OpenUnconfirmedTxesCursor())
{
var unconfirmedTxesCursor = handle.Item;
unconfirmedTxesCursor.BeginTransaction();
var newChain = chain.Value.ToBuilder().AddBlock(chainedHeader).ToImmutable();
foreach (var blockTx in blockTxes)
{
// remove any txes confirmed in the block from the list of unconfirmed txes
UnconfirmedTx unconfirmedTx;
if (unconfirmedTxesCursor.TryGetTransaction(blockTx.Hash, out unconfirmedTx))
{
// track confirmed txes
confirmedTxes.Add(unconfirmedTx.Hash, unconfirmedTx);
if (!unconfirmedTxesCursor.TryRemoveTransaction(blockTx.Hash))
{
throw new InvalidOperationException();
}
}
// check for and remove any unconfirmed txes that conflict with the confirmed tx
var confirmedTx = blockTx.EncodedTx.Decode().Transaction;
foreach (var input in confirmedTx.Inputs)
{
var conflictingTxes = unconfirmedTxesCursor.GetTransactionsSpending(input.PrevTxOutputKey);
if (conflictingTxes.Count > 0)
{
logger.Warn($"Removing {conflictingTxes.Count} conflicting txes from the unconfirmed transaction pool");
// remove the conflicting unconfirmed txes
foreach (var conflictingTx in conflictingTxes.Keys)
{
if (!unconfirmedTxesCursor.TryRemoveTransaction(conflictingTx))
{
throw new StorageCorruptException(StorageType.UnconfirmedTxes, $"{conflictingTx} is indexed but not present");
}
}
}
}
}
unconfirmedTxesCursor.ChainTip = chainedHeader;
commitLock.DoWrite(() =>
{
unconfirmedTxesCursor.CommitTransaction();
chain = new Lazy <Chain>(() => newChain).Force();
});
}
});
TxesConfirmed?.Invoke(this, new TxesConfirmedEventArgs(chainedHeader, confirmedTxes.ToImmutable()));
}
public void Start()
{
controlLock.DoWrite(() => InternalStart());
}
public void AddHandler(int typeId, THandler handler)
{
_lock.DoWrite(() => _handlerMap.Add(typeId, handler));
}
