/// <summary>
/// Serializes the object to JSON.
/// </summary>
/// <param name="writer">The <see cref="T: Newtonsoft.Json.JsonWriter" /> to write to.</param>
/// <param name="obj">The object to serialize to JSON.</param>
internal static void Serialize(JsonWriter writer, PartitionLoadInformation obj)
{
// Required properties are always serialized, optional properties are serialized when not null.
writer.WriteStartObject();
if (obj.PartitionId != null)
{
writer.WriteProperty(obj.PartitionId, "PartitionId", PartitionIdConverter.Serialize);
}
if (obj.PrimaryLoadMetricReports != null)
{
writer.WriteEnumerableProperty(obj.PrimaryLoadMetricReports, "PrimaryLoadMetricReports", LoadMetricReportConverter.Serialize);
}
if (obj.SecondaryLoadMetricReports != null)
{
writer.WriteEnumerableProperty(obj.SecondaryLoadMetricReports, "SecondaryLoadMetricReports", LoadMetricReportConverter.Serialize);
}
if (obj.AuxiliaryLoadMetricReports != null)
{
writer.WriteEnumerableProperty(obj.AuxiliaryLoadMetricReports, "AuxiliaryLoadMetricReports", LoadMetricReportConverter.Serialize);
}
writer.WriteEndObject();
}
/// <summary>
/// Reports metrics specificed for an application
/// </summary>
/// <param name="metric"></param>
/// <returns>Indicator of success.</returns>
internal async Task <bool> ReportPartitionMetricAsync(MetricCheck metric)
{
ServiceEventSource.Current.ServiceRequestStart(nameof(this.ReportServiceMetricAsync));
try
{
PartitionLoadInformation loadInfo =
await this.Client.QueryManager.GetPartitionLoadInformationAsync(metric.Partition, this._timeout, this._token);
foreach (LoadMetricReport item in loadInfo.PrimaryLoadMetricReports)
{
await this._telemetry.ReportMetricAsync(metric.Service, metric.Partition, item.Name, item.Value, this._token).ConfigureAwait(false);
}
}
catch (FabricElementNotFoundException)
{
return(false);
}
catch (TimeoutException ex)
{
ServiceEventSource.Current.ServiceMessage(this._service.Context, "Timeout in ReportServiceMetric at {0}", ex.StackTrace);
}
catch (FabricObjectClosedException)
{
this._service.RefreshFabricClient();
ServiceEventSource.Current.ServiceMessage(this._service.Context, "FabricClient closed");
}
ServiceEventSource.Current.ServiceRequestStop(nameof(this.ReportServiceMetricAsync));
return(true);
}
protected override async Task OnEnumChildren(bool deep)
{
var replicas = await _fabricClient.QueryManager.GetReplicaListAsync(_partition.PartitionInformation.Id);
foreach (var replica in replicas)
{
var sfReplica = new SFReplica(_fabricClient, this, replica);
Replicas.Add(sfReplica);
if (deep)
{
await sfReplica.EnumChildren(deep);
}
}
Loadinformation = await _fabricClient.QueryManager.GetPartitionLoadInformationAsync(_partition.PartitionInformation.Id);
}
private static async Task DumpClusterAsync(FabricClient fc)
{
var qm = fc.QueryManager;
ClusterLoadInformation info = await qm.GetClusterLoadInformationAsync();
WriteLine($"LB StartTime={info.LastBalancingStartTimeUtc}, LB EndTime={info.LastBalancingEndTimeUtc}");
foreach (LoadMetricInformation lmi in info.LoadMetricInformationList)
{
WriteLine($"Name={lmi.Name}");
}
foreach (ProvisionedFabricCodeVersion pfcv in await qm.GetProvisionedFabricCodeVersionListAsync())
{
WriteLine($"SF CodeVersion={pfcv.CodeVersion}");
}
foreach (ProvisionedFabricConfigVersion pfcv in await qm.GetProvisionedFabricConfigVersionListAsync())
{
WriteLine($"SF Config version={pfcv.ConfigVersion}");
}
foreach (ApplicationType at in await qm.GetApplicationTypeListAsync())
{
WriteLine($"Name={at.ApplicationTypeName}, Ver={at.ApplicationTypeVersion}");
foreach (ServiceType st in await qm.GetServiceTypeListAsync(at.ApplicationTypeName, at.ApplicationTypeVersion))
{
WriteLine($" Name={st.ServiceManifestName}, Ver={st.ServiceManifestVersion}");
}
}
foreach (Node n in await qm.GetNodeListAsync())
{
WriteLine($"Name={n.NodeName}, Health={n.HealthState}, FD={n.FaultDomain}, UD={n.UpgradeDomain}, IP={n.IpAddressOrFQDN}");
NodeLoadInformation nli = await qm.GetNodeLoadInformationAsync(n.NodeName);
foreach (NodeLoadMetricInformation nlmi in nli.NodeLoadMetricInformationList)
{
WriteLine($"Name={nlmi.Name}, Remaining={nlmi.NodeRemainingCapacity}");
}
foreach (DeployedApplication da in await qm.GetDeployedApplicationListAsync(n.NodeName))
{
WriteLine(da.ApplicationName);
foreach (DeployedCodePackage dcp in await qm.GetDeployedCodePackageListAsync(n.NodeName, da.ApplicationName))
{
WriteLine(dcp.EntryPoint.EntryPointLocation);
}
foreach (DeployedServiceType dst in await qm.GetDeployedServiceTypeListAsync(n.NodeName, da.ApplicationName))
{
WriteLine(dst.ServiceTypeName);
}
foreach (DeployedServiceReplica dsr in await qm.GetDeployedReplicaListAsync(n.NodeName, da.ApplicationName))
{
long?id = (dsr as DeployedStatefulServiceReplica)?.ReplicaId;
if (id == null)
{
id = (dsr as DeployedStatelessServiceInstance)?.InstanceId;
}
WriteLine($"ServiceName={dsr.ServiceName}, PartitionId={dsr.Partitionid}, ReplicaId={id}, Status={dsr.ReplicaStatus}");
DeployedServiceReplicaDetail drd = await qm.GetDeployedReplicaDetailAsync(n.NodeName, dsr.Partitionid, id.Value);
}
foreach (DeployedServicePackage dsp in await qm.GetDeployedServicePackageListAsync(n.NodeName, da.ApplicationName))
{
WriteLine($"ManifestName={dsp.ServiceManifestName}, Status={dsp.DeployedServicePackageStatus}");
}
}
}
foreach (Application a in await qm.GetApplicationListAsync())
{
WriteLine($"App={a.ApplicationName}, Status={a.ApplicationStatus}, Health={a.HealthState}");
foreach (Service s in await qm.GetServiceListAsync(a.ApplicationName))
{
WriteLine($" Service={s.ServiceName}, Status={s.ServiceStatus}, Health={s.HealthState}");
foreach (Partition p in await qm.GetPartitionListAsync(s.ServiceName))
{
WriteLine($" Partition={p.PartitionInformation.Id}, Status={p.PartitionStatus}, Health={p.HealthState}");
PartitionLoadInformation pli = await qm.GetPartitionLoadInformationAsync(p.PartitionInformation.Id);
foreach (Replica r in await qm.GetReplicaListAsync(p.PartitionInformation.Id))
{
WriteLine($" Replica={r.Id}, Status={r.ReplicaStatus}, Health={r.HealthState}");
ReplicaLoadInformation rli = await qm.GetReplicaLoadInformationAsync(p.PartitionInformation.Id, r.Id);
}
UnplacedReplicaInformation ur = await qm.GetUnplacedReplicaInformationAsync(s.ServiceName.ToString(), p.PartitionInformation.Id, false);
if (ur.UnplacedReplicaReasons.Count > 0)
{
WriteLine("Unplaced partition replicas");
foreach (var reason in ur.UnplacedReplicaReasons)
{
WriteLine(reason);
}
}
}
}
}
}
