public void postMessage(UInt64 connID, BufferT msgBuff)
{
//auto f = connections.find(connID);
//assert(f != connections.end());
//auto & conn = f->second;
ClientConnection conn = connections[connID];
Debug.Assert(conn.ref_id_at_client == connID); // self-consistency
BufferT buff = platform.makeBuffer();
IPublishableComposer composer = platform.makePublishableComposer(buff);
PublishableStateMessageHeader mh = new PublishableStateMessageHeader();
mh.type = PublishableStateMessageHeader.MsgType.connectionMessage;
mh.priority = 0; // TODO: source
mh.state_type_id_or_direction = (UInt64)PublishableStateMessageHeader.ConnMsgDirection.toServer;
Debug.Assert(conn.ref_id_at_client == connID);
mh.ref_id_at_subscriber = conn.ref_id_at_client;
Debug.Assert(conn.ref_id_at_server != 0);
mh.ref_id_at_publisher = conn.ref_id_at_server;
GMQueue.helperComposePublishableStateMessageBegin(composer, mh);
ReadIteratorT riter = msgBuff.getReadIterator();
composer.appendRaw(riter);
GMQueue.helperComposePublishableStateMessageEnd(composer);
//assert(transport != nullptr);
transport.postMessage(buff);
}
public GMQTransport(GMQueue queue, string name_, SlotIdx idx_, UInt64 id_)
{
this.gmq = queue;
this.name = name_;
this.idx = idx_;
this.id = id_;
}
static MetaPool initializeGmQueue(MwsrThreadQueue msgQueue)
{
IPlatformSupport platform = new DefaultJsonPlatformSupport();
GMQueue gmq = new GMQueue();
gmq.initStateConcentratorFactory(new mtest.StateConcentratorFactory());
gmq.initPlatformSupport(platform);
gmq.initAuthority(String.Empty);
//BasicMtQueue<ThreadQueueItem> msgQueue = new BasicMtQueue<ThreadQueueItem>();
ThreadQueuePostman postMan = new ThreadQueuePostman(msgQueue, 1);
SlotIdx idx_;
UInt64 id_ = gmq.add("test_node", postMan, out idx_);
GMQTransport transport = new GMQTransport(gmq, "test_node", idx_, id_);
MetaPool mp = new MetaPool();
mp.setTransport(transport);
mp.setPlatform(platform);
return(mp);
}
public static void runNodeInThisThread(IPlatformSupport platform, GMQueue gmq, INodeFactory factory)
{
ThreadStartInfo info = new ThreadStartInfo();
info.platform = platform;
info.gmq = gmq;
info.factories = new INodeFactory[] { factory };
nodeThreadQueueMain(info);
}
public static void runNodeInAnotherThread(IPlatformSupport platform, GMQueue gmq, INodeFactory factory)
{
ThreadStartInfo info = new ThreadStartInfo();
info.platform = platform;
info.gmq = gmq;
info.factories = new INodeFactory[] { factory };
Thread th = new Thread(nodeThreadQueueMain);
th.Start(info);
}
static void Main(string[] args)
{
IPlatformSupport platform = new DefaultJsonPlatformSupport();
GMQueue gmq = new GMQueue();
gmq.initStateConcentratorFactory(new basic_test.StateConcentratorFactory());
gmq.initPlatformSupport(platform);
gmq.initAuthority("");
ThreadQueueManager.runNodeInAnotherThread(platform, gmq, new PublisherNodeFactory());
ThreadQueueManager.runNodeInThisThread(platform, gmq, new SubscriberNodeFactory());
}
public void onMessage(IPublishableParser parser)
{
PublishableStateMessageHeader mh = new PublishableStateMessageHeader();
GMQueue.helperParsePublishableStateMessageBegin(parser, ref mh);
switch (mh.type)
{
case PublishableStateMessageHeader.MsgType.connectionAccepted:
{
//auto f = connections.find(mh.ref_id_at_subscriber);
//if (f == connections.end())
// throw std::exception();
//auto & conn = f->second;
ClientConnection conn = connections[mh.ref_id_at_subscriber];
Debug.Assert(conn.ref_id_at_client == mh.ref_id_at_subscriber); // self-consistency
conn.ref_id_at_server = mh.ref_id_at_publisher;
//if (conn.connection->status != ConnectionT::Status::connRequestSent)
// throw std::exception(); // well, we have not requested connection yet
//conn.connection->status = ConnectionT::Status::connected;
conn.connection.setConnected();
conn.connection.onConnectionAccepted();
break;
}
case PublishableStateMessageHeader.MsgType.connectionMessage:
{
Debug.Assert(mh.state_type_id_or_direction == (ulong)PublishableStateMessageHeader.ConnMsgDirection.toClient);
//auto f = connections.find(mh.ref_id_at_subscriber);
//if (f == connections.end())
// throw std::exception();
//auto & conn = f->second;
ClientConnection conn = connections[mh.ref_id_at_subscriber];
if (!conn.connection.isConnected())
throw new Exception(); // TODO: revise
Debug.Assert(conn.ref_id_at_server == mh.ref_id_at_publisher); // self-consistency
//ReadIteratorT riter = parser.getIterator();
conn.connection.onMessage(parser.getIterator());
//parser = riter;
break;
}
default:
throw new Exception(); // TODO: ... (unknown msg type)
}
GMQueue.helperParsePublishableStateMessageEnd(parser);
}
public void connect(UInt64 connID, string path)
{
ClientConnection conn = connections[connID];
//assert(f != connections.end());
//auto & conn = f->second;
Debug.Assert(conn.ref_id_at_client == connID); // self-consistency
BufferT buff = platform.makeBuffer();
IPublishableComposer composer = platform.makePublishableComposer(buff);
PublishableStateMessageHeader mh = new PublishableStateMessageHeader();
mh.type = PublishableStateMessageHeader.MsgType.connectionRequest;
mh.priority = 0; // TODO: source
mh.state_type_id_or_direction = (UInt64)PublishableStateMessageHeader.ConnMsgDirection.toServer;
mh.path = path;
Debug.Assert(conn.ref_id_at_client == connID);
mh.ref_id_at_subscriber = conn.ref_id_at_client;
GMQueue.helperComposePublishableStateMessageBegin(composer, mh);
GMQueue.helperComposePublishableStateMessageEnd(composer);
transport.postMessage(buff);
conn.connection.setRequestSent();
}
void onMessage(IPublishableParser parser)
{
ReadIteratorT riter = parser.getIterator().shallowClone();
IPublishableParser parser1 = platform.makePublishableParser(riter);
PublishableStateMessageHeader mh = new PublishableStateMessageHeader();
GMQueue.helperParsePublishableStateMessageBegin(parser1, ref mh);
switch (mh.type)
{
case PublishableStateMessageHeader.MsgType.subscriptionResponse:
case PublishableStateMessageHeader.MsgType.stateUpdate:
subPool.onMessage(parser);
break;
case PublishableStateMessageHeader.MsgType.subscriptionRequest:
pubPool.onMessage(parser);
break;
case PublishableStateMessageHeader.MsgType.connectionRequest:
srvPool.onMessage(parser);
break;
case PublishableStateMessageHeader.MsgType.connectionAccepted:
cliPool.onMessage(parser);
break;
case PublishableStateMessageHeader.MsgType.connectionMessage:
switch ((PublishableStateMessageHeader.ConnMsgDirection)mh.state_type_id_or_direction)
{
case PublishableStateMessageHeader.ConnMsgDirection.toClient:
cliPool.onMessage(parser);
break;
case PublishableStateMessageHeader.ConnMsgDirection.toServer:
srvPool.onMessage(parser);
break;
default:
throw new Exception(); // TODO: ... (unknown msg type)
}
break;
default:
throw new Exception(); // TODO: ... (unknown msg type)
}
}
public void onMessage(IPublishableParser parser)
{
PublishableStateMessageHeader mh = new PublishableStateMessageHeader();
GMQueue.helperParsePublishableStateMessageBegin(parser, ref mh);
switch (mh.type)
{
case PublishableStateMessageHeader.MsgType.subscriptionResponse:
//if (mh.ref_id_at_subscriber >= subscribers.size())
// throw std::exception(); // TODO: ... (invalid ID)
subscribers[(int)(mh.ref_id_at_subscriber)].ref_id_at_publisher = mh.ref_id_at_publisher;
//if constexpr(ParserT::proto == globalmq::marshalling::Proto::JSON)
// subscribers[mh.ref_id_at_subscriber].subscriber->applyJsonStateSyncMessage(parser);
//else
//{
// static_assert(ParserT::proto == globalmq::marshalling::Proto::GMQ);
// subscribers[mh.ref_id_at_subscriber].subscriber->applyGmqStateSyncMessage(parser);
//}
subscribers[(int)mh.ref_id_at_subscriber].subscriber.applyStateSyncMessage(parser);
break;
case PublishableStateMessageHeader.MsgType.stateUpdate:
//if (mh.ref_id_at_subscriber >= subscribers.size())
// throw std::exception(); // TODO: ... (invalid ID)
// TODO: consider the following:
//if ( subscribers[mh.ref_id_at_subscriber].ref_id_at_publisher != mh.ref_id_at_publisher )
// throw std::exception(); // TODO: ... (invalid source)
//if constexpr(ParserT::proto == globalmq::marshalling::Proto::JSON)
// subscribers[mh.ref_id_at_subscriber].subscriber->applyJsonMessageWithUpdates(parser);
//else
//{
// static_assert(ParserT::proto == globalmq::marshalling::Proto::GMQ);
// subscribers[mh.ref_id_at_subscriber].subscriber->applyGmqMessageWithUpdates(parser);
//}
subscribers[(int)mh.ref_id_at_subscriber].subscriber.applyMessageWithUpdates(parser);
break;
default:
throw new Exception(); // TODO: ... (unknown msg type)
}
GMQueue.helperParsePublishableStateMessageEnd(parser);
}
public void subscribe(StateSubscriberBase subscriber, string path)
{
for (int i = 0; i < subscribers.Count; ++i)
if (subscribers[i].subscriber == subscriber)
{
BufferT buff = platform.makeBuffer();
IPublishableComposer composer = platform.makePublishableComposer(buff);
PublishableStateMessageHeader mh = new PublishableStateMessageHeader();
mh.type = PublishableStateMessageHeader.MsgType.subscriptionRequest;
mh.priority = 0; // TODO: source
mh.state_type_id_or_direction = subscriber.stateTypeID();
mh.path = path;
Debug.Assert(subscribers[i].ref_id_at_subscriber == (ulong)i);
mh.ref_id_at_subscriber = subscribers[i].ref_id_at_subscriber;
GMQueue.helperComposePublishableStateMessageBegin(composer, mh);
GMQueue.helperComposePublishableStateMessageEnd(composer);
//assert(transport != nullptr);
transport.postMessage(buff);
return;
}
Debug.Assert(false); // not found
}
public void onMessage(IPublishableParser parser)
{
PublishableStateMessageHeader mh = new PublishableStateMessageHeader();
GMQueue.helperParsePublishableStateMessageBegin(parser, ref mh);
switch (mh.type)
{
case PublishableStateMessageHeader.MsgType.connectionRequest:
{
GmqPathHelper.PathComponents pc = new GmqPathHelper.PathComponents();
pc.type = PublishableStateMessageHeader.MsgType.connectionRequest;
bool pathOK = GmqPathHelper.parse(mh.path, pc);
if (!pathOK)
throw new Exception(); // TODO: ... (bad path)
//auto f = connFactories.find(pc.statePublisherOrConnectionType);
//if (f == connFactories.end())
// throw std::exception(); // TODO: ... (no factory for conn name)
//auto & connFactory = *f->second;
IConnectionFactory connFactory = connFactories[pc.statePublisherOrConnectionType];
ServerConnection sc = new ServerConnection();
sc.connection = connFactory.create();
sc.ref_id_at_client = mh.ref_id_at_subscriber;
sc.ref_id_at_server = ++connIdxBase;
//sc.connection->pool = this;
//sc.connection->connID = sc.ref_id_at_server;
//sc.connection->status = ConnectionT::Status::connected;
sc.connection.setServerConnected(this, sc.ref_id_at_server);
/*auto ins = */
connections.Add(sc.ref_id_at_server, sc);
//assert(ins.second);
PublishableStateMessageHeader hdrBack = new PublishableStateMessageHeader();
hdrBack.type = PublishableStateMessageHeader.MsgType.connectionAccepted;
hdrBack.state_type_id_or_direction = (ulong)PublishableStateMessageHeader.ConnMsgDirection.toClient;
hdrBack.priority = mh.priority; // TODO: source?
hdrBack.ref_id_at_subscriber = mh.ref_id_at_subscriber;
hdrBack.ref_id_at_publisher = sc.ref_id_at_server;
BufferT msgBack = platform.makeBuffer();
IPublishableComposer composer = platform.makePublishableComposer(msgBack);
GMQueue.helperComposePublishableStateMessageBegin(composer, hdrBack);
GMQueue.helperComposePublishableStateMessageEnd(composer);
//assert(transport != nullptr);
transport.postMessage(msgBack);
break;
}
case PublishableStateMessageHeader.MsgType.connectionMessage:
{
Debug.Assert(mh.state_type_id_or_direction == (ulong)PublishableStateMessageHeader.ConnMsgDirection.toServer);
//auto f = connections.find(mh.ref_id_at_publisher);
//if (f == connections.end())
// throw std::exception();
//auto & conn = f->second;
ServerConnection conn = connections[mh.ref_id_at_publisher];
Debug.Assert(conn.ref_id_at_server == mh.ref_id_at_publisher); // self-consistency
//auto riter = parser.getIterator();
conn.connection.onMessage(parser.getIterator());
//parser = riter;
break;
}
default:
throw new Exception(); // TODO: ... (unknown msg type)
}
GMQueue.helperParsePublishableStateMessageEnd(parser);
}
