/// <summary>
/// Downloads a file by file id from Backblaze B2 Cloud Storage.
/// </summary>
/// <param name="fileId">The unique id of the file to download.</param>
/// <param name="localPath">The relative or absolute path to the file. This string is not case-sensitive.</param>
/// <param name="progress">A progress action which fires every time the write buffer is cycled.</param>
/// <param name="cancel">The cancellation token to cancel operation.</param>
/// <exception cref="AuthenticationException">Thrown when authentication fails.</exception>
/// <exception cref="InvalidHashException">Thrown when a checksum hash is not valid.</exception>
/// <exception cref="ApiException">Thrown when an error occurs during client operation.</exception>
async Task <IApiResults <DownloadFileResponse> > IStorageFiles.DownloadByIdAsync
(string fileId, string localPath, IProgress <ICopyProgress> progress, CancellationToken cancel)
{
if (!Directory.Exists(Path.GetDirectoryName(localPath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(localPath));
}
using (var content = File.Create(localPath))
{
var request = new DownloadFileByIdRequest(fileId);
var results = await _client.DownloadByIdAsync(request, content, progress, cancel);
if (results.IsSuccessStatusCode)
{
var lastModified = results.Response.FileInfo.GetLastModified();
if (lastModified != DateTime.MinValue)
{
File.SetLastWriteTime(localPath, lastModified);
}
}
return(results);
}
}
/// <summary>
/// Download a specific version of content by file id from Backblaze B2 Cloud Storage.
/// </summary>
/// <param name="fileId">The unique id of the file to download.</param>
/// <param name="content">The download content to receive.</param>
/// <exception cref="AuthenticationException">Thrown when authentication fails.</exception>
/// <exception cref="CapExceededExecption">Thrown when a cap is exceeded or an account in bad standing.</exception>
/// <exception cref="InvalidHashException">Thrown when a checksum hash is not valid.</exception>
/// <exception cref="ApiException">Thrown when an error occurs during client operation.</exception>
public async Task <IApiResults <DownloadFileResponse> > DownloadByIdAsync
(string fileId, Stream content)
{
var request = new DownloadFileByIdRequest(fileId);
return(await DownloadByIdAsync(request, content, null, _cancellationToken).ConfigureAwait(false));
}
/// <summary>
/// Sets content disposition header.
/// </summary>
/// <param name="headers">The http content request header.</param>
/// <param name="request">The <see cref="DownloadFileByIdRequest"/>.</param>
public static void SetContentDisposition(this HttpContentHeaders headers, DownloadFileByIdRequest request)
{
if (request.ContentDisposition != null)
{
headers.ContentDisposition = request.ContentDisposition;
}
}
public async Task DownloadAsync_ById()
{
var fileSystem = new MockFileSystem();
string fileSha1 = string.Empty;
int progressCounter = 0;
TimeSpan transferTime = TimeSpan.Zero;
long bytesPerSecond = 0;
long bytesTransferred = 0;
long expectedBytes = 0;
double percentComplete = 0;
var progress = new NaiveProgress <ICopyProgress>(x =>
{
progressCounter++;
transferTime = x.TransferTime;
bytesPerSecond = x.BytesPerSecond;
bytesTransferred = x.BytesTransferred;
expectedBytes = x.ExpectedBytes;
percentComplete = x.PercentComplete;
});
using (var content = fileSystem.File.Create(_fileName))
{
var request = new DownloadFileByIdRequest(_fileId);
var results = await Storage.DownloadByIdAsync(request, content, progress, CancellationToken.None);
if (results.IsSuccessStatusCode)
{
fileSha1 = results.Response.ContentSha1;
}
}
var downloadSha1 = fileSystem.File.OpenRead(_fileName).ToSha1();
if (!downloadSha1.Equals(fileSha1))
{
throw new InvalidOperationException();
}
Assert.Single(fileSystem.AllFiles);
Assert.True(progressCounter > 0);
Assert.True(transferTime > TimeSpan.Zero);
Assert.True(bytesPerSecond > 0);
Assert.Equal(524288, bytesTransferred);
Assert.Equal(524288, expectedBytes);
Assert.Equal(1, percentComplete);
}
/// <summary>
/// Downloads a specific version of content by file id.
/// </summary>
/// <param name="request">The <see cref="DownloadFileByIdRequest"/> to send.</param>
/// <param name="content">The download content to receive.</param>
/// <param name="progress">A progress action which fires every time the write buffer is cycled.</param>
/// <param name="cancel">The cancellation token to cancel operation.</param>
public async Task <IApiResults <DownloadFileResponse> > DownloadByIdAsync
(DownloadFileByIdRequest request, Stream content, IProgress <ICopyProgress> progress, CancellationToken cancel)
{
return(await _policy.InvokeDownload.ExecuteAsync(async() =>
{
var fileRequest = new DownloadFileByIdRequest(request.FileId);
var fileResults = await DownloadFileByIdAsync(fileRequest, cancel).ConfigureAwait(false);
if (fileResults.IsSuccessStatusCode)
{
if (fileResults.Response.ContentLength < Options.DownloadCutoffSize)
{
return await DownloadFileByIdAsync(request, content, progress, cancel).ConfigureAwait(false);
}
else
{
return await DownloadLargeFileAsync(fileRequest, fileResults, content, progress, cancel).ConfigureAwait(false);
}
}
return fileResults;
}).ConfigureAwait(false));
}
/// <summary>
/// Downloads the most recent version of a large file in chunked parts.
/// </summary>
/// <param name="request">The <see cref="DownloadFileByIdRequest"/> content to send.</param>
/// <param name="results">The <see cref="DownloadFileResponse"/> results.</param>
/// <param name="content">The download content to receive.</param>
/// <param name="progress">A progress action which fires every time the write buffer is cycled.</param>
/// <param name="cancellationToken">The cancellation token to cancel operation.</param>
private async Task <IApiResults <DownloadFileResponse> > DownloadLargeFileAsync
(DownloadFileByIdRequest request, IApiResults <DownloadFileResponse> results, Stream content, IProgress <ICopyProgress> progress, CancellationToken cancellationToken)
{
var parts = GetContentParts(results.Response.ContentLength, Options.DownloadPartSize);
foreach (var part in parts)
{
var mmultiStream = new MultiStream(content, part.Position, part.Length);
var partReqeust = new DownloadFileByIdRequest(request.FileId)
{
Range = new RangeHeaderValue(part.Position, part.Position + part.Length - 1)
};
var partResults = await DownloadFileByIdAsync(partReqeust, mmultiStream, progress, cancellationToken).ConfigureAwait(false);
if (!partResults.IsSuccessStatusCode)
{
return(new ApiResults <DownloadFileResponse>(partResults.HttpResponse, partResults.Error));
}
}
return(results);
}
/// <summary>
/// Downloads a specific version of a file by file id.
/// </summary>
/// <param name="request">The <see cref="DownloadFileByIdRequest"/> to send.</param>
/// <param name="content">The download content to receive.</param>
/// <param name="progress">A progress action which fires every time the write buffer is cycled.</param>
/// <exception cref="AuthenticationException">Thrown when authentication fails.</exception>
/// <exception cref="InvalidHashException">Thrown when a checksum hash is not valid.</exception>
/// <exception cref="ApiException">Thrown when an error occurs during client operation.</exception>
async Task <IApiResults <DownloadFileResponse> > IStorageFiles.DownloadAsync
(DownloadFileByIdRequest request, Stream content, IProgress <ICopyProgress> progress)
{
return(await _client.DownloadFileByIdAsync(request, content, progress, _cancellationToken));
}
/// <summary>
/// Download a specific version of content by file id from Backblaze B2 Cloud Storage.
/// </summary>
/// <param name="request">The <see cref="DownloadFileByIdRequest"/> to send.</param>
/// <param name="content">The download content to receive.</param>
/// <param name="progress">A progress action which fires every time the write buffer is cycled.</param>
/// <param name="cancel">The cancellation token to cancel operation.</param>
/// <exception cref="AuthenticationException">Thrown when authentication fails.</exception>
/// <exception cref="CapExceededExecption">Thrown when a cap is exceeded or an account in bad standing.</exception>
/// <exception cref="InvalidHashException">Thrown when a checksum hash is not valid.</exception>
/// <exception cref="ApiException">Thrown when an error occurs during client operation.</exception>
public async Task <IApiResults <DownloadFileResponse> > DownloadByIdAsync
(DownloadFileByIdRequest request, Stream content, IProgress <ICopyProgress> progress, CancellationToken cancel)
{
return(await _client.DownloadByIdAsync(request, content, progress, cancel).ConfigureAwait(false));
}
public DownloadFileResponse Get(DownloadFileByIdRequest request)
{
Console.WriteLine("In DownloadFileByIdRequest");
byte[] fb = new byte[0];
string sFilePath = string.Format("../StaticFiles/{0}/{1}", request.SolnId, request.FileDetails.FileRefId);
MemoryStream ms = null;
DownloadFileResponse dfs = new DownloadFileResponse();
try
{
if (!System.IO.File.Exists(sFilePath))
{
EbFileCategory category = request.FileDetails.FileCategory;
string Qry = this.EbConnectionFactory.DataDB.EB_DOWNLOAD_FILE_BY_ID;
DbParameter[] parameters =
{
this.EbConnectionFactory.DataDB.GetNewParameter("fileref", EbDbTypes.Int32, request.FileDetails.FileRefId),
};
EbDataTable t = this.EbConnectionFactory.DataDB.DoQuery(Qry, parameters);
if (t.Rows.Count > 0)
{
request.FileDetails.FileStoreId = t.Rows[0]["filestore_sid"].ToString();
request.FileDetails.InfraConID = Convert.ToInt32(t.Rows[0]["filedb_con_id"]);
}
else
{
throw new Exception("File Not Found in Database , fileref = " + request.FileDetails.FileRefId);
}
fb = this.EbConnectionFactory.FilesDB.DownloadFileById(request.FileDetails.FileStoreId, category, request.FileDetails.InfraConID);
if (fb != null)
{
EbFile.Bytea_ToFile(fb, sFilePath);
}
}
if (File.Exists(sFilePath))
{
ms = new MemoryStream(File.ReadAllBytes(sFilePath));
dfs.StreamWrapper = new MemorystreamWrapper(ms);
dfs.FileDetails = new FileMeta
{
FileName = request.FileDetails.FileName,
FileType = request.FileDetails.FileType,
Length = request.FileDetails.Length,
FileStoreId = request.FileDetails.FileStoreId,
UploadDateTime = request.FileDetails.UploadDateTime,
MetaDataDictionary = (request.FileDetails.MetaDataDictionary != null) ? request.FileDetails.MetaDataDictionary : new Dictionary <String, List <string> >()
{
},
};
}
else
{
throw new Exception("File Not Found");
}
}
catch (FormatException e)
{
Console.WriteLine("ObjectId not in Correct Format: " + request.FileDetails.FileName);
Console.WriteLine("Exception: " + e.ToString());
}
catch (Exception e)
{
Log.Info("Exception:" + e.ToString());
}
return(dfs);
}
