public void FlushMsg(object state) { if (!flushMsgThreadSignal.WaitOne(5)) { return; } flushMsgThreadSignal.Reset(); try { TBase msg = null; using (var serializer = new HeaderTBaseSerializer()) { while (cachedQueue.TryDequeue(out msg)) { var data = serializer.serialize(msg); server.SendTo(data, ipep); } } } catch (Exception ex) { Common.Logger.Current.Error(ex.ToString()); } flushMsgThreadSignal.Set(); }
public void Send(TBase @base) { if (@base != null) { cachedQueue.Enqueue(@base); } }
void SendMessageToClient(JStateObject state, byte messageType, TBase message) { int length = JThrift.Serialize(messageType, message, ref state.writeBuffer); server.Send(state.workSocket, state.writeBuffer, length); Debug.Log(string.Format("<color=green>R: ->C ({0}) - {1} </color> \n", state.name, message)); }
public void putMsg(TBase tBase) { if (tBase is LogEvent) { this.chunk.LogEvents.Add((LogEvent)tBase); this.chunkSize++; return; } else if (tBase is MetricEvent) { this.chunk.Metrics.Add((MetricEvent)tBase); this.chunkSize++; return; } else if (tBase is Span) { this.chunk.Spans.Add((Span)tBase); this.chunkSize++; return; } else if (tBase is Event) { this.chunk.Events.Add((Event)tBase); this.chunkSize++; return; } }
public void DeSerialize(TBase tbase, byte[] bytes) { if (tbase == null || bytes == null) { return; } DeSerialize(tbase, bytes, 0, bytes.Length); }
// from: https://stackoverflow.com/questions/24988527/tserializer-serializer-new-tserializer-in-c-sharp private byte[] Serialize(TBase obj) { var stream = new MemoryStream(); TProtocol tProtocol = new TBinaryProtocol(new TStreamTransport(stream, stream)); obj.Write(tProtocol); return(stream.ToArray()); }
public void SendMsgToServer(TBase msgValue) { if (CheckSocketStatus()) { PingTickTask.ResetSendMsgTime(); m_BufferTool.EncodeGamePackage(msgValue); Send(msgValue); } }
private void Send(TBase msgValue) { if (m_Status == SocketStatus.Idle || m_Status == SocketStatus.Closing) { return; } m_Status = SocketStatus.Sending; m_Socket.BeginSend(m_BufferTool.GetSendBuffer(), 0, m_BufferTool.GetSendBufferSize(), 0, SendEventHandle, msgValue); }
public static int GetMessageId(TBase message) { if (CanSupportMessage(message)) { return(REQ_MSG_ID[message.GetType()]); } return(-1); }
public static int GetMessageId(TBase message) { if (CanSupportMessage(message)) { return REQ_MSG_ID[message.GetType()]; } return -1; }
public PendingInjection(TBase targetModel, Inject inject, Type modelType, Type iface = null, TBase single = null) { TargetModel = targetModel; Injection = inject; ModelType = modelType; Interface = iface; Single = single; }
public byte[] serialize(TBase @base) { var header = locator.HeaderLookup(@base); Reset(); WriteHeader(header); @base.Write(protocol); return(baos.ToArray()); }
public RoutineInstanceBuilder AddParameter(String name, String dataTypeId, TBase value) { ResourceDTO resource = new ResourceDTO(); resource.DataTypeId = dataTypeId; resource.Data = Serialize(value); inParams.Add(name, resource); return(this); }
public static byte[] Serialize(TBase s) { var t = new TMemoryBuffer(); var p = new TBinaryProtocol(t); s.Write(p); return(t.GetBuffer()); }
public void CopyClass(TBase src, TBase tar) { if (src == null || tar == null) { return; } byte[] data = Serialize(src); DeSerialize(tar, data); }
/// <summary> /// Perform the injection /// </summary> /// <returns>What was injected</returns> public TBase Inject(TBase model, Type iface = null, TBase single = null) { model.Registry = _reg; foreach (var inject in _injections) { _reg.Inject(model, inject, iface, single); } return(model); }
public static T Deserialize <T>(byte[] buffer) where T : new() { using (TMemoryBuffer trans = new TMemoryBuffer(buffer)) { TProtocol proto = new TCompactProtocol(trans); TBase deserialized = (TBase) new T(); deserialized.Read(proto); return((T)deserialized); } }
/// <summary> /// CalcSizeOfSerializedThrift calculates the size in bytes that a Thrift object will take up. /// </summary> /// <param name="thriftBase">the base Thrift object to calculate the size of</param> /// <returns></returns> private async Task <int> CalcSizeOfSerializedThrift(TBase thriftBase) { _thriftBuffer.Reset(); try { await thriftBase.WriteAsync(_thriftProtocol, CancellationToken.None); } catch (Exception e) { throw new Exception("failed to calculate the size of a serialized thrift object", e); } return(_thriftBuffer.GetBuffer().Length); }
bool Receive() { try { var msg = socket?.ReceiveMultipartMessage(); if (msg == null || PubsubUtil.IsStoppingMessage(msg)) { PublisherLogger.Info("subscribe client stopped by stpping message!"); return(false); } var topic = msg[0].ConvertToString(); var msgType = msg[1].ConvertToString(); if (MsgHandlers.TryGetValue(msgType, out Delegate mh)) { var respBytes = msg[2].Buffer; var stream = new MemoryStream(respBytes, 0, respBytes.Length); using (TStreamTransport trans = new TStreamTransport(stream, stream)) using (TBinaryProtocol proto = new TBinaryProtocol(trans)) { Type t = GeneratedTypeCache.GetType(msgType); if (t == null) { throw new TargetInvocationException(new Exception($"can't get type for: {msgType}")); } TBase ret = Activator.CreateInstance(t) as TBase; ret.Read(proto); mh.DynamicInvoke(topic, ret); } } return(true); } catch (Exception e) { if (e is TargetInvocationException) { var ee = e as TargetInvocationException; Log($"SubscribeClient, invoke exception: {(ee).InnerException.Message} \n {ee.InnerException.StackTrace}", Logging.LogLevel.Warn); return(true); } if (e is TerminatingException) { Log($"SubscribeClient, terminated: {e.Message}", Logging.LogLevel.Info); return(false); } else { Log(disposing ? $"SubscribeClient, disposing exception: {e.Message}" : $"subscribe client receive exception: {e.Message} \n {e.StackTrace}", disposing ? Logging.LogLevel.Info : Logging.LogLevel.Error ); return(false); } } }
public static GameMessage CreateGameMessage(MessageType inType, TBase content, string inNetworkId) { GameMessage msg = new GameMessage { EventType = inType, Content = Serialize(content), NetworkId = inNetworkId }; return(msg); }
public static long Serialize(TBase message, ref byte[] buffer, int offset) { MemoryStream outputStream = new MemoryStream(buffer, offset, buffer.Length - offset); TStreamTransport transport = new TStreamTransport(null, outputStream); TBinaryProtocol binaryProtocol = new TBinaryProtocol(transport); message.Write(binaryProtocol); return outputStream.Position; }
public Base ConvertToClassBase(TBase pbase) { return(new Base { Nombre = pbase.Nombre, Departamento = pbase.Departamento, Ciudad = pbase.Ciudad, Direccion = pbase.Direccion, NumeroTelefono = pbase.NumeroTelefono }); }
public static byte[] SerializeGetBytes(object value) { using (TMemoryBuffer trans = new TMemoryBuffer()) { TProtocol proto = new TCompactProtocol(trans); TBase trade = (TBase)value; trade.Write(proto); byte[] bytes = trans.GetBuffer(); return(bytes); } }
void NotifyMessageToAllClients(byte messageType, TBase message) { //int length = JThrift.Serialize(messageType, message, ref writeBuffer); Debug.Log(string.Format("<color=green>R: ->All_C ({0}) - {1} </color> \n", messageType, message)); foreach (JStateObject state in states) { //System.Buffer.BlockCopy(writeBuffer, 0, state.writeBuffer, 0, length); int length = JThrift.Serialize(messageType, message, ref state.writeBuffer); server.Send(state.workSocket, state.writeBuffer, length); } }
public TBase Deserialize(byte[] buffer) { Reset(); baos.Write(buffer, 0, buffer.Length); baos.Seek(0, SeekOrigin.Begin); baos = new MemoryStream(buffer); Header header = ReadHeader(); TBase @base = locator.TBaseLookup(header.Type); @base.Read(protocol); return(@base); }
public static Stream Serialize(object value) { using (TMemoryBuffer trans = new TMemoryBuffer()) { TProtocol proto = new TCompactProtocol(trans); TBase trade = (TBase)value; trade.Write(proto); byte[] bytes = trans.GetBuffer(); var memoryStream = new MemoryStream(bytes); return(memoryStream); } }
public Base ConvertToDomain(TBase b) { return(new Base { IdBase = b.IdBase, Nombre = b.Nombre, Region = b.Region, Ciudad = b.Ciudad, Direccion = b.Direccion, NumeroTelefono = b.NumeroTelefono }); }
public Header HeaderLookup(TBase tbase) { if (tbase == null) { throw new Exception("tbase must not be null"); } if (tbase is TSpan) { return(SPAN_HEADER); } if (tbase is TSpanChunk) { return(SPANCHUNK_HEADER); } if (tbase is TSpanEvent) { return(SPANEVENT_HEADER); } if (tbase is TAgentInfo) { return(AGENT_INFO_HEADER); } if (tbase is TAgentStat) { return(AGENT_STAT_HEADER); } if (tbase is TAgentStatBatch) { return(AGENT_STAT_BATCH_HEADER); } if (tbase is TSqlMetaData) { return(SQLMETADATA_HEADER); } if (tbase is TApiMetaData) { return(APIMETADATA_HEADER); } if (tbase is TResult) { return(RESULT_HEADER); } if (tbase is TStringMetaData) { return(STRINGMETADATA_HEADER); } //if (tbase is NetworkAvailabilityCheckPacket) { // return NETWORK_CHECK_HEADER; //} throw new TException("Unsupported Type" + tbase.GetType()); }
public static int Serialize(byte messageType, TBase message, ref byte[] buffer) { long thriftLength = JThrift.Serialize(message, ref buffer, 4); short totalLength = (short) (thriftLength + 4); byte[] lengthBytes = System.BitConverter.GetBytes(totalLength); buffer[0] = lengthBytes[0]; buffer[1] = lengthBytes[1]; buffer[2] = (byte)messageType; return totalLength; }
/// <summary> /// serialize thrift msg to string /// </summary> /// <param name="tbase"></param> /// <returns></returns> public static string SerializeToBase64String(TBase tbase) { string szMsg = null; try { byte[] _bytes = Serialize(tbase); szMsg = Convert.ToBase64String(_bytes); } catch (Exception e) { Logger.LogError("SerializeToBase64String is exception, error : " + e.ToString()); } return szMsg; }
private ResponseMessage Decode(Stream responseStream) { ByteBuffer buffer = ByteBuffer.Allocate(512); byte[] tempBytes = new byte[256]; while (true) { int readLen = responseStream.Read(tempBytes, 0, tempBytes.Length); if (readLen <= 0) { break; } buffer.WriteBytes(tempBytes); } ResponseMessage responseMessage = new ResponseMessage(); responseMessage.MessageId = buffer.ReadInt(); responseMessage.StatusCode = HttpStatusCode.OK; TBase message = ThriftMessageHelper.GetResponseMessage(responseMessage.MessageId); if (message == null) { Debuger.LogError("don't support response messageId:" + responseMessage.MessageId); return(null); } byte[] headerBytes = new byte[buffer.ReadInt()]; buffer.ReadBytes(headerBytes, 0, headerBytes.Length); byte[] messageBytes = new byte[buffer.ReadInt()]; buffer.ReadBytes(messageBytes, 0, messageBytes.Length); byte[] eventListBytes = new byte[buffer.ReadInt()]; buffer.ReadBytes(eventListBytes, 0, eventListBytes.Length); responseMessage.Header = new Header(); ThriftSerialize.DeSerialize(responseMessage.Header, headerBytes); responseMessage.Message = message; ThriftSerialize.DeSerialize(message, messageBytes); responseMessage.EventList = new MEventList(); ThriftSerialize.DeSerialize(responseMessage.EventList, eventListBytes); return(responseMessage); }
public static void DeSerialize(TBase tbase, byte[] bytes) { if (tbase == null || bytes == null) { return; } using (Stream inputStream = new MemoryStream(64)) { inputStream.Write(bytes, 0, bytes.Length); inputStream.Position = 0; TStreamTransport transport = new TStreamTransport(inputStream, null); TProtocol protocol = new TCompactProtocol(transport); tbase.Read(protocol); } }
/// <summary> /// serialize thrift msg object to byte array /// </summary> /// <param name="tbase"></param> /// <returns></returns> public static byte[] Serialize(TBase tbase) { if (tbase == null) { return null; } OUTPUT_STREAM.Seek(0, SeekOrigin.Begin); OUTPUT_STREAM.SetLength(0); tbase.Write(SERIALIZE_PROTOCOL); byte[] bytes = new byte[OUTPUT_STREAM.Length]; OUTPUT_STREAM.Position = 0; OUTPUT_STREAM.Read(bytes, 0, bytes.Length); return bytes; }
public void TrySetConfig(string path, TBase value) { if (m_ConfigPool.ContainsKey(path)) { m_ConfigPool[path] = value; } else { m_ConfigPool.Add(path, value); } //save to file FileUtils.EnsureFolder(GetConfigPath() + path); byte[] buffer = ThriftSerialize.Serialize(value); FileUtils.WriteByteFile(GetConfigPath() + path, buffer); }
public static byte[] SerializeCompact(TBase tbase) { if (tbase == null) { return(null); } using (MemoryStream outputStream = new MemoryStream()) { TStreamTransport transport = new TStreamTransport(null, outputStream); TProtocol protocol = new TCompactProtocol(transport); tbase.Write(protocol); return(outputStream.ToArray()); } }
/// <summary> /// deSerialize msg data to thrift msg object /// </summary> /// <param name="tbase"></param> /// <param name="bytes"></param> public static void DeSerialize(TBase tbase, byte[] bytes) { if (tbase == null || bytes == null) { return; } INPUT_STREAM.Seek(0, SeekOrigin.Begin); INPUT_STREAM.SetLength(0); INPUT_STREAM.Write(bytes, 0, bytes.Length); INPUT_STREAM.Seek(0, SeekOrigin.Begin); tbase.Read(DESERIALIZE_PROTOCOL); }
public static string Serialize(TBase tbase) { if (tbase == null) { return(null); } using (MemoryStream outputStream = new MemoryStream()) { TStreamTransport transport = new TStreamTransport(null, outputStream); TProtocol protocol = new TJSONProtocol(transport); tbase.Write(protocol); return(Encoding.UTF8.GetString(outputStream.ToArray())); } }
public static void DeSerialize(TBase tbase, byte[] bytes) { if (tbase == null || bytes == null) { return; } using (Stream inputStream = new MemoryStream(64)) { inputStream.Write(bytes, 0, bytes.Length); inputStream.Position = 0; TStreamTransport transport = new TStreamTransport(inputStream, null); TProtocol protocol = new TJSONProtocol(transport); tbase.Read(protocol); } }
public T TryGetConfig <T>(string path) where T : class, TBase, new() { TBase config = null; if (m_ConfigPool.TryGetValue(path, out config)) { return(config as T); } T configInstance = default(T); if (ResourceManager.DecodePersonalDataTemplate <T>(GetConfigPath() + path, ref configInstance)) { m_ConfigPool.Add(path, configInstance); } return(configInstance); }
public static byte[] Serialize(TBase tbase) { if (tbase == null) { return null; } using (Stream outputStream = new MemoryStream(64)) { TStreamTransport transport = new TStreamTransport(null, outputStream); TProtocol protocol = new TCompactProtocol(transport); tbase.Write(protocol); byte[] bytes = new byte[outputStream.Length]; outputStream.Position = 0; outputStream.Read(bytes, 0, bytes.Length); return bytes; } }
public static void SendMessage(TBase msg, bool playLoadingWait = true) { lock (CSMsgQueue.SyncRoot) { CSMsgQueue.Enqueue(msg); //Throw the message sended event. if (OnMessageSended != null) { OnMessageSended(playLoadingWait); } } if (MsgThread.ThreadState == ThreadState.Unstarted) { MsgThread.Start(); } }
protected override void ReadImpl() { try { var contentLen = GetMsgLength() - MinMsgLen; if (contentLen <= 0) { return; } var contentBytes = ReadBytes(contentLen); ThriftMsgSerialize.DeSerialize(content, contentBytes); } catch (Exception ex) { content = null; Logger.LogError(ex.ToString()); } }
public static bool CanSupportMessage(TBase message) { return REQ_MSG_ID.ContainsKey(message.GetType()); }
public ThriftSCMessage(short msgType) { this.msgType = msgType; content = SCMessageHelper.createMessage(msgType); }
/// <summary> /// send msg to server /// </summary> /// <param name="msgContent"></param> public void SendMessage(TBase msgContent) { var msg = new ThriftCSMessage(msgContent); var bytes = msg.Encode(); if (bytes == null || bytes.Length <= 0) { Logger.LogError("send data is null or length is 0, msg type = " + msgContent.GetType().ToString()); return; } // TODO Encrypt Message Data StartSendMsg(bytes); }
public ThriftCSMessage(TBase content) { this.content = content; }
public void Send(Socket socket, byte messageType, TBase message) { int length = JThrift.Serialize(messageType, message, ref writeBuffer); Send(socket, writeBuffer, length); }
public void StartSendMsg(TBase msgContent) { if (null == socketClient || !socketClient.IsConnected()) return; Logger.LogError("send msg at time " + DateTime.Now + " : " + msgContent); socketClient.SendMessage(msgContent); }
void SendToAllPeers(byte messageType, TBase message) { foreach (KeyValuePair<int, JStateObject> state in peers) { int length = JThrift.Serialize(messageType, message, ref writeBuffer); Send(state.Value.workSocket, writeBuffer, length); break; } }
void OnNtfMatch(TBase message) { // Debug.Log("VirtualPlayer.OnNtfMatch \n" + message.ToString()); NtfMatch msg = message as NtfMatch; //Debug.Log(string.Format("{0} got a match. localId({1}), \n{2}", ansLogin.NickName, msg.LocalId, message.ToString())); nation = msg.LocalId == 0 ? JgNation.kCho : JgNation.kHan; localId = msg.LocalId; this.Invoke("SendSangcharim", 1f); }
public void SendMessageToServer(JgC2S_Msgs messageType, TBase message) { if (transport.IsBound() == false) return; Debug.Log(string.Format("C({0}): ->S ({1}) - {2} \n", dbgUserName, messageType, message)); int length = JThrift.Serialize((byte)messageType, message, ref writeBuffer); transport.Write(writeBuffer, length); }
public void WriteToServer(JgC2S_Msgs messageType, TBase message, Action<TBase> callback) { if (transport.IsBound() == false) return; int messageIndex = (int)messageType; messageCallbacks[messageIndex] = callback; SendMessageToServer(messageType, message); }
/// <summary> /// deserializ string msg data to thrift msg object /// </summary> /// <param name="tbase"></param> /// <param name="szMsg"></param> public static void DeSerializeFromBase64String(TBase tbase, string szMsg) { try { byte[] _bytes = Convert.FromBase64String(szMsg); DeSerialize(tbase, _bytes); } catch (Exception e) { Logger.LogError("DeSerializeFromBase64String is exception, error : " + e.ToString()); } }
public static void SaveData(TBase data, string savePath) { byte[] fileData = ThriftSerialize.Serialize(data); FileUtils.WriteByteFile(savePath,fileData); }
public static void Deserialize(byte[] buffer, TBase message) { MemoryStream inputStream = new MemoryStream(buffer); TStreamTransport transport = new TStreamTransport(inputStream, null); TBinaryProtocol binaryProtocol = new TBinaryProtocol(transport); message.Read(binaryProtocol); }