2278 lines
79 KiB
C#
2278 lines
79 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: CarotDAV.AsyncCopy
|
|
// Assembly: CarotDAV, Version=1.13.2.18337, Culture=neutral, PublicKeyToken=null
|
|
// MVID: C31F2651-A4A8-4D09-916A-8C6106F5E7C8
|
|
// Assembly location: F:\Eigene Dateien\Dropbox\portable Collection\Progs\CarotDAV\CarotDAV.exe
|
|
|
|
using Microsoft.VisualBasic.CompilerServices;
|
|
using Rei.Com;
|
|
using Rei.Fs;
|
|
using Rei.Fs.IO;
|
|
using Rei.Fs.Webdav;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Windows.Forms;
|
|
|
|
namespace CarotDAV
|
|
{
|
|
public class AsyncCopy : Component
|
|
{
|
|
private static DateTime win32timeorigin = new DateTime(1601, 1, 1, 0, 0, 0, DateTimeKind.Utc);
|
|
private IContainer components;
|
|
private object pLock;
|
|
private int pWorkerState;
|
|
private bool pStopAfterFile;
|
|
private LinkedList<AsyncCopy.DavCopyTask> pTaskList;
|
|
private FsBase pFS;
|
|
private CacheManager pCache;
|
|
private UCSNormalization pUploadFilenameNormalization;
|
|
private UCSNormalization pDownloadFilenameNormalization;
|
|
private SendOrPostCallback pServerResourceChangedCallback;
|
|
private SendOrPostCallback pCompleteCallback;
|
|
private AsyncCopy.DavCopyWorkerDelegate pDavCopyWorkerDelegate;
|
|
private AsyncCopy.DavCopyStateType pCurrentState;
|
|
private long pTotalCost;
|
|
private long pTotalProgress;
|
|
private double pTotalTransferSeconds;
|
|
private long pCurrentCost;
|
|
private long pCurrentProgress;
|
|
private double pCurrentSeconds;
|
|
private string pCurrentDesc;
|
|
private long pTotalFiles;
|
|
private long pTotalFolders;
|
|
private long pCurrentFiles;
|
|
private long pCurrentFolders;
|
|
private bool pCancelled;
|
|
private Exception pLastException;
|
|
private AsyncOperation pAsyncOp;
|
|
|
|
[DebuggerNonUserCode]
|
|
public AsyncCopy(IContainer container)
|
|
: this()
|
|
{
|
|
if (container == null)
|
|
return;
|
|
container.Add((IComponent) this);
|
|
}
|
|
|
|
[DebuggerNonUserCode]
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
try
|
|
{
|
|
if (!disposing || this.components == null)
|
|
return;
|
|
this.components.Dispose();
|
|
}
|
|
finally
|
|
{
|
|
base.Dispose(disposing);
|
|
}
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
private void InitializeComponent()
|
|
{
|
|
this.components = (IContainer) new System.ComponentModel.Container();
|
|
}
|
|
|
|
public event EventHandler<ResourceChangedEventArgs> RemoteResourceChanged;
|
|
|
|
public event AsyncCompletedEventHandler CopyCompleted;
|
|
|
|
public event EventHandler<AsyncCopy.CopyConflictedEventArgs> ConflictionOccurred;
|
|
|
|
public event EventHandler<ExceptionOccurredEventArgs> ExceptionOccurred;
|
|
|
|
[DebuggerNonUserCode]
|
|
public AsyncCopy()
|
|
{
|
|
this.Disposed += new EventHandler(this.AsyncCopy_Disposed);
|
|
this.pServerResourceChangedCallback = new SendOrPostCallback(this.ServerResourceChangedCallback);
|
|
this.pCompleteCallback = new SendOrPostCallback(this.DavCopyCompletedCallback);
|
|
this.pDavCopyWorkerDelegate = new AsyncCopy.DavCopyWorkerDelegate(this.Worker);
|
|
this.InitializeComponent();
|
|
this.pLock = RuntimeHelpers.GetObjectValue(new object());
|
|
this.pTaskList = new LinkedList<AsyncCopy.DavCopyTask>();
|
|
this.pUploadFilenameNormalization = UCSNormalization.None;
|
|
this.pDownloadFilenameNormalization = UCSNormalization.None;
|
|
}
|
|
|
|
public int TaskCount
|
|
{
|
|
get
|
|
{
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
return this.pTaskList.Count;
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
}
|
|
}
|
|
|
|
public int UncompleteTaskCount
|
|
{
|
|
get
|
|
{
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
int num;
|
|
try
|
|
{
|
|
LinkedList<AsyncCopy.DavCopyTask>.Enumerator enumerator;
|
|
try
|
|
{
|
|
enumerator = this.pTaskList.GetEnumerator();
|
|
while (enumerator.MoveNext())
|
|
{
|
|
AsyncCopy.DavCopyTask current = enumerator.Current;
|
|
if (current.State != AsyncCopy.TaskStateType.Complete && current.State != AsyncCopy.TaskStateType.ErrorIgnore && current.State != AsyncCopy.TaskStateType.Skipped)
|
|
checked { ++num; }
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
enumerator.Dispose();
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
return num;
|
|
}
|
|
}
|
|
|
|
public int FinishedTaskCount
|
|
{
|
|
get
|
|
{
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
int num;
|
|
try
|
|
{
|
|
LinkedList<AsyncCopy.DavCopyTask>.Enumerator enumerator;
|
|
try
|
|
{
|
|
enumerator = this.pTaskList.GetEnumerator();
|
|
while (enumerator.MoveNext())
|
|
{
|
|
AsyncCopy.DavCopyTask current = enumerator.Current;
|
|
if (current.State == AsyncCopy.TaskStateType.Complete)
|
|
checked { ++num; }
|
|
if (current.State == AsyncCopy.TaskStateType.ErrorIgnore)
|
|
checked { ++num; }
|
|
if (current.State == AsyncCopy.TaskStateType.Skipped)
|
|
checked { ++num; }
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
enumerator.Dispose();
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
return num;
|
|
}
|
|
}
|
|
|
|
public void SetClient(FsBase fs, CacheManager cm, UCSNormalization downnormalization, UCSNormalization uploadnormalization)
|
|
{
|
|
this.pFS = fs;
|
|
this.pCache = cm;
|
|
this.pDownloadFilenameNormalization = downnormalization;
|
|
this.pUploadFilenameNormalization = uploadnormalization;
|
|
}
|
|
|
|
public void Download(ResourceId[] remoteids, string localdir)
|
|
{
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
ResourceId[] resourceIdArray = remoteids;
|
|
int index = 0;
|
|
while (index < resourceIdArray.Length)
|
|
{
|
|
this.pTaskList.AddLast(new AsyncCopy.DavCopyTask(AsyncCopy.TaskType.Download, resourceIdArray[index], localdir));
|
|
checked { ++index; }
|
|
}
|
|
this.pTotalCost = -1L;
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
}
|
|
|
|
public void Upload(string[] localfiles, ResourceId remoteid, IDataObject dobj, DragDropEffects finisheffect)
|
|
{
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
int num1 = 0;
|
|
int num2 = checked (localfiles.Length - 1);
|
|
int index = num1;
|
|
while (index <= num2)
|
|
{
|
|
this.pTaskList.AddLast(new AsyncCopy.DavCopyTask(AsyncCopy.TaskType.Upload, remoteid, localfiles[index]));
|
|
checked { ++index; }
|
|
}
|
|
this.pTaskList.Last.Value.DataObject = dobj;
|
|
this.pTaskList.Last.Value.FinishEffect = finisheffect;
|
|
this.pTotalCost = -1L;
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
}
|
|
|
|
public void UploadDescriptors(VirtualFileInfo[] vfinfos, ResourceId remoteid, IDataObject dobj, DragDropEffects finisheffect)
|
|
{
|
|
List<AsyncCopy.DavCopyTask> davCopyTaskList = new List<AsyncCopy.DavCopyTask>();
|
|
int num1 = 0;
|
|
int num2 = checked (vfinfos.Length - 1);
|
|
int index1 = num1;
|
|
while (index1 <= num2)
|
|
{
|
|
bool flag = (vfinfos[index1].FileAttributes & FileAttributes.Directory) != (FileAttributes) 0;
|
|
string[] strArray = vfinfos[index1].FileName.Split(new char[2]
|
|
{
|
|
'\\',
|
|
'/'
|
|
}, StringSplitOptions.RemoveEmptyEntries);
|
|
AsyncCopy.DavCopyTask parenttask = (AsyncCopy.DavCopyTask) null;
|
|
int num3 = 0;
|
|
int num4 = checked (strArray.Length - 2);
|
|
int index2 = num3;
|
|
while (index2 <= num4)
|
|
{
|
|
AsyncCopy.DavCopyTask davCopyTask = (AsyncCopy.DavCopyTask) null;
|
|
AsyncCopy.DavCopyTask[] davCopyTaskArray = parenttask != null ? parenttask.SubTasks : davCopyTaskList.ToArray();
|
|
int num5 = 0;
|
|
int num6 = checked (davCopyTaskArray.Length - 1);
|
|
int index3 = num5;
|
|
while (index3 <= num6)
|
|
{
|
|
if (Operators.CompareString(davCopyTaskArray[index3].LocalPath, strArray[index2], false) == 0 && davCopyTaskArray[index3].IsCollection)
|
|
{
|
|
davCopyTask = davCopyTaskArray[index3];
|
|
break;
|
|
}
|
|
checked { ++index3; }
|
|
}
|
|
if (davCopyTask == null)
|
|
{
|
|
if (parenttask == null)
|
|
{
|
|
davCopyTask = new AsyncCopy.DavCopyTask(AsyncCopy.TaskType.Upload, remoteid, strArray[index2]);
|
|
davCopyTaskList.Add(davCopyTask);
|
|
}
|
|
else
|
|
davCopyTask = new AsyncCopy.DavCopyTask(parenttask, strArray[index2]);
|
|
davCopyTask.Size = -1L;
|
|
davCopyTask.IsCollection = true;
|
|
davCopyTask.LastModifiedTime = DateTime.MinValue;
|
|
davCopyTask.CreationDate = DateTime.MinValue;
|
|
davCopyTask.LastModifiedTime = DateTime.MinValue;
|
|
davCopyTask.State = AsyncCopy.TaskStateType.PropertyAcquired;
|
|
}
|
|
parenttask = davCopyTask;
|
|
checked { ++index2; }
|
|
}
|
|
AsyncCopy.DavCopyTask davCopyTask1 = (AsyncCopy.DavCopyTask) null;
|
|
AsyncCopy.DavCopyTask[] davCopyTaskArray1 = parenttask != null ? parenttask.SubTasks : davCopyTaskList.ToArray();
|
|
int num7 = 0;
|
|
int num8 = checked (davCopyTaskArray1.Length - 1);
|
|
int index4 = num7;
|
|
while (index4 <= num8)
|
|
{
|
|
if (Operators.CompareString(davCopyTaskArray1[index4].LocalPath, strArray[index2], false) == 0 && davCopyTaskArray1[index4].IsCollection == flag)
|
|
{
|
|
davCopyTask1 = davCopyTaskArray1[index4];
|
|
break;
|
|
}
|
|
checked { ++index4; }
|
|
}
|
|
if (davCopyTask1 == null)
|
|
{
|
|
if (parenttask == null)
|
|
{
|
|
davCopyTask1 = new AsyncCopy.DavCopyTask(AsyncCopy.TaskType.Upload, remoteid, vfinfos[index1]);
|
|
davCopyTaskList.Add(davCopyTask1);
|
|
}
|
|
else
|
|
davCopyTask1 = new AsyncCopy.DavCopyTask(parenttask, strArray[index2], vfinfos[index1]);
|
|
}
|
|
if ((vfinfos[index1].Flags & FDFlags.FD_CREATETIME) != (FDFlags) 0)
|
|
davCopyTask1.CreationDate = vfinfos[index1].CreationTime;
|
|
if ((vfinfos[index1].Flags & FDFlags.FD_ACCESSTIME) != (FDFlags) 0)
|
|
davCopyTask1.LastAccessTime = vfinfos[index1].LastAccessTime;
|
|
if ((vfinfos[index1].Flags & FDFlags.FD_WRITESTIME) != (FDFlags) 0)
|
|
davCopyTask1.LastModifiedTime = vfinfos[index1].LastWriteTime;
|
|
davCopyTask1.Size = (vfinfos[index1].Flags & FDFlags.FD_FILESIZE) == (FDFlags) 0 ? -1L : checked ((long) vfinfos[index1].FileSize);
|
|
davCopyTask1.IsCollection = flag;
|
|
davCopyTask1.State = AsyncCopy.TaskStateType.PropertyAcquired;
|
|
checked { ++index1; }
|
|
}
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
int num3 = 0;
|
|
int num4 = checked (davCopyTaskList.Count - 1);
|
|
int index2 = num3;
|
|
while (index2 <= num4)
|
|
{
|
|
this.pTaskList.AddLast(davCopyTaskList[index2]);
|
|
checked { ++index2; }
|
|
}
|
|
this.pTaskList.Last.Value.DataObject = dobj;
|
|
this.pTaskList.Last.Value.FinishEffect = finisheffect;
|
|
this.pTotalCost = -1L;
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
this.pTotalCost = -1L;
|
|
this.pTaskList.Clear();
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
}
|
|
|
|
public void DavCopyAsync()
|
|
{
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
if (this.pWorkerState != 0)
|
|
throw new InvalidOperationException();
|
|
this.pWorkerState = 1;
|
|
this.pCancelled = false;
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
if (this.pFS == null)
|
|
throw new InvalidOperationException();
|
|
this.pDavCopyWorkerDelegate.BeginInvoke(AsyncOperationManager.CreateOperation(RuntimeHelpers.GetObjectValue(this.pLock)), (AsyncCallback) null, (object) null);
|
|
}
|
|
|
|
public bool IsBusy
|
|
{
|
|
get
|
|
{
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
return this.pWorkerState != 0;
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool StopAfterFile
|
|
{
|
|
get
|
|
{
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
return this.pStopAfterFile;
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
}
|
|
set
|
|
{
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
this.pStopAfterFile = value;
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void DavCopyAsyncCancel()
|
|
{
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
if (this.pWorkerState != 1)
|
|
return;
|
|
this.pWorkerState = 2;
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
}
|
|
|
|
protected void OnServerResourceChanged(ResourceChangedEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
EventHandler<ResourceChangedEventArgs> resourceChangedEvent = this.RemoteResourceChangedEvent;
|
|
if (resourceChangedEvent == null)
|
|
return;
|
|
resourceChangedEvent((object) null, e);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ProjectData.SetProjectError(ex);
|
|
ProjectData.ClearProjectError();
|
|
}
|
|
}
|
|
|
|
protected void OnDavCopyCompleted(AsyncCompletedEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
this.pWorkerState = 0;
|
|
this.pFS.ResetConnection();
|
|
AsyncCompletedEventHandler copyCompletedEvent = this.CopyCompletedEvent;
|
|
if (copyCompletedEvent == null)
|
|
return;
|
|
copyCompletedEvent((object) null, e);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ProjectData.SetProjectError(ex);
|
|
int num = (int) MessageBox.Show("Error\r\n" + ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Hand);
|
|
ProjectData.ClearProjectError();
|
|
}
|
|
}
|
|
|
|
public AsyncCopy.StateContainer GetState()
|
|
{
|
|
AsyncCopy.StateContainer stateContainer = new AsyncCopy.StateContainer();
|
|
stateContainer.CurrentState = this.pCurrentState;
|
|
stateContainer.TotalCost = this.pTotalCost;
|
|
stateContainer.TotalProgress = this.pTotalProgress;
|
|
stateContainer.TotalSeconds = this.pTotalTransferSeconds;
|
|
stateContainer.CurrentCost = this.pCurrentCost;
|
|
stateContainer.CurrentProgress = this.pCurrentProgress;
|
|
stateContainer.CurrentSeconds = this.pCurrentSeconds;
|
|
stateContainer.CurrentDesc = this.pCurrentDesc;
|
|
stateContainer.TotalFiles = this.pTotalFiles;
|
|
stateContainer.CurrentFiles = this.pCurrentFiles;
|
|
stateContainer.TotalFolders = this.pTotalFolders;
|
|
stateContainer.CurrentFolders = this.pCurrentFolders;
|
|
if (stateContainer.CurrentProgress >= 0L && stateContainer.TotalProgress >= 0L)
|
|
stateContainer.TotalProgress = checked (stateContainer.TotalProgress + stateContainer.CurrentProgress);
|
|
if (stateContainer.TotalSeconds >= 0.0 && stateContainer.CurrentSeconds >= 0.0)
|
|
stateContainer.TotalSeconds = stateContainer.TotalSeconds + stateContainer.CurrentSeconds;
|
|
return stateContainer;
|
|
}
|
|
|
|
private void Worker(AsyncOperation asyncop)
|
|
{
|
|
this.pLastException = (Exception) null;
|
|
this.pAsyncOp = asyncop;
|
|
try
|
|
{
|
|
while (true)
|
|
{
|
|
if (this.pWorkerState == 2)
|
|
this.pCancelled = true;
|
|
if (this.pStopAfterFile)
|
|
this.pCancelled = true;
|
|
if (!this.pCancelled)
|
|
{
|
|
long num1 = 0;
|
|
long num2 = 0;
|
|
double num3 = 0.0;
|
|
long num4 = 0;
|
|
long num5 = 0;
|
|
long num6 = 0;
|
|
long num7 = 0;
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
LinkedList<AsyncCopy.DavCopyTask>.Enumerator enumerator;
|
|
try
|
|
{
|
|
enumerator = this.pTaskList.GetEnumerator();
|
|
while (enumerator.MoveNext())
|
|
{
|
|
AsyncCopy.DavCopyTask current = enumerator.Current;
|
|
if (current.State != AsyncCopy.TaskStateType.ErrorIgnore && current.State != AsyncCopy.TaskStateType.Skipped)
|
|
{
|
|
if (current.Size < 0L || num1 < 0L)
|
|
num1 = -1L;
|
|
else
|
|
checked { num1 += current.Size; }
|
|
if (current.IsCollection)
|
|
checked { ++num5; }
|
|
else
|
|
checked { ++num4; }
|
|
if (current.State == AsyncCopy.TaskStateType.Complete)
|
|
{
|
|
if (current.Size < 0L || num2 < 0L)
|
|
num2 = -1L;
|
|
else
|
|
checked { num2 += current.Size; }
|
|
if (current.IsCollection)
|
|
checked { ++num7; }
|
|
else
|
|
checked { ++num6; }
|
|
num3 += current.TransferSeconds;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
enumerator.Dispose();
|
|
}
|
|
this.pTotalCost = num1;
|
|
this.pTotalProgress = num2;
|
|
this.pTotalTransferSeconds = num3;
|
|
this.pTotalFiles = num4;
|
|
this.pTotalFolders = num5;
|
|
this.pCurrentFiles = num6;
|
|
this.pCurrentFolders = num7;
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
AsyncCopy.DavCopyTask task = this.Worker_GetTask();
|
|
if (task != null)
|
|
{
|
|
switch (task.TaskType)
|
|
{
|
|
case AsyncCopy.TaskType.Download:
|
|
switch (task.State)
|
|
{
|
|
case AsyncCopy.TaskStateType.Initialized:
|
|
this.Worker_Download_GetProperty(task);
|
|
continue;
|
|
case AsyncCopy.TaskStateType.PropertyAcquired:
|
|
if (task.IsCollection)
|
|
{
|
|
this.Worker_Download_ConfirmFolder(task);
|
|
continue;
|
|
}
|
|
this.Worker_Download_DownloadFile(task);
|
|
continue;
|
|
case AsyncCopy.TaskStateType.FolderConfirmed:
|
|
this.Worker_Download_SetFolderProperty(task);
|
|
continue;
|
|
default:
|
|
goto label_35;
|
|
}
|
|
case AsyncCopy.TaskType.Upload:
|
|
switch (task.State)
|
|
{
|
|
case AsyncCopy.TaskStateType.Initialized:
|
|
this.Worker_Upload_GetProperty(task);
|
|
continue;
|
|
case AsyncCopy.TaskStateType.PropertyAcquired:
|
|
if (task.IsCollection)
|
|
{
|
|
this.Worker_Upload_ConfirmFolder(task);
|
|
continue;
|
|
}
|
|
this.Worker_Upload_UploadFile(task);
|
|
continue;
|
|
case AsyncCopy.TaskStateType.FolderConfirmed:
|
|
this.Worker_Upload_SetFolderProperty(task);
|
|
continue;
|
|
default:
|
|
goto label_42;
|
|
}
|
|
default:
|
|
goto label_43;
|
|
}
|
|
}
|
|
else
|
|
goto label_45;
|
|
}
|
|
else
|
|
goto label_45;
|
|
}
|
|
label_35:
|
|
throw new Exception();
|
|
label_42:
|
|
throw new Exception();
|
|
label_43:
|
|
throw new Exception();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ProjectData.SetProjectError(ex);
|
|
this.pLastException = ex;
|
|
ProjectData.ClearProjectError();
|
|
}
|
|
label_45:
|
|
this.pAsyncOp.PostOperationCompleted(this.pCompleteCallback, (object) new AsyncCompletedEventArgs(this.pLastException, this.pCancelled, (object) null));
|
|
}
|
|
|
|
private AsyncCopy.DavCopyTask Worker_GetTask()
|
|
{
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
LinkedList<AsyncCopy.DavCopyTask>.Enumerator enumerator1;
|
|
try
|
|
{
|
|
enumerator1 = this.pTaskList.GetEnumerator();
|
|
while (enumerator1.MoveNext())
|
|
{
|
|
AsyncCopy.DavCopyTask current = enumerator1.Current;
|
|
if (current.State == AsyncCopy.TaskStateType.Initialized)
|
|
return current;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
enumerator1.Dispose();
|
|
}
|
|
LinkedList<AsyncCopy.DavCopyTask>.Enumerator enumerator2;
|
|
try
|
|
{
|
|
enumerator2 = this.pTaskList.GetEnumerator();
|
|
while (enumerator2.MoveNext())
|
|
{
|
|
AsyncCopy.DavCopyTask davCopyTask1 = enumerator2.Current;
|
|
if (davCopyTask1.IsRootTask)
|
|
{
|
|
if (davCopyTask1.State == AsyncCopy.TaskStateType.PropertyAcquired)
|
|
return davCopyTask1;
|
|
if (davCopyTask1.State == AsyncCopy.TaskStateType.FolderConfirmed)
|
|
{
|
|
label_11:
|
|
AsyncCopy.DavCopyTask[] subTasks1 = davCopyTask1.SubTasks;
|
|
int index1 = 0;
|
|
while (index1 < subTasks1.Length)
|
|
{
|
|
AsyncCopy.DavCopyTask davCopyTask2 = subTasks1[index1];
|
|
if (!davCopyTask2.IsCollection && davCopyTask2.State == AsyncCopy.TaskStateType.PropertyAcquired)
|
|
return davCopyTask2;
|
|
checked { ++index1; }
|
|
}
|
|
AsyncCopy.DavCopyTask[] subTasks2 = davCopyTask1.SubTasks;
|
|
int index2 = 0;
|
|
while (index2 < subTasks2.Length)
|
|
{
|
|
AsyncCopy.DavCopyTask davCopyTask2 = subTasks2[index2];
|
|
if (davCopyTask2.State == AsyncCopy.TaskStateType.FolderConfirmed)
|
|
{
|
|
davCopyTask1 = davCopyTask2;
|
|
goto label_11;
|
|
}
|
|
else
|
|
checked { ++index2; }
|
|
}
|
|
AsyncCopy.DavCopyTask[] subTasks3 = davCopyTask1.SubTasks;
|
|
int index3 = 0;
|
|
while (index3 < subTasks3.Length)
|
|
{
|
|
AsyncCopy.DavCopyTask davCopyTask2 = subTasks3[index3];
|
|
if (davCopyTask2.State == AsyncCopy.TaskStateType.PropertyAcquired)
|
|
return davCopyTask2;
|
|
checked { ++index3; }
|
|
}
|
|
return davCopyTask1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
enumerator2.Dispose();
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
return (AsyncCopy.DavCopyTask) null;
|
|
}
|
|
|
|
private void Worker_Download_GetProperty(AsyncCopy.DavCopyTask task)
|
|
{
|
|
int retryminutes = 1;
|
|
this.pCurrentState = AsyncCopy.DavCopyStateType.DownloadProperty;
|
|
this.pCurrentCost = -1L;
|
|
this.pCurrentProgress = 0L;
|
|
this.pCurrentDesc = task.GetDownloadFileName();
|
|
ResourceInfo[] resourceInfoArray;
|
|
while (true)
|
|
{
|
|
try
|
|
{
|
|
resourceInfoArray = !task.IsRootTask ? this.pCache.GetEntries(this.pFS, task.RemoteId, false) : this.pCache.GetInfoAndEntries(this.pFS, task.RemoteId, false);
|
|
break;
|
|
}
|
|
catch (Exception ex1)
|
|
{
|
|
ProjectData.SetProjectError(ex1);
|
|
Exception ex2 = ex1;
|
|
this.pFS.ResetConnection();
|
|
ExceptionOccurredEventArgs e = new ExceptionOccurredEventArgs("Error occurred during downloading property.", task.GetDownloadFileName(), ErrorPromptType.IgnoreAllIgnoreRetryCancel, ex2, retryminutes);
|
|
EventHandler<ExceptionOccurredEventArgs> exceptionOccurredEvent = this.ExceptionOccurredEvent;
|
|
if (exceptionOccurredEvent != null)
|
|
exceptionOccurredEvent((object) this, e);
|
|
switch (e.Result.Action)
|
|
{
|
|
case ErrorAction.Ignore:
|
|
task.State = AsyncCopy.TaskStateType.ErrorIgnore;
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
case ErrorAction.Retry:
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.AutoRetry:
|
|
checked { retryminutes *= 2; }
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.Cancel:
|
|
this.pCancelled = true;
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
default:
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (task.IsRootTask)
|
|
{
|
|
task.RemoteId = resourceInfoArray[0].Id;
|
|
task.UriDic.Add(resourceInfoArray[0].Id.Uri, true);
|
|
task.Info = resourceInfoArray[0];
|
|
task.LastModifiedTime = resourceInfoArray[0].LastModifiedTime;
|
|
task.IsCollection = resourceInfoArray[0].IsCollection;
|
|
task.CreationDate = resourceInfoArray[0].CreationTime;
|
|
task.LastAccessTime = resourceInfoArray[0].LastAccessTime;
|
|
task.Size = !task.IsCollection ? resourceInfoArray[0].Size : 0L;
|
|
}
|
|
task.State = AsyncCopy.TaskStateType.PropertyAcquired;
|
|
int num1 = 0;
|
|
int num2 = checked (resourceInfoArray.Length - 1);
|
|
int index = num1;
|
|
while (index <= num2)
|
|
{
|
|
if (!task.UriDic.ContainsKey(resourceInfoArray[index].Id.Uri))
|
|
{
|
|
task.UriDic.Add(resourceInfoArray[index].Id.Uri, true);
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
AsyncCopy.DavCopyTask davCopyTask = new AsyncCopy.DavCopyTask(task, resourceInfoArray[index].Id);
|
|
davCopyTask.Info = resourceInfoArray[index];
|
|
davCopyTask.LastModifiedTime = resourceInfoArray[index].LastModifiedTime;
|
|
davCopyTask.IsCollection = resourceInfoArray[index].IsCollection;
|
|
davCopyTask.CreationDate = resourceInfoArray[index].CreationTime;
|
|
davCopyTask.LastAccessTime = resourceInfoArray[index].LastAccessTime;
|
|
davCopyTask.Size = !davCopyTask.IsCollection ? resourceInfoArray[index].Size : 0L;
|
|
if (!davCopyTask.IsCollection)
|
|
davCopyTask.State = AsyncCopy.TaskStateType.PropertyAcquired;
|
|
this.pTaskList.AddLast(davCopyTask);
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
}
|
|
checked { ++index; }
|
|
}
|
|
}
|
|
|
|
private void Worker_Download_ConfirmFolder(AsyncCopy.DavCopyTask task)
|
|
{
|
|
int namecount = 0;
|
|
int retryminutes = 1;
|
|
while (true)
|
|
{
|
|
string path2 = task.CalcLocalPathForDownload(this.pDownloadFilenameNormalization, namecount);
|
|
string str = Path.Combine(task.BaseLocalPath, path2);
|
|
this.pCurrentState = AsyncCopy.DavCopyStateType.ConfirmFolder;
|
|
this.pCurrentCost = -1L;
|
|
this.pCurrentProgress = 0L;
|
|
this.pCurrentDesc = task.GetDownloadFileName();
|
|
try
|
|
{
|
|
SimpleResourceInfo localFileInfo = SimpleResourceInfo.CreateLocalFileInfo(str);
|
|
ConflictType type;
|
|
if (localFileInfo == null)
|
|
{
|
|
type = ConflictType.NoConfliction;
|
|
}
|
|
else
|
|
{
|
|
if (namecount > 0)
|
|
{
|
|
checked { ++namecount; }
|
|
continue;
|
|
}
|
|
type = !localFileInfo.IsCollection ? ConflictType.FolderToFile : ConflictType.FolderToFolder;
|
|
}
|
|
ConflictAction conflictAction;
|
|
if (type == ConflictType.NoConfliction)
|
|
{
|
|
conflictAction = ConflictAction.NoConfliction;
|
|
}
|
|
else
|
|
{
|
|
AsyncCopy.CopyConflictedEventArgs e = new AsyncCopy.CopyConflictedEventArgs(new SimpleResourceInfo(task.GetDownloadFileName(), task.Size, task.LastModifiedTime, true), localFileInfo, type, (this.pFS.Ability & FsAbility.PartialRead) != FsAbility.None, FsAbility.All, retryminutes);
|
|
EventHandler<AsyncCopy.CopyConflictedEventArgs> conflictionOccurredEvent = this.ConflictionOccurredEvent;
|
|
if (conflictionOccurredEvent != null)
|
|
conflictionOccurredEvent((object) this, e);
|
|
conflictAction = e.Result.Action;
|
|
}
|
|
switch (conflictAction)
|
|
{
|
|
case ConflictAction.NoConfliction:
|
|
Directory.CreateDirectory(str);
|
|
goto case ConflictAction.Integrate;
|
|
case ConflictAction.Integrate:
|
|
task.LocalPath = str;
|
|
task.State = AsyncCopy.TaskStateType.FolderConfirmed;
|
|
return;
|
|
case ConflictAction.DeleteTarget:
|
|
if (type == ConflictType.FileToFile)
|
|
File.Delete(str);
|
|
else
|
|
Directory.Delete(str, true);
|
|
Directory.CreateDirectory(str);
|
|
goto case ConflictAction.Integrate;
|
|
case ConflictAction.Retry:
|
|
continue;
|
|
case ConflictAction.AutoRetry:
|
|
checked { retryminutes *= 2; }
|
|
continue;
|
|
case ConflictAction.ChangeName:
|
|
checked { ++namecount; }
|
|
continue;
|
|
case ConflictAction.Skip:
|
|
LinkedList<AsyncCopy.DavCopyTask> linkedList = new LinkedList<AsyncCopy.DavCopyTask>();
|
|
linkedList.AddFirst(task);
|
|
while (linkedList.Count > 0)
|
|
{
|
|
AsyncCopy.DavCopyTask davCopyTask1 = linkedList.First.Value;
|
|
linkedList.RemoveFirst();
|
|
davCopyTask1.State = AsyncCopy.TaskStateType.Skipped;
|
|
AsyncCopy.DavCopyTask[] subTasks = davCopyTask1.SubTasks;
|
|
int index = 0;
|
|
while (index < subTasks.Length)
|
|
{
|
|
AsyncCopy.DavCopyTask davCopyTask2 = subTasks[index];
|
|
linkedList.AddLast(davCopyTask2);
|
|
checked { ++index; }
|
|
}
|
|
}
|
|
return;
|
|
case ConflictAction.CancelAll:
|
|
this.pCancelled = true;
|
|
return;
|
|
default:
|
|
throw new InvalidOperationException();
|
|
}
|
|
}
|
|
catch (Exception ex1)
|
|
{
|
|
ProjectData.SetProjectError(ex1);
|
|
Exception ex2 = ex1;
|
|
ExceptionOccurredEventArgs e = new ExceptionOccurredEventArgs("Error occurred during confirming folder property.", str, ErrorPromptType.IgnoreAllIgnoreRetryCancel, ex2, retryminutes);
|
|
EventHandler<ExceptionOccurredEventArgs> exceptionOccurredEvent = this.ExceptionOccurredEvent;
|
|
if (exceptionOccurredEvent != null)
|
|
exceptionOccurredEvent((object) this, e);
|
|
switch (e.Result.Action)
|
|
{
|
|
case ErrorAction.Ignore:
|
|
LinkedList<AsyncCopy.DavCopyTask> linkedList = new LinkedList<AsyncCopy.DavCopyTask>();
|
|
linkedList.AddLast(task);
|
|
while (linkedList.Count > 0)
|
|
{
|
|
AsyncCopy.DavCopyTask davCopyTask1 = linkedList.First.Value;
|
|
linkedList.RemoveFirst();
|
|
davCopyTask1.State = AsyncCopy.TaskStateType.ErrorIgnore;
|
|
AsyncCopy.DavCopyTask[] subTasks = davCopyTask1.SubTasks;
|
|
int index = 0;
|
|
while (index < subTasks.Length)
|
|
{
|
|
AsyncCopy.DavCopyTask davCopyTask2 = subTasks[index];
|
|
linkedList.AddLast(davCopyTask2);
|
|
checked { ++index; }
|
|
}
|
|
}
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
case ErrorAction.Retry:
|
|
namecount = 0;
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.AutoRetry:
|
|
namecount = 0;
|
|
checked { retryminutes *= 2; }
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.Cancel:
|
|
this.pCancelled = true;
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
default:
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Worker_Download_DownloadFile(AsyncCopy.DavCopyTask task)
|
|
{
|
|
int namecount = 0;
|
|
int retryminutes = 1;
|
|
while (true)
|
|
{
|
|
string path2 = task.CalcLocalPathForDownload(this.pDownloadFilenameNormalization, namecount);
|
|
string path = Path.Combine(task.BaseLocalPath, path2);
|
|
this.pCurrentState = AsyncCopy.DavCopyStateType.ConfirmFile;
|
|
this.pCurrentCost = -1L;
|
|
this.pCurrentProgress = 0L;
|
|
this.pCurrentDesc = task.GetDownloadFileName();
|
|
try
|
|
{
|
|
long start = 0;
|
|
SimpleResourceInfo localFileInfo = SimpleResourceInfo.CreateLocalFileInfo(path);
|
|
ConflictType type;
|
|
if (localFileInfo == null)
|
|
{
|
|
type = ConflictType.NoConfliction;
|
|
}
|
|
else
|
|
{
|
|
if (namecount > 0)
|
|
{
|
|
checked { ++namecount; }
|
|
continue;
|
|
}
|
|
type = !localFileInfo.IsCollection ? ConflictType.FileToFile : ConflictType.FileToFolder;
|
|
}
|
|
ConflictAction conflictAction;
|
|
if (type == ConflictType.NoConfliction)
|
|
{
|
|
conflictAction = ConflictAction.NoConfliction;
|
|
}
|
|
else
|
|
{
|
|
AsyncCopy.CopyConflictedEventArgs e = new AsyncCopy.CopyConflictedEventArgs(new SimpleResourceInfo(task.GetDownloadFileName(), task.Size, task.LastModifiedTime, false), localFileInfo, type, (this.pFS.Ability & FsAbility.PartialRead) != FsAbility.None, FsAbility.All, retryminutes);
|
|
EventHandler<AsyncCopy.CopyConflictedEventArgs> conflictionOccurredEvent = this.ConflictionOccurredEvent;
|
|
if (conflictionOccurredEvent != null)
|
|
conflictionOccurredEvent((object) this, e);
|
|
conflictAction = e.Result.Action;
|
|
}
|
|
switch (conflictAction)
|
|
{
|
|
case ConflictAction.NoConfliction:
|
|
case ConflictAction.Overwrite:
|
|
task.LocalPath = path;
|
|
byte[] buffer = new byte[65536];
|
|
DateTime now = DateTime.Now;
|
|
this.pCurrentCost = task.Size;
|
|
this.pCurrentProgress = 0L;
|
|
this.pCurrentState = AsyncCopy.DavCopyStateType.DownloadFile;
|
|
CacheManager pCache = this.pCache;
|
|
FsBase pFs = this.pFS;
|
|
ResourceId remoteId = task.RemoteId;
|
|
long length = -1;
|
|
using (Stream stream1 = pCache.OpenRead(pFs, remoteId, ref start, ref length))
|
|
{
|
|
using (Stream stream2 = (Stream) File.OpenWrite(task.LocalPath))
|
|
{
|
|
if (start > 0L)
|
|
{
|
|
stream2.Seek(start, SeekOrigin.Begin);
|
|
if (task.Size >= 0L)
|
|
this.pCurrentCost = checked (task.Size - start);
|
|
}
|
|
while (true)
|
|
{
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
if (this.pWorkerState == 2)
|
|
{
|
|
this.pCancelled = true;
|
|
stream1.Close();
|
|
throw new Exception();
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
int count = stream1.Read(buffer, 0, buffer.Length);
|
|
if (count != 0)
|
|
{
|
|
stream2.Write(buffer, 0, count);
|
|
this.pCurrentProgress = checked (this.pCurrentProgress + (long) count);
|
|
this.pCurrentSeconds = DateTime.Now.Subtract(now).TotalSeconds;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this.SetTimes(task.LocalPath, task.LastModifiedTime, task.CreationDate, task.LastAccessTime);
|
|
if (this.pCurrentCost >= 0L)
|
|
{
|
|
if (this.pCurrentProgress < this.pCurrentCost)
|
|
throw new ApplicationException("Cannot receive whole contents. Resource may be changed.");
|
|
if (this.pCurrentProgress > this.pCurrentCost)
|
|
throw new ApplicationException("Received stream is too long. Resource may be changed.");
|
|
}
|
|
task.State = AsyncCopy.TaskStateType.Complete;
|
|
goto label_62;
|
|
case ConflictAction.OverwriteNewer:
|
|
if (DateTime.Compare(File.GetLastWriteTime(path), task.Info.LastModifiedTime) >= 0)
|
|
{
|
|
task.State = AsyncCopy.TaskStateType.Skipped;
|
|
goto label_62;
|
|
}
|
|
else
|
|
goto case ConflictAction.NoConfliction;
|
|
case ConflictAction.Resume:
|
|
if (localFileInfo.Size < 0L || task.Size < 0L)
|
|
throw new InvalidOperationException("Cannot Resume.");
|
|
if (localFileInfo.Size >= task.Size)
|
|
{
|
|
task.State = AsyncCopy.TaskStateType.Skipped;
|
|
goto label_62;
|
|
}
|
|
else
|
|
{
|
|
start = localFileInfo.Size;
|
|
goto case ConflictAction.NoConfliction;
|
|
}
|
|
case ConflictAction.DeleteTarget:
|
|
if (type == ConflictType.FileToFile)
|
|
{
|
|
File.Delete(path);
|
|
goto case ConflictAction.NoConfliction;
|
|
}
|
|
else
|
|
{
|
|
Directory.Delete(path, true);
|
|
goto case ConflictAction.NoConfliction;
|
|
}
|
|
case ConflictAction.Retry:
|
|
continue;
|
|
case ConflictAction.AutoRetry:
|
|
checked { retryminutes *= 2; }
|
|
continue;
|
|
case ConflictAction.ChangeName:
|
|
checked { ++namecount; }
|
|
continue;
|
|
case ConflictAction.Skip:
|
|
task.State = AsyncCopy.TaskStateType.Skipped;
|
|
goto label_62;
|
|
case ConflictAction.CancelAll:
|
|
this.pCancelled = true;
|
|
return;
|
|
default:
|
|
throw new InvalidOperationException();
|
|
}
|
|
}
|
|
catch (Exception ex1)
|
|
{
|
|
ProjectData.SetProjectError(ex1);
|
|
Exception ex2 = ex1;
|
|
this.pFS.ResetConnection();
|
|
if (this.pCancelled)
|
|
{
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
}
|
|
ExceptionOccurredEventArgs e = new ExceptionOccurredEventArgs("Error occurred during downloading file.", task.RemoteId.Uri, ErrorPromptType.IgnoreAllIgnoreRetryCancel, ex2, retryminutes);
|
|
EventHandler<ExceptionOccurredEventArgs> exceptionOccurredEvent = this.ExceptionOccurredEvent;
|
|
if (exceptionOccurredEvent != null)
|
|
exceptionOccurredEvent((object) this, e);
|
|
switch (e.Result.Action)
|
|
{
|
|
case ErrorAction.Ignore:
|
|
task.State = AsyncCopy.TaskStateType.ErrorIgnore;
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
case ErrorAction.Retry:
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.AutoRetry:
|
|
checked { retryminutes *= 2; }
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.Cancel:
|
|
this.pCancelled = true;
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
default:
|
|
ProjectData.ClearProjectError();
|
|
goto label_62;
|
|
}
|
|
}
|
|
}
|
|
label_62:
|
|
task.TransferSeconds = this.pCurrentSeconds;
|
|
this.pTotalTransferSeconds = this.pTotalTransferSeconds + this.pCurrentSeconds;
|
|
this.pCurrentSeconds = 0.0;
|
|
if (task.State == AsyncCopy.TaskStateType.Skipped)
|
|
{
|
|
this.pCurrentProgress = 0L;
|
|
this.pCurrentCost = 0L;
|
|
}
|
|
else
|
|
{
|
|
if (this.pTotalProgress < 0L)
|
|
return;
|
|
this.pTotalProgress = checked (this.pTotalProgress + this.pCurrentProgress);
|
|
this.pCurrentProgress = 0L;
|
|
}
|
|
}
|
|
|
|
private void Worker_Download_SetFolderProperty(AsyncCopy.DavCopyTask task)
|
|
{
|
|
int retryminutes = 1;
|
|
this.pCurrentState = AsyncCopy.DavCopyStateType.SetFolderAttribute;
|
|
this.pCurrentCost = -1L;
|
|
this.pCurrentProgress = 0L;
|
|
this.pCurrentDesc = task.GetDownloadFileName();
|
|
while (true)
|
|
{
|
|
try
|
|
{
|
|
this.SetTimes(task.LocalPath, task.LastModifiedTime, task.CreationDate, task.LastAccessTime);
|
|
task.State = AsyncCopy.TaskStateType.Complete;
|
|
break;
|
|
}
|
|
catch (Exception ex1)
|
|
{
|
|
ProjectData.SetProjectError(ex1);
|
|
Exception ex2 = ex1;
|
|
ExceptionOccurredEventArgs e = new ExceptionOccurredEventArgs("Error occurred during updating folder property.", task.LocalPath, ErrorPromptType.IgnoreAllIgnoreRetryCancel, ex2, retryminutes);
|
|
EventHandler<ExceptionOccurredEventArgs> exceptionOccurredEvent = this.ExceptionOccurredEvent;
|
|
if (exceptionOccurredEvent != null)
|
|
exceptionOccurredEvent((object) this, e);
|
|
switch (e.Result.Action)
|
|
{
|
|
case ErrorAction.Ignore:
|
|
task.State = AsyncCopy.TaskStateType.ErrorIgnore;
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
case ErrorAction.Retry:
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.AutoRetry:
|
|
checked { retryminutes *= 2; }
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.Cancel:
|
|
this.pCancelled = true;
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
default:
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Worker_Upload_GetProperty(AsyncCopy.DavCopyTask task)
|
|
{
|
|
int retryminutes = 1;
|
|
while (true)
|
|
{
|
|
this.pCurrentCost = -1L;
|
|
this.pCurrentProgress = 0L;
|
|
this.pCurrentState = AsyncCopy.DavCopyStateType.SearchDirectory;
|
|
this.pCurrentDesc = task.LocalPath;
|
|
try
|
|
{
|
|
if (task.VirtualFileInfo != null)
|
|
{
|
|
if ((task.VirtualFileInfo.Flags & FDFlags.FD_CREATETIME) != (FDFlags) 0)
|
|
task.CreationDate = task.VirtualFileInfo.CreationTime;
|
|
if ((task.VirtualFileInfo.Flags & FDFlags.FD_ACCESSTIME) != (FDFlags) 0)
|
|
task.LastAccessTime = task.VirtualFileInfo.LastAccessTime;
|
|
if ((task.VirtualFileInfo.Flags & FDFlags.FD_WRITESTIME) != (FDFlags) 0)
|
|
task.LastModifiedTime = task.VirtualFileInfo.LastWriteTime;
|
|
task.Size = (task.VirtualFileInfo.Flags & FDFlags.FD_FILESIZE) == (FDFlags) 0 ? -1L : checked ((long) task.VirtualFileInfo.FileSize);
|
|
task.IsCollection = task.VirtualFileInfo.IStreamCreator == null;
|
|
task.State = AsyncCopy.TaskStateType.PropertyAcquired;
|
|
break;
|
|
}
|
|
if (File.Exists(task.LocalPath))
|
|
{
|
|
System.IO.FileInfo fileInfo = new System.IO.FileInfo(task.LocalPath);
|
|
task.Size = fileInfo.Length;
|
|
task.LastModifiedTime = fileInfo.LastWriteTime;
|
|
task.IsCollection = false;
|
|
task.CreationDate = fileInfo.CreationTime;
|
|
task.LastAccessTime = fileInfo.LastAccessTime;
|
|
task.State = AsyncCopy.TaskStateType.PropertyAcquired;
|
|
break;
|
|
}
|
|
if (Directory.Exists(task.LocalPath))
|
|
{
|
|
DirectoryInfo directoryInfo = new DirectoryInfo(task.LocalPath);
|
|
task.Size = 0L;
|
|
task.LastModifiedTime = directoryInfo.LastWriteTime;
|
|
task.IsCollection = true;
|
|
task.CreationDate = directoryInfo.CreationTime;
|
|
task.LastAccessTime = directoryInfo.LastAccessTime;
|
|
task.State = AsyncCopy.TaskStateType.PropertyAcquired;
|
|
FileSystemInfo[] fileSystemInfos = directoryInfo.GetFileSystemInfos();
|
|
int index = 0;
|
|
while (index < fileSystemInfos.Length)
|
|
{
|
|
FileSystemInfo fileSystemInfo = fileSystemInfos[index];
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
this.pTaskList.AddLast(new AsyncCopy.DavCopyTask(task, fileSystemInfo.FullName));
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
checked { ++index; }
|
|
}
|
|
break;
|
|
}
|
|
task.State = AsyncCopy.TaskStateType.Skipped;
|
|
break;
|
|
}
|
|
catch (Exception ex1)
|
|
{
|
|
ProjectData.SetProjectError(ex1);
|
|
Exception ex2 = ex1;
|
|
ExceptionOccurredEventArgs e = new ExceptionOccurredEventArgs("Error occurred during reading file property.", task.LocalPath, ErrorPromptType.IgnoreAllIgnoreRetryCancel, ex2, retryminutes);
|
|
EventHandler<ExceptionOccurredEventArgs> exceptionOccurredEvent = this.ExceptionOccurredEvent;
|
|
if (exceptionOccurredEvent != null)
|
|
exceptionOccurredEvent((object) this, e);
|
|
switch (e.Result.Action)
|
|
{
|
|
case ErrorAction.Ignore:
|
|
task.State = AsyncCopy.TaskStateType.ErrorIgnore;
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
case ErrorAction.Retry:
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.AutoRetry:
|
|
checked { retryminutes *= 2; }
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.Cancel:
|
|
this.pCancelled = true;
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
default:
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Worker_Upload_ConfirmFolder(AsyncCopy.DavCopyTask task)
|
|
{
|
|
int namecount = 0;
|
|
int retryminutes = 1;
|
|
while (true)
|
|
{
|
|
string name = task.CalcRemoteUriForUpload(this.pUploadFilenameNormalization, namecount);
|
|
this.pCurrentCost = -1L;
|
|
this.pCurrentProgress = 0L;
|
|
this.pCurrentState = AsyncCopy.DavCopyStateType.MakingCollection;
|
|
this.pCurrentDesc = task.GetUploadFileName(name);
|
|
try
|
|
{
|
|
ResourceInfo ri;
|
|
try
|
|
{
|
|
ri = this.pCache.GetInfo(this.pFS, task.BaseRemoteId, name, false);
|
|
}
|
|
catch (RemoteResourceNotFoundException ex)
|
|
{
|
|
ProjectData.SetProjectError((Exception) ex);
|
|
ri = (ResourceInfo) null;
|
|
ProjectData.ClearProjectError();
|
|
}
|
|
ConflictType type;
|
|
ResourceId resourceId;
|
|
if (ri == null)
|
|
{
|
|
type = ConflictType.NoConfliction;
|
|
resourceId = (ResourceId) null;
|
|
}
|
|
else
|
|
{
|
|
if (namecount > 0)
|
|
{
|
|
checked { ++namecount; }
|
|
continue;
|
|
}
|
|
if (ri.IsCollection)
|
|
{
|
|
type = ConflictType.FolderToFolder;
|
|
resourceId = ri.Id;
|
|
}
|
|
else
|
|
{
|
|
type = ConflictType.FolderToFile;
|
|
resourceId = ri.Id;
|
|
}
|
|
}
|
|
ConflictAction conflictAction;
|
|
if (type == ConflictType.NoConfliction)
|
|
{
|
|
conflictAction = ConflictAction.NoConfliction;
|
|
}
|
|
else
|
|
{
|
|
AsyncCopy.CopyConflictedEventArgs e = new AsyncCopy.CopyConflictedEventArgs(new SimpleResourceInfo(task.LocalPath, task.Size, task.LastModifiedTime, true), new SimpleResourceInfo(ri), type, (this.pFS.Ability & FsAbility.PartialWrite) != FsAbility.None, this.pFS.Ability, retryminutes);
|
|
EventHandler<AsyncCopy.CopyConflictedEventArgs> conflictionOccurredEvent = this.ConflictionOccurredEvent;
|
|
if (conflictionOccurredEvent != null)
|
|
conflictionOccurredEvent((object) this, e);
|
|
conflictAction = e.Result.Action;
|
|
}
|
|
switch (conflictAction)
|
|
{
|
|
case ConflictAction.NoConfliction:
|
|
ReturnedInfo collection1 = this.pCache.CreateCollection(this.pFS, task.BaseRemoteId, name);
|
|
ResourceInfo resourceInfo1 = collection1 as ResourceInfo;
|
|
resourceId = resourceInfo1 == null ? (ResourceId) collection1 : resourceInfo1.Id;
|
|
goto case ConflictAction.Integrate;
|
|
case ConflictAction.Integrate:
|
|
task.RemoteId = resourceId;
|
|
task.State = AsyncCopy.TaskStateType.FolderConfirmed;
|
|
return;
|
|
case ConflictAction.DeleteTarget:
|
|
this.pCache.Delete(this.pFS, ri.Id);
|
|
ReturnedInfo collection2 = this.pCache.CreateCollection(this.pFS, task.BaseRemoteId, name);
|
|
ResourceInfo resourceInfo2 = collection2 as ResourceInfo;
|
|
resourceId = resourceInfo2 == null ? (ResourceId) collection2 : resourceInfo2.Id;
|
|
goto case ConflictAction.Integrate;
|
|
case ConflictAction.Retry:
|
|
continue;
|
|
case ConflictAction.AutoRetry:
|
|
checked { retryminutes *= 2; }
|
|
continue;
|
|
case ConflictAction.ChangeName:
|
|
checked { ++namecount; }
|
|
continue;
|
|
case ConflictAction.Skip:
|
|
LinkedList<AsyncCopy.DavCopyTask> linkedList = new LinkedList<AsyncCopy.DavCopyTask>();
|
|
linkedList.AddLast(task);
|
|
while (linkedList.Count > 0)
|
|
{
|
|
AsyncCopy.DavCopyTask davCopyTask1 = linkedList.First.Value;
|
|
linkedList.RemoveFirst();
|
|
davCopyTask1.State = AsyncCopy.TaskStateType.Skipped;
|
|
AsyncCopy.DavCopyTask[] subTasks = davCopyTask1.SubTasks;
|
|
int index = 0;
|
|
while (index < subTasks.Length)
|
|
{
|
|
AsyncCopy.DavCopyTask davCopyTask2 = subTasks[index];
|
|
linkedList.AddLast(davCopyTask2);
|
|
checked { ++index; }
|
|
}
|
|
}
|
|
return;
|
|
case ConflictAction.CancelAll:
|
|
this.pCancelled = true;
|
|
return;
|
|
default:
|
|
throw new InvalidOperationException();
|
|
}
|
|
}
|
|
catch (Exception ex1)
|
|
{
|
|
ProjectData.SetProjectError(ex1);
|
|
Exception ex2 = ex1;
|
|
this.pFS.ResetConnection();
|
|
ExceptionOccurredEventArgs e = new ExceptionOccurredEventArgs("Error occurred during confirming collection.", task.GetUploadFileName(name), ErrorPromptType.IgnoreAllIgnoreRetryCancel, ex2, retryminutes);
|
|
EventHandler<ExceptionOccurredEventArgs> exceptionOccurredEvent = this.ExceptionOccurredEvent;
|
|
if (exceptionOccurredEvent != null)
|
|
exceptionOccurredEvent((object) this, e);
|
|
switch (e.Result.Action)
|
|
{
|
|
case ErrorAction.Ignore:
|
|
LinkedList<AsyncCopy.DavCopyTask> linkedList = new LinkedList<AsyncCopy.DavCopyTask>();
|
|
linkedList.AddLast(task);
|
|
while (linkedList.Count > 0)
|
|
{
|
|
AsyncCopy.DavCopyTask davCopyTask1 = linkedList.First.Value;
|
|
linkedList.RemoveFirst();
|
|
davCopyTask1.State = AsyncCopy.TaskStateType.ErrorIgnore;
|
|
AsyncCopy.DavCopyTask[] subTasks = davCopyTask1.SubTasks;
|
|
int index = 0;
|
|
while (index < subTasks.Length)
|
|
{
|
|
AsyncCopy.DavCopyTask davCopyTask2 = subTasks[index];
|
|
linkedList.AddLast(davCopyTask2);
|
|
checked { ++index; }
|
|
}
|
|
}
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
case ErrorAction.Retry:
|
|
namecount = 0;
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.AutoRetry:
|
|
namecount = 0;
|
|
checked { retryminutes *= 2; }
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.Cancel:
|
|
this.pCancelled = true;
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
default:
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Worker_Upload_UploadFile(AsyncCopy.DavCopyTask task)
|
|
{
|
|
int namecount = 0;
|
|
int retryminutes = 1;
|
|
while (true)
|
|
{
|
|
string name = task.CalcRemoteUriForUpload(this.pUploadFilenameNormalization, namecount);
|
|
this.pCurrentCost = -1L;
|
|
this.pCurrentProgress = 0L;
|
|
this.pCurrentState = AsyncCopy.DavCopyStateType.UploadFile;
|
|
this.pCurrentDesc = task.GetUploadFileName(name);
|
|
try
|
|
{
|
|
long start = 0;
|
|
ResourceInfo ri;
|
|
try
|
|
{
|
|
ri = this.pCache.GetInfo(this.pFS, task.BaseRemoteId, name, false);
|
|
}
|
|
catch (RemoteResourceNotFoundException ex)
|
|
{
|
|
ProjectData.SetProjectError((Exception) ex);
|
|
ri = (ResourceInfo) null;
|
|
ProjectData.ClearProjectError();
|
|
}
|
|
ConflictType type;
|
|
if (ri == null)
|
|
{
|
|
type = ConflictType.NoConfliction;
|
|
}
|
|
else
|
|
{
|
|
if (namecount > 0)
|
|
{
|
|
checked { ++namecount; }
|
|
continue;
|
|
}
|
|
type = !ri.IsCollection ? ConflictType.FileToFile : ConflictType.FileToFolder;
|
|
}
|
|
ConflictAction conflictAction;
|
|
if (type == ConflictType.NoConfliction)
|
|
{
|
|
conflictAction = ConflictAction.NoConfliction;
|
|
}
|
|
else
|
|
{
|
|
AsyncCopy.CopyConflictedEventArgs e = new AsyncCopy.CopyConflictedEventArgs(new SimpleResourceInfo(task.LocalPath, task.Size, task.LastModifiedTime, true), new SimpleResourceInfo(ri), type, (this.pFS.Ability & FsAbility.PartialWrite) != FsAbility.None, this.pFS.Ability, retryminutes);
|
|
EventHandler<AsyncCopy.CopyConflictedEventArgs> conflictionOccurredEvent = this.ConflictionOccurredEvent;
|
|
if (conflictionOccurredEvent != null)
|
|
conflictionOccurredEvent((object) this, e);
|
|
conflictAction = e.Result.Action;
|
|
}
|
|
switch (conflictAction)
|
|
{
|
|
case ConflictAction.NoConfliction:
|
|
case ConflictAction.Overwrite:
|
|
if (ri != null)
|
|
task.RemoteId = ri.Id;
|
|
byte[] buffer = new byte[131072];
|
|
DateTime now = DateTime.Now;
|
|
long size = task.Size;
|
|
while (true)
|
|
{
|
|
try
|
|
{
|
|
this.pCurrentCost = size;
|
|
this.pCurrentProgress = 0L;
|
|
this.pCurrentState = AsyncCopy.DavCopyStateType.UploadFile;
|
|
using (Stream stream1 = task.VirtualFileInfo == null ? (Stream) File.OpenRead(task.LocalPath) : task.VirtualFileInfo.ManageStream)
|
|
{
|
|
Stream st;
|
|
if (start == 0L)
|
|
{
|
|
st = (object) task.RemoteId == null ? this.pCache.OpenWrite(this.pFS, task.BaseRemoteId, name, size) : this.pCache.OpenWriteOver(this.pFS, task.RemoteId, size);
|
|
}
|
|
else
|
|
{
|
|
if (size >= 0L)
|
|
checked { size -= start; }
|
|
st = this.pCache.OpenWriteResume(this.pFS, task.RemoteId, ref start, ref size);
|
|
stream1.Seek(start, SeekOrigin.Begin);
|
|
this.pCurrentCost = size;
|
|
}
|
|
using (Stream stream2 = st)
|
|
{
|
|
while (true)
|
|
{
|
|
object pLock = this.pLock;
|
|
ObjectFlowControl.CheckForSyncLockOnValueType(pLock);
|
|
Monitor.Enter(pLock);
|
|
try
|
|
{
|
|
if (this.pWorkerState == 2)
|
|
{
|
|
this.pCancelled = true;
|
|
stream2.Close();
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(pLock);
|
|
}
|
|
int count = stream1.Read(buffer, 0, buffer.Length);
|
|
if (count != 0)
|
|
{
|
|
stream2.Write(buffer, 0, count);
|
|
this.pCurrentProgress = checked (this.pCurrentProgress + (long) count);
|
|
this.pCurrentSeconds = DateTime.Now.Subtract(now).TotalSeconds;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
ReturnedInfo returnedInfo = this.pCache.CloseWrite(this.pFS, st);
|
|
ResourceInfo resourceInfo = returnedInfo as ResourceInfo;
|
|
task.RemoteId = resourceInfo == null ? returnedInfo as ResourceId : resourceInfo.Id;
|
|
break;
|
|
}
|
|
}
|
|
catch (UnauthorizedException ex)
|
|
{
|
|
ProjectData.SetProjectError((Exception) ex);
|
|
this.pFS.ResetConnection();
|
|
WebdavFs pFs = this.pFS as WebdavFs;
|
|
if (pFs == null)
|
|
throw;
|
|
else if (pFs.SendEmptyPUT)
|
|
{
|
|
throw;
|
|
}
|
|
else
|
|
{
|
|
pFs.SendEmptyPUT = true;
|
|
ProjectData.ClearProjectError();
|
|
}
|
|
}
|
|
}
|
|
if ((this.pFS.Ability & FsAbility.Times) != FsAbility.None)
|
|
{
|
|
DateTime lastmodifiedtime = DateTime.MinValue;
|
|
DateTime creationtime = DateTime.MinValue;
|
|
DateTime lastaccesstime = DateTime.MinValue;
|
|
if ((this.pFS.Ability & FsAbility.LastModifiedTime) != FsAbility.None)
|
|
lastmodifiedtime = task.LastModifiedTime;
|
|
if ((this.pFS.Ability & FsAbility.CreationTime) != FsAbility.None)
|
|
creationtime = task.CreationDate;
|
|
if ((this.pFS.Ability & FsAbility.LastAccessTime) != FsAbility.None)
|
|
lastaccesstime = task.LastAccessTime;
|
|
this.pCache.SetTimes(this.pFS, task.RemoteId, lastmodifiedtime, creationtime, lastaccesstime);
|
|
}
|
|
if (this.pCurrentCost >= 0L)
|
|
{
|
|
if (this.pCurrentProgress < this.pCurrentCost)
|
|
throw new ApplicationException("Cannot send whole contents. Resource may be changed.");
|
|
if (this.pCurrentProgress > this.pCurrentCost)
|
|
throw new ApplicationException("Send stream is too long. Resource may be changed.");
|
|
}
|
|
task.FinishTask();
|
|
goto label_83;
|
|
case ConflictAction.OverwriteNewer:
|
|
if (DateTime.Compare(ri.LastModifiedTime.AddSeconds(1.0), File.GetLastWriteTime(task.LocalPath)) >= 0)
|
|
{
|
|
task.State = AsyncCopy.TaskStateType.Skipped;
|
|
goto label_83;
|
|
}
|
|
else
|
|
goto case ConflictAction.NoConfliction;
|
|
case ConflictAction.Resume:
|
|
if (ri.Size < 0L || task.Size < 0L)
|
|
throw new InvalidOperationException("Cannot Resume.");
|
|
if (ri.Size >= task.Size)
|
|
{
|
|
task.State = AsyncCopy.TaskStateType.Skipped;
|
|
goto label_83;
|
|
}
|
|
else
|
|
{
|
|
start = ri.Size;
|
|
if (start < 0L)
|
|
{
|
|
start = 0L;
|
|
goto case ConflictAction.NoConfliction;
|
|
}
|
|
else
|
|
goto case ConflictAction.NoConfliction;
|
|
}
|
|
case ConflictAction.DeleteTarget:
|
|
this.pCache.Delete(this.pFS, ri.Id);
|
|
ri = (ResourceInfo) null;
|
|
goto case ConflictAction.NoConfliction;
|
|
case ConflictAction.Retry:
|
|
continue;
|
|
case ConflictAction.AutoRetry:
|
|
checked { retryminutes *= 2; }
|
|
continue;
|
|
case ConflictAction.ChangeName:
|
|
checked { ++namecount; }
|
|
continue;
|
|
case ConflictAction.Skip:
|
|
task.State = AsyncCopy.TaskStateType.Skipped;
|
|
goto label_83;
|
|
case ConflictAction.CancelAll:
|
|
this.pCancelled = true;
|
|
return;
|
|
default:
|
|
throw new InvalidOperationException();
|
|
}
|
|
}
|
|
catch (Exception ex1)
|
|
{
|
|
ProjectData.SetProjectError(ex1);
|
|
Exception ex2 = ex1;
|
|
this.pFS.ResetConnection();
|
|
if (this.pCancelled)
|
|
{
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
}
|
|
ExceptionOccurredEventArgs e = new ExceptionOccurredEventArgs("Error occurred during uploading resource.", task.GetUploadFileName(name), ErrorPromptType.IgnoreAllIgnoreRetryCancel, ex2, retryminutes);
|
|
EventHandler<ExceptionOccurredEventArgs> exceptionOccurredEvent = this.ExceptionOccurredEvent;
|
|
if (exceptionOccurredEvent != null)
|
|
exceptionOccurredEvent((object) this, e);
|
|
switch (e.Result.Action)
|
|
{
|
|
case ErrorAction.Ignore:
|
|
task.State = AsyncCopy.TaskStateType.ErrorIgnore;
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
case ErrorAction.Retry:
|
|
namecount = 0;
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.AutoRetry:
|
|
namecount = 0;
|
|
checked { retryminutes *= 2; }
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.Cancel:
|
|
this.pCancelled = true;
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
default:
|
|
ProjectData.ClearProjectError();
|
|
goto label_83;
|
|
}
|
|
}
|
|
}
|
|
label_83:
|
|
task.TransferSeconds = this.pCurrentSeconds;
|
|
this.pTotalTransferSeconds = this.pTotalTransferSeconds + this.pCurrentSeconds;
|
|
this.pCurrentSeconds = 0.0;
|
|
if (task.State == AsyncCopy.TaskStateType.Skipped)
|
|
{
|
|
this.pCurrentProgress = 0L;
|
|
this.pCurrentCost = 0L;
|
|
}
|
|
else
|
|
{
|
|
if (this.pTotalProgress < 0L)
|
|
return;
|
|
this.pTotalProgress = checked (this.pTotalProgress + this.pCurrentProgress);
|
|
this.pCurrentProgress = 0L;
|
|
}
|
|
}
|
|
|
|
private void Worker_Upload_SetFolderProperty(AsyncCopy.DavCopyTask task)
|
|
{
|
|
int retryminutes = 1;
|
|
this.pCurrentCost = -1L;
|
|
this.pCurrentProgress = 0L;
|
|
this.pCurrentState = AsyncCopy.DavCopyStateType.UploadProperty;
|
|
this.pCurrentDesc = task.GetUploadFileName((string) null);
|
|
while (true)
|
|
{
|
|
try
|
|
{
|
|
if ((this.pFS.Ability & FsAbility.Times) != FsAbility.None)
|
|
{
|
|
DateTime lastmodifiedtime = DateTime.MinValue;
|
|
DateTime creationtime = DateTime.MinValue;
|
|
DateTime lastaccesstime = DateTime.MinValue;
|
|
if ((this.pFS.Ability & FsAbility.LastModifiedTime) != FsAbility.None)
|
|
lastmodifiedtime = task.LastModifiedTime;
|
|
if ((this.pFS.Ability & FsAbility.CreationTime) != FsAbility.None)
|
|
creationtime = task.CreationDate;
|
|
if ((this.pFS.Ability & FsAbility.LastAccessTime) != FsAbility.None)
|
|
lastaccesstime = task.LastAccessTime;
|
|
this.pCache.SetTimes(this.pFS, task.RemoteId, lastmodifiedtime, creationtime, lastaccesstime);
|
|
}
|
|
task.FinishTask();
|
|
break;
|
|
}
|
|
catch (Exception ex1)
|
|
{
|
|
ProjectData.SetProjectError(ex1);
|
|
Exception ex2 = ex1;
|
|
this.pFS.ResetConnection();
|
|
ExceptionOccurredEventArgs e = new ExceptionOccurredEventArgs("Error occurred during updating collection property.", task.GetUploadFileName((string) null), ErrorPromptType.IgnoreAllIgnoreRetryCancel, ex2, retryminutes);
|
|
EventHandler<ExceptionOccurredEventArgs> exceptionOccurredEvent = this.ExceptionOccurredEvent;
|
|
if (exceptionOccurredEvent != null)
|
|
exceptionOccurredEvent((object) this, e);
|
|
switch (e.Result.Action)
|
|
{
|
|
case ErrorAction.Ignore:
|
|
task.State = AsyncCopy.TaskStateType.ErrorIgnore;
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
case ErrorAction.Retry:
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.AutoRetry:
|
|
checked { retryminutes *= 2; }
|
|
ProjectData.ClearProjectError();
|
|
continue;
|
|
case ErrorAction.Cancel:
|
|
this.pCancelled = true;
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
default:
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ServerResourceChangedCallback(object state)
|
|
{
|
|
this.OnServerResourceChanged((ResourceChangedEventArgs) state);
|
|
}
|
|
|
|
private void DavCopyCompletedCallback(object state)
|
|
{
|
|
this.OnDavCopyCompleted((AsyncCompletedEventArgs) state);
|
|
}
|
|
|
|
private void AsyncCopy_Disposed(object sender, EventArgs e)
|
|
{
|
|
if (this.pFS == null)
|
|
return;
|
|
this.pFS.ResetConnection();
|
|
}
|
|
|
|
private void SetTimes(string path, DateTime lastmodifiedtime, DateTime creationtime, DateTime lastaccesstime)
|
|
{
|
|
FileSystem.SetFileTime(path, creationtime, lastaccesstime, lastmodifiedtime);
|
|
}
|
|
|
|
private delegate void DavCopyWorkerDelegate(AsyncOperation asyncop);
|
|
|
|
public class DavCopyCompletedEventArgs : AsyncCompletedEventArgs
|
|
{
|
|
private long pTotalBytes;
|
|
private TimeSpan pTotalTime;
|
|
private long pTransferBytes;
|
|
|
|
public DavCopyCompletedEventArgs(Exception error, bool cancelled, long total, long transfer, TimeSpan totaltime)
|
|
: base(error, cancelled, (object) null)
|
|
{
|
|
this.pTotalBytes = total;
|
|
this.pTransferBytes = transfer;
|
|
this.pTotalTime = this.pTotalTime;
|
|
}
|
|
|
|
public long TotalBytes
|
|
{
|
|
get
|
|
{
|
|
return this.pTotalBytes;
|
|
}
|
|
}
|
|
|
|
public long TransferBytes
|
|
{
|
|
get
|
|
{
|
|
return this.pTransferBytes;
|
|
}
|
|
}
|
|
|
|
public TimeSpan TotalTime
|
|
{
|
|
get
|
|
{
|
|
return this.pTotalTime;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class CopyConflictedEventArgs : EventArgs
|
|
{
|
|
private SimpleResourceInfo pSource;
|
|
private SimpleResourceInfo pDestination;
|
|
private ConflictType pType;
|
|
private ConflictPromptFormResult pResult;
|
|
private bool pEnableResume;
|
|
private FsAbility pDestinationAbility;
|
|
private int pRetryMinutes;
|
|
|
|
public CopyConflictedEventArgs(SimpleResourceInfo source, SimpleResourceInfo destination, ConflictType type, bool enableresume, FsAbility destability, int retryminutes)
|
|
{
|
|
this.pSource = source;
|
|
this.pDestination = destination;
|
|
this.pType = type;
|
|
this.pResult = new ConflictPromptFormResult();
|
|
this.pResult.ToAll = false;
|
|
this.pResult.Action = ConflictAction.Skip;
|
|
this.pEnableResume = enableresume;
|
|
this.pDestinationAbility = destability;
|
|
this.pRetryMinutes = retryminutes;
|
|
}
|
|
|
|
public SimpleResourceInfo Source
|
|
{
|
|
get
|
|
{
|
|
return this.pSource;
|
|
}
|
|
}
|
|
|
|
public SimpleResourceInfo Destination
|
|
{
|
|
get
|
|
{
|
|
return this.pDestination;
|
|
}
|
|
}
|
|
|
|
public ConflictType Type
|
|
{
|
|
get
|
|
{
|
|
return this.pType;
|
|
}
|
|
}
|
|
|
|
public bool EnableResume
|
|
{
|
|
get
|
|
{
|
|
return this.pEnableResume;
|
|
}
|
|
}
|
|
|
|
public FsAbility DestinationAbility
|
|
{
|
|
get
|
|
{
|
|
return this.pDestinationAbility;
|
|
}
|
|
}
|
|
|
|
public ConflictPromptFormResult Result
|
|
{
|
|
get
|
|
{
|
|
return this.pResult;
|
|
}
|
|
set
|
|
{
|
|
this.pResult = value;
|
|
}
|
|
}
|
|
|
|
public int RetryMinutes
|
|
{
|
|
get
|
|
{
|
|
return this.pRetryMinutes;
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum DavCopyStateType
|
|
{
|
|
DownloadProperty,
|
|
ConfirmFolder,
|
|
SetFolderAttribute,
|
|
ConfirmFile,
|
|
DownloadFile,
|
|
SearchDirectory,
|
|
MakingCollection,
|
|
UploadFile,
|
|
UploadProperty,
|
|
Finished,
|
|
}
|
|
|
|
public class StateContainer
|
|
{
|
|
public AsyncCopy.DavCopyStateType CurrentState;
|
|
public long TotalCost;
|
|
public long TotalProgress;
|
|
public double TotalSeconds;
|
|
public long CurrentCost;
|
|
public long CurrentProgress;
|
|
public double CurrentSeconds;
|
|
public string CurrentDesc;
|
|
public long TotalFiles;
|
|
public long TotalFolders;
|
|
public long CurrentFiles;
|
|
public long CurrentFolders;
|
|
}
|
|
|
|
private enum TaskType
|
|
{
|
|
Download,
|
|
Upload,
|
|
}
|
|
|
|
private enum TaskStateType
|
|
{
|
|
Initialized,
|
|
PropertyAcquired,
|
|
FolderConfirmed,
|
|
Complete,
|
|
Skipped,
|
|
ErrorIgnore,
|
|
}
|
|
|
|
private class DavCopyTask
|
|
{
|
|
private AsyncCopy.DavCopyTask pParentTask;
|
|
private List<AsyncCopy.DavCopyTask> pSubTasks;
|
|
private AsyncCopy.TaskType pTaskType;
|
|
private Dictionary<Uri, bool> pUriDic;
|
|
private string pLocalPath;
|
|
private VirtualFileInfo pvirtualfileinfo;
|
|
private ResourceId pRemoteId;
|
|
private string pBaseLocalPath;
|
|
private ResourceId pBaseRemoteId;
|
|
public AsyncCopy.TaskStateType State;
|
|
public double TransferSeconds;
|
|
public long Size;
|
|
public DateTime LastModifiedTime;
|
|
public bool IsCollection;
|
|
public DateTime CreationDate;
|
|
public DateTime LastAccessTime;
|
|
public ResourceInfo Info;
|
|
internal IDataObject DataObject;
|
|
internal DragDropEffects FinishEffect;
|
|
|
|
public AsyncCopy.TaskType TaskType
|
|
{
|
|
get
|
|
{
|
|
return this.pTaskType;
|
|
}
|
|
}
|
|
|
|
public AsyncCopy.DavCopyTask ParentTask
|
|
{
|
|
get
|
|
{
|
|
return this.pParentTask;
|
|
}
|
|
}
|
|
|
|
public AsyncCopy.DavCopyTask[] SubTasks
|
|
{
|
|
get
|
|
{
|
|
return this.pSubTasks.ToArray();
|
|
}
|
|
}
|
|
|
|
public bool IsRootTask
|
|
{
|
|
get
|
|
{
|
|
return this.pParentTask == null;
|
|
}
|
|
}
|
|
|
|
public Dictionary<Uri, bool> UriDic
|
|
{
|
|
get
|
|
{
|
|
return this.pUriDic;
|
|
}
|
|
}
|
|
|
|
public string LocalPath
|
|
{
|
|
get
|
|
{
|
|
return this.pLocalPath;
|
|
}
|
|
set
|
|
{
|
|
this.pLocalPath = value;
|
|
}
|
|
}
|
|
|
|
public ResourceId RemoteId
|
|
{
|
|
get
|
|
{
|
|
return this.pRemoteId;
|
|
}
|
|
set
|
|
{
|
|
this.pRemoteId = value;
|
|
}
|
|
}
|
|
|
|
public string BaseLocalPath
|
|
{
|
|
get
|
|
{
|
|
if (this.IsRootTask)
|
|
return this.pBaseLocalPath;
|
|
return this.pParentTask.pLocalPath;
|
|
}
|
|
}
|
|
|
|
public ResourceId BaseRemoteId
|
|
{
|
|
get
|
|
{
|
|
if (this.IsRootTask)
|
|
return this.pBaseRemoteId;
|
|
return this.pParentTask.pRemoteId;
|
|
}
|
|
}
|
|
|
|
public VirtualFileInfo VirtualFileInfo
|
|
{
|
|
get
|
|
{
|
|
return this.pvirtualfileinfo;
|
|
}
|
|
}
|
|
|
|
internal DavCopyTask(AsyncCopy.TaskType type, ResourceId remoteid, string localpath_1)
|
|
{
|
|
this.pSubTasks = new List<AsyncCopy.DavCopyTask>();
|
|
this.pParentTask = (AsyncCopy.DavCopyTask) null;
|
|
this.pTaskType = type;
|
|
this.pUriDic = new Dictionary<Uri, bool>();
|
|
this.State = AsyncCopy.TaskStateType.Initialized;
|
|
if (this.pTaskType == AsyncCopy.TaskType.Download)
|
|
{
|
|
this.pBaseLocalPath = localpath_1;
|
|
this.pRemoteId = remoteid;
|
|
this.pLocalPath = (string) null;
|
|
}
|
|
else
|
|
{
|
|
if (this.pTaskType != AsyncCopy.TaskType.Upload)
|
|
throw new Exception();
|
|
this.pBaseRemoteId = remoteid;
|
|
this.pLocalPath = localpath_1;
|
|
this.pRemoteId = (ResourceId) null;
|
|
this.pvirtualfileinfo = (VirtualFileInfo) null;
|
|
}
|
|
}
|
|
|
|
internal DavCopyTask(AsyncCopy.TaskType type, ResourceId remoteid, VirtualFileInfo vfinfo)
|
|
{
|
|
this.pSubTasks = new List<AsyncCopy.DavCopyTask>();
|
|
this.pParentTask = (AsyncCopy.DavCopyTask) null;
|
|
this.pTaskType = type;
|
|
this.pUriDic = new Dictionary<Uri, bool>();
|
|
this.State = AsyncCopy.TaskStateType.Initialized;
|
|
this.pBaseRemoteId = remoteid;
|
|
this.pLocalPath = vfinfo.FileName;
|
|
this.pvirtualfileinfo = vfinfo;
|
|
this.pRemoteId = (ResourceId) null;
|
|
}
|
|
|
|
internal DavCopyTask(AsyncCopy.DavCopyTask parenttask, ResourceId id)
|
|
{
|
|
this.pSubTasks = new List<AsyncCopy.DavCopyTask>();
|
|
this.pParentTask = parenttask;
|
|
this.pParentTask.pSubTasks.Add(this);
|
|
this.pTaskType = this.pParentTask.TaskType;
|
|
this.pUriDic = this.pParentTask.UriDic;
|
|
this.State = AsyncCopy.TaskStateType.Initialized;
|
|
this.pLocalPath = (string) null;
|
|
this.pRemoteId = id;
|
|
}
|
|
|
|
public string CalcLocalPathForDownload(UCSNormalization normalization, int namecount)
|
|
{
|
|
string path = UriUtil.GetLastName(this.pRemoteId.Uri);
|
|
if (namecount > 0)
|
|
path = Path.GetFileNameWithoutExtension(path) + " (" + namecount.ToString() + ")." + Path.GetExtension(path);
|
|
if (normalization != UCSNormalization.None)
|
|
path = path.Normalize((NormalizationForm) normalization);
|
|
return path;
|
|
}
|
|
|
|
internal DavCopyTask(AsyncCopy.DavCopyTask parenttask, string filepath)
|
|
{
|
|
this.pSubTasks = new List<AsyncCopy.DavCopyTask>();
|
|
this.pParentTask = parenttask;
|
|
this.pParentTask.pSubTasks.Add(this);
|
|
this.pTaskType = this.pParentTask.TaskType;
|
|
this.pUriDic = this.pParentTask.UriDic;
|
|
this.State = AsyncCopy.TaskStateType.Initialized;
|
|
this.pLocalPath = filepath;
|
|
this.pRemoteId = (ResourceId) null;
|
|
}
|
|
|
|
internal DavCopyTask(AsyncCopy.DavCopyTask parenttask, string filepath, VirtualFileInfo vfinfo)
|
|
{
|
|
this.pSubTasks = new List<AsyncCopy.DavCopyTask>();
|
|
this.pParentTask = parenttask;
|
|
this.pParentTask.pSubTasks.Add(this);
|
|
this.pTaskType = this.pParentTask.TaskType;
|
|
this.pUriDic = this.pParentTask.UriDic;
|
|
this.State = AsyncCopy.TaskStateType.Initialized;
|
|
this.pLocalPath = filepath;
|
|
this.pvirtualfileinfo = vfinfo;
|
|
this.pRemoteId = (ResourceId) null;
|
|
}
|
|
|
|
public string CalcRemoteUriForUpload(UCSNormalization normalization, int namecount)
|
|
{
|
|
string path = Path.GetFileName(this.pLocalPath);
|
|
if (namecount > 0)
|
|
path = Path.GetFileNameWithoutExtension(path) + " (" + namecount.ToString() + ")." + Path.GetExtension(path);
|
|
if (normalization != UCSNormalization.None)
|
|
path = path.Normalize((NormalizationForm) normalization);
|
|
return path;
|
|
}
|
|
|
|
public string GetDownloadFileName()
|
|
{
|
|
return this.RemoteId.Uri.ToString();
|
|
}
|
|
|
|
public string GetUploadFileName(string name = null)
|
|
{
|
|
if (string.IsNullOrEmpty(name))
|
|
return this.BaseRemoteId.Uri.ToString();
|
|
return UriUtil.CombineName(this.BaseRemoteId.Uri, name).ToString();
|
|
}
|
|
|
|
public void FinishTask()
|
|
{
|
|
this.State = AsyncCopy.TaskStateType.Complete;
|
|
if (this.DataObject != null)
|
|
{
|
|
DataObjectHelper.SetPerformedDragEffect(this.DataObject, this.FinishEffect);
|
|
DataObjectHelper.SetLogicalPerformedDragEffect(this.DataObject, this.FinishEffect);
|
|
if (this.FinishEffect == DragDropEffects.Move)
|
|
DataObjectHelper.SetPasteSucceeded(this.DataObject, this.FinishEffect);
|
|
DataObjectHelper.EndAsyncOperation(this.DataObject, this.FinishEffect);
|
|
this.DataObject = (IDataObject) null;
|
|
}
|
|
if (this.pvirtualfileinfo == null)
|
|
return;
|
|
if (this.pvirtualfileinfo.IStreamCreator != null)
|
|
{
|
|
this.pvirtualfileinfo.IStreamCreator.Dispose();
|
|
this.pvirtualfileinfo.IStreamCreator = (IStreamCreator) null;
|
|
}
|
|
if (this.pvirtualfileinfo.ManageStream != null)
|
|
{
|
|
this.pvirtualfileinfo.ManageStream.Dispose();
|
|
this.pvirtualfileinfo.ManageStream = (Stream) null;
|
|
}
|
|
this.pvirtualfileinfo = (VirtualFileInfo) null;
|
|
}
|
|
}
|
|
}
|
|
}
|