private static unsafe void AddSessionToPacket(UnmanagedMemory packet,byte[] sessionBytes,int index) { if (sessionBytes != null) { Marshal.Copy(sessionBytes, 0, (IntPtr)(packet.Handle + index), sessionBytes.Length); } }
private static unsafe void AddHeaderToPacket(UnmanagedMemory packet, byte isPrice, byte sessionLength, byte[] contentLengthBytes) { packet.Handle[PacketConstants.SettingIndex] = isPrice; packet.Handle[PacketConstants.SessionLengthIndex] = sessionLength; const int startIndex = PacketConstants.ContentLengthIndex; Marshal.Copy(contentLengthBytes, 0, (IntPtr)(packet.Handle + startIndex), contentLengthBytes.Length); }
public TraderMemoryStream(int capacity) { if (capacity < 0) { throw new ArgumentOutOfRangeException("capacity", "ArgumentOutOfRange_NegativeCapacity"); } this._buffer = new UnmanagedMemory(capacity); this._capacity = capacity; this._expandable = true; this._writable = true; this._exposable = true; this._origin = 0; this._isOpen = true; }
private static unsafe UnmanagedMemory BuildForCommandCommon(byte[] data, bool isPrice) { int packetLength = PacketConstants.HeadLength + data.Length; UnmanagedMemory packet =new UnmanagedMemory(packetLength); byte[] contentLengthBytes = CustomerIntCache.Get(data.Length); packet.Handle[PacketConstants.SettingIndex] = 0; if (isPrice) { byte priceByte = PacketFirstHeadByteValue.IsPrice; packet.Handle[PacketConstants.SettingIndex] = priceByte; } packet.Handle[PacketConstants.SessionLengthIndex] = 0; int offset = PacketConstants.ContentLengthIndex; Marshal.Copy(contentLengthBytes, 0, (IntPtr)(packet.Handle + offset), contentLengthBytes.Length); offset = PacketConstants.HeadLength; Marshal.Copy(data, 0, (IntPtr)(packet.Handle + offset), data.Length); return packet; }
public static UnmanagedMemory GetKickoutPacket() { if (_KickoutPacket != null) { return _KickoutPacket; } lock (_Lock) { if (_KickoutPacket != null) { return _KickoutPacket; } byte[] contentBytes = PacketConstants.ContentEncoding.GetBytes(KickoutContent); byte[] contentLengthBytes = contentBytes.Length.ToCustomerBytes(); byte[] packet = new byte[PacketConstants.HeadLength + contentBytes.Length]; Buffer.BlockCopy(contentLengthBytes, 0, packet, PacketConstants.ContentLengthIndex, contentLengthBytes.Length); Buffer.BlockCopy(contentBytes, 0, packet, PacketConstants.HeadLength, contentBytes.Length); _KickoutPacket = new UnmanagedMemory(packet); return _KickoutPacket; } }
public CommandForClient(UnmanagedMemory data = null, QuotationCommand quotationCommand = null, Command command = null) { if (command != null) { this._Command = command; this._Quotation = null; this._Data = null; this._CommandType = DataType.Command; } else if (quotationCommand != null) { this._Quotation = new QuotationTranslator(quotationCommand); this._Command = null; this._Data = null; this._CommandType = DataType.Quotation; } else { this._Data = data; this._Command = null; this._Quotation = null; this._CommandType = DataType.Response; } }
public PacketContent(UnmanagedMemory mem) { this.UnmanageMem = mem; this.ContentType = ContentType.UnmanageMemory; }
private static unsafe void AddContentToPacket(UnmanagedMemory packet, byte[] contentBytes,int index) { Marshal.Copy(contentBytes, 0, (IntPtr)(packet.Handle + index), contentBytes.Length); }
private static unsafe UnmanagedMemory BuildForPointer(UnmanagedMemory source, string invokeID) { UnmanagedMemory content = ZlibHelper.ZibCompress(source.ToArray()); source.Dispose(); int contentLength = PacketConstants.InvokeIdLength + content.Length; int packetLength=PacketConstants.HeadLength + contentLength; UnmanagedMemory packet = new UnmanagedMemory(packetLength); byte[] contentLengthBytes = contentLength.ToCustomerBytes(); packet.Handle[PacketConstants.SettingIndex] = PacketFirstHeadByteValue.IsPlainString; packet.Handle[PacketConstants.SessionLengthIndex] = 0; int offset = PacketConstants.ContentLengthIndex; Marshal.Copy(contentLengthBytes, 0, (IntPtr)(packet.Handle + offset), contentLengthBytes.Length); offset = PacketConstants.HeadLength; byte[] invokeIDBytes = PacketConstants.ClientInvokeIDEncoding.GetBytes(invokeID); Marshal.Copy(invokeIDBytes, 0, (IntPtr)(packet.Handle + offset), invokeIDBytes.Length); offset += invokeIDBytes.Length; CopyMemory((IntPtr)(packet.Handle + offset),(IntPtr)content.Handle, (uint)content.Length); content.Dispose(); return packet; }
private static UnmanagedMemory BuildForKeepAlive(SerializedInfo response) { Debug.Assert(response.Content.ContentType == ContentType.KeepAlivePacket, "content type should be keepalive"); KeepAlive keepAlive = response.Content.KeepAlive; keepAlive.Packet[PacketConstants.SettingIndex] = keepAlive.IsSuccess ? PacketFirstHeadByteValue.IsKeepAliveAndSuccessValue : PacketFirstHeadByteValue.IsKeepAliveAndFailedValue; UnmanagedMemory packet = new UnmanagedMemory(keepAlive.Packet); return packet; }
private static UnmanagedMemory BuildForGeneralFormat(SerializedInfo response) { if (!string.IsNullOrEmpty(response.ClientInfo.ClientInvokeId)) { AppendClientInvokeIdToContentNode(response.Content, response.ClientInfo.ClientInvokeId); } byte[] contentBytes = GetContentBytes(response.Content); byte[] sessionBytes = GetSessionBytes(response.ClientInfo.Session.ToString()); byte sessionLengthByte = (byte)sessionBytes.Length; byte[] contentLengthBytes = contentBytes.Length.ToCustomerBytes(); int packetLength = PacketConstants.HeadLength + sessionLengthByte + contentBytes.Length; var packet = new UnmanagedMemory(packetLength); const byte priceByte = 0; AddHeaderToPacket(packet, priceByte, sessionLengthByte, contentLengthBytes); AddSessionToPacket(packet, sessionBytes, PacketConstants.HeadLength); AddContentToPacket(packet, contentBytes, PacketConstants.HeadLength + sessionLengthByte); return packet; }
private unsafe void BeginWrite(UnmanagedMemory mem, int offset, int len) { try { if (mem.Data != null) // keep alive data or kickout packet { this._Stream.BeginWrite(mem.Data, 0, mem.Data.Length, this.EndWrite, null); return; } if (len <= MAX_WRITE_LENGTH) { Marshal.Copy((IntPtr)(mem.Handle + offset), this._Buffer, this._WriteBufferIndex, len); this._Stream.BeginWrite(this._Buffer, this._WriteBufferIndex, len, this.EndWrite, null); } else { this._LastWriteBuffer = mem; Marshal.Copy((IntPtr)(mem.Handle + offset), this._Buffer, this._WriteBufferIndex, MAX_WRITE_LENGTH); this._Stream.BeginWrite(this._Buffer, this._WriteBufferIndex, MAX_WRITE_LENGTH, this.EndWrite, null); } } catch(Exception ex) { _Logger.Error("Begin Write", ex); this.Close(); } }
private void WriteForQuotation() { Token token; TraderState state = SessionManager.Default.GetTokenAndState(this._Id, out token); if (state == null || token == null) { Write(); return; } this._QuotationQueue.Clear(); this._QuotationQueue.Add(this._CurrentCommand.Quotation.QuotationCommand); while (this._Queue.Count > 0) { CommandForClient item = this._Queue.Peek(); if (item.CommandType != DataType.Quotation) { break; } item = this._Queue.Dequeue(); this._QuotationQueue.Add(item.Quotation.QuotationCommand); } byte[] content; if (this._QuotationQueue.Count == 1) { content = this._CurrentCommand.Quotation.GetPriceInBytes(token, state); } else { QuotationCommand command = new QuotationCommand(); command.Merge(this._QuotationQueue); content = QuotationTranslator.GetPriceInBytes(token, state, command, this._QuotationQueue[0].Sequence, this._QuotationQueue[this._QuotationQueue.Count - 1].Sequence); } if (content == null) { Write(); return; } this._CurrentPacket = SerializeManager.Default.SerializePrice(content); this.BeginWrite(this._CurrentPacket, 0, this._CurrentPacket.Length); }
private void WriteForCommand() { Token token; TraderState state = SessionManager.Default.GetTokenAndState(this._Id, out token); if (state == null || token == null) { Write(); return; } byte[] data = CommandTranslator.GetDataForCommand(token, state, this._CurrentCommand.Command); if (data == null) { Write(); return; } this._CurrentPacket = SerializeManager.Default.SerializeCommand(data); this.BeginWrite(this._CurrentPacket, 0, this._CurrentPacket.Length); }
private void Write() { try { lock (this._QueueLock) { if (this._Queue.Count == 0) { this._IsSendingData = false; return; } this._CurrentCommand = this._Queue.Dequeue(); if (this._CurrentCommand.CommandType == DataType.Command) { WriteForCommand(); } else if (this._CurrentCommand.CommandType == DataType.Response) { this._CurrentPacket = this._CurrentCommand.Data; this.BeginWrite(this._CurrentPacket, 0, this._CurrentPacket.Length); } else if (this._CurrentCommand.CommandType == DataType.Quotation) { WriteForQuotation(); } else { throw new ArgumentException(string.Format("Unrecognize DataType:{0}", this._CurrentCommand.CommandType)); } } } catch (Exception ex) { _Logger.Error("Write",ex); this.Close(); } }
private void EndWrite(IAsyncResult ar) { Action action = new Action(() => { try { this._Stream.EndWrite(ar); if (this._LastWriteBuffer == null) { this._CurrentPacket.Dispose(); Write(); return; } this._LastWriteIndex += MAX_WRITE_LENGTH; int len = this._LastWriteBuffer.Length - this._LastWriteIndex; if (len <= 0) { this._LastWriteBuffer = null; this._LastWriteIndex = 0; this._CurrentPacket.Dispose(); Write(); return; } int lenToBeWrite = len >= MAX_WRITE_LENGTH ? MAX_WRITE_LENGTH : len; this.BeginWrite(this._LastWriteBuffer, this._LastWriteIndex, lenToBeWrite); } catch(Exception ex) { _Logger.Error("End write", ex); this.Close(); } }); Task task = new Task(action); TaskQueue.Default.Enqueue(task); }