public Msg ReplyFromServer() { try { lock (ContainerLock()) { IReflectClass claxx = SystemTransaction().Reflector().ForName(ReadString()); if (claxx != null) { ClassMetadata classMetadata = Container().ProduceClassMetadata(claxx); if (classMetadata != null) { Container().CheckStillToSet(); StatefulBuffer returnBytes = Container().ReadStatefulBufferById(SystemTransaction (), classMetadata.GetID()); MsgD createdClass = Msg.ObjectToClient.GetWriter(returnBytes); return(createdClass); } } } } catch (Db4oException) { } // TODO: send the exception to the client return(Msg.Failed); }
public virtual Msg GetWriter(Transaction trans, ByteArrayBuffer bytes) { MsgD msg = GetWriterForLength(trans, bytes.Length()); msg._payLoad.Append(bytes._buffer); return(msg); }
public void ProcessAtServer() { IServerMessageDispatcher dispatcher = (IServerMessageDispatcher)MessageDispatcher (); int count = ReadInt(); Transaction ta = Transaction(); for (int i = 0; i < count; i++) { StatefulBuffer writer = _payLoad.ReadStatefulBuffer(); int messageId = writer.ReadInt(); Msg message = Msg.GetMessage(messageId); Msg clonedMessage = message.PublicClone(); clonedMessage.SetMessageDispatcher(MessageDispatcher()); clonedMessage.SetTransaction(ta); if (clonedMessage is MsgD) { MsgD msgd = (MsgD)clonedMessage; msgd.PayLoad(writer); if (msgd.PayLoad() != null) { msgd.PayLoad().IncrementOffset(Const4.IntLength); Transaction t = CheckParentTransaction(ta, msgd.PayLoad()); msgd.SetTransaction(t); dispatcher.ProcessMessage(msgd); } } else { dispatcher.ProcessMessage(clonedMessage); } } }
public Db4objects.Db4o.CS.Internal.Messages.MsgD GetWriterForByte(Transaction trans , byte b) { Db4objects.Db4o.CS.Internal.Messages.MsgD msg = GetWriterForLength(trans, 1); msg._payLoad.WriteByte(b); return(msg); }
private MsgD WriteImmediateQueryResult(AbstractQueryResult queryResult, ObjectExchangeConfiguration config) { IIntIterator4 idIterator = queryResult.IterateIDs(); MsgD message = BuildQueryResultMessage(0, idIterator, queryResult.Size(), config); return(message); }
public Db4objects.Db4o.CS.Internal.Messages.MsgD GetWriterForInt(Transaction a_trans , int id) { Db4objects.Db4o.CS.Internal.Messages.MsgD message = GetWriterForLength(a_trans, Const4 .IntLength); message.WriteInt(id); return(message); }
public Db4objects.Db4o.CS.Internal.Messages.MsgD GetWriterForString(Transaction a_trans , string str) { Db4objects.Db4o.CS.Internal.Messages.MsgD message = GetWriterForLength(a_trans, Const4 .stringIO.Length(str) + Const4.IntLength); message.WriteString(str); return(message); }
public virtual Db4objects.Db4o.CS.Internal.Messages.MsgD GetWriter(StatefulBuffer bytes) { Db4objects.Db4o.CS.Internal.Messages.MsgD message = GetWriterForLength(bytes.Transaction (), bytes.Length()); message._payLoad.Append(bytes._buffer); return(message); }
public Db4objects.Db4o.CS.Internal.Messages.MsgD GetWriterForLong(Transaction a_trans , long a_long) { Db4objects.Db4o.CS.Internal.Messages.MsgD message = GetWriterForLength(a_trans, Const4 .LongLength); message.WriteLong(a_long); return(message); }
public Db4objects.Db4o.CS.Internal.Messages.MsgD GetWriterForBuffer(Transaction trans , ByteArrayBuffer buffer) { Db4objects.Db4o.CS.Internal.Messages.MsgD writer = GetWriterForLength(trans, buffer .Length()); writer.WriteBytes(buffer._buffer); return(writer); }
public sealed override MsgD GetWriter(StatefulBuffer bytes) { MsgD message = GetWriterForLength(bytes.Transaction(), bytes.Length() + Const4.IntLength ); message._payLoad.WriteInt(bytes.GetAddress()); message._payLoad.Append(bytes._buffer); return(message); }
private int AskServer(MsgD message, int param) { _client.Write(message.GetWriterForInts(_transaction, new[] { _queryResultID, param })); return ((MsgD) _client.ExpectedResponse(message)).ReadInt(); }
public virtual Db4objects.Db4o.CS.Internal.Messages.MsgD GetWriterForSingleObject (Transaction trans, object obj) { SerializedGraph serialized = Serializer.Marshall(trans.Container(), obj); Db4objects.Db4o.CS.Internal.Messages.MsgD msg = GetWriterForLength(trans, serialized .MarshalledLength()); serialized.Write(msg._payLoad); return(msg); }
public Db4objects.Db4o.CS.Internal.Messages.MsgD GetWriterForLongs(Transaction trans , long[] longs) { Db4objects.Db4o.CS.Internal.Messages.MsgD message = GetWriterForLength(trans, Const4 .LongLength * longs.Length); for (int i = 0; i < longs.Length; i++) { message.WriteLong(longs[i]); } return(message); }
public Db4objects.Db4o.CS.Internal.Messages.MsgD GetWriterForInts(Transaction trans , int[] ints) { Db4objects.Db4o.CS.Internal.Messages.MsgD message = GetWriterForLength(trans, Const4 .IntLength * ints.Length); for (int i = 0; i < ints.Length; i++) { message.WriteInt(ints[i]); } return(message); }
public virtual Db4objects.Db4o.CS.Internal.Messages.MsgD GetWriterForIntSequence( Transaction trans, int length, IEnumerator iterator) { Db4objects.Db4o.CS.Internal.Messages.MsgD message = GetWriterForLength(trans, Const4 .IntLength * (length + 1)); message.WriteInt(length); while (iterator.MoveNext()) { message.WriteInt(((int)iterator.Current)); } return(message); }
private MsgD BuildQueryResultMessage(int queryResultId, IIntIterator4 ids, int maxCount , ObjectExchangeConfiguration config) { ByteArrayBuffer payload = ObjectExchangeStrategyFactory.ForConfig(config).Marshall ((LocalTransaction)Transaction(), ids, maxCount); MsgD message = QueryResult.GetWriterForLength(Transaction(), Const4.IntLength + payload .Length()); StatefulBuffer writer = message.PayLoad(); writer.WriteInt(queryResultId); writer.WriteBytes(payload._buffer); return(message); }
internal sealed override Msg ReadPayLoad(IMessageDispatcher messageDispatcher, Transaction a_trans, Socket4Adapter sock, ByteArrayBuffer reader) { int length = reader.ReadInt(); a_trans = CheckParentTransaction(a_trans, reader); Db4objects.Db4o.CS.Internal.Messages.MsgD command = (Db4objects.Db4o.CS.Internal.Messages.MsgD )PublicClone(); command.SetTransaction(a_trans); command.SetMessageDispatcher(messageDispatcher); command._payLoad = ReadMessageBuffer(a_trans, sock, length); return(command); }
private MsgD WriteLazyQueryResult(AbstractQueryResult queryResult, ObjectExchangeConfiguration config) { int queryResultId = GenerateID(); int maxCount = Config().PrefetchObjectCount(); IIntIterator4 idIterator = queryResult.IterateIDs(); MsgD message = BuildQueryResultMessage(queryResultId, idIterator, maxCount, config ); IServerMessageDispatcher serverThread = ServerMessageDispatcher(); serverThread.MapQueryResultToID(new LazyClientObjectSetStub(queryResult, idIterator ), queryResultId); return(message); }
public Msg ReplyFromServer() { ByteArrayBuffer bytes = GetByteLoad(); int classMetadataID = bytes.ReadInt(); int prefetchDepth = bytes.ReadInt(); int prefetchCount = bytes.ReadInt(); bool triggerQueryEvents = bytes.ReadInt() == 1; ByteArrayBuffer payload = MarshallIDsFor(classMetadataID, prefetchDepth, prefetchCount , triggerQueryEvents); MsgD message = Msg.IdList.GetWriterForLength(Transaction(), payload.Length()); message.PayLoad().WriteBytes(payload._buffer); return(message); }
public Msg ReplyFromServer() { int prefetchIDCount = ReadInt(); MsgD reply = Msg.IdList.GetWriterForLength(Transaction(), Const4.IntLength * prefetchIDCount ); lock (ContainerLock()) { ITransactionalIdSystem idSystem = Transaction().IdSystem(); for (int i = 0; i < prefetchIDCount; i++) { reply.WriteInt(idSystem.PrefetchID()); } } return(reply); }
public virtual Msg ReplyFromServer() { int queryResultID = ReadInt(); int fetchSize = ReadInt(); int fetchDepth = ReadInt(); MsgD message = null; lock (ContainerLock()) { IIntIterator4 idIterator = Stub(queryResultID).IdIterator(); ByteArrayBuffer payload = ObjectExchangeStrategyFactory.ForConfig(new ObjectExchangeConfiguration (fetchDepth, fetchSize)).Marshall((LocalTransaction)Transaction(), idIterator, fetchSize ); message = IdList.GetWriterForBuffer(Transaction(), payload); } return(message); }
public Db4objects.Db4o.CS.Internal.Messages.MsgD GetWriterForLength(Transaction trans , int length) { Db4objects.Db4o.CS.Internal.Messages.MsgD message = (Db4objects.Db4o.CS.Internal.Messages.MsgD )PublicClone(); message.SetTransaction(trans); message._payLoad = new StatefulBuffer(trans, length + Const4.MessageLength); message.WriteInt(_msgID); message.WriteInt(length); if (trans.ParentTransaction() == null) { message._payLoad.WriteByte(Const4.SystemTrans); } else { message._payLoad.WriteByte(Const4.UserTrans); } return(message); }
internal MsgD GetWriter(Transaction trans, Pointer4 pointer, ByteArrayBuffer buffer , int[] prependInts) { int lengthNeeded = buffer.Length() + LengthForFirst; if (prependInts != null) { lengthNeeded += (prependInts.Length * Const4.IntLength); } MsgD message = GetWriterForLength(trans, lengthNeeded); if (prependInts != null) { for (int i = 0; i < prependInts.Length; i++) { message._payLoad.WriteInt(prependInts[i]); } } AppendPayLoad(message._payLoad, pointer, buffer); return(message); }
public Msg ReplyFromServer() { lock (ContainerLock()) { try { // Since every new Client reads the class // collection from the file, we have to // make sure, it has been written. Container().ClassCollection().Write(Transaction()); } catch (Exception) { } } MsgD message = Msg.GetClasses.GetWriterForLength(Transaction(), Const4.IntLength + 1); ByteArrayBuffer writer = message.PayLoad(); writer.WriteInt(Container().ClassCollection().GetID()); writer.WriteByte(Container().StringIO().EncodingByte()); return(message); }
private void AssertNonRecoverableExceptionForMessage(MsgD message, Exception throwable ) { // Make sure the ClassMetadata of the exception is in the // ObjectContainer otherwise we get side effects from producing it. var reflectClass = Client().Reflector().ForClass(throwable.GetType()); Client().ProduceClassMetadata(reflectClass); _storage.SyncAllowed(false); Client().Write(message.GetWriterForSingleObject(Trans(), throwable)); AssertDatabaseClosedException(); AssertServerContainerStateClosed(true); }
private void AssertPrefetchingBehaviorFor(IQuery query, MsgD expectedFirstMessage ) { StoreFlatItemGraph(); Client().Config().PrefetchObjectCount(2); Client().Config().PrefetchDepth(1); AssertQueryIterationProtocol(query, expectedFirstMessage, new[] { new Stimulus(new MsgD[] {}), new Stimulus (new MsgD[] {}), new Stimulus(new MsgD[] { Msg.ReadMultipleObjects }), new Stimulus(new MsgD[] {}), new Stimulus (new MsgD[] {Msg.ReadMultipleObjects}) }); }
private void AssertQueryIterationProtocol(IQuery query, MsgD expectedResultMessage , Stimulus[] stimuli) { var messages = MessageCollector.ForServerDispatcher(ServerDispatcher()); var result = query.Execute(); AssertMessages(messages, new IMessage[] {expectedResultMessage}); messages.Clear(); for (var stimulusIndex = 0; stimulusIndex < stimuli.Length; ++stimulusIndex) { var stimulus = stimuli[stimulusIndex]; stimulus.ActUpon(result); AssertMessages(messages, stimulus.expectedMessagesAfter); messages.Clear(); } if (result.HasNext()) { Assert.Fail("Unexpected item: " + ((Item) result.Next ())); } AssertMessages(messages, new IMessage[] {}); }
public Depth2Stimulus(PrefetchConfigurationTestCase _enclosing, MsgD[] expectedMessagesAfter ) : base(expectedMessagesAfter) { this._enclosing = _enclosing; }
public Stimulus(MsgD[] expectedMessagesAfter) { this.expectedMessagesAfter = expectedMessagesAfter; }
private void AssertQueryIterationProtocol(IQuery query, MsgD expectedResultMessage , PrefetchConfigurationTestCase.Stimulus[] stimuli) { IList messages = MessageCollector.ForServerDispatcher(ServerDispatcher()); IObjectSet result = query.Execute(); AssertMessages(messages, new IMessage[] { expectedResultMessage }); messages.Clear(); for (int stimulusIndex = 0; stimulusIndex < stimuli.Length; ++stimulusIndex) { PrefetchConfigurationTestCase.Stimulus stimulus = stimuli[stimulusIndex]; stimulus.ActUpon(result); AssertMessages(messages, stimulus.expectedMessagesAfter); messages.Clear(); } if (result.HasNext()) { Assert.Fail("Unexpected item: " + ((PrefetchConfigurationTestCase.Item)result.Next ())); } AssertMessages(messages, new IMessage[] { }); }