public async Task <RpcResult <APaperStaDetailRsp> > GetAPaperStaAsync(GetAPaperStaDetailReq req, int timeOut = 3000)
{
AmpMessage message = AmpMessage.CreateRequestMessage(20002, 4);
message.FriendlyServiceName = "APaperService.GetAPaperSta";
message.Data = req.ToByteArray();
var response = await base.CallInvoker.AsyncCall(message, timeOut);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <APaperStaDetailRsp>();
if (response.Code != 0)
{
result.Code = response.Code;
}
if (response.Data == null)
{
result.Data = new APaperStaDetailRsp();
}
else
{
result.Data = APaperStaDetailRsp.Parser.ParseFrom(response.Data);
}
return(result);
}
/*
* We always reduce our map call first, then children.
*/
public State AddChildResult(RpcResult child)
{
if (Reducing)
{
//We need to add this to pending
var pend = new ImmutableList <RpcResult>(child, Pending);
return(new State(MapResult, Tree, ChildReductions, ReduceResult, Done, pend, true));
}
else if (MapResult == DEFAULT_OBJ)
{
/*
* We are not reducing AND we have not finished the first
* Reduce, that means we are waiting for the Map result.
*/
var pend = new ImmutableList <RpcResult>(child, Pending);
return(new State(MapResult, Tree, ChildReductions, ReduceResult, Done, pend, false));
}
else
{
/*
* In this case, we are not already reducing, and we have reduced
* the MapResult
*/
return(new State(MapResult, Tree, ChildReductions, ReduceResult, Done, ImmutableList <RpcResult> .Empty, true));
}
}
static void Ping(IList nodes)
{
Random my_r = new Random();
int idx0 = my_r.Next(0, nodes.Count);
int idx1 = my_r.Next(0, nodes.Count);
Node n0 = (Node)nodes[idx0];
Node n1 = (Node)nodes[idx1];
RpcManager pinger = n0.Rpc;
Channel results = new Channel();
results.EnqueueEvent += delegate(object q, EventArgs a) {
object result = results.Dequeue();
RpcResult r = (RpcResult)result;
try {
IDictionary data = (IDictionary)r.Result;
Console.WriteLine("target: {0}, rtt: {1}", data["target"], data["musec"]);
}
catch (Exception x) {
Console.WriteLine("target: {0}, Exception: {1}", n1.Address, x);
}
};
Console.WriteLine("Pinging: {0} -> {1}", n0.Address, n1.Address);
try {
pinger.Invoke(n0, results, "trace.GetRttTo", n1.Address.ToString());
}
catch (Exception x) {
Console.WriteLine("Exception: {0}", x);
}
}
public async Task <RpcResult <SaveQPaperRsp> > SaveQPaperAsync(SaveQPaperReq req, int timeOut = 3000)
{
AmpMessage message = AmpMessage.CreateRequestMessage(20001, 1);
message.FriendlyServiceName = "QPaperInnerService.SaveQPaper";
message.Data = req.ToByteArray();
var response = await base.CallInvoker.AsyncCall(message, timeOut);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <SaveQPaperRsp>();
if (response.Code != 0)
{
result.Code = response.Code;
}
else if (response.Data == null)
{
result.Code = ErrorCodes.CODE_INTERNAL_ERROR;
}
else
{
result.Data = SaveQPaperRsp.Parser.ParseFrom(response.Data);
}
return(result);
}
/**
* Step 1. Get vivaldi state for the current trial.
* @param state information associated with the node we are going to sample.
*/
protected void GetVivaldiState()
{
#if NC_DEBUG
Console.Error.WriteLine("[NCService] {0} Requesting vivaldi state from: {1}.", _node.Address, _target_address);
#endif
Channel q = new Channel(1);
q.CloseEvent += delegate(object o, EventArgs args) {
Channel nc_q = (Channel)o;
if (nc_q.Count > 0)
{
try {
RpcResult result = nc_q.Dequeue() as RpcResult;
_state_result.Value = (Hashtable)result.Result;
} catch (Exception) {}
}
//if got something valid, move on to Step 2.
if (_state_result.Value != null)
{
GetLatencySample();
}
else
{
//do nothing, looks like things are not going well with this trial
//termination
#if NC_DEBUG
Console.Error.WriteLine("[NCService] {0} Rpc (GetVivaldiState) failed: {1}.", _node.Address, _target_address);
#endif
}
};
try {
_node.Rpc.Invoke(_target_edge, q, "ncserver.EchoVivaldiState", new object[] {});
} catch (Exception) {}
}
public async Task <RpcResult <RegisterRsp> > RegisterAsync(RegisterReq req, int timeOut = 3000)
{
AmpMessage message = AmpMessage.CreateRequestMessage(20003, 1);
message.FriendlyServiceName = "UserService.Register";
message.Data = req.ToByteArray();
var response = await base.CallInvoker.AsyncCall(message, timeOut);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <RegisterRsp>();
if (response.Code != 0)
{
result.Code = response.Code;
}
if (response.Data == null)
{
result.Data = new RegisterRsp();
}
else
{
result.Data = RegisterRsp.Parser.ParseFrom(response.Data);
}
return(result);
}
//同步方法
public RpcResult <AddRes> Add(AddReq req)
{
AmpMessage message = AmpMessage.CreateRequestMessage(10005, 1);
message.FriendlyServiceName = "Math.Add";
message.Data = req.ToByteArray();
var response = base.CallInvoker.BlockingCall(message);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <AddRes>();
if (response.Code != 0)
{
result.Code = response.Code;
}
if (response.Data == null)
{
result.Data = new AddRes();
}
else
{
result.Data = AddRes.Parser.ParseFrom(response.Data);
}
return(result);
}
public async Task <RpcResult <VoidRes> > EnqueueAsync(EnqueueReq req, int timeOut = 3000)
{
AmpMessage message = AmpMessage.CreateRequestMessage(1000, 1);
message.FriendlyServiceName = "TaskProducerService.Enqueue";
message.Data = req.ToByteArray();
var response = await base.CallInvoker.AsyncCall(message, timeOut);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <VoidRes>();
if (response.Code != 0)
{
result.Code = response.Code;
}
else if (response.Data == null)
{
result.Code = ErrorCodes.CODE_INTERNAL_ERROR;
}
else
{
result.Data = VoidRes.Parser.ParseFrom(response.Data);
}
return(result);
}
//同步方法
public RpcResult <VoidRsp> AddAPaperCount(AddAPaperReq req)
{
AmpMessage message = AmpMessage.CreateRequestMessage(20001, 5);
message.FriendlyServiceName = "QPaperService.AddAPaperCount";
message.Data = req.ToByteArray();
var response = base.CallInvoker.BlockingCall(message);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <VoidRsp>();
if (response.Code != 0)
{
result.Code = response.Code;
}
if (response.Data == null)
{
result.Data = new VoidRsp();
}
else
{
result.Data = VoidRsp.Parser.ParseFrom(response.Data);
}
return(result);
}
public override void Reduce(Channel q, object reduce_arg,
object current_result, RpcResult child_rpc)
{
bool done = false;
ISender child_sender = child_rpc.ResultSender;
//the following can throw an exception, will be handled by the framework
object child_result = child_rpc.Result;
//child result is a valid result
if (current_result == null)
{
q.Enqueue(new Brunet.Collections.Pair <object, bool>(child_result, done));
return;
}
ArrayList retval = current_result as ArrayList;
IDictionary my_entry = (IDictionary)retval[0];
my_entry["next_con"] = child_sender.ToUri();
retval.AddRange((IList)child_result);
if (LogEnabled)
{
ProtocolLog.Write(ProtocolLog.MapReduce,
String.Format("{0}: {1}, reduce list count: {2}.", this.TaskName, _node.Address, retval.Count));
}
q.Enqueue(new Brunet.Collections.Pair <object, bool>(retval, done));
}
protected void Callback(object o, EventArgs ea)
{
Channel q = o as Channel;
try {
RpcResult res = (RpcResult)q.Dequeue();
int result = (int)res.Result;
if (result != 0)
{
throw new Exception(res.Result.ToString());
}
_total_latency += (DateTime.UtcNow.Ticks / TimeSpan.TicksPerMillisecond) - _start_time;
} catch {
// } catch(Exception e) {
// Console.WriteLine(e);
}
if (Interlocked.Decrement(ref _waiting_on) == 0)
{
Interlocked.Exchange(ref _done, 1);
Console.WriteLine("Performed {0} tests on {1} nodes", _count, _nodes.Count);
Console.WriteLine("Latency avg: {0}", _total_latency / _count);
DateTime start = new DateTime(_start_time * TimeSpan.TicksPerMillisecond);
Console.WriteLine("Finished in: {0}", (DateTime.UtcNow - start));
}
}
public override Task <RpcResult <TaskVoidRes> > ScheduleSecondTransforAsync(ScheduleTaskReq req)
{
RpcResult <TaskVoidRes> res = new RpcResult <TaskVoidRes>();
_jobClient.Schedule <IHangfireJobService>(x => x.Schedule(0, 1, req.Delay, $"{req.ServiceId}|{req.MessageId}|{req.Data}", null), TimeSpan.FromSeconds(req.Delay));
return(Task.FromResult(res));
}
public override Task <RpcResult <TaskVoidRes> > ExcuteAsync(CommonTaskReq req)
{
var result = new RpcResult <TaskVoidRes>();
_logger.LogInformation("receive task req: jobId={0},data ={1}", req.JobId, req.Data);
return(Task.FromResult(result));
}
public async Task <RpcResult <TResult> > AsyncRequest <T, TResult>(string callName, string groupName, int serviceId, ushort messageId,
T req, int timeout = 3000)
{
RpcResult <TResult> result = new RpcResult <TResult>();
var reqMessage = AmpMessage.CreateRequestMessage(serviceId, messageId);
reqMessage.FriendlyServiceName = callName;
reqMessage.ServiceGroupName = groupName;
reqMessage.CodecType = (CodecType)Enum.ToObject(typeof(CodecType), this._serializer.CodecType);
reqMessage.Data = this._serializer.Serialize(req);
var rsp = await AsyncCallInner(reqMessage, timeout);
if (rsp != null)
{
result.Code = rsp.Code;
if (rsp.Data != null)
{
result.Data = this._serializer.Deserialize <TResult>(rsp.Data);
}
}
else
{
this._logger.LogError("Call {0} , return null", callName);
result.Code = RpcErrorCodes.CODE_INTERNAL_ERROR;
}
return(result);
}
public override Task <RpcResult <VoidRes> > ScheduleSecondAsync(ScheduleReq req)
{
RpcResult <VoidRes> res = new RpcResult <VoidRes>();
_jobClient.Schedule <IJobService>(x => x.Schedule(req.ServiceId, req.MessageId, req.Data, null), TimeSpan.FromSeconds(req.Delay));
return(Task.FromResult(res));
}
public async Task <RpcResult <TaskVoidRes> > ScheduleSecondTransforAsync(ScheduleTaskReq req, int timeOut = 3000)
{
AmpMessage message = AmpMessage.CreateRequestMessage(2001, 106);
message.FriendlyServiceName = "TaskProducerService.ScheduleSecondTransfor";
message.Data = req.ToByteArray();
var response = await base.CallInvoker.AsyncCall(message, timeOut);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <TaskVoidRes>();
if (response.Code != 0)
{
result.Code = response.Code;
}
if (response.Data == null)
{
result.Data = new TaskVoidRes();
}
else
{
result.Data = TaskVoidRes.Parser.ParseFrom(response.Data);
}
return(result);
}
//同步方法
public RpcResult <TaskVoidRes> ScheduleTransfor(ScheduleTaskReq req)
{
AmpMessage message = AmpMessage.CreateRequestMessage(2001, 105);
message.FriendlyServiceName = "TaskProducerService.ScheduleTransfor";
message.Data = req.ToByteArray();
var response = base.CallInvoker.BlockingCall(message);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <TaskVoidRes>();
if (response.Code != 0)
{
result.Code = response.Code;
}
if (response.Data == null)
{
result.Data = new TaskVoidRes();
}
else
{
result.Data = TaskVoidRes.Parser.ParseFrom(response.Data);
}
return(result);
}
static void TraceRoute(IList nodes)
{
Random my_r = new Random();
int idx0 = my_r.Next(0, nodes.Count);
int idx1 = my_r.Next(0, nodes.Count);
Node n0 = (Node)nodes[idx0];
Node n1 = (Node)nodes[idx1];
RpcManager pinger = n0.Rpc;
Channel results = new Channel();
Console.WriteLine("Traceroute: {0} -> {1}", n0.Address, n1.Address);
results.EnqueueEvent += delegate(object q, EventArgs a) {
object result = results.Dequeue();
RpcResult r = (RpcResult)result;
IList data = (IList)r.Result;
int hop = 0;
foreach (IDictionary d in data)
{
Console.WriteLine("Hop: {0} :: {1}\n :: {2}", hop, d["node"], d["next_con"]);
hop++;
}
};
try {
pinger.Invoke(n0, results, "trace.GetRouteTo", n1.Address.ToString());
}
catch (Exception x) {
Console.WriteLine("Exception: {0}", x);
}
}
public override async Task <RpcResult <APaperStaDetailRsp> > GetAPaperStaAsync(GetAPaperStaDetailReq request)
{
var res = new RpcResult <APaperStaDetailRsp>();
res.Data = new APaperStaDetailRsp();
var staList = await this._apaperRepo.QueryQPaperStaDetailAsync(request.QpaperId);
foreach (var item in staList)
{
var stad = new APaperStaDetail()
{
QuestionId = item.QuestionId
};
stad.Oa.AddRange(new int[]
{
item.OA1, item.OA2, item.OA3, item.OA4, item.OA5, item.OA6, item.OA7, item.OA8, item.OA9, item.OA10
});
res.Data.StaDetail.Add(stad);
}
return(res);
}
/**
* Try to get an RpcResult out and handle it
*/
protected void EnqueueHandler(object queue, EventArgs arg)
{
Channel q = (Channel)queue;
RpcResult rpc_res = null;
try {
rpc_res = (RpcResult)q.Dequeue();
ConnectToMessage new_ctm = new ConnectToMessage((IDictionary)rpc_res.Result);
if (_local_node.Address.Equals(new_ctm.Target.Address))
{
throw new Exception("Trying to connect to myself!");
}
lock ( _sync ) {
/**
* It is the responsibilty of the ConnectionOverlord
* to deal with this ctm
*/
_got_ctms.Add(new_ctm);
}
bool close_queue = _co.HandleCtmResponse(this, rpc_res.ResultSender, new_ctm);
if (close_queue)
{
q.Close();
}
}
catch (Exception) {
//This can happen if the queue is empty and closed. Don't do
//anything.
}
}
//同步方法
public RpcResult <VoidRes> Schedule(ScheduleReq req)
{
AmpMessage message = AmpMessage.CreateRequestMessage(1000, 2);
message.FriendlyServiceName = "TaskProducerService.Schedule";
message.Data = req.ToByteArray();
var response = base.CallInvoker.BlockingCall(message);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <VoidRes>();
if (response.Code != 0)
{
result.Code = response.Code;
}
else if (response.Data == null)
{
result.Code = ErrorCodes.CODE_INTERNAL_ERROR;
}
else
{
result.Data = VoidRes.Parser.ParseFrom(response.Data);
}
return(result);
}
public async Task <RpcResult <SubmitOrderRes> > SubmitOrder(SubmitOrderReq req)
{
var result = new RpcResult <SubmitOrderRes>();
try
{
//var userService = _rpcServiceProxy.GetService<IUserService>();
//var user = await userService.GetUser(new UserService.DTO.GetUserReq { UserId = req.UserId });
var productService = _rpcServiceProxy.GetService <IProductService>();
foreach (var item in req.Lines ?? new List <SubmitOrderLine>())
{
var skuInfo = await productService.GetProduct(new ProductService.DTO.GetProductReq {
ProductId = item.SkuId
});
}
result.Data = new SubmitOrderRes
{
OrderId = OrderId++
};
}
catch (Exception ex)
{
result.Code = ExceptionCode.INTETNAL_ERROR;
result.Message = "内部错误";
}
return(result);
}
/// <summary>
/// 分页获取问卷列表
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public override async Task <RpcResult <QPaperListRsp> > QueryQPaperListAsync(QueryQPaperReq request)
{
var res = new RpcResult <QPaperListRsp>();
res.Data = new QPaperListRsp();
var userId = request.CheckRole ? request.Identity : String.Empty;
var view = new PageView(request.Page, request.Rp);
var plist = await this._qpaperRepo.QueryQPaperList(Utility.ClearSafeStringParma(request.Query), userId, view);
res.Data.Total = view.PageIndex == 0 ? plist.Total : -1;
if (plist != null && plist.DataList != null && plist.DataList.Count > 0)
{
foreach (var qpaper in plist.DataList)
{
res.Data.List.Add(new DTOQPaper()
{
QpaperId = qpaper.QpaperId,
Subject = qpaper.Subject,
Description = qpaper.Description,
ApaperCount = qpaper.ApaperCount,
StartTime = qpaper.StartTime.HasValue ? qpaper.StartTime.Value.ToString("yyyy-MM-dd HH:mm:ss") : "",
EndTime = qpaper.EndTime.HasValue ? qpaper.EndTime.Value.ToString("yyyy-MM-dd HH:mm:ss") : ""
});
}
}
return(res);
}
//同步方法
public RpcResult <RegisterRsp> Register(RegisterReq req)
{
AmpMessage message = AmpMessage.CreateRequestMessage(10001, 31);
message.FriendlyServiceName = "UserGateService.Register";
message.Data = req.ToByteArray();
var response = base.CallInvoker.BlockingCall(message);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <RegisterRsp>();
if (response.Code != 0)
{
result.Code = response.Code;
}
else if (response.Data == null)
{
result.Code = ErrorCodes.CODE_INTERNAL_ERROR;
}
else
{
result.Data = RegisterRsp.Parser.ParseFrom(response.Data);
}
return(result);
}
//同步方法
public RpcResult <LoginRsp> Login(LoginReq req)
{
AmpMessage message = AmpMessage.CreateRequestMessage(20003, 2);
message.FriendlyServiceName = "UserService.Login";
message.Data = req.ToByteArray();
var response = base.CallInvoker.BlockingCall(message);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <LoginRsp>();
if (response.Code != 0)
{
result.Code = response.Code;
}
if (response.Data == null)
{
result.Data = new LoginRsp();
}
else
{
result.Data = LoginRsp.Parser.ParseFrom(response.Data);
}
return(result);
}
public async Task <RpcResult <GetUserRsp> > CheckLoginAsync(CheckLoginReq req, int timeOut = 3000)
{
AmpMessage message = AmpMessage.CreateRequestMessage(10001, 34);
message.FriendlyServiceName = "UserGateService.CheckLogin";
message.Data = req.ToByteArray();
var response = await base.CallInvoker.AsyncCall(message, timeOut);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <GetUserRsp>();
if (response.Code != 0)
{
result.Code = response.Code;
}
else if (response.Data == null)
{
result.Code = ErrorCodes.CODE_INTERNAL_ERROR;
}
else
{
result.Data = GetUserRsp.Parser.ParseFrom(response.Data);
}
return(result);
}
public async Task <RpcResult <AddRes> > AddAsync(AddReq req, int timeOut = 3000)
{
AmpMessage message = AmpMessage.CreateRequestMessage(10005, 1);
message.FriendlyServiceName = "Math.Add";
message.Data = req.ToByteArray();
var response = await base.CallInvoker.AsyncCall(message, timeOut);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <AddRes>();
if (response.Code != 0)
{
result.Code = response.Code;
}
if (response.Data == null)
{
result.Data = new AddRes();
}
else
{
result.Data = AddRes.Parser.ParseFrom(response.Data);
}
return(result);
}
//同步方法
public RpcResult <APaperStaDetailRsp> GetAPaperSta(GetAPaperStaDetailReq req)
{
AmpMessage message = AmpMessage.CreateRequestMessage(20002, 4);
message.FriendlyServiceName = "APaperService.GetAPaperSta";
message.Data = req.ToByteArray();
var response = base.CallInvoker.BlockingCall(message);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <APaperStaDetailRsp>();
if (response.Code != 0)
{
result.Code = response.Code;
}
if (response.Data == null)
{
result.Data = new APaperStaDetailRsp();
}
else
{
result.Data = APaperStaDetailRsp.Parser.ParseFrom(response.Data);
}
return(result);
}
//同步方法
public RpcResult <QPaperListRsp> QueryQPaperList(QueryQPaperReq req)
{
AmpMessage message = AmpMessage.CreateRequestMessage(20001, 2);
message.FriendlyServiceName = "QPaperInnerService.QueryQPaperList";
message.Data = req.ToByteArray();
var response = base.CallInvoker.BlockingCall(message);
if (response == null)
{
throw new RpcException("error,response is null !");
}
var result = new RpcResult <QPaperListRsp>();
if (response.Code != 0)
{
result.Code = response.Code;
}
else if (response.Data == null)
{
result.Code = ErrorCodes.CODE_INTERNAL_ERROR;
}
else
{
result.Data = QPaperListRsp.Parser.ParseFrom(response.Data);
}
return(result);
}
/// <summary>
/// 获取答卷列表
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public override async Task <RpcResult <APaperListRsp> > QueryAPaperListAsync(QueryAPaperReq request)
{
var res = new RpcResult <APaperListRsp>();
res.Data = new APaperListRsp();
var view = new PageView(request.Page, request.Rp);
var plist = await this._apaperRepo.QueryAPaperList(request.Qtext, request.QpaperId, request.CheckRole?request.Identity : "", view);
res.Data.Total = view.PageIndex == 0 ? plist.Total : -1;
if (plist != null && plist.DataList != null && plist.DataList.Count > 0)
{
foreach (var apaper in plist.DataList)
{
res.Data.List.Add(new DTOAPaper()
{
ApaperId = apaper.PaperId,
CreateTime = apaper.CreateTime.ToString("yyyy-MM-dd HH:mm:ss"),
QpaperId = apaper.QpaperId,
UserId = apaper.UserId,
QpaperSubject = apaper.QpaperSubject ?? "",
QpaperUserId = apaper.QpaperUserId ?? "",
Remark = apaper.Remark
});
}
}
return(res);
}
/**
* Reduce method
* @param reduce_arg argument for reduce
* @param current_result result of current map
* @param child_rpc results from children
* @param done if done is true, stop reducing and return result
* return table of hop count, number of success, tree depth
*/
public override object Reduce(object reduce_arg,
object current_result, RpcResult child_rpc,
out bool done) {
done = false;
object child_result = child_rpc.Result;
if (current_result == null) {
return child_result;
}
int my_count = (int)(current_result);
int child_count = (int)(child_result);
int result = my_count + child_count;
return result;
}
private void AddStuffToBQAndClose(object ostate) {
object[] state = (object[])ostate;
BlockingQueue bq = (BlockingQueue)state[0];
ISender target = (ISender)state[1];
foreach (object o in this.CurrentInvokeState.RetValues) {
if (CurrentInvokeState.EnqueueIntervalInMillisec >= 0) {
Thread.Sleep(CurrentInvokeState.EnqueueIntervalInMillisec);
}
RpcResult rs = new RpcResult(target, o);
bq.Enqueue(rs);
}
if (CurrentInvokeState.IntervalBetweenLastEnqueueAndClose >= 0) {
Thread.Sleep(CurrentInvokeState.IntervalBetweenLastEnqueueAndClose);
}
bq.Close();
}
/**
* Reduce method
* @param reduce_arg argument for reduce
* @param current_result result of current map
* @param child_rpc results from children
* @param done if done is true, stop reducing and return result
* return table of hop count, number of success, tree depth
*/
public override object Reduce(object reduce_arg,
object current_result, RpcResult child_rpc,
out bool done) {
done = false;
//ISender child_sender = child_rpc.ResultSender;
//the following can throw an exception, will be handled by the framework
object child_result = child_rpc.Result;
//child result is a valid result
if (current_result == null) {
return child_result;
}
IDictionary my_entry = current_result as IDictionary;
IDictionary value = child_result as IDictionary;
int max_height = (int) my_entry["height"];
int count = (int) my_entry["count"];
my_entry["success"] = (int) my_entry["success"] + (int) value["success"];
int y = (int) value["count"];
my_entry["count"] = count + y;
int z = (int) value["height"] + 1;
if (z > max_height) {
my_entry["height"] = z;
}
return my_entry;
}
/**
* Reduce method
* @param reduce_arg argument for reduce
* @param current_result result of current map
* @param child_rpc results from children
* @param done if done is true, stop reducing and return result
* return table of hop count, tree depth, and query result
*/
public override object Reduce(object reduce_arg,
object current_result, RpcResult child_rpc,
out bool done) {
done = false;
//ISender child_sender = child_rpc.ResultSender;
string query_type = (string)reduce_arg;
object child_result = null;
try {
child_result = child_rpc.Result;
}
catch {
throw new Exception("no rpc result.");
}
//child result is a valid result
if (current_result == null) {
return child_result;
}
IDictionary my_entry = current_result as IDictionary;
IDictionary value = child_result as IDictionary;
int max_height = (int) (my_entry["height"]);
int count = (int) (my_entry["count"]);
int y = (int) value["count"];
my_entry["count"] = count + y;
int z = (int) value["height"] + 1;
if (z > max_height) {
my_entry["height"] = z;
}
if (query_type == "exact") {
string m_result = (string)(my_entry["query_result"]); //current result
string c_result = (string)(value["query_result"]); //child result
if (m_result != null) {
//Console.WriteLine("m_result is not null");
// if query type is exact matching and current result is not an empty string,
// stop searching and return the result immediately.
done = true;
}
else {
if (c_result != null) {
//Console.WriteLine("c_result is not null");
done = true;
my_entry["query_result"] = c_result;
}
else {
//there is no valid result, return null for the entry
my_entry["query_result"] = null;
}
}
return my_entry;
}
else if (query_type == "regex") {
ArrayList q_result = (ArrayList)(my_entry["query_result"]);
ArrayList c_result = (ArrayList)(value["query_result"]);
q_result.AddRange(c_result); //concatenate current result with child result
my_entry["query_result"] = q_result;
return my_entry;
}
else {
throw new AdrException(-32608, "This query type {0} is supported." + query_type);
}
}
