/// <summary>
/// since files has been transferred, mark the job as completed
/// </summary>
public void Complete()
{
CheckError(delegate
{
_progressWatch.Stop();
_job.Complete();
});
}
public void Complete()
{
copyJob.Complete();
}
/// <summary>
/// 检查/启动/结束传输作业进程,参数文件节点为空的取当前文件节点
/// </summary>
/// <param name="nodeFile">要管理的传输文件节点</param>
static private void HandleBits(Object o)
{
IBackgroundCopyManager bcm = null;
IBackgroundCopyJob job = null;
XmlNode nodeFile = null;
nodeFile = BitsFileList.GetCurrentFile();
if (null == nodeFile)
{
return;
}
((XmlElement)nodeFile).SetAttribute("state", "doing");
try
{
// Create BITS object
bcm = (IBackgroundCopyManager) new BackgroundCopyManager();
Guid jobID = Guid.Empty;
if (null != nodeFile.Attributes["jobguid"] && !string.IsNullOrEmpty(nodeFile.Attributes["jobguid"].Value))
{ // Do we already have a job in place?
jobID = new Guid(nodeFile.Attributes["jobguid"].Value);
BG_JOB_STATE state;
try
{
bcm.GetJob(ref jobID, out job); // Get the BITS job object
job.GetState(out state); // check its state
switch (state)
{
case BG_JOB_STATE.BG_JOB_STATE_ERROR: // If it is an error, re-poll
job.Complete();
nodeFile.Attributes.RemoveNamedItem("jobguid");
Marshal.ReleaseComObject(job);
job = null;
break;
case BG_JOB_STATE.BG_JOB_STATE_CANCELLED:
case BG_JOB_STATE.BG_JOB_STATE_TRANSFERRED: // If we got the job
job.Complete(); // then complete it
nodeFile.ParentNode.RemoveChild(nodeFile);
Marshal.ReleaseComObject(job);
Marshal.ReleaseComObject(bcm);
return;
default:
Marshal.ReleaseComObject(bcm);
return;
}
}
catch (Exception e)
{
NameValueCollection errInfo = new NameValueCollection();
errInfo["文件类别"] = nodeFile.Attributes["doctype"].Value;
errInfo["远程文件"] = nodeFile.Attributes["srcurl"].Value;
errInfo["作业Guid"] = nodeFile.Attributes["jobguid"].Value;
ExceptionManager.Publish(e, errInfo);
if (null != (e as UnauthorizedAccessException))
{
if (job != null)
{
Marshal.ReleaseComObject(job);
}
if (bcm != null)
{
Marshal.ReleaseComObject(bcm);
}
return;
}
COMException exCOM = e as COMException;
if (null != exCOM && exCOM.ErrorCode == unchecked ((Int32)0x80200001))
{
nodeFile.Attributes.RemoveNamedItem("jobguid");
}
else
{
return;
}
}
}
// Create a bits job to download the next expected update
if (null != nodeFile && (null == nodeFile.Attributes["jobguid"] || string.IsNullOrEmpty(nodeFile.Attributes["jobguid"].Value)))
{
bcm.CreateJob("下载远程文件",
BG_JOB_TYPE.BG_JOB_TYPE_DOWNLOAD, out jobID, out job);
string doctype = nodeFile.Attributes["doctype"].Value;
string srcurl = nodeFile.Attributes["srcurl"].Value;
string dest = nodeFile.Attributes["localname"].Value;
job.SetDescription("下载文件位置: " + doctype);
job.AddFile(srcurl, dest);
job.Resume(); // start the job in action
((XmlElement)nodeFile).SetAttribute("jobguid", jobID.ToString());
}
if (bcm != null)
{
Marshal.ReleaseComObject(bcm);
}
return;
}
catch { }
}
/// <summary>
/// Method called by BITS when the job is completed.
/// </summary>
/// <param name="task">The Updater task instance.</param>
/// <param name="pJob">The BITS job reeference.</param>
private void OnJobTransferred(DownloadTask task, IBackgroundCopyJob pJob)
{
pJob.Complete();
OnDownloadCompleted(new TaskEventArgs(task));
}
/// <summary>
/// Synchronous downloading method using BITS
/// </summary>
/// <param name="sourceFile">Source file to download</param>
/// <param name="destFile">Target file on the local system</param>
/// <param name="maxTimeWait">Maximum time to wait for a download</param>
void IDownloader.Download(string sourceFile, string destFile, TimeSpan maxTimeWait)
{
IBackgroundCopyManager backGroundCopyManager = null;
IBackgroundCopyJob backGroundCopyJob = null;
Guid jobID = Guid.Empty;
bool isCompleted = false;
bool isSuccessful = false;
string cumulativeErrMessage = "";
BG_JOB_STATE state;
// to defend against config errors, check to see if the path given is UNC;
// if so, throw immediately there's a misconfiguration. Paths to BITS must be HTTP/HTTPS
ThrowIfSourceIsUNC(sourceFile);
try
{
// use utility function to create manager, job, get back jobid etc.; uses 'out' semantics
CreateCopyJob(
out backGroundCopyManager,
out backGroundCopyJob,
ref jobID,
"RES_BITSJobName",
"RES_BITSDescription");
// Add the file to the Job List
backGroundCopyJob.AddFile(sourceFile, destFile);
// Start the Back Ground Copy Job.
backGroundCopyJob.Resume();
// set endtime to current tickcount + allowable # milliseconds to wait for job
int endTime = Environment.TickCount + (int)maxTimeWait.TotalMilliseconds;
#region __While Loop Waits On Single Download__
while (!isCompleted)
{
backGroundCopyJob.GetState(out state);
switch (state)
{
case BG_JOB_STATE.BG_JOB_STATE_ERROR:
{
// use utility to:
// a) get error info
// b) report it
// c) cancel and remove copy job
HandleDownloadErrorCancelJob(backGroundCopyJob, ref cumulativeErrMessage);
// complete loop, but DON'T say it's successful
isCompleted = true;
break;
}
case BG_JOB_STATE.BG_JOB_STATE_TRANSIENT_ERROR:
{
// NOTE: during debugging + test, transient errors resulted in complete job failure about 90%
// of the time. Therefore we treat transients just like full errors, and CANCEL the job
// use utility to manage error etc.
HandleDownloadErrorCancelJob(backGroundCopyJob, ref cumulativeErrMessage);
// stop the loop, set completed to true but not successful
isCompleted = true;
break;
}
case BG_JOB_STATE.BG_JOB_STATE_TRANSFERRED:
{
// notify BITS we're happy, remove from queue and transfer ownership to us:
backGroundCopyJob.Complete();
// remove job from our collection, we won't need to Cancel() in our Dispose()
RemoveCopyJobEntry(jobID);
isCompleted = true;
isSuccessful = true;
break;
}
default:
break;
}
if (endTime < Environment.TickCount)
{
HandleDownloadErrorCancelJob(backGroundCopyJob, ref cumulativeErrMessage);
break;
}
// Avoid 100% CPU utilisation with too tight a loop, let download happen.
Thread.Sleep(TIME_WAIT_SYNCH_DOWNLOAD);
}
#endregion
if (!isSuccessful)
{
// create message + error, package it, publish
string error = ApplicationUpdateManager.TraceWrite(
"[BITSDownloader.Download]",
"RES_MESSAGE_ManifestFileNotDownloaded", sourceFile, cumulativeErrMessage);
Exception ex = new Exception(error + Environment.NewLine + cumulativeErrMessage);
throw ex;
}
}
catch (ThreadInterruptedException tie)
{
// if interrupted, clean up job
HandleDownloadErrorCancelJob(backGroundCopyJob, ref cumulativeErrMessage);
ApplicationUpdateManager.TraceWrite(tie, "[BITSDownloader.Download]", "RES_TIEInBITS", sourceFile);
throw tie;
}
catch (Exception e)
{
// if exception, clean up job
HandleDownloadErrorCancelJob(backGroundCopyJob, ref cumulativeErrMessage);
// then log error
string error = ApplicationUpdateManager.TraceWrite(
e,
"[BITSDownloader.Download]",
"RES_MESSAGE_ManifestFileNotDownloaded", sourceFile, cumulativeErrMessage);
Exception ex = new Exception(error, e);
ExceptionManager.Publish(ex);
// throw; allow consuming class to figure out what to do
throw ex;
}
finally
{
if (null != backGroundCopyJob)
{
Marshal.ReleaseComObject(backGroundCopyJob);
}
if (null != backGroundCopyManager)
{
Marshal.ReleaseComObject(backGroundCopyManager);
}
}
}
/// <summary>
/// returns a job status enum for a particular job identified by its GUID
/// </summary>
/// <param name="jobId">a guid for the job requested</param>
/// <returns>a JobStatus describing the state of the job</returns>
JobStatus IDownloader.GetJobStatus(Guid jobId)
{
IBackgroundCopyManager backGroundCopyManager = null;
IBackgroundCopyJob backGroundCopyJob = null;
BG_JOB_STATE state;
string errMessage = "";
string jobName = "";
string jobDesc = "";
string error = "";
try
{
backGroundCopyManager = (IBackgroundCopyManager) new BackgroundCopyManager();
backGroundCopyManager.GetJob(ref jobId, out backGroundCopyJob);
// get job name
backGroundCopyJob.GetDisplayName(out jobName);
// get job desc
backGroundCopyJob.GetDescription(out jobDesc);
// get job state enum value
backGroundCopyJob.GetState(out state);
switch (state)
{
case BG_JOB_STATE.BG_JOB_STATE_ERROR:
{
// use utility method to handle error:
HandleDownloadErrorCancelJob(backGroundCopyJob, ref errMessage);
// return status as error
return(JobStatus.Error);
}
case BG_JOB_STATE.BG_JOB_STATE_TRANSIENT_ERROR:
{
// NOTE: if transient, just treat as full error. During testing about 90% of transients
// resulted in full failure. Cleanup.
// use utility method to handle error:
HandleDownloadErrorCancelJob(backGroundCopyJob, ref errMessage);
// return status as error
return(JobStatus.Error);
}
case BG_JOB_STATE.BG_JOB_STATE_TRANSFERRED:
{
// tell BITS to transfer to us and stop thinking about the job
backGroundCopyJob.Complete();
// remove job from collection to be Dispose()ed
RemoveCopyJobEntry(jobId);
return(JobStatus.Ready);
}
case BG_JOB_STATE.BG_JOB_STATE_CANCELLED:
{
// use utility method to handle error:
HandleDownloadErrorCancelJob(backGroundCopyJob, ref errMessage);
// return status as cancelled
return(JobStatus.Cancelled);
}
default:
return(JobStatus.Downloading);
}
}
catch (ThreadInterruptedException tie)
{
// if interrupted, clean up job
HandleDownloadErrorCancelJob(backGroundCopyJob, ref errMessage);
ApplicationUpdateManager.TraceWrite(tie, "[BITSDownloader.Download]", "RES_TIEInBITS", "N/A");
throw tie;
}
catch (Exception e)
{
// use utility method to handle error:
HandleDownloadErrorCancelJob(backGroundCopyJob, ref errMessage);
// bad to catch all exceptions, but OK because we adorn it with necessary additional info then pass it up as innerException
error = ApplicationUpdateManager.TraceWrite(e, "[BITSDownloader.GetJobStatus]", "RES_EXCEPTION_BITSOtherError", jobId, jobName, jobDesc);
// publish
Exception newE = new Exception(error, e);
ExceptionManager.Publish(newE);
// rethrow;
throw newE;
}
finally
{
if (backGroundCopyManager != null)
{
Marshal.ReleaseComObject(backGroundCopyManager);
}
if (backGroundCopyJob != null)
{
Marshal.ReleaseComObject(backGroundCopyJob);
}
}
}
internal void CompleteJob( )
{
_job.Complete();
}