private static void HandleBasicUpOp(string step, ConnectionConfigBuilder connectionConfigBuilder,
ConnectionConfigList connectionAllConfigList, int connectionCnt, List <string> slaveList)
{
var isNumeric = int.TryParse(step.Substring(2), out int n);
if (step.Substring(0, 2) == "up" && isNumeric)
{
var AdditionalSendConnCnt = 0;
var lastOne = false;
if (step.Substring(0, 2) == "up")
{
if (step.Contains("LastOne"))
{
AdditionalSendConnCnt = 1;
lastOne = true;
}
else
{
AdditionalSendConnCnt = Convert.ToInt32(step.Substring(2));
}
}
connectionAllConfigList = connectionConfigBuilder.UpdateSendConn(connectionAllConfigList,
AdditionalSendConnCnt, connectionCnt, slaveList.Count, lastOne);
}
}
public static IObservableConnection Create(Action <IConnectionConfigBuilder> config)
{
var configuration = new ConnectionConfigBuilder();
config(configuration);
var connectionConfig = configuration.Create();
return(Create(connectionConfig));
}
private static void HandleUpPerGroupOp(string step, ConnectionConfigBuilder connectionConfigBuilder, ConnectionConfigList connectionAllConfigList, List <string> groupNameMat)
{
var pattern = "upPerGroup";
if (step.Contains(pattern))
{
var isNumeric = int.TryParse(step.Substring(pattern.Length), out int upNum);
if (!isNumeric)
{
throw new Exception();
}
connectionConfigBuilder.UpdateSendConnPerGroup(connectionAllConfigList, groupNameMat, upNum);
}
}
private static async Task ProcessPipeline(List <RpcService.RpcServiceClient> clients, string pipelineStr, List <string> slaveList, int connections,
string serviceType, string transportType, string hubProtocol, string scenario, string messageSize,
int groupNum, int overlap, int serverCount, string sendToFixedClient, bool enableGroupJoinLeave,
string stopIfLatencyIsBig, string stopSendIfConnectionErrorBig)
{
// var connections = argsOption.Connections;
// var serviceType = argsOption.ServiceType;
// var transportType = argsOption.TransportType;
// var hubProtocol = argsOption.HubProtocal;
// var scenario = argsOption.Scenario;
// var messageSize = argsOption.MessageSize;
// var groupNum = argsOption.groupNum;
// var overlap = argsOption.groupOverlap;
// var serverCount = argsOption.ServerUrl.Split(";").ToList().Count;
// var sendToFixedClient = argsOption.sendToFixedClient;
// var pipeline = argsOption.PipeLine.Split(';').ToList();
var pipeline = pipelineStr.Split(';').ToList();
var connectionConfigBuilder = new ConnectionConfigBuilder();
var connectionAllConfigList = connectionConfigBuilder.Build(connections);
var targetConnectionIds = new List <string>();
var groupNameList = GenerateGroupNameList(connections, groupNum, overlap);
var callbackList = Enumerable.Repeat(true, connections).ToList();
var messageCountPerInterval = 1;
var joinLeavePerGroupAdditionalCnt = 0;
var joinLeavePerGroupList = Enumerable.Repeat(false, connections).ToList();
var sendGroupList = Enumerable.Repeat(false, groupNum).ToList();
var stopIfLatencyBig = bool.Parse(stopIfLatencyIsBig);
var stopIfConnectionErrorBig = bool.Parse(stopSendIfConnectionErrorBig);
// var serverUrls = serverCount;
for (var i = 0; i < pipeline.Count; i++)
{
var tasks = new List <Task>(clients.Count);
var step = pipeline[i];
int indClient = -1;
Util.Log($"current step: {step}");
if (stopIfLatencyBig && _ge1000msGT1Percent)
{
if (step.Substring(0, 2) == "up")
{
Util.Log($"Stop the sending steps since there are too many messages whose latency is larger than 1s!");
// skip "upxxxx" step
i++;
// skip the immediate following "scenario" step,
// as a result, all "upxxx;scenario" steps were skipped.
continue;
}
}
if (stopIfConnectionErrorBig && _connectionErrorGT1Percent)
{
if (step.Substring(0, 2) == "up")
{
Util.Log($"Stop the sending steps since there are too many connections drops (dropped connection > 1%)!");
// skip "upxxxx" step
i++;
// skip the immediate following "scenario" step,
// as a result, all "upxxx;scenario" steps were skipped.
continue;
}
}
// up op
HandleBasicUpOp(step, connectionConfigBuilder, connectionAllConfigList, connections, slaveList);
// handle up join/leave group per group
HandleUpSendGroupOp(step, sendGroupList, groupNum, overlap);
// handle up per group op
HandleUpPerGroupOp(step, connectionConfigBuilder, connectionAllConfigList, groupNameList);
// handle config message count per interval
var configMessageCountPerInterval = step.Contains("configMessageCountPerInterval") ? true : false;
if (configMessageCountPerInterval)
{
int.TryParse(Util.TrimAlphabeticPrefix(step), out messageCountPerInterval);
}
var upJoinLeavePerGroup = step.Contains("upJoinLeavePerGroup") ? true : false;
if (upJoinLeavePerGroup)
{
int.TryParse(Util.TrimAlphabeticPrefix(step), out joinLeavePerGroupAdditionalCnt);
joinLeavePerGroupList = UpdateJoinLeavePergroupList(joinLeavePerGroupList, connectionAllConfigList, groupNameList, joinLeavePerGroupAdditionalCnt);
}
// remove last one callback
RemoveExceptLastOneCallback(step, callbackList);
clients.ForEach(client =>
{
indClient++;
var benchmarkCellConfig = GenerateBenchmarkConfig(indClient, step,
serviceType, transportType, hubProtocol, scenario, messageSize,
targetConnectionIds, groupNameList, callbackList, messageCountPerInterval,
enableGroupJoinLeave, joinLeavePerGroupList, sendGroupList);
Util.Log($"service: {benchmarkCellConfig.ServiceType}; transport: {benchmarkCellConfig.TransportType}; hubprotocol: {benchmarkCellConfig.HubProtocol}; scenario: {benchmarkCellConfig.Scenario}; step: {step}");
var indClientInLoop = indClient;
tasks.Add(Task.Run(() =>
{
var beg = 0;
for (var indStart = 0; indStart < indClientInLoop; indStart++)
{
beg += Util.SplitNumber(connections, indStart, slaveList.Count);
}
var currConnSliceCnt = Util.SplitNumber(connections, indClientInLoop, slaveList.Count);
client.LoadConnectionRange(new Range {
Begin = beg, End = beg + currConnSliceCnt
});
client.LoadConnectionConfig(connectionAllConfigList);
client.RunJob(benchmarkCellConfig);
}));
});
await Task.WhenAll(tasks);
await Task.Delay(1000);
// collect all connections' ids just after connections start
if (step.Contains("startConn", StringComparison.OrdinalIgnoreCase) ||
step.Contains("StartRestClientConn", StringComparison.OrdinalIgnoreCase))
{
// There are more than 1 server, we'd prefer to send message to target connection
// on different service, which means those message will go to Redis.
// In addition, in order to avoid time difference of different clients,
// The message should be sent to connections on the same clients.
if (bool.Parse(sendToFixedClient) && serverCount > 1)
{
targetConnectionIds = LeftShiftConnectionIdsOnEachClient(clients, serverCount);
}
else
{
targetConnectionIds = CollectConnectionIds(clients);
targetConnectionIds.Shuffle();
}
}
}
}
