/// <summary>
/// Initializes a new instance of the ChaosMovePrimaryFaultScheduledEvent class.
/// </summary>
/// <param name="eventInstanceId">The identifier for the FabricEvent instance.</param>
/// <param name="timeStamp">The time event was logged.</param>
/// <param name="partitionId">An internal ID used by Service Fabric to uniquely identify a partition. This is a
/// randomly generated GUID when the service was created. The partition ID is unique and does not change for the
/// lifetime of the service. If the same service was deleted and recreated the IDs of its partitions would be
/// different.</param>
/// <param name="faultGroupId">Id of fault group.</param>
/// <param name="faultId">Id of fault.</param>
/// <param name="serviceName">Service name.</param>
/// <param name="nodeTo">The name of a Service Fabric node.</param>
/// <param name="forcedMove">Indicates a forced move.</param>
/// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param>
public ChaosMovePrimaryFaultScheduledEvent(
Guid?eventInstanceId,
DateTime?timeStamp,
PartitionId partitionId,
Guid?faultGroupId,
Guid?faultId,
string serviceName,
NodeName nodeTo,
bool?forcedMove,
bool?hasCorrelatedEvents = default(bool?))
: base(
eventInstanceId,
timeStamp,
Common.FabricEventKind.ChaosMovePrimaryFaultScheduled,
partitionId,
hasCorrelatedEvents)
{
faultGroupId.ThrowIfNull(nameof(faultGroupId));
faultId.ThrowIfNull(nameof(faultId));
serviceName.ThrowIfNull(nameof(serviceName));
nodeTo.ThrowIfNull(nameof(nodeTo));
forcedMove.ThrowIfNull(nameof(forcedMove));
this.FaultGroupId = faultGroupId;
this.FaultId = faultId;
this.ServiceName = serviceName;
this.NodeTo = nodeTo;
this.ForcedMove = forcedMove;
}
/// <summary>
/// Initializes a new instance of the ChaosMoveSecondaryFaultScheduledEvent class.
/// </summary>
/// <param name="eventInstanceId">The identifier for the FabricEvent instance.</param>
/// <param name="timeStamp">The time event was logged.</param>
/// <param name="partitionId">An internal ID used by Service Fabric to uniquely identify a partition. This is a
/// randomly generated GUID when the service was created. The partition ID is unique and does not change for the
/// lifetime of the service. If the same service was deleted and recreated the IDs of its partitions would be
/// different.</param>
/// <param name="faultGroupId">Id of fault group.</param>
/// <param name="faultId">Id of fault.</param>
/// <param name="serviceName">Service name.</param>
/// <param name="sourceNode">The name of a Service Fabric node.</param>
/// <param name="destinationNode">The name of a Service Fabric node.</param>
/// <param name="forcedMove">Indicates a forced move.</param>
/// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param>
public ChaosMoveSecondaryFaultScheduledEvent(
Guid?eventInstanceId,
DateTime?timeStamp,
PartitionId partitionId,
Guid?faultGroupId,
Guid?faultId,
string serviceName,
NodeName sourceNode,
NodeName destinationNode,
bool?forcedMove,
bool?hasCorrelatedEvents = default(bool?))
: base(
eventInstanceId,
timeStamp,
Common.FabricEventKind.ChaosMoveSecondaryFaultScheduled,
partitionId,
hasCorrelatedEvents)
{
faultGroupId.ThrowIfNull(nameof(faultGroupId));
faultId.ThrowIfNull(nameof(faultId));
serviceName.ThrowIfNull(nameof(serviceName));
sourceNode.ThrowIfNull(nameof(sourceNode));
destinationNode.ThrowIfNull(nameof(destinationNode));
forcedMove.ThrowIfNull(nameof(forcedMove));
this.FaultGroupId = faultGroupId;
this.FaultId = faultId;
this.ServiceName = serviceName;
this.SourceNode = sourceNode;
this.DestinationNode = destinationNode;
this.ForcedMove = forcedMove;
}
/// <summary>
/// Initializes a new instance of the PartitionPrimaryMoveAnalysisEvent class.
/// </summary>
/// <param name="eventInstanceId">The identifier for the FabricEvent instance.</param>
/// <param name="timeStamp">The time event was logged.</param>
/// <param name="partitionId">An internal ID used by Service Fabric to uniquely identify a partition. This is a
/// randomly generated GUID when the service was created. The partition ID is unique and does not change for the
/// lifetime of the service. If the same service was deleted and recreated the IDs of its partitions would be
/// different.</param>
/// <param name="metadata">Metadata about an Analysis Event.</param>
/// <param name="whenMoveCompleted">Time when the move was completed.</param>
/// <param name="previousNode">The name of a Service Fabric node.</param>
/// <param name="currentNode">The name of a Service Fabric node.</param>
/// <param name="moveReason">Move reason.</param>
/// <param name="relevantTraces">Relevant traces.</param>
/// <param name="category">The category of event.</param>
/// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param>
public PartitionPrimaryMoveAnalysisEvent(
Guid?eventInstanceId,
DateTime?timeStamp,
PartitionId partitionId,
AnalysisEventMetadata metadata,
DateTime?whenMoveCompleted,
NodeName previousNode,
NodeName currentNode,
string moveReason,
string relevantTraces,
string category = default(string),
bool?hasCorrelatedEvents = default(bool?))
: base(
eventInstanceId,
timeStamp,
Common.FabricEventKind.PartitionPrimaryMoveAnalysis,
partitionId,
metadata,
category,
hasCorrelatedEvents)
{
whenMoveCompleted.ThrowIfNull(nameof(whenMoveCompleted));
previousNode.ThrowIfNull(nameof(previousNode));
currentNode.ThrowIfNull(nameof(currentNode));
moveReason.ThrowIfNull(nameof(moveReason));
relevantTraces.ThrowIfNull(nameof(relevantTraces));
this.WhenMoveCompleted = whenMoveCompleted;
this.PreviousNode = previousNode;
this.CurrentNode = currentNode;
this.MoveReason = moveReason;
this.RelevantTraces = relevantTraces;
}
/// <summary>
/// Initializes a new instance of the NodeAddedEvent class.
/// </summary>
/// <param name="eventInstanceId">The identifier for the FabricEvent instance.</param>
/// <param name="timeStamp">The time event was logged.</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="nodeId">Id of Node.</param>
/// <param name="nodeInstance">Id of Node instance.</param>
/// <param name="nodeType">Type of Node.</param>
/// <param name="fabricVersion">Fabric version.</param>
/// <param name="ipAddressOrFQDN">IP address or FQDN.</param>
/// <param name="nodeCapacities">Capacities.</param>
/// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param>
public NodeAddedEvent(
Guid?eventInstanceId,
DateTime?timeStamp,
NodeName nodeName,
string nodeId,
long?nodeInstance,
string nodeType,
string fabricVersion,
string ipAddressOrFQDN,
string nodeCapacities,
bool?hasCorrelatedEvents = default(bool?))
: base(
eventInstanceId,
timeStamp,
Common.FabricEventKind.NodeAdded,
nodeName,
hasCorrelatedEvents)
{
nodeId.ThrowIfNull(nameof(nodeId));
nodeInstance.ThrowIfNull(nameof(nodeInstance));
nodeType.ThrowIfNull(nameof(nodeType));
fabricVersion.ThrowIfNull(nameof(fabricVersion));
ipAddressOrFQDN.ThrowIfNull(nameof(ipAddressOrFQDN));
nodeCapacities.ThrowIfNull(nameof(nodeCapacities));
this.NodeId = nodeId;
this.NodeInstance = nodeInstance;
this.NodeType = nodeType;
this.FabricVersion = fabricVersion;
this.IpAddressOrFQDN = ipAddressOrFQDN;
this.NodeCapacities = nodeCapacities;
}
/// <summary>
/// Initializes a new instance of the NodeLoadInfo class.
/// </summary>
/// <param name="nodeName">Name of the node for which the load information is provided by this object.</param>
/// <param name="nodeLoadMetricInformation">List that contains metrics and their load information on this node.</param>
public NodeLoadInfo(
NodeName nodeName = default(NodeName),
IEnumerable <NodeLoadMetricInformation> nodeLoadMetricInformation = default(IEnumerable <NodeLoadMetricInformation>))
{
this.NodeName = nodeName;
this.NodeLoadMetricInformation = nodeLoadMetricInformation;
}
/// <summary>
/// Initializes a new instance of the NodeResult class.
/// </summary>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="nodeInstanceId">The node instance id.</param>
public NodeResult(
NodeName nodeName = default(NodeName),
string nodeInstanceId = default(string))
{
this.NodeName = nodeName;
this.NodeInstanceId = nodeInstanceId;
}
/// <summary>
/// Initializes a new instance of the NodeDeactivateCompleteEvent class.
/// </summary>
/// <param name="eventInstanceId">The identifier for the FabricEvent instance.</param>
/// <param name="timeStamp">The time event was logged.</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="nodeInstance">Id of Node instance.</param>
/// <param name="effectiveDeactivateIntent">Describes deactivate intent.</param>
/// <param name="batchIdsWithDeactivateIntent">Batch Ids.</param>
/// <param name="startTime">Start time.</param>
/// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param>
public NodeDeactivateCompleteEvent(
Guid?eventInstanceId,
DateTime?timeStamp,
NodeName nodeName,
long?nodeInstance,
string effectiveDeactivateIntent,
string batchIdsWithDeactivateIntent,
DateTime?startTime,
bool?hasCorrelatedEvents = default(bool?))
: base(
eventInstanceId,
timeStamp,
Common.FabricEventKind.NodeDeactivateComplete,
nodeName,
hasCorrelatedEvents)
{
nodeInstance.ThrowIfNull(nameof(nodeInstance));
effectiveDeactivateIntent.ThrowIfNull(nameof(effectiveDeactivateIntent));
batchIdsWithDeactivateIntent.ThrowIfNull(nameof(batchIdsWithDeactivateIntent));
startTime.ThrowIfNull(nameof(startTime));
this.NodeInstance = nodeInstance;
this.EffectiveDeactivateIntent = effectiveDeactivateIntent;
this.BatchIdsWithDeactivateIntent = batchIdsWithDeactivateIntent;
this.StartTime = startTime;
}
/// <summary>
/// Initializes a new instance of the ChaosRestartCodePackageFaultScheduledEvent class.
/// </summary>
/// <param name="eventInstanceId">The identifier for the FabricEvent instance.</param>
/// <param name="timeStamp">The time event was logged.</param>
/// <param name="applicationId">The identity of the application. This is an encoded representation of the application
/// name. This is used in the REST APIs to identify the application resource.
/// Starting in version 6.0, hierarchical names are delimited with the "\~" character. For example, if the application
/// name is "fabric:/myapp/app1",
/// the application identity would be "myapp\~app1" in 6.0+ and "myapp/app1" in previous versions.
/// </param>
/// <param name="faultGroupId">Id of fault group.</param>
/// <param name="faultId">Id of fault.</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="serviceManifestName">Service manifest name.</param>
/// <param name="codePackageName">Code package name.</param>
/// <param name="servicePackageActivationId">Id of Service package activation.</param>
/// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param>
public ChaosRestartCodePackageFaultScheduledEvent(
Guid?eventInstanceId,
DateTime?timeStamp,
string applicationId,
Guid?faultGroupId,
Guid?faultId,
NodeName nodeName,
string serviceManifestName,
string codePackageName,
string servicePackageActivationId,
bool?hasCorrelatedEvents = default(bool?))
: base(
eventInstanceId,
timeStamp,
Common.FabricEventKind.ChaosRestartCodePackageFaultScheduled,
applicationId,
hasCorrelatedEvents)
{
faultGroupId.ThrowIfNull(nameof(faultGroupId));
faultId.ThrowIfNull(nameof(faultId));
nodeName.ThrowIfNull(nameof(nodeName));
serviceManifestName.ThrowIfNull(nameof(serviceManifestName));
codePackageName.ThrowIfNull(nameof(codePackageName));
servicePackageActivationId.ThrowIfNull(nameof(servicePackageActivationId));
this.FaultGroupId = faultGroupId;
this.FaultId = faultId;
this.NodeName = nodeName;
this.ServiceManifestName = serviceManifestName;
this.CodePackageName = codePackageName;
this.ServicePackageActivationId = servicePackageActivationId;
}
/// <summary>
/// Initializes a new instance of the NodeHealthStateChunk class.
/// </summary>
/// <param name="healthState">The health state of a Service Fabric entity such as Cluster, Node, Application, Service,
/// Partition, Replica etc. Possible values include: 'Invalid', 'Ok', 'Warning', 'Error', 'Unknown'</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
public NodeHealthStateChunk(
HealthState?healthState = default(HealthState?),
NodeName nodeName = default(NodeName))
: base(
healthState)
{
this.NodeName = nodeName;
}
/// <summary>
/// Initializes a new instance of the NodeUpgradeProgressInfo class.
/// </summary>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="upgradePhase">The state of the upgrading node. Possible values include: 'Invalid',
/// 'PreUpgradeSafetyCheck', 'Upgrading', 'PostUpgradeSafetyCheck'</param>
/// <param name="pendingSafetyChecks">List of pending safety checks</param>
public NodeUpgradeProgressInfo(
NodeName nodeName = default(NodeName),
NodeUpgradePhase?upgradePhase = default(NodeUpgradePhase?),
IEnumerable <SafetyCheckWrapper> pendingSafetyChecks = default(IEnumerable <SafetyCheckWrapper>))
{
this.NodeName = nodeName;
this.UpgradePhase = upgradePhase;
this.PendingSafetyChecks = pendingSafetyChecks;
}
/// <summary>
/// Initializes a new instance of the DeployedApplicationHealthState class.
/// </summary>
/// <param name="aggregatedHealthState">The health state of a Service Fabric entity such as Cluster, Node, Application,
/// Service, Partition, Replica etc. Possible values include: 'Invalid', 'Ok', 'Warning', 'Error', 'Unknown'</param>
/// <param name="nodeName">Name of the node on which the service package is deployed.</param>
/// <param name="applicationName">The name of the application, including the 'fabric:' URI scheme.</param>
public DeployedApplicationHealthState(
HealthState?aggregatedHealthState = default(HealthState?),
NodeName nodeName = default(NodeName),
ApplicationName applicationName = default(ApplicationName))
: base(
aggregatedHealthState)
{
this.NodeName = nodeName;
this.ApplicationName = applicationName;
}
/// <summary>
/// Initializes a new instance of the NodeHealthState class.
/// </summary>
/// <param name="aggregatedHealthState">The health state of a Service Fabric entity such as Cluster, Node, Application,
/// Service, Partition, Replica etc. Possible values include: 'Invalid', 'Ok', 'Warning', 'Error', 'Unknown'</param>
/// <param name="name">The name of a Service Fabric node.</param>
/// <param name="id">An internal ID used by Service Fabric to uniquely identify a node. Node Id is deterministically
/// generated from node name.</param>
public NodeHealthState(
HealthState?aggregatedHealthState = default(HealthState?),
NodeName name = default(NodeName),
NodeId id = default(NodeId))
: base(
aggregatedHealthState)
{
this.Name = name;
this.Id = id;
}
/// <summary>
/// Initializes a new instance of the PartitionReconfiguredEvent class.
/// </summary>
/// <param name="eventInstanceId">The identifier for the FabricEvent instance.</param>
/// <param name="timeStamp">The time event was logged.</param>
/// <param name="partitionId">An internal ID used by Service Fabric to uniquely identify a partition. This is a
/// randomly generated GUID when the service was created. The partition ID is unique and does not change for the
/// lifetime of the service. If the same service was deleted and recreated the IDs of its partitions would be
/// different.</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="nodeInstanceId">Id of Node instance.</param>
/// <param name="serviceType">Type of Service.</param>
/// <param name="ccEpochDataLossVersion">CcEpochDataLoss version.</param>
/// <param name="ccEpochConfigVersion">CcEpochConfig version.</param>
/// <param name="reconfigType">Type of reconfiguration.</param>
/// <param name="result">Describes reconfiguration result.</param>
/// <param name="phase0DurationMs">Duration of Phase0 in milli-seconds.</param>
/// <param name="phase1DurationMs">Duration of Phase1 in milli-seconds.</param>
/// <param name="phase2DurationMs">Duration of Phase2 in milli-seconds.</param>
/// <param name="phase3DurationMs">Duration of Phase3 in milli-seconds.</param>
/// <param name="phase4DurationMs">Duration of Phase4 in milli-seconds.</param>
/// <param name="totalDurationMs">Total duration in milli-seconds.</param>
/// <param name="category">The category of event.</param>
/// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param>
public PartitionReconfiguredEvent(
Guid?eventInstanceId,
DateTime?timeStamp,
PartitionId partitionId,
NodeName nodeName,
string nodeInstanceId,
string serviceType,
long?ccEpochDataLossVersion,
long?ccEpochConfigVersion,
string reconfigType,
string result,
double?phase0DurationMs,
double?phase1DurationMs,
double?phase2DurationMs,
double?phase3DurationMs,
double?phase4DurationMs,
double?totalDurationMs,
string category = default(string),
bool?hasCorrelatedEvents = default(bool?))
: base(
eventInstanceId,
timeStamp,
Common.FabricEventKind.PartitionReconfigured,
partitionId,
category,
hasCorrelatedEvents)
{
nodeName.ThrowIfNull(nameof(nodeName));
nodeInstanceId.ThrowIfNull(nameof(nodeInstanceId));
serviceType.ThrowIfNull(nameof(serviceType));
ccEpochDataLossVersion.ThrowIfNull(nameof(ccEpochDataLossVersion));
ccEpochConfigVersion.ThrowIfNull(nameof(ccEpochConfigVersion));
reconfigType.ThrowIfNull(nameof(reconfigType));
result.ThrowIfNull(nameof(result));
phase0DurationMs.ThrowIfNull(nameof(phase0DurationMs));
phase1DurationMs.ThrowIfNull(nameof(phase1DurationMs));
phase2DurationMs.ThrowIfNull(nameof(phase2DurationMs));
phase3DurationMs.ThrowIfNull(nameof(phase3DurationMs));
phase4DurationMs.ThrowIfNull(nameof(phase4DurationMs));
totalDurationMs.ThrowIfNull(nameof(totalDurationMs));
this.NodeName = nodeName;
this.NodeInstanceId = nodeInstanceId;
this.ServiceType = serviceType;
this.CcEpochDataLossVersion = ccEpochDataLossVersion;
this.CcEpochConfigVersion = ccEpochConfigVersion;
this.ReconfigType = reconfigType;
this.Result = result;
this.Phase0DurationMs = phase0DurationMs;
this.Phase1DurationMs = phase1DurationMs;
this.Phase2DurationMs = phase2DurationMs;
this.Phase3DurationMs = phase3DurationMs;
this.Phase4DurationMs = phase4DurationMs;
this.TotalDurationMs = totalDurationMs;
}
/// <summary>
/// Initializes a new instance of the NodeHealthEvaluation class.
/// </summary>
/// <param name="aggregatedHealthState">The health state of a Service Fabric entity such as Cluster, Node, Application,
/// Service, Partition, Replica etc. Possible values include: 'Invalid', 'Ok', 'Warning', 'Error', 'Unknown'</param>
/// <param name="description">Description of the health evaluation, which represents a summary of the evaluation
/// process.</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="unhealthyEvaluations">List of unhealthy evaluations that led to the current aggregated health state of
/// the node. The types of the unhealthy evaluations can be EventHealthEvaluation.</param>
public NodeHealthEvaluation(
HealthState?aggregatedHealthState = default(HealthState?),
string description = default(string),
NodeName nodeName = default(NodeName),
IEnumerable <HealthEvaluationWrapper> unhealthyEvaluations = default(IEnumerable <HealthEvaluationWrapper>))
: base(
Common.HealthEvaluationKind.Node,
aggregatedHealthState,
description)
{
this.NodeName = nodeName;
this.UnhealthyEvaluations = unhealthyEvaluations;
}
/// <summary>
/// Initializes a new instance of the DeployedServicePackageNewHealthReportEvent class.
/// </summary>
/// <param name="eventInstanceId">The identifier for the FabricEvent instance.</param>
/// <param name="timeStamp">The time event was logged.</param>
/// <param name="applicationId">The identity of the application. This is an encoded representation of the application
/// name. This is used in the REST APIs to identify the application resource.
/// Starting in version 6.0, hierarchical names are delimited with the "\~" character. For example, if the application
/// name is "fabric:/myapp/app1",
/// the application identity would be "myapp\~app1" in 6.0+ and "myapp/app1" in previous versions.
/// </param>
/// <param name="serviceManifestName">Service manifest name.</param>
/// <param name="servicePackageInstanceId">Id of Service package instance.</param>
/// <param name="servicePackageActivationId">Id of Service package activation.</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="sourceId">Id of report source.</param>
/// <param name="property">Describes the property.</param>
/// <param name="healthState">Describes the property health state.</param>
/// <param name="timeToLiveMs">Time to live in milli-seconds.</param>
/// <param name="sequenceNumber">Sequence number of report.</param>
/// <param name="description">Description of report.</param>
/// <param name="removeWhenExpired">Indicates the removal when it expires.</param>
/// <param name="sourceUtcTimestamp">Source time.</param>
/// <param name="category">The category of event.</param>
/// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param>
public DeployedServicePackageNewHealthReportEvent(
Guid?eventInstanceId,
DateTime?timeStamp,
string applicationId,
string serviceManifestName,
long?servicePackageInstanceId,
string servicePackageActivationId,
NodeName nodeName,
string sourceId,
string property,
string healthState,
long?timeToLiveMs,
long?sequenceNumber,
string description,
bool?removeWhenExpired,
DateTime?sourceUtcTimestamp,
string category = default(string),
bool?hasCorrelatedEvents = default(bool?))
: base(
eventInstanceId,
timeStamp,
Common.FabricEventKind.DeployedServicePackageNewHealthReport,
applicationId,
category,
hasCorrelatedEvents)
{
serviceManifestName.ThrowIfNull(nameof(serviceManifestName));
servicePackageInstanceId.ThrowIfNull(nameof(servicePackageInstanceId));
servicePackageActivationId.ThrowIfNull(nameof(servicePackageActivationId));
nodeName.ThrowIfNull(nameof(nodeName));
sourceId.ThrowIfNull(nameof(sourceId));
property.ThrowIfNull(nameof(property));
healthState.ThrowIfNull(nameof(healthState));
timeToLiveMs.ThrowIfNull(nameof(timeToLiveMs));
sequenceNumber.ThrowIfNull(nameof(sequenceNumber));
description.ThrowIfNull(nameof(description));
removeWhenExpired.ThrowIfNull(nameof(removeWhenExpired));
sourceUtcTimestamp.ThrowIfNull(nameof(sourceUtcTimestamp));
this.ServiceManifestName = serviceManifestName;
this.ServicePackageInstanceId = servicePackageInstanceId;
this.ServicePackageActivationId = servicePackageActivationId;
this.NodeName = nodeName;
this.SourceId = sourceId;
this.Property = property;
this.HealthState = healthState;
this.TimeToLiveMs = timeToLiveMs;
this.SequenceNumber = sequenceNumber;
this.Description = description;
this.RemoveWhenExpired = removeWhenExpired;
this.SourceUtcTimestamp = sourceUtcTimestamp;
}
/// <summary>
/// Initializes a new instance of the NodeHealth class.
/// </summary>
/// <param name="aggregatedHealthState">The health state of a Service Fabric entity such as Cluster, Node, Application,
/// Service, Partition, Replica etc. Possible values include: 'Invalid', 'Ok', 'Warning', 'Error', 'Unknown'</param>
/// <param name="healthEvents">The list of health events reported on the entity.</param>
/// <param name="unhealthyEvaluations">The unhealthy evaluations that show why the current aggregated health state was
/// returned by Health Manager.</param>
/// <param name="healthStatistics">Shows the health statistics for all children types of the queried entity.</param>
/// <param name="name">Name of the node whose health information is described by this object.</param>
public NodeHealth(
HealthState?aggregatedHealthState = default(HealthState?),
IEnumerable <HealthEvent> healthEvents = default(IEnumerable <HealthEvent>),
IEnumerable <HealthEvaluationWrapper> unhealthyEvaluations = default(IEnumerable <HealthEvaluationWrapper>),
HealthStatistics healthStatistics = default(HealthStatistics),
NodeName name = default(NodeName))
: base(
aggregatedHealthState,
healthEvents,
unhealthyEvaluations,
healthStatistics)
{
this.Name = name;
}
/// <summary>
/// Initializes a new instance of the DeployedServicePackageHealthState class.
/// </summary>
/// <param name="aggregatedHealthState">The health state of a Service Fabric entity such as Cluster, Node, Application,
/// Service, Partition, Replica etc. Possible values include: 'Invalid', 'Ok', 'Warning', 'Error', 'Unknown'</param>
/// <param name="nodeName">Name of the node on which the service package is deployed.</param>
/// <param name="applicationName">The name of the application, including the 'fabric:' URI scheme.</param>
/// <param name="serviceManifestName">Name of the manifest describing the service package.</param>
/// <param name="servicePackageActivationId">The ActivationId of a deployed service package. If
/// ServicePackageActivationMode specified at the time of creating the service
/// is 'SharedProcess' (or if it is not specified, in which case it defaults to 'SharedProcess'), then value of
/// ServicePackageActivationId
/// is always an empty string.
/// </param>
public DeployedServicePackageHealthState(
HealthState?aggregatedHealthState = default(HealthState?),
NodeName nodeName = default(NodeName),
ApplicationName applicationName = default(ApplicationName),
string serviceManifestName = default(string),
string servicePackageActivationId = default(string))
: base(
aggregatedHealthState)
{
this.NodeName = nodeName;
this.ApplicationName = applicationName;
this.ServiceManifestName = serviceManifestName;
this.ServicePackageActivationId = servicePackageActivationId;
}
/// <summary>
/// Initializes a new instance of the NodeEvent class.
/// </summary>
/// <param name="eventInstanceId">The identifier for the FabricEvent instance.</param>
/// <param name="timeStamp">The time event was logged.</param>
/// <param name="kind">The kind of FabricEvent.</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param>
public NodeEvent(
Guid?eventInstanceId,
DateTime?timeStamp,
FabricEventKind?kind,
NodeName nodeName,
bool?hasCorrelatedEvents = default(bool?))
: base(
eventInstanceId,
timeStamp,
Common.FabricEventKind.NodeEvent,
hasCorrelatedEvents)
{
nodeName.ThrowIfNull(nameof(nodeName));
this.NodeName = nodeName;
}
/// <summary>
/// Initializes a new instance of the ReplicaInfo class.
/// </summary>
/// <param name="serviceKind">The kind of service (Stateless or Stateful).</param>
/// <param name="replicaStatus">The status of a replica of a service. Possible values include: 'Invalid', 'InBuild',
/// 'Standby', 'Ready', 'Down', 'Dropped'</param>
/// <param name="healthState">The health state of a Service Fabric entity such as Cluster, Node, Application, Service,
/// Partition, Replica etc. Possible values include: 'Invalid', 'Ok', 'Warning', 'Error', 'Unknown'</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="address">The address the replica is listening on.</param>
/// <param name="lastInBuildDurationInSeconds">The last in build duration of the replica in seconds.</param>
protected ReplicaInfo(
ServiceKind?serviceKind,
ReplicaStatus?replicaStatus = default(ReplicaStatus?),
HealthState?healthState = default(HealthState?),
NodeName nodeName = default(NodeName),
string address = default(string),
string lastInBuildDurationInSeconds = default(string))
{
serviceKind.ThrowIfNull(nameof(serviceKind));
this.ServiceKind = serviceKind;
this.ReplicaStatus = replicaStatus;
this.HealthState = healthState;
this.NodeName = nodeName;
this.Address = address;
this.LastInBuildDurationInSeconds = lastInBuildDurationInSeconds;
}
/// <summary>
/// Initializes a new instance of the DeployServicePackageToNodeDescription class.
/// </summary>
/// <param name="serviceManifestName">The name of service manifest whose packages need to be downloaded.</param>
/// <param name="applicationTypeName">The application type name as defined in the application manifest.</param>
/// <param name="applicationTypeVersion">The version of the application type as defined in the application
/// manifest.</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="packageSharingPolicy">List of package sharing policy information.</param>
public DeployServicePackageToNodeDescription(
string serviceManifestName,
string applicationTypeName,
string applicationTypeVersion,
NodeName nodeName,
IEnumerable <PackageSharingPolicyInfo> packageSharingPolicy = default(IEnumerable <PackageSharingPolicyInfo>))
{
serviceManifestName.ThrowIfNull(nameof(serviceManifestName));
applicationTypeName.ThrowIfNull(nameof(applicationTypeName));
applicationTypeVersion.ThrowIfNull(nameof(applicationTypeVersion));
nodeName.ThrowIfNull(nameof(nodeName));
this.ServiceManifestName = serviceManifestName;
this.ApplicationTypeName = applicationTypeName;
this.ApplicationTypeVersion = applicationTypeVersion;
this.NodeName = nodeName;
this.PackageSharingPolicy = packageSharingPolicy;
}
/// <summary>
/// Initializes a new instance of the StatelessServiceInstanceInfo class.
/// </summary>
/// <param name="replicaStatus">The status of a replica of a service. Possible values include: 'Invalid', 'InBuild',
/// 'Standby', 'Ready', 'Down', 'Dropped'</param>
/// <param name="healthState">The health state of a Service Fabric entity such as Cluster, Node, Application, Service,
/// Partition, Replica etc. Possible values include: 'Invalid', 'Ok', 'Warning', 'Error', 'Unknown'</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="address">The address the replica is listening on.</param>
/// <param name="lastInBuildDurationInSeconds">The last in build duration of the replica in seconds.</param>
/// <param name="instanceId">Id of a stateless service instance. InstanceId is used by Service Fabric to uniquely
/// identify an instance of a partition of a stateless service. It is unique within a partition and does not change for
/// the lifetime of the instance. If the instance has failed over on the same or different node, it will get a
/// different value for the InstanceId.</param>
public StatelessServiceInstanceInfo(
ReplicaStatus?replicaStatus = default(ReplicaStatus?),
HealthState?healthState = default(HealthState?),
NodeName nodeName = default(NodeName),
string address = default(string),
string lastInBuildDurationInSeconds = default(string),
ReplicaId instanceId = default(ReplicaId))
: base(
Common.ServiceKind.Stateless,
replicaStatus,
healthState,
nodeName,
address,
lastInBuildDurationInSeconds)
{
this.InstanceId = instanceId;
}
/// <summary>
/// Initializes a new instance of the DeployedServicePackageHealthEvaluation class.
/// </summary>
/// <param name="aggregatedHealthState">The health state of a Service Fabric entity such as Cluster, Node, Application,
/// Service, Partition, Replica etc. Possible values include: 'Invalid', 'Ok', 'Warning', 'Error', 'Unknown'</param>
/// <param name="description">Description of the health evaluation, which represents a summary of the evaluation
/// process.</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="applicationName">The name of the application, including the 'fabric:' URI scheme.</param>
/// <param name="serviceManifestName">The name of the service manifest.</param>
/// <param name="unhealthyEvaluations">List of unhealthy evaluations that led to the current aggregated health state.
/// The type of the unhealthy evaluations can be EventHealthEvaluation.</param>
public DeployedServicePackageHealthEvaluation(
HealthState?aggregatedHealthState = default(HealthState?),
string description = default(string),
NodeName nodeName = default(NodeName),
ApplicationName applicationName = default(ApplicationName),
string serviceManifestName = default(string),
IEnumerable <HealthEvaluationWrapper> unhealthyEvaluations = default(IEnumerable <HealthEvaluationWrapper>))
: base(
Common.HealthEvaluationKind.DeployedServicePackage,
aggregatedHealthState,
description)
{
this.NodeName = nodeName;
this.ApplicationName = applicationName;
this.ServiceManifestName = serviceManifestName;
this.UnhealthyEvaluations = unhealthyEvaluations;
}
/// <summary>
/// Initializes a new instance of the NodeInfo class.
/// </summary>
/// <param name="name">The name of a Service Fabric node.</param>
/// <param name="ipAddressOrFQDN">The IP address or fully qualified domain name of the node.</param>
/// <param name="type">The type of the node.</param>
/// <param name="codeVersion">The version of Service Fabric binaries that the node is running.</param>
/// <param name="configVersion">The version of Service Fabric cluster manifest that the node is using.</param>
/// <param name="nodeStatus">The status of the node. Possible values include: 'Invalid', 'Up', 'Down', 'Enabling',
/// 'Disabling', 'Disabled', 'Unknown', 'Removed'</param>
/// <param name="nodeUpTimeInSeconds">Time in seconds since the node has been in NodeStatus Up. Value zero indicates
/// that the node is not Up.</param>
/// <param name="healthState">The health state of a Service Fabric entity such as Cluster, Node, Application, Service,
/// Partition, Replica etc. Possible values include: 'Invalid', 'Ok', 'Warning', 'Error', 'Unknown'</param>
/// <param name="isSeedNode">Indicates if the node is a seed node or not. Returns true if the node is a seed node,
/// otherwise false. A quorum of seed nodes are required for proper operation of Service Fabric cluster.</param>
/// <param name="upgradeDomain">The upgrade domain of the node.</param>
/// <param name="faultDomain">The fault domain of the node.</param>
/// <param name="id">An internal ID used by Service Fabric to uniquely identify a node. Node Id is deterministically
/// generated from node name.</param>
/// <param name="instanceId">The ID representing the node instance. While the ID of the node is deterministically
/// generated from the node name and remains same across restarts, the InstanceId changes every time node
/// restarts.</param>
/// <param name="nodeDeactivationInfo">Information about the node deactivation. This information is valid for a node
/// that is undergoing deactivation or has already been deactivated.</param>
/// <param name="isStopped">Indicates if the node is stopped by calling stop node API or not. Returns true if the node
/// is stopped, otherwise false.</param>
/// <param name="nodeDownTimeInSeconds">Time in seconds since the node has been in NodeStatus Down. Value zero
/// indicates node is not NodeStatus Down.</param>
/// <param name="nodeUpAt">Date time in UTC when the node came up. If the node has never been up then this value will
/// be zero date time.</param>
/// <param name="nodeDownAt">Date time in UTC when the node went down. If node has never been down then this value will
/// be zero date time.</param>
/// <param name="nodeTags">List that contains tags, which will be applied to the nodes.</param>
/// <param name="isNodeByNodeUpgradeInProgress">Indicates if a node-by-node upgrade is currently being performed on
/// this node.</param>
/// <param name="infrastructurePlacementID">PlacementID used by the InfrastructureService.</param>
public NodeInfo(
NodeName name = default(NodeName),
string ipAddressOrFQDN = default(string),
string type = default(string),
string codeVersion = default(string),
string configVersion = default(string),
NodeStatus?nodeStatus = default(NodeStatus?),
string nodeUpTimeInSeconds = default(string),
HealthState?healthState = default(HealthState?),
bool?isSeedNode = default(bool?),
string upgradeDomain = default(string),
string faultDomain = default(string),
NodeId id = default(NodeId),
string instanceId = default(string),
NodeDeactivationInfo nodeDeactivationInfo = default(NodeDeactivationInfo),
bool?isStopped = default(bool?),
string nodeDownTimeInSeconds = default(string),
DateTime?nodeUpAt = default(DateTime?),
DateTime?nodeDownAt = default(DateTime?),
IEnumerable <string> nodeTags = default(IEnumerable <string>),
bool?isNodeByNodeUpgradeInProgress = default(bool?),
string infrastructurePlacementID = default(string))
{
this.Name = name;
this.IpAddressOrFQDN = ipAddressOrFQDN;
this.Type = type;
this.CodeVersion = codeVersion;
this.ConfigVersion = configVersion;
this.NodeStatus = nodeStatus;
this.NodeUpTimeInSeconds = nodeUpTimeInSeconds;
this.HealthState = healthState;
this.IsSeedNode = isSeedNode;
this.UpgradeDomain = upgradeDomain;
this.FaultDomain = faultDomain;
this.Id = id;
this.InstanceId = instanceId;
this.NodeDeactivationInfo = nodeDeactivationInfo;
this.IsStopped = isStopped;
this.NodeDownTimeInSeconds = nodeDownTimeInSeconds;
this.NodeUpAt = nodeUpAt;
this.NodeDownAt = nodeDownAt;
this.NodeTags = nodeTags;
this.IsNodeByNodeUpgradeInProgress = isNodeByNodeUpgradeInProgress;
this.InfrastructurePlacementID = infrastructurePlacementID;
}
/// <summary>
/// Initializes a new instance of the DeployedApplicationHealth class.
/// </summary>
/// <param name="aggregatedHealthState">The health state of a Service Fabric entity such as Cluster, Node, Application,
/// Service, Partition, Replica etc. Possible values include: 'Invalid', 'Ok', 'Warning', 'Error', 'Unknown'</param>
/// <param name="healthEvents">The list of health events reported on the entity.</param>
/// <param name="unhealthyEvaluations">The unhealthy evaluations that show why the current aggregated health state was
/// returned by Health Manager.</param>
/// <param name="healthStatistics">Shows the health statistics for all children types of the queried entity.</param>
/// <param name="name">Name of the application deployed on the node whose health information is described by this
/// object.</param>
/// <param name="nodeName">Name of the node where this application is deployed.</param>
/// <param name="deployedServicePackageHealthStates">Deployed service package health states for the current deployed
/// application as found in the health store.</param>
public DeployedApplicationHealth(
HealthState?aggregatedHealthState = default(HealthState?),
IEnumerable <HealthEvent> healthEvents = default(IEnumerable <HealthEvent>),
IEnumerable <HealthEvaluationWrapper> unhealthyEvaluations = default(IEnumerable <HealthEvaluationWrapper>),
HealthStatistics healthStatistics = default(HealthStatistics),
ApplicationName name = default(ApplicationName),
NodeName nodeName = default(NodeName),
IEnumerable <DeployedServicePackageHealthState> deployedServicePackageHealthStates = default(IEnumerable <DeployedServicePackageHealthState>))
: base(
aggregatedHealthState,
healthEvents,
unhealthyEvaluations,
healthStatistics)
{
this.Name = name;
this.NodeName = nodeName;
this.DeployedServicePackageHealthStates = deployedServicePackageHealthStates;
}
/// <summary>
/// Initializes a new instance of the DeployedServicePackageHealth class.
/// </summary>
/// <param name="aggregatedHealthState">The HealthState representing the aggregated health state of the entity computed
/// by Health Manager.
/// The health evaluation of the entity reflects all events reported on the entity and its children (if any).
/// The aggregation is done by applying the desired health policy.
/// . Possible values include: 'Invalid', 'Ok', 'Warning', 'Error', 'Unknown'
///
/// The health state of a Service Fabric entity such as Cluster, Node, Application, Service, Partition, Replica etc.
/// </param>
/// <param name="healthEvents">The list of health events reported on the entity.</param>
/// <param name="unhealthyEvaluations">The unhealthy evaluations that show why the current aggregated health state was
/// returned by Health Manager.</param>
/// <param name="healthStatistics">Shows the health statistics for all children types of the queried entity.</param>
/// <param name="applicationName">The name of the application, including the 'fabric:' URI scheme.</param>
/// <param name="serviceManifestName">Name of the service manifest.</param>
/// <param name="nodeName">Name of the node where this service package is deployed.</param>
public DeployedServicePackageHealth(
HealthState?aggregatedHealthState = default(HealthState?),
IEnumerable <HealthEvent> healthEvents = default(IEnumerable <HealthEvent>),
IEnumerable <HealthEvaluationWrapper> unhealthyEvaluations = default(IEnumerable <HealthEvaluationWrapper>),
HealthStatistics healthStatistics = default(HealthStatistics),
ApplicationName applicationName = default(ApplicationName),
string serviceManifestName = default(string),
NodeName nodeName = default(NodeName))
: base(
aggregatedHealthState,
healthEvents,
unhealthyEvaluations,
healthStatistics)
{
this.ApplicationName = applicationName;
this.ServiceManifestName = serviceManifestName;
this.NodeName = nodeName;
}
/// <summary>
/// Initializes a new instance of the NodeDownEvent class.
/// </summary>
/// <param name="eventInstanceId">The identifier for the FabricEvent instance.</param>
/// <param name="timeStamp">The time event was logged.</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="nodeInstance">Id of Node instance.</param>
/// <param name="lastNodeUpAt">Time when Node was last up.</param>
/// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param>
public NodeDownEvent(
Guid?eventInstanceId,
DateTime?timeStamp,
NodeName nodeName,
long?nodeInstance,
DateTime?lastNodeUpAt,
bool?hasCorrelatedEvents = default(bool?))
: base(
eventInstanceId,
timeStamp,
Common.FabricEventKind.NodeDown,
nodeName,
hasCorrelatedEvents)
{
nodeInstance.ThrowIfNull(nameof(nodeInstance));
lastNodeUpAt.ThrowIfNull(nameof(lastNodeUpAt));
this.NodeInstance = nodeInstance;
this.LastNodeUpAt = lastNodeUpAt;
}
/// <summary>
/// Initializes a new instance of the StatefulServiceReplicaInfo class.
/// </summary>
/// <param name="replicaStatus">The status of a replica of a service. Possible values include: 'Invalid', 'InBuild',
/// 'Standby', 'Ready', 'Down', 'Dropped'</param>
/// <param name="healthState">The health state of a Service Fabric entity such as Cluster, Node, Application, Service,
/// Partition, Replica etc. Possible values include: 'Invalid', 'Ok', 'Warning', 'Error', 'Unknown'</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="address">The address the replica is listening on.</param>
/// <param name="lastInBuildDurationInSeconds">The last in build duration of the replica in seconds.</param>
/// <param name="replicaRole">The role of a replica of a stateful service. Possible values include: 'Unknown', 'None',
/// 'Primary', 'IdleSecondary', 'ActiveSecondary'</param>
/// <param name="replicaId">Id of a stateful service replica. ReplicaId is used by Service Fabric to uniquely identify
/// a replica of a partition. It is unique within a partition and does not change for the lifetime of the replica. If a
/// replica gets dropped and another replica gets created on the same node for the same partition, it will get a
/// different value for the id. Sometimes the id of a stateless service instance is also referred as a replica
/// id.</param>
public StatefulServiceReplicaInfo(
ReplicaStatus?replicaStatus = default(ReplicaStatus?),
HealthState?healthState = default(HealthState?),
NodeName nodeName = default(NodeName),
string address = default(string),
string lastInBuildDurationInSeconds = default(string),
ReplicaRole?replicaRole = default(ReplicaRole?),
ReplicaId replicaId = default(ReplicaId))
: base(
Common.ServiceKind.Stateful,
replicaStatus,
healthState,
nodeName,
address,
lastInBuildDurationInSeconds)
{
this.ReplicaRole = replicaRole;
this.ReplicaId = replicaId;
}
/// <summary>
/// Initializes a new instance of the NodeOpenFailedEvent class.
/// </summary>
/// <param name="eventInstanceId">The identifier for the FabricEvent instance.</param>
/// <param name="timeStamp">The time event was logged.</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="nodeInstance">Id of Node instance.</param>
/// <param name="nodeId">Id of Node.</param>
/// <param name="upgradeDomain">Upgrade domain of Node.</param>
/// <param name="faultDomain">Fault domain of Node.</param>
/// <param name="ipAddressOrFQDN">IP address or FQDN.</param>
/// <param name="hostname">Name of Host.</param>
/// <param name="isSeedNode">Indicates if it is seed node.</param>
/// <param name="nodeVersion">Version of Node.</param>
/// <param name="error">Describes the error.</param>
/// <param name="category">The category of event.</param>
/// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param>
public NodeOpenFailedEvent(
Guid?eventInstanceId,
DateTime?timeStamp,
NodeName nodeName,
long?nodeInstance,
string nodeId,
string upgradeDomain,
string faultDomain,
string ipAddressOrFQDN,
string hostname,
bool?isSeedNode,
string nodeVersion,
string error,
string category = default(string),
bool?hasCorrelatedEvents = default(bool?))
: base(
eventInstanceId,
timeStamp,
Common.FabricEventKind.NodeOpenFailed,
nodeName,
category,
hasCorrelatedEvents)
{
nodeInstance.ThrowIfNull(nameof(nodeInstance));
nodeId.ThrowIfNull(nameof(nodeId));
upgradeDomain.ThrowIfNull(nameof(upgradeDomain));
faultDomain.ThrowIfNull(nameof(faultDomain));
ipAddressOrFQDN.ThrowIfNull(nameof(ipAddressOrFQDN));
hostname.ThrowIfNull(nameof(hostname));
isSeedNode.ThrowIfNull(nameof(isSeedNode));
nodeVersion.ThrowIfNull(nameof(nodeVersion));
error.ThrowIfNull(nameof(error));
this.NodeInstance = nodeInstance;
this.NodeId = nodeId;
this.UpgradeDomain = upgradeDomain;
this.FaultDomain = faultDomain;
this.IpAddressOrFQDN = ipAddressOrFQDN;
this.Hostname = hostname;
this.IsSeedNode = isSeedNode;
this.NodeVersion = nodeVersion;
this.Error = error;
}
/// <summary>
/// Initializes a new instance of the NodeHealthReportExpiredEvent class.
/// </summary>
/// <param name="eventInstanceId">The identifier for the FabricEvent instance.</param>
/// <param name="timeStamp">The time event was logged.</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="nodeInstanceId">Id of Node instance.</param>
/// <param name="sourceId">Id of report source.</param>
/// <param name="property">Describes the property.</param>
/// <param name="healthState">Describes the property health state.</param>
/// <param name="timeToLiveMs">Time to live in milli-seconds.</param>
/// <param name="sequenceNumber">Sequence number of report.</param>
/// <param name="description">Description of report.</param>
/// <param name="removeWhenExpired">Indicates the removal when it expires.</param>
/// <param name="sourceUtcTimestamp">Source time.</param>
/// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param>
public NodeHealthReportExpiredEvent(
Guid?eventInstanceId,
DateTime?timeStamp,
NodeName nodeName,
long?nodeInstanceId,
string sourceId,
string property,
string healthState,
long?timeToLiveMs,
long?sequenceNumber,
string description,
bool?removeWhenExpired,
DateTime?sourceUtcTimestamp,
bool?hasCorrelatedEvents = default(bool?))
: base(
eventInstanceId,
timeStamp,
Common.FabricEventKind.NodeHealthReportExpired,
nodeName,
hasCorrelatedEvents)
{
nodeInstanceId.ThrowIfNull(nameof(nodeInstanceId));
sourceId.ThrowIfNull(nameof(sourceId));
property.ThrowIfNull(nameof(property));
healthState.ThrowIfNull(nameof(healthState));
timeToLiveMs.ThrowIfNull(nameof(timeToLiveMs));
sequenceNumber.ThrowIfNull(nameof(sequenceNumber));
description.ThrowIfNull(nameof(description));
removeWhenExpired.ThrowIfNull(nameof(removeWhenExpired));
sourceUtcTimestamp.ThrowIfNull(nameof(sourceUtcTimestamp));
this.NodeInstanceId = nodeInstanceId;
this.SourceId = sourceId;
this.Property = property;
this.HealthState = healthState;
this.TimeToLiveMs = timeToLiveMs;
this.SequenceNumber = sequenceNumber;
this.Description = description;
this.RemoveWhenExpired = removeWhenExpired;
this.SourceUtcTimestamp = sourceUtcTimestamp;
}
/// <summary>
/// Initializes a new instance of the ChaosRestartNodeFaultScheduledEvent class.
/// </summary>
/// <param name="eventInstanceId">The identifier for the FabricEvent instance.</param>
/// <param name="timeStamp">The time event was logged.</param>
/// <param name="nodeName">The name of a Service Fabric node.</param>
/// <param name="nodeInstanceId">Id of Node instance.</param>
/// <param name="faultGroupId">Id of fault group.</param>
/// <param name="faultId">Id of fault.</param>
/// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param>
public ChaosRestartNodeFaultScheduledEvent(
Guid?eventInstanceId,
DateTime?timeStamp,
NodeName nodeName,
long?nodeInstanceId,
Guid?faultGroupId,
Guid?faultId,
bool?hasCorrelatedEvents = default(bool?))
: base(
eventInstanceId,
timeStamp,
Common.FabricEventKind.ChaosRestartNodeFaultScheduled,
nodeName,
hasCorrelatedEvents)
{
nodeInstanceId.ThrowIfNull(nameof(nodeInstanceId));
faultGroupId.ThrowIfNull(nameof(faultGroupId));
faultId.ThrowIfNull(nameof(faultId));
this.NodeInstanceId = nodeInstanceId;
this.FaultGroupId = faultGroupId;
this.FaultId = faultId;
}
