static IConnectionPool <IMqttClient> CreateMqttConnectionPool(State state)
{
var mqttFactory = new MqttFactory();
return(ConnectionPool.Create(
name: "mqtt.connection.pool",
openConnection: () =>
{
var clientId = Guid.NewGuid().ToString("N");
var client = mqttFactory.CreateMqttClient();
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer(state.TargetMqttBrokerHost)
.WithCleanSession()
.WithClientId(clientId)
.Build();
client.UseConnectedHandler(e => client.SubscribeAsync($"requests/{clientId}"));
client.UseApplicationMessageReceivedHandler(msg =>
{
state.ClientResponses.SetResponse(clientId, msg.ApplicationMessage.Payload);
});
client.ConnectAsync(clientOptions, CancellationToken.None).Wait();
state.ClientResponses.InitClientId(clientId);
return client;
}));
}
public static void Run()
{
var url = "ws://localhost:5000";
var concurrentCopies = 50;
var webSocketsPool = ConnectionPool.Create(
name: "webSocketsPool",
connectionsCount: concurrentCopies,
openConnection: (number) =>
{
var ws = new ClientWebSocket();
ws.ConnectAsync(new Uri(url), CancellationToken.None).Wait();
return(ws);
},
closeConnection: (connection) =>
{
connection.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None)
.Wait();
}
);
var pingStep = Step.Create("ping", webSocketsPool, async context =>
{
var msg = new WebSocketRequest
{
CorrelationId = context.CorrelationId.Id,
RequestType = RequestType.Ping
};
var bytes = MsgConverter.ToJsonByteArray(msg);
await context.Connection.SendAsync(bytes, WebSocketMessageType.Text, true, context.CancellationToken);
return(Response.Ok());
});
var pongStep = Step.Create("pong", webSocketsPool, async context =>
{
while (true)
{
var(response, message) = await WebSocketsMiddleware.ReadFullMessage(context.Connection, context.CancellationToken);
var msg = MsgConverter.FromJsonByteArray <WebSocketResponse>(message);
if (msg.CorrelationId == context.CorrelationId.Id)
{
return(Response.Ok(msg));
}
}
});
var scenario = ScenarioBuilder
.CreateScenario("web_socket test", new[] { pingStep, pongStep })
.WithOutWarmUp()
.WithLoadSimulations(new[]
{
Simulation.KeepConcurrentScenarios(concurrentCopies, during: TimeSpan.FromSeconds(10))
});
NBomberRunner.RegisterScenarios(scenario)
.RunInConsole();
}
public VirtualRtuAdapter(RtuMap map, IChannel channel)
{
this.Id = Guid.NewGuid().ToString();
this.map = map;
this.channel = channel;
pool = ConnectionPool.Create();
client = pool.Take();
}
public static void Run()
{
var url = "ws://localhost:53231";
var webSocketsPool = ConnectionPool.Create("webSocketsPool",
openConnection: () =>
{
var ws = new ClientWebSocket();
ws.ConnectAsync(new Uri(url), CancellationToken.None).Wait();
return(ws);
},
closeConnection: (connection) =>
{
connection.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None)
.Wait();
});
//connectionsCount: 50);
var pingStep = Step.Create("ping", async context =>
{
var msg = new WebSocketRequest
{
CorrelationId = context.CorrelationId,
RequestType = RequestType.Ping
};
var bytes = MsgConverter.ToJsonByteArray(msg);
await context.Connection.SendAsync(bytes, WebSocketMessageType.Text, true, context.CancellationToken);
return(Response.Ok());
},
pool: webSocketsPool);
var pongStep = Step.Create("pong", async context =>
{
while (true)
{
var(response, message) = await WebSocketsMiddleware.ReadFullMessage(context.Connection, context.CancellationToken);
var msg = MsgConverter.FromJsonByteArray <WebSocketResponse>(message);
if (msg.CorrelationId == context.CorrelationId)
{
return(Response.Ok(msg));
}
}
},
pool: webSocketsPool);
var scenario = ScenarioBuilder.CreateScenario("web_socket test", pingStep, pongStep);
NBomberRunner.RegisterScenarios(scenario)
.RunInConsole();
}
private void CreateConnectionPool()
{
try
{
//JsonWebToken token = new JsonWebToken(config.SymmetricKey, config.GetClaimset(), config.LifetimeMinutes, config.Issuer, config.Audience);
//string securityToken = token.ToString();
string securityToken = GetSecurityToken("vrtu", "manage");
string url = string.Format($"wss://{config.PiraeusHostname}/ws/api/connect");
pool = ConnectionPool.Create(url, securityToken, config.PoolSize);
pool.Init();
}
catch (Exception ex)
{
Console.WriteLine($"Startup CreateConnectionPool - {ex.Message}");
throw ex;
}
}
public static Scenario BuildScenario()
{
var url = "ws://localhost:53231";
var webSocketsPool = ConnectionPool.Create("webSocketsPool",
openConnection: () =>
{
var ws = new ClientWebSocket();
ws.ConnectAsync(new Uri(url), CancellationToken.None).Wait();
return(ws);
},
closeConnection: (connection) =>
{
connection.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None)
.Wait();
});
//connectionsCount: 50);
var pingStep = Step.CreatePull("ping", webSocketsPool, async context =>
{
var msg = new WebSocketRequest
{
CorrelationId = context.CorrelationId,
RequestType = RequestType.Ping
};
var bytes = MsgConverter.ToJsonByteArray(msg);
await context.Connection.SendAsync(bytes, WebSocketMessageType.Text, true, CancellationToken.None);
return(Response.Ok());
});
var pongStep = Step.CreatePush("pong", webSocketsPool, async context =>
{
var(response, message) = await WebSocketsMiddleware.ReadFullMessage(context.Connection);
var msg = MsgConverter.FromJsonByteArray <WebSocketResponse>(message);
if (msg.CorrelationId == context.CorrelationId)
{
context.UpdatesChannel.ReceivedUpdate(Response.Ok(msg));
}
});
return(ScenarioBuilder.CreateScenario("web_socket test", pingStep, pongStep));
}
public void Sequential_clients_reuse_connection()
{
var pool = ConnectionPool.Create(TestConfig.Host, TestConfig.Port);
Assert.AreEqual(0, pool.ActiveConnections);
Assert.AreEqual(0, pool.IdleConnections);
using (var client = new BeanstalkClient(pool)) {
var data = "abc";
var stream = data.AsStream();
var put = client.Put(100, TimeSpan.Zero, TimeSpan.FromMinutes(2), stream, data.Length);
var reserve = client.Reserve();
Assert.AreEqual(put.JobId, reserve.Id);
Assert.IsTrue(client.Delete(reserve.Id));
using (var reader = new StreamReader(reserve.Data)) {
Assert.AreEqual(data, reader.ReadToEnd());
}
Assert.AreEqual(1, pool.ActiveConnections);
Assert.AreEqual(0, pool.IdleConnections);
}
Assert.AreEqual(0, pool.ActiveConnections);
Assert.AreEqual(1, pool.IdleConnections);
using (var client = new BeanstalkClient(pool)) {
var data = "abc";
var stream = data.AsStream();
var put = client.Put(100, TimeSpan.Zero, TimeSpan.FromMinutes(2), stream, data.Length);
var reserve = client.Reserve();
Assert.AreEqual(put.JobId, reserve.Id);
Assert.IsTrue(client.Delete(reserve.Id));
using (var reader = new StreamReader(reserve.Data)) {
Assert.AreEqual(data, reader.ReadToEnd());
}
Assert.AreEqual(1, pool.ActiveConnections);
Assert.AreEqual(0, pool.IdleConnections);
}
Assert.AreEqual(0, pool.ActiveConnections);
Assert.AreEqual(1, pool.IdleConnections);
}