public async Task Handle(ReportCustomCheckResult message, IMessageHandlerContext context)
{
if (string.IsNullOrEmpty(message.EndpointName))
{
throw new Exception("Received an custom check message without proper initialization of the EndpointName in the schema");
}
if (string.IsNullOrEmpty(message.Host))
{
throw new Exception("Received an custom check message without proper initialization of the Host in the schema");
}
if (message.HostId == Guid.Empty)
{
throw new Exception("Received an custom check message without proper initialization of the HostId in the schema");
}
var originatingEndpoint = new EndpointDetails
{
Host = message.Host,
HostId = message.HostId,
Name = message.EndpointName
};
await customChecks.UpdateCustomCheckStatus(
originatingEndpoint,
message.ReportedAt,
message.CustomCheckId,
message.Category,
message.HasFailed,
message.FailureReason
).ConfigureAwait(false);
}
public void OnEndpointFound(EndpointDetails discoveredEndpoint)
{
PlayGamesHelperObject.RunOnGameThread(delegate
{
mListener.OnEndpointFound(discoveredEndpoint);
});
}
public void OnEndpointFound(EndpointDetails discoveredEndpoint)
{
ConsoleLog.SLog("Found Endpoint: " +
discoveredEndpoint.DeviceId + " " +
discoveredEndpoint.EndpointId + " " +
discoveredEndpoint.Name);
}
private static void AssertEndpoint(Endpoint expected, EndpointDetails actual)
{
Assert.Equal(expected.MonitorType, actual.MonitorType);
Assert.Equal(expected.Address, actual.Address);
Assert.Equal(expected.Name, actual.Name);
Assert.Equal(expected.Group, actual.Group);
Assert.Equal(expected.Id, actual.Id);
}
//IDiscoveryListener
public void OnEndpointFound(EndpointDetails discoveredEndpoint)
{
Debug.Log("***Nearby discovery — Found Endpoint: " +
discoveredEndpoint.DeviceId + " " +
discoveredEndpoint.EndpointId + " " +
discoveredEndpoint.Name);
SendNearbyConnectionRequest(discoveredEndpoint);
}
public HeartbeatsStats RegisterNewEndpoint(EndpointDetails endpointDetails)
{
lock (locker)
{
GetEndpoint(endpointDetails);
return GetHeartbeatsStats();
}
}
public HeartbeatsStats RegisterNewEndpoint(EndpointDetails endpointDetails)
{
lock (locker)
{
GetEndpoint(endpointDetails);
return(GetHeartbeatsStatsNoLock());
}
}
public HeartbeatsStats DisableMonitoring(EndpointDetails endpoint)
{
lock (locker)
{
var existingEndpoint = GetEndpoint(endpoint);
existingEndpoint.MonitoringDisabled = true;
return(GetHeartbeatsStatsNoLock());
}
}
public HeartbeatsStats DisableMonitoring(EndpointDetails endpoint)
{
lock (locker)
{
var existingEndpoint = GetEndpoint(endpoint);
existingEndpoint.MonitoringDisabled = true;
return GetHeartbeatsStats();
}
}
public IHttpActionResult GetEndpoint(Guid id)
{
var endpoint = _endpointRegistry.GetById(id);
if (endpoint == null)
{
return(NotFound());
}
return(Ok(EndpointDetails.FromDomain(endpoint)));
}
void TryAddEndpoint(EndpointDetails endpointDetails)
{
// for backwards compat with version before 4_5 we might not have a hostid
if (endpointDetails.HostId == Guid.Empty)
{
return;
}
monitoring.DetectEndpointFromLocalAudit(endpointDetails);
}
public void DetectEndpointFromLocalAudit(EndpointDetails newEndpointDetails)
{
var endpointInstanceId = newEndpointDetails.ToInstanceId();
if (endpoints.TryAdd(endpointInstanceId.UniqueId, new EndpointInstanceMonitor(endpointInstanceId, false, domainEvents)))
{
domainEvents.Raise(new NewEndpointDetected {
DetectedAt = DateTime.UtcNow, Endpoint = newEndpointDetails
});
}
}
public InternalCustomChecksStartup(IList <ICustomCheck> customChecks, CustomChecksStorage store, HostInformation hostInfo, string endpointName)
{
this.customChecks = customChecks;
this.store = store;
localEndpointDetails = new EndpointDetails
{
Host = hostInfo.DisplayName,
HostId = hostInfo.HostId,
Name = endpointName
};
}
public HeartbeatsStats RegisterEndpointThatFailedToHeartbeat(EndpointDetails endpointDetails)
{
lock (locker)
{
var existingEndpoint = GetEndpoint(endpointDetails);
existingEndpoint.Active = false;
return GetHeartbeatsStatsNoLock();
}
}
public HeartbeatsStats RegisterEndpointThatFailedToHeartbeat(EndpointDetails endpointDetails)
{
lock (locker)
{
var existingEndpoint = GetEndpoint(endpointDetails);
existingEndpoint.Active = false;
return(GetHeartbeatsStatsNoLock());
}
}
public void Handle(RegisterEndpointStartup message)
{
var endpointDetails = new EndpointDetails
{
Host = message.Host,
HostId = message.HostId,
Name = message.Endpoint
};
monitoring.DetectEndpointFromHeartbeatStartup(endpointDetails, message.StartedAt);
}
async Task TryAddEndpoint(EndpointDetails endpointDetails)
{
// for backwards compat with version before 4_5 we might not have a hostid
if (endpointDetails.HostId == Guid.Empty)
{
return;
}
await monitoring.DetectEndpointFromLocalAudit(endpointDetails)
.ConfigureAwait(false);
}
public Task Handle(RegisterEndpointStartup message, IMessageHandlerContext context)
{
var endpointDetails = new EndpointDetails
{
Host = message.Host,
HostId = message.HostId,
Name = message.Endpoint
};
return(monitoring.DetectEndpointFromHeartbeatStartup(endpointDetails, message.StartedAt));
}
public void DetectEndpointFromHeartbeatStartup(EndpointDetails newEndpointDetails, DateTime startedAt)
{
var endpointInstanceId = newEndpointDetails.ToInstanceId();
endpoints.GetOrAdd(endpointInstanceId.UniqueId, id => new EndpointInstanceMonitor(endpointInstanceId, true, domainEvents));
domainEvents.Raise(new EndpointStarted
{
EndpointDetails = newEndpointDetails,
StartedAt = startedAt
});
}
public void HandleMetricsForwarding(EndpointIdentity identity, EndpointMetadata metadata, EndpointHealth health)
{
var ed = new EndpointDetails(identity.Id, metadata.Group, metadata.Name, identity.Address, identity.MonitorType);
var em = new EndpointMetrics(health.CheckTimeUtc, health.ResponseTime.Milliseconds, health.Status.ToString());
foreach (var f in _forwarders)
{
Logger.InfoFormat("Forwarding metrics using {0} forwarder, for endpoint id {1}", f.Key, identity.Id);
f.Value.ForwardEndpointMetrics(ed, em);
}
}
public HeartbeatsStats RegisterHeartbeatingEndpoint(EndpointDetails endpointDetails, DateTime timeOfHeartbeat)
{
lock (locker)
{
var existingEndpoint = GetEndpoint(endpointDetails);
existingEndpoint.Active = true;
existingEndpoint.TimeOfLastHeartbeat = timeOfHeartbeat;
return(GetHeartbeatsStatsNoLock());
}
}
public async Task DetectEndpointFromHeartbeatStartup(EndpointDetails newEndpointDetails, DateTime startedAt)
{
var endpointInstanceId = newEndpointDetails.ToInstanceId();
endpoints.GetOrAdd(endpointInstanceId.UniqueId, id => new EndpointInstanceMonitor(endpointInstanceId, true, domainEvents));
await domainEvents.Raise(new EndpointStarted
{
EndpointDetails = newEndpointDetails,
StartedAt = startedAt
}).ConfigureAwait(false);
}
public void OnEndpointFound(EndpointDetails discoveredEndpoint)
{
Debug.Log("OnEndpointFound");
mNearbyStatus = "OnEndpointFound" + discoveredEndpoint.Name +
" " + discoveredEndpoint.EndpointId;
EndpointHolder holder = new EndpointHolder();
holder.Endpoint = discoveredEndpoint;
holder.State = EndpointState.DISCOVERED;
mEndpoints.Remove(discoveredEndpoint.EndpointId);
mEndpoints.Add(discoveredEndpoint.EndpointId, holder);
mKnownEndpoints.Add(discoveredEndpoint.EndpointId);
}
public async Task EndpointDetected(EndpointDetails newEndpointDetails)
{
var endpointInstanceId = newEndpointDetails.ToInstanceId();
if (endpoints.TryAdd(endpointInstanceId.UniqueId, new EndpointInstanceMonitor(endpointInstanceId, false, domainEvents)))
{
await domainEvents.Raise(new EndpointDetected
{
DetectedAt = DateTime.UtcNow,
Endpoint = newEndpointDetails
}).ConfigureAwait(false);
}
}
public HeartbeatsStats RegisterHeartbeatingEndpoint(EndpointDetails endpointDetails,DateTime timeOfHeartbeat)
{
lock (locker)
{
var existingEndpoint = GetEndpoint(endpointDetails);
existingEndpoint.Active = true;
existingEndpoint.TimeOfLastHeartbeat = timeOfHeartbeat;
return GetHeartbeatsStats();
}
}
void SendNearbyConnectionRequest(EndpointDetails remote)
{
Debug.Log("***Nearby sending connection request …");
PlayGamesPlatform.Nearby.SendConnectionRequest(
"Local Game player", // the user-friendly name
remote.EndpointId, // the discovered endpoint
System.Text.Encoding.UTF8.GetBytes("hello, neighbor"), // byte[] of data
(response) => {
Debug.Log("***Nearby connection response: ResponseStatus" +
response.ResponseStatus + ",Payload=" + response.Payload);
},
(IMessageListener)this);
}
void HandlePost45Endpoint(EndpointDetails endpointDetails)
{
var endpointInstanceId = DeterministicGuid.MakeId(endpointDetails.Name, endpointDetails.HostId.ToString());
if (KnownEndpointsCache.TryAdd(endpointInstanceId))
{
var registerEndpoint = new RegisterEndpoint
{
EndpointInstanceId = endpointInstanceId,
Endpoint = endpointDetails,
DetectedAt = DateTime.UtcNow
};
Bus.SendLocal(registerEndpoint);
}
}
void HandlePre45Endpoint(EndpointDetails endpointDetails)
{
//since for pre 4.5 endpoints we wont have a hostid then fake one
var endpointInstanceId = DeterministicGuid.MakeId(endpointDetails.Name, endpointDetails.Host);
if (KnownEndpointsCache.TryAdd(endpointInstanceId))
{
var registerEndpoint = new RegisterEndpoint
{
//we don't set then endpoint instance id since we don't have the host id
Endpoint = endpointDetails,
DetectedAt = DateTime.UtcNow
};
Bus.SendLocal(registerEndpoint);
}
}
public void OnEndpointFound(EndpointDetails discoveredEndpoint)
{
Debug.Log("ALLOW ME");
GameObject newGroup = Instantiate(Grprefab);
newGroup.transform.SetParent(GroupContent.transform);
Vector3 position = newGroup.transform.localPosition;
position.z = 1;
newGroup.transform.localPosition = position;
newGroup.transform.localScale = new Vector3(1, 1, 1); // Let it be default
newGroup.transform.GetChild(0).GetComponent <Text> ().text = discoveredEndpoint.Name; // Here is the group
newGroup.gameObject.name = discoveredEndpoint.EndpointId;
Button newGroupButton = newGroup.GetComponent <Button>();
newGroupButton.onClick.AddListener(() => OnGroupClick(discoveredEndpoint.EndpointId));
}
public async Task UpdateEndpointMonitoring(EndpointDetails endpoint, bool isMonitored)
{
var id = DeterministicGuid.MakeId(endpoint.Name, endpoint.HostId.ToString());
using (var session = store.OpenAsyncSession())
{
var knownEndpoint = await session.LoadAsync <KnownEndpoint>(id)
.ConfigureAwait(false);
if (knownEndpoint != null)
{
knownEndpoint.Monitored = isMonitored;
await session.SaveChangesAsync()
.ConfigureAwait(false);
}
}
}
public void OnEndpointFound(EndpointDetails discoveredEndpoint)
{
Debug.Log("Found Endpoint!");
NearbyRoom room = new NearbyRoom(
discoveredEndpoint.DeviceId,
discoveredEndpoint.EndpointId,
discoveredEndpoint.Name);
if (roomDiscoveredCallback != null)
{
Debug.Log("Invoking roomCallback.");
roomDiscoveredCallback.Invoke(room, true);
}
else
{
Debug.Log("No roomCallback configured.");
}
}
static void RecordKnownEndpoints(EndpointDetails observedEndpoint, Dictionary <string, KnownEndpoint> observedEndpoints, ProcessedMessage processedMessage)
{
var uniqueEndpointId = $"{observedEndpoint.Name}{observedEndpoint.HostId}";
if (!observedEndpoints.TryGetValue(uniqueEndpointId, out var knownEndpoint))
{
knownEndpoint = new KnownEndpoint
{
Host = observedEndpoint.Host,
HostId = observedEndpoint.HostId,
LastSeen = processedMessage.ProcessedAt,
Name = observedEndpoint.Name,
Id = KnownEndpoint.MakeDocumentId(observedEndpoint.Name, observedEndpoint.HostId),
};
observedEndpoints.Add(uniqueEndpointId, knownEndpoint);
}
knownEndpoint.LastSeen = processedMessage.ProcessedAt > knownEndpoint.LastSeen ? processedMessage.ProcessedAt : knownEndpoint.LastSeen;
}
void TryAddEndpoint(EndpointDetails endpointDetails)
{
// SendingEndpoint will be null for messages that are from v3.3.x endpoints because we don't
// have the relevant information via the headers, which were added in v4.
// The ReceivingEndpoint will be null for messages from v3.3.x endpoints that were successfully
// processed because we dont have the information from the relevant headers.
if (endpointDetails == null)
{
return;
}
// for backwards compat with version before 4_5 we might not have a hostid
if (endpointDetails.HostId == Guid.Empty)
{
HandlePre45Endpoint(endpointDetails);
return;
}
HandlePost45Endpoint(endpointDetails);
}
public void GeneralTest()
{
SslLabsClient client = new SslLabsClient();
Host analysis = client.GetAnalysisBlocking("scotthelme.co.uk", options: AnalyzeOptions.ReturnAll);
Assert.IsNotNull(analysis);
Assert.AreEqual(AnalysisStatus.READY, analysis.Status, "scotthelme.co.uk analysis was not ready. Wait for the analysis to complete.");
TestHelpers.EnsureAllPropertiesSet(analysis, nameof(Host.StatusMessage));
Assert.IsTrue(analysis.Endpoints.Any());
Endpoint endpoint = analysis.Endpoints.First();
TestHelpers.EnsureAllPropertiesSet(endpoint, nameof(Endpoint.StatusDetails), nameof(Endpoint.StatusDetailsMessage));
EndpointDetails details = endpoint.Details;
TestHelpers.EnsureAllPropertiesSet(details, nameof(EndpointDetails.StaplingRevocationErrorMessage), nameof(EndpointDetails.HttpForwarding));
}
public void When_endpoint_is_disabled_should_not_count()
{
var currentHeartbeatStatus = new HeartbeatStatusProvider();
var endpoint = new EndpointDetails()
{
Host = "Machine",
HostId = Guid.NewGuid(),
Name = "NewEndpoint"
};
currentHeartbeatStatus.RegisterNewEndpoint(endpoint);
var stats = currentHeartbeatStatus.DisableMonitoring(endpoint);
VerifyHeartbeatStats(stats, 0, 0);
//enable and make sure it counts again
stats = currentHeartbeatStatus.EnableMonitoring(endpoint);
VerifyHeartbeatStats(stats, 0, 1);
}
public void When_Heartbeating_Endpoint_Is_Detected_For_A_Known_Endpoint_That_Has_No_Prior_HostId()
{
var currentHeartbeatStatus = new HeartbeatStatusProvider();
var hostId = Guid.NewGuid();
var endpointWithNoHostId = new EndpointDetails
{
Host = "Machine",
Name = "NewEndpoint"
};
currentHeartbeatStatus.RegisterNewEndpoint(endpointWithNoHostId);
var endpointWithHostId = new EndpointDetails
{
Host = "Machine",
HostId = hostId,
Name = "NewEndpoint"
};
var stats = currentHeartbeatStatus.RegisterHeartbeatingEndpoint(endpointWithHostId, DateTime.UtcNow);
VerifyHeartbeatStats(stats, 1, 0);
}
HeartbeatingEndpoint GetEndpoint(EndpointDetails endpointDetails)
{
var existingEndpoint = TryFindEndpoint(endpointDetails);
if (existingEndpoint == null)
{
existingEndpoint = new HeartbeatingEndpoint
{
Host = endpointDetails.Host,
HostId = endpointDetails.HostId,
Name = endpointDetails.Name
};
endpoints.Add(existingEndpoint);
}
else
{
if (existingEndpoint.HostId == Guid.Empty && endpointDetails.HostId != Guid.Empty)
{
existingEndpoint.HostId = endpointDetails.HostId;
}
}
return existingEndpoint;
}
HeartbeatingEndpoint TryFindEndpoint(EndpointDetails endpointDetails)
{
if (endpointDetails.HostId == Guid.Empty)
{
// Try to match existing ones on host and machine if no host id is present
return endpoints.SingleOrDefault(e => e.Host == endpointDetails.Host && e.Name == endpointDetails.Name);
}
//try to get an exact match
var existingEndpoint = endpoints.SingleOrDefault(e => e.HostId == endpointDetails.HostId && e.Name == endpointDetails.Name);
if (existingEndpoint != null)
{
return existingEndpoint;
}
//try to match on existing ones without host IDs
return endpoints.SingleOrDefault(e =>
e.HostId == Guid.Empty &&
e.Host == endpointDetails.Host && e.Name == endpointDetails.Name);
}
public HeartbeatsStats RegisterEndpointWhoseHeartbeatIsRestored(EndpointDetails endpointDetails, DateTime timeOfHeartbeat)
{
return RegisterHeartbeatingEndpoint(endpointDetails,timeOfHeartbeat);
}
HeartbeatingEndpoint TryFindEndpoint(EndpointDetails endpointDetails)
{
if (endpointDetails.HostId == Guid.Empty)
{
// Try to match existing ones on host and machine if no host id is present
return endpoints.Where(e => e.Host == endpointDetails.Host && e.Name == endpointDetails.Name)
.OrderBy(e => e.HostId) // This is a hack because of Issue #448
.FirstOrDefault();
}
//try to get an exact match
var existingEndpoint = endpoints.SingleOrDefault(e => e.HostId == endpointDetails.HostId && e.Name == endpointDetails.Name);
if (existingEndpoint != null)
{
return existingEndpoint;
}
//try to match on existing ones without host IDs
return endpoints.SingleOrDefault(e =>
e.HostId == Guid.Empty &&
e.Host == endpointDetails.Host && e.Name == endpointDetails.Name);
}
