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[] { });
}
