/// <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();
}