TransferContext
using System;
namespace Relativity.Transfer
{
public sealed class TransferContext
{
public const bool DefaultLargeFileProgressEnabled = false;
public const double DefaultLargeFileProgressRateSeconds = 5;
public const bool DefaultStatisticsEnabled = true;
public const double DefaultStatisticsRateSeconds = 2;
private static readonly object SyncRoot = new object();
private DateTime? startTime;
private DateTime? endTime;
private bool largeFileProgressEnabled;
private double largeFileProgressRateSeconds;
private bool statisticsEnabled;
private double statisticsRateSeconds;
private IssueAttributes? previouslyPublishedIssueErrorCode;
private IssueAttributes? PreviouslyPublishedIssueErrorCode {
get {
lock (SyncRoot) {
return previouslyPublishedIssueErrorCode;
}
}
set {
lock (SyncRoot) {
previouslyPublishedIssueErrorCode = value;
}
}
}
public DateTime? EndTime {
get {
lock (SyncRoot) {
return endTime;
}
}
internal set {
lock (SyncRoot) {
endTime = value;
}
}
}
public bool LargeFileProgressEnabled {
get {
lock (SyncRoot) {
return largeFileProgressEnabled;
}
}
set {
lock (SyncRoot) {
largeFileProgressEnabled = value;
}
}
}
public double LargeFileProgressRateSeconds {
get {
lock (SyncRoot) {
return largeFileProgressRateSeconds;
}
}
set {
lock (SyncRoot) {
largeFileProgressRateSeconds = value;
}
}
}
public DateTime? StartTime {
get {
lock (SyncRoot) {
return startTime;
}
}
internal set {
lock (SyncRoot) {
startTime = value;
}
}
}
public bool StatisticsEnabled {
get {
lock (SyncRoot) {
return statisticsEnabled;
}
}
set {
lock (SyncRoot) {
statisticsEnabled = value;
}
}
}
public double StatisticsRateSeconds {
get {
lock (SyncRoot) {
return statisticsRateSeconds;
}
}
set {
lock (SyncRoot) {
statisticsRateSeconds = value;
}
}
}
public event EventHandler<LargeFileProgressEventArgs> LargeFileProgress = delegate {
};
public event EventHandler<TransferPathProgressEventArgs> TransferPathProgress = delegate {
};
public event EventHandler<TransferPathIssueEventArgs> TransferPathIssue = delegate {
};
public event EventHandler<TransferPathIssueEventArgs> TransferJobIssue = delegate {
};
public event EventHandler<TransferJobRetryEventArgs> TransferJobRetry = delegate {
};
public event EventHandler<TransferRequestEventArgs> TransferRequest = delegate {
};
public event EventHandler<TransferStatisticsEventArgs> TransferStatistics = delegate {
};
public TransferContext()
{
EndTime = null;
LargeFileProgressEnabled = false;
LargeFileProgressRateSeconds = 5;
StartTime = null;
StatisticsEnabled = true;
StatisticsRateSeconds = 2;
}
public void PublishLargeFileProgress(LargeFileProgressEventArgs args)
{
if (LargeFileProgressEnabled)
this.LargeFileProgress(this, args);
}
public void PublishTransferPathProgress(ITransferRequest request, TransferPathResult result)
{
if (request == null)
throw new ArgumentNullException("request");
if (result == null)
throw new ArgumentNullException("result");
this.TransferPathProgress(this, new TransferPathProgressEventArgs(request, result.Path, result.TargetFile, result.Status, result.Completed, result.StartTime, result.EndTime, result.BytesTransferred, result.Checksum));
}
public void PublishTransferJobRetry(ITransferRequest request, int count, int maxAttempts)
{
this.TransferJobRetry(this, new TransferJobRetryEventArgs(request, count, maxAttempts));
PreviouslyPublishedIssueErrorCode = null;
}
public void PublishTransferJobIssue(ITransferRequest request, ITransferIssue issue)
{
if (!PreviouslyPublishedIssueErrorCode.HasValue || previouslyPublishedIssueErrorCode.Equals(IssueAttributes.None)) {
PreviouslyPublishedIssueErrorCode = issue.Attributes;
this.TransferJobIssue(this, new TransferPathIssueEventArgs(request, issue));
}
}
public void PublishTransferPathIssue(ITransferRequest request, ITransferIssue issue)
{
this.TransferPathIssue(this, new TransferPathIssueEventArgs(request, issue));
}
public void PublishTransferRequest(ITransferRequest request, TransferRequestStatus status)
{
switch (status) {
case TransferRequestStatus.Started:
StartTime = DateTime.Now;
EndTime = null;
break;
case TransferRequestStatus.Canceled:
case TransferRequestStatus.Ended:
case TransferRequestStatus.EndedMaxRetry:
EndTime = DateTime.Now;
break;
}
this.TransferRequest(this, new TransferRequestEventArgs(request, status));
}
public void PublishTransferStatistics(ITransferRequest request, ITransferStatistics statistics)
{
if (StatisticsEnabled)
this.TransferStatistics(this, new TransferStatisticsEventArgs(request, statistics));
}
internal void Clear(bool retry)
{
EndTime = null;
if (!retry)
StartTime = null;
}
}
}