/// <summary> /// It is guaranteed that CloudStorage can be accessed (server started) /// before a client calls module ClientInitialize() method. /// </summary> public unsafe void ClientInitialize(RunningMode remoteRunningMode, MemoryCloud mc) { m_memorycloud = mc; string moduleName = GetModuleName(); IMessagePassingEndpoint rs = remoteRunningMode == RunningMode.Server ? mc.StorageTable.FirstOrDefault(_ => !(_ is LocalMemoryStorage)) as IMessagePassingEndpoint : mc.ProxyList.FirstOrDefault(); if (null == rs) { string msg = "ClientInitialize: " + moduleName + ": No remote communication instance found."; Log.WriteLine(LogLevel.Error, msg); throw new InvalidOperationException(msg); } ushort synReqOffset; ushort synReqRspOffset; ushort asynReqOffset; ushort asynReqRspOffset; if (!rs.GetCommunicationModuleOffset(moduleName, out synReqOffset, out synReqRspOffset, out asynReqOffset, out asynReqRspOffset)) { string msg = "CommunicationModule " + moduleName + " not found on the remote side."; Log.WriteLine(LogLevel.Error, msg); throw new InvalidOperationException(msg); } else { this.SynReqIdOffset = synReqOffset; this.SynReqRspIdOffset = synReqRspOffset; this.AsynReqIdOffset = asynReqOffset; this.AsynReqRspIdOffset = asynReqRspOffset; } }
public RedirectedIStorage(IMessagePassingEndpoint ep, TrinityClient tc, int p) { m_ep = ep; m_comminst = tc; partitionId = p; m_mod = GetCommunicationModule <TrinityClientModule.TrinityClientModule>(); }
protected internal unsafe void SendMessage(IMessagePassingEndpoint endpoint, byte **buffers, int *sizes, int count, out TrinityResponse response) { byte b_msg_type = PointerHelper.GetByte(buffers, sizes, TrinityProtocol.MsgTypeOffset); PointerHelper.Add(buffers, sizes, TrinityProtocol.MsgIdOffset, m_MessageIdOffsets[b_msg_type]); endpoint.SendMessage(buffers, sizes, count, out response); }
internal static void BeginInitialize(IMessagePassingEndpoint ep, TrinityClient tc) { s_ep = ep; s_client = tc; s_redir_storages = new List <IStorage> { new PassThroughIStorage(ep) }; }
protected internal unsafe void SendMessage(IMessagePassingEndpoint endpoint, byte *buffer, int size) { var e_msg_type = *(TrinityMessageType *)(buffer + TrinityProtocol.MsgTypeOffset); *(ushort *)(buffer + TrinityProtocol.MsgIdOffset) += m_MessageIdOffsets[(int)e_msg_type]; endpoint.SendMessage(buffer, size); }
protected internal unsafe void SendMessage(IMessagePassingEndpoint endpoint, byte *buffer, int size, out TrinityResponse response) { byte b_msg_type = *(buffer + TrinityProtocol.MsgTypeOffset); *(ushort *)(buffer + TrinityProtocol.MsgIdOffset) += m_MessageIdOffsets[b_msg_type]; endpoint.SendMessage(buffer, size, out response); }
protected internal unsafe void SendMessage(IMessagePassingEndpoint endpoint, byte **buffers, int *sizes, int count) { var e_msg_type = PointerHelper.GetUshort(buffers, sizes, TrinityProtocol.MsgTypeOffset); PointerHelper.Add(buffers, sizes, TrinityProtocol.MsgIdOffset, m_MessageIdOffsets[e_msg_type]); endpoint.SendMessage(buffers, sizes, count); }
internal static bool GetCommunicationModuleOffset(this IMessagePassingEndpoint storage, string moduleName, out ushort synReqOffset, out ushort synReqRspOffset, out ushort asynReqOffset, out ushort asynReqRspOffset) { /****************** * Comm. protocol: * - REQUEST : [char_cnt, char[] moduleName] * - RESPONSE: [int synReqOffset, int synReqRspOffset, int asynReqOffset, int asynReqRspOffset] * An response error code other than E_SUCCESS indicates failure of remote module lookup. ******************/ using (TrinityMessage tm = new TrinityMessage( TrinityMessageType.PRESERVED_SYNC_WITH_RSP, (ushort)RequestType.GetCommunicationModuleOffsets, size: sizeof(int) + sizeof(char) * moduleName.Length)) { PointerHelper sp = PointerHelper.New(tm.Buffer + TrinityMessage.Offset); *sp.ip++ = moduleName.Length; BitHelper.WriteString(moduleName, sp.bp); TrinityResponse response = null; bool ret; try { storage.SendMessage(tm, out response); ret = (response.ErrorCode == TrinityErrorCode.E_SUCCESS); } catch (System.IO.IOException) { ret = false; } if (ret) { sp.bp = response.Buffer + response.Offset; int synReq_msg = *sp.ip++; int synReqRsp_msg = *sp.ip++; int asynReq_msg = *sp.ip++; int asynReqRsp_msg = *sp.ip++; synReqOffset = (ushort)synReq_msg; synReqRspOffset = (ushort)synReqRsp_msg; asynReqOffset = (ushort)asynReq_msg; asynReqRspOffset = (ushort)asynReqRsp_msg; } else { synReqOffset = 0; synReqRspOffset = 0; asynReqOffset = 0; asynReqRspOffset = 0; } response?.Dispose(); return(ret); } }
protected override void StartCommunicationListeners() { if (m_clientfactory == null) { ScanClientConnectionFactory(); } m_client = m_clientfactory.ConnectAsync(m_endpoint, this).Result; ClientMemoryCloud.Initialize(m_client, this); this.Started += StartPolling; }
internal static void Initialize(IMessagePassingEndpoint ep, TrinityClient tc) { s_ep = ep; s_client = tc; // during initialization, there's a single // PassThroughIStorage in our storage table. s_redir_storages = new List <IStorage> { new PassThroughIStorage(ep) }; }
public void RegisterClient() { // copy from initialization result m_client = s_client; m_ep = s_ep; m_cmod = m_client.GetCommunicationModule <TrinityClientModule.TrinityClientModule>(); m_cookie = m_cmod.MyCookie; using (var req = new RegisterClientRequestWriter(m_cmod.MyCookie)) using (var rsp = m_ep.RegisterClient(req)) { m_partitionCount = rsp.PartitionCount; m_instanceId = rsp.InstanceId; } // after initialization, we switch from pass-through storage // to redirecting storage. SetPartitionMethod(GetServerIdByCellIdDefault); m_redir_storages = Enumerable.Range(0, m_partitionCount).Select(p => new RedirectedIStorage(m_ep, m_client, p)).Cast <IStorage>().ToList(); }
internal static void GetCommunicationSchema(this IMessagePassingEndpoint storage, out string name, out string signature) { /****************** * Comm. protocol: * - REQUEST : VOID * - RESPONSE: [char_cnt, char[] name, char_cnt, char[] sig] ******************/ using (TrinityMessage tm = new TrinityMessage( TrinityMessageType.PRESERVED_SYNC_WITH_RSP, (ushort)RequestType.GetCommunicationSchema, size: 0)) { TrinityResponse response; storage.SendMessage(tm, out response); PointerHelper sp = PointerHelper.New(response.Buffer + response.Offset); int name_string_len = *sp.ip++; name = BitHelper.GetString(sp.bp, name_string_len * 2); sp.cp += name_string_len; int sig_string_len = *sp.ip++; signature = BitHelper.GetString(sp.bp, sig_string_len * 2); response.Dispose(); } }
protected internal new unsafe void SendMessage(IMessagePassingEndpoint ep, byte **bufs, int *sizes, int cnt, out TrinityResponse rsp) => base.SendMessage(ep, bufs, sizes, cnt, out rsp);
public static void SendMessage <T>(this IMessagePassingEndpoint storage, byte **message, int *sizes, int count, out TrinityResponse response) where T : CommunicationModule { storage.GetCommunicationModule <T>().SendMessage(storage, message, sizes, count, out response); }
public static void SendMessage <T>(this IMessagePassingEndpoint storage, byte *message, int size) where T : CommunicationModule { storage.GetCommunicationModule <T>().SendMessage(storage, message, size); }
public static void SendMessage(this IMessagePassingEndpoint storage, TrinityMessage message, out TrinityResponse response) { storage.SendMessage(message.Buffer, message.Size, out response); }
protected internal unsafe new void SendMessage(IMessagePassingEndpoint ep, byte *buf, int size, out TrinityResponse rsp) => base.SendMessage(ep, buf, size, out rsp);
protected internal unsafe new void SendMessage(IMessagePassingEndpoint ep, byte **bufs, int *sizes, int cnt) => base.SendMessage(ep, bufs, sizes, cnt);
public Task DisconnectAsync(IMessagePassingEndpoint endpoint) { var cc = endpoint as DefaultClientConnection; return(Task.Run(() => cc.Dispose())); }
protected unsafe void SendMessage(IMessagePassingEndpoint messagePassingEndpoint, byte *buffer, int v) { throw new NotImplementedException(); }
/// <summary> /// /// </summary> /// <param name="endpoint"></param> /// <returns></returns> public Task DisconnectAsync(IMessagePassingEndpoint endpoint) { return(Task.FromResult(true)); }
public PassThroughIStorage(IMessagePassingEndpoint ep) { this.m_ep = ep; }
internal static Task <t_protocol_responseReader> t_protocol_name_3(IMessagePassingEndpoint messagePassingEndpoint, t_protocol_requestWriter msg) { throw new NotImplementedException(); }
internal static void t_protocol_name(IMessagePassingEndpoint messagePassingEndpoint, t_protocol_requestWriter msg) { throw new NotImplementedException(); }
internal static t_protocol_responseReader t_protocol_name_2(IMessagePassingEndpoint messagePassingEndpoint) { throw new NotImplementedException(); }