public async Task <IActionResult> Index() { var model = new HomeIndex(); if (new string[] { null, "", "your-google-bucket-name" } .Contains(_options.BucketName)) { model.MissingBucketName = true; return(View(model)); } try { var storageObject = await _storage.GetObjectAsync(_options.BucketName, _options.ObjectName); model.MediaLink = storageObject.MediaLink; MemoryStream m = new MemoryStream(); await _storage.DownloadObjectAsync( _options.BucketName, _options.ObjectName, m); m.Seek(0, SeekOrigin.Begin); byte[] content = new byte[m.Length]; m.Read(content, 0, content.Length); model.Content = Encoding.UTF8.GetString(content); } catch (GoogleApiException e) when(e.HttpStatusCode == System.Net.HttpStatusCode.NotFound) { // Does not exist yet. No problem. } return(View(model)); }
private async Task <BlobData> GetLatestDataAsync(StorageClient storageClient) { // Set the appropriate AccessCondition based on what we believe the latest // file contents to be, then make the request. var latestCachedData = Volatile.Read(ref _cachedBlobData); // local ref so field isn't mutated under our feet try { using (var memoryStream = new MemoryStream()) { var obj = await storageClient.GetObjectAsync(_bucketName, _name); await storageClient.DownloadObjectAsync(obj, memoryStream); latestCachedData = new BlobData() { BlobContents = memoryStream.ToArray(), ETag = obj.ETag }; } Volatile.Write(ref _cachedBlobData, latestCachedData); } catch { latestCachedData = null; Volatile.Write(ref _cachedBlobData, latestCachedData); } return(latestCachedData); }
public ConfiguredTaskAwaitable <Object> GetObjectAsync(string fileName) { return(_client.GetObjectAsync( _bucketName, fileName, cancellationToken: CancellationToken ).ConfigureAwait(false)); }
public Task <Object> GetObjectAsync(string fileName) { return(_client.GetObjectAsync( _bucketName, fileName, cancellationToken: CancellationToken )); }
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 async Task RenameFileAsync(string bucket, string objectName, string filename) { using (StorageClient client = await StorageClient.CreateAsync(_credential)) { var dataObject = await client.GetObjectAsync(bucket, objectName); dataObject.ContentDisposition = $"filename=\"{filename}\""; await client.PatchObjectAsync(dataObject); } }
protected override async Task <Blob> GetBlobAsync(string fullPath, CancellationToken cancellationToken) { fullPath = StoragePath.Normalize(fullPath); try { Object obj = await _client.GetObjectAsync(_bucketName, fullPath, new GetObjectOptions { //todo }, cancellationToken).ConfigureAwait(false); return(GConvert.ToBlob(obj)); } catch (GoogleApiException ex) when(ex.HttpStatusCode == HttpStatusCode.NotFound) { return(null); } }
public async Task <IActionResult> GetWithBranch(string branch, string version, string filename) { using (var stream = new MemoryStream()) { await storageClient.DownloadObjectAsync("upward-test", $"pkg/{Response.Headers["x-project-id"]}/{branch}/{version}/{filename}", stream); var metaData = await storageClient.GetObjectAsync("upward-test", $"pkg/{Response.Headers["x-project-id"]}/{branch}/{version}/{filename}"); return(File(stream.ToArray(), metaData.ContentType)); } }
/// <summary> /// Reads the metadata for the object in Google Cloud Storage /// </summary> /// <param name="objectName">Name of the Google Cloud object</param> /// <param name="addContentLength">True to add in the content length metadata</param> /// <returns>Metadata for the object</returns> private async Task <Dictionary <string, string> > GetObjectMetadataAsync(string objectName, bool addContentLength) { var o = await _storageClient.GetObjectAsync(_options.BucketName, objectName); var metadata = new Dictionary <string, string>(o.Metadata); if (addContentLength) { metadata[MetadataKeys.Length] = o.Size.ToString(); } return(metadata); }
/// <summary> /// Function to stream the download the results of a bucket as a stream /// </summary> /// <param name="client">Google storage client</param> /// <param name="bucketName">Name of the bucket</param> /// <param name="objectName">Object name to download</param> /// <returns>Open stream for reading the data</returns> internal static async Task <Stream> DownloadAsStreamAsync(StorageClient client, string bucketName, string objectName) { var o = await client.GetObjectAsync(bucketName, objectName); var request = new HttpRequestMessage { RequestUri = new Uri(o.MediaLink) }; var response = await client.Service.HttpClient.SendAsync(request); return(await response.Content.ReadAsStreamAsync()); }
public async Task <Game> GetGame(string name) { var source = await _storageClient.GetObjectAsync(BucketName, name); using (var ms = new MemoryStream()) { await _storageClient.DownloadObjectAsync(source, ms); var json = Encoding.UTF8.GetString(ms.ToArray()); return(JsonConvert.DeserializeObject <Game>(json)); } }
public async Task <BlobDescriptor> GetBlobDescriptorAsync(string containerName, string blobName) { try { var obj = await _client.GetObjectAsync(_bucket, ObjectName(containerName, blobName), new GetObjectOptions { Projection = Projection.Full }); return(GetBlobDescriptor(obj)); } catch (GoogleApiException gae) { throw Error(gae); } }
public async Task <bool> FileExistsAsync(string name) { var cachedBytes = await DistributedCache.GetAsync(name); if (cachedBytes != null && cachedBytes.Length > 0) { return(true); } _client = _client ?? await StorageClient.CreateAsync(); var obj = await _client.GetObjectAsync(Settings.GoogleStorageBucket, name); return(obj?.Size > 0); }
private async Task SetBlobAsync(Blob blob, CancellationToken cancellationToken = default) { Object item = await _client.GetObjectAsync(_bucketName, NormalisePath(blob.FullPath), cancellationToken : cancellationToken).ConfigureAwait(false); if (item.Metadata == null) { item.Metadata = new Dictionary <string, string>(); } foreach (KeyValuePair <string, string> metadata in blob.Metadata) { if (item.Metadata.ContainsKey(metadata.Key)) { item.Metadata[metadata.Key] = metadata.Value; } else { item.Metadata.Add(metadata.Key, metadata.Value); } } await _client.UpdateObjectAsync(item, cancellationToken : cancellationToken).ConfigureAwait(false); }
public async Task <IUnixFileSystemEntry> GetEntryByNameAsync(IUnixDirectoryEntry directoryEntry, string name, CancellationToken cancellationToken) { IUnixFileSystemEntry result = null; var parentEntry = (GcsDirectoryEntry)directoryEntry; var fullName = string.Join("/", new string[] { parentEntry.FullName.Trim('/'), name }).Trim('/'); Google.Apis.Storage.v1.Data.Object obj = null; try { obj = await _storageClient.GetObjectAsync(_bucketName, fullName, null, cancellationToken); } catch { } if (obj == null) { var childEntry = new GcsDirectoryEntry(this) { Name = $"{fullName}/" }; var directoryExists = await DirectoryExistsAsync(childEntry); if (directoryExists) { result = childEntry; } } else { if (obj.ContentType != "application/x-directory") { DateTimeOffset?createdTime = null; if (obj.TimeCreated is DateTime created) { createdTime = new DateTimeOffset(created); } DateTimeOffset?updatedTime = null; if (obj.Updated is DateTime updated) { updatedTime = new DateTimeOffset(updated); } return(new GcsFileEntry(this) { Name = obj.Name, Size = Convert.ToInt64(obj.Size), CreatedTime = createdTime, LastWriteTime = updatedTime }); } } return(result); }
public async Task <bool> ExistsAsync(string path) { try { await _googleStorageClient.GetObjectAsync(_bucket, path); return(true); } catch (GoogleApiException ex) { if (ex.HttpStatusCode == HttpStatusCode.NotFound) { return(false); } throw; } }
public async Task <bool> ExistBlob(Uri key) { string bucket = GetBucketName(key); string blob = GetObjectName(key); try { var obj = await _client.GetObjectAsync(bucket, blob); return(bucket != null); } catch (GoogleApiException e) when(e.Error.Code == 404) { return(false); } }
public async Task <bool> FileExistsAsync(string filename) { try { var storageObject = await _storageClient.GetObjectAsync(_configuration.BucketName, filename); if (storageObject != null) { return(true); } } catch (Exception) { } return(false); }
public async Task <long> GetSizeAsync(string fileName, CancellationToken ct = default) { Guard.NotNullOrEmpty(fileName, nameof(fileName)); try { var obj = await storageClient.GetObjectAsync(bucketName, fileName, null, ct); if (!obj.Size.HasValue) { throw new AssetNotFoundException(fileName); } return((long)obj.Size.Value); } catch (GoogleApiException ex) when(ex.HttpStatusCode == HttpStatusCode.NotFound) { throw new AssetNotFoundException(fileName, ex); } }
public static async Task DeleteFile( int projectId, string version, string filename, 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(); var metaData = await client .GetObjectAsync("upward-test", $"pkg/{projectId}/{branch}/{version}/{filename}"); pkg.Filename = pkg.Filename.Where(val => val != filename).ToArray(); pkg.Size -= (long)metaData.Size; user.Size -= (long)metaData.Size; await client.DeleteObjectAsync("upward-test", $"pkg/{projectId}/{branch}/{version}/{filename}"); await accountsDb.SaveChangesAsync(); await upwardDb.SaveChangesAsync(); }
public async Task <Fighter> GetFighterByIdAsync(string id) { var entity = await _db.LookupAsync(_keyFactory.CreateKey(id)); if (entity == null) { return(null); } var fighter = new Fighter { Id = id, Name = entity.Properties["name"].StringValue, Votes = (int)entity.Properties["vote"].IntegerValue }; var image = await _storage.GetObjectAsync(_bucketName, $"{id}"); fighter.Image = image.MediaLink; return(fighter); }
public override async Task <FileData> GetAsync(FileGetOptions fileGetOptions) { GoogleCredential credential = await AuthorizedAsync(fileGetOptions); StorageClient storageClient = await StorageClient.CreateAsync(credential); FileData file = new FileData(); switch (fileGetOptions.FileTransfer) { case FileTransferOptions.Stream: await storageClient.DownloadObjectAsync(fileGetOptions.Folder, fileGetOptions.Key, file.Stream); break; case FileTransferOptions.Url: var _file = await storageClient.GetObjectAsync(fileGetOptions.Folder, fileGetOptions.Key); if (_file != null) { file.Loc = _file.MediaLink; } break; case FileTransferOptions.SecureUrl: var urlSigner = UrlSigner.FromServiceAccountCredential((ServiceAccountCredential)credential.UnderlyingCredential); if (urlSigner != null) { urlSigner.Sign(fileGetOptions.Folder, fileGetOptions.Key, fileGetOptions.SecureLinkTimeToLive); } break; } file.Type = "Google Cloud Storage"; return(file); }
public async Task <Stream> ReadFileAsync(string name) { var cachedBytes = await DistributedCache.GetAsync(name); if (cachedBytes != null && cachedBytes.Length > 0) { var ms = new MemoryStream(cachedBytes); ms.Position = 0; return(ms); } _client = _client ?? await StorageClient.CreateAsync(); var obj = await _client.GetObjectAsync(Settings.GoogleStorageBucket, name); if (obj?.Size > 0) { var ms = new MemoryStream(); await _client.DownloadObjectAsync(Settings.GoogleStorageBucket, name, ms); ms.Position = 0; if (ms.Length <= Settings.MultimediaMemoryCacheMaxSizeInBytes) { // Save to memory cache await DistributedCache.SetAsync(name, ms.ToArray(), new DistributedCacheEntryOptions { SlidingExpiration = Settings.MultimediaMemoryCacheSlidingExpiration }); ms.Position = 0; } return(ms); } return(null); }
private static async Task GetObject(StorageClient client, string bucket, string name) { var obj = await client.GetObjectAsync(bucket, name); Console.WriteLine(JsonConvert.SerializeObject(obj, Formatting.Indented)); }
//ChangeUserDetails public async Task <JsonResult> OnPostUserDetails(Players player, IFormFile picture) { try { if (!ModelState.IsValid) { return(new JsonResult("Invalid data")); } Google.Apis.Storage.v1.Data.Object uploadedimage; try { //Sprawdzanie czy istnieje już zdjęcie profilowe dla tego użytkownika w cloud storage uploadedimage = await _storage.GetObjectAsync(_bucket.BucketName, Player.PlayerId.ToString()); //Jeśli nie przesłano zdjęcia profilowego if (picture == null) { _context.Attach(Player).State = EntityState.Modified; //Aktualizacja danych w bazie danych try { Player.Modified = DateTime.Now; Player.ProfilePicture = uploadedimage.MediaLink; await _context.SaveChangesAsync(); return(new JsonResult("Your details has been updated")); } catch (DbUpdateConcurrencyException dbex) { return(new JsonResult("Error while saving to database")); } } //Jeśli przesłano nowe zdjęcie profilowe if (picture.ContentType.Contains("image")) { //Usuwanie aktualnego zdjęcia profilowego z cloud storage await _storage.DeleteObjectAsync(_bucket.BucketName, Player.PlayerId.ToString()); //Wysłanie nowego zdjęcie profilowego do cloud storage var pictureStream = picture.OpenReadStream(); await _storage.UploadObjectAsync(_bucket.BucketName, Player.PlayerId.ToString(), picture.ContentType, pictureStream); //Pobranie danych nowego zdjęcia z cloud storage uploadedimage = await _storage.GetObjectAsync(_bucket.BucketName, Player.PlayerId.ToString()); _context.Attach(Player).State = EntityState.Modified; //Aktualizacja danych w bazie danych try { Player.Modified = DateTime.Now; Player.ProfilePicture = uploadedimage.MediaLink; await _context.SaveChangesAsync(); return(new JsonResult("Your details has been updated")); } catch (DbUpdateConcurrencyException dbex) { return(new JsonResult("Error while saving to database")); } } //Podano nie prawidłowy rodzaj pliku return(new JsonResult("Invalid type of file")); } //Jeśli w nie istnieje zdjęcie profilowe dla tego użytkownika w cloud storage catch (Exception ex) { //Jeśli nie przesłano zdjęcia profilowego if (picture == null) { _context.Attach(Player).State = EntityState.Modified; //Aktualizacja danych w bazie danych try { Player.Modified = DateTime.Now; await _context.SaveChangesAsync(); return(new JsonResult("Your details has been updated")); } catch (DbUpdateConcurrencyException dbex) { return(new JsonResult("Error while saving to database")); } } //Jeśli przesłano nowe zdjęcie profilowe if (picture.ContentType.Contains("image")) { //Wysłanie nowego zdjęcie profilowego do cloud storage var pictureStream = picture.OpenReadStream(); await _storage.UploadObjectAsync(_bucket.BucketName, Player.PlayerId.ToString(), picture.ContentType, pictureStream); //Pobranie danych nowego zdjęcia z cloud storage uploadedimage = await _storage.GetObjectAsync(_bucket.BucketName, Player.PlayerId.ToString()); _context.Attach(Player).State = EntityState.Modified; //Aktualizacja danych w bazie danych try { Player.Modified = DateTime.Now; Player.ProfilePicture = uploadedimage.MediaLink; await _context.SaveChangesAsync(); return(new JsonResult("Your details has been updated")); } catch (DbUpdateConcurrencyException dbex) { return(new JsonResult("Error while saving to database")); } } //Podano nie prawidłowy rodzaj pliku return(new JsonResult("Invalid type of file")); } } catch (Exception ex) { return(new JsonResult("Request failed")); } }
public async Task <IActionResult> GetBatchImagesAsync() { JsonSerializerOptions options = new(JsonSerializerDefaults.Web) { WriteIndented = true }; string requestBody = await new StreamReader(Request.Body).ReadToEndAsync(); var data = JsonConvert.DeserializeObject <BatchImageData[]>(requestBody); // var request = await JsonSerializer.DeserializeAsync<BatchImageData[]>(requestBody, options); // var images = request!["images"].EnumerateArray().ToList(); try { using var outputStream = new MemoryStream(); using var archive = new ZipArchive(outputStream, ZipArchiveMode.Create, true); //ms.Position = 0; // Will likely be usuful to have TenantData and Property data seperate classes foreach (var imageData in data !) { using var ms = new MemoryStream(); var googleObject = await _storageClient.GetObjectAsync(bucket, imageData.imageUrl); //TODO: Get date taken, this should be done on image caputre await _storageClient.DownloadObjectAsync(googleObject, ms); var imageNameWithExtension = imageData !.imageUrl !.Split("/")[1]; var imageExtension = imageNameWithExtension.Split('.').Last(); var rawBestLabel = imageData !.labels !.OrderByDescending(l => l.Confidence).FirstOrDefault()?.Label; string bestLabel = GetTrimmedLabel(rawBestLabel, 20); //CreateEntry needs a full file name with extension. Can have a directory structure. var zipArchiveEntry = archive.CreateEntry($"{imageData!.tenantName}/{bestLabel}-date/{bestLabel}date.{imageExtension}", CompressionLevel.Optimal); using (var zipStream = zipArchiveEntry.Open()) { //await outputStream.CopyToAsync(zipStream); zipStream.Write(ms.ToArray()); //zipStream.Flush(); } var zipArchiveEntry2 = archive.CreateEntry($"{imageData!.tenantName}/{bestLabel}-date/{bestLabel}-date-labels.txt", CompressionLevel.Optimal); using (var zipStream2 = zipArchiveEntry2.Open()) { zipStream2.Write(Encoding.ASCII.GetBytes(string.Concat(imageData !.labels !.Select(l => l.Label + "-" + l.Confidence + "-" + l.Source + "\r").ToList()))); } } archive.Dispose(); outputStream.Seek(0, SeekOrigin.Begin); //var response = File(outputStream.ToArray(), "application/zip", "Images.zip"); var packageId = Guid.NewGuid().ToString(); var uploadResult = await _storageClient.UploadObjectAsync(bucket, "packages/" + packageId + ".zip", MediaTypeNames.Application.Zip, outputStream); //return response; return(Json(new { id = packageId })); } catch (Exception ex) { _logger.LogError(ex.Message); return(new BadRequestResult()); } }