public override void HandleResponse(Message.Message requestMessage, PeerConnection peerConnection, bool sign, IResponder responder)
{
if (!(requestMessage.Type == Message.Message.MessageType.RequestFf1 && requestMessage.Command == Rpc.Commands.Quit.GetNr()))
{
throw new ArgumentException("Message content is wrong for this handler.");
}
Logger.Debug("Received QUIT message {0}.", requestMessage);
lock (PeerBean.PeerStatusListeners)
{
foreach (var listener in PeerBean.PeerStatusListeners)
{
listener.PeerFailed(requestMessage.Sender,
new PeerException(PeerException.AbortCauseEnum.Shutdown, "shutdown"));
}
}
if (requestMessage.IsUdp)
{
responder.ResponseFireAndForget();
}
else
{
responder.Response(CreateResponseMessage(requestMessage, Message.Message.MessageType.Ok));
}
}
void StatusCreated(Twitterizer.TwitterStatus status)
{
string response = keywordResponder.Response(status.Text);
if (!string.IsNullOrEmpty(response))
{
client.Reply(status, response);
}
else
{
if (System.Text.RegularExpressions.Regex.IsMatch(status.Text, "^@meitanbot"))
{
client.Reply(status, replaceResponder.Response(null, status.User.Id));
}
}
}
public override void HandleResponse(Message requestMessage, PeerConnection peerConnection, bool sign,
IResponder responder)
{
var responseMessage = CreateResponseMessage(requestMessage, Message.MessageType.Ok);
if (requestMessage.Command == Rpc.Commands.Add.GetNr())
{
HandleAdd(requestMessage, responseMessage, IsDomainProtected(requestMessage));
}
else if (requestMessage.Command == Rpc.Commands.Put.GetNr() ||
requestMessage.Command == Rpc.Commands.ReplicaPut.GetNr())
{
HandlePut(requestMessage, responseMessage, IsStoreIfAbsent(requestMessage),
IsDomainProtected(requestMessage), IsReplicaPut(requestMessage));
}
else if (requestMessage.Command == Rpc.Commands.PutConfirm.GetNr())
{
HandlePutConfirm(requestMessage, responseMessage);
}
else if (requestMessage.Command == Rpc.Commands.Get.GetNr())
{
HandleGet(requestMessage, responseMessage);
}
else if (requestMessage.Command == Rpc.Commands.GetLatest.GetNr())
{
HandleGetLatest(requestMessage, responseMessage, false);
}
else if (requestMessage.Command == Rpc.Commands.GetLatestWithDigest.GetNr())
{
HandleGetLatest(requestMessage, responseMessage, true);
}
else if (requestMessage.Command == Rpc.Commands.Digest.GetNr() ||
requestMessage.Command == Rpc.Commands.DigestBloomfilter.GetNr() ||
requestMessage.Command == Rpc.Commands.DigestMetaValues.GetNr() ||
requestMessage.Command == Rpc.Commands.DigestAllBloomfilter.GetNr())
{
HandleDigest(requestMessage, responseMessage);
}
else if (requestMessage.Command == Rpc.Commands.Remove.GetNr())
{
HandleRemove(requestMessage, responseMessage,
requestMessage.Type == Message.MessageType.Request2);
}
else if (requestMessage.Command == Rpc.Commands.PutMeta.GetNr())
{
HandlePutMeta(requestMessage, responseMessage,
requestMessage.Type == Message.MessageType.Request2);
}
else
{
throw new ArgumentException($"Message content is wrong {requestMessage.Command}.");
}
if (sign)
{
responseMessage.SetPublicKeyAndSign(PeerBean.KeyPair);
}
Logger.Debug("Response for storage request: {0}.", responseMessage);
responder.Response(responseMessage);
}
public override void HandleResponse(Message.Message requestMessage, PeerConnection peerConnection, bool sign, IResponder responder)
{
if (!(requestMessage.Type == Message.Message.MessageType.RequestFf1 &&
requestMessage.Command == Rpc.Commands.Broadcast.GetNr()))
{
throw new ArgumentException("Message content is wrong for this handler.");
}
Logger.Debug("Received BROADCAST message: {0}.", requestMessage);
BroadcastHandler.Receive(requestMessage);
if (requestMessage.IsUdp)
{
responder.ResponseFireAndForget();
}
else
{
responder.Response(CreateResponseMessage(requestMessage, Message.Message.MessageType.Ok));
}
}
public override void HandleResponse(Message.Message requestMessage, PeerConnection peerConnection, bool sign, IResponder responder)
{
if (!(requestMessage.Type == Message.Message.MessageType.RequestFf1
&& requestMessage.Command == Rpc.Commands.Broadcast.GetNr()))
{
throw new ArgumentException("Message content is wrong for this handler.");
}
Logger.Debug("Received BROADCAST message: {0}.", requestMessage);
BroadcastHandler.Receive(requestMessage);
if (requestMessage.IsUdp)
{
responder.ResponseFireAndForget();
}
else
{
responder.Response(CreateResponseMessage(requestMessage, Message.Message.MessageType.Ok));
}
}
public override void HandleResponse(Message.Message requestMessage, PeerConnection peerConnection, bool sign, IResponder responder)
{
if (!(requestMessage.Type == Message.Message.MessageType.RequestFf1 && requestMessage.Command == Rpc.Commands.Quit.GetNr()))
{
throw new ArgumentException("Message content is wrong for this handler.");
}
Logger.Debug("Received QUIT message {0}.", requestMessage);
lock (PeerBean.PeerStatusListeners)
{
foreach (var listener in PeerBean.PeerStatusListeners)
{
listener.PeerFailed(requestMessage.Sender,
new PeerException(PeerException.AbortCauseEnum.Shutdown, "shutdown"));
}
}
if (requestMessage.IsUdp)
{
responder.ResponseFireAndForget();
}
else
{
responder.Response(CreateResponseMessage(requestMessage, Message.Message.MessageType.Ok));
}
}
public override void HandleResponse(Message.Message requestMessage, PeerConnection peerConnection, bool sign, IResponder responder)
{
if (requestMessage.KeyList.Count < 2)
{
throw new ArgumentException("At least location and domain keys are needed.");
}
if (!(requestMessage.Type == Message.Message.MessageType.Request1 ||
requestMessage.Type == Message.Message.MessageType.Request2 ||
requestMessage.Type == Message.Message.MessageType.Request3 ||
requestMessage.Type == Message.Message.MessageType.Request4) &&
(requestMessage.Command == Rpc.Commands.Neighbor.GetNr()))
{
throw new ArgumentException("Message content is wrong for this handler.");
}
Number160 locationKey = requestMessage.Key(0);
Number160 domainKey = requestMessage.Key(1);
var neighbors = GetNeighbors(locationKey, NeighborSize);
if (neighbors == null)
{
// return empty neighbor set
var response = CreateResponseMessage(requestMessage, Message.Message.MessageType.NotFound);
response.SetNeighborSet(new NeighborSet(-1, new Collection <PeerAddress>()));
responder.Response(response);
return;
}
// create response message and set neighbors
var responseMessage = CreateResponseMessage(requestMessage, Message.Message.MessageType.Ok);
Logger.Debug("Found the following neighbors: {0}.", Convenient.ToString(neighbors));
var neighborSet = new NeighborSet(NeighborLimit, neighbors);
responseMessage.SetNeighborSet(neighborSet);
Number160 contentKey = requestMessage.Key(2);
var keyBloomFilter = requestMessage.BloomFilter(0);
var contentBloomFilter = requestMessage.BloomFilter(1);
var keyCollection = requestMessage.KeyCollection(0);
// it is important to set an integer if a value is present
bool isDigest = requestMessage.Type != Message.Message.MessageType.Request1;
if (isDigest)
{
if (requestMessage.Type == Message.Message.MessageType.Request2)
{
DigestInfo digestInfo;
if (PeerBean.DigestStorage == null)
{
// no storage to search
digestInfo = new DigestInfo();
}
else if (contentKey != null && locationKey != null && domainKey != null)
{
var locationAndDomainKey = new Number320(locationKey, domainKey);
var from = new Number640(locationAndDomainKey, contentKey, Number160.Zero);
var to = new Number640(locationAndDomainKey, contentKey, Number160.MaxValue);
digestInfo = PeerBean.DigestStorage.Digest(from, to, -1, true);
}
else if ((keyBloomFilter != null || contentBloomFilter != null) && locationKey != null && domainKey != null)
{
var locationAndDomainKey = new Number320(locationKey, domainKey);
digestInfo = PeerBean.DigestStorage.Digest(locationAndDomainKey, keyBloomFilter,
contentBloomFilter, -1, true, true);
}
else if (keyCollection != null && keyCollection.Keys.Count == 2)
{
var enumerator = keyCollection.Keys.GetEnumerator();
var from = enumerator.MoveNext() ? enumerator.Current : null; // TODO works correctly?
var to = enumerator.MoveNext() ? enumerator.Current : null;
digestInfo = PeerBean.DigestStorage.Digest(from, to, -1, true);
}
else if (locationKey != null && domainKey != null)
{
var locationAndDomainKey = new Number320(locationKey, domainKey);
var from = new Number640(locationAndDomainKey, Number160.Zero, Number160.Zero);
var to = new Number640(locationAndDomainKey, Number160.MaxValue, Number160.MaxValue);
digestInfo = PeerBean.DigestStorage.Digest(from, to, -1, true);
}
else
{
Logger.Warn("Did not search for anything.");
digestInfo = new DigestInfo();
}
responseMessage.SetIntValue(digestInfo.Size);
responseMessage.SetKey(digestInfo.KeyDigest);
responseMessage.SetKey(digestInfo.ContentDigest);
}
else if (requestMessage.Type == Message.Message.MessageType.Request3)
{
DigestInfo digestInfo;
if (PeerBean.DigestTracker == null)
{
// no tracker to search
digestInfo = new DigestInfo();
}
else
{
digestInfo = PeerBean.DigestTracker.Digest(locationKey, domainKey, contentKey);
if (digestInfo.Size == 0)
{
Logger.Debug("No entry found on peer {0}.", requestMessage.Recipient);
}
}
responseMessage.SetIntValue(digestInfo.Size);
}
else if (requestMessage.Type == Message.Message.MessageType.Request4)
{
lock (PeerBean.PeerStatusListeners)
{
foreach (var listener in PeerBean.PeerStatusListeners)
{
listener.PeerFailed(requestMessage.Sender,
new PeerException(PeerException.AbortCauseEnum.Shutdown, "shutdown"));
}
}
}
}
responder.Response(responseMessage);
}
public override void HandleResponse(Message.Message requestMessage, PeerConnection peerConnection, bool sign, IResponder responder)
{
// server-side:
// comes from DispatchHandler
// IResponder now responds the result...
if (!((requestMessage.Type == Message.Message.MessageType.RequestFf1 ||
requestMessage.Type == Message.Message.MessageType.Request1 ||
requestMessage.Type == Message.Message.MessageType.Request2 ||
requestMessage.Type == Message.Message.MessageType.Request3 ||
requestMessage.Type == Message.Message.MessageType.Request3) &&
requestMessage.Command == Rpc.Commands.Ping.GetNr()))
{
throw new ArgumentException("Request message type or command is wrong for this handler.");
}
Message.Message responseMessage;
// probe
if (requestMessage.Type == Message.Message.MessageType.Request3)
{
Logger.Debug("Respond to probing. Firing message to {0}.", requestMessage.Sender);
responseMessage = CreateResponseMessage(requestMessage, Message.Message.MessageType.Ok);
if (requestMessage.IsUdp)
{
ConnectionBean.Reservation.CreateAsync(1, 0).ContinueWith(t =>
{
if (!t.IsFaulted)
{
Logger.Debug("Fire UDP to {0}.", requestMessage.Sender);
var taskResponse = FireUdpAsync(requestMessage.Sender, t.Result,
ConnectionBean.ChannelServer.ChannelServerConfiguration);
Utils.Utils.AddReleaseListener(t.Result, taskResponse);
}
else
{
Utils.Utils.AddReleaseListener(t.Result);
Logger.Warn("Handling response for Request3 failed. (UDP) {0}", t.Exception);
}
});
}
else
{
ConnectionBean.Reservation.CreateAsync(0, 1).ContinueWith(t =>
{
if (!t.IsFaulted)
{
Logger.Debug("Fire TCP to {0}.", requestMessage.Sender);
var taskResponse = FireTcpAsync(requestMessage.Sender, t.Result,
ConnectionBean.ChannelServer.ChannelServerConfiguration);
Utils.Utils.AddReleaseListener(t.Result, taskResponse);
}
else
{
Utils.Utils.AddReleaseListener(t.Result);
Logger.Warn("Handling response for Request3 failed. (TCP) {0}", t.Exception);
}
});
}
}
// discover
else if (requestMessage.Type == Message.Message.MessageType.Request2)
{
Logger.Debug("Respond to discovering. Found {0}.", requestMessage.Sender);
responseMessage = CreateResponseMessage(requestMessage, Message.Message.MessageType.Ok);
responseMessage.SetNeighborSet(CreateNeighborSet(requestMessage.Sender));
}
// regular ping
else if (requestMessage.Type == Message.Message.MessageType.Request1 ||
requestMessage.Type == Message.Message.MessageType.Request4)
{
Logger.Debug("Respond to regular ping from {0}.", requestMessage.Sender);
// Test, if this is a broadcast message to ourselves.
// If it is, do not reply.
if (requestMessage.IsUdp &&
requestMessage.Sender.PeerId.Equals(PeerBean.ServerPeerAddress.PeerId) &&
requestMessage.Recipient.PeerId.Equals(Number160.Zero))
{
Logger.Warn("Don't respond. We are on the same peer, you should make this call.");
responder.ResponseFireAndForget();
}
if (_enable)
{
responseMessage = CreateResponseMessage(requestMessage, Message.Message.MessageType.Ok);
if (_wait)
{
Thread.Sleep(WaitTime);
}
}
else
{
Logger.Debug("Don't respond.");
// used for debugging
if (_wait)
{
Thread.Sleep(WaitTime);
}
return;
}
if (requestMessage.Type == Message.Message.MessageType.Request4)
{
lock (_receivedBroadcastPingListeners)
{
foreach (IPeerReceivedBroadcastPing listener in _receivedBroadcastPingListeners)
{
listener.BroadcastPingReceived(requestMessage.Sender);
}
}
}
}
else
{
// fire-and-forget if requestMessage.Type == MessageType.RequestFf1
// we received a fire-and forget ping
// this means we are reachable from the outside
PeerAddress serverAddress = PeerBean.ServerPeerAddress;
if (requestMessage.IsUdp)
{
// UDP
PeerAddress newServerAddress = serverAddress.ChangeIsFirewalledUdp(false);
PeerBean.SetServerPeerAddress(newServerAddress);
lock (_reachableListeners)
{
foreach (IPeerReachable listener in _reachableListeners)
{
listener.PeerWellConnected(newServerAddress, requestMessage.Sender, false);
}
}
responseMessage = requestMessage;
}
else
{
// TCP
PeerAddress newServerAddress = serverAddress.ChangeIsFirewalledTcp(false);
PeerBean.SetServerPeerAddress(newServerAddress);
lock (_reachableListeners)
{
foreach (IPeerReachable listener in _reachableListeners)
{
listener.PeerWellConnected(newServerAddress, requestMessage.Sender, true);
}
}
responseMessage = CreateResponseMessage(requestMessage, Message.Message.MessageType.Ok);
}
}
responder.Response(responseMessage);
}
public override void HandleResponse(Message.Message requestMessage, PeerConnection peerConnection, bool sign, IResponder responder)
{
if (!(requestMessage.Type == Message.Message.MessageType.Request1
|| requestMessage.Type == Message.Message.MessageType.Request2)
&& requestMessage.Command == Rpc.Commands.DirectData.GetNr())
{
throw new ArgumentException("Message content is wrong for this handler.");
}
var responseMessage = CreateResponseMessage(requestMessage, Message.Message.MessageType.Ok);
if (sign)
{
responseMessage.SetPublicKeyAndSign(PeerBean.KeyPair);
}
var rawDataReply2 = _rawDataReply;
var objectDataReply2 = _objectDataReply;
if (requestMessage.Type == Message.Message.MessageType.Request1 && rawDataReply2 == null)
{
responseMessage.SetType(Message.Message.MessageType.NotFound);
}
else if (requestMessage.Type == Message.Message.MessageType.Request2 && objectDataReply2 == null)
{
responseMessage.SetType(Message.Message.MessageType.NotFound);
}
else
{
var requestBuffer = requestMessage.Buffer(0);
// The user can reply with null, indicating not found or returning
// the request buffer, which means nothing is returned.
// Or an exception can be thrown.
if (requestMessage.Type == Message.Message.MessageType.Request1)
{
Logger.Debug("Handling Request1.");
var responseBuffer = rawDataReply2.Reply(requestMessage.Sender, requestBuffer, requestMessage.IsDone);
if (responseBuffer == null && requestMessage.IsDone)
{
Logger.Warn("Raw reply is null, returning not found.");
responseMessage.SetType(Message.Message.MessageType.NotFound);
}
// ReSharper disable once PossibleUnintendedReferenceComparison
else if (responseBuffer != requestBuffer) // reference equality ok
{
// can be partial as well
if (!responseBuffer.IsComplete)
{
responseMessage.SetStreaming();
}
responseMessage.SetBuffer(responseBuffer);
}
}
else
{
// no streaming here when we deal with objects
object obj = Utils.Utils.DecodeObject(requestBuffer.BackingBuffer);
Logger.Debug("Handling {0}.", obj);
object reply = objectDataReply2.Reply(requestMessage.Sender, obj);
if (reply == null)
{
responseMessage.SetType(Message.Message.MessageType.NotFound);
}
else if (reply == obj)
{
responseMessage.SetType(Message.Message.MessageType.Ok);
}
else
{
sbyte[] me = Utils.Utils.EncodeObject(reply);
responseMessage.SetBuffer(new Message.Buffer(Unpooled.WrappedBuffer(me)));
}
}
}
responder.Response(responseMessage);
}
public override void HandleResponse(Message.Message requestMessage, PeerConnection peerConnection, bool sign, IResponder responder)
{
if (requestMessage.KeyList.Count < 2)
{
throw new ArgumentException("At least location and domain keys are needed.");
}
if (!(requestMessage.Type == Message.Message.MessageType.Request1
|| requestMessage.Type == Message.Message.MessageType.Request2
|| requestMessage.Type == Message.Message.MessageType.Request3
|| requestMessage.Type == Message.Message.MessageType.Request4)
&& (requestMessage.Command == Rpc.Commands.Neighbor.GetNr()))
{
throw new ArgumentException("Message content is wrong for this handler.");
}
Number160 locationKey = requestMessage.Key(0);
Number160 domainKey = requestMessage.Key(1);
var neighbors = GetNeighbors(locationKey, NeighborSize);
if (neighbors == null)
{
// return empty neighbor set
var response = CreateResponseMessage(requestMessage, Message.Message.MessageType.NotFound);
response.SetNeighborSet(new NeighborSet(-1, new Collection<PeerAddress>()));
responder.Response(response);
return;
}
// create response message and set neighbors
var responseMessage = CreateResponseMessage(requestMessage, Message.Message.MessageType.Ok);
Logger.Debug("Found the following neighbors: {0}.", Convenient.ToString(neighbors));
var neighborSet = new NeighborSet(NeighborLimit, neighbors);
responseMessage.SetNeighborSet(neighborSet);
Number160 contentKey = requestMessage.Key(2);
var keyBloomFilter = requestMessage.BloomFilter(0);
var contentBloomFilter = requestMessage.BloomFilter(1);
var keyCollection = requestMessage.KeyCollection(0);
// it is important to set an integer if a value is present
bool isDigest = requestMessage.Type != Message.Message.MessageType.Request1;
if (isDigest)
{
if (requestMessage.Type == Message.Message.MessageType.Request2)
{
DigestInfo digestInfo;
if (PeerBean.DigestStorage == null)
{
// no storage to search
digestInfo = new DigestInfo();
}
else if (contentKey != null && locationKey != null && domainKey != null)
{
var locationAndDomainKey = new Number320(locationKey, domainKey);
var from = new Number640(locationAndDomainKey, contentKey, Number160.Zero);
var to = new Number640(locationAndDomainKey, contentKey, Number160.MaxValue);
digestInfo = PeerBean.DigestStorage.Digest(from, to, -1, true);
}
else if ((keyBloomFilter != null || contentBloomFilter != null) && locationKey != null && domainKey != null)
{
var locationAndDomainKey = new Number320(locationKey, domainKey);
digestInfo = PeerBean.DigestStorage.Digest(locationAndDomainKey, keyBloomFilter,
contentBloomFilter, -1, true, true);
}
else if (keyCollection != null && keyCollection.Keys.Count == 2)
{
var enumerator = keyCollection.Keys.GetEnumerator();
var from = enumerator.MoveNext() ? enumerator.Current : null; // TODO works correctly?
var to = enumerator.MoveNext() ? enumerator.Current : null;
digestInfo = PeerBean.DigestStorage.Digest(from, to, -1, true);
}
else if (locationKey != null && domainKey != null)
{
var locationAndDomainKey = new Number320(locationKey, domainKey);
var from = new Number640(locationAndDomainKey, Number160.Zero, Number160.Zero);
var to = new Number640(locationAndDomainKey, Number160.MaxValue, Number160.MaxValue);
digestInfo = PeerBean.DigestStorage.Digest(from, to, -1, true);
}
else
{
Logger.Warn("Did not search for anything.");
digestInfo = new DigestInfo();
}
responseMessage.SetIntValue(digestInfo.Size);
responseMessage.SetKey(digestInfo.KeyDigest);
responseMessage.SetKey(digestInfo.ContentDigest);
}
else if (requestMessage.Type == Message.Message.MessageType.Request3)
{
DigestInfo digestInfo;
if (PeerBean.DigestTracker == null)
{
// no tracker to search
digestInfo = new DigestInfo();
}
else
{
digestInfo = PeerBean.DigestTracker.Digest(locationKey, domainKey, contentKey);
if (digestInfo.Size == 0)
{
Logger.Debug("No entry found on peer {0}.", requestMessage.Recipient);
}
}
responseMessage.SetIntValue(digestInfo.Size);
}
else if (requestMessage.Type == Message.Message.MessageType.Request4)
{
lock (PeerBean.PeerStatusListeners)
{
foreach (var listener in PeerBean.PeerStatusListeners)
{
listener.PeerFailed(requestMessage.Sender,
new PeerException(PeerException.AbortCauseEnum.Shutdown, "shutdown"));
}
}
}
}
responder.Response(responseMessage);
}
public override void HandleResponse(Message.Message requestMessage, PeerConnection peerConnection, bool sign, IResponder responder)
{
if (!(requestMessage.Type == Message.Message.MessageType.Request1 ||
requestMessage.Type == Message.Message.MessageType.Request2) &&
requestMessage.Command == Rpc.Commands.DirectData.GetNr())
{
throw new ArgumentException("Message content is wrong for this handler.");
}
var responseMessage = CreateResponseMessage(requestMessage, Message.Message.MessageType.Ok);
if (sign)
{
responseMessage.SetPublicKeyAndSign(PeerBean.KeyPair);
}
var rawDataReply2 = _rawDataReply;
var objectDataReply2 = _objectDataReply;
if (requestMessage.Type == Message.Message.MessageType.Request1 && rawDataReply2 == null)
{
responseMessage.SetType(Message.Message.MessageType.NotFound);
}
else if (requestMessage.Type == Message.Message.MessageType.Request2 && objectDataReply2 == null)
{
responseMessage.SetType(Message.Message.MessageType.NotFound);
}
else
{
var requestBuffer = requestMessage.Buffer(0);
// The user can reply with null, indicating not found or returning
// the request buffer, which means nothing is returned.
// Or an exception can be thrown.
if (requestMessage.Type == Message.Message.MessageType.Request1)
{
Logger.Debug("Handling Request1.");
var responseBuffer = rawDataReply2.Reply(requestMessage.Sender, requestBuffer, requestMessage.IsDone);
if (responseBuffer == null && requestMessage.IsDone)
{
Logger.Warn("Raw reply is null, returning not found.");
responseMessage.SetType(Message.Message.MessageType.NotFound);
}
// ReSharper disable once PossibleUnintendedReferenceComparison
else if (responseBuffer != requestBuffer) // reference equality ok
{
// can be partial as well
if (!responseBuffer.IsComplete)
{
responseMessage.SetStreaming();
}
responseMessage.SetBuffer(responseBuffer);
}
}
else
{
// no streaming here when we deal with objects
object obj = Utils.Utils.DecodeObject(requestBuffer.BackingBuffer);
Logger.Debug("Handling {0}.", obj);
object reply = objectDataReply2.Reply(requestMessage.Sender, obj);
if (reply == null)
{
responseMessage.SetType(Message.Message.MessageType.NotFound);
}
else if (reply == obj)
{
responseMessage.SetType(Message.Message.MessageType.Ok);
}
else
{
sbyte[] me = Utils.Utils.EncodeObject(reply);
responseMessage.SetBuffer(new Message.Buffer(Unpooled.WrappedBuffer(me)));
}
}
}
responder.Response(responseMessage);
}
