public override async Task <BackupResponse> Backup(Backup backup, BackupRequest request)
{
var bucket = $"backups-service-{backup.ServiceId}";
var service = new Service(backup.ServiceId);
var server = new Server(service.ServerId);
var fileSystemService = server.FileSystemService;
var combinePath = FileSystem.FixAbsoluteFilePath(
FileSystem.CombinePath(server.OperatingSystem, service.RootDirectory, request.Path,
Compress(backup, request)), server.OperatingSystem);
var fileSize = fileSystemService.GetFileSize(combinePath);
BackupManagerController.ThrowExceedQuota(backup, request, fileSize);
backup.FileSize = fileSize;
if (!await MinioClient.BucketExistsAsync(bucket))
{
await MinioClient.MakeBucketAsync(bucket, _region);
}
var contents = fileSystemService.ReadBinary(combinePath);
Stream stream = new MemoryStream(contents);
await MinioClient.PutObjectAsync(bucket, backup.ZipFullName, stream, stream.Length, "application/zip");
return(new BackupResponse(true));
}
public async Task <IActionResult> UploadFile()
{
//服务器区域
//var location = "us-east-1";
try
{
bool found = await minio.BucketExistsAsync(bucketName);
if (found)
{
//await minio.MakeBucketAsync(bucketName);
foreach (var file in HttpContext.Request.Form.Files)
{
Stream stream = file.OpenReadStream();
await minio.PutObjectAsync(bucketName,
file.FileName,
stream,
file.Length,
file.ContentType);
}
}
}
catch (MinioException e)
{
Console.WriteLine("File Upload Error: {0}", e.Message);
}
return(Json(new { Result = "ok" }));
}
protected virtual async Task CreateBucketIfNotExists()
{
if (!await _client.BucketExistsAsync(_bucketName))
{
await _client.MakeBucketAsync(_bucketName);
}
}
public async Task <IEnumerable <string> > Get()
{
if (!await _blobClient.BucketExistsAsync(bucketName))
{
await _blobClient.MakeBucketAsync(bucketName);
}
return(_blobClient.ListObjectsAsync(bucketName).Select(x => x.Key).ToEnumerable());
}
private async Task EnsureBucket()
{
bool found = await minio.BucketExistsAsync(bucketName);
if (!found)
{
await minio.MakeBucketAsync(bucketName);
}
}
public override async Task <bool> Backup(string fileName, byte[] contents, string contentType)
{
if (!await MinioClient.BucketExistsAsync(_bucketName))
{
await MinioClient.MakeBucketAsync(_bucketName, _region);
}
Stream stream = new MemoryStream(contents);
await MinioClient.PutObjectAsync(_bucketName, fileName, stream, stream.Length, contentType);
return(true);
}
public async Task <int> Upload(String encode, String name, String username)
{
var endpoint = "127.0.0.1:9000";
var accessKey = "VDX5QGGFWH9HFGCQXY42";
var secretKey = "FSDxipLeNUX7E8Y6ttsXVhaTyGe6mnlCHsP1xWKW";
var minio = new MinioClient(endpoint, accessKey, secretKey);
var bucketName = username.ToLower();
var location = "us-east-1";
var objectName = name;
var contentType = "application/octet-stream";
int mod4 = encode.Length % 4;
byte[] bs = Convert.FromBase64String(encode);
System.IO.MemoryStream filestream = new System.IO.MemoryStream(bs);
bool found = await minio.BucketExistsAsync(bucketName);
if (!found)
{
await minio.MakeBucketAsync(bucketName, location);
}
await minio.PutObjectAsync(bucketName, objectName, filestream, filestream.Length, contentType);
return(1);
}
public async Task <IList <MinioUploadDto> > Upload(ICollection <IFormFile> files)
{
IList <MinioUploadDto> minioUploadDtos = new List <MinioUploadDto>();
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);
}
foreach (var file in files)
{
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}",
};
minioUploadDtos.Add(minioUploadDto);
}
return(minioUploadDtos);
}
public async Task <string> UploadAsync(Stream data, string bucketName, string fileName)
{
if (string.IsNullOrEmpty(bucketName))
{
throw new MinioException("haven't specified bucket name");
}
if (string.IsNullOrEmpty(fileName))
{
fileName = Guid.NewGuid().ToString();
}
if (!await _client.BucketExistsAsync(bucketName))
{
await _client.MakeBucketAsync(bucketName);
await _client.SetPolicyAsync(bucketName, _config.GetPolicyJsonString(bucketName));
}
using (data)
{
await _client.PutObjectAsync(bucketName, fileName, data, data.Length);
return($"{bucketName}/{fileName}");
}
}
/// <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
{
bool found = await minio.BucketExistsAsync(bucketName);
if (!found)
{
await minio.MakeBucketAsync(bucketName, location);
}
await minio.PutObjectAsync(bucketName, objectName, filePath, contentType);
Console.WriteLine("Successfully uploaded " + objectName);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
/// <summary>
/// Task that uploads a file to a bucket
/// </summary>
/// <param name="minio"></param>
/// <returns></returns>
private async static 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 = "test.doc";
var filePath = "D:\\test.doc";
var contentType = "application/msword";
try
{
bool found = await minio.BucketExistsAsync(bucketName);
if (!found)
{
await minio.MakeBucketAsync(bucketName, location);
}
await minio.PutObjectAsync(bucketName, objectName, filePath, contentType);
Console.Out.WriteLine("Successfully uploaded " + objectName);
}
catch (Exception e)
{
Console.Out.WriteLine(e);
}
}
private void ThrowExceptionIfBucketDoesNotExist(string bucketName)
{
if (!m_client.BucketExistsAsync(bucketName).Await())
{
throw new FolderMissingException($"Bucket {bucketName} does not exist.");
}
}
private async static Task RemoveBucket_Test1(MinioClient minio)
{
Console.Out.WriteLine("Test: RemoveBucketAsync");
string bucketName = GetRandomName(length: 60);
await minio.MakeBucketAsync(bucketName);
bool found = await minio.BucketExistsAsync(bucketName);
Assert.IsTrue(found);
await minio.RemoveBucketAsync(bucketName);
found = await minio.BucketExistsAsync(bucketName);
Assert.IsFalse(found);
Console.Out.WriteLine("Test: RemoveBucketAsync succeeded");
}
private async static Task MakeBucket_Test3(MinioClient minio)
{
Console.Out.WriteLine("Test 3 : MakeBucketAsync with region");
string bucketName = GetRandomName(length: 60);
try
{
await minio.MakeBucketAsync(bucketName, location : "eu-central-1");
bool found = await minio.BucketExistsAsync(bucketName);
Assert.IsTrue(found);
if (found)
{
await minio.MakeBucketAsync(bucketName);
await minio.RemoveBucketAsync(bucketName);
}
}
catch (MinioException ex)
{
Assert.AreEqual <string>(ex.message, "Your previous request to create the named bucket succeeded and you already own it.");
}
Console.Out.WriteLine("Test 3 : MakeBucketAsync with region complete");
}
public async Task <IEnumerable <string> > EnumerateBucket(string bucket)
{
if (!await _client.BucketExistsAsync(bucket))
{
return(new string[0]);
}
var blobNames = new List <string>();
var observable = _client.ListObjectsAsync(bucket);
using (observable.Subscribe(item => blobNames.Add(item.Key)))
{
await observable;
return(blobNames.ToList());
}
}
public async Task <UploadFileViewModel> Handle(UploadFileDto request, CancellationToken cancellationToken)
{
var bucketExists = await _client.BucketExistsAsync(request.FileType, cancellationToken);
if (!bucketExists)
{
await _client.MakeBucketAsync(request.FileType, cancellationToken : cancellationToken);
}
var name = Guid.NewGuid().ToString();
var stream = request.File.OpenReadStream();
await _client.PutObjectAsync(request.FileType, name, stream, stream.Length, cancellationToken : cancellationToken);
var file = _mapper.Map <File>(request);
file.Name = name;
file.ContentType = request.File.ContentType;
file.Extension = Path.GetExtension(request.File.FileName);
// file.Extension = request.File.Headers.
await _context.AddAsync(file);
await _context.SaveChangesAsync();
return(new UploadFileViewModel {
Id = $"file.{request.FileType}.{name}.{file.Id}"
});
}
public async Task <string> UploadFile(string bucketName, IFormFile file)
{
string _rtn = "";
try
{
MinioClient minio = new MinioClient(con.minioHost, con.minioAccessKey, con.minioSecretKey);
BucketControl:
bool found = await minio.BucketExistsAsync(bucketName);
if (found)
{
string fileName = Guid.NewGuid().ToString();
string[] splittedName = file.FileName.Split('.');
fileName += "." + splittedName[1].ToString();
using (Stream stream = file.OpenReadStream())
{
await minio.PutObjectAsync(bucketName, fileName, stream, stream.Length);
_rtn = String.Format(@"http://{0}/{1}/{2}", con.remoteMinioHost, bucketName, fileName);
}
}
else
{
await minio.MakeBucketAsync(bucketName);
goto BucketControl;
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return(_rtn);
}
// File uploader task.
public async static Task Upload(
MinioClient minioClient,
string bucketName,
string objectName,
string filePath,
string location,
string contentType
)
{
try
{
// Make a bucket on the server, if not already present.
bool found = await minioClient.BucketExistsAsync(bucketName);
if (!found)
{
await minioClient.MakeBucketAsync(bucketName, location);
}
// Upload a file to bucket.
await minioClient.PutObjectAsync(bucketName, objectName, filePath, contentType);
Console.WriteLine("Successfully uploaded " + objectName);
}
catch (MinioException e)
{
Console.WriteLine("File Upload Error: {0}", e.Message);
}
}
public async Task PresignedGetObject()
{
// todo how to test this with mock client.
var client = new MinioClient(endpoint: "play.min.io", "Q3AM3UQ867SPQQA43P2F", "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG");
var bucket = "bucket";
var objectName = "object-name";
if (!await client.BucketExistsAsync(bucket))
{
await client.MakeBucketAsync(bucket);
}
if (!await this.ObjectExistsAsync(client, bucket, objectName))
{
var helloData = Encoding.UTF8.GetBytes("hello world");
var helloStream = new MemoryStream();
helloStream.Write(helloData);
helloStream.Seek(0, SeekOrigin.Begin);
await client.PutObjectAsync(bucket, objectName, helloStream, helloData.Length);
}
var signedUrl = await client.PresignedGetObjectAsync(bucket, objectName, 3600, null, _requestDate);
Assert.AreEqual(
"http://play.min.io/bucket/object-name?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=Q3AM3UQ867SPQQA43P2F%2F20200501%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20200501T154533Z&X-Amz-Expires=3600&X-Amz-SignedHeaders=host&X-Amz-Signature=d4202da690618f77142d6f0557c97839f0773b2c718082e745cd9b199aa6b28f",
signedUrl);
}
private async Task MakeBucketIfNotExists(string bucketName)
{
if (!await _client.BucketExistsAsync(bucketName))
{
await _client.MakeBucketAsync(bucketName);
}
}
public async Task PresignedGetObjectWithHeaders()
{
// todo how to test this with mock client.
var client = new MinioClient(endpoint: "play.min.io", "Q3AM3UQ867SPQQA43P2F", "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG");
var bucket = "bucket";
var objectName = "object-name";
Dictionary <string, string> reqParams = new Dictionary <string, string>
{
{ "Response-Content-Disposition", "attachment; filename=\"filename.jpg\"" },
};
if (!await client.BucketExistsAsync(bucket))
{
await client.MakeBucketAsync(bucket);
}
if (!await this.ObjectExistsAsync(client, bucket, objectName))
{
var helloData = Encoding.UTF8.GetBytes("hello world");
var helloStream = new MemoryStream();
helloStream.Write(helloData);
await client.PutObjectAsync(bucket, objectName, helloStream, helloData.Length);
}
var signedUrl = await client.PresignedGetObjectAsync(bucket, objectName, 3600, reqParams, _requestDate);
Assert.AreEqual(
"http://play.min.io/bucket/object-name?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=Q3AM3UQ867SPQQA43P2F%2F20200501%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20200501T154533Z&X-Amz-Expires=3600&X-Amz-SignedHeaders=host&response-content-disposition=attachment%3B%20filename%3D%22filename.jpg%22&X-Amz-Signature=de66f04dd4ac35838b9e83d669f7b5a70b452c6468e2b4a9e9c29f42e7fa102d",
signedUrl);
}
public async Task <UploadResponse> FileUpload(byte[] imageBytes, string fileName)
{
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);
}
using (var stream = new MemoryStream(imageBytes))
{
// Upload a file to bucket.
await minio.PutObjectAsync(bucketName, fileName, stream, stream.Length);
}
obj.Message = "Uploded Successfully.";
obj.HasSucceed = true;
obj.FileName = fileName;
obj.FileUrl = this.BaseUrl + bucketName + "/" + fileName;
}
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 TestRetryPolicyOnSuccess()
{
var client = new MinioClient()
.WithEndpoint("play.min.io")
.WithCredentials("Q3AM3UQ867SPQQA43P2F",
"zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG")
.WithSSL()
.Build();
var invokeCount = 0;
client.WithRetryPolicy(
async callback =>
{
invokeCount++;
return(await callback());
});
var bktArgs = new BucketExistsArgs()
.WithBucket(Guid.NewGuid().ToString());
var result = await client.BucketExistsAsync(bktArgs);
Assert.IsFalse(result);
Assert.AreEqual(invokeCount, 1);
}
protected virtual async Task CreateBucketIfNotExists(MinioClient client, string containerName)
{
if (!await client.BucketExistsAsync(containerName))
{
await client.MakeBucketAsync(containerName);
}
}
private static async Task Run(MinioClient minio_client, string bucketName, string objectName, string filePath)
{
string self_bucketName = bucketName;
string location = "us-east-1";
string self_objectName = objectName;
string contentType = "application/text";
string self_filePath = filePath;
try
{
bool found = await minio_client.BucketExistsAsync(bucketName);
if (!found)
{
await minio_client.MakeBucketAsync(bucketName, location);
}
await minio_client.PutObjectAsync(self_bucketName, self_objectName, self_filePath, contentType);
Console.WriteLine("Successfully Upload: {0}", objectName);
}
catch (MinioException Minio_Error)
{
Console.WriteLine("Upload Error: {0}", Minio_Error.Message);
}
}
private async static Task Run(MinioClient minio)
{
// Make a new bucket called mymusic.
var bucketName = "ai-medical1"; //<==== change this
//var location = "172.16.131.38:9003/minio/login";
// Upload the zip file
var objectName = "11122test.doc";
var filePath = "D:\\HE_20180612214954.doc";
var contentType = "application/msword";
//var endpoint = "172.16.131.38:9003";
try
{
bool found = await minio.BucketExistsAsync(bucketName);
if (!found)
{
await minio.MakeBucketAsync(bucketName);
}
await minio.PutObjectAsync(bucketName, objectName, filePath, contentType);
Console.Out.WriteLine("Successfully uploaded " + objectName);
}
catch (Exception e)
{
Console.Out.WriteLine(e);
}
}
// File uploader task.
private async static Task Run(MinioClient minio)
{
var bucketName = "vivek";
var location = "us-east-1";
var objectName = "example.pdf";
var filePath = "C:\\Users\\user\\.p2\\Desktop\\Outgoing\\example.pdf";
var contentType = "application/pdf";
Console.WriteLine("Step:1 -- We have example.pdf file in Outgoing folder");
try
{
// Make a bucket on the server, if not already present.
bool found = await minio.BucketExistsAsync(bucketName);
if (!found)
{
Console.WriteLine("Step:2 -- Folder is not found, So we created the folder for you !");
await minio.MakeBucketAsync(bucketName, location);
}
Console.WriteLine("Step:3 -- Upload a file to bucket");
await minio.PutObjectAsync(bucketName, objectName, filePath, contentType);
Console.WriteLine("Successfully uploaded " + objectName);
var url = "http://" + "play.min.io/" + "minio/" + bucketName + "/";
//var uploadPath = "http://play.min.io/minio/vivek/";
Console.WriteLine("Your file saved at location :-" + url);
}
catch (MinioException e)
{
Console.WriteLine("File Upload Error: {0}", e.Message);
}
}
private async static Task Setup_Test(MinioClient minio, string bucketName)
{
await minio.MakeBucketAsync(bucketName);
bool found = await minio.BucketExistsAsync(bucketName);
Assert.IsTrue(found);
}
public static async Task <MinioBucketStorage> GetOrCreateBucket(MinioClient mc, string bucketName)
{
if (!await mc.BucketExistsAsync(bucketName))
{
await mc.MakeBucketAsync(bucketName);
}
return(new MinioBucketStorage(mc, bucketName));
}
public async Task TestNoConnectionError()
{
// invalid uri
var minio = new MinioClient("localhost:12121");
var ex = await Assert.ThrowsExceptionAsync <ConnectionException>(() => minio.BucketExistsAsync("test"));
Assert.IsNotNull(ex.ServerResponse);
}
