private async Task <HubConnection> GetConnection()
{
var connection = new HubConnectionBuilder()
.WithUrl($"{_option.ApiUrl.ToString()}{JobQueueHubEndpoint}", options =>
{
options.AccessTokenProvider = () => Task.FromResult(_option.AuthorizationToken);
options.CloseTimeout = _option.ApiRequestTimeout;
})
.Build();
await connection.StartAsync();
return(connection);
}
static async Task Main(string[] args)
{
Console.Write("Username: "******"Password: "******"";
while (true)
{
var key = Console.ReadKey(intercept: true);
if (key.Key == ConsoleKey.Enter)
{
break;
}
password += key.KeyChar;
}
var hubConnection = new HubConnectionBuilder()
.WithUrl($"{baseUrl}/chat", options =>
{
options.AccessTokenProvider = async() =>
{
var stringData = JsonConvert.SerializeObject(new
{
username,
password
});
var content = new StringContent(stringData);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var response = await httpClient.PostAsync($"{baseUrl}/api/token", content);
response.EnsureSuccessStatusCode();
return(await response.Content.ReadAsStringAsync());
};
})
.Build();
hubConnection.On <string, string>("newMessage",
(sender, message) => Console.WriteLine($"{sender}: {message}"));
await hubConnection.StartAsync();
System.Console.WriteLine("\nConnected!");
while (true)
{
var message = Console.ReadLine();
await hubConnection.SendAsync("SendMessage", message);
}
}
private async Task ServerClosesConnectionWithErrorIfHubCannotBeCreated(TransportType transportType)
{
using (StartLog(out var loggerFactory, testName: $"ConnectionCanSendAndReceiveMessages_{transportType.ToString()}"))
{
var logger = loggerFactory.CreateLogger <EndToEndTests>();
var url = _serverFixture.BaseUrl + "/uncreatable";
var connection = new HubConnectionBuilder()
.WithUrl(new Uri(url))
.WithTransport(transportType)
.WithLoggerFactory(loggerFactory)
.Build();
try
{
var closeTcs = new TaskCompletionSource <object>();
connection.Closed += e =>
{
logger.LogInformation("Connection closed");
if (e != null)
{
closeTcs.TrySetException(e);
}
else
{
closeTcs.TrySetResult(null);
}
return(Task.CompletedTask);
};
logger.LogInformation("Starting connection to {url}", url);
await connection.StartAsync().OrTimeout();
await closeTcs.Task.OrTimeout();
}
catch (Exception ex)
{
logger.LogInformation(ex, "Test threw exception");
throw;
}
finally
{
logger.LogInformation("Disposing Connection");
await connection.DisposeAsync().OrTimeout();
logger.LogInformation("Disposed Connection");
}
}
}
static async Task Main(string[] args)
{
var connection = new HubConnectionBuilder().WithUrl("https://localhost:5001/chat")
.WithAutomaticReconnect()
.AddJsonProtocol().Build();
connection.Closed += async(error) =>
{
await Task.Delay(new Random().Next(0, 5) * 1000);
await connection.StartAsync();
};
connection.On <string, string>("inMessage", (name, text) =>
{
Console.WriteLine($"{name}: {text}");
});
connection.On <string>("aggregation", (aggregation) =>
{
Console.WriteLine(aggregation);
});
await connection.StartAsync();
while (true)
{
var line = Console.ReadLine();
if (line == "q")
{
break;
}
await connection.SendAsync("Send", "Console", line, "1");
}
await connection.StopAsync();
}
static async Task Main(string[] args)
{
var accessToken = "{generate the access token}";
var hubName = "chat";
var endpoint = "{the endpoint from the connection string}/client/";
var connection = new HubConnectionBuilder().WithUrl(
$"wss://{endpoint}?hub={hubName}&asrs.op=%2F{hubName}"
, HttpTransportType.WebSockets,
s =>
{
s.AccessTokenProvider = () => Task.FromResult(accessToken);
s.SkipNegotiation = true;
}
).ConfigureLogging(logging =>
{
logging.AddConsole();
logging.SetMinimumLevel(LogLevel.Debug);
})
.Build();
connection.Closed += async(error) =>
{
Console.WriteLine(error.Message);
await Task.Delay(new Random().Next(0, 5) * 1000);
await connection.StartAsync();
};
connection.On <string, string>("broadcastMessage", (name, message) =>
{
Console.WriteLine(name + ":" + message);
});
await connection.StartAsync();
Console.ReadKey();
}
static async Task Main(string[] args)
{
Console.BackgroundColor = ConsoleColor.Blue;
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("Signal-R Sender!");
const string url = "http://localhost:5000/hubs/sensors";
// dotnet add package Microsoft.AspNetCore.SignalR.Client
HubConnection connection = new HubConnectionBuilder()
.WithUrl(url)
.Build();
System.Console.WriteLine("Connecting...");
await connection.StartAsync();
System.Console.WriteLine("Connected.");
while (true)
{
// dotnet add package Bogus
var faker = new Faker <Measure>()
.RuleFor(p => p.DeviceId, "temp-001")
.RuleFor(p => p.Temperature, f => f.Random.Float(20, 40));
Measure measure = faker.Generate();
// Measure measure = new Measure
// {
// DeviceId = "temp-001",
// Temperature = 26.04f
// };
await connection.SendAsync("MeasureAdded", measure);
System.Console.WriteLine($"Sent {measure.Temperature}");
await Task.Delay(TimeSpan.FromSeconds(1));
}
System.Console.WriteLine("Press enter key to exit.");
Console.ReadLine();
Console.ResetColor();
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
HubConnection hubConnection = new HubConnectionBuilder().WithUrl($"{Configuration["ApiBase"]}/hub").Build();
hubConnection.On <ServiceConfig>("AddServerConfig", x =>
{
_logger.LogInformation("Adding {service}", x.ServiceName);
services.Add(x);
});
hubConnection.On <ServiceConfig>("RemoveService", x =>
{
_logger.LogInformation("Removing {service}", x.ServiceName);
services.RemoveAt(services.FindIndex(0, s => s.ServiceName == x.ServiceName));
});
await hubConnection.StartAsync();
await hubConnection.SendAsync("RegisterServer", Environment.MachineName);
int interval = await service.GetInterval();
services = await service.GetServices(Environment.MachineName);
if (interval == 0)
{
interval = 1;
}
while (!stoppingToken.IsCancellationRequested)
{
_logger.LogInformation("Checking {count} service(s)", services.Count);
Parallel.ForEach(services, async item =>
{
try
{
_logger.LogInformation("Checking service {name}", item.ServiceName);
using var ps = PowerShell.Create();
var results = ps.AddScript($"get-service {item.ServiceName} ").Invoke();
foreach (var result in results)
{
var isRunning = result.Properties["Status"].Value.ToString() == "Running";
await service.UpdateStatus(item.Id, isRunning ? "Up" : "Down");
_logger.LogInformation("Service {name} is {status}", item.ServiceName, isRunning ? "Up" : "Down");
}
}
catch (Exception ex) { _logger.LogError("Error", ex); }
});
await Task.Delay(TimeSpan.FromMinutes(interval), stoppingToken);
}
}
private async Task SetupSignalR()
{
var uri = new Uri($"{_config[Constants.CONFIG_SIGNALR_URI]}");
var hubConnection = new HubConnectionBuilder()
.WithAutomaticReconnect()
.WithUrl(uri)
.Build();
hubConnection.On <ChannelActivityEntity>("UpdateChannelState", async entity =>
{
var activity = (StreamActivity)Enum.Parse(typeof(StreamActivity), entity.Activity);
switch (activity)
{
case StreamActivity.StreamStarted:
await Start(entity.PartitionKey);
break;
case StreamActivity.StreamStopped:
await Stop(entity.PartitionKey);
break;
case StreamActivity.MessagePosted:
break;
case StreamActivity.UserJoined:
break;
case StreamActivity.UserLeft:
break;
case StreamActivity.UserFollowed:
break;
case StreamActivity.UserSubscribed:
break;
case StreamActivity.ViewerTimestamped:
break;
default:
throw new ArgumentOutOfRangeException();
}
});
hubConnection.On <string>("UpdatePassword", async passwordText => { await UpdatePassword(passwordText); });
await hubConnection.StartAsync().ConfigureAwait(false);
_logger.LogInformation($"{DateTime.UtcNow.ToString(CultureInfo.CurrentUICulture)}: Connected to SignalR hub {uri} - {hubConnection.ConnectionId}");
}
private static async Task Main(string[] args)
{
//HubConnectionオブジェクトを使ってサーバーのSignalRハブと通信する
HubConnection connection;
//SignalRハブとの通信を担うオブジェクトを生成
connection = new HubConnectionBuilder()
.WithUrl("https://localhost:44304/mysignalrhub")
.WithAutomaticReconnect()
.Build();
//クライアント側の受信時の処理を行うメソッドを登録する。
//文字列で指定した名前でサーバー側から呼び出される。
connection.On <string>("ReceiveMessage", (string messageFromServer) =>
{
Console.WriteLine($"サーバーから{DateTimeOffset.Now.ToString("yyyy/MM/dd/HH:mm:ss.fff")}に受信:\n {messageFromServer}");
});
try
{
//サーバー側のSignalRハブと接続
await connection.StartAsync();
Console.WriteLine("接続できました");
}
catch (Exception ex)
{
Console.WriteLine("接続できませんでした");
}
while (true)
{
Console.Write("メッセージを入力: ");
string input = Console.ReadLine();
try
{
//メッセージ送信
await connection.InvokeAsync <string>("SendToAllAsync", input);
}
catch (Exception ex)
{
Console.WriteLine("メッセージの送信に失敗しました");
}
Thread.Sleep(500);
}
}
static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
HubConnection connection = new HubConnectionBuilder()
.WithUrl("http://localhost:5001/notification")
.Build();
connection.On <string>("HandleNotification", (message) =>
{
Console.WriteLine(message);
});
await connection.StartAsync();
Console.ReadKey();
}
private static async Task Listen()
{
var connection = new HubConnectionBuilder()
.WithUrl("http://localhost:56428/chat")
.Build();
connection.On <string>("broadcast", (message) =>
{
Console.WriteLine(message);
});
await connection.StartAsync();
Console.WriteLine("Listening...");
}
static async Task Main(string[] args)
{
var connection = new HubConnectionBuilder()
.WithUrl("http://localhost:5000/chatHub")
.Build();
connection.On <string, string>("ReceiveMessage", (user, message) =>
{
Console.WriteLine($"{user} says {message}");
});
await connection.StartAsync();
Console.ReadKey();
}
public Launcher()
{
_queues = new List <BufferBlock <string> >();
_cancellationTokenSource = new CancellationTokenSource();
_tasks = new List <Task>();
var connection = new HubConnectionBuilder()
.WithUrl("http://localhost:5000/hub")
.Build();
connection.On <string>("message", HandleMessage);
connection.StartAsync().Wait();
}
public async Task <IActionResult> Get()
{
var connection = new HubConnectionBuilder()
.WithUrl("wss://localhost:44302/readvalues").Build();
connection.On("test", (string deviceId, string value) =>
{
Console.WriteLine(deviceId, value);
});
await connection.StartAsync();
await connection.InvokeAsync("SendMessage", "test", "hello from server");
return(Ok());
}
protected override async Task OnInitializedAsync()
{
await LoadDataAsync();
hubConnection = new HubConnectionBuilder()
.WithUrl(_navigationManager.ToAbsoluteUri("/signalRHub"))
.WithUrl(_navigationManager.ToAbsoluteUri("/signalRHub"))
.Build();
hubConnection.On("UpdateDashboard", async() =>
{
await LoadDataAsync();
StateHasChanged();
});
await hubConnection.StartAsync();
}
public async Task Run()
{
WriteLine("Press any key to exit.");
var connection = new HubConnectionBuilder()
.WithUrl(Endpoint).Build();
connection.On <BuildingActionSnaphotDto>("SendBuildingState", buildingSnapshot =>
{
WriteLine("Received message");
WriteLine(JsonSerializer.Serialize(buildingSnapshot));
});
await connection.StartAsync().ConfigureAwait(false);
ReadLine();
}
private async Task _SignalRHelper_HubReceiverContainer_Gets_From_Server()
{
var hc = new HubConnectionBuilder()
.WithUrl(ProxyTestHostHolder._mainHubString).Build();
await hc.StartAsync();
var client = HubProxyBuilder.CreateProxy <IBar>(hc);
var hubRec = new HubReceiverContainer <IFoo>(hc, new FooImpl());
await client.StringType("hello");
SpinWait.SpinUntil(() => false, TimeSpan.FromSeconds(2));
Assert.True(FooImpl.callCounter["hello"] > 0);
GC.KeepAlive(hubRec);
hubRec.Dispose();
}
public async Task AlwaysSendAttribute_Is_Respected()
{
var hc = new HubConnectionBuilder()
.WithUrl(ProxyTestHostHolder._mainHubString).Build();
await hc.StartAsync();
var client = HubProxyBuilder.CreateProxy <IBar>(hc, true);
await client.StreamToServerSend(clientStreamData(), "asend");
Assert.Throws <KeyNotFoundException>(() =>
GroupHub.streamCounter["asend"].Count);
await Task.Delay(TimeSpan.FromSeconds(5));
Assert.Equal(5, GroupHub.streamCounter["asend"].Count);
}
public void BuildServerConnection()
{
HubConnection connection = new HubConnectionBuilder()
.WithUrl("http://localhost:5000/marketDataHub")
.WithAutomaticReconnect() //handel lost connection
.Build();
Logger.LogInformation("Main thread ID" + Thread.CurrentThread.ManagedThreadId);
//on close event
connection.Closed += async(error) =>
{
await Task.Delay(new Random().Next(0, 5) * 1000);
await connection.StartAsync();
};
connection.Reconnecting += error =>
{
Debug.Assert(connection.State == HubConnectionState.Reconnecting);
Logger.LogInformation("Connection lost, trying to reconnect");
return(Task.CompletedTask);
};
connection.Reconnected += connectionId =>
{
Debug.Assert(connection.State == HubConnectionState.Connected);
return(Task.CompletedTask);
};
//on market data notification received
connection.On <List <MarketDataModelPresenter> >("PublishMarketDataList", (data) => UpdateStockGrid(data));
//Open client server connection
connection.StartAsync();
}
public async Task StartToListen()
{
var _connection = new HubConnectionBuilder()
.WithUrl("http://localhost:64480/sensorshub")
.Build();
_connection.On <SensorDataDto>("SensorData", sensorData =>
{
Console.WriteLine($"New SensorData received (id: {sensorData.Id})");
_sensorDataProducer.Produce(sensorData);
});
await _connection.StartAsync();
}
private async Task ConfigurarSignalR(ObservableCollection <Promocao> promocoes)
{
var connection = new HubConnectionBuilder()
.WithAutomaticReconnect()
.WithUrl("https://realpromoapiwebabb.azurewebsites.net/PromoHub").Build();
connection.On <Promocao>("receberPromocao", (promocao) =>
{
Xamarin.Forms.Device.InvokeOnMainThreadAsync(() => {
promocoes.Add(promocao);
});
});
await connection.StartAsync();
}
static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
HubConnection connection = new HubConnectionBuilder()
.WithUrl("http://localhost:18128/ChatHub")
.WithAutomaticReconnect()
.Build();
await connection.StartAsync();
string message = Console.ReadLine();
await connection.InvokeAsync("SendMessage", "Agent", message);
}
internal static IServiceCollection AddSignalRConnection(this IServiceCollection services, string hubUrl)
{
HubConnection connection = new HubConnectionBuilder()
.WithUrl(hubUrl)
.Build();
connection.Closed += async(error) =>
{
Console.WriteLine("Reconnect");
await Task.Delay(new Random().Next(0, 5) * 1000);
await connection.StartAsync();
};
connection.On <string>("OnEvent", message => {
// TODO: message processing here
Console.WriteLine(message);
});
connection.StartAsync();
services.AddSingleton <HubConnection>(connection);
return(services);
}
/// <summary>
/// TO DO : Client should be able to subscribe the ohlc data by passing stock name
/// Currently and empty string is passed. This will perform ohlc analysis on all the feed.
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
var connection = new HubConnectionBuilder()
.WithUrl("http://localhost:5000/ohlchub")
.Build();
connection.StartAsync().Wait();
connection.InvokeCoreAsync("SendMessage", args: new[] { "subscribe", "", "15" });
connection.On("ReceiveMessage", (string eventname, string stockname) =>
{
Console.WriteLine("Running Analyzer on Server " + stockname);
});
Console.ReadLine();
}
public async Task <JoinResponse> Connect(int meetingId)
{
MeetingId = meetingId;
Connection = new HubConnectionBuilder()
.WithUrl("http://192.168.0.73:5000/game",
options => { options.Headers.Add("Authorization", $"Bearer {_token.Token}"); })
.Build();
await Connection.StartAsync();
Connection.On <ClientResponse>("TaskChange", OnTaskChanged);
Connection.On <OrganizerResponse>("Submitted", OnSubmitted);
Connection.On("CloseWindow", OnCLoseWindow);
return(await Connection.InvokeAsync <JoinResponse>("join", MeetingId));
}
/// <summary>
/// Open connection
/// </summary>
/// <returns></returns>
private async Task <HubConnection> OpenAsync()
{
var connection = new HubConnectionBuilder()
.WithAutomaticReconnect()
.AddNewtonsoftJsonProtocol(options => {
options.PayloadSerializerSettings = JsonConvertEx.GetSettings();
})
.WithUrl(_endpointUri)
.Build();
connection.Closed += ex => OnClosedAsync(connection, ex);
await connection.StartAsync();
return(connection);
}
private static async Task <HubConnection> Connect(string endpoint)
{
var connection = new HubConnectionBuilder()
.WithUrl(endpoint)
.AddNewtonsoftJsonProtocol(s => s.PayloadSerializerSettings.ConfigureRemoteLinq())
.Build();
while (connection.State == HubConnectionState.Disconnected) // Wait for server to start
{
try { await connection.StartAsync(); }
catch (HttpRequestException ex) { Console.WriteLine("Error connecting to server: " + ex.Message); }
}
return(connection);
}
// <= C# 7.0
// static void Main(string[] args) => MainAsync(args).GetAwaiter().GetResult();
// dotnet add package Microsoft.AspNetCore.SignalR.Client
static async Task Main(string[] args)
{
Console.BackgroundColor = ConsoleColor.Green;
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("Hello Signal-R Sender!");
const string url = "http://localhost:5000/signalr/chatter";
HubConnection connection = new HubConnectionBuilder()
.WithUrl(url)
.Build();
Console.WriteLine("connecting...");
await connection.StartAsync();
Console.WriteLine("Connected.");
//while(true)
//{
// Console.Write("Type message: ");
// string content = Console.ReadLine();
// ChatMessage message = new ChatMessage { Content = content };
// await connection.SendAsync("SendMessage", message, "Klon");
//}
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 0; i < 10000; i++)
{
ChatMessage message = new ChatMessage {
Content = $"Temp {i}"
};
await connection.SendAsync("SendMessage", message, "Klon");
}
stopwatch.Stop();
Console.WriteLine($"elapsed time: {stopwatch.Elapsed}");
Console.ReadKey();
Console.ResetColor();
}
private static async Task WaitingForMessage(string[] args)
{
//HubConnection connection;
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("https://netconfbcn2019demo2publishtosignalr.azurewebsites.net");
HttpResponseMessage response = await client.GetAsync("/api/negotiatevotingresults");
response.EnsureSuccessStatusCode();
var content = JsonConvert.DeserializeObject <NegotiateResponse>(await response.Content.ReadAsStringAsync());
string token = content.Accesstoken;
string url = content.Url;
var connection = new HubConnectionBuilder()
.WithUrl(url, options => {
options.AccessTokenProvider = () => Task.FromResult(token);
})
.Build();
connection.StartAsync().ContinueWith(task => {
if (task.IsFaulted)
{
Console.WriteLine("Se ha producido un error al establecer la conexión: {0}",
task.Exception.GetBaseException());
}
else
{
Console.WriteLine("Connected");
connection.On <string>("VotingResults", (resultados) => {
Console.WriteLine($"{resultados}");
});
while (true)
{
string message = Console.ReadLine();
if (string.IsNullOrEmpty(message))
{
break;
}
}
}
}).Wait();
await connection.StopAsync();
}
private async Task <HubConnection> SetUpHubConnection(ConnectionString connectionString, string hubUrl, string nameIdentifier)
{
var accessTokensService = new AccessTokensService();
var accessToken = accessTokensService.GenerateAccessToken(connectionString, hubUrl, nameIdentifier);
var hubConnection = new HubConnectionBuilder()
.WithUrl(hubUrl, options =>
{
options.AccessTokenProvider = () => Task.FromResult(accessToken);
})
.Build();
await hubConnection.StartAsync();
return(hubConnection);
}