public void ValidGetCandidatesTests(Media media, MultiStatus status, Offset offset, Limit limit, Order order)
{
var request = new Dictionary <string, string>()
{
[GetCandidatesParam.jobId.ToString()] = "35"
};
CommonMapper.ValidOffsetMapper[offset](request);
CommonMapper.ValidLimitMapper[limit](request);
CommonMapper.ValidMultiStatusMapper[status](request);
CommonMapper.ValidMediaMapper[media](request);
request[GetCandidatesParam.order.ToString()] = order.GetEnumStringValue();
var defaultManager = new DefaultManager(new MatchingProUIConnection(TestConfig.GetValueFromConfig("MatchingProWeb")));
var response = defaultManager.Send <object>(Endpoints.Candidates, request, HttpMethod.GET);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
}
private byte[] JoinPackets(int id, byte total, bool bzipped, MultiStatus status) {
var multiPkt = bzipped ? status.BzipDict[id] : status.PlainDict[id];
var len = multiPkt.Sum(pkt => pkt.Length);
for (var i = total; i < multiPkt.Length; i++)
len -= multiPkt[i].Length;
var replyPkt = new byte[len];
var pos = 0;
for (var i = 0; i < total; i++) {
Buffer.BlockCopy(multiPkt[i], 0, replyPkt, pos, multiPkt[i].Length);
pos += multiPkt[i].Length;
}
if (bzipped) {
//var input = new MemoryStream(replyPkt);
//var output = new MemoryStream();
//BZip2.Decompress(input, output, true);
//replyPkt = output.ToArray();
}
var valid = true;
if (total + 1 < multiPkt.Length) {
//var size = BitConverter.ToInt32(multiPkt[total + 1], 0);
//var crc = BitConverter.ToInt32(multiPkt[total + 1], 4);
//if (replyPkt.Length * 8 != size) valid = false;
//var checkCrc = new Crc32();
//checkCrc.Update(replyPkt);
//if (checkCrc.Value != crc) valid = false;
}
if (!valid) {
throw new Exception("split packet not decompressed properly");
//TODO: check if at least header is intact so query can be retried
}
return replyPkt;
}
private byte[] CollectPacket(byte[] reply, int pos, MultiStatus status) {
//TODO: test if this works on old source server or mockup
var id = BitConverter.ToInt32(reply, pos);
pos += 4;
var bzipped = (id & 0x80000000) != 0;
var total = reply[pos++];
var number = reply[pos++];
pos += 2; //ignoring next short
if (bzipped) {
throw new Exception("bzip2 compression not implemented");
/*
if (!status.BzipDict.ContainsKey(id))
{
status.BzipDict[id] = new byte[total + 2][];
status.BzipDict[id][total] = new byte[1];
}
if (number == 0)
{
status.BzipDict[id][total + 1] = reply.Skip(pos).Take(4).ToArray();
pos += 4;
}
status.BzipDict[id][number] = reply.Skip(pos).ToArray();
var runTotal = status.BzipDict[id][total][0]++;
if (runTotal == total) JoinPackets(id, total, true);
*/
}
//else
if (!status.PlainDict.ContainsKey(id)) {
status.PlainDict[id] = new byte[total + 1][];
status.PlainDict[id][total] = new byte[1];
}
status.PlainDict[id][number] = reply.Skip(pos).ToArray();
var runTotal = status.PlainDict[id][total][0]++;
if (runTotal == total)
return JoinPackets(id, total, false, status);
return null;
}
private byte[] ProcessPacketHeader(byte[] reply, MultiStatus status) {
Contract.Requires<ArgumentNullException>(reply != null);
var pos = 0;
byte[] header = {0xFF, 0xFF, 0xFF};
var match = header.All(b => reply[pos++] == b);
if (!match)
return null;
if (reply[pos] == 0xFF)
return reply;
if (reply[pos] == 0xFE)
return CollectPacket(reply, ++pos, status);
return null;
}
private async Task<byte[]> ReceiveMultiple(MultiStatus status) {
// TODO: Keep looping for multi packets (process each header to find if there are more)
// and concatenate them in the right order
var response = await Receive().ConfigureAwait(false);
return ProcessPacketHeader(response.Buffer, status);
}
private async Task<byte[]> SendAndReceiveUntilEnd(byte[] msg) {
_state.StartSW();
var i = 0;
try {
await SendPacket(msg).ConfigureAwait(false);
byte[] response = null;
var multiStatus = new MultiStatus();
while (response == null) {
try {
response = await ReceiveMultiple(multiStatus).ConfigureAwait(false);
} finally {
if (i == 0)
_state.StopSW();
}
i++;
}
return response;
} finally {
if (i == 0)
_state.StopSW();
}
}
