static void Main(string[] args) { /// Note: s3 AccessKey and SecretKey needs to be added in App.config file /// See instructions in README.md on running examples for more information. var minio = new MinioClient(ConfigurationManager.AppSettings["Endpoint"], ConfigurationManager.AppSettings["AccessKey"], ConfigurationManager.AppSettings["SecretKey"]).WithSSL(); ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12; var getListBucketsTask = minio.ListBucketsAsync(); try { Task.WaitAll(getListBucketsTask); // block while the task completes } catch (AggregateException aggEx) { aggEx.Handle(HandleBatchExceptions); } var list = getListBucketsTask.Result; foreach (Bucket bucket in list.Buckets) { Console.Out.WriteLine(bucket.Name + " " + bucket.CreationDateDateTime); } var bucketExistTask = minio.BucketExistsAsync("mynewbucket"); Task.WaitAll(bucketExistTask); var found = bucketExistTask.Result; if (!found) { // Supply a new bucket name Task.WaitAll(minio.MakeBucketAsync("mynewbucket")); } Console.Out.WriteLine("bucket was " + found); Console.ReadLine(); }
public async Task <string> StoreFileAsync(UploadVm model, DateTimeOffset now) { var fileName = model.File.FileName; var folder = $"attachments/{now.Year}/{now.Month}/{now.Day}/"; var saveFileName = model.MD5 + Path.GetExtension(fileName); //attachments/2018/12/28/{id}.ext var objectName = folder + saveFileName; bool found = await _client.BucketExistsAsync(_minioOption.BucketName); if (!found) { await _client.MakeBucketAsync(_minioOption.BucketName); } using (var stream = model.File.OpenReadStream()) { await _client.PutObjectAsync(_minioOption.BucketName, objectName, stream, model.File.Length); } return(objectName); }
// Make a bucket public async static Task Run(MinioClient minio, string bucketName = "my-bucket-name", string loc = "us-east-1") { try { Console.WriteLine("Running example for API: MakeBucketAsync"); await minio.MakeBucketAsync( new MakeBucketArgs() .WithBucket(bucketName) .WithLocation(loc) ); Console.WriteLine($"Created bucket {bucketName}"); Console.WriteLine(); } catch (Exception e) { Console.WriteLine($"[Bucket] Exception: {e}"); } }
public async Task TestInvalidObjectNameError() { var badName = new string('A', 260); var bucketName = Guid.NewGuid().ToString("N"); var minio = new MinioClient() .WithEndpoint("play.min.io") .WithCredentials("Q3AM3UQ867SPQQA43P2F", "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG") .Build(); try { const int tryCount = 5; var args = new MakeBucketArgs() .WithBucket(bucketName); await minio.MakeBucketAsync(args); var ex = await Assert.ThrowsExceptionAsync <InvalidObjectNameException>( () => minio.StatObjectAsync(bucketName, badName)); for (int i = 0; i < tryCount && (ex.ServerResponse != null && ex.ServerResponse.StatusCode.Equals(HttpStatusCode.ServiceUnavailable)); ++i) { ex = await Assert.ThrowsExceptionAsync <InvalidObjectNameException>( () => minio.StatObjectAsync(bucketName, badName)); } Assert.AreEqual(ex.Response.Code, "InvalidObjectName"); ex = await Assert.ThrowsExceptionAsync <InvalidObjectNameException>( () => minio.GetObjectAsync(bucketName, badName, s => { })); Assert.AreEqual(ex.Response.Code, "InvalidObjectName"); } finally { var args = new RemoveBucketArgs() .WithBucket(bucketName); await minio.RemoveBucketAsync(args); } }
public async Task <UploadResponse> FileUploadCopy(List <TempFilesToDestination> content) { var bucketName = this.bucket; UploadResponse obj = new UploadResponse(); try { var minio = new MinioClient(this.endpoint, accessKey, accessSecret); // Make a bucket on the server, if not already present. bool found = await minio.BucketExistsAsync(bucketName); if (!found) { await minio.MakeBucketAsync(bucketName, this.location); } foreach (var item in content) { try { await minio.StatObjectAsync(bucketName, item.distObjectName); } catch (MinioException e) { await minio.CopyObjectAsync(bucketName, item.tempObjectName, bucketName, item.distObjectName); await minio.RemoveObjectAsync(bucketName, item.tempObjectName); } } obj.Message = "Uploaded Successfully."; obj.HasSucceed = true; } catch (MinioException e) { Console.WriteLine("File Upload Error: {0}", e.Message); obj.Message = "Uploaded failed with error " + e.message; obj.HasSucceed = false; obj.FileUrl = this.BaseUrl + bucketName + "/"; } return(obj); }
public void Init() { ESTraceLogger.Debug($"AWS_S3CacheProvider Init: Starting"); if (client == null) { lock (_lockconnections) { if (connections.ContainsKey(this.AWS_S3Servers.First())) { client = connections[this.AWS_S3Servers.First()]; } else { client = new MinioClient(this.AWS_S3Servers.First(), this.AccessKey, this.SecretKey, this.Region ); connections.Add(this.AWS_S3Servers.First(), client); bool found = client.BucketExistsAsync(this.Bucket).Result; if (!found) { ESTraceLogger.Debug($"AWS_S3CacheProvider Init: Bucket {this.AWS_S3Servers.First()} / {this.Bucket} doesn't exist. Creating new one"); try { client.MakeBucketAsync(this.Bucket).Wait(); } catch (Exception e) { ESTraceLogger.Fatal($"AWS_S3CacheProvider: Created db error {e.Message}", e); throw new ApplicationException($"Cannot created AWS_S3 {this.AWS_S3Servers.First()} / {this.Bucket}"); } } } ESTraceLogger.Debug($"AWS_S3CacheProvider Init: Bucket {this.AWS_S3Servers.First()} / {this.Bucket} is live."); cleaning.Elapsed += Cleaning_Elapsed; cleaning.Start(); } } }
static void Main(string[] args) { ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12; /// Note: s3 AccessKey and SecretKey needs to be added in App.config file /// See instructions in README.md on running examples for more information. var minio = new MinioClient("play.min.io:9000", "Q3AM3UQ867SPQQA43P2F", "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG").WithSSL(); var getListBucketsTask = minio.ListBucketsAsync(); try { Task.WaitAll(getListBucketsTask); // block while the task completes } catch (AggregateException aggEx) { aggEx.Handle(HandleBatchExceptions); } var list = getListBucketsTask.Result; foreach (Bucket bucket in list.Buckets) { Console.Out.WriteLine(bucket.Name + " " + bucket.CreationDateDateTime); } //Supply a new bucket name Task.WaitAll(minio.MakeBucketAsync("mynewbucket")); var bucketExistTask = minio.BucketExistsAsync("mynewbucket"); Task.WaitAll(bucketExistTask); var found = bucketExistTask.Result; Console.Out.WriteLine("bucket was " + found); Console.ReadLine(); }
public async Task <IActionResult> UploadFile(IFormFile file) { if (file is null) { return(BadRequest("Must upload a valid file!")); } var fileId = Guid.NewGuid().ToString(); var extension = Path.GetExtension(file.FileName); var fileName = $"{fileId}{extension}"; var filePath = Path.GetTempFileName(); _logger.LogInformation($"Temp file name: '{filePath}'."); try { await using var stream = System.IO.File.Create(filePath); await file.CopyToAsync(stream); _logger.LogInformation("File copied to stream."); if (!await _minioClient.BucketExistsAsync(BucketName)) { await _minioClient.MakeBucketAsync(BucketName); } _logger.LogInformation("Bucket exists/created, uploading file..."); stream.Seek(0, SeekOrigin.Begin); await _minioClient.PutObjectAsync(BucketName, fileName, stream, stream.Length, file.ContentType); } catch (Exception exception) { _logger.LogError(exception, exception.Message); throw; } return(Ok(new { FileName = fileName })); }
public async Task CreateAndListBuckets() { var minio = new MinioClient(Endpoint, AccessKey, SecretKey) /*.WithSSL()*/; var listBucketsResult = await minio.ListBucketsAsync(); for (var i = 0; i < 10; i++) { var bucketName = "bucket" + i; if (await minio.BucketExistsAsync(bucketName) == false) { await minio.MakeBucketAsync(bucketName); } } foreach (var bucket in listBucketsResult.Buckets) { Console.WriteLine(bucket.Name + " " + bucket.CreationDateDateTime); } }
// BUCKET OPERATIONS // true - bucket was created | false - bucket already exists public async Task <Boolean> CreateBucketIfExistAsync(String BucketName) { try { // Create bucket if it doesn't exist. bool found = await minio.BucketExistsAsync(BucketName); if (found) { return(false); } else { // Create bucket 'bucketname'. await minio.MakeBucketAsync(BucketName); return(true); } } catch (MinioException e) { throw; } }
public async Task <UploadResponse> FileUploadv2(Microsoft.AspNetCore.Http.IFormFile file) { var bucketName = this.bucket; UploadResponse obj = new UploadResponse(); try { var minio = new MinioClient(this.endpoint, accessKey, accessSecret); // Make a bucket on the server, if not already present. bool found = await minio.BucketExistsAsync(bucketName); if (!found) { await minio.MakeBucketAsync(bucketName, this.location); } var stream = file.OpenReadStream(); await minio.PutObjectAsync(bucketName, file.Name, stream, stream.Length); if (file.Length > 0) { obj.Message = "Uploaded Successfully."; obj.HasSucceed = true; obj.FileName = file.Name; obj.FileUrl = this.BaseUrl + bucketName + "/" + file.Name; } else { obj.Message = this.BaseUrl + bucketName + "/"; } } catch (MinioException e) { Console.WriteLine("File Upload Error: {0}", e.Message); obj.Message = "Uploaded failed with error " + e.message; obj.HasSucceed = false; obj.FileUrl = this.BaseUrl + bucketName + "/"; } return(obj); }
public async Task <bool> CreateBucketAsync(string bucketName) { if (string.IsNullOrEmpty(bucketName)) { throw new ArgumentNullException(nameof(bucketName)); } bool found = await BucketExistsAsync(bucketName); if (found) { throw new BucketExistException($"Bucket '{bucketName}' already exists."); } else { await _client.MakeBucketAsync( new MakeBucketArgs() .WithBucket(bucketName) .WithLocation(Options.Region)); return(true); } }
private async static Task MakeBucket_Test4(MinioClient minio) { Console.Out.WriteLine("Test 4 : MakeBucketAsync with region"); string bucketName = GetRandomName(length: 20) + ".withperiod"; try { await minio.MakeBucketAsync(bucketName, location : "us-west-2"); bool found = await minio.BucketExistsAsync(bucketName); Assert.IsTrue(found); if (found) { await minio.RemoveBucketAsync(bucketName); } } catch (MinioException) { Assert.Fail(); } }
public async Task <MinioUploadDto> Upload(IFormFile file) { MinioClient minioClient = new MinioClient(AppSettings.MinIO.EndPoint, AppSettings.MinIO.AccessKey, AppSettings.MinIO.SecretKey); bool isExist = await minioClient.BucketExistsAsync(AppSettings.MinIO.BucketName); if (!isExist) { minioClient.MakeBucketAsync(AppSettings.MinIO.BucketName); //minioClient.SetPolicyAsync(AppSettings.MinIO.BucketName, "*.*", PolicyType.WRITE_ONLY); } var fileName = file.Name; string objectName = $"{Clock.Now.ToString("yyyyMMdd")}/fileName"; minioClient.PutObjectAsync(AppSettings.MinIO.BucketName, objectName, fileName, file.ContentType); MinioUploadDto minioUploadDto = new MinioUploadDto { FileName = fileName, Url = $"{AppSettings.MinIO.EndPoint}/{AppSettings.MinIO.BucketName}/{objectName}", }; return(minioUploadDto); }
/// <summary> /// 20210310 保存 /// </summary> /// <param name="minio"></param> /// <param name="userBucketName"></param> /// <param name="uploadFilePath"></param> /// <param name="saveFileName"></param> /// <returns></returns> private static async Task Run(MinioClient minio, string userBucketName, string uploadFilePath, string saveFileName) { var bucketName = userBucketName; var location = "us-east-1"; var objectName = saveFileName; var filePath = uploadFilePath; var contentType = ContentTypeHelper.GetContentType(saveFileName.Substring(saveFileName.LastIndexOf('.') + 1)); var file = new FileInfo(uploadFilePath); try { var found = await minio.BucketExistsAsync(bucketName); if (!found) { await minio.MakeBucketAsync(bucketName, location); } _minioClient.SetTraceOn(new LogHelper());//我们在上传开始的时候,打开日志,通过日志抛出的块编号来计算出当前进度 ViewModelLocator.Instance.FileUploadViewModel.FileSize = file.Length; ViewModelLocator.Instance.FileUploadViewModel.TotalParts = file.Length / App.MinimumPartSize + 1;//计算出文件总块数 //上传文件 await minio.PutObjectAsync(bucketName, objectName, filePath, contentType); Debug.WriteLine("Successfully uploaded " + objectName); } catch (MinioException e) { App.NewNLog.Error($"File Upload Error: {e}"); Debug.WriteLine($"File Upload Error: {e.Message}"); } finally { _minioClient.SetTraceOff(); } }
public async Task <bool> Handle(UploadProfilePhotoCommand request, CancellationToken cancellationToken) { string bucketName = _configuration["MinioConfiguration:UserProfilePhotosBucketName"]; bool found = await _minioClient.BucketExistsAsync(bucketName); if (!found) { await _minioClient.MakeBucketAsync(bucketName, cancellationToken : cancellationToken); } var fileExtension = Path.GetExtension(request.FileName); string realFileName = $"{request.UserId.ToString()}{fileExtension}".ToLower(); var fileStream = GetStreamFromBytes(request.PhotoContent); await _minioClient.PutObjectAsync( bucketName : bucketName, objectName : realFileName, data : fileStream, size : fileStream.Length ); return(true); }
/// <summary> /// Task that uploads a file to a bucket /// </summary> /// <param name="minio"></param> /// <returns></returns> private static async Task Run(MinioClient minio) { // Make a new bucket called mymusic. var bucketName = "mymusic-folder"; //<==== change this var location = "us-east-1"; // Upload the zip file var objectName = "my-golden-oldies.mp3"; var filePath = "C:\\Users\\vagrant\\Downloads\\golden_oldies.mp3"; var contentType = "application/zip"; try { var bktExistArgs = new BucketExistsArgs() .WithBucket(bucketName); bool found = await minio.BucketExistsAsync(bktExistArgs); if (!found) { var mkBktArgs = new MakeBucketArgs() .WithBucket(bucketName) .WithLocation(location); await minio.MakeBucketAsync(mkBktArgs); } PutObjectArgs putObjectArgs = new PutObjectArgs() .WithBucket(bucketName) .WithObject(objectName) .WithFileName(filePath) .WithContentType(contentType); await minio.PutObjectAsync(putObjectArgs).ConfigureAwait(false); Console.WriteLine($"\nSuccessfully uploaded {objectName}\n"); } catch (Exception e) { Console.WriteLine(e); } }
public async Task <SaveImageResult> SaveImageByteAsync(SaveImageParam param) { string defaultLocation = "us-east-1"; try { bool isBucketExist = await _minio.BucketExistsAsync(param.BucketName); if (!isBucketExist) { await _minio.MakeBucketAsync(param.BucketName, defaultLocation); } param.ImageData.Position = 0; await _minio.PutObjectAsync( param.BucketName, param.ImageName, param.ImageData, param.ImageSize, param.ContentType, param.MetaData); return(new SaveImageResult() { BucketName = param.BucketName, ImageName = param.ImageName, Location = defaultLocation }); } catch (MinioException e) { //SentrySdk.CaptureException(e); throw; } }
/// <summary> /// 上传文件 /// </summary> /// <param name="filePath"></param> /// <param name="fileName"></param> /// <param name="bucketName"></param> /// <param name="location"></param> /// <returns></returns> public async Task <bool> FileUpload(string filePath, string fileName, string bucketName) { try { var contentType = "application/zip"; // Make a bucket on the server, if not already present. bool found = await minioClient.BucketExistsAsync(bucketName); if (!found) { await minioClient.MakeBucketAsync(bucketName); } // Upload a file to bucket. await minioClient.PutObjectAsync(bucketName, fileName, filePath, contentType); Console.WriteLine("Successfully uploaded " + fileName); return(true); } catch (MinioException ex) { throw ex; Console.WriteLine("File Upload Error: {0}", ex.Message); } }
/// <summary> /// Upload file to minio /// </summary> /// <param name="formFile"></param> /// <param name="bucketName"></param> /// <param name="fileName"></param> /// <returns></returns> public async Task <bool> UploadFile(IFormFile formFile, string bucketName, string fileName) { bool response = true; try { bool bucketFound = await _minioClient.BucketExistsAsync(bucketName); if (!bucketFound) { _minioClient.MakeBucketAsync(bucketName, "Tr-tr").Wait(); } using (Stream stream = formFile.OpenReadStream()) { await _minioClient.PutObjectAsync(bucketName, fileName, stream, stream.Length); } } catch (Exception ex) { Console.WriteLine(ex.Message); response = false; } return(response); }
private async static Task Run(MinioClient minio, IFormFile _request, string bucketName, string location, Guid guid, string fileType, string fileLocation) { if (!Directory.Exists(fileLocation)) { Directory.CreateDirectory(fileLocation); } string FilePath = ""; using (var fileStream = new FileStream(fileLocation + _request.FileName, FileMode.Create)) { await _request.CopyToAsync(fileStream); FilePath = fileStream.Name; } var objectName = ""; if (fileType == "audio") { //var fileExtension = _request.FileName.Split("."); objectName = guid.ToString(); } else if (fileType == "video") { objectName = guid.ToString(); } var filePath = FilePath; var contentType = ""; if (fileType == "audio") { contentType = _request.ContentType; } else if (fileType == "video") { contentType = _request.ContentType; } try { // Make a bucket on the server, if not already present. bool found = await minio.BucketExistsAsync(bucketName); if (!found) { await minio.MakeBucketAsync(bucketName, location); } // Upload a file to bucket. await minio.PutObjectAsync(bucketName, objectName, filePath, contentType); System.IO.File.Delete(filePath); Console.WriteLine("Successfully uploaded " + objectName); } catch (MinioException e) { logger.Error(e); Console.WriteLine("File Upload Error: {0}", e.Message); } }
private async Task <string> moveObject(string input, MinioClient minio) { var request = getTaskFromDb(input); if (request.ContainsKey("error")) { return(request.ToString()); } var bucket = request["params"]["bucket"].Value <string>(); var file = request["params"]["object"].Value <string>(); var newBucket = request["params"]["newBucket"].Value <string>(); bool found = await minio.BucketExistsAsync(newBucket); if (!found) { await minio.MakeBucketAsync(newBucket); } string result = string.Empty; minio.CopyObjectAsync(bucket, file, newBucket).ContinueWith((x) => { if (x.IsFaulted) { StringBuilder sb = new StringBuilder(); sb.AppendLine(x.Exception.Message); foreach (var e in x.Exception.InnerExceptions) { sb.AppendLine(e.Message); } result = sb.ToString(); } else { Console.WriteLine($"Object {file} copied to {newBucket} successfully"); var key = Guid.NewGuid().ToString(); var callJson = new JObject( new JProperty("_key", key), new JProperty("params", new JObject( new JProperty("bucket", bucket), new JProperty("object", file), new JProperty("topic", "augury")) )); writeTaskToDb(callJson); string callResponse = string.Empty; makeCallAsync("kafkawriter", key).ContinueWith(c => { if (x.IsFaulted) { callResponse = $"Error calling objectmover for {file}: {c.Exception.Message}"; } else { callResponse = c.Result; } Console.WriteLine($"{input}: {callResponse}"); }).Wait(); result = callResponse; } }) .Wait(); return(result); }
public bool MakeBucket(string bucketName) { _minioClient.MakeBucketAsync(bucketName).Wait(); return(true); }
public Task MakeBucketAsync(string bucketName, string location = "us-east-1", CancellationToken cancellationToken = default(CancellationToken)) { return(_client.MakeBucketAsync(bucketName, location, cancellationToken)); }
public async Task <IActionResult> FileUpload(FileUpload formFile) { // Perform an initial check to catch FileUpload class attribute violations. if (!ModelState.IsValid) { return(Json(new { status = "error", message = "The model is not correct" })); } //Check MIME if (formFile.CardImageUpload.ContentType.ToLower() != "image/png") { return(Json(new { status = "error", message = "The file mime must be image/png" })); } //Check if size is between 0 and 10MB if (formFile.CardImageUpload.Length == 0) { return(Json(new { status = "error", message = "Upload Failed. The selected file is empty." })); } else if (formFile.CardImageUpload.Length > 10485760) { return(Json(new { status = "error", message = "The selected file exceeds 10 MB." })); } //Generate Random Name //string ext = System.IO.Path.GetExtension(formFile.CardImageUpload.FileName); //Get the file extension string objectName = Guid.NewGuid() + ".png"; var filePath = System.IO.Path.GetTempFileName() + objectName; //Create Temp File with Random GUID using (var fileStream = new FileStream(filePath, FileMode.Create)) { await formFile.CardImageUpload.CopyToAsync(fileStream); } //Prepare S3 Upload var bucketName = "tcg-upload"; var location = "us-east-1"; var contentType = formFile.CardImageUpload.ContentType.ToLower(); try { // Make a bucket on the server, if not already present. bool found = await minio.BucketExistsAsync(bucketName); if (!found) { await minio.MakeBucketAsync(bucketName, location); } // Upload a file to bucket. await minio.PutObjectAsync(bucketName, objectName, filePath, contentType); Console.Out.WriteLine("Successfully uploaded " + objectName); return(Json(new { status = "Ok", message = "Successfully uploaded " + objectName, image = objectName })); } catch (MinioException e) { return(Json(new { status = "Error", message = "File Upload Error:" + e.Message })); } }
public async Task <IActionResult> UploadFiles(List <IFormFile> files) { var log = new List <ScanResult>(); foreach (var formFile in files) { if (formFile.Length > 0) { var extension = formFile.FileName.Contains('.') ? formFile.FileName.Substring(formFile.FileName.LastIndexOf('.'), formFile.FileName.Length - formFile.FileName.LastIndexOf('.')) : string.Empty; var file = new File { Name = $"{Guid.NewGuid()}{extension}", Alias = formFile.FileName, Region = "us-east-1", Bucket = BUCKET_NAME, ContentType = formFile.ContentType, Size = formFile.Length, Uploaded = DateTime.UtcNow, }; var ping = await _clam.PingAsync(); if (ping) { _logger.LogInformation("Successfully pinged the ClamAV server."); var result = await _clam.SendAndScanFileAsync(formFile.OpenReadStream()); file.ScanResult = result.Result.ToString(); file.Infected = result.Result == ClamScanResults.VirusDetected; file.Scanned = DateTime.UtcNow; if (result.InfectedFiles != null) { foreach (var infectedFile in result.InfectedFiles) { file.Viruses.Add(new Virus { Name = infectedFile.VirusName }); } } var metaData = new Dictionary <string, string> { { "av-status", result.Result.ToString() }, { "av-timestamp", DateTime.UtcNow.ToString() }, { "alias", file.Alias } }; try { var found = await _minio.BucketExistsAsync(BUCKET_NAME); if (!found) { await _minio.MakeBucketAsync(BUCKET_NAME); } await _minio.PutObjectAsync(BUCKET_NAME, file.Name, formFile.OpenReadStream(), formFile.Length, formFile.ContentType, metaData); await _context.Files.AddAsync(file); await _context.SaveChangesAsync(); } catch (MinioException e) { _logger.LogError($"File Upload Error: {e.Message}"); } var scanResult = new ScanResult() { FileName = formFile.FileName, Result = result.Result.ToString(), Message = result.InfectedFiles?.FirstOrDefault()?.VirusName, RawResult = result.RawResult }; log.Add(scanResult); } else { _logger.LogWarning("Wasn't able to connect to the ClamAV server."); } } } var model = new UploadFilesViewModel { Results = log }; return(View("UploadResults", model)); }