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(); } } } }