/// <summary> /// This is only here so it can implement an interface which so it can be mocked. /// </summary> /// <param name="source"></param> /// <param name="destination"></param> /// <param name="options"></param> /// <param name="progress"></param> public override void DownloadObject(Object source, Stream destination, DownloadObjectOptions options = null, IProgress <IDownloadProgress> progress = null) { base.DownloadObject(source, destination, options, progress); }
public void InvalidDownloadValidationMode() { var options = new DownloadObjectOptions { DownloadValidationMode = (DownloadValidationMode)12345 }; Assert.Throws <ArgumentException>(() => _fixture.Client.DownloadObject(_fixture.ReadBucket, "irrelevant.txt", new MemoryStream(), options)); }
public void ModifyDownloader_DefaultOptions() { var downloader = new MediaDownloader(null); var options = new DownloadObjectOptions(); options.ModifyDownloader(downloader); Assert.Equal(MediaDownloader.MaximumChunkSize, downloader.ChunkSize); }
internal static void ValidateData(string bucketName, string objectName, byte[] expectedData, StorageClient client = null, DownloadObjectOptions options = null) { client = client ?? StorageClient.Create(); var downloaded = new MemoryStream(); client.DownloadObject(bucketName, objectName, downloaded, options); Assert.Equal(expectedData, downloaded.ToArray()); }
public override Task DownloadObjectAsync( Object source, Stream destination, DownloadObjectOptions options = null, CancellationToken cancellationToken = default(CancellationToken), IProgress <IDownloadProgress> progress = null) { return(Task.Run(() => DownloadObject(source, destination, options, progress))); }
public void ModifyDownloader_WithChunkSize() { var downloader = new MediaDownloader(null); var options = new DownloadObjectOptions { ChunkSize = 2048 }; options.ModifyDownloader(downloader); Assert.Equal(2048, downloader.ChunkSize); }
public Task DownloadRecordAsync(StorageRecord record, Stream destination, int?chunkSize = null, CancellationToken cancellationToken = default(CancellationToken)) { return(UseStorageClient(client => { var options = new DownloadObjectOptions(); if (chunkSize.HasValue) { options.ChunkSize = chunkSize.Value; } return client.DownloadObjectAsync(record.GoogleObject, destination, options, cancellationToken); })); }
public void ModifyDownloader_NegativeMatchOptions() { var options = new DownloadObjectOptions { IfGenerationNotMatch = 1L, IfMetagenerationNotMatch = 2L, Generation = 3L }; var uri = options.GetUri("http://url/foo?x=y"); Assert.Contains("&ifGenerationNotMatch=1", uri); Assert.Contains("&ifMetagenerationNotMatch=2", uri); Assert.Contains("&generation=3", uri); }
/// <summary> /// This version of download() gets a range of bytes. Since this is a partial download, /// this function DOES NOT flush the stream object. /// </summary> public void download(string bucket_name, string key_name, Stream stream, long start, long length) { try { var download_options = new DownloadObjectOptions(); download_options.Range = new System.Net.Http.Headers.RangeHeaderValue(start, start + length - 1); client.DownloadObject(bucket_name, key_name, stream, download_options); } catch (Exception ex) { throw new Exception("Error while trying to download from GCP \"" + bucket_name + "\\" + key_name + "\". GCP error message: " + ex.Message); } }
public void GetUri_MatchNotMatchConflicts() { Assert.Throws <ArgumentException>(() => { var options = new DownloadObjectOptions { IfGenerationMatch = 1L, IfGenerationNotMatch = 2L }; options.GetUri("http://url/foo?x=y"); }); Assert.Throws <ArgumentException>(() => { var options = new DownloadObjectOptions { IfMetagenerationMatch = 1L, IfMetagenerationNotMatch = 2L }; options.GetUri("http://url/foo?x=y"); }); }
public void GetUri_PositiveMatchOptions() { var options = new DownloadObjectOptions { IfGenerationMatch = 1L, IfMetagenerationMatch = 2L, Generation = 3L, UserProject = "my proj" }; var uri = options.GetUri("http://url/foo?x=y"); Assert.Contains("&ifGenerationMatch=1", uri); Assert.Contains("&ifMetagenerationMatch=2", uri); Assert.Contains("&generation=3", uri); // I don't expect project IDs to actually need escaping, but let's check that it works. Assert.Contains("&userProject=my%20proj", uri); }
// ************************************************************************************************************* // DOWNLOAD OBJECT public override void DownloadObject( string bucket, string objectName, Stream destination, DownloadObjectOptions options = null, IProgress <IDownloadProgress> progress = null) { var key = Key(bucket, objectName); if (_entries.TryGetValue(key, out var entry)) { destination.Write(entry.Data, 0, entry.Data.Length); destination.Flush(); return; } // FIXME: Google compatible exception throw new InvalidOperationException($"No object found for {key}."); }
public async Task DownloadAsync(string fileName, Stream stream, BytesRange range = default, CancellationToken ct = default) { Guard.NotNullOrEmpty(fileName); try { var downloadOptions = new DownloadObjectOptions(); if (range.IsDefined) { downloadOptions.Range = new RangeHeaderValue(range.From, range.To); } await storageClient.DownloadObjectAsync(bucketName, fileName, stream, downloadOptions, ct); } catch (GoogleApiException ex) when(ex.HttpStatusCode == HttpStatusCode.NotFound) { throw new AssetNotFoundException(fileName, ex); } }
public void ModifyDownloader_NegativeMatchOptions() { var options = new DownloadObjectOptions { IfGenerationNotMatch = 1L, IfMetagenerationNotMatch = 2L, Generation = 3L }; var builder = new RequestBuilder { BaseUri = new Uri("http://url/"), Path = "foo" }; options.ModifyRequestBuilder(builder); // The replacement here simplifies the tests, to avoid needing to care which query parameter was first. var uri = builder.BuildUri().AbsoluteUri.Replace('?', '&'); Assert.Contains("&ifGenerationNotMatch=1", uri); Assert.Contains("&ifMetagenerationNotMatch=2", uri); Assert.Contains("&generation=3", uri); }
public static async System.Threading.Tasks.Task <Stream> DownloadObjectAsync(string bucket, string objectName, string name, string serviceAccountName, string serviceAccountKeyFile, string clientId, Stream objectStream) { if (objectStream is null) { throw new ArgumentNullException(nameof(objectStream)); } var credential = GoogleCredential.FromFile(serviceAccountKeyFile); using (StorageClient storageClient = StorageClient.Create(credential)) { DownloadObjectOptions options = new DownloadObjectOptions() { DownloadValidationMode = DownloadValidationMode.Always }; await storageClient.DownloadObjectAsync(bucket, objectName, objectStream, options); } return(objectStream); }
public void GetUri_MatchNotMatchConflicts() { Assert.Throws <ArgumentException>(() => { var options = new DownloadObjectOptions { IfGenerationMatch = 1L, IfGenerationNotMatch = 2L }; var builder = new RequestBuilder { BaseUri = new Uri("http://url/"), Path = "foo" }; options.ModifyRequestBuilder(builder); }); Assert.Throws <ArgumentException>(() => { var options = new DownloadObjectOptions { IfMetagenerationMatch = 1L, IfMetagenerationNotMatch = 2L }; var builder = new RequestBuilder { BaseUri = new Uri("http://url/"), Path = "foo" }; options.ModifyRequestBuilder(builder); }); }
public void GetUri_PositiveMatchOptions() { var options = new DownloadObjectOptions { IfGenerationMatch = 1L, IfMetagenerationMatch = 2L, Generation = 3L, UserProject = "my proj" }; var builder = new RequestBuilder { BaseUri = new Uri("http://url/"), Path = "foo" }; options.ModifyRequestBuilder(builder); // The replacement here simplifies the tests, to avoid needing to care which query parameter was first. var uri = builder.BuildUri().AbsoluteUri.Replace('?', '&'); Assert.Contains("&ifGenerationMatch=1", uri); Assert.Contains("&ifMetagenerationMatch=2", uri); Assert.Contains("&generation=3", uri); // I don't expect project IDs to actually need escaping, but let's check that it works. Assert.Contains("&userProject=my%20proj", uri); }
private async void btn_download_Click(object sender, EventArgs e) { var dlg = new SaveFileDialog(); dlg.FileName = lbl_file.Text; if (dlg.ShowDialog() == DialogResult.OK) { var token = new CancellationTokenSource().Token; using (var fileStream = File.Create(dlg.FileName)) { progressBar1.Maximum = int.Parse(lbl_byte.Text); var downloadObjectOptions = new DownloadObjectOptions { ChunkSize = UploadObjectOptions.MinimumChunkSize }; var progressReporter = new Progress <IDownloadProgress>(OnDownloadProgress); await storageClient.DownloadObjectAsync(bucketName, Path.GetFileName(dlg.FileName), fileStream, downloadObjectOptions, token, progress : progressReporter).ConfigureAwait(true); } } }
/// <summary> /// /// <para>DownloadFile:</para> /// /// <para>Downloads a file from File Service and stores locally/or to stream, caller thread will be blocked before it is done</para> /// /// <para>Check <seealso cref="IBFileServiceInterface.DownloadFile"/> for detailed documentation</para> /// /// </summary> public bool DownloadFile( string _BucketName, string _KeyInBucket, BStringOrStream _Destination, Action <string> _ErrorMessageAction = null, UInt64 _StartIndex = 0, UInt64 _Size = 0) { if (GSClient == null) { _ErrorMessageAction?.Invoke("BFileServiceGC->DownloadFile: GSClient is null."); return(false); } if (!CheckFileExistence( _BucketName, _KeyInBucket, out bool bExists, _ErrorMessageAction )) { _ErrorMessageAction?.Invoke("BFileServiceGC->DownloadFile: CheckFileExistence failed."); return(false); } if (!bExists) { _ErrorMessageAction?.Invoke("BFileServiceGC->DownloadFile: File does not exist in the File Service."); return(false); } DownloadObjectOptions DOO = null; if (_Size > 0) { DOO = new DownloadObjectOptions() { Range = new System.Net.Http.Headers.RangeHeaderValue((long)_StartIndex, (long)(_StartIndex + _Size)) }; } try { if (_Destination.Type == EBStringOrStreamEnum.String) { using (FileStream FS = File.Create(_Destination.String)) { GSClient.DownloadObject(_BucketName, _KeyInBucket, FS, DOO); } if (!BUtility.DoesFileExist( _Destination.String, out bool bLocalFileExists, _ErrorMessageAction)) { _ErrorMessageAction?.Invoke("BFileServiceGC->DownloadFile: DoesFileExist failed."); return(false); } if (!bLocalFileExists) { _ErrorMessageAction?.Invoke("BFileServiceGC->DownloadFile: Download finished, but still file does not locally exist."); return(false); } } else { if (_Destination.Stream == null) { _ErrorMessageAction?.Invoke("BFileServiceGC->DownloadFile: Destination stream is null."); return(false); } GSClient.DownloadObject(_BucketName, _KeyInBucket, _Destination.Stream, DOO); try { _Destination.Stream.Position = 0; } catch (Exception) { } } } catch (Exception e) { _ErrorMessageAction?.Invoke("BFileServiceGC->DownloadFile: " + e.Message + ", Trace: " + e.StackTrace); return(false); } return(true); }
internal static void ValidateData(string bucketName, string objectName, MemoryStream expectedData, StorageClient client = null, DownloadObjectOptions options = null) => ValidateData(bucketName, objectName, expectedData.ToArray(), client, options);
public Task DownloadObjectAsync(string bucket, string objectName, Stream destination, DownloadObjectOptions options = null) { return(_wrappedClient.DownloadObjectAsync(bucket, objectName, destination, options)); }
public virtual void DownloadObject(string bucket, string objectName, Stream destination, DownloadObjectOptions options = null, IProgress <IDownloadProgress> progress = null) { var client = StorageClient.Create(); var source = "greetings/hello.txt"; var destination = "hello.txt"; using (var stream = File.Create(destination)) { // IDownloadProgress defined in Google.Apis.Download namespace var progress = new Progress <IDownloadProgress>( p => Console.WriteLine($"bytes: {p.BytesDownloaded}, status: {p.Status}") ); // Download source object from bucket to local file system client.DownloadObject(bucket, source, stream, null, progress); } }