ImportTapiBase
Represents the base-class object for all TAPI-based import and export instances.
using kCura.WinEDDS.Helpers;
using kCura.WinEDDS.Service;
using kCura.WinEDDS.Service.Kepler;
using Microsoft.VisualBasic.CompilerServices;
using Monitoring;
using My.Resources;
using Polly;
using Polly.Retry;
using Relativity.DataExchange;
using Relativity.DataExchange.Io;
using Relativity.DataExchange.Process;
using Relativity.DataExchange.Service;
using Relativity.DataExchange.Transfer;
using Relativity.Logging;
using Relativity.Transfer;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.Runtime.CompilerServices;
using System.Threading;
namespace kCura.WinEDDS
{
public abstract class ImportTapiBase
{
public delegate void UploadModeChangeEventEventHandler (string statusBarText);
internal delegate void BatchCompletedEventHandler (BatchInformation batchInformation);
[CompilerGenerated]
internal sealed class _Closure$__104-0
{
public int $VB$Local_currentRetryAttempt;
public int $VB$Local_maxRetryAttempts;
public _Closure$__104-1 $VB$NonLocal_$VB$Closure_2;
internal TimeSpan _Lambda$__0(int count)
{
$VB$Local_currentRetryAttempt = count;
return TimeSpan.FromSeconds((double)AppSettings.Instance.IoErrorWaitTimeInSeconds);
}
internal void _Lambda$__1(Exception exception, TimeSpan span)
{
$VB$NonLocal_$VB$Closure_2.$VB$Me.PublishIoRetryMessage(exception, span, $VB$Local_currentRetryAttempt, $VB$Local_maxRetryAttempts);
}
}
[CompilerGenerated]
internal sealed class _Closure$__104-1
{
public string $VB$Local_path;
public ImportTapiBase $VB$Me;
internal string _Lambda$__2(CancellationToken token)
{
return $VB$Me._filePathHelper.GetExistingFilePath($VB$Local_path);
}
}
[CompilerGenerated]
internal sealed class _Closure$__146-0
{
public int $VB$Local_waitBetweenRetriesMilliseconds;
public bool $VB$Local_waitSuccess;
public Func<bool> $VB$Local_retryFunction;
internal TimeSpan _Lambda$__0(int count)
{
return TimeSpan.FromMilliseconds((double)$VB$Local_waitBetweenRetriesMilliseconds);
}
internal bool _Lambda$__R1(CancellationToken a0)
{
return _Lambda$__1();
}
internal bool _Lambda$__1()
{
$VB$Local_waitSuccess = $VB$Local_retryFunction();
return $VB$Local_waitSuccess;
}
}
private const int _fileCheckRetryCount = 6000;
private const int _fileCheckWaitBetweenRetriesMilliseconds = 10;
private readonly IIoReporter _ioReporter;
private readonly object _syncRoot;
private readonly IFileSystem _fileSystem;
private readonly CancellationTokenSource _cancellationTokenSource;
private readonly ImportStatistics _statistics;
[CompilerGenerated]
[AccessedThroughProperty("_bulkLoadTapiBridge")]
private UploadTapiBridge2 __bulkLoadTapiBridge;
[CompilerGenerated]
[AccessedThroughProperty("_fileTapiBridge")]
private UploadTapiBridge2 __fileTapiBridge;
private TapiClient _bulkLoadTapiClient;
private string _bulkLoadTapiClientName;
private TapiClient _fileTapiClient;
private string _fileTapiClientName;
private DateTime _statisticsLastUpdated;
private int _batchFileTapiProgressCount;
protected readonly ILog _logger;
private readonly IFilePathHelper _filePathHelper;
private IWaitAndRetryPolicy _waitAndRetryPolicy;
protected Func<string> CorrelationIdFunc;
[CompilerGenerated]
private UploadModeChangeEventEventHandler UploadModeChangeEventEvent;
[CompilerGenerated]
private BatchCompletedEventHandler BatchCompletedEvent;
[CompilerGenerated]
private IDictionary _CurrentStatisticsSnapshot;
[CompilerGenerated]
private int _JobCounter;
[CompilerGenerated]
private bool _DisableNativeLocationValidation;
private int _fileTapiProgressCount;
private int _totalTransferredFilesCount;
[CompilerGenerated]
private bool _ShouldImport;
[CompilerGenerated]
private int _ImportFilesCount;
[CompilerGenerated]
private int _MetadataFilesCount;
[CompilerGenerated]
private RetryOptions _RetryOptions;
[field: AccessedThroughProperty("_bulkLoadTapiBridge")]
private virtual UploadTapiBridge2 _bulkLoadTapiBridge {
get;
[MethodImpl(MethodImplOptions.Synchronized)]
set;
}
[field: AccessedThroughProperty("_fileTapiBridge")]
private virtual UploadTapiBridge2 _fileTapiBridge {
get;
[MethodImpl(MethodImplOptions.Synchronized)]
set;
}
public ImportStatistics Statistics => _statistics;
protected abstract int CurrentLineNumber { get; }
protected UploadTapiBridge2 BulkLoadTapiBridge => _bulkLoadTapiBridge;
protected TapiClient BulkLoadTapiClient => _bulkLoadTapiClient;
protected string BulkLoadTapiClientName => _bulkLoadTapiClientName;
protected CancellationToken CancellationToken => _cancellationTokenSource.Token;
protected IDictionary CurrentStatisticsSnapshot { get; set; }
protected int JobCounter { get; set; }
protected ILog Logger => _logger;
protected UploadTapiBridge2 FileTapiBridge => _fileTapiBridge;
protected TapiClient FileTapiClient => _fileTapiClient;
protected string FileTapiClientName => _fileTapiClientName;
public string TapiClientName {
get {
object obj = FileTapiClientName ?? BulkLoadTapiClientName;
if (obj == null)
obj = ((Enum)0).ToString();
return (string)obj;
}
}
public TapiClient TapiClient {
get {
if (FileTapiClient == TapiClient.None) {
if (BulkLoadTapiClient == TapiClient.None)
return TapiClient.None;
return BulkLoadTapiClient;
}
return FileTapiClient;
}
}
public bool DisableNativeLocationValidation { get; set; }
public int FileTapiProgressCount {
get {
return _fileTapiProgressCount;
}
protected set {
_fileTapiProgressCount = value;
}
}
public int TotalTransferredFilesCount {
get {
return _totalTransferredFilesCount;
}
protected set {
_totalTransferredFilesCount = value;
}
}
protected bool ShouldImport { get; set; }
protected int ImportFilesCount { get; set; }
protected int MetadataFilesCount { get; set; }
protected RetryOptions RetryOptions { get; }
protected IFileSystem FileSystem => _fileSystem;
public event UploadModeChangeEventEventHandler UploadModeChangeEvent {
[CompilerGenerated]
add {
UploadModeChangeEventEventHandler uploadModeChangeEventEventHandler = UploadModeChangeEventEvent;
UploadModeChangeEventEventHandler uploadModeChangeEventEventHandler2;
do {
uploadModeChangeEventEventHandler2 = uploadModeChangeEventEventHandler;
UploadModeChangeEventEventHandler value2 = (UploadModeChangeEventEventHandler)Delegate.Combine(uploadModeChangeEventEventHandler2, value);
uploadModeChangeEventEventHandler = Interlocked.CompareExchange(ref UploadModeChangeEventEvent, value2, uploadModeChangeEventEventHandler2);
} while ((object)uploadModeChangeEventEventHandler != uploadModeChangeEventEventHandler2);
}
[CompilerGenerated]
remove {
UploadModeChangeEventEventHandler uploadModeChangeEventEventHandler = UploadModeChangeEventEvent;
UploadModeChangeEventEventHandler uploadModeChangeEventEventHandler2;
do {
uploadModeChangeEventEventHandler2 = uploadModeChangeEventEventHandler;
UploadModeChangeEventEventHandler value2 = (UploadModeChangeEventEventHandler)Delegate.Remove(uploadModeChangeEventEventHandler2, value);
uploadModeChangeEventEventHandler = Interlocked.CompareExchange(ref UploadModeChangeEventEvent, value2, uploadModeChangeEventEventHandler2);
} while ((object)uploadModeChangeEventEventHandler != uploadModeChangeEventEventHandler2);
}
}
internal event BatchCompletedEventHandler BatchCompleted {
[CompilerGenerated]
add {
BatchCompletedEventHandler batchCompletedEventHandler = BatchCompletedEvent;
BatchCompletedEventHandler batchCompletedEventHandler2;
do {
batchCompletedEventHandler2 = batchCompletedEventHandler;
BatchCompletedEventHandler value2 = (BatchCompletedEventHandler)Delegate.Combine(batchCompletedEventHandler2, value);
batchCompletedEventHandler = Interlocked.CompareExchange(ref BatchCompletedEvent, value2, batchCompletedEventHandler2);
} while ((object)batchCompletedEventHandler != batchCompletedEventHandler2);
}
[CompilerGenerated]
remove {
BatchCompletedEventHandler batchCompletedEventHandler = BatchCompletedEvent;
BatchCompletedEventHandler batchCompletedEventHandler2;
do {
batchCompletedEventHandler2 = batchCompletedEventHandler;
BatchCompletedEventHandler value2 = (BatchCompletedEventHandler)Delegate.Remove(batchCompletedEventHandler2, value);
batchCompletedEventHandler = Interlocked.CompareExchange(ref BatchCompletedEvent, value2, batchCompletedEventHandler2);
} while ((object)batchCompletedEventHandler != batchCompletedEventHandler2);
}
}
public ImportTapiBase(IIoReporter reporter, ILog logger, CancellationTokenSource cancellationTokenSource, Func<string> correlationIdFunc)
{
_syncRoot = RuntimeHelpers.GetObjectValue(new object());
_statistics = new ImportStatistics();
_bulkLoadTapiClient = TapiClient.None;
_fileTapiClient = TapiClient.None;
_statisticsLastUpdated = DateTime.Now;
_batchFileTapiProgressCount = 0;
_filePathHelper = new ConfigurableFilePathHelper();
DisableNativeLocationValidation = AppSettings.Instance.DisableThrowOnIllegalCharacters;
ImportFilesCount = 0;
MetadataFilesCount = 0;
_RetryOptions = AppSettings.Instance.RetryOptions;
_fileSystem = global::Relativity.DataExchange.Io.FileSystem.Instance.DeepCopy();
if (reporter == null)
reporter = new NullIoReporter(_fileSystem);
if (logger == null)
throw new ArgumentNullException("logger");
if (cancellationTokenSource == null)
cancellationTokenSource = new CancellationTokenSource();
_logger = logger;
_cancellationTokenSource = cancellationTokenSource;
_ioReporter = reporter;
CorrelationIdFunc = correlationIdFunc;
}
protected virtual void OnBatchCompleted(BatchInformation batchInformation)
{
BatchCompletedEvent?.Invoke(batchInformation);
}
protected static bool IsTimeoutException(Exception ex)
{
if (!(ex is BulkImportManager.BulkImportSqlTimeoutException)) {
if (ex is Exception && ((ex.InnerException != null) & (ex.InnerException is OperationCanceledException)))
return true;
WebException ex2 = ex as WebException;
return ex2 != null && ex2.Status == WebExceptionStatus.Timeout;
}
return true;
}
protected static bool IsBulkImportSqlException(Exception ex)
{
return ex.GetType() == typeof(BulkImportManager.BulkImportSqlException);
}
protected static bool IsInsufficientPermissionsForImportException(Exception ex)
{
return ex.GetType() == typeof(BulkImportManager.InsufficientPermissionsForImportException);
}
protected void CopyFile(string sourceFileName, string destFileName)
{
CopyFile(sourceFileName, destFileName, false);
}
protected IWaitAndRetryPolicy CreateWaitAndRetryPolicy()
{
if (_waitAndRetryPolicy == null)
_waitAndRetryPolicy = new WaitAndRetryPolicy(AppSettings.Instance);
return _waitAndRetryPolicy;
}
protected void CopyFile(string sourceFileName, string destFileName, bool overwrite)
{
_ioReporter.CopyFile(sourceFileName, destFileName, overwrite, CurrentLineNumber);
}
protected string GetExistingFilePath(string path, bool retry)
{
_Closure$__104-1 closure$__104- = new _Closure$__104-1();
closure$__104-.$VB$Me = this;
closure$__104-.$VB$Local_path = path;
if (retry) {
_Closure$__104-0 closure$__104-2;
closure$__104-2.$VB$NonLocal_$VB$Closure_2 = closure$__104-;
closure$__104-2.$VB$Local_maxRetryAttempts = AppSettings.Instance.IoErrorNumberOfRetries;
closure$__104-2.$VB$Local_currentRetryAttempt = 0;
return CreateWaitAndRetryPolicy().WaitAndRetry(RetryExceptionHelper.CreateRetryPredicate(RetryOptions), delegate(int count) {
closure$__104-2.$VB$Local_currentRetryAttempt = count;
return TimeSpan.FromSeconds((double)AppSettings.Instance.IoErrorWaitTimeInSeconds);
}, delegate(Exception exception, TimeSpan span) {
closure$__104-2.$VB$NonLocal_$VB$Closure_2.$VB$Me.PublishIoRetryMessage(exception, span, closure$__104-2.$VB$Local_currentRetryAttempt, closure$__104-2.$VB$Local_maxRetryAttempts);
}, (CancellationToken token) => closure$__104-2.$VB$NonLocal_$VB$Closure_2.$VB$Me._filePathHelper.GetExistingFilePath(closure$__104-2.$VB$NonLocal_$VB$Closure_2.$VB$Local_path), CancellationToken);
}
return _filePathHelper.GetExistingFilePath(closure$__104-.$VB$Local_path);
}
protected bool GetFileExists(string path)
{
return _ioReporter.GetFileExists(path, CurrentLineNumber);
}
protected long GetFileLength(string path, bool retry)
{
if (retry)
return _ioReporter.GetFileLength(path, CurrentLineNumber);
return _fileSystem.CreateFileInfo(path).Length;
}
protected void PublishIoRetryMessage(Exception exception, TimeSpan timeSpan, int retryCount, int totalRetryCount)
{
_ioReporter.PublishRetryMessage(exception, timeSpan, retryCount, totalRetryCount, CurrentLineNumber);
}
protected void PublishIoWarningEvent(IoWarningEventArgs args)
{
_ioReporter.PublishWarningMessage(args);
}
protected void CreateTapiBridges(UploadTapiBridgeParameters2 fileParameters, UploadTapiBridgeParameters2 bulkLoadParameters, IAuthenticationTokenProvider authTokenProvider, IRelativityManagerServiceFactory managerServiceFactory)
{
_fileTapiBridge = TapiBridgeFactory.CreateUploadBridge(fileParameters, Logger, authTokenProvider, CancellationToken, CorrelationIdFunc, new WebApiVsKeplerFactory(Logger), managerServiceFactory);
_fileTapiBridge.TapiClientChanged += FileOnTapiClientChanged;
_fileTapiBridge.TapiFatalError += OnTapiFatalError;
_fileTapiBridge.TapiProgress += FileOnTapiProgress;
_fileTapiBridge.TapiStatistics += FileOnTapiStatistics;
_fileTapiBridge.TapiStatusMessage += OnTapiStatusEvent;
_fileTapiBridge.TapiErrorMessage += OnTapiErrorMessage;
_fileTapiBridge.TapiWarningMessage += OnTapiWarningMessage;
_bulkLoadTapiBridge = TapiBridgeFactory.CreateUploadBridge(bulkLoadParameters, Logger, authTokenProvider, CancellationToken, CorrelationIdFunc, new WebApiVsKeplerFactory(Logger), managerServiceFactory);
_bulkLoadTapiBridge.TargetPath = bulkLoadParameters.FileShare;
_bulkLoadTapiBridge.TapiClientChanged += BulkLoadOnTapiClientChanged;
_bulkLoadTapiBridge.TapiStatistics += BulkLoadOnTapiStatistics;
_bulkLoadTapiBridge.TapiFatalError += OnTapiFatalError;
_bulkLoadTapiBridge.TapiStatusMessage += OnTapiStatusEvent;
_bulkLoadTapiBridge.TapiErrorMessage += OnTapiErrorMessage;
_bulkLoadTapiBridge.TapiWarningMessage += OnTapiWarningMessage;
_bulkLoadTapiBridge.TapiProgress += BulkLoadOnTapiProgress;
LogInformation("Begin dumping native parameters.");
_fileTapiBridge.LogTransferParameters();
LogInformation("Begin dumping bcp parameters.");
_bulkLoadTapiBridge.LogTransferParameters();
}
protected void DestroyTapiBridges()
{
if (_fileTapiBridge != null) {
_fileTapiBridge.TapiClientChanged -= FileOnTapiClientChanged;
_fileTapiBridge.TapiFatalError -= OnTapiFatalError;
_fileTapiBridge.TapiProgress -= FileOnTapiProgress;
_fileTapiBridge.TapiStatistics -= FileOnTapiStatistics;
_fileTapiBridge.TapiStatusMessage -= OnTapiStatusEvent;
_fileTapiBridge.TapiErrorMessage -= OnTapiErrorMessage;
_fileTapiBridge.TapiWarningMessage -= OnTapiWarningMessage;
_fileTapiBridge.Dispose();
_fileTapiBridge = null;
}
if (_bulkLoadTapiBridge != null) {
_bulkLoadTapiBridge.TapiClientChanged -= BulkLoadOnTapiClientChanged;
_bulkLoadTapiBridge.TapiStatistics -= BulkLoadOnTapiStatistics;
_bulkLoadTapiBridge.TapiFatalError -= OnTapiFatalError;
_bulkLoadTapiBridge.TapiStatusMessage -= OnTapiStatusEvent;
_bulkLoadTapiBridge.TapiErrorMessage -= OnTapiErrorMessage;
_bulkLoadTapiBridge.TapiWarningMessage -= OnTapiWarningMessage;
_bulkLoadTapiBridge.TapiProgress -= BulkLoadOnTapiProgress;
_bulkLoadTapiBridge.Dispose();
_bulkLoadTapiBridge = null;
}
}
protected void LogStatistics()
{
IDictionary<string, object> dictionary = _statistics.ToDictionaryForLogs();
LogInformation("Import statistics: {@Statistics}", dictionary);
}
protected void LogInformation(Exception exception, string messageTemplate, params object[] propertyValues)
{
_logger.LogInformation(exception, messageTemplate, propertyValues);
}
protected void LogInformation(string messageTemplate, params object[] propertyValues)
{
_logger.LogInformation(messageTemplate, propertyValues);
}
protected void LogError(Exception exception, string messageTemplate, params object[] propertyValues)
{
_logger.LogError(exception, messageTemplate, propertyValues);
}
protected void LogError(string messageTemplate, params object[] propertyValues)
{
_logger.LogError(messageTemplate, propertyValues);
}
protected void LogFatal(Exception exception, string messageTemplate, params object[] propertyValues)
{
_logger.LogFatal(exception, messageTemplate, propertyValues);
}
protected void LogFatal(string messageTemplate, params object[] propertyValues)
{
_logger.LogFatal(messageTemplate, propertyValues);
}
protected void LogWarning(Exception exception, string messageTemplate, params object[] propertyValues)
{
_logger.LogWarning(exception, messageTemplate, propertyValues);
}
protected void LogWarning(string messageTemplate, params object[] propertyValues)
{
_logger.LogWarning(messageTemplate, propertyValues);
}
protected virtual void OnStopImport()
{
Logger.LogWarning("Import has been stopped.", new object[0]);
}
protected virtual void OnTapiClientChanged()
{
Logger.LogWarning("Tapi client has been changed.", new object[0]);
}
protected virtual void OnWriteStatusMessage(EventType2 eventType, string message)
{
}
protected virtual void OnWriteStatusMessage(EventType2 eventType, string message, int progressLineNumber, int physicalLineNumber)
{
}
protected virtual void OnWriteFatalError(Exception exception)
{
Logger.LogFatal($"""{CurrentLineNumber}""{exception.Message}", new object[0]);
}
protected void StopImport(bool userCancelRequest = false)
{
try {
if (userCancelRequest)
_logger.LogInformation("Import process has been canceled on user request", new object[0]);
ShouldImport = false;
OnStopImport();
_cancellationTokenSource.Cancel();
} catch (Exception ex) {
ProjectData.SetProjectError(ex);
Exception ex2 = ex;
OnWriteStatusMessage(EventType2.Status, "Error occured while stopping the job.");
throw;
}
}
protected void UpdateStatisticsSnapshot(DateTime time, bool force = false)
{
if (checked(time.Ticks - _statisticsLastUpdated.Ticks) > 10000000 || force) {
CurrentStatisticsSnapshot = Statistics.ToDictionaryForProgress();
_statisticsLastUpdated = time;
OnWriteStatusMessage(EventType2.Statistics, "", 0, 0);
}
}
private void BulkLoadOnTapiClientChanged(object sender, TapiClientEventArgs e)
{
_bulkLoadTapiClient = e.Client;
_bulkLoadTapiClientName = e.Name;
OnTapiClientChanged();
}
private void BulkLoadOnTapiStatistics(object sender, TapiStatisticsEventArgs e)
{
object syncRoot = _syncRoot;
ObjectFlowControl.CheckForSyncLockOnValueType(syncRoot);
bool lockTaken = false;
try {
Monitor.Enter(syncRoot, ref lockTaken);
_statistics.MetadataTransferDuration = new TimeSpan(e.TotalTransferTicks);
_statistics.MetadataTransferredBytes = e.TotalBytes;
_statistics.MetadataTransferThroughput = e.TransferRateBytes;
UpdateStatisticsSnapshot(DateTime.Now, false);
} finally {
if (lockTaken)
Monitor.Exit(syncRoot);
}
}
private void FileOnTapiClientChanged(object sender, TapiClientEventArgs e)
{
_fileTapiClient = e.Client;
_fileTapiClientName = e.Name;
OnTapiClientChanged();
}
private unsafe void FileOnTapiProgress(object sender, TapiProgressEventArgs e)
{
object syncRoot = _syncRoot;
ObjectFlowControl.CheckForSyncLockOnValueType(syncRoot);
bool lockTaken = false;
checked {
try {
Monitor.Enter(syncRoot, ref lockTaken);
if (e.Completed) {
ref int batchFileTapiProgressCount;
*(ref batchFileTapiProgressCount = ref _batchFileTapiProgressCount) = batchFileTapiProgressCount + 1;
}
if (ShouldImport && e.Successful) {
FileTapiProgressCount++;
ImportStatistics statistics;
(statistics = _statistics).NativeFilesTransferredCount = statistics.NativeFilesTransferredCount + 1;
WriteTapiProgressMessage($"""{e.FileName}""{(e.EndTime - e.StartTime).Milliseconds}""", e.LineNumber);
}
} finally {
if (lockTaken)
Monitor.Exit(syncRoot);
}
}
}
private void BulkLoadOnTapiProgress(object sender, TapiProgressEventArgs e)
{
object syncRoot = _syncRoot;
ObjectFlowControl.CheckForSyncLockOnValueType(syncRoot);
bool lockTaken = false;
try {
Monitor.Enter(syncRoot, ref lockTaken);
if (ShouldImport && e.Successful) {
ImportStatistics statistics;
(statistics = _statistics).MetadataFilesTransferredCount = checked(statistics.MetadataFilesTransferredCount + 1);
}
} finally {
if (lockTaken)
Monitor.Exit(syncRoot);
}
}
private void FileOnTapiStatistics(object sender, TapiStatisticsEventArgs e)
{
object syncRoot = _syncRoot;
ObjectFlowControl.CheckForSyncLockOnValueType(syncRoot);
bool lockTaken = false;
try {
Monitor.Enter(syncRoot, ref lockTaken);
_statistics.FileTransferDuration = new TimeSpan(e.TotalTransferTicks);
_statistics.FileTransferredBytes = e.TotalBytes;
_statistics.FileTransferThroughput = e.TransferRateBytes;
UpdateStatisticsSnapshot(DateTime.Now, false);
} finally {
if (lockTaken)
Monitor.Exit(syncRoot);
}
}
private void OnTapiErrorMessage(object sender, TapiMessageEventArgs e)
{
object syncRoot = _syncRoot;
ObjectFlowControl.CheckForSyncLockOnValueType(syncRoot);
bool lockTaken = false;
try {
Monitor.Enter(syncRoot, ref lockTaken);
if (ShouldImport) {
OnWriteStatusMessage(EventType2.Error, e.Message, e.LineNumber, e.LineNumber);
LogError(e.Message);
}
} finally {
if (lockTaken)
Monitor.Exit(syncRoot);
}
}
private void OnTapiWarningMessage(object sender, TapiMessageEventArgs e)
{
object syncRoot = _syncRoot;
ObjectFlowControl.CheckForSyncLockOnValueType(syncRoot);
bool lockTaken = false;
try {
Monitor.Enter(syncRoot, ref lockTaken);
if (ShouldImport) {
OnWriteStatusMessage(EventType2.Warning, e.Message, e.LineNumber, e.LineNumber);
LogWarning(e.Message);
}
} finally {
if (lockTaken)
Monitor.Exit(syncRoot);
}
}
private void OnTapiFatalError(object sender, TapiMessageEventArgs e)
{
object syncRoot = _syncRoot;
ObjectFlowControl.CheckForSyncLockOnValueType(syncRoot);
bool lockTaken = false;
try {
Monitor.Enter(syncRoot, ref lockTaken);
Exception exception = new Exception(e.Message);
OnWriteFatalError(exception);
LogFatal(exception, "A fatal error has occurred transferring files.");
} finally {
if (lockTaken)
Monitor.Exit(syncRoot);
}
}
private void OnTapiStatusEvent(object sender, TapiMessageEventArgs e)
{
object syncRoot = _syncRoot;
ObjectFlowControl.CheckForSyncLockOnValueType(syncRoot);
bool lockTaken = false;
try {
Monitor.Enter(syncRoot, ref lockTaken);
if (ShouldImport)
OnWriteStatusMessage(EventType2.Status, e.Message, e.LineNumber, e.LineNumber);
} finally {
if (lockTaken)
Monitor.Exit(syncRoot);
}
}
private void WriteTapiProgressMessage(string message, int lineNumber)
{
OnWriteStatusMessage(EventType2.Progress, message, FileTapiProgressCount, lineNumber);
}
protected string GetLineMessage(string line, int lineNumber)
{
line = ((lineNumber != 0) ? (line + $"""{lineNumber}""") : (line + $"""{JobCounter}"""));
return line;
}
protected virtual void RaiseWarningAndPause(Exception exception, int timeoutSeconds)
{
RaiseWarningAndPause(exception, timeoutSeconds, -1, -1);
}
protected virtual void RaiseWarningAndPause(Exception exception, int timeoutSeconds, int retryCount, int totalRetryCount)
{
PublishIoRetryMessage(exception, TimeSpan.FromSeconds((double)timeoutSeconds), retryCount, totalRetryCount);
Thread.CurrentThread.Join(checked(1000 * timeoutSeconds));
}
protected void PublishUploadModeChangeEvent(bool nativeFilesCopied)
{
string statusBarText = TapiModeHelper.BuildImportStatusText(nativeFilesCopied, FileTapiBridge?.Client, BulkLoadTapiBridge?.Client);
UploadModeChangeEventEvent?.Invoke(statusBarText);
}
protected void AwaitPendingBulkLoadFileUploadsForBatch()
{
BulkLoadTapiBridge.WaitForTransfers(Strings.BulkLoadFileUploadsWaitMessage, Strings.BulkLoadFileUploadsSuccessMessage, Strings.BulkLoadFileUploadsErrorMessage, true);
MetadataFilesCount = 0;
}
protected void AwaitPendingBulkLoadFileUploadsForJob()
{
BulkLoadTapiBridge.WaitForTransfers(Strings.BulkLoadFileUploadsWaitMessage, Strings.BulkLoadFileUploadsSuccessMessage, Strings.BulkLoadFileUploadsErrorMessage, false);
}
protected void AwaitPendingPhysicalFileUploadsForBatch()
{
if (AppSettings.Instance.UseSynchronizedImportBatchMode)
FileTapiBridge.WaitForTransfers(Strings.PhysicalFileUploadsWaitMessage, Strings.PhysicalFileUploadsSuccessMessage, Strings.PhysicalFileUploadsErrorMessage, true);
else
WaitForRetry(() => _batchFileTapiProgressCount >= ImportFilesCount, Strings.PhysicalFileUploadsWaitMessage, Strings.PhysicalFileUploadsSuccessMessage, Strings.PhysicalFileUploadsErrorMessage, 6000, 10);
_batchFileTapiProgressCount = 0;
ImportFilesCount = 0;
}
protected void AwaitPendingPhysicalFileUploadsForJob()
{
FileTapiBridge.WaitForTransfers(Strings.PhysicalFileUploadsWaitMessage, Strings.PhysicalFileUploadsSuccessMessage, Strings.PhysicalFileUploadsErrorMessage, false);
}
public bool WaitForRetry(Func<bool> retryFunction, string startMessage, string successMessage, string warningMessage, int retryCount, int waitBetweenRetriesMilliseconds)
{
_Closure$__146-0 closure$__146-;
closure$__146-.$VB$Local_waitSuccess = false;
RetryPolicy<bool> val = RetryTResultSyntax.WaitAndRetry<bool>(Policy.HandleResult<bool>(false), retryCount, (Func<int, TimeSpan>)((int count) => TimeSpan.FromMilliseconds((double)waitBetweenRetriesMilliseconds)));
OnWriteStatusMessage(EventType2.Status, startMessage, 0, 0);
LogInformation(startMessage);
val.Execute((Func<CancellationToken, bool>)((CancellationToken a0) => closure$__146-._Lambda$__1()), _cancellationTokenSource.Token);
if (closure$__146-.$VB$Local_waitSuccess) {
OnWriteStatusMessage(EventType2.Status, successMessage, 0, 0);
LogInformation(successMessage);
} else {
OnWriteStatusMessage(EventType2.Status, warningMessage, 0, 0);
LogWarning(warningMessage);
}
return closure$__146-.$VB$Local_waitSuccess;
}
[CompilerGenerated]
private bool _Lambda$__144-0()
{
return _batchFileTapiProgressCount >= ImportFilesCount;
}
}
}