/// <summary>
        /// Gets the object from Json properties.
        /// </summary>
        /// <param name="reader">The <see cref="T: Newtonsoft.Json.JsonReader" /> to read from, reader must be placed at first property.</param>
        /// <returns>The object Value.</returns>
        internal static StatefulServiceReplicaHealthState GetFromJsonProperties(JsonReader reader)
        {
            var aggregatedHealthState = default(HealthState?);
            var partitionId           = default(PartitionId);
            var replicaId             = default(ReplicaId);

            do
            {
                var propName = reader.ReadPropertyName();
                if (string.Compare("AggregatedHealthState", propName, StringComparison.Ordinal) == 0)
                {
                    aggregatedHealthState = HealthStateConverter.Deserialize(reader);
                }
                else if (string.Compare("PartitionId", propName, StringComparison.Ordinal) == 0)
                {
                    partitionId = PartitionIdConverter.Deserialize(reader);
                }
                else if (string.Compare("ReplicaId", propName, StringComparison.Ordinal) == 0)
                {
                    replicaId = ReplicaIdConverter.Deserialize(reader);
                }
                else
                {
                    reader.SkipPropertyValue();
                }
            }while (reader.TokenType != JsonToken.EndObject);

            return(new StatefulServiceReplicaHealthState(
                       aggregatedHealthState: aggregatedHealthState,
                       partitionId: partitionId,
                       replicaId: replicaId));
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Gets the object from Json properties.
        /// </summary>
        /// <param name="reader">The <see cref="T: Newtonsoft.Json.JsonReader" /> to read from, reader must be placed at first property.</param>
        /// <returns>The object Value.</returns>
        internal static DeployedStatelessServiceInstanceDetailInfo GetFromJsonProperties(JsonReader reader)
        {
            var serviceName                         = default(ServiceName);
            var partitionId                         = default(PartitionId);
            var currentServiceOperation             = default(ServiceOperationName?);
            var currentServiceOperationStartTimeUtc = default(DateTime?);
            var reportedLoad                        = default(IEnumerable <LoadMetricReportInfo>);
            var instanceId = default(ReplicaId);
            var deployedServiceReplicaQueryResult = default(DeployedStatelessServiceInstanceInfo);

            do
            {
                var propName = reader.ReadPropertyName();
                if (string.Compare("ServiceName", propName, StringComparison.Ordinal) == 0)
                {
                    serviceName = ServiceNameConverter.Deserialize(reader);
                }
                else if (string.Compare("PartitionId", propName, StringComparison.Ordinal) == 0)
                {
                    partitionId = PartitionIdConverter.Deserialize(reader);
                }
                else if (string.Compare("CurrentServiceOperation", propName, StringComparison.Ordinal) == 0)
                {
                    currentServiceOperation = ServiceOperationNameConverter.Deserialize(reader);
                }
                else if (string.Compare("CurrentServiceOperationStartTimeUtc", propName, StringComparison.Ordinal) == 0)
                {
                    currentServiceOperationStartTimeUtc = reader.ReadValueAsDateTime();
                }
                else if (string.Compare("ReportedLoad", propName, StringComparison.Ordinal) == 0)
                {
                    reportedLoad = reader.ReadList(LoadMetricReportInfoConverter.Deserialize);
                }
                else if (string.Compare("InstanceId", propName, StringComparison.Ordinal) == 0)
                {
                    instanceId = ReplicaIdConverter.Deserialize(reader);
                }
                else if (string.Compare("DeployedServiceReplicaQueryResult", propName, StringComparison.Ordinal) == 0)
                {
                    deployedServiceReplicaQueryResult = DeployedStatelessServiceInstanceInfoConverter.Deserialize(reader);
                }
                else
                {
                    reader.SkipPropertyValue();
                }
            }while (reader.TokenType != JsonToken.EndObject);

            return(new DeployedStatelessServiceInstanceDetailInfo(
                       serviceName: serviceName,
                       partitionId: partitionId,
                       currentServiceOperation: currentServiceOperation,
                       currentServiceOperationStartTimeUtc: currentServiceOperationStartTimeUtc,
                       reportedLoad: reportedLoad,
                       instanceId: instanceId,
                       deployedServiceReplicaQueryResult: deployedServiceReplicaQueryResult));
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Gets the object from Json properties.
        /// </summary>
        /// <param name="reader">The <see cref="T: Newtonsoft.Json.JsonReader" /> to read from, reader must be placed at first property.</param>
        /// <returns>The object Value.</returns>
        internal static StatefulServiceReplicaInfo GetFromJsonProperties(JsonReader reader)
        {
            var replicaStatus = default(ReplicaStatus?);
            var healthState   = default(HealthState?);
            var nodeName      = default(NodeName);
            var address       = default(string);
            var lastInBuildDurationInSeconds = default(string);
            var replicaRole = default(ReplicaRole?);
            var replicaId   = default(ReplicaId);

            do
            {
                var propName = reader.ReadPropertyName();
                if (string.Compare("ReplicaStatus", propName, StringComparison.Ordinal) == 0)
                {
                    replicaStatus = ReplicaStatusConverter.Deserialize(reader);
                }
                else if (string.Compare("HealthState", propName, StringComparison.Ordinal) == 0)
                {
                    healthState = HealthStateConverter.Deserialize(reader);
                }
                else if (string.Compare("NodeName", propName, StringComparison.Ordinal) == 0)
                {
                    nodeName = NodeNameConverter.Deserialize(reader);
                }
                else if (string.Compare("Address", propName, StringComparison.Ordinal) == 0)
                {
                    address = reader.ReadValueAsString();
                }
                else if (string.Compare("LastInBuildDurationInSeconds", propName, StringComparison.Ordinal) == 0)
                {
                    lastInBuildDurationInSeconds = reader.ReadValueAsString();
                }
                else if (string.Compare("ReplicaRole", propName, StringComparison.Ordinal) == 0)
                {
                    replicaRole = ReplicaRoleConverter.Deserialize(reader);
                }
                else if (string.Compare("ReplicaId", propName, StringComparison.Ordinal) == 0)
                {
                    replicaId = ReplicaIdConverter.Deserialize(reader);
                }
                else
                {
                    reader.SkipPropertyValue();
                }
            }while (reader.TokenType != JsonToken.EndObject);

            return(new StatefulServiceReplicaInfo(
                       replicaStatus: replicaStatus,
                       healthState: healthState,
                       nodeName: nodeName,
                       address: address,
                       lastInBuildDurationInSeconds: lastInBuildDurationInSeconds,
                       replicaRole: replicaRole,
                       replicaId: replicaId));
        }
        /// <summary>
        /// Gets the object from Json properties.
        /// </summary>
        /// <param name="reader">The <see cref="T: Newtonsoft.Json.JsonReader" /> to read from, reader must be placed at first property.</param>
        /// <returns>The object Value.</returns>
        internal static StatelessServiceInstanceHealth GetFromJsonProperties(JsonReader reader)
        {
            var aggregatedHealthState = default(HealthState?);
            var healthEvents          = default(IEnumerable <HealthEvent>);
            var unhealthyEvaluations  = default(IEnumerable <HealthEvaluationWrapper>);
            var healthStatistics      = default(HealthStatistics);
            var partitionId           = default(PartitionId);
            var instanceId            = default(ReplicaId);

            do
            {
                var propName = reader.ReadPropertyName();
                if (string.Compare("AggregatedHealthState", propName, StringComparison.Ordinal) == 0)
                {
                    aggregatedHealthState = HealthStateConverter.Deserialize(reader);
                }
                else if (string.Compare("HealthEvents", propName, StringComparison.Ordinal) == 0)
                {
                    healthEvents = reader.ReadList(HealthEventConverter.Deserialize);
                }
                else if (string.Compare("UnhealthyEvaluations", propName, StringComparison.Ordinal) == 0)
                {
                    unhealthyEvaluations = reader.ReadList(HealthEvaluationWrapperConverter.Deserialize);
                }
                else if (string.Compare("HealthStatistics", propName, StringComparison.Ordinal) == 0)
                {
                    healthStatistics = HealthStatisticsConverter.Deserialize(reader);
                }
                else if (string.Compare("PartitionId", propName, StringComparison.Ordinal) == 0)
                {
                    partitionId = PartitionIdConverter.Deserialize(reader);
                }
                else if (string.Compare("InstanceId", propName, StringComparison.Ordinal) == 0)
                {
                    instanceId = ReplicaIdConverter.Deserialize(reader);
                }
                else
                {
                    reader.SkipPropertyValue();
                }
            }while (reader.TokenType != JsonToken.EndObject);

            return(new StatelessServiceInstanceHealth(
                       aggregatedHealthState: aggregatedHealthState,
                       healthEvents: healthEvents,
                       unhealthyEvaluations: unhealthyEvaluations,
                       healthStatistics: healthStatistics,
                       partitionId: partitionId,
                       instanceId: instanceId));
        }
        /// <summary>
        /// Gets the object from Json properties.
        /// </summary>
        /// <param name="reader">The <see cref="T: Newtonsoft.Json.JsonReader" /> to read from, reader must be placed at first property.</param>
        /// <returns>The object Value.</returns>
        internal static StatelessReplicaHealthReportExpiredEvent GetFromJsonProperties(JsonReader reader)
        {
            var eventInstanceId     = default(Guid?);
            var category            = default(string);
            var timeStamp           = default(DateTime?);
            var hasCorrelatedEvents = default(bool?);
            var partitionId         = default(PartitionId);
            var replicaId           = default(ReplicaId);
            var sourceId            = default(string);
            var property            = default(string);
            var healthState         = default(string);
            var timeToLiveMs        = default(long?);
            var sequenceNumber      = default(long?);
            var description         = default(string);
            var removeWhenExpired   = default(bool?);
            var sourceUtcTimestamp  = default(DateTime?);

            do
            {
                var propName = reader.ReadPropertyName();
                if (string.Compare("EventInstanceId", propName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    eventInstanceId = reader.ReadValueAsGuid();
                }
                else if (string.Compare("Category", propName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    category = reader.ReadValueAsString();
                }
                else if (string.Compare("TimeStamp", propName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    timeStamp = reader.ReadValueAsDateTime();
                }
                else if (string.Compare("HasCorrelatedEvents", propName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    hasCorrelatedEvents = reader.ReadValueAsBool();
                }
                else if (string.Compare("PartitionId", propName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    partitionId = PartitionIdConverter.Deserialize(reader);
                }
                else if (string.Compare("ReplicaId", propName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    replicaId = ReplicaIdConverter.Deserialize(reader);
                }
                else if (string.Compare("SourceId", propName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    sourceId = reader.ReadValueAsString();
                }
                else if (string.Compare("Property", propName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    property = reader.ReadValueAsString();
                }
                else if (string.Compare("HealthState", propName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    healthState = reader.ReadValueAsString();
                }
                else if (string.Compare("TimeToLiveMs", propName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    timeToLiveMs = reader.ReadValueAsLong();
                }
                else if (string.Compare("SequenceNumber", propName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    sequenceNumber = reader.ReadValueAsLong();
                }
                else if (string.Compare("Description", propName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    description = reader.ReadValueAsString();
                }
                else if (string.Compare("RemoveWhenExpired", propName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    removeWhenExpired = reader.ReadValueAsBool();
                }
                else if (string.Compare("SourceUtcTimestamp", propName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    sourceUtcTimestamp = reader.ReadValueAsDateTime();
                }
                else
                {
                    reader.SkipPropertyValue();
                }
            }while (reader.TokenType != JsonToken.EndObject);

            return(new StatelessReplicaHealthReportExpiredEvent(
                       eventInstanceId: eventInstanceId,
                       category: category,
                       timeStamp: timeStamp,
                       hasCorrelatedEvents: hasCorrelatedEvents,
                       partitionId: partitionId,
                       replicaId: replicaId,
                       sourceId: sourceId,
                       property: property,
                       healthState: healthState,
                       timeToLiveMs: timeToLiveMs,
                       sequenceNumber: sequenceNumber,
                       description: description,
                       removeWhenExpired: removeWhenExpired,
                       sourceUtcTimestamp: sourceUtcTimestamp));
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Gets the object from Json properties.
        /// </summary>
        /// <param name="reader">The <see cref="T: Newtonsoft.Json.JsonReader" /> to read from, reader must be placed at first property.</param>
        /// <returns>The object Value.</returns>
        internal static ChaosRestartReplicaFaultScheduledEvent GetFromJsonProperties(JsonReader reader)
        {
            var eventInstanceId     = default(Guid?);
            var timeStamp           = default(DateTime?);
            var hasCorrelatedEvents = default(bool?);
            var partitionId         = default(PartitionId);
            var replicaId           = default(ReplicaId);
            var faultGroupId        = default(Guid?);
            var faultId             = default(Guid?);
            var serviceUri          = default(string);

            do
            {
                var propName = reader.ReadPropertyName();
                if (string.Compare("EventInstanceId", propName, StringComparison.Ordinal) == 0)
                {
                    eventInstanceId = reader.ReadValueAsGuid();
                }
                else if (string.Compare("TimeStamp", propName, StringComparison.Ordinal) == 0)
                {
                    timeStamp = reader.ReadValueAsDateTime();
                }
                else if (string.Compare("HasCorrelatedEvents", propName, StringComparison.Ordinal) == 0)
                {
                    hasCorrelatedEvents = reader.ReadValueAsBool();
                }
                else if (string.Compare("PartitionId", propName, StringComparison.Ordinal) == 0)
                {
                    partitionId = PartitionIdConverter.Deserialize(reader);
                }
                else if (string.Compare("ReplicaId", propName, StringComparison.Ordinal) == 0)
                {
                    replicaId = ReplicaIdConverter.Deserialize(reader);
                }
                else if (string.Compare("FaultGroupId", propName, StringComparison.Ordinal) == 0)
                {
                    faultGroupId = reader.ReadValueAsGuid();
                }
                else if (string.Compare("FaultId", propName, StringComparison.Ordinal) == 0)
                {
                    faultId = reader.ReadValueAsGuid();
                }
                else if (string.Compare("ServiceUri", propName, StringComparison.Ordinal) == 0)
                {
                    serviceUri = reader.ReadValueAsString();
                }
                else
                {
                    reader.SkipPropertyValue();
                }
            }while (reader.TokenType != JsonToken.EndObject);

            return(new ChaosRestartReplicaFaultScheduledEvent(
                       eventInstanceId: eventInstanceId,
                       timeStamp: timeStamp,
                       hasCorrelatedEvents: hasCorrelatedEvents,
                       partitionId: partitionId,
                       replicaId: replicaId,
                       faultGroupId: faultGroupId,
                       faultId: faultId,
                       serviceUri: serviceUri));
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Gets the object from Json properties.
        /// </summary>
        /// <param name="reader">The <see cref="T: Newtonsoft.Json.JsonReader" /> to read from, reader must be placed at first property.</param>
        /// <returns>The object Value.</returns>
        internal static DeployedStatefulServiceReplicaInfo GetFromJsonProperties(JsonReader reader)
        {
            var serviceName                = default(ServiceName);
            var serviceTypeName            = default(string);
            var serviceManifestName        = default(string);
            var codePackageName            = default(string);
            var partitionId                = default(PartitionId);
            var replicaStatus              = default(ReplicaStatus?);
            var address                    = default(string);
            var servicePackageActivationId = default(string);
            var hostProcessId              = default(string);
            var replicaId                  = default(ReplicaId);
            var replicaRole                = default(ReplicaRole?);
            var reconfigurationInformation = default(ReconfigurationInformation);

            do
            {
                var propName = reader.ReadPropertyName();
                if (string.Compare("ServiceName", propName, StringComparison.Ordinal) == 0)
                {
                    serviceName = ServiceNameConverter.Deserialize(reader);
                }
                else if (string.Compare("ServiceTypeName", propName, StringComparison.Ordinal) == 0)
                {
                    serviceTypeName = reader.ReadValueAsString();
                }
                else if (string.Compare("ServiceManifestName", propName, StringComparison.Ordinal) == 0)
                {
                    serviceManifestName = reader.ReadValueAsString();
                }
                else if (string.Compare("CodePackageName", propName, StringComparison.Ordinal) == 0)
                {
                    codePackageName = reader.ReadValueAsString();
                }
                else if (string.Compare("PartitionId", propName, StringComparison.Ordinal) == 0)
                {
                    partitionId = PartitionIdConverter.Deserialize(reader);
                }
                else if (string.Compare("ReplicaStatus", propName, StringComparison.Ordinal) == 0)
                {
                    replicaStatus = ReplicaStatusConverter.Deserialize(reader);
                }
                else if (string.Compare("Address", propName, StringComparison.Ordinal) == 0)
                {
                    address = reader.ReadValueAsString();
                }
                else if (string.Compare("ServicePackageActivationId", propName, StringComparison.Ordinal) == 0)
                {
                    servicePackageActivationId = reader.ReadValueAsString();
                }
                else if (string.Compare("HostProcessId", propName, StringComparison.Ordinal) == 0)
                {
                    hostProcessId = reader.ReadValueAsString();
                }
                else if (string.Compare("ReplicaId", propName, StringComparison.Ordinal) == 0)
                {
                    replicaId = ReplicaIdConverter.Deserialize(reader);
                }
                else if (string.Compare("ReplicaRole", propName, StringComparison.Ordinal) == 0)
                {
                    replicaRole = ReplicaRoleConverter.Deserialize(reader);
                }
                else if (string.Compare("ReconfigurationInformation", propName, StringComparison.Ordinal) == 0)
                {
                    reconfigurationInformation = ReconfigurationInformationConverter.Deserialize(reader);
                }
                else
                {
                    reader.SkipPropertyValue();
                }
            }while (reader.TokenType != JsonToken.EndObject);

            return(new DeployedStatefulServiceReplicaInfo(
                       serviceName: serviceName,
                       serviceTypeName: serviceTypeName,
                       serviceManifestName: serviceManifestName,
                       codePackageName: codePackageName,
                       partitionId: partitionId,
                       replicaStatus: replicaStatus,
                       address: address,
                       servicePackageActivationId: servicePackageActivationId,
                       hostProcessId: hostProcessId,
                       replicaId: replicaId,
                       replicaRole: replicaRole,
                       reconfigurationInformation: reconfigurationInformation));
        }
        /// <summary>
        /// Gets the object from Json properties.
        /// </summary>
        /// <param name="reader">The <see cref="T: Newtonsoft.Json.JsonReader" /> to read from.</param>
        /// <returns>The object Value.</returns>
        internal static ReplicaEvent GetFromJsonProperties(JsonReader reader)
        {
            var eventInstanceId     = default(Guid?);
            var category            = default(string);
            var timeStamp           = default(DateTime?);
            var hasCorrelatedEvents = default(bool?);
            var partitionId         = default(PartitionId);
            var replicaId           = default(ReplicaId);

            do
            {
                var propName = reader.ReadPropertyName();
                if (propName.Equals("Kind", StringComparison.OrdinalIgnoreCase))
                {
                    var propValue = reader.ReadValueAsString();

                    if (propValue.Equals("StatefulReplicaNewHealthReport", StringComparison.OrdinalIgnoreCase))
                    {
                        return(StatefulReplicaNewHealthReportEventConverter.GetFromJsonProperties(reader));
                    }
                    else if (propValue.Equals("StatefulReplicaHealthReportExpired", StringComparison.OrdinalIgnoreCase))
                    {
                        return(StatefulReplicaHealthReportExpiredEventConverter.GetFromJsonProperties(reader));
                    }
                    else if (propValue.Equals("StatelessReplicaNewHealthReport", StringComparison.OrdinalIgnoreCase))
                    {
                        return(StatelessReplicaNewHealthReportEventConverter.GetFromJsonProperties(reader));
                    }
                    else if (propValue.Equals("StatelessReplicaHealthReportExpired", StringComparison.OrdinalIgnoreCase))
                    {
                        return(StatelessReplicaHealthReportExpiredEventConverter.GetFromJsonProperties(reader));
                    }
                    else if (propValue.Equals("ChaosReplicaRemovalScheduled", StringComparison.OrdinalIgnoreCase))
                    {
                        return(ChaosReplicaRemovalScheduledEventConverter.GetFromJsonProperties(reader));
                    }
                    else if (propValue.Equals("ChaosReplicaRestartScheduled", StringComparison.OrdinalIgnoreCase))
                    {
                        return(ChaosReplicaRestartScheduledEventConverter.GetFromJsonProperties(reader));
                    }
                    else if (propValue.Equals("ReplicaEvent", StringComparison.OrdinalIgnoreCase))
                    {
                        // kind specified as same type, deserialize using properties.
                    }
                    else
                    {
                        throw new InvalidOperationException("Unknown Discriminator.");
                    }
                }
                else
                {
                    if (string.Compare("EventInstanceId", propName, StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        eventInstanceId = reader.ReadValueAsGuid();
                    }
                    else if (string.Compare("Category", propName, StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        category = reader.ReadValueAsString();
                    }
                    else if (string.Compare("TimeStamp", propName, StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        timeStamp = reader.ReadValueAsDateTime();
                    }
                    else if (string.Compare("HasCorrelatedEvents", propName, StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        hasCorrelatedEvents = reader.ReadValueAsBool();
                    }
                    else if (string.Compare("PartitionId", propName, StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        partitionId = PartitionIdConverter.Deserialize(reader);
                    }
                    else if (string.Compare("ReplicaId", propName, StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        replicaId = ReplicaIdConverter.Deserialize(reader);
                    }
                    else
                    {
                        reader.SkipPropertyValue();
                    }
                }
            }while (reader.TokenType != JsonToken.EndObject);

            return(new ReplicaEvent(
                       kind: Common.FabricEventKind.ReplicaEvent,
                       eventInstanceId: eventInstanceId,
                       category: category,
                       timeStamp: timeStamp,
                       hasCorrelatedEvents: hasCorrelatedEvents,
                       partitionId: partitionId,
                       replicaId: replicaId));
        }
        /// <summary>
        /// Gets the object from Json properties.
        /// </summary>
        /// <param name="reader">The <see cref="T: Newtonsoft.Json.JsonReader" /> to read from, reader must be placed at first property.</param>
        /// <returns>The object Value.</returns>
        internal static RemoteReplicatorStatus GetFromJsonProperties(JsonReader reader)
        {
            var replicaId = default(ReplicaId);
            var lastAcknowledgementProcessedTimeUtc   = default(DateTime?);
            var lastReceivedReplicationSequenceNumber = default(string);
            var lastAppliedReplicationSequenceNumber  = default(string);
            var isInBuild = default(bool?);
            var lastReceivedCopySequenceNumber        = default(string);
            var lastAppliedCopySequenceNumber         = default(string);
            var remoteReplicatorAcknowledgementStatus = default(RemoteReplicatorAcknowledgementStatus);

            do
            {
                var propName = reader.ReadPropertyName();
                if (string.Compare("ReplicaId", propName, StringComparison.Ordinal) == 0)
                {
                    replicaId = ReplicaIdConverter.Deserialize(reader);
                }
                else if (string.Compare("LastAcknowledgementProcessedTimeUtc", propName, StringComparison.Ordinal) == 0)
                {
                    lastAcknowledgementProcessedTimeUtc = reader.ReadValueAsDateTime();
                }
                else if (string.Compare("LastReceivedReplicationSequenceNumber", propName, StringComparison.Ordinal) == 0)
                {
                    lastReceivedReplicationSequenceNumber = reader.ReadValueAsString();
                }
                else if (string.Compare("LastAppliedReplicationSequenceNumber", propName, StringComparison.Ordinal) == 0)
                {
                    lastAppliedReplicationSequenceNumber = reader.ReadValueAsString();
                }
                else if (string.Compare("IsInBuild", propName, StringComparison.Ordinal) == 0)
                {
                    isInBuild = reader.ReadValueAsBool();
                }
                else if (string.Compare("LastReceivedCopySequenceNumber", propName, StringComparison.Ordinal) == 0)
                {
                    lastReceivedCopySequenceNumber = reader.ReadValueAsString();
                }
                else if (string.Compare("LastAppliedCopySequenceNumber", propName, StringComparison.Ordinal) == 0)
                {
                    lastAppliedCopySequenceNumber = reader.ReadValueAsString();
                }
                else if (string.Compare("RemoteReplicatorAcknowledgementStatus", propName, StringComparison.Ordinal) == 0)
                {
                    remoteReplicatorAcknowledgementStatus = RemoteReplicatorAcknowledgementStatusConverter.Deserialize(reader);
                }
                else
                {
                    reader.SkipPropertyValue();
                }
            }while (reader.TokenType != JsonToken.EndObject);

            return(new RemoteReplicatorStatus(
                       replicaId: replicaId,
                       lastAcknowledgementProcessedTimeUtc: lastAcknowledgementProcessedTimeUtc,
                       lastReceivedReplicationSequenceNumber: lastReceivedReplicationSequenceNumber,
                       lastAppliedReplicationSequenceNumber: lastAppliedReplicationSequenceNumber,
                       isInBuild: isInBuild,
                       lastReceivedCopySequenceNumber: lastReceivedCopySequenceNumber,
                       lastAppliedCopySequenceNumber: lastAppliedCopySequenceNumber,
                       remoteReplicatorAcknowledgementStatus: remoteReplicatorAcknowledgementStatus));
        }