public void Init()
{
if (_connGateway == null)
{
switch (GameService.CommandInfo.Protocol)
{
case GsEncryptor.TcpSec:
_connGateway = new GsTcpClient();
break;
case GsEncryptor.WebSocketSec:
_connGateway = new GsWebSocketClient();
break;
}
if (_connGateway != null)
{
_connGateway.DataReceived += OnDataReceived;
}
}
_cancellationToken = new CancellationTokenSource();
if (IsInitializing)
{
return;
}
IsInitializing = true;
PingUtil.Stop();
_connGateway?.Init(GameService.CommandInfo, GameService.CommandInfo.Cipher);
}
private void OnAuth(object sender, string playerHash)
{
DebugUtil.LogNormal <CommandHandler>(DebugLocation.Command, "OnAuth", "CommandHandler OnAuth Done");
IsInitializing = false;
PlayerHash = playerHash;
_connGateway?.StartSending();
PingUtil.Start();
if (_isFirstInit)
{
return;
}
_isFirstInit = true;
try
{
if (GameService.HandlerType == EventHandlerType.NativeContext)
{
CoreEventHandlers.SuccessfullyLogined?.Invoke(null, null);
}
else
{
GameService.SynchronizationContext?.Send(
delegate { CoreEventHandlers.SuccessfullyLogined?.Invoke(null, null); }, null);
}
}
catch (Exception)
{
// ignored
}
}
private void WorkerOnDoWork(object sender, DoWorkEventArgs doWorkEventArgs)
{
WorkerParam param = doWorkEventArgs.Argument as WorkerParam;
doWorkEventArgs.Result = new WorkerResult()
{
Times = PingUtil.Ping(param.Address),
RowIndex = param.RowIndex
};
}
private void UpdateRow(WorkerResult result)
{
PingUtil.AnalyzePingResult(result.Times, out var min, out var max, out var avg);
var row = dgvResult.Rows[result.RowIndex];
row.Cells["PingResult"].Value = string.Join(";", result.Times);
row.Cells["Min"].Value = min;
row.Cells["Max"].Value = max;
row.Cells["Avg"].Value = avg;
}
private void OnMirror(object sender, Packet packet)
{
try
{
var currentTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
var lastCurrentTime = long.Parse(packet.Data);
PingUtil.SetLastPing(currentTime, lastCurrentTime);
}
finally
{
_retryPingCounter = 0;
_isPingRequested = false;
}
}
private void PingServers(LoadBalancerRoute route)
{
PingUtil pingUtil = new PingUtil(_loadBalancerContext, _logger);
if (pingUtil.HasPing)
{
foreach (ServerGroup serverGroup in route.ServerGroups)
{
foreach (Server server in serverGroup.Servers)
{
server.IsAlive = pingUtil.IsAlive(server);
}
}
}
}
public PingViewModel(Reading reading)
{
try
{
Host = string.Format("Pinging {0}", reading.Reader.Host);
Task.Run(() =>
{
while (true)
{
string info = string.Empty;
info += string.Format("{0}: Pinging {1}...", DateTime.Now.ToString(Consts.TIME_FORMAT), reading.Reader.Host);
Application.Current.Dispatcher.Invoke((Action)(() =>
{
PingInfo += info;
}));
info = string.Empty;
if (PingUtil.PingHost(reading.Reader.Host) == true)
{
info += string.Format(" OK");
}
else if (PingUtil.PingHostViaTcp(reading.Reader.Host, Consts.PING_PORT) == true)
{
info += string.Format(" OK");
}
else
{
info += string.Format(" Request Timeout.");
}
info += Environment.NewLine;
Thread.Sleep(50);
Application.Current.Dispatcher.Invoke((Action)(() =>
{
PingInfo += info;
}));
Thread.Sleep(1500);
}
});
}
catch (Exception ex)
{
Debug.WriteLine(string.Format("{0}: {1}\n{2}", nameof(PingViewModel), ex.Message, ex.StackTrace));
}
}
public void Dispose(bool isGraceful)
{
try
{
_isDisposed = true;
_isFirstInit = false;
_isPingRequested = false;
IsInitializing = false;
_retryConnectCounter = 0;
_retryPingCounter = 0;
_cancellationToken?.Cancel(false);
_observer?.Dispose();
PingUtil.Dispose();
_connGateway?.StopReceiving(isGraceful);
}
catch (Exception)
{
// ignored
}
finally
{
_connGateway = null;
PlayerHash = null;
CommandEventHandlers.CommandAuthorized = null;
CommandEventHandlers.CommandClientConnected = null;
CommandEventHandlers.GsCommandClientConnected = null;
CommandEventHandlers.GsCommandClientError = null;
CommandEventHandlers.CommandPing = null;
CommandEventHandlers.CommandMirror = null;
try
{
GC.SuppressFinalize(this);
}
catch (Exception)
{
// ignored
}
DebugUtil.LogNormal <CommandHandler>(DebugLocation.Command, "Dispose", "CommandHandler Dispose Done");
}
}
public DefaultServerSourceMonitor(ILoadBalancerContext loadBalancerContext)
{
_loadBalancerContext = loadBalancerContext;
_pingUtil = new PingUtil(_loadBalancerContext, _logger);
var configurationManager = _loadBalancerContext.ConfigurationManager;
string prefix = _loadBalancerContext.LoadBalancerKey;
CheckIntervalInMillisecondProperty = configurationManager.GetProperty <int?>(prefix + "." + ConfigurationKeys.CheckInterval);
FailureThresholdPercentageProperty = configurationManager.GetProperty <int?>(prefix + "." + ConfigurationKeys.FailureThresholdPercentage);
string globalPrefix = _loadBalancerContext.ManagerId;
GlobalCheckIntervalInMillisecondProperty = configurationManager.GetProperty <int?>(globalPrefix + "." + ConfigurationKeys.CheckInterval, DefaultCheckInterval);
GlobalFailureThresholdPercentageProperty = configurationManager.GetProperty <int?>(globalPrefix + "." + ConfigurationKeys.FailureThresholdPercentage, DefaultFailureThresholdPercent);
_checkHealthLatencyMetrics = new ConcurrentDictionary <string, IAuditMetric>();
_checkHealthEventMetrics = new ConcurrentDictionary <string, IEventMetric>();
}
public async Task Handle(DoPageLoadMessage notification, CancellationToken cancellationToken)
{
var cacheKey = $"{notification.EndPointId}-{nameof(SensorType.PageLoad)}";
var operation = await _cache.GetAsync <OngoingOperationDto>(cacheKey);
if (operation != null)
{
if ((DateTime.Now - operation.StartDate).TotalMinutes <= 1)
{
return;
}
}
else
{
await _cache.SetAsync(cacheKey, new OngoingOperationDto(DateTime.Now));
}
var networkavailability = true;
var urlResult = WebSiteUtil.IsUrlAlive(notification.PageUrl);
if (urlResult == false) // check network availability
{
networkavailability = PingUtil.Ping("8.8.8.8");
}
if (networkavailability == false)
{
//TODO Notify about connection
}
else
{
await _mediator.Publish(new PageLoadNotificationMessage
{
PageUrl = notification.PageUrl,
EmailNotify = notification.EmailNotify,
EndPointId = notification.EndPointId,
MobileNotify = notification.MobileNotify,
LoadSuccess = urlResult
}, cancellationToken);
}
}
public async Task Handle(DoPingMessage notification, CancellationToken cancellationToken)
{
var cacheKey = $"{notification.EndPointId}-{nameof(SensorType.Ping)}";
var operation = await _cache.GetAsync <OngoingOperationDto>(cacheKey);
if (operation != null)
{
if ((DateTime.Now - operation.StartDate).TotalMinutes <= 1)
{
return;
}
}
else
{
await _cache.SetAsync(cacheKey, new OngoingOperationDto(DateTime.Now));
}
var networkavailability = true;
var pingResult = PingUtil.Ping(notification.IpAddress);
if (pingResult == false) // IS Network availability
{
networkavailability = PingUtil.Ping("8.8.8.8");
}
if (networkavailability == false)
{
//TODO Notify about connection
}
else
{
await _mediator.Publish(new PingNotificationMessage
{
IpAddress = notification.IpAddress,
EmailNotify = notification.EmailNotify,
EndPointId = notification.EndPointId,
MobileNotify = notification.MobileNotify,
PingSuccess = pingResult
}, cancellationToken);
}
}
internal CommandHandler()
{
_observer = new GsLiveSystemObserver(GSLiveType.Command);
_isDisposed = false;
_isFirstInit = false;
InitRequestMessageHandlers();
InitResponseMessageHandlers();
PingUtil.Init();
// Set Internal Event Handlers
CommandEventHandlers.CommandPing += OnPing;
CommandEventHandlers.CommandAuthorized += OnAuth;
CommandEventHandlers.CommandMirror += OnMirror;
PingUtil.RequestPing += RequestPing;
CommandEventHandlers.GsCommandClientConnected += OnGsTcpClientConnected;
CommandEventHandlers.GsCommandClientError += OnGsTcpClientError;
DebugUtil.LogNormal <CommandHandler>(DebugLocation.Command, "Constructor", "CommandHandler Initialized");
}
public Task StartReading()
{
try
{
bool isPingable = false;
while (!isPingable && !_cancellationToken.IsCancellationRequested)
{
isPingable = PingUtil.PingHostViaTcp(_reading.Reader.Host, int.Parse(_reading.Reader.Port));
}
if (isPingable)
{
return(backgoundWorker = Task.Run(() => DoReadingWork(_cancellationToken.Token), _cancellationToken.Token));
}
}
catch (Exception ex)
{
Debug.WriteLine(string.Format("{0}: {1}\n{2}", nameof(StartReading), ex.Message, ex.StackTrace));
}
return(backgoundWorker);
}
public void DoWork()
{
startedWorksCount = 0;
finishedWorksCount = 0;
foreach (KeyValuePair <string, MachineConnectivity> keyValue in connectivityResults)
{
MachineConnectivity connectivity = keyValue.Value;
if (connectivity.CanPing ?? false)
{
continue;
}
startedWorksCount++;
string machineName = keyValue.Key;
BackgroundWork <bool> .CreateWork(window, () => { },
() =>
{
return(PingUtil.PingHost(machineName));
},
(taskResult) =>
{
bool result = false;
if (taskResult.HasError)
{
result = false;
}
else
{
result = taskResult.Result;
}
ConsolidatePingResult(machineName, result);
}
).Execute();
}
foreach (KeyValuePair <string, MachineConnectivity> keyValue in connectivityResults)
{
MachineConnectivity connectivity = keyValue.Value;
if (connectivity.CanRemotePathAccess ?? false)
{
continue;
}
startedWorksCount++;
string machineName = keyValue.Key;
string userName = connectivity.Machine.Credential?.UserName;
string password = connectivity.Machine.Credential?.LoginPlainPassword;
NetworkFileAccess fileAccess = new NetworkFileAccess(machineName, userName, password);
BackgroundWork.CreateWork(window, () => { },
() =>
{
fileAccess.EnsureDirectory(testingFolderPath);
fileAccess.CanAccessDirectory(testingFolderPath);
return(0);
},
(taskResult) =>
{
bool result = true;
if (taskResult.HasError)
{
logger.Error($"Testing of RemotePathAccess failed for machine [{ machineName }]. Message: { taskResult.Exception.ToString() }");
result = false;
}
ConsolidateRemotePathAccessResult(machineName, result);
}
).Execute();
}
foreach (KeyValuePair <string, MachineConnectivity> keyValue in connectivityResults)
{
MachineConnectivity connectivity = keyValue.Value;
MinerMachine machine = connectivity.Machine;
if (connectivity.CanRemotePowershell ?? false)
{
continue;
}
startedWorksCount++;
string machineName = keyValue.Key;
BackgroundWork.CreateWork(window, () => { },
() =>
{
TargetMachineExecutor executor = TargetMachineExecutor.GetExecutor(machineName);
if (machine.Credential != null)
{
executor.SetCredential(machine.Credential.UserName, machine.Credential.LoginPlainPassword);
}
executor.TestConnection();
return(0);
},
(taskResult) =>
{
bool result = true;
if (taskResult.HasError)
{
logger.Error($"Testing of RemotePathAccess failed for machine [{ machineName }]. Message: { taskResult.Exception.ToString() }");
result = false;
}
ConsolidateRemotePowershellResult(machineName, result);
}
).Execute();
}
while (finishedWorksCount < startedWorksCount)
{
Thread.Sleep(30);
}
}
internal static short GetPing()
{
return(PingUtil.GetLastPing());
}
