TransferStatistics
using Relativity.Transfer.Job;
using System;
using System.Globalization;
using System.Text;
namespace Relativity.Transfer
{
public sealed class TransferStatistics : ITransferStatistics
{
private static readonly object SyncRoot = new object();
private readonly ITransferRequest transferRequest;
private double averageTransferRateMbps;
private bool jobError;
private long jobErrorCode;
private string jobErrorMessage;
private DateTime? endTime;
private DateTime? preCalcEndTime;
private DateTime? preCalcStartTime;
private double progress;
private int order;
private TimeSpan remainingTime;
private int retryCount;
private DateTime? startTime;
private Guid statisticsId;
private double transferRateMbps;
private double transferTimeSeconds;
private long totalBadPathErrors;
private long totalFailedFiles;
private long totalFatalErrors;
private long totalFilePermissionErrors;
private long totalFilesNotFound;
private long totalRequestBytes;
private long totalRequestFiles;
private long totalSkippedFiles;
private long totalTransferredBytes;
private long totalTransferredFiles;
private long totalFilesIdentifiedAsMalware;
public double AverageTransferRateMbps {
get {
lock (SyncRoot) {
return averageTransferRateMbps;
}
}
set {
lock (SyncRoot) {
averageTransferRateMbps = value;
}
}
}
public DateTime? EndTime {
get {
lock (SyncRoot) {
return endTime;
}
}
set {
lock (SyncRoot) {
endTime = value;
}
}
}
public Guid Id {
get {
lock (SyncRoot) {
return statisticsId;
}
}
set {
lock (SyncRoot) {
statisticsId = value;
}
}
}
public bool JobError {
get {
lock (SyncRoot) {
return jobError;
}
}
set {
lock (SyncRoot) {
jobError = value;
}
}
}
public long JobErrorCode {
get {
lock (SyncRoot) {
return jobErrorCode;
}
}
set {
lock (SyncRoot) {
jobErrorCode = value;
}
}
}
public string JobErrorMessage {
get {
lock (SyncRoot) {
return jobErrorMessage;
}
}
set {
lock (SyncRoot) {
jobErrorMessage = value;
}
}
}
public int Order {
get {
lock (SyncRoot) {
return order;
}
}
set {
lock (SyncRoot) {
order = value;
}
}
}
public DateTime? PreCalcEndTime {
get {
lock (SyncRoot) {
return preCalcEndTime;
}
}
set {
lock (SyncRoot) {
preCalcEndTime = value;
}
}
}
public DateTime? PreCalcStartTime {
get {
lock (SyncRoot) {
return preCalcStartTime;
}
}
set {
lock (SyncRoot) {
preCalcStartTime = value;
}
}
}
public double Progress {
get {
lock (SyncRoot) {
return progress;
}
}
set {
lock (SyncRoot) {
progress = value;
}
}
}
public TimeSpan RemainingTime {
get {
lock (SyncRoot) {
return remainingTime;
}
}
set {
lock (SyncRoot) {
remainingTime = value;
}
}
}
public ITransferRequest Request {
get {
lock (SyncRoot) {
return transferRequest;
}
}
}
public int RetryAttempt {
get {
lock (SyncRoot) {
return retryCount;
}
}
set {
lock (SyncRoot) {
retryCount = value;
}
}
}
public DateTime? StartTime {
get {
lock (SyncRoot) {
return startTime;
}
}
set {
lock (SyncRoot) {
startTime = value;
}
}
}
public long TotalBadPathErrors {
get {
lock (SyncRoot) {
return totalBadPathErrors;
}
}
set {
lock (SyncRoot) {
totalBadPathErrors = value;
}
}
}
public long TotalFailedFiles {
get {
lock (SyncRoot) {
return totalFailedFiles;
}
}
set {
lock (SyncRoot) {
totalFailedFiles = value;
}
}
}
public long TotalFilesNotFound {
get {
lock (SyncRoot) {
return totalFilesNotFound;
}
}
set {
lock (SyncRoot) {
totalFilesNotFound = value;
}
}
}
public long TotalFatalErrors {
get {
lock (SyncRoot) {
return totalFatalErrors;
}
}
set {
lock (SyncRoot) {
totalFatalErrors = value;
}
}
}
public long TotalFilePermissionsErrors {
get {
lock (SyncRoot) {
return totalFilePermissionErrors;
}
}
set {
lock (SyncRoot) {
totalFilePermissionErrors = value;
}
}
}
public long TotalFilesIdentifiedAsMalware {
get {
lock (SyncRoot) {
return totalFilesIdentifiedAsMalware;
}
}
set {
lock (SyncRoot) {
totalFilesIdentifiedAsMalware = value;
}
}
}
public long TotalRequestBytes {
get {
lock (SyncRoot) {
return totalRequestBytes;
}
}
set {
lock (SyncRoot) {
totalRequestBytes = value;
}
}
}
public long TotalRequestFiles {
get {
lock (SyncRoot) {
return totalRequestFiles;
}
}
set {
lock (SyncRoot) {
totalRequestFiles = value;
}
}
}
public long TotalSkippedFiles {
get {
lock (SyncRoot) {
return totalSkippedFiles;
}
}
set {
lock (SyncRoot) {
totalSkippedFiles = value;
}
}
}
public long TotalTransferredBytes {
get {
lock (SyncRoot) {
return totalTransferredBytes;
}
}
set {
lock (SyncRoot) {
totalTransferredBytes = value;
}
}
}
public long TotalTransferredFiles {
get {
lock (SyncRoot) {
return totalTransferredFiles;
}
}
set {
lock (SyncRoot) {
totalTransferredFiles = value;
}
}
}
public double TransferRateMbps {
get {
lock (SyncRoot) {
return transferRateMbps;
}
}
set {
lock (SyncRoot) {
transferRateMbps = value;
}
}
}
public double TransferTimeSeconds {
get {
lock (SyncRoot) {
return transferTimeSeconds;
}
}
set {
lock (SyncRoot) {
transferTimeSeconds = value;
}
}
}
public TransferStatistics(ITransferRequest request)
{
if (request == null)
throw new ArgumentNullException("request");
AverageTransferRateMbps = 0;
EndTime = null;
Id = Guid.NewGuid();
JobError = false;
JobErrorMessage = null;
JobErrorCode = 0;
PreCalcEndTime = null;
PreCalcStartTime = null;
RemainingTime = TimeSpan.Zero;
RetryAttempt = 0;
StartTime = null;
TotalFailedFiles = 0;
TotalFatalErrors = 0;
TotalFilesNotFound = 0;
TotalFilePermissionsErrors = 0;
TotalBadPathErrors = 0;
TotalRequestBytes = 0;
TotalRequestFiles = 0;
TotalSkippedFiles = 0;
TotalTransferredBytes = 0;
TotalTransferredFiles = 0;
transferRequest = request;
TransferTimeSeconds = 0;
transferRateMbps = 0;
}
public TransferStatistics(ITransferStatistics source)
{
if (source == null)
throw new ArgumentNullException("source");
AverageTransferRateMbps = source.AverageTransferRateMbps;
EndTime = source.EndTime;
Id = source.Id;
JobError = source.JobError;
JobErrorCode = source.JobErrorCode;
JobErrorMessage = source.JobErrorMessage;
PreCalcEndTime = source.PreCalcEndTime;
PreCalcStartTime = source.PreCalcStartTime;
RemainingTime = source.RemainingTime;
RetryAttempt = source.RetryAttempt;
StartTime = source.StartTime;
TotalFailedFiles = source.TotalFailedFiles;
TotalFatalErrors = source.TotalFatalErrors;
TotalFilesNotFound = source.TotalFilesNotFound;
TotalFilePermissionsErrors = source.TotalFilePermissionsErrors;
TotalBadPathErrors = source.TotalBadPathErrors;
TotalRequestBytes = source.TotalRequestBytes;
TotalRequestFiles = source.TotalRequestFiles;
TotalSkippedFiles = source.TotalSkippedFiles;
TotalTransferredBytes = source.TotalTransferredBytes;
TotalTransferredFiles = source.TotalTransferredFiles;
transferRequest = source.Request;
TransferTimeSeconds = source.TransferTimeSeconds;
}
public void Clear()
{
AverageTransferRateMbps = 0;
EndTime = null;
JobError = false;
JobErrorCode = 0;
JobErrorMessage = null;
PreCalcEndTime = null;
PreCalcStartTime = null;
RemainingTime = TimeSpan.Zero;
RetryAttempt = 0;
StartTime = null;
TotalFailedFiles = 0;
TotalFatalErrors = 0;
TotalFilesNotFound = 0;
TotalFilePermissionsErrors = 0;
TotalBadPathErrors = 0;
TotalRequestBytes = 0;
TotalRequestFiles = 0;
TotalSkippedFiles = 0;
TotalTransferredBytes = 0;
TotalTransferredFiles = 0;
TransferTimeSeconds = 0;
}
public ITransferStatistics DeepCopy()
{
return new TransferStatistics(this);
}
internal void AssignTotals(IStatisticsTotals totals)
{
TotalRequestBytes = totals.TotalRequestBytes;
TotalRequestFiles = totals.TotalRequestFiles;
TotalSkippedFiles = totals.TotalSkippedFiles;
TotalTransferredBytes = totals.TotalTransferredBytes;
TotalTransferredFiles = totals.TotalTransferredFiles;
TotalFilesNotFound = totals.TotalFilesNotFound;
TotalFilePermissionsErrors = totals.TotalFilePermissionErrors;
TotalBadPathErrors = totals.TotalBadPathErrors;
TotalFailedFiles = totals.TotalFailedFiles;
TotalFatalErrors = totals.TotalFatalErrors;
totalFilesIdentifiedAsMalware = totals.TotalFilesIdentifiedAsMalware;
}
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine("Transfer Statistics:");
stringBuilder.AppendLine($"""{Id}");
stringBuilder.AppendLine($"""{RetryAttempt}");
stringBuilder.AppendLine($"""{AverageTransferRateMbps}");
stringBuilder.AppendLine($"""{TransferTimeSeconds}");
stringBuilder.AppendLine($"""{RemainingTime}");
stringBuilder.AppendLine("StartTime = " + ValueOrDefault(StartTime, "[NULL]"));
stringBuilder.AppendLine("EndTime = " + ValueOrDefault(EndTime, "[NULL]"));
stringBuilder.AppendLine("PreCalcStartTime = " + ValueOrDefault(PreCalcStartTime, "[NULL]"));
stringBuilder.AppendLine("PreCalcEndTime = " + ValueOrDefault(PreCalcEndTime, "[NULL]"));
stringBuilder.AppendLine($"""{JobError}");
stringBuilder.AppendLine($"""{JobErrorCode}");
stringBuilder.AppendLine("JobErrorMessage = " + ValueOrDefault(JobErrorMessage, "[NULL]"));
stringBuilder.AppendLine($"""{TotalFatalErrors}");
stringBuilder.AppendLine($"""{TotalFilesIdentifiedAsMalware}");
stringBuilder.AppendLine($"""{TotalFilesNotFound}");
stringBuilder.AppendLine($"""{TotalFilePermissionsErrors}");
stringBuilder.AppendLine($"""{TotalBadPathErrors}");
stringBuilder.AppendLine($"""{TotalRequestBytes}");
stringBuilder.AppendLine($"""{TotalRequestFiles}");
stringBuilder.AppendLine($"""{TotalFailedFiles}");
stringBuilder.AppendLine($"""{TotalSkippedFiles}");
stringBuilder.AppendLine($"""{TotalTransferredBytes}");
stringBuilder.AppendLine($"""{TotalTransferredFiles}");
return stringBuilder.ToString();
}
private static string ValueOrDefault(DateTime? value, string default)
{
if (!value.HasValue)
return default;
return value.Value.ToString(CultureInfo.InvariantCulture);
}
private static string ValueOrDefault(string value, string default)
{
if (string.IsNullOrEmpty(value))
return default;
return value;
}
}
}