TransferResult
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
namespace Relativity.Transfer
{
public sealed class TransferResult : ITransferResult
{
private static readonly object SyncRoot = new object();
private readonly List<ITransferIssue> registeredTransferIssues = new List<ITransferIssue>();
private readonly List<ITransferStatistics> registeredStatistics = new List<ITransferStatistics>();
private ClientConfiguration clientConfiguration;
private int minDataRateMbps;
private int targetDataRateMbps;
private DateTime? startTime;
private DateTime? endTime;
private int issueIndex;
private TransferStatus status;
private ITransferRequest request;
private int retryCount;
private long totalFailedFiles;
private long totalFatalErrors;
private long totalFilesNotFound;
private long totalFilePermissionErrors;
private long totalBadPathErrors;
private long totalSkippedFiles;
private long totalTransferredBytes;
private long totalTransferredFiles;
[SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This is designed to support assignments.")]
public ClientConfiguration Configuration {
get {
lock (SyncRoot) {
return clientConfiguration;
}
}
set {
lock (SyncRoot) {
clientConfiguration = value;
}
}
}
public TimeSpan Elapsed {
get {
if (!EndTime.HasValue || !StartTime.HasValue)
return TimeSpan.FromSeconds(0);
return EndTime.Value - StartTime.Value;
}
}
public DateTime? EndTime {
get {
lock (SyncRoot) {
return endTime;
}
}
set {
lock (SyncRoot) {
endTime = value;
}
}
}
public IReadOnlyList<ITransferIssue> Issues {
get {
lock (SyncRoot) {
return new List<ITransferIssue>(registeredTransferIssues);
}
}
}
public int MinDataRateMbps {
get {
lock (SyncRoot) {
return minDataRateMbps;
}
}
set {
lock (SyncRoot) {
minDataRateMbps = value;
}
}
}
public ITransferRequest Request {
get {
lock (SyncRoot) {
return request;
}
}
set {
lock (SyncRoot) {
request = value;
}
}
}
public int RetryCount {
get {
lock (SyncRoot) {
return retryCount;
}
}
set {
lock (SyncRoot) {
retryCount = value;
}
}
}
public IReadOnlyList<ITransferStatistics> Statistics => registeredStatistics;
public TransferStatus Status {
get {
lock (SyncRoot) {
return status;
}
}
set {
lock (SyncRoot) {
status = value;
}
}
}
public DateTime? StartTime {
get {
lock (SyncRoot) {
return startTime;
}
}
set {
lock (SyncRoot) {
startTime = value;
}
}
}
public int TargetDataRateMbps {
get {
lock (SyncRoot) {
return targetDataRateMbps;
}
}
set {
lock (SyncRoot) {
targetDataRateMbps = value;
}
}
}
public long TotalFailedFiles {
get {
lock (SyncRoot) {
return totalFailedFiles;
}
}
set {
lock (SyncRoot) {
totalFailedFiles = value;
}
}
}
public long TotalFatalErrors {
get {
lock (SyncRoot) {
return totalFatalErrors;
}
}
set {
lock (SyncRoot) {
totalFatalErrors = value;
}
}
}
public long TotalFilesNotFound {
get {
lock (SyncRoot) {
return totalFilesNotFound;
}
}
set {
lock (SyncRoot) {
totalFilesNotFound = value;
}
}
}
public long TotalFilePermissionErrors {
get {
lock (SyncRoot) {
return totalFilePermissionErrors;
}
}
set {
lock (SyncRoot) {
totalFilePermissionErrors = value;
}
}
}
public long TotalBadPathErrors {
get {
lock (SyncRoot) {
return totalBadPathErrors;
}
}
set {
lock (SyncRoot) {
totalBadPathErrors = 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 ITransferIssue TransferError {
get {
lock (SyncRoot) {
if (registeredTransferIssues.Count != 0)
return registeredTransferIssues.OrderBy(delegate(ITransferIssue x) {
if (!x.Attributes.HasFlag(IssueAttributes.Error))
return 1;
return 0;
}).ThenBy((ITransferIssue y) => y.Attributes.HasFlag(IssueAttributes.File)).ThenBy((ITransferIssue z) => z.Index)
.FirstOrDefault((ITransferIssue x) => x.Attributes.HasFlag(IssueAttributes.Error));
return null;
}
}
}
public double TransferRateMbps {
get {
if (!EndTime.HasValue || !StartTime.HasValue)
return 0;
return TransferHelper.CalculateTransferRateMbps(TotalTransferredBytes, (EndTime.Value - StartTime.Value).TotalSeconds);
}
}
public TransferResult()
{
Configuration = null;
EndTime = null;
MinDataRateMbps = 0;
Request = null;
RetryCount = 0;
StartTime = null;
Status = TransferStatus.NotStarted;
TargetDataRateMbps = 0;
TotalFailedFiles = 0;
TotalFatalErrors = 0;
TotalFilesNotFound = 0;
TotalFilePermissionErrors = 0;
TotalBadPathErrors = 0;
TotalSkippedFiles = 0;
TotalTransferredBytes = 0;
TotalTransferredFiles = 0;
issueIndex = 0;
}
public void RegisterIssue(string message, IssueAttributes attributes)
{
RegisterIssue(message, null, attributes, null);
}
public void RegisterIssue(string message, TransferPath path, IssueAttributes attributes, int? code)
{
RegisterIssue(new TransferIssue {
Message = message,
Path = path,
Attributes = attributes,
Code = code
});
}
public void RegisterIssue(TransferIssue issue)
{
if (issue == (TransferIssue)null)
throw new ArgumentNullException("issue");
lock (SyncRoot) {
issueIndex++;
issue.Index = issueIndex;
registeredTransferIssues.Add(issue);
}
}
public void RegisterIssues(IEnumerable<ITransferIssue> issues)
{
if (issues == null)
throw new ArgumentNullException("issues");
lock (SyncRoot) {
foreach (ITransferIssue issue in issues) {
issueIndex++;
TransferIssue item = new TransferIssue(issue) {
Index = issueIndex
};
registeredTransferIssues.Add(item);
}
}
}
public void RegisterStatistics(ITransferStatistics statistics)
{
if (statistics == null)
throw new ArgumentNullException("statistics");
lock (SyncRoot) {
registeredStatistics.Add(statistics);
}
}
}
}