protected override async Task DeleteSingleAsync(string fullPath, CancellationToken cancellationToken) { try { await _client.DeleteObjectAsync(_bucketName, NormalisePath(fullPath), cancellationToken : cancellationToken).ConfigureAwait(false); } catch (GoogleApiException ex) when(ex.HttpStatusCode == HttpStatusCode.NotFound) { //when not found, just ignore //try delete everything recursively IReadOnlyCollection <Blob> childObjects = await ListAsync(new ListOptions { Recurse = true }, cancellationToken).ConfigureAwait(false); foreach (Blob blob in childObjects) { try { await _client.DeleteObjectAsync(_bucketName, NormalisePath(blob.FullPath), cancellationToken : cancellationToken).ConfigureAwait(false); } catch (GoogleApiException exc) when(exc.HttpStatusCode == HttpStatusCode.NotFound) { } } } }
public async Task DeleteByPrefixAsync(string prefix, CancellationToken ct = default) { var name = GetFileName(prefix, nameof(prefix)); try { var items = storageClient.ListObjectsAsync(bucketName, name); await foreach (var item in items.WithCancellation(ct)) { try { await storageClient.DeleteObjectAsync(item.Bucket, item.Name, cancellationToken : ct); } catch (GoogleApiException ex) when(ex.HttpStatusCode == HttpStatusCode.NotFound) { continue; } } } catch (GoogleApiException ex) when(ex.HttpStatusCode == HttpStatusCode.NotFound) { return; } }
public async Task <IUnixFileSystemEntry> MoveAsync(IUnixDirectoryEntry parent, IUnixFileSystemEntry source, IUnixDirectoryEntry target, string fileName, CancellationToken cancellationToken) { var targetDirEntry = (GcsDirectoryEntry)target; var targetName = string.Join("/", new string[] { targetDirEntry.FullName.Trim('/'), fileName }).Trim('/'); if (source is GcsFileEntry sourceFileEntry) { var sourceDirEntry = (GcsDirectoryEntry)parent; var sourceName = string.Join("/", new string[] { sourceDirEntry.FullName.Trim('/'), sourceFileEntry.Name }).Trim('/'); try { var newObj = await _storageClient.CopyObjectAsync(_bucketName, sourceName, _bucketName, targetName, null, cancellationToken); if (newObj != null) { await _storageClient.DeleteObjectAsync(_bucketName, sourceName, null, cancellationToken); } } catch { } } else { throw new NotSupportedException(); } return(new GcsDirectoryEntry(this) { Name = targetName }); }
public async Task DeleteAsync(string name) { try { await storageClient.DeleteObjectAsync(bucketName, name); } catch (GoogleApiException ex) { if (ex.HttpStatusCode != HttpStatusCode.NotFound) { throw; } } }
public async Task DeleteOldBackupsAsync(DateTime removeThreshold) { var objects = _storageClient.ListObjectsAsync(_bucketName); var objectsToDelete = new List <Object>(); await objects.ForEachAsync(obj => { if (obj.TimeCreated.Value.ToUniversalTime() <= removeThreshold) { objectsToDelete.Add(obj); } }); if (objectsToDelete.Count == 0) { Console.WriteLine("Nothing to delete."); } foreach (var objToDelete in objectsToDelete) { Console.WriteLine($"Deleting {objToDelete.Name}, because it TimeCreated: {objToDelete.TimeCreated.Value.ToUniversalTime()} is older then threshold: {removeThreshold}"); await _storageClient.DeleteObjectAsync(_bucketName, objToDelete.Name); } }
public async Task DeleteFileAsync(string bucket, string objectName) { using (StorageClient client = await StorageClient.CreateAsync(_credential)) { await client.DeleteObjectAsync(bucket, objectName); } }
private static async Task DeleteObject(StorageClient client, string bucket, string name, string generation) { long?generationOption = generation == null ? default(long?) : long.Parse(generation); await client.DeleteObjectAsync(bucket, name, new DeleteObjectOptions { Generation = generationOption }, CancellationToken.None); Console.WriteLine($"Deleted object {bucket}/{name}"); }
/// <summary> /// Deletes the attachment with the given ID /// </summary> /// <param name="id">ID of the data object to delete</param> public async Task Delete(string id) { await RetryCatchAsync(id, async objectName => { await _storageClient.DeleteObjectAsync(_options.BucketName, objectName); return(true); }); }
public async Task DeleteFile(string identificator) { var task = _storageClient.DeleteObjectAsync( bucket: _bucketName, objectName: identificator ); await Task.WhenAny(task); }
public ConfiguredTaskAwaitable DeleteObjectAsync(string fileName) { return(_client.DeleteObjectAsync( _bucketName, fileName, null, CancellationToken ).ConfigureAwait(false)); }
private static async Task DeleteDocumentObject(StorageClient storage, string bucket, string remoteFileName) { using (new Timing($"Delete {bucket}:{remoteFileName}")) { var document = await storage.GetObjectAsync(bucket, remoteFileName); await storage.DeleteObjectAsync(document); } }
public Task DeleteObjectAsync(string fileName) { return(_client.DeleteObjectAsync( _bucketName, fileName, null, CancellationToken )); }
public string DeleteFile(string fileurl) { Regex search = new Regex(@"[a-zA-Z0-9]{16}?"); string objectName = search.Match(fileurl).ToString(); storageClient.DeleteObjectAsync(bucketName, objectName); return(objectName); }
/// <summary> /// Unregister a subscriber for a topic /// </summary> /// <param name="topic">Topic to unregister the subscriber for</param> /// <param name="subscriberAddress">Address of the subscriber</param> public async Task UnregisterSubscriber(string topic, string subscriberAddress) { // Create the name of the object to store the subscription under topic = $"{topic}/{subscriberAddress}"; await RetryCatchAsync(topic, async objectName => { await _storageClient.DeleteObjectAsync(_options.BucketName, objectName); return(true); }); }
public async Task DeleteBlobAsync(string containerName, string blobName) { try { await _client.DeleteObjectAsync(_bucket, ObjectName(containerName, blobName)); } catch (GoogleApiException gae) { throw Error(gae); } }
//delete image public async Task DeleteFileAsync(string fileNameForStorage) { try { await _storageClient.DeleteObjectAsync(_bucketName, fileNameForStorage); } catch { // ignored } }
private async Task DeleteCoreAsync(string objectName) { try { await storageClient.DeleteObjectAsync(bucketName, objectName); } catch (GoogleApiException ex) when(ex.HttpStatusCode == HttpStatusCode.NotFound) { return; } }
public async Task <IActionResult> UploadVideo([FromForm] IFormFile file, [FromForm] string Title, [FromForm] string Username) { if (String.IsNullOrWhiteSpace(Title) || String.IsNullOrWhiteSpace(Username)) { return(BadRequest()); } Guid vidId = Guid.NewGuid(); var safeLinkURL = Microsoft.AspNetCore.WebUtilities.WebEncoders.Base64UrlEncode(vidId.ToByteArray()); var videoRecord = new Video { VideoId = vidId, Title = Title, Username = Username, PostedAt = DateTime.UtcNow, BucketURL = GenerateBucketURL(vidId, file.FileName), LinkURL = safeLinkURL }; try { using (var memoryStream = new MemoryStream()) { await file.CopyToAsync(memoryStream); await _storageClient.UploadObjectAsync(_bucketName, videoRecord.BucketURL, null, memoryStream); } } catch (Exception e) { Console.WriteLine(e.ToString()); return(StatusCode(500)); } try { _videoDbContext.Videos.Add(videoRecord); _videoDbContext.SaveChanges(); }catch (Exception e) { Console.WriteLine(e.ToString()); //Video record saved to fail so we need to remove the video file in the GCP Storage so it's not left stranded await _storageClient.DeleteObjectAsync(_bucketName, videoRecord.BucketURL); return(StatusCode(500)); } return(Ok(videoRecord)); }
private static async Task DeleteDocumentObjects(StorageClient storage, string bucket, string remotePrefix) { using (new Timing($"Delete All {bucket}:{remotePrefix}")) { var documents = await GetAllDocumentObjects(storage, bucket, remotePrefix); foreach (var doc in documents) { await storage.DeleteObjectAsync(doc); } } }
public async Task DeleteFileAsync(string imageUrl) { var filename = imageUrl.Substring(imageUrl.LastIndexOf("/") + 1); try { await _storageClient.DeleteObjectAsync(_bucketName, filename); } catch (Exception e) { Console.WriteLine(e); } }
public async Task DeleteAsync(string fileName) { Guard.NotNullOrEmpty(fileName); try { await storageClient.DeleteObjectAsync(bucketName, fileName); } catch (GoogleApiException ex) when(ex.HttpStatusCode == HttpStatusCode.NotFound) { return; } }
public async Task <Result <string> > DeleteFileAsync(string fileName) { try { await storageClient.DeleteObjectAsync(googleCloudSettings.GoogleCloudStorageBucket, fileName); return(new SuccessResult <string>($"Deleted {fileName}")); } catch (Exception ex) { return(new UnexpectedResult <string>(ex.Message)); } }
public async Task <IActionResult> OnPostDeleteBucketObject(string FileToDelete) { var user = await _userManager.GetUserAsync(HttpContext.User); var TempDataList = TempData.GetKeep <InputModel>("FileList"); var ToRemove = TempDataList.FileList.SingleOrDefault(a => a.FileName == FileToDelete); _options.ObjectName = MakeFileName(FileToDelete, user.SenderId); try { IOrderedEnumerable <Google.Apis.Storage.v1.Data.Object> bucketItems = _storage.ListObjects(_options.BucketName).OrderBy(x => x.TimeCreated); if (bucketItems.Any(x => x.Name == _options.ObjectName)) { await _storage.DeleteObjectAsync(_options.BucketName, _options.ObjectName); } else { _logger.LogError("File does not exist: " + _options.BucketName, _options.ObjectName + " : " + "Please contact help desk for further advice.", string.Empty, ""); } FileUploadInfo fileToRemove = _context.FileUploadInfo.Where(x => x.FileName == FileToDelete || x.FileName == _options.ObjectName).LastOrDefault(); if (fileToRemove != null) { TempDataList.FileList.Remove(ToRemove); _context.FileUploadInfo.Remove(fileToRemove); await _context.SaveChangesAsync(); } else { string errorMessage = "An error occured while removing the selected file " + FileToDelete + " , please contact help desk for further help"; ModelState.AddModelError("fileToRemove.FileName", errorMessage.ToString()); _logger.LogError("Removing file error: " + _options.BucketName, _options.ObjectName + " : " + "An error while removing the file, either not found or null parameter passed", string.Empty, ""); TempDataList.FileList.ForEach(x => Input.FileList.Add(x)); return(Page()); } } catch (Exception e) { ModelState.AddModelError("CustomError", e.ToString()); _logger.LogError("Removing file error: " + _options.BucketName, _options.ObjectName + " : " + e.Message, e.InnerException != null ? e.InnerException.Message : string.Empty, e.StackTrace); TempData.Put("FileList", TempDataList); return(Page()); } TempData.Put("FileList", TempDataList); return(RedirectToPage()); }
public async Task RemoveImage(string fileName) { try { await storageClient.DeleteObjectAsync(bucketName, fileName); } catch (Google.GoogleApiException exception) { if (exception.Error.Code != 404) { throw; } } }
public static async Task Delete( int projectId, string version, string branch, StorageClient client, upwardContext upwardDb, accountsContext accountsDb) { var ver = version.Split("."); int major = int.Parse(ver[0]); int minor = int.Parse(ver[1]); int patch = int.Parse(ver[2]); var pkg = await upwardDb.Pkgfile .Where(r => r.Project == projectId && r.Major == major && r.Minor == minor && r.Patch == patch && r.Branch == branch) .FirstOrDefaultAsync(); var project = await accountsDb.Project .Where(r => r.Id == projectId) .FirstOrDefaultAsync(); var user = await accountsDb.Userprofile .Where(r => r.Id == project.Userid) .FirstOrDefaultAsync(); user.Size -= pkg.Size; upwardDb.Pkgfile.Remove(pkg); if (pkg.Filename.Count() == 0) { await accountsDb.SaveChangesAsync(); await upwardDb.SaveChangesAsync(); return; } else { foreach (string name in pkg.Filename) { await client.DeleteObjectAsync("upward-test", $"pkg/{projectId}/{branch}/{version}/{name}"); } await accountsDb.SaveChangesAsync(); await upwardDb.SaveChangesAsync(); } }
// [END uploadimage] public async Task DeleteUploadedImage(long id) { try { await _storageClient.DeleteObjectAsync(_bucketName, id.ToString()); } catch (Google.GoogleApiException exception) { // A 404 error is ok. The image is not stored in cloud storage. if (exception.Error.Code != 404) { throw; } } }
public async Task Delete(string path, CancellationToken cancellationToken) { path = normalizePath(path); try { await _storageClient.DeleteObjectAsync(_configuration.Bucket, path, cancellationToken : cancellationToken); } catch (GoogleApiException ex) { if (ex.Error.Code == 404) { // Already gone return; } throw ex; } }
public async Task <OperationResult> DeleteBlob(Uri key) { try { string bucket = GetBucketName(key); string blob = GetObjectName(key); await _client.DeleteObjectAsync(bucket, blob); return(new OperationResult(true, "", HttpStatusCode.OK)); } catch (GoogleApiException e) { return(new OperationResult(false, e.Message, (HttpStatusCode)e.Error.Code)); } }
public async Task DeleteFile(string filename, string folder) { try { var objNameToDelete = Util.Util.GenerateDataStoreObjectName(filename); await _storageClient.DeleteObjectAsync(BUCKET, $"{folder}/{objNameToDelete}"); } catch (Google.GoogleApiException ex) { // ignore 404, the image is already deleted or never existed if (ex.Error.Code != 404) { throw ex; } } }
public async Task CleanAsync(CancellationToken cancellationToken) { var deadlineAt = DateTime.UtcNow.AddDays(-7); var result = storageClient.ListObjectsAsync(options.CloudStorageBackupBucketName); var enumerator = result.GetEnumerator(); while (await enumerator.MoveNext(cancellationToken)) { // 1週間より前のバックアップは削除する var obj = enumerator.Current; if (obj.TimeCreated < deadlineAt) { await storageClient.DeleteObjectAsync(obj, cancellationToken : cancellationToken); logger.LogInformation($"{obj.Name} を削除しました。"); } } }