public void AddHandleListener(Type packetType,OnHanldePacketData handleFunction)
{
PacketHandle handle = new PacketHandle();
handle.packetType = packetType;
handle.handleFuntion = handleFunction;
mListPacketDataHandle.Add(handle);
}
internal override PacketHandle ReadAsync(SessionHandle handle, out uint error)
{
SNIPacket packet;
error = SNIProxy.Singleton.ReadAsync(handle.ManagedHandle, out packet);
return(PacketHandle.FromManagedPacket(packet));
}
/// <summary>
/// Handle receive completion
/// </summary>
/// <param name="packet">SNI packet</param>
/// <param name="header">SMUX header</param>
public void HandleReceiveComplete(SNIPacket packet, SNISMUXHeader header)
{
lock (this)
{
if (_sendHighwater != header.highwater)
{
HandleAck(header.highwater);
}
lock (_receivedPacketQueue)
{
if (_asyncReceives == 0)
{
_receivedPacketQueue.Enqueue(packet);
_packetEvent.Set();
return;
}
_asyncReceives--;
Debug.Assert(_callbackObject != null);
((TdsParserStateObject)_callbackObject).ReadAsyncCallback(PacketHandle.FromManagedPacket(packet), 0);
}
}
lock (this)
{
_receiveHighwater++;
}
SendAckIfNecessary();
}
private void RegisterMessageHandler(int pid, PacketHandle hander)
{
if (!this.MsgHandleDic_.ContainsKey(pid))
{
this.MsgHandleDic_.Add(pid, hander);
}
}
internal override PacketHandle GetResetWritePacket(int dataSize)
{
var packet = new SNIPacket(headerSize: _sessionHandle.ReserveHeaderSize, dataSize: dataSize);
Debug.Assert(packet.ReservedHeaderSize == _sessionHandle.ReserveHeaderSize, "failed to reserve header");
return(PacketHandle.FromManagedPacket(packet));
}
internal override PacketHandle CreateAndSetAttentionPacket()
{
PacketHandle packetHandle = GetResetWritePacket(TdsEnums.HEADER_LEN);
SetPacketData(packetHandle, SQL.AttentionHeader, TdsEnums.HEADER_LEN);
return(packetHandle);
}
/// <summary>
/// Copies data in SNIPacket to given byte array parameter
/// </summary>
/// <param name="packet">SNIPacket object containing data packets</param>
/// <param name="inBuff">Destination byte array where data packets are copied to</param>
/// <param name="dataSize">Length of data packets</param>
/// <returns>SNI error status</returns>
protected override uint SNIPacketGetData(PacketHandle packet, byte[] inBuff, ref uint dataSize)
{
int dataSizeInt = 0;
packet.ManagedPacket.GetData(inBuff, ref dataSizeInt);
dataSize = (uint)dataSizeInt;
return(TdsEnums.SNI_SUCCESS);
}
public void AddHandleListener(Type packetType, OnHanldePacketData handleFunction)
{
PacketHandle handle = new PacketHandle();
handle.packetType = packetType;
handle.handleFuntion = handleFunction;
mListPacketDataHandle.Add(handle);
}
internal override bool IsValidPacket(PacketHandle packet)
{
Debug.Assert(packet.Type == PacketHandle.ManagedPacketType, "unexpected packet type when requiring ManagedPacket");
return(
packet.Type == PacketHandle.ManagedPacketType &&
packet.ManagedPacket != null &&
!packet.ManagedPacket.IsInvalid
);
}
/// <summary>
/// Handle send completion
/// </summary>
/// <param name="packet">SNI packet</param>
/// <param name="sniErrorCode">SNI error code</param>
public void HandleSendComplete(SNIPacket packet, uint sniErrorCode)
{
lock (this)
{
Debug.Assert(_callbackObject != null);
((TdsParserStateObject)_callbackObject).WriteAsyncCallback(PacketHandle.FromManagedPacket(packet), sniErrorCode);
}
}
internal override PacketHandle ReadAsync(SessionHandle handle, out uint error)
{
SNIPacket packet = null;
error = handle.ManagedHandle.ReceiveAsync(ref packet);
SqlClientEventSource.Log.TryTraceEvent("TdsParserStateObjectManaged.ReadAsync | Info | State Object Id {0}, Session Id {1}, Packet DataLeft {2}", _objectID, _sessionHandle?.ConnectionId, packet?.DataLeft);
return(PacketHandle.FromManagedPacket(packet));
}
internal override PacketHandle CreateAndSetAttentionPacket()
{
if (_sniAsyncAttnPacket == null)
{
SNIPacket attnPacket = new SNIPacket();
SetPacketData(PacketHandle.FromManagedPacket(attnPacket), SQL.AttentionHeader, TdsEnums.HEADER_LEN);
_sniAsyncAttnPacket = attnPacket;
}
return(PacketHandle.FromManagedPacket(_sniAsyncAttnPacket));
}
/// <summary>
/// Handle receive error
/// </summary>
public void HandleReceiveError(SNIPacket packet)
{
lock (_receivedPacketQueue)
{
_connectionError = SNILoadHandle.SingletonInstance.LastError;
_packetEvent.Set();
}
((TdsParserStateObject)_callbackObject).ReadAsyncCallback(PacketHandle.FromManagedPacket(packet), 1);
}
/// <summary>
/// Добавить пакет для обработки сервером
/// </summary>
/// <param name="packetId">Индификатор пакета в системе</param>
/// <param name="packet">Обработчик пакета</param>
/// <returns></returns>
public bool AddPacket(ushort packetId, PacketHandle packet)
{
var r = Packets.ContainsKey(packetId);
if (!r)
{
Packets.Add(packetId, packet);
}
return(!r);
}
internal override void ReleasePacket(PacketHandle syncReadPacket)
{
SNIPacket packet = syncReadPacket.ManagedPacket;
if (packet != null)
{
SNIHandle handle = Handle;
handle.ReturnPacket(packet);
}
}
internal override PacketHandle ReadSyncOverAsync(int timeoutRemaining, out uint error)
{
SNIHandle handle = Handle;
if (handle == null)
{
throw ADP.ClosedConnectionError();
}
error = SNIProxy.GetInstance().ReadSyncOverAsync(handle, out SNIPacket packet, timeoutRemaining);
return(PacketHandle.FromManagedPacket(packet));
}
private void RegisterMessageHandler(int pid, PacketHandle hander)
{
if (!this.MsgHandleDic_.ContainsKey(pid))
{
this.MsgHandleDic_.Add(pid, hander);
}
else
{
Debug.LogError("MsgHandler[" + pid.ToString() + "] has registered.");
}
}
internal override PacketHandle CreateAndSetAttentionPacket()
{
PacketHandle packetHandle = GetResetWritePacket(TdsEnums.HEADER_LEN);
#if DEBUG
Debug.Assert(packetHandle.ManagedPacket.IsActive, "rental packet is not active a serious pooling error may have occurred");
#endif
SetPacketData(packetHandle, SQL.AttentionHeader, TdsEnums.HEADER_LEN);
packetHandle.ManagedPacket.IsOutOfBand = true;
return(packetHandle);
}
internal override PacketHandle GetResetWritePacket(int dataSize)
{
SNIHandle handle = Handle;
SNIPacket packet = handle.RentPacket(headerSize: handle.ReserveHeaderSize, dataSize: dataSize);
#if DEBUG
Debug.Assert(packet.IsActive, "packet is not active, a serious pooling error may have occurred");
#endif
Debug.Assert(packet.ReservedHeaderSize == handle.ReserveHeaderSize, "failed to reserve header");
return(PacketHandle.FromManagedPacket(packet));
}
public void RemoveHandleListener(OnHanldePacketData handleFunction)
{
for (int i = 0; i < mListPacketDataHandle.Count; i++)
{
PacketHandle handle = mListPacketDataHandle[i];
if (handle.handleFuntion == handleFunction)
{
mListPacketDataHandle.Remove(handle);
}
}
}
public void RegisterProtoHandler(int msgID, PacketHandle handler, int interestResult = -1)
{
if (_packetHandleDic.ContainsKey(msgID))
{
Debug.Log("Already register msg " + msgID + " handler");
return;
}
PacketHadleInfo info = new PacketHadleInfo(handler, interestResult);
_packetHandleDic.Add(msgID, info);
}
internal override PacketHandle CreateAndSetAttentionPacket()
{
PacketHandle packetHandle = GetResetWritePacket(TdsEnums.HEADER_LEN);
#if DEBUG
Debug.Assert(packetHandle.ManagedPacket.IsActive, "rental packet is not active a serious pooling error may have occurred");
#endif
SetPacketData(packetHandle, SQL.AttentionHeader, TdsEnums.HEADER_LEN);
SqlClientEventSource.Log.TryTraceEvent("TdsParserStateObjectManaged.CreateAndSetAttentionPacket | Info | State Object Id {0}, Session Id {1}", _objectID, _sessionHandle?.ConnectionId);
packetHandle.ManagedPacket.IsOutOfBand = true;
return(packetHandle);
}
//--------------逻辑处理映射----------------
public void AddPacketHandle(ushort protocol, PacketHandle handle)
{
lock (this)
{
if (!PacketHandles.ContainsKey(protocol))
{
PacketHandles.Add(protocol, handle);
}
else
{
PacketHandles[protocol] = handle;
}
}
}
internal override void ReleasePacket(PacketHandle syncReadPacket)
{
SNIPacket packet = syncReadPacket.ManagedPacket;
SqlClientEventSource.Log.TryTraceEvent("TdsParserStateObjectManaged.ReleasePacket | Info | State Object Id {0}, Session Id {1}, Packet DataLeft {2}", _objectID, _sessionHandle?.ConnectionId, packet?.DataLeft);
#if DEBUG
SqlClientEventSource.Log.TryAdvancedTraceEvent("TdsParserStateObjectManaged.ReleasePacket | TRC | State Object Id {0}, Session Id {1}, Packet {2} will be released, Packet Owner Id {3}, Packet dataLeft {4}", _objectID, _sessionHandle?.ConnectionId, packet?._id, packet?._owner.ConnectionId, packet?.DataLeft);
#endif
if (packet != null)
{
SNIHandle handle = Handle;
handle.ReturnPacket(packet);
}
}
/// <summary>
/// 处理协议包
/// </summary>
/// <param name="resp"></param>
void HandlePacket(ProtoBase_S2C resp)
{
//触发所有侦听了这个协议的函数
for (int i = 0; i < mListPacketDataHandle.Count; i++)
{
PacketHandle handle = mListPacketDataHandle[i];
if (handle.packetType == resp.GetType())
{
if (handle.handleFuntion != null)
{
handle.handleFuntion(resp);
}
}
}
}
internal override PacketHandle ReadSyncOverAsync(int timeoutRemaining, out uint error)
{
SNIHandle handle = Handle;
if (handle == null)
{
throw ADP.ClosedConnectionError();
}
error = SNIProxy.GetInstance().ReadSyncOverAsync(handle, out SNIPacket packet, timeoutRemaining);
SqlClientEventSource.Log.TryTraceEvent("TdsParserStateObjectManaged.ReadSyncOverAsync | Info | State Object Id {0}, Session Id {1}", _objectID, _sessionHandle?.ConnectionId);
#if DEBUG
SqlClientEventSource.Log.TryAdvancedTraceEvent("TdsParserStateObjectManaged.ReadSyncOverAsync | TRC | State Object Id {0}, Session Id {1}, Packet {2} received, Packet owner Id {3}, Packet dataLeft {4}", _objectID, _sessionHandle?.ConnectionId, packet?._id, packet?._owner.ConnectionId, packet?.DataLeft);
#endif
return(PacketHandle.FromManagedPacket(packet));
}
internal override PacketHandle GetResetWritePacket()
{
if (_sniPacket != null)
{
_sniPacket.Reset();
}
else
{
lock (_writePacketLockObject)
{
_sniPacket = _writePacketCache.Take(Handle);
}
}
return(PacketHandle.FromManagedPacket(_sniPacket));
}
internal void WriteAsyncCallback(SNIPacket packet, uint sniError)
{
SNIHandle sessionHandle = _sessionHandle;
if (sessionHandle != null)
{
WriteAsyncCallback(IntPtr.Zero, PacketHandle.FromManagedPacket(packet), sniError);
sessionHandle?.ReturnPacket(packet);
}
else
{
// clear the packet and drop it to GC because we no longer know how to return it to the correct owner
// this can only happen if a packet is in-flight when the _sessionHandle is cleared
packet.Release();
}
}
/// <summary>
/// Handle send completion
/// </summary>
/// <param name="packet">SNI packet</param>
/// <param name="sniErrorCode">SNI error code</param>
public void HandleSendComplete(SNIPacket packet, uint sniErrorCode)
{
using (TrySNIEventScope.Create(nameof(SNIMarsHandle)))
{
lock (this)
{
Debug.Assert(_callbackObject != null);
((TdsParserStateObject)_callbackObject).WriteAsyncCallback(PacketHandle.FromManagedPacket(packet), sniErrorCode);
}
_connection.ReturnPacket(packet);
#if DEBUG
SqlClientEventSource.Log.TrySNITraceEvent(nameof(SNIMarsHandle), EventType.INFO, "MARS Session Id {0}, Returned Packet: {1}", args0: ConnectionId, args1: packet?._id);
#endif
}
}
/// <summary>
/// Handle receive completion
/// </summary>
/// <param name="packet">SNI packet</param>
/// <param name="header">SMUX header</param>
public void HandleReceiveComplete(SNIPacket packet, SNISMUXHeader header)
{
long scopeID = SqlClientEventSource.Log.TrySNIScopeEnterEvent(s_className);
try
{
lock (this)
{
if (_sendHighwater != header.highwater)
{
SqlClientEventSource.Log.TrySNITraceEvent(s_className, EventType.INFO, "MARS Session Id {0}, header.highwater {1}, _sendHighwater {2}, Handle Ack with header.highwater", args0: ConnectionId, args1: header?.highwater, args2: _sendHighwater);
HandleAck(header.highwater);
}
lock (_receivedPacketQueue)
{
if (_asyncReceives == 0)
{
_receivedPacketQueue.Enqueue(packet);
_packetEvent.Set();
SqlClientEventSource.Log.TrySNITraceEvent(s_className, EventType.INFO, "MARS Session Id {0}, _sequenceNumber {1}, _sendHighwater {2}, _receivedPacketQueue count {3}, packet event set", args0: ConnectionId, args1: _sequenceNumber, args2: _sendHighwater, args3: _receivedPacketQueue?.Count);
return;
}
_asyncReceives--;
Debug.Assert(_callbackObject != null);
SqlClientEventSource.Log.TrySNITraceEvent(s_className, EventType.INFO, "MARS Session Id {0}, _sequenceNumber {1}, _sendHighwater {2}, _asyncReceives {3}", args0: ConnectionId, args1: _sequenceNumber, args2: _sendHighwater, args3: _asyncReceives);
((TdsParserStateObject)_callbackObject).ReadAsyncCallback(PacketHandle.FromManagedPacket(packet), 0);
}
_connection.ReturnPacket(packet);
}
lock (this)
{
_receiveHighwater++;
}
SqlClientEventSource.Log.TrySNITraceEvent(s_className, EventType.INFO, "MARS Session Id {0}, _asyncReceives {1}, _receiveHighwater {2}, _sendHighwater {3}, _receiveHighwaterLastAck {4}", args0: ConnectionId, args1: _asyncReceives, args2: _receiveHighwater, args3: _sendHighwater, args4: _receiveHighwaterLastAck);
SendAckIfNecessary();
}
finally
{
SqlClientEventSource.Log.TrySNIScopeLeaveEvent(scopeID);
}
}
/// <summary>
/// Handle receive error
/// </summary>
public void HandleReceiveError(SNIPacket packet)
{
using (TrySNIEventScope.Create(nameof(SNIMarsHandle)))
{
// SNIMarsHandle should only receive calls to this function from the SNIMarsConnection aggregator class
// which should handle ownership of the packet because the individual mars handles are not aware of
// each other and cannot know if they are the last one in the list and that it is safe to return the packet
lock (_receivedPacketQueue)
{
_connectionError = SNILoadHandle.SingletonInstance.LastError;
SqlClientEventSource.Log.TrySNITraceEvent(nameof(SNIMarsHandle), EventType.ERR, "MARS Session Id {0}, _connectionError to be handled: {1}", args0: ConnectionId, args1: _connectionError);
_packetEvent.Set();
}
((TdsParserStateObject)_callbackObject).ReadAsyncCallback(PacketHandle.FromManagedPacket(packet), 1);
}
}
