protected override async Task SendMessages(IEnumerable <Package> packages) { var hubContext = await CreateHubContextAsync(); await Task.WhenAll(from package in packages let index = ConnectionIndex[package.LocalIndex] let groupIndex = index % GroupCount let indexInGroup = index / GroupCount let connection = package.Connection let data = package.Data let restApiClient = hubContext where Mode == SignalREnums.GroupConfigMode.Group && IsSending(indexInGroup, GroupInternalModulo, GroupInternalRemainderBegin, GroupInternalRemainderEnd) && IsSending(groupIndex, GroupCount, GroupLevelRemainderBegin, GroupLevelRemainderEnd) || Mode == SignalREnums.GroupConfigMode.Connection && IsSending(index, Modulo, RemainderBegin, RemainderEnd) select ContinuousSend((GroupName: SignalRUtils.GroupName(Type, index % GroupCount), RestApiProvider: restApiClient), data, SendToGroup, TimeSpan.FromMilliseconds(Duration), TimeSpan.FromMilliseconds(Interval), TimeSpan.FromMilliseconds(1), TimeSpan.FromMilliseconds(Interval))); }
async Task StreamingWriter(ChannelWriter <IDictionary <string, object> > writer, IDictionary <string, object> sentData, int count, int streamItemWaiting) { Exception localException = null; try { for (var i = 0; i < count; i++) { sentData[SignalRConstants.Timestamp] = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds().ToString(); await writer.WriteAsync(sentData); if (streamItemWaiting > 0) { await Task.Delay(streamItemWaiting); } // Update statistics SignalRUtils.RecordSend(sentData, StatisticsCollector); } } catch (Exception ex) { localException = ex; } writer.Complete(localException); }
protected Task Reconnect( IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters, IList <IRpcClient> clients) { // Get parameters stepParameters.TryGetTypedValue(SignalRConstants.ConnectionTotal, out int connectionTotal, Convert.ToInt32); stepParameters.TryGetTypedValue(SignalRConstants.ConcurrentConnection, out int concurrentConnection, Convert.ToInt32); stepParameters.TryGetTypedValue(SignalRConstants.Type, out string type, Convert.ToString); // Prepare configuration for each clients var packages = clients.Select((client, i) => { int currentConcurrentConnection = Util.SplitNumber(concurrentConnection, i, clients.Count); (int beg, int end) = Util.GetConnectionRange(connectionTotal, i, clients.Count); var data = new Dictionary <string, object>(stepParameters); data[SignalRConstants.ConcurrentConnection] = currentConcurrentConnection > 0 ? currentConcurrentConnection : 1; return(new { Client = client, Data = data }); }); // Process on clients var results = from package in packages select package.Client.QueryAsync(package.Data); var task = Task.WhenAll(results); long expectedMilliseconds = SignalRConstants.MillisecondsToWait; if (SignalRUtils.FetchTotalConnectionFromContext(pluginParameters, type, out int totalConnections)) { expectedMilliseconds = SignalRUtils.GetTimeoutPerConcurrentSpeed(totalConnections, concurrentConnection); } return(Util.TimeoutCheckedTask(task, expectedMilliseconds, nameof(Reconnect))); }
public async Task <IDictionary <string, object> > Do( IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters) { try { Log.Information($"Stop connections..."); // Get parameters stepParameters.TryGetTypedValue(SignalRConstants.Type, out string type, Convert.ToString); pluginParameters.TryGetTypedValue($"{SignalRConstants.ConnectionStore}.{type}", out IList <IHubConnectionAdapter> connections, (obj) => (IList <IHubConnectionAdapter>)obj); // Stop the possible scanner StopRapirConnectionScanner(stepParameters, pluginParameters); // Stop connections await Task.WhenAll(from connection in connections select connection.StopAsync()); await SignalRUtils.StopNegotiationServer(stepParameters, pluginParameters); await SignalRUtils.StopInternalAppServer(stepParameters, pluginParameters); return(null); } catch (Exception ex) { var message = $"Fail to stop connections: {ex}"; Log.Error(message); throw; } }
public Task Do(IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters, IList <IRpcClient> clients) { Log.Information($"Start connections..."); // Get parameters stepParameters.TryGetTypedValue(SignalRConstants.ConcurrentConnection, out int concurrentConnection, Convert.ToInt32); stepParameters.TryGetTypedValue(SignalRConstants.Type, out string type, Convert.ToString); if (concurrentConnection < clients.Count) { concurrentConnection = clients.Count; var message = $"Concurrent connection {concurrentConnection} should NOT be less than the number of agents {clients.Count}, we force it to be {clients.Count}"; Log.Warning(message); } var packages = clients.Select((client, i) => { int currentConcurrentConnection = Util.SplitNumber(concurrentConnection, i, clients.Count); var data = new Dictionary <string, object>(stepParameters); data[SignalRConstants.ConcurrentConnection] = currentConcurrentConnection; return(new { Client = client, Data = data }); }); var results = from package in packages select package.Client.QueryAsync(package.Data); var task = Task.WhenAll(results); // we wait until the default timeout reached long expectedMilliseconds = SignalRConstants.MillisecondsToWait; if (SignalRUtils.FetchTotalConnectionFromContext(pluginParameters, type, out int totalConnections)) { expectedMilliseconds = SignalRUtils.GetTimeoutPerConcurrentSpeed(totalConnections, concurrentConnection); } return(Util.TimeoutCheckedTask(task, expectedMilliseconds, nameof(StartConnection))); }
public async Task <IDictionary <string, object> > Do( IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters) { try { Log.Information($"Create connections..."); if (SignalRUtils.isUsingInternalApp(stepParameters)) { await SignalRUtils.StartInternalAppServer(stepParameters, pluginParameters); // rewrite the url stepParameters[SignalRConstants.HubUrls] = SignalRConstants.LocalhostUrl; } SignalRUtils.SlaveCreateConnection(stepParameters, pluginParameters, ClientType.AspNetCore); return(null); } catch (Exception ex) { var message = $"Fail to create connections: {ex}"; Log.Error(message); throw; } }
private double GetLargeLatencyPercentage(IDictionary <string, long> data, long latencyMax) { var largeLatencyMessageCount = data[SignalRUtils.MessageGreaterOrEqualTo(latencyMax)]; var receivedMessageCount = data[SignalRConstants.StatisticsMessageReceived]; return((double)largeLatencyMessageCount / receivedMessageCount); }
private async Task DirectConnectionJoinGroup(string connectionString) { var serviceManager = new ServiceManagerBuilder().WithOptions(option => { option.ConnectionString = connectionString; option.ServiceTransportType = ServiceTransportType.Transient; }).Build(); var hubContext = await serviceManager.CreateHubContextAsync(SignalRConstants.DefaultRestHubName); await SignalRUtils.JoinGroupForConnection( _totalConnection, _groupCount, _connectionIndex, async (i, g) => { var userId = SignalRUtils.GenClientUserIdFromConnectionIndex(_connectionIndex[i]); try { await hubContext.UserGroups.AddToGroupAsync( userId, SignalRUtils.GroupName(_type, g)); _statisticsCollector.IncreaseJoinGroupSuccess(); } catch (Exception e) { _statisticsCollector.IncreaseJoinGroupFail(); Log.Error($"Fail to join group: {e.Message}"); } }); }
public async Task <IDictionary <string, object> > Do( IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters) { try { Log.Information($"Dispose connections..."); // Get parameters stepParameters.TryGetTypedValue(SignalRConstants.Type, out string type, Convert.ToString); pluginParameters.TryGetTypedValue($"{SignalRConstants.ConnectionStore}.{type}", out IList <IHubConnectionAdapter> connections, (obj) => (IList <IHubConnectionAdapter>)obj); // Dispose HttpClients SignalRUtils.DiposeAllHttpClient(stepParameters, pluginParameters); // Dispose connections await Task.WhenAll(from connection in connections select connection.DisposeAsync()); return(null); } catch (Exception ex) { var message = $"Fail to dispose connections: {ex}"; Log.Error(message); throw; } }
protected void UpdateStatistics( StatisticsCollector statisticsCollector, int sendingStep) { SignalRUtils.ResetCounters(statisticsCollector); UpdateEpoch(statisticsCollector); SetSendingStep(statisticsCollector, sendingStep); }
public async Task Do(IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters, IList <IRpcClient> clients) { Log.Information($"Start to conditional stop..."); // Get parameters stepParameters.TryGetTypedValue(SignalRConstants.Type, out string type, Convert.ToString); stepParameters.TryGetTypedValue(SignalRConstants.CriteriaMaxFailConnectionPercentage, out double criteriaMaxFailConnectionPercentage, Convert.ToDouble); stepParameters.TryGetTypedValue(SignalRConstants.CriteriaMaxFailConnectionAmount, out int criteriaMaxFailConnectionAmount, Convert.ToInt32); stepParameters.TryGetTypedValue(SignalRConstants.CriteriaMaxFailSendingPercentage, out double criteriaMaxFailSendingPercentage, Convert.ToDouble); // Get context pluginParameters.TryGetTypedValue($"{SignalRConstants.LatencyStep}.{type}", out long latencyStep, Convert.ToInt64); pluginParameters.TryGetTypedValue($"{SignalRConstants.LatencyMax}.{type}", out long latencyMax, Convert.ToInt64); var results = await Task.WhenAll(from client in clients select client.QueryAsync(stepParameters)); // Merge statistics var merged = SignalRUtils.MergeStatistics(results, latencyMax, latencyStep); merged.TryGetTypedValue(SignalRConstants.StatisticsConnectionConnectSuccess, out long connectionSuccess, Convert.ToInt64); merged.TryGetTypedValue(SignalRConstants.StatisticsConnectionConnectFail, out long connectionFail, Convert.ToInt64); var connectionTotal = connectionSuccess + connectionFail; var connectionFailPercentage = (double)connectionFail / connectionTotal; var largeLatencyPercentage = GetLargeLatencyPercentage(merged, latencyMax); if (connectionFailPercentage > criteriaMaxFailConnectionPercentage) { var message = $"Connection fail percentage {connectionFailPercentage * 100}%" + $" is greater than criteria {criteriaMaxFailConnectionPercentage * 100}%, stop benchmark"; Log.Warning(message); throw new Exception(message); } if (connectionFail > criteriaMaxFailConnectionAmount) { var message = $"Connection fail amount {connectionFail}" + $"is greater than {criteriaMaxFailConnectionAmount}, stop benchmark"; Log.Warning(message); throw new Exception(message); } if (largeLatencyPercentage > criteriaMaxFailSendingPercentage) { var message = $"The percentage {largeLatencyPercentage * 100}%" + $"of Sending latency greater than {latencyMax}" + $" ms is larger than {criteriaMaxFailSendingPercentage * 100}%, stop benchmark"; Log.Warning(message); throw new Exception(message); } }
public Task Do( IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters, IList <IRpcClient> clients) { Log.Information($"Create AspNet connections..."); var ret = SignalRUtils.MasterCreateConnection(stepParameters, pluginParameters, clients); return(ret); }
public Task Do(IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters, IList <IRpcClient> clients) { Log.Information($"Stop connections..."); var data = new Dictionary <string, object>(); SignalRUtils.AddMethodAndType(data, stepParameters); return(Task.WhenAll(from client in clients select client.QueryAsync(data))); }
public void TestTryGetBatchMode() { var dic = new Dictionary <string, object>(); SignalRUtils.TryGetBatchMode( dic, out string batchConfigMode, out int batchWaitMilliSeconds, out SignalREnums.BatchMode mode); Assert.Equal(batchConfigMode, SignalRConstants.DefaultBatchMode); }
protected async Task LatencyEventerCallback( IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters, IList <IRpcClient> clients) { var results = await Task.WhenAll(from client in clients select client.QueryAsync(stepParameters)); // Merge statistics var merged = SignalRUtils.MergeStatistics(results, _latencyMax, _latencyStep); PrintAndSave(merged); }
public async Task <IDictionary <string, object> > Do( IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters) { try { Log.Information($"Join groups..."); // Get parameters stepParameters.TryGetTypedValue(SignalRConstants.Type, out _type, Convert.ToString); stepParameters.TryGetTypedValue(SignalRConstants.GroupCount, out _groupCount, Convert.ToInt32); stepParameters.TryGetTypedValue(SignalRConstants.ConnectionTotal, out _totalConnection, Convert.ToInt32); if (_totalConnection % _groupCount != 0) { //throw new Exception("Not supported: Total connections cannot be divided by group count"); Log.Warning($"groups do not have equal members because total connections {_totalConnection} cannot be divided by group count {_groupCount}"); } SignalRUtils.SaveGroupInfoToContext(pluginParameters, _type, _groupCount, _totalConnection); // Get context pluginParameters.TryGetTypedValue($"{SignalRConstants.ConnectionStore}.{_type}", out _connections, (obj) => (IList <IHubConnectionAdapter>)obj); pluginParameters.TryGetTypedValue($"{SignalRConstants.StatisticsStore}.{_type}", out _statisticsCollector, obj => (StatisticsCollector)obj); pluginParameters.TryGetTypedValue($"{SignalRConstants.ConnectionIndex}.{_type}", out _connectionIndex, (obj) => (List <int>)obj); // Reset counters SignalRUtils.ResetCounters(_statisticsCollector); // Join group var connectionType = SignalRUtils.GetClientTypeFromContext(pluginParameters, _type); if (connectionType == SignalREnums.ClientType.DirectConnect) { var connectionString = SignalRUtils.FetchConnectionStringFromContext(pluginParameters, _type); await DirectConnectionJoinGroup(connectionString); } else { await NormalConnectionJoinGroup(); } return(null); } catch (Exception ex) { var message = $"Fail to join group: {ex}"; Log.Error(message); throw; } }
public static void SetCallback( IList <IHubConnectionAdapter> connections, StatisticsCollector statisticsCollector) { foreach (var connection in connections) { connection.On(SignalRConstants.RecordLatencyCallbackName, (IDictionary <string, object> data) => { var receiveTimestamp = Util.Timestamp(); data.TryGetTypedValue(SignalRConstants.Timestamp, out long sendTimestamp, Convert.ToInt64); var latency = receiveTimestamp - sendTimestamp; statisticsCollector.RecordLatency(latency); SignalRUtils.RecordRecvSize(data, statisticsCollector); });
private async Task DirectConnectionLeaveGroup(string connectionString) { var serviceManager = new ServiceManagerBuilder().WithOptions(option => { option.ConnectionString = connectionString; option.ServiceTransportType = ServiceTransportType.Transient; }).Build(); var hubContext = await serviceManager.CreateHubContextAsync(SignalRConstants.DefaultRestHubName); if (_connections.Count >= _groupCount) { for (var i = 0; i < _connections.Count; i++) { var userId = SignalRUtils.GenClientUserIdFromConnectionIndex(_connectionIndex[i]); try { await hubContext.UserGroups.RemoveFromGroupAsync(userId, SignalRUtils.GroupName(_type, _connectionIndex[i] % _groupCount)); _statisticsCollector.IncreaseLeaveGroupSuccess(); } catch (Exception e) { _statisticsCollector.IncreaseLeaveGroupFail(); Log.Error($"Fail to leave group: {e.Message}"); } } } else { for (var i = 0; i < _groupCount; i++) { var userId = SignalRUtils.GenClientUserIdFromConnectionIndex(i); try { await hubContext.UserGroups.RemoveFromGroupAsync( userId, SignalRUtils.GroupName(_type, i)); _statisticsCollector.IncreaseLeaveGroupSuccess(); } catch (Exception e) { _statisticsCollector.IncreaseLeaveGroupFail(); Log.Error($"Fail to leave group: {e.Message}"); } } } }
private async Task NormalConnectionJoinGroup() { await SignalRUtils.JoinGroupForConnection( _totalConnection, _groupCount, _connectionIndex, async (i, g) => { await SignalRUtils.JoinToGroup( _connections[i], SignalRUtils.GroupName(_type, g), _statisticsCollector); }); }
protected async Task ConnectionStatEventerCallback( IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters, IList <IRpcClient> clients) { var results = await Task.WhenAll(from client in clients select client.QueryAsync(stepParameters)); // Merge statistics var merged = SignalRUtils.MergeStatistics(results, _latencyMax, _latencyStep); var connectionStatMerged = SignalRUtils.MergeConnectionStatistics(results, _percentileList.ToArray()); merged = merged.Union(connectionStatMerged).ToDictionary(entry => entry.Key, entry => entry.Value); PrintAndSave(merged); }
public void RecordLatency(long latency) { var index = latency / LatencyStep; var upperBound = (index + 1) * LatencyStep; if (upperBound <= LatencyMax) { _statistics.AddOrUpdate(SignalRUtils.MessageLessThan(upperBound), 1, (k, v) => v + 1); } else { _statistics.AddOrUpdate(SignalRUtils.MessageGreaterOrEqualTo(LatencyMax), 1, (k, v) => v + 1); } }
public async Task <IDictionary <string, object> > Do( IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters) { try { Log.Information($"Leave groups..."); // Get parameters stepParameters.TryGetTypedValue(SignalRConstants.Type, out _type, Convert.ToString); stepParameters.TryGetTypedValue(SignalRConstants.GroupCount, out _groupCount, Convert.ToInt32); stepParameters.TryGetTypedValue(SignalRConstants.ConnectionTotal, out int totalConnection, Convert.ToInt32); if (totalConnection % _groupCount != 0) { throw new Exception("Not supported: Total connections cannot be divided by group count"); } // Get context pluginParameters.TryGetTypedValue($"{SignalRConstants.ConnectionStore}.{_type}", out _connections, (obj) => (IList <IHubConnectionAdapter>)obj); pluginParameters.TryGetTypedValue($"{SignalRConstants.StatisticsStore}.{_type}", out _statisticsCollector, obj => (StatisticsCollector)obj); pluginParameters.TryGetTypedValue($"{SignalRConstants.ConnectionIndex}.{_type}", out _connectionIndex, (obj) => (List <int>)obj); // Not reset counters because typically this step is followed the last sending step. // We do not want to clear the last sending step's sending statistics // Leave group var connectionType = SignalRUtils.GetClientTypeFromContext(pluginParameters, _type); if (connectionType == SignalREnums.ClientType.DirectConnect) { var connectionString = SignalRUtils.FetchConnectionStringFromContext(pluginParameters, _type); await DirectConnectionLeaveGroup(connectionString); } else { await NormalConnectionLeaveGroup(); } return(null); } catch (Exception ex) { var message = $"Fail to leave group: {ex}"; Log.Error(message); throw; } }
public async Task <IDictionary <string, object> > Do(IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters) { try { Log.Information($"Start connections..."); // Get parameters stepParameters.TryGetTypedValue(SignalRConstants.ConcurrentConnection, out int concurrentConnection, Convert.ToInt32); stepParameters.TryGetTypedValue(SignalRConstants.Type, out string type, Convert.ToString); pluginParameters.TryGetTypedValue($"{SignalRConstants.ConnectionStore}.{type}", out IList <IHubConnectionAdapter> connections, (obj) => (IList <IHubConnectionAdapter>)obj); pluginParameters.TryGetTypedValue($"{SignalRConstants.StatisticsStore}.{type}", out _statisticsCollector, obj => (StatisticsCollector)obj); SignalRUtils.FilterOnConnectedNotification(pluginParameters, type); // The following get connection Id needs the concurrent connection value SignalRUtils.SaveConcurrentConnectionCountToContext( pluginParameters, type, concurrentConnection); var sw = new Stopwatch(); sw.Start(); Log.Information($"{DateTime.Now.ToString("yyyyMMddHHmmss")} Start connection"); try { await BatchConnect( stepParameters, pluginParameters, connections, concurrentConnection); } finally { sw.Stop(); Log.Information($"{DateTime.Now.ToString("yyyyMMddHHmmss")} Finishing connection {connections.Count} with {sw.ElapsedMilliseconds} ms"); } return(null); } catch (Exception ex) { var message = $"Fail to start connections: {ex}"; Log.Error(message); throw; } }
public Task <IDictionary <string, object> > Do( IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters) { try { Log.Information($"Create connections..."); SignalRUtils.SlaveCreateConnection(stepParameters, pluginParameters, ClientType.AspNet); return(Task.FromResult <IDictionary <string, object> >(null)); } catch (Exception ex) { var message = $"Fail to create connections: {ex}"; Log.Error(message); throw; } }
protected override async Task <IDictionary <string, object> > SimpleScenarioSend( IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters, string callbackMethod) { try { Log.Information($"Start {GetType().Name}..."); LoadParametersAndContext(stepParameters, pluginParameters); // Generate necessary data var data = new Dictionary <string, object> { { SignalRConstants.MessageBlob, SignalRUtils.GenerateRandomData(MessageSize) } // message payload }; // Reset counters UpdateStatistics(StatisticsCollector, RemainderEnd); // Send messages await Task.WhenAll(from i in Enumerable.Range(0, Connections.Count) where ConnectionIndex[i] % Modulo >= RemainderBegin && ConnectionIndex[i] % Modulo < RemainderEnd select ContinuousSend((Connection: Connections[i], LocalIndex: i, CallbackMethod: callbackMethod, StreamItemsCount, StreamItemInterval), data, StreamingBaseSendAsync, TimeSpan.FromMilliseconds(Duration), TimeSpan.FromMilliseconds(Interval), TimeSpan.FromMilliseconds(1), TimeSpan.FromMilliseconds(Interval))); Log.Information($"Finish {GetType().Name} {RemainderEnd}"); return(null); } catch (Exception ex) { var message = $"Fail to {GetType().Name}: {ex}"; Log.Error(message); throw; } }
public async Task <IDictionary <string, object> > Do(IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters) { try { Log.Information($"Send {GetType().Name}..."); LoadParametersAndContext(stepParameters, pluginParameters); // Get parameters stepParameters.TryGetTypedValue(SignalRConstants.ConnectionIdStore, out string[] connectionIds, obj => Convert.ToString(obj).Split(' ')); // Generate necessary data var messageBlob = SignalRUtils.GenerateRandomData(MessageSize); // Reset counters UpdateStatistics(StatisticsCollector, RemainderEnd); // Send messages await Task.WhenAll(from i in Enumerable.Range(0, Connections.Count) let data = new Dictionary <string, object> { { SignalRConstants.MessageBlob, messageBlob }, // message payload { SignalRConstants.ConnectionId, connectionIds[i] } } where ConnectionIndex[i] % Modulo >= RemainderBegin && ConnectionIndex[i] % Modulo < RemainderEnd select ContinuousSend((Connection: Connections[i], LocalIndex: i, CallbackMethod: SignalRConstants.SendToClientCallbackName), data, BaseSendAsync, TimeSpan.FromMilliseconds(Duration), TimeSpan.FromMilliseconds(Interval), TimeSpan.FromMilliseconds(1), TimeSpan.FromMilliseconds(Interval))); Log.Information($"Finish {GetType().Name} {RemainderEnd}"); return(null); } catch (Exception ex) { var message = $"Fail to send to client: {ex}"; Log.Error(message); throw; } }
public async Task BatchConnect( IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters, IList <IHubConnectionAdapter> connections, int concurrentConnection) { SignalRUtils.TryGetBatchMode( stepParameters, out string batchConfigMode, out int batchWaitMilliSeconds, out SignalREnums.BatchMode mode); var packages = (from i in Enumerable.Range(0, connections.Count()) where connections[i].GetStat() == SignalREnums.ConnectionInternalStat.Init select(Connection: connections[i], LocalIndex: i)).ToList(); // 100 milliseconds is the default fine-granularity var period = SignalRConstants.RateLimitDefaultGranularity; var factor = 1000 / period; var fillTokenPerDuration = concurrentConnection > factor ? concurrentConnection / factor : 1; switch (mode) { case SignalREnums.BatchMode.ExtLimitRatePress: await Util.ExternalRateLimitBatchProcess(packages, SignalRUtils.StartConnect, concurrentConnection, fillTokenPerDuration, period); break; case SignalREnums.BatchMode.LimitRatePress: await Util.RateLimitBatchProces(packages, SignalRUtils.StartConnect, concurrentConnection, fillTokenPerDuration, period); break; case SignalREnums.BatchMode.HighPress: await Util.BatchProcess(packages, SignalRUtils.StartConnect, concurrentConnection); break; case SignalREnums.BatchMode.LowPress: await Util.LowPressBatchProcess(packages, SignalRUtils.StartConnect, concurrentConnection, batchWaitMilliSeconds); break; } }
private async Task NormalConnectionLeaveGroup() { if (_connections.Count >= _groupCount) { await Task.WhenAll(from i in Enumerable.Range(0, _connections.Count) select SignalRUtils.LeaveFromGroup(_connections[i], SignalRUtils.GroupName(_type, _connectionIndex[i] % _groupCount), _statisticsCollector)); } else { var connectionCount = _connections.Count; await Task.WhenAll(from i in Enumerable.Range(0, _groupCount) select SignalRUtils.LeaveFromGroup(_connections[i % connectionCount], SignalRUtils.GroupName(_type, i), _statisticsCollector)); } }
public async Task <IDictionary <string, object> > Do( IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters) { try { // Here allow manually evaluate the "send" latency if "RecordLatency" callback is not registered HideRecordLatency = SignalRUtils.HideMessageRoundTripLatency(stepParameters, pluginParameters); await RunRest(stepParameters, pluginParameters); return(null); } catch (Exception ex) { var message = $"Fail to {GetType().Name}: {ex}"; Log.Error(message); throw; } }
public Task <IDictionary <string, object> > Do( IDictionary <string, object> stepParameters, IDictionary <string, object> pluginParameters) { stepParameters.TryGetTypedValue(SignalRConstants.Type, out string type, Convert.ToString); pluginParameters.TryGetTypedValue($"{SignalRConstants.ConnectionStore}.{type}", out IList <IHubConnectionAdapter> connections, (obj) => (IList <IHubConnectionAdapter>)obj); if (stepParameters.TryGetValue(SignalRConstants.ActionAfterConnect, out _)) { stepParameters.TryGetTypedValue(SignalRConstants.ActionAfterConnect, out string postAction, Convert.ToString); if (Enum.TryParse(postAction, out SignalREnums.ActionAfterConnection action)) { _action = action; } } _concurrentConnection = SignalRUtils.FetchConcurrentConnectionCountFromContext( pluginParameters, type, connections.Count); _type = type; // register the CTS to control the connector repairer. var cts = new CancellationTokenSource(); pluginParameters[$"{SignalRConstants.RepairConnectionCTS}.{type}"] = cts; _context = pluginParameters; _ = Task.Run(async() => { try { await Start(connections, cts); } catch (Exception e) { Log.Error($"Fail to repair the connection: {e.Message}"); } }); return(Task.FromResult <IDictionary <string, object> >(null));; }