public DeviceController(WebSocketHandler websocketHandler, DeviceService deviceService, HeartbeatService heartbeatService, AlertService alertService)
{
_deviceService = deviceService;
_heartbeatService = heartbeatService;
_alertService = alertService;
_websocketHandler = websocketHandler;
}
public PreloadService(IServiceProvider provider, HeartbeatService heartbeatService)
{
var classes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypes()).Where(x =>
x != typeof(PreloadService) && !x.IsInterface && !x.IsAbstract && typeof(IPreload).IsAssignableFrom(x)).ToList();
_preloaders = classes.Select(type => (IPreload)ActivatorUtilities.CreateInstance(provider, type)).ToList();
heartbeatService.Beat += Preload;
}
public async Task StartAsync_CancelBeforeStart()
{
var connectionService = new FakeIWebSocketConnectionsService();
var service = new HeartbeatService(connectionService);
CancellationTokenSource source = new CancellationTokenSource();
CancellationToken token = source.Token;
source.Cancel();
await service.StartAsync(token);
Assert.AreEqual(0, connectionService.FakeSendToAllAsync.Count);
}
public MainViewModel(AuthorizationService authorizationService)
{
_authorizationService = authorizationService;
_heartbeatService = new HeartbeatService(_authorizationService);
ClosingCommand = new AsyncCommand <object>(async(unused, token) => await _heartbeatService.Stop());
ViewUpdatedCommand = new RelayCommand(o =>
{
OnPropertyChanged("CurrentContent");
}, o => true);
CreateNavigation();
}
public async Task StartAsyncStop()
{
var connectionService = new FakeIWebSocketConnectionsService();
var service = new HeartbeatService(connectionService);
CancellationTokenSource source = new CancellationTokenSource();
CancellationToken token = source.Token;
await service.StartAsync(token);
await service.StopAsync(token);
Assert.IsTrue(connectionService.FakeSendToAllAsync.LastOrDefault()?.Contains("dateTime"));
}
public void beats_regularly()
{
// ARRANGE
var hearbeat = new HeartbeatService(TimeSpan.FromMilliseconds(200), _schedulerService);
// ACT
var beats = new List <Unit>();
hearbeat.Listen.Subscribe(x => beats.Add(x));
_testScheduler.AdvanceBy(TimeSpan.FromMilliseconds(450));
// ASSERT
Assert.That(beats, Is.Not.Empty);
Assert.That(beats.Count, Is.EqualTo(2));
}
public void disposing_stops_the_heart_beating()
{
// ARRANGE
var hearbeat = new HeartbeatService(TimeSpan.FromMilliseconds(200), _schedulerService);
// ACT
var beats = new List <Unit>();
hearbeat.Listen.Subscribe(x => beats.Add(x));
hearbeat.Dispose();
_testScheduler.AdvanceBy(TimeSpan.FromMilliseconds(450));
// ASSERT
Assert.That(beats, Is.Empty);
}
private static BaseResponse GetResponse(Methods methodCalled, PingRequest ahRequest)
{
string className = "SFGWrapper.Heartbeat";
BaseResponse baseResponse = new BaseResponse();
try
{
using (HeartbeatService svc = new HeartbeatService())
{
svc.Timeout = 20000;
svc.Credentials = new System.Net.NetworkCredential(ahRequest.ServiceUsername, ahRequest.ServicePassword);
argtype sfgRequest = HeartbeatTranslators.TranslateToSfgRequest(ahRequest);
switch (methodCalled)
{
case Methods.PING:
baseResponse = HeartbeatTranslators.Ping(svc.process_wsdl(sfgRequest));
break;
}
}
if (baseResponse == null)
{
baseResponse = new BaseResponse();
FatalErrorResponse fatalError = new FatalErrorResponse();
baseResponse.TypedResponse = fatalError;
baseResponse.Messages.Add(new Message("SFGFatalError"));
}
}
catch (Exception ex)
{
baseResponse = new BaseResponse();
FatalErrorResponse fatalError = new FatalErrorResponse();
baseResponse.TypedResponse = fatalError;
Message error = new Message("UnknownException");
baseResponse.DebugStringLog.Add(ex.TargetSite.Name);
baseResponse.DebugStringLog.Add(ex.Message);
baseResponse.DebugStringLog.Add(ex.StackTrace);
baseResponse.Messages.Add(error);
EventLogger.LogError(string.Format("{0}.{1}()", new object[] { className, methodCalled.ToString() }),
string.Format("Message: {0} \r\nStackTrace: {1}", ex.Message, ex.StackTrace));
}
return(baseResponse);
}
public bool Handle(EventBus.Events.UserOnlineStateChangedEvent evt)
{
try
{
if (evt == null || evt.UserID == "@TLS#ERROR")
{
return(true);
}
var userService = new BLL.Sys.Implements.ConversationIMUidService("");
var userids = userService.GetUserIdByUids(new int[] { int.Parse(evt.UserID) });
if (userids.Count > 0)
{
ConversationRoomService bllRoom = new ConversationRoomService();
var heartService = new HeartbeatService();
var userId = userids[0];
if (evt.Action == "Logout")
{
//断开连接时设置房间状态（断开）
bllRoom.Disconnection(userId);
heartService.SetAppHeartBeat(userId, false);
}
else if (evt.Action == "Login")
{
heartService.SetAppHeartBeat(userId, true);
}
}
else
{
return(true);
}
}
catch (Exception E)
{
LogHelper.WriteError(E);
return(false);
}
return(true);
}
public async Task <SkillResponse> AlexaHandler(SkillRequest skillRequest, ILambdaContext lambdaContext)
{
if (skillRequest.Request is IntentRequest && skillRequest.Request.RequestId == "HEARTBEAT")
{
return(HeartbeatService.SendHeartbeat());
}
Logger.Init(lambdaContext);
if (skillRequest.Request is IntentRequest intentRequest)
{
return(await HandleIntent(intentRequest.Intent, skillRequest.Session.User.UserId));
}
else if (skillRequest.Request is SkillEventRequest)
{
return(await HandleSkillEvent(skillRequest));
}
else
{
return(ResponseBuilder.Tell("I'm sorry, I couldn't understand your request. Please rephrase it or try again later."));
}
}
/// <summary>
/// 获取连接请求处理 委托
/// </summary>
/// <param name="heartbeatService"></param>
/// <returns></returns>
private Func <TcpClient, CancellationToken, Task> GetRequestConnectionEventHandle(HeartbeatService heartbeatService, ForwardRuleDetail forwardRuleDetail)
{
return(async(tcp, serviceToken) =>
{
var remoteEndPoint = tcp.Client.RemoteEndPoint;
Action EndNotice = null;
try
{
_logger.LogInformation("接收到访问请求:ClientId, {0}:{1}, 访问者:{2}", forwardRuleDetail.ClientId, forwardRuleDetail.RuleId, remoteEndPoint);
var(serverTcp, EndNotice2) = await heartbeatService.GetRequestTcpClient(serviceToken, forwardRuleDetail);
EndNotice = EndNotice2;
if (serverTcp == null)
{
_logger.LogInformation("连接请求失败: 未获得服务端tcp连接");
return;
}
using (var forwarder = new Forwarder(tcp, serverTcp))
{
await forwarder.Start();
}
}
catch (IOException ex)
{
_logger.LogInformation("数据转发连接断开:ClientId, {0}:{1}, 访问者:{2}, {3}", forwardRuleDetail.ClientId, forwardRuleDetail.RuleId, remoteEndPoint, ex.Message);
}
catch (Exception ex)
{
_logger.LogError(ex, "数据转发出现异常:ClientId, {0}:{1}, 访问者:{2}", forwardRuleDetail.ClientId, forwardRuleDetail.RuleId, remoteEndPoint);
}
EndNotice?.Invoke();
});
}
/// <summary>
/// 构建转发连接处理服务
/// </summary>
/// <param name="heartbeatLifetime"></param>
/// <param name="heartbeatService"></param>
/// <returns></returns>
private IEnumerable <Task> BuildHeartbeatService(IServiceProvider heartbeatLifetime, HeartbeatService heartbeatService)
{
foreach (var client in _settings.Clients)
{
_logger.LogWarning("侦听客户端的连接端口:{0}", client.ClientId);
foreach (var rule in client.ForwardRules)
{
var detail = new ForwardRuleDetail
{
ClientId = client.ClientId,
ClientKey = client.ClientKey,
RuleId = rule.RuleId,
ListenerPort = rule.ListenerPort
};
var rcs = heartbeatLifetime.GetRequiredService <RequestConnectionService>();
rcs.RequestConnectionEvent += GetRequestConnectionEventHandle(heartbeatService, detail);
yield return(rcs.Start(detail.ListenerPort));
_logger.LogWarning("侦听连接端口:{0}, {1}:{2}", client.ClientId, rule.RuleId, rule.ListenerPort);
}
}
}
public HeartbeatController(HeartbeatService heartbeatService)
{
_heartbeatService = heartbeatService;
}
