/// <param name="socket"></param> internal virtual Db4objects.Db4o.CS.Internal.Messages.Msg ReadPayLoad(IMessageDispatcher messageDispatcher, Db4objects.Db4o.Internal.Transaction a_trans, Socket4Adapter socket, ByteArrayBuffer reader) { Db4objects.Db4o.CS.Internal.Messages.Msg msg = PublicClone(); msg.SetMessageDispatcher(messageDispatcher); msg.SetTransaction(CheckParentTransaction(a_trans, reader)); return(msg); }
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception> public static Db4objects.Db4o.CS.Internal.Messages.Msg ReadMessage(IMessageDispatcher messageDispatcher, Db4objects.Db4o.Internal.Transaction trans, Socket4Adapter socket ) { StatefulBuffer reader = ReadMessageBuffer(trans, socket); Db4objects.Db4o.CS.Internal.Messages.Msg message = _messages[reader.ReadInt()].ReadPayLoad (messageDispatcher, trans, socket, reader); return(message); }
public void OnMessage(Msg msg) { if (msg is MQueryExecute) { this._enclosing.processingMessage = true; barrier.Add(new object()); Runtime4.Sleep(500); this._enclosing.processingMessage = false; } else { if (msg is MIsAlive) { Assert.IsFalse(this._enclosing.processingMessage); } } }
public void AddToBatch(Msg msg) { lock (Lock()) { _batchedMessages.Add(msg); // the first INT_LENGTH is for buffer.length, and then buffer content. _batchedQueueLength += Const4.IntLength + msg.PayLoad().Length(); } }
public virtual bool WriteMessageToSocket(Msg msg) { if (_messageListener != null) { _messageListener.OnMessage(msg); } return msg.Write(_socket); }
public void WriteMsg(Msg msg, bool flush) { if (_config.BatchMessages()) { if (flush && _batchedMessages.IsEmpty()) { // if there's nothing batched, just send this message directly WriteMessageToSocket(msg); } else { AddToBatch(msg); if (flush || _batchedQueueLength > _config.MaxBatchQueueSize()) { WriteBatchedMessages(); } } } else { if (!_batchedMessages.IsEmpty()) { AddToBatch(msg); WriteBatchedMessages(); } else { WriteMessageToSocket(msg); } } }
public void WriteBatchedMessage(Msg msg) { WriteMsg(msg, false); }
public virtual bool Write(Msg msg) { _container.Write(msg); return true; }
// null denotes password not necessary // initial value of _batchedQueueLength is // used for to write the number of messages. public void OnMessage(Msg msg) { }
private void CheckExceptionMessage(Msg msg) { if (msg is MRuntimeException) { ((MRuntimeException)msg).ThrowPayload(); } }
public virtual void Write(Db4objects.Db4o.CS.Internal.Messages.Msg msg) { _messageDispatcher.Write(msg); }
public bool Write(Msg msg) { lock (_lock) { if (!IsMessageDispatcherAlive()) { return false; } return msg.Write(_socket); } }
private void WriteException(Msg message, Exception exc) { if (!(message is IMessageWithResponse)) { Sharpen.Runtime.PrintStackTrace(exc); return; } if (!(exc is Exception)) { exc = new Db4oException(exc); } // Writing exceptions can produce ClassMetadata in // the main ObjectContainer. lock (_mainLock) { message.WriteException((Exception)exc); } }
public bool ProcessMessage(Msg message) { if (IsMessageDispatcherAlive()) { if (message is IMessageWithResponse) { IMessageWithResponse msgWithResp = (IMessageWithResponse)message; try { Msg reply = msgWithResp.ReplyFromServer(); Write(reply); } catch (Db4oRecoverableException exc) { WriteException(message, exc); return true; } catch (Exception t) { Sharpen.Runtime.PrintStackTrace(t); FatalShutDownServer(t); return false; } try { msgWithResp.PostProcessAtServer(); return true; } catch (Exception exc) { Sharpen.Runtime.PrintStackTrace(exc); } return true; } try { ((IServerSideMessage)message).ProcessAtServer(); return true; } catch (Db4oRecoverableException exc) { Sharpen.Runtime.PrintStackTrace(exc); return true; } catch (Exception t) { Sharpen.Runtime.PrintStackTrace(t); FatalShutDownServer(t); } } return false; }
internal ByteArrayBuffer ExpectedBufferResponse(Msg expectedMessage) { Msg msg = ExpectedResponse(expectedMessage); if (msg == null) { // TODO: throw Exception to allow // smooth shutdown return null; } return msg.GetByteLoad(); }
public Msg ExpectedResponse(Msg expectedMessage) { Msg message = GetResponse(); if (expectedMessage.Equals(message)) { return message; } CheckExceptionMessage(message); throw new InvalidOperationException("Unexpected Message:" + message + " Expected:" + expectedMessage); }
public virtual void BroadcastMsg(Msg message, IBroadcastFilter filter) { IEnumerator i = IterateDispatchers(); while (i.MoveNext()) { IServerMessageDispatcher dispatcher = (IServerMessageDispatcher)i.Current; if (filter.Accept(dispatcher)) { dispatcher.Write(message); } } }
private bool IsClientSideMessage(Msg message) { return message is IClientSideMessage; }
public void OnMessage(Msg msg) { messages.Add(msg); }
// do nothing public bool Write(Msg msg) { WriteMsg(msg, true); return true; }
public virtual void Write(Msg msg) { _messageDispatcher.Write(msg); }