/// <summary> /// Initializes a new instance of the DeployedStatefulServiceReplicaDetailInfo class. /// </summary> /// <param name="serviceName">Full hierarchical name of the service in URI format starting with `fabric:`.</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="currentServiceOperation">Specifies the current active life-cycle operation on a stateful service /// replica or stateless service instance. Possible values include: 'Unknown', 'None', 'Open', 'ChangeRole', 'Close', /// 'Abort'</param> /// <param name="currentServiceOperationStartTimeUtc">The start time of the current service operation in UTC /// format.</param> /// <param name="reportedLoad">List of load reported by replica.</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> /// <param name="currentReplicatorOperation">Specifies the operation currently being executed by the Replicator. /// Possible values include: 'Invalid', 'None', 'Open', 'ChangeRole', 'UpdateEpoch', 'Close', 'Abort', 'OnDataLoss', /// 'WaitForCatchup', 'Build'</param> /// <param name="readStatus">Specifies the access status of the partition. Possible values include: 'Invalid', /// 'Granted', 'ReconfigurationPending', 'NotPrimary', 'NoWriteQuorum'</param> /// <param name="writeStatus">Specifies the access status of the partition. Possible values include: 'Invalid', /// 'Granted', 'ReconfigurationPending', 'NotPrimary', 'NoWriteQuorum'</param> /// <param name="replicatorStatus">Represents a base class for primary or secondary replicator status. /// Contains information about the service fabric replicator like the replication/copy queue utilization, last /// acknowledgement received timestamp, etc. /// </param> /// <param name="replicaStatus">Key value store related information for the replica.</param> /// <param name="deployedServiceReplicaQueryResult">Information about a stateful service replica deployed on a /// node.</param> public DeployedStatefulServiceReplicaDetailInfo( ServiceName serviceName = default(ServiceName), PartitionId partitionId = default(PartitionId), ServiceOperationName?currentServiceOperation = default(ServiceOperationName?), DateTime?currentServiceOperationStartTimeUtc = default(DateTime?), IEnumerable <LoadMetricReportInfo> reportedLoad = default(IEnumerable <LoadMetricReportInfo>), ReplicaId replicaId = default(ReplicaId), ReplicatorOperationName?currentReplicatorOperation = default(ReplicatorOperationName?), PartitionAccessStatus?readStatus = default(PartitionAccessStatus?), PartitionAccessStatus?writeStatus = default(PartitionAccessStatus?), ReplicatorStatus replicatorStatus = default(ReplicatorStatus), KeyValueStoreReplicaStatus replicaStatus = default(KeyValueStoreReplicaStatus), DeployedStatefulServiceReplicaInfo deployedServiceReplicaQueryResult = default(DeployedStatefulServiceReplicaInfo)) : base( Common.ServiceKind.Stateful, serviceName, partitionId, currentServiceOperation, currentServiceOperationStartTimeUtc, reportedLoad) { this.ReplicaId = replicaId; this.CurrentReplicatorOperation = currentReplicatorOperation; this.ReadStatus = readStatus; this.WriteStatus = writeStatus; this.ReplicatorStatus = replicatorStatus; this.ReplicaStatus = replicaStatus; this.DeployedServiceReplicaQueryResult = deployedServiceReplicaQueryResult; }
/// <summary> /// Initializes a new instance of the DeployedStatefulServiceReplicaInfo class. /// </summary> /// <param name="serviceName">The full name of the service with 'fabric:' URI scheme.</param> /// <param name="serviceTypeName">Name of the service type as specified in the service manifest.</param> /// <param name="serviceManifestName">The name of the service manifest in which this service type is defined.</param> /// <param name="codePackageName">The name of the code package that hosts this replica.</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="replicaStatus">The status of a replica of a service. Possible values include: 'Invalid', 'InBuild', /// 'Standby', 'Ready', 'Down', 'Dropped'</param> /// <param name="address">The last address returned by the replica in Open or ChangeRole.</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> /// <param name="hostProcessId">Host process ID of the process that is hosting the replica. This will be zero if the /// replica is down. In hyper-v containers this host process ID will be from different kernel.</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> /// <param name="replicaRole">The role of a replica of a stateful service. Possible values include: 'Unknown', 'None', /// 'Primary', 'IdleSecondary', 'ActiveSecondary'</param> /// <param name="reconfigurationInformation">Information about current reconfiguration like phase, type, previous /// configuration role of replica and reconfiguration start date time.</param> public DeployedStatefulServiceReplicaInfo( ServiceName serviceName = default(ServiceName), string serviceTypeName = default(string), string serviceManifestName = default(string), string codePackageName = default(string), PartitionId partitionId = default(PartitionId), ReplicaStatus?replicaStatus = default(ReplicaStatus?), string address = default(string), string servicePackageActivationId = default(string), string hostProcessId = default(string), ReplicaId replicaId = default(ReplicaId), ReplicaRole?replicaRole = default(ReplicaRole?), ReconfigurationInformation reconfigurationInformation = default(ReconfigurationInformation)) : base( Common.ServiceKind.Stateful, serviceName, serviceTypeName, serviceManifestName, codePackageName, partitionId, replicaStatus, address, servicePackageActivationId, hostProcessId) { this.ReplicaId = replicaId; this.ReplicaRole = replicaRole; this.ReconfigurationInformation = reconfigurationInformation; }
/// <summary> /// Initializes a new instance of the ChaosReplicaRemovalScheduledEvent 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="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> /// <param name="faultGroupId">Id of fault group.</param> /// <param name="faultId">Id of fault.</param> /// <param name="serviceUri">Service name.</param> /// <param name="category">The category of event.</param> /// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param> public ChaosReplicaRemovalScheduledEvent( Guid?eventInstanceId, DateTime?timeStamp, PartitionId partitionId, ReplicaId replicaId, Guid?faultGroupId, Guid?faultId, string serviceUri, string category = default(string), bool?hasCorrelatedEvents = default(bool?)) : base( eventInstanceId, timeStamp, Common.FabricEventKind.ChaosReplicaRemovalScheduled, partitionId, replicaId, category, hasCorrelatedEvents) { faultGroupId.ThrowIfNull(nameof(faultGroupId)); faultId.ThrowIfNull(nameof(faultId)); serviceUri.ThrowIfNull(nameof(serviceUri)); this.FaultGroupId = faultGroupId; this.FaultId = faultId; this.ServiceUri = serviceUri; }
/// <summary> /// Initializes a new instance of the DeployedStatelessServiceInstanceInfo class. /// </summary> /// <param name="serviceName">The full name of the service with 'fabric:' URI scheme.</param> /// <param name="serviceTypeName">Name of the service type as specified in the service manifest.</param> /// <param name="serviceManifestName">The name of the service manifest in which this service type is defined.</param> /// <param name="codePackageName">The name of the code package that hosts this replica.</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="replicaStatus">The status of a replica of a service. Possible values include: 'Invalid', 'InBuild', /// 'Standby', 'Ready', 'Down', 'Dropped'</param> /// <param name="address">The last address returned by the replica in Open or ChangeRole.</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> /// <param name="hostProcessId">Host process ID of the process that is hosting the replica. This will be zero if the /// replica is down. In hyper-v containers this host process ID will be from different kernel.</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 DeployedStatelessServiceInstanceInfo( ServiceName serviceName = default(ServiceName), string serviceTypeName = default(string), string serviceManifestName = default(string), string codePackageName = default(string), PartitionId partitionId = default(PartitionId), ReplicaStatus?replicaStatus = default(ReplicaStatus?), string address = default(string), string servicePackageActivationId = default(string), string hostProcessId = default(string), ReplicaId instanceId = default(ReplicaId)) : base( Common.ServiceKind.Stateless, serviceName, serviceTypeName, serviceManifestName, codePackageName, partitionId, replicaStatus, address, servicePackageActivationId, hostProcessId) { this.InstanceId = instanceId; }
/// <summary> /// Initializes a new instance of the StatefulServiceReplicaHealthState 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="partitionId">The ID of the partition to which this replica belongs.</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 StatefulServiceReplicaHealthState( HealthState?aggregatedHealthState = default(HealthState?), PartitionId partitionId = default(PartitionId), ReplicaId replicaId = default(ReplicaId)) : base( aggregatedHealthState, partitionId) { this.ReplicaId = replicaId; }
/// <summary> /// Initializes a new instance of the StatelessServiceInstanceHealthState 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="partitionId">The ID of the partition to which this replica belongs.</param> /// <param name="replicaId">Id of the stateless service instance on the wire this field is called ReplicaId.</param> public StatelessServiceInstanceHealthState( HealthState?aggregatedHealthState = default(HealthState?), PartitionId partitionId = default(PartitionId), ReplicaId replicaId = default(ReplicaId)) : base( Common.ServiceKind.Stateless, aggregatedHealthState, partitionId) { this.ReplicaId = replicaId; }
/// <summary> /// Initializes a new instance of the StatefulServiceReplicaHealth 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="partitionId">Id of the partition to which this replica belongs.</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 StatefulServiceReplicaHealth( HealthState?aggregatedHealthState = default(HealthState?), IEnumerable <HealthEvent> healthEvents = default(IEnumerable <HealthEvent>), IEnumerable <HealthEvaluationWrapper> unhealthyEvaluations = default(IEnumerable <HealthEvaluationWrapper>), HealthStatistics healthStatistics = default(HealthStatistics), PartitionId partitionId = default(PartitionId), ReplicaId replicaId = default(ReplicaId)) : base( aggregatedHealthState, healthEvents, unhealthyEvaluations, healthStatistics, partitionId) { this.ReplicaId = replicaId; }
/// <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 StatelessServiceInstanceHealth 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="partitionId">Id of the partition to which this replica belongs.</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 StatelessServiceInstanceHealth( HealthState?aggregatedHealthState = default(HealthState?), IEnumerable <HealthEvent> healthEvents = default(IEnumerable <HealthEvent>), IEnumerable <HealthEvaluationWrapper> unhealthyEvaluations = default(IEnumerable <HealthEvaluationWrapper>), HealthStatistics healthStatistics = default(HealthStatistics), PartitionId partitionId = default(PartitionId), ReplicaId instanceId = default(ReplicaId)) : base( Common.ServiceKind.Stateless, aggregatedHealthState, healthEvents, unhealthyEvaluations, healthStatistics, partitionId) { this.InstanceId = instanceId; }
/// <summary> /// Initializes a new instance of the ReplicaEvent 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="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="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> /// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param> public ReplicaEvent( Guid?eventInstanceId, DateTime?timeStamp, FabricEventKind?kind, PartitionId partitionId, ReplicaId replicaId, bool?hasCorrelatedEvents = default(bool?)) : base( eventInstanceId, timeStamp, Common.FabricEventKind.ReplicaEvent, hasCorrelatedEvents) { partitionId.ThrowIfNull(nameof(partitionId)); replicaId.ThrowIfNull(nameof(replicaId)); this.PartitionId = partitionId; this.ReplicaId = replicaId; }
/// <summary> /// Initializes a new instance of the StatefulReplicaHealthReportExpiredEvent 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="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> /// <param name="replicaInstanceId">Id of Replica 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="category">The category of event.</param> /// <param name="hasCorrelatedEvents">Shows there is existing related events available.</param> public StatefulReplicaHealthReportExpiredEvent( Guid?eventInstanceId, DateTime?timeStamp, PartitionId partitionId, ReplicaId replicaId, long?replicaInstanceId, 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.StatefulReplicaHealthReportExpired, partitionId, replicaId, category, hasCorrelatedEvents) { replicaInstanceId.ThrowIfNull(nameof(replicaInstanceId)); 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.ReplicaInstanceId = replicaInstanceId; 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 RemoteReplicatorStatus class. /// </summary> /// <param name="replicaId">Represents the replica ID of the remote secondary replicator.</param> /// <param name="lastAcknowledgementProcessedTimeUtc">The last timestamp (in UTC) when an acknowledgement from the /// secondary replicator was processed on the primary. /// UTC 0 represents an invalid value, indicating that no acknowledgement messages were ever processed. /// </param> /// <param name="lastReceivedReplicationSequenceNumber">The highest replication operation sequence number that the /// secondary has received from the primary.</param> /// <param name="lastAppliedReplicationSequenceNumber">The highest replication operation sequence number that the /// secondary has applied to its state.</param> /// <param name="isInBuild">A value that indicates whether the secondary replica is in the process of being /// built.</param> /// <param name="lastReceivedCopySequenceNumber">The highest copy operation sequence number that the secondary has /// received from the primary. /// A value of -1 implies that the secondary has received all copy operations. /// </param> /// <param name="lastAppliedCopySequenceNumber">The highest copy operation sequence number that the secondary has /// applied to its state. /// A value of -1 implies that the secondary has applied all copy operations and the copy process is complete. /// </param> /// <param name="remoteReplicatorAcknowledgementStatus">Represents the acknowledgment status for the remote secondary /// replicator.</param> public RemoteReplicatorStatus( ReplicaId replicaId = default(ReplicaId), DateTime?lastAcknowledgementProcessedTimeUtc = default(DateTime?), string lastReceivedReplicationSequenceNumber = default(string), string lastAppliedReplicationSequenceNumber = default(string), bool?isInBuild = default(bool?), string lastReceivedCopySequenceNumber = default(string), string lastAppliedCopySequenceNumber = default(string), RemoteReplicatorAcknowledgementStatus remoteReplicatorAcknowledgementStatus = default(RemoteReplicatorAcknowledgementStatus)) { this.ReplicaId = replicaId; this.LastAcknowledgementProcessedTimeUtc = lastAcknowledgementProcessedTimeUtc; this.LastReceivedReplicationSequenceNumber = lastReceivedReplicationSequenceNumber; this.LastAppliedReplicationSequenceNumber = lastAppliedReplicationSequenceNumber; this.IsInBuild = isInBuild; this.LastReceivedCopySequenceNumber = lastReceivedCopySequenceNumber; this.LastAppliedCopySequenceNumber = lastAppliedCopySequenceNumber; this.RemoteReplicatorAcknowledgementStatus = remoteReplicatorAcknowledgementStatus; }
/// <summary> /// Initializes a new instance of the DeployedStatelessServiceInstanceDetailInfo class. /// </summary> /// <param name="serviceName">Full hierarchical name of the service in URI format starting with `fabric:`.</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="currentServiceOperation">Specifies the current active life-cycle operation on a stateful service /// replica or stateless service instance. Possible values include: 'Unknown', 'None', 'Open', 'ChangeRole', 'Close', /// 'Abort'</param> /// <param name="currentServiceOperationStartTimeUtc">The start time of the current service operation in UTC /// format.</param> /// <param name="reportedLoad">List of load reported by replica.</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> /// <param name="deployedServiceReplicaQueryResult">Information about a stateless service instance deployed on a /// node.</param> public DeployedStatelessServiceInstanceDetailInfo( ServiceName serviceName = default(ServiceName), PartitionId partitionId = default(PartitionId), ServiceOperationName?currentServiceOperation = default(ServiceOperationName?), DateTime?currentServiceOperationStartTimeUtc = default(DateTime?), IEnumerable <LoadMetricReportInfo> reportedLoad = default(IEnumerable <LoadMetricReportInfo>), ReplicaId instanceId = default(ReplicaId), DeployedStatelessServiceInstanceInfo deployedServiceReplicaQueryResult = default(DeployedStatelessServiceInstanceInfo)) : base( Common.ServiceKind.Stateless, serviceName, partitionId, currentServiceOperation, currentServiceOperationStartTimeUtc, reportedLoad) { this.InstanceId = instanceId; this.DeployedServiceReplicaQueryResult = deployedServiceReplicaQueryResult; }
/// <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; }